diff --git a/.gitignore b/.gitignore index 7d44f7067da5..857f9b9dfec5 100644 --- a/.gitignore +++ b/.gitignore @@ -85,3 +85,9 @@ pythonenv* # tmp output from tests *.exec1 *.out1 + +# Local-environment-specific scripts (carry SSH hostnames, IPs, usernames +# for a particular dev machine + Jetson setup). Each developer has their +# own version of these. +scripts/correctness/run_jetson.sh +scripts/correctness/logs/ diff --git a/BLAS_Implementation_Plan.md b/BLAS_Implementation_Plan.md new file mode 100644 index 000000000000..c56787ea5b09 --- /dev/null +++ b/BLAS_Implementation_Plan.md @@ -0,0 +1,196 @@ +# BLAS Primitives Implementation and Raising Plan + +## Overview +This document outlines the action plan for implementing BLAS primitives in C and raising them to MLIR using the Polygeist pipeline. The goal is to create a comprehensive library of BLAS operations that can be automatically optimized and scheduled. + +## Target BLAS Primitives + +### Level 1 BLAS (Vector-Vector Operations) +- **DOT**: `sum(x[i] * y[i])` - Dot product of two vectors +- **SCAL**: `x *= alpha` - Scale vector by scalar +- **COPY**: `y = x` - Copy vector +- **AXPY**: `y = alpha * x + y` - Scaled vector addition + +### Level 2 BLAS (Matrix-Vector Operations) +- **GEMV**: `y = alpha * A * x + beta * y` - Matrix-vector multiply +- **GER**: `A = alpha * x * y^T + A` - Outer product (rank-1 update) + +### Level 3 BLAS (Matrix-Matrix Operations) +- **GEMM**: `C = alpha * A * B + beta * C` - Matrix-matrix multiply + +### Matrix Utility Operations +- **LACPY**: Copy matrix with optional transposition +- **LASCL**: `A *= alpha` - Scale matrix by scalar + +## Naming Convention +Following standard BLAS naming: `[prefix][type][operation]` +- **Prefix**: `""` (none), `"cublas"`, `"cblas_"` +- **Type**: `s` (float), `d` (double), `c` (complex float), `z` (complex double) +- **Operation**: BLAS function name + +Examples: +- `dgemv` - Double precision GEMV +- `sgemm` - Single precision GEMM +- `cublasDgemv` - CUDA double precision GEMV + +## Action Items + +### Phase 1: C Implementation (Foundation) +- [ ] **1.1** Create basic C implementations for all primitives + - [ ] Implement with proper LDA/stride support + - [ ] Include alpha/beta scaling parameters + - [ ] Add comprehensive error checking + - [ ] Create both simple and optimized versions + +- [ ] **1.2** Create test harnesses + - [ ] Unit tests for each primitive + - [ ] Performance benchmarks + - [ ] Verification against reference implementations + - [ ] Edge case testing (zero dimensions, negative strides) + +- [ ] **1.3** File structure organization + ``` + blas/ + ├── src/ + │ ├── level1/ # DOT, SCAL, COPY, AXPY + │ ├── level2/ # GEMV, GER + │ ├── level3/ # GEMM + │ └── utils/ # LACPY, LASCL + ├── include/ + │ └── blas.h # Header with all declarations + ├── tests/ + │ ├── test_level1.c + │ ├── test_level2.c + │ └── test_level3.c + └── simple/ # Minimal versions for Polygeist + ├── simple_gemm.c + ├── simple_gemv.c + └── ... + ``` + +### Phase 2: Polygeist Pipeline Integration +- [ ] **2.1** Test each primitive with cgeist + - [ ] Convert C to initial MLIR: `cgeist primitive.c --function=* --resource-dir=/usr/lib/clang/14 --raise-scf-to-affine -fPIC -S -g -c -o primitive.mlir` + - [ ] Verify successful parsing and basic structure + - [ ] Document any conversion issues + +- [ ] **2.2** Apply affine-to-linalg pipeline + - [ ] Run: `polygeist-opt --affine-parallelize --raise-affine-to-linalg-pipeline primitive.mlir -o primitive_linalg.mlir` + - [ ] Verify linalg operations are generated correctly + - [ ] Check for proper loop nest structure + +- [ ] **2.3** Apply debufferization + - [ ] Run: `polygeist-opt --linalg-debufferize primitive_linalg.mlir -o primitive_debufferized.mlir` + - [ ] Ensure tensor operations are created properly + - [ ] Verify memory access patterns + +- [ ] **2.4** Apply kernel extraction + - [ ] Run: `polygeist-opt primitive_debufferized.mlir --linalg-to-kernel="kernel-library-path=/home/arjaiswal/Polygeist/generic_solver/kernel_library.mlir"` + - [ ] Verify kernel definitions are generated + - [ ] Check integration with existing kernel library + +### Phase 3: Kernel Library Integration +- [ ] **3.1** Update kernel library + - [ ] Add all BLAS primitive kernels to `kernel_library.mlir` + - [ ] Ensure consistent naming and interfaces + - [ ] Add metadata for scheduler integration + +- [ ] **3.2** Create automation scripts + - [ ] Script to process all BLAS primitives through pipeline + - [ ] Batch processing with error handling + - [ ] Output validation and reporting + +- [ ] **3.3** Integration testing + - [ ] Test composite operations using multiple primitives + - [ ] Verify scheduler can handle BLAS operations + - [ ] Performance validation against reference implementations + +### Phase 4: Advanced Features +- [ ] **4.1** Multiple precision support + - [ ] Implement float, double, complex variants + - [ ] Template-based approach for code reuse + - [ ] Type-specific optimizations + +- [ ] **4.2** GPU backend support + - [ ] CUDA implementations (`cublas*` variants) + - [ ] ROCm implementations + - [ ] Backend selection logic + +- [ ] **4.3** Optimization variants + - [ ] Blocked implementations for cache efficiency + - [ ] Vectorized versions + - [ ] Thread-parallel versions + +### Phase 5: Scheduler Integration +- [ ] **5.1** Cost model development + - [ ] Performance characterization of each primitive + - [ ] Memory access pattern analysis + - [ ] Scheduling heuristics + +- [ ] **5.2** Composition analysis + - [ ] Identify common BLAS operation patterns + - [ ] Fusion opportunities (e.g., GEMV + AXPY) + - [ ] Memory reuse optimization + +- [ ] **5.3** End-to-end validation + - [ ] Complex linear algebra algorithms + - [ ] Performance comparison with optimized libraries + - [ ] Correctness verification + +## Implementation Priority + +### High Priority (Core Operations) +1. **GEMM** - Most computationally intensive, widely used +2. **GEMV** - Foundation for many algorithms +3. **DOT** - Simple but fundamental +4. **AXPY** - Common in iterative methods + +### Medium Priority (Supporting Operations) +5. **SCAL** - Simple scaling operation +6. **COPY** - Basic data movement +7. **GER** - Rank-1 updates + +### Lower Priority (Utility Operations) +8. **LACPY** - Matrix copying +9. **LASCL** - Matrix scaling + +## File Naming Convention +- C implementations: `[type][operation].c` (e.g., `dgemm.c`, `sgemv.c`) +- Simple versions: `simple_[operation].c` (e.g., `simple_gemm.c`) +- MLIR outputs: `[operation]_[stage].mlir` (e.g., `gemm_linalg.mlir`) + +## Testing Strategy +- **Unit Tests**: Each primitive tested independently +- **Integration Tests**: Multiple primitives working together +- **Performance Tests**: Comparison with reference implementations +- **Pipeline Tests**: Full Polygeist pipeline for each primitive +- **Regression Tests**: Ensure changes don't break existing functionality + +## Success Criteria +- [ ] All primitives successfully convert through Polygeist pipeline +- [ ] Generated kernels integrate with existing kernel library +- [ ] Performance within 80% of reference implementations +- [ ] Scheduler can effectively utilize BLAS operations +- [ ] Documentation and examples complete + +## Dependencies +- Polygeist toolchain (cgeist, polygeist-opt) +- Kernel library infrastructure +- Testing framework +- Reference BLAS implementation for validation + +## Timeline Estimate +- **Phase 1**: 2-3 weeks (C implementations and tests) +- **Phase 2**: 2-3 weeks (Pipeline integration) +- **Phase 3**: 1-2 weeks (Kernel library integration) +- **Phase 4**: 3-4 weeks (Advanced features) +- **Phase 5**: 2-3 weeks (Scheduler integration) + +**Total**: ~10-15 weeks for complete implementation + +## Notes +- Start with simple, correct implementations before optimizing +- Maintain compatibility with standard BLAS interfaces +- Document any limitations or assumptions +- Consider memory alignment and padding requirements +- Plan for both CPU and GPU backends from the beginning diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 000000000000..a6983bf63e86 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,67 @@ +# Polygeist - Claude Instructions + +## Environment Setup + +Source this before running any commands: +```bash +export POLYGEIST_ROOT=/path/to/Polygeist +source "$POLYGEIST_ROOT/envsetup.sh" +``` +This adds `build/bin/` to PATH, making `cgeist` and `polygeist-opt` available. + +## Build + +Only `build_polygeist.sh` is needed (LLVM/MLIR/Clang are pre-built in `llvm-project/build`). + +To rebuild after making changes to any pass: +```bash +cd "$POLYGEIST_ROOT/build" && ninja +``` + +## Raising Pipeline (C → Linalg) + +```bash +# Step 1: C to affine MLIR +cgeist --function=* --resource-dir=/usr/lib/clang/14 --raise-scf-to-affine -fPIC -S -g -c -o output.mlir + +# Step 2: Affine → Linalg (memref form) +polygeist-opt --select-func="func-name=" --remove-iter-args --affine-parallelize --raise-affine-to-linalg-pipeline -o + +# Step 3: Debufferize (memref linalg → tensor linalg) +polygeist-opt --linalg-debufferize -o + +# Step 4: Kernel extraction +polygeist-opt --linalg-to-kernel="kernel-library-path=$POLYGEIST_ROOT/generic_solver/kernel_library.mlir" +``` + +## Key Source Files + +- `lib/polygeist/Passes/RaiseToLinalg.cpp` — raises `affine.for` loops to `linalg.generic`, creates `polygeist.submap` for strided accesses +- `lib/polygeist/Passes/LinalgDebufferize.cpp` — converts memref-based linalg to tensor-based SSA form +- `include/polygeist/PolygeistOps.td` — defines `polygeist.submap` and `polygeist.submapInverse` + +## NVIDIA gated-distribution SDKs — point, don't copy + +The directory `$PVASOL_ROOT` is the source tree for the PVA +Solutions SDK. The PVA Solutions public `.deb` packages ship binaries only +(`libpva_operator.so`, `libnvcv_types.so`, allowlist file) — *no headers*. +Headers exist only inside the source tree, which NVIDIA distributes to +approved developers through `developer.nvidia.com/embedded/pva`. The headers +are therefore "behind a developer-program gate," not "secret internal-only"; +they're the same files any approved external developer would have. + +*Rule for using these headers in Polygeist:* + +- *Build-time include path is fine.* Add `-I$PVASOL_ROOT/public/src/operator/include` + (and the same pattern for NVCV / cuPVA / CV-CUDA headers under `public/3rdparty/`) + to the cross-compile flags in our build scripts. +- *Never copy headers into the Polygeist tree.* No `cp` / `git add` of any + `.h` / `.hpp` / `.cpp` / `.c` from `$PVASOL_ROOT` into + `$POLYGEIST_ROOT`. The Polygeist repo only ever references those + paths symbolically. +- *Polygeist source code may `#include "OpConv2d.h"` etc.* — the include is + resolved through the `-I` flag at build time, just like cuDNN's `cudnn.h`. +- *Anyone cloning Polygeist without PVA Solutions access gets a clean build + failure* — same as the cuDNN dependency on the cross-compile path today. +- *Same policy applies* to any other gated-distribution NVIDIA SDK source + tree on this VM (cuPVA SDK, internal NVCV builds, etc.). diff --git a/LINALG_DEBUFFERIZE_ALGORITHM.md b/LINALG_DEBUFFERIZE_ALGORITHM.md new file mode 100644 index 000000000000..f4e3bf7acd51 --- /dev/null +++ b/LINALG_DEBUFFERIZE_ALGORITHM.md @@ -0,0 +1,1395 @@ +# LinalgDebufferize Pass - Algorithm Documentation + +**File:** `lib/polygeist/Passes/LinalgDebufferize.cpp` +**Author:** Polygeist Team +**Last Updated:** October 17, 2025 + +--- + +## Table of Contents + +1. [Overview](#overview) +2. [Purpose and Goals](#purpose-and-goals) +3. [High-Level Transformation](#high-level-transformation) +4. [Algorithm Flowchart](#algorithm-flowchart) +5. [Detailed Algorithm](#detailed-algorithm) +6. [Key Data Structures](#key-data-structures) +7. [Helper Functions](#helper-functions) +8. [Region Propagation](#region-propagation) +9. [Example Transformations](#example-transformations) +10. [Current Limitations](#current-limitations) +11. [Future Work](#future-work) + +--- + +## Overview + +The `LinalgDebufferize` pass transforms **memref-based** Linalg operations into **tensor-based** operations. This enables: + +- **Fusion opportunities**: Tensor operations can be fused more easily +- **High-level optimizations**: Polyhedral transformations, tiling, vectorization +- **Explicit data flow**: SSA form makes dependencies clear +- **Functional semantics**: Easier to reason about and optimize + +### Pattern Structure + +The pass uses **greedy pattern rewriting** with two main patterns: + +1. **`LinalgDebufferization`**: Main transformation pattern (matches `func::FuncOp`) +2. **`debufferizationAllocaRemoval`**: Cleanup pattern for dead allocations + +--- + +## Purpose and Goals + +### Input: Memref-based Linalg +```mlir +func.func @example(%A: memref<10xf32>, %B: memref<10xf32>) { + %alloca = memref.alloca() : memref<10xf32> + linalg.generic ins(%A : memref<10xf32>) + outs(%alloca : memref<10xf32>) { + ^bb0(%a: f32, %out: f32): + %c = arith.mulf %a, %a : f32 + linalg.yield %c : f32 + } + linalg.generic ins(%alloca : memref<10xf32>) + outs(%B : memref<10xf32>) { + ^bb0(%a: f32, %out: f32): + %c = arith.addf %a, %a : f32 + linalg.yield %c : f32 + } + return +} +``` + +### Output: Tensor-based Linalg +```mlir +func.func @example(%A: memref<10xf32>, %B: memref<10xf32>) { + %A_tensor = bufferization.to_tensor %A : memref<10xf32> + + %init1 = tensor.empty() : tensor<10xf32> + %result1 = linalg.generic ins(%A_tensor : tensor<10xf32>) + outs(%init1 : tensor<10xf32>) -> tensor<10xf32> { + ^bb0(%a: f32, %out: f32): + %c = arith.mulf %a, %a : f32 + linalg.yield %c : f32 + } + + %init2 = tensor.empty() : tensor<10xf32> + %result2 = linalg.generic ins(%result1 : tensor<10xf32>) + outs(%init2 : tensor<10xf32>) -> tensor<10xf32> { + ^bb0(%a: f32, %out: f32): + %c = arith.addf %a, %a : f32 + linalg.yield %c : f32 + } + + %B_memref = bufferization.to_memref %result2 : memref<10xf32> + memref.copy %B_memref, %B : memref<10xf32> to memref<10xf32> + return +} +``` + +**Key Differences:** +- Memref operations are **in-place** (side effects) +- Tensor operations are **functional** (return new values) +- Tensor form enables **fusion** (subsequent passes can merge the two generics) + +--- + +## High-Level Transformation + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ LinalgDebufferize Pass │ +└─────────────────────────────────────────────────────────────────┘ + │ + ▼ + ┌─────────────────────────────────────────┐ + │ Identify Memref Roots to Debufferize │ + │ • memref.alloca operations │ + │ • memref.alloc operations │ + │ • Function arguments (memref type) │ + └─────────────────────────────────────────┘ + │ + ▼ + ┌─────────────────────────────────────────┐ + │ For Each Memref Root: │ + │ handleMemref(root) │ + └─────────────────────────────────────────┘ + │ + ▼ + ┌─────────────────────────────────────────┐ + │ 1. Validate (type, aliasing) │ + │ 2. Create to_tensor operation │ + │ 3. Sort users by execution order │ + │ 4. Transform each user │ + │ 5. Convert back to memref │ + └─────────────────────────────────────────┘ + │ + ▼ + ┌─────────────────────────────────────────┐ + │ Cleanup: Remove Dead Allocations │ + │ debufferizationAllocaRemoval │ + └─────────────────────────────────────────┘ +``` + +--- + +## Algorithm Flowchart + +### Main Algorithm: `matchAndRewrite(func::FuncOp)` + +``` + START + │ + ▼ + ┌──────────────────────────┐ + │ Collect Memref Roots: │ + │ • AllocaOps │ + │ • AllocOps │ + │ • Function Arguments │ + └──────────────────────────┘ + │ + ▼ + ┌──────────────────────────┐ + │ For each root: │ + │ handleMemref(root) ───┼──┐ + └──────────────────────────┘ │ + │ │ + ▼ │ + ┌─────────────────┐ │ + │ Any Success? │ │ + └─────────────────┘ │ + │ │ │ + Yes No │ + │ │ │ + ▼ ▼ │ + SUCCESS FAILURE │ + │ + ┌───────────────┘ + │ + ▼ + ┌─────────────────────────────────────────┐ + │ handleMemref(memVal) │ + └─────────────────────────────────────────┘ + │ + ▼ + ┌─────────────────────────────────────────┐ + │ Validation: │ + │ ✓ Is MemRefType? │ + │ ✓ Check aliasing (noalias preferred) │ + │ ✓ Not already debufferized? │ + └─────────────────────────────────────────┘ + │ + ┌─────┴─────┐ + │ │ + Valid Invalid + │ │ + ▼ ▼ + ┌───────────────┐ FAILURE + │ to_tensor │ + │ currentTensor│ + └───────────────┘ + │ + ▼ + ┌─────────────────────────────────────────┐ + │ sortedUsers = getSortedUsers(memVal) │ + │ (Order by program execution) │ + └─────────────────────────────────────────┘ + │ + ▼ + ┌─────────────────────────────────────────┐ + │ For each user in sortedUsers: │ + └─────────────────────────────────────────┘ + │ + ▼ + ┌─────────────────────────────────────────┐ + │ Is currentTensor in right scope? │ + │ (Check common ancestor region) │ + └─────────────────────────────────────────┘ + │ + ┌─────┴─────┐ + │ │ + No Yes + │ │ + ▼ │ + ┌──────────────────┐ │ + │ Propagate Value │ │ + │ Through Regions │ │ + │ • scf.for │ │ + │ • scf.if │ │ + └──────────────────┘ │ + │ │ + └─────┬─────┘ + │ + ▼ + ┌─────────────────────────────────────────┐ + │ What type of user? │ + └─────────────────────────────────────────┘ + │ + ┌───────────┼───────────┐ + │ │ │ + ▼ ▼ ▼ + linalg.generic memref. Other + subview (SKIP!) + │ │ + │ │ + ▼ ▼ + Transform Convert to + to Tensor extract_slice + │ │ + └─────┬─────┘ + │ + ▼ + ┌──────────────────────┐ + │ Update currentTensor │ + │ (to result/output) │ + └──────────────────────┘ + │ + ▼ + ┌──────────────────────┐ + │ All users done? │ + └──────────────────────┘ + │ + ┌─────┴─────┐ + │ │ + No Yes + │ │ + │ ▼ + │ ┌──────────────────────┐ + │ │ Final propagation │ + │ │ to outer scope │ + │ └──────────────────────┘ + │ │ + │ ▼ + │ ┌──────────────────────┐ + │ │ Was tensor changed? │ + │ └──────────────────────┘ + │ │ + │ ┌─────┴─────┐ + │ │ │ + │ Yes No + │ │ │ + │ ▼ │ + │ to_memref │ + │ memref.copy │ + │ │ │ + │ └─────┬─────┘ + │ │ + └───────────┤ + ▼ + SUCCESS +``` + +--- + +## Detailed Algorithm + +### Phase 1: Memref Root Collection + +```cpp +void matchAndRewrite(func::FuncOp funcOp, PatternRewriter &rewriter) { + SmallVector listOfAllocaOps; + SmallVector listOfAllocOps; + + // Collect all stack allocations + funcOp.walk([&](memref::AllocaOp alloca) { + listOfAllocaOps.push_back(alloca); + }); + + // Collect all heap allocations + funcOp.walk([&](memref::AllocOp alloc) { + listOfAllocOps.push_back(alloc); + }); + + // Process each root + for (auto alloca : listOfAllocaOps) { + anySuccess |= succeeded(handleMemref(alloca)); + } + + for (auto alloc : listOfAllocOps) { + anySuccess |= succeeded(handleMemref(alloc)); + } + + // Process function arguments + for (auto arg : funcOp.getArguments()) { + anySuccess |= succeeded(handleMemref(arg)); + } +} +``` + +**Why these three types?** +- They represent **independent memory objects** +- No aliasing concerns (or marked as noalias) +- Safe to transform to tensors + +--- + +### Phase 2: handleMemref - Core Transformation + +#### Step 1: Validation + +```cpp +LogicalResult handleMemref(Value memVal) { + // 1. Type check + if (!memVal.getType().isa()) + return failure(); + + // 2. Aliasing analysis + bool isNoalias = false; + if (auto allocaOp = memVal.getDefiningOp()) + isNoalias = true; // Stack allocations are local + else if (auto ba = dyn_cast(memVal)) + isNoalias = checkNoaliasAttr(ba); + + // 3. Check if already debufferized + auto sortedUsers = getSortedUsers(memVal); + if (!sortedUsers.empty() && isa(sortedUsers[0])) + return failure(); // Already in tensor form +``` + +#### Step 2: Create Initial Tensor + +```cpp + // Convert memref to tensor + MemRefType memrefType = getMemRefType(memVal); + auto tensorType = RankedTensorType::get( + memrefType.getShape(), + memrefType.getElementType()); + + auto toTensorOp = rewriter.create( + memVal.getLoc(), tensorType, memVal); + + Value currentTensor = toTensorOp; +``` + +**Transformation:** +```mlir +%memref = memref.alloca() : memref<10xf32> +// Becomes: +%memref = memref.alloca() : memref<10xf32> +%tensor = bufferization.to_tensor %memref : memref<10xf32> +``` + +#### Step 3: Sort Users + +```cpp + auto sortedUsers = getSortedUsers(memVal); + std::vector expandedUserList(sortedUsers); +``` + +**Critical:** Users must be processed in **program execution order** to maintain correctness. + +#### Step 4: Process Each User + +```cpp + llvm::DenseMap opResultMap; + + for (auto user : sortedUsers) { + // === SCOPE MANAGEMENT === + // Find common ancestor region + auto commonRegion = findCommonAncestorRegion( + currentTensor.getDefiningOp(), user); + + // Collect regions to propagate through + SmallVector regions; + for (Region* r = currentTensor.getParentRegion(); + r != commonRegion; + r = r->getParentOp()->getParentRegion()) { + regions.push_back(r); + } + + // Propagate value if needed + if (!regions.empty()) { + propagateValueThroughRegion(currentTensor, regions, + expandedUserList, opResultMap, rewriter); + } +``` + +**Why is this needed?** + +Example where propagation is required: +```mlir +%tensor = ... // Outer scope +scf.for %i = 0 to 10 { + linalg.generic outs(%tensor) { ... } // Inner scope - needs propagation! +} +``` + +The tensor is defined in outer scope but used in inner scope. We need to: +1. Add it as an `iter_arg` to the loop +2. Update uses inside to reference the block argument +3. Yield it at the end + +--- + +### Phase 3: User Type Handling + +#### Case A: `linalg.generic` Operations + +```cpp + if (auto genericOp = dyn_cast(user)) { + // Replace memref operands with tensor operands + SmallVector newInputs; + for (auto input : genericOp.getInputs()) { + newInputs.push_back(input == memVal ? currentTensor : input); + } + + SmallVector newOutputs; + SmallVector resultTypes; + int newCurrentTensorIndex = -1; + + for (auto output : genericOp.getOutputs()) { + newOutputs.push_back(output == memVal ? currentTensor : output); + resultTypes.push_back(output == memVal ? currentTensor.getType() + : output.getType()); + if (output == memVal) { + newCurrentTensorIndex = index; // Track our tensor + } + index++; + } + + // Create new tensor-based linalg.generic + auto newGenericOp = rewriter.create( + genericOp.getLoc(), + resultTypes, // Returns tensors! + newInputs, // Tensor inputs + newOutputs, // Tensor outputs (init tensors) + genericOp.getIndexingMaps(), + genericOp.getIteratorTypes() + ); + + // Clone computation region + rewriter.cloneRegionBefore(genericOp.getRegion(), + newGenericOp.getRegion(), ...); + + // Update currentTensor to result + if (newCurrentTensorIndex != -1) { + currentTensor = newGenericOp.getResult(newCurrentTensorIndex); + opResultMap[newGenericOp] = std::make_tuple(currentTensor, prevTensor); + } + + // Delete old operation + rewriter.eraseOp(genericOp); + } +``` + +**Transformation:** +```mlir +// BEFORE +linalg.generic ins(%A : memref<10xf32>) + outs(%B : memref<10xf32>) { + ^bb0(%a: f32, %b: f32): + %c = arith.addf %a, %b : f32 + linalg.yield %c : f32 +} + +// AFTER +%result = linalg.generic ins(%A_tensor : tensor<10xf32>) + outs(%B_tensor : tensor<10xf32>) -> tensor<10xf32> { + ^bb0(%a: f32, %b: f32): + %c = arith.addf %a, %b : f32 + linalg.yield %c : f32 +} +``` + +#### Case B: `memref.subview` Operations + +```cpp + else if (auto subviewOp = dyn_cast(user)) { + if (subviewOp.getSource() == memVal) { + // Convert to tensor.extract_slice + auto extractSliceOp = rewriter.create( + subviewOp.getLoc(), + currentTensor, // Tensor input + subviewOp.getOffsets(), + subviewOp.getSizes(), + subviewOp.getStrides() + ); + } + } +``` + +**Transformation:** +```mlir +// BEFORE +%view = memref.subview %base[0][10][1] : memref<100xf32> to memref<10xf32> + +// AFTER +%view = tensor.extract_slice %base_tensor[0][10][1] : + tensor<100xf32> to tensor<10xf32> +``` + +#### Case C: Unknown Operations (⚠️ THE PROBLEM!) + +```cpp + else { + // Skip unknown users + // THIS IS WHERE polygeist.submap IS SKIPPED! + } + } // End user loop +``` + +**Why is this a problem?** +- `polygeist.submap` operations are not handled +- They create intermediate memref views +- `linalg.generic` operations that consume these views are never reached +- **This blocks debufferization of strided operations!** + +--- + +### Phase 4: Final Conversion + +```cpp + // Final propagation to outer scope + propagateValueThroughRegion(currentTensor, regions, + expandedUserList, opResultMap, rewriter); + + // Convert tensor back to memref (if modified) + if (currentTensor != toTensorOp) { + auto toMemrefOp = rewriter.create( + memVal.getLoc(), memrefType, currentTensor); + + auto copyOp = rewriter.create( + memVal.getLoc(), toMemrefOp, memVal); + } + + return success(); +} +``` + +**Final IR:** +```mlir +%tensor = bufferization.to_tensor %memref : memref +// ... tensor transformations ... +%final_tensor = linalg.generic ... -> tensor +%final_memref = bufferization.to_memref %final_tensor : memref +memref.copy %final_memref, %memref : memref to memref +``` + +--- + +## Key Data Structures + +### 1. `opTuple` - Operation Result Tracking + +```cpp +using opTuple = std::tuple; +// First: result tensor from this operation +// Second: init tensor (input to this operation) + +llvm::DenseMap opResultMap; +``` + +**Purpose:** Track transformations for region propagation + +**Example:** +```mlir +// Original: +%init = tensor.empty() : tensor<10xf32> +%result = linalg.generic outs(%init) -> tensor<10xf32> { ... } + +// Stored in map: +opResultMap[genericOp] = {%result, %init} +``` + +**Why needed?** When propagating through `scf.for` loops, we need to know: +- What tensor to use as `iter_arg` (init tensor) +- What tensor the loop produces (result tensor) + +### 2. `expandedUserList` - Dynamic User Tracking + +```cpp +std::vector expandedUserList(sortedUsers); +``` + +**Purpose:** Track operations as they're replaced + +**Example:** +```cpp +// Before transformation +expandedUserList = [oldForOp, genericOp1, genericOp2] + +// After transforming oldForOp +expandedUserList = [newForOp, genericOp1, genericOp2] +// ^^^^^^^^^ Replaced! + +// Used by propagateValueThroughRegion to find the right newForOp +``` + +### 3. `sortedUsers` - Execution Order + +```cpp +std::vector sortedUsers = getSortedUsers(memVal); +``` + +**Purpose:** Process users in program execution order + +**Why critical?** SSA form requires definitions before uses. + +--- + +## Helper Functions + +### 1. `getSortedUsers(Value val)` + +```cpp +std::vector getSortedUsers(Value val) { + std::vector users; + for (Operation *user : val.getUsers()) { + // Deduplicate + if (std::find(users.begin(), users.end(), user) == users.end()) + users.push_back(user); + } + + // Sort by program order + std::sort(users.begin(), users.end(), + [](Operation *a, Operation *b) { + return comesBefore(a, b); + }); + + return users; +} +``` + +**Returns:** All users in **execution order** + +### 2. `comesBefore(Operation *a, Operation *b)` + +**Purpose:** Determine if operation `a` executes before `b` + +**Algorithm:** +``` +if a == b: + return false + +if a is ancestor of b: + return true // a surrounds b, so a starts first + +if b is ancestor of a: + return false // b surrounds a, so b starts first + +// Find common ancestor and compare positions +commonAncestor = findCommonParent(a, b) +compare positions within commonAncestor's regions +``` + +**Handles:** +- Same block: `a->isBeforeInBlock(b)` +- Different blocks: compare block order +- Different regions: compare region order +- Nested hierarchies: recursive comparison + +### 3. `findCommonAncestorRegion(Operation *a, Operation *b)` + +```cpp +Region* findCommonAncestorRegion(Operation* a, Operation* b) { + DenseMap regionCounts; + + // Walk up from a, marking all ancestor regions + Operation* currentOp = a; + while (Region* region = currentOp->getParentRegion()) { + regionCounts[region]++; + currentOp = region->getParentOp(); + } + + // Walk up from b, find first common region + currentOp = b; + while (Region* region = currentOp->getParentRegion()) { + if (regionCounts.count(region)) + return region; // Found common ancestor! + currentOp = region->getParentOp(); + } + + return nullptr; +} +``` + +**Returns:** Innermost region containing both operations + +**Example:** +```mlir +func.func @example() { // Region 0 + %tensor = ... + scf.for %i = 0 to 10 { // Region 1 + scf.if %cond { // Region 2 + linalg.generic outs(%tensor) // Operation b + } + } +} +// Operation a: %tensor definition (in Region 0) +// Operation b: linalg.generic (in Region 2) +// Common ancestor: Region 0 +``` + +### 4. `findUsersInRegion(Value val, Region ®ion, ...)` + +```cpp +void findUsersInRegion(Value value, Region& region, + SmallVectorImpl& users) { + for (Block& block : region) { + for (Operation& op : block) { + // Check if op uses value + for (Value operand : op.getOperands()) { + if (operand == value) { + users.push_back(&op); + break; + } + } + + // Recursively search sub-regions + for (Region& subRegion : op.getRegions()) { + findUsersInRegion(value, subRegion, users); + } + } + } +} +``` + +**Purpose:** Find all operations in a region that use a specific value + +**Used by:** `propagateValueThroughRegion` to find which operations need updating + +--- + +## Region Propagation + +This is the most complex part of the algorithm. When a tensor is defined in one scope but used in another, we need to **thread it through** the intermediate regions. + +### Flowchart: `propagateValueThroughRegion` + +``` + Input: currentValue, regions[], expandedUserList, opResultMap + │ + ▼ + ┌────────────────────────────┐ + │ For each region: │ + └────────────────────────────┘ + │ + ▼ + ┌────────────────────────────┐ + │ Find init tensor: │ + │ • First use in region │ + │ • From opResultMap │ + └────────────────────────────┘ + │ + ▼ + ┌────────────────────────────┐ + │ What is parent op? │ + └────────────────────────────┘ + │ + ┌───────────┴───────────┐ + │ │ + ▼ ▼ + ┌─────────┐ ┌─────────┐ + │ scf.for │ │ scf.if │ + └─────────┘ └─────────┘ + │ │ + ▼ ▼ + ┌──────────────────┐ ┌──────────────────┐ + │ Add to iter_args │ │ Add to results │ + └──────────────────┘ └──────────────────┘ + │ │ + ▼ ▼ + ┌──────────────────┐ ┌──────────────────┐ + │ Create new loop │ │ Create new if │ + │ with extra arg │ │ with extra result│ + └──────────────────┘ └──────────────────┘ + │ │ + ▼ ▼ + ┌──────────────────┐ ┌──────────────────┐ + │ Update users │ │ Update yields │ + │ inside to use │ │ • then: current │ + │ block argument │ │ • else: init │ + └──────────────────┘ └──────────────────┘ + │ │ + ▼ ▼ + ┌──────────────────┐ ┌──────────────────┐ + │ Update yield to │ │ Update current │ + │ return tensor │ │ to if result │ + └──────────────────┘ └──────────────────┘ + │ │ + ▼ ▼ + ┌──────────────────┐ ┌──────────────────┐ + │ Update current │ │ Store in │ + │ to loop result │ │ opResultMap │ + └──────────────────┘ └──────────────────┘ + │ │ + └───────────┬───────────┘ + ▼ + ┌────────────────────────────┐ + │ Store in opResultMap │ + │ Update expandedUserList │ + └────────────────────────────┘ +``` + +### Case A: `scf.for` Loops + +**Problem:** +```mlir +%tensor = ... // Outer scope +scf.for %i = 0 to 10 { + linalg.generic outs(%tensor) { ... } // ❌ Captures outer variable +} +``` + +**Solution: Add as `iter_arg`** +```mlir +%tensor = ... +%result = scf.for %i = 0 to 10 iter_args(%arg = %tensor) -> tensor { + %updated = linalg.generic outs(%arg) { ... } + scf.yield %updated : tensor +} +%tensor_after = %result +``` + +**Implementation:** +```cpp +if (auto prevFor = dyn_cast(parentOp)) { + // 1. Find which operations use initTensor inside the loop + findUsersInRegion(initTensor, *region, initOpUsers); + + // 2. Add tensor to loop's iter_args + SmallVector newInitOperands = prevFor.getInitArgs(); + newInitOperands.push_back(initTensor); + + // 3. Create new loop with extra iter_arg + scf::ForOp newLoop = rewriter.create( + prevFor.getLoc(), + prevFor.getLowerBound(), + prevFor.getUpperBound(), + prevFor.getStep(), + newInitOperands // Now includes our tensor + ); + + // 4. Transfer operations to new loop + Block *newBlock = &newLoop.getRegion().front(); + Block *originalBlock = &prevFor.getRegion().front(); + newBlock->getOperations().splice(newBlock->end(), + originalBlock->getOperations()); + + // 5. Update uses of initTensor to use the new block argument + Value newIterArg = newLoop.getRegionIterArg(numArgs - 2); + for (auto initOpUser : initOpUsers) { + for (auto &en : llvm::enumerate(initOpUser->getOperands())) { + if (en.value() == initTensor) { + initOpUser->setOperand(en.index(), newIterArg); + } + } + } + + // 6. Update yield to return the tensor + auto yieldOp = newBlock->getTerminator(); + SmallVector newYieldValues = yieldOp->getOperands(); + newYieldValues.push_back(currentValue); + rewriter.replaceOpWithNewOp(yieldOp, newYieldValues); + + // 7. Update currentValue to be the loop result + currentValue = newLoop.getResults().back(); + + // 8. Track this transformation + opResultMap[newLoop] = std::make_tuple(currentValue, initTensor); + + // 9. Erase old loop + rewriter.eraseOp(prevFor); +} +``` + +### Case B: `scf.if` Operations + +**Problem:** +```mlir +%tensor = ... // Outer scope +scf.if %cond { + linalg.generic outs(%tensor) { ... } // ❌ Captures outer variable +} +``` + +**Solution: Add as result** +```mlir +%tensor = ... +%result = scf.if %cond -> tensor { + %updated = linalg.generic outs(%tensor) { ... } + scf.yield %updated : tensor +} else { + scf.yield %tensor : tensor // Unchanged in else +} +%tensor_after = %result +``` + +**Implementation:** +```cpp +if (auto prevIf = dyn_cast(parentOp)) { + // 1. Add tensor to result types + SmallVector newResultTypes = prevIf.getResultTypes(); + newResultTypes.push_back(currentValue.getType()); + + // 2. Update then region yield + SmallVector thenYieldValues = prevIf.thenYield().getOperands(); + thenYieldValues.push_back(currentValue); + + // 3. Update else region yield (or use initTensor if no modification) + SmallVector elseYieldValues; + if (!prevIf.getElseRegion().empty()) { + elseYieldValues = prevIf.elseYield().getOperands(); + } + elseYieldValues.push_back(initTensor); // Unchanged in else + + // 4. Create new if with updated yields + auto newIf = rewriter.create( + prevIf.getLoc(), + newResultTypes, + prevIf.getCondition(), + true // withElseRegion + ); + + // 5. Transfer regions + newIf.getThenRegion().takeBody(prevIf.getThenRegion()); + if (!prevIf.getElseRegion().empty()) + newIf.getElseRegion().takeBody(prevIf.getElseRegion()); + + // 6. Update yield operations + rewriter.setInsertionPointToEnd(newIf.thenBlock()); + rewriter.replaceOpWithNewOp(newIf.thenYield(), thenYieldValues); + + rewriter.setInsertionPointToEnd(newIf.elseBlock()); + if (!prevIf.getElseRegion().empty()) + rewriter.replaceOpWithNewOp(newIf.elseYield(), elseYieldValues); + else + rewriter.create(newIf.getLoc(), elseYieldValues); + + // 7. Update currentValue to if result + currentValue = newIf->getResult(newIf->getNumResults() - 1); + + // 8. Track this transformation + opResultMap[newIf] = std::make_tuple(currentValue, initTensor); + + // 9. Erase old if + rewriter.eraseOp(prevIf); +} +``` + +--- + +## Example Transformations + +### Example 1: Simple Transformation + +**Input:** +```mlir +func.func @simple(%A: memref<10xf32>, %B: memref<10xf32>) { + %tmp = memref.alloca() : memref<10xf32> + + linalg.generic ins(%A : memref<10xf32>) + outs(%tmp : memref<10xf32>) { + ^bb0(%a: f32, %out: f32): + %c = arith.mulf %a, %a : f32 + linalg.yield %c : f32 + } + + linalg.generic ins(%tmp : memref<10xf32>) + outs(%B : memref<10xf32>) { + ^bb0(%a: f32, %out: f32): + %c = arith.addf %a, %a : f32 + linalg.yield %c : f32 + } + + return +} +``` + +**Step-by-Step Transformation:** + +1. **Identify root:** `%tmp = memref.alloca()` + +2. **Create to_tensor:** +```mlir +%tmp = memref.alloca() : memref<10xf32> +%tmp_tensor = bufferization.to_tensor %tmp : memref<10xf32> +``` + +3. **Process first generic:** +```mlir +%A_tensor = bufferization.to_tensor %A : memref<10xf32> +%init1 = tensor.empty() : tensor<10xf32> +%result1 = linalg.generic ins(%A_tensor : tensor<10xf32>) + outs(%init1 : tensor<10xf32>) -> tensor<10xf32> { +^bb0(%a: f32, %out: f32): + %c = arith.mulf %a, %a : f32 + linalg.yield %c : f32 +} +// currentTensor = %result1 +``` + +4. **Process second generic:** +```mlir +%B_tensor = bufferization.to_tensor %B : memref<10xf32> +%result2 = linalg.generic ins(%result1 : tensor<10xf32>) + outs(%B_tensor : tensor<10xf32>) -> tensor<10xf32> { +^bb0(%a: f32, %out: f32): + %c = arith.addf %a, %a : f32 + linalg.yield %c : f32 +} +// currentTensor = %result2 +``` + +5. **Convert back:** +```mlir +%B_memref = bufferization.to_memref %result2 : memref<10xf32> +memref.copy %B_memref, %B : memref<10xf32> to memref<10xf32> +``` + +**Output:** +```mlir +func.func @simple(%A: memref<10xf32>, %B: memref<10xf32>) { + %tmp = memref.alloca() : memref<10xf32> + %tmp_tensor = bufferization.to_tensor %tmp : memref<10xf32> + + %A_tensor = bufferization.to_tensor %A : memref<10xf32> + %init1 = tensor.empty() : tensor<10xf32> + %result1 = linalg.generic ins(%A_tensor : tensor<10xf32>) + outs(%init1 : tensor<10xf32>) -> tensor<10xf32> { + ^bb0(%a: f32, %out: f32): + %c = arith.mulf %a, %a : f32 + linalg.yield %c : f32 + } + + %B_tensor = bufferization.to_tensor %B : memref<10xf32> + %result2 = linalg.generic ins(%result1 : tensor<10xf32>) + outs(%B_tensor : tensor<10xf32>) -> tensor<10xf32> { + ^bb0(%a: f32, %out: f32): + %c = arith.addf %a, %a : f32 + linalg.yield %c : f32 + } + + %B_memref = bufferization.to_memref %result2 : memref<10xf32> + memref.copy %B_memref, %B : memref<10xf32> to memref<10xf32> + + return +} +``` + +**Benefits:** +- Now `%result1` and `%result2` can be fused by later passes +- Data flow is explicit + +--- + +### Example 2: Loop with Region Propagation + +**Input:** +```mlir +func.func @loop(%A: memref<10xf32>, %n: index) { + %tmp = memref.alloca() : memref<10xf32> + + scf.for %i = %c0 to %n step %c1 { + linalg.generic ins(%A : memref<10xf32>) + outs(%tmp : memref<10xf32>) { + ^bb0(%a: f32, %out: f32): + %c = arith.addf %out, %a : f32 + linalg.yield %c : f32 + } + } + + return +} +``` + +**Transformation Steps:** + +1. **Create to_tensor:** +```mlir +%tmp = memref.alloca() : memref<10xf32> +%tmp_tensor = bufferization.to_tensor %tmp : memref<10xf32> +``` + +2. **Detect scope issue:** + - `linalg.generic` is inside `scf.for` + - `%tmp_tensor` is outside `scf.for` + - Need propagation! + +3. **Propagate through scf.for:** +```mlir +%result = scf.for %i = %c0 to %n step %c1 + iter_args(%iter_tensor = %tmp_tensor) -> tensor<10xf32> { + %A_tensor = bufferization.to_tensor %A : memref<10xf32> + %updated = linalg.generic ins(%A_tensor : tensor<10xf32>) + outs(%iter_tensor : tensor<10xf32>) -> tensor<10xf32> { + ^bb0(%a: f32, %out: f32): + %c = arith.addf %out, %a : f32 + linalg.yield %c : f32 + } + scf.yield %updated : tensor<10xf32> +} +``` + +4. **Convert back:** +```mlir +%tmp_memref = bufferization.to_memref %result : memref<10xf32> +memref.copy %tmp_memref, %tmp : memref<10xf32> to memref<10xf32> +``` + +**Output:** +```mlir +func.func @loop(%A: memref<10xf32>, %n: index) { + %tmp = memref.alloca() : memref<10xf32> + %tmp_tensor = bufferization.to_tensor %tmp : memref<10xf32> + + %result = scf.for %i = %c0 to %n step %c1 + iter_args(%iter_tensor = %tmp_tensor) -> tensor<10xf32> { + %A_tensor = bufferization.to_tensor %A : memref<10xf32> + %updated = linalg.generic ins(%A_tensor : tensor<10xf32>) + outs(%iter_tensor : tensor<10xf32>) -> tensor<10xf32> { + ^bb0(%a: f32, %out: f32): + %c = arith.addf %out, %a : f32 + linalg.yield %c : f32 + } + scf.yield %updated : tensor<10xf32> + } + + %tmp_memref = bufferization.to_memref %result : memref<10xf32> + memref.copy %tmp_memref, %tmp : memref<10xf32> to memref<10xf32> + + return +} +``` + +**Key change:** The tensor is now threaded through the loop as an `iter_arg`, making the accumulation explicit! + +--- + +### Example 3: Nested Conditionals + +**Input:** +```mlir +func.func @conditional(%A: memref<10xf32>, %cond1: i1, %cond2: i1) { + %tmp = memref.alloca() : memref<10xf32> + + scf.if %cond1 { + scf.if %cond2 { + linalg.generic ins(%A : memref<10xf32>) + outs(%tmp : memref<10xf32>) { + ^bb0(%a: f32, %out: f32): + linalg.yield %a : f32 + } + } + } + + return +} +``` + +**Output (after propagation):** +```mlir +func.func @conditional(%A: memref<10xf32>, %cond1: i1, %cond2: i1) { + %tmp = memref.alloca() : memref<10xf32> + %tmp_tensor = bufferization.to_tensor %tmp : memref<10xf32> + + %result = scf.if %cond1 -> tensor<10xf32> { + %inner_result = scf.if %cond2 -> tensor<10xf32> { + %A_tensor = bufferization.to_tensor %A : memref<10xf32> + %updated = linalg.generic ins(%A_tensor : tensor<10xf32>) + outs(%tmp_tensor : tensor<10xf32>) -> tensor<10xf32> { + ^bb0(%a: f32, %out: f32): + linalg.yield %a : f32 + } + scf.yield %updated : tensor<10xf32> + } else { + scf.yield %tmp_tensor : tensor<10xf32> + } + scf.yield %inner_result : tensor<10xf32> + } else { + scf.yield %tmp_tensor : tensor<10xf32> + } + + %tmp_memref = bufferization.to_memref %result : memref<10xf32> + memref.copy %tmp_memref, %tmp : memref<10xf32> to memref<10xf32> + + return +} +``` + +**Key:** The tensor is propagated through **both** nested `scf.if` operations! + +--- + +## Current Limitations + +### 1. ⚠️ **Skips `polygeist.submap` Operations** + +**Problem:** +```mlir +%x_view = polygeist.submap(%x, %stride, %size) + <{map = affine_map<(d0)[s0] -> (d0 * s0)>}> + : (memref, index, index) -> memref + +linalg.generic ins(%x_view : memref) ... // ❌ NEVER REACHED! +``` + +**Why:** +- `polygeist.submap` creates an intermediate memref view +- The algorithm only looks at direct users of the base memref +- `linalg.generic` consuming the submap is never encountered +- **This blocks all strided BLAS operations!** + +**Impact:** High - affects all Level 1 BLAS with stride parameters + +**See:** `RaiseToLinalg_Issues.md` - Issue #3 + +### 2. **Limited Operation Support** + +Currently only handles: +- `linalg.generic` +- `memref.subview` → `tensor.extract_slice` + +**Not handled:** +- `polygeist.submap` +- Other linalg ops (`linalg.matmul`, `linalg.conv`, etc.) +- Custom operations + +### 3. **No Multi-Value Propagation** + +**Limitation:** Only propagates one tensor at a time through regions + +**Example that could fail:** +```mlir +%A_tensor = ... +%B_tensor = ... +scf.for %i = ... { + linalg.generic ins(%A_tensor) outs(%B_tensor) ... +} +``` + +The algorithm would try to propagate `%A_tensor` and `%B_tensor` separately, which could lead to issues. + +### 4. **Aliasing Analysis is Basic** + +```cpp +bool isNoalias = false; +if (auto allocaOp = memVal.getDefiningOp()) + isNoalias = true; // Assumes all allocas are noalias +``` + +**Issue:** Doesn't perform deep aliasing analysis, may miss optimization opportunities or transform incorrectly. + +### 5. **No Partial Debufferization** + +**Current behavior:** All-or-nothing per memref root + +**Would be useful:** Debufferize only certain uses, leave others as memref + +--- + +## Future Work + +### Priority 1: Handle `polygeist.submap` ⭐⭐⭐ + +**Proposal:** Add case in user processing loop: + +```cpp +else if (auto submapOp = dyn_cast(user)) { + // Extract affine map and operands + AffineMap map = submapOp.getMap(); + Value stride = submapOp.getStride(); + Value size = submapOp.getSize(); + + // Check if stride is constant + if (auto constStride = getConstantIntValue(stride)) { + // Use tensor.extract_slice with static stride + auto sliceOp = rewriter.create( + submapOp.getLoc(), currentTensor, + /*offsets=*/..., /*sizes=*/..., /*strides=*/*constStride); + currentTensor = sliceOp; + } else { + // Create scf.for gather loop + auto gatherLoop = createGatherLoop(currentTensor, stride, size); + currentTensor = gatherLoop; + } + + // Recursively process users of submap + auto submapUsers = getSortedUsers(submapOp.getResult()); + for (auto submapUser : submapUsers) { + // Process linalg.generic that consumes the submap + // ... + } +} +``` + +**See:** `saxpy_debufferized_example.mlir` for detailed transformation examples + +### Priority 2: Extend to Other Linalg Ops + +**Current:** Only `linalg.generic` + +**Extend to:** +- `linalg.matmul` +- `linalg.conv` +- `linalg.fill` +- `linalg.copy` +- Custom named linalg ops + +**Implementation:** Similar pattern to `linalg.generic` handling + +### Priority 3: Better Aliasing Analysis + +**Current:** Basic checks on operation type + +**Improve:** +- Use MLIR's aliasing analysis framework +- Track memory effects more precisely +- Handle partial aliasing + +### Priority 4: Multi-Value Propagation + +**Goal:** Propagate multiple tensors through regions simultaneously + +**Challenge:** Tracking dependencies between multiple tensors + +**Benefit:** Handle more complex kernels with multiple outputs + +### Priority 5: Partial Debufferization + +**Goal:** Debufferize only profitable uses + +**Use case:** Some uses are better left as memref (e.g., escaping pointers) + +**Implementation:** Cost model + selective transformation + +--- + +## Summary + +The `LinalgDebufferize` pass is a sophisticated transformation that: + +✅ **Converts memref-based linalg ops to tensor-based ops** +✅ **Handles complex control flow (loops, conditionals)** +✅ **Threads values through nested regions** +✅ **Enables high-level linalg optimizations** + +❌ **Currently skips `polygeist.submap` operations** +❌ **Limited to `linalg.generic` and `memref.subview`** +❌ **Basic aliasing analysis** + +**Key Innovation:** Region propagation algorithm that automatically updates `scf.for`/`scf.if` operations to thread tensors through their regions. + +**Main Limitation:** Doesn't handle strided memory access patterns created by `polygeist.submap`, blocking debufferization of BLAS operations. + +**Next Steps:** Extend the pass to handle `polygeist.submap` by materializing gather/scatter operations (see Issue #3 in `RaiseToLinalg_Issues.md`). + +--- + +## References + +- **Implementation:** `lib/polygeist/Passes/LinalgDebufferize.cpp` +- **Related Issues:** `RaiseToLinalg_Issues.md` - Issue #3 +- **Example Transformations:** `saxpy_debufferized_example.mlir` +- **Test Cases:** `test/polygeist-opt/` (TODO: add debufferize tests) +- **MLIR Linalg Dialect:** https://mlir.llvm.org/docs/Dialects/Linalg/ +- **MLIR Bufferization:** https://mlir.llvm.org/docs/Bufferization/ + +--- + +**Document Version:** 1.0 +**Last Updated:** October 17, 2025 +**Maintained by:** Polygeist Team + diff --git a/REFACTORING_SUMMARY.md b/REFACTORING_SUMMARY.md new file mode 100644 index 000000000000..fd0d0261032a --- /dev/null +++ b/REFACTORING_SUMMARY.md @@ -0,0 +1,397 @@ +# RemoveIterArgs Pass Refactoring Summary + +## Overview + +This document describes the refactoring of the `RemoveIterArgs` pass to follow **Approach 3: Shared Helper Functions**, which extracts common algorithmic logic into reusable helpers while keeping dialect-specific operations separate. + +## Motivation + +Previously, the `RemoveAffineIterArgs` and `RemoveSCFIterArgs` patterns had significant code duplication: +- **Before refactoring:** ~470 lines total (~235 lines × 2 patterns) +- **After refactoring:** ~380 lines total (~180 shared + ~100 affine + ~100 scf) +- **Code reduction:** ~19% fewer lines, with much better maintainability + +The refactoring provides: +1. ✅ **~60-70% code reuse** through shared helpers +2. ✅ **Clear, maintainable** structure +3. ✅ **Type-safe** - no template complexity +4. ✅ **Easy to test** - helpers are independently testable +5. ✅ **Enhanced SCF support** - SCF now has the same capabilities as Affine + +## Architecture + +### File Structure + +``` +RemoveIterArgs.cpp +├── RemoveIterArgsHelpers namespace (shared logic) +│ ├── isLoopInvariant() // Generic loop-invariant checking +│ ├── UseChainAnalysis // Generic use chain traversal +│ └── pullOperationsIntoLoop() // Generic operation distribution +├── RemoveSCFIterArgs pattern // SCF-specific implementation +└── RemoveAffineIterArgs pattern // Affine-specific implementation +``` + +### Shared Helpers + +#### 1. `isLoopInvariant(Value val, Operation *loopOp)` + +**Purpose:** Determine if a value is defined outside a loop. + +**Why it's generic:** +- Works on generic `Operation*` and `Value` types +- No dialect-specific knowledge required +- Uses MLIR's ancestry checking + +**Usage:** +```cpp +if (RemoveIterArgsHelpers::isLoopInvariant(operand, forOp.getOperation())) { + // operand can be safely used as a constant multiplier +} +``` + +--- + +#### 2. `UseChainAnalysis::analyze()` + +**Purpose:** Traverse the use-def chain of a loop result to identify transformation opportunities. + +**Why it's generic:** +- Templated on load/store operation types (affine vs memref) +- Algorithm is identical for both SCF and Affine +- Recognizes generic arithmetic ops (`arith.mulf`, `arith.addf`, etc.) + +**Capabilities:** +- ✅ Detects direct store: `loop_result → store` +- ✅ Detects multiply distribution: `loop_result → mul → store` +- ✅ Detects init load merging: `loop_result → add(load) → store` +- ✅ Detects GEMM pattern: `loop_result → mul → add(load) → store` +- ✅ Supports both float and integer arithmetic + +**Usage:** +```cpp +UseChainAnalysis analysis; + +// For Affine: +if (analysis.analyze( + result, yieldedValue, forOp.getOperation())) { + auto storeOp = cast(analysis.storeOp); + // ... use analysis.opsChain, analysis.initLoad +} + +// For SCF: +if (analysis.analyze( + result, yieldedValue, forOp.getOperation())) { + auto storeOp = cast(analysis.storeOp); + // ... use analysis.opsChain, analysis.initLoad +} +``` + +**Data Structure:** +```cpp +struct UseChainAnalysis { + SmallVector, 4> opsChain; // Operations to pull in + Operation *storeOp = nullptr; // Final store operation + Operation *initLoad = nullptr; // Optional init load + bool succeeded = false; // Analysis result +}; +``` + +--- + +#### 3. `pullOperationsIntoLoop()` + +**Purpose:** Apply distributivity transformations to pull external operations into the loop body. + +**Why it's generic:** +- Works with `IRMapping` (generic MLIR value remapping) +- Handles generic `arith.mulf`/`arith.muli` and `arith.addf`/`arith.addi` +- Uses generic `Operation*` pointers + +**Transformations:** + +**Before:** +```mlir +%sum = loop iter_args(%acc = %init) { + %val = load ... + %new_acc = addf %acc, %val + yield %new_acc +} +%scaled = mulf %alpha, %sum +store %scaled, %C +``` + +**After:** +```mlir +loop { + %acc = load %C + %val = load ... + %prod = mulf %alpha, %val // ← Pulled in (distributivity) + %new_acc = addf %acc, %prod + store %new_acc, %C +} +``` + +**Mathematical justification:** +- Uses distributivity: `α * (Σ x_i) = Σ (α * x_i)` +- Uses associativity: `(c + Σ x_i) = c + Σ x_i` with adjusted init + +**Usage:** +```cpp +Value finalAccum; +if (failed(pullOperationsIntoLoop( + mapper, analysis.opsChain, yieldedValue, + newForOp.getOperation(), rewriter, loc, finalAccum))) { + // Transformation failed +} +// finalAccum contains the value to store +``` + +--- + +### Pattern-Specific Code + +#### What Stays Separate + +| Aspect | Affine | SCF | Why Separate? | +|--------|--------|-----|---------------| +| **Loop creation** | `affine::AffineForOp` | `scf::ForOp` | Different C++ types | +| **Load operation** | `affine::AffineLoadOp` with `AffineMap` | `memref::LoadOp` with indices | Different parameters | +| **Store operation** | `affine::AffineStoreOp` with `AffineMap` | `memref::StoreOp` with indices | Different parameters | +| **Yield operation** | `affine::AffineYieldOp` | `scf::YieldOp` | Different C++ types | +| **Bound access** | `getLowerBoundMap()`, `getUpperBoundMap()` | `getLowerBound()`, `getUpperBound()` | Different APIs | + +#### Pattern Structure (Both Similar) + +Both patterns follow the same algorithm: + +```cpp +1. Validate loop has iter_args +2. Get last iter_arg and its yielded value +3. Call UseChainAnalysis::analyze() +4. Adjust init value if needed (initLoad) +5. Create new loop with fewer iter_args +6. Setup IRMapping +7. Create load to replace iter_arg +8. Clone loop body operations +9. Call pullOperationsIntoLoop() +10. Create store for final accumulator +11. Fix yield operation +12. Cleanup old operations +13. Replace old loop with new loop +``` + +**Only steps 5, 7, 8, 10, 11 differ** between SCF and Affine! + +--- + +## Benefits of Approach 3 + +### ✅ Code Reuse + +**Shared logic (~180 lines):** +- Loop-invariant checking +- Use chain analysis (~100 lines) +- Operation pull-in logic (~80 lines) + +**Pattern-specific (~200 lines):** +- Affine pattern: ~100 lines +- SCF pattern: ~100 lines + +**Total:** 380 lines (vs 470 lines before) + +### ✅ Maintainability + +**Single source of truth:** +- Algorithm improvements benefit both patterns +- Bug fixes propagate automatically +- Easier to understand and document + +**Example:** Supporting `arith.addi`/`arith.muli` required changes in only one place (the shared helpers). + +### ✅ Type Safety + +**No template complexity:** +- Each pattern is strongly typed +- Compiler catches errors immediately +- No cryptic template error messages + +**Template parameters only where needed:** +```cpp +// Only the load/store types are templated +template +bool analyze(Value result, Value yielded, Operation *loop); +``` + +### ✅ Extensibility + +**Easy to add new loop types:** +1. Create new pattern (e.g., `RemoveLoopIterArgs`) +2. Implement dialect-specific ops (load/store creation) +3. Call shared helpers +4. ~100 lines of code + +**Easy to add new transformations:** +1. Extend `UseChainAnalysis::analyze()` to detect pattern +2. Extend `pullOperationsIntoLoop()` to apply transformation +3. Both patterns benefit automatically + +--- + +## Testing + +### Test Coverage + +**Affine tests (`test_remove_iter_args.mlir`):** +1. Direct store +2. Multiply after loop +3. Add with invariant load +4. Full GEMM pattern +5. Nested loops +6. Integer operations (6 cases) + +**SCF tests (`test_remove_iter_args.mlir`):** +1. Direct store +2. Multiply after loop +3. Add with invariant load +4. Full GEMM pattern +5. Integer operations + +### Test Strategy + +```bash +# Build +cd /home/arjaiswal/Polygeist +source envsetup.sh +ninja -C build polygeist-opt + +# Test Affine patterns +./build/bin/polygeist-opt test_remove_iter_args.mlir \ + --remove-iter-args --mlir-print-ir-after-all + +# Test SCF patterns +./build/bin/polygeist-opt test_remove_iter_args.mlir \ + --remove-iter-args --mlir-print-ir-after-all +``` + +--- + +## Future Work + +### Possible Extensions + +1. **Support more arithmetic operations:** + - `arith.subf`, `arith.subi` (subtraction) + - `arith.divf`, `arith.divi` (division - requires commutativity check) + - `math.powf` (exponentiation) + +2. **Support chain patterns:** + - Multiple multiplies: `a * b * sum` + - Multiple adds: `c + d + sum` + - Mixed chains: `a * sum + b * sum` + +3. **Support nested transformations:** + - Process multiple iter_args in one pass + - Process nested loops + +4. **Better heuristics:** + - Cost model for when to apply transformation + - Detect when transformation would hurt performance + +5. **Additional loop types:** + - `scf.while` loops + - `scf.parallel` loops (if reductions are involved) + +--- + +## Design Decisions + +### Why Not Full Templates? + +❌ **Considered:** Full C++ template for entire pattern +```cpp +template +struct RemoveIterArgsTemplate { ... }; +``` + +**Rejected because:** +- Affine and SCF have fundamentally different APIs +- AffineMap vs raw indices can't be abstracted cleanly +- Template errors are harder to debug +- MLIR prefers concrete types + +✅ **Chosen:** Template only where necessary (UseChainAnalysis) + +### Why Not Dynamic Dispatch? + +❌ **Considered:** Virtual interface + subclasses +```cpp +class LoopTransformHelper { + virtual Operation* createLoad(...) = 0; + ... +}; +``` + +**Rejected because:** +- Runtime overhead (minor but unnecessary) +- More boilerplate code +- Still need pattern-specific registration +- Harder to inline + +✅ **Chosen:** Static polymorphism through shared functions + +### Why Not Separate Passes? + +❌ **Considered:** Separate passes for SCF and Affine + +**Rejected because:** +- More files to maintain +- Harder to see commonalities +- Duplicate test infrastructure +- Shared helpers would need separate header file + +✅ **Chosen:** Single pass with multiple patterns + +--- + +## Metrics + +### Code Statistics + +| Metric | Before | After | Change | +|--------|--------|-------|--------| +| Total lines | 605 | 670 | +65 (test cases) | +| Shared helpers | 0 | 180 | +180 | +| Affine pattern | 235 | 100 | -135 | +| SCF pattern (simple) | 150 | 100 | -50 | +| SCF pattern (enhanced) | N/A | 100 | +100 | +| Test cases | 180 | 280 | +100 | + +**Net result:** Enhanced SCF support with minimal code increase! + +### Complexity Reduction + +**Before:** +- Duplicated logic in 2 places +- Changes required edits to both patterns +- SCF had limited capabilities + +**After:** +- Shared logic in 1 place +- Changes propagate automatically +- SCF has full parity with Affine + +--- + +## Conclusion + +The refactoring to Approach 3 (Shared Helper Functions) achieves: + +1. ✅ **Significant code reuse** (~60-70%) +2. ✅ **Enhanced SCF support** (multiply distribution, init load merging) +3. ✅ **Maintainability** (single source of truth for algorithms) +4. ✅ **Type safety** (no template complexity) +5. ✅ **Extensibility** (easy to add new patterns/transformations) + +This is the recommended approach for similar refactorings in MLIR, balancing code reuse with type safety and maintainability. + diff --git a/RaiseToLinalg_Issues.md b/RaiseToLinalg_Issues.md new file mode 100644 index 000000000000..6be602846dac --- /dev/null +++ b/RaiseToLinalg_Issues.md @@ -0,0 +1,1044 @@ +# Issues in RaiseToLinalg.cpp + +This document tracks known issues and limitations in the `RaiseToLinalg.cpp` pass. + +--- + +## Issue #1: Strided Memory Access Pattern Conversion Failure + +**Date Identified:** October 15, 2025 + +**Status:** 🔴 Open + +### Description + +The `RaiseToLinalg` pass fails when converting affine loops with strided memory access patterns (e.g., `x[i*2]`) to `linalg.generic` operations. The pass creates invalid MLIR that fails verification. + +### Error Message + +``` +error: 'linalg.generic' op expected the shape-to-loops map to be non-null +``` + +### Root Cause + +When the pass encounters strided access patterns like: +```mlir +affine.for %arg0 = 0 to 3 { + %1 = affine.load %x[%arg0 * 2] : memref<6xf64> + %2 = affine.load %y[%arg0 * 2] : memref<6xf64> + // ... operations ... + affine.store %result, %y[%arg0 * 2] : memref<6xf64> +} +``` + +The pass generates: +```mlir +linalg.generic { + indexing_maps = [affine_map<(d0) -> (d0 * 2)>, affine_map<(d0) -> (d0 * 2)>], + iterator_types = [#linalg.iterator_type] +} ins(%x : memref<6xf64>) outs(%y : memref<6xf64>) { ... } +``` + +**Problem:** `linalg.generic` with non-strided memref types doesn't support non-identity indexing maps with multiplicative stride patterns. This causes a verification failure because the shape-to-loops mapping becomes ambiguous. + +### Example Test Case + +From `blas/daxpy.c` with stride=2: +```c +// Computing: y[::2] += alpha * x[::2] (every other element) +daxpy(3, 10.0, x, 2, y, 2); // incx=2, incy=2 +``` + +This generates the failing MLIR pattern. + +### Expected Behavior + +The pass should create strided memory views using `polygeist.submap` before the `linalg.generic`, similar to how the non-strided version works: + +```mlir +%strided_x = polygeist.submap(%x, %stride, %size) <{map = affine_map<(d0)[s0] -> (d0 * s0)>}> +%strided_y = polygeist.submap(%y, %stride, %size) <{map = affine_map<(d0)[s0] -> (d0 * s0)>}> + +linalg.generic { + indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], // Identity maps! + iterator_types = [#linalg.iterator_type] +} ins(%strided_x : memref) outs(%strided_y : memref) { ... } +``` + +### Workaround + +Currently, strided BLAS operations (with `incx != 1` or `incy != 1`) fail when passed through the `--raise-affine-to-linalg-pipeline`. + +**Temporary workaround:** +- Only test with `simple_*` versions that have contiguous memory access +- Manually avoid stride parameters in BLAS kernels during testing + +### Proposed Fix + +Modify the `AffineForOpRaising::matchAndRewrite` function in `RaiseToLinalg.cpp`: + +1. **Detect non-identity affine maps** in memory access patterns +2. **Extract stride information** from expressions like `d0 * c` where `c` is a constant +3. **Create `polygeist.submap` operations** to materialize strided views +4. **Generate identity indexing maps** for `linalg.generic` +5. **Adjust loop bounds** to reflect the strided iteration space + +### Impact + +**Affected Operations:** +- All Level 1 BLAS with stride parameters: `daxpy`, `ddot`, `dscal`, `dcopy`, `dasum`, `dnrm2` +- Any custom kernels with strided memory access patterns + +**Severity:** High - Blocks usage of standard BLAS interfaces with stride support + +### Related Files + +- `lib/polygeist/Passes/RaiseToLinalg.cpp` - Main pass implementation +- `blas/daxpy.c` - Test case demonstrating the issue +- Debug log with failure: See commit around Oct 15, 2025 + +### References + +- MLIR Linalg Dialect Documentation: https://mlir.llvm.org/docs/Dialects/Linalg/ +- Polygeist Documentation on memory views +- Debug output showing failure: `/home/arjaiswal/Polygeist/out` (lines 2579-2835) + +--- + +## Issue #2: Reduction Loops Not Supported + +**Date Identified:** October 15, 2025 + +**Status:** 🔴 Open + +### Description + +The `AffineForOpRaising` pattern immediately rejects any `affine.for` loop that has results (uses `iter_args`), preventing reduction operations from being raised to linalg. This blocks operations like `dasum`, `ddot`, and `dnrm2` that accumulate values. + +### Error Pattern + +``` +REJECTED: Loop has results +``` + +### Root Cause + +In `RaiseToLinalg.cpp`, the `AffineForOpRaising::matchAndRewrite` function contains: + +```cpp +// Early rejection if loop has results +if (op.getNumResults() > 0) { + LLVM_DEBUG(llvm::dbgs() << "\nREJECTED: Loop has results\n"); + return failure(); +} +``` + +This check was designed for simple parallel loops but prevents handling of reduction patterns. + +### Example Test Case + +From `blas/dasum.c`: +```c +double simple_dasum(int n, const double* x, int incx) { + double sum = 0.0; + for (int i = 0; i < n; i++) { + sum += fabs(x[i * incx]); // Reduction: accumulate sum + } + return sum; +} +``` + +Generated MLIR (correctly represents reduction): +```mlir +%sum = affine.for %arg0 = 0 to %n iter_args(%arg1 = %cst) -> (f64) { + %val = affine.load %x[%arg0] : memref + %abs = math.absf %val : f64 + %new_sum = arith.addf %arg1, %abs : f64 + affine.yield %new_sum : f64 +} +``` + +This loop is **rejected** because it has results. + +### Expected Behavior + +The pass should detect reduction patterns and generate appropriate linalg operations: + +```mlir +%sum = linalg.generic { + indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> ()>], + iterator_types = [#linalg.iterator_type] +} ins(%x : memref) outs(%init : memref) { +^bb0(%in: f64, %out: f64): + %abs = math.absf %in : f64 + %sum = arith.addf %out, %abs : f64 + linalg.yield %sum : f64 +} +``` + +Or use `linalg.reduce` operation for simple reductions. + +### Proposed Fix + +1. **Remove or conditionally apply** the early rejection for loops with results +2. **Add reduction pattern detection**: Check if loop body accumulates into `iter_args` +3. **Identify reduction operation type**: `addf`, `mulf`, `minf`, `maxf`, etc. +4. **Generate linalg with reduction semantics**: Use `linalg.iterator_type` and proper output handling +5. **Handle scalar results**: Map scalar reductions to 0-D tensors or memrefs + +### Impact + +**Affected Operations:** +- **Level 1 BLAS reductions**: `ddot` (dot product), `dasum` (sum of absolute values), `dnrm2` (Euclidean norm) +- Any custom kernels with accumulation/reduction patterns + +**Severity:** High - Completely blocks reduction operations, which are core BLAS primitives + +### Workaround + +None currently available. Reduction operations cannot be raised to linalg with the current pass implementation. + +### Related Files + +- `lib/polygeist/Passes/RaiseToLinalg.cpp` - Lines with `getNumResults()` check +- `blas/dasum.c`, `blas/ddot.c`, `blas/dnrm2.c` - Test cases +- Debug output: `/home/arjaiswal/Polygeist/out` (lines 2902-2912, 3080-3090) + +--- + +## Issue #3: LinalgDebufferize Cannot Handle polygeist.submap Operations + +**Date Identified:** October 17, 2025 + +**Status:** 🔴 Open + +### Description + +The `LinalgDebufferize` pass fails to transform `linalg.generic` operations that consume `polygeist.submap` results. The pass only recognizes `memref.AllocaOp`, `memref.AllocOp`, and function arguments as "roots" for debufferization, causing it to skip `polygeist.submap` operations entirely. This means any `linalg.generic` that operates on strided views created by `polygeist.submap` remains in memref form and is never debufferized. + +### Error Pattern + +Debug logs show: +``` +[User 0] Processing: polygeist.submap + Unknown user type (skipping): polygeist.submap +``` + +No error is thrown, but the pass silently skips the operations, leaving them untransformed. + +### Root Cause + +In `LinalgDebufferize.cpp`, the `handleMemref` lambda only processes memrefs from specific sources: +```cpp +for (auto arg : funcOp.getArguments()) { + if (failed(handleMemref(arg))) return failure(); +} +// Also handles memref.alloc and memref.alloca +``` + +When `polygeist.submap` creates a view: +```mlir +%strided_x = polygeist.submap(%arg2, %stride, %size) + <{map = affine_map<(d0)[s0] -> (d0 * s0)>}> + : (memref, index, index) -> memref + +linalg.generic ins(%strided_x : memref) ... +``` + +The pass sees `%strided_x` as a user of the base memref, classifies it as "Unknown user type", and skips it. Consequently, the `linalg.generic` that uses `%strided_x` is never encountered or transformed. + +### Example Test Case + +From `saxpy_linalg.mlir` (after RaiseToLinalg): +```mlir +func.func @saxpy(%n: i32, %alpha: f32, %x: memref, %incx: i32, + %y: memref, %incy: i32) { + %stride_x = arith.index_cast %incx : i32 to index + %stride_y = arith.index_cast %incy : i32 to index + %size = arith.index_cast %n : i32 to index + + // Create strided views + %x_view = polygeist.submap(%x, %stride_x, %size) + <{map = affine_map<(d0)[s0] -> (d0 * s0)>}> + : (memref, index, index) -> memref + + %y_view = polygeist.submap(%y, %stride_y, %size) + <{map = affine_map<(d0)[s0] -> (d0 * s0)>}> + : (memref, index, index) -> memref + + // This linalg.generic is NEVER debufferized! + linalg.generic { + indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], + iterator_types = ["parallel"] + } ins(%x_view : memref) outs(%y_view : memref) { + ^bb0(%x_val: f32, %y_val: f32): + %mul = arith.mulf %alpha, %x_val : f32 + %add = arith.addf %y_val, %mul : f32 + linalg.yield %add : f32 + } + return +} +``` + +Running `polygeist-opt --linalg-debufferize` leaves this IR unchanged. + +### Why Can't We Use linalg.generic for Materialization? + +Initial attempts to materialize `polygeist.submap` as `linalg.generic` operations fail because: + +**MLIR Constraint:** `linalg.generic` indexing maps **cannot contain symbols** - only dimensions are allowed. + +```mlir +// ❌ INVALID - symbols not allowed in linalg.generic indexing maps +linalg.generic { + indexing_maps = [ + affine_map<(d0)[s0] -> (d0 * s0)>, // Symbol [s0] causes error! + affine_map<(d0) -> (d0)> + ] +} ins(%base : tensor) outs(%view : tensor) { ... } +``` + +**Error message:** +``` +error: 'linalg.generic' op unexpected symbols in indexing_map #0 +``` + +This is a fundamental constraint of the Linalg dialect - iteration spaces must be determined solely by operand shapes (dimensions), not by runtime parameters (symbols). + +### Proposed Solutions + +#### **Solution 1: SCF Loops with tensor.extract/insert (Most General)** + +Transform `polygeist.submap` into explicit gather/scatter loops: + +```mlir +// For: polygeist.submap(%base, %stride, %size) with map (d0)[s0] -> (d0 * s0) + +%base_tensor = bufferization.to_tensor %base : memref +%view_init = tensor.empty(%size) : tensor + +%view = scf.for %i = %c0 to %size step %c1 + iter_args(%acc = %view_init) -> (tensor) { + // Compute strided index: i * stride + %strided_idx = arith.muli %i, %stride : index + + // Gather: extract from strided position in base + %val = tensor.extract %base_tensor[%strided_idx] : tensor + + // Insert into contiguous position in view + %updated = tensor.insert %val into %acc[%i] : tensor + scf.yield %updated : tensor +} +``` + +**Pros:** +- ✅ Works for **dynamic strides** (runtime values) +- ✅ Always valid MLIR +- ✅ Can be fused with subsequent operations by SCF loop fusion +- ✅ After fusion + bufferization, produces optimal code + +**Cons:** +- ❌ Not a single linalg operation (harder for linalg-specific transformations) +- ❌ Introduces loop overhead for materialization (eliminated by fusion) + +#### **Solution 2: tensor.extract_slice for Static Strides (Optimized)** + +For compile-time constant strides, use native tensor view operations: + +```mlir +// If stride is known at compile-time (e.g., constant 2) +%view = tensor.extract_slice %base_tensor[0][%size][2] : + tensor to tensor +``` + +**Pros:** +- ✅ Zero-copy view (just metadata) +- ✅ No loops needed +- ✅ Works naturally with linalg operations + +**Cons:** +- ❌ **Only works for static (constant) strides** +- ❌ Most BLAS operations have dynamic strides (function parameters) + +#### **Solution 3: Hybrid Approach (Recommended)** + +```cpp +// In LinalgDebufferize.cpp + +if (auto submapOp = dyn_cast(user)) { + // Extract stride operand and affine map + Value stride = submapOp.getStride(); + AffineMap map = submapOp.getMap(); + + // Check if stride is compile-time constant + if (auto constStride = getConstantIntValue(stride)) { + // Solution 2: Use tensor.extract_slice + createExtractSliceView(submapOp, *constStride); + } else { + // Solution 1: Create scf.for gather loop + createGatherLoop(submapOp, stride); + } +} +``` + +### Implementation Strategy + +1. **Extend `handleMemref` in LinalgDebufferize.cpp:** + - Add case for `polygeist::SubmapOp` users + - Transform submap into tensor operations (scf.for or extract_slice) + +2. **Recursively process submap results:** + - After materializing submap as tensor, recursively call `handleMemref` on the result + - This allows `linalg.generic` consumers to be debufferized + +3. **Pattern matching for affine maps:** + - Simple stride: `(d0)[s0] -> (d0 * s0)` → use Solution 1 or 2 + - Offset + stride: `(d0)[s0, s1] -> (s0 + d0 * s1)` → add offset to gather loop + - Multi-dimensional: Handle via nested loops + +4. **Fusion and optimization:** + - Let standard passes handle fusion: + - `--scf-loop-fusion` fuses gather/compute/scatter loops + - `--one-shot-bufferize` eliminates tensor↔memref conversions + - Final result should be equivalent to original affine code + +### Performance Considerations + +**Concern:** Won't materialization introduce expensive copies? + +**Answer:** No, because of fusion! + +**Transformation Pipeline:** +```mlir +Step 1: Materialize (3 loops) + %x_view = scf.for ... { gather x[i*stride] } + %result = linalg.generic ins(%x_view) ... + scf.for ... { scatter result[i] to y[i*stride] } + +Step 2: After SCF Loop Fusion (1 loop) + scf.for %i = 0 to %n { + %x_val = tensor.extract %x[%i * %stride] + %result = compute(%x_val, ...) + tensor.insert %result into %y[%i * %stride] + } + +Step 3: After Bufferization (optimal) + scf.for %i = 0 to %n { + %x_val = memref.load %x[%i * %stride] + %result = compute(%x_val, ...) + memref.store %result, %y[%i * %stride] + } +``` + +This is **exactly** the original loop - no overhead! + +### Expected Behavior After Fix + +```mlir +// Input: saxpy_linalg.mlir with polygeist.submap + +// After linalg-debufferize: +func.func @saxpy(...) { + %x_tensor = bufferization.to_tensor %x : memref + %y_tensor = bufferization.to_tensor %y : memref + + // Materialized gather loops (to be fused) + %x_view = scf.for %i ... { tensor.extract %x_tensor[%i * %incx] } + %y_view = scf.for %i ... { tensor.extract %y_tensor[%i * %incy] } + + // Debufferized linalg.generic + %result = linalg.generic ins(%x_view, %y_view : tensor, tensor) ... + + // Scatter result back + %y_updated = scf.for %i ... { tensor.insert ... into %y_tensor[%i * %incy] } + + memref.copy ... +} + +// After --scf-loop-fusion + --one-shot-bufferize: +func.func @saxpy(...) { + scf.for %i = 0 to %n { + %x_val = memref.load %x[%i * %incx] + %y_val = memref.load %y[%i * %incy] + %result = arith.addf %y_val, arith.mulf(%alpha, %x_val) + memref.store %result, %y[%i * %incy] + } +} +// Equivalent to original affine code! +``` + +### Impact + +**Affected Operations:** +- All Level 1 BLAS operations using strided access after RaiseToLinalg +- Any `linalg.generic` operations consuming `polygeist.submap` results +- Essentially blocks the tensor-based optimization pipeline for strided operations + +**Severity:** High - Prevents debufferization of common BLAS patterns, blocking tensor-level optimizations + +### Related Files + +- `lib/polygeist/Passes/LinalgDebufferize.cpp` - Pass implementation (needs extension) +- `saxpy_linalg.mlir` - Test case demonstrating the issue +- `saxpy_debufferized_example.mlir` - Detailed example of proposed transformation +- `blas/daxpy.c`, `blas/saxpy.c` - Original source files with strided access + +### References + +- MLIR Linalg Dialect: https://mlir.llvm.org/docs/Dialects/Linalg/ + - Section on indexing maps: "Maps must have no symbols" +- MLIR SCF Dialect: https://mlir.llvm.org/docs/Dialects/SCFDialect/ +- Debug logs: See `temp` file, lines showing "Unknown user type (skipping): polygeist.submap" + +--- + +## Issue #4: Dynamic Loop Offsets Not Properly Handled in SubmapOp Creation + +**Date Identified:** November 11, 2025 + +**Status:** 🔴 Open + +### Description + +The `remap_in_affine_dim` function in `RaiseToLinalg.cpp` incorrectly handles dynamic (non-constant) loop lower bounds when creating `polygeist.submap` operations. When a loop has a dynamic offset (e.g., `for i = offset to offset+n`), the code attempts to extract a constant value and defaults to `0` when it fails, resulting in incorrect indexing in the generated submap. + +### Error Pattern + +No compilation error occurs, but the generated IR is semantically incorrect. The offset is silently ignored, leading to wrong memory accesses at runtime. + +### Root Cause + +In `RaiseToLinalg.cpp`, line 228 of the `remap_in_affine_dim` function: + +```cpp +int lower_bound_val = getConstantFromAffineApply(lower_bound).value_or(0); +``` + +This code: +1. Tries to extract a **constant** value from the lower bound +2. If the lower bound is dynamic (depends on runtime values), `getConstantFromAffineApply` returns `nullopt` +3. Falls back to `0` as the default value +4. Uses this (incorrect) constant `0` in the affine map at lines 297 and 309: + +```cpp +// Line 297 +dimReplacements.push_back(builder.getAffineDimExpr(validDims) + + builder.getAffineConstantExpr(lower_bound_val)); +// Line 309 +symReplacements.push_back(builder.getAffineDimExpr(validDims) + + builder.getAffineConstantExpr(lower_bound_val)); +``` + +### Example Test Case + +Consider a loop with dynamic offset: + +```c +void dynamic_slice(double* A, int offset, int n) { + for (int i = offset; i < offset + n; i++) { + A[i] = A[i] * 2.0; + } +} +``` + +This generates MLIR like: + +```mlir +func.func @dynamic_slice(%A: memref, %offset: index, %n: index) { + %lb = affine.apply affine_map<()[s0] -> (s0)>(%offset) + %ub = affine.apply affine_map<()[s0, s1] -> (s0 + s1)>(%offset, %n) + + affine.for %i = %lb to %ub { + %val = affine.load %A[%i] : memref + %result = arith.mulf %val, %c2 : f64 + affine.store %result, %A[%i] : memref + } +} +``` + +### Current (Incorrect) Behavior + +After running `--raise-affine-to-linalg`, the code generates: + +```mlir +// WRONG: offset is ignored, defaults to 0 +%view = polygeist.submap(%A, %n) + {map = affine_map<(d0) -> (d0 + 0)>} // Should be (d0 + offset)! + : (memref, index) -> memref + +linalg.generic { + indexing_maps = [affine_map<(d0) -> (d0)>], + iterator_types = ["parallel"] +} ins(%view : memref) outs(%view : memref) { + // ... body ... +} +``` + +**Problem:** The submap starts at index `0` instead of `offset`, causing: +- Wrong memory region to be accessed +- Potential out-of-bounds access +- Incorrect computation results + +### Expected Behavior + +The pass should extract the dynamic offset value and pass it as a symbol operand: + +```mlir +// CORRECT: offset passed as symbol operand +%view = polygeist.submap(%A, %offset, %n) + {map = affine_map<(d0)[s0] -> (d0 + s0)>} // s0 = offset + : (memref, index, index) -> memref + +linalg.generic { + indexing_maps = [affine_map<(d0) -> (d0)>], + iterator_types = ["parallel"] +} ins(%view : memref) outs(%view : memref) { + // ... body ... +} +``` + +Where: +- `%offset` is passed as a symbol operand to the submap +- The map `affine_map<(d0)[s0] -> (d0 + s0)>` correctly adds the offset +- When indexing `view[i]`, it computes `A[i + offset]` as intended + +### Why This Design Works + +The current `SubmapOp` design is actually **correct** and doesn't need explicit offset operands because: + +1. **Constant offsets:** Can be baked into the affine map as constant expressions + ```mlir + map = affine_map<(d0) -> (d0 + 10)> // Constant offset 10 + ``` + +2. **Dynamic offsets:** Can be passed as symbol operands and referenced in the map + ```mlir + polygeist.submap(%base, %offset, %size) + map = affine_map<(d0)[s0] -> (d0 + s0)> // s0 is the dynamic offset + ``` + +The bug is NOT a design limitation - it's an implementation bug in handling dynamic offsets. + +### Proposed Fix + +Modify `remap_in_affine_dim` in `RaiseToLinalg.cpp`: + +```cpp +// Current (line 228): +int lower_bound_val = getConstantFromAffineApply(lower_bound).value_or(0); + +// Proposed fix: +std::optional lower_bound_const = getConstantFromAffineApply(lower_bound); +if (lower_bound_const) { + // Constant offset: bake into the map + int lower_bound_val = *lower_bound_const; + dimReplacements.push_back(builder.getAffineDimExpr(validDims) + + builder.getAffineConstantExpr(lower_bound_val)); + validDims++; +} else { + // Dynamic offset: add as symbol operand + Value lowerBoundValue = lower_bound.getResult(); + + // Add the offset to operands_without_indices + operands_without_indices.push_back(lowerBoundValue); + + // Reference it as a symbol in the map + dimReplacements.push_back(builder.getAffineDimExpr(validDims) + + builder.getAffineSymbolExpr(validSims)); + validDims++; + validSims++; +} +``` + +Similar changes needed for the symbol replacement logic (lines 306-315). + +### Alternative: More Robust Extraction + +Instead of assuming `AffineApplyOp` represents the lower bound simply, extract the actual lower bound operands and map: + +```cpp +// Extract the lower bound map and its operands +AffineMap lbMap = lower_bound.getAffineMap(); +ValueRange lbOperands = lower_bound.getOperands(); + +// Check if it's a constant map +if (lbMap.getNumResults() == 1 && lbMap.isSingleConstant()) { + // Constant offset: bake into map + int64_t offset = lbMap.getSingleConstantResult(); + // ... add as constant expression ... +} else { + // Dynamic offset: add operands as symbols + for (Value operand : lbOperands) { + operands_without_indices.push_back(operand); + } + // ... update map to reference these symbols ... +} +``` + +### Impact + +**Affected Operations:** +- Any affine loops with dynamic lower bounds (not starting at constant 0) +- Loops iterating over sub-slices of arrays (e.g., `for i = start to end`) +- Tiled loop nests where tile offsets are runtime parameters +- Blocked algorithms with dynamic block boundaries + +**Severity:** High - Silent correctness bug that produces wrong results without any error message + +**Current Workaround:** +- Manually rewrite loops to always start at 0 and adjust indexing +- Example: `for (i = offset; i < offset+n; i++) A[i] = ...` + → `for (i = 0; i < n; i++) A[i+offset] = ...` +- This workaround may not be feasible for all patterns + +### Related Files + +- `lib/polygeist/Passes/RaiseToLinalg.cpp` - Lines 218-435 (`remap_in_affine_dim` function) + - Line 228: Incorrect default to `0` for dynamic offsets + - Lines 297, 309: Where the (incorrect) constant offset is used +- `include/polygeist/PolygeistOps.td` - Lines 318-369 (`SubmapOp` definition) + - Shows that the design supports symbol operands for dynamic values + +### Testing Strategy + +Create test cases with: +1. **Simple dynamic offset:** + ```c + for (int i = offset; i < offset + n; i++) A[i] = B[i]; + ``` + +2. **Nested loops with dynamic offsets:** + ```c + for (int i = i_start; i < i_end; i++) + for (int j = j_start; j < j_end; j++) + C[i][j] = A[i][j] + B[i][j]; + ``` + +3. **Tiled GEMM with dynamic tile offsets:** + ```c + for (int ii = tile_i; ii < tile_i + tile_size; ii++) + for (int jj = tile_j; jj < tile_j + tile_size; jj++) + // ... computation ... + ``` + +Verify that the generated `polygeist.submap` operations: +- Include offset values as symbol operands +- Have affine maps that correctly reference these symbols +- Produce correct results when lowered and executed + +### References + +- MLIR Affine Dialect Documentation: https://mlir.llvm.org/docs/Dialects/Affine/ +- Affine Map composition and symbol handling +- Related to Issue #1 (strided access) - both involve properly encoding indexing information in submaps + +--- + +## Issue #5: SubmapInverse Cannot Handle Shape-Changing Tensor Transformations + +**Date Identified:** November 11, 2025 + +**Status:** 🔴 Open + +### Description + +The `polygeist.submapInverse` operation cannot correctly scatter results back when the tensor undergoes shape-changing transformations (like `tensor.expand_shape`, `tensor.collapse_shape`, or `tensor.extract_slice`) between the initial `polygeist.submap` and the final `submapInverse`. This limitation affects the debufferization pipeline when intermediate optimization passes modify tensor shapes. + +### Error Pattern + +Type mismatch errors occur when `submapInverse` receives a tensor of different shape than expected: + +``` +error: 'polygeist.submapInverse' op operand #1 must be memref of any type values or tensor of any type values, but got 'tensor<5x5xf64>' +``` + +Or semantic errors where the scatter-back operation cannot determine the correct mapping from the transformed shape back to the original strided view. + +### Root Cause + +The `submapInverse` operation expects to receive a tensor with the **exact same shape** as the original `submap` result. When intermediate operations change the shape, the type signature no longer matches: + +```mlir +// Original submap creates tensor<50xf64> +%view = polygeist.submap(%base_tensor, %stride, %c50) + {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (tensor<100xf64>, index, index) -> tensor<50xf64> + +// Shape change: tensor<50xf64> → tensor<10x5xf64> +%view_2d = tensor.expand_shape %view [[0, 1]] + : tensor<50xf64> into tensor<10x5xf64> + +// Computation on transformed shape +%result_2d = linalg.generic ... outs(%view_2d : tensor<10x5xf64>) -> tensor<10x5xf64> + +// ❌ TYPE MISMATCH: submapInverse expects tensor<50xf64>, receives tensor<10x5xf64> +%updated = polygeist.submapInverse(%base_tensor, %result_2d, %stride, %c50) + {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (tensor<100xf64>, tensor<10x5xf64>, index, index) -> tensor<100xf64> +``` + +### When Does This Work? + +`submapInverse` works correctly when the tensor chain **preserves shape**: + +✅ **Safe Operations (Shape-Preserving):** +- `linalg.generic` with identity indexing maps +- `linalg.map` (element-wise operations) +- Element-wise arithmetic (`arith.addf`, `arith.mulf`, etc.) +- `tensor.insert` / `tensor.extract` (single elements) +- `math.*` operations (element-wise) + +### When Does This Break? + +❌ **Problematic Operations (Shape-Changing):** +- `tensor.expand_shape` / `tensor.collapse_shape` - Changes dimensionality +- `tensor.extract_slice` - Reduces dimensions or size +- `tensor.insert_slice` - If inserting into different shape +- `tensor.pad` - Changes tensor size +- `tensor.concat` - Changes tensor size +- `tensor.broadcast` - Adds dimensions + +### Example Test Case + +**Memref Version (Works Fine):** +```mlir +func.func @reshape_memref(%A: memref<100xf64>, %stride: index) { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c50 = arith.constant 50 : index + %c2 = arith.constant 2.0 : f64 + + scf.for %i = %c0 to %c50 step %c1 { + %idx = arith.muli %i, %stride : index + %val = memref.load %A[%idx] : memref<100xf64> + %doubled = arith.mulf %val, %c2 : f64 + memref.store %doubled, %A[%idx] : memref<100xf64> + } + + return +} +``` + +**Tensor Version with Reshape (Breaks):** +```mlir +func.func @reshape_tensor(%A: memref<100xf64>, %stride: index) { + %c50 = arith.constant 50 : index + %c2 = arith.constant 2.0 : f64 + + %A_tensor = bufferization.to_tensor %A : memref<100xf64> + + %A_view = polygeist.submap(%A_tensor, %stride, %c50) + {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (tensor<100xf64>, index, index) -> tensor<50xf64> + + %A_2d = tensor.expand_shape %A_view [[0, 1]] + : tensor<50xf64> into tensor<10x5xf64> + + %result_2d = linalg.generic { + indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>], + iterator_types = ["parallel", "parallel"] + } outs(%A_2d : tensor<10x5xf64>) { + ^bb0(%val: f64): + %doubled = arith.mulf %val, %c2 : f64 + linalg.yield %doubled : f64 + } -> tensor<10x5xf64> + + %A_updated = polygeist.submapInverse(%A_tensor, %result_2d, %stride, %c50) + {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (tensor<100xf64>, tensor<10x5xf64>, index, index) -> tensor<100xf64> + + %A_memref = bufferization.to_memref %A_updated : memref<100xf64> + memref.copy %A_memref, %A : memref<100xf64> to memref<100xf64> + + return +} +``` + +**Problem:** The `tensor.expand_shape` changes `tensor<50xf64>` to `tensor<10x5xf64>`, but `submapInverse` still expects `tensor<50xf64>`. + +### Why Does This Happen? + +Tensor-level optimization passes may introduce shape changes for various reasons: +- **Vectorization preparation**: Reshaping to expose parallelism +- **Tiling**: Splitting dimensions for cache locality +- **Layout optimization**: Changing data layout for better memory access +- **Broadcasting**: Expanding dimensions for element-wise operations + +These transformations are valid and beneficial in tensor land, but they break the assumption that `submapInverse` can directly map the result back to the original strided view. + +### Proposed Solutions + +#### **Solution 1: Restrict Debufferization to Shape-Preserving Chains** + +Only debufferize when the tensor chain between `submap` and `submapInverse` preserves shape: + +```cpp +// In LinalgDebufferize.cpp +bool isShapePreserving(Operation* op) { + return isa(op); +} + +// When processing submap: +if (auto submapOp = dyn_cast(user)) { + // Check if all uses preserve shape + for (Operation* user : submapOp->getUsers()) { + if (!isShapePreserving(user)) { + return failure(); // Skip debufferization + } + } + // Proceed with debufferization... +} +``` + +**Pros:** +- ✅ Simple to implement +- ✅ Guarantees correctness +- ✅ Works for common BLAS patterns (element-wise operations) + +**Cons:** +- ❌ Misses optimization opportunities when shape changes are beneficial +- ❌ Requires conservative analysis + +#### **Solution 2: Track Provenance and Insert Inverse Transformations** + +Track the chain of transformations and insert inverse operations before `submapInverse`: + +```mlir +// Original chain: +%view = polygeist.submap(...) -> tensor<50xf64> +%view_2d = tensor.expand_shape %view [[0, 1]] -> tensor<10x5xf64> +%result_2d = linalg.generic ... -> tensor<10x5xf64> + +// Insert inverse transformation: +%result_1d = tensor.collapse_shape %result_2d [[0, 1]] -> tensor<50xf64> +%updated = polygeist.submapInverse(%base, %result_1d, ...) -> tensor<100xf64> +``` + +**Pros:** +- ✅ Allows shape-changing optimizations +- ✅ Maintains correctness by undoing transformations + +**Cons:** +- ❌ Complex provenance tracking required +- ❌ May not always be invertible (e.g., `extract_slice` loses information) +- ❌ Additional overhead from inverse operations + +#### **Solution 3: Use SubmapInverse at Original Tensor Shape** + +Instead of threading the transformed tensor through, maintain a parallel chain for the scatter-back: + +```mlir +// Keep original view for scatter-back +%view = polygeist.submap(%base, %stride, %size) -> tensor<50xf64> + +// Create transformed version for computation +%view_2d = tensor.expand_shape %view [[0, 1]] -> tensor<10x5xf64> +%result_2d = linalg.generic ... outs(%view_2d) -> tensor<10x5xf64> + +// Collapse back before scatter +%result_1d = tensor.collapse_shape %result_2d [[0, 1]] -> tensor<50xf64> + +// Scatter with matching shape +%updated = polygeist.submapInverse(%base, %result_1d, %stride, %size) +``` + +This is similar to Solution 2 but explicitly managed by the debufferization pass. + +#### **Solution 4: Extend SubmapInverse to Handle Shape Metadata** + +Extend `submapInverse` to accept shape transformation metadata: + +```mlir +%updated = polygeist.submapInverse(%base, %result_2d, %stride, %size) + {map = affine_map<(d0)[s0] -> (d0 * s0)>, + shape_transform = #polygeist.reshape<[50] -> [10, 5]>} + : (tensor<100xf64>, tensor<10x5xf64>, index, index) -> tensor<100xf64> +``` + +**Pros:** +- ✅ Most general solution +- ✅ Encapsulates complexity in the operation + +**Cons:** +- ❌ Significant implementation complexity +- ❌ Requires extending the operation definition +- ❌ May be overkill for common cases + +### Recommended Approach + +**Start with Solution 1 (Restricted Debufferization):** +1. Implement debufferization only for shape-preserving chains +2. Add validation to detect and reject shape-changing operations +3. Document the limitation clearly + +**Future Enhancement (Solution 2/3):** +1. Add provenance tracking to detect shape transformations +2. Insert inverse transformations before `submapInverse` +3. Validate that transformations are invertible + +### Implementation Strategy + +```cpp +// In LinalgDebufferize.cpp + +// Helper to check if operation preserves shape +static bool preservesShape(Operation* op) { + return isa(op) || + op->hasTrait() || + isa(op); +} + +// When handling submap: +if (auto submapOp = dyn_cast(user)) { + // Validate shape preservation + SmallVector chain; + if (!collectShapePreservingChain(submapOp, chain)) { + LLVM_DEBUG(llvm::dbgs() << "Skipping submap: chain contains shape-changing ops\n"); + return failure(); + } + + // Proceed with debufferization... + Value tensorView = convertSubmapToTensor(submapOp); + // ... process chain ... + insertSubmapInverse(submapOp, tensorView); +} +``` + +### Impact + +**Affected Operations:** +- Any debufferization pipeline that includes shape-changing tensor operations +- Optimization passes that reshape tensors for vectorization or tiling +- Patterns that use `tensor.expand_shape`, `tensor.collapse_shape`, or `tensor.extract_slice` + +**Severity:** Medium - Limits the applicability of debufferization but doesn't cause correctness issues (operations are rejected rather than producing wrong results) + +**Current Workaround:** +- Avoid shape-changing operations in the tensor chain between `submap` and `submapInverse` +- Perform shape transformations before or after the debufferized region +- Use memref-based transformations instead of tensor-based ones + +### Related Files + +- `lib/polygeist/Passes/LinalgDebufferize.cpp` - Needs validation logic +- `include/polygeist/PolygeistOps.td` - `SubmapOp` and `SubmapInverseOp` definitions +- `saxpy_debufferized_example.mlir` - Example showing shape-preserving debufferization + +### Related Issues + +- **Issue #3**: LinalgDebufferize Cannot Handle polygeist.submap Operations (parent issue) +- This issue documents a specific limitation once Issue #3 is resolved + +### References + +- MLIR Tensor Dialect: https://mlir.llvm.org/docs/Dialects/TensorOps/ +- Shape manipulation operations and their semantics +- Provenance tracking in compiler transformations + +--- + +## Future Issues + +*Document additional issues here as they are discovered.* + diff --git a/SUBMAP_INVERSE_EXPLAINED.md b/SUBMAP_INVERSE_EXPLAINED.md new file mode 100644 index 000000000000..9d34f807add2 --- /dev/null +++ b/SUBMAP_INVERSE_EXPLAINED.md @@ -0,0 +1,561 @@ +# Understanding polygeist.submapInverse + +This document explains why `polygeist.submapInverse` is essential for the debufferization pipeline and how it works. + +--- + +## Table of Contents + +1. [The Problem: Strided Scatter-Back](#the-problem-strided-scatter-back) +2. [What submapInverse Does](#what-submapinverse-does) +3. [Complete Example: With vs Without submapInverse](#complete-example-with-vs-without-submapinverse) +4. [How submapInverse Works Internally](#how-submapinverse-works-internally) +5. [Why to_memref + copy is Still Needed](#why-to_memref--copy-is-still-needed) +6. [Multiple submapInverse Operations](#multiple-submapinverse-operations) +7. [After Bufferization: Final Optimized Code](#after-bufferization-final-optimized-code) + +--- + +## The Problem: Strided Scatter-Back + +When we debufferize operations on strided views, we face a fundamental challenge: + +**The Gather-Compute-Scatter Pattern:** + +``` +Original memref: [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, ...] (100 elements) + ^ ^ ^ ^ ^ + | | | | | +Stride=2 extracts: a0 a2 a4 a6 a8 (50 elements) + ↓ ↓ ↓ ↓ ↓ +Contiguous view: [a0, a2, a4, a6, a8, ...] (50 elements) + ↓ ↓ ↓ ↓ ↓ +Compute (×2): [v0, v1, v2, v3, v4, ...] (50 elements) + ↓ ↓ ↓ ↓ ↓ +Scatter back: v0 v1 v2 v3 v4 + ↓ ↓ ↓ ↓ ↓ +Updated memref: [v0, a1, v1, a3, v2, a5, v3, a7, v4, a9, ...] +``` + +**The challenge:** How do we scatter 50 contiguous values back to 50 non-contiguous (strided) positions? + +--- + +## What submapInverse Does + +`polygeist.submapInverse` performs a **strided scatter** operation: + +```mlir +%result = polygeist.submapInverse(%base, %values, %stride, %size) + {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (tensor<100xf64>, tensor<50xf64>, index, index) -> tensor<100xf64> +``` + +**Semantics:** +1. Takes a base tensor (`tensor<100xf64>`) +2. Takes computed values (`tensor<50xf64>`) - contiguous +3. Scatters values to strided positions using the affine map +4. Preserves all other elements in the base tensor +5. Returns a new tensor with updates applied + +**Key properties:** +- Uses the **same affine map** as the original `polygeist.submap` +- Inverse operation: `submap` gathers, `submapInverse` scatters +- Preserves elements not covered by the strided access pattern + +--- + +## Complete Example: With vs Without submapInverse + +### Scenario: Double every other element (stride=2) + +**Input:** `A = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]` +**Goal:** Double elements at positions 0, 2, 4, 6, 8 (stride=2) +**Expected:** `A = [2.0, 2.0, 6.0, 4.0, 10.0, 6.0, 14.0, 8.0, 18.0, 10.0]` + +### ❌ Without submapInverse: Manual Scatter Loop + +```mlir +func.func @without_inverse(%A: memref<10xf64>) { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c2_f64 = arith.constant 2.0 : f64 + + // Convert to tensor + %A_tensor = bufferization.to_tensor %A : memref<10xf64> + + // Gather: Extract strided elements + %A_view = polygeist.submap(%A_tensor, %c2, %c5) + {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (tensor<10xf64>, index, index) -> tensor<5xf64> + // %A_view = [1.0, 3.0, 5.0, 7.0, 9.0] + + // Compute: Double the values + %computed = linalg.generic { + indexing_maps = [affine_map<(d0) -> (d0)>], + iterator_types = ["parallel"] + } outs(%A_view : tensor<5xf64>) { + ^bb0(%a: f64): + %doubled = arith.mulf %a, %c2_f64 : f64 + linalg.yield %doubled : f64 + } -> tensor<5xf64> + // %computed = [2.0, 6.0, 10.0, 14.0, 18.0] + + // ❌ PROBLEM: How to scatter back? + // Can't do: memref.copy %computed, %A (shape mismatch: 5 vs 10) + + // Manual scatter loop required: + %computed_memref = bufferization.to_memref %computed : memref<5xf64> + + scf.for %i = %c0 to %c5 step %c1 { + // Load from contiguous position i + %val = memref.load %computed_memref[%i] : memref<5xf64> + + // Store to strided position i * 2 + %strided_idx = arith.muli %i, %c2 : index + memref.store %val, %A[%strided_idx] : memref<10xf64> + } + // Manual loop: A[0]=2.0, A[2]=6.0, A[4]=10.0, A[6]=14.0, A[8]=18.0 + + return +} +``` + +**Problems:** +- ❌ Verbose: Requires manual scatter loop +- ❌ Error-prone: Easy to get indexing wrong +- ❌ Loses semantic information: Compiler can't see the strided pattern +- ❌ Harder to optimize: Loop fusion, vectorization passes may miss opportunities + +### ✅ With submapInverse: Clean and Declarative + +```mlir +func.func @with_inverse(%A: memref<10xf64>) { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c2_f64 = arith.constant 2.0 : f64 + + // Convert to tensor + %A_tensor = bufferization.to_tensor %A : memref<10xf64> + + // Gather: Extract strided elements + %A_view = polygeist.submap(%A_tensor, %c2, %c5) + {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (tensor<10xf64>, index, index) -> tensor<5xf64> + // %A_view = [1.0, 3.0, 5.0, 7.0, 9.0] + + // Compute: Double the values + %computed = linalg.generic { + indexing_maps = [affine_map<(d0) -> (d0)>], + iterator_types = ["parallel"] + } outs(%A_view : tensor<5xf64>) { + ^bb0(%a: f64): + %doubled = arith.mulf %a, %c2_f64 : f64 + linalg.yield %doubled : f64 + } -> tensor<5xf64> + // %computed = [2.0, 6.0, 10.0, 14.0, 18.0] + + // ✅ Scatter: Use submapInverse with SAME map + %A_updated = polygeist.submapInverse(%A_tensor, %computed, %c2, %c5) + {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (tensor<10xf64>, tensor<5xf64>, index, index) -> tensor<10xf64> + // %A_updated = [2.0, 2.0, 6.0, 4.0, 10.0, 6.0, 14.0, 8.0, 18.0, 10.0] + // ^new ^old ^new ^old ^new ^old ^new ^old ^new ^old + + // Convert back to memref and copy + %A_final = bufferization.to_memref %A_updated : memref<10xf64> + memref.copy %A_final, %A : memref<10xf64> to memref<10xf64> + + return +} +``` + +**Advantages:** +- ✅ Clean: Single operation for strided scatter +- ✅ Declarative: Clearly expresses the intent +- ✅ Preserves semantics: Compiler knows it's a strided scatter +- ✅ Optimizable: Subsequent passes can fuse and vectorize + +--- + +## How submapInverse Works Internally + +### Step-by-Step Execution + +```mlir +%A_updated = polygeist.submapInverse(%A_tensor, %computed, %stride, %size) + {map = affine_map<(d0)[s0] -> (d0 * s0)>} +``` + +**Given:** +- `%A_tensor = [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9]` (10 elements) +- `%computed = [v0, v1, v2, v3, v4]` (5 elements) +- `%stride = 2` +- `%size = 5` +- `map = affine_map<(d0)[s0] -> (d0 * s0)>` + +**Process:** + +``` +For each dimension index d0 in [0, size): + 1. Compute target index: target = map(d0)[stride] = d0 * stride + 2. Update: result[target] = computed[d0] + 3. Preserve: result[i] = A_tensor[i] for all i != target + +Iteration 0: d0=0 → target=0*2=0 → result[0] = v0 +Iteration 1: d0=1 → target=1*2=2 → result[2] = v1 +Iteration 2: d0=2 → target=2*2=4 → result[4] = v2 +Iteration 3: d0=3 → target=3*2=6 → result[6] = v3 +Iteration 4: d0=4 → target=4*2=8 → result[8] = v4 + +Preserve: result[1]=a1, result[3]=a3, result[5]=a5, result[7]=a7, result[9]=a9 +``` + +**Result:** +``` +%A_updated = [v0, a1, v1, a3, v2, a5, v3, a7, v4, a9] +``` + +### With Offset + Stride + +```mlir +%result = polygeist.submapInverse(%base, %values, %offset, %stride, %size) + {map = affine_map<(d0)[s0, s1] -> (s0 + d0 * s1)>} + : (tensor<100xf64>, tensor<30xf64>, index, index, index) -> tensor<100xf64> +``` + +**Given:** +- `%base = [b0, b1, b2, ..., b99]` (100 elements) +- `%values = [v0, v1, v2, ..., v29]` (30 elements) +- `%offset = 10` +- `%stride = 3` +- `map = affine_map<(d0)[s0, s1] -> (s0 + d0 * s1)>` + +**Process:** + +``` +For d0 in [0, 30): + target = offset + d0 * stride = 10 + d0 * 3 + +d0=0 → target=10+0*3=10 → result[10] = v0 +d0=1 → target=10+1*3=13 → result[13] = v1 +d0=2 → target=10+2*3=16 → result[16] = v2 +... +d0=29 → target=10+29*3=97 → result[97] = v29 + +Preserve: All other elements remain unchanged +``` + +--- + +## Why to_memref + copy is Still Needed + +Even with `submapInverse`, we still need the final `to_memref` + `copy`. Here's why: + +### The Type System Boundary + +```mlir +func.func @example(%A: memref<100xf64>, %stride: index) { + // ^^^^^^^^^^^^^^^^ Input is MEMREF + + // Enter tensor world + %A_tensor = bufferization.to_tensor %A : memref<100xf64> + + // ... submap, compute, submapInverse ... + + %A_updated = polygeist.submapInverse(...) + : (...) -> tensor<100xf64> + // ^^^^^^^^^^^^^^ Returns TENSOR + + // Exit tensor world + %A_final = bufferization.to_memref %A_updated : memref<100xf64> + + // Update the original memref parameter + memref.copy %A_final, %A : memref<100xf64> to memref<100xf64> + // ^^^^^^^^ ^^ + // new data original parameter + + return +} +``` + +### Memref vs Tensor Semantics + +**Memrefs (Reference Semantics):** +- Like pointers or references +- Operations modify data in-place +- Multiple memrefs can alias the same memory +- Mutable + +**Tensors (Value Semantics):** +- Like immutable values +- Operations create new tensors +- No aliasing +- Immutable + +### What Happens Without the Copy + +```mlir +func.func @no_copy(%A: memref<100xf64>, %stride: index) { + %A_tensor = bufferization.to_tensor %A : memref<100xf64> + + %A_view = polygeist.submap(%A_tensor, %stride, %c50) ... + %computed = linalg.generic ... -> tensor<50xf64> + %A_updated = polygeist.submapInverse(%A_tensor, %computed, ...) + -> tensor<100xf64> + + %A_final = bufferization.to_memref %A_updated : memref<100xf64> + + // ❌ NO COPY - Original %A is never updated! + return +} + +// Caller sees: +func.func @caller() { + %A = memref.alloc() : memref<100xf64> + // ... initialize A with [1, 2, 3, ...] ... + + call @no_copy(%A, %stride) : (memref<100xf64>, index) -> () + + // ❌ %A still has [1, 2, 3, ...] - unchanged! + // The computation was lost because we never copied back +} +``` + +### The Complete Flow + +``` +Input memref %A + ↓ +to_tensor (enter tensor world) + ↓ +submap (gather strided elements) + ↓ +linalg.generic (compute) + ↓ +submapInverse (scatter back to tensor) + ↓ +to_memref (exit tensor world, creates new memref) + ↓ +memref.copy (update original memref parameter) + ↓ +Original %A is now updated +``` + +**Each step is necessary:** +1. `to_tensor`: Enter tensor world for transformations +2. `submap`: Gather strided elements into contiguous tensor +3. `linalg.generic`: Perform computation +4. `submapInverse`: Scatter results back to strided positions +5. `to_memref`: Exit tensor world +6. `memref.copy`: Update the original input parameter + +--- + +## Multiple submapInverse Operations + +When multiple arrays are modified, each needs its own `submapInverse`: + +```mlir +func.func @multi_array(%X: memref<200xf64>, %Y: memref<300xf64>, + %stride_x: index, %stride_y: index) { + %c50 = arith.constant 50 : index + %c2 = arith.constant 2.0 : f64 + + %X_tensor = bufferization.to_tensor %X : memref<200xf64> + %Y_tensor = bufferization.to_tensor %Y : memref<300xf64> + + // Create two submaps with different strides + %X_view = polygeist.submap(%X_tensor, %stride_x, %c50) + {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (tensor<200xf64>, index, index) -> tensor<50xf64> + + %Y_view = polygeist.submap(%Y_tensor, %stride_y, %c50) + {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (tensor<300xf64>, index, index) -> tensor<50xf64> + + // Compute: Y = Y + X * 2 + %Y_result = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, // X_view + affine_map<(d0) -> (d0)> // Y_view + ], + iterator_types = ["parallel"] + } ins(%X_view : tensor<50xf64>) outs(%Y_view : tensor<50xf64>) { + ^bb0(%x: f64, %y: f64): + %scaled = arith.mulf %x, %c2 : f64 + %sum = arith.addf %y, %scaled : f64 + linalg.yield %sum : f64 + } -> tensor<50xf64> + + // Compute: X = X * 3 + %X_result = linalg.generic { + indexing_maps = [affine_map<(d0) -> (d0)>], + iterator_types = ["parallel"] + } outs(%X_view : tensor<50xf64>) { + ^bb0(%x: f64): + %c3 = arith.constant 3.0 : f64 + %tripled = arith.mulf %x, %c3 : f64 + linalg.yield %tripled : f64 + } -> tensor<50xf64> + + // Scatter Y back using stride_y + %Y_updated = polygeist.submapInverse(%Y_tensor, %Y_result, %stride_y, %c50) + {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (tensor<300xf64>, tensor<50xf64>, index, index) -> tensor<300xf64> + + // Scatter X back using stride_x + %X_updated = polygeist.submapInverse(%X_tensor, %X_result, %stride_x, %c50) + {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (tensor<200xf64>, tensor<50xf64>, index, index) -> tensor<200xf64> + + // Convert and copy both + %Y_final = bufferization.to_memref %Y_updated : memref<300xf64> + %X_final = bufferization.to_memref %X_updated : memref<200xf64> + + memref.copy %Y_final, %Y : memref<300xf64> to memref<300xf64> + memref.copy %X_final, %X : memref<200xf64> to memref<200xf64> + + return +} +``` + +**Key points:** +- Each modified array needs its own `submapInverse` +- Each uses its own stride and map +- Read-only arrays (inputs only) don't need `submapInverse` + +--- + +## After Bufferization: Final Optimized Code + +The good news: After running **one-shot bufferization**, all the tensor operations and conversions get optimized away! + +### Before One-Shot Bufferization + +```mlir +func.func @example(%A: memref<100xf64>, %stride: index) { + %c50 = arith.constant 50 : index + %c2 = arith.constant 2.0 : f64 + + %A_tensor = bufferization.to_tensor %A : memref<100xf64> + + %A_view = polygeist.submap(%A_tensor, %stride, %c50) + {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (tensor<100xf64>, index, index) -> tensor<50xf64> + + %computed = linalg.generic { + indexing_maps = [affine_map<(d0) -> (d0)>], + iterator_types = ["parallel"] + } outs(%A_view : tensor<50xf64>) { + ^bb0(%a: f64): + %doubled = arith.mulf %a, %c2 : f64 + linalg.yield %doubled : f64 + } -> tensor<50xf64> + + %A_updated = polygeist.submapInverse(%A_tensor, %computed, %stride, %c50) + {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (tensor<100xf64>, tensor<50xf64>, index, index) -> tensor<100xf64> + + %A_final = bufferization.to_memref %A_updated : memref<100xf64> + memref.copy %A_final, %A : memref<100xf64> to memref<100xf64> + + return +} +``` + +### After One-Shot Bufferization + +```mlir +func.func @example(%A: memref<100xf64>, %stride: index) { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c50 = arith.constant 50 : index + %c2 = arith.constant 2.0 : f64 + + // All tensor ops are gone! Direct in-place memref operations + scf.for %i = %c0 to %c50 step %c1 { + // Compute strided index + %idx = arith.muli %i, %stride : index + + // Load from strided position + %val = memref.load %A[%idx] : memref<100xf64> + + // Compute + %doubled = arith.mulf %val, %c2 : f64 + + // Store back to strided position (in-place) + memref.store %doubled, %A[%idx] : memref<100xf64> + } + + return +} +``` + +**What happened:** +- ✅ All tensor operations eliminated +- ✅ Direct in-place memref operations +- ✅ No copies, no allocations +- ✅ Optimal performance - equivalent to hand-written code + +**Further optimization (after loop fusion, vectorization):** + +```mlir +func.func @example(%A: memref<100xf64>, %stride: index) { + %c0 = arith.constant 0 : index + %c50 = arith.constant 50 : index + %c2_vec = arith.constant dense<2.0> : vector<4xf64> + + // Vectorized strided load-compute-store + scf.for %i = %c0 to %c50 step %c4 { + %vec = vector.strided_load %A[%i], %stride : vector<4xf64> + %doubled = arith.mulf %vec, %c2_vec : vector<4xf64> + vector.strided_store %doubled, %A[%i], %stride : vector<4xf64> + } + + return +} +``` + +--- + +## Summary + +### Why submapInverse is Essential + +1. **Solves the scatter problem**: Efficiently scatters contiguous values to strided positions +2. **Preserves semantics**: Maintains high-level information about strided access patterns +3. **Enables optimization**: Allows subsequent passes to recognize and optimize strided operations +4. **Clean abstraction**: Avoids manual scatter loops, reducing verbosity and errors + +### The Complete Transformation Pipeline + +``` +Original memref code (strided in-place operations) + ↓ +LinalgDebufferize (add submap/submapInverse) + ↓ +Tensor-based IR (functional, immutable) + ↓ +Tensor optimizations (fusion, tiling, etc.) + ↓ +One-shot bufferization + ↓ +Optimized memref code (back to in-place operations) + ↓ +Vectorization, lowering + ↓ +Efficient machine code +``` + +### Key Takeaways + +- **`submap`**: Gathers strided elements into contiguous tensor +- **`submapInverse`**: Scatters contiguous tensor back to strided positions +- **`to_memref` + `copy`**: Bridges tensor world back to memref world +- **After bufferization**: All overhead disappears, leaving optimal code + +The debufferization → optimization → rebufferization cycle allows us to apply powerful tensor-level transformations to strided memref operations while maintaining correctness and achieving optimal performance! + diff --git a/agents.md b/agents.md new file mode 100644 index 000000000000..47788bce5822 --- /dev/null +++ b/agents.md @@ -0,0 +1,1268 @@ +# Agent Notes + +## Proxy-App Raising Fixes: miniAMR and HyPar + +- miniAMR direct-source `stencil_calc` no longer fails in `cgeist` on the + local 3-D VLA: + `double work[x_block_size+2][y_block_size+2][z_block_size+2];`. +- Root cause: cgeist created `memref` but passed only one dynamic + size operand to `memref.alloca`, so MLIR verification failed with + "dimension operand count does not equal memref dynamic dimension count". +- Fix: in `tools/cgeist/Lib/clang-mlir.cc`, nested `VariableArrayType` + allocation now walks the array type chain and passes every dynamic dimension + to `memref.alloca`. The miniAMR repro now emits + `memref.alloca(%x, %y, %z) : memref`. +- Current miniAMR status after the fix: `cgeist` succeeds and the raise + pipeline runs, but the result is still `no-linalg+loops+if` because the + source still contains global state, `scf.while`, struct/LLVM loads, and + indirect indexing through AMR metadata. Next step is kernel extraction or + canonicalization of the actual stencil loop body. +- HyPar `LinearADRAdvection` no longer crashes in + `--raise-affine-to-linalg-pipeline`. +- Root cause: `FoldSCFIf` rewrote an `scf.if` with existing scalar results and + lifted branch stores, but erased the old `scf.if` without replacing uses of + the old results. The enclosing `scf.yield` still referenced a destroyed op, + causing MLIR to abort with "operation destroyed but still has uses". +- Fix: in `lib/polygeist/Passes/FoldSCFIf.cpp`, map each old `scf.if` result to + the corresponding new `scf.if` result before erasing the old op. +- Current HyPar status after the fix: the full proxy probe reports + `memref-linalg+loops+if` with 6 `linalg.generic` ops. +- Latest full proxy probe summary is in `/tmp/proxy_app_raise_mlir/summary.txt`. + +## cgeist Whisper/GGML Debugging Focus + +- Do not spend debugging time on C++ / STL-heavy Whisper translation units for + the current kernel-raising work. +- Treat files such as `whisper.cpp`, `gguf.cpp`, `ggml-backend-meta.cpp`, + `ggml-backend-reg.cpp`, `ggml-backend.cpp`, `ggml-threading.cpp`, and other + libstdc++/STL-heavy `.cpp` files as out of scope unless the user explicitly + asks to resume C++ frontend work. +- Prefer C files and kernel-relevant code paths that are closer to the paper's + linalg raising / kernel matching story: + - `third_party/whisper.cpp/ggml/src/ggml.c` + - `third_party/whisper.cpp/ggml/src/ggml-quants.c` + - `third_party/whisper.cpp/ggml/src/ggml-alloc.c` + - `third_party/whisper.cpp/examples/stb_vorbis.c` + - `third_party/whisper.cpp/tests/test-c.c` +- For timeout-heavy full translation units, prefer function-level selection or + extracted kernels over `--function='*'`. +- Keep C++/STL fixes already made recorded, but do not use them as the main + success criterion for the CGO/kernel ISA narrative. + +## C-File Timeout Triage Notes + +- `ggml-quants.c` has a large frontend baseline because `GGML_COMMON_IMPL_C` + pulls huge IQ lookup/grid tables from `ggml-common.h`; Clang syntax checking + alone takes about 19 seconds. Do not classify simple quant/dequant kernels as + failed with a 20-second timeout. Use a 60-120 second bound for targeted + functions. +- Simple quant kernels such as `quantize_row_q4_0_ref` do compile when given + enough budget. IQ table initialization helpers such as `iq2xs_init_impl` and + likely `iq3xs_init_impl` are true timeout suspects and are not representative + linalg/kernel-matching targets. +- Sampled `ggml.c` compute/graph functions compile individually + (`ggml_mul_mat`, `ggml_soft_max_ext`, `ggml_rope`, `ggml_conv_1d`, + `ggml_conv_2d`, `ggml_build_forward_impl`). Treat full-file timeouts as + breadth/infrastructure issues unless a specific function is isolated. +- `ggml-alloc.c` slowdowns/timeouts are dominated by recursive MLIR type + expansion in backend/tensor/callback structs, producing 100-200+ MB MLIR + outputs with very few functions. Skip allocator/backend functions for the + kernel-raising story unless ABI/type-opaquing work is explicitly requested. +- `stb_vorbis.c` lower-level decode/math functions compile individually + (`inverse_mdct`, `decode_residue`, codebook decode helpers), while + `stb_vorbis_decode_frame_pushdata` is a true high-level pipeline timeout. + +### Current C Timeout Repros + +- Allocator/backend type expansion repros: + - `issues/ggml_alloc_signature_public_probe.c` + - `issues/ggml_alloc_signature_internal_probe.c` +- `ggml-alloc.c` public-header empty-body signatures emit only 1-2 KB, while + internal-header empty-body signatures emit 8-21 MB in only 6-7 MLIR lines. + This confirms the allocator timeout is recursive internal type expansion, not + allocator loop logic. +- `stb_vorbis.c` packet-present repros: + - `issues/stb_vorbis_packet_present_probe.c` + - `issues/stb_vorbis_sentinel_loop_probe.c` +- The generic sentinel loop compiles. The minimized packet-present timeout is + the cross-page scan loop plus the continued-packet flag branch; `memcmp` alone + is not the trigger. +- `vorbis_decode_packet_rest` still times out with + `STB_VORBIS_NO_INLINE_DECODE`; its major helpers (`decode_residue`, + `inverse_mdct`, `do_floor`, `vorbis_decode_initial`) compile individually. + Treat it as a composed high-level packet pipeline timeout. + +### Timeout Fix Priorities and Kernel Extraction Rule + +- Do not treat all timeouts as one pass failure: + - `ggml-alloc.c` is a recursive internal type expansion / signature printing + problem. Fix by opaquing backend/tensor/callback structs or lowering them + through pointer-style ABI when they are used as handles. + - `ggml-quants.c` simple quant/dequant kernels compile; skip IQ table init + helpers (`iq2xs_init_impl`, `iq3xs_init_impl`) for the current + linalg/kernel-matching story. + - `stb_vorbis.c::is_whole_packet_present` has a minimized loop+flag-branch + lowering repro. This is a compiler/debugging issue, not a useful compute + kernel. + - `vorbis_decode_packet_rest` is a high-level parser/decode pipeline; its + math helpers compile individually, so extract kernels instead of raising the + full composed control-flow body. +- For paper-facing Whisper/GGML experiments, extract the compute kernels that + map to optimized libraries or clean linalg forms: + - vector dot / GEMV-style dot products + - softmax, including max-reduce + exp/sum + normalize + - RMSNorm + - GELU tanh approximation + - 1D convolution as repeated dot products, with full conv1d composition left + as matcher/library future work + - optional Vorbis math kernels such as `decode_residue` and `inverse_mdct`, + but not the pushdata packet parser +- Reuse `third_party/cnn-extracted/whisper_ops.c` and + `scripts/correctness/bake_whisper_ops_mlir.sh` for isolated Whisper kernel + raising. This fixture is the current source-level extraction path for + avoiding C++/STL, SIMD, allocator/backend, and parser pipeline noise. + +### Isolated Whisper Kernel Raise Status + +- Fresh run output: + `/tmp/whisper_ops_mlir_isolated_20260602_211202` +- All extracted kernels in `third_party/cnn-extracted/whisper_ops.c` compile, + raise, and debufferize with multi-root: + - `whisper_vec_dot`: 1 tensor `linalg.generic`, no loops/ifs + - `whisper_vec_softmax`: 1 tensor `linalg.generic`, no loops/ifs + - `whisper_softmax_full`: 3 tensor `linalg.generic`, no loops/ifs + - `whisper_rms_norm`: 2 tensor `linalg.generic`, no loops/ifs + - `whisper_gelu`: 1 tensor `linalg.generic`, no loops/ifs + - `whisper_conv1d`: 1 tensor `linalg.generic` plus one residual loop +- Matcher dry-run works with `/usr/bin/python3` because default `python3` lacks + `egglog`. +- Matcher dry-run reports: + - `whisper_vec_dot` -> `cublasSdot` (dtype-gated; f64 dot uses `cublasDdot`) + - `whisper_vec_softmax` -> `whisperExpShiftSum_f32_tensor` + - `whisper_softmax_full` -> `cudnnSoftmaxForwardOut_tensor` + - `whisper_rms_norm` -> `rmsnorm_unweighted_f32` + - `whisper_gelu` -> `gelu_tanh_f32_tensor` + - `whisper_conv1d` -> inner dot match only; full conv1d composition remains + future matcher/library work +- Original-source probe output: + `/tmp/whisper_original_c_kernel_raise_20260602_211402` + - `quantize_row_q4_0_ref`: raises but produces no linalg, leaves loops/ifs + - `decode_residue`: raise fails on mixed LLVM/memref `llvm.load` + - `inverse_mdct`: selected output has no useful raised function body + +## Proxy App Standalone Kernel Extraction Status + +- Added a standalone extraction suite for the five selected C proxy apps under + `issues/proxy_kernel_extractions/`. +- Source fixture: + `issues/proxy_kernel_extractions/proxy_kernel_extractions.c` +- Runner: + `issues/proxy_kernel_extractions/run_proxy_kernel_extractions.sh` +- Results note: + `issues/proxy_kernel_extractions/RESULTS.md` +- Latest generated MLIR output: + `/tmp/proxy_kernel_extractions_mlir` +- Latest summary: + `/tmp/proxy_kernel_extractions_mlir/summary.txt` +- Coverage: 85 standalone probes. + - `miniAMR`: 13 kernels covering stencil averages, weighted/directional + stencils, material pointwise updates, and halo/block pack/unpack. + - `HPGMG`: 29 kernels covering 7-point/27-point apply, residual, Jacobi, + GSRB, BLAS1, reductions, restriction, interpolation, FV flux, and solver + updates. + - `HyPar`: 28 kernels covering finite derivatives, reconstruction/WENO, + limiters, LinearADR, Burgers, and Euler flux/upwind bodies. + - `SWFFT`: 6 local redistribution, slab, and transpose/layout kernels. + - `ExaSP2`: 9 dense matrix/SP2/trace/AXPBY/SpMV/CG-step kernels. +- 2026-06-04 raising fixes for the remaining standalone proxy issues: + - Fixed `mayAlias` bookkeeping in `lib/polygeist/Ops.cpp`: the second value's + block-argument/noalias state now updates `isArg[1]` and `isNoAliasArg[1]` + instead of accidentally overwriting slot 0. + - Extended `lib/polygeist/Passes/FoldSCFIf.cpp` with a single-store + conditional rewrite. An `scf.if` with one store and no else can now become + `select(condition, candidate, old_output_value)` plus one store. This is + what lets the branchy HPGMG red-black smoother + `hpgmg_gsrb_smooth_7pt` raise to tensor Linalg. + - Added scalar `scf.if` and `affine.if` result folding to selects. The + affine path materializes each integer-set constraint as + `affine.apply + arith.cmpi` and combines them with `arith.andi`. This fixes + the HyPar branch/upwind cases and the previous + `exasp2_normalize_dense` raise failure caused by an `affine.if` reaching a + `linalg.generic` body with `linalg.index` operands. + - Extended store-disjointness checks in + `lib/polygeist/Passes/RaiseToLinalg.cpp`. Multiple stores are now accepted + when they target distinct memrefs, or when affine constant result positions + prove different fixed components of the same memref. This fixes + `hpgmg_cg_update`, `hpgmg_bicgstab_update`, + `hypar_weno_weights_js`, HyPar Euler flux bodies, and + `exasp2_conjugate_gradient_step`. + - Extended the hybrid affine-for raiser so affine self-loads from the exact + same address as the final store become the Linalg `outs` block argument + instead of being preserved as illegal affine loads after `linalg.index` + substitution. This turns `hpgmg_interpolation_p1` into loop-free memref + Linalg. +- Latest run status: + - 0 `cgeist` failures. + - 82 tensor-form Linalg results. + - 2 loop-free memref-form Linalg results: + `hpgmg_interpolation_p1`, `hpgmg_interpolation_p2`. + - 1 memref-form Linalg result with residual loops: + `miniamr_stencil_calc_27`. + - 0 no-Linalg loop/control-flow results. + - 0 raise failures. +- Important successful story: + after stripping app ABI/MPI/BML/solver structs, most regular compute and + local data-layout kernels raise cleanly. This supports the paper point that + extracted kernels can form a useful ISA-like layer plus a fallback Linalg + lowering path. +- Important remaining limitations: + - `miniamr_stencil_calc_27` still leaves the explicit nested 3x3x3 + accumulation loops. It reaches memref Linalg around the outer update, but + the fixed-size inner reduction is not composed into one tensor Linalg body. + - `hpgmg_interpolation_p1` and `hpgmg_interpolation_p2` are loop-free + memref-Linalg, not tensor-Linalg. They keep dynamic coarse-grid + `memref.load` payloads inside the Linalg body, so the current debufferizer + does not tensorize them. + +### Proxy Kernel Correctness Verification + +- 2026-06-04 execution verifier: + `python3 /tmp/proxy_kernel_correctness.py --repo /home/arjaiswal/Polygeist --mlir-dir /tmp/proxy_kernel_extractions_mlir` +- Latest verifier workspace: + `/tmp/proxy_kernel_correctness_1780640949` +- Result after rebuilding `polygeist-opt` and regenerating + `/tmp/proxy_kernel_extractions_mlir`: + - 85/85 standalone proxy probes still reach Linalg structurally. + - 81/85 lower to LLVM, link into the generated C harness, and match the + original C reference output. + - The executable subset reports `SUMMARY failures=0 tests=81` and + `ALL_PROXY_KERNEL_CORRECTNESS_PASS`. +- Four probes are not yet execution-verified because verifier lowering rejects + their current Linalg/submap form: + - `miniamr_stencil_calc_27` + - `miniamr_stencil_27_weighted` + - `hpgmg_apply_op_27pt` + - `hpgmg_interpolation_p0` +- Lowering-blocker details: + - `miniamr_stencil_27_weighted` and `hpgmg_apply_op_27pt` now have the + correct overwrite-reduction seed, but the raised IR still contains no-op + identity `linalg.generic` reductions such as `outs(...) { yield %out }` + over `polygeist.submap` views. These are semantically removable, but the + standard Linalg lowering rejects the reduction-shaped output maps with + "expected the shape-to-loops map to be non-null". + - `miniamr_stencil_calc_27` remains the residual-loop/memref-Linalg case and + still carries a symbol-bearing `polygeist.submap` in the executable + lowering path. + - `hpgmg_interpolation_p0` raises as a 2x2x2 fanout Linalg map into the fine + grid. This is structurally useful but not directly lowerable by standard + Linalg because the output map is not a projected permutation/invertible + shape-to-loop map. +- Verification-time fixes: + - `lib/polygeist/Passes/RemoveIterArgs.cpp`: direct overwrite reductions + (`sum = init; ...; out = sum`) now seed the destination with the iter_arg + init before the rewritten loop. This fixes reductions that previously + accumulated from the old output value, which was only correct for + `out += ...` forms. The helper skips loop-carried region args so nested + accumulator loops are not seeded from enclosing loop-carried values. + - `issues/proxy_kernel_extractions/proxy_kernel_extractions.c`: + `hypar_interp_second_order_muscl` now declares `fC[HL + 3][HNV]`. The old + `HL + 2` bound made the last iteration read `fC[i + 2]` one row past the + array, so the reference C and lowered path compared undefined behavior. + +### Proxy Kernel Matcher Coverage and Operand-Role Lessons + +- 2026-06-05 matcher sweep over `/tmp/proxy_kernel_extractions_mlir/summary.txt` + reached full structural kernel-dialect coverage: + - 85/85 standalone proxy kernels emit at least one `kernel.launch`. + - Total emitted launches: 88. + - Matcher exits: 0 nonzero return codes. + - Latest sweep result file: + `/tmp/proxy_kernel_kernel_match_after_1780674500/results.tsv`. +- Important distinction for the paper/matcher discussion: the same scalar + algebra can differ in operand role, and that determines whether a cuBLAS + call is valid or whether the matcher must emit a separate residual/custom + kernel symbol. +- Example 1, in-place scale vs out-of-place scale: + - Existing `cublasDscal` template correctly matches the in-place form + `x[i] = alpha * x[i]`. + - Linalg body shape for in-place scale: + `yield alpha * Out(0)`. + - HPGMG `scale_vector` is out-of-place: + `out[i] = alpha * in[i]`. + - Linalg body shape for HPGMG: + `yield alpha * In(0)`. + - Plain `cublasDscal` cannot represent this by itself because it mutates one + vector in place. A CUDA lowering would need either `copy(in, out)` followed + by `scal(out)`, or a fused custom elementwise kernel. The matcher therefore + emits a separate semantic symbol, `elemwise_scale_input_1D`, rather than + overclaiming `cublasDscal`. +- Example 2, in-place AXPBY vs two-input AXPBY: + - Existing `_axpby` template matches: + `out[i] = alpha * x[i] + beta * out[i]`. + - Linalg body shape: + `yield alpha * In(0) + beta * Out(0)`. + - HPGMG `add_vectors` and ExaSP2 `axpby` use two separate source vectors: + `out[i] = alpha * x[i] + beta * y[i]`. + - Linalg body shape: + `yield alpha * In(0) + beta * In(1)`. + - The old template should not fire because the second source is not the old + output value. The matcher now emits `elemwise_axpby_inputs_1D` for this + out-of-place/two-input variant. +- 2026-06-05 batched-GEMV-to-GEMM probe: + - Probe source: `issues/gemv_to_gemm_probe.c`. + - Shape tested: + `for b, i: Y[b][i] = 0; for b, i, k: Y[b][i] += X[b][k] * A[i][k]`. + - Mathematically this is a batch of GEMVs, equivalently + `Y = X * A^T`. + - Raised/debufferized IR has two tensor `linalg.generic` ops: + a 2-D zero fill and a contraction with iterator types + `["parallel", "parallel", "reduction"]`. + - Kernel matcher emits: + `memset_zero_2D` followed by `cublasDgemm_simple`. + - This exposed a matcher ordering issue: the alpha-capture GEMM template + could previously match no-alpha GEMM by implicitly binding `alpha = 1`. + Exact no-alpha GEMM/GEMV templates now run before alpha-capture variants, + so no-alpha contractions emit ABI-compatible simple symbols. +- Other matcher-side fixes that made the 85/85 sweep possible: + - Added parser support for egglog pretty-printed `_Term_N = ...` aliases and + trailing constructor commas. Without this, templates that were algebraically + identical, such as `hpgmg_norm` and `hypar_limiter_minmod`, failed because + repeated subexpressions were not inlined before unification. + - Added shape-gated tensor copy symbols for rank-2, rank-3, and rank-6 copy + bodies. The existing `cublasDcopy_tensor` algebra matched some pack/unpack + kernels, but rewrite policy rejected them because the cuBLAS copy ABI was + 1D-only. + - Added exact semantic templates for proxy kernels that are useful as a + kernel-ISA layer: miniAMR 7/27-point stencils, HPGMG apply/residual/smooth/ + restriction/interpolation, HyPar derivatives/limiters/WENO/Euler fluxes, + SWFFT copies/transposes, and ExaSP2 normalize/SP2/CG update kernels. +- Runtime/ABI caveat: + - This is structural kernel-dialect coverage, not full CUDA execution + coverage. + - `kernel_match_rewrite.py` can emit symbols such as + `elemwise_scale_input_1D`, `hypar_weno_weights_js`, or + `hpgmg_gsrb_smooth_7pt_tensor`. + - For actual GPU execution, each emitted symbol still needs a matching + `LowerKernelLaunchToCuBLAS.cpp` lowering case plus a runtime implementation + or decomposition. For example, `elemwise_scale_input_1D` could lower to + `copy + cublasDscal` or to a fused custom CUDA elementwise kernel; until + that ABI/runtime path exists, the IR explorer can show a successful kernel + match but CUDA lowering may still reject or leave the launch unsupported. + +## Proxy Pipeline Fixtures + +### miniAMR Pipeline + +- 2026-06-05 added `issues/proxy_kernel_pipelines/miniamr_pipeline.c`. +- The fixture is one inline pipeline-shaped function, not a call wrapper, so + `--select-func=miniamr_pipeline` sees the loop bodies directly. +- Included loop families: + - halo face pack/unpack + - block pack/unpack + - 7-point average stencil + - 27-point average stencil + - material coupled sum + - pointwise material update + - x/y/z directional stencils + - weighted 7-point stencil + - weighted 27-point stencil +- Latest fixture run: + `/tmp/miniamr_pipeline_1780675056` +- Pipeline fixture result: + - `cgeist` succeeds. + - `--raise-affine-to-linalg-pipeline` produces 16 `linalg.generic` ops. + - The selected raised artifact still has 8 residual loops and 0 ifs. + - Both default and multi-root `--linalg-debufferize` fail. + - Running the matcher on the non-debufferized Linalg artifact emits 6 + launches: four `cublasDcopy`, one `reduce_sum_1D`, and one + `reduce_weighted_sum_1D`. +- Primary composed-pipeline blocker: + - The 27-point average stencil still lowers as outer affine loops containing + a scalar `memref.alloca` accumulator and an inner reduction + `linalg.generic`. + - During debufferization this becomes an invalid tensor/affine region with a + dominance failure: + `operand #0 does not dominate this use`, where the offending operand is the + scalar alloca defined inside the child loop region. + - This is the same structural limitation as isolated + `miniamr_stencil_calc_27`: the fixed 3x3x3 reduction is not collapsed into + one clean tensor Linalg op. +- Secondary matcher issue in the composed fixture: + - Because debufferization fails, most stencil bodies remain memref-form. + - The isolated-kernel matcher templates for miniAMR directional/weighted + stencils are mostly tensor-form symbols, so the non-debufferized pipeline + artifact does not get the same 85/85-style coverage. + - This is not an algebra miss; body inspection shows the same shapes as the + isolated kernels. +- Fresh original-source miniAMR probe: + `/tmp/miniamr_original_probe_1780675165` +- Original `third_party/miniAMR/ref/stencil.c::stencil_calc` result: + - `cgeist` succeeds. + - Raised artifact has 0 `linalg.generic`, 6 loops, 7 ifs, and 152 memref + type mentions. + - The original app function remains worse than the pipeline fixture because + it contains branchy `stencil_in` selection, `scf.while` over + `sorted_index[num_refine+1]`, global block metadata, `blocks[sorted_list]` + indirection, LLVM GEP/load on `block` structs, and `double ****array` + pointer-chasing before reaching the stencil values. + - Problem chain observed in the original miniAMR source: + `global lookup -> struct pointer -> array pointer -> dynamic loop bounds -> + branchy control flow -> temporary VLA -> copy-back loop`. + - Compiler-facing meaning of that chain: + - Global lookup: the useful stencil body is reached through global AMR + state such as sorted block/refinement metadata, not direct kernel + arguments. + - Struct pointer: the selected block is loaded through a `block` struct, + which introduces LLVM GEP/load traffic before the numeric array is + visible. + - Array pointer: the data payload is a pointer-rich layout such as + `double ****array`, so the frontend sees pointer chasing instead of a + simple strided memref. + - Dynamic loop bounds: block dimensions and refinement metadata drive loop + bounds, so the regular stencil extents are not obvious constants at the + kernel boundary. + - Branchy control flow: stencil selection and boundary/control branches + survive as `scf.if`/`scf.while`, blocking the clean affine/linalg shape. + - Temporary VLA: the local work array + `work[x_block_size+2][y_block_size+2][z_block_size+2]` becomes a dynamic + stack allocation. The frontend VLA allocation bug is fixed, but the + remaining temporary still complicates tensorization. + - Copy-back loop: the stencil result is first staged into the temporary and + then copied back, so the useful update is split across producer and + consumer loops rather than appearing as one direct linalg operation. + - This confirms the current paper-facing path should use extracted or + pipeline-shaped kernels for miniAMR, while treating the full original app + as future frontend/control-flow/metadata work. + +### miniAMR Easy Pipeline + +- 2026-06-05 added + `issues/proxy_kernel_pipelines/miniamr_pipeline_easy.c`. +- This is a cleaned, paper-facing miniAMR-style pipeline fixture. It keeps the + relevant pipeline families but removes the original app ABI/control-flow + barriers and the one reduction shape that still trips debufferization: + global block metadata, `double ****` pointer chasing, AMR sorted-list + indirection, branchy stencil selection, and the unweighted local-scalar + 27-point accumulator. +- Included loop families: + - halo face pack/unpack + - block pack/unpack + - 7-point average stencil + - x/y/z directional stencils + - weighted 7-point stencil + - weighted 27-point stencil expressed with a 3x3x3 coefficient tensor + - final pointwise six-input combine +- Latest fixture run: + `/tmp/miniamr_pipeline_easy_1780678211` +- Pipeline result: + - `cgeist` succeeds. + - `--raise-affine-to-linalg-pipeline` produces 14 `linalg.generic` ops. + - Multi-root `--linalg-debufferize` succeeds. + - The debufferized artifact has 14 tensor `linalg.generic` ops, 0 residual + loops, and 0 ifs. + - Kernel matcher dry-run reports 10 matched bodies out of 11 semantic bodies: + two `tensor_copy_2D`, two `tensor_copy_3D`, one + `miniamr_average_7pt_tensor`, three + `miniamr_directional_stencil_tensor`, one + `miniamr_weighted_7pt_tensor`, and one composed + `miniamr_weighted_27pt_tensor` spanning bodies 9-12. + - Rewritten kernel dialect artifact has 10 `kernel.launch` ops. + - The only unmatched body is the final clean 3D pointwise sum of six tensors: + `final = avg7 + dir_x + dir_y + dir_z + weighted7 + weighted27`. +- Interpretation: + - This fixture demonstrates a clean end-to-end route for a miniAMR-style + extracted pipeline: linalg raising, tensor debufferization, and kernel-ISA + matching all work for the stencil/copy pieces. + - The final pointwise combine is a good residual-Linalg example for the paper: + it can be lowered through ordinary Linalg tiling/vectorization/buffering, or + later matched to a small generated elementwise kernel if we want 11/11 + kernel-dialect coverage. + +### Five Easy Proxy Pipelines + +- 2026-06-05 added four more easy composed-pipeline fixtures: + - `issues/proxy_kernel_pipelines/hpgmg_pipeline_easy.c` + - `issues/proxy_kernel_pipelines/hypar_pipeline_easy.c` + - `issues/proxy_kernel_pipelines/swfft_pipeline_easy.c` + - `issues/proxy_kernel_pipelines/exasp2_pipeline_easy.c` +- Together with `miniamr_pipeline_easy.c`, these are the five paper-facing + pipeline fixtures: + - miniAMR: halo/block movement, 7-point and weighted stencils, final + pointwise combine. + - HPGMG: apply-op, residual, Jacobi smoother, restriction, simple + prolongation/injection, CG vector update. + - HyPar: fourth-order derivative, WENO weights/reconstruction, limiter, + upwind flux, reaction/update. + - SWFFT: local pack/unpack, slab movement, and local transposes. + - ExaSP2: dense normalization, dense square/SP2 update, diagonal trace-term + extraction, SpMV, AXPBY, and CG update. +- Latest all-pipeline sweep: + `/tmp/proxy_pipeline_easy_all_1780679229/summary.txt` +- Common result across all five: + - `cgeist` succeeds. + - `--raise-affine-to-linalg-pipeline` succeeds. + - Multi-root `--linalg-debufferize` succeeds. + - Rewriting through `kernel_match_rewrite.py` succeeds. + - Every debufferized pipeline has 0 residual `affine.for`/`scf.for` loops and + 0 residual `affine.if`/`scf.if` branches. +- Final structural/matcher coverage: + - miniAMR: 14 tensor `linalg.generic`, 10 `kernel.launch`, 10/11 semantic + bodies matched. The remaining body is the final six-input pointwise combine + `avg7 + dir_x + dir_y + dir_z + weighted7 + weighted27`. + - HPGMG: 6 tensor `linalg.generic`, 6 `kernel.launch`, 6/6 matched: + `hpgmg_apply_op_7pt_tensor`, `hpgmg_residual_7pt_tensor`, + `hpgmg_jacobi_smooth_7pt_tensor`, `hpgmg_restriction_cell_tensor`, + `tensor_copy_3D`, and `cg_update_3out`. + - HyPar: 7 tensor `linalg.generic`, 5 `kernel.launch`, 5/7 matched: + `derivative_fourth_order`, `hypar_weno_weights_js`, + `hypar_weno_interp5`, `elemwise_avg2`, and `hypar_upwind_var_flux`. + The two residual bodies are: + - composed slope-difference plus minmod limiter, which does not match the + existing standalone minmod template because the slope differences are + computed inside the same body instead of passed as direct inputs. + - final fused reaction plus conservative update, which is a good + residual-Linalg lowering example. + - SWFFT: 6 tensor `linalg.generic`, 6 `kernel.launch`, 6/6 matched. All are + local copy/layout movement bodies (`tensor_copy_2D`/`tensor_copy_3D`) for + pack/unpack/slab/transpose shapes. + - ExaSP2: 10 tensor `linalg.generic`, 9 `kernel.launch`, 9/10 matched: + `exasp2_neg_div`, `elemwise_add_out_scalar_1D`, `memset_zero_2D`, + dense square lowered as `cublasDsyrk_alias`, diagonal trace-term extraction + as `elemwise_scale_input_1D`, `memset_zero_1D`, `cublasDgemv`, + `elemwise_axpby_inputs_1D`, and `cg_update_3out`. The residual body is the + scalar-conditioned SP2 selection: + `x = take_square ? x2 : 2*rho - x2`. +- HPGMG adjustment note: + - An earlier HPGMG version included P2 interpolation and one-element stats + reductions. P2 interpolation is one of the known memref-only Linalg cases, + so it prevented useful tensor-form kernel matching for the composed + pipeline. + - The one-element stats reductions exposed a scalar-output reduction hazard: + in the composed form, the raised reduction body did not use the accumulator + block argument. Keep scalar reductions out of the easy composed fixtures + until that lowering is fixed or verified through the correctness harness. + - The final HPGMG easy fixture therefore uses simple injection/prolongation + and keeps the CG update but leaves scalar norm/dot/mean reductions as a + separate issue. +- ExaSP2 trace adjustment note: + - The first ExaSP2 pipeline used a scalar trace reduction and exposed the same + scalar-output reduction hazard. The current fixture extracts diagonal trace + terms into a vector instead. This keeps the pipeline correct and + tensorizable while leaving scalar trace reduction as a separate fix. + +### Elementwise Semantic Matcher Prototype + +- 2026-06-05 implemented a first semantic-recognition fallback in + `scripts/correctness/kernel_match.py` and + `scripts/correctness/kernel_match_rewrite.py`. +- Design: + - Existing whole-body/multi-step `CompositionEntry` matching still runs first. + - Only previously unmatched all-parallel tensor `linalg.generic` bodies reach + the semantic fallback. + - The fallback normalizes selected lowered scalar trees to semantic + `External`-style nodes in the Python tuple AST, rather than adding egglog + constructors yet. + - This separates semantic recognition from lowering/scheduling: recognizing a + semantic root returns a normal one-body match plan and the existing rewriter + emits a named `kernel.launch`. +- Implemented semantic roots: + - lowered `select/cmp/abs` minmod tree -> + `External("minmod", a, b)`. + - `External("minmod", center-left, right-center)` -> + `hypar_slope_minmod`. + - scalar-conditioned SP2 select + `select(pred, square, 2*current - square)` -> + `exasp2_select_square_inputs`. +- Also added a normal multi-yield composition for HyPar's final fused + reaction/update body: + - `reaction = source - lambda*u` + - `next = u - dt*(flux_r - flux_l) + dt*reaction` + - emitted as `hypar_reaction_update`. +- Rewriter fixes found while validating the semantic path: + - `render_launch` now preserves MLIR multi-result binding syntax, e.g. + `%19:3 = kernel.launch ...`, which is required for bodies like + `hypar_weno_weights_js` and `hypar_reaction_update`. + - `_scan_scalar_types` now records boolean constants printed as + `arith.constant false`/`true` without an explicit `: i1`, avoiding `!any` + in launch signatures for boolean captures. +- Latest semantic all-pipeline sweep: + `/tmp/proxy_pipeline_semantic_all_1780700150/summary.txt` +- Semantic sweep result: + - miniAMR: unchanged, 10/11 matched; the remaining body is the generic final + six-input pointwise combine. + - HPGMG: 6/6 matched. + - HyPar: improved from 5/7 to 7/7 matched. New symbols: + `hypar_slope_minmod` and `hypar_reaction_update`. + - SWFFT: 6/6 matched. + - ExaSP2: improved from 9/10 to 10/10 matched. New symbol: + `exasp2_select_square_inputs`. + - All five still have 0 residual loops and 0 residual ifs after + debufferization. +- Standalone proxy-kernel matcher regression: + `/tmp/proxy_kernel_semantic_match_1780700214/results.tsv` + - 84 current `*_debuf_mr.mlir` files were swept. + - 0 nonzero matcher exits. + - 0 zero-match files. + - 87 total matched bodies. + - 0 `no_match` reports. +- Runtime/ABI caveat: + - These are matcher/rewrite symbols. Jetson execution still needs + `LowerKernelLaunchToCuBLAS.cpp` and runtime/kernel implementations for new + semantic symbols such as `hypar_slope_minmod`, + `hypar_reaction_update`, and `exasp2_select_square_inputs`, or a generic + fused elementwise kernel lowering path. + +### Kernel Runtime Pipeline Scope Pass + +- 2026-06-05 added a first compiler-side hook for avoiding per-kernel runtime + setup when matched kernels appear in a pipeline: + `--wrap-kernel-launch-pipeline`. +- Files added/updated: + - `lib/polygeist/Passes/WrapKernelLaunchPipeline.cpp` + - `include/polygeist/Passes/Passes.td` + - `include/polygeist/Passes/Passes.h` + - `lib/polygeist/Passes/CMakeLists.txt` + - `runtime/polygeist_cublas_rt.h` + - `runtime/polygeist_cublas_rt_cpu.c` + - `runtime/polygeist_cublas_rt_cuda.c` + - `test/polygeist-opt/wrap-kernel-launch-pipeline.mlir` +- Pass behavior: + - Inserts `func.call @polygeist_cublas_pipeline_begin()` at the start of any + non-declaration function containing matched CUDA/cuBLAS/cuDNN runtime shim + calls. + - Inserts `func.call @polygeist_cublas_pipeline_end()` before each + `func.return` in that function. + - Declares the begin/end functions privately if missing. + - Is idempotent: if a function already contains begin/end calls, the pass + leaves it unchanged. + - Recognizes post-lowering calls with prefixes: + `polygeist_cublas_`, `polygeist_cudnn_`, `polygeist_cuda_`, + `polygeist_rmsnorm_`, and `polygeist_whisper_`. + - Also recognizes raw `kernel.launch` ops, but the safest intended placement + is after `--lower-kernel-launch-to-cublas`, so only actually lowered CUDA + runtime calls are scoped. +- Runtime behavior today: + - CPU runtime: begin/end are no-ops. + - CUDA runtime: begin calls `polygeist_cublas_init()` and increments a nesting + depth; end decrements depth and synchronizes the CUDA stream at the + outermost scope. + - This was initially conservative; see the next memory section for the later + runtime-cache/sync update that removes per-shim sync inside an active + pipeline scope. +- Validation: + - `ninja -C build polygeist-opt` passed. + - `gcc -I runtime -c runtime/polygeist_cublas_rt_cpu.c -o + /tmp/polygeist_cublas_rt_cpu.o` passed. + - `build/bin/polygeist-opt --wrap-kernel-launch-pipeline + test/polygeist-opt/wrap-kernel-launch-pipeline.mlir | FileCheck ...` + passed. + - The same test with the pass run twice passed, confirming idempotency. + - Smoke-tested intended placement: + `build/bin/polygeist-opt --lower-kernel-launch-to-cublas + --wrap-kernel-launch-pipeline --split-input-file + test/polygeist-opt/lower-llm-kernel-launches.mlir`. +- Important limitation / next step: + - This pass creates the pipeline scope but does not yet implement true + device-resident tensor dataflow. + - To safely remove per-shim synchronization, either narrow the compiler pass + to provably adjacent shim-only regions or add dataflow analysis proving + there are no host reads of GPU-written buffers inside the scope. + +### Pipeline-Scoped Runtime Cache/Sync Update + +- 2026-06-05 completed the first runtime side of + `--wrap-kernel-launch-pipeline` in `runtime/polygeist_cublas_rt_cuda.c`. +- Runtime behavior inside an active pipeline scope: + - `timing_gpu_end` no longer performs a per-shim + `cudaStreamSynchronize(g_stream)` when `POLYGEIST_RT_TIMING` is disabled. + - If timing is enabled inside a pipeline, it records host enqueue timing only; + per-op device timing is intentionally not collected because that would + require synchronizing every shim and erase the pipeline benefit. + - `DEVICE_MALLOC`/`DEVICE_FREE` now route shim-local `cudaMalloc`/`cudaFree` + through a pipeline-aware temporary-device-buffer cache. + - Freed device temporaries are marked reusable inside the same stream-ordered + pipeline instead of being returned to CUDA immediately. + - Device frees for non-cache pointers encountered inside a pipeline are + deferred until the outermost pipeline-end sync, avoiding an immediate + `cudaFree` synchronization on those paths. + - Temporary host staging buffers that feed async H2D copies are freed through + `pipeline_host_free`; inside a pipeline they are deferred until the + outermost `polygeist_cublas_pipeline_end` synchronization. + - At outermost pipeline end, the runtime synchronizes the stream and flushes + deferred device and host frees. Device temporary buffers stay cached for + reuse across future pipeline scopes and are released in + `polygeist_cublas_destroy`. +- Runtime behavior outside a pipeline scope: + - Allocation/free and synchronization remain conservative, matching previous + per-shim behavior. +- Validation performed locally: + - CPU runtime still compiles: + `gcc -I runtime -c runtime/polygeist_cublas_rt_cpu.c -o + /tmp/polygeist_cublas_rt_cpu.o`. + - `--wrap-kernel-launch-pipeline` FileCheck test still passes. + - `--lower-kernel-launch-to-cublas --wrap-kernel-launch-pipeline` smoke test + on `test/polygeist-opt/lower-llm-kernel-launches.mlir` still produces + begin/end scopes. +- Validation still needed on Jetson/CUDA machine: + - Compile `runtime/polygeist_cublas_rt_cuda.c` with CUDA/cuBLAS/cuDNN headers + and libraries. + - Run llama forward with and without `--wrap-kernel-launch-pipeline`. + - Keep `POLYGEIST_RT_TIMING=0` for the speed test; enabling it intentionally + changes timing behavior and may perturb performance. + +### Jetson Silicon Runner Script Update + +- 2026-06-05 tested and fixed `scripts/correctness/run_jetson.sh`. +- Initial test result: + - `--dry-run --mlir /tmp/run_jetson_smoke_abi.mlir smoke` worked, but showed + the stale default route `nvidia@jetson-orin` with a forced bounce through + `arjaiswal@10.176.207.72`. + - Even with `POLYGEIST_JETSON_HOST=enmity` and + `POLYGEIST_JETSON_USER=ubuntu`, the old script still printed the bounce + route because `ST_TRACKER_DEV_HOST` defaulted internally. +- Script fixes: + - Added direct SSH/SCP mode when `ST_TRACKER_DEV_HOST` is unset. + - Kept bounce mode available when `ST_TRACKER_DEV_HOST` is explicitly set. + - Added `--exe [tag]` / `--binary [tag]` mode for arbitrary + prebuilt Jetson/aarch64 executables. + - Broadened explicit-MLIR sanity check from `polygeist_cublas_*` to any + `polygeist_*` runtime shim call, so cuDNN/custom/PVA-style ABI calls are + accepted. + - Added `POLYGEIST_JETSON_RUNS` to run an executable multiple times. + - Added `POLYGEIST_JETSON_LD_LIBRARY_PATH` with a default that includes + `/home//venv/lib/python3.12/site-packages/nvidia/cudnn/lib`, needed + on `ubuntu@enmity` because `libcudnn.so.9` is installed in the Python + package path, not the default linker path. + - Cleaned the accelerator status probe to fall back cleanly from `nvidia-smi` + to `tegrastats` on Jetson. +- Validation: + - `bash -n scripts/correctness/run_jetson.sh` passed. + - Built `/tmp/jetson_smoke` with `aarch64-linux-gnu-gcc`. + - Real silicon smoke run passed: + `POLYGEIST_JETSON_HOST=enmity POLYGEIST_JETSON_USER=ubuntu + POLYGEIST_JETSON_RUNS=1 scripts/correctness/run_jetson.sh --exe + /tmp/jetson_smoke jetson_smoke`. + - The smoke run staged to `/tmp/polygeist_jetson_runs/...`, printed + `polygeist jetson smoke ok`, and exited 0. +- Llama/CUDA blocker discovered: + - The Llama suffix binaries built successfully locally for Jetson: + `/tmp/llama_pipeline_scope_20260605_172506/llama_suffix_baseline` + and `/tmp/llama_pipeline_scope_20260605_172506/llama_suffix_wrapped`. + - Running the CUDA binary on `ubuntu@enmity` aborts in CUDA initialization: + `cuda error: no CUDA-capable device is detected`. + - Independent C runtime check on the Jetson also reports: + `cudaGetDeviceCount err=100 name=no CUDA-capable device is detected`. + - Therefore the runner is fixed, but this Jetson currently cannot execute + CUDA workloads until its CUDA driver/device visibility issue is resolved. + +### Proxy Five-Pipeline Raised Build/Silicon Fixes + +- 2026-06-06 fixed the target=Jetson build/run path for the five proxy C + pipelines: + - `issues/proxy_kernel_pipelines/miniamr_pipeline_easy.c` + - `issues/proxy_kernel_pipelines/hpgmg_pipeline_easy.c` + - `issues/proxy_kernel_pipelines/hypar_pipeline_easy.c` + - `issues/proxy_kernel_pipelines/swfft_pipeline_easy.c` + - `issues/proxy_kernel_pipelines/exasp2_pipeline_easy.c` +- Key lowering fixes in `lib/polygeist/Passes/LowerPolygeistSubmap.cpp`: + - Added constant-stride tensor submap lowering, covering HPGMG coarse/fine + maps like `(d0, d1, d2) -> (2*d0 + c0, 2*d1 + c1, 2*d2 + c2)`. + - Added row-major flatten/unflatten lowering using + `tensor.expand_shape`/`tensor.collapse_shape` with static shape casts, + covering MiniAMR/SWFFT maps like + `(d0,d1,d2) -> d2 + d0*stride0 + d1*stride1`. + - Fixed inverse submap size handling in the pass: for + `polygeist.submapInverse`, use `map.getNumDims()` view sizes rather than + the result/base rank. The generated op accessor currently reports only + result-rank sizes, which broke flatten inverse maps. + - Added a materialized linalg fallback for rank-expanding tensor submaps that + are legal linalg indexing maps but not slices, notably MiniAMR's 27-point + sliding-window view `grid[i+di][j+dj][k+dk]`. + - Added lowering for rank-expanding projection inverses by extracting the + first slice along ignored dimensions. This handles the identity-init + scaffolding generated around MiniAMR's temporary higher-rank views. +- Runtime/build fixes: + - Added `runtime/polygeist_mlir_runner_utils.c`, a small C implementation of + MLIR's `memrefCopy(int64_t elemSize, unranked_memref *src, *dst)` ABI. + This is needed when residual `memref.copy` lowers through MLIR's runner + utility call, especially for MiniAMR/HPGMG/SWFFT pack/copy stages. + - Updated `scripts/correctness/polygeist_build.sh` to compile and link + `polygeist_mlir_runner_utils.o` for both host and Jetson targets. + - Updated the harness compile in `polygeist_build.sh` to `-O0 + -fno-inline -fno-inline-functions`. This prevents the smoke harness from + optimizing around an included kernel definition that is later replaced by + the generated wrapper. Without this, the optimized SWFFT smoke binary + segfaulted on Jetson in `checksum_1d` with an invalid pointer (`x0 = 0x4`), + while the lowered SWFFT implementation itself passed under an O0/debug + harness. +- Matcher/build policy retained: + - Unsupported semantic matches are rejected by the ABI allowlist in + `scripts/correctness/kernel_match_rewrite.py` and left as residual Linalg + instead of emitting `kernel.launch` symbols without lowering/runtime + support. + - Final target=Jetson build coverage: + - MiniAMR: 0 ABI-lowerable launches, residual Linalg lowered and linked. + - HPGMG: 0 ABI-lowerable launches, residual Linalg lowered and linked. + - HyPar: 0 ABI-lowerable launches, residual Linalg lowered and linked. + - SWFFT: 0 ABI-lowerable launches, residual Linalg lowered and linked. + - ExaSP2: 4 ABI-lowerable launches, 4 runtime shim calls emitted. +- Final validation: + - `cmake --build build --target polygeist-opt -j$(nproc)` passed after the + pass changes. + - `bash -n scripts/correctness/polygeist_build.sh` passed. + - `runtime/polygeist_mlir_runner_utils.c` compiled for host and aarch64: + `cc -O2 -c ...` and `aarch64-linux-gnu-gcc -O2 -c ...`. + - Final build root: + `/tmp/proxy_pipeline_final_20260606_023215`. + - All five final aarch64 executables built: + `miniamr_raised`, `hpgmg_raised`, `hypar_raised`, `swfft_raised`, + `exasp2_raised`. + - Final silicon smoke root: + `/tmp/proxy_pipeline_final_silicon_20260606_023343`. + - All five final binaries ran on the Jetson through + `scripts/correctness/run_jetson.sh --exe` and matched the known CPU + reference checksums: + - `miniamr 49.901192783357` + - `hpgmg 5.626727135200` + - `hypar 15.654281386856` + - `swfft -0.483973000000` + - `exasp2 13.101903706667` + - `total 83.800132012080` +- Remaining technical caveat: + - This proves buildability and correctness on silicon for the five proxy + pipelines. It is not a performance claim for MiniAMR/HPGMG/HyPar/SWFFT, + since those four currently run as residual Linalg/CPU-loop lowers in this + conservative ABI-lowerable flow. ExaSP2 is the only one in this final sweep + with lowered runtime shim calls. + +### MiniAMR 27-Point cuDNN 3D Convolution Lowering + +- 2026-06-06 added ABI support for the constant/shared-filter 3D ntap + convolution subset exposed by MiniAMR's raised 27-point weighted stencil. +- Matcher change: + - `scripts/correctness/kernel_match_rewrite.py` now treats the recognized + `miniamr_weighted_27pt_tensor` four-step composition as a concrete + `cudnnConvolution3D_ntap_tensor` / `_f32_tensor` launch when the last + reduction consumes: + - a rank-3 coefficient/filter tensor, + - a rank-6 `polygeist.submap` window whose trailing three dimensions are a + constant odd filter width, and + - a rank-3 dense output tensor. + - The rewrite recovers the haloed rank-3 input base from the rank-6 window + submap and emits `kernel.launch @cudnnConvolution3D_ntap_tensor(input, + output, weights, K) -> output`. +- ABI/lowering/runtime change: + - Added `kernel.defn` declarations for `cudnnConvolution3D_ntap_tensor` and + `cudnnConvolution3D_ntap_f32_tensor` in + `generic_solver/kernel_library_phase2.mlir`. + - Added `LowerKernelLaunchToCuBLAS.cpp` lowering to runtime shims + `polygeist_cudnn_conv3d_ntap_f64` / `_f32`, passing explicit + `inD, inH, inW, outD, outH, outW, K, W*, A*, B*`. + - Added CPU reference loops and CUDA/cuDNN NCDHW runtime implementations in + `runtime/polygeist_cublas_rt_{cpu,cuda}.c`. +- Validation performed: + - Rebuilt `build/bin/polygeist-opt` successfully with `ninja -C build + polygeist-opt`. + - MiniAMR host build now reports `matched 1 kernel.launch op(s)` and + `emitted 1 func.call to runtime shim`. + - Host smoke run of `/tmp/miniamr_conv3d_host` matched the previous checksum: + `miniamr 49.901192783357`, total `83.800132012080`. + - Jetson aarch64 cross-build `/tmp/miniamr_conv3d_jetson` linked + successfully and also emitted one lowered runtime call. + - Jetson silicon smoke using + `scripts/correctness/run_jetson.sh --exe /tmp/miniamr_conv3d_jetson + miniamr_conv3d_smoke` passed with exit code 0. Runtime timing confirmed the + new cuDNN path executed: + `POLYGEIST_RT_TIMING op=cudnnConvolution3D_ntap_f64 m=12 n=80 k=27 + host_ms=501.300608 device_ms=62.056961`, with checksum + `miniamr 49.901192783357` and total `83.800132012080`. +- Scope/caveat: + - This fixes the constant-filter 27-point convolution route. It does not make + variable-coefficient stencil pieces standard cuDNN convolutions; those stay + residual Linalg or need generated/custom CUDA kernels. + +### CUDA Library Clones And First cuFFT Integration + +- 2026-06-06 cloned additional CUDA/HPC library sources and samples into + `third_party/` for matcher/runtime expansion: + - `third_party/VkFFT` from `https://github.com/DTolm/VkFFT.git` + (header-oriented FFT library with CUDA backend). + - `third_party/finufft` from `https://github.com/flatironinstitute/finufft.git` + (includes `include/cufinufft.h` for nonuniform FFT). + - `third_party/CUDALibrarySamples` from + `https://github.com/NVIDIA/CUDALibrarySamples.git` (reference examples for + cuFFT/cuSPARSE/cuSOLVER/cuRAND/cuFFTMp/cuSPARSELt). + - `third_party/AMGX` from `https://github.com/NVIDIA/AMGX.git` (sparse + iterative solver library, useful for HPGMG/CG future directions). + - Pre-existing local libraries retained: + `third_party/cutlass` and `third_party/cuda_headers/cuda_cccl`. +- Installed the CUDA 12.6 cross-SBSA dev packages needed to compile/link + against more NVIDIA binary libraries locally: + - `libcufft-cross-sbsa-12-6` + - `libcusparse-cross-sbsa-12-6` + - `libcusolver-cross-sbsa-12-6` + - Verified headers/libs now exist under + `/usr/local/cuda-12.6/targets/sbsa-linux/include` and `lib/stubs`, including + `cufft.h`, `cusparse.h`, `cusolverDn.h`, `libcufft.so`, + `libcusparse.so`, and `libcusolver.so`. + - `apt-get` returned a nonzero status because of an unrelated pre-existing + `shim-signed` postinstall failure (`/var/lib/grub/esp` missing + `/dev/sda1`). The CUDA packages themselves are installed (`dpkg -l` shows + `ii` for all three). +- First runtime integration added for cuFFT: + - Added runtime ABI declarations: + `polygeist_cufft_z2z_1d(int32_t N, int32_t inverse, const double *A, + double *B)` and `polygeist_cufft_c2c_1d(...)`. + - Complex values are represented as interleaved real/imag pairs: + `A[2*i+0]`, `A[2*i+1]`. + - CPU runtime has an O(N^2) DFT fallback with cuFFT-compatible signs and + unnormalized inverse semantics. + - CUDA runtime includes guarded `cufft.h` support and uses `cufftPlan1d`, + `cufftSetStream`, `cufftExecZ2Z`, and `cufftExecC2C` when the cuFFT dev + headers are present. + - `scripts/correctness/polygeist_build.sh` now links Jetson target binaries + with `-lcufft -lcusparse -lcusolver` in addition to existing + cuDNN/cuBLAS/CUDA runtime libraries. +- Kernel-launch lowering support added: + - New library defs in `generic_solver/kernel_library_phase2.mlir`: + `@cufftZ2Z_1D_tensor` and `@cufftC2C_1D_tensor`, using + `tensor` / `tensor` interleaved complex layout. + - `LowerKernelLaunchToCuBLAS.cpp` maps those symbols to + `polygeist_cufft_z2z_1d` / `polygeist_cufft_c2c_1d` and lowers launch + operands `(input, output, inverse)` to shim args `(N, inverse, A*, B*)`. + - Added `test/polygeist-opt/lower-kernel-launch-cufft.mlir`; manual run of + `polygeist-opt --lower-kernel-launch-to-cublas` lowers both launch symbols + to the expected runtime calls. +- Validation: + - `ninja -C build polygeist-opt` passed after the lowering changes. + - `cc -O2 -D_POSIX_C_SOURCE=199309L -I runtime -c + runtime/polygeist_cublas_rt_cpu.c` passed. + - `aarch64-linux-gnu-gcc -O2 -I/usr/local/cuda-12.6/targets/sbsa-linux/include + -I/usr/include/aarch64-linux-gnu -c runtime/polygeist_cublas_rt_cuda.c` + passed. + - Added `issues/cufft_runtime_smoke.c` to directly test the new ABI. + - Host smoke using CPU fallback passed with `cufft_runtime_smoke ok`. + - Jetson silicon smoke using + `scripts/correctness/run_jetson.sh --exe /tmp/cufft_runtime_smoke_jetson + cufft_runtime_smoke` passed with exit code 0. Runtime timing confirmed + actual cuFFT execution: + `POLYGEIST_RT_TIMING op=cufftZ2Z_1D m=4 n=1 k=1 ...` and + `POLYGEIST_RT_TIMING op=cufftC2C_1D m=4 n=1 k=1 ...`. + +### cuFFT Matcher For Raised Direct DFT + +- 2026-06-06 added first matcher route from raised Linalg DFT code to cuFFT. +- Added extracted FFT/DFT fixture: + - `issues/fft_dft1d_extracted.c` + - `issues/fft_dft1d_harness.c` + - The cleanly raised matcher target is + `fft_dft1d_z2z_forward_interleaved`, which uses interleaved complex layout + `double out[N][2]`. +- Raising observations: + - The scalar-accumulator DFT form + `fft_dft1d_z2z_forward` raises into a nested affine/linalg form that fails + dominance verification during the raise pipeline. + - The two-scalar-slice accumulation form + `fft_dft1d_z2z_forward_inplace_accum` raises, but the residual tensor IR + only reinserts one of the two multi-result slices. This is not a good + residual path. + - The interleaved-output form raises cleanly to: + - one full `tensor` zeroing linalg.generic, + - one DFT reduction linalg.generic over `(k, component, n)`, with + `math.cos`, `math.sin`, and an `arith.select` selecting real vs imaginary + contribution, + - one final `tensor.insert_slice` into the output tensor. +- Matcher changes: + - Added `_is_dft1d_z2z_body` in `scripts/correctness/kernel_match.py`. + - Added `_cufft_z2z_1d_tensor` composition: zero full complex tensor + + special direct-DFT reduction. + - The predicate is intentionally narrow: two input component slices, one + output, two parallel dims, one reduction dim, `math.cos`, `math.sin`, + `arith.cmpi eq`, `arith.select`, and the expected DFT arithmetic markers. +- Rewriter changes: + - Added custom cuFFT rewrite in `scripts/correctness/kernel_match_rewrite.py` + that replaces the zero+DFT generics plus trailing `tensor.insert_slice` + with one full-tensor `kernel.launch`. + - The rewrite recovers the input base tensor from real/imag + `tensor.extract_slice` operands and passes the original output tensor as + the cuFFT destination. + - It preserves the static complex lane dimension by normalizing to + `tensor` / `tensor`, not all-dynamic `tensor`. + - It detects forward vs inverse from the sign of the captured `2*pi` + constant and passes an `i32` inverse flag to the runtime. +- Validation: + - `python3 -m py_compile scripts/correctness/kernel_match.py + scripts/correctness/kernel_match_rewrite.py` passed. + - Dry-run on the raised fixture reports: + `match body#[0, 1] cufftZ2Z_1D_tensor`. + - Rewritten MLIR contains: + `kernel.launch @cufftZ2Z_1D_tensor(%1, %0, %inverse)`. + - `polygeist-opt --lower-kernel-launch-to-cublas` lowers this to: + `call @polygeist_cufft_z2z_1d`. + - Full host build via `scripts/correctness/polygeist_build.sh` emitted + `matched 1 kernel.launch op(s)` and `emitted 1 func.call to runtime shim`; + `/tmp/fft_dft1d_host` passed with `fft_dft1d_interleaved ok`. + - Full Jetson build `/tmp/fft_dft1d_jetson` linked successfully. + - Jetson silicon smoke using + `scripts/correctness/run_jetson.sh --exe /tmp/fft_dft1d_jetson + fft_dft1d_cufft_match` passed with exit code 0 and confirmed real cuFFT + execution: + `POLYGEIST_RT_TIMING op=cufftZ2Z_1D m=4 n=1 k=1 ...`. +- Scope/caveat: + - This is a semantic direct-DFT-to-cuFFT matcher for raised Linalg, not a + general Cooley-Tukey FFT recognizer yet. + - The current SWFFT proxy pipeline still only contains redistribution, + slab copy, and transpose kernels; it does not include the FFT computation + itself. This matcher is ready for extracted SWFFT local FFT stages once + those are isolated in C. + +### Semantic Candidate Planner For Kernel Matching + +- 2026-06-06 added the first explicit semantic-candidate enumeration layer, + inspired by the Leo discussion about separating semantic recognition from + backend lowering/scheduling. +- New matcher-side data/API in `scripts/correctness/kernel_match.py`: + - `SemanticCandidate` records one possible interpretation of a raised + Linalg body: + - `name` + - `body_indices` + - `match_kind` (`whole`, `composition`, `subterm`, or `completion`) + - `coverage` (`whole` or `partial`) + - `bindings` + - optional `defaults`, `subterm_path`, and `source` + - `composition_semantic_candidates(...)` tries every registered + `CompositionEntry` at a body index instead of returning only the first + greedy match. + - `elementwise_semantic_candidates(...)` walks scalar subexpressions and + reports semantic nodes such as minmod/slope-minmod even when the known + semantic kernel is only a subterm of a larger elementwise body. + - `enumerate_semantic_candidates(...)` combines whole/composition matches, + subterm semantic nodes, and completion/specialization candidates. +- First completion rule: + - A whole-body `miniamr_average_7pt_tensor` match now also produces a + candidate `conv3d_sparse_3x3x3`. + - The completion explicitly records defaults: + `missing_filter_taps = 20 zeros`, + `nonzero_filter_taps = center + six axial neighbors`, + `tap_scale = 1/7`. + - This is the architecture hook for mapping a 7-point 3D average stencil to + cuDNN 3D convolution by materializing a sparse 3x3x3 filter. It is not + emitted yet; current default rewriting still leaves the 7-point average as + residual Linalg. +- Rewriter-side diagnostic support in + `scripts/correctness/kernel_match_rewrite.py`: + - Added `--dry-run --show-candidates`. + - Normal build/rewrite behavior is unchanged unless `--show-candidates` is + passed. + - Candidate reports distinguish: + - exact ABI-lowerable names, + - semantic-only nodes, + - backend candidates where a semantic node can be routed through a + different backend symbol later. + - Current backend hints: + - `miniamr_weighted_27pt_tensor -> cudnnConvolution3D_ntap_tensor` + - `conv3d_sparse_3x3x3 -> cudnnConvolution3D_ntap_tensor` +- Validation: + - `/usr/bin/python3 -m py_compile scripts/correctness/kernel_match.py + scripts/correctness/kernel_match_rewrite.py` passed. + - `kernel_match_rewrite.py /tmp/tmp.2tmoPtgkRE/linalg.mlir --dry-run + --show-candidates` reports both: + - `miniamr_average_7pt_tensor` as the direct semantic match, and + - `conv3d_sparse_3x3x3` as a completion/backend candidate with 20 zero + default taps. + - Five proxy pipeline candidate sweep: + - MiniAMR: 10 selected semantic matches / 20 report entries, + 15 candidates, including the sparse 3D conv completion and the existing + 27-point cuDNN3D backend candidate. + - HPGMG: 6 selected semantic matches / 12 report entries, 7 candidates. + - HyPar: 7 selected semantic matches / 14 report entries, 7 candidates. + - SWFFT: 6 selected semantic matches / 12 report entries, 12 candidates. + - ExaSP2: 10 selected semantic matches / 16 report entries, + 15 candidates. + - Default host builds still behave as before: + - MiniAMR emits 1 `kernel.launch` and 1 runtime shim. + - ExaSP2 emits 4 `kernel.launch` ops and 4 runtime shims. + - Both host smoke binaries produce the unchanged checksum set: + `miniamr 49.901192783357`, `hpgmg 5.626727135200`, + `hypar 15.654281386856`, `swfft -0.483973000000`, + `exasp2 13.101903706667`, `total 83.800132012080`. + +### Kernel Definitions As The ISA: Matcher Design Clarification + +- 2026-06-06 discussion outcome: the stronger design is not to make + semantic-only labels the main compiler result. The useful abstraction is: + **library/kernel definitions are the ISA**. +- Current semantic-only labels such as `miniamr_average_7pt_tensor`, + `hypar_weno_interp5`, or `cg_update_3out` are useful as debugging/evaluation + annotations, but they are weak as compiler targets when they were designed + one-to-one by observing benchmark bodies and do not have a backend route. +- The desired matcher result should be a match against a real kernel + definition with an implementation path: + - vendor library definitions, e.g. cuBLAS GEMM/GEMV, cuDNN convolution, + cuFFT FFT; + - custom optimized kernel definitions, e.g. a custom CUDA minmod or stencil + kernel once such runtime/lowering support exists; + - residual Linalg only for unmatched leftovers. +- Revised flow: + - Raise C to Linalg. + - Encode each Linalg body plus Linalg context: iterator types, indexing + maps/subviews, dtype, rank/layout, constants, aliases. + - Match against registered kernel/library definitions, not benchmark-only + labels. + - Allow generalized matching modes under one matcher: + - exact whole-body match, + - specialization/default completion, e.g. missing convolution taps become + explicit zero weights, omitted RMSNorm weight becomes one, beta defaults + to zero, etc., + - subterm/partial match, e.g. recognize `minmod(a,b)` inside a larger + elementwise expression and then decide whether to split/lower it. + - Produce a candidate list containing only backend-capable or potentially + backend-capable matches for actual rewriting/planning. + - Select a non-overlapping set of matches using legality and cost: + backend availability, coverage, number of materializations, fusion loss, + data residency, target hardware, and expected performance. +- Example: MiniAMR 7-point average should not primarily become a semantic + label `miniamr_average_7pt_tensor`. It should match the generic + `conv3d_ntap`/`cudnnConvolution3D_ntap_tensor` kernel definition by + completing a sparse 3x3x3 filter: + - center and six axial neighbor taps are `1/7`; + - the other 20 taps are explicit zero defaults. +- Example: HyPar minmod should not primarily become `hypar_slope_minmod` + unless that name is backed by a real implementation. The useful target is a + library/custom-kernel definition such as `external_elementwise_minmod(a,b)` + only once there is a custom CUDA or other backend lowering for it. +- Paper framing: + - Linalg raising exposes algebraic loop bodies and tensor access structure. + - Optimized kernels are treated as an ISA. + - The matcher maps raised Linalg fragments to that ISA using equality, + specialization/defaults, and subexpression matching. + - Matched ISA nodes lower to vendor libraries or custom optimized kernels. + - Unmatched residual Linalg lowers through standard MLIR codegen, retaining a + systematic path for code that does not map to a library definition. +- Follow-up implementation adjustment: + - `kernel_match_rewrite.py --dry-run --show-candidates` now reports only + backend-capable kernel-definition candidates by default. + - Semantic-only labels are no longer reported as ordinary candidates. They + can still be inspected explicitly with `--show-semantic-only` for debug or + evaluation bookkeeping. + - Report labels now distinguish: + - `kernel_candidate`: a direct ABI-lowerable definition or a semantic + completion with a declared backend route; + - `semantic_debug`: a semantic-only match with no current backend route. + - MiniAMR candidate report now shows only: + - `conv3d_sparse_3x3x3`, a completion candidate routed to + `cudnnConvolution3D_ntap_tensor`; + - `miniamr_weighted_27pt_tensor`, routed to + `cudnnConvolution3D_ntap_tensor`. + - ExaSP2 candidate report shows backend-capable candidates for zeroing, + GEMM, and GEMV; duplicate same-body alternatives such as + `cublasDgemm_simple` vs `cublasDgemm_alpha_only` are still visible for the + future planner/cost model to choose between. + - HPGMG, HyPar, and current SWFFT proxy reports have zero backend-capable + candidates in the default view because their current recognitions do not + yet have real backend definitions/lowerings. + +### Custom CUDA 7-Point Stencil Library + +- 2026-06-06 added and wired a standalone custom CUDA library directory: + `custom_library/cuda`. +- Added: + - `custom_library/cuda/polygeist_stencil3d_7pt.h` + - `custom_library/cuda/polygeist_stencil3d_7pt.cu` + - `custom_library/cuda/README.md` +- The exported C ABI has f64/f32 structured launch wrappers: + - `polygeist_custom_stencil3d_7pt_f64` + - `polygeist_custom_stencil3d_7pt_f32` +- It also has flat f64/f32 device launchers used by the current + compiler/runtime ABI after the runtime shim maps pointers: + - `polygeist_custom_stencil3d_7pt_flat_f64_device` + - `polygeist_custom_stencil3d_7pt_flat_f32_device` +- The structured wrappers are device-pointer based and stride-aware. The flat + device launchers are also device-pointer based: they do not allocate, copy, + or synchronize. The public runtime ABI symbols + `polygeist_custom_stencil3d_7pt_flat_{f64,f32}` live in + `runtime/polygeist_cublas_rt_cuda.c`; they use `register_host_safe` like the + other Jetson CUDA shims, then call the linked custom CUDA device launcher. +- Kernel computation: + - Inputs are an interior `input_center` pointer, optional `extra`, optional + per-cell `coeff`, and output. + - Strides are in elements and can represent halo-backed C arrays or tensor + slices. + - Computation: + `base = base_center * center + base_extra * extra` + `inner = coeff_center * center + coeff_xm*xm + coeff_xp*xp + + coeff_ym*ym + coeff_yp*yp + coeff_zm*zm + coeff_zp*zp + + coeff_extra * extra` + `out = base + (coeff ? coeff[i,j,k] : 1) * inner` +- Intended one-kernel coverage: + - MiniAMR `miniamr_average_7pt_tensor` + - MiniAMR `miniamr_weighted_7pt_tensor` + - HPGMG `hpgmg_apply_op_7pt_tensor` + - HPGMG `hpgmg_residual_7pt_tensor` + - HPGMG weighted-Jacobi-style smoother + - PolyBench-style 3D heat/Jacobi 7-point stencils +- Compiler/runtime integration now complete for MiniAMR f64 tensor 7-point + bodies: + - `generic_solver/kernel_library_phase2.mlir` declares + `customStencil3D7pt_f64_tensor`, + `customStencil3D7ptCoeff_f64_tensor`, and + `customStencil3D7ptExtra_f64_tensor`. + - `scripts/correctness/kernel_match_rewrite.py` emits: + - `miniamr_average_7pt_tensor -> customStencil3D7pt_f64_tensor` + with coefficients `[0, 0, 0, 1/7, ..., 1/7]`; + - `miniamr_weighted_7pt_tensor -> customStencil3D7ptCoeff_f64_tensor` + with coefficients `[1, 0, 0, -6, 1, 1, 1, 1, 1, 1]`. + - `lib/polygeist/Passes/LowerKernelLaunchToCuBLAS.cpp` lowers those + `kernel.launch` ops to `polygeist_custom_stencil3d_7pt_flat_f64`. + - `runtime/polygeist_cublas_rt_cpu.c` has CPU reference implementations. + - `runtime/polygeist_cublas_rt_cuda.c` has public runtime shims. Each shim + uses the linked custom CUDA `*_device` launcher if present, otherwise falls + back to the CPU reference loop so Jetson binaries still link/run without + the custom object. + - `scripts/correctness/polygeist_build.sh` accepts + `POLYGEIST_CUSTOM_CUDA_OBJ` / `POLYGEIST_CUSTOM_CUDA_OBJS`; a strong CUDA + object overrides the weak fallback at link time. +- Validation: + - `cc -fsyntax-only -I custom_library/cuda -include + polygeist_stencil3d_7pt.h -xc /dev/null` passed. + - `git diff --check -- custom_library/cuda/...` passed. + - `ninja -C build polygeist-opt` passed. + - Host MiniAMR proxy build emitted 3 launches / 3 shim calls and produced + checksum `miniamr 49.901192783357`, `total 83.800132012080`. + - Jetson cross-build without custom object passed; the two 7-point calls ran + through weak fallback and the 27-point call ran through cuDNN. Log: + `scripts/correctness/logs/miniamr_custom7_20260606_212752.silicon.log`. + - Compiled `polygeist_stencil3d_7pt.cu` on Jetson with + `/usr/local/cuda/bin/nvcc` and copied the aarch64 object back to + `/tmp/polygeist_stencil3d_7pt_jetson.o`. + - Earlier Jetson cross-build with the pre-split custom object passed, but + that object overrode the runtime shim and did its own per-call + `cudaMalloc/cudaMemcpy/cudaFree`. This was fixed after the commit by + renaming the custom CUDA exports to `*_device` and moving pointer mapping + back into the runtime shim. +- Remaining optimization: + - 2026-06-07 rebuilt the custom CUDA object on Jetson after the `*_device` + split. New object: + `/tmp/polygeist_stencil3d_7pt_device_jetson.o`. + - Verified the object exports only: + `polygeist_custom_stencil3d_7pt_flat_f64_device` and + `polygeist_custom_stencil3d_7pt_flat_f32_device`; it no longer exports the + public runtime shim symbol. + - Cross-built MiniAMR with + `POLYGEIST_WRAP_KERNEL_PIPELINE=1` and + `POLYGEIST_CUSTOM_CUDA_OBJ=/tmp/polygeist_stencil3d_7pt_device_jetson.o`. + The ABI MLIR had exactly one scoped sequence: + `polygeist_cublas_pipeline_begin`, two + `polygeist_custom_stencil3d_7pt_flat_f64` calls, one + `polygeist_cudnn_conv3d_ntap_f64` call, then + `polygeist_cublas_pipeline_end`. + - Jetson silicon run passed with checksum + `miniamr 49.901192783357`, `total 83.800132012080`. + Timing labels were `customStencil3D7pt_f64` rather than + `_cpu_fallback`, proving the runtime shim called the custom CUDA device + launcher. Log: + `scripts/correctness/logs/miniamr_custom7_device_20260607_075129.silicon.log`. +- Remaining optimization: + - timing inside a pipeline scope intentionally reports `device_ms=0` because + the runtime does not synchronize per op inside the scope; add aggregate + scope timing if needed for performance reporting. diff --git a/blas/dasum.c b/blas/dasum.c new file mode 100644 index 000000000000..6a5115839be5 --- /dev/null +++ b/blas/dasum.c @@ -0,0 +1,74 @@ +#include +#include +#include + +// DASUM: Sum of absolute values +// result = sum(|x[i]|) +// x: vector of length N with stride incx +double dasum(int N, const double* x, int incx) { + double result = 0.0; + + for (int i = 0; i < N; i++) { + result += fabs(x[i * incx]); + } + + return result; +} + +// Simple version (stride = 1) +double simple_dasum(int N, const double* x) { + double result = 0.0; + + for (int i = 0; i < N; i++) { + result += fabs(x[i]); + } + + return result; +} + +// Single precision version +float sasum(int N, const float* x, int incx) { + float result = 0.0f; + + for (int i = 0; i < N; i++) { + result += fabsf(x[i * incx]); + } + + return result; +} + +void print_vector(const double* x, int N, const char* name) { + printf("%s: [", name); + for (int i = 0; i < N; i++) { + printf("%.1f", x[i]); + if (i < N - 1) printf(", "); + } + printf("]\n"); +} + +int main() { + const int N = 6; + + double x[] = {1.0, -2.0, 3.0, -4.0, 5.0, -6.0}; + + printf("ASUM Test: sum of absolute values\n"); + print_vector(x, N, "x"); + + double result = simple_dasum(N, x); + + printf("\nasum(x) = %.1f\n", result); + + printf("\nManual verification:\n"); + printf("|1.0| + |-2.0| + |3.0| + |-4.0| + |5.0| + |-6.0|\n"); + printf("= 1.0 + 2.0 + 3.0 + 4.0 + 5.0 + 6.0\n"); + printf("= 21.0\n"); + + // Test with stride + printf("\n\nTesting with stride=2 (every other element):\n"); + double result_stride = dasum(3, x, 2); + printf("asum(x[::2]) = %.1f\n", result_stride); + printf("Manual: |%.1f| + |%.1f| + |%.1f| = %.1f\n", + x[0], x[2], x[4], fabs(x[0]) + fabs(x[2]) + fabs(x[4])); + + return 0; +} diff --git a/blas/daxpy.c b/blas/daxpy.c new file mode 100644 index 000000000000..a8f738c6c174 --- /dev/null +++ b/blas/daxpy.c @@ -0,0 +1,78 @@ +#include +#include + +// DAXPY: Constant times a vector plus a vector +// y = alpha * x + y +// x: vector of length N with stride incx +// y: vector of length N with stride incy (modified in place) +// alpha: scaling factor +void daxpy(int N, double alpha, const double* x, int incx, double* y, int incy) { + for (int i = 0; i < N; i++) { + y[i * incy] += alpha * x[i * incx]; + } +} + +// Simple version (stride = 1) +void simple_daxpy(int N, double alpha, const double* x, double* y) { + for (int i = 0; i < N; i++) { + y[i] += alpha * x[i]; + } +} + +// Single precision version +void saxpy(int N, float alpha, const float* x, int incx, float* y, int incy) { + for (int i = 0; i < N; i++) { + y[i * incy] += alpha * x[i * incx]; + } +} + +void print_vector(const double* x, int N, const char* name) { + printf("%s: [", name); + for (int i = 0; i < N; i++) { + printf("%.2f", x[i]); + if (i < N - 1) printf(", "); + } + printf("]\n"); +} + +int main() { + const int N = 5; + const double alpha = 2.0; + + double x[] = {1.0, 2.0, 3.0, 4.0, 5.0}; + double y[] = {10.0, 20.0, 30.0, 40.0, 50.0}; + + printf("AXPY Test: y = alpha * x + y\n"); + printf("alpha = %.2f\n", alpha); + print_vector(x, N, "x"); + print_vector(y, N, "y (before)"); + + // Apply axpy + simple_daxpy(N, alpha, x, y); + + print_vector(y, N, "y (after)"); + + printf("\nManual verification:\n"); + printf("y[0] = 2.0*1.0 + 10.0 = 12.00\n"); + printf("y[1] = 2.0*2.0 + 20.0 = 24.00\n"); + printf("y[2] = 2.0*3.0 + 30.0 = 36.00\n"); + printf("y[3] = 2.0*4.0 + 40.0 = 48.00\n"); + printf("y[4] = 2.0*5.0 + 50.0 = 60.00\n"); + + // Test with stride + printf("\n\nTesting with stride=2:\n"); + double x2[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0}; + double y2[] = {100.0, 200.0, 300.0, 400.0, 500.0, 600.0}; + + printf("x: [1, 2, 3, 4, 5, 6]\n"); + printf("y (before): [100, 200, 300, 400, 500, 600]\n"); + printf("Computing: y[::2] += 10.0 * x[::2]\n"); + + daxpy(3, 10.0, x2, 2, y2, 2); // y[0,2,4] += 10*x[0,2,4] + + printf("y (after): [%.1f, %.1f, %.1f, %.1f, %.1f, %.1f]\n", + y2[0], y2[1], y2[2], y2[3], y2[4], y2[5]); + printf("Expected: [110.0, 200.0, 330.0, 400.0, 550.0, 600.0]\n"); + + return 0; +} diff --git a/blas/dcopy.c b/blas/dcopy.c new file mode 100644 index 000000000000..83ad16677c63 --- /dev/null +++ b/blas/dcopy.c @@ -0,0 +1,76 @@ +#include +#include + +// DCOPY: Copy vector x to vector y +// y = x +// x: source vector of length N with stride incx +// y: destination vector of length N with stride incy +void dcopy(int N, const double* x, int incx, double* y, int incy) { + for (int i = 0; i < N; i++) { + y[i * incy] = x[i * incx]; + } +} + +// Simple version (stride = 1) +void simple_dcopy(int N, const double* x, double* y) { + for (int i = 0; i < N; i++) { + y[i] = x[i]; + } +} + +// Single precision version +void scopy(int N, const float* x, int incx, float* y, int incy) { + for (int i = 0; i < N; i++) { + y[i * incy] = x[i * incx]; + } +} + +void print_vector(const double* x, int N, const char* name) { + printf("%s: [", name); + for (int i = 0; i < N; i++) { + printf("%.1f", x[i]); + if (i < N - 1) printf(", "); + } + printf("]\n"); +} + +int main() { + const int N = 5; + + double x[] = {1.0, 2.0, 3.0, 4.0, 5.0}; + double y[5] = {0.0, 0.0, 0.0, 0.0, 0.0}; + + printf("COPY Test\n"); + print_vector(x, N, "x (source)"); + print_vector(y, N, "y (before)"); + + // Copy x to y + simple_dcopy(N, x, y); + + print_vector(y, N, "y (after)"); + + // Verify + printf("\nVerification: "); + int correct = 1; + for (int i = 0; i < N; i++) { + if (x[i] != y[i]) { + correct = 0; + break; + } + } + printf("%s\n", correct ? "PASS" : "FAIL"); + + // Test with stride + printf("\n\nTesting with stride:\n"); + double src[] = {10.0, 20.0, 30.0, 40.0, 50.0, 60.0}; + double dst[6] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}; + + printf("Source: [10, 20, 30, 40, 50, 60]\n"); + printf("Copying every other element (incx=2) to every position (incy=1):\n"); + dcopy(3, src, 2, dst, 1); // Copy src[0,2,4] to dst[0,1,2] + printf("Result: [%.1f, %.1f, %.1f, %.1f, %.1f, %.1f]\n", + dst[0], dst[1], dst[2], dst[3], dst[4], dst[5]); + printf("Expected: [10.0, 30.0, 50.0, 0.0, 0.0, 0.0]\n"); + + return 0; +} diff --git a/blas/ddot.c b/blas/ddot.c new file mode 100644 index 000000000000..1e599a09cc3a --- /dev/null +++ b/blas/ddot.c @@ -0,0 +1,79 @@ +#include +#include + +// DDOT: Compute dot product of two vectors +// result = sum(x[i] * y[i]) +// x: vector of length N with stride incx +// y: vector of length N with stride incy +double ddot(int N, const double* x, int incx, const double* y, int incy) { + double result = 0.0; + + for (int i = 0; i < N; i++) { + result += x[i * incx] * y[i * incy]; + } + + return result; +} + +// Simple version (stride = 1) +double simple_ddot(int N, const double* x, const double* y) { + double result = 0.0; + + for (int i = 0; i < N; i++) { + result += x[i] * y[i]; + } + + return result; +} + +// Single precision version +float sdot(int N, const float* x, int incx, const float* y, int incy) { + float result = 0.0f; + + for (int i = 0; i < N; i++) { + result += x[i * incx] * y[i * incy]; + } + + return result; +} + +int main() { + const int N = 5; + double x[] = {1.0, 2.0, 3.0, 4.0, 5.0}; + double y[] = {2.0, 3.0, 4.0, 5.0, 6.0}; + + printf("DOT Product Test\n"); + printf("x: ["); + for (int i = 0; i < N; i++) { + printf("%.1f ", x[i]); + } + printf("]\n"); + + printf("y: ["); + for (int i = 0; i < N; i++) { + printf("%.1f ", y[i]); + } + printf("]\n\n"); + + // Test simple version + double result = simple_ddot(N, x, y); + printf("dot(x, y) = %.1f\n", result); + + // Manual verification + double manual = 0.0; + for (int i = 0; i < N; i++) { + manual += x[i] * y[i]; + printf(" %.1f * %.1f = %.1f\n", x[i], y[i], x[i] * y[i]); + } + printf("Expected: %.1f, Actual: %.1f\n\n", manual, result); + + // Test with stride + printf("Testing with stride=2 (every other element):\n"); + double result_stride = ddot(3, x, 2, y, 2); + printf("dot(x[::2], y[::2]) = %.1f\n", result_stride); + printf("Manual: %.1f*%.1f + %.1f*%.1f + %.1f*%.1f = %.1f\n", + x[0], y[0], x[2], y[2], x[4], y[4], + x[0]*y[0] + x[2]*y[2] + x[4]*y[4]); + + return 0; +} diff --git a/blas/dgemm.c b/blas/dgemm.c new file mode 100644 index 000000000000..71509e98c85a --- /dev/null +++ b/blas/dgemm.c @@ -0,0 +1,153 @@ +#include +#include +#include + +// GEMM: C = alpha * A * B + beta * C +// A: M x K matrix with leading dimension LDA +// B: K x N matrix with leading dimension LDB +// C: M x N matrix with leading dimension LDC +void dgemm(char transa, char transb, int M, int N, int K, + double alpha, + const double* A, int LDA, + const double* B, int LDB, + double beta, + double* C, int LDC) { + + // Handle beta scaling first + if (beta == 0.0) { + // Zero out C + for (int i = 0; i < M; i++) { + for (int j = 0; j < N; j++) { + C[i * LDC + j] = 0.0; + } + } + } else if (beta != 1.0) { + // Scale C by beta + for (int i = 0; i < M; i++) { + for (int j = 0; j < N; j++) { + C[i * LDC + j] *= beta; + } + } + } + + // Early return if alpha is zero + if (alpha == 0.0) { + return; + } + + // Handle different transpose cases + if (transa == 'N' && transb == 'N') { + // C = alpha * A * B + beta * C (no transpose) + for (int i = 0; i < M; i++) { + for (int j = 0; j < N; j++) { + double sum = 0.0; + for (int k = 0; k < K; k++) { + sum += A[i * LDA + k] * B[k * LDB + j]; + } + C[i * LDC + j] += alpha * sum; + } + } + } else if (transa == 'T' && transb == 'N') { + // C = alpha * A^T * B + beta * C + for (int i = 0; i < M; i++) { + for (int j = 0; j < N; j++) { + double sum = 0.0; + for (int k = 0; k < K; k++) { + sum += A[k * LDA + i] * B[k * LDB + j]; + } + C[i * LDC + j] += alpha * sum; + } + } + } else if (transa == 'N' && transb == 'T') { + // C = alpha * A * B^T + beta * C + for (int i = 0; i < M; i++) { + for (int j = 0; j < N; j++) { + double sum = 0.0; + for (int k = 0; k < K; k++) { + sum += A[i * LDA + k] * B[j * LDB + k]; + } + C[i * LDC + j] += alpha * sum; + } + } + } else if (transa == 'T' && transb == 'T') { + // C = alpha * A^T * B^T + beta * C + for (int i = 0; i < M; i++) { + for (int j = 0; j < N; j++) { + double sum = 0.0; + for (int k = 0; k < K; k++) { + sum += A[k * LDA + i] * B[j * LDB + k]; + } + C[i * LDC + j] += alpha * sum; + } + } + } +} + +// Simple GEMM (no transpose, alpha=1, beta=0) +void simple_dgemm(int M, int N, int K, + const double* A, int LDA, + const double* B, int LDB, + double* C, int LDC) { + for (int i = 0; i < M; i++) { + for (int j = 0; j < N; j++) { + double sum = 0.0; + for (int k = 0; k < K; k++) { + sum += A[i * LDA + k] * B[k * LDB + j]; + } + C[i * LDC + j] = sum; + } + } +} + +// Single precision version +void sgemm(char transa, char transb, int M, int N, int K, + float alpha, + const float* A, int LDA, + const float* B, int LDB, + float beta, + float* C, int LDC) { + + // Handle beta scaling + if (beta == 0.0f) { + for (int i = 0; i < M; i++) { + for (int j = 0; j < N; j++) { + C[i * LDC + j] = 0.0f; + } + } + } else if (beta != 1.0f) { + for (int i = 0; i < M; i++) { + for (int j = 0; j < N; j++) { + C[i * LDC + j] *= beta; + } + } + } + + if (alpha == 0.0f) return; + + // Only implement N,N case for simplicity + if (transa == 'N' && transb == 'N') { + for (int i = 0; i < M; i++) { + for (int j = 0; j < N; j++) { + float sum = 0.0f; + for (int k = 0; k < K; k++) { + sum += A[i * LDA + k] * B[k * LDB + j]; + } + C[i * LDC + j] += alpha * sum; + } + } + } +} + +// Utility functions +void print_matrix(const double* matrix, int rows, int cols, int LD, const char* name) { + printf("%s (%dx%d with LD=%d):\n", name, rows, cols, LD); + for (int i = 0; i < rows; i++) { + printf("Row %d: [", i); + for (int j = 0; j < cols; j++) { + printf("%8.3f", matrix[i * LD + j]); + if (j < cols - 1) printf(", "); + } + printf("]\n"); + } + printf("\n"); +} diff --git a/blas/dnrm2.c b/blas/dnrm2.c new file mode 100644 index 000000000000..81106405d6f8 --- /dev/null +++ b/blas/dnrm2.c @@ -0,0 +1,85 @@ +#include +#include +#include + +// DNRM2: Euclidean norm (L2 norm) of a vector +// result = sqrt(sum(x[i]^2)) +// x: vector of length N with stride incx +double dnrm2(int N, const double* x, int incx) { + double sum = 0.0; + + for (int i = 0; i < N; i++) { + double val = x[i * incx]; + sum += val * val; + } + + return sqrt(sum); +} + +// Simple version (stride = 1) +double simple_dnrm2(int N, const double* x) { + double sum = 0.0; + + for (int i = 0; i < N; i++) { + sum += x[i] * x[i]; + } + + return sqrt(sum); +} + +// Single precision version +float snrm2(int N, const float* x, int incx) { + float sum = 0.0f; + + for (int i = 0; i < N; i++) { + float val = x[i * incx]; + sum += val * val; + } + + return sqrtf(sum); +} + +void print_vector(const double* x, int N, const char* name) { + printf("%s: [", name); + for (int i = 0; i < N; i++) { + printf("%.1f", x[i]); + if (i < N - 1) printf(", "); + } + printf("]\n"); +} + +int main() { + const int N = 4; + + double x[] = {3.0, 4.0, 0.0, 0.0}; + + printf("NRM2 Test: Euclidean norm (L2 norm)\n"); + print_vector(x, N, "x"); + + double result = simple_dnrm2(N, x); + + printf("\n||x||_2 = %.2f\n", result); + + printf("\nManual verification:\n"); + printf("sqrt(3^2 + 4^2 + 0^2 + 0^2)\n"); + printf("= sqrt(9 + 16 + 0 + 0)\n"); + printf("= sqrt(25)\n"); + printf("= 5.00\n"); + + // Test with unit vector + printf("\n\nTest with unit vector:\n"); + double unit[] = {1.0, 0.0, 0.0}; + print_vector(unit, 3, "unit"); + double norm_unit = simple_dnrm2(3, unit); + printf("||unit||_2 = %.2f (expected: 1.00)\n", norm_unit); + + // Test with stride + printf("\n\nTesting with stride=2:\n"); + double y[] = {3.0, 100.0, 4.0, 200.0, 0.0, 300.0}; + printf("y: [3.0, 100.0, 4.0, 200.0, 0.0, 300.0]\n"); + double result_stride = dnrm2(3, y, 2); + printf("||y[::2]||_2 = %.2f\n", result_stride); + printf("Manual: sqrt(3^2 + 4^2 + 0^2) = sqrt(25) = 5.00\n"); + + return 0; +} diff --git a/blas/dscal.c b/blas/dscal.c new file mode 100644 index 000000000000..b7b98201beef --- /dev/null +++ b/blas/dscal.c @@ -0,0 +1,66 @@ +#include +#include + +// DSCAL: Scale a vector by a constant +// x = alpha * x +// x: vector of length N with stride incx +// alpha: scaling factor +void dscal(int N, double alpha, double* x, int incx) { + for (int i = 0; i < N; i++) { + x[i * incx] *= alpha; + } +} + +// Simple version (stride = 1) +void simple_dscal(int N, double alpha, double* x) { + for (int i = 0; i < N; i++) { + x[i] *= alpha; + } +} + +// Single precision version +void sscal(int N, float alpha, float* x, int incx) { + for (int i = 0; i < N; i++) { + x[i * incx] *= alpha; + } +} + +void print_vector(const double* x, int N, const char* name) { + printf("%s: [", name); + for (int i = 0; i < N; i++) { + printf("%.2f", x[i]); + if (i < N - 1) printf(", "); + } + printf("]\n"); +} + +int main() { + const int N = 5; + const double alpha = 2.5; + + double x[] = {1.0, 2.0, 3.0, 4.0, 5.0}; + + printf("SCAL Test\n"); + printf("alpha = %.2f\n", alpha); + print_vector(x, N, "x (before)"); + + // Apply scaling + simple_dscal(N, alpha, x); + + print_vector(x, N, "x (after)"); + + printf("\nManual verification:\n"); + printf("Expected: [2.50, 5.00, 7.50, 10.00, 12.50]\n"); + + // Test with stride + printf("\n\nTesting with stride=2:\n"); + double y[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0}; + printf("Original: [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]\n"); + dscal(3, 10.0, y, 2); // Scale elements at positions 0, 2, 4 + printf("After scaling every other element by 10:\n"); + printf("Result: [%.1f, %.1f, %.1f, %.1f, %.1f, %.1f]\n", + y[0], y[1], y[2], y[3], y[4], y[5]); + printf("Expected: [10.0, 2.0, 30.0, 4.0, 50.0, 6.0]\n"); + + return 0; +} diff --git a/custom_library/cuda/README.md b/custom_library/cuda/README.md new file mode 100644 index 000000000000..209613e2abb9 --- /dev/null +++ b/custom_library/cuda/README.md @@ -0,0 +1,85 @@ +# Polygeist Custom CUDA Library + +This directory holds custom CUDA kernels that are meant to become backend +targets for kernel-definition matching when no vendor library primitive is a +good fit. + +## `stencil3d_7pt` + +Files: + +- `polygeist_stencil3d_7pt.h` +- `polygeist_stencil3d_7pt.cu` + +The exported C ABI provides f64 and f32 launch wrappers over +device-accessible structured pointers: + +- `polygeist_custom_stencil3d_7pt_f64` +- `polygeist_custom_stencil3d_7pt_f32` + +It also provides flat seven-tensor device launchers used by the current +`kernel.launch` lowering path after the runtime shim maps host pointers: + +- `polygeist_custom_stencil3d_7pt_flat_f64_device` +- `polygeist_custom_stencil3d_7pt_flat_f32_device` + +The kernel computes a structured center-plus-six-neighbor 3D stencil with +optional extra input and optional per-cell coefficient: + +```text +base = base_center * center + base_extra * extra +inner = coeff_center * center + + coeff_xm * xm + coeff_xp * xp + + coeff_ym * ym + coeff_yp * yp + + coeff_zm * zm + coeff_zp * zp + + coeff_extra * extra +out = base + (coeff ? coeff[i,j,k] : 1) * inner +``` + +This one kernel definition can cover: + +- MiniAMR 7-point average. +- MiniAMR weighted 7-point stencil. +- HPGMG 7-point apply operator. +- HPGMG 7-point residual. +- HPGMG weighted-Jacobi-style smoother. +- PolyBench-style 3D heat/Jacobi 7-point stencils. + +The structured API intentionally uses strides in elements and assumes +`input_center` already points at the logical center cell for `(0,0,0)`. That +lets a future lowering pass halo-backed interiors directly without +materializing a dense filter. + +The flat device ABI mirrors the current raised Linalg lowering: it receives +seven same-shaped tap tensors plus optional `extra`/`coeff` pointers. The CUDA +object does not allocate, copy, or synchronize. The runtime shim +`polygeist_custom_stencil3d_7pt_flat_f64` owns pointer registration/data +residency, timing, and pipeline-scope synchronization, then calls the linked +`*_device` launcher. + +Example standalone build, when `nvcc` is available: + +```text +nvcc -O3 -std=c++17 -c custom_library/cuda/polygeist_stencil3d_7pt.cu \ + -o /tmp/polygeist_stencil3d_7pt.o +``` + +`polygeist_build.sh` links weak CPU fallback definitions by default. To use +the CUDA object, compile it for the target architecture and pass: + +```text +POLYGEIST_CUSTOM_CUDA_OBJ=/tmp/polygeist_stencil3d_7pt.o \ + scripts/correctness/polygeist_build.sh --target=jetson ... +``` + +Current integration status: + +1. `generic_solver/kernel_library_phase2.mlir` declares the custom f64 tensor + definitions. +2. `kernel_match_rewrite.py` routes MiniAMR average/weighted 7-point tensor + bodies to those definitions. +3. `LowerKernelLaunchToCuBLAS.cpp` lowers them to + `polygeist_custom_stencil3d_7pt_flat_f64`. +4. `runtime/polygeist_cublas_rt_{cpu,cuda}.c` provide the public runtime shim. + The CUDA shim calls the device launcher when a custom CUDA object is linked, + otherwise it falls back to the CPU reference loop. diff --git a/custom_library/cuda/polygeist_stencil3d_7pt.cu b/custom_library/cuda/polygeist_stencil3d_7pt.cu new file mode 100644 index 000000000000..3ff1faf15b0c --- /dev/null +++ b/custom_library/cuda/polygeist_stencil3d_7pt.cu @@ -0,0 +1,278 @@ +#include "polygeist_stencil3d_7pt.h" + +#include + +#include +#include +#include + +#define POLYGEIST_CUSTOM_CUDA_CHECK(call) do { \ + cudaError_t err = (call); \ + if (err != cudaSuccess) { \ + fprintf(stderr, "%s:%d cuda error: %s\n", __FILE__, __LINE__, \ + cudaGetErrorString(err)); \ + abort(); \ + } \ + } while (0) + +template +__global__ void polygeist_stencil3d_7pt_kernel( + int32_t nx, int32_t ny, int32_t nz, + const T *input_center, + int64_t input_stride_i, int64_t input_stride_j, int64_t input_stride_k, + const T *extra, + int64_t extra_stride_i, int64_t extra_stride_j, int64_t extra_stride_k, + const T *coeff, + int64_t coeff_stride_i, int64_t coeff_stride_j, int64_t coeff_stride_k, + T *output, + int64_t output_stride_i, int64_t output_stride_j, int64_t output_stride_k, + T base_center, T base_extra, T coeff_extra, + T coeff_center, + T coeff_xm, T coeff_xp, + T coeff_ym, T coeff_yp, + T coeff_zm, T coeff_zp) { + int32_t i = (int32_t)(blockIdx.x * blockDim.x + threadIdx.x); + int32_t j = (int32_t)(blockIdx.y * blockDim.y + threadIdx.y); + int32_t k = (int32_t)(blockIdx.z * blockDim.z + threadIdx.z); + if (i >= nx || j >= ny || k >= nz) + return; + + int64_t input_offset = + (int64_t)i * input_stride_i + + (int64_t)j * input_stride_j + + (int64_t)k * input_stride_k; + int64_t output_offset = + (int64_t)i * output_stride_i + + (int64_t)j * output_stride_j + + (int64_t)k * output_stride_k; + + T center = input_center[input_offset]; + T extra_value = T(0); + if (extra) { + int64_t extra_offset = + (int64_t)i * extra_stride_i + + (int64_t)j * extra_stride_j + + (int64_t)k * extra_stride_k; + extra_value = extra[extra_offset]; + } + + T base = base_center * center; + if (extra) + base += base_extra * extra_value; + + T inner = + coeff_center * center + + coeff_xm * input_center[input_offset - input_stride_i] + + coeff_xp * input_center[input_offset + input_stride_i] + + coeff_ym * input_center[input_offset - input_stride_j] + + coeff_yp * input_center[input_offset + input_stride_j] + + coeff_zm * input_center[input_offset - input_stride_k] + + coeff_zp * input_center[input_offset + input_stride_k]; + if (extra) + inner += coeff_extra * extra_value; + + T scale = T(1); + if (coeff) { + int64_t coeff_offset = + (int64_t)i * coeff_stride_i + + (int64_t)j * coeff_stride_j + + (int64_t)k * coeff_stride_k; + scale = coeff[coeff_offset]; + } + + output[output_offset] = base + scale * inner; +} + +template +static void launch_stencil3d_7pt( + int32_t nx, int32_t ny, int32_t nz, + const T *input_center, + int64_t input_stride_i, int64_t input_stride_j, int64_t input_stride_k, + const T *extra, + int64_t extra_stride_i, int64_t extra_stride_j, int64_t extra_stride_k, + const T *coeff, + int64_t coeff_stride_i, int64_t coeff_stride_j, int64_t coeff_stride_k, + T *output, + int64_t output_stride_i, int64_t output_stride_j, int64_t output_stride_k, + T base_center, T base_extra, T coeff_extra, + T coeff_center, + T coeff_xm, T coeff_xp, + T coeff_ym, T coeff_yp, + T coeff_zm, T coeff_zp, + void *cuda_stream) { + if (nx <= 0 || ny <= 0 || nz <= 0) + return; + if (!input_center || !output) { + fprintf(stderr, "polygeist custom stencil3d_7pt: null input/output\n"); + abort(); + } + + cudaStream_t stream = (cudaStream_t)cuda_stream; + dim3 block(8, 8, 4); + dim3 grid((uint32_t)((nx + block.x - 1) / block.x), + (uint32_t)((ny + block.y - 1) / block.y), + (uint32_t)((nz + block.z - 1) / block.z)); + polygeist_stencil3d_7pt_kernel<<>>( + nx, ny, nz, + input_center, + input_stride_i, input_stride_j, input_stride_k, + extra, + extra_stride_i, extra_stride_j, extra_stride_k, + coeff, + coeff_stride_i, coeff_stride_j, coeff_stride_k, + output, + output_stride_i, output_stride_j, output_stride_k, + base_center, base_extra, coeff_extra, + coeff_center, + coeff_xm, coeff_xp, + coeff_ym, coeff_yp, + coeff_zm, coeff_zp); + POLYGEIST_CUSTOM_CUDA_CHECK(cudaGetLastError()); +} + +template +__global__ void polygeist_stencil3d_7pt_flat_kernel( + int32_t N, + const T *a0, const T *a1, const T *a2, + const T *a3, const T *a4, const T *a5, + const T *a6, const T *extra, const T *coeff, T *out, + T base0, T base_extra, T coeff_extra, + T c0, T c1, T c2, T c3, T c4, T c5, T c6) { + int32_t i = (int32_t)(blockIdx.x * blockDim.x + threadIdx.x); + if (i >= N) + return; + T extra_value = extra ? extra[i] : T(0); + T scale = coeff ? coeff[i] : T(1); + T base = base0 * a0[i]; + if (extra) + base += base_extra * extra_value; + T inner = c0 * a0[i] + c1 * a1[i] + c2 * a2[i] + + c3 * a3[i] + c4 * a4[i] + c5 * a5[i] + c6 * a6[i]; + if (extra) + inner += coeff_extra * extra_value; + out[i] = base + scale * inner; +} + +template +static void launch_stencil3d_7pt_flat( + int32_t N, + const T *a0, const T *a1, const T *a2, + const T *a3, const T *a4, const T *a5, + const T *a6, const T *extra, const T *coeff, T *out, + T base0, T base_extra, T coeff_extra, + T c0, T c1, T c2, T c3, T c4, T c5, T c6, + void *cuda_stream) { + if (N <= 0) + return; + if (!a0 || !a1 || !a2 || !a3 || !a4 || !a5 || !a6 || !out) { + fprintf(stderr, "polygeist custom stencil3d_7pt_flat: null required input\n"); + abort(); + } + cudaStream_t stream = (cudaStream_t)cuda_stream; + int block = 256; + int grid = (N + block - 1) / block; + polygeist_stencil3d_7pt_flat_kernel<<>>( + N, a0, a1, a2, a3, a4, a5, a6, extra, coeff, out, + base0, base_extra, coeff_extra, c0, c1, c2, c3, c4, c5, c6); + POLYGEIST_CUSTOM_CUDA_CHECK(cudaGetLastError()); +} + +extern "C" void polygeist_custom_stencil3d_7pt_f64( + int32_t nx, int32_t ny, int32_t nz, + const double *input_center, + int64_t input_stride_i, int64_t input_stride_j, int64_t input_stride_k, + const double *extra, + int64_t extra_stride_i, int64_t extra_stride_j, int64_t extra_stride_k, + const double *coeff, + int64_t coeff_stride_i, int64_t coeff_stride_j, int64_t coeff_stride_k, + double *output, + int64_t output_stride_i, int64_t output_stride_j, int64_t output_stride_k, + double base_center, double base_extra, double coeff_extra, + double coeff_center, + double coeff_xm, double coeff_xp, + double coeff_ym, double coeff_yp, + double coeff_zm, double coeff_zp, + void *cuda_stream) { + launch_stencil3d_7pt( + nx, ny, nz, + input_center, + input_stride_i, input_stride_j, input_stride_k, + extra, + extra_stride_i, extra_stride_j, extra_stride_k, + coeff, + coeff_stride_i, coeff_stride_j, coeff_stride_k, + output, + output_stride_i, output_stride_j, output_stride_k, + base_center, base_extra, coeff_extra, + coeff_center, + coeff_xm, coeff_xp, + coeff_ym, coeff_yp, + coeff_zm, coeff_zp, + cuda_stream); +} + +extern "C" void polygeist_custom_stencil3d_7pt_flat_f64_device( + int32_t N, + const double *a0, const double *a1, const double *a2, + const double *a3, const double *a4, const double *a5, + const double *a6, const double *extra, const double *coeff, + double *out, + double base0, double base_extra, double coeff_extra, + double c0, double c1, double c2, double c3, + double c4, double c5, double c6, + void *cuda_stream) { + launch_stencil3d_7pt_flat( + N, a0, a1, a2, a3, a4, a5, a6, extra, coeff, out, + base0, base_extra, coeff_extra, c0, c1, c2, c3, c4, c5, c6, + cuda_stream); +} + +extern "C" void polygeist_custom_stencil3d_7pt_f32( + int32_t nx, int32_t ny, int32_t nz, + const float *input_center, + int64_t input_stride_i, int64_t input_stride_j, int64_t input_stride_k, + const float *extra, + int64_t extra_stride_i, int64_t extra_stride_j, int64_t extra_stride_k, + const float *coeff, + int64_t coeff_stride_i, int64_t coeff_stride_j, int64_t coeff_stride_k, + float *output, + int64_t output_stride_i, int64_t output_stride_j, int64_t output_stride_k, + float base_center, float base_extra, float coeff_extra, + float coeff_center, + float coeff_xm, float coeff_xp, + float coeff_ym, float coeff_yp, + float coeff_zm, float coeff_zp, + void *cuda_stream) { + launch_stencil3d_7pt( + nx, ny, nz, + input_center, + input_stride_i, input_stride_j, input_stride_k, + extra, + extra_stride_i, extra_stride_j, extra_stride_k, + coeff, + coeff_stride_i, coeff_stride_j, coeff_stride_k, + output, + output_stride_i, output_stride_j, output_stride_k, + base_center, base_extra, coeff_extra, + coeff_center, + coeff_xm, coeff_xp, + coeff_ym, coeff_yp, + coeff_zm, coeff_zp, + cuda_stream); +} + +extern "C" void polygeist_custom_stencil3d_7pt_flat_f32_device( + int32_t N, + const float *a0, const float *a1, const float *a2, + const float *a3, const float *a4, const float *a5, + const float *a6, const float *extra, const float *coeff, + float *out, + float base0, float base_extra, float coeff_extra, + float c0, float c1, float c2, float c3, + float c4, float c5, float c6, + void *cuda_stream) { + launch_stencil3d_7pt_flat( + N, a0, a1, a2, a3, a4, a5, a6, extra, coeff, out, + base0, base_extra, coeff_extra, c0, c1, c2, c3, c4, c5, c6, + cuda_stream); +} diff --git a/custom_library/cuda/polygeist_stencil3d_7pt.h b/custom_library/cuda/polygeist_stencil3d_7pt.h new file mode 100644 index 000000000000..72d65b947f6f --- /dev/null +++ b/custom_library/cuda/polygeist_stencil3d_7pt.h @@ -0,0 +1,128 @@ +#ifndef POLYGEIST_CUSTOM_LIBRARY_CUDA_STENCIL3D_7PT_H +#define POLYGEIST_CUSTOM_LIBRARY_CUDA_STENCIL3D_7PT_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Structured 3D 7-point affine stencil over device-accessible pointers. + * + * Pointers are interpreted as already pointing at the logical center cell + * for (i=0,j=0,k=0). Neighbor accesses use the input strides: + * xm = input - input_stride_i + * xp = input + input_stride_i + * ym = input - input_stride_j + * yp = input + input_stride_j + * zm = input - input_stride_k + * zp = input + input_stride_k + * + * For each output cell: + * + * base = base_center * center + * if extra != NULL: + * base += base_extra * extra[i,j,k] + * + * inner = coeff_center * center + * + coeff_xm * xm + coeff_xp * xp + * + coeff_ym * ym + coeff_yp * yp + * + coeff_zm * zm + coeff_zp * zp + * if extra != NULL: + * inner += coeff_extra * extra[i,j,k] + * + * out = base + (coeff ? coeff[i,j,k] : 1) * inner + * + * This single form covers: + * - MiniAMR average7: + * coeff=NULL, base*=0, all coeff_* taps = 1/7, coeff_extra=0. + * - MiniAMR weighted7: + * base_center=1, coeff=cell coefficient, + * coeff_center=-6, neighbor coeffs=1. + * - HPGMG apply-op: + * coeff=NULL, coeff_center=a+6*b, neighbor coeffs=-b. + * - HPGMG residual: + * extra=rhs, base_extra=1, + * coeff_center=-(a+6*b), neighbor coeffs=b. + * - HPGMG weighted Jacobi-like smoother: + * base_center=1, extra=rhs, coeff=dinv, + * coeff_extra=weight, + * coeff_center=-weight*(a+6*b), neighbor coeffs=weight*b. + * + * Strides are in elements, not bytes. cuda_stream may be NULL for the default + * stream, otherwise it must be a cudaStream_t cast to void*. + */ +void polygeist_custom_stencil3d_7pt_f64( + int32_t nx, int32_t ny, int32_t nz, + const double *input_center, + int64_t input_stride_i, int64_t input_stride_j, int64_t input_stride_k, + const double *extra, + int64_t extra_stride_i, int64_t extra_stride_j, int64_t extra_stride_k, + const double *coeff, + int64_t coeff_stride_i, int64_t coeff_stride_j, int64_t coeff_stride_k, + double *output, + int64_t output_stride_i, int64_t output_stride_j, int64_t output_stride_k, + double base_center, double base_extra, double coeff_extra, + double coeff_center, + double coeff_xm, double coeff_xp, + double coeff_ym, double coeff_yp, + double coeff_zm, double coeff_zp, + void *cuda_stream); + +void polygeist_custom_stencil3d_7pt_f32( + int32_t nx, int32_t ny, int32_t nz, + const float *input_center, + int64_t input_stride_i, int64_t input_stride_j, int64_t input_stride_k, + const float *extra, + int64_t extra_stride_i, int64_t extra_stride_j, int64_t extra_stride_k, + const float *coeff, + int64_t coeff_stride_i, int64_t coeff_stride_j, int64_t coeff_stride_k, + float *output, + int64_t output_stride_i, int64_t output_stride_j, int64_t output_stride_k, + float base_center, float base_extra, float coeff_extra, + float coeff_center, + float coeff_xm, float coeff_xp, + float coeff_ym, float coeff_yp, + float coeff_zm, float coeff_zp, + void *cuda_stream); + +/* + * Flat seven-tensor device ABI used by current raised Linalg lowering after + * the runtime shim has mapped host pointers to device-accessible pointers. + * `extra` and `coeff` may be NULL. This mirrors the formula above but each + * tap is already presented as a same-shaped tensor: + * out = base0*a0 + base_extra*extra + * + (coeff ? coeff[i] : 1) * + * (c0*a0 + ... + c6*a6 + coeff_extra*extra) + * + * These functions do not allocate, copy, or synchronize. The runtime shim owns + * pointer registration/data residency and passes the stream. + */ +void polygeist_custom_stencil3d_7pt_flat_f64_device( + int32_t N, + const double *a0, const double *a1, const double *a2, + const double *a3, const double *a4, const double *a5, + const double *a6, const double *extra, const double *coeff, + double *out, + double base0, double base_extra, double coeff_extra, + double c0, double c1, double c2, double c3, + double c4, double c5, double c6, + void *cuda_stream); + +void polygeist_custom_stencil3d_7pt_flat_f32_device( + int32_t N, + const float *a0, const float *a1, const float *a2, + const float *a3, const float *a4, const float *a5, + const float *a6, const float *extra, const float *coeff, + float *out, + float base0, float base_extra, float coeff_extra, + float c0, float c1, float c2, float c3, + float c4, float c5, float c6, + void *cuda_stream); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/debufferize_stress/after/s01_submap_of_submap.mlir b/debufferize_stress/after/s01_submap_of_submap.mlir new file mode 100644 index 000000000000..3be93c20a595 --- /dev/null +++ b/debufferize_stress/after/s01_submap_of_submap.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0)[s0] -> (d0 * s0)> +#map1 = affine_map<(d0) -> (d0)> +module { + func.func @submap_of_submap(%arg0: index, %arg1: index, %arg2: index, %arg3: memref, %arg4: memref) { + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = polygeist.submap(%1, %arg2, %arg0) {map = #map} : (tensor, index, index) -> tensor + %3 = polygeist.submap(%0, %arg2, %arg0) {map = #map} : (tensor, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%2 : tensor) outs(%3 : tensor) { + ^bb0(%in: f64, %out: f64): + %7 = arith.addf %in, %out : f64 + linalg.yield %7 : f64 + } -> tensor + %5 = polygeist.submapInverse(%0, %4, %arg2, %arg0) {map = #map} : (tensor, tensor, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/debufferize_stress/after/s01_submap_of_submap_v2.mlir b/debufferize_stress/after/s01_submap_of_submap_v2.mlir new file mode 100644 index 000000000000..166fdb0061ca --- /dev/null +++ b/debufferize_stress/after/s01_submap_of_submap_v2.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0)[s0] -> (d0 * s0)> +#map1 = affine_map<(d0) -> (d0)> +module { + func.func @submap_of_submap(%arg0: index, %arg1: index, %arg2: index, %arg3: memref, %arg4: memref) { + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = polygeist.submap(%1, %arg1, %arg0) {map = #map} : (tensor, index, index) -> tensor + %3 = polygeist.submap(%2, %arg2, %arg0) {map = #map} : (tensor, index, index) -> tensor + %4 = polygeist.submap(%0, %arg1, %arg0) {map = #map} : (tensor, index, index) -> tensor + %5 = polygeist.submap(%4, %arg2, %arg0) {map = #map} : (tensor, index, index) -> tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%3 : tensor) outs(%5 : tensor) { + ^bb0(%in: f64, %out: f64): + %11 = arith.addf %in, %out : f64 + linalg.yield %11 : f64 + } -> tensor + %7 = polygeist.submap(%0, %arg1, %arg0) {map = #map} : (tensor, index, index) -> tensor + %8 = polygeist.submapInverse(%7, %6, %arg2, %arg0) {map = #map} : (tensor, tensor, index, index) -> tensor + %9 = polygeist.submapInverse(%0, %8, %arg1, %arg0) {map = #map} : (tensor, tensor, index, index) -> tensor + %10 = bufferization.to_memref %9 : memref + memref.copy %10, %arg4 : memref to memref + return + } +} + diff --git a/debufferize_stress/after/s02_scf_if_no_else_v2.mlir b/debufferize_stress/after/s02_scf_if_no_else_v2.mlir new file mode 100644 index 000000000000..6b86643c832c --- /dev/null +++ b/debufferize_stress/after/s02_scf_if_no_else_v2.mlir @@ -0,0 +1,17 @@ +module { + func.func @if_no_else(%arg0: i1, %arg1: index, %arg2: memref) { + %c0 = arith.constant 0 : index + %cst = arith.constant 1.000000e+00 : f64 + %0 = bufferization.to_tensor %arg2 : memref + %1 = scf.if %arg0 -> (tensor) { + %inserted = tensor.insert %cst into %0[%c0] : tensor + scf.yield %inserted : tensor + } else { + scf.yield %0 : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/debufferize_stress/after/s03_sibling_ifs_v2.mlir b/debufferize_stress/after/s03_sibling_ifs_v2.mlir new file mode 100644 index 000000000000..abb5f18d7c5d --- /dev/null +++ b/debufferize_stress/after/s03_sibling_ifs_v2.mlir @@ -0,0 +1,25 @@ +module { + func.func @sibling_ifs(%arg0: i1, %arg1: i1, %arg2: memref<8xf64>) { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %cst = arith.constant 2.000000e+00 : f64 + %cst_0 = arith.constant 1.000000e+00 : f64 + %0 = bufferization.to_tensor %arg2 : memref<8xf64> + %1 = scf.if %arg0 -> (tensor<8xf64>) { + %inserted = tensor.insert %cst_0 into %0[%c0] : tensor<8xf64> + scf.yield %inserted : tensor<8xf64> + } else { + scf.yield %0 : tensor<8xf64> + } + %2 = scf.if %arg1 -> (tensor<8xf64>) { + %inserted = tensor.insert %cst into %1[%c1] : tensor<8xf64> + scf.yield %inserted : tensor<8xf64> + } else { + scf.yield %1 : tensor<8xf64> + } + %3 = bufferization.to_memref %2 : memref<8xf64> + memref.copy %3, %arg2 : memref<8xf64> to memref<8xf64> + return + } +} + diff --git a/debufferize_stress/after/s04_then_else_both_write_v2.mlir b/debufferize_stress/after/s04_then_else_both_write_v2.mlir new file mode 100644 index 000000000000..c9bc39d4c1a6 --- /dev/null +++ b/debufferize_stress/after/s04_then_else_both_write_v2.mlir @@ -0,0 +1,20 @@ +module { + func.func @then_else_both_write(%arg0: i1, %arg1: memref<8xf64>) { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %cst = arith.constant 2.000000e+00 : f64 + %cst_0 = arith.constant 1.000000e+00 : f64 + %0 = bufferization.to_tensor %arg1 : memref<8xf64> + %1 = scf.if %arg0 -> (tensor<8xf64>) { + %inserted = tensor.insert %cst_0 into %0[%c0] : tensor<8xf64> + scf.yield %inserted : tensor<8xf64> + } else { + %inserted = tensor.insert %cst into %0[%c1] : tensor<8xf64> + scf.yield %inserted : tensor<8xf64> + } + %2 = bufferization.to_memref %1 : memref<8xf64> + memref.copy %2, %arg1 : memref<8xf64> to memref<8xf64> + return + } +} + diff --git a/debufferize_stress/after/s05_then_load_after_store_v2.mlir b/debufferize_stress/after/s05_then_load_after_store_v2.mlir new file mode 100644 index 000000000000..7a7bba3db2ce --- /dev/null +++ b/debufferize_stress/after/s05_then_load_after_store_v2.mlir @@ -0,0 +1,19 @@ +module { + func.func @then_load_after_store(%arg0: i1, %arg1: memref<8xf64>) -> f64 { + %c0 = arith.constant 0 : index + %cst = arith.constant 3.140000e+00 : f64 + %0 = bufferization.to_tensor %arg1 : memref<8xf64> + %1:2 = scf.if %arg0 -> (f64, tensor<8xf64>) { + %inserted = tensor.insert %cst into %0[%c0] : tensor<8xf64> + %extracted = tensor.extract %inserted[%c0] : tensor<8xf64> + scf.yield %extracted, %inserted : f64, tensor<8xf64> + } else { + %extracted = tensor.extract %0[%c0] : tensor<8xf64> + scf.yield %extracted, %0 : f64, tensor<8xf64> + } + %2 = bufferization.to_memref %1#1 : memref<8xf64> + memref.copy %2, %arg1 : memref<8xf64> to memref<8xf64> + return %1#0 : f64 + } +} + diff --git a/debufferize_stress/after/s06_scf_while_v2.mlir b/debufferize_stress/after/s06_scf_while_v2.mlir new file mode 100644 index 000000000000..1556bb83efbd --- /dev/null +++ b/debufferize_stress/after/s06_scf_while_v2.mlir @@ -0,0 +1,21 @@ +module { + func.func @scf_while_store(%arg0: index, %arg1: memref) { + %cst = arith.constant 1.000000e+00 : f64 + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1:2 = scf.while (%arg2 = %c0, %arg3 = %0) : (index, tensor) -> (index, tensor) { + %3 = arith.cmpi slt, %arg2, %arg0 : index + scf.condition(%3) %arg2, %arg3 : index, tensor + } do { + ^bb0(%arg2: index, %arg3: tensor): + %inserted = tensor.insert %cst into %arg3[%arg2] : tensor + %3 = arith.addi %arg2, %c1 : index + scf.yield %3, %inserted : index, tensor + } + %2 = bufferization.to_memref %1#1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/debufferize_stress/after/s07_memref_cast.mlir b/debufferize_stress/after/s07_memref_cast.mlir new file mode 100644 index 000000000000..bedfaa9f086d --- /dev/null +++ b/debufferize_stress/after/s07_memref_cast.mlir @@ -0,0 +1,12 @@ +module { + func.func @cast_then_store(%arg0: memref<8xf64>) { + %cst = arith.constant 1.000000e+00 : f64 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref<8xf64> + %inserted = tensor.insert %cst into %0[%c0] : tensor<8xf64> + %1 = bufferization.to_memref %inserted : memref<8xf64> + memref.copy %1, %arg0 : memref<8xf64> to memref<8xf64> + return + } +} + diff --git a/debufferize_stress/after/s07_memref_cast_v2.mlir b/debufferize_stress/after/s07_memref_cast_v2.mlir new file mode 100644 index 000000000000..bedfaa9f086d --- /dev/null +++ b/debufferize_stress/after/s07_memref_cast_v2.mlir @@ -0,0 +1,12 @@ +module { + func.func @cast_then_store(%arg0: memref<8xf64>) { + %cst = arith.constant 1.000000e+00 : f64 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref<8xf64> + %inserted = tensor.insert %cst into %0[%c0] : tensor<8xf64> + %1 = bufferization.to_memref %inserted : memref<8xf64> + memref.copy %1, %arg0 : memref<8xf64> to memref<8xf64> + return + } +} + diff --git a/debufferize_stress/after/s08_func_call_consumer.mlir b/debufferize_stress/after/s08_func_call_consumer.mlir new file mode 100644 index 000000000000..996f82247d6d --- /dev/null +++ b/debufferize_stress/after/s08_func_call_consumer.mlir @@ -0,0 +1,14 @@ +module { + func.func private @sink(memref) + func.func @call_consumer(%arg0: index, %arg1: memref) { + %c0 = arith.constant 0 : index + %cst = arith.constant 1.000000e+00 : f64 + %0 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %cst into %0[%c0] : tensor + %1 = bufferization.to_memref %inserted : memref + memref.copy %1, %arg1 : memref to memref + call @sink(%arg1) : (memref) -> () + return + } +} + diff --git a/debufferize_stress/after/s08_func_call_consumer_v2.mlir b/debufferize_stress/after/s08_func_call_consumer_v2.mlir new file mode 100644 index 000000000000..842918af2ee3 --- /dev/null +++ b/debufferize_stress/after/s08_func_call_consumer_v2.mlir @@ -0,0 +1,11 @@ +module { + func.func private @sink(memref) + func.func @call_consumer(%arg0: index, %arg1: memref) { + %cst = arith.constant 1.000000e+00 : f64 + %c0 = arith.constant 0 : index + memref.store %cst, %arg1[%c0] : memref + call @sink(%arg1) : (memref) -> () + return + } +} + diff --git a/debufferize_stress/after/s09_same_memref_in_and_out.mlir b/debufferize_stress/after/s09_same_memref_in_and_out.mlir new file mode 100644 index 000000000000..992d8742e59b --- /dev/null +++ b/debufferize_stress/after/s09_same_memref_in_and_out.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module { + func.func @in_eq_out(%arg0: index, %arg1: memref) { + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %arg0) {map = #map} : (tensor, index) -> tensor + %2 = polygeist.submap(%0, %arg0) {map = #map} : (tensor, index) -> tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1 : tensor) outs(%2 : tensor) { + ^bb0(%in: f64, %out: f64): + %6 = arith.mulf %in, %in : f64 + linalg.yield %6 : f64 + } -> tensor + %4 = polygeist.submapInverse(%0, %3, %arg0) {map = #map} : (tensor, tensor, index) -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/debufferize_stress/after/s10_multi_block_region.mlir b/debufferize_stress/after/s10_multi_block_region.mlir new file mode 100644 index 000000000000..4df53d51693f --- /dev/null +++ b/debufferize_stress/after/s10_multi_block_region.mlir @@ -0,0 +1,16 @@ +module { + func.func @two_blocks(%arg0: i1, %arg1: memref<8xf64>) { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %cst = arith.constant 1.000000e+00 : f64 + %0 = bufferization.to_tensor %arg1 : memref<8xf64> + %inserted = tensor.insert %cst into %0[%c0] : tensor<8xf64> + cf.br ^bb1 + ^bb1: // pred: ^bb0 + %inserted_0 = tensor.insert %cst into %inserted[%c1] : tensor<8xf64> + %1 = bufferization.to_memref %inserted_0 : memref<8xf64> + memref.copy %1, %arg1 : memref<8xf64> to memref<8xf64> + return + } +} + diff --git a/debufferize_stress/after/s10_multi_block_region_v2.mlir b/debufferize_stress/after/s10_multi_block_region_v2.mlir new file mode 100644 index 000000000000..96969190e416 --- /dev/null +++ b/debufferize_stress/after/s10_multi_block_region_v2.mlir @@ -0,0 +1,13 @@ +module { + func.func @two_blocks(%arg0: i1, %arg1: memref<8xf64>) { + %cst = arith.constant 1.000000e+00 : f64 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + memref.store %cst, %arg1[%c0] : memref<8xf64> + cf.br ^bb1 + ^bb1: // pred: ^bb0 + memref.store %cst, %arg1[%c1] : memref<8xf64> + return + } +} + diff --git a/debufferize_stress/after/s11_scf_for_then_load_outside_v2.mlir b/debufferize_stress/after/s11_scf_for_then_load_outside_v2.mlir new file mode 100644 index 000000000000..f48491ef4128 --- /dev/null +++ b/debufferize_stress/after/s11_scf_for_then_load_outside_v2.mlir @@ -0,0 +1,17 @@ +module { + func.func @for_then_load(%arg0: index, %arg1: memref) -> f64 { + %cst = arith.constant 1.000000e+00 : f64 + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = scf.for %arg2 = %c0 to %arg0 step %c1 iter_args(%arg3 = %0) -> (tensor) { + %inserted = tensor.insert %cst into %arg3[%arg2] : tensor + scf.yield %inserted : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + %extracted = tensor.extract %1[%c0] : tensor + return %extracted : f64 + } +} + diff --git a/debufferize_stress/after/s12_affine_for_iter_arg_with_memref_v2.mlir b/debufferize_stress/after/s12_affine_for_iter_arg_with_memref_v2.mlir new file mode 100644 index 000000000000..279bbab64b96 --- /dev/null +++ b/debufferize_stress/after/s12_affine_for_iter_arg_with_memref_v2.mlir @@ -0,0 +1,16 @@ +module { + func.func @affine_for_with_iter(%arg0: index, %arg1: memref) -> f64 { + %cst = arith.constant 1.000000e+00 : f64 + %cst_0 = arith.constant 0.000000e+00 : f64 + %0 = bufferization.to_tensor %arg1 : memref + %1:2 = affine.for %arg2 = 0 to %arg0 iter_args(%arg3 = %cst_0, %arg4 = %0) -> (f64, tensor) { + %inserted = tensor.insert %cst into %arg4[%arg2] : tensor + %3 = arith.addf %arg3, %cst : f64 + affine.yield %3, %inserted : f64, tensor + } + %2 = bufferization.to_memref %1#1 : memref + memref.copy %2, %arg1 : memref to memref + return %1#0 : f64 + } +} + diff --git a/debufferize_stress/after/s13_two_allocas_aliased_via_cast.mlir b/debufferize_stress/after/s13_two_allocas_aliased_via_cast.mlir new file mode 100644 index 000000000000..7392d4eaa120 --- /dev/null +++ b/debufferize_stress/after/s13_two_allocas_aliased_via_cast.mlir @@ -0,0 +1,6 @@ +module { + func.func @aliased_allocas() { + return + } +} + diff --git a/debufferize_stress/after/s13_two_allocas_aliased_via_cast_v2.mlir b/debufferize_stress/after/s13_two_allocas_aliased_via_cast_v2.mlir new file mode 100644 index 000000000000..7392d4eaa120 --- /dev/null +++ b/debufferize_stress/after/s13_two_allocas_aliased_via_cast_v2.mlir @@ -0,0 +1,6 @@ +module { + func.func @aliased_allocas() { + return + } +} + diff --git a/debufferize_stress/after/s14_memref_subview.mlir b/debufferize_stress/after/s14_memref_subview.mlir new file mode 100644 index 000000000000..ca4c6a7f1c4e --- /dev/null +++ b/debufferize_stress/after/s14_memref_subview.mlir @@ -0,0 +1,10 @@ +module { + func.func @subview_then_store(%arg0: memref<8x8xf64>) { + %c0 = arith.constant 0 : index + %cst = arith.constant 1.000000e+00 : f64 + %subview = memref.subview %arg0[0, 0] [4, 4] [1, 1] : memref<8x8xf64> to memref<4x4xf64, strided<[8, 1]>> + memref.store %cst, %subview[%c0, %c0] : memref<4x4xf64, strided<[8, 1]>> + return + } +} + diff --git a/debufferize_stress/after/s14_memref_subview_v2.mlir b/debufferize_stress/after/s14_memref_subview_v2.mlir new file mode 100644 index 000000000000..ca4c6a7f1c4e --- /dev/null +++ b/debufferize_stress/after/s14_memref_subview_v2.mlir @@ -0,0 +1,10 @@ +module { + func.func @subview_then_store(%arg0: memref<8x8xf64>) { + %c0 = arith.constant 0 : index + %cst = arith.constant 1.000000e+00 : f64 + %subview = memref.subview %arg0[0, 0] [4, 4] [1, 1] : memref<8x8xf64> to memref<4x4xf64, strided<[8, 1]>> + memref.store %cst, %subview[%c0, %c0] : memref<4x4xf64, strided<[8, 1]>> + return + } +} + diff --git a/debufferize_stress/after/s15_dealloc.mlir b/debufferize_stress/after/s15_dealloc.mlir new file mode 100644 index 000000000000..c744a256e7e2 --- /dev/null +++ b/debufferize_stress/after/s15_dealloc.mlir @@ -0,0 +1,14 @@ +module { + func.func @with_dealloc(%arg0: index) { + %c0 = arith.constant 0 : index + %cst = arith.constant 1.000000e+00 : f64 + %alloc = memref.alloc(%arg0) : memref + %0 = bufferization.to_tensor %alloc : memref + %inserted = tensor.insert %cst into %0[%c0] : tensor + %1 = bufferization.to_memref %inserted : memref + memref.copy %1, %alloc : memref to memref + memref.dealloc %alloc : memref + return + } +} + diff --git a/debufferize_stress/after/s15_dealloc_v2.mlir b/debufferize_stress/after/s15_dealloc_v2.mlir new file mode 100644 index 000000000000..c744a256e7e2 --- /dev/null +++ b/debufferize_stress/after/s15_dealloc_v2.mlir @@ -0,0 +1,14 @@ +module { + func.func @with_dealloc(%arg0: index) { + %c0 = arith.constant 0 : index + %cst = arith.constant 1.000000e+00 : f64 + %alloc = memref.alloc(%arg0) : memref + %0 = bufferization.to_tensor %alloc : memref + %inserted = tensor.insert %cst into %0[%c0] : tensor + %1 = bufferization.to_memref %inserted : memref + memref.copy %1, %alloc : memref to memref + memref.dealloc %alloc : memref + return + } +} + diff --git a/debufferize_stress/after/s16_linalg_inside_if.mlir b/debufferize_stress/after/s16_linalg_inside_if.mlir new file mode 100644 index 000000000000..0af8eac57758 --- /dev/null +++ b/debufferize_stress/after/s16_linalg_inside_if.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module { + func.func @linalg_inside_if(%arg0: i1, %arg1: index, %arg2: memref) { + %cst = arith.constant 1.000000e+00 : f64 + %0 = bufferization.to_tensor %arg2 : memref + %1 = scf.if %arg0 -> (tensor) { + %3 = polygeist.submap(%0, %arg1) {map = #map} : (tensor, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%3 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %5 = polygeist.submapInverse(%0, %4, %arg1) {map = #map} : (tensor, tensor, index) -> tensor + scf.yield %5 : tensor + } else { + scf.yield %0 : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/debufferize_stress/after/s16_linalg_inside_if_v2.mlir b/debufferize_stress/after/s16_linalg_inside_if_v2.mlir new file mode 100644 index 000000000000..0af8eac57758 --- /dev/null +++ b/debufferize_stress/after/s16_linalg_inside_if_v2.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module { + func.func @linalg_inside_if(%arg0: i1, %arg1: index, %arg2: memref) { + %cst = arith.constant 1.000000e+00 : f64 + %0 = bufferization.to_tensor %arg2 : memref + %1 = scf.if %arg0 -> (tensor) { + %3 = polygeist.submap(%0, %arg1) {map = #map} : (tensor, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%3 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %5 = polygeist.submapInverse(%0, %4, %arg1) {map = #map} : (tensor, tensor, index) -> tensor + scf.yield %5 : tensor + } else { + scf.yield %0 : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/debufferize_stress/after/s17_linalg_then_load_outside.mlir b/debufferize_stress/after/s17_linalg_then_load_outside.mlir new file mode 100644 index 000000000000..bb0cde4e0f67 --- /dev/null +++ b/debufferize_stress/after/s17_linalg_then_load_outside.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module { + func.func @linalg_then_load(%arg0: index, %arg1: memref, %arg2: memref) -> f64 { + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%1, %arg0) {map = #map} : (tensor, index) -> tensor + %3 = polygeist.submap(%0, %arg0) {map = #map} : (tensor, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%2 : tensor) outs(%3 : tensor) { + ^bb0(%in: f64, %out: f64): + %7 = arith.addf %in, %out : f64 + linalg.yield %7 : f64 + } -> tensor + %5 = polygeist.submapInverse(%0, %4, %arg0) {map = #map} : (tensor, tensor, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + %extracted = tensor.extract %5[%c0] : tensor + return %extracted : f64 + } +} + diff --git a/debufferize_stress/after/s17_linalg_then_load_outside_v2.mlir b/debufferize_stress/after/s17_linalg_then_load_outside_v2.mlir new file mode 100644 index 000000000000..bb0cde4e0f67 --- /dev/null +++ b/debufferize_stress/after/s17_linalg_then_load_outside_v2.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module { + func.func @linalg_then_load(%arg0: index, %arg1: memref, %arg2: memref) -> f64 { + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%1, %arg0) {map = #map} : (tensor, index) -> tensor + %3 = polygeist.submap(%0, %arg0) {map = #map} : (tensor, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%2 : tensor) outs(%3 : tensor) { + ^bb0(%in: f64, %out: f64): + %7 = arith.addf %in, %out : f64 + linalg.yield %7 : f64 + } -> tensor + %5 = polygeist.submapInverse(%0, %4, %arg0) {map = #map} : (tensor, tensor, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + %extracted = tensor.extract %5[%c0] : tensor + return %extracted : f64 + } +} + diff --git a/debufferize_stress/after/s18_alloca_reduction_then_load.mlir b/debufferize_stress/after/s18_alloca_reduction_then_load.mlir new file mode 100644 index 000000000000..5e5373d621a6 --- /dev/null +++ b/debufferize_stress/after/s18_alloca_reduction_then_load.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> ()> +#map1 = affine_map<(d0) -> (d0)> +module { + func.func @reduction_then_load(%arg0: index, %arg1: memref, %arg2: memref) -> f64 { + %cst = arith.constant 0.000000e+00 : f64 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %2[] : tensor + %3 = polygeist.submap(%inserted, %arg0) {map = #map} : (tensor, index) -> tensor + %4 = polygeist.submap(%1, %arg0) {map = #map1} : (tensor, index) -> tensor + %5 = polygeist.submap(%0, %arg0) {map = #map1} : (tensor, index) -> tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%4, %5 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } -> tensor + %7 = polygeist.submapInverse(%inserted, %6, %arg0) {map = #map} : (tensor, tensor, index) -> tensor + %extracted = tensor.extract %7[] : tensor + return %extracted : f64 + } +} + diff --git a/debufferize_stress/after/s18_alloca_reduction_then_load_v2.mlir b/debufferize_stress/after/s18_alloca_reduction_then_load_v2.mlir new file mode 100644 index 000000000000..5e5373d621a6 --- /dev/null +++ b/debufferize_stress/after/s18_alloca_reduction_then_load_v2.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> ()> +#map1 = affine_map<(d0) -> (d0)> +module { + func.func @reduction_then_load(%arg0: index, %arg1: memref, %arg2: memref) -> f64 { + %cst = arith.constant 0.000000e+00 : f64 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %2[] : tensor + %3 = polygeist.submap(%inserted, %arg0) {map = #map} : (tensor, index) -> tensor + %4 = polygeist.submap(%1, %arg0) {map = #map1} : (tensor, index) -> tensor + %5 = polygeist.submap(%0, %arg0) {map = #map1} : (tensor, index) -> tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%4, %5 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } -> tensor + %7 = polygeist.submapInverse(%inserted, %6, %arg0) {map = #map} : (tensor, tensor, index) -> tensor + %extracted = tensor.extract %7[] : tensor + return %extracted : f64 + } +} + diff --git a/debufferize_stress/err/s01_submap_of_submap.err b/debufferize_stress/err/s01_submap_of_submap.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s01_submap_of_submap_v2.err b/debufferize_stress/err/s01_submap_of_submap_v2.err new file mode 100644 index 000000000000..63c3ad8d98d5 --- /dev/null +++ b/debufferize_stress/err/s01_submap_of_submap_v2.err @@ -0,0 +1,54 @@ +polygeist-opt: /home/arjaiswal/Polygeist/llvm-project/mlir/lib/IR/PatternMatch.cpp:307: virtual void mlir::RewriterBase::eraseOp(mlir::Operation*): Assertion `op->use_empty() && "expected 'op' to have no uses"' failed. +PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace. +Stack dump: +0. Program arguments: polygeist-opt --linalg-debufferize=use-recursive=true inputs/s01_submap_of_submap.mlir -o after/s01_submap_of_submap_v2.mlir +Stack dump without symbol names (ensure you have llvm-symbolizer in your PATH or set the environment var `LLVM_SYMBOLIZER_PATH` to point to it): +0 polygeist-opt 0x000055a8dcc2156a +1 polygeist-opt 0x000055a8dcc21986 +2 polygeist-opt 0x000055a8dcc1edd3 +3 polygeist-opt 0x000055a8dcc20e02 +4 libc.so.6 0x00007f71c7f17520 +5 libc.so.6 0x00007f71c7f6b9fc pthread_kill + 300 +6 libc.so.6 0x00007f71c7f17476 raise + 22 +7 libc.so.6 0x00007f71c7efd7f3 abort + 211 +8 libc.so.6 0x00007f71c7efd71b +9 libc.so.6 0x00007f71c7f0ee96 +10 polygeist-opt 0x000055a8dca491b1 +11 polygeist-opt 0x000055a8d92307af +12 polygeist-opt 0x000055a8d9239d02 +13 polygeist-opt 0x000055a8d924b8b0 +14 polygeist-opt 0x000055a8dc6074ca +15 polygeist-opt 0x000055a8dc607e8f +16 polygeist-opt 0x000055a8db985a1a +17 polygeist-opt 0x000055a8dc60b237 +18 polygeist-opt 0x000055a8dc607c3c +19 polygeist-opt 0x000055a8dc42303e +20 polygeist-opt 0x000055a8dc42429c +21 polygeist-opt 0x000055a8dc42542d +22 polygeist-opt 0x000055a8db985a1a +23 polygeist-opt 0x000055a8dc4251b9 +24 polygeist-opt 0x000055a8dc42450e +25 polygeist-opt 0x000055a8dc42464b +26 polygeist-opt 0x000055a8d75a86c3 +27 polygeist-opt 0x000055a8d9230a65 +28 polygeist-opt 0x000055a8dc6ee0d1 +29 polygeist-opt 0x000055a8dc6f1dae +30 polygeist-opt 0x000055a8db985a1a +31 polygeist-opt 0x000055a8dc6f7b2f +32 polygeist-opt 0x000055a8dc6ee4f3 +33 polygeist-opt 0x000055a8dc6ee7ce +34 polygeist-opt 0x000055a8dc6f06f4 +35 polygeist-opt 0x000055a8dc6f054c +36 polygeist-opt 0x000055a8d98798d1 +37 polygeist-opt 0x000055a8d9879ea5 +38 polygeist-opt 0x000055a8d9879fdf +39 polygeist-opt 0x000055a8d987b11e +40 polygeist-opt 0x000055a8dca98805 +41 polygeist-opt 0x000055a8dca980cf +42 polygeist-opt 0x000055a8d987a194 +43 polygeist-opt 0x000055a8d987a751 +44 polygeist-opt 0x000055a8d7443d8e +45 libc.so.6 0x00007f71c7efed90 +46 libc.so.6 0x00007f71c7efee40 __libc_start_main + 128 +47 polygeist-opt 0x000055a8d7443765 +timeout: the monitored command dumped core diff --git a/debufferize_stress/err/s02_scf_if_no_else.err b/debufferize_stress/err/s02_scf_if_no_else.err new file mode 100644 index 000000000000..a601f58350ae --- /dev/null +++ b/debufferize_stress/err/s02_scf_if_no_else.err @@ -0,0 +1,50 @@ +PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace. +Stack dump: +0. Program arguments: polygeist-opt --linalg-debufferize inputs/s02_scf_if_no_else.mlir -o after/s02_scf_if_no_else.mlir +Stack dump without symbol names (ensure you have llvm-symbolizer in your PATH or set the environment var `LLVM_SYMBOLIZER_PATH` to point to it): +0 polygeist-opt 0x0000557c2185ec6a +1 polygeist-opt 0x0000557c2185f086 +2 polygeist-opt 0x0000557c2185c4d3 +3 polygeist-opt 0x0000557c2185e502 +4 libc.so.6 0x00007f199b5a7520 +5 polygeist-opt 0x0000557c21689fae +6 polygeist-opt 0x0000557c2168a034 +7 polygeist-opt 0x0000557c1c28948d +8 polygeist-opt 0x0000557c1de6ebd1 +9 polygeist-opt 0x0000557c1de78a7a +10 polygeist-opt 0x0000557c1de7965a +11 polygeist-opt 0x0000557c1de88fdc +12 polygeist-opt 0x0000557c21244bf6 +13 polygeist-opt 0x0000557c212455bb +14 polygeist-opt 0x0000557c205c3146 +15 polygeist-opt 0x0000557c21248963 +16 polygeist-opt 0x0000557c21245368 +17 polygeist-opt 0x0000557c2106076a +18 polygeist-opt 0x0000557c210619c8 +19 polygeist-opt 0x0000557c21062b59 +20 polygeist-opt 0x0000557c205c3146 +21 polygeist-opt 0x0000557c210628e5 +22 polygeist-opt 0x0000557c21061c3a +23 polygeist-opt 0x0000557c21061d77 +24 polygeist-opt 0x0000557c1c1eb243 +25 polygeist-opt 0x0000557c1de70e51 +26 polygeist-opt 0x0000557c2132b7fd +27 polygeist-opt 0x0000557c2132f4da +28 polygeist-opt 0x0000557c205c3146 +29 polygeist-opt 0x0000557c2133525b +30 polygeist-opt 0x0000557c2132bc1f +31 polygeist-opt 0x0000557c2132befa +32 polygeist-opt 0x0000557c2132de20 +33 polygeist-opt 0x0000557c2132dc78 +34 polygeist-opt 0x0000557c1e4b6ffd +35 polygeist-opt 0x0000557c1e4b75d1 +36 polygeist-opt 0x0000557c1e4b770b +37 polygeist-opt 0x0000557c1e4b884a +38 polygeist-opt 0x0000557c216d5f31 +39 polygeist-opt 0x0000557c216d57fb +40 polygeist-opt 0x0000557c1e4b78c0 +41 polygeist-opt 0x0000557c1e4b7e7d +42 polygeist-opt 0x0000557c1c08690e +43 libc.so.6 0x00007f199b58ed90 +44 libc.so.6 0x00007f199b58ee40 __libc_start_main + 128 +45 polygeist-opt 0x0000557c1c0862e5 diff --git a/debufferize_stress/err/s02_scf_if_no_else_v2.err b/debufferize_stress/err/s02_scf_if_no_else_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s03_sibling_ifs.err b/debufferize_stress/err/s03_sibling_ifs.err new file mode 100644 index 000000000000..4465c74f8c86 --- /dev/null +++ b/debufferize_stress/err/s03_sibling_ifs.err @@ -0,0 +1,50 @@ +PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace. +Stack dump: +0. Program arguments: polygeist-opt --linalg-debufferize inputs/s03_sibling_ifs.mlir -o after/s03_sibling_ifs.mlir +Stack dump without symbol names (ensure you have llvm-symbolizer in your PATH or set the environment var `LLVM_SYMBOLIZER_PATH` to point to it): +0 polygeist-opt 0x0000555bcd25ec6a +1 polygeist-opt 0x0000555bcd25f086 +2 polygeist-opt 0x0000555bcd25c4d3 +3 polygeist-opt 0x0000555bcd25e502 +4 libc.so.6 0x00007f2d3adae520 +5 polygeist-opt 0x0000555bcd089fae +6 polygeist-opt 0x0000555bcd08a034 +7 polygeist-opt 0x0000555bc7c8948d +8 polygeist-opt 0x0000555bc986ebd1 +9 polygeist-opt 0x0000555bc9878a7a +10 polygeist-opt 0x0000555bc987965a +11 polygeist-opt 0x0000555bc9888fdc +12 polygeist-opt 0x0000555bccc44bf6 +13 polygeist-opt 0x0000555bccc455bb +14 polygeist-opt 0x0000555bcbfc3146 +15 polygeist-opt 0x0000555bccc48963 +16 polygeist-opt 0x0000555bccc45368 +17 polygeist-opt 0x0000555bcca6076a +18 polygeist-opt 0x0000555bcca619c8 +19 polygeist-opt 0x0000555bcca62b59 +20 polygeist-opt 0x0000555bcbfc3146 +21 polygeist-opt 0x0000555bcca628e5 +22 polygeist-opt 0x0000555bcca61c3a +23 polygeist-opt 0x0000555bcca61d77 +24 polygeist-opt 0x0000555bc7beb243 +25 polygeist-opt 0x0000555bc9870e51 +26 polygeist-opt 0x0000555bccd2b7fd +27 polygeist-opt 0x0000555bccd2f4da +28 polygeist-opt 0x0000555bcbfc3146 +29 polygeist-opt 0x0000555bccd3525b +30 polygeist-opt 0x0000555bccd2bc1f +31 polygeist-opt 0x0000555bccd2befa +32 polygeist-opt 0x0000555bccd2de20 +33 polygeist-opt 0x0000555bccd2dc78 +34 polygeist-opt 0x0000555bc9eb6ffd +35 polygeist-opt 0x0000555bc9eb75d1 +36 polygeist-opt 0x0000555bc9eb770b +37 polygeist-opt 0x0000555bc9eb884a +38 polygeist-opt 0x0000555bcd0d5f31 +39 polygeist-opt 0x0000555bcd0d57fb +40 polygeist-opt 0x0000555bc9eb78c0 +41 polygeist-opt 0x0000555bc9eb7e7d +42 polygeist-opt 0x0000555bc7a8690e +43 libc.so.6 0x00007f2d3ad95d90 +44 libc.so.6 0x00007f2d3ad95e40 __libc_start_main + 128 +45 polygeist-opt 0x0000555bc7a862e5 diff --git a/debufferize_stress/err/s03_sibling_ifs_v2.err b/debufferize_stress/err/s03_sibling_ifs_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s04_then_else_both_write.err b/debufferize_stress/err/s04_then_else_both_write.err new file mode 100644 index 000000000000..b642d8ce5592 --- /dev/null +++ b/debufferize_stress/err/s04_then_else_both_write.err @@ -0,0 +1,50 @@ +PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace. +Stack dump: +0. Program arguments: polygeist-opt --linalg-debufferize inputs/s04_then_else_both_write.mlir -o after/s04_then_else_both_write.mlir +Stack dump without symbol names (ensure you have llvm-symbolizer in your PATH or set the environment var `LLVM_SYMBOLIZER_PATH` to point to it): +0 polygeist-opt 0x0000564121762c6a +1 polygeist-opt 0x0000564121763086 +2 polygeist-opt 0x00005641217604d3 +3 polygeist-opt 0x0000564121762502 +4 libc.so.6 0x00007ffa49934520 +5 polygeist-opt 0x000056412158dfae +6 polygeist-opt 0x000056412158e034 +7 polygeist-opt 0x000056411c18d48d +8 polygeist-opt 0x000056411dd72bd1 +9 polygeist-opt 0x000056411dd7ca7a +10 polygeist-opt 0x000056411dd7d65a +11 polygeist-opt 0x000056411dd8cfdc +12 polygeist-opt 0x0000564121148bf6 +13 polygeist-opt 0x00005641211495bb +14 polygeist-opt 0x00005641204c7146 +15 polygeist-opt 0x000056412114c963 +16 polygeist-opt 0x0000564121149368 +17 polygeist-opt 0x0000564120f6476a +18 polygeist-opt 0x0000564120f659c8 +19 polygeist-opt 0x0000564120f66b59 +20 polygeist-opt 0x00005641204c7146 +21 polygeist-opt 0x0000564120f668e5 +22 polygeist-opt 0x0000564120f65c3a +23 polygeist-opt 0x0000564120f65d77 +24 polygeist-opt 0x000056411c0ef243 +25 polygeist-opt 0x000056411dd74e51 +26 polygeist-opt 0x000056412122f7fd +27 polygeist-opt 0x00005641212334da +28 polygeist-opt 0x00005641204c7146 +29 polygeist-opt 0x000056412123925b +30 polygeist-opt 0x000056412122fc1f +31 polygeist-opt 0x000056412122fefa +32 polygeist-opt 0x0000564121231e20 +33 polygeist-opt 0x0000564121231c78 +34 polygeist-opt 0x000056411e3baffd +35 polygeist-opt 0x000056411e3bb5d1 +36 polygeist-opt 0x000056411e3bb70b +37 polygeist-opt 0x000056411e3bc84a +38 polygeist-opt 0x00005641215d9f31 +39 polygeist-opt 0x00005641215d97fb +40 polygeist-opt 0x000056411e3bb8c0 +41 polygeist-opt 0x000056411e3bbe7d +42 polygeist-opt 0x000056411bf8a90e +43 libc.so.6 0x00007ffa4991bd90 +44 libc.so.6 0x00007ffa4991be40 __libc_start_main + 128 +45 polygeist-opt 0x000056411bf8a2e5 diff --git a/debufferize_stress/err/s04_then_else_both_write_v2.err b/debufferize_stress/err/s04_then_else_both_write_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s05_then_load_after_store.err b/debufferize_stress/err/s05_then_load_after_store.err new file mode 100644 index 000000000000..90c4331c7705 --- /dev/null +++ b/debufferize_stress/err/s05_then_load_after_store.err @@ -0,0 +1,7 @@ +inputs/s05_then_load_after_store.mlir:15:13: error: operand #0 does not dominate this use + %l2 = memref.load %x[%i0] : memref<8xf64> + ^ +inputs/s05_then_load_after_store.mlir:15:13: note: see current operation: %4 = "tensor.extract"(%4, %0) : (tensor<8xf64>, index) -> f64 +inputs/s05_then_load_after_store.mlir:11:7: note: operand defined here (op is neither in a parent nor in a child region) + memref.store %v, %x[%i0] : memref<8xf64> + ^ diff --git a/debufferize_stress/err/s05_then_load_after_store_v2.err b/debufferize_stress/err/s05_then_load_after_store_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s06_scf_while.err b/debufferize_stress/err/s06_scf_while.err new file mode 100644 index 000000000000..131c44588aaa --- /dev/null +++ b/debufferize_stress/err/s06_scf_while.err @@ -0,0 +1,50 @@ +PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace. +Stack dump: +0. Program arguments: polygeist-opt --linalg-debufferize inputs/s06_scf_while.mlir -o after/s06_scf_while.mlir +Stack dump without symbol names (ensure you have llvm-symbolizer in your PATH or set the environment var `LLVM_SYMBOLIZER_PATH` to point to it): +0 polygeist-opt 0x00005652f290ec6a +1 polygeist-opt 0x00005652f290f086 +2 polygeist-opt 0x00005652f290c4d3 +3 polygeist-opt 0x00005652f290e502 +4 libc.so.6 0x00007f6d90556520 +5 polygeist-opt 0x00005652f2739fae +6 polygeist-opt 0x00005652f273a034 +7 polygeist-opt 0x00005652ed33948d +8 polygeist-opt 0x00005652eef1ebd1 +9 polygeist-opt 0x00005652eef28a7a +10 polygeist-opt 0x00005652eef2965a +11 polygeist-opt 0x00005652eef38fdc +12 polygeist-opt 0x00005652f22f4bf6 +13 polygeist-opt 0x00005652f22f55bb +14 polygeist-opt 0x00005652f1673146 +15 polygeist-opt 0x00005652f22f8963 +16 polygeist-opt 0x00005652f22f5368 +17 polygeist-opt 0x00005652f211076a +18 polygeist-opt 0x00005652f21119c8 +19 polygeist-opt 0x00005652f2112b59 +20 polygeist-opt 0x00005652f1673146 +21 polygeist-opt 0x00005652f21128e5 +22 polygeist-opt 0x00005652f2111c3a +23 polygeist-opt 0x00005652f2111d77 +24 polygeist-opt 0x00005652ed29b243 +25 polygeist-opt 0x00005652eef20e51 +26 polygeist-opt 0x00005652f23db7fd +27 polygeist-opt 0x00005652f23df4da +28 polygeist-opt 0x00005652f1673146 +29 polygeist-opt 0x00005652f23e525b +30 polygeist-opt 0x00005652f23dbc1f +31 polygeist-opt 0x00005652f23dbefa +32 polygeist-opt 0x00005652f23dde20 +33 polygeist-opt 0x00005652f23ddc78 +34 polygeist-opt 0x00005652ef566ffd +35 polygeist-opt 0x00005652ef5675d1 +36 polygeist-opt 0x00005652ef56770b +37 polygeist-opt 0x00005652ef56884a +38 polygeist-opt 0x00005652f2785f31 +39 polygeist-opt 0x00005652f27857fb +40 polygeist-opt 0x00005652ef5678c0 +41 polygeist-opt 0x00005652ef567e7d +42 polygeist-opt 0x00005652ed13690e +43 libc.so.6 0x00007f6d9053dd90 +44 libc.so.6 0x00007f6d9053de40 __libc_start_main + 128 +45 polygeist-opt 0x00005652ed1362e5 diff --git a/debufferize_stress/err/s06_scf_while_v2.err b/debufferize_stress/err/s06_scf_while_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s07_memref_cast.err b/debufferize_stress/err/s07_memref_cast.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s07_memref_cast_v2.err b/debufferize_stress/err/s07_memref_cast_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s08_func_call_consumer.err b/debufferize_stress/err/s08_func_call_consumer.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s08_func_call_consumer_v2.err b/debufferize_stress/err/s08_func_call_consumer_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s09_same_memref_in_and_out.err b/debufferize_stress/err/s09_same_memref_in_and_out.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s09_same_memref_in_and_out_v2.err b/debufferize_stress/err/s09_same_memref_in_and_out_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s10_multi_block_region.err b/debufferize_stress/err/s10_multi_block_region.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s10_multi_block_region_v2.err b/debufferize_stress/err/s10_multi_block_region_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s11_scf_for_then_load_outside.err b/debufferize_stress/err/s11_scf_for_then_load_outside.err new file mode 100644 index 000000000000..b185be2b867b --- /dev/null +++ b/debufferize_stress/err/s11_scf_for_then_load_outside.err @@ -0,0 +1,56 @@ +polygeist-opt: /home/arjaiswal/Polygeist/llvm-project/mlir/lib/IR/PatternMatch.cpp:326: mlir::RewriterBase::eraseOp(mlir::Operation*)::: Assertion `mayBeGraphRegion(*op->getParentRegion()) && "expected that op has no uses"' failed. +PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace. +Stack dump: +0. Program arguments: polygeist-opt --linalg-debufferize inputs/s11_scf_for_then_load_outside.mlir -o after/s11_scf_for_then_load_outside.mlir +Stack dump without symbol names (ensure you have llvm-symbolizer in your PATH or set the environment var `LLVM_SYMBOLIZER_PATH` to point to it): +0 polygeist-opt 0x0000559fed05fc6a +1 polygeist-opt 0x0000559fed060086 +2 polygeist-opt 0x0000559fed05d4d3 +3 polygeist-opt 0x0000559fed05f502 +4 libc.so.6 0x00007fbdaf4eb520 +5 libc.so.6 0x00007fbdaf53f9fc pthread_kill + 300 +6 libc.so.6 0x00007fbdaf4eb476 raise + 22 +7 libc.so.6 0x00007fbdaf4d17f3 abort + 211 +8 libc.so.6 0x00007fbdaf4d171b +9 libc.so.6 0x00007fbdaf4e2e96 +10 polygeist-opt 0x0000559fece873d3 +11 polygeist-opt 0x0000559fece8786b +12 polygeist-opt 0x0000559fece889ce +13 polygeist-opt 0x0000559fece887dd +14 polygeist-opt 0x0000559fece8861e +15 polygeist-opt 0x0000559fe7a91c99 +16 polygeist-opt 0x0000559fece87638 +17 polygeist-opt 0x0000559fece889ce +18 polygeist-opt 0x0000559fece887dd +19 polygeist-opt 0x0000559fece8861e +20 polygeist-opt 0x0000559fe7a91c99 +21 polygeist-opt 0x0000559fece87946 +22 polygeist-opt 0x0000559fec861566 +23 polygeist-opt 0x0000559fec8629c8 +24 polygeist-opt 0x0000559fec863b59 +25 polygeist-opt 0x0000559febdc4146 +26 polygeist-opt 0x0000559fec8638e5 +27 polygeist-opt 0x0000559fec862c3a +28 polygeist-opt 0x0000559fec862d77 +29 polygeist-opt 0x0000559fe79ec243 +30 polygeist-opt 0x0000559fe9671e51 +31 polygeist-opt 0x0000559fecb2c7fd +32 polygeist-opt 0x0000559fecb304da +33 polygeist-opt 0x0000559febdc4146 +34 polygeist-opt 0x0000559fecb3625b +35 polygeist-opt 0x0000559fecb2cc1f +36 polygeist-opt 0x0000559fecb2cefa +37 polygeist-opt 0x0000559fecb2ee20 +38 polygeist-opt 0x0000559fecb2ec78 +39 polygeist-opt 0x0000559fe9cb7ffd +40 polygeist-opt 0x0000559fe9cb85d1 +41 polygeist-opt 0x0000559fe9cb870b +42 polygeist-opt 0x0000559fe9cb984a +43 polygeist-opt 0x0000559feced6f31 +44 polygeist-opt 0x0000559feced67fb +45 polygeist-opt 0x0000559fe9cb88c0 +46 polygeist-opt 0x0000559fe9cb8e7d +47 polygeist-opt 0x0000559fe788790e +48 libc.so.6 0x00007fbdaf4d2d90 +49 libc.so.6 0x00007fbdaf4d2e40 __libc_start_main + 128 +50 polygeist-opt 0x0000559fe78872e5 diff --git a/debufferize_stress/err/s11_scf_for_then_load_outside_v2.err b/debufferize_stress/err/s11_scf_for_then_load_outside_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s12_affine_for_iter_arg_with_memref.err b/debufferize_stress/err/s12_affine_for_iter_arg_with_memref.err new file mode 100644 index 000000000000..2dc1af3f483c --- /dev/null +++ b/debufferize_stress/err/s12_affine_for_iter_arg_with_memref.err @@ -0,0 +1,50 @@ +PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace. +Stack dump: +0. Program arguments: polygeist-opt --linalg-debufferize inputs/s12_affine_for_iter_arg_with_memref.mlir -o after/s12_affine_for_iter_arg_with_memref.mlir +Stack dump without symbol names (ensure you have llvm-symbolizer in your PATH or set the environment var `LLVM_SYMBOLIZER_PATH` to point to it): +0 polygeist-opt 0x000055e930d6ec6a +1 polygeist-opt 0x000055e930d6f086 +2 polygeist-opt 0x000055e930d6c4d3 +3 polygeist-opt 0x000055e930d6e502 +4 libc.so.6 0x00007fc909545520 +5 polygeist-opt 0x000055e930b99fae +6 polygeist-opt 0x000055e930b9a034 +7 polygeist-opt 0x000055e92b79948d +8 polygeist-opt 0x000055e92d37ebd1 +9 polygeist-opt 0x000055e92d388a7a +10 polygeist-opt 0x000055e92d38965a +11 polygeist-opt 0x000055e92d398fdc +12 polygeist-opt 0x000055e930754bf6 +13 polygeist-opt 0x000055e9307555bb +14 polygeist-opt 0x000055e92fad3146 +15 polygeist-opt 0x000055e930758963 +16 polygeist-opt 0x000055e930755368 +17 polygeist-opt 0x000055e93057076a +18 polygeist-opt 0x000055e9305719c8 +19 polygeist-opt 0x000055e930572b59 +20 polygeist-opt 0x000055e92fad3146 +21 polygeist-opt 0x000055e9305728e5 +22 polygeist-opt 0x000055e930571c3a +23 polygeist-opt 0x000055e930571d77 +24 polygeist-opt 0x000055e92b6fb243 +25 polygeist-opt 0x000055e92d380e51 +26 polygeist-opt 0x000055e93083b7fd +27 polygeist-opt 0x000055e93083f4da +28 polygeist-opt 0x000055e92fad3146 +29 polygeist-opt 0x000055e93084525b +30 polygeist-opt 0x000055e93083bc1f +31 polygeist-opt 0x000055e93083befa +32 polygeist-opt 0x000055e93083de20 +33 polygeist-opt 0x000055e93083dc78 +34 polygeist-opt 0x000055e92d9c6ffd +35 polygeist-opt 0x000055e92d9c75d1 +36 polygeist-opt 0x000055e92d9c770b +37 polygeist-opt 0x000055e92d9c884a +38 polygeist-opt 0x000055e930be5f31 +39 polygeist-opt 0x000055e930be57fb +40 polygeist-opt 0x000055e92d9c78c0 +41 polygeist-opt 0x000055e92d9c7e7d +42 polygeist-opt 0x000055e92b59690e +43 libc.so.6 0x00007fc90952cd90 +44 libc.so.6 0x00007fc90952ce40 __libc_start_main + 128 +45 polygeist-opt 0x000055e92b5962e5 diff --git a/debufferize_stress/err/s12_affine_for_iter_arg_with_memref_v2.err b/debufferize_stress/err/s12_affine_for_iter_arg_with_memref_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s13_two_allocas_aliased_via_cast.err b/debufferize_stress/err/s13_two_allocas_aliased_via_cast.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s13_two_allocas_aliased_via_cast_v2.err b/debufferize_stress/err/s13_two_allocas_aliased_via_cast_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s14_memref_subview.err b/debufferize_stress/err/s14_memref_subview.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s14_memref_subview_v2.err b/debufferize_stress/err/s14_memref_subview_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s15_dealloc.err b/debufferize_stress/err/s15_dealloc.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s15_dealloc_v2.err b/debufferize_stress/err/s15_dealloc_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s16_linalg_inside_if.err b/debufferize_stress/err/s16_linalg_inside_if.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s16_linalg_inside_if_v2.err b/debufferize_stress/err/s16_linalg_inside_if_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s17_linalg_then_load_outside.err b/debufferize_stress/err/s17_linalg_then_load_outside.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s17_linalg_then_load_outside_v2.err b/debufferize_stress/err/s17_linalg_then_load_outside_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s18_alloca_reduction_then_load.err b/debufferize_stress/err/s18_alloca_reduction_then_load.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/err/s18_alloca_reduction_then_load_v2.err b/debufferize_stress/err/s18_alloca_reduction_then_load_v2.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/debufferize_stress/inputs/s01_submap_of_submap.mlir b/debufferize_stress/inputs/s01_submap_of_submap.mlir new file mode 100644 index 000000000000..f5fc5795f7b3 --- /dev/null +++ b/debufferize_stress/inputs/s01_submap_of_submap.mlir @@ -0,0 +1,28 @@ +// INTENT: two-level submap chain (submap of submap). The pass's +// traceSubmapChainToRoot collects both, but the re-emission only uses the +// LEAF submap's map + operands. Intermediate level is dropped — expect +// either silently wrong IR or a verifier failure. + +#map = affine_map<(d0) -> (d0)> +module { + func.func @submap_of_submap(%n: index, %s1: index, %s2: index, + %x: memref, %y: memref) { + // Outer submap (stride s1) + %xa = polygeist.submap(%x, %s1, %n) {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (memref, index, index) -> memref + %ya = polygeist.submap(%y, %s1, %n) {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (memref, index, index) -> memref + // Inner submap on top (stride s2 on the already-strided view) + %xb = polygeist.submap(%xa, %s2, %n) {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (memref, index, index) -> memref + %yb = polygeist.submap(%ya, %s2, %n) {map = affine_map<(d0)[s0] -> (d0 * s0)>} + : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} + ins(%xb : memref) outs(%yb : memref) { + ^bb0(%in: f64, %out: f64): + %v = arith.addf %in, %out : f64 + linalg.yield %v : f64 + } + return + } +} diff --git a/debufferize_stress/inputs/s02_scf_if_no_else.mlir b/debufferize_stress/inputs/s02_scf_if_no_else.mlir new file mode 100644 index 000000000000..eb6a6f528387 --- /dev/null +++ b/debufferize_stress/inputs/s02_scf_if_no_else.mlir @@ -0,0 +1,17 @@ +// INTENT: scf.if without an else region. The store happens conditionally; +// the rebuild must synthesize an else branch that yields the entry tensor. +// In propagateValueThroughRegion the `hadElse` path (line ~593) handles this, +// but the if-finalization codepath in the main loop assumes both branches +// were entered. + +#map = affine_map<(d0) -> (d0)> +module { + func.func @if_no_else(%cond: i1, %n: index, %x: memref) { + %cst = arith.constant 1.0 : f64 + %c0 = arith.constant 0 : index + scf.if %cond { + memref.store %cst, %x[%c0] : memref + } + return + } +} diff --git a/debufferize_stress/inputs/s03_sibling_ifs.mlir b/debufferize_stress/inputs/s03_sibling_ifs.mlir new file mode 100644 index 000000000000..487e4fd7f0bf --- /dev/null +++ b/debufferize_stress/inputs/s03_sibling_ifs.mlir @@ -0,0 +1,21 @@ +// INTENT: two sibling scf.if at function-body level, both storing into the +// same memref. The second if must see the FIRST if's *rebuilt* result as its +// entry tensor, not the original to_tensor — the function-body if eager +// rebuild at line 942-967 is what makes this work. Verify. + +#map = affine_map<(d0) -> (d0)> +module { + func.func @sibling_ifs(%c1: i1, %c2: i1, %x: memref<8xf64>) { + %v1 = arith.constant 1.0 : f64 + %v2 = arith.constant 2.0 : f64 + %i0 = arith.constant 0 : index + %i1_ = arith.constant 1 : index + scf.if %c1 { + memref.store %v1, %x[%i0] : memref<8xf64> + } + scf.if %c2 { + memref.store %v2, %x[%i1_] : memref<8xf64> + } + return + } +} diff --git a/debufferize_stress/inputs/s04_then_else_both_write.mlir b/debufferize_stress/inputs/s04_then_else_both_write.mlir new file mode 100644 index 000000000000..b5d1a91a0ed7 --- /dev/null +++ b/debufferize_stress/inputs/s04_then_else_both_write.mlir @@ -0,0 +1,18 @@ +// INTENT: scf.if where BOTH branches store to the same memref at different +// indices. Each branch's result must yield from its own modified tensor; +// the eventual if must have a single result tensor that downstream code uses. + +module { + func.func @then_else_both_write(%cond: i1, %x: memref<8xf64>) { + %v1 = arith.constant 1.0 : f64 + %v2 = arith.constant 2.0 : f64 + %i0 = arith.constant 0 : index + %i1 = arith.constant 1 : index + scf.if %cond { + memref.store %v1, %x[%i0] : memref<8xf64> + } else { + memref.store %v2, %x[%i1] : memref<8xf64> + } + return + } +} diff --git a/debufferize_stress/inputs/s05_then_load_after_store.mlir b/debufferize_stress/inputs/s05_then_load_after_store.mlir new file mode 100644 index 000000000000..03698d3efb43 --- /dev/null +++ b/debufferize_stress/inputs/s05_then_load_after_store.mlir @@ -0,0 +1,20 @@ +// INTENT: scf.if writes to %x then reads from it within the same branch. +// The load inside the THEN branch must extract from the just-modified +// tensor — i.e. the load should see the *insert's* result, not the +// pre-if entry tensor. Verifies intra-region threading. + +module { + func.func @then_load_after_store(%cond: i1, %x: memref<8xf64>) -> f64 { + %v = arith.constant 3.14 : f64 + %i0 = arith.constant 0 : index + %r = scf.if %cond -> f64 { + memref.store %v, %x[%i0] : memref<8xf64> + %l = memref.load %x[%i0] : memref<8xf64> + scf.yield %l : f64 + } else { + %l2 = memref.load %x[%i0] : memref<8xf64> + scf.yield %l2 : f64 + } + return %r : f64 + } +} diff --git a/debufferize_stress/inputs/s06_scf_while.mlir b/debufferize_stress/inputs/s06_scf_while.mlir new file mode 100644 index 000000000000..bc681811918e --- /dev/null +++ b/debufferize_stress/inputs/s06_scf_while.mlir @@ -0,0 +1,22 @@ +// INTENT: scf.while contains memref stores. propagateValueThroughRegion only +// has codepaths for scf.if and scf.for — there's no scf.while branch. Expect +// the inner store to be rewritten but the tensor SSA threading to fail at +// finalization (the while's region won't get an iter_arg added). + +module { + func.func @scf_while_store(%n: index, %x: memref) { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %v = arith.constant 1.0 : f64 + %final = scf.while (%i = %c0) : (index) -> index { + %cond = arith.cmpi slt, %i, %n : index + scf.condition(%cond) %i : index + } do { + ^bb0(%i: index): + memref.store %v, %x[%i] : memref + %next = arith.addi %i, %c1 : index + scf.yield %next : index + } + return + } +} diff --git a/debufferize_stress/inputs/s07_memref_cast.mlir b/debufferize_stress/inputs/s07_memref_cast.mlir new file mode 100644 index 000000000000..dd9c52ef4812 --- /dev/null +++ b/debufferize_stress/inputs/s07_memref_cast.mlir @@ -0,0 +1,14 @@ +// INTENT: a memref.cast user — pass's supported-user set doesn't include +// memref.cast. collectMemoryOpsRecursively will skip it, so the store +// reached via the cast is not in the user list at all → not rewritten. +// Expect: store untouched, function still memref-typed, no debufferization. + +module { + func.func @cast_then_store(%x: memref<8xf64>) { + %xc = memref.cast %x : memref<8xf64> to memref + %v = arith.constant 1.0 : f64 + %i0 = arith.constant 0 : index + memref.store %v, %xc[%i0] : memref + return + } +} diff --git a/debufferize_stress/inputs/s08_func_call_consumer.mlir b/debufferize_stress/inputs/s08_func_call_consumer.mlir new file mode 100644 index 000000000000..56384ede64a9 --- /dev/null +++ b/debufferize_stress/inputs/s08_func_call_consumer.mlir @@ -0,0 +1,15 @@ +// INTENT: memref passed to a func.call. Call isn't in the supported-user +// set; the call may modify the memref in a way the pass can't track. +// Expect: pass either ignores the call (treats memref as not modified by it) +// or fails to debufferize. Test reveals which. + +module { + func.func private @sink(memref) + func.func @call_consumer(%n: index, %x: memref) { + %v = arith.constant 1.0 : f64 + %i0 = arith.constant 0 : index + memref.store %v, %x[%i0] : memref + func.call @sink(%x) : (memref) -> () + return + } +} diff --git a/debufferize_stress/inputs/s09_same_memref_in_and_out.mlir b/debufferize_stress/inputs/s09_same_memref_in_and_out.mlir new file mode 100644 index 000000000000..38205c1384a1 --- /dev/null +++ b/debufferize_stress/inputs/s09_same_memref_in_and_out.mlir @@ -0,0 +1,24 @@ +// INTENT: linalg.generic uses the SAME memref both as an input and as an +// output (read-then-write). Two submap chains both terminate at %x. The +// pass processes input and output operands separately, both pulling from +// `currentTensor`; the input submap and output submap will both reference +// the same SSA tensor pre-update. Verify the resulting IR is correct +// (the output should still update via submapInverse, and the input read +// should observe pre-update values per linalg semantics). + +#map = affine_map<(d0) -> (d0)> +module { + func.func @in_eq_out(%n: index, %x: memref) { + %xs = polygeist.submap(%x, %n) {map = #map} + : (memref, index) -> memref + %xo = polygeist.submap(%x, %n) {map = #map} + : (memref, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} + ins(%xs : memref) outs(%xo : memref) { + ^bb0(%in: f64, %out: f64): + %v = arith.mulf %in, %in : f64 + linalg.yield %v : f64 + } + return + } +} diff --git a/debufferize_stress/inputs/s10_multi_block_region.mlir b/debufferize_stress/inputs/s10_multi_block_region.mlir new file mode 100644 index 000000000000..27e72cb7d783 --- /dev/null +++ b/debufferize_stress/inputs/s10_multi_block_region.mlir @@ -0,0 +1,17 @@ +// INTENT: function body has TWO basic blocks (cf.br between them). The pass +// uses region->front() (e.g. line 480), assuming exactly one block. With two +// blocks the second block's stores are technically still in the same region +// but may not be properly handled. + +module { + func.func @two_blocks(%cond: i1, %x: memref<8xf64>) { + %v = arith.constant 1.0 : f64 + %i0 = arith.constant 0 : index + %i1 = arith.constant 1 : index + memref.store %v, %x[%i0] : memref<8xf64> + cf.br ^bb1 + ^bb1: + memref.store %v, %x[%i1] : memref<8xf64> + return + } +} diff --git a/debufferize_stress/inputs/s11_scf_for_then_load_outside.mlir b/debufferize_stress/inputs/s11_scf_for_then_load_outside.mlir new file mode 100644 index 000000000000..ae5277a6af5f --- /dev/null +++ b/debufferize_stress/inputs/s11_scf_for_then_load_outside.mlir @@ -0,0 +1,17 @@ +// INTENT: scf.for body modifies the memref via stores in every iteration, +// then *after* the loop the same memref is loaded. The loop must be +// rewritten with an iter_arg + yield; the post-loop load must extract from +// the loop's *result*, not from the original to_tensor. + +module { + func.func @for_then_load(%n: index, %x: memref) -> f64 { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %v = arith.constant 1.0 : f64 + scf.for %i = %c0 to %n step %c1 { + memref.store %v, %x[%i] : memref + } + %out = memref.load %x[%c0] : memref + return %out : f64 + } +} diff --git a/debufferize_stress/inputs/s12_affine_for_iter_arg_with_memref.mlir b/debufferize_stress/inputs/s12_affine_for_iter_arg_with_memref.mlir new file mode 100644 index 000000000000..605dfcc40a55 --- /dev/null +++ b/debufferize_stress/inputs/s12_affine_for_iter_arg_with_memref.mlir @@ -0,0 +1,17 @@ +// INTENT: affine.for has iter_args carrying a SCALAR plus stores to a +// memref in each iteration. The pass must handle iter_args on affine.for +// (propagateValueThroughRegion only adds iter_args for scf.for and yields +// for scf.if — there's NO affine.for branch). + +module { + func.func @affine_for_with_iter(%n: index, %x: memref) -> f64 { + %cst = arith.constant 0.0 : f64 + %v = arith.constant 1.0 : f64 + %s = affine.for %i = 0 to %n iter_args(%acc = %cst) -> f64 { + memref.store %v, %x[%i] : memref + %a = arith.addf %acc, %v : f64 + affine.yield %a : f64 + } + return %s : f64 + } +} diff --git a/debufferize_stress/inputs/s13_two_allocas_aliased_via_cast.mlir b/debufferize_stress/inputs/s13_two_allocas_aliased_via_cast.mlir new file mode 100644 index 000000000000..eadae4adbbce --- /dev/null +++ b/debufferize_stress/inputs/s13_two_allocas_aliased_via_cast.mlir @@ -0,0 +1,18 @@ +// INTENT: two allocas of different static shape are both viewed via cast +// onto the same dynamic shape, then a store happens through the cast view. +// The per-root iteration treats each alloca independently — the cast user +// breaks the assumption that all uses of an alloca are typed identically. + +module { + func.func @aliased_allocas() { + %a = memref.alloca() : memref<4xf64> + %b = memref.alloca() : memref<4xf64> + %ac = memref.cast %a : memref<4xf64> to memref + %bc = memref.cast %b : memref<4xf64> to memref + %v = arith.constant 1.0 : f64 + %i0 = arith.constant 0 : index + memref.store %v, %ac[%i0] : memref + memref.store %v, %bc[%i0] : memref + return + } +} diff --git a/debufferize_stress/inputs/s14_memref_subview.mlir b/debufferize_stress/inputs/s14_memref_subview.mlir new file mode 100644 index 000000000000..8382a6e95758 --- /dev/null +++ b/debufferize_stress/inputs/s14_memref_subview.mlir @@ -0,0 +1,15 @@ +// INTENT: memref.subview between alloca and store. memref.subview IS listed +// in areAllUsersSupportedForDebufferization but is NOT in +// collectMemoryOpsRecursively's recursion set (only polygeist.submap is). +// Expect: the store via the subview is NOT collected, so the alloca is +// effectively treated as having no users → debuf is a no-op for it. + +module { + func.func @subview_then_store(%x: memref<8x8xf64>) { + %sv = memref.subview %x[0, 0] [4, 4] [1, 1] : memref<8x8xf64> to memref<4x4xf64, strided<[8, 1]>> + %v = arith.constant 1.0 : f64 + %i0 = arith.constant 0 : index + memref.store %v, %sv[%i0, %i0] : memref<4x4xf64, strided<[8, 1]>> + return + } +} diff --git a/debufferize_stress/inputs/s15_dealloc.mlir b/debufferize_stress/inputs/s15_dealloc.mlir new file mode 100644 index 000000000000..b76296beb978 --- /dev/null +++ b/debufferize_stress/inputs/s15_dealloc.mlir @@ -0,0 +1,14 @@ +// INTENT: an alloc is followed by a store and finally a dealloc. The dealloc +// is not in the supported-user set. Check whether the pass handles dealloc +// gracefully (it has no tensor analogue) or chokes. + +module { + func.func @with_dealloc(%n: index) { + %a = memref.alloc(%n) : memref + %v = arith.constant 1.0 : f64 + %i0 = arith.constant 0 : index + memref.store %v, %a[%i0] : memref + memref.dealloc %a : memref + return + } +} diff --git a/debufferize_stress/inputs/s16_linalg_inside_if.mlir b/debufferize_stress/inputs/s16_linalg_inside_if.mlir new file mode 100644 index 000000000000..365ab106e714 --- /dev/null +++ b/debufferize_stress/inputs/s16_linalg_inside_if.mlir @@ -0,0 +1,19 @@ +// INTENT: linalg.generic on a memref nested inside scf.if (sgemm pattern). +// The threading must lift the generic's result through the if's branches. + +#map = affine_map<(d0) -> (d0)> +module { + func.func @linalg_inside_if(%cond: i1, %n: index, %y: memref) { + %v = arith.constant 1.0 : f64 + scf.if %cond { + %ys = polygeist.submap(%y, %n) {map = #map} + : (memref, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} + outs(%ys : memref) { + ^bb0(%out: f64): + linalg.yield %v : f64 + } + } + return + } +} diff --git a/debufferize_stress/inputs/s17_linalg_then_load_outside.mlir b/debufferize_stress/inputs/s17_linalg_then_load_outside.mlir new file mode 100644 index 000000000000..6fb47dd967ab --- /dev/null +++ b/debufferize_stress/inputs/s17_linalg_then_load_outside.mlir @@ -0,0 +1,23 @@ +// INTENT: linalg.generic writes to a strided view, then a memref.load reads +// from the same root outside any region. Tests that the linalg's tensor +// result is correctly threaded to the subsequent load. + +#map = affine_map<(d0) -> (d0)> +module { + func.func @linalg_then_load(%n: index, %x: memref, + %y: memref) -> f64 { + %xs = polygeist.submap(%x, %n) {map = #map} + : (memref, index) -> memref + %ys = polygeist.submap(%y, %n) {map = #map} + : (memref, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} + ins(%xs : memref) outs(%ys : memref) { + ^bb0(%in: f64, %out: f64): + %v = arith.addf %in, %out : f64 + linalg.yield %v : f64 + } + %c0 = arith.constant 0 : index + %r = memref.load %y[%c0] : memref + return %r : f64 + } +} diff --git a/debufferize_stress/inputs/s18_alloca_reduction_then_load.mlir b/debufferize_stress/inputs/s18_alloca_reduction_then_load.mlir new file mode 100644 index 000000000000..dc2985efec33 --- /dev/null +++ b/debufferize_stress/inputs/s18_alloca_reduction_then_load.mlir @@ -0,0 +1,31 @@ +// INTENT: mirrors the post-`--remove-iter-args` shape — a 0-D scalar alloca +// used as the reduction destination inside a loop, then loaded after the +// loop. This is exactly what we just made the BLAS reductions emit. +// Verify the debufferizer handles the 0-D alloca-after-loop pattern end-to-end. + +#map = affine_map<(d0) -> (d0)> +#m0 = affine_map<(d0) -> ()> +module { + func.func @reduction_then_load(%n: index, %x: memref, + %y: memref) -> f64 { + %cst = arith.constant 0.0 : f64 + %slot = memref.alloca() : memref + affine.store %cst, %slot[] : memref + %xs = polygeist.submap(%x, %n) {map = #map} + : (memref, index) -> memref + %ys = polygeist.submap(%y, %n) {map = #map} + : (memref, index) -> memref + %ss = polygeist.submap(%slot, %n) {map = #m0} + : (memref, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], + iterator_types = ["reduction"]} + ins(%xs, %ys : memref, memref) outs(%ss : memref) { + ^bb0(%a: f64, %b: f64, %acc: f64): + %p = arith.mulf %a, %b : f64 + %v = arith.addf %acc, %p : f64 + linalg.yield %v : f64 + } + %r = affine.load %slot[] : memref + return %r : f64 + } +} diff --git a/docs/cpu_blas_runtime.md b/docs/cpu_blas_runtime.md new file mode 100644 index 000000000000..0f3597c54dd5 --- /dev/null +++ b/docs/cpu_blas_runtime.md @@ -0,0 +1,116 @@ +CPU BLAS Runtime Backend +======================== + +Polygeist's `--lower-kernel-launch-to-cublas` ABI can be linked against a CPU +runtime for host-side correctness and performance experiments. By default, +`runtime/polygeist_cublas_rt_cpu.c` uses simple reference loops. For BLAS-like +symbols, it can instead call an optimized CBLAS implementation such as +OpenBLAS, BLIS, MKL, ArmPL, or NVPL. + +Supported CBLAS-routed symbols +------------------------------ + +When `POLYGEIST_CPU_BLAS=1` is set for a host build, the CPU runtime compiles +with `POLYGEIST_CPU_USE_CBLAS` and routes these symbols through CBLAS: + +* `polygeist_cublas_dgemm` +* `polygeist_cublas_sgemm` +* `polygeist_cublas_dgemv` +* `polygeist_cublas_sgemv` +* `polygeist_cublas_dgemv_T` +* `polygeist_cublas_sgemv_T` +* `polygeist_cublas_daxpby` +* `polygeist_cublas_daxpy_unit` +* `polygeist_cublas_dger_rank2` +* `polygeist_cublas_dscal_2d` +* `polygeist_cublas_sgemm_1x1conv` +* `polygeist_cublas_dsyrk` +* `polygeist_cublaslt_matmul_bias_relu` + +Stencil, convolution, limiter, pack/unpack, and other non-BLAS symbols still +use the existing CPU reference implementations unless a separate optimized CPU +backend is added for them. + +Install OpenBLAS on Ubuntu +-------------------------- + +For the default OpenBLAS configuration: + +``` +sudo apt-get update +sudo apt-get install -y libopenblas-dev +``` + +On this VM, unrelated third-party apt repositories may report warnings during +`apt-get update`. The relevant check is that `cblas.h` and `libopenblas.so` +exist: + +``` +find /usr/include /usr/local/include -name cblas.h +ldconfig -p | grep openblas +``` + +Build With OpenBLAS +------------------- + +Set `POLYGEIST_CPU_BLAS=1` for host builds: + +``` +OPENBLAS_NUM_THREADS=1 \ +POLYGEIST_CPU_BLAS=1 \ +PYTHON=/usr/bin/python3 \ +scripts/correctness/polygeist_build.sh \ + issues/proxy_kernel_pipelines/exasp2_pipeline_easy.c \ + --function=exasp2_pipeline_easy \ + --harness=issues/proxy_kernel_pipelines/proxy_pipeline_silicon_large.c \ + --target=host \ + -o /tmp/exasp2_large_raised_host_blas \ + -DEN=512 +``` + +Run: + +``` +OPENBLAS_NUM_THREADS=1 PROXY_PIPELINE_ITERS=3 \ + /tmp/exasp2_large_raised_host_blas +``` + +The selected raised function is the only meaningful timing in a raised harness +run. The surrounding harness code is compiled conservatively so it can call the +generated wrapper without inlining the original C function. + +Using Another CBLAS Provider +---------------------------- + +Override compile and link flags with: + +``` +POLYGEIST_CPU_BLAS=1 +POLYGEIST_CPU_BLAS_CFLAGS="" +POLYGEIST_CPU_BLAS_LIBS="" +``` + +Examples: + +``` +POLYGEIST_CPU_BLAS_LIBS="-lblis" +POLYGEIST_CPU_BLAS_LIBS="-L/path/to/mkl/lib -lmkl_rt" +POLYGEIST_CPU_BLAS_CFLAGS="-I/path/to/armpl/include" +POLYGEIST_CPU_BLAS_LIBS="-L/path/to/armpl/lib -larmpl_lp64_mp" +``` + +Reference Result +---------------- + +On the current x86_64 Cascade Lake VM, using the ExaSP2 512 proxy pipeline: + +``` +native C gcc -O3 225.223896 ms +raised reference CPU shim 467.187299 ms +raised OpenBLAS, 1 thread 19.976757 ms +raised OpenBLAS, 24 threads 52.420795 ms +``` + +The checksums matched. For this 512-size case, single-threaded OpenBLAS was +faster than 24 OpenBLAS threads because thread startup and synchronization +overhead dominates the relatively small GEMM/GEMV workload. diff --git a/docs/row_scratch_privatization_failures.md b/docs/row_scratch_privatization_failures.md new file mode 100644 index 000000000000..ca68b176f609 --- /dev/null +++ b/docs/row_scratch_privatization_failures.md @@ -0,0 +1,165 @@ +# PrivatizeRowScratchAllocaForLoop — Failure Catalogue + +The pattern is *implemented* in `lib/polygeist/Passes/RaiseToLinalg.cpp` +but is **NOT** currently registered in the raise pipeline — the +registration line is commented out, with a comment pointing at this +file. This document records what happens when the pattern *is* enabled, +so a future implementer knows exactly which kernels regress and why. + +To re-enable for experimentation, uncomment the relevant line in +`runOnOperation` (search for `PrivatizeRowScratchAllocaForLoop`). + +Date: 2026-05-16. Sweeps: PolyBench (30 kernels), MachSuite (19), +NPB-polybenchified (7). All other test inputs (BLAS, stress) unchanged. + +## Net result: 4 regressions, 0 improvements + +| kernel | baseline | with pattern | +|-----------------------|--------------------|---------------------| +| **mg-psinv** (NPB ex) | PARTIAL_LIFT 3LG/2AF | **RAISE_FAIL (timeout)** | +| **mg-resid** (NPB ex) | PARTIAL_LIFT 3LG/2AF | **RAISE_FAIL (timeout)** | +| **mg-rprj3** (NPB ex) | PARTIAL_LIFT 3LG/2AF | **RAISE_FAIL (timeout)** | +| **fft-transpose** (MachSuite) | PARTIAL_LIFT 2LG/11AF | **RAISE_FAIL (timeout)** | + +Every other kernel (29 PolyBench + 18 other MachSuite + 4 other NPB +extracted) is bit-identical to baseline. The pattern did not improve any +kernel; it strictly regressed 4. + +## Failure mode (uniform across the 4 regressions) + +1. cgeist emits the kernel as expected. +2. The raise-to-linalg pipeline starts. +3. `PrivatizeRowScratchAllocaForLoop` fires successfully on an outer + `affine.for` containing a rank-1 static `memref.alloca`, rewriting + the alloca to `memref` and adding a per-iteration + `memref.subview ... -> memref>`. +4. Greedy driver continues: `DistributeAffineForOnLinalgGeneric` and + `AffineForOpRaising` each fire once or twice on the new IR. +5. `AffineForOpRaising` starts processing a deeper loop nest, begins + emitting `affine.apply` + `polygeist.submap` ops, and never finishes. +6. Polygeist-opt is killed by the sweep's 60-second timeout. + +`--debug-only=greedy-rewriter` traces confirm: total of 7 successful +pattern applications, then a long tail of failed-match attempts on +unchanged ops. Not a true infinite re-fire loop; the inner pattern's +polyhedral analysis is *very* slow on the post-privatization IR shape. + +## Root-cause hypothesis (best guess; not fully verified) + +The post-privatization rowView is + +```mlir +%row = memref.subview %new[%iv, 0] [1, %N] [1, 1] + : memref to memref> +``` + +The dynamic `offset: ?` in the strided layout type appears to defeat +`AffineForOpRaising`'s dep-check. The existing rank-0 +`PrivatizeScratchAllocaForLoop` instead uses `polygeist.submap` to +express row-selection — and that path doesn't trigger the same +slowdown. So the next attempt should rewrite users via +`polygeist.submap` (passing `%iv` as an extra symbol) rather than +`memref.subview`. + +## Failure-by-failure detail + +### NPB-polybenchified/mg-psinv + +Baseline raised IR (working without pattern): + +```mlir +%alloca = memref.alloca() : memref<35xf64> +%alloca_0 = memref.alloca() : memref<35xf64> +affine.for %i3 = 1 to N-1 { + affine.for %i2 = 1 to N-1 { + linalg.generic outs(%alloca_0 : memref<35xf64>) ... // pass 1 fill (a) + linalg.generic outs(%alloca : memref<35xf64>) ... // pass 1 fill (b) + linalg.generic ins(... subviews of alloca/alloca_0 ...) + outs(... subview of arg1 ...) // pass 2 + } +} +``` + +After pattern fires (with all patterns enabled), polygeist-opt times out +inside `AffineForOpRaising` on the inner i1 loop. The pattern's rewrite +is structurally fine — verified by running with `DistributeAffineForOnLinalgGeneric` +*disabled*, which produces clean post-rewrite IR (mg_psinv goes to +1LG/3AF residual). With Distribute enabled, the pipeline hangs. + +### NPB-polybenchified/mg-resid + +Identical shape to mg-psinv. Same failure mode. + +### NPB-polybenchified/mg-rprj3 + +Identical shape (restriction operator with row scratch). +Same failure mode. + +### MachSuite/fft-transpose + +```mlir +%alloca = memref.alloca() : memref<576xf64> +%alloca_5 = memref.alloca() : memref<8xf64> +%alloca_6 = memref.alloca() : memref<8xf64> +%alloca_7 = memref.alloca() : memref<512xf64> +%alloca_8 = memref.alloca() : memref<512xf64> +%alloca_9 = memref.alloca() : memref<8xi32> +``` + +Multiple rank-1 static scratch allocas. Pattern fires on at least one. +Then polygeist-opt is killed by the 60-second sweep timeout. Note this +is a regression on a benchmark where the C source has *much* less +clean a structure than mg_psinv — it's the bit-reversal FFT with lots +of imperative control flow — yet the pattern still fires because it +only requires "static rank-1 alloca, first touch is a write". The +match is too eager. + +## What the pattern correctly *doesn't* affect + +PolyBench (all 30 kernels) and the remaining MachSuite + NPB-extracted +kernels show *no* status change between baseline and pattern-enabled. +That means the recogniser is at least conservative enough to not +trigger on most code. The 4 regressions are specifically kernels with +the right structural shape. + +## Tests confirming no improvements + +- PolyBench gramschmidt: 5LG/1AF PARTIAL in both. (Has a column-vector + scratch; the pattern doesn't recognize the access shape — uses + `affine.load`/`store` directly into the multi-dim array, not a 1-D + alloca that's separately allocated.) +- PolyBench durbin: 3LG/1AF PARTIAL in both. (Uses scalar carries + (`alpha`/`beta`) — should be handled by the existing rank-0 + pattern; my new rank-1 pattern is irrelevant.) +- PolyBench correlation/covariance: unchanged. + +So even on the PolyBench kernels we hoped to fix (durbin, gramschmidt), +the pattern doesn't fire because they don't have rank-1 *separately +allocated* scratch arrays. They use direct indexing into the original +matrix. + +## Required follow-ups (in priority order) + +1. **Re-emit users via `polygeist.submap` instead of `memref.subview`.** + Mirror the 0-D pattern's rewrite. Should fix the AffineForOpRaising + slowdown. +2. **Tighten match conditions.** The MachSuite/fft-transpose regression + shows the recognizer fires on inputs that aren't the intended pattern. + Add a precondition that the alloca is used in *at least two* sibling + inner loops (the "fill then consume" shape) — that rules out + single-loop scratch reads which don't benefit from privatization. +3. **Cover the PolyBench scratch patterns.** durbin and gramschmidt + use direct multi-dim indexing rather than a separate scratch + alloca — the pattern shape there is "use an outer loop's iv to + index into the original 2-D array". Different transformation + needed (not array privatization — closer to loop interchange or + scalar promotion). + +## Status + +Pattern is implemented in `RaiseToLinalg.cpp` (~250 LOC) but registration +is commented out so the raise pipeline is bit-identical to baseline. +The 4 regressions above only manifest when the registration is +uncommented. This was the deliberate trade-off agreed with the user: +keep the work as a scaffold for a future fix, don't ship a strict +regression in the pipeline today. diff --git a/generic_solver/CublasDefnPattern.cpp b/generic_solver/CublasDefnPattern.cpp new file mode 100644 index 000000000000..4a62fb8345da --- /dev/null +++ b/generic_solver/CublasDefnPattern.cpp @@ -0,0 +1,360 @@ +//===- KernelDefnPattern.cpp - Pattern to match linalg.generic with kernel.defn ------===// +// +// This file implements a pattern to rewrite linalg.generic operations to kernel +// operations by matching against patterns defined in kernel.defn_collection. +// +//===----------------------------------------------------------------------===// + +#include "mlir/Dialect/Linalg/IR/Linalg.h" +#include "mlir/Dialect/Tensor/IR/Tensor.h" +#include "mlir/IR/PatternMatch.h" +#include "llvm/ADT/TypeSwitch.h" +#include "KernelOps.h" + +using namespace mlir; +using namespace mlir::linalg; + +namespace { + +// Cases: +// 1. What if they do a*(b+c) as a*b+a*c ? +// 2. What is they do (a+b)/c as a/c+b/c ? +// - The required best form can vary based on a cost model for a given architecture +// - The expectation is that kernel.defn is the best form an op is expected to take +// - The generic solver will employ heuristics to match the best form +// - Heuristics can be as simple as "is the op a commutative operation ?", +// "is the op an associative operation ?", "is the op distributive ?", etc. +// 3. What if the order of operations is different ? add(a,b) as add(b,a) +// - This requires a commutative check for operations, i.e in commutative ops +// we don't need to match positions +// 4. What if order of uses are different for an op? Eg- +// a1 = ... | a2 = ... +// b1 = a1/c1 | d2 = a2*c2 +// d1 = a1*c1 | b2 = a2/c2 +// - In this case, we need to find the corresponding uses of the operands +// 5. + +// Non-recursive traversal of use-def chain using a stack +bool compareUseDefChains(Value firstValue, Value secondValue) { + // Use a std::stack to track operations we need to visit + std::stack> workList; + std::set> visited; + + // Start with the initial values + workList.push({firstValue, secondValue}); + + while (!workList.empty()) { + auto [value1, value2] = workList.top(); + workList.pop(); + + // Skip if we've already processed this pair + auto valuePtrPair = std::make_pair(value1.getImpl(), value2.getImpl()); + if (visited.count(valuePtrPair)) + continue; + visited.insert(valuePtrPair); + + // Compare the values themselves + if (value1.getType() != value2.getType()) + return false; + + // Compare all uses + auto uses1 = value1.getUses(); + auto uses2 = value2.getUses(); + + // Process each use + for (auto &use1 : uses1) { + Operation *op1 = use1.getOwner(); + + // Find corresponding use in second value + bool foundMatch = false; + for (auto &use2 : uses2) { + Operation *op2 = use2.getOwner(); + + // Compare operations (customize based on your definition of equivalence) + if (op1->getName() == op2->getName() && + //This requires a commutative check + use1.getOperandNumber() == use2.getOperandNumber()) { + foundMatch = true; + + // Add results to worklist to continue traversal + for (unsigned i = 0; i < op1->getNumResults(); ++i) { + if (i < op2->getNumResults()) + workList.push({op1->getResult(i), op2->getResult(i)}); + } + break; + } + } + + if (!foundMatch) + return false; + } + } + + return true; +} + + +// Helper function to check if two regions are structurally equivalent +bool areRegionsEquivalent(Region &first, Region &second) { + // Compare number of blocks + if (first.getBlocks().size() != second.getBlocks().size()) + return false; + + // Compare corresponding blocks + for (auto blockPair : llvm::zip(first.getBlocks(), second.getBlocks())) { + Block &firstBlock = std::get<0>(blockPair); + Block &secondBlock = std::get<1>(blockPair); + + // Compare number of arguments + if (firstBlock.getNumArguments() != secondBlock.getNumArguments()) + return false; + + //// Compare argument types + //for (auto argPair : llvm::zip(firstBlock.getArguments(), + // secondBlock.getArguments())) { + // if (std::get<0>(argPair).getType() != std::get<1>(argPair).getType()) + // return false; + //} + + //Traverse the use-def chain of the arguments and compare the operation names + for (auto argPair : llvm::zip(firstBlock.getArguments(), + secondBlock.getArguments())) { + if (std::get<0>(argPair).getName() != std::get<1>(argPair).getName()) + return false; + //Traverse the use-def chain of the argument + for (auto use : std::get<0>(argPair).getUses()) { + if (use.getOwner().getName() != std::get<1>(argPair).getName()) + return false; + } + } + + //// Compare operations (simplified - real implementation would be more complex) + //if (firstBlock.getOperations().size() != secondBlock.getOperations().size()) + // return false; + + //// For a full implementation, you'd need more sophisticated operation comparison + //// based on operands, attributes, and result types + } + + return true; +} + +// Helper to check if indexing maps are equivalent +bool areIndexingMapsEquivalent(ArrayAttr firstMaps, ArrayAttr secondMaps) { + if (firstMaps.size() != secondMaps.size()) + return false; + + for (auto mapPair : llvm::zip(firstMaps, secondMaps)) { + auto firstMap = std::get<0>(mapPair).cast().getValue(); + auto secondMap = std::get<1>(mapPair).cast().getValue(); + + if (firstMap != secondMap) + return false; + } + + return true; +} + +// Helper to check if iterator types are equivalent +bool areIteratorTypesEquivalent(ArrayAttr firstTypes, ArrayAttr secondTypes) { + if (firstTypes.size() != secondTypes.size()) + return false; + + for (auto typePair : llvm::zip(firstTypes, secondTypes)) { + auto firstType = std::get<0>(typePair).cast().getValue(); + auto secondType = std::get<1>(typePair).cast().getValue(); + + if (firstType != secondType) + return false; + } + + return true; +} + +// Check if a linalg.generic operation matches a kernel.defn in a collection +FailureOr matchGenericWithDefn( + GenericOp genericOp, + kernel::DefnCollectionOp collectionOp) { + + // Get attributes from the generic operation + ArrayAttr indexingMaps = genericOp.getIndexingMapsAttr(); + ArrayAttr iteratorTypes = genericOp.getIteratorTypesAttr(); + unsigned numInputs = genericOp.getNumDpsInputs(); + unsigned numOutputs = genericOp.getNumDpsInits(); + + // Walk through each defn in the collection + for (Operation &op : collectionOp.getDefns()) { + auto defnOp = cast(op); + StringAttr opName = defnOp.getNameAttr(); + + // Check for linalg.generic in the defn's body + bool foundMatch = false; + defnOp.getBody().walk([&](GenericOp candidateOp) { + // Skip if already found a match + if (foundMatch) + return; + + // Check if this linalg.generic matches our target + if (candidateOp.getNumDpsInputs() == numInputs && + candidateOp.getNumDpsInits() == numOutputs && + //DONE: Generalize to a single dialect, with no special ops + //TODO: Indexing maps and orders might differ + //TODO: More complex case- where extra loops exists around the ops we have + //TODO: Custom cost model ? + //TODO: Constants might require special handling such as bounds + //IDEA: Descheduling / removing tiles + int numOfIndexingMaps = indexingMaps.size(); + int combinations = calculate_combinations(numOfIndexingMaps); + int calculatedCombinations(int numOfPos) { + //Calculate factorial of numOfPos + int result = 1; + for (int i = 1; i <= numOfPos; i++) { + result *= i; + } + return result; + } + areIndexingMapsEquivalent(candidateOp.getIndexingMapsAttr(), indexingMaps) && + areIteratorTypesEquivalent(candidateOp.getIteratorTypesAttr(), iteratorTypes) && + areRegionsEquivalent(candidateOp.getRegion(), genericOp.getRegion())) { + foundMatch = true; + } + }); + + if (foundMatch) + return opName.str(); + } + + return failure(); +} + +// Rewrite pattern to convert linalg.generic to kernel ops +class LinalgGenericToKernelPattern : public OpRewritePattern { +public: + LinalgGenericToKernelPattern(MLIRContext *context, + kernel::DefnCollectionOp collectionOp) + : OpRewritePattern(context), collectionOp(collectionOp) {} + + LogicalResult matchAndRewrite(GenericOp genericOp, + PatternRewriter &rewriter) const override { + // Try to match with a defn in the collection + auto matchResult = matchGenericWithDefn(genericOp, collectionOp); + if (failed(matchResult)) + return failure(); + + std::string opName = *matchResult; + + // Create the appropriate kernel operation based on the matched pattern + if (opName == "Kernel_gemm") { + // Get inputs and outputs + Value outputTensor = genericOp.getDpsInitOperand(0)->get(); + Value inputA = genericOp.getDpsInputOperand(0)->get(); + Value inputB = genericOp.getDpsInputOperand(1)->get(); + + // Default alpha and beta values (could be extracted from pattern) + FloatAttr alpha = rewriter.getF32FloatAttr(1.0); + FloatAttr beta = rewriter.getF32FloatAttr(0.0); + + // Create the kernel.gemm operation + rewriter.replaceOpWithNewOp( + genericOp, genericOp.getResultTypes(), + outputTensor, inputA, inputB, alpha, beta); + + return success(); + } + else if (opName == "Kernel_batched_gemm") { + // Get inputs and outputs + Value outputTensor = genericOp.getDpsInitOperand(0)->get(); + Value inputA = genericOp.getDpsInputOperand(0)->get(); + Value inputB = genericOp.getDpsInputOperand(1)->get(); + + // Default alpha and beta values + FloatAttr alpha = rewriter.getF32FloatAttr(1.0); + FloatAttr beta = rewriter.getF32FloatAttr(0.0); + + // Create the kernel.batched_gemm operation + rewriter.replaceOpWithNewOp( + genericOp, genericOp.getResultTypes(), + outputTensor, inputA, inputB, alpha, beta); + + return success(); + } + else if (opName == "Kernel_iamax") { + // Get input + Value input = genericOp.getDpsInputOperand(0)->get(); + + // Create the kernel.iamax operation + rewriter.replaceOpWithNewOp( + genericOp, genericOp.getResultTypes(), input); + + return success(); + } + else if (opName == "Kernel_iamin") { + // Get input + Value input = genericOp.getDpsInputOperand(0)->get(); + + // Create the kernel.iamin operation + rewriter.replaceOpWithNewOp( + genericOp, genericOp.getResultTypes(), input); + + return success(); + } + else if (opName == "Kernel_asum") { + // Get input + Value input = genericOp.getDpsInputOperand(0)->get(); + + // Create the kernel.asum operation + rewriter.replaceOpWithNewOp( + genericOp, genericOp.getResultTypes(), input); + + return success(); + } + + return failure(); + } + +private: + kernel::DefnCollectionOp collectionOp; +}; + +// Pass to apply the rewrite pattern +class LinalgToKernelPass + : public PassWrapper> { +public: + MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(LinalgToKernelPass) + + void runOnOperation() override { + ModuleOp module = getOperation(); + + // Find the kernel.defn_collection in the module + kernel::DefnCollectionOp collectionOp; + module.walk([&](kernel::DefnCollectionOp op) { + collectionOp = op; + return WalkResult::interrupt(); + }); + + if (!collectionOp) { + module.emitError("No kernel.defn_collection found in module"); + return signalPassFailure(); + } + + // Apply the rewrite pattern + RewritePatternSet patterns(&getContext()); + patterns.add(&getContext(), collectionOp); + + if (failed(applyPatternsAndFoldGreedily(module, std::move(patterns)))) + return signalPassFailure(); + } +}; + +} // namespace + +// Create a pass to convert linalg.generic to kernel +std::unique_ptr createLinalgToKernelPass() { + return std::make_unique(); +} + +// Register the pass +void registerLinalgToKernelPasses() { + PassRegistration("linalg-to-kernel", + "Convert linalg.generic to kernel operations"); +} \ No newline at end of file diff --git a/generic_solver/CublasOps.td b/generic_solver/CublasOps.td new file mode 100644 index 000000000000..56aaebba0766 --- /dev/null +++ b/generic_solver/CublasOps.td @@ -0,0 +1,85 @@ +//===- KernelOps.td - kernel dialect operation definitions ---*- tablegen -*-===// +// +// This file defines the kernel operation definitions in TableGen format. +// +//===----------------------------------------------------------------------===// + +#ifndef kernel_OPS +#define kernel_OPS + +include "mlir/IR/OpBase.td" +include "mlir/Interfaces/SideEffectInterfaces.td" +include "mlir/Dialect/Linalg/IR/LinalgInterfaces.td" + +//===----------------------------------------------------------------------===// +// kernel dialect definition +//===----------------------------------------------------------------------===// + +def Kernel_Dialect : Dialect { + let name = "kernel"; + let cppNamespace = "::mlir::kernel"; + let description = [{ + The kernel dialect provides operations for NVIDIA kernel matrix multiplication + routines, including standard and batched GEMM operations. + }]; +} + +//===----------------------------------------------------------------------===// +// Base class for kernel dialect operations +//===----------------------------------------------------------------------===// + +class Kernel_Op traits = []> : + Op; + +//===----------------------------------------------------------------------===// +// kernel ops instantiation collection +//===----------------------------------------------------------------------===// + +def Opinst_DefnCollection : Op { + let summary = "Collection of operation definitions"; + let description = [{ + A collection of operation definitions that can be referenced elsewhere. + This operation serves as a container for multiple operation definitions. + }]; + + let regions = (region SizedRegion<1>:$defns); + + let assemblyFormat = [{ + $defns attr-dict + }]; +} + +def Opinst_Defn : Op { + let summary = "Definition of an operation"; + let description = [{ + A definition of an operation with inputs and arbitrary body code. + Can contain either literal code or a linalg.generic representation. + }]; + + let arguments = (ins + StrAttr:$name, + Variadic:$inputs + ); + + let regions = (region SizedRegion<1>:$body); + + let assemblyFormat = [{ + $name `(` $inputs `)` $body attr-dict `:` functional-type($inputs, results) + }]; +} + +//===----------------------------------------------------------------------===// +// Example pattern representation +//===----------------------------------------------------------------------===// + +// Patterns for gemm and batched_gemm expressed in a mathematical notation. +// These are informational and would be used by pattern matchers. + +// Standard GEMM pattern: C(i,k) += alpha * A(i,j) * B(j,k) +// Batched GEMM pattern: C(N, i,k) += alpha * A(N, i,j) * B(N, j,k) + +// Index of max absolute value pattern: result = argmax_i |x_i| +// Index of min absolute value pattern: result = argmin_i |x_i| +// Sum of absolute values pattern: result = sum_i |x_i| + +#endif // kernel_OPS \ No newline at end of file diff --git a/generic_solver/example.mlir b/generic_solver/example.mlir new file mode 100644 index 000000000000..ad97ca921c8d --- /dev/null +++ b/generic_solver/example.mlir @@ -0,0 +1,49 @@ +//RUN: polygeist-opt --linalg-to-kernel="kernel-library-path=%S/kernel_library.mlir" -allow-unregistered-dialect %s +// Example MLIR module demonstrating kernel operations and their linalg.generic representations +module { + //Func that uses simple gemm + func.func @simple_gemm(%A: tensor, %B: tensor, %C: tensor) -> tensor { + // Implementation using linalg.generic + %result = linalg.generic { + indexing_maps = [ + affine_map<(i, j, k) -> (i, k)>, // A(i,k) + affine_map<(i, j, k) -> (k, j)>, // B(k,j) + affine_map<(i, j, k) -> (i, j)> // C(i,j) + ], + iterator_types = ["parallel", "parallel", "reduction"] + } ins(%A, %B : tensor, tensor) + outs(%C : tensor) { + ^bb0(%a: f32, %b: f32, %c: f32): + %product = arith.mulf %a, %b : f32 + %result = arith.addf %product, %c : f32 + linalg.yield %result : f32 + } -> tensor + return %result : tensor + } + + // Function that uses iamin (index of minimum absolute value) + func.func @find_min_abs_index(%X: tensor, %init: tensor) -> tensor { + // Implementation using linalg.generic + %result = linalg.generic { + indexing_maps = [ + affine_map<(i) -> (i)>, // Input vector + affine_map<(i) -> ()> // Result scalar (index) + ], + iterator_types = ["reduction"] + } ins(%X : tensor) + outs(%init : tensor) { + ^bb0(%in: f32, %out: i32): + %idx = linalg.index 0 : index + %abs_val = math.absf %in : f32 + %curr_min_idx = arith.index_cast %out : i32 to index + %curr_min = tensor.extract %X[%curr_min_idx] : tensor + %curr_min_abs = math.absf %curr_min : f32 + %cmp = arith.cmpf olt, %abs_val, %curr_min_abs : f32 + %new_idx = arith.select %cmp, %idx, %curr_min_idx : index + %result = arith.index_cast %new_idx : index to i32 + linalg.yield %result : i32 + } -> tensor + return %result : tensor + } + +} diff --git a/generic_solver/kernel_library.mlir b/generic_solver/kernel_library.mlir new file mode 100644 index 000000000000..fd4fd6a48a70 --- /dev/null +++ b/generic_solver/kernel_library.mlir @@ -0,0 +1,218 @@ +// Kernel Library - Reusable kernel definitions +// This file contains a collection of kernel definitions that can be loaded +// by the linalg-to-kernel pass and applied to different MLIR modules. + +module { + // Collection of kernel operation definitions + kernel.defn_collection { + + // Simple GEMM operation definition with linalg.generic representation + kernel.defn @simple_gemm_linalg(%A: tensor, %B: tensor, %C: tensor) -> tensor { + // Simple matrix multiplication: C = A * B + C + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2) -> (d0, d2)>, + affine_map<(d0, d1, d2) -> (d2, d1)>, + affine_map<(d0, d1, d2) -> (d0, d1)> + ], + iterator_types = ["parallel", "parallel", "reduction"] + } ins(%A, %B : tensor, tensor) + outs(%C : tensor) { + ^bb0(%a: f32, %b: f32, %c: f32): + %product = arith.mulf %a, %b : f32 + %result = arith.addf %product, %c : f32 + linalg.yield %result : f32 + } -> tensor + kernel.yield %result : tensor + } + + // Scaled GEMM operation definition with alpha and beta coefficients + kernel.defn @gemm_linalg(%A: tensor, %B: tensor, %C: tensor, %alpha: f32, %beta: f32) -> tensor { + // GEMM with scaling: C = alpha * A * B + beta * C + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2) -> (d0, d2)>, + affine_map<(d0, d1, d2) -> (d2, d1)>, + affine_map<(d0, d1, d2) -> (d0, d1)> + ], + iterator_types = ["parallel", "parallel", "reduction"] + } ins(%A, %B : tensor, tensor) + outs(%C : tensor) { + ^bb0(%a: f32, %b: f32, %c: f32): + %product = arith.mulf %a, %b : f32 + %scaled = arith.mulf %product, %alpha : f32 + %scaled_c = arith.mulf %c, %beta : f32 + %result = arith.addf %scaled, %scaled_c : f32 + linalg.yield %result : f32 + } -> tensor + kernel.yield %result : tensor + } + + // Alpha-scaled GEMM accumulation (matches the second operation in the user's pattern) + kernel.defn @alpha_gemm_accumulate(%A: tensor, %B: tensor, %C: tensor, %alpha: f64) -> tensor { + // Matrix multiplication with alpha scaling: C += alpha * A * B + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2) -> (d0, d2)>, + affine_map<(d0, d1, d2) -> (d2, d1)>, + affine_map<(d0, d1, d2) -> (d0, d1)> + ], + iterator_types = ["parallel", "reduction", "parallel"] + } ins(%A, %B : tensor, tensor) + outs(%C : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %6 = arith.mulf %alpha, %in : f64 + %7 = arith.mulf %6, %in_0 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } -> tensor + kernel.yield %result : tensor + } + + // Element-wise beta scaling (matches the first operation in the user's pattern) + kernel.defn @beta_scale(%C: tensor, %beta: f64) -> tensor { + // Element-wise scaling: C = beta * C + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d1, d0)> + ], + iterator_types = ["parallel", "parallel"] + } outs(%C : tensor) { + ^bb0(%out: f64): + %6 = arith.mulf %out, %beta : f64 + linalg.yield %6 : f64 + } -> tensor + kernel.yield %result : tensor + } + + // Matrix multiplication with alpha scaling (second operation standalone) + kernel.defn @gemm_alpha_only(%A: tensor, %B: tensor, %C: tensor, %alpha: f64) -> tensor { + // Matrix multiplication: C += alpha * A * B + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2) -> (d2, d1)>, + affine_map<(d0, d1, d2) -> (d1, d0)>, + affine_map<(d0, d1, d2) -> (d2, d0)> + ], + iterator_types = ["parallel", "reduction", "parallel"] + } ins(%A, %B : tensor, tensor) + outs(%C : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %6 = arith.mulf %alpha, %in : f64 + %7 = arith.mulf %6, %in_0 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } -> tensor + kernel.yield %result : tensor + } + + // Sum of absolute values operation (ASUM) + kernel.defn @asum_linalg(%X: tensor, %init: tensor) -> tensor { + // Sum of absolute values: result = sum_i |x_i| + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> ()> + ], + iterator_types = ["reduction"] + } ins(%X : tensor) + outs(%init : tensor) { + ^bb0(%in: f32, %out: f32): + %abs_val = math.absf %in : f32 + %result = arith.addf %abs_val, %out : f32 + linalg.yield %result : f32 + } -> tensor + kernel.yield %result : tensor + } + + // Vector dot product + kernel.defn @dot_linalg(%X: tensor, %Y: tensor, %init: tensor) -> tensor { + // Dot product: result = sum_i x_i * y_i + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> ()> + ], + iterator_types = ["reduction"] + } ins(%X, %Y : tensor, tensor) + outs(%init : tensor) { + ^bb0(%x: f32, %y: f32, %out: f32): + %product = arith.mulf %x, %y : f32 + %result = arith.addf %product, %out : f32 + linalg.yield %result : f32 + } -> tensor + kernel.yield %result : tensor + } + + // Index of maximum absolute value operation definition with linalg.generic representation + kernel.defn @iamax_linalg(%X: tensor, %init: tensor) -> tensor { + // Implementation using linalg.generic + %result = linalg.generic { + indexing_maps = [ + affine_map<(i) -> (i)>, // Input vector + affine_map<(i) -> ()> // Result scalar (index) + ], + iterator_types = ["reduction"] + } ins(%X : tensor) + outs(%init : tensor) { + ^bb0(%in: f32, %out: i32): + %idx = linalg.index 0 : index + %abs_val = math.absf %in : f32 + %curr_max_idx = arith.index_cast %out : i32 to index + %curr_max = tensor.extract %X[%curr_max_idx] : tensor + %curr_max_abs = math.absf %curr_max : f32 + %cmp = arith.cmpf ogt, %abs_val, %curr_max_abs : f32 + %new_idx = arith.select %cmp, %idx, %curr_max_idx : index + %result = arith.index_cast %new_idx : index to i32 + linalg.yield %result : i32 + } -> tensor + kernel.yield %result : tensor + } + + // General Matrix-Vector Multiply (GEMV) + kernel.defn @gemv_simple(%A: tensor, %x: tensor, %y: tensor) -> tensor { + // Simple matrix-vector multiplication: y += A * x + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d1, d0)>, // Matrix A[d0, d1] + affine_map<(d0, d1) -> (d0)>, // Vector x[d1] + affine_map<(d0, d1) -> (d1)> // Vector y[d0] + ], + iterator_types = ["parallel", "reduction"] + } ins(%A, %x : tensor, tensor) + outs(%y : tensor) { + ^bb0(%a: f64, %x_val: f64, %y_val: f64): + %product = arith.mulf %a, %x_val : f64 + %result = arith.addf %y_val, %product : f64 + linalg.yield %result : f64 + } -> tensor + kernel.yield %result : tensor + } + + // Index of minimum absolute value operation definition with linalg.generic representation + kernel.defn @iamin_linalg(%X: tensor, %init: tensor) -> tensor { + // Implementation using linalg.generic + %result = linalg.generic { + indexing_maps = [ + affine_map<(i) -> (i)>, // Input vector + affine_map<(i) -> ()> // Result scalar (index) + ], + iterator_types = ["reduction"] + } ins(%X : tensor) + outs(%init : tensor) { + ^bb0(%in: f32, %out: i32): + %idx = linalg.index 0 : index + %abs_val = math.absf %in : f32 + %curr_min_idx = arith.index_cast %out : i32 to index + %curr_min = tensor.extract %X[%curr_min_idx] : tensor + %curr_min_abs = math.absf %curr_min : f32 + %cmp = arith.cmpf olt, %abs_val, %curr_min_abs : f32 + %new_idx = arith.select %cmp, %idx, %curr_min_idx : index + %result = arith.index_cast %new_idx : index to i32 + linalg.yield %result : i32 + } -> tensor + kernel.yield %result : tensor + } + } +} \ No newline at end of file diff --git a/generic_solver/kernel_library_phase2.mlir b/generic_solver/kernel_library_phase2.mlir new file mode 100644 index 000000000000..42e4ed4a71f1 --- /dev/null +++ b/generic_solver/kernel_library_phase2.mlir @@ -0,0 +1,1782 @@ +// Phase-2 kernel library — canonical linalg implementations for each library +// symbol the kernel matcher emits. The --lower-kernel-launch pass loads this +// file (via kernel-library-path=) and substitutes each kernel.defn's body +// in place of its matching kernel.launch op. +// +// Conventions: +// - All bodies operate on `f64` tensors. The PolyBench corpus is double-only. +// - Operand order matches what kernel_match_rewrite.py emits: +// all tensor inputs (in source order) + first generic's outs + scalars. +// - Each defn's linalg.generic uses *self-contained* indexing_maps and +// iterator_types; it operates on whatever shape the launch's operands +// have at the call site, without referring to any caller context. +// +// To add a new library entry: pick a unique kernel.launch signature observed +// in `kernel_match_rewrite.py` output and author a kernel.defn with that +// signature whose body computes the canonical semantics for that library op. + +module { + + // cuDNN tensor add: output += input (NCHW). + kernel.defn @cudnnAddTensor_batched( + %input: tensor, + %output: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, + affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>], + iterator_types = ["parallel", "parallel", "parallel", "parallel"] + } ins(%input : tensor) + outs(%output : tensor) { + ^bb0(%in: f32, %out: f32): + %sum = arith.addf %out, %in : f32 + linalg.yield %sum : f32 + } -> tensor + kernel.yield %result : tensor + } + + // cuDNN inference batch normalization with caller-provided reciprocal stddev. + kernel.defn @cudnnBatchNormalizationForwardInference( + %input: tensor, %weight: tensor, + %mean: tensor, %inv_std: tensor, + %bias: tensor, %output: tensor) + -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, + affine_map<(d0, d1, d2, d3) -> (d1)>, + affine_map<(d0, d1, d2, d3) -> (d1)>, + affine_map<(d0, d1, d2, d3) -> (d1)>, + affine_map<(d0, d1, d2, d3) -> (d1)>, + affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>], + iterator_types = ["parallel", "parallel", "parallel", "parallel"] + } ins(%input, %weight, %mean, %inv_std, %bias + : tensor, tensor, tensor, + tensor, tensor) + outs(%output : tensor) { + ^bb0(%in: f32, %w: f32, %m: f32, %is: f32, %b: f32, %out: f32): + %centered = arith.subf %in, %m : f32 + %scaled0 = arith.mulf %centered, %is : f32 + %scaled1 = arith.mulf %w, %scaled0 : f32 + %value = arith.addf %scaled1, %b : f32 + linalg.yield %value : f32 + } -> tensor + kernel.yield %result : tensor + } + + // cuDNN valid NCHW convolution. The first operand is the rank-7 window + // view produced by polygeist.submap: [N, OC, OH, OW, IC, KH, KW]. + kernel.defn @cudnnConvolutionFwd_batched( + %windows: tensor, + %filter: tensor, + %output: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2, d3, d4, d5, d6) -> + (d0, d1, d2, d3, d4, d5, d6)>, + affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d1, d4, d5, d6)>, + affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)>], + iterator_types = ["parallel", "parallel", "parallel", "parallel", + "reduction", "reduction", "reduction"] + } ins(%windows, %filter + : tensor, tensor) + outs(%output : tensor) { + ^bb0(%in: f32, %f: f32, %out: f32): + %product = arith.mulf %in, %f : f32 + %sum = arith.addf %out, %product : f32 + linalg.yield %sum : f32 + } -> tensor + kernel.yield %result : tensor + } + + // cuDNN max pool. The rank-6 input is [N, C, OH, OW, KH, KW]. + kernel.defn @cudnnMaxPoolFwd_batched( + %windows: tensor, + %output: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)>, + affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3)>], + iterator_types = ["parallel", "parallel", "parallel", "parallel", + "reduction", "reduction"] + } ins(%windows : tensor) + outs(%output : tensor) { + ^bb0(%in: f32, %out: f32): + %take_input = arith.cmpf ogt, %in, %out : f32 + %maximum = arith.select %take_input, %in, %out : f32 + linalg.yield %maximum : f32 + } -> tensor + kernel.yield %result : tensor + } + + // GEMM: C = alpha*A*B + beta*C (standard textbook gemm) + // Operand order: A, B, C, beta, alpha. + kernel.defn @cublasDgemm(%A: tensor, %B: tensor, + %C: tensor, + %beta: f64, %alpha: f64) -> tensor { + // Step 1: C = beta * C + %scaled = linalg.generic { + indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>], + iterator_types = ["parallel", "parallel"] + } outs(%C : tensor) { + ^bb0(%out: f64): + %t = arith.mulf %out, %beta : f64 + linalg.yield %t : f64 + } -> tensor + // Step 2: C = alpha * A * B + C + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2) -> (d0, d2)>, + affine_map<(d0, d1, d2) -> (d2, d1)>, + affine_map<(d0, d1, d2) -> (d0, d1)> + ], + iterator_types = ["parallel", "parallel", "reduction"] + } ins(%A, %B : tensor, tensor) + outs(%scaled : tensor) { + ^bb0(%a: f64, %b: f64, %out: f64): + %p = arith.mulf %a, %b : f64 + %ap = arith.mulf %alpha, %p : f64 + %s = arith.addf %out, %ap : f64 + linalg.yield %s : f64 + } -> tensor + kernel.yield %result : tensor + } + + // GEMM-SIMPLE: C += A*B (alpha=1, beta=1, accumulate-into-C). + kernel.defn @cublasDgemm_simple(%A: tensor, %B: tensor, + %C: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2) -> (d0, d2)>, + affine_map<(d0, d1, d2) -> (d2, d1)>, + affine_map<(d0, d1, d2) -> (d0, d1)> + ], + iterator_types = ["parallel", "parallel", "reduction"] + } ins(%A, %B : tensor, tensor) + outs(%C : tensor) { + ^bb0(%a: f64, %b: f64, %out: f64): + %p = arith.mulf %a, %b : f64 + %s = arith.addf %out, %p : f64 + linalg.yield %s : f64 + } -> tensor + kernel.yield %result : tensor + } + + // FP32 Darknet im2col+GEMM lowered shape. The linalg raiser represents the + // scalar A[i,k] load as a broadcasted rank-3 input so the output submap can + // still ignore the reduction dim when lowered back to the flat C buffer. + kernel.defn @cublasSgemm_broadcast3d_simple( + %A: tensor, %B: tensor, + %C: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)> + ], + iterator_types = ["parallel", "reduction", "parallel"] + } ins(%A, %B : tensor, tensor) + outs(%C : tensor) { + ^bb0(%a: f32, %b: f32, %out: f32): + %p = arith.mulf %a, %b : f32 + %s = arith.addf %out, %p : f32 + linalg.yield %s : f32 + } -> tensor + kernel.yield %result : tensor + } + + kernel.defn @cublasSgemm_broadcast3d_memref( + %A: memref, %B: memref, + %C: memref) { + linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)> + ], + iterator_types = ["parallel", "reduction", "parallel"] + } ins(%A, %B : memref, memref) + outs(%C : memref) { + ^bb0(%a: f32, %b: f32, %out: f32): + %p = arith.mulf %a, %b : f32 + %s = arith.addf %out, %p : f32 + linalg.yield %s : f32 + } + kernel.yield + } + + // Batched FP32 matrix multiplication with one right-hand matrix shared by + // every batch: C[b,m,n] = sum_k A[b,m,k] * B[k,n]. The CUDA ABI lowers + // this to cublasSgemmStridedBatched with strideB=0 and beta=0. + kernel.defn @cublasSgemm_strided_batched_broadcast_rhs( + %A: tensor, %B: tensor, + %C: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)>, + affine_map<(d0, d1, d2, d3) -> (d3, d2)>, + affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> + ], + iterator_types = ["parallel", "parallel", "parallel", "reduction"] + } ins(%A, %B : tensor, tensor) + outs(%C : tensor) { + ^bb0(%a: f32, %b: f32, %out: f32): + %p = arith.mulf %a, %b : f32 + %s = arith.addf %out, %p : f32 + linalg.yield %s : f32 + } -> tensor + kernel.yield %result : tensor + } + + // Darknet-style explicit im2col + SGEMM as one library op. The matcher + // recognizes the zero-fill, guarded im2col workspace materialization, and + // following GEMM as a single composition; ABI lowering maps this directly + // to cuDNN convolution with caller-supplied padding and stride. + kernel.defn @cudnnConvolutionFwd_im2col_gemm( + %input: memref, %weights: memref, + %output: memref, + %channels: i32, %height: i32, %width: i32, %out_channels: i32, + %ksize: i32, %stride: i32, %pad: i32) { + kernel.yield + } + + // llama2.c RMSNorm matched as: + // ss = sum(x[i] * x[i]) + // out[i] = weight[i] * x[i] * rsqrt(ss / N + 1e-5) + // ABI lowering maps this to a runtime shim. The shim owns the optimized + // implementation choice (cuDNN frontend/custom CUDA/CPU fallback). + kernel.defn @rmsnorm_f32( + %x: memref, %weight: memref, %out: memref) { + kernel.yield + } + + kernel.defn @rmsnorm_f32_tensor( + %x: tensor, %weight: tensor, + %out: tensor) -> tensor { + kernel.yield %out : tensor + } + + kernel.defn @rmsnorm_unweighted_f32_tensor( + %x: tensor, %out: tensor) -> tensor { + kernel.yield %out : tensor + } + + kernel.defn @gelu_tanh_f32_tensor( + %x: tensor, %out: tensor) -> tensor { + kernel.yield %out : tensor + } + + kernel.defn @cublasDdot( + %x: tensor, %y: tensor, + %out: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> ()> + ], + iterator_types = ["reduction"] + } ins(%x, %y : tensor, tensor) outs(%out : tensor) { + ^bb0(%xv: f64, %yv: f64, %ov: f64): + %p = arith.mulf %xv, %yv : f64 + %s = arith.addf %ov, %p : f64 + linalg.yield %s : f64 + } -> tensor + kernel.yield %result : tensor + } + + kernel.defn @cublasSdot( + %x: tensor, %y: tensor, + %out: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> ()> + ], + iterator_types = ["reduction"] + } ins(%x, %y : tensor, tensor) outs(%out : tensor) { + ^bb0(%xv: f32, %yv: f32, %ov: f32): + %p = arith.mulf %xv, %yv : f32 + %s = arith.addf %ov, %p : f32 + linalg.yield %s : f32 + } -> tensor + kernel.yield %result : tensor + } + + kernel.defn @whisperExpShiftSum_f32_tensor( + %x: tensor, %out: tensor, %sum: tensor, + %max: f32) -> (tensor, tensor) { + %result:2 = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> ()> + ], + iterator_types = ["reduction"] + } ins(%x : tensor) outs(%out, %sum : tensor, tensor) { + ^bb0(%xv: f32, %ov: f32, %sumv: f32): + %shifted = arith.subf %xv, %max : f32 + %e = math.exp %shifted : f32 + %acc = arith.addf %sumv, %e : f32 + linalg.yield %e, %acc : f32, f32 + } -> (tensor, tensor) + kernel.yield %result#0, %result#1 : tensor, tensor + } + + // llama2.c row softmax in-place: + // x = exp(x - max(x)) / sum(exp(x - max(x))) + // ABI lowering maps this to cudnnSoftmaxForward for FP32. + kernel.defn @cudnnSoftmaxForward(%x: memref) { + kernel.yield + } + + kernel.defn @cudnnSoftmaxForward_tensor(%x: tensor) -> tensor { + kernel.yield %x : tensor + } + + kernel.defn @cudnnSoftmaxForwardOut_tensor( + %scores: tensor, %out: tensor) -> tensor { + kernel.yield %out : tensor + } + + // Llama standalone elementwise / copy helpers. ABI lowering routes these + // to CUDA-runtime/cuDNN/cuBLAS shims in the CUDA backend. + kernel.defn @cudaCopy1D_f32_tensor( + %src: tensor, %out: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)> + ], + iterator_types = ["parallel"] + } ins(%src : tensor) outs(%out : tensor) { + ^bb0(%sv: f32, %ov: f32): + linalg.yield %sv : f32 + } -> tensor + kernel.yield %result : tensor + } + + kernel.defn @cudaCopy2D_f32_tensor( + %src: tensor, %out: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)> + ], + iterator_types = ["parallel", "parallel"] + } ins(%src : tensor) outs(%out : tensor) { + ^bb0(%sv: f32, %ov: f32): + linalg.yield %sv : f32 + } -> tensor + kernel.yield %result : tensor + } + + kernel.defn @cudaCopy3D_f32_tensor( + %src: tensor, + %out: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)> + ], + iterator_types = ["parallel", "parallel", "parallel"] + } ins(%src : tensor) outs(%out : tensor) { + ^bb0(%sv: f32, %ov: f32): + linalg.yield %sv : f32 + } -> tensor + kernel.yield %result : tensor + } + + kernel.defn @cudaCopy6D_f32_tensor( + %src: tensor, + %out: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)>, + affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> + ], + iterator_types = [ + "parallel", "parallel", "parallel", + "parallel", "parallel", "parallel" + ] + } ins(%src : tensor) + outs(%out : tensor) { + ^bb0(%sv: f32, %ov: f32): + linalg.yield %sv : f32 + } -> tensor + kernel.yield %result : tensor + } + + kernel.defn @cudaAdd_f32_tensor( + %x: tensor, %y: tensor, + %out: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)> + ], + iterator_types = ["parallel"] + } ins(%x, %y : tensor, tensor) outs(%out : tensor) { + ^bb0(%xv: f32, %yv: f32, %ov: f32): + %sum = arith.addf %xv, %yv : f32 + linalg.yield %sum : f32 + } -> tensor + kernel.yield %result : tensor + } + + kernel.defn @cudaMaskSelect_f32_tensor( + %scores: tensor, %out: tensor, %pos: i32) + -> tensor { + %one = arith.constant 1.000000e+00 : f32 + %neg_inf = arith.constant -3.40282347E+38 : f32 + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)> + ], + iterator_types = ["parallel"] + } ins(%scores : tensor) outs(%out : tensor) { + ^bb0(%sv: f32, %ov: f32): + %i = linalg.index 0 : index + %ii = arith.index_cast %i : index to i32 + %pred = arith.cmpi sgt, %ii, %pos : i32 + %drop_i = arith.extui %pred : i1 to i32 + %drop = arith.sitofp %drop_i : i32 to f32 + %keep = arith.subf %one, %drop : f32 + %kept = arith.mulf %keep, %sv : f32 + %masked = arith.mulf %drop, %neg_inf : f32 + %r = arith.addf %kept, %masked : f32 + linalg.yield %r : f32 + } -> tensor + kernel.yield %result : tensor + } + + kernel.defn @cudaSwiGLU_f32_tensor( + %gate: tensor, %up: tensor, + %out: tensor) -> tensor { + %one = arith.constant 1.000000e+00 : f32 + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)> + ], + iterator_types = ["parallel"] + } ins(%gate, %up : tensor, tensor) outs(%out : tensor) { + ^bb0(%g: f32, %u: f32, %ov: f32): + %ng = arith.negf %g : f32 + %e = math.exp %ng : f32 + %den = arith.addf %e, %one : f32 + %silu = arith.divf %g, %den : f32 + %r = arith.mulf %silu, %u : f32 + linalg.yield %r : f32 + } -> tensor + kernel.yield %result : tensor + } + + kernel.defn @cudaRopeMulMulSub_f32_tensor( + %a: tensor, %b: tensor, + %c: tensor, %d: tensor, + %out: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d1)>, + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d1)>, + affine_map<(d0, d1) -> (d0, d1)> + ], + iterator_types = ["parallel", "parallel"] + } ins(%a, %b, %c, %d : tensor, tensor, + tensor, tensor) outs(%out : tensor) { + ^bb0(%av: f32, %bv: f32, %cv: f32, %dv: f32, %ov: f32): + %p0 = arith.mulf %av, %bv : f32 + %p1 = arith.mulf %cv, %dv : f32 + %r = arith.subf %p0, %p1 : f32 + linalg.yield %r : f32 + } -> tensor + kernel.yield %result : tensor + } + + kernel.defn @cudaRopeMulMulAdd_f32_tensor( + %a: tensor, %b: tensor, + %c: tensor, %d: tensor, + %out: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d1)>, + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d1)>, + affine_map<(d0, d1) -> (d0, d1)> + ], + iterator_types = ["parallel", "parallel"] + } ins(%a, %b, %c, %d : tensor, tensor, + tensor, tensor) outs(%out : tensor) { + ^bb0(%av: f32, %bv: f32, %cv: f32, %dv: f32, %ov: f32): + %p0 = arith.mulf %av, %bv : f32 + %p1 = arith.mulf %cv, %dv : f32 + %r = arith.addf %p0, %p1 : f32 + linalg.yield %r : f32 + } -> tensor + kernel.yield %result : tensor + } + + // GEMM-ALPHA-ONLY: C += alpha*A*B (beta=1, accumulate-into-C, custom alpha). + kernel.defn @cublasDgemm_alpha_only(%A: tensor, %B: tensor, + %C: tensor, + %alpha: f64) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2) -> (d0, d2)>, + affine_map<(d0, d1, d2) -> (d2, d1)>, + affine_map<(d0, d1, d2) -> (d0, d1)> + ], + iterator_types = ["parallel", "parallel", "reduction"] + } ins(%A, %B : tensor, tensor) + outs(%C : tensor) { + ^bb0(%a: f64, %b: f64, %out: f64): + %p = arith.mulf %a, %b : f64 + %ap = arith.mulf %alpha, %p : f64 + %s = arith.addf %out, %ap : f64 + linalg.yield %s : f64 + } -> tensor + kernel.yield %result : tensor + } + + // GEAM-SCALE-2D: C = alpha * C (elementwise scaling, 2D). + kernel.defn @cublasDgeam_scale2D(%C: tensor, %alpha: f64) + -> tensor { + %result = linalg.generic { + indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>], + iterator_types = ["parallel", "parallel"] + } outs(%C : tensor) { + ^bb0(%out: f64): + %t = arith.mulf %out, %alpha : f64 + linalg.yield %t : f64 + } -> tensor + kernel.yield %result : tensor + } + + // GEMV (2D matrix x 1D vector): y += A * x. + // Operand order seen in atax, mvt, gesummv, 3mm. + kernel.defn @cublasDgemv(%A: tensor, %x: tensor, + %y: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d1)>, + affine_map<(d0, d1) -> (d0)> + ], + iterator_types = ["parallel", "reduction"] + } ins(%A, %x : tensor, tensor) + outs(%y : tensor) { + ^bb0(%a: f64, %xv: f64, %out: f64): + %p = arith.mulf %a, %xv : f64 + %s = arith.addf %out, %p : f64 + linalg.yield %s : f64 + } -> tensor + kernel.yield %result : tensor + } + + kernel.defn @cublasDgemv_T(%A: tensor, %x: tensor, + %y: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d1, d0)>, + affine_map<(d0, d1) -> (d1)>, + affine_map<(d0, d1) -> (d0)> + ], + iterator_types = ["parallel", "reduction"] + } ins(%A, %x : tensor, tensor) + outs(%y : tensor) { + ^bb0(%a: f64, %xv: f64, %out: f64): + %p = arith.mulf %a, %xv : f64 + %s = arith.addf %out, %p : f64 + linalg.yield %s : f64 + } -> tensor + kernel.yield %result : tensor + } + + kernel.defn @cublasSgemv(%A: tensor, %x: tensor, + %y: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d1)>, + affine_map<(d0, d1) -> (d0)> + ], + iterator_types = ["parallel", "reduction"] + } ins(%A, %x : tensor, tensor) + outs(%y : tensor) { + ^bb0(%a: f32, %xv: f32, %out: f32): + %p = arith.mulf %a, %xv : f32 + %s = arith.addf %out, %p : f32 + linalg.yield %s : f32 + } -> tensor + kernel.yield %result : tensor + } + + kernel.defn @cublasSgemv_T(%A: tensor, %x: tensor, + %y: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d1, d0)>, + affine_map<(d0, d1) -> (d1)>, + affine_map<(d0, d1) -> (d0)> + ], + iterator_types = ["parallel", "reduction"] + } ins(%A, %x : tensor, tensor) + outs(%y : tensor) { + ^bb0(%a: f32, %xv: f32, %out: f32): + %p = arith.mulf %a, %xv : f32 + %s = arith.addf %out, %p : f32 + linalg.yield %s : f32 + } -> tensor + kernel.yield %result : tensor + } + + // GEMV-ALPHA: y += alpha * A * x (gemver pattern). + kernel.defn @cublasDgemv_alpha(%A: tensor, %x: tensor, + %y: tensor, + %alpha: f64) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d1)>, + affine_map<(d0, d1) -> (d0)> + ], + iterator_types = ["parallel", "reduction"] + } ins(%A, %x : tensor, tensor) + outs(%y : tensor) { + ^bb0(%a: f64, %xv: f64, %out: f64): + %p = arith.mulf %a, %xv : f64 + %ap = arith.mulf %alpha, %p : f64 + %s = arith.addf %out, %ap : f64 + linalg.yield %s : f64 + } -> tensor + kernel.yield %result : tensor + } + + // GER-RANK2: A += u1*v1^T + u2*v2^T. + // gemver-style fused rank-2 update. + kernel.defn @cublasDger_rank2(%u1: tensor, %v1: tensor, + %u2: tensor, %v2: tensor, + %A: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d0)>, + affine_map<(d0, d1) -> (d1)>, + affine_map<(d0, d1) -> (d0)>, + affine_map<(d0, d1) -> (d1)>, + affine_map<(d0, d1) -> (d0, d1)> + ], + iterator_types = ["parallel", "parallel"] + } ins(%u1, %v1, %u2, %v2 + : tensor, tensor, tensor, tensor) + outs(%A : tensor) { + ^bb0(%u1v: f64, %v1v: f64, %u2v: f64, %v2v: f64, %out: f64): + %p1 = arith.mulf %u1v, %v1v : f64 + %p2 = arith.mulf %u2v, %v2v : f64 + %s1 = arith.addf %out, %p1 : f64 + %s2 = arith.addf %s1, %p2 : f64 + linalg.yield %s2 : f64 + } -> tensor + kernel.yield %result : tensor + } + + // Overwriting outer product: C[i,j] = u[i] * v[j]. Unlike the BLAS GER + // update primitive this operation does not consume the old contents of C. + kernel.defn @cublasDgemm_outer_product( + %u: tensor, %v: tensor, + %C: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d0)>, + affine_map<(d0, d1) -> (d1)>, + affine_map<(d0, d1) -> (d0, d1)> + ], + iterator_types = ["parallel", "parallel"] + } ins(%u, %v : tensor, tensor) + outs(%C : tensor) { + ^bb0(%uv: f64, %vv: f64, %out: f64): + %p = arith.mulf %uv, %vv : f64 + linalg.yield %p : f64 + } -> tensor + kernel.yield %result : tensor + } + + // AXPBY: y = a*x + b*y (gesummv pattern). + kernel.defn @cublasDaxpby(%x: tensor, %y: tensor, + %a: f64, %b: f64) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)> + ], + iterator_types = ["parallel"] + } ins(%x : tensor) outs(%y : tensor) { + ^bb0(%xv: f64, %out: f64): + %ax = arith.mulf %a, %xv : f64 + %by = arith.mulf %b, %out : f64 + %s = arith.addf %ax, %by : f64 + linalg.yield %s : f64 + } -> tensor + kernel.yield %result : tensor + } + + // AXPY (alpha=1): y += x. + kernel.defn @cublasDaxpy_unit(%x: tensor, %y: tensor) + -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)> + ], + iterator_types = ["parallel"] + } ins(%x : tensor) outs(%y : tensor) { + ^bb0(%xv: f64, %out: f64): + %s = arith.addf %out, %xv : f64 + linalg.yield %s : f64 + } -> tensor + kernel.yield %result : tensor + } + + // MEMSET-ZERO-1D: y[i] = 0 for all i. + kernel.defn @memset_zero_1D(%y: tensor) -> tensor { + %zero = arith.constant 0.000000e+00 : f64 + %result = linalg.generic { + indexing_maps = [affine_map<(d0) -> (d0)>], + iterator_types = ["parallel"] + } outs(%y : tensor) { + ^bb0(%out: f64): + linalg.yield %zero : f64 + } -> tensor + kernel.yield %result : tensor + } + + kernel.defn @memset_zero_1D_f32(%y: tensor) -> tensor { + %zero = arith.constant 0.000000e+00 : f32 + %result = linalg.generic { + indexing_maps = [affine_map<(d0) -> (d0)>], + iterator_types = ["parallel"] + } outs(%y : tensor) { + ^bb0(%out: f32): + linalg.yield %zero : f32 + } -> tensor + kernel.yield %result : tensor + } + + // MEMSET-ZERO-2D: A[i,j] = 0 for all i,j. + kernel.defn @memset_zero_2D(%A: tensor) -> tensor { + %zero = arith.constant 0.000000e+00 : f64 + %result = linalg.generic { + indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>], + iterator_types = ["parallel", "parallel"] + } outs(%A : tensor) { + ^bb0(%out: f64): + linalg.yield %zero : f64 + } -> tensor + kernel.yield %result : tensor + } + + kernel.defn @memset_zero_2D_f32(%A: tensor) -> tensor { + %zero = arith.constant 0.000000e+00 : f32 + %result = linalg.generic { + indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>], + iterator_types = ["parallel", "parallel"] + } outs(%A : tensor) { + ^bb0(%out: f32): + linalg.yield %zero : f32 + } -> tensor + kernel.yield %result : tensor + } + + // MEMSET-CONST-1D: fill the diagonal of a 2D tensor with 1.0. + // The matcher names this "1D" because the iter space is 1D (single d0) — + // the tensor is 2D but accessed at (d0, d0). Used in correlation's + // diagonal initialization. NOTE: the constant value is HARD-CODED to 1.0 + // because the matcher's Cap binding for the literal isn't currently + // propagated through render_launch. A different caller wanting a + // different fill value would need a separate library entry. + kernel.defn @memset_const_1D(%A: tensor) -> tensor { + %one = arith.constant 1.000000e+00 : f64 + %result = linalg.generic { + indexing_maps = [affine_map<(d0) -> (d0, d0)>], + iterator_types = ["parallel"] + } outs(%A : tensor) { + ^bb0(%out: f64): + linalg.yield %one : f64 + } -> tensor + kernel.yield %result : tensor + } + + // ELEMWISE-DIV-SCALAR: y[i] = y[i] / s. + kernel.defn @elemwise_div_scalar(%y: tensor, %s: f64) -> tensor { + %result = linalg.generic { + indexing_maps = [affine_map<(d0) -> (d0)>], + iterator_types = ["parallel"] + } outs(%y : tensor) { + ^bb0(%out: f64): + %t = arith.divf %out, %s : f64 + linalg.yield %t : f64 + } -> tensor + kernel.yield %result : tensor + } + + // REDUCE-SUM-AXIS: out[j] = sum over the *other* axis of a 2D tensor. + // The 1D output's length matches the parallel axis of the 2D input. + // Indexing maps mirror what correlation's raise step produces. + kernel.defn @reduce_sum_axis(%X: tensor, %y: tensor) + -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d1)> + ], + iterator_types = ["parallel", "reduction"] + } ins(%X : tensor) outs(%y : tensor) { + ^bb0(%in: f64, %out: f64): + %s = arith.addf %out, %in : f64 + linalg.yield %s : f64 + } -> tensor + kernel.yield %result : tensor + } + + // SYRK: C[j<=i] = beta*C[j<=i] + alpha*A*A^T (symmetric rank-k update). + // + // Two-step canonical body matching what RaiseToLinalg emits for PolyBench + // syrk: masked beta-scale of C on the lower triangle, then masked + // alpha-A*A^T-accumulate. The mask is recomputed from linalg.index + + // affine.apply inside each linalg.generic so the defn body is + // self-contained — no external mask SSA is threaded as an operand. + // + // Operand order (matches matcher emit): two A-views (the matcher passes + // both ins of the gemm-shape linalg, which is the same A twice), C, beta, + // alpha. + kernel.defn @cublasDsyrk(%A: tensor, %A2: tensor, + %C: tensor, + %beta: f64, %alpha: f64) -> tensor { + %scaled = linalg.generic { + indexing_maps = [affine_map<(d0, d1) -> (d1, d0)>], + iterator_types = ["parallel", "parallel"] + } outs(%C : tensor) { + ^bb0(%out: f64): + %i = linalg.index 0 : index + %j = linalg.index 1 : index + %i1 = affine.apply affine_map<(d0) -> (d0 + 1)>(%i) + %cond = arith.cmpi slt, %j, %i1 : index + %scaled_val = arith.mulf %out, %beta : f64 + %r = arith.select %cond, %scaled_val, %out : f64 + linalg.yield %r : f64 + } -> tensor + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2) -> (d2, d1)>, + affine_map<(d0, d1, d2) -> (d0, d1)>, + affine_map<(d0, d1, d2) -> (d2, d0)> + ], + iterator_types = ["parallel", "reduction", "parallel"] + } ins(%A, %A2 : tensor, tensor) + outs(%scaled : tensor) { + ^bb0(%a: f64, %a_t: f64, %out: f64): + %i = linalg.index 0 : index + %j = linalg.index 2 : index + %scaled_a = arith.mulf %alpha, %a : f64 + %p = arith.mulf %scaled_a, %a_t : f64 + %s = arith.addf %out, %p : f64 + %i1 = affine.apply affine_map<(d0) -> (d0 + 1)>(%i) + %cond = arith.cmpi slt, %j, %i1 : index + %r = arith.select %cond, %s, %out : f64 + linalg.yield %r : f64 + } -> tensor + kernel.yield %result : tensor + } + + // SYR2K: C[j<=i] = beta*C[j<=i] + alpha*(A*B^T + B*A^T) (rank-2k update). + // + // Five tensor operands: (A1, B1, B2, A2, C) — the matcher's body splits + // the rank-2 update across four ins to the second linalg.generic. Maps + // and iter ordering replicate exactly what RaiseToLinalg emits. + kernel.defn @cublasDsyr2k(%A1: tensor, %B1: tensor, + %B2: tensor, %A2: tensor, + %C: tensor, + %beta: f64, %alpha: f64) -> tensor { + %scaled = linalg.generic { + indexing_maps = [affine_map<(d0, d1) -> (d1, d0)>], + iterator_types = ["parallel", "parallel"] + } outs(%C : tensor) { + ^bb0(%out: f64): + %i = linalg.index 0 : index + %j = linalg.index 1 : index + %i1 = affine.apply affine_map<(d0) -> (d0 + 1)>(%i) + %cond = arith.cmpi slt, %j, %i1 : index + %scaled_val = arith.mulf %out, %beta : f64 + %r = arith.select %cond, %scaled_val, %out : f64 + linalg.yield %r : f64 + } -> tensor + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2) -> (d0, d1)>, + affine_map<(d0, d1, d2) -> (d2, d1)>, + affine_map<(d0, d1, d2) -> (d0, d1)>, + affine_map<(d0, d1, d2) -> (d2, d1)>, + affine_map<(d0, d1, d2) -> (d2, d0)> + ], + iterator_types = ["parallel", "reduction", "parallel"] + } ins(%A1, %B1, %B2, %A2 + : tensor, tensor, + tensor, tensor) + outs(%scaled : tensor) { + ^bb0(%a1: f64, %b1: f64, %b2: f64, %a2: f64, %out: f64): + %i = linalg.index 0 : index + %j = linalg.index 2 : index + %t1 = arith.mulf %a1, %alpha : f64 + %t2 = arith.mulf %t1, %b1 : f64 + %t3 = arith.mulf %b2, %alpha : f64 + %t4 = arith.mulf %t3, %a2 : f64 + %t5 = arith.addf %t2, %t4 : f64 + %t6 = arith.addf %out, %t5 : f64 + %i1 = affine.apply affine_map<(d0) -> (d0 + 1)>(%i) + %cond = arith.cmpi slt, %j, %i1 : index + %r = arith.select %cond, %t6, %out : f64 + linalg.yield %r : f64 + } -> tensor + kernel.yield %result : tensor + } + + // ======================================================================== + // Stencils (Bucket 2). These bodies operate on memref-form linalg.generic + // because the surrounding time-stepping loop holds a memref iter, so + // --linalg-debufferize never lifts them to tensor form. The defns mirror + // the strided memref types that RaiseToLinalg emits for PolyBench stencils. + // Constants are hard-coded to PolyBench's values (1/3, 1/5, 1/8, etc.) — + // a Cap-bound literal would be passed as a runtime operand for general + // callers; we don't do that yet (matcher's Cap-binds-to-Lit means the + // launch operand list drops the literal). + // ======================================================================== + + // JACOBI 1D 3-point: out[i] = (a[i] + b[i+1] + c[i+2]) / 3 + // The "shift" is baked into the subview offsets (the linalg body sees + // identity-accessed memrefs at different base offsets). + kernel.defn @jacobi_1d_3pt( + %a: memref>, + %b: memref>, + %c: memref>, + %out: memref>) { + %cst = arith.constant 0.33333333333333331 : f64 + linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)> + ], + iterator_types = ["parallel"] + } ins(%a, %b, %c + : memref>, + memref>, + memref>) + outs(%out : memref>) { + ^bb0(%av: f64, %bv: f64, %cv: f64, %outv: f64): + %s1 = arith.addf %av, %bv : f64 + %s2 = arith.addf %s1, %cv : f64 + %r = arith.mulf %s2, %cst : f64 + linalg.yield %r : f64 + } + kernel.yield + } + + // JACOBI 2D 5-point: out[i,j] = (c + n + s + w + e) / 5 + kernel.defn @jacobi_2d_5pt( + %a0: memref>, + %a1: memref>, + %a2: memref>, + %a3: memref>, + %a4: memref>, + %out: memref>) { + %cst = arith.constant 0.20000000000000001 : f64 + linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d1, d0)>, + affine_map<(d0, d1) -> (d1, d0)>, + affine_map<(d0, d1) -> (d1, d0)>, + affine_map<(d0, d1) -> (d1, d0)>, + affine_map<(d0, d1) -> (d1, d0)>, + affine_map<(d0, d1) -> (d1, d0)> + ], + iterator_types = ["parallel", "parallel"] + } ins(%a0, %a1, %a2, %a3, %a4 + : memref>, + memref>, + memref>, + memref>, + memref>) + outs(%out : memref>) { + ^bb0(%v0: f64, %v1: f64, %v2: f64, %v3: f64, %v4: f64, %ov: f64): + %s1 = arith.addf %v0, %v1 : f64 + %s2 = arith.addf %s1, %v2 : f64 + %s3 = arith.addf %s2, %v3 : f64 + %s4 = arith.addf %s3, %v4 : f64 + %r = arith.mulf %s4, %cst : f64 + linalg.yield %r : f64 + } + kernel.yield + } + + // HEAT 3D 7-point: out = c + (l-2c+r + d-2c+u + b-2c+f)/8. + // Operand order from matcher: x-pair (a0,a2), center (a1), y-pair (a3,a4), + // z-pair (a5,a6). + kernel.defn @heat_3d_7pt( + %a0: memref>, + %a1: memref>, + %a2: memref>, + %a3: memref>, + %a4: memref>, + %a5: memref>, + %a6: memref>, + %out: memref>) { + %coef = arith.constant 0.125 : f64 + %two = arith.constant 2.000000e+00 : f64 + linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)> + ], + iterator_types = ["parallel", "parallel", "parallel"] + } ins(%a0, %a1, %a2, %a3, %a4, %a5, %a6 + : memref>, + memref>, + memref>, + memref>, + memref>, + memref>, + memref>) + outs(%out : memref>) { + ^bb0(%v0: f64, %v1: f64, %v2: f64, %v3: f64, %v4: f64, + %v5: f64, %v6: f64, %ov: f64): + %t2c = arith.mulf %v1, %two : f64 + %x_diff = arith.subf %v0, %t2c : f64 + %x_lap = arith.addf %x_diff, %v2 : f64 + %x_sc = arith.mulf %x_lap, %coef : f64 + %y_diff = arith.subf %v3, %t2c : f64 + %y_lap = arith.addf %y_diff, %v4 : f64 + %y_sc = arith.mulf %y_lap, %coef : f64 + %z_diff = arith.subf %v5, %t2c : f64 + %z_lap = arith.addf %z_diff, %v6 : f64 + %z_sc = arith.mulf %z_lap, %coef : f64 + %xy = arith.addf %x_sc, %y_sc : f64 + %xyz = arith.addf %xy, %z_sc : f64 + %r = arith.addf %xyz, %v1 : f64 + linalg.yield %r : f64 + } + kernel.yield + } + + // FDTD-2D H-field update: out -= 0.5 * (in0 - in1). + kernel.defn @fdtd_update_2in( + %a0: memref>, + %a1: memref>, + %out: memref>) { + %coef = arith.constant 5.000000e-01 : f64 + linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)> + ], + iterator_types = ["parallel", "parallel"] + } ins(%a0, %a1 + : memref>, + memref>) + outs(%out : memref>) { + ^bb0(%v0: f64, %v1: f64, %ov: f64): + %diff = arith.subf %v0, %v1 : f64 + %sc = arith.mulf %diff, %coef : f64 + %r = arith.subf %ov, %sc : f64 + linalg.yield %r : f64 + } + kernel.yield + } + + // FDTD-2D E-field update: out -= 0.7 * (in0 - in1 + in2 - in3). + kernel.defn @fdtd_E_update( + %a0: memref>, + %a1: memref>, + %a2: memref>, + %a3: memref>, + %out: memref>) { + %coef = arith.constant 6.999999999999999e-01 : f64 + linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)> + ], + iterator_types = ["parallel", "parallel"] + } ins(%a0, %a1, %a2, %a3 + : memref>, + memref>, + memref>, + memref>) + outs(%out : memref>) { + ^bb0(%v0: f64, %v1: f64, %v2: f64, %v3: f64, %ov: f64): + %d1 = arith.subf %v0, %v1 : f64 + %a = arith.addf %d1, %v2 : f64 + %d2 = arith.subf %a, %v3 : f64 + %sc = arith.mulf %d2, %coef : f64 + %r = arith.subf %ov, %sc : f64 + linalg.yield %r : f64 + } + kernel.yield + } + + // FDTD-2D source-injection: out[j] = source (broadcast 0-D memref over 1D). + // Matcher emits this when the input's indexing map is `() -> ()` (scalar + // access). + kernel.defn @broadcast_scalar_to_vec( + %src: memref>, + %out: memref>) { + linalg.generic { + indexing_maps = [ + affine_map<(d0) -> ()>, + affine_map<(d0) -> (d0)> + ], + iterator_types = ["parallel"] + } ins(%src : memref>) + outs(%out : memref>) { + ^bb0(%sv: f64, %ov: f64): + linalg.yield %sv : f64 + } + kernel.yield + } + + // cublasDcopy: 1D-to-1D identity copy (out[i] = in[i]). Used by doitgen + // for write-back of the scratch buffer. + kernel.defn @cublasDcopy( + %src: memref>, + %out: memref>) { + linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)> + ], + iterator_types = ["parallel"] + } ins(%src : memref>) + outs(%out : memref>) { + ^bb0(%sv: f64, %ov: f64): + linalg.yield %sv : f64 + } + kernel.yield + } + + // CENTERED-SUM-SQUARES: out[j] = sum_i (X[i,j] - mean[j])^2. + // Variance accumulation (without the 1/N division — that's a separate + // elemwise_div_scalar in correlation). + kernel.defn @centered_sum_squares(%X: tensor, + %mean: tensor, + %y: tensor) -> tensor { + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d1)>, + affine_map<(d0, d1) -> (d1)> + ], + iterator_types = ["parallel", "reduction"] + } ins(%X, %mean : tensor, tensor) + outs(%y : tensor) { + ^bb0(%in: f64, %m: f64, %out: f64): + %d = arith.subf %in, %m : f64 + %p = arith.mulf %d, %d : f64 + %s = arith.addf %out, %p : f64 + linalg.yield %s : f64 + } -> tensor + kernel.yield %result : tensor + } + + // ============================================================ + // Tensor-form stencil defns (multi-root debufferize emits these). + // Identical bodies to the memref-form stencils above, but with plain + // `tensor` operand/result types — the polygeist.submap chain + // that encodes the offsets is opaque to the lowerer, so the defns can + // treat each input as a plain tensor of the same rank. + // ============================================================ + + // JACOBI 1D 3-point, tensor form. + kernel.defn @jacobi_1d_3pt_tensor( + %a: tensor, %b: tensor, %c: tensor, + %out_init: tensor) -> tensor { + %cst = arith.constant 0.33333333333333331 : f64 + %r = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)> + ], + iterator_types = ["parallel"] + } ins(%a, %b, %c : tensor, tensor, tensor) + outs(%out_init : tensor) { + ^bb0(%av: f64, %bv: f64, %cv: f64, %ov: f64): + %s1 = arith.addf %av, %bv : f64 + %s2 = arith.addf %s1, %cv : f64 + %r = arith.mulf %s2, %cst : f64 + linalg.yield %r : f64 + } -> tensor + kernel.yield %r : tensor + } + + // JACOBI 2D 5-point, tensor form. + kernel.defn @jacobi_2d_5pt_tensor( + %a0: tensor, %a1: tensor, %a2: tensor, + %a3: tensor, %a4: tensor, + %out_init: tensor) -> tensor { + %cst = arith.constant 0.20000000000000001 : f64 + %r = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)> + ], + iterator_types = ["parallel", "parallel"] + } ins(%a0, %a1, %a2, %a3, %a4 + : tensor, tensor, tensor, + tensor, tensor) + outs(%out_init : tensor) { + ^bb0(%v0: f64, %v1: f64, %v2: f64, %v3: f64, %v4: f64, %ov: f64): + %s1 = arith.addf %v0, %v1 : f64 + %s2 = arith.addf %s1, %v2 : f64 + %s3 = arith.addf %s2, %v3 : f64 + %s4 = arith.addf %s3, %v4 : f64 + %r = arith.mulf %s4, %cst : f64 + linalg.yield %r : f64 + } -> tensor + kernel.yield %r : tensor + } + + // HEAT 3D 7-point, tensor form. + kernel.defn @heat_3d_7pt_tensor( + %a0: tensor, %a1: tensor, %a2: tensor, + %a3: tensor, %a4: tensor, %a5: tensor, + %a6: tensor, + %out_init: tensor) -> tensor { + %coef = arith.constant 0.125 : f64 + %two = arith.constant 2.000000e+00 : f64 + %r = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)>, + affine_map<(d0, d1, d2) -> (d0, d1, d2)> + ], + iterator_types = ["parallel", "parallel", "parallel"] + } ins(%a0, %a1, %a2, %a3, %a4, %a5, %a6 + : tensor, tensor, tensor, + tensor, tensor, tensor, + tensor) + outs(%out_init : tensor) { + ^bb0(%v0: f64, %v1: f64, %v2: f64, %v3: f64, %v4: f64, + %v5: f64, %v6: f64, %ov: f64): + %t2c = arith.mulf %v1, %two : f64 + %x_diff = arith.subf %v0, %t2c : f64 + %x_lap = arith.addf %x_diff, %v2 : f64 + %x_sc = arith.mulf %x_lap, %coef : f64 + %y_diff = arith.subf %v3, %t2c : f64 + %y_lap = arith.addf %y_diff, %v4 : f64 + %y_sc = arith.mulf %y_lap, %coef : f64 + %z_diff = arith.subf %v5, %t2c : f64 + %z_lap = arith.addf %z_diff, %v6 : f64 + %z_sc = arith.mulf %z_lap, %coef : f64 + %xy = arith.addf %x_sc, %y_sc : f64 + %xyz = arith.addf %xy, %z_sc : f64 + %r = arith.addf %xyz, %v1 : f64 + linalg.yield %r : f64 + } -> tensor + kernel.yield %r : tensor + } + + // FDTD-2D H-field update, tensor form. + kernel.defn @fdtd_update_2in_tensor( + %a0: tensor, %a1: tensor, + %out_init: tensor) -> tensor { + %coef = arith.constant 5.000000e-01 : f64 + %r = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)> + ], + iterator_types = ["parallel", "parallel"] + } ins(%a0, %a1 : tensor, tensor) + outs(%out_init : tensor) { + ^bb0(%v0: f64, %v1: f64, %ov: f64): + %diff = arith.subf %v0, %v1 : f64 + %sc = arith.mulf %diff, %coef : f64 + %r = arith.subf %ov, %sc : f64 + linalg.yield %r : f64 + } -> tensor + kernel.yield %r : tensor + } + + // Broadcast a 0-D tensor (scalar) over a 1D tensor — tensor-form twin + // of @broadcast_scalar_to_vec. Used by multi-root fdtd-2d's source- + // injection step where polygeist.submap produces a rank-0 tensor. + kernel.defn @broadcast_scalar_to_vec_tensor( + %src: tensor, + %out_init: tensor) -> tensor { + %r = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> ()>, + affine_map<(d0) -> (d0)> + ], + iterator_types = ["parallel"] + } ins(%src : tensor) + outs(%out_init : tensor) { + ^bb0(%sv: f64, %ov: f64): + linalg.yield %sv : f64 + } -> tensor + kernel.yield %r : tensor + } + + // cublasDcopy, tensor form (1D identity copy). Used by multi-root + // fdtd-2d's source-injection step. + kernel.defn @cublasDcopy_tensor( + %src: tensor, + %out_init: tensor) -> tensor { + %r = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)> + ], + iterator_types = ["parallel"] + } ins(%src : tensor) + outs(%out_init : tensor) { + ^bb0(%sv: f64, %ov: f64): + linalg.yield %sv : f64 + } -> tensor + kernel.yield %r : tensor + } + + // FDTD-2D E-field update, tensor form. + kernel.defn @fdtd_E_update_tensor( + %a0: tensor, %a1: tensor, + %a2: tensor, %a3: tensor, + %out_init: tensor) -> tensor { + %coef = arith.constant 6.999999999999999e-01 : f64 + %r = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)>, + affine_map<(d0, d1) -> (d0, d1)> + ], + iterator_types = ["parallel", "parallel"] + } ins(%a0, %a1, %a2, %a3 + : tensor, tensor, tensor, tensor) + outs(%out_init : tensor) { + ^bb0(%v0: f64, %v1: f64, %v2: f64, %v3: f64, %ov: f64): + %d1 = arith.subf %v0, %v1 : f64 + %a = arith.addf %d1, %v2 : f64 + %d2 = arith.subf %a, %v3 : f64 + %sc = arith.mulf %d2, %coef : f64 + %r = arith.subf %ov, %sc : f64 + linalg.yield %r : f64 + } -> tensor + kernel.yield %r : tensor + } + + // Conv2D 9-tap weighted (3x3 stencil). + // Operands: 9 input subviews (memref form) of one source tensor (one per + // 3x3 neighbour position) + 1 output subview. The 9 scalar weights live + // *inside* the matched linalg.generic body, not in the kernel.launch + // operand list — surfacing them is a matcher-extension TODO. For the + // --lower-kernel-launch-to-cublas dispatch this defn is just a symbol + // carrier (the cuDNN runtime shim hardcodes the polybench weights); + // body is no-op so the verifier passes. + kernel.defn @cudnnConvolution2D_9tap( + %A0: memref>, + %A1: memref>, + %A2: memref>, + %A3: memref>, + %A4: memref>, + %A5: memref>, + %A6: memref>, + %A7: memref>, + %A8: memref>, + %C: memref>, + %w0: f64, %w1: f64, %w2: f64, + %w3: f64, %w4: f64, %w5: f64, + %w6: f64, %w7: f64, %w8: f64) { + kernel.yield + } + + kernel.defn @cudnnConvolution2D_9tap_tensor( + %A0: tensor, %A1: tensor, %A2: tensor, + %A3: tensor, %A4: tensor, %A5: tensor, + %A6: tensor, %A7: tensor, %A8: tensor, + %C: tensor, + %w0: f64, %w1: f64, %w2: f64, + %w3: f64, %w4: f64, %w5: f64, + %w6: f64, %w7: f64, %w8: f64) -> tensor { + kernel.yield %C : tensor + } + + // FP32 variant of the conv2d 9-tap defn. Same structure as the f64 one + // but with f32 memrefs + f32 weights. Selected by the rewriter when the + // matched body's operand types are f32 (it emits @cudnnConvolution2D_9tap_f32 + // as the launch symbol). Phase 2 of the cuDNN conv generalization. + kernel.defn @cudnnConvolution2D_9tap_f32( + %A0: memref>, + %A1: memref>, + %A2: memref>, + %A3: memref>, + %A4: memref>, + %A5: memref>, + %A6: memref>, + %A7: memref>, + %A8: memref>, + %C: memref>, + %w0: f32, %w1: f32, %w2: f32, + %w3: f32, %w4: f32, %w5: f32, + %w6: f32, %w7: f32, %w8: f32) { + kernel.yield + } + + // Conv2D 25-tap weighted (5x5 stencil), surfaced exactly like the 9-tap + // path: 25 shifted input subviews, one output interior subview, then 25 + // scalar filter weights in row-major order. + kernel.defn @cudnnConvolution2D_25tap( + %A0: memref>, + %A1: memref>, + %A2: memref>, + %A3: memref>, + %A4: memref>, + %A5: memref>, + %A6: memref>, + %A7: memref>, + %A8: memref>, + %A9: memref>, + %A10: memref>, + %A11: memref>, + %A12: memref>, + %A13: memref>, + %A14: memref>, + %A15: memref>, + %A16: memref>, + %A17: memref>, + %A18: memref>, + %A19: memref>, + %A20: memref>, + %A21: memref>, + %A22: memref>, + %A23: memref>, + %A24: memref>, + %C: memref>, + %w0: f64, %w1: f64, %w2: f64, %w3: f64, %w4: f64, + %w5: f64, %w6: f64, %w7: f64, %w8: f64, %w9: f64, + %w10: f64, %w11: f64, %w12: f64, %w13: f64, %w14: f64, + %w15: f64, %w16: f64, %w17: f64, %w18: f64, %w19: f64, + %w20: f64, %w21: f64, %w22: f64, %w23: f64, %w24: f64) { + kernel.yield + } + + kernel.defn @cudnnConvolution2D_25tap_f32( + %A0: memref>, + %A1: memref>, + %A2: memref>, + %A3: memref>, + %A4: memref>, + %A5: memref>, + %A6: memref>, + %A7: memref>, + %A8: memref>, + %A9: memref>, + %A10: memref>, + %A11: memref>, + %A12: memref>, + %A13: memref>, + %A14: memref>, + %A15: memref>, + %A16: memref>, + %A17: memref>, + %A18: memref>, + %A19: memref>, + %A20: memref>, + %A21: memref>, + %A22: memref>, + %A23: memref>, + %A24: memref>, + %C: memref>, + %w0: f32, %w1: f32, %w2: f32, %w3: f32, %w4: f32, + %w5: f32, %w6: f32, %w7: f32, %w8: f32, %w9: f32, + %w10: f32, %w11: f32, %w12: f32, %w13: f32, %w14: f32, + %w15: f32, %w16: f32, %w17: f32, %w18: f32, %w19: f32, + %w20: f32, %w21: f32, %w22: f32, %w23: f32, %w24: f32) { + kernel.yield + } + + // Generalized odd-square weighted Conv2D stencil. The matcher proves the + // original linalg inputs are same-base shifted subviews, then packs the + // row-major KxK weights into %W and passes only the top-left input subview, + // output interior subview, packed weights, and K. This avoids adding one + // kernel.defn per tap count. + kernel.defn @cudnnConvolution2D_ntap( + %A: memref>, + %C: memref>, + %W: memref, + %K: i32) { + kernel.yield + } + + kernel.defn @cudnnConvolution2D_ntap_f32( + %A: memref>, + %C: memref>, + %W: memref, + %K: i32) { + kernel.yield + } + + kernel.defn @cudnnConvolution2D_ntap_tensor( + %A: tensor, + %C: tensor, + %W: tensor, + %K: i32) -> tensor { + kernel.yield %C : tensor + } + + kernel.defn @cudnnConvolution2D_ntap_f32_tensor( + %A: tensor, + %C: tensor, + %W: tensor, + %K: i32) -> tensor { + kernel.yield %C : tensor + } + + // Generalized packed-weight Conv3D stencil. The matcher proves the raised + // reduction uses a dense rank-6 window view, then passes the haloed 3D input + // tensor, dense 3D output tensor, rank-3 filter tensor, and filter width. + kernel.defn @cudnnConvolution3D_ntap_tensor( + %A: tensor, + %C: tensor, + %W: tensor, + %K: i32) -> tensor { + kernel.yield %C : tensor + } + + kernel.defn @cudnnConvolution3D_ntap_f32_tensor( + %A: tensor, + %C: tensor, + %W: tensor, + %K: i32) -> tensor { + kernel.yield %C : tensor + } + + // Multi-channel, single-batch valid Conv3D. The rank-8 operand is the + // logical [OC,OD,OH,OW,IC,KD,KH,KW] window; ABI lowering recovers the + // underlying rank-4/5 NCDHW input before calling cuDNN. + kernel.defn @cudnnConvolution3D_f32( + %window: tensor, + %filter: tensor, + %out: tensor) -> tensor { + kernel.yield %out : tensor + } + + kernel.defn @cudnnConvolution3D_f32_bias( + %window: tensor, + %filter: tensor, %bias: tensor, + %out: tensor) -> tensor { + kernel.yield %out : tensor + } + + // Custom structured 3D 7-point stencil definitions. These operate on the + // raised form directly: seven same-shaped tap tensors plus an output tensor. + // The lowering maps all variants to one runtime ABI and passes null pointers + // for missing optional operands. + kernel.defn @customStencil3D7pt_f64_tensor( + %a0: tensor, %a1: tensor, + %a2: tensor, %a3: tensor, + %a4: tensor, %a5: tensor, + %a6: tensor, %out: tensor, + %base0: f64, %base_extra: f64, %coeff_extra: f64, + %c0: f64, %c1: f64, %c2: f64, %c3: f64, + %c4: f64, %c5: f64, %c6: f64) -> tensor { + kernel.yield %out : tensor + } + + kernel.defn @customStencil3D7ptCoeff_f64_tensor( + %a0: tensor, %a1: tensor, + %a2: tensor, %a3: tensor, + %a4: tensor, %a5: tensor, + %a6: tensor, %coeff: tensor, + %out: tensor, + %base0: f64, %base_extra: f64, %coeff_extra: f64, + %c0: f64, %c1: f64, %c2: f64, %c3: f64, + %c4: f64, %c5: f64, %c6: f64) -> tensor { + kernel.yield %out : tensor + } + + kernel.defn @customStencil3D7ptExtra_f64_tensor( + %a0: tensor, %a1: tensor, + %a2: tensor, %a3: tensor, + %a4: tensor, %a5: tensor, + %a6: tensor, %extra: tensor, + %out: tensor, + %base0: f64, %base_extra: f64, %coeff_extra: f64, + %c0: f64, %c1: f64, %c2: f64, %c3: f64, + %c4: f64, %c5: f64, %c6: f64) -> tensor { + kernel.yield %out : tensor + } + + // 1D complex FFT ABI declarations. Complex values are represented as + // interleaved real/imag pairs in the trailing dimension of size 2. The + // runtime follows cuFFT semantics: inverse transforms are unnormalized. + kernel.defn @cufftZ2Z_1D_tensor( + %A: tensor, + %C: tensor, + %inverse: i32) -> tensor { + kernel.yield %C : tensor + } + + kernel.defn @cufftC2C_1D_tensor( + %A: tensor, + %C: tensor, + %inverse: i32) -> tensor { + kernel.yield %C : tensor + } + + // Separable 3D tensor product: ai,bj,ck,ijk->abc. The operands are the + // rank-6 broadcast/submap views produced by raising; ABI lowering unwraps + // them to the shared psi buffer, the u buffer, and the output buffer. + kernel.defn @cutensornetTensorProduct3D_f32_tensor( + %psiA: tensor, + %psiB: tensor, + %psiC: tensor, + %u: tensor, + %out: tensor) -> tensor { + kernel.yield %out : tensor + } + + kernel.defn @cutensornetTensorProduct3D_f64_tensor( + %psiA: tensor, + %psiB: tensor, + %psiC: tensor, + %u: tensor, + %out: tensor) -> tensor { + kernel.yield %out : tensor + } + + // Layout-aware two-input FP64 Einstein contractions. The matcher attaches + // the original linalg indexing maps to each launch; ABI lowering combines + // them with polygeist.submap strides and routes the operation to + // cuTensorNet. The unranked signature is the generic route; ranked legacy + // symbols remain accepted for compatibility with existing matched files. + kernel.defn @cutensornetContraction2_f64( + %A: tensor<*xf64>, + %B: tensor<*xf64>, + %C: tensor<*xf64>) -> tensor<*xf64> { + kernel.yield %C : tensor<*xf64> + } + + kernel.defn @cutensornetContraction2_f64_r4r5r4( + %A: tensor, + %B: tensor, + %C: tensor) -> tensor { + kernel.yield %C : tensor + } + + kernel.defn @cutensornetContraction2_f64_r5r4r4( + %A: tensor, + %B: tensor, + %C: tensor) -> tensor { + kernel.yield %C : tensor + } + + kernel.defn @cutensornetContraction2_f64_r5r5r4( + %A: tensor, + %B: tensor, + %C: tensor) -> tensor { + kernel.yield %C : tensor + } + + kernel.defn @cudnnConvolution2D_9tap_f16( + %A0: memref>, + %A1: memref>, + %A2: memref>, + %A3: memref>, + %A4: memref>, + %A5: memref>, + %A6: memref>, + %A7: memref>, + %A8: memref>, + %C: memref>, + %w0: f16, %w1: f16, %w2: f16, + %w3: f16, %w4: f16, %w5: f16, + %w6: f16, %w7: f16, %w8: f16) { + kernel.yield + } + + kernel.defn @cudnnConvolution2D_9tap_bf16( + %A0: memref>, + %A1: memref>, + %A2: memref>, + %A3: memref>, + %A4: memref>, + %A5: memref>, + %A6: memref>, + %A7: memref>, + %A8: memref>, + %C: memref>, + %w0: bf16, %w1: bf16, %w2: bf16, + %w3: bf16, %w4: bf16, %w5: bf16, + %w6: bf16, %w7: bf16, %w8: bf16) { + kernel.yield + } + + kernel.defn @cudnnConvolution2D_9tap_i32( + %A0: memref>, + %A1: memref>, + %A2: memref>, + %A3: memref>, + %A4: memref>, + %A5: memref>, + %A6: memref>, + %A7: memref>, + %A8: memref>, + %C: memref>, + %w0: i32, %w1: i32, %w2: i32, + %w3: i32, %w4: i32, %w5: i32, + %w6: i32, %w7: i32, %w8: i32) { + kernel.yield + } + + kernel.defn @cudnnConvolution2D_9tap_i16( + %A0: memref>, + %A1: memref>, + %A2: memref>, + %A3: memref>, + %A4: memref>, + %A5: memref>, + %A6: memref>, + %A7: memref>, + %A8: memref>, + %C: memref>, + %w0: i16, %w1: i16, %w2: i16, + %w3: i16, %w4: i16, %w5: i16, + %w6: i16, %w7: i16, %w8: i16) { + kernel.yield + } +} diff --git a/generic_solver/test_input_simple.mlir b/generic_solver/test_input_simple.mlir new file mode 100644 index 000000000000..8fa0e6df4edf --- /dev/null +++ b/generic_solver/test_input_simple.mlir @@ -0,0 +1,71 @@ +// Test input file - contains linalg.generic operations to be matched +// This file does NOT contain kernel.defn_collection - those will be loaded externally + +module { + // Function that performs simple matrix multiplication + func.func @simple_gemm(%A: tensor, %B: tensor, %C: tensor) -> tensor { + // This linalg.generic should match @simple_gemm_linalg from kernel_library.mlir + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0, d1, d2) -> (d0, d2)>, + affine_map<(d0, d1, d2) -> (d2, d1)>, + affine_map<(d0, d1, d2) -> (d0, d1)> + ], + iterator_types = ["parallel", "parallel", "reduction"] + } ins(%A, %B : tensor, tensor) + outs(%C : tensor) { + ^bb0(%a: f32, %b: f32, %c: f32): + %product = arith.mulf %a, %b : f32 + %result = arith.addf %product, %c : f32 + linalg.yield %result : f32 + } -> tensor + return %result : tensor + } + + // Function that computes sum of absolute values + func.func @compute_asum(%X: tensor) -> tensor { + %c0 = arith.constant 0.0 : f32 + %init = tensor.empty() : tensor + %fill = linalg.fill ins(%c0 : f32) outs(%init : tensor) -> tensor + + // This linalg.generic should match @asum_linalg from kernel_library.mlir + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> ()> + ], + iterator_types = ["reduction"] + } ins(%X : tensor) + outs(%fill : tensor) { + ^bb0(%in: f32, %out: f32): + %abs_val = math.absf %in : f32 + %result = arith.addf %abs_val, %out : f32 + linalg.yield %result : f32 + } -> tensor + return %result : tensor + } + + // Function that computes dot product + func.func @compute_dot(%X: tensor, %Y: tensor) -> tensor { + %c0 = arith.constant 0.0 : f32 + %init = tensor.empty() : tensor + %fill = linalg.fill ins(%c0 : f32) outs(%init : tensor) -> tensor + + // This linalg.generic should match @dot_linalg from kernel_library.mlir + %result = linalg.generic { + indexing_maps = [ + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> (d0)>, + affine_map<(d0) -> ()> + ], + iterator_types = ["reduction"] + } ins(%X, %Y : tensor, tensor) + outs(%fill : tensor) { + ^bb0(%x: f32, %y: f32, %out: f32): + %product = arith.mulf %x, %y : f32 + %result = arith.addf %product, %out : f32 + linalg.yield %result : f32 + } -> tensor + return %result : tensor + } +} \ No newline at end of file diff --git a/include/polygeist/CMakeLists.txt b/include/polygeist/CMakeLists.txt index efcf93f70329..06fb9a05da90 100644 --- a/include/polygeist/CMakeLists.txt +++ b/include/polygeist/CMakeLists.txt @@ -2,4 +2,5 @@ add_mlir_dialect(PolygeistOps polygeist) add_mlir_doc(PolygeistDialect -gen-dialect-doc PolygeistDialect Polygeist/) add_mlir_doc(PolygeistOps -gen-op-doc PolygeistOps Polygeist/) -add_subdirectory(Passes) \ No newline at end of file +add_subdirectory(Passes) +add_subdirectory(Kernel) \ No newline at end of file diff --git a/include/polygeist/Kernel/CMakeLists.txt b/include/polygeist/Kernel/CMakeLists.txt new file mode 100644 index 000000000000..6bc7f03a564c --- /dev/null +++ b/include/polygeist/Kernel/CMakeLists.txt @@ -0,0 +1 @@ +add_mlir_dialect(KernelOps kernel) \ No newline at end of file diff --git a/include/polygeist/Kernel/KernelDialect.h b/include/polygeist/Kernel/KernelDialect.h new file mode 100644 index 000000000000..6dbf888f97fc --- /dev/null +++ b/include/polygeist/Kernel/KernelDialect.h @@ -0,0 +1,25 @@ +//===- KernelDialect.h - Kernel dialect declaration -------------*- C++ -*-===// +// +// This file is licensed under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef POLYGEIST_KERNEL_KERNELDIALECT_H +#define POLYGEIST_KERNEL_KERNELDIALECT_H + +#include "mlir/IR/Dialect.h" +#include "mlir/Dialect/MemRef/IR/MemRef.h" + +namespace mlir { +namespace polygeist { +namespace kernel { + +} // namespace kernel +} // namespace polygeist +} // namespace mlir + +#include "polygeist/Kernel/KernelOpsDialect.h.inc" + +#endif // POLYGEIST_KERNEL_KERNELDIALECT_H \ No newline at end of file diff --git a/include/polygeist/Kernel/KernelDialect.td b/include/polygeist/Kernel/KernelDialect.td new file mode 100644 index 000000000000..68ffc856b65f --- /dev/null +++ b/include/polygeist/Kernel/KernelDialect.td @@ -0,0 +1,36 @@ +//===- KernelDialect.td - Kernel dialect definition -------*- tablegen -*-===// +// +// This file is licensed under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef KERNEL_DIALECT +#define KERNEL_DIALECT + +include "mlir/IR/OpBase.td" + +//===----------------------------------------------------------------------===// +// Kernel dialect definition +//===----------------------------------------------------------------------===// + +def Kernel_Dialect : Dialect { + let name = "kernel"; + let cppNamespace = "::mlir::polygeist::kernel"; + let description = [{ + The kernel dialect provides operations for NVIDIA kernel matrix multiplication + routines, including standard and batched GEMM operations. This dialect enables + representation and optimization of high-performance linear algebra kernels + within the Polygeist infrastructure. + }]; +} + +//===----------------------------------------------------------------------===// +// Base class for kernel dialect operations +//===----------------------------------------------------------------------===// + +class Kernel_Op traits = []> : + Op; + +#endif // KERNEL_DIALECT \ No newline at end of file diff --git a/include/polygeist/Kernel/KernelOps.h b/include/polygeist/Kernel/KernelOps.h new file mode 100644 index 000000000000..966ef77d6379 --- /dev/null +++ b/include/polygeist/Kernel/KernelOps.h @@ -0,0 +1,32 @@ +//===- KernelOps.h - Kernel dialect operations ------------------*- C++ -*-===// +// +// This file is licensed under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef POLYGEIST_KERNEL_KERNELOPS_H +#define POLYGEIST_KERNEL_KERNELOPS_H + +#include "mlir/IR/BuiltinOps.h" +#include "mlir/IR/BuiltinTypes.h" +#include "mlir/IR/Dialect.h" +#include "mlir/IR/OpDefinition.h" +#include "mlir/Interfaces/ControlFlowInterfaces.h" +#include "mlir/Interfaces/SideEffectInterfaces.h" +#include "mlir/Dialect/Func/IR/FuncOps.h" +#include "polygeist/Kernel/KernelDialect.h" + +namespace mlir { +namespace polygeist { +namespace kernel { + +} // namespace kernel +} // namespace polygeist +} // namespace mlir + +#define GET_OP_CLASSES +#include "polygeist/Kernel/KernelOps.h.inc" + +#endif // POLYGEIST_KERNEL_KERNELOPS_H \ No newline at end of file diff --git a/include/polygeist/Kernel/KernelOps.td b/include/polygeist/Kernel/KernelOps.td new file mode 100644 index 000000000000..aa5c758cf179 --- /dev/null +++ b/include/polygeist/Kernel/KernelOps.td @@ -0,0 +1,200 @@ +//===- KernelOps.td - Kernel dialect operation definitions -*-- tablegen -*-===// +// +// This file is licensed under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef KERNEL_OPS +#define KERNEL_OPS + +include "polygeist/Kernel/KernelDialect.td" +include "mlir/Interfaces/SideEffectInterfaces.td" +include "mlir/Interfaces/ControlFlowInterfaces.td" +include "mlir/Interfaces/FunctionInterfaces.td" +include "mlir/IR/SymbolInterfaces.td" +include "mlir/IR/OpAsmInterface.td" + +//===----------------------------------------------------------------------===// +// Kernel operation definitions +//===----------------------------------------------------------------------===// + +def Kernel_DefnCollectionOp : Kernel_Op<"defn_collection", [NoTerminator]> { + let summary = "Collection of kernel operation definitions"; + let description = [{ + A collection of operation definitions that can be referenced elsewhere. + This operation serves as a container for multiple kernel operation definitions, + enabling modular organization of kernel implementations. + }]; + + let regions = (region SizedRegion<1>:$defns); + + let assemblyFormat = [{ + $defns attr-dict + }]; +} + +def Kernel_DefnOp : Kernel_Op<"defn", [ + AffineScope, + AutomaticAllocationScope, + IsolatedFromAbove, + FunctionOpInterface, + Symbol +]> { + let summary = "Definition of a kernel operation"; + let description = [{ + A definition of a kernel operation with inputs and arbitrary body code. + Can contain either literal CUDA/HIP code or a linalg.generic representation + for high-performance linear algebra operations. + + This operation is particularly useful for defining custom GEMM variants, + batched operations, and other specialized linear algebra kernels. + + Example: + ```mlir + kernel.defn @custom_gemm(%A: memref, %B: memref, + %C: memref, %alpha: f32) -> tensor { + // Kernel implementation + kernel.yield %some_result : tensor + } + ``` + }]; + + let arguments = (ins + SymbolNameAttr:$sym_name, + TypeAttrOf:$function_type, + OptionalAttr:$sym_visibility, + OptionalAttr:$arg_attrs, + OptionalAttr:$res_attrs + ); + + let regions = (region AnyRegion:$body); + + let builders = [OpBuilder<(ins + "StringRef":$name, "FunctionType":$type, + CArg<"ArrayRef", "{}">:$attrs, + CArg<"ArrayRef", "{}">:$argAttrs) + >]; + + let hasCustomAssemblyFormat = 1; + + let hasVerifier = 1; + + let extraClassDeclaration = [{ + /// Returns the argument types of this kernel. + ArrayRef getArgumentTypes() { return getFunctionType().getInputs(); } + + /// Returns the result types of this kernel. + ArrayRef getResultTypes() { return getFunctionType().getResults(); } + + /// Returns the region on the current operation that is callable. + ::mlir::Region *getCallableRegion() { return &getBody(); } + + //===------------------------------------------------------------------===// + // SymbolOpInterface Methods + //===------------------------------------------------------------------===// + + bool isDeclaration() { return getBody().empty(); } + }]; +} + +//===----------------------------------------------------------------------===// +// LaunchOp +//===----------------------------------------------------------------------===// + +def Kernel_LaunchOp : Kernel_Op<"launch", + [CallOpInterface, MemRefsNormalizable, + DeclareOpInterfaceMethods]> { + let summary = "kernel launch operation"; + let description = [{ + The `kernel.launch` operation represents a launch of a kernel that is + within the same symbol scope as the launch. The operands and result types of + the launch must match the specified kernel type. The kernel is encoded as a + symbol reference attribute named "kernel". + + Example: + + ```mlir + %result = kernel.launch @custom_gemm(%A, %B, %C, %alpha) : (memref, memref, memref, f32) -> tensor + ``` + }]; + + let arguments = (ins FlatSymbolRefAttr:$kernel, Variadic:$operands); + let results = (outs Variadic); + + let builders = [ + OpBuilder<(ins "DefnOp":$kernel, CArg<"ValueRange", "{}">:$operands), [{ + $_state.addOperands(operands); + $_state.addAttribute("kernel", SymbolRefAttr::get(kernel)); + $_state.addTypes(kernel.getFunctionType().getResults()); + }]>, + OpBuilder<(ins "SymbolRefAttr":$kernel, "TypeRange":$results, + CArg<"ValueRange", "{}">:$operands), [{ + $_state.addOperands(operands); + $_state.addAttribute("kernel", kernel); + $_state.addTypes(results); + }]>, + OpBuilder<(ins "StringAttr":$kernel, "TypeRange":$results, + CArg<"ValueRange", "{}">:$operands), [{ + build($_builder, $_state, SymbolRefAttr::get(kernel), results, operands); + }]>, + OpBuilder<(ins "StringRef":$kernel, "TypeRange":$results, + CArg<"ValueRange", "{}">:$operands), [{ + build($_builder, $_state, StringAttr::get($_builder.getContext(), kernel), + results, operands); + }]>]; + + let extraClassDeclaration = [{ + FunctionType getKernelType(); + + /// Get the argument operands to the launched kernel. + operand_range getArgOperands() { + return {arg_operand_begin(), arg_operand_end()}; + } + + MutableOperandRange getArgOperandsMutable() { + return getOperandsMutable(); + } + + operand_iterator arg_operand_begin() { return operand_begin(); } + operand_iterator arg_operand_end() { return operand_end(); } + + /// Return the kernel of this operation. + CallInterfaceCallable getCallableForCallee() { + return (*this)->getAttrOfType("kernel"); + } + + /// Set the kernel for this operation. + void setCalleeFromCallable(CallInterfaceCallable callee) { + (*this)->setAttr("kernel", callee.get()); + } + }]; + + let assemblyFormat = [{ + $kernel `(` $operands `)` attr-dict `:` functional-type($operands, results) + }]; +} + +def Kernel_YieldOp : Kernel_Op<"yield", [Pure, HasParent<"DefnOp">, + MemRefsNormalizable, ReturnLike, Terminator]> { + let summary = "Terminator for kernel.defn operation"; + let description = [{ + The `kernel.yield` operation terminates regions within kernel operations. + It optionally returns values from the kernel definition. + }]; + + let arguments = (ins Variadic:$operands); + + let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?"; + + let builders = [ + OpBuilder<(ins), [{ + build($_builder, $_state, std::nullopt); + }]> + ]; + + let hasVerifier = 1; +} + +#endif // KERNEL_OPS \ No newline at end of file diff --git a/include/polygeist/Passes/Passes.h b/include/polygeist/Passes/Passes.h index 92c5812e8c4c..f8aa2d2b089b 100644 --- a/include/polygeist/Passes/Passes.h +++ b/include/polygeist/Passes/Passes.h @@ -22,6 +22,7 @@ class PatternRewriter; class RewritePatternSet; class DominanceInfo; namespace polygeist { +std::unique_ptr createSelectFuncPass(); std::unique_ptr createParallelLICMPass(); std::unique_ptr createPolygeistMem2RegPass(); std::unique_ptr createLoopRestructurePass(); @@ -32,6 +33,15 @@ std::unique_ptr createOpenMPOptPass(); std::unique_ptr createCanonicalizeForPass(); std::unique_ptr createRaiseSCFToAffinePass(); std::unique_ptr createRaiseAffineToLinalgPass(); +std::unique_ptr createRaiseAffineToLinalgPipelinePass(); +std::unique_ptr createLinalgDebufferizePass(); +std::unique_ptr createLowerPolygeistSubmapPass(); +std::unique_ptr createLowerKernelLaunchPass(); +std::unique_ptr createWrapKernelLaunchPipelinePass(); +std::unique_ptr createLowerKernelLaunchToCuBLASPass(); +std::unique_ptr createLowerKernelLaunchToPVAPass(); +std::unique_ptr createRemoveIterArgsPass(); +std::unique_ptr createFoldSCFIfPass(); std::unique_ptr createCPUifyPass(StringRef method = ""); std::unique_ptr createBarrierRemovalContinuation(); std::unique_ptr detectReductionPass(); @@ -71,6 +81,9 @@ createGpuSerializeToHsacoPass(StringRef arch, StringRef features, int llvmOptLevel, int hsaOptLevel, std::string rocmPath, bool outputIntermediate); +std::unique_ptr createLinalgToKernelPass(); +std::unique_ptr createLinalgToKernelPass(const std::string& kernelLibraryPath); + void registerGpuSerializeToCubinPass(); void registerGpuSerializeToHsacoPass(); @@ -96,6 +109,11 @@ namespace omp { class OpenMPDialect; } // end namespace omp +namespace polygeist { +namespace kernel { +class KernelDialect; +} // end namespace kernel +} namespace polygeist { class PolygeistDialect; } // end namespace polygeist @@ -128,6 +146,18 @@ namespace linalg { class LinalgDialect; } +namespace tensor { +class TensorDialect; +} + +namespace bufferization { +class BufferizationDialect; +} + +namespace Tensor { +class TensorDialect; +} + namespace LLVM { class LLVMDialect; } diff --git a/include/polygeist/Passes/Passes.td b/include/polygeist/Passes/Passes.td index 5c17a9d6dc25..28d6df1a162c 100644 --- a/include/polygeist/Passes/Passes.td +++ b/include/polygeist/Passes/Passes.td @@ -4,6 +4,17 @@ include "mlir/Pass/PassBase.td" include "mlir/Rewrite/PassUtil.td" +def SelectFunc : Pass<"select-func"> { + let summary = "Run a pass pipeline on selected functions by name"; + let constructor = "mlir::polygeist::createSelectFuncPass()"; + let options = [ + Option<"pipeline", "pipeline", "std::string", /*default=*/"\"\"", + "The pass pipeline to run on filtered functions">, + ListOption<"funcNames", "func-name", "std::string", + "Function names to process (if empty, process all)"> + ]; +} + def AffineCFG : Pass<"affine-cfg"> { let summary = "Replace scf.if and similar with affine.if"; let constructor = "mlir::polygeist::replaceAffineCFGPass()"; @@ -151,12 +162,220 @@ def SCFRaiseToAffine : Pass<"raise-scf-to-affine"> { ]; } +def RemoveIterArgs : Pass<"remove-iter-args"> { + let summary = "Remove scf iter args"; + let constructor = "mlir::polygeist::createRemoveIterArgsPass()"; + let dependentDialects = [ + "affine::AffineDialect", + "scf::SCFDialect", + "memref::MemRefDialect", + ]; +} + +def FoldSCFIf : Pass<"fold-scf-if"> { + let summary = "Fold simple scf.if regions into arith.select"; + let constructor = "mlir::polygeist::createFoldSCFIfPass()"; + let dependentDialects = [ + "affine::AffineDialect", + "arith::ArithDialect", + "func::FuncDialect", + "memref::MemRefDialect", + "scf::SCFDialect", + ]; +} + +def LowerPolygeistSubmap : Pass<"lower-polygeist-submap"> { + let summary = "Lower polygeist.submap and polygeist.submapInverse to standard MLIR"; + let constructor = "mlir::polygeist::createLowerPolygeistSubmapPass()"; + let dependentDialects = [ + "arith::ArithDialect", + "linalg::LinalgDialect", + "memref::MemRefDialect", + "tensor::TensorDialect", + "polygeist::PolygeistDialect", + ]; +} + +def LowerKernelLaunch : Pass<"lower-kernel-launch", "::mlir::ModuleOp"> { + let summary = "Inline kernel.defn bodies in place of kernel.launch ops"; + let description = [{ + For each `kernel.launch @(operands)` op, finds the `kernel.defn + @` symbol (either in the same module or in a separately-loaded + library file, controlled by the `kernel-library-path` option), clones the + defn's body into the launch's parent block with block-arg-to-operand + substitution, and erases the launch. The defn body's terminating + `kernel.yield` is replaced by remapping the launch's result SSA to the + yielded value. + + Phase-2 of the kernel-match pipeline. Replaces the Phase-1 comment-marker + roundtrip lowering with a real canonical-implementation substitution, so + a wrongly-labeled kernel.launch produces different numerics from the + user's original code and fails e2e correctness diffs. + }]; + let constructor = "mlir::polygeist::createLowerKernelLaunchPass()"; + let options = [ + Option<"kernelLibraryPath", "kernel-library-path", "std::string", + /*default=*/"\"\"", + "Optional path to an MLIR file with `kernel.defn` entries. When " + "set, defns are loaded from the file and looked up by symbol " + "name. When unset, defns are expected in the input module."> + ]; + let dependentDialects = [ + "arith::ArithDialect", + "linalg::LinalgDialect", + "tensor::TensorDialect", + "math::MathDialect", + "polygeist::kernel::KernelDialect", + ]; +} + +def WrapKernelLaunchPipeline + : Pass<"wrap-kernel-launch-pipeline", "::mlir::ModuleOp"> { + let summary = + "Insert runtime pipeline begin/end calls around matched kernel dispatches"; + let description = [{ + Inserts calls to a runtime pipeline-scope ABI around functions that contain + matched kernel dispatches. This gives the runtime one explicit scope for a + sequence of lowered library calls, so backend implementations can keep + host mappings, temporary device allocations, streams, descriptors, and + future device-resident buffers alive across adjacent calls. + + By default the pass targets the cuBLAS/cuDNN CUDA runtime ABI: + + * `polygeist_cublas_pipeline_begin` + * `polygeist_cublas_pipeline_end` + + The pass recognizes both pre-lowering `kernel.launch` ops and post-lowering + runtime `func.call`s with Polygeist CUDA/cuBLAS/cuDNN shim prefixes. Running + it after `--lower-kernel-launch-to-cublas` is the safest execution path + because the pass then only scopes launches that actually lowered to CUDA + runtime calls. + }]; + let constructor = + "mlir::polygeist::createWrapKernelLaunchPipelinePass()"; + let dependentDialects = [ + "func::FuncDialect", + "polygeist::kernel::KernelDialect", + ]; + let options = [ + Option<"beginSymbol", "begin-symbol", "std::string", + /*default=*/"\"polygeist_cublas_pipeline_begin\"", + "Runtime function called at pipeline-scope entry.">, + Option<"endSymbol", "end-symbol", "std::string", + /*default=*/"\"polygeist_cublas_pipeline_end\"", + "Runtime function called at pipeline-scope exit."> + ]; +} + +def LowerKernelLaunchToCuBLAS + : Pass<"lower-kernel-launch-to-cublas", "::mlir::ModuleOp"> { + let summary = "Lower kernel.launch ops to runtime-shim func.calls (cuBLAS ABI)"; + let description = [{ + Phase-2 *ABI* lowering for the kernel-matcher pipeline. For each + recognised `kernel.launch @(operands)` op, replaces the launch + with a `func.call` to a runtime-shim ABI function declared in + `runtime/polygeist_cublas_rt.h`. Linking the shim object file (CPU + stub for validation, cuBLAS-backed for hardware) produces an executable. + + Distinct from `--lower-kernel-launch`, which inlines a canonical + `linalg.generic` body for the library symbol and stays in MLIR-land. + Use this pass instead when you want the matched op to dispatch to + an actual library implementation at runtime. + + Currently supports: + * `@cublasDgemm` → `polygeist_cublas_dgemm` + + Expected input: `kernel.launch` ops in TENSOR form (the matcher's + default output). The pass synthesises `bufferization.to_memref` / + `bufferization.to_tensor` ops around the call. + }]; + let constructor = "mlir::polygeist::createLowerKernelLaunchToCuBLASPass()"; + let dependentDialects = [ + "arith::ArithDialect", + "bufferization::BufferizationDialect", + "func::FuncDialect", + "LLVM::LLVMDialect", + "memref::MemRefDialect", + "tensor::TensorDialect", + "polygeist::kernel::KernelDialect", + ]; + let options = [ + Option<"deviceResidentCutensornet", "device-resident-cutensornet", + "bool", /*default=*/"false", + "Lower generic cuTensorNet contractions through the CUDA-device " + "pointer ABI. Fails if residual host tensor computation remains."> + ]; +} + +def LowerKernelLaunchToPVA + : Pass<"lower-kernel-launch-to-pva", "::mlir::ModuleOp"> { + let summary = "Lower kernel.launch ops to PVA Solutions runtime-shim func.calls"; + let description = [{ + Phase-2 ABI lowering for kernels routed to NVIDIA PVA Solutions + (libpva_operator on Jetson Orin's Programmable Vision Accelerator). + Currently handles `@cudnnConvolution2D_9tap_i{8,16}` → `func.call + @polygeist_pva_conv2d_3x3_i{8,16}`, the runtime-shim entry point for + PVA's single-channel integer Conv2d operator. + + Distinct from `--lower-kernel-launch-to-cublas` because PVA is a + separate backend with its own vendor library, host-side staging + contract (cuPVA-mapped memory, not cudaMemcpy), and hardware + semantics (Q-format quantized filter with REPLICATE border, not + raw integer multiply-accumulate). The two passes handle disjoint + launch symbol sets and can run in either order. + }]; + let constructor = "mlir::polygeist::createLowerKernelLaunchToPVAPass()"; + let dependentDialects = [ + "arith::ArithDialect", + "func::FuncDialect", + "LLVM::LLVMDialect", + "memref::MemRefDialect", + "polygeist::kernel::KernelDialect", + ]; +} + +def LinalgDebufferize : Pass<"linalg-debufferize"> { + let summary = "Raise affine to linalg"; + let constructor = "mlir::polygeist::createLinalgDebufferizePass()"; + let dependentDialects = [ + "affine::AffineDialect", + "linalg::LinalgDialect", + "bufferization::BufferizationDialect", + "memref::MemRefDialect", + "tensor::TensorDialect", + "polygeist::PolygeistDialect", + ]; + let options = [ + Option<"useRecursive", "use-recursive", "bool", /*default=*/"true", + "Use the region-recursive (v2) debufferization implementation. " + "Set to false to fall back to the legacy v1 pattern.">, + Option<"useMultiRoot", "use-multi-root", "bool", /*default=*/"false", + "Force the multi-root walker that processes ALL memref " + "args of a function jointly. Handles double-buffer stencils, trmm, " + "symm, etc. where a single linalg.generic touches operands from " + "multiple memref roots. Cross-root generics select it automatically " + "when use-recursive is enabled; this option forces it. Overrides " + "useRecursive when set."> + ]; +} + def AffineRaiseToLinalg : Pass<"raise-affine-to-linalg"> { let summary = "Raise affine to linalg"; let constructor = "mlir::polygeist::createRaiseAffineToLinalgPass()"; let dependentDialects = [ "affine::AffineDialect", "linalg::LinalgDialect", + "polygeist::PolygeistDialect", + ]; +} + +def AffineRaiseToLinalgPipeline : Pass<"raise-affine-to-linalg-pipeline"> { + let summary = "Pipeline: fold-scf-if, affine-parallelize, raise-affine-to-linalg"; + let constructor = "mlir::polygeist::createRaiseAffineToLinalgPipelinePass()"; + let dependentDialects = [ + "affine::AffineDialect", + "linalg::LinalgDialect", + "polygeist::PolygeistDialect", ]; } @@ -234,6 +453,54 @@ def RemoveTrivialUse : Pass<"trivialuse"> { let constructor = "mlir::polygeist::createRemoveTrivialUsePass()"; } +def LinalgToKernel : Pass<"linalg-to-kernel", "mlir::ModuleOp"> { + let summary = "Convert linalg.generic operations to kernel operations by matching with kernel.defn patterns"; + let description = [{ + This pass matches linalg.generic operations against patterns defined in + kernel.defn_collection operations and converts them to the corresponding + specialized kernel operations (e.g., kernel.gemm, kernel.batched_gemm). + + The pass performs semantic matching of linalg.generic operations by: + - Comparing indexing maps and iterator types + - Matching the operation structure within regions + - Checking input/output operand counts + + Example transformation: + ```mlir + // Input: linalg.generic performing matrix multiplication + linalg.generic { + indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d2)>, + affine_map<(d0, d1, d2) -> (d2, d1)>, + affine_map<(d0, d1, d2) -> (d0, d1)>], + iterator_types = ["parallel", "parallel", "reduction"] + } ins(%A, %B : tensor, tensor) + outs(%C : tensor) { + ^bb0(%a: f32, %b: f32, %c: f32): + %mul = arith.mulf %a, %b : f32 + %add = arith.addf %mul, %c : f32 + linalg.yield %add : f32 + } -> tensor + + // Output: Specialized kernel operation + %result = kernel.gemm %C, %A, %B, %alpha, %beta : tensor + ``` + }]; + let constructor = "mlir::polygeist::createLinalgToKernelPass()"; + let dependentDialects = [ + "linalg::LinalgDialect", + "polygeist::kernel::KernelDialect", + "tensor::TensorDialect", + "arith::ArithDialect", + "bufferization::BufferizationDialect", + ]; + let options = [ + Option<"kernelLibraryPath", "kernel-library-path", "std::string", + /*default=*/"\"\"", + "Path to external MLIR file containing kernel.defn_collection definitions. " + "If empty, looks for kernel.defn_collection in the input module."> + ]; +} + def ConvertPolygeistToLLVM : Pass<"convert-polygeist-to-llvm", "mlir::ModuleOp"> { let summary = "Convert scalar and vector operations from the Standard to the " "LLVM dialect"; diff --git a/include/polygeist/PolygeistOps.td b/include/polygeist/PolygeistOps.td index 159f6c144947..56130cb7e7b6 100644 --- a/include/polygeist/PolygeistOps.td +++ b/include/polygeist/PolygeistOps.td @@ -259,4 +259,113 @@ def TypeAlignOp : Polygeist_Op<"typeAlign", [Pure]> { let hasFolder = 1; let hasCanonicalizer = 1; } + +//Add check for result to be same as original memref/tensor type +def SubmapInverseOp : Polygeist_Op<"submapInverse", [Pure, ViewLikeOpInterface]> { + let summary = "Inverse submap operation for scatter-back semantics"; + let description = [{ + The `polygeist.submapInverse` operation scatters a modified view back into + the original base tensor/memref, preserving elements not covered by the view. + + This is the inverse operation to `polygeist.submap` and is essential for + debufferization of strided memory operations. + + Example: + ```mlir + // Scatter strided view back into base tensor + %base_updated = polygeist.submapInverse(%base, %modified_view, %stride, %size) + <{map = affine_map<(d0)[s0] -> (d0 * s0)>}> + : (tensor<100xf32>, tensor<50xf32>) -> tensor<100xf32> + + // Semantics: base_updated[i*stride] = modified_view[i] + // base_updated[other] = base[other] (preserved) + ``` + }]; + + let arguments = (ins + Arg, "the original base">:$base_original, + Arg, "the modified view">:$view_modified, + Variadic:$indices_and_sizes, + AffineMapAttr:$map + ); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]> : $result); + let hasFolder = 1; + let hasCanonicalizer = 1; + + let assemblyFormat = [{ + `(` $base_original `,` $view_modified (`,` $indices_and_sizes^)? `)` + attr-dict `:` functional-type(operands, results) + }]; + + let extraClassDeclaration = [{ + ::mlir::ValueRange getSymbols() { return getOperands().slice(2, getMap().getNumSymbols()); } + ::mlir::ValueRange getSizes() { + auto shapedType = ::llvm::cast<::mlir::ShapedType>(getType()); + return getOperands().slice(getMap().getNumSymbols()+2, shapedType.getShape().size()); + } + ::mlir::Value getViewSource() { return getBaseOriginal(); } + + // Type compatibility helpers + bool isMemRefVariant() { + return ::llvm::isa<::mlir::MemRefType>(getBaseOriginal().getType()); + } + bool isTensorVariant() { + return ::llvm::isa<::mlir::TensorType>(getBaseOriginal().getType()); + } + }]; +} + +def SubmapOp : Polygeist_Op<"submap", [Pure, ViewLikeOpInterface]> { + let summary = "Submap operation for strided view extraction"; + let description = [{ + The `polygeist.submap` operation creates a strided view of a tensor/memref + by applying an affine map to extract elements. This is used to represent + strided access patterns in a composable way. + + The operation works in both memref and tensor contexts, enabling + debufferization of strided operations. + + Example: + ```mlir + // Extract every other element (stride=2) + %view = polygeist.submap(%base, %stride, %size) + <{map = affine_map<(d0)[s0] -> (d0 * s0)>}> + : tensor<100xf32> -> tensor<50xf32> + + // Semantics: view[i] = base[i * stride] + ``` + }]; + + let arguments = (ins + Arg, "the base to view">:$base, + Variadic:$indices_and_sizes, + AffineMapAttr:$map + ); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]> : $result); + let hasFolder = 1; + let hasCanonicalizer = 1; + + let assemblyFormat = [{ + `(` $base (`,` $indices_and_sizes^)? `)` + attr-dict `:` functional-type(operands, results) + }]; + + let extraClassDeclaration = [{ + ::mlir::ValueRange getSymbols() { return getOperands().slice(1, getMap().getNumSymbols()); } + ::mlir::ValueRange getSizes() { + auto shapedType = ::llvm::cast<::mlir::ShapedType>(getType()); + return getOperands().slice(getMap().getNumSymbols()+1, shapedType.getShape().size()); + } + ::mlir::Value getViewSource() { return getBase(); } + + // Type compatibility helpers + bool isMemRefVariant() { + return ::llvm::isa<::mlir::MemRefType>(getBase().getType()); + } + bool isTensorVariant() { + return ::llvm::isa<::mlir::TensorType>(getBase().getType()); + } + }]; +} + #endif // POLYGEIST_OPS diff --git a/issues/array_pointer_return_memref_cast_min.c b/issues/array_pointer_return_memref_cast_min.c new file mode 100644 index 000000000000..4255432655f9 --- /dev/null +++ b/issues/array_pointer_return_memref_cast_min.c @@ -0,0 +1,10 @@ +typedef unsigned char array_pointer_return_memref_cast_guid[16]; +typedef array_pointer_return_memref_cast_guid + *array_pointer_return_memref_cast_guid_t; + +array_pointer_return_memref_cast_guid_t +array_pointer_return_memref_cast_min(void) { + static array_pointer_return_memref_cast_guid guid = { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; + return &guid; +} diff --git a/issues/aten_c_kernels/CUDA_LIBRARY_AUDIT.md b/issues/aten_c_kernels/CUDA_LIBRARY_AUDIT.md new file mode 100644 index 000000000000..75c42d99e64e --- /dev/null +++ b/issues/aten_c_kernels/CUDA_LIBRARY_AUDIT.md @@ -0,0 +1,68 @@ +# Exhaustive ATen CUDA-library audit + +This audit adjudicates every provenance-linked standalone ATen C fixture against public NVIDIA libraries. It separately records whether the current rewrite covers the complete function or only an initialization/copy stage. The machine-readable CSV is the authoritative per-kernel list. + +- Fixtures reviewed: 598 +- Complete current rewrite candidates: 40 +- Partial stage-only current matches: 101 +- No current launch: 457 + +## What exists in NVIDIA libraries + +- One fixed public call: 121 +- One configurable generic primitive: 139 +- Complete multi-node library graph/composition: 182 +- Only some stages have library primitives: 121 +- No direct tensor-library implementation: 35 + +A CUB or Thrust result means NVIDIA ships the generic device algorithm; it is not a stable host C ABI and would require a new template-backed runtime wrapper. A cuDNN graph result requires graph construction/lowering. Neither should be described as merely a missing Egglog pattern. + +## Compiler diagnosis + +- `ALREADY_FOUND`: 40 +- `BACKEND_AND_MATCHER_GAP`: 256 +- `COMPOSITION_REQUIRED_NOT_MATCHER_ONLY`: 52 +- `NO_LIBRARY_MATCH_EXPECTED`: 31 +- `PARTIAL_MATCH_ONLY_RESIDUAL_IR_REMAINS`: 101 +- `RAISING_BLOCKS_WHOLE_OP_RECOGNITION`: 118 + +Only the `MATCHER_COVERAGE_GAP` rows are clean, whole-operation cases for which a selected runtime-wrapper family is already present locally. The remaining positive library candidates need raising work, a new API backend, graph composition, or some combination. + +## Clean matcher-coverage candidates + + +## Candidate-library census + +- cuDNN: 205 +- CUB: 83 +- NPP: 45 +- Thrust: 43 +- cuDNN Resample: 42 +- none: 35 +- cuTENSOR: 33 +- cuBLAS: 32 +- cuSPARSE: 32 +- cuRAND: 29 +- CUDA Runtime: 14 +- cuSOLVER: 3 +- cuDNN CTC: 2 + +## Per-kernel results + +See [`cuda_library_audit.csv`](cuda_library_audit.csv). Every row includes the source provenance, current matcher scope, semantic family, candidate library/API, whole/partial availability, evidence URL, local backend status, and the precise compiler gap. The same fields are rendered on the paginated ATen Compiler Explorer pages. + +## Official capability sources + +- [cuBLAS](https://docs.nvidia.com/cuda/cublas/) +- [cuDNN](https://docs.nvidia.com/deeplearning/cudnn/latest/operations/operations.html) +- [cuDNN Resample](https://docs.nvidia.com/deeplearning/cudnn/latest/operations/Resampling.html) +- [cuDNN CTC](https://docs.nvidia.com/deeplearning/cudnn/backend/latest/api/cudnn-adv-library.html) +- [cuTENSOR](https://docs.nvidia.com/cuda/cutensor/latest/api/cutensor.html) +- [cuSPARSE](https://docs.nvidia.com/cuda/cusparse/) +- [cuSOLVER](https://docs.nvidia.com/cuda/cusolver/contents.html) +- [cuFFT](https://docs.nvidia.com/cuda/cufft/contents.html) +- [cuRAND](https://docs.nvidia.com/cuda/curand/index.html) +- [CUB](https://nvidia.github.io/cccl/cub/api/device.html) +- [Thrust](https://nvidia.github.io/cccl/thrust/api/) +- [NPP](https://docs.nvidia.com/cuda/npp/index.html) +- [CUDA Runtime](https://docs.nvidia.com/cuda/cuda-runtime-api/) diff --git a/issues/aten_c_kernels/README.md b/issues/aten_c_kernels/README.md new file mode 100644 index 000000000000..a8e87ecfff41 --- /dev/null +++ b/issues/aten_c_kernels/README.md @@ -0,0 +1,90 @@ +# ATen C kernel extraction corpus + +These are standalone C reference forms of high-value ATen operations. They +deliberately expose the numerical loop body using fixed, small shapes so the +experiment measures raising and GPU-library matching rather than PyTorch's C++ +dispatch, `TensorIterator`, registration, or object lifetime machinery. + +The corpus is pinned to PyTorch revision +`d7af122d81a49b1fa7a31ba52bd57c026f092646`. Each source names the corresponding +upstream `aten/src/ATen/native` implementation family. These files preserve the +numerical algorithm but replace ATen tensor/dispatch machinery with explicit C +arrays and dimensions; they are compiler fixtures, not replacements for ATen's +public ABI. + +The original ten-kernel batch covers established library routes: + +| File | ATen operation | Intended GPU route | +| --- | --- | --- | +| `aten_mm.c` | `aten::mm` | cuBLAS GEMM | +| `aten_addmm.c` | `aten::addmm` | cuBLAS GEMM with alpha/beta | +| `aten_mv.c` | `aten::mv` | cuBLAS GEMV | +| `aten_dot.c` | `aten::dot` | cuBLAS dot | +| `aten_add.c` | in-place `aten::add` | cuDNN add-tensor/custom CUDA | +| `aten_softmax.c` | `aten::_softmax` | cuDNN softmax | +| `aten_rms_norm.c` | `aten::rms_norm` | custom CUDA RMSNorm | +| `aten_conv2d.c` | `aten::conv2d` | cuDNN convolution | +| `aten_max_pool2d.c` | `aten::max_pool2d` | cuDNN pooling | +| `aten_batch_norm.c` | inference `aten::batch_norm` | cuDNN batch normalization | + +The second batch adds fifteen structurally distinct operations: + +- linear algebra: `bmm`, `outer` +- reductions: `sum`, `mean` +- activations: `relu`, tanh-approximation `gelu`, `silu` +- normalization/loss: `layer_norm`, mean-reduced `mse_loss` +- pooling: `avg_pool2d`, specialized `adaptive_avg_pool2d` +- data movement: materialized transpose, `im2col`, nearest-neighbor upsample +- vector algebra: batched three-component `cross` + +The third batch adds twenty-five more native numerical families: + +- activations: sigmoid, tanh, leaky-ReLU, ELU, softplus, hard-sigmoid, + hard-swish, hard-tanh, and clamp +- elementwise/loss/reduction: lerp, L1 loss, binary cross entropy, product, + and cumulative sum +- indexing/layout: embedding, channel shuffle, pixel shuffle, reflection + padding, and replication padding +- pooling/convolution/resampling: 3D average and adaptive-average pooling, + 1D and 3D convolution, 2D transposed convolution, and bilinear upsampling + +The fourth batch adds 30 fixed-f32 scalar specializations transcribed from +ATen's TensorIterator lambdas: unary arithmetic, binary arithmetic and +comparisons, loss elements, activation backward formulas, addcmul, addcdiv, +fill, linspace, AMP unscale, and scalar lerp. They are generated by the scalar +extraction generator under scripts/correctness; their pinned source function +provenance is recorded in generated_provenance.csv. + +The exhaustive corpus now contains 598 standalone specializations. It covers +all numerical bodies found in the pinned 224-translation-unit census; it is not +a claim that ATen exposes only 598 public operations. A translation unit and a +kernel are deliberately not equated: a registration wrapper may contain no +numerical body, while a TensorIterator file may contain dozens of independently +extractable scalar operators. + +The accounting is recorded at three levels: + +- `extraction_inventory.csv`: all 224 translation units. +- `operator_adjudication.csv`: all 834 named iterative bodies, including + provenance-linked extractions, covered helpers/composites, external-library + delegation, and non-numerical plumbing. +- `dispatch_kernel_inventory.csv`: all 358 concrete CPU dispatch + registrations; 357 have an extraction and one is the upstream null + `mean_stub` registration. + +Generated fixtures retain source/function provenance in the +`generated*_provenance.csv` manifests. They fix shapes, ranks, dtypes, and +optional modes to expose a static numerical loop nest. Random distributions +take random draws as explicit inputs, and half/bfloat16 arithmetic fixtures use +their widened f32 arithmetic core. These choices are visible in the standalone +C and do not claim to preserve PyTorch's public Tensor ABI. + +Run the complete corpus with: + +```sh +bash scripts/correctness/aten_c_kernel_sweep.sh +``` + +The default output is the checked-in `results/` directory. Each kernel keeps +`orig.mlir`, `raised.mlir`, `debuf.mlir`, `matched.mlir`, and diagnostics; flat +MLIR aliases are also generated for the IR explorer. diff --git a/issues/aten_c_kernels/RESULTS.md b/issues/aten_c_kernels/RESULTS.md new file mode 100644 index 000000000000..eac808f0a9c0 --- /dev/null +++ b/issues/aten_c_kernels/RESULTS.md @@ -0,0 +1,333 @@ +# Raising and matching results + +Date: 2026-07-21; matcher revalidated 2026-07-24 + +Pipeline: + +``` +cgeist --raise-scf-to-affine +polygeist-opt --remove-iter-args --affine-parallelize \ + --raise-affine-to-linalg-pipeline --lower-polygeist-submap +polygeist-opt --linalg-debufferize +kernel_match_rewrite.py +``` + +Results: + +| Kernel | Raise | Linalg ops | Residual loops | Existing GPU match | +| --- | --- | ---: | ---: | --- | +| `aten_add` | pass | 1 | 0 | `cudnnAddTensor_batched` | +| `aten_addmm` | pass | 2 | 0 | `cublasDgemm` | +| `aten_batch_norm` | pass | 1 | 0 | `cudnnBatchNormalizationForwardInference` | +| `aten_conv2d` | pass | 2 | 0 | `cudnnConvolutionFwd_batched` | +| `aten_dot` | pass | 1 | 0 | `cublasDdot` | +| `aten_max_pool2d` | pass | 2 | 0 | `cudnnMaxPoolFwd_batched` | +| `aten_mm` | pass | 2 | 0 | `memset_zero_2D` + `cublasDgemm_simple` | +| `aten_mv` | pass | 1 | 0 | `cublasDgemv` | +| `aten_rms_norm` | pass | 2 | 0 | `rmsnorm_f32_tensor` | +| `aten_softmax` | pass | 3 | 0 | `cudnnSoftmaxForward_tensor` | + +Summary: + +- C frontend success: 10/10 +- Raised to at least one Linalg operation: 10/10 +- Fully raised, with no residual affine/SCF loop: 10/10 +- Matched to an existing GPU-backed definition: 10/10 +- Total raised `linalg.generic` operations: 17 +- Total emitted `kernel.launch` operations: 11 + +The 2026-07-24 rerun used the current matcher/library definitions and produced +the same mappings. The added cuTensorNet separable 3D tensor-product definition +did not add an ATen match: none of these kernels has that definition's rank-6 +3D tensor-product signature. Their existing cuBLAS, cuDNN, and custom CUDA +routes remain the appropriate implementations. + +These results demonstrate that the numerical C loop bodies are within the +raising and matcher coverage. The poor whole-ATen result is therefore chiefly +an extraction/frontend problem around PyTorch's C++ abstraction layer, not a +failure of the Linalg raiser on these computations. + +This experiment stops at `kernel.launch`. The next validation stage is ABI +lowering, Jetson cross-compilation, correctness comparison, and execution on +the attached Orin GPU. + +## Second extraction batch + +Date: 2026-07-24 + +Fifteen additional C extractions were tested with the same pipeline: + +| Kernel | Linalg ops | Residual loops | Matcher result | +| --- | ---: | ---: | --- | +| `aten_adaptive_avg_pool2d` | 2 | 0 | none | +| `aten_avg_pool2d` | 2 | 0 | none | +| `aten_bmm` | 2 | 0 | none | +| `aten_cross` | 3 | 0 | none | +| `aten_gelu` | 1 | 0 | `gelu_tanh_f32_tensor` | +| `aten_im2col` | 1 | 0 | none (copy legality rejection) | +| `aten_layer_norm` | 3 | 0 | none | +| `aten_mean` | 1 | 0 | none | +| `aten_mse_loss` | 2 | 0 | none | +| `aten_outer` | 2 | 0 | `memset_zero_2D` only | +| `aten_relu` | 1 | 0 | none | +| `aten_silu` | 1 | 0 | none | +| `aten_sum` | 2 | 0 | `memset_zero_1D` only | +| `aten_transpose_copy` | 1 | 0 | none (copy legality rejection) | +| `aten_upsample_nearest2d` | 1 | 0 | none | + +Second-batch summary: + +- frontend and raising success: 15/15 +- completely raised with no residual affine/SCF loops: 15/15 +- additional `linalg.generic` operations: 25 +- kernels with at least one emitted matcher hit: 3/15 +- completely consumed by semantic matches: 1/15 +- executable, semantically valid whole-kernel match: 1/15 (`aten_gelu`) +- partial helper matches: 2/15 (`outer` and `sum` initialization) +- rejected unsafe copy candidates: 2/15 (`im2col` and transpose) + +The copy false-positives expose a legality gap. `im2col` is a window gather and +transpose has a permuted output indexing map, but the selected runtime shim is +a flat contiguous copy. Rank and scalar-body agreement are therefore +insufficient; copy matching must also prove compatible indexing maps and +contiguous view layout. + +Across the first two batches, all 25 extracted kernels raise completely, +producing 42 Linalg operations and zero residual loops. + +The copy false-positives described above have now been fixed. A copy match must +prove identical input/output indexing maps and shaped tensor types, and it +rejects a source produced by `polygeist.submap`. Consequently transpose and +im2col remain as correct residual Linalg instead of becoming invalid +`cudaCopy*` launches. + +## Third extraction batch + +Date: 2026-07-24 + +Twenty-five additional C extractions were tested with the same pipeline: + +| Kernel | Linalg ops | Residual loops | Matcher result | +| --- | ---: | ---: | --- | +| `aten_adaptive_avg_pool3d` | 2 | 0 | none | +| `aten_avg_pool3d` | 2 | 0 | none | +| `aten_binary_cross_entropy` | 0 | 1 | none | +| `aten_channel_shuffle` | 1 | 0 | none | +| `aten_clamp` | 1 | 0 | none | +| `aten_conv1d` | 2 | 0 | none | +| `aten_conv3d` | 2 | 0 | none | +| `aten_conv_transpose2d` | 2 | 0 | none | +| `aten_cumsum` | 1 | 0 | none | +| `aten_elu` | 1 | 0 | none | +| `aten_embedding` | 0 | 2 | none | +| `aten_hardsigmoid` | 1 | 0 | none | +| `aten_hardswish` | 1 | 0 | none | +| `aten_hardtanh` | 1 | 0 | none | +| `aten_l1_loss` | 1 | 0 | none | +| `aten_leaky_relu` | 1 | 0 | none | +| `aten_lerp` | 1 | 0 | none | +| `aten_pixel_shuffle` | 1 | 0 | none (layout-aware copy rejection) | +| `aten_prod` | 1 | 0 | none | +| `aten_reflection_pad2d` | 1 | 0 | none | +| `aten_replication_pad2d` | 1 | 0 | none | +| `aten_sigmoid` | 1 | 0 | none | +| `aten_softplus` | 0 | 1 | none | +| `aten_tanh` | 1 | 0 | none | +| `aten_upsample_bilinear2d` | 1 | 0 | none | + +The `--select-func` pass was fixed during this batch to preserve the transitive +symbol dependencies of a selected root function. This keeps declarations such +as `logf`, and helper functions called by the root, instead of producing +dangling symbol references. BCE and softplus therefore complete the pipeline, +but external math calls and control flow prevent their loops from becoming +Linalg. Embedding retains two loops because its data-dependent integer index is +an indirect gather. + +Third-batch summary: + +- frontend/pipeline success: 25/25 +- completely raised with no residual affine/SCF loops: 22/25 +- additional Linalg operations: 27 +- residual loops: 4 across BCE, embedding, and softplus +- new valid GPU-library matches: 0 + +## Complete 50-kernel corpus + +- frontend/pipeline success: 50/50 +- raised completely to Linalg: 47/50 +- total Linalg operations: 69 +- residual loops: 4 +- kernels with a valid matcher hit: 13/50 +- emitted launches: 14 +- valid whole-computation GPU routes: the original 10 plus GELU +- partial helper routes: output initialization in `outer` and `sum` +- unsafe copy rewrites remaining: 0 + +All sources and every intermediate/result are stored under this directory; +`results/summary.tsv` is the machine-readable aggregate. + +## 2026-08-07 executable revalidation + +A fresh 50-kernel sweep supersedes the older matcher counts above: + +- frontend/pipeline success: 50/50 +- completely raised: 47/50 +- 69 Linalg operations and 4 residual loops +- 13 launches in 13 kernels +- 11 valid whole-kernel routes, all passing large-shape Jetson correctness +- one partial route (`sum` initialization) +- one unsafe route (`pixel_shuffle` rank-6 copy), withheld from execution + +The eleven executable kernels are add, addmm, batch norm, conv2d, dot, GELU, +max-pool2d, mm, mv, RMSNorm, and softmax. Performance and exact problem sizes +are in `silicon_results/large_problem_comparison.csv`. Raised and resident +CUDA values are warm medians of process runs 2--4 on Jetson Orin `sm_87` in +MAXN mode. The resident baseline uses cuBLAS/cuDNN or a fused CUDA kernel with +device-resident operands; the raised path uses the current registered-host- +pointer ABI. + +## 2026-08-07 scalar extraction expansion + +Thirty additional fixed-f32 scalar specializations were generated from the +pinned ATen TensorIterator implementations and swept with the same pipeline. + +- frontend/pipeline success: 80/80 total +- completely raised: 77/80 total +- total Linalg operations: 99 +- residual loops: 4 (unchanged from the 50-kernel corpus) +- matcher launches: 13 in 13 kernels (unchanged) +- new scalar batch: 30/30 completely raised, 30 Linalg operations + +The lack of new matcher launches is expected: these are small pointwise +formulas and the current policy does not emit one library call per scalar +operation. Raising coverage increased; whole-kernel library coverage did not. + +The pinned 224-file source inventory currently classifies translation units as: + +- 37 with at least one standalone-C extraction +- 18 additional TensorIterator numerical-body candidates +- 123 additional explicit-loop candidates +- 15 dispatch-only wrappers +- 31 files with no local numerical body + +These are source-file counts, not operator counts or claims of complete +operator coverage within the 37 represented files. The authoritative +per-source accounting is extraction_inventory.csv. + +The CE ATen tracker is split into 20-row static pages. numerical.html is the +alphabetical ordering; numerical-correctness.html is correctness-first. Both +orderings contain all 80 kernels across four pages. + +## 2026-08-07 exhaustive 224-file completion + +This section supersedes the earlier incremental corpus totals. + +- Standalone C fixtures: 598 +- Pinned translation units accounted: 224/224 +- Named iterative bodies accounted: 834/834 (`NEEDS_PORT = 0`) +- Concrete CPU dispatch registrations: 358; 357 extracted and one upstream + null implementation (`mean_stub`) +- cgeist frontend success: 598/598 +- raise-pass success: 598/598 +- completed `linalg-debufferize` and matcher: 526/598 +- stopped at `linalg-debufferize`: 72/598 +- raised Linalg operations in successful pipelines: 434 +- residual affine/SCF loops in successful pipelines: 424 +- emitted library launches: 89 in 86 fixtures +- distinct matched implementation symbols: 18 +- launch element-type/ABI mismatches: 0 + +The 72 debufferization failures are retained as results, not removed from the +corpus. They are concentrated in nested reductions, arg-reductions, pooled +forward reductions, normalization statistics, selection/sorting, and +scatter-accumulation forms. Their C, frontend MLIR, raised MLIR, and diagnostic +logs remain available in the per-kernel result directories. + +During this completion pass, `RemoveIterArgs` was fixed to reject a +distributive rewrite when an allegedly invariant epilogue operand is defined +after the loop and therefore does not dominate the proposed in-loop use. The +alloca fallback now handles that case; the regression is covered by +`test/polygeist-opt/remove-iter-args.mlir`. Closed-form output indices also +remove artificial loop-carried counters from triangular, combinations, and +pair-distance extractions. Consequently the final corpus has no raise failure. + +Dot-product matching is now element-type gated. f32 reductions emit +`cublasSdot` and lower to `polygeist_cublas_dot_f32`; f64 reductions emit +`cublasDdot` and lower to `polygeist_cublas_dot_f64`. The exhaustive launch +audit found no remaining f32/f64 ABI mismatch. + +The CE ATen tracker now has 30 pages per ordering (20 rows per page): +`numerical.html` is alphabetical and `numerical-correctness.html` is +correctness-first. Both contain all 598 fixtures, with upstream implementation +and standalone-C links. + +Executable revalidation fixed the cuDNN definition set, batch-normalization +operand order, FP64 dot ABI, GEMV accumulator beta, rank-N wrapper generation, +and softmax slice-to-base SSA provenance. The resident benchmark source is +`benchmarks/aten_resident_cuda_baseline.cu`; raised correctness uses +`benchmarks/aten_raised_jetson_harness.c`. + +## 2026-08-07 exhaustive FULL/FULL silicon batch + +The 29 previously unmeasured kernels that were both fully raised and fully +consumed by library matches were run at large shapes on the Jetson Orin +(`sm_87`, MAXN, CUDA 12.6). All 29 raised paths and all 28 newly built resident +baselines passed the CPU-reference gate in four independent process runs. +`aten_gelu_cpu_tanh` reuses the already measured identical fused GELU baseline +at the same `N=8388608` shape. Reported values are medians of process runs 2--4; +raised calls use 5 inner iterations and resident calls use 20. + +The run exposed and fixed a real ABI defect: copy matches over rank-reduced or +pitched slices discarded their source/destination strides. The lowering now +calls `polygeist_cuda_copy_strided_2d_f32`; the CUDA runtime uses contiguous +`cudaMemcpyAsync` or pitched `cudaMemcpy2DAsync` as appropriate. This fixes +`aten_as_complex_cpu` and `aten_narrow_copy_dense_cpu` without packing copies. + +Those measurements diagnosed the compatibility ABI and have now been replaced +by the complete direct-buffer rerun below. + +## 2026-08-10 all 40 executable matches with direct device buffers + +The direct-buffer fix is now general rather than GEMV-specific. Library +lowering recovers the public ABI memref behind `bufferization.to_tensor`, +preserves `tensor.extract_slice` offsets/strides as a `memref.subview`, and +recognizes cast-mediated `launch -> tensor.insert_slice` write-backs. In-place +library destinations are rewired to the original allocation, eliminating the +otherwise redundant output snapshot and CPU copy. + +The same treatment now covers GEMV, GEMM, batched GEMM, dot, outer product, +copy/memset, cuDNN add, convolution, pooling, batch normalization, RMSNorm, and +the cuTensorNet contraction route. The CUDA runtime also detects device +pointers for memset, scalar dot output, and batch-normalization parameters. + +All 40 executable FULL-raise/FULL-match kernels pass in both modes: + +- mapped-host compatibility ABI: 40/40 pass +- true `cudaMalloc` raised ABI: 40/40 pass +- median device-resident raised/native ratio: 1.068x +- within 1.25x of native: 32/40 +- within 2x of native: 36/40 + +The remaining four gaps are not hidden tensor copies: both GELU fixtures lower +to a multi-operation cuDNN/cuBLAS graph instead of one fused CUDA kernel; +`aten_linear_combination_cpu` maps four pointwise terms to a low-K GEMV; and +RMSNorm's cuDNN backend plan still stages through plan-owned buffers. At +N=8,388,608, both raised and handwritten CUDA RMSNorm differ from the strictly +sequential float C reduction by `9.26375e-4`; a double-precision sum confirms +the GPU tree reduction is more accurate, so both harnesses use an explicitly +documented 2e-3 reduction-reassociation bound for this case. + +The earlier representative GEMV now measures 821.989 us raised with device +buffers versus 758.952 us resident cuBLAS (1.083x), rather than the obsolete +173x mapped/materialized result. Inputs are uploaded before timing and outputs +downloaded only for correctness. + +Authoritative data and reproduction artifacts: + +- `silicon_results/large_problem_comparison.csv` (now 40 executed ATen rows) +- `silicon_results/device_residency_comparison.csv` (mapped/device/native) +- `silicon_results/logs/full_match_large_run_{1,2,3,4}.log` +- `benchmarks/aten_full_match_raised_harness.c` +- `benchmarks/aten_full_match_resident_baseline.c` +- `scripts/correctness/aten_full_match_silicon.py` +- `scripts/correctness/collect_aten_device_residency.py` diff --git a/issues/aten_c_kernels/aten_abs.c b/issues/aten_c_kernels/aten_abs.c new file mode 100644 index 000000000000..01184c16c9b0 --- /dev/null +++ b/issues/aten_c_kernels/aten_abs.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_abs(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = x[i] < 0.0f ? -x[i] : x[i]; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_acos.c b/issues/aten_c_kernels/aten_acos.c new file mode 100644 index 000000000000..638c1cf18be1 --- /dev/null +++ b/issues/aten_c_kernels/aten_acos.c @@ -0,0 +1,14 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float cosf(float); +extern ATEN_CONST float acosf(float); +void aten_acos(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = acosf(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_acosh.c b/issues/aten_c_kernels/aten_acosh.c new file mode 100644 index 000000000000..6b68e8e480e9 --- /dev/null +++ b/issues/aten_c_kernels/aten_acosh.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float acoshf(float); +void aten_acosh(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = acoshf(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_adaptive_avg_pool2d.c b/issues/aten_c_kernels/aten_adaptive_avg_pool2d.c new file mode 100644 index 000000000000..c814dfbc60af --- /dev/null +++ b/issues/aten_c_kernels/aten_adaptive_avg_pool2d.c @@ -0,0 +1,28 @@ +/* aten::adaptive_avg_pool2d specialized to 8x8 -> 4x4. + * Upstream family: aten/src/ATen/native/AdaptiveAveragePooling.cpp. + */ +#define B 2 +#define C 4 +#define H 8 +#define W 8 +#define OH 4 +#define OW 4 + +void aten_adaptive_avg_pool2d(float input[B][C][H][W], + float output[B][C][OH][OW]) { +#pragma scop + for (int b = 0; b < B; ++b) + for (int c = 0; c < C; ++c) + for (int oh = 0; oh < OH; ++oh) + for (int ow = 0; ow < OW; ++ow) + output[b][c][oh][ow] = 0.0f; + for (int b = 0; b < B; ++b) + for (int c = 0; c < C; ++c) + for (int oh = 0; oh < OH; ++oh) + for (int ow = 0; ow < OW; ++ow) + for (int kh = 0; kh < 2; ++kh) + for (int kw = 0; kw < 2; ++kw) + output[b][c][oh][ow] += + 0.25f * input[b][c][2 * oh + kh][2 * ow + kw]; +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_adaptive_avg_pool2d_backward_cpu.c b/issues/aten_c_kernels/aten_adaptive_avg_pool2d_backward_cpu.c new file mode 100644 index 000000000000..15c7a0fc3893 --- /dev/null +++ b/issues/aten_c_kernels/aten_adaptive_avg_pool2d_backward_cpu.c @@ -0,0 +1,40 @@ +/* Fixed-shape ATen adaptive_avg_pool2d_backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 6 +#endif +#ifndef O0 +#define O0 3 +#endif +#ifndef I1 +#define I1 7 +#endif +#ifndef O1 +#define O1 3 +#endif +void aten_adaptive_avg_pool2d_backward_cpu(float grad_output[B*C*O0*O1], float grad_input[B*C*I0*I1]){ + for(int p=0;pv){v=x[c][i];b=i;}out[c][o]=v;index[c][o]=b;}} diff --git a/issues/aten_c_kernels/aten_adaptive_max_pool2d_backward_cpu.c b/issues/aten_c_kernels/aten_adaptive_max_pool2d_backward_cpu.c new file mode 100644 index 000000000000..ecf0ea06174f --- /dev/null +++ b/issues/aten_c_kernels/aten_adaptive_max_pool2d_backward_cpu.c @@ -0,0 +1,36 @@ +/* Fixed-shape ATen adaptive_max_pool2d_backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 6 +#endif +#ifndef O0 +#define O0 3 +#endif +#ifndef I1 +#define I1 7 +#endif +#ifndef O1 +#define O1 3 +#endif +void aten_adaptive_max_pool2d_backward_cpu(float grad_output[B*C*O0*O1], int indices[B*C*O0*O1], float grad_input[B*C*I0*I1]){ + for(int p=0;pvalue){value=input[((((((n)*C+c))*I0+i0))*I1+i1)];best=((i0)*I1+i1);} + } + } + output[((((((n)*C+c))*O0+o0))*O1+o1)]=value;indices[((((((n)*C+c))*O0+o0))*O1+o1)]=best; + } + } + } +} +} diff --git a/issues/aten_c_kernels/aten_adaptive_max_pool3d_backward_cpu.c b/issues/aten_c_kernels/aten_adaptive_max_pool3d_backward_cpu.c new file mode 100644 index 000000000000..872f57b3cf77 --- /dev/null +++ b/issues/aten_c_kernels/aten_adaptive_max_pool3d_backward_cpu.c @@ -0,0 +1,46 @@ +/* Fixed-shape ATen adaptive_max_pool3d_backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 6 +#endif +#ifndef O0 +#define O0 3 +#endif +#ifndef I1 +#define I1 7 +#endif +#ifndef O1 +#define O1 3 +#endif +#ifndef I2 +#define I2 8 +#endif +#ifndef O2 +#define O2 3 +#endif +void aten_adaptive_max_pool3d_backward_cpu(float grad_output[B*C*O0*O1*O2], int indices[B*C*O0*O1*O2], float grad_input[B*C*I0*I1*I2]){ + for(int p=0;pvalue){value=input[((((((((n)*C+c))*I0+i0))*I1+i1))*I2+i2)];best=((((i0)*I1+i1))*I2+i2);} + } + } + } + output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)]=value;indices[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)]=best; + } + } + } + } +} +} diff --git a/issues/aten_c_kernels/aten_adaptive_max_pool3d_legacy_backward_cpu.c b/issues/aten_c_kernels/aten_adaptive_max_pool3d_legacy_backward_cpu.c new file mode 100644 index 000000000000..5e1474649f43 --- /dev/null +++ b/issues/aten_c_kernels/aten_adaptive_max_pool3d_legacy_backward_cpu.c @@ -0,0 +1,8 @@ +#define C 2 +#define ID 8 +#define IH 9 +#define IW 10 +#define OD 3 +#define OH 4 +#define OW 5 +void aten_adaptive_max_pool3d_legacy_backward_cpu(float g[C][OD][OH][OW],int idx[C][OD][OH][OW],float out[C][ID][IH][IW]){for(int p=0;pv){v=x[c][iz][iy][ix];b=(iz*IH+iy)*IW+ix;}out[c][z][y][q]=v;idx[c][z][y][q]=b;}} diff --git a/issues/aten_c_kernels/aten_add.c b/issues/aten_c_kernels/aten_add.c new file mode 100644 index 000000000000..ae7147c03b47 --- /dev/null +++ b/issues/aten_c_kernels/aten_add.c @@ -0,0 +1,23 @@ +/* In-place aten::add on an NCHW tensor: out += src. */ +#ifndef B +#define B 2 +#endif +#ifndef C +#define C 8 +#endif +#ifndef H +#define H 16 +#endif +#ifndef W +#define W 16 +#endif + +void aten_add(float src[B][C][H][W], float out[B][C][H][W]) { +#pragma scop + for (int b = 0; b < B; ++b) + for (int c = 0; c < C; ++c) + for (int h = 0; h < H; ++h) + for (int w = 0; w < W; ++w) + out[b][c][h][w] += src[b][c][h][w]; +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_add_clamp.c b/issues/aten_c_kernels/aten_add_clamp.c new file mode 100644 index 000000000000..efcd016cf3c6 --- /dev/null +++ b/issues/aten_c_kernels/aten_add_clamp.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_add_clamp(float a[N], float b[N], float alpha, float minval, float maxval, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + float v = a[i] + alpha * b[i]; + out[i] = v < minval ? minval : (v > maxval ? maxval : v); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_addcdiv.c b/issues/aten_c_kernels/aten_addcdiv.c new file mode 100644 index 000000000000..89f5cc9a8e7b --- /dev/null +++ b/issues/aten_c_kernels/aten_addcdiv.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_addcdiv(float self[N], float x[N], float y[N], float value, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = self[i] + value * x[i] / y[i]; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_addcmul.c b/issues/aten_c_kernels/aten_addcmul.c new file mode 100644 index 000000000000..d17646b72d7e --- /dev/null +++ b/issues/aten_c_kernels/aten_addcmul.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_addcmul(float self[N], float x[N], float y[N], float value, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = self[i] + value * x[i] * y[i]; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_addmm.c b/issues/aten_c_kernels/aten_addmm.c new file mode 100644 index 000000000000..d584861056c2 --- /dev/null +++ b/issues/aten_c_kernels/aten_addmm.c @@ -0,0 +1,23 @@ +/* aten::addmm: C = beta*C + alpha*(A@B). */ +#ifndef M +#define M 16 +#endif +#ifndef N +#define N 16 +#endif +#ifndef K +#define K 16 +#endif + +void aten_addmm(double A[M][K], double B[K][N], double C[M][N], + double beta, double alpha) { +#pragma scop + for (int i = 0; i < M; ++i) + for (int j = 0; j < N; ++j) + C[i][j] *= beta; + for (int i = 0; i < M; ++i) + for (int j = 0; j < N; ++j) + for (int k = 0; k < K; ++k) + C[i][j] += alpha * A[i][k] * B[k][j]; +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_addr_elementwise.c b/issues/aten_c_kernels/aten_addr_elementwise.c new file mode 100644 index 000000000000..b454245c5597 --- /dev/null +++ b/issues/aten_c_kernels/aten_addr_elementwise.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_addr_elementwise(float self[N], float x[N], float y[N], float beta, float alpha, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = beta == 0.0f ? alpha * x[i] * y[i] : beta * self[i] + alpha * x[i] * y[i]; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_airy_ai.c b/issues/aten_c_kernels/aten_airy_ai.c new file mode 100644 index 000000000000..535efb4b2d05 --- /dev/null +++ b/issues/aten_c_kernels/aten_airy_ai.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float calc_airy_aif(float); +void aten_airy_ai(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = calc_airy_aif(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_allany_dims_cpu.c b/issues/aten_c_kernels/aten_allany_dims_cpu.c new file mode 100644 index 000000000000..75a41a005fe6 --- /dev/null +++ b/issues/aten_c_kernels/aten_allany_dims_cpu.c @@ -0,0 +1,3 @@ +#define R 32 +#define C 64 +void aten_allany_dims_cpu(int x[R][C],int all,int out[R]){for(int r=0;r hi ? x[i] : hi; + } + out_min[0] = lo; out_max[0] = hi; +} diff --git a/issues/aten_c_kernels/aten_aminmax_cpu.c b/issues/aten_c_kernels/aten_aminmax_cpu.c new file mode 100644 index 000000000000..5b6483508f8e --- /dev/null +++ b/issues/aten_c_kernels/aten_aminmax_cpu.c @@ -0,0 +1,13 @@ +#ifndef N +#define N 4096 +#endif +void aten_aminmax_cpu(float x[N], float out_min[1], float out_max[1]) { +#pragma scop + float lo = x[0], hi = x[0]; + for (int i = 1; i < N; ++i) { + lo = x[i] < lo ? x[i] : lo; + hi = x[i] > hi ? x[i] : hi; + } + out_min[0] = lo; out_max[0] = hi; +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_amp_update_scale_cpu.c b/issues/aten_c_kernels/aten_amp_update_scale_cpu.c new file mode 100644 index 000000000000..59f80b0c0153 --- /dev/null +++ b/issues/aten_c_kernels/aten_amp_update_scale_cpu.c @@ -0,0 +1,9 @@ +void aten_amp_update_scale_cpu(float scale[1], int tracker[1], + float found_inf[1], float growth, float backoff, int interval) { + if (found_inf[0] != 0.0f) { scale[0] *= backoff; tracker[0] = 0; } + else { + int successful = tracker[0] + 1; + if (successful == interval) { scale[0] *= growth; tracker[0] = 0; } + else tracker[0] = successful; + } +} diff --git a/issues/aten_c_kernels/aten_and_reduce_cpu.c b/issues/aten_c_kernels/aten_and_reduce_cpu.c new file mode 100644 index 000000000000..d5bfd553aecc --- /dev/null +++ b/issues/aten_c_kernels/aten_and_reduce_cpu.c @@ -0,0 +1,9 @@ +#ifndef R +#define R 32 +#endif +#ifndef K +#define K 64 +#endif +void aten_and_reduce_cpu(int x[R][K], int out[R]) { + for(int r=0;rv){v=x[r][k];best=k;}out[r]=best;} +} diff --git a/issues/aten_c_kernels/aten_argmin_cpu.c b/issues/aten_c_kernels/aten_argmin_cpu.c new file mode 100644 index 000000000000..1840edd282b8 --- /dev/null +++ b/issues/aten_c_kernels/aten_argmin_cpu.c @@ -0,0 +1,9 @@ +#ifndef R +#define R 32 +#endif +#ifndef K +#define K 64 +#endif +void aten_argmin_cpu(float x[R][K], int out[R]) { + for(int r=0;r hi ? hi : x[i]); +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_clamp_cpu.c b/issues/aten_c_kernels/aten_clamp_cpu.c new file mode 100644 index 000000000000..dba8c23041d2 --- /dev/null +++ b/issues/aten_c_kernels/aten_clamp_cpu.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_clamp_cpu(float x[N], float minval[N], float maxval[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = x[i] < minval[i] ? minval[i] : (x[i] > maxval[i] ? maxval[i] : x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_clamp_max_scalar_cpu.c b/issues/aten_c_kernels/aten_clamp_max_scalar_cpu.c new file mode 100644 index 000000000000..25361f8736e4 --- /dev/null +++ b/issues/aten_c_kernels/aten_clamp_max_scalar_cpu.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_clamp_max_scalar_cpu(float x[N], float maxval, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = x[i] > maxval ? maxval : x[i]; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_clamp_min_scalar_cpu.c b/issues/aten_c_kernels/aten_clamp_min_scalar_cpu.c new file mode 100644 index 000000000000..7813a044c76d --- /dev/null +++ b/issues/aten_c_kernels/aten_clamp_min_scalar_cpu.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_clamp_min_scalar_cpu(float x[N], float minval, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = x[i] < minval ? minval : x[i]; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_clamp_scalar_cpu.c b/issues/aten_c_kernels/aten_clamp_scalar_cpu.c new file mode 100644 index 000000000000..184ecd58a97b --- /dev/null +++ b/issues/aten_c_kernels/aten_clamp_scalar_cpu.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_clamp_scalar_cpu(float x[N], float minval, float maxval, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = x[i] < minval ? minval : (x[i] > maxval ? maxval : x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_coalesce_sparse_cpu.c b/issues/aten_c_kernels/aten_coalesce_sparse_cpu.c new file mode 100644 index 000000000000..b59cc157ea22 --- /dev/null +++ b/issues/aten_c_kernels/aten_coalesce_sparse_cpu.c @@ -0,0 +1,2 @@ +#define N 512 +void aten_coalesce_sparse_cpu(int idx[N],float val[N],int out_idx[N],float out_val[N],int count[1]){int p=0;for(int i=0;i=0;--t)for(int s=0;s0)a+=alpha[b][t-1][s-1];if(s>1&&lab!=blank&&lab!=((s-2)&1?labels[b][(s-2)/2]:blank))a+=alpha[b][t-1][s-2];alpha[b][t][s]=a*expf(logp[t][b][lab]);}float z=alpha[b][T-1][S-1]+alpha[b][T-1][S-2];loss[b]=-logf(z);}} diff --git a/issues/aten_c_kernels/aten_cummax_cummin_cpu.c b/issues/aten_c_kernels/aten_cummax_cummin_cpu.c new file mode 100644 index 000000000000..d66a124fb172 --- /dev/null +++ b/issues/aten_c_kernels/aten_cummax_cummin_cpu.c @@ -0,0 +1,3 @@ +#define R 16 +#define N 64 +void aten_cummax_cummin_cpu(float x[R][N],int is_max,float out[R][N],int index[R][N]){for(int r=0;r=v)||(!is_max&&x[r][i]<=v)){v=x[r][i];q=i;}out[r][i]=v;index[r][i]=q;}}} diff --git a/issues/aten_c_kernels/aten_cumprod_backward_cpu.c b/issues/aten_c_kernels/aten_cumprod_backward_cpu.c new file mode 100644 index 000000000000..73b64fde28e1 --- /dev/null +++ b/issues/aten_c_kernels/aten_cumprod_backward_cpu.c @@ -0,0 +1,2 @@ +#define N 128 +void aten_cumprod_backward_cpu(float x[N],float prod[N],float grad[N],float out[N]){for(int i=0;i=0&&iy=0&&ix>(4*(k&1)))&15;s+=a[m][k]*((float)q-zero[n])*scale[n];}out[m][n]=s;}} diff --git a/issues/aten_c_kernels/aten_dyn_quant_pack_4bit_weight_cpu.c b/issues/aten_c_kernels/aten_dyn_quant_pack_4bit_weight_cpu.c new file mode 100644 index 000000000000..1e8e74100716 --- /dev/null +++ b/issues/aten_c_kernels/aten_dyn_quant_pack_4bit_weight_cpu.c @@ -0,0 +1,4 @@ +#define M 32 +#define K 64 +#define N 48 +void aten_dyn_quant_pack_4bit_weight_cpu(float weight[N][K],unsigned char packed[N][K/2],float scale[N],float zero[N]){for(int n=0;nhi?weight[n][k]:hi;}scale[n]=(hi-lo)/15.0f;zero[n]=-lo/scale[n];for(int k=0;k15)q0=15;if(q1<0)q1=0;if(q1>15)q1=15;packed[n][k/2]=(unsigned char)(q0|(q1<<4));}}} diff --git a/issues/aten_c_kernels/aten_eig_complex_vectors_cpu.c b/issues/aten_c_kernels/aten_eig_complex_vectors_cpu.c new file mode 100644 index 000000000000..51788023cf64 --- /dev/null +++ b/issues/aten_c_kernels/aten_eig_complex_vectors_cpu.c @@ -0,0 +1,2 @@ +#define N 64 +void aten_eig_complex_vectors_cpu(float real[N][N],float imag[N],float out_re[N][N],float out_im[N][N]){for(int i=0;i 0.0f ? x[i] : alpha * (expf(x[i]) - 1.0f)); +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_elu_backward.c b/issues/aten_c_kernels/aten_elu_backward.c new file mode 100644 index 000000000000..a40877cd1b5d --- /dev/null +++ b/issues/aten_c_kernels/aten_elu_backward.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_elu_backward(float grad[N], float output[N], float alpha, float scale, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = output[i] <= 0.0f ? grad[i] * (output[i] + alpha) * scale : grad[i] * scale; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_embedding.c b/issues/aten_c_kernels/aten_embedding.c new file mode 100644 index 000000000000..c2612db83896 --- /dev/null +++ b/issues/aten_c_kernels/aten_embedding.c @@ -0,0 +1,12 @@ +/* aten::embedding indexed gather. Upstream: ATen/native/Embedding.cpp. */ +#define VOCAB 64 +#define DIM 16 +#define TOKENS 8 +void aten_embedding(float weight[VOCAB][DIM], int indices[TOKENS], + float output[TOKENS][DIM]) { +#pragma scop + for (int i = 0; i < TOKENS; ++i) + for (int d = 0; d < DIM; ++d) + output[i][d] = weight[indices[i]][d]; +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_embedding_bag_backward_max_cpu.c b/issues/aten_c_kernels/aten_embedding_bag_backward_max_cpu.c new file mode 100644 index 000000000000..ca2a5e109b7e --- /dev/null +++ b/issues/aten_c_kernels/aten_embedding_bag_backward_max_cpu.c @@ -0,0 +1,4 @@ +#define B 32 +#define D 64 +#define E 1024 +void aten_embedding_bag_backward_max_cpu(float grad[B][D],int maxidx[B][D],float out[E][D]){for(int p=0;pv)v=table[index[b][l]][d];out[b][d]=v;}} diff --git a/issues/aten_c_kernels/aten_embedding_bag_per_sample_backward_cpu.c b/issues/aten_c_kernels/aten_embedding_bag_per_sample_backward_cpu.c new file mode 100644 index 000000000000..a597f13eb48e --- /dev/null +++ b/issues/aten_c_kernels/aten_embedding_bag_per_sample_backward_cpu.c @@ -0,0 +1,5 @@ +#define B 32 +#define L 16 +#define E 1024 +#define D 64 +void aten_embedding_bag_per_sample_backward_cpu(float grad[B][D],float table[E][D],int index[B][L],float out[B][L]){for(int b=0;bm?p[j]:m;}for(int j=0;jm?score[j]:m;}float z=0;for(int j=0;jIH-KH)sy=IH-KH;if(sx>IW-KW)sx=IW-KW;float v=-3.402823466e38f;int best=0;for(int ky=0;kyv){v=x[b][c][sy+ky][sx+kx];best=(sy+ky)*IW+sx+kx;}out[b][c][oy][ox]=v;index[b][c][oy][ox]=best;}} diff --git a/issues/aten_c_kernels/aten_fractional_max_pool3d_backward_cpu.c b/issues/aten_c_kernels/aten_fractional_max_pool3d_backward_cpu.c new file mode 100644 index 000000000000..f2671631b8b0 --- /dev/null +++ b/issues/aten_c_kernels/aten_fractional_max_pool3d_backward_cpu.c @@ -0,0 +1,12 @@ +#define B 1 +#define C 2 +#define ID 8 +#define IH 9 +#define IW 10 +#define OD 3 +#define OH 4 +#define OW 5 +#define KD 2 +#define KH 3 +#define KW 3 +void aten_fractional_max_pool3d_backward_cpu(float grad[B][C][OD][OH][OW],int index[B][C][OD][OH][OW],float out[B][C][ID][IH][IW]){for(int p=0;pID-KD)sz=ID-KD;if(sy>IH-KH)sy=IH-KH;if(sx>IW-KW)sx=IW-KW;float v=-3.402823466e38f;int best=0;for(int kz=0;kzv){v=x[b][c][sz+kz][sy+ky][sx+kx];best=((sz+kz)*IH+sy+ky)*IW+sx+kx;}out[b][c][oz][oy][ox]=v;index[b][c][oz][oy][ox]=best;}} diff --git a/issues/aten_c_kernels/aten_fused_adagrad_cpu.c b/issues/aten_c_kernels/aten_fused_adagrad_cpu.c new file mode 100644 index 000000000000..89b07ca39135 --- /dev/null +++ b/issues/aten_c_kernels/aten_fused_adagrad_cpu.c @@ -0,0 +1,17 @@ +#ifndef N +#define N 4096 +#endif +extern float sqrtf(float); +void aten_fused_adagrad_cpu(float param[N], float grad[N], float state_sum[N], + float lr, float lr_decay, float weight_decay, float eps, float step, + float grad_scale, int maximize) { + float clr = lr / (1.0f + (step - 1.0f) * lr_decay); + for (int i = 0; i < N; ++i) { + float g = grad[i] / grad_scale; + grad[i] = g; + if (maximize) g = -g; + if (weight_decay != 0.0f) g += param[i] * weight_decay; + state_sum[i] += g * g; + param[i] -= clr * g / (sqrtf(state_sum[i]) + eps); + } +} diff --git a/issues/aten_c_kernels/aten_fused_adam_cpu.c b/issues/aten_c_kernels/aten_fused_adam_cpu.c new file mode 100644 index 000000000000..948c1dc9676a --- /dev/null +++ b/issues/aten_c_kernels/aten_fused_adam_cpu.c @@ -0,0 +1,23 @@ +#ifndef N +#define N 4096 +#endif +extern float sqrtf(float); +void aten_fused_adam_cpu(float param[N], float grad[N], float exp_avg[N], + float exp_avg_sq[N], float max_exp_avg_sq[N], float lr, float beta1, + float beta2, float bias1, float bias2_sqrt, float weight_decay, float eps, + float grad_scale, int maximize, int amsgrad) { + float step_size = lr / bias1; + for (int i = 0; i < N; ++i) { + float g = grad[i] / grad_scale; grad[i] = g; + if (maximize) g = -g; + if (weight_decay != 0.0f) g += param[i] * weight_decay; + exp_avg[i] += (1.0f - beta1) * (g - exp_avg[i]); + exp_avg_sq[i] = beta2 * exp_avg_sq[i] + (1.0f - beta2) * g * g; + float variance = exp_avg_sq[i]; + if (amsgrad) { + max_exp_avg_sq[i] = max_exp_avg_sq[i] > variance ? max_exp_avg_sq[i] : variance; + variance = max_exp_avg_sq[i]; + } + param[i] -= step_size * exp_avg[i] / (sqrtf(variance) / bias2_sqrt + eps); + } +} diff --git a/issues/aten_c_kernels/aten_fused_sgd_cpu.c b/issues/aten_c_kernels/aten_fused_sgd_cpu.c new file mode 100644 index 000000000000..4b3260cc9609 --- /dev/null +++ b/issues/aten_c_kernels/aten_fused_sgd_cpu.c @@ -0,0 +1,18 @@ +#ifndef N +#define N 4096 +#endif +void aten_fused_sgd_cpu(float param[N], float grad[N], float momentum_buffer[N], + float lr, float momentum, float dampening, float weight_decay, + float grad_scale, int maximize, int first_step, int nesterov) { + for (int i = 0; i < N; ++i) { + float g = grad[i] / grad_scale; grad[i] = g; + if (maximize) g = -g; + if (weight_decay != 0.0f) g += param[i] * weight_decay; + if (momentum != 0.0f) { + momentum_buffer[i] = first_step ? g : + momentum_buffer[i] * momentum + g * (1.0f - dampening); + g = nesterov ? g + momentum * momentum_buffer[i] : momentum_buffer[i]; + } + param[i] -= lr * g; + } +} diff --git a/issues/aten_c_kernels/aten_gamma_transform_cpu.c b/issues/aten_c_kernels/aten_gamma_transform_cpu.c new file mode 100644 index 000000000000..a338b3566d5c --- /dev/null +++ b/issues/aten_c_kernels/aten_gamma_transform_cpu.c @@ -0,0 +1,2 @@ +#define N 1024 +extern float sqrtf(float);void aten_gamma_transform_cpu(float alpha[N],float normal[N],float uniform[N],float out[N]){for(int i=0;i= b[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_gelu.c b/issues/aten_c_kernels/aten_gelu.c new file mode 100644 index 000000000000..72ec932652ce --- /dev/null +++ b/issues/aten_c_kernels/aten_gelu.c @@ -0,0 +1,17 @@ +/* aten::gelu tanh approximation. + * Upstream family: aten/src/ATen/native/Activation.cpp. + */ +#ifndef N +#define N 256 +#endif +extern float tanhf(float); + +void aten_gelu(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + float v = x[i]; + float inner = 0.7978845608f * (v + 0.044715f * v * v * v); + out[i] = 0.5f * v * (1.0f + tanhf(inner)); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_gelu_backward_cpu_exact.c b/issues/aten_c_kernels/aten_gelu_backward_cpu_exact.c new file mode 100644 index 000000000000..096cffbed8d2 --- /dev/null +++ b/issues/aten_c_kernels/aten_gelu_backward_cpu_exact.c @@ -0,0 +1,16 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float erff(float); +extern ATEN_CONST float expf(float); +void aten_gelu_backward_cpu_exact(float grad[N], float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + float cdf = 0.5f * (1.0f + erff(x[i] * 0.7071067811865475f)); + float pdf = 0.3989422804014327f * expf(-0.5f * x[i] * x[i]); + out[i] = grad[i] * (cdf + x[i] * pdf); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_gelu_backward_cpu_tanh.c b/issues/aten_c_kernels/aten_gelu_backward_cpu_tanh.c new file mode 100644 index 000000000000..5987434a11d4 --- /dev/null +++ b/issues/aten_c_kernels/aten_gelu_backward_cpu_tanh.c @@ -0,0 +1,17 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float tanhf(float); +void aten_gelu_backward_cpu_tanh(float grad[N], float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + float x2 = x[i] * x[i]; + float inner = 0.7978845608028654f * (x[i] + 0.044715f * x[i] * x2); + float t = tanhf(inner); + float deriv = 0.5f * (1.0f + t) + 0.5f * x[i] * (1.0f - t * t) * 0.7978845608028654f * (1.0f + 3.0f * 0.044715f * x2); + out[i] = grad[i] * deriv; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_gelu_cpu_exact.c b/issues/aten_c_kernels/aten_gelu_cpu_exact.c new file mode 100644 index 000000000000..3dfeceecafda --- /dev/null +++ b/issues/aten_c_kernels/aten_gelu_cpu_exact.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float erff(float); +void aten_gelu_cpu_exact(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = 0.5f * x[i] * (1.0f + erff(x[i] * 0.7071067811865475f)); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_gelu_cpu_tanh.c b/issues/aten_c_kernels/aten_gelu_cpu_tanh.c new file mode 100644 index 000000000000..00bcb954db2f --- /dev/null +++ b/issues/aten_c_kernels/aten_gelu_cpu_tanh.c @@ -0,0 +1,14 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float tanhf(float); +void aten_gelu_cpu_tanh(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + float inner = 0.7978845608028654f * (x[i] + 0.044715f * x[i] * x[i] * x[i]); + out[i] = 0.5f * x[i] * (1.0f + tanhf(inner)); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_gemm_notrans_cpu.c b/issues/aten_c_kernels/aten_gemm_notrans_cpu.c new file mode 100644 index 000000000000..32a4575996fd --- /dev/null +++ b/issues/aten_c_kernels/aten_gemm_notrans_cpu.c @@ -0,0 +1,4 @@ +#define M 32 +#define N 48 +#define K 40 +void aten_gemm_notrans_cpu(float a[M][K],float b[K][N],float c[M][N]){for(int i=0;i=0&&x0=0&&y0=0&&x1=0&&y0=0&&x0=0&&y1=0&&x1=0&&y1=0&&x0=0&&y0=0&&x1=0&&y0=0&&x0=0&&y1=0&&x1=0&&y1=0?input[index[i]]:0.0f;} diff --git a/issues/aten_c_kernels/aten_grid_sampler_2d_quantized_cpu.c b/issues/aten_c_kernels/aten_grid_sampler_2d_quantized_cpu.c new file mode 100644 index 000000000000..8927883fa548 --- /dev/null +++ b/issues/aten_c_kernels/aten_grid_sampler_2d_quantized_cpu.c @@ -0,0 +1,2 @@ +#define N 256 +void aten_grid_sampler_2d_quantized_cpu(unsigned char input[N],float scale,int zero,unsigned char out[N]){for(int i=0;i255)q=255;out[i]=(unsigned char)q;}} diff --git a/issues/aten_c_kernels/aten_grid_sampler_3d_backward_cpu.c b/issues/aten_c_kernels/aten_grid_sampler_3d_backward_cpu.c new file mode 100644 index 000000000000..b16cffde7f6b --- /dev/null +++ b/issues/aten_c_kernels/aten_grid_sampler_3d_backward_cpu.c @@ -0,0 +1,9 @@ +#define B 1 +#define C 2 +#define ID 6 +#define IH 7 +#define IW 8 +#define OD 4 +#define OH 5 +#define OW 6 +void aten_grid_sampler_3d_backward_cpu(float grad[B][C][OD][OH][OW],float grid[B][OD][OH][OW][3],float out[B][C][ID][IH][IW]){for(int p=0;p=0&&iz=0&&iy=0&&ix=0&&iz=0&&iy=0&&ix b[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_hardshrink.c b/issues/aten_c_kernels/aten_hardshrink.c new file mode 100644 index 000000000000..0685fa5bf16a --- /dev/null +++ b/issues/aten_c_kernels/aten_hardshrink.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_hardshrink(float self[N], float lambd, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = self[i] >= -lambd && self[i] <= lambd ? 0.0f : self[i]; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_hardsigmoid.c b/issues/aten_c_kernels/aten_hardsigmoid.c new file mode 100644 index 000000000000..678ff1be778e --- /dev/null +++ b/issues/aten_c_kernels/aten_hardsigmoid.c @@ -0,0 +1,10 @@ +/* aten::hardsigmoid. Upstream: ATen/native/cpu/Activation.cpp. */ +#define N 256 +void aten_hardsigmoid(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + float v = (x[i] + 3.0f) / 6.0f; + out[i] = v < 0.0f ? 0.0f : (v > 1.0f ? 1.0f : v); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_hardsigmoid_backward.c b/issues/aten_c_kernels/aten_hardsigmoid_backward.c new file mode 100644 index 000000000000..b8cff07d73b2 --- /dev/null +++ b/issues/aten_c_kernels/aten_hardsigmoid_backward.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_hardsigmoid_backward(float grad[N], float self[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = self[i] > -3.0f && self[i] < 3.0f ? grad[i] * (1.0f / 6.0f) : 0.0f; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_hardswish.c b/issues/aten_c_kernels/aten_hardswish.c new file mode 100644 index 000000000000..79889e455b8f --- /dev/null +++ b/issues/aten_c_kernels/aten_hardswish.c @@ -0,0 +1,11 @@ +/* aten::hardswish. Upstream: ATen/native/cpu/Activation.cpp. */ +#define N 256 +void aten_hardswish(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + float v = x[i] + 3.0f; + v = v < 0.0f ? 0.0f : (v > 6.0f ? 6.0f : v); + out[i] = x[i] * v / 6.0f; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_hardswish_backward.c b/issues/aten_c_kernels/aten_hardswish_backward.c new file mode 100644 index 000000000000..802f42d9abac --- /dev/null +++ b/issues/aten_c_kernels/aten_hardswish_backward.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_hardswish_backward(float grad[N], float self[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = self[i] <= -3.0f ? 0.0f : (self[i] < 3.0f ? grad[i] * (self[i] / 3.0f + 0.5f) : grad[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_hardtanh.c b/issues/aten_c_kernels/aten_hardtanh.c new file mode 100644 index 000000000000..af2921dcf599 --- /dev/null +++ b/issues/aten_c_kernels/aten_hardtanh.c @@ -0,0 +1,8 @@ +/* aten::hardtanh. Upstream: ATen/native/cpu/Activation.cpp. */ +#define N 256 +void aten_hardtanh(float x[N], float out[N], float lo, float hi) { +#pragma scop + for (int i = 0; i < N; ++i) + out[i] = x[i] < lo ? lo : (x[i] > hi ? hi : x[i]); +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_hardtanh_backward.c b/issues/aten_c_kernels/aten_hardtanh_backward.c new file mode 100644 index 000000000000..7e82c6126d32 --- /dev/null +++ b/issues/aten_c_kernels/aten_hardtanh_backward.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_hardtanh_backward(float grad[N], float self[N], float minval, float maxval, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = self[i] <= minval || self[i] >= maxval ? 0.0f : grad[i]; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_heaviside.c b/issues/aten_c_kernels/aten_heaviside.c new file mode 100644 index 000000000000..77880a5eec87 --- /dev/null +++ b/issues/aten_c_kernels/aten_heaviside.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_heaviside(float a[N], float b[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = a[i] == 0.0f ? b[i] : (float)(a[i] > 0.0f); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_hermite_polynomial_h.c b/issues/aten_c_kernels/aten_hermite_polynomial_h.c new file mode 100644 index 000000000000..fe54eaed9d03 --- /dev/null +++ b/issues/aten_c_kernels/aten_hermite_polynomial_h.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float calc_hermite_hf(float, float); +void aten_hermite_polynomial_h(float a[N], float b[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = calc_hermite_hf(a[i], b[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_hermite_polynomial_he.c b/issues/aten_c_kernels/aten_hermite_polynomial_he.c new file mode 100644 index 000000000000..80a1d677f16e --- /dev/null +++ b/issues/aten_c_kernels/aten_hermite_polynomial_he.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float calc_hermite_hef(float, float); +void aten_hermite_polynomial_he(float a[N], float b[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = calc_hermite_hef(a[i], b[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_histogram_select_outer_bin_edges_cpu.c b/issues/aten_c_kernels/aten_histogram_select_outer_bin_edges_cpu.c new file mode 100644 index 000000000000..1b9bff0ae6f8 --- /dev/null +++ b/issues/aten_c_kernels/aten_histogram_select_outer_bin_edges_cpu.c @@ -0,0 +1,10 @@ +#ifndef N +#define N 4096 +#endif +#ifndef B0 +#define B0 16 +#endif +#ifndef B1 +#define B1 12 +#endif +void aten_histogram_select_outer_bin_edges_cpu(float x[N],float out_min[1],float out_max[1]){float lo=x[0],hi=x[0];for(int i=1;ihi?x[i]:hi;}out_min[0]=lo;out_max[0]=hi;} diff --git a/issues/aten_c_kernels/aten_histogramdd_cpu.c b/issues/aten_c_kernels/aten_histogramdd_cpu.c new file mode 100644 index 000000000000..78d2dfd27ca2 --- /dev/null +++ b/issues/aten_c_kernels/aten_histogramdd_cpu.c @@ -0,0 +1,10 @@ +#ifndef N +#define N 4096 +#endif +#ifndef B0 +#define B0 16 +#endif +#ifndef B1 +#define B1 12 +#endif +void aten_histogramdd_cpu(float x[N][2],float weight[N],float lo0,float hi0,float lo1,float hi1,float out[B0][B1]){for(int a=0;a=0&&a=0&&b=0&&bin[i]m?x[r][k]:m;float s=0;for(int k=0;k delta ? norm * delta : norm * z); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_huber_elementwise.c b/issues/aten_c_kernels/aten_huber_elementwise.c new file mode 100644 index 000000000000..0a72c76b81bc --- /dev/null +++ b/issues/aten_c_kernels/aten_huber_elementwise.c @@ -0,0 +1,14 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_huber_elementwise(float a[N], float b[N], float delta, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + float z = a[i] - b[i]; + float az = z < 0.0f ? -z : z; + out[i] = az < delta ? 0.5f * z * z : delta * (az - 0.5f * delta); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_hypot.c b/issues/aten_c_kernels/aten_hypot.c new file mode 100644 index 000000000000..b53f2de67084 --- /dev/null +++ b/issues/aten_c_kernels/aten_hypot.c @@ -0,0 +1,14 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float hypotf(float, float); +extern ATEN_CONST float hypotf(float, float); +void aten_hypot(float a[N], float b[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = hypotf(a[i], b[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_i0.c b/issues/aten_c_kernels/aten_i0.c new file mode 100644 index 000000000000..d04364ff522d --- /dev/null +++ b/issues/aten_c_kernels/aten_i0.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float calc_i0f(float); +void aten_i0(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = calc_i0f(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_i0e.c b/issues/aten_c_kernels/aten_i0e.c new file mode 100644 index 000000000000..530814d448b6 --- /dev/null +++ b/issues/aten_c_kernels/aten_i0e.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float calc_i0ef(float); +void aten_i0e(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = calc_i0ef(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_i1.c b/issues/aten_c_kernels/aten_i1.c new file mode 100644 index 000000000000..df54c27f9eea --- /dev/null +++ b/issues/aten_c_kernels/aten_i1.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float calc_i1f(float); +void aten_i1(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = calc_i1f(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_i1e.c b/issues/aten_c_kernels/aten_i1e.c new file mode 100644 index 000000000000..b3f66feb4010 --- /dev/null +++ b/issues/aten_c_kernels/aten_i1e.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float calc_i1ef(float); +void aten_i1e(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = calc_i1ef(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_ifftshift_cpu.c b/issues/aten_c_kernels/aten_ifftshift_cpu.c new file mode 100644 index 000000000000..9d88d1c2a916 --- /dev/null +++ b/issues/aten_c_kernels/aten_ifftshift_cpu.c @@ -0,0 +1,2 @@ +#define N 255 +void aten_ifftshift_cpu(float x[N],float out[N]){for(int i=0;i>(4*(k&1)))&15;s+=a[m][k]*((float)q-zero[n])*scale[n];}out[m][n]=s;}} diff --git a/issues/aten_c_kernels/aten_int8pack_mm_cpu.c b/issues/aten_c_kernels/aten_int8pack_mm_cpu.c new file mode 100644 index 000000000000..6b26a8a50868 --- /dev/null +++ b/issues/aten_c_kernels/aten_int8pack_mm_cpu.c @@ -0,0 +1,4 @@ +#define M 32 +#define K 64 +#define N 48 +void aten_int8pack_mm_cpu(float a[M][K],signed char weight[N][K],float scale[N],float out[M][N]){for(int m=0;m max_finite); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_jagged_to_padded_cpu.c b/issues/aten_c_kernels/aten_jagged_to_padded_cpu.c new file mode 100644 index 000000000000..4d8ef67d6475 --- /dev/null +++ b/issues/aten_c_kernels/aten_jagged_to_padded_cpu.c @@ -0,0 +1,3 @@ +#define B 8 +#define N 64 +void aten_jagged_to_padded_cpu(float x[B*N],int off[B+1],float out[B][N]){for(int b=0;bma)ma=x;if(y>mb)mb=y;}out[0]=ma*mb;} diff --git a/issues/aten_c_kernels/aten_kaiser_window.c b/issues/aten_c_kernels/aten_kaiser_window.c new file mode 100644 index 000000000000..c786b8590eb6 --- /dev/null +++ b/issues/aten_c_kernels/aten_kaiser_window.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float calc_kaiserf(float, float); +void aten_kaiser_window(float x[N], float beta, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = calc_kaiserf(x[i], beta); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_kron_impl_cpu.c b/issues/aten_c_kernels/aten_kron_impl_cpu.c new file mode 100644 index 000000000000..ba0c382fab43 --- /dev/null +++ b/issues/aten_c_kernels/aten_kron_impl_cpu.c @@ -0,0 +1,5 @@ +#define A 16 +#define B 12 +#define C 8 +#define D 10 +void aten_kron_impl_cpu(float x[A][B],float y[C][D],float out[A*C][B*D]){for(int a=0;a= 0.0f ? x[i] : slope * x[i]; +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_legendre_polynomial_p.c b/issues/aten_c_kernels/aten_legendre_polynomial_p.c new file mode 100644 index 000000000000..05acd1883cd4 --- /dev/null +++ b/issues/aten_c_kernels/aten_legendre_polynomial_p.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float calc_legendre_pf(float, float); +void aten_legendre_polynomial_p(float a[N], float b[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = calc_legendre_pf(a[i], b[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_lerp.c b/issues/aten_c_kernels/aten_lerp.c new file mode 100644 index 000000000000..d0f8bcdcc22b --- /dev/null +++ b/issues/aten_c_kernels/aten_lerp.c @@ -0,0 +1,7 @@ +/* aten::lerp.Tensor. Upstream: ATen/native/cpu/LerpKernel.cpp. */ +#define N 256 +void aten_lerp(float a[N], float b[N], float weight[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) out[i] = a[i] + weight[i] * (b[i] - a[i]); +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_lerp_scalar.c b/issues/aten_c_kernels/aten_lerp_scalar.c new file mode 100644 index 000000000000..9107b05563e2 --- /dev/null +++ b/issues/aten_c_kernels/aten_lerp_scalar.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_lerp_scalar(float self[N], float end[N], float weight, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = self[i] + weight * (end[i] - self[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_lerp_scalar_cpu.c b/issues/aten_c_kernels/aten_lerp_scalar_cpu.c new file mode 100644 index 000000000000..068ee91b57c7 --- /dev/null +++ b/issues/aten_c_kernels/aten_lerp_scalar_cpu.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_lerp_scalar_cpu(float self[N], float end[N], float weight, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = self[i] + weight * (end[i] - self[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_lerp_tensor_cpu.c b/issues/aten_c_kernels/aten_lerp_tensor_cpu.c new file mode 100644 index 000000000000..ed8ea9bb596b --- /dev/null +++ b/issues/aten_c_kernels/aten_lerp_tensor_cpu.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_lerp_tensor_cpu(float self[N], float end[N], float weight[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = self[i] + weight[i] * (end[i] - self[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_lgamma.c b/issues/aten_c_kernels/aten_lgamma.c new file mode 100644 index 000000000000..7b526fe89635 --- /dev/null +++ b/issues/aten_c_kernels/aten_lgamma.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float lgammaf(float); +void aten_lgamma(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = lgammaf(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_linalg_powsum_cpu.c b/issues/aten_c_kernels/aten_linalg_powsum_cpu.c new file mode 100644 index 000000000000..72546a5b4837 --- /dev/null +++ b/issues/aten_c_kernels/aten_linalg_powsum_cpu.c @@ -0,0 +1,3 @@ +#define R 32 +#define C 64 +extern float powf(float,float);void aten_linalg_powsum_cpu(float x[R][C],float p,float out[R]){for(int r=0;r b[i] ? a[i] : b[i]; + float d = a[i] - b[i]; + if (d < 0.0f) d = -d; + out[i] = m + log1pf(expf(-d)); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_logaddexp2.c b/issues/aten_c_kernels/aten_logaddexp2.c new file mode 100644 index 000000000000..61ee11258cc4 --- /dev/null +++ b/issues/aten_c_kernels/aten_logaddexp2.c @@ -0,0 +1,17 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float exp2f(float); +extern ATEN_CONST float log1pf(float); +void aten_logaddexp2(float a[N], float b[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + float m = a[i] > b[i] ? a[i] : b[i]; + float d = a[i] - b[i]; + if (d < 0.0f) d = -d; + out[i] = m + log1pf(exp2f(-d)) * 1.4426950408889634f; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_logcumsumexp_cpu.c b/issues/aten_c_kernels/aten_logcumsumexp_cpu.c new file mode 100644 index 000000000000..b83b47ad62c5 --- /dev/null +++ b/issues/aten_c_kernels/aten_logcumsumexp_cpu.c @@ -0,0 +1,10 @@ +#ifndef R +#define R 32 +#endif +#ifndef K +#define K 64 +#endif +extern float expf(float); extern float log1pf(float); +void aten_logcumsumexp_cpu(float x[R][K], float out[R][K]) { + for(int r=0;rx[r][k]?v:x[r][k];float d=v-x[r][k];if(d<0)d=-d;v=m+log1pf(expf(-d));out[r][k]=v;}} +} diff --git a/issues/aten_c_kernels/aten_logical_and.c b/issues/aten_c_kernels/aten_logical_and.c new file mode 100644 index 000000000000..2bee75c5d37e --- /dev/null +++ b/issues/aten_c_kernels/aten_logical_and.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_logical_and(float a[N], float b[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = (float)((a[i] != 0.0f) && (b[i] != 0.0f)); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_logical_not_f32.c b/issues/aten_c_kernels/aten_logical_not_f32.c new file mode 100644 index 000000000000..af66b6792713 --- /dev/null +++ b/issues/aten_c_kernels/aten_logical_not_f32.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_logical_not_f32(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = (float)(!x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_logical_or.c b/issues/aten_c_kernels/aten_logical_or.c new file mode 100644 index 000000000000..576d7035a4b7 --- /dev/null +++ b/issues/aten_c_kernels/aten_logical_or.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_logical_or(float a[N], float b[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = (float)((a[i] != 0.0f) || (b[i] != 0.0f)); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_logical_xor.c b/issues/aten_c_kernels/aten_logical_xor.c new file mode 100644 index 000000000000..9cdd9904d4b1 --- /dev/null +++ b/issues/aten_c_kernels/aten_logical_xor.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_logical_xor(float a[N], float b[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = (float)((a[i] != 0.0f) != (b[i] != 0.0f)); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_logit.c b/issues/aten_c_kernels/aten_logit.c new file mode 100644 index 000000000000..27cb51051ec9 --- /dev/null +++ b/issues/aten_c_kernels/aten_logit.c @@ -0,0 +1,14 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float logf(float); +void aten_logit(float x[N], float eps, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + float z = x[i] < eps ? eps : (x[i] > 1.0f - eps ? 1.0f - eps : x[i]); + out[i] = logf(z / (1.0f - z)); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_logit_backward.c b/issues/aten_c_kernels/aten_logit_backward.c new file mode 100644 index 000000000000..52badcd8921f --- /dev/null +++ b/issues/aten_c_kernels/aten_logit_backward.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_logit_backward(float grad[N], float self[N], float eps, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = self[i] < eps || self[i] > 1.0f - eps ? 0.0f : grad[i] / (self[i] * (1.0f - self[i])); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_logspace_cpu.c b/issues/aten_c_kernels/aten_logspace_cpu.c new file mode 100644 index 000000000000..07200d9c2780 --- /dev/null +++ b/issues/aten_c_kernels/aten_logspace_cpu.c @@ -0,0 +1,2 @@ +#define N 256 +extern float powf(float,float);void aten_logspace_cpu(float start,float end,float base,float out[N]){for(int i=0;i value ? x[i] : value; + out[0] = value; +} diff --git a/issues/aten_c_kernels/aten_max_pool1d_cpu.c b/issues/aten_c_kernels/aten_max_pool1d_cpu.c new file mode 100644 index 000000000000..f0b01d244aab --- /dev/null +++ b/issues/aten_c_kernels/aten_max_pool1d_cpu.c @@ -0,0 +1,26 @@ +/* Fixed-shape ATen max_pool1d. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 6 +#endif +#define O0 (I0/2) +void aten_max_pool1d_cpu(float input[B*C*I0], float output[B*C*O0], int indices[B*C*O0]){ + for(int n=0;nvalue){value=input[((((n)*C+c))*I0+i0)];best=i0;} + } + output[((((n)*C+c))*O0+o0)]=value;indices[((((n)*C+c))*O0+o0)]=best; + } + } +} +} diff --git a/issues/aten_c_kernels/aten_max_pool2d.c b/issues/aten_c_kernels/aten_max_pool2d.c new file mode 100644 index 000000000000..87ef7adcddfa --- /dev/null +++ b/issues/aten_c_kernels/aten_max_pool2d.c @@ -0,0 +1,43 @@ +/* aten::max_pool2d, NCHW, 2x2 window and stride 2. */ +#ifndef B +#define B 2 +#endif +#ifndef C +#define C 8 +#endif +#ifndef H +#define H 16 +#endif +#ifndef W +#define W 16 +#endif +#ifndef K +#define K 2 +#endif +#ifndef S +#define S 2 +#endif +#define OH ((H - K) / S + 1) +#define OW ((W - K) / S + 1) +#define NEG_INF (-3.402823466e38f) + +void aten_max_pool2d(float input[B][C][H][W], + float output[B][C][OH][OW]) { +#pragma scop + for (int b = 0; b < B; ++b) + for (int c = 0; c < C; ++c) + for (int oh = 0; oh < OH; ++oh) + for (int ow = 0; ow < OW; ++ow) + output[b][c][oh][ow] = NEG_INF; + for (int b = 0; b < B; ++b) + for (int c = 0; c < C; ++c) + for (int oh = 0; oh < OH; ++oh) + for (int ow = 0; ow < OW; ++ow) + for (int kh = 0; kh < K; ++kh) + for (int kw = 0; kw < K; ++kw) { + float value = input[b][c][oh * S + kh][ow * S + kw]; + float current = output[b][c][oh][ow]; + output[b][c][oh][ow] = value > current ? value : current; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_max_pool3d_backward_cpu.c b/issues/aten_c_kernels/aten_max_pool3d_backward_cpu.c new file mode 100644 index 000000000000..70c564b79add --- /dev/null +++ b/issues/aten_c_kernels/aten_max_pool3d_backward_cpu.c @@ -0,0 +1,40 @@ +/* Fixed-shape ATen max_pool3d_backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 6 +#endif +#define O0 (I0/2) +#ifndef I1 +#define I1 7 +#endif +#define O1 (I1/2) +#ifndef I2 +#define I2 8 +#endif +#define O2 (I2/2) +void aten_max_pool3d_backward_cpu(float grad_output[B*C*O0*O1*O2], int indices[B*C*O0*O1*O2], float grad_input[B*C*I0*I1*I2]){ + for(int p=0;pvalue){value=input[((((((((n)*C+c))*I0+i0))*I1+i1))*I2+i2)];best=((((i0)*I1+i1))*I2+i2);} + } + } + } + output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)]=value;indices[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)]=best; + } + } + } + } +} +} diff --git a/issues/aten_c_kernels/aten_max_reduce_cpu.c b/issues/aten_c_kernels/aten_max_reduce_cpu.c new file mode 100644 index 000000000000..62c900e8a6c1 --- /dev/null +++ b/issues/aten_c_kernels/aten_max_reduce_cpu.c @@ -0,0 +1,10 @@ +#ifndef N +#define N 4096 +#endif +void aten_max_reduce_cpu(float x[N], float out[1]) { +#pragma scop + float value = x[0]; + for (int i = 1; i < N; ++i) value = x[i] > value ? x[i] : value; + out[0] = value; +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_max_unpool2d_cpu.c b/issues/aten_c_kernels/aten_max_unpool2d_cpu.c new file mode 100644 index 000000000000..cd1478b0559c --- /dev/null +++ b/issues/aten_c_kernels/aten_max_unpool2d_cpu.c @@ -0,0 +1,4 @@ +#define C 2 +#define N 64 +#define O 256 +void aten_max_unpool2d_cpu(float x[C][N],int index[C][N],float out[C][O]){for(int p=0;pv?x[r][k]:v;out[r]=v;} +} diff --git a/issues/aten_c_kernels/aten_maximum.c b/issues/aten_c_kernels/aten_maximum.c new file mode 100644 index 000000000000..31a529dd04c0 --- /dev/null +++ b/issues/aten_c_kernels/aten_maximum.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_maximum(float a[N], float b[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = a[i] > b[i] ? a[i] : b[i]; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_mean.c b/issues/aten_c_kernels/aten_mean.c new file mode 100644 index 000000000000..1afe22d1b5df --- /dev/null +++ b/issues/aten_c_kernels/aten_mean.c @@ -0,0 +1,13 @@ +/* aten::mean over one contiguous tensor. + * Upstream family: aten/src/ATen/native/ReduceOps.cpp. + */ +#define N 256 + +void aten_mean(double x[N], double out[1]) { + double sum = 0.0; +#pragma scop + for (int i = 0; i < N; ++i) + sum += x[i]; + out[0] = sum / (double)N; +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_median_indices_cpu.c b/issues/aten_c_kernels/aten_median_indices_cpu.c new file mode 100644 index 000000000000..b9e3014bad4b --- /dev/null +++ b/issues/aten_c_kernels/aten_median_indices_cpu.c @@ -0,0 +1,3 @@ +#define R 16 +#define N 63 +void aten_median_indices_cpu(float x[R][N],float out[R],int idx[R]){for(int r=0;r= 0 && work[j] > v) { + work[j + 1] = work[j]; indices[j + 1] = indices[j]; --j; + } + work[j + 1] = v; indices[j + 1] = idx; + } + int best_count = 1, count = 1, best = 0; + for (int i = 1; i < N; ++i) { + if (work[i] == work[i - 1]) ++count; else count = 1; + if (count > best_count) { best_count = count; best = i; } + } + out[0] = work[best]; out_index[0] = indices[best]; +} diff --git a/issues/aten_c_kernels/aten_modified_bessel_i0.c b/issues/aten_c_kernels/aten_modified_bessel_i0.c new file mode 100644 index 000000000000..b4c30a5920b1 --- /dev/null +++ b/issues/aten_c_kernels/aten_modified_bessel_i0.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float modified_bessel_i0_forwardf(float); +void aten_modified_bessel_i0(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = modified_bessel_i0_forwardf(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_modified_bessel_i1.c b/issues/aten_c_kernels/aten_modified_bessel_i1.c new file mode 100644 index 000000000000..739e0abf6d9a --- /dev/null +++ b/issues/aten_c_kernels/aten_modified_bessel_i1.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float modified_bessel_i1_forwardf(float); +void aten_modified_bessel_i1(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = modified_bessel_i1_forwardf(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_modified_bessel_k0.c b/issues/aten_c_kernels/aten_modified_bessel_k0.c new file mode 100644 index 000000000000..aa6e7f521246 --- /dev/null +++ b/issues/aten_c_kernels/aten_modified_bessel_k0.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float modified_bessel_k0_forwardf(float); +void aten_modified_bessel_k0(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = modified_bessel_k0_forwardf(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_modified_bessel_k1.c b/issues/aten_c_kernels/aten_modified_bessel_k1.c new file mode 100644 index 000000000000..2a989d0976fe --- /dev/null +++ b/issues/aten_c_kernels/aten_modified_bessel_k1.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float modified_bessel_k1_forwardf(float); +void aten_modified_bessel_k1(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = modified_bessel_k1_forwardf(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_mse_backward.c b/issues/aten_c_kernels/aten_mse_backward.c new file mode 100644 index 000000000000..e92bc5f989ea --- /dev/null +++ b/issues/aten_c_kernels/aten_mse_backward.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_mse_backward(float input[N], float target[N], float value, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = value * (input[i] - target[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_mse_elementwise.c b/issues/aten_c_kernels/aten_mse_elementwise.c new file mode 100644 index 000000000000..3fecc4732173 --- /dev/null +++ b/issues/aten_c_kernels/aten_mse_elementwise.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_mse_elementwise(float a[N], float b[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = (a[i] - b[i]) * (a[i] - b[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_mse_loss.c b/issues/aten_c_kernels/aten_mse_loss.c new file mode 100644 index 000000000000..6937eefb4812 --- /dev/null +++ b/issues/aten_c_kernels/aten_mse_loss.c @@ -0,0 +1,18 @@ +/* aten::mse_loss with mean reduction. + * Upstream family: aten/src/ATen/native/Loss.cpp. + */ +#define N 256 + +void aten_mse_loss(float input[N], float target[N], float scratch[N], + float out[1]) { + float sum = 0.0f; +#pragma scop + for (int i = 0; i < N; ++i) { + float diff = input[i] - target[i]; + scratch[i] = diff * diff; + } + for (int i = 0; i < N; ++i) + sum += scratch[i]; + out[0] = sum / (float)N; +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_mul.c b/issues/aten_c_kernels/aten_mul.c new file mode 100644 index 000000000000..bddca885fb3f --- /dev/null +++ b/issues/aten_c_kernels/aten_mul.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_mul(float a[N], float b[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = a[i] * b[i]; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_multi_margin_loss_backward_cpu.c b/issues/aten_c_kernels/aten_multi_margin_loss_backward_cpu.c new file mode 100644 index 000000000000..e4fe47250fe0 --- /dev/null +++ b/issues/aten_c_kernels/aten_multi_margin_loss_backward_cpu.c @@ -0,0 +1,3 @@ +#define B 32 +#define C 16 +void aten_multi_margin_loss_backward_cpu(float input[B][C],int target[B],float weight[C],float margin,int p,float grad[B],float out[B][C]){for(int b=0;b0){float g=grad[b]*weight[t]*(p==1?1.0f:2.0f*z)/C;out[b][c]=g;sum+=g;}}}out[b][t]=-sum;}} diff --git a/issues/aten_c_kernels/aten_multi_margin_loss_cpu.c b/issues/aten_c_kernels/aten_multi_margin_loss_cpu.c new file mode 100644 index 000000000000..4f450613dc80 --- /dev/null +++ b/issues/aten_c_kernels/aten_multi_margin_loss_cpu.c @@ -0,0 +1,3 @@ +#define B 32 +#define C 16 +void aten_multi_margin_loss_cpu(float input[B][C],int target[B],float weight[C],float margin,int p,float out[B]){for(int b=0;b0)s+=p==1?z:z*z;}out[b]=s*weight[t]/C;}} diff --git a/issues/aten_c_kernels/aten_multilabel_margin_loss_backward_cpu.c b/issues/aten_c_kernels/aten_multilabel_margin_loss_backward_cpu.c new file mode 100644 index 000000000000..05235d0cc439 --- /dev/null +++ b/issues/aten_c_kernels/aten_multilabel_margin_loss_backward_cpu.c @@ -0,0 +1,4 @@ +#define B 16 +#define C 16 +#define L 4 +void aten_multilabel_margin_loss_backward_cpu(float input[B][C],int target[B][L],float grad[B],float out[B][C]){for(int b=0;b0){float g=grad[b]/C;out[b][c]+=g;out[b][t]-=g;}}}}} diff --git a/issues/aten_c_kernels/aten_multilabel_margin_loss_forward_cpu.c b/issues/aten_c_kernels/aten_multilabel_margin_loss_forward_cpu.c new file mode 100644 index 000000000000..2e4a1d51343d --- /dev/null +++ b/issues/aten_c_kernels/aten_multilabel_margin_loss_forward_cpu.c @@ -0,0 +1,4 @@ +#define B 16 +#define C 16 +#define L 4 +void aten_multilabel_margin_loss_forward_cpu(float input[B][C],int target[B][L],float out[B]){for(int b=0;b0)s+=z;}}}out[b]=s/C;}} diff --git a/issues/aten_c_kernels/aten_multinomial_with_replacement_cpu.c b/issues/aten_c_kernels/aten_multinomial_with_replacement_cpu.c new file mode 100644 index 000000000000..847a61667c87 --- /dev/null +++ b/issues/aten_c_kernels/aten_multinomial_with_replacement_cpu.c @@ -0,0 +1,4 @@ +#define B 8 +#define C 32 +#define S 16 +void aten_multinomial_with_replacement_cpu(float probability[B][C],float uniform[B][S],int out[B][S]){for(int b=0;b max_finite ? posinf_value : (x[i] < -max_finite ? neginf_value : x[i])); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_nansum_cpu.c b/issues/aten_c_kernels/aten_nansum_cpu.c new file mode 100644 index 000000000000..b849870849d2 --- /dev/null +++ b/issues/aten_c_kernels/aten_nansum_cpu.c @@ -0,0 +1,10 @@ +#ifndef R +#define R 16 +#endif +#ifndef K +#define K 64 +#endif +#ifndef TOP +#define TOP 8 +#endif +void aten_nansum_cpu(float x[R][K],float out[R]){for(int r=0;rexpf(-lambda[i]))q*=uniform[i][k++];out[i]=k-1;}} diff --git a/issues/aten_c_kernels/aten_polar_scalarized.c b/issues/aten_c_kernels/aten_polar_scalarized.c new file mode 100644 index 000000000000..49627664551e --- /dev/null +++ b/issues/aten_c_kernels/aten_polar_scalarized.c @@ -0,0 +1,15 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float cosf(float); +extern ATEN_CONST float sinf(float); +void aten_polar_scalarized(float magnitude[N], float angle[N], float out_re[N], float out_im[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out_re[i] = magnitude[i] * cosf(angle[i]); + out_im[i] = magnitude[i] * sinf(angle[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_polygamma.c b/issues/aten_c_kernels/aten_polygamma.c new file mode 100644 index 000000000000..9cef71ee0bea --- /dev/null +++ b/issues/aten_c_kernels/aten_polygamma.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float calc_polygammaf(int, float); +void aten_polygamma(float x[N], int order, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = calc_polygammaf(order, x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_pow.c b/issues/aten_c_kernels/aten_pow.c new file mode 100644 index 000000000000..05caa993e098 --- /dev/null +++ b/issues/aten_c_kernels/aten_pow.c @@ -0,0 +1,14 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float powf(float, float); +extern ATEN_CONST float powf(float, float); +void aten_pow(float a[N], float b[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = powf(a[i], b[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_pow_tensor_scalar.c b/issues/aten_c_kernels/aten_pow_tensor_scalar.c new file mode 100644 index 000000000000..8ec3acb7eb43 --- /dev/null +++ b/issues/aten_c_kernels/aten_pow_tensor_scalar.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float powf(float, float); +void aten_pow_tensor_scalar(float input[N], float exponent, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = powf(input[i], exponent); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_powsum_cpu.c b/issues/aten_c_kernels/aten_powsum_cpu.c new file mode 100644 index 000000000000..bb1331aee044 --- /dev/null +++ b/issues/aten_c_kernels/aten_powsum_cpu.c @@ -0,0 +1,10 @@ +#ifndef R +#define R 32 +#endif +#ifndef K +#define K 64 +#endif +extern float powf(float,float); +void aten_powsum_cpu(float x[R][K], float p, float out[R]) { + for(int r=0;r127)v=127;out[i]=(signed char)v;}} diff --git a/issues/aten_c_kernels/aten_quick_select_cpu.c b/issues/aten_c_kernels/aten_quick_select_cpu.c new file mode 100644 index 000000000000..e8c739faccf4 --- /dev/null +++ b/issues/aten_c_kernels/aten_quick_select_cpu.c @@ -0,0 +1,2 @@ +#define N 127 +void aten_quick_select_cpu(float x[N],int k,float out[1]){for(int i=0;i<=k;++i){int b=i;for(int j=i+1;j0;--i){int j=bits[i]%(i+1);int t=out[i];out[i]=out[j];out[j]=t;}} diff --git a/issues/aten_c_kernels/aten_range_out_cpu.c b/issues/aten_c_kernels/aten_range_out_cpu.c new file mode 100644 index 000000000000..9d64ec6709f9 --- /dev/null +++ b/issues/aten_c_kernels/aten_range_out_cpu.c @@ -0,0 +1,2 @@ +#define N 256 +void aten_range_out_cpu(float start,float step,float out[N]){for(int i=0;i= I0) i0 = 2*I0-2-i0; + grad_input[((((n)*C+c))*I0+i0)] += grad_output[((((n)*C+c))*O0+o0)]; + } + } +} +} diff --git a/issues/aten_c_kernels/aten_reflection_pad1d_cpu.c b/issues/aten_c_kernels/aten_reflection_pad1d_cpu.c new file mode 100644 index 000000000000..46641247a037 --- /dev/null +++ b/issues/aten_c_kernels/aten_reflection_pad1d_cpu.c @@ -0,0 +1,26 @@ +/* Fixed-shape ATen reflection padding 1D. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef P0 +#define P0 2 +#endif +#define O0 (I0+2*P0) +void aten_reflection_pad1d_cpu(float input[B*C*I0], float output[B*C*O0]) { + for (int n=0; n= I0) i0 = 2*I0-2-i0; + output[((((n)*C+c))*O0+o0)] = input[((((n)*C+c))*I0+i0)]; + } + } +} +} diff --git a/issues/aten_c_kernels/aten_reflection_pad2d.c b/issues/aten_c_kernels/aten_reflection_pad2d.c new file mode 100644 index 000000000000..e7bf3f34bfd3 --- /dev/null +++ b/issues/aten_c_kernels/aten_reflection_pad2d.c @@ -0,0 +1,16 @@ +/* aten::reflection_pad2d, pad=1. Upstream: ATen/native/ReflectionPad.cpp. */ +#define C 3 +#define H 8 +#define W 8 +void aten_reflection_pad2d(float input[C][H][W], + float output[C][H + 2][W + 2]) { +#pragma scop + for (int c = 0; c < C; ++c) + for (int oh = 0; oh < H + 2; ++oh) + for (int ow = 0; ow < W + 2; ++ow) { + int ih = oh == 0 ? 1 : (oh == H + 1 ? H - 2 : oh - 1); + int iw = ow == 0 ? 1 : (ow == W + 1 ? W - 2 : ow - 1); + output[c][oh][ow] = input[c][ih][iw]; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_reflection_pad2d_backward_cpu.c b/issues/aten_c_kernels/aten_reflection_pad2d_backward_cpu.c new file mode 100644 index 000000000000..46fb9bebf073 --- /dev/null +++ b/issues/aten_c_kernels/aten_reflection_pad2d_backward_cpu.c @@ -0,0 +1,39 @@ +/* Fixed-shape ATen reflection padding 2D_backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef P0 +#define P0 2 +#endif +#define O0 (I0+2*P0) +#ifndef I1 +#define I1 5 +#endif +#ifndef P1 +#define P1 2 +#endif +#define O1 (I1+2*P1) +void aten_reflection_pad2d_backward_cpu(float grad_output[B*C*O0*O1], float grad_input[B*C*I0*I1]) { + for (int p=0; p= I0) i0 = 2*I0-2-i0; + int i1 = o1 - P1; + if (i1 < 0) i1 = -i1; + if (i1 >= I1) i1 = 2*I1-2-i1; + grad_input[((((((n)*C+c))*I0+i0))*I1+i1)] += grad_output[((((((n)*C+c))*O0+o0))*O1+o1)]; + } + } + } +} +} diff --git a/issues/aten_c_kernels/aten_reflection_pad2d_cpu.c b/issues/aten_c_kernels/aten_reflection_pad2d_cpu.c new file mode 100644 index 000000000000..686f58a7fdf8 --- /dev/null +++ b/issues/aten_c_kernels/aten_reflection_pad2d_cpu.c @@ -0,0 +1,38 @@ +/* Fixed-shape ATen reflection padding 2D. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef P0 +#define P0 2 +#endif +#define O0 (I0+2*P0) +#ifndef I1 +#define I1 5 +#endif +#ifndef P1 +#define P1 2 +#endif +#define O1 (I1+2*P1) +void aten_reflection_pad2d_cpu(float input[B*C*I0*I1], float output[B*C*O0*O1]) { + for (int n=0; n= I0) i0 = 2*I0-2-i0; + int i1 = o1 - P1; + if (i1 < 0) i1 = -i1; + if (i1 >= I1) i1 = 2*I1-2-i1; + output[((((((n)*C+c))*O0+o0))*O1+o1)] = input[((((((n)*C+c))*I0+i0))*I1+i1)]; + } + } + } +} +} diff --git a/issues/aten_c_kernels/aten_reflection_pad3d_backward_cpu.c b/issues/aten_c_kernels/aten_reflection_pad3d_backward_cpu.c new file mode 100644 index 000000000000..dcb5095e2b9b --- /dev/null +++ b/issues/aten_c_kernels/aten_reflection_pad3d_backward_cpu.c @@ -0,0 +1,51 @@ +/* Fixed-shape ATen reflection padding 3D_backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef P0 +#define P0 2 +#endif +#define O0 (I0+2*P0) +#ifndef I1 +#define I1 5 +#endif +#ifndef P1 +#define P1 2 +#endif +#define O1 (I1+2*P1) +#ifndef I2 +#define I2 6 +#endif +#ifndef P2 +#define P2 2 +#endif +#define O2 (I2+2*P2) +void aten_reflection_pad3d_backward_cpu(float grad_output[B*C*O0*O1*O2], float grad_input[B*C*I0*I1*I2]) { + for (int p=0; p= I0) i0 = 2*I0-2-i0; + int i1 = o1 - P1; + if (i1 < 0) i1 = -i1; + if (i1 >= I1) i1 = 2*I1-2-i1; + int i2 = o2 - P2; + if (i2 < 0) i2 = -i2; + if (i2 >= I2) i2 = 2*I2-2-i2; + grad_input[((((((((n)*C+c))*I0+i0))*I1+i1))*I2+i2)] += grad_output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)]; + } + } + } + } +} +} diff --git a/issues/aten_c_kernels/aten_reflection_pad3d_cpu.c b/issues/aten_c_kernels/aten_reflection_pad3d_cpu.c new file mode 100644 index 000000000000..be4a6fcc3c7b --- /dev/null +++ b/issues/aten_c_kernels/aten_reflection_pad3d_cpu.c @@ -0,0 +1,50 @@ +/* Fixed-shape ATen reflection padding 3D. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef P0 +#define P0 2 +#endif +#define O0 (I0+2*P0) +#ifndef I1 +#define I1 5 +#endif +#ifndef P1 +#define P1 2 +#endif +#define O1 (I1+2*P1) +#ifndef I2 +#define I2 6 +#endif +#ifndef P2 +#define P2 2 +#endif +#define O2 (I2+2*P2) +void aten_reflection_pad3d_cpu(float input[B*C*I0*I1*I2], float output[B*C*O0*O1*O2]) { + for (int n=0; n= I0) i0 = 2*I0-2-i0; + int i1 = o1 - P1; + if (i1 < 0) i1 = -i1; + if (i1 >= I1) i1 = 2*I1-2-i1; + int i2 = o2 - P2; + if (i2 < 0) i2 = -i2; + if (i2 >= I2) i2 = 2*I2-2-i2; + output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)] = input[((((((((n)*C+c))*I0+i0))*I1+i1))*I2+i2)]; + } + } + } + } +} +} diff --git a/issues/aten_c_kernels/aten_relu.c b/issues/aten_c_kernels/aten_relu.c new file mode 100644 index 000000000000..0da777c7c829 --- /dev/null +++ b/issues/aten_c_kernels/aten_relu.c @@ -0,0 +1,11 @@ +/* aten::relu numerical body. + * Upstream family: aten/src/ATen/native/Activation.cpp. + */ +#define N 256 + +void aten_relu(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) + out[i] = x[i] > 0.0f ? x[i] : 0.0f; +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_remainder.c b/issues/aten_c_kernels/aten_remainder.c new file mode 100644 index 000000000000..476e8b73c65b --- /dev/null +++ b/issues/aten_c_kernels/aten_remainder.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float remainderf(float, float); +void aten_remainder(float a[N], float b[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = remainderf(a[i], b[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_renorm_scale_factor.c b/issues/aten_c_kernels/aten_renorm_scale_factor.c new file mode 100644 index 000000000000..c0e9695b91bb --- /dev/null +++ b/issues/aten_c_kernels/aten_renorm_scale_factor.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_renorm_scale_factor(float norm[N], float maxnorm, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = norm[i] > maxnorm ? maxnorm / (norm[i] + 1.0e-7f) : 1.0f; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_repeat_compute_cpu.c b/issues/aten_c_kernels/aten_repeat_compute_cpu.c new file mode 100644 index 000000000000..079ca7bd7895 --- /dev/null +++ b/issues/aten_c_kernels/aten_repeat_compute_cpu.c @@ -0,0 +1,3 @@ +#define N 64 +#define R 4 +void aten_repeat_compute_cpu(float x[N],float out[R][N]){for(int r=0;r= I0) i0 = I0-1; + grad_input[((((n)*C+c))*I0+i0)] += grad_output[((((n)*C+c))*O0+o0)]; + } + } +} +} diff --git a/issues/aten_c_kernels/aten_replication_pad1d_cpu.c b/issues/aten_c_kernels/aten_replication_pad1d_cpu.c new file mode 100644 index 000000000000..cbe45dc1309f --- /dev/null +++ b/issues/aten_c_kernels/aten_replication_pad1d_cpu.c @@ -0,0 +1,26 @@ +/* Fixed-shape ATen replication padding 1D. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef P0 +#define P0 2 +#endif +#define O0 (I0+2*P0) +void aten_replication_pad1d_cpu(float input[B*C*I0], float output[B*C*O0]) { + for (int n=0; n= I0) i0 = I0-1; + output[((((n)*C+c))*O0+o0)] = input[((((n)*C+c))*I0+i0)]; + } + } +} +} diff --git a/issues/aten_c_kernels/aten_replication_pad2d.c b/issues/aten_c_kernels/aten_replication_pad2d.c new file mode 100644 index 000000000000..b57ab43dd44a --- /dev/null +++ b/issues/aten_c_kernels/aten_replication_pad2d.c @@ -0,0 +1,16 @@ +/* aten::replication_pad2d, pad=1. Upstream: ATen/native/ReplicationPadding.cpp. */ +#define C 3 +#define H 8 +#define W 8 +void aten_replication_pad2d(float input[C][H][W], + float output[C][H + 2][W + 2]) { +#pragma scop + for (int c = 0; c < C; ++c) + for (int oh = 0; oh < H + 2; ++oh) + for (int ow = 0; ow < W + 2; ++ow) { + int ih = oh == 0 ? 0 : (oh == H + 1 ? H - 1 : oh - 1); + int iw = ow == 0 ? 0 : (ow == W + 1 ? W - 1 : ow - 1); + output[c][oh][ow] = input[c][ih][iw]; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_replication_pad2d_backward_cpu.c b/issues/aten_c_kernels/aten_replication_pad2d_backward_cpu.c new file mode 100644 index 000000000000..8e39e4c6402a --- /dev/null +++ b/issues/aten_c_kernels/aten_replication_pad2d_backward_cpu.c @@ -0,0 +1,39 @@ +/* Fixed-shape ATen replication padding 2D_backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef P0 +#define P0 2 +#endif +#define O0 (I0+2*P0) +#ifndef I1 +#define I1 5 +#endif +#ifndef P1 +#define P1 2 +#endif +#define O1 (I1+2*P1) +void aten_replication_pad2d_backward_cpu(float grad_output[B*C*O0*O1], float grad_input[B*C*I0*I1]) { + for (int p=0; p= I0) i0 = I0-1; + int i1 = o1 - P1; + if (i1 < 0) i1 = 0; + if (i1 >= I1) i1 = I1-1; + grad_input[((((((n)*C+c))*I0+i0))*I1+i1)] += grad_output[((((((n)*C+c))*O0+o0))*O1+o1)]; + } + } + } +} +} diff --git a/issues/aten_c_kernels/aten_replication_pad2d_cpu.c b/issues/aten_c_kernels/aten_replication_pad2d_cpu.c new file mode 100644 index 000000000000..dad052546eed --- /dev/null +++ b/issues/aten_c_kernels/aten_replication_pad2d_cpu.c @@ -0,0 +1,38 @@ +/* Fixed-shape ATen replication padding 2D. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef P0 +#define P0 2 +#endif +#define O0 (I0+2*P0) +#ifndef I1 +#define I1 5 +#endif +#ifndef P1 +#define P1 2 +#endif +#define O1 (I1+2*P1) +void aten_replication_pad2d_cpu(float input[B*C*I0*I1], float output[B*C*O0*O1]) { + for (int n=0; n= I0) i0 = I0-1; + int i1 = o1 - P1; + if (i1 < 0) i1 = 0; + if (i1 >= I1) i1 = I1-1; + output[((((((n)*C+c))*O0+o0))*O1+o1)] = input[((((((n)*C+c))*I0+i0))*I1+i1)]; + } + } + } +} +} diff --git a/issues/aten_c_kernels/aten_replication_pad3d_backward_cpu.c b/issues/aten_c_kernels/aten_replication_pad3d_backward_cpu.c new file mode 100644 index 000000000000..94b5bf84ef98 --- /dev/null +++ b/issues/aten_c_kernels/aten_replication_pad3d_backward_cpu.c @@ -0,0 +1,51 @@ +/* Fixed-shape ATen replication padding 3D_backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef P0 +#define P0 2 +#endif +#define O0 (I0+2*P0) +#ifndef I1 +#define I1 5 +#endif +#ifndef P1 +#define P1 2 +#endif +#define O1 (I1+2*P1) +#ifndef I2 +#define I2 6 +#endif +#ifndef P2 +#define P2 2 +#endif +#define O2 (I2+2*P2) +void aten_replication_pad3d_backward_cpu(float grad_output[B*C*O0*O1*O2], float grad_input[B*C*I0*I1*I2]) { + for (int p=0; p= I0) i0 = I0-1; + int i1 = o1 - P1; + if (i1 < 0) i1 = 0; + if (i1 >= I1) i1 = I1-1; + int i2 = o2 - P2; + if (i2 < 0) i2 = 0; + if (i2 >= I2) i2 = I2-1; + grad_input[((((((((n)*C+c))*I0+i0))*I1+i1))*I2+i2)] += grad_output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)]; + } + } + } + } +} +} diff --git a/issues/aten_c_kernels/aten_replication_pad3d_cpu.c b/issues/aten_c_kernels/aten_replication_pad3d_cpu.c new file mode 100644 index 000000000000..dd88e0abbde5 --- /dev/null +++ b/issues/aten_c_kernels/aten_replication_pad3d_cpu.c @@ -0,0 +1,50 @@ +/* Fixed-shape ATen replication padding 3D. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef P0 +#define P0 2 +#endif +#define O0 (I0+2*P0) +#ifndef I1 +#define I1 5 +#endif +#ifndef P1 +#define P1 2 +#endif +#define O1 (I1+2*P1) +#ifndef I2 +#define I2 6 +#endif +#ifndef P2 +#define P2 2 +#endif +#define O2 (I2+2*P2) +void aten_replication_pad3d_cpu(float input[B*C*I0*I1*I2], float output[B*C*O0*O1*O2]) { + for (int n=0; n= I0) i0 = I0-1; + int i1 = o1 - P1; + if (i1 < 0) i1 = 0; + if (i1 >= I1) i1 = I1-1; + int i2 = o2 - P2; + if (i2 < 0) i2 = 0; + if (i2 >= I2) i2 = I2-1; + output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)] = input[((((((((n)*C+c))*I0+i0))*I1+i1))*I2+i2)]; + } + } + } + } +} +} diff --git a/issues/aten_c_kernels/aten_rms_norm.c b/issues/aten_c_kernels/aten_rms_norm.c new file mode 100644 index 000000000000..f54cfa436e55 --- /dev/null +++ b/issues/aten_c_kernels/aten_rms_norm.c @@ -0,0 +1,16 @@ +/* aten::rms_norm for one row, with learned elementwise weight. */ +#ifndef N +#define N 128 +#endif +extern float sqrtf(float); + +void aten_rms_norm(float x[N], float weight[N], float out[N], float eps) { + float sum_square = 0.0f; +#pragma scop + for (int i = 0; i < N; ++i) + sum_square += x[i] * x[i]; + float scale = 1.0f / sqrtf(sum_square / (float)N + eps); + for (int i = 0; i < N; ++i) + out[i] = weight[i] * (scale * x[i]); +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_round.c b/issues/aten_c_kernels/aten_round.c new file mode 100644 index 000000000000..906a44a07650 --- /dev/null +++ b/issues/aten_c_kernels/aten_round.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float roundf(float); +void aten_round(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = roundf(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_round_decimals.c b/issues/aten_c_kernels/aten_round_decimals.c new file mode 100644 index 000000000000..c929f8f31183 --- /dev/null +++ b/issues/aten_c_kernels/aten_round_decimals.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float roundf(float); +void aten_round_decimals(float x[N], float scale, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = roundf(x[i] * scale) / scale; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_rowwise_prune_cpu.c b/issues/aten_c_kernels/aten_rowwise_prune_cpu.c new file mode 100644 index 000000000000..0963dcc47ecc --- /dev/null +++ b/issues/aten_c_kernels/aten_rowwise_prune_cpu.c @@ -0,0 +1,3 @@ +#define R 64 +#define C 32 +void aten_rowwise_prune_cpu(float x[R][C],float threshold,int keep[R]){for(int r=0;rthreshold;}} diff --git a/issues/aten_c_kernels/aten_rshift_i32.c b/issues/aten_c_kernels/aten_rshift_i32.c new file mode 100644 index 000000000000..a4ce99290f51 --- /dev/null +++ b/issues/aten_c_kernels/aten_rshift_i32.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_rshift_i32(int a[N], int b[N], int out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = a[i] >> b[i]; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_rsqrt.c b/issues/aten_c_kernels/aten_rsqrt.c new file mode 100644 index 000000000000..500c9d3b315a --- /dev/null +++ b/issues/aten_c_kernels/aten_rsqrt.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float sqrtf(float); +void aten_rsqrt(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = 1.0f / sqrtf(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_sample_poisson_transform_cpu.c b/issues/aten_c_kernels/aten_sample_poisson_transform_cpu.c new file mode 100644 index 000000000000..736e83a1b778 --- /dev/null +++ b/issues/aten_c_kernels/aten_sample_poisson_transform_cpu.c @@ -0,0 +1,2 @@ +#define N 1024 +extern float expf(float);void aten_sample_poisson_transform_cpu(float lambda[N],float uniform[N][32],int out[N]){for(int i=0;is){++k;p*=lambda[i]/k;s+=p;}out[i]=k;}} diff --git a/issues/aten_c_kernels/aten_sampled_addmm_sparse_csr_cpu.c b/issues/aten_c_kernels/aten_sampled_addmm_sparse_csr_cpu.c new file mode 100644 index 000000000000..b71d7787ff2e --- /dev/null +++ b/issues/aten_c_kernels/aten_sampled_addmm_sparse_csr_cpu.c @@ -0,0 +1,5 @@ +#define R 16 +#define K 32 +#define C 24 +#define NNZ 96 +void aten_sampled_addmm_sparse_csr_cpu(int crow[R+1],int col[NNZ],float self[NNZ],float a[R][K],float b[K][C],float alpha,float beta,float out[NNZ]){for(int r=0;rx?out[r][j]:x;else out[r][j]=out[r][j]source[r][k]?out[r][j]:source[r][k];}} diff --git a/issues/aten_c_kernels/aten_scatter_reduce_two_cpu.c b/issues/aten_c_kernels/aten_scatter_reduce_two_cpu.c new file mode 100644 index 000000000000..e40f9d8b1f38 --- /dev/null +++ b/issues/aten_c_kernels/aten_scatter_reduce_two_cpu.c @@ -0,0 +1,10 @@ +#ifndef R +#define R 32 +#endif +#ifndef K +#define K 64 +#endif +#ifndef S +#define S 128 +#endif +void aten_scatter_reduce_two_cpu(float out[R][S],int index[R][K],float source[R][K]){for(int r=0;rvalue?out[r][j]:value;else out[r][j]=out[r][j]a?v:a;else v=v= -lambd && self[i] <= lambd ? 0.0f : grad[i]; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_sigmoid.c b/issues/aten_c_kernels/aten_sigmoid.c new file mode 100644 index 000000000000..3db2f5063cc1 --- /dev/null +++ b/issues/aten_c_kernels/aten_sigmoid.c @@ -0,0 +1,8 @@ +/* aten::sigmoid. Upstream: ATen/native/cpu/UnaryOpsKernel.cpp. */ +#define N 256 +extern float expf(float); +void aten_sigmoid(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) out[i] = 1.0f / (1.0f + expf(-x[i])); +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_sigmoid_backward.c b/issues/aten_c_kernels/aten_sigmoid_backward.c new file mode 100644 index 000000000000..dde25362ee6b --- /dev/null +++ b/issues/aten_c_kernels/aten_sigmoid_backward.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_sigmoid_backward(float grad[N], float output[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = grad[i] * (1.0f - output[i]) * output[i]; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_sign.c b/issues/aten_c_kernels/aten_sign.c new file mode 100644 index 000000000000..67b06ffcff72 --- /dev/null +++ b/issues/aten_c_kernels/aten_sign.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_sign(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = (float)((0.0f < x[i]) - (x[i] < 0.0f)); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_signbit.c b/issues/aten_c_kernels/aten_signbit.c new file mode 100644 index 000000000000..1b31eaeca46c --- /dev/null +++ b/issues/aten_c_kernels/aten_signbit.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_signbit(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = (float)(x[i] < 0.0f); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_silu.c b/issues/aten_c_kernels/aten_silu.c new file mode 100644 index 000000000000..b46f95e83032 --- /dev/null +++ b/issues/aten_c_kernels/aten_silu.c @@ -0,0 +1,12 @@ +/* aten::silu numerical body. + * Upstream family: aten/src/ATen/native/Activation.cpp. + */ +#define N 256 +extern float expf(float); + +void aten_silu(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) + out[i] = x[i] / (1.0f + expf(-x[i])); +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_silu_backward.c b/issues/aten_c_kernels/aten_silu_backward.c new file mode 100644 index 000000000000..326b9f1eddf3 --- /dev/null +++ b/issues/aten_c_kernels/aten_silu_backward.c @@ -0,0 +1,14 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float expf(float); +void aten_silu_backward(float grad[N], float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + float s = 1.0f / (1.0f + expf(-x[i])); + out[i] = grad[i] * s * (1.0f + x[i] * (1.0f - s)); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_silu_cpu.c b/issues/aten_c_kernels/aten_silu_cpu.c new file mode 100644 index 000000000000..9593d2094a87 --- /dev/null +++ b/issues/aten_c_kernels/aten_silu_cpu.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float expf(float); +void aten_silu_cpu(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = x[i] / (1.0f + expf(-x[i])); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_sin.c b/issues/aten_c_kernels/aten_sin.c new file mode 100644 index 000000000000..adbf5d6db142 --- /dev/null +++ b/issues/aten_c_kernels/aten_sin.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float sinf(float); +void aten_sin(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = sinf(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_sinc.c b/issues/aten_c_kernels/aten_sinc.c new file mode 100644 index 000000000000..76cae963a562 --- /dev/null +++ b/issues/aten_c_kernels/aten_sinc.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float sinf(float); +void aten_sinc(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = x[i] == 0.0f ? 1.0f : sinf(3.14159265358979323846f * x[i]) / (3.14159265358979323846f * x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_sinh.c b/issues/aten_c_kernels/aten_sinh.c new file mode 100644 index 000000000000..1b3b4c62c9eb --- /dev/null +++ b/issues/aten_c_kernels/aten_sinh.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float sinhf(float); +void aten_sinh(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = sinhf(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_slow_conv3d_backward_input_cpu.c b/issues/aten_c_kernels/aten_slow_conv3d_backward_input_cpu.c new file mode 100644 index 000000000000..810a73d7f237 --- /dev/null +++ b/issues/aten_c_kernels/aten_slow_conv3d_backward_input_cpu.c @@ -0,0 +1,7 @@ +#define C 2 +#define O 3 +#define D 6 +#define H 7 +#define W 8 +#define K 3 +void aten_slow_conv3d_backward_input_cpu(float g[O][D][H][W],float w[O][C][K][K][K],float out[C][D+2][H+2][W+2]){for(int p=0;p= beta ? norm : norm * z / beta); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_smooth_l1_elementwise.c b/issues/aten_c_kernels/aten_smooth_l1_elementwise.c new file mode 100644 index 000000000000..f3d9b8e494b4 --- /dev/null +++ b/issues/aten_c_kernels/aten_smooth_l1_elementwise.c @@ -0,0 +1,14 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_smooth_l1_elementwise(float a[N], float b[N], float beta, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + float z = a[i] - b[i]; + float az = z < 0.0f ? -z : z; + out[i] = az < beta ? 0.5f * z * z / beta : az - 0.5f * beta; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_sobol_draw_cpu.c b/issues/aten_c_kernels/aten_sobol_draw_cpu.c new file mode 100644 index 000000000000..7126d6305cb5 --- /dev/null +++ b/issues/aten_c_kernels/aten_sobol_draw_cpu.c @@ -0,0 +1,3 @@ +#define N 256 +#define D 8 +void aten_sobol_draw_cpu(unsigned state[D],unsigned dirs[D][32],float out[N][D]){for(int n=0;n>=1;}for(int d=0;d>=1;}for(int d=0;d>(b&7);} diff --git a/issues/aten_c_kernels/aten_softmax.c b/issues/aten_c_kernels/aten_softmax.c new file mode 100644 index 000000000000..fe39dedd1b8a --- /dev/null +++ b/issues/aten_c_kernels/aten_softmax.c @@ -0,0 +1,21 @@ +/* aten::_softmax over one contiguous row. */ +#ifndef N +#define N 128 +#endif +#define NEG_INF (-3.402823466e38f) +extern float expf(float); + +void aten_softmax(float x[N]) { + float max_value = NEG_INF; +#pragma scop + for (int i = 0; i < N; ++i) + max_value = x[i] > max_value ? x[i] : max_value; + float sum = 0.0f; + for (int i = 0; i < N; ++i) { + x[i] = expf(x[i] - max_value); + sum += x[i]; + } + for (int i = 0; i < N; ++i) + x[i] /= sum; +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_softplus.c b/issues/aten_c_kernels/aten_softplus.c new file mode 100644 index 000000000000..611d7d2093af --- /dev/null +++ b/issues/aten_c_kernels/aten_softplus.c @@ -0,0 +1,12 @@ +/* aten::softplus. Upstream: ATen/native/cpu/Activation.cpp. */ +#define N 256 +extern float expf(float); +void aten_softplus(float x[N], float out[N], float beta, float threshold) { +#pragma scop + for (int i = 0; i < N; ++i) { + float z = beta * x[i]; + out[i] = z > threshold ? x[i] : + __builtin_logf(1.0f + expf(z)) / beta; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_softplus_backward.c b/issues/aten_c_kernels/aten_softplus_backward.c new file mode 100644 index 000000000000..3ea25abf554f --- /dev/null +++ b/issues/aten_c_kernels/aten_softplus_backward.c @@ -0,0 +1,14 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float expf(float); +void aten_softplus_backward(float grad[N], float self[N], float beta, float threshold, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + float z = beta * self[i]; + out[i] = z > threshold ? grad[i] : grad[i] * (1.0f - 1.0f / (1.0f + expf(z))); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_softshrink.c b/issues/aten_c_kernels/aten_softshrink.c new file mode 100644 index 000000000000..ffc77e8d3c66 --- /dev/null +++ b/issues/aten_c_kernels/aten_softshrink.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_softshrink(float self[N], float lambd, float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = self[i] > lambd ? self[i] - lambd : (self[i] < -lambd ? self[i] + lambd : self[i] * 0.0f); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_sort_cpu.c b/issues/aten_c_kernels/aten_sort_cpu.c new file mode 100644 index 000000000000..2f921339967d --- /dev/null +++ b/issues/aten_c_kernels/aten_sort_cpu.c @@ -0,0 +1,10 @@ +#ifndef R +#define R 16 +#endif +#ifndef K +#define K 64 +#endif +#ifndef TOP +#define TOP 8 +#endif +void aten_sort_cpu(float input[R][K],float values[R][K],int indices[R][K]){for(int r=0;r=0&&values[r][j]=0&&j=0?i:i-offsets[d]];}} diff --git a/issues/aten_c_kernels/aten_spherical_bessel_j0.c b/issues/aten_c_kernels/aten_spherical_bessel_j0.c new file mode 100644 index 000000000000..de5e52d43312 --- /dev/null +++ b/issues/aten_c_kernels/aten_spherical_bessel_j0.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float calc_spherical_bessel_j0f(float); +void aten_spherical_bessel_j0(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = calc_spherical_bessel_j0f(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_split_copy_cpu.c b/issues/aten_c_kernels/aten_split_copy_cpu.c new file mode 100644 index 000000000000..879dc5b512a0 --- /dev/null +++ b/issues/aten_c_kernels/aten_split_copy_cpu.c @@ -0,0 +1,3 @@ +#define N 128 +#define S 4 +void aten_split_copy_cpu(float x[N],float out[S][N/S]){for(int s=0;sacc)||(!choose_max&&x=0)out[p]+=grad[r][n]*other[col[p]][n];}} diff --git a/issues/aten_c_kernels/aten_spmm_reduce_backward_input_cpu.c b/issues/aten_c_kernels/aten_spmm_reduce_backward_input_cpu.c new file mode 100644 index 000000000000..9f4677998891 --- /dev/null +++ b/issues/aten_c_kernels/aten_spmm_reduce_backward_input_cpu.c @@ -0,0 +1,5 @@ +#define ROWS 16 +#define INNER 32 +#define COLS 24 +#define NNZ 96 +void aten_spmm_reduce_backward_input_cpu(int crow[ROWS+1],int col[NNZ],float grad[ROWS][COLS],float other[INNER][COLS],float out[NNZ]){for(int r=0;r=0)out[col[p]][n]+=val[p]*grad[r][n];}} diff --git a/issues/aten_c_kernels/aten_spmm_reduce_backward_other_cpu.c b/issues/aten_c_kernels/aten_spmm_reduce_backward_other_cpu.c new file mode 100644 index 000000000000..86681474941a --- /dev/null +++ b/issues/aten_c_kernels/aten_spmm_reduce_backward_other_cpu.c @@ -0,0 +1,5 @@ +#define ROWS 16 +#define INNER 32 +#define COLS 24 +#define NNZ 96 +void aten_spmm_reduce_backward_other_cpu(int crow[ROWS+1],int col[NNZ],float val[NNZ],float grad[ROWS][COLS],float out[INNER][COLS]){for(int k=0;kx?acc:x;else acc=acccrow[r])acc/=(float)(crow[r+1]-crow[r]);out[r][n]=acc;}} diff --git a/issues/aten_c_kernels/aten_sqrt.c b/issues/aten_c_kernels/aten_sqrt.c new file mode 100644 index 000000000000..a75dcf2aaeab --- /dev/null +++ b/issues/aten_c_kernels/aten_sqrt.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float sqrtf(float); +void aten_sqrt(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = sqrtf(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_square.c b/issues/aten_c_kernels/aten_square.c new file mode 100644 index 000000000000..e8664db59ba5 --- /dev/null +++ b/issues/aten_c_kernels/aten_square.c @@ -0,0 +1,12 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +void aten_square(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = x[i] * x[i]; + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_sspaddmm_cpu.c b/issues/aten_c_kernels/aten_sspaddmm_cpu.c new file mode 100644 index 000000000000..6c437627f5db --- /dev/null +++ b/issues/aten_c_kernels/aten_sspaddmm_cpu.c @@ -0,0 +1,5 @@ +#define R 64 +#define K 64 +#define C 48 +#define N 512 +void aten_sspaddmm_cpu(int row[N],int col[N],float val[N],float b[K][C],float out[R][C]){for(int r=0;r=0&&values[r][j]=diagonal;} diff --git a/issues/aten_c_kernels/aten_triu_tril_batch_cpu.c b/issues/aten_c_kernels/aten_triu_tril_batch_cpu.c new file mode 100644 index 000000000000..ed5499048e82 --- /dev/null +++ b/issues/aten_c_kernels/aten_triu_tril_batch_cpu.c @@ -0,0 +1,4 @@ +#define B 4 +#define M 32 +#define N 24 +void aten_triu_tril_batch_cpu(float x[B][M][N],int diagonal,int upper,float out[B][M][N]){for(int b=0;b=diagonal):(j-i<=diagonal))?x[b][i][j]:0;} diff --git a/issues/aten_c_kernels/aten_triu_tril_single_cpu.c b/issues/aten_c_kernels/aten_triu_tril_single_cpu.c new file mode 100644 index 000000000000..0532e01ac1ab --- /dev/null +++ b/issues/aten_c_kernels/aten_triu_tril_single_cpu.c @@ -0,0 +1,3 @@ +#define M 32 +#define N 24 +void aten_triu_tril_single_cpu(float x[M][N],int diagonal,int upper,float out[M][N]){for(int i=0;i=diagonal):(j-i<=diagonal))?x[i][j]:0;} diff --git a/issues/aten_c_kernels/aten_trunc.c b/issues/aten_c_kernels/aten_trunc.c new file mode 100644 index 000000000000..898bcfe3b5ae --- /dev/null +++ b/issues/aten_c_kernels/aten_trunc.c @@ -0,0 +1,13 @@ +/* Fixed-shape scalar specialization extracted from pinned ATen. */ +#ifndef N +#define N 4096 +#endif +#define ATEN_CONST __attribute__((const)) +extern ATEN_CONST float truncf(float); +void aten_trunc(float x[N], float out[N]) { +#pragma scop + for (int i = 0; i < N; ++i) { + out[i] = truncf(x[i]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_unbind_copy_cpu.c b/issues/aten_c_kernels/aten_unbind_copy_cpu.c new file mode 100644 index 000000000000..b83301d30706 --- /dev/null +++ b/issues/aten_c_kernels/aten_unbind_copy_cpu.c @@ -0,0 +1,3 @@ +#define B 4 +#define N 64 +void aten_unbind_copy_cpu(float x[B][N],float out[B][N]){for(int b=0;b=0&&iz=0&&iy=0&&ix=0&&iz=0&&iy=0&&ix 1.0f ? sy_scale : 1.0f; + float fx_scale = sx_scale > 1.0f ? sx_scale : 1.0f; + for (int n = 0; n < B; ++n) for (int c = 0; c < C; ++c) + for (int oy = 0; oy < O0; ++oy) for (int ox = 0; ox < O1; ++ox) { + float sy = ((float)oy + 0.5f) * sy_scale - 0.5f; + float sx = ((float)ox + 0.5f) * sx_scale - 0.5f; + float norm = 0.0f; + + for (int iy = 0; iy < I0; ++iy) for (int ix = 0; ix < I1; ++ix) { + float ay = sy - (float)iy; if (ay < 0.0f) ay = -ay; ay /= fy_scale; + float ax = sx - (float)ix; if (ax < 0.0f) ax = -ax; ax /= fx_scale; + float wy = ay < 2.0f ? (ay < 1.0f ? ((1.5f * ay - 2.5f) * ay * ay + 1.0f) : (ay < 2.0f ? ((-0.5f * ay + 2.5f) * ay - 4.0f) * ay + 2.0f : 0.0f)) : 0.0f; + float wx = ax < 2.0f ? (ax < 1.0f ? ((1.5f * ax - 2.5f) * ax * ax + 1.0f) : (ax < 2.0f ? ((-0.5f * ax + 2.5f) * ax - 4.0f) * ax + 2.0f : 0.0f)) : 0.0f; + norm += wy * wx; + } + for (int iy = 0; iy < I0; ++iy) for (int ix = 0; ix < I1; ++ix) { + float ay = sy - (float)iy; if (ay < 0.0f) ay = -ay; ay /= fy_scale; + float ax = sx - (float)ix; if (ax < 0.0f) ax = -ax; ax /= fx_scale; + float wy = ay < 2.0f ? (ay < 1.0f ? ((1.5f * ay - 2.5f) * ay * ay + 1.0f) : (ay < 2.0f ? ((-0.5f * ay + 2.5f) * ay - 4.0f) * ay + 2.0f : 0.0f)) : 0.0f; + float wx = ax < 2.0f ? (ax < 1.0f ? ((1.5f * ax - 2.5f) * ax * ax + 1.0f) : (ax < 2.0f ? ((-0.5f * ax + 2.5f) * ax - 4.0f) * ax + 2.0f : 0.0f)) : 0.0f; + grad_input[((n*C+c)*I0+iy)*I1+ix] += grad_output[((n*C+c)*O0+oy)*O1+ox] * wy * wx / norm; + } + } +} diff --git a/issues/aten_c_kernels/aten_upsample_bicubic2d_aa_cpu.c b/issues/aten_c_kernels/aten_upsample_bicubic2d_aa_cpu.c new file mode 100644 index 000000000000..581f6c45e0b8 --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_bicubic2d_aa_cpu.c @@ -0,0 +1,48 @@ +/* Fixed-shape ATen antialiased bicubic 2D. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +extern float sinf(float); +void aten_upsample_bicubic2d_aa_cpu(float input[B*C*I0*I1], float output[B*C*O0*O1]) { + float sy_scale = (float)I0 / (float)O0; + float sx_scale = (float)I1 / (float)O1; + float fy_scale = sy_scale > 1.0f ? sy_scale : 1.0f; + float fx_scale = sx_scale > 1.0f ? sx_scale : 1.0f; + for (int n = 0; n < B; ++n) for (int c = 0; c < C; ++c) + for (int oy = 0; oy < O0; ++oy) for (int ox = 0; ox < O1; ++ox) { + float sy = ((float)oy + 0.5f) * sy_scale - 0.5f; + float sx = ((float)ox + 0.5f) * sx_scale - 0.5f; + float norm = 0.0f; + float value = 0.0f; + for (int iy = 0; iy < I0; ++iy) for (int ix = 0; ix < I1; ++ix) { + float ay = sy - (float)iy; if (ay < 0.0f) ay = -ay; ay /= fy_scale; + float ax = sx - (float)ix; if (ax < 0.0f) ax = -ax; ax /= fx_scale; + float wy = ay < 2.0f ? (ay < 1.0f ? ((1.5f * ay - 2.5f) * ay * ay + 1.0f) : (ay < 2.0f ? ((-0.5f * ay + 2.5f) * ay - 4.0f) * ay + 2.0f : 0.0f)) : 0.0f; + float wx = ax < 2.0f ? (ax < 1.0f ? ((1.5f * ax - 2.5f) * ax * ax + 1.0f) : (ax < 2.0f ? ((-0.5f * ax + 2.5f) * ax - 4.0f) * ax + 2.0f : 0.0f)) : 0.0f; + norm += wy * wx; + } + for (int iy = 0; iy < I0; ++iy) for (int ix = 0; ix < I1; ++ix) { + float ay = sy - (float)iy; if (ay < 0.0f) ay = -ay; ay /= fy_scale; + float ax = sx - (float)ix; if (ax < 0.0f) ax = -ax; ax /= fx_scale; + float wy = ay < 2.0f ? (ay < 1.0f ? ((1.5f * ay - 2.5f) * ay * ay + 1.0f) : (ay < 2.0f ? ((-0.5f * ay + 2.5f) * ay - 4.0f) * ay + 2.0f : 0.0f)) : 0.0f; + float wx = ax < 2.0f ? (ax < 1.0f ? ((1.5f * ax - 2.5f) * ax * ax + 1.0f) : (ax < 2.0f ? ((-0.5f * ax + 2.5f) * ax - 4.0f) * ax + 2.0f : 0.0f)) : 0.0f; + value += input[((n*C+c)*I0+iy)*I1+ix] * wy * wx; + } + output[((n*C+c)*O0+oy)*O1+ox] = value / norm; + } +} diff --git a/issues/aten_c_kernels/aten_upsample_bicubic2d_backward_cpu.c b/issues/aten_c_kernels/aten_upsample_bicubic2d_backward_cpu.c new file mode 100644 index 000000000000..e7fb4f79779e --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_bicubic2d_backward_cpu.c @@ -0,0 +1,5 @@ +#define OH 8 +#define OW 8 +#define IH 5 +#define IW 5 +void aten_upsample_bicubic2d_backward_cpu(float grad[OH][OW],float out[IH][IW]){for(int p=0;p= I0) iy = I0 - 1; + int ix = bx + kx; if (ix < 0) ix = 0; if (ix >= I1) ix = I1 - 1; + value += input[((n*C+c)*I0+iy)*I1+ix] * + aten_cubic_weight(sy-(float)(by+ky)) * + aten_cubic_weight(sx-(float)(bx+kx)); + } + output[((n*C+c)*O0+oy)*O1+ox] = value; + } +} diff --git a/issues/aten_c_kernels/aten_upsample_bilinear2d.c b/issues/aten_c_kernels/aten_upsample_bilinear2d.c new file mode 100644 index 000000000000..6531e65ebb05 --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_bilinear2d.c @@ -0,0 +1,26 @@ +/* aten::upsample_bilinear2d, aligned 4x4 to 8x8. Upstream: ATen/native/UpSampleBilinear2d.cpp. */ +#define B 2 +#define C 3 +#define H 4 +#define W 4 +void aten_upsample_bilinear2d(float input[B][C][H][W], + float output[B][C][2*H][2*W]) { +#pragma scop + for (int b = 0; b < B; ++b) + for (int c = 0; c < C; ++c) + for (int oh = 0; oh < 2*H; ++oh) + for (int ow = 0; ow < 2*W; ++ow) { + int h0 = oh / 2; + int w0 = ow / 2; + int h1 = h0 + 1 < H ? h0 + 1 : h0; + int w1 = w0 + 1 < W ? w0 + 1 : w0; + float fh = (float)(oh % 2) * 0.5f; + float fw = (float)(ow % 2) * 0.5f; + output[b][c][oh][ow] = + (1.0f-fh) * ((1.0f-fw)*input[b][c][h0][w0] + + fw*input[b][c][h0][w1]) + + fh * ((1.0f-fw)*input[b][c][h1][w0] + + fw*input[b][c][h1][w1]); + } +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_bilinear2d_aa_backward_cpu.c b/issues/aten_c_kernels/aten_upsample_bilinear2d_aa_backward_cpu.c new file mode 100644 index 000000000000..1588677e445d --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_bilinear2d_aa_backward_cpu.c @@ -0,0 +1,48 @@ +/* Fixed-shape ATen antialiased bilinear 2D backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +extern float sinf(float); +void aten_upsample_bilinear2d_aa_backward_cpu(float grad_output[B*C*O0*O1], float grad_input[B*C*I0*I1]) { + for (int p = 0; p < B*C*I0*I1; ++p) grad_input[p] = 0.0f; + float sy_scale = (float)I0 / (float)O0; + float sx_scale = (float)I1 / (float)O1; + float fy_scale = sy_scale > 1.0f ? sy_scale : 1.0f; + float fx_scale = sx_scale > 1.0f ? sx_scale : 1.0f; + for (int n = 0; n < B; ++n) for (int c = 0; c < C; ++c) + for (int oy = 0; oy < O0; ++oy) for (int ox = 0; ox < O1; ++ox) { + float sy = ((float)oy + 0.5f) * sy_scale - 0.5f; + float sx = ((float)ox + 0.5f) * sx_scale - 0.5f; + float norm = 0.0f; + + for (int iy = 0; iy < I0; ++iy) for (int ix = 0; ix < I1; ++ix) { + float ay = sy - (float)iy; if (ay < 0.0f) ay = -ay; ay /= fy_scale; + float ax = sx - (float)ix; if (ax < 0.0f) ax = -ax; ax /= fx_scale; + float wy = ay < 1.0f ? (ay < 1.0f ? 1.0f - ay : 0.0f) : 0.0f; + float wx = ax < 1.0f ? (ax < 1.0f ? 1.0f - ax : 0.0f) : 0.0f; + norm += wy * wx; + } + for (int iy = 0; iy < I0; ++iy) for (int ix = 0; ix < I1; ++ix) { + float ay = sy - (float)iy; if (ay < 0.0f) ay = -ay; ay /= fy_scale; + float ax = sx - (float)ix; if (ax < 0.0f) ax = -ax; ax /= fx_scale; + float wy = ay < 1.0f ? (ay < 1.0f ? 1.0f - ay : 0.0f) : 0.0f; + float wx = ax < 1.0f ? (ax < 1.0f ? 1.0f - ax : 0.0f) : 0.0f; + grad_input[((n*C+c)*I0+iy)*I1+ix] += grad_output[((n*C+c)*O0+oy)*O1+ox] * wy * wx / norm; + } + } +} diff --git a/issues/aten_c_kernels/aten_upsample_bilinear2d_aa_cpu.c b/issues/aten_c_kernels/aten_upsample_bilinear2d_aa_cpu.c new file mode 100644 index 000000000000..d807d11f370f --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_bilinear2d_aa_cpu.c @@ -0,0 +1,48 @@ +/* Fixed-shape ATen antialiased bilinear 2D. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +extern float sinf(float); +void aten_upsample_bilinear2d_aa_cpu(float input[B*C*I0*I1], float output[B*C*O0*O1]) { + float sy_scale = (float)I0 / (float)O0; + float sx_scale = (float)I1 / (float)O1; + float fy_scale = sy_scale > 1.0f ? sy_scale : 1.0f; + float fx_scale = sx_scale > 1.0f ? sx_scale : 1.0f; + for (int n = 0; n < B; ++n) for (int c = 0; c < C; ++c) + for (int oy = 0; oy < O0; ++oy) for (int ox = 0; ox < O1; ++ox) { + float sy = ((float)oy + 0.5f) * sy_scale - 0.5f; + float sx = ((float)ox + 0.5f) * sx_scale - 0.5f; + float norm = 0.0f; + float value = 0.0f; + for (int iy = 0; iy < I0; ++iy) for (int ix = 0; ix < I1; ++ix) { + float ay = sy - (float)iy; if (ay < 0.0f) ay = -ay; ay /= fy_scale; + float ax = sx - (float)ix; if (ax < 0.0f) ax = -ax; ax /= fx_scale; + float wy = ay < 1.0f ? (ay < 1.0f ? 1.0f - ay : 0.0f) : 0.0f; + float wx = ax < 1.0f ? (ax < 1.0f ? 1.0f - ax : 0.0f) : 0.0f; + norm += wy * wx; + } + for (int iy = 0; iy < I0; ++iy) for (int ix = 0; ix < I1; ++ix) { + float ay = sy - (float)iy; if (ay < 0.0f) ay = -ay; ay /= fy_scale; + float ax = sx - (float)ix; if (ax < 0.0f) ax = -ax; ax /= fx_scale; + float wy = ay < 1.0f ? (ay < 1.0f ? 1.0f - ay : 0.0f) : 0.0f; + float wx = ax < 1.0f ? (ax < 1.0f ? 1.0f - ax : 0.0f) : 0.0f; + value += input[((n*C+c)*I0+iy)*I1+ix] * wy * wx; + } + output[((n*C+c)*O0+oy)*O1+ox] = value / norm; + } +} diff --git a/issues/aten_c_kernels/aten_upsample_bilinear2d_backward_cpu.c b/issues/aten_c_kernels/aten_upsample_bilinear2d_backward_cpu.c new file mode 100644 index 000000000000..9fee51a5f687 --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_bilinear2d_backward_cpu.c @@ -0,0 +1,48 @@ +/* Fixed-shape ATen bilinear 2D align_corners=false backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +void aten_upsample_bilinear2d_backward_cpu(float grad_output[B*C*O0*O1], float grad_input[B*C*I0*I1]) { +#pragma scop + for (int p = 0; p < B*C*I0*I1; ++p) grad_input[p] = 0.0f; + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + for (int o1 = 0; o1 < O1; ++o1) { + float s0 = ((float)o0 + 0.5f) * (float)I0 / (float)O0 - 0.5f; + if (s0 < 0.0f) s0 = 0.0f; + int i00 = (int)s0; + int i01 = i00 + 1 < I0 ? i00 + 1 : i00; + float w01 = s0 - (float)i00; + float w00 = 1.0f - w01; + float s1 = ((float)o1 + 0.5f) * (float)I1 / (float)O1 - 0.5f; + if (s1 < 0.0f) s1 = 0.0f; + int i10 = (int)s1; + int i11 = i10 + 1 < I1 ? i10 + 1 : i10; + float w11 = s1 - (float)i10; + float w10 = 1.0f - w11; + grad_input[((((((n)*C+c))*I0+i00))*I1+i10)] += grad_output[((((((n)*C+c))*O0+o0))*O1+o1)] * w00*w10; + grad_input[((((((n)*C+c))*I0+i00))*I1+i11)] += grad_output[((((((n)*C+c))*O0+o0))*O1+o1)] * w00*w11; + grad_input[((((((n)*C+c))*I0+i01))*I1+i10)] += grad_output[((((((n)*C+c))*O0+o0))*O1+o1)] * w01*w10; + grad_input[((((((n)*C+c))*I0+i01))*I1+i11)] += grad_output[((((((n)*C+c))*O0+o0))*O1+o1)] * w01*w11; + } + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_bilinear2d_cpu.c b/issues/aten_c_kernels/aten_upsample_bilinear2d_cpu.c new file mode 100644 index 000000000000..7ceaa8f59201 --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_bilinear2d_cpu.c @@ -0,0 +1,44 @@ +/* Fixed-shape ATen bilinear 2D align_corners=false. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +void aten_upsample_bilinear2d_cpu(float input[B*C*I0*I1], float output[B*C*O0*O1]) { +#pragma scop + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + for (int o1 = 0; o1 < O1; ++o1) { + float s0 = ((float)o0 + 0.5f) * (float)I0 / (float)O0 - 0.5f; + if (s0 < 0.0f) s0 = 0.0f; + int i00 = (int)s0; + int i01 = i00 + 1 < I0 ? i00 + 1 : i00; + float w01 = s0 - (float)i00; + float w00 = 1.0f - w01; + float s1 = ((float)o1 + 0.5f) * (float)I1 / (float)O1 - 0.5f; + if (s1 < 0.0f) s1 = 0.0f; + int i10 = (int)s1; + int i11 = i10 + 1 < I1 ? i10 + 1 : i10; + float w11 = s1 - (float)i10; + float w10 = 1.0f - w11; + output[((((((n)*C+c))*O0+o0))*O1+o1)] = input[((((((n)*C+c))*I0+i00))*I1+i10)] * w00*w10 + input[((((((n)*C+c))*I0+i00))*I1+i11)] * w00*w11 + input[((((((n)*C+c))*I0+i01))*I1+i10)] * w01*w10 + input[((((((n)*C+c))*I0+i01))*I1+i11)] * w01*w11; + } + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_lanczos2d_aa_backward_cpu.c b/issues/aten_c_kernels/aten_upsample_lanczos2d_aa_backward_cpu.c new file mode 100644 index 000000000000..5e9841db475f --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_lanczos2d_aa_backward_cpu.c @@ -0,0 +1,48 @@ +/* Fixed-shape ATen antialiased lanczos 2D backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +extern float sinf(float); +void aten_upsample_lanczos2d_aa_backward_cpu(float grad_output[B*C*O0*O1], float grad_input[B*C*I0*I1]) { + for (int p = 0; p < B*C*I0*I1; ++p) grad_input[p] = 0.0f; + float sy_scale = (float)I0 / (float)O0; + float sx_scale = (float)I1 / (float)O1; + float fy_scale = sy_scale > 1.0f ? sy_scale : 1.0f; + float fx_scale = sx_scale > 1.0f ? sx_scale : 1.0f; + for (int n = 0; n < B; ++n) for (int c = 0; c < C; ++c) + for (int oy = 0; oy < O0; ++oy) for (int ox = 0; ox < O1; ++ox) { + float sy = ((float)oy + 0.5f) * sy_scale - 0.5f; + float sx = ((float)ox + 0.5f) * sx_scale - 0.5f; + float norm = 0.0f; + + for (int iy = 0; iy < I0; ++iy) for (int ix = 0; ix < I1; ++ix) { + float ay = sy - (float)iy; if (ay < 0.0f) ay = -ay; ay /= fy_scale; + float ax = sx - (float)ix; if (ax < 0.0f) ax = -ax; ax /= fx_scale; + float wy = ay < 3.0f ? (ay == 0.0f ? 1.0f : (ay < 3.0f ? sinf(3.14159265358979323846f * ay) * sinf(3.14159265358979323846f * ay / 3.0f) / (3.289868133696453f * ay * ay) : 0.0f)) : 0.0f; + float wx = ax < 3.0f ? (ax == 0.0f ? 1.0f : (ax < 3.0f ? sinf(3.14159265358979323846f * ax) * sinf(3.14159265358979323846f * ax / 3.0f) / (3.289868133696453f * ax * ax) : 0.0f)) : 0.0f; + norm += wy * wx; + } + for (int iy = 0; iy < I0; ++iy) for (int ix = 0; ix < I1; ++ix) { + float ay = sy - (float)iy; if (ay < 0.0f) ay = -ay; ay /= fy_scale; + float ax = sx - (float)ix; if (ax < 0.0f) ax = -ax; ax /= fx_scale; + float wy = ay < 3.0f ? (ay == 0.0f ? 1.0f : (ay < 3.0f ? sinf(3.14159265358979323846f * ay) * sinf(3.14159265358979323846f * ay / 3.0f) / (3.289868133696453f * ay * ay) : 0.0f)) : 0.0f; + float wx = ax < 3.0f ? (ax == 0.0f ? 1.0f : (ax < 3.0f ? sinf(3.14159265358979323846f * ax) * sinf(3.14159265358979323846f * ax / 3.0f) / (3.289868133696453f * ax * ax) : 0.0f)) : 0.0f; + grad_input[((n*C+c)*I0+iy)*I1+ix] += grad_output[((n*C+c)*O0+oy)*O1+ox] * wy * wx / norm; + } + } +} diff --git a/issues/aten_c_kernels/aten_upsample_lanczos2d_aa_cpu.c b/issues/aten_c_kernels/aten_upsample_lanczos2d_aa_cpu.c new file mode 100644 index 000000000000..506db710e331 --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_lanczos2d_aa_cpu.c @@ -0,0 +1,48 @@ +/* Fixed-shape ATen antialiased lanczos 2D. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +extern float sinf(float); +void aten_upsample_lanczos2d_aa_cpu(float input[B*C*I0*I1], float output[B*C*O0*O1]) { + float sy_scale = (float)I0 / (float)O0; + float sx_scale = (float)I1 / (float)O1; + float fy_scale = sy_scale > 1.0f ? sy_scale : 1.0f; + float fx_scale = sx_scale > 1.0f ? sx_scale : 1.0f; + for (int n = 0; n < B; ++n) for (int c = 0; c < C; ++c) + for (int oy = 0; oy < O0; ++oy) for (int ox = 0; ox < O1; ++ox) { + float sy = ((float)oy + 0.5f) * sy_scale - 0.5f; + float sx = ((float)ox + 0.5f) * sx_scale - 0.5f; + float norm = 0.0f; + float value = 0.0f; + for (int iy = 0; iy < I0; ++iy) for (int ix = 0; ix < I1; ++ix) { + float ay = sy - (float)iy; if (ay < 0.0f) ay = -ay; ay /= fy_scale; + float ax = sx - (float)ix; if (ax < 0.0f) ax = -ax; ax /= fx_scale; + float wy = ay < 3.0f ? (ay == 0.0f ? 1.0f : (ay < 3.0f ? sinf(3.14159265358979323846f * ay) * sinf(3.14159265358979323846f * ay / 3.0f) / (3.289868133696453f * ay * ay) : 0.0f)) : 0.0f; + float wx = ax < 3.0f ? (ax == 0.0f ? 1.0f : (ax < 3.0f ? sinf(3.14159265358979323846f * ax) * sinf(3.14159265358979323846f * ax / 3.0f) / (3.289868133696453f * ax * ax) : 0.0f)) : 0.0f; + norm += wy * wx; + } + for (int iy = 0; iy < I0; ++iy) for (int ix = 0; ix < I1; ++ix) { + float ay = sy - (float)iy; if (ay < 0.0f) ay = -ay; ay /= fy_scale; + float ax = sx - (float)ix; if (ax < 0.0f) ax = -ax; ax /= fx_scale; + float wy = ay < 3.0f ? (ay == 0.0f ? 1.0f : (ay < 3.0f ? sinf(3.14159265358979323846f * ay) * sinf(3.14159265358979323846f * ay / 3.0f) / (3.289868133696453f * ay * ay) : 0.0f)) : 0.0f; + float wx = ax < 3.0f ? (ax == 0.0f ? 1.0f : (ax < 3.0f ? sinf(3.14159265358979323846f * ax) * sinf(3.14159265358979323846f * ax / 3.0f) / (3.289868133696453f * ax * ax) : 0.0f)) : 0.0f; + value += input[((n*C+c)*I0+iy)*I1+ix] * wy * wx; + } + output[((n*C+c)*O0+oy)*O1+ox] = value / norm; + } +} diff --git a/issues/aten_c_kernels/aten_upsample_linear1d_backward_cpu.c b/issues/aten_c_kernels/aten_upsample_linear1d_backward_cpu.c new file mode 100644 index 000000000000..31526a4e17d5 --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_linear1d_backward_cpu.c @@ -0,0 +1,32 @@ +/* Fixed-shape ATen linear 1D align_corners=false backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +void aten_upsample_linear1d_backward_cpu(float grad_output[B*C*O0], float grad_input[B*C*I0]) { +#pragma scop + for (int p = 0; p < B*C*I0; ++p) grad_input[p] = 0.0f; + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + float s0 = ((float)o0 + 0.5f) * (float)I0 / (float)O0 - 0.5f; + if (s0 < 0.0f) s0 = 0.0f; + int i00 = (int)s0; + int i01 = i00 + 1 < I0 ? i00 + 1 : i00; + float w01 = s0 - (float)i00; + float w00 = 1.0f - w01; + grad_input[((((n)*C+c))*I0+i00)] += grad_output[((((n)*C+c))*O0+o0)] * w00; + grad_input[((((n)*C+c))*I0+i01)] += grad_output[((((n)*C+c))*O0+o0)] * w01; + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_linear1d_cpu.c b/issues/aten_c_kernels/aten_upsample_linear1d_cpu.c new file mode 100644 index 000000000000..8ec9f1093d29 --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_linear1d_cpu.c @@ -0,0 +1,30 @@ +/* Fixed-shape ATen linear 1D align_corners=false. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +void aten_upsample_linear1d_cpu(float input[B*C*I0], float output[B*C*O0]) { +#pragma scop + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + float s0 = ((float)o0 + 0.5f) * (float)I0 / (float)O0 - 0.5f; + if (s0 < 0.0f) s0 = 0.0f; + int i00 = (int)s0; + int i01 = i00 + 1 < I0 ? i00 + 1 : i00; + float w01 = s0 - (float)i00; + float w00 = 1.0f - w01; + output[((((n)*C+c))*O0+o0)] = input[((((n)*C+c))*I0+i00)] * w00 + input[((((n)*C+c))*I0+i01)] * w01; + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_nearest1d_backward_cpu.c b/issues/aten_c_kernels/aten_upsample_nearest1d_backward_cpu.c new file mode 100644 index 000000000000..c8ee980f3d1c --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_nearest1d_backward_cpu.c @@ -0,0 +1,27 @@ +/* Fixed-shape ATen nearest 1D backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +void aten_upsample_nearest1d_backward_cpu(float grad_output[B*C*O0], float grad_input[B*C*I0]) { +#pragma scop + for (int p = 0; p < B*C*I0; ++p) grad_input[p] = 0.0f; + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + int i0 = (o0 * I0) / O0; + if (i0 >= I0) i0 = I0 - 1; + grad_input[((((n)*C+c))*I0+i0)] += grad_output[((((n)*C+c))*O0+o0)]; + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_nearest1d_cpu.c b/issues/aten_c_kernels/aten_upsample_nearest1d_cpu.c new file mode 100644 index 000000000000..18443d6d996b --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_nearest1d_cpu.c @@ -0,0 +1,26 @@ +/* Fixed-shape ATen nearest 1D. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +void aten_upsample_nearest1d_cpu(float input[B*C*I0], float output[B*C*O0]) { +#pragma scop + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + int i0 = (o0 * I0) / O0; + if (i0 >= I0) i0 = I0 - 1; + output[((((n)*C+c))*O0+o0)] = input[((((n)*C+c))*I0+i0)]; + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_nearest2d.c b/issues/aten_c_kernels/aten_upsample_nearest2d.c new file mode 100644 index 000000000000..212206b78de6 --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_nearest2d.c @@ -0,0 +1,20 @@ +/* aten::upsample_nearest2d specialized to scale factor 2. + * Upstream family: aten/src/ATen/native/UpSampleNearest2d.cpp. + */ +#define B 2 +#define C 4 +#define H 8 +#define W 8 +#define OH (2 * H) +#define OW (2 * W) + +void aten_upsample_nearest2d(float input[B][C][H][W], + float output[B][C][OH][OW]) { +#pragma scop + for (int b = 0; b < B; ++b) + for (int c = 0; c < C; ++c) + for (int oh = 0; oh < OH; ++oh) + for (int ow = 0; ow < OW; ++ow) + output[b][c][oh][ow] = input[b][c][oh / 2][ow / 2]; +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_nearest2d_backward_cpu.c b/issues/aten_c_kernels/aten_upsample_nearest2d_backward_cpu.c new file mode 100644 index 000000000000..a1d88e094af7 --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_nearest2d_backward_cpu.c @@ -0,0 +1,37 @@ +/* Fixed-shape ATen nearest 2D backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +void aten_upsample_nearest2d_backward_cpu(float grad_output[B*C*O0*O1], float grad_input[B*C*I0*I1]) { +#pragma scop + for (int p = 0; p < B*C*I0*I1; ++p) grad_input[p] = 0.0f; + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + for (int o1 = 0; o1 < O1; ++o1) { + int i0 = (o0 * I0) / O0; + if (i0 >= I0) i0 = I0 - 1; + int i1 = (o1 * I1) / O1; + if (i1 >= I1) i1 = I1 - 1; + grad_input[((((((n)*C+c))*I0+i0))*I1+i1)] += grad_output[((((((n)*C+c))*O0+o0))*O1+o1)]; + } + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_nearest2d_cpu.c b/issues/aten_c_kernels/aten_upsample_nearest2d_cpu.c new file mode 100644 index 000000000000..5d81750cdc52 --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_nearest2d_cpu.c @@ -0,0 +1,36 @@ +/* Fixed-shape ATen nearest 2D. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +void aten_upsample_nearest2d_cpu(float input[B*C*I0*I1], float output[B*C*O0*O1]) { +#pragma scop + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + for (int o1 = 0; o1 < O1; ++o1) { + int i0 = (o0 * I0) / O0; + if (i0 >= I0) i0 = I0 - 1; + int i1 = (o1 * I1) / O1; + if (i1 >= I1) i1 = I1 - 1; + output[((((((n)*C+c))*O0+o0))*O1+o1)] = input[((((((n)*C+c))*I0+i0))*I1+i1)]; + } + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_nearest3d_backward_cpu.c b/issues/aten_c_kernels/aten_upsample_nearest3d_backward_cpu.c new file mode 100644 index 000000000000..df216b12619a --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_nearest3d_backward_cpu.c @@ -0,0 +1,47 @@ +/* Fixed-shape ATen nearest 3D backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +#ifndef I2 +#define I2 6 +#endif +#ifndef O2 +#define O2 9 +#endif +void aten_upsample_nearest3d_backward_cpu(float grad_output[B*C*O0*O1*O2], float grad_input[B*C*I0*I1*I2]) { +#pragma scop + for (int p = 0; p < B*C*I0*I1*I2; ++p) grad_input[p] = 0.0f; + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + for (int o1 = 0; o1 < O1; ++o1) { + for (int o2 = 0; o2 < O2; ++o2) { + int i0 = (o0 * I0) / O0; + if (i0 >= I0) i0 = I0 - 1; + int i1 = (o1 * I1) / O1; + if (i1 >= I1) i1 = I1 - 1; + int i2 = (o2 * I2) / O2; + if (i2 >= I2) i2 = I2 - 1; + grad_input[((((((((n)*C+c))*I0+i0))*I1+i1))*I2+i2)] += grad_output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)]; + } + } + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_nearest3d_cpu.c b/issues/aten_c_kernels/aten_upsample_nearest3d_cpu.c new file mode 100644 index 000000000000..0ae3760527ae --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_nearest3d_cpu.c @@ -0,0 +1,46 @@ +/* Fixed-shape ATen nearest 3D. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +#ifndef I2 +#define I2 6 +#endif +#ifndef O2 +#define O2 9 +#endif +void aten_upsample_nearest3d_cpu(float input[B*C*I0*I1*I2], float output[B*C*O0*O1*O2]) { +#pragma scop + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + for (int o1 = 0; o1 < O1; ++o1) { + for (int o2 = 0; o2 < O2; ++o2) { + int i0 = (o0 * I0) / O0; + if (i0 >= I0) i0 = I0 - 1; + int i1 = (o1 * I1) / O1; + if (i1 >= I1) i1 = I1 - 1; + int i2 = (o2 * I2) / O2; + if (i2 >= I2) i2 = I2 - 1; + output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)] = input[((((((((n)*C+c))*I0+i0))*I1+i1))*I2+i2)]; + } + } + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_nearest_exact1d_backward_cpu.c b/issues/aten_c_kernels/aten_upsample_nearest_exact1d_backward_cpu.c new file mode 100644 index 000000000000..a1ab45a1ff18 --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_nearest_exact1d_backward_cpu.c @@ -0,0 +1,27 @@ +/* Fixed-shape ATen nearest-exact 1D backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +void aten_upsample_nearest_exact1d_backward_cpu(float grad_output[B*C*O0], float grad_input[B*C*I0]) { +#pragma scop + for (int p = 0; p < B*C*I0; ++p) grad_input[p] = 0.0f; + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + int i0 = ((2 * o0 + 1) * I0) / (2 * O0); + if (i0 >= I0) i0 = I0 - 1; + grad_input[((((n)*C+c))*I0+i0)] += grad_output[((((n)*C+c))*O0+o0)]; + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_nearest_exact1d_cpu.c b/issues/aten_c_kernels/aten_upsample_nearest_exact1d_cpu.c new file mode 100644 index 000000000000..01ed8b80367d --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_nearest_exact1d_cpu.c @@ -0,0 +1,26 @@ +/* Fixed-shape ATen nearest-exact 1D. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +void aten_upsample_nearest_exact1d_cpu(float input[B*C*I0], float output[B*C*O0]) { +#pragma scop + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + int i0 = ((2 * o0 + 1) * I0) / (2 * O0); + if (i0 >= I0) i0 = I0 - 1; + output[((((n)*C+c))*O0+o0)] = input[((((n)*C+c))*I0+i0)]; + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_nearest_exact2d_backward_cpu.c b/issues/aten_c_kernels/aten_upsample_nearest_exact2d_backward_cpu.c new file mode 100644 index 000000000000..0da3b6b6281a --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_nearest_exact2d_backward_cpu.c @@ -0,0 +1,37 @@ +/* Fixed-shape ATen nearest-exact 2D backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +void aten_upsample_nearest_exact2d_backward_cpu(float grad_output[B*C*O0*O1], float grad_input[B*C*I0*I1]) { +#pragma scop + for (int p = 0; p < B*C*I0*I1; ++p) grad_input[p] = 0.0f; + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + for (int o1 = 0; o1 < O1; ++o1) { + int i0 = ((2 * o0 + 1) * I0) / (2 * O0); + if (i0 >= I0) i0 = I0 - 1; + int i1 = ((2 * o1 + 1) * I1) / (2 * O1); + if (i1 >= I1) i1 = I1 - 1; + grad_input[((((((n)*C+c))*I0+i0))*I1+i1)] += grad_output[((((((n)*C+c))*O0+o0))*O1+o1)]; + } + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_nearest_exact2d_cpu.c b/issues/aten_c_kernels/aten_upsample_nearest_exact2d_cpu.c new file mode 100644 index 000000000000..420ca756535a --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_nearest_exact2d_cpu.c @@ -0,0 +1,36 @@ +/* Fixed-shape ATen nearest-exact 2D. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +void aten_upsample_nearest_exact2d_cpu(float input[B*C*I0*I1], float output[B*C*O0*O1]) { +#pragma scop + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + for (int o1 = 0; o1 < O1; ++o1) { + int i0 = ((2 * o0 + 1) * I0) / (2 * O0); + if (i0 >= I0) i0 = I0 - 1; + int i1 = ((2 * o1 + 1) * I1) / (2 * O1); + if (i1 >= I1) i1 = I1 - 1; + output[((((((n)*C+c))*O0+o0))*O1+o1)] = input[((((((n)*C+c))*I0+i0))*I1+i1)]; + } + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_nearest_exact3d_backward_cpu.c b/issues/aten_c_kernels/aten_upsample_nearest_exact3d_backward_cpu.c new file mode 100644 index 000000000000..e77d915e8ee3 --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_nearest_exact3d_backward_cpu.c @@ -0,0 +1,47 @@ +/* Fixed-shape ATen nearest-exact 3D backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +#ifndef I2 +#define I2 6 +#endif +#ifndef O2 +#define O2 9 +#endif +void aten_upsample_nearest_exact3d_backward_cpu(float grad_output[B*C*O0*O1*O2], float grad_input[B*C*I0*I1*I2]) { +#pragma scop + for (int p = 0; p < B*C*I0*I1*I2; ++p) grad_input[p] = 0.0f; + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + for (int o1 = 0; o1 < O1; ++o1) { + for (int o2 = 0; o2 < O2; ++o2) { + int i0 = ((2 * o0 + 1) * I0) / (2 * O0); + if (i0 >= I0) i0 = I0 - 1; + int i1 = ((2 * o1 + 1) * I1) / (2 * O1); + if (i1 >= I1) i1 = I1 - 1; + int i2 = ((2 * o2 + 1) * I2) / (2 * O2); + if (i2 >= I2) i2 = I2 - 1; + grad_input[((((((((n)*C+c))*I0+i0))*I1+i1))*I2+i2)] += grad_output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)]; + } + } + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_nearest_exact3d_cpu.c b/issues/aten_c_kernels/aten_upsample_nearest_exact3d_cpu.c new file mode 100644 index 000000000000..5c3ea0a705a0 --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_nearest_exact3d_cpu.c @@ -0,0 +1,46 @@ +/* Fixed-shape ATen nearest-exact 3D. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +#ifndef I2 +#define I2 6 +#endif +#ifndef O2 +#define O2 9 +#endif +void aten_upsample_nearest_exact3d_cpu(float input[B*C*I0*I1*I2], float output[B*C*O0*O1*O2]) { +#pragma scop + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + for (int o1 = 0; o1 < O1; ++o1) { + for (int o2 = 0; o2 < O2; ++o2) { + int i0 = ((2 * o0 + 1) * I0) / (2 * O0); + if (i0 >= I0) i0 = I0 - 1; + int i1 = ((2 * o1 + 1) * I1) / (2 * O1); + if (i1 >= I1) i1 = I1 - 1; + int i2 = ((2 * o2 + 1) * I2) / (2 * O2); + if (i2 >= I2) i2 = I2 - 1; + output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)] = input[((((((((n)*C+c))*I0+i0))*I1+i1))*I2+i2)]; + } + } + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_trilinear3d_backward_cpu.c b/issues/aten_c_kernels/aten_upsample_trilinear3d_backward_cpu.c new file mode 100644 index 000000000000..bd31e999db00 --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_trilinear3d_backward_cpu.c @@ -0,0 +1,66 @@ +/* Fixed-shape ATen trilinear 3D align_corners=false backward. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +#ifndef I2 +#define I2 6 +#endif +#ifndef O2 +#define O2 9 +#endif +void aten_upsample_trilinear3d_backward_cpu(float grad_output[B*C*O0*O1*O2], float grad_input[B*C*I0*I1*I2]) { +#pragma scop + for (int p = 0; p < B*C*I0*I1*I2; ++p) grad_input[p] = 0.0f; + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + for (int o1 = 0; o1 < O1; ++o1) { + for (int o2 = 0; o2 < O2; ++o2) { + float s0 = ((float)o0 + 0.5f) * (float)I0 / (float)O0 - 0.5f; + if (s0 < 0.0f) s0 = 0.0f; + int i00 = (int)s0; + int i01 = i00 + 1 < I0 ? i00 + 1 : i00; + float w01 = s0 - (float)i00; + float w00 = 1.0f - w01; + float s1 = ((float)o1 + 0.5f) * (float)I1 / (float)O1 - 0.5f; + if (s1 < 0.0f) s1 = 0.0f; + int i10 = (int)s1; + int i11 = i10 + 1 < I1 ? i10 + 1 : i10; + float w11 = s1 - (float)i10; + float w10 = 1.0f - w11; + float s2 = ((float)o2 + 0.5f) * (float)I2 / (float)O2 - 0.5f; + if (s2 < 0.0f) s2 = 0.0f; + int i20 = (int)s2; + int i21 = i20 + 1 < I2 ? i20 + 1 : i20; + float w21 = s2 - (float)i20; + float w20 = 1.0f - w21; + grad_input[((((((((n)*C+c))*I0+i00))*I1+i10))*I2+i20)] += grad_output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)] * w00*w10*w20; + grad_input[((((((((n)*C+c))*I0+i00))*I1+i10))*I2+i21)] += grad_output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)] * w00*w10*w21; + grad_input[((((((((n)*C+c))*I0+i00))*I1+i11))*I2+i20)] += grad_output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)] * w00*w11*w20; + grad_input[((((((((n)*C+c))*I0+i00))*I1+i11))*I2+i21)] += grad_output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)] * w00*w11*w21; + grad_input[((((((((n)*C+c))*I0+i01))*I1+i10))*I2+i20)] += grad_output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)] * w01*w10*w20; + grad_input[((((((((n)*C+c))*I0+i01))*I1+i10))*I2+i21)] += grad_output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)] * w01*w10*w21; + grad_input[((((((((n)*C+c))*I0+i01))*I1+i11))*I2+i20)] += grad_output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)] * w01*w11*w20; + grad_input[((((((((n)*C+c))*I0+i01))*I1+i11))*I2+i21)] += grad_output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)] * w01*w11*w21; + } + } + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_upsample_trilinear3d_cpu.c b/issues/aten_c_kernels/aten_upsample_trilinear3d_cpu.c new file mode 100644 index 000000000000..858a86c7fddd --- /dev/null +++ b/issues/aten_c_kernels/aten_upsample_trilinear3d_cpu.c @@ -0,0 +1,58 @@ +/* Fixed-shape ATen trilinear 3D align_corners=false. */ +#ifndef B +#define B 1 +#endif +#ifndef C +#define C 2 +#endif +#ifndef I0 +#define I0 4 +#endif +#ifndef O0 +#define O0 7 +#endif +#ifndef I1 +#define I1 5 +#endif +#ifndef O1 +#define O1 8 +#endif +#ifndef I2 +#define I2 6 +#endif +#ifndef O2 +#define O2 9 +#endif +void aten_upsample_trilinear3d_cpu(float input[B*C*I0*I1*I2], float output[B*C*O0*O1*O2]) { +#pragma scop + for (int n = 0; n < B; ++n) { + for (int c = 0; c < C; ++c) { + for (int o0 = 0; o0 < O0; ++o0) { + for (int o1 = 0; o1 < O1; ++o1) { + for (int o2 = 0; o2 < O2; ++o2) { + float s0 = ((float)o0 + 0.5f) * (float)I0 / (float)O0 - 0.5f; + if (s0 < 0.0f) s0 = 0.0f; + int i00 = (int)s0; + int i01 = i00 + 1 < I0 ? i00 + 1 : i00; + float w01 = s0 - (float)i00; + float w00 = 1.0f - w01; + float s1 = ((float)o1 + 0.5f) * (float)I1 / (float)O1 - 0.5f; + if (s1 < 0.0f) s1 = 0.0f; + int i10 = (int)s1; + int i11 = i10 + 1 < I1 ? i10 + 1 : i10; + float w11 = s1 - (float)i10; + float w10 = 1.0f - w11; + float s2 = ((float)o2 + 0.5f) * (float)I2 / (float)O2 - 0.5f; + if (s2 < 0.0f) s2 = 0.0f; + int i20 = (int)s2; + int i21 = i20 + 1 < I2 ? i20 + 1 : i20; + float w21 = s2 - (float)i20; + float w20 = 1.0f - w21; + output[((((((((n)*C+c))*O0+o0))*O1+o1))*O2+o2)] = input[((((((((n)*C+c))*I0+i00))*I1+i10))*I2+i20)] * w00*w10*w20 + input[((((((((n)*C+c))*I0+i00))*I1+i10))*I2+i21)] * w00*w10*w21 + input[((((((((n)*C+c))*I0+i00))*I1+i11))*I2+i20)] * w00*w11*w20 + input[((((((((n)*C+c))*I0+i00))*I1+i11))*I2+i21)] * w00*w11*w21 + input[((((((((n)*C+c))*I0+i01))*I1+i10))*I2+i20)] * w01*w10*w20 + input[((((((((n)*C+c))*I0+i01))*I1+i10))*I2+i21)] * w01*w10*w21 + input[((((((((n)*C+c))*I0+i01))*I1+i11))*I2+i20)] * w01*w11*w20 + input[((((((((n)*C+c))*I0+i01))*I1+i11))*I2+i21)] * w01*w11*w21; + } + } + } + } +} +#pragma endscop +} diff --git a/issues/aten_c_kernels/aten_vector_norm_out_cpu.c b/issues/aten_c_kernels/aten_vector_norm_out_cpu.c new file mode 100644 index 000000000000..0d1d457c8192 --- /dev/null +++ b/issues/aten_c_kernels/aten_vector_norm_out_cpu.c @@ -0,0 +1,3 @@ +#define R 32 +#define C 64 +extern float sqrtf(float);void aten_vector_norm_out_cpu(float x[R][C],float out[R]){for(int r=0;r +#include +#include +#include +#include +#include +#ifdef DEVICE_RESIDENT +#include +#define CUDA_CHECK(expr) \ + do { \ + cudaError_t status_ = (expr); \ + if (status_ != cudaSuccess) { \ + fprintf(stderr, "CUDA error at %s:%d: %s\n", __FILE__, __LINE__, \ + cudaGetErrorString(status_)); \ + return 2; \ + } \ + } while (0) +#endif + +#ifndef BENCH_ITERS +#define BENCH_ITERS 5 +#endif +#define STR1(x) #x +#define STR(x) STR1(x) + +static double seconds(void) { + struct timespec t; + clock_gettime(CLOCK_MONOTONIC, &t); + return (double)t.tv_sec + (double)t.tv_nsec * 1.0e-9; +} +static void fill_f32(float *p, size_t n, int salt) { + for (size_t i = 0; i < n; ++i) + p[i] = (float)((int)((i * 17 + (size_t)salt * 13 + 5) % 101) - 50) / 257.0f; +} +static void fill_f64(double *p, size_t n, int salt) { + for (size_t i = 0; i < n; ++i) + p[i] = (double)((int)((i * 17 + (size_t)salt * 13 + 5) % 101) - 50) / 257.0; +} +static int compare_f32(const float *a, const float *b, size_t n, + double *max_abs, double *max_rel) { + *max_abs = *max_rel = 0.0; + for (size_t i = 0; i < n; ++i) { + double d = fabs((double)a[i] - (double)b[i]); + double r = d / fmax(1.0, fabs((double)b[i])); + *max_abs = fmax(*max_abs, d); *max_rel = fmax(*max_rel, r); + } +#if defined(BENCH_KIND_CONV3D_BIAS) || defined(BENCH_KIND_CONV3D) || \ + defined(BENCH_KIND_CONV3D_TRANSPOSE_BACKWARD) + return *max_abs <= 5.0e-4 || *max_rel <= 5.0e-4; +#else + return *max_abs <= 2.0e-4 || *max_rel <= 2.0e-4; +#endif +} +static int compare_f64(const double *a, const double *b, size_t n, + double *max_abs, double *max_rel) { + *max_abs = *max_rel = 0.0; + for (size_t i = 0; i < n; ++i) { + double d = fabs(a[i] - b[i]); + double r = d / fmax(1.0, fabs(b[i])); + *max_abs = fmax(*max_abs, d); *max_rel = fmax(*max_rel, r); + } + return *max_abs <= 1.0e-9 || *max_rel <= 1.0e-9; +} + +#if defined(BENCH_KIND_COPY1) +extern void FUNCTION(float *, float *); extern void REFERENCE(float *, float *); +static const size_t sizes[] = {N, N}; static const int outputs[] = {1}; +static void call_raised(void **p) { FUNCTION(p[0], p[1]); } +static void call_reference(void **p) { REFERENCE(p[0], p[1]); } +#elif defined(BENCH_KIND_COPY2) +extern void FUNCTION(float *, float *); extern void REFERENCE(float *, float *); +static const size_t sizes[] = {(size_t)B*N, (size_t)B*N}; static const int outputs[] = {1}; +static void call_raised(void **p) { FUNCTION(p[0], p[1]); } +static void call_reference(void **p) { REFERENCE(p[0], p[1]); } +#elif defined(BENCH_KIND_TWO_COPY) +extern void FUNCTION(float *, float *, float *, float *); +extern void REFERENCE(float *, float *, float *, float *); +static const size_t sizes[] = {N, N, N, N}; static const int outputs[] = {2, 3}; +static void call_raised(void **p) { FUNCTION(p[0], p[1], p[2], p[3]); } +static void call_reference(void **p) { REFERENCE(p[0], p[1], p[2], p[3]); } +#elif defined(BENCH_KIND_AS_COMPLEX) +extern void FUNCTION(float *, float *, float *); extern void REFERENCE(float *, float *, float *); +static const size_t sizes[] = {(size_t)N*2, N, N}; static const int outputs[] = {1, 2}; +static void call_raised(void **p) { FUNCTION(p[0], p[1], p[2]); } +static void call_reference(void **p) { REFERENCE(p[0], p[1], p[2]); } +#elif defined(BENCH_KIND_CAT) +extern void FUNCTION(float *, float *, float *); extern void REFERENCE(float *, float *, float *); +static const size_t sizes[] = {(size_t)R*K, (size_t)M*K, (size_t)(R+M)*K}; +static const int outputs[] = {2}; +static void call_raised(void **p) { FUNCTION(p[0], p[1], p[2]); } +static void call_reference(void **p) { REFERENCE(p[0], p[1], p[2]); } +#elif defined(BENCH_KIND_NARROW) +extern void FUNCTION(float *, float *); extern void REFERENCE(float *, float *); +static const size_t sizes[] = {(size_t)R*C, (size_t)R*L}; static const int outputs[] = {1}; +static void call_raised(void **p) { FUNCTION(p[0], p[1]); } +static void call_reference(void **p) { REFERENCE(p[0], p[1]); } +#elif defined(BENCH_KIND_DOT) +extern void FUNCTION(float *, float *, float *); extern void REFERENCE(float *, float *, float *); +static const size_t sizes[] = {K, K, 1}; static const int outputs[] = {2}; +static void call_raised(void **p) { FUNCTION(p[0], p[1], p[2]); } +static void call_reference(void **p) { REFERENCE(p[0], p[1], p[2]); } +#elif defined(BENCH_KIND_GEMV) +extern void FUNCTION(float *, float *, float *); extern void REFERENCE(float *, float *, float *); +#ifdef GEMV_TRANS +static const size_t sizes[] = {(size_t)M*K, M, K}; +#else +static const size_t sizes[] = {(size_t)M*K, K, M}; +#endif +static const int outputs[] = {2}; +static void call_raised(void **p) { FUNCTION(p[0], p[1], p[2]); } +static void call_reference(void **p) { REFERENCE(p[0], p[1], p[2]); } +#elif defined(BENCH_KIND_BATCH_GEMM) +extern void FUNCTION(float *, float *, float *); extern void REFERENCE(float *, float *, float *); +static const size_t sizes[] = {(size_t)B*M*K, (size_t)K*N, (size_t)B*M*N}; +static const int outputs[] = {2}; +static void call_raised(void **p) { FUNCTION(p[0], p[1], p[2]); } +static void call_reference(void **p) { REFERENCE(p[0], p[1], p[2]); } +#elif defined(BENCH_KIND_OUTER) +extern void FUNCTION(double *, double *, double *); extern void REFERENCE(double *, double *, double *); +static const size_t sizes[] = {M, N, (size_t)M*N}; static const int outputs[] = {2}; +static void call_raised(void **p) { FUNCTION(p[0], p[1], p[2]); } +static void call_reference(void **p) { REFERENCE(p[0], p[1], p[2]); } +#define IS_F64 1 +#elif defined(BENCH_KIND_GELU) +extern void FUNCTION(float *, float *); extern void REFERENCE(float *, float *); +static const size_t sizes[] = {N, N}; static const int outputs[] = {1}; +static void call_raised(void **p) { FUNCTION(p[0], p[1]); } +static void call_reference(void **p) { REFERENCE(p[0], p[1]); } +#elif defined(BENCH_KIND_LINEAR_COMB) +extern void FUNCTION(float *, float *, float *); extern void REFERENCE(float *, float *, float *); +static const size_t sizes[] = {(size_t)4*N, 4, N}; static const int outputs[] = {2}; +static void call_raised(void **p) { FUNCTION(p[0], p[1], p[2]); } +static void call_reference(void **p) { REFERENCE(p[0], p[1], p[2]); } +#elif defined(BENCH_KIND_ZERO) +extern void FUNCTION(float *); extern void REFERENCE(float *); +static const size_t sizes[] = {N}; static const int outputs[] = {0}; +static void call_raised(void **p) { FUNCTION(p[0]); } +static void call_reference(void **p) { REFERENCE(p[0]); } +#elif defined(BENCH_KIND_CONV3D_BIAS) +extern void FUNCTION(float *, float *, float *, float *); +extern void REFERENCE(float *, float *, float *, float *); +static const size_t sizes[] = {(size_t)B*IC*D*H*W, (size_t)OC*IC*K*K*K, OC, + (size_t)B*OC*(D-K+1)*(H-K+1)*(W-K+1)}; +static const int outputs[] = {3}; +static void call_raised(void **p) { FUNCTION(p[0], p[1], p[2], p[3]); } +static void call_reference(void **p) { REFERENCE(p[0], p[1], p[2], p[3]); } +#elif defined(BENCH_KIND_CONV3D) +extern void FUNCTION(float *, float *, float *); extern void REFERENCE(float *, float *, float *); +static const size_t sizes[] = {(size_t)C*D*H*W, (size_t)O*C*K*K*K, + (size_t)O*(D-K+1)*(H-K+1)*(W-K+1)}; +static const int outputs[] = {2}; +static void call_raised(void **p) { FUNCTION(p[0], p[1], p[2]); } +static void call_reference(void **p) { REFERENCE(p[0], p[1], p[2]); } +#elif defined(BENCH_KIND_CONV3D_TRANSPOSE_BACKWARD) +extern void FUNCTION(float *, float *, float *); extern void REFERENCE(float *, float *, float *); +static const size_t sizes[] = {(size_t)O*(D+2)*(H+2)*(W+2), (size_t)C*O*K*K*K, + (size_t)C*D*H*W}; +static const int outputs[] = {2}; +static void call_raised(void **p) { FUNCTION(p[0], p[1], p[2]); } +static void call_reference(void **p) { REFERENCE(p[0], p[1], p[2]); } +#else +#error Select BENCH_KIND_* +#endif + +int main(void) { + enum { ARGC = sizeof(sizes) / sizeof(sizes[0]), + NOUT = sizeof(outputs) / sizeof(outputs[0]) }; + void *raised[4] = {0}, *reference[4] = {0}; +#ifdef IS_F64 + const size_t elem = sizeof(double); +#else + const size_t elem = sizeof(float); +#endif + for (int i = 0; i < ARGC; ++i) { +#ifdef DEVICE_RESIDENT + CUDA_CHECK(cudaMalloc(&raised[i], sizes[i] * elem)); +#else + raised[i] = malloc(sizes[i] * elem); +#endif + reference[i] = malloc(sizes[i] * elem); + if (!raised[i] || !reference[i]) return 2; +#ifdef IS_F64 +#ifdef DEVICE_RESIDENT + fill_f64(reference[i], sizes[i], i + 1); +#else + fill_f64(raised[i], sizes[i], i + 1); +#endif +#else +#ifdef DEVICE_RESIDENT + fill_f32(reference[i], sizes[i], i + 1); +#else + fill_f32(raised[i], sizes[i], i + 1); +#endif +#endif +#ifdef DEVICE_RESIDENT + CUDA_CHECK(cudaMemcpy(raised[i], reference[i], sizes[i] * elem, + cudaMemcpyHostToDevice)); +#else + memcpy(reference[i], raised[i], sizes[i] * elem); +#endif + } +#ifdef BENCH_KIND_DOT + /* Avoid a cancellation-dominated condition number when comparing the + * sequential C reduction with cuBLAS's tree reduction at 16M elements. */ + for (int p = 0; p < 2; ++p) { +#ifdef DEVICE_RESIDENT + float *x = (float *)reference[p]; +#else + float *x = (float *)raised[p]; +#endif + for (size_t i = 0; i < sizes[p]; ++i) + x[i] = (i & 1) ? -1.0f : 1.0f; +#ifdef DEVICE_RESIDENT + CUDA_CHECK(cudaMemcpy(raised[p], reference[p], + sizes[p] * sizeof(float), cudaMemcpyHostToDevice)); +#else + memcpy(reference[p], raised[p], sizes[p] * sizeof(float)); +#endif + } +#endif + call_reference(reference); call_raised(raised); + int correct = 1; double max_abs = 0.0, max_rel = 0.0; + for (int j = 0; j < NOUT; ++j) { + int i = outputs[j]; double a = 0.0, r = 0.0; +#ifdef DEVICE_RESIDENT + void *actual = malloc(sizes[i] * elem); + if (!actual) return 2; + CUDA_CHECK(cudaMemcpy(actual, raised[i], sizes[i] * elem, + cudaMemcpyDeviceToHost)); +#else + void *actual = raised[i]; +#endif +#ifdef IS_F64 + correct &= compare_f64(actual, reference[i], sizes[i], &a, &r); +#else + correct &= compare_f32(actual, reference[i], sizes[i], &a, &r); +#endif +#ifdef DEVICE_RESIDENT + free(actual); +#endif + max_abs = fmax(max_abs, a); max_rel = fmax(max_rel, r); + } + printf("kernel=%s correctness=%s max_abs=%.17g max_rel=%.17g\n", + STR(FUNCTION), correct ? "PASS" : "FAIL", max_abs, max_rel); + if (!correct) return 1; + call_raised(raised); + double start = seconds(); + for (int i = 0; i < BENCH_ITERS; ++i) call_raised(raised); + double us = (seconds() - start) * 1.0e6 / BENCH_ITERS; +#ifdef DEVICE_RESIDENT + printf("kernel=%s mode=raised_device iterations=%d raised_device_us=%.6f\n", + STR(FUNCTION), BENCH_ITERS, us); +#else + printf("kernel=%s iterations=%d raised_gpu_us=%.6f\n", + STR(FUNCTION), BENCH_ITERS, us); +#endif + for (int i = 0; i < ARGC; ++i) { +#ifdef DEVICE_RESIDENT + CUDA_CHECK(cudaFree(raised[i])); +#else + free(raised[i]); +#endif + free(reference[i]); + } + return 0; +} diff --git a/issues/aten_c_kernels/benchmarks/aten_full_match_resident_baseline.c b/issues/aten_c_kernels/benchmarks/aten_full_match_resident_baseline.c new file mode 100644 index 000000000000..1121843cebca --- /dev/null +++ b/issues/aten_c_kernels/benchmarks/aten_full_match_resident_baseline.c @@ -0,0 +1,181 @@ +/* Device-resident CUDA/cuBLAS/cuDNN baselines for the exhaustive ATen + * FULL/FULL batch. This is ordinary C (no custom CUDA kernels), so it can be + * cross-compiled with aarch64-linux-gnu-gcc against the Jetson SDK stubs. */ +#include +#include +#include +#include +#include +#include +#include +#include + +/* Shape names are activated only after vendor headers; short macros such as + * B, C, and N otherwise rewrite parameter names inside those headers. */ +#ifdef ATEN_B +#define B ATEN_B +#endif +#ifdef ATEN_C +#define C ATEN_C +#endif +#ifdef ATEN_D +#define D ATEN_D +#endif +#ifdef ATEN_H +#define H ATEN_H +#endif +#ifdef ATEN_W +#define W ATEN_W +#endif +#ifdef ATEN_IC +#define IC ATEN_IC +#endif +#ifdef ATEN_OC +#define OC ATEN_OC +#endif +#ifdef ATEN_O +#define O ATEN_O +#endif +#ifdef ATEN_K +#define K ATEN_K +#endif +#ifdef ATEN_M +#define M ATEN_M +#endif +#ifdef ATEN_N +#define N ATEN_N +#endif +#ifdef ATEN_R +#define R ATEN_R +#endif +#ifdef ATEN_L +#define L ATEN_L +#endif +#ifdef ATEN_S +#define S ATEN_S +#endif + +#ifndef BENCH_ITERS +#define BENCH_ITERS 20 +#endif +#define STR1(x) #x +#define STR(x) STR1(x) +#define CUDA_OK(x) do { cudaError_t e=(x); if(e!=cudaSuccess){fprintf(stderr,"CUDA: %s\n",cudaGetErrorString(e));return 2;} } while(0) +#define BLAS_OK(x) do { cublasStatus_t e=(x); if(e!=CUBLAS_STATUS_SUCCESS){fprintf(stderr,"cuBLAS: %d\n",(int)e);return 2;} } while(0) +#define DNN_OK(x) do { cudnnStatus_t e=(x); if(e!=CUDNN_STATUS_SUCCESS){fprintf(stderr,"cuDNN: %s\n",cudnnGetErrorString(e));return 2;} } while(0) + +static void fill_f32(float *p,size_t n,int salt){for(size_t i=0;ih,&one,c->xd,c->dx,c->fd,c->dw,c->cd,c->algo,c->ws,c->wsz,&zero,c->yd,c->dy); +#ifdef BENCH_KIND_CONV3D_BIAS +cudnnAddTensor(c->h,&one,c->bd,c->db,&one,c->yd,c->dy); +#endif +} +int main(void){int od=ID-K+1,oh=IH-K+1,ow=IW-K+1;size_t nx=(size_t)CIN*ID*IH*IW,nw=(size_t)COUT*CIN*K*K*K,ny=(size_t)COUT*od*oh*ow;float*x=malloc(nx*4),*w=malloc(nw*4),*o=malloc(ny*4),*r=malloc(ny*4),*bias=NULL;fill_f32(x,nx,1);fill_f32(w,nw,2); +#ifdef BENCH_KIND_CONV3D_BIAS +bias=malloc(COUT*4);fill_f32(bias,COUT,3);REFERENCE(x,w,bias,r); +#else +REFERENCE(x,w,r); +#endif +Conv c={0};DNN_OK(cudnnCreate(&c.h));DNN_OK(cudnnCreateTensorDescriptor(&c.xd));DNN_OK(cudnnCreateTensorDescriptor(&c.yd));DNN_OK(cudnnCreateFilterDescriptor(&c.fd));DNN_OK(cudnnCreateConvolutionDescriptor(&c.cd));int xd[5]={1,CIN,ID,IH,IW},xs[5]={CIN*ID*IH*IW,ID*IH*IW,IH*IW,IW,1};int yd[5]={1,COUT,od,oh,ow},ys[5]={COUT*od*oh*ow,od*oh*ow,oh*ow,ow,1};int fd[5]={COUT,CIN,K,K,K},pad[3]={0,0,0},stride[3]={1,1,1},dilation[3]={1,1,1};DNN_OK(cudnnSetTensorNdDescriptor(c.xd,CUDNN_DATA_FLOAT,5,xd,xs));DNN_OK(cudnnSetTensorNdDescriptor(c.yd,CUDNN_DATA_FLOAT,5,yd,ys));DNN_OK(cudnnSetFilterNdDescriptor(c.fd,CUDNN_DATA_FLOAT,CUDNN_TENSOR_NCHW,5,fd));DNN_OK(cudnnSetConvolutionNdDescriptor(c.cd,3,pad,stride,dilation,CUDNN_CROSS_CORRELATION,CUDNN_DATA_FLOAT));int got=0;cudnnConvolutionFwdAlgoPerf_t perf;DNN_OK(cudnnGetConvolutionForwardAlgorithm_v7(c.h,c.xd,c.fd,c.cd,c.yd,1,&got,&perf));if(!got)return 2;c.algo=perf.algo;DNN_OK(cudnnGetConvolutionForwardWorkspaceSize(c.h,c.xd,c.fd,c.cd,c.yd,c.algo,&c.wsz));CUDA_OK(cudaMalloc((void**)&c.dx,nx*4));CUDA_OK(cudaMalloc((void**)&c.dw,nw*4));CUDA_OK(cudaMalloc((void**)&c.dy,ny*4));if(c.wsz)CUDA_OK(cudaMalloc(&c.ws,c.wsz));CUDA_OK(cudaMemcpy(c.dx,x,nx*4,cudaMemcpyHostToDevice));CUDA_OK(cudaMemcpy(c.dw,w,nw*4,cudaMemcpyHostToDevice)); +#ifdef BENCH_KIND_CONV3D_BIAS +DNN_OK(cudnnCreateTensorDescriptor(&c.bd));int bd[5]={1,COUT,1,1,1},bs[5]={COUT,1,1,1,1};DNN_OK(cudnnSetTensorNdDescriptor(c.bd,CUDNN_DATA_FLOAT,5,bd,bs));CUDA_OK(cudaMalloc((void**)&c.db,COUT*4));CUDA_OK(cudaMemcpy(c.db,bias,COUT*4,cudaMemcpyHostToDevice)); +#endif +float us;TIME_LAUNCH(launch_conv(&c));CUDA_OK(cudaMemcpy(o,c.dy,ny*4,cudaMemcpyDeviceToHost));double e=err_f32(o,r,ny);PRINT_RESULT(e,5e-4);} +#else +#error Unsupported resident benchmark kind +#endif diff --git a/issues/aten_c_kernels/benchmarks/aten_gemv_device_resident_harness.c b/issues/aten_c_kernels/benchmarks/aten_gemv_device_resident_harness.c new file mode 100644 index 000000000000..4c1a89bc9a06 --- /dev/null +++ b/issues/aten_c_kernels/benchmarks/aten_gemv_device_resident_harness.c @@ -0,0 +1,113 @@ +/* Correctness and warm timing for the generated ATen GEMV function with + * cudaMalloc operands. This intentionally calls FUNCTION, not cuBLAS + * directly, so raising, matching, ABI lowering, the zero stage, and the + * cuBLAS shim are all exercised exactly as in the mapped-host harness. + */ +#define _POSIX_C_SOURCE 200809L +#include +#include +#include +#include +#include +#include + +#ifndef BENCH_ITERS +#define BENCH_ITERS 20 +#endif + +#define STR1(x) #x +#define STR(x) STR1(x) +#define CUDA_CHECK(expr) \ + do { \ + cudaError_t status_ = (expr); \ + if (status_ != cudaSuccess) { \ + fprintf(stderr, "CUDA error at %s:%d: %s\n", __FILE__, __LINE__, \ + cudaGetErrorString(status_)); \ + exit(2); \ + } \ + } while (0) + +extern void FUNCTION(float *, float *, float *); +extern void REFERENCE(float *, float *, float *); + +static double seconds(void) { + struct timespec value; + clock_gettime(CLOCK_MONOTONIC, &value); + return (double)value.tv_sec + (double)value.tv_nsec * 1.0e-9; +} + +static void fill(float *values, size_t count, int salt) { + for (size_t i = 0; i < count; ++i) + values[i] = + (float)((int)((i * 17 + (size_t)salt * 13 + 5) % 101) - 50) / + 257.0f; +} + +int main(void) { + const size_t matrix_elems = (size_t)M * K; +#ifdef GEMV_TRANS + const size_t x_elems = M; + const size_t y_elems = K; +#else + const size_t x_elems = K; + const size_t y_elems = M; +#endif + float *matrix = (float *)malloc(matrix_elems * sizeof(float)); + float *x = (float *)malloc(x_elems * sizeof(float)); + float *expected = (float *)malloc(y_elems * sizeof(float)); + float *actual = (float *)malloc(y_elems * sizeof(float)); + if (!matrix || !x || !expected || !actual) + return 2; + fill(matrix, matrix_elems, 1); + fill(x, x_elems, 2); + REFERENCE(matrix, x, expected); + + float *device_matrix = NULL; + float *device_x = NULL; + float *device_y = NULL; + CUDA_CHECK(cudaMalloc((void **)&device_matrix, + matrix_elems * sizeof(float))); + CUDA_CHECK(cudaMalloc((void **)&device_x, x_elems * sizeof(float))); + CUDA_CHECK(cudaMalloc((void **)&device_y, y_elems * sizeof(float))); + CUDA_CHECK(cudaMemcpy(device_matrix, matrix, + matrix_elems * sizeof(float), + cudaMemcpyHostToDevice)); + CUDA_CHECK(cudaMemcpy(device_x, x, x_elems * sizeof(float), + cudaMemcpyHostToDevice)); + + FUNCTION(device_matrix, device_x, device_y); + CUDA_CHECK(cudaMemcpy(actual, device_y, y_elems * sizeof(float), + cudaMemcpyDeviceToHost)); + double max_abs = 0.0; + double max_rel = 0.0; + for (size_t i = 0; i < y_elems; ++i) { + double diff = fabs((double)actual[i] - (double)expected[i]); + double relative = diff / fmax(1.0, fabs((double)expected[i])); + max_abs = fmax(max_abs, diff); + max_rel = fmax(max_rel, relative); + } + const int correct = max_abs <= 1.0e-3 || max_rel <= 1.0e-3; + printf("kernel=%s mode=raised_device correctness=%s " + "max_abs=%.17g max_rel=%.17g\n", + STR(FUNCTION), correct ? "PASS" : "FAIL", max_abs, max_rel); + if (!correct) + return 1; + + FUNCTION(device_matrix, device_x, device_y); + double start = seconds(); + for (int iteration = 0; iteration < BENCH_ITERS; ++iteration) + FUNCTION(device_matrix, device_x, device_y); + double runtime_us = (seconds() - start) * 1.0e6 / BENCH_ITERS; + printf("kernel=%s mode=raised_device iterations=%d " + "raised_device_us=%.6f\n", + STR(FUNCTION), BENCH_ITERS, runtime_us); + + CUDA_CHECK(cudaFree(device_matrix)); + CUDA_CHECK(cudaFree(device_x)); + CUDA_CHECK(cudaFree(device_y)); + free(matrix); + free(x); + free(expected); + free(actual); + return 0; +} diff --git a/issues/aten_c_kernels/benchmarks/aten_raised_jetson_harness.c b/issues/aten_c_kernels/benchmarks/aten_raised_jetson_harness.c new file mode 100644 index 000000000000..08b1087a7326 --- /dev/null +++ b/issues/aten_c_kernels/benchmarks/aten_raised_jetson_harness.c @@ -0,0 +1,278 @@ +#include +#include +#include +#include +#include +#ifdef DEVICE_RESIDENT +#include +#define CUDA_CHECK(expr) \ + do { \ + cudaError_t status_ = (expr); \ + if (status_ != cudaSuccess) { \ + fprintf(stderr, "CUDA error at %s:%d: %s\n", __FILE__, __LINE__, \ + cudaGetErrorString(status_)); \ + return 2; \ + } \ + } while (0) +#endif + +#ifndef BENCH_ITERS +#define BENCH_ITERS 5 +#endif + +#if defined(BENCH_ATEN_CONV2D) +#define OH (H - KH + 1) +#define OW (W - KW + 1) +#elif defined(BENCH_ATEN_MAX_POOL2D) +#define OH ((H - K) / S + 1) +#define OW ((W - K) / S + 1) +#endif + +static double seconds(void) { + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return (double)ts.tv_sec + 1.0e-9 * (double)ts.tv_nsec; +} + +static double value(size_t i, int salt) { + const int centered = (int)((i * 17 + (size_t)salt * 13 + 5) % 101) - 50; + return (double)centered / 257.0; +} + +static void fill_f32(float *p, size_t n, int salt) { + for (size_t i = 0; i < n; ++i) p[i] = (float)value(i, salt); +} + +static void fill_f64(double *p, size_t n, int salt) { + for (size_t i = 0; i < n; ++i) p[i] = value(i, salt); +} + +static int compare_f32(const float *a, const float *b, size_t n, + double *max_abs, double *max_rel) { + *max_abs = 0.0; + *max_rel = 0.0; + for (size_t i = 0; i < n; ++i) { + double d = fabs((double)a[i] - (double)b[i]); + double r = d / fmax(1.0, fabs((double)b[i])); + *max_abs = fmax(*max_abs, d); + *max_rel = fmax(*max_rel, r); + } +#if defined(BENCH_ATEN_RMS_NORM) + // The extracted scalar C reference accumulates 8M squares strictly in + // float loop order. The library implementation uses a tree reduction, + // whose result is substantially closer to a double-precision sum but is + // not bitwise-equivalent to that increasingly ill-conditioned ordering. + return *max_abs <= 2.0e-3 || *max_rel <= 2.0e-3; +#else + return *max_abs <= 2.0e-4 || *max_rel <= 2.0e-4; +#endif +} + +static int compare_f64(const double *a, const double *b, size_t n, + double *max_abs, double *max_rel) { + *max_abs = 0.0; + *max_rel = 0.0; + for (size_t i = 0; i < n; ++i) { + double d = fabs(a[i] - b[i]); + double r = d / fmax(1.0, fabs(b[i])); + *max_abs = fmax(*max_abs, d); + *max_rel = fmax(*max_rel, r); + } + return *max_abs <= 1.0e-10 || *max_rel <= 1.0e-10; +} + +#if defined(BENCH_ATEN_ADD) +#define BENCH_NAME "aten_add" +extern void aten_add(float *, float *); +extern void aten_add_reference(float *, float *); +static size_t output_size(void) { return (size_t)B*C*H*W; } +static void call_raised(void **p) { aten_add(p[0], p[1]); } +static void call_reference(void **p) { aten_add_reference(p[0], p[1]); } +#elif defined(BENCH_ATEN_ADDMM) +#define BENCH_NAME "aten_addmm" +extern void aten_addmm(double *, double *, double *, double, double); +extern void aten_addmm_reference(double *, double *, double *, double, double); +static size_t output_size(void) { return (size_t)M*N; } +static void call_raised(void **p) { aten_addmm(p[0], p[1], p[2], 0.5, 1.25); } +static void call_reference(void **p) { aten_addmm_reference(p[0], p[1], p[2], 0.5, 1.25); } +#elif defined(BENCH_ATEN_BATCH_NORM) +#define BENCH_NAME "aten_batch_norm" +extern void aten_batch_norm(float *, float *, float *, float *, float *, float *); +extern void aten_batch_norm_reference(float *, float *, float *, float *, float *, float *); +static size_t output_size(void) { return (size_t)B*C*H*W; } +static void call_raised(void **p) { aten_batch_norm(p[0],p[1],p[2],p[3],p[4],p[5]); } +static void call_reference(void **p) { aten_batch_norm_reference(p[0],p[1],p[2],p[3],p[4],p[5]); } +#elif defined(BENCH_ATEN_CONV2D) +#define BENCH_NAME "aten_conv2d" +extern void aten_conv2d(float *, float *, float *); +extern void aten_conv2d_reference(float *, float *, float *); +static size_t output_size(void) { return (size_t)B*OC*OH*OW; } +static void call_raised(void **p) { aten_conv2d(p[0], p[1], p[2]); } +static void call_reference(void **p) { aten_conv2d_reference(p[0], p[1], p[2]); } +#elif defined(BENCH_ATEN_DOT) +#define BENCH_NAME "aten_dot" +extern void aten_dot(double *, double *, double *); +extern void aten_dot_reference(double *, double *, double *); +static size_t output_size(void) { return 1; } +static void call_raised(void **p) { aten_dot(p[0], p[1], p[2]); } +static void call_reference(void **p) { aten_dot_reference(p[0], p[1], p[2]); } +#elif defined(BENCH_ATEN_GELU) +#define BENCH_NAME "aten_gelu" +extern void aten_gelu(float *, float *); +extern void aten_gelu_reference(float *, float *); +static size_t output_size(void) { return N; } +static void call_raised(void **p) { aten_gelu(p[0], p[1]); } +static void call_reference(void **p) { aten_gelu_reference(p[0], p[1]); } +#elif defined(BENCH_ATEN_MAX_POOL2D) +#define BENCH_NAME "aten_max_pool2d" +extern void aten_max_pool2d(float *, float *); +extern void aten_max_pool2d_reference(float *, float *); +static size_t output_size(void) { return (size_t)B*C*OH*OW; } +static void call_raised(void **p) { aten_max_pool2d(p[0], p[1]); } +static void call_reference(void **p) { aten_max_pool2d_reference(p[0], p[1]); } +#elif defined(BENCH_ATEN_MM) +#define BENCH_NAME "aten_mm" +extern void aten_mm(double *, double *, double *); +extern void aten_mm_reference(double *, double *, double *); +static size_t output_size(void) { return (size_t)M*N; } +static void call_raised(void **p) { aten_mm(p[0], p[1], p[2]); } +static void call_reference(void **p) { aten_mm_reference(p[0], p[1], p[2]); } +#elif defined(BENCH_ATEN_MV) +#define BENCH_NAME "aten_mv" +extern void aten_mv(double *, double *, double *); +extern void aten_mv_reference(double *, double *, double *); +static size_t output_size(void) { return M; } +static void call_raised(void **p) { aten_mv(p[0], p[1], p[2]); } +static void call_reference(void **p) { aten_mv_reference(p[0], p[1], p[2]); } +#elif defined(BENCH_ATEN_RMS_NORM) +#define BENCH_NAME "aten_rms_norm" +extern void aten_rms_norm(float *, float *, float *, float); +extern void aten_rms_norm_reference(float *, float *, float *, float); +static size_t output_size(void) { return N; } +static void call_raised(void **p) { aten_rms_norm(p[0], p[1], p[2], 1.0e-5f); } +static void call_reference(void **p) { aten_rms_norm_reference(p[0], p[1], p[2], 1.0e-5f); } +#elif defined(BENCH_ATEN_SOFTMAX) +#define BENCH_NAME "aten_softmax" +extern void aten_softmax(float *); +extern void aten_softmax_reference(float *); +static size_t output_size(void) { return N; } +static void call_raised(void **p) { aten_softmax(p[0]); } +static void call_reference(void **p) { aten_softmax_reference(p[0]); } +#else +#error "Select one BENCH_ATEN_* kernel" +#endif + +int main(void) { + void *raised[6] = {0}; + void *reference[6] = {0}; + size_t sizes[6] = {0}; + int output_index = 0; + int is_f64 = 0; + +#if defined(BENCH_ATEN_ADD) + sizes[0]=sizes[1]=(size_t)B*C*H*W; output_index=1; +#elif defined(BENCH_ATEN_ADDMM) + sizes[0]=(size_t)M*K; sizes[1]=(size_t)K*N; sizes[2]=(size_t)M*N; output_index=2; is_f64=1; +#elif defined(BENCH_ATEN_BATCH_NORM) + sizes[0]=sizes[5]=(size_t)B*C*H*W; sizes[1]=sizes[2]=sizes[3]=sizes[4]=C; output_index=5; +#elif defined(BENCH_ATEN_CONV2D) + sizes[0]=(size_t)B*IC*H*W; sizes[1]=(size_t)OC*IC*KH*KW; sizes[2]=(size_t)B*OC*OH*OW; output_index=2; +#elif defined(BENCH_ATEN_DOT) + sizes[0]=sizes[1]=N; sizes[2]=1; output_index=2; is_f64=1; +#elif defined(BENCH_ATEN_GELU) + sizes[0]=sizes[1]=N; output_index=1; +#elif defined(BENCH_ATEN_MAX_POOL2D) + sizes[0]=(size_t)B*C*H*W; sizes[1]=(size_t)B*C*OH*OW; output_index=1; +#elif defined(BENCH_ATEN_MM) + sizes[0]=(size_t)M*K; sizes[1]=(size_t)K*N; sizes[2]=(size_t)M*N; output_index=2; is_f64=1; +#elif defined(BENCH_ATEN_MV) + sizes[0]=(size_t)M*K; sizes[1]=K; sizes[2]=M; output_index=2; is_f64=1; +#elif defined(BENCH_ATEN_RMS_NORM) + sizes[0]=sizes[1]=sizes[2]=N; output_index=2; +#elif defined(BENCH_ATEN_SOFTMAX) + sizes[0]=N; output_index=0; +#endif + + for (int p = 0; p < 6; ++p) { + if (!sizes[p]) continue; + size_t bytes = sizes[p] * (is_f64 ? sizeof(double) : sizeof(float)); +#ifdef DEVICE_RESIDENT + CUDA_CHECK(cudaMalloc(&raised[p], bytes)); +#else + raised[p] = malloc(bytes); +#endif + reference[p] = malloc(bytes); + if (!raised[p] || !reference[p]) return 2; +#ifdef DEVICE_RESIDENT + if (is_f64) fill_f64(reference[p], sizes[p], p + 1); + else fill_f32(reference[p], sizes[p], p + 1); + CUDA_CHECK(cudaMemcpy(raised[p], reference[p], bytes, + cudaMemcpyHostToDevice)); +#else + if (is_f64) fill_f64(raised[p], sizes[p], p + 1); + else fill_f32(raised[p], sizes[p], p + 1); + memcpy(reference[p], raised[p], bytes); +#endif + } + +#if defined(BENCH_ATEN_BATCH_NORM) + // inv_std is mathematically positive in inference. cuDNN accepts variance + // and epsilon, so use valid inverse standard deviations that can be + // reconstructed without losing a sign. + for (size_t c = 0; c < C; ++c) { + ((float *)reference[3])[c] = 0.75f + 0.005f * (float)(c % 41); +#ifndef DEVICE_RESIDENT + ((float *)raised[3])[c] = ((float *)reference[3])[c]; +#endif + } +#ifdef DEVICE_RESIDENT + CUDA_CHECK(cudaMemcpy(raised[3], reference[3], C * sizeof(float), + cudaMemcpyHostToDevice)); +#endif +#endif + + call_reference(reference); + call_raised(raised); + double max_abs, max_rel; +#ifdef DEVICE_RESIDENT + void *actual = malloc(output_size() * (is_f64 ? sizeof(double) : sizeof(float))); + if (!actual) return 2; + CUDA_CHECK(cudaMemcpy(actual, raised[output_index], + output_size() * (is_f64 ? sizeof(double) : sizeof(float)), + cudaMemcpyDeviceToHost)); +#else + void *actual = raised[output_index]; +#endif + int correct = is_f64 + ? compare_f64(actual, reference[output_index], + output_size(), &max_abs, &max_rel) + : compare_f32(actual, reference[output_index], + output_size(), &max_abs, &max_rel); +#ifdef DEVICE_RESIDENT + free(actual); +#endif + printf("kernel=%s correctness=%s max_abs=%.17g max_rel=%.17g\n", + BENCH_NAME, correct ? "PASS" : "FAIL", max_abs, max_rel); + if (!correct) return 1; + + call_raised(raised); + const double start = seconds(); + for (int i = 0; i < BENCH_ITERS; ++i) call_raised(raised); + const double runtime_us = (seconds() - start) * 1.0e6 / BENCH_ITERS; +#ifdef DEVICE_RESIDENT + printf("kernel=%s mode=raised_device iterations=%d raised_device_us=%.6f\n", + BENCH_NAME, BENCH_ITERS, runtime_us); +#else + printf("kernel=%s iterations=%d raised_gpu_us=%.6f\n", + BENCH_NAME, BENCH_ITERS, runtime_us); +#endif + for (int p = 0; p < 6; ++p) { +#ifdef DEVICE_RESIDENT + if (raised[p]) CUDA_CHECK(cudaFree(raised[p])); +#else + free(raised[p]); +#endif + free(reference[p]); + } + return 0; +} diff --git a/issues/aten_c_kernels/benchmarks/aten_resident_cuda_baseline.cu b/issues/aten_c_kernels/benchmarks/aten_resident_cuda_baseline.cu new file mode 100644 index 000000000000..e72ab191d746 --- /dev/null +++ b/issues/aten_c_kernels/benchmarks/aten_resident_cuda_baseline.cu @@ -0,0 +1,184 @@ +#include +#include +#include + +#include +#include +#include +#include +#include + +// Shape macros are defined only after CUDA/cuBLAS/cuDNN headers. Short names +// such as B and C otherwise rewrite parameter names inside vendor headers. +#ifdef ATEN_B +#define B ATEN_B +#endif +#ifdef ATEN_C +#define C ATEN_C +#endif +#ifdef ATEN_H +#define H ATEN_H +#endif +#ifdef ATEN_W +#define W ATEN_W +#endif +#ifdef ATEN_M +#define M ATEN_M +#endif +#ifdef ATEN_N +#define N ATEN_N +#endif +#ifdef ATEN_K +#define K ATEN_K +#endif +#ifdef ATEN_IC +#define IC ATEN_IC +#endif +#ifdef ATEN_OC +#define OC ATEN_OC +#endif +#ifdef ATEN_KH +#define KH ATEN_KH +#endif +#ifdef ATEN_KW +#define KW ATEN_KW +#endif +#ifdef ATEN_S +#define S ATEN_S +#endif + +#ifndef BENCH_ITERS +#define BENCH_ITERS 20 +#endif + +#define CUDA_OK(x) do { cudaError_t e=(x); if(e!=cudaSuccess){std::fprintf(stderr,"CUDA: %s\n",cudaGetErrorString(e)); return 2;} } while(0) +#define BLAS_OK(x) do { cublasStatus_t e=(x); if(e!=CUBLAS_STATUS_SUCCESS){std::fprintf(stderr,"cuBLAS: %d\n",(int)e); return 2;} } while(0) +#define DNN_OK(x) do { cudnnStatus_t e=(x); if(e!=CUDNN_STATUS_SUCCESS){std::fprintf(stderr,"cuDNN: %s\n",cudnnGetErrorString(e)); return 2;} } while(0) + +static double value(size_t i, int salt) { + int centered=(int)((i*17+(size_t)salt*13+5)%101)-50; + return (double)centered/257.0; +} +template static void fill(std::vector& v,int salt){for(size_t i=0;i static double max_error(const std::vector& a,const std::vector& b){double m=0;for(size_t i=0;i>=1){if(t>=1){if(th,&one,c->d,c->a,&one,c->d,c->o);} +int main(){size_t n=(size_t)B*C*H*W;std::vectora(n),o(n),ref;fill(a,1);fill(o,2);ref=o;aten_add_reference(a.data(),ref.data());Ctx c;DNN_OK(cudnnCreate(&c.h));DNN_OK(cudnnCreateTensorDescriptor(&c.d));DNN_OK(cudnnSetTensor4dDescriptor(c.d,CUDNN_TENSOR_NCHW,CUDNN_DATA_FLOAT,B,C,H,W));CUDA_OK(cudaMalloc(&c.a,n*4));CUDA_OK(cudaMalloc(&c.o,n*4));CUDA_OK(cudaMemcpy(c.a,a.data(),n*4,cudaMemcpyHostToDevice));CUDA_OK(cudaMemcpy(c.o,o.data(),n*4,cudaMemcpyHostToDevice)); +#elif defined(BENCH_ATEN_BATCH_NORM) +extern "C" void aten_batch_norm_reference(float*,float*,float*,float*,float*,float*); +struct Ctx{cudnnHandle_t h;cudnnTensorDescriptor_t xd,bn;float*dx,*s,*m,*v,*b,*o;}; +static void launch(void*p){auto*c=(Ctx*)p;float one=1,zero=0;cudnnBatchNormalizationForwardInference(c->h,CUDNN_BATCHNORM_SPATIAL,&one,&zero,c->xd,c->dx,c->xd,c->o,c->bn,c->s,c->b,c->m,c->v,1e-5);} +int main(){size_t n=(size_t)B*C*H*W;std::vectorx(n),s(C),m(C),is(C),b(C),o(n),ref(n),var(C);fill(x,1);fill(s,2);fill(m,3);fill(b,4);for(int i=0;ih,&one,c->xd,c->dx,c->fd,c->df,c->conv,c->algo,c->ws,c->wsz,&zero,c->yd,c->dy);} +int main(){size_t nx=(size_t)B*IC*H*W,nf=(size_t)OC*IC*KH*KW,ny=(size_t)B*OC*OH*OW;std::vectorx(nx),f(nf),o(ny),ref(ny);fill(x,1);fill(f,2);aten_conv2d_reference(x.data(),f.data(),ref.data());Ctx c;DNN_OK(cudnnCreate(&c.h));DNN_OK(cudnnCreateTensorDescriptor(&c.xd));DNN_OK(cudnnCreateTensorDescriptor(&c.yd));DNN_OK(cudnnCreateFilterDescriptor(&c.fd));DNN_OK(cudnnCreateConvolutionDescriptor(&c.conv));DNN_OK(cudnnSetTensor4dDescriptor(c.xd,CUDNN_TENSOR_NCHW,CUDNN_DATA_FLOAT,B,IC,H,W));DNN_OK(cudnnSetTensor4dDescriptor(c.yd,CUDNN_TENSOR_NCHW,CUDNN_DATA_FLOAT,B,OC,OH,OW));DNN_OK(cudnnSetFilter4dDescriptor(c.fd,CUDNN_DATA_FLOAT,CUDNN_TENSOR_NCHW,OC,IC,KH,KW));DNN_OK(cudnnSetConvolution2dDescriptor(c.conv,0,0,1,1,1,1,CUDNN_CROSS_CORRELATION,CUDNN_DATA_FLOAT));int got=0;cudnnConvolutionFwdAlgoPerf_t perf;DNN_OK(cudnnGetConvolutionForwardAlgorithm_v7(c.h,c.xd,c.fd,c.conv,c.yd,1,&got,&perf));c.algo=perf.algo;DNN_OK(cudnnGetConvolutionForwardWorkspaceSize(c.h,c.xd,c.fd,c.conv,c.yd,c.algo,&c.wsz));CUDA_OK(cudaMalloc(&c.dx,nx*4));CUDA_OK(cudaMalloc(&c.df,nf*4));CUDA_OK(cudaMalloc(&c.dy,ny*4));c.ws=nullptr;if(c.wsz)CUDA_OK(cudaMalloc(&c.ws,c.wsz));CUDA_OK(cudaMemcpy(c.dx,x.data(),nx*4,cudaMemcpyHostToDevice));CUDA_OK(cudaMemcpy(c.df,f.data(),nf*4,cudaMemcpyHostToDevice)); +#elif defined(BENCH_ATEN_MAX_POOL2D) +extern "C" void aten_max_pool2d_reference(float*,float*); +#define OH ((H-K)/S+1) +#define OW ((W-K)/S+1) +struct Ctx{cudnnHandle_t h;cudnnTensorDescriptor_t xd,yd;cudnnPoolingDescriptor_t pool;float*dx,*dy;}; +static void launch(void*p){auto*c=(Ctx*)p;float one=1,zero=0;cudnnPoolingForward(c->h,c->pool,&one,c->xd,c->dx,&zero,c->yd,c->dy);} +int main(){size_t nx=(size_t)B*C*H*W,ny=(size_t)B*C*OH*OW;std::vectorx(nx),o(ny),ref(ny);fill(x,1);aten_max_pool2d_reference(x.data(),ref.data());Ctx c;DNN_OK(cudnnCreate(&c.h));DNN_OK(cudnnCreateTensorDescriptor(&c.xd));DNN_OK(cudnnCreateTensorDescriptor(&c.yd));DNN_OK(cudnnCreatePoolingDescriptor(&c.pool));DNN_OK(cudnnSetTensor4dDescriptor(c.xd,CUDNN_TENSOR_NCHW,CUDNN_DATA_FLOAT,B,C,H,W));DNN_OK(cudnnSetTensor4dDescriptor(c.yd,CUDNN_TENSOR_NCHW,CUDNN_DATA_FLOAT,B,C,OH,OW));DNN_OK(cudnnSetPooling2dDescriptor(c.pool,CUDNN_POOLING_MAX,CUDNN_NOT_PROPAGATE_NAN,K,K,0,0,S,S));CUDA_OK(cudaMalloc(&c.dx,nx*4));CUDA_OK(cudaMalloc(&c.dy,ny*4));CUDA_OK(cudaMemcpy(c.dx,x.data(),nx*4,cudaMemcpyHostToDevice)); +#elif defined(BENCH_ATEN_SOFTMAX) +extern "C" void aten_softmax_reference(float*); +struct Ctx{cudnnHandle_t h;cudnnTensorDescriptor_t d;float*x;};static void launch(void*p){auto*c=(Ctx*)p;float one=1,zero=0;cudnnSoftmaxForward(c->h,CUDNN_SOFTMAX_ACCURATE,CUDNN_SOFTMAX_MODE_INSTANCE,&one,c->d,c->x,&zero,c->d,c->x);} +int main(){size_t n=N;std::vectoro(n),ref;fill(o,1);ref=o;aten_softmax_reference(ref.data());Ctx c;DNN_OK(cudnnCreate(&c.h));DNN_OK(cudnnCreateTensorDescriptor(&c.d));DNN_OK(cudnnSetTensor4dDescriptor(c.d,CUDNN_TENSOR_NCHW,CUDNN_DATA_FLOAT,1,N,1,1));CUDA_OK(cudaMalloc(&c.x,n*4));CUDA_OK(cudaMemcpy(c.x,o.data(),n*4,cudaMemcpyHostToDevice)); +#elif defined(BENCH_ATEN_ADDMM) || defined(BENCH_ATEN_MM) +#if defined(BENCH_ATEN_ADDMM) +extern "C" void aten_addmm_reference(double*,double*,double*,double,double); +#else +extern "C" void aten_mm_reference(double*,double*,double*); +#endif +struct Ctx{cublasHandle_t h;double*a,*b,*c;};static void launch(void*p){auto*c=(Ctx*)p; +#if defined(BENCH_ATEN_ADDMM) +double alpha=1.25,beta=.5; +#else +double alpha=1,beta=0; +#endif +cublasDgemm(c->h,CUBLAS_OP_N,CUBLAS_OP_N,N,M,K,&alpha,c->b,N,c->a,K,&beta,c->c,N);} +int main(){size_t na=(size_t)M*K,nb=(size_t)K*N,nc=(size_t)M*N;std::vectora(na),b(nb),o(nc),ref;fill(a,1);fill(b,2);fill(o,3);ref=o; +#if defined(BENCH_ATEN_ADDMM) +aten_addmm_reference(a.data(),b.data(),ref.data(),.5,1.25); +#else +aten_mm_reference(a.data(),b.data(),ref.data()); +#endif +Ctx c;BLAS_OK(cublasCreate(&c.h));CUDA_OK(cudaMalloc(&c.a,na*8));CUDA_OK(cudaMalloc(&c.b,nb*8));CUDA_OK(cudaMalloc(&c.c,nc*8));CUDA_OK(cudaMemcpy(c.a,a.data(),na*8,cudaMemcpyHostToDevice));CUDA_OK(cudaMemcpy(c.b,b.data(),nb*8,cudaMemcpyHostToDevice));CUDA_OK(cudaMemcpy(c.c,o.data(),nc*8,cudaMemcpyHostToDevice)); +#elif defined(BENCH_ATEN_DOT) +extern "C" void aten_dot_reference(double*,double*,double*);struct Ctx{cublasHandle_t h;double*x,*y,*o;};static void launch(void*p){auto*c=(Ctx*)p;cublasDdot(c->h,N,c->x,1,c->y,1,c->o);}int main(){std::vectorx(N),y(N),o(1),ref(1);fill(x,1);fill(y,2);aten_dot_reference(x.data(),y.data(),ref.data());Ctx c;BLAS_OK(cublasCreate(&c.h));BLAS_OK(cublasSetPointerMode(c.h,CUBLAS_POINTER_MODE_DEVICE));CUDA_OK(cudaMalloc(&c.x,N*8));CUDA_OK(cudaMalloc(&c.y,N*8));CUDA_OK(cudaMalloc(&c.o,8));CUDA_OK(cudaMemcpy(c.x,x.data(),N*8,cudaMemcpyHostToDevice));CUDA_OK(cudaMemcpy(c.y,y.data(),N*8,cudaMemcpyHostToDevice)); +#elif defined(BENCH_ATEN_MV) +extern "C" void aten_mv_reference(double*,double*,double*);struct Ctx{cublasHandle_t h;double*a,*x,*y;};static void launch(void*p){auto*c=(Ctx*)p;double one=1;cublasDgemv(c->h,CUBLAS_OP_T,K,M,&one,c->a,K,c->x,1,&one,c->y,1);}int main(){size_t na=(size_t)M*K;std::vectora(na),x(K),o(M),ref;fill(a,1);fill(x,2);fill(o,3);ref=o;aten_mv_reference(a.data(),x.data(),ref.data());Ctx c;BLAS_OK(cublasCreate(&c.h));CUDA_OK(cudaMalloc(&c.a,na*8));CUDA_OK(cudaMalloc(&c.x,K*8));CUDA_OK(cudaMalloc(&c.y,M*8));CUDA_OK(cudaMemcpy(c.a,a.data(),na*8,cudaMemcpyHostToDevice));CUDA_OK(cudaMemcpy(c.x,x.data(),K*8,cudaMemcpyHostToDevice));CUDA_OK(cudaMemcpy(c.y,o.data(),M*8,cudaMemcpyHostToDevice)); +#elif defined(BENCH_ATEN_GELU) +extern "C" void aten_gelu_reference(float*,float*);struct Ctx{float*x,*y;};static void launch(void*p){auto*c=(Ctx*)p;gelu_kernel<<<(N+255)/256,256>>>(c->x,c->y,N);}int main(){std::vectorx(N),o(N),ref(N);fill(x,1);aten_gelu_reference(x.data(),ref.data());Ctx c;CUDA_OK(cudaMalloc(&c.x,N*4));CUDA_OK(cudaMalloc(&c.y,N*4));CUDA_OK(cudaMemcpy(c.x,x.data(),N*4,cudaMemcpyHostToDevice)); +#elif defined(BENCH_ATEN_RMS_NORM) +extern "C" void aten_rms_norm_reference(float*,float*,float*,float);struct Ctx{float*x,*w,*y,*p,*scale;int blocks;};static void launch(void*p){auto*c=(Ctx*)p;rms_partial<<blocks,256>>>(c->x,c->p,N);rms_finish<<<1,256>>>(c->p,c->scale,N,c->blocks);rms_scale<<<(N+255)/256,256>>>(c->x,c->w,c->y,c->scale,N);}int main(){std::vectorx(N),w(N),o(N),ref(N);fill(x,1);fill(w,2);aten_rms_norm_reference(x.data(),w.data(),ref.data(),1e-5f);Ctx c;c.blocks=(N+511)/512;CUDA_OK(cudaMalloc(&c.x,N*4));CUDA_OK(cudaMalloc(&c.w,N*4));CUDA_OK(cudaMalloc(&c.y,N*4));CUDA_OK(cudaMalloc(&c.p,c.blocks*4));CUDA_OK(cudaMalloc(&c.scale,4));CUDA_OK(cudaMemcpy(c.x,x.data(),N*4,cudaMemcpyHostToDevice));CUDA_OK(cudaMemcpy(c.w,w.data(),N*4,cudaMemcpyHostToDevice)); +#else +#error Select BENCH_ATEN_* +#endif + + launch(&c); CUDA_OK(cudaDeviceSynchronize()); +#if defined(BENCH_ATEN_ADD) + CUDA_OK(cudaMemcpy(o.data(),c.o,n*4,cudaMemcpyDeviceToHost)); const char*name="aten_add"; +#elif defined(BENCH_ATEN_BATCH_NORM) + CUDA_OK(cudaMemcpy(o.data(),c.o,n*4,cudaMemcpyDeviceToHost)); const char*name="aten_batch_norm"; +#elif defined(BENCH_ATEN_CONV2D) + CUDA_OK(cudaMemcpy(o.data(),c.dy,ny*4,cudaMemcpyDeviceToHost)); const char*name="aten_conv2d"; +#elif defined(BENCH_ATEN_MAX_POOL2D) + CUDA_OK(cudaMemcpy(o.data(),c.dy,ny*4,cudaMemcpyDeviceToHost)); const char*name="aten_max_pool2d"; +#elif defined(BENCH_ATEN_SOFTMAX) + CUDA_OK(cudaMemcpy(o.data(),c.x,n*4,cudaMemcpyDeviceToHost)); const char*name="aten_softmax"; +#elif defined(BENCH_ATEN_ADDMM) + CUDA_OK(cudaMemcpy(o.data(),c.c,nc*8,cudaMemcpyDeviceToHost)); const char*name="aten_addmm"; +#elif defined(BENCH_ATEN_MM) + CUDA_OK(cudaMemcpy(o.data(),c.c,nc*8,cudaMemcpyDeviceToHost)); const char*name="aten_mm"; +#elif defined(BENCH_ATEN_DOT) + CUDA_OK(cudaMemcpy(o.data(),c.o,8,cudaMemcpyDeviceToHost)); const char*name="aten_dot"; +#elif defined(BENCH_ATEN_MV) + CUDA_OK(cudaMemcpy(o.data(),c.y,M*8,cudaMemcpyDeviceToHost)); const char*name="aten_mv"; +#elif defined(BENCH_ATEN_GELU) + CUDA_OK(cudaMemcpy(o.data(),c.y,N*4,cudaMemcpyDeviceToHost)); const char*name="aten_gelu"; +#elif defined(BENCH_ATEN_RMS_NORM) + CUDA_OK(cudaMemcpy(o.data(),c.y,N*4,cudaMemcpyDeviceToHost)); const char*name="aten_rms_norm"; +#endif + double err=max_error(o,ref); + // Restore mutable operands before timing. Repeated calls then measure only + // resident GPU execution, with no setup or host/device transfer included. +#if defined(BENCH_ATEN_ADD) + fill(o,2); CUDA_OK(cudaMemcpy(c.o,o.data(),n*4,cudaMemcpyHostToDevice)); +#elif defined(BENCH_ATEN_ADDMM) + fill(o,3); CUDA_OK(cudaMemcpy(c.c,o.data(),nc*8,cudaMemcpyHostToDevice)); +#elif defined(BENCH_ATEN_MV) + fill(o,3); CUDA_OK(cudaMemcpy(c.y,o.data(),M*8,cudaMemcpyHostToDevice)); +#elif defined(BENCH_ATEN_SOFTMAX) + fill(o,1); CUDA_OK(cudaMemcpy(c.x,o.data(),n*4,cudaMemcpyHostToDevice)); +#endif + cudaEvent_t begin,end; CUDA_OK(cudaEventCreate(&begin)); CUDA_OK(cudaEventCreate(&end)); + float us=timed(begin,end,launch,&c); +#if defined(BENCH_ATEN_RMS_NORM) + // At very large N the scalar reference's strict float accumulation drifts + // from both the CUDA tree reduction and a double-precision sum. Use the + // same reassociation-aware bound as the raised harness. + const double tolerance = 2e-3; +#else + const double tolerance = 2e-4; +#endif + std::printf("kernel=%s correctness=%s max_abs=%.17g iterations=%d resident_cuda_us=%.6f\n",name,err, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_abs(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.cmpf olt, %0, %cst : f32 + %2 = scf.if %1 -> (f32) { + %3 = arith.negf %0 : f32 + scf.yield %3 : f32 + } else { + scf.yield %0 : f32 + } + affine.store %2, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_abs/debuf.mlir b/issues/aten_c_kernels/results/aten_abs/debuf.mlir new file mode 100644 index 000000000000..eee47a80572f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_abs/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_abs(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %cst : f32 + %5 = arith.negf %in : f32 + %6 = arith.select %4, %5, %in : f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_abs/matched.mlir b/issues/aten_c_kernels/results/aten_abs/matched.mlir new file mode 100644 index 000000000000..eee47a80572f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_abs/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_abs(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %cst : f32 + %5 = arith.negf %in : f32 + %6 = arith.select %4, %5, %in : f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_abs/orig.mlir b/issues/aten_c_kernels/results/aten_abs/orig.mlir new file mode 100644 index 000000000000..eae89955609c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_abs/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_abs(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.cmpf olt, %0, %cst : f32 + %2 = scf.if %1 -> (f32) { + %3 = arith.negf %0 : f32 + scf.yield %3 : f32 + } else { + scf.yield %0 : f32 + } + affine.store %2, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_abs/raised.mlir b/issues/aten_c_kernels/results/aten_abs/raised.mlir new file mode 100644 index 000000000000..ff2511595ef1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_abs/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_abs(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %cst : f32 + %1 = arith.negf %in : f32 + %2 = arith.select %0, %1, %in : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_abs_debuf.mlir b/issues/aten_c_kernels/results/aten_abs_debuf.mlir new file mode 100644 index 000000000000..eee47a80572f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_abs_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_abs(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %cst : f32 + %5 = arith.negf %in : f32 + %6 = arith.select %4, %5, %in : f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_abs_linalg.mlir b/issues/aten_c_kernels/results/aten_abs_linalg.mlir new file mode 100644 index 000000000000..ff2511595ef1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_abs_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_abs(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %cst : f32 + %1 = arith.negf %in : f32 + %2 = arith.select %0, %1, %in : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_acos.mlir b/issues/aten_c_kernels/results/aten_acos.mlir new file mode 100644 index 000000000000..6de88117f844 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_acos.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_acos(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @acosf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @acosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_acos/debuf.mlir b/issues/aten_c_kernels/results/aten_acos/debuf.mlir new file mode 100644 index 000000000000..3c446e86e566 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_acos/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_acos(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @acosf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @acosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_acos/matched.mlir b/issues/aten_c_kernels/results/aten_acos/matched.mlir new file mode 100644 index 000000000000..3c446e86e566 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_acos/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_acos(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @acosf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @acosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_acos/orig.mlir b/issues/aten_c_kernels/results/aten_acos/orig.mlir new file mode 100644 index 000000000000..6de88117f844 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_acos/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_acos(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @acosf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @acosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_acos/raised.mlir b/issues/aten_c_kernels/results/aten_acos/raised.mlir new file mode 100644 index 000000000000..2a9caa0c3f6e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_acos/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_acos(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @acosf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @acosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_acos_debuf.mlir b/issues/aten_c_kernels/results/aten_acos_debuf.mlir new file mode 100644 index 000000000000..3c446e86e566 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_acos_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_acos(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @acosf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @acosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_acos_linalg.mlir b/issues/aten_c_kernels/results/aten_acos_linalg.mlir new file mode 100644 index 000000000000..2a9caa0c3f6e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_acos_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_acos(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @acosf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @acosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_acosh.mlir b/issues/aten_c_kernels/results/aten_acosh.mlir new file mode 100644 index 000000000000..40cd53f09c24 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_acosh.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_acosh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @acoshf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @acoshf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_acosh/debuf.mlir b/issues/aten_c_kernels/results/aten_acosh/debuf.mlir new file mode 100644 index 000000000000..d00243b6f675 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_acosh/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_acosh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @acoshf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @acoshf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_acosh/matched.mlir b/issues/aten_c_kernels/results/aten_acosh/matched.mlir new file mode 100644 index 000000000000..d00243b6f675 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_acosh/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_acosh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @acoshf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @acoshf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_acosh/orig.mlir b/issues/aten_c_kernels/results/aten_acosh/orig.mlir new file mode 100644 index 000000000000..40cd53f09c24 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_acosh/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_acosh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @acoshf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @acoshf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_acosh/raised.mlir b/issues/aten_c_kernels/results/aten_acosh/raised.mlir new file mode 100644 index 000000000000..0e0a37461c87 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_acosh/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_acosh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @acoshf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @acoshf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_acosh_debuf.mlir b/issues/aten_c_kernels/results/aten_acosh_debuf.mlir new file mode 100644 index 000000000000..d00243b6f675 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_acosh_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_acosh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @acoshf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @acoshf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_acosh_linalg.mlir b/issues/aten_c_kernels/results/aten_acosh_linalg.mlir new file mode 100644 index 000000000000..0e0a37461c87 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_acosh_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_acosh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @acoshf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @acoshf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d.mlir new file mode 100644 index 000000000000..339d94982c69 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d.mlir @@ -0,0 +1,33 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.500000e-01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + affine.store %cst_0, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 2 { + %0 = affine.load %arg0[%arg2, %arg3, %arg6 + %arg4 * 2, %arg7 + %arg5 * 2] : memref + %1 = arith.mulf %0, %cst : f32 + %2 = affine.load %arg1[%arg2, %arg3, %arg4, %arg5] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d/debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d/debuf.mlir new file mode 100644 index 000000000000..62b7d48ccd1b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d/debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2 * 2, d5 + d3 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 2.500000e-01 : f32 + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c4, %c4, %c4, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%3 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.mulf %in, %cst_0 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d/matched.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d/matched.mlir new file mode 100644 index 000000000000..62b7d48ccd1b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d/matched.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2 * 2, d5 + d3 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 2.500000e-01 : f32 + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c4, %c4, %c4, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%3 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.mulf %in, %cst_0 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d/orig.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d/orig.mlir new file mode 100644 index 000000000000..339d94982c69 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d/orig.mlir @@ -0,0 +1,33 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.500000e-01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + affine.store %cst_0, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 2 { + %0 = affine.load %arg0[%arg2, %arg3, %arg6 + %arg4 * 2, %arg7 + %arg5 * 2] : memref + %1 = arith.mulf %0, %cst : f32 + %2 = affine.load %arg1[%arg2, %arg3, %arg4, %arg5] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d/raised.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d/raised.mlir new file mode 100644 index 000000000000..40e05dceed51 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d/raised.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2 * 2, d5 + d3 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 2.500000e-01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg1[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c4, %c4, %c4, %c2, %c2) {map = #map1} : (memref, index, index, index, index, index, index) -> memref + %subview_1 = memref.subview %arg1[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"]} ins(%0 : memref) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.mulf %in, %cst : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu.mlir new file mode 100644 index 000000000000..33fe92c060f1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu.mlir @@ -0,0 +1,67 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c42 = arith.constant 42 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c3_i32 = arith.constant 3 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c2_i32 = arith.constant 2 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg2 = 0 to 84 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.muli %arg2, %c42 : index + affine.for %arg3 = 0 to 3 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = arith.muli %1, %c6_i32 : i32 + %3 = arith.divsi %2, %c3_i32 : i32 + %4 = arith.addi %1, %c1_i32 : i32 + %5 = arith.muli %4, %c6_i32 : i32 + %6 = arith.addi %5, %c2_i32 : i32 + %7 = arith.divsi %6, %c3_i32 : i32 + %8 = arith.subi %7, %3 : i32 + affine.for %arg4 = 0 to 3 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c7_i32 : i32 + %11 = arith.divsi %10, %c3_i32 : i32 + %12 = arith.addi %9, %c1_i32 : i32 + %13 = arith.muli %12, %c7_i32 : i32 + %14 = arith.addi %13, %c2_i32 : i32 + %15 = arith.divsi %14, %c3_i32 : i32 + %16 = arith.subi %15, %11 : i32 + %17 = arith.muli %8, %16 : i32 + %18 = arith.sitofp %17 : i32 to f32 + %19 = arith.muli %arg4, %c7 : index + %20 = arith.cmpi slt, %19, %c0 : index + %21 = arith.subi %c-1, %19 : index + %22 = arith.select %20, %21, %19 : index + %23 = arith.divsi %22, %c3 : index + %24 = arith.subi %c-1, %23 : index + %25 = arith.select %20, %24, %23 : index + %26 = arith.addi %25, %c3 : index + affine.for %arg5 = #map(%arg3) to #map1(%arg3) { + %27 = arith.muli %arg5, %c7 : index + scf.for %arg6 = %25 to %26 step %c1 { + %28 = affine.load %arg0[%arg4 + %arg2 * 9 + %arg3 * 3] : memref + %29 = arith.divf %28, %18 : f32 + %30 = arith.addi %arg6, %0 : index + %31 = arith.addi %30, %27 : index + %32 = memref.load %arg1[%31] : memref + %33 = arith.addf %32, %29 : f32 + memref.store %33, %arg1[%31] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..948a79c56ac9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu/debuf.mlir @@ -0,0 +1,81 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 * 2)> +#map2 = affine_map<(d0) -> (d0 * 2 + 2)> +#map3 = affine_map<(d0, d1, d2) -> (d0 + d1 * 9 + d2 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c2_i32 = arith.constant 2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c3_i32 = arith.constant 3 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c42 = arith.constant 42 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.muli %arg2, %c42 : index + %6 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %7 = arith.index_cast %arg4 : index to i32 + %8 = arith.muli %7, %c6_i32 : i32 + %9 = arith.divsi %8, %c3_i32 : i32 + %10 = arith.addi %7, %c1_i32 : i32 + %11 = arith.muli %10, %c6_i32 : i32 + %12 = arith.addi %11, %c2_i32 : i32 + %13 = arith.divsi %12, %c3_i32 : i32 + %14 = arith.subi %13, %9 : i32 + %15 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg5) -> (tensor) { + %16 = arith.index_cast %arg6 : index to i32 + %17 = arith.muli %16, %c7_i32 : i32 + %18 = arith.divsi %17, %c3_i32 : i32 + %19 = arith.addi %16, %c1_i32 : i32 + %20 = arith.muli %19, %c7_i32 : i32 + %21 = arith.addi %20, %c2_i32 : i32 + %22 = arith.divsi %21, %c3_i32 : i32 + %23 = arith.subi %22, %18 : i32 + %24 = arith.muli %14, %23 : i32 + %25 = arith.sitofp %24 : i32 to f32 + %26 = arith.muli %arg6, %c7 : index + %27 = arith.cmpi slt, %26, %c0 : index + %28 = arith.subi %c-1, %26 : index + %29 = arith.select %27, %28, %26 : index + %30 = arith.divsi %29, %c3 : index + %31 = arith.subi %c-1, %30 : index + %32 = arith.select %27, %31, %30 : index + %33 = arith.addi %32, %c3 : index + %34 = affine.for %arg8 = #map1(%arg4) to #map2(%arg4) iter_args(%arg9 = %arg7) -> (tensor) { + %35 = arith.muli %arg8, %c7 : index + %36 = scf.for %arg10 = %32 to %33 step %c1 iter_args(%arg11 = %arg9) -> (tensor) { + %37 = affine.apply #map3(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%37] : tensor + %38 = arith.divf %extracted, %25 : f32 + %39 = arith.addi %arg10, %5 : index + %40 = arith.addi %39, %35 : index + %extracted_0 = tensor.extract %arg11[%40] : tensor + %41 = arith.addf %extracted_0, %38 : f32 + %inserted = tensor.insert %41 into %arg11[%40] : tensor + scf.yield %inserted : tensor + } + affine.yield %36 : tensor + } + affine.yield %34 : tensor + } + affine.yield %15 : tensor + } + affine.yield %6 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..0d1ef55cc336 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu/matched.mlir @@ -0,0 +1,78 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 * 2)> +#map2 = affine_map<(d0) -> (d0 * 2 + 2)> +#map3 = affine_map<(d0, d1, d2) -> (d0 + d1 * 9 + d2 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c2_i32 = arith.constant 2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c3_i32 = arith.constant 3 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c42 = arith.constant 42 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.muli %arg2, %c42 : index + %6 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %7 = arith.index_cast %arg4 : index to i32 + %8 = arith.muli %7, %c6_i32 : i32 + %9 = arith.divsi %8, %c3_i32 : i32 + %10 = arith.addi %7, %c1_i32 : i32 + %11 = arith.muli %10, %c6_i32 : i32 + %12 = arith.addi %11, %c2_i32 : i32 + %13 = arith.divsi %12, %c3_i32 : i32 + %14 = arith.subi %13, %9 : i32 + %15 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg5) -> (tensor) { + %16 = arith.index_cast %arg6 : index to i32 + %17 = arith.muli %16, %c7_i32 : i32 + %18 = arith.divsi %17, %c3_i32 : i32 + %19 = arith.addi %16, %c1_i32 : i32 + %20 = arith.muli %19, %c7_i32 : i32 + %21 = arith.addi %20, %c2_i32 : i32 + %22 = arith.divsi %21, %c3_i32 : i32 + %23 = arith.subi %22, %18 : i32 + %24 = arith.muli %14, %23 : i32 + %25 = arith.sitofp %24 : i32 to f32 + %26 = arith.muli %arg6, %c7 : index + %27 = arith.cmpi slt, %26, %c0 : index + %28 = arith.subi %c-1, %26 : index + %29 = arith.select %27, %28, %26 : index + %30 = arith.divsi %29, %c3 : index + %31 = arith.subi %c-1, %30 : index + %32 = arith.select %27, %31, %30 : index + %33 = arith.addi %32, %c3 : index + %34 = affine.for %arg8 = #map1(%arg4) to #map2(%arg4) iter_args(%arg9 = %arg7) -> (tensor) { + %35 = arith.muli %arg8, %c7 : index + %36 = scf.for %arg10 = %32 to %33 step %c1 iter_args(%arg11 = %arg9) -> (tensor) { + %37 = affine.apply #map3(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%37] : tensor + %38 = arith.divf %extracted, %25 : f32 + %39 = arith.addi %arg10, %5 : index + %40 = arith.addi %39, %35 : index + %extracted_0 = tensor.extract %arg11[%40] : tensor + %41 = arith.addf %extracted_0, %38 : f32 + %inserted = tensor.insert %41 into %arg11[%40] : tensor + scf.yield %inserted : tensor + } + affine.yield %36 : tensor + } + affine.yield %34 : tensor + } + affine.yield %15 : tensor + } + affine.yield %6 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..33fe92c060f1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu/orig.mlir @@ -0,0 +1,67 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c42 = arith.constant 42 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c3_i32 = arith.constant 3 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c2_i32 = arith.constant 2 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg2 = 0 to 84 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.muli %arg2, %c42 : index + affine.for %arg3 = 0 to 3 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = arith.muli %1, %c6_i32 : i32 + %3 = arith.divsi %2, %c3_i32 : i32 + %4 = arith.addi %1, %c1_i32 : i32 + %5 = arith.muli %4, %c6_i32 : i32 + %6 = arith.addi %5, %c2_i32 : i32 + %7 = arith.divsi %6, %c3_i32 : i32 + %8 = arith.subi %7, %3 : i32 + affine.for %arg4 = 0 to 3 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c7_i32 : i32 + %11 = arith.divsi %10, %c3_i32 : i32 + %12 = arith.addi %9, %c1_i32 : i32 + %13 = arith.muli %12, %c7_i32 : i32 + %14 = arith.addi %13, %c2_i32 : i32 + %15 = arith.divsi %14, %c3_i32 : i32 + %16 = arith.subi %15, %11 : i32 + %17 = arith.muli %8, %16 : i32 + %18 = arith.sitofp %17 : i32 to f32 + %19 = arith.muli %arg4, %c7 : index + %20 = arith.cmpi slt, %19, %c0 : index + %21 = arith.subi %c-1, %19 : index + %22 = arith.select %20, %21, %19 : index + %23 = arith.divsi %22, %c3 : index + %24 = arith.subi %c-1, %23 : index + %25 = arith.select %20, %24, %23 : index + %26 = arith.addi %25, %c3 : index + affine.for %arg5 = #map(%arg3) to #map1(%arg3) { + %27 = arith.muli %arg5, %c7 : index + scf.for %arg6 = %25 to %26 step %c1 { + %28 = affine.load %arg0[%arg4 + %arg2 * 9 + %arg3 * 3] : memref + %29 = arith.divf %28, %18 : f32 + %30 = arith.addi %arg6, %0 : index + %31 = arith.addi %30, %27 : index + %32 = memref.load %arg1[%31] : memref + %33 = arith.addf %32, %29 : f32 + memref.store %33, %arg1[%31] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..8b26d1d8b971 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu/raised.mlir @@ -0,0 +1,70 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 * 2)> +#map2 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c42 = arith.constant 42 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c3_i32 = arith.constant 3 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1 = arith.constant 1 : index + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.muli %arg2, %c42 : index + affine.for %arg3 = 0 to 3 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = arith.muli %1, %c6_i32 : i32 + %3 = arith.divsi %2, %c3_i32 : i32 + %4 = arith.addi %1, %c1_i32 : i32 + %5 = arith.muli %4, %c6_i32 : i32 + %6 = arith.addi %5, %c2_i32 : i32 + %7 = arith.divsi %6, %c3_i32 : i32 + %8 = arith.subi %7, %3 : i32 + affine.for %arg4 = 0 to 3 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c7_i32 : i32 + %11 = arith.divsi %10, %c3_i32 : i32 + %12 = arith.addi %9, %c1_i32 : i32 + %13 = arith.muli %12, %c7_i32 : i32 + %14 = arith.addi %13, %c2_i32 : i32 + %15 = arith.divsi %14, %c3_i32 : i32 + %16 = arith.subi %15, %11 : i32 + %17 = arith.muli %8, %16 : i32 + %18 = arith.sitofp %17 : i32 to f32 + %19 = arith.muli %arg4, %c7 : index + %20 = arith.cmpi slt, %19, %c0 : index + %21 = arith.subi %c-1, %19 : index + %22 = arith.select %20, %21, %19 : index + %23 = arith.divsi %22, %c3 : index + %24 = arith.subi %c-1, %23 : index + %25 = arith.select %20, %24, %23 : index + %26 = arith.addi %25, %c3 : index + affine.for %arg5 = #map1(%arg3) to #map2(%arg3) { + %27 = arith.muli %arg5, %c7 : index + scf.for %arg6 = %25 to %26 step %c1 { + %28 = affine.load %arg0[%arg4 + %arg2 * 9 + %arg3 * 3] : memref + %29 = arith.divf %28, %18 : f32 + %30 = arith.addi %arg6, %0 : index + %31 = arith.addi %30, %27 : index + %32 = memref.load %arg1[%31] : memref + %33 = arith.addf %32, %29 : f32 + memref.store %33, %arg1[%31] : memref + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..948a79c56ac9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu_debuf.mlir @@ -0,0 +1,81 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 * 2)> +#map2 = affine_map<(d0) -> (d0 * 2 + 2)> +#map3 = affine_map<(d0, d1, d2) -> (d0 + d1 * 9 + d2 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c2_i32 = arith.constant 2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c3_i32 = arith.constant 3 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c42 = arith.constant 42 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.muli %arg2, %c42 : index + %6 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %7 = arith.index_cast %arg4 : index to i32 + %8 = arith.muli %7, %c6_i32 : i32 + %9 = arith.divsi %8, %c3_i32 : i32 + %10 = arith.addi %7, %c1_i32 : i32 + %11 = arith.muli %10, %c6_i32 : i32 + %12 = arith.addi %11, %c2_i32 : i32 + %13 = arith.divsi %12, %c3_i32 : i32 + %14 = arith.subi %13, %9 : i32 + %15 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg5) -> (tensor) { + %16 = arith.index_cast %arg6 : index to i32 + %17 = arith.muli %16, %c7_i32 : i32 + %18 = arith.divsi %17, %c3_i32 : i32 + %19 = arith.addi %16, %c1_i32 : i32 + %20 = arith.muli %19, %c7_i32 : i32 + %21 = arith.addi %20, %c2_i32 : i32 + %22 = arith.divsi %21, %c3_i32 : i32 + %23 = arith.subi %22, %18 : i32 + %24 = arith.muli %14, %23 : i32 + %25 = arith.sitofp %24 : i32 to f32 + %26 = arith.muli %arg6, %c7 : index + %27 = arith.cmpi slt, %26, %c0 : index + %28 = arith.subi %c-1, %26 : index + %29 = arith.select %27, %28, %26 : index + %30 = arith.divsi %29, %c3 : index + %31 = arith.subi %c-1, %30 : index + %32 = arith.select %27, %31, %30 : index + %33 = arith.addi %32, %c3 : index + %34 = affine.for %arg8 = #map1(%arg4) to #map2(%arg4) iter_args(%arg9 = %arg7) -> (tensor) { + %35 = arith.muli %arg8, %c7 : index + %36 = scf.for %arg10 = %32 to %33 step %c1 iter_args(%arg11 = %arg9) -> (tensor) { + %37 = affine.apply #map3(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%37] : tensor + %38 = arith.divf %extracted, %25 : f32 + %39 = arith.addi %arg10, %5 : index + %40 = arith.addi %39, %35 : index + %extracted_0 = tensor.extract %arg11[%40] : tensor + %41 = arith.addf %extracted_0, %38 : f32 + %inserted = tensor.insert %41 into %arg11[%40] : tensor + scf.yield %inserted : tensor + } + affine.yield %36 : tensor + } + affine.yield %34 : tensor + } + affine.yield %15 : tensor + } + affine.yield %6 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..8b26d1d8b971 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_backward_cpu_linalg.mlir @@ -0,0 +1,70 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 * 2)> +#map2 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c42 = arith.constant 42 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c3_i32 = arith.constant 3 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1 = arith.constant 1 : index + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.muli %arg2, %c42 : index + affine.for %arg3 = 0 to 3 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = arith.muli %1, %c6_i32 : i32 + %3 = arith.divsi %2, %c3_i32 : i32 + %4 = arith.addi %1, %c1_i32 : i32 + %5 = arith.muli %4, %c6_i32 : i32 + %6 = arith.addi %5, %c2_i32 : i32 + %7 = arith.divsi %6, %c3_i32 : i32 + %8 = arith.subi %7, %3 : i32 + affine.for %arg4 = 0 to 3 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c7_i32 : i32 + %11 = arith.divsi %10, %c3_i32 : i32 + %12 = arith.addi %9, %c1_i32 : i32 + %13 = arith.muli %12, %c7_i32 : i32 + %14 = arith.addi %13, %c2_i32 : i32 + %15 = arith.divsi %14, %c3_i32 : i32 + %16 = arith.subi %15, %11 : i32 + %17 = arith.muli %8, %16 : i32 + %18 = arith.sitofp %17 : i32 to f32 + %19 = arith.muli %arg4, %c7 : index + %20 = arith.cmpi slt, %19, %c0 : index + %21 = arith.subi %c-1, %19 : index + %22 = arith.select %20, %21, %19 : index + %23 = arith.divsi %22, %c3 : index + %24 = arith.subi %c-1, %23 : index + %25 = arith.select %20, %24, %23 : index + %26 = arith.addi %25, %c3 : index + affine.for %arg5 = #map1(%arg3) to #map2(%arg3) { + %27 = arith.muli %arg5, %c7 : index + scf.for %arg6 = %25 to %26 step %c1 { + %28 = affine.load %arg0[%arg4 + %arg2 * 9 + %arg3 * 3] : memref + %29 = arith.divf %28, %18 : f32 + %30 = arith.addi %arg6, %0 : index + %31 = arith.addi %30, %27 : index + %32 = memref.load %arg1[%31] : memref + %33 = arith.addf %32, %29 : f32 + memref.store %33, %arg1[%31] : memref + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu.mlir new file mode 100644 index 000000000000..1e8d83544201 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu.mlir @@ -0,0 +1,61 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c42 = arith.constant 42 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg2 = 0 to 2 { + %0 = arith.muli %arg2, %c42 : index + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + %1 = arith.index_cast %arg4 : index to i32 + %2 = arith.muli %1, %c7_i32 : i32 + %3 = arith.divsi %2, %c3_i32 : i32 + %4 = arith.addi %1, %c1_i32 : i32 + %5 = arith.muli %4, %c7_i32 : i32 + %6 = arith.addi %5, %c2_i32 : i32 + %7 = arith.divsi %6, %c3_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = arith.index_cast %3 : i32 to index + %10 = arith.subi %8, %9 : index + %11 = arith.muli %arg4, %c7 : index + %12 = arith.cmpi slt, %11, %c0 : index + %13 = arith.subi %c-1, %11 : index + %14 = arith.select %12, %13, %11 : index + %15 = arith.divsi %14, %c3 : index + %16 = arith.subi %c-1, %15 : index + %17 = arith.select %12, %16, %15 : index + %18 = arith.addi %17, %c3 : index + %19:2 = affine.for %arg5 = #map(%arg3) to #map1(%arg3) iter_args(%arg6 = %c0_i32, %arg7 = %cst) -> (i32, f32) { + %22 = arith.index_cast %arg6 : i32 to index + %23 = arith.addi %22, %10 : index + %24 = arith.index_cast %23 : index to i32 + %25 = arith.muli %arg5, %c7 : index + %26 = scf.for %arg8 = %17 to %18 step %c1 iter_args(%arg9 = %arg7) -> (f32) { + %27 = arith.addi %arg8, %0 : index + %28 = arith.addi %27, %25 : index + %29 = memref.load %arg0[%28] : memref + %30 = arith.addf %arg9, %29 : f32 + scf.yield %30 : f32 + } + affine.yield %24, %26 : i32, f32 + } + %20 = arith.sitofp %19#0 : i32 to f32 + %21 = arith.divf %19#1, %20 : f32 + affine.store %21, %arg1[%arg4 + %arg2 * 9 + %arg3 * 3] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu/debuf.mlir new file mode 100644 index 000000000000..3ddf5df8f255 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu/debuf.mlir @@ -0,0 +1,97 @@ +#map = affine_map<(d0)[s0] -> (s0)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0) -> (d0 * 2)> +#map3 = affine_map<(d0) -> (d0 * 2 + 2)> +#map4 = affine_map<(d0, d1, d2) -> (d0 + d1 * 9 + d2 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c42 = arith.constant 42 : index + %c6 = arith.constant 6 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %4 = arith.muli %arg2, %c42 : index + %5 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %alloca = memref.alloca(%c3) : memref + %6 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %7 = bufferization.to_tensor %alloca_0 : memref + %8:3 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %6, %arg8 = %7, %arg9 = %arg5) -> (tensor, tensor, tensor) { + %9 = arith.index_cast %arg6 : index to i32 + %10 = arith.muli %9, %c7_i32 : i32 + %11 = arith.divsi %10, %c3_i32 : i32 + %12 = arith.addi %9, %c1_i32 : i32 + %13 = arith.muli %12, %c7_i32 : i32 + %14 = arith.addi %13, %c2_i32 : i32 + %15 = arith.divsi %14, %c3_i32 : i32 + %16 = arith.index_cast %15 : i32 to index + %17 = arith.index_cast %11 : i32 to index + %18 = arith.subi %16, %17 : index + %19 = arith.muli %arg6, %c7 : index + %20 = arith.cmpi slt, %19, %c0 : index + %21 = arith.subi %c-1, %19 : index + %22 = arith.select %20, %21, %19 : index + %23 = arith.divsi %22, %c3 : index + %24 = arith.subi %c-1, %23 : index + %25 = arith.select %20, %24, %23 : index + %26 = arith.addi %25, %c3 : index + %inserted = tensor.insert %c0_i32 into %arg7[%arg6] : tensor + %inserted_1 = tensor.insert %cst into %arg8[%arg6] : tensor + %27 = polygeist.submap(%inserted, %arg6, %c6) {map = #map} : (tensor, index, index) -> tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction"], library_call = ""} outs(%27 : tensor) { + ^bb0(%out: i32): + %34 = arith.index_cast %out : i32 to index + %35 = arith.addi %34, %18 : index + %36 = arith.index_cast %35 : index to i32 + %37 = linalg.index 0 : index + %38 = affine.apply #map2(%arg4) + %39 = arith.cmpi sge, %37, %38 : index + %40 = affine.apply #map3(%arg4) + %41 = arith.cmpi slt, %37, %40 : index + %42 = arith.andi %39, %41 : i1 + %43 = arith.select %42, %36, %out : i32 + linalg.yield %43 : i32 + } -> tensor + %29 = polygeist.submapInverse(%inserted, %28, %arg6, %c6) {map = #map} : (tensor, tensor, index, index) -> tensor + %30 = affine.for %arg10 = #map2(%arg4) to #map3(%arg4) iter_args(%arg11 = %inserted_1) -> (tensor) { + %extracted_4 = tensor.extract %arg11[%arg6] : tensor + %34 = arith.muli %arg10, %c7 : index + %35 = scf.for %arg12 = %25 to %26 step %c1 iter_args(%arg13 = %extracted_4) -> (f32) { + %36 = arith.addi %arg12, %4 : index + %37 = arith.addi %36, %34 : index + %extracted_6 = tensor.extract %1[%37] : tensor + %38 = arith.addf %arg13, %extracted_6 : f32 + scf.yield %38 : f32 + } + %inserted_5 = tensor.insert %35 into %arg11[%arg6] : tensor + affine.yield %inserted_5 : tensor + } + %extracted = tensor.extract %29[%arg6] : tensor + %extracted_2 = tensor.extract %30[%arg6] : tensor + %31 = arith.sitofp %extracted : i32 to f32 + %32 = arith.divf %extracted_2, %31 : f32 + %33 = affine.apply #map4(%arg6, %arg2, %arg4) + %inserted_3 = tensor.insert %32 into %arg9[%33] : tensor + affine.yield %29, %30, %inserted_3 : tensor, tensor, tensor + } + affine.yield %8#2 : tensor + } + affine.yield %5 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu/matched.mlir new file mode 100644 index 000000000000..3ddf5df8f255 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu/matched.mlir @@ -0,0 +1,97 @@ +#map = affine_map<(d0)[s0] -> (s0)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0) -> (d0 * 2)> +#map3 = affine_map<(d0) -> (d0 * 2 + 2)> +#map4 = affine_map<(d0, d1, d2) -> (d0 + d1 * 9 + d2 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c42 = arith.constant 42 : index + %c6 = arith.constant 6 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %4 = arith.muli %arg2, %c42 : index + %5 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %alloca = memref.alloca(%c3) : memref + %6 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %7 = bufferization.to_tensor %alloca_0 : memref + %8:3 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %6, %arg8 = %7, %arg9 = %arg5) -> (tensor, tensor, tensor) { + %9 = arith.index_cast %arg6 : index to i32 + %10 = arith.muli %9, %c7_i32 : i32 + %11 = arith.divsi %10, %c3_i32 : i32 + %12 = arith.addi %9, %c1_i32 : i32 + %13 = arith.muli %12, %c7_i32 : i32 + %14 = arith.addi %13, %c2_i32 : i32 + %15 = arith.divsi %14, %c3_i32 : i32 + %16 = arith.index_cast %15 : i32 to index + %17 = arith.index_cast %11 : i32 to index + %18 = arith.subi %16, %17 : index + %19 = arith.muli %arg6, %c7 : index + %20 = arith.cmpi slt, %19, %c0 : index + %21 = arith.subi %c-1, %19 : index + %22 = arith.select %20, %21, %19 : index + %23 = arith.divsi %22, %c3 : index + %24 = arith.subi %c-1, %23 : index + %25 = arith.select %20, %24, %23 : index + %26 = arith.addi %25, %c3 : index + %inserted = tensor.insert %c0_i32 into %arg7[%arg6] : tensor + %inserted_1 = tensor.insert %cst into %arg8[%arg6] : tensor + %27 = polygeist.submap(%inserted, %arg6, %c6) {map = #map} : (tensor, index, index) -> tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction"], library_call = ""} outs(%27 : tensor) { + ^bb0(%out: i32): + %34 = arith.index_cast %out : i32 to index + %35 = arith.addi %34, %18 : index + %36 = arith.index_cast %35 : index to i32 + %37 = linalg.index 0 : index + %38 = affine.apply #map2(%arg4) + %39 = arith.cmpi sge, %37, %38 : index + %40 = affine.apply #map3(%arg4) + %41 = arith.cmpi slt, %37, %40 : index + %42 = arith.andi %39, %41 : i1 + %43 = arith.select %42, %36, %out : i32 + linalg.yield %43 : i32 + } -> tensor + %29 = polygeist.submapInverse(%inserted, %28, %arg6, %c6) {map = #map} : (tensor, tensor, index, index) -> tensor + %30 = affine.for %arg10 = #map2(%arg4) to #map3(%arg4) iter_args(%arg11 = %inserted_1) -> (tensor) { + %extracted_4 = tensor.extract %arg11[%arg6] : tensor + %34 = arith.muli %arg10, %c7 : index + %35 = scf.for %arg12 = %25 to %26 step %c1 iter_args(%arg13 = %extracted_4) -> (f32) { + %36 = arith.addi %arg12, %4 : index + %37 = arith.addi %36, %34 : index + %extracted_6 = tensor.extract %1[%37] : tensor + %38 = arith.addf %arg13, %extracted_6 : f32 + scf.yield %38 : f32 + } + %inserted_5 = tensor.insert %35 into %arg11[%arg6] : tensor + affine.yield %inserted_5 : tensor + } + %extracted = tensor.extract %29[%arg6] : tensor + %extracted_2 = tensor.extract %30[%arg6] : tensor + %31 = arith.sitofp %extracted : i32 to f32 + %32 = arith.divf %extracted_2, %31 : f32 + %33 = affine.apply #map4(%arg6, %arg2, %arg4) + %inserted_3 = tensor.insert %32 into %arg9[%33] : tensor + affine.yield %29, %30, %inserted_3 : tensor, tensor, tensor + } + affine.yield %8#2 : tensor + } + affine.yield %5 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu/orig.mlir new file mode 100644 index 000000000000..1e8d83544201 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu/orig.mlir @@ -0,0 +1,61 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c42 = arith.constant 42 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg2 = 0 to 2 { + %0 = arith.muli %arg2, %c42 : index + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + %1 = arith.index_cast %arg4 : index to i32 + %2 = arith.muli %1, %c7_i32 : i32 + %3 = arith.divsi %2, %c3_i32 : i32 + %4 = arith.addi %1, %c1_i32 : i32 + %5 = arith.muli %4, %c7_i32 : i32 + %6 = arith.addi %5, %c2_i32 : i32 + %7 = arith.divsi %6, %c3_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = arith.index_cast %3 : i32 to index + %10 = arith.subi %8, %9 : index + %11 = arith.muli %arg4, %c7 : index + %12 = arith.cmpi slt, %11, %c0 : index + %13 = arith.subi %c-1, %11 : index + %14 = arith.select %12, %13, %11 : index + %15 = arith.divsi %14, %c3 : index + %16 = arith.subi %c-1, %15 : index + %17 = arith.select %12, %16, %15 : index + %18 = arith.addi %17, %c3 : index + %19:2 = affine.for %arg5 = #map(%arg3) to #map1(%arg3) iter_args(%arg6 = %c0_i32, %arg7 = %cst) -> (i32, f32) { + %22 = arith.index_cast %arg6 : i32 to index + %23 = arith.addi %22, %10 : index + %24 = arith.index_cast %23 : index to i32 + %25 = arith.muli %arg5, %c7 : index + %26 = scf.for %arg8 = %17 to %18 step %c1 iter_args(%arg9 = %arg7) -> (f32) { + %27 = arith.addi %arg8, %0 : index + %28 = arith.addi %27, %25 : index + %29 = memref.load %arg0[%28] : memref + %30 = arith.addf %arg9, %29 : f32 + scf.yield %30 : f32 + } + affine.yield %24, %26 : i32, f32 + } + %20 = arith.sitofp %19#0 : i32 to f32 + %21 = arith.divf %19#1, %20 : f32 + affine.store %21, %arg1[%arg4 + %arg2 * 9 + %arg3 * 3] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu/raised.mlir new file mode 100644 index 000000000000..7c36f319104b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu/raised.mlir @@ -0,0 +1,84 @@ +#map = affine_map<(d0)[s0] -> (s0)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0) -> (d0 * 2)> +#map3 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c6 = arith.constant 6 : index + %c42 = arith.constant 42 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg2 = 0 to 2 { + %0 = arith.muli %arg2, %c42 : index + affine.for %arg3 = 0 to 3 { + %alloca = memref.alloca(%c3) : memref + %alloca_0 = memref.alloca(%c3) : memref + affine.for %arg4 = 0 to 3 { + %1 = arith.index_cast %arg4 : index to i32 + %2 = arith.muli %1, %c7_i32 : i32 + %3 = arith.divsi %2, %c3_i32 : i32 + %4 = arith.addi %1, %c1_i32 : i32 + %5 = arith.muli %4, %c7_i32 : i32 + %6 = arith.addi %5, %c2_i32 : i32 + %7 = arith.divsi %6, %c3_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = arith.index_cast %3 : i32 to index + %10 = arith.subi %8, %9 : index + %11 = arith.muli %arg4, %c7 : index + %12 = arith.cmpi slt, %11, %c0 : index + %13 = arith.subi %c-1, %11 : index + %14 = arith.select %12, %13, %11 : index + %15 = arith.divsi %14, %c3 : index + %16 = arith.subi %c-1, %15 : index + %17 = arith.select %12, %16, %15 : index + %18 = arith.addi %17, %c3 : index + affine.store %c0_i32, %alloca[%arg4] : memref + affine.store %cst, %alloca_0[%arg4] : memref + %19 = polygeist.submap(%alloca, %arg4, %c6) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction"]} outs(%19 : memref) { + ^bb0(%out: i32): + %24 = arith.index_cast %out : i32 to index + %25 = arith.addi %24, %10 : index + %26 = arith.index_cast %25 : index to i32 + %27 = linalg.index 0 : index + %28 = affine.apply #map2(%arg3) + %29 = arith.cmpi sge, %27, %28 : index + %30 = affine.apply #map3(%arg3) + %31 = arith.cmpi slt, %27, %30 : index + %32 = arith.andi %29, %31 : i1 + %33 = arith.select %32, %26, %out : i32 + linalg.yield %33 : i32 + } + affine.for %arg5 = #map2(%arg3) to #map3(%arg3) { + %24 = affine.load %alloca_0[%arg4] : memref + %25 = arith.muli %arg5, %c7 : index + %26 = scf.for %arg6 = %17 to %18 step %c1 iter_args(%arg7 = %24) -> (f32) { + %27 = arith.addi %arg6, %0 : index + %28 = arith.addi %27, %25 : index + %29 = memref.load %arg0[%28] : memref + %30 = arith.addf %arg7, %29 : f32 + scf.yield %30 : f32 + } + affine.store %26, %alloca_0[%arg4] : memref + } + %20 = affine.load %alloca[%arg4] : memref + %21 = affine.load %alloca_0[%arg4] : memref + %22 = arith.sitofp %20 : i32 to f32 + %23 = arith.divf %21, %22 : f32 + affine.store %23, %arg1[%arg4 + %arg2 * 9 + %arg3 * 3] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu_debuf.mlir new file mode 100644 index 000000000000..3ddf5df8f255 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu_debuf.mlir @@ -0,0 +1,97 @@ +#map = affine_map<(d0)[s0] -> (s0)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0) -> (d0 * 2)> +#map3 = affine_map<(d0) -> (d0 * 2 + 2)> +#map4 = affine_map<(d0, d1, d2) -> (d0 + d1 * 9 + d2 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c42 = arith.constant 42 : index + %c6 = arith.constant 6 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %4 = arith.muli %arg2, %c42 : index + %5 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %alloca = memref.alloca(%c3) : memref + %6 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %7 = bufferization.to_tensor %alloca_0 : memref + %8:3 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %6, %arg8 = %7, %arg9 = %arg5) -> (tensor, tensor, tensor) { + %9 = arith.index_cast %arg6 : index to i32 + %10 = arith.muli %9, %c7_i32 : i32 + %11 = arith.divsi %10, %c3_i32 : i32 + %12 = arith.addi %9, %c1_i32 : i32 + %13 = arith.muli %12, %c7_i32 : i32 + %14 = arith.addi %13, %c2_i32 : i32 + %15 = arith.divsi %14, %c3_i32 : i32 + %16 = arith.index_cast %15 : i32 to index + %17 = arith.index_cast %11 : i32 to index + %18 = arith.subi %16, %17 : index + %19 = arith.muli %arg6, %c7 : index + %20 = arith.cmpi slt, %19, %c0 : index + %21 = arith.subi %c-1, %19 : index + %22 = arith.select %20, %21, %19 : index + %23 = arith.divsi %22, %c3 : index + %24 = arith.subi %c-1, %23 : index + %25 = arith.select %20, %24, %23 : index + %26 = arith.addi %25, %c3 : index + %inserted = tensor.insert %c0_i32 into %arg7[%arg6] : tensor + %inserted_1 = tensor.insert %cst into %arg8[%arg6] : tensor + %27 = polygeist.submap(%inserted, %arg6, %c6) {map = #map} : (tensor, index, index) -> tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction"], library_call = ""} outs(%27 : tensor) { + ^bb0(%out: i32): + %34 = arith.index_cast %out : i32 to index + %35 = arith.addi %34, %18 : index + %36 = arith.index_cast %35 : index to i32 + %37 = linalg.index 0 : index + %38 = affine.apply #map2(%arg4) + %39 = arith.cmpi sge, %37, %38 : index + %40 = affine.apply #map3(%arg4) + %41 = arith.cmpi slt, %37, %40 : index + %42 = arith.andi %39, %41 : i1 + %43 = arith.select %42, %36, %out : i32 + linalg.yield %43 : i32 + } -> tensor + %29 = polygeist.submapInverse(%inserted, %28, %arg6, %c6) {map = #map} : (tensor, tensor, index, index) -> tensor + %30 = affine.for %arg10 = #map2(%arg4) to #map3(%arg4) iter_args(%arg11 = %inserted_1) -> (tensor) { + %extracted_4 = tensor.extract %arg11[%arg6] : tensor + %34 = arith.muli %arg10, %c7 : index + %35 = scf.for %arg12 = %25 to %26 step %c1 iter_args(%arg13 = %extracted_4) -> (f32) { + %36 = arith.addi %arg12, %4 : index + %37 = arith.addi %36, %34 : index + %extracted_6 = tensor.extract %1[%37] : tensor + %38 = arith.addf %arg13, %extracted_6 : f32 + scf.yield %38 : f32 + } + %inserted_5 = tensor.insert %35 into %arg11[%arg6] : tensor + affine.yield %inserted_5 : tensor + } + %extracted = tensor.extract %29[%arg6] : tensor + %extracted_2 = tensor.extract %30[%arg6] : tensor + %31 = arith.sitofp %extracted : i32 to f32 + %32 = arith.divf %extracted_2, %31 : f32 + %33 = affine.apply #map4(%arg6, %arg2, %arg4) + %inserted_3 = tensor.insert %32 into %arg9[%33] : tensor + affine.yield %29, %30, %inserted_3 : tensor, tensor, tensor + } + affine.yield %8#2 : tensor + } + affine.yield %5 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu_linalg.mlir new file mode 100644 index 000000000000..7c36f319104b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_cpu_linalg.mlir @@ -0,0 +1,84 @@ +#map = affine_map<(d0)[s0] -> (s0)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0) -> (d0 * 2)> +#map3 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c6 = arith.constant 6 : index + %c42 = arith.constant 42 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg2 = 0 to 2 { + %0 = arith.muli %arg2, %c42 : index + affine.for %arg3 = 0 to 3 { + %alloca = memref.alloca(%c3) : memref + %alloca_0 = memref.alloca(%c3) : memref + affine.for %arg4 = 0 to 3 { + %1 = arith.index_cast %arg4 : index to i32 + %2 = arith.muli %1, %c7_i32 : i32 + %3 = arith.divsi %2, %c3_i32 : i32 + %4 = arith.addi %1, %c1_i32 : i32 + %5 = arith.muli %4, %c7_i32 : i32 + %6 = arith.addi %5, %c2_i32 : i32 + %7 = arith.divsi %6, %c3_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = arith.index_cast %3 : i32 to index + %10 = arith.subi %8, %9 : index + %11 = arith.muli %arg4, %c7 : index + %12 = arith.cmpi slt, %11, %c0 : index + %13 = arith.subi %c-1, %11 : index + %14 = arith.select %12, %13, %11 : index + %15 = arith.divsi %14, %c3 : index + %16 = arith.subi %c-1, %15 : index + %17 = arith.select %12, %16, %15 : index + %18 = arith.addi %17, %c3 : index + affine.store %c0_i32, %alloca[%arg4] : memref + affine.store %cst, %alloca_0[%arg4] : memref + %19 = polygeist.submap(%alloca, %arg4, %c6) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction"]} outs(%19 : memref) { + ^bb0(%out: i32): + %24 = arith.index_cast %out : i32 to index + %25 = arith.addi %24, %10 : index + %26 = arith.index_cast %25 : index to i32 + %27 = linalg.index 0 : index + %28 = affine.apply #map2(%arg3) + %29 = arith.cmpi sge, %27, %28 : index + %30 = affine.apply #map3(%arg3) + %31 = arith.cmpi slt, %27, %30 : index + %32 = arith.andi %29, %31 : i1 + %33 = arith.select %32, %26, %out : i32 + linalg.yield %33 : i32 + } + affine.for %arg5 = #map2(%arg3) to #map3(%arg3) { + %24 = affine.load %alloca_0[%arg4] : memref + %25 = arith.muli %arg5, %c7 : index + %26 = scf.for %arg6 = %17 to %18 step %c1 iter_args(%arg7 = %24) -> (f32) { + %27 = arith.addi %arg6, %0 : index + %28 = arith.addi %27, %25 : index + %29 = memref.load %arg0[%28] : memref + %30 = arith.addf %arg7, %29 : f32 + scf.yield %30 : f32 + } + affine.store %26, %alloca_0[%arg4] : memref + } + %20 = affine.load %alloca[%arg4] : memref + %21 = affine.load %alloca_0[%arg4] : memref + %22 = arith.sitofp %20 : i32 to f32 + %23 = arith.divf %21, %22 : f32 + affine.store %23, %arg1[%arg4 + %arg2 * 9 + %arg3 * 3] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_debuf.mlir new file mode 100644 index 000000000000..62b7d48ccd1b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2 * 2, d5 + d3 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 2.500000e-01 : f32 + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c4, %c4, %c4, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%3 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.mulf %in, %cst_0 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_linalg.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_linalg.mlir new file mode 100644 index 000000000000..40e05dceed51 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool2d_linalg.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2 * 2, d5 + d3 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 2.500000e-01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg1[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c4, %c4, %c4, %c2, %c2) {map = #map1} : (memref, index, index, index, index, index, index) -> memref + %subview_1 = memref.subview %arg1[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"]} ins(%0 : memref) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.mulf %in, %cst : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d.mlir new file mode 100644 index 000000000000..cd24947965a6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.store %cst_0, %arg1[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 2 { + %0 = affine.load %arg0[%arg2, %arg3, %arg7 + %arg4 * 2, %arg8 + %arg5 * 2, %arg9 + %arg6 * 2] : memref + %1 = arith.divf %0, %cst : f32 + %2 = affine.load %arg1[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d/debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d/debuf.mlir new file mode 100644 index 000000000000..eabbfe014856 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5 + d2 * 2, d6 + d3 * 2, d7 + d4 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 8.000000e+00 : f32 + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c3, %c4, %c4, %c4, %c2, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%3 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.divf %in, %cst_0 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d/matched.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d/matched.mlir new file mode 100644 index 000000000000..eabbfe014856 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d/matched.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5 + d2 * 2, d6 + d3 * 2, d7 + d4 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 8.000000e+00 : f32 + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c3, %c4, %c4, %c4, %c2, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%3 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.divf %in, %cst_0 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d/orig.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d/orig.mlir new file mode 100644 index 000000000000..cd24947965a6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d/orig.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.store %cst_0, %arg1[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 2 { + %0 = affine.load %arg0[%arg2, %arg3, %arg7 + %arg4 * 2, %arg8 + %arg5 * 2, %arg9 + %arg6 * 2] : memref + %1 = arith.divf %0, %cst : f32 + %2 = affine.load %arg1[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d/raised.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d/raised.mlir new file mode 100644 index 000000000000..508f6eec4399 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d/raised.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5 + d2 * 2, d6 + d3 * 2, d7 + d4 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c3, %c4, %c4, %c4, %c2, %c2, %c2) {map = #map1} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview_1 = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%0 : memref) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.divf %in, %cst : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu.mlir new file mode 100644 index 000000000000..6c68e5c576a5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu.mlir @@ -0,0 +1,101 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-11 = arith.constant -11 : index + %c56 = arith.constant 56 : index + %c336 = arith.constant 336 : index + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c3_i32 = arith.constant 3 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c2_i32 = arith.constant 2 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg2 = 0 to 672 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.muli %arg2, %c336 : index + affine.for %arg3 = 0 to 3 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = arith.muli %1, %c6_i32 : i32 + %3 = arith.divsi %2, %c3_i32 : i32 + %4 = arith.addi %1, %c1_i32 : i32 + %5 = arith.muli %4, %c6_i32 : i32 + %6 = arith.addi %5, %c2_i32 : i32 + %7 = arith.divsi %6, %c3_i32 : i32 + %8 = arith.subi %7, %3 : i32 + affine.for %arg4 = 0 to 3 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c7_i32 : i32 + %11 = arith.divsi %10, %c3_i32 : i32 + %12 = arith.addi %9, %c1_i32 : i32 + %13 = arith.muli %12, %c7_i32 : i32 + %14 = arith.addi %13, %c2_i32 : i32 + %15 = arith.divsi %14, %c3_i32 : i32 + %16 = arith.subi %15, %11 : i32 + %17 = arith.muli %8, %16 : i32 + %18 = arith.muli %arg4, %c7 : index + %19 = arith.cmpi slt, %18, %c0 : index + %20 = arith.subi %c-1, %18 : index + %21 = arith.select %19, %20, %18 : index + %22 = arith.divsi %21, %c3 : index + %23 = arith.subi %c-1, %22 : index + %24 = arith.select %19, %23, %22 : index + %25 = arith.addi %24, %c3 : index + affine.for %arg5 = 0 to 3 { + %26 = arith.index_cast %arg5 : index to i32 + %27 = arith.muli %26, %c8_i32 : i32 + %28 = arith.divsi %27, %c3_i32 : i32 + %29 = arith.addi %26, %c1_i32 : i32 + %30 = arith.muli %29, %c8_i32 : i32 + %31 = arith.addi %30, %c2_i32 : i32 + %32 = arith.divsi %31, %c3_i32 : i32 + %33 = arith.subi %32, %28 : i32 + %34 = arith.muli %17, %33 : i32 + %35 = arith.sitofp %34 : i32 to f32 + %36 = arith.muli %arg5, %c8 : index + %37 = arith.cmpi slt, %36, %c0 : index + %38 = arith.subi %c-1, %36 : index + %39 = arith.select %37, %38, %36 : index + %40 = arith.divsi %39, %c3 : index + %41 = arith.subi %c-1, %40 : index + %42 = arith.select %37, %41, %40 : index + %43 = arith.addi %36, %c10 : index + %44 = arith.cmpi slt, %43, %c0 : index + %45 = arith.subi %c-11, %36 : index + %46 = arith.select %44, %45, %43 : index + %47 = arith.divsi %46, %c3 : index + %48 = arith.subi %c-1, %47 : index + %49 = arith.select %44, %48, %47 : index + affine.for %arg6 = #map(%arg3) to #map1(%arg3) { + %50 = arith.muli %arg6, %c56 : index + scf.for %arg7 = %24 to %25 step %c1 { + %51 = arith.muli %arg7, %c8 : index + scf.for %arg8 = %42 to %49 step %c1 { + %52 = affine.load %arg0[%arg2 * 27 + %arg5 + %arg3 * 9 + %arg4 * 3] : memref + %53 = arith.divf %52, %35 : f32 + %54 = arith.addi %arg8, %51 : index + %55 = arith.addi %54, %0 : index + %56 = arith.addi %55, %50 : index + %57 = memref.load %arg1[%56] : memref + %58 = arith.addf %57, %53 : f32 + memref.store %58, %arg1[%56] : memref + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..e47c5f7f5190 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu/debuf.mlir @@ -0,0 +1,117 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 * 2)> +#map2 = affine_map<(d0) -> (d0 * 2 + 2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0 * 27 + d1 + d2 * 9 + d3 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c2_i32 = arith.constant 2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c7_i32 = arith.constant 7 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c3_i32 = arith.constant 3 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c8 = arith.constant 8 : index + %c10 = arith.constant 10 : index + %c336 = arith.constant 336 : index + %c56 = arith.constant 56 : index + %c-11 = arith.constant -11 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.muli %arg2, %c336 : index + %6 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %7 = arith.index_cast %arg4 : index to i32 + %8 = arith.muli %7, %c6_i32 : i32 + %9 = arith.divsi %8, %c3_i32 : i32 + %10 = arith.addi %7, %c1_i32 : i32 + %11 = arith.muli %10, %c6_i32 : i32 + %12 = arith.addi %11, %c2_i32 : i32 + %13 = arith.divsi %12, %c3_i32 : i32 + %14 = arith.subi %13, %9 : i32 + %15 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg5) -> (tensor) { + %16 = arith.index_cast %arg6 : index to i32 + %17 = arith.muli %16, %c7_i32 : i32 + %18 = arith.divsi %17, %c3_i32 : i32 + %19 = arith.addi %16, %c1_i32 : i32 + %20 = arith.muli %19, %c7_i32 : i32 + %21 = arith.addi %20, %c2_i32 : i32 + %22 = arith.divsi %21, %c3_i32 : i32 + %23 = arith.subi %22, %18 : i32 + %24 = arith.muli %14, %23 : i32 + %25 = arith.muli %arg6, %c7 : index + %26 = arith.cmpi slt, %25, %c0 : index + %27 = arith.subi %c-1, %25 : index + %28 = arith.select %26, %27, %25 : index + %29 = arith.divsi %28, %c3 : index + %30 = arith.subi %c-1, %29 : index + %31 = arith.select %26, %30, %29 : index + %32 = arith.addi %31, %c3 : index + %33 = affine.for %arg8 = 0 to 3 iter_args(%arg9 = %arg7) -> (tensor) { + %34 = arith.index_cast %arg8 : index to i32 + %35 = arith.muli %34, %c8_i32 : i32 + %36 = arith.divsi %35, %c3_i32 : i32 + %37 = arith.addi %34, %c1_i32 : i32 + %38 = arith.muli %37, %c8_i32 : i32 + %39 = arith.addi %38, %c2_i32 : i32 + %40 = arith.divsi %39, %c3_i32 : i32 + %41 = arith.subi %40, %36 : i32 + %42 = arith.muli %24, %41 : i32 + %43 = arith.sitofp %42 : i32 to f32 + %44 = arith.muli %arg8, %c8 : index + %45 = arith.cmpi slt, %44, %c0 : index + %46 = arith.subi %c-1, %44 : index + %47 = arith.select %45, %46, %44 : index + %48 = arith.divsi %47, %c3 : index + %49 = arith.subi %c-1, %48 : index + %50 = arith.select %45, %49, %48 : index + %51 = arith.addi %44, %c10 : index + %52 = arith.cmpi slt, %51, %c0 : index + %53 = arith.subi %c-11, %44 : index + %54 = arith.select %52, %53, %51 : index + %55 = arith.divsi %54, %c3 : index + %56 = arith.subi %c-1, %55 : index + %57 = arith.select %52, %56, %55 : index + %58 = affine.for %arg10 = #map1(%arg4) to #map2(%arg4) iter_args(%arg11 = %arg9) -> (tensor) { + %59 = arith.muli %arg10, %c56 : index + %60 = scf.for %arg12 = %31 to %32 step %c1 iter_args(%arg13 = %arg11) -> (tensor) { + %61 = arith.muli %arg12, %c8 : index + %62 = scf.for %arg14 = %50 to %57 step %c1 iter_args(%arg15 = %arg13) -> (tensor) { + %63 = affine.apply #map3(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%63] : tensor + %64 = arith.divf %extracted, %43 : f32 + %65 = arith.addi %arg14, %61 : index + %66 = arith.addi %65, %5 : index + %67 = arith.addi %66, %59 : index + %extracted_0 = tensor.extract %arg15[%67] : tensor + %68 = arith.addf %extracted_0, %64 : f32 + %inserted = tensor.insert %68 into %arg15[%67] : tensor + scf.yield %inserted : tensor + } + scf.yield %62 : tensor + } + affine.yield %60 : tensor + } + affine.yield %58 : tensor + } + affine.yield %33 : tensor + } + affine.yield %15 : tensor + } + affine.yield %6 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..c4fdbf7e2aa6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu/matched.mlir @@ -0,0 +1,114 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 * 2)> +#map2 = affine_map<(d0) -> (d0 * 2 + 2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0 * 27 + d1 + d2 * 9 + d3 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c2_i32 = arith.constant 2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c7_i32 = arith.constant 7 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c3_i32 = arith.constant 3 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c8 = arith.constant 8 : index + %c10 = arith.constant 10 : index + %c336 = arith.constant 336 : index + %c56 = arith.constant 56 : index + %c-11 = arith.constant -11 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.muli %arg2, %c336 : index + %6 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %7 = arith.index_cast %arg4 : index to i32 + %8 = arith.muli %7, %c6_i32 : i32 + %9 = arith.divsi %8, %c3_i32 : i32 + %10 = arith.addi %7, %c1_i32 : i32 + %11 = arith.muli %10, %c6_i32 : i32 + %12 = arith.addi %11, %c2_i32 : i32 + %13 = arith.divsi %12, %c3_i32 : i32 + %14 = arith.subi %13, %9 : i32 + %15 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg5) -> (tensor) { + %16 = arith.index_cast %arg6 : index to i32 + %17 = arith.muli %16, %c7_i32 : i32 + %18 = arith.divsi %17, %c3_i32 : i32 + %19 = arith.addi %16, %c1_i32 : i32 + %20 = arith.muli %19, %c7_i32 : i32 + %21 = arith.addi %20, %c2_i32 : i32 + %22 = arith.divsi %21, %c3_i32 : i32 + %23 = arith.subi %22, %18 : i32 + %24 = arith.muli %14, %23 : i32 + %25 = arith.muli %arg6, %c7 : index + %26 = arith.cmpi slt, %25, %c0 : index + %27 = arith.subi %c-1, %25 : index + %28 = arith.select %26, %27, %25 : index + %29 = arith.divsi %28, %c3 : index + %30 = arith.subi %c-1, %29 : index + %31 = arith.select %26, %30, %29 : index + %32 = arith.addi %31, %c3 : index + %33 = affine.for %arg8 = 0 to 3 iter_args(%arg9 = %arg7) -> (tensor) { + %34 = arith.index_cast %arg8 : index to i32 + %35 = arith.muli %34, %c8_i32 : i32 + %36 = arith.divsi %35, %c3_i32 : i32 + %37 = arith.addi %34, %c1_i32 : i32 + %38 = arith.muli %37, %c8_i32 : i32 + %39 = arith.addi %38, %c2_i32 : i32 + %40 = arith.divsi %39, %c3_i32 : i32 + %41 = arith.subi %40, %36 : i32 + %42 = arith.muli %24, %41 : i32 + %43 = arith.sitofp %42 : i32 to f32 + %44 = arith.muli %arg8, %c8 : index + %45 = arith.cmpi slt, %44, %c0 : index + %46 = arith.subi %c-1, %44 : index + %47 = arith.select %45, %46, %44 : index + %48 = arith.divsi %47, %c3 : index + %49 = arith.subi %c-1, %48 : index + %50 = arith.select %45, %49, %48 : index + %51 = arith.addi %44, %c10 : index + %52 = arith.cmpi slt, %51, %c0 : index + %53 = arith.subi %c-11, %44 : index + %54 = arith.select %52, %53, %51 : index + %55 = arith.divsi %54, %c3 : index + %56 = arith.subi %c-1, %55 : index + %57 = arith.select %52, %56, %55 : index + %58 = affine.for %arg10 = #map1(%arg4) to #map2(%arg4) iter_args(%arg11 = %arg9) -> (tensor) { + %59 = arith.muli %arg10, %c56 : index + %60 = scf.for %arg12 = %31 to %32 step %c1 iter_args(%arg13 = %arg11) -> (tensor) { + %61 = arith.muli %arg12, %c8 : index + %62 = scf.for %arg14 = %50 to %57 step %c1 iter_args(%arg15 = %arg13) -> (tensor) { + %63 = affine.apply #map3(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%63] : tensor + %64 = arith.divf %extracted, %43 : f32 + %65 = arith.addi %arg14, %61 : index + %66 = arith.addi %65, %5 : index + %67 = arith.addi %66, %59 : index + %extracted_0 = tensor.extract %arg15[%67] : tensor + %68 = arith.addf %extracted_0, %64 : f32 + %inserted = tensor.insert %68 into %arg15[%67] : tensor + scf.yield %inserted : tensor + } + scf.yield %62 : tensor + } + affine.yield %60 : tensor + } + affine.yield %58 : tensor + } + affine.yield %33 : tensor + } + affine.yield %15 : tensor + } + affine.yield %6 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..6c68e5c576a5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu/orig.mlir @@ -0,0 +1,101 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-11 = arith.constant -11 : index + %c56 = arith.constant 56 : index + %c336 = arith.constant 336 : index + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c3_i32 = arith.constant 3 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c2_i32 = arith.constant 2 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg2 = 0 to 672 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.muli %arg2, %c336 : index + affine.for %arg3 = 0 to 3 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = arith.muli %1, %c6_i32 : i32 + %3 = arith.divsi %2, %c3_i32 : i32 + %4 = arith.addi %1, %c1_i32 : i32 + %5 = arith.muli %4, %c6_i32 : i32 + %6 = arith.addi %5, %c2_i32 : i32 + %7 = arith.divsi %6, %c3_i32 : i32 + %8 = arith.subi %7, %3 : i32 + affine.for %arg4 = 0 to 3 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c7_i32 : i32 + %11 = arith.divsi %10, %c3_i32 : i32 + %12 = arith.addi %9, %c1_i32 : i32 + %13 = arith.muli %12, %c7_i32 : i32 + %14 = arith.addi %13, %c2_i32 : i32 + %15 = arith.divsi %14, %c3_i32 : i32 + %16 = arith.subi %15, %11 : i32 + %17 = arith.muli %8, %16 : i32 + %18 = arith.muli %arg4, %c7 : index + %19 = arith.cmpi slt, %18, %c0 : index + %20 = arith.subi %c-1, %18 : index + %21 = arith.select %19, %20, %18 : index + %22 = arith.divsi %21, %c3 : index + %23 = arith.subi %c-1, %22 : index + %24 = arith.select %19, %23, %22 : index + %25 = arith.addi %24, %c3 : index + affine.for %arg5 = 0 to 3 { + %26 = arith.index_cast %arg5 : index to i32 + %27 = arith.muli %26, %c8_i32 : i32 + %28 = arith.divsi %27, %c3_i32 : i32 + %29 = arith.addi %26, %c1_i32 : i32 + %30 = arith.muli %29, %c8_i32 : i32 + %31 = arith.addi %30, %c2_i32 : i32 + %32 = arith.divsi %31, %c3_i32 : i32 + %33 = arith.subi %32, %28 : i32 + %34 = arith.muli %17, %33 : i32 + %35 = arith.sitofp %34 : i32 to f32 + %36 = arith.muli %arg5, %c8 : index + %37 = arith.cmpi slt, %36, %c0 : index + %38 = arith.subi %c-1, %36 : index + %39 = arith.select %37, %38, %36 : index + %40 = arith.divsi %39, %c3 : index + %41 = arith.subi %c-1, %40 : index + %42 = arith.select %37, %41, %40 : index + %43 = arith.addi %36, %c10 : index + %44 = arith.cmpi slt, %43, %c0 : index + %45 = arith.subi %c-11, %36 : index + %46 = arith.select %44, %45, %43 : index + %47 = arith.divsi %46, %c3 : index + %48 = arith.subi %c-1, %47 : index + %49 = arith.select %44, %48, %47 : index + affine.for %arg6 = #map(%arg3) to #map1(%arg3) { + %50 = arith.muli %arg6, %c56 : index + scf.for %arg7 = %24 to %25 step %c1 { + %51 = arith.muli %arg7, %c8 : index + scf.for %arg8 = %42 to %49 step %c1 { + %52 = affine.load %arg0[%arg2 * 27 + %arg5 + %arg3 * 9 + %arg4 * 3] : memref + %53 = arith.divf %52, %35 : f32 + %54 = arith.addi %arg8, %51 : index + %55 = arith.addi %54, %0 : index + %56 = arith.addi %55, %50 : index + %57 = memref.load %arg1[%56] : memref + %58 = arith.addf %57, %53 : f32 + memref.store %58, %arg1[%56] : memref + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..a9fdff0829e7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu/raised.mlir @@ -0,0 +1,104 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 * 2)> +#map2 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c-11 = arith.constant -11 : index + %c56 = arith.constant 56 : index + %c336 = arith.constant 336 : index + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c3_i32 = arith.constant 3 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1 = arith.constant 1 : index + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.muli %arg2, %c336 : index + affine.for %arg3 = 0 to 3 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = arith.muli %1, %c6_i32 : i32 + %3 = arith.divsi %2, %c3_i32 : i32 + %4 = arith.addi %1, %c1_i32 : i32 + %5 = arith.muli %4, %c6_i32 : i32 + %6 = arith.addi %5, %c2_i32 : i32 + %7 = arith.divsi %6, %c3_i32 : i32 + %8 = arith.subi %7, %3 : i32 + affine.for %arg4 = 0 to 3 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c7_i32 : i32 + %11 = arith.divsi %10, %c3_i32 : i32 + %12 = arith.addi %9, %c1_i32 : i32 + %13 = arith.muli %12, %c7_i32 : i32 + %14 = arith.addi %13, %c2_i32 : i32 + %15 = arith.divsi %14, %c3_i32 : i32 + %16 = arith.subi %15, %11 : i32 + %17 = arith.muli %8, %16 : i32 + %18 = arith.muli %arg4, %c7 : index + %19 = arith.cmpi slt, %18, %c0 : index + %20 = arith.subi %c-1, %18 : index + %21 = arith.select %19, %20, %18 : index + %22 = arith.divsi %21, %c3 : index + %23 = arith.subi %c-1, %22 : index + %24 = arith.select %19, %23, %22 : index + %25 = arith.addi %24, %c3 : index + affine.for %arg5 = 0 to 3 { + %26 = arith.index_cast %arg5 : index to i32 + %27 = arith.muli %26, %c8_i32 : i32 + %28 = arith.divsi %27, %c3_i32 : i32 + %29 = arith.addi %26, %c1_i32 : i32 + %30 = arith.muli %29, %c8_i32 : i32 + %31 = arith.addi %30, %c2_i32 : i32 + %32 = arith.divsi %31, %c3_i32 : i32 + %33 = arith.subi %32, %28 : i32 + %34 = arith.muli %17, %33 : i32 + %35 = arith.sitofp %34 : i32 to f32 + %36 = arith.muli %arg5, %c8 : index + %37 = arith.cmpi slt, %36, %c0 : index + %38 = arith.subi %c-1, %36 : index + %39 = arith.select %37, %38, %36 : index + %40 = arith.divsi %39, %c3 : index + %41 = arith.subi %c-1, %40 : index + %42 = arith.select %37, %41, %40 : index + %43 = arith.addi %36, %c10 : index + %44 = arith.cmpi slt, %43, %c0 : index + %45 = arith.subi %c-11, %36 : index + %46 = arith.select %44, %45, %43 : index + %47 = arith.divsi %46, %c3 : index + %48 = arith.subi %c-1, %47 : index + %49 = arith.select %44, %48, %47 : index + affine.for %arg6 = #map1(%arg3) to #map2(%arg3) { + %50 = arith.muli %arg6, %c56 : index + scf.for %arg7 = %24 to %25 step %c1 { + %51 = arith.muli %arg7, %c8 : index + scf.for %arg8 = %42 to %49 step %c1 { + %52 = affine.load %arg0[%arg2 * 27 + %arg5 + %arg3 * 9 + %arg4 * 3] : memref + %53 = arith.divf %52, %35 : f32 + %54 = arith.addi %arg8, %51 : index + %55 = arith.addi %54, %0 : index + %56 = arith.addi %55, %50 : index + %57 = memref.load %arg1[%56] : memref + %58 = arith.addf %57, %53 : f32 + memref.store %58, %arg1[%56] : memref + } + } + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..e47c5f7f5190 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu_debuf.mlir @@ -0,0 +1,117 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 * 2)> +#map2 = affine_map<(d0) -> (d0 * 2 + 2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0 * 27 + d1 + d2 * 9 + d3 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c2_i32 = arith.constant 2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c7_i32 = arith.constant 7 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c3_i32 = arith.constant 3 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c8 = arith.constant 8 : index + %c10 = arith.constant 10 : index + %c336 = arith.constant 336 : index + %c56 = arith.constant 56 : index + %c-11 = arith.constant -11 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.muli %arg2, %c336 : index + %6 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %7 = arith.index_cast %arg4 : index to i32 + %8 = arith.muli %7, %c6_i32 : i32 + %9 = arith.divsi %8, %c3_i32 : i32 + %10 = arith.addi %7, %c1_i32 : i32 + %11 = arith.muli %10, %c6_i32 : i32 + %12 = arith.addi %11, %c2_i32 : i32 + %13 = arith.divsi %12, %c3_i32 : i32 + %14 = arith.subi %13, %9 : i32 + %15 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg5) -> (tensor) { + %16 = arith.index_cast %arg6 : index to i32 + %17 = arith.muli %16, %c7_i32 : i32 + %18 = arith.divsi %17, %c3_i32 : i32 + %19 = arith.addi %16, %c1_i32 : i32 + %20 = arith.muli %19, %c7_i32 : i32 + %21 = arith.addi %20, %c2_i32 : i32 + %22 = arith.divsi %21, %c3_i32 : i32 + %23 = arith.subi %22, %18 : i32 + %24 = arith.muli %14, %23 : i32 + %25 = arith.muli %arg6, %c7 : index + %26 = arith.cmpi slt, %25, %c0 : index + %27 = arith.subi %c-1, %25 : index + %28 = arith.select %26, %27, %25 : index + %29 = arith.divsi %28, %c3 : index + %30 = arith.subi %c-1, %29 : index + %31 = arith.select %26, %30, %29 : index + %32 = arith.addi %31, %c3 : index + %33 = affine.for %arg8 = 0 to 3 iter_args(%arg9 = %arg7) -> (tensor) { + %34 = arith.index_cast %arg8 : index to i32 + %35 = arith.muli %34, %c8_i32 : i32 + %36 = arith.divsi %35, %c3_i32 : i32 + %37 = arith.addi %34, %c1_i32 : i32 + %38 = arith.muli %37, %c8_i32 : i32 + %39 = arith.addi %38, %c2_i32 : i32 + %40 = arith.divsi %39, %c3_i32 : i32 + %41 = arith.subi %40, %36 : i32 + %42 = arith.muli %24, %41 : i32 + %43 = arith.sitofp %42 : i32 to f32 + %44 = arith.muli %arg8, %c8 : index + %45 = arith.cmpi slt, %44, %c0 : index + %46 = arith.subi %c-1, %44 : index + %47 = arith.select %45, %46, %44 : index + %48 = arith.divsi %47, %c3 : index + %49 = arith.subi %c-1, %48 : index + %50 = arith.select %45, %49, %48 : index + %51 = arith.addi %44, %c10 : index + %52 = arith.cmpi slt, %51, %c0 : index + %53 = arith.subi %c-11, %44 : index + %54 = arith.select %52, %53, %51 : index + %55 = arith.divsi %54, %c3 : index + %56 = arith.subi %c-1, %55 : index + %57 = arith.select %52, %56, %55 : index + %58 = affine.for %arg10 = #map1(%arg4) to #map2(%arg4) iter_args(%arg11 = %arg9) -> (tensor) { + %59 = arith.muli %arg10, %c56 : index + %60 = scf.for %arg12 = %31 to %32 step %c1 iter_args(%arg13 = %arg11) -> (tensor) { + %61 = arith.muli %arg12, %c8 : index + %62 = scf.for %arg14 = %50 to %57 step %c1 iter_args(%arg15 = %arg13) -> (tensor) { + %63 = affine.apply #map3(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%63] : tensor + %64 = arith.divf %extracted, %43 : f32 + %65 = arith.addi %arg14, %61 : index + %66 = arith.addi %65, %5 : index + %67 = arith.addi %66, %59 : index + %extracted_0 = tensor.extract %arg15[%67] : tensor + %68 = arith.addf %extracted_0, %64 : f32 + %inserted = tensor.insert %68 into %arg15[%67] : tensor + scf.yield %inserted : tensor + } + scf.yield %62 : tensor + } + affine.yield %60 : tensor + } + affine.yield %58 : tensor + } + affine.yield %33 : tensor + } + affine.yield %15 : tensor + } + affine.yield %6 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..a9fdff0829e7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_backward_cpu_linalg.mlir @@ -0,0 +1,104 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 * 2)> +#map2 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c-11 = arith.constant -11 : index + %c56 = arith.constant 56 : index + %c336 = arith.constant 336 : index + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c3_i32 = arith.constant 3 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1 = arith.constant 1 : index + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.muli %arg2, %c336 : index + affine.for %arg3 = 0 to 3 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = arith.muli %1, %c6_i32 : i32 + %3 = arith.divsi %2, %c3_i32 : i32 + %4 = arith.addi %1, %c1_i32 : i32 + %5 = arith.muli %4, %c6_i32 : i32 + %6 = arith.addi %5, %c2_i32 : i32 + %7 = arith.divsi %6, %c3_i32 : i32 + %8 = arith.subi %7, %3 : i32 + affine.for %arg4 = 0 to 3 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c7_i32 : i32 + %11 = arith.divsi %10, %c3_i32 : i32 + %12 = arith.addi %9, %c1_i32 : i32 + %13 = arith.muli %12, %c7_i32 : i32 + %14 = arith.addi %13, %c2_i32 : i32 + %15 = arith.divsi %14, %c3_i32 : i32 + %16 = arith.subi %15, %11 : i32 + %17 = arith.muli %8, %16 : i32 + %18 = arith.muli %arg4, %c7 : index + %19 = arith.cmpi slt, %18, %c0 : index + %20 = arith.subi %c-1, %18 : index + %21 = arith.select %19, %20, %18 : index + %22 = arith.divsi %21, %c3 : index + %23 = arith.subi %c-1, %22 : index + %24 = arith.select %19, %23, %22 : index + %25 = arith.addi %24, %c3 : index + affine.for %arg5 = 0 to 3 { + %26 = arith.index_cast %arg5 : index to i32 + %27 = arith.muli %26, %c8_i32 : i32 + %28 = arith.divsi %27, %c3_i32 : i32 + %29 = arith.addi %26, %c1_i32 : i32 + %30 = arith.muli %29, %c8_i32 : i32 + %31 = arith.addi %30, %c2_i32 : i32 + %32 = arith.divsi %31, %c3_i32 : i32 + %33 = arith.subi %32, %28 : i32 + %34 = arith.muli %17, %33 : i32 + %35 = arith.sitofp %34 : i32 to f32 + %36 = arith.muli %arg5, %c8 : index + %37 = arith.cmpi slt, %36, %c0 : index + %38 = arith.subi %c-1, %36 : index + %39 = arith.select %37, %38, %36 : index + %40 = arith.divsi %39, %c3 : index + %41 = arith.subi %c-1, %40 : index + %42 = arith.select %37, %41, %40 : index + %43 = arith.addi %36, %c10 : index + %44 = arith.cmpi slt, %43, %c0 : index + %45 = arith.subi %c-11, %36 : index + %46 = arith.select %44, %45, %43 : index + %47 = arith.divsi %46, %c3 : index + %48 = arith.subi %c-1, %47 : index + %49 = arith.select %44, %48, %47 : index + affine.for %arg6 = #map1(%arg3) to #map2(%arg3) { + %50 = arith.muli %arg6, %c56 : index + scf.for %arg7 = %24 to %25 step %c1 { + %51 = arith.muli %arg7, %c8 : index + scf.for %arg8 = %42 to %49 step %c1 { + %52 = affine.load %arg0[%arg2 * 27 + %arg5 + %arg3 * 9 + %arg4 * 3] : memref + %53 = arith.divf %52, %35 : f32 + %54 = arith.addi %arg8, %51 : index + %55 = arith.addi %54, %0 : index + %56 = arith.addi %55, %50 : index + %57 = memref.load %arg1[%56] : memref + %58 = arith.addf %57, %53 : f32 + memref.store %58, %arg1[%56] : memref + } + } + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu.mlir new file mode 100644 index 000000000000..5d3ded8b9941 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu.mlir @@ -0,0 +1,86 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-11 = arith.constant -11 : index + %c56 = arith.constant 56 : index + %c336 = arith.constant 336 : index + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c3_i32 = arith.constant 3 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg2 = 0 to 2 { + %0 = arith.muli %arg2, %c336 : index + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + %1 = arith.muli %arg4, %c7 : index + %2 = arith.cmpi slt, %1, %c0 : index + %3 = arith.subi %c-1, %1 : index + %4 = arith.select %2, %3, %1 : index + %5 = arith.divsi %4, %c3 : index + %6 = arith.subi %c-1, %5 : index + %7 = arith.select %2, %6, %5 : index + %8 = arith.addi %7, %c3 : index + affine.for %arg5 = 0 to 3 { + %9 = arith.index_cast %arg5 : index to i32 + %10 = arith.muli %9, %c8_i32 : i32 + %11 = arith.divsi %10, %c3_i32 : i32 + %12 = arith.addi %9, %c1_i32 : i32 + %13 = arith.muli %12, %c8_i32 : i32 + %14 = arith.addi %13, %c2_i32 : i32 + %15 = arith.divsi %14, %c3_i32 : i32 + %16 = arith.index_cast %15 : i32 to index + %17 = arith.index_cast %11 : i32 to index + %18 = arith.subi %16, %17 : index + %19 = arith.muli %arg5, %c8 : index + %20 = arith.cmpi slt, %19, %c0 : index + %21 = arith.subi %c-1, %19 : index + %22 = arith.select %20, %21, %19 : index + %23 = arith.divsi %22, %c3 : index + %24 = arith.subi %c-1, %23 : index + %25 = arith.select %20, %24, %23 : index + %26 = arith.addi %19, %c10 : index + %27 = arith.cmpi slt, %26, %c0 : index + %28 = arith.subi %c-11, %19 : index + %29 = arith.select %27, %28, %26 : index + %30 = arith.divsi %29, %c3 : index + %31 = arith.subi %c-1, %30 : index + %32 = arith.select %27, %31, %30 : index + %33:2 = affine.for %arg6 = #map(%arg3) to #map1(%arg3) iter_args(%arg7 = %c0_i32, %arg8 = %cst) -> (i32, f32) { + %36 = arith.muli %arg6, %c56 : index + %37:2 = scf.for %arg9 = %7 to %8 step %c1 iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (i32, f32) { + %38 = arith.index_cast %arg10 : i32 to index + %39 = arith.addi %38, %18 : index + %40 = arith.index_cast %39 : index to i32 + %41 = arith.muli %arg9, %c8 : index + %42 = scf.for %arg12 = %25 to %32 step %c1 iter_args(%arg13 = %arg11) -> (f32) { + %43 = arith.addi %arg12, %41 : index + %44 = arith.addi %43, %0 : index + %45 = arith.addi %44, %36 : index + %46 = memref.load %arg0[%45] : memref + %47 = arith.addf %arg13, %46 : f32 + scf.yield %47 : f32 + } + scf.yield %40, %42 : i32, f32 + } + affine.yield %37#0, %37#1 : i32, f32 + } + %34 = arith.sitofp %33#0 : i32 to f32 + %35 = arith.divf %33#1, %34 : f32 + affine.store %35, %arg1[%arg2 * 27 + %arg5 + %arg3 * 9 + %arg4 * 3] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu/debuf.mlir new file mode 100644 index 000000000000..cbfebd361a9b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu/debuf.mlir @@ -0,0 +1,109 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0 * 27 + d1 + d2 * 9 + d3 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c3_i32 = arith.constant 3 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c8 = arith.constant 8 : index + %c10 = arith.constant 10 : index + %c336 = arith.constant 336 : index + %c56 = arith.constant 56 : index + %c-11 = arith.constant -11 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %4 = arith.muli %arg2, %c336 : index + %5 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %6 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg5) -> (tensor) { + %7 = arith.muli %arg6, %c7 : index + %8 = arith.cmpi slt, %7, %c0 : index + %9 = arith.subi %c-1, %7 : index + %10 = arith.select %8, %9, %7 : index + %11 = arith.divsi %10, %c3 : index + %12 = arith.subi %c-1, %11 : index + %13 = arith.select %8, %12, %11 : index + %14 = arith.addi %13, %c3 : index + %alloca = memref.alloca(%c3) : memref + %15 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %16 = bufferization.to_tensor %alloca_0 : memref + %17:3 = affine.for %arg8 = 0 to 3 iter_args(%arg9 = %15, %arg10 = %16, %arg11 = %arg7) -> (tensor, tensor, tensor) { + %18 = arith.index_cast %arg8 : index to i32 + %19 = arith.muli %18, %c8_i32 : i32 + %20 = arith.divsi %19, %c3_i32 : i32 + %21 = arith.addi %18, %c1_i32 : i32 + %22 = arith.muli %21, %c8_i32 : i32 + %23 = arith.addi %22, %c2_i32 : i32 + %24 = arith.divsi %23, %c3_i32 : i32 + %25 = arith.index_cast %24 : i32 to index + %26 = arith.index_cast %20 : i32 to index + %27 = arith.subi %25, %26 : index + %28 = arith.muli %arg8, %c8 : index + %29 = arith.cmpi slt, %28, %c0 : index + %30 = arith.subi %c-1, %28 : index + %31 = arith.select %29, %30, %28 : index + %32 = arith.divsi %31, %c3 : index + %33 = arith.subi %c-1, %32 : index + %34 = arith.select %29, %33, %32 : index + %35 = arith.addi %28, %c10 : index + %36 = arith.cmpi slt, %35, %c0 : index + %37 = arith.subi %c-11, %28 : index + %38 = arith.select %36, %37, %35 : index + %39 = arith.divsi %38, %c3 : index + %40 = arith.subi %c-1, %39 : index + %41 = arith.select %36, %40, %39 : index + %inserted = tensor.insert %c0_i32 into %arg9[%arg8] : tensor + %inserted_1 = tensor.insert %cst into %arg10[%arg8] : tensor + %42:2 = affine.for %arg12 = #map(%arg4) to #map1(%arg4) iter_args(%arg13 = %inserted, %arg14 = %inserted_1) -> (tensor, tensor) { + %extracted_4 = tensor.extract %arg13[%arg8] : tensor + %extracted_5 = tensor.extract %arg14[%arg8] : tensor + %46 = arith.muli %arg12, %c56 : index + %47:2 = scf.for %arg15 = %13 to %14 step %c1 iter_args(%arg16 = %extracted_4, %arg17 = %extracted_5) -> (i32, f32) { + %48 = arith.index_cast %arg16 : i32 to index + %49 = arith.addi %48, %27 : index + %50 = arith.index_cast %49 : index to i32 + %51 = arith.muli %arg15, %c8 : index + %52 = scf.for %arg18 = %34 to %41 step %c1 iter_args(%arg19 = %arg17) -> (f32) { + %53 = arith.addi %arg18, %51 : index + %54 = arith.addi %53, %4 : index + %55 = arith.addi %54, %46 : index + %extracted_8 = tensor.extract %1[%55] : tensor + %56 = arith.addf %arg19, %extracted_8 : f32 + scf.yield %56 : f32 + } + scf.yield %50, %52 : i32, f32 + } + %inserted_6 = tensor.insert %47#0 into %arg13[%arg8] : tensor + %inserted_7 = tensor.insert %47#1 into %arg14[%arg8] : tensor + affine.yield %inserted_6, %inserted_7 : tensor, tensor + } + %extracted = tensor.extract %42#0[%arg8] : tensor + %extracted_2 = tensor.extract %42#1[%arg8] : tensor + %43 = arith.sitofp %extracted : i32 to f32 + %44 = arith.divf %extracted_2, %43 : f32 + %45 = affine.apply #map2(%arg2, %arg8, %arg4, %arg6) + %inserted_3 = tensor.insert %44 into %arg11[%45] : tensor + affine.yield %42#0, %42#1, %inserted_3 : tensor, tensor, tensor + } + affine.yield %17#2 : tensor + } + affine.yield %6 : tensor + } + affine.yield %5 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu/matched.mlir new file mode 100644 index 000000000000..cbfebd361a9b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu/matched.mlir @@ -0,0 +1,109 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0 * 27 + d1 + d2 * 9 + d3 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c3_i32 = arith.constant 3 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c8 = arith.constant 8 : index + %c10 = arith.constant 10 : index + %c336 = arith.constant 336 : index + %c56 = arith.constant 56 : index + %c-11 = arith.constant -11 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %4 = arith.muli %arg2, %c336 : index + %5 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %6 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg5) -> (tensor) { + %7 = arith.muli %arg6, %c7 : index + %8 = arith.cmpi slt, %7, %c0 : index + %9 = arith.subi %c-1, %7 : index + %10 = arith.select %8, %9, %7 : index + %11 = arith.divsi %10, %c3 : index + %12 = arith.subi %c-1, %11 : index + %13 = arith.select %8, %12, %11 : index + %14 = arith.addi %13, %c3 : index + %alloca = memref.alloca(%c3) : memref + %15 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %16 = bufferization.to_tensor %alloca_0 : memref + %17:3 = affine.for %arg8 = 0 to 3 iter_args(%arg9 = %15, %arg10 = %16, %arg11 = %arg7) -> (tensor, tensor, tensor) { + %18 = arith.index_cast %arg8 : index to i32 + %19 = arith.muli %18, %c8_i32 : i32 + %20 = arith.divsi %19, %c3_i32 : i32 + %21 = arith.addi %18, %c1_i32 : i32 + %22 = arith.muli %21, %c8_i32 : i32 + %23 = arith.addi %22, %c2_i32 : i32 + %24 = arith.divsi %23, %c3_i32 : i32 + %25 = arith.index_cast %24 : i32 to index + %26 = arith.index_cast %20 : i32 to index + %27 = arith.subi %25, %26 : index + %28 = arith.muli %arg8, %c8 : index + %29 = arith.cmpi slt, %28, %c0 : index + %30 = arith.subi %c-1, %28 : index + %31 = arith.select %29, %30, %28 : index + %32 = arith.divsi %31, %c3 : index + %33 = arith.subi %c-1, %32 : index + %34 = arith.select %29, %33, %32 : index + %35 = arith.addi %28, %c10 : index + %36 = arith.cmpi slt, %35, %c0 : index + %37 = arith.subi %c-11, %28 : index + %38 = arith.select %36, %37, %35 : index + %39 = arith.divsi %38, %c3 : index + %40 = arith.subi %c-1, %39 : index + %41 = arith.select %36, %40, %39 : index + %inserted = tensor.insert %c0_i32 into %arg9[%arg8] : tensor + %inserted_1 = tensor.insert %cst into %arg10[%arg8] : tensor + %42:2 = affine.for %arg12 = #map(%arg4) to #map1(%arg4) iter_args(%arg13 = %inserted, %arg14 = %inserted_1) -> (tensor, tensor) { + %extracted_4 = tensor.extract %arg13[%arg8] : tensor + %extracted_5 = tensor.extract %arg14[%arg8] : tensor + %46 = arith.muli %arg12, %c56 : index + %47:2 = scf.for %arg15 = %13 to %14 step %c1 iter_args(%arg16 = %extracted_4, %arg17 = %extracted_5) -> (i32, f32) { + %48 = arith.index_cast %arg16 : i32 to index + %49 = arith.addi %48, %27 : index + %50 = arith.index_cast %49 : index to i32 + %51 = arith.muli %arg15, %c8 : index + %52 = scf.for %arg18 = %34 to %41 step %c1 iter_args(%arg19 = %arg17) -> (f32) { + %53 = arith.addi %arg18, %51 : index + %54 = arith.addi %53, %4 : index + %55 = arith.addi %54, %46 : index + %extracted_8 = tensor.extract %1[%55] : tensor + %56 = arith.addf %arg19, %extracted_8 : f32 + scf.yield %56 : f32 + } + scf.yield %50, %52 : i32, f32 + } + %inserted_6 = tensor.insert %47#0 into %arg13[%arg8] : tensor + %inserted_7 = tensor.insert %47#1 into %arg14[%arg8] : tensor + affine.yield %inserted_6, %inserted_7 : tensor, tensor + } + %extracted = tensor.extract %42#0[%arg8] : tensor + %extracted_2 = tensor.extract %42#1[%arg8] : tensor + %43 = arith.sitofp %extracted : i32 to f32 + %44 = arith.divf %extracted_2, %43 : f32 + %45 = affine.apply #map2(%arg2, %arg8, %arg4, %arg6) + %inserted_3 = tensor.insert %44 into %arg11[%45] : tensor + affine.yield %42#0, %42#1, %inserted_3 : tensor, tensor, tensor + } + affine.yield %17#2 : tensor + } + affine.yield %6 : tensor + } + affine.yield %5 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu/orig.mlir new file mode 100644 index 000000000000..5d3ded8b9941 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu/orig.mlir @@ -0,0 +1,86 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-11 = arith.constant -11 : index + %c56 = arith.constant 56 : index + %c336 = arith.constant 336 : index + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c3_i32 = arith.constant 3 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg2 = 0 to 2 { + %0 = arith.muli %arg2, %c336 : index + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + %1 = arith.muli %arg4, %c7 : index + %2 = arith.cmpi slt, %1, %c0 : index + %3 = arith.subi %c-1, %1 : index + %4 = arith.select %2, %3, %1 : index + %5 = arith.divsi %4, %c3 : index + %6 = arith.subi %c-1, %5 : index + %7 = arith.select %2, %6, %5 : index + %8 = arith.addi %7, %c3 : index + affine.for %arg5 = 0 to 3 { + %9 = arith.index_cast %arg5 : index to i32 + %10 = arith.muli %9, %c8_i32 : i32 + %11 = arith.divsi %10, %c3_i32 : i32 + %12 = arith.addi %9, %c1_i32 : i32 + %13 = arith.muli %12, %c8_i32 : i32 + %14 = arith.addi %13, %c2_i32 : i32 + %15 = arith.divsi %14, %c3_i32 : i32 + %16 = arith.index_cast %15 : i32 to index + %17 = arith.index_cast %11 : i32 to index + %18 = arith.subi %16, %17 : index + %19 = arith.muli %arg5, %c8 : index + %20 = arith.cmpi slt, %19, %c0 : index + %21 = arith.subi %c-1, %19 : index + %22 = arith.select %20, %21, %19 : index + %23 = arith.divsi %22, %c3 : index + %24 = arith.subi %c-1, %23 : index + %25 = arith.select %20, %24, %23 : index + %26 = arith.addi %19, %c10 : index + %27 = arith.cmpi slt, %26, %c0 : index + %28 = arith.subi %c-11, %19 : index + %29 = arith.select %27, %28, %26 : index + %30 = arith.divsi %29, %c3 : index + %31 = arith.subi %c-1, %30 : index + %32 = arith.select %27, %31, %30 : index + %33:2 = affine.for %arg6 = #map(%arg3) to #map1(%arg3) iter_args(%arg7 = %c0_i32, %arg8 = %cst) -> (i32, f32) { + %36 = arith.muli %arg6, %c56 : index + %37:2 = scf.for %arg9 = %7 to %8 step %c1 iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (i32, f32) { + %38 = arith.index_cast %arg10 : i32 to index + %39 = arith.addi %38, %18 : index + %40 = arith.index_cast %39 : index to i32 + %41 = arith.muli %arg9, %c8 : index + %42 = scf.for %arg12 = %25 to %32 step %c1 iter_args(%arg13 = %arg11) -> (f32) { + %43 = arith.addi %arg12, %41 : index + %44 = arith.addi %43, %0 : index + %45 = arith.addi %44, %36 : index + %46 = memref.load %arg0[%45] : memref + %47 = arith.addf %arg13, %46 : f32 + scf.yield %47 : f32 + } + scf.yield %40, %42 : i32, f32 + } + affine.yield %37#0, %37#1 : i32, f32 + } + %34 = arith.sitofp %33#0 : i32 to f32 + %35 = arith.divf %33#1, %34 : f32 + affine.store %35, %arg1[%arg2 * 27 + %arg5 + %arg3 * 9 + %arg4 * 3] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu/raised.mlir new file mode 100644 index 000000000000..7040d43cc80a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu/raised.mlir @@ -0,0 +1,96 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-11 = arith.constant -11 : index + %c56 = arith.constant 56 : index + %c336 = arith.constant 336 : index + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c3_i32 = arith.constant 3 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg2 = 0 to 2 { + %0 = arith.muli %arg2, %c336 : index + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + %1 = arith.muli %arg4, %c7 : index + %2 = arith.cmpi slt, %1, %c0 : index + %3 = arith.subi %c-1, %1 : index + %4 = arith.select %2, %3, %1 : index + %5 = arith.divsi %4, %c3 : index + %6 = arith.subi %c-1, %5 : index + %7 = arith.select %2, %6, %5 : index + %8 = arith.addi %7, %c3 : index + %alloca = memref.alloca(%c3) : memref + %alloca_0 = memref.alloca(%c3) : memref + affine.for %arg5 = 0 to 3 { + %9 = arith.index_cast %arg5 : index to i32 + %10 = arith.muli %9, %c8_i32 : i32 + %11 = arith.divsi %10, %c3_i32 : i32 + %12 = arith.addi %9, %c1_i32 : i32 + %13 = arith.muli %12, %c8_i32 : i32 + %14 = arith.addi %13, %c2_i32 : i32 + %15 = arith.divsi %14, %c3_i32 : i32 + %16 = arith.index_cast %15 : i32 to index + %17 = arith.index_cast %11 : i32 to index + %18 = arith.subi %16, %17 : index + %19 = arith.muli %arg5, %c8 : index + %20 = arith.cmpi slt, %19, %c0 : index + %21 = arith.subi %c-1, %19 : index + %22 = arith.select %20, %21, %19 : index + %23 = arith.divsi %22, %c3 : index + %24 = arith.subi %c-1, %23 : index + %25 = arith.select %20, %24, %23 : index + %26 = arith.addi %19, %c10 : index + %27 = arith.cmpi slt, %26, %c0 : index + %28 = arith.subi %c-11, %19 : index + %29 = arith.select %27, %28, %26 : index + %30 = arith.divsi %29, %c3 : index + %31 = arith.subi %c-1, %30 : index + %32 = arith.select %27, %31, %30 : index + affine.store %c0_i32, %alloca[%arg5] : memref + affine.store %cst, %alloca_0[%arg5] : memref + affine.for %arg6 = #map(%arg3) to #map1(%arg3) { + %37 = affine.load %alloca[%arg5] : memref + %38 = affine.load %alloca_0[%arg5] : memref + %39 = arith.muli %arg6, %c56 : index + %40:2 = scf.for %arg7 = %7 to %8 step %c1 iter_args(%arg8 = %37, %arg9 = %38) -> (i32, f32) { + %41 = arith.index_cast %arg8 : i32 to index + %42 = arith.addi %41, %18 : index + %43 = arith.index_cast %42 : index to i32 + %44 = arith.muli %arg7, %c8 : index + %45 = scf.for %arg10 = %25 to %32 step %c1 iter_args(%arg11 = %arg9) -> (f32) { + %46 = arith.addi %arg10, %44 : index + %47 = arith.addi %46, %0 : index + %48 = arith.addi %47, %39 : index + %49 = memref.load %arg0[%48] : memref + %50 = arith.addf %arg11, %49 : f32 + scf.yield %50 : f32 + } + scf.yield %43, %45 : i32, f32 + } + affine.store %40#0, %alloca[%arg5] : memref + affine.store %40#1, %alloca_0[%arg5] : memref + } + %33 = affine.load %alloca[%arg5] : memref + %34 = affine.load %alloca_0[%arg5] : memref + %35 = arith.sitofp %33 : i32 to f32 + %36 = arith.divf %34, %35 : f32 + affine.store %36, %arg1[%arg2 * 27 + %arg5 + %arg3 * 9 + %arg4 * 3] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu_debuf.mlir new file mode 100644 index 000000000000..cbfebd361a9b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu_debuf.mlir @@ -0,0 +1,109 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0 * 27 + d1 + d2 * 9 + d3 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c3_i32 = arith.constant 3 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c8 = arith.constant 8 : index + %c10 = arith.constant 10 : index + %c336 = arith.constant 336 : index + %c56 = arith.constant 56 : index + %c-11 = arith.constant -11 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %4 = arith.muli %arg2, %c336 : index + %5 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %6 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg5) -> (tensor) { + %7 = arith.muli %arg6, %c7 : index + %8 = arith.cmpi slt, %7, %c0 : index + %9 = arith.subi %c-1, %7 : index + %10 = arith.select %8, %9, %7 : index + %11 = arith.divsi %10, %c3 : index + %12 = arith.subi %c-1, %11 : index + %13 = arith.select %8, %12, %11 : index + %14 = arith.addi %13, %c3 : index + %alloca = memref.alloca(%c3) : memref + %15 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %16 = bufferization.to_tensor %alloca_0 : memref + %17:3 = affine.for %arg8 = 0 to 3 iter_args(%arg9 = %15, %arg10 = %16, %arg11 = %arg7) -> (tensor, tensor, tensor) { + %18 = arith.index_cast %arg8 : index to i32 + %19 = arith.muli %18, %c8_i32 : i32 + %20 = arith.divsi %19, %c3_i32 : i32 + %21 = arith.addi %18, %c1_i32 : i32 + %22 = arith.muli %21, %c8_i32 : i32 + %23 = arith.addi %22, %c2_i32 : i32 + %24 = arith.divsi %23, %c3_i32 : i32 + %25 = arith.index_cast %24 : i32 to index + %26 = arith.index_cast %20 : i32 to index + %27 = arith.subi %25, %26 : index + %28 = arith.muli %arg8, %c8 : index + %29 = arith.cmpi slt, %28, %c0 : index + %30 = arith.subi %c-1, %28 : index + %31 = arith.select %29, %30, %28 : index + %32 = arith.divsi %31, %c3 : index + %33 = arith.subi %c-1, %32 : index + %34 = arith.select %29, %33, %32 : index + %35 = arith.addi %28, %c10 : index + %36 = arith.cmpi slt, %35, %c0 : index + %37 = arith.subi %c-11, %28 : index + %38 = arith.select %36, %37, %35 : index + %39 = arith.divsi %38, %c3 : index + %40 = arith.subi %c-1, %39 : index + %41 = arith.select %36, %40, %39 : index + %inserted = tensor.insert %c0_i32 into %arg9[%arg8] : tensor + %inserted_1 = tensor.insert %cst into %arg10[%arg8] : tensor + %42:2 = affine.for %arg12 = #map(%arg4) to #map1(%arg4) iter_args(%arg13 = %inserted, %arg14 = %inserted_1) -> (tensor, tensor) { + %extracted_4 = tensor.extract %arg13[%arg8] : tensor + %extracted_5 = tensor.extract %arg14[%arg8] : tensor + %46 = arith.muli %arg12, %c56 : index + %47:2 = scf.for %arg15 = %13 to %14 step %c1 iter_args(%arg16 = %extracted_4, %arg17 = %extracted_5) -> (i32, f32) { + %48 = arith.index_cast %arg16 : i32 to index + %49 = arith.addi %48, %27 : index + %50 = arith.index_cast %49 : index to i32 + %51 = arith.muli %arg15, %c8 : index + %52 = scf.for %arg18 = %34 to %41 step %c1 iter_args(%arg19 = %arg17) -> (f32) { + %53 = arith.addi %arg18, %51 : index + %54 = arith.addi %53, %4 : index + %55 = arith.addi %54, %46 : index + %extracted_8 = tensor.extract %1[%55] : tensor + %56 = arith.addf %arg19, %extracted_8 : f32 + scf.yield %56 : f32 + } + scf.yield %50, %52 : i32, f32 + } + %inserted_6 = tensor.insert %47#0 into %arg13[%arg8] : tensor + %inserted_7 = tensor.insert %47#1 into %arg14[%arg8] : tensor + affine.yield %inserted_6, %inserted_7 : tensor, tensor + } + %extracted = tensor.extract %42#0[%arg8] : tensor + %extracted_2 = tensor.extract %42#1[%arg8] : tensor + %43 = arith.sitofp %extracted : i32 to f32 + %44 = arith.divf %extracted_2, %43 : f32 + %45 = affine.apply #map2(%arg2, %arg8, %arg4, %arg6) + %inserted_3 = tensor.insert %44 into %arg11[%45] : tensor + affine.yield %42#0, %42#1, %inserted_3 : tensor, tensor, tensor + } + affine.yield %17#2 : tensor + } + affine.yield %6 : tensor + } + affine.yield %5 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu_linalg.mlir new file mode 100644 index 000000000000..7040d43cc80a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_cpu_linalg.mlir @@ -0,0 +1,96 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-11 = arith.constant -11 : index + %c56 = arith.constant 56 : index + %c336 = arith.constant 336 : index + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c3_i32 = arith.constant 3 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg2 = 0 to 2 { + %0 = arith.muli %arg2, %c336 : index + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + %1 = arith.muli %arg4, %c7 : index + %2 = arith.cmpi slt, %1, %c0 : index + %3 = arith.subi %c-1, %1 : index + %4 = arith.select %2, %3, %1 : index + %5 = arith.divsi %4, %c3 : index + %6 = arith.subi %c-1, %5 : index + %7 = arith.select %2, %6, %5 : index + %8 = arith.addi %7, %c3 : index + %alloca = memref.alloca(%c3) : memref + %alloca_0 = memref.alloca(%c3) : memref + affine.for %arg5 = 0 to 3 { + %9 = arith.index_cast %arg5 : index to i32 + %10 = arith.muli %9, %c8_i32 : i32 + %11 = arith.divsi %10, %c3_i32 : i32 + %12 = arith.addi %9, %c1_i32 : i32 + %13 = arith.muli %12, %c8_i32 : i32 + %14 = arith.addi %13, %c2_i32 : i32 + %15 = arith.divsi %14, %c3_i32 : i32 + %16 = arith.index_cast %15 : i32 to index + %17 = arith.index_cast %11 : i32 to index + %18 = arith.subi %16, %17 : index + %19 = arith.muli %arg5, %c8 : index + %20 = arith.cmpi slt, %19, %c0 : index + %21 = arith.subi %c-1, %19 : index + %22 = arith.select %20, %21, %19 : index + %23 = arith.divsi %22, %c3 : index + %24 = arith.subi %c-1, %23 : index + %25 = arith.select %20, %24, %23 : index + %26 = arith.addi %19, %c10 : index + %27 = arith.cmpi slt, %26, %c0 : index + %28 = arith.subi %c-11, %19 : index + %29 = arith.select %27, %28, %26 : index + %30 = arith.divsi %29, %c3 : index + %31 = arith.subi %c-1, %30 : index + %32 = arith.select %27, %31, %30 : index + affine.store %c0_i32, %alloca[%arg5] : memref + affine.store %cst, %alloca_0[%arg5] : memref + affine.for %arg6 = #map(%arg3) to #map1(%arg3) { + %37 = affine.load %alloca[%arg5] : memref + %38 = affine.load %alloca_0[%arg5] : memref + %39 = arith.muli %arg6, %c56 : index + %40:2 = scf.for %arg7 = %7 to %8 step %c1 iter_args(%arg8 = %37, %arg9 = %38) -> (i32, f32) { + %41 = arith.index_cast %arg8 : i32 to index + %42 = arith.addi %41, %18 : index + %43 = arith.index_cast %42 : index to i32 + %44 = arith.muli %arg7, %c8 : index + %45 = scf.for %arg10 = %25 to %32 step %c1 iter_args(%arg11 = %arg9) -> (f32) { + %46 = arith.addi %arg10, %44 : index + %47 = arith.addi %46, %0 : index + %48 = arith.addi %47, %39 : index + %49 = memref.load %arg0[%48] : memref + %50 = arith.addf %arg11, %49 : f32 + scf.yield %50 : f32 + } + scf.yield %43, %45 : i32, f32 + } + affine.store %40#0, %alloca[%arg5] : memref + affine.store %40#1, %alloca_0[%arg5] : memref + } + %33 = affine.load %alloca[%arg5] : memref + %34 = affine.load %alloca_0[%arg5] : memref + %35 = arith.sitofp %33 : i32 to f32 + %36 = arith.divf %34, %35 : f32 + affine.store %36, %arg1[%arg2 * 27 + %arg5 + %arg3 * 9 + %arg4 * 3] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_debuf.mlir new file mode 100644 index 000000000000..eabbfe014856 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5 + d2 * 2, d6 + d3 * 2, d7 + d4 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 8.000000e+00 : f32 + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c3, %c4, %c4, %c4, %c2, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%3 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.divf %in, %cst_0 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_linalg.mlir b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_linalg.mlir new file mode 100644 index 000000000000..508f6eec4399 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_avg_pool3d_linalg.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5 + d2 * 2, d6 + d3 * 2, d7 + d4 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_avg_pool3d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c3, %c4, %c4, %c4, %c2, %c2, %c2) {map = #map1} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview_1 = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%0 : memref) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.divf %in, %cst : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu.mlir new file mode 100644 index 000000000000..4d70842b05f3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu.mlir @@ -0,0 +1,47 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool1d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-39 = arith.constant -39 : index + %c38 = arith.constant 38 : index + %c-1 = arith.constant -1 : index + %c32 = arith.constant 32 : index + %c7 = arith.constant 7 : index + %c32_i32 = arith.constant 32 : i32 + %c7_i32 = arith.constant 7 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 7 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = arith.muli %0, %c32_i32 : i32 + %2 = arith.divsi %1, %c7_i32 : i32 + %3 = arith.muli %arg4, %c32 : index + %4 = arith.cmpi slt, %3, %c0 : index + %5 = arith.subi %c-1, %3 : index + %6 = arith.select %4, %5, %3 : index + %7 = arith.divsi %6, %c7 : index + %8 = arith.subi %c-1, %7 : index + %9 = arith.select %4, %8, %7 : index + %10 = memref.load %arg0[%arg3, %9] : memref + %11 = arith.addi %9, %c1 : index + %12 = arith.addi %3, %c38 : index + %13 = arith.cmpi slt, %12, %c0 : index + %14 = arith.subi %c-39, %3 : index + %15 = arith.select %13, %14, %12 : index + %16 = arith.divsi %15, %c7 : index + %17 = arith.subi %c-1, %16 : index + %18 = arith.select %13, %17, %16 : index + %19:2 = scf.for %arg5 = %11 to %18 step %c1 iter_args(%arg6 = %10, %arg7 = %2) -> (f32, i32) { + %20 = arith.index_cast %arg5 : index to i32 + %21 = memref.load %arg0[%arg3, %arg5] : memref + %22 = arith.cmpf ogt, %21, %arg6 : f32 + %23 = arith.select %22, %20, %arg7 : i32 + %24 = arith.select %22, %21, %arg6 : f32 + scf.yield %24, %23 : f32, i32 + } + affine.store %19#0, %arg1[%arg3, %arg4] : memref + affine.store %19#1, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu/debuf.mlir new file mode 100644 index 000000000000..92ddb3833615 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu/debuf.mlir @@ -0,0 +1,57 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool1d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c7_i32 = arith.constant 7 : i32 + %c32_i32 = arith.constant 32 : i32 + %c7 = arith.constant 7 : index + %c32 = arith.constant 32 : index + %c-1 = arith.constant -1 : index + %c38 = arith.constant 38 : index + %c-39 = arith.constant -39 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 4 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %6:2 = affine.for %arg6 = 0 to 7 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %7 = arith.index_cast %arg6 : index to i32 + %8 = arith.muli %7, %c32_i32 : i32 + %9 = arith.divsi %8, %c7_i32 : i32 + %10 = arith.muli %arg6, %c32 : index + %11 = arith.cmpi slt, %10, %c0 : index + %12 = arith.subi %c-1, %10 : index + %13 = arith.select %11, %12, %10 : index + %14 = arith.divsi %13, %c7 : index + %15 = arith.subi %c-1, %14 : index + %16 = arith.select %11, %15, %14 : index + %extracted = tensor.extract %2[%arg3, %16] : tensor + %17 = arith.addi %16, %c1 : index + %18 = arith.addi %10, %c38 : index + %19 = arith.cmpi slt, %18, %c0 : index + %20 = arith.subi %c-39, %10 : index + %21 = arith.select %19, %20, %18 : index + %22 = arith.divsi %21, %c7 : index + %23 = arith.subi %c-1, %22 : index + %24 = arith.select %19, %23, %22 : index + %25:2 = scf.for %arg9 = %17 to %24 step %c1 iter_args(%arg10 = %extracted, %arg11 = %9) -> (f32, i32) { + %26 = arith.index_cast %arg9 : index to i32 + %extracted_1 = tensor.extract %2[%arg3, %arg9] : tensor + %27 = arith.cmpf ogt, %extracted_1, %arg10 : f32 + %28 = arith.select %27, %26, %arg11 : i32 + %29 = arith.select %27, %extracted_1, %arg10 : f32 + scf.yield %29, %28 : f32, i32 + } + %inserted = tensor.insert %25#0 into %arg7[%arg3, %arg6] : tensor + %inserted_0 = tensor.insert %25#1 into %arg8[%arg3, %arg6] : tensor + affine.yield %inserted, %inserted_0 : tensor, tensor + } + affine.yield %6#0, %6#1 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu/matched.mlir new file mode 100644 index 000000000000..92ddb3833615 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu/matched.mlir @@ -0,0 +1,57 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool1d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c7_i32 = arith.constant 7 : i32 + %c32_i32 = arith.constant 32 : i32 + %c7 = arith.constant 7 : index + %c32 = arith.constant 32 : index + %c-1 = arith.constant -1 : index + %c38 = arith.constant 38 : index + %c-39 = arith.constant -39 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 4 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %6:2 = affine.for %arg6 = 0 to 7 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %7 = arith.index_cast %arg6 : index to i32 + %8 = arith.muli %7, %c32_i32 : i32 + %9 = arith.divsi %8, %c7_i32 : i32 + %10 = arith.muli %arg6, %c32 : index + %11 = arith.cmpi slt, %10, %c0 : index + %12 = arith.subi %c-1, %10 : index + %13 = arith.select %11, %12, %10 : index + %14 = arith.divsi %13, %c7 : index + %15 = arith.subi %c-1, %14 : index + %16 = arith.select %11, %15, %14 : index + %extracted = tensor.extract %2[%arg3, %16] : tensor + %17 = arith.addi %16, %c1 : index + %18 = arith.addi %10, %c38 : index + %19 = arith.cmpi slt, %18, %c0 : index + %20 = arith.subi %c-39, %10 : index + %21 = arith.select %19, %20, %18 : index + %22 = arith.divsi %21, %c7 : index + %23 = arith.subi %c-1, %22 : index + %24 = arith.select %19, %23, %22 : index + %25:2 = scf.for %arg9 = %17 to %24 step %c1 iter_args(%arg10 = %extracted, %arg11 = %9) -> (f32, i32) { + %26 = arith.index_cast %arg9 : index to i32 + %extracted_1 = tensor.extract %2[%arg3, %arg9] : tensor + %27 = arith.cmpf ogt, %extracted_1, %arg10 : f32 + %28 = arith.select %27, %26, %arg11 : i32 + %29 = arith.select %27, %extracted_1, %arg10 : f32 + scf.yield %29, %28 : f32, i32 + } + %inserted = tensor.insert %25#0 into %arg7[%arg3, %arg6] : tensor + %inserted_0 = tensor.insert %25#1 into %arg8[%arg3, %arg6] : tensor + affine.yield %inserted, %inserted_0 : tensor, tensor + } + affine.yield %6#0, %6#1 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu/orig.mlir new file mode 100644 index 000000000000..4d70842b05f3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu/orig.mlir @@ -0,0 +1,47 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool1d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-39 = arith.constant -39 : index + %c38 = arith.constant 38 : index + %c-1 = arith.constant -1 : index + %c32 = arith.constant 32 : index + %c7 = arith.constant 7 : index + %c32_i32 = arith.constant 32 : i32 + %c7_i32 = arith.constant 7 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 7 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = arith.muli %0, %c32_i32 : i32 + %2 = arith.divsi %1, %c7_i32 : i32 + %3 = arith.muli %arg4, %c32 : index + %4 = arith.cmpi slt, %3, %c0 : index + %5 = arith.subi %c-1, %3 : index + %6 = arith.select %4, %5, %3 : index + %7 = arith.divsi %6, %c7 : index + %8 = arith.subi %c-1, %7 : index + %9 = arith.select %4, %8, %7 : index + %10 = memref.load %arg0[%arg3, %9] : memref + %11 = arith.addi %9, %c1 : index + %12 = arith.addi %3, %c38 : index + %13 = arith.cmpi slt, %12, %c0 : index + %14 = arith.subi %c-39, %3 : index + %15 = arith.select %13, %14, %12 : index + %16 = arith.divsi %15, %c7 : index + %17 = arith.subi %c-1, %16 : index + %18 = arith.select %13, %17, %16 : index + %19:2 = scf.for %arg5 = %11 to %18 step %c1 iter_args(%arg6 = %10, %arg7 = %2) -> (f32, i32) { + %20 = arith.index_cast %arg5 : index to i32 + %21 = memref.load %arg0[%arg3, %arg5] : memref + %22 = arith.cmpf ogt, %21, %arg6 : f32 + %23 = arith.select %22, %20, %arg7 : i32 + %24 = arith.select %22, %21, %arg6 : f32 + scf.yield %24, %23 : f32, i32 + } + affine.store %19#0, %arg1[%arg3, %arg4] : memref + affine.store %19#1, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu/raised.mlir new file mode 100644 index 000000000000..afa53408fc82 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu/raised.mlir @@ -0,0 +1,48 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool1d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-39 = arith.constant -39 : index + %c38 = arith.constant 38 : index + %c-1 = arith.constant -1 : index + %c32 = arith.constant 32 : index + %c7 = arith.constant 7 : index + %c32_i32 = arith.constant 32 : i32 + %c7_i32 = arith.constant 7 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 7 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = arith.muli %0, %c32_i32 : i32 + %2 = arith.divsi %1, %c7_i32 : i32 + %3 = arith.muli %arg4, %c32 : index + %4 = arith.cmpi slt, %3, %c0 : index + %5 = arith.subi %c-1, %3 : index + %6 = arith.select %4, %5, %3 : index + %7 = arith.divsi %6, %c7 : index + %8 = arith.subi %c-1, %7 : index + %9 = arith.select %4, %8, %7 : index + %10 = memref.load %arg0[%arg3, %9] : memref + %11 = arith.addi %9, %c1 : index + %12 = arith.addi %3, %c38 : index + %13 = arith.cmpi slt, %12, %c0 : index + %14 = arith.subi %c-39, %3 : index + %15 = arith.select %13, %14, %12 : index + %16 = arith.divsi %15, %c7 : index + %17 = arith.subi %c-1, %16 : index + %18 = arith.select %13, %17, %16 : index + %19:2 = scf.for %arg5 = %11 to %18 step %c1 iter_args(%arg6 = %10, %arg7 = %2) -> (f32, i32) { + %20 = arith.index_cast %arg5 : index to i32 + %21 = memref.load %arg0[%arg3, %arg5] : memref + %22 = arith.cmpf ogt, %21, %arg6 : f32 + %23 = arith.select %22, %20, %arg7 : i32 + %24 = arith.select %22, %21, %arg6 : f32 + scf.yield %24, %23 : f32, i32 + } + affine.store %19#0, %arg1[%arg3, %arg4] : memref + affine.store %19#1, %arg2[%arg3, %arg4] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu_debuf.mlir new file mode 100644 index 000000000000..92ddb3833615 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu_debuf.mlir @@ -0,0 +1,57 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool1d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c7_i32 = arith.constant 7 : i32 + %c32_i32 = arith.constant 32 : i32 + %c7 = arith.constant 7 : index + %c32 = arith.constant 32 : index + %c-1 = arith.constant -1 : index + %c38 = arith.constant 38 : index + %c-39 = arith.constant -39 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 4 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %6:2 = affine.for %arg6 = 0 to 7 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %7 = arith.index_cast %arg6 : index to i32 + %8 = arith.muli %7, %c32_i32 : i32 + %9 = arith.divsi %8, %c7_i32 : i32 + %10 = arith.muli %arg6, %c32 : index + %11 = arith.cmpi slt, %10, %c0 : index + %12 = arith.subi %c-1, %10 : index + %13 = arith.select %11, %12, %10 : index + %14 = arith.divsi %13, %c7 : index + %15 = arith.subi %c-1, %14 : index + %16 = arith.select %11, %15, %14 : index + %extracted = tensor.extract %2[%arg3, %16] : tensor + %17 = arith.addi %16, %c1 : index + %18 = arith.addi %10, %c38 : index + %19 = arith.cmpi slt, %18, %c0 : index + %20 = arith.subi %c-39, %10 : index + %21 = arith.select %19, %20, %18 : index + %22 = arith.divsi %21, %c7 : index + %23 = arith.subi %c-1, %22 : index + %24 = arith.select %19, %23, %22 : index + %25:2 = scf.for %arg9 = %17 to %24 step %c1 iter_args(%arg10 = %extracted, %arg11 = %9) -> (f32, i32) { + %26 = arith.index_cast %arg9 : index to i32 + %extracted_1 = tensor.extract %2[%arg3, %arg9] : tensor + %27 = arith.cmpf ogt, %extracted_1, %arg10 : f32 + %28 = arith.select %27, %26, %arg11 : i32 + %29 = arith.select %27, %extracted_1, %arg10 : f32 + scf.yield %29, %28 : f32, i32 + } + %inserted = tensor.insert %25#0 into %arg7[%arg3, %arg6] : tensor + %inserted_0 = tensor.insert %25#1 into %arg8[%arg3, %arg6] : tensor + affine.yield %inserted, %inserted_0 : tensor, tensor + } + affine.yield %6#0, %6#1 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu_linalg.mlir new file mode 100644 index 000000000000..afa53408fc82 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool1d_cpu_linalg.mlir @@ -0,0 +1,48 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool1d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-39 = arith.constant -39 : index + %c38 = arith.constant 38 : index + %c-1 = arith.constant -1 : index + %c32 = arith.constant 32 : index + %c7 = arith.constant 7 : index + %c32_i32 = arith.constant 32 : i32 + %c7_i32 = arith.constant 7 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 7 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = arith.muli %0, %c32_i32 : i32 + %2 = arith.divsi %1, %c7_i32 : i32 + %3 = arith.muli %arg4, %c32 : index + %4 = arith.cmpi slt, %3, %c0 : index + %5 = arith.subi %c-1, %3 : index + %6 = arith.select %4, %5, %3 : index + %7 = arith.divsi %6, %c7 : index + %8 = arith.subi %c-1, %7 : index + %9 = arith.select %4, %8, %7 : index + %10 = memref.load %arg0[%arg3, %9] : memref + %11 = arith.addi %9, %c1 : index + %12 = arith.addi %3, %c38 : index + %13 = arith.cmpi slt, %12, %c0 : index + %14 = arith.subi %c-39, %3 : index + %15 = arith.select %13, %14, %12 : index + %16 = arith.divsi %15, %c7 : index + %17 = arith.subi %c-1, %16 : index + %18 = arith.select %13, %17, %16 : index + %19:2 = scf.for %arg5 = %11 to %18 step %c1 iter_args(%arg6 = %10, %arg7 = %2) -> (f32, i32) { + %20 = arith.index_cast %arg5 : index to i32 + %21 = memref.load %arg0[%arg3, %arg5] : memref + %22 = arith.cmpf ogt, %21, %arg6 : f32 + %23 = arith.select %22, %20, %arg7 : i32 + %24 = arith.select %22, %21, %arg6 : f32 + scf.yield %24, %23 : f32, i32 + } + affine.store %19#0, %arg1[%arg3, %arg4] : memref + affine.store %19#1, %arg2[%arg3, %arg4] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu.mlir new file mode 100644 index 000000000000..94adb47460d7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c42_i32 = arith.constant 42 : i32 + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 84 { + affine.store %cst, %arg2[%arg3] : memref + } + affine.for %arg3 = 0 to 2 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.muli %0, %c42_i32 : i32 + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + %2 = affine.load %arg1[%arg5 + %arg3 * 9 + %arg4 * 3] : memref + %3 = arith.addi %1, %2 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = affine.load %arg0[%arg5 + %arg3 * 9 + %arg4 * 3] : memref + %6 = memref.load %arg2[%4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg2[%4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..1272dfbc8b04 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu/debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0 + d1 * 9 + d2 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c42_i32 = arith.constant 42 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %3) -> (tensor) { + %6 = arith.index_cast %arg3 : index to i32 + %7 = arith.muli %6, %c42_i32 : i32 + %8 = affine.for %arg5 = 0 to 3 iter_args(%arg6 = %arg4) -> (tensor) { + %9 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %arg6) -> (tensor) { + %10 = affine.apply #map1(%arg7, %arg3, %arg5) + %extracted = tensor.extract %1[%10] : tensor + %11 = arith.addi %7, %extracted : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = affine.apply #map1(%arg7, %arg3, %arg5) + %extracted_0 = tensor.extract %2[%13] : tensor + %extracted_1 = tensor.extract %arg8[%12] : tensor + %14 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %14 into %arg8[%12] : tensor + affine.yield %inserted : tensor + } + affine.yield %9 : tensor + } + affine.yield %8 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..88d1a4defe65 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu/matched.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0 + d1 * 9 + d2 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c42_i32 = arith.constant 42 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %4 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %3) -> (tensor) { + %6 = arith.index_cast %arg3 : index to i32 + %7 = arith.muli %6, %c42_i32 : i32 + %8 = affine.for %arg5 = 0 to 3 iter_args(%arg6 = %arg4) -> (tensor) { + %9 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %arg6) -> (tensor) { + %10 = affine.apply #map1(%arg7, %arg3, %arg5) + %extracted = tensor.extract %1[%10] : tensor + %11 = arith.addi %7, %extracted : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = affine.apply #map1(%arg7, %arg3, %arg5) + %extracted_0 = tensor.extract %2[%13] : tensor + %extracted_1 = tensor.extract %arg8[%12] : tensor + %14 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %14 into %arg8[%12] : tensor + affine.yield %inserted : tensor + } + affine.yield %9 : tensor + } + affine.yield %8 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..94adb47460d7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu/orig.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c42_i32 = arith.constant 42 : i32 + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 84 { + affine.store %cst, %arg2[%arg3] : memref + } + affine.for %arg3 = 0 to 2 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.muli %0, %c42_i32 : i32 + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + %2 = affine.load %arg1[%arg5 + %arg3 * 9 + %arg4 * 3] : memref + %3 = arith.addi %1, %2 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = affine.load %arg0[%arg5 + %arg3 * 9 + %arg4 * 3] : memref + %6 = memref.load %arg2[%4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg2[%4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..7d27940a6290 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu/raised.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c42_i32 = arith.constant 42 : i32 + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 2 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.muli %0, %c42_i32 : i32 + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + %2 = affine.load %arg1[%arg5 + %arg3 * 9 + %arg4 * 3] : memref + %3 = arith.addi %1, %2 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = affine.load %arg0[%arg5 + %arg3 * 9 + %arg4 * 3] : memref + %6 = memref.load %arg2[%4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg2[%4] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..1272dfbc8b04 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu_debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0 + d1 * 9 + d2 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c42_i32 = arith.constant 42 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %3) -> (tensor) { + %6 = arith.index_cast %arg3 : index to i32 + %7 = arith.muli %6, %c42_i32 : i32 + %8 = affine.for %arg5 = 0 to 3 iter_args(%arg6 = %arg4) -> (tensor) { + %9 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %arg6) -> (tensor) { + %10 = affine.apply #map1(%arg7, %arg3, %arg5) + %extracted = tensor.extract %1[%10] : tensor + %11 = arith.addi %7, %extracted : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = affine.apply #map1(%arg7, %arg3, %arg5) + %extracted_0 = tensor.extract %2[%13] : tensor + %extracted_1 = tensor.extract %arg8[%12] : tensor + %14 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %14 into %arg8[%12] : tensor + affine.yield %inserted : tensor + } + affine.yield %9 : tensor + } + affine.yield %8 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..7d27940a6290 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_backward_cpu_linalg.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c42_i32 = arith.constant 42 : i32 + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 2 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.muli %0, %c42_i32 : i32 + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + %2 = affine.load %arg1[%arg5 + %arg3 * 9 + %arg4 * 3] : memref + %3 = arith.addi %1, %2 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = affine.load %arg0[%arg5 + %arg3 * 9 + %arg4 * 3] : memref + %6 = memref.load %arg2[%4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg2[%4] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu.mlir new file mode 100644 index 000000000000..78a74a95d4b7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu.mlir @@ -0,0 +1,54 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c42 = arith.constant 42 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c7_i32 = arith.constant 7 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg3 = 0 to 2 { + %0 = arith.muli %arg3, %c42 : index + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + %1 = arith.muli %arg5, %c7 : index + %2 = arith.cmpi slt, %1, %c0 : index + %3 = arith.subi %c-1, %1 : index + %4 = arith.select %2, %3, %1 : index + %5 = arith.divsi %4, %c3 : index + %6 = arith.subi %c-1, %5 : index + %7 = arith.select %2, %6, %5 : index + %8 = arith.addi %7, %c3 : index + %9:2 = affine.for %arg6 = #map(%arg4) to #map1(%arg4) iter_args(%arg7 = %c0_i32, %arg8 = %cst) -> (i32, f32) { + %10 = arith.index_cast %arg6 : index to i32 + %11 = arith.muli %10, %c7_i32 : i32 + %12 = arith.muli %arg6, %c7 : index + %13:2 = scf.for %arg9 = %7 to %8 step %c1 iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (i32, f32) { + %14 = arith.index_cast %arg9 : index to i32 + %15 = arith.addi %arg9, %0 : index + %16 = arith.addi %15, %12 : index + %17 = memref.load %arg0[%16] : memref + %18 = arith.cmpf ogt, %17, %arg11 : f32 + %19 = arith.select %18, %17, %arg11 : f32 + %20 = scf.if %18 -> (i32) { + %21 = arith.addi %11, %14 : i32 + scf.yield %21 : i32 + } else { + scf.yield %arg10 : i32 + } + scf.yield %20, %19 : i32, f32 + } + affine.yield %13#0, %13#1 : i32, f32 + } + affine.store %9#1, %arg1[%arg5 + %arg3 * 9 + %arg4 * 3] : memref + affine.store %9#0, %arg2[%arg5 + %arg3 * 9 + %arg4 * 3] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu/debuf.mlir new file mode 100644 index 000000000000..1ea073f921d0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu/debuf.mlir @@ -0,0 +1,76 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +#map2 = affine_map<(d0, d1, d2) -> (d0 + d1 * 9 + d2 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c42 = arith.constant 42 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %6 = arith.muli %arg3, %c42 : index + %7:2 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %alloca = memref.alloca(%c3) : memref + %8 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %9 = bufferization.to_tensor %alloca_0 : memref + %10:4 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %8, %arg11 = %9, %arg12 = %arg7, %arg13 = %arg8) -> (tensor, tensor, tensor, tensor) { + %11 = arith.muli %arg9, %c7 : index + %12 = arith.cmpi slt, %11, %c0 : index + %13 = arith.subi %c-1, %11 : index + %14 = arith.select %12, %13, %11 : index + %15 = arith.divsi %14, %c3 : index + %16 = arith.subi %c-1, %15 : index + %17 = arith.select %12, %16, %15 : index + %18 = arith.addi %17, %c3 : index + %inserted = tensor.insert %c0_i32 into %arg10[%arg9] : tensor + %inserted_1 = tensor.insert %cst into %arg11[%arg9] : tensor + %19:2 = affine.for %arg14 = #map(%arg6) to #map1(%arg6) iter_args(%arg15 = %inserted, %arg16 = %inserted_1) -> (tensor, tensor) { + %extracted_5 = tensor.extract %arg15[%arg9] : tensor + %extracted_6 = tensor.extract %arg16[%arg9] : tensor + %22 = arith.index_cast %arg14 : index to i32 + %23 = arith.muli %22, %c7_i32 : i32 + %24 = arith.muli %arg14, %c7 : index + %25:2 = scf.for %arg17 = %17 to %18 step %c1 iter_args(%arg18 = %extracted_5, %arg19 = %extracted_6) -> (i32, f32) { + %26 = arith.index_cast %arg17 : index to i32 + %27 = arith.addi %arg17, %6 : index + %28 = arith.addi %27, %24 : index + %extracted_9 = tensor.extract %2[%28] : tensor + %29 = arith.cmpf ogt, %extracted_9, %arg19 : f32 + %30 = arith.select %29, %extracted_9, %arg19 : f32 + %31 = arith.addi %23, %26 : i32 + %32 = arith.select %29, %31, %arg18 : i32 + scf.yield %32, %30 : i32, f32 + } + %inserted_7 = tensor.insert %25#0 into %arg15[%arg9] : tensor + %inserted_8 = tensor.insert %25#1 into %arg16[%arg9] : tensor + affine.yield %inserted_7, %inserted_8 : tensor, tensor + } + %extracted = tensor.extract %19#0[%arg9] : tensor + %extracted_2 = tensor.extract %19#1[%arg9] : tensor + %20 = affine.apply #map2(%arg9, %arg3, %arg6) + %inserted_3 = tensor.insert %extracted_2 into %arg12[%20] : tensor + %21 = affine.apply #map2(%arg9, %arg3, %arg6) + %inserted_4 = tensor.insert %extracted into %arg13[%21] : tensor + affine.yield %19#0, %19#1, %inserted_3, %inserted_4 : tensor, tensor, tensor, tensor + } + affine.yield %10#2, %10#3 : tensor, tensor + } + affine.yield %7#0, %7#1 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu/matched.mlir new file mode 100644 index 000000000000..1ea073f921d0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu/matched.mlir @@ -0,0 +1,76 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +#map2 = affine_map<(d0, d1, d2) -> (d0 + d1 * 9 + d2 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c42 = arith.constant 42 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %6 = arith.muli %arg3, %c42 : index + %7:2 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %alloca = memref.alloca(%c3) : memref + %8 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %9 = bufferization.to_tensor %alloca_0 : memref + %10:4 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %8, %arg11 = %9, %arg12 = %arg7, %arg13 = %arg8) -> (tensor, tensor, tensor, tensor) { + %11 = arith.muli %arg9, %c7 : index + %12 = arith.cmpi slt, %11, %c0 : index + %13 = arith.subi %c-1, %11 : index + %14 = arith.select %12, %13, %11 : index + %15 = arith.divsi %14, %c3 : index + %16 = arith.subi %c-1, %15 : index + %17 = arith.select %12, %16, %15 : index + %18 = arith.addi %17, %c3 : index + %inserted = tensor.insert %c0_i32 into %arg10[%arg9] : tensor + %inserted_1 = tensor.insert %cst into %arg11[%arg9] : tensor + %19:2 = affine.for %arg14 = #map(%arg6) to #map1(%arg6) iter_args(%arg15 = %inserted, %arg16 = %inserted_1) -> (tensor, tensor) { + %extracted_5 = tensor.extract %arg15[%arg9] : tensor + %extracted_6 = tensor.extract %arg16[%arg9] : tensor + %22 = arith.index_cast %arg14 : index to i32 + %23 = arith.muli %22, %c7_i32 : i32 + %24 = arith.muli %arg14, %c7 : index + %25:2 = scf.for %arg17 = %17 to %18 step %c1 iter_args(%arg18 = %extracted_5, %arg19 = %extracted_6) -> (i32, f32) { + %26 = arith.index_cast %arg17 : index to i32 + %27 = arith.addi %arg17, %6 : index + %28 = arith.addi %27, %24 : index + %extracted_9 = tensor.extract %2[%28] : tensor + %29 = arith.cmpf ogt, %extracted_9, %arg19 : f32 + %30 = arith.select %29, %extracted_9, %arg19 : f32 + %31 = arith.addi %23, %26 : i32 + %32 = arith.select %29, %31, %arg18 : i32 + scf.yield %32, %30 : i32, f32 + } + %inserted_7 = tensor.insert %25#0 into %arg15[%arg9] : tensor + %inserted_8 = tensor.insert %25#1 into %arg16[%arg9] : tensor + affine.yield %inserted_7, %inserted_8 : tensor, tensor + } + %extracted = tensor.extract %19#0[%arg9] : tensor + %extracted_2 = tensor.extract %19#1[%arg9] : tensor + %20 = affine.apply #map2(%arg9, %arg3, %arg6) + %inserted_3 = tensor.insert %extracted_2 into %arg12[%20] : tensor + %21 = affine.apply #map2(%arg9, %arg3, %arg6) + %inserted_4 = tensor.insert %extracted into %arg13[%21] : tensor + affine.yield %19#0, %19#1, %inserted_3, %inserted_4 : tensor, tensor, tensor, tensor + } + affine.yield %10#2, %10#3 : tensor, tensor + } + affine.yield %7#0, %7#1 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu/orig.mlir new file mode 100644 index 000000000000..78a74a95d4b7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu/orig.mlir @@ -0,0 +1,54 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c42 = arith.constant 42 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c7_i32 = arith.constant 7 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg3 = 0 to 2 { + %0 = arith.muli %arg3, %c42 : index + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + %1 = arith.muli %arg5, %c7 : index + %2 = arith.cmpi slt, %1, %c0 : index + %3 = arith.subi %c-1, %1 : index + %4 = arith.select %2, %3, %1 : index + %5 = arith.divsi %4, %c3 : index + %6 = arith.subi %c-1, %5 : index + %7 = arith.select %2, %6, %5 : index + %8 = arith.addi %7, %c3 : index + %9:2 = affine.for %arg6 = #map(%arg4) to #map1(%arg4) iter_args(%arg7 = %c0_i32, %arg8 = %cst) -> (i32, f32) { + %10 = arith.index_cast %arg6 : index to i32 + %11 = arith.muli %10, %c7_i32 : i32 + %12 = arith.muli %arg6, %c7 : index + %13:2 = scf.for %arg9 = %7 to %8 step %c1 iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (i32, f32) { + %14 = arith.index_cast %arg9 : index to i32 + %15 = arith.addi %arg9, %0 : index + %16 = arith.addi %15, %12 : index + %17 = memref.load %arg0[%16] : memref + %18 = arith.cmpf ogt, %17, %arg11 : f32 + %19 = arith.select %18, %17, %arg11 : f32 + %20 = scf.if %18 -> (i32) { + %21 = arith.addi %11, %14 : i32 + scf.yield %21 : i32 + } else { + scf.yield %arg10 : i32 + } + scf.yield %20, %19 : i32, f32 + } + affine.yield %13#0, %13#1 : i32, f32 + } + affine.store %9#1, %arg1[%arg5 + %arg3 * 9 + %arg4 * 3] : memref + affine.store %9#0, %arg2[%arg5 + %arg3 * 9 + %arg4 * 3] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu/raised.mlir new file mode 100644 index 000000000000..34e5b3c15030 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu/raised.mlir @@ -0,0 +1,60 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c42 = arith.constant 42 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c7_i32 = arith.constant 7 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg3 = 0 to 2 { + %0 = arith.muli %arg3, %c42 : index + affine.for %arg4 = 0 to 3 { + %alloca = memref.alloca(%c3) : memref + %alloca_0 = memref.alloca(%c3) : memref + affine.for %arg5 = 0 to 3 { + %1 = arith.muli %arg5, %c7 : index + %2 = arith.cmpi slt, %1, %c0 : index + %3 = arith.subi %c-1, %1 : index + %4 = arith.select %2, %3, %1 : index + %5 = arith.divsi %4, %c3 : index + %6 = arith.subi %c-1, %5 : index + %7 = arith.select %2, %6, %5 : index + %8 = arith.addi %7, %c3 : index + affine.store %c0_i32, %alloca[%arg5] : memref + affine.store %cst, %alloca_0[%arg5] : memref + affine.for %arg6 = #map(%arg4) to #map1(%arg4) { + %11 = affine.load %alloca[%arg5] : memref + %12 = affine.load %alloca_0[%arg5] : memref + %13 = arith.index_cast %arg6 : index to i32 + %14 = arith.muli %13, %c7_i32 : i32 + %15 = arith.muli %arg6, %c7 : index + %16:2 = scf.for %arg7 = %7 to %8 step %c1 iter_args(%arg8 = %11, %arg9 = %12) -> (i32, f32) { + %17 = arith.index_cast %arg7 : index to i32 + %18 = arith.addi %arg7, %0 : index + %19 = arith.addi %18, %15 : index + %20 = memref.load %arg0[%19] : memref + %21 = arith.cmpf ogt, %20, %arg9 : f32 + %22 = arith.select %21, %20, %arg9 : f32 + %23 = arith.addi %14, %17 : i32 + %24 = arith.select %21, %23, %arg8 : i32 + scf.yield %24, %22 : i32, f32 + } + affine.store %16#0, %alloca[%arg5] : memref + affine.store %16#1, %alloca_0[%arg5] : memref + } + %9 = affine.load %alloca[%arg5] : memref + %10 = affine.load %alloca_0[%arg5] : memref + affine.store %10, %arg1[%arg5 + %arg3 * 9 + %arg4 * 3] : memref + affine.store %9, %arg2[%arg5 + %arg3 * 9 + %arg4 * 3] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu_debuf.mlir new file mode 100644 index 000000000000..1ea073f921d0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu_debuf.mlir @@ -0,0 +1,76 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +#map2 = affine_map<(d0, d1, d2) -> (d0 + d1 * 9 + d2 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c42 = arith.constant 42 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %6 = arith.muli %arg3, %c42 : index + %7:2 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %alloca = memref.alloca(%c3) : memref + %8 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %9 = bufferization.to_tensor %alloca_0 : memref + %10:4 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %8, %arg11 = %9, %arg12 = %arg7, %arg13 = %arg8) -> (tensor, tensor, tensor, tensor) { + %11 = arith.muli %arg9, %c7 : index + %12 = arith.cmpi slt, %11, %c0 : index + %13 = arith.subi %c-1, %11 : index + %14 = arith.select %12, %13, %11 : index + %15 = arith.divsi %14, %c3 : index + %16 = arith.subi %c-1, %15 : index + %17 = arith.select %12, %16, %15 : index + %18 = arith.addi %17, %c3 : index + %inserted = tensor.insert %c0_i32 into %arg10[%arg9] : tensor + %inserted_1 = tensor.insert %cst into %arg11[%arg9] : tensor + %19:2 = affine.for %arg14 = #map(%arg6) to #map1(%arg6) iter_args(%arg15 = %inserted, %arg16 = %inserted_1) -> (tensor, tensor) { + %extracted_5 = tensor.extract %arg15[%arg9] : tensor + %extracted_6 = tensor.extract %arg16[%arg9] : tensor + %22 = arith.index_cast %arg14 : index to i32 + %23 = arith.muli %22, %c7_i32 : i32 + %24 = arith.muli %arg14, %c7 : index + %25:2 = scf.for %arg17 = %17 to %18 step %c1 iter_args(%arg18 = %extracted_5, %arg19 = %extracted_6) -> (i32, f32) { + %26 = arith.index_cast %arg17 : index to i32 + %27 = arith.addi %arg17, %6 : index + %28 = arith.addi %27, %24 : index + %extracted_9 = tensor.extract %2[%28] : tensor + %29 = arith.cmpf ogt, %extracted_9, %arg19 : f32 + %30 = arith.select %29, %extracted_9, %arg19 : f32 + %31 = arith.addi %23, %26 : i32 + %32 = arith.select %29, %31, %arg18 : i32 + scf.yield %32, %30 : i32, f32 + } + %inserted_7 = tensor.insert %25#0 into %arg15[%arg9] : tensor + %inserted_8 = tensor.insert %25#1 into %arg16[%arg9] : tensor + affine.yield %inserted_7, %inserted_8 : tensor, tensor + } + %extracted = tensor.extract %19#0[%arg9] : tensor + %extracted_2 = tensor.extract %19#1[%arg9] : tensor + %20 = affine.apply #map2(%arg9, %arg3, %arg6) + %inserted_3 = tensor.insert %extracted_2 into %arg12[%20] : tensor + %21 = affine.apply #map2(%arg9, %arg3, %arg6) + %inserted_4 = tensor.insert %extracted into %arg13[%21] : tensor + affine.yield %19#0, %19#1, %inserted_3, %inserted_4 : tensor, tensor, tensor, tensor + } + affine.yield %10#2, %10#3 : tensor, tensor + } + affine.yield %7#0, %7#1 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu_linalg.mlir new file mode 100644 index 000000000000..34e5b3c15030 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool2d_cpu_linalg.mlir @@ -0,0 +1,60 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c42 = arith.constant 42 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c7_i32 = arith.constant 7 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg3 = 0 to 2 { + %0 = arith.muli %arg3, %c42 : index + affine.for %arg4 = 0 to 3 { + %alloca = memref.alloca(%c3) : memref + %alloca_0 = memref.alloca(%c3) : memref + affine.for %arg5 = 0 to 3 { + %1 = arith.muli %arg5, %c7 : index + %2 = arith.cmpi slt, %1, %c0 : index + %3 = arith.subi %c-1, %1 : index + %4 = arith.select %2, %3, %1 : index + %5 = arith.divsi %4, %c3 : index + %6 = arith.subi %c-1, %5 : index + %7 = arith.select %2, %6, %5 : index + %8 = arith.addi %7, %c3 : index + affine.store %c0_i32, %alloca[%arg5] : memref + affine.store %cst, %alloca_0[%arg5] : memref + affine.for %arg6 = #map(%arg4) to #map1(%arg4) { + %11 = affine.load %alloca[%arg5] : memref + %12 = affine.load %alloca_0[%arg5] : memref + %13 = arith.index_cast %arg6 : index to i32 + %14 = arith.muli %13, %c7_i32 : i32 + %15 = arith.muli %arg6, %c7 : index + %16:2 = scf.for %arg7 = %7 to %8 step %c1 iter_args(%arg8 = %11, %arg9 = %12) -> (i32, f32) { + %17 = arith.index_cast %arg7 : index to i32 + %18 = arith.addi %arg7, %0 : index + %19 = arith.addi %18, %15 : index + %20 = memref.load %arg0[%19] : memref + %21 = arith.cmpf ogt, %20, %arg9 : f32 + %22 = arith.select %21, %20, %arg9 : f32 + %23 = arith.addi %14, %17 : i32 + %24 = arith.select %21, %23, %arg8 : i32 + scf.yield %24, %22 : i32, f32 + } + affine.store %16#0, %alloca[%arg5] : memref + affine.store %16#1, %alloca_0[%arg5] : memref + } + %9 = affine.load %alloca[%arg5] : memref + %10 = affine.load %alloca_0[%arg5] : memref + affine.store %10, %arg1[%arg5 + %arg3 * 9 + %arg4 * 3] : memref + affine.store %9, %arg2[%arg5 + %arg3 * 9 + %arg4 * 3] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu.mlir new file mode 100644 index 000000000000..5d1793d07ae7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c336_i32 = arith.constant 336 : i32 + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 672 { + affine.store %cst, %arg2[%arg3] : memref + } + affine.for %arg3 = 0 to 2 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.muli %0, %c336_i32 : i32 + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 3 { + %2 = affine.load %arg1[%arg3 * 27 + %arg6 + %arg4 * 9 + %arg5 * 3] : memref + %3 = arith.addi %1, %2 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = affine.load %arg0[%arg3 * 27 + %arg6 + %arg4 * 9 + %arg5 * 3] : memref + %6 = memref.load %arg2[%4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg2[%4] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..ad90b1f54a51 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu/debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0 * 27 + d1 + d2 * 9 + d3 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c336_i32 = arith.constant 336 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %3) -> (tensor) { + %6 = arith.index_cast %arg3 : index to i32 + %7 = arith.muli %6, %c336_i32 : i32 + %8 = affine.for %arg5 = 0 to 3 iter_args(%arg6 = %arg4) -> (tensor) { + %9 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %arg6) -> (tensor) { + %10 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %arg8) -> (tensor) { + %11 = affine.apply #map1(%arg3, %arg9, %arg5, %arg7) + %extracted = tensor.extract %1[%11] : tensor + %12 = arith.addi %7, %extracted : i32 + %13 = arith.index_cast %12 : i32 to index + %14 = affine.apply #map1(%arg3, %arg9, %arg5, %arg7) + %extracted_0 = tensor.extract %2[%14] : tensor + %extracted_1 = tensor.extract %arg10[%13] : tensor + %15 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %15 into %arg10[%13] : tensor + affine.yield %inserted : tensor + } + affine.yield %10 : tensor + } + affine.yield %9 : tensor + } + affine.yield %8 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..1dbae0f7eedd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu/matched.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0 * 27 + d1 + d2 * 9 + d3 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c336_i32 = arith.constant 336 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %4 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %3) -> (tensor) { + %6 = arith.index_cast %arg3 : index to i32 + %7 = arith.muli %6, %c336_i32 : i32 + %8 = affine.for %arg5 = 0 to 3 iter_args(%arg6 = %arg4) -> (tensor) { + %9 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %arg6) -> (tensor) { + %10 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %arg8) -> (tensor) { + %11 = affine.apply #map1(%arg3, %arg9, %arg5, %arg7) + %extracted = tensor.extract %1[%11] : tensor + %12 = arith.addi %7, %extracted : i32 + %13 = arith.index_cast %12 : i32 to index + %14 = affine.apply #map1(%arg3, %arg9, %arg5, %arg7) + %extracted_0 = tensor.extract %2[%14] : tensor + %extracted_1 = tensor.extract %arg10[%13] : tensor + %15 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %15 into %arg10[%13] : tensor + affine.yield %inserted : tensor + } + affine.yield %10 : tensor + } + affine.yield %9 : tensor + } + affine.yield %8 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..5d1793d07ae7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu/orig.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c336_i32 = arith.constant 336 : i32 + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 672 { + affine.store %cst, %arg2[%arg3] : memref + } + affine.for %arg3 = 0 to 2 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.muli %0, %c336_i32 : i32 + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 3 { + %2 = affine.load %arg1[%arg3 * 27 + %arg6 + %arg4 * 9 + %arg5 * 3] : memref + %3 = arith.addi %1, %2 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = affine.load %arg0[%arg3 * 27 + %arg6 + %arg4 * 9 + %arg5 * 3] : memref + %6 = memref.load %arg2[%4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg2[%4] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..0bd8332e09a4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu/raised.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c336_i32 = arith.constant 336 : i32 + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 2 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.muli %0, %c336_i32 : i32 + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 3 { + %2 = affine.load %arg1[%arg3 * 27 + %arg6 + %arg4 * 9 + %arg5 * 3] : memref + %3 = arith.addi %1, %2 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = affine.load %arg0[%arg3 * 27 + %arg6 + %arg4 * 9 + %arg5 * 3] : memref + %6 = memref.load %arg2[%4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg2[%4] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..ad90b1f54a51 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu_debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0 * 27 + d1 + d2 * 9 + d3 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c336_i32 = arith.constant 336 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %3) -> (tensor) { + %6 = arith.index_cast %arg3 : index to i32 + %7 = arith.muli %6, %c336_i32 : i32 + %8 = affine.for %arg5 = 0 to 3 iter_args(%arg6 = %arg4) -> (tensor) { + %9 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %arg6) -> (tensor) { + %10 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %arg8) -> (tensor) { + %11 = affine.apply #map1(%arg3, %arg9, %arg5, %arg7) + %extracted = tensor.extract %1[%11] : tensor + %12 = arith.addi %7, %extracted : i32 + %13 = arith.index_cast %12 : i32 to index + %14 = affine.apply #map1(%arg3, %arg9, %arg5, %arg7) + %extracted_0 = tensor.extract %2[%14] : tensor + %extracted_1 = tensor.extract %arg10[%13] : tensor + %15 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %15 into %arg10[%13] : tensor + affine.yield %inserted : tensor + } + affine.yield %10 : tensor + } + affine.yield %9 : tensor + } + affine.yield %8 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..0bd8332e09a4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_backward_cpu_linalg.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c336_i32 = arith.constant 336 : i32 + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 2 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.muli %0, %c336_i32 : i32 + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 3 { + %2 = affine.load %arg1[%arg3 * 27 + %arg6 + %arg4 * 9 + %arg5 * 3] : memref + %3 = arith.addi %1, %2 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = affine.load %arg0[%arg3 * 27 + %arg6 + %arg4 * 9 + %arg5 * 3] : memref + %6 = memref.load %arg2[%4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg2[%4] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu.mlir new file mode 100644 index 000000000000..597a57540dd0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu.mlir @@ -0,0 +1,83 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-11 = arith.constant -11 : index + %c56 = arith.constant 56 : index + %c336 = arith.constant 336 : index + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c8_i32 = arith.constant 8 : i32 + %c7_i32 = arith.constant 7 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg3 = 0 to 2 { + %0 = arith.muli %arg3, %c336 : index + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + %1 = arith.muli %arg5, %c7 : index + %2 = arith.cmpi slt, %1, %c0 : index + %3 = arith.subi %c-1, %1 : index + %4 = arith.select %2, %3, %1 : index + %5 = arith.divsi %4, %c3 : index + %6 = arith.subi %c-1, %5 : index + %7 = arith.select %2, %6, %5 : index + %8 = arith.addi %7, %c3 : index + affine.for %arg6 = 0 to 3 { + %9 = arith.muli %arg6, %c8 : index + %10 = arith.cmpi slt, %9, %c0 : index + %11 = arith.subi %c-1, %9 : index + %12 = arith.select %10, %11, %9 : index + %13 = arith.divsi %12, %c3 : index + %14 = arith.subi %c-1, %13 : index + %15 = arith.select %10, %14, %13 : index + %16 = arith.addi %9, %c10 : index + %17 = arith.cmpi slt, %16, %c0 : index + %18 = arith.subi %c-11, %9 : index + %19 = arith.select %17, %18, %16 : index + %20 = arith.divsi %19, %c3 : index + %21 = arith.subi %c-1, %20 : index + %22 = arith.select %17, %21, %20 : index + %23:2 = affine.for %arg7 = #map(%arg4) to #map1(%arg4) iter_args(%arg8 = %c0_i32, %arg9 = %cst) -> (i32, f32) { + %24 = arith.index_cast %arg7 : index to i32 + %25 = arith.muli %24, %c7_i32 : i32 + %26 = arith.muli %arg7, %c56 : index + %27:2 = scf.for %arg10 = %7 to %8 step %c1 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (i32, f32) { + %28 = arith.index_cast %arg10 : index to i32 + %29 = arith.addi %25, %28 : i32 + %30 = arith.muli %29, %c8_i32 : i32 + %31 = arith.muli %arg10, %c8 : index + %32:2 = scf.for %arg13 = %15 to %22 step %c1 iter_args(%arg14 = %arg11, %arg15 = %arg12) -> (i32, f32) { + %33 = arith.index_cast %arg13 : index to i32 + %34 = arith.addi %arg13, %31 : index + %35 = arith.addi %34, %0 : index + %36 = arith.addi %35, %26 : index + %37 = memref.load %arg0[%36] : memref + %38 = arith.cmpf ogt, %37, %arg15 : f32 + %39 = arith.select %38, %37, %arg15 : f32 + %40 = scf.if %38 -> (i32) { + %41 = arith.addi %30, %33 : i32 + scf.yield %41 : i32 + } else { + scf.yield %arg14 : i32 + } + scf.yield %40, %39 : i32, f32 + } + scf.yield %32#0, %32#1 : i32, f32 + } + affine.yield %27#0, %27#1 : i32, f32 + } + affine.store %23#1, %arg1[%arg3 * 27 + %arg6 + %arg4 * 9 + %arg5 * 3] : memref + affine.store %23#0, %arg2[%arg3 * 27 + %arg6 + %arg4 * 9 + %arg5 * 3] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu/debuf.mlir new file mode 100644 index 000000000000..e618da3a5ab8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu/debuf.mlir @@ -0,0 +1,106 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0 * 27 + d1 + d2 * 9 + d3 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c7_i32 = arith.constant 7 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c8 = arith.constant 8 : index + %c10 = arith.constant 10 : index + %c336 = arith.constant 336 : index + %c56 = arith.constant 56 : index + %c-11 = arith.constant -11 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %6 = arith.muli %arg3, %c336 : index + %7:2 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %8:2 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (tensor, tensor) { + %9 = arith.muli %arg9, %c7 : index + %10 = arith.cmpi slt, %9, %c0 : index + %11 = arith.subi %c-1, %9 : index + %12 = arith.select %10, %11, %9 : index + %13 = arith.divsi %12, %c3 : index + %14 = arith.subi %c-1, %13 : index + %15 = arith.select %10, %14, %13 : index + %16 = arith.addi %15, %c3 : index + %alloca = memref.alloca(%c3) : memref + %17 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %18 = bufferization.to_tensor %alloca_0 : memref + %19:4 = affine.for %arg12 = 0 to 3 iter_args(%arg13 = %17, %arg14 = %18, %arg15 = %arg10, %arg16 = %arg11) -> (tensor, tensor, tensor, tensor) { + %20 = arith.muli %arg12, %c8 : index + %21 = arith.cmpi slt, %20, %c0 : index + %22 = arith.subi %c-1, %20 : index + %23 = arith.select %21, %22, %20 : index + %24 = arith.divsi %23, %c3 : index + %25 = arith.subi %c-1, %24 : index + %26 = arith.select %21, %25, %24 : index + %27 = arith.addi %20, %c10 : index + %28 = arith.cmpi slt, %27, %c0 : index + %29 = arith.subi %c-11, %20 : index + %30 = arith.select %28, %29, %27 : index + %31 = arith.divsi %30, %c3 : index + %32 = arith.subi %c-1, %31 : index + %33 = arith.select %28, %32, %31 : index + %inserted = tensor.insert %c0_i32 into %arg13[%arg12] : tensor + %inserted_1 = tensor.insert %cst into %arg14[%arg12] : tensor + %34:2 = affine.for %arg17 = #map(%arg6) to #map1(%arg6) iter_args(%arg18 = %inserted, %arg19 = %inserted_1) -> (tensor, tensor) { + %extracted_5 = tensor.extract %arg18[%arg12] : tensor + %extracted_6 = tensor.extract %arg19[%arg12] : tensor + %37 = arith.index_cast %arg17 : index to i32 + %38 = arith.muli %37, %c7_i32 : i32 + %39 = arith.muli %arg17, %c56 : index + %40:2 = scf.for %arg20 = %15 to %16 step %c1 iter_args(%arg21 = %extracted_5, %arg22 = %extracted_6) -> (i32, f32) { + %41 = arith.index_cast %arg20 : index to i32 + %42 = arith.addi %38, %41 : i32 + %43 = arith.muli %42, %c8_i32 : i32 + %44 = arith.muli %arg20, %c8 : index + %45:2 = scf.for %arg23 = %26 to %33 step %c1 iter_args(%arg24 = %arg21, %arg25 = %arg22) -> (i32, f32) { + %46 = arith.index_cast %arg23 : index to i32 + %47 = arith.addi %arg23, %44 : index + %48 = arith.addi %47, %6 : index + %49 = arith.addi %48, %39 : index + %extracted_9 = tensor.extract %2[%49] : tensor + %50 = arith.cmpf ogt, %extracted_9, %arg25 : f32 + %51 = arith.select %50, %extracted_9, %arg25 : f32 + %52 = arith.addi %43, %46 : i32 + %53 = arith.select %50, %52, %arg24 : i32 + scf.yield %53, %51 : i32, f32 + } + scf.yield %45#0, %45#1 : i32, f32 + } + %inserted_7 = tensor.insert %40#0 into %arg18[%arg12] : tensor + %inserted_8 = tensor.insert %40#1 into %arg19[%arg12] : tensor + affine.yield %inserted_7, %inserted_8 : tensor, tensor + } + %extracted = tensor.extract %34#0[%arg12] : tensor + %extracted_2 = tensor.extract %34#1[%arg12] : tensor + %35 = affine.apply #map2(%arg3, %arg12, %arg6, %arg9) + %inserted_3 = tensor.insert %extracted_2 into %arg15[%35] : tensor + %36 = affine.apply #map2(%arg3, %arg12, %arg6, %arg9) + %inserted_4 = tensor.insert %extracted into %arg16[%36] : tensor + affine.yield %34#0, %34#1, %inserted_3, %inserted_4 : tensor, tensor, tensor, tensor + } + affine.yield %19#2, %19#3 : tensor, tensor + } + affine.yield %8#0, %8#1 : tensor, tensor + } + affine.yield %7#0, %7#1 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu/matched.mlir new file mode 100644 index 000000000000..e618da3a5ab8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu/matched.mlir @@ -0,0 +1,106 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0 * 27 + d1 + d2 * 9 + d3 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c7_i32 = arith.constant 7 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c8 = arith.constant 8 : index + %c10 = arith.constant 10 : index + %c336 = arith.constant 336 : index + %c56 = arith.constant 56 : index + %c-11 = arith.constant -11 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %6 = arith.muli %arg3, %c336 : index + %7:2 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %8:2 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (tensor, tensor) { + %9 = arith.muli %arg9, %c7 : index + %10 = arith.cmpi slt, %9, %c0 : index + %11 = arith.subi %c-1, %9 : index + %12 = arith.select %10, %11, %9 : index + %13 = arith.divsi %12, %c3 : index + %14 = arith.subi %c-1, %13 : index + %15 = arith.select %10, %14, %13 : index + %16 = arith.addi %15, %c3 : index + %alloca = memref.alloca(%c3) : memref + %17 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %18 = bufferization.to_tensor %alloca_0 : memref + %19:4 = affine.for %arg12 = 0 to 3 iter_args(%arg13 = %17, %arg14 = %18, %arg15 = %arg10, %arg16 = %arg11) -> (tensor, tensor, tensor, tensor) { + %20 = arith.muli %arg12, %c8 : index + %21 = arith.cmpi slt, %20, %c0 : index + %22 = arith.subi %c-1, %20 : index + %23 = arith.select %21, %22, %20 : index + %24 = arith.divsi %23, %c3 : index + %25 = arith.subi %c-1, %24 : index + %26 = arith.select %21, %25, %24 : index + %27 = arith.addi %20, %c10 : index + %28 = arith.cmpi slt, %27, %c0 : index + %29 = arith.subi %c-11, %20 : index + %30 = arith.select %28, %29, %27 : index + %31 = arith.divsi %30, %c3 : index + %32 = arith.subi %c-1, %31 : index + %33 = arith.select %28, %32, %31 : index + %inserted = tensor.insert %c0_i32 into %arg13[%arg12] : tensor + %inserted_1 = tensor.insert %cst into %arg14[%arg12] : tensor + %34:2 = affine.for %arg17 = #map(%arg6) to #map1(%arg6) iter_args(%arg18 = %inserted, %arg19 = %inserted_1) -> (tensor, tensor) { + %extracted_5 = tensor.extract %arg18[%arg12] : tensor + %extracted_6 = tensor.extract %arg19[%arg12] : tensor + %37 = arith.index_cast %arg17 : index to i32 + %38 = arith.muli %37, %c7_i32 : i32 + %39 = arith.muli %arg17, %c56 : index + %40:2 = scf.for %arg20 = %15 to %16 step %c1 iter_args(%arg21 = %extracted_5, %arg22 = %extracted_6) -> (i32, f32) { + %41 = arith.index_cast %arg20 : index to i32 + %42 = arith.addi %38, %41 : i32 + %43 = arith.muli %42, %c8_i32 : i32 + %44 = arith.muli %arg20, %c8 : index + %45:2 = scf.for %arg23 = %26 to %33 step %c1 iter_args(%arg24 = %arg21, %arg25 = %arg22) -> (i32, f32) { + %46 = arith.index_cast %arg23 : index to i32 + %47 = arith.addi %arg23, %44 : index + %48 = arith.addi %47, %6 : index + %49 = arith.addi %48, %39 : index + %extracted_9 = tensor.extract %2[%49] : tensor + %50 = arith.cmpf ogt, %extracted_9, %arg25 : f32 + %51 = arith.select %50, %extracted_9, %arg25 : f32 + %52 = arith.addi %43, %46 : i32 + %53 = arith.select %50, %52, %arg24 : i32 + scf.yield %53, %51 : i32, f32 + } + scf.yield %45#0, %45#1 : i32, f32 + } + %inserted_7 = tensor.insert %40#0 into %arg18[%arg12] : tensor + %inserted_8 = tensor.insert %40#1 into %arg19[%arg12] : tensor + affine.yield %inserted_7, %inserted_8 : tensor, tensor + } + %extracted = tensor.extract %34#0[%arg12] : tensor + %extracted_2 = tensor.extract %34#1[%arg12] : tensor + %35 = affine.apply #map2(%arg3, %arg12, %arg6, %arg9) + %inserted_3 = tensor.insert %extracted_2 into %arg15[%35] : tensor + %36 = affine.apply #map2(%arg3, %arg12, %arg6, %arg9) + %inserted_4 = tensor.insert %extracted into %arg16[%36] : tensor + affine.yield %34#0, %34#1, %inserted_3, %inserted_4 : tensor, tensor, tensor, tensor + } + affine.yield %19#2, %19#3 : tensor, tensor + } + affine.yield %8#0, %8#1 : tensor, tensor + } + affine.yield %7#0, %7#1 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu/orig.mlir new file mode 100644 index 000000000000..597a57540dd0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu/orig.mlir @@ -0,0 +1,83 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-11 = arith.constant -11 : index + %c56 = arith.constant 56 : index + %c336 = arith.constant 336 : index + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c8_i32 = arith.constant 8 : i32 + %c7_i32 = arith.constant 7 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg3 = 0 to 2 { + %0 = arith.muli %arg3, %c336 : index + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + %1 = arith.muli %arg5, %c7 : index + %2 = arith.cmpi slt, %1, %c0 : index + %3 = arith.subi %c-1, %1 : index + %4 = arith.select %2, %3, %1 : index + %5 = arith.divsi %4, %c3 : index + %6 = arith.subi %c-1, %5 : index + %7 = arith.select %2, %6, %5 : index + %8 = arith.addi %7, %c3 : index + affine.for %arg6 = 0 to 3 { + %9 = arith.muli %arg6, %c8 : index + %10 = arith.cmpi slt, %9, %c0 : index + %11 = arith.subi %c-1, %9 : index + %12 = arith.select %10, %11, %9 : index + %13 = arith.divsi %12, %c3 : index + %14 = arith.subi %c-1, %13 : index + %15 = arith.select %10, %14, %13 : index + %16 = arith.addi %9, %c10 : index + %17 = arith.cmpi slt, %16, %c0 : index + %18 = arith.subi %c-11, %9 : index + %19 = arith.select %17, %18, %16 : index + %20 = arith.divsi %19, %c3 : index + %21 = arith.subi %c-1, %20 : index + %22 = arith.select %17, %21, %20 : index + %23:2 = affine.for %arg7 = #map(%arg4) to #map1(%arg4) iter_args(%arg8 = %c0_i32, %arg9 = %cst) -> (i32, f32) { + %24 = arith.index_cast %arg7 : index to i32 + %25 = arith.muli %24, %c7_i32 : i32 + %26 = arith.muli %arg7, %c56 : index + %27:2 = scf.for %arg10 = %7 to %8 step %c1 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (i32, f32) { + %28 = arith.index_cast %arg10 : index to i32 + %29 = arith.addi %25, %28 : i32 + %30 = arith.muli %29, %c8_i32 : i32 + %31 = arith.muli %arg10, %c8 : index + %32:2 = scf.for %arg13 = %15 to %22 step %c1 iter_args(%arg14 = %arg11, %arg15 = %arg12) -> (i32, f32) { + %33 = arith.index_cast %arg13 : index to i32 + %34 = arith.addi %arg13, %31 : index + %35 = arith.addi %34, %0 : index + %36 = arith.addi %35, %26 : index + %37 = memref.load %arg0[%36] : memref + %38 = arith.cmpf ogt, %37, %arg15 : f32 + %39 = arith.select %38, %37, %arg15 : f32 + %40 = scf.if %38 -> (i32) { + %41 = arith.addi %30, %33 : i32 + scf.yield %41 : i32 + } else { + scf.yield %arg14 : i32 + } + scf.yield %40, %39 : i32, f32 + } + scf.yield %32#0, %32#1 : i32, f32 + } + affine.yield %27#0, %27#1 : i32, f32 + } + affine.store %23#1, %arg1[%arg3 * 27 + %arg6 + %arg4 * 9 + %arg5 * 3] : memref + affine.store %23#0, %arg2[%arg3 * 27 + %arg6 + %arg4 * 9 + %arg5 * 3] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu/raised.mlir new file mode 100644 index 000000000000..4cf1c418cf88 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu/raised.mlir @@ -0,0 +1,89 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-11 = arith.constant -11 : index + %c56 = arith.constant 56 : index + %c336 = arith.constant 336 : index + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c8_i32 = arith.constant 8 : i32 + %c7_i32 = arith.constant 7 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg3 = 0 to 2 { + %0 = arith.muli %arg3, %c336 : index + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + %1 = arith.muli %arg5, %c7 : index + %2 = arith.cmpi slt, %1, %c0 : index + %3 = arith.subi %c-1, %1 : index + %4 = arith.select %2, %3, %1 : index + %5 = arith.divsi %4, %c3 : index + %6 = arith.subi %c-1, %5 : index + %7 = arith.select %2, %6, %5 : index + %8 = arith.addi %7, %c3 : index + %alloca = memref.alloca(%c3) : memref + %alloca_0 = memref.alloca(%c3) : memref + affine.for %arg6 = 0 to 3 { + %9 = arith.muli %arg6, %c8 : index + %10 = arith.cmpi slt, %9, %c0 : index + %11 = arith.subi %c-1, %9 : index + %12 = arith.select %10, %11, %9 : index + %13 = arith.divsi %12, %c3 : index + %14 = arith.subi %c-1, %13 : index + %15 = arith.select %10, %14, %13 : index + %16 = arith.addi %9, %c10 : index + %17 = arith.cmpi slt, %16, %c0 : index + %18 = arith.subi %c-11, %9 : index + %19 = arith.select %17, %18, %16 : index + %20 = arith.divsi %19, %c3 : index + %21 = arith.subi %c-1, %20 : index + %22 = arith.select %17, %21, %20 : index + affine.store %c0_i32, %alloca[%arg6] : memref + affine.store %cst, %alloca_0[%arg6] : memref + affine.for %arg7 = #map(%arg4) to #map1(%arg4) { + %25 = affine.load %alloca[%arg6] : memref + %26 = affine.load %alloca_0[%arg6] : memref + %27 = arith.index_cast %arg7 : index to i32 + %28 = arith.muli %27, %c7_i32 : i32 + %29 = arith.muli %arg7, %c56 : index + %30:2 = scf.for %arg8 = %7 to %8 step %c1 iter_args(%arg9 = %25, %arg10 = %26) -> (i32, f32) { + %31 = arith.index_cast %arg8 : index to i32 + %32 = arith.addi %28, %31 : i32 + %33 = arith.muli %32, %c8_i32 : i32 + %34 = arith.muli %arg8, %c8 : index + %35:2 = scf.for %arg11 = %15 to %22 step %c1 iter_args(%arg12 = %arg9, %arg13 = %arg10) -> (i32, f32) { + %36 = arith.index_cast %arg11 : index to i32 + %37 = arith.addi %arg11, %34 : index + %38 = arith.addi %37, %0 : index + %39 = arith.addi %38, %29 : index + %40 = memref.load %arg0[%39] : memref + %41 = arith.cmpf ogt, %40, %arg13 : f32 + %42 = arith.select %41, %40, %arg13 : f32 + %43 = arith.addi %33, %36 : i32 + %44 = arith.select %41, %43, %arg12 : i32 + scf.yield %44, %42 : i32, f32 + } + scf.yield %35#0, %35#1 : i32, f32 + } + affine.store %30#0, %alloca[%arg6] : memref + affine.store %30#1, %alloca_0[%arg6] : memref + } + %23 = affine.load %alloca[%arg6] : memref + %24 = affine.load %alloca_0[%arg6] : memref + affine.store %24, %arg1[%arg3 * 27 + %arg6 + %arg4 * 9 + %arg5 * 3] : memref + affine.store %23, %arg2[%arg3 * 27 + %arg6 + %arg4 * 9 + %arg5 * 3] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu_debuf.mlir new file mode 100644 index 000000000000..e618da3a5ab8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu_debuf.mlir @@ -0,0 +1,106 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0 * 27 + d1 + d2 * 9 + d3 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c7_i32 = arith.constant 7 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c7 = arith.constant 7 : index + %c-1 = arith.constant -1 : index + %c8 = arith.constant 8 : index + %c10 = arith.constant 10 : index + %c336 = arith.constant 336 : index + %c56 = arith.constant 56 : index + %c-11 = arith.constant -11 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %6 = arith.muli %arg3, %c336 : index + %7:2 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %8:2 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (tensor, tensor) { + %9 = arith.muli %arg9, %c7 : index + %10 = arith.cmpi slt, %9, %c0 : index + %11 = arith.subi %c-1, %9 : index + %12 = arith.select %10, %11, %9 : index + %13 = arith.divsi %12, %c3 : index + %14 = arith.subi %c-1, %13 : index + %15 = arith.select %10, %14, %13 : index + %16 = arith.addi %15, %c3 : index + %alloca = memref.alloca(%c3) : memref + %17 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %18 = bufferization.to_tensor %alloca_0 : memref + %19:4 = affine.for %arg12 = 0 to 3 iter_args(%arg13 = %17, %arg14 = %18, %arg15 = %arg10, %arg16 = %arg11) -> (tensor, tensor, tensor, tensor) { + %20 = arith.muli %arg12, %c8 : index + %21 = arith.cmpi slt, %20, %c0 : index + %22 = arith.subi %c-1, %20 : index + %23 = arith.select %21, %22, %20 : index + %24 = arith.divsi %23, %c3 : index + %25 = arith.subi %c-1, %24 : index + %26 = arith.select %21, %25, %24 : index + %27 = arith.addi %20, %c10 : index + %28 = arith.cmpi slt, %27, %c0 : index + %29 = arith.subi %c-11, %20 : index + %30 = arith.select %28, %29, %27 : index + %31 = arith.divsi %30, %c3 : index + %32 = arith.subi %c-1, %31 : index + %33 = arith.select %28, %32, %31 : index + %inserted = tensor.insert %c0_i32 into %arg13[%arg12] : tensor + %inserted_1 = tensor.insert %cst into %arg14[%arg12] : tensor + %34:2 = affine.for %arg17 = #map(%arg6) to #map1(%arg6) iter_args(%arg18 = %inserted, %arg19 = %inserted_1) -> (tensor, tensor) { + %extracted_5 = tensor.extract %arg18[%arg12] : tensor + %extracted_6 = tensor.extract %arg19[%arg12] : tensor + %37 = arith.index_cast %arg17 : index to i32 + %38 = arith.muli %37, %c7_i32 : i32 + %39 = arith.muli %arg17, %c56 : index + %40:2 = scf.for %arg20 = %15 to %16 step %c1 iter_args(%arg21 = %extracted_5, %arg22 = %extracted_6) -> (i32, f32) { + %41 = arith.index_cast %arg20 : index to i32 + %42 = arith.addi %38, %41 : i32 + %43 = arith.muli %42, %c8_i32 : i32 + %44 = arith.muli %arg20, %c8 : index + %45:2 = scf.for %arg23 = %26 to %33 step %c1 iter_args(%arg24 = %arg21, %arg25 = %arg22) -> (i32, f32) { + %46 = arith.index_cast %arg23 : index to i32 + %47 = arith.addi %arg23, %44 : index + %48 = arith.addi %47, %6 : index + %49 = arith.addi %48, %39 : index + %extracted_9 = tensor.extract %2[%49] : tensor + %50 = arith.cmpf ogt, %extracted_9, %arg25 : f32 + %51 = arith.select %50, %extracted_9, %arg25 : f32 + %52 = arith.addi %43, %46 : i32 + %53 = arith.select %50, %52, %arg24 : i32 + scf.yield %53, %51 : i32, f32 + } + scf.yield %45#0, %45#1 : i32, f32 + } + %inserted_7 = tensor.insert %40#0 into %arg18[%arg12] : tensor + %inserted_8 = tensor.insert %40#1 into %arg19[%arg12] : tensor + affine.yield %inserted_7, %inserted_8 : tensor, tensor + } + %extracted = tensor.extract %34#0[%arg12] : tensor + %extracted_2 = tensor.extract %34#1[%arg12] : tensor + %35 = affine.apply #map2(%arg3, %arg12, %arg6, %arg9) + %inserted_3 = tensor.insert %extracted_2 into %arg15[%35] : tensor + %36 = affine.apply #map2(%arg3, %arg12, %arg6, %arg9) + %inserted_4 = tensor.insert %extracted into %arg16[%36] : tensor + affine.yield %34#0, %34#1, %inserted_3, %inserted_4 : tensor, tensor, tensor, tensor + } + affine.yield %19#2, %19#3 : tensor, tensor + } + affine.yield %8#0, %8#1 : tensor, tensor + } + affine.yield %7#0, %7#1 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu_linalg.mlir new file mode 100644 index 000000000000..4cf1c418cf88 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_cpu_linalg.mlir @@ -0,0 +1,89 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-11 = arith.constant -11 : index + %c56 = arith.constant 56 : index + %c336 = arith.constant 336 : index + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %c7 = arith.constant 7 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c8_i32 = arith.constant 8 : i32 + %c7_i32 = arith.constant 7 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + affine.for %arg3 = 0 to 2 { + %0 = arith.muli %arg3, %c336 : index + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + %1 = arith.muli %arg5, %c7 : index + %2 = arith.cmpi slt, %1, %c0 : index + %3 = arith.subi %c-1, %1 : index + %4 = arith.select %2, %3, %1 : index + %5 = arith.divsi %4, %c3 : index + %6 = arith.subi %c-1, %5 : index + %7 = arith.select %2, %6, %5 : index + %8 = arith.addi %7, %c3 : index + %alloca = memref.alloca(%c3) : memref + %alloca_0 = memref.alloca(%c3) : memref + affine.for %arg6 = 0 to 3 { + %9 = arith.muli %arg6, %c8 : index + %10 = arith.cmpi slt, %9, %c0 : index + %11 = arith.subi %c-1, %9 : index + %12 = arith.select %10, %11, %9 : index + %13 = arith.divsi %12, %c3 : index + %14 = arith.subi %c-1, %13 : index + %15 = arith.select %10, %14, %13 : index + %16 = arith.addi %9, %c10 : index + %17 = arith.cmpi slt, %16, %c0 : index + %18 = arith.subi %c-11, %9 : index + %19 = arith.select %17, %18, %16 : index + %20 = arith.divsi %19, %c3 : index + %21 = arith.subi %c-1, %20 : index + %22 = arith.select %17, %21, %20 : index + affine.store %c0_i32, %alloca[%arg6] : memref + affine.store %cst, %alloca_0[%arg6] : memref + affine.for %arg7 = #map(%arg4) to #map1(%arg4) { + %25 = affine.load %alloca[%arg6] : memref + %26 = affine.load %alloca_0[%arg6] : memref + %27 = arith.index_cast %arg7 : index to i32 + %28 = arith.muli %27, %c7_i32 : i32 + %29 = arith.muli %arg7, %c56 : index + %30:2 = scf.for %arg8 = %7 to %8 step %c1 iter_args(%arg9 = %25, %arg10 = %26) -> (i32, f32) { + %31 = arith.index_cast %arg8 : index to i32 + %32 = arith.addi %28, %31 : i32 + %33 = arith.muli %32, %c8_i32 : i32 + %34 = arith.muli %arg8, %c8 : index + %35:2 = scf.for %arg11 = %15 to %22 step %c1 iter_args(%arg12 = %arg9, %arg13 = %arg10) -> (i32, f32) { + %36 = arith.index_cast %arg11 : index to i32 + %37 = arith.addi %arg11, %34 : index + %38 = arith.addi %37, %0 : index + %39 = arith.addi %38, %29 : index + %40 = memref.load %arg0[%39] : memref + %41 = arith.cmpf ogt, %40, %arg13 : f32 + %42 = arith.select %41, %40, %arg13 : f32 + %43 = arith.addi %33, %36 : i32 + %44 = arith.select %41, %43, %arg12 : i32 + scf.yield %44, %42 : i32, f32 + } + scf.yield %35#0, %35#1 : i32, f32 + } + affine.store %30#0, %alloca[%arg6] : memref + affine.store %30#1, %alloca_0[%arg6] : memref + } + %23 = affine.load %alloca[%arg6] : memref + %24 = affine.load %alloca_0[%arg6] : memref + affine.store %24, %arg1[%arg3 * 27 + %arg6 + %arg4 * 9 + %arg5 * 3] : memref + affine.store %23, %arg2[%arg3 * 27 + %arg6 + %arg4 * 9 + %arg5 * 3] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu.mlir new file mode 100644 index 000000000000..4cd0ed99ee4e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_legacy_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c90_i32 = arith.constant 90 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %c9_i32 = arith.constant 9 : i32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %1 = affine.load %arg1[%arg3, %arg4, %arg5, %arg6] : memref + %2 = arith.divsi %1, %c90_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.divsi %1, %c10_i32 : i32 + %5 = arith.remsi %4, %c9_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + %7 = arith.remsi %1, %c10_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[%arg3, %arg4, %arg5, %arg6] : memref + %10 = memref.load %arg2[%arg3, %3, %6, %8] : memref + %11 = arith.addf %10, %9 : f32 + memref.store %11, %arg2[%arg3, %3, %6, %8] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..12348e4136c9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu/debuf.mlir @@ -0,0 +1,38 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_legacy_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c9_i32 = arith.constant 9 : i32 + %c10_i32 = arith.constant 10 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c90_i32 = arith.constant 90 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %3 = arith.index_cast %arg3 : index to i32 + %4 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %4 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %extracted = tensor.extract %0[%arg3, %arg4, %arg5, %arg6] : tensor + %3 = arith.divsi %extracted, %c90_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = arith.divsi %extracted, %c10_i32 : i32 + %6 = arith.remsi %5, %c9_i32 : i32 + %7 = arith.index_cast %6 : i32 to index + %8 = arith.remsi %extracted, %c10_i32 : i32 + %9 = arith.index_cast %8 : i32 to index + %extracted_0 = tensor.extract %1[%arg3, %arg4, %arg5, %arg6] : tensor + %10 = memref.load %arg2[%arg3, %4, %7, %9] : memref + %11 = arith.addf %10, %extracted_0 : f32 + memref.store %11, %arg2[%arg3, %4, %7, %9] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu/matched.mlir new file mode 100644 index 000000000000..12348e4136c9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu/matched.mlir @@ -0,0 +1,38 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_legacy_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c9_i32 = arith.constant 9 : i32 + %c10_i32 = arith.constant 10 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c90_i32 = arith.constant 90 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %3 = arith.index_cast %arg3 : index to i32 + %4 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %4 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %extracted = tensor.extract %0[%arg3, %arg4, %arg5, %arg6] : tensor + %3 = arith.divsi %extracted, %c90_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = arith.divsi %extracted, %c10_i32 : i32 + %6 = arith.remsi %5, %c9_i32 : i32 + %7 = arith.index_cast %6 : i32 to index + %8 = arith.remsi %extracted, %c10_i32 : i32 + %9 = arith.index_cast %8 : i32 to index + %extracted_0 = tensor.extract %1[%arg3, %arg4, %arg5, %arg6] : tensor + %10 = memref.load %arg2[%arg3, %4, %7, %9] : memref + %11 = arith.addf %10, %extracted_0 : f32 + memref.store %11, %arg2[%arg3, %4, %7, %9] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu/orig.mlir new file mode 100644 index 000000000000..4cd0ed99ee4e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu/orig.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_legacy_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c90_i32 = arith.constant 90 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %c9_i32 = arith.constant 9 : i32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %1 = affine.load %arg1[%arg3, %arg4, %arg5, %arg6] : memref + %2 = arith.divsi %1, %c90_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.divsi %1, %c10_i32 : i32 + %5 = arith.remsi %4, %c9_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + %7 = arith.remsi %1, %c10_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[%arg3, %arg4, %arg5, %arg6] : memref + %10 = memref.load %arg2[%arg3, %3, %6, %8] : memref + %11 = arith.addf %10, %9 : f32 + memref.store %11, %arg2[%arg3, %3, %6, %8] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu/raised.mlir new file mode 100644 index 000000000000..8091b501f01e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu/raised.mlir @@ -0,0 +1,36 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_legacy_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c90_i32 = arith.constant 90 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %c9_i32 = arith.constant 9 : i32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %1 = affine.load %arg1[%arg3, %arg4, %arg5, %arg6] : memref + %2 = arith.divsi %1, %c90_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.divsi %1, %c10_i32 : i32 + %5 = arith.remsi %4, %c9_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + %7 = arith.remsi %1, %c10_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[%arg3, %arg4, %arg5, %arg6] : memref + %10 = memref.load %arg2[%arg3, %3, %6, %8] : memref + %11 = arith.addf %10, %9 : f32 + memref.store %11, %arg2[%arg3, %3, %6, %8] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..12348e4136c9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu_debuf.mlir @@ -0,0 +1,38 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_legacy_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c9_i32 = arith.constant 9 : i32 + %c10_i32 = arith.constant 10 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c90_i32 = arith.constant 90 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %3 = arith.index_cast %arg3 : index to i32 + %4 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %4 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %extracted = tensor.extract %0[%arg3, %arg4, %arg5, %arg6] : tensor + %3 = arith.divsi %extracted, %c90_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = arith.divsi %extracted, %c10_i32 : i32 + %6 = arith.remsi %5, %c9_i32 : i32 + %7 = arith.index_cast %6 : i32 to index + %8 = arith.remsi %extracted, %c10_i32 : i32 + %9 = arith.index_cast %8 : i32 to index + %extracted_0 = tensor.extract %1[%arg3, %arg4, %arg5, %arg6] : tensor + %10 = memref.load %arg2[%arg3, %4, %7, %9] : memref + %11 = arith.addf %10, %extracted_0 : f32 + memref.store %11, %arg2[%arg3, %4, %7, %9] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..8091b501f01e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_backward_cpu_linalg.mlir @@ -0,0 +1,36 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_legacy_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c90_i32 = arith.constant 90 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %c9_i32 = arith.constant 9 : i32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %1 = affine.load %arg1[%arg3, %arg4, %arg5, %arg6] : memref + %2 = arith.divsi %1, %c90_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.divsi %1, %c10_i32 : i32 + %5 = arith.remsi %4, %c9_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + %7 = arith.remsi %1, %c10_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[%arg3, %arg4, %arg5, %arg6] : memref + %10 = memref.load %arg2[%arg3, %3, %6, %8] : memref + %11 = arith.addf %10, %9 : f32 + memref.store %11, %arg2[%arg3, %3, %6, %8] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu.mlir new file mode 100644 index 000000000000..e58e645e7bc2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu.mlir @@ -0,0 +1,94 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_legacy_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-11 = arith.constant -11 : index + %c10 = arith.constant 10 : index + %c9 = arith.constant 9 : index + %c-1 = arith.constant -1 : index + %c8 = arith.constant 8 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c10_i32 = arith.constant 10 : i32 + %c9_i32 = arith.constant 9 : i32 + %c8_i32 = arith.constant 8 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c3_i32 = arith.constant 3 : i32 + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %c1 = arith.constant 1 : index + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = arith.muli %0, %c8_i32 : i32 + %2 = arith.divsi %1, %c3_i32 : i32 + %3 = arith.muli %2, %c9_i32 : i32 + %4 = arith.muli %arg4, %c8 : index + %5 = arith.cmpi slt, %4, %c0 : index + %6 = arith.subi %c-1, %4 : index + %7 = arith.select %5, %6, %4 : index + %8 = arith.divsi %7, %c3 : index + %9 = arith.subi %c-1, %8 : index + %10 = arith.select %5, %9, %8 : index + %11 = arith.addi %4, %c10 : index + %12 = arith.cmpi slt, %11, %c0 : index + %13 = arith.subi %c-11, %4 : index + %14 = arith.select %12, %13, %11 : index + %15 = arith.divsi %14, %c3 : index + %16 = arith.subi %c-1, %15 : index + %17 = arith.select %12, %16, %15 : index + affine.for %arg5 = 0 to 4 { + %18 = arith.index_cast %arg5 : index to i32 + %19 = arith.muli %18, %c9_i32 : i32 + %20 = arith.divsi %19, %c4_i32 : i32 + %21 = arith.addi %3, %20 : i32 + %22 = arith.muli %21, %c10_i32 : i32 + %23 = arith.muli %arg5, %c9 : index + %24 = arith.cmpi slt, %23, %c0 : index + %25 = arith.subi %c-1, %23 : index + %26 = arith.select %24, %25, %23 : index + %27 = arith.divsi %26, %c4 : index + %28 = arith.subi %c-1, %27 : index + %29 = arith.select %24, %28, %27 : index + %30 = arith.addi %29, %c3 : index + affine.for %arg6 = 0 to 5 { + %31 = arith.index_cast %arg6 : index to i32 + %32 = arith.muli %31, %c10_i32 : i32 + %33 = arith.divsi %32, %c5_i32 : i32 + %34 = arith.addi %22, %33 : i32 + %35 = arith.muli %arg6, %c2 : index + %36 = memref.load %arg0[%arg3, %10, %29, %35] : memref + %37:2 = scf.for %arg7 = %10 to %17 step %c1 iter_args(%arg8 = %36, %arg9 = %34) -> (f32, i32) { + %38 = arith.index_cast %arg7 : index to i32 + %39 = arith.muli %38, %c9_i32 : i32 + %40:2 = scf.for %arg10 = %29 to %30 step %c1 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (f32, i32) { + %41 = arith.index_cast %arg10 : index to i32 + %42 = arith.addi %39, %41 : i32 + %43 = arith.muli %42, %c10_i32 : i32 + %44:2 = affine.for %arg13 = #map(%arg6) to #map1(%arg6) iter_args(%arg14 = %arg11, %arg15 = %arg12) -> (f32, i32) { + %45 = arith.index_cast %arg13 : index to i32 + %46 = memref.load %arg0[%arg3, %arg7, %arg10, %arg13] : memref + %47 = arith.cmpf ogt, %46, %arg14 : f32 + %48 = arith.select %47, %46, %arg14 : f32 + %49 = scf.if %47 -> (i32) { + %50 = arith.addi %43, %45 : i32 + scf.yield %50 : i32 + } else { + scf.yield %arg15 : i32 + } + affine.yield %48, %49 : f32, i32 + } + scf.yield %44#0, %44#1 : f32, i32 + } + scf.yield %40#0, %40#1 : f32, i32 + } + affine.store %37#0, %arg1[%arg3, %arg4, %arg5, %arg6] : memref + affine.store %37#1, %arg2[%arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu/debuf.mlir new file mode 100644 index 000000000000..90b9895691b5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu/debuf.mlir @@ -0,0 +1,114 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_legacy_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c3_i32 = arith.constant 3 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c8_i32 = arith.constant 8 : i32 + %c9_i32 = arith.constant 9 : i32 + %c10_i32 = arith.constant 10 : i32 + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %c9 = arith.constant 9 : index + %c10 = arith.constant 10 : index + %c-11 = arith.constant -11 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %6:2 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %7 = arith.index_cast %arg6 : index to i32 + %8 = arith.muli %7, %c8_i32 : i32 + %9 = arith.divsi %8, %c3_i32 : i32 + %10 = arith.muli %9, %c9_i32 : i32 + %11 = arith.muli %arg6, %c8 : index + %12 = arith.cmpi slt, %11, %c0 : index + %13 = arith.subi %c-1, %11 : index + %14 = arith.select %12, %13, %11 : index + %15 = arith.divsi %14, %c3 : index + %16 = arith.subi %c-1, %15 : index + %17 = arith.select %12, %16, %15 : index + %18 = arith.addi %11, %c10 : index + %19 = arith.cmpi slt, %18, %c0 : index + %20 = arith.subi %c-11, %11 : index + %21 = arith.select %19, %20, %18 : index + %22 = arith.divsi %21, %c3 : index + %23 = arith.subi %c-1, %22 : index + %24 = arith.select %19, %23, %22 : index + %25:2 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (tensor, tensor) { + %26 = arith.index_cast %arg9 : index to i32 + %27 = arith.muli %26, %c9_i32 : i32 + %28 = arith.divsi %27, %c4_i32 : i32 + %29 = arith.addi %10, %28 : i32 + %30 = arith.muli %29, %c10_i32 : i32 + %31 = arith.muli %arg9, %c9 : index + %32 = arith.cmpi slt, %31, %c0 : index + %33 = arith.subi %c-1, %31 : index + %34 = arith.select %32, %33, %31 : index + %35 = arith.divsi %34, %c4 : index + %36 = arith.subi %c-1, %35 : index + %37 = arith.select %32, %36, %35 : index + %38 = arith.addi %37, %c3 : index + %39:2 = affine.for %arg12 = 0 to 5 iter_args(%arg13 = %arg10, %arg14 = %arg11) -> (tensor, tensor) { + %40 = arith.index_cast %arg12 : index to i32 + %41 = arith.muli %40, %c10_i32 : i32 + %42 = arith.divsi %41, %c5_i32 : i32 + %43 = arith.addi %30, %42 : i32 + %44 = arith.muli %arg12, %c2 : index + %extracted = tensor.extract %2[%arg3, %17, %37, %44] : tensor + %45:2 = scf.for %arg15 = %17 to %24 step %c1 iter_args(%arg16 = %extracted, %arg17 = %43) -> (f32, i32) { + %46 = arith.index_cast %arg15 : index to i32 + %47 = arith.muli %46, %c9_i32 : i32 + %48:2 = scf.for %arg18 = %37 to %38 step %c1 iter_args(%arg19 = %arg16, %arg20 = %arg17) -> (f32, i32) { + %49 = arith.index_cast %arg18 : index to i32 + %50 = arith.addi %47, %49 : i32 + %51 = arith.muli %50, %c10_i32 : i32 + %alloca = memref.alloca() : memref + %52 = bufferization.to_tensor %alloca : memref + %inserted_1 = tensor.insert %arg19 into %52[] : tensor + %alloca_2 = memref.alloca() : memref + %53 = bufferization.to_tensor %alloca_2 : memref + %inserted_3 = tensor.insert %arg20 into %53[] : tensor + %54:2 = affine.for %arg21 = #map(%arg12) to #map1(%arg12) iter_args(%arg22 = %inserted_1, %arg23 = %inserted_3) -> (tensor, tensor) { + %extracted_6 = tensor.extract %arg22[] : tensor + %extracted_7 = tensor.extract %arg23[] : tensor + %55 = arith.index_cast %arg21 : index to i32 + %extracted_8 = tensor.extract %2[%arg3, %arg15, %arg18, %arg21] : tensor + %56 = arith.cmpf ogt, %extracted_8, %extracted_6 : f32 + %57 = arith.select %56, %extracted_8, %extracted_6 : f32 + %58 = arith.addi %51, %55 : i32 + %59 = arith.select %56, %58, %extracted_7 : i32 + %inserted_9 = tensor.insert %57 into %arg22[] : tensor + %inserted_10 = tensor.insert %59 into %arg23[] : tensor + affine.yield %inserted_9, %inserted_10 : tensor, tensor + } + %extracted_4 = tensor.extract %54#0[] : tensor + %extracted_5 = tensor.extract %54#1[] : tensor + scf.yield %extracted_4, %extracted_5 : f32, i32 + } + scf.yield %48#0, %48#1 : f32, i32 + } + %inserted = tensor.insert %45#0 into %arg13[%arg3, %arg6, %arg9, %arg12] : tensor + %inserted_0 = tensor.insert %45#1 into %arg14[%arg3, %arg6, %arg9, %arg12] : tensor + affine.yield %inserted, %inserted_0 : tensor, tensor + } + affine.yield %39#0, %39#1 : tensor, tensor + } + affine.yield %25#0, %25#1 : tensor, tensor + } + affine.yield %6#0, %6#1 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu/matched.mlir new file mode 100644 index 000000000000..90b9895691b5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu/matched.mlir @@ -0,0 +1,114 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_legacy_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c3_i32 = arith.constant 3 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c8_i32 = arith.constant 8 : i32 + %c9_i32 = arith.constant 9 : i32 + %c10_i32 = arith.constant 10 : i32 + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %c9 = arith.constant 9 : index + %c10 = arith.constant 10 : index + %c-11 = arith.constant -11 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %6:2 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %7 = arith.index_cast %arg6 : index to i32 + %8 = arith.muli %7, %c8_i32 : i32 + %9 = arith.divsi %8, %c3_i32 : i32 + %10 = arith.muli %9, %c9_i32 : i32 + %11 = arith.muli %arg6, %c8 : index + %12 = arith.cmpi slt, %11, %c0 : index + %13 = arith.subi %c-1, %11 : index + %14 = arith.select %12, %13, %11 : index + %15 = arith.divsi %14, %c3 : index + %16 = arith.subi %c-1, %15 : index + %17 = arith.select %12, %16, %15 : index + %18 = arith.addi %11, %c10 : index + %19 = arith.cmpi slt, %18, %c0 : index + %20 = arith.subi %c-11, %11 : index + %21 = arith.select %19, %20, %18 : index + %22 = arith.divsi %21, %c3 : index + %23 = arith.subi %c-1, %22 : index + %24 = arith.select %19, %23, %22 : index + %25:2 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (tensor, tensor) { + %26 = arith.index_cast %arg9 : index to i32 + %27 = arith.muli %26, %c9_i32 : i32 + %28 = arith.divsi %27, %c4_i32 : i32 + %29 = arith.addi %10, %28 : i32 + %30 = arith.muli %29, %c10_i32 : i32 + %31 = arith.muli %arg9, %c9 : index + %32 = arith.cmpi slt, %31, %c0 : index + %33 = arith.subi %c-1, %31 : index + %34 = arith.select %32, %33, %31 : index + %35 = arith.divsi %34, %c4 : index + %36 = arith.subi %c-1, %35 : index + %37 = arith.select %32, %36, %35 : index + %38 = arith.addi %37, %c3 : index + %39:2 = affine.for %arg12 = 0 to 5 iter_args(%arg13 = %arg10, %arg14 = %arg11) -> (tensor, tensor) { + %40 = arith.index_cast %arg12 : index to i32 + %41 = arith.muli %40, %c10_i32 : i32 + %42 = arith.divsi %41, %c5_i32 : i32 + %43 = arith.addi %30, %42 : i32 + %44 = arith.muli %arg12, %c2 : index + %extracted = tensor.extract %2[%arg3, %17, %37, %44] : tensor + %45:2 = scf.for %arg15 = %17 to %24 step %c1 iter_args(%arg16 = %extracted, %arg17 = %43) -> (f32, i32) { + %46 = arith.index_cast %arg15 : index to i32 + %47 = arith.muli %46, %c9_i32 : i32 + %48:2 = scf.for %arg18 = %37 to %38 step %c1 iter_args(%arg19 = %arg16, %arg20 = %arg17) -> (f32, i32) { + %49 = arith.index_cast %arg18 : index to i32 + %50 = arith.addi %47, %49 : i32 + %51 = arith.muli %50, %c10_i32 : i32 + %alloca = memref.alloca() : memref + %52 = bufferization.to_tensor %alloca : memref + %inserted_1 = tensor.insert %arg19 into %52[] : tensor + %alloca_2 = memref.alloca() : memref + %53 = bufferization.to_tensor %alloca_2 : memref + %inserted_3 = tensor.insert %arg20 into %53[] : tensor + %54:2 = affine.for %arg21 = #map(%arg12) to #map1(%arg12) iter_args(%arg22 = %inserted_1, %arg23 = %inserted_3) -> (tensor, tensor) { + %extracted_6 = tensor.extract %arg22[] : tensor + %extracted_7 = tensor.extract %arg23[] : tensor + %55 = arith.index_cast %arg21 : index to i32 + %extracted_8 = tensor.extract %2[%arg3, %arg15, %arg18, %arg21] : tensor + %56 = arith.cmpf ogt, %extracted_8, %extracted_6 : f32 + %57 = arith.select %56, %extracted_8, %extracted_6 : f32 + %58 = arith.addi %51, %55 : i32 + %59 = arith.select %56, %58, %extracted_7 : i32 + %inserted_9 = tensor.insert %57 into %arg22[] : tensor + %inserted_10 = tensor.insert %59 into %arg23[] : tensor + affine.yield %inserted_9, %inserted_10 : tensor, tensor + } + %extracted_4 = tensor.extract %54#0[] : tensor + %extracted_5 = tensor.extract %54#1[] : tensor + scf.yield %extracted_4, %extracted_5 : f32, i32 + } + scf.yield %48#0, %48#1 : f32, i32 + } + %inserted = tensor.insert %45#0 into %arg13[%arg3, %arg6, %arg9, %arg12] : tensor + %inserted_0 = tensor.insert %45#1 into %arg14[%arg3, %arg6, %arg9, %arg12] : tensor + affine.yield %inserted, %inserted_0 : tensor, tensor + } + affine.yield %39#0, %39#1 : tensor, tensor + } + affine.yield %25#0, %25#1 : tensor, tensor + } + affine.yield %6#0, %6#1 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu/orig.mlir new file mode 100644 index 000000000000..e58e645e7bc2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu/orig.mlir @@ -0,0 +1,94 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_legacy_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-11 = arith.constant -11 : index + %c10 = arith.constant 10 : index + %c9 = arith.constant 9 : index + %c-1 = arith.constant -1 : index + %c8 = arith.constant 8 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c10_i32 = arith.constant 10 : i32 + %c9_i32 = arith.constant 9 : i32 + %c8_i32 = arith.constant 8 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c3_i32 = arith.constant 3 : i32 + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %c1 = arith.constant 1 : index + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = arith.muli %0, %c8_i32 : i32 + %2 = arith.divsi %1, %c3_i32 : i32 + %3 = arith.muli %2, %c9_i32 : i32 + %4 = arith.muli %arg4, %c8 : index + %5 = arith.cmpi slt, %4, %c0 : index + %6 = arith.subi %c-1, %4 : index + %7 = arith.select %5, %6, %4 : index + %8 = arith.divsi %7, %c3 : index + %9 = arith.subi %c-1, %8 : index + %10 = arith.select %5, %9, %8 : index + %11 = arith.addi %4, %c10 : index + %12 = arith.cmpi slt, %11, %c0 : index + %13 = arith.subi %c-11, %4 : index + %14 = arith.select %12, %13, %11 : index + %15 = arith.divsi %14, %c3 : index + %16 = arith.subi %c-1, %15 : index + %17 = arith.select %12, %16, %15 : index + affine.for %arg5 = 0 to 4 { + %18 = arith.index_cast %arg5 : index to i32 + %19 = arith.muli %18, %c9_i32 : i32 + %20 = arith.divsi %19, %c4_i32 : i32 + %21 = arith.addi %3, %20 : i32 + %22 = arith.muli %21, %c10_i32 : i32 + %23 = arith.muli %arg5, %c9 : index + %24 = arith.cmpi slt, %23, %c0 : index + %25 = arith.subi %c-1, %23 : index + %26 = arith.select %24, %25, %23 : index + %27 = arith.divsi %26, %c4 : index + %28 = arith.subi %c-1, %27 : index + %29 = arith.select %24, %28, %27 : index + %30 = arith.addi %29, %c3 : index + affine.for %arg6 = 0 to 5 { + %31 = arith.index_cast %arg6 : index to i32 + %32 = arith.muli %31, %c10_i32 : i32 + %33 = arith.divsi %32, %c5_i32 : i32 + %34 = arith.addi %22, %33 : i32 + %35 = arith.muli %arg6, %c2 : index + %36 = memref.load %arg0[%arg3, %10, %29, %35] : memref + %37:2 = scf.for %arg7 = %10 to %17 step %c1 iter_args(%arg8 = %36, %arg9 = %34) -> (f32, i32) { + %38 = arith.index_cast %arg7 : index to i32 + %39 = arith.muli %38, %c9_i32 : i32 + %40:2 = scf.for %arg10 = %29 to %30 step %c1 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (f32, i32) { + %41 = arith.index_cast %arg10 : index to i32 + %42 = arith.addi %39, %41 : i32 + %43 = arith.muli %42, %c10_i32 : i32 + %44:2 = affine.for %arg13 = #map(%arg6) to #map1(%arg6) iter_args(%arg14 = %arg11, %arg15 = %arg12) -> (f32, i32) { + %45 = arith.index_cast %arg13 : index to i32 + %46 = memref.load %arg0[%arg3, %arg7, %arg10, %arg13] : memref + %47 = arith.cmpf ogt, %46, %arg14 : f32 + %48 = arith.select %47, %46, %arg14 : f32 + %49 = scf.if %47 -> (i32) { + %50 = arith.addi %43, %45 : i32 + scf.yield %50 : i32 + } else { + scf.yield %arg15 : i32 + } + affine.yield %48, %49 : f32, i32 + } + scf.yield %44#0, %44#1 : f32, i32 + } + scf.yield %40#0, %40#1 : f32, i32 + } + affine.store %37#0, %arg1[%arg3, %arg4, %arg5, %arg6] : memref + affine.store %37#1, %arg2[%arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu/raised.mlir new file mode 100644 index 000000000000..1be4e6939974 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu/raised.mlir @@ -0,0 +1,100 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_legacy_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-11 = arith.constant -11 : index + %c10 = arith.constant 10 : index + %c9 = arith.constant 9 : index + %c-1 = arith.constant -1 : index + %c8 = arith.constant 8 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c10_i32 = arith.constant 10 : i32 + %c9_i32 = arith.constant 9 : i32 + %c8_i32 = arith.constant 8 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c3_i32 = arith.constant 3 : i32 + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %c1 = arith.constant 1 : index + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = arith.muli %0, %c8_i32 : i32 + %2 = arith.divsi %1, %c3_i32 : i32 + %3 = arith.muli %2, %c9_i32 : i32 + %4 = arith.muli %arg4, %c8 : index + %5 = arith.cmpi slt, %4, %c0 : index + %6 = arith.subi %c-1, %4 : index + %7 = arith.select %5, %6, %4 : index + %8 = arith.divsi %7, %c3 : index + %9 = arith.subi %c-1, %8 : index + %10 = arith.select %5, %9, %8 : index + %11 = arith.addi %4, %c10 : index + %12 = arith.cmpi slt, %11, %c0 : index + %13 = arith.subi %c-11, %4 : index + %14 = arith.select %12, %13, %11 : index + %15 = arith.divsi %14, %c3 : index + %16 = arith.subi %c-1, %15 : index + %17 = arith.select %12, %16, %15 : index + affine.for %arg5 = 0 to 4 { + %18 = arith.index_cast %arg5 : index to i32 + %19 = arith.muli %18, %c9_i32 : i32 + %20 = arith.divsi %19, %c4_i32 : i32 + %21 = arith.addi %3, %20 : i32 + %22 = arith.muli %21, %c10_i32 : i32 + %23 = arith.muli %arg5, %c9 : index + %24 = arith.cmpi slt, %23, %c0 : index + %25 = arith.subi %c-1, %23 : index + %26 = arith.select %24, %25, %23 : index + %27 = arith.divsi %26, %c4 : index + %28 = arith.subi %c-1, %27 : index + %29 = arith.select %24, %28, %27 : index + %30 = arith.addi %29, %c3 : index + affine.for %arg6 = 0 to 5 { + %31 = arith.index_cast %arg6 : index to i32 + %32 = arith.muli %31, %c10_i32 : i32 + %33 = arith.divsi %32, %c5_i32 : i32 + %34 = arith.addi %22, %33 : i32 + %35 = arith.muli %arg6, %c2 : index + %36 = memref.load %arg0[%arg3, %10, %29, %35] : memref + %37:2 = scf.for %arg7 = %10 to %17 step %c1 iter_args(%arg8 = %36, %arg9 = %34) -> (f32, i32) { + %38 = arith.index_cast %arg7 : index to i32 + %39 = arith.muli %38, %c9_i32 : i32 + %40:2 = scf.for %arg10 = %29 to %30 step %c1 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (f32, i32) { + %41 = arith.index_cast %arg10 : index to i32 + %42 = arith.addi %39, %41 : i32 + %43 = arith.muli %42, %c10_i32 : i32 + %alloca = memref.alloca() : memref + affine.store %arg11, %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %arg12, %alloca_0[] : memref + affine.for %arg13 = #map(%arg6) to #map1(%arg6) { + %46 = affine.load %alloca[] : memref + %47 = affine.load %alloca_0[] : memref + %48 = arith.index_cast %arg13 : index to i32 + %49 = memref.load %arg0[%arg3, %arg7, %arg10, %arg13] : memref + %50 = arith.cmpf ogt, %49, %46 : f32 + %51 = arith.select %50, %49, %46 : f32 + %52 = arith.addi %43, %48 : i32 + %53 = arith.select %50, %52, %47 : i32 + affine.store %51, %alloca[] : memref + affine.store %53, %alloca_0[] : memref + } + %44 = affine.load %alloca[] : memref + %45 = affine.load %alloca_0[] : memref + scf.yield %44, %45 : f32, i32 + } + scf.yield %40#0, %40#1 : f32, i32 + } + affine.store %37#0, %arg1[%arg3, %arg4, %arg5, %arg6] : memref + affine.store %37#1, %arg2[%arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu_debuf.mlir new file mode 100644 index 000000000000..90b9895691b5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu_debuf.mlir @@ -0,0 +1,114 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_legacy_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c3_i32 = arith.constant 3 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c8_i32 = arith.constant 8 : i32 + %c9_i32 = arith.constant 9 : i32 + %c10_i32 = arith.constant 10 : i32 + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %c9 = arith.constant 9 : index + %c10 = arith.constant 10 : index + %c-11 = arith.constant -11 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %6:2 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %7 = arith.index_cast %arg6 : index to i32 + %8 = arith.muli %7, %c8_i32 : i32 + %9 = arith.divsi %8, %c3_i32 : i32 + %10 = arith.muli %9, %c9_i32 : i32 + %11 = arith.muli %arg6, %c8 : index + %12 = arith.cmpi slt, %11, %c0 : index + %13 = arith.subi %c-1, %11 : index + %14 = arith.select %12, %13, %11 : index + %15 = arith.divsi %14, %c3 : index + %16 = arith.subi %c-1, %15 : index + %17 = arith.select %12, %16, %15 : index + %18 = arith.addi %11, %c10 : index + %19 = arith.cmpi slt, %18, %c0 : index + %20 = arith.subi %c-11, %11 : index + %21 = arith.select %19, %20, %18 : index + %22 = arith.divsi %21, %c3 : index + %23 = arith.subi %c-1, %22 : index + %24 = arith.select %19, %23, %22 : index + %25:2 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (tensor, tensor) { + %26 = arith.index_cast %arg9 : index to i32 + %27 = arith.muli %26, %c9_i32 : i32 + %28 = arith.divsi %27, %c4_i32 : i32 + %29 = arith.addi %10, %28 : i32 + %30 = arith.muli %29, %c10_i32 : i32 + %31 = arith.muli %arg9, %c9 : index + %32 = arith.cmpi slt, %31, %c0 : index + %33 = arith.subi %c-1, %31 : index + %34 = arith.select %32, %33, %31 : index + %35 = arith.divsi %34, %c4 : index + %36 = arith.subi %c-1, %35 : index + %37 = arith.select %32, %36, %35 : index + %38 = arith.addi %37, %c3 : index + %39:2 = affine.for %arg12 = 0 to 5 iter_args(%arg13 = %arg10, %arg14 = %arg11) -> (tensor, tensor) { + %40 = arith.index_cast %arg12 : index to i32 + %41 = arith.muli %40, %c10_i32 : i32 + %42 = arith.divsi %41, %c5_i32 : i32 + %43 = arith.addi %30, %42 : i32 + %44 = arith.muli %arg12, %c2 : index + %extracted = tensor.extract %2[%arg3, %17, %37, %44] : tensor + %45:2 = scf.for %arg15 = %17 to %24 step %c1 iter_args(%arg16 = %extracted, %arg17 = %43) -> (f32, i32) { + %46 = arith.index_cast %arg15 : index to i32 + %47 = arith.muli %46, %c9_i32 : i32 + %48:2 = scf.for %arg18 = %37 to %38 step %c1 iter_args(%arg19 = %arg16, %arg20 = %arg17) -> (f32, i32) { + %49 = arith.index_cast %arg18 : index to i32 + %50 = arith.addi %47, %49 : i32 + %51 = arith.muli %50, %c10_i32 : i32 + %alloca = memref.alloca() : memref + %52 = bufferization.to_tensor %alloca : memref + %inserted_1 = tensor.insert %arg19 into %52[] : tensor + %alloca_2 = memref.alloca() : memref + %53 = bufferization.to_tensor %alloca_2 : memref + %inserted_3 = tensor.insert %arg20 into %53[] : tensor + %54:2 = affine.for %arg21 = #map(%arg12) to #map1(%arg12) iter_args(%arg22 = %inserted_1, %arg23 = %inserted_3) -> (tensor, tensor) { + %extracted_6 = tensor.extract %arg22[] : tensor + %extracted_7 = tensor.extract %arg23[] : tensor + %55 = arith.index_cast %arg21 : index to i32 + %extracted_8 = tensor.extract %2[%arg3, %arg15, %arg18, %arg21] : tensor + %56 = arith.cmpf ogt, %extracted_8, %extracted_6 : f32 + %57 = arith.select %56, %extracted_8, %extracted_6 : f32 + %58 = arith.addi %51, %55 : i32 + %59 = arith.select %56, %58, %extracted_7 : i32 + %inserted_9 = tensor.insert %57 into %arg22[] : tensor + %inserted_10 = tensor.insert %59 into %arg23[] : tensor + affine.yield %inserted_9, %inserted_10 : tensor, tensor + } + %extracted_4 = tensor.extract %54#0[] : tensor + %extracted_5 = tensor.extract %54#1[] : tensor + scf.yield %extracted_4, %extracted_5 : f32, i32 + } + scf.yield %48#0, %48#1 : f32, i32 + } + %inserted = tensor.insert %45#0 into %arg13[%arg3, %arg6, %arg9, %arg12] : tensor + %inserted_0 = tensor.insert %45#1 into %arg14[%arg3, %arg6, %arg9, %arg12] : tensor + affine.yield %inserted, %inserted_0 : tensor, tensor + } + affine.yield %39#0, %39#1 : tensor, tensor + } + affine.yield %25#0, %25#1 : tensor, tensor + } + affine.yield %6#0, %6#1 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu_linalg.mlir new file mode 100644 index 000000000000..1be4e6939974 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_adaptive_max_pool3d_legacy_cpu_linalg.mlir @@ -0,0 +1,100 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_adaptive_max_pool3d_legacy_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-11 = arith.constant -11 : index + %c10 = arith.constant 10 : index + %c9 = arith.constant 9 : index + %c-1 = arith.constant -1 : index + %c8 = arith.constant 8 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c10_i32 = arith.constant 10 : i32 + %c9_i32 = arith.constant 9 : i32 + %c8_i32 = arith.constant 8 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c3_i32 = arith.constant 3 : i32 + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %c1 = arith.constant 1 : index + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = arith.muli %0, %c8_i32 : i32 + %2 = arith.divsi %1, %c3_i32 : i32 + %3 = arith.muli %2, %c9_i32 : i32 + %4 = arith.muli %arg4, %c8 : index + %5 = arith.cmpi slt, %4, %c0 : index + %6 = arith.subi %c-1, %4 : index + %7 = arith.select %5, %6, %4 : index + %8 = arith.divsi %7, %c3 : index + %9 = arith.subi %c-1, %8 : index + %10 = arith.select %5, %9, %8 : index + %11 = arith.addi %4, %c10 : index + %12 = arith.cmpi slt, %11, %c0 : index + %13 = arith.subi %c-11, %4 : index + %14 = arith.select %12, %13, %11 : index + %15 = arith.divsi %14, %c3 : index + %16 = arith.subi %c-1, %15 : index + %17 = arith.select %12, %16, %15 : index + affine.for %arg5 = 0 to 4 { + %18 = arith.index_cast %arg5 : index to i32 + %19 = arith.muli %18, %c9_i32 : i32 + %20 = arith.divsi %19, %c4_i32 : i32 + %21 = arith.addi %3, %20 : i32 + %22 = arith.muli %21, %c10_i32 : i32 + %23 = arith.muli %arg5, %c9 : index + %24 = arith.cmpi slt, %23, %c0 : index + %25 = arith.subi %c-1, %23 : index + %26 = arith.select %24, %25, %23 : index + %27 = arith.divsi %26, %c4 : index + %28 = arith.subi %c-1, %27 : index + %29 = arith.select %24, %28, %27 : index + %30 = arith.addi %29, %c3 : index + affine.for %arg6 = 0 to 5 { + %31 = arith.index_cast %arg6 : index to i32 + %32 = arith.muli %31, %c10_i32 : i32 + %33 = arith.divsi %32, %c5_i32 : i32 + %34 = arith.addi %22, %33 : i32 + %35 = arith.muli %arg6, %c2 : index + %36 = memref.load %arg0[%arg3, %10, %29, %35] : memref + %37:2 = scf.for %arg7 = %10 to %17 step %c1 iter_args(%arg8 = %36, %arg9 = %34) -> (f32, i32) { + %38 = arith.index_cast %arg7 : index to i32 + %39 = arith.muli %38, %c9_i32 : i32 + %40:2 = scf.for %arg10 = %29 to %30 step %c1 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (f32, i32) { + %41 = arith.index_cast %arg10 : index to i32 + %42 = arith.addi %39, %41 : i32 + %43 = arith.muli %42, %c10_i32 : i32 + %alloca = memref.alloca() : memref + affine.store %arg11, %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %arg12, %alloca_0[] : memref + affine.for %arg13 = #map(%arg6) to #map1(%arg6) { + %46 = affine.load %alloca[] : memref + %47 = affine.load %alloca_0[] : memref + %48 = arith.index_cast %arg13 : index to i32 + %49 = memref.load %arg0[%arg3, %arg7, %arg10, %arg13] : memref + %50 = arith.cmpf ogt, %49, %46 : f32 + %51 = arith.select %50, %49, %46 : f32 + %52 = arith.addi %43, %48 : i32 + %53 = arith.select %50, %52, %47 : i32 + affine.store %51, %alloca[] : memref + affine.store %53, %alloca_0[] : memref + } + %44 = affine.load %alloca[] : memref + %45 = affine.load %alloca_0[] : memref + scf.yield %44, %45 : f32, i32 + } + scf.yield %40#0, %40#1 : f32, i32 + } + affine.store %37#0, %arg1[%arg3, %arg4, %arg5, %arg6] : memref + affine.store %37#1, %arg2[%arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_add.mlir b/issues/aten_c_kernels/results/aten_add.mlir new file mode 100644 index 000000000000..b48eeaf36192 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_add.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_add(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 16 { + %0 = affine.load %arg0[%arg2, %arg3, %arg4, %arg5] : memref + %1 = affine.load %arg1[%arg2, %arg3, %arg4, %arg5] : memref + %2 = arith.addf %1, %0 : f32 + affine.store %2, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_add/debuf.mlir b/issues/aten_c_kernels/results/aten_add/debuf.mlir new file mode 100644 index 000000000000..ae16960bcf44 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_add/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_add(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_add/matched.mlir b/issues/aten_c_kernels/results/aten_add/matched.mlir new file mode 100644 index 000000000000..cca48701862e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_add/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_add(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %2 = kernel.launch @cudnnAddTensor_batched(%extracted_slice, %extracted_slice_0) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_add/orig.mlir b/issues/aten_c_kernels/results/aten_add/orig.mlir new file mode 100644 index 000000000000..b48eeaf36192 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_add/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_add(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 16 { + %0 = affine.load %arg0[%arg2, %arg3, %arg4, %arg5] : memref + %1 = affine.load %arg1[%arg2, %arg3, %arg4, %arg5] : memref + %2 = arith.addf %1, %0 : f32 + affine.store %2, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_add/raised.mlir b/issues/aten_c_kernels/results/aten_add/raised.mlir new file mode 100644 index 000000000000..b178399ad0da --- /dev/null +++ b/issues/aten_c_kernels/results/aten_add/raised.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_add(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %subview = memref.subview %arg0[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.addf %out, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_add_clamp.mlir b/issues/aten_c_kernels/results/aten_add_clamp.mlir new file mode 100644 index 000000000000..1b87cceca414 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_add_clamp.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_add_clamp(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg6 = 0 to 4096 { + %0 = affine.load %arg0[%arg6] : memref + %1 = affine.load %arg1[%arg6] : memref + %2 = arith.mulf %arg2, %1 : f32 + %3 = arith.addf %0, %2 : f32 + %4 = arith.cmpf olt, %3, %arg3 : f32 + %5 = scf.if %4 -> (f32) { + scf.yield %arg3 : f32 + } else { + %6 = arith.cmpf ogt, %3, %arg4 : f32 + %7 = arith.select %6, %arg4, %3 : f32 + scf.yield %7 : f32 + } + affine.store %5, %arg5[%arg6] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_add_clamp/debuf.mlir b/issues/aten_c_kernels/results/aten_add_clamp/debuf.mlir new file mode 100644 index 000000000000..1942f13afd7b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_add_clamp/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_add_clamp(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg5 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %arg2, %in_0 : f32 + %6 = arith.addf %in, %5 : f32 + %7 = arith.cmpf olt, %6, %arg3 : f32 + %8 = arith.cmpf ogt, %6, %arg4 : f32 + %9 = arith.select %8, %arg4, %6 : f32 + %10 = arith.select %7, %arg3, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_add_clamp/matched.mlir b/issues/aten_c_kernels/results/aten_add_clamp/matched.mlir new file mode 100644 index 000000000000..1942f13afd7b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_add_clamp/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_add_clamp(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg5 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %arg2, %in_0 : f32 + %6 = arith.addf %in, %5 : f32 + %7 = arith.cmpf olt, %6, %arg3 : f32 + %8 = arith.cmpf ogt, %6, %arg4 : f32 + %9 = arith.select %8, %arg4, %6 : f32 + %10 = arith.select %7, %arg3, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_add_clamp/orig.mlir b/issues/aten_c_kernels/results/aten_add_clamp/orig.mlir new file mode 100644 index 000000000000..1b87cceca414 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_add_clamp/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_add_clamp(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg6 = 0 to 4096 { + %0 = affine.load %arg0[%arg6] : memref + %1 = affine.load %arg1[%arg6] : memref + %2 = arith.mulf %arg2, %1 : f32 + %3 = arith.addf %0, %2 : f32 + %4 = arith.cmpf olt, %3, %arg3 : f32 + %5 = scf.if %4 -> (f32) { + scf.yield %arg3 : f32 + } else { + %6 = arith.cmpf ogt, %3, %arg4 : f32 + %7 = arith.select %6, %arg4, %3 : f32 + scf.yield %7 : f32 + } + affine.store %5, %arg5[%arg6] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_add_clamp/raised.mlir b/issues/aten_c_kernels/results/aten_add_clamp/raised.mlir new file mode 100644 index 000000000000..77d7ef27d8b6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_add_clamp/raised.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_add_clamp(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg5 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %arg2, %in_0 : f32 + %1 = arith.addf %in, %0 : f32 + %2 = arith.cmpf olt, %1, %arg3 : f32 + %3 = arith.cmpf ogt, %1, %arg4 : f32 + %4 = arith.select %3, %arg4, %1 : f32 + %5 = arith.select %2, %arg3, %4 : f32 + linalg.yield %5 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_add_clamp_debuf.mlir b/issues/aten_c_kernels/results/aten_add_clamp_debuf.mlir new file mode 100644 index 000000000000..1942f13afd7b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_add_clamp_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_add_clamp(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg5 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %arg2, %in_0 : f32 + %6 = arith.addf %in, %5 : f32 + %7 = arith.cmpf olt, %6, %arg3 : f32 + %8 = arith.cmpf ogt, %6, %arg4 : f32 + %9 = arith.select %8, %arg4, %6 : f32 + %10 = arith.select %7, %arg3, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_add_clamp_linalg.mlir b/issues/aten_c_kernels/results/aten_add_clamp_linalg.mlir new file mode 100644 index 000000000000..77d7ef27d8b6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_add_clamp_linalg.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_add_clamp(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg5 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %arg2, %in_0 : f32 + %1 = arith.addf %in, %0 : f32 + %2 = arith.cmpf olt, %1, %arg3 : f32 + %3 = arith.cmpf ogt, %1, %arg4 : f32 + %4 = arith.select %3, %arg4, %1 : f32 + %5 = arith.select %2, %arg3, %4 : f32 + linalg.yield %5 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_add_debuf.mlir b/issues/aten_c_kernels/results/aten_add_debuf.mlir new file mode 100644 index 000000000000..ae16960bcf44 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_add_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_add(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_add_linalg.mlir b/issues/aten_c_kernels/results/aten_add_linalg.mlir new file mode 100644 index 000000000000..b178399ad0da --- /dev/null +++ b/issues/aten_c_kernels/results/aten_add_linalg.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_add(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %subview = memref.subview %arg0[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.addf %out, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addcdiv.mlir b/issues/aten_c_kernels/results/aten_addcdiv.mlir new file mode 100644 index 000000000000..dbd25d883bd9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addcdiv.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addcdiv(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg5 = 0 to 4096 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg1[%arg5] : memref + %2 = arith.mulf %arg3, %1 : f32 + %3 = affine.load %arg2[%arg5] : memref + %4 = arith.divf %2, %3 : f32 + %5 = arith.addf %0, %4 : f32 + affine.store %5, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_addcdiv/debuf.mlir b/issues/aten_c_kernels/results/aten_addcdiv/debuf.mlir new file mode 100644 index 000000000000..d35b49d6c81c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addcdiv/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addcdiv(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.mulf %arg3, %in_0 : f32 + %7 = arith.divf %6, %in_1 : f32 + %8 = arith.addf %in, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addcdiv/matched.mlir b/issues/aten_c_kernels/results/aten_addcdiv/matched.mlir new file mode 100644 index 000000000000..d35b49d6c81c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addcdiv/matched.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addcdiv(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.mulf %arg3, %in_0 : f32 + %7 = arith.divf %6, %in_1 : f32 + %8 = arith.addf %in, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addcdiv/orig.mlir b/issues/aten_c_kernels/results/aten_addcdiv/orig.mlir new file mode 100644 index 000000000000..dbd25d883bd9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addcdiv/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addcdiv(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg5 = 0 to 4096 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg1[%arg5] : memref + %2 = arith.mulf %arg3, %1 : f32 + %3 = affine.load %arg2[%arg5] : memref + %4 = arith.divf %2, %3 : f32 + %5 = arith.addf %0, %4 : f32 + affine.store %5, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_addcdiv/raised.mlir b/issues/aten_c_kernels/results/aten_addcdiv/raised.mlir new file mode 100644 index 000000000000..aea92111effe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addcdiv/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addcdiv(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg2 : memref, memref, memref) outs(%arg4 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.mulf %arg3, %in_0 : f32 + %1 = arith.divf %0, %in_1 : f32 + %2 = arith.addf %in, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addcdiv_debuf.mlir b/issues/aten_c_kernels/results/aten_addcdiv_debuf.mlir new file mode 100644 index 000000000000..d35b49d6c81c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addcdiv_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addcdiv(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.mulf %arg3, %in_0 : f32 + %7 = arith.divf %6, %in_1 : f32 + %8 = arith.addf %in, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addcdiv_linalg.mlir b/issues/aten_c_kernels/results/aten_addcdiv_linalg.mlir new file mode 100644 index 000000000000..aea92111effe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addcdiv_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addcdiv(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg2 : memref, memref, memref) outs(%arg4 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.mulf %arg3, %in_0 : f32 + %1 = arith.divf %0, %in_1 : f32 + %2 = arith.addf %in, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addcmul.mlir b/issues/aten_c_kernels/results/aten_addcmul.mlir new file mode 100644 index 000000000000..63d61f718765 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addcmul.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addcmul(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg5 = 0 to 4096 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg1[%arg5] : memref + %2 = arith.mulf %arg3, %1 : f32 + %3 = affine.load %arg2[%arg5] : memref + %4 = arith.mulf %2, %3 : f32 + %5 = arith.addf %0, %4 : f32 + affine.store %5, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_addcmul/debuf.mlir b/issues/aten_c_kernels/results/aten_addcmul/debuf.mlir new file mode 100644 index 000000000000..773b35cd47df --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addcmul/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addcmul(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.mulf %arg3, %in_0 : f32 + %7 = arith.mulf %6, %in_1 : f32 + %8 = arith.addf %in, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addcmul/matched.mlir b/issues/aten_c_kernels/results/aten_addcmul/matched.mlir new file mode 100644 index 000000000000..773b35cd47df --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addcmul/matched.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addcmul(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.mulf %arg3, %in_0 : f32 + %7 = arith.mulf %6, %in_1 : f32 + %8 = arith.addf %in, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addcmul/orig.mlir b/issues/aten_c_kernels/results/aten_addcmul/orig.mlir new file mode 100644 index 000000000000..63d61f718765 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addcmul/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addcmul(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg5 = 0 to 4096 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg1[%arg5] : memref + %2 = arith.mulf %arg3, %1 : f32 + %3 = affine.load %arg2[%arg5] : memref + %4 = arith.mulf %2, %3 : f32 + %5 = arith.addf %0, %4 : f32 + affine.store %5, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_addcmul/raised.mlir b/issues/aten_c_kernels/results/aten_addcmul/raised.mlir new file mode 100644 index 000000000000..61be895d10e4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addcmul/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addcmul(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg2 : memref, memref, memref) outs(%arg4 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.mulf %arg3, %in_0 : f32 + %1 = arith.mulf %0, %in_1 : f32 + %2 = arith.addf %in, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addcmul_debuf.mlir b/issues/aten_c_kernels/results/aten_addcmul_debuf.mlir new file mode 100644 index 000000000000..773b35cd47df --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addcmul_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addcmul(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.mulf %arg3, %in_0 : f32 + %7 = arith.mulf %6, %in_1 : f32 + %8 = arith.addf %in, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addcmul_linalg.mlir b/issues/aten_c_kernels/results/aten_addcmul_linalg.mlir new file mode 100644 index 000000000000..61be895d10e4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addcmul_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addcmul(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg2 : memref, memref, memref) outs(%arg4 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.mulf %arg3, %in_0 : f32 + %1 = arith.mulf %0, %in_1 : f32 + %2 = arith.addf %in, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addmm.mlir b/issues/aten_c_kernels/results/aten_addmm.mlir new file mode 100644 index 000000000000..ea0d865866b1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addmm.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addmm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f64, %arg4: f64) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 16 { + %0 = affine.load %arg2[%arg5, %arg6] : memref + %1 = arith.mulf %0, %arg3 : f64 + affine.store %1, %arg2[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 16 { + affine.for %arg7 = 0 to 16 { + %0 = affine.load %arg0[%arg5, %arg7] : memref + %1 = arith.mulf %arg4, %0 : f64 + %2 = affine.load %arg1[%arg7, %arg6] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg2[%arg5, %arg6] : memref + %5 = arith.addf %4, %3 : f64 + affine.store %5, %arg2[%arg5, %arg6] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_addmm/debuf.mlir b/issues/aten_c_kernels/results/aten_addmm/debuf.mlir new file mode 100644 index 000000000000..a8bd7c6d799b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addmm/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addmm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f64, %arg4: f64) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + %6 = arith.mulf %out, %arg3 : f64 + linalg.yield %6 : f64 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %6 = arith.mulf %arg4, %in : f64 + %7 = arith.mulf %6, %in_2 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0] [%c16, %c16] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addmm/matched.mlir b/issues/aten_c_kernels/results/aten_addmm/matched.mlir new file mode 100644 index 000000000000..ce2d3bc7938a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addmm/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addmm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f64, %arg4: f64) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %4 = kernel.launch @cublasDgemm(%extracted_slice_0, %extracted_slice_1, %extracted_slice, %arg3, %arg4) : (tensor, tensor, tensor, f64, f64) -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0] [%c16, %c16] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addmm/orig.mlir b/issues/aten_c_kernels/results/aten_addmm/orig.mlir new file mode 100644 index 000000000000..ea0d865866b1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addmm/orig.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addmm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f64, %arg4: f64) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 16 { + %0 = affine.load %arg2[%arg5, %arg6] : memref + %1 = arith.mulf %0, %arg3 : f64 + affine.store %1, %arg2[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 16 { + affine.for %arg7 = 0 to 16 { + %0 = affine.load %arg0[%arg5, %arg7] : memref + %1 = arith.mulf %arg4, %0 : f64 + %2 = affine.load %arg1[%arg7, %arg6] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg2[%arg5, %arg6] : memref + %5 = arith.addf %4, %3 : f64 + affine.store %5, %arg2[%arg5, %arg6] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_addmm/raised.mlir b/issues/aten_c_kernels/results/aten_addmm/raised.mlir new file mode 100644 index 000000000000..4a899f0840ae --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addmm/raised.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addmm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f64, %arg4: f64) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %subview = memref.subview %arg2[0, 0] [%c16, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + %0 = arith.mulf %out, %arg3 : f64 + linalg.yield %0 : f64 + } + %subview_0 = memref.subview %arg0[0, 0] [%c16, %c16] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0] [%c16, %c16] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0] [%c16, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f64, %in_3: f64, %out: f64): + %0 = arith.mulf %arg4, %in : f64 + %1 = arith.mulf %0, %in_3 : f64 + %2 = arith.addf %out, %1 : f64 + linalg.yield %2 : f64 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addmm_debuf.mlir b/issues/aten_c_kernels/results/aten_addmm_debuf.mlir new file mode 100644 index 000000000000..a8bd7c6d799b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addmm_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addmm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f64, %arg4: f64) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + %6 = arith.mulf %out, %arg3 : f64 + linalg.yield %6 : f64 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %6 = arith.mulf %arg4, %in : f64 + %7 = arith.mulf %6, %in_2 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0] [%c16, %c16] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addmm_linalg.mlir b/issues/aten_c_kernels/results/aten_addmm_linalg.mlir new file mode 100644 index 000000000000..4a899f0840ae --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addmm_linalg.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addmm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f64, %arg4: f64) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %subview = memref.subview %arg2[0, 0] [%c16, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + %0 = arith.mulf %out, %arg3 : f64 + linalg.yield %0 : f64 + } + %subview_0 = memref.subview %arg0[0, 0] [%c16, %c16] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0] [%c16, %c16] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0] [%c16, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f64, %in_3: f64, %out: f64): + %0 = arith.mulf %arg4, %in : f64 + %1 = arith.mulf %0, %in_3 : f64 + %2 = arith.addf %out, %1 : f64 + linalg.yield %2 : f64 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addr_elementwise.mlir b/issues/aten_c_kernels/results/aten_addr_elementwise.mlir new file mode 100644 index 000000000000..d78b6f16ffaa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addr_elementwise.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addr_elementwise(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = arith.cmpf oeq, %arg3, %cst : f32 + affine.for %arg6 = 0 to 4096 { + %1 = scf.if %0 -> (f32) { + %2 = affine.load %arg1[%arg6] : memref + %3 = arith.mulf %arg4, %2 : f32 + %4 = affine.load %arg2[%arg6] : memref + %5 = arith.mulf %3, %4 : f32 + scf.yield %5 : f32 + } else { + %2 = affine.load %arg0[%arg6] : memref + %3 = arith.mulf %arg3, %2 : f32 + %4 = affine.load %arg1[%arg6] : memref + %5 = arith.mulf %arg4, %4 : f32 + %6 = affine.load %arg2[%arg6] : memref + %7 = arith.mulf %5, %6 : f32 + %8 = arith.addf %3, %7 : f32 + scf.yield %8 : f32 + } + affine.store %1, %arg5[%arg6] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_addr_elementwise/debuf.mlir b/issues/aten_c_kernels/results/aten_addr_elementwise/debuf.mlir new file mode 100644 index 000000000000..a7d049527569 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addr_elementwise/debuf.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addr_elementwise(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg5 : memref + %4 = arith.cmpf oeq, %arg3, %cst : f32 + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %2, %0, %1, %2 : tensor, tensor, tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %in_2: f32, %in_3: f32, %out: f32): + %7 = arith.mulf %arg4, %in : f32 + %8 = arith.mulf %7, %in_0 : f32 + %9 = arith.mulf %arg3, %in_1 : f32 + %10 = arith.mulf %arg4, %in_2 : f32 + %11 = arith.mulf %10, %in_3 : f32 + %12 = arith.addf %9, %11 : f32 + %13 = arith.select %4, %8, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addr_elementwise/matched.mlir b/issues/aten_c_kernels/results/aten_addr_elementwise/matched.mlir new file mode 100644 index 000000000000..a7d049527569 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addr_elementwise/matched.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addr_elementwise(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg5 : memref + %4 = arith.cmpf oeq, %arg3, %cst : f32 + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %2, %0, %1, %2 : tensor, tensor, tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %in_2: f32, %in_3: f32, %out: f32): + %7 = arith.mulf %arg4, %in : f32 + %8 = arith.mulf %7, %in_0 : f32 + %9 = arith.mulf %arg3, %in_1 : f32 + %10 = arith.mulf %arg4, %in_2 : f32 + %11 = arith.mulf %10, %in_3 : f32 + %12 = arith.addf %9, %11 : f32 + %13 = arith.select %4, %8, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addr_elementwise/orig.mlir b/issues/aten_c_kernels/results/aten_addr_elementwise/orig.mlir new file mode 100644 index 000000000000..d78b6f16ffaa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addr_elementwise/orig.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addr_elementwise(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = arith.cmpf oeq, %arg3, %cst : f32 + affine.for %arg6 = 0 to 4096 { + %1 = scf.if %0 -> (f32) { + %2 = affine.load %arg1[%arg6] : memref + %3 = arith.mulf %arg4, %2 : f32 + %4 = affine.load %arg2[%arg6] : memref + %5 = arith.mulf %3, %4 : f32 + scf.yield %5 : f32 + } else { + %2 = affine.load %arg0[%arg6] : memref + %3 = arith.mulf %arg3, %2 : f32 + %4 = affine.load %arg1[%arg6] : memref + %5 = arith.mulf %arg4, %4 : f32 + %6 = affine.load %arg2[%arg6] : memref + %7 = arith.mulf %5, %6 : f32 + %8 = arith.addf %3, %7 : f32 + scf.yield %8 : f32 + } + affine.store %1, %arg5[%arg6] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_addr_elementwise/raised.mlir b/issues/aten_c_kernels/results/aten_addr_elementwise/raised.mlir new file mode 100644 index 000000000000..32a1d737e58d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addr_elementwise/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addr_elementwise(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = arith.cmpf oeq, %arg3, %cst : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg2, %arg0, %arg1, %arg2 : memref, memref, memref, memref, memref) outs(%arg5 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %in_2: f32, %in_3: f32, %out: f32): + %1 = arith.mulf %arg4, %in : f32 + %2 = arith.mulf %1, %in_0 : f32 + %3 = arith.mulf %arg3, %in_1 : f32 + %4 = arith.mulf %arg4, %in_2 : f32 + %5 = arith.mulf %4, %in_3 : f32 + %6 = arith.addf %3, %5 : f32 + %7 = arith.select %0, %2, %6 : f32 + linalg.yield %7 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addr_elementwise_debuf.mlir b/issues/aten_c_kernels/results/aten_addr_elementwise_debuf.mlir new file mode 100644 index 000000000000..a7d049527569 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addr_elementwise_debuf.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addr_elementwise(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg5 : memref + %4 = arith.cmpf oeq, %arg3, %cst : f32 + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %2, %0, %1, %2 : tensor, tensor, tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %in_2: f32, %in_3: f32, %out: f32): + %7 = arith.mulf %arg4, %in : f32 + %8 = arith.mulf %7, %in_0 : f32 + %9 = arith.mulf %arg3, %in_1 : f32 + %10 = arith.mulf %arg4, %in_2 : f32 + %11 = arith.mulf %10, %in_3 : f32 + %12 = arith.addf %9, %11 : f32 + %13 = arith.select %4, %8, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_addr_elementwise_linalg.mlir b/issues/aten_c_kernels/results/aten_addr_elementwise_linalg.mlir new file mode 100644 index 000000000000..32a1d737e58d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_addr_elementwise_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_addr_elementwise(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = arith.cmpf oeq, %arg3, %cst : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg2, %arg0, %arg1, %arg2 : memref, memref, memref, memref, memref) outs(%arg5 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %in_2: f32, %in_3: f32, %out: f32): + %1 = arith.mulf %arg4, %in : f32 + %2 = arith.mulf %1, %in_0 : f32 + %3 = arith.mulf %arg3, %in_1 : f32 + %4 = arith.mulf %arg4, %in_2 : f32 + %5 = arith.mulf %4, %in_3 : f32 + %6 = arith.addf %3, %5 : f32 + %7 = arith.select %0, %2, %6 : f32 + linalg.yield %7 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_airy_ai.mlir b/issues/aten_c_kernels/results/aten_airy_ai.mlir new file mode 100644 index 000000000000..3b1668d432fa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_airy_ai.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_airy_ai(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_airy_aif(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_airy_aif(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_airy_ai/debuf.mlir b/issues/aten_c_kernels/results/aten_airy_ai/debuf.mlir new file mode 100644 index 000000000000..cc425d1b4d51 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_airy_ai/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_airy_ai(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_airy_aif(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_airy_aif(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_airy_ai/matched.mlir b/issues/aten_c_kernels/results/aten_airy_ai/matched.mlir new file mode 100644 index 000000000000..cc425d1b4d51 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_airy_ai/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_airy_ai(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_airy_aif(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_airy_aif(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_airy_ai/orig.mlir b/issues/aten_c_kernels/results/aten_airy_ai/orig.mlir new file mode 100644 index 000000000000..3b1668d432fa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_airy_ai/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_airy_ai(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_airy_aif(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_airy_aif(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_airy_ai/raised.mlir b/issues/aten_c_kernels/results/aten_airy_ai/raised.mlir new file mode 100644 index 000000000000..05c9e37c7a7c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_airy_ai/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_airy_ai(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_airy_aif(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_airy_aif(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_airy_ai_debuf.mlir b/issues/aten_c_kernels/results/aten_airy_ai_debuf.mlir new file mode 100644 index 000000000000..cc425d1b4d51 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_airy_ai_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_airy_ai(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_airy_aif(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_airy_aif(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_airy_ai_linalg.mlir b/issues/aten_c_kernels/results/aten_airy_ai_linalg.mlir new file mode 100644 index 000000000000..05c9e37c7a7c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_airy_ai_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_airy_ai(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_airy_aif(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_airy_aif(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_allany_dims_cpu.mlir b/issues/aten_c_kernels/results/aten_allany_dims_cpu.mlir new file mode 100644 index 000000000000..fcc879538d34 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_allany_dims_cpu.mlir @@ -0,0 +1,38 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_allany_dims_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %false = arith.constant false + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg1, %c0_i32 : i32 + affine.for %arg3 = 0 to 32 { + %1 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %arg1) -> (i32) { + %2 = scf.if %0 -> (i32) { + %3 = arith.cmpi ne, %arg5, %c0_i32 : i32 + %4 = scf.if %3 -> (i1) { + %6 = affine.load %arg0[%arg3, %arg4] : memref + %7 = arith.cmpi ne, %6, %c0_i32 : i32 + scf.yield %7 : i1 + } else { + scf.yield %false : i1 + } + %5 = arith.extsi %4 : i1 to i32 + scf.yield %5 : i32 + } else { + %3 = arith.cmpi ne, %arg5, %c0_i32 : i32 + %4 = scf.if %3 -> (i1) { + scf.yield %true : i1 + } else { + %6 = affine.load %arg0[%arg3, %arg4] : memref + %7 = arith.cmpi ne, %6, %c0_i32 : i32 + scf.yield %7 : i1 + } + %5 = arith.extsi %4 : i1 to i32 + scf.yield %5 : i32 + } + affine.yield %2 : i32 + } + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_allany_dims_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_allany_dims_cpu/debuf.mlir new file mode 100644 index 000000000000..4c79f5116c80 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_allany_dims_cpu/debuf.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_allany_dims_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %false = arith.constant false + %true = arith.constant true + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.cmpi ne, %arg1, %c0_i32 : i32 + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %arg1 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %6 = arith.cmpi ne, %out, %c0_i32 : i32 + %7 = arith.cmpi ne, %in, %c0_i32 : i32 + %8 = arith.select %6, %7, %false : i1 + %9 = arith.extsi %8 : i1 to i32 + %10 = arith.cmpi ne, %out, %c0_i32 : i32 + %11 = arith.cmpi ne, %in_2, %c0_i32 : i32 + %12 = arith.select %10, %true, %11 : i1 + %13 = arith.extsi %12 : i1 to i32 + %14 = arith.select %2, %9, %13 : i32 + linalg.yield %14 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c32] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_allany_dims_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_allany_dims_cpu/matched.mlir new file mode 100644 index 000000000000..4c79f5116c80 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_allany_dims_cpu/matched.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_allany_dims_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %false = arith.constant false + %true = arith.constant true + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.cmpi ne, %arg1, %c0_i32 : i32 + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %arg1 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %6 = arith.cmpi ne, %out, %c0_i32 : i32 + %7 = arith.cmpi ne, %in, %c0_i32 : i32 + %8 = arith.select %6, %7, %false : i1 + %9 = arith.extsi %8 : i1 to i32 + %10 = arith.cmpi ne, %out, %c0_i32 : i32 + %11 = arith.cmpi ne, %in_2, %c0_i32 : i32 + %12 = arith.select %10, %true, %11 : i1 + %13 = arith.extsi %12 : i1 to i32 + %14 = arith.select %2, %9, %13 : i32 + linalg.yield %14 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c32] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_allany_dims_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_allany_dims_cpu/orig.mlir new file mode 100644 index 000000000000..fcc879538d34 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_allany_dims_cpu/orig.mlir @@ -0,0 +1,38 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_allany_dims_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %false = arith.constant false + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg1, %c0_i32 : i32 + affine.for %arg3 = 0 to 32 { + %1 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %arg1) -> (i32) { + %2 = scf.if %0 -> (i32) { + %3 = arith.cmpi ne, %arg5, %c0_i32 : i32 + %4 = scf.if %3 -> (i1) { + %6 = affine.load %arg0[%arg3, %arg4] : memref + %7 = arith.cmpi ne, %6, %c0_i32 : i32 + scf.yield %7 : i1 + } else { + scf.yield %false : i1 + } + %5 = arith.extsi %4 : i1 to i32 + scf.yield %5 : i32 + } else { + %3 = arith.cmpi ne, %arg5, %c0_i32 : i32 + %4 = scf.if %3 -> (i1) { + scf.yield %true : i1 + } else { + %6 = affine.load %arg0[%arg3, %arg4] : memref + %7 = arith.cmpi ne, %6, %c0_i32 : i32 + scf.yield %7 : i1 + } + %5 = arith.extsi %4 : i1 to i32 + scf.yield %5 : i32 + } + affine.yield %2 : i32 + } + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_allany_dims_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_allany_dims_cpu/raised.mlir new file mode 100644 index 000000000000..d3d71cb113c3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_allany_dims_cpu/raised.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_allany_dims_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %true = arith.constant true + %false = arith.constant false + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg1, %c0_i32 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: i32): + linalg.yield %arg1 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %1 = arith.cmpi ne, %out, %c0_i32 : i32 + %2 = arith.cmpi ne, %in, %c0_i32 : i32 + %3 = arith.select %1, %2, %false : i1 + %4 = arith.extsi %3 : i1 to i32 + %5 = arith.cmpi ne, %out, %c0_i32 : i32 + %6 = arith.cmpi ne, %in_2, %c0_i32 : i32 + %7 = arith.select %5, %true, %6 : i1 + %8 = arith.extsi %7 : i1 to i32 + %9 = arith.select %0, %4, %8 : i32 + linalg.yield %9 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_allany_dims_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_allany_dims_cpu_debuf.mlir new file mode 100644 index 000000000000..4c79f5116c80 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_allany_dims_cpu_debuf.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_allany_dims_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %false = arith.constant false + %true = arith.constant true + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.cmpi ne, %arg1, %c0_i32 : i32 + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %arg1 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %6 = arith.cmpi ne, %out, %c0_i32 : i32 + %7 = arith.cmpi ne, %in, %c0_i32 : i32 + %8 = arith.select %6, %7, %false : i1 + %9 = arith.extsi %8 : i1 to i32 + %10 = arith.cmpi ne, %out, %c0_i32 : i32 + %11 = arith.cmpi ne, %in_2, %c0_i32 : i32 + %12 = arith.select %10, %true, %11 : i1 + %13 = arith.extsi %12 : i1 to i32 + %14 = arith.select %2, %9, %13 : i32 + linalg.yield %14 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c32] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_allany_dims_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_allany_dims_cpu_linalg.mlir new file mode 100644 index 000000000000..d3d71cb113c3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_allany_dims_cpu_linalg.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_allany_dims_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %true = arith.constant true + %false = arith.constant false + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg1, %c0_i32 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: i32): + linalg.yield %arg1 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %1 = arith.cmpi ne, %out, %c0_i32 : i32 + %2 = arith.cmpi ne, %in, %c0_i32 : i32 + %3 = arith.select %1, %2, %false : i1 + %4 = arith.extsi %3 : i1 to i32 + %5 = arith.cmpi ne, %out, %c0_i32 : i32 + %6 = arith.cmpi ne, %in_2, %c0_i32 : i32 + %7 = arith.select %5, %true, %6 : i1 + %8 = arith.extsi %7 : i1 to i32 + %9 = arith.select %0, %4, %8 : i32 + linalg.yield %9 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu.mlir b/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu.mlir new file mode 100644 index 000000000000..89eafd23db7c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_aminmax_allreduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = affine.load %arg0[0] : memref + %1:2 = affine.for %arg3 = 1 to 4096 iter_args(%arg4 = %0, %arg5 = %0) -> (f32, f32) { + %2 = affine.load %arg0[%arg3] : memref + %3 = arith.cmpf olt, %2, %arg5 : f32 + %4 = arith.select %3, %2, %arg5 : f32 + %5 = arith.cmpf ogt, %2, %arg4 : f32 + %6 = arith.select %5, %2, %arg4 : f32 + affine.yield %6, %4 : f32, f32 + } + affine.store %1#1, %arg1[0] : memref + affine.store %1#0, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu/debuf.mlir new file mode 100644 index 000000000000..1a234d45d476 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu/debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_aminmax_allreduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted = tensor.extract %0[%c0] : tensor + %3 = tensor.empty() : tensor + %inserted = tensor.insert %extracted into %3[] : tensor + %4 = tensor.empty() : tensor + %inserted_0 = tensor.insert %extracted into %4[] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %5:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted, %inserted_0 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_5: f32): + %8 = arith.cmpf olt, %in, %out_5 : f32 + %9 = arith.select %8, %in, %out_5 : f32 + %10 = arith.cmpf ogt, %in, %out : f32 + %11 = arith.select %10, %in, %out : f32 + linalg.yield %11, %9 : f32, f32 + } -> (tensor, tensor) + %extracted_1 = tensor.extract %5#0[] : tensor + %extracted_2 = tensor.extract %5#1[] : tensor + %inserted_3 = tensor.insert %extracted_2 into %1[%c0] : tensor + %6 = bufferization.to_memref %inserted_3 : memref + memref.copy %6, %arg1 : memref to memref + %inserted_4 = tensor.insert %extracted_1 into %2[%c0] : tensor + %7 = bufferization.to_memref %inserted_4 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu/matched.mlir new file mode 100644 index 000000000000..1a234d45d476 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu/matched.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_aminmax_allreduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted = tensor.extract %0[%c0] : tensor + %3 = tensor.empty() : tensor + %inserted = tensor.insert %extracted into %3[] : tensor + %4 = tensor.empty() : tensor + %inserted_0 = tensor.insert %extracted into %4[] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %5:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted, %inserted_0 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_5: f32): + %8 = arith.cmpf olt, %in, %out_5 : f32 + %9 = arith.select %8, %in, %out_5 : f32 + %10 = arith.cmpf ogt, %in, %out : f32 + %11 = arith.select %10, %in, %out : f32 + linalg.yield %11, %9 : f32, f32 + } -> (tensor, tensor) + %extracted_1 = tensor.extract %5#0[] : tensor + %extracted_2 = tensor.extract %5#1[] : tensor + %inserted_3 = tensor.insert %extracted_2 into %1[%c0] : tensor + %6 = bufferization.to_memref %inserted_3 : memref + memref.copy %6, %arg1 : memref to memref + %inserted_4 = tensor.insert %extracted_1 into %2[%c0] : tensor + %7 = bufferization.to_memref %inserted_4 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu/orig.mlir new file mode 100644 index 000000000000..89eafd23db7c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu/orig.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_aminmax_allreduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = affine.load %arg0[0] : memref + %1:2 = affine.for %arg3 = 1 to 4096 iter_args(%arg4 = %0, %arg5 = %0) -> (f32, f32) { + %2 = affine.load %arg0[%arg3] : memref + %3 = arith.cmpf olt, %2, %arg5 : f32 + %4 = arith.select %3, %2, %arg5 : f32 + %5 = arith.cmpf ogt, %2, %arg4 : f32 + %6 = arith.select %5, %2, %arg4 : f32 + affine.yield %6, %4 : f32, f32 + } + affine.store %1#1, %arg1[0] : memref + affine.store %1#0, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu/raised.mlir new file mode 100644 index 000000000000..2c5a30279aa8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu/raised.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_aminmax_allreduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %0 = affine.load %arg0[0] : memref + %alloca = memref.alloca() : memref + affine.store %0, %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %0, %alloca_0[] : memref + %subview = memref.subview %arg0[1] [%c4095] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca, %alloca_0 : memref, memref) { + ^bb0(%in: f32, %out: f32, %out_1: f32): + %3 = arith.cmpf olt, %in, %out_1 : f32 + %4 = arith.select %3, %in, %out_1 : f32 + %5 = arith.cmpf ogt, %in, %out : f32 + %6 = arith.select %5, %in, %out : f32 + linalg.yield %6, %4 : f32, f32 + } + %1 = affine.load %alloca[] : memref + %2 = affine.load %alloca_0[] : memref + affine.store %2, %arg1[0] : memref + affine.store %1, %arg2[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu_debuf.mlir new file mode 100644 index 000000000000..1a234d45d476 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu_debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_aminmax_allreduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted = tensor.extract %0[%c0] : tensor + %3 = tensor.empty() : tensor + %inserted = tensor.insert %extracted into %3[] : tensor + %4 = tensor.empty() : tensor + %inserted_0 = tensor.insert %extracted into %4[] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %5:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted, %inserted_0 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_5: f32): + %8 = arith.cmpf olt, %in, %out_5 : f32 + %9 = arith.select %8, %in, %out_5 : f32 + %10 = arith.cmpf ogt, %in, %out : f32 + %11 = arith.select %10, %in, %out : f32 + linalg.yield %11, %9 : f32, f32 + } -> (tensor, tensor) + %extracted_1 = tensor.extract %5#0[] : tensor + %extracted_2 = tensor.extract %5#1[] : tensor + %inserted_3 = tensor.insert %extracted_2 into %1[%c0] : tensor + %6 = bufferization.to_memref %inserted_3 : memref + memref.copy %6, %arg1 : memref to memref + %inserted_4 = tensor.insert %extracted_1 into %2[%c0] : tensor + %7 = bufferization.to_memref %inserted_4 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu_linalg.mlir new file mode 100644 index 000000000000..2c5a30279aa8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_aminmax_allreduce_cpu_linalg.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_aminmax_allreduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %0 = affine.load %arg0[0] : memref + %alloca = memref.alloca() : memref + affine.store %0, %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %0, %alloca_0[] : memref + %subview = memref.subview %arg0[1] [%c4095] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca, %alloca_0 : memref, memref) { + ^bb0(%in: f32, %out: f32, %out_1: f32): + %3 = arith.cmpf olt, %in, %out_1 : f32 + %4 = arith.select %3, %in, %out_1 : f32 + %5 = arith.cmpf ogt, %in, %out : f32 + %6 = arith.select %5, %in, %out : f32 + linalg.yield %6, %4 : f32, f32 + } + %1 = affine.load %alloca[] : memref + %2 = affine.load %alloca_0[] : memref + affine.store %2, %arg1[0] : memref + affine.store %1, %arg2[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_aminmax_cpu.mlir b/issues/aten_c_kernels/results/aten_aminmax_cpu.mlir new file mode 100644 index 000000000000..58630cc83fc4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_aminmax_cpu.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_aminmax_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %0, %alloca_0[] : memref + %1 = affine.load %arg0[0] : memref + affine.store %1, %alloca_0[] : memref + %2 = affine.load %arg0[0] : memref + affine.store %2, %alloca[] : memref + affine.for %arg3 = 1 to 4096 { + %5 = affine.load %arg0[%arg3] : memref + %6 = affine.load %alloca_0[] : memref + %7 = arith.cmpf olt, %5, %6 : f32 + %8 = arith.select %7, %5, %6 : f32 + affine.store %8, %alloca_0[] : memref + %9 = affine.load %arg0[%arg3] : memref + %10 = affine.load %alloca[] : memref + %11 = arith.cmpf ogt, %9, %10 : f32 + %12 = arith.select %11, %9, %10 : f32 + affine.store %12, %alloca[] : memref + } + %3 = affine.load %alloca_0[] : memref + affine.store %3, %arg1[0] : memref + %4 = affine.load %alloca[] : memref + affine.store %4, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_aminmax_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_aminmax_cpu/debuf.mlir new file mode 100644 index 000000000000..ae64f1abc08e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_aminmax_cpu/debuf.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_aminmax_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = tensor.empty() : tensor + %4 = llvm.mlir.undef : f32 + %inserted = tensor.insert %4 into %3[] : tensor + %5 = tensor.empty() : tensor + %inserted_0 = tensor.insert %4 into %5[] : tensor + %extracted = tensor.extract %0[%c0] : tensor + %inserted_1 = tensor.insert %extracted into %inserted_0[] : tensor + %extracted_2 = tensor.extract %0[%c0] : tensor + %inserted_3 = tensor.insert %extracted_2 into %inserted[] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted_1 : tensor) { + ^bb0(%in: f32, %out: f32): + %10 = arith.cmpf olt, %in, %out : f32 + %11 = arith.select %10, %in, %out : f32 + linalg.yield %11 : f32 + } -> tensor + %extracted_slice_4 = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_4 : tensor) outs(%inserted_3 : tensor) { + ^bb0(%in: f32, %out: f32): + %10 = arith.cmpf ogt, %in, %out : f32 + %11 = arith.select %10, %in, %out : f32 + linalg.yield %11 : f32 + } -> tensor + %extracted_5 = tensor.extract %6[] : tensor + %inserted_6 = tensor.insert %extracted_5 into %1[%c0] : tensor + %8 = bufferization.to_memref %inserted_6 : memref + memref.copy %8, %arg1 : memref to memref + %extracted_7 = tensor.extract %7[] : tensor + %inserted_8 = tensor.insert %extracted_7 into %2[%c0] : tensor + %9 = bufferization.to_memref %inserted_8 : memref + memref.copy %9, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_aminmax_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_aminmax_cpu/matched.mlir new file mode 100644 index 000000000000..ae64f1abc08e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_aminmax_cpu/matched.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_aminmax_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = tensor.empty() : tensor + %4 = llvm.mlir.undef : f32 + %inserted = tensor.insert %4 into %3[] : tensor + %5 = tensor.empty() : tensor + %inserted_0 = tensor.insert %4 into %5[] : tensor + %extracted = tensor.extract %0[%c0] : tensor + %inserted_1 = tensor.insert %extracted into %inserted_0[] : tensor + %extracted_2 = tensor.extract %0[%c0] : tensor + %inserted_3 = tensor.insert %extracted_2 into %inserted[] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted_1 : tensor) { + ^bb0(%in: f32, %out: f32): + %10 = arith.cmpf olt, %in, %out : f32 + %11 = arith.select %10, %in, %out : f32 + linalg.yield %11 : f32 + } -> tensor + %extracted_slice_4 = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_4 : tensor) outs(%inserted_3 : tensor) { + ^bb0(%in: f32, %out: f32): + %10 = arith.cmpf ogt, %in, %out : f32 + %11 = arith.select %10, %in, %out : f32 + linalg.yield %11 : f32 + } -> tensor + %extracted_5 = tensor.extract %6[] : tensor + %inserted_6 = tensor.insert %extracted_5 into %1[%c0] : tensor + %8 = bufferization.to_memref %inserted_6 : memref + memref.copy %8, %arg1 : memref to memref + %extracted_7 = tensor.extract %7[] : tensor + %inserted_8 = tensor.insert %extracted_7 into %2[%c0] : tensor + %9 = bufferization.to_memref %inserted_8 : memref + memref.copy %9, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_aminmax_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_aminmax_cpu/orig.mlir new file mode 100644 index 000000000000..58630cc83fc4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_aminmax_cpu/orig.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_aminmax_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %0, %alloca_0[] : memref + %1 = affine.load %arg0[0] : memref + affine.store %1, %alloca_0[] : memref + %2 = affine.load %arg0[0] : memref + affine.store %2, %alloca[] : memref + affine.for %arg3 = 1 to 4096 { + %5 = affine.load %arg0[%arg3] : memref + %6 = affine.load %alloca_0[] : memref + %7 = arith.cmpf olt, %5, %6 : f32 + %8 = arith.select %7, %5, %6 : f32 + affine.store %8, %alloca_0[] : memref + %9 = affine.load %arg0[%arg3] : memref + %10 = affine.load %alloca[] : memref + %11 = arith.cmpf ogt, %9, %10 : f32 + %12 = arith.select %11, %9, %10 : f32 + affine.store %12, %alloca[] : memref + } + %3 = affine.load %alloca_0[] : memref + affine.store %3, %arg1[0] : memref + %4 = affine.load %alloca[] : memref + affine.store %4, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_aminmax_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_aminmax_cpu/raised.mlir new file mode 100644 index 000000000000..589ee3778a12 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_aminmax_cpu/raised.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_aminmax_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %0, %alloca_0[] : memref + %1 = affine.load %arg0[0] : memref + affine.store %1, %alloca_0[] : memref + %2 = affine.load %arg0[0] : memref + affine.store %2, %alloca[] : memref + %subview = memref.subview %arg0[1] [%c4095] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca_0 : memref) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %out : f32 + %6 = arith.select %5, %in, %out : f32 + linalg.yield %6 : f32 + } + %subview_1 = memref.subview %arg0[1] [%c4095] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview_1 : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %out : f32 + %6 = arith.select %5, %in, %out : f32 + linalg.yield %6 : f32 + } + %3 = affine.load %alloca_0[] : memref + affine.store %3, %arg1[0] : memref + %4 = affine.load %alloca[] : memref + affine.store %4, %arg2[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_aminmax_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_aminmax_cpu_debuf.mlir new file mode 100644 index 000000000000..ae64f1abc08e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_aminmax_cpu_debuf.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_aminmax_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = tensor.empty() : tensor + %4 = llvm.mlir.undef : f32 + %inserted = tensor.insert %4 into %3[] : tensor + %5 = tensor.empty() : tensor + %inserted_0 = tensor.insert %4 into %5[] : tensor + %extracted = tensor.extract %0[%c0] : tensor + %inserted_1 = tensor.insert %extracted into %inserted_0[] : tensor + %extracted_2 = tensor.extract %0[%c0] : tensor + %inserted_3 = tensor.insert %extracted_2 into %inserted[] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted_1 : tensor) { + ^bb0(%in: f32, %out: f32): + %10 = arith.cmpf olt, %in, %out : f32 + %11 = arith.select %10, %in, %out : f32 + linalg.yield %11 : f32 + } -> tensor + %extracted_slice_4 = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_4 : tensor) outs(%inserted_3 : tensor) { + ^bb0(%in: f32, %out: f32): + %10 = arith.cmpf ogt, %in, %out : f32 + %11 = arith.select %10, %in, %out : f32 + linalg.yield %11 : f32 + } -> tensor + %extracted_5 = tensor.extract %6[] : tensor + %inserted_6 = tensor.insert %extracted_5 into %1[%c0] : tensor + %8 = bufferization.to_memref %inserted_6 : memref + memref.copy %8, %arg1 : memref to memref + %extracted_7 = tensor.extract %7[] : tensor + %inserted_8 = tensor.insert %extracted_7 into %2[%c0] : tensor + %9 = bufferization.to_memref %inserted_8 : memref + memref.copy %9, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_aminmax_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_aminmax_cpu_linalg.mlir new file mode 100644 index 000000000000..589ee3778a12 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_aminmax_cpu_linalg.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_aminmax_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %0, %alloca_0[] : memref + %1 = affine.load %arg0[0] : memref + affine.store %1, %alloca_0[] : memref + %2 = affine.load %arg0[0] : memref + affine.store %2, %alloca[] : memref + %subview = memref.subview %arg0[1] [%c4095] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca_0 : memref) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %out : f32 + %6 = arith.select %5, %in, %out : f32 + linalg.yield %6 : f32 + } + %subview_1 = memref.subview %arg0[1] [%c4095] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview_1 : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %out : f32 + %6 = arith.select %5, %in, %out : f32 + linalg.yield %6 : f32 + } + %3 = affine.load %alloca_0[] : memref + affine.store %3, %arg1[0] : memref + %4 = affine.load %alloca[] : memref + affine.store %4, %arg2[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_amp_update_scale_cpu.mlir b/issues/aten_c_kernels/results/aten_amp_update_scale_cpu.mlir new file mode 100644 index 000000000000..701dab0b01dc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_amp_update_scale_cpu.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_amp_update_scale_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: i32) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.load %arg2[0] : memref + %1 = arith.cmpf une, %0, %cst : f32 + scf.if %1 { + %2 = affine.load %arg0[0] : memref + %3 = arith.mulf %2, %arg4 : f32 + affine.store %3, %arg0[0] : memref + affine.store %c0_i32, %arg1[0] : memref + } else { + %2 = affine.load %arg1[0] : memref + %3 = arith.addi %2, %c1_i32 : i32 + %4 = arith.cmpi eq, %3, %arg5 : i32 + scf.if %4 { + %5 = affine.load %arg0[0] : memref + %6 = arith.mulf %5, %arg3 : f32 + affine.store %6, %arg0[0] : memref + affine.store %c0_i32, %arg1[0] : memref + } else { + affine.store %3, %arg1[0] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_amp_update_scale_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_amp_update_scale_cpu/debuf.mlir new file mode 100644 index 000000000000..b3ec070516b7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_amp_update_scale_cpu/debuf.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_amp_update_scale_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted = tensor.extract %0[%c0] : tensor + %3 = arith.cmpf une, %extracted, %cst : f32 + %4:2 = scf.if %3 -> (tensor, tensor) { + %extracted_0 = tensor.extract %2[%c0] : tensor + %7 = arith.mulf %extracted_0, %arg4 : f32 + %inserted = tensor.insert %7 into %2[%c0] : tensor + %inserted_1 = tensor.insert %c0_i32 into %1[%c0] : tensor + scf.yield %inserted, %inserted_1 : tensor, tensor + } else { + %extracted_0 = tensor.extract %1[%c0] : tensor + %7 = arith.addi %extracted_0, %c1_i32 : i32 + %8 = arith.cmpi eq, %7, %arg5 : i32 + %9:2 = scf.if %8 -> (tensor, tensor) { + %extracted_1 = tensor.extract %2[%c0] : tensor + %10 = arith.mulf %extracted_1, %arg3 : f32 + %inserted = tensor.insert %10 into %2[%c0] : tensor + %inserted_2 = tensor.insert %c0_i32 into %1[%c0] : tensor + scf.yield %inserted, %inserted_2 : tensor, tensor + } else { + %inserted = tensor.insert %7 into %1[%c0] : tensor + scf.yield %2, %inserted : tensor, tensor + } + scf.yield %9#0, %9#1 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg1 : memref to memref + %6 = bufferization.to_memref %4#0 : memref + memref.copy %6, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_amp_update_scale_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_amp_update_scale_cpu/matched.mlir new file mode 100644 index 000000000000..b3ec070516b7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_amp_update_scale_cpu/matched.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_amp_update_scale_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted = tensor.extract %0[%c0] : tensor + %3 = arith.cmpf une, %extracted, %cst : f32 + %4:2 = scf.if %3 -> (tensor, tensor) { + %extracted_0 = tensor.extract %2[%c0] : tensor + %7 = arith.mulf %extracted_0, %arg4 : f32 + %inserted = tensor.insert %7 into %2[%c0] : tensor + %inserted_1 = tensor.insert %c0_i32 into %1[%c0] : tensor + scf.yield %inserted, %inserted_1 : tensor, tensor + } else { + %extracted_0 = tensor.extract %1[%c0] : tensor + %7 = arith.addi %extracted_0, %c1_i32 : i32 + %8 = arith.cmpi eq, %7, %arg5 : i32 + %9:2 = scf.if %8 -> (tensor, tensor) { + %extracted_1 = tensor.extract %2[%c0] : tensor + %10 = arith.mulf %extracted_1, %arg3 : f32 + %inserted = tensor.insert %10 into %2[%c0] : tensor + %inserted_2 = tensor.insert %c0_i32 into %1[%c0] : tensor + scf.yield %inserted, %inserted_2 : tensor, tensor + } else { + %inserted = tensor.insert %7 into %1[%c0] : tensor + scf.yield %2, %inserted : tensor, tensor + } + scf.yield %9#0, %9#1 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg1 : memref to memref + %6 = bufferization.to_memref %4#0 : memref + memref.copy %6, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_amp_update_scale_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_amp_update_scale_cpu/orig.mlir new file mode 100644 index 000000000000..701dab0b01dc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_amp_update_scale_cpu/orig.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_amp_update_scale_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: i32) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.load %arg2[0] : memref + %1 = arith.cmpf une, %0, %cst : f32 + scf.if %1 { + %2 = affine.load %arg0[0] : memref + %3 = arith.mulf %2, %arg4 : f32 + affine.store %3, %arg0[0] : memref + affine.store %c0_i32, %arg1[0] : memref + } else { + %2 = affine.load %arg1[0] : memref + %3 = arith.addi %2, %c1_i32 : i32 + %4 = arith.cmpi eq, %3, %arg5 : i32 + scf.if %4 { + %5 = affine.load %arg0[0] : memref + %6 = arith.mulf %5, %arg3 : f32 + affine.store %6, %arg0[0] : memref + affine.store %c0_i32, %arg1[0] : memref + } else { + affine.store %3, %arg1[0] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_amp_update_scale_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_amp_update_scale_cpu/raised.mlir new file mode 100644 index 000000000000..28758334aed4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_amp_update_scale_cpu/raised.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_amp_update_scale_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: i32) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.load %arg2[0] : memref + %1 = arith.cmpf une, %0, %cst : f32 + scf.if %1 { + %2 = affine.load %arg0[0] : memref + %3 = arith.mulf %2, %arg4 : f32 + affine.store %3, %arg0[0] : memref + affine.store %c0_i32, %arg1[0] : memref + } else { + %2 = affine.load %arg1[0] : memref + %3 = arith.addi %2, %c1_i32 : i32 + %4 = arith.cmpi eq, %3, %arg5 : i32 + scf.if %4 { + %5 = affine.load %arg0[0] : memref + %6 = arith.mulf %5, %arg3 : f32 + affine.store %6, %arg0[0] : memref + affine.store %c0_i32, %arg1[0] : memref + } else { + affine.store %3, %arg1[0] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_amp_update_scale_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_amp_update_scale_cpu_debuf.mlir new file mode 100644 index 000000000000..b3ec070516b7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_amp_update_scale_cpu_debuf.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_amp_update_scale_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted = tensor.extract %0[%c0] : tensor + %3 = arith.cmpf une, %extracted, %cst : f32 + %4:2 = scf.if %3 -> (tensor, tensor) { + %extracted_0 = tensor.extract %2[%c0] : tensor + %7 = arith.mulf %extracted_0, %arg4 : f32 + %inserted = tensor.insert %7 into %2[%c0] : tensor + %inserted_1 = tensor.insert %c0_i32 into %1[%c0] : tensor + scf.yield %inserted, %inserted_1 : tensor, tensor + } else { + %extracted_0 = tensor.extract %1[%c0] : tensor + %7 = arith.addi %extracted_0, %c1_i32 : i32 + %8 = arith.cmpi eq, %7, %arg5 : i32 + %9:2 = scf.if %8 -> (tensor, tensor) { + %extracted_1 = tensor.extract %2[%c0] : tensor + %10 = arith.mulf %extracted_1, %arg3 : f32 + %inserted = tensor.insert %10 into %2[%c0] : tensor + %inserted_2 = tensor.insert %c0_i32 into %1[%c0] : tensor + scf.yield %inserted, %inserted_2 : tensor, tensor + } else { + %inserted = tensor.insert %7 into %1[%c0] : tensor + scf.yield %2, %inserted : tensor, tensor + } + scf.yield %9#0, %9#1 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg1 : memref to memref + %6 = bufferization.to_memref %4#0 : memref + memref.copy %6, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_amp_update_scale_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_amp_update_scale_cpu_linalg.mlir new file mode 100644 index 000000000000..28758334aed4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_amp_update_scale_cpu_linalg.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_amp_update_scale_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: i32) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.load %arg2[0] : memref + %1 = arith.cmpf une, %0, %cst : f32 + scf.if %1 { + %2 = affine.load %arg0[0] : memref + %3 = arith.mulf %2, %arg4 : f32 + affine.store %3, %arg0[0] : memref + affine.store %c0_i32, %arg1[0] : memref + } else { + %2 = affine.load %arg1[0] : memref + %3 = arith.addi %2, %c1_i32 : i32 + %4 = arith.cmpi eq, %3, %arg5 : i32 + scf.if %4 { + %5 = affine.load %arg0[0] : memref + %6 = arith.mulf %5, %arg3 : f32 + affine.store %6, %arg0[0] : memref + affine.store %c0_i32, %arg1[0] : memref + } else { + affine.store %3, %arg1[0] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_and_reduce_cpu.mlir b/issues/aten_c_kernels/results/aten_and_reduce_cpu.mlir new file mode 100644 index 000000000000..101f945bec9e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_and_reduce_cpu.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_and_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 32 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %c1_i32) -> (i32) { + %1 = arith.cmpi ne, %arg4, %c0_i32 : i32 + %2 = scf.if %1 -> (i1) { + %4 = affine.load %arg0[%arg2, %arg3] : memref + %5 = arith.cmpi ne, %4, %c0_i32 : i32 + scf.yield %5 : i1 + } else { + scf.yield %false : i1 + } + %3 = arith.extsi %2 : i1 to i32 + affine.yield %3 : i32 + } + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_and_reduce_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_and_reduce_cpu/debuf.mlir new file mode 100644 index 000000000000..c6efbc5b1ad0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_and_reduce_cpu/debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_and_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %c1_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.cmpi ne, %out, %c0_i32 : i32 + %6 = arith.cmpi ne, %in, %c0_i32 : i32 + %7 = arith.select %5, %6, %false : i1 + %8 = arith.extsi %7 : i1 to i32 + linalg.yield %8 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_and_reduce_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_and_reduce_cpu/matched.mlir new file mode 100644 index 000000000000..c6efbc5b1ad0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_and_reduce_cpu/matched.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_and_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %c1_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.cmpi ne, %out, %c0_i32 : i32 + %6 = arith.cmpi ne, %in, %c0_i32 : i32 + %7 = arith.select %5, %6, %false : i1 + %8 = arith.extsi %7 : i1 to i32 + linalg.yield %8 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_and_reduce_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_and_reduce_cpu/orig.mlir new file mode 100644 index 000000000000..101f945bec9e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_and_reduce_cpu/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_and_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 32 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %c1_i32) -> (i32) { + %1 = arith.cmpi ne, %arg4, %c0_i32 : i32 + %2 = scf.if %1 -> (i1) { + %4 = affine.load %arg0[%arg2, %arg3] : memref + %5 = arith.cmpi ne, %4, %c0_i32 : i32 + scf.yield %5 : i1 + } else { + scf.yield %false : i1 + } + %3 = arith.extsi %2 : i1 to i32 + affine.yield %3 : i32 + } + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_and_reduce_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_and_reduce_cpu/raised.mlir new file mode 100644 index 000000000000..5ba97707e6e3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_and_reduce_cpu/raised.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_and_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: i32): + linalg.yield %c1_i32 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: i32, %out: i32): + %0 = arith.cmpi ne, %out, %c0_i32 : i32 + %1 = arith.cmpi ne, %in, %c0_i32 : i32 + %2 = arith.select %0, %1, %false : i1 + %3 = arith.extsi %2 : i1 to i32 + linalg.yield %3 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_and_reduce_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_and_reduce_cpu_debuf.mlir new file mode 100644 index 000000000000..c6efbc5b1ad0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_and_reduce_cpu_debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_and_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %c1_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.cmpi ne, %out, %c0_i32 : i32 + %6 = arith.cmpi ne, %in, %c0_i32 : i32 + %7 = arith.select %5, %6, %false : i1 + %8 = arith.extsi %7 : i1 to i32 + linalg.yield %8 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_and_reduce_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_and_reduce_cpu_linalg.mlir new file mode 100644 index 000000000000..5ba97707e6e3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_and_reduce_cpu_linalg.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_and_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: i32): + linalg.yield %c1_i32 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: i32, %out: i32): + %0 = arith.cmpi ne, %out, %c0_i32 : i32 + %1 = arith.cmpi ne, %in, %c0_i32 : i32 + %2 = arith.select %0, %1, %false : i1 + %3 = arith.extsi %2 : i1 to i32 + linalg.yield %3 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_angle_complex_scalarized.mlir b/issues/aten_c_kernels/results/aten_angle_complex_scalarized.mlir new file mode 100644 index 000000000000..fe645f2fa872 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_angle_complex_scalarized.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_angle_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg1[%arg3] : memref + %1 = affine.load %arg0[%arg3] : memref + %2 = func.call @atan2f(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @atan2f(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_angle_complex_scalarized/debuf.mlir b/issues/aten_c_kernels/results/aten_angle_complex_scalarized/debuf.mlir new file mode 100644 index 000000000000..35382d753e3c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_angle_complex_scalarized/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_angle_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = math.atan2 %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @atan2f(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_angle_complex_scalarized/matched.mlir b/issues/aten_c_kernels/results/aten_angle_complex_scalarized/matched.mlir new file mode 100644 index 000000000000..35382d753e3c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_angle_complex_scalarized/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_angle_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = math.atan2 %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @atan2f(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_angle_complex_scalarized/orig.mlir b/issues/aten_c_kernels/results/aten_angle_complex_scalarized/orig.mlir new file mode 100644 index 000000000000..fe645f2fa872 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_angle_complex_scalarized/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_angle_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg1[%arg3] : memref + %1 = affine.load %arg0[%arg3] : memref + %2 = func.call @atan2f(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @atan2f(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_angle_complex_scalarized/raised.mlir b/issues/aten_c_kernels/results/aten_angle_complex_scalarized/raised.mlir new file mode 100644 index 000000000000..6ad1dfbdb8d2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_angle_complex_scalarized/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_angle_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = math.atan2 %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @atan2f(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_angle_complex_scalarized_debuf.mlir b/issues/aten_c_kernels/results/aten_angle_complex_scalarized_debuf.mlir new file mode 100644 index 000000000000..35382d753e3c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_angle_complex_scalarized_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_angle_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = math.atan2 %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @atan2f(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_angle_complex_scalarized_linalg.mlir b/issues/aten_c_kernels/results/aten_angle_complex_scalarized_linalg.mlir new file mode 100644 index 000000000000..6ad1dfbdb8d2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_angle_complex_scalarized_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_angle_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = math.atan2 %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @atan2f(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_angle_real.mlir b/issues/aten_c_kernels/results/aten_angle_real.mlir new file mode 100644 index 000000000000..ae5d06089f1e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_angle_real.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_angle_real(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.14159274 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.cmpf olt, %0, %cst_0 : f32 + %2 = arith.select %1, %cst, %cst_0 : f32 + affine.store %2, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_angle_real/debuf.mlir b/issues/aten_c_kernels/results/aten_angle_real/debuf.mlir new file mode 100644 index 000000000000..c0ea4dc60ca3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_angle_real/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_angle_real(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 3.14159274 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %cst : f32 + %5 = arith.select %4, %cst_0, %cst : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_angle_real/matched.mlir b/issues/aten_c_kernels/results/aten_angle_real/matched.mlir new file mode 100644 index 000000000000..c0ea4dc60ca3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_angle_real/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_angle_real(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 3.14159274 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %cst : f32 + %5 = arith.select %4, %cst_0, %cst : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_angle_real/orig.mlir b/issues/aten_c_kernels/results/aten_angle_real/orig.mlir new file mode 100644 index 000000000000..ae5d06089f1e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_angle_real/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_angle_real(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.14159274 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.cmpf olt, %0, %cst_0 : f32 + %2 = arith.select %1, %cst, %cst_0 : f32 + affine.store %2, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_angle_real/raised.mlir b/issues/aten_c_kernels/results/aten_angle_real/raised.mlir new file mode 100644 index 000000000000..83b24d9cea17 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_angle_real/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_angle_real(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.14159274 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %cst_0 : f32 + %1 = arith.select %0, %cst, %cst_0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_angle_real_debuf.mlir b/issues/aten_c_kernels/results/aten_angle_real_debuf.mlir new file mode 100644 index 000000000000..c0ea4dc60ca3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_angle_real_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_angle_real(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 3.14159274 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %cst : f32 + %5 = arith.select %4, %cst_0, %cst : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_angle_real_linalg.mlir b/issues/aten_c_kernels/results/aten_angle_real_linalg.mlir new file mode 100644 index 000000000000..83b24d9cea17 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_angle_real_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_angle_real(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.14159274 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %cst_0 : f32 + %1 = arith.select %0, %cst, %cst_0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_arange_cpu.mlir b/issues/aten_c_kernels/results/aten_arange_cpu.mlir new file mode 100644 index 000000000000..80e8d94b9910 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_arange_cpu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_arange_cpu(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.mulf %1, %arg1 : f32 + %3 = arith.addf %arg0, %2 : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_arange_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_arange_cpu/debuf.mlir new file mode 100644 index 000000000000..4d83d255a2af --- /dev/null +++ b/issues/aten_c_kernels/results/aten_arange_cpu/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_arange_cpu(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.sitofp %4 : i32 to f32 + %6 = arith.mulf %5, %arg1 : f32 + %7 = arith.addf %arg0, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_arange_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_arange_cpu/matched.mlir new file mode 100644 index 000000000000..4d83d255a2af --- /dev/null +++ b/issues/aten_c_kernels/results/aten_arange_cpu/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_arange_cpu(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.sitofp %4 : i32 to f32 + %6 = arith.mulf %5, %arg1 : f32 + %7 = arith.addf %arg0, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_arange_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_arange_cpu/orig.mlir new file mode 100644 index 000000000000..80e8d94b9910 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_arange_cpu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_arange_cpu(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.mulf %1, %arg1 : f32 + %3 = arith.addf %arg0, %2 : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_arange_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_arange_cpu/raised.mlir new file mode 100644 index 000000000000..3a3ddde3745c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_arange_cpu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_arange_cpu(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.sitofp %1 : i32 to f32 + %3 = arith.mulf %2, %arg1 : f32 + %4 = arith.addf %arg0, %3 : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_arange_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_arange_cpu_debuf.mlir new file mode 100644 index 000000000000..4d83d255a2af --- /dev/null +++ b/issues/aten_c_kernels/results/aten_arange_cpu_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_arange_cpu(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.sitofp %4 : i32 to f32 + %6 = arith.mulf %5, %arg1 : f32 + %7 = arith.addf %arg0, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_arange_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_arange_cpu_linalg.mlir new file mode 100644 index 000000000000..3a3ddde3745c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_arange_cpu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_arange_cpu(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.sitofp %1 : i32 to f32 + %3 = arith.mulf %2, %arg1 : f32 + %4 = arith.addf %arg0, %3 : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_argmax_cpu.mlir b/issues/aten_c_kernels/results/aten_argmax_cpu.mlir new file mode 100644 index 000000000000..89e099be9caf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_argmax_cpu.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_argmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 32 { + %0 = affine.load %arg0[%arg2, 0] : memref + %1:2 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %c0_i32, %arg5 = %0) -> (i32, f32) { + %2 = arith.index_cast %arg3 : index to i32 + %3 = affine.load %arg0[%arg2, %arg3] : memref + %4 = arith.cmpf ogt, %3, %arg5 : f32 + %5 = arith.select %4, %2, %arg4 : i32 + %6 = arith.select %4, %3, %arg5 : f32 + affine.yield %5, %6 : i32, f32 + } + affine.store %1#0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_argmax_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_argmax_cpu/debuf.mlir new file mode 100644 index 000000000000..e94ec7282cd0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_argmax_cpu/debuf.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_argmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c63 = arith.constant 63 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3 = tensor.empty(%c32) : tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 1] [%c32, %c63] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %4[0] [%c32] [1] : tensor to tensor + %6:2 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice_2, %5 : tensor, tensor) { + ^bb0(%in: f32, %out: i32, %out_3: f32): + %9 = linalg.index 1 : index + %10 = arith.index_cast %9 : index to i32 + %11 = arith.cmpf ogt, %in, %out_3 : f32 + %12 = arith.select %11, %10, %out : i32 + %13 = arith.select %11, %in, %out_3 : f32 + linalg.yield %12, %13 : i32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %6#0 into %4[0] [%c32] [1] : tensor into tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %8 = bufferization.to_memref %7 : memref + memref.copy %8, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_argmax_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_argmax_cpu/matched.mlir new file mode 100644 index 000000000000..f5642350d368 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_argmax_cpu/matched.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_argmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c63 = arith.constant 63 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3 = tensor.empty(%c32) : tensor + %4 = kernel.launch @memset_zero_1D(%2) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %5 = kernel.launch @cudaCopy1D_f32_tensor(%extracted_slice, %extracted_slice_0) : (tensor, tensor) -> tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 1] [%c32, %c63] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %4[0] [%c32] [1] : tensor to tensor + %6:2 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice_2, %5 : tensor, tensor) { + ^bb0(%in: f32, %out: i32, %out_3: f32): + %9 = linalg.index 1 : index + %10 = arith.index_cast %9 : index to i32 + %11 = arith.cmpf ogt, %in, %out_3 : f32 + %12 = arith.select %11, %10, %out : i32 + %13 = arith.select %11, %in, %out_3 : f32 + linalg.yield %12, %13 : i32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %6#0 into %4[0] [%c32] [1] : tensor into tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %8 = bufferization.to_memref %7 : memref + memref.copy %8, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_argmax_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_argmax_cpu/orig.mlir new file mode 100644 index 000000000000..89e099be9caf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_argmax_cpu/orig.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_argmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 32 { + %0 = affine.load %arg0[%arg2, 0] : memref + %1:2 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %c0_i32, %arg5 = %0) -> (i32, f32) { + %2 = arith.index_cast %arg3 : index to i32 + %3 = affine.load %arg0[%arg2, %arg3] : memref + %4 = arith.cmpf ogt, %3, %arg5 : f32 + %5 = arith.select %4, %2, %arg4 : i32 + %6 = arith.select %4, %3, %arg5 : f32 + affine.yield %5, %6 : i32, f32 + } + affine.store %1#0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_argmax_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_argmax_cpu/raised.mlir new file mode 100644 index 000000000000..044b88ea1e49 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_argmax_cpu/raised.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_argmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c63 = arith.constant 63 : index + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca(%c32) : memref + %alloca_0 = memref.alloca(%c32) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c32, 1] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca_0[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_2 = memref.subview %arg0[0, 1] [%c32, %c63] [1, 1] : memref to memref> + %subview_3 = memref.subview %alloca[0] [%c32] [1] : memref to memref> + %subview_4 = memref.subview %alloca_0[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview_2 : memref>) outs(%subview_3, %subview_4 : memref>, memref>) { + ^bb0(%in: f32, %out: i32, %out_5: f32): + %0 = linalg.index 1 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.cmpf ogt, %in, %out_5 : f32 + %3 = arith.select %2, %1, %out : i32 + %4 = arith.select %2, %in, %out_5 : f32 + linalg.yield %3, %4 : i32, f32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca : memref) outs(%arg1 : memref) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_argmax_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_argmax_cpu_debuf.mlir new file mode 100644 index 000000000000..e94ec7282cd0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_argmax_cpu_debuf.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_argmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c63 = arith.constant 63 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3 = tensor.empty(%c32) : tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 1] [%c32, %c63] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %4[0] [%c32] [1] : tensor to tensor + %6:2 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice_2, %5 : tensor, tensor) { + ^bb0(%in: f32, %out: i32, %out_3: f32): + %9 = linalg.index 1 : index + %10 = arith.index_cast %9 : index to i32 + %11 = arith.cmpf ogt, %in, %out_3 : f32 + %12 = arith.select %11, %10, %out : i32 + %13 = arith.select %11, %in, %out_3 : f32 + linalg.yield %12, %13 : i32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %6#0 into %4[0] [%c32] [1] : tensor into tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %8 = bufferization.to_memref %7 : memref + memref.copy %8, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_argmax_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_argmax_cpu_linalg.mlir new file mode 100644 index 000000000000..044b88ea1e49 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_argmax_cpu_linalg.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_argmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c63 = arith.constant 63 : index + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca(%c32) : memref + %alloca_0 = memref.alloca(%c32) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c32, 1] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca_0[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_2 = memref.subview %arg0[0, 1] [%c32, %c63] [1, 1] : memref to memref> + %subview_3 = memref.subview %alloca[0] [%c32] [1] : memref to memref> + %subview_4 = memref.subview %alloca_0[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview_2 : memref>) outs(%subview_3, %subview_4 : memref>, memref>) { + ^bb0(%in: f32, %out: i32, %out_5: f32): + %0 = linalg.index 1 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.cmpf ogt, %in, %out_5 : f32 + %3 = arith.select %2, %1, %out : i32 + %4 = arith.select %2, %in, %out_5 : f32 + linalg.yield %3, %4 : i32, f32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca : memref) outs(%arg1 : memref) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_argmin_cpu.mlir b/issues/aten_c_kernels/results/aten_argmin_cpu.mlir new file mode 100644 index 000000000000..b72196ca6350 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_argmin_cpu.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_argmin_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 32 { + %0 = affine.load %arg0[%arg2, 0] : memref + %1:2 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %c0_i32, %arg5 = %0) -> (i32, f32) { + %2 = arith.index_cast %arg3 : index to i32 + %3 = affine.load %arg0[%arg2, %arg3] : memref + %4 = arith.cmpf olt, %3, %arg5 : f32 + %5 = arith.select %4, %2, %arg4 : i32 + %6 = arith.select %4, %3, %arg5 : f32 + affine.yield %5, %6 : i32, f32 + } + affine.store %1#0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_argmin_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_argmin_cpu/debuf.mlir new file mode 100644 index 000000000000..d0f0b0b02150 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_argmin_cpu/debuf.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_argmin_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c63 = arith.constant 63 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3 = tensor.empty(%c32) : tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 1] [%c32, %c63] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %4[0] [%c32] [1] : tensor to tensor + %6:2 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice_2, %5 : tensor, tensor) { + ^bb0(%in: f32, %out: i32, %out_3: f32): + %9 = linalg.index 1 : index + %10 = arith.index_cast %9 : index to i32 + %11 = arith.cmpf olt, %in, %out_3 : f32 + %12 = arith.select %11, %10, %out : i32 + %13 = arith.select %11, %in, %out_3 : f32 + linalg.yield %12, %13 : i32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %6#0 into %4[0] [%c32] [1] : tensor into tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %8 = bufferization.to_memref %7 : memref + memref.copy %8, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_argmin_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_argmin_cpu/matched.mlir new file mode 100644 index 000000000000..cbb17514a618 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_argmin_cpu/matched.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_argmin_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c63 = arith.constant 63 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3 = tensor.empty(%c32) : tensor + %4 = kernel.launch @memset_zero_1D(%2) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %5 = kernel.launch @cudaCopy1D_f32_tensor(%extracted_slice, %extracted_slice_0) : (tensor, tensor) -> tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 1] [%c32, %c63] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %4[0] [%c32] [1] : tensor to tensor + %6:2 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice_2, %5 : tensor, tensor) { + ^bb0(%in: f32, %out: i32, %out_3: f32): + %9 = linalg.index 1 : index + %10 = arith.index_cast %9 : index to i32 + %11 = arith.cmpf olt, %in, %out_3 : f32 + %12 = arith.select %11, %10, %out : i32 + %13 = arith.select %11, %in, %out_3 : f32 + linalg.yield %12, %13 : i32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %6#0 into %4[0] [%c32] [1] : tensor into tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %8 = bufferization.to_memref %7 : memref + memref.copy %8, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_argmin_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_argmin_cpu/orig.mlir new file mode 100644 index 000000000000..b72196ca6350 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_argmin_cpu/orig.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_argmin_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 32 { + %0 = affine.load %arg0[%arg2, 0] : memref + %1:2 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %c0_i32, %arg5 = %0) -> (i32, f32) { + %2 = arith.index_cast %arg3 : index to i32 + %3 = affine.load %arg0[%arg2, %arg3] : memref + %4 = arith.cmpf olt, %3, %arg5 : f32 + %5 = arith.select %4, %2, %arg4 : i32 + %6 = arith.select %4, %3, %arg5 : f32 + affine.yield %5, %6 : i32, f32 + } + affine.store %1#0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_argmin_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_argmin_cpu/raised.mlir new file mode 100644 index 000000000000..7385ee88c620 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_argmin_cpu/raised.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_argmin_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c63 = arith.constant 63 : index + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca(%c32) : memref + %alloca_0 = memref.alloca(%c32) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c32, 1] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca_0[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_2 = memref.subview %arg0[0, 1] [%c32, %c63] [1, 1] : memref to memref> + %subview_3 = memref.subview %alloca[0] [%c32] [1] : memref to memref> + %subview_4 = memref.subview %alloca_0[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview_2 : memref>) outs(%subview_3, %subview_4 : memref>, memref>) { + ^bb0(%in: f32, %out: i32, %out_5: f32): + %0 = linalg.index 1 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.cmpf olt, %in, %out_5 : f32 + %3 = arith.select %2, %1, %out : i32 + %4 = arith.select %2, %in, %out_5 : f32 + linalg.yield %3, %4 : i32, f32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca : memref) outs(%arg1 : memref) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_argmin_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_argmin_cpu_debuf.mlir new file mode 100644 index 000000000000..d0f0b0b02150 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_argmin_cpu_debuf.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_argmin_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c63 = arith.constant 63 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3 = tensor.empty(%c32) : tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 1] [%c32, %c63] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %4[0] [%c32] [1] : tensor to tensor + %6:2 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice_2, %5 : tensor, tensor) { + ^bb0(%in: f32, %out: i32, %out_3: f32): + %9 = linalg.index 1 : index + %10 = arith.index_cast %9 : index to i32 + %11 = arith.cmpf olt, %in, %out_3 : f32 + %12 = arith.select %11, %10, %out : i32 + %13 = arith.select %11, %in, %out_3 : f32 + linalg.yield %12, %13 : i32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %6#0 into %4[0] [%c32] [1] : tensor into tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %8 = bufferization.to_memref %7 : memref + memref.copy %8, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_argmin_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_argmin_cpu_linalg.mlir new file mode 100644 index 000000000000..7385ee88c620 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_argmin_cpu_linalg.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_argmin_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c63 = arith.constant 63 : index + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca(%c32) : memref + %alloca_0 = memref.alloca(%c32) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c32, 1] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca_0[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_2 = memref.subview %arg0[0, 1] [%c32, %c63] [1, 1] : memref to memref> + %subview_3 = memref.subview %alloca[0] [%c32] [1] : memref to memref> + %subview_4 = memref.subview %alloca_0[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview_2 : memref>) outs(%subview_3, %subview_4 : memref>, memref>) { + ^bb0(%in: f32, %out: i32, %out_5: f32): + %0 = linalg.index 1 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.cmpf olt, %in, %out_5 : f32 + %3 = arith.select %2, %1, %out : i32 + %4 = arith.select %2, %in, %out_5 : f32 + linalg.yield %3, %4 : i32, f32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca : memref) outs(%arg1 : memref) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_as_complex_cpu.mlir b/issues/aten_c_kernels/results/aten_as_complex_cpu.mlir new file mode 100644 index 000000000000..3a42fee960a5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_as_complex_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_as_complex_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg0[%arg3, 0] : memref + affine.store %0, %arg1[%arg3] : memref + %1 = affine.load %arg0[%arg3, 1] : memref + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_as_complex_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_as_complex_cpu/debuf.mlir new file mode 100644 index 000000000000..9d75b59db970 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_as_complex_cpu/debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_as_complex_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c512 = arith.constant 512 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c512, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c512] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0] [%c512] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + %extracted_slice_1 = tensor.extract_slice %0[0, 1] [%c512, 1] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %2[0] [%c512] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice_3 = tensor.insert_slice %5 into %2[0] [%c512] [1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice_3 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_as_complex_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_as_complex_cpu/matched.mlir new file mode 100644 index 000000000000..a14c8de4d5d2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_as_complex_cpu/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_as_complex_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c512 = arith.constant 512 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c512, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c512] [1] : tensor to tensor + %3 = kernel.launch @cudaCopy1D_f32_tensor(%extracted_slice, %extracted_slice_0) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0] [%c512] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + %extracted_slice_1 = tensor.extract_slice %0[0, 1] [%c512, 1] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %2[0] [%c512] [1] : tensor to tensor + %5 = kernel.launch @cudaCopy1D_f32_tensor(%extracted_slice_1, %extracted_slice_2) : (tensor, tensor) -> tensor + %inserted_slice_3 = tensor.insert_slice %5 into %2[0] [%c512] [1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice_3 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_as_complex_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_as_complex_cpu/orig.mlir new file mode 100644 index 000000000000..3a42fee960a5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_as_complex_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_as_complex_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg0[%arg3, 0] : memref + affine.store %0, %arg1[%arg3] : memref + %1 = affine.load %arg0[%arg3, 1] : memref + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_as_complex_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_as_complex_cpu/raised.mlir new file mode 100644 index 000000000000..f30796433eef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_as_complex_cpu/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_as_complex_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c512 = arith.constant 512 : index + %subview = memref.subview %arg0[0, 0] [%c512, 1] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c512] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_1 = memref.subview %arg0[0, 1] [%c512, 1] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0] [%c512] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_1 : memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_as_complex_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_as_complex_cpu_debuf.mlir new file mode 100644 index 000000000000..9d75b59db970 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_as_complex_cpu_debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_as_complex_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c512 = arith.constant 512 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c512, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c512] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0] [%c512] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + %extracted_slice_1 = tensor.extract_slice %0[0, 1] [%c512, 1] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %2[0] [%c512] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice_3 = tensor.insert_slice %5 into %2[0] [%c512] [1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice_3 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_as_complex_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_as_complex_cpu_linalg.mlir new file mode 100644 index 000000000000..f30796433eef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_as_complex_cpu_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_as_complex_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c512 = arith.constant 512 : index + %subview = memref.subview %arg0[0, 0] [%c512, 1] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c512] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_1 = memref.subview %arg0[0, 1] [%c512, 1] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0] [%c512] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_1 : memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_asin.mlir b/issues/aten_c_kernels/results/aten_asin.mlir new file mode 100644 index 000000000000..560db365f74e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_asin.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_asin(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @asinf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @asinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_asin/debuf.mlir b/issues/aten_c_kernels/results/aten_asin/debuf.mlir new file mode 100644 index 000000000000..8ae52f045d47 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_asin/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_asin(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @asinf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @asinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_asin/matched.mlir b/issues/aten_c_kernels/results/aten_asin/matched.mlir new file mode 100644 index 000000000000..8ae52f045d47 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_asin/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_asin(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @asinf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @asinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_asin/orig.mlir b/issues/aten_c_kernels/results/aten_asin/orig.mlir new file mode 100644 index 000000000000..560db365f74e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_asin/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_asin(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @asinf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @asinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_asin/raised.mlir b/issues/aten_c_kernels/results/aten_asin/raised.mlir new file mode 100644 index 000000000000..c5e103d6dc85 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_asin/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_asin(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @asinf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @asinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_asin_debuf.mlir b/issues/aten_c_kernels/results/aten_asin_debuf.mlir new file mode 100644 index 000000000000..8ae52f045d47 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_asin_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_asin(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @asinf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @asinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_asin_linalg.mlir b/issues/aten_c_kernels/results/aten_asin_linalg.mlir new file mode 100644 index 000000000000..c5e103d6dc85 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_asin_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_asin(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @asinf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @asinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_asinh.mlir b/issues/aten_c_kernels/results/aten_asinh.mlir new file mode 100644 index 000000000000..fd77a64eba41 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_asinh.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_asinh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @asinhf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @asinhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_asinh/debuf.mlir b/issues/aten_c_kernels/results/aten_asinh/debuf.mlir new file mode 100644 index 000000000000..bd00e539b870 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_asinh/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_asinh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @asinhf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @asinhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_asinh/matched.mlir b/issues/aten_c_kernels/results/aten_asinh/matched.mlir new file mode 100644 index 000000000000..bd00e539b870 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_asinh/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_asinh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @asinhf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @asinhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_asinh/orig.mlir b/issues/aten_c_kernels/results/aten_asinh/orig.mlir new file mode 100644 index 000000000000..fd77a64eba41 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_asinh/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_asinh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @asinhf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @asinhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_asinh/raised.mlir b/issues/aten_c_kernels/results/aten_asinh/raised.mlir new file mode 100644 index 000000000000..ef3c6c092ebb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_asinh/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_asinh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @asinhf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @asinhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_asinh_debuf.mlir b/issues/aten_c_kernels/results/aten_asinh_debuf.mlir new file mode 100644 index 000000000000..bd00e539b870 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_asinh_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_asinh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @asinhf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @asinhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_asinh_linalg.mlir b/issues/aten_c_kernels/results/aten_asinh_linalg.mlir new file mode 100644 index 000000000000..ef3c6c092ebb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_asinh_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_asinh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @asinhf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @asinhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_atan.mlir b/issues/aten_c_kernels/results/aten_atan.mlir new file mode 100644 index 000000000000..8905305755fe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atan.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atan(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @atanf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @atanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_atan/debuf.mlir b/issues/aten_c_kernels/results/aten_atan/debuf.mlir new file mode 100644 index 000000000000..681eb2d0be21 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atan/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atan(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.atan %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @atanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_atan/matched.mlir b/issues/aten_c_kernels/results/aten_atan/matched.mlir new file mode 100644 index 000000000000..681eb2d0be21 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atan/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atan(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.atan %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @atanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_atan/orig.mlir b/issues/aten_c_kernels/results/aten_atan/orig.mlir new file mode 100644 index 000000000000..8905305755fe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atan/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atan(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @atanf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @atanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_atan/raised.mlir b/issues/aten_c_kernels/results/aten_atan/raised.mlir new file mode 100644 index 000000000000..55f38a3f0890 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atan/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atan(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.atan %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @atanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_atan2.mlir b/issues/aten_c_kernels/results/aten_atan2.mlir new file mode 100644 index 000000000000..7467d377b41b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atan2.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atan2(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @atan2f(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @atan2f(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_atan2/debuf.mlir b/issues/aten_c_kernels/results/aten_atan2/debuf.mlir new file mode 100644 index 000000000000..e70909625db3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atan2/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atan2(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = math.atan2 %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @atan2f(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_atan2/matched.mlir b/issues/aten_c_kernels/results/aten_atan2/matched.mlir new file mode 100644 index 000000000000..e70909625db3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atan2/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atan2(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = math.atan2 %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @atan2f(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_atan2/orig.mlir b/issues/aten_c_kernels/results/aten_atan2/orig.mlir new file mode 100644 index 000000000000..7467d377b41b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atan2/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atan2(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @atan2f(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @atan2f(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_atan2/raised.mlir b/issues/aten_c_kernels/results/aten_atan2/raised.mlir new file mode 100644 index 000000000000..e9733ccc572b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atan2/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atan2(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = math.atan2 %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @atan2f(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_atan2_debuf.mlir b/issues/aten_c_kernels/results/aten_atan2_debuf.mlir new file mode 100644 index 000000000000..e70909625db3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atan2_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atan2(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = math.atan2 %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @atan2f(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_atan2_linalg.mlir b/issues/aten_c_kernels/results/aten_atan2_linalg.mlir new file mode 100644 index 000000000000..e9733ccc572b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atan2_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atan2(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = math.atan2 %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @atan2f(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_atan_debuf.mlir b/issues/aten_c_kernels/results/aten_atan_debuf.mlir new file mode 100644 index 000000000000..681eb2d0be21 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atan_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atan(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.atan %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @atanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_atan_linalg.mlir b/issues/aten_c_kernels/results/aten_atan_linalg.mlir new file mode 100644 index 000000000000..55f38a3f0890 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atan_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atan(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.atan %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @atanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_atanh.mlir b/issues/aten_c_kernels/results/aten_atanh.mlir new file mode 100644 index 000000000000..040082f065f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atanh.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @atanhf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @atanhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_atanh/debuf.mlir b/issues/aten_c_kernels/results/aten_atanh/debuf.mlir new file mode 100644 index 000000000000..14cfa9ca0027 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atanh/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @atanhf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @atanhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_atanh/matched.mlir b/issues/aten_c_kernels/results/aten_atanh/matched.mlir new file mode 100644 index 000000000000..14cfa9ca0027 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atanh/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @atanhf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @atanhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_atanh/orig.mlir b/issues/aten_c_kernels/results/aten_atanh/orig.mlir new file mode 100644 index 000000000000..040082f065f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atanh/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @atanhf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @atanhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_atanh/raised.mlir b/issues/aten_c_kernels/results/aten_atanh/raised.mlir new file mode 100644 index 000000000000..ca8aefd3606f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atanh/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @atanhf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @atanhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_atanh_debuf.mlir b/issues/aten_c_kernels/results/aten_atanh_debuf.mlir new file mode 100644 index 000000000000..14cfa9ca0027 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atanh_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @atanhf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @atanhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_atanh_linalg.mlir b/issues/aten_c_kernels/results/aten_atanh_linalg.mlir new file mode 100644 index 000000000000..ca8aefd3606f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_atanh_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_atanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @atanhf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @atanhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d.mlir new file mode 100644 index 000000000000..0a20dcfc0a2d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d.mlir @@ -0,0 +1,33 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.500000e-01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 8 { + affine.store %cst_0, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 8 { + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 2 { + %0 = affine.load %arg0[%arg2, %arg3, %arg6 + %arg4 * 2, %arg7 + %arg5 * 2] : memref + %1 = arith.mulf %0, %cst : f32 + %2 = affine.load %arg1[%arg2, %arg3, %arg4, %arg5] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d/debuf.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d/debuf.mlir new file mode 100644 index 000000000000..07c350c90416 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2 * 2, d5 + d3 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 2.500000e-01 : f32 + %c8 = arith.constant 8 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0] [%c2, %c4, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c4, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%3 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.mulf %in, %cst_0 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0, 0, 0] [%c2, %c4, %c8, %c8] [1, 1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d/matched.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d/matched.mlir new file mode 100644 index 000000000000..07c350c90416 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d/matched.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2 * 2, d5 + d3 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 2.500000e-01 : f32 + %c8 = arith.constant 8 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0] [%c2, %c4, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c4, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%3 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.mulf %in, %cst_0 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0, 0, 0] [%c2, %c4, %c8, %c8] [1, 1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d/orig.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d/orig.mlir new file mode 100644 index 000000000000..0a20dcfc0a2d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d/orig.mlir @@ -0,0 +1,33 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.500000e-01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 8 { + affine.store %cst_0, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 8 { + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 2 { + %0 = affine.load %arg0[%arg2, %arg3, %arg6 + %arg4 * 2, %arg7 + %arg5 * 2] : memref + %1 = arith.mulf %0, %cst : f32 + %2 = affine.load %arg1[%arg2, %arg3, %arg4, %arg5] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d/raised.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d/raised.mlir new file mode 100644 index 000000000000..e0cdef6601c4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d/raised.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2 * 2, d5 + d3 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 2.500000e-01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg1[0, 0, 0, 0] [%c2, %c4, %c8, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c4, %c8, %c8, %c2, %c2) {map = #map1} : (memref, index, index, index, index, index, index) -> memref + %subview_1 = memref.subview %arg1[0, 0, 0, 0] [%c2, %c4, %c8, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"]} ins(%0 : memref) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.mulf %in, %cst : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu.mlir new file mode 100644 index 000000000000..3885f16c2ae8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 4.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 84 { + affine.store %cst_0, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = #map(%arg3) to #map1(%arg3) { + affine.for %arg6 = #map(%arg4) to #map1(%arg4) { + %0 = affine.load %arg0[%arg4 + %arg2 * 9 + %arg3 * 3] : memref + %1 = arith.divf %0, %cst : f32 + %2 = affine.load %arg1[%arg6 + %arg5 * 7 + %arg2 * 42] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg6 + %arg5 * 7 + %arg2 * 42] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..a3e9d72cba63 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu/debuf.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d2 + d0 * 9 + d1 * 3)> +#map2 = affine_map<(d0, d1, d2) -> (d2 + d1 * 7 + d0 * 42)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4)> +#map5 = affine_map<(d0) -> (d0 * 2)> +#map6 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c3, %c3, %c6, %c6) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %4 = polygeist.submap(%2, %c2, %c6, %c6) {map = #map2} : (tensor, index, index, index) -> tensor<2x6x6xf32> + %5 = linalg.generic {doc = "", indexing_maps = [#map3, #map4], iterator_types = ["parallel", "reduction", "reduction", "parallel", "parallel"], library_call = ""} ins(%3 : tensor) outs(%4 : tensor<2x6x6xf32>) { + ^bb0(%in: f32, %out: f32): + %8 = linalg.index 2 : index + %9 = arith.divf %in, %cst_0 : f32 + %10 = arith.addf %out, %9 : f32 + %11 = linalg.index 4 : index + %12 = affine.apply #map5(%8) + %13 = arith.cmpi sge, %11, %12 : index + %14 = affine.apply #map6(%8) + %15 = arith.cmpi slt, %11, %14 : index + %16 = arith.andi %13, %15 : i1 + %17 = arith.select %16, %10, %out : f32 + linalg.yield %17 : f32 + } -> tensor<2x6x6xf32> + %6 = polygeist.submapInverse(%2, %5, %c2, %c6, %c6) {map = #map2} : (tensor, tensor<2x6x6xf32>, index, index, index) -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..19af93353ecb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu/matched.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d2 + d0 * 9 + d1 * 3)> +#map2 = affine_map<(d0, d1, d2) -> (d2 + d1 * 7 + d0 * 42)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4)> +#map5 = affine_map<(d0) -> (d0 * 2)> +#map6 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = kernel.launch @memset_zero_1D_f32(%1) : (tensor) -> tensor + %3 = polygeist.submap(%0, %c2, %c3, %c3, %c6, %c6) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %4 = polygeist.submap(%2, %c2, %c6, %c6) {map = #map2} : (tensor, index, index, index) -> tensor<2x6x6xf32> + %5 = linalg.generic {doc = "", indexing_maps = [#map3, #map4], iterator_types = ["parallel", "reduction", "reduction", "parallel", "parallel"], library_call = ""} ins(%3 : tensor) outs(%4 : tensor<2x6x6xf32>) { + ^bb0(%in: f32, %out: f32): + %8 = linalg.index 2 : index + %9 = arith.divf %in, %cst_0 : f32 + %10 = arith.addf %out, %9 : f32 + %11 = linalg.index 4 : index + %12 = affine.apply #map5(%8) + %13 = arith.cmpi sge, %11, %12 : index + %14 = affine.apply #map6(%8) + %15 = arith.cmpi slt, %11, %14 : index + %16 = arith.andi %13, %15 : i1 + %17 = arith.select %16, %10, %out : f32 + linalg.yield %17 : f32 + } -> tensor<2x6x6xf32> + %6 = polygeist.submapInverse(%2, %5, %c2, %c6, %c6) {map = #map2} : (tensor, tensor<2x6x6xf32>, index, index, index) -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..3885f16c2ae8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu/orig.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 4.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 84 { + affine.store %cst_0, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = #map(%arg3) to #map1(%arg3) { + affine.for %arg6 = #map(%arg4) to #map1(%arg4) { + %0 = affine.load %arg0[%arg4 + %arg2 * 9 + %arg3 * 3] : memref + %1 = arith.divf %0, %cst : f32 + %2 = affine.load %arg1[%arg6 + %arg5 * 7 + %arg2 * 42] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg6 + %arg5 * 7 + %arg2 * 42] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..4da97fb31bc1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu/raised.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d2 + d0 * 9 + d1 * 3)> +#map2 = affine_map<(d0, d1, d2) -> (d2 + d1 * 7 + d0 * 42)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4)> +#map5 = affine_map<(d0) -> (d0 * 2)> +#map6 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %cst = arith.constant 4.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c3, %c3, %c6, %c6) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %c2, %c6, %c6) {map = #map2} : (memref, index, index, index) -> memref<2x6x6xf32> + linalg.generic {indexing_maps = [#map3, #map4], iterator_types = ["parallel", "reduction", "reduction", "parallel", "parallel"]} ins(%0 : memref) outs(%1 : memref<2x6x6xf32>) { + ^bb0(%in: f32, %out: f32): + %2 = linalg.index 2 : index + %3 = arith.divf %in, %cst : f32 + %4 = arith.addf %out, %3 : f32 + %5 = linalg.index 4 : index + %6 = affine.apply #map5(%2) + %7 = arith.cmpi sge, %5, %6 : index + %8 = affine.apply #map6(%2) + %9 = arith.cmpi slt, %5, %8 : index + %10 = arith.andi %7, %9 : i1 + %11 = arith.select %10, %4, %out : f32 + linalg.yield %11 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..a3e9d72cba63 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu_debuf.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d2 + d0 * 9 + d1 * 3)> +#map2 = affine_map<(d0, d1, d2) -> (d2 + d1 * 7 + d0 * 42)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4)> +#map5 = affine_map<(d0) -> (d0 * 2)> +#map6 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c3, %c3, %c6, %c6) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %4 = polygeist.submap(%2, %c2, %c6, %c6) {map = #map2} : (tensor, index, index, index) -> tensor<2x6x6xf32> + %5 = linalg.generic {doc = "", indexing_maps = [#map3, #map4], iterator_types = ["parallel", "reduction", "reduction", "parallel", "parallel"], library_call = ""} ins(%3 : tensor) outs(%4 : tensor<2x6x6xf32>) { + ^bb0(%in: f32, %out: f32): + %8 = linalg.index 2 : index + %9 = arith.divf %in, %cst_0 : f32 + %10 = arith.addf %out, %9 : f32 + %11 = linalg.index 4 : index + %12 = affine.apply #map5(%8) + %13 = arith.cmpi sge, %11, %12 : index + %14 = affine.apply #map6(%8) + %15 = arith.cmpi slt, %11, %14 : index + %16 = arith.andi %13, %15 : i1 + %17 = arith.select %16, %10, %out : f32 + linalg.yield %17 : f32 + } -> tensor<2x6x6xf32> + %6 = polygeist.submapInverse(%2, %5, %c2, %c6, %c6) {map = #map2} : (tensor, tensor<2x6x6xf32>, index, index, index) -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..4da97fb31bc1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d_backward_cpu_linalg.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d2 + d0 * 9 + d1 * 3)> +#map2 = affine_map<(d0, d1, d2) -> (d2 + d1 * 7 + d0 * 42)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4)> +#map5 = affine_map<(d0) -> (d0 * 2)> +#map6 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %cst = arith.constant 4.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c3, %c3, %c6, %c6) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %c2, %c6, %c6) {map = #map2} : (memref, index, index, index) -> memref<2x6x6xf32> + linalg.generic {indexing_maps = [#map3, #map4], iterator_types = ["parallel", "reduction", "reduction", "parallel", "parallel"]} ins(%0 : memref) outs(%1 : memref<2x6x6xf32>) { + ^bb0(%in: f32, %out: f32): + %2 = linalg.index 2 : index + %3 = arith.divf %in, %cst : f32 + %4 = arith.addf %out, %3 : f32 + %5 = linalg.index 4 : index + %6 = affine.apply #map5(%2) + %7 = arith.cmpi sge, %5, %6 : index + %8 = affine.apply #map6(%2) + %9 = arith.cmpi slt, %5, %8 : index + %10 = arith.andi %7, %9 : i1 + %11 = arith.select %10, %4, %out : f32 + linalg.yield %11 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d_cpu.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d_cpu.mlir new file mode 100644 index 000000000000..569258a6b5b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d_cpu.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = arith.muli %0, %c2_i32 : i32 + %2 = arith.addi %1, %c2_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.index_cast %1 : i32 to index + %5 = arith.subi %3, %4 : index + %6:2 = affine.for %arg5 = #map(%arg3) to #map1(%arg3) iter_args(%arg6 = %c0_i32, %arg7 = %cst) -> (i32, f32) { + %9 = arith.index_cast %arg6 : i32 to index + %10 = arith.addi %9, %5 : index + %11 = arith.index_cast %10 : index to i32 + %12 = affine.for %arg8 = #map(%arg4) to #map1(%arg4) iter_args(%arg9 = %arg7) -> (f32) { + %13 = affine.load %arg0[%arg8 + %arg5 * 7 + %arg2 * 42] : memref + %14 = arith.addf %arg9, %13 : f32 + affine.yield %14 : f32 + } + affine.yield %11, %12 : i32, f32 + } + %7 = arith.sitofp %6#0 : i32 to f32 + %8 = arith.divf %6#1, %7 : f32 + affine.store %8, %arg1[%arg4 + %arg2 * 9 + %arg3 * 3] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d_cpu/debuf.mlir new file mode 100644 index 000000000000..bc148f926a66 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d_cpu/debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0)[s0, s1] -> (d0 + s0 * 9 + s1 * 3)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %3 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %alloca = memref.alloca(%c3) : memref + %4 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %5 = bufferization.to_tensor %alloca_0 : memref + %6 = polygeist.submap(%arg5, %arg2, %arg4, %c3) {map = #map} : (tensor, index, index, index) -> tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%4, %5 : tensor, tensor) outs(%6 : tensor) { + ^bb0(%in: i32, %in_1: f32, %out: f32): + %9 = arith.sitofp %in : i32 to f32 + %10 = arith.divf %in_1, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %8 = polygeist.submapInverse(%arg5, %7, %arg2, %arg4, %c3) {map = #map} : (tensor, tensor, index, index, index) -> tensor + affine.yield %8 : tensor + } + affine.yield %3 : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d_cpu/matched.mlir new file mode 100644 index 000000000000..bc148f926a66 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d_cpu/matched.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0)[s0, s1] -> (d0 + s0 * 9 + s1 * 3)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %3 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %alloca = memref.alloca(%c3) : memref + %4 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %5 = bufferization.to_tensor %alloca_0 : memref + %6 = polygeist.submap(%arg5, %arg2, %arg4, %c3) {map = #map} : (tensor, index, index, index) -> tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%4, %5 : tensor, tensor) outs(%6 : tensor) { + ^bb0(%in: i32, %in_1: f32, %out: f32): + %9 = arith.sitofp %in : i32 to f32 + %10 = arith.divf %in_1, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %8 = polygeist.submapInverse(%arg5, %7, %arg2, %arg4, %c3) {map = #map} : (tensor, tensor, index, index, index) -> tensor + affine.yield %8 : tensor + } + affine.yield %3 : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d_cpu/orig.mlir new file mode 100644 index 000000000000..569258a6b5b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d_cpu/orig.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = arith.muli %0, %c2_i32 : i32 + %2 = arith.addi %1, %c2_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.index_cast %1 : i32 to index + %5 = arith.subi %3, %4 : index + %6:2 = affine.for %arg5 = #map(%arg3) to #map1(%arg3) iter_args(%arg6 = %c0_i32, %arg7 = %cst) -> (i32, f32) { + %9 = arith.index_cast %arg6 : i32 to index + %10 = arith.addi %9, %5 : index + %11 = arith.index_cast %10 : index to i32 + %12 = affine.for %arg8 = #map(%arg4) to #map1(%arg4) iter_args(%arg9 = %arg7) -> (f32) { + %13 = affine.load %arg0[%arg8 + %arg5 * 7 + %arg2 * 42] : memref + %14 = arith.addf %arg9, %13 : f32 + affine.yield %14 : f32 + } + affine.yield %11, %12 : i32, f32 + } + %7 = arith.sitofp %6#0 : i32 to f32 + %8 = arith.divf %6#1, %7 : f32 + affine.store %8, %arg1[%arg4 + %arg2 * 9 + %arg3 * 3] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d_cpu/raised.mlir new file mode 100644 index 000000000000..9708a3c9c97c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d_cpu/raised.mlir @@ -0,0 +1,67 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 * 2)> +#map2 = affine_map<(d0) -> (d0 * 2 + 2)> +#map3 = affine_map<(d0)[s0, s1] -> (d0 + s0 * 7 + s1 * 42)> +#map4 = affine_map<(d0) -> ()> +#map5 = affine_map<(d0)[s0, s1] -> (d0 + s0 * 9 + s1 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + %alloca = memref.alloca(%c3) : memref + %alloca_0 = memref.alloca(%c3) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_0 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg4 = 0 to 3 { + %1 = arith.index_cast %arg4 : index to i32 + %2 = arith.muli %1, %c2_i32 : i32 + %3 = arith.addi %2, %c2_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = arith.index_cast %2 : i32 to index + %6 = arith.subi %4, %5 : index + affine.for %arg5 = #map1(%arg3) to #map2(%arg3) { + %7 = affine.load %alloca[%arg4] : memref + %8 = arith.index_cast %7 : i32 to index + %9 = arith.addi %8, %6 : index + %10 = arith.index_cast %9 : index to i32 + %11 = polygeist.submap(%arg0, %arg5, %arg2, %c6) {map = #map3} : (memref, index, index, index) -> memref + %subview = memref.subview %alloca_0[%arg4] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map4], iterator_types = ["reduction"]} ins(%11 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + %12 = arith.addf %out, %in : f32 + %13 = linalg.index 0 : index + %14 = affine.apply #map1(%arg4) + %15 = arith.cmpi sge, %13, %14 : index + %16 = affine.apply #map2(%arg4) + %17 = arith.cmpi slt, %13, %16 : index + %18 = arith.andi %15, %17 : i1 + %19 = arith.select %18, %12, %out : f32 + linalg.yield %19 : f32 + } + affine.store %10, %alloca[%arg4] : memref + } + } {polygeist.was_parallel} + %0 = polygeist.submap(%arg1, %arg2, %arg3, %c3) {map = #map5} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%alloca, %alloca_0 : memref, memref) outs(%0 : memref) { + ^bb0(%in: i32, %in_1: f32, %out: f32): + %1 = arith.sitofp %in : i32 to f32 + %2 = arith.divf %in_1, %1 : f32 + linalg.yield %2 : f32 + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d_cpu_debuf.mlir new file mode 100644 index 000000000000..bc148f926a66 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d_cpu_debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0)[s0, s1] -> (d0 + s0 * 9 + s1 * 3)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %3 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %alloca = memref.alloca(%c3) : memref + %4 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %5 = bufferization.to_tensor %alloca_0 : memref + %6 = polygeist.submap(%arg5, %arg2, %arg4, %c3) {map = #map} : (tensor, index, index, index) -> tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%4, %5 : tensor, tensor) outs(%6 : tensor) { + ^bb0(%in: i32, %in_1: f32, %out: f32): + %9 = arith.sitofp %in : i32 to f32 + %10 = arith.divf %in_1, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %8 = polygeist.submapInverse(%arg5, %7, %arg2, %arg4, %c3) {map = #map} : (tensor, tensor, index, index, index) -> tensor + affine.yield %8 : tensor + } + affine.yield %3 : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d_cpu_linalg.mlir new file mode 100644 index 000000000000..9708a3c9c97c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d_cpu_linalg.mlir @@ -0,0 +1,67 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 * 2)> +#map2 = affine_map<(d0) -> (d0 * 2 + 2)> +#map3 = affine_map<(d0)[s0, s1] -> (d0 + s0 * 7 + s1 * 42)> +#map4 = affine_map<(d0) -> ()> +#map5 = affine_map<(d0)[s0, s1] -> (d0 + s0 * 9 + s1 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + %alloca = memref.alloca(%c3) : memref + %alloca_0 = memref.alloca(%c3) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_0 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg4 = 0 to 3 { + %1 = arith.index_cast %arg4 : index to i32 + %2 = arith.muli %1, %c2_i32 : i32 + %3 = arith.addi %2, %c2_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = arith.index_cast %2 : i32 to index + %6 = arith.subi %4, %5 : index + affine.for %arg5 = #map1(%arg3) to #map2(%arg3) { + %7 = affine.load %alloca[%arg4] : memref + %8 = arith.index_cast %7 : i32 to index + %9 = arith.addi %8, %6 : index + %10 = arith.index_cast %9 : index to i32 + %11 = polygeist.submap(%arg0, %arg5, %arg2, %c6) {map = #map3} : (memref, index, index, index) -> memref + %subview = memref.subview %alloca_0[%arg4] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map4], iterator_types = ["reduction"]} ins(%11 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + %12 = arith.addf %out, %in : f32 + %13 = linalg.index 0 : index + %14 = affine.apply #map1(%arg4) + %15 = arith.cmpi sge, %13, %14 : index + %16 = affine.apply #map2(%arg4) + %17 = arith.cmpi slt, %13, %16 : index + %18 = arith.andi %15, %17 : i1 + %19 = arith.select %18, %12, %out : f32 + linalg.yield %19 : f32 + } + affine.store %10, %alloca[%arg4] : memref + } + } {polygeist.was_parallel} + %0 = polygeist.submap(%arg1, %arg2, %arg3, %c3) {map = #map5} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%alloca, %alloca_0 : memref, memref) outs(%0 : memref) { + ^bb0(%in: i32, %in_1: f32, %out: f32): + %1 = arith.sitofp %in : i32 to f32 + %2 = arith.divf %in_1, %1 : f32 + linalg.yield %2 : f32 + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d_debuf.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d_debuf.mlir new file mode 100644 index 000000000000..07c350c90416 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2 * 2, d5 + d3 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 2.500000e-01 : f32 + %c8 = arith.constant 8 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0] [%c2, %c4, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c4, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%3 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.mulf %in, %cst_0 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0, 0, 0] [%c2, %c4, %c8, %c8] [1, 1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool2d_linalg.mlir b/issues/aten_c_kernels/results/aten_avg_pool2d_linalg.mlir new file mode 100644 index 000000000000..e0cdef6601c4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool2d_linalg.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2 * 2, d5 + d3 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 2.500000e-01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg1[0, 0, 0, 0] [%c2, %c4, %c8, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c4, %c8, %c8, %c2, %c2) {map = #map1} : (memref, index, index, index, index, index, index) -> memref + %subview_1 = memref.subview %arg1[0, 0, 0, 0] [%c2, %c4, %c8, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"]} ins(%0 : memref) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.mulf %in, %cst : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d.mlir new file mode 100644 index 000000000000..4c606814ccfa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.store %cst_0, %arg1[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 2 { + %0 = affine.load %arg0[%arg2, %arg3, %arg7 + %arg4 * 2, %arg8 + %arg5 * 2, %arg9 + %arg6 * 2] : memref + %1 = arith.divf %0, %cst : f32 + %2 = affine.load %arg1[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d/debuf.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d/debuf.mlir new file mode 100644 index 000000000000..86f2190eb7b2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5 + d2 * 2, d6 + d3 * 2, d7 + d4 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 8.000000e+00 : f32 + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c3, %c4, %c4, %c4, %c2, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%3 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.divf %in, %cst_0 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d/matched.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d/matched.mlir new file mode 100644 index 000000000000..86f2190eb7b2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d/matched.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5 + d2 * 2, d6 + d3 * 2, d7 + d4 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 8.000000e+00 : f32 + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c3, %c4, %c4, %c4, %c2, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%3 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.divf %in, %cst_0 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d/orig.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d/orig.mlir new file mode 100644 index 000000000000..4c606814ccfa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d/orig.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.store %cst_0, %arg1[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 2 { + %0 = affine.load %arg0[%arg2, %arg3, %arg7 + %arg4 * 2, %arg8 + %arg5 * 2, %arg9 + %arg6 * 2] : memref + %1 = arith.divf %0, %cst : f32 + %2 = affine.load %arg1[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d/raised.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d/raised.mlir new file mode 100644 index 000000000000..3e27ff1dc299 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d/raised.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5 + d2 * 2, d6 + d3 * 2, d7 + d4 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c3, %c4, %c4, %c4, %c2, %c2, %c2) {map = #map1} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview_1 = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%0 : memref) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.divf %in, %cst : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu.mlir new file mode 100644 index 000000000000..2fbadcb7ab25 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 672 { + affine.store %cst_0, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = #map(%arg3) to #map1(%arg3) { + affine.for %arg7 = #map(%arg4) to #map1(%arg4) { + affine.for %arg8 = #map(%arg5) to #map1(%arg5) { + %0 = affine.load %arg0[%arg2 * 36 + %arg5 + %arg3 * 12 + %arg4 * 4] : memref + %1 = arith.divf %0, %cst : f32 + %2 = affine.load %arg1[%arg6 * 56 + %arg8 + %arg2 * 336 + %arg7 * 8] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg6 * 56 + %arg8 + %arg2 * 336 + %arg7 * 8] : memref + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..84155a90582b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu/debuf.mlir @@ -0,0 +1,45 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d3 + d0 * 36 + d1 * 12 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 56 + d0 * 336 + d2 * 8)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +#map5 = affine_map<(d0) -> (d0 * 2)> +#map6 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 8.000000e+00 : f32 + %c8 = arith.constant 8 : index + %c6 = arith.constant 6 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c3, %c3, %c4, %c6, %c6, %c8) {map = #map1} : (tensor, index, index, index, index, index, index, index) -> tensor + %4 = polygeist.submap(%2, %c2, %c6, %c6, %c8) {map = #map2} : (tensor, index, index, index, index) -> tensor<2x6x6x8xf32> + %5 = linalg.generic {doc = "", indexing_maps = [#map3, #map4], iterator_types = ["parallel", "reduction", "reduction", "reduction", "parallel", "parallel", "parallel"], library_call = ""} ins(%3 : tensor) outs(%4 : tensor<2x6x6x8xf32>) { + ^bb0(%in: f32, %out: f32): + %8 = linalg.index 3 : index + %9 = arith.divf %in, %cst_0 : f32 + %10 = arith.addf %out, %9 : f32 + %11 = linalg.index 6 : index + %12 = affine.apply #map5(%8) + %13 = arith.cmpi sge, %11, %12 : index + %14 = affine.apply #map6(%8) + %15 = arith.cmpi slt, %11, %14 : index + %16 = arith.andi %13, %15 : i1 + %17 = arith.select %16, %10, %out : f32 + linalg.yield %17 : f32 + } -> tensor<2x6x6x8xf32> + %6 = polygeist.submapInverse(%2, %5, %c2, %c6, %c6, %c8) {map = #map2} : (tensor, tensor<2x6x6x8xf32>, index, index, index, index) -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..e179021db5ef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu/matched.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d3 + d0 * 36 + d1 * 12 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 56 + d0 * 336 + d2 * 8)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +#map5 = affine_map<(d0) -> (d0 * 2)> +#map6 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 8.000000e+00 : f32 + %c8 = arith.constant 8 : index + %c6 = arith.constant 6 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = kernel.launch @memset_zero_1D_f32(%1) : (tensor) -> tensor + %3 = polygeist.submap(%0, %c2, %c3, %c3, %c4, %c6, %c6, %c8) {map = #map1} : (tensor, index, index, index, index, index, index, index) -> tensor + %4 = polygeist.submap(%2, %c2, %c6, %c6, %c8) {map = #map2} : (tensor, index, index, index, index) -> tensor<2x6x6x8xf32> + %5 = linalg.generic {doc = "", indexing_maps = [#map3, #map4], iterator_types = ["parallel", "reduction", "reduction", "reduction", "parallel", "parallel", "parallel"], library_call = ""} ins(%3 : tensor) outs(%4 : tensor<2x6x6x8xf32>) { + ^bb0(%in: f32, %out: f32): + %8 = linalg.index 3 : index + %9 = arith.divf %in, %cst_0 : f32 + %10 = arith.addf %out, %9 : f32 + %11 = linalg.index 6 : index + %12 = affine.apply #map5(%8) + %13 = arith.cmpi sge, %11, %12 : index + %14 = affine.apply #map6(%8) + %15 = arith.cmpi slt, %11, %14 : index + %16 = arith.andi %13, %15 : i1 + %17 = arith.select %16, %10, %out : f32 + linalg.yield %17 : f32 + } -> tensor<2x6x6x8xf32> + %6 = polygeist.submapInverse(%2, %5, %c2, %c6, %c6, %c8) {map = #map2} : (tensor, tensor<2x6x6x8xf32>, index, index, index, index) -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..2fbadcb7ab25 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu/orig.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 672 { + affine.store %cst_0, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = #map(%arg3) to #map1(%arg3) { + affine.for %arg7 = #map(%arg4) to #map1(%arg4) { + affine.for %arg8 = #map(%arg5) to #map1(%arg5) { + %0 = affine.load %arg0[%arg2 * 36 + %arg5 + %arg3 * 12 + %arg4 * 4] : memref + %1 = arith.divf %0, %cst : f32 + %2 = affine.load %arg1[%arg6 * 56 + %arg8 + %arg2 * 336 + %arg7 * 8] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg6 * 56 + %arg8 + %arg2 * 336 + %arg7 * 8] : memref + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..11bc0bb7215d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu/raised.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d3 + d0 * 36 + d1 * 12 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 56 + d0 * 336 + d2 * 8)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +#map5 = affine_map<(d0) -> (d0 * 2)> +#map6 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c6 = arith.constant 6 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c3, %c3, %c4, %c6, %c6, %c8) {map = #map1} : (memref, index, index, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %c2, %c6, %c6, %c8) {map = #map2} : (memref, index, index, index, index) -> memref<2x6x6x8xf32> + linalg.generic {indexing_maps = [#map3, #map4], iterator_types = ["parallel", "reduction", "reduction", "reduction", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%1 : memref<2x6x6x8xf32>) { + ^bb0(%in: f32, %out: f32): + %2 = linalg.index 3 : index + %3 = arith.divf %in, %cst : f32 + %4 = arith.addf %out, %3 : f32 + %5 = linalg.index 6 : index + %6 = affine.apply #map5(%2) + %7 = arith.cmpi sge, %5, %6 : index + %8 = affine.apply #map6(%2) + %9 = arith.cmpi slt, %5, %8 : index + %10 = arith.andi %7, %9 : i1 + %11 = arith.select %10, %4, %out : f32 + linalg.yield %11 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..84155a90582b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu_debuf.mlir @@ -0,0 +1,45 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d3 + d0 * 36 + d1 * 12 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 56 + d0 * 336 + d2 * 8)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +#map5 = affine_map<(d0) -> (d0 * 2)> +#map6 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 8.000000e+00 : f32 + %c8 = arith.constant 8 : index + %c6 = arith.constant 6 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c3, %c3, %c4, %c6, %c6, %c8) {map = #map1} : (tensor, index, index, index, index, index, index, index) -> tensor + %4 = polygeist.submap(%2, %c2, %c6, %c6, %c8) {map = #map2} : (tensor, index, index, index, index) -> tensor<2x6x6x8xf32> + %5 = linalg.generic {doc = "", indexing_maps = [#map3, #map4], iterator_types = ["parallel", "reduction", "reduction", "reduction", "parallel", "parallel", "parallel"], library_call = ""} ins(%3 : tensor) outs(%4 : tensor<2x6x6x8xf32>) { + ^bb0(%in: f32, %out: f32): + %8 = linalg.index 3 : index + %9 = arith.divf %in, %cst_0 : f32 + %10 = arith.addf %out, %9 : f32 + %11 = linalg.index 6 : index + %12 = affine.apply #map5(%8) + %13 = arith.cmpi sge, %11, %12 : index + %14 = affine.apply #map6(%8) + %15 = arith.cmpi slt, %11, %14 : index + %16 = arith.andi %13, %15 : i1 + %17 = arith.select %16, %10, %out : f32 + linalg.yield %17 : f32 + } -> tensor<2x6x6x8xf32> + %6 = polygeist.submapInverse(%2, %5, %c2, %c6, %c6, %c8) {map = #map2} : (tensor, tensor<2x6x6x8xf32>, index, index, index, index) -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..11bc0bb7215d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d_backward_cpu_linalg.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d3 + d0 * 36 + d1 * 12 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 56 + d0 * 336 + d2 * 8)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +#map5 = affine_map<(d0) -> (d0 * 2)> +#map6 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c6 = arith.constant 6 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c3, %c3, %c4, %c6, %c6, %c8) {map = #map1} : (memref, index, index, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %c2, %c6, %c6, %c8) {map = #map2} : (memref, index, index, index, index) -> memref<2x6x6x8xf32> + linalg.generic {indexing_maps = [#map3, #map4], iterator_types = ["parallel", "reduction", "reduction", "reduction", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%1 : memref<2x6x6x8xf32>) { + ^bb0(%in: f32, %out: f32): + %2 = linalg.index 3 : index + %3 = arith.divf %in, %cst : f32 + %4 = arith.addf %out, %3 : f32 + %5 = linalg.index 6 : index + %6 = affine.apply #map5(%2) + %7 = arith.cmpi sge, %5, %6 : index + %8 = affine.apply #map6(%2) + %9 = arith.cmpi slt, %5, %8 : index + %10 = arith.andi %7, %9 : i1 + %11 = arith.select %10, %4, %out : f32 + linalg.yield %11 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d_cpu.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d_cpu.mlir new file mode 100644 index 000000000000..deecf4d1b89b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d_cpu.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + %0 = arith.index_cast %arg5 : index to i32 + %1 = arith.muli %0, %c2_i32 : i32 + %2 = arith.addi %1, %c2_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.index_cast %1 : i32 to index + %5 = arith.subi %3, %4 : index + %6:2 = affine.for %arg6 = #map(%arg3) to #map1(%arg3) iter_args(%arg7 = %c0_i32, %arg8 = %cst) -> (i32, f32) { + %9:2 = affine.for %arg9 = #map(%arg4) to #map1(%arg4) iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (i32, f32) { + %10 = arith.index_cast %arg10 : i32 to index + %11 = arith.addi %10, %5 : index + %12 = arith.index_cast %11 : index to i32 + %13 = affine.for %arg12 = #map(%arg5) to #map1(%arg5) iter_args(%arg13 = %arg11) -> (f32) { + %14 = affine.load %arg0[%arg6 * 56 + %arg12 + %arg2 * 336 + %arg9 * 8] : memref + %15 = arith.addf %arg13, %14 : f32 + affine.yield %15 : f32 + } + affine.yield %12, %13 : i32, f32 + } + affine.yield %9#0, %9#1 : i32, f32 + } + %7 = arith.sitofp %6#0 : i32 to f32 + %8 = arith.divf %6#1, %7 : f32 + affine.store %8, %arg1[%arg2 * 36 + %arg5 + %arg3 * 12 + %arg4 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d_cpu/debuf.mlir new file mode 100644 index 000000000000..abec8b935557 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d_cpu/debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 36 + s1 * 12 + s2 * 4)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %3 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %4 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg5) -> (tensor) { + %alloca = memref.alloca(%c4) : memref + %5 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c4) : memref + %6 = bufferization.to_tensor %alloca_0 : memref + %7 = polygeist.submap(%arg7, %arg2, %arg4, %arg6, %c4) {map = #map} : (tensor, index, index, index, index) -> tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%5, %6 : tensor, tensor) outs(%7 : tensor) { + ^bb0(%in: i32, %in_1: f32, %out: f32): + %10 = arith.sitofp %in : i32 to f32 + %11 = arith.divf %in_1, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %9 = polygeist.submapInverse(%arg7, %8, %arg2, %arg4, %arg6, %c4) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + affine.yield %9 : tensor + } + affine.yield %4 : tensor + } + affine.yield %3 : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d_cpu/matched.mlir new file mode 100644 index 000000000000..abec8b935557 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d_cpu/matched.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 36 + s1 * 12 + s2 * 4)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %3 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %4 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg5) -> (tensor) { + %alloca = memref.alloca(%c4) : memref + %5 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c4) : memref + %6 = bufferization.to_tensor %alloca_0 : memref + %7 = polygeist.submap(%arg7, %arg2, %arg4, %arg6, %c4) {map = #map} : (tensor, index, index, index, index) -> tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%5, %6 : tensor, tensor) outs(%7 : tensor) { + ^bb0(%in: i32, %in_1: f32, %out: f32): + %10 = arith.sitofp %in : i32 to f32 + %11 = arith.divf %in_1, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %9 = polygeist.submapInverse(%arg7, %8, %arg2, %arg4, %arg6, %c4) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + affine.yield %9 : tensor + } + affine.yield %4 : tensor + } + affine.yield %3 : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d_cpu/orig.mlir new file mode 100644 index 000000000000..deecf4d1b89b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d_cpu/orig.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + %0 = arith.index_cast %arg5 : index to i32 + %1 = arith.muli %0, %c2_i32 : i32 + %2 = arith.addi %1, %c2_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.index_cast %1 : i32 to index + %5 = arith.subi %3, %4 : index + %6:2 = affine.for %arg6 = #map(%arg3) to #map1(%arg3) iter_args(%arg7 = %c0_i32, %arg8 = %cst) -> (i32, f32) { + %9:2 = affine.for %arg9 = #map(%arg4) to #map1(%arg4) iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (i32, f32) { + %10 = arith.index_cast %arg10 : i32 to index + %11 = arith.addi %10, %5 : index + %12 = arith.index_cast %11 : index to i32 + %13 = affine.for %arg12 = #map(%arg5) to #map1(%arg5) iter_args(%arg13 = %arg11) -> (f32) { + %14 = affine.load %arg0[%arg6 * 56 + %arg12 + %arg2 * 336 + %arg9 * 8] : memref + %15 = arith.addf %arg13, %14 : f32 + affine.yield %15 : f32 + } + affine.yield %12, %13 : i32, f32 + } + affine.yield %9#0, %9#1 : i32, f32 + } + %7 = arith.sitofp %6#0 : i32 to f32 + %8 = arith.divf %6#1, %7 : f32 + affine.store %8, %arg1[%arg2 * 36 + %arg5 + %arg3 * 12 + %arg4 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d_cpu/raised.mlir new file mode 100644 index 000000000000..0602340436c3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d_cpu/raised.mlir @@ -0,0 +1,80 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 * 2)> +#map2 = affine_map<(d0) -> (d0 * 2 + 2)> +#map3 = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 56 + s1 * 336 + s2 * 8)> +#map4 = affine_map<(d0) -> ()> +#map5 = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 36 + s1 * 12 + s2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c8 = arith.constant 8 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + %alloca = memref.alloca(%c4) : memref + %alloca_0 = memref.alloca(%c4) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_0 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg5 = 0 to 4 { + %1 = arith.index_cast %arg5 : index to i32 + %2 = arith.muli %1, %c2_i32 : i32 + %3 = arith.addi %2, %c2_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = arith.index_cast %2 : i32 to index + %6 = arith.subi %4, %5 : index + affine.for %arg6 = #map1(%arg3) to #map2(%arg3) { + %7 = affine.load %alloca[%arg5] : memref + %8 = affine.load %alloca_0[%arg5] : memref + %alloca_1 = memref.alloca() : memref + affine.store %7, %alloca_1[] : memref + %alloca_2 = memref.alloca() : memref + affine.store %8, %alloca_2[] : memref + affine.for %arg7 = #map1(%arg4) to #map2(%arg4) { + %11 = affine.load %alloca_1[] : memref + %12 = arith.index_cast %11 : i32 to index + %13 = arith.addi %12, %6 : index + %14 = arith.index_cast %13 : index to i32 + %15 = polygeist.submap(%arg0, %arg6, %arg2, %arg7, %c8) {map = #map3} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map4], iterator_types = ["reduction"]} ins(%15 : memref) outs(%alloca_2 : memref) { + ^bb0(%in: f32, %out: f32): + %16 = arith.addf %out, %in : f32 + %17 = linalg.index 0 : index + %18 = affine.apply #map1(%arg5) + %19 = arith.cmpi sge, %17, %18 : index + %20 = affine.apply #map2(%arg5) + %21 = arith.cmpi slt, %17, %20 : index + %22 = arith.andi %19, %21 : i1 + %23 = arith.select %22, %16, %out : f32 + linalg.yield %23 : f32 + } + affine.store %14, %alloca_1[] : memref + } + %9 = affine.load %alloca_1[] : memref + %10 = affine.load %alloca_2[] : memref + affine.store %9, %alloca[%arg5] : memref + affine.store %10, %alloca_0[%arg5] : memref + } + } {polygeist.was_parallel} + %0 = polygeist.submap(%arg1, %arg2, %arg3, %arg4, %c4) {map = #map5} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%alloca, %alloca_0 : memref, memref) outs(%0 : memref) { + ^bb0(%in: i32, %in_1: f32, %out: f32): + %1 = arith.sitofp %in : i32 to f32 + %2 = arith.divf %in_1, %1 : f32 + linalg.yield %2 : f32 + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d_cpu_debuf.mlir new file mode 100644 index 000000000000..abec8b935557 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d_cpu_debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 36 + s1 * 12 + s2 * 4)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %3 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %arg3) -> (tensor) { + %4 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg5) -> (tensor) { + %alloca = memref.alloca(%c4) : memref + %5 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c4) : memref + %6 = bufferization.to_tensor %alloca_0 : memref + %7 = polygeist.submap(%arg7, %arg2, %arg4, %arg6, %c4) {map = #map} : (tensor, index, index, index, index) -> tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%5, %6 : tensor, tensor) outs(%7 : tensor) { + ^bb0(%in: i32, %in_1: f32, %out: f32): + %10 = arith.sitofp %in : i32 to f32 + %11 = arith.divf %in_1, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %9 = polygeist.submapInverse(%arg7, %8, %arg2, %arg4, %arg6, %c4) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + affine.yield %9 : tensor + } + affine.yield %4 : tensor + } + affine.yield %3 : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d_cpu_linalg.mlir new file mode 100644 index 000000000000..0602340436c3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d_cpu_linalg.mlir @@ -0,0 +1,80 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 * 2)> +#map2 = affine_map<(d0) -> (d0 * 2 + 2)> +#map3 = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 56 + s1 * 336 + s2 * 8)> +#map4 = affine_map<(d0) -> ()> +#map5 = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 36 + s1 * 12 + s2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c8 = arith.constant 8 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + %alloca = memref.alloca(%c4) : memref + %alloca_0 = memref.alloca(%c4) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_0 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg5 = 0 to 4 { + %1 = arith.index_cast %arg5 : index to i32 + %2 = arith.muli %1, %c2_i32 : i32 + %3 = arith.addi %2, %c2_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = arith.index_cast %2 : i32 to index + %6 = arith.subi %4, %5 : index + affine.for %arg6 = #map1(%arg3) to #map2(%arg3) { + %7 = affine.load %alloca[%arg5] : memref + %8 = affine.load %alloca_0[%arg5] : memref + %alloca_1 = memref.alloca() : memref + affine.store %7, %alloca_1[] : memref + %alloca_2 = memref.alloca() : memref + affine.store %8, %alloca_2[] : memref + affine.for %arg7 = #map1(%arg4) to #map2(%arg4) { + %11 = affine.load %alloca_1[] : memref + %12 = arith.index_cast %11 : i32 to index + %13 = arith.addi %12, %6 : index + %14 = arith.index_cast %13 : index to i32 + %15 = polygeist.submap(%arg0, %arg6, %arg2, %arg7, %c8) {map = #map3} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map4], iterator_types = ["reduction"]} ins(%15 : memref) outs(%alloca_2 : memref) { + ^bb0(%in: f32, %out: f32): + %16 = arith.addf %out, %in : f32 + %17 = linalg.index 0 : index + %18 = affine.apply #map1(%arg5) + %19 = arith.cmpi sge, %17, %18 : index + %20 = affine.apply #map2(%arg5) + %21 = arith.cmpi slt, %17, %20 : index + %22 = arith.andi %19, %21 : i1 + %23 = arith.select %22, %16, %out : f32 + linalg.yield %23 : f32 + } + affine.store %14, %alloca_1[] : memref + } + %9 = affine.load %alloca_1[] : memref + %10 = affine.load %alloca_2[] : memref + affine.store %9, %alloca[%arg5] : memref + affine.store %10, %alloca_0[%arg5] : memref + } + } {polygeist.was_parallel} + %0 = polygeist.submap(%arg1, %arg2, %arg3, %arg4, %c4) {map = #map5} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%alloca, %alloca_0 : memref, memref) outs(%0 : memref) { + ^bb0(%in: i32, %in_1: f32, %out: f32): + %1 = arith.sitofp %in : i32 to f32 + %2 = arith.divf %in_1, %1 : f32 + linalg.yield %2 : f32 + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d_debuf.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d_debuf.mlir new file mode 100644 index 000000000000..86f2190eb7b2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5 + d2 * 2, d6 + d3 * 2, d7 + d4 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 8.000000e+00 : f32 + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c3, %c4, %c4, %c4, %c2, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%3 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.divf %in, %cst_0 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_avg_pool3d_linalg.mlir b/issues/aten_c_kernels/results/aten_avg_pool3d_linalg.mlir new file mode 100644 index 000000000000..3e27ff1dc299 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_avg_pool3d_linalg.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5 + d2 * 2, d6 + d3 * 2, d7 + d4 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_avg_pool3d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c3, %c4, %c4, %c4, %c2, %c2, %c2) {map = #map1} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview_1 = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%0 : memref) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.divf %in, %cst : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm.mlir b/issues/aten_c_kernels/results/aten_batch_norm.mlir new file mode 100644 index 000000000000..d120399cc721 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 8 { + affine.for %arg8 = 0 to 16 { + affine.for %arg9 = 0 to 16 { + %0 = affine.load %arg1[%arg7] : memref + %1 = affine.load %arg0[%arg6, %arg7, %arg8, %arg9] : memref + %2 = affine.load %arg2[%arg7] : memref + %3 = arith.subf %1, %2 : f32 + %4 = arith.mulf %0, %3 : f32 + %5 = affine.load %arg3[%arg7] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = affine.load %arg4[%arg7] : memref + %8 = arith.addf %6, %7 : f32 + affine.store %8, %arg5[%arg6, %arg7, %arg8, %arg9] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_batch_norm/debuf.mlir b/issues/aten_c_kernels/results/aten_batch_norm/debuf.mlir new file mode 100644 index 000000000000..4e7bd387fdd3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm/debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d1)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = bufferization.to_tensor %arg5 : memref + %extracted_slice = tensor.extract_slice %1[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0] [%c8] [1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %3[0] [%c8] [1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %4[0] [%c8] [1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %5[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map, #map, #map, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1, %extracted_slice_2, %extracted_slice_3 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_4 : tensor) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %in_7: f32, %in_8: f32, %out: f32): + %8 = arith.subf %in_5, %in_6 : f32 + %9 = arith.mulf %in, %8 : f32 + %10 = arith.mulf %9, %in_7 : f32 + %11 = arith.addf %10, %in_8 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %5[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm/matched.mlir b/issues/aten_c_kernels/results/aten_batch_norm/matched.mlir new file mode 100644 index 000000000000..6fb30ed33b09 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d1)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = bufferization.to_tensor %arg5 : memref + %extracted_slice = tensor.extract_slice %1[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0] [%c8] [1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %3[0] [%c8] [1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %4[0] [%c8] [1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %5[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %6 = kernel.launch @cudnnBatchNormalizationForwardInference(%extracted_slice_0, %extracted_slice, %extracted_slice_1, %extracted_slice_2, %extracted_slice_3, %extracted_slice_4) : (tensor, tensor, tensor, tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %6 into %5[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm/orig.mlir b/issues/aten_c_kernels/results/aten_batch_norm/orig.mlir new file mode 100644 index 000000000000..d120399cc721 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 8 { + affine.for %arg8 = 0 to 16 { + affine.for %arg9 = 0 to 16 { + %0 = affine.load %arg1[%arg7] : memref + %1 = affine.load %arg0[%arg6, %arg7, %arg8, %arg9] : memref + %2 = affine.load %arg2[%arg7] : memref + %3 = arith.subf %1, %2 : f32 + %4 = arith.mulf %0, %3 : f32 + %5 = affine.load %arg3[%arg7] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = affine.load %arg4[%arg7] : memref + %8 = arith.addf %6, %7 : f32 + affine.store %8, %arg5[%arg6, %arg7, %arg8, %arg9] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_batch_norm/raised.mlir b/issues/aten_c_kernels/results/aten_batch_norm/raised.mlir new file mode 100644 index 000000000000..f0339fdc954d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm/raised.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d1)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %subview = memref.subview %arg1[0] [%c8] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c8] [1] : memref to memref> + %subview_2 = memref.subview %arg3[0] [%c8] [1] : memref to memref> + %subview_3 = memref.subview %arg4[0] [%c8] [1] : memref to memref> + %subview_4 = memref.subview %arg5[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map, #map, #map, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0, %subview_1, %subview_2, %subview_3 : memref>, memref>, memref>, memref>, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %in_7: f32, %in_8: f32, %out: f32): + %0 = arith.subf %in_5, %in_6 : f32 + %1 = arith.mulf %in, %0 : f32 + %2 = arith.mulf %1, %in_7 : f32 + %3 = arith.addf %2, %in_8 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu.mlir new file mode 100644 index 000000000000..7334c3d16620 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu.mlir @@ -0,0 +1,46 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.280000e+02 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg8 = 0 to 8 { + %0 = affine.load %arg2[%arg8] : memref + %1:2 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst_0, %arg11 = %cst_0) -> (f32, f32) { + %4:2 = affine.for %arg12 = 0 to 32 iter_args(%arg13 = %arg10, %arg14 = %arg11) -> (f32, f32) { + %5 = affine.load %arg0[%arg9, %arg8, %arg12] : memref + %6 = arith.addf %arg14, %5 : f32 + %7 = affine.load %arg1[%arg9, %arg8, %arg12] : memref + %8 = arith.subf %7, %0 : f32 + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg13, %9 : f32 + affine.yield %10, %6 : f32, f32 + } + affine.yield %4#0, %4#1 : f32, f32 + } + affine.store %1#1, %arg7[%arg8] : memref + %2 = affine.load %arg3[%arg8] : memref + %3 = arith.mulf %1#0, %2 : f32 + affine.store %3, %arg6[%arg8] : memref + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 32 { + %4 = affine.load %arg4[%arg8] : memref + %5 = affine.load %arg3[%arg8] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.divf %6, %cst : f32 + %8 = affine.load %arg0[%arg9, %arg8, %arg10] : memref + %9 = arith.mulf %8, %cst : f32 + %10 = arith.subf %9, %1#1 : f32 + %11 = affine.load %arg1[%arg9, %arg8, %arg10] : memref + %12 = affine.load %arg2[%arg8] : memref + %13 = arith.subf %11, %12 : f32 + %14 = arith.mulf %13, %5 : f32 + %15 = arith.mulf %14, %5 : f32 + %16 = arith.mulf %15, %1#0 : f32 + %17 = arith.subf %10, %16 : f32 + %18 = arith.mulf %7, %17 : f32 + affine.store %18, %arg5[%arg9, %arg8, %arg10] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..b5864370f8cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu/debuf.mlir @@ -0,0 +1,97 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1) -> ()> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.280000e+02 : f32 + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = bufferization.to_tensor %arg7 : memref + %6 = bufferization.to_tensor %arg6 : memref + %7 = bufferization.to_tensor %arg5 : memref + %8 = bufferization.to_tensor %arg3 : memref + %9 = bufferization.to_tensor %arg2 : memref + %10 = bufferization.to_tensor %arg1 : memref + %11 = bufferization.to_tensor %arg0 : memref + %12 = tensor.empty(%c8) : tensor + %13 = tensor.empty(%c8) : tensor + %14:5 = affine.for %arg8 = 0 to 8 iter_args(%arg9 = %12, %arg10 = %13, %arg11 = %7, %arg12 = %6, %arg13 = %5) -> (tensor, tensor, tensor, tensor, tensor) { + %extracted = tensor.extract %9[%arg8] : tensor + %inserted = tensor.insert %cst into %arg9[%arg8] : tensor + %inserted_1 = tensor.insert %cst into %arg10[%arg8] : tensor + %alloca = memref.alloca(%c4) : memref + %18 = bufferization.to_tensor %alloca : memref + %alloca_2 = memref.alloca(%c4) : memref + %19 = bufferization.to_tensor %alloca_2 : memref + %20:4 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %inserted, %arg16 = %inserted_1, %arg17 = %18, %arg18 = %19) -> (tensor, tensor, tensor, tensor) { + %extracted_13 = tensor.extract %arg15[%arg8] : tensor + %extracted_14 = tensor.extract %arg16[%arg8] : tensor + %inserted_15 = tensor.insert %extracted_13 into %arg17[%arg14] : tensor + %inserted_16 = tensor.insert %extracted_14 into %arg18[%arg14] : tensor + %extracted_slice_17 = tensor.extract_slice %inserted_15[%arg14] [1] [1] : tensor to tensor + %extracted_slice_18 = tensor.extract_slice %inserted_16[%arg14] [1] [1] : tensor to tensor + %extracted_slice_19 = tensor.extract_slice %11[%arg14, %arg8, 0] [1, 1, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_20 = tensor.extract_slice %10[%arg14, %arg8, 0] [1, 1, %c32] [1, 1, 1] : tensor to tensor + %23:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_19, %extracted_slice_20 : tensor, tensor) outs(%extracted_slice_17, %extracted_slice_18 : tensor, tensor) { + ^bb0(%in: f32, %in_27: f32, %out: f32, %out_28: f32): + %24 = arith.addf %out_28, %in : f32 + %25 = arith.subf %in_27, %extracted : f32 + %26 = arith.mulf %in, %25 : f32 + %27 = arith.addf %out, %26 : f32 + linalg.yield %27, %24 : f32, f32 + } -> (tensor, tensor) + %inserted_slice_21 = tensor.insert_slice %23#1 into %inserted_16[%arg14] [1] [1] : tensor into tensor + %inserted_slice_22 = tensor.insert_slice %23#0 into %inserted_15[%arg14] [1] [1] : tensor into tensor + %extracted_23 = tensor.extract %inserted_slice_22[%arg14] : tensor + %extracted_24 = tensor.extract %inserted_slice_21[%arg14] : tensor + %inserted_25 = tensor.insert %extracted_23 into %arg15[%arg8] : tensor + %inserted_26 = tensor.insert %extracted_24 into %arg16[%arg8] : tensor + affine.yield %inserted_25, %inserted_26, %inserted_slice_22, %inserted_slice_21 : tensor, tensor, tensor, tensor + } + %extracted_3 = tensor.extract %20#0[%arg8] : tensor + %extracted_4 = tensor.extract %20#1[%arg8] : tensor + %inserted_5 = tensor.insert %extracted_4 into %arg13[%arg8] : tensor + %extracted_6 = tensor.extract %8[%arg8] : tensor + %21 = arith.mulf %extracted_3, %extracted_6 : f32 + %inserted_7 = tensor.insert %21 into %arg12[%arg8] : tensor + %extracted_slice = tensor.extract_slice %arg11[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_8 = tensor.extract_slice %4[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_9 = tensor.extract_slice %3[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_10 = tensor.extract_slice %2[%arg8] [1] [1] : tensor to tensor + %extracted_slice_11 = tensor.extract_slice %1[%arg8] [1] [1] : tensor to tensor + %extracted_slice_12 = tensor.extract_slice %0[%arg8] [1] [1] : tensor to tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map2, #map2, #map3, #map3, #map2, #map3], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_12, %extracted_slice_11, %extracted_slice_8, %extracted_slice_9, %extracted_slice_10 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_13: f32, %in_14: f32, %in_15: f32, %in_16: f32, %out: f32): + %23 = arith.mulf %in, %in_13 : f32 + %24 = arith.divf %23, %cst_0 : f32 + %25 = arith.mulf %in_14, %cst_0 : f32 + %26 = arith.subf %25, %extracted_4 : f32 + %27 = arith.subf %in_15, %in_16 : f32 + %28 = arith.mulf %27, %in_13 : f32 + %29 = arith.mulf %28, %in_13 : f32 + %30 = arith.mulf %29, %extracted_3 : f32 + %31 = arith.subf %26, %30 : f32 + %32 = arith.mulf %24, %31 : f32 + linalg.yield %32 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %22 into %arg11[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : tensor into tensor + affine.yield %20#0, %20#1, %inserted_slice, %inserted_7, %inserted_5 : tensor, tensor, tensor, tensor, tensor + } + %15 = bufferization.to_memref %14#4 : memref + memref.copy %15, %arg7 : memref to memref + %16 = bufferization.to_memref %14#3 : memref + memref.copy %16, %arg6 : memref to memref + %17 = bufferization.to_memref %14#2 : memref + memref.copy %17, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu/matched.mlir new file mode 100644 index 000000000000..b5864370f8cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu/matched.mlir @@ -0,0 +1,97 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1) -> ()> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.280000e+02 : f32 + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = bufferization.to_tensor %arg7 : memref + %6 = bufferization.to_tensor %arg6 : memref + %7 = bufferization.to_tensor %arg5 : memref + %8 = bufferization.to_tensor %arg3 : memref + %9 = bufferization.to_tensor %arg2 : memref + %10 = bufferization.to_tensor %arg1 : memref + %11 = bufferization.to_tensor %arg0 : memref + %12 = tensor.empty(%c8) : tensor + %13 = tensor.empty(%c8) : tensor + %14:5 = affine.for %arg8 = 0 to 8 iter_args(%arg9 = %12, %arg10 = %13, %arg11 = %7, %arg12 = %6, %arg13 = %5) -> (tensor, tensor, tensor, tensor, tensor) { + %extracted = tensor.extract %9[%arg8] : tensor + %inserted = tensor.insert %cst into %arg9[%arg8] : tensor + %inserted_1 = tensor.insert %cst into %arg10[%arg8] : tensor + %alloca = memref.alloca(%c4) : memref + %18 = bufferization.to_tensor %alloca : memref + %alloca_2 = memref.alloca(%c4) : memref + %19 = bufferization.to_tensor %alloca_2 : memref + %20:4 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %inserted, %arg16 = %inserted_1, %arg17 = %18, %arg18 = %19) -> (tensor, tensor, tensor, tensor) { + %extracted_13 = tensor.extract %arg15[%arg8] : tensor + %extracted_14 = tensor.extract %arg16[%arg8] : tensor + %inserted_15 = tensor.insert %extracted_13 into %arg17[%arg14] : tensor + %inserted_16 = tensor.insert %extracted_14 into %arg18[%arg14] : tensor + %extracted_slice_17 = tensor.extract_slice %inserted_15[%arg14] [1] [1] : tensor to tensor + %extracted_slice_18 = tensor.extract_slice %inserted_16[%arg14] [1] [1] : tensor to tensor + %extracted_slice_19 = tensor.extract_slice %11[%arg14, %arg8, 0] [1, 1, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_20 = tensor.extract_slice %10[%arg14, %arg8, 0] [1, 1, %c32] [1, 1, 1] : tensor to tensor + %23:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_19, %extracted_slice_20 : tensor, tensor) outs(%extracted_slice_17, %extracted_slice_18 : tensor, tensor) { + ^bb0(%in: f32, %in_27: f32, %out: f32, %out_28: f32): + %24 = arith.addf %out_28, %in : f32 + %25 = arith.subf %in_27, %extracted : f32 + %26 = arith.mulf %in, %25 : f32 + %27 = arith.addf %out, %26 : f32 + linalg.yield %27, %24 : f32, f32 + } -> (tensor, tensor) + %inserted_slice_21 = tensor.insert_slice %23#1 into %inserted_16[%arg14] [1] [1] : tensor into tensor + %inserted_slice_22 = tensor.insert_slice %23#0 into %inserted_15[%arg14] [1] [1] : tensor into tensor + %extracted_23 = tensor.extract %inserted_slice_22[%arg14] : tensor + %extracted_24 = tensor.extract %inserted_slice_21[%arg14] : tensor + %inserted_25 = tensor.insert %extracted_23 into %arg15[%arg8] : tensor + %inserted_26 = tensor.insert %extracted_24 into %arg16[%arg8] : tensor + affine.yield %inserted_25, %inserted_26, %inserted_slice_22, %inserted_slice_21 : tensor, tensor, tensor, tensor + } + %extracted_3 = tensor.extract %20#0[%arg8] : tensor + %extracted_4 = tensor.extract %20#1[%arg8] : tensor + %inserted_5 = tensor.insert %extracted_4 into %arg13[%arg8] : tensor + %extracted_6 = tensor.extract %8[%arg8] : tensor + %21 = arith.mulf %extracted_3, %extracted_6 : f32 + %inserted_7 = tensor.insert %21 into %arg12[%arg8] : tensor + %extracted_slice = tensor.extract_slice %arg11[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_8 = tensor.extract_slice %4[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_9 = tensor.extract_slice %3[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_10 = tensor.extract_slice %2[%arg8] [1] [1] : tensor to tensor + %extracted_slice_11 = tensor.extract_slice %1[%arg8] [1] [1] : tensor to tensor + %extracted_slice_12 = tensor.extract_slice %0[%arg8] [1] [1] : tensor to tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map2, #map2, #map3, #map3, #map2, #map3], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_12, %extracted_slice_11, %extracted_slice_8, %extracted_slice_9, %extracted_slice_10 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_13: f32, %in_14: f32, %in_15: f32, %in_16: f32, %out: f32): + %23 = arith.mulf %in, %in_13 : f32 + %24 = arith.divf %23, %cst_0 : f32 + %25 = arith.mulf %in_14, %cst_0 : f32 + %26 = arith.subf %25, %extracted_4 : f32 + %27 = arith.subf %in_15, %in_16 : f32 + %28 = arith.mulf %27, %in_13 : f32 + %29 = arith.mulf %28, %in_13 : f32 + %30 = arith.mulf %29, %extracted_3 : f32 + %31 = arith.subf %26, %30 : f32 + %32 = arith.mulf %24, %31 : f32 + linalg.yield %32 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %22 into %arg11[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : tensor into tensor + affine.yield %20#0, %20#1, %inserted_slice, %inserted_7, %inserted_5 : tensor, tensor, tensor, tensor, tensor + } + %15 = bufferization.to_memref %14#4 : memref + memref.copy %15, %arg7 : memref to memref + %16 = bufferization.to_memref %14#3 : memref + memref.copy %16, %arg6 : memref to memref + %17 = bufferization.to_memref %14#2 : memref + memref.copy %17, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu/orig.mlir new file mode 100644 index 000000000000..7334c3d16620 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu/orig.mlir @@ -0,0 +1,46 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.280000e+02 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg8 = 0 to 8 { + %0 = affine.load %arg2[%arg8] : memref + %1:2 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst_0, %arg11 = %cst_0) -> (f32, f32) { + %4:2 = affine.for %arg12 = 0 to 32 iter_args(%arg13 = %arg10, %arg14 = %arg11) -> (f32, f32) { + %5 = affine.load %arg0[%arg9, %arg8, %arg12] : memref + %6 = arith.addf %arg14, %5 : f32 + %7 = affine.load %arg1[%arg9, %arg8, %arg12] : memref + %8 = arith.subf %7, %0 : f32 + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg13, %9 : f32 + affine.yield %10, %6 : f32, f32 + } + affine.yield %4#0, %4#1 : f32, f32 + } + affine.store %1#1, %arg7[%arg8] : memref + %2 = affine.load %arg3[%arg8] : memref + %3 = arith.mulf %1#0, %2 : f32 + affine.store %3, %arg6[%arg8] : memref + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 32 { + %4 = affine.load %arg4[%arg8] : memref + %5 = affine.load %arg3[%arg8] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.divf %6, %cst : f32 + %8 = affine.load %arg0[%arg9, %arg8, %arg10] : memref + %9 = arith.mulf %8, %cst : f32 + %10 = arith.subf %9, %1#1 : f32 + %11 = affine.load %arg1[%arg9, %arg8, %arg10] : memref + %12 = affine.load %arg2[%arg8] : memref + %13 = arith.subf %11, %12 : f32 + %14 = arith.mulf %13, %5 : f32 + %15 = arith.mulf %14, %5 : f32 + %16 = arith.mulf %15, %1#0 : f32 + %17 = arith.subf %10, %16 : f32 + %18 = arith.mulf %7, %17 : f32 + affine.store %18, %arg5[%arg9, %arg8, %arg10] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu/raised.mlir new file mode 100644 index 000000000000..29c985b60636 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu/raised.mlir @@ -0,0 +1,72 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1) -> ()> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c4 = arith.constant 4 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 1.280000e+02 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca(%c8) : memref + %alloca_1 = memref.alloca(%c8) : memref + affine.for %arg8 = 0 to 8 { + %0 = affine.load %arg2[%arg8] : memref + affine.store %cst_0, %alloca[%arg8] : memref + affine.store %cst_0, %alloca_1[%arg8] : memref + %alloca_2 = memref.alloca(%c4) : memref + %alloca_3 = memref.alloca(%c4) : memref + affine.for %arg9 = 0 to 4 { + %5 = affine.load %alloca[%arg8] : memref + %6 = affine.load %alloca_1[%arg8] : memref + affine.store %5, %alloca_2[%arg9] : memref + affine.store %6, %alloca_3[%arg9] : memref + %subview_9 = memref.subview %arg0[%arg9, %arg8, 0] [1, 1, %c32] [1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg1[%arg9, %arg8, 0] [1, 1, %c32] [1, 1, 1] : memref to memref> + %subview_11 = memref.subview %alloca_2[%arg9] [1] [1] : memref to memref> + %subview_12 = memref.subview %alloca_3[%arg9] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview_9, %subview_10 : memref>, memref>) outs(%subview_11, %subview_12 : memref>, memref>) { + ^bb0(%in: f32, %in_13: f32, %out: f32, %out_14: f32): + %9 = arith.addf %out_14, %in : f32 + %10 = arith.subf %in_13, %0 : f32 + %11 = arith.mulf %in, %10 : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12, %9 : f32, f32 + } + %7 = affine.load %alloca_2[%arg9] : memref + %8 = affine.load %alloca_3[%arg9] : memref + affine.store %7, %alloca[%arg8] : memref + affine.store %8, %alloca_1[%arg8] : memref + } + %1 = affine.load %alloca[%arg8] : memref + %2 = affine.load %alloca_1[%arg8] : memref + affine.store %2, %arg7[%arg8] : memref + %3 = affine.load %arg3[%arg8] : memref + %4 = arith.mulf %1, %3 : f32 + affine.store %4, %arg6[%arg8] : memref + %subview = memref.subview %arg4[%arg8] [1] [1] : memref to memref> + %subview_4 = memref.subview %arg3[%arg8] [1] [1] : memref to memref> + %subview_5 = memref.subview %arg0[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : memref to memref> + %subview_6 = memref.subview %arg1[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : memref to memref> + %subview_7 = memref.subview %arg2[%arg8] [1] [1] : memref to memref> + %subview_8 = memref.subview %arg5[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map3, #map3, #map2, #map3], iterator_types = ["parallel", "parallel"]} ins(%subview, %subview_4, %subview_5, %subview_6, %subview_7 : memref>, memref>, memref>, memref>, memref>) outs(%subview_8 : memref>) { + ^bb0(%in: f32, %in_9: f32, %in_10: f32, %in_11: f32, %in_12: f32, %out: f32): + %5 = arith.mulf %in, %in_9 : f32 + %6 = arith.divf %5, %cst : f32 + %7 = arith.mulf %in_10, %cst : f32 + %8 = arith.subf %7, %2 : f32 + %9 = arith.subf %in_11, %in_12 : f32 + %10 = arith.mulf %9, %in_9 : f32 + %11 = arith.mulf %10, %in_9 : f32 + %12 = arith.mulf %11, %1 : f32 + %13 = arith.subf %8, %12 : f32 + %14 = arith.mulf %6, %13 : f32 + linalg.yield %14 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..b5864370f8cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu_debuf.mlir @@ -0,0 +1,97 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1) -> ()> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.280000e+02 : f32 + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = bufferization.to_tensor %arg7 : memref + %6 = bufferization.to_tensor %arg6 : memref + %7 = bufferization.to_tensor %arg5 : memref + %8 = bufferization.to_tensor %arg3 : memref + %9 = bufferization.to_tensor %arg2 : memref + %10 = bufferization.to_tensor %arg1 : memref + %11 = bufferization.to_tensor %arg0 : memref + %12 = tensor.empty(%c8) : tensor + %13 = tensor.empty(%c8) : tensor + %14:5 = affine.for %arg8 = 0 to 8 iter_args(%arg9 = %12, %arg10 = %13, %arg11 = %7, %arg12 = %6, %arg13 = %5) -> (tensor, tensor, tensor, tensor, tensor) { + %extracted = tensor.extract %9[%arg8] : tensor + %inserted = tensor.insert %cst into %arg9[%arg8] : tensor + %inserted_1 = tensor.insert %cst into %arg10[%arg8] : tensor + %alloca = memref.alloca(%c4) : memref + %18 = bufferization.to_tensor %alloca : memref + %alloca_2 = memref.alloca(%c4) : memref + %19 = bufferization.to_tensor %alloca_2 : memref + %20:4 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %inserted, %arg16 = %inserted_1, %arg17 = %18, %arg18 = %19) -> (tensor, tensor, tensor, tensor) { + %extracted_13 = tensor.extract %arg15[%arg8] : tensor + %extracted_14 = tensor.extract %arg16[%arg8] : tensor + %inserted_15 = tensor.insert %extracted_13 into %arg17[%arg14] : tensor + %inserted_16 = tensor.insert %extracted_14 into %arg18[%arg14] : tensor + %extracted_slice_17 = tensor.extract_slice %inserted_15[%arg14] [1] [1] : tensor to tensor + %extracted_slice_18 = tensor.extract_slice %inserted_16[%arg14] [1] [1] : tensor to tensor + %extracted_slice_19 = tensor.extract_slice %11[%arg14, %arg8, 0] [1, 1, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_20 = tensor.extract_slice %10[%arg14, %arg8, 0] [1, 1, %c32] [1, 1, 1] : tensor to tensor + %23:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_19, %extracted_slice_20 : tensor, tensor) outs(%extracted_slice_17, %extracted_slice_18 : tensor, tensor) { + ^bb0(%in: f32, %in_27: f32, %out: f32, %out_28: f32): + %24 = arith.addf %out_28, %in : f32 + %25 = arith.subf %in_27, %extracted : f32 + %26 = arith.mulf %in, %25 : f32 + %27 = arith.addf %out, %26 : f32 + linalg.yield %27, %24 : f32, f32 + } -> (tensor, tensor) + %inserted_slice_21 = tensor.insert_slice %23#1 into %inserted_16[%arg14] [1] [1] : tensor into tensor + %inserted_slice_22 = tensor.insert_slice %23#0 into %inserted_15[%arg14] [1] [1] : tensor into tensor + %extracted_23 = tensor.extract %inserted_slice_22[%arg14] : tensor + %extracted_24 = tensor.extract %inserted_slice_21[%arg14] : tensor + %inserted_25 = tensor.insert %extracted_23 into %arg15[%arg8] : tensor + %inserted_26 = tensor.insert %extracted_24 into %arg16[%arg8] : tensor + affine.yield %inserted_25, %inserted_26, %inserted_slice_22, %inserted_slice_21 : tensor, tensor, tensor, tensor + } + %extracted_3 = tensor.extract %20#0[%arg8] : tensor + %extracted_4 = tensor.extract %20#1[%arg8] : tensor + %inserted_5 = tensor.insert %extracted_4 into %arg13[%arg8] : tensor + %extracted_6 = tensor.extract %8[%arg8] : tensor + %21 = arith.mulf %extracted_3, %extracted_6 : f32 + %inserted_7 = tensor.insert %21 into %arg12[%arg8] : tensor + %extracted_slice = tensor.extract_slice %arg11[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_8 = tensor.extract_slice %4[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_9 = tensor.extract_slice %3[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_10 = tensor.extract_slice %2[%arg8] [1] [1] : tensor to tensor + %extracted_slice_11 = tensor.extract_slice %1[%arg8] [1] [1] : tensor to tensor + %extracted_slice_12 = tensor.extract_slice %0[%arg8] [1] [1] : tensor to tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map2, #map2, #map3, #map3, #map2, #map3], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_12, %extracted_slice_11, %extracted_slice_8, %extracted_slice_9, %extracted_slice_10 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_13: f32, %in_14: f32, %in_15: f32, %in_16: f32, %out: f32): + %23 = arith.mulf %in, %in_13 : f32 + %24 = arith.divf %23, %cst_0 : f32 + %25 = arith.mulf %in_14, %cst_0 : f32 + %26 = arith.subf %25, %extracted_4 : f32 + %27 = arith.subf %in_15, %in_16 : f32 + %28 = arith.mulf %27, %in_13 : f32 + %29 = arith.mulf %28, %in_13 : f32 + %30 = arith.mulf %29, %extracted_3 : f32 + %31 = arith.subf %26, %30 : f32 + %32 = arith.mulf %24, %31 : f32 + linalg.yield %32 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %22 into %arg11[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : tensor into tensor + affine.yield %20#0, %20#1, %inserted_slice, %inserted_7, %inserted_5 : tensor, tensor, tensor, tensor, tensor + } + %15 = bufferization.to_memref %14#4 : memref + memref.copy %15, %arg7 : memref to memref + %16 = bufferization.to_memref %14#3 : memref + memref.copy %16, %arg6 : memref to memref + %17 = bufferization.to_memref %14#2 : memref + memref.copy %17, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..29c985b60636 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_backward_cpu_linalg.mlir @@ -0,0 +1,72 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1) -> ()> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c4 = arith.constant 4 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 1.280000e+02 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca(%c8) : memref + %alloca_1 = memref.alloca(%c8) : memref + affine.for %arg8 = 0 to 8 { + %0 = affine.load %arg2[%arg8] : memref + affine.store %cst_0, %alloca[%arg8] : memref + affine.store %cst_0, %alloca_1[%arg8] : memref + %alloca_2 = memref.alloca(%c4) : memref + %alloca_3 = memref.alloca(%c4) : memref + affine.for %arg9 = 0 to 4 { + %5 = affine.load %alloca[%arg8] : memref + %6 = affine.load %alloca_1[%arg8] : memref + affine.store %5, %alloca_2[%arg9] : memref + affine.store %6, %alloca_3[%arg9] : memref + %subview_9 = memref.subview %arg0[%arg9, %arg8, 0] [1, 1, %c32] [1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg1[%arg9, %arg8, 0] [1, 1, %c32] [1, 1, 1] : memref to memref> + %subview_11 = memref.subview %alloca_2[%arg9] [1] [1] : memref to memref> + %subview_12 = memref.subview %alloca_3[%arg9] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview_9, %subview_10 : memref>, memref>) outs(%subview_11, %subview_12 : memref>, memref>) { + ^bb0(%in: f32, %in_13: f32, %out: f32, %out_14: f32): + %9 = arith.addf %out_14, %in : f32 + %10 = arith.subf %in_13, %0 : f32 + %11 = arith.mulf %in, %10 : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12, %9 : f32, f32 + } + %7 = affine.load %alloca_2[%arg9] : memref + %8 = affine.load %alloca_3[%arg9] : memref + affine.store %7, %alloca[%arg8] : memref + affine.store %8, %alloca_1[%arg8] : memref + } + %1 = affine.load %alloca[%arg8] : memref + %2 = affine.load %alloca_1[%arg8] : memref + affine.store %2, %arg7[%arg8] : memref + %3 = affine.load %arg3[%arg8] : memref + %4 = arith.mulf %1, %3 : f32 + affine.store %4, %arg6[%arg8] : memref + %subview = memref.subview %arg4[%arg8] [1] [1] : memref to memref> + %subview_4 = memref.subview %arg3[%arg8] [1] [1] : memref to memref> + %subview_5 = memref.subview %arg0[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : memref to memref> + %subview_6 = memref.subview %arg1[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : memref to memref> + %subview_7 = memref.subview %arg2[%arg8] [1] [1] : memref to memref> + %subview_8 = memref.subview %arg5[0, %arg8, 0] [%c4, 1, %c32] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map3, #map3, #map2, #map3], iterator_types = ["parallel", "parallel"]} ins(%subview, %subview_4, %subview_5, %subview_6, %subview_7 : memref>, memref>, memref>, memref>, memref>) outs(%subview_8 : memref>) { + ^bb0(%in: f32, %in_9: f32, %in_10: f32, %in_11: f32, %in_12: f32, %out: f32): + %5 = arith.mulf %in, %in_9 : f32 + %6 = arith.divf %5, %cst : f32 + %7 = arith.mulf %in_10, %cst : f32 + %8 = arith.subf %7, %2 : f32 + %9 = arith.subf %in_11, %in_12 : f32 + %10 = arith.mulf %9, %in_9 : f32 + %11 = arith.mulf %10, %in_9 : f32 + %12 = arith.mulf %11, %1 : f32 + %13 = arith.subf %8, %12 : f32 + %14 = arith.mulf %6, %13 : f32 + linalg.yield %14 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu.mlir b/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu.mlir new file mode 100644 index 000000000000..80083f17801b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu.mlir @@ -0,0 +1,45 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_backward_template_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.048000e+03 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 16 { + %0:2 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %cst_0, %arg8 = %cst_0) -> (f32, f32) { + %2 = affine.load %arg2[%arg5] : memref + %3:2 = affine.for %arg9 = 0 to 16 iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (f32, f32) { + %4:2 = affine.for %arg12 = 0 to 16 iter_args(%arg13 = %arg10, %arg14 = %arg11) -> (f32, f32) { + %5 = affine.load %arg0[%arg6, %arg5, %arg9, %arg12] : memref + %6 = arith.addf %arg14, %5 : f32 + %7 = affine.load %arg1[%arg6, %arg5, %arg9, %arg12] : memref + %8 = arith.subf %7, %2 : f32 + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg13, %9 : f32 + affine.yield %10, %6 : f32, f32 + } + affine.yield %4#0, %4#1 : f32, f32 + } + affine.yield %3#0, %3#1 : f32, f32 + } + %1 = arith.divf %0#1, %cst : f32 + affine.for %arg6 = 0 to 8 { + affine.for %arg7 = 0 to 16 { + affine.for %arg8 = 0 to 16 { + %2 = affine.load %arg3[%arg5] : memref + %3 = affine.load %arg0[%arg6, %arg5, %arg7, %arg8] : memref + %4 = arith.subf %3, %1 : f32 + %5 = affine.load %arg1[%arg6, %arg5, %arg7, %arg8] : memref + %6 = affine.load %arg2[%arg5] : memref + %7 = arith.subf %5, %6 : f32 + %8 = arith.mulf %7, %2 : f32 + %9 = arith.mulf %8, %2 : f32 + %10 = arith.mulf %9, %0#0 : f32 + %11 = arith.divf %10, %cst : f32 + %12 = arith.subf %4, %11 : f32 + %13 = arith.mulf %2, %12 : f32 + affine.store %13, %arg4[%arg6, %arg5, %arg7, %arg8] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu/debuf.mlir new file mode 100644 index 000000000000..284c7bd0bff1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu/debuf.mlir @@ -0,0 +1,85 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d1, d0, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_backward_template_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 2.048000e+03 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca(%c16) : memref + %alloca_1 = memref.alloca(%c16) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + affine.for %arg5 = 0 to 16 { + %alloca_8 = memref.alloca(%c8) : memref + %alloca_9 = memref.alloca(%c8) : memref + affine.for %arg6 = 0 to 8 { + %2 = affine.load %alloca[%arg5] : memref + %3 = affine.load %alloca_1[%arg5] : memref + %4 = affine.load %arg2[%arg5] : memref + affine.store %2, %alloca_8[%arg6] : memref + affine.store %3, %alloca_9[%arg6] : memref + %alloca_10 = memref.alloca(%c16) : memref + %alloca_11 = memref.alloca(%c16) : memref + affine.for %arg7 = 0 to 16 { + %7 = affine.load %alloca_8[%arg6] : memref + %8 = affine.load %alloca_9[%arg6] : memref + affine.store %7, %alloca_10[%arg7] : memref + affine.store %8, %alloca_11[%arg7] : memref + %subview_12 = memref.subview %arg0[%arg6, %arg5, %arg7, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_13 = memref.subview %arg1[%arg6, %arg5, %arg7, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_14 = memref.subview %alloca_10[%arg7] [1] [1] : memref to memref> + %subview_15 = memref.subview %alloca_11[%arg7] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview_12, %subview_13 : memref>, memref>) outs(%subview_14, %subview_15 : memref>, memref>) { + ^bb0(%in: f32, %in_16: f32, %out: f32, %out_17: f32): + %11 = arith.addf %out_17, %in : f32 + %12 = arith.subf %in_16, %4 : f32 + %13 = arith.mulf %in, %12 : f32 + %14 = arith.addf %out, %13 : f32 + linalg.yield %14, %11 : f32, f32 + } + %9 = affine.load %alloca_10[%arg7] : memref + %10 = affine.load %alloca_11[%arg7] : memref + affine.store %9, %alloca_8[%arg6] : memref + affine.store %10, %alloca_9[%arg6] : memref + } + %5 = affine.load %alloca_8[%arg6] : memref + %6 = affine.load %alloca_9[%arg6] : memref + affine.store %5, %alloca[%arg5] : memref + affine.store %6, %alloca_1[%arg5] : memref + } + } {polygeist.was_parallel} + %subview = memref.subview %arg3[0] [%c16] [1] : memref to memref> + %subview_2 = memref.subview %arg0[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %subview_3 = memref.subview %arg1[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %subview_4 = memref.subview %arg2[0] [%c16] [1] : memref to memref> + %subview_5 = memref.subview %arg4[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %0 = polygeist.submap(%alloca, %c16) {map = #map} : (memref, index) -> memref + %subview_6 = memref.subview %0[0] [%c16] [1] : memref to memref> + %1 = polygeist.submap(%alloca_1, %c16) {map = #map} : (memref, index) -> memref + %subview_7 = memref.subview %1[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map2, #map3, #map3, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_6, %subview_7, %subview, %subview_2, %subview_3, %subview_4 : memref>, memref>, memref>, memref>, memref>, memref>) outs(%subview_5 : memref>) { + ^bb0(%in: f32, %in_8: f32, %in_9: f32, %in_10: f32, %in_11: f32, %in_12: f32, %out: f32): + %2 = arith.divf %in_8, %cst : f32 + %3 = arith.subf %in_10, %2 : f32 + %4 = arith.subf %in_11, %in_12 : f32 + %5 = arith.mulf %4, %in_9 : f32 + %6 = arith.mulf %5, %in_9 : f32 + %7 = arith.mulf %6, %in : f32 + %8 = arith.divf %7, %cst : f32 + %9 = arith.subf %3, %8 : f32 + %10 = arith.mulf %in_9, %9 : f32 + linalg.yield %10 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu/matched.mlir new file mode 100644 index 000000000000..284c7bd0bff1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu/matched.mlir @@ -0,0 +1,85 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d1, d0, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_backward_template_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 2.048000e+03 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca(%c16) : memref + %alloca_1 = memref.alloca(%c16) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + affine.for %arg5 = 0 to 16 { + %alloca_8 = memref.alloca(%c8) : memref + %alloca_9 = memref.alloca(%c8) : memref + affine.for %arg6 = 0 to 8 { + %2 = affine.load %alloca[%arg5] : memref + %3 = affine.load %alloca_1[%arg5] : memref + %4 = affine.load %arg2[%arg5] : memref + affine.store %2, %alloca_8[%arg6] : memref + affine.store %3, %alloca_9[%arg6] : memref + %alloca_10 = memref.alloca(%c16) : memref + %alloca_11 = memref.alloca(%c16) : memref + affine.for %arg7 = 0 to 16 { + %7 = affine.load %alloca_8[%arg6] : memref + %8 = affine.load %alloca_9[%arg6] : memref + affine.store %7, %alloca_10[%arg7] : memref + affine.store %8, %alloca_11[%arg7] : memref + %subview_12 = memref.subview %arg0[%arg6, %arg5, %arg7, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_13 = memref.subview %arg1[%arg6, %arg5, %arg7, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_14 = memref.subview %alloca_10[%arg7] [1] [1] : memref to memref> + %subview_15 = memref.subview %alloca_11[%arg7] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview_12, %subview_13 : memref>, memref>) outs(%subview_14, %subview_15 : memref>, memref>) { + ^bb0(%in: f32, %in_16: f32, %out: f32, %out_17: f32): + %11 = arith.addf %out_17, %in : f32 + %12 = arith.subf %in_16, %4 : f32 + %13 = arith.mulf %in, %12 : f32 + %14 = arith.addf %out, %13 : f32 + linalg.yield %14, %11 : f32, f32 + } + %9 = affine.load %alloca_10[%arg7] : memref + %10 = affine.load %alloca_11[%arg7] : memref + affine.store %9, %alloca_8[%arg6] : memref + affine.store %10, %alloca_9[%arg6] : memref + } + %5 = affine.load %alloca_8[%arg6] : memref + %6 = affine.load %alloca_9[%arg6] : memref + affine.store %5, %alloca[%arg5] : memref + affine.store %6, %alloca_1[%arg5] : memref + } + } {polygeist.was_parallel} + %subview = memref.subview %arg3[0] [%c16] [1] : memref to memref> + %subview_2 = memref.subview %arg0[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %subview_3 = memref.subview %arg1[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %subview_4 = memref.subview %arg2[0] [%c16] [1] : memref to memref> + %subview_5 = memref.subview %arg4[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %0 = polygeist.submap(%alloca, %c16) {map = #map} : (memref, index) -> memref + %subview_6 = memref.subview %0[0] [%c16] [1] : memref to memref> + %1 = polygeist.submap(%alloca_1, %c16) {map = #map} : (memref, index) -> memref + %subview_7 = memref.subview %1[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map2, #map3, #map3, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_6, %subview_7, %subview, %subview_2, %subview_3, %subview_4 : memref>, memref>, memref>, memref>, memref>, memref>) outs(%subview_5 : memref>) { + ^bb0(%in: f32, %in_8: f32, %in_9: f32, %in_10: f32, %in_11: f32, %in_12: f32, %out: f32): + %2 = arith.divf %in_8, %cst : f32 + %3 = arith.subf %in_10, %2 : f32 + %4 = arith.subf %in_11, %in_12 : f32 + %5 = arith.mulf %4, %in_9 : f32 + %6 = arith.mulf %5, %in_9 : f32 + %7 = arith.mulf %6, %in : f32 + %8 = arith.divf %7, %cst : f32 + %9 = arith.subf %3, %8 : f32 + %10 = arith.mulf %in_9, %9 : f32 + linalg.yield %10 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu/orig.mlir new file mode 100644 index 000000000000..80083f17801b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu/orig.mlir @@ -0,0 +1,45 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_backward_template_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.048000e+03 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 16 { + %0:2 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %cst_0, %arg8 = %cst_0) -> (f32, f32) { + %2 = affine.load %arg2[%arg5] : memref + %3:2 = affine.for %arg9 = 0 to 16 iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (f32, f32) { + %4:2 = affine.for %arg12 = 0 to 16 iter_args(%arg13 = %arg10, %arg14 = %arg11) -> (f32, f32) { + %5 = affine.load %arg0[%arg6, %arg5, %arg9, %arg12] : memref + %6 = arith.addf %arg14, %5 : f32 + %7 = affine.load %arg1[%arg6, %arg5, %arg9, %arg12] : memref + %8 = arith.subf %7, %2 : f32 + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg13, %9 : f32 + affine.yield %10, %6 : f32, f32 + } + affine.yield %4#0, %4#1 : f32, f32 + } + affine.yield %3#0, %3#1 : f32, f32 + } + %1 = arith.divf %0#1, %cst : f32 + affine.for %arg6 = 0 to 8 { + affine.for %arg7 = 0 to 16 { + affine.for %arg8 = 0 to 16 { + %2 = affine.load %arg3[%arg5] : memref + %3 = affine.load %arg0[%arg6, %arg5, %arg7, %arg8] : memref + %4 = arith.subf %3, %1 : f32 + %5 = affine.load %arg1[%arg6, %arg5, %arg7, %arg8] : memref + %6 = affine.load %arg2[%arg5] : memref + %7 = arith.subf %5, %6 : f32 + %8 = arith.mulf %7, %2 : f32 + %9 = arith.mulf %8, %2 : f32 + %10 = arith.mulf %9, %0#0 : f32 + %11 = arith.divf %10, %cst : f32 + %12 = arith.subf %4, %11 : f32 + %13 = arith.mulf %2, %12 : f32 + affine.store %13, %arg4[%arg6, %arg5, %arg7, %arg8] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu/raised.mlir new file mode 100644 index 000000000000..284c7bd0bff1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu/raised.mlir @@ -0,0 +1,85 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d1, d0, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_backward_template_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 2.048000e+03 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca(%c16) : memref + %alloca_1 = memref.alloca(%c16) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + affine.for %arg5 = 0 to 16 { + %alloca_8 = memref.alloca(%c8) : memref + %alloca_9 = memref.alloca(%c8) : memref + affine.for %arg6 = 0 to 8 { + %2 = affine.load %alloca[%arg5] : memref + %3 = affine.load %alloca_1[%arg5] : memref + %4 = affine.load %arg2[%arg5] : memref + affine.store %2, %alloca_8[%arg6] : memref + affine.store %3, %alloca_9[%arg6] : memref + %alloca_10 = memref.alloca(%c16) : memref + %alloca_11 = memref.alloca(%c16) : memref + affine.for %arg7 = 0 to 16 { + %7 = affine.load %alloca_8[%arg6] : memref + %8 = affine.load %alloca_9[%arg6] : memref + affine.store %7, %alloca_10[%arg7] : memref + affine.store %8, %alloca_11[%arg7] : memref + %subview_12 = memref.subview %arg0[%arg6, %arg5, %arg7, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_13 = memref.subview %arg1[%arg6, %arg5, %arg7, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_14 = memref.subview %alloca_10[%arg7] [1] [1] : memref to memref> + %subview_15 = memref.subview %alloca_11[%arg7] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview_12, %subview_13 : memref>, memref>) outs(%subview_14, %subview_15 : memref>, memref>) { + ^bb0(%in: f32, %in_16: f32, %out: f32, %out_17: f32): + %11 = arith.addf %out_17, %in : f32 + %12 = arith.subf %in_16, %4 : f32 + %13 = arith.mulf %in, %12 : f32 + %14 = arith.addf %out, %13 : f32 + linalg.yield %14, %11 : f32, f32 + } + %9 = affine.load %alloca_10[%arg7] : memref + %10 = affine.load %alloca_11[%arg7] : memref + affine.store %9, %alloca_8[%arg6] : memref + affine.store %10, %alloca_9[%arg6] : memref + } + %5 = affine.load %alloca_8[%arg6] : memref + %6 = affine.load %alloca_9[%arg6] : memref + affine.store %5, %alloca[%arg5] : memref + affine.store %6, %alloca_1[%arg5] : memref + } + } {polygeist.was_parallel} + %subview = memref.subview %arg3[0] [%c16] [1] : memref to memref> + %subview_2 = memref.subview %arg0[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %subview_3 = memref.subview %arg1[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %subview_4 = memref.subview %arg2[0] [%c16] [1] : memref to memref> + %subview_5 = memref.subview %arg4[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %0 = polygeist.submap(%alloca, %c16) {map = #map} : (memref, index) -> memref + %subview_6 = memref.subview %0[0] [%c16] [1] : memref to memref> + %1 = polygeist.submap(%alloca_1, %c16) {map = #map} : (memref, index) -> memref + %subview_7 = memref.subview %1[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map2, #map3, #map3, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_6, %subview_7, %subview, %subview_2, %subview_3, %subview_4 : memref>, memref>, memref>, memref>, memref>, memref>) outs(%subview_5 : memref>) { + ^bb0(%in: f32, %in_8: f32, %in_9: f32, %in_10: f32, %in_11: f32, %in_12: f32, %out: f32): + %2 = arith.divf %in_8, %cst : f32 + %3 = arith.subf %in_10, %2 : f32 + %4 = arith.subf %in_11, %in_12 : f32 + %5 = arith.mulf %4, %in_9 : f32 + %6 = arith.mulf %5, %in_9 : f32 + %7 = arith.mulf %6, %in : f32 + %8 = arith.divf %7, %cst : f32 + %9 = arith.subf %3, %8 : f32 + %10 = arith.mulf %in_9, %9 : f32 + linalg.yield %10 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu_debuf.mlir new file mode 100644 index 000000000000..284c7bd0bff1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu_debuf.mlir @@ -0,0 +1,85 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d1, d0, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_backward_template_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 2.048000e+03 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca(%c16) : memref + %alloca_1 = memref.alloca(%c16) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + affine.for %arg5 = 0 to 16 { + %alloca_8 = memref.alloca(%c8) : memref + %alloca_9 = memref.alloca(%c8) : memref + affine.for %arg6 = 0 to 8 { + %2 = affine.load %alloca[%arg5] : memref + %3 = affine.load %alloca_1[%arg5] : memref + %4 = affine.load %arg2[%arg5] : memref + affine.store %2, %alloca_8[%arg6] : memref + affine.store %3, %alloca_9[%arg6] : memref + %alloca_10 = memref.alloca(%c16) : memref + %alloca_11 = memref.alloca(%c16) : memref + affine.for %arg7 = 0 to 16 { + %7 = affine.load %alloca_8[%arg6] : memref + %8 = affine.load %alloca_9[%arg6] : memref + affine.store %7, %alloca_10[%arg7] : memref + affine.store %8, %alloca_11[%arg7] : memref + %subview_12 = memref.subview %arg0[%arg6, %arg5, %arg7, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_13 = memref.subview %arg1[%arg6, %arg5, %arg7, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_14 = memref.subview %alloca_10[%arg7] [1] [1] : memref to memref> + %subview_15 = memref.subview %alloca_11[%arg7] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview_12, %subview_13 : memref>, memref>) outs(%subview_14, %subview_15 : memref>, memref>) { + ^bb0(%in: f32, %in_16: f32, %out: f32, %out_17: f32): + %11 = arith.addf %out_17, %in : f32 + %12 = arith.subf %in_16, %4 : f32 + %13 = arith.mulf %in, %12 : f32 + %14 = arith.addf %out, %13 : f32 + linalg.yield %14, %11 : f32, f32 + } + %9 = affine.load %alloca_10[%arg7] : memref + %10 = affine.load %alloca_11[%arg7] : memref + affine.store %9, %alloca_8[%arg6] : memref + affine.store %10, %alloca_9[%arg6] : memref + } + %5 = affine.load %alloca_8[%arg6] : memref + %6 = affine.load %alloca_9[%arg6] : memref + affine.store %5, %alloca[%arg5] : memref + affine.store %6, %alloca_1[%arg5] : memref + } + } {polygeist.was_parallel} + %subview = memref.subview %arg3[0] [%c16] [1] : memref to memref> + %subview_2 = memref.subview %arg0[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %subview_3 = memref.subview %arg1[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %subview_4 = memref.subview %arg2[0] [%c16] [1] : memref to memref> + %subview_5 = memref.subview %arg4[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %0 = polygeist.submap(%alloca, %c16) {map = #map} : (memref, index) -> memref + %subview_6 = memref.subview %0[0] [%c16] [1] : memref to memref> + %1 = polygeist.submap(%alloca_1, %c16) {map = #map} : (memref, index) -> memref + %subview_7 = memref.subview %1[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map2, #map3, #map3, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_6, %subview_7, %subview, %subview_2, %subview_3, %subview_4 : memref>, memref>, memref>, memref>, memref>, memref>) outs(%subview_5 : memref>) { + ^bb0(%in: f32, %in_8: f32, %in_9: f32, %in_10: f32, %in_11: f32, %in_12: f32, %out: f32): + %2 = arith.divf %in_8, %cst : f32 + %3 = arith.subf %in_10, %2 : f32 + %4 = arith.subf %in_11, %in_12 : f32 + %5 = arith.mulf %4, %in_9 : f32 + %6 = arith.mulf %5, %in_9 : f32 + %7 = arith.mulf %6, %in : f32 + %8 = arith.divf %7, %cst : f32 + %9 = arith.subf %3, %8 : f32 + %10 = arith.mulf %in_9, %9 : f32 + linalg.yield %10 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu_linalg.mlir new file mode 100644 index 000000000000..284c7bd0bff1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_backward_template_cpu_linalg.mlir @@ -0,0 +1,85 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d1, d0, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_backward_template_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 2.048000e+03 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca(%c16) : memref + %alloca_1 = memref.alloca(%c16) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + affine.for %arg5 = 0 to 16 { + %alloca_8 = memref.alloca(%c8) : memref + %alloca_9 = memref.alloca(%c8) : memref + affine.for %arg6 = 0 to 8 { + %2 = affine.load %alloca[%arg5] : memref + %3 = affine.load %alloca_1[%arg5] : memref + %4 = affine.load %arg2[%arg5] : memref + affine.store %2, %alloca_8[%arg6] : memref + affine.store %3, %alloca_9[%arg6] : memref + %alloca_10 = memref.alloca(%c16) : memref + %alloca_11 = memref.alloca(%c16) : memref + affine.for %arg7 = 0 to 16 { + %7 = affine.load %alloca_8[%arg6] : memref + %8 = affine.load %alloca_9[%arg6] : memref + affine.store %7, %alloca_10[%arg7] : memref + affine.store %8, %alloca_11[%arg7] : memref + %subview_12 = memref.subview %arg0[%arg6, %arg5, %arg7, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_13 = memref.subview %arg1[%arg6, %arg5, %arg7, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_14 = memref.subview %alloca_10[%arg7] [1] [1] : memref to memref> + %subview_15 = memref.subview %alloca_11[%arg7] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview_12, %subview_13 : memref>, memref>) outs(%subview_14, %subview_15 : memref>, memref>) { + ^bb0(%in: f32, %in_16: f32, %out: f32, %out_17: f32): + %11 = arith.addf %out_17, %in : f32 + %12 = arith.subf %in_16, %4 : f32 + %13 = arith.mulf %in, %12 : f32 + %14 = arith.addf %out, %13 : f32 + linalg.yield %14, %11 : f32, f32 + } + %9 = affine.load %alloca_10[%arg7] : memref + %10 = affine.load %alloca_11[%arg7] : memref + affine.store %9, %alloca_8[%arg6] : memref + affine.store %10, %alloca_9[%arg6] : memref + } + %5 = affine.load %alloca_8[%arg6] : memref + %6 = affine.load %alloca_9[%arg6] : memref + affine.store %5, %alloca[%arg5] : memref + affine.store %6, %alloca_1[%arg5] : memref + } + } {polygeist.was_parallel} + %subview = memref.subview %arg3[0] [%c16] [1] : memref to memref> + %subview_2 = memref.subview %arg0[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %subview_3 = memref.subview %arg1[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %subview_4 = memref.subview %arg2[0] [%c16] [1] : memref to memref> + %subview_5 = memref.subview %arg4[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %0 = polygeist.submap(%alloca, %c16) {map = #map} : (memref, index) -> memref + %subview_6 = memref.subview %0[0] [%c16] [1] : memref to memref> + %1 = polygeist.submap(%alloca_1, %c16) {map = #map} : (memref, index) -> memref + %subview_7 = memref.subview %1[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map2, #map3, #map3, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_6, %subview_7, %subview, %subview_2, %subview_3, %subview_4 : memref>, memref>, memref>, memref>, memref>, memref>) outs(%subview_5 : memref>) { + ^bb0(%in: f32, %in_8: f32, %in_9: f32, %in_10: f32, %in_11: f32, %in_12: f32, %out: f32): + %2 = arith.divf %in_8, %cst : f32 + %3 = arith.subf %in_10, %2 : f32 + %4 = arith.subf %in_11, %in_12 : f32 + %5 = arith.mulf %4, %in_9 : f32 + %6 = arith.mulf %5, %in_9 : f32 + %7 = arith.mulf %6, %in : f32 + %8 = arith.divf %7, %cst : f32 + %9 = arith.subf %3, %8 : f32 + %10 = arith.mulf %in_9, %9 : f32 + linalg.yield %10 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu.mlir b/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu.mlir new file mode 100644 index 000000000000..641e26c2f991 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_collect_stats_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.280000e+02 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + %0 = affine.for %arg4 = 0 to 4 iter_args(%arg5 = %cst_0) -> (f32) { + %4 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %arg5) -> (f32) { + %5 = affine.load %arg0[%arg4, %arg3, %arg6] : memref + %6 = arith.addf %arg7, %5 : f32 + affine.yield %6 : f32 + } + affine.yield %4 : f32 + } + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg1[%arg3] : memref + %2 = affine.for %arg4 = 0 to 4 iter_args(%arg5 = %cst_0) -> (f32) { + %4 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %arg5) -> (f32) { + %5 = affine.load %arg0[%arg4, %arg3, %arg6] : memref + %6 = arith.subf %5, %1 : f32 + %7 = arith.mulf %6, %6 : f32 + %8 = arith.addf %arg7, %7 : f32 + affine.yield %8 : f32 + } + affine.yield %4 : f32 + } + %3 = arith.divf %2, %cst : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu/debuf.mlir new file mode 100644 index 000000000000..86a6e44605ef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu/debuf.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_collect_stats_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.280000e+02 : f32 + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %alloca = memref.alloca() : memref + %6 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %6[] : tensor + %extracted_slice = tensor.extract_slice %2[0, %arg3, 0] [%c4, 1, %c32] [1, 1, 1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = arith.addf %out, %in : f32 + linalg.yield %12 : f32 + } -> tensor + %extracted = tensor.extract %7[] : tensor + %8 = arith.divf %extracted, %cst_0 : f32 + %inserted_1 = tensor.insert %8 into %arg4[%arg3] : tensor + %alloca_2 = memref.alloca() : memref + %9 = bufferization.to_tensor %alloca_2 : memref + %inserted_3 = tensor.insert %cst into %9[] : tensor + %extracted_slice_4 = tensor.extract_slice %2[0, %arg3, 0] [%c4, 1, %c32] [1, 1, 1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%extracted_slice_4 : tensor) outs(%inserted_3 : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = arith.subf %in, %8 : f32 + %13 = arith.mulf %12, %12 : f32 + %14 = arith.addf %out, %13 : f32 + linalg.yield %14 : f32 + } -> tensor + %extracted_5 = tensor.extract %10[] : tensor + %11 = arith.divf %extracted_5, %cst_0 : f32 + %inserted_6 = tensor.insert %11 into %arg5[%arg3] : tensor + affine.yield %inserted_1, %inserted_6 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu/matched.mlir new file mode 100644 index 000000000000..86a6e44605ef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu/matched.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_collect_stats_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.280000e+02 : f32 + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %alloca = memref.alloca() : memref + %6 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %6[] : tensor + %extracted_slice = tensor.extract_slice %2[0, %arg3, 0] [%c4, 1, %c32] [1, 1, 1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = arith.addf %out, %in : f32 + linalg.yield %12 : f32 + } -> tensor + %extracted = tensor.extract %7[] : tensor + %8 = arith.divf %extracted, %cst_0 : f32 + %inserted_1 = tensor.insert %8 into %arg4[%arg3] : tensor + %alloca_2 = memref.alloca() : memref + %9 = bufferization.to_tensor %alloca_2 : memref + %inserted_3 = tensor.insert %cst into %9[] : tensor + %extracted_slice_4 = tensor.extract_slice %2[0, %arg3, 0] [%c4, 1, %c32] [1, 1, 1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%extracted_slice_4 : tensor) outs(%inserted_3 : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = arith.subf %in, %8 : f32 + %13 = arith.mulf %12, %12 : f32 + %14 = arith.addf %out, %13 : f32 + linalg.yield %14 : f32 + } -> tensor + %extracted_5 = tensor.extract %10[] : tensor + %11 = arith.divf %extracted_5, %cst_0 : f32 + %inserted_6 = tensor.insert %11 into %arg5[%arg3] : tensor + affine.yield %inserted_1, %inserted_6 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu/orig.mlir new file mode 100644 index 000000000000..641e26c2f991 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu/orig.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_collect_stats_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.280000e+02 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + %0 = affine.for %arg4 = 0 to 4 iter_args(%arg5 = %cst_0) -> (f32) { + %4 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %arg5) -> (f32) { + %5 = affine.load %arg0[%arg4, %arg3, %arg6] : memref + %6 = arith.addf %arg7, %5 : f32 + affine.yield %6 : f32 + } + affine.yield %4 : f32 + } + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg1[%arg3] : memref + %2 = affine.for %arg4 = 0 to 4 iter_args(%arg5 = %cst_0) -> (f32) { + %4 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %arg5) -> (f32) { + %5 = affine.load %arg0[%arg4, %arg3, %arg6] : memref + %6 = arith.subf %5, %1 : f32 + %7 = arith.mulf %6, %6 : f32 + %8 = arith.addf %arg7, %7 : f32 + affine.yield %8 : f32 + } + affine.yield %4 : f32 + } + %3 = arith.divf %2, %cst : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu/raised.mlir new file mode 100644 index 000000000000..53da8ea9d145 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu/raised.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_collect_stats_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 1.280000e+02 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + %alloca = memref.alloca() : memref + affine.store %cst_0, %alloca[] : memref + %subview = memref.subview %arg0[0, %arg3, 0] [%c4, 1, %c32] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg1[%arg3] : memref + %alloca_1 = memref.alloca() : memref + affine.store %cst_0, %alloca_1[] : memref + %subview_2 = memref.subview %arg0[0, %arg3, 0] [%c4, 1, %c32] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"]} ins(%subview_2 : memref>) outs(%alloca_1 : memref) { + ^bb0(%in: f32, %out: f32): + %4 = arith.subf %in, %1 : f32 + %5 = arith.mulf %4, %4 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } + %2 = affine.load %alloca_1[] : memref + %3 = arith.divf %2, %cst : f32 + affine.store %3, %arg2[%arg3] : memref + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu_debuf.mlir new file mode 100644 index 000000000000..86a6e44605ef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu_debuf.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_collect_stats_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.280000e+02 : f32 + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %alloca = memref.alloca() : memref + %6 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %6[] : tensor + %extracted_slice = tensor.extract_slice %2[0, %arg3, 0] [%c4, 1, %c32] [1, 1, 1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = arith.addf %out, %in : f32 + linalg.yield %12 : f32 + } -> tensor + %extracted = tensor.extract %7[] : tensor + %8 = arith.divf %extracted, %cst_0 : f32 + %inserted_1 = tensor.insert %8 into %arg4[%arg3] : tensor + %alloca_2 = memref.alloca() : memref + %9 = bufferization.to_tensor %alloca_2 : memref + %inserted_3 = tensor.insert %cst into %9[] : tensor + %extracted_slice_4 = tensor.extract_slice %2[0, %arg3, 0] [%c4, 1, %c32] [1, 1, 1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%extracted_slice_4 : tensor) outs(%inserted_3 : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = arith.subf %in, %8 : f32 + %13 = arith.mulf %12, %12 : f32 + %14 = arith.addf %out, %13 : f32 + linalg.yield %14 : f32 + } -> tensor + %extracted_5 = tensor.extract %10[] : tensor + %11 = arith.divf %extracted_5, %cst_0 : f32 + %inserted_6 = tensor.insert %11 into %arg5[%arg3] : tensor + affine.yield %inserted_1, %inserted_6 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu_linalg.mlir new file mode 100644 index 000000000000..53da8ea9d145 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_collect_stats_cpu_linalg.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_collect_stats_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 1.280000e+02 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + %alloca = memref.alloca() : memref + affine.store %cst_0, %alloca[] : memref + %subview = memref.subview %arg0[0, %arg3, 0] [%c4, 1, %c32] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg1[%arg3] : memref + %alloca_1 = memref.alloca() : memref + affine.store %cst_0, %alloca_1[] : memref + %subview_2 = memref.subview %arg0[0, %arg3, 0] [%c4, 1, %c32] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"]} ins(%subview_2 : memref>) outs(%alloca_1 : memref) { + ^bb0(%in: f32, %out: f32): + %4 = arith.subf %in, %1 : f32 + %5 = arith.mulf %4, %4 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } + %2 = affine.load %alloca_1[] : memref + %3 = arith.divf %2, %cst : f32 + affine.store %3, %arg2[%arg3] : memref + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry.mlir b/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry.mlir new file mode 100644 index 000000000000..6fb8fb374e01 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_cpu_entry(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 2048 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.mulf %0, %arg1 : f32 + %2 = arith.addf %1, %arg2 : f32 + affine.store %2, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry/debuf.mlir b/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry/debuf.mlir new file mode 100644 index 000000000000..0333cf6fb120 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_cpu_entry(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %arg1 : f32 + %5 = arith.addf %4, %arg2 : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry/matched.mlir b/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry/matched.mlir new file mode 100644 index 000000000000..0333cf6fb120 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_cpu_entry(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %arg1 : f32 + %5 = arith.addf %4, %arg2 : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry/orig.mlir b/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry/orig.mlir new file mode 100644 index 000000000000..6fb8fb374e01 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_cpu_entry(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 2048 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.mulf %0, %arg1 : f32 + %2 = arith.addf %1, %arg2 : f32 + affine.store %2, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry/raised.mlir b/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry/raised.mlir new file mode 100644 index 000000000000..22bafe51a78e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_cpu_entry(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %arg1 : f32 + %1 = arith.addf %0, %arg2 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry_debuf.mlir b/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry_debuf.mlir new file mode 100644 index 000000000000..0333cf6fb120 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_cpu_entry(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %arg1 : f32 + %5 = arith.addf %4, %arg2 : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry_linalg.mlir b/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry_linalg.mlir new file mode 100644 index 000000000000..22bafe51a78e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_cpu_entry_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_cpu_entry(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %arg1 : f32 + %1 = arith.addf %0, %arg2 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_debuf.mlir b/issues/aten_c_kernels/results/aten_batch_norm_debuf.mlir new file mode 100644 index 000000000000..4e7bd387fdd3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d1)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = bufferization.to_tensor %arg5 : memref + %extracted_slice = tensor.extract_slice %1[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0] [%c8] [1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %3[0] [%c8] [1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %4[0] [%c8] [1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %5[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map, #map, #map, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1, %extracted_slice_2, %extracted_slice_3 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_4 : tensor) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %in_7: f32, %in_8: f32, %out: f32): + %8 = arith.subf %in_5, %in_6 : f32 + %9 = arith.mulf %in, %8 : f32 + %10 = arith.mulf %9, %in_7 : f32 + %11 = arith.addf %10, %in_8 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %5[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_linalg.mlir b/issues/aten_c_kernels/results/aten_batch_norm_linalg.mlir new file mode 100644 index 000000000000..f0339fdc954d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_linalg.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d1)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %subview = memref.subview %arg1[0] [%c8] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c8] [1] : memref to memref> + %subview_2 = memref.subview %arg3[0] [%c8] [1] : memref to memref> + %subview_3 = memref.subview %arg4[0] [%c8] [1] : memref to memref> + %subview_4 = memref.subview %arg5[0, 0, 0, 0] [%c2, %c8, %c16, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map, #map, #map, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0, %subview_1, %subview_2, %subview_3 : memref>, memref>, memref>, memref>, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %in_7: f32, %in_8: f32, %out: f32): + %0 = arith.subf %in_5, %in_6 : f32 + %1 = arith.mulf %in, %0 : f32 + %2 = arith.mulf %1, %in_7 : f32 + %3 = arith.addf %2, %in_8 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu.mlir b/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu.mlir new file mode 100644 index 000000000000..dadf38ded7ea --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_stats_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.048000e+03 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 16 { + %0 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %cst_0) -> (f32) { + %4 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %arg5) -> (f32) { + %5 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %arg7) -> (f32) { + %6 = affine.load %arg0[%arg4, %arg3, %arg6, %arg8] : memref + %7 = arith.addf %arg9, %6 : f32 + affine.yield %7 : f32 + } + affine.yield %5 : f32 + } + affine.yield %4 : f32 + } + %1 = arith.divf %0, %cst : f32 + %2 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %cst_0) -> (f32) { + %4 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %arg5) -> (f32) { + %5 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %arg7) -> (f32) { + %6 = affine.load %arg0[%arg4, %arg3, %arg6, %arg8] : memref + %7 = arith.subf %6, %1 : f32 + %8 = arith.mulf %7, %7 : f32 + %9 = arith.addf %arg9, %8 : f32 + affine.yield %9 : f32 + } + affine.yield %5 : f32 + } + affine.yield %4 : f32 + } + affine.store %1, %arg1[%arg3] : memref + %3 = arith.divf %2, %cst : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu/debuf.mlir new file mode 100644 index 000000000000..1eea8b088ee2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu/debuf.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_stats_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 2.048000e+03 : f32 + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %alloca = memref.alloca() : memref + %6 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %6[] : tensor + %extracted_slice = tensor.extract_slice %2[0, %arg3, 0, 0] [%c8, 1, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = arith.addf %out, %in : f32 + linalg.yield %12 : f32 + } -> tensor + %extracted = tensor.extract %7[] : tensor + %8 = arith.divf %extracted, %cst_0 : f32 + %alloca_1 = memref.alloca() : memref + %9 = bufferization.to_tensor %alloca_1 : memref + %inserted_2 = tensor.insert %cst into %9[] : tensor + %extracted_slice_3 = tensor.extract_slice %2[0, %arg3, 0, 0] [%c8, 1, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction", "reduction"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%inserted_2 : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = arith.subf %in, %8 : f32 + %13 = arith.mulf %12, %12 : f32 + %14 = arith.addf %out, %13 : f32 + linalg.yield %14 : f32 + } -> tensor + %extracted_4 = tensor.extract %10[] : tensor + %inserted_5 = tensor.insert %8 into %arg4[%arg3] : tensor + %11 = arith.divf %extracted_4, %cst_0 : f32 + %inserted_6 = tensor.insert %11 into %arg5[%arg3] : tensor + affine.yield %inserted_5, %inserted_6 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu/matched.mlir new file mode 100644 index 000000000000..1eea8b088ee2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu/matched.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_stats_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 2.048000e+03 : f32 + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %alloca = memref.alloca() : memref + %6 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %6[] : tensor + %extracted_slice = tensor.extract_slice %2[0, %arg3, 0, 0] [%c8, 1, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = arith.addf %out, %in : f32 + linalg.yield %12 : f32 + } -> tensor + %extracted = tensor.extract %7[] : tensor + %8 = arith.divf %extracted, %cst_0 : f32 + %alloca_1 = memref.alloca() : memref + %9 = bufferization.to_tensor %alloca_1 : memref + %inserted_2 = tensor.insert %cst into %9[] : tensor + %extracted_slice_3 = tensor.extract_slice %2[0, %arg3, 0, 0] [%c8, 1, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction", "reduction"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%inserted_2 : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = arith.subf %in, %8 : f32 + %13 = arith.mulf %12, %12 : f32 + %14 = arith.addf %out, %13 : f32 + linalg.yield %14 : f32 + } -> tensor + %extracted_4 = tensor.extract %10[] : tensor + %inserted_5 = tensor.insert %8 into %arg4[%arg3] : tensor + %11 = arith.divf %extracted_4, %cst_0 : f32 + %inserted_6 = tensor.insert %11 into %arg5[%arg3] : tensor + affine.yield %inserted_5, %inserted_6 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu/orig.mlir new file mode 100644 index 000000000000..dadf38ded7ea --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu/orig.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_stats_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.048000e+03 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 16 { + %0 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %cst_0) -> (f32) { + %4 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %arg5) -> (f32) { + %5 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %arg7) -> (f32) { + %6 = affine.load %arg0[%arg4, %arg3, %arg6, %arg8] : memref + %7 = arith.addf %arg9, %6 : f32 + affine.yield %7 : f32 + } + affine.yield %5 : f32 + } + affine.yield %4 : f32 + } + %1 = arith.divf %0, %cst : f32 + %2 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %cst_0) -> (f32) { + %4 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %arg5) -> (f32) { + %5 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %arg7) -> (f32) { + %6 = affine.load %arg0[%arg4, %arg3, %arg6, %arg8] : memref + %7 = arith.subf %6, %1 : f32 + %8 = arith.mulf %7, %7 : f32 + %9 = arith.addf %arg9, %8 : f32 + affine.yield %9 : f32 + } + affine.yield %5 : f32 + } + affine.yield %4 : f32 + } + affine.store %1, %arg1[%arg3] : memref + %3 = arith.divf %2, %cst : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu/raised.mlir new file mode 100644 index 000000000000..9d0bbfe0152b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu/raised.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_stats_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 2.048000e+03 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 16 { + %alloca = memref.alloca() : memref + affine.store %cst_0, %alloca[] : memref + %subview = memref.subview %arg0[0, %arg3, 0, 0] [%c8, 1, %c16, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction", "reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f32 + %alloca_1 = memref.alloca() : memref + affine.store %cst_0, %alloca_1[] : memref + %subview_2 = memref.subview %arg0[0, %arg3, 0, 0] [%c8, 1, %c16, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction", "reduction"]} ins(%subview_2 : memref>) outs(%alloca_1 : memref) { + ^bb0(%in: f32, %out: f32): + %4 = arith.subf %in, %1 : f32 + %5 = arith.mulf %4, %4 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } + %2 = affine.load %alloca_1[] : memref + affine.store %1, %arg1[%arg3] : memref + %3 = arith.divf %2, %cst : f32 + affine.store %3, %arg2[%arg3] : memref + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu_debuf.mlir new file mode 100644 index 000000000000..1eea8b088ee2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu_debuf.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_stats_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 2.048000e+03 : f32 + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %alloca = memref.alloca() : memref + %6 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %6[] : tensor + %extracted_slice = tensor.extract_slice %2[0, %arg3, 0, 0] [%c8, 1, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = arith.addf %out, %in : f32 + linalg.yield %12 : f32 + } -> tensor + %extracted = tensor.extract %7[] : tensor + %8 = arith.divf %extracted, %cst_0 : f32 + %alloca_1 = memref.alloca() : memref + %9 = bufferization.to_tensor %alloca_1 : memref + %inserted_2 = tensor.insert %cst into %9[] : tensor + %extracted_slice_3 = tensor.extract_slice %2[0, %arg3, 0, 0] [%c8, 1, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction", "reduction"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%inserted_2 : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = arith.subf %in, %8 : f32 + %13 = arith.mulf %12, %12 : f32 + %14 = arith.addf %out, %13 : f32 + linalg.yield %14 : f32 + } -> tensor + %extracted_4 = tensor.extract %10[] : tensor + %inserted_5 = tensor.insert %8 into %arg4[%arg3] : tensor + %11 = arith.divf %extracted_4, %cst_0 : f32 + %inserted_6 = tensor.insert %11 into %arg5[%arg3] : tensor + affine.yield %inserted_5, %inserted_6 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu_linalg.mlir new file mode 100644 index 000000000000..9d0bbfe0152b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_stats_cpu_linalg.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_stats_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 2.048000e+03 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 16 { + %alloca = memref.alloca() : memref + affine.store %cst_0, %alloca[] : memref + %subview = memref.subview %arg0[0, %arg3, 0, 0] [%c8, 1, %c16, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction", "reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f32 + %alloca_1 = memref.alloca() : memref + affine.store %cst_0, %alloca_1[] : memref + %subview_2 = memref.subview %arg0[0, %arg3, 0, 0] [%c8, 1, %c16, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction", "reduction"]} ins(%subview_2 : memref>) outs(%alloca_1 : memref) { + ^bb0(%in: f32, %out: f32): + %4 = arith.subf %in, %1 : f32 + %5 = arith.mulf %4, %4 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } + %2 = affine.load %alloca_1[] : memref + affine.store %1, %arg1[%arg3] : memref + %3 = arith.divf %2, %cst : f32 + affine.store %3, %arg2[%arg3] : memref + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu.mlir b/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu.mlir new file mode 100644 index 000000000000..b54340264ca5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg6 = 0 to 8 { + affine.for %arg7 = 0 to 16 { + affine.for %arg8 = 0 to 16 { + affine.for %arg9 = 0 to 16 { + %0 = affine.load %arg0[%arg6, %arg7, %arg8, %arg9] : memref + %1 = affine.load %arg1[%arg7] : memref + %2 = arith.subf %0, %1 : f32 + %3 = affine.load %arg2[%arg7] : memref + %4 = arith.mulf %2, %3 : f32 + %5 = affine.load %arg3[%arg7] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = affine.load %arg4[%arg7] : memref + %8 = arith.addf %6, %7 : f32 + affine.store %8, %arg5[%arg6, %arg7, %arg8, %arg9] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu/debuf.mlir new file mode 100644 index 000000000000..aabfcda985ef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu/debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = bufferization.to_tensor %arg5 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c16] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0] [%c16] [1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %3[0] [%c16] [1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %4[0] [%c16] [1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %5[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1, #map1, #map1, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1, %extracted_slice_2, %extracted_slice_3 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_4 : tensor) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %in_7: f32, %in_8: f32, %out: f32): + %8 = arith.subf %in, %in_5 : f32 + %9 = arith.mulf %8, %in_6 : f32 + %10 = arith.mulf %9, %in_7 : f32 + %11 = arith.addf %10, %in_8 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %5[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu/matched.mlir new file mode 100644 index 000000000000..aabfcda985ef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu/matched.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = bufferization.to_tensor %arg5 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c16] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0] [%c16] [1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %3[0] [%c16] [1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %4[0] [%c16] [1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %5[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1, #map1, #map1, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1, %extracted_slice_2, %extracted_slice_3 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_4 : tensor) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %in_7: f32, %in_8: f32, %out: f32): + %8 = arith.subf %in, %in_5 : f32 + %9 = arith.mulf %8, %in_6 : f32 + %10 = arith.mulf %9, %in_7 : f32 + %11 = arith.addf %10, %in_8 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %5[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu/orig.mlir new file mode 100644 index 000000000000..b54340264ca5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg6 = 0 to 8 { + affine.for %arg7 = 0 to 16 { + affine.for %arg8 = 0 to 16 { + affine.for %arg9 = 0 to 16 { + %0 = affine.load %arg0[%arg6, %arg7, %arg8, %arg9] : memref + %1 = affine.load %arg1[%arg7] : memref + %2 = arith.subf %0, %1 : f32 + %3 = affine.load %arg2[%arg7] : memref + %4 = arith.mulf %2, %3 : f32 + %5 = affine.load %arg3[%arg7] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = affine.load %arg4[%arg7] : memref + %8 = arith.addf %6, %7 : f32 + affine.store %8, %arg5[%arg6, %arg7, %arg8, %arg9] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu/raised.mlir new file mode 100644 index 000000000000..1cecccd04b5f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu/raised.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %subview = memref.subview %arg0[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c16] [1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c16] [1] : memref to memref> + %subview_2 = memref.subview %arg3[0] [%c16] [1] : memref to memref> + %subview_3 = memref.subview %arg4[0] [%c16] [1] : memref to memref> + %subview_4 = memref.subview %arg5[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map1, #map1, #map1, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0, %subview_1, %subview_2, %subview_3 : memref>, memref>, memref>, memref>, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %in_7: f32, %in_8: f32, %out: f32): + %0 = arith.subf %in, %in_5 : f32 + %1 = arith.mulf %0, %in_6 : f32 + %2 = arith.mulf %1, %in_7 : f32 + %3 = arith.addf %2, %in_8 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu_debuf.mlir new file mode 100644 index 000000000000..aabfcda985ef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu_debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = bufferization.to_tensor %arg5 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c16] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0] [%c16] [1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %3[0] [%c16] [1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %4[0] [%c16] [1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %5[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1, #map1, #map1, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1, %extracted_slice_2, %extracted_slice_3 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_4 : tensor) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %in_7: f32, %in_8: f32, %out: f32): + %8 = arith.subf %in, %in_5 : f32 + %9 = arith.mulf %8, %in_6 : f32 + %10 = arith.mulf %9, %in_7 : f32 + %11 = arith.addf %10, %in_8 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %5[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu_linalg.mlir new file mode 100644 index 000000000000..1cecccd04b5f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_batch_norm_transform_cpu_linalg.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_batch_norm_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %subview = memref.subview %arg0[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c16] [1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c16] [1] : memref to memref> + %subview_2 = memref.subview %arg3[0] [%c16] [1] : memref to memref> + %subview_3 = memref.subview %arg4[0] [%c16] [1] : memref to memref> + %subview_4 = memref.subview %arg5[0, 0, 0, 0] [%c8, %c16, %c16, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map1, #map1, #map1, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0, %subview_1, %subview_2, %subview_3 : memref>, memref>, memref>, memref>, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %in_7: f32, %in_8: f32, %out: f32): + %0 = arith.subf %in, %in_5 : f32 + %1 = arith.mulf %0, %in_6 : f32 + %2 = arith.mulf %1, %in_7 : f32 + %3 = arith.addf %2, %in_8 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu.mlir b/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu.mlir new file mode 100644 index 000000000000..3831d220fe1d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bernoulli_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf olt, %0, %arg1 : f32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.sitofp %2 : i32 to f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu/debuf.mlir new file mode 100644 index 000000000000..5beeb88ca42b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bernoulli_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %arg1 : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.sitofp %5 : i32 to f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu/matched.mlir new file mode 100644 index 000000000000..5beeb88ca42b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bernoulli_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %arg1 : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.sitofp %5 : i32 to f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu/orig.mlir new file mode 100644 index 000000000000..3831d220fe1d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bernoulli_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf olt, %0, %arg1 : f32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.sitofp %2 : i32 to f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu/raised.mlir new file mode 100644 index 000000000000..0a188273cc3a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bernoulli_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %arg1 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu_debuf.mlir new file mode 100644 index 000000000000..5beeb88ca42b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bernoulli_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %arg1 : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.sitofp %5 : i32 to f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu_linalg.mlir new file mode 100644 index 000000000000..0a188273cc3a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bernoulli_scalar_cpu_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bernoulli_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %arg1 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu.mlir b/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu.mlir new file mode 100644 index 000000000000..fe59c32a046d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bernoulli_tensor_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf olt, %0, %1 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu/debuf.mlir new file mode 100644 index 000000000000..bd6ce756ab3f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bernoulli_tensor_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf olt, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu/matched.mlir new file mode 100644 index 000000000000..bd6ce756ab3f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bernoulli_tensor_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf olt, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu/orig.mlir new file mode 100644 index 000000000000..fe59c32a046d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bernoulli_tensor_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf olt, %0, %1 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu/raised.mlir new file mode 100644 index 000000000000..a32a72ba4ec5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bernoulli_tensor_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf olt, %in, %in_0 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu_debuf.mlir new file mode 100644 index 000000000000..bd6ce756ab3f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bernoulli_tensor_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf olt, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu_linalg.mlir new file mode 100644 index 000000000000..a32a72ba4ec5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bernoulli_tensor_cpu_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bernoulli_tensor_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf olt, %in, %in_0 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_j0.mlir b/issues/aten_c_kernels/results/aten_bessel_j0.mlir new file mode 100644 index 000000000000..d9c17f239556 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_j0.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_j0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @bessel_j0_forwardf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @bessel_j0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_bessel_j0/debuf.mlir b/issues/aten_c_kernels/results/aten_bessel_j0/debuf.mlir new file mode 100644 index 000000000000..e6e6d4970cd3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_j0/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_j0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @bessel_j0_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @bessel_j0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_j0/matched.mlir b/issues/aten_c_kernels/results/aten_bessel_j0/matched.mlir new file mode 100644 index 000000000000..e6e6d4970cd3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_j0/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_j0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @bessel_j0_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @bessel_j0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_j0/orig.mlir b/issues/aten_c_kernels/results/aten_bessel_j0/orig.mlir new file mode 100644 index 000000000000..d9c17f239556 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_j0/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_j0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @bessel_j0_forwardf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @bessel_j0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_bessel_j0/raised.mlir b/issues/aten_c_kernels/results/aten_bessel_j0/raised.mlir new file mode 100644 index 000000000000..3f4d7e213a2f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_j0/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_j0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @bessel_j0_forwardf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @bessel_j0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_j0_debuf.mlir b/issues/aten_c_kernels/results/aten_bessel_j0_debuf.mlir new file mode 100644 index 000000000000..e6e6d4970cd3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_j0_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_j0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @bessel_j0_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @bessel_j0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_j0_linalg.mlir b/issues/aten_c_kernels/results/aten_bessel_j0_linalg.mlir new file mode 100644 index 000000000000..3f4d7e213a2f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_j0_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_j0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @bessel_j0_forwardf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @bessel_j0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_j1.mlir b/issues/aten_c_kernels/results/aten_bessel_j1.mlir new file mode 100644 index 000000000000..8967980b0b69 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_j1.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_j1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @bessel_j1_forwardf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @bessel_j1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_bessel_j1/debuf.mlir b/issues/aten_c_kernels/results/aten_bessel_j1/debuf.mlir new file mode 100644 index 000000000000..487f572ea82d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_j1/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_j1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @bessel_j1_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @bessel_j1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_j1/matched.mlir b/issues/aten_c_kernels/results/aten_bessel_j1/matched.mlir new file mode 100644 index 000000000000..487f572ea82d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_j1/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_j1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @bessel_j1_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @bessel_j1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_j1/orig.mlir b/issues/aten_c_kernels/results/aten_bessel_j1/orig.mlir new file mode 100644 index 000000000000..8967980b0b69 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_j1/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_j1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @bessel_j1_forwardf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @bessel_j1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_bessel_j1/raised.mlir b/issues/aten_c_kernels/results/aten_bessel_j1/raised.mlir new file mode 100644 index 000000000000..6d2971681419 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_j1/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_j1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @bessel_j1_forwardf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @bessel_j1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_j1_debuf.mlir b/issues/aten_c_kernels/results/aten_bessel_j1_debuf.mlir new file mode 100644 index 000000000000..487f572ea82d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_j1_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_j1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @bessel_j1_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @bessel_j1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_j1_linalg.mlir b/issues/aten_c_kernels/results/aten_bessel_j1_linalg.mlir new file mode 100644 index 000000000000..6d2971681419 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_j1_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_j1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @bessel_j1_forwardf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @bessel_j1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_y0.mlir b/issues/aten_c_kernels/results/aten_bessel_y0.mlir new file mode 100644 index 000000000000..4d89779a2e3b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_y0.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_y0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @bessel_y0_forwardf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @bessel_y0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_bessel_y0/debuf.mlir b/issues/aten_c_kernels/results/aten_bessel_y0/debuf.mlir new file mode 100644 index 000000000000..b0a91157615a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_y0/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_y0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @bessel_y0_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @bessel_y0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_y0/matched.mlir b/issues/aten_c_kernels/results/aten_bessel_y0/matched.mlir new file mode 100644 index 000000000000..b0a91157615a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_y0/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_y0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @bessel_y0_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @bessel_y0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_y0/orig.mlir b/issues/aten_c_kernels/results/aten_bessel_y0/orig.mlir new file mode 100644 index 000000000000..4d89779a2e3b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_y0/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_y0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @bessel_y0_forwardf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @bessel_y0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_bessel_y0/raised.mlir b/issues/aten_c_kernels/results/aten_bessel_y0/raised.mlir new file mode 100644 index 000000000000..90739c747023 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_y0/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_y0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @bessel_y0_forwardf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @bessel_y0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_y0_debuf.mlir b/issues/aten_c_kernels/results/aten_bessel_y0_debuf.mlir new file mode 100644 index 000000000000..b0a91157615a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_y0_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_y0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @bessel_y0_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @bessel_y0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_y0_linalg.mlir b/issues/aten_c_kernels/results/aten_bessel_y0_linalg.mlir new file mode 100644 index 000000000000..90739c747023 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_y0_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_y0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @bessel_y0_forwardf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @bessel_y0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_y1.mlir b/issues/aten_c_kernels/results/aten_bessel_y1.mlir new file mode 100644 index 000000000000..2ddf92d77082 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_y1.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_y1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @bessel_y1_forwardf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @bessel_y1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_bessel_y1/debuf.mlir b/issues/aten_c_kernels/results/aten_bessel_y1/debuf.mlir new file mode 100644 index 000000000000..209ccc2d87aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_y1/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_y1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @bessel_y1_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @bessel_y1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_y1/matched.mlir b/issues/aten_c_kernels/results/aten_bessel_y1/matched.mlir new file mode 100644 index 000000000000..209ccc2d87aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_y1/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_y1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @bessel_y1_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @bessel_y1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_y1/orig.mlir b/issues/aten_c_kernels/results/aten_bessel_y1/orig.mlir new file mode 100644 index 000000000000..2ddf92d77082 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_y1/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_y1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @bessel_y1_forwardf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @bessel_y1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_bessel_y1/raised.mlir b/issues/aten_c_kernels/results/aten_bessel_y1/raised.mlir new file mode 100644 index 000000000000..6ba4df336a57 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_y1/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_y1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @bessel_y1_forwardf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @bessel_y1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_y1_debuf.mlir b/issues/aten_c_kernels/results/aten_bessel_y1_debuf.mlir new file mode 100644 index 000000000000..209ccc2d87aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_y1_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_y1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @bessel_y1_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @bessel_y1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bessel_y1_linalg.mlir b/issues/aten_c_kernels/results/aten_bessel_y1_linalg.mlir new file mode 100644 index 000000000000..6ba4df336a57 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bessel_y1_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bessel_y1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @bessel_y1_forwardf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @bessel_y1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_bf16_dot_cpu.mlir b/issues/aten_c_kernels/results/aten_bf16_dot_cpu.mlir new file mode 100644 index 000000000000..62cc17d37202 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bf16_dot_cpu.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bf16_dot_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3] : memref + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg4, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bf16_dot_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_bf16_dot_cpu/debuf.mlir new file mode 100644 index 000000000000..b01fe17ce957 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bf16_dot_cpu/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bf16_dot_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bf16_dot_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_bf16_dot_cpu/matched.mlir new file mode 100644 index 000000000000..fb7504ea95e8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bf16_dot_cpu/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bf16_dot_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = kernel.launch @cublasSdot(%0, %1, %extracted_slice) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bf16_dot_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_bf16_dot_cpu/orig.mlir new file mode 100644 index 000000000000..62cc17d37202 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bf16_dot_cpu/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bf16_dot_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3] : memref + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg4, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bf16_dot_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_bf16_dot_cpu/raised.mlir new file mode 100644 index 000000000000..e50aea50c09a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bf16_dot_cpu/raised.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bf16_dot_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.store %cst, %arg2[0] : memref + %subview = memref.subview %arg2[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%arg0, %arg1 : memref, memref) outs(%subview : memref>) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %in, %in_0 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bf16_dot_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_bf16_dot_cpu_debuf.mlir new file mode 100644 index 000000000000..b01fe17ce957 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bf16_dot_cpu_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bf16_dot_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bf16_dot_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_bf16_dot_cpu_linalg.mlir new file mode 100644 index 000000000000..e50aea50c09a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bf16_dot_cpu_linalg.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bf16_dot_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.store %cst, %arg2[0] : memref + %subview = memref.subview %arg2[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%arg0, %arg1 : memref, memref) outs(%subview : memref>) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %in, %in_0 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu.mlir b/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu.mlir new file mode 100644 index 000000000000..a3ecc5976661 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bf16_gemv_trans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 128 { + %0 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg4, %arg3] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu/debuf.mlir new file mode 100644 index 000000000000..35c35701487b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bf16_gemv_trans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c128 = arith.constant 128 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c128] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c64] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c128] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c128] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu/matched.mlir new file mode 100644 index 000000000000..b7f9db07b242 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bf16_gemv_trans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c128 = arith.constant 128 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = kernel.launch @memset_zero_1D_f32(%2) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c128] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c64] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c128] [1] : tensor to tensor + %4 = kernel.launch @cublasSgemv_T(%extracted_slice, %extracted_slice_0, %extracted_slice_1) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c128] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu/orig.mlir new file mode 100644 index 000000000000..a3ecc5976661 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu/orig.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bf16_gemv_trans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 128 { + %0 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg4, %arg3] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu/raised.mlir new file mode 100644 index 000000000000..0ba8a1966896 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bf16_gemv_trans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c128 = arith.constant 128 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c64, %c128] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c64] [1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c128] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu_debuf.mlir new file mode 100644 index 000000000000..35c35701487b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bf16_gemv_trans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c128 = arith.constant 128 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c128] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c64] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c128] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c128] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu_linalg.mlir new file mode 100644 index 000000000000..0ba8a1966896 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bf16_gemv_trans_cpu_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bf16_gemv_trans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c128 = arith.constant 128 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c64, %c128] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c64] [1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c128] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bilinear_cpu.mlir b/issues/aten_c_kernels/results/aten_bilinear_cpu.mlir new file mode 100644 index 000000000000..b943042b9002 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bilinear_cpu.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bilinear_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 24 { + %0 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg4, %arg6] : memref + %2 = affine.for %arg8 = 0 to 20 iter_args(%arg9 = %arg7) -> (f32) { + %3 = affine.load %arg1[%arg5, %arg6, %arg8] : memref + %4 = arith.mulf %1, %3 : f32 + %5 = affine.load %arg2[%arg4, %arg8] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.addf %arg9, %6 : f32 + affine.yield %7 : f32 + } + affine.yield %2 : f32 + } + affine.store %0, %arg3[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bilinear_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_bilinear_cpu/debuf.mlir new file mode 100644 index 000000000000..6349e16373f6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bilinear_cpu/debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d1, d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bilinear_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c24 = arith.constant 24 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %3[0, 0] [%c8, %c24] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c8, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c24, %c16, %c20] [1, 1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %2[0, 0] [%c8, %c20] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1, %extracted_slice_2 : tensor, tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_3: f32, %in_4: f32, %out: f32): + %7 = arith.mulf %in, %in_3 : f32 + %8 = arith.mulf %7, %in_4 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %3[0, 0] [%c8, %c24] [1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bilinear_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_bilinear_cpu/matched.mlir new file mode 100644 index 000000000000..33ca9434d30a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bilinear_cpu/matched.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d1, d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bilinear_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c24 = arith.constant 24 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %3[0, 0] [%c8, %c24] [1, 1] : tensor to tensor + %4 = kernel.launch @memset_zero_2D_f32(%extracted_slice) : (tensor) -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c8, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c24, %c16, %c20] [1, 1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %2[0, 0] [%c8, %c20] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1, %extracted_slice_2 : tensor, tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_3: f32, %in_4: f32, %out: f32): + %7 = arith.mulf %in, %in_3 : f32 + %8 = arith.mulf %7, %in_4 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %3[0, 0] [%c8, %c24] [1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bilinear_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_bilinear_cpu/orig.mlir new file mode 100644 index 000000000000..b943042b9002 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bilinear_cpu/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bilinear_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 24 { + %0 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg4, %arg6] : memref + %2 = affine.for %arg8 = 0 to 20 iter_args(%arg9 = %arg7) -> (f32) { + %3 = affine.load %arg1[%arg5, %arg6, %arg8] : memref + %4 = arith.mulf %1, %3 : f32 + %5 = affine.load %arg2[%arg4, %arg8] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.addf %arg9, %6 : f32 + affine.yield %7 : f32 + } + affine.yield %2 : f32 + } + affine.store %0, %arg3[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bilinear_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_bilinear_cpu/raised.mlir new file mode 100644 index 000000000000..4d3a3b3898bc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bilinear_cpu/raised.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d1, d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bilinear_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c24 = arith.constant 24 : index + %c16 = arith.constant 16 : index + %c20 = arith.constant 20 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg3[0, 0] [%c8, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0] [%c8, %c16] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0] [%c24, %c16, %c20] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0] [%c8, %c20] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg3[0, 0] [%c8, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%subview_0, %subview_1, %subview_2 : memref>, memref>, memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f32, %in_4: f32, %in_5: f32, %out: f32): + %0 = arith.mulf %in, %in_4 : f32 + %1 = arith.mulf %0, %in_5 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bilinear_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_bilinear_cpu_debuf.mlir new file mode 100644 index 000000000000..6349e16373f6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bilinear_cpu_debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d1, d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bilinear_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c24 = arith.constant 24 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %3[0, 0] [%c8, %c24] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c8, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c24, %c16, %c20] [1, 1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %2[0, 0] [%c8, %c20] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1, %extracted_slice_2 : tensor, tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_3: f32, %in_4: f32, %out: f32): + %7 = arith.mulf %in, %in_3 : f32 + %8 = arith.mulf %7, %in_4 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %3[0, 0] [%c8, %c24] [1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bilinear_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_bilinear_cpu_linalg.mlir new file mode 100644 index 000000000000..4d3a3b3898bc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bilinear_cpu_linalg.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d1, d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bilinear_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c24 = arith.constant 24 : index + %c16 = arith.constant 16 : index + %c20 = arith.constant 20 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg3[0, 0] [%c8, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0] [%c8, %c16] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0] [%c24, %c16, %c20] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0] [%c8, %c20] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg3[0, 0] [%c8, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%subview_0, %subview_1, %subview_2 : memref>, memref>, memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f32, %in_4: f32, %in_5: f32, %out: f32): + %0 = arith.mulf %in, %in_4 : f32 + %1 = arith.mulf %0, %in_5 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_binary_cross_entropy.mlir b/issues/aten_c_kernels/results/aten_binary_cross_entropy.mlir new file mode 100644 index 000000000000..35b8e508f716 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binary_cross_entropy.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binary_cross_entropy(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.560000e+02 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + affine.store %cst_1, %arg2[0] : memref + affine.for %arg3 = 0 to 256 { + %2 = affine.load %arg1[%arg3] : memref + %3 = affine.load %arg0[%arg3] : memref + %4 = func.call @logf(%3) : (f32) -> f32 + %5 = arith.mulf %2, %4 : f32 + %6 = affine.load %arg1[%arg3] : memref + %7 = arith.subf %cst_0, %6 : f32 + %8 = affine.load %arg0[%arg3] : memref + %9 = arith.subf %cst_0, %8 : f32 + %10 = func.call @logf(%9) : (f32) -> f32 + %11 = arith.mulf %7, %10 : f32 + %12 = arith.addf %5, %11 : f32 + %13 = affine.load %arg2[0] : memref + %14 = arith.subf %13, %12 : f32 + affine.store %14, %arg2[0] : memref + } + %0 = affine.load %arg2[0] : memref + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg2[0] : memref + return + } + func.func private @logf(f32) -> f32 +} diff --git a/issues/aten_c_kernels/results/aten_binary_cross_entropy/cgeist.err b/issues/aten_c_kernels/results/aten_binary_cross_entropy/cgeist.err new file mode 100644 index 000000000000..a080fb775fde --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binary_cross_entropy/cgeist.err @@ -0,0 +1,2 @@ +warning: we fall back to libc call for __builtin_logf +warning: we fall back to libc call for __builtin_logf diff --git a/issues/aten_c_kernels/results/aten_binary_cross_entropy/debuf.mlir b/issues/aten_c_kernels/results/aten_binary_cross_entropy/debuf.mlir new file mode 100644 index 000000000000..10f893930fc8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binary_cross_entropy/debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binary_cross_entropy(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 2.560000e+02 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%1, %0, %1, %0 : tensor, tensor, tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_3: f32, %in_4: f32, %in_5: f32, %out: f32): + %6 = math.log %in_3 : f32 + %7 = arith.mulf %in, %6 : f32 + %8 = arith.subf %cst_0, %in_4 : f32 + %9 = arith.subf %cst_0, %in_5 : f32 + %10 = math.log %9 : f32 + %11 = arith.mulf %8, %10 : f32 + %12 = arith.addf %7, %11 : f32 + %13 = arith.subf %out, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %extracted = tensor.extract %inserted_slice[%c0] : tensor + %4 = arith.divf %extracted, %cst_1 : f32 + %inserted_2 = tensor.insert %4 into %inserted_slice[%c0] : tensor + %5 = bufferization.to_memref %inserted_2 : memref + memref.copy %5, %arg2 : memref to memref + return + } + func.func private @logf(f32) -> f32 +} + diff --git a/issues/aten_c_kernels/results/aten_binary_cross_entropy/matched.mlir b/issues/aten_c_kernels/results/aten_binary_cross_entropy/matched.mlir new file mode 100644 index 000000000000..10f893930fc8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binary_cross_entropy/matched.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binary_cross_entropy(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 2.560000e+02 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%1, %0, %1, %0 : tensor, tensor, tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_3: f32, %in_4: f32, %in_5: f32, %out: f32): + %6 = math.log %in_3 : f32 + %7 = arith.mulf %in, %6 : f32 + %8 = arith.subf %cst_0, %in_4 : f32 + %9 = arith.subf %cst_0, %in_5 : f32 + %10 = math.log %9 : f32 + %11 = arith.mulf %8, %10 : f32 + %12 = arith.addf %7, %11 : f32 + %13 = arith.subf %out, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %extracted = tensor.extract %inserted_slice[%c0] : tensor + %4 = arith.divf %extracted, %cst_1 : f32 + %inserted_2 = tensor.insert %4 into %inserted_slice[%c0] : tensor + %5 = bufferization.to_memref %inserted_2 : memref + memref.copy %5, %arg2 : memref to memref + return + } + func.func private @logf(f32) -> f32 +} + diff --git a/issues/aten_c_kernels/results/aten_binary_cross_entropy/orig.mlir b/issues/aten_c_kernels/results/aten_binary_cross_entropy/orig.mlir new file mode 100644 index 000000000000..35b8e508f716 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binary_cross_entropy/orig.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binary_cross_entropy(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.560000e+02 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + affine.store %cst_1, %arg2[0] : memref + affine.for %arg3 = 0 to 256 { + %2 = affine.load %arg1[%arg3] : memref + %3 = affine.load %arg0[%arg3] : memref + %4 = func.call @logf(%3) : (f32) -> f32 + %5 = arith.mulf %2, %4 : f32 + %6 = affine.load %arg1[%arg3] : memref + %7 = arith.subf %cst_0, %6 : f32 + %8 = affine.load %arg0[%arg3] : memref + %9 = arith.subf %cst_0, %8 : f32 + %10 = func.call @logf(%9) : (f32) -> f32 + %11 = arith.mulf %7, %10 : f32 + %12 = arith.addf %5, %11 : f32 + %13 = affine.load %arg2[0] : memref + %14 = arith.subf %13, %12 : f32 + affine.store %14, %arg2[0] : memref + } + %0 = affine.load %arg2[0] : memref + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg2[0] : memref + return + } + func.func private @logf(f32) -> f32 +} diff --git a/issues/aten_c_kernels/results/aten_binary_cross_entropy/raised.mlir b/issues/aten_c_kernels/results/aten_binary_cross_entropy/raised.mlir new file mode 100644 index 000000000000..d16f3b6b34b7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binary_cross_entropy/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binary_cross_entropy(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.560000e+02 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + affine.store %cst_1, %arg2[0] : memref + %subview = memref.subview %arg2[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map1], iterator_types = ["reduction"]} ins(%arg1, %arg0, %arg1, %arg0 : memref, memref, memref, memref) outs(%subview : memref>) { + ^bb0(%in: f32, %in_2: f32, %in_3: f32, %in_4: f32, %out: f32): + %2 = math.log %in_2 : f32 + %3 = arith.mulf %in, %2 : f32 + %4 = arith.subf %cst_0, %in_3 : f32 + %5 = arith.subf %cst_0, %in_4 : f32 + %6 = math.log %5 : f32 + %7 = arith.mulf %4, %6 : f32 + %8 = arith.addf %3, %7 : f32 + %9 = arith.subf %out, %8 : f32 + linalg.yield %9 : f32 + } + %0 = affine.load %arg2[0] : memref + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg2[0] : memref + return + } + func.func private @logf(f32) -> f32 +} + diff --git a/issues/aten_c_kernels/results/aten_binary_cross_entropy_debuf.mlir b/issues/aten_c_kernels/results/aten_binary_cross_entropy_debuf.mlir new file mode 100644 index 000000000000..10f893930fc8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binary_cross_entropy_debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binary_cross_entropy(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 2.560000e+02 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%1, %0, %1, %0 : tensor, tensor, tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_3: f32, %in_4: f32, %in_5: f32, %out: f32): + %6 = math.log %in_3 : f32 + %7 = arith.mulf %in, %6 : f32 + %8 = arith.subf %cst_0, %in_4 : f32 + %9 = arith.subf %cst_0, %in_5 : f32 + %10 = math.log %9 : f32 + %11 = arith.mulf %8, %10 : f32 + %12 = arith.addf %7, %11 : f32 + %13 = arith.subf %out, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %extracted = tensor.extract %inserted_slice[%c0] : tensor + %4 = arith.divf %extracted, %cst_1 : f32 + %inserted_2 = tensor.insert %4 into %inserted_slice[%c0] : tensor + %5 = bufferization.to_memref %inserted_2 : memref + memref.copy %5, %arg2 : memref to memref + return + } + func.func private @logf(f32) -> f32 +} + diff --git a/issues/aten_c_kernels/results/aten_binary_cross_entropy_linalg.mlir b/issues/aten_c_kernels/results/aten_binary_cross_entropy_linalg.mlir new file mode 100644 index 000000000000..d16f3b6b34b7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binary_cross_entropy_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binary_cross_entropy(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.560000e+02 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + affine.store %cst_1, %arg2[0] : memref + %subview = memref.subview %arg2[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map1], iterator_types = ["reduction"]} ins(%arg1, %arg0, %arg1, %arg0 : memref, memref, memref, memref) outs(%subview : memref>) { + ^bb0(%in: f32, %in_2: f32, %in_3: f32, %in_4: f32, %out: f32): + %2 = math.log %in_2 : f32 + %3 = arith.mulf %in, %2 : f32 + %4 = arith.subf %cst_0, %in_3 : f32 + %5 = arith.subf %cst_0, %in_4 : f32 + %6 = math.log %5 : f32 + %7 = arith.mulf %4, %6 : f32 + %8 = arith.addf %3, %7 : f32 + %9 = arith.subf %out, %8 : f32 + linalg.yield %9 : f32 + } + %0 = affine.load %arg2[0] : memref + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg2[0] : memref + return + } + func.func private @logf(f32) -> f32 +} + diff --git a/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu.mlir b/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu.mlir new file mode 100644 index 000000000000..b5902f3e4a8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binary_search_strided_rightmost_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c512_i32 = arith.constant 512 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0:2 = scf.while (%arg4 = %c512_i32, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %2 = arith.cmpi slt, %arg5, %arg4 : i32 + scf.condition(%2) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %2 = arith.addi %arg4, %arg5 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg0[%4] : memref + %6 = affine.load %arg1[%arg3] : memref + %7 = arith.cmpi sle, %5, %6 : i32 + %8 = arith.select %7, %arg5, %3 : i32 + %9 = scf.if %7 -> (i32) { + %10 = arith.addi %3, %c1_i32 : i32 + scf.yield %10 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %8, %9 : i32, i32 + } + %1 = arith.addi %0#0, %c-1_i32 : i32 + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu/debuf.mlir new file mode 100644 index 000000000000..650f06f6d8d6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu/debuf.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binary_search_strided_rightmost_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c512_i32 = arith.constant 512 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c-1_i32 = arith.constant -1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c512_i32, %arg6 = %c0_i32) : (i32, i32) -> (i32, i32) { + %7 = arith.cmpi slt, %arg6, %arg5 : i32 + scf.condition(%7) %arg6, %arg5 : i32, i32 + } do { + ^bb0(%arg5: i32, %arg6: i32): + %7 = arith.addi %arg5, %arg6 : i32 + %8 = arith.divsi %7, %c2_i32 : i32 + %9 = arith.index_cast %8 : i32 to index + %extracted = tensor.extract %2[%9] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %10 = arith.cmpi sle, %extracted, %extracted_0 : i32 + %11 = arith.select %10, %arg6, %8 : i32 + %12 = arith.addi %8, %c1_i32 : i32 + %13 = arith.select %10, %12, %arg5 : i32 + scf.yield %11, %13 : i32, i32 + } + %6 = arith.addi %5#0, %c-1_i32 : i32 + %inserted = tensor.insert %6 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu/matched.mlir new file mode 100644 index 000000000000..650f06f6d8d6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu/matched.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binary_search_strided_rightmost_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c512_i32 = arith.constant 512 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c-1_i32 = arith.constant -1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c512_i32, %arg6 = %c0_i32) : (i32, i32) -> (i32, i32) { + %7 = arith.cmpi slt, %arg6, %arg5 : i32 + scf.condition(%7) %arg6, %arg5 : i32, i32 + } do { + ^bb0(%arg5: i32, %arg6: i32): + %7 = arith.addi %arg5, %arg6 : i32 + %8 = arith.divsi %7, %c2_i32 : i32 + %9 = arith.index_cast %8 : i32 to index + %extracted = tensor.extract %2[%9] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %10 = arith.cmpi sle, %extracted, %extracted_0 : i32 + %11 = arith.select %10, %arg6, %8 : i32 + %12 = arith.addi %8, %c1_i32 : i32 + %13 = arith.select %10, %12, %arg5 : i32 + scf.yield %11, %13 : i32, i32 + } + %6 = arith.addi %5#0, %c-1_i32 : i32 + %inserted = tensor.insert %6 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu/orig.mlir new file mode 100644 index 000000000000..b5902f3e4a8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu/orig.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binary_search_strided_rightmost_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c512_i32 = arith.constant 512 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0:2 = scf.while (%arg4 = %c512_i32, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %2 = arith.cmpi slt, %arg5, %arg4 : i32 + scf.condition(%2) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %2 = arith.addi %arg4, %arg5 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg0[%4] : memref + %6 = affine.load %arg1[%arg3] : memref + %7 = arith.cmpi sle, %5, %6 : i32 + %8 = arith.select %7, %arg5, %3 : i32 + %9 = scf.if %7 -> (i32) { + %10 = arith.addi %3, %c1_i32 : i32 + scf.yield %10 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %8, %9 : i32, i32 + } + %1 = arith.addi %0#0, %c-1_i32 : i32 + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu/raised.mlir new file mode 100644 index 000000000000..36c105bac7a8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu/raised.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binary_search_strided_rightmost_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c512_i32 = arith.constant 512 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0:2 = scf.while (%arg4 = %c512_i32, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %2 = arith.cmpi slt, %arg5, %arg4 : i32 + scf.condition(%2) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %2 = arith.addi %arg4, %arg5 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg0[%4] : memref + %6 = affine.load %arg1[%arg3] : memref + %7 = arith.cmpi sle, %5, %6 : i32 + %8 = arith.select %7, %arg5, %3 : i32 + %9 = arith.addi %3, %c1_i32 : i32 + %10 = arith.select %7, %9, %arg4 : i32 + scf.yield %8, %10 : i32, i32 + } + %1 = arith.addi %0#0, %c-1_i32 : i32 + affine.store %1, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu_debuf.mlir new file mode 100644 index 000000000000..650f06f6d8d6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu_debuf.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binary_search_strided_rightmost_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c512_i32 = arith.constant 512 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c-1_i32 = arith.constant -1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c512_i32, %arg6 = %c0_i32) : (i32, i32) -> (i32, i32) { + %7 = arith.cmpi slt, %arg6, %arg5 : i32 + scf.condition(%7) %arg6, %arg5 : i32, i32 + } do { + ^bb0(%arg5: i32, %arg6: i32): + %7 = arith.addi %arg5, %arg6 : i32 + %8 = arith.divsi %7, %c2_i32 : i32 + %9 = arith.index_cast %8 : i32 to index + %extracted = tensor.extract %2[%9] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %10 = arith.cmpi sle, %extracted, %extracted_0 : i32 + %11 = arith.select %10, %arg6, %8 : i32 + %12 = arith.addi %8, %c1_i32 : i32 + %13 = arith.select %10, %12, %arg5 : i32 + scf.yield %11, %13 : i32, i32 + } + %6 = arith.addi %5#0, %c-1_i32 : i32 + %inserted = tensor.insert %6 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu_linalg.mlir new file mode 100644 index 000000000000..36c105bac7a8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binary_search_strided_rightmost_cpu_linalg.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binary_search_strided_rightmost_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c512_i32 = arith.constant 512 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0:2 = scf.while (%arg4 = %c512_i32, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %2 = arith.cmpi slt, %arg5, %arg4 : i32 + scf.condition(%2) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %2 = arith.addi %arg4, %arg5 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg0[%4] : memref + %6 = affine.load %arg1[%arg3] : memref + %7 = arith.cmpi sle, %5, %6 : i32 + %8 = arith.select %7, %arg5, %3 : i32 + %9 = arith.addi %3, %c1_i32 : i32 + %10 = arith.select %7, %9, %arg4 : i32 + scf.yield %8, %10 : i32, i32 + } + %1 = arith.addi %0#0, %c-1_i32 : i32 + affine.store %1, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bincount_cpu.mlir b/issues/aten_c_kernels/results/aten_bincount_cpu.mlir new file mode 100644 index 000000000000..e6e13b7b728f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bincount_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bincount_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + affine.store %cst, %arg2[%arg3] : memref + } + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg1[%arg3] : memref + %3 = memref.load %arg2[%1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg2[%1] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bincount_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_bincount_cpu/debuf.mlir new file mode 100644 index 000000000000..3052f431d91a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bincount_cpu/debuf.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bincount_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %3) -> (tensor) { + %extracted = tensor.extract %2[%arg3] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %1[%arg3] : tensor + %extracted_1 = tensor.extract %arg4[%6] : tensor + %7 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %7 into %arg4[%6] : tensor + affine.yield %inserted : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bincount_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_bincount_cpu/matched.mlir new file mode 100644 index 000000000000..ccb77ac7f828 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bincount_cpu/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bincount_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %4 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %3) -> (tensor) { + %extracted = tensor.extract %2[%arg3] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %1[%arg3] : tensor + %extracted_1 = tensor.extract %arg4[%6] : tensor + %7 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %7 into %arg4[%6] : tensor + affine.yield %inserted : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bincount_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_bincount_cpu/orig.mlir new file mode 100644 index 000000000000..e6e13b7b728f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bincount_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bincount_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + affine.store %cst, %arg2[%arg3] : memref + } + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg1[%arg3] : memref + %3 = memref.load %arg2[%1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg2[%1] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bincount_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_bincount_cpu/raised.mlir new file mode 100644 index 000000000000..e8c641b22b4d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bincount_cpu/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bincount_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg1[%arg3] : memref + %3 = memref.load %arg2[%1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg2[%1] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bincount_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_bincount_cpu_debuf.mlir new file mode 100644 index 000000000000..3052f431d91a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bincount_cpu_debuf.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bincount_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %3) -> (tensor) { + %extracted = tensor.extract %2[%arg3] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %1[%arg3] : tensor + %extracted_1 = tensor.extract %arg4[%6] : tensor + %7 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %7 into %arg4[%6] : tensor + affine.yield %inserted : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bincount_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_bincount_cpu_linalg.mlir new file mode 100644 index 000000000000..e8c641b22b4d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bincount_cpu_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bincount_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg1[%arg3] : memref + %3 = memref.load %arg2[%1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg2[%1] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_binomial_transform_cpu.mlir b/issues/aten_c_kernels/results/aten_binomial_transform_cpu.mlir new file mode 100644 index 000000000000..2faaec62a428 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binomial_transform_cpu.mlir @@ -0,0 +1,38 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binomial_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c32_i32 = arith.constant 32 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 1024 { + %0:2 = scf.while (%arg5 = %c0_i32, %arg6 = %c0_i32) : (i32, i32) -> (i32, i32) { + %1 = arith.cmpi slt, %arg5, %c32_i32 : i32 + %2:3 = scf.if %1 -> (i1, i32, i32) { + %3 = affine.load %arg0[%arg4] : memref + %4 = arith.cmpi slt, %arg5, %3 : i32 + %5:2 = scf.if %4 -> (i32, i32) { + %6 = arith.index_cast %arg5 : i32 to index + %7 = memref.load %arg2[%arg4, %6] : memref + %8 = affine.load %arg1[%arg4] : memref + %9 = arith.cmpf olt, %7, %8 : f32 + %10 = arith.extui %9 : i1 to i32 + %11 = arith.addi %arg6, %10 : i32 + %12 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %12, %11 : i32, i32 + } else { + scf.yield %arg5, %arg6 : i32, i32 + } + scf.yield %4, %5#0, %5#1 : i1, i32, i32 + } else { + scf.yield %false, %arg5, %arg6 : i1, i32, i32 + } + scf.condition(%2#0) %2#1, %2#2 : i32, i32 + } do { + ^bb0(%arg5: i32, %arg6: i32): + scf.yield %arg5, %arg6 : i32, i32 + } + affine.store %0#1, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_binomial_transform_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_binomial_transform_cpu/debuf.mlir new file mode 100644 index 000000000000..d0931c9ad0b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binomial_transform_cpu/debuf.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binomial_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c32_i32 = arith.constant 32 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = affine.for %arg4 = 0 to 1024 iter_args(%arg5 = %0) -> (tensor) { + %6:2 = scf.while (%arg6 = %c0_i32, %arg7 = %c0_i32) : (i32, i32) -> (i32, i32) { + %7 = arith.cmpi slt, %arg6, %c32_i32 : i32 + %extracted = tensor.extract %3[%arg4] : tensor + %8 = arith.cmpi slt, %arg6, %extracted : i32 + %9 = arith.index_cast %arg6 : i32 to index + %extracted_0 = tensor.extract %1[%arg4, %9] : tensor + %extracted_1 = tensor.extract %2[%arg4] : tensor + %10 = arith.cmpf olt, %extracted_0, %extracted_1 : f32 + %11 = arith.extui %10 : i1 to i32 + %12 = arith.addi %arg7, %11 : i32 + %13 = arith.addi %arg6, %c1_i32 : i32 + %14 = arith.select %8, %13, %arg6 : i32 + %15 = arith.select %8, %12, %arg7 : i32 + %16 = arith.select %7, %8, %false : i1 + %17 = arith.select %7, %14, %arg6 : i32 + %18 = arith.select %7, %15, %arg7 : i32 + scf.condition(%16) %17, %18 : i32, i32 + } do { + ^bb0(%arg6: i32, %arg7: i32): + scf.yield %arg6, %arg7 : i32, i32 + } + %inserted = tensor.insert %6#1 into %arg5[%arg4] : tensor + affine.yield %inserted : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_binomial_transform_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_binomial_transform_cpu/matched.mlir new file mode 100644 index 000000000000..d0931c9ad0b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binomial_transform_cpu/matched.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binomial_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c32_i32 = arith.constant 32 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = affine.for %arg4 = 0 to 1024 iter_args(%arg5 = %0) -> (tensor) { + %6:2 = scf.while (%arg6 = %c0_i32, %arg7 = %c0_i32) : (i32, i32) -> (i32, i32) { + %7 = arith.cmpi slt, %arg6, %c32_i32 : i32 + %extracted = tensor.extract %3[%arg4] : tensor + %8 = arith.cmpi slt, %arg6, %extracted : i32 + %9 = arith.index_cast %arg6 : i32 to index + %extracted_0 = tensor.extract %1[%arg4, %9] : tensor + %extracted_1 = tensor.extract %2[%arg4] : tensor + %10 = arith.cmpf olt, %extracted_0, %extracted_1 : f32 + %11 = arith.extui %10 : i1 to i32 + %12 = arith.addi %arg7, %11 : i32 + %13 = arith.addi %arg6, %c1_i32 : i32 + %14 = arith.select %8, %13, %arg6 : i32 + %15 = arith.select %8, %12, %arg7 : i32 + %16 = arith.select %7, %8, %false : i1 + %17 = arith.select %7, %14, %arg6 : i32 + %18 = arith.select %7, %15, %arg7 : i32 + scf.condition(%16) %17, %18 : i32, i32 + } do { + ^bb0(%arg6: i32, %arg7: i32): + scf.yield %arg6, %arg7 : i32, i32 + } + %inserted = tensor.insert %6#1 into %arg5[%arg4] : tensor + affine.yield %inserted : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_binomial_transform_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_binomial_transform_cpu/orig.mlir new file mode 100644 index 000000000000..2faaec62a428 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binomial_transform_cpu/orig.mlir @@ -0,0 +1,38 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binomial_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c32_i32 = arith.constant 32 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 1024 { + %0:2 = scf.while (%arg5 = %c0_i32, %arg6 = %c0_i32) : (i32, i32) -> (i32, i32) { + %1 = arith.cmpi slt, %arg5, %c32_i32 : i32 + %2:3 = scf.if %1 -> (i1, i32, i32) { + %3 = affine.load %arg0[%arg4] : memref + %4 = arith.cmpi slt, %arg5, %3 : i32 + %5:2 = scf.if %4 -> (i32, i32) { + %6 = arith.index_cast %arg5 : i32 to index + %7 = memref.load %arg2[%arg4, %6] : memref + %8 = affine.load %arg1[%arg4] : memref + %9 = arith.cmpf olt, %7, %8 : f32 + %10 = arith.extui %9 : i1 to i32 + %11 = arith.addi %arg6, %10 : i32 + %12 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %12, %11 : i32, i32 + } else { + scf.yield %arg5, %arg6 : i32, i32 + } + scf.yield %4, %5#0, %5#1 : i1, i32, i32 + } else { + scf.yield %false, %arg5, %arg6 : i1, i32, i32 + } + scf.condition(%2#0) %2#1, %2#2 : i32, i32 + } do { + ^bb0(%arg5: i32, %arg6: i32): + scf.yield %arg5, %arg6 : i32, i32 + } + affine.store %0#1, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_binomial_transform_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_binomial_transform_cpu/raised.mlir new file mode 100644 index 000000000000..60dd66aab534 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binomial_transform_cpu/raised.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binomial_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c32_i32 = arith.constant 32 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 1024 { + %0:2 = scf.while (%arg5 = %c0_i32, %arg6 = %c0_i32) : (i32, i32) -> (i32, i32) { + %1 = arith.cmpi slt, %arg5, %c32_i32 : i32 + %2 = affine.load %arg0[%arg4] : memref + %3 = arith.cmpi slt, %arg5, %2 : i32 + %4 = arith.index_cast %arg5 : i32 to index + %5 = memref.load %arg2[%arg4, %4] : memref + %6 = affine.load %arg1[%arg4] : memref + %7 = arith.cmpf olt, %5, %6 : f32 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.addi %arg6, %8 : i32 + %10 = arith.addi %arg5, %c1_i32 : i32 + %11 = arith.select %3, %10, %arg5 : i32 + %12 = arith.select %3, %9, %arg6 : i32 + %13 = arith.select %1, %3, %false : i1 + %14 = arith.select %1, %11, %arg5 : i32 + %15 = arith.select %1, %12, %arg6 : i32 + scf.condition(%13) %14, %15 : i32, i32 + } do { + ^bb0(%arg5: i32, %arg6: i32): + scf.yield %arg5, %arg6 : i32, i32 + } + affine.store %0#1, %arg3[%arg4] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_binomial_transform_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_binomial_transform_cpu_debuf.mlir new file mode 100644 index 000000000000..d0931c9ad0b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binomial_transform_cpu_debuf.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binomial_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c32_i32 = arith.constant 32 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = affine.for %arg4 = 0 to 1024 iter_args(%arg5 = %0) -> (tensor) { + %6:2 = scf.while (%arg6 = %c0_i32, %arg7 = %c0_i32) : (i32, i32) -> (i32, i32) { + %7 = arith.cmpi slt, %arg6, %c32_i32 : i32 + %extracted = tensor.extract %3[%arg4] : tensor + %8 = arith.cmpi slt, %arg6, %extracted : i32 + %9 = arith.index_cast %arg6 : i32 to index + %extracted_0 = tensor.extract %1[%arg4, %9] : tensor + %extracted_1 = tensor.extract %2[%arg4] : tensor + %10 = arith.cmpf olt, %extracted_0, %extracted_1 : f32 + %11 = arith.extui %10 : i1 to i32 + %12 = arith.addi %arg7, %11 : i32 + %13 = arith.addi %arg6, %c1_i32 : i32 + %14 = arith.select %8, %13, %arg6 : i32 + %15 = arith.select %8, %12, %arg7 : i32 + %16 = arith.select %7, %8, %false : i1 + %17 = arith.select %7, %14, %arg6 : i32 + %18 = arith.select %7, %15, %arg7 : i32 + scf.condition(%16) %17, %18 : i32, i32 + } do { + ^bb0(%arg6: i32, %arg7: i32): + scf.yield %arg6, %arg7 : i32, i32 + } + %inserted = tensor.insert %6#1 into %arg5[%arg4] : tensor + affine.yield %inserted : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_binomial_transform_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_binomial_transform_cpu_linalg.mlir new file mode 100644 index 000000000000..60dd66aab534 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_binomial_transform_cpu_linalg.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_binomial_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c32_i32 = arith.constant 32 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 1024 { + %0:2 = scf.while (%arg5 = %c0_i32, %arg6 = %c0_i32) : (i32, i32) -> (i32, i32) { + %1 = arith.cmpi slt, %arg5, %c32_i32 : i32 + %2 = affine.load %arg0[%arg4] : memref + %3 = arith.cmpi slt, %arg5, %2 : i32 + %4 = arith.index_cast %arg5 : i32 to index + %5 = memref.load %arg2[%arg4, %4] : memref + %6 = affine.load %arg1[%arg4] : memref + %7 = arith.cmpf olt, %5, %6 : f32 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.addi %arg6, %8 : i32 + %10 = arith.addi %arg5, %c1_i32 : i32 + %11 = arith.select %3, %10, %arg5 : i32 + %12 = arith.select %3, %9, %arg6 : i32 + %13 = arith.select %1, %3, %false : i1 + %14 = arith.select %1, %11, %arg5 : i32 + %15 = arith.select %1, %12, %arg6 : i32 + scf.condition(%13) %14, %15 : i32, i32 + } do { + ^bb0(%arg5: i32, %arg6: i32): + scf.yield %arg5, %arg6 : i32, i32 + } + affine.store %0#1, %arg3[%arg4] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_and_i32.mlir b/issues/aten_c_kernels/results/aten_bitwise_and_i32.mlir new file mode 100644 index 000000000000..b50612fb6f51 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_and_i32.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_and_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.andi %0, %1 : i32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bitwise_and_i32/debuf.mlir b/issues/aten_c_kernels/results/aten_bitwise_and_i32/debuf.mlir new file mode 100644 index 000000000000..4fd112f77333 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_and_i32/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_and_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.andi %in, %in_0 : i32 + linalg.yield %5 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_and_i32/matched.mlir b/issues/aten_c_kernels/results/aten_bitwise_and_i32/matched.mlir new file mode 100644 index 000000000000..4fd112f77333 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_and_i32/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_and_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.andi %in, %in_0 : i32 + linalg.yield %5 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_and_i32/orig.mlir b/issues/aten_c_kernels/results/aten_bitwise_and_i32/orig.mlir new file mode 100644 index 000000000000..b50612fb6f51 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_and_i32/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_and_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.andi %0, %1 : i32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bitwise_and_i32/raised.mlir b/issues/aten_c_kernels/results/aten_bitwise_and_i32/raised.mlir new file mode 100644 index 000000000000..97f636e8c96e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_and_i32/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_and_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %0 = arith.andi %in, %in_0 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_and_i32_debuf.mlir b/issues/aten_c_kernels/results/aten_bitwise_and_i32_debuf.mlir new file mode 100644 index 000000000000..4fd112f77333 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_and_i32_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_and_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.andi %in, %in_0 : i32 + linalg.yield %5 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_and_i32_linalg.mlir b/issues/aten_c_kernels/results/aten_bitwise_and_i32_linalg.mlir new file mode 100644 index 000000000000..97f636e8c96e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_and_i32_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_and_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %0 = arith.andi %in, %in_0 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_not_i32.mlir b/issues/aten_c_kernels/results/aten_bitwise_not_i32.mlir new file mode 100644 index 000000000000..3cc674b784bf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_not_i32.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_not_i32(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.xori %0, %c-1_i32 : i32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bitwise_not_i32/debuf.mlir b/issues/aten_c_kernels/results/aten_bitwise_not_i32/debuf.mlir new file mode 100644 index 000000000000..a2548fcc0e1f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_not_i32/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_not_i32(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + %4 = arith.xori %in, %c-1_i32 : i32 + linalg.yield %4 : i32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_not_i32/matched.mlir b/issues/aten_c_kernels/results/aten_bitwise_not_i32/matched.mlir new file mode 100644 index 000000000000..a2548fcc0e1f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_not_i32/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_not_i32(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + %4 = arith.xori %in, %c-1_i32 : i32 + linalg.yield %4 : i32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_not_i32/orig.mlir b/issues/aten_c_kernels/results/aten_bitwise_not_i32/orig.mlir new file mode 100644 index 000000000000..3cc674b784bf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_not_i32/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_not_i32(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.xori %0, %c-1_i32 : i32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bitwise_not_i32/raised.mlir b/issues/aten_c_kernels/results/aten_bitwise_not_i32/raised.mlir new file mode 100644 index 000000000000..b401cb17cde9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_not_i32/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_not_i32(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: i32, %out: i32): + %0 = arith.xori %in, %c-1_i32 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_not_i32_debuf.mlir b/issues/aten_c_kernels/results/aten_bitwise_not_i32_debuf.mlir new file mode 100644 index 000000000000..a2548fcc0e1f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_not_i32_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_not_i32(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + %4 = arith.xori %in, %c-1_i32 : i32 + linalg.yield %4 : i32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_not_i32_linalg.mlir b/issues/aten_c_kernels/results/aten_bitwise_not_i32_linalg.mlir new file mode 100644 index 000000000000..b401cb17cde9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_not_i32_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_not_i32(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: i32, %out: i32): + %0 = arith.xori %in, %c-1_i32 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_or_i32.mlir b/issues/aten_c_kernels/results/aten_bitwise_or_i32.mlir new file mode 100644 index 000000000000..c86cebacfbd1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_or_i32.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_or_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.ori %0, %1 : i32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bitwise_or_i32/debuf.mlir b/issues/aten_c_kernels/results/aten_bitwise_or_i32/debuf.mlir new file mode 100644 index 000000000000..64faafa9b26e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_or_i32/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_or_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.ori %in, %in_0 : i32 + linalg.yield %5 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_or_i32/matched.mlir b/issues/aten_c_kernels/results/aten_bitwise_or_i32/matched.mlir new file mode 100644 index 000000000000..64faafa9b26e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_or_i32/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_or_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.ori %in, %in_0 : i32 + linalg.yield %5 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_or_i32/orig.mlir b/issues/aten_c_kernels/results/aten_bitwise_or_i32/orig.mlir new file mode 100644 index 000000000000..c86cebacfbd1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_or_i32/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_or_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.ori %0, %1 : i32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bitwise_or_i32/raised.mlir b/issues/aten_c_kernels/results/aten_bitwise_or_i32/raised.mlir new file mode 100644 index 000000000000..8d0071b8382f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_or_i32/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_or_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %0 = arith.ori %in, %in_0 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_or_i32_debuf.mlir b/issues/aten_c_kernels/results/aten_bitwise_or_i32_debuf.mlir new file mode 100644 index 000000000000..64faafa9b26e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_or_i32_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_or_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.ori %in, %in_0 : i32 + linalg.yield %5 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_or_i32_linalg.mlir b/issues/aten_c_kernels/results/aten_bitwise_or_i32_linalg.mlir new file mode 100644 index 000000000000..8d0071b8382f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_or_i32_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_or_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %0 = arith.ori %in, %in_0 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_xor_i32.mlir b/issues/aten_c_kernels/results/aten_bitwise_xor_i32.mlir new file mode 100644 index 000000000000..c8929ff14789 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_xor_i32.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_xor_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.xori %0, %1 : i32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bitwise_xor_i32/debuf.mlir b/issues/aten_c_kernels/results/aten_bitwise_xor_i32/debuf.mlir new file mode 100644 index 000000000000..2083e54210ea --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_xor_i32/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_xor_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.xori %in, %in_0 : i32 + linalg.yield %5 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_xor_i32/matched.mlir b/issues/aten_c_kernels/results/aten_bitwise_xor_i32/matched.mlir new file mode 100644 index 000000000000..2083e54210ea --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_xor_i32/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_xor_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.xori %in, %in_0 : i32 + linalg.yield %5 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_xor_i32/orig.mlir b/issues/aten_c_kernels/results/aten_bitwise_xor_i32/orig.mlir new file mode 100644 index 000000000000..c8929ff14789 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_xor_i32/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_xor_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.xori %0, %1 : i32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bitwise_xor_i32/raised.mlir b/issues/aten_c_kernels/results/aten_bitwise_xor_i32/raised.mlir new file mode 100644 index 000000000000..1ea9d36becb4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_xor_i32/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_xor_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %0 = arith.xori %in, %in_0 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_xor_i32_debuf.mlir b/issues/aten_c_kernels/results/aten_bitwise_xor_i32_debuf.mlir new file mode 100644 index 000000000000..2083e54210ea --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_xor_i32_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_xor_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.xori %in, %in_0 : i32 + linalg.yield %5 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bitwise_xor_i32_linalg.mlir b/issues/aten_c_kernels/results/aten_bitwise_xor_i32_linalg.mlir new file mode 100644 index 000000000000..1ea9d36becb4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bitwise_xor_i32_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bitwise_xor_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %0 = arith.xori %in, %in_0 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_axpy_cpu.mlir b/issues/aten_c_kernels/results/aten_blas_axpy_cpu.mlir new file mode 100644 index 000000000000..654e7e6738fb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_axpy_cpu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_axpy_cpu(%arg0: f32, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.mulf %arg0, %0 : f32 + %2 = affine.load %arg2[%arg3] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_blas_axpy_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_blas_axpy_cpu/debuf.mlir new file mode 100644 index 000000000000..414a4f51242e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_axpy_cpu/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_axpy_cpu(%arg0: f32, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %arg0, %in : f32 + %5 = arith.addf %out, %4 : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_axpy_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_blas_axpy_cpu/matched.mlir new file mode 100644 index 000000000000..414a4f51242e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_axpy_cpu/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_axpy_cpu(%arg0: f32, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %arg0, %in : f32 + %5 = arith.addf %out, %4 : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_axpy_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_blas_axpy_cpu/orig.mlir new file mode 100644 index 000000000000..654e7e6738fb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_axpy_cpu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_axpy_cpu(%arg0: f32, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.mulf %arg0, %0 : f32 + %2 = affine.load %arg2[%arg3] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_blas_axpy_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_blas_axpy_cpu/raised.mlir new file mode 100644 index 000000000000..bdb68282e216 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_axpy_cpu/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_axpy_cpu(%arg0: f32, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg1 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %arg0, %in : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_axpy_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_blas_axpy_cpu_debuf.mlir new file mode 100644 index 000000000000..414a4f51242e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_axpy_cpu_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_axpy_cpu(%arg0: f32, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %arg0, %in : f32 + %5 = arith.addf %out, %4 : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_axpy_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_blas_axpy_cpu_linalg.mlir new file mode 100644 index 000000000000..bdb68282e216 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_axpy_cpu_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_axpy_cpu(%arg0: f32, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg1 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %arg0, %in : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_copy_cpu.mlir b/issues/aten_c_kernels/results/aten_blas_copy_cpu.mlir new file mode 100644 index 000000000000..94b042b6315b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_copy_cpu.mlir @@ -0,0 +1,9 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 1024 { + %0 = affine.load %arg0[%arg2] : memref + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_blas_copy_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_blas_copy_cpu/debuf.mlir new file mode 100644 index 000000000000..3bc5b68441b2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_copy_cpu/debuf.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_copy_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_blas_copy_cpu/matched.mlir new file mode 100644 index 000000000000..20b1d6fe1a3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_copy_cpu/matched.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = kernel.launch @cudaCopy1D_f32_tensor(%0, %1) : (tensor, tensor) -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_copy_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_blas_copy_cpu/orig.mlir new file mode 100644 index 000000000000..94b042b6315b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_copy_cpu/orig.mlir @@ -0,0 +1,9 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 1024 { + %0 = affine.load %arg0[%arg2] : memref + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_blas_copy_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_blas_copy_cpu/raised.mlir new file mode 100644 index 000000000000..b9c355f56842 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_copy_cpu/raised.mlir @@ -0,0 +1,11 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_copy_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_blas_copy_cpu_debuf.mlir new file mode 100644 index 000000000000..3bc5b68441b2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_copy_cpu_debuf.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_copy_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_blas_copy_cpu_linalg.mlir new file mode 100644 index 000000000000..b9c355f56842 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_copy_cpu_linalg.mlir @@ -0,0 +1,11 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu.mlir b/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu.mlir new file mode 100644 index 000000000000..be7b97a5fcc8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_dot_naive_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg3 = 0 to 2048 iter_args(%arg4 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3] : memref + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg4, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu/debuf.mlir new file mode 100644 index 000000000000..785f09a890b0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_dot_naive_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu/matched.mlir new file mode 100644 index 000000000000..fd06189137a5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_dot_naive_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = kernel.launch @cublasSdot(%0, %1, %extracted_slice) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu/orig.mlir new file mode 100644 index 000000000000..be7b97a5fcc8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_dot_naive_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg3 = 0 to 2048 iter_args(%arg4 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3] : memref + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg4, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu/raised.mlir new file mode 100644 index 000000000000..0246b557b907 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu/raised.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_dot_naive_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.store %cst, %arg2[0] : memref + %subview = memref.subview %arg2[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%arg0, %arg1 : memref, memref) outs(%subview : memref>) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %in, %in_0 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu_debuf.mlir new file mode 100644 index 000000000000..785f09a890b0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_dot_naive_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu_linalg.mlir new file mode 100644 index 000000000000..0246b557b907 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_dot_naive_cpu_linalg.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_dot_naive_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.store %cst, %arg2[0] : memref + %subview = memref.subview %arg2[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%arg0, %arg1 : memref, memref) outs(%subview : memref>) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %in, %in_0 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu.mlir b/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu.mlir new file mode 100644 index 000000000000..c55ec56e89c3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_gemv_generic_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %0 = affine.for %arg4 = 0 to 96 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu/debuf.mlir new file mode 100644 index 000000000000..b55c7d55b60a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_gemv_generic_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c96 = arith.constant 96 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c96] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c96] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c64] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c64] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu/matched.mlir new file mode 100644 index 000000000000..4031ed7a73d5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_gemv_generic_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c96 = arith.constant 96 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = kernel.launch @memset_zero_1D_f32(%2) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c96] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c96] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c64] [1] : tensor to tensor + %4 = kernel.launch @cublasSgemv(%extracted_slice, %extracted_slice_0, %extracted_slice_1) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c64] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu/orig.mlir new file mode 100644 index 000000000000..c55ec56e89c3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu/orig.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_gemv_generic_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %0 = affine.for %arg4 = 0 to 96 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu/raised.mlir new file mode 100644 index 000000000000..499ea7c73cfb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_gemv_generic_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c96 = arith.constant 96 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c64, %c96] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c96] [1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c64] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu_debuf.mlir new file mode 100644 index 000000000000..b55c7d55b60a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_gemv_generic_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c96 = arith.constant 96 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c96] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c96] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c64] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c64] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu_linalg.mlir new file mode 100644 index 000000000000..499ea7c73cfb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_gemv_generic_cpu_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_gemv_generic_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c96 = arith.constant 96 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c64, %c96] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c96] [1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c64] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_scale_cpu.mlir b/issues/aten_c_kernels/results/aten_blas_scale_cpu.mlir new file mode 100644 index 000000000000..e313c6a70da1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_scale_cpu.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_scale_cpu(%arg0: memref, %arg1: f32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 1024 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.mulf %0, %arg1 : f32 + affine.store %1, %arg0[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_blas_scale_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_blas_scale_cpu/debuf.mlir new file mode 100644 index 000000000000..2ba2cf03affb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_scale_cpu/debuf.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_scale_cpu(%arg0: memref, %arg1: f32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = arith.mulf %out, %arg1 : f32 + linalg.yield %3 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_scale_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_blas_scale_cpu/matched.mlir new file mode 100644 index 000000000000..2ba2cf03affb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_scale_cpu/matched.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_scale_cpu(%arg0: memref, %arg1: f32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = arith.mulf %out, %arg1 : f32 + linalg.yield %3 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_scale_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_blas_scale_cpu/orig.mlir new file mode 100644 index 000000000000..e313c6a70da1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_scale_cpu/orig.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_scale_cpu(%arg0: memref, %arg1: f32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 1024 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.mulf %0, %arg1 : f32 + affine.store %1, %arg0[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_blas_scale_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_blas_scale_cpu/raised.mlir new file mode 100644 index 000000000000..4c8e9ead1a68 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_scale_cpu/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_scale_cpu(%arg0: memref, %arg1: f32) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg0 : memref) { + ^bb0(%out: f32): + %0 = arith.mulf %out, %arg1 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_scale_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_blas_scale_cpu_debuf.mlir new file mode 100644 index 000000000000..2ba2cf03affb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_scale_cpu_debuf.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_scale_cpu(%arg0: memref, %arg1: f32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = arith.mulf %out, %arg1 : f32 + linalg.yield %3 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_scale_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_blas_scale_cpu_linalg.mlir new file mode 100644 index 000000000000..4c8e9ead1a68 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_scale_cpu_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_scale_cpu(%arg0: memref, %arg1: f32) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg0 : memref) { + ^bb0(%out: f32): + %0 = arith.mulf %out, %arg1 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_sum_cpu.mlir b/issues/aten_c_kernels/results/aten_blas_sum_cpu.mlir new file mode 100644 index 000000000000..03c05dd2289a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_sum_cpu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg2 = 0 to 1024 iter_args(%arg3 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2] : memref + %2 = arith.addf %arg3, %1 : f32 + affine.yield %2 : f32 + } + affine.store %0, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_blas_sum_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_blas_sum_cpu/debuf.mlir new file mode 100644 index 000000000000..c61d29986312 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_sum_cpu/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %cst into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_sum_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_blas_sum_cpu/matched.mlir new file mode 100644 index 000000000000..c61d29986312 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_sum_cpu/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %cst into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_sum_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_blas_sum_cpu/orig.mlir new file mode 100644 index 000000000000..03c05dd2289a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_sum_cpu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg2 = 0 to 1024 iter_args(%arg3 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2] : memref + %2 = arith.addf %arg3, %1 : f32 + affine.yield %2 : f32 + } + affine.store %0, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_blas_sum_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_blas_sum_cpu/raised.mlir new file mode 100644 index 000000000000..f8f49536dd3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_sum_cpu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.store %cst, %arg1[0] : memref + %subview = memref.subview %arg1[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.addf %out, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_sum_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_blas_sum_cpu_debuf.mlir new file mode 100644 index 000000000000..c61d29986312 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_sum_cpu_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %cst into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_blas_sum_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_blas_sum_cpu_linalg.mlir new file mode 100644 index 000000000000..f8f49536dd3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_blas_sum_cpu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_blas_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.store %cst, %arg1[0] : memref + %subview = memref.subview %arg1[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.addf %out, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_block_diag_cpu.mlir b/issues/aten_c_kernels/results/aten_block_diag_cpu.mlir new file mode 100644 index 000000000000..e9e2e2b7223b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_block_diag_cpu.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_block_diag_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 64 { + affine.for %arg3 = 0 to 64 { + affine.store %cst, %arg1[%arg2, %arg3] : memref + } + } + affine.for %arg2 = 0 to 4 { + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 16 { + %0 = affine.load %arg0[%arg2, %arg3, %arg4] : memref + affine.store %0, %arg1[%arg3 + %arg2 * 16, %arg4 + %arg2 * 16] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_block_diag_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_block_diag_cpu/debuf.mlir new file mode 100644 index 000000000000..0fbe9b1f0c05 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_block_diag_cpu/debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d1 + d0 * 16, d2 + d0 * 16)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_block_diag_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c64, %c64] [1, 1] : tensor into tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c4, %c16, %c16] [1, 1, 1] : tensor to tensor + %3 = polygeist.submap(%inserted_slice, %c4, %c16, %c16) {map = #map1} : (tensor, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submapInverse(%inserted_slice, %4, %c4, %c16, %c16) {map = #map1} : (tensor, tensor, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_block_diag_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_block_diag_cpu/matched.mlir new file mode 100644 index 000000000000..9563d5d13041 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_block_diag_cpu/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d1 + d0 * 16, d2 + d0 * 16)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_block_diag_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %2 = kernel.launch @memset_zero_2D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c64, %c64] [1, 1] : tensor into tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c4, %c16, %c16] [1, 1, 1] : tensor to tensor + %3 = polygeist.submap(%inserted_slice, %c4, %c16, %c16) {map = #map1} : (tensor, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submapInverse(%inserted_slice, %4, %c4, %c16, %c16) {map = #map1} : (tensor, tensor, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_block_diag_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_block_diag_cpu/orig.mlir new file mode 100644 index 000000000000..e9e2e2b7223b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_block_diag_cpu/orig.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_block_diag_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 64 { + affine.for %arg3 = 0 to 64 { + affine.store %cst, %arg1[%arg2, %arg3] : memref + } + } + affine.for %arg2 = 0 to 4 { + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 16 { + %0 = affine.load %arg0[%arg2, %arg3, %arg4] : memref + affine.store %0, %arg1[%arg3 + %arg2 * 16, %arg4 + %arg2 * 16] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_block_diag_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_block_diag_cpu/raised.mlir new file mode 100644 index 000000000000..7e99e9b38016 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_block_diag_cpu/raised.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d1 + d0 * 16, d2 + d0 * 16)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_block_diag_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg1[0, 0] [%c64, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c4, %c16, %c16] [1, 1, 1] : memref to memref> + %0 = polygeist.submap(%arg1, %c4, %c16, %c16) {map = #map1} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview_0 : memref>) outs(%0 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_block_diag_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_block_diag_cpu_debuf.mlir new file mode 100644 index 000000000000..0fbe9b1f0c05 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_block_diag_cpu_debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d1 + d0 * 16, d2 + d0 * 16)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_block_diag_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c64, %c64] [1, 1] : tensor into tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c4, %c16, %c16] [1, 1, 1] : tensor to tensor + %3 = polygeist.submap(%inserted_slice, %c4, %c16, %c16) {map = #map1} : (tensor, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submapInverse(%inserted_slice, %4, %c4, %c16, %c16) {map = #map1} : (tensor, tensor, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_block_diag_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_block_diag_cpu_linalg.mlir new file mode 100644 index 000000000000..7e99e9b38016 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_block_diag_cpu_linalg.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d1 + d0 * 16, d2 + d0 * 16)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_block_diag_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg1[0, 0] [%c64, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c4, %c16, %c16] [1, 1, 1] : memref to memref> + %0 = polygeist.submap(%arg1, %c4, %c16, %c16) {map = #map1} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview_0 : memref>) outs(%0 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bmm.mlir b/issues/aten_c_kernels/results/aten_bmm.mlir new file mode 100644 index 000000000000..ed1520878339 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bmm.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bmm(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 12 { + affine.store %cst, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 12 { + affine.for %arg6 = 0 to 16 { + %0 = affine.load %arg0[%arg3, %arg4, %arg6] : memref + %1 = affine.load %arg1[%arg3, %arg6, %arg5] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg2[%arg3, %arg4, %arg5] : memref + %4 = arith.addf %3, %2 : f32 + affine.store %4, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bmm/debuf.mlir b/issues/aten_c_kernels/results/aten_bmm/debuf.mlir new file mode 100644 index 000000000000..9369159cac7c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bmm/debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bmm(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %c12 = arith.constant 12 : index + %c8 = arith.constant 8 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c4, %c8, %c12] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c4, %c8, %c16] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c4, %c16, %c12] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c4, %c8, %c12] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bmm/matched.mlir b/issues/aten_c_kernels/results/aten_bmm/matched.mlir new file mode 100644 index 000000000000..9369159cac7c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bmm/matched.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bmm(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %c12 = arith.constant 12 : index + %c8 = arith.constant 8 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c4, %c8, %c12] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c4, %c8, %c16] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c4, %c16, %c12] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c4, %c8, %c12] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bmm/orig.mlir b/issues/aten_c_kernels/results/aten_bmm/orig.mlir new file mode 100644 index 000000000000..ed1520878339 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bmm/orig.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bmm(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 12 { + affine.store %cst, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 12 { + affine.for %arg6 = 0 to 16 { + %0 = affine.load %arg0[%arg3, %arg4, %arg6] : memref + %1 = affine.load %arg1[%arg3, %arg6, %arg5] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg2[%arg3, %arg4, %arg5] : memref + %4 = arith.addf %3, %2 : f32 + affine.store %4, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_bmm/raised.mlir b/issues/aten_c_kernels/results/aten_bmm/raised.mlir new file mode 100644 index 000000000000..f931d7cf4b05 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bmm/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bmm(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c8 = arith.constant 8 : index + %c12 = arith.constant 12 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c4, %c8, %c12] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c4, %c8, %c16] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0] [%c4, %c16, %c12] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0, 0] [%c4, %c8, %c12] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bmm_debuf.mlir b/issues/aten_c_kernels/results/aten_bmm_debuf.mlir new file mode 100644 index 000000000000..9369159cac7c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bmm_debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bmm(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %c12 = arith.constant 12 : index + %c8 = arith.constant 8 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c4, %c8, %c12] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c4, %c8, %c16] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c4, %c16, %c12] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c4, %c8, %c12] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_bmm_linalg.mlir b/issues/aten_c_kernels/results/aten_bmm_linalg.mlir new file mode 100644 index 000000000000..f931d7cf4b05 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_bmm_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_bmm(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c8 = arith.constant 8 : index + %c12 = arith.constant 12 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c4, %c8, %c12] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c4, %c8, %c16] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0] [%c4, %c16, %c12] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0, 0] [%c4, %c8, %c12] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cartesian_prod_cpu.mlir b/issues/aten_c_kernels/results/aten_cartesian_prod_cpu.mlir new file mode 100644 index 000000000000..dad71aecbf52 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cartesian_prod_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cartesian_prod_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 12 { + %0 = affine.load %arg0[%arg3] : memref + affine.store %0, %arg2[%arg4 + %arg3 * 12, 0] : memref + %1 = affine.load %arg1[%arg4] : memref + affine.store %1, %arg2[%arg4 + %arg3 * 12, 1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cartesian_prod_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_cartesian_prod_cpu/debuf.mlir new file mode 100644 index 000000000000..d9f65ac57291 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cartesian_prod_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 12, 0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (d1 + d0 * 12, 1)> +#map4 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cartesian_prod_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c12 = arith.constant 12 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0] [%c16] [1] : tensor to tensor + %3 = polygeist.submap(%2, %c16, %c12) {map = #map} : (tensor, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submapInverse(%2, %4, %c16, %c12) {map = #map} : (tensor, tensor, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c12] [1] : tensor to tensor + %6 = polygeist.submap(%5, %c16, %c12) {map = #map3} : (tensor, index, index) -> tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map4, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%6 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %8 = polygeist.submapInverse(%5, %7, %c16, %c12) {map = #map3} : (tensor, tensor, index, index) -> tensor + %9 = bufferization.to_memref %8 : memref + memref.copy %9, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cartesian_prod_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_cartesian_prod_cpu/matched.mlir new file mode 100644 index 000000000000..d9f65ac57291 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cartesian_prod_cpu/matched.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 12, 0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (d1 + d0 * 12, 1)> +#map4 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cartesian_prod_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c12 = arith.constant 12 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0] [%c16] [1] : tensor to tensor + %3 = polygeist.submap(%2, %c16, %c12) {map = #map} : (tensor, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submapInverse(%2, %4, %c16, %c12) {map = #map} : (tensor, tensor, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c12] [1] : tensor to tensor + %6 = polygeist.submap(%5, %c16, %c12) {map = #map3} : (tensor, index, index) -> tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map4, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%6 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %8 = polygeist.submapInverse(%5, %7, %c16, %c12) {map = #map3} : (tensor, tensor, index, index) -> tensor + %9 = bufferization.to_memref %8 : memref + memref.copy %9, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cartesian_prod_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_cartesian_prod_cpu/orig.mlir new file mode 100644 index 000000000000..dad71aecbf52 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cartesian_prod_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cartesian_prod_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 12 { + %0 = affine.load %arg0[%arg3] : memref + affine.store %0, %arg2[%arg4 + %arg3 * 12, 0] : memref + %1 = affine.load %arg1[%arg4] : memref + affine.store %1, %arg2[%arg4 + %arg3 * 12, 1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cartesian_prod_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_cartesian_prod_cpu/raised.mlir new file mode 100644 index 000000000000..7681446f874d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cartesian_prod_cpu/raised.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 12, 0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (d1 + d0 * 12, 1)> +#map4 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cartesian_prod_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c12 = arith.constant 12 : index + %subview = memref.subview %arg0[0] [%c16] [1] : memref to memref> + %0 = polygeist.submap(%arg2, %c16, %c12) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%0 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_0 = memref.subview %arg1[0] [%c12] [1] : memref to memref> + %1 = polygeist.submap(%arg2, %c16, %c12) {map = #map3} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map4, #map2], iterator_types = ["parallel", "parallel"]} ins(%subview_0 : memref>) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cartesian_prod_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_cartesian_prod_cpu_debuf.mlir new file mode 100644 index 000000000000..d9f65ac57291 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cartesian_prod_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 12, 0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (d1 + d0 * 12, 1)> +#map4 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cartesian_prod_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c12 = arith.constant 12 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0] [%c16] [1] : tensor to tensor + %3 = polygeist.submap(%2, %c16, %c12) {map = #map} : (tensor, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submapInverse(%2, %4, %c16, %c12) {map = #map} : (tensor, tensor, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c12] [1] : tensor to tensor + %6 = polygeist.submap(%5, %c16, %c12) {map = #map3} : (tensor, index, index) -> tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map4, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%6 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %8 = polygeist.submapInverse(%5, %7, %c16, %c12) {map = #map3} : (tensor, tensor, index, index) -> tensor + %9 = bufferization.to_memref %8 : memref + memref.copy %9, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cartesian_prod_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_cartesian_prod_cpu_linalg.mlir new file mode 100644 index 000000000000..7681446f874d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cartesian_prod_cpu_linalg.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 12, 0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (d1 + d0 * 12, 1)> +#map4 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cartesian_prod_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c12 = arith.constant 12 : index + %subview = memref.subview %arg0[0] [%c16] [1] : memref to memref> + %0 = polygeist.submap(%arg2, %c16, %c12) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%0 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_0 = memref.subview %arg1[0] [%c12] [1] : memref to memref> + %1 = polygeist.submap(%arg2, %c16, %c12) {map = #map3} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map4, #map2], iterator_types = ["parallel", "parallel"]} ins(%subview_0 : memref>) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cat_serial_cpu.mlir b/issues/aten_c_kernels/results/aten_cat_serial_cpu.mlir new file mode 100644 index 000000000000..952019c5383e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cat_serial_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cat_serial_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg0[%arg3, %arg4] : memref + affine.store %0, %arg2[%arg3, %arg4] : memref + } + } + affine.for %arg3 = 0 to 12 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + affine.store %0, %arg2[%arg3 + 16, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cat_serial_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_cat_serial_cpu/debuf.mlir new file mode 100644 index 000000000000..10f52c029f3a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cat_serial_cpu/debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cat_serial_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c12 = arith.constant 12 : index + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c12, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %inserted_slice[16, 0] [%c12, %c64] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice_3 = tensor.insert_slice %4 into %inserted_slice[16, 0] [%c12, %c64] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice_3 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cat_serial_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_cat_serial_cpu/matched.mlir new file mode 100644 index 000000000000..b5c088932b15 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cat_serial_cpu/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cat_serial_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c12 = arith.constant 12 : index + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %3 = kernel.launch @cudaCopy2D_f32_tensor(%extracted_slice, %extracted_slice_0) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c12, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %inserted_slice[16, 0] [%c12, %c64] [1, 1] : tensor to tensor + %4 = kernel.launch @cudaCopy2D_f32_tensor(%extracted_slice_1, %extracted_slice_2) : (tensor, tensor) -> tensor + %inserted_slice_3 = tensor.insert_slice %4 into %inserted_slice[16, 0] [%c12, %c64] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice_3 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cat_serial_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_cat_serial_cpu/orig.mlir new file mode 100644 index 000000000000..952019c5383e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cat_serial_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cat_serial_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg0[%arg3, %arg4] : memref + affine.store %0, %arg2[%arg3, %arg4] : memref + } + } + affine.for %arg3 = 0 to 12 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + affine.store %0, %arg2[%arg3 + 16, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cat_serial_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_cat_serial_cpu/raised.mlir new file mode 100644 index 000000000000..d689df299ffb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cat_serial_cpu/raised.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cat_serial_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %c12 = arith.constant 12 : index + %subview = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg2[0, 0] [%c16, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_1 = memref.subview %arg1[0, 0] [%c12, %c64] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[16, 0] [%c12, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview_1 : memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cat_serial_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_cat_serial_cpu_debuf.mlir new file mode 100644 index 000000000000..10f52c029f3a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cat_serial_cpu_debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cat_serial_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c12 = arith.constant 12 : index + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c12, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %inserted_slice[16, 0] [%c12, %c64] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice_3 = tensor.insert_slice %4 into %inserted_slice[16, 0] [%c12, %c64] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice_3 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cat_serial_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_cat_serial_cpu_linalg.mlir new file mode 100644 index 000000000000..d689df299ffb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cat_serial_cpu_linalg.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cat_serial_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %c12 = arith.constant 12 : index + %subview = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg2[0, 0] [%c16, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_1 = memref.subview %arg1[0, 0] [%c12, %c64] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[16, 0] [%c12, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview_1 : memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cat_sparse_cpu.mlir b/issues/aten_c_kernels/results/aten_cat_sparse_cpu.mlir new file mode 100644 index 000000000000..9b40e9df5c84 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cat_sparse_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cat_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 256 { + %0 = affine.load %arg0[%arg4, %arg5] : memref + affine.store %0, %arg2[%arg5 + %arg4 * 256] : memref + %1 = affine.load %arg1[%arg4, %arg5] : memref + affine.store %1, %arg3[%arg5 + %arg4 * 256] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cat_sparse_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_cat_sparse_cpu/debuf.mlir new file mode 100644 index 000000000000..05465648cf00 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cat_sparse_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 256)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cat_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c4, %c256] [1, 1] : tensor to tensor + %4 = polygeist.submap(%2, %c4, %c256) {map = #map} : (tensor, index, index) -> tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%4 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %6 = polygeist.submapInverse(%2, %5, %c4, %c256) {map = #map} : (tensor, tensor, index, index) -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg2 : memref to memref + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c4, %c256] [1, 1] : tensor to tensor + %8 = polygeist.submap(%3, %c4, %c256) {map = #map} : (tensor, index, index) -> tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%8 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %10 = polygeist.submapInverse(%3, %9, %c4, %c256) {map = #map} : (tensor, tensor, index, index) -> tensor + %11 = bufferization.to_memref %10 : memref + memref.copy %11, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cat_sparse_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_cat_sparse_cpu/matched.mlir new file mode 100644 index 000000000000..8b6f4d24793f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cat_sparse_cpu/matched.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 256)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cat_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c4, %c256] [1, 1] : tensor to tensor + %4 = polygeist.submap(%2, %c4, %c256) {map = #map} : (tensor, index, index) -> tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%4 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %6 = polygeist.submapInverse(%2, %5, %c4, %c256) {map = #map} : (tensor, tensor, index, index) -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg2 : memref to memref + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c4, %c256] [1, 1] : tensor to tensor + %8 = polygeist.submap(%3, %c4, %c256) {map = #map} : (tensor, index, index) -> tensor + %9 = kernel.launch @cudaCopy2D_f32_tensor(%extracted_slice_0, %8) : (tensor, tensor) -> tensor + %10 = polygeist.submapInverse(%3, %9, %c4, %c256) {map = #map} : (tensor, tensor, index, index) -> tensor + %11 = bufferization.to_memref %10 : memref + memref.copy %11, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cat_sparse_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_cat_sparse_cpu/orig.mlir new file mode 100644 index 000000000000..9b40e9df5c84 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cat_sparse_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cat_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 256 { + %0 = affine.load %arg0[%arg4, %arg5] : memref + affine.store %0, %arg2[%arg5 + %arg4 * 256] : memref + %1 = affine.load %arg1[%arg4, %arg5] : memref + affine.store %1, %arg3[%arg5 + %arg4 * 256] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cat_sparse_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_cat_sparse_cpu/raised.mlir new file mode 100644 index 000000000000..daf77ad2bd74 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cat_sparse_cpu/raised.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 256)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cat_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c256 = arith.constant 256 : index + %subview = memref.subview %arg0[0, 0] [%c4, %c256] [1, 1] : memref to memref> + %0 = polygeist.submap(%arg2, %c4, %c256) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%0 : memref) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + %subview_0 = memref.subview %arg1[0, 0] [%c4, %c256] [1, 1] : memref to memref> + %1 = polygeist.submap(%arg3, %c4, %c256) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview_0 : memref>) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cat_sparse_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_cat_sparse_cpu_debuf.mlir new file mode 100644 index 000000000000..05465648cf00 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cat_sparse_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 256)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cat_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c4, %c256] [1, 1] : tensor to tensor + %4 = polygeist.submap(%2, %c4, %c256) {map = #map} : (tensor, index, index) -> tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%4 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %6 = polygeist.submapInverse(%2, %5, %c4, %c256) {map = #map} : (tensor, tensor, index, index) -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg2 : memref to memref + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c4, %c256] [1, 1] : tensor to tensor + %8 = polygeist.submap(%3, %c4, %c256) {map = #map} : (tensor, index, index) -> tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%8 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %10 = polygeist.submapInverse(%3, %9, %c4, %c256) {map = #map} : (tensor, tensor, index, index) -> tensor + %11 = bufferization.to_memref %10 : memref + memref.copy %11, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cat_sparse_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_cat_sparse_cpu_linalg.mlir new file mode 100644 index 000000000000..daf77ad2bd74 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cat_sparse_cpu_linalg.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 256)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cat_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c256 = arith.constant 256 : index + %subview = memref.subview %arg0[0, 0] [%c4, %c256] [1, 1] : memref to memref> + %0 = polygeist.submap(%arg2, %c4, %c256) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%0 : memref) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + %subview_0 = memref.subview %arg1[0, 0] [%c4, %c256] [1, 1] : memref to memref> + %1 = polygeist.submap(%arg3, %c4, %c256) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview_0 : memref>) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cauchy_cpu.mlir b/issues/aten_c_kernels/results/aten_cauchy_cpu.mlir new file mode 100644 index 000000000000..fcc72b3181d6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cauchy_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cauchy_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 3.14159274 : f32 + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.subf %0, %cst : f32 + %2 = arith.mulf %1, %cst_0 : f32 + %3 = func.call @tanf(%2) : (f32) -> f32 + %4 = arith.mulf %arg2, %3 : f32 + %5 = arith.addf %arg1, %4 : f32 + affine.store %5, %arg3[%arg4] : memref + } + return + } + func.func private @tanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_cauchy_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_cauchy_cpu/debuf.mlir new file mode 100644 index 000000000000..0a5a58675748 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cauchy_cpu/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cauchy_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.14159274 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.subf %in, %cst_0 : f32 + %5 = arith.mulf %4, %cst : f32 + %6 = math.tan %5 : f32 + %7 = arith.mulf %arg2, %6 : f32 + %8 = arith.addf %arg1, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } + func.func private @tanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_cauchy_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_cauchy_cpu/matched.mlir new file mode 100644 index 000000000000..0a5a58675748 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cauchy_cpu/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cauchy_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.14159274 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.subf %in, %cst_0 : f32 + %5 = arith.mulf %4, %cst : f32 + %6 = math.tan %5 : f32 + %7 = arith.mulf %arg2, %6 : f32 + %8 = arith.addf %arg1, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } + func.func private @tanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_cauchy_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_cauchy_cpu/orig.mlir new file mode 100644 index 000000000000..fcc72b3181d6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cauchy_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cauchy_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 3.14159274 : f32 + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.subf %0, %cst : f32 + %2 = arith.mulf %1, %cst_0 : f32 + %3 = func.call @tanf(%2) : (f32) -> f32 + %4 = arith.mulf %arg2, %3 : f32 + %5 = arith.addf %arg1, %4 : f32 + affine.store %5, %arg3[%arg4] : memref + } + return + } + func.func private @tanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_cauchy_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_cauchy_cpu/raised.mlir new file mode 100644 index 000000000000..2a06c4b41095 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cauchy_cpu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cauchy_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 3.14159274 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.subf %in, %cst : f32 + %1 = arith.mulf %0, %cst_0 : f32 + %2 = math.tan %1 : f32 + %3 = arith.mulf %arg2, %2 : f32 + %4 = arith.addf %arg1, %3 : f32 + linalg.yield %4 : f32 + } + return + } + func.func private @tanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_cauchy_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_cauchy_cpu_debuf.mlir new file mode 100644 index 000000000000..0a5a58675748 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cauchy_cpu_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cauchy_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.14159274 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.subf %in, %cst_0 : f32 + %5 = arith.mulf %4, %cst : f32 + %6 = math.tan %5 : f32 + %7 = arith.mulf %arg2, %6 : f32 + %8 = arith.addf %arg1, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } + func.func private @tanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_cauchy_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_cauchy_cpu_linalg.mlir new file mode 100644 index 000000000000..2a06c4b41095 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cauchy_cpu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cauchy_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 3.14159274 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.subf %in, %cst : f32 + %1 = arith.mulf %0, %cst_0 : f32 + %2 = math.tan %1 : f32 + %3 = arith.mulf %arg2, %2 : f32 + %4 = arith.addf %arg1, %3 : f32 + linalg.yield %4 : f32 + } + return + } + func.func private @tanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_cdist_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_cdist_backward_cpu.mlir new file mode 100644 index 000000000000..a6d9d950b298 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cdist_backward_cpu.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cdist_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 32 { + affine.store %cst, %arg3[%arg4, %arg5] : memref + } + } + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 12 { + %0 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %cst) -> (f32) { + %4 = affine.load %arg0[%arg4, %arg6] : memref + %5 = affine.load %arg1[%arg5, %arg6] : memref + %6 = arith.subf %4, %5 : f32 + %7 = arith.mulf %6, %6 : f32 + %8 = arith.addf %arg7, %7 : f32 + affine.yield %8 : f32 + } + %1 = math.sqrt %0 : f32 + %2 = arith.cmpf oeq, %1, %cst : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %cst : f32 + } else { + %4 = affine.load %arg2[%arg4, %arg5] : memref + %5 = arith.divf %4, %1 : f32 + scf.yield %5 : f32 + } + affine.for %arg6 = 0 to 32 { + %4 = affine.load %arg0[%arg4, %arg6] : memref + %5 = affine.load %arg1[%arg5, %arg6] : memref + %6 = arith.subf %4, %5 : f32 + %7 = arith.mulf %3, %6 : f32 + %8 = affine.load %arg3[%arg4, %arg6] : memref + %9 = arith.addf %8, %7 : f32 + affine.store %9, %arg3[%arg4, %arg6] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cdist_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_cdist_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..7f98f1855b5b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cdist_backward_cpu/debuf.mlir @@ -0,0 +1,61 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cdist_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c16, %c32] [1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %2[0, 0] [%c16, %c32] [1, 1] : tensor into tensor + %7 = affine.for %arg4 = 0 to 16 iter_args(%arg5 = %inserted_slice) -> (tensor) { + %9 = affine.for %arg6 = 0 to 12 iter_args(%arg7 = %arg5) -> (tensor) { + %alloca = memref.alloca() : memref + %10 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %10[] : tensor + %extracted_slice_0 = tensor.extract_slice %5[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %4[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map2], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %in_7: f32, %out: f32): + %17 = arith.subf %in, %in_7 : f32 + %18 = arith.mulf %17, %17 : f32 + %19 = arith.addf %out, %18 : f32 + linalg.yield %19 : f32 + } -> tensor + %extracted = tensor.extract %11[] : tensor + %12 = math.sqrt %extracted : f32 + %13 = arith.cmpf oeq, %12, %cst : f32 + %extracted_2 = tensor.extract %3[%arg4, %arg6] : tensor + %14 = arith.divf %extracted_2, %12 : f32 + %15 = arith.select %13, %cst, %14 : f32 + %extracted_slice_3 = tensor.extract_slice %arg7[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %1[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %0[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_4, %extracted_slice_5 : tensor, tensor) outs(%extracted_slice_3 : tensor) { + ^bb0(%in: f32, %in_7: f32, %out: f32): + %17 = arith.subf %in, %in_7 : f32 + %18 = arith.mulf %15, %17 : f32 + %19 = arith.addf %out, %18 : f32 + linalg.yield %19 : f32 + } -> tensor + %inserted_slice_6 = tensor.insert_slice %16 into %arg7[%arg4, 0] [1, %c32] [1, 1] : tensor into tensor + affine.yield %inserted_slice_6 : tensor + } + affine.yield %9 : tensor + } + %8 = bufferization.to_memref %7 : memref + memref.copy %8, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cdist_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_cdist_backward_cpu/matched.mlir new file mode 100644 index 000000000000..3a357ea32fa6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cdist_backward_cpu/matched.mlir @@ -0,0 +1,58 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cdist_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c16, %c32] [1, 1] : tensor to tensor + %6 = kernel.launch @memset_zero_2D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %6 into %2[0, 0] [%c16, %c32] [1, 1] : tensor into tensor + %7 = affine.for %arg4 = 0 to 16 iter_args(%arg5 = %inserted_slice) -> (tensor) { + %9 = affine.for %arg6 = 0 to 12 iter_args(%arg7 = %arg5) -> (tensor) { + %alloca = memref.alloca() : memref + %10 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %10[] : tensor + %extracted_slice_0 = tensor.extract_slice %5[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %4[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map2], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %in_7: f32, %out: f32): + %17 = arith.subf %in, %in_7 : f32 + %18 = arith.mulf %17, %17 : f32 + %19 = arith.addf %out, %18 : f32 + linalg.yield %19 : f32 + } -> tensor + %extracted = tensor.extract %11[] : tensor + %12 = math.sqrt %extracted : f32 + %13 = arith.cmpf oeq, %12, %cst : f32 + %extracted_2 = tensor.extract %3[%arg4, %arg6] : tensor + %14 = arith.divf %extracted_2, %12 : f32 + %15 = arith.select %13, %cst, %14 : f32 + %extracted_slice_3 = tensor.extract_slice %arg7[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %1[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %0[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_4, %extracted_slice_5 : tensor, tensor) outs(%extracted_slice_3 : tensor) { + ^bb0(%in: f32, %in_7: f32, %out: f32): + %17 = arith.subf %in, %in_7 : f32 + %18 = arith.mulf %15, %17 : f32 + %19 = arith.addf %out, %18 : f32 + linalg.yield %19 : f32 + } -> tensor + %inserted_slice_6 = tensor.insert_slice %16 into %arg7[%arg4, 0] [1, %c32] [1, 1] : tensor into tensor + affine.yield %inserted_slice_6 : tensor + } + affine.yield %9 : tensor + } + %8 = bufferization.to_memref %7 : memref + memref.copy %8, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cdist_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_cdist_backward_cpu/orig.mlir new file mode 100644 index 000000000000..a6d9d950b298 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cdist_backward_cpu/orig.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cdist_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 32 { + affine.store %cst, %arg3[%arg4, %arg5] : memref + } + } + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 12 { + %0 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %cst) -> (f32) { + %4 = affine.load %arg0[%arg4, %arg6] : memref + %5 = affine.load %arg1[%arg5, %arg6] : memref + %6 = arith.subf %4, %5 : f32 + %7 = arith.mulf %6, %6 : f32 + %8 = arith.addf %arg7, %7 : f32 + affine.yield %8 : f32 + } + %1 = math.sqrt %0 : f32 + %2 = arith.cmpf oeq, %1, %cst : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %cst : f32 + } else { + %4 = affine.load %arg2[%arg4, %arg5] : memref + %5 = arith.divf %4, %1 : f32 + scf.yield %5 : f32 + } + affine.for %arg6 = 0 to 32 { + %4 = affine.load %arg0[%arg4, %arg6] : memref + %5 = affine.load %arg1[%arg5, %arg6] : memref + %6 = arith.subf %4, %5 : f32 + %7 = arith.mulf %3, %6 : f32 + %8 = affine.load %arg3[%arg4, %arg6] : memref + %9 = arith.addf %8, %7 : f32 + affine.store %9, %arg3[%arg4, %arg6] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cdist_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_cdist_backward_cpu/raised.mlir new file mode 100644 index 000000000000..b679f83eb3e1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cdist_backward_cpu/raised.mlir @@ -0,0 +1,49 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cdist_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg3[0, 0] [%c16, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 12 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview_0 = memref.subview %arg0[%arg4, 0] [1, %c32] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[%arg5, 0] [1, %c32] [1, 1] : memref to memref> + %subview_2 = memref.subview %alloca[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1, #map2], iterator_types = ["reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_6: f32, %out: f32): + %6 = arith.subf %in, %in_6 : f32 + %7 = arith.mulf %6, %6 : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = math.sqrt %0 : f32 + %2 = arith.cmpf oeq, %1, %cst : f32 + %3 = affine.load %arg2[%arg4, %arg5] : memref + %4 = arith.divf %3, %1 : f32 + %5 = arith.select %2, %cst, %4 : f32 + %subview_3 = memref.subview %arg0[%arg4, 0] [1, %c32] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg1[%arg5, 0] [1, %c32] [1, 1] : memref to memref> + %subview_5 = memref.subview %arg3[%arg4, 0] [1, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"]} ins(%subview_3, %subview_4 : memref>, memref>) outs(%subview_5 : memref>) { + ^bb0(%in: f32, %in_6: f32, %out: f32): + %6 = arith.subf %in, %in_6 : f32 + %7 = arith.mulf %5, %6 : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cdist_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_cdist_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..7f98f1855b5b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cdist_backward_cpu_debuf.mlir @@ -0,0 +1,61 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cdist_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c16, %c32] [1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %2[0, 0] [%c16, %c32] [1, 1] : tensor into tensor + %7 = affine.for %arg4 = 0 to 16 iter_args(%arg5 = %inserted_slice) -> (tensor) { + %9 = affine.for %arg6 = 0 to 12 iter_args(%arg7 = %arg5) -> (tensor) { + %alloca = memref.alloca() : memref + %10 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %10[] : tensor + %extracted_slice_0 = tensor.extract_slice %5[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %4[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map2], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %in_7: f32, %out: f32): + %17 = arith.subf %in, %in_7 : f32 + %18 = arith.mulf %17, %17 : f32 + %19 = arith.addf %out, %18 : f32 + linalg.yield %19 : f32 + } -> tensor + %extracted = tensor.extract %11[] : tensor + %12 = math.sqrt %extracted : f32 + %13 = arith.cmpf oeq, %12, %cst : f32 + %extracted_2 = tensor.extract %3[%arg4, %arg6] : tensor + %14 = arith.divf %extracted_2, %12 : f32 + %15 = arith.select %13, %cst, %14 : f32 + %extracted_slice_3 = tensor.extract_slice %arg7[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %1[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %0[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_4, %extracted_slice_5 : tensor, tensor) outs(%extracted_slice_3 : tensor) { + ^bb0(%in: f32, %in_7: f32, %out: f32): + %17 = arith.subf %in, %in_7 : f32 + %18 = arith.mulf %15, %17 : f32 + %19 = arith.addf %out, %18 : f32 + linalg.yield %19 : f32 + } -> tensor + %inserted_slice_6 = tensor.insert_slice %16 into %arg7[%arg4, 0] [1, %c32] [1, 1] : tensor into tensor + affine.yield %inserted_slice_6 : tensor + } + affine.yield %9 : tensor + } + %8 = bufferization.to_memref %7 : memref + memref.copy %8, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cdist_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_cdist_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..b679f83eb3e1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cdist_backward_cpu_linalg.mlir @@ -0,0 +1,49 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cdist_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg3[0, 0] [%c16, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 12 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview_0 = memref.subview %arg0[%arg4, 0] [1, %c32] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[%arg5, 0] [1, %c32] [1, 1] : memref to memref> + %subview_2 = memref.subview %alloca[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1, #map2], iterator_types = ["reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_6: f32, %out: f32): + %6 = arith.subf %in, %in_6 : f32 + %7 = arith.mulf %6, %6 : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = math.sqrt %0 : f32 + %2 = arith.cmpf oeq, %1, %cst : f32 + %3 = affine.load %arg2[%arg4, %arg5] : memref + %4 = arith.divf %3, %1 : f32 + %5 = arith.select %2, %cst, %4 : f32 + %subview_3 = memref.subview %arg0[%arg4, 0] [1, %c32] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg1[%arg5, 0] [1, %c32] [1, 1] : memref to memref> + %subview_5 = memref.subview %arg3[%arg4, 0] [1, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"]} ins(%subview_3, %subview_4 : memref>, memref>) outs(%subview_5 : memref>) { + ^bb0(%in: f32, %in_6: f32, %out: f32): + %6 = arith.subf %in, %in_6 : f32 + %7 = arith.mulf %5, %6 : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cdist_cpu.mlir b/issues/aten_c_kernels/results/aten_cdist_cpu.mlir new file mode 100644 index 000000000000..04a028feb6e8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cdist_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cdist_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 12 { + %0 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %cst) -> (f32) { + %2 = affine.load %arg0[%arg3, %arg5] : memref + %3 = affine.load %arg1[%arg4, %arg5] : memref + %4 = arith.subf %2, %3 : f32 + %5 = arith.mulf %4, %4 : f32 + %6 = arith.addf %arg6, %5 : f32 + affine.yield %6 : f32 + } + %1 = math.sqrt %0 : f32 + affine.store %1, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cdist_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_cdist_cpu/debuf.mlir new file mode 100644 index 000000000000..31a2414d36c3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cdist_cpu/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cdist_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c12 = arith.constant 12 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %0) -> (tensor) { + %alloca = memref.alloca(%c12) : memref + %3 = bufferization.to_tensor %alloca : memref + %extracted_slice = tensor.extract_slice %arg4[%arg3, 0] [1, %c12] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c12] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = math.sqrt %in : f32 + linalg.yield %5 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %arg4[%arg3, 0] [1, %c12] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cdist_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_cdist_cpu/matched.mlir new file mode 100644 index 000000000000..31a2414d36c3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cdist_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cdist_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c12 = arith.constant 12 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %0) -> (tensor) { + %alloca = memref.alloca(%c12) : memref + %3 = bufferization.to_tensor %alloca : memref + %extracted_slice = tensor.extract_slice %arg4[%arg3, 0] [1, %c12] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c12] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = math.sqrt %in : f32 + linalg.yield %5 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %arg4[%arg3, 0] [1, %c12] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cdist_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_cdist_cpu/orig.mlir new file mode 100644 index 000000000000..04a028feb6e8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cdist_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cdist_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 12 { + %0 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %cst) -> (f32) { + %2 = affine.load %arg0[%arg3, %arg5] : memref + %3 = affine.load %arg1[%arg4, %arg5] : memref + %4 = arith.subf %2, %3 : f32 + %5 = arith.mulf %4, %4 : f32 + %6 = arith.addf %arg6, %5 : f32 + affine.yield %6 : f32 + } + %1 = math.sqrt %0 : f32 + affine.store %1, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cdist_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_cdist_cpu/raised.mlir new file mode 100644 index 000000000000..c27d30296ab0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cdist_cpu/raised.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cdist_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c12 = arith.constant 12 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 16 { + %alloca = memref.alloca(%c12) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[%arg3, 0] [1, %c32] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c12, %c32] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[0] [%c12] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %0 = arith.subf %in, %in_4 : f32 + %1 = arith.mulf %0, %0 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + %subview_2 = memref.subview %alloca[0] [%c12] [1] : memref to memref> + %subview_3 = memref.subview %arg2[%arg3, 0] [1, %c12] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_2 : memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = math.sqrt %in : f32 + linalg.yield %0 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cdist_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_cdist_cpu_debuf.mlir new file mode 100644 index 000000000000..31a2414d36c3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cdist_cpu_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cdist_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c12 = arith.constant 12 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %0) -> (tensor) { + %alloca = memref.alloca(%c12) : memref + %3 = bufferization.to_tensor %alloca : memref + %extracted_slice = tensor.extract_slice %arg4[%arg3, 0] [1, %c12] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c12] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = math.sqrt %in : f32 + linalg.yield %5 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %arg4[%arg3, 0] [1, %c12] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cdist_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_cdist_cpu_linalg.mlir new file mode 100644 index 000000000000..c27d30296ab0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cdist_cpu_linalg.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cdist_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c12 = arith.constant 12 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 16 { + %alloca = memref.alloca(%c12) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[%arg3, 0] [1, %c32] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c12, %c32] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[0] [%c12] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %0 = arith.subf %in, %in_4 : f32 + %1 = arith.mulf %0, %0 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + %subview_2 = memref.subview %alloca[0] [%c12] [1] : memref to memref> + %subview_3 = memref.subview %arg2[%arg3, 0] [1, %c12] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_2 : memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = math.sqrt %in : f32 + linalg.yield %0 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ceil.mlir b/issues/aten_c_kernels/results/aten_ceil.mlir new file mode 100644 index 000000000000..6fc125eda848 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ceil.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ceil(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @ceilf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @ceilf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_ceil/debuf.mlir b/issues/aten_c_kernels/results/aten_ceil/debuf.mlir new file mode 100644 index 000000000000..8849b4f5e5f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ceil/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ceil(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.ceil %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @ceilf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_ceil/matched.mlir b/issues/aten_c_kernels/results/aten_ceil/matched.mlir new file mode 100644 index 000000000000..8849b4f5e5f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ceil/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ceil(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.ceil %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @ceilf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_ceil/orig.mlir b/issues/aten_c_kernels/results/aten_ceil/orig.mlir new file mode 100644 index 000000000000..6fc125eda848 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ceil/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ceil(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @ceilf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @ceilf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_ceil/raised.mlir b/issues/aten_c_kernels/results/aten_ceil/raised.mlir new file mode 100644 index 000000000000..1bda94d7ad6e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ceil/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ceil(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.ceil %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @ceilf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_ceil_debuf.mlir b/issues/aten_c_kernels/results/aten_ceil_debuf.mlir new file mode 100644 index 000000000000..8849b4f5e5f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ceil_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ceil(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.ceil %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @ceilf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_ceil_linalg.mlir b/issues/aten_c_kernels/results/aten_ceil_linalg.mlir new file mode 100644 index 000000000000..1bda94d7ad6e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ceil_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ceil(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.ceil %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @ceilf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_channel_shuffle.mlir b/issues/aten_c_kernels/results/aten_channel_shuffle.mlir new file mode 100644 index 000000000000..24ea9817ad97 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_channel_shuffle.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_channel_shuffle(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + %0 = affine.load %arg0[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + affine.store %0, %arg1[%arg2, %arg4, %arg3, %arg5, %arg6] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_channel_shuffle/debuf.mlir b/issues/aten_c_kernels/results/aten_channel_shuffle/debuf.mlir new file mode 100644 index 000000000000..dae2bc60437a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_channel_shuffle/debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d2, d1, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_channel_shuffle(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0, 0] [%c2, %c2, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c2, %c4, %c2, %c4, %c4] [1, 1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0, 0, 0, 0] [%c2, %c4, %c2, %c4, %c4] [1, 1, 1, 1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_channel_shuffle/matched.mlir b/issues/aten_c_kernels/results/aten_channel_shuffle/matched.mlir new file mode 100644 index 000000000000..dae2bc60437a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_channel_shuffle/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d2, d1, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_channel_shuffle(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0, 0] [%c2, %c2, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c2, %c4, %c2, %c4, %c4] [1, 1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0, 0, 0, 0] [%c2, %c4, %c2, %c4, %c4] [1, 1, 1, 1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_channel_shuffle/orig.mlir b/issues/aten_c_kernels/results/aten_channel_shuffle/orig.mlir new file mode 100644 index 000000000000..24ea9817ad97 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_channel_shuffle/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_channel_shuffle(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + %0 = affine.load %arg0[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + affine.store %0, %arg1[%arg2, %arg4, %arg3, %arg5, %arg6] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_channel_shuffle/raised.mlir b/issues/aten_c_kernels/results/aten_channel_shuffle/raised.mlir new file mode 100644 index 000000000000..c94318964b0f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_channel_shuffle/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d2, d1, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_channel_shuffle(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %subview = memref.subview %arg0[0, 0, 0, 0, 0] [%c2, %c2, %c4, %c4, %c4] [1, 1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c4, %c2, %c4, %c4] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_channel_shuffle_cpu.mlir b/issues/aten_c_kernels/results/aten_channel_shuffle_cpu.mlir new file mode 100644 index 000000000000..73b6c5886784 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_channel_shuffle_cpu.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_channel_shuffle_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 32 { + %0 = affine.load %arg0[%arg2, %arg4 + %arg3 * 3, %arg5] : memref + affine.store %0, %arg1[%arg2, %arg3 + %arg4 * 4, %arg5] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_channel_shuffle_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_channel_shuffle_cpu/debuf.mlir new file mode 100644 index 000000000000..784c404d4cdd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_channel_shuffle_cpu/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d2 + d1 * 3, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d2 * 4 + d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_channel_shuffle_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c4, %c3, %c32) {map = #map} : (tensor, index, index, index, index) -> tensor + %3 = polygeist.submap(%1, %c2, %c4, %c3, %c32) {map = #map1} : (tensor, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submapInverse(%1, %4, %c2, %c4, %c3, %c32) {map = #map1} : (tensor, tensor, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_channel_shuffle_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_channel_shuffle_cpu/matched.mlir new file mode 100644 index 000000000000..784c404d4cdd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_channel_shuffle_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d2 + d1 * 3, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d2 * 4 + d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_channel_shuffle_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c4, %c3, %c32) {map = #map} : (tensor, index, index, index, index) -> tensor + %3 = polygeist.submap(%1, %c2, %c4, %c3, %c32) {map = #map1} : (tensor, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submapInverse(%1, %4, %c2, %c4, %c3, %c32) {map = #map1} : (tensor, tensor, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_channel_shuffle_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_channel_shuffle_cpu/orig.mlir new file mode 100644 index 000000000000..73b6c5886784 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_channel_shuffle_cpu/orig.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_channel_shuffle_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 32 { + %0 = affine.load %arg0[%arg2, %arg4 + %arg3 * 3, %arg5] : memref + affine.store %0, %arg1[%arg2, %arg3 + %arg4 * 4, %arg5] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_channel_shuffle_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_channel_shuffle_cpu/raised.mlir new file mode 100644 index 000000000000..0c6b1cbb193d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_channel_shuffle_cpu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d2 + d1 * 3, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d2 * 4 + d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_channel_shuffle_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c32 = arith.constant 32 : index + %0 = polygeist.submap(%arg0, %c2, %c4, %c3, %c32) {map = #map} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %c2, %c4, %c3, %c32) {map = #map1} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_channel_shuffle_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_channel_shuffle_cpu_debuf.mlir new file mode 100644 index 000000000000..784c404d4cdd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_channel_shuffle_cpu_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d2 + d1 * 3, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d2 * 4 + d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_channel_shuffle_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c4, %c3, %c32) {map = #map} : (tensor, index, index, index, index) -> tensor + %3 = polygeist.submap(%1, %c2, %c4, %c3, %c32) {map = #map1} : (tensor, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submapInverse(%1, %4, %c2, %c4, %c3, %c32) {map = #map1} : (tensor, tensor, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_channel_shuffle_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_channel_shuffle_cpu_linalg.mlir new file mode 100644 index 000000000000..0c6b1cbb193d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_channel_shuffle_cpu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d2 + d1 * 3, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d2 * 4 + d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_channel_shuffle_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c32 = arith.constant 32 : index + %0 = polygeist.submap(%arg0, %c2, %c4, %c3, %c32) {map = #map} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %c2, %c4, %c3, %c32) {map = #map1} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_channel_shuffle_debuf.mlir b/issues/aten_c_kernels/results/aten_channel_shuffle_debuf.mlir new file mode 100644 index 000000000000..dae2bc60437a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_channel_shuffle_debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d2, d1, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_channel_shuffle(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0, 0] [%c2, %c2, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c2, %c4, %c2, %c4, %c4] [1, 1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0, 0, 0, 0] [%c2, %c4, %c2, %c4, %c4] [1, 1, 1, 1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_channel_shuffle_linalg.mlir b/issues/aten_c_kernels/results/aten_channel_shuffle_linalg.mlir new file mode 100644 index 000000000000..c94318964b0f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_channel_shuffle_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d2, d1, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_channel_shuffle(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %subview = memref.subview %arg0[0, 0, 0, 0, 0] [%c2, %c2, %c4, %c4, %c4] [1, 1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c4, %c2, %c4, %c4] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t.mlir new file mode 100644 index 000000000000..ad4b21eb2700 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_t(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_chebyshev_tf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_chebyshev_tf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t/debuf.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t/debuf.mlir new file mode 100644 index 000000000000..10f0b0e33e8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_t(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_chebyshev_tf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_chebyshev_tf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t/matched.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t/matched.mlir new file mode 100644 index 000000000000..10f0b0e33e8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_t(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_chebyshev_tf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_chebyshev_tf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t/orig.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t/orig.mlir new file mode 100644 index 000000000000..ad4b21eb2700 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_t(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_chebyshev_tf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_chebyshev_tf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t/raised.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t/raised.mlir new file mode 100644 index 000000000000..18b71b187fc4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_t(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_chebyshev_tf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_chebyshev_tf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t_debuf.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t_debuf.mlir new file mode 100644 index 000000000000..10f0b0e33e8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_t(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_chebyshev_tf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_chebyshev_tf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t_linalg.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t_linalg.mlir new file mode 100644 index 000000000000..18b71b187fc4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_t_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_t(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_chebyshev_tf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_chebyshev_tf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u.mlir new file mode 100644 index 000000000000..3ae53c438df9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_u(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_chebyshev_uf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_chebyshev_uf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u/debuf.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u/debuf.mlir new file mode 100644 index 000000000000..3055e513bdc6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_u(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_chebyshev_uf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_chebyshev_uf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u/matched.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u/matched.mlir new file mode 100644 index 000000000000..3055e513bdc6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_u(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_chebyshev_uf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_chebyshev_uf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u/orig.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u/orig.mlir new file mode 100644 index 000000000000..3ae53c438df9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_u(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_chebyshev_uf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_chebyshev_uf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u/raised.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u/raised.mlir new file mode 100644 index 000000000000..f74f2827d90e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_u(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_chebyshev_uf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_chebyshev_uf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u_debuf.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u_debuf.mlir new file mode 100644 index 000000000000..3055e513bdc6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_u(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_chebyshev_uf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_chebyshev_uf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u_linalg.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u_linalg.mlir new file mode 100644 index 000000000000..f74f2827d90e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_u_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_u(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_chebyshev_uf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_chebyshev_uf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v.mlir new file mode 100644 index 000000000000..7f7f4c418a90 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_v(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_chebyshev_vf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_chebyshev_vf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v/debuf.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v/debuf.mlir new file mode 100644 index 000000000000..45e773a861cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_v(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_chebyshev_vf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_chebyshev_vf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v/matched.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v/matched.mlir new file mode 100644 index 000000000000..45e773a861cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_v(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_chebyshev_vf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_chebyshev_vf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v/orig.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v/orig.mlir new file mode 100644 index 000000000000..7f7f4c418a90 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_v(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_chebyshev_vf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_chebyshev_vf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v/raised.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v/raised.mlir new file mode 100644 index 000000000000..a18063814c70 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_v(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_chebyshev_vf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_chebyshev_vf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v_debuf.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v_debuf.mlir new file mode 100644 index 000000000000..45e773a861cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_v(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_chebyshev_vf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_chebyshev_vf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v_linalg.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v_linalg.mlir new file mode 100644 index 000000000000..a18063814c70 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_v_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_v(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_chebyshev_vf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_chebyshev_vf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w.mlir new file mode 100644 index 000000000000..310dbd0eb5d5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_w(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_chebyshev_wf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_chebyshev_wf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w/debuf.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w/debuf.mlir new file mode 100644 index 000000000000..fd8d60394371 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_w(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_chebyshev_wf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_chebyshev_wf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w/matched.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w/matched.mlir new file mode 100644 index 000000000000..fd8d60394371 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_w(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_chebyshev_wf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_chebyshev_wf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w/orig.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w/orig.mlir new file mode 100644 index 000000000000..310dbd0eb5d5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_w(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_chebyshev_wf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_chebyshev_wf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w/raised.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w/raised.mlir new file mode 100644 index 000000000000..76cb42c06e04 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_w(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_chebyshev_wf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_chebyshev_wf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w_debuf.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w_debuf.mlir new file mode 100644 index 000000000000..fd8d60394371 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_w(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_chebyshev_wf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_chebyshev_wf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w_linalg.mlir b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w_linalg.mlir new file mode 100644 index 000000000000..76cb42c06e04 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_chebyshev_polynomial_w_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_chebyshev_polynomial_w(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_chebyshev_wf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_chebyshev_wf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_circular_pad_cpu.mlir b/issues/aten_c_kernels/results/aten_circular_pad_cpu.mlir new file mode 100644 index 000000000000..eed4d7012c98 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_circular_pad_cpu.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_circular_pad_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c32 = arith.constant 32 : index + %c-3 = arith.constant -3 : index + %c-1 = arith.constant -1 : index + %c-3_i32 = arith.constant -3 : i32 + %c32_i32 = arith.constant 32 : i32 + %c0 = arith.constant 0 : index + affine.for %arg2 = 0 to 38 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.addi %0, %c-3_i32 : i32 + %2 = arith.remsi %1, %c32_i32 : i32 + %3 = arith.addi %arg2, %c-3 : index + %4 = arith.cmpi slt, %3, %c0 : index + %5 = arith.subi %c2, %arg2 : index + %6 = arith.select %4, %5, %3 : index + %7 = arith.divsi %6, %c32 : index + %8 = arith.subi %c-1, %7 : index + %9 = arith.select %4, %8, %7 : index + %10 = arith.muli %9, %c32 : index + %11 = arith.subi %10, %arg2 : index + %12 = arith.addi %11, %c2 : index + %13 = arith.cmpi sge, %12, %c0 : index + %14 = scf.if %13 -> (i32) { + %17 = arith.addi %2, %c32_i32 : i32 + scf.yield %17 : i32 + } else { + scf.yield %2 : i32 + } + %15 = arith.index_cast %14 : i32 to index + %16 = memref.load %arg0[%15] : memref + affine.store %16, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_circular_pad_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_circular_pad_cpu/debuf.mlir new file mode 100644 index 000000000000..0fdbbaef2905 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_circular_pad_cpu/debuf.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_circular_pad_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32_i32 = arith.constant 32 : i32 + %c-3_i32 = arith.constant -3 : i32 + %c-1 = arith.constant -1 : index + %c-3 = arith.constant -3 : index + %c32 = arith.constant 32 : index + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.addi %4, %c-3_i32 : i32 + %6 = arith.remsi %5, %c32_i32 : i32 + %7 = arith.addi %3, %c-3 : index + %8 = arith.cmpi slt, %7, %c0 : index + %9 = arith.subi %c2, %3 : index + %10 = arith.select %8, %9, %7 : index + %11 = arith.divsi %10, %c32 : index + %12 = arith.subi %c-1, %11 : index + %13 = arith.select %8, %12, %11 : index + %14 = arith.muli %13, %c32 : index + %15 = arith.subi %14, %3 : index + %16 = arith.addi %15, %c2 : index + %17 = arith.cmpi sge, %16, %c0 : index + %18 = arith.addi %6, %c32_i32 : i32 + %19 = arith.select %17, %18, %6 : i32 + %20 = arith.index_cast %19 : i32 to index + %21 = memref.load %arg0[%20] : memref + linalg.yield %21 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_circular_pad_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_circular_pad_cpu/matched.mlir new file mode 100644 index 000000000000..0fdbbaef2905 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_circular_pad_cpu/matched.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_circular_pad_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32_i32 = arith.constant 32 : i32 + %c-3_i32 = arith.constant -3 : i32 + %c-1 = arith.constant -1 : index + %c-3 = arith.constant -3 : index + %c32 = arith.constant 32 : index + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.addi %4, %c-3_i32 : i32 + %6 = arith.remsi %5, %c32_i32 : i32 + %7 = arith.addi %3, %c-3 : index + %8 = arith.cmpi slt, %7, %c0 : index + %9 = arith.subi %c2, %3 : index + %10 = arith.select %8, %9, %7 : index + %11 = arith.divsi %10, %c32 : index + %12 = arith.subi %c-1, %11 : index + %13 = arith.select %8, %12, %11 : index + %14 = arith.muli %13, %c32 : index + %15 = arith.subi %14, %3 : index + %16 = arith.addi %15, %c2 : index + %17 = arith.cmpi sge, %16, %c0 : index + %18 = arith.addi %6, %c32_i32 : i32 + %19 = arith.select %17, %18, %6 : i32 + %20 = arith.index_cast %19 : i32 to index + %21 = memref.load %arg0[%20] : memref + linalg.yield %21 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_circular_pad_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_circular_pad_cpu/orig.mlir new file mode 100644 index 000000000000..eed4d7012c98 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_circular_pad_cpu/orig.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_circular_pad_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c32 = arith.constant 32 : index + %c-3 = arith.constant -3 : index + %c-1 = arith.constant -1 : index + %c-3_i32 = arith.constant -3 : i32 + %c32_i32 = arith.constant 32 : i32 + %c0 = arith.constant 0 : index + affine.for %arg2 = 0 to 38 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.addi %0, %c-3_i32 : i32 + %2 = arith.remsi %1, %c32_i32 : i32 + %3 = arith.addi %arg2, %c-3 : index + %4 = arith.cmpi slt, %3, %c0 : index + %5 = arith.subi %c2, %arg2 : index + %6 = arith.select %4, %5, %3 : index + %7 = arith.divsi %6, %c32 : index + %8 = arith.subi %c-1, %7 : index + %9 = arith.select %4, %8, %7 : index + %10 = arith.muli %9, %c32 : index + %11 = arith.subi %10, %arg2 : index + %12 = arith.addi %11, %c2 : index + %13 = arith.cmpi sge, %12, %c0 : index + %14 = scf.if %13 -> (i32) { + %17 = arith.addi %2, %c32_i32 : i32 + scf.yield %17 : i32 + } else { + scf.yield %2 : i32 + } + %15 = arith.index_cast %14 : i32 to index + %16 = memref.load %arg0[%15] : memref + affine.store %16, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_circular_pad_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_circular_pad_cpu/raised.mlir new file mode 100644 index 000000000000..dcb63f215896 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_circular_pad_cpu/raised.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_circular_pad_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %c32 = arith.constant 32 : index + %c-3 = arith.constant -3 : index + %c-1 = arith.constant -1 : index + %c-3_i32 = arith.constant -3 : i32 + %c32_i32 = arith.constant 32 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.addi %1, %c-3_i32 : i32 + %3 = arith.remsi %2, %c32_i32 : i32 + %4 = arith.addi %0, %c-3 : index + %5 = arith.cmpi slt, %4, %c0 : index + %6 = arith.subi %c2, %0 : index + %7 = arith.select %5, %6, %4 : index + %8 = arith.divsi %7, %c32 : index + %9 = arith.subi %c-1, %8 : index + %10 = arith.select %5, %9, %8 : index + %11 = arith.muli %10, %c32 : index + %12 = arith.subi %11, %0 : index + %13 = arith.addi %12, %c2 : index + %14 = arith.cmpi sge, %13, %c0 : index + %15 = arith.addi %3, %c32_i32 : i32 + %16 = arith.select %14, %15, %3 : i32 + %17 = arith.index_cast %16 : i32 to index + %18 = memref.load %arg0[%17] : memref + linalg.yield %18 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_circular_pad_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_circular_pad_cpu_debuf.mlir new file mode 100644 index 000000000000..0fdbbaef2905 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_circular_pad_cpu_debuf.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_circular_pad_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32_i32 = arith.constant 32 : i32 + %c-3_i32 = arith.constant -3 : i32 + %c-1 = arith.constant -1 : index + %c-3 = arith.constant -3 : index + %c32 = arith.constant 32 : index + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.addi %4, %c-3_i32 : i32 + %6 = arith.remsi %5, %c32_i32 : i32 + %7 = arith.addi %3, %c-3 : index + %8 = arith.cmpi slt, %7, %c0 : index + %9 = arith.subi %c2, %3 : index + %10 = arith.select %8, %9, %7 : index + %11 = arith.divsi %10, %c32 : index + %12 = arith.subi %c-1, %11 : index + %13 = arith.select %8, %12, %11 : index + %14 = arith.muli %13, %c32 : index + %15 = arith.subi %14, %3 : index + %16 = arith.addi %15, %c2 : index + %17 = arith.cmpi sge, %16, %c0 : index + %18 = arith.addi %6, %c32_i32 : i32 + %19 = arith.select %17, %18, %6 : i32 + %20 = arith.index_cast %19 : i32 to index + %21 = memref.load %arg0[%20] : memref + linalg.yield %21 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_circular_pad_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_circular_pad_cpu_linalg.mlir new file mode 100644 index 000000000000..dcb63f215896 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_circular_pad_cpu_linalg.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_circular_pad_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %c32 = arith.constant 32 : index + %c-3 = arith.constant -3 : index + %c-1 = arith.constant -1 : index + %c-3_i32 = arith.constant -3 : i32 + %c32_i32 = arith.constant 32 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.addi %1, %c-3_i32 : i32 + %3 = arith.remsi %2, %c32_i32 : i32 + %4 = arith.addi %0, %c-3 : index + %5 = arith.cmpi slt, %4, %c0 : index + %6 = arith.subi %c2, %0 : index + %7 = arith.select %5, %6, %4 : index + %8 = arith.divsi %7, %c32 : index + %9 = arith.subi %c-1, %8 : index + %10 = arith.select %5, %9, %8 : index + %11 = arith.muli %10, %c32 : index + %12 = arith.subi %11, %0 : index + %13 = arith.addi %12, %c2 : index + %14 = arith.cmpi sge, %13, %c0 : index + %15 = arith.addi %3, %c32_i32 : i32 + %16 = arith.select %14, %15, %3 : i32 + %17 = arith.index_cast %16 : i32 to index + %18 = memref.load %arg0[%17] : memref + linalg.yield %18 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp.mlir b/issues/aten_c_kernels/results/aten_clamp.mlir new file mode 100644 index 000000000000..241cf8ca4fe1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 256 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.cmpf olt, %0, %arg2 : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %arg2 : f32 + } else { + %3 = arith.cmpf ogt, %0, %arg3 : f32 + %4 = arith.select %3, %arg3, %0 : f32 + scf.yield %4 : f32 + } + affine.store %2, %arg1[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_clamp/debuf.mlir b/issues/aten_c_kernels/results/aten_clamp/debuf.mlir new file mode 100644 index 000000000000..920524738af0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %arg2 : f32 + %5 = arith.cmpf ogt, %in, %arg3 : f32 + %6 = arith.select %5, %arg3, %in : f32 + %7 = arith.select %4, %arg2, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp/matched.mlir b/issues/aten_c_kernels/results/aten_clamp/matched.mlir new file mode 100644 index 000000000000..920524738af0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %arg2 : f32 + %5 = arith.cmpf ogt, %in, %arg3 : f32 + %6 = arith.select %5, %arg3, %in : f32 + %7 = arith.select %4, %arg2, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp/orig.mlir b/issues/aten_c_kernels/results/aten_clamp/orig.mlir new file mode 100644 index 000000000000..241cf8ca4fe1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 256 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.cmpf olt, %0, %arg2 : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %arg2 : f32 + } else { + %3 = arith.cmpf ogt, %0, %arg3 : f32 + %4 = arith.select %3, %arg3, %0 : f32 + scf.yield %4 : f32 + } + affine.store %2, %arg1[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_clamp/raised.mlir b/issues/aten_c_kernels/results/aten_clamp/raised.mlir new file mode 100644 index 000000000000..27ad045543e7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %arg2 : f32 + %1 = arith.cmpf ogt, %in, %arg3 : f32 + %2 = arith.select %1, %arg3, %in : f32 + %3 = arith.select %0, %arg2, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_cpu.mlir b/issues/aten_c_kernels/results/aten_clamp_cpu.mlir new file mode 100644 index 000000000000..366f26f170ad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_cpu.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.cmpf olt, %0, %1 : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %1 : f32 + } else { + %4 = affine.load %arg2[%arg4] : memref + %5 = arith.cmpf ogt, %0, %4 : f32 + %6 = arith.select %5, %4, %0 : f32 + scf.yield %6 : f32 + } + affine.store %3, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_clamp_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_clamp_cpu/debuf.mlir new file mode 100644 index 000000000000..c39149fb8cd0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_cpu/debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.cmpf olt, %in, %in_0 : f32 + %7 = arith.cmpf ogt, %in, %in_1 : f32 + %8 = arith.select %7, %in_1, %in : f32 + %9 = arith.select %6, %in_0, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_clamp_cpu/matched.mlir new file mode 100644 index 000000000000..c39149fb8cd0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_cpu/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.cmpf olt, %in, %in_0 : f32 + %7 = arith.cmpf ogt, %in, %in_1 : f32 + %8 = arith.select %7, %in_1, %in : f32 + %9 = arith.select %6, %in_0, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_clamp_cpu/orig.mlir new file mode 100644 index 000000000000..366f26f170ad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_cpu/orig.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.cmpf olt, %0, %1 : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %1 : f32 + } else { + %4 = affine.load %arg2[%arg4] : memref + %5 = arith.cmpf ogt, %0, %4 : f32 + %6 = arith.select %5, %4, %0 : f32 + scf.yield %6 : f32 + } + affine.store %3, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_clamp_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_clamp_cpu/raised.mlir new file mode 100644 index 000000000000..b23a8b2b7247 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_cpu/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg2 : memref, memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.cmpf olt, %in, %in_0 : f32 + %1 = arith.cmpf ogt, %in, %in_1 : f32 + %2 = arith.select %1, %in_1, %in : f32 + %3 = arith.select %0, %in_0, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_clamp_cpu_debuf.mlir new file mode 100644 index 000000000000..c39149fb8cd0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_cpu_debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.cmpf olt, %in, %in_0 : f32 + %7 = arith.cmpf ogt, %in, %in_1 : f32 + %8 = arith.select %7, %in_1, %in : f32 + %9 = arith.select %6, %in_0, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_clamp_cpu_linalg.mlir new file mode 100644 index 000000000000..b23a8b2b7247 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_cpu_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg2 : memref, memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.cmpf olt, %in, %in_0 : f32 + %1 = arith.cmpf ogt, %in, %in_1 : f32 + %2 = arith.select %1, %in_1, %in : f32 + %3 = arith.select %0, %in_0, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_debuf.mlir b/issues/aten_c_kernels/results/aten_clamp_debuf.mlir new file mode 100644 index 000000000000..920524738af0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %arg2 : f32 + %5 = arith.cmpf ogt, %in, %arg3 : f32 + %6 = arith.select %5, %arg3, %in : f32 + %7 = arith.select %4, %arg2, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_linalg.mlir b/issues/aten_c_kernels/results/aten_clamp_linalg.mlir new file mode 100644 index 000000000000..27ad045543e7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %arg2 : f32 + %1 = arith.cmpf ogt, %in, %arg3 : f32 + %2 = arith.select %1, %arg3, %in : f32 + %3 = arith.select %0, %arg2, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu.mlir b/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu.mlir new file mode 100644 index 000000000000..835e08e0e413 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_max_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf ogt, %0, %arg1 : f32 + %2 = arith.select %1, %arg1, %0 : f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu/debuf.mlir new file mode 100644 index 000000000000..4025e5cf3441 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_max_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %arg1 : f32 + %5 = arith.select %4, %arg1, %in : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu/matched.mlir new file mode 100644 index 000000000000..4025e5cf3441 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_max_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %arg1 : f32 + %5 = arith.select %4, %arg1, %in : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu/orig.mlir new file mode 100644 index 000000000000..835e08e0e413 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_max_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf ogt, %0, %arg1 : f32 + %2 = arith.select %1, %arg1, %0 : f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu/raised.mlir new file mode 100644 index 000000000000..0e1e74b12ef0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_max_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %arg1 : f32 + %1 = arith.select %0, %arg1, %in : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu_debuf.mlir new file mode 100644 index 000000000000..4025e5cf3441 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_max_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %arg1 : f32 + %5 = arith.select %4, %arg1, %in : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu_linalg.mlir new file mode 100644 index 000000000000..0e1e74b12ef0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_max_scalar_cpu_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_max_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %arg1 : f32 + %1 = arith.select %0, %arg1, %in : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu.mlir b/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu.mlir new file mode 100644 index 000000000000..92662f56d599 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_min_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf olt, %0, %arg1 : f32 + %2 = arith.select %1, %arg1, %0 : f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu/debuf.mlir new file mode 100644 index 000000000000..2ab434de5133 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_min_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %arg1 : f32 + %5 = arith.select %4, %arg1, %in : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu/matched.mlir new file mode 100644 index 000000000000..2ab434de5133 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_min_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %arg1 : f32 + %5 = arith.select %4, %arg1, %in : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu/orig.mlir new file mode 100644 index 000000000000..92662f56d599 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_min_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf olt, %0, %arg1 : f32 + %2 = arith.select %1, %arg1, %0 : f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu/raised.mlir new file mode 100644 index 000000000000..613480e3edbe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_min_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %arg1 : f32 + %1 = arith.select %0, %arg1, %in : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu_debuf.mlir new file mode 100644 index 000000000000..2ab434de5133 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_min_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %arg1 : f32 + %5 = arith.select %4, %arg1, %in : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu_linalg.mlir new file mode 100644 index 000000000000..613480e3edbe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_min_scalar_cpu_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_min_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %arg1 : f32 + %1 = arith.select %0, %arg1, %in : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_scalar_cpu.mlir b/issues/aten_c_kernels/results/aten_clamp_scalar_cpu.mlir new file mode 100644 index 000000000000..1d3a7af32712 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_scalar_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.cmpf olt, %0, %arg1 : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %arg1 : f32 + } else { + %3 = arith.cmpf ogt, %0, %arg2 : f32 + %4 = arith.select %3, %arg2, %0 : f32 + scf.yield %4 : f32 + } + affine.store %2, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_clamp_scalar_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_clamp_scalar_cpu/debuf.mlir new file mode 100644 index 000000000000..5a157ff2b987 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_scalar_cpu/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %arg1 : f32 + %5 = arith.cmpf ogt, %in, %arg2 : f32 + %6 = arith.select %5, %arg2, %in : f32 + %7 = arith.select %4, %arg1, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_scalar_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_clamp_scalar_cpu/matched.mlir new file mode 100644 index 000000000000..5a157ff2b987 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_scalar_cpu/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %arg1 : f32 + %5 = arith.cmpf ogt, %in, %arg2 : f32 + %6 = arith.select %5, %arg2, %in : f32 + %7 = arith.select %4, %arg1, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_scalar_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_clamp_scalar_cpu/orig.mlir new file mode 100644 index 000000000000..1d3a7af32712 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_scalar_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.cmpf olt, %0, %arg1 : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %arg1 : f32 + } else { + %3 = arith.cmpf ogt, %0, %arg2 : f32 + %4 = arith.select %3, %arg2, %0 : f32 + scf.yield %4 : f32 + } + affine.store %2, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_clamp_scalar_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_clamp_scalar_cpu/raised.mlir new file mode 100644 index 000000000000..cb3640c55be1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_scalar_cpu/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %arg1 : f32 + %1 = arith.cmpf ogt, %in, %arg2 : f32 + %2 = arith.select %1, %arg2, %in : f32 + %3 = arith.select %0, %arg1, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_scalar_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_clamp_scalar_cpu_debuf.mlir new file mode 100644 index 000000000000..5a157ff2b987 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_scalar_cpu_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %arg1 : f32 + %5 = arith.cmpf ogt, %in, %arg2 : f32 + %6 = arith.select %5, %arg2, %in : f32 + %7 = arith.select %4, %arg1, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_clamp_scalar_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_clamp_scalar_cpu_linalg.mlir new file mode 100644 index 000000000000..cb3640c55be1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_clamp_scalar_cpu_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_clamp_scalar_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %arg1 : f32 + %1 = arith.cmpf ogt, %in, %arg2 : f32 + %2 = arith.select %1, %arg2, %in : f32 + %3 = arith.select %0, %arg1, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu.mlir b/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu.mlir new file mode 100644 index 000000000000..02867b3d7536 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu.mlir @@ -0,0 +1,42 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_coalesce_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %c0_i32) -> (i32) { + %1 = arith.index_cast %arg5 : index to i32 + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i1) { + %5 = affine.load %arg0[%arg5] : memref + %6 = arith.addi %arg6, %c-1_i32 : i32 + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg2[%7] : memref + %9 = arith.cmpi eq, %5, %8 : i32 + scf.yield %9 : i1 + } else { + scf.yield %false : i1 + } + %4 = scf.if %3 -> (i32) { + %5 = arith.addi %arg6, %c-1_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + %7 = affine.load %arg1[%arg5] : memref + %8 = memref.load %arg3[%6] : memref + %9 = arith.addf %8, %7 : f32 + memref.store %9, %arg3[%6] : memref + scf.yield %arg6 : i32 + } else { + %5 = arith.index_cast %arg6 : i32 to index + %6 = affine.load %arg0[%arg5] : memref + memref.store %6, %arg2[%5] : memref + %7 = arith.addi %arg6, %c1_i32 : i32 + %8 = affine.load %arg1[%arg5] : memref + memref.store %8, %arg3[%5] : memref + scf.yield %7 : i32 + } + affine.yield %4 : i32 + } + affine.store %0, %arg4[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu/debuf.mlir new file mode 100644 index 000000000000..e46bca5e9872 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu/debuf.mlir @@ -0,0 +1,53 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_coalesce_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c-1_i32 = arith.constant -1 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %c0_i32 into %0[%c0] : tensor + %5:3 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %2, %arg7 = %1, %arg8 = %inserted) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg8[%c0] : tensor + %9 = arith.index_cast %arg5 : index to i32 + %10 = arith.cmpi ne, %9, %c0_i32 : i32 + %extracted_0 = tensor.extract %4[%arg5] : tensor + %11 = arith.addi %extracted, %c-1_i32 : i32 + %12 = arith.index_cast %11 : i32 to index + %extracted_1 = tensor.extract %arg6[%12] : tensor + %13 = arith.cmpi eq, %extracted_0, %extracted_1 : i32 + %14 = arith.select %10, %13, %false : i1 + %15:3 = scf.if %14 -> (i32, tensor, tensor) { + %16 = arith.addi %extracted, %c-1_i32 : i32 + %17 = arith.index_cast %16 : i32 to index + %extracted_3 = tensor.extract %3[%arg5] : tensor + %extracted_4 = tensor.extract %arg7[%17] : tensor + %18 = arith.addf %extracted_4, %extracted_3 : f32 + %inserted_5 = tensor.insert %18 into %arg7[%17] : tensor + scf.yield %extracted, %arg6, %inserted_5 : i32, tensor, tensor + } else { + %16 = arith.index_cast %extracted : i32 to index + %extracted_3 = tensor.extract %4[%arg5] : tensor + %inserted_4 = tensor.insert %extracted_3 into %arg6[%16] : tensor + %17 = arith.addi %extracted, %c1_i32 : i32 + %extracted_5 = tensor.extract %3[%arg5] : tensor + %inserted_6 = tensor.insert %extracted_5 into %arg7[%16] : tensor + scf.yield %17, %inserted_4, %inserted_6 : i32, tensor, tensor + } + %inserted_2 = tensor.insert %15#0 into %arg8[%c0] : tensor + affine.yield %15#1, %15#2, %inserted_2 : tensor, tensor, tensor + } + %6 = bufferization.to_memref %5#2 : memref + memref.copy %6, %arg4 : memref to memref + %7 = bufferization.to_memref %5#1 : memref + memref.copy %7, %arg3 : memref to memref + %8 = bufferization.to_memref %5#0 : memref + memref.copy %8, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu/matched.mlir new file mode 100644 index 000000000000..e46bca5e9872 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu/matched.mlir @@ -0,0 +1,53 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_coalesce_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c-1_i32 = arith.constant -1 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %c0_i32 into %0[%c0] : tensor + %5:3 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %2, %arg7 = %1, %arg8 = %inserted) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg8[%c0] : tensor + %9 = arith.index_cast %arg5 : index to i32 + %10 = arith.cmpi ne, %9, %c0_i32 : i32 + %extracted_0 = tensor.extract %4[%arg5] : tensor + %11 = arith.addi %extracted, %c-1_i32 : i32 + %12 = arith.index_cast %11 : i32 to index + %extracted_1 = tensor.extract %arg6[%12] : tensor + %13 = arith.cmpi eq, %extracted_0, %extracted_1 : i32 + %14 = arith.select %10, %13, %false : i1 + %15:3 = scf.if %14 -> (i32, tensor, tensor) { + %16 = arith.addi %extracted, %c-1_i32 : i32 + %17 = arith.index_cast %16 : i32 to index + %extracted_3 = tensor.extract %3[%arg5] : tensor + %extracted_4 = tensor.extract %arg7[%17] : tensor + %18 = arith.addf %extracted_4, %extracted_3 : f32 + %inserted_5 = tensor.insert %18 into %arg7[%17] : tensor + scf.yield %extracted, %arg6, %inserted_5 : i32, tensor, tensor + } else { + %16 = arith.index_cast %extracted : i32 to index + %extracted_3 = tensor.extract %4[%arg5] : tensor + %inserted_4 = tensor.insert %extracted_3 into %arg6[%16] : tensor + %17 = arith.addi %extracted, %c1_i32 : i32 + %extracted_5 = tensor.extract %3[%arg5] : tensor + %inserted_6 = tensor.insert %extracted_5 into %arg7[%16] : tensor + scf.yield %17, %inserted_4, %inserted_6 : i32, tensor, tensor + } + %inserted_2 = tensor.insert %15#0 into %arg8[%c0] : tensor + affine.yield %15#1, %15#2, %inserted_2 : tensor, tensor, tensor + } + %6 = bufferization.to_memref %5#2 : memref + memref.copy %6, %arg4 : memref to memref + %7 = bufferization.to_memref %5#1 : memref + memref.copy %7, %arg3 : memref to memref + %8 = bufferization.to_memref %5#0 : memref + memref.copy %8, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu/orig.mlir new file mode 100644 index 000000000000..02867b3d7536 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu/orig.mlir @@ -0,0 +1,42 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_coalesce_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %c0_i32) -> (i32) { + %1 = arith.index_cast %arg5 : index to i32 + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i1) { + %5 = affine.load %arg0[%arg5] : memref + %6 = arith.addi %arg6, %c-1_i32 : i32 + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg2[%7] : memref + %9 = arith.cmpi eq, %5, %8 : i32 + scf.yield %9 : i1 + } else { + scf.yield %false : i1 + } + %4 = scf.if %3 -> (i32) { + %5 = arith.addi %arg6, %c-1_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + %7 = affine.load %arg1[%arg5] : memref + %8 = memref.load %arg3[%6] : memref + %9 = arith.addf %8, %7 : f32 + memref.store %9, %arg3[%6] : memref + scf.yield %arg6 : i32 + } else { + %5 = arith.index_cast %arg6 : i32 to index + %6 = affine.load %arg0[%arg5] : memref + memref.store %6, %arg2[%5] : memref + %7 = arith.addi %arg6, %c1_i32 : i32 + %8 = affine.load %arg1[%arg5] : memref + memref.store %8, %arg3[%5] : memref + scf.yield %7 : i32 + } + affine.yield %4 : i32 + } + affine.store %0, %arg4[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu/raised.mlir new file mode 100644 index 000000000000..5d84154c663f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu/raised.mlir @@ -0,0 +1,40 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_coalesce_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg4[0] : memref + affine.for %arg5 = 0 to 512 { + %0 = affine.load %arg4[0] : memref + %1 = arith.index_cast %arg5 : index to i32 + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = affine.load %arg0[%arg5] : memref + %4 = arith.addi %0, %c-1_i32 : i32 + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg2[%5] : memref + %7 = arith.cmpi eq, %3, %6 : i32 + %8 = arith.select %2, %7, %false : i1 + %9 = scf.if %8 -> (i32) { + %10 = arith.addi %0, %c-1_i32 : i32 + %11 = arith.index_cast %10 : i32 to index + %12 = affine.load %arg1[%arg5] : memref + %13 = memref.load %arg3[%11] : memref + %14 = arith.addf %13, %12 : f32 + memref.store %14, %arg3[%11] : memref + scf.yield %0 : i32 + } else { + %10 = arith.index_cast %0 : i32 to index + %11 = affine.load %arg0[%arg5] : memref + memref.store %11, %arg2[%10] : memref + %12 = arith.addi %0, %c1_i32 : i32 + %13 = affine.load %arg1[%arg5] : memref + memref.store %13, %arg3[%10] : memref + scf.yield %12 : i32 + } + affine.store %9, %arg4[0] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu_debuf.mlir new file mode 100644 index 000000000000..e46bca5e9872 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu_debuf.mlir @@ -0,0 +1,53 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_coalesce_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c-1_i32 = arith.constant -1 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %c0_i32 into %0[%c0] : tensor + %5:3 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %2, %arg7 = %1, %arg8 = %inserted) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg8[%c0] : tensor + %9 = arith.index_cast %arg5 : index to i32 + %10 = arith.cmpi ne, %9, %c0_i32 : i32 + %extracted_0 = tensor.extract %4[%arg5] : tensor + %11 = arith.addi %extracted, %c-1_i32 : i32 + %12 = arith.index_cast %11 : i32 to index + %extracted_1 = tensor.extract %arg6[%12] : tensor + %13 = arith.cmpi eq, %extracted_0, %extracted_1 : i32 + %14 = arith.select %10, %13, %false : i1 + %15:3 = scf.if %14 -> (i32, tensor, tensor) { + %16 = arith.addi %extracted, %c-1_i32 : i32 + %17 = arith.index_cast %16 : i32 to index + %extracted_3 = tensor.extract %3[%arg5] : tensor + %extracted_4 = tensor.extract %arg7[%17] : tensor + %18 = arith.addf %extracted_4, %extracted_3 : f32 + %inserted_5 = tensor.insert %18 into %arg7[%17] : tensor + scf.yield %extracted, %arg6, %inserted_5 : i32, tensor, tensor + } else { + %16 = arith.index_cast %extracted : i32 to index + %extracted_3 = tensor.extract %4[%arg5] : tensor + %inserted_4 = tensor.insert %extracted_3 into %arg6[%16] : tensor + %17 = arith.addi %extracted, %c1_i32 : i32 + %extracted_5 = tensor.extract %3[%arg5] : tensor + %inserted_6 = tensor.insert %extracted_5 into %arg7[%16] : tensor + scf.yield %17, %inserted_4, %inserted_6 : i32, tensor, tensor + } + %inserted_2 = tensor.insert %15#0 into %arg8[%c0] : tensor + affine.yield %15#1, %15#2, %inserted_2 : tensor, tensor, tensor + } + %6 = bufferization.to_memref %5#2 : memref + memref.copy %6, %arg4 : memref to memref + %7 = bufferization.to_memref %5#1 : memref + memref.copy %7, %arg3 : memref to memref + %8 = bufferization.to_memref %5#0 : memref + memref.copy %8, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu_linalg.mlir new file mode 100644 index 000000000000..5d84154c663f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_coalesce_sparse_cpu_linalg.mlir @@ -0,0 +1,40 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_coalesce_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg4[0] : memref + affine.for %arg5 = 0 to 512 { + %0 = affine.load %arg4[0] : memref + %1 = arith.index_cast %arg5 : index to i32 + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = affine.load %arg0[%arg5] : memref + %4 = arith.addi %0, %c-1_i32 : i32 + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg2[%5] : memref + %7 = arith.cmpi eq, %3, %6 : i32 + %8 = arith.select %2, %7, %false : i1 + %9 = scf.if %8 -> (i32) { + %10 = arith.addi %0, %c-1_i32 : i32 + %11 = arith.index_cast %10 : i32 to index + %12 = affine.load %arg1[%arg5] : memref + %13 = memref.load %arg3[%11] : memref + %14 = arith.addf %13, %12 : f32 + memref.store %14, %arg3[%11] : memref + scf.yield %0 : i32 + } else { + %10 = arith.index_cast %0 : i32 to index + %11 = affine.load %arg0[%arg5] : memref + memref.store %11, %arg2[%10] : memref + %12 = arith.addi %0, %c1_i32 : i32 + %13 = affine.load %arg1[%arg5] : memref + memref.store %13, %arg3[%10] : memref + scf.yield %12 : i32 + } + affine.store %9, %arg4[0] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_col2im_cpu.mlir b/issues/aten_c_kernels/results/aten_col2im_cpu.mlir new file mode 100644 index 000000000000..2cd23f06a259 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_col2im_cpu.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_col2im_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 200 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 8 { + affine.for %arg6 = 0 to 8 { + %1 = affine.load %arg0[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + %2 = affine.load %arg1[%arg2, %arg5 + %arg3, %arg6 + %arg4] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg5 + %arg3, %arg6 + %arg4] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_col2im_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_col2im_cpu/debuf.mlir new file mode 100644 index 000000000000..bf6f1d06885a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_col2im_cpu/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_col2im_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 200 { + %2 = arith.index_cast %arg2 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c8, %c8] [1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg1, %c2, %c3, %c3, %c8, %c8) {map = #map} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.addf %out, %in : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_col2im_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_col2im_cpu/matched.mlir new file mode 100644 index 000000000000..bf6f1d06885a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_col2im_cpu/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_col2im_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 200 { + %2 = arith.index_cast %arg2 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c8, %c8] [1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg1, %c2, %c3, %c3, %c8, %c8) {map = #map} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.addf %out, %in : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_col2im_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_col2im_cpu/orig.mlir new file mode 100644 index 000000000000..2cd23f06a259 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_col2im_cpu/orig.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_col2im_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 200 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 8 { + affine.for %arg6 = 0 to 8 { + %1 = affine.load %arg0[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + %2 = affine.load %arg1[%arg2, %arg5 + %arg3, %arg6 + %arg4] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg5 + %arg3, %arg6 + %arg4] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_col2im_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_col2im_cpu/raised.mlir new file mode 100644 index 000000000000..bf6f1d06885a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_col2im_cpu/raised.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_col2im_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 200 { + %2 = arith.index_cast %arg2 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c8, %c8] [1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg1, %c2, %c3, %c3, %c8, %c8) {map = #map} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.addf %out, %in : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_col2im_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_col2im_cpu_debuf.mlir new file mode 100644 index 000000000000..bf6f1d06885a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_col2im_cpu_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_col2im_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 200 { + %2 = arith.index_cast %arg2 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c8, %c8] [1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg1, %c2, %c3, %c3, %c8, %c8) {map = #map} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.addf %out, %in : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_col2im_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_col2im_cpu_linalg.mlir new file mode 100644 index 000000000000..bf6f1d06885a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_col2im_cpu_linalg.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_col2im_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 200 { + %2 = arith.index_cast %arg2 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c8, %c8] [1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg1, %c2, %c3, %c3, %c8, %c8) {map = #map} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.addf %out, %in : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_combinations_cpu.mlir b/issues/aten_c_kernels/results/aten_combinations_cpu.mlir new file mode 100644 index 000000000000..63e58c8104e3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_combinations_cpu.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_combinations_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c-1_i32 = arith.constant -1 : i32 + %c63_i32 = arith.constant 63 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 32 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.subi %c63_i32, %0 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg3 = #map(%arg2) to 32 { + %4 = arith.index_cast %arg3 : index to i32 + %5 = arith.subi %4, %0 : i32 + %6 = arith.addi %5, %c-1_i32 : i32 + %7 = arith.addi %3, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[%arg2] : memref + memref.store %9, %arg1[%8, %c0] : memref + %10 = affine.load %arg0[%arg3] : memref + memref.store %10, %arg1[%8, %c1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_combinations_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_combinations_cpu/debuf.mlir new file mode 100644 index 000000000000..b55643558620 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_combinations_cpu/debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_combinations_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c63_i32 = arith.constant 63 : i32 + %c-1_i32 = arith.constant -1 : i32 + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %0) -> (tensor) { + %4 = arith.index_cast %arg2 : index to i32 + %5 = arith.subi %c63_i32, %4 : i32 + %6 = arith.muli %4, %5 : i32 + %7 = arith.divsi %6, %c2_i32 : i32 + %8 = affine.for %arg4 = #map(%arg2) to 32 iter_args(%arg5 = %arg3) -> (tensor) { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.subi %9, %4 : i32 + %11 = arith.addi %10, %c-1_i32 : i32 + %12 = arith.addi %7, %11 : i32 + %13 = arith.index_cast %12 : i32 to index + %extracted = tensor.extract %1[%arg2] : tensor + %inserted = tensor.insert %extracted into %arg5[%13, %c0] : tensor + %extracted_0 = tensor.extract %1[%arg4] : tensor + %inserted_1 = tensor.insert %extracted_0 into %inserted[%13, %c1] : tensor + affine.yield %inserted_1 : tensor + } + affine.yield %8 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_combinations_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_combinations_cpu/matched.mlir new file mode 100644 index 000000000000..b55643558620 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_combinations_cpu/matched.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_combinations_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c63_i32 = arith.constant 63 : i32 + %c-1_i32 = arith.constant -1 : i32 + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %0) -> (tensor) { + %4 = arith.index_cast %arg2 : index to i32 + %5 = arith.subi %c63_i32, %4 : i32 + %6 = arith.muli %4, %5 : i32 + %7 = arith.divsi %6, %c2_i32 : i32 + %8 = affine.for %arg4 = #map(%arg2) to 32 iter_args(%arg5 = %arg3) -> (tensor) { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.subi %9, %4 : i32 + %11 = arith.addi %10, %c-1_i32 : i32 + %12 = arith.addi %7, %11 : i32 + %13 = arith.index_cast %12 : i32 to index + %extracted = tensor.extract %1[%arg2] : tensor + %inserted = tensor.insert %extracted into %arg5[%13, %c0] : tensor + %extracted_0 = tensor.extract %1[%arg4] : tensor + %inserted_1 = tensor.insert %extracted_0 into %inserted[%13, %c1] : tensor + affine.yield %inserted_1 : tensor + } + affine.yield %8 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_combinations_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_combinations_cpu/orig.mlir new file mode 100644 index 000000000000..63e58c8104e3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_combinations_cpu/orig.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_combinations_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c-1_i32 = arith.constant -1 : i32 + %c63_i32 = arith.constant 63 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 32 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.subi %c63_i32, %0 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg3 = #map(%arg2) to 32 { + %4 = arith.index_cast %arg3 : index to i32 + %5 = arith.subi %4, %0 : i32 + %6 = arith.addi %5, %c-1_i32 : i32 + %7 = arith.addi %3, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[%arg2] : memref + memref.store %9, %arg1[%8, %c0] : memref + %10 = affine.load %arg0[%arg3] : memref + memref.store %10, %arg1[%8, %c1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_combinations_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_combinations_cpu/raised.mlir new file mode 100644 index 000000000000..2757a2a8ab5f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_combinations_cpu/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_combinations_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c-1_i32 = arith.constant -1 : i32 + %c63_i32 = arith.constant 63 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 32 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.subi %c63_i32, %0 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg3 = #map(%arg2) to 32 { + %4 = arith.index_cast %arg3 : index to i32 + %5 = arith.subi %4, %0 : i32 + %6 = arith.addi %5, %c-1_i32 : i32 + %7 = arith.addi %3, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[%arg2] : memref + memref.store %9, %arg1[%8, %c0] : memref + %10 = affine.load %arg0[%arg3] : memref + memref.store %10, %arg1[%8, %c1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_combinations_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_combinations_cpu_debuf.mlir new file mode 100644 index 000000000000..b55643558620 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_combinations_cpu_debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_combinations_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c63_i32 = arith.constant 63 : i32 + %c-1_i32 = arith.constant -1 : i32 + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %0) -> (tensor) { + %4 = arith.index_cast %arg2 : index to i32 + %5 = arith.subi %c63_i32, %4 : i32 + %6 = arith.muli %4, %5 : i32 + %7 = arith.divsi %6, %c2_i32 : i32 + %8 = affine.for %arg4 = #map(%arg2) to 32 iter_args(%arg5 = %arg3) -> (tensor) { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.subi %9, %4 : i32 + %11 = arith.addi %10, %c-1_i32 : i32 + %12 = arith.addi %7, %11 : i32 + %13 = arith.index_cast %12 : i32 to index + %extracted = tensor.extract %1[%arg2] : tensor + %inserted = tensor.insert %extracted into %arg5[%13, %c0] : tensor + %extracted_0 = tensor.extract %1[%arg4] : tensor + %inserted_1 = tensor.insert %extracted_0 into %inserted[%13, %c1] : tensor + affine.yield %inserted_1 : tensor + } + affine.yield %8 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_combinations_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_combinations_cpu_linalg.mlir new file mode 100644 index 000000000000..2757a2a8ab5f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_combinations_cpu_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_combinations_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c-1_i32 = arith.constant -1 : i32 + %c63_i32 = arith.constant 63 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 32 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.subi %c63_i32, %0 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg3 = #map(%arg2) to 32 { + %4 = arith.index_cast %arg3 : index to i32 + %5 = arith.subi %4, %0 : i32 + %6 = arith.addi %5, %c-1_i32 : i32 + %7 = arith.addi %3, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[%arg2] : memref + memref.store %9, %arg1[%8, %c0] : memref + %10 = affine.load %arg0[%arg3] : memref + memref.store %10, %arg1[%8, %c1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_complex_scalarized.mlir b/issues/aten_c_kernels/results/aten_complex_scalarized.mlir new file mode 100644 index 000000000000..ba019bbed612 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_complex_scalarized.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + affine.store %0, %arg2[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + affine.store %1, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_complex_scalarized/debuf.mlir b/issues/aten_c_kernels/results/aten_complex_scalarized/debuf.mlir new file mode 100644 index 000000000000..6294040df950 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_complex_scalarized/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_complex_scalarized/matched.mlir b/issues/aten_c_kernels/results/aten_complex_scalarized/matched.mlir new file mode 100644 index 000000000000..f3e57eae3091 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_complex_scalarized/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = kernel.launch @cudaCopy1D_f32_tensor(%0, %2) : (tensor, tensor) -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + %6 = kernel.launch @cudaCopy1D_f32_tensor(%1, %3) : (tensor, tensor) -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_complex_scalarized/orig.mlir b/issues/aten_c_kernels/results/aten_complex_scalarized/orig.mlir new file mode 100644 index 000000000000..ba019bbed612 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_complex_scalarized/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + affine.store %0, %arg2[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + affine.store %1, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_complex_scalarized/raised.mlir b/issues/aten_c_kernels/results/aten_complex_scalarized/raised.mlir new file mode 100644 index 000000000000..fd8370f77963 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_complex_scalarized/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg1 : memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_complex_scalarized_debuf.mlir b/issues/aten_c_kernels/results/aten_complex_scalarized_debuf.mlir new file mode 100644 index 000000000000..6294040df950 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_complex_scalarized_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_complex_scalarized_linalg.mlir b/issues/aten_c_kernels/results/aten_complex_scalarized_linalg.mlir new file mode 100644 index 000000000000..fd8370f77963 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_complex_scalarized_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg1 : memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu.mlir b/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu.mlir new file mode 100644 index 000000000000..8c385a3e2fd4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_compressed_block_convert_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c4 = arith.constant 4 : index + %c0 = arith.constant 0 : index + affine.for %arg2 = 0 to 64 { + %0 = arith.cmpi slt, %arg2, %c0 : index + %1 = arith.subi %c-1, %arg2 : index + %2 = arith.select %0, %1, %arg2 : index + %3 = arith.divsi %2, %c4 : index + %4 = arith.subi %c-1, %3 : index + %5 = arith.select %0, %4, %3 : index + %6 = arith.remsi %arg2, %c4 : index + %7 = arith.cmpi slt, %6, %c0 : index + %8 = arith.addi %6, %c4 : index + %9 = arith.select %7, %8, %6 : index + affine.for %arg3 = 0 to 64 { + %10 = affine.load %arg0[%arg2, %arg3] : memref + %11 = arith.cmpi slt, %arg3, %c0 : index + %12 = arith.subi %c-1, %arg3 : index + %13 = arith.select %11, %12, %arg3 : index + %14 = arith.divsi %13, %c4 : index + %15 = arith.subi %c-1, %14 : index + %16 = arith.select %11, %15, %14 : index + %17 = arith.remsi %arg3, %c4 : index + %18 = arith.cmpi slt, %17, %c0 : index + %19 = arith.addi %17, %c4 : index + %20 = arith.select %18, %19, %17 : index + memref.store %10, %arg1[%5, %16, %9, %20] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu/debuf.mlir new file mode 100644 index 000000000000..462c5447d2bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu/debuf.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_compressed_block_convert_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c4 = arith.constant 4 : index + %c-1 = arith.constant -1 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 64 iter_args(%arg3 = %0) -> (tensor) { + %4 = arith.cmpi slt, %arg2, %c0 : index + %5 = arith.subi %c-1, %arg2 : index + %6 = arith.select %4, %5, %arg2 : index + %7 = arith.divsi %6, %c4 : index + %8 = arith.subi %c-1, %7 : index + %9 = arith.select %4, %8, %7 : index + %10 = arith.remsi %arg2, %c4 : index + %11 = arith.cmpi slt, %10, %c0 : index + %12 = arith.addi %10, %c4 : index + %13 = arith.select %11, %12, %10 : index + %14 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %arg3) -> (tensor) { + %extracted = tensor.extract %1[%arg2, %arg4] : tensor + %15 = arith.cmpi slt, %arg4, %c0 : index + %16 = arith.subi %c-1, %arg4 : index + %17 = arith.select %15, %16, %arg4 : index + %18 = arith.divsi %17, %c4 : index + %19 = arith.subi %c-1, %18 : index + %20 = arith.select %15, %19, %18 : index + %21 = arith.remsi %arg4, %c4 : index + %22 = arith.cmpi slt, %21, %c0 : index + %23 = arith.addi %21, %c4 : index + %24 = arith.select %22, %23, %21 : index + %inserted = tensor.insert %extracted into %arg5[%9, %20, %13, %24] : tensor + affine.yield %inserted : tensor + } + affine.yield %14 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu/matched.mlir new file mode 100644 index 000000000000..462c5447d2bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu/matched.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_compressed_block_convert_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c4 = arith.constant 4 : index + %c-1 = arith.constant -1 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 64 iter_args(%arg3 = %0) -> (tensor) { + %4 = arith.cmpi slt, %arg2, %c0 : index + %5 = arith.subi %c-1, %arg2 : index + %6 = arith.select %4, %5, %arg2 : index + %7 = arith.divsi %6, %c4 : index + %8 = arith.subi %c-1, %7 : index + %9 = arith.select %4, %8, %7 : index + %10 = arith.remsi %arg2, %c4 : index + %11 = arith.cmpi slt, %10, %c0 : index + %12 = arith.addi %10, %c4 : index + %13 = arith.select %11, %12, %10 : index + %14 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %arg3) -> (tensor) { + %extracted = tensor.extract %1[%arg2, %arg4] : tensor + %15 = arith.cmpi slt, %arg4, %c0 : index + %16 = arith.subi %c-1, %arg4 : index + %17 = arith.select %15, %16, %arg4 : index + %18 = arith.divsi %17, %c4 : index + %19 = arith.subi %c-1, %18 : index + %20 = arith.select %15, %19, %18 : index + %21 = arith.remsi %arg4, %c4 : index + %22 = arith.cmpi slt, %21, %c0 : index + %23 = arith.addi %21, %c4 : index + %24 = arith.select %22, %23, %21 : index + %inserted = tensor.insert %extracted into %arg5[%9, %20, %13, %24] : tensor + affine.yield %inserted : tensor + } + affine.yield %14 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu/orig.mlir new file mode 100644 index 000000000000..8c385a3e2fd4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu/orig.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_compressed_block_convert_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c4 = arith.constant 4 : index + %c0 = arith.constant 0 : index + affine.for %arg2 = 0 to 64 { + %0 = arith.cmpi slt, %arg2, %c0 : index + %1 = arith.subi %c-1, %arg2 : index + %2 = arith.select %0, %1, %arg2 : index + %3 = arith.divsi %2, %c4 : index + %4 = arith.subi %c-1, %3 : index + %5 = arith.select %0, %4, %3 : index + %6 = arith.remsi %arg2, %c4 : index + %7 = arith.cmpi slt, %6, %c0 : index + %8 = arith.addi %6, %c4 : index + %9 = arith.select %7, %8, %6 : index + affine.for %arg3 = 0 to 64 { + %10 = affine.load %arg0[%arg2, %arg3] : memref + %11 = arith.cmpi slt, %arg3, %c0 : index + %12 = arith.subi %c-1, %arg3 : index + %13 = arith.select %11, %12, %arg3 : index + %14 = arith.divsi %13, %c4 : index + %15 = arith.subi %c-1, %14 : index + %16 = arith.select %11, %15, %14 : index + %17 = arith.remsi %arg3, %c4 : index + %18 = arith.cmpi slt, %17, %c0 : index + %19 = arith.addi %17, %c4 : index + %20 = arith.select %18, %19, %17 : index + memref.store %10, %arg1[%5, %16, %9, %20] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu/raised.mlir new file mode 100644 index 000000000000..b6dd9e4a5cc1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu/raised.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_compressed_block_convert_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c4 = arith.constant 4 : index + %c0 = arith.constant 0 : index + affine.for %arg2 = 0 to 64 { + %0 = arith.cmpi slt, %arg2, %c0 : index + %1 = arith.subi %c-1, %arg2 : index + %2 = arith.select %0, %1, %arg2 : index + %3 = arith.divsi %2, %c4 : index + %4 = arith.subi %c-1, %3 : index + %5 = arith.select %0, %4, %3 : index + %6 = arith.remsi %arg2, %c4 : index + %7 = arith.cmpi slt, %6, %c0 : index + %8 = arith.addi %6, %c4 : index + %9 = arith.select %7, %8, %6 : index + affine.for %arg3 = 0 to 64 { + %10 = affine.load %arg0[%arg2, %arg3] : memref + %11 = arith.cmpi slt, %arg3, %c0 : index + %12 = arith.subi %c-1, %arg3 : index + %13 = arith.select %11, %12, %arg3 : index + %14 = arith.divsi %13, %c4 : index + %15 = arith.subi %c-1, %14 : index + %16 = arith.select %11, %15, %14 : index + %17 = arith.remsi %arg3, %c4 : index + %18 = arith.cmpi slt, %17, %c0 : index + %19 = arith.addi %17, %c4 : index + %20 = arith.select %18, %19, %17 : index + memref.store %10, %arg1[%5, %16, %9, %20] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu_debuf.mlir new file mode 100644 index 000000000000..462c5447d2bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu_debuf.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_compressed_block_convert_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c4 = arith.constant 4 : index + %c-1 = arith.constant -1 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 64 iter_args(%arg3 = %0) -> (tensor) { + %4 = arith.cmpi slt, %arg2, %c0 : index + %5 = arith.subi %c-1, %arg2 : index + %6 = arith.select %4, %5, %arg2 : index + %7 = arith.divsi %6, %c4 : index + %8 = arith.subi %c-1, %7 : index + %9 = arith.select %4, %8, %7 : index + %10 = arith.remsi %arg2, %c4 : index + %11 = arith.cmpi slt, %10, %c0 : index + %12 = arith.addi %10, %c4 : index + %13 = arith.select %11, %12, %10 : index + %14 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %arg3) -> (tensor) { + %extracted = tensor.extract %1[%arg2, %arg4] : tensor + %15 = arith.cmpi slt, %arg4, %c0 : index + %16 = arith.subi %c-1, %arg4 : index + %17 = arith.select %15, %16, %arg4 : index + %18 = arith.divsi %17, %c4 : index + %19 = arith.subi %c-1, %18 : index + %20 = arith.select %15, %19, %18 : index + %21 = arith.remsi %arg4, %c4 : index + %22 = arith.cmpi slt, %21, %c0 : index + %23 = arith.addi %21, %c4 : index + %24 = arith.select %22, %23, %21 : index + %inserted = tensor.insert %extracted into %arg5[%9, %20, %13, %24] : tensor + affine.yield %inserted : tensor + } + affine.yield %14 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu_linalg.mlir new file mode 100644 index 000000000000..b6dd9e4a5cc1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_compressed_block_convert_cpu_linalg.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_compressed_block_convert_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c4 = arith.constant 4 : index + %c0 = arith.constant 0 : index + affine.for %arg2 = 0 to 64 { + %0 = arith.cmpi slt, %arg2, %c0 : index + %1 = arith.subi %c-1, %arg2 : index + %2 = arith.select %0, %1, %arg2 : index + %3 = arith.divsi %2, %c4 : index + %4 = arith.subi %c-1, %3 : index + %5 = arith.select %0, %4, %3 : index + %6 = arith.remsi %arg2, %c4 : index + %7 = arith.cmpi slt, %6, %c0 : index + %8 = arith.addi %6, %c4 : index + %9 = arith.select %7, %8, %6 : index + affine.for %arg3 = 0 to 64 { + %10 = affine.load %arg0[%arg2, %arg3] : memref + %11 = arith.cmpi slt, %arg3, %c0 : index + %12 = arith.subi %c-1, %arg3 : index + %13 = arith.select %11, %12, %arg3 : index + %14 = arith.divsi %13, %c4 : index + %15 = arith.subi %c-1, %14 : index + %16 = arith.select %11, %15, %14 : index + %17 = arith.remsi %arg3, %c4 : index + %18 = arith.cmpi slt, %17, %c0 : index + %19 = arith.addi %17, %c4 : index + %20 = arith.select %18, %19, %17 : index + memref.store %10, %arg1[%5, %16, %9, %20] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conj_complex_scalarized.mlir b/issues/aten_c_kernels/results/aten_conj_complex_scalarized.mlir new file mode 100644 index 000000000000..c13a86ee8e31 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conj_complex_scalarized.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conj_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + affine.store %0, %arg2[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.negf %1 : f32 + affine.store %2, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conj_complex_scalarized/debuf.mlir b/issues/aten_c_kernels/results/aten_conj_complex_scalarized/debuf.mlir new file mode 100644 index 000000000000..6cfbfda261c8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conj_complex_scalarized/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conj_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + %8 = arith.negf %in : f32 + linalg.yield %8 : f32 + } -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conj_complex_scalarized/matched.mlir b/issues/aten_c_kernels/results/aten_conj_complex_scalarized/matched.mlir new file mode 100644 index 000000000000..af31c6556c58 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conj_complex_scalarized/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conj_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = kernel.launch @cudaCopy1D_f32_tensor(%0, %2) : (tensor, tensor) -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + %8 = arith.negf %in : f32 + linalg.yield %8 : f32 + } -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conj_complex_scalarized/orig.mlir b/issues/aten_c_kernels/results/aten_conj_complex_scalarized/orig.mlir new file mode 100644 index 000000000000..c13a86ee8e31 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conj_complex_scalarized/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conj_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + affine.store %0, %arg2[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.negf %1 : f32 + affine.store %2, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conj_complex_scalarized/raised.mlir b/issues/aten_c_kernels/results/aten_conj_complex_scalarized/raised.mlir new file mode 100644 index 000000000000..1607110016e2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conj_complex_scalarized/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conj_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg1 : memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.negf %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conj_complex_scalarized_debuf.mlir b/issues/aten_c_kernels/results/aten_conj_complex_scalarized_debuf.mlir new file mode 100644 index 000000000000..6cfbfda261c8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conj_complex_scalarized_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conj_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + %8 = arith.negf %in : f32 + linalg.yield %8 : f32 + } -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conj_complex_scalarized_linalg.mlir b/issues/aten_c_kernels/results/aten_conj_complex_scalarized_linalg.mlir new file mode 100644 index 000000000000..1607110016e2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conj_complex_scalarized_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conj_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg1 : memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.negf %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu.mlir b/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu.mlir new file mode 100644 index 000000000000..72ce45afb2aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_constant_pad_nd_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 38 { + affine.store %arg1, %arg2[%arg3] : memref + } + affine.for %arg3 = 0 to 32 { + %0 = affine.load %arg0[%arg3] : memref + affine.store %0, %arg2[%arg3 + 3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu/debuf.mlir new file mode 100644 index 000000000000..95dda153de6f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_constant_pad_nd_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %arg1 : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0] [%c32] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[3] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[3] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu/matched.mlir new file mode 100644 index 000000000000..551cf0115fef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu/matched.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_constant_pad_nd_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %arg1 : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0] [%c32] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[3] [%c32] [1] : tensor to tensor + %3 = kernel.launch @cudaCopy1D_f32_tensor(%extracted_slice, %extracted_slice_0) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[3] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu/orig.mlir new file mode 100644 index 000000000000..72ce45afb2aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_constant_pad_nd_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 38 { + affine.store %arg1, %arg2[%arg3] : memref + } + affine.for %arg3 = 0 to 32 { + %0 = affine.load %arg0[%arg3] : memref + affine.store %0, %arg2[%arg3 + 3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu/raised.mlir new file mode 100644 index 000000000000..97225238105b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu/raised.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_constant_pad_nd_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %arg1 : f32 + } + %subview = memref.subview %arg0[0] [%c32] [1] : memref to memref> + %subview_0 = memref.subview %arg2[3] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu_debuf.mlir new file mode 100644 index 000000000000..95dda153de6f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_constant_pad_nd_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %arg1 : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0] [%c32] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[3] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[3] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu_linalg.mlir new file mode 100644 index 000000000000..97225238105b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_constant_pad_nd_cpu_linalg.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_constant_pad_nd_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %arg1 : f32 + } + %subview = memref.subview %arg0[0] [%c32] [1] : memref to memref> + %subview_0 = memref.subview %arg2[3] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv1d.mlir b/issues/aten_c_kernels/results/aten_conv1d.mlir new file mode 100644 index 000000000000..9440a4cd3f33 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv1d.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv1d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 14 { + %0 = affine.load %arg2[%arg5] : memref + affine.store %0, %arg3[%arg4, %arg5, %arg6] : memref + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + %1 = affine.load %arg0[%arg4, %arg7, %arg6 + %arg8] : memref + %2 = affine.load %arg1[%arg5, %arg7, %arg8] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = affine.load %arg3[%arg4, %arg5, %arg6] : memref + %5 = arith.addf %4, %3 : f32 + affine.store %5, %arg3[%arg4, %arg5, %arg6] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv1d/debuf.mlir b/issues/aten_c_kernels/results/aten_conv1d/debuf.mlir new file mode 100644 index 000000000000..4be945a149d1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv1d/debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0, d1, d2) -> (d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4 + d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d1, d3, d4)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv1d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c14 = arith.constant 14 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %2[0] [%c4] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0, 0, 0] [%c2, %c4, %c14] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submap(%0, %c2, %c4, %c14, %c3, %c3) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c4, %c3, %c3] [1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map3, #map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%5, %extracted_slice_1 : tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %8 = arith.mulf %in, %in_2 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %3[0, 0, 0] [%c2, %c4, %c14] [1, 1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv1d/matched.mlir b/issues/aten_c_kernels/results/aten_conv1d/matched.mlir new file mode 100644 index 000000000000..4be945a149d1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv1d/matched.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0, d1, d2) -> (d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4 + d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d1, d3, d4)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv1d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c14 = arith.constant 14 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %2[0] [%c4] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0, 0, 0] [%c2, %c4, %c14] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submap(%0, %c2, %c4, %c14, %c3, %c3) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c4, %c3, %c3] [1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map3, #map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%5, %extracted_slice_1 : tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %8 = arith.mulf %in, %in_2 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %3[0, 0, 0] [%c2, %c4, %c14] [1, 1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv1d/orig.mlir b/issues/aten_c_kernels/results/aten_conv1d/orig.mlir new file mode 100644 index 000000000000..9440a4cd3f33 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv1d/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv1d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 14 { + %0 = affine.load %arg2[%arg5] : memref + affine.store %0, %arg3[%arg4, %arg5, %arg6] : memref + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + %1 = affine.load %arg0[%arg4, %arg7, %arg6 + %arg8] : memref + %2 = affine.load %arg1[%arg5, %arg7, %arg8] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = affine.load %arg3[%arg4, %arg5, %arg6] : memref + %5 = arith.addf %4, %3 : f32 + affine.store %5, %arg3[%arg4, %arg5, %arg6] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv1d/raised.mlir b/issues/aten_c_kernels/results/aten_conv1d/raised.mlir new file mode 100644 index 000000000000..9b7f00f4cb87 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv1d/raised.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2) -> (d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4 + d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d1, d3, d4)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv1d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %c14 = arith.constant 14 : index + %c3 = arith.constant 3 : index + %subview = memref.subview %arg2[0] [%c4] [1] : memref to memref> + %subview_0 = memref.subview %arg3[0, 0, 0] [%c2, %c4, %c14] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c4, %c14, %c3, %c3) {map = #map2} : (memref, index, index, index, index, index) -> memref + %subview_1 = memref.subview %arg1[0, 0, 0] [%c4, %c3, %c3] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg3[0, 0, 0] [%c2, %c4, %c14] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map3, #map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]} ins(%0, %subview_1 : memref, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %1 = arith.mulf %in, %in_3 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv1d_debuf.mlir b/issues/aten_c_kernels/results/aten_conv1d_debuf.mlir new file mode 100644 index 000000000000..4be945a149d1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv1d_debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0, d1, d2) -> (d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4 + d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d1, d3, d4)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv1d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c14 = arith.constant 14 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %2[0] [%c4] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0, 0, 0] [%c2, %c4, %c14] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submap(%0, %c2, %c4, %c14, %c3, %c3) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c4, %c3, %c3] [1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map3, #map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%5, %extracted_slice_1 : tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %8 = arith.mulf %in, %in_2 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %3[0, 0, 0] [%c2, %c4, %c14] [1, 1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv1d_linalg.mlir b/issues/aten_c_kernels/results/aten_conv1d_linalg.mlir new file mode 100644 index 000000000000..9b7f00f4cb87 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv1d_linalg.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2) -> (d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4 + d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d1, d3, d4)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv1d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %c14 = arith.constant 14 : index + %c3 = arith.constant 3 : index + %subview = memref.subview %arg2[0] [%c4] [1] : memref to memref> + %subview_0 = memref.subview %arg3[0, 0, 0] [%c2, %c4, %c14] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c4, %c14, %c3, %c3) {map = #map2} : (memref, index, index, index, index, index) -> memref + %subview_1 = memref.subview %arg1[0, 0, 0] [%c4, %c3, %c3] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg3[0, 0, 0] [%c2, %c4, %c14] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map3, #map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]} ins(%0, %subview_1 : memref, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %1 = arith.mulf %in, %in_3 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv2d.mlir b/issues/aten_c_kernels/results/aten_conv2d.mlir new file mode 100644 index 000000000000..b11144dee051 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv2d.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 14 { + affine.for %arg6 = 0 to 14 { + affine.store %cst, %arg2[%arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 14 { + affine.for %arg6 = 0 to 14 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + %0 = affine.load %arg0[%arg3, %arg7, %arg5 + %arg8, %arg6 + %arg9] : memref + %1 = affine.load %arg1[%arg4, %arg7, %arg8, %arg9] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg2[%arg3, %arg4, %arg5, %arg6] : memref + %4 = arith.addf %3, %2 : f32 + affine.store %4, %arg2[%arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv2d/debuf.mlir b/issues/aten_c_kernels/results/aten_conv2d/debuf.mlir new file mode 100644 index 000000000000..395a1886e67c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv2d/debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5 + d2, d6 + d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d1, d4, d5, d6)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c14 = arith.constant 14 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0, 0] [%c2, %c8, %c14, %c14] [1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = polygeist.submap(%0, %c2, %c8, %c14, %c14, %c4, %c3, %c3) {map = #map1} : (tensor, index, index, index, index, index, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0] [%c8, %c4, %c3, %c3] [1, 1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%4, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0, 0] [%c2, %c8, %c14, %c14] [1, 1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv2d/matched.mlir b/issues/aten_c_kernels/results/aten_conv2d/matched.mlir new file mode 100644 index 000000000000..2c0ac36cca7e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv2d/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5 + d2, d6 + d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d1, d4, d5, d6)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c14 = arith.constant 14 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0, 0] [%c2, %c8, %c14, %c14] [1, 1, 1, 1] : tensor to tensor + %4 = polygeist.submap(%0, %c2, %c8, %c14, %c14, %c4, %c3, %c3) {map = #map1} : (tensor, index, index, index, index, index, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0] [%c8, %c4, %c3, %c3] [1, 1, 1, 1] : tensor to tensor + %5 = kernel.launch @cudnnConvolutionFwd_batched(%4, %extracted_slice_0, %extracted_slice) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0, 0] [%c2, %c8, %c14, %c14] [1, 1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv2d/orig.mlir b/issues/aten_c_kernels/results/aten_conv2d/orig.mlir new file mode 100644 index 000000000000..b11144dee051 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv2d/orig.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 14 { + affine.for %arg6 = 0 to 14 { + affine.store %cst, %arg2[%arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 14 { + affine.for %arg6 = 0 to 14 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + %0 = affine.load %arg0[%arg3, %arg7, %arg5 + %arg8, %arg6 + %arg9] : memref + %1 = affine.load %arg1[%arg4, %arg7, %arg8, %arg9] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg2[%arg3, %arg4, %arg5, %arg6] : memref + %4 = arith.addf %3, %2 : f32 + affine.store %4, %arg2[%arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv2d/raised.mlir b/issues/aten_c_kernels/results/aten_conv2d/raised.mlir new file mode 100644 index 000000000000..8b68b87aad82 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv2d/raised.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5 + d2, d6 + d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d1, d4, d5, d6)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c14 = arith.constant 14 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0, 0] [%c2, %c8, %c14, %c14] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c8, %c14, %c14, %c4, %c3, %c3) {map = #map1} : (memref, index, index, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg1[0, 0, 0, 0] [%c8, %c4, %c3, %c3] [1, 1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0, 0, 0] [%c2, %c8, %c14, %c14] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%0, %subview_0 : memref, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %1 = arith.mulf %in, %in_2 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv2d_columns_cpu.mlir b/issues/aten_c_kernels/results/aten_conv2d_columns_cpu.mlir new file mode 100644 index 000000000000..5cee2003fd79 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv2d_columns_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv2d_columns_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 3 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 14 { + affine.for %arg6 = 0 to 14 { + %0 = affine.load %arg0[%arg2, %arg5 + %arg3, %arg6 + %arg4] : memref + affine.store %0, %arg1[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv2d_columns_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_conv2d_columns_cpu/debuf.mlir new file mode 100644 index 000000000000..d49610997e45 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv2d_columns_cpu/debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv2d_columns_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c14 = arith.constant 14 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c3, %c3, %c3, %c14, %c14) {map = #map} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c3, %c3, %c3, %c14, %c14] [1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0] [%c3, %c3, %c3, %c14, %c14] [1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv2d_columns_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_conv2d_columns_cpu/matched.mlir new file mode 100644 index 000000000000..d49610997e45 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv2d_columns_cpu/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv2d_columns_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c14 = arith.constant 14 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c3, %c3, %c3, %c14, %c14) {map = #map} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c3, %c3, %c3, %c14, %c14] [1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0] [%c3, %c3, %c3, %c14, %c14] [1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv2d_columns_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_conv2d_columns_cpu/orig.mlir new file mode 100644 index 000000000000..5cee2003fd79 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv2d_columns_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv2d_columns_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 3 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 14 { + affine.for %arg6 = 0 to 14 { + %0 = affine.load %arg0[%arg2, %arg5 + %arg3, %arg6 + %arg4] : memref + affine.store %0, %arg1[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv2d_columns_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_conv2d_columns_cpu/raised.mlir new file mode 100644 index 000000000000..676762f5bc0f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv2d_columns_cpu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv2d_columns_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c14 = arith.constant 14 : index + %0 = polygeist.submap(%arg0, %c3, %c3, %c3, %c14, %c14) {map = #map} : (memref, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0, 0] [%c3, %c3, %c3, %c14, %c14] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv2d_columns_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_conv2d_columns_cpu_debuf.mlir new file mode 100644 index 000000000000..d49610997e45 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv2d_columns_cpu_debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv2d_columns_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c14 = arith.constant 14 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c3, %c3, %c3, %c14, %c14) {map = #map} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c3, %c3, %c3, %c14, %c14] [1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0] [%c3, %c3, %c3, %c14, %c14] [1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv2d_columns_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_conv2d_columns_cpu_linalg.mlir new file mode 100644 index 000000000000..676762f5bc0f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv2d_columns_cpu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv2d_columns_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c14 = arith.constant 14 : index + %0 = polygeist.submap(%arg0, %c3, %c3, %c3, %c14, %c14) {map = #map} : (memref, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0, 0] [%c3, %c3, %c3, %c14, %c14] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv2d_debuf.mlir b/issues/aten_c_kernels/results/aten_conv2d_debuf.mlir new file mode 100644 index 000000000000..395a1886e67c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv2d_debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5 + d2, d6 + d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d1, d4, d5, d6)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c14 = arith.constant 14 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0, 0] [%c2, %c8, %c14, %c14] [1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = polygeist.submap(%0, %c2, %c8, %c14, %c14, %c4, %c3, %c3) {map = #map1} : (tensor, index, index, index, index, index, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0] [%c8, %c4, %c3, %c3] [1, 1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%4, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0, 0] [%c2, %c8, %c14, %c14] [1, 1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv2d_linalg.mlir b/issues/aten_c_kernels/results/aten_conv2d_linalg.mlir new file mode 100644 index 000000000000..8b68b87aad82 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv2d_linalg.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5 + d2, d6 + d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d1, d4, d5, d6)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c14 = arith.constant 14 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0, 0] [%c2, %c8, %c14, %c14] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c8, %c14, %c14, %c4, %c3, %c3) {map = #map1} : (memref, index, index, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg1[0, 0, 0, 0] [%c8, %c4, %c3, %c3] [1, 1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0, 0, 0] [%c2, %c8, %c14, %c14] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%0, %subview_0 : memref, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %1 = arith.mulf %in, %in_2 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv3d.mlir b/issues/aten_c_kernels/results/aten_conv3d.mlir new file mode 100644 index 000000000000..9e356d86e8f8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv3d.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.load %arg2[%arg4] : memref + affine.store %0, %arg3[0, %arg4, %arg5, %arg6, %arg7] : memref + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 3 { + %1 = affine.load %arg0[0, %arg8, %arg5 + %arg9, %arg6 + %arg10, %arg7 + %arg11] : memref + %2 = affine.load %arg1[%arg4, %arg8, %arg9, %arg10, %arg11] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = affine.load %arg3[0, %arg4, %arg5, %arg6, %arg7] : memref + %5 = arith.addf %4, %3 : f32 + affine.store %5, %arg3[0, %arg4, %arg5, %arg6, %arg7] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv3d/debuf.mlir b/issues/aten_c_kernels/results/aten_conv3d/debuf.mlir new file mode 100644 index 000000000000..120c9416fcc1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv3d/debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (0, d4, d5 + d1, d6 + d2, d7 + d3)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d4, d5, d6, d7)> +#map5 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %2[0] [%c3] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0, 0, 0, 0, 0] [1, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submap(%0, %c3, %c4, %c4, %c4, %c2, %c3, %c3, %c3) {map = #map2} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map3, #map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction", "reduction"], library_call = ""} ins(%5, %extracted_slice_1 : tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %8 = arith.mulf %in, %in_2 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %3[0, 0, 0, 0, 0] [1, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv3d/matched.mlir b/issues/aten_c_kernels/results/aten_conv3d/matched.mlir new file mode 100644 index 000000000000..ecd184abdcfa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv3d/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (0, d4, d5 + d1, d6 + d2, d7 + d3)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d4, d5, d6, d7)> +#map5 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %2[0] [%c3] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0, 0, 0, 0, 0] [1, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor to tensor + %5 = polygeist.submap(%0, %c3, %c4, %c4, %c4, %c2, %c3, %c3, %c3) {map = #map2} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : tensor to tensor + %6 = kernel.launch @cudnnConvolution3D_f32_bias(%5, %extracted_slice_1, %extracted_slice, %extracted_slice_0) : (tensor, tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %6 into %3[0, 0, 0, 0, 0] [1, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv3d/orig.mlir b/issues/aten_c_kernels/results/aten_conv3d/orig.mlir new file mode 100644 index 000000000000..9e356d86e8f8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv3d/orig.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.load %arg2[%arg4] : memref + affine.store %0, %arg3[0, %arg4, %arg5, %arg6, %arg7] : memref + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 3 { + %1 = affine.load %arg0[0, %arg8, %arg5 + %arg9, %arg6 + %arg10, %arg7 + %arg11] : memref + %2 = affine.load %arg1[%arg4, %arg8, %arg9, %arg10, %arg11] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = affine.load %arg3[0, %arg4, %arg5, %arg6, %arg7] : memref + %5 = arith.addf %4, %3 : f32 + affine.store %5, %arg3[0, %arg4, %arg5, %arg6, %arg7] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv3d/raised.mlir b/issues/aten_c_kernels/results/aten_conv3d/raised.mlir new file mode 100644 index 000000000000..79db0fc66a76 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv3d/raised.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (0, d4, d5 + d1, d6 + d2, d7 + d3)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d4, d5, d6, d7)> +#map5 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %subview = memref.subview %arg2[0] [%c3] [1] : memref to memref> + %subview_0 = memref.subview %arg3[0, 0, 0, 0, 0] [1, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %0 = polygeist.submap(%arg0, %c3, %c4, %c4, %c4, %c2, %c3, %c3, %c3) {map = #map2} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview_1 = memref.subview %arg1[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg3[0, 0, 0, 0, 0] [1, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map3, #map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction", "reduction"]} ins(%0, %subview_1 : memref, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %1 = arith.mulf %in, %in_3 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv3d_columns_cpu.mlir b/issues/aten_c_kernels/results/aten_conv3d_columns_cpu.mlir new file mode 100644 index 000000000000..d3802b3e90a8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv3d_columns_cpu.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv3d_columns_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 6 { + affine.for %arg7 = 0 to 7 { + affine.for %arg8 = 0 to 8 { + %0 = affine.load %arg0[%arg2, %arg6 + %arg3, %arg7 + %arg4, %arg8 + %arg5] : memref + affine.store %0, %arg1[%arg2, %arg3, %arg4, %arg5, %arg6, %arg7, %arg8] : memref + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv3d_columns_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_conv3d_columns_cpu/debuf.mlir new file mode 100644 index 000000000000..45a27ea7c3ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv3d_columns_cpu/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv3d_columns_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c3, %c3, %c3, %c6, %c7, %c8) {map = #map} : (tensor, index, index, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv3d_columns_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_conv3d_columns_cpu/matched.mlir new file mode 100644 index 000000000000..45a27ea7c3ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv3d_columns_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv3d_columns_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c3, %c3, %c3, %c6, %c7, %c8) {map = #map} : (tensor, index, index, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv3d_columns_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_conv3d_columns_cpu/orig.mlir new file mode 100644 index 000000000000..d3802b3e90a8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv3d_columns_cpu/orig.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv3d_columns_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 6 { + affine.for %arg7 = 0 to 7 { + affine.for %arg8 = 0 to 8 { + %0 = affine.load %arg0[%arg2, %arg6 + %arg3, %arg7 + %arg4, %arg8 + %arg5] : memref + affine.store %0, %arg1[%arg2, %arg3, %arg4, %arg5, %arg6, %arg7, %arg8] : memref + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv3d_columns_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_conv3d_columns_cpu/raised.mlir new file mode 100644 index 000000000000..0eea9d53b2cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv3d_columns_cpu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv3d_columns_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %0 = polygeist.submap(%arg0, %c2, %c3, %c3, %c3, %c6, %c7, %c8) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv3d_columns_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_conv3d_columns_cpu_debuf.mlir new file mode 100644 index 000000000000..45a27ea7c3ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv3d_columns_cpu_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv3d_columns_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c3, %c3, %c3, %c6, %c7, %c8) {map = #map} : (tensor, index, index, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv3d_columns_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_conv3d_columns_cpu_linalg.mlir new file mode 100644 index 000000000000..0eea9d53b2cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv3d_columns_cpu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv3d_columns_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %0 = polygeist.submap(%arg0, %c2, %c3, %c3, %c3, %c6, %c7, %c8) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv3d_debuf.mlir b/issues/aten_c_kernels/results/aten_conv3d_debuf.mlir new file mode 100644 index 000000000000..120c9416fcc1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv3d_debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (0, d4, d5 + d1, d6 + d2, d7 + d3)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d4, d5, d6, d7)> +#map5 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %2[0] [%c3] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0, 0, 0, 0, 0] [1, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submap(%0, %c3, %c4, %c4, %c4, %c2, %c3, %c3, %c3) {map = #map2} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map3, #map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction", "reduction"], library_call = ""} ins(%5, %extracted_slice_1 : tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %8 = arith.mulf %in, %in_2 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %3[0, 0, 0, 0, 0] [1, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv3d_linalg.mlir b/issues/aten_c_kernels/results/aten_conv3d_linalg.mlir new file mode 100644 index 000000000000..79db0fc66a76 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv3d_linalg.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (0, d4, d5 + d1, d6 + d2, d7 + d3)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d4, d5, d6, d7)> +#map5 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %subview = memref.subview %arg2[0] [%c3] [1] : memref to memref> + %subview_0 = memref.subview %arg3[0, 0, 0, 0, 0] [1, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %0 = polygeist.submap(%arg0, %c3, %c4, %c4, %c4, %c2, %c3, %c3, %c3) {map = #map2} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview_1 = memref.subview %arg1[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg3[0, 0, 0, 0, 0] [1, %c3, %c4, %c4, %c4] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map3, #map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction", "reduction"]} ins(%0, %subview_1 : memref, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %1 = arith.mulf %in, %in_3 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu.mlir new file mode 100644 index 000000000000..c24b955c83d4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_tbc_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 4096 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 30 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 24 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 16 { + %1 = affine.load %arg0[%arg3, %arg4, %arg5] : memref + %2 = affine.load %arg1[%arg6, %arg7, %arg5] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = affine.load %arg2[%arg3 + %arg6, %arg4, %arg7] : memref + %5 = arith.addf %4, %3 : f32 + affine.store %5, %arg2[%arg3 + %arg6, %arg4, %arg7] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..d2bf0bec6666 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu/debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d2 + d0, d1, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d3, d4, d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_tbc_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c30 = arith.constant 30 : index + %c8 = arith.constant 8 : index + %c24 = arith.constant 24 : index + %c3 = arith.constant 3 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 4096 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0] [%c30, %c8, %c24] [1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0] [%c3, %c16, %c24] [1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg2, %c30, %c8, %c3, %c16) {map = #map} : (memref, index, index, index, index) -> memref<30x8x3x16xf32> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%1 : memref<30x8x3x16xf32>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu/matched.mlir new file mode 100644 index 000000000000..d2bf0bec6666 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu/matched.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d2 + d0, d1, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d3, d4, d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_tbc_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c30 = arith.constant 30 : index + %c8 = arith.constant 8 : index + %c24 = arith.constant 24 : index + %c3 = arith.constant 3 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 4096 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0] [%c30, %c8, %c24] [1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0] [%c3, %c16, %c24] [1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg2, %c30, %c8, %c3, %c16) {map = #map} : (memref, index, index, index, index) -> memref<30x8x3x16xf32> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%1 : memref<30x8x3x16xf32>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu/orig.mlir new file mode 100644 index 000000000000..c24b955c83d4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu/orig.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_tbc_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 4096 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 30 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 24 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 16 { + %1 = affine.load %arg0[%arg3, %arg4, %arg5] : memref + %2 = affine.load %arg1[%arg6, %arg7, %arg5] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = affine.load %arg2[%arg3 + %arg6, %arg4, %arg7] : memref + %5 = arith.addf %4, %3 : f32 + affine.store %5, %arg2[%arg3 + %arg6, %arg4, %arg7] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu/raised.mlir new file mode 100644 index 000000000000..d2bf0bec6666 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu/raised.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d2 + d0, d1, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d3, d4, d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_tbc_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c30 = arith.constant 30 : index + %c8 = arith.constant 8 : index + %c24 = arith.constant 24 : index + %c3 = arith.constant 3 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 4096 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0] [%c30, %c8, %c24] [1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0] [%c3, %c16, %c24] [1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg2, %c30, %c8, %c3, %c16) {map = #map} : (memref, index, index, index, index) -> memref<30x8x3x16xf32> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%1 : memref<30x8x3x16xf32>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..d2bf0bec6666 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu_debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d2 + d0, d1, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d3, d4, d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_tbc_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c30 = arith.constant 30 : index + %c8 = arith.constant 8 : index + %c24 = arith.constant 24 : index + %c3 = arith.constant 3 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 4096 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0] [%c30, %c8, %c24] [1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0] [%c3, %c16, %c24] [1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg2, %c30, %c8, %c3, %c16) {map = #map} : (memref, index, index, index, index) -> memref<30x8x3x16xf32> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%1 : memref<30x8x3x16xf32>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..d2bf0bec6666 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_tbc_backward_cpu_linalg.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d2 + d0, d1, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d3, d4, d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_tbc_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c30 = arith.constant 30 : index + %c8 = arith.constant 8 : index + %c24 = arith.constant 24 : index + %c3 = arith.constant 3 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 4096 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0] [%c30, %c8, %c24] [1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0] [%c3, %c16, %c24] [1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg2, %c30, %c8, %c3, %c16) {map = #map} : (memref, index, index, index, index) -> memref<30x8x3x16xf32> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%1 : memref<30x8x3x16xf32>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_tbc_cpu.mlir b/issues/aten_c_kernels/results/aten_conv_tbc_cpu.mlir new file mode 100644 index 000000000000..8cd06d70806a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_tbc_cpu.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_tbc_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 30 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 24 { + %0 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %arg7) -> (f32) { + %2 = affine.load %arg0[%arg3 + %arg6, %arg4, %arg8] : memref + %3 = affine.load %arg1[%arg6, %arg8, %arg5] : memref + %4 = arith.mulf %2, %3 : f32 + %5 = arith.addf %arg9, %4 : f32 + affine.yield %5 : f32 + } + affine.yield %1 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv_tbc_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_conv_tbc_cpu/debuf.mlir new file mode 100644 index 000000000000..5af697c12358 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_tbc_cpu/debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d0, d1, d4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d3, d4, d2)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_tbc_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %c3 = arith.constant 3 : index + %c24 = arith.constant 24 : index + %c8 = arith.constant 8 : index + %c30 = arith.constant 30 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c30, %c8, %c24] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = polygeist.submap(%0, %c30, %c8, %c24, %c3, %c16) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0] [%c3, %c16, %c24] [1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%4, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0] [%c30, %c8, %c24] [1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_tbc_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_conv_tbc_cpu/matched.mlir new file mode 100644 index 000000000000..5af697c12358 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_tbc_cpu/matched.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d0, d1, d4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d3, d4, d2)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_tbc_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %c3 = arith.constant 3 : index + %c24 = arith.constant 24 : index + %c8 = arith.constant 8 : index + %c30 = arith.constant 30 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c30, %c8, %c24] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = polygeist.submap(%0, %c30, %c8, %c24, %c3, %c16) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0] [%c3, %c16, %c24] [1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%4, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0] [%c30, %c8, %c24] [1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_tbc_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_conv_tbc_cpu/orig.mlir new file mode 100644 index 000000000000..8cd06d70806a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_tbc_cpu/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_tbc_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 30 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 24 { + %0 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %arg7) -> (f32) { + %2 = affine.load %arg0[%arg3 + %arg6, %arg4, %arg8] : memref + %3 = affine.load %arg1[%arg6, %arg8, %arg5] : memref + %4 = arith.mulf %2, %3 : f32 + %5 = arith.addf %arg9, %4 : f32 + affine.yield %5 : f32 + } + affine.yield %1 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv_tbc_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_conv_tbc_cpu/raised.mlir new file mode 100644 index 000000000000..c82f029ac60d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_tbc_cpu/raised.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d0, d1, d4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d3, d4, d2)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_tbc_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c30 = arith.constant 30 : index + %c8 = arith.constant 8 : index + %c24 = arith.constant 24 : index + %c3 = arith.constant 3 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c30, %c8, %c24] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg0, %c30, %c8, %c24, %c3, %c16) {map = #map1} : (memref, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg1[0, 0, 0] [%c3, %c16, %c24] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0, 0] [%c30, %c8, %c24] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]} ins(%0, %subview_0 : memref, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %1 = arith.mulf %in, %in_2 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_tbc_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_conv_tbc_cpu_debuf.mlir new file mode 100644 index 000000000000..5af697c12358 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_tbc_cpu_debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d0, d1, d4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d3, d4, d2)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_tbc_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %c3 = arith.constant 3 : index + %c24 = arith.constant 24 : index + %c8 = arith.constant 8 : index + %c30 = arith.constant 30 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c30, %c8, %c24] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = polygeist.submap(%0, %c30, %c8, %c24, %c3, %c16) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0] [%c3, %c16, %c24] [1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%4, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0] [%c30, %c8, %c24] [1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_tbc_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_conv_tbc_cpu_linalg.mlir new file mode 100644 index 000000000000..c82f029ac60d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_tbc_cpu_linalg.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d0, d1, d4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d3, d4, d2)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_tbc_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c30 = arith.constant 30 : index + %c8 = arith.constant 8 : index + %c24 = arith.constant 24 : index + %c3 = arith.constant 3 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c30, %c8, %c24] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg0, %c30, %c8, %c24, %c3, %c16) {map = #map1} : (memref, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg1[0, 0, 0] [%c3, %c16, %c24] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0, 0] [%c30, %c8, %c24] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]} ins(%0, %subview_0 : memref, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %1 = arith.mulf %in, %in_2 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose2d.mlir b/issues/aten_c_kernels/results/aten_conv_transpose2d.mlir new file mode 100644 index 000000000000..754ae49a3660 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose2d.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 8 { + affine.store %cst, %arg2[0, %arg3, %arg4, %arg5] : memref + } + } + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 6 { + affine.for %arg5 = 0 to 6 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + %0 = affine.load %arg0[0, %arg3, %arg4, %arg5] : memref + %1 = affine.load %arg1[%arg3, %arg6, %arg7, %arg8] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg2[0, %arg6, %arg4 + %arg7, %arg5 + %arg8] : memref + %4 = arith.addf %3, %2 : f32 + affine.store %4, %arg2[0, %arg6, %arg4 + %arg7, %arg5 + %arg8] : memref + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv_transpose2d/debuf.mlir b/issues/aten_c_kernels/results/aten_conv_transpose2d/debuf.mlir new file mode 100644 index 000000000000..c4d1a544e365 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose2d/debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (0, d2, d3 + d0, d4 + d1)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d3, d4, d5)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d1, d2, d3, d4, d5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c6 = arith.constant 6 : index + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0, 0] [1, %c3, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0, 0, 0] [1, %c3, %c8, %c8] [1, 1, 1, 1] : tensor into tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0, 0] [1, %c2, %c6, %c6] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0, 0] [%c2, %c3, %c3, %c3] [1, 1, 1, 1] : tensor to tensor + %4 = polygeist.submap(%inserted_slice, %c6, %c6, %c3, %c3, %c3) {map = #map1} : (tensor, index, index, index, index, index) -> tensor<6x6x3x3x3xf32> + %5 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["reduction", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%4 : tensor<6x6x3x3x3xf32>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %8 = arith.mulf %in, %in_2 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor<6x6x3x3x3xf32> + %6 = polygeist.submapInverse(%inserted_slice, %5, %c6, %c6, %c3, %c3, %c3) {map = #map1} : (tensor, tensor<6x6x3x3x3xf32>, index, index, index, index, index) -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose2d/matched.mlir b/issues/aten_c_kernels/results/aten_conv_transpose2d/matched.mlir new file mode 100644 index 000000000000..c4d1a544e365 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose2d/matched.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (0, d2, d3 + d0, d4 + d1)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d3, d4, d5)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d1, d2, d3, d4, d5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c6 = arith.constant 6 : index + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0, 0] [1, %c3, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0, 0, 0] [1, %c3, %c8, %c8] [1, 1, 1, 1] : tensor into tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0, 0] [1, %c2, %c6, %c6] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0, 0] [%c2, %c3, %c3, %c3] [1, 1, 1, 1] : tensor to tensor + %4 = polygeist.submap(%inserted_slice, %c6, %c6, %c3, %c3, %c3) {map = #map1} : (tensor, index, index, index, index, index) -> tensor<6x6x3x3x3xf32> + %5 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["reduction", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%4 : tensor<6x6x3x3x3xf32>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %8 = arith.mulf %in, %in_2 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor<6x6x3x3x3xf32> + %6 = polygeist.submapInverse(%inserted_slice, %5, %c6, %c6, %c3, %c3, %c3) {map = #map1} : (tensor, tensor<6x6x3x3x3xf32>, index, index, index, index, index) -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose2d/orig.mlir b/issues/aten_c_kernels/results/aten_conv_transpose2d/orig.mlir new file mode 100644 index 000000000000..754ae49a3660 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose2d/orig.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 8 { + affine.store %cst, %arg2[0, %arg3, %arg4, %arg5] : memref + } + } + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 6 { + affine.for %arg5 = 0 to 6 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + %0 = affine.load %arg0[0, %arg3, %arg4, %arg5] : memref + %1 = affine.load %arg1[%arg3, %arg6, %arg7, %arg8] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg2[0, %arg6, %arg4 + %arg7, %arg5 + %arg8] : memref + %4 = arith.addf %3, %2 : f32 + affine.store %4, %arg2[0, %arg6, %arg4 + %arg7, %arg5 + %arg8] : memref + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv_transpose2d/raised.mlir b/issues/aten_c_kernels/results/aten_conv_transpose2d/raised.mlir new file mode 100644 index 000000000000..d716b79b98fa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose2d/raised.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (0, d2, d3 + d0, d4 + d1)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d3, d4, d5)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d1, d2, d3, d4, d5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0, 0] [1, %c3, %c8, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0, 0] [1, %c2, %c6, %c6] [1, 1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0, 0] [%c2, %c3, %c3, %c3] [1, 1, 1, 1] : memref to memref> + %0 = polygeist.submap(%arg2, %c6, %c6, %c3, %c3, %c3) {map = #map1} : (memref, index, index, index, index, index) -> memref<6x6x3x3x3xf32> + linalg.generic {indexing_maps = [#map2, #map3, #map4], iterator_types = ["reduction", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%0 : memref<6x6x3x3x3xf32>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %1 = arith.mulf %in, %in_2 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose2d_debuf.mlir b/issues/aten_c_kernels/results/aten_conv_transpose2d_debuf.mlir new file mode 100644 index 000000000000..c4d1a544e365 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose2d_debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (0, d2, d3 + d0, d4 + d1)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d3, d4, d5)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d1, d2, d3, d4, d5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c6 = arith.constant 6 : index + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0, 0] [1, %c3, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0, 0, 0] [1, %c3, %c8, %c8] [1, 1, 1, 1] : tensor into tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0, 0] [1, %c2, %c6, %c6] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0, 0] [%c2, %c3, %c3, %c3] [1, 1, 1, 1] : tensor to tensor + %4 = polygeist.submap(%inserted_slice, %c6, %c6, %c3, %c3, %c3) {map = #map1} : (tensor, index, index, index, index, index) -> tensor<6x6x3x3x3xf32> + %5 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["reduction", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%4 : tensor<6x6x3x3x3xf32>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %8 = arith.mulf %in, %in_2 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor<6x6x3x3x3xf32> + %6 = polygeist.submapInverse(%inserted_slice, %5, %c6, %c6, %c3, %c3, %c3) {map = #map1} : (tensor, tensor<6x6x3x3x3xf32>, index, index, index, index, index) -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose2d_linalg.mlir b/issues/aten_c_kernels/results/aten_conv_transpose2d_linalg.mlir new file mode 100644 index 000000000000..d716b79b98fa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose2d_linalg.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (0, d2, d3 + d0, d4 + d1)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d3, d4, d5)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d1, d2, d3, d4, d5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0, 0] [1, %c3, %c8, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0, 0] [1, %c2, %c6, %c6] [1, 1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0, 0] [%c2, %c3, %c3, %c3] [1, 1, 1, 1] : memref to memref> + %0 = polygeist.submap(%arg2, %c6, %c6, %c3, %c3, %c3) {map = #map1} : (memref, index, index, index, index, index) -> memref<6x6x3x3x3xf32> + linalg.generic {indexing_maps = [#map2, #map3, #map4], iterator_types = ["reduction", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%0 : memref<6x6x3x3x3xf32>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %1 = arith.mulf %in, %in_2 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu.mlir new file mode 100644 index 000000000000..ca2d06cb7c44 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 6 { + affine.for %arg5 = 0 to 7 { + affine.for %arg6 = 0 to 8 { + %0 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %cst) -> (f32) { + %1 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %arg8) -> (f32) { + %2 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %arg10) -> (f32) { + %3 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %arg12) -> (f32) { + %4 = affine.load %arg0[%arg7, %arg4 + %arg9, %arg5 + %arg11, %arg6 + %arg13] : memref + %5 = affine.load %arg1[%arg3, %arg7, %arg9, %arg11, %arg13] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.addf %arg14, %6 : f32 + affine.yield %7 : f32 + } + affine.yield %3 : f32 + } + affine.yield %2 : f32 + } + affine.yield %1 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..337d9b3cc46a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu/debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4, d5 + d1, d6 + d2, d7 + d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d4, d5, d6, d7)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c6 = arith.constant 6 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = polygeist.submap(%0, %c2, %c6, %c7, %c8, %c3, %c3, %c3, %c3) {map = #map1} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c3] [1, 1, 1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction", "reduction"], library_call = ""} ins(%4, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..dfad70e3c50e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4, d5 + d1, d6 + d2, d7 + d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d4, d5, d6, d7)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c6 = arith.constant 6 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : tensor to tensor + %4 = polygeist.submap(%0, %c2, %c6, %c7, %c8, %c3, %c3, %c3, %c3) {map = #map1} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c3] [1, 1, 1, 1, 1] : tensor to tensor + %5 = kernel.launch @cudnnConvolution3D_f32(%4, %extracted_slice_0, %extracted_slice) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..ca2d06cb7c44 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu/orig.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 6 { + affine.for %arg5 = 0 to 7 { + affine.for %arg6 = 0 to 8 { + %0 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %cst) -> (f32) { + %1 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %arg8) -> (f32) { + %2 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %arg10) -> (f32) { + %3 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %arg12) -> (f32) { + %4 = affine.load %arg0[%arg7, %arg4 + %arg9, %arg5 + %arg11, %arg6 + %arg13] : memref + %5 = affine.load %arg1[%arg3, %arg7, %arg9, %arg11, %arg13] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.addf %arg14, %6 : f32 + affine.yield %7 : f32 + } + affine.yield %3 : f32 + } + affine.yield %2 : f32 + } + affine.yield %1 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..8f4c3325b09b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu/raised.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4, d5 + d1, d6 + d2, d7 + d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d4, d5, d6, d7)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c6, %c7, %c8, %c3, %c3, %c3, %c3) {map = #map1} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction", "reduction"]} ins(%0, %subview_0 : memref, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %1 = arith.mulf %in, %in_2 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..337d9b3cc46a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu_debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4, d5 + d1, d6 + d2, d7 + d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d4, d5, d6, d7)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c6 = arith.constant 6 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = polygeist.submap(%0, %c2, %c6, %c7, %c8, %c3, %c3, %c3, %c3) {map = #map1} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c3] [1, 1, 1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction", "reduction"], library_call = ""} ins(%4, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..8f4c3325b09b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_backward_cpu_linalg.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4, d5 + d1, d6 + d2, d7 + d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d4, d5, d6, d7)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c6, %c7, %c8, %c3, %c3, %c3, %c3) {map = #map1} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction", "reduction"]} ins(%0, %subview_0 : memref, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %1 = arith.mulf %in, %in_2 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu.mlir new file mode 100644 index 000000000000..7707b588719d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 2160 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 6 { + affine.for %arg6 = 0 to 7 { + affine.for %arg7 = 0 to 8 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %1 = affine.load %arg0[%arg3, %arg5, %arg6, %arg7] : memref + %2 = affine.load %arg1[%arg3, %arg4, %arg8, %arg9, %arg10] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = affine.load %arg2[%arg4, %arg5 + %arg8, %arg6 + %arg9, %arg7 + %arg10] : memref + %5 = arith.addf %4, %3 : f32 + affine.store %5, %arg2[%arg4, %arg5 + %arg8, %arg6 + %arg9, %arg7 + %arg10] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu/debuf.mlir new file mode 100644 index 000000000000..d2fece46e063 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu/debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d2, d3, d4)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d2, d3, d4, d5, d6, d7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 2160 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg2, %c3, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref<3x6x7x8x3x3x3xf32> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["reduction", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%1 : memref<3x6x7x8x3x3x3xf32>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu/matched.mlir new file mode 100644 index 000000000000..d2fece46e063 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu/matched.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d2, d3, d4)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d2, d3, d4, d5, d6, d7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 2160 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg2, %c3, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref<3x6x7x8x3x3x3xf32> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["reduction", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%1 : memref<3x6x7x8x3x3x3xf32>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu/orig.mlir new file mode 100644 index 000000000000..7707b588719d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu/orig.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 2160 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 6 { + affine.for %arg6 = 0 to 7 { + affine.for %arg7 = 0 to 8 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %1 = affine.load %arg0[%arg3, %arg5, %arg6, %arg7] : memref + %2 = affine.load %arg1[%arg3, %arg4, %arg8, %arg9, %arg10] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = affine.load %arg2[%arg4, %arg5 + %arg8, %arg6 + %arg9, %arg7 + %arg10] : memref + %5 = arith.addf %4, %3 : f32 + affine.store %5, %arg2[%arg4, %arg5 + %arg8, %arg6 + %arg9, %arg7 + %arg10] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu/raised.mlir new file mode 100644 index 000000000000..d2fece46e063 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu/raised.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d2, d3, d4)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d2, d3, d4, d5, d6, d7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 2160 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg2, %c3, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref<3x6x7x8x3x3x3xf32> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["reduction", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%1 : memref<3x6x7x8x3x3x3xf32>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu_debuf.mlir new file mode 100644 index 000000000000..d2fece46e063 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu_debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d2, d3, d4)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d2, d3, d4, d5, d6, d7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 2160 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg2, %c3, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref<3x6x7x8x3x3x3xf32> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["reduction", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%1 : memref<3x6x7x8x3x3x3xf32>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu_linalg.mlir new file mode 100644 index 000000000000..d2fece46e063 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_cpu_linalg.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d2, d3, d4)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d2, d3, d4, d5, d6, d7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 2160 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg2, %c3, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref<3x6x7x8x3x3x3xf32> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["reduction", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%1 : memref<3x6x7x8x3x3x3xf32>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu.mlir new file mode 100644 index 000000000000..633091bff657 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_grad_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 162 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 6 { + affine.for %arg9 = 0 to 7 { + affine.for %arg10 = 0 to 8 { + %1 = affine.load %arg0[%arg3, %arg8, %arg9, %arg10] : memref + %2 = affine.load %arg1[%arg4, %arg8 + %arg5, %arg9 + %arg6, %arg10 + %arg7] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = affine.load %arg2[%arg3, %arg4, %arg5, %arg6, %arg7] : memref + %5 = arith.addf %4, %3 : f32 + affine.store %5, %arg2[%arg3, %arg4, %arg5, %arg6, %arg7] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu/debuf.mlir new file mode 100644 index 000000000000..10c60bbdd0e8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu/debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d5 + d2, d6 + d3, d7 + d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d5, d6, d7)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_grad_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 162 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg1, %c2, %c3, %c3, %c3, %c3, %c6, %c7, %c8) {map = #map} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg2[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%subview, %1 : memref>, memref) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu/matched.mlir new file mode 100644 index 000000000000..10c60bbdd0e8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu/matched.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d5 + d2, d6 + d3, d7 + d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d5, d6, d7)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_grad_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 162 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg1, %c2, %c3, %c3, %c3, %c3, %c6, %c7, %c8) {map = #map} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg2[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%subview, %1 : memref>, memref) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu/orig.mlir new file mode 100644 index 000000000000..633091bff657 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu/orig.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_grad_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 162 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 6 { + affine.for %arg9 = 0 to 7 { + affine.for %arg10 = 0 to 8 { + %1 = affine.load %arg0[%arg3, %arg8, %arg9, %arg10] : memref + %2 = affine.load %arg1[%arg4, %arg8 + %arg5, %arg9 + %arg6, %arg10 + %arg7] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = affine.load %arg2[%arg3, %arg4, %arg5, %arg6, %arg7] : memref + %5 = arith.addf %4, %3 : f32 + affine.store %5, %arg2[%arg3, %arg4, %arg5, %arg6, %arg7] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu/raised.mlir new file mode 100644 index 000000000000..10c60bbdd0e8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu/raised.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d5 + d2, d6 + d3, d7 + d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d5, d6, d7)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_grad_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 162 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg1, %c2, %c3, %c3, %c3, %c3, %c6, %c7, %c8) {map = #map} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg2[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%subview, %1 : memref>, memref) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu_debuf.mlir new file mode 100644 index 000000000000..10c60bbdd0e8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu_debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d5 + d2, d6 + d3, d7 + d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d5, d6, d7)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_grad_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 162 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg1, %c2, %c3, %c3, %c3, %c3, %c6, %c7, %c8) {map = #map} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg2[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%subview, %1 : memref>, memref) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu_linalg.mlir new file mode 100644 index 000000000000..10c60bbdd0e8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_conv_transpose3d_grad_weight_cpu_linalg.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d5 + d2, d6 + d3, d7 + d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d5, d6, d7)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_conv_transpose3d_grad_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 162 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0] [%c2, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg1, %c2, %c3, %c3, %c3, %c3, %c6, %c7, %c8) {map = #map} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg2[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%subview, %1 : memref>, memref) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu.mlir b/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu.mlir new file mode 100644 index 000000000000..2603ace2b3b9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_convert_coo_to_csr_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c512_i32 = arith.constant 512 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg2 = 0 to 65 iter_args(%arg3 = %c0_i32) -> (i32) { + %1 = arith.index_cast %arg2 : index to i32 + %2 = scf.while (%arg4 = %arg3) : (i32) -> i32 { + %3 = arith.cmpi slt, %arg4, %c512_i32 : i32 + %4:2 = scf.if %3 -> (i1, i32) { + %5 = arith.index_cast %arg4 : i32 to index + %6 = memref.load %arg0[%5] : memref + %7 = arith.cmpi slt, %6, %1 : i32 + %8 = scf.if %7 -> (i32) { + %9 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %9 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %7, %8 : i1, i32 + } else { + scf.yield %false, %arg4 : i1, i32 + } + scf.condition(%4#0) %4#1 : i32 + } do { + ^bb0(%arg4: i32): + scf.yield %arg4 : i32 + } + affine.store %2, %arg1[%arg2] : memref + affine.yield %2 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu/debuf.mlir new file mode 100644 index 000000000000..0d619454bc1c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu/debuf.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_convert_coo_to_csr_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c512_i32 = arith.constant 512 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %2[] : tensor + %3:2 = affine.for %arg2 = 0 to 65 iter_args(%arg3 = %inserted, %arg4 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg3[] : tensor + %5 = arith.index_cast %arg2 : index to i32 + %6 = scf.while (%arg5 = %extracted) : (i32) -> i32 { + %7 = arith.cmpi slt, %arg5, %c512_i32 : i32 + %8 = arith.index_cast %arg5 : i32 to index + %extracted_2 = tensor.extract %1[%8] : tensor + %9 = arith.cmpi slt, %extracted_2, %5 : i32 + %10 = arith.addi %arg5, %c1_i32 : i32 + %11 = arith.select %9, %10, %arg5 : i32 + %12 = arith.select %7, %9, %false : i1 + %13 = arith.select %7, %11, %arg5 : i32 + scf.condition(%12) %13 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %inserted_0 = tensor.insert %6 into %arg4[%arg2] : tensor + %inserted_1 = tensor.insert %6 into %arg3[] : tensor + affine.yield %inserted_1, %inserted_0 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu/matched.mlir new file mode 100644 index 000000000000..0d619454bc1c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu/matched.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_convert_coo_to_csr_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c512_i32 = arith.constant 512 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %2[] : tensor + %3:2 = affine.for %arg2 = 0 to 65 iter_args(%arg3 = %inserted, %arg4 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg3[] : tensor + %5 = arith.index_cast %arg2 : index to i32 + %6 = scf.while (%arg5 = %extracted) : (i32) -> i32 { + %7 = arith.cmpi slt, %arg5, %c512_i32 : i32 + %8 = arith.index_cast %arg5 : i32 to index + %extracted_2 = tensor.extract %1[%8] : tensor + %9 = arith.cmpi slt, %extracted_2, %5 : i32 + %10 = arith.addi %arg5, %c1_i32 : i32 + %11 = arith.select %9, %10, %arg5 : i32 + %12 = arith.select %7, %9, %false : i1 + %13 = arith.select %7, %11, %arg5 : i32 + scf.condition(%12) %13 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %inserted_0 = tensor.insert %6 into %arg4[%arg2] : tensor + %inserted_1 = tensor.insert %6 into %arg3[] : tensor + affine.yield %inserted_1, %inserted_0 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu/orig.mlir new file mode 100644 index 000000000000..2603ace2b3b9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu/orig.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_convert_coo_to_csr_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c512_i32 = arith.constant 512 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg2 = 0 to 65 iter_args(%arg3 = %c0_i32) -> (i32) { + %1 = arith.index_cast %arg2 : index to i32 + %2 = scf.while (%arg4 = %arg3) : (i32) -> i32 { + %3 = arith.cmpi slt, %arg4, %c512_i32 : i32 + %4:2 = scf.if %3 -> (i1, i32) { + %5 = arith.index_cast %arg4 : i32 to index + %6 = memref.load %arg0[%5] : memref + %7 = arith.cmpi slt, %6, %1 : i32 + %8 = scf.if %7 -> (i32) { + %9 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %9 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %7, %8 : i1, i32 + } else { + scf.yield %false, %arg4 : i1, i32 + } + scf.condition(%4#0) %4#1 : i32 + } do { + ^bb0(%arg4: i32): + scf.yield %arg4 : i32 + } + affine.store %2, %arg1[%arg2] : memref + affine.yield %2 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu/raised.mlir new file mode 100644 index 000000000000..3595612db8e3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu/raised.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_convert_coo_to_csr_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c512_i32 = arith.constant 512 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg2 = 0 to 65 { + %0 = affine.load %alloca[] : memref + %1 = arith.index_cast %arg2 : index to i32 + %2 = scf.while (%arg3 = %0) : (i32) -> i32 { + %3 = arith.cmpi slt, %arg3, %c512_i32 : i32 + %4 = arith.index_cast %arg3 : i32 to index + %5 = memref.load %arg0[%4] : memref + %6 = arith.cmpi slt, %5, %1 : i32 + %7 = arith.addi %arg3, %c1_i32 : i32 + %8 = arith.select %6, %7, %arg3 : i32 + %9 = arith.select %3, %6, %false : i1 + %10 = arith.select %3, %8, %arg3 : i32 + scf.condition(%9) %10 : i32 + } do { + ^bb0(%arg3: i32): + scf.yield %arg3 : i32 + } + affine.store %2, %arg1[%arg2] : memref + affine.store %2, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu_debuf.mlir new file mode 100644 index 000000000000..0d619454bc1c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu_debuf.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_convert_coo_to_csr_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c512_i32 = arith.constant 512 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %2[] : tensor + %3:2 = affine.for %arg2 = 0 to 65 iter_args(%arg3 = %inserted, %arg4 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg3[] : tensor + %5 = arith.index_cast %arg2 : index to i32 + %6 = scf.while (%arg5 = %extracted) : (i32) -> i32 { + %7 = arith.cmpi slt, %arg5, %c512_i32 : i32 + %8 = arith.index_cast %arg5 : i32 to index + %extracted_2 = tensor.extract %1[%8] : tensor + %9 = arith.cmpi slt, %extracted_2, %5 : i32 + %10 = arith.addi %arg5, %c1_i32 : i32 + %11 = arith.select %9, %10, %arg5 : i32 + %12 = arith.select %7, %9, %false : i1 + %13 = arith.select %7, %11, %arg5 : i32 + scf.condition(%12) %13 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %inserted_0 = tensor.insert %6 into %arg4[%arg2] : tensor + %inserted_1 = tensor.insert %6 into %arg3[] : tensor + affine.yield %inserted_1, %inserted_0 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu_linalg.mlir new file mode 100644 index 000000000000..3595612db8e3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_convert_coo_to_csr_cpu_linalg.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_convert_coo_to_csr_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c512_i32 = arith.constant 512 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg2 = 0 to 65 { + %0 = affine.load %alloca[] : memref + %1 = arith.index_cast %arg2 : index to i32 + %2 = scf.while (%arg3 = %0) : (i32) -> i32 { + %3 = arith.cmpi slt, %arg3, %c512_i32 : i32 + %4 = arith.index_cast %arg3 : i32 to index + %5 = memref.load %arg0[%4] : memref + %6 = arith.cmpi slt, %5, %1 : i32 + %7 = arith.addi %arg3, %c1_i32 : i32 + %8 = arith.select %6, %7, %arg3 : i32 + %9 = arith.select %3, %6, %false : i1 + %10 = arith.select %3, %8, %arg3 : i32 + scf.condition(%9) %10 : i32 + } do { + ^bb0(%arg3: i32): + scf.yield %arg3 : i32 + } + affine.store %2, %arg1[%arg2] : memref + affine.store %2, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu.mlir b/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu.mlir new file mode 100644 index 000000000000..351dfa47e50d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_convert_csr_to_coo_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + affine.for %arg3 = 0 to 64 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = affine.load %arg0[%arg3] : memref + %2 = scf.while (%arg4 = %1) : (i32) -> i32 { + %3 = affine.load %arg0[%arg3 + 1] : memref + %4 = arith.cmpi slt, %arg4, %3 : i32 + scf.condition(%4) %arg4 : i32 + } do { + ^bb0(%arg4: i32): + %3 = arith.index_cast %arg4 : i32 to index + memref.store %0, %arg2[%3] : memref + %4 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %4 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu/debuf.mlir new file mode 100644 index 000000000000..0f3b22b1ceaa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu/debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_convert_csr_to_coo_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %0) -> (tensor) { + %4 = arith.index_cast %arg3 : index to i32 + %extracted = tensor.extract %1[%arg3] : tensor + %5:2 = scf.while (%arg5 = %extracted, %arg6 = %arg4) : (i32, tensor) -> (i32, tensor) { + %6 = affine.apply #map(%arg3) + %extracted_0 = tensor.extract %1[%6] : tensor + %7 = arith.cmpi slt, %arg5, %extracted_0 : i32 + scf.condition(%7) %arg5, %arg6 : i32, tensor + } do { + ^bb0(%arg5: i32, %arg6: tensor): + %6 = arith.index_cast %arg5 : i32 to index + %inserted = tensor.insert %4 into %arg6[%6] : tensor + %7 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %7, %inserted : i32, tensor + } + affine.yield %5#1 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu/matched.mlir new file mode 100644 index 000000000000..0f3b22b1ceaa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu/matched.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_convert_csr_to_coo_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %0) -> (tensor) { + %4 = arith.index_cast %arg3 : index to i32 + %extracted = tensor.extract %1[%arg3] : tensor + %5:2 = scf.while (%arg5 = %extracted, %arg6 = %arg4) : (i32, tensor) -> (i32, tensor) { + %6 = affine.apply #map(%arg3) + %extracted_0 = tensor.extract %1[%6] : tensor + %7 = arith.cmpi slt, %arg5, %extracted_0 : i32 + scf.condition(%7) %arg5, %arg6 : i32, tensor + } do { + ^bb0(%arg5: i32, %arg6: tensor): + %6 = arith.index_cast %arg5 : i32 to index + %inserted = tensor.insert %4 into %arg6[%6] : tensor + %7 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %7, %inserted : i32, tensor + } + affine.yield %5#1 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu/orig.mlir new file mode 100644 index 000000000000..351dfa47e50d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu/orig.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_convert_csr_to_coo_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + affine.for %arg3 = 0 to 64 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = affine.load %arg0[%arg3] : memref + %2 = scf.while (%arg4 = %1) : (i32) -> i32 { + %3 = affine.load %arg0[%arg3 + 1] : memref + %4 = arith.cmpi slt, %arg4, %3 : i32 + scf.condition(%4) %arg4 : i32 + } do { + ^bb0(%arg4: i32): + %3 = arith.index_cast %arg4 : i32 to index + memref.store %0, %arg2[%3] : memref + %4 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %4 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu/raised.mlir new file mode 100644 index 000000000000..3845451a3648 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu/raised.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_convert_csr_to_coo_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + affine.for %arg3 = 0 to 64 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = affine.load %arg0[%arg3] : memref + %2 = scf.while (%arg4 = %1) : (i32) -> i32 { + %3 = affine.load %arg0[%arg3 + 1] : memref + %4 = arith.cmpi slt, %arg4, %3 : i32 + scf.condition(%4) %arg4 : i32 + } do { + ^bb0(%arg4: i32): + %3 = arith.index_cast %arg4 : i32 to index + memref.store %0, %arg2[%3] : memref + %4 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %4 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu_debuf.mlir new file mode 100644 index 000000000000..0f3b22b1ceaa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu_debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_convert_csr_to_coo_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %0) -> (tensor) { + %4 = arith.index_cast %arg3 : index to i32 + %extracted = tensor.extract %1[%arg3] : tensor + %5:2 = scf.while (%arg5 = %extracted, %arg6 = %arg4) : (i32, tensor) -> (i32, tensor) { + %6 = affine.apply #map(%arg3) + %extracted_0 = tensor.extract %1[%6] : tensor + %7 = arith.cmpi slt, %arg5, %extracted_0 : i32 + scf.condition(%7) %arg5, %arg6 : i32, tensor + } do { + ^bb0(%arg5: i32, %arg6: tensor): + %6 = arith.index_cast %arg5 : i32 to index + %inserted = tensor.insert %4 into %arg6[%6] : tensor + %7 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %7, %inserted : i32, tensor + } + affine.yield %5#1 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu_linalg.mlir new file mode 100644 index 000000000000..3845451a3648 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_convert_csr_to_coo_cpu_linalg.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_convert_csr_to_coo_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + affine.for %arg3 = 0 to 64 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = affine.load %arg0[%arg3] : memref + %2 = scf.while (%arg4 = %1) : (i32) -> i32 { + %3 = affine.load %arg0[%arg3 + 1] : memref + %4 = arith.cmpi slt, %arg4, %3 : i32 + scf.condition(%4) %arg4 : i32 + } do { + ^bb0(%arg4: i32): + %3 = arith.index_cast %arg4 : i32 to index + memref.store %0, %arg2[%3] : memref + %4 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %4 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_copy_cpu.mlir b/issues/aten_c_kernels/results/aten_copy_cpu.mlir new file mode 100644 index 000000000000..02c0857991e3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copy_cpu.mlir @@ -0,0 +1,9 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_copy_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_copy_cpu/debuf.mlir new file mode 100644 index 000000000000..7e98c1dd7c2b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copy_cpu/debuf.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_copy_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_copy_cpu/matched.mlir new file mode 100644 index 000000000000..938cb4eaacab --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copy_cpu/matched.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = kernel.launch @cudaCopy1D_f32_tensor(%0, %1) : (tensor, tensor) -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_copy_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_copy_cpu/orig.mlir new file mode 100644 index 000000000000..02c0857991e3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copy_cpu/orig.mlir @@ -0,0 +1,9 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_copy_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_copy_cpu/raised.mlir new file mode 100644 index 000000000000..10c6dec6accd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copy_cpu/raised.mlir @@ -0,0 +1,11 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_copy_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_copy_cpu_debuf.mlir new file mode 100644 index 000000000000..7e98c1dd7c2b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copy_cpu_debuf.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_copy_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_copy_cpu_linalg.mlir new file mode 100644 index 000000000000..10c6dec6accd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copy_cpu_linalg.mlir @@ -0,0 +1,11 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu.mlir b/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu.mlir new file mode 100644 index 000000000000..b73bc2109f99 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copy_tensor_array_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu/debuf.mlir new file mode 100644 index 000000000000..4a315230d72f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copy_tensor_array_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c4, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu/matched.mlir new file mode 100644 index 000000000000..de37792d0220 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copy_tensor_array_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %2 = kernel.launch @cudaCopy2D_f32_tensor(%extracted_slice, %extracted_slice_0) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c4, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu/orig.mlir new file mode 100644 index 000000000000..b73bc2109f99 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copy_tensor_array_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu/raised.mlir new file mode 100644 index 000000000000..8cd58f39b53e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copy_tensor_array_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 0] [%c4, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c4, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu_debuf.mlir new file mode 100644 index 000000000000..4a315230d72f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copy_tensor_array_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c4, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu_linalg.mlir new file mode 100644 index 000000000000..8cd58f39b53e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copy_tensor_array_cpu_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copy_tensor_array_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 0] [%c4, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c4, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_copysign.mlir b/issues/aten_c_kernels/results/aten_copysign.mlir new file mode 100644 index 000000000000..421da2701856 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copysign.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copysign(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @copysignf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @copysignf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_copysign/debuf.mlir b/issues/aten_c_kernels/results/aten_copysign/debuf.mlir new file mode 100644 index 000000000000..a8fdffc62e03 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copysign/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copysign(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = math.copysign %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @copysignf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_copysign/matched.mlir b/issues/aten_c_kernels/results/aten_copysign/matched.mlir new file mode 100644 index 000000000000..a8fdffc62e03 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copysign/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copysign(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = math.copysign %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @copysignf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_copysign/orig.mlir b/issues/aten_c_kernels/results/aten_copysign/orig.mlir new file mode 100644 index 000000000000..421da2701856 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copysign/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copysign(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @copysignf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @copysignf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_copysign/raised.mlir b/issues/aten_c_kernels/results/aten_copysign/raised.mlir new file mode 100644 index 000000000000..0294eeb75d1e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copysign/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copysign(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = math.copysign %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @copysignf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_copysign_debuf.mlir b/issues/aten_c_kernels/results/aten_copysign_debuf.mlir new file mode 100644 index 000000000000..a8fdffc62e03 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copysign_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copysign(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = math.copysign %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @copysignf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_copysign_linalg.mlir b/issues/aten_c_kernels/results/aten_copysign_linalg.mlir new file mode 100644 index 000000000000..0294eeb75d1e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_copysign_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_copysign(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = math.copysign %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @copysignf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_cos.mlir b/issues/aten_c_kernels/results/aten_cos.mlir new file mode 100644 index 000000000000..e1b224efce2d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cos.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cos(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @cosf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @cosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_cos/debuf.mlir b/issues/aten_c_kernels/results/aten_cos/debuf.mlir new file mode 100644 index 000000000000..fc63ee176cd3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cos/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cos(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.cos %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @cosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_cos/matched.mlir b/issues/aten_c_kernels/results/aten_cos/matched.mlir new file mode 100644 index 000000000000..fc63ee176cd3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cos/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cos(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.cos %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @cosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_cos/orig.mlir b/issues/aten_c_kernels/results/aten_cos/orig.mlir new file mode 100644 index 000000000000..e1b224efce2d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cos/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cos(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @cosf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @cosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_cos/raised.mlir b/issues/aten_c_kernels/results/aten_cos/raised.mlir new file mode 100644 index 000000000000..488838ce4c87 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cos/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cos(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.cos %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @cosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_cos_debuf.mlir b/issues/aten_c_kernels/results/aten_cos_debuf.mlir new file mode 100644 index 000000000000..fc63ee176cd3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cos_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cos(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.cos %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @cosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_cos_linalg.mlir b/issues/aten_c_kernels/results/aten_cos_linalg.mlir new file mode 100644 index 000000000000..488838ce4c87 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cos_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cos(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.cos %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @cosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_cosh.mlir b/issues/aten_c_kernels/results/aten_cosh.mlir new file mode 100644 index 000000000000..e86a9d3876c7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cosh.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cosh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @coshf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @coshf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_cosh/debuf.mlir b/issues/aten_c_kernels/results/aten_cosh/debuf.mlir new file mode 100644 index 000000000000..6d3d332cfc48 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cosh/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cosh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @coshf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @coshf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_cosh/matched.mlir b/issues/aten_c_kernels/results/aten_cosh/matched.mlir new file mode 100644 index 000000000000..6d3d332cfc48 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cosh/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cosh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @coshf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @coshf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_cosh/orig.mlir b/issues/aten_c_kernels/results/aten_cosh/orig.mlir new file mode 100644 index 000000000000..e86a9d3876c7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cosh/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cosh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @coshf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @coshf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_cosh/raised.mlir b/issues/aten_c_kernels/results/aten_cosh/raised.mlir new file mode 100644 index 000000000000..3e4e10ce9cee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cosh/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cosh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @coshf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @coshf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_cosh_debuf.mlir b/issues/aten_c_kernels/results/aten_cosh_debuf.mlir new file mode 100644 index 000000000000..6d3d332cfc48 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cosh_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cosh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @coshf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @coshf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_cosh_linalg.mlir b/issues/aten_c_kernels/results/aten_cosh_linalg.mlir new file mode 100644 index 000000000000..3e4e10ce9cee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cosh_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cosh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @coshf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @coshf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_count_nonzero_cpu.mlir b/issues/aten_c_kernels/results/aten_count_nonzero_cpu.mlir new file mode 100644 index 000000000000..88d8c73b2ce2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_count_nonzero_cpu.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_count_nonzero_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg2 = 0 to 2048 iter_args(%arg3 = %c0_i32) -> (i32) { + %1 = affine.load %arg0[%arg2] : memref + %2 = arith.cmpf une, %1, %cst : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.addi %arg3, %3 : i32 + affine.yield %4 : i32 + } + affine.store %0, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_count_nonzero_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_count_nonzero_cpu/debuf.mlir new file mode 100644 index 000000000000..4e5ff7afb909 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_count_nonzero_cpu/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_count_nonzero_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %c0_i32 into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: i32): + %4 = arith.cmpf une, %in, %cst : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.addi %out, %5 : i32 + linalg.yield %6 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_count_nonzero_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_count_nonzero_cpu/matched.mlir new file mode 100644 index 000000000000..4e5ff7afb909 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_count_nonzero_cpu/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_count_nonzero_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %c0_i32 into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: i32): + %4 = arith.cmpf une, %in, %cst : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.addi %out, %5 : i32 + linalg.yield %6 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_count_nonzero_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_count_nonzero_cpu/orig.mlir new file mode 100644 index 000000000000..88d8c73b2ce2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_count_nonzero_cpu/orig.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_count_nonzero_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg2 = 0 to 2048 iter_args(%arg3 = %c0_i32) -> (i32) { + %1 = affine.load %arg0[%arg2] : memref + %2 = arith.cmpf une, %1, %cst : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.addi %arg3, %3 : i32 + affine.yield %4 : i32 + } + affine.store %0, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_count_nonzero_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_count_nonzero_cpu/raised.mlir new file mode 100644 index 000000000000..a4e20abf5916 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_count_nonzero_cpu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_count_nonzero_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg1[0] : memref + %subview = memref.subview %arg1[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: i32): + %0 = arith.cmpf une, %in, %cst : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.addi %out, %1 : i32 + linalg.yield %2 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_count_nonzero_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_count_nonzero_cpu_debuf.mlir new file mode 100644 index 000000000000..4e5ff7afb909 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_count_nonzero_cpu_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_count_nonzero_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %c0_i32 into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: i32): + %4 = arith.cmpf une, %in, %cst : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.addi %out, %5 : i32 + linalg.yield %6 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_count_nonzero_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_count_nonzero_cpu_linalg.mlir new file mode 100644 index 000000000000..a4e20abf5916 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_count_nonzero_cpu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_count_nonzero_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg1[0] : memref + %subview = memref.subview %arg1[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: i32): + %0 = arith.cmpf une, %in, %cst : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.addi %out, %1 : i32 + linalg.yield %2 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu.mlir b/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu.mlir new file mode 100644 index 000000000000..85324e40fa17 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_count_nonzero_impl_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 32 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %c0_i32) -> (i32) { + %1 = affine.load %arg0[%arg2, %arg3] : memref + %2 = arith.cmpf une, %1, %cst : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.addi %arg4, %3 : i32 + affine.yield %4 : i32 + } + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu/debuf.mlir new file mode 100644 index 000000000000..2b1aa3e3c221 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu/debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_count_nonzero_impl_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: i32): + %5 = arith.cmpf une, %in, %cst : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.addi %out, %6 : i32 + linalg.yield %7 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu/matched.mlir new file mode 100644 index 000000000000..519417536a84 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu/matched.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_count_nonzero_impl_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = kernel.launch @memset_zero_1D(%1) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: i32): + %5 = arith.cmpf une, %in, %cst : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.addi %out, %6 : i32 + linalg.yield %7 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu/orig.mlir new file mode 100644 index 000000000000..85324e40fa17 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_count_nonzero_impl_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 32 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %c0_i32) -> (i32) { + %1 = affine.load %arg0[%arg2, %arg3] : memref + %2 = arith.cmpf une, %1, %cst : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.addi %arg4, %3 : i32 + affine.yield %4 : i32 + } + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu/raised.mlir new file mode 100644 index 000000000000..3d72bafab8c8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_count_nonzero_impl_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: i32): + %0 = arith.cmpf une, %in, %cst : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.addi %out, %1 : i32 + linalg.yield %2 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu_debuf.mlir new file mode 100644 index 000000000000..2b1aa3e3c221 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu_debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_count_nonzero_impl_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: i32): + %5 = arith.cmpf une, %in, %cst : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.addi %out, %6 : i32 + linalg.yield %7 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu_linalg.mlir new file mode 100644 index 000000000000..3d72bafab8c8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_count_nonzero_impl_cpu_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_count_nonzero_impl_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: i32): + %0 = arith.cmpf une, %in, %cst : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.addi %out, %1 : i32 + linalg.yield %2 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu.mlir new file mode 100644 index 000000000000..47098d65433c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_batched_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 20 { + %0 = affine.for %arg6 = 0 to 24 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4, %arg6] : memref + %2 = affine.load %arg1[%arg3, %arg6, %arg5] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg7, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu/debuf.mlir new file mode 100644 index 000000000000..be7b53b744b5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu/debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_batched_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c4, %c16, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c4, %c24, %c20] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu/matched.mlir new file mode 100644 index 000000000000..be7b53b744b5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu/matched.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_batched_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c4, %c16, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c4, %c24, %c20] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu/orig.mlir new file mode 100644 index 000000000000..47098d65433c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_batched_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 20 { + %0 = affine.for %arg6 = 0 to 24 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4, %arg6] : memref + %2 = affine.load %arg1[%arg3, %arg6, %arg5] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg7, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu/raised.mlir new file mode 100644 index 000000000000..9971a683c5aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_batched_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %c20 = arith.constant 20 : index + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c4, %c16, %c24] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0] [%c4, %c24, %c20] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu_debuf.mlir new file mode 100644 index 000000000000..be7b53b744b5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu_debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_batched_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c4, %c16, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c4, %c24, %c20] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu_linalg.mlir new file mode 100644 index 000000000000..9971a683c5aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_batched_cpu_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_batched_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %c20 = arith.constant 20 : index + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c4, %c16, %c24] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0] [%c4, %c24, %c20] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu.mlir new file mode 100644 index 000000000000..2603cea1e6a2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 24 { + affine.for %arg4 = 0 to 32 { + %0 = affine.for %arg5 = 0 to 40 iter_args(%arg6 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg5] : memref + %2 = affine.load %arg1[%arg5, %arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg6, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu/debuf.mlir new file mode 100644 index 000000000000..74afb9c6efa5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu/debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c40 = arith.constant 40 : index + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c24, %c32] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c24, %c40] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c40, %c32] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0] [%c24, %c32] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu/matched.mlir new file mode 100644 index 000000000000..74afb9c6efa5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu/matched.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c40 = arith.constant 40 : index + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c24, %c32] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c24, %c40] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c40, %c32] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0] [%c24, %c32] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu/orig.mlir new file mode 100644 index 000000000000..2603cea1e6a2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu/orig.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 24 { + affine.for %arg4 = 0 to 32 { + %0 = affine.for %arg5 = 0 to 40 iter_args(%arg6 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg5] : memref + %2 = affine.load %arg1[%arg5, %arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg6, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu/raised.mlir new file mode 100644 index 000000000000..24d3826d06f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu/raised.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %c40 = arith.constant 40 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0] [%c24, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0] [%c24, %c40] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0] [%c40, %c32] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0] [%c24, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu_debuf.mlir new file mode 100644 index 000000000000..74afb9c6efa5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu_debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c40 = arith.constant 40 : index + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c24, %c32] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c24, %c40] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c40, %c32] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0] [%c24, %c32] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu_linalg.mlir new file mode 100644 index 000000000000..24d3826d06f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_cpu_linalg.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %c40 = arith.constant 40 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0] [%c24, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0] [%c24, %c40] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0] [%c40, %c32] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0] [%c24, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu.mlir new file mode 100644 index 000000000000..8d3e87c85022 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_strided_batched_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 20 { + %0 = affine.for %arg6 = 0 to 24 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4, %arg6] : memref + %2 = affine.load %arg1[%arg3, %arg6, %arg5] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg7, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu/debuf.mlir new file mode 100644 index 000000000000..a27cbcb7dd13 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu/debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_strided_batched_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c4, %c16, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c4, %c24, %c20] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu/matched.mlir new file mode 100644 index 000000000000..a27cbcb7dd13 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu/matched.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_strided_batched_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c4, %c16, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c4, %c24, %c20] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu/orig.mlir new file mode 100644 index 000000000000..8d3e87c85022 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_strided_batched_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 20 { + %0 = affine.for %arg6 = 0 to 24 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4, %arg6] : memref + %2 = affine.load %arg1[%arg3, %arg6, %arg5] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg7, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu/raised.mlir new file mode 100644 index 000000000000..daddc2917f10 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_strided_batched_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %c20 = arith.constant 20 : index + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c4, %c16, %c24] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0] [%c4, %c24, %c20] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu_debuf.mlir new file mode 100644 index 000000000000..a27cbcb7dd13 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu_debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_strided_batched_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c4, %c16, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c4, %c24, %c20] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu_linalg.mlir new file mode 100644 index 000000000000..daddc2917f10 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cpu_blas_gemm_strided_batched_cpu_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cpu_blas_gemm_strided_batched_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %c20 = arith.constant 20 : index + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c4, %c16, %c24] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0] [%c4, %c24, %c20] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0, 0] [%c4, %c16, %c20] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cross.mlir b/issues/aten_c_kernels/results/aten_cross.mlir new file mode 100644 index 000000000000..853e348b4c3f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cross.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cross(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg3, 1] : memref + %1 = affine.load %arg1[%arg3, 2] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg0[%arg3, 2] : memref + %4 = affine.load %arg1[%arg3, 1] : memref + %5 = arith.mulf %3, %4 : f32 + %6 = arith.subf %2, %5 : f32 + affine.store %6, %arg2[%arg3, 0] : memref + %7 = affine.load %arg0[%arg3, 2] : memref + %8 = affine.load %arg1[%arg3, 0] : memref + %9 = arith.mulf %7, %8 : f32 + %10 = affine.load %arg0[%arg3, 0] : memref + %11 = affine.load %arg1[%arg3, 2] : memref + %12 = arith.mulf %10, %11 : f32 + %13 = arith.subf %9, %12 : f32 + affine.store %13, %arg2[%arg3, 1] : memref + %14 = affine.load %arg0[%arg3, 0] : memref + %15 = affine.load %arg1[%arg3, 1] : memref + %16 = arith.mulf %14, %15 : f32 + %17 = affine.load %arg0[%arg3, 1] : memref + %18 = affine.load %arg1[%arg3, 0] : memref + %19 = arith.mulf %17, %18 : f32 + %20 = arith.subf %16, %19 : f32 + affine.store %20, %arg2[%arg3, 2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cross/debuf.mlir b/issues/aten_c_kernels/results/aten_cross/debuf.mlir new file mode 100644 index 000000000000..753ac4bcecd9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cross/debuf.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cross(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 1] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 2] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 2] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %1[0, 1] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %2[0, 0] [%c64, 1] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1, %extracted_slice_2 : tensor, tensor, tensor, tensor) outs(%extracted_slice_3 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c64, 1] [1, 1] : tensor into tensor + %extracted_slice_4 = tensor.extract_slice %0[0, 2] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %1[0, 0] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %0[0, 0] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_7 = tensor.extract_slice %1[0, 2] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_8 = tensor.extract_slice %inserted_slice[0, 1] [%c64, 1] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_4, %extracted_slice_5, %extracted_slice_6, %extracted_slice_7 : tensor, tensor, tensor, tensor) outs(%extracted_slice_8 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice_9 = tensor.insert_slice %4 into %inserted_slice[0, 1] [%c64, 1] [1, 1] : tensor into tensor + %extracted_slice_10 = tensor.extract_slice %0[0, 0] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_11 = tensor.extract_slice %1[0, 1] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_12 = tensor.extract_slice %0[0, 1] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_13 = tensor.extract_slice %1[0, 0] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_14 = tensor.extract_slice %inserted_slice_9[0, 2] [%c64, 1] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_10, %extracted_slice_11, %extracted_slice_12, %extracted_slice_13 : tensor, tensor, tensor, tensor) outs(%extracted_slice_14 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice_15 = tensor.insert_slice %5 into %inserted_slice_9[0, 2] [%c64, 1] [1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice_15 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cross/matched.mlir b/issues/aten_c_kernels/results/aten_cross/matched.mlir new file mode 100644 index 000000000000..753ac4bcecd9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cross/matched.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cross(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 1] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 2] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 2] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %1[0, 1] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %2[0, 0] [%c64, 1] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1, %extracted_slice_2 : tensor, tensor, tensor, tensor) outs(%extracted_slice_3 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c64, 1] [1, 1] : tensor into tensor + %extracted_slice_4 = tensor.extract_slice %0[0, 2] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %1[0, 0] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %0[0, 0] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_7 = tensor.extract_slice %1[0, 2] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_8 = tensor.extract_slice %inserted_slice[0, 1] [%c64, 1] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_4, %extracted_slice_5, %extracted_slice_6, %extracted_slice_7 : tensor, tensor, tensor, tensor) outs(%extracted_slice_8 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice_9 = tensor.insert_slice %4 into %inserted_slice[0, 1] [%c64, 1] [1, 1] : tensor into tensor + %extracted_slice_10 = tensor.extract_slice %0[0, 0] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_11 = tensor.extract_slice %1[0, 1] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_12 = tensor.extract_slice %0[0, 1] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_13 = tensor.extract_slice %1[0, 0] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_14 = tensor.extract_slice %inserted_slice_9[0, 2] [%c64, 1] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_10, %extracted_slice_11, %extracted_slice_12, %extracted_slice_13 : tensor, tensor, tensor, tensor) outs(%extracted_slice_14 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice_15 = tensor.insert_slice %5 into %inserted_slice_9[0, 2] [%c64, 1] [1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice_15 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cross/orig.mlir b/issues/aten_c_kernels/results/aten_cross/orig.mlir new file mode 100644 index 000000000000..853e348b4c3f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cross/orig.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cross(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg3, 1] : memref + %1 = affine.load %arg1[%arg3, 2] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg0[%arg3, 2] : memref + %4 = affine.load %arg1[%arg3, 1] : memref + %5 = arith.mulf %3, %4 : f32 + %6 = arith.subf %2, %5 : f32 + affine.store %6, %arg2[%arg3, 0] : memref + %7 = affine.load %arg0[%arg3, 2] : memref + %8 = affine.load %arg1[%arg3, 0] : memref + %9 = arith.mulf %7, %8 : f32 + %10 = affine.load %arg0[%arg3, 0] : memref + %11 = affine.load %arg1[%arg3, 2] : memref + %12 = arith.mulf %10, %11 : f32 + %13 = arith.subf %9, %12 : f32 + affine.store %13, %arg2[%arg3, 1] : memref + %14 = affine.load %arg0[%arg3, 0] : memref + %15 = affine.load %arg1[%arg3, 1] : memref + %16 = arith.mulf %14, %15 : f32 + %17 = affine.load %arg0[%arg3, 1] : memref + %18 = affine.load %arg1[%arg3, 0] : memref + %19 = arith.mulf %17, %18 : f32 + %20 = arith.subf %16, %19 : f32 + affine.store %20, %arg2[%arg3, 2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cross/raised.mlir b/issues/aten_c_kernels/results/aten_cross/raised.mlir new file mode 100644 index 000000000000..79cf2e190645 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cross/raised.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cross(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 1] [%c64, 1] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 2] [%c64, 1] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg0[0, 2] [%c64, 1] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg1[0, 1] [%c64, 1] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg2[0, 0] [%c64, 1] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview, %subview_0, %subview_1, %subview_2 : memref>, memref>, memref>, memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %out: f32): + %0 = arith.mulf %in, %in_14 : f32 + %1 = arith.mulf %in_15, %in_16 : f32 + %2 = arith.subf %0, %1 : f32 + linalg.yield %2 : f32 + } + %subview_4 = memref.subview %arg0[0, 2] [%c64, 1] [1, 1] : memref to memref> + %subview_5 = memref.subview %arg1[0, 0] [%c64, 1] [1, 1] : memref to memref> + %subview_6 = memref.subview %arg0[0, 0] [%c64, 1] [1, 1] : memref to memref> + %subview_7 = memref.subview %arg1[0, 2] [%c64, 1] [1, 1] : memref to memref> + %subview_8 = memref.subview %arg2[0, 1] [%c64, 1] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview_4, %subview_5, %subview_6, %subview_7 : memref>, memref>, memref>, memref>) outs(%subview_8 : memref>) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %out: f32): + %0 = arith.mulf %in, %in_14 : f32 + %1 = arith.mulf %in_15, %in_16 : f32 + %2 = arith.subf %0, %1 : f32 + linalg.yield %2 : f32 + } + %subview_9 = memref.subview %arg0[0, 0] [%c64, 1] [1, 1] : memref to memref> + %subview_10 = memref.subview %arg1[0, 1] [%c64, 1] [1, 1] : memref to memref> + %subview_11 = memref.subview %arg0[0, 1] [%c64, 1] [1, 1] : memref to memref> + %subview_12 = memref.subview %arg1[0, 0] [%c64, 1] [1, 1] : memref to memref> + %subview_13 = memref.subview %arg2[0, 2] [%c64, 1] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview_9, %subview_10, %subview_11, %subview_12 : memref>, memref>, memref>, memref>) outs(%subview_13 : memref>) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %out: f32): + %0 = arith.mulf %in, %in_14 : f32 + %1 = arith.mulf %in_15, %in_16 : f32 + %2 = arith.subf %0, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cross_cpu_backend.mlir b/issues/aten_c_kernels/results/aten_cross_cpu_backend.mlir new file mode 100644 index 000000000000..6851412874fa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cross_cpu_backend.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cross_cpu_backend(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 256 { + %0 = affine.load %arg0[%arg3, 1] : memref + %1 = affine.load %arg1[%arg3, 2] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg0[%arg3, 2] : memref + %4 = affine.load %arg1[%arg3, 1] : memref + %5 = arith.mulf %3, %4 : f32 + %6 = arith.subf %2, %5 : f32 + affine.store %6, %arg2[%arg3, 0] : memref + %7 = affine.load %arg0[%arg3, 2] : memref + %8 = affine.load %arg1[%arg3, 0] : memref + %9 = arith.mulf %7, %8 : f32 + %10 = affine.load %arg0[%arg3, 0] : memref + %11 = affine.load %arg1[%arg3, 2] : memref + %12 = arith.mulf %10, %11 : f32 + %13 = arith.subf %9, %12 : f32 + affine.store %13, %arg2[%arg3, 1] : memref + %14 = affine.load %arg0[%arg3, 0] : memref + %15 = affine.load %arg1[%arg3, 1] : memref + %16 = arith.mulf %14, %15 : f32 + %17 = affine.load %arg0[%arg3, 1] : memref + %18 = affine.load %arg1[%arg3, 0] : memref + %19 = arith.mulf %17, %18 : f32 + %20 = arith.subf %16, %19 : f32 + affine.store %20, %arg2[%arg3, 2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cross_cpu_backend/debuf.mlir b/issues/aten_c_kernels/results/aten_cross_cpu_backend/debuf.mlir new file mode 100644 index 000000000000..d935c28889d4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cross_cpu_backend/debuf.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cross_cpu_backend(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 1] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 2] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 2] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %1[0, 1] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %2[0, 0] [%c256, 1] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1, %extracted_slice_2 : tensor, tensor, tensor, tensor) outs(%extracted_slice_3 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c256, 1] [1, 1] : tensor into tensor + %extracted_slice_4 = tensor.extract_slice %0[0, 2] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %1[0, 0] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %0[0, 0] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_7 = tensor.extract_slice %1[0, 2] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_8 = tensor.extract_slice %inserted_slice[0, 1] [%c256, 1] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_4, %extracted_slice_5, %extracted_slice_6, %extracted_slice_7 : tensor, tensor, tensor, tensor) outs(%extracted_slice_8 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice_9 = tensor.insert_slice %4 into %inserted_slice[0, 1] [%c256, 1] [1, 1] : tensor into tensor + %extracted_slice_10 = tensor.extract_slice %0[0, 0] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_11 = tensor.extract_slice %1[0, 1] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_12 = tensor.extract_slice %0[0, 1] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_13 = tensor.extract_slice %1[0, 0] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_14 = tensor.extract_slice %inserted_slice_9[0, 2] [%c256, 1] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_10, %extracted_slice_11, %extracted_slice_12, %extracted_slice_13 : tensor, tensor, tensor, tensor) outs(%extracted_slice_14 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice_15 = tensor.insert_slice %5 into %inserted_slice_9[0, 2] [%c256, 1] [1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice_15 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cross_cpu_backend/matched.mlir b/issues/aten_c_kernels/results/aten_cross_cpu_backend/matched.mlir new file mode 100644 index 000000000000..d935c28889d4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cross_cpu_backend/matched.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cross_cpu_backend(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 1] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 2] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 2] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %1[0, 1] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %2[0, 0] [%c256, 1] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1, %extracted_slice_2 : tensor, tensor, tensor, tensor) outs(%extracted_slice_3 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c256, 1] [1, 1] : tensor into tensor + %extracted_slice_4 = tensor.extract_slice %0[0, 2] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %1[0, 0] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %0[0, 0] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_7 = tensor.extract_slice %1[0, 2] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_8 = tensor.extract_slice %inserted_slice[0, 1] [%c256, 1] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_4, %extracted_slice_5, %extracted_slice_6, %extracted_slice_7 : tensor, tensor, tensor, tensor) outs(%extracted_slice_8 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice_9 = tensor.insert_slice %4 into %inserted_slice[0, 1] [%c256, 1] [1, 1] : tensor into tensor + %extracted_slice_10 = tensor.extract_slice %0[0, 0] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_11 = tensor.extract_slice %1[0, 1] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_12 = tensor.extract_slice %0[0, 1] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_13 = tensor.extract_slice %1[0, 0] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_14 = tensor.extract_slice %inserted_slice_9[0, 2] [%c256, 1] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_10, %extracted_slice_11, %extracted_slice_12, %extracted_slice_13 : tensor, tensor, tensor, tensor) outs(%extracted_slice_14 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice_15 = tensor.insert_slice %5 into %inserted_slice_9[0, 2] [%c256, 1] [1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice_15 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cross_cpu_backend/orig.mlir b/issues/aten_c_kernels/results/aten_cross_cpu_backend/orig.mlir new file mode 100644 index 000000000000..6851412874fa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cross_cpu_backend/orig.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cross_cpu_backend(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 256 { + %0 = affine.load %arg0[%arg3, 1] : memref + %1 = affine.load %arg1[%arg3, 2] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg0[%arg3, 2] : memref + %4 = affine.load %arg1[%arg3, 1] : memref + %5 = arith.mulf %3, %4 : f32 + %6 = arith.subf %2, %5 : f32 + affine.store %6, %arg2[%arg3, 0] : memref + %7 = affine.load %arg0[%arg3, 2] : memref + %8 = affine.load %arg1[%arg3, 0] : memref + %9 = arith.mulf %7, %8 : f32 + %10 = affine.load %arg0[%arg3, 0] : memref + %11 = affine.load %arg1[%arg3, 2] : memref + %12 = arith.mulf %10, %11 : f32 + %13 = arith.subf %9, %12 : f32 + affine.store %13, %arg2[%arg3, 1] : memref + %14 = affine.load %arg0[%arg3, 0] : memref + %15 = affine.load %arg1[%arg3, 1] : memref + %16 = arith.mulf %14, %15 : f32 + %17 = affine.load %arg0[%arg3, 1] : memref + %18 = affine.load %arg1[%arg3, 0] : memref + %19 = arith.mulf %17, %18 : f32 + %20 = arith.subf %16, %19 : f32 + affine.store %20, %arg2[%arg3, 2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cross_cpu_backend/raised.mlir b/issues/aten_c_kernels/results/aten_cross_cpu_backend/raised.mlir new file mode 100644 index 000000000000..e6832654f534 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cross_cpu_backend/raised.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cross_cpu_backend(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %subview = memref.subview %arg0[0, 1] [%c256, 1] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 2] [%c256, 1] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg0[0, 2] [%c256, 1] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg1[0, 1] [%c256, 1] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg2[0, 0] [%c256, 1] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview, %subview_0, %subview_1, %subview_2 : memref>, memref>, memref>, memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %out: f32): + %0 = arith.mulf %in, %in_14 : f32 + %1 = arith.mulf %in_15, %in_16 : f32 + %2 = arith.subf %0, %1 : f32 + linalg.yield %2 : f32 + } + %subview_4 = memref.subview %arg0[0, 2] [%c256, 1] [1, 1] : memref to memref> + %subview_5 = memref.subview %arg1[0, 0] [%c256, 1] [1, 1] : memref to memref> + %subview_6 = memref.subview %arg0[0, 0] [%c256, 1] [1, 1] : memref to memref> + %subview_7 = memref.subview %arg1[0, 2] [%c256, 1] [1, 1] : memref to memref> + %subview_8 = memref.subview %arg2[0, 1] [%c256, 1] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview_4, %subview_5, %subview_6, %subview_7 : memref>, memref>, memref>, memref>) outs(%subview_8 : memref>) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %out: f32): + %0 = arith.mulf %in, %in_14 : f32 + %1 = arith.mulf %in_15, %in_16 : f32 + %2 = arith.subf %0, %1 : f32 + linalg.yield %2 : f32 + } + %subview_9 = memref.subview %arg0[0, 0] [%c256, 1] [1, 1] : memref to memref> + %subview_10 = memref.subview %arg1[0, 1] [%c256, 1] [1, 1] : memref to memref> + %subview_11 = memref.subview %arg0[0, 1] [%c256, 1] [1, 1] : memref to memref> + %subview_12 = memref.subview %arg1[0, 0] [%c256, 1] [1, 1] : memref to memref> + %subview_13 = memref.subview %arg2[0, 2] [%c256, 1] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview_9, %subview_10, %subview_11, %subview_12 : memref>, memref>, memref>, memref>) outs(%subview_13 : memref>) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %out: f32): + %0 = arith.mulf %in, %in_14 : f32 + %1 = arith.mulf %in_15, %in_16 : f32 + %2 = arith.subf %0, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cross_cpu_backend_debuf.mlir b/issues/aten_c_kernels/results/aten_cross_cpu_backend_debuf.mlir new file mode 100644 index 000000000000..d935c28889d4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cross_cpu_backend_debuf.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cross_cpu_backend(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 1] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 2] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 2] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %1[0, 1] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %2[0, 0] [%c256, 1] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1, %extracted_slice_2 : tensor, tensor, tensor, tensor) outs(%extracted_slice_3 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c256, 1] [1, 1] : tensor into tensor + %extracted_slice_4 = tensor.extract_slice %0[0, 2] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %1[0, 0] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %0[0, 0] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_7 = tensor.extract_slice %1[0, 2] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_8 = tensor.extract_slice %inserted_slice[0, 1] [%c256, 1] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_4, %extracted_slice_5, %extracted_slice_6, %extracted_slice_7 : tensor, tensor, tensor, tensor) outs(%extracted_slice_8 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice_9 = tensor.insert_slice %4 into %inserted_slice[0, 1] [%c256, 1] [1, 1] : tensor into tensor + %extracted_slice_10 = tensor.extract_slice %0[0, 0] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_11 = tensor.extract_slice %1[0, 1] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_12 = tensor.extract_slice %0[0, 1] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_13 = tensor.extract_slice %1[0, 0] [%c256, 1] [1, 1] : tensor to tensor + %extracted_slice_14 = tensor.extract_slice %inserted_slice_9[0, 2] [%c256, 1] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_10, %extracted_slice_11, %extracted_slice_12, %extracted_slice_13 : tensor, tensor, tensor, tensor) outs(%extracted_slice_14 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice_15 = tensor.insert_slice %5 into %inserted_slice_9[0, 2] [%c256, 1] [1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice_15 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cross_cpu_backend_linalg.mlir b/issues/aten_c_kernels/results/aten_cross_cpu_backend_linalg.mlir new file mode 100644 index 000000000000..e6832654f534 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cross_cpu_backend_linalg.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cross_cpu_backend(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %subview = memref.subview %arg0[0, 1] [%c256, 1] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 2] [%c256, 1] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg0[0, 2] [%c256, 1] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg1[0, 1] [%c256, 1] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg2[0, 0] [%c256, 1] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview, %subview_0, %subview_1, %subview_2 : memref>, memref>, memref>, memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %out: f32): + %0 = arith.mulf %in, %in_14 : f32 + %1 = arith.mulf %in_15, %in_16 : f32 + %2 = arith.subf %0, %1 : f32 + linalg.yield %2 : f32 + } + %subview_4 = memref.subview %arg0[0, 2] [%c256, 1] [1, 1] : memref to memref> + %subview_5 = memref.subview %arg1[0, 0] [%c256, 1] [1, 1] : memref to memref> + %subview_6 = memref.subview %arg0[0, 0] [%c256, 1] [1, 1] : memref to memref> + %subview_7 = memref.subview %arg1[0, 2] [%c256, 1] [1, 1] : memref to memref> + %subview_8 = memref.subview %arg2[0, 1] [%c256, 1] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview_4, %subview_5, %subview_6, %subview_7 : memref>, memref>, memref>, memref>) outs(%subview_8 : memref>) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %out: f32): + %0 = arith.mulf %in, %in_14 : f32 + %1 = arith.mulf %in_15, %in_16 : f32 + %2 = arith.subf %0, %1 : f32 + linalg.yield %2 : f32 + } + %subview_9 = memref.subview %arg0[0, 0] [%c256, 1] [1, 1] : memref to memref> + %subview_10 = memref.subview %arg1[0, 1] [%c256, 1] [1, 1] : memref to memref> + %subview_11 = memref.subview %arg0[0, 1] [%c256, 1] [1, 1] : memref to memref> + %subview_12 = memref.subview %arg1[0, 0] [%c256, 1] [1, 1] : memref to memref> + %subview_13 = memref.subview %arg2[0, 2] [%c256, 1] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview_9, %subview_10, %subview_11, %subview_12 : memref>, memref>, memref>, memref>) outs(%subview_13 : memref>) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %out: f32): + %0 = arith.mulf %in, %in_14 : f32 + %1 = arith.mulf %in_15, %in_16 : f32 + %2 = arith.subf %0, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cross_debuf.mlir b/issues/aten_c_kernels/results/aten_cross_debuf.mlir new file mode 100644 index 000000000000..753ac4bcecd9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cross_debuf.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cross(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 1] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 2] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 2] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %1[0, 1] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %2[0, 0] [%c64, 1] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1, %extracted_slice_2 : tensor, tensor, tensor, tensor) outs(%extracted_slice_3 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c64, 1] [1, 1] : tensor into tensor + %extracted_slice_4 = tensor.extract_slice %0[0, 2] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %1[0, 0] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %0[0, 0] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_7 = tensor.extract_slice %1[0, 2] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_8 = tensor.extract_slice %inserted_slice[0, 1] [%c64, 1] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_4, %extracted_slice_5, %extracted_slice_6, %extracted_slice_7 : tensor, tensor, tensor, tensor) outs(%extracted_slice_8 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice_9 = tensor.insert_slice %4 into %inserted_slice[0, 1] [%c64, 1] [1, 1] : tensor into tensor + %extracted_slice_10 = tensor.extract_slice %0[0, 0] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_11 = tensor.extract_slice %1[0, 1] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_12 = tensor.extract_slice %0[0, 1] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_13 = tensor.extract_slice %1[0, 0] [%c64, 1] [1, 1] : tensor to tensor + %extracted_slice_14 = tensor.extract_slice %inserted_slice_9[0, 2] [%c64, 1] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_10, %extracted_slice_11, %extracted_slice_12, %extracted_slice_13 : tensor, tensor, tensor, tensor) outs(%extracted_slice_14 : tensor) { + ^bb0(%in: f32, %in_16: f32, %in_17: f32, %in_18: f32, %out: f32): + %7 = arith.mulf %in, %in_16 : f32 + %8 = arith.mulf %in_17, %in_18 : f32 + %9 = arith.subf %7, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice_15 = tensor.insert_slice %5 into %inserted_slice_9[0, 2] [%c64, 1] [1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice_15 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cross_linalg.mlir b/issues/aten_c_kernels/results/aten_cross_linalg.mlir new file mode 100644 index 000000000000..79cf2e190645 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cross_linalg.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cross(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 1] [%c64, 1] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 2] [%c64, 1] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg0[0, 2] [%c64, 1] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg1[0, 1] [%c64, 1] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg2[0, 0] [%c64, 1] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview, %subview_0, %subview_1, %subview_2 : memref>, memref>, memref>, memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %out: f32): + %0 = arith.mulf %in, %in_14 : f32 + %1 = arith.mulf %in_15, %in_16 : f32 + %2 = arith.subf %0, %1 : f32 + linalg.yield %2 : f32 + } + %subview_4 = memref.subview %arg0[0, 2] [%c64, 1] [1, 1] : memref to memref> + %subview_5 = memref.subview %arg1[0, 0] [%c64, 1] [1, 1] : memref to memref> + %subview_6 = memref.subview %arg0[0, 0] [%c64, 1] [1, 1] : memref to memref> + %subview_7 = memref.subview %arg1[0, 2] [%c64, 1] [1, 1] : memref to memref> + %subview_8 = memref.subview %arg2[0, 1] [%c64, 1] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview_4, %subview_5, %subview_6, %subview_7 : memref>, memref>, memref>, memref>) outs(%subview_8 : memref>) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %out: f32): + %0 = arith.mulf %in, %in_14 : f32 + %1 = arith.mulf %in_15, %in_16 : f32 + %2 = arith.subf %0, %1 : f32 + linalg.yield %2 : f32 + } + %subview_9 = memref.subview %arg0[0, 0] [%c64, 1] [1, 1] : memref to memref> + %subview_10 = memref.subview %arg1[0, 1] [%c64, 1] [1, 1] : memref to memref> + %subview_11 = memref.subview %arg0[0, 1] [%c64, 1] [1, 1] : memref to memref> + %subview_12 = memref.subview %arg1[0, 0] [%c64, 1] [1, 1] : memref to memref> + %subview_13 = memref.subview %arg2[0, 2] [%c64, 1] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview_9, %subview_10, %subview_11, %subview_12 : memref>, memref>, memref>, memref>) outs(%subview_13 : memref>) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %out: f32): + %0 = arith.mulf %in, %in_14 : f32 + %1 = arith.mulf %in_15, %in_16 : f32 + %2 = arith.subf %0, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu.mlir new file mode 100644 index 000000000000..079f7a88ee0c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu.mlir @@ -0,0 +1,162 @@ +#set = affine_set<(d0) : (-d0 + 9 >= 0)> +#set1 = affine_set<(d0) : (-d0 + 8 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ctc_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-2 = arith.constant -2 : index + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c22 = arith.constant 22 : index + %cst = arith.constant 1.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<24x11xf32> + affine.for %arg6 = 0 to 24 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 12 { + %0 = affine.load %arg0[%arg6, %arg7, %arg8] : memref + %1 = math.exp %0 : f32 + %2 = affine.load %arg4[%arg7] : memref + %3 = arith.mulf %1, %2 : f32 + affine.store %3, %arg5[%arg6, %arg7, %arg8] : memref + } + } + } + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 24 { + affine.for %arg8 = 0 to 11 { + affine.store %cst_0, %alloca[%arg7, %arg8] : memref<24x11xf32> + } + } + affine.store %cst, %alloca[23, 9] : memref<24x11xf32> + affine.store %cst, %alloca[23, 10] : memref<24x11xf32> + affine.for %arg7 = 0 to 23 { + %3 = arith.subi %c22, %arg7 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.addi %4, %c1_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + affine.for %arg8 = 0 to 11 { + %7 = arith.index_cast %arg8 : index to i32 + %8 = arith.andi %7, %c1_i32 : i32 + %9 = arith.cmpi ne, %8, %c0_i32 : i32 + %10 = scf.if %9 -> (i32) { + %20 = arith.cmpi slt, %arg8, %c0 : index + %21 = arith.subi %c-1, %arg8 : index + %22 = arith.select %20, %21, %arg8 : index + %23 = arith.divsi %22, %c2 : index + %24 = arith.subi %c-1, %23 : index + %25 = arith.select %20, %24, %23 : index + %26 = memref.load %arg1[%arg6, %25] : memref + scf.yield %26 : i32 + } else { + scf.yield %arg2 : i32 + } + %11 = affine.load %alloca[-%arg7 + 23, %arg8] : memref<24x11xf32> + %12 = arith.index_cast %10 : i32 to index + %13 = memref.load %arg0[%6, %arg6, %12] : memref + %14 = math.exp %13 : f32 + %15 = arith.mulf %11, %14 : f32 + %16 = arith.addi %7, %c1_i32 : i32 + %17 = affine.if #set(%arg8) -> f32 { + %20 = arith.andi %16, %c1_i32 : i32 + %21 = arith.cmpi ne, %20, %c0_i32 : i32 + %22 = scf.if %21 -> (i32) { + %29 = arith.addi %arg8, %c1 : index + %30 = arith.cmpi slt, %29, %c0 : index + %31 = arith.subi %c-2, %arg8 : index + %32 = arith.select %30, %31, %29 : index + %33 = arith.divsi %32, %c2 : index + %34 = arith.subi %c-1, %33 : index + %35 = arith.select %30, %34, %33 : index + %36 = memref.load %arg1[%arg6, %35] : memref + scf.yield %36 : i32 + } else { + scf.yield %arg2 : i32 + } + %23 = affine.load %alloca[-%arg7 + 23, %arg8 + 1] : memref<24x11xf32> + %24 = arith.index_cast %22 : i32 to index + %25 = memref.load %arg0[%6, %arg6, %24] : memref + %26 = math.exp %25 : f32 + %27 = arith.mulf %23, %26 : f32 + %28 = arith.addf %15, %27 : f32 + affine.yield %28 : f32 + } else { + affine.yield %15 : f32 + } + %18 = arith.addi %7, %c2_i32 : i32 + %19 = affine.if #set1(%arg8) -> f32 { + %20 = arith.andi %18, %c1_i32 : i32 + %21 = arith.cmpi ne, %20, %c0_i32 : i32 + %22 = scf.if %21 -> (i32) { + %27 = arith.cmpi slt, %arg8, %c0 : index + %28 = arith.subi %c-1, %arg8 : index + %29 = arith.select %27, %28, %arg8 : index + %30 = arith.divsi %29, %c2 : index + %31 = arith.subi %c-1, %30 : index + %32 = arith.select %27, %31, %30 : index + %33 = arith.addi %32, %c1 : index + %34 = memref.load %arg1[%arg6, %33] : memref + scf.yield %34 : i32 + } else { + scf.yield %arg2 : i32 + } + %23 = arith.cmpi ne, %10, %arg2 : i32 + %24 = arith.cmpi ne, %10, %22 : i32 + %25 = arith.andi %23, %24 : i1 + %26 = scf.if %25 -> (f32) { + %27 = affine.load %alloca[-%arg7 + 23, %arg8 + 2] : memref<24x11xf32> + %28 = arith.index_cast %22 : i32 to index + %29 = memref.load %arg0[%6, %arg6, %28] : memref + %30 = math.exp %29 : f32 + %31 = arith.mulf %27, %30 : f32 + %32 = arith.addf %17, %31 : f32 + scf.yield %32 : f32 + } else { + scf.yield %17 : f32 + } + affine.yield %26 : f32 + } else { + affine.yield %17 : f32 + } + affine.store %19, %alloca[-%arg7 + 22, %arg8] : memref<24x11xf32> + } + } + %0 = affine.load %arg3[%arg6, 23, 10] : memref + %1 = affine.load %arg3[%arg6, 23, 9] : memref + %2 = arith.addf %0, %1 : f32 + affine.for %arg7 = 0 to 24 { + affine.for %arg8 = 0 to 11 { + %3 = arith.index_cast %arg8 : index to i32 + %4 = arith.andi %3, %c1_i32 : i32 + %5 = arith.cmpi ne, %4, %c0_i32 : i32 + %6 = scf.if %5 -> (i32) { + %16 = arith.cmpi slt, %arg8, %c0 : index + %17 = arith.subi %c-1, %arg8 : index + %18 = arith.select %16, %17, %arg8 : index + %19 = arith.divsi %18, %c2 : index + %20 = arith.subi %c-1, %19 : index + %21 = arith.select %16, %20, %19 : index + %22 = memref.load %arg1[%arg6, %21] : memref + scf.yield %22 : i32 + } else { + scf.yield %arg2 : i32 + } + %7 = arith.index_cast %6 : i32 to index + %8 = affine.load %arg4[%arg6] : memref + %9 = affine.load %arg3[%arg6, %arg7, %arg8] : memref + %10 = arith.mulf %8, %9 : f32 + %11 = affine.load %alloca[%arg7, %arg8] : memref<24x11xf32> + %12 = arith.mulf %10, %11 : f32 + %13 = arith.divf %12, %2 : f32 + %14 = memref.load %arg5[%arg7, %arg6, %7] : memref + %15 = arith.subf %14, %13 : f32 + memref.store %15, %arg5[%arg7, %arg6, %7] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..bdab0c583cce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu/debuf.mlir @@ -0,0 +1,171 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (-d0 + 23)> +#map4 = affine_map<(d0) -> (-d0 + 9)> +#map5 = affine_map<(d0, d1) -> (d1 + 1)> +#map6 = affine_map<(d0) -> (-d0 + 8)> +#map7 = affine_map<(d0, d1) -> (d1 + 2)> +#map8 = affine_map<(d0, d1) -> (-d0 + 22)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ctc_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %c22 = arith.constant 22 : index + %c1 = arith.constant 1 : index + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %c-2 = arith.constant -2 : index + %c11 = arith.constant 11 : index + %c12 = arith.constant 12 : index + %c4 = arith.constant 4 : index + %c0 = arith.constant 0 : index + %c24 = arith.constant 24 : index + %c10 = arith.constant 10 : index + %c23 = arith.constant 23 : index + %c9 = arith.constant 9 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = tensor.empty() : tensor<24x11xf32> + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c24, %c4, %c12] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c4] [1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %4[0, 0, 0] [%c24, %c4, %c12] [1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_1 : tensor, tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %9 = math.exp %in : f32 + %10 = arith.mulf %9, %in_3 : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %4[0, 0, 0] [%c24, %c4, %c12] [1, 1, 1] : tensor into tensor + %7:2 = affine.for %arg6 = 0 to 4 iter_args(%arg7 = %5, %arg8 = %inserted_slice) -> (tensor<24x11xf32>, tensor) { + %extracted_slice_3 = tensor.extract_slice %arg7[0, 0] [%c24, %c11] [1, 1] : tensor<24x11xf32> to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice_3 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice_4 = tensor.insert_slice %9 into %arg7[0, 0] [%c24, %c11] [1, 1] : tensor into tensor<24x11xf32> + %inserted = tensor.insert %cst_0 into %inserted_slice_4[%c23, %c9] : tensor<24x11xf32> + %inserted_5 = tensor.insert %cst_0 into %inserted[%c23, %c10] : tensor<24x11xf32> + %10 = affine.for %arg9 = 0 to 23 iter_args(%arg10 = %inserted_5) -> (tensor<24x11xf32>) { + %13 = arith.subi %c22, %arg9 : index + %14 = arith.index_cast %13 : index to i32 + %15 = arith.addi %14, %c1_i32 : i32 + %16 = arith.index_cast %15 : i32 to index + %17 = affine.for %arg11 = 0 to 11 iter_args(%arg12 = %arg10) -> (tensor<24x11xf32>) { + %18 = arith.index_cast %arg11 : index to i32 + %19 = arith.andi %18, %c1_i32 : i32 + %20 = arith.cmpi ne, %19, %c0_i32 : i32 + %21 = arith.cmpi slt, %arg11, %c0 : index + %22 = arith.subi %c-1, %arg11 : index + %23 = arith.select %21, %22, %arg11 : index + %24 = arith.divsi %23, %c2 : index + %25 = arith.subi %c-1, %24 : index + %26 = arith.select %21, %25, %24 : index + %extracted_7 = tensor.extract %1[%arg6, %26] : tensor + %27 = arith.select %20, %extracted_7, %arg2 : i32 + %28 = affine.apply #map3(%arg9, %arg11) + %extracted_8 = tensor.extract %arg12[%28, %arg11] : tensor<24x11xf32> + %29 = arith.index_cast %27 : i32 to index + %extracted_9 = tensor.extract %0[%16, %arg6, %29] : tensor + %30 = math.exp %extracted_9 : f32 + %31 = arith.mulf %extracted_8, %30 : f32 + %32 = arith.addi %18, %c1_i32 : i32 + %33 = affine.apply #map4(%arg11) + %34 = arith.cmpi sge, %33, %c0 : index + %35 = arith.andi %32, %c1_i32 : i32 + %36 = arith.cmpi ne, %35, %c0_i32 : i32 + %37 = arith.addi %arg11, %c1 : index + %38 = arith.cmpi slt, %37, %c0 : index + %39 = arith.subi %c-2, %arg11 : index + %40 = arith.select %38, %39, %37 : index + %41 = arith.divsi %40, %c2 : index + %42 = arith.subi %c-1, %41 : index + %43 = arith.select %38, %42, %41 : index + %extracted_10 = tensor.extract %1[%arg6, %43] : tensor + %44 = arith.select %36, %extracted_10, %arg2 : i32 + %45 = affine.apply #map3(%arg9, %arg11) + %46 = affine.apply #map5(%arg9, %arg11) + %extracted_11 = tensor.extract %arg12[%45, %46] : tensor<24x11xf32> + %47 = arith.index_cast %44 : i32 to index + %extracted_12 = tensor.extract %0[%16, %arg6, %47] : tensor + %48 = math.exp %extracted_12 : f32 + %49 = arith.mulf %extracted_11, %48 : f32 + %50 = arith.addf %31, %49 : f32 + %51 = arith.select %34, %50, %31 : f32 + %52 = arith.addi %18, %c2_i32 : i32 + %53 = affine.apply #map6(%arg11) + %54 = arith.cmpi sge, %53, %c0 : index + %55 = arith.andi %52, %c1_i32 : i32 + %56 = arith.cmpi ne, %55, %c0_i32 : i32 + %57 = arith.cmpi slt, %arg11, %c0 : index + %58 = arith.subi %c-1, %arg11 : index + %59 = arith.select %57, %58, %arg11 : index + %60 = arith.divsi %59, %c2 : index + %61 = arith.subi %c-1, %60 : index + %62 = arith.select %57, %61, %60 : index + %63 = arith.addi %62, %c1 : index + %extracted_13 = tensor.extract %1[%arg6, %63] : tensor + %64 = arith.select %56, %extracted_13, %arg2 : i32 + %65 = arith.cmpi ne, %27, %arg2 : i32 + %66 = arith.cmpi ne, %27, %64 : i32 + %67 = arith.andi %65, %66 : i1 + %68 = affine.apply #map3(%arg9, %arg11) + %69 = affine.apply #map7(%arg9, %arg11) + %extracted_14 = tensor.extract %arg12[%68, %69] : tensor<24x11xf32> + %70 = arith.index_cast %64 : i32 to index + %extracted_15 = tensor.extract %0[%16, %arg6, %70] : tensor + %71 = math.exp %extracted_15 : f32 + %72 = arith.mulf %extracted_14, %71 : f32 + %73 = arith.addf %51, %72 : f32 + %74 = arith.select %67, %73, %51 : f32 + %75 = arith.select %54, %74, %51 : f32 + %76 = affine.apply #map8(%arg9, %arg11) + %inserted_16 = tensor.insert %75 into %arg12[%76, %arg11] : tensor<24x11xf32> + affine.yield %inserted_16 : tensor<24x11xf32> + } + affine.yield %17 : tensor<24x11xf32> + } + %extracted = tensor.extract %2[%arg6, %c23, %c10] : tensor + %extracted_6 = tensor.extract %2[%arg6, %c23, %c9] : tensor + %11 = arith.addf %extracted, %extracted_6 : f32 + %12 = affine.for %arg9 = 0 to 24 iter_args(%arg10 = %arg8) -> (tensor) { + %13 = affine.for %arg11 = 0 to 11 iter_args(%arg12 = %arg10) -> (tensor) { + %14 = arith.index_cast %arg11 : index to i32 + %15 = arith.andi %14, %c1_i32 : i32 + %16 = arith.cmpi ne, %15, %c0_i32 : i32 + %17 = arith.cmpi slt, %arg11, %c0 : index + %18 = arith.subi %c-1, %arg11 : index + %19 = arith.select %17, %18, %arg11 : index + %20 = arith.divsi %19, %c2 : index + %21 = arith.subi %c-1, %20 : index + %22 = arith.select %17, %21, %20 : index + %extracted_7 = tensor.extract %1[%arg6, %22] : tensor + %23 = arith.select %16, %extracted_7, %arg2 : i32 + %24 = arith.index_cast %23 : i32 to index + %extracted_8 = tensor.extract %3[%arg6] : tensor + %extracted_9 = tensor.extract %2[%arg6, %arg9, %arg11] : tensor + %25 = arith.mulf %extracted_8, %extracted_9 : f32 + %extracted_10 = tensor.extract %10[%arg9, %arg11] : tensor<24x11xf32> + %26 = arith.mulf %25, %extracted_10 : f32 + %27 = arith.divf %26, %11 : f32 + %extracted_11 = tensor.extract %arg12[%arg9, %arg6, %24] : tensor + %28 = arith.subf %extracted_11, %27 : f32 + %inserted_12 = tensor.insert %28 into %arg12[%arg9, %arg6, %24] : tensor + affine.yield %inserted_12 : tensor + } + affine.yield %13 : tensor + } + affine.yield %10, %12 : tensor<24x11xf32>, tensor + } + %8 = bufferization.to_memref %7#1 : memref + memref.copy %8, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu/matched.mlir new file mode 100644 index 000000000000..6bca641a04a4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu/matched.mlir @@ -0,0 +1,168 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (-d0 + 23)> +#map4 = affine_map<(d0) -> (-d0 + 9)> +#map5 = affine_map<(d0, d1) -> (d1 + 1)> +#map6 = affine_map<(d0) -> (-d0 + 8)> +#map7 = affine_map<(d0, d1) -> (d1 + 2)> +#map8 = affine_map<(d0, d1) -> (-d0 + 22)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ctc_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %c22 = arith.constant 22 : index + %c1 = arith.constant 1 : index + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %c-2 = arith.constant -2 : index + %c11 = arith.constant 11 : index + %c12 = arith.constant 12 : index + %c4 = arith.constant 4 : index + %c0 = arith.constant 0 : index + %c24 = arith.constant 24 : index + %c10 = arith.constant 10 : index + %c23 = arith.constant 23 : index + %c9 = arith.constant 9 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = tensor.empty() : tensor<24x11xf32> + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c24, %c4, %c12] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c4] [1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %4[0, 0, 0] [%c24, %c4, %c12] [1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_1 : tensor, tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %9 = math.exp %in : f32 + %10 = arith.mulf %9, %in_3 : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %4[0, 0, 0] [%c24, %c4, %c12] [1, 1, 1] : tensor into tensor + %7:2 = affine.for %arg6 = 0 to 4 iter_args(%arg7 = %5, %arg8 = %inserted_slice) -> (tensor<24x11xf32>, tensor) { + %extracted_slice_3 = tensor.extract_slice %arg7[0, 0] [%c24, %c11] [1, 1] : tensor<24x11xf32> to tensor + %9 = kernel.launch @memset_zero_2D_f32(%extracted_slice_3) : (tensor) -> tensor + %inserted_slice_4 = tensor.insert_slice %9 into %arg7[0, 0] [%c24, %c11] [1, 1] : tensor into tensor<24x11xf32> + %inserted = tensor.insert %cst_0 into %inserted_slice_4[%c23, %c9] : tensor<24x11xf32> + %inserted_5 = tensor.insert %cst_0 into %inserted[%c23, %c10] : tensor<24x11xf32> + %10 = affine.for %arg9 = 0 to 23 iter_args(%arg10 = %inserted_5) -> (tensor<24x11xf32>) { + %13 = arith.subi %c22, %arg9 : index + %14 = arith.index_cast %13 : index to i32 + %15 = arith.addi %14, %c1_i32 : i32 + %16 = arith.index_cast %15 : i32 to index + %17 = affine.for %arg11 = 0 to 11 iter_args(%arg12 = %arg10) -> (tensor<24x11xf32>) { + %18 = arith.index_cast %arg11 : index to i32 + %19 = arith.andi %18, %c1_i32 : i32 + %20 = arith.cmpi ne, %19, %c0_i32 : i32 + %21 = arith.cmpi slt, %arg11, %c0 : index + %22 = arith.subi %c-1, %arg11 : index + %23 = arith.select %21, %22, %arg11 : index + %24 = arith.divsi %23, %c2 : index + %25 = arith.subi %c-1, %24 : index + %26 = arith.select %21, %25, %24 : index + %extracted_7 = tensor.extract %1[%arg6, %26] : tensor + %27 = arith.select %20, %extracted_7, %arg2 : i32 + %28 = affine.apply #map3(%arg9, %arg11) + %extracted_8 = tensor.extract %arg12[%28, %arg11] : tensor<24x11xf32> + %29 = arith.index_cast %27 : i32 to index + %extracted_9 = tensor.extract %0[%16, %arg6, %29] : tensor + %30 = math.exp %extracted_9 : f32 + %31 = arith.mulf %extracted_8, %30 : f32 + %32 = arith.addi %18, %c1_i32 : i32 + %33 = affine.apply #map4(%arg11) + %34 = arith.cmpi sge, %33, %c0 : index + %35 = arith.andi %32, %c1_i32 : i32 + %36 = arith.cmpi ne, %35, %c0_i32 : i32 + %37 = arith.addi %arg11, %c1 : index + %38 = arith.cmpi slt, %37, %c0 : index + %39 = arith.subi %c-2, %arg11 : index + %40 = arith.select %38, %39, %37 : index + %41 = arith.divsi %40, %c2 : index + %42 = arith.subi %c-1, %41 : index + %43 = arith.select %38, %42, %41 : index + %extracted_10 = tensor.extract %1[%arg6, %43] : tensor + %44 = arith.select %36, %extracted_10, %arg2 : i32 + %45 = affine.apply #map3(%arg9, %arg11) + %46 = affine.apply #map5(%arg9, %arg11) + %extracted_11 = tensor.extract %arg12[%45, %46] : tensor<24x11xf32> + %47 = arith.index_cast %44 : i32 to index + %extracted_12 = tensor.extract %0[%16, %arg6, %47] : tensor + %48 = math.exp %extracted_12 : f32 + %49 = arith.mulf %extracted_11, %48 : f32 + %50 = arith.addf %31, %49 : f32 + %51 = arith.select %34, %50, %31 : f32 + %52 = arith.addi %18, %c2_i32 : i32 + %53 = affine.apply #map6(%arg11) + %54 = arith.cmpi sge, %53, %c0 : index + %55 = arith.andi %52, %c1_i32 : i32 + %56 = arith.cmpi ne, %55, %c0_i32 : i32 + %57 = arith.cmpi slt, %arg11, %c0 : index + %58 = arith.subi %c-1, %arg11 : index + %59 = arith.select %57, %58, %arg11 : index + %60 = arith.divsi %59, %c2 : index + %61 = arith.subi %c-1, %60 : index + %62 = arith.select %57, %61, %60 : index + %63 = arith.addi %62, %c1 : index + %extracted_13 = tensor.extract %1[%arg6, %63] : tensor + %64 = arith.select %56, %extracted_13, %arg2 : i32 + %65 = arith.cmpi ne, %27, %arg2 : i32 + %66 = arith.cmpi ne, %27, %64 : i32 + %67 = arith.andi %65, %66 : i1 + %68 = affine.apply #map3(%arg9, %arg11) + %69 = affine.apply #map7(%arg9, %arg11) + %extracted_14 = tensor.extract %arg12[%68, %69] : tensor<24x11xf32> + %70 = arith.index_cast %64 : i32 to index + %extracted_15 = tensor.extract %0[%16, %arg6, %70] : tensor + %71 = math.exp %extracted_15 : f32 + %72 = arith.mulf %extracted_14, %71 : f32 + %73 = arith.addf %51, %72 : f32 + %74 = arith.select %67, %73, %51 : f32 + %75 = arith.select %54, %74, %51 : f32 + %76 = affine.apply #map8(%arg9, %arg11) + %inserted_16 = tensor.insert %75 into %arg12[%76, %arg11] : tensor<24x11xf32> + affine.yield %inserted_16 : tensor<24x11xf32> + } + affine.yield %17 : tensor<24x11xf32> + } + %extracted = tensor.extract %2[%arg6, %c23, %c10] : tensor + %extracted_6 = tensor.extract %2[%arg6, %c23, %c9] : tensor + %11 = arith.addf %extracted, %extracted_6 : f32 + %12 = affine.for %arg9 = 0 to 24 iter_args(%arg10 = %arg8) -> (tensor) { + %13 = affine.for %arg11 = 0 to 11 iter_args(%arg12 = %arg10) -> (tensor) { + %14 = arith.index_cast %arg11 : index to i32 + %15 = arith.andi %14, %c1_i32 : i32 + %16 = arith.cmpi ne, %15, %c0_i32 : i32 + %17 = arith.cmpi slt, %arg11, %c0 : index + %18 = arith.subi %c-1, %arg11 : index + %19 = arith.select %17, %18, %arg11 : index + %20 = arith.divsi %19, %c2 : index + %21 = arith.subi %c-1, %20 : index + %22 = arith.select %17, %21, %20 : index + %extracted_7 = tensor.extract %1[%arg6, %22] : tensor + %23 = arith.select %16, %extracted_7, %arg2 : i32 + %24 = arith.index_cast %23 : i32 to index + %extracted_8 = tensor.extract %3[%arg6] : tensor + %extracted_9 = tensor.extract %2[%arg6, %arg9, %arg11] : tensor + %25 = arith.mulf %extracted_8, %extracted_9 : f32 + %extracted_10 = tensor.extract %10[%arg9, %arg11] : tensor<24x11xf32> + %26 = arith.mulf %25, %extracted_10 : f32 + %27 = arith.divf %26, %11 : f32 + %extracted_11 = tensor.extract %arg12[%arg9, %arg6, %24] : tensor + %28 = arith.subf %extracted_11, %27 : f32 + %inserted_12 = tensor.insert %28 into %arg12[%arg9, %arg6, %24] : tensor + affine.yield %inserted_12 : tensor + } + affine.yield %13 : tensor + } + affine.yield %10, %12 : tensor<24x11xf32>, tensor + } + %8 = bufferization.to_memref %7#1 : memref + memref.copy %8, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu/orig.mlir new file mode 100644 index 000000000000..079f7a88ee0c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu/orig.mlir @@ -0,0 +1,162 @@ +#set = affine_set<(d0) : (-d0 + 9 >= 0)> +#set1 = affine_set<(d0) : (-d0 + 8 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ctc_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-2 = arith.constant -2 : index + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c22 = arith.constant 22 : index + %cst = arith.constant 1.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<24x11xf32> + affine.for %arg6 = 0 to 24 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 12 { + %0 = affine.load %arg0[%arg6, %arg7, %arg8] : memref + %1 = math.exp %0 : f32 + %2 = affine.load %arg4[%arg7] : memref + %3 = arith.mulf %1, %2 : f32 + affine.store %3, %arg5[%arg6, %arg7, %arg8] : memref + } + } + } + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 24 { + affine.for %arg8 = 0 to 11 { + affine.store %cst_0, %alloca[%arg7, %arg8] : memref<24x11xf32> + } + } + affine.store %cst, %alloca[23, 9] : memref<24x11xf32> + affine.store %cst, %alloca[23, 10] : memref<24x11xf32> + affine.for %arg7 = 0 to 23 { + %3 = arith.subi %c22, %arg7 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.addi %4, %c1_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + affine.for %arg8 = 0 to 11 { + %7 = arith.index_cast %arg8 : index to i32 + %8 = arith.andi %7, %c1_i32 : i32 + %9 = arith.cmpi ne, %8, %c0_i32 : i32 + %10 = scf.if %9 -> (i32) { + %20 = arith.cmpi slt, %arg8, %c0 : index + %21 = arith.subi %c-1, %arg8 : index + %22 = arith.select %20, %21, %arg8 : index + %23 = arith.divsi %22, %c2 : index + %24 = arith.subi %c-1, %23 : index + %25 = arith.select %20, %24, %23 : index + %26 = memref.load %arg1[%arg6, %25] : memref + scf.yield %26 : i32 + } else { + scf.yield %arg2 : i32 + } + %11 = affine.load %alloca[-%arg7 + 23, %arg8] : memref<24x11xf32> + %12 = arith.index_cast %10 : i32 to index + %13 = memref.load %arg0[%6, %arg6, %12] : memref + %14 = math.exp %13 : f32 + %15 = arith.mulf %11, %14 : f32 + %16 = arith.addi %7, %c1_i32 : i32 + %17 = affine.if #set(%arg8) -> f32 { + %20 = arith.andi %16, %c1_i32 : i32 + %21 = arith.cmpi ne, %20, %c0_i32 : i32 + %22 = scf.if %21 -> (i32) { + %29 = arith.addi %arg8, %c1 : index + %30 = arith.cmpi slt, %29, %c0 : index + %31 = arith.subi %c-2, %arg8 : index + %32 = arith.select %30, %31, %29 : index + %33 = arith.divsi %32, %c2 : index + %34 = arith.subi %c-1, %33 : index + %35 = arith.select %30, %34, %33 : index + %36 = memref.load %arg1[%arg6, %35] : memref + scf.yield %36 : i32 + } else { + scf.yield %arg2 : i32 + } + %23 = affine.load %alloca[-%arg7 + 23, %arg8 + 1] : memref<24x11xf32> + %24 = arith.index_cast %22 : i32 to index + %25 = memref.load %arg0[%6, %arg6, %24] : memref + %26 = math.exp %25 : f32 + %27 = arith.mulf %23, %26 : f32 + %28 = arith.addf %15, %27 : f32 + affine.yield %28 : f32 + } else { + affine.yield %15 : f32 + } + %18 = arith.addi %7, %c2_i32 : i32 + %19 = affine.if #set1(%arg8) -> f32 { + %20 = arith.andi %18, %c1_i32 : i32 + %21 = arith.cmpi ne, %20, %c0_i32 : i32 + %22 = scf.if %21 -> (i32) { + %27 = arith.cmpi slt, %arg8, %c0 : index + %28 = arith.subi %c-1, %arg8 : index + %29 = arith.select %27, %28, %arg8 : index + %30 = arith.divsi %29, %c2 : index + %31 = arith.subi %c-1, %30 : index + %32 = arith.select %27, %31, %30 : index + %33 = arith.addi %32, %c1 : index + %34 = memref.load %arg1[%arg6, %33] : memref + scf.yield %34 : i32 + } else { + scf.yield %arg2 : i32 + } + %23 = arith.cmpi ne, %10, %arg2 : i32 + %24 = arith.cmpi ne, %10, %22 : i32 + %25 = arith.andi %23, %24 : i1 + %26 = scf.if %25 -> (f32) { + %27 = affine.load %alloca[-%arg7 + 23, %arg8 + 2] : memref<24x11xf32> + %28 = arith.index_cast %22 : i32 to index + %29 = memref.load %arg0[%6, %arg6, %28] : memref + %30 = math.exp %29 : f32 + %31 = arith.mulf %27, %30 : f32 + %32 = arith.addf %17, %31 : f32 + scf.yield %32 : f32 + } else { + scf.yield %17 : f32 + } + affine.yield %26 : f32 + } else { + affine.yield %17 : f32 + } + affine.store %19, %alloca[-%arg7 + 22, %arg8] : memref<24x11xf32> + } + } + %0 = affine.load %arg3[%arg6, 23, 10] : memref + %1 = affine.load %arg3[%arg6, 23, 9] : memref + %2 = arith.addf %0, %1 : f32 + affine.for %arg7 = 0 to 24 { + affine.for %arg8 = 0 to 11 { + %3 = arith.index_cast %arg8 : index to i32 + %4 = arith.andi %3, %c1_i32 : i32 + %5 = arith.cmpi ne, %4, %c0_i32 : i32 + %6 = scf.if %5 -> (i32) { + %16 = arith.cmpi slt, %arg8, %c0 : index + %17 = arith.subi %c-1, %arg8 : index + %18 = arith.select %16, %17, %arg8 : index + %19 = arith.divsi %18, %c2 : index + %20 = arith.subi %c-1, %19 : index + %21 = arith.select %16, %20, %19 : index + %22 = memref.load %arg1[%arg6, %21] : memref + scf.yield %22 : i32 + } else { + scf.yield %arg2 : i32 + } + %7 = arith.index_cast %6 : i32 to index + %8 = affine.load %arg4[%arg6] : memref + %9 = affine.load %arg3[%arg6, %arg7, %arg8] : memref + %10 = arith.mulf %8, %9 : f32 + %11 = affine.load %alloca[%arg7, %arg8] : memref<24x11xf32> + %12 = arith.mulf %10, %11 : f32 + %13 = arith.divf %12, %2 : f32 + %14 = memref.load %arg5[%arg7, %arg6, %7] : memref + %15 = arith.subf %14, %13 : f32 + memref.store %15, %arg5[%arg7, %arg6, %7] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu/raised.mlir new file mode 100644 index 000000000000..97c917e9a863 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu/raised.mlir @@ -0,0 +1,144 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0) -> (-d0 + 9)> +#map4 = affine_map<(d0) -> (-d0 + 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ctc_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c24 = arith.constant 24 : index + %c0 = arith.constant 0 : index + %c4 = arith.constant 4 : index + %c12 = arith.constant 12 : index + %c11 = arith.constant 11 : index + %c-2 = arith.constant -2 : index + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c1 = arith.constant 1 : index + %c22 = arith.constant 22 : index + %cst = arith.constant 1.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<24x11xf32> + %subview = memref.subview %arg0[0, 0, 0] [%c24, %c4, %c12] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg4[0] [%c4] [1] : memref to memref> + %subview_2 = memref.subview %arg5[0, 0, 0] [%c24, %c4, %c12] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = math.exp %in : f32 + %1 = arith.mulf %0, %in_3 : f32 + linalg.yield %1 : f32 + } + affine.for %arg6 = 0 to 4 { + %subview_3 = memref.subview %alloca[0, 0] [%c24, %c11] [1, 1] : memref<24x11xf32> to memref> + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel", "parallel"]} outs(%subview_3 : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + affine.store %cst, %alloca[23, 9] : memref<24x11xf32> + affine.store %cst, %alloca[23, 10] : memref<24x11xf32> + affine.for %arg7 = 0 to 23 { + %3 = arith.subi %c22, %arg7 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.addi %4, %c1_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + affine.for %arg8 = 0 to 11 { + %7 = arith.index_cast %arg8 : index to i32 + %8 = arith.andi %7, %c1_i32 : i32 + %9 = arith.cmpi ne, %8, %c0_i32 : i32 + %10 = arith.cmpi slt, %arg8, %c0 : index + %11 = arith.subi %c-1, %arg8 : index + %12 = arith.select %10, %11, %arg8 : index + %13 = arith.divsi %12, %c2 : index + %14 = arith.subi %c-1, %13 : index + %15 = arith.select %10, %14, %13 : index + %16 = memref.load %arg1[%arg6, %15] : memref + %17 = arith.select %9, %16, %arg2 : i32 + %18 = affine.load %alloca[-%arg7 + 23, %arg8] : memref<24x11xf32> + %19 = arith.index_cast %17 : i32 to index + %20 = memref.load %arg0[%6, %arg6, %19] : memref + %21 = math.exp %20 : f32 + %22 = arith.mulf %18, %21 : f32 + %23 = arith.addi %7, %c1_i32 : i32 + %24 = affine.apply #map3(%arg8) + %25 = arith.cmpi sge, %24, %c0 : index + %26 = arith.andi %23, %c1_i32 : i32 + %27 = arith.cmpi ne, %26, %c0_i32 : i32 + %28 = arith.addi %arg8, %c1 : index + %29 = arith.cmpi slt, %28, %c0 : index + %30 = arith.subi %c-2, %arg8 : index + %31 = arith.select %29, %30, %28 : index + %32 = arith.divsi %31, %c2 : index + %33 = arith.subi %c-1, %32 : index + %34 = arith.select %29, %33, %32 : index + %35 = memref.load %arg1[%arg6, %34] : memref + %36 = arith.select %27, %35, %arg2 : i32 + %37 = affine.load %alloca[-%arg7 + 23, %arg8 + 1] : memref<24x11xf32> + %38 = arith.index_cast %36 : i32 to index + %39 = memref.load %arg0[%6, %arg6, %38] : memref + %40 = math.exp %39 : f32 + %41 = arith.mulf %37, %40 : f32 + %42 = arith.addf %22, %41 : f32 + %43 = arith.select %25, %42, %22 : f32 + %44 = arith.addi %7, %c2_i32 : i32 + %45 = affine.apply #map4(%arg8) + %46 = arith.cmpi sge, %45, %c0 : index + %47 = arith.andi %44, %c1_i32 : i32 + %48 = arith.cmpi ne, %47, %c0_i32 : i32 + %49 = arith.cmpi slt, %arg8, %c0 : index + %50 = arith.subi %c-1, %arg8 : index + %51 = arith.select %49, %50, %arg8 : index + %52 = arith.divsi %51, %c2 : index + %53 = arith.subi %c-1, %52 : index + %54 = arith.select %49, %53, %52 : index + %55 = arith.addi %54, %c1 : index + %56 = memref.load %arg1[%arg6, %55] : memref + %57 = arith.select %48, %56, %arg2 : i32 + %58 = arith.cmpi ne, %17, %arg2 : i32 + %59 = arith.cmpi ne, %17, %57 : i32 + %60 = arith.andi %58, %59 : i1 + %61 = affine.load %alloca[-%arg7 + 23, %arg8 + 2] : memref<24x11xf32> + %62 = arith.index_cast %57 : i32 to index + %63 = memref.load %arg0[%6, %arg6, %62] : memref + %64 = math.exp %63 : f32 + %65 = arith.mulf %61, %64 : f32 + %66 = arith.addf %43, %65 : f32 + %67 = arith.select %60, %66, %43 : f32 + %68 = arith.select %46, %67, %43 : f32 + affine.store %68, %alloca[-%arg7 + 22, %arg8] : memref<24x11xf32> + } + } + %0 = affine.load %arg3[%arg6, 23, 10] : memref + %1 = affine.load %arg3[%arg6, 23, 9] : memref + %2 = arith.addf %0, %1 : f32 + affine.for %arg7 = 0 to 24 { + affine.for %arg8 = 0 to 11 { + %3 = arith.index_cast %arg8 : index to i32 + %4 = arith.andi %3, %c1_i32 : i32 + %5 = arith.cmpi ne, %4, %c0_i32 : i32 + %6 = arith.cmpi slt, %arg8, %c0 : index + %7 = arith.subi %c-1, %arg8 : index + %8 = arith.select %6, %7, %arg8 : index + %9 = arith.divsi %8, %c2 : index + %10 = arith.subi %c-1, %9 : index + %11 = arith.select %6, %10, %9 : index + %12 = memref.load %arg1[%arg6, %11] : memref + %13 = arith.select %5, %12, %arg2 : i32 + %14 = arith.index_cast %13 : i32 to index + %15 = affine.load %arg4[%arg6] : memref + %16 = affine.load %arg3[%arg6, %arg7, %arg8] : memref + %17 = arith.mulf %15, %16 : f32 + %18 = affine.load %alloca[%arg7, %arg8] : memref<24x11xf32> + %19 = arith.mulf %17, %18 : f32 + %20 = arith.divf %19, %2 : f32 + %21 = memref.load %arg5[%arg7, %arg6, %14] : memref + %22 = arith.subf %21, %20 : f32 + memref.store %22, %arg5[%arg7, %arg6, %14] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..bdab0c583cce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu_debuf.mlir @@ -0,0 +1,171 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (-d0 + 23)> +#map4 = affine_map<(d0) -> (-d0 + 9)> +#map5 = affine_map<(d0, d1) -> (d1 + 1)> +#map6 = affine_map<(d0) -> (-d0 + 8)> +#map7 = affine_map<(d0, d1) -> (d1 + 2)> +#map8 = affine_map<(d0, d1) -> (-d0 + 22)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ctc_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %c22 = arith.constant 22 : index + %c1 = arith.constant 1 : index + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %c-2 = arith.constant -2 : index + %c11 = arith.constant 11 : index + %c12 = arith.constant 12 : index + %c4 = arith.constant 4 : index + %c0 = arith.constant 0 : index + %c24 = arith.constant 24 : index + %c10 = arith.constant 10 : index + %c23 = arith.constant 23 : index + %c9 = arith.constant 9 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = tensor.empty() : tensor<24x11xf32> + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c24, %c4, %c12] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c4] [1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %4[0, 0, 0] [%c24, %c4, %c12] [1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_1 : tensor, tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %9 = math.exp %in : f32 + %10 = arith.mulf %9, %in_3 : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %4[0, 0, 0] [%c24, %c4, %c12] [1, 1, 1] : tensor into tensor + %7:2 = affine.for %arg6 = 0 to 4 iter_args(%arg7 = %5, %arg8 = %inserted_slice) -> (tensor<24x11xf32>, tensor) { + %extracted_slice_3 = tensor.extract_slice %arg7[0, 0] [%c24, %c11] [1, 1] : tensor<24x11xf32> to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice_3 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice_4 = tensor.insert_slice %9 into %arg7[0, 0] [%c24, %c11] [1, 1] : tensor into tensor<24x11xf32> + %inserted = tensor.insert %cst_0 into %inserted_slice_4[%c23, %c9] : tensor<24x11xf32> + %inserted_5 = tensor.insert %cst_0 into %inserted[%c23, %c10] : tensor<24x11xf32> + %10 = affine.for %arg9 = 0 to 23 iter_args(%arg10 = %inserted_5) -> (tensor<24x11xf32>) { + %13 = arith.subi %c22, %arg9 : index + %14 = arith.index_cast %13 : index to i32 + %15 = arith.addi %14, %c1_i32 : i32 + %16 = arith.index_cast %15 : i32 to index + %17 = affine.for %arg11 = 0 to 11 iter_args(%arg12 = %arg10) -> (tensor<24x11xf32>) { + %18 = arith.index_cast %arg11 : index to i32 + %19 = arith.andi %18, %c1_i32 : i32 + %20 = arith.cmpi ne, %19, %c0_i32 : i32 + %21 = arith.cmpi slt, %arg11, %c0 : index + %22 = arith.subi %c-1, %arg11 : index + %23 = arith.select %21, %22, %arg11 : index + %24 = arith.divsi %23, %c2 : index + %25 = arith.subi %c-1, %24 : index + %26 = arith.select %21, %25, %24 : index + %extracted_7 = tensor.extract %1[%arg6, %26] : tensor + %27 = arith.select %20, %extracted_7, %arg2 : i32 + %28 = affine.apply #map3(%arg9, %arg11) + %extracted_8 = tensor.extract %arg12[%28, %arg11] : tensor<24x11xf32> + %29 = arith.index_cast %27 : i32 to index + %extracted_9 = tensor.extract %0[%16, %arg6, %29] : tensor + %30 = math.exp %extracted_9 : f32 + %31 = arith.mulf %extracted_8, %30 : f32 + %32 = arith.addi %18, %c1_i32 : i32 + %33 = affine.apply #map4(%arg11) + %34 = arith.cmpi sge, %33, %c0 : index + %35 = arith.andi %32, %c1_i32 : i32 + %36 = arith.cmpi ne, %35, %c0_i32 : i32 + %37 = arith.addi %arg11, %c1 : index + %38 = arith.cmpi slt, %37, %c0 : index + %39 = arith.subi %c-2, %arg11 : index + %40 = arith.select %38, %39, %37 : index + %41 = arith.divsi %40, %c2 : index + %42 = arith.subi %c-1, %41 : index + %43 = arith.select %38, %42, %41 : index + %extracted_10 = tensor.extract %1[%arg6, %43] : tensor + %44 = arith.select %36, %extracted_10, %arg2 : i32 + %45 = affine.apply #map3(%arg9, %arg11) + %46 = affine.apply #map5(%arg9, %arg11) + %extracted_11 = tensor.extract %arg12[%45, %46] : tensor<24x11xf32> + %47 = arith.index_cast %44 : i32 to index + %extracted_12 = tensor.extract %0[%16, %arg6, %47] : tensor + %48 = math.exp %extracted_12 : f32 + %49 = arith.mulf %extracted_11, %48 : f32 + %50 = arith.addf %31, %49 : f32 + %51 = arith.select %34, %50, %31 : f32 + %52 = arith.addi %18, %c2_i32 : i32 + %53 = affine.apply #map6(%arg11) + %54 = arith.cmpi sge, %53, %c0 : index + %55 = arith.andi %52, %c1_i32 : i32 + %56 = arith.cmpi ne, %55, %c0_i32 : i32 + %57 = arith.cmpi slt, %arg11, %c0 : index + %58 = arith.subi %c-1, %arg11 : index + %59 = arith.select %57, %58, %arg11 : index + %60 = arith.divsi %59, %c2 : index + %61 = arith.subi %c-1, %60 : index + %62 = arith.select %57, %61, %60 : index + %63 = arith.addi %62, %c1 : index + %extracted_13 = tensor.extract %1[%arg6, %63] : tensor + %64 = arith.select %56, %extracted_13, %arg2 : i32 + %65 = arith.cmpi ne, %27, %arg2 : i32 + %66 = arith.cmpi ne, %27, %64 : i32 + %67 = arith.andi %65, %66 : i1 + %68 = affine.apply #map3(%arg9, %arg11) + %69 = affine.apply #map7(%arg9, %arg11) + %extracted_14 = tensor.extract %arg12[%68, %69] : tensor<24x11xf32> + %70 = arith.index_cast %64 : i32 to index + %extracted_15 = tensor.extract %0[%16, %arg6, %70] : tensor + %71 = math.exp %extracted_15 : f32 + %72 = arith.mulf %extracted_14, %71 : f32 + %73 = arith.addf %51, %72 : f32 + %74 = arith.select %67, %73, %51 : f32 + %75 = arith.select %54, %74, %51 : f32 + %76 = affine.apply #map8(%arg9, %arg11) + %inserted_16 = tensor.insert %75 into %arg12[%76, %arg11] : tensor<24x11xf32> + affine.yield %inserted_16 : tensor<24x11xf32> + } + affine.yield %17 : tensor<24x11xf32> + } + %extracted = tensor.extract %2[%arg6, %c23, %c10] : tensor + %extracted_6 = tensor.extract %2[%arg6, %c23, %c9] : tensor + %11 = arith.addf %extracted, %extracted_6 : f32 + %12 = affine.for %arg9 = 0 to 24 iter_args(%arg10 = %arg8) -> (tensor) { + %13 = affine.for %arg11 = 0 to 11 iter_args(%arg12 = %arg10) -> (tensor) { + %14 = arith.index_cast %arg11 : index to i32 + %15 = arith.andi %14, %c1_i32 : i32 + %16 = arith.cmpi ne, %15, %c0_i32 : i32 + %17 = arith.cmpi slt, %arg11, %c0 : index + %18 = arith.subi %c-1, %arg11 : index + %19 = arith.select %17, %18, %arg11 : index + %20 = arith.divsi %19, %c2 : index + %21 = arith.subi %c-1, %20 : index + %22 = arith.select %17, %21, %20 : index + %extracted_7 = tensor.extract %1[%arg6, %22] : tensor + %23 = arith.select %16, %extracted_7, %arg2 : i32 + %24 = arith.index_cast %23 : i32 to index + %extracted_8 = tensor.extract %3[%arg6] : tensor + %extracted_9 = tensor.extract %2[%arg6, %arg9, %arg11] : tensor + %25 = arith.mulf %extracted_8, %extracted_9 : f32 + %extracted_10 = tensor.extract %10[%arg9, %arg11] : tensor<24x11xf32> + %26 = arith.mulf %25, %extracted_10 : f32 + %27 = arith.divf %26, %11 : f32 + %extracted_11 = tensor.extract %arg12[%arg9, %arg6, %24] : tensor + %28 = arith.subf %extracted_11, %27 : f32 + %inserted_12 = tensor.insert %28 into %arg12[%arg9, %arg6, %24] : tensor + affine.yield %inserted_12 : tensor + } + affine.yield %13 : tensor + } + affine.yield %10, %12 : tensor<24x11xf32>, tensor + } + %8 = bufferization.to_memref %7#1 : memref + memref.copy %8, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..97c917e9a863 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ctc_loss_backward_cpu_linalg.mlir @@ -0,0 +1,144 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0) -> (-d0 + 9)> +#map4 = affine_map<(d0) -> (-d0 + 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ctc_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c24 = arith.constant 24 : index + %c0 = arith.constant 0 : index + %c4 = arith.constant 4 : index + %c12 = arith.constant 12 : index + %c11 = arith.constant 11 : index + %c-2 = arith.constant -2 : index + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c1 = arith.constant 1 : index + %c22 = arith.constant 22 : index + %cst = arith.constant 1.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<24x11xf32> + %subview = memref.subview %arg0[0, 0, 0] [%c24, %c4, %c12] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg4[0] [%c4] [1] : memref to memref> + %subview_2 = memref.subview %arg5[0, 0, 0] [%c24, %c4, %c12] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = math.exp %in : f32 + %1 = arith.mulf %0, %in_3 : f32 + linalg.yield %1 : f32 + } + affine.for %arg6 = 0 to 4 { + %subview_3 = memref.subview %alloca[0, 0] [%c24, %c11] [1, 1] : memref<24x11xf32> to memref> + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel", "parallel"]} outs(%subview_3 : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + affine.store %cst, %alloca[23, 9] : memref<24x11xf32> + affine.store %cst, %alloca[23, 10] : memref<24x11xf32> + affine.for %arg7 = 0 to 23 { + %3 = arith.subi %c22, %arg7 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.addi %4, %c1_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + affine.for %arg8 = 0 to 11 { + %7 = arith.index_cast %arg8 : index to i32 + %8 = arith.andi %7, %c1_i32 : i32 + %9 = arith.cmpi ne, %8, %c0_i32 : i32 + %10 = arith.cmpi slt, %arg8, %c0 : index + %11 = arith.subi %c-1, %arg8 : index + %12 = arith.select %10, %11, %arg8 : index + %13 = arith.divsi %12, %c2 : index + %14 = arith.subi %c-1, %13 : index + %15 = arith.select %10, %14, %13 : index + %16 = memref.load %arg1[%arg6, %15] : memref + %17 = arith.select %9, %16, %arg2 : i32 + %18 = affine.load %alloca[-%arg7 + 23, %arg8] : memref<24x11xf32> + %19 = arith.index_cast %17 : i32 to index + %20 = memref.load %arg0[%6, %arg6, %19] : memref + %21 = math.exp %20 : f32 + %22 = arith.mulf %18, %21 : f32 + %23 = arith.addi %7, %c1_i32 : i32 + %24 = affine.apply #map3(%arg8) + %25 = arith.cmpi sge, %24, %c0 : index + %26 = arith.andi %23, %c1_i32 : i32 + %27 = arith.cmpi ne, %26, %c0_i32 : i32 + %28 = arith.addi %arg8, %c1 : index + %29 = arith.cmpi slt, %28, %c0 : index + %30 = arith.subi %c-2, %arg8 : index + %31 = arith.select %29, %30, %28 : index + %32 = arith.divsi %31, %c2 : index + %33 = arith.subi %c-1, %32 : index + %34 = arith.select %29, %33, %32 : index + %35 = memref.load %arg1[%arg6, %34] : memref + %36 = arith.select %27, %35, %arg2 : i32 + %37 = affine.load %alloca[-%arg7 + 23, %arg8 + 1] : memref<24x11xf32> + %38 = arith.index_cast %36 : i32 to index + %39 = memref.load %arg0[%6, %arg6, %38] : memref + %40 = math.exp %39 : f32 + %41 = arith.mulf %37, %40 : f32 + %42 = arith.addf %22, %41 : f32 + %43 = arith.select %25, %42, %22 : f32 + %44 = arith.addi %7, %c2_i32 : i32 + %45 = affine.apply #map4(%arg8) + %46 = arith.cmpi sge, %45, %c0 : index + %47 = arith.andi %44, %c1_i32 : i32 + %48 = arith.cmpi ne, %47, %c0_i32 : i32 + %49 = arith.cmpi slt, %arg8, %c0 : index + %50 = arith.subi %c-1, %arg8 : index + %51 = arith.select %49, %50, %arg8 : index + %52 = arith.divsi %51, %c2 : index + %53 = arith.subi %c-1, %52 : index + %54 = arith.select %49, %53, %52 : index + %55 = arith.addi %54, %c1 : index + %56 = memref.load %arg1[%arg6, %55] : memref + %57 = arith.select %48, %56, %arg2 : i32 + %58 = arith.cmpi ne, %17, %arg2 : i32 + %59 = arith.cmpi ne, %17, %57 : i32 + %60 = arith.andi %58, %59 : i1 + %61 = affine.load %alloca[-%arg7 + 23, %arg8 + 2] : memref<24x11xf32> + %62 = arith.index_cast %57 : i32 to index + %63 = memref.load %arg0[%6, %arg6, %62] : memref + %64 = math.exp %63 : f32 + %65 = arith.mulf %61, %64 : f32 + %66 = arith.addf %43, %65 : f32 + %67 = arith.select %60, %66, %43 : f32 + %68 = arith.select %46, %67, %43 : f32 + affine.store %68, %alloca[-%arg7 + 22, %arg8] : memref<24x11xf32> + } + } + %0 = affine.load %arg3[%arg6, 23, 10] : memref + %1 = affine.load %arg3[%arg6, 23, 9] : memref + %2 = arith.addf %0, %1 : f32 + affine.for %arg7 = 0 to 24 { + affine.for %arg8 = 0 to 11 { + %3 = arith.index_cast %arg8 : index to i32 + %4 = arith.andi %3, %c1_i32 : i32 + %5 = arith.cmpi ne, %4, %c0_i32 : i32 + %6 = arith.cmpi slt, %arg8, %c0 : index + %7 = arith.subi %c-1, %arg8 : index + %8 = arith.select %6, %7, %arg8 : index + %9 = arith.divsi %8, %c2 : index + %10 = arith.subi %c-1, %9 : index + %11 = arith.select %6, %10, %9 : index + %12 = memref.load %arg1[%arg6, %11] : memref + %13 = arith.select %5, %12, %arg2 : i32 + %14 = arith.index_cast %13 : i32 to index + %15 = affine.load %arg4[%arg6] : memref + %16 = affine.load %arg3[%arg6, %arg7, %arg8] : memref + %17 = arith.mulf %15, %16 : f32 + %18 = affine.load %alloca[%arg7, %arg8] : memref<24x11xf32> + %19 = arith.mulf %17, %18 : f32 + %20 = arith.divf %19, %2 : f32 + %21 = memref.load %arg5[%arg7, %arg6, %14] : memref + %22 = arith.subf %21, %20 : f32 + memref.store %22, %arg5[%arg7, %arg6, %14] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ctc_loss_cpu.mlir b/issues/aten_c_kernels/results/aten_ctc_loss_cpu.mlir new file mode 100644 index 000000000000..3f858fece0d7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ctc_loss_cpu.mlir @@ -0,0 +1,100 @@ +#set = affine_set<(d0) : (d0 - 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ctc_loss_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c-2_i32 = arith.constant -2 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.index_cast %arg2 : i32 to index + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 24 { + affine.for %arg7 = 0 to 11 { + affine.store %cst, %arg4[%arg5, %arg6, %arg7] : memref + } + } + %1 = affine.load %arg0[0, %arg5, symbol(%0)] : memref + %2 = math.exp %1 : f32 + affine.store %2, %arg4[%arg5, 0, 0] : memref + %3 = affine.load %arg1[%arg5, 0] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg0[%c0, %arg5, %4] : memref + %6 = math.exp %5 : f32 + affine.store %6, %arg4[%arg5, 0, 1] : memref + affine.for %arg6 = 1 to 24 { + affine.for %arg7 = 0 to 11 { + %12 = arith.index_cast %arg7 : index to i32 + %13 = arith.andi %12, %c1_i32 : i32 + %14 = arith.cmpi ne, %13, %c0_i32 : i32 + %15 = scf.if %14 -> (i32) { + %26 = arith.cmpi slt, %arg7, %c0 : index + %27 = arith.subi %c-1, %arg7 : index + %28 = arith.select %26, %27, %arg7 : index + %29 = arith.divsi %28, %c2 : index + %30 = arith.subi %c-1, %29 : index + %31 = arith.select %26, %30, %29 : index + %32 = memref.load %arg1[%arg5, %31] : memref + scf.yield %32 : i32 + } else { + scf.yield %arg2 : i32 + } + %16 = affine.load %arg4[%arg5, %arg6 - 1, %arg7] : memref + %17 = affine.if #set(%arg7) -> f32 { + %26 = affine.load %arg4[%arg5, %arg6 - 1, %arg7 - 1] : memref + %27 = arith.addf %16, %26 : f32 + affine.yield %27 : f32 + } else { + affine.yield %16 : f32 + } + %18 = arith.cmpi sgt, %12, %c1_i32 : i32 + %19 = arith.cmpi ne, %15, %arg2 : i32 + %20 = arith.andi %18, %19 : i1 + %21 = scf.if %20 -> (f32) { + %26 = arith.addi %12, %c-2_i32 : i32 + %27 = arith.andi %26, %c1_i32 : i32 + %28 = arith.cmpi ne, %27, %c0_i32 : i32 + %29 = scf.if %28 -> (i32) { + %32 = arith.cmpi slt, %arg7, %c0 : index + %33 = arith.subi %c-1, %arg7 : index + %34 = arith.select %32, %33, %arg7 : index + %35 = arith.divsi %34, %c2 : index + %36 = arith.subi %c-1, %35 : index + %37 = arith.select %32, %36, %35 : index + %38 = arith.addi %37, %c-1 : index + %39 = memref.load %arg1[%arg5, %38] : memref + scf.yield %39 : i32 + } else { + scf.yield %arg2 : i32 + } + %30 = arith.cmpi ne, %15, %29 : i32 + %31 = scf.if %30 -> (f32) { + %32 = affine.load %arg4[%arg5, %arg6 - 1, %arg7 - 2] : memref + %33 = arith.addf %17, %32 : f32 + scf.yield %33 : f32 + } else { + scf.yield %17 : f32 + } + scf.yield %31 : f32 + } else { + scf.yield %17 : f32 + } + %22 = arith.index_cast %15 : i32 to index + %23 = memref.load %arg0[%arg6, %arg5, %22] : memref + %24 = math.exp %23 : f32 + %25 = arith.mulf %21, %24 : f32 + affine.store %25, %arg4[%arg5, %arg6, %arg7] : memref + } + } + %7 = affine.load %arg4[%arg5, 23, 10] : memref + %8 = affine.load %arg4[%arg5, 23, 9] : memref + %9 = arith.addf %7, %8 : f32 + %10 = func.call @logf(%9) : (f32) -> f32 + %11 = arith.negf %10 : f32 + affine.store %11, %arg3[%arg5] : memref + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_ctc_loss_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_ctc_loss_cpu/debuf.mlir new file mode 100644 index 000000000000..0672a6ccbf54 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ctc_loss_cpu/debuf.mlir @@ -0,0 +1,122 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0, d1, d2) -> (d1 - 1)> +#map3 = affine_map<(d0) -> (d0 - 1)> +#map4 = affine_map<(d0, d1, d2) -> (d2 - 1)> +#map5 = affine_map<(d0, d1, d2) -> (d2 - 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ctc_loss_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c-2_i32 = arith.constant -2 : i32 + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %c11 = arith.constant 11 : index + %c24 = arith.constant 24 : index + %c0 = arith.constant 0 : index + %c4 = arith.constant 4 : index + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = arith.index_cast %arg2 : i32 to index + %extracted_slice = tensor.extract_slice %3[0, 0, 0] [%c4, %c24, %c11] [1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %3[0, 0, 0] [%c4, %c24, %c11] [1, 1, 1] : tensor into tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, %4] [1, %c4, 1] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %inserted_slice[0, 0, 0] [%c4, 1, 1] [1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = math.exp %in : f32 + linalg.yield %12 : f32 + } -> tensor + %inserted_slice_2 = tensor.insert_slice %6 into %inserted_slice[0, 0, 0] [%c4, 1, 1] [1, 1, 1] : tensor into tensor + %7 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %inserted_slice_2) -> (tensor) { + %extracted = tensor.extract %1[%arg5, %c0] : tensor + %12 = arith.index_cast %extracted : i32 to index + %extracted_7 = tensor.extract %0[%c0, %arg5, %12] : tensor + %13 = math.exp %extracted_7 : f32 + %inserted = tensor.insert %13 into %arg6[%arg5, %c0, %c1] : tensor + affine.yield %inserted : tensor + } + %8 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %7) -> (tensor) { + %12 = affine.for %arg7 = 1 to 24 iter_args(%arg8 = %arg6) -> (tensor) { + %13 = affine.for %arg9 = 0 to 11 iter_args(%arg10 = %arg8) -> (tensor) { + %14 = arith.index_cast %arg9 : index to i32 + %15 = arith.andi %14, %c1_i32 : i32 + %16 = arith.cmpi ne, %15, %c0_i32 : i32 + %17 = arith.cmpi slt, %arg9, %c0 : index + %18 = arith.subi %c-1, %arg9 : index + %19 = arith.select %17, %18, %arg9 : index + %20 = arith.divsi %19, %c2 : index + %21 = arith.subi %c-1, %20 : index + %22 = arith.select %17, %21, %20 : index + %extracted = tensor.extract %1[%arg5, %22] : tensor + %23 = arith.select %16, %extracted, %arg2 : i32 + %24 = affine.apply #map2(%arg5, %arg7, %arg9) + %extracted_7 = tensor.extract %arg10[%arg5, %24, %arg9] : tensor + %25 = affine.apply #map3(%arg9) + %26 = arith.cmpi sge, %25, %c0 : index + %27 = affine.apply #map2(%arg5, %arg7, %arg9) + %28 = affine.apply #map4(%arg5, %arg7, %arg9) + %extracted_8 = tensor.extract %arg10[%arg5, %27, %28] : tensor + %29 = arith.addf %extracted_7, %extracted_8 : f32 + %30 = arith.select %26, %29, %extracted_7 : f32 + %31 = arith.cmpi sgt, %14, %c1_i32 : i32 + %32 = arith.cmpi ne, %23, %arg2 : i32 + %33 = arith.andi %31, %32 : i1 + %34 = arith.addi %14, %c-2_i32 : i32 + %35 = arith.andi %34, %c1_i32 : i32 + %36 = arith.cmpi ne, %35, %c0_i32 : i32 + %37 = arith.cmpi slt, %arg9, %c0 : index + %38 = arith.subi %c-1, %arg9 : index + %39 = arith.select %37, %38, %arg9 : index + %40 = arith.divsi %39, %c2 : index + %41 = arith.subi %c-1, %40 : index + %42 = arith.select %37, %41, %40 : index + %43 = arith.addi %42, %c-1 : index + %extracted_9 = tensor.extract %1[%arg5, %43] : tensor + %44 = arith.select %36, %extracted_9, %arg2 : i32 + %45 = arith.cmpi ne, %23, %44 : i32 + %46 = affine.apply #map2(%arg5, %arg7, %arg9) + %47 = affine.apply #map5(%arg5, %arg7, %arg9) + %extracted_10 = tensor.extract %arg10[%arg5, %46, %47] : tensor + %48 = arith.addf %30, %extracted_10 : f32 + %49 = arith.select %45, %48, %30 : f32 + %50 = arith.select %33, %49, %30 : f32 + %51 = arith.index_cast %23 : i32 to index + %extracted_11 = tensor.extract %0[%arg7, %arg5, %51] : tensor + %52 = math.exp %extracted_11 : f32 + %53 = arith.mulf %50, %52 : f32 + %inserted = tensor.insert %53 into %arg10[%arg5, %arg7, %arg9] : tensor + affine.yield %inserted : tensor + } + affine.yield %13 : tensor + } + affine.yield %12 : tensor + } + %9 = bufferization.to_memref %8 : memref + memref.copy %9, %arg4 : memref to memref + %extracted_slice_3 = tensor.extract_slice %8[0, 23, 10] [%c4, 1, 1] [1, 1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %8[0, 23, 9] [%c4, 1, 1] [1, 1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %2[0] [%c4] [1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3, %extracted_slice_4 : tensor, tensor) outs(%extracted_slice_5 : tensor) { + ^bb0(%in: f32, %in_7: f32, %out: f32): + %12 = arith.addf %in, %in_7 : f32 + %13 = math.log %12 : f32 + %14 = arith.negf %13 : f32 + linalg.yield %14 : f32 + } -> tensor + %inserted_slice_6 = tensor.insert_slice %10 into %2[0] [%c4] [1] : tensor into tensor + %11 = bufferization.to_memref %inserted_slice_6 : memref + memref.copy %11, %arg3 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_ctc_loss_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_ctc_loss_cpu/matched.mlir new file mode 100644 index 000000000000..0672a6ccbf54 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ctc_loss_cpu/matched.mlir @@ -0,0 +1,122 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0, d1, d2) -> (d1 - 1)> +#map3 = affine_map<(d0) -> (d0 - 1)> +#map4 = affine_map<(d0, d1, d2) -> (d2 - 1)> +#map5 = affine_map<(d0, d1, d2) -> (d2 - 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ctc_loss_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c-2_i32 = arith.constant -2 : i32 + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %c11 = arith.constant 11 : index + %c24 = arith.constant 24 : index + %c0 = arith.constant 0 : index + %c4 = arith.constant 4 : index + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = arith.index_cast %arg2 : i32 to index + %extracted_slice = tensor.extract_slice %3[0, 0, 0] [%c4, %c24, %c11] [1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %3[0, 0, 0] [%c4, %c24, %c11] [1, 1, 1] : tensor into tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, %4] [1, %c4, 1] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %inserted_slice[0, 0, 0] [%c4, 1, 1] [1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = math.exp %in : f32 + linalg.yield %12 : f32 + } -> tensor + %inserted_slice_2 = tensor.insert_slice %6 into %inserted_slice[0, 0, 0] [%c4, 1, 1] [1, 1, 1] : tensor into tensor + %7 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %inserted_slice_2) -> (tensor) { + %extracted = tensor.extract %1[%arg5, %c0] : tensor + %12 = arith.index_cast %extracted : i32 to index + %extracted_7 = tensor.extract %0[%c0, %arg5, %12] : tensor + %13 = math.exp %extracted_7 : f32 + %inserted = tensor.insert %13 into %arg6[%arg5, %c0, %c1] : tensor + affine.yield %inserted : tensor + } + %8 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %7) -> (tensor) { + %12 = affine.for %arg7 = 1 to 24 iter_args(%arg8 = %arg6) -> (tensor) { + %13 = affine.for %arg9 = 0 to 11 iter_args(%arg10 = %arg8) -> (tensor) { + %14 = arith.index_cast %arg9 : index to i32 + %15 = arith.andi %14, %c1_i32 : i32 + %16 = arith.cmpi ne, %15, %c0_i32 : i32 + %17 = arith.cmpi slt, %arg9, %c0 : index + %18 = arith.subi %c-1, %arg9 : index + %19 = arith.select %17, %18, %arg9 : index + %20 = arith.divsi %19, %c2 : index + %21 = arith.subi %c-1, %20 : index + %22 = arith.select %17, %21, %20 : index + %extracted = tensor.extract %1[%arg5, %22] : tensor + %23 = arith.select %16, %extracted, %arg2 : i32 + %24 = affine.apply #map2(%arg5, %arg7, %arg9) + %extracted_7 = tensor.extract %arg10[%arg5, %24, %arg9] : tensor + %25 = affine.apply #map3(%arg9) + %26 = arith.cmpi sge, %25, %c0 : index + %27 = affine.apply #map2(%arg5, %arg7, %arg9) + %28 = affine.apply #map4(%arg5, %arg7, %arg9) + %extracted_8 = tensor.extract %arg10[%arg5, %27, %28] : tensor + %29 = arith.addf %extracted_7, %extracted_8 : f32 + %30 = arith.select %26, %29, %extracted_7 : f32 + %31 = arith.cmpi sgt, %14, %c1_i32 : i32 + %32 = arith.cmpi ne, %23, %arg2 : i32 + %33 = arith.andi %31, %32 : i1 + %34 = arith.addi %14, %c-2_i32 : i32 + %35 = arith.andi %34, %c1_i32 : i32 + %36 = arith.cmpi ne, %35, %c0_i32 : i32 + %37 = arith.cmpi slt, %arg9, %c0 : index + %38 = arith.subi %c-1, %arg9 : index + %39 = arith.select %37, %38, %arg9 : index + %40 = arith.divsi %39, %c2 : index + %41 = arith.subi %c-1, %40 : index + %42 = arith.select %37, %41, %40 : index + %43 = arith.addi %42, %c-1 : index + %extracted_9 = tensor.extract %1[%arg5, %43] : tensor + %44 = arith.select %36, %extracted_9, %arg2 : i32 + %45 = arith.cmpi ne, %23, %44 : i32 + %46 = affine.apply #map2(%arg5, %arg7, %arg9) + %47 = affine.apply #map5(%arg5, %arg7, %arg9) + %extracted_10 = tensor.extract %arg10[%arg5, %46, %47] : tensor + %48 = arith.addf %30, %extracted_10 : f32 + %49 = arith.select %45, %48, %30 : f32 + %50 = arith.select %33, %49, %30 : f32 + %51 = arith.index_cast %23 : i32 to index + %extracted_11 = tensor.extract %0[%arg7, %arg5, %51] : tensor + %52 = math.exp %extracted_11 : f32 + %53 = arith.mulf %50, %52 : f32 + %inserted = tensor.insert %53 into %arg10[%arg5, %arg7, %arg9] : tensor + affine.yield %inserted : tensor + } + affine.yield %13 : tensor + } + affine.yield %12 : tensor + } + %9 = bufferization.to_memref %8 : memref + memref.copy %9, %arg4 : memref to memref + %extracted_slice_3 = tensor.extract_slice %8[0, 23, 10] [%c4, 1, 1] [1, 1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %8[0, 23, 9] [%c4, 1, 1] [1, 1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %2[0] [%c4] [1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3, %extracted_slice_4 : tensor, tensor) outs(%extracted_slice_5 : tensor) { + ^bb0(%in: f32, %in_7: f32, %out: f32): + %12 = arith.addf %in, %in_7 : f32 + %13 = math.log %12 : f32 + %14 = arith.negf %13 : f32 + linalg.yield %14 : f32 + } -> tensor + %inserted_slice_6 = tensor.insert_slice %10 into %2[0] [%c4] [1] : tensor into tensor + %11 = bufferization.to_memref %inserted_slice_6 : memref + memref.copy %11, %arg3 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_ctc_loss_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_ctc_loss_cpu/orig.mlir new file mode 100644 index 000000000000..3f858fece0d7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ctc_loss_cpu/orig.mlir @@ -0,0 +1,100 @@ +#set = affine_set<(d0) : (d0 - 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ctc_loss_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c-2_i32 = arith.constant -2 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.index_cast %arg2 : i32 to index + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 24 { + affine.for %arg7 = 0 to 11 { + affine.store %cst, %arg4[%arg5, %arg6, %arg7] : memref + } + } + %1 = affine.load %arg0[0, %arg5, symbol(%0)] : memref + %2 = math.exp %1 : f32 + affine.store %2, %arg4[%arg5, 0, 0] : memref + %3 = affine.load %arg1[%arg5, 0] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg0[%c0, %arg5, %4] : memref + %6 = math.exp %5 : f32 + affine.store %6, %arg4[%arg5, 0, 1] : memref + affine.for %arg6 = 1 to 24 { + affine.for %arg7 = 0 to 11 { + %12 = arith.index_cast %arg7 : index to i32 + %13 = arith.andi %12, %c1_i32 : i32 + %14 = arith.cmpi ne, %13, %c0_i32 : i32 + %15 = scf.if %14 -> (i32) { + %26 = arith.cmpi slt, %arg7, %c0 : index + %27 = arith.subi %c-1, %arg7 : index + %28 = arith.select %26, %27, %arg7 : index + %29 = arith.divsi %28, %c2 : index + %30 = arith.subi %c-1, %29 : index + %31 = arith.select %26, %30, %29 : index + %32 = memref.load %arg1[%arg5, %31] : memref + scf.yield %32 : i32 + } else { + scf.yield %arg2 : i32 + } + %16 = affine.load %arg4[%arg5, %arg6 - 1, %arg7] : memref + %17 = affine.if #set(%arg7) -> f32 { + %26 = affine.load %arg4[%arg5, %arg6 - 1, %arg7 - 1] : memref + %27 = arith.addf %16, %26 : f32 + affine.yield %27 : f32 + } else { + affine.yield %16 : f32 + } + %18 = arith.cmpi sgt, %12, %c1_i32 : i32 + %19 = arith.cmpi ne, %15, %arg2 : i32 + %20 = arith.andi %18, %19 : i1 + %21 = scf.if %20 -> (f32) { + %26 = arith.addi %12, %c-2_i32 : i32 + %27 = arith.andi %26, %c1_i32 : i32 + %28 = arith.cmpi ne, %27, %c0_i32 : i32 + %29 = scf.if %28 -> (i32) { + %32 = arith.cmpi slt, %arg7, %c0 : index + %33 = arith.subi %c-1, %arg7 : index + %34 = arith.select %32, %33, %arg7 : index + %35 = arith.divsi %34, %c2 : index + %36 = arith.subi %c-1, %35 : index + %37 = arith.select %32, %36, %35 : index + %38 = arith.addi %37, %c-1 : index + %39 = memref.load %arg1[%arg5, %38] : memref + scf.yield %39 : i32 + } else { + scf.yield %arg2 : i32 + } + %30 = arith.cmpi ne, %15, %29 : i32 + %31 = scf.if %30 -> (f32) { + %32 = affine.load %arg4[%arg5, %arg6 - 1, %arg7 - 2] : memref + %33 = arith.addf %17, %32 : f32 + scf.yield %33 : f32 + } else { + scf.yield %17 : f32 + } + scf.yield %31 : f32 + } else { + scf.yield %17 : f32 + } + %22 = arith.index_cast %15 : i32 to index + %23 = memref.load %arg0[%arg6, %arg5, %22] : memref + %24 = math.exp %23 : f32 + %25 = arith.mulf %21, %24 : f32 + affine.store %25, %arg4[%arg5, %arg6, %arg7] : memref + } + } + %7 = affine.load %arg4[%arg5, 23, 10] : memref + %8 = affine.load %arg4[%arg5, 23, 9] : memref + %9 = arith.addf %7, %8 : f32 + %10 = func.call @logf(%9) : (f32) -> f32 + %11 = arith.negf %10 : f32 + affine.store %11, %arg3[%arg5] : memref + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_ctc_loss_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_ctc_loss_cpu/raised.mlir new file mode 100644 index 000000000000..f4c332600c34 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ctc_loss_cpu/raised.mlir @@ -0,0 +1,98 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0) -> (d0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ctc_loss_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c0 = arith.constant 0 : index + %c24 = arith.constant 24 : index + %c11 = arith.constant 11 : index + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c-2_i32 = arith.constant -2 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.index_cast %arg2 : i32 to index + %subview = memref.subview %arg4[0, 0, 0] [%c4, %c24, %c11] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, %0] [1, %c4, 1] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg4[0, 0, 0] [%c4, 1, 1] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%subview_0 : memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = math.exp %in : f32 + linalg.yield %1 : f32 + } + affine.for %arg5 = 0 to 4 { + %1 = affine.load %arg1[%arg5, 0] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%c0, %arg5, %2] : memref + %4 = math.exp %3 : f32 + affine.store %4, %arg4[%arg5, 0, 1] : memref + } + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 1 to 24 { + affine.for %arg7 = 0 to 11 { + %1 = arith.index_cast %arg7 : index to i32 + %2 = arith.andi %1, %c1_i32 : i32 + %3 = arith.cmpi ne, %2, %c0_i32 : i32 + %4 = arith.cmpi slt, %arg7, %c0 : index + %5 = arith.subi %c-1, %arg7 : index + %6 = arith.select %4, %5, %arg7 : index + %7 = arith.divsi %6, %c2 : index + %8 = arith.subi %c-1, %7 : index + %9 = arith.select %4, %8, %7 : index + %10 = memref.load %arg1[%arg5, %9] : memref + %11 = arith.select %3, %10, %arg2 : i32 + %12 = affine.load %arg4[%arg5, %arg6 - 1, %arg7] : memref + %13 = affine.apply #map2(%arg7) + %14 = arith.cmpi sge, %13, %c0 : index + %15 = affine.load %arg4[%arg5, %arg6 - 1, %arg7 - 1] : memref + %16 = arith.addf %12, %15 : f32 + %17 = arith.select %14, %16, %12 : f32 + %18 = arith.cmpi sgt, %1, %c1_i32 : i32 + %19 = arith.cmpi ne, %11, %arg2 : i32 + %20 = arith.andi %18, %19 : i1 + %21 = arith.addi %1, %c-2_i32 : i32 + %22 = arith.andi %21, %c1_i32 : i32 + %23 = arith.cmpi ne, %22, %c0_i32 : i32 + %24 = arith.cmpi slt, %arg7, %c0 : index + %25 = arith.subi %c-1, %arg7 : index + %26 = arith.select %24, %25, %arg7 : index + %27 = arith.divsi %26, %c2 : index + %28 = arith.subi %c-1, %27 : index + %29 = arith.select %24, %28, %27 : index + %30 = arith.addi %29, %c-1 : index + %31 = memref.load %arg1[%arg5, %30] : memref + %32 = arith.select %23, %31, %arg2 : i32 + %33 = arith.cmpi ne, %11, %32 : i32 + %34 = affine.load %arg4[%arg5, %arg6 - 1, %arg7 - 2] : memref + %35 = arith.addf %17, %34 : f32 + %36 = arith.select %33, %35, %17 : f32 + %37 = arith.select %20, %36, %17 : f32 + %38 = arith.index_cast %11 : i32 to index + %39 = memref.load %arg0[%arg6, %arg5, %38] : memref + %40 = math.exp %39 : f32 + %41 = arith.mulf %37, %40 : f32 + affine.store %41, %arg4[%arg5, %arg6, %arg7] : memref + } + } + } + %subview_2 = memref.subview %arg4[0, 23, 10] [%c4, 1, 1] [1, 1, 1] : memref to memref> + %subview_3 = memref.subview %arg4[0, 23, 9] [%c4, 1, 1] [1, 1, 1] : memref to memref> + %subview_4 = memref.subview %arg3[0] [%c4] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"]} ins(%subview_2, %subview_3 : memref>, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %1 = arith.addf %in, %in_5 : f32 + %2 = math.log %1 : f32 + %3 = arith.negf %2 : f32 + linalg.yield %3 : f32 + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_ctc_loss_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_ctc_loss_cpu_debuf.mlir new file mode 100644 index 000000000000..0672a6ccbf54 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ctc_loss_cpu_debuf.mlir @@ -0,0 +1,122 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0, d1, d2) -> (d1 - 1)> +#map3 = affine_map<(d0) -> (d0 - 1)> +#map4 = affine_map<(d0, d1, d2) -> (d2 - 1)> +#map5 = affine_map<(d0, d1, d2) -> (d2 - 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ctc_loss_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c-2_i32 = arith.constant -2 : i32 + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %c11 = arith.constant 11 : index + %c24 = arith.constant 24 : index + %c0 = arith.constant 0 : index + %c4 = arith.constant 4 : index + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = arith.index_cast %arg2 : i32 to index + %extracted_slice = tensor.extract_slice %3[0, 0, 0] [%c4, %c24, %c11] [1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %3[0, 0, 0] [%c4, %c24, %c11] [1, 1, 1] : tensor into tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, %4] [1, %c4, 1] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %inserted_slice[0, 0, 0] [%c4, 1, 1] [1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = math.exp %in : f32 + linalg.yield %12 : f32 + } -> tensor + %inserted_slice_2 = tensor.insert_slice %6 into %inserted_slice[0, 0, 0] [%c4, 1, 1] [1, 1, 1] : tensor into tensor + %7 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %inserted_slice_2) -> (tensor) { + %extracted = tensor.extract %1[%arg5, %c0] : tensor + %12 = arith.index_cast %extracted : i32 to index + %extracted_7 = tensor.extract %0[%c0, %arg5, %12] : tensor + %13 = math.exp %extracted_7 : f32 + %inserted = tensor.insert %13 into %arg6[%arg5, %c0, %c1] : tensor + affine.yield %inserted : tensor + } + %8 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %7) -> (tensor) { + %12 = affine.for %arg7 = 1 to 24 iter_args(%arg8 = %arg6) -> (tensor) { + %13 = affine.for %arg9 = 0 to 11 iter_args(%arg10 = %arg8) -> (tensor) { + %14 = arith.index_cast %arg9 : index to i32 + %15 = arith.andi %14, %c1_i32 : i32 + %16 = arith.cmpi ne, %15, %c0_i32 : i32 + %17 = arith.cmpi slt, %arg9, %c0 : index + %18 = arith.subi %c-1, %arg9 : index + %19 = arith.select %17, %18, %arg9 : index + %20 = arith.divsi %19, %c2 : index + %21 = arith.subi %c-1, %20 : index + %22 = arith.select %17, %21, %20 : index + %extracted = tensor.extract %1[%arg5, %22] : tensor + %23 = arith.select %16, %extracted, %arg2 : i32 + %24 = affine.apply #map2(%arg5, %arg7, %arg9) + %extracted_7 = tensor.extract %arg10[%arg5, %24, %arg9] : tensor + %25 = affine.apply #map3(%arg9) + %26 = arith.cmpi sge, %25, %c0 : index + %27 = affine.apply #map2(%arg5, %arg7, %arg9) + %28 = affine.apply #map4(%arg5, %arg7, %arg9) + %extracted_8 = tensor.extract %arg10[%arg5, %27, %28] : tensor + %29 = arith.addf %extracted_7, %extracted_8 : f32 + %30 = arith.select %26, %29, %extracted_7 : f32 + %31 = arith.cmpi sgt, %14, %c1_i32 : i32 + %32 = arith.cmpi ne, %23, %arg2 : i32 + %33 = arith.andi %31, %32 : i1 + %34 = arith.addi %14, %c-2_i32 : i32 + %35 = arith.andi %34, %c1_i32 : i32 + %36 = arith.cmpi ne, %35, %c0_i32 : i32 + %37 = arith.cmpi slt, %arg9, %c0 : index + %38 = arith.subi %c-1, %arg9 : index + %39 = arith.select %37, %38, %arg9 : index + %40 = arith.divsi %39, %c2 : index + %41 = arith.subi %c-1, %40 : index + %42 = arith.select %37, %41, %40 : index + %43 = arith.addi %42, %c-1 : index + %extracted_9 = tensor.extract %1[%arg5, %43] : tensor + %44 = arith.select %36, %extracted_9, %arg2 : i32 + %45 = arith.cmpi ne, %23, %44 : i32 + %46 = affine.apply #map2(%arg5, %arg7, %arg9) + %47 = affine.apply #map5(%arg5, %arg7, %arg9) + %extracted_10 = tensor.extract %arg10[%arg5, %46, %47] : tensor + %48 = arith.addf %30, %extracted_10 : f32 + %49 = arith.select %45, %48, %30 : f32 + %50 = arith.select %33, %49, %30 : f32 + %51 = arith.index_cast %23 : i32 to index + %extracted_11 = tensor.extract %0[%arg7, %arg5, %51] : tensor + %52 = math.exp %extracted_11 : f32 + %53 = arith.mulf %50, %52 : f32 + %inserted = tensor.insert %53 into %arg10[%arg5, %arg7, %arg9] : tensor + affine.yield %inserted : tensor + } + affine.yield %13 : tensor + } + affine.yield %12 : tensor + } + %9 = bufferization.to_memref %8 : memref + memref.copy %9, %arg4 : memref to memref + %extracted_slice_3 = tensor.extract_slice %8[0, 23, 10] [%c4, 1, 1] [1, 1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %8[0, 23, 9] [%c4, 1, 1] [1, 1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %2[0] [%c4] [1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3, %extracted_slice_4 : tensor, tensor) outs(%extracted_slice_5 : tensor) { + ^bb0(%in: f32, %in_7: f32, %out: f32): + %12 = arith.addf %in, %in_7 : f32 + %13 = math.log %12 : f32 + %14 = arith.negf %13 : f32 + linalg.yield %14 : f32 + } -> tensor + %inserted_slice_6 = tensor.insert_slice %10 into %2[0] [%c4] [1] : tensor into tensor + %11 = bufferization.to_memref %inserted_slice_6 : memref + memref.copy %11, %arg3 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_ctc_loss_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_ctc_loss_cpu_linalg.mlir new file mode 100644 index 000000000000..f4c332600c34 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ctc_loss_cpu_linalg.mlir @@ -0,0 +1,98 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0) -> (d0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ctc_loss_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c0 = arith.constant 0 : index + %c24 = arith.constant 24 : index + %c11 = arith.constant 11 : index + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c-2_i32 = arith.constant -2 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.index_cast %arg2 : i32 to index + %subview = memref.subview %arg4[0, 0, 0] [%c4, %c24, %c11] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, %0] [1, %c4, 1] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg4[0, 0, 0] [%c4, 1, 1] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%subview_0 : memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = math.exp %in : f32 + linalg.yield %1 : f32 + } + affine.for %arg5 = 0 to 4 { + %1 = affine.load %arg1[%arg5, 0] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%c0, %arg5, %2] : memref + %4 = math.exp %3 : f32 + affine.store %4, %arg4[%arg5, 0, 1] : memref + } + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 1 to 24 { + affine.for %arg7 = 0 to 11 { + %1 = arith.index_cast %arg7 : index to i32 + %2 = arith.andi %1, %c1_i32 : i32 + %3 = arith.cmpi ne, %2, %c0_i32 : i32 + %4 = arith.cmpi slt, %arg7, %c0 : index + %5 = arith.subi %c-1, %arg7 : index + %6 = arith.select %4, %5, %arg7 : index + %7 = arith.divsi %6, %c2 : index + %8 = arith.subi %c-1, %7 : index + %9 = arith.select %4, %8, %7 : index + %10 = memref.load %arg1[%arg5, %9] : memref + %11 = arith.select %3, %10, %arg2 : i32 + %12 = affine.load %arg4[%arg5, %arg6 - 1, %arg7] : memref + %13 = affine.apply #map2(%arg7) + %14 = arith.cmpi sge, %13, %c0 : index + %15 = affine.load %arg4[%arg5, %arg6 - 1, %arg7 - 1] : memref + %16 = arith.addf %12, %15 : f32 + %17 = arith.select %14, %16, %12 : f32 + %18 = arith.cmpi sgt, %1, %c1_i32 : i32 + %19 = arith.cmpi ne, %11, %arg2 : i32 + %20 = arith.andi %18, %19 : i1 + %21 = arith.addi %1, %c-2_i32 : i32 + %22 = arith.andi %21, %c1_i32 : i32 + %23 = arith.cmpi ne, %22, %c0_i32 : i32 + %24 = arith.cmpi slt, %arg7, %c0 : index + %25 = arith.subi %c-1, %arg7 : index + %26 = arith.select %24, %25, %arg7 : index + %27 = arith.divsi %26, %c2 : index + %28 = arith.subi %c-1, %27 : index + %29 = arith.select %24, %28, %27 : index + %30 = arith.addi %29, %c-1 : index + %31 = memref.load %arg1[%arg5, %30] : memref + %32 = arith.select %23, %31, %arg2 : i32 + %33 = arith.cmpi ne, %11, %32 : i32 + %34 = affine.load %arg4[%arg5, %arg6 - 1, %arg7 - 2] : memref + %35 = arith.addf %17, %34 : f32 + %36 = arith.select %33, %35, %17 : f32 + %37 = arith.select %20, %36, %17 : f32 + %38 = arith.index_cast %11 : i32 to index + %39 = memref.load %arg0[%arg6, %arg5, %38] : memref + %40 = math.exp %39 : f32 + %41 = arith.mulf %37, %40 : f32 + affine.store %41, %arg4[%arg5, %arg6, %arg7] : memref + } + } + } + %subview_2 = memref.subview %arg4[0, 23, 10] [%c4, 1, 1] [1, 1, 1] : memref to memref> + %subview_3 = memref.subview %arg4[0, 23, 9] [%c4, 1, 1] [1, 1, 1] : memref to memref> + %subview_4 = memref.subview %arg3[0] [%c4] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"]} ins(%subview_2, %subview_3 : memref>, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %1 = arith.addf %in, %in_5 : f32 + %2 = math.log %1 : f32 + %3 = arith.negf %2 : f32 + linalg.yield %3 : f32 + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_cummax_cummin_cpu.mlir b/issues/aten_c_kernels/results/aten_cummax_cummin_cpu.mlir new file mode 100644 index 000000000000..98da8462b03c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cummax_cummin_cpu.mlir @@ -0,0 +1,44 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cummax_cummin_cpu(%arg0: memref, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %false = arith.constant false + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg1, %c0_i32 : i32 + affine.for %arg4 = 0 to 16 { + %1 = affine.load %arg0[%arg4, 0] : memref + %2:2 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %c0_i32, %arg7 = %1) -> (i32, f32) { + %3 = arith.index_cast %arg5 : index to i32 + %4 = scf.if %0 -> (i1) { + %8 = affine.load %arg0[%arg4, %arg5] : memref + %9 = arith.cmpf oge, %8, %arg7 : f32 + scf.yield %9 : i1 + } else { + scf.yield %false : i1 + } + %5 = scf.if %4 -> (i1) { + scf.yield %true : i1 + } else { + %8 = scf.if %0 -> (i1) { + scf.yield %false : i1 + } else { + %9 = affine.load %arg0[%arg4, %arg5] : memref + %10 = arith.cmpf ole, %9, %arg7 : f32 + scf.yield %10 : i1 + } + scf.yield %8 : i1 + } + %6 = arith.select %5, %3, %arg6 : i32 + %7 = scf.if %5 -> (f32) { + %8 = affine.load %arg0[%arg4, %arg5] : memref + scf.yield %8 : f32 + } else { + scf.yield %arg7 : f32 + } + affine.store %7, %arg2[%arg4, %arg5] : memref + affine.store %6, %arg3[%arg4, %arg5] : memref + affine.yield %6, %7 : i32, f32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cummax_cummin_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_cummax_cummin_cpu/debuf.mlir new file mode 100644 index 000000000000..54743020cbdc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cummax_cummin_cpu/debuf.mlir @@ -0,0 +1,55 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cummax_cummin_cpu(%arg0: memref, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %false = arith.constant false + %true = arith.constant true + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.cmpi ne, %arg1, %c0_i32 : i32 + %4 = tensor.empty(%c16) : tensor + %5 = tensor.empty(%c16) : tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%4 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %5[0] [%c16] [1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %1[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %2[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %6[0] [%c16] [1] : tensor to tensor + %8:4 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1, #map1, #map1, #map2, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_1, %extracted_slice_2, %extracted_slice_3 : tensor, tensor, tensor) outs(%extracted_slice_4, %extracted_slice_5, %extracted_slice_6, %7 : tensor, tensor, tensor, tensor) { + ^bb0(%in: f32, %in_8: f32, %in_9: f32, %out: f32, %out_10: i32, %out_11: i32, %out_12: f32): + %11 = linalg.index 1 : index + %12 = arith.index_cast %11 : index to i32 + %13 = arith.cmpf oge, %in, %out_12 : f32 + %14 = arith.select %3, %13, %false : i1 + %15 = arith.cmpf ole, %in_8, %out_12 : f32 + %16 = arith.select %3, %false, %15 : i1 + %17 = arith.select %14, %true, %16 : i1 + %18 = arith.select %17, %12, %out_11 : i32 + %19 = arith.select %17, %in_9, %out_12 : f32 + linalg.yield %19, %18, %18, %19 : f32, i32, i32, f32 + } -> (tensor, tensor, tensor, tensor) + %inserted_slice = tensor.insert_slice %8#0 into %1[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %9 = bufferization.to_memref %inserted_slice : memref + memref.copy %9, %arg2 : memref to memref + %inserted_slice_7 = tensor.insert_slice %8#1 into %2[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %10 = bufferization.to_memref %inserted_slice_7 : memref + memref.copy %10, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cummax_cummin_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_cummax_cummin_cpu/matched.mlir new file mode 100644 index 000000000000..05e205e52e87 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cummax_cummin_cpu/matched.mlir @@ -0,0 +1,49 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cummax_cummin_cpu(%arg0: memref, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %false = arith.constant false + %true = arith.constant true + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.cmpi ne, %arg1, %c0_i32 : i32 + %4 = tensor.empty(%c16) : tensor + %5 = tensor.empty(%c16) : tensor + %6 = kernel.launch @memset_zero_1D(%4) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %5[0] [%c16] [1] : tensor to tensor + %7 = kernel.launch @cudaCopy1D_f32_tensor(%extracted_slice, %extracted_slice_0) : (tensor, tensor) -> tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %1[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %2[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %6[0] [%c16] [1] : tensor to tensor + %8:4 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1, #map1, #map1, #map2, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_1, %extracted_slice_2, %extracted_slice_3 : tensor, tensor, tensor) outs(%extracted_slice_4, %extracted_slice_5, %extracted_slice_6, %7 : tensor, tensor, tensor, tensor) { + ^bb0(%in: f32, %in_8: f32, %in_9: f32, %out: f32, %out_10: i32, %out_11: i32, %out_12: f32): + %11 = linalg.index 1 : index + %12 = arith.index_cast %11 : index to i32 + %13 = arith.cmpf oge, %in, %out_12 : f32 + %14 = arith.select %3, %13, %false : i1 + %15 = arith.cmpf ole, %in_8, %out_12 : f32 + %16 = arith.select %3, %false, %15 : i1 + %17 = arith.select %14, %true, %16 : i1 + %18 = arith.select %17, %12, %out_11 : i32 + %19 = arith.select %17, %in_9, %out_12 : f32 + linalg.yield %19, %18, %18, %19 : f32, i32, i32, f32 + } -> (tensor, tensor, tensor, tensor) + %inserted_slice = tensor.insert_slice %8#0 into %1[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %9 = bufferization.to_memref %inserted_slice : memref + memref.copy %9, %arg2 : memref to memref + %inserted_slice_7 = tensor.insert_slice %8#1 into %2[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %10 = bufferization.to_memref %inserted_slice_7 : memref + memref.copy %10, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cummax_cummin_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_cummax_cummin_cpu/orig.mlir new file mode 100644 index 000000000000..98da8462b03c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cummax_cummin_cpu/orig.mlir @@ -0,0 +1,44 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cummax_cummin_cpu(%arg0: memref, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %false = arith.constant false + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg1, %c0_i32 : i32 + affine.for %arg4 = 0 to 16 { + %1 = affine.load %arg0[%arg4, 0] : memref + %2:2 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %c0_i32, %arg7 = %1) -> (i32, f32) { + %3 = arith.index_cast %arg5 : index to i32 + %4 = scf.if %0 -> (i1) { + %8 = affine.load %arg0[%arg4, %arg5] : memref + %9 = arith.cmpf oge, %8, %arg7 : f32 + scf.yield %9 : i1 + } else { + scf.yield %false : i1 + } + %5 = scf.if %4 -> (i1) { + scf.yield %true : i1 + } else { + %8 = scf.if %0 -> (i1) { + scf.yield %false : i1 + } else { + %9 = affine.load %arg0[%arg4, %arg5] : memref + %10 = arith.cmpf ole, %9, %arg7 : f32 + scf.yield %10 : i1 + } + scf.yield %8 : i1 + } + %6 = arith.select %5, %3, %arg6 : i32 + %7 = scf.if %5 -> (f32) { + %8 = affine.load %arg0[%arg4, %arg5] : memref + scf.yield %8 : f32 + } else { + scf.yield %arg7 : f32 + } + affine.store %7, %arg2[%arg4, %arg5] : memref + affine.store %6, %arg3[%arg4, %arg5] : memref + affine.yield %6, %7 : i32, f32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cummax_cummin_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_cummax_cummin_cpu/raised.mlir new file mode 100644 index 000000000000..912cbc1407d6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cummax_cummin_cpu/raised.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cummax_cummin_cpu(%arg0: memref, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %true = arith.constant true + %false = arith.constant false + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg1, %c0_i32 : i32 + %alloca = memref.alloca(%c16) : memref + %alloca_0 = memref.alloca(%c16) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c16, 1] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca_0[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_2 = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_5 = memref.subview %arg2[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_6 = memref.subview %arg3[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_7 = memref.subview %alloca[0] [%c16] [1] : memref to memref> + %subview_8 = memref.subview %alloca_0[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1, #map1, #map2, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview_2, %subview_3, %subview_4 : memref>, memref>, memref>) outs(%subview_5, %subview_6, %subview_7, %subview_8 : memref>, memref>, memref>, memref>) { + ^bb0(%in: f32, %in_9: f32, %in_10: f32, %out: f32, %out_11: i32, %out_12: i32, %out_13: f32): + %1 = linalg.index 1 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.cmpf oge, %in, %out_13 : f32 + %4 = arith.select %0, %3, %false : i1 + %5 = arith.cmpf ole, %in_9, %out_13 : f32 + %6 = arith.select %0, %false, %5 : i1 + %7 = arith.select %4, %true, %6 : i1 + %8 = arith.select %7, %2, %out_12 : i32 + %9 = arith.select %7, %in_10, %out_13 : f32 + linalg.yield %9, %8, %8, %9 : f32, i32, i32, f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cummax_cummin_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_cummax_cummin_cpu_debuf.mlir new file mode 100644 index 000000000000..54743020cbdc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cummax_cummin_cpu_debuf.mlir @@ -0,0 +1,55 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cummax_cummin_cpu(%arg0: memref, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %false = arith.constant false + %true = arith.constant true + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.cmpi ne, %arg1, %c0_i32 : i32 + %4 = tensor.empty(%c16) : tensor + %5 = tensor.empty(%c16) : tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%4 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %5[0] [%c16] [1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %1[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %2[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %6[0] [%c16] [1] : tensor to tensor + %8:4 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1, #map1, #map1, #map2, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_1, %extracted_slice_2, %extracted_slice_3 : tensor, tensor, tensor) outs(%extracted_slice_4, %extracted_slice_5, %extracted_slice_6, %7 : tensor, tensor, tensor, tensor) { + ^bb0(%in: f32, %in_8: f32, %in_9: f32, %out: f32, %out_10: i32, %out_11: i32, %out_12: f32): + %11 = linalg.index 1 : index + %12 = arith.index_cast %11 : index to i32 + %13 = arith.cmpf oge, %in, %out_12 : f32 + %14 = arith.select %3, %13, %false : i1 + %15 = arith.cmpf ole, %in_8, %out_12 : f32 + %16 = arith.select %3, %false, %15 : i1 + %17 = arith.select %14, %true, %16 : i1 + %18 = arith.select %17, %12, %out_11 : i32 + %19 = arith.select %17, %in_9, %out_12 : f32 + linalg.yield %19, %18, %18, %19 : f32, i32, i32, f32 + } -> (tensor, tensor, tensor, tensor) + %inserted_slice = tensor.insert_slice %8#0 into %1[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %9 = bufferization.to_memref %inserted_slice : memref + memref.copy %9, %arg2 : memref to memref + %inserted_slice_7 = tensor.insert_slice %8#1 into %2[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %10 = bufferization.to_memref %inserted_slice_7 : memref + memref.copy %10, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cummax_cummin_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_cummax_cummin_cpu_linalg.mlir new file mode 100644 index 000000000000..912cbc1407d6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cummax_cummin_cpu_linalg.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cummax_cummin_cpu(%arg0: memref, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %true = arith.constant true + %false = arith.constant false + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg1, %c0_i32 : i32 + %alloca = memref.alloca(%c16) : memref + %alloca_0 = memref.alloca(%c16) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c16, 1] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca_0[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_2 = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_5 = memref.subview %arg2[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_6 = memref.subview %arg3[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_7 = memref.subview %alloca[0] [%c16] [1] : memref to memref> + %subview_8 = memref.subview %alloca_0[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1, #map1, #map2, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview_2, %subview_3, %subview_4 : memref>, memref>, memref>) outs(%subview_5, %subview_6, %subview_7, %subview_8 : memref>, memref>, memref>, memref>) { + ^bb0(%in: f32, %in_9: f32, %in_10: f32, %out: f32, %out_11: i32, %out_12: i32, %out_13: f32): + %1 = linalg.index 1 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.cmpf oge, %in, %out_13 : f32 + %4 = arith.select %0, %3, %false : i1 + %5 = arith.cmpf ole, %in_9, %out_13 : f32 + %6 = arith.select %0, %false, %5 : i1 + %7 = arith.select %4, %true, %6 : i1 + %8 = arith.select %7, %2, %out_12 : i32 + %9 = arith.select %7, %in_10, %out_13 : f32 + linalg.yield %9, %8, %8, %9 : f32, i32, i32, f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cumprod_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_cumprod_backward_cpu.mlir new file mode 100644 index 000000000000..c7c9ea6556ff --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumprod_backward_cpu.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumprod_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 128 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.for %arg5 = #map(%arg4) to 128 iter_args(%arg6 = %cst_0) -> (f32) { + %2 = affine.for %arg7 = 0 to #map1(%arg5) iter_args(%arg8 = %cst) -> (f32) { + %6 = arith.index_cast %arg7 : index to i32 + %7 = arith.cmpi ne, %6, %0 : i32 + %8 = scf.if %7 -> (f32) { + %9 = affine.load %arg0[%arg7] : memref + %10 = arith.mulf %arg8, %9 : f32 + scf.yield %10 : f32 + } else { + scf.yield %arg8 : f32 + } + affine.yield %8 : f32 + } + %3 = affine.load %arg2[%arg5] : memref + %4 = arith.mulf %3, %2 : f32 + %5 = arith.addf %arg6, %4 : f32 + affine.yield %5 : f32 + } + affine.store %1, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cumprod_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_cumprod_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..ecdafea644a3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumprod_backward_cpu/debuf.mlir @@ -0,0 +1,49 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumprod_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = affine.for %arg4 = 0 to 128 iter_args(%arg5 = %3) -> (tensor) { + %6 = arith.index_cast %arg4 : index to i32 + %7 = affine.for %arg6 = #map(%arg4) to 128 iter_args(%arg7 = %arg5) -> (tensor) { + %extracted = tensor.extract %arg7[%arg4] : tensor + %alloca = memref.alloca() : memref + %8 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst_0 into %8[] : tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%2 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = linalg.index 0 : index + %13 = arith.index_cast %12 : index to i32 + %14 = arith.cmpi ne, %13, %6 : i32 + %15 = arith.mulf %out, %in : f32 + %16 = arith.select %14, %15, %out : f32 + %17 = linalg.index 0 : index + %18 = affine.apply #map2(%arg6) + %19 = arith.cmpi slt, %17, %18 : index + %20 = arith.select %19, %16, %out : f32 + linalg.yield %20 : f32 + } -> tensor + %extracted_1 = tensor.extract %9[] : tensor + %extracted_2 = tensor.extract %1[%arg6] : tensor + %10 = arith.mulf %extracted_2, %extracted_1 : f32 + %11 = arith.addf %extracted, %10 : f32 + %inserted_3 = tensor.insert %11 into %arg7[%arg4] : tensor + affine.yield %inserted_3 : tensor + } + affine.yield %7 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cumprod_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_cumprod_backward_cpu/matched.mlir new file mode 100644 index 000000000000..17f8b52145d1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumprod_backward_cpu/matched.mlir @@ -0,0 +1,46 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumprod_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %4 = affine.for %arg4 = 0 to 128 iter_args(%arg5 = %3) -> (tensor) { + %6 = arith.index_cast %arg4 : index to i32 + %7 = affine.for %arg6 = #map(%arg4) to 128 iter_args(%arg7 = %arg5) -> (tensor) { + %extracted = tensor.extract %arg7[%arg4] : tensor + %alloca = memref.alloca() : memref + %8 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst_0 into %8[] : tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%2 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = linalg.index 0 : index + %13 = arith.index_cast %12 : index to i32 + %14 = arith.cmpi ne, %13, %6 : i32 + %15 = arith.mulf %out, %in : f32 + %16 = arith.select %14, %15, %out : f32 + %17 = linalg.index 0 : index + %18 = affine.apply #map2(%arg6) + %19 = arith.cmpi slt, %17, %18 : index + %20 = arith.select %19, %16, %out : f32 + linalg.yield %20 : f32 + } -> tensor + %extracted_1 = tensor.extract %9[] : tensor + %extracted_2 = tensor.extract %1[%arg6] : tensor + %10 = arith.mulf %extracted_2, %extracted_1 : f32 + %11 = arith.addf %extracted, %10 : f32 + %inserted_3 = tensor.insert %11 into %arg7[%arg4] : tensor + affine.yield %inserted_3 : tensor + } + affine.yield %7 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cumprod_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_cumprod_backward_cpu/orig.mlir new file mode 100644 index 000000000000..c7c9ea6556ff --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumprod_backward_cpu/orig.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumprod_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 128 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.for %arg5 = #map(%arg4) to 128 iter_args(%arg6 = %cst_0) -> (f32) { + %2 = affine.for %arg7 = 0 to #map1(%arg5) iter_args(%arg8 = %cst) -> (f32) { + %6 = arith.index_cast %arg7 : index to i32 + %7 = arith.cmpi ne, %6, %0 : i32 + %8 = scf.if %7 -> (f32) { + %9 = affine.load %arg0[%arg7] : memref + %10 = arith.mulf %arg8, %9 : f32 + scf.yield %10 : f32 + } else { + scf.yield %arg8 : f32 + } + affine.yield %8 : f32 + } + %3 = affine.load %arg2[%arg5] : memref + %4 = arith.mulf %3, %2 : f32 + %5 = arith.addf %arg6, %4 : f32 + affine.yield %5 : f32 + } + affine.store %1, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cumprod_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_cumprod_backward_cpu/raised.mlir new file mode 100644 index 000000000000..74a2c380ce30 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumprod_backward_cpu/raised.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumprod_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg3 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + affine.for %arg4 = 0 to 128 { + %0 = arith.index_cast %arg4 : index to i32 + affine.for %arg5 = #map(%arg4) to 128 { + %1 = affine.load %arg3[%arg4] : memref + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %6 = linalg.index 0 : index + %7 = arith.index_cast %6 : index to i32 + %8 = arith.cmpi ne, %7, %0 : i32 + %9 = arith.mulf %out, %in : f32 + %10 = arith.select %8, %9, %out : f32 + %11 = linalg.index 0 : index + %12 = affine.apply #map2(%arg5) + %13 = arith.cmpi slt, %11, %12 : index + %14 = arith.select %13, %10, %out : f32 + linalg.yield %14 : f32 + } + %2 = affine.load %alloca[] : memref + %3 = affine.load %arg2[%arg5] : memref + %4 = arith.mulf %3, %2 : f32 + %5 = arith.addf %1, %4 : f32 + affine.store %5, %arg3[%arg4] : memref + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cumprod_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_cumprod_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..ecdafea644a3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumprod_backward_cpu_debuf.mlir @@ -0,0 +1,49 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumprod_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = affine.for %arg4 = 0 to 128 iter_args(%arg5 = %3) -> (tensor) { + %6 = arith.index_cast %arg4 : index to i32 + %7 = affine.for %arg6 = #map(%arg4) to 128 iter_args(%arg7 = %arg5) -> (tensor) { + %extracted = tensor.extract %arg7[%arg4] : tensor + %alloca = memref.alloca() : memref + %8 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst_0 into %8[] : tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%2 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = linalg.index 0 : index + %13 = arith.index_cast %12 : index to i32 + %14 = arith.cmpi ne, %13, %6 : i32 + %15 = arith.mulf %out, %in : f32 + %16 = arith.select %14, %15, %out : f32 + %17 = linalg.index 0 : index + %18 = affine.apply #map2(%arg6) + %19 = arith.cmpi slt, %17, %18 : index + %20 = arith.select %19, %16, %out : f32 + linalg.yield %20 : f32 + } -> tensor + %extracted_1 = tensor.extract %9[] : tensor + %extracted_2 = tensor.extract %1[%arg6] : tensor + %10 = arith.mulf %extracted_2, %extracted_1 : f32 + %11 = arith.addf %extracted, %10 : f32 + %inserted_3 = tensor.insert %11 into %arg7[%arg4] : tensor + affine.yield %inserted_3 : tensor + } + affine.yield %7 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cumprod_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_cumprod_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..74a2c380ce30 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumprod_backward_cpu_linalg.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumprod_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg3 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + affine.for %arg4 = 0 to 128 { + %0 = arith.index_cast %arg4 : index to i32 + affine.for %arg5 = #map(%arg4) to 128 { + %1 = affine.load %arg3[%arg4] : memref + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %6 = linalg.index 0 : index + %7 = arith.index_cast %6 : index to i32 + %8 = arith.cmpi ne, %7, %0 : i32 + %9 = arith.mulf %out, %in : f32 + %10 = arith.select %8, %9, %out : f32 + %11 = linalg.index 0 : index + %12 = affine.apply #map2(%arg5) + %13 = arith.cmpi slt, %11, %12 : index + %14 = arith.select %13, %10, %out : f32 + linalg.yield %14 : f32 + } + %2 = affine.load %alloca[] : memref + %3 = affine.load %arg2[%arg5] : memref + %4 = arith.mulf %3, %2 : f32 + %5 = arith.addf %1, %4 : f32 + affine.store %5, %arg3[%arg4] : memref + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cumprod_cpu.mlir b/issues/aten_c_kernels/results/aten_cumprod_cpu.mlir new file mode 100644 index 000000000000..22292eda6323 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumprod_cpu.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumprod_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 32 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2, %arg3] : memref + %2 = arith.mulf %arg4, %1 : f32 + affine.store %2, %arg1[%arg2, %arg3] : memref + affine.yield %2 : f32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cumprod_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_cumprod_cpu/debuf.mlir new file mode 100644 index 000000000000..83e9b55672c3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumprod_cpu/debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumprod_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %4:2 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_2: f32): + %6 = arith.mulf %out_2, %in : f32 + linalg.yield %6, %6 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %4#0 into %1[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cumprod_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_cumprod_cpu/matched.mlir new file mode 100644 index 000000000000..83e9b55672c3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumprod_cpu/matched.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumprod_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %4:2 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_2: f32): + %6 = arith.mulf %out_2, %in : f32 + linalg.yield %6, %6 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %4#0 into %1[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cumprod_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_cumprod_cpu/orig.mlir new file mode 100644 index 000000000000..22292eda6323 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumprod_cpu/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumprod_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 32 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2, %arg3] : memref + %2 = arith.mulf %arg4, %1 : f32 + affine.store %2, %arg1[%arg2, %arg3] : memref + affine.yield %2 : f32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cumprod_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_cumprod_cpu/raised.mlir new file mode 100644 index 000000000000..bb71cba8e8ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumprod_cpu/raised.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumprod_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 1.000000e+00 : f32 + %alloca = memref.alloca(%c32) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0, %subview_1 : memref>, memref>) { + ^bb0(%in: f32, %out: f32, %out_2: f32): + %0 = arith.mulf %out_2, %in : f32 + linalg.yield %0, %0 : f32, f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cumprod_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_cumprod_cpu_debuf.mlir new file mode 100644 index 000000000000..83e9b55672c3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumprod_cpu_debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumprod_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %4:2 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_2: f32): + %6 = arith.mulf %out_2, %in : f32 + linalg.yield %6, %6 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %4#0 into %1[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cumprod_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_cumprod_cpu_linalg.mlir new file mode 100644 index 000000000000..bb71cba8e8ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumprod_cpu_linalg.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumprod_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 1.000000e+00 : f32 + %alloca = memref.alloca(%c32) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0, %subview_1 : memref>, memref>) { + ^bb0(%in: f32, %out: f32, %out_2: f32): + %0 = arith.mulf %out_2, %in : f32 + linalg.yield %0, %0 : f32, f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cumsum.mlir b/issues/aten_c_kernels/results/aten_cumsum.mlir new file mode 100644 index 000000000000..3544b11a79e6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumsum.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumsum(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = affine.load %alloca[] : memref + %2 = arith.addf %1, %0 : f32 + affine.store %2, %alloca[] : memref + affine.store %2, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cumsum/debuf.mlir b/issues/aten_c_kernels/results/aten_cumsum/debuf.mlir new file mode 100644 index 000000000000..8acdd5946c9e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumsum/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumsum(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c256 = arith.constant 256 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %2[] : tensor + %extracted_slice = tensor.extract_slice %0[0] [%c256] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c256] [1] : tensor to tensor + %3:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted, %extracted_slice_0 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_1: f32): + %5 = arith.addf %out, %in : f32 + linalg.yield %5, %5 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %3#1 into %1[0] [%c256] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cumsum/matched.mlir b/issues/aten_c_kernels/results/aten_cumsum/matched.mlir new file mode 100644 index 000000000000..8acdd5946c9e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumsum/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumsum(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c256 = arith.constant 256 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %2[] : tensor + %extracted_slice = tensor.extract_slice %0[0] [%c256] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c256] [1] : tensor to tensor + %3:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted, %extracted_slice_0 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_1: f32): + %5 = arith.addf %out, %in : f32 + linalg.yield %5, %5 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %3#1 into %1[0] [%c256] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cumsum/orig.mlir b/issues/aten_c_kernels/results/aten_cumsum/orig.mlir new file mode 100644 index 000000000000..3544b11a79e6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumsum/orig.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumsum(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = affine.load %alloca[] : memref + %2 = arith.addf %1, %0 : f32 + affine.store %2, %alloca[] : memref + affine.store %2, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_cumsum/raised.mlir b/issues/aten_c_kernels/results/aten_cumsum/raised.mlir new file mode 100644 index 000000000000..ced5bbc92734 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumsum/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumsum(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[0] [%c256] [1] : memref to memref> + %subview_0 = memref.subview %alloca[] [] [] : memref to memref> + %subview_1 = memref.subview %arg1[0] [%c256] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_0, %subview_1 : memref>, memref>) { + ^bb0(%in: f32, %out: f32, %out_2: f32): + %0 = arith.addf %out, %in : f32 + linalg.yield %0, %0 : f32, f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cumsum_debuf.mlir b/issues/aten_c_kernels/results/aten_cumsum_debuf.mlir new file mode 100644 index 000000000000..8acdd5946c9e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumsum_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumsum(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c256 = arith.constant 256 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %2[] : tensor + %extracted_slice = tensor.extract_slice %0[0] [%c256] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c256] [1] : tensor to tensor + %3:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted, %extracted_slice_0 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_1: f32): + %5 = arith.addf %out, %in : f32 + linalg.yield %5, %5 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %3#1 into %1[0] [%c256] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_cumsum_linalg.mlir b/issues/aten_c_kernels/results/aten_cumsum_linalg.mlir new file mode 100644 index 000000000000..ced5bbc92734 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_cumsum_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_cumsum(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[0] [%c256] [1] : memref to memref> + %subview_0 = memref.subview %alloca[] [] [] : memref to memref> + %subview_1 = memref.subview %arg1[0] [%c256] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_0, %subview_1 : memref>, memref>) { + ^bb0(%in: f32, %out: f32, %out_2: f32): + %0 = arith.addf %out, %in : f32 + linalg.yield %0, %0 : f32, f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu.mlir b/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu.mlir new file mode 100644 index 000000000000..ffb6b0c1aa77 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dense_sparse_add_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg5 = 0 to 64 { + affine.for %arg6 = 0 to 64 { + %0 = affine.load %arg0[%arg5, %arg6] : memref + affine.store %0, %arg4[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 0 to 512 { + %0 = affine.load %arg1[%arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg5] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = affine.load %arg3[%arg5] : memref + %5 = memref.load %arg4[%1, %3] : memref + %6 = arith.addf %5, %4 : f32 + memref.store %6, %arg4[%1, %3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu/debuf.mlir new file mode 100644 index 000000000000..893d771ac1b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu/debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dense_sparse_add_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg4 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %4[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %4[0, 0] [%c64, %c64] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %extracted = tensor.extract %1[%arg5] : tensor + %8 = arith.index_cast %extracted : i32 to index + %extracted_1 = tensor.extract %2[%arg5] : tensor + %9 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %3[%arg5] : tensor + %extracted_3 = tensor.extract %arg6[%8, %9] : tensor + %10 = arith.addf %extracted_3, %extracted_2 : f32 + %inserted = tensor.insert %10 into %arg6[%8, %9] : tensor + affine.yield %inserted : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu/matched.mlir new file mode 100644 index 000000000000..3d38241aa02c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu/matched.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dense_sparse_add_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg4 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %4[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %5 = kernel.launch @cudaCopy2D_f32_tensor(%extracted_slice, %extracted_slice_0) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %5 into %4[0, 0] [%c64, %c64] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %extracted = tensor.extract %1[%arg5] : tensor + %8 = arith.index_cast %extracted : i32 to index + %extracted_1 = tensor.extract %2[%arg5] : tensor + %9 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %3[%arg5] : tensor + %extracted_3 = tensor.extract %arg6[%8, %9] : tensor + %10 = arith.addf %extracted_3, %extracted_2 : f32 + %inserted = tensor.insert %10 into %arg6[%8, %9] : tensor + affine.yield %inserted : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu/orig.mlir new file mode 100644 index 000000000000..ffb6b0c1aa77 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu/orig.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dense_sparse_add_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg5 = 0 to 64 { + affine.for %arg6 = 0 to 64 { + %0 = affine.load %arg0[%arg5, %arg6] : memref + affine.store %0, %arg4[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 0 to 512 { + %0 = affine.load %arg1[%arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg5] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = affine.load %arg3[%arg5] : memref + %5 = memref.load %arg4[%1, %3] : memref + %6 = arith.addf %5, %4 : f32 + memref.store %6, %arg4[%1, %3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu/raised.mlir new file mode 100644 index 000000000000..de5038c1afa7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu/raised.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dense_sparse_add_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 0] [%c64, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg4[0, 0] [%c64, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + affine.for %arg5 = 0 to 512 { + %0 = affine.load %arg1[%arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg5] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = affine.load %arg3[%arg5] : memref + %5 = memref.load %arg4[%1, %3] : memref + %6 = arith.addf %5, %4 : f32 + memref.store %6, %arg4[%1, %3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu_debuf.mlir new file mode 100644 index 000000000000..893d771ac1b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu_debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dense_sparse_add_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg4 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %4[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %4[0, 0] [%c64, %c64] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %extracted = tensor.extract %1[%arg5] : tensor + %8 = arith.index_cast %extracted : i32 to index + %extracted_1 = tensor.extract %2[%arg5] : tensor + %9 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %3[%arg5] : tensor + %extracted_3 = tensor.extract %arg6[%8, %9] : tensor + %10 = arith.addf %extracted_3, %extracted_2 : f32 + %inserted = tensor.insert %10 into %arg6[%8, %9] : tensor + affine.yield %inserted : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu_linalg.mlir new file mode 100644 index 000000000000..de5038c1afa7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dense_sparse_add_cpu_linalg.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dense_sparse_add_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 0] [%c64, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg4[0, 0] [%c64, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + affine.for %arg5 = 0 to 512 { + %0 = affine.load %arg1[%arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg5] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = affine.load %arg3[%arg5] : memref + %5 = memref.load %arg4[%1, %3] : memref + %6 = arith.addf %5, %4 : f32 + memref.store %6, %arg4[%1, %3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu.mlir b/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu.mlir new file mode 100644 index 000000000000..8526242fe0c4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu.mlir @@ -0,0 +1,29 @@ +#set = affine_set<(d0, d1, d2, d3) : (-d0 - d1 + 16 >= 0, d0 + d1 - 1 >= 0, d2 + d3 - 1 >= 0, -d2 - d3 + 16 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_depthwise_conv3x3_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 16 { + %0 = affine.load %arg2[%arg4] : memref + %1 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %0) -> (f32) { + %2 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %arg8) -> (f32) { + %3 = affine.if #set(%arg9, %arg6, %arg5, %arg7) -> f32 { + %4 = affine.load %arg0[0, %arg4, %arg5 + %arg7 - 1, %arg6 + %arg9 - 1] : memref + %5 = affine.load %arg1[%arg4, %arg7, %arg9] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.addf %arg10, %6 : f32 + affine.yield %7 : f32 + } else { + affine.yield %arg10 : f32 + } + affine.yield %3 : f32 + } + affine.yield %2 : f32 + } + affine.store %1, %arg3[0, %arg4, %arg5, %arg6] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu/debuf.mlir new file mode 100644 index 000000000000..a72076b39fce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu/debuf.mlir @@ -0,0 +1,57 @@ +#map = affine_map<(d0, d1, d2) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (0, d0, d3 + d1 - 1, d4 + d2 - 1)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +#map6 = affine_map<(d0, d1, d2, d3) -> (-d0 - d1 + 16)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0 + d1 - 1)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d2 + d3 - 1)> +#map9 = affine_map<(d0, d1, d2, d3) -> (-d2 - d3 + 16)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_depthwise_conv3x3_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c16 = arith.constant 16 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %2[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0, 0, 0, 0] [1, %c8, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submap(%0, %c8, %c16, %c16, %c3, %c3) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c8, %c3, %c3] [1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map3, #map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%5, %extracted_slice_1 : tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %8 = linalg.index 1 : index + %9 = linalg.index 2 : index + %10 = linalg.index 3 : index + %11 = linalg.index 4 : index + %12 = affine.apply #map6(%11, %9, %8, %10) + %13 = arith.cmpi sge, %12, %c0 : index + %14 = affine.apply #map7(%11, %9, %8, %10) + %15 = arith.cmpi sge, %14, %c0 : index + %16 = arith.andi %13, %15 : i1 + %17 = affine.apply #map8(%11, %9, %8, %10) + %18 = arith.cmpi sge, %17, %c0 : index + %19 = arith.andi %16, %18 : i1 + %20 = affine.apply #map9(%11, %9, %8, %10) + %21 = arith.cmpi sge, %20, %c0 : index + %22 = arith.andi %19, %21 : i1 + %23 = arith.mulf %in, %in_2 : f32 + %24 = arith.addf %out, %23 : f32 + %25 = arith.select %22, %24, %out : f32 + linalg.yield %25 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %3[0, 0, 0, 0] [1, %c8, %c16, %c16] [1, 1, 1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu/matched.mlir new file mode 100644 index 000000000000..a72076b39fce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu/matched.mlir @@ -0,0 +1,57 @@ +#map = affine_map<(d0, d1, d2) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (0, d0, d3 + d1 - 1, d4 + d2 - 1)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +#map6 = affine_map<(d0, d1, d2, d3) -> (-d0 - d1 + 16)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0 + d1 - 1)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d2 + d3 - 1)> +#map9 = affine_map<(d0, d1, d2, d3) -> (-d2 - d3 + 16)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_depthwise_conv3x3_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c16 = arith.constant 16 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %2[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0, 0, 0, 0] [1, %c8, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submap(%0, %c8, %c16, %c16, %c3, %c3) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c8, %c3, %c3] [1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map3, #map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%5, %extracted_slice_1 : tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %8 = linalg.index 1 : index + %9 = linalg.index 2 : index + %10 = linalg.index 3 : index + %11 = linalg.index 4 : index + %12 = affine.apply #map6(%11, %9, %8, %10) + %13 = arith.cmpi sge, %12, %c0 : index + %14 = affine.apply #map7(%11, %9, %8, %10) + %15 = arith.cmpi sge, %14, %c0 : index + %16 = arith.andi %13, %15 : i1 + %17 = affine.apply #map8(%11, %9, %8, %10) + %18 = arith.cmpi sge, %17, %c0 : index + %19 = arith.andi %16, %18 : i1 + %20 = affine.apply #map9(%11, %9, %8, %10) + %21 = arith.cmpi sge, %20, %c0 : index + %22 = arith.andi %19, %21 : i1 + %23 = arith.mulf %in, %in_2 : f32 + %24 = arith.addf %out, %23 : f32 + %25 = arith.select %22, %24, %out : f32 + linalg.yield %25 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %3[0, 0, 0, 0] [1, %c8, %c16, %c16] [1, 1, 1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu/orig.mlir new file mode 100644 index 000000000000..8526242fe0c4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu/orig.mlir @@ -0,0 +1,29 @@ +#set = affine_set<(d0, d1, d2, d3) : (-d0 - d1 + 16 >= 0, d0 + d1 - 1 >= 0, d2 + d3 - 1 >= 0, -d2 - d3 + 16 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_depthwise_conv3x3_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 16 { + %0 = affine.load %arg2[%arg4] : memref + %1 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %0) -> (f32) { + %2 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %arg8) -> (f32) { + %3 = affine.if #set(%arg9, %arg6, %arg5, %arg7) -> f32 { + %4 = affine.load %arg0[0, %arg4, %arg5 + %arg7 - 1, %arg6 + %arg9 - 1] : memref + %5 = affine.load %arg1[%arg4, %arg7, %arg9] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.addf %arg10, %6 : f32 + affine.yield %7 : f32 + } else { + affine.yield %arg10 : f32 + } + affine.yield %3 : f32 + } + affine.yield %2 : f32 + } + affine.store %1, %arg3[0, %arg4, %arg5, %arg6] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu/raised.mlir new file mode 100644 index 000000000000..93b9e28b1e22 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu/raised.mlir @@ -0,0 +1,51 @@ +#map = affine_map<(d0, d1, d2) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (0, d0, d3 + d1 - 1, d4 + d2 - 1)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +#map6 = affine_map<(d0, d1, d2, d3) -> (-d0 - d1 + 16)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0 + d1 - 1)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d2 + d3 - 1)> +#map9 = affine_map<(d0, d1, d2, d3) -> (-d2 - d3 + 16)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_depthwise_conv3x3_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c16 = arith.constant 16 : index + %c3 = arith.constant 3 : index + %subview = memref.subview %arg2[0] [%c8] [1] : memref to memref> + %subview_0 = memref.subview %arg3[0, 0, 0, 0] [1, %c8, %c16, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %0 = polygeist.submap(%arg0, %c8, %c16, %c16, %c3, %c3) {map = #map2} : (memref, index, index, index, index, index) -> memref + %subview_1 = memref.subview %arg1[0, 0, 0] [%c8, %c3, %c3] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg3[0, 0, 0, 0] [1, %c8, %c16, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map3, #map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]} ins(%0, %subview_1 : memref, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %1 = linalg.index 1 : index + %2 = linalg.index 2 : index + %3 = linalg.index 3 : index + %4 = linalg.index 4 : index + %5 = affine.apply #map6(%4, %2, %1, %3) + %6 = arith.cmpi sge, %5, %c0 : index + %7 = affine.apply #map7(%4, %2, %1, %3) + %8 = arith.cmpi sge, %7, %c0 : index + %9 = arith.andi %6, %8 : i1 + %10 = affine.apply #map8(%4, %2, %1, %3) + %11 = arith.cmpi sge, %10, %c0 : index + %12 = arith.andi %9, %11 : i1 + %13 = affine.apply #map9(%4, %2, %1, %3) + %14 = arith.cmpi sge, %13, %c0 : index + %15 = arith.andi %12, %14 : i1 + %16 = arith.mulf %in, %in_3 : f32 + %17 = arith.addf %out, %16 : f32 + %18 = arith.select %15, %17, %out : f32 + linalg.yield %18 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu_debuf.mlir new file mode 100644 index 000000000000..a72076b39fce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu_debuf.mlir @@ -0,0 +1,57 @@ +#map = affine_map<(d0, d1, d2) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (0, d0, d3 + d1 - 1, d4 + d2 - 1)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +#map6 = affine_map<(d0, d1, d2, d3) -> (-d0 - d1 + 16)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0 + d1 - 1)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d2 + d3 - 1)> +#map9 = affine_map<(d0, d1, d2, d3) -> (-d2 - d3 + 16)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_depthwise_conv3x3_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c16 = arith.constant 16 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %2[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0, 0, 0, 0] [1, %c8, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submap(%0, %c8, %c16, %c16, %c3, %c3) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c8, %c3, %c3] [1, 1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map3, #map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%5, %extracted_slice_1 : tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %8 = linalg.index 1 : index + %9 = linalg.index 2 : index + %10 = linalg.index 3 : index + %11 = linalg.index 4 : index + %12 = affine.apply #map6(%11, %9, %8, %10) + %13 = arith.cmpi sge, %12, %c0 : index + %14 = affine.apply #map7(%11, %9, %8, %10) + %15 = arith.cmpi sge, %14, %c0 : index + %16 = arith.andi %13, %15 : i1 + %17 = affine.apply #map8(%11, %9, %8, %10) + %18 = arith.cmpi sge, %17, %c0 : index + %19 = arith.andi %16, %18 : i1 + %20 = affine.apply #map9(%11, %9, %8, %10) + %21 = arith.cmpi sge, %20, %c0 : index + %22 = arith.andi %19, %21 : i1 + %23 = arith.mulf %in, %in_2 : f32 + %24 = arith.addf %out, %23 : f32 + %25 = arith.select %22, %24, %out : f32 + linalg.yield %25 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %3[0, 0, 0, 0] [1, %c8, %c16, %c16] [1, 1, 1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu_linalg.mlir new file mode 100644 index 000000000000..93b9e28b1e22 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_depthwise_conv3x3_cpu_linalg.mlir @@ -0,0 +1,51 @@ +#map = affine_map<(d0, d1, d2) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (0, d0, d3 + d1 - 1, d4 + d2 - 1)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2)> +#map6 = affine_map<(d0, d1, d2, d3) -> (-d0 - d1 + 16)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0 + d1 - 1)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d2 + d3 - 1)> +#map9 = affine_map<(d0, d1, d2, d3) -> (-d2 - d3 + 16)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_depthwise_conv3x3_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c16 = arith.constant 16 : index + %c3 = arith.constant 3 : index + %subview = memref.subview %arg2[0] [%c8] [1] : memref to memref> + %subview_0 = memref.subview %arg3[0, 0, 0, 0] [1, %c8, %c16, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %0 = polygeist.submap(%arg0, %c8, %c16, %c16, %c3, %c3) {map = #map2} : (memref, index, index, index, index, index) -> memref + %subview_1 = memref.subview %arg1[0, 0, 0] [%c8, %c3, %c3] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg3[0, 0, 0, 0] [1, %c8, %c16, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map3, #map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]} ins(%0, %subview_1 : memref, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %1 = linalg.index 1 : index + %2 = linalg.index 2 : index + %3 = linalg.index 3 : index + %4 = linalg.index 4 : index + %5 = affine.apply #map6(%4, %2, %1, %3) + %6 = arith.cmpi sge, %5, %c0 : index + %7 = affine.apply #map7(%4, %2, %1, %3) + %8 = arith.cmpi sge, %7, %c0 : index + %9 = arith.andi %6, %8 : i1 + %10 = affine.apply #map8(%4, %2, %1, %3) + %11 = arith.cmpi sge, %10, %c0 : index + %12 = arith.andi %9, %11 : i1 + %13 = affine.apply #map9(%4, %2, %1, %3) + %14 = arith.cmpi sge, %13, %c0 : index + %15 = arith.andi %12, %14 : i1 + %16 = arith.mulf %in, %in_3 : f32 + %17 = arith.addf %out, %16 : f32 + %18 = arith.select %15, %17, %out : f32 + linalg.yield %18 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_diff_cpu.mlir b/issues/aten_c_kernels/results/aten_diff_cpu.mlir new file mode 100644 index 000000000000..075d73e4d12e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_diff_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_diff_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 127 { + %0 = affine.load %arg0[%arg2 + 1] : memref + %1 = affine.load %arg0[%arg2] : memref + %2 = arith.subf %0, %1 : f32 + affine.store %2, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_diff_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_diff_cpu/debuf.mlir new file mode 100644 index 000000000000..10d96b5caaef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_diff_cpu/debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_diff_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c127 = arith.constant 127 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[1] [%c127] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0] [%c127] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0] [%c127] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %4 = arith.subf %in, %in_2 : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0] [%c127] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_diff_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_diff_cpu/matched.mlir new file mode 100644 index 000000000000..10d96b5caaef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_diff_cpu/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_diff_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c127 = arith.constant 127 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[1] [%c127] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0] [%c127] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0] [%c127] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %4 = arith.subf %in, %in_2 : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0] [%c127] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_diff_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_diff_cpu/orig.mlir new file mode 100644 index 000000000000..075d73e4d12e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_diff_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_diff_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 127 { + %0 = affine.load %arg0[%arg2 + 1] : memref + %1 = affine.load %arg0[%arg2] : memref + %2 = arith.subf %0, %1 : f32 + affine.store %2, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_diff_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_diff_cpu/raised.mlir new file mode 100644 index 000000000000..3c85995f8297 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_diff_cpu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_diff_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c127 = arith.constant 127 : index + %subview = memref.subview %arg0[1] [%c127] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0] [%c127] [1] : memref to memref> + %subview_1 = memref.subview %arg1[0] [%c127] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.subf %in, %in_2 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_diff_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_diff_cpu_debuf.mlir new file mode 100644 index 000000000000..10d96b5caaef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_diff_cpu_debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_diff_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c127 = arith.constant 127 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[1] [%c127] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0] [%c127] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0] [%c127] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %4 = arith.subf %in, %in_2 : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0] [%c127] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_diff_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_diff_cpu_linalg.mlir new file mode 100644 index 000000000000..3c85995f8297 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_diff_cpu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_diff_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c127 = arith.constant 127 : index + %subview = memref.subview %arg0[1] [%c127] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0] [%c127] [1] : memref to memref> + %subview_1 = memref.subview %arg1[0] [%c127] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.subf %in, %in_2 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_digamma.mlir b/issues/aten_c_kernels/results/aten_digamma.mlir new file mode 100644 index 000000000000..87ad5aa6397c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_digamma.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_digamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_digammaf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_digammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_digamma/debuf.mlir b/issues/aten_c_kernels/results/aten_digamma/debuf.mlir new file mode 100644 index 000000000000..581758e8965d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_digamma/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_digamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_digammaf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_digammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_digamma/matched.mlir b/issues/aten_c_kernels/results/aten_digamma/matched.mlir new file mode 100644 index 000000000000..581758e8965d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_digamma/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_digamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_digammaf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_digammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_digamma/orig.mlir b/issues/aten_c_kernels/results/aten_digamma/orig.mlir new file mode 100644 index 000000000000..87ad5aa6397c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_digamma/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_digamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_digammaf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_digammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_digamma/raised.mlir b/issues/aten_c_kernels/results/aten_digamma/raised.mlir new file mode 100644 index 000000000000..19eaa01ccba6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_digamma/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_digamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_digammaf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_digammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_digamma_debuf.mlir b/issues/aten_c_kernels/results/aten_digamma_debuf.mlir new file mode 100644 index 000000000000..581758e8965d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_digamma_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_digamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_digammaf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_digammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_digamma_linalg.mlir b/issues/aten_c_kernels/results/aten_digamma_linalg.mlir new file mode 100644 index 000000000000..19eaa01ccba6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_digamma_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_digamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_digammaf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_digammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_dilated_convolution_cpu.mlir b/issues/aten_c_kernels/results/aten_dilated_convolution_cpu.mlir new file mode 100644 index 000000000000..3eb6905ba4fc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dilated_convolution_cpu.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dilated_convolution_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 12 { + affine.for %arg5 = 0 to 12 { + %0 = affine.for %arg6 = 0 to 2 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.for %arg8 = 0 to 3 iter_args(%arg9 = %arg7) -> (f32) { + %2 = affine.for %arg10 = 0 to 3 iter_args(%arg11 = %arg9) -> (f32) { + %3 = affine.load %arg0[%arg6, %arg4 + %arg8 * 2, %arg5 + %arg10 * 2] : memref + %4 = affine.load %arg1[%arg3, %arg6, %arg8, %arg10] : memref + %5 = arith.mulf %3, %4 : f32 + %6 = arith.addf %arg11, %5 : f32 + affine.yield %6 : f32 + } + affine.yield %2 : f32 + } + affine.yield %1 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_dilated_convolution_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_dilated_convolution_cpu/debuf.mlir new file mode 100644 index 000000000000..e183f58876f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dilated_convolution_cpu/debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d3, d4 * 2 + d1, d5 * 2 + d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d3, d4, d5)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dilated_convolution_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c2 = arith.constant 2 : index + %c12 = arith.constant 12 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c3, %c12, %c12] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = polygeist.submap(%0, %c3, %c12, %c12, %c2, %c3, %c3) {map = #map1} : (tensor, index, index, index, index, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0] [%c3, %c2, %c3, %c3] [1, 1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%4, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0] [%c3, %c12, %c12] [1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dilated_convolution_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_dilated_convolution_cpu/matched.mlir new file mode 100644 index 000000000000..e183f58876f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dilated_convolution_cpu/matched.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d3, d4 * 2 + d1, d5 * 2 + d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d3, d4, d5)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dilated_convolution_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c2 = arith.constant 2 : index + %c12 = arith.constant 12 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c3, %c12, %c12] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = polygeist.submap(%0, %c3, %c12, %c12, %c2, %c3, %c3) {map = #map1} : (tensor, index, index, index, index, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0] [%c3, %c2, %c3, %c3] [1, 1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%4, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0] [%c3, %c12, %c12] [1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dilated_convolution_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_dilated_convolution_cpu/orig.mlir new file mode 100644 index 000000000000..3eb6905ba4fc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dilated_convolution_cpu/orig.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dilated_convolution_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 12 { + affine.for %arg5 = 0 to 12 { + %0 = affine.for %arg6 = 0 to 2 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.for %arg8 = 0 to 3 iter_args(%arg9 = %arg7) -> (f32) { + %2 = affine.for %arg10 = 0 to 3 iter_args(%arg11 = %arg9) -> (f32) { + %3 = affine.load %arg0[%arg6, %arg4 + %arg8 * 2, %arg5 + %arg10 * 2] : memref + %4 = affine.load %arg1[%arg3, %arg6, %arg8, %arg10] : memref + %5 = arith.mulf %3, %4 : f32 + %6 = arith.addf %arg11, %5 : f32 + affine.yield %6 : f32 + } + affine.yield %2 : f32 + } + affine.yield %1 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_dilated_convolution_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_dilated_convolution_cpu/raised.mlir new file mode 100644 index 000000000000..f89ebebebb61 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dilated_convolution_cpu/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d3, d4 * 2 + d1, d5 * 2 + d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d3, d4, d5)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dilated_convolution_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c12 = arith.constant 12 : index + %c2 = arith.constant 2 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c3, %c12, %c12] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg0, %c3, %c12, %c12, %c2, %c3, %c3) {map = #map1} : (memref, index, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg1[0, 0, 0, 0] [%c3, %c2, %c3, %c3] [1, 1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0, 0] [%c3, %c12, %c12] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%0, %subview_0 : memref, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %1 = arith.mulf %in, %in_2 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dilated_convolution_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_dilated_convolution_cpu_debuf.mlir new file mode 100644 index 000000000000..e183f58876f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dilated_convolution_cpu_debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d3, d4 * 2 + d1, d5 * 2 + d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d3, d4, d5)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dilated_convolution_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c2 = arith.constant 2 : index + %c12 = arith.constant 12 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c3, %c12, %c12] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = polygeist.submap(%0, %c3, %c12, %c12, %c2, %c3, %c3) {map = #map1} : (tensor, index, index, index, index, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0] [%c3, %c2, %c3, %c3] [1, 1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%4, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0] [%c3, %c12, %c12] [1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dilated_convolution_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_dilated_convolution_cpu_linalg.mlir new file mode 100644 index 000000000000..f89ebebebb61 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dilated_convolution_cpu_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d3, d4 * 2 + d1, d5 * 2 + d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d3, d4, d5)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dilated_convolution_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c12 = arith.constant 12 : index + %c2 = arith.constant 2 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c3, %c12, %c12] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg0, %c3, %c12, %c12, %c2, %c3, %c3) {map = #map1} : (memref, index, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg1[0, 0, 0, 0] [%c3, %c2, %c3, %c3] [1, 1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0, 0] [%c3, %c12, %c12] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%0, %subview_0 : memref, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %1 = arith.mulf %in, %in_2 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu.mlir b/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu.mlir new file mode 100644 index 000000000000..df9dab794dda --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dirichlet_grad_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-03 : f32 + affine.for %arg4 = 0 to 1024 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.addf %0, %cst : f32 + %2 = func.call @logf(%1) : (f32) -> f32 + %3 = affine.load %arg1[%arg4] : memref + %4 = affine.load %arg2[%arg4] : memref + %5 = arith.divf %3, %4 : f32 + %6 = arith.subf %2, %5 : f32 + %7 = arith.mulf %0, %6 : f32 + affine.store %7, %arg3[%arg4] : memref + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu/debuf.mlir new file mode 100644 index 000000000000..c6854a2b7a6d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dirichlet_grad_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-03 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.addf %in, %cst : f32 + %7 = math.log %6 : f32 + %8 = arith.divf %in_0, %in_1 : f32 + %9 = arith.subf %7, %8 : f32 + %10 = arith.mulf %in, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu/matched.mlir new file mode 100644 index 000000000000..c6854a2b7a6d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dirichlet_grad_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-03 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.addf %in, %cst : f32 + %7 = math.log %6 : f32 + %8 = arith.divf %in_0, %in_1 : f32 + %9 = arith.subf %7, %8 : f32 + %10 = arith.mulf %in, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu/orig.mlir new file mode 100644 index 000000000000..df9dab794dda --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu/orig.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dirichlet_grad_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-03 : f32 + affine.for %arg4 = 0 to 1024 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.addf %0, %cst : f32 + %2 = func.call @logf(%1) : (f32) -> f32 + %3 = affine.load %arg1[%arg4] : memref + %4 = affine.load %arg2[%arg4] : memref + %5 = arith.divf %3, %4 : f32 + %6 = arith.subf %2, %5 : f32 + %7 = arith.mulf %0, %6 : f32 + affine.store %7, %arg3[%arg4] : memref + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu/raised.mlir new file mode 100644 index 000000000000..53adbc7faa9f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu/raised.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dirichlet_grad_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-03 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg2 : memref, memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.addf %in, %cst : f32 + %1 = math.log %0 : f32 + %2 = arith.divf %in_0, %in_1 : f32 + %3 = arith.subf %1, %2 : f32 + %4 = arith.mulf %in, %3 : f32 + linalg.yield %4 : f32 + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu_debuf.mlir new file mode 100644 index 000000000000..c6854a2b7a6d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dirichlet_grad_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-03 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.addf %in, %cst : f32 + %7 = math.log %6 : f32 + %8 = arith.divf %in_0, %in_1 : f32 + %9 = arith.subf %7, %8 : f32 + %10 = arith.mulf %in, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu_linalg.mlir new file mode 100644 index 000000000000..53adbc7faa9f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dirichlet_grad_cpu_linalg.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dirichlet_grad_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-03 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg2 : memref, memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.addf %in, %cst : f32 + %1 = math.log %0 : f32 + %2 = arith.divf %in_0, %in_1 : f32 + %3 = arith.subf %1, %2 : f32 + %4 = arith.mulf %in, %3 : f32 + linalg.yield %4 : f32 + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu.mlir b/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu.mlir new file mode 100644 index 000000000000..c1f8caa84f4f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dirichlet_transform_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 64 { + %0 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2, %arg3] : memref + %2 = arith.addf %arg4, %1 : f32 + affine.yield %2 : f32 + } + affine.for %arg3 = 0 to 16 { + %1 = affine.load %arg0[%arg2, %arg3] : memref + %2 = arith.divf %1, %0 : f32 + affine.store %2, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu/debuf.mlir new file mode 100644 index 000000000000..4362eaa7b114 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu/debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dirichlet_transform_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg2 = 0 to 64 iter_args(%arg3 = %1) -> (tensor) { + %alloca = memref.alloca() : memref + %5 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %5[] : tensor + %extracted_slice = tensor.extract_slice %2[%arg2, 0] [1, %c16] [1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %8 = arith.addf %out, %in : f32 + linalg.yield %8 : f32 + } -> tensor + %extracted = tensor.extract %6[] : tensor + %extracted_slice_0 = tensor.extract_slice %arg3[%arg2, 0] [1, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %0[%arg2, 0] [1, %c16] [1, 1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %8 = arith.divf %in, %extracted : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %7 into %arg3[%arg2, 0] [1, %c16] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu/matched.mlir new file mode 100644 index 000000000000..4362eaa7b114 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu/matched.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dirichlet_transform_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg2 = 0 to 64 iter_args(%arg3 = %1) -> (tensor) { + %alloca = memref.alloca() : memref + %5 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %5[] : tensor + %extracted_slice = tensor.extract_slice %2[%arg2, 0] [1, %c16] [1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %8 = arith.addf %out, %in : f32 + linalg.yield %8 : f32 + } -> tensor + %extracted = tensor.extract %6[] : tensor + %extracted_slice_0 = tensor.extract_slice %arg3[%arg2, 0] [1, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %0[%arg2, 0] [1, %c16] [1, 1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %8 = arith.divf %in, %extracted : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %7 into %arg3[%arg2, 0] [1, %c16] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu/orig.mlir new file mode 100644 index 000000000000..c1f8caa84f4f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu/orig.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dirichlet_transform_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 64 { + %0 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2, %arg3] : memref + %2 = arith.addf %arg4, %1 : f32 + affine.yield %2 : f32 + } + affine.for %arg3 = 0 to 16 { + %1 = affine.load %arg0[%arg2, %arg3] : memref + %2 = arith.divf %1, %0 : f32 + affine.store %2, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu/raised.mlir new file mode 100644 index 000000000000..b76ab24d7b75 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu/raised.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dirichlet_transform_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 64 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[%arg2, 0] [1, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.addf %out, %in : f32 + linalg.yield %1 : f32 + } + %0 = affine.load %alloca[] : memref + %subview_0 = memref.subview %arg0[%arg2, 0] [1, %c16] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[%arg2, 0] [1, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_0 : memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.divf %in, %0 : f32 + linalg.yield %1 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu_debuf.mlir new file mode 100644 index 000000000000..4362eaa7b114 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu_debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dirichlet_transform_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg2 = 0 to 64 iter_args(%arg3 = %1) -> (tensor) { + %alloca = memref.alloca() : memref + %5 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %5[] : tensor + %extracted_slice = tensor.extract_slice %2[%arg2, 0] [1, %c16] [1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %8 = arith.addf %out, %in : f32 + linalg.yield %8 : f32 + } -> tensor + %extracted = tensor.extract %6[] : tensor + %extracted_slice_0 = tensor.extract_slice %arg3[%arg2, 0] [1, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %0[%arg2, 0] [1, %c16] [1, 1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %8 = arith.divf %in, %extracted : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %7 into %arg3[%arg2, 0] [1, %c16] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu_linalg.mlir new file mode 100644 index 000000000000..b76ab24d7b75 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dirichlet_transform_cpu_linalg.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dirichlet_transform_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 64 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[%arg2, 0] [1, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.addf %out, %in : f32 + linalg.yield %1 : f32 + } + %0 = affine.load %alloca[] : memref + %subview_0 = memref.subview %arg0[%arg2, 0] [1, %c16] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[%arg2, 0] [1, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_0 : memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.divf %in, %0 : f32 + linalg.yield %1 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_div.mlir b/issues/aten_c_kernels/results/aten_div.mlir new file mode 100644 index 000000000000..a6f366635024 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.divf %0, %1 : f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_div/debuf.mlir b/issues/aten_c_kernels/results/aten_div/debuf.mlir new file mode 100644 index 000000000000..ec58b5b84fa7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.divf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_div/matched.mlir b/issues/aten_c_kernels/results/aten_div/matched.mlir new file mode 100644 index 000000000000..ec58b5b84fa7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.divf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_div/orig.mlir b/issues/aten_c_kernels/results/aten_div/orig.mlir new file mode 100644 index 000000000000..a6f366635024 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.divf %0, %1 : f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_div/raised.mlir b/issues/aten_c_kernels/results/aten_div/raised.mlir new file mode 100644 index 000000000000..10c1f130bf4a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.divf %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_div_debuf.mlir b/issues/aten_c_kernels/results/aten_div_debuf.mlir new file mode 100644 index 000000000000..ec58b5b84fa7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.divf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_div_floor.mlir b/issues/aten_c_kernels/results/aten_div_floor.mlir new file mode 100644 index 000000000000..7b07aabc6cce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div_floor.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div_floor(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.divf %0, %1 : f32 + %3 = func.call @floorf(%2) : (f32) -> f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } + func.func private @floorf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_div_floor/debuf.mlir b/issues/aten_c_kernels/results/aten_div_floor/debuf.mlir new file mode 100644 index 000000000000..3861e66ed61d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div_floor/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div_floor(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.divf %in, %in_0 : f32 + %6 = math.floor %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @floorf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_div_floor/matched.mlir b/issues/aten_c_kernels/results/aten_div_floor/matched.mlir new file mode 100644 index 000000000000..3861e66ed61d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div_floor/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div_floor(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.divf %in, %in_0 : f32 + %6 = math.floor %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @floorf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_div_floor/orig.mlir b/issues/aten_c_kernels/results/aten_div_floor/orig.mlir new file mode 100644 index 000000000000..7b07aabc6cce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div_floor/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div_floor(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.divf %0, %1 : f32 + %3 = func.call @floorf(%2) : (f32) -> f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } + func.func private @floorf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_div_floor/raised.mlir b/issues/aten_c_kernels/results/aten_div_floor/raised.mlir new file mode 100644 index 000000000000..350260de31aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div_floor/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div_floor(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.divf %in, %in_0 : f32 + %1 = math.floor %0 : f32 + linalg.yield %1 : f32 + } + return + } + func.func private @floorf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_div_floor_debuf.mlir b/issues/aten_c_kernels/results/aten_div_floor_debuf.mlir new file mode 100644 index 000000000000..3861e66ed61d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div_floor_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div_floor(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.divf %in, %in_0 : f32 + %6 = math.floor %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @floorf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_div_floor_linalg.mlir b/issues/aten_c_kernels/results/aten_div_floor_linalg.mlir new file mode 100644 index 000000000000..350260de31aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div_floor_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div_floor(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.divf %in, %in_0 : f32 + %1 = math.floor %0 : f32 + linalg.yield %1 : f32 + } + return + } + func.func private @floorf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_div_linalg.mlir b/issues/aten_c_kernels/results/aten_div_linalg.mlir new file mode 100644 index 000000000000..10c1f130bf4a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.divf %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_div_trunc.mlir b/issues/aten_c_kernels/results/aten_div_trunc.mlir new file mode 100644 index 000000000000..01d06329b22e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div_trunc.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div_trunc(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.divf %0, %1 : f32 + %3 = func.call @truncf(%2) : (f32) -> f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_div_trunc/debuf.mlir b/issues/aten_c_kernels/results/aten_div_trunc/debuf.mlir new file mode 100644 index 000000000000..4611dcc5e893 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div_trunc/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div_trunc(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.divf %in, %in_0 : f32 + %6 = math.trunc %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_div_trunc/matched.mlir b/issues/aten_c_kernels/results/aten_div_trunc/matched.mlir new file mode 100644 index 000000000000..4611dcc5e893 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div_trunc/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div_trunc(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.divf %in, %in_0 : f32 + %6 = math.trunc %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_div_trunc/orig.mlir b/issues/aten_c_kernels/results/aten_div_trunc/orig.mlir new file mode 100644 index 000000000000..01d06329b22e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div_trunc/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div_trunc(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.divf %0, %1 : f32 + %3 = func.call @truncf(%2) : (f32) -> f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_div_trunc/raised.mlir b/issues/aten_c_kernels/results/aten_div_trunc/raised.mlir new file mode 100644 index 000000000000..6baaafc7d624 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div_trunc/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div_trunc(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.divf %in, %in_0 : f32 + %1 = math.trunc %0 : f32 + linalg.yield %1 : f32 + } + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_div_trunc_debuf.mlir b/issues/aten_c_kernels/results/aten_div_trunc_debuf.mlir new file mode 100644 index 000000000000..4611dcc5e893 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div_trunc_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div_trunc(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.divf %in, %in_0 : f32 + %6 = math.trunc %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_div_trunc_linalg.mlir b/issues/aten_c_kernels/results/aten_div_trunc_linalg.mlir new file mode 100644 index 000000000000..6baaafc7d624 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_div_trunc_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_div_trunc(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.divf %in, %in_0 : f32 + %1 = math.trunc %0 : f32 + linalg.yield %1 : f32 + } + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_dot.mlir b/issues/aten_c_kernels/results/aten_dot.mlir new file mode 100644 index 000000000000..f51eafa3d3a1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dot.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dot(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + affine.store %cst, %arg2[0] : memref + affine.for %arg3 = 0 to 128 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %arg2[0] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg2[0] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_dot/debuf.mlir b/issues/aten_c_kernels/results/aten_dot/debuf.mlir new file mode 100644 index 000000000000..e627c2acb3af --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dot/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dot(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dot/matched.mlir b/issues/aten_c_kernels/results/aten_dot/matched.mlir new file mode 100644 index 000000000000..acb8b96c94e6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dot/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dot(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = kernel.launch @cublasDdot(%0, %1, %extracted_slice) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dot/orig.mlir b/issues/aten_c_kernels/results/aten_dot/orig.mlir new file mode 100644 index 000000000000..f51eafa3d3a1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dot/orig.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dot(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + affine.store %cst, %arg2[0] : memref + affine.for %arg3 = 0 to 128 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %arg2[0] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg2[0] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_dot/raised.mlir b/issues/aten_c_kernels/results/aten_dot/raised.mlir new file mode 100644 index 000000000000..532879f6b07f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dot/raised.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dot(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + affine.store %cst, %arg2[0] : memref + %subview = memref.subview %arg2[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%arg0, %arg1 : memref, memref) outs(%subview : memref>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %0 = arith.mulf %in, %in_0 : f64 + %1 = arith.addf %out, %0 : f64 + linalg.yield %1 : f64 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dot_debuf.mlir b/issues/aten_c_kernels/results/aten_dot_debuf.mlir new file mode 100644 index 000000000000..e627c2acb3af --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dot_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dot(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dot_linalg.mlir b/issues/aten_c_kernels/results/aten_dot_linalg.mlir new file mode 100644 index 000000000000..532879f6b07f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dot_linalg.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dot(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + affine.store %cst, %arg2[0] : memref + %subview = memref.subview %arg2[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%arg0, %arg1 : memref, memref) outs(%subview : memref>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %0 = arith.mulf %in, %in_0 : f64 + %1 = arith.addf %out, %0 : f64 + linalg.yield %1 : f64 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu.mlir b/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu.mlir new file mode 100644 index 000000000000..3497697e6d40 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dropout_feature_noise_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 8 { + affine.for %arg7 = 0 to 8 { + %0 = affine.load %arg0[%arg4, %arg5, %arg6, %arg7] : memref + %1 = affine.load %arg1[%arg4, %arg5] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = arith.mulf %2, %arg2 : f32 + affine.store %3, %arg3[%arg4, %arg5, %arg6, %arg7] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu/debuf.mlir new file mode 100644 index 000000000000..dd91f9aae394 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dropout_feature_noise_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0] [%c8, %c16, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0, 0, 0] [%c8, %c16, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %in, %in_2 : f32 + %6 = arith.mulf %5, %arg2 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0, 0, 0] [%c8, %c16, %c8, %c8] [1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu/matched.mlir new file mode 100644 index 000000000000..dd91f9aae394 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dropout_feature_noise_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0] [%c8, %c16, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0, 0, 0] [%c8, %c16, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %in, %in_2 : f32 + %6 = arith.mulf %5, %arg2 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0, 0, 0] [%c8, %c16, %c8, %c8] [1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu/orig.mlir new file mode 100644 index 000000000000..3497697e6d40 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu/orig.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dropout_feature_noise_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 8 { + affine.for %arg7 = 0 to 8 { + %0 = affine.load %arg0[%arg4, %arg5, %arg6, %arg7] : memref + %1 = affine.load %arg1[%arg4, %arg5] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = arith.mulf %2, %arg2 : f32 + affine.store %3, %arg3[%arg4, %arg5, %arg6, %arg7] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu/raised.mlir new file mode 100644 index 000000000000..95ce96213dd1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dropout_feature_noise_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %subview = memref.subview %arg0[0, 0, 0, 0] [%c8, %c16, %c8, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c16] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg3[0, 0, 0, 0] [%c8, %c16, %c8, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.mulf %0, %arg2 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu_debuf.mlir new file mode 100644 index 000000000000..dd91f9aae394 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dropout_feature_noise_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0] [%c8, %c16, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0, 0, 0] [%c8, %c16, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %in, %in_2 : f32 + %6 = arith.mulf %5, %arg2 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0, 0, 0] [%c8, %c16, %c8, %c8] [1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu_linalg.mlir new file mode 100644 index 000000000000..95ce96213dd1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dropout_feature_noise_cpu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dropout_feature_noise_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %subview = memref.subview %arg0[0, 0, 0, 0] [%c8, %c16, %c8, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c16] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg3[0, 0, 0, 0] [%c8, %c16, %c8, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.mulf %0, %arg2 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu.mlir b/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu.mlir new file mode 100644 index 000000000000..1c4e7b2114cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dyn_quant_matmul_4bit_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c15_i32 = arith.constant 15 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + affine.for %arg5 = 0 to 32 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg3[%arg6] : memref + %1 = affine.load %arg2[%arg6] : memref + %2 = affine.for %arg7 = 0 to 64 iter_args(%arg8 = %cst) -> (f32) { + %3 = arith.index_cast %arg7 : index to i32 + %4 = arith.cmpi slt, %arg7, %c0 : index + %5 = arith.subi %c-1, %arg7 : index + %6 = arith.select %4, %5, %arg7 : index + %7 = arith.divsi %6, %c2 : index + %8 = arith.subi %c-1, %7 : index + %9 = arith.select %4, %8, %7 : index + %10 = memref.load %arg1[%arg6, %9] : memref + %11 = arith.extui %10 : i8 to i32 + %12 = arith.andi %3, %c1_i32 : i32 + %13 = arith.muli %12, %c4_i32 : i32 + %14 = arith.shrsi %11, %13 : i32 + %15 = arith.andi %14, %c15_i32 : i32 + %16 = affine.load %arg0[%arg5, %arg7] : memref + %17 = arith.sitofp %15 : i32 to f32 + %18 = arith.subf %17, %0 : f32 + %19 = arith.mulf %16, %18 : f32 + %20 = arith.mulf %19, %1 : f32 + %21 = arith.addf %arg8, %20 : f32 + affine.yield %21 : f32 + } + affine.store %2, %arg4[%arg5, %arg6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu/debuf.mlir new file mode 100644 index 000000000000..92a998334d9a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu/debuf.mlir @@ -0,0 +1,64 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dyn_quant_matmul_4bit_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c15_i32 = arith.constant 15 : i32 + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %2) -> (tensor) { + %extracted_slice = tensor.extract_slice %arg6[%arg5, 0] [1, %c48] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %arg6[%arg5, 0] [1, %c48] [1, 1] : tensor into tensor + %6 = polygeist.submap(%inserted_slice, %arg5, %c48, %c64) {map = #map1} : (tensor, index, index, index) -> tensor + %7 = polygeist.submap(%1, %c48) {map = #map} : (tensor, index) -> tensor + %8 = polygeist.submap(%7, %c48, %c64) {map = #map2} : (tensor, index, index) -> tensor + %9 = polygeist.submap(%0, %c48) {map = #map} : (tensor, index) -> tensor + %10 = polygeist.submap(%9, %c48, %c64) {map = #map2} : (tensor, index, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%10, %8 : tensor, tensor) outs(%6 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %13 = linalg.index 0 : index + %14 = linalg.index 1 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.cmpi slt, %14, %c0 : index + %17 = arith.subi %c-1, %14 : index + %18 = arith.select %16, %17, %14 : index + %19 = arith.divsi %18, %c2 : index + %20 = arith.subi %c-1, %19 : index + %21 = arith.select %16, %20, %19 : index + %22 = memref.load %arg1[%13, %21] : memref + %23 = arith.extui %22 : i8 to i32 + %24 = arith.andi %15, %c1_i32 : i32 + %25 = arith.muli %24, %c4_i32 : i32 + %26 = arith.shrsi %23, %25 : i32 + %27 = arith.andi %26, %c15_i32 : i32 + %28 = memref.load %arg0[%arg5, %14] : memref + %29 = arith.sitofp %27 : i32 to f32 + %30 = arith.subf %29, %in : f32 + %31 = arith.mulf %28, %30 : f32 + %32 = arith.mulf %31, %in_0 : f32 + %33 = arith.addf %out, %32 : f32 + linalg.yield %33 : f32 + } -> tensor + %12 = polygeist.submapInverse(%inserted_slice, %11, %arg5, %c48, %c64) {map = #map1} : (tensor, tensor, index, index, index) -> tensor + affine.yield %12 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu/matched.mlir new file mode 100644 index 000000000000..3c2538a0c59c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu/matched.mlir @@ -0,0 +1,61 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dyn_quant_matmul_4bit_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c15_i32 = arith.constant 15 : i32 + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %2) -> (tensor) { + %extracted_slice = tensor.extract_slice %arg6[%arg5, 0] [1, %c48] [1, 1] : tensor to tensor + %5 = kernel.launch @memset_zero_1D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %5 into %arg6[%arg5, 0] [1, %c48] [1, 1] : tensor into tensor + %6 = polygeist.submap(%inserted_slice, %arg5, %c48, %c64) {map = #map1} : (tensor, index, index, index) -> tensor + %7 = polygeist.submap(%1, %c48) {map = #map} : (tensor, index) -> tensor + %8 = polygeist.submap(%7, %c48, %c64) {map = #map2} : (tensor, index, index) -> tensor + %9 = polygeist.submap(%0, %c48) {map = #map} : (tensor, index) -> tensor + %10 = polygeist.submap(%9, %c48, %c64) {map = #map2} : (tensor, index, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%10, %8 : tensor, tensor) outs(%6 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %13 = linalg.index 0 : index + %14 = linalg.index 1 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.cmpi slt, %14, %c0 : index + %17 = arith.subi %c-1, %14 : index + %18 = arith.select %16, %17, %14 : index + %19 = arith.divsi %18, %c2 : index + %20 = arith.subi %c-1, %19 : index + %21 = arith.select %16, %20, %19 : index + %22 = memref.load %arg1[%13, %21] : memref + %23 = arith.extui %22 : i8 to i32 + %24 = arith.andi %15, %c1_i32 : i32 + %25 = arith.muli %24, %c4_i32 : i32 + %26 = arith.shrsi %23, %25 : i32 + %27 = arith.andi %26, %c15_i32 : i32 + %28 = memref.load %arg0[%arg5, %14] : memref + %29 = arith.sitofp %27 : i32 to f32 + %30 = arith.subf %29, %in : f32 + %31 = arith.mulf %28, %30 : f32 + %32 = arith.mulf %31, %in_0 : f32 + %33 = arith.addf %out, %32 : f32 + linalg.yield %33 : f32 + } -> tensor + %12 = polygeist.submapInverse(%inserted_slice, %11, %arg5, %c48, %c64) {map = #map1} : (tensor, tensor, index, index, index) -> tensor + affine.yield %12 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu/orig.mlir new file mode 100644 index 000000000000..1c4e7b2114cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu/orig.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dyn_quant_matmul_4bit_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c15_i32 = arith.constant 15 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + affine.for %arg5 = 0 to 32 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg3[%arg6] : memref + %1 = affine.load %arg2[%arg6] : memref + %2 = affine.for %arg7 = 0 to 64 iter_args(%arg8 = %cst) -> (f32) { + %3 = arith.index_cast %arg7 : index to i32 + %4 = arith.cmpi slt, %arg7, %c0 : index + %5 = arith.subi %c-1, %arg7 : index + %6 = arith.select %4, %5, %arg7 : index + %7 = arith.divsi %6, %c2 : index + %8 = arith.subi %c-1, %7 : index + %9 = arith.select %4, %8, %7 : index + %10 = memref.load %arg1[%arg6, %9] : memref + %11 = arith.extui %10 : i8 to i32 + %12 = arith.andi %3, %c1_i32 : i32 + %13 = arith.muli %12, %c4_i32 : i32 + %14 = arith.shrsi %11, %13 : i32 + %15 = arith.andi %14, %c15_i32 : i32 + %16 = affine.load %arg0[%arg5, %arg7] : memref + %17 = arith.sitofp %15 : i32 to f32 + %18 = arith.subf %17, %0 : f32 + %19 = arith.mulf %16, %18 : f32 + %20 = arith.mulf %19, %1 : f32 + %21 = arith.addf %arg8, %20 : f32 + affine.yield %21 : f32 + } + affine.store %2, %arg4[%arg5, %arg6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu/raised.mlir new file mode 100644 index 000000000000..3efab14851e4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu/raised.mlir @@ -0,0 +1,56 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dyn_quant_matmul_4bit_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c15_i32 = arith.constant 15 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + affine.for %arg5 = 0 to 32 { + %subview = memref.subview %arg4[%arg5, 0] [1, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg4, %arg5, %c48, %c64) {map = #map1} : (memref, index, index, index) -> memref + %1 = polygeist.submap(%arg3, %c48) {map = #map} : (memref, index) -> memref + %2 = polygeist.submap(%1, %c48, %c64) {map = #map2} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg2, %c48) {map = #map} : (memref, index) -> memref + %4 = polygeist.submap(%3, %c48, %c64) {map = #map2} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"]} ins(%2, %4 : memref, memref) outs(%0 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = linalg.index 0 : index + %6 = linalg.index 1 : index + %7 = arith.index_cast %6 : index to i32 + %8 = arith.cmpi slt, %6, %c0 : index + %9 = arith.subi %c-1, %6 : index + %10 = arith.select %8, %9, %6 : index + %11 = arith.divsi %10, %c2 : index + %12 = arith.subi %c-1, %11 : index + %13 = arith.select %8, %12, %11 : index + %14 = memref.load %arg1[%5, %13] : memref + %15 = arith.extui %14 : i8 to i32 + %16 = arith.andi %7, %c1_i32 : i32 + %17 = arith.muli %16, %c4_i32 : i32 + %18 = arith.shrsi %15, %17 : i32 + %19 = arith.andi %18, %c15_i32 : i32 + %20 = memref.load %arg0[%arg5, %6] : memref + %21 = arith.sitofp %19 : i32 to f32 + %22 = arith.subf %21, %in : f32 + %23 = arith.mulf %20, %22 : f32 + %24 = arith.mulf %23, %in_0 : f32 + %25 = arith.addf %out, %24 : f32 + linalg.yield %25 : f32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu_debuf.mlir new file mode 100644 index 000000000000..92a998334d9a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu_debuf.mlir @@ -0,0 +1,64 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dyn_quant_matmul_4bit_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c15_i32 = arith.constant 15 : i32 + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %2) -> (tensor) { + %extracted_slice = tensor.extract_slice %arg6[%arg5, 0] [1, %c48] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %arg6[%arg5, 0] [1, %c48] [1, 1] : tensor into tensor + %6 = polygeist.submap(%inserted_slice, %arg5, %c48, %c64) {map = #map1} : (tensor, index, index, index) -> tensor + %7 = polygeist.submap(%1, %c48) {map = #map} : (tensor, index) -> tensor + %8 = polygeist.submap(%7, %c48, %c64) {map = #map2} : (tensor, index, index) -> tensor + %9 = polygeist.submap(%0, %c48) {map = #map} : (tensor, index) -> tensor + %10 = polygeist.submap(%9, %c48, %c64) {map = #map2} : (tensor, index, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%10, %8 : tensor, tensor) outs(%6 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %13 = linalg.index 0 : index + %14 = linalg.index 1 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.cmpi slt, %14, %c0 : index + %17 = arith.subi %c-1, %14 : index + %18 = arith.select %16, %17, %14 : index + %19 = arith.divsi %18, %c2 : index + %20 = arith.subi %c-1, %19 : index + %21 = arith.select %16, %20, %19 : index + %22 = memref.load %arg1[%13, %21] : memref + %23 = arith.extui %22 : i8 to i32 + %24 = arith.andi %15, %c1_i32 : i32 + %25 = arith.muli %24, %c4_i32 : i32 + %26 = arith.shrsi %23, %25 : i32 + %27 = arith.andi %26, %c15_i32 : i32 + %28 = memref.load %arg0[%arg5, %14] : memref + %29 = arith.sitofp %27 : i32 to f32 + %30 = arith.subf %29, %in : f32 + %31 = arith.mulf %28, %30 : f32 + %32 = arith.mulf %31, %in_0 : f32 + %33 = arith.addf %out, %32 : f32 + linalg.yield %33 : f32 + } -> tensor + %12 = polygeist.submapInverse(%inserted_slice, %11, %arg5, %c48, %c64) {map = #map1} : (tensor, tensor, index, index, index) -> tensor + affine.yield %12 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu_linalg.mlir new file mode 100644 index 000000000000..3efab14851e4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dyn_quant_matmul_4bit_cpu_linalg.mlir @@ -0,0 +1,56 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dyn_quant_matmul_4bit_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c15_i32 = arith.constant 15 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + affine.for %arg5 = 0 to 32 { + %subview = memref.subview %arg4[%arg5, 0] [1, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg4, %arg5, %c48, %c64) {map = #map1} : (memref, index, index, index) -> memref + %1 = polygeist.submap(%arg3, %c48) {map = #map} : (memref, index) -> memref + %2 = polygeist.submap(%1, %c48, %c64) {map = #map2} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg2, %c48) {map = #map} : (memref, index) -> memref + %4 = polygeist.submap(%3, %c48, %c64) {map = #map2} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"]} ins(%2, %4 : memref, memref) outs(%0 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = linalg.index 0 : index + %6 = linalg.index 1 : index + %7 = arith.index_cast %6 : index to i32 + %8 = arith.cmpi slt, %6, %c0 : index + %9 = arith.subi %c-1, %6 : index + %10 = arith.select %8, %9, %6 : index + %11 = arith.divsi %10, %c2 : index + %12 = arith.subi %c-1, %11 : index + %13 = arith.select %8, %12, %11 : index + %14 = memref.load %arg1[%5, %13] : memref + %15 = arith.extui %14 : i8 to i32 + %16 = arith.andi %7, %c1_i32 : i32 + %17 = arith.muli %16, %c4_i32 : i32 + %18 = arith.shrsi %15, %17 : i32 + %19 = arith.andi %18, %c15_i32 : i32 + %20 = memref.load %arg0[%arg5, %6] : memref + %21 = arith.sitofp %19 : i32 to f32 + %22 = arith.subf %21, %in : f32 + %23 = arith.mulf %20, %22 : f32 + %24 = arith.mulf %23, %in_0 : f32 + %25 = arith.addf %out, %24 : f32 + linalg.yield %25 : f32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu.mlir b/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu.mlir new file mode 100644 index 000000000000..f35ebb31f93e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu.mlir @@ -0,0 +1,73 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dyn_quant_pack_4bit_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %false = arith.constant false + %c4_i32 = arith.constant 4 : i32 + %c15_i32 = arith.constant 15 : i32 + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 1.500000e+01 : f32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + affine.for %arg4 = 0 to 48 { + %0 = affine.load %arg0[%arg4, 0] : memref + %1:2 = affine.for %arg5 = 1 to 64 iter_args(%arg6 = %0, %arg7 = %0) -> (f32, f32) { + %6 = affine.load %arg0[%arg4, %arg5] : memref + %7 = arith.cmpf olt, %6, %arg7 : f32 + %8 = arith.select %7, %6, %arg7 : f32 + %9 = arith.cmpf ogt, %6, %arg6 : f32 + %10 = arith.select %9, %6, %arg6 : f32 + affine.yield %10, %8 : f32, f32 + } + %2 = arith.subf %1#0, %1#1 : f32 + %3 = arith.divf %2, %cst_0 : f32 + affine.store %3, %arg2[%arg4] : memref + %4 = arith.negf %1#1 : f32 + %5 = arith.divf %4, %3 : f32 + affine.store %5, %arg3[%arg4] : memref + affine.for %arg5 = 0 to 64 step 2 { + %6 = affine.load %arg0[%arg4, %arg5] : memref + %7 = affine.load %arg2[%arg4] : memref + %8 = arith.divf %6, %7 : f32 + %9 = affine.load %arg3[%arg4] : memref + %10 = arith.addf %8, %9 : f32 + %11 = arith.addf %10, %cst : f32 + %12 = arith.fptosi %11 : f32 to i32 + %13 = affine.load %arg0[%arg4, %arg5 + 1] : memref + %14 = arith.divf %13, %7 : f32 + %15 = arith.addf %14, %9 : f32 + %16 = arith.addf %15, %cst : f32 + %17 = arith.fptosi %16 : f32 to i32 + %18 = arith.cmpi slt, %12, %c0_i32 : i32 + %19 = arith.select %18, %c0_i32, %12 : i32 + %20 = scf.if %18 -> (i1) { + scf.yield %false : i1 + } else { + %35 = arith.cmpi sgt, %12, %c15_i32 : i32 + scf.yield %35 : i1 + } + %21 = arith.select %20, %c15_i32, %19 : i32 + %22 = arith.cmpi slt, %17, %c0_i32 : i32 + %23 = arith.select %22, %c0_i32, %17 : i32 + %24 = scf.if %22 -> (i1) { + scf.yield %false : i1 + } else { + %35 = arith.cmpi sgt, %17, %c15_i32 : i32 + scf.yield %35 : i1 + } + %25 = arith.select %24, %c15_i32, %23 : i32 + %26 = arith.shli %25, %c4_i32 : i32 + %27 = arith.ori %21, %26 : i32 + %28 = arith.trunci %27 : i32 to i8 + %29 = arith.cmpi slt, %arg5, %c0 : index + %30 = arith.subi %c-1, %arg5 : index + %31 = arith.select %29, %30, %arg5 : index + %32 = arith.divsi %31, %c2 : index + %33 = arith.subi %c-1, %32 : index + %34 = arith.select %29, %33, %32 : index + memref.store %28, %arg1[%arg4, %34] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu/debuf.mlir new file mode 100644 index 000000000000..a8015da1b312 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu/debuf.mlir @@ -0,0 +1,95 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1) -> (d1 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dyn_quant_pack_4bit_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 1.500000e+01 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %c15_i32 = arith.constant 15 : i32 + %c4_i32 = arith.constant 4 : i32 + %false = arith.constant false + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %c63 = arith.constant 63 : index + %c48 = arith.constant 48 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = tensor.empty(%c48) : tensor + %5 = tensor.empty(%c48) : tensor + %6:5 = affine.for %arg4 = 0 to 48 iter_args(%arg5 = %4, %arg6 = %5, %arg7 = %2, %arg8 = %3, %arg9 = %1) -> (tensor, tensor, tensor, tensor, tensor) { + %extracted = tensor.extract %0[%arg4, %c0] : tensor + %inserted = tensor.insert %extracted into %arg5[%arg4] : tensor + %inserted_1 = tensor.insert %extracted into %arg6[%arg4] : tensor + %extracted_slice = tensor.extract_slice %0[%arg4, 1] [1, %c63] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %inserted[%arg4] [1] [1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %inserted_1[%arg4] [1] [1] : tensor to tensor + %10:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_2, %extracted_slice_3 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_9: f32): + %16 = arith.cmpf olt, %in, %out_9 : f32 + %17 = arith.select %16, %in, %out_9 : f32 + %18 = arith.cmpf ogt, %in, %out : f32 + %19 = arith.select %18, %in, %out : f32 + linalg.yield %19, %17 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %10#0 into %inserted[%arg4] [1] [1] : tensor into tensor + %inserted_slice_4 = tensor.insert_slice %10#1 into %inserted_1[%arg4] [1] [1] : tensor into tensor + %extracted_5 = tensor.extract %inserted_slice[%arg4] : tensor + %extracted_6 = tensor.extract %inserted_slice_4[%arg4] : tensor + %11 = arith.subf %extracted_5, %extracted_6 : f32 + %12 = arith.divf %11, %cst : f32 + %inserted_7 = tensor.insert %12 into %arg7[%arg4] : tensor + %13 = arith.negf %extracted_6 : f32 + %14 = arith.divf %13, %12 : f32 + %inserted_8 = tensor.insert %14 into %arg8[%arg4] : tensor + %15 = affine.for %arg10 = 0 to 64 step 2 iter_args(%arg11 = %arg9) -> (tensor) { + %extracted_9 = tensor.extract %0[%arg4, %arg10] : tensor + %extracted_10 = tensor.extract %inserted_7[%arg4] : tensor + %16 = arith.divf %extracted_9, %extracted_10 : f32 + %extracted_11 = tensor.extract %inserted_8[%arg4] : tensor + %17 = arith.addf %16, %extracted_11 : f32 + %18 = arith.addf %17, %cst_0 : f32 + %19 = arith.fptosi %18 : f32 to i32 + %20 = affine.apply #map2(%arg4, %arg10) + %extracted_12 = tensor.extract %0[%arg4, %20] : tensor + %21 = arith.divf %extracted_12, %extracted_10 : f32 + %22 = arith.addf %21, %extracted_11 : f32 + %23 = arith.addf %22, %cst_0 : f32 + %24 = arith.fptosi %23 : f32 to i32 + %25 = arith.cmpi slt, %19, %c0_i32 : i32 + %26 = arith.select %25, %c0_i32, %19 : i32 + %27 = arith.cmpi sgt, %19, %c15_i32 : i32 + %28 = arith.select %25, %false, %27 : i1 + %29 = arith.select %28, %c15_i32, %26 : i32 + %30 = arith.cmpi slt, %24, %c0_i32 : i32 + %31 = arith.select %30, %c0_i32, %24 : i32 + %32 = arith.cmpi sgt, %24, %c15_i32 : i32 + %33 = arith.select %30, %false, %32 : i1 + %34 = arith.select %33, %c15_i32, %31 : i32 + %35 = arith.shli %34, %c4_i32 : i32 + %36 = arith.ori %29, %35 : i32 + %37 = arith.trunci %36 : i32 to i8 + %38 = arith.cmpi slt, %arg10, %c0 : index + %39 = arith.subi %c-1, %arg10 : index + %40 = arith.select %38, %39, %arg10 : index + %41 = arith.divsi %40, %c2 : index + %42 = arith.subi %c-1, %41 : index + %43 = arith.select %38, %42, %41 : index + %inserted_13 = tensor.insert %37 into %arg11[%arg4, %43] : tensor + affine.yield %inserted_13 : tensor + } + affine.yield %inserted_slice, %inserted_slice_4, %inserted_7, %inserted_8, %15 : tensor, tensor, tensor, tensor, tensor + } + %7 = bufferization.to_memref %6#2 : memref + memref.copy %7, %arg2 : memref to memref + %8 = bufferization.to_memref %6#4 : memref + memref.copy %8, %arg1 : memref to memref + %9 = bufferization.to_memref %6#3 : memref + memref.copy %9, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu/matched.mlir new file mode 100644 index 000000000000..a8015da1b312 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu/matched.mlir @@ -0,0 +1,95 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1) -> (d1 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dyn_quant_pack_4bit_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 1.500000e+01 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %c15_i32 = arith.constant 15 : i32 + %c4_i32 = arith.constant 4 : i32 + %false = arith.constant false + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %c63 = arith.constant 63 : index + %c48 = arith.constant 48 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = tensor.empty(%c48) : tensor + %5 = tensor.empty(%c48) : tensor + %6:5 = affine.for %arg4 = 0 to 48 iter_args(%arg5 = %4, %arg6 = %5, %arg7 = %2, %arg8 = %3, %arg9 = %1) -> (tensor, tensor, tensor, tensor, tensor) { + %extracted = tensor.extract %0[%arg4, %c0] : tensor + %inserted = tensor.insert %extracted into %arg5[%arg4] : tensor + %inserted_1 = tensor.insert %extracted into %arg6[%arg4] : tensor + %extracted_slice = tensor.extract_slice %0[%arg4, 1] [1, %c63] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %inserted[%arg4] [1] [1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %inserted_1[%arg4] [1] [1] : tensor to tensor + %10:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_2, %extracted_slice_3 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_9: f32): + %16 = arith.cmpf olt, %in, %out_9 : f32 + %17 = arith.select %16, %in, %out_9 : f32 + %18 = arith.cmpf ogt, %in, %out : f32 + %19 = arith.select %18, %in, %out : f32 + linalg.yield %19, %17 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %10#0 into %inserted[%arg4] [1] [1] : tensor into tensor + %inserted_slice_4 = tensor.insert_slice %10#1 into %inserted_1[%arg4] [1] [1] : tensor into tensor + %extracted_5 = tensor.extract %inserted_slice[%arg4] : tensor + %extracted_6 = tensor.extract %inserted_slice_4[%arg4] : tensor + %11 = arith.subf %extracted_5, %extracted_6 : f32 + %12 = arith.divf %11, %cst : f32 + %inserted_7 = tensor.insert %12 into %arg7[%arg4] : tensor + %13 = arith.negf %extracted_6 : f32 + %14 = arith.divf %13, %12 : f32 + %inserted_8 = tensor.insert %14 into %arg8[%arg4] : tensor + %15 = affine.for %arg10 = 0 to 64 step 2 iter_args(%arg11 = %arg9) -> (tensor) { + %extracted_9 = tensor.extract %0[%arg4, %arg10] : tensor + %extracted_10 = tensor.extract %inserted_7[%arg4] : tensor + %16 = arith.divf %extracted_9, %extracted_10 : f32 + %extracted_11 = tensor.extract %inserted_8[%arg4] : tensor + %17 = arith.addf %16, %extracted_11 : f32 + %18 = arith.addf %17, %cst_0 : f32 + %19 = arith.fptosi %18 : f32 to i32 + %20 = affine.apply #map2(%arg4, %arg10) + %extracted_12 = tensor.extract %0[%arg4, %20] : tensor + %21 = arith.divf %extracted_12, %extracted_10 : f32 + %22 = arith.addf %21, %extracted_11 : f32 + %23 = arith.addf %22, %cst_0 : f32 + %24 = arith.fptosi %23 : f32 to i32 + %25 = arith.cmpi slt, %19, %c0_i32 : i32 + %26 = arith.select %25, %c0_i32, %19 : i32 + %27 = arith.cmpi sgt, %19, %c15_i32 : i32 + %28 = arith.select %25, %false, %27 : i1 + %29 = arith.select %28, %c15_i32, %26 : i32 + %30 = arith.cmpi slt, %24, %c0_i32 : i32 + %31 = arith.select %30, %c0_i32, %24 : i32 + %32 = arith.cmpi sgt, %24, %c15_i32 : i32 + %33 = arith.select %30, %false, %32 : i1 + %34 = arith.select %33, %c15_i32, %31 : i32 + %35 = arith.shli %34, %c4_i32 : i32 + %36 = arith.ori %29, %35 : i32 + %37 = arith.trunci %36 : i32 to i8 + %38 = arith.cmpi slt, %arg10, %c0 : index + %39 = arith.subi %c-1, %arg10 : index + %40 = arith.select %38, %39, %arg10 : index + %41 = arith.divsi %40, %c2 : index + %42 = arith.subi %c-1, %41 : index + %43 = arith.select %38, %42, %41 : index + %inserted_13 = tensor.insert %37 into %arg11[%arg4, %43] : tensor + affine.yield %inserted_13 : tensor + } + affine.yield %inserted_slice, %inserted_slice_4, %inserted_7, %inserted_8, %15 : tensor, tensor, tensor, tensor, tensor + } + %7 = bufferization.to_memref %6#2 : memref + memref.copy %7, %arg2 : memref to memref + %8 = bufferization.to_memref %6#4 : memref + memref.copy %8, %arg1 : memref to memref + %9 = bufferization.to_memref %6#3 : memref + memref.copy %9, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu/orig.mlir new file mode 100644 index 000000000000..f35ebb31f93e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu/orig.mlir @@ -0,0 +1,73 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dyn_quant_pack_4bit_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %false = arith.constant false + %c4_i32 = arith.constant 4 : i32 + %c15_i32 = arith.constant 15 : i32 + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 1.500000e+01 : f32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + affine.for %arg4 = 0 to 48 { + %0 = affine.load %arg0[%arg4, 0] : memref + %1:2 = affine.for %arg5 = 1 to 64 iter_args(%arg6 = %0, %arg7 = %0) -> (f32, f32) { + %6 = affine.load %arg0[%arg4, %arg5] : memref + %7 = arith.cmpf olt, %6, %arg7 : f32 + %8 = arith.select %7, %6, %arg7 : f32 + %9 = arith.cmpf ogt, %6, %arg6 : f32 + %10 = arith.select %9, %6, %arg6 : f32 + affine.yield %10, %8 : f32, f32 + } + %2 = arith.subf %1#0, %1#1 : f32 + %3 = arith.divf %2, %cst_0 : f32 + affine.store %3, %arg2[%arg4] : memref + %4 = arith.negf %1#1 : f32 + %5 = arith.divf %4, %3 : f32 + affine.store %5, %arg3[%arg4] : memref + affine.for %arg5 = 0 to 64 step 2 { + %6 = affine.load %arg0[%arg4, %arg5] : memref + %7 = affine.load %arg2[%arg4] : memref + %8 = arith.divf %6, %7 : f32 + %9 = affine.load %arg3[%arg4] : memref + %10 = arith.addf %8, %9 : f32 + %11 = arith.addf %10, %cst : f32 + %12 = arith.fptosi %11 : f32 to i32 + %13 = affine.load %arg0[%arg4, %arg5 + 1] : memref + %14 = arith.divf %13, %7 : f32 + %15 = arith.addf %14, %9 : f32 + %16 = arith.addf %15, %cst : f32 + %17 = arith.fptosi %16 : f32 to i32 + %18 = arith.cmpi slt, %12, %c0_i32 : i32 + %19 = arith.select %18, %c0_i32, %12 : i32 + %20 = scf.if %18 -> (i1) { + scf.yield %false : i1 + } else { + %35 = arith.cmpi sgt, %12, %c15_i32 : i32 + scf.yield %35 : i1 + } + %21 = arith.select %20, %c15_i32, %19 : i32 + %22 = arith.cmpi slt, %17, %c0_i32 : i32 + %23 = arith.select %22, %c0_i32, %17 : i32 + %24 = scf.if %22 -> (i1) { + scf.yield %false : i1 + } else { + %35 = arith.cmpi sgt, %17, %c15_i32 : i32 + scf.yield %35 : i1 + } + %25 = arith.select %24, %c15_i32, %23 : i32 + %26 = arith.shli %25, %c4_i32 : i32 + %27 = arith.ori %21, %26 : i32 + %28 = arith.trunci %27 : i32 to i8 + %29 = arith.cmpi slt, %arg5, %c0 : index + %30 = arith.subi %c-1, %arg5 : index + %31 = arith.select %29, %30, %arg5 : index + %32 = arith.divsi %31, %c2 : index + %33 = arith.subi %c-1, %32 : index + %34 = arith.select %29, %33, %32 : index + memref.store %28, %arg1[%arg4, %34] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu/raised.mlir new file mode 100644 index 000000000000..456e589657af --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu/raised.mlir @@ -0,0 +1,79 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dyn_quant_pack_4bit_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c48 = arith.constant 48 : index + %c63 = arith.constant 63 : index + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %false = arith.constant false + %c4_i32 = arith.constant 4 : i32 + %c15_i32 = arith.constant 15 : i32 + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 1.500000e+01 : f32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %alloca = memref.alloca(%c48) : memref + %alloca_1 = memref.alloca(%c48) : memref + affine.for %arg4 = 0 to 48 { + %0 = affine.load %arg0[%arg4, 0] : memref + affine.store %0, %alloca[%arg4] : memref + affine.store %0, %alloca_1[%arg4] : memref + %subview = memref.subview %arg0[%arg4, 1] [1, %c63] [1, 1] : memref to memref> + %subview_2 = memref.subview %alloca[%arg4] [1] [1] : memref to memref> + %subview_3 = memref.subview %alloca_1[%arg4] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%subview_2, %subview_3 : memref>, memref>) { + ^bb0(%in: f32, %out: f32, %out_4: f32): + %7 = arith.cmpf olt, %in, %out_4 : f32 + %8 = arith.select %7, %in, %out_4 : f32 + %9 = arith.cmpf ogt, %in, %out : f32 + %10 = arith.select %9, %in, %out : f32 + linalg.yield %10, %8 : f32, f32 + } + %1 = affine.load %alloca[%arg4] : memref + %2 = affine.load %alloca_1[%arg4] : memref + %3 = arith.subf %1, %2 : f32 + %4 = arith.divf %3, %cst_0 : f32 + affine.store %4, %arg2[%arg4] : memref + %5 = arith.negf %2 : f32 + %6 = arith.divf %5, %4 : f32 + affine.store %6, %arg3[%arg4] : memref + affine.for %arg5 = 0 to 64 step 2 { + %7 = affine.load %arg0[%arg4, %arg5] : memref + %8 = affine.load %arg2[%arg4] : memref + %9 = arith.divf %7, %8 : f32 + %10 = affine.load %arg3[%arg4] : memref + %11 = arith.addf %9, %10 : f32 + %12 = arith.addf %11, %cst : f32 + %13 = arith.fptosi %12 : f32 to i32 + %14 = affine.load %arg0[%arg4, %arg5 + 1] : memref + %15 = arith.divf %14, %8 : f32 + %16 = arith.addf %15, %10 : f32 + %17 = arith.addf %16, %cst : f32 + %18 = arith.fptosi %17 : f32 to i32 + %19 = arith.cmpi slt, %13, %c0_i32 : i32 + %20 = arith.select %19, %c0_i32, %13 : i32 + %21 = arith.cmpi sgt, %13, %c15_i32 : i32 + %22 = arith.select %19, %false, %21 : i1 + %23 = arith.select %22, %c15_i32, %20 : i32 + %24 = arith.cmpi slt, %18, %c0_i32 : i32 + %25 = arith.select %24, %c0_i32, %18 : i32 + %26 = arith.cmpi sgt, %18, %c15_i32 : i32 + %27 = arith.select %24, %false, %26 : i1 + %28 = arith.select %27, %c15_i32, %25 : i32 + %29 = arith.shli %28, %c4_i32 : i32 + %30 = arith.ori %23, %29 : i32 + %31 = arith.trunci %30 : i32 to i8 + %32 = arith.cmpi slt, %arg5, %c0 : index + %33 = arith.subi %c-1, %arg5 : index + %34 = arith.select %32, %33, %arg5 : index + %35 = arith.divsi %34, %c2 : index + %36 = arith.subi %c-1, %35 : index + %37 = arith.select %32, %36, %35 : index + memref.store %31, %arg1[%arg4, %37] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu_debuf.mlir new file mode 100644 index 000000000000..a8015da1b312 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu_debuf.mlir @@ -0,0 +1,95 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1) -> (d1 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dyn_quant_pack_4bit_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 1.500000e+01 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %c15_i32 = arith.constant 15 : i32 + %c4_i32 = arith.constant 4 : i32 + %false = arith.constant false + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %c63 = arith.constant 63 : index + %c48 = arith.constant 48 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = tensor.empty(%c48) : tensor + %5 = tensor.empty(%c48) : tensor + %6:5 = affine.for %arg4 = 0 to 48 iter_args(%arg5 = %4, %arg6 = %5, %arg7 = %2, %arg8 = %3, %arg9 = %1) -> (tensor, tensor, tensor, tensor, tensor) { + %extracted = tensor.extract %0[%arg4, %c0] : tensor + %inserted = tensor.insert %extracted into %arg5[%arg4] : tensor + %inserted_1 = tensor.insert %extracted into %arg6[%arg4] : tensor + %extracted_slice = tensor.extract_slice %0[%arg4, 1] [1, %c63] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %inserted[%arg4] [1] [1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %inserted_1[%arg4] [1] [1] : tensor to tensor + %10:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_2, %extracted_slice_3 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_9: f32): + %16 = arith.cmpf olt, %in, %out_9 : f32 + %17 = arith.select %16, %in, %out_9 : f32 + %18 = arith.cmpf ogt, %in, %out : f32 + %19 = arith.select %18, %in, %out : f32 + linalg.yield %19, %17 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %10#0 into %inserted[%arg4] [1] [1] : tensor into tensor + %inserted_slice_4 = tensor.insert_slice %10#1 into %inserted_1[%arg4] [1] [1] : tensor into tensor + %extracted_5 = tensor.extract %inserted_slice[%arg4] : tensor + %extracted_6 = tensor.extract %inserted_slice_4[%arg4] : tensor + %11 = arith.subf %extracted_5, %extracted_6 : f32 + %12 = arith.divf %11, %cst : f32 + %inserted_7 = tensor.insert %12 into %arg7[%arg4] : tensor + %13 = arith.negf %extracted_6 : f32 + %14 = arith.divf %13, %12 : f32 + %inserted_8 = tensor.insert %14 into %arg8[%arg4] : tensor + %15 = affine.for %arg10 = 0 to 64 step 2 iter_args(%arg11 = %arg9) -> (tensor) { + %extracted_9 = tensor.extract %0[%arg4, %arg10] : tensor + %extracted_10 = tensor.extract %inserted_7[%arg4] : tensor + %16 = arith.divf %extracted_9, %extracted_10 : f32 + %extracted_11 = tensor.extract %inserted_8[%arg4] : tensor + %17 = arith.addf %16, %extracted_11 : f32 + %18 = arith.addf %17, %cst_0 : f32 + %19 = arith.fptosi %18 : f32 to i32 + %20 = affine.apply #map2(%arg4, %arg10) + %extracted_12 = tensor.extract %0[%arg4, %20] : tensor + %21 = arith.divf %extracted_12, %extracted_10 : f32 + %22 = arith.addf %21, %extracted_11 : f32 + %23 = arith.addf %22, %cst_0 : f32 + %24 = arith.fptosi %23 : f32 to i32 + %25 = arith.cmpi slt, %19, %c0_i32 : i32 + %26 = arith.select %25, %c0_i32, %19 : i32 + %27 = arith.cmpi sgt, %19, %c15_i32 : i32 + %28 = arith.select %25, %false, %27 : i1 + %29 = arith.select %28, %c15_i32, %26 : i32 + %30 = arith.cmpi slt, %24, %c0_i32 : i32 + %31 = arith.select %30, %c0_i32, %24 : i32 + %32 = arith.cmpi sgt, %24, %c15_i32 : i32 + %33 = arith.select %30, %false, %32 : i1 + %34 = arith.select %33, %c15_i32, %31 : i32 + %35 = arith.shli %34, %c4_i32 : i32 + %36 = arith.ori %29, %35 : i32 + %37 = arith.trunci %36 : i32 to i8 + %38 = arith.cmpi slt, %arg10, %c0 : index + %39 = arith.subi %c-1, %arg10 : index + %40 = arith.select %38, %39, %arg10 : index + %41 = arith.divsi %40, %c2 : index + %42 = arith.subi %c-1, %41 : index + %43 = arith.select %38, %42, %41 : index + %inserted_13 = tensor.insert %37 into %arg11[%arg4, %43] : tensor + affine.yield %inserted_13 : tensor + } + affine.yield %inserted_slice, %inserted_slice_4, %inserted_7, %inserted_8, %15 : tensor, tensor, tensor, tensor, tensor + } + %7 = bufferization.to_memref %6#2 : memref + memref.copy %7, %arg2 : memref to memref + %8 = bufferization.to_memref %6#4 : memref + memref.copy %8, %arg1 : memref to memref + %9 = bufferization.to_memref %6#3 : memref + memref.copy %9, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu_linalg.mlir new file mode 100644 index 000000000000..456e589657af --- /dev/null +++ b/issues/aten_c_kernels/results/aten_dyn_quant_pack_4bit_weight_cpu_linalg.mlir @@ -0,0 +1,79 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_dyn_quant_pack_4bit_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c48 = arith.constant 48 : index + %c63 = arith.constant 63 : index + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %false = arith.constant false + %c4_i32 = arith.constant 4 : i32 + %c15_i32 = arith.constant 15 : i32 + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 1.500000e+01 : f32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %alloca = memref.alloca(%c48) : memref + %alloca_1 = memref.alloca(%c48) : memref + affine.for %arg4 = 0 to 48 { + %0 = affine.load %arg0[%arg4, 0] : memref + affine.store %0, %alloca[%arg4] : memref + affine.store %0, %alloca_1[%arg4] : memref + %subview = memref.subview %arg0[%arg4, 1] [1, %c63] [1, 1] : memref to memref> + %subview_2 = memref.subview %alloca[%arg4] [1] [1] : memref to memref> + %subview_3 = memref.subview %alloca_1[%arg4] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%subview_2, %subview_3 : memref>, memref>) { + ^bb0(%in: f32, %out: f32, %out_4: f32): + %7 = arith.cmpf olt, %in, %out_4 : f32 + %8 = arith.select %7, %in, %out_4 : f32 + %9 = arith.cmpf ogt, %in, %out : f32 + %10 = arith.select %9, %in, %out : f32 + linalg.yield %10, %8 : f32, f32 + } + %1 = affine.load %alloca[%arg4] : memref + %2 = affine.load %alloca_1[%arg4] : memref + %3 = arith.subf %1, %2 : f32 + %4 = arith.divf %3, %cst_0 : f32 + affine.store %4, %arg2[%arg4] : memref + %5 = arith.negf %2 : f32 + %6 = arith.divf %5, %4 : f32 + affine.store %6, %arg3[%arg4] : memref + affine.for %arg5 = 0 to 64 step 2 { + %7 = affine.load %arg0[%arg4, %arg5] : memref + %8 = affine.load %arg2[%arg4] : memref + %9 = arith.divf %7, %8 : f32 + %10 = affine.load %arg3[%arg4] : memref + %11 = arith.addf %9, %10 : f32 + %12 = arith.addf %11, %cst : f32 + %13 = arith.fptosi %12 : f32 to i32 + %14 = affine.load %arg0[%arg4, %arg5 + 1] : memref + %15 = arith.divf %14, %8 : f32 + %16 = arith.addf %15, %10 : f32 + %17 = arith.addf %16, %cst : f32 + %18 = arith.fptosi %17 : f32 to i32 + %19 = arith.cmpi slt, %13, %c0_i32 : i32 + %20 = arith.select %19, %c0_i32, %13 : i32 + %21 = arith.cmpi sgt, %13, %c15_i32 : i32 + %22 = arith.select %19, %false, %21 : i1 + %23 = arith.select %22, %c15_i32, %20 : i32 + %24 = arith.cmpi slt, %18, %c0_i32 : i32 + %25 = arith.select %24, %c0_i32, %18 : i32 + %26 = arith.cmpi sgt, %18, %c15_i32 : i32 + %27 = arith.select %24, %false, %26 : i1 + %28 = arith.select %27, %c15_i32, %25 : i32 + %29 = arith.shli %28, %c4_i32 : i32 + %30 = arith.ori %23, %29 : i32 + %31 = arith.trunci %30 : i32 to i8 + %32 = arith.cmpi slt, %arg5, %c0 : index + %33 = arith.subi %c-1, %arg5 : index + %34 = arith.select %32, %33, %arg5 : index + %35 = arith.divsi %34, %c2 : index + %36 = arith.subi %c-1, %35 : index + %37 = arith.select %32, %36, %35 : index + memref.store %31, %arg1[%arg4, %37] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu.mlir b/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu.mlir new file mode 100644 index 000000000000..32fb9b4cf6be --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu.mlir @@ -0,0 +1,27 @@ +#set = affine_set<(d0) : (-d0 + 62 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eig_complex_vectors_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 64 { + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg0[%arg4, %arg5] : memref + affine.store %0, %arg2[%arg4, %arg5] : memref + %1 = affine.load %arg1[%arg5] : memref + %2 = arith.cmpf oeq, %1, %cst : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %cst : f32 + } else { + %4 = affine.if #set(%arg5) -> f32 { + %5 = affine.load %arg0[%arg4, %arg5 + 1] : memref + affine.yield %5 : f32 + } else { + affine.yield %cst : f32 + } + scf.yield %4 : f32 + } + affine.store %3, %arg3[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu/debuf.mlir new file mode 100644 index 000000000000..c4faa1b6a64c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu/debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (-d0 + 62)> +#map1 = affine_map<(d0, d1) -> (d1 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eig_complex_vectors_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4:2 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %1, %arg6 = %0) -> (tensor, tensor) { + %7:2 = affine.for %arg7 = 0 to 64 iter_args(%arg8 = %arg5, %arg9 = %arg6) -> (tensor, tensor) { + %extracted = tensor.extract %3[%arg4, %arg7] : tensor + %inserted = tensor.insert %extracted into %arg8[%arg4, %arg7] : tensor + %extracted_0 = tensor.extract %2[%arg7] : tensor + %8 = arith.cmpf oeq, %extracted_0, %cst : f32 + %9 = scf.if %8 -> (f32) { + scf.yield %cst : f32 + } else { + %10 = affine.apply #map(%arg7) + %11 = arith.cmpi sge, %10, %c0 : index + %12 = affine.apply #map1(%arg4, %arg7) + %extracted_2 = tensor.extract %3[%arg4, %12] : tensor + %13 = arith.select %11, %extracted_2, %cst : f32 + scf.yield %13 : f32 + } + %inserted_1 = tensor.insert %9 into %arg9[%arg4, %arg7] : tensor + affine.yield %inserted, %inserted_1 : tensor, tensor + } + affine.yield %7#0, %7#1 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg3 : memref to memref + %6 = bufferization.to_memref %4#0 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu/matched.mlir new file mode 100644 index 000000000000..c4faa1b6a64c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu/matched.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (-d0 + 62)> +#map1 = affine_map<(d0, d1) -> (d1 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eig_complex_vectors_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4:2 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %1, %arg6 = %0) -> (tensor, tensor) { + %7:2 = affine.for %arg7 = 0 to 64 iter_args(%arg8 = %arg5, %arg9 = %arg6) -> (tensor, tensor) { + %extracted = tensor.extract %3[%arg4, %arg7] : tensor + %inserted = tensor.insert %extracted into %arg8[%arg4, %arg7] : tensor + %extracted_0 = tensor.extract %2[%arg7] : tensor + %8 = arith.cmpf oeq, %extracted_0, %cst : f32 + %9 = scf.if %8 -> (f32) { + scf.yield %cst : f32 + } else { + %10 = affine.apply #map(%arg7) + %11 = arith.cmpi sge, %10, %c0 : index + %12 = affine.apply #map1(%arg4, %arg7) + %extracted_2 = tensor.extract %3[%arg4, %12] : tensor + %13 = arith.select %11, %extracted_2, %cst : f32 + scf.yield %13 : f32 + } + %inserted_1 = tensor.insert %9 into %arg9[%arg4, %arg7] : tensor + affine.yield %inserted, %inserted_1 : tensor, tensor + } + affine.yield %7#0, %7#1 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg3 : memref to memref + %6 = bufferization.to_memref %4#0 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu/orig.mlir new file mode 100644 index 000000000000..32fb9b4cf6be --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu/orig.mlir @@ -0,0 +1,27 @@ +#set = affine_set<(d0) : (-d0 + 62 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eig_complex_vectors_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 64 { + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg0[%arg4, %arg5] : memref + affine.store %0, %arg2[%arg4, %arg5] : memref + %1 = affine.load %arg1[%arg5] : memref + %2 = arith.cmpf oeq, %1, %cst : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %cst : f32 + } else { + %4 = affine.if #set(%arg5) -> f32 { + %5 = affine.load %arg0[%arg4, %arg5 + 1] : memref + affine.yield %5 : f32 + } else { + affine.yield %cst : f32 + } + scf.yield %4 : f32 + } + affine.store %3, %arg3[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu/raised.mlir new file mode 100644 index 000000000000..10ae4ed9e141 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu/raised.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (-d0 + 62)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eig_complex_vectors_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 64 { + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg0[%arg4, %arg5] : memref + affine.store %0, %arg2[%arg4, %arg5] : memref + %1 = affine.load %arg1[%arg5] : memref + %2 = arith.cmpf oeq, %1, %cst : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %cst : f32 + } else { + %4 = affine.apply #map(%arg5) + %5 = arith.cmpi sge, %4, %c0 : index + %6 = affine.load %arg0[%arg4, %arg5 + 1] : memref + %7 = arith.select %5, %6, %cst : f32 + scf.yield %7 : f32 + } + affine.store %3, %arg3[%arg4, %arg5] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu_debuf.mlir new file mode 100644 index 000000000000..c4faa1b6a64c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu_debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (-d0 + 62)> +#map1 = affine_map<(d0, d1) -> (d1 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eig_complex_vectors_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4:2 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %1, %arg6 = %0) -> (tensor, tensor) { + %7:2 = affine.for %arg7 = 0 to 64 iter_args(%arg8 = %arg5, %arg9 = %arg6) -> (tensor, tensor) { + %extracted = tensor.extract %3[%arg4, %arg7] : tensor + %inserted = tensor.insert %extracted into %arg8[%arg4, %arg7] : tensor + %extracted_0 = tensor.extract %2[%arg7] : tensor + %8 = arith.cmpf oeq, %extracted_0, %cst : f32 + %9 = scf.if %8 -> (f32) { + scf.yield %cst : f32 + } else { + %10 = affine.apply #map(%arg7) + %11 = arith.cmpi sge, %10, %c0 : index + %12 = affine.apply #map1(%arg4, %arg7) + %extracted_2 = tensor.extract %3[%arg4, %12] : tensor + %13 = arith.select %11, %extracted_2, %cst : f32 + scf.yield %13 : f32 + } + %inserted_1 = tensor.insert %9 into %arg9[%arg4, %arg7] : tensor + affine.yield %inserted, %inserted_1 : tensor, tensor + } + affine.yield %7#0, %7#1 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg3 : memref to memref + %6 = bufferization.to_memref %4#0 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu_linalg.mlir new file mode 100644 index 000000000000..10ae4ed9e141 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eig_complex_vectors_cpu_linalg.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (-d0 + 62)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eig_complex_vectors_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 64 { + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg0[%arg4, %arg5] : memref + affine.store %0, %arg2[%arg4, %arg5] : memref + %1 = affine.load %arg1[%arg5] : memref + %2 = arith.cmpf oeq, %1, %cst : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %cst : f32 + } else { + %4 = affine.apply #map(%arg5) + %5 = arith.cmpi sge, %4, %c0 : index + %6 = affine.load %arg0[%arg4, %arg5 + 1] : memref + %7 = arith.select %5, %6, %cst : f32 + scf.yield %7 : f32 + } + affine.store %3, %arg3[%arg4, %arg5] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_elu.mlir b/issues/aten_c_kernels/results/aten_elu.mlir new file mode 100644 index 000000000000..1db2f557daad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_elu.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_elu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 256 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.cmpf ogt, %0, %cst_0 : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %0 : f32 + } else { + %4 = math.exp %0 : f32 + %5 = arith.subf %4, %cst : f32 + %6 = arith.mulf %arg2, %5 : f32 + scf.yield %6 : f32 + } + %3 = arith.mulf %arg3, %2 : f32 + affine.store %3, %arg1[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_elu/debuf.mlir b/issues/aten_c_kernels/results/aten_elu/debuf.mlir new file mode 100644 index 000000000000..aa5a18bf6d40 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_elu/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_elu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %cst : f32 + %5 = math.exp %in : f32 + %6 = arith.subf %5, %cst_0 : f32 + %7 = arith.mulf %arg2, %6 : f32 + %8 = arith.select %4, %in, %7 : f32 + %9 = arith.mulf %arg3, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_elu/matched.mlir b/issues/aten_c_kernels/results/aten_elu/matched.mlir new file mode 100644 index 000000000000..aa5a18bf6d40 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_elu/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_elu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %cst : f32 + %5 = math.exp %in : f32 + %6 = arith.subf %5, %cst_0 : f32 + %7 = arith.mulf %arg2, %6 : f32 + %8 = arith.select %4, %in, %7 : f32 + %9 = arith.mulf %arg3, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_elu/orig.mlir b/issues/aten_c_kernels/results/aten_elu/orig.mlir new file mode 100644 index 000000000000..1db2f557daad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_elu/orig.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_elu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 256 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.cmpf ogt, %0, %cst_0 : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %0 : f32 + } else { + %4 = math.exp %0 : f32 + %5 = arith.subf %4, %cst : f32 + %6 = arith.mulf %arg2, %5 : f32 + scf.yield %6 : f32 + } + %3 = arith.mulf %arg3, %2 : f32 + affine.store %3, %arg1[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_elu/raised.mlir b/issues/aten_c_kernels/results/aten_elu/raised.mlir new file mode 100644 index 000000000000..8696aab54f7c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_elu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_elu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %cst_0 : f32 + %1 = math.exp %in : f32 + %2 = arith.subf %1, %cst : f32 + %3 = arith.mulf %arg2, %2 : f32 + %4 = arith.select %0, %in, %3 : f32 + %5 = arith.mulf %arg3, %4 : f32 + linalg.yield %5 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_elu_backward.mlir b/issues/aten_c_kernels/results/aten_elu_backward.mlir new file mode 100644 index 000000000000..f3238aa0fee3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_elu_backward.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_elu_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 4096 { + %0 = affine.load %arg1[%arg5] : memref + %1 = arith.cmpf ole, %0, %cst : f32 + %2 = scf.if %1 -> (f32) { + %3 = affine.load %arg0[%arg5] : memref + %4 = arith.addf %0, %arg2 : f32 + %5 = arith.mulf %3, %4 : f32 + %6 = arith.mulf %5, %arg3 : f32 + scf.yield %6 : f32 + } else { + %3 = affine.load %arg0[%arg5] : memref + %4 = arith.mulf %3, %arg3 : f32 + scf.yield %4 : f32 + } + affine.store %2, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_elu_backward/debuf.mlir b/issues/aten_c_kernels/results/aten_elu_backward/debuf.mlir new file mode 100644 index 000000000000..410cf7f3a235 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_elu_backward/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_elu_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0, %0 : tensor, tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %5 = arith.cmpf ole, %in, %cst : f32 + %6 = arith.addf %in, %arg2 : f32 + %7 = arith.mulf %in_0, %6 : f32 + %8 = arith.mulf %7, %arg3 : f32 + %9 = arith.mulf %in_1, %arg3 : f32 + %10 = arith.select %5, %8, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_elu_backward/matched.mlir b/issues/aten_c_kernels/results/aten_elu_backward/matched.mlir new file mode 100644 index 000000000000..410cf7f3a235 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_elu_backward/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_elu_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0, %0 : tensor, tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %5 = arith.cmpf ole, %in, %cst : f32 + %6 = arith.addf %in, %arg2 : f32 + %7 = arith.mulf %in_0, %6 : f32 + %8 = arith.mulf %7, %arg3 : f32 + %9 = arith.mulf %in_1, %arg3 : f32 + %10 = arith.select %5, %8, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_elu_backward/orig.mlir b/issues/aten_c_kernels/results/aten_elu_backward/orig.mlir new file mode 100644 index 000000000000..f3238aa0fee3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_elu_backward/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_elu_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 4096 { + %0 = affine.load %arg1[%arg5] : memref + %1 = arith.cmpf ole, %0, %cst : f32 + %2 = scf.if %1 -> (f32) { + %3 = affine.load %arg0[%arg5] : memref + %4 = arith.addf %0, %arg2 : f32 + %5 = arith.mulf %3, %4 : f32 + %6 = arith.mulf %5, %arg3 : f32 + scf.yield %6 : f32 + } else { + %3 = affine.load %arg0[%arg5] : memref + %4 = arith.mulf %3, %arg3 : f32 + scf.yield %4 : f32 + } + affine.store %2, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_elu_backward/raised.mlir b/issues/aten_c_kernels/results/aten_elu_backward/raised.mlir new file mode 100644 index 000000000000..337227da8428 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_elu_backward/raised.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_elu_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0, %arg0 : memref, memref, memref) outs(%arg4 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.cmpf ole, %in, %cst : f32 + %1 = arith.addf %in, %arg2 : f32 + %2 = arith.mulf %in_0, %1 : f32 + %3 = arith.mulf %2, %arg3 : f32 + %4 = arith.mulf %in_1, %arg3 : f32 + %5 = arith.select %0, %3, %4 : f32 + linalg.yield %5 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_elu_backward_debuf.mlir b/issues/aten_c_kernels/results/aten_elu_backward_debuf.mlir new file mode 100644 index 000000000000..410cf7f3a235 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_elu_backward_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_elu_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0, %0 : tensor, tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %5 = arith.cmpf ole, %in, %cst : f32 + %6 = arith.addf %in, %arg2 : f32 + %7 = arith.mulf %in_0, %6 : f32 + %8 = arith.mulf %7, %arg3 : f32 + %9 = arith.mulf %in_1, %arg3 : f32 + %10 = arith.select %5, %8, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_elu_backward_linalg.mlir b/issues/aten_c_kernels/results/aten_elu_backward_linalg.mlir new file mode 100644 index 000000000000..337227da8428 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_elu_backward_linalg.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_elu_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0, %arg0 : memref, memref, memref) outs(%arg4 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.cmpf ole, %in, %cst : f32 + %1 = arith.addf %in, %arg2 : f32 + %2 = arith.mulf %in_0, %1 : f32 + %3 = arith.mulf %2, %arg3 : f32 + %4 = arith.mulf %in_1, %arg3 : f32 + %5 = arith.select %0, %3, %4 : f32 + linalg.yield %5 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_elu_debuf.mlir b/issues/aten_c_kernels/results/aten_elu_debuf.mlir new file mode 100644 index 000000000000..aa5a18bf6d40 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_elu_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_elu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %cst : f32 + %5 = math.exp %in : f32 + %6 = arith.subf %5, %cst_0 : f32 + %7 = arith.mulf %arg2, %6 : f32 + %8 = arith.select %4, %in, %7 : f32 + %9 = arith.mulf %arg3, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_elu_linalg.mlir b/issues/aten_c_kernels/results/aten_elu_linalg.mlir new file mode 100644 index 000000000000..8696aab54f7c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_elu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_elu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %cst_0 : f32 + %1 = math.exp %in : f32 + %2 = arith.subf %1, %cst : f32 + %3 = arith.mulf %arg2, %2 : f32 + %4 = arith.select %0, %in, %3 : f32 + %5 = arith.mulf %arg3, %4 : f32 + linalg.yield %5 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding.mlir b/issues/aten_c_kernels/results/aten_embedding.mlir new file mode 100644 index 000000000000..d99377b21b4b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 16 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1, %arg4] : memref + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_embedding/debuf.mlir b/issues/aten_c_kernels/results/aten_embedding/debuf.mlir new file mode 100644 index 000000000000..ac3fa6f7961f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, %c16] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%6, %4] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c8, %c16] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding/matched.mlir b/issues/aten_c_kernels/results/aten_embedding/matched.mlir new file mode 100644 index 000000000000..ac3fa6f7961f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, %c16] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%6, %4] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c8, %c16] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding/orig.mlir b/issues/aten_c_kernels/results/aten_embedding/orig.mlir new file mode 100644 index 000000000000..d99377b21b4b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 16 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1, %arg4] : memref + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_embedding/raised.mlir b/issues/aten_c_kernels/results/aten_embedding/raised.mlir new file mode 100644 index 000000000000..0f58b8b421bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %subview = memref.subview %arg2[0, 0] [%c8, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = memref.load %arg1[%0] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3, %1] : memref + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu.mlir new file mode 100644 index 000000000000..14e14c3cf106 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_backward_max_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 65536 { + affine.store %cst, %arg2[0, %arg3] : memref + } + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3, %arg4] : memref + %3 = memref.load %arg2[%1, %arg4] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg2[%1, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu/debuf.mlir new file mode 100644 index 000000000000..ce411b80de6f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_backward_max_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c65536 = arith.constant 65536 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [1, %c65536] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [1, %c65536] [1, 1] : tensor into tensor + %4 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %6 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg3, %arg5] : tensor + %extracted_1 = tensor.extract %arg6[%7, %arg5] : tensor + %8 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %8 into %arg6[%7, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu/matched.mlir new file mode 100644 index 000000000000..2bff2ea54dac --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu/matched.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_backward_max_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c65536 = arith.constant 65536 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [1, %c65536] [1, 1] : tensor to tensor + %3 = kernel.launch @memset_zero_1D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [1, %c65536] [1, 1] : tensor into tensor + %4 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %6 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg3, %arg5] : tensor + %extracted_1 = tensor.extract %arg6[%7, %arg5] : tensor + %8 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %8 into %arg6[%7, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu/orig.mlir new file mode 100644 index 000000000000..14e14c3cf106 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu/orig.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_backward_max_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 65536 { + affine.store %cst, %arg2[0, %arg3] : memref + } + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3, %arg4] : memref + %3 = memref.load %arg2[%1, %arg4] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg2[%1, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu/raised.mlir new file mode 100644 index 000000000000..ca70cd19bb1a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu/raised.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_backward_max_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c65536 = arith.constant 65536 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0] [1, %c65536] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3, %arg4] : memref + %3 = memref.load %arg2[%1, %arg4] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg2[%1, %arg4] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu_debuf.mlir new file mode 100644 index 000000000000..ce411b80de6f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_backward_max_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c65536 = arith.constant 65536 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [1, %c65536] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [1, %c65536] [1, 1] : tensor into tensor + %4 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %6 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg3, %arg5] : tensor + %extracted_1 = tensor.extract %arg6[%7, %arg5] : tensor + %8 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %8 into %arg6[%7, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu_linalg.mlir new file mode 100644 index 000000000000..ca70cd19bb1a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_backward_max_cpu_linalg.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_backward_max_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c65536 = arith.constant 65536 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0] [1, %c65536] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3, %arg4] : memref + %3 = memref.load %arg2[%1, %arg4] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg2[%1, %arg4] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu.mlir new file mode 100644 index 000000000000..9a0b6f50c2fd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_backward_sum_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 65536 { + affine.store %cst, %arg2[0, %arg3] : memref + } + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3, %arg5] : memref + %3 = memref.load %arg2[%1, %arg5] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg2[%1, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu/debuf.mlir new file mode 100644 index 000000000000..d9e161c7c336 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu/debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_backward_sum_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c65536 = arith.constant 65536 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [1, %c65536] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [1, %c65536] [1, 1] : tensor into tensor + %4 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %6 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %arg4) -> (tensor) { + %7 = affine.for %arg7 = 0 to 64 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %8 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg3, %arg7] : tensor + %extracted_1 = tensor.extract %arg8[%8, %arg7] : tensor + %9 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %9 into %arg8[%8, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu/matched.mlir new file mode 100644 index 000000000000..d31ee41b9439 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu/matched.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_backward_sum_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c65536 = arith.constant 65536 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [1, %c65536] [1, 1] : tensor to tensor + %3 = kernel.launch @memset_zero_1D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [1, %c65536] [1, 1] : tensor into tensor + %4 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %6 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %arg4) -> (tensor) { + %7 = affine.for %arg7 = 0 to 64 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %8 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg3, %arg7] : tensor + %extracted_1 = tensor.extract %arg8[%8, %arg7] : tensor + %9 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %9 into %arg8[%8, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu/orig.mlir new file mode 100644 index 000000000000..9a0b6f50c2fd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu/orig.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_backward_sum_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 65536 { + affine.store %cst, %arg2[0, %arg3] : memref + } + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3, %arg5] : memref + %3 = memref.load %arg2[%1, %arg5] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg2[%1, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu/raised.mlir new file mode 100644 index 000000000000..6ea4e7627ae9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_backward_sum_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c65536 = arith.constant 65536 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0] [1, %c65536] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3, %arg5] : memref + %3 = memref.load %arg2[%1, %arg5] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg2[%1, %arg5] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu_debuf.mlir new file mode 100644 index 000000000000..d9e161c7c336 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu_debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_backward_sum_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c65536 = arith.constant 65536 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [1, %c65536] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [1, %c65536] [1, 1] : tensor into tensor + %4 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %6 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %arg4) -> (tensor) { + %7 = affine.for %arg7 = 0 to 64 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %8 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg3, %arg7] : tensor + %extracted_1 = tensor.extract %arg8[%8, %arg7] : tensor + %9 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %9 into %arg8[%8, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu_linalg.mlir new file mode 100644 index 000000000000..6ea4e7627ae9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_backward_sum_cpu_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_backward_sum_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c65536 = arith.constant 65536 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0] [1, %c65536] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3, %arg5] : memref + %3 = memref.load %arg2[%1, %arg5] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg2[%1, %arg5] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu.mlir new file mode 100644 index 000000000000..b7fb30411fa9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_counts_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 1024 { + affine.store %c0_i32, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 512 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg1[%1] : memref + %3 = arith.addi %2, %c1_i32 : i32 + memref.store %3, %arg1[%1] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu/debuf.mlir new file mode 100644 index 000000000000..4ebc1fde0e09 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_counts_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %3 = affine.for %arg2 = 0 to 512 iter_args(%arg3 = %2) -> (tensor) { + %extracted = tensor.extract %1[%arg2] : tensor + %5 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %arg3[%5] : tensor + %6 = arith.addi %extracted_0, %c1_i32 : i32 + %inserted = tensor.insert %6 into %arg3[%5] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu/matched.mlir new file mode 100644 index 000000000000..7b876b08b5cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_counts_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 512 iter_args(%arg3 = %2) -> (tensor) { + %extracted = tensor.extract %1[%arg2] : tensor + %5 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %arg3[%5] : tensor + %6 = arith.addi %extracted_0, %c1_i32 : i32 + %inserted = tensor.insert %6 into %arg3[%5] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu/orig.mlir new file mode 100644 index 000000000000..b7fb30411fa9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_counts_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 1024 { + affine.store %c0_i32, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 512 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg1[%1] : memref + %3 = arith.addi %2, %c1_i32 : i32 + memref.store %3, %arg1[%1] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu/raised.mlir new file mode 100644 index 000000000000..b170d3d0bac6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_counts_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + affine.for %arg2 = 0 to 512 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg1[%1] : memref + %3 = arith.addi %2, %c1_i32 : i32 + memref.store %3, %arg1[%1] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu_debuf.mlir new file mode 100644 index 000000000000..4ebc1fde0e09 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_counts_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %3 = affine.for %arg2 = 0 to 512 iter_args(%arg3 = %2) -> (tensor) { + %extracted = tensor.extract %1[%arg2] : tensor + %5 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %arg3[%5] : tensor + %6 = arith.addi %extracted_0, %c1_i32 : i32 + %inserted = tensor.insert %6 into %arg3[%5] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu_linalg.mlir new file mode 100644 index 000000000000..b170d3d0bac6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_counts_cpu_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_counts_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + affine.for %arg2 = 0 to 512 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg1[%1] : memref + %3 = arith.addi %2, %c1_i32 : i32 + memref.store %3, %arg1[%1] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu.mlir new file mode 100644 index 000000000000..b1591546fc2d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_counts_uniq_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 512 { + %0 = affine.load %arg0[%arg2] : memref + %1 = affine.for %arg3 = 0 to 512 iter_args(%arg4 = %c0_i32) -> (i32) { + %2 = affine.load %arg0[%arg3] : memref + %3 = arith.cmpi eq, %2, %0 : i32 + %4 = arith.extui %3 : i1 to i32 + %5 = arith.addi %arg4, %4 : i32 + affine.yield %5 : i32 + } + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu/debuf.mlir new file mode 100644 index 000000000000..fbec244777ca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu/debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_counts_uniq_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c512 = arith.constant 512 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + %subview = memref.subview %arg0[0] [%c512] [1] : memref to memref> + %3 = polygeist.submap(%arg0, %c512) {map = #map} : (memref, index) -> memref + %subview_0 = memref.subview %3[0] [%c512] [1] : memref to memref> + %subview_1 = memref.subview %arg1[0] [%c512] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "reduction"]} ins(%subview_0, %subview : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %4 = arith.cmpi eq, %in_2, %in : i32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.addi %out, %5 : i32 + linalg.yield %6 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu/matched.mlir new file mode 100644 index 000000000000..5928a95446b0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu/matched.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_counts_uniq_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c512 = arith.constant 512 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = kernel.launch @memset_zero_1D(%0) : (tensor) -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + %subview = memref.subview %arg0[0] [%c512] [1] : memref to memref> + %3 = polygeist.submap(%arg0, %c512) {map = #map} : (memref, index) -> memref + %subview_0 = memref.subview %3[0] [%c512] [1] : memref to memref> + %subview_1 = memref.subview %arg1[0] [%c512] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "reduction"]} ins(%subview_0, %subview : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %4 = arith.cmpi eq, %in_2, %in : i32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.addi %out, %5 : i32 + linalg.yield %6 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu/orig.mlir new file mode 100644 index 000000000000..b1591546fc2d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_counts_uniq_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 512 { + %0 = affine.load %arg0[%arg2] : memref + %1 = affine.for %arg3 = 0 to 512 iter_args(%arg4 = %c0_i32) -> (i32) { + %2 = affine.load %arg0[%arg3] : memref + %3 = arith.cmpi eq, %2, %0 : i32 + %4 = arith.extui %3 : i1 to i32 + %5 = arith.addi %arg4, %4 : i32 + affine.yield %5 : i32 + } + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu/raised.mlir new file mode 100644 index 000000000000..0d64cf4071eb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_counts_uniq_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c512 = arith.constant 512 : index + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg0[0] [%c512] [1] : memref to memref> + %0 = polygeist.submap(%arg0, %c512) {map = #map} : (memref, index) -> memref + %subview_0 = memref.subview %0[0] [%c512] [1] : memref to memref> + %subview_1 = memref.subview %arg1[0] [%c512] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "reduction"]} ins(%subview_0, %subview : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %1 = arith.cmpi eq, %in_2, %in : i32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.addi %out, %2 : i32 + linalg.yield %3 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu_debuf.mlir new file mode 100644 index 000000000000..fbec244777ca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu_debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_counts_uniq_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c512 = arith.constant 512 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + %subview = memref.subview %arg0[0] [%c512] [1] : memref to memref> + %3 = polygeist.submap(%arg0, %c512) {map = #map} : (memref, index) -> memref + %subview_0 = memref.subview %3[0] [%c512] [1] : memref to memref> + %subview_1 = memref.subview %arg1[0] [%c512] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "reduction"]} ins(%subview_0, %subview : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %4 = arith.cmpi eq, %in_2, %in : i32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.addi %out, %5 : i32 + linalg.yield %6 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu_linalg.mlir new file mode 100644 index 000000000000..0d64cf4071eb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_counts_uniq_cpu_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_counts_uniq_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c512 = arith.constant 512 : index + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg0[0] [%c512] [1] : memref to memref> + %0 = polygeist.submap(%arg0, %c512) {map = #map} : (memref, index) -> memref + %subview_0 = memref.subview %0[0] [%c512] [1] : memref to memref> + %subview_1 = memref.subview %arg1[0] [%c512] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "reduction"]} ins(%subview_0, %subview : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %1 = arith.cmpi eq, %in_2, %in : i32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.addi %out, %2 : i32 + linalg.yield %3 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu.mlir new file mode 100644 index 000000000000..05a10c656be8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_max_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, 0] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1, %arg4] : memref + %3 = affine.for %arg5 = 1 to 16 iter_args(%arg6 = %2) -> (f32) { + %4 = affine.load %arg1[%arg3, %arg5] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%5, %arg4] : memref + %7 = arith.cmpf ogt, %6, %arg6 : f32 + %8 = scf.if %7 -> (f32) { + %9 = memref.load %arg0[%5, %arg4] : memref + scf.yield %9 : f32 + } else { + scf.yield %arg6 : f32 + } + affine.yield %8 : f32 + } + affine.store %3, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu/debuf.mlir new file mode 100644 index 000000000000..806e7cadb3b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu/debuf.mlir @@ -0,0 +1,39 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_max_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %0) -> (tensor) { + %6 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %c0] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%7, %arg5] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%arg3, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %4 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %3) -> (tensor) { + %6 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %7 = affine.for %arg7 = 1 to 16 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %arg8[%arg3, %arg5] : tensor + %extracted_0 = tensor.extract %1[%arg3, %arg7] : tensor + %8 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %2[%8, %arg5] : tensor + %9 = arith.cmpf ogt, %extracted_1, %extracted : f32 + %extracted_2 = tensor.extract %2[%8, %arg5] : tensor + %10 = arith.select %9, %extracted_2, %extracted : f32 + %inserted = tensor.insert %10 into %arg8[%arg3, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu/matched.mlir new file mode 100644 index 000000000000..806e7cadb3b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu/matched.mlir @@ -0,0 +1,39 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_max_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %0) -> (tensor) { + %6 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %c0] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%7, %arg5] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%arg3, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %4 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %3) -> (tensor) { + %6 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %7 = affine.for %arg7 = 1 to 16 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %arg8[%arg3, %arg5] : tensor + %extracted_0 = tensor.extract %1[%arg3, %arg7] : tensor + %8 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %2[%8, %arg5] : tensor + %9 = arith.cmpf ogt, %extracted_1, %extracted : f32 + %extracted_2 = tensor.extract %2[%8, %arg5] : tensor + %10 = arith.select %9, %extracted_2, %extracted : f32 + %inserted = tensor.insert %10 into %arg8[%arg3, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu/orig.mlir new file mode 100644 index 000000000000..05a10c656be8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu/orig.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_max_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, 0] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1, %arg4] : memref + %3 = affine.for %arg5 = 1 to 16 iter_args(%arg6 = %2) -> (f32) { + %4 = affine.load %arg1[%arg3, %arg5] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%5, %arg4] : memref + %7 = arith.cmpf ogt, %6, %arg6 : f32 + %8 = scf.if %7 -> (f32) { + %9 = memref.load %arg0[%5, %arg4] : memref + scf.yield %9 : f32 + } else { + scf.yield %arg6 : f32 + } + affine.yield %8 : f32 + } + affine.store %3, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu/raised.mlir new file mode 100644 index 000000000000..2181476ce0b2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu/raised.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_max_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, 0] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1, %arg4] : memref + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + affine.for %arg5 = 1 to 16 { + %0 = affine.load %arg2[%arg3, %arg4] : memref + %1 = affine.load %arg1[%arg3, %arg5] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%2, %arg4] : memref + %4 = arith.cmpf ogt, %3, %0 : f32 + %5 = memref.load %arg0[%2, %arg4] : memref + %6 = arith.select %4, %5, %0 : f32 + affine.store %6, %arg2[%arg3, %arg4] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu_debuf.mlir new file mode 100644 index 000000000000..806e7cadb3b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu_debuf.mlir @@ -0,0 +1,39 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_max_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %0) -> (tensor) { + %6 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %c0] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%7, %arg5] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%arg3, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %4 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %3) -> (tensor) { + %6 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %7 = affine.for %arg7 = 1 to 16 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %arg8[%arg3, %arg5] : tensor + %extracted_0 = tensor.extract %1[%arg3, %arg7] : tensor + %8 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %2[%8, %arg5] : tensor + %9 = arith.cmpf ogt, %extracted_1, %extracted : f32 + %extracted_2 = tensor.extract %2[%8, %arg5] : tensor + %10 = arith.select %9, %extracted_2, %extracted : f32 + %inserted = tensor.insert %10 into %arg8[%arg3, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu_linalg.mlir new file mode 100644 index 000000000000..2181476ce0b2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_max_cpu_linalg.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_max_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, 0] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1, %arg4] : memref + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + affine.for %arg5 = 1 to 16 { + %0 = affine.load %arg2[%arg3, %arg4] : memref + %1 = affine.load %arg1[%arg3, %arg5] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%2, %arg4] : memref + %4 = arith.cmpf ogt, %3, %0 : f32 + %5 = memref.load %arg0[%2, %arg4] : memref + %6 = arith.select %4, %5, %0 : f32 + affine.store %6, %arg2[%arg3, %arg4] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu.mlir new file mode 100644 index 000000000000..e889169d1c17 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_per_sample_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 16 { + %0 = affine.load %arg2[%arg4, %arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.for %arg6 = 0 to 64 iter_args(%arg7 = %cst) -> (f32) { + %3 = affine.load %arg0[%arg4, %arg6] : memref + %4 = memref.load %arg1[%1, %arg6] : memref + %5 = arith.mulf %3, %4 : f32 + %6 = arith.addf %arg7, %5 : f32 + affine.yield %6 : f32 + } + affine.store %2, %arg3[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..ccf707868dcb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu/debuf.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_per_sample_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %0) -> (tensor) { + %extracted_slice = tensor.extract_slice %arg5[%arg4, 0] [1, %c16] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %arg5[%arg4, 0] [1, %c16] [1, 1] : tensor into tensor + %subview = memref.subview %arg2[%arg4, 0] [1, %c16] [1, 1] : memref to memref> + %cast = memref.cast %subview : memref> to memref + %4 = polygeist.submap(%cast, %c16, %c64) {map = #map1} : (memref, index, index) -> memref + %5 = polygeist.submap(%inserted_slice, %arg4, %c16, %c64) {map = #map2} : (tensor, index, index, index) -> tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map3, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%4 : memref) outs(%5 : tensor) { + ^bb0(%in: i32, %out: f32): + %8 = arith.index_cast %in : i32 to index + %9 = linalg.index 1 : index + %10 = memref.load %arg0[%arg4, %9] : memref + %11 = memref.load %arg1[%8, %9] : memref + %12 = arith.mulf %10, %11 : f32 + %13 = arith.addf %out, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %7 = polygeist.submapInverse(%inserted_slice, %6, %arg4, %c16, %c64) {map = #map2} : (tensor, tensor, index, index, index) -> tensor + affine.yield %7 : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu/matched.mlir new file mode 100644 index 000000000000..b772372a844d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu/matched.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_per_sample_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %0) -> (tensor) { + %extracted_slice = tensor.extract_slice %arg5[%arg4, 0] [1, %c16] [1, 1] : tensor to tensor + %3 = kernel.launch @memset_zero_1D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %3 into %arg5[%arg4, 0] [1, %c16] [1, 1] : tensor into tensor + %subview = memref.subview %arg2[%arg4, 0] [1, %c16] [1, 1] : memref to memref> + %cast = memref.cast %subview : memref> to memref + %4 = polygeist.submap(%cast, %c16, %c64) {map = #map1} : (memref, index, index) -> memref + %5 = polygeist.submap(%inserted_slice, %arg4, %c16, %c64) {map = #map2} : (tensor, index, index, index) -> tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map3, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%4 : memref) outs(%5 : tensor) { + ^bb0(%in: i32, %out: f32): + %8 = arith.index_cast %in : i32 to index + %9 = linalg.index 1 : index + %10 = memref.load %arg0[%arg4, %9] : memref + %11 = memref.load %arg1[%8, %9] : memref + %12 = arith.mulf %10, %11 : f32 + %13 = arith.addf %out, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %7 = polygeist.submapInverse(%inserted_slice, %6, %arg4, %c16, %c64) {map = #map2} : (tensor, tensor, index, index, index) -> tensor + affine.yield %7 : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu/orig.mlir new file mode 100644 index 000000000000..e889169d1c17 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_per_sample_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 16 { + %0 = affine.load %arg2[%arg4, %arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.for %arg6 = 0 to 64 iter_args(%arg7 = %cst) -> (f32) { + %3 = affine.load %arg0[%arg4, %arg6] : memref + %4 = memref.load %arg1[%1, %arg6] : memref + %5 = arith.mulf %3, %4 : f32 + %6 = arith.addf %arg7, %5 : f32 + affine.yield %6 : f32 + } + affine.store %2, %arg3[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu/raised.mlir new file mode 100644 index 000000000000..930833969b07 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu/raised.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_per_sample_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 32 { + %subview = memref.subview %arg3[%arg4, 0] [1, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg3, %arg4, %c16, %c64) {map = #map1} : (memref, index, index, index) -> memref + %subview_0 = memref.subview %arg2[%arg4, 0] [1, %c16] [1, 1] : memref to memref> + %cast = memref.cast %subview_0 : memref> to memref + %1 = polygeist.submap(%cast, %c16, %c64) {map = #map2} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3], iterator_types = ["parallel", "reduction"]} ins(%1 : memref) outs(%0 : memref) { + ^bb0(%in: i32, %out: f32): + %2 = arith.index_cast %in : i32 to index + %3 = linalg.index 1 : index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = memref.load %arg1[%2, %3] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..ccf707868dcb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu_debuf.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_per_sample_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %0) -> (tensor) { + %extracted_slice = tensor.extract_slice %arg5[%arg4, 0] [1, %c16] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %arg5[%arg4, 0] [1, %c16] [1, 1] : tensor into tensor + %subview = memref.subview %arg2[%arg4, 0] [1, %c16] [1, 1] : memref to memref> + %cast = memref.cast %subview : memref> to memref + %4 = polygeist.submap(%cast, %c16, %c64) {map = #map1} : (memref, index, index) -> memref + %5 = polygeist.submap(%inserted_slice, %arg4, %c16, %c64) {map = #map2} : (tensor, index, index, index) -> tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map3, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%4 : memref) outs(%5 : tensor) { + ^bb0(%in: i32, %out: f32): + %8 = arith.index_cast %in : i32 to index + %9 = linalg.index 1 : index + %10 = memref.load %arg0[%arg4, %9] : memref + %11 = memref.load %arg1[%8, %9] : memref + %12 = arith.mulf %10, %11 : f32 + %13 = arith.addf %out, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %7 = polygeist.submapInverse(%inserted_slice, %6, %arg4, %c16, %c64) {map = #map2} : (tensor, tensor, index, index, index) -> tensor + affine.yield %7 : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..930833969b07 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_bag_per_sample_backward_cpu_linalg.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding_bag_per_sample_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 32 { + %subview = memref.subview %arg3[%arg4, 0] [1, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg3, %arg4, %c16, %c64) {map = #map1} : (memref, index, index, index) -> memref + %subview_0 = memref.subview %arg2[%arg4, 0] [1, %c16] [1, 1] : memref to memref> + %cast = memref.cast %subview_0 : memref> to memref + %1 = polygeist.submap(%cast, %c16, %c64) {map = #map2} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3], iterator_types = ["parallel", "reduction"]} ins(%1 : memref) outs(%0 : memref) { + ^bb0(%in: i32, %out: f32): + %2 = arith.index_cast %in : i32 to index + %3 = linalg.index 1 : index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = memref.load %arg1[%2, %3] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_debuf.mlir b/issues/aten_c_kernels/results/aten_embedding_debuf.mlir new file mode 100644 index 000000000000..ac3fa6f7961f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, %c16] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%6, %4] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c8, %c16] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_embedding_linalg.mlir b/issues/aten_c_kernels/results/aten_embedding_linalg.mlir new file mode 100644 index 000000000000..0f58b8b421bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_embedding_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_embedding(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %subview = memref.subview %arg2[0, 0] [%c8, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = memref.load %arg1[%0] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3, %1] : memref + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_entr.mlir b/issues/aten_c_kernels/results/aten_entr.mlir new file mode 100644 index 000000000000..e232e6162ea8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_entr.mlir @@ -0,0 +1,36 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_entr(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.cmpf olt, %0, %cst_0 : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %arg1 : f32 + } else { + %3 = affine.load %arg0[%arg4] : memref + %4 = arith.cmpf oeq, %3, %cst_0 : f32 + %5 = scf.if %4 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %6 = affine.load %arg0[%arg4] : memref + %7 = arith.cmpf ole, %6, %cst : f32 + %8 = scf.if %7 -> (f32) { + %9 = affine.load %arg0[%arg4] : memref + %10 = arith.negf %9 : f32 + %11 = func.call @logf(%9) : (f32) -> f32 + %12 = arith.mulf %10, %11 : f32 + scf.yield %12 : f32 + } else { + scf.yield %arg2 : f32 + } + scf.yield %8 : f32 + } + scf.yield %5 : f32 + } + affine.store %2, %arg3[%arg4] : memref + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_entr/debuf.mlir b/issues/aten_c_kernels/results/aten_entr/debuf.mlir new file mode 100644 index 000000000000..19d19cbfeee3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_entr/debuf.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_entr(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg0[%3] : memref + %5 = arith.cmpf olt, %4, %cst : f32 + %6 = scf.if %5 -> (f32) { + scf.yield %arg1 : f32 + } else { + %7 = memref.load %arg0[%3] : memref + %8 = arith.cmpf oeq, %7, %cst : f32 + %9 = scf.if %8 -> (f32) { + scf.yield %cst : f32 + } else { + %10 = memref.load %arg0[%3] : memref + %11 = arith.cmpf ole, %10, %cst_0 : f32 + %12 = scf.if %11 -> (f32) { + %13 = memref.load %arg0[%3] : memref + %14 = arith.negf %13 : f32 + %15 = math.log %13 : f32 + %16 = arith.mulf %14, %15 : f32 + scf.yield %16 : f32 + } else { + scf.yield %arg2 : f32 + } + scf.yield %12 : f32 + } + scf.yield %9 : f32 + } + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg3 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_entr/matched.mlir b/issues/aten_c_kernels/results/aten_entr/matched.mlir new file mode 100644 index 000000000000..19d19cbfeee3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_entr/matched.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_entr(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg0[%3] : memref + %5 = arith.cmpf olt, %4, %cst : f32 + %6 = scf.if %5 -> (f32) { + scf.yield %arg1 : f32 + } else { + %7 = memref.load %arg0[%3] : memref + %8 = arith.cmpf oeq, %7, %cst : f32 + %9 = scf.if %8 -> (f32) { + scf.yield %cst : f32 + } else { + %10 = memref.load %arg0[%3] : memref + %11 = arith.cmpf ole, %10, %cst_0 : f32 + %12 = scf.if %11 -> (f32) { + %13 = memref.load %arg0[%3] : memref + %14 = arith.negf %13 : f32 + %15 = math.log %13 : f32 + %16 = arith.mulf %14, %15 : f32 + scf.yield %16 : f32 + } else { + scf.yield %arg2 : f32 + } + scf.yield %12 : f32 + } + scf.yield %9 : f32 + } + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg3 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_entr/orig.mlir b/issues/aten_c_kernels/results/aten_entr/orig.mlir new file mode 100644 index 000000000000..e232e6162ea8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_entr/orig.mlir @@ -0,0 +1,36 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_entr(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.cmpf olt, %0, %cst_0 : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %arg1 : f32 + } else { + %3 = affine.load %arg0[%arg4] : memref + %4 = arith.cmpf oeq, %3, %cst_0 : f32 + %5 = scf.if %4 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %6 = affine.load %arg0[%arg4] : memref + %7 = arith.cmpf ole, %6, %cst : f32 + %8 = scf.if %7 -> (f32) { + %9 = affine.load %arg0[%arg4] : memref + %10 = arith.negf %9 : f32 + %11 = func.call @logf(%9) : (f32) -> f32 + %12 = arith.mulf %10, %11 : f32 + scf.yield %12 : f32 + } else { + scf.yield %arg2 : f32 + } + scf.yield %8 : f32 + } + scf.yield %5 : f32 + } + affine.store %2, %arg3[%arg4] : memref + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_entr/raised.mlir b/issues/aten_c_kernels/results/aten_entr/raised.mlir new file mode 100644 index 000000000000..e4a6fc7a8805 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_entr/raised.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_entr(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg3 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg0[%0] : memref + %2 = arith.cmpf olt, %1, %cst_0 : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %arg1 : f32 + } else { + %4 = memref.load %arg0[%0] : memref + %5 = arith.cmpf oeq, %4, %cst_0 : f32 + %6 = scf.if %5 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %7 = memref.load %arg0[%0] : memref + %8 = arith.cmpf ole, %7, %cst : f32 + %9 = scf.if %8 -> (f32) { + %10 = memref.load %arg0[%0] : memref + %11 = arith.negf %10 : f32 + %12 = math.log %10 : f32 + %13 = arith.mulf %11, %12 : f32 + scf.yield %13 : f32 + } else { + scf.yield %arg2 : f32 + } + scf.yield %9 : f32 + } + scf.yield %6 : f32 + } + linalg.yield %3 : f32 + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_entr_debuf.mlir b/issues/aten_c_kernels/results/aten_entr_debuf.mlir new file mode 100644 index 000000000000..19d19cbfeee3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_entr_debuf.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_entr(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg0[%3] : memref + %5 = arith.cmpf olt, %4, %cst : f32 + %6 = scf.if %5 -> (f32) { + scf.yield %arg1 : f32 + } else { + %7 = memref.load %arg0[%3] : memref + %8 = arith.cmpf oeq, %7, %cst : f32 + %9 = scf.if %8 -> (f32) { + scf.yield %cst : f32 + } else { + %10 = memref.load %arg0[%3] : memref + %11 = arith.cmpf ole, %10, %cst_0 : f32 + %12 = scf.if %11 -> (f32) { + %13 = memref.load %arg0[%3] : memref + %14 = arith.negf %13 : f32 + %15 = math.log %13 : f32 + %16 = arith.mulf %14, %15 : f32 + scf.yield %16 : f32 + } else { + scf.yield %arg2 : f32 + } + scf.yield %12 : f32 + } + scf.yield %9 : f32 + } + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg3 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_entr_linalg.mlir b/issues/aten_c_kernels/results/aten_entr_linalg.mlir new file mode 100644 index 000000000000..e4a6fc7a8805 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_entr_linalg.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_entr(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg3 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg0[%0] : memref + %2 = arith.cmpf olt, %1, %cst_0 : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %arg1 : f32 + } else { + %4 = memref.load %arg0[%0] : memref + %5 = arith.cmpf oeq, %4, %cst_0 : f32 + %6 = scf.if %5 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %7 = memref.load %arg0[%0] : memref + %8 = arith.cmpf ole, %7, %cst : f32 + %9 = scf.if %8 -> (f32) { + %10 = memref.load %arg0[%0] : memref + %11 = arith.negf %10 : f32 + %12 = math.log %10 : f32 + %13 = arith.mulf %11, %12 : f32 + scf.yield %13 : f32 + } else { + scf.yield %arg2 : f32 + } + scf.yield %9 : f32 + } + scf.yield %6 : f32 + } + linalg.yield %3 : f32 + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_eq.mlir b/issues/aten_c_kernels/results/aten_eq.mlir new file mode 100644 index 000000000000..27a81ef7ae70 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eq.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eq(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf oeq, %0, %1 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_eq/debuf.mlir b/issues/aten_c_kernels/results/aten_eq/debuf.mlir new file mode 100644 index 000000000000..6b807a47b781 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eq/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eq(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf oeq, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_eq/matched.mlir b/issues/aten_c_kernels/results/aten_eq/matched.mlir new file mode 100644 index 000000000000..6b807a47b781 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eq/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eq(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf oeq, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_eq/orig.mlir b/issues/aten_c_kernels/results/aten_eq/orig.mlir new file mode 100644 index 000000000000..27a81ef7ae70 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eq/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eq(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf oeq, %0, %1 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_eq/raised.mlir b/issues/aten_c_kernels/results/aten_eq/raised.mlir new file mode 100644 index 000000000000..03a08049a610 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eq/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eq(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf oeq, %in, %in_0 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_eq_debuf.mlir b/issues/aten_c_kernels/results/aten_eq_debuf.mlir new file mode 100644 index 000000000000..6b807a47b781 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eq_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eq(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf oeq, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_eq_linalg.mlir b/issues/aten_c_kernels/results/aten_eq_linalg.mlir new file mode 100644 index 000000000000..03a08049a610 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eq_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eq(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf oeq, %in, %in_0 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_equal_cpu.mlir b/issues/aten_c_kernels/results/aten_equal_cpu.mlir new file mode 100644 index 000000000000..8c4dbf4c219b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_equal_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_equal_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %c1_i32) -> (i32) { + %1 = arith.cmpi ne, %arg4, %c0_i32 : i32 + %2 = scf.if %1 -> (i1) { + %4 = affine.load %arg0[%arg3] : memref + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf oeq, %4, %5 : f32 + scf.yield %6 : i1 + } else { + scf.yield %false : i1 + } + %3 = arith.extsi %2 : i1 to i32 + affine.yield %3 : i32 + } + affine.store %0, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_equal_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_equal_cpu/debuf.mlir new file mode 100644 index 000000000000..07b49241f597 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_equal_cpu/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_equal_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %false = arith.constant false + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %c1_i32 into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: i32): + %5 = arith.cmpi ne, %out, %c0_i32 : i32 + %6 = arith.cmpf oeq, %in, %in_0 : f32 + %7 = arith.select %5, %6, %false : i1 + %8 = arith.extsi %7 : i1 to i32 + linalg.yield %8 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_equal_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_equal_cpu/matched.mlir new file mode 100644 index 000000000000..07b49241f597 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_equal_cpu/matched.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_equal_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %false = arith.constant false + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %c1_i32 into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: i32): + %5 = arith.cmpi ne, %out, %c0_i32 : i32 + %6 = arith.cmpf oeq, %in, %in_0 : f32 + %7 = arith.select %5, %6, %false : i1 + %8 = arith.extsi %7 : i1 to i32 + linalg.yield %8 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_equal_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_equal_cpu/orig.mlir new file mode 100644 index 000000000000..8c4dbf4c219b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_equal_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_equal_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %c1_i32) -> (i32) { + %1 = arith.cmpi ne, %arg4, %c0_i32 : i32 + %2 = scf.if %1 -> (i1) { + %4 = affine.load %arg0[%arg3] : memref + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf oeq, %4, %5 : f32 + scf.yield %6 : i1 + } else { + scf.yield %false : i1 + } + %3 = arith.extsi %2 : i1 to i32 + affine.yield %3 : i32 + } + affine.store %0, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_equal_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_equal_cpu/raised.mlir new file mode 100644 index 000000000000..973abe96460e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_equal_cpu/raised.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_equal_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + affine.store %c1_i32, %arg2[0] : memref + %subview = memref.subview %arg2[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%arg0, %arg1 : memref, memref) outs(%subview : memref>) { + ^bb0(%in: f32, %in_0: f32, %out: i32): + %0 = arith.cmpi ne, %out, %c0_i32 : i32 + %1 = arith.cmpf oeq, %in, %in_0 : f32 + %2 = arith.select %0, %1, %false : i1 + %3 = arith.extsi %2 : i1 to i32 + linalg.yield %3 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_equal_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_equal_cpu_debuf.mlir new file mode 100644 index 000000000000..07b49241f597 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_equal_cpu_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_equal_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %false = arith.constant false + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %c1_i32 into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: i32): + %5 = arith.cmpi ne, %out, %c0_i32 : i32 + %6 = arith.cmpf oeq, %in, %in_0 : f32 + %7 = arith.select %5, %6, %false : i1 + %8 = arith.extsi %7 : i1 to i32 + linalg.yield %8 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_equal_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_equal_cpu_linalg.mlir new file mode 100644 index 000000000000..973abe96460e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_equal_cpu_linalg.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_equal_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + affine.store %c1_i32, %arg2[0] : memref + %subview = memref.subview %arg2[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%arg0, %arg1 : memref, memref) outs(%subview : memref>) { + ^bb0(%in: f32, %in_0: f32, %out: i32): + %0 = arith.cmpi ne, %out, %c0_i32 : i32 + %1 = arith.cmpf oeq, %in, %in_0 : f32 + %2 = arith.select %0, %1, %false : i1 + %3 = arith.extsi %2 : i1 to i32 + linalg.yield %3 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_erf.mlir b/issues/aten_c_kernels/results/aten_erf.mlir new file mode 100644 index 000000000000..521a0334897d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erf.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erf(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @erff(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_erf/debuf.mlir b/issues/aten_c_kernels/results/aten_erf/debuf.mlir new file mode 100644 index 000000000000..055399eb4e2d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erf/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erf(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.erf %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erf/matched.mlir b/issues/aten_c_kernels/results/aten_erf/matched.mlir new file mode 100644 index 000000000000..055399eb4e2d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erf/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erf(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.erf %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erf/orig.mlir b/issues/aten_c_kernels/results/aten_erf/orig.mlir new file mode 100644 index 000000000000..521a0334897d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erf/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erf(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @erff(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_erf/raised.mlir b/issues/aten_c_kernels/results/aten_erf/raised.mlir new file mode 100644 index 000000000000..920889d37129 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erf/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erf(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.erf %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erf_debuf.mlir b/issues/aten_c_kernels/results/aten_erf_debuf.mlir new file mode 100644 index 000000000000..055399eb4e2d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erf_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erf(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.erf %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erf_linalg.mlir b/issues/aten_c_kernels/results/aten_erf_linalg.mlir new file mode 100644 index 000000000000..920889d37129 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erf_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erf(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.erf %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erfc.mlir b/issues/aten_c_kernels/results/aten_erfc.mlir new file mode 100644 index 000000000000..3e3d6c1d4c89 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfc.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @erfcf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @erfcf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_erfc/debuf.mlir b/issues/aten_c_kernels/results/aten_erfc/debuf.mlir new file mode 100644 index 000000000000..2977e6b9ed57 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfc/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @erfcf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @erfcf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erfc/matched.mlir b/issues/aten_c_kernels/results/aten_erfc/matched.mlir new file mode 100644 index 000000000000..2977e6b9ed57 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfc/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @erfcf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @erfcf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erfc/orig.mlir b/issues/aten_c_kernels/results/aten_erfc/orig.mlir new file mode 100644 index 000000000000..3e3d6c1d4c89 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfc/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @erfcf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @erfcf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_erfc/raised.mlir b/issues/aten_c_kernels/results/aten_erfc/raised.mlir new file mode 100644 index 000000000000..27b29e82a264 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfc/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @erfcf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @erfcf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erfc_debuf.mlir b/issues/aten_c_kernels/results/aten_erfc_debuf.mlir new file mode 100644 index 000000000000..2977e6b9ed57 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfc_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @erfcf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @erfcf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erfc_linalg.mlir b/issues/aten_c_kernels/results/aten_erfc_linalg.mlir new file mode 100644 index 000000000000..27b29e82a264 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfc_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @erfcf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @erfcf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erfcx.mlir b/issues/aten_c_kernels/results/aten_erfcx.mlir new file mode 100644 index 000000000000..260368ffa83c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfcx.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfcx(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_erfcxf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_erfcxf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_erfcx/debuf.mlir b/issues/aten_c_kernels/results/aten_erfcx/debuf.mlir new file mode 100644 index 000000000000..5ad8464c2835 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfcx/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfcx(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_erfcxf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_erfcxf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erfcx/matched.mlir b/issues/aten_c_kernels/results/aten_erfcx/matched.mlir new file mode 100644 index 000000000000..5ad8464c2835 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfcx/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfcx(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_erfcxf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_erfcxf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erfcx/orig.mlir b/issues/aten_c_kernels/results/aten_erfcx/orig.mlir new file mode 100644 index 000000000000..260368ffa83c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfcx/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfcx(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_erfcxf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_erfcxf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_erfcx/raised.mlir b/issues/aten_c_kernels/results/aten_erfcx/raised.mlir new file mode 100644 index 000000000000..aa0677c11368 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfcx/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfcx(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_erfcxf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_erfcxf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erfcx_debuf.mlir b/issues/aten_c_kernels/results/aten_erfcx_debuf.mlir new file mode 100644 index 000000000000..5ad8464c2835 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfcx_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfcx(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_erfcxf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_erfcxf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erfcx_linalg.mlir b/issues/aten_c_kernels/results/aten_erfcx_linalg.mlir new file mode 100644 index 000000000000..aa0677c11368 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfcx_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfcx(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_erfcxf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_erfcxf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erfinv.mlir b/issues/aten_c_kernels/results/aten_erfinv.mlir new file mode 100644 index 000000000000..fe6780b315a0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfinv.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfinv(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_erfinvf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_erfinvf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_erfinv/debuf.mlir b/issues/aten_c_kernels/results/aten_erfinv/debuf.mlir new file mode 100644 index 000000000000..3a18ed9cb43e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfinv/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfinv(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_erfinvf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_erfinvf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erfinv/matched.mlir b/issues/aten_c_kernels/results/aten_erfinv/matched.mlir new file mode 100644 index 000000000000..3a18ed9cb43e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfinv/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfinv(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_erfinvf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_erfinvf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erfinv/orig.mlir b/issues/aten_c_kernels/results/aten_erfinv/orig.mlir new file mode 100644 index 000000000000..fe6780b315a0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfinv/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfinv(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_erfinvf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_erfinvf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_erfinv/raised.mlir b/issues/aten_c_kernels/results/aten_erfinv/raised.mlir new file mode 100644 index 000000000000..058b5680f031 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfinv/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfinv(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_erfinvf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_erfinvf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erfinv_debuf.mlir b/issues/aten_c_kernels/results/aten_erfinv_debuf.mlir new file mode 100644 index 000000000000..3a18ed9cb43e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfinv_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfinv(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_erfinvf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_erfinvf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_erfinv_linalg.mlir b/issues/aten_c_kernels/results/aten_erfinv_linalg.mlir new file mode 100644 index 000000000000..058b5680f031 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_erfinv_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_erfinv(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_erfinvf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_erfinvf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_exp.mlir b/issues/aten_c_kernels/results/aten_exp.mlir new file mode 100644 index 000000000000..f26ea05e6362 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exp.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exp(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = math.exp %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_exp/debuf.mlir b/issues/aten_c_kernels/results/aten_exp/debuf.mlir new file mode 100644 index 000000000000..c96e5b1c3392 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exp/debuf.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exp(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.exp %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_exp/matched.mlir b/issues/aten_c_kernels/results/aten_exp/matched.mlir new file mode 100644 index 000000000000..c96e5b1c3392 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exp/matched.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exp(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.exp %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_exp/orig.mlir b/issues/aten_c_kernels/results/aten_exp/orig.mlir new file mode 100644 index 000000000000..f26ea05e6362 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exp/orig.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exp(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = math.exp %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_exp/raised.mlir b/issues/aten_c_kernels/results/aten_exp/raised.mlir new file mode 100644 index 000000000000..a646d8144992 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exp/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exp(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.exp %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_exp2.mlir b/issues/aten_c_kernels/results/aten_exp2.mlir new file mode 100644 index 000000000000..be6ea2cf976e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exp2.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exp2(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @exp2f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @exp2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_exp2/debuf.mlir b/issues/aten_c_kernels/results/aten_exp2/debuf.mlir new file mode 100644 index 000000000000..7ff0a51ae9a6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exp2/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exp2(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.exp2 %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @exp2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_exp2/matched.mlir b/issues/aten_c_kernels/results/aten_exp2/matched.mlir new file mode 100644 index 000000000000..7ff0a51ae9a6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exp2/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exp2(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.exp2 %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @exp2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_exp2/orig.mlir b/issues/aten_c_kernels/results/aten_exp2/orig.mlir new file mode 100644 index 000000000000..be6ea2cf976e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exp2/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exp2(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @exp2f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @exp2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_exp2/raised.mlir b/issues/aten_c_kernels/results/aten_exp2/raised.mlir new file mode 100644 index 000000000000..d6419da79cd9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exp2/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exp2(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.exp2 %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @exp2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_exp2_debuf.mlir b/issues/aten_c_kernels/results/aten_exp2_debuf.mlir new file mode 100644 index 000000000000..7ff0a51ae9a6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exp2_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exp2(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.exp2 %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @exp2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_exp2_linalg.mlir b/issues/aten_c_kernels/results/aten_exp2_linalg.mlir new file mode 100644 index 000000000000..d6419da79cd9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exp2_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exp2(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.exp2 %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @exp2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_exp_debuf.mlir b/issues/aten_c_kernels/results/aten_exp_debuf.mlir new file mode 100644 index 000000000000..c96e5b1c3392 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exp_debuf.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exp(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.exp %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_exp_linalg.mlir b/issues/aten_c_kernels/results/aten_exp_linalg.mlir new file mode 100644 index 000000000000..a646d8144992 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exp_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exp(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.exp %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_expm1.mlir b/issues/aten_c_kernels/results/aten_expm1.mlir new file mode 100644 index 000000000000..05b4dabb7be5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_expm1.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_expm1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @expm1f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @expm1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_expm1/debuf.mlir b/issues/aten_c_kernels/results/aten_expm1/debuf.mlir new file mode 100644 index 000000000000..bdfaa1b7885a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_expm1/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_expm1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.expm1 %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @expm1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_expm1/matched.mlir b/issues/aten_c_kernels/results/aten_expm1/matched.mlir new file mode 100644 index 000000000000..bdfaa1b7885a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_expm1/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_expm1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.expm1 %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @expm1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_expm1/orig.mlir b/issues/aten_c_kernels/results/aten_expm1/orig.mlir new file mode 100644 index 000000000000..05b4dabb7be5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_expm1/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_expm1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @expm1f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @expm1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_expm1/raised.mlir b/issues/aten_c_kernels/results/aten_expm1/raised.mlir new file mode 100644 index 000000000000..871f04673eb6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_expm1/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_expm1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.expm1 %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @expm1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_expm1_debuf.mlir b/issues/aten_c_kernels/results/aten_expm1_debuf.mlir new file mode 100644 index 000000000000..bdfaa1b7885a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_expm1_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_expm1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.expm1 %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @expm1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_expm1_linalg.mlir b/issues/aten_c_kernels/results/aten_expm1_linalg.mlir new file mode 100644 index 000000000000..871f04673eb6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_expm1_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_expm1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.expm1 %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @expm1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_exponential_cpu.mlir b/issues/aten_c_kernels/results/aten_exponential_cpu.mlir new file mode 100644 index 000000000000..6e672ad7f1db --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exponential_cpu.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exponential_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.negf %0 : f32 + %2 = func.call @log1pf(%1) : (f32) -> f32 + %3 = arith.negf %2 : f32 + %4 = arith.divf %3, %arg1 : f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_exponential_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_exponential_cpu/debuf.mlir new file mode 100644 index 000000000000..a0bbd37be29b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exponential_cpu/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exponential_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.negf %in : f32 + %5 = math.log1p %4 : f32 + %6 = arith.negf %5 : f32 + %7 = arith.divf %6, %arg1 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_exponential_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_exponential_cpu/matched.mlir new file mode 100644 index 000000000000..a0bbd37be29b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exponential_cpu/matched.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exponential_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.negf %in : f32 + %5 = math.log1p %4 : f32 + %6 = arith.negf %5 : f32 + %7 = arith.divf %6, %arg1 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_exponential_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_exponential_cpu/orig.mlir new file mode 100644 index 000000000000..6e672ad7f1db --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exponential_cpu/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exponential_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.negf %0 : f32 + %2 = func.call @log1pf(%1) : (f32) -> f32 + %3 = arith.negf %2 : f32 + %4 = arith.divf %3, %arg1 : f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_exponential_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_exponential_cpu/raised.mlir new file mode 100644 index 000000000000..b71695e76ea8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exponential_cpu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exponential_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.negf %in : f32 + %1 = math.log1p %0 : f32 + %2 = arith.negf %1 : f32 + %3 = arith.divf %2, %arg1 : f32 + linalg.yield %3 : f32 + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_exponential_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_exponential_cpu_debuf.mlir new file mode 100644 index 000000000000..a0bbd37be29b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exponential_cpu_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exponential_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.negf %in : f32 + %5 = math.log1p %4 : f32 + %6 = arith.negf %5 : f32 + %7 = arith.divf %6, %arg1 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_exponential_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_exponential_cpu_linalg.mlir new file mode 100644 index 000000000000..b71695e76ea8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_exponential_cpu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_exponential_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.negf %in : f32 + %1 = math.log1p %0 : f32 + %2 = arith.negf %1 : f32 + %3 = arith.divf %2, %arg1 : f32 + linalg.yield %3 : f32 + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_eye_cpu.mlir b/issues/aten_c_kernels/results/aten_eye_cpu.mlir new file mode 100644 index 000000000000..936badf790de --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eye_cpu.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eye_cpu(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg1 = 0 to 64 { + %0 = arith.index_cast %arg1 : index to i32 + affine.for %arg2 = 0 to 64 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = arith.cmpi eq, %0, %1 : i32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg0[%arg1, %arg2] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_eye_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_eye_cpu/debuf.mlir new file mode 100644 index 000000000000..43b0f562de6b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eye_cpu/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eye_cpu(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = linalg.index 1 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.cmpi eq, %4, %6 : i32 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.sitofp %8 : i32 to f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c64, %c64] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_eye_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_eye_cpu/matched.mlir new file mode 100644 index 000000000000..43b0f562de6b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eye_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eye_cpu(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = linalg.index 1 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.cmpi eq, %4, %6 : i32 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.sitofp %8 : i32 to f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c64, %c64] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_eye_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_eye_cpu/orig.mlir new file mode 100644 index 000000000000..936badf790de --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eye_cpu/orig.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eye_cpu(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg1 = 0 to 64 { + %0 = arith.index_cast %arg1 : index to i32 + affine.for %arg2 = 0 to 64 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = arith.cmpi eq, %0, %1 : i32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg0[%arg1, %arg2] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_eye_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_eye_cpu/raised.mlir new file mode 100644 index 000000000000..a0f777e882cd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eye_cpu/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eye_cpu(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 0] [%c64, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = arith.index_cast %0 : index to i32 + %2 = linalg.index 1 : index + %3 = arith.index_cast %2 : index to i32 + %4 = arith.cmpi eq, %1, %3 : i32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.sitofp %5 : i32 to f32 + linalg.yield %6 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_eye_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_eye_cpu_debuf.mlir new file mode 100644 index 000000000000..43b0f562de6b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eye_cpu_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eye_cpu(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = linalg.index 1 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.cmpi eq, %4, %6 : i32 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.sitofp %8 : i32 to f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c64, %c64] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_eye_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_eye_cpu_linalg.mlir new file mode 100644 index 000000000000..a0f777e882cd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_eye_cpu_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_eye_cpu(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 0] [%c64, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = arith.index_cast %0 : index to i32 + %2 = linalg.index 1 : index + %3 = arith.index_cast %2 : index to i32 + %4 = arith.cmpi eq, %1, %3 : i32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.sitofp %5 : i32 to f32 + linalg.yield %6 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu.mlir b/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu.mlir new file mode 100644 index 000000000000..c74ea85220e0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fast_cat_dim0_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4 { + affine.for %arg3 = 0 to 256 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + affine.store %0, %arg1[%arg3 + %arg2 * 256] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu/debuf.mlir new file mode 100644 index 000000000000..5fce5827b67f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu/debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 256)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fast_cat_dim0_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c4, %c256] [1, 1] : tensor to tensor + %2 = polygeist.submap(%1, %c4, %c256) {map = #map} : (tensor, index, index) -> tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %4 = polygeist.submapInverse(%1, %3, %c4, %c256) {map = #map} : (tensor, tensor, index, index) -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu/matched.mlir new file mode 100644 index 000000000000..33feb4b6abf5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 256)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fast_cat_dim0_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c4, %c256] [1, 1] : tensor to tensor + %2 = polygeist.submap(%1, %c4, %c256) {map = #map} : (tensor, index, index) -> tensor + %3 = kernel.launch @cudaCopy2D_f32_tensor(%extracted_slice, %2) : (tensor, tensor) -> tensor + %4 = polygeist.submapInverse(%1, %3, %c4, %c256) {map = #map} : (tensor, tensor, index, index) -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu/orig.mlir new file mode 100644 index 000000000000..c74ea85220e0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fast_cat_dim0_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4 { + affine.for %arg3 = 0 to 256 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + affine.store %0, %arg1[%arg3 + %arg2 * 256] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu/raised.mlir new file mode 100644 index 000000000000..93c57cc6db68 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 256)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fast_cat_dim0_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c256 = arith.constant 256 : index + %subview = memref.subview %arg0[0, 0] [%c4, %c256] [1, 1] : memref to memref> + %0 = polygeist.submap(%arg1, %c4, %c256) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%0 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu_debuf.mlir new file mode 100644 index 000000000000..5fce5827b67f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu_debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 256)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fast_cat_dim0_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c4, %c256] [1, 1] : tensor to tensor + %2 = polygeist.submap(%1, %c4, %c256) {map = #map} : (tensor, index, index) -> tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %4 = polygeist.submapInverse(%1, %3, %c4, %c256) {map = #map} : (tensor, tensor, index, index) -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu_linalg.mlir new file mode 100644 index 000000000000..93c57cc6db68 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fast_cat_dim0_cpu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 256)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fast_cat_dim0_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c256 = arith.constant 256 : index + %subview = memref.subview %arg0[0, 0] [%c4, %c256] [1, 1] : memref to memref> + %0 = polygeist.submap(%arg1, %c4, %c256) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%0 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu.mlir b/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu.mlir new file mode 100644 index 000000000000..b6da7a6af718 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fft_conjugate_symmetry_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 129 to 256 { + %0 = affine.load %arg0[-%arg2 + 256] : memref + affine.store %0, %arg0[%arg2] : memref + %1 = affine.load %arg1[-%arg2 + 256] : memref + %2 = arith.negf %1 : f32 + affine.store %2, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu/debuf.mlir new file mode 100644 index 000000000000..da4dd01a7586 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu/debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (-(d0 + 129) + 256)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fft_conjugate_symmetry_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c127 = arith.constant 127 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = polygeist.submap(%1, %c127) {map = #map} : (tensor, index) -> tensor + %extracted_slice = tensor.extract_slice %1[129] [%c127] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[129] [%c127] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg0 : memref to memref + %5 = polygeist.submap(%0, %c127) {map = #map} : (tensor, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %0[129] [%c127] [1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%5 : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %8 = arith.negf %in : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice_1 = tensor.insert_slice %6 into %0[129] [%c127] [1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice_1 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu/matched.mlir new file mode 100644 index 000000000000..da4dd01a7586 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu/matched.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (-(d0 + 129) + 256)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fft_conjugate_symmetry_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c127 = arith.constant 127 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = polygeist.submap(%1, %c127) {map = #map} : (tensor, index) -> tensor + %extracted_slice = tensor.extract_slice %1[129] [%c127] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[129] [%c127] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg0 : memref to memref + %5 = polygeist.submap(%0, %c127) {map = #map} : (tensor, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %0[129] [%c127] [1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%5 : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %8 = arith.negf %in : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice_1 = tensor.insert_slice %6 into %0[129] [%c127] [1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice_1 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu/orig.mlir new file mode 100644 index 000000000000..b6da7a6af718 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fft_conjugate_symmetry_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 129 to 256 { + %0 = affine.load %arg0[-%arg2 + 256] : memref + affine.store %0, %arg0[%arg2] : memref + %1 = affine.load %arg1[-%arg2 + 256] : memref + %2 = arith.negf %1 : f32 + affine.store %2, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu/raised.mlir new file mode 100644 index 000000000000..98d730ac0303 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu/raised.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (-(d0 + 129) + 256)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fft_conjugate_symmetry_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c127 = arith.constant 127 : index + %0 = polygeist.submap(%arg0, %c127) {map = #map} : (memref, index) -> memref + %subview = memref.subview %arg0[129] [%c127] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %1 = polygeist.submap(%arg1, %c127) {map = #map} : (memref, index) -> memref + %subview_0 = memref.subview %arg1[129] [%c127] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%1 : memref) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %2 = arith.negf %in : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu_debuf.mlir new file mode 100644 index 000000000000..da4dd01a7586 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu_debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (-(d0 + 129) + 256)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fft_conjugate_symmetry_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c127 = arith.constant 127 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = polygeist.submap(%1, %c127) {map = #map} : (tensor, index) -> tensor + %extracted_slice = tensor.extract_slice %1[129] [%c127] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[129] [%c127] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg0 : memref to memref + %5 = polygeist.submap(%0, %c127) {map = #map} : (tensor, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %0[129] [%c127] [1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%5 : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %8 = arith.negf %in : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice_1 = tensor.insert_slice %6 into %0[129] [%c127] [1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice_1 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu_linalg.mlir new file mode 100644 index 000000000000..98d730ac0303 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fft_conjugate_symmetry_cpu_linalg.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (-(d0 + 129) + 256)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fft_conjugate_symmetry_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c127 = arith.constant 127 : index + %0 = polygeist.submap(%arg0, %c127) {map = #map} : (memref, index) -> memref + %subview = memref.subview %arg0[129] [%c127] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %1 = polygeist.submap(%arg1, %c127) {map = #map} : (memref, index) -> memref + %subview_0 = memref.subview %arg1[129] [%c127] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%1 : memref) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %2 = arith.negf %in : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fftshift_cpu.mlir b/issues/aten_c_kernels/results/aten_fftshift_cpu.mlir new file mode 100644 index 000000000000..5a6b7ae6644b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fftshift_cpu.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fftshift_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-129 = arith.constant -129 : index + %c-256 = arith.constant -256 : index + %c-1 = arith.constant -1 : index + %c128 = arith.constant 128 : index + %c0 = arith.constant 0 : index + %c256 = arith.constant 256 : index + affine.for %arg2 = 0 to 256 { + %0 = arith.addi %arg2, %c128 : index + %1 = arith.cmpi slt, %0, %c0 : index + %2 = arith.subi %c-129, %arg2 : index + %3 = arith.select %1, %2, %0 : index + %4 = arith.divsi %3, %c256 : index + %5 = arith.subi %c-1, %4 : index + %6 = arith.select %1, %5, %4 : index + %7 = arith.muli %6, %c-256 : index + %8 = arith.addi %arg2, %7 : index + %9 = arith.addi %8, %c128 : index + %10 = memref.load %arg0[%9] : memref + affine.store %10, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fftshift_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_fftshift_cpu/debuf.mlir new file mode 100644 index 000000000000..2e1320c5a4ca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fftshift_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fftshift_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c128 = arith.constant 128 : index + %c-1 = arith.constant -1 : index + %c-256 = arith.constant -256 : index + %c-129 = arith.constant -129 : index + %c0 = arith.constant 0 : index + %c256 = arith.constant 256 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.addi %3, %c128 : index + %5 = arith.cmpi slt, %4, %c0 : index + %6 = arith.subi %c-129, %3 : index + %7 = arith.select %5, %6, %4 : index + %8 = arith.divsi %7, %c256 : index + %9 = arith.subi %c-1, %8 : index + %10 = arith.select %5, %9, %8 : index + %11 = arith.muli %10, %c-256 : index + %12 = arith.addi %3, %11 : index + %13 = arith.addi %12, %c128 : index + %14 = memref.load %arg0[%13] : memref + linalg.yield %14 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fftshift_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_fftshift_cpu/matched.mlir new file mode 100644 index 000000000000..2e1320c5a4ca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fftshift_cpu/matched.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fftshift_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c128 = arith.constant 128 : index + %c-1 = arith.constant -1 : index + %c-256 = arith.constant -256 : index + %c-129 = arith.constant -129 : index + %c0 = arith.constant 0 : index + %c256 = arith.constant 256 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.addi %3, %c128 : index + %5 = arith.cmpi slt, %4, %c0 : index + %6 = arith.subi %c-129, %3 : index + %7 = arith.select %5, %6, %4 : index + %8 = arith.divsi %7, %c256 : index + %9 = arith.subi %c-1, %8 : index + %10 = arith.select %5, %9, %8 : index + %11 = arith.muli %10, %c-256 : index + %12 = arith.addi %3, %11 : index + %13 = arith.addi %12, %c128 : index + %14 = memref.load %arg0[%13] : memref + linalg.yield %14 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fftshift_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_fftshift_cpu/orig.mlir new file mode 100644 index 000000000000..5a6b7ae6644b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fftshift_cpu/orig.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fftshift_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-129 = arith.constant -129 : index + %c-256 = arith.constant -256 : index + %c-1 = arith.constant -1 : index + %c128 = arith.constant 128 : index + %c0 = arith.constant 0 : index + %c256 = arith.constant 256 : index + affine.for %arg2 = 0 to 256 { + %0 = arith.addi %arg2, %c128 : index + %1 = arith.cmpi slt, %0, %c0 : index + %2 = arith.subi %c-129, %arg2 : index + %3 = arith.select %1, %2, %0 : index + %4 = arith.divsi %3, %c256 : index + %5 = arith.subi %c-1, %4 : index + %6 = arith.select %1, %5, %4 : index + %7 = arith.muli %6, %c-256 : index + %8 = arith.addi %arg2, %7 : index + %9 = arith.addi %8, %c128 : index + %10 = memref.load %arg0[%9] : memref + affine.store %10, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fftshift_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_fftshift_cpu/raised.mlir new file mode 100644 index 000000000000..4a8140fa4619 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fftshift_cpu/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fftshift_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %c0 = arith.constant 0 : index + %c-129 = arith.constant -129 : index + %c-256 = arith.constant -256 : index + %c-1 = arith.constant -1 : index + %c128 = arith.constant 128 : index + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = arith.addi %0, %c128 : index + %2 = arith.cmpi slt, %1, %c0 : index + %3 = arith.subi %c-129, %0 : index + %4 = arith.select %2, %3, %1 : index + %5 = arith.divsi %4, %c256 : index + %6 = arith.subi %c-1, %5 : index + %7 = arith.select %2, %6, %5 : index + %8 = arith.muli %7, %c-256 : index + %9 = arith.addi %0, %8 : index + %10 = arith.addi %9, %c128 : index + %11 = memref.load %arg0[%10] : memref + linalg.yield %11 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fftshift_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_fftshift_cpu_debuf.mlir new file mode 100644 index 000000000000..2e1320c5a4ca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fftshift_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fftshift_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c128 = arith.constant 128 : index + %c-1 = arith.constant -1 : index + %c-256 = arith.constant -256 : index + %c-129 = arith.constant -129 : index + %c0 = arith.constant 0 : index + %c256 = arith.constant 256 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.addi %3, %c128 : index + %5 = arith.cmpi slt, %4, %c0 : index + %6 = arith.subi %c-129, %3 : index + %7 = arith.select %5, %6, %4 : index + %8 = arith.divsi %7, %c256 : index + %9 = arith.subi %c-1, %8 : index + %10 = arith.select %5, %9, %8 : index + %11 = arith.muli %10, %c-256 : index + %12 = arith.addi %3, %11 : index + %13 = arith.addi %12, %c128 : index + %14 = memref.load %arg0[%13] : memref + linalg.yield %14 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fftshift_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_fftshift_cpu_linalg.mlir new file mode 100644 index 000000000000..4a8140fa4619 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fftshift_cpu_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fftshift_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %c0 = arith.constant 0 : index + %c-129 = arith.constant -129 : index + %c-256 = arith.constant -256 : index + %c-1 = arith.constant -1 : index + %c128 = arith.constant 128 : index + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = arith.addi %0, %c128 : index + %2 = arith.cmpi slt, %1, %c0 : index + %3 = arith.subi %c-129, %0 : index + %4 = arith.select %2, %3, %1 : index + %5 = arith.divsi %4, %c256 : index + %6 = arith.subi %c-1, %5 : index + %7 = arith.select %2, %6, %5 : index + %8 = arith.muli %7, %c-256 : index + %9 = arith.addi %0, %8 : index + %10 = arith.addi %9, %c128 : index + %11 = memref.load %arg0[%10] : memref + linalg.yield %11 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fill.mlir b/issues/aten_c_kernels/results/aten_fill.mlir new file mode 100644 index 000000000000..2c181778a333 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fill.mlir @@ -0,0 +1,8 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fill(%arg0: f32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + affine.store %arg0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fill/debuf.mlir b/issues/aten_c_kernels/results/aten_fill/debuf.mlir new file mode 100644 index 000000000000..e527cd4c0f60 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fill/debuf.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fill(%arg0: f32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %arg0 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fill/matched.mlir b/issues/aten_c_kernels/results/aten_fill/matched.mlir new file mode 100644 index 000000000000..e527cd4c0f60 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fill/matched.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fill(%arg0: f32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %arg0 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fill/orig.mlir b/issues/aten_c_kernels/results/aten_fill/orig.mlir new file mode 100644 index 000000000000..2c181778a333 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fill/orig.mlir @@ -0,0 +1,8 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fill(%arg0: f32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + affine.store %arg0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fill/raised.mlir b/issues/aten_c_kernels/results/aten_fill/raised.mlir new file mode 100644 index 000000000000..6031b78f0ed2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fill/raised.mlir @@ -0,0 +1,11 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fill(%arg0: f32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %arg0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fill_debuf.mlir b/issues/aten_c_kernels/results/aten_fill_debuf.mlir new file mode 100644 index 000000000000..e527cd4c0f60 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fill_debuf.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fill(%arg0: f32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %arg0 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fill_diagonal_cpu.mlir b/issues/aten_c_kernels/results/aten_fill_diagonal_cpu.mlir new file mode 100644 index 000000000000..7b2f7b2fd431 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fill_diagonal_cpu.mlir @@ -0,0 +1,8 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fill_diagonal_cpu(%arg0: memref, %arg1: f32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 32 { + affine.store %arg1, %arg0[%arg2, %arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fill_diagonal_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_fill_diagonal_cpu/debuf.mlir new file mode 100644 index 000000000000..88b59054a1b8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fill_diagonal_cpu/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0, d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fill_diagonal_cpu(%arg0: memref, %arg1: f32) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c32] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %arg1 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c32] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fill_diagonal_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_fill_diagonal_cpu/matched.mlir new file mode 100644 index 000000000000..88b59054a1b8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fill_diagonal_cpu/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0, d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fill_diagonal_cpu(%arg0: memref, %arg1: f32) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c32] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %arg1 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c32] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fill_diagonal_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_fill_diagonal_cpu/orig.mlir new file mode 100644 index 000000000000..7b2f7b2fd431 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fill_diagonal_cpu/orig.mlir @@ -0,0 +1,8 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fill_diagonal_cpu(%arg0: memref, %arg1: f32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 32 { + affine.store %arg1, %arg0[%arg2, %arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fill_diagonal_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_fill_diagonal_cpu/raised.mlir new file mode 100644 index 000000000000..fcfc8b149132 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fill_diagonal_cpu/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0, d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fill_diagonal_cpu(%arg0: memref, %arg1: f32) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %subview = memref.subview %arg0[0, 0] [%c32, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %arg1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fill_diagonal_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_fill_diagonal_cpu_debuf.mlir new file mode 100644 index 000000000000..88b59054a1b8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fill_diagonal_cpu_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0, d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fill_diagonal_cpu(%arg0: memref, %arg1: f32) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c32] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %arg1 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c32] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fill_diagonal_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_fill_diagonal_cpu_linalg.mlir new file mode 100644 index 000000000000..fcfc8b149132 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fill_diagonal_cpu_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0, d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fill_diagonal_cpu(%arg0: memref, %arg1: f32) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %subview = memref.subview %arg0[0, 0] [%c32, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %arg1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fill_linalg.mlir b/issues/aten_c_kernels/results/aten_fill_linalg.mlir new file mode 100644 index 000000000000..6031b78f0ed2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fill_linalg.mlir @@ -0,0 +1,11 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fill(%arg0: f32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %arg0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu.mlir new file mode 100644 index 000000000000..443bcda735ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu.mlir @@ -0,0 +1,90 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flash_attention_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.176776692 : f32 + %cst_0 = arith.constant -3.40282347E+38 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref<16xf32> + %alloca_2 = memref.alloca() : memref<16xf32> + %0 = "polygeist.memref2pointer"(%arg4) : (memref) -> !llvm.ptr + affine.for %arg7 = 0 to 1024 { + %3 = arith.index_cast %arg7 : index to i32 + %4 = llvm.getelementptr %0[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %4 : f32, !llvm.ptr + } + %1 = "polygeist.memref2pointer"(%arg5) : (memref) -> !llvm.ptr + %2 = "polygeist.memref2pointer"(%arg6) : (memref) -> !llvm.ptr + affine.for %arg7 = 0 to 1024 { + %3 = arith.index_cast %arg7 : index to i32 + %4 = llvm.getelementptr %1[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %4 : f32, !llvm.ptr + %5 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %5 : f32, !llvm.ptr + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 16 { + %3 = affine.for %arg9 = 0 to 16 iter_args(%arg10 = %cst_0) -> (f32) { + %6 = affine.for %arg11 = 0 to 32 iter_args(%arg12 = %cst_1) -> (f32) { + %10 = affine.load %arg0[0, %arg7, %arg8, %arg11] : memref + %11 = affine.load %arg1[0, %arg7, %arg9, %arg11] : memref + %12 = arith.mulf %10, %11 : f32 + %13 = arith.addf %arg12, %12 : f32 + affine.yield %13 : f32 + } + %7 = arith.mulf %6, %cst : f32 + affine.store %7, %alloca_2[%arg9] : memref<16xf32> + %8 = arith.cmpf ogt, %7, %arg10 : f32 + %9 = arith.select %8, %7, %arg10 : f32 + affine.yield %9 : f32 + } + %4 = affine.for %arg9 = 0 to 16 iter_args(%arg10 = %cst_1) -> (f32) { + %6 = affine.load %alloca_2[%arg9] : memref<16xf32> + %7 = arith.subf %6, %3 : f32 + %8 = math.exp %7 : f32 + affine.store %8, %alloca_2[%arg9] : memref<16xf32> + %9 = arith.addf %arg10, %8 : f32 + affine.yield %9 : f32 + } + %5 = affine.for %arg9 = 0 to 16 iter_args(%arg10 = %cst_1) -> (f32) { + %6 = affine.load %alloca_2[%arg9] : memref<16xf32> + %7 = arith.divf %6, %4 : f32 + affine.store %7, %alloca_2[%arg9] : memref<16xf32> + %8 = affine.for %arg11 = 0 to 32 iter_args(%arg12 = %cst_1) -> (f32) { + %11 = affine.load %arg3[0, %arg7, %arg8, %arg11] : memref + %12 = affine.load %arg2[0, %arg7, %arg9, %arg11] : memref + %13 = arith.mulf %11, %12 : f32 + %14 = arith.addf %arg12, %13 : f32 + %15 = arith.mulf %7, %11 : f32 + %16 = affine.load %arg6[0, %arg7, %arg9, %arg11] : memref + %17 = arith.addf %16, %15 : f32 + affine.store %17, %arg6[0, %arg7, %arg9, %arg11] : memref + affine.yield %14 : f32 + } + affine.store %8, %alloca[%arg9] : memref<16xf32> + %9 = arith.mulf %8, %7 : f32 + %10 = arith.addf %arg10, %9 : f32 + affine.yield %10 : f32 + } + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_2[%arg9] : memref<16xf32> + %7 = affine.load %alloca[%arg9] : memref<16xf32> + %8 = arith.subf %7, %5 : f32 + %9 = arith.mulf %6, %8 : f32 + %10 = arith.mulf %9, %cst : f32 + affine.for %arg10 = 0 to 32 { + %11 = affine.load %arg1[0, %arg7, %arg9, %arg10] : memref + %12 = arith.mulf %10, %11 : f32 + %13 = affine.load %arg4[0, %arg7, %arg8, %arg10] : memref + %14 = arith.addf %13, %12 : f32 + affine.store %14, %arg4[0, %arg7, %arg8, %arg10] : memref + %15 = affine.load %arg0[0, %arg7, %arg8, %arg10] : memref + %16 = arith.mulf %10, %15 : f32 + %17 = affine.load %arg5[0, %arg7, %arg9, %arg10] : memref + %18 = arith.addf %17, %16 : f32 + affine.store %18, %arg5[0, %arg7, %arg9, %arg10] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..a09b20a64a8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu/debuf.mlir @@ -0,0 +1,120 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flash_attention_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 0.176776692 : f32 + %cst_0 = arith.constant -3.40282347E+38 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref<16xf32> + %alloca_2 = memref.alloca() : memref<16xf32> + %0 = "polygeist.memref2pointer"(%arg4) : (memref) -> !llvm.ptr + affine.for %arg7 = 0 to 1024 { + %3 = arith.index_cast %arg7 : index to i32 + %4 = llvm.getelementptr %0[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %4 : f32, !llvm.ptr + } + %1 = "polygeist.memref2pointer"(%arg5) : (memref) -> !llvm.ptr + %2 = "polygeist.memref2pointer"(%arg6) : (memref) -> !llvm.ptr + affine.for %arg7 = 0 to 1024 { + %3 = arith.index_cast %arg7 : index to i32 + %4 = llvm.getelementptr %1[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %4 : f32, !llvm.ptr + %5 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %5 : f32, !llvm.ptr + } + affine.for %arg7 = 0 to 2 { + %alloca_3 = memref.alloca(%c16) : memref + %alloca_4 = memref.alloca(%c16) : memref + %alloca_5 = memref.alloca(%c16) : memref + affine.for %arg8 = 0 to 16 { + affine.store %cst_0, %alloca_3[%arg8] : memref + %alloca_6 = memref.alloca(%c16) : memref + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_3[%arg8] : memref + affine.store %cst_1, %alloca_6[%arg9] : memref + %subview_9 = memref.subview %arg0[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg1[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_11 = memref.subview %alloca_6[%arg9] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview_9, %subview_10 : memref>, memref>) outs(%subview_11 : memref>) { + ^bb0(%in: f32, %in_12: f32, %out: f32): + %11 = arith.mulf %in, %in_12 : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + %7 = affine.load %alloca_6[%arg9] : memref + %8 = arith.mulf %7, %cst : f32 + affine.store %8, %alloca_2[%arg9] : memref<16xf32> + %9 = arith.cmpf ogt, %8, %6 : f32 + %10 = arith.select %9, %8, %6 : f32 + affine.store %10, %alloca_3[%arg8] : memref + } + %3 = affine.load %alloca_3[%arg8] : memref + affine.store %cst_1, %alloca_4[%arg8] : memref + %subview = memref.subview %alloca_2[0] [%c16] [1] : memref<16xf32> to memref> + %subview_7 = memref.subview %alloca_4[%arg8] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} outs(%subview, %subview_7 : memref>, memref>) { + ^bb0(%out: f32, %out_9: f32): + %6 = arith.subf %out, %3 : f32 + %7 = math.exp %6 : f32 + %8 = arith.addf %out_9, %7 : f32 + linalg.yield %7, %8 : f32, f32 + } + %4 = affine.load %alloca_4[%arg8] : memref + affine.store %cst_1, %alloca_5[%arg8] : memref + %alloca_8 = memref.alloca(%c16) : memref + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_5[%arg8] : memref + %7 = affine.load %alloca_2[%arg9] : memref<16xf32> + %8 = arith.divf %7, %4 : f32 + affine.store %8, %alloca_2[%arg9] : memref<16xf32> + affine.store %cst_1, %alloca_8[%arg9] : memref + %subview_9 = memref.subview %arg3[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg2[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_11 = memref.subview %arg6[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %alloca_8[%arg9] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map1], iterator_types = ["reduction"]} ins(%subview_9, %subview_10 : memref>, memref>) outs(%subview_11, %subview_12 : memref>, memref>) { + ^bb0(%in: f32, %in_13: f32, %out: f32, %out_14: f32): + %12 = arith.mulf %in, %in_13 : f32 + %13 = arith.addf %out_14, %12 : f32 + %14 = arith.mulf %8, %in : f32 + %15 = arith.addf %out, %14 : f32 + linalg.yield %15, %13 : f32, f32 + } + %9 = affine.load %alloca_8[%arg9] : memref + affine.store %9, %alloca[%arg9] : memref<16xf32> + %10 = arith.mulf %9, %8 : f32 + %11 = arith.addf %6, %10 : f32 + affine.store %11, %alloca_5[%arg8] : memref + } + %5 = affine.load %alloca_5[%arg8] : memref + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_2[%arg9] : memref<16xf32> + %7 = affine.load %alloca[%arg9] : memref<16xf32> + %8 = arith.subf %7, %5 : f32 + %9 = arith.mulf %6, %8 : f32 + %10 = arith.mulf %9, %cst : f32 + %subview_9 = memref.subview %arg1[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg4[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_9 : memref>) outs(%subview_10 : memref>) { + ^bb0(%in: f32, %out: f32): + %11 = arith.mulf %10, %in : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + %subview_11 = memref.subview %arg0[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %arg5[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_11 : memref>) outs(%subview_12 : memref>) { + ^bb0(%in: f32, %out: f32): + %11 = arith.mulf %10, %in : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu/matched.mlir new file mode 100644 index 000000000000..a09b20a64a8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu/matched.mlir @@ -0,0 +1,120 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flash_attention_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 0.176776692 : f32 + %cst_0 = arith.constant -3.40282347E+38 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref<16xf32> + %alloca_2 = memref.alloca() : memref<16xf32> + %0 = "polygeist.memref2pointer"(%arg4) : (memref) -> !llvm.ptr + affine.for %arg7 = 0 to 1024 { + %3 = arith.index_cast %arg7 : index to i32 + %4 = llvm.getelementptr %0[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %4 : f32, !llvm.ptr + } + %1 = "polygeist.memref2pointer"(%arg5) : (memref) -> !llvm.ptr + %2 = "polygeist.memref2pointer"(%arg6) : (memref) -> !llvm.ptr + affine.for %arg7 = 0 to 1024 { + %3 = arith.index_cast %arg7 : index to i32 + %4 = llvm.getelementptr %1[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %4 : f32, !llvm.ptr + %5 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %5 : f32, !llvm.ptr + } + affine.for %arg7 = 0 to 2 { + %alloca_3 = memref.alloca(%c16) : memref + %alloca_4 = memref.alloca(%c16) : memref + %alloca_5 = memref.alloca(%c16) : memref + affine.for %arg8 = 0 to 16 { + affine.store %cst_0, %alloca_3[%arg8] : memref + %alloca_6 = memref.alloca(%c16) : memref + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_3[%arg8] : memref + affine.store %cst_1, %alloca_6[%arg9] : memref + %subview_9 = memref.subview %arg0[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg1[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_11 = memref.subview %alloca_6[%arg9] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview_9, %subview_10 : memref>, memref>) outs(%subview_11 : memref>) { + ^bb0(%in: f32, %in_12: f32, %out: f32): + %11 = arith.mulf %in, %in_12 : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + %7 = affine.load %alloca_6[%arg9] : memref + %8 = arith.mulf %7, %cst : f32 + affine.store %8, %alloca_2[%arg9] : memref<16xf32> + %9 = arith.cmpf ogt, %8, %6 : f32 + %10 = arith.select %9, %8, %6 : f32 + affine.store %10, %alloca_3[%arg8] : memref + } + %3 = affine.load %alloca_3[%arg8] : memref + affine.store %cst_1, %alloca_4[%arg8] : memref + %subview = memref.subview %alloca_2[0] [%c16] [1] : memref<16xf32> to memref> + %subview_7 = memref.subview %alloca_4[%arg8] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} outs(%subview, %subview_7 : memref>, memref>) { + ^bb0(%out: f32, %out_9: f32): + %6 = arith.subf %out, %3 : f32 + %7 = math.exp %6 : f32 + %8 = arith.addf %out_9, %7 : f32 + linalg.yield %7, %8 : f32, f32 + } + %4 = affine.load %alloca_4[%arg8] : memref + affine.store %cst_1, %alloca_5[%arg8] : memref + %alloca_8 = memref.alloca(%c16) : memref + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_5[%arg8] : memref + %7 = affine.load %alloca_2[%arg9] : memref<16xf32> + %8 = arith.divf %7, %4 : f32 + affine.store %8, %alloca_2[%arg9] : memref<16xf32> + affine.store %cst_1, %alloca_8[%arg9] : memref + %subview_9 = memref.subview %arg3[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg2[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_11 = memref.subview %arg6[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %alloca_8[%arg9] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map1], iterator_types = ["reduction"]} ins(%subview_9, %subview_10 : memref>, memref>) outs(%subview_11, %subview_12 : memref>, memref>) { + ^bb0(%in: f32, %in_13: f32, %out: f32, %out_14: f32): + %12 = arith.mulf %in, %in_13 : f32 + %13 = arith.addf %out_14, %12 : f32 + %14 = arith.mulf %8, %in : f32 + %15 = arith.addf %out, %14 : f32 + linalg.yield %15, %13 : f32, f32 + } + %9 = affine.load %alloca_8[%arg9] : memref + affine.store %9, %alloca[%arg9] : memref<16xf32> + %10 = arith.mulf %9, %8 : f32 + %11 = arith.addf %6, %10 : f32 + affine.store %11, %alloca_5[%arg8] : memref + } + %5 = affine.load %alloca_5[%arg8] : memref + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_2[%arg9] : memref<16xf32> + %7 = affine.load %alloca[%arg9] : memref<16xf32> + %8 = arith.subf %7, %5 : f32 + %9 = arith.mulf %6, %8 : f32 + %10 = arith.mulf %9, %cst : f32 + %subview_9 = memref.subview %arg1[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg4[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_9 : memref>) outs(%subview_10 : memref>) { + ^bb0(%in: f32, %out: f32): + %11 = arith.mulf %10, %in : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + %subview_11 = memref.subview %arg0[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %arg5[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_11 : memref>) outs(%subview_12 : memref>) { + ^bb0(%in: f32, %out: f32): + %11 = arith.mulf %10, %in : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu/orig.mlir new file mode 100644 index 000000000000..443bcda735ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu/orig.mlir @@ -0,0 +1,90 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flash_attention_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.176776692 : f32 + %cst_0 = arith.constant -3.40282347E+38 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref<16xf32> + %alloca_2 = memref.alloca() : memref<16xf32> + %0 = "polygeist.memref2pointer"(%arg4) : (memref) -> !llvm.ptr + affine.for %arg7 = 0 to 1024 { + %3 = arith.index_cast %arg7 : index to i32 + %4 = llvm.getelementptr %0[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %4 : f32, !llvm.ptr + } + %1 = "polygeist.memref2pointer"(%arg5) : (memref) -> !llvm.ptr + %2 = "polygeist.memref2pointer"(%arg6) : (memref) -> !llvm.ptr + affine.for %arg7 = 0 to 1024 { + %3 = arith.index_cast %arg7 : index to i32 + %4 = llvm.getelementptr %1[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %4 : f32, !llvm.ptr + %5 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %5 : f32, !llvm.ptr + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 16 { + %3 = affine.for %arg9 = 0 to 16 iter_args(%arg10 = %cst_0) -> (f32) { + %6 = affine.for %arg11 = 0 to 32 iter_args(%arg12 = %cst_1) -> (f32) { + %10 = affine.load %arg0[0, %arg7, %arg8, %arg11] : memref + %11 = affine.load %arg1[0, %arg7, %arg9, %arg11] : memref + %12 = arith.mulf %10, %11 : f32 + %13 = arith.addf %arg12, %12 : f32 + affine.yield %13 : f32 + } + %7 = arith.mulf %6, %cst : f32 + affine.store %7, %alloca_2[%arg9] : memref<16xf32> + %8 = arith.cmpf ogt, %7, %arg10 : f32 + %9 = arith.select %8, %7, %arg10 : f32 + affine.yield %9 : f32 + } + %4 = affine.for %arg9 = 0 to 16 iter_args(%arg10 = %cst_1) -> (f32) { + %6 = affine.load %alloca_2[%arg9] : memref<16xf32> + %7 = arith.subf %6, %3 : f32 + %8 = math.exp %7 : f32 + affine.store %8, %alloca_2[%arg9] : memref<16xf32> + %9 = arith.addf %arg10, %8 : f32 + affine.yield %9 : f32 + } + %5 = affine.for %arg9 = 0 to 16 iter_args(%arg10 = %cst_1) -> (f32) { + %6 = affine.load %alloca_2[%arg9] : memref<16xf32> + %7 = arith.divf %6, %4 : f32 + affine.store %7, %alloca_2[%arg9] : memref<16xf32> + %8 = affine.for %arg11 = 0 to 32 iter_args(%arg12 = %cst_1) -> (f32) { + %11 = affine.load %arg3[0, %arg7, %arg8, %arg11] : memref + %12 = affine.load %arg2[0, %arg7, %arg9, %arg11] : memref + %13 = arith.mulf %11, %12 : f32 + %14 = arith.addf %arg12, %13 : f32 + %15 = arith.mulf %7, %11 : f32 + %16 = affine.load %arg6[0, %arg7, %arg9, %arg11] : memref + %17 = arith.addf %16, %15 : f32 + affine.store %17, %arg6[0, %arg7, %arg9, %arg11] : memref + affine.yield %14 : f32 + } + affine.store %8, %alloca[%arg9] : memref<16xf32> + %9 = arith.mulf %8, %7 : f32 + %10 = arith.addf %arg10, %9 : f32 + affine.yield %10 : f32 + } + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_2[%arg9] : memref<16xf32> + %7 = affine.load %alloca[%arg9] : memref<16xf32> + %8 = arith.subf %7, %5 : f32 + %9 = arith.mulf %6, %8 : f32 + %10 = arith.mulf %9, %cst : f32 + affine.for %arg10 = 0 to 32 { + %11 = affine.load %arg1[0, %arg7, %arg9, %arg10] : memref + %12 = arith.mulf %10, %11 : f32 + %13 = affine.load %arg4[0, %arg7, %arg8, %arg10] : memref + %14 = arith.addf %13, %12 : f32 + affine.store %14, %arg4[0, %arg7, %arg8, %arg10] : memref + %15 = affine.load %arg0[0, %arg7, %arg8, %arg10] : memref + %16 = arith.mulf %10, %15 : f32 + %17 = affine.load %arg5[0, %arg7, %arg9, %arg10] : memref + %18 = arith.addf %17, %16 : f32 + affine.store %18, %arg5[0, %arg7, %arg9, %arg10] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu/raised.mlir new file mode 100644 index 000000000000..a09b20a64a8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu/raised.mlir @@ -0,0 +1,120 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flash_attention_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 0.176776692 : f32 + %cst_0 = arith.constant -3.40282347E+38 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref<16xf32> + %alloca_2 = memref.alloca() : memref<16xf32> + %0 = "polygeist.memref2pointer"(%arg4) : (memref) -> !llvm.ptr + affine.for %arg7 = 0 to 1024 { + %3 = arith.index_cast %arg7 : index to i32 + %4 = llvm.getelementptr %0[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %4 : f32, !llvm.ptr + } + %1 = "polygeist.memref2pointer"(%arg5) : (memref) -> !llvm.ptr + %2 = "polygeist.memref2pointer"(%arg6) : (memref) -> !llvm.ptr + affine.for %arg7 = 0 to 1024 { + %3 = arith.index_cast %arg7 : index to i32 + %4 = llvm.getelementptr %1[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %4 : f32, !llvm.ptr + %5 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %5 : f32, !llvm.ptr + } + affine.for %arg7 = 0 to 2 { + %alloca_3 = memref.alloca(%c16) : memref + %alloca_4 = memref.alloca(%c16) : memref + %alloca_5 = memref.alloca(%c16) : memref + affine.for %arg8 = 0 to 16 { + affine.store %cst_0, %alloca_3[%arg8] : memref + %alloca_6 = memref.alloca(%c16) : memref + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_3[%arg8] : memref + affine.store %cst_1, %alloca_6[%arg9] : memref + %subview_9 = memref.subview %arg0[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg1[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_11 = memref.subview %alloca_6[%arg9] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview_9, %subview_10 : memref>, memref>) outs(%subview_11 : memref>) { + ^bb0(%in: f32, %in_12: f32, %out: f32): + %11 = arith.mulf %in, %in_12 : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + %7 = affine.load %alloca_6[%arg9] : memref + %8 = arith.mulf %7, %cst : f32 + affine.store %8, %alloca_2[%arg9] : memref<16xf32> + %9 = arith.cmpf ogt, %8, %6 : f32 + %10 = arith.select %9, %8, %6 : f32 + affine.store %10, %alloca_3[%arg8] : memref + } + %3 = affine.load %alloca_3[%arg8] : memref + affine.store %cst_1, %alloca_4[%arg8] : memref + %subview = memref.subview %alloca_2[0] [%c16] [1] : memref<16xf32> to memref> + %subview_7 = memref.subview %alloca_4[%arg8] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} outs(%subview, %subview_7 : memref>, memref>) { + ^bb0(%out: f32, %out_9: f32): + %6 = arith.subf %out, %3 : f32 + %7 = math.exp %6 : f32 + %8 = arith.addf %out_9, %7 : f32 + linalg.yield %7, %8 : f32, f32 + } + %4 = affine.load %alloca_4[%arg8] : memref + affine.store %cst_1, %alloca_5[%arg8] : memref + %alloca_8 = memref.alloca(%c16) : memref + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_5[%arg8] : memref + %7 = affine.load %alloca_2[%arg9] : memref<16xf32> + %8 = arith.divf %7, %4 : f32 + affine.store %8, %alloca_2[%arg9] : memref<16xf32> + affine.store %cst_1, %alloca_8[%arg9] : memref + %subview_9 = memref.subview %arg3[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg2[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_11 = memref.subview %arg6[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %alloca_8[%arg9] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map1], iterator_types = ["reduction"]} ins(%subview_9, %subview_10 : memref>, memref>) outs(%subview_11, %subview_12 : memref>, memref>) { + ^bb0(%in: f32, %in_13: f32, %out: f32, %out_14: f32): + %12 = arith.mulf %in, %in_13 : f32 + %13 = arith.addf %out_14, %12 : f32 + %14 = arith.mulf %8, %in : f32 + %15 = arith.addf %out, %14 : f32 + linalg.yield %15, %13 : f32, f32 + } + %9 = affine.load %alloca_8[%arg9] : memref + affine.store %9, %alloca[%arg9] : memref<16xf32> + %10 = arith.mulf %9, %8 : f32 + %11 = arith.addf %6, %10 : f32 + affine.store %11, %alloca_5[%arg8] : memref + } + %5 = affine.load %alloca_5[%arg8] : memref + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_2[%arg9] : memref<16xf32> + %7 = affine.load %alloca[%arg9] : memref<16xf32> + %8 = arith.subf %7, %5 : f32 + %9 = arith.mulf %6, %8 : f32 + %10 = arith.mulf %9, %cst : f32 + %subview_9 = memref.subview %arg1[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg4[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_9 : memref>) outs(%subview_10 : memref>) { + ^bb0(%in: f32, %out: f32): + %11 = arith.mulf %10, %in : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + %subview_11 = memref.subview %arg0[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %arg5[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_11 : memref>) outs(%subview_12 : memref>) { + ^bb0(%in: f32, %out: f32): + %11 = arith.mulf %10, %in : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..a09b20a64a8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu_debuf.mlir @@ -0,0 +1,120 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flash_attention_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 0.176776692 : f32 + %cst_0 = arith.constant -3.40282347E+38 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref<16xf32> + %alloca_2 = memref.alloca() : memref<16xf32> + %0 = "polygeist.memref2pointer"(%arg4) : (memref) -> !llvm.ptr + affine.for %arg7 = 0 to 1024 { + %3 = arith.index_cast %arg7 : index to i32 + %4 = llvm.getelementptr %0[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %4 : f32, !llvm.ptr + } + %1 = "polygeist.memref2pointer"(%arg5) : (memref) -> !llvm.ptr + %2 = "polygeist.memref2pointer"(%arg6) : (memref) -> !llvm.ptr + affine.for %arg7 = 0 to 1024 { + %3 = arith.index_cast %arg7 : index to i32 + %4 = llvm.getelementptr %1[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %4 : f32, !llvm.ptr + %5 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %5 : f32, !llvm.ptr + } + affine.for %arg7 = 0 to 2 { + %alloca_3 = memref.alloca(%c16) : memref + %alloca_4 = memref.alloca(%c16) : memref + %alloca_5 = memref.alloca(%c16) : memref + affine.for %arg8 = 0 to 16 { + affine.store %cst_0, %alloca_3[%arg8] : memref + %alloca_6 = memref.alloca(%c16) : memref + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_3[%arg8] : memref + affine.store %cst_1, %alloca_6[%arg9] : memref + %subview_9 = memref.subview %arg0[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg1[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_11 = memref.subview %alloca_6[%arg9] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview_9, %subview_10 : memref>, memref>) outs(%subview_11 : memref>) { + ^bb0(%in: f32, %in_12: f32, %out: f32): + %11 = arith.mulf %in, %in_12 : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + %7 = affine.load %alloca_6[%arg9] : memref + %8 = arith.mulf %7, %cst : f32 + affine.store %8, %alloca_2[%arg9] : memref<16xf32> + %9 = arith.cmpf ogt, %8, %6 : f32 + %10 = arith.select %9, %8, %6 : f32 + affine.store %10, %alloca_3[%arg8] : memref + } + %3 = affine.load %alloca_3[%arg8] : memref + affine.store %cst_1, %alloca_4[%arg8] : memref + %subview = memref.subview %alloca_2[0] [%c16] [1] : memref<16xf32> to memref> + %subview_7 = memref.subview %alloca_4[%arg8] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} outs(%subview, %subview_7 : memref>, memref>) { + ^bb0(%out: f32, %out_9: f32): + %6 = arith.subf %out, %3 : f32 + %7 = math.exp %6 : f32 + %8 = arith.addf %out_9, %7 : f32 + linalg.yield %7, %8 : f32, f32 + } + %4 = affine.load %alloca_4[%arg8] : memref + affine.store %cst_1, %alloca_5[%arg8] : memref + %alloca_8 = memref.alloca(%c16) : memref + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_5[%arg8] : memref + %7 = affine.load %alloca_2[%arg9] : memref<16xf32> + %8 = arith.divf %7, %4 : f32 + affine.store %8, %alloca_2[%arg9] : memref<16xf32> + affine.store %cst_1, %alloca_8[%arg9] : memref + %subview_9 = memref.subview %arg3[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg2[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_11 = memref.subview %arg6[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %alloca_8[%arg9] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map1], iterator_types = ["reduction"]} ins(%subview_9, %subview_10 : memref>, memref>) outs(%subview_11, %subview_12 : memref>, memref>) { + ^bb0(%in: f32, %in_13: f32, %out: f32, %out_14: f32): + %12 = arith.mulf %in, %in_13 : f32 + %13 = arith.addf %out_14, %12 : f32 + %14 = arith.mulf %8, %in : f32 + %15 = arith.addf %out, %14 : f32 + linalg.yield %15, %13 : f32, f32 + } + %9 = affine.load %alloca_8[%arg9] : memref + affine.store %9, %alloca[%arg9] : memref<16xf32> + %10 = arith.mulf %9, %8 : f32 + %11 = arith.addf %6, %10 : f32 + affine.store %11, %alloca_5[%arg8] : memref + } + %5 = affine.load %alloca_5[%arg8] : memref + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_2[%arg9] : memref<16xf32> + %7 = affine.load %alloca[%arg9] : memref<16xf32> + %8 = arith.subf %7, %5 : f32 + %9 = arith.mulf %6, %8 : f32 + %10 = arith.mulf %9, %cst : f32 + %subview_9 = memref.subview %arg1[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg4[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_9 : memref>) outs(%subview_10 : memref>) { + ^bb0(%in: f32, %out: f32): + %11 = arith.mulf %10, %in : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + %subview_11 = memref.subview %arg0[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %arg5[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_11 : memref>) outs(%subview_12 : memref>) { + ^bb0(%in: f32, %out: f32): + %11 = arith.mulf %10, %in : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..a09b20a64a8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flash_attention_backward_cpu_linalg.mlir @@ -0,0 +1,120 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flash_attention_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 0.176776692 : f32 + %cst_0 = arith.constant -3.40282347E+38 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref<16xf32> + %alloca_2 = memref.alloca() : memref<16xf32> + %0 = "polygeist.memref2pointer"(%arg4) : (memref) -> !llvm.ptr + affine.for %arg7 = 0 to 1024 { + %3 = arith.index_cast %arg7 : index to i32 + %4 = llvm.getelementptr %0[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %4 : f32, !llvm.ptr + } + %1 = "polygeist.memref2pointer"(%arg5) : (memref) -> !llvm.ptr + %2 = "polygeist.memref2pointer"(%arg6) : (memref) -> !llvm.ptr + affine.for %arg7 = 0 to 1024 { + %3 = arith.index_cast %arg7 : index to i32 + %4 = llvm.getelementptr %1[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %4 : f32, !llvm.ptr + %5 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_1, %5 : f32, !llvm.ptr + } + affine.for %arg7 = 0 to 2 { + %alloca_3 = memref.alloca(%c16) : memref + %alloca_4 = memref.alloca(%c16) : memref + %alloca_5 = memref.alloca(%c16) : memref + affine.for %arg8 = 0 to 16 { + affine.store %cst_0, %alloca_3[%arg8] : memref + %alloca_6 = memref.alloca(%c16) : memref + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_3[%arg8] : memref + affine.store %cst_1, %alloca_6[%arg9] : memref + %subview_9 = memref.subview %arg0[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg1[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_11 = memref.subview %alloca_6[%arg9] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview_9, %subview_10 : memref>, memref>) outs(%subview_11 : memref>) { + ^bb0(%in: f32, %in_12: f32, %out: f32): + %11 = arith.mulf %in, %in_12 : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + %7 = affine.load %alloca_6[%arg9] : memref + %8 = arith.mulf %7, %cst : f32 + affine.store %8, %alloca_2[%arg9] : memref<16xf32> + %9 = arith.cmpf ogt, %8, %6 : f32 + %10 = arith.select %9, %8, %6 : f32 + affine.store %10, %alloca_3[%arg8] : memref + } + %3 = affine.load %alloca_3[%arg8] : memref + affine.store %cst_1, %alloca_4[%arg8] : memref + %subview = memref.subview %alloca_2[0] [%c16] [1] : memref<16xf32> to memref> + %subview_7 = memref.subview %alloca_4[%arg8] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} outs(%subview, %subview_7 : memref>, memref>) { + ^bb0(%out: f32, %out_9: f32): + %6 = arith.subf %out, %3 : f32 + %7 = math.exp %6 : f32 + %8 = arith.addf %out_9, %7 : f32 + linalg.yield %7, %8 : f32, f32 + } + %4 = affine.load %alloca_4[%arg8] : memref + affine.store %cst_1, %alloca_5[%arg8] : memref + %alloca_8 = memref.alloca(%c16) : memref + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_5[%arg8] : memref + %7 = affine.load %alloca_2[%arg9] : memref<16xf32> + %8 = arith.divf %7, %4 : f32 + affine.store %8, %alloca_2[%arg9] : memref<16xf32> + affine.store %cst_1, %alloca_8[%arg9] : memref + %subview_9 = memref.subview %arg3[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg2[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_11 = memref.subview %arg6[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %alloca_8[%arg9] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map1], iterator_types = ["reduction"]} ins(%subview_9, %subview_10 : memref>, memref>) outs(%subview_11, %subview_12 : memref>, memref>) { + ^bb0(%in: f32, %in_13: f32, %out: f32, %out_14: f32): + %12 = arith.mulf %in, %in_13 : f32 + %13 = arith.addf %out_14, %12 : f32 + %14 = arith.mulf %8, %in : f32 + %15 = arith.addf %out, %14 : f32 + linalg.yield %15, %13 : f32, f32 + } + %9 = affine.load %alloca_8[%arg9] : memref + affine.store %9, %alloca[%arg9] : memref<16xf32> + %10 = arith.mulf %9, %8 : f32 + %11 = arith.addf %6, %10 : f32 + affine.store %11, %alloca_5[%arg8] : memref + } + %5 = affine.load %alloca_5[%arg8] : memref + affine.for %arg9 = 0 to 16 { + %6 = affine.load %alloca_2[%arg9] : memref<16xf32> + %7 = affine.load %alloca[%arg9] : memref<16xf32> + %8 = arith.subf %7, %5 : f32 + %9 = arith.mulf %6, %8 : f32 + %10 = arith.mulf %9, %cst : f32 + %subview_9 = memref.subview %arg1[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_10 = memref.subview %arg4[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_9 : memref>) outs(%subview_10 : memref>) { + ^bb0(%in: f32, %out: f32): + %11 = arith.mulf %10, %in : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + %subview_11 = memref.subview %arg0[0, %arg7, %arg8, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %arg5[0, %arg7, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_11 : memref>) outs(%subview_12 : memref>) { + ^bb0(%in: f32, %out: f32): + %11 = arith.mulf %10, %in : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flash_attention_cpu.mlir b/issues/aten_c_kernels/results/aten_flash_attention_cpu.mlir new file mode 100644 index 000000000000..907f60e0c0fb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flash_attention_cpu.mlir @@ -0,0 +1,50 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flash_attention_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.176776692 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant -3.40282347E+38 : f32 + %alloca = memref.alloca() : memref<16xf32> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 16 { + %0 = affine.for %arg7 = 0 to 16 iter_args(%arg8 = %cst_1) -> (f32) { + %4 = affine.for %arg9 = 0 to 32 iter_args(%arg10 = %cst_0) -> (f32) { + %8 = affine.load %arg0[0, %arg5, %arg6, %arg9] : memref + %9 = affine.load %arg1[0, %arg5, %arg7, %arg9] : memref + %10 = arith.mulf %8, %9 : f32 + %11 = arith.addf %arg10, %10 : f32 + affine.yield %11 : f32 + } + %5 = arith.mulf %4, %cst : f32 + affine.store %5, %alloca[%arg7] : memref<16xf32> + %6 = arith.cmpf ogt, %5, %arg8 : f32 + %7 = arith.select %6, %5, %arg8 : f32 + affine.yield %7 : f32 + } + %1 = affine.for %arg7 = 0 to 16 iter_args(%arg8 = %cst_0) -> (f32) { + %4 = affine.load %alloca[%arg7] : memref<16xf32> + %5 = arith.subf %4, %0 : f32 + %6 = math.exp %5 : f32 + affine.store %6, %alloca[%arg7] : memref<16xf32> + %7 = arith.addf %arg8, %6 : f32 + affine.yield %7 : f32 + } + %2 = func.call @logf(%1) : (f32) -> f32 + %3 = arith.addf %0, %2 : f32 + affine.store %3, %arg4[0, %arg5, %arg6] : memref + affine.for %arg7 = 0 to 32 { + %4 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %cst_0) -> (f32) { + %5 = affine.load %alloca[%arg8] : memref<16xf32> + %6 = arith.divf %5, %1 : f32 + %7 = affine.load %arg2[0, %arg5, %arg8, %arg7] : memref + %8 = arith.mulf %6, %7 : f32 + %9 = arith.addf %arg9, %8 : f32 + affine.yield %9 : f32 + } + affine.store %4, %arg3[0, %arg5, %arg6, %arg7] : memref + } + } + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_flash_attention_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_flash_attention_cpu/debuf.mlir new file mode 100644 index 000000000000..55bfcc370ce2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flash_attention_cpu/debuf.mlir @@ -0,0 +1,94 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d1, d0)> +#map4 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flash_attention_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.40282347E+38 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 0.176776692 : f32 + %c16 = arith.constant 16 : index + %c0 = arith.constant 0 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = tensor.empty() : tensor<16xf32> + %alloca = memref.alloca() : memref<16xf32> + %6 = bufferization.to_tensor %alloca : memref<16xf32> + %7:3 = affine.for %arg5 = 0 to 2 iter_args(%arg6 = %5, %arg7 = %2, %arg8 = %1) -> (tensor<16xf32>, tensor, tensor) { + %10:3 = affine.for %arg9 = 0 to 16 iter_args(%arg10 = %arg6, %arg11 = %arg7, %arg12 = %arg8) -> (tensor<16xf32>, tensor, tensor) { + %alloca_2 = memref.alloca() : memref + %11 = bufferization.to_tensor %alloca_2 : memref + %inserted = tensor.insert %cst into %11[] : tensor + %alloca_3 = memref.alloca(%c16) : memref + %12 = bufferization.to_tensor %alloca_3 : memref + %13:3 = affine.for %arg13 = 0 to 16 iter_args(%arg14 = %arg10, %arg15 = %inserted, %arg16 = %12) -> (tensor<16xf32>, tensor, tensor) { + %extracted_12 = tensor.extract %arg15[] : tensor + %inserted_13 = tensor.insert %cst_0 into %arg16[%arg13] : tensor + %extracted_slice_14 = tensor.extract_slice %inserted_13[%arg13] [1] [1] : tensor to tensor + %extracted_slice_15 = tensor.extract_slice %4[0, %arg5, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_16 = tensor.extract_slice %3[0, %arg5, %arg13, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : tensor to tensor + %20 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_15, %extracted_slice_16 : tensor, tensor) outs(%extracted_slice_14 : tensor) { + ^bb0(%in: f32, %in_21: f32, %out: f32): + %24 = arith.mulf %in, %in_21 : f32 + %25 = arith.addf %out, %24 : f32 + linalg.yield %25 : f32 + } -> tensor + %inserted_slice_17 = tensor.insert_slice %20 into %inserted_13[%arg13] [1] [1] : tensor into tensor + %extracted_18 = tensor.extract %inserted_slice_17[%arg13] : tensor + %21 = arith.mulf %extracted_18, %cst_1 : f32 + %inserted_19 = tensor.insert %21 into %arg14[%arg13] : tensor<16xf32> + %22 = arith.cmpf ogt, %21, %extracted_12 : f32 + %23 = arith.select %22, %21, %extracted_12 : f32 + %inserted_20 = tensor.insert %23 into %arg15[] : tensor + affine.yield %inserted_19, %inserted_20, %inserted_slice_17 : tensor<16xf32>, tensor, tensor + } + %extracted = tensor.extract %13#1[] : tensor + %alloca_4 = memref.alloca() : memref + %14 = bufferization.to_tensor %alloca_4 : memref + %inserted_5 = tensor.insert %cst_0 into %14[] : tensor + %extracted_slice = tensor.extract_slice %13#0[0] [%c16] [1] : tensor<16xf32> to tensor + %15:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} outs(%extracted_slice, %inserted_5 : tensor, tensor) { + ^bb0(%out: f32, %out_12: f32): + %20 = arith.subf %out, %extracted : f32 + %21 = math.exp %20 : f32 + %22 = arith.addf %out_12, %21 : f32 + linalg.yield %21, %22 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %15#0 into %13#0[0] [%c16] [1] : tensor into tensor<16xf32> + %extracted_6 = tensor.extract %15#1[] : tensor + %16 = math.log %extracted_6 : f32 + %17 = arith.addf %extracted, %16 : f32 + %inserted_7 = tensor.insert %17 into %arg12[%c0, %arg5, %arg9] : tensor + %extracted_slice_8 = tensor.extract_slice %arg11[0, %arg5, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : tensor to tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice_8 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } -> tensor + %extracted_slice_9 = tensor.extract_slice %6[0] [%c16] [1] : tensor<16xf32> to tensor + %extracted_slice_10 = tensor.extract_slice %0[0, %arg5, 0, 0] [1, 1, %c16, %c32] [1, 1, 1, 1] : tensor to tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_9, %extracted_slice_10 : tensor, tensor) outs(%18 : tensor) { + ^bb0(%in: f32, %in_12: f32, %out: f32): + %20 = arith.divf %in, %extracted_6 : f32 + %21 = arith.mulf %20, %in_12 : f32 + %22 = arith.addf %out, %21 : f32 + linalg.yield %22 : f32 + } -> tensor + %inserted_slice_11 = tensor.insert_slice %19 into %arg11[0, %arg5, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_slice_11, %inserted_7 : tensor<16xf32>, tensor, tensor + } + affine.yield %10#0, %10#1, %10#2 : tensor<16xf32>, tensor, tensor + } + %8 = bufferization.to_memref %7#2 : memref + memref.copy %8, %arg4 : memref to memref + %9 = bufferization.to_memref %7#1 : memref + memref.copy %9, %arg3 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_flash_attention_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_flash_attention_cpu/matched.mlir new file mode 100644 index 000000000000..8d9f004f07ad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flash_attention_cpu/matched.mlir @@ -0,0 +1,86 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d1, d0)> +#map4 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flash_attention_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.40282347E+38 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 0.176776692 : f32 + %c16 = arith.constant 16 : index + %c0 = arith.constant 0 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = tensor.empty() : tensor<16xf32> + %alloca = memref.alloca() : memref<16xf32> + %6 = bufferization.to_tensor %alloca : memref<16xf32> + %7:3 = affine.for %arg5 = 0 to 2 iter_args(%arg6 = %5, %arg7 = %2, %arg8 = %1) -> (tensor<16xf32>, tensor, tensor) { + %10:3 = affine.for %arg9 = 0 to 16 iter_args(%arg10 = %arg6, %arg11 = %arg7, %arg12 = %arg8) -> (tensor<16xf32>, tensor, tensor) { + %alloca_2 = memref.alloca() : memref + %11 = bufferization.to_tensor %alloca_2 : memref + %inserted = tensor.insert %cst into %11[] : tensor + %alloca_3 = memref.alloca(%c16) : memref + %12 = bufferization.to_tensor %alloca_3 : memref + %13:3 = affine.for %arg13 = 0 to 16 iter_args(%arg14 = %arg10, %arg15 = %inserted, %arg16 = %12) -> (tensor<16xf32>, tensor, tensor) { + %extracted_12 = tensor.extract %arg15[] : tensor + %inserted_13 = tensor.insert %cst_0 into %arg16[%arg13] : tensor + %extracted_slice_14 = tensor.extract_slice %inserted_13[%arg13] [1] [1] : tensor to tensor + %extracted_slice_15 = tensor.extract_slice %4[0, %arg5, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_16 = tensor.extract_slice %3[0, %arg5, %arg13, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : tensor to tensor + %20 = kernel.launch @cublasSdot(%extracted_slice_15, %extracted_slice_16, %extracted_slice_14) : (tensor, tensor, tensor) -> tensor + %inserted_slice_17 = tensor.insert_slice %20 into %inserted_13[%arg13] [1] [1] : tensor into tensor + %extracted_18 = tensor.extract %inserted_slice_17[%arg13] : tensor + %21 = arith.mulf %extracted_18, %cst_1 : f32 + %inserted_19 = tensor.insert %21 into %arg14[%arg13] : tensor<16xf32> + %22 = arith.cmpf ogt, %21, %extracted_12 : f32 + %23 = arith.select %22, %21, %extracted_12 : f32 + %inserted_20 = tensor.insert %23 into %arg15[] : tensor + affine.yield %inserted_19, %inserted_20, %inserted_slice_17 : tensor<16xf32>, tensor, tensor + } + %extracted = tensor.extract %13#1[] : tensor + %alloca_4 = memref.alloca() : memref + %14 = bufferization.to_tensor %alloca_4 : memref + %inserted_5 = tensor.insert %cst_0 into %14[] : tensor + %extracted_slice = tensor.extract_slice %13#0[0] [%c16] [1] : tensor<16xf32> to tensor + %15:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} outs(%extracted_slice, %inserted_5 : tensor, tensor) { + ^bb0(%out: f32, %out_12: f32): + %20 = arith.subf %out, %extracted : f32 + %21 = math.exp %20 : f32 + %22 = arith.addf %out_12, %21 : f32 + linalg.yield %21, %22 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %15#0 into %13#0[0] [%c16] [1] : tensor into tensor<16xf32> + %extracted_6 = tensor.extract %15#1[] : tensor + %16 = math.log %extracted_6 : f32 + %17 = arith.addf %extracted, %16 : f32 + %inserted_7 = tensor.insert %17 into %arg12[%c0, %arg5, %arg9] : tensor + %extracted_slice_8 = tensor.extract_slice %arg11[0, %arg5, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : tensor to tensor + %18 = kernel.launch @memset_zero_1D_f32(%extracted_slice_8) : (tensor) -> tensor + %extracted_slice_9 = tensor.extract_slice %6[0] [%c16] [1] : tensor<16xf32> to tensor + %extracted_slice_10 = tensor.extract_slice %0[0, %arg5, 0, 0] [1, 1, %c16, %c32] [1, 1, 1, 1] : tensor to tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_9, %extracted_slice_10 : tensor, tensor) outs(%18 : tensor) { + ^bb0(%in: f32, %in_12: f32, %out: f32): + %20 = arith.divf %in, %extracted_6 : f32 + %21 = arith.mulf %20, %in_12 : f32 + %22 = arith.addf %out, %21 : f32 + linalg.yield %22 : f32 + } -> tensor + %inserted_slice_11 = tensor.insert_slice %19 into %arg11[0, %arg5, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_slice_11, %inserted_7 : tensor<16xf32>, tensor, tensor + } + affine.yield %10#0, %10#1, %10#2 : tensor<16xf32>, tensor, tensor + } + %8 = bufferization.to_memref %7#2 : memref + memref.copy %8, %arg4 : memref to memref + %9 = bufferization.to_memref %7#1 : memref + memref.copy %9, %arg3 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_flash_attention_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_flash_attention_cpu/orig.mlir new file mode 100644 index 000000000000..907f60e0c0fb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flash_attention_cpu/orig.mlir @@ -0,0 +1,50 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flash_attention_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.176776692 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant -3.40282347E+38 : f32 + %alloca = memref.alloca() : memref<16xf32> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 16 { + %0 = affine.for %arg7 = 0 to 16 iter_args(%arg8 = %cst_1) -> (f32) { + %4 = affine.for %arg9 = 0 to 32 iter_args(%arg10 = %cst_0) -> (f32) { + %8 = affine.load %arg0[0, %arg5, %arg6, %arg9] : memref + %9 = affine.load %arg1[0, %arg5, %arg7, %arg9] : memref + %10 = arith.mulf %8, %9 : f32 + %11 = arith.addf %arg10, %10 : f32 + affine.yield %11 : f32 + } + %5 = arith.mulf %4, %cst : f32 + affine.store %5, %alloca[%arg7] : memref<16xf32> + %6 = arith.cmpf ogt, %5, %arg8 : f32 + %7 = arith.select %6, %5, %arg8 : f32 + affine.yield %7 : f32 + } + %1 = affine.for %arg7 = 0 to 16 iter_args(%arg8 = %cst_0) -> (f32) { + %4 = affine.load %alloca[%arg7] : memref<16xf32> + %5 = arith.subf %4, %0 : f32 + %6 = math.exp %5 : f32 + affine.store %6, %alloca[%arg7] : memref<16xf32> + %7 = arith.addf %arg8, %6 : f32 + affine.yield %7 : f32 + } + %2 = func.call @logf(%1) : (f32) -> f32 + %3 = arith.addf %0, %2 : f32 + affine.store %3, %arg4[0, %arg5, %arg6] : memref + affine.for %arg7 = 0 to 32 { + %4 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %cst_0) -> (f32) { + %5 = affine.load %alloca[%arg8] : memref<16xf32> + %6 = arith.divf %5, %1 : f32 + %7 = affine.load %arg2[0, %arg5, %arg8, %arg7] : memref + %8 = arith.mulf %6, %7 : f32 + %9 = arith.addf %arg9, %8 : f32 + affine.yield %9 : f32 + } + affine.store %4, %arg3[0, %arg5, %arg6, %arg7] : memref + } + } + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_flash_attention_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_flash_attention_cpu/raised.mlir new file mode 100644 index 000000000000..07a9bb0026f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flash_attention_cpu/raised.mlir @@ -0,0 +1,75 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d1, d0)> +#map4 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flash_attention_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 0.176776692 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant -3.40282347E+38 : f32 + %alloca = memref.alloca() : memref<16xf32> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 16 { + %alloca_2 = memref.alloca() : memref + affine.store %cst_1, %alloca_2[] : memref + %alloca_3 = memref.alloca(%c16) : memref + affine.for %arg7 = 0 to 16 { + %4 = affine.load %alloca_2[] : memref + affine.store %cst_0, %alloca_3[%arg7] : memref + %subview_10 = memref.subview %arg0[0, %arg5, %arg6, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_11 = memref.subview %arg1[0, %arg5, %arg7, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %alloca_3[%arg7] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview_10, %subview_11 : memref>, memref>) outs(%subview_12 : memref>) { + ^bb0(%in: f32, %in_13: f32, %out: f32): + %9 = arith.mulf %in, %in_13 : f32 + %10 = arith.addf %out, %9 : f32 + linalg.yield %10 : f32 + } + %5 = affine.load %alloca_3[%arg7] : memref + %6 = arith.mulf %5, %cst : f32 + affine.store %6, %alloca[%arg7] : memref<16xf32> + %7 = arith.cmpf ogt, %6, %4 : f32 + %8 = arith.select %7, %6, %4 : f32 + affine.store %8, %alloca_2[] : memref + } + %0 = affine.load %alloca_2[] : memref + %alloca_4 = memref.alloca() : memref + affine.store %cst_0, %alloca_4[] : memref + %subview = memref.subview %alloca[0] [%c16] [1] : memref<16xf32> to memref> + %subview_5 = memref.subview %alloca_4[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} outs(%subview, %subview_5 : memref>, memref>) { + ^bb0(%out: f32, %out_10: f32): + %4 = arith.subf %out, %0 : f32 + %5 = math.exp %4 : f32 + %6 = arith.addf %out_10, %5 : f32 + linalg.yield %5, %6 : f32, f32 + } + %1 = affine.load %alloca_4[] : memref + %2 = math.log %1 : f32 + %3 = arith.addf %0, %2 : f32 + affine.store %3, %arg4[0, %arg5, %arg6] : memref + %subview_6 = memref.subview %arg3[0, %arg5, %arg6, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview_6 : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + %subview_7 = memref.subview %alloca[0] [%c16] [1] : memref<16xf32> to memref> + %subview_8 = memref.subview %arg2[0, %arg5, 0, 0] [1, 1, %c16, %c32] [1, 1, 1, 1] : memref to memref> + %subview_9 = memref.subview %arg3[0, %arg5, %arg6, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "reduction"]} ins(%subview_7, %subview_8 : memref>, memref>) outs(%subview_9 : memref>) { + ^bb0(%in: f32, %in_10: f32, %out: f32): + %4 = arith.divf %in, %1 : f32 + %5 = arith.mulf %4, %in_10 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } + } + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_flash_attention_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_flash_attention_cpu_debuf.mlir new file mode 100644 index 000000000000..55bfcc370ce2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flash_attention_cpu_debuf.mlir @@ -0,0 +1,94 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d1, d0)> +#map4 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flash_attention_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.40282347E+38 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 0.176776692 : f32 + %c16 = arith.constant 16 : index + %c0 = arith.constant 0 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = tensor.empty() : tensor<16xf32> + %alloca = memref.alloca() : memref<16xf32> + %6 = bufferization.to_tensor %alloca : memref<16xf32> + %7:3 = affine.for %arg5 = 0 to 2 iter_args(%arg6 = %5, %arg7 = %2, %arg8 = %1) -> (tensor<16xf32>, tensor, tensor) { + %10:3 = affine.for %arg9 = 0 to 16 iter_args(%arg10 = %arg6, %arg11 = %arg7, %arg12 = %arg8) -> (tensor<16xf32>, tensor, tensor) { + %alloca_2 = memref.alloca() : memref + %11 = bufferization.to_tensor %alloca_2 : memref + %inserted = tensor.insert %cst into %11[] : tensor + %alloca_3 = memref.alloca(%c16) : memref + %12 = bufferization.to_tensor %alloca_3 : memref + %13:3 = affine.for %arg13 = 0 to 16 iter_args(%arg14 = %arg10, %arg15 = %inserted, %arg16 = %12) -> (tensor<16xf32>, tensor, tensor) { + %extracted_12 = tensor.extract %arg15[] : tensor + %inserted_13 = tensor.insert %cst_0 into %arg16[%arg13] : tensor + %extracted_slice_14 = tensor.extract_slice %inserted_13[%arg13] [1] [1] : tensor to tensor + %extracted_slice_15 = tensor.extract_slice %4[0, %arg5, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_16 = tensor.extract_slice %3[0, %arg5, %arg13, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : tensor to tensor + %20 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_15, %extracted_slice_16 : tensor, tensor) outs(%extracted_slice_14 : tensor) { + ^bb0(%in: f32, %in_21: f32, %out: f32): + %24 = arith.mulf %in, %in_21 : f32 + %25 = arith.addf %out, %24 : f32 + linalg.yield %25 : f32 + } -> tensor + %inserted_slice_17 = tensor.insert_slice %20 into %inserted_13[%arg13] [1] [1] : tensor into tensor + %extracted_18 = tensor.extract %inserted_slice_17[%arg13] : tensor + %21 = arith.mulf %extracted_18, %cst_1 : f32 + %inserted_19 = tensor.insert %21 into %arg14[%arg13] : tensor<16xf32> + %22 = arith.cmpf ogt, %21, %extracted_12 : f32 + %23 = arith.select %22, %21, %extracted_12 : f32 + %inserted_20 = tensor.insert %23 into %arg15[] : tensor + affine.yield %inserted_19, %inserted_20, %inserted_slice_17 : tensor<16xf32>, tensor, tensor + } + %extracted = tensor.extract %13#1[] : tensor + %alloca_4 = memref.alloca() : memref + %14 = bufferization.to_tensor %alloca_4 : memref + %inserted_5 = tensor.insert %cst_0 into %14[] : tensor + %extracted_slice = tensor.extract_slice %13#0[0] [%c16] [1] : tensor<16xf32> to tensor + %15:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} outs(%extracted_slice, %inserted_5 : tensor, tensor) { + ^bb0(%out: f32, %out_12: f32): + %20 = arith.subf %out, %extracted : f32 + %21 = math.exp %20 : f32 + %22 = arith.addf %out_12, %21 : f32 + linalg.yield %21, %22 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %15#0 into %13#0[0] [%c16] [1] : tensor into tensor<16xf32> + %extracted_6 = tensor.extract %15#1[] : tensor + %16 = math.log %extracted_6 : f32 + %17 = arith.addf %extracted, %16 : f32 + %inserted_7 = tensor.insert %17 into %arg12[%c0, %arg5, %arg9] : tensor + %extracted_slice_8 = tensor.extract_slice %arg11[0, %arg5, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : tensor to tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice_8 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } -> tensor + %extracted_slice_9 = tensor.extract_slice %6[0] [%c16] [1] : tensor<16xf32> to tensor + %extracted_slice_10 = tensor.extract_slice %0[0, %arg5, 0, 0] [1, 1, %c16, %c32] [1, 1, 1, 1] : tensor to tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_9, %extracted_slice_10 : tensor, tensor) outs(%18 : tensor) { + ^bb0(%in: f32, %in_12: f32, %out: f32): + %20 = arith.divf %in, %extracted_6 : f32 + %21 = arith.mulf %20, %in_12 : f32 + %22 = arith.addf %out, %21 : f32 + linalg.yield %22 : f32 + } -> tensor + %inserted_slice_11 = tensor.insert_slice %19 into %arg11[0, %arg5, %arg9, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_slice_11, %inserted_7 : tensor<16xf32>, tensor, tensor + } + affine.yield %10#0, %10#1, %10#2 : tensor<16xf32>, tensor, tensor + } + %8 = bufferization.to_memref %7#2 : memref + memref.copy %8, %arg4 : memref to memref + %9 = bufferization.to_memref %7#1 : memref + memref.copy %9, %arg3 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_flash_attention_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_flash_attention_cpu_linalg.mlir new file mode 100644 index 000000000000..07a9bb0026f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flash_attention_cpu_linalg.mlir @@ -0,0 +1,75 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d1, d0)> +#map4 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flash_attention_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 0.176776692 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant -3.40282347E+38 : f32 + %alloca = memref.alloca() : memref<16xf32> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 16 { + %alloca_2 = memref.alloca() : memref + affine.store %cst_1, %alloca_2[] : memref + %alloca_3 = memref.alloca(%c16) : memref + affine.for %arg7 = 0 to 16 { + %4 = affine.load %alloca_2[] : memref + affine.store %cst_0, %alloca_3[%arg7] : memref + %subview_10 = memref.subview %arg0[0, %arg5, %arg6, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_11 = memref.subview %arg1[0, %arg5, %arg7, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %alloca_3[%arg7] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview_10, %subview_11 : memref>, memref>) outs(%subview_12 : memref>) { + ^bb0(%in: f32, %in_13: f32, %out: f32): + %9 = arith.mulf %in, %in_13 : f32 + %10 = arith.addf %out, %9 : f32 + linalg.yield %10 : f32 + } + %5 = affine.load %alloca_3[%arg7] : memref + %6 = arith.mulf %5, %cst : f32 + affine.store %6, %alloca[%arg7] : memref<16xf32> + %7 = arith.cmpf ogt, %6, %4 : f32 + %8 = arith.select %7, %6, %4 : f32 + affine.store %8, %alloca_2[] : memref + } + %0 = affine.load %alloca_2[] : memref + %alloca_4 = memref.alloca() : memref + affine.store %cst_0, %alloca_4[] : memref + %subview = memref.subview %alloca[0] [%c16] [1] : memref<16xf32> to memref> + %subview_5 = memref.subview %alloca_4[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} outs(%subview, %subview_5 : memref>, memref>) { + ^bb0(%out: f32, %out_10: f32): + %4 = arith.subf %out, %0 : f32 + %5 = math.exp %4 : f32 + %6 = arith.addf %out_10, %5 : f32 + linalg.yield %5, %6 : f32, f32 + } + %1 = affine.load %alloca_4[] : memref + %2 = math.log %1 : f32 + %3 = arith.addf %0, %2 : f32 + affine.store %3, %arg4[0, %arg5, %arg6] : memref + %subview_6 = memref.subview %arg3[0, %arg5, %arg6, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview_6 : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + %subview_7 = memref.subview %alloca[0] [%c16] [1] : memref<16xf32> to memref> + %subview_8 = memref.subview %arg2[0, %arg5, 0, 0] [1, 1, %c16, %c32] [1, 1, 1, 1] : memref to memref> + %subview_9 = memref.subview %arg3[0, %arg5, %arg6, 0] [1, 1, 1, %c32] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "reduction"]} ins(%subview_7, %subview_8 : memref>, memref>) outs(%subview_9 : memref>) { + ^bb0(%in: f32, %in_10: f32, %out: f32): + %4 = arith.divf %in, %1 : f32 + %5 = arith.mulf %4, %in_10 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } + } + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu.mlir b/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu.mlir new file mode 100644 index 000000000000..b15b154aec9c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flatten_indices_launch_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 512 { + %0 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %c0_i32) -> (i32) { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.muli %arg5, %1 : i32 + %3 = affine.load %arg0[%arg4, %arg3] : memref + %4 = arith.addi %2, %3 : i32 + affine.yield %4 : i32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu/debuf.mlir new file mode 100644 index 000000000000..760c1910d6fb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flatten_indices_launch_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c512 = arith.constant 512 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %1[0] [%c3] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c3, %c512] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c512] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %6 = arith.muli %out, %in : i32 + %7 = arith.addi %6, %in_2 : i32 + linalg.yield %7 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c512] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu/matched.mlir new file mode 100644 index 000000000000..5f3223d7b603 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu/matched.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flatten_indices_launch_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c512 = arith.constant 512 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = kernel.launch @memset_zero_1D(%2) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %1[0] [%c3] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c3, %c512] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c512] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %6 = arith.muli %out, %in : i32 + %7 = arith.addi %6, %in_2 : i32 + linalg.yield %7 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c512] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu/orig.mlir new file mode 100644 index 000000000000..b15b154aec9c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu/orig.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flatten_indices_launch_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 512 { + %0 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %c0_i32) -> (i32) { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.muli %arg5, %1 : i32 + %3 = affine.load %arg0[%arg4, %arg3] : memref + %4 = arith.addi %2, %3 : i32 + affine.yield %4 : i32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu/raised.mlir new file mode 100644 index 000000000000..1aa691682245 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flatten_indices_launch_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c512 = arith.constant 512 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg1[0] [%c3] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c3, %c512] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c512] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %0 = arith.muli %out, %in : i32 + %1 = arith.addi %0, %in_2 : i32 + linalg.yield %1 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu_debuf.mlir new file mode 100644 index 000000000000..760c1910d6fb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flatten_indices_launch_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c512 = arith.constant 512 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %1[0] [%c3] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c3, %c512] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c512] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %6 = arith.muli %out, %in : i32 + %7 = arith.addi %6, %in_2 : i32 + linalg.yield %7 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c512] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu_linalg.mlir new file mode 100644 index 000000000000..1aa691682245 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flatten_indices_launch_cpu_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flatten_indices_launch_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c512 = arith.constant 512 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg1[0] [%c3] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c3, %c512] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c512] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %0 = arith.muli %out, %in : i32 + %1 = arith.addi %0, %in_2 : i32 + linalg.yield %1 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu.mlir b/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu.mlir new file mode 100644 index 000000000000..edbdfeedef90 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flatten_nd_linear_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 48 { + %0 = affine.for %arg6 = 0 to 64 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4, %arg6] : memref + %2 = affine.load %arg1[%arg6, %arg5] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg7, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu/debuf.mlir new file mode 100644 index 000000000000..98fa892a3485 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu/debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flatten_nd_linear_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c16, %c32, %c48] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c16, %c32, %c64] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c16, %c32, %c48] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu/matched.mlir new file mode 100644 index 000000000000..c71c8b47369c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flatten_nd_linear_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c16, %c32, %c48] [1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c16, %c32, %c64] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %4 = kernel.launch @cublasSgemm_strided_batched_broadcast_rhs(%extracted_slice_0, %extracted_slice_1, %extracted_slice) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c16, %c32, %c48] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu/orig.mlir new file mode 100644 index 000000000000..edbdfeedef90 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flatten_nd_linear_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 48 { + %0 = affine.for %arg6 = 0 to 64 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4, %arg6] : memref + %2 = affine.load %arg1[%arg6, %arg5] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg7, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu/raised.mlir new file mode 100644 index 000000000000..e33e5fb4d11f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flatten_nd_linear_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c16, %c32, %c48] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c16, %c32, %c64] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0] [%c64, %c48] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0, 0] [%c16, %c32, %c48] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu_debuf.mlir new file mode 100644 index 000000000000..98fa892a3485 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu_debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flatten_nd_linear_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c16, %c32, %c48] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c16, %c32, %c64] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c16, %c32, %c48] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu_linalg.mlir new file mode 100644 index 000000000000..e33e5fb4d11f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flatten_nd_linear_cpu_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flatten_nd_linear_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c16, %c32, %c48] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c16, %c32, %c64] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0] [%c64, %c48] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0, 0] [%c16, %c32, %c48] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flip_cpu.mlir b/issues/aten_c_kernels/results/aten_flip_cpu.mlir new file mode 100644 index 000000000000..c7af854f8399 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flip_cpu.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flip_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c63_i32 = arith.constant 63 : i32 + %c31_i32 = arith.constant 31 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %1 = arith.cmpi ne, %arg3, %c0_i32 : i32 + affine.for %arg4 = 0 to 32 { + %2 = arith.index_cast %arg4 : index to i32 + %3 = scf.if %0 -> (i32) { + %5 = arith.subi %c31_i32, %2 : i32 + scf.yield %5 : i32 + } else { + scf.yield %2 : i32 + } + %4 = arith.index_cast %3 : i32 to index + affine.for %arg5 = 0 to 64 { + %5 = arith.index_cast %arg5 : index to i32 + %6 = scf.if %1 -> (i32) { + %9 = arith.subi %c63_i32, %5 : i32 + scf.yield %9 : i32 + } else { + scf.yield %5 : i32 + } + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg0[%4, %7] : memref + affine.store %8, %arg1[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_flip_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_flip_cpu/debuf.mlir new file mode 100644 index 000000000000..b72af8d2d318 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flip_cpu/debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flip_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c31_i32 = arith.constant 31 : i32 + %c63_i32 = arith.constant 63 : i32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %2 = arith.cmpi ne, %arg3, %c0_i32 : i32 + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.subi %c31_i32, %6 : i32 + %8 = arith.select %1, %7, %6 : i32 + %9 = arith.index_cast %8 : i32 to index + %10 = linalg.index 1 : index + %11 = arith.index_cast %10 : index to i32 + %12 = arith.subi %c63_i32, %11 : i32 + %13 = arith.select %2, %12, %11 : i32 + %14 = arith.index_cast %13 : i32 to index + %15 = memref.load %arg0[%9, %14] : memref + linalg.yield %15 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flip_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_flip_cpu/matched.mlir new file mode 100644 index 000000000000..b72af8d2d318 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flip_cpu/matched.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flip_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c31_i32 = arith.constant 31 : i32 + %c63_i32 = arith.constant 63 : i32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %2 = arith.cmpi ne, %arg3, %c0_i32 : i32 + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.subi %c31_i32, %6 : i32 + %8 = arith.select %1, %7, %6 : i32 + %9 = arith.index_cast %8 : i32 to index + %10 = linalg.index 1 : index + %11 = arith.index_cast %10 : index to i32 + %12 = arith.subi %c63_i32, %11 : i32 + %13 = arith.select %2, %12, %11 : i32 + %14 = arith.index_cast %13 : i32 to index + %15 = memref.load %arg0[%9, %14] : memref + linalg.yield %15 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flip_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_flip_cpu/orig.mlir new file mode 100644 index 000000000000..c7af854f8399 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flip_cpu/orig.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flip_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c63_i32 = arith.constant 63 : i32 + %c31_i32 = arith.constant 31 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %1 = arith.cmpi ne, %arg3, %c0_i32 : i32 + affine.for %arg4 = 0 to 32 { + %2 = arith.index_cast %arg4 : index to i32 + %3 = scf.if %0 -> (i32) { + %5 = arith.subi %c31_i32, %2 : i32 + scf.yield %5 : i32 + } else { + scf.yield %2 : i32 + } + %4 = arith.index_cast %3 : i32 to index + affine.for %arg5 = 0 to 64 { + %5 = arith.index_cast %arg5 : index to i32 + %6 = scf.if %1 -> (i32) { + %9 = arith.subi %c63_i32, %5 : i32 + scf.yield %9 : i32 + } else { + scf.yield %5 : i32 + } + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg0[%4, %7] : memref + affine.store %8, %arg1[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_flip_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_flip_cpu/raised.mlir new file mode 100644 index 000000000000..152128852974 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flip_cpu/raised.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flip_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %c63_i32 = arith.constant 63 : i32 + %c31_i32 = arith.constant 31 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %1 = arith.cmpi ne, %arg3, %c0_i32 : i32 + %subview = memref.subview %arg1[0, 0] [%c32, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %2 = linalg.index 0 : index + %3 = arith.index_cast %2 : index to i32 + %4 = arith.subi %c31_i32, %3 : i32 + %5 = arith.select %0, %4, %3 : i32 + %6 = arith.index_cast %5 : i32 to index + %7 = linalg.index 1 : index + %8 = arith.index_cast %7 : index to i32 + %9 = arith.subi %c63_i32, %8 : i32 + %10 = arith.select %1, %9, %8 : i32 + %11 = arith.index_cast %10 : i32 to index + %12 = memref.load %arg0[%6, %11] : memref + linalg.yield %12 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flip_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_flip_cpu_debuf.mlir new file mode 100644 index 000000000000..b72af8d2d318 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flip_cpu_debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flip_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c31_i32 = arith.constant 31 : i32 + %c63_i32 = arith.constant 63 : i32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %2 = arith.cmpi ne, %arg3, %c0_i32 : i32 + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.subi %c31_i32, %6 : i32 + %8 = arith.select %1, %7, %6 : i32 + %9 = arith.index_cast %8 : i32 to index + %10 = linalg.index 1 : index + %11 = arith.index_cast %10 : index to i32 + %12 = arith.subi %c63_i32, %11 : i32 + %13 = arith.select %2, %12, %11 : i32 + %14 = arith.index_cast %13 : i32 to index + %15 = memref.load %arg0[%9, %14] : memref + linalg.yield %15 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flip_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_flip_cpu_linalg.mlir new file mode 100644 index 000000000000..152128852974 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flip_cpu_linalg.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flip_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %c63_i32 = arith.constant 63 : i32 + %c31_i32 = arith.constant 31 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %1 = arith.cmpi ne, %arg3, %c0_i32 : i32 + %subview = memref.subview %arg1[0, 0] [%c32, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %2 = linalg.index 0 : index + %3 = arith.index_cast %2 : index to i32 + %4 = arith.subi %c31_i32, %3 : i32 + %5 = arith.select %0, %4, %3 : i32 + %6 = arith.index_cast %5 : i32 to index + %7 = linalg.index 1 : index + %8 = arith.index_cast %7 : index to i32 + %9 = arith.subi %c63_i32, %8 : i32 + %10 = arith.select %1, %9, %8 : i32 + %11 = arith.index_cast %10 : i32 to index + %12 = memref.load %arg0[%6, %11] : memref + linalg.yield %12 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu.mlir b/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu.mlir new file mode 100644 index 000000000000..0395a008de71 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flip_tensor_transform_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 32 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[-%arg2 + 31, -%arg3 + 63] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu/debuf.mlir new file mode 100644 index 000000000000..67cf04d8de69 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu/debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (-d0 + 31, -d1 + 63)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flip_tensor_transform_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c32, %c64) {map = #map} : (tensor, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu/matched.mlir new file mode 100644 index 000000000000..67cf04d8de69 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (-d0 + 31, -d1 + 63)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flip_tensor_transform_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c32, %c64) {map = #map} : (tensor, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu/orig.mlir new file mode 100644 index 000000000000..0395a008de71 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flip_tensor_transform_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 32 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[-%arg2 + 31, -%arg3 + 63] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu/raised.mlir new file mode 100644 index 000000000000..1f3b0c634cef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1) -> (-d0 + 31, -d1 + 63)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flip_tensor_transform_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %0 = polygeist.submap(%arg0, %c32, %c64) {map = #map} : (memref, index, index) -> memref + %subview = memref.subview %arg1[0, 0] [%c32, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu_debuf.mlir new file mode 100644 index 000000000000..67cf04d8de69 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu_debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (-d0 + 31, -d1 + 63)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flip_tensor_transform_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c32, %c64) {map = #map} : (tensor, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu_linalg.mlir new file mode 100644 index 000000000000..1f3b0c634cef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_flip_tensor_transform_cpu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1) -> (-d0 + 31, -d1 + 63)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_flip_tensor_transform_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %0 = polygeist.submap(%arg0, %c32, %c64) {map = #map} : (memref, index, index) -> memref + %subview = memref.subview %arg1[0, 0] [%c32, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_floor.mlir b/issues/aten_c_kernels/results/aten_floor.mlir new file mode 100644 index 000000000000..3f950f6c42bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_floor.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_floor(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @floorf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @floorf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_floor/debuf.mlir b/issues/aten_c_kernels/results/aten_floor/debuf.mlir new file mode 100644 index 000000000000..f6609db0d6b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_floor/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_floor(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.floor %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @floorf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_floor/matched.mlir b/issues/aten_c_kernels/results/aten_floor/matched.mlir new file mode 100644 index 000000000000..f6609db0d6b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_floor/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_floor(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.floor %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @floorf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_floor/orig.mlir b/issues/aten_c_kernels/results/aten_floor/orig.mlir new file mode 100644 index 000000000000..3f950f6c42bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_floor/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_floor(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @floorf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @floorf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_floor/raised.mlir b/issues/aten_c_kernels/results/aten_floor/raised.mlir new file mode 100644 index 000000000000..b3ac0b7e7cb5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_floor/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_floor(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.floor %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @floorf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_floor_debuf.mlir b/issues/aten_c_kernels/results/aten_floor_debuf.mlir new file mode 100644 index 000000000000..f6609db0d6b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_floor_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_floor(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.floor %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @floorf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_floor_linalg.mlir b/issues/aten_c_kernels/results/aten_floor_linalg.mlir new file mode 100644 index 000000000000..b3ac0b7e7cb5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_floor_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_floor(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.floor %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @floorf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fmax.mlir b/issues/aten_c_kernels/results/aten_fmax.mlir new file mode 100644 index 000000000000..492967de17eb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmax.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmax(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @fmaxf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @fmaxf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_fmax/debuf.mlir b/issues/aten_c_kernels/results/aten_fmax/debuf.mlir new file mode 100644 index 000000000000..f676ad00635a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmax/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmax(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @fmaxf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @fmaxf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fmax/matched.mlir b/issues/aten_c_kernels/results/aten_fmax/matched.mlir new file mode 100644 index 000000000000..f676ad00635a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmax/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmax(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @fmaxf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @fmaxf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fmax/orig.mlir b/issues/aten_c_kernels/results/aten_fmax/orig.mlir new file mode 100644 index 000000000000..492967de17eb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmax/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmax(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @fmaxf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @fmaxf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_fmax/raised.mlir b/issues/aten_c_kernels/results/aten_fmax/raised.mlir new file mode 100644 index 000000000000..1826fdb7ac05 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmax/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmax(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @fmaxf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @fmaxf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fmax_debuf.mlir b/issues/aten_c_kernels/results/aten_fmax_debuf.mlir new file mode 100644 index 000000000000..f676ad00635a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmax_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmax(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @fmaxf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @fmaxf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fmax_linalg.mlir b/issues/aten_c_kernels/results/aten_fmax_linalg.mlir new file mode 100644 index 000000000000..1826fdb7ac05 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmax_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmax(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @fmaxf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @fmaxf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fmin.mlir b/issues/aten_c_kernels/results/aten_fmin.mlir new file mode 100644 index 000000000000..654e92f74211 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmin.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmin(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @fminf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @fminf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_fmin/debuf.mlir b/issues/aten_c_kernels/results/aten_fmin/debuf.mlir new file mode 100644 index 000000000000..e4742cc3eb5a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmin/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmin(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @fminf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @fminf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fmin/matched.mlir b/issues/aten_c_kernels/results/aten_fmin/matched.mlir new file mode 100644 index 000000000000..e4742cc3eb5a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmin/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmin(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @fminf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @fminf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fmin/orig.mlir b/issues/aten_c_kernels/results/aten_fmin/orig.mlir new file mode 100644 index 000000000000..654e92f74211 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmin/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmin(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @fminf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @fminf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_fmin/raised.mlir b/issues/aten_c_kernels/results/aten_fmin/raised.mlir new file mode 100644 index 000000000000..b56ef131e919 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmin/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmin(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @fminf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @fminf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fmin_debuf.mlir b/issues/aten_c_kernels/results/aten_fmin_debuf.mlir new file mode 100644 index 000000000000..e4742cc3eb5a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmin_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmin(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @fminf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @fminf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fmin_linalg.mlir b/issues/aten_c_kernels/results/aten_fmin_linalg.mlir new file mode 100644 index 000000000000..b56ef131e919 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmin_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmin(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @fminf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @fminf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fmod.mlir b/issues/aten_c_kernels/results/aten_fmod.mlir new file mode 100644 index 000000000000..f696b6e055bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmod.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmod(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @fmodf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @fmodf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_fmod/debuf.mlir b/issues/aten_c_kernels/results/aten_fmod/debuf.mlir new file mode 100644 index 000000000000..7f35e60e2ec7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmod/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmod(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @fmodf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @fmodf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fmod/matched.mlir b/issues/aten_c_kernels/results/aten_fmod/matched.mlir new file mode 100644 index 000000000000..7f35e60e2ec7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmod/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmod(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @fmodf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @fmodf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fmod/orig.mlir b/issues/aten_c_kernels/results/aten_fmod/orig.mlir new file mode 100644 index 000000000000..f696b6e055bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmod/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmod(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @fmodf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @fmodf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_fmod/raised.mlir b/issues/aten_c_kernels/results/aten_fmod/raised.mlir new file mode 100644 index 000000000000..f5de5dcbecc5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmod/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmod(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @fmodf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @fmodf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fmod_debuf.mlir b/issues/aten_c_kernels/results/aten_fmod_debuf.mlir new file mode 100644 index 000000000000..7f35e60e2ec7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmod_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmod(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @fmodf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @fmodf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fmod_linalg.mlir b/issues/aten_c_kernels/results/aten_fmod_linalg.mlir new file mode 100644 index 000000000000..f5de5dcbecc5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fmod_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fmod(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @fmodf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @fmodf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_dot_cpu.mlir b/issues/aten_c_kernels/results/aten_fp16_dot_cpu.mlir new file mode 100644 index 000000000000..b3c89afe2c04 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_dot_cpu.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_dot_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3] : memref + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg4, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fp16_dot_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_fp16_dot_cpu/debuf.mlir new file mode 100644 index 000000000000..60569455d15b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_dot_cpu/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_dot_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_dot_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_fp16_dot_cpu/matched.mlir new file mode 100644 index 000000000000..94a08195f6b1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_dot_cpu/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_dot_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = kernel.launch @cublasSdot(%0, %1, %extracted_slice) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_dot_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_fp16_dot_cpu/orig.mlir new file mode 100644 index 000000000000..b3c89afe2c04 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_dot_cpu/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_dot_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3] : memref + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg4, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fp16_dot_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_fp16_dot_cpu/raised.mlir new file mode 100644 index 000000000000..4a8432a7fab8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_dot_cpu/raised.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_dot_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.store %cst, %arg2[0] : memref + %subview = memref.subview %arg2[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%arg0, %arg1 : memref, memref) outs(%subview : memref>) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %in, %in_0 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_dot_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_fp16_dot_cpu_debuf.mlir new file mode 100644 index 000000000000..60569455d15b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_dot_cpu_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_dot_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_dot_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_fp16_dot_cpu_linalg.mlir new file mode 100644 index 000000000000..4a8432a7fab8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_dot_cpu_linalg.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_dot_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.store %cst, %arg2[0] : memref + %subview = memref.subview %arg2[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%arg0, %arg1 : memref, memref) outs(%subview : memref>) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %in, %in_0 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu.mlir new file mode 100644 index 000000000000..8efb9b2dbc29 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_f16arith_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %0 = affine.for %arg4 = 0 to 96 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu/debuf.mlir new file mode 100644 index 000000000000..912e2299bfab --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_f16arith_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c96 = arith.constant 96 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c96] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c96] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c64] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c64] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu/matched.mlir new file mode 100644 index 000000000000..244e71fb1d9e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_f16arith_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c96 = arith.constant 96 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = kernel.launch @memset_zero_1D_f32(%2) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c96] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c96] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c64] [1] : tensor to tensor + %4 = kernel.launch @cublasSgemv(%extracted_slice, %extracted_slice_0, %extracted_slice_1) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c64] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu/orig.mlir new file mode 100644 index 000000000000..8efb9b2dbc29 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu/orig.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_f16arith_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %0 = affine.for %arg4 = 0 to 96 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu/raised.mlir new file mode 100644 index 000000000000..2cd3f3697f00 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_f16arith_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c96 = arith.constant 96 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c64, %c96] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c96] [1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c64] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu_debuf.mlir new file mode 100644 index 000000000000..912e2299bfab --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_f16arith_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c96 = arith.constant 96 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c96] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c96] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c64] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c64] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu_linalg.mlir new file mode 100644 index 000000000000..2cd3f3697f00 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_f16arith_cpu_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_f16arith_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c96 = arith.constant 96 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c64, %c96] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c96] [1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c64] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu.mlir new file mode 100644 index 000000000000..7070497887c5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_f32arith_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %0 = affine.for %arg4 = 0 to 96 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu/debuf.mlir new file mode 100644 index 000000000000..48f1b94dee59 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_f32arith_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c96 = arith.constant 96 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c96] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c96] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c64] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c64] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu/matched.mlir new file mode 100644 index 000000000000..7952ce1b33c7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_f32arith_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c96 = arith.constant 96 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = kernel.launch @memset_zero_1D_f32(%2) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c96] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c96] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c64] [1] : tensor to tensor + %4 = kernel.launch @cublasSgemv(%extracted_slice, %extracted_slice_0, %extracted_slice_1) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c64] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu/orig.mlir new file mode 100644 index 000000000000..7070497887c5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu/orig.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_f32arith_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %0 = affine.for %arg4 = 0 to 96 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu/raised.mlir new file mode 100644 index 000000000000..6d82b62efb52 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_f32arith_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c96 = arith.constant 96 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c64, %c96] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c96] [1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c64] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu_debuf.mlir new file mode 100644 index 000000000000..48f1b94dee59 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_f32arith_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c96 = arith.constant 96 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c96] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c96] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c64] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c64] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu_linalg.mlir new file mode 100644 index 000000000000..6d82b62efb52 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_f32arith_cpu_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_f32arith_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c96 = arith.constant 96 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c64, %c96] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c96] [1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c64] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu.mlir new file mode 100644 index 000000000000..793d2fd6fcff --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_notrans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %0 = affine.for %arg4 = 0 to 96 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu/debuf.mlir new file mode 100644 index 000000000000..70fefb018326 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_notrans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c96 = arith.constant 96 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c96] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c96] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c64] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c64] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu/matched.mlir new file mode 100644 index 000000000000..12c39e00ceaf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_notrans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c96 = arith.constant 96 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = kernel.launch @memset_zero_1D_f32(%2) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c96] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c96] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c64] [1] : tensor to tensor + %4 = kernel.launch @cublasSgemv(%extracted_slice, %extracted_slice_0, %extracted_slice_1) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c64] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu/orig.mlir new file mode 100644 index 000000000000..793d2fd6fcff --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu/orig.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_notrans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %0 = affine.for %arg4 = 0 to 96 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu/raised.mlir new file mode 100644 index 000000000000..761aa0ae8177 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_notrans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c96 = arith.constant 96 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c64, %c96] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c96] [1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c64] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu_debuf.mlir new file mode 100644 index 000000000000..70fefb018326 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_notrans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c96 = arith.constant 96 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c96] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c96] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c64] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c64] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu_linalg.mlir new file mode 100644 index 000000000000..761aa0ae8177 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_notrans_cpu_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_notrans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c96 = arith.constant 96 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c64, %c96] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c96] [1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c64] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu.mlir new file mode 100644 index 000000000000..bfbd609ffca9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_trans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 128 { + %0 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg4, %arg3] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu/debuf.mlir new file mode 100644 index 000000000000..88e2455113df --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_trans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c128 = arith.constant 128 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c128] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c64] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c128] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c128] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu/matched.mlir new file mode 100644 index 000000000000..b870c202a7f7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_trans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c128 = arith.constant 128 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = kernel.launch @memset_zero_1D_f32(%2) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c128] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c64] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c128] [1] : tensor to tensor + %4 = kernel.launch @cublasSgemv_T(%extracted_slice, %extracted_slice_0, %extracted_slice_1) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c128] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu/orig.mlir new file mode 100644 index 000000000000..bfbd609ffca9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu/orig.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_trans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 128 { + %0 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg4, %arg3] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu/raised.mlir new file mode 100644 index 000000000000..11e8da5492ba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_trans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c128 = arith.constant 128 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c64, %c128] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c64] [1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c128] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu_debuf.mlir new file mode 100644 index 000000000000..88e2455113df --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_trans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c128 = arith.constant 128 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c128] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c64] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c128] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c128] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu_linalg.mlir new file mode 100644 index 000000000000..11e8da5492ba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fp16_gemv_trans_cpu_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fp16_gemv_trans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c128 = arith.constant 128 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c64, %c128] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c64] [1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c128] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_frac.mlir b/issues/aten_c_kernels/results/aten_frac.mlir new file mode 100644 index 000000000000..1410d4bf14c6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_frac.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_frac(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @truncf(%0) : (f32) -> f32 + %2 = arith.subf %0, %1 : f32 + affine.store %2, %arg1[%arg2] : memref + } + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_frac/debuf.mlir b/issues/aten_c_kernels/results/aten_frac/debuf.mlir new file mode 100644 index 000000000000..7d8ed7beadfb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_frac/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_frac(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.trunc %in : f32 + %5 = arith.subf %in, %4 : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_frac/matched.mlir b/issues/aten_c_kernels/results/aten_frac/matched.mlir new file mode 100644 index 000000000000..7d8ed7beadfb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_frac/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_frac(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.trunc %in : f32 + %5 = arith.subf %in, %4 : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_frac/orig.mlir b/issues/aten_c_kernels/results/aten_frac/orig.mlir new file mode 100644 index 000000000000..1410d4bf14c6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_frac/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_frac(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @truncf(%0) : (f32) -> f32 + %2 = arith.subf %0, %1 : f32 + affine.store %2, %arg1[%arg2] : memref + } + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_frac/raised.mlir b/issues/aten_c_kernels/results/aten_frac/raised.mlir new file mode 100644 index 000000000000..1d8b0ebdad16 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_frac/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_frac(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.trunc %in : f32 + %1 = arith.subf %in, %0 : f32 + linalg.yield %1 : f32 + } + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_frac_debuf.mlir b/issues/aten_c_kernels/results/aten_frac_debuf.mlir new file mode 100644 index 000000000000..7d8ed7beadfb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_frac_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_frac(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.trunc %in : f32 + %5 = arith.subf %in, %4 : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_frac_linalg.mlir b/issues/aten_c_kernels/results/aten_frac_linalg.mlir new file mode 100644 index 000000000000..1d8b0ebdad16 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_frac_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_frac(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.trunc %in : f32 + %1 = arith.subf %in, %0 : f32 + linalg.yield %1 : f32 + } + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu.mlir new file mode 100644 index 000000000000..9d58f7286647 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 540 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %1 = affine.load %arg1[%arg3, %arg4, %arg5, %arg6] : memref + %2 = arith.divsi %1, %c10_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.remsi %1, %c10_i32 : i32 + %5 = arith.index_cast %4 : i32 to index + %6 = affine.load %arg0[%arg3, %arg4, %arg5, %arg6] : memref + %7 = memref.load %arg2[%arg3, %arg4, %3, %5] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg2[%arg3, %arg4, %3, %5] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..88cd54128c3d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu/debuf.mlir @@ -0,0 +1,33 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c10_i32 = arith.constant 10 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 540 { + %3 = arith.index_cast %arg3 : index to i32 + %4 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %4 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %extracted = tensor.extract %0[%arg3, %arg4, %arg5, %arg6] : tensor + %3 = arith.divsi %extracted, %c10_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = arith.remsi %extracted, %c10_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + %extracted_0 = tensor.extract %1[%arg3, %arg4, %arg5, %arg6] : tensor + %7 = memref.load %arg2[%arg3, %arg4, %4, %6] : memref + %8 = arith.addf %7, %extracted_0 : f32 + memref.store %8, %arg2[%arg3, %arg4, %4, %6] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..88cd54128c3d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu/matched.mlir @@ -0,0 +1,33 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c10_i32 = arith.constant 10 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 540 { + %3 = arith.index_cast %arg3 : index to i32 + %4 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %4 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %extracted = tensor.extract %0[%arg3, %arg4, %arg5, %arg6] : tensor + %3 = arith.divsi %extracted, %c10_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = arith.remsi %extracted, %c10_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + %extracted_0 = tensor.extract %1[%arg3, %arg4, %arg5, %arg6] : tensor + %7 = memref.load %arg2[%arg3, %arg4, %4, %6] : memref + %8 = arith.addf %7, %extracted_0 : f32 + memref.store %8, %arg2[%arg3, %arg4, %4, %6] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..9d58f7286647 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu/orig.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 540 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %1 = affine.load %arg1[%arg3, %arg4, %arg5, %arg6] : memref + %2 = arith.divsi %1, %c10_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.remsi %1, %c10_i32 : i32 + %5 = arith.index_cast %4 : i32 to index + %6 = affine.load %arg0[%arg3, %arg4, %arg5, %arg6] : memref + %7 = memref.load %arg2[%arg3, %arg4, %3, %5] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg2[%arg3, %arg4, %3, %5] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..985ae2dc1c05 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu/raised.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 540 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %1 = affine.load %arg1[%arg3, %arg4, %arg5, %arg6] : memref + %2 = arith.divsi %1, %c10_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.remsi %1, %c10_i32 : i32 + %5 = arith.index_cast %4 : i32 to index + %6 = affine.load %arg0[%arg3, %arg4, %arg5, %arg6] : memref + %7 = memref.load %arg2[%arg3, %arg4, %3, %5] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg2[%arg3, %arg4, %3, %5] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..88cd54128c3d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu_debuf.mlir @@ -0,0 +1,33 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c10_i32 = arith.constant 10 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 540 { + %3 = arith.index_cast %arg3 : index to i32 + %4 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %4 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %extracted = tensor.extract %0[%arg3, %arg4, %arg5, %arg6] : tensor + %3 = arith.divsi %extracted, %c10_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = arith.remsi %extracted, %c10_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + %extracted_0 = tensor.extract %1[%arg3, %arg4, %arg5, %arg6] : tensor + %7 = memref.load %arg2[%arg3, %arg4, %4, %6] : memref + %8 = arith.addf %7, %extracted_0 : f32 + memref.store %8, %arg2[%arg3, %arg4, %4, %6] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..985ae2dc1c05 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_backward_cpu_linalg.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 540 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %1 = affine.load %arg1[%arg3, %arg4, %arg5, %arg6] : memref + %2 = arith.divsi %1, %c10_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.remsi %1, %c10_i32 : i32 + %5 = arith.index_cast %4 : i32 to index + %6 = affine.load %arg0[%arg3, %arg4, %arg5, %arg6] : memref + %7 = memref.load %arg2[%arg3, %arg4, %3, %5] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg2[%arg3, %arg4, %3, %5] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu.mlir new file mode 100644 index 000000000000..f7c6be75790b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu.mlir @@ -0,0 +1,65 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 6.000000e+00 : f32 + %cst_0 = arith.constant 3.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 4.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %cst_3 = arith.constant -3.40282347E+38 : f32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 4 { + %0 = arith.index_cast %arg6 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + affine.for %arg7 = 0 to 5 { + %2 = arith.index_cast %arg7 : index to i32 + %3 = affine.load %arg1[%arg4, %arg5, 0] : memref + %4 = arith.addf %1, %3 : f32 + %5 = arith.mulf %4, %cst : f32 + %6 = arith.divf %5, %cst_0 : f32 + %7 = arith.fptosi %6 : f32 to i32 + %8 = arith.sitofp %2 : i32 to f32 + %9 = affine.load %arg1[%arg4, %arg5, 1] : memref + %10 = arith.addf %8, %9 : f32 + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.divf %11, %cst_2 : f32 + %13 = arith.fptosi %12 : f32 to i32 + %14 = arith.cmpi sgt, %7, %c6_i32 : i32 + %15 = arith.select %14, %c6_i32, %7 : i32 + %16 = arith.cmpi sgt, %13, %c7_i32 : i32 + %17 = arith.select %16, %c7_i32, %13 : i32 + %18:2 = affine.for %arg8 = 0 to 3 iter_args(%arg9 = %c0_i32, %arg10 = %cst_3) -> (i32, f32) { + %19 = arith.index_cast %arg8 : index to i32 + %20 = arith.addi %15, %19 : i32 + %21 = arith.index_cast %20 : i32 to index + %22 = arith.muli %20, %c10_i32 : i32 + %23 = arith.addi %22, %17 : i32 + %24:2 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %arg9, %arg13 = %arg10) -> (i32, f32) { + %25 = arith.index_cast %arg11 : index to i32 + %26 = arith.addi %17, %25 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = memref.load %arg0[%arg4, %arg5, %21, %27] : memref + %29 = arith.cmpf ogt, %28, %arg13 : f32 + %30:2 = scf.if %29 -> (i32, f32) { + %31 = memref.load %arg0[%arg4, %arg5, %21, %27] : memref + %32 = arith.addi %23, %25 : i32 + scf.yield %32, %31 : i32, f32 + } else { + scf.yield %arg12, %arg13 : i32, f32 + } + affine.yield %30#0, %30#1 : i32, f32 + } + affine.yield %24#0, %24#1 : i32, f32 + } + affine.store %18#1, %arg2[%arg4, %arg5, %arg6, %arg7] : memref + affine.store %18#0, %arg3[%arg4, %arg5, %arg6, %arg7] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu/debuf.mlir new file mode 100644 index 000000000000..1d1c54cd3444 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu/debuf.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2:2 = affine.for %arg4 = 0 to 2 iter_args(%arg5 = %1, %arg6 = %0) -> (tensor, tensor) { + %5:2 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %arg5, %arg9 = %arg6) -> (tensor, tensor) { + %6:2 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (tensor, tensor) { + %alloca = memref.alloca(%c5) : memref + %7 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c5) : memref + %8 = bufferization.to_tensor %alloca_0 : memref + %extracted_slice = tensor.extract_slice %arg11[%arg4, %arg7, %arg10, 0] [1, 1, 1, %c5] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %8[0] [%c5] [1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %9 into %arg11[%arg4, %arg7, %arg10, 0] [1, 1, 1, %c5] [1, 1, 1, 1] : tensor into tensor + %extracted_slice_2 = tensor.extract_slice %arg12[%arg4, %arg7, %arg10, 0] [1, 1, 1, %c5] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %7[0] [%c5] [1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %inserted_slice_4 = tensor.insert_slice %10 into %arg12[%arg4, %arg7, %arg10, 0] [1, 1, 1, %c5] [1, 1, 1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_slice_4 : tensor, tensor + } + affine.yield %6#0, %6#1 : tensor, tensor + } + affine.yield %5#0, %5#1 : tensor, tensor + } + %3 = bufferization.to_memref %2#1 : memref + memref.copy %3, %arg3 : memref to memref + %4 = bufferization.to_memref %2#0 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu/matched.mlir new file mode 100644 index 000000000000..17dc16f441f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu/matched.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2:2 = affine.for %arg4 = 0 to 2 iter_args(%arg5 = %1, %arg6 = %0) -> (tensor, tensor) { + %5:2 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %arg5, %arg9 = %arg6) -> (tensor, tensor) { + %6:2 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (tensor, tensor) { + %alloca = memref.alloca(%c5) : memref + %7 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c5) : memref + %8 = bufferization.to_tensor %alloca_0 : memref + %extracted_slice = tensor.extract_slice %arg11[%arg4, %arg7, %arg10, 0] [1, 1, 1, %c5] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %8[0] [%c5] [1] : tensor to tensor + %9 = kernel.launch @cudaCopy1D_f32_tensor(%extracted_slice_1, %extracted_slice) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %9 into %arg11[%arg4, %arg7, %arg10, 0] [1, 1, 1, %c5] [1, 1, 1, 1] : tensor into tensor + %extracted_slice_2 = tensor.extract_slice %arg12[%arg4, %arg7, %arg10, 0] [1, 1, 1, %c5] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %7[0] [%c5] [1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %inserted_slice_4 = tensor.insert_slice %10 into %arg12[%arg4, %arg7, %arg10, 0] [1, 1, 1, %c5] [1, 1, 1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_slice_4 : tensor, tensor + } + affine.yield %6#0, %6#1 : tensor, tensor + } + affine.yield %5#0, %5#1 : tensor, tensor + } + %3 = bufferization.to_memref %2#1 : memref + memref.copy %3, %arg3 : memref to memref + %4 = bufferization.to_memref %2#0 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu/orig.mlir new file mode 100644 index 000000000000..f7c6be75790b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu/orig.mlir @@ -0,0 +1,65 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 6.000000e+00 : f32 + %cst_0 = arith.constant 3.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 4.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %cst_3 = arith.constant -3.40282347E+38 : f32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 4 { + %0 = arith.index_cast %arg6 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + affine.for %arg7 = 0 to 5 { + %2 = arith.index_cast %arg7 : index to i32 + %3 = affine.load %arg1[%arg4, %arg5, 0] : memref + %4 = arith.addf %1, %3 : f32 + %5 = arith.mulf %4, %cst : f32 + %6 = arith.divf %5, %cst_0 : f32 + %7 = arith.fptosi %6 : f32 to i32 + %8 = arith.sitofp %2 : i32 to f32 + %9 = affine.load %arg1[%arg4, %arg5, 1] : memref + %10 = arith.addf %8, %9 : f32 + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.divf %11, %cst_2 : f32 + %13 = arith.fptosi %12 : f32 to i32 + %14 = arith.cmpi sgt, %7, %c6_i32 : i32 + %15 = arith.select %14, %c6_i32, %7 : i32 + %16 = arith.cmpi sgt, %13, %c7_i32 : i32 + %17 = arith.select %16, %c7_i32, %13 : i32 + %18:2 = affine.for %arg8 = 0 to 3 iter_args(%arg9 = %c0_i32, %arg10 = %cst_3) -> (i32, f32) { + %19 = arith.index_cast %arg8 : index to i32 + %20 = arith.addi %15, %19 : i32 + %21 = arith.index_cast %20 : i32 to index + %22 = arith.muli %20, %c10_i32 : i32 + %23 = arith.addi %22, %17 : i32 + %24:2 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %arg9, %arg13 = %arg10) -> (i32, f32) { + %25 = arith.index_cast %arg11 : index to i32 + %26 = arith.addi %17, %25 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = memref.load %arg0[%arg4, %arg5, %21, %27] : memref + %29 = arith.cmpf ogt, %28, %arg13 : f32 + %30:2 = scf.if %29 -> (i32, f32) { + %31 = memref.load %arg0[%arg4, %arg5, %21, %27] : memref + %32 = arith.addi %23, %25 : i32 + scf.yield %32, %31 : i32, f32 + } else { + scf.yield %arg12, %arg13 : i32, f32 + } + affine.yield %30#0, %30#1 : i32, f32 + } + affine.yield %24#0, %24#1 : i32, f32 + } + affine.store %18#1, %arg2[%arg4, %arg5, %arg6, %arg7] : memref + affine.store %18#0, %arg3[%arg4, %arg5, %arg6, %arg7] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu/raised.mlir new file mode 100644 index 000000000000..a725010b7d51 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu/raised.mlir @@ -0,0 +1,98 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 6.000000e+00 : f32 + %cst_0 = arith.constant 3.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 4.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %cst_3 = arith.constant -3.40282347E+38 : f32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 4 { + %0 = arith.index_cast %arg6 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %alloca = memref.alloca(%c5) : memref + %alloca_4 = memref.alloca(%c5) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_4 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_3 : f32 + } + affine.for %arg7 = 0 to 5 { + %2 = arith.index_cast %arg7 : index to i32 + %3 = affine.load %arg1[%arg4, %arg5, 0] : memref + %4 = arith.addf %1, %3 : f32 + %5 = arith.mulf %4, %cst : f32 + %6 = arith.divf %5, %cst_0 : f32 + %7 = arith.fptosi %6 : f32 to i32 + %8 = arith.sitofp %2 : i32 to f32 + %9 = affine.load %arg1[%arg4, %arg5, 1] : memref + %10 = arith.addf %8, %9 : f32 + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.divf %11, %cst_2 : f32 + %13 = arith.fptosi %12 : f32 to i32 + %14 = arith.cmpi sgt, %7, %c6_i32 : i32 + %15 = arith.select %14, %c6_i32, %7 : i32 + %16 = arith.cmpi sgt, %13, %c7_i32 : i32 + %17 = arith.select %16, %c7_i32, %13 : i32 + %alloca_8 = memref.alloca(%c3) : memref + %alloca_9 = memref.alloca(%c3) : memref + affine.for %arg8 = 0 to 3 { + %18 = affine.load %alloca[%arg7] : memref + %19 = affine.load %alloca_4[%arg7] : memref + %20 = arith.index_cast %arg8 : index to i32 + %21 = arith.addi %15, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = arith.muli %21, %c10_i32 : i32 + %24 = arith.addi %23, %17 : i32 + affine.store %18, %alloca_8[%arg8] : memref + affine.store %19, %alloca_9[%arg8] : memref + affine.for %arg9 = 0 to 3 { + %27 = affine.load %alloca_8[%arg8] : memref + %28 = affine.load %alloca_9[%arg8] : memref + %29 = arith.index_cast %arg9 : index to i32 + %30 = arith.addi %17, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %arg0[%arg4, %arg5, %22, %31] : memref + %33 = arith.cmpf ogt, %32, %28 : f32 + %34 = memref.load %arg0[%arg4, %arg5, %22, %31] : memref + %35 = arith.addi %24, %29 : i32 + %36 = arith.select %33, %35, %27 : i32 + %37 = arith.select %33, %34, %28 : f32 + affine.store %36, %alloca_8[%arg8] : memref + affine.store %37, %alloca_9[%arg8] : memref + } + %25 = affine.load %alloca_8[%arg8] : memref + %26 = affine.load %alloca_9[%arg8] : memref + affine.store %25, %alloca[%arg7] : memref + affine.store %26, %alloca_4[%arg7] : memref + } + } + %subview = memref.subview %alloca_4[0] [%c5] [1] : memref to memref> + %subview_5 = memref.subview %arg2[%arg4, %arg5, %arg6, 0] [1, 1, 1, %c5] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_5 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_6 = memref.subview %alloca[0] [%c5] [1] : memref to memref> + %subview_7 = memref.subview %arg3[%arg4, %arg5, %arg6, 0] [1, 1, 1, %c5] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_6 : memref>) outs(%subview_7 : memref>) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu_debuf.mlir new file mode 100644 index 000000000000..1d1c54cd3444 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu_debuf.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2:2 = affine.for %arg4 = 0 to 2 iter_args(%arg5 = %1, %arg6 = %0) -> (tensor, tensor) { + %5:2 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %arg5, %arg9 = %arg6) -> (tensor, tensor) { + %6:2 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (tensor, tensor) { + %alloca = memref.alloca(%c5) : memref + %7 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c5) : memref + %8 = bufferization.to_tensor %alloca_0 : memref + %extracted_slice = tensor.extract_slice %arg11[%arg4, %arg7, %arg10, 0] [1, 1, 1, %c5] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %8[0] [%c5] [1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %9 into %arg11[%arg4, %arg7, %arg10, 0] [1, 1, 1, %c5] [1, 1, 1, 1] : tensor into tensor + %extracted_slice_2 = tensor.extract_slice %arg12[%arg4, %arg7, %arg10, 0] [1, 1, 1, %c5] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %7[0] [%c5] [1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %inserted_slice_4 = tensor.insert_slice %10 into %arg12[%arg4, %arg7, %arg10, 0] [1, 1, 1, %c5] [1, 1, 1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_slice_4 : tensor, tensor + } + affine.yield %6#0, %6#1 : tensor, tensor + } + affine.yield %5#0, %5#1 : tensor, tensor + } + %3 = bufferization.to_memref %2#1 : memref + memref.copy %3, %arg3 : memref to memref + %4 = bufferization.to_memref %2#0 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu_linalg.mlir new file mode 100644 index 000000000000..a725010b7d51 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool2d_cpu_linalg.mlir @@ -0,0 +1,98 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 6.000000e+00 : f32 + %cst_0 = arith.constant 3.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 4.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %cst_3 = arith.constant -3.40282347E+38 : f32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 4 { + %0 = arith.index_cast %arg6 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %alloca = memref.alloca(%c5) : memref + %alloca_4 = memref.alloca(%c5) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_4 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_3 : f32 + } + affine.for %arg7 = 0 to 5 { + %2 = arith.index_cast %arg7 : index to i32 + %3 = affine.load %arg1[%arg4, %arg5, 0] : memref + %4 = arith.addf %1, %3 : f32 + %5 = arith.mulf %4, %cst : f32 + %6 = arith.divf %5, %cst_0 : f32 + %7 = arith.fptosi %6 : f32 to i32 + %8 = arith.sitofp %2 : i32 to f32 + %9 = affine.load %arg1[%arg4, %arg5, 1] : memref + %10 = arith.addf %8, %9 : f32 + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.divf %11, %cst_2 : f32 + %13 = arith.fptosi %12 : f32 to i32 + %14 = arith.cmpi sgt, %7, %c6_i32 : i32 + %15 = arith.select %14, %c6_i32, %7 : i32 + %16 = arith.cmpi sgt, %13, %c7_i32 : i32 + %17 = arith.select %16, %c7_i32, %13 : i32 + %alloca_8 = memref.alloca(%c3) : memref + %alloca_9 = memref.alloca(%c3) : memref + affine.for %arg8 = 0 to 3 { + %18 = affine.load %alloca[%arg7] : memref + %19 = affine.load %alloca_4[%arg7] : memref + %20 = arith.index_cast %arg8 : index to i32 + %21 = arith.addi %15, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = arith.muli %21, %c10_i32 : i32 + %24 = arith.addi %23, %17 : i32 + affine.store %18, %alloca_8[%arg8] : memref + affine.store %19, %alloca_9[%arg8] : memref + affine.for %arg9 = 0 to 3 { + %27 = affine.load %alloca_8[%arg8] : memref + %28 = affine.load %alloca_9[%arg8] : memref + %29 = arith.index_cast %arg9 : index to i32 + %30 = arith.addi %17, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %arg0[%arg4, %arg5, %22, %31] : memref + %33 = arith.cmpf ogt, %32, %28 : f32 + %34 = memref.load %arg0[%arg4, %arg5, %22, %31] : memref + %35 = arith.addi %24, %29 : i32 + %36 = arith.select %33, %35, %27 : i32 + %37 = arith.select %33, %34, %28 : f32 + affine.store %36, %alloca_8[%arg8] : memref + affine.store %37, %alloca_9[%arg8] : memref + } + %25 = affine.load %alloca_8[%arg8] : memref + %26 = affine.load %alloca_9[%arg8] : memref + affine.store %25, %alloca[%arg7] : memref + affine.store %26, %alloca_4[%arg7] : memref + } + } + %subview = memref.subview %alloca_4[0] [%c5] [1] : memref to memref> + %subview_5 = memref.subview %arg2[%arg4, %arg5, %arg6, 0] [1, 1, 1, %c5] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_5 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_6 = memref.subview %alloca[0] [%c5] [1] : memref to memref> + %subview_7 = memref.subview %arg3[%arg4, %arg5, %arg6, 0] [1, 1, 1, %c5] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_6 : memref>) outs(%subview_7 : memref>) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu.mlir new file mode 100644 index 000000000000..60bcce523266 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu.mlir @@ -0,0 +1,36 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c90_i32 = arith.constant 90 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %c9_i32 = arith.constant 9 : i32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %1 = affine.load %arg1[0, %arg3, %arg4, %arg5, %arg6] : memref + %2 = arith.divsi %1, %c90_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.divsi %1, %c10_i32 : i32 + %5 = arith.remsi %4, %c9_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + %7 = arith.remsi %1, %c10_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[0, %arg3, %arg4, %arg5, %arg6] : memref + %10 = memref.load %arg2[%c0, %arg3, %3, %6, %8] : memref + %11 = arith.addf %10, %9 : f32 + memref.store %11, %arg2[%c0, %arg3, %3, %6, %8] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..f97af1e54da0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu/debuf.mlir @@ -0,0 +1,39 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c9_i32 = arith.constant 9 : i32 + %c10_i32 = arith.constant 10 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c90_i32 = arith.constant 90 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %3 = arith.index_cast %arg3 : index to i32 + %4 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %4 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %extracted = tensor.extract %0[%c0, %arg3, %arg4, %arg5, %arg6] : tensor + %3 = arith.divsi %extracted, %c90_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = arith.divsi %extracted, %c10_i32 : i32 + %6 = arith.remsi %5, %c9_i32 : i32 + %7 = arith.index_cast %6 : i32 to index + %8 = arith.remsi %extracted, %c10_i32 : i32 + %9 = arith.index_cast %8 : i32 to index + %extracted_0 = tensor.extract %1[%c0, %arg3, %arg4, %arg5, %arg6] : tensor + %10 = memref.load %arg2[%c0, %arg3, %4, %7, %9] : memref + %11 = arith.addf %10, %extracted_0 : f32 + memref.store %11, %arg2[%c0, %arg3, %4, %7, %9] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..f97af1e54da0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu/matched.mlir @@ -0,0 +1,39 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c9_i32 = arith.constant 9 : i32 + %c10_i32 = arith.constant 10 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c90_i32 = arith.constant 90 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %3 = arith.index_cast %arg3 : index to i32 + %4 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %4 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %extracted = tensor.extract %0[%c0, %arg3, %arg4, %arg5, %arg6] : tensor + %3 = arith.divsi %extracted, %c90_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = arith.divsi %extracted, %c10_i32 : i32 + %6 = arith.remsi %5, %c9_i32 : i32 + %7 = arith.index_cast %6 : i32 to index + %8 = arith.remsi %extracted, %c10_i32 : i32 + %9 = arith.index_cast %8 : i32 to index + %extracted_0 = tensor.extract %1[%c0, %arg3, %arg4, %arg5, %arg6] : tensor + %10 = memref.load %arg2[%c0, %arg3, %4, %7, %9] : memref + %11 = arith.addf %10, %extracted_0 : f32 + memref.store %11, %arg2[%c0, %arg3, %4, %7, %9] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..60bcce523266 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu/orig.mlir @@ -0,0 +1,36 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c90_i32 = arith.constant 90 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %c9_i32 = arith.constant 9 : i32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %1 = affine.load %arg1[0, %arg3, %arg4, %arg5, %arg6] : memref + %2 = arith.divsi %1, %c90_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.divsi %1, %c10_i32 : i32 + %5 = arith.remsi %4, %c9_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + %7 = arith.remsi %1, %c10_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[0, %arg3, %arg4, %arg5, %arg6] : memref + %10 = memref.load %arg2[%c0, %arg3, %3, %6, %8] : memref + %11 = arith.addf %10, %9 : f32 + memref.store %11, %arg2[%c0, %arg3, %3, %6, %8] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..bcd435c74b6b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu/raised.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c90_i32 = arith.constant 90 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %c9_i32 = arith.constant 9 : i32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %1 = affine.load %arg1[0, %arg3, %arg4, %arg5, %arg6] : memref + %2 = arith.divsi %1, %c90_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.divsi %1, %c10_i32 : i32 + %5 = arith.remsi %4, %c9_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + %7 = arith.remsi %1, %c10_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[0, %arg3, %arg4, %arg5, %arg6] : memref + %10 = memref.load %arg2[%c0, %arg3, %3, %6, %8] : memref + %11 = arith.addf %10, %9 : f32 + memref.store %11, %arg2[%c0, %arg3, %3, %6, %8] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..f97af1e54da0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu_debuf.mlir @@ -0,0 +1,39 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c9_i32 = arith.constant 9 : i32 + %c10_i32 = arith.constant 10 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c90_i32 = arith.constant 90 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %3 = arith.index_cast %arg3 : index to i32 + %4 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %4 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %extracted = tensor.extract %0[%c0, %arg3, %arg4, %arg5, %arg6] : tensor + %3 = arith.divsi %extracted, %c90_i32 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = arith.divsi %extracted, %c10_i32 : i32 + %6 = arith.remsi %5, %c9_i32 : i32 + %7 = arith.index_cast %6 : i32 to index + %8 = arith.remsi %extracted, %c10_i32 : i32 + %9 = arith.index_cast %8 : i32 to index + %extracted_0 = tensor.extract %1[%c0, %arg3, %arg4, %arg5, %arg6] : tensor + %10 = memref.load %arg2[%c0, %arg3, %4, %7, %9] : memref + %11 = arith.addf %10, %extracted_0 : f32 + memref.store %11, %arg2[%c0, %arg3, %4, %7, %9] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..bcd435c74b6b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_backward_cpu_linalg.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c90_i32 = arith.constant 90 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %c9_i32 = arith.constant 9 : i32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %1 = affine.load %arg1[0, %arg3, %arg4, %arg5, %arg6] : memref + %2 = arith.divsi %1, %c90_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.divsi %1, %c10_i32 : i32 + %5 = arith.remsi %4, %c9_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + %7 = arith.remsi %1, %c10_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[0, %arg3, %arg4, %arg5, %arg6] : memref + %10 = memref.load %arg2[%c0, %arg3, %3, %6, %8] : memref + %11 = arith.addf %10, %9 : f32 + memref.store %11, %arg2[%c0, %arg3, %3, %6, %8] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu.mlir new file mode 100644 index 000000000000..25aed31ec4e4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu.mlir @@ -0,0 +1,86 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 2.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %cst_1 = arith.constant 3.000000e+00 : f32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %cst_3 = arith.constant 4.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %c9_i32 = arith.constant 9 : i32 + %cst_4 = arith.constant -3.40282347E+38 : f32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 3 { + %0 = arith.index_cast %arg5 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + affine.for %arg6 = 0 to 4 { + %2 = arith.index_cast %arg6 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + affine.for %arg7 = 0 to 5 { + %4 = arith.index_cast %arg7 : index to i32 + %5 = affine.load %arg1[0, %arg4, 0] : memref + %6 = arith.addf %1, %5 : f32 + %7 = arith.mulf %6, %cst_0 : f32 + %8 = arith.divf %7, %cst : f32 + %9 = arith.fptosi %8 : f32 to i32 + %10 = affine.load %arg1[0, %arg4, 1] : memref + %11 = arith.addf %3, %10 : f32 + %12 = arith.mulf %11, %cst_0 : f32 + %13 = arith.divf %12, %cst_1 : f32 + %14 = arith.fptosi %13 : f32 to i32 + %15 = arith.sitofp %4 : i32 to f32 + %16 = affine.load %arg1[0, %arg4, 2] : memref + %17 = arith.addf %15, %16 : f32 + %18 = arith.mulf %17, %cst_2 : f32 + %19 = arith.divf %18, %cst_3 : f32 + %20 = arith.fptosi %19 : f32 to i32 + %21 = arith.cmpi sgt, %9, %c6_i32 : i32 + %22 = arith.select %21, %c6_i32, %9 : i32 + %23 = arith.cmpi sgt, %14, %c6_i32 : i32 + %24 = arith.select %23, %c6_i32, %14 : i32 + %25 = arith.cmpi sgt, %20, %c7_i32 : i32 + %26 = arith.select %25, %c7_i32, %20 : i32 + %27:2 = affine.for %arg8 = 0 to 2 iter_args(%arg9 = %c0_i32, %arg10 = %cst_4) -> (i32, f32) { + %28 = arith.index_cast %arg8 : index to i32 + %29 = arith.addi %22, %28 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = arith.muli %29, %c9_i32 : i32 + %32 = arith.addi %31, %24 : i32 + %33:2 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %arg9, %arg13 = %arg10) -> (i32, f32) { + %34 = arith.index_cast %arg11 : index to i32 + %35 = arith.addi %24, %34 : i32 + %36 = arith.index_cast %35 : i32 to index + %37 = arith.addi %32, %34 : i32 + %38 = arith.muli %37, %c10_i32 : i32 + %39 = arith.addi %38, %26 : i32 + %40:2 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %arg12, %arg16 = %arg13) -> (i32, f32) { + %41 = arith.index_cast %arg14 : index to i32 + %42 = arith.addi %26, %41 : i32 + %43 = arith.index_cast %42 : i32 to index + %44 = memref.load %arg0[%c0, %arg4, %30, %36, %43] : memref + %45 = arith.cmpf ogt, %44, %arg16 : f32 + %46:2 = scf.if %45 -> (i32, f32) { + %47 = memref.load %arg0[%c0, %arg4, %30, %36, %43] : memref + %48 = arith.addi %39, %41 : i32 + scf.yield %48, %47 : i32, f32 + } else { + scf.yield %arg15, %arg16 : i32, f32 + } + affine.yield %46#0, %46#1 : i32, f32 + } + affine.yield %40#0, %40#1 : i32, f32 + } + affine.yield %33#0, %33#1 : i32, f32 + } + affine.store %27#1, %arg2[0, %arg4, %arg5, %arg6, %arg7] : memref + affine.store %27#0, %arg3[0, %arg4, %arg5, %arg6, %arg7] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu/debuf.mlir new file mode 100644 index 000000000000..608b8a36d7f8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu/debuf.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2:2 = affine.for %arg4 = 0 to 2 iter_args(%arg5 = %1, %arg6 = %0) -> (tensor, tensor) { + %5:2 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %arg5, %arg9 = %arg6) -> (tensor, tensor) { + %6:2 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (tensor, tensor) { + %alloca = memref.alloca(%c5) : memref + %7 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c5) : memref + %8 = bufferization.to_tensor %alloca_0 : memref + %extracted_slice = tensor.extract_slice %arg11[0, %arg4, %arg7, %arg10, 0] [1, 1, 1, 1, %c5] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %8[0] [%c5] [1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %9 into %arg11[0, %arg4, %arg7, %arg10, 0] [1, 1, 1, 1, %c5] [1, 1, 1, 1, 1] : tensor into tensor + %extracted_slice_2 = tensor.extract_slice %arg12[0, %arg4, %arg7, %arg10, 0] [1, 1, 1, 1, %c5] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %7[0] [%c5] [1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %inserted_slice_4 = tensor.insert_slice %10 into %arg12[0, %arg4, %arg7, %arg10, 0] [1, 1, 1, 1, %c5] [1, 1, 1, 1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_slice_4 : tensor, tensor + } + affine.yield %6#0, %6#1 : tensor, tensor + } + affine.yield %5#0, %5#1 : tensor, tensor + } + %3 = bufferization.to_memref %2#1 : memref + memref.copy %3, %arg3 : memref to memref + %4 = bufferization.to_memref %2#0 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu/matched.mlir new file mode 100644 index 000000000000..92fad0a87b2d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu/matched.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2:2 = affine.for %arg4 = 0 to 2 iter_args(%arg5 = %1, %arg6 = %0) -> (tensor, tensor) { + %5:2 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %arg5, %arg9 = %arg6) -> (tensor, tensor) { + %6:2 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (tensor, tensor) { + %alloca = memref.alloca(%c5) : memref + %7 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c5) : memref + %8 = bufferization.to_tensor %alloca_0 : memref + %extracted_slice = tensor.extract_slice %arg11[0, %arg4, %arg7, %arg10, 0] [1, 1, 1, 1, %c5] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %8[0] [%c5] [1] : tensor to tensor + %9 = kernel.launch @cudaCopy1D_f32_tensor(%extracted_slice_1, %extracted_slice) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %9 into %arg11[0, %arg4, %arg7, %arg10, 0] [1, 1, 1, 1, %c5] [1, 1, 1, 1, 1] : tensor into tensor + %extracted_slice_2 = tensor.extract_slice %arg12[0, %arg4, %arg7, %arg10, 0] [1, 1, 1, 1, %c5] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %7[0] [%c5] [1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %inserted_slice_4 = tensor.insert_slice %10 into %arg12[0, %arg4, %arg7, %arg10, 0] [1, 1, 1, 1, %c5] [1, 1, 1, 1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_slice_4 : tensor, tensor + } + affine.yield %6#0, %6#1 : tensor, tensor + } + affine.yield %5#0, %5#1 : tensor, tensor + } + %3 = bufferization.to_memref %2#1 : memref + memref.copy %3, %arg3 : memref to memref + %4 = bufferization.to_memref %2#0 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu/orig.mlir new file mode 100644 index 000000000000..25aed31ec4e4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu/orig.mlir @@ -0,0 +1,86 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 2.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %cst_1 = arith.constant 3.000000e+00 : f32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %cst_3 = arith.constant 4.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %c9_i32 = arith.constant 9 : i32 + %cst_4 = arith.constant -3.40282347E+38 : f32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 3 { + %0 = arith.index_cast %arg5 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + affine.for %arg6 = 0 to 4 { + %2 = arith.index_cast %arg6 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + affine.for %arg7 = 0 to 5 { + %4 = arith.index_cast %arg7 : index to i32 + %5 = affine.load %arg1[0, %arg4, 0] : memref + %6 = arith.addf %1, %5 : f32 + %7 = arith.mulf %6, %cst_0 : f32 + %8 = arith.divf %7, %cst : f32 + %9 = arith.fptosi %8 : f32 to i32 + %10 = affine.load %arg1[0, %arg4, 1] : memref + %11 = arith.addf %3, %10 : f32 + %12 = arith.mulf %11, %cst_0 : f32 + %13 = arith.divf %12, %cst_1 : f32 + %14 = arith.fptosi %13 : f32 to i32 + %15 = arith.sitofp %4 : i32 to f32 + %16 = affine.load %arg1[0, %arg4, 2] : memref + %17 = arith.addf %15, %16 : f32 + %18 = arith.mulf %17, %cst_2 : f32 + %19 = arith.divf %18, %cst_3 : f32 + %20 = arith.fptosi %19 : f32 to i32 + %21 = arith.cmpi sgt, %9, %c6_i32 : i32 + %22 = arith.select %21, %c6_i32, %9 : i32 + %23 = arith.cmpi sgt, %14, %c6_i32 : i32 + %24 = arith.select %23, %c6_i32, %14 : i32 + %25 = arith.cmpi sgt, %20, %c7_i32 : i32 + %26 = arith.select %25, %c7_i32, %20 : i32 + %27:2 = affine.for %arg8 = 0 to 2 iter_args(%arg9 = %c0_i32, %arg10 = %cst_4) -> (i32, f32) { + %28 = arith.index_cast %arg8 : index to i32 + %29 = arith.addi %22, %28 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = arith.muli %29, %c9_i32 : i32 + %32 = arith.addi %31, %24 : i32 + %33:2 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %arg9, %arg13 = %arg10) -> (i32, f32) { + %34 = arith.index_cast %arg11 : index to i32 + %35 = arith.addi %24, %34 : i32 + %36 = arith.index_cast %35 : i32 to index + %37 = arith.addi %32, %34 : i32 + %38 = arith.muli %37, %c10_i32 : i32 + %39 = arith.addi %38, %26 : i32 + %40:2 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %arg12, %arg16 = %arg13) -> (i32, f32) { + %41 = arith.index_cast %arg14 : index to i32 + %42 = arith.addi %26, %41 : i32 + %43 = arith.index_cast %42 : i32 to index + %44 = memref.load %arg0[%c0, %arg4, %30, %36, %43] : memref + %45 = arith.cmpf ogt, %44, %arg16 : f32 + %46:2 = scf.if %45 -> (i32, f32) { + %47 = memref.load %arg0[%c0, %arg4, %30, %36, %43] : memref + %48 = arith.addi %39, %41 : i32 + scf.yield %48, %47 : i32, f32 + } else { + scf.yield %arg15, %arg16 : i32, f32 + } + affine.yield %46#0, %46#1 : i32, f32 + } + affine.yield %40#0, %40#1 : i32, f32 + } + affine.yield %33#0, %33#1 : i32, f32 + } + affine.store %27#1, %arg2[0, %arg4, %arg5, %arg6, %arg7] : memref + affine.store %27#0, %arg3[0, %arg4, %arg5, %arg6, %arg7] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu/raised.mlir new file mode 100644 index 000000000000..d4a5af5319ab --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu/raised.mlir @@ -0,0 +1,129 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c0 = arith.constant 0 : index + %cst = arith.constant 2.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %cst_1 = arith.constant 3.000000e+00 : f32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %cst_3 = arith.constant 4.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %c9_i32 = arith.constant 9 : i32 + %cst_4 = arith.constant -3.40282347E+38 : f32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 3 { + %0 = arith.index_cast %arg5 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + affine.for %arg6 = 0 to 4 { + %2 = arith.index_cast %arg6 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %alloca = memref.alloca(%c5) : memref + %alloca_5 = memref.alloca(%c5) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_5 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_4 : f32 + } + affine.for %arg7 = 0 to 5 { + %4 = arith.index_cast %arg7 : index to i32 + %5 = affine.load %arg1[0, %arg4, 0] : memref + %6 = arith.addf %1, %5 : f32 + %7 = arith.mulf %6, %cst_0 : f32 + %8 = arith.divf %7, %cst : f32 + %9 = arith.fptosi %8 : f32 to i32 + %10 = affine.load %arg1[0, %arg4, 1] : memref + %11 = arith.addf %3, %10 : f32 + %12 = arith.mulf %11, %cst_0 : f32 + %13 = arith.divf %12, %cst_1 : f32 + %14 = arith.fptosi %13 : f32 to i32 + %15 = arith.sitofp %4 : i32 to f32 + %16 = affine.load %arg1[0, %arg4, 2] : memref + %17 = arith.addf %15, %16 : f32 + %18 = arith.mulf %17, %cst_2 : f32 + %19 = arith.divf %18, %cst_3 : f32 + %20 = arith.fptosi %19 : f32 to i32 + %21 = arith.cmpi sgt, %9, %c6_i32 : i32 + %22 = arith.select %21, %c6_i32, %9 : i32 + %23 = arith.cmpi sgt, %14, %c6_i32 : i32 + %24 = arith.select %23, %c6_i32, %14 : i32 + %25 = arith.cmpi sgt, %20, %c7_i32 : i32 + %26 = arith.select %25, %c7_i32, %20 : i32 + %alloca_9 = memref.alloca(%c2) : memref + %alloca_10 = memref.alloca(%c2) : memref + affine.for %arg8 = 0 to 2 { + %27 = affine.load %alloca[%arg7] : memref + %28 = affine.load %alloca_5[%arg7] : memref + %29 = arith.index_cast %arg8 : index to i32 + %30 = arith.addi %22, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = arith.muli %30, %c9_i32 : i32 + %33 = arith.addi %32, %24 : i32 + affine.store %27, %alloca_9[%arg8] : memref + affine.store %28, %alloca_10[%arg8] : memref + %alloca_11 = memref.alloca(%c3) : memref + %alloca_12 = memref.alloca(%c3) : memref + affine.for %arg9 = 0 to 3 { + %36 = affine.load %alloca_9[%arg8] : memref + %37 = affine.load %alloca_10[%arg8] : memref + %38 = arith.index_cast %arg9 : index to i32 + %39 = arith.addi %24, %38 : i32 + %40 = arith.index_cast %39 : i32 to index + %41 = arith.addi %33, %38 : i32 + %42 = arith.muli %41, %c10_i32 : i32 + %43 = arith.addi %42, %26 : i32 + affine.store %36, %alloca_11[%arg9] : memref + affine.store %37, %alloca_12[%arg9] : memref + affine.for %arg10 = 0 to 3 { + %46 = affine.load %alloca_11[%arg9] : memref + %47 = affine.load %alloca_12[%arg9] : memref + %48 = arith.index_cast %arg10 : index to i32 + %49 = arith.addi %26, %48 : i32 + %50 = arith.index_cast %49 : i32 to index + %51 = memref.load %arg0[%c0, %arg4, %31, %40, %50] : memref + %52 = arith.cmpf ogt, %51, %47 : f32 + %53 = memref.load %arg0[%c0, %arg4, %31, %40, %50] : memref + %54 = arith.addi %43, %48 : i32 + %55 = arith.select %52, %54, %46 : i32 + %56 = arith.select %52, %53, %47 : f32 + affine.store %55, %alloca_11[%arg9] : memref + affine.store %56, %alloca_12[%arg9] : memref + } + %44 = affine.load %alloca_11[%arg9] : memref + %45 = affine.load %alloca_12[%arg9] : memref + affine.store %44, %alloca_9[%arg8] : memref + affine.store %45, %alloca_10[%arg8] : memref + } + %34 = affine.load %alloca_9[%arg8] : memref + %35 = affine.load %alloca_10[%arg8] : memref + affine.store %34, %alloca[%arg7] : memref + affine.store %35, %alloca_5[%arg7] : memref + } + } + %subview = memref.subview %alloca_5[0] [%c5] [1] : memref to memref> + %subview_6 = memref.subview %arg2[0, %arg4, %arg5, %arg6, 0] [1, 1, 1, 1, %c5] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_6 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_7 = memref.subview %alloca[0] [%c5] [1] : memref to memref> + %subview_8 = memref.subview %arg3[0, %arg4, %arg5, %arg6, 0] [1, 1, 1, 1, %c5] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_7 : memref>) outs(%subview_8 : memref>) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu_debuf.mlir new file mode 100644 index 000000000000..608b8a36d7f8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu_debuf.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2:2 = affine.for %arg4 = 0 to 2 iter_args(%arg5 = %1, %arg6 = %0) -> (tensor, tensor) { + %5:2 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %arg5, %arg9 = %arg6) -> (tensor, tensor) { + %6:2 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (tensor, tensor) { + %alloca = memref.alloca(%c5) : memref + %7 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c5) : memref + %8 = bufferization.to_tensor %alloca_0 : memref + %extracted_slice = tensor.extract_slice %arg11[0, %arg4, %arg7, %arg10, 0] [1, 1, 1, 1, %c5] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %8[0] [%c5] [1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %9 into %arg11[0, %arg4, %arg7, %arg10, 0] [1, 1, 1, 1, %c5] [1, 1, 1, 1, 1] : tensor into tensor + %extracted_slice_2 = tensor.extract_slice %arg12[0, %arg4, %arg7, %arg10, 0] [1, 1, 1, 1, %c5] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %7[0] [%c5] [1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %inserted_slice_4 = tensor.insert_slice %10 into %arg12[0, %arg4, %arg7, %arg10, 0] [1, 1, 1, 1, %c5] [1, 1, 1, 1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_slice_4 : tensor, tensor + } + affine.yield %6#0, %6#1 : tensor, tensor + } + affine.yield %5#0, %5#1 : tensor, tensor + } + %3 = bufferization.to_memref %2#1 : memref + memref.copy %3, %arg3 : memref to memref + %4 = bufferization.to_memref %2#0 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu_linalg.mlir new file mode 100644 index 000000000000..d4a5af5319ab --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fractional_max_pool3d_cpu_linalg.mlir @@ -0,0 +1,129 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fractional_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c0 = arith.constant 0 : index + %cst = arith.constant 2.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %cst_1 = arith.constant 3.000000e+00 : f32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %cst_3 = arith.constant 4.000000e+00 : f32 + %c10_i32 = arith.constant 10 : i32 + %c9_i32 = arith.constant 9 : i32 + %cst_4 = arith.constant -3.40282347E+38 : f32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 3 { + %0 = arith.index_cast %arg5 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + affine.for %arg6 = 0 to 4 { + %2 = arith.index_cast %arg6 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %alloca = memref.alloca(%c5) : memref + %alloca_5 = memref.alloca(%c5) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_5 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_4 : f32 + } + affine.for %arg7 = 0 to 5 { + %4 = arith.index_cast %arg7 : index to i32 + %5 = affine.load %arg1[0, %arg4, 0] : memref + %6 = arith.addf %1, %5 : f32 + %7 = arith.mulf %6, %cst_0 : f32 + %8 = arith.divf %7, %cst : f32 + %9 = arith.fptosi %8 : f32 to i32 + %10 = affine.load %arg1[0, %arg4, 1] : memref + %11 = arith.addf %3, %10 : f32 + %12 = arith.mulf %11, %cst_0 : f32 + %13 = arith.divf %12, %cst_1 : f32 + %14 = arith.fptosi %13 : f32 to i32 + %15 = arith.sitofp %4 : i32 to f32 + %16 = affine.load %arg1[0, %arg4, 2] : memref + %17 = arith.addf %15, %16 : f32 + %18 = arith.mulf %17, %cst_2 : f32 + %19 = arith.divf %18, %cst_3 : f32 + %20 = arith.fptosi %19 : f32 to i32 + %21 = arith.cmpi sgt, %9, %c6_i32 : i32 + %22 = arith.select %21, %c6_i32, %9 : i32 + %23 = arith.cmpi sgt, %14, %c6_i32 : i32 + %24 = arith.select %23, %c6_i32, %14 : i32 + %25 = arith.cmpi sgt, %20, %c7_i32 : i32 + %26 = arith.select %25, %c7_i32, %20 : i32 + %alloca_9 = memref.alloca(%c2) : memref + %alloca_10 = memref.alloca(%c2) : memref + affine.for %arg8 = 0 to 2 { + %27 = affine.load %alloca[%arg7] : memref + %28 = affine.load %alloca_5[%arg7] : memref + %29 = arith.index_cast %arg8 : index to i32 + %30 = arith.addi %22, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = arith.muli %30, %c9_i32 : i32 + %33 = arith.addi %32, %24 : i32 + affine.store %27, %alloca_9[%arg8] : memref + affine.store %28, %alloca_10[%arg8] : memref + %alloca_11 = memref.alloca(%c3) : memref + %alloca_12 = memref.alloca(%c3) : memref + affine.for %arg9 = 0 to 3 { + %36 = affine.load %alloca_9[%arg8] : memref + %37 = affine.load %alloca_10[%arg8] : memref + %38 = arith.index_cast %arg9 : index to i32 + %39 = arith.addi %24, %38 : i32 + %40 = arith.index_cast %39 : i32 to index + %41 = arith.addi %33, %38 : i32 + %42 = arith.muli %41, %c10_i32 : i32 + %43 = arith.addi %42, %26 : i32 + affine.store %36, %alloca_11[%arg9] : memref + affine.store %37, %alloca_12[%arg9] : memref + affine.for %arg10 = 0 to 3 { + %46 = affine.load %alloca_11[%arg9] : memref + %47 = affine.load %alloca_12[%arg9] : memref + %48 = arith.index_cast %arg10 : index to i32 + %49 = arith.addi %26, %48 : i32 + %50 = arith.index_cast %49 : i32 to index + %51 = memref.load %arg0[%c0, %arg4, %31, %40, %50] : memref + %52 = arith.cmpf ogt, %51, %47 : f32 + %53 = memref.load %arg0[%c0, %arg4, %31, %40, %50] : memref + %54 = arith.addi %43, %48 : i32 + %55 = arith.select %52, %54, %46 : i32 + %56 = arith.select %52, %53, %47 : f32 + affine.store %55, %alloca_11[%arg9] : memref + affine.store %56, %alloca_12[%arg9] : memref + } + %44 = affine.load %alloca_11[%arg9] : memref + %45 = affine.load %alloca_12[%arg9] : memref + affine.store %44, %alloca_9[%arg8] : memref + affine.store %45, %alloca_10[%arg8] : memref + } + %34 = affine.load %alloca_9[%arg8] : memref + %35 = affine.load %alloca_10[%arg8] : memref + affine.store %34, %alloca[%arg7] : memref + affine.store %35, %alloca_5[%arg7] : memref + } + } + %subview = memref.subview %alloca_5[0] [%c5] [1] : memref to memref> + %subview_6 = memref.subview %arg2[0, %arg4, %arg5, %arg6, 0] [1, 1, 1, 1, %c5] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_6 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_7 = memref.subview %alloca[0] [%c5] [1] : memref to memref> + %subview_8 = memref.subview %arg3[0, %arg4, %arg5, %arg6, 0] [1, 1, 1, 1, %c5] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_7 : memref>) outs(%subview_8 : memref>) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fused_adagrad_cpu.mlir b/issues/aten_c_kernels/results/aten_fused_adagrad_cpu.mlir new file mode 100644 index 000000000000..6244405b8ab8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_adagrad_cpu.mlir @@ -0,0 +1,44 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_adagrad_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: f32, %arg9: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = arith.subf %arg7, %cst_0 : f32 + %1 = arith.mulf %0, %arg4 : f32 + %2 = arith.addf %1, %cst_0 : f32 + %3 = arith.divf %arg3, %2 : f32 + %4 = arith.cmpi ne, %arg9, %c0_i32 : i32 + %5 = arith.cmpf une, %arg5, %cst : f32 + affine.for %arg10 = 0 to 4096 { + %6 = affine.load %arg1[%arg10] : memref + %7 = arith.divf %6, %arg8 : f32 + affine.store %7, %arg1[%arg10] : memref + %8 = scf.if %4 -> (f32) { + %19 = arith.negf %7 : f32 + scf.yield %19 : f32 + } else { + scf.yield %7 : f32 + } + %9 = scf.if %5 -> (f32) { + %19 = affine.load %arg0[%arg10] : memref + %20 = arith.mulf %19, %arg5 : f32 + %21 = arith.addf %8, %20 : f32 + scf.yield %21 : f32 + } else { + scf.yield %8 : f32 + } + %10 = arith.mulf %9, %9 : f32 + %11 = affine.load %arg2[%arg10] : memref + %12 = arith.addf %11, %10 : f32 + affine.store %12, %arg2[%arg10] : memref + %13 = arith.mulf %3, %9 : f32 + %14 = math.sqrt %12 : f32 + %15 = arith.addf %14, %arg6 : f32 + %16 = arith.divf %13, %15 : f32 + %17 = affine.load %arg0[%arg10] : memref + %18 = arith.subf %17, %16 : f32 + affine.store %18, %arg0[%arg10] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fused_adagrad_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_fused_adagrad_cpu/debuf.mlir new file mode 100644 index 000000000000..e2d0415cd46e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_adagrad_cpu/debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_adagrad_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: f32, %arg9: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = arith.subf %arg7, %cst : f32 + %4 = arith.mulf %3, %arg4 : f32 + %5 = arith.addf %4, %cst : f32 + %6 = arith.divf %arg3, %5 : f32 + %7 = arith.cmpi ne, %arg9, %c0_i32 : i32 + %8 = arith.cmpf une, %arg5, %cst_0 : f32 + %9:3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} outs(%1, %2, %0 : tensor, tensor, tensor) { + ^bb0(%out: f32, %out_1: f32, %out_2: f32): + %13 = arith.divf %out, %arg8 : f32 + %14 = arith.negf %13 : f32 + %15 = arith.select %7, %14, %13 : f32 + %16 = arith.mulf %out_2, %arg5 : f32 + %17 = arith.addf %15, %16 : f32 + %18 = arith.select %8, %17, %15 : f32 + %19 = arith.mulf %18, %18 : f32 + %20 = arith.addf %out_1, %19 : f32 + %21 = arith.mulf %6, %18 : f32 + %22 = math.sqrt %20 : f32 + %23 = arith.addf %22, %arg6 : f32 + %24 = arith.divf %21, %23 : f32 + %25 = arith.subf %out_2, %24 : f32 + linalg.yield %13, %20, %25 : f32, f32, f32 + } -> (tensor, tensor, tensor) + %10 = bufferization.to_memref %9#2 : memref + memref.copy %10, %arg0 : memref to memref + %11 = bufferization.to_memref %9#0 : memref + memref.copy %11, %arg1 : memref to memref + %12 = bufferization.to_memref %9#1 : memref + memref.copy %12, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fused_adagrad_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_fused_adagrad_cpu/matched.mlir new file mode 100644 index 000000000000..e2d0415cd46e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_adagrad_cpu/matched.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_adagrad_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: f32, %arg9: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = arith.subf %arg7, %cst : f32 + %4 = arith.mulf %3, %arg4 : f32 + %5 = arith.addf %4, %cst : f32 + %6 = arith.divf %arg3, %5 : f32 + %7 = arith.cmpi ne, %arg9, %c0_i32 : i32 + %8 = arith.cmpf une, %arg5, %cst_0 : f32 + %9:3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} outs(%1, %2, %0 : tensor, tensor, tensor) { + ^bb0(%out: f32, %out_1: f32, %out_2: f32): + %13 = arith.divf %out, %arg8 : f32 + %14 = arith.negf %13 : f32 + %15 = arith.select %7, %14, %13 : f32 + %16 = arith.mulf %out_2, %arg5 : f32 + %17 = arith.addf %15, %16 : f32 + %18 = arith.select %8, %17, %15 : f32 + %19 = arith.mulf %18, %18 : f32 + %20 = arith.addf %out_1, %19 : f32 + %21 = arith.mulf %6, %18 : f32 + %22 = math.sqrt %20 : f32 + %23 = arith.addf %22, %arg6 : f32 + %24 = arith.divf %21, %23 : f32 + %25 = arith.subf %out_2, %24 : f32 + linalg.yield %13, %20, %25 : f32, f32, f32 + } -> (tensor, tensor, tensor) + %10 = bufferization.to_memref %9#2 : memref + memref.copy %10, %arg0 : memref to memref + %11 = bufferization.to_memref %9#0 : memref + memref.copy %11, %arg1 : memref to memref + %12 = bufferization.to_memref %9#1 : memref + memref.copy %12, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fused_adagrad_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_fused_adagrad_cpu/orig.mlir new file mode 100644 index 000000000000..6244405b8ab8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_adagrad_cpu/orig.mlir @@ -0,0 +1,44 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_adagrad_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: f32, %arg9: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = arith.subf %arg7, %cst_0 : f32 + %1 = arith.mulf %0, %arg4 : f32 + %2 = arith.addf %1, %cst_0 : f32 + %3 = arith.divf %arg3, %2 : f32 + %4 = arith.cmpi ne, %arg9, %c0_i32 : i32 + %5 = arith.cmpf une, %arg5, %cst : f32 + affine.for %arg10 = 0 to 4096 { + %6 = affine.load %arg1[%arg10] : memref + %7 = arith.divf %6, %arg8 : f32 + affine.store %7, %arg1[%arg10] : memref + %8 = scf.if %4 -> (f32) { + %19 = arith.negf %7 : f32 + scf.yield %19 : f32 + } else { + scf.yield %7 : f32 + } + %9 = scf.if %5 -> (f32) { + %19 = affine.load %arg0[%arg10] : memref + %20 = arith.mulf %19, %arg5 : f32 + %21 = arith.addf %8, %20 : f32 + scf.yield %21 : f32 + } else { + scf.yield %8 : f32 + } + %10 = arith.mulf %9, %9 : f32 + %11 = affine.load %arg2[%arg10] : memref + %12 = arith.addf %11, %10 : f32 + affine.store %12, %arg2[%arg10] : memref + %13 = arith.mulf %3, %9 : f32 + %14 = math.sqrt %12 : f32 + %15 = arith.addf %14, %arg6 : f32 + %16 = arith.divf %13, %15 : f32 + %17 = affine.load %arg0[%arg10] : memref + %18 = arith.subf %17, %16 : f32 + affine.store %18, %arg0[%arg10] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fused_adagrad_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_fused_adagrad_cpu/raised.mlir new file mode 100644 index 000000000000..3a1a6c7e94cc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_adagrad_cpu/raised.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_adagrad_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: f32, %arg9: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = arith.subf %arg7, %cst_0 : f32 + %1 = arith.mulf %0, %arg4 : f32 + %2 = arith.addf %1, %cst_0 : f32 + %3 = arith.divf %arg3, %2 : f32 + %4 = arith.cmpi ne, %arg9, %c0_i32 : i32 + %5 = arith.cmpf une, %arg5, %cst : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} outs(%arg1, %arg2, %arg0 : memref, memref, memref) { + ^bb0(%out: f32, %out_1: f32, %out_2: f32): + %6 = arith.divf %out, %arg8 : f32 + %7 = arith.negf %6 : f32 + %8 = arith.select %4, %7, %6 : f32 + %9 = arith.mulf %out_2, %arg5 : f32 + %10 = arith.addf %8, %9 : f32 + %11 = arith.select %5, %10, %8 : f32 + %12 = arith.mulf %11, %11 : f32 + %13 = arith.addf %out_1, %12 : f32 + %14 = arith.mulf %3, %11 : f32 + %15 = math.sqrt %13 : f32 + %16 = arith.addf %15, %arg6 : f32 + %17 = arith.divf %14, %16 : f32 + %18 = arith.subf %out_2, %17 : f32 + linalg.yield %6, %13, %18 : f32, f32, f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fused_adagrad_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_fused_adagrad_cpu_debuf.mlir new file mode 100644 index 000000000000..e2d0415cd46e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_adagrad_cpu_debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_adagrad_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: f32, %arg9: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = arith.subf %arg7, %cst : f32 + %4 = arith.mulf %3, %arg4 : f32 + %5 = arith.addf %4, %cst : f32 + %6 = arith.divf %arg3, %5 : f32 + %7 = arith.cmpi ne, %arg9, %c0_i32 : i32 + %8 = arith.cmpf une, %arg5, %cst_0 : f32 + %9:3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} outs(%1, %2, %0 : tensor, tensor, tensor) { + ^bb0(%out: f32, %out_1: f32, %out_2: f32): + %13 = arith.divf %out, %arg8 : f32 + %14 = arith.negf %13 : f32 + %15 = arith.select %7, %14, %13 : f32 + %16 = arith.mulf %out_2, %arg5 : f32 + %17 = arith.addf %15, %16 : f32 + %18 = arith.select %8, %17, %15 : f32 + %19 = arith.mulf %18, %18 : f32 + %20 = arith.addf %out_1, %19 : f32 + %21 = arith.mulf %6, %18 : f32 + %22 = math.sqrt %20 : f32 + %23 = arith.addf %22, %arg6 : f32 + %24 = arith.divf %21, %23 : f32 + %25 = arith.subf %out_2, %24 : f32 + linalg.yield %13, %20, %25 : f32, f32, f32 + } -> (tensor, tensor, tensor) + %10 = bufferization.to_memref %9#2 : memref + memref.copy %10, %arg0 : memref to memref + %11 = bufferization.to_memref %9#0 : memref + memref.copy %11, %arg1 : memref to memref + %12 = bufferization.to_memref %9#1 : memref + memref.copy %12, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fused_adagrad_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_fused_adagrad_cpu_linalg.mlir new file mode 100644 index 000000000000..3a1a6c7e94cc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_adagrad_cpu_linalg.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_adagrad_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: f32, %arg9: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = arith.subf %arg7, %cst_0 : f32 + %1 = arith.mulf %0, %arg4 : f32 + %2 = arith.addf %1, %cst_0 : f32 + %3 = arith.divf %arg3, %2 : f32 + %4 = arith.cmpi ne, %arg9, %c0_i32 : i32 + %5 = arith.cmpf une, %arg5, %cst : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} outs(%arg1, %arg2, %arg0 : memref, memref, memref) { + ^bb0(%out: f32, %out_1: f32, %out_2: f32): + %6 = arith.divf %out, %arg8 : f32 + %7 = arith.negf %6 : f32 + %8 = arith.select %4, %7, %6 : f32 + %9 = arith.mulf %out_2, %arg5 : f32 + %10 = arith.addf %8, %9 : f32 + %11 = arith.select %5, %10, %8 : f32 + %12 = arith.mulf %11, %11 : f32 + %13 = arith.addf %out_1, %12 : f32 + %14 = arith.mulf %3, %11 : f32 + %15 = math.sqrt %13 : f32 + %16 = arith.addf %15, %arg6 : f32 + %17 = arith.divf %14, %16 : f32 + %18 = arith.subf %out_2, %17 : f32 + linalg.yield %6, %13, %18 : f32, f32, f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fused_adam_cpu.mlir b/issues/aten_c_kernels/results/aten_fused_adam_cpu.mlir new file mode 100644 index 000000000000..263bf92e5339 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_adam_cpu.mlir @@ -0,0 +1,62 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_adam_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: f32, %arg9: f32, %arg10: f32, %arg11: f32, %arg12: f32, %arg13: i32, %arg14: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.divf %arg5, %arg8 : f32 + %1 = arith.cmpi ne, %arg13, %c0_i32 : i32 + %2 = arith.cmpf une, %arg10, %cst_0 : f32 + %3 = arith.subf %cst, %arg6 : f32 + %4 = arith.subf %cst, %arg7 : f32 + %5 = arith.cmpi ne, %arg14, %c0_i32 : i32 + affine.for %arg15 = 0 to 4096 { + %6 = affine.load %arg1[%arg15] : memref + %7 = arith.divf %6, %arg12 : f32 + affine.store %7, %arg1[%arg15] : memref + %8 = scf.if %1 -> (f32) { + %28 = arith.negf %7 : f32 + scf.yield %28 : f32 + } else { + scf.yield %7 : f32 + } + %9 = scf.if %2 -> (f32) { + %28 = affine.load %arg0[%arg15] : memref + %29 = arith.mulf %28, %arg10 : f32 + %30 = arith.addf %8, %29 : f32 + scf.yield %30 : f32 + } else { + scf.yield %8 : f32 + } + %10 = affine.load %arg2[%arg15] : memref + %11 = arith.subf %9, %10 : f32 + %12 = arith.mulf %3, %11 : f32 + %13 = arith.addf %10, %12 : f32 + affine.store %13, %arg2[%arg15] : memref + %14 = affine.load %arg3[%arg15] : memref + %15 = arith.mulf %arg7, %14 : f32 + %16 = arith.mulf %4, %9 : f32 + %17 = arith.mulf %16, %9 : f32 + %18 = arith.addf %15, %17 : f32 + affine.store %18, %arg3[%arg15] : memref + %19 = scf.if %5 -> (f32) { + %28 = affine.load %arg4[%arg15] : memref + %29 = arith.cmpf ogt, %28, %18 : f32 + %30 = arith.select %29, %28, %18 : f32 + affine.store %30, %arg4[%arg15] : memref + scf.yield %30 : f32 + } else { + scf.yield %18 : f32 + } + %20 = affine.load %arg2[%arg15] : memref + %21 = arith.mulf %0, %20 : f32 + %22 = math.sqrt %19 : f32 + %23 = arith.divf %22, %arg9 : f32 + %24 = arith.addf %23, %arg11 : f32 + %25 = arith.divf %21, %24 : f32 + %26 = affine.load %arg0[%arg15] : memref + %27 = arith.subf %26, %25 : f32 + affine.store %27, %arg0[%arg15] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fused_adam_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_fused_adam_cpu/debuf.mlir new file mode 100644 index 000000000000..79d7e15949e8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_adam_cpu/debuf.mlir @@ -0,0 +1,71 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_adam_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: f32, %arg9: f32, %arg10: f32, %arg11: f32, %arg12: f32, %arg13: i32, %arg14: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = arith.divf %arg5, %arg8 : f32 + %6 = arith.cmpi ne, %arg13, %c0_i32 : i32 + %7 = arith.cmpf une, %arg10, %cst : f32 + %8 = arith.subf %cst_0, %arg6 : f32 + %9 = arith.subf %cst_0, %arg7 : f32 + %10 = arith.cmpi ne, %arg14, %c0_i32 : i32 + %11:5 = affine.for %arg15 = 0 to 4096 iter_args(%arg16 = %4, %arg17 = %3, %arg18 = %2, %arg19 = %1, %arg20 = %0) -> (tensor, tensor, tensor, tensor, tensor) { + %extracted = tensor.extract %arg17[%arg15] : tensor + %17 = arith.divf %extracted, %arg12 : f32 + %inserted = tensor.insert %17 into %arg17[%arg15] : tensor + %18 = arith.negf %17 : f32 + %19 = arith.select %6, %18, %17 : f32 + %extracted_1 = tensor.extract %arg16[%arg15] : tensor + %20 = arith.mulf %extracted_1, %arg10 : f32 + %21 = arith.addf %19, %20 : f32 + %22 = arith.select %7, %21, %19 : f32 + %extracted_2 = tensor.extract %arg18[%arg15] : tensor + %23 = arith.subf %22, %extracted_2 : f32 + %24 = arith.mulf %8, %23 : f32 + %25 = arith.addf %extracted_2, %24 : f32 + %inserted_3 = tensor.insert %25 into %arg18[%arg15] : tensor + %extracted_4 = tensor.extract %arg19[%arg15] : tensor + %26 = arith.mulf %arg7, %extracted_4 : f32 + %27 = arith.mulf %9, %22 : f32 + %28 = arith.mulf %27, %22 : f32 + %29 = arith.addf %26, %28 : f32 + %inserted_5 = tensor.insert %29 into %arg19[%arg15] : tensor + %30:2 = scf.if %10 -> (f32, tensor) { + %extracted_9 = tensor.extract %arg20[%arg15] : tensor + %37 = arith.cmpf ogt, %extracted_9, %29 : f32 + %38 = arith.select %37, %extracted_9, %29 : f32 + %inserted_10 = tensor.insert %38 into %arg20[%arg15] : tensor + scf.yield %38, %inserted_10 : f32, tensor + } else { + scf.yield %29, %arg20 : f32, tensor + } + %extracted_6 = tensor.extract %inserted_3[%arg15] : tensor + %31 = arith.mulf %5, %extracted_6 : f32 + %32 = math.sqrt %30#0 : f32 + %33 = arith.divf %32, %arg9 : f32 + %34 = arith.addf %33, %arg11 : f32 + %35 = arith.divf %31, %34 : f32 + %extracted_7 = tensor.extract %arg16[%arg15] : tensor + %36 = arith.subf %extracted_7, %35 : f32 + %inserted_8 = tensor.insert %36 into %arg16[%arg15] : tensor + affine.yield %inserted_8, %inserted, %inserted_3, %inserted_5, %30#1 : tensor, tensor, tensor, tensor, tensor + } + %12 = bufferization.to_memref %11#4 : memref + memref.copy %12, %arg4 : memref to memref + %13 = bufferization.to_memref %11#3 : memref + memref.copy %13, %arg3 : memref to memref + %14 = bufferization.to_memref %11#2 : memref + memref.copy %14, %arg2 : memref to memref + %15 = bufferization.to_memref %11#1 : memref + memref.copy %15, %arg1 : memref to memref + %16 = bufferization.to_memref %11#0 : memref + memref.copy %16, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fused_adam_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_fused_adam_cpu/matched.mlir new file mode 100644 index 000000000000..79d7e15949e8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_adam_cpu/matched.mlir @@ -0,0 +1,71 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_adam_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: f32, %arg9: f32, %arg10: f32, %arg11: f32, %arg12: f32, %arg13: i32, %arg14: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = arith.divf %arg5, %arg8 : f32 + %6 = arith.cmpi ne, %arg13, %c0_i32 : i32 + %7 = arith.cmpf une, %arg10, %cst : f32 + %8 = arith.subf %cst_0, %arg6 : f32 + %9 = arith.subf %cst_0, %arg7 : f32 + %10 = arith.cmpi ne, %arg14, %c0_i32 : i32 + %11:5 = affine.for %arg15 = 0 to 4096 iter_args(%arg16 = %4, %arg17 = %3, %arg18 = %2, %arg19 = %1, %arg20 = %0) -> (tensor, tensor, tensor, tensor, tensor) { + %extracted = tensor.extract %arg17[%arg15] : tensor + %17 = arith.divf %extracted, %arg12 : f32 + %inserted = tensor.insert %17 into %arg17[%arg15] : tensor + %18 = arith.negf %17 : f32 + %19 = arith.select %6, %18, %17 : f32 + %extracted_1 = tensor.extract %arg16[%arg15] : tensor + %20 = arith.mulf %extracted_1, %arg10 : f32 + %21 = arith.addf %19, %20 : f32 + %22 = arith.select %7, %21, %19 : f32 + %extracted_2 = tensor.extract %arg18[%arg15] : tensor + %23 = arith.subf %22, %extracted_2 : f32 + %24 = arith.mulf %8, %23 : f32 + %25 = arith.addf %extracted_2, %24 : f32 + %inserted_3 = tensor.insert %25 into %arg18[%arg15] : tensor + %extracted_4 = tensor.extract %arg19[%arg15] : tensor + %26 = arith.mulf %arg7, %extracted_4 : f32 + %27 = arith.mulf %9, %22 : f32 + %28 = arith.mulf %27, %22 : f32 + %29 = arith.addf %26, %28 : f32 + %inserted_5 = tensor.insert %29 into %arg19[%arg15] : tensor + %30:2 = scf.if %10 -> (f32, tensor) { + %extracted_9 = tensor.extract %arg20[%arg15] : tensor + %37 = arith.cmpf ogt, %extracted_9, %29 : f32 + %38 = arith.select %37, %extracted_9, %29 : f32 + %inserted_10 = tensor.insert %38 into %arg20[%arg15] : tensor + scf.yield %38, %inserted_10 : f32, tensor + } else { + scf.yield %29, %arg20 : f32, tensor + } + %extracted_6 = tensor.extract %inserted_3[%arg15] : tensor + %31 = arith.mulf %5, %extracted_6 : f32 + %32 = math.sqrt %30#0 : f32 + %33 = arith.divf %32, %arg9 : f32 + %34 = arith.addf %33, %arg11 : f32 + %35 = arith.divf %31, %34 : f32 + %extracted_7 = tensor.extract %arg16[%arg15] : tensor + %36 = arith.subf %extracted_7, %35 : f32 + %inserted_8 = tensor.insert %36 into %arg16[%arg15] : tensor + affine.yield %inserted_8, %inserted, %inserted_3, %inserted_5, %30#1 : tensor, tensor, tensor, tensor, tensor + } + %12 = bufferization.to_memref %11#4 : memref + memref.copy %12, %arg4 : memref to memref + %13 = bufferization.to_memref %11#3 : memref + memref.copy %13, %arg3 : memref to memref + %14 = bufferization.to_memref %11#2 : memref + memref.copy %14, %arg2 : memref to memref + %15 = bufferization.to_memref %11#1 : memref + memref.copy %15, %arg1 : memref to memref + %16 = bufferization.to_memref %11#0 : memref + memref.copy %16, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fused_adam_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_fused_adam_cpu/orig.mlir new file mode 100644 index 000000000000..263bf92e5339 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_adam_cpu/orig.mlir @@ -0,0 +1,62 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_adam_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: f32, %arg9: f32, %arg10: f32, %arg11: f32, %arg12: f32, %arg13: i32, %arg14: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.divf %arg5, %arg8 : f32 + %1 = arith.cmpi ne, %arg13, %c0_i32 : i32 + %2 = arith.cmpf une, %arg10, %cst_0 : f32 + %3 = arith.subf %cst, %arg6 : f32 + %4 = arith.subf %cst, %arg7 : f32 + %5 = arith.cmpi ne, %arg14, %c0_i32 : i32 + affine.for %arg15 = 0 to 4096 { + %6 = affine.load %arg1[%arg15] : memref + %7 = arith.divf %6, %arg12 : f32 + affine.store %7, %arg1[%arg15] : memref + %8 = scf.if %1 -> (f32) { + %28 = arith.negf %7 : f32 + scf.yield %28 : f32 + } else { + scf.yield %7 : f32 + } + %9 = scf.if %2 -> (f32) { + %28 = affine.load %arg0[%arg15] : memref + %29 = arith.mulf %28, %arg10 : f32 + %30 = arith.addf %8, %29 : f32 + scf.yield %30 : f32 + } else { + scf.yield %8 : f32 + } + %10 = affine.load %arg2[%arg15] : memref + %11 = arith.subf %9, %10 : f32 + %12 = arith.mulf %3, %11 : f32 + %13 = arith.addf %10, %12 : f32 + affine.store %13, %arg2[%arg15] : memref + %14 = affine.load %arg3[%arg15] : memref + %15 = arith.mulf %arg7, %14 : f32 + %16 = arith.mulf %4, %9 : f32 + %17 = arith.mulf %16, %9 : f32 + %18 = arith.addf %15, %17 : f32 + affine.store %18, %arg3[%arg15] : memref + %19 = scf.if %5 -> (f32) { + %28 = affine.load %arg4[%arg15] : memref + %29 = arith.cmpf ogt, %28, %18 : f32 + %30 = arith.select %29, %28, %18 : f32 + affine.store %30, %arg4[%arg15] : memref + scf.yield %30 : f32 + } else { + scf.yield %18 : f32 + } + %20 = affine.load %arg2[%arg15] : memref + %21 = arith.mulf %0, %20 : f32 + %22 = math.sqrt %19 : f32 + %23 = arith.divf %22, %arg9 : f32 + %24 = arith.addf %23, %arg11 : f32 + %25 = arith.divf %21, %24 : f32 + %26 = affine.load %arg0[%arg15] : memref + %27 = arith.subf %26, %25 : f32 + affine.store %27, %arg0[%arg15] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fused_adam_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_fused_adam_cpu/raised.mlir new file mode 100644 index 000000000000..43401457e2ef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_adam_cpu/raised.mlir @@ -0,0 +1,55 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_adam_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: f32, %arg9: f32, %arg10: f32, %arg11: f32, %arg12: f32, %arg13: i32, %arg14: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.divf %arg5, %arg8 : f32 + %1 = arith.cmpi ne, %arg13, %c0_i32 : i32 + %2 = arith.cmpf une, %arg10, %cst_0 : f32 + %3 = arith.subf %cst, %arg6 : f32 + %4 = arith.subf %cst, %arg7 : f32 + %5 = arith.cmpi ne, %arg14, %c0_i32 : i32 + affine.for %arg15 = 0 to 4096 { + %6 = affine.load %arg1[%arg15] : memref + %7 = arith.divf %6, %arg12 : f32 + affine.store %7, %arg1[%arg15] : memref + %8 = arith.negf %7 : f32 + %9 = arith.select %1, %8, %7 : f32 + %10 = affine.load %arg0[%arg15] : memref + %11 = arith.mulf %10, %arg10 : f32 + %12 = arith.addf %9, %11 : f32 + %13 = arith.select %2, %12, %9 : f32 + %14 = affine.load %arg2[%arg15] : memref + %15 = arith.subf %13, %14 : f32 + %16 = arith.mulf %3, %15 : f32 + %17 = arith.addf %14, %16 : f32 + affine.store %17, %arg2[%arg15] : memref + %18 = affine.load %arg3[%arg15] : memref + %19 = arith.mulf %arg7, %18 : f32 + %20 = arith.mulf %4, %13 : f32 + %21 = arith.mulf %20, %13 : f32 + %22 = arith.addf %19, %21 : f32 + affine.store %22, %arg3[%arg15] : memref + %23 = scf.if %5 -> (f32) { + %32 = affine.load %arg4[%arg15] : memref + %33 = arith.cmpf ogt, %32, %22 : f32 + %34 = arith.select %33, %32, %22 : f32 + affine.store %34, %arg4[%arg15] : memref + scf.yield %34 : f32 + } else { + scf.yield %22 : f32 + } + %24 = affine.load %arg2[%arg15] : memref + %25 = arith.mulf %0, %24 : f32 + %26 = math.sqrt %23 : f32 + %27 = arith.divf %26, %arg9 : f32 + %28 = arith.addf %27, %arg11 : f32 + %29 = arith.divf %25, %28 : f32 + %30 = affine.load %arg0[%arg15] : memref + %31 = arith.subf %30, %29 : f32 + affine.store %31, %arg0[%arg15] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fused_adam_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_fused_adam_cpu_debuf.mlir new file mode 100644 index 000000000000..79d7e15949e8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_adam_cpu_debuf.mlir @@ -0,0 +1,71 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_adam_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: f32, %arg9: f32, %arg10: f32, %arg11: f32, %arg12: f32, %arg13: i32, %arg14: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = arith.divf %arg5, %arg8 : f32 + %6 = arith.cmpi ne, %arg13, %c0_i32 : i32 + %7 = arith.cmpf une, %arg10, %cst : f32 + %8 = arith.subf %cst_0, %arg6 : f32 + %9 = arith.subf %cst_0, %arg7 : f32 + %10 = arith.cmpi ne, %arg14, %c0_i32 : i32 + %11:5 = affine.for %arg15 = 0 to 4096 iter_args(%arg16 = %4, %arg17 = %3, %arg18 = %2, %arg19 = %1, %arg20 = %0) -> (tensor, tensor, tensor, tensor, tensor) { + %extracted = tensor.extract %arg17[%arg15] : tensor + %17 = arith.divf %extracted, %arg12 : f32 + %inserted = tensor.insert %17 into %arg17[%arg15] : tensor + %18 = arith.negf %17 : f32 + %19 = arith.select %6, %18, %17 : f32 + %extracted_1 = tensor.extract %arg16[%arg15] : tensor + %20 = arith.mulf %extracted_1, %arg10 : f32 + %21 = arith.addf %19, %20 : f32 + %22 = arith.select %7, %21, %19 : f32 + %extracted_2 = tensor.extract %arg18[%arg15] : tensor + %23 = arith.subf %22, %extracted_2 : f32 + %24 = arith.mulf %8, %23 : f32 + %25 = arith.addf %extracted_2, %24 : f32 + %inserted_3 = tensor.insert %25 into %arg18[%arg15] : tensor + %extracted_4 = tensor.extract %arg19[%arg15] : tensor + %26 = arith.mulf %arg7, %extracted_4 : f32 + %27 = arith.mulf %9, %22 : f32 + %28 = arith.mulf %27, %22 : f32 + %29 = arith.addf %26, %28 : f32 + %inserted_5 = tensor.insert %29 into %arg19[%arg15] : tensor + %30:2 = scf.if %10 -> (f32, tensor) { + %extracted_9 = tensor.extract %arg20[%arg15] : tensor + %37 = arith.cmpf ogt, %extracted_9, %29 : f32 + %38 = arith.select %37, %extracted_9, %29 : f32 + %inserted_10 = tensor.insert %38 into %arg20[%arg15] : tensor + scf.yield %38, %inserted_10 : f32, tensor + } else { + scf.yield %29, %arg20 : f32, tensor + } + %extracted_6 = tensor.extract %inserted_3[%arg15] : tensor + %31 = arith.mulf %5, %extracted_6 : f32 + %32 = math.sqrt %30#0 : f32 + %33 = arith.divf %32, %arg9 : f32 + %34 = arith.addf %33, %arg11 : f32 + %35 = arith.divf %31, %34 : f32 + %extracted_7 = tensor.extract %arg16[%arg15] : tensor + %36 = arith.subf %extracted_7, %35 : f32 + %inserted_8 = tensor.insert %36 into %arg16[%arg15] : tensor + affine.yield %inserted_8, %inserted, %inserted_3, %inserted_5, %30#1 : tensor, tensor, tensor, tensor, tensor + } + %12 = bufferization.to_memref %11#4 : memref + memref.copy %12, %arg4 : memref to memref + %13 = bufferization.to_memref %11#3 : memref + memref.copy %13, %arg3 : memref to memref + %14 = bufferization.to_memref %11#2 : memref + memref.copy %14, %arg2 : memref to memref + %15 = bufferization.to_memref %11#1 : memref + memref.copy %15, %arg1 : memref to memref + %16 = bufferization.to_memref %11#0 : memref + memref.copy %16, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fused_adam_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_fused_adam_cpu_linalg.mlir new file mode 100644 index 000000000000..43401457e2ef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_adam_cpu_linalg.mlir @@ -0,0 +1,55 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_adam_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: f32, %arg9: f32, %arg10: f32, %arg11: f32, %arg12: f32, %arg13: i32, %arg14: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.divf %arg5, %arg8 : f32 + %1 = arith.cmpi ne, %arg13, %c0_i32 : i32 + %2 = arith.cmpf une, %arg10, %cst_0 : f32 + %3 = arith.subf %cst, %arg6 : f32 + %4 = arith.subf %cst, %arg7 : f32 + %5 = arith.cmpi ne, %arg14, %c0_i32 : i32 + affine.for %arg15 = 0 to 4096 { + %6 = affine.load %arg1[%arg15] : memref + %7 = arith.divf %6, %arg12 : f32 + affine.store %7, %arg1[%arg15] : memref + %8 = arith.negf %7 : f32 + %9 = arith.select %1, %8, %7 : f32 + %10 = affine.load %arg0[%arg15] : memref + %11 = arith.mulf %10, %arg10 : f32 + %12 = arith.addf %9, %11 : f32 + %13 = arith.select %2, %12, %9 : f32 + %14 = affine.load %arg2[%arg15] : memref + %15 = arith.subf %13, %14 : f32 + %16 = arith.mulf %3, %15 : f32 + %17 = arith.addf %14, %16 : f32 + affine.store %17, %arg2[%arg15] : memref + %18 = affine.load %arg3[%arg15] : memref + %19 = arith.mulf %arg7, %18 : f32 + %20 = arith.mulf %4, %13 : f32 + %21 = arith.mulf %20, %13 : f32 + %22 = arith.addf %19, %21 : f32 + affine.store %22, %arg3[%arg15] : memref + %23 = scf.if %5 -> (f32) { + %32 = affine.load %arg4[%arg15] : memref + %33 = arith.cmpf ogt, %32, %22 : f32 + %34 = arith.select %33, %32, %22 : f32 + affine.store %34, %arg4[%arg15] : memref + scf.yield %34 : f32 + } else { + scf.yield %22 : f32 + } + %24 = affine.load %arg2[%arg15] : memref + %25 = arith.mulf %0, %24 : f32 + %26 = math.sqrt %23 : f32 + %27 = arith.divf %26, %arg9 : f32 + %28 = arith.addf %27, %arg11 : f32 + %29 = arith.divf %25, %28 : f32 + %30 = affine.load %arg0[%arg15] : memref + %31 = arith.subf %30, %29 : f32 + affine.store %31, %arg0[%arg15] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fused_sgd_cpu.mlir b/issues/aten_c_kernels/results/aten_fused_sgd_cpu.mlir new file mode 100644 index 000000000000..d40c2e32a159 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_sgd_cpu.mlir @@ -0,0 +1,59 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_sgd_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: i32, %arg9: i32, %arg10: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg8, %c0_i32 : i32 + %1 = arith.cmpf une, %arg6, %cst_0 : f32 + %2 = arith.cmpf une, %arg4, %cst_0 : f32 + %3 = arith.cmpi ne, %arg9, %c0_i32 : i32 + %4 = arith.subf %cst, %arg5 : f32 + %5 = arith.cmpi ne, %arg10, %c0_i32 : i32 + affine.for %arg11 = 0 to 4096 { + %6 = affine.load %arg1[%arg11] : memref + %7 = arith.divf %6, %arg7 : f32 + affine.store %7, %arg1[%arg11] : memref + %8 = scf.if %0 -> (f32) { + %14 = arith.negf %7 : f32 + scf.yield %14 : f32 + } else { + scf.yield %7 : f32 + } + %9 = scf.if %1 -> (f32) { + %14 = affine.load %arg0[%arg11] : memref + %15 = arith.mulf %14, %arg6 : f32 + %16 = arith.addf %8, %15 : f32 + scf.yield %16 : f32 + } else { + scf.yield %8 : f32 + } + %10 = scf.if %2 -> (f32) { + %14 = scf.if %3 -> (f32) { + scf.yield %9 : f32 + } else { + %16 = affine.load %arg2[%arg11] : memref + %17 = arith.mulf %16, %arg4 : f32 + %18 = arith.mulf %9, %4 : f32 + %19 = arith.addf %17, %18 : f32 + scf.yield %19 : f32 + } + affine.store %14, %arg2[%arg11] : memref + %15 = scf.if %5 -> (f32) { + %16 = arith.mulf %arg4, %14 : f32 + %17 = arith.addf %9, %16 : f32 + scf.yield %17 : f32 + } else { + scf.yield %14 : f32 + } + scf.yield %15 : f32 + } else { + scf.yield %9 : f32 + } + %11 = arith.mulf %arg3, %10 : f32 + %12 = affine.load %arg0[%arg11] : memref + %13 = arith.subf %12, %11 : f32 + affine.store %13, %arg0[%arg11] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fused_sgd_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_fused_sgd_cpu/debuf.mlir new file mode 100644 index 000000000000..847a98a20a2e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_sgd_cpu/debuf.mlir @@ -0,0 +1,54 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_sgd_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: i32, %arg9: i32, %arg10: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = arith.cmpi ne, %arg8, %c0_i32 : i32 + %4 = arith.cmpf une, %arg6, %cst : f32 + %5 = arith.cmpf une, %arg4, %cst : f32 + %6 = arith.cmpi ne, %arg9, %c0_i32 : i32 + %7 = arith.subf %cst_0, %arg5 : f32 + %8 = arith.cmpi ne, %arg10, %c0_i32 : i32 + %9:3 = affine.for %arg11 = 0 to 4096 iter_args(%arg12 = %2, %arg13 = %1, %arg14 = %0) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg13[%arg11] : tensor + %13 = arith.divf %extracted, %arg7 : f32 + %inserted = tensor.insert %13 into %arg13[%arg11] : tensor + %14 = arith.negf %13 : f32 + %15 = arith.select %3, %14, %13 : f32 + %extracted_1 = tensor.extract %arg12[%arg11] : tensor + %16 = arith.mulf %extracted_1, %arg6 : f32 + %17 = arith.addf %15, %16 : f32 + %18 = arith.select %4, %17, %15 : f32 + %19:2 = scf.if %5 -> (f32, tensor) { + %extracted_4 = tensor.extract %arg14[%arg11] : tensor + %22 = arith.mulf %extracted_4, %arg4 : f32 + %23 = arith.mulf %18, %7 : f32 + %24 = arith.addf %22, %23 : f32 + %25 = arith.select %6, %18, %24 : f32 + %inserted_5 = tensor.insert %25 into %arg14[%arg11] : tensor + %26 = arith.mulf %arg4, %25 : f32 + %27 = arith.addf %18, %26 : f32 + %28 = arith.select %8, %27, %25 : f32 + scf.yield %28, %inserted_5 : f32, tensor + } else { + scf.yield %18, %arg14 : f32, tensor + } + %20 = arith.mulf %arg3, %19#0 : f32 + %extracted_2 = tensor.extract %arg12[%arg11] : tensor + %21 = arith.subf %extracted_2, %20 : f32 + %inserted_3 = tensor.insert %21 into %arg12[%arg11] : tensor + affine.yield %inserted_3, %inserted, %19#1 : tensor, tensor, tensor + } + %10 = bufferization.to_memref %9#2 : memref + memref.copy %10, %arg2 : memref to memref + %11 = bufferization.to_memref %9#1 : memref + memref.copy %11, %arg1 : memref to memref + %12 = bufferization.to_memref %9#0 : memref + memref.copy %12, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fused_sgd_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_fused_sgd_cpu/matched.mlir new file mode 100644 index 000000000000..847a98a20a2e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_sgd_cpu/matched.mlir @@ -0,0 +1,54 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_sgd_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: i32, %arg9: i32, %arg10: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = arith.cmpi ne, %arg8, %c0_i32 : i32 + %4 = arith.cmpf une, %arg6, %cst : f32 + %5 = arith.cmpf une, %arg4, %cst : f32 + %6 = arith.cmpi ne, %arg9, %c0_i32 : i32 + %7 = arith.subf %cst_0, %arg5 : f32 + %8 = arith.cmpi ne, %arg10, %c0_i32 : i32 + %9:3 = affine.for %arg11 = 0 to 4096 iter_args(%arg12 = %2, %arg13 = %1, %arg14 = %0) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg13[%arg11] : tensor + %13 = arith.divf %extracted, %arg7 : f32 + %inserted = tensor.insert %13 into %arg13[%arg11] : tensor + %14 = arith.negf %13 : f32 + %15 = arith.select %3, %14, %13 : f32 + %extracted_1 = tensor.extract %arg12[%arg11] : tensor + %16 = arith.mulf %extracted_1, %arg6 : f32 + %17 = arith.addf %15, %16 : f32 + %18 = arith.select %4, %17, %15 : f32 + %19:2 = scf.if %5 -> (f32, tensor) { + %extracted_4 = tensor.extract %arg14[%arg11] : tensor + %22 = arith.mulf %extracted_4, %arg4 : f32 + %23 = arith.mulf %18, %7 : f32 + %24 = arith.addf %22, %23 : f32 + %25 = arith.select %6, %18, %24 : f32 + %inserted_5 = tensor.insert %25 into %arg14[%arg11] : tensor + %26 = arith.mulf %arg4, %25 : f32 + %27 = arith.addf %18, %26 : f32 + %28 = arith.select %8, %27, %25 : f32 + scf.yield %28, %inserted_5 : f32, tensor + } else { + scf.yield %18, %arg14 : f32, tensor + } + %20 = arith.mulf %arg3, %19#0 : f32 + %extracted_2 = tensor.extract %arg12[%arg11] : tensor + %21 = arith.subf %extracted_2, %20 : f32 + %inserted_3 = tensor.insert %21 into %arg12[%arg11] : tensor + affine.yield %inserted_3, %inserted, %19#1 : tensor, tensor, tensor + } + %10 = bufferization.to_memref %9#2 : memref + memref.copy %10, %arg2 : memref to memref + %11 = bufferization.to_memref %9#1 : memref + memref.copy %11, %arg1 : memref to memref + %12 = bufferization.to_memref %9#0 : memref + memref.copy %12, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fused_sgd_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_fused_sgd_cpu/orig.mlir new file mode 100644 index 000000000000..d40c2e32a159 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_sgd_cpu/orig.mlir @@ -0,0 +1,59 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_sgd_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: i32, %arg9: i32, %arg10: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg8, %c0_i32 : i32 + %1 = arith.cmpf une, %arg6, %cst_0 : f32 + %2 = arith.cmpf une, %arg4, %cst_0 : f32 + %3 = arith.cmpi ne, %arg9, %c0_i32 : i32 + %4 = arith.subf %cst, %arg5 : f32 + %5 = arith.cmpi ne, %arg10, %c0_i32 : i32 + affine.for %arg11 = 0 to 4096 { + %6 = affine.load %arg1[%arg11] : memref + %7 = arith.divf %6, %arg7 : f32 + affine.store %7, %arg1[%arg11] : memref + %8 = scf.if %0 -> (f32) { + %14 = arith.negf %7 : f32 + scf.yield %14 : f32 + } else { + scf.yield %7 : f32 + } + %9 = scf.if %1 -> (f32) { + %14 = affine.load %arg0[%arg11] : memref + %15 = arith.mulf %14, %arg6 : f32 + %16 = arith.addf %8, %15 : f32 + scf.yield %16 : f32 + } else { + scf.yield %8 : f32 + } + %10 = scf.if %2 -> (f32) { + %14 = scf.if %3 -> (f32) { + scf.yield %9 : f32 + } else { + %16 = affine.load %arg2[%arg11] : memref + %17 = arith.mulf %16, %arg4 : f32 + %18 = arith.mulf %9, %4 : f32 + %19 = arith.addf %17, %18 : f32 + scf.yield %19 : f32 + } + affine.store %14, %arg2[%arg11] : memref + %15 = scf.if %5 -> (f32) { + %16 = arith.mulf %arg4, %14 : f32 + %17 = arith.addf %9, %16 : f32 + scf.yield %17 : f32 + } else { + scf.yield %14 : f32 + } + scf.yield %15 : f32 + } else { + scf.yield %9 : f32 + } + %11 = arith.mulf %arg3, %10 : f32 + %12 = affine.load %arg0[%arg11] : memref + %13 = arith.subf %12, %11 : f32 + affine.store %13, %arg0[%arg11] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_fused_sgd_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_fused_sgd_cpu/raised.mlir new file mode 100644 index 000000000000..d4ed4e515e73 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_sgd_cpu/raised.mlir @@ -0,0 +1,44 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_sgd_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: i32, %arg9: i32, %arg10: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg8, %c0_i32 : i32 + %1 = arith.cmpf une, %arg6, %cst_0 : f32 + %2 = arith.cmpf une, %arg4, %cst_0 : f32 + %3 = arith.cmpi ne, %arg9, %c0_i32 : i32 + %4 = arith.subf %cst, %arg5 : f32 + %5 = arith.cmpi ne, %arg10, %c0_i32 : i32 + affine.for %arg11 = 0 to 4096 { + %6 = affine.load %arg1[%arg11] : memref + %7 = arith.divf %6, %arg7 : f32 + affine.store %7, %arg1[%arg11] : memref + %8 = arith.negf %7 : f32 + %9 = arith.select %0, %8, %7 : f32 + %10 = affine.load %arg0[%arg11] : memref + %11 = arith.mulf %10, %arg6 : f32 + %12 = arith.addf %9, %11 : f32 + %13 = arith.select %1, %12, %9 : f32 + %14 = scf.if %2 -> (f32) { + %18 = affine.load %arg2[%arg11] : memref + %19 = arith.mulf %18, %arg4 : f32 + %20 = arith.mulf %13, %4 : f32 + %21 = arith.addf %19, %20 : f32 + %22 = arith.select %3, %13, %21 : f32 + affine.store %22, %arg2[%arg11] : memref + %23 = arith.mulf %arg4, %22 : f32 + %24 = arith.addf %13, %23 : f32 + %25 = arith.select %5, %24, %22 : f32 + scf.yield %25 : f32 + } else { + scf.yield %13 : f32 + } + %15 = arith.mulf %arg3, %14 : f32 + %16 = affine.load %arg0[%arg11] : memref + %17 = arith.subf %16, %15 : f32 + affine.store %17, %arg0[%arg11] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fused_sgd_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_fused_sgd_cpu_debuf.mlir new file mode 100644 index 000000000000..847a98a20a2e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_sgd_cpu_debuf.mlir @@ -0,0 +1,54 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_sgd_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: i32, %arg9: i32, %arg10: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = arith.cmpi ne, %arg8, %c0_i32 : i32 + %4 = arith.cmpf une, %arg6, %cst : f32 + %5 = arith.cmpf une, %arg4, %cst : f32 + %6 = arith.cmpi ne, %arg9, %c0_i32 : i32 + %7 = arith.subf %cst_0, %arg5 : f32 + %8 = arith.cmpi ne, %arg10, %c0_i32 : i32 + %9:3 = affine.for %arg11 = 0 to 4096 iter_args(%arg12 = %2, %arg13 = %1, %arg14 = %0) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg13[%arg11] : tensor + %13 = arith.divf %extracted, %arg7 : f32 + %inserted = tensor.insert %13 into %arg13[%arg11] : tensor + %14 = arith.negf %13 : f32 + %15 = arith.select %3, %14, %13 : f32 + %extracted_1 = tensor.extract %arg12[%arg11] : tensor + %16 = arith.mulf %extracted_1, %arg6 : f32 + %17 = arith.addf %15, %16 : f32 + %18 = arith.select %4, %17, %15 : f32 + %19:2 = scf.if %5 -> (f32, tensor) { + %extracted_4 = tensor.extract %arg14[%arg11] : tensor + %22 = arith.mulf %extracted_4, %arg4 : f32 + %23 = arith.mulf %18, %7 : f32 + %24 = arith.addf %22, %23 : f32 + %25 = arith.select %6, %18, %24 : f32 + %inserted_5 = tensor.insert %25 into %arg14[%arg11] : tensor + %26 = arith.mulf %arg4, %25 : f32 + %27 = arith.addf %18, %26 : f32 + %28 = arith.select %8, %27, %25 : f32 + scf.yield %28, %inserted_5 : f32, tensor + } else { + scf.yield %18, %arg14 : f32, tensor + } + %20 = arith.mulf %arg3, %19#0 : f32 + %extracted_2 = tensor.extract %arg12[%arg11] : tensor + %21 = arith.subf %extracted_2, %20 : f32 + %inserted_3 = tensor.insert %21 into %arg12[%arg11] : tensor + affine.yield %inserted_3, %inserted, %19#1 : tensor, tensor, tensor + } + %10 = bufferization.to_memref %9#2 : memref + memref.copy %10, %arg2 : memref to memref + %11 = bufferization.to_memref %9#1 : memref + memref.copy %11, %arg1 : memref to memref + %12 = bufferization.to_memref %9#0 : memref + memref.copy %12, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_fused_sgd_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_fused_sgd_cpu_linalg.mlir new file mode 100644 index 000000000000..d4ed4e515e73 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_fused_sgd_cpu_linalg.mlir @@ -0,0 +1,44 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_fused_sgd_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: f32, %arg7: f32, %arg8: i32, %arg9: i32, %arg10: i32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg8, %c0_i32 : i32 + %1 = arith.cmpf une, %arg6, %cst_0 : f32 + %2 = arith.cmpf une, %arg4, %cst_0 : f32 + %3 = arith.cmpi ne, %arg9, %c0_i32 : i32 + %4 = arith.subf %cst, %arg5 : f32 + %5 = arith.cmpi ne, %arg10, %c0_i32 : i32 + affine.for %arg11 = 0 to 4096 { + %6 = affine.load %arg1[%arg11] : memref + %7 = arith.divf %6, %arg7 : f32 + affine.store %7, %arg1[%arg11] : memref + %8 = arith.negf %7 : f32 + %9 = arith.select %0, %8, %7 : f32 + %10 = affine.load %arg0[%arg11] : memref + %11 = arith.mulf %10, %arg6 : f32 + %12 = arith.addf %9, %11 : f32 + %13 = arith.select %1, %12, %9 : f32 + %14 = scf.if %2 -> (f32) { + %18 = affine.load %arg2[%arg11] : memref + %19 = arith.mulf %18, %arg4 : f32 + %20 = arith.mulf %13, %4 : f32 + %21 = arith.addf %19, %20 : f32 + %22 = arith.select %3, %13, %21 : f32 + affine.store %22, %arg2[%arg11] : memref + %23 = arith.mulf %arg4, %22 : f32 + %24 = arith.addf %13, %23 : f32 + %25 = arith.select %5, %24, %22 : f32 + scf.yield %25 : f32 + } else { + scf.yield %13 : f32 + } + %15 = arith.mulf %arg3, %14 : f32 + %16 = affine.load %arg0[%arg11] : memref + %17 = arith.subf %16, %15 : f32 + affine.store %17, %arg0[%arg11] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gamma_transform_cpu.mlir b/issues/aten_c_kernels/results/aten_gamma_transform_cpu.mlir new file mode 100644 index 000000000000..a48a3a966dfb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gamma_transform_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gamma_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 9.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.333333313 : f32 + affine.for %arg4 = 0 to 1024 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.subf %0, %cst_1 : f32 + %2 = arith.mulf %1, %cst : f32 + %3 = math.sqrt %2 : f32 + %4 = arith.divf %cst_0, %3 : f32 + %5 = affine.load %arg1[%arg4] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.addf %6, %cst_0 : f32 + %8 = arith.mulf %1, %7 : f32 + %9 = arith.mulf %8, %7 : f32 + %10 = arith.mulf %9, %7 : f32 + affine.store %10, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gamma_transform_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_gamma_transform_cpu/debuf.mlir new file mode 100644 index 000000000000..1b3b45353a5a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gamma_transform_cpu/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gamma_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.333333313 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 9.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.subf %in, %cst : f32 + %6 = arith.mulf %5, %cst_1 : f32 + %7 = math.sqrt %6 : f32 + %8 = arith.divf %cst_0, %7 : f32 + %9 = arith.mulf %8, %in_2 : f32 + %10 = arith.addf %9, %cst_0 : f32 + %11 = arith.mulf %5, %10 : f32 + %12 = arith.mulf %11, %10 : f32 + %13 = arith.mulf %12, %10 : f32 + linalg.yield %13 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gamma_transform_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_gamma_transform_cpu/matched.mlir new file mode 100644 index 000000000000..1b3b45353a5a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gamma_transform_cpu/matched.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gamma_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.333333313 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 9.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.subf %in, %cst : f32 + %6 = arith.mulf %5, %cst_1 : f32 + %7 = math.sqrt %6 : f32 + %8 = arith.divf %cst_0, %7 : f32 + %9 = arith.mulf %8, %in_2 : f32 + %10 = arith.addf %9, %cst_0 : f32 + %11 = arith.mulf %5, %10 : f32 + %12 = arith.mulf %11, %10 : f32 + %13 = arith.mulf %12, %10 : f32 + linalg.yield %13 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gamma_transform_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_gamma_transform_cpu/orig.mlir new file mode 100644 index 000000000000..a48a3a966dfb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gamma_transform_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gamma_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 9.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.333333313 : f32 + affine.for %arg4 = 0 to 1024 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.subf %0, %cst_1 : f32 + %2 = arith.mulf %1, %cst : f32 + %3 = math.sqrt %2 : f32 + %4 = arith.divf %cst_0, %3 : f32 + %5 = affine.load %arg1[%arg4] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.addf %6, %cst_0 : f32 + %8 = arith.mulf %1, %7 : f32 + %9 = arith.mulf %8, %7 : f32 + %10 = arith.mulf %9, %7 : f32 + affine.store %10, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gamma_transform_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_gamma_transform_cpu/raised.mlir new file mode 100644 index 000000000000..717d19417bf2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gamma_transform_cpu/raised.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gamma_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 9.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.333333313 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.subf %in, %cst_1 : f32 + %1 = arith.mulf %0, %cst : f32 + %2 = math.sqrt %1 : f32 + %3 = arith.divf %cst_0, %2 : f32 + %4 = arith.mulf %3, %in_2 : f32 + %5 = arith.addf %4, %cst_0 : f32 + %6 = arith.mulf %0, %5 : f32 + %7 = arith.mulf %6, %5 : f32 + %8 = arith.mulf %7, %5 : f32 + linalg.yield %8 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gamma_transform_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_gamma_transform_cpu_debuf.mlir new file mode 100644 index 000000000000..1b3b45353a5a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gamma_transform_cpu_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gamma_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.333333313 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 9.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.subf %in, %cst : f32 + %6 = arith.mulf %5, %cst_1 : f32 + %7 = math.sqrt %6 : f32 + %8 = arith.divf %cst_0, %7 : f32 + %9 = arith.mulf %8, %in_2 : f32 + %10 = arith.addf %9, %cst_0 : f32 + %11 = arith.mulf %5, %10 : f32 + %12 = arith.mulf %11, %10 : f32 + %13 = arith.mulf %12, %10 : f32 + linalg.yield %13 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gamma_transform_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_gamma_transform_cpu_linalg.mlir new file mode 100644 index 000000000000..717d19417bf2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gamma_transform_cpu_linalg.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gamma_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 9.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.333333313 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.subf %in, %cst_1 : f32 + %1 = arith.mulf %0, %cst : f32 + %2 = math.sqrt %1 : f32 + %3 = arith.divf %cst_0, %2 : f32 + %4 = arith.mulf %3, %in_2 : f32 + %5 = arith.addf %4, %cst_0 : f32 + %6 = arith.mulf %0, %5 : f32 + %7 = arith.mulf %6, %5 : f32 + %8 = arith.mulf %7, %5 : f32 + linalg.yield %8 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gather_cpu.mlir b/issues/aten_c_kernels/results/aten_gather_cpu.mlir new file mode 100644 index 000000000000..964121d28c76 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gather_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gather_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%arg3, %1] : memref + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gather_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_gather_cpu/debuf.mlir new file mode 100644 index 000000000000..4ae4a168114f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gather_cpu/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gather_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3, %4] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%3, %6] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gather_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_gather_cpu/matched.mlir new file mode 100644 index 000000000000..4ae4a168114f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gather_cpu/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gather_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3, %4] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%3, %6] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gather_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_gather_cpu/orig.mlir new file mode 100644 index 000000000000..964121d28c76 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gather_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gather_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%arg3, %1] : memref + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gather_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_gather_cpu/raised.mlir new file mode 100644 index 000000000000..67d55288aca6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gather_cpu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gather_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg2[0, 0] [%c32, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = memref.load %arg1[%0, %1] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%0, %3] : memref + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gather_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_gather_cpu_debuf.mlir new file mode 100644 index 000000000000..4ae4a168114f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gather_cpu_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gather_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3, %4] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%3, %6] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gather_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_gather_cpu_linalg.mlir new file mode 100644 index 000000000000..67d55288aca6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gather_cpu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gather_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg2[0, 0] [%c32, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = memref.load %arg1[%0, %1] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%0, %3] : memref + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu.mlir b/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu.mlir new file mode 100644 index 000000000000..703fed5f1b6b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gather_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%arg3, %1] : memref + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu/debuf.mlir new file mode 100644 index 000000000000..b81af5379ae2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gather_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3, %4] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%3, %6] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu/matched.mlir new file mode 100644 index 000000000000..b81af5379ae2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gather_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3, %4] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%3, %6] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu/orig.mlir new file mode 100644 index 000000000000..703fed5f1b6b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gather_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%arg3, %1] : memref + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu/raised.mlir new file mode 100644 index 000000000000..01f38e34212e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gather_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg2[0, 0] [%c32, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = memref.load %arg1[%0, %1] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%0, %3] : memref + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu_debuf.mlir new file mode 100644 index 000000000000..b81af5379ae2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gather_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3, %4] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%3, %6] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu_linalg.mlir new file mode 100644 index 000000000000..01f38e34212e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gather_expanded_index_cpu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gather_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg2[0, 0] [%c32, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = memref.load %arg1[%0, %1] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%0, %3] : memref + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gcd_i32.mlir b/issues/aten_c_kernels/results/aten_gcd_i32.mlir new file mode 100644 index 000000000000..214eb08bccdb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gcd_i32.mlir @@ -0,0 +1,33 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gcd_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpi slt, %0, %c0_i32 : i32 + %2 = scf.if %1 -> (i32) { + %7 = arith.subi %c0_i32, %0 : i32 + scf.yield %7 : i32 + } else { + scf.yield %0 : i32 + } + %3 = affine.load %arg1[%arg3] : memref + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = scf.if %4 -> (i32) { + %7 = arith.subi %c0_i32, %3 : i32 + scf.yield %7 : i32 + } else { + scf.yield %3 : i32 + } + %6:2 = scf.while (%arg4 = %5, %arg5 = %2) : (i32, i32) -> (i32, i32) { + %7 = arith.cmpi ne, %arg4, %c0_i32 : i32 + scf.condition(%7) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %7 = arith.remsi %arg4, %arg5 : i32 + scf.yield %7, %arg5 : i32, i32 + } + affine.store %6#0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gcd_i32/debuf.mlir b/issues/aten_c_kernels/results/aten_gcd_i32/debuf.mlir new file mode 100644 index 000000000000..19a0cc451b60 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gcd_i32/debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gcd_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.cmpi slt, %in, %c0_i32 : i32 + %6 = arith.subi %c0_i32, %in : i32 + %7 = arith.select %5, %6, %in : i32 + %8 = arith.cmpi slt, %in_0, %c0_i32 : i32 + %9 = arith.subi %c0_i32, %in_0 : i32 + %10 = arith.select %8, %9, %in_0 : i32 + %11:2 = scf.while (%arg3 = %10, %arg4 = %7) : (i32, i32) -> (i32, i32) { + %12 = arith.cmpi ne, %arg3, %c0_i32 : i32 + scf.condition(%12) %arg4, %arg3 : i32, i32 + } do { + ^bb0(%arg3: i32, %arg4: i32): + %12 = arith.remsi %arg3, %arg4 : i32 + scf.yield %12, %arg4 : i32, i32 + } + linalg.yield %11#0 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gcd_i32/matched.mlir b/issues/aten_c_kernels/results/aten_gcd_i32/matched.mlir new file mode 100644 index 000000000000..19a0cc451b60 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gcd_i32/matched.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gcd_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.cmpi slt, %in, %c0_i32 : i32 + %6 = arith.subi %c0_i32, %in : i32 + %7 = arith.select %5, %6, %in : i32 + %8 = arith.cmpi slt, %in_0, %c0_i32 : i32 + %9 = arith.subi %c0_i32, %in_0 : i32 + %10 = arith.select %8, %9, %in_0 : i32 + %11:2 = scf.while (%arg3 = %10, %arg4 = %7) : (i32, i32) -> (i32, i32) { + %12 = arith.cmpi ne, %arg3, %c0_i32 : i32 + scf.condition(%12) %arg4, %arg3 : i32, i32 + } do { + ^bb0(%arg3: i32, %arg4: i32): + %12 = arith.remsi %arg3, %arg4 : i32 + scf.yield %12, %arg4 : i32, i32 + } + linalg.yield %11#0 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gcd_i32/orig.mlir b/issues/aten_c_kernels/results/aten_gcd_i32/orig.mlir new file mode 100644 index 000000000000..214eb08bccdb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gcd_i32/orig.mlir @@ -0,0 +1,33 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gcd_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpi slt, %0, %c0_i32 : i32 + %2 = scf.if %1 -> (i32) { + %7 = arith.subi %c0_i32, %0 : i32 + scf.yield %7 : i32 + } else { + scf.yield %0 : i32 + } + %3 = affine.load %arg1[%arg3] : memref + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = scf.if %4 -> (i32) { + %7 = arith.subi %c0_i32, %3 : i32 + scf.yield %7 : i32 + } else { + scf.yield %3 : i32 + } + %6:2 = scf.while (%arg4 = %5, %arg5 = %2) : (i32, i32) -> (i32, i32) { + %7 = arith.cmpi ne, %arg4, %c0_i32 : i32 + scf.condition(%7) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %7 = arith.remsi %arg4, %arg5 : i32 + scf.yield %7, %arg5 : i32, i32 + } + affine.store %6#0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gcd_i32/raised.mlir b/issues/aten_c_kernels/results/aten_gcd_i32/raised.mlir new file mode 100644 index 000000000000..a651f20e87ab --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gcd_i32/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gcd_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %0 = arith.cmpi slt, %in, %c0_i32 : i32 + %1 = arith.subi %c0_i32, %in : i32 + %2 = arith.select %0, %1, %in : i32 + %3 = arith.cmpi slt, %in_0, %c0_i32 : i32 + %4 = arith.subi %c0_i32, %in_0 : i32 + %5 = arith.select %3, %4, %in_0 : i32 + %6:2 = scf.while (%arg3 = %5, %arg4 = %2) : (i32, i32) -> (i32, i32) { + %7 = arith.cmpi ne, %arg3, %c0_i32 : i32 + scf.condition(%7) %arg4, %arg3 : i32, i32 + } do { + ^bb0(%arg3: i32, %arg4: i32): + %7 = arith.remsi %arg3, %arg4 : i32 + scf.yield %7, %arg4 : i32, i32 + } + linalg.yield %6#0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gcd_i32_debuf.mlir b/issues/aten_c_kernels/results/aten_gcd_i32_debuf.mlir new file mode 100644 index 000000000000..19a0cc451b60 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gcd_i32_debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gcd_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.cmpi slt, %in, %c0_i32 : i32 + %6 = arith.subi %c0_i32, %in : i32 + %7 = arith.select %5, %6, %in : i32 + %8 = arith.cmpi slt, %in_0, %c0_i32 : i32 + %9 = arith.subi %c0_i32, %in_0 : i32 + %10 = arith.select %8, %9, %in_0 : i32 + %11:2 = scf.while (%arg3 = %10, %arg4 = %7) : (i32, i32) -> (i32, i32) { + %12 = arith.cmpi ne, %arg3, %c0_i32 : i32 + scf.condition(%12) %arg4, %arg3 : i32, i32 + } do { + ^bb0(%arg3: i32, %arg4: i32): + %12 = arith.remsi %arg3, %arg4 : i32 + scf.yield %12, %arg4 : i32, i32 + } + linalg.yield %11#0 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gcd_i32_linalg.mlir b/issues/aten_c_kernels/results/aten_gcd_i32_linalg.mlir new file mode 100644 index 000000000000..a651f20e87ab --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gcd_i32_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gcd_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %0 = arith.cmpi slt, %in, %c0_i32 : i32 + %1 = arith.subi %c0_i32, %in : i32 + %2 = arith.select %0, %1, %in : i32 + %3 = arith.cmpi slt, %in_0, %c0_i32 : i32 + %4 = arith.subi %c0_i32, %in_0 : i32 + %5 = arith.select %3, %4, %in_0 : i32 + %6:2 = scf.while (%arg3 = %5, %arg4 = %2) : (i32, i32) -> (i32, i32) { + %7 = arith.cmpi ne, %arg3, %c0_i32 : i32 + scf.condition(%7) %arg4, %arg3 : i32, i32 + } do { + ^bb0(%arg3: i32, %arg4: i32): + %7 = arith.remsi %arg3, %arg4 : i32 + scf.yield %7, %arg4 : i32, i32 + } + linalg.yield %6#0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ge.mlir b/issues/aten_c_kernels/results/aten_ge.mlir new file mode 100644 index 000000000000..8e1954c886c7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ge.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ge(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf oge, %0, %1 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_ge/debuf.mlir b/issues/aten_c_kernels/results/aten_ge/debuf.mlir new file mode 100644 index 000000000000..4a2d92c9e632 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ge/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ge(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf oge, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ge/matched.mlir b/issues/aten_c_kernels/results/aten_ge/matched.mlir new file mode 100644 index 000000000000..4a2d92c9e632 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ge/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ge(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf oge, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ge/orig.mlir b/issues/aten_c_kernels/results/aten_ge/orig.mlir new file mode 100644 index 000000000000..8e1954c886c7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ge/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ge(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf oge, %0, %1 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_ge/raised.mlir b/issues/aten_c_kernels/results/aten_ge/raised.mlir new file mode 100644 index 000000000000..0a048685b770 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ge/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ge(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf oge, %in, %in_0 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ge_debuf.mlir b/issues/aten_c_kernels/results/aten_ge_debuf.mlir new file mode 100644 index 000000000000..4a2d92c9e632 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ge_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ge(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf oge, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ge_linalg.mlir b/issues/aten_c_kernels/results/aten_ge_linalg.mlir new file mode 100644 index 000000000000..0a048685b770 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ge_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ge(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf oge, %in, %in_0 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gelu.mlir b/issues/aten_c_kernels/results/aten_gelu.mlir new file mode 100644 index 000000000000..858194cf558a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.471500e-02 : f32 + %cst_2 = arith.constant 0.797884583 : f32 + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.mulf %0, %cst_0 : f32 + %2 = arith.mulf %0, %cst_1 : f32 + %3 = arith.mulf %2, %0 : f32 + %4 = arith.mulf %3, %0 : f32 + %5 = arith.addf %0, %4 : f32 + %6 = arith.mulf %5, %cst_2 : f32 + %7 = math.tanh %6 : f32 + %8 = arith.addf %7, %cst : f32 + %9 = arith.mulf %1, %8 : f32 + affine.store %9, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gelu/debuf.mlir b/issues/aten_c_kernels/results/aten_gelu/debuf.mlir new file mode 100644 index 000000000000..d6dd0f0609c3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.797884583 : f32 + %cst_0 = arith.constant 4.471500e-02 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %cst_1 : f32 + %5 = arith.mulf %in, %cst_0 : f32 + %6 = arith.mulf %5, %in : f32 + %7 = arith.mulf %6, %in : f32 + %8 = arith.addf %in, %7 : f32 + %9 = arith.mulf %8, %cst : f32 + %10 = math.tanh %9 : f32 + %11 = arith.addf %10, %cst_2 : f32 + %12 = arith.mulf %4, %11 : f32 + linalg.yield %12 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gelu/matched.mlir b/issues/aten_c_kernels/results/aten_gelu/matched.mlir new file mode 100644 index 000000000000..32d5698c6fb2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu/matched.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.797884583 : f32 + %cst_0 = arith.constant 4.471500e-02 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = kernel.launch @gelu_tanh_f32_tensor(%0, %1) : (tensor, tensor) -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gelu/orig.mlir b/issues/aten_c_kernels/results/aten_gelu/orig.mlir new file mode 100644 index 000000000000..858194cf558a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.471500e-02 : f32 + %cst_2 = arith.constant 0.797884583 : f32 + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.mulf %0, %cst_0 : f32 + %2 = arith.mulf %0, %cst_1 : f32 + %3 = arith.mulf %2, %0 : f32 + %4 = arith.mulf %3, %0 : f32 + %5 = arith.addf %0, %4 : f32 + %6 = arith.mulf %5, %cst_2 : f32 + %7 = math.tanh %6 : f32 + %8 = arith.addf %7, %cst : f32 + %9 = arith.mulf %1, %8 : f32 + affine.store %9, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gelu/raised.mlir b/issues/aten_c_kernels/results/aten_gelu/raised.mlir new file mode 100644 index 000000000000..fc2f17e7a155 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu/raised.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.471500e-02 : f32 + %cst_2 = arith.constant 0.797884583 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %cst_0 : f32 + %1 = arith.mulf %in, %cst_1 : f32 + %2 = arith.mulf %1, %in : f32 + %3 = arith.mulf %2, %in : f32 + %4 = arith.addf %in, %3 : f32 + %5 = arith.mulf %4, %cst_2 : f32 + %6 = math.tanh %5 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.mulf %0, %7 : f32 + linalg.yield %8 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact.mlir b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact.mlir new file mode 100644 index 000000000000..125c3123bb46 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_backward_cpu_exact(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -5.000000e-01 : f32 + %cst_0 = arith.constant 0.398942292 : f32 + %cst_1 = arith.constant 0.707106769 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %cst_3 = arith.constant 5.000000e-01 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.mulf %0, %cst_1 : f32 + %2 = func.call @erff(%1) : (f32) -> f32 + %3 = arith.addf %2, %cst_2 : f32 + %4 = arith.mulf %3, %cst_3 : f32 + %5 = affine.load %arg0[%arg3] : memref + %6 = affine.load %arg1[%arg3] : memref + %7 = arith.mulf %6, %cst : f32 + %8 = arith.mulf %7, %6 : f32 + %9 = math.exp %8 : f32 + %10 = arith.mulf %9, %cst_0 : f32 + %11 = arith.mulf %6, %10 : f32 + %12 = arith.addf %4, %11 : f32 + %13 = arith.mulf %5, %12 : f32 + affine.store %13, %arg2[%arg3] : memref + } + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact/debuf.mlir b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact/debuf.mlir new file mode 100644 index 000000000000..7ec8eb22c748 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact/debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_backward_cpu_exact(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.707106769 : f32 + %cst_2 = arith.constant 0.398942292 : f32 + %cst_3 = arith.constant -5.000000e-01 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0, %1 : tensor, tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_4: f32, %in_5: f32, %out: f32): + %5 = arith.mulf %in, %cst_1 : f32 + %6 = math.erf %5 : f32 + %7 = arith.addf %6, %cst_0 : f32 + %8 = arith.mulf %7, %cst : f32 + %9 = arith.mulf %in_5, %cst_3 : f32 + %10 = arith.mulf %9, %in_5 : f32 + %11 = math.exp %10 : f32 + %12 = arith.mulf %11, %cst_2 : f32 + %13 = arith.mulf %in_5, %12 : f32 + %14 = arith.addf %8, %13 : f32 + %15 = arith.mulf %in_4, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact/matched.mlir b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact/matched.mlir new file mode 100644 index 000000000000..7ec8eb22c748 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact/matched.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_backward_cpu_exact(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.707106769 : f32 + %cst_2 = arith.constant 0.398942292 : f32 + %cst_3 = arith.constant -5.000000e-01 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0, %1 : tensor, tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_4: f32, %in_5: f32, %out: f32): + %5 = arith.mulf %in, %cst_1 : f32 + %6 = math.erf %5 : f32 + %7 = arith.addf %6, %cst_0 : f32 + %8 = arith.mulf %7, %cst : f32 + %9 = arith.mulf %in_5, %cst_3 : f32 + %10 = arith.mulf %9, %in_5 : f32 + %11 = math.exp %10 : f32 + %12 = arith.mulf %11, %cst_2 : f32 + %13 = arith.mulf %in_5, %12 : f32 + %14 = arith.addf %8, %13 : f32 + %15 = arith.mulf %in_4, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact/orig.mlir b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact/orig.mlir new file mode 100644 index 000000000000..125c3123bb46 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact/orig.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_backward_cpu_exact(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -5.000000e-01 : f32 + %cst_0 = arith.constant 0.398942292 : f32 + %cst_1 = arith.constant 0.707106769 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %cst_3 = arith.constant 5.000000e-01 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.mulf %0, %cst_1 : f32 + %2 = func.call @erff(%1) : (f32) -> f32 + %3 = arith.addf %2, %cst_2 : f32 + %4 = arith.mulf %3, %cst_3 : f32 + %5 = affine.load %arg0[%arg3] : memref + %6 = affine.load %arg1[%arg3] : memref + %7 = arith.mulf %6, %cst : f32 + %8 = arith.mulf %7, %6 : f32 + %9 = math.exp %8 : f32 + %10 = arith.mulf %9, %cst_0 : f32 + %11 = arith.mulf %6, %10 : f32 + %12 = arith.addf %4, %11 : f32 + %13 = arith.mulf %5, %12 : f32 + affine.store %13, %arg2[%arg3] : memref + } + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact/raised.mlir b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact/raised.mlir new file mode 100644 index 000000000000..181df469f10a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact/raised.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_backward_cpu_exact(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -5.000000e-01 : f32 + %cst_0 = arith.constant 0.398942292 : f32 + %cst_1 = arith.constant 0.707106769 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %cst_3 = arith.constant 5.000000e-01 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0, %arg1 : memref, memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_4: f32, %in_5: f32, %out: f32): + %0 = arith.mulf %in, %cst_1 : f32 + %1 = math.erf %0 : f32 + %2 = arith.addf %1, %cst_2 : f32 + %3 = arith.mulf %2, %cst_3 : f32 + %4 = arith.mulf %in_5, %cst : f32 + %5 = arith.mulf %4, %in_5 : f32 + %6 = math.exp %5 : f32 + %7 = arith.mulf %6, %cst_0 : f32 + %8 = arith.mulf %in_5, %7 : f32 + %9 = arith.addf %3, %8 : f32 + %10 = arith.mulf %in_4, %9 : f32 + linalg.yield %10 : f32 + } + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact_debuf.mlir b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact_debuf.mlir new file mode 100644 index 000000000000..7ec8eb22c748 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact_debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_backward_cpu_exact(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.707106769 : f32 + %cst_2 = arith.constant 0.398942292 : f32 + %cst_3 = arith.constant -5.000000e-01 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0, %1 : tensor, tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_4: f32, %in_5: f32, %out: f32): + %5 = arith.mulf %in, %cst_1 : f32 + %6 = math.erf %5 : f32 + %7 = arith.addf %6, %cst_0 : f32 + %8 = arith.mulf %7, %cst : f32 + %9 = arith.mulf %in_5, %cst_3 : f32 + %10 = arith.mulf %9, %in_5 : f32 + %11 = math.exp %10 : f32 + %12 = arith.mulf %11, %cst_2 : f32 + %13 = arith.mulf %in_5, %12 : f32 + %14 = arith.addf %8, %13 : f32 + %15 = arith.mulf %in_4, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact_linalg.mlir b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact_linalg.mlir new file mode 100644 index 000000000000..181df469f10a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_exact_linalg.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_backward_cpu_exact(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -5.000000e-01 : f32 + %cst_0 = arith.constant 0.398942292 : f32 + %cst_1 = arith.constant 0.707106769 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %cst_3 = arith.constant 5.000000e-01 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0, %arg1 : memref, memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_4: f32, %in_5: f32, %out: f32): + %0 = arith.mulf %in, %cst_1 : f32 + %1 = math.erf %0 : f32 + %2 = arith.addf %1, %cst_2 : f32 + %3 = arith.mulf %2, %cst_3 : f32 + %4 = arith.mulf %in_5, %cst : f32 + %5 = arith.mulf %4, %in_5 : f32 + %6 = math.exp %5 : f32 + %7 = arith.mulf %6, %cst_0 : f32 + %8 = arith.mulf %in_5, %7 : f32 + %9 = arith.addf %3, %8 : f32 + %10 = arith.mulf %in_4, %9 : f32 + linalg.yield %10 : f32 + } + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh.mlir b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh.mlir new file mode 100644 index 000000000000..9932a9cea12d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh.mlir @@ -0,0 +1,33 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_backward_cpu_tanh(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.134144992 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 4.471500e-02 : f32 + %cst_3 = arith.constant 0.797884583 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.mulf %1, %cst_2 : f32 + %3 = arith.mulf %1, %1 : f32 + %4 = arith.mulf %2, %3 : f32 + %5 = arith.addf %1, %4 : f32 + %6 = arith.mulf %5, %cst_3 : f32 + %7 = math.tanh %6 : f32 + %8 = arith.addf %7, %cst_0 : f32 + %9 = arith.mulf %8, %cst_1 : f32 + %10 = arith.mulf %1, %cst_1 : f32 + %11 = arith.mulf %7, %7 : f32 + %12 = arith.subf %cst_0, %11 : f32 + %13 = arith.mulf %10, %12 : f32 + %14 = arith.mulf %13, %cst_3 : f32 + %15 = arith.mulf %3, %cst : f32 + %16 = arith.addf %15, %cst_0 : f32 + %17 = arith.mulf %14, %16 : f32 + %18 = arith.addf %9, %17 : f32 + %19 = arith.mulf %0, %18 : f32 + affine.store %19, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh/debuf.mlir b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh/debuf.mlir new file mode 100644 index 000000000000..f972a411e900 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh/debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_backward_cpu_tanh(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.797884583 : f32 + %cst_0 = arith.constant 4.471500e-02 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %cst_3 = arith.constant 0.134144992 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %5 = arith.mulf %in_4, %cst_0 : f32 + %6 = arith.mulf %in_4, %in_4 : f32 + %7 = arith.mulf %5, %6 : f32 + %8 = arith.addf %in_4, %7 : f32 + %9 = arith.mulf %8, %cst : f32 + %10 = math.tanh %9 : f32 + %11 = arith.addf %10, %cst_2 : f32 + %12 = arith.mulf %11, %cst_1 : f32 + %13 = arith.mulf %in_4, %cst_1 : f32 + %14 = arith.mulf %10, %10 : f32 + %15 = arith.subf %cst_2, %14 : f32 + %16 = arith.mulf %13, %15 : f32 + %17 = arith.mulf %16, %cst : f32 + %18 = arith.mulf %6, %cst_3 : f32 + %19 = arith.addf %18, %cst_2 : f32 + %20 = arith.mulf %17, %19 : f32 + %21 = arith.addf %12, %20 : f32 + %22 = arith.mulf %in, %21 : f32 + linalg.yield %22 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh/matched.mlir b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh/matched.mlir new file mode 100644 index 000000000000..f972a411e900 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh/matched.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_backward_cpu_tanh(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.797884583 : f32 + %cst_0 = arith.constant 4.471500e-02 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %cst_3 = arith.constant 0.134144992 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %5 = arith.mulf %in_4, %cst_0 : f32 + %6 = arith.mulf %in_4, %in_4 : f32 + %7 = arith.mulf %5, %6 : f32 + %8 = arith.addf %in_4, %7 : f32 + %9 = arith.mulf %8, %cst : f32 + %10 = math.tanh %9 : f32 + %11 = arith.addf %10, %cst_2 : f32 + %12 = arith.mulf %11, %cst_1 : f32 + %13 = arith.mulf %in_4, %cst_1 : f32 + %14 = arith.mulf %10, %10 : f32 + %15 = arith.subf %cst_2, %14 : f32 + %16 = arith.mulf %13, %15 : f32 + %17 = arith.mulf %16, %cst : f32 + %18 = arith.mulf %6, %cst_3 : f32 + %19 = arith.addf %18, %cst_2 : f32 + %20 = arith.mulf %17, %19 : f32 + %21 = arith.addf %12, %20 : f32 + %22 = arith.mulf %in, %21 : f32 + linalg.yield %22 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh/orig.mlir b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh/orig.mlir new file mode 100644 index 000000000000..9932a9cea12d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh/orig.mlir @@ -0,0 +1,33 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_backward_cpu_tanh(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.134144992 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 4.471500e-02 : f32 + %cst_3 = arith.constant 0.797884583 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.mulf %1, %cst_2 : f32 + %3 = arith.mulf %1, %1 : f32 + %4 = arith.mulf %2, %3 : f32 + %5 = arith.addf %1, %4 : f32 + %6 = arith.mulf %5, %cst_3 : f32 + %7 = math.tanh %6 : f32 + %8 = arith.addf %7, %cst_0 : f32 + %9 = arith.mulf %8, %cst_1 : f32 + %10 = arith.mulf %1, %cst_1 : f32 + %11 = arith.mulf %7, %7 : f32 + %12 = arith.subf %cst_0, %11 : f32 + %13 = arith.mulf %10, %12 : f32 + %14 = arith.mulf %13, %cst_3 : f32 + %15 = arith.mulf %3, %cst : f32 + %16 = arith.addf %15, %cst_0 : f32 + %17 = arith.mulf %14, %16 : f32 + %18 = arith.addf %9, %17 : f32 + %19 = arith.mulf %0, %18 : f32 + affine.store %19, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh/raised.mlir b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh/raised.mlir new file mode 100644 index 000000000000..254da0abb218 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh/raised.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_backward_cpu_tanh(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.134144992 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 4.471500e-02 : f32 + %cst_3 = arith.constant 0.797884583 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %0 = arith.mulf %in_4, %cst_2 : f32 + %1 = arith.mulf %in_4, %in_4 : f32 + %2 = arith.mulf %0, %1 : f32 + %3 = arith.addf %in_4, %2 : f32 + %4 = arith.mulf %3, %cst_3 : f32 + %5 = math.tanh %4 : f32 + %6 = arith.addf %5, %cst_0 : f32 + %7 = arith.mulf %6, %cst_1 : f32 + %8 = arith.mulf %in_4, %cst_1 : f32 + %9 = arith.mulf %5, %5 : f32 + %10 = arith.subf %cst_0, %9 : f32 + %11 = arith.mulf %8, %10 : f32 + %12 = arith.mulf %11, %cst_3 : f32 + %13 = arith.mulf %1, %cst : f32 + %14 = arith.addf %13, %cst_0 : f32 + %15 = arith.mulf %12, %14 : f32 + %16 = arith.addf %7, %15 : f32 + %17 = arith.mulf %in, %16 : f32 + linalg.yield %17 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh_debuf.mlir b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh_debuf.mlir new file mode 100644 index 000000000000..f972a411e900 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh_debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_backward_cpu_tanh(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.797884583 : f32 + %cst_0 = arith.constant 4.471500e-02 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %cst_3 = arith.constant 0.134144992 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %5 = arith.mulf %in_4, %cst_0 : f32 + %6 = arith.mulf %in_4, %in_4 : f32 + %7 = arith.mulf %5, %6 : f32 + %8 = arith.addf %in_4, %7 : f32 + %9 = arith.mulf %8, %cst : f32 + %10 = math.tanh %9 : f32 + %11 = arith.addf %10, %cst_2 : f32 + %12 = arith.mulf %11, %cst_1 : f32 + %13 = arith.mulf %in_4, %cst_1 : f32 + %14 = arith.mulf %10, %10 : f32 + %15 = arith.subf %cst_2, %14 : f32 + %16 = arith.mulf %13, %15 : f32 + %17 = arith.mulf %16, %cst : f32 + %18 = arith.mulf %6, %cst_3 : f32 + %19 = arith.addf %18, %cst_2 : f32 + %20 = arith.mulf %17, %19 : f32 + %21 = arith.addf %12, %20 : f32 + %22 = arith.mulf %in, %21 : f32 + linalg.yield %22 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh_linalg.mlir b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh_linalg.mlir new file mode 100644 index 000000000000..254da0abb218 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_backward_cpu_tanh_linalg.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_backward_cpu_tanh(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.134144992 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 4.471500e-02 : f32 + %cst_3 = arith.constant 0.797884583 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %0 = arith.mulf %in_4, %cst_2 : f32 + %1 = arith.mulf %in_4, %in_4 : f32 + %2 = arith.mulf %0, %1 : f32 + %3 = arith.addf %in_4, %2 : f32 + %4 = arith.mulf %3, %cst_3 : f32 + %5 = math.tanh %4 : f32 + %6 = arith.addf %5, %cst_0 : f32 + %7 = arith.mulf %6, %cst_1 : f32 + %8 = arith.mulf %in_4, %cst_1 : f32 + %9 = arith.mulf %5, %5 : f32 + %10 = arith.subf %cst_0, %9 : f32 + %11 = arith.mulf %8, %10 : f32 + %12 = arith.mulf %11, %cst_3 : f32 + %13 = arith.mulf %1, %cst : f32 + %14 = arith.addf %13, %cst_0 : f32 + %15 = arith.mulf %12, %14 : f32 + %16 = arith.addf %7, %15 : f32 + %17 = arith.mulf %in, %16 : f32 + linalg.yield %17 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_cpu_exact.mlir b/issues/aten_c_kernels/results/aten_gelu_cpu_exact.mlir new file mode 100644 index 000000000000..f1966aefe491 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_cpu_exact.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_cpu_exact(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.707106769 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.mulf %0, %cst_1 : f32 + %2 = arith.mulf %0, %cst : f32 + %3 = func.call @erff(%2) : (f32) -> f32 + %4 = arith.addf %3, %cst_0 : f32 + %5 = arith.mulf %1, %4 : f32 + affine.store %5, %arg1[%arg2] : memref + } + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_gelu_cpu_exact/debuf.mlir b/issues/aten_c_kernels/results/aten_gelu_cpu_exact/debuf.mlir new file mode 100644 index 000000000000..a342334f420d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_cpu_exact/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_cpu_exact(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.707106769 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %cst : f32 + %5 = arith.mulf %in, %cst_1 : f32 + %6 = math.erf %5 : f32 + %7 = arith.addf %6, %cst_0 : f32 + %8 = arith.mulf %4, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_cpu_exact/matched.mlir b/issues/aten_c_kernels/results/aten_gelu_cpu_exact/matched.mlir new file mode 100644 index 000000000000..a342334f420d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_cpu_exact/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_cpu_exact(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.707106769 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %cst : f32 + %5 = arith.mulf %in, %cst_1 : f32 + %6 = math.erf %5 : f32 + %7 = arith.addf %6, %cst_0 : f32 + %8 = arith.mulf %4, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_cpu_exact/orig.mlir b/issues/aten_c_kernels/results/aten_gelu_cpu_exact/orig.mlir new file mode 100644 index 000000000000..f1966aefe491 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_cpu_exact/orig.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_cpu_exact(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.707106769 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.mulf %0, %cst_1 : f32 + %2 = arith.mulf %0, %cst : f32 + %3 = func.call @erff(%2) : (f32) -> f32 + %4 = arith.addf %3, %cst_0 : f32 + %5 = arith.mulf %1, %4 : f32 + affine.store %5, %arg1[%arg2] : memref + } + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_gelu_cpu_exact/raised.mlir b/issues/aten_c_kernels/results/aten_gelu_cpu_exact/raised.mlir new file mode 100644 index 000000000000..3e0484282980 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_cpu_exact/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_cpu_exact(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.707106769 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %cst_1 : f32 + %1 = arith.mulf %in, %cst : f32 + %2 = math.erf %1 : f32 + %3 = arith.addf %2, %cst_0 : f32 + %4 = arith.mulf %0, %3 : f32 + linalg.yield %4 : f32 + } + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_cpu_exact_debuf.mlir b/issues/aten_c_kernels/results/aten_gelu_cpu_exact_debuf.mlir new file mode 100644 index 000000000000..a342334f420d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_cpu_exact_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_cpu_exact(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.707106769 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %cst : f32 + %5 = arith.mulf %in, %cst_1 : f32 + %6 = math.erf %5 : f32 + %7 = arith.addf %6, %cst_0 : f32 + %8 = arith.mulf %4, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_cpu_exact_linalg.mlir b/issues/aten_c_kernels/results/aten_gelu_cpu_exact_linalg.mlir new file mode 100644 index 000000000000..3e0484282980 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_cpu_exact_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_cpu_exact(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.707106769 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %cst_1 : f32 + %1 = arith.mulf %in, %cst : f32 + %2 = math.erf %1 : f32 + %3 = arith.addf %2, %cst_0 : f32 + %4 = arith.mulf %0, %3 : f32 + linalg.yield %4 : f32 + } + return + } + func.func private @erff(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_cpu_tanh.mlir b/issues/aten_c_kernels/results/aten_gelu_cpu_tanh.mlir new file mode 100644 index 000000000000..bf17f77a8c80 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_cpu_tanh.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_cpu_tanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.471500e-02 : f32 + %cst_2 = arith.constant 0.797884583 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.mulf %0, %cst_0 : f32 + %2 = arith.mulf %0, %cst_1 : f32 + %3 = arith.mulf %2, %0 : f32 + %4 = arith.mulf %3, %0 : f32 + %5 = arith.addf %0, %4 : f32 + %6 = arith.mulf %5, %cst_2 : f32 + %7 = math.tanh %6 : f32 + %8 = arith.addf %7, %cst : f32 + %9 = arith.mulf %1, %8 : f32 + affine.store %9, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gelu_cpu_tanh/debuf.mlir b/issues/aten_c_kernels/results/aten_gelu_cpu_tanh/debuf.mlir new file mode 100644 index 000000000000..d35e82d7e5f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_cpu_tanh/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_cpu_tanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.797884583 : f32 + %cst_0 = arith.constant 4.471500e-02 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %cst_1 : f32 + %5 = arith.mulf %in, %cst_0 : f32 + %6 = arith.mulf %5, %in : f32 + %7 = arith.mulf %6, %in : f32 + %8 = arith.addf %in, %7 : f32 + %9 = arith.mulf %8, %cst : f32 + %10 = math.tanh %9 : f32 + %11 = arith.addf %10, %cst_2 : f32 + %12 = arith.mulf %4, %11 : f32 + linalg.yield %12 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_cpu_tanh/matched.mlir b/issues/aten_c_kernels/results/aten_gelu_cpu_tanh/matched.mlir new file mode 100644 index 000000000000..d5ed44dfeb45 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_cpu_tanh/matched.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_cpu_tanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.797884583 : f32 + %cst_0 = arith.constant 4.471500e-02 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = kernel.launch @gelu_tanh_f32_tensor(%0, %1) : (tensor, tensor) -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_cpu_tanh/orig.mlir b/issues/aten_c_kernels/results/aten_gelu_cpu_tanh/orig.mlir new file mode 100644 index 000000000000..bf17f77a8c80 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_cpu_tanh/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_cpu_tanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.471500e-02 : f32 + %cst_2 = arith.constant 0.797884583 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.mulf %0, %cst_0 : f32 + %2 = arith.mulf %0, %cst_1 : f32 + %3 = arith.mulf %2, %0 : f32 + %4 = arith.mulf %3, %0 : f32 + %5 = arith.addf %0, %4 : f32 + %6 = arith.mulf %5, %cst_2 : f32 + %7 = math.tanh %6 : f32 + %8 = arith.addf %7, %cst : f32 + %9 = arith.mulf %1, %8 : f32 + affine.store %9, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gelu_cpu_tanh/raised.mlir b/issues/aten_c_kernels/results/aten_gelu_cpu_tanh/raised.mlir new file mode 100644 index 000000000000..c90988212412 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_cpu_tanh/raised.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_cpu_tanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.471500e-02 : f32 + %cst_2 = arith.constant 0.797884583 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %cst_0 : f32 + %1 = arith.mulf %in, %cst_1 : f32 + %2 = arith.mulf %1, %in : f32 + %3 = arith.mulf %2, %in : f32 + %4 = arith.addf %in, %3 : f32 + %5 = arith.mulf %4, %cst_2 : f32 + %6 = math.tanh %5 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.mulf %0, %7 : f32 + linalg.yield %8 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_cpu_tanh_debuf.mlir b/issues/aten_c_kernels/results/aten_gelu_cpu_tanh_debuf.mlir new file mode 100644 index 000000000000..d35e82d7e5f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_cpu_tanh_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_cpu_tanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.797884583 : f32 + %cst_0 = arith.constant 4.471500e-02 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %cst_1 : f32 + %5 = arith.mulf %in, %cst_0 : f32 + %6 = arith.mulf %5, %in : f32 + %7 = arith.mulf %6, %in : f32 + %8 = arith.addf %in, %7 : f32 + %9 = arith.mulf %8, %cst : f32 + %10 = math.tanh %9 : f32 + %11 = arith.addf %10, %cst_2 : f32 + %12 = arith.mulf %4, %11 : f32 + linalg.yield %12 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_cpu_tanh_linalg.mlir b/issues/aten_c_kernels/results/aten_gelu_cpu_tanh_linalg.mlir new file mode 100644 index 000000000000..c90988212412 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_cpu_tanh_linalg.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu_cpu_tanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.471500e-02 : f32 + %cst_2 = arith.constant 0.797884583 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %cst_0 : f32 + %1 = arith.mulf %in, %cst_1 : f32 + %2 = arith.mulf %1, %in : f32 + %3 = arith.mulf %2, %in : f32 + %4 = arith.addf %in, %3 : f32 + %5 = arith.mulf %4, %cst_2 : f32 + %6 = math.tanh %5 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.mulf %0, %7 : f32 + linalg.yield %8 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_debuf.mlir b/issues/aten_c_kernels/results/aten_gelu_debuf.mlir new file mode 100644 index 000000000000..d6dd0f0609c3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.797884583 : f32 + %cst_0 = arith.constant 4.471500e-02 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %cst_1 : f32 + %5 = arith.mulf %in, %cst_0 : f32 + %6 = arith.mulf %5, %in : f32 + %7 = arith.mulf %6, %in : f32 + %8 = arith.addf %in, %7 : f32 + %9 = arith.mulf %8, %cst : f32 + %10 = math.tanh %9 : f32 + %11 = arith.addf %10, %cst_2 : f32 + %12 = arith.mulf %4, %11 : f32 + linalg.yield %12 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gelu_linalg.mlir b/issues/aten_c_kernels/results/aten_gelu_linalg.mlir new file mode 100644 index 000000000000..fc2f17e7a155 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gelu_linalg.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gelu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.471500e-02 : f32 + %cst_2 = arith.constant 0.797884583 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %cst_0 : f32 + %1 = arith.mulf %in, %cst_1 : f32 + %2 = arith.mulf %1, %in : f32 + %3 = arith.mulf %2, %in : f32 + %4 = arith.addf %in, %3 : f32 + %5 = arith.mulf %4, %cst_2 : f32 + %6 = math.tanh %5 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.mulf %0, %7 : f32 + linalg.yield %8 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_notrans_cpu.mlir b/issues/aten_c_kernels/results/aten_gemm_notrans_cpu.mlir new file mode 100644 index 000000000000..400474d3b2fc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_notrans_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_notrans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 48 { + affine.for %arg5 = 0 to 40 { + %0 = affine.load %arg0[%arg3, %arg5] : memref + %1 = affine.load %arg1[%arg5, %arg4] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg2[%arg3, %arg4] : memref + %4 = arith.addf %3, %2 : f32 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gemm_notrans_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_gemm_notrans_cpu/debuf.mlir new file mode 100644 index 000000000000..1f39af6d45ad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_notrans_cpu/debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_notrans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c40 = arith.constant 40 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c40] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c40, %c48] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %in, %in_2 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_notrans_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_gemm_notrans_cpu/matched.mlir new file mode 100644 index 000000000000..1f39af6d45ad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_notrans_cpu/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_notrans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c40 = arith.constant 40 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c40] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c40, %c48] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %in, %in_2 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_notrans_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_gemm_notrans_cpu/orig.mlir new file mode 100644 index 000000000000..400474d3b2fc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_notrans_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_notrans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 48 { + affine.for %arg5 = 0 to 40 { + %0 = affine.load %arg0[%arg3, %arg5] : memref + %1 = affine.load %arg1[%arg5, %arg4] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg2[%arg3, %arg4] : memref + %4 = arith.addf %3, %2 : f32 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gemm_notrans_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_gemm_notrans_cpu/raised.mlir new file mode 100644 index 000000000000..999f99e8c1ad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_notrans_cpu/raised.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_notrans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c48 = arith.constant 48 : index + %c40 = arith.constant 40 : index + %subview = memref.subview %arg0[0, 0] [%c32, %c40] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c40, %c48] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0] [%c32, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_notrans_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_gemm_notrans_cpu_debuf.mlir new file mode 100644 index 000000000000..1f39af6d45ad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_notrans_cpu_debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_notrans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c40 = arith.constant 40 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c40] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c40, %c48] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %in, %in_2 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_notrans_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_gemm_notrans_cpu_linalg.mlir new file mode 100644 index 000000000000..999f99e8c1ad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_notrans_cpu_linalg.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_notrans_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c48 = arith.constant 48 : index + %c40 = arith.constant 40 : index + %subview = memref.subview %arg0[0, 0] [%c32, %c40] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c40, %c48] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0] [%c32, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_transa_cpu.mlir b/issues/aten_c_kernels/results/aten_gemm_transa_cpu.mlir new file mode 100644 index 000000000000..da3749afd478 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transa_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transa_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 48 { + affine.for %arg5 = 0 to 40 { + %0 = affine.load %arg0[%arg5, %arg3] : memref + %1 = affine.load %arg1[%arg5, %arg4] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg2[%arg3, %arg4] : memref + %4 = arith.addf %3, %2 : f32 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gemm_transa_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_gemm_transa_cpu/debuf.mlir new file mode 100644 index 000000000000..dbb6ef9b4be8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transa_cpu/debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2) -> (d2, d0)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transa_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c40 = arith.constant 40 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c40, %c32] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c40, %c48] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %in, %in_2 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_transa_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_gemm_transa_cpu/matched.mlir new file mode 100644 index 000000000000..dbb6ef9b4be8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transa_cpu/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2) -> (d2, d0)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transa_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c40 = arith.constant 40 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c40, %c32] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c40, %c48] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %in, %in_2 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_transa_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_gemm_transa_cpu/orig.mlir new file mode 100644 index 000000000000..da3749afd478 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transa_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transa_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 48 { + affine.for %arg5 = 0 to 40 { + %0 = affine.load %arg0[%arg5, %arg3] : memref + %1 = affine.load %arg1[%arg5, %arg4] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg2[%arg3, %arg4] : memref + %4 = arith.addf %3, %2 : f32 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gemm_transa_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_gemm_transa_cpu/raised.mlir new file mode 100644 index 000000000000..6ea00408f920 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transa_cpu/raised.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1, d2) -> (d2, d0)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transa_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c48 = arith.constant 48 : index + %c40 = arith.constant 40 : index + %subview = memref.subview %arg0[0, 0] [%c40, %c32] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c40, %c48] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0] [%c32, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_transa_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_gemm_transa_cpu_debuf.mlir new file mode 100644 index 000000000000..dbb6ef9b4be8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transa_cpu_debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2) -> (d2, d0)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transa_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c40 = arith.constant 40 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c40, %c32] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c40, %c48] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %in, %in_2 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_transa_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_gemm_transa_cpu_linalg.mlir new file mode 100644 index 000000000000..6ea00408f920 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transa_cpu_linalg.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1, d2) -> (d2, d0)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transa_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c48 = arith.constant 48 : index + %c40 = arith.constant 40 : index + %subview = memref.subview %arg0[0, 0] [%c40, %c32] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c40, %c48] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0] [%c32, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_transab_cpu.mlir b/issues/aten_c_kernels/results/aten_gemm_transab_cpu.mlir new file mode 100644 index 000000000000..d4fa7f7bfcc3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transab_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transab_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 48 { + affine.for %arg5 = 0 to 40 { + %0 = affine.load %arg0[%arg5, %arg3] : memref + %1 = affine.load %arg1[%arg4, %arg5] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg2[%arg3, %arg4] : memref + %4 = arith.addf %3, %2 : f32 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gemm_transab_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_gemm_transab_cpu/debuf.mlir new file mode 100644 index 000000000000..29eab581a563 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transab_cpu/debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2) -> (d2, d0)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transab_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c40 = arith.constant 40 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c40, %c32] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c48, %c40] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %in, %in_2 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_transab_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_gemm_transab_cpu/matched.mlir new file mode 100644 index 000000000000..29eab581a563 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transab_cpu/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2) -> (d2, d0)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transab_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c40 = arith.constant 40 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c40, %c32] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c48, %c40] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %in, %in_2 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_transab_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_gemm_transab_cpu/orig.mlir new file mode 100644 index 000000000000..d4fa7f7bfcc3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transab_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transab_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 48 { + affine.for %arg5 = 0 to 40 { + %0 = affine.load %arg0[%arg5, %arg3] : memref + %1 = affine.load %arg1[%arg4, %arg5] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg2[%arg3, %arg4] : memref + %4 = arith.addf %3, %2 : f32 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gemm_transab_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_gemm_transab_cpu/raised.mlir new file mode 100644 index 000000000000..e87a11f029f7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transab_cpu/raised.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1, d2) -> (d2, d0)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transab_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c48 = arith.constant 48 : index + %c40 = arith.constant 40 : index + %subview = memref.subview %arg0[0, 0] [%c40, %c32] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c48, %c40] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0] [%c32, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_transab_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_gemm_transab_cpu_debuf.mlir new file mode 100644 index 000000000000..29eab581a563 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transab_cpu_debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2) -> (d2, d0)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transab_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c40 = arith.constant 40 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c40, %c32] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c48, %c40] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %in, %in_2 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_transab_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_gemm_transab_cpu_linalg.mlir new file mode 100644 index 000000000000..e87a11f029f7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transab_cpu_linalg.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1, d2) -> (d2, d0)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transab_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c48 = arith.constant 48 : index + %c40 = arith.constant 40 : index + %subview = memref.subview %arg0[0, 0] [%c40, %c32] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c48, %c40] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0] [%c32, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_transb_cpu.mlir b/issues/aten_c_kernels/results/aten_gemm_transb_cpu.mlir new file mode 100644 index 000000000000..132387f07a9e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transb_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transb_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 48 { + affine.for %arg5 = 0 to 40 { + %0 = affine.load %arg0[%arg3, %arg5] : memref + %1 = affine.load %arg1[%arg4, %arg5] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg2[%arg3, %arg4] : memref + %4 = arith.addf %3, %2 : f32 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gemm_transb_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_gemm_transb_cpu/debuf.mlir new file mode 100644 index 000000000000..8968a5c1de17 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transb_cpu/debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transb_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c40 = arith.constant 40 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c40] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c48, %c40] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %in, %in_2 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_transb_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_gemm_transb_cpu/matched.mlir new file mode 100644 index 000000000000..8968a5c1de17 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transb_cpu/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transb_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c40 = arith.constant 40 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c40] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c48, %c40] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %in, %in_2 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_transb_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_gemm_transb_cpu/orig.mlir new file mode 100644 index 000000000000..132387f07a9e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transb_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transb_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 48 { + affine.for %arg5 = 0 to 40 { + %0 = affine.load %arg0[%arg3, %arg5] : memref + %1 = affine.load %arg1[%arg4, %arg5] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = affine.load %arg2[%arg3, %arg4] : memref + %4 = arith.addf %3, %2 : f32 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gemm_transb_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_gemm_transb_cpu/raised.mlir new file mode 100644 index 000000000000..531250dd5d44 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transb_cpu/raised.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transb_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c48 = arith.constant 48 : index + %c40 = arith.constant 40 : index + %subview = memref.subview %arg0[0, 0] [%c32, %c40] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c48, %c40] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0] [%c32, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_transb_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_gemm_transb_cpu_debuf.mlir new file mode 100644 index 000000000000..8968a5c1de17 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transb_cpu_debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transb_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c40 = arith.constant 40 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c40] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c48, %c40] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %in, %in_2 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gemm_transb_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_gemm_transb_cpu_linalg.mlir new file mode 100644 index 000000000000..531250dd5d44 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gemm_transb_cpu_linalg.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gemm_transb_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c48 = arith.constant 48 : index + %c40 = arith.constant 40 : index + %subview = memref.subview %arg0[0, 0] [%c32, %c40] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c48, %c40] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0] [%c32, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %0 = arith.mulf %in, %in_2 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_geometric_cpu.mlir b/issues/aten_c_kernels/results/aten_geometric_cpu.mlir new file mode 100644 index 000000000000..96c68b453286 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_geometric_cpu.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_geometric_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = arith.subf %cst, %arg1 : f32 + %1 = call @logf(%0) : (f32) -> f32 + affine.for %arg3 = 0 to 4096 { + %2 = affine.load %arg0[%arg3] : memref + %3 = arith.subf %cst, %2 : f32 + %4 = func.call @logf(%3) : (f32) -> f32 + %5 = arith.divf %4, %1 : f32 + %6 = func.call @ceilf(%5) : (f32) -> f32 + affine.store %6, %arg2[%arg3] : memref + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} + func.func private @ceilf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_geometric_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_geometric_cpu/debuf.mlir new file mode 100644 index 000000000000..ca730ba2806d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_geometric_cpu/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_geometric_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.subf %cst, %arg1 : f32 + %3 = math.log %2 : f32 + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.subf %cst, %in : f32 + %7 = math.log %6 : f32 + %8 = arith.divf %7, %3 : f32 + %9 = math.ceil %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} + func.func private @ceilf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_geometric_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_geometric_cpu/matched.mlir new file mode 100644 index 000000000000..ca730ba2806d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_geometric_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_geometric_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.subf %cst, %arg1 : f32 + %3 = math.log %2 : f32 + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.subf %cst, %in : f32 + %7 = math.log %6 : f32 + %8 = arith.divf %7, %3 : f32 + %9 = math.ceil %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} + func.func private @ceilf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_geometric_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_geometric_cpu/orig.mlir new file mode 100644 index 000000000000..96c68b453286 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_geometric_cpu/orig.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_geometric_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = arith.subf %cst, %arg1 : f32 + %1 = call @logf(%0) : (f32) -> f32 + affine.for %arg3 = 0 to 4096 { + %2 = affine.load %arg0[%arg3] : memref + %3 = arith.subf %cst, %2 : f32 + %4 = func.call @logf(%3) : (f32) -> f32 + %5 = arith.divf %4, %1 : f32 + %6 = func.call @ceilf(%5) : (f32) -> f32 + affine.store %6, %arg2[%arg3] : memref + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} + func.func private @ceilf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_geometric_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_geometric_cpu/raised.mlir new file mode 100644 index 000000000000..8c178432fa67 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_geometric_cpu/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_geometric_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = arith.subf %cst, %arg1 : f32 + %1 = math.log %0 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.subf %cst, %in : f32 + %3 = math.log %2 : f32 + %4 = arith.divf %3, %1 : f32 + %5 = math.ceil %4 : f32 + linalg.yield %5 : f32 + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} + func.func private @ceilf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_geometric_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_geometric_cpu_debuf.mlir new file mode 100644 index 000000000000..ca730ba2806d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_geometric_cpu_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_geometric_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.subf %cst, %arg1 : f32 + %3 = math.log %2 : f32 + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.subf %cst, %in : f32 + %7 = math.log %6 : f32 + %8 = arith.divf %7, %3 : f32 + %9 = math.ceil %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} + func.func private @ceilf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_geometric_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_geometric_cpu_linalg.mlir new file mode 100644 index 000000000000..8c178432fa67 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_geometric_cpu_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_geometric_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = arith.subf %cst, %arg1 : f32 + %1 = math.log %0 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.subf %cst, %in : f32 + %3 = math.log %2 : f32 + %4 = arith.divf %3, %1 : f32 + %5 = math.ceil %4 : f32 + linalg.yield %5 : f32 + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} + func.func private @ceilf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_glu.mlir b/issues/aten_c_kernels/results/aten_glu.mlir new file mode 100644 index 000000000000..55e7c9b557e6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.negf %1 : f32 + %3 = math.exp %2 : f32 + %4 = arith.addf %3, %cst : f32 + %5 = arith.divf %0, %4 : f32 + affine.store %5, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_glu/debuf.mlir b/issues/aten_c_kernels/results/aten_glu/debuf.mlir new file mode 100644 index 000000000000..615b94cd400a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu/debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.negf %in_0 : f32 + %6 = math.exp %5 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.divf %in, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_glu/matched.mlir b/issues/aten_c_kernels/results/aten_glu/matched.mlir new file mode 100644 index 000000000000..615b94cd400a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.negf %in_0 : f32 + %6 = math.exp %5 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.divf %in, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_glu/orig.mlir b/issues/aten_c_kernels/results/aten_glu/orig.mlir new file mode 100644 index 000000000000..55e7c9b557e6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu/orig.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.negf %1 : f32 + %3 = math.exp %2 : f32 + %4 = arith.addf %3, %cst : f32 + %5 = arith.divf %0, %4 : f32 + affine.store %5, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_glu/raised.mlir b/issues/aten_c_kernels/results/aten_glu/raised.mlir new file mode 100644 index 000000000000..c8aabc91f485 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.negf %in_0 : f32 + %1 = math.exp %0 : f32 + %2 = arith.addf %1, %cst : f32 + %3 = arith.divf %in, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_glu_backward.mlir b/issues/aten_c_kernels/results/aten_glu_backward.mlir new file mode 100644 index 000000000000..cba109b01d2c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu_backward.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu_backward(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.subf %cst, %0 : f32 + %2 = arith.mulf %1, %0 : f32 + %3 = affine.load %arg1[%arg4] : memref + %4 = arith.mulf %2, %3 : f32 + %5 = affine.load %arg2[%arg4] : memref + %6 = arith.mulf %4, %5 : f32 + affine.store %6, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_glu_backward/debuf.mlir b/issues/aten_c_kernels/results/aten_glu_backward/debuf.mlir new file mode 100644 index 000000000000..8ec883897a73 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu_backward/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu_backward(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.subf %cst, %in : f32 + %7 = arith.mulf %6, %in : f32 + %8 = arith.mulf %7, %in_0 : f32 + %9 = arith.mulf %8, %in_1 : f32 + linalg.yield %9 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_glu_backward/matched.mlir b/issues/aten_c_kernels/results/aten_glu_backward/matched.mlir new file mode 100644 index 000000000000..8ec883897a73 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu_backward/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu_backward(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.subf %cst, %in : f32 + %7 = arith.mulf %6, %in : f32 + %8 = arith.mulf %7, %in_0 : f32 + %9 = arith.mulf %8, %in_1 : f32 + linalg.yield %9 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_glu_backward/orig.mlir b/issues/aten_c_kernels/results/aten_glu_backward/orig.mlir new file mode 100644 index 000000000000..cba109b01d2c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu_backward/orig.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu_backward(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.subf %cst, %0 : f32 + %2 = arith.mulf %1, %0 : f32 + %3 = affine.load %arg1[%arg4] : memref + %4 = arith.mulf %2, %3 : f32 + %5 = affine.load %arg2[%arg4] : memref + %6 = arith.mulf %4, %5 : f32 + affine.store %6, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_glu_backward/raised.mlir b/issues/aten_c_kernels/results/aten_glu_backward/raised.mlir new file mode 100644 index 000000000000..7203e53c3c6b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu_backward/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu_backward(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg2 : memref, memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.subf %cst, %in : f32 + %1 = arith.mulf %0, %in : f32 + %2 = arith.mulf %1, %in_0 : f32 + %3 = arith.mulf %2, %in_1 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_glu_backward_debuf.mlir b/issues/aten_c_kernels/results/aten_glu_backward_debuf.mlir new file mode 100644 index 000000000000..8ec883897a73 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu_backward_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu_backward(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.subf %cst, %in : f32 + %7 = arith.mulf %6, %in : f32 + %8 = arith.mulf %7, %in_0 : f32 + %9 = arith.mulf %8, %in_1 : f32 + linalg.yield %9 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_glu_backward_linalg.mlir b/issues/aten_c_kernels/results/aten_glu_backward_linalg.mlir new file mode 100644 index 000000000000..7203e53c3c6b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu_backward_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu_backward(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg2 : memref, memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.subf %cst, %in : f32 + %1 = arith.mulf %0, %in : f32 + %2 = arith.mulf %1, %in_0 : f32 + %3 = arith.mulf %2, %in_1 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_glu_debuf.mlir b/issues/aten_c_kernels/results/aten_glu_debuf.mlir new file mode 100644 index 000000000000..615b94cd400a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu_debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.negf %in_0 : f32 + %6 = math.exp %5 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.divf %in, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_glu_jvp.mlir b/issues/aten_c_kernels/results/aten_glu_jvp.mlir new file mode 100644 index 000000000000..7a104187af93 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu_jvp.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu_jvp(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg5 = 0 to 4096 { + %0 = affine.load %arg2[%arg5] : memref + %1 = affine.load %arg1[%arg5] : memref + %2 = arith.negf %1 : f32 + %3 = math.exp %2 : f32 + %4 = arith.addf %3, %cst : f32 + %5 = arith.divf %cst, %4 : f32 + %6 = arith.mulf %0, %5 : f32 + %7 = affine.load %arg0[%arg5] : memref + %8 = affine.load %arg3[%arg5] : memref + %9 = arith.mulf %5, %8 : f32 + %10 = arith.subf %8, %9 : f32 + %11 = arith.mulf %7, %10 : f32 + %12 = arith.addf %6, %11 : f32 + affine.store %12, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_glu_jvp/debuf.mlir b/issues/aten_c_kernels/results/aten_glu_jvp/debuf.mlir new file mode 100644 index 000000000000..fc896a170c0f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu_jvp/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu_jvp(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%2, %1, %0, %3 : tensor, tensor, tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %in_2: f32, %out: f32): + %7 = arith.negf %in_0 : f32 + %8 = math.exp %7 : f32 + %9 = arith.addf %8, %cst : f32 + %10 = arith.divf %cst, %9 : f32 + %11 = arith.mulf %in, %10 : f32 + %12 = arith.mulf %10, %in_2 : f32 + %13 = arith.subf %in_2, %12 : f32 + %14 = arith.mulf %in_1, %13 : f32 + %15 = arith.addf %11, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_glu_jvp/matched.mlir b/issues/aten_c_kernels/results/aten_glu_jvp/matched.mlir new file mode 100644 index 000000000000..fc896a170c0f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu_jvp/matched.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu_jvp(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%2, %1, %0, %3 : tensor, tensor, tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %in_2: f32, %out: f32): + %7 = arith.negf %in_0 : f32 + %8 = math.exp %7 : f32 + %9 = arith.addf %8, %cst : f32 + %10 = arith.divf %cst, %9 : f32 + %11 = arith.mulf %in, %10 : f32 + %12 = arith.mulf %10, %in_2 : f32 + %13 = arith.subf %in_2, %12 : f32 + %14 = arith.mulf %in_1, %13 : f32 + %15 = arith.addf %11, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_glu_jvp/orig.mlir b/issues/aten_c_kernels/results/aten_glu_jvp/orig.mlir new file mode 100644 index 000000000000..7a104187af93 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu_jvp/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu_jvp(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg5 = 0 to 4096 { + %0 = affine.load %arg2[%arg5] : memref + %1 = affine.load %arg1[%arg5] : memref + %2 = arith.negf %1 : f32 + %3 = math.exp %2 : f32 + %4 = arith.addf %3, %cst : f32 + %5 = arith.divf %cst, %4 : f32 + %6 = arith.mulf %0, %5 : f32 + %7 = affine.load %arg0[%arg5] : memref + %8 = affine.load %arg3[%arg5] : memref + %9 = arith.mulf %5, %8 : f32 + %10 = arith.subf %8, %9 : f32 + %11 = arith.mulf %7, %10 : f32 + %12 = arith.addf %6, %11 : f32 + affine.store %12, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_glu_jvp/raised.mlir b/issues/aten_c_kernels/results/aten_glu_jvp/raised.mlir new file mode 100644 index 000000000000..fc1f64e15cc5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu_jvp/raised.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu_jvp(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg2, %arg1, %arg0, %arg3 : memref, memref, memref, memref) outs(%arg4 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %in_2: f32, %out: f32): + %0 = arith.negf %in_0 : f32 + %1 = math.exp %0 : f32 + %2 = arith.addf %1, %cst : f32 + %3 = arith.divf %cst, %2 : f32 + %4 = arith.mulf %in, %3 : f32 + %5 = arith.mulf %3, %in_2 : f32 + %6 = arith.subf %in_2, %5 : f32 + %7 = arith.mulf %in_1, %6 : f32 + %8 = arith.addf %4, %7 : f32 + linalg.yield %8 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_glu_jvp_debuf.mlir b/issues/aten_c_kernels/results/aten_glu_jvp_debuf.mlir new file mode 100644 index 000000000000..fc896a170c0f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu_jvp_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu_jvp(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%2, %1, %0, %3 : tensor, tensor, tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %in_2: f32, %out: f32): + %7 = arith.negf %in_0 : f32 + %8 = math.exp %7 : f32 + %9 = arith.addf %8, %cst : f32 + %10 = arith.divf %cst, %9 : f32 + %11 = arith.mulf %in, %10 : f32 + %12 = arith.mulf %10, %in_2 : f32 + %13 = arith.subf %in_2, %12 : f32 + %14 = arith.mulf %in_1, %13 : f32 + %15 = arith.addf %11, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_glu_jvp_linalg.mlir b/issues/aten_c_kernels/results/aten_glu_jvp_linalg.mlir new file mode 100644 index 000000000000..fc1f64e15cc5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu_jvp_linalg.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu_jvp(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg2, %arg1, %arg0, %arg3 : memref, memref, memref, memref) outs(%arg4 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %in_2: f32, %out: f32): + %0 = arith.negf %in_0 : f32 + %1 = math.exp %0 : f32 + %2 = arith.addf %1, %cst : f32 + %3 = arith.divf %cst, %2 : f32 + %4 = arith.mulf %in, %3 : f32 + %5 = arith.mulf %3, %in_2 : f32 + %6 = arith.subf %in_2, %5 : f32 + %7 = arith.mulf %in_1, %6 : f32 + %8 = arith.addf %4, %7 : f32 + linalg.yield %8 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_glu_linalg.mlir b/issues/aten_c_kernels/results/aten_glu_linalg.mlir new file mode 100644 index 000000000000..c8aabc91f485 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_glu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_glu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.negf %in_0 : f32 + %1 = math.exp %0 : f32 + %2 = arith.addf %1, %cst : f32 + %3 = arith.divf %in, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gradient_cpu.mlir b/issues/aten_c_kernels/results/aten_gradient_cpu.mlir new file mode 100644 index 000000000000..187555fc2470 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gradient_cpu.mlir @@ -0,0 +1,24 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gradient_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.000000e+00 : f32 + %0 = affine.load %arg0[1] : memref + %1 = affine.load %arg0[0] : memref + %2 = arith.subf %0, %1 : f32 + %3 = arith.divf %2, %arg1 : f32 + affine.store %3, %arg2[0] : memref + %4 = arith.mulf %arg1, %cst : f32 + affine.for %arg3 = 1 to 127 { + %9 = affine.load %arg0[%arg3 + 1] : memref + %10 = affine.load %arg0[%arg3 - 1] : memref + %11 = arith.subf %9, %10 : f32 + %12 = arith.divf %11, %4 : f32 + affine.store %12, %arg2[%arg3] : memref + } + %5 = affine.load %arg0[127] : memref + %6 = affine.load %arg0[126] : memref + %7 = arith.subf %5, %6 : f32 + %8 = arith.divf %7, %arg1 : f32 + affine.store %8, %arg2[127] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gradient_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_gradient_cpu/debuf.mlir new file mode 100644 index 000000000000..a8cf5d1f0d8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gradient_cpu/debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gradient_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.000000e+00 : f32 + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c127 = arith.constant 127 : index + %c126 = arith.constant 126 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %extracted = tensor.extract %0[%c1] : tensor + %extracted_0 = tensor.extract %0[%c0] : tensor + %2 = arith.subf %extracted, %extracted_0 : f32 + %3 = arith.divf %2, %arg1 : f32 + %inserted = tensor.insert %3 into %1[%c0] : tensor + %4 = arith.mulf %arg1, %cst : f32 + %extracted_slice = tensor.extract_slice %0[2] [%c126] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %0[0] [%c126] [1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %inserted[1] [%c126] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_1 : tensor, tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: f32, %in_6: f32, %out: f32): + %9 = arith.subf %in, %in_6 : f32 + %10 = arith.divf %9, %4 : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %inserted[1] [%c126] [1] : tensor into tensor + %extracted_3 = tensor.extract %0[%c127] : tensor + %extracted_4 = tensor.extract %0[%c126] : tensor + %6 = arith.subf %extracted_3, %extracted_4 : f32 + %7 = arith.divf %6, %arg1 : f32 + %inserted_5 = tensor.insert %7 into %inserted_slice[%c127] : tensor + %8 = bufferization.to_memref %inserted_5 : memref + memref.copy %8, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gradient_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_gradient_cpu/matched.mlir new file mode 100644 index 000000000000..a8cf5d1f0d8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gradient_cpu/matched.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gradient_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.000000e+00 : f32 + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c127 = arith.constant 127 : index + %c126 = arith.constant 126 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %extracted = tensor.extract %0[%c1] : tensor + %extracted_0 = tensor.extract %0[%c0] : tensor + %2 = arith.subf %extracted, %extracted_0 : f32 + %3 = arith.divf %2, %arg1 : f32 + %inserted = tensor.insert %3 into %1[%c0] : tensor + %4 = arith.mulf %arg1, %cst : f32 + %extracted_slice = tensor.extract_slice %0[2] [%c126] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %0[0] [%c126] [1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %inserted[1] [%c126] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_1 : tensor, tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: f32, %in_6: f32, %out: f32): + %9 = arith.subf %in, %in_6 : f32 + %10 = arith.divf %9, %4 : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %inserted[1] [%c126] [1] : tensor into tensor + %extracted_3 = tensor.extract %0[%c127] : tensor + %extracted_4 = tensor.extract %0[%c126] : tensor + %6 = arith.subf %extracted_3, %extracted_4 : f32 + %7 = arith.divf %6, %arg1 : f32 + %inserted_5 = tensor.insert %7 into %inserted_slice[%c127] : tensor + %8 = bufferization.to_memref %inserted_5 : memref + memref.copy %8, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gradient_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_gradient_cpu/orig.mlir new file mode 100644 index 000000000000..187555fc2470 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gradient_cpu/orig.mlir @@ -0,0 +1,24 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gradient_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.000000e+00 : f32 + %0 = affine.load %arg0[1] : memref + %1 = affine.load %arg0[0] : memref + %2 = arith.subf %0, %1 : f32 + %3 = arith.divf %2, %arg1 : f32 + affine.store %3, %arg2[0] : memref + %4 = arith.mulf %arg1, %cst : f32 + affine.for %arg3 = 1 to 127 { + %9 = affine.load %arg0[%arg3 + 1] : memref + %10 = affine.load %arg0[%arg3 - 1] : memref + %11 = arith.subf %9, %10 : f32 + %12 = arith.divf %11, %4 : f32 + affine.store %12, %arg2[%arg3] : memref + } + %5 = affine.load %arg0[127] : memref + %6 = affine.load %arg0[126] : memref + %7 = arith.subf %5, %6 : f32 + %8 = arith.divf %7, %arg1 : f32 + affine.store %8, %arg2[127] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gradient_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_gradient_cpu/raised.mlir new file mode 100644 index 000000000000..4fa9f6b86233 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gradient_cpu/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gradient_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c126 = arith.constant 126 : index + %cst = arith.constant 2.000000e+00 : f32 + %0 = affine.load %arg0[1] : memref + %1 = affine.load %arg0[0] : memref + %2 = arith.subf %0, %1 : f32 + %3 = arith.divf %2, %arg1 : f32 + affine.store %3, %arg2[0] : memref + %4 = arith.mulf %arg1, %cst : f32 + %subview = memref.subview %arg0[2] [%c126] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0] [%c126] [1] : memref to memref> + %subview_1 = memref.subview %arg2[1] [%c126] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %9 = arith.subf %in, %in_2 : f32 + %10 = arith.divf %9, %4 : f32 + linalg.yield %10 : f32 + } + %5 = affine.load %arg0[127] : memref + %6 = affine.load %arg0[126] : memref + %7 = arith.subf %5, %6 : f32 + %8 = arith.divf %7, %arg1 : f32 + affine.store %8, %arg2[127] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gradient_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_gradient_cpu_debuf.mlir new file mode 100644 index 000000000000..a8cf5d1f0d8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gradient_cpu_debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gradient_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.000000e+00 : f32 + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c127 = arith.constant 127 : index + %c126 = arith.constant 126 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %extracted = tensor.extract %0[%c1] : tensor + %extracted_0 = tensor.extract %0[%c0] : tensor + %2 = arith.subf %extracted, %extracted_0 : f32 + %3 = arith.divf %2, %arg1 : f32 + %inserted = tensor.insert %3 into %1[%c0] : tensor + %4 = arith.mulf %arg1, %cst : f32 + %extracted_slice = tensor.extract_slice %0[2] [%c126] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %0[0] [%c126] [1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %inserted[1] [%c126] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_1 : tensor, tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: f32, %in_6: f32, %out: f32): + %9 = arith.subf %in, %in_6 : f32 + %10 = arith.divf %9, %4 : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %inserted[1] [%c126] [1] : tensor into tensor + %extracted_3 = tensor.extract %0[%c127] : tensor + %extracted_4 = tensor.extract %0[%c126] : tensor + %6 = arith.subf %extracted_3, %extracted_4 : f32 + %7 = arith.divf %6, %arg1 : f32 + %inserted_5 = tensor.insert %7 into %inserted_slice[%c127] : tensor + %8 = bufferization.to_memref %inserted_5 : memref + memref.copy %8, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gradient_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_gradient_cpu_linalg.mlir new file mode 100644 index 000000000000..4fa9f6b86233 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gradient_cpu_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gradient_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c126 = arith.constant 126 : index + %cst = arith.constant 2.000000e+00 : f32 + %0 = affine.load %arg0[1] : memref + %1 = affine.load %arg0[0] : memref + %2 = arith.subf %0, %1 : f32 + %3 = arith.divf %2, %arg1 : f32 + affine.store %3, %arg2[0] : memref + %4 = arith.mulf %arg1, %cst : f32 + %subview = memref.subview %arg0[2] [%c126] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0] [%c126] [1] : memref to memref> + %subview_1 = memref.subview %arg2[1] [%c126] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %9 = arith.subf %in, %in_2 : f32 + %10 = arith.divf %9, %4 : f32 + linalg.yield %10 : f32 + } + %5 = affine.load %arg0[127] : memref + %6 = affine.load %arg0[126] : memref + %7 = arith.subf %5, %6 : f32 + %8 = arith.divf %7, %arg1 : f32 + affine.store %8, %arg2[127] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gradient_float_cpu.mlir b/issues/aten_c_kernels/results/aten_gradient_float_cpu.mlir new file mode 100644 index 000000000000..ebc69bb12b72 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gradient_float_cpu.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gradient_float_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = affine.load %arg0[1] : memref + %1 = affine.load %arg0[0] : memref + %2 = arith.subf %0, %1 : f32 + %3 = affine.load %arg1[1] : memref + %4 = affine.load %arg1[0] : memref + %5 = arith.subf %3, %4 : f32 + %6 = arith.divf %2, %5 : f32 + affine.store %6, %arg2[0] : memref + affine.for %arg3 = 1 to 127 { + %14 = affine.load %arg0[%arg3 + 1] : memref + %15 = affine.load %arg0[%arg3 - 1] : memref + %16 = arith.subf %14, %15 : f32 + %17 = affine.load %arg1[%arg3 + 1] : memref + %18 = affine.load %arg1[%arg3 - 1] : memref + %19 = arith.subf %17, %18 : f32 + %20 = arith.divf %16, %19 : f32 + affine.store %20, %arg2[%arg3] : memref + } + %7 = affine.load %arg0[127] : memref + %8 = affine.load %arg0[126] : memref + %9 = arith.subf %7, %8 : f32 + %10 = affine.load %arg1[127] : memref + %11 = affine.load %arg1[126] : memref + %12 = arith.subf %10, %11 : f32 + %13 = arith.divf %9, %12 : f32 + affine.store %13, %arg2[127] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gradient_float_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_gradient_float_cpu/debuf.mlir new file mode 100644 index 000000000000..9bf37539ad13 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gradient_float_cpu/debuf.mlir @@ -0,0 +1,45 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gradient_float_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c127 = arith.constant 127 : index + %c126 = arith.constant 126 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted = tensor.extract %0[%c1] : tensor + %extracted_0 = tensor.extract %0[%c0] : tensor + %3 = arith.subf %extracted, %extracted_0 : f32 + %extracted_1 = tensor.extract %1[%c1] : tensor + %extracted_2 = tensor.extract %1[%c0] : tensor + %4 = arith.subf %extracted_1, %extracted_2 : f32 + %5 = arith.divf %3, %4 : f32 + %inserted = tensor.insert %5 into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %0[2] [%c126] [1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[0] [%c126] [1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %1[2] [%c126] [1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %1[0] [%c126] [1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %inserted[1] [%c126] [1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_3, %extracted_slice_4, %extracted_slice_5 : tensor, tensor, tensor, tensor) outs(%extracted_slice_6 : tensor) { + ^bb0(%in: f32, %in_12: f32, %in_13: f32, %in_14: f32, %out: f32): + %11 = arith.subf %in, %in_12 : f32 + %12 = arith.subf %in_13, %in_14 : f32 + %13 = arith.divf %11, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %inserted[1] [%c126] [1] : tensor into tensor + %extracted_7 = tensor.extract %0[%c127] : tensor + %extracted_8 = tensor.extract %0[%c126] : tensor + %7 = arith.subf %extracted_7, %extracted_8 : f32 + %extracted_9 = tensor.extract %1[%c127] : tensor + %extracted_10 = tensor.extract %1[%c126] : tensor + %8 = arith.subf %extracted_9, %extracted_10 : f32 + %9 = arith.divf %7, %8 : f32 + %inserted_11 = tensor.insert %9 into %inserted_slice[%c127] : tensor + %10 = bufferization.to_memref %inserted_11 : memref + memref.copy %10, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gradient_float_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_gradient_float_cpu/matched.mlir new file mode 100644 index 000000000000..9bf37539ad13 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gradient_float_cpu/matched.mlir @@ -0,0 +1,45 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gradient_float_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c127 = arith.constant 127 : index + %c126 = arith.constant 126 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted = tensor.extract %0[%c1] : tensor + %extracted_0 = tensor.extract %0[%c0] : tensor + %3 = arith.subf %extracted, %extracted_0 : f32 + %extracted_1 = tensor.extract %1[%c1] : tensor + %extracted_2 = tensor.extract %1[%c0] : tensor + %4 = arith.subf %extracted_1, %extracted_2 : f32 + %5 = arith.divf %3, %4 : f32 + %inserted = tensor.insert %5 into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %0[2] [%c126] [1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[0] [%c126] [1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %1[2] [%c126] [1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %1[0] [%c126] [1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %inserted[1] [%c126] [1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_3, %extracted_slice_4, %extracted_slice_5 : tensor, tensor, tensor, tensor) outs(%extracted_slice_6 : tensor) { + ^bb0(%in: f32, %in_12: f32, %in_13: f32, %in_14: f32, %out: f32): + %11 = arith.subf %in, %in_12 : f32 + %12 = arith.subf %in_13, %in_14 : f32 + %13 = arith.divf %11, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %inserted[1] [%c126] [1] : tensor into tensor + %extracted_7 = tensor.extract %0[%c127] : tensor + %extracted_8 = tensor.extract %0[%c126] : tensor + %7 = arith.subf %extracted_7, %extracted_8 : f32 + %extracted_9 = tensor.extract %1[%c127] : tensor + %extracted_10 = tensor.extract %1[%c126] : tensor + %8 = arith.subf %extracted_9, %extracted_10 : f32 + %9 = arith.divf %7, %8 : f32 + %inserted_11 = tensor.insert %9 into %inserted_slice[%c127] : tensor + %10 = bufferization.to_memref %inserted_11 : memref + memref.copy %10, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gradient_float_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_gradient_float_cpu/orig.mlir new file mode 100644 index 000000000000..ebc69bb12b72 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gradient_float_cpu/orig.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gradient_float_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = affine.load %arg0[1] : memref + %1 = affine.load %arg0[0] : memref + %2 = arith.subf %0, %1 : f32 + %3 = affine.load %arg1[1] : memref + %4 = affine.load %arg1[0] : memref + %5 = arith.subf %3, %4 : f32 + %6 = arith.divf %2, %5 : f32 + affine.store %6, %arg2[0] : memref + affine.for %arg3 = 1 to 127 { + %14 = affine.load %arg0[%arg3 + 1] : memref + %15 = affine.load %arg0[%arg3 - 1] : memref + %16 = arith.subf %14, %15 : f32 + %17 = affine.load %arg1[%arg3 + 1] : memref + %18 = affine.load %arg1[%arg3 - 1] : memref + %19 = arith.subf %17, %18 : f32 + %20 = arith.divf %16, %19 : f32 + affine.store %20, %arg2[%arg3] : memref + } + %7 = affine.load %arg0[127] : memref + %8 = affine.load %arg0[126] : memref + %9 = arith.subf %7, %8 : f32 + %10 = affine.load %arg1[127] : memref + %11 = affine.load %arg1[126] : memref + %12 = arith.subf %10, %11 : f32 + %13 = arith.divf %9, %12 : f32 + affine.store %13, %arg2[127] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gradient_float_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_gradient_float_cpu/raised.mlir new file mode 100644 index 000000000000..c57b72ed77a6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gradient_float_cpu/raised.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gradient_float_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c126 = arith.constant 126 : index + %0 = affine.load %arg0[1] : memref + %1 = affine.load %arg0[0] : memref + %2 = arith.subf %0, %1 : f32 + %3 = affine.load %arg1[1] : memref + %4 = affine.load %arg1[0] : memref + %5 = arith.subf %3, %4 : f32 + %6 = arith.divf %2, %5 : f32 + affine.store %6, %arg2[0] : memref + %subview = memref.subview %arg0[2] [%c126] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0] [%c126] [1] : memref to memref> + %subview_1 = memref.subview %arg1[2] [%c126] [1] : memref to memref> + %subview_2 = memref.subview %arg1[0] [%c126] [1] : memref to memref> + %subview_3 = memref.subview %arg2[1] [%c126] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview, %subview_0, %subview_1, %subview_2 : memref>, memref>, memref>, memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f32, %in_4: f32, %in_5: f32, %in_6: f32, %out: f32): + %14 = arith.subf %in, %in_4 : f32 + %15 = arith.subf %in_5, %in_6 : f32 + %16 = arith.divf %14, %15 : f32 + linalg.yield %16 : f32 + } + %7 = affine.load %arg0[127] : memref + %8 = affine.load %arg0[126] : memref + %9 = arith.subf %7, %8 : f32 + %10 = affine.load %arg1[127] : memref + %11 = affine.load %arg1[126] : memref + %12 = arith.subf %10, %11 : f32 + %13 = arith.divf %9, %12 : f32 + affine.store %13, %arg2[127] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gradient_float_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_gradient_float_cpu_debuf.mlir new file mode 100644 index 000000000000..9bf37539ad13 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gradient_float_cpu_debuf.mlir @@ -0,0 +1,45 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gradient_float_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %c127 = arith.constant 127 : index + %c126 = arith.constant 126 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted = tensor.extract %0[%c1] : tensor + %extracted_0 = tensor.extract %0[%c0] : tensor + %3 = arith.subf %extracted, %extracted_0 : f32 + %extracted_1 = tensor.extract %1[%c1] : tensor + %extracted_2 = tensor.extract %1[%c0] : tensor + %4 = arith.subf %extracted_1, %extracted_2 : f32 + %5 = arith.divf %3, %4 : f32 + %inserted = tensor.insert %5 into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %0[2] [%c126] [1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[0] [%c126] [1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %1[2] [%c126] [1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %1[0] [%c126] [1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %inserted[1] [%c126] [1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_3, %extracted_slice_4, %extracted_slice_5 : tensor, tensor, tensor, tensor) outs(%extracted_slice_6 : tensor) { + ^bb0(%in: f32, %in_12: f32, %in_13: f32, %in_14: f32, %out: f32): + %11 = arith.subf %in, %in_12 : f32 + %12 = arith.subf %in_13, %in_14 : f32 + %13 = arith.divf %11, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %inserted[1] [%c126] [1] : tensor into tensor + %extracted_7 = tensor.extract %0[%c127] : tensor + %extracted_8 = tensor.extract %0[%c126] : tensor + %7 = arith.subf %extracted_7, %extracted_8 : f32 + %extracted_9 = tensor.extract %1[%c127] : tensor + %extracted_10 = tensor.extract %1[%c126] : tensor + %8 = arith.subf %extracted_9, %extracted_10 : f32 + %9 = arith.divf %7, %8 : f32 + %inserted_11 = tensor.insert %9 into %inserted_slice[%c127] : tensor + %10 = bufferization.to_memref %inserted_11 : memref + memref.copy %10, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gradient_float_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_gradient_float_cpu_linalg.mlir new file mode 100644 index 000000000000..c57b72ed77a6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gradient_float_cpu_linalg.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gradient_float_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c126 = arith.constant 126 : index + %0 = affine.load %arg0[1] : memref + %1 = affine.load %arg0[0] : memref + %2 = arith.subf %0, %1 : f32 + %3 = affine.load %arg1[1] : memref + %4 = affine.load %arg1[0] : memref + %5 = arith.subf %3, %4 : f32 + %6 = arith.divf %2, %5 : f32 + affine.store %6, %arg2[0] : memref + %subview = memref.subview %arg0[2] [%c126] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0] [%c126] [1] : memref to memref> + %subview_1 = memref.subview %arg1[2] [%c126] [1] : memref to memref> + %subview_2 = memref.subview %arg1[0] [%c126] [1] : memref to memref> + %subview_3 = memref.subview %arg2[1] [%c126] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview, %subview_0, %subview_1, %subview_2 : memref>, memref>, memref>, memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f32, %in_4: f32, %in_5: f32, %in_6: f32, %out: f32): + %14 = arith.subf %in, %in_4 : f32 + %15 = arith.subf %in_5, %in_6 : f32 + %16 = arith.divf %14, %15 : f32 + linalg.yield %16 : f32 + } + %7 = affine.load %arg0[127] : memref + %8 = affine.load %arg0[126] : memref + %9 = arith.subf %7, %8 : f32 + %10 = affine.load %arg1[127] : memref + %11 = affine.load %arg1[126] : memref + %12 = arith.subf %10, %11 : f32 + %13 = arith.divf %9, %12 : f32 + affine.store %13, %arg2[127] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu.mlir new file mode 100644 index 000000000000..afbaa1e753c9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu.mlir @@ -0,0 +1,131 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 7.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = "polygeist.memref2pointer"(%arg3) : (memref) -> !llvm.ptr + affine.for %arg5 = 0 to 192 { + %1 = arith.index_cast %arg5 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_2, %2 : f32, !llvm.ptr + } + affine.for %arg5 = 0 to 6 { + affine.for %arg6 = 0 to 6 { + %1 = affine.load %arg1[0, %arg5, %arg6, 0] : memref + %2 = arith.addf %1, %cst_1 : f32 + %3 = arith.mulf %2, %cst_0 : f32 + %4 = arith.mulf %3, %cst : f32 + %5 = affine.load %arg1[0, %arg5, %arg6, 1] : memref + %6 = arith.addf %5, %cst_1 : f32 + %7 = arith.mulf %6, %cst_0 : f32 + %8 = arith.mulf %7, %cst : f32 + %9 = arith.fptosi %4 : f32 to i32 + %10 = arith.fptosi %8 : f32 to i32 + %11 = arith.addi %9, %c1_i32 : i32 + %12 = arith.addi %10, %c1_i32 : i32 + %13 = arith.sitofp %9 : i32 to f32 + %14 = arith.subf %4, %13 : f32 + %15 = arith.sitofp %10 : i32 to f32 + %16 = arith.subf %8, %15 : f32 + %17 = arith.cmpi sge, %9, %c0_i32 : i32 + %18 = arith.cmpi slt, %9, %c8_i32 : i32 + %19 = arith.cmpi sge, %10, %c0_i32 : i32 + %20 = arith.cmpi slt, %10, %c8_i32 : i32 + %21 = arith.andi %19, %20 : i1 + %22 = arith.andi %18, %21 : i1 + %23 = arith.andi %17, %22 : i1 + %24 = arith.cmpi sge, %11, %c0_i32 : i32 + %25 = arith.cmpi slt, %11, %c8_i32 : i32 + %26 = arith.andi %25, %21 : i1 + %27 = arith.andi %24, %26 : i1 + %28 = arith.cmpi sge, %12, %c0_i32 : i32 + %29 = arith.cmpi slt, %12, %c8_i32 : i32 + %30 = arith.andi %28, %29 : i1 + %31 = arith.andi %18, %30 : i1 + %32 = arith.andi %17, %31 : i1 + %33 = arith.andi %25, %30 : i1 + %34 = arith.andi %24, %33 : i1 + %35 = arith.subf %cst_1, %16 : f32 + %36 = arith.subf %cst_1, %14 : f32 + %37 = arith.index_cast %10 : i32 to index + %38 = arith.index_cast %9 : i32 to index + %39 = arith.index_cast %11 : i32 to index + %40 = arith.index_cast %12 : i32 to index + %41:2 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %cst_2, %arg9 = %cst_2) -> (f32, f32) { + %46 = affine.load %arg2[0, %arg7, %arg5, %arg6] : memref + %47 = scf.if %23 -> (f32) { + %65 = memref.load %arg0[%c0, %arg7, %37, %38] : memref + %66 = arith.mulf %46, %36 : f32 + %67 = arith.mulf %66, %35 : f32 + %68 = memref.load %arg3[%c0, %arg7, %37, %38] : memref + %69 = arith.addf %68, %67 : f32 + memref.store %69, %arg3[%c0, %arg7, %37, %38] : memref + scf.yield %65 : f32 + } else { + scf.yield %cst_2 : f32 + } + %48 = scf.if %27 -> (f32) { + %65 = memref.load %arg0[%c0, %arg7, %37, %39] : memref + %66 = arith.mulf %46, %14 : f32 + %67 = arith.mulf %66, %35 : f32 + %68 = memref.load %arg3[%c0, %arg7, %37, %39] : memref + %69 = arith.addf %68, %67 : f32 + memref.store %69, %arg3[%c0, %arg7, %37, %39] : memref + scf.yield %65 : f32 + } else { + scf.yield %cst_2 : f32 + } + %49 = scf.if %32 -> (f32) { + %65 = memref.load %arg0[%c0, %arg7, %40, %38] : memref + %66 = arith.mulf %46, %36 : f32 + %67 = arith.mulf %66, %16 : f32 + %68 = memref.load %arg3[%c0, %arg7, %40, %38] : memref + %69 = arith.addf %68, %67 : f32 + memref.store %69, %arg3[%c0, %arg7, %40, %38] : memref + scf.yield %65 : f32 + } else { + scf.yield %cst_2 : f32 + } + %50 = scf.if %34 -> (f32) { + %65 = memref.load %arg0[%c0, %arg7, %40, %39] : memref + %66 = arith.mulf %46, %14 : f32 + %67 = arith.mulf %66, %16 : f32 + %68 = memref.load %arg3[%c0, %arg7, %40, %39] : memref + %69 = arith.addf %68, %67 : f32 + memref.store %69, %arg3[%c0, %arg7, %40, %39] : memref + scf.yield %65 : f32 + } else { + scf.yield %cst_2 : f32 + } + %51 = arith.subf %48, %47 : f32 + %52 = arith.mulf %51, %35 : f32 + %53 = arith.subf %50, %49 : f32 + %54 = arith.mulf %53, %16 : f32 + %55 = arith.addf %52, %54 : f32 + %56 = arith.mulf %46, %55 : f32 + %57 = arith.addf %arg9, %56 : f32 + %58 = arith.subf %49, %47 : f32 + %59 = arith.mulf %58, %36 : f32 + %60 = arith.subf %50, %48 : f32 + %61 = arith.mulf %60, %14 : f32 + %62 = arith.addf %59, %61 : f32 + %63 = arith.mulf %46, %62 : f32 + %64 = arith.addf %arg8, %63 : f32 + affine.yield %64, %57 : f32, f32 + } + %42 = arith.mulf %41#1, %cst_0 : f32 + %43 = arith.mulf %42, %cst : f32 + affine.store %43, %arg4[0, %arg5, %arg6, 0] : memref + %44 = arith.mulf %41#0, %cst_0 : f32 + %45 = arith.mulf %44, %cst : f32 + affine.store %45, %arg4[0, %arg5, %arg6, 1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..a351064834dd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu/debuf.mlir @@ -0,0 +1,173 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %c0 = arith.constant 0 : index + %c6 = arith.constant 6 : index + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = "polygeist.memref2pointer"(%arg3) : (memref) -> !llvm.ptr + affine.for %arg5 = 0 to 192 { + %7 = arith.index_cast %arg5 : index to i32 + %8 = llvm.getelementptr %4[%7] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %8 : f32, !llvm.ptr + } + %5 = affine.for %arg5 = 0 to 6 iter_args(%arg6 = %0) -> (tensor) { + %alloca = memref.alloca(%c6) : memref + %7 = bufferization.to_tensor %alloca : memref + %8 = bufferization.to_tensor %alloca : memref + %alloca_3 = memref.alloca(%c6) : memref + %9 = bufferization.to_tensor %alloca_3 : memref + %10 = bufferization.to_tensor %alloca_3 : memref + %11 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%8 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %12 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%10 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %13:2 = affine.for %arg7 = 0 to 6 iter_args(%arg8 = %11, %arg9 = %12) -> (tensor, tensor) { + %extracted = tensor.extract %2[%c0, %arg5, %arg7, %c0] : tensor + %16 = arith.addf %extracted, %cst_0 : f32 + %17 = arith.mulf %16, %cst_1 : f32 + %18 = arith.mulf %17, %cst_2 : f32 + %extracted_8 = tensor.extract %2[%c0, %arg5, %arg7, %c1] : tensor + %19 = arith.addf %extracted_8, %cst_0 : f32 + %20 = arith.mulf %19, %cst_1 : f32 + %21 = arith.mulf %20, %cst_2 : f32 + %22 = arith.fptosi %18 : f32 to i32 + %23 = arith.fptosi %21 : f32 to i32 + %24 = arith.addi %22, %c1_i32 : i32 + %25 = arith.addi %23, %c1_i32 : i32 + %26 = arith.sitofp %22 : i32 to f32 + %27 = arith.subf %18, %26 : f32 + %28 = arith.sitofp %23 : i32 to f32 + %29 = arith.subf %21, %28 : f32 + %30 = arith.cmpi sge, %22, %c0_i32 : i32 + %31 = arith.cmpi slt, %22, %c8_i32 : i32 + %32 = arith.cmpi sge, %23, %c0_i32 : i32 + %33 = arith.cmpi slt, %23, %c8_i32 : i32 + %34 = arith.andi %32, %33 : i1 + %35 = arith.andi %31, %34 : i1 + %36 = arith.andi %30, %35 : i1 + %37 = arith.cmpi sge, %24, %c0_i32 : i32 + %38 = arith.cmpi slt, %24, %c8_i32 : i32 + %39 = arith.andi %38, %34 : i1 + %40 = arith.andi %37, %39 : i1 + %41 = arith.cmpi sge, %25, %c0_i32 : i32 + %42 = arith.cmpi slt, %25, %c8_i32 : i32 + %43 = arith.andi %41, %42 : i1 + %44 = arith.andi %31, %43 : i1 + %45 = arith.andi %30, %44 : i1 + %46 = arith.andi %38, %43 : i1 + %47 = arith.andi %37, %46 : i1 + %48 = arith.subf %cst_0, %29 : f32 + %49 = arith.subf %cst_0, %27 : f32 + %50 = arith.index_cast %23 : i32 to index + %51 = arith.index_cast %22 : i32 to index + %52 = arith.index_cast %24 : i32 to index + %53 = arith.index_cast %25 : i32 to index + %54:2 = affine.for %arg10 = 0 to 3 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (tensor, tensor) { + %extracted_9 = tensor.extract %arg11[%arg7] : tensor + %extracted_10 = tensor.extract %arg12[%arg7] : tensor + %extracted_11 = tensor.extract %1[%c0, %arg10, %arg5, %arg7] : tensor + %55 = scf.if %36 -> (f32) { + %extracted_13 = tensor.extract %3[%c0, %arg10, %50, %51] : tensor + %73 = arith.mulf %extracted_11, %49 : f32 + %74 = arith.mulf %73, %48 : f32 + %75 = memref.load %arg3[%c0, %arg10, %50, %51] : memref + %76 = arith.addf %75, %74 : f32 + memref.store %76, %arg3[%c0, %arg10, %50, %51] : memref + scf.yield %extracted_13 : f32 + } else { + scf.yield %cst : f32 + } + %56 = scf.if %40 -> (f32) { + %extracted_13 = tensor.extract %3[%c0, %arg10, %50, %52] : tensor + %73 = arith.mulf %extracted_11, %27 : f32 + %74 = arith.mulf %73, %48 : f32 + %75 = memref.load %arg3[%c0, %arg10, %50, %52] : memref + %76 = arith.addf %75, %74 : f32 + memref.store %76, %arg3[%c0, %arg10, %50, %52] : memref + scf.yield %extracted_13 : f32 + } else { + scf.yield %cst : f32 + } + %57 = scf.if %45 -> (f32) { + %extracted_13 = tensor.extract %3[%c0, %arg10, %53, %51] : tensor + %73 = arith.mulf %extracted_11, %49 : f32 + %74 = arith.mulf %73, %29 : f32 + %75 = memref.load %arg3[%c0, %arg10, %53, %51] : memref + %76 = arith.addf %75, %74 : f32 + memref.store %76, %arg3[%c0, %arg10, %53, %51] : memref + scf.yield %extracted_13 : f32 + } else { + scf.yield %cst : f32 + } + %58 = scf.if %47 -> (f32) { + %extracted_13 = tensor.extract %3[%c0, %arg10, %53, %52] : tensor + %73 = arith.mulf %extracted_11, %27 : f32 + %74 = arith.mulf %73, %29 : f32 + %75 = memref.load %arg3[%c0, %arg10, %53, %52] : memref + %76 = arith.addf %75, %74 : f32 + memref.store %76, %arg3[%c0, %arg10, %53, %52] : memref + scf.yield %extracted_13 : f32 + } else { + scf.yield %cst : f32 + } + %59 = arith.subf %56, %55 : f32 + %60 = arith.mulf %59, %48 : f32 + %61 = arith.subf %58, %57 : f32 + %62 = arith.mulf %61, %29 : f32 + %63 = arith.addf %60, %62 : f32 + %64 = arith.mulf %extracted_11, %63 : f32 + %65 = arith.addf %extracted_10, %64 : f32 + %66 = arith.subf %57, %55 : f32 + %67 = arith.mulf %66, %49 : f32 + %68 = arith.subf %58, %56 : f32 + %69 = arith.mulf %68, %27 : f32 + %70 = arith.addf %67, %69 : f32 + %71 = arith.mulf %extracted_11, %70 : f32 + %72 = arith.addf %extracted_9, %71 : f32 + %inserted = tensor.insert %72 into %arg11[%arg7] : tensor + %inserted_12 = tensor.insert %65 into %arg12[%arg7] : tensor + affine.yield %inserted, %inserted_12 : tensor, tensor + } + affine.yield %54#0, %54#1 : tensor, tensor + } + %extracted_slice = tensor.extract_slice %arg6[0, %arg5, 0, 0] [1, 1, %c6, 1] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %9[0] [%c6] [1] : tensor to tensor + %14 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_4 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %16 = arith.mulf %in, %cst_1 : f32 + %17 = arith.mulf %16, %cst_2 : f32 + linalg.yield %17 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %14 into %arg6[0, %arg5, 0, 0] [1, 1, %c6, 1] [1, 1, 1, 1] : tensor into tensor + %extracted_slice_5 = tensor.extract_slice %inserted_slice[0, %arg5, 0, 1] [1, 1, %c6, 1] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %7[0] [%c6] [1] : tensor to tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_6 : tensor) outs(%extracted_slice_5 : tensor) { + ^bb0(%in: f32, %out: f32): + %16 = arith.mulf %in, %cst_1 : f32 + %17 = arith.mulf %16, %cst_2 : f32 + linalg.yield %17 : f32 + } -> tensor + %inserted_slice_7 = tensor.insert_slice %15 into %inserted_slice[0, %arg5, 0, 1] [1, 1, %c6, 1] [1, 1, 1, 1] : tensor into tensor + affine.yield %inserted_slice_7 : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..2425b05fc138 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu/matched.mlir @@ -0,0 +1,167 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %c0 = arith.constant 0 : index + %c6 = arith.constant 6 : index + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = "polygeist.memref2pointer"(%arg3) : (memref) -> !llvm.ptr + affine.for %arg5 = 0 to 192 { + %7 = arith.index_cast %arg5 : index to i32 + %8 = llvm.getelementptr %4[%7] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %8 : f32, !llvm.ptr + } + %5 = affine.for %arg5 = 0 to 6 iter_args(%arg6 = %0) -> (tensor) { + %alloca = memref.alloca(%c6) : memref + %7 = bufferization.to_tensor %alloca : memref + %8 = bufferization.to_tensor %alloca : memref + %alloca_3 = memref.alloca(%c6) : memref + %9 = bufferization.to_tensor %alloca_3 : memref + %10 = bufferization.to_tensor %alloca_3 : memref + %11 = kernel.launch @memset_zero_1D_f32(%8) : (tensor) -> tensor + %12 = kernel.launch @memset_zero_1D_f32(%10) : (tensor) -> tensor + %13:2 = affine.for %arg7 = 0 to 6 iter_args(%arg8 = %11, %arg9 = %12) -> (tensor, tensor) { + %extracted = tensor.extract %2[%c0, %arg5, %arg7, %c0] : tensor + %16 = arith.addf %extracted, %cst_0 : f32 + %17 = arith.mulf %16, %cst_1 : f32 + %18 = arith.mulf %17, %cst_2 : f32 + %extracted_8 = tensor.extract %2[%c0, %arg5, %arg7, %c1] : tensor + %19 = arith.addf %extracted_8, %cst_0 : f32 + %20 = arith.mulf %19, %cst_1 : f32 + %21 = arith.mulf %20, %cst_2 : f32 + %22 = arith.fptosi %18 : f32 to i32 + %23 = arith.fptosi %21 : f32 to i32 + %24 = arith.addi %22, %c1_i32 : i32 + %25 = arith.addi %23, %c1_i32 : i32 + %26 = arith.sitofp %22 : i32 to f32 + %27 = arith.subf %18, %26 : f32 + %28 = arith.sitofp %23 : i32 to f32 + %29 = arith.subf %21, %28 : f32 + %30 = arith.cmpi sge, %22, %c0_i32 : i32 + %31 = arith.cmpi slt, %22, %c8_i32 : i32 + %32 = arith.cmpi sge, %23, %c0_i32 : i32 + %33 = arith.cmpi slt, %23, %c8_i32 : i32 + %34 = arith.andi %32, %33 : i1 + %35 = arith.andi %31, %34 : i1 + %36 = arith.andi %30, %35 : i1 + %37 = arith.cmpi sge, %24, %c0_i32 : i32 + %38 = arith.cmpi slt, %24, %c8_i32 : i32 + %39 = arith.andi %38, %34 : i1 + %40 = arith.andi %37, %39 : i1 + %41 = arith.cmpi sge, %25, %c0_i32 : i32 + %42 = arith.cmpi slt, %25, %c8_i32 : i32 + %43 = arith.andi %41, %42 : i1 + %44 = arith.andi %31, %43 : i1 + %45 = arith.andi %30, %44 : i1 + %46 = arith.andi %38, %43 : i1 + %47 = arith.andi %37, %46 : i1 + %48 = arith.subf %cst_0, %29 : f32 + %49 = arith.subf %cst_0, %27 : f32 + %50 = arith.index_cast %23 : i32 to index + %51 = arith.index_cast %22 : i32 to index + %52 = arith.index_cast %24 : i32 to index + %53 = arith.index_cast %25 : i32 to index + %54:2 = affine.for %arg10 = 0 to 3 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (tensor, tensor) { + %extracted_9 = tensor.extract %arg11[%arg7] : tensor + %extracted_10 = tensor.extract %arg12[%arg7] : tensor + %extracted_11 = tensor.extract %1[%c0, %arg10, %arg5, %arg7] : tensor + %55 = scf.if %36 -> (f32) { + %extracted_13 = tensor.extract %3[%c0, %arg10, %50, %51] : tensor + %73 = arith.mulf %extracted_11, %49 : f32 + %74 = arith.mulf %73, %48 : f32 + %75 = memref.load %arg3[%c0, %arg10, %50, %51] : memref + %76 = arith.addf %75, %74 : f32 + memref.store %76, %arg3[%c0, %arg10, %50, %51] : memref + scf.yield %extracted_13 : f32 + } else { + scf.yield %cst : f32 + } + %56 = scf.if %40 -> (f32) { + %extracted_13 = tensor.extract %3[%c0, %arg10, %50, %52] : tensor + %73 = arith.mulf %extracted_11, %27 : f32 + %74 = arith.mulf %73, %48 : f32 + %75 = memref.load %arg3[%c0, %arg10, %50, %52] : memref + %76 = arith.addf %75, %74 : f32 + memref.store %76, %arg3[%c0, %arg10, %50, %52] : memref + scf.yield %extracted_13 : f32 + } else { + scf.yield %cst : f32 + } + %57 = scf.if %45 -> (f32) { + %extracted_13 = tensor.extract %3[%c0, %arg10, %53, %51] : tensor + %73 = arith.mulf %extracted_11, %49 : f32 + %74 = arith.mulf %73, %29 : f32 + %75 = memref.load %arg3[%c0, %arg10, %53, %51] : memref + %76 = arith.addf %75, %74 : f32 + memref.store %76, %arg3[%c0, %arg10, %53, %51] : memref + scf.yield %extracted_13 : f32 + } else { + scf.yield %cst : f32 + } + %58 = scf.if %47 -> (f32) { + %extracted_13 = tensor.extract %3[%c0, %arg10, %53, %52] : tensor + %73 = arith.mulf %extracted_11, %27 : f32 + %74 = arith.mulf %73, %29 : f32 + %75 = memref.load %arg3[%c0, %arg10, %53, %52] : memref + %76 = arith.addf %75, %74 : f32 + memref.store %76, %arg3[%c0, %arg10, %53, %52] : memref + scf.yield %extracted_13 : f32 + } else { + scf.yield %cst : f32 + } + %59 = arith.subf %56, %55 : f32 + %60 = arith.mulf %59, %48 : f32 + %61 = arith.subf %58, %57 : f32 + %62 = arith.mulf %61, %29 : f32 + %63 = arith.addf %60, %62 : f32 + %64 = arith.mulf %extracted_11, %63 : f32 + %65 = arith.addf %extracted_10, %64 : f32 + %66 = arith.subf %57, %55 : f32 + %67 = arith.mulf %66, %49 : f32 + %68 = arith.subf %58, %56 : f32 + %69 = arith.mulf %68, %27 : f32 + %70 = arith.addf %67, %69 : f32 + %71 = arith.mulf %extracted_11, %70 : f32 + %72 = arith.addf %extracted_9, %71 : f32 + %inserted = tensor.insert %72 into %arg11[%arg7] : tensor + %inserted_12 = tensor.insert %65 into %arg12[%arg7] : tensor + affine.yield %inserted, %inserted_12 : tensor, tensor + } + affine.yield %54#0, %54#1 : tensor, tensor + } + %extracted_slice = tensor.extract_slice %arg6[0, %arg5, 0, 0] [1, 1, %c6, 1] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %9[0] [%c6] [1] : tensor to tensor + %14 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_4 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %16 = arith.mulf %in, %cst_1 : f32 + %17 = arith.mulf %16, %cst_2 : f32 + linalg.yield %17 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %14 into %arg6[0, %arg5, 0, 0] [1, 1, %c6, 1] [1, 1, 1, 1] : tensor into tensor + %extracted_slice_5 = tensor.extract_slice %inserted_slice[0, %arg5, 0, 1] [1, 1, %c6, 1] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %7[0] [%c6] [1] : tensor to tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_6 : tensor) outs(%extracted_slice_5 : tensor) { + ^bb0(%in: f32, %out: f32): + %16 = arith.mulf %in, %cst_1 : f32 + %17 = arith.mulf %16, %cst_2 : f32 + linalg.yield %17 : f32 + } -> tensor + %inserted_slice_7 = tensor.insert_slice %15 into %inserted_slice[0, %arg5, 0, 1] [1, 1, %c6, 1] [1, 1, 1, 1] : tensor into tensor + affine.yield %inserted_slice_7 : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..afbaa1e753c9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu/orig.mlir @@ -0,0 +1,131 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 7.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = "polygeist.memref2pointer"(%arg3) : (memref) -> !llvm.ptr + affine.for %arg5 = 0 to 192 { + %1 = arith.index_cast %arg5 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_2, %2 : f32, !llvm.ptr + } + affine.for %arg5 = 0 to 6 { + affine.for %arg6 = 0 to 6 { + %1 = affine.load %arg1[0, %arg5, %arg6, 0] : memref + %2 = arith.addf %1, %cst_1 : f32 + %3 = arith.mulf %2, %cst_0 : f32 + %4 = arith.mulf %3, %cst : f32 + %5 = affine.load %arg1[0, %arg5, %arg6, 1] : memref + %6 = arith.addf %5, %cst_1 : f32 + %7 = arith.mulf %6, %cst_0 : f32 + %8 = arith.mulf %7, %cst : f32 + %9 = arith.fptosi %4 : f32 to i32 + %10 = arith.fptosi %8 : f32 to i32 + %11 = arith.addi %9, %c1_i32 : i32 + %12 = arith.addi %10, %c1_i32 : i32 + %13 = arith.sitofp %9 : i32 to f32 + %14 = arith.subf %4, %13 : f32 + %15 = arith.sitofp %10 : i32 to f32 + %16 = arith.subf %8, %15 : f32 + %17 = arith.cmpi sge, %9, %c0_i32 : i32 + %18 = arith.cmpi slt, %9, %c8_i32 : i32 + %19 = arith.cmpi sge, %10, %c0_i32 : i32 + %20 = arith.cmpi slt, %10, %c8_i32 : i32 + %21 = arith.andi %19, %20 : i1 + %22 = arith.andi %18, %21 : i1 + %23 = arith.andi %17, %22 : i1 + %24 = arith.cmpi sge, %11, %c0_i32 : i32 + %25 = arith.cmpi slt, %11, %c8_i32 : i32 + %26 = arith.andi %25, %21 : i1 + %27 = arith.andi %24, %26 : i1 + %28 = arith.cmpi sge, %12, %c0_i32 : i32 + %29 = arith.cmpi slt, %12, %c8_i32 : i32 + %30 = arith.andi %28, %29 : i1 + %31 = arith.andi %18, %30 : i1 + %32 = arith.andi %17, %31 : i1 + %33 = arith.andi %25, %30 : i1 + %34 = arith.andi %24, %33 : i1 + %35 = arith.subf %cst_1, %16 : f32 + %36 = arith.subf %cst_1, %14 : f32 + %37 = arith.index_cast %10 : i32 to index + %38 = arith.index_cast %9 : i32 to index + %39 = arith.index_cast %11 : i32 to index + %40 = arith.index_cast %12 : i32 to index + %41:2 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %cst_2, %arg9 = %cst_2) -> (f32, f32) { + %46 = affine.load %arg2[0, %arg7, %arg5, %arg6] : memref + %47 = scf.if %23 -> (f32) { + %65 = memref.load %arg0[%c0, %arg7, %37, %38] : memref + %66 = arith.mulf %46, %36 : f32 + %67 = arith.mulf %66, %35 : f32 + %68 = memref.load %arg3[%c0, %arg7, %37, %38] : memref + %69 = arith.addf %68, %67 : f32 + memref.store %69, %arg3[%c0, %arg7, %37, %38] : memref + scf.yield %65 : f32 + } else { + scf.yield %cst_2 : f32 + } + %48 = scf.if %27 -> (f32) { + %65 = memref.load %arg0[%c0, %arg7, %37, %39] : memref + %66 = arith.mulf %46, %14 : f32 + %67 = arith.mulf %66, %35 : f32 + %68 = memref.load %arg3[%c0, %arg7, %37, %39] : memref + %69 = arith.addf %68, %67 : f32 + memref.store %69, %arg3[%c0, %arg7, %37, %39] : memref + scf.yield %65 : f32 + } else { + scf.yield %cst_2 : f32 + } + %49 = scf.if %32 -> (f32) { + %65 = memref.load %arg0[%c0, %arg7, %40, %38] : memref + %66 = arith.mulf %46, %36 : f32 + %67 = arith.mulf %66, %16 : f32 + %68 = memref.load %arg3[%c0, %arg7, %40, %38] : memref + %69 = arith.addf %68, %67 : f32 + memref.store %69, %arg3[%c0, %arg7, %40, %38] : memref + scf.yield %65 : f32 + } else { + scf.yield %cst_2 : f32 + } + %50 = scf.if %34 -> (f32) { + %65 = memref.load %arg0[%c0, %arg7, %40, %39] : memref + %66 = arith.mulf %46, %14 : f32 + %67 = arith.mulf %66, %16 : f32 + %68 = memref.load %arg3[%c0, %arg7, %40, %39] : memref + %69 = arith.addf %68, %67 : f32 + memref.store %69, %arg3[%c0, %arg7, %40, %39] : memref + scf.yield %65 : f32 + } else { + scf.yield %cst_2 : f32 + } + %51 = arith.subf %48, %47 : f32 + %52 = arith.mulf %51, %35 : f32 + %53 = arith.subf %50, %49 : f32 + %54 = arith.mulf %53, %16 : f32 + %55 = arith.addf %52, %54 : f32 + %56 = arith.mulf %46, %55 : f32 + %57 = arith.addf %arg9, %56 : f32 + %58 = arith.subf %49, %47 : f32 + %59 = arith.mulf %58, %36 : f32 + %60 = arith.subf %50, %48 : f32 + %61 = arith.mulf %60, %14 : f32 + %62 = arith.addf %59, %61 : f32 + %63 = arith.mulf %46, %62 : f32 + %64 = arith.addf %arg8, %63 : f32 + affine.yield %64, %57 : f32, f32 + } + %42 = arith.mulf %41#1, %cst_0 : f32 + %43 = arith.mulf %42, %cst : f32 + affine.store %43, %arg4[0, %arg5, %arg6, 0] : memref + %44 = arith.mulf %41#0, %cst_0 : f32 + %45 = arith.mulf %44, %cst : f32 + affine.store %45, %arg4[0, %arg5, %arg6, 1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..e5a219c6974d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu/raised.mlir @@ -0,0 +1,157 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c6 = arith.constant 6 : index + %c0 = arith.constant 0 : index + %cst = arith.constant 7.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = "polygeist.memref2pointer"(%arg3) : (memref) -> !llvm.ptr + affine.for %arg5 = 0 to 192 { + %1 = arith.index_cast %arg5 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_2, %2 : f32, !llvm.ptr + } + affine.for %arg5 = 0 to 6 { + %alloca = memref.alloca(%c6) : memref + %alloca_3 = memref.alloca(%c6) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst_2 : f32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_3 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_2 : f32 + } + affine.for %arg6 = 0 to 6 { + %1 = affine.load %arg1[0, %arg5, %arg6, 0] : memref + %2 = arith.addf %1, %cst_1 : f32 + %3 = arith.mulf %2, %cst_0 : f32 + %4 = arith.mulf %3, %cst : f32 + %5 = affine.load %arg1[0, %arg5, %arg6, 1] : memref + %6 = arith.addf %5, %cst_1 : f32 + %7 = arith.mulf %6, %cst_0 : f32 + %8 = arith.mulf %7, %cst : f32 + %9 = arith.fptosi %4 : f32 to i32 + %10 = arith.fptosi %8 : f32 to i32 + %11 = arith.addi %9, %c1_i32 : i32 + %12 = arith.addi %10, %c1_i32 : i32 + %13 = arith.sitofp %9 : i32 to f32 + %14 = arith.subf %4, %13 : f32 + %15 = arith.sitofp %10 : i32 to f32 + %16 = arith.subf %8, %15 : f32 + %17 = arith.cmpi sge, %9, %c0_i32 : i32 + %18 = arith.cmpi slt, %9, %c8_i32 : i32 + %19 = arith.cmpi sge, %10, %c0_i32 : i32 + %20 = arith.cmpi slt, %10, %c8_i32 : i32 + %21 = arith.andi %19, %20 : i1 + %22 = arith.andi %18, %21 : i1 + %23 = arith.andi %17, %22 : i1 + %24 = arith.cmpi sge, %11, %c0_i32 : i32 + %25 = arith.cmpi slt, %11, %c8_i32 : i32 + %26 = arith.andi %25, %21 : i1 + %27 = arith.andi %24, %26 : i1 + %28 = arith.cmpi sge, %12, %c0_i32 : i32 + %29 = arith.cmpi slt, %12, %c8_i32 : i32 + %30 = arith.andi %28, %29 : i1 + %31 = arith.andi %18, %30 : i1 + %32 = arith.andi %17, %31 : i1 + %33 = arith.andi %25, %30 : i1 + %34 = arith.andi %24, %33 : i1 + %35 = arith.subf %cst_1, %16 : f32 + %36 = arith.subf %cst_1, %14 : f32 + %37 = arith.index_cast %10 : i32 to index + %38 = arith.index_cast %9 : i32 to index + %39 = arith.index_cast %11 : i32 to index + %40 = arith.index_cast %12 : i32 to index + affine.for %arg7 = 0 to 3 { + %41 = affine.load %alloca[%arg6] : memref + %42 = affine.load %alloca_3[%arg6] : memref + %43 = affine.load %arg2[0, %arg7, %arg5, %arg6] : memref + %44 = scf.if %23 -> (f32) { + %62 = memref.load %arg0[%c0, %arg7, %37, %38] : memref + %63 = arith.mulf %43, %36 : f32 + %64 = arith.mulf %63, %35 : f32 + %65 = memref.load %arg3[%c0, %arg7, %37, %38] : memref + %66 = arith.addf %65, %64 : f32 + memref.store %66, %arg3[%c0, %arg7, %37, %38] : memref + scf.yield %62 : f32 + } else { + scf.yield %cst_2 : f32 + } + %45 = scf.if %27 -> (f32) { + %62 = memref.load %arg0[%c0, %arg7, %37, %39] : memref + %63 = arith.mulf %43, %14 : f32 + %64 = arith.mulf %63, %35 : f32 + %65 = memref.load %arg3[%c0, %arg7, %37, %39] : memref + %66 = arith.addf %65, %64 : f32 + memref.store %66, %arg3[%c0, %arg7, %37, %39] : memref + scf.yield %62 : f32 + } else { + scf.yield %cst_2 : f32 + } + %46 = scf.if %32 -> (f32) { + %62 = memref.load %arg0[%c0, %arg7, %40, %38] : memref + %63 = arith.mulf %43, %36 : f32 + %64 = arith.mulf %63, %16 : f32 + %65 = memref.load %arg3[%c0, %arg7, %40, %38] : memref + %66 = arith.addf %65, %64 : f32 + memref.store %66, %arg3[%c0, %arg7, %40, %38] : memref + scf.yield %62 : f32 + } else { + scf.yield %cst_2 : f32 + } + %47 = scf.if %34 -> (f32) { + %62 = memref.load %arg0[%c0, %arg7, %40, %39] : memref + %63 = arith.mulf %43, %14 : f32 + %64 = arith.mulf %63, %16 : f32 + %65 = memref.load %arg3[%c0, %arg7, %40, %39] : memref + %66 = arith.addf %65, %64 : f32 + memref.store %66, %arg3[%c0, %arg7, %40, %39] : memref + scf.yield %62 : f32 + } else { + scf.yield %cst_2 : f32 + } + %48 = arith.subf %45, %44 : f32 + %49 = arith.mulf %48, %35 : f32 + %50 = arith.subf %47, %46 : f32 + %51 = arith.mulf %50, %16 : f32 + %52 = arith.addf %49, %51 : f32 + %53 = arith.mulf %43, %52 : f32 + %54 = arith.addf %42, %53 : f32 + %55 = arith.subf %46, %44 : f32 + %56 = arith.mulf %55, %36 : f32 + %57 = arith.subf %47, %45 : f32 + %58 = arith.mulf %57, %14 : f32 + %59 = arith.addf %56, %58 : f32 + %60 = arith.mulf %43, %59 : f32 + %61 = arith.addf %41, %60 : f32 + affine.store %61, %alloca[%arg6] : memref + affine.store %54, %alloca_3[%arg6] : memref + } + } + %subview = memref.subview %alloca_3[0] [%c6] [1] : memref to memref> + %subview_4 = memref.subview %arg4[0, %arg5, 0, 0] [1, 1, %c6, 1] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.mulf %in, %cst_0 : f32 + %2 = arith.mulf %1, %cst : f32 + linalg.yield %2 : f32 + } + %subview_5 = memref.subview %alloca[0] [%c6] [1] : memref to memref> + %subview_6 = memref.subview %arg4[0, %arg5, 0, 1] [1, 1, %c6, 1] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_5 : memref>) outs(%subview_6 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.mulf %in, %cst_0 : f32 + %2 = arith.mulf %1, %cst : f32 + linalg.yield %2 : f32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..a351064834dd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu_debuf.mlir @@ -0,0 +1,173 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %c0 = arith.constant 0 : index + %c6 = arith.constant 6 : index + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = "polygeist.memref2pointer"(%arg3) : (memref) -> !llvm.ptr + affine.for %arg5 = 0 to 192 { + %7 = arith.index_cast %arg5 : index to i32 + %8 = llvm.getelementptr %4[%7] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %8 : f32, !llvm.ptr + } + %5 = affine.for %arg5 = 0 to 6 iter_args(%arg6 = %0) -> (tensor) { + %alloca = memref.alloca(%c6) : memref + %7 = bufferization.to_tensor %alloca : memref + %8 = bufferization.to_tensor %alloca : memref + %alloca_3 = memref.alloca(%c6) : memref + %9 = bufferization.to_tensor %alloca_3 : memref + %10 = bufferization.to_tensor %alloca_3 : memref + %11 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%8 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %12 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%10 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %13:2 = affine.for %arg7 = 0 to 6 iter_args(%arg8 = %11, %arg9 = %12) -> (tensor, tensor) { + %extracted = tensor.extract %2[%c0, %arg5, %arg7, %c0] : tensor + %16 = arith.addf %extracted, %cst_0 : f32 + %17 = arith.mulf %16, %cst_1 : f32 + %18 = arith.mulf %17, %cst_2 : f32 + %extracted_8 = tensor.extract %2[%c0, %arg5, %arg7, %c1] : tensor + %19 = arith.addf %extracted_8, %cst_0 : f32 + %20 = arith.mulf %19, %cst_1 : f32 + %21 = arith.mulf %20, %cst_2 : f32 + %22 = arith.fptosi %18 : f32 to i32 + %23 = arith.fptosi %21 : f32 to i32 + %24 = arith.addi %22, %c1_i32 : i32 + %25 = arith.addi %23, %c1_i32 : i32 + %26 = arith.sitofp %22 : i32 to f32 + %27 = arith.subf %18, %26 : f32 + %28 = arith.sitofp %23 : i32 to f32 + %29 = arith.subf %21, %28 : f32 + %30 = arith.cmpi sge, %22, %c0_i32 : i32 + %31 = arith.cmpi slt, %22, %c8_i32 : i32 + %32 = arith.cmpi sge, %23, %c0_i32 : i32 + %33 = arith.cmpi slt, %23, %c8_i32 : i32 + %34 = arith.andi %32, %33 : i1 + %35 = arith.andi %31, %34 : i1 + %36 = arith.andi %30, %35 : i1 + %37 = arith.cmpi sge, %24, %c0_i32 : i32 + %38 = arith.cmpi slt, %24, %c8_i32 : i32 + %39 = arith.andi %38, %34 : i1 + %40 = arith.andi %37, %39 : i1 + %41 = arith.cmpi sge, %25, %c0_i32 : i32 + %42 = arith.cmpi slt, %25, %c8_i32 : i32 + %43 = arith.andi %41, %42 : i1 + %44 = arith.andi %31, %43 : i1 + %45 = arith.andi %30, %44 : i1 + %46 = arith.andi %38, %43 : i1 + %47 = arith.andi %37, %46 : i1 + %48 = arith.subf %cst_0, %29 : f32 + %49 = arith.subf %cst_0, %27 : f32 + %50 = arith.index_cast %23 : i32 to index + %51 = arith.index_cast %22 : i32 to index + %52 = arith.index_cast %24 : i32 to index + %53 = arith.index_cast %25 : i32 to index + %54:2 = affine.for %arg10 = 0 to 3 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (tensor, tensor) { + %extracted_9 = tensor.extract %arg11[%arg7] : tensor + %extracted_10 = tensor.extract %arg12[%arg7] : tensor + %extracted_11 = tensor.extract %1[%c0, %arg10, %arg5, %arg7] : tensor + %55 = scf.if %36 -> (f32) { + %extracted_13 = tensor.extract %3[%c0, %arg10, %50, %51] : tensor + %73 = arith.mulf %extracted_11, %49 : f32 + %74 = arith.mulf %73, %48 : f32 + %75 = memref.load %arg3[%c0, %arg10, %50, %51] : memref + %76 = arith.addf %75, %74 : f32 + memref.store %76, %arg3[%c0, %arg10, %50, %51] : memref + scf.yield %extracted_13 : f32 + } else { + scf.yield %cst : f32 + } + %56 = scf.if %40 -> (f32) { + %extracted_13 = tensor.extract %3[%c0, %arg10, %50, %52] : tensor + %73 = arith.mulf %extracted_11, %27 : f32 + %74 = arith.mulf %73, %48 : f32 + %75 = memref.load %arg3[%c0, %arg10, %50, %52] : memref + %76 = arith.addf %75, %74 : f32 + memref.store %76, %arg3[%c0, %arg10, %50, %52] : memref + scf.yield %extracted_13 : f32 + } else { + scf.yield %cst : f32 + } + %57 = scf.if %45 -> (f32) { + %extracted_13 = tensor.extract %3[%c0, %arg10, %53, %51] : tensor + %73 = arith.mulf %extracted_11, %49 : f32 + %74 = arith.mulf %73, %29 : f32 + %75 = memref.load %arg3[%c0, %arg10, %53, %51] : memref + %76 = arith.addf %75, %74 : f32 + memref.store %76, %arg3[%c0, %arg10, %53, %51] : memref + scf.yield %extracted_13 : f32 + } else { + scf.yield %cst : f32 + } + %58 = scf.if %47 -> (f32) { + %extracted_13 = tensor.extract %3[%c0, %arg10, %53, %52] : tensor + %73 = arith.mulf %extracted_11, %27 : f32 + %74 = arith.mulf %73, %29 : f32 + %75 = memref.load %arg3[%c0, %arg10, %53, %52] : memref + %76 = arith.addf %75, %74 : f32 + memref.store %76, %arg3[%c0, %arg10, %53, %52] : memref + scf.yield %extracted_13 : f32 + } else { + scf.yield %cst : f32 + } + %59 = arith.subf %56, %55 : f32 + %60 = arith.mulf %59, %48 : f32 + %61 = arith.subf %58, %57 : f32 + %62 = arith.mulf %61, %29 : f32 + %63 = arith.addf %60, %62 : f32 + %64 = arith.mulf %extracted_11, %63 : f32 + %65 = arith.addf %extracted_10, %64 : f32 + %66 = arith.subf %57, %55 : f32 + %67 = arith.mulf %66, %49 : f32 + %68 = arith.subf %58, %56 : f32 + %69 = arith.mulf %68, %27 : f32 + %70 = arith.addf %67, %69 : f32 + %71 = arith.mulf %extracted_11, %70 : f32 + %72 = arith.addf %extracted_9, %71 : f32 + %inserted = tensor.insert %72 into %arg11[%arg7] : tensor + %inserted_12 = tensor.insert %65 into %arg12[%arg7] : tensor + affine.yield %inserted, %inserted_12 : tensor, tensor + } + affine.yield %54#0, %54#1 : tensor, tensor + } + %extracted_slice = tensor.extract_slice %arg6[0, %arg5, 0, 0] [1, 1, %c6, 1] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %9[0] [%c6] [1] : tensor to tensor + %14 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_4 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %16 = arith.mulf %in, %cst_1 : f32 + %17 = arith.mulf %16, %cst_2 : f32 + linalg.yield %17 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %14 into %arg6[0, %arg5, 0, 0] [1, 1, %c6, 1] [1, 1, 1, 1] : tensor into tensor + %extracted_slice_5 = tensor.extract_slice %inserted_slice[0, %arg5, 0, 1] [1, 1, %c6, 1] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %7[0] [%c6] [1] : tensor to tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_6 : tensor) outs(%extracted_slice_5 : tensor) { + ^bb0(%in: f32, %out: f32): + %16 = arith.mulf %in, %cst_1 : f32 + %17 = arith.mulf %16, %cst_2 : f32 + linalg.yield %17 : f32 + } -> tensor + %inserted_slice_7 = tensor.insert_slice %15 into %inserted_slice[0, %arg5, 0, 1] [1, 1, %c6, 1] [1, 1, 1, 1] : tensor into tensor + affine.yield %inserted_slice_7 : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..e5a219c6974d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_backward_cpu_linalg.mlir @@ -0,0 +1,157 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c6 = arith.constant 6 : index + %c0 = arith.constant 0 : index + %cst = arith.constant 7.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = "polygeist.memref2pointer"(%arg3) : (memref) -> !llvm.ptr + affine.for %arg5 = 0 to 192 { + %1 = arith.index_cast %arg5 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_2, %2 : f32, !llvm.ptr + } + affine.for %arg5 = 0 to 6 { + %alloca = memref.alloca(%c6) : memref + %alloca_3 = memref.alloca(%c6) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst_2 : f32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_3 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_2 : f32 + } + affine.for %arg6 = 0 to 6 { + %1 = affine.load %arg1[0, %arg5, %arg6, 0] : memref + %2 = arith.addf %1, %cst_1 : f32 + %3 = arith.mulf %2, %cst_0 : f32 + %4 = arith.mulf %3, %cst : f32 + %5 = affine.load %arg1[0, %arg5, %arg6, 1] : memref + %6 = arith.addf %5, %cst_1 : f32 + %7 = arith.mulf %6, %cst_0 : f32 + %8 = arith.mulf %7, %cst : f32 + %9 = arith.fptosi %4 : f32 to i32 + %10 = arith.fptosi %8 : f32 to i32 + %11 = arith.addi %9, %c1_i32 : i32 + %12 = arith.addi %10, %c1_i32 : i32 + %13 = arith.sitofp %9 : i32 to f32 + %14 = arith.subf %4, %13 : f32 + %15 = arith.sitofp %10 : i32 to f32 + %16 = arith.subf %8, %15 : f32 + %17 = arith.cmpi sge, %9, %c0_i32 : i32 + %18 = arith.cmpi slt, %9, %c8_i32 : i32 + %19 = arith.cmpi sge, %10, %c0_i32 : i32 + %20 = arith.cmpi slt, %10, %c8_i32 : i32 + %21 = arith.andi %19, %20 : i1 + %22 = arith.andi %18, %21 : i1 + %23 = arith.andi %17, %22 : i1 + %24 = arith.cmpi sge, %11, %c0_i32 : i32 + %25 = arith.cmpi slt, %11, %c8_i32 : i32 + %26 = arith.andi %25, %21 : i1 + %27 = arith.andi %24, %26 : i1 + %28 = arith.cmpi sge, %12, %c0_i32 : i32 + %29 = arith.cmpi slt, %12, %c8_i32 : i32 + %30 = arith.andi %28, %29 : i1 + %31 = arith.andi %18, %30 : i1 + %32 = arith.andi %17, %31 : i1 + %33 = arith.andi %25, %30 : i1 + %34 = arith.andi %24, %33 : i1 + %35 = arith.subf %cst_1, %16 : f32 + %36 = arith.subf %cst_1, %14 : f32 + %37 = arith.index_cast %10 : i32 to index + %38 = arith.index_cast %9 : i32 to index + %39 = arith.index_cast %11 : i32 to index + %40 = arith.index_cast %12 : i32 to index + affine.for %arg7 = 0 to 3 { + %41 = affine.load %alloca[%arg6] : memref + %42 = affine.load %alloca_3[%arg6] : memref + %43 = affine.load %arg2[0, %arg7, %arg5, %arg6] : memref + %44 = scf.if %23 -> (f32) { + %62 = memref.load %arg0[%c0, %arg7, %37, %38] : memref + %63 = arith.mulf %43, %36 : f32 + %64 = arith.mulf %63, %35 : f32 + %65 = memref.load %arg3[%c0, %arg7, %37, %38] : memref + %66 = arith.addf %65, %64 : f32 + memref.store %66, %arg3[%c0, %arg7, %37, %38] : memref + scf.yield %62 : f32 + } else { + scf.yield %cst_2 : f32 + } + %45 = scf.if %27 -> (f32) { + %62 = memref.load %arg0[%c0, %arg7, %37, %39] : memref + %63 = arith.mulf %43, %14 : f32 + %64 = arith.mulf %63, %35 : f32 + %65 = memref.load %arg3[%c0, %arg7, %37, %39] : memref + %66 = arith.addf %65, %64 : f32 + memref.store %66, %arg3[%c0, %arg7, %37, %39] : memref + scf.yield %62 : f32 + } else { + scf.yield %cst_2 : f32 + } + %46 = scf.if %32 -> (f32) { + %62 = memref.load %arg0[%c0, %arg7, %40, %38] : memref + %63 = arith.mulf %43, %36 : f32 + %64 = arith.mulf %63, %16 : f32 + %65 = memref.load %arg3[%c0, %arg7, %40, %38] : memref + %66 = arith.addf %65, %64 : f32 + memref.store %66, %arg3[%c0, %arg7, %40, %38] : memref + scf.yield %62 : f32 + } else { + scf.yield %cst_2 : f32 + } + %47 = scf.if %34 -> (f32) { + %62 = memref.load %arg0[%c0, %arg7, %40, %39] : memref + %63 = arith.mulf %43, %14 : f32 + %64 = arith.mulf %63, %16 : f32 + %65 = memref.load %arg3[%c0, %arg7, %40, %39] : memref + %66 = arith.addf %65, %64 : f32 + memref.store %66, %arg3[%c0, %arg7, %40, %39] : memref + scf.yield %62 : f32 + } else { + scf.yield %cst_2 : f32 + } + %48 = arith.subf %45, %44 : f32 + %49 = arith.mulf %48, %35 : f32 + %50 = arith.subf %47, %46 : f32 + %51 = arith.mulf %50, %16 : f32 + %52 = arith.addf %49, %51 : f32 + %53 = arith.mulf %43, %52 : f32 + %54 = arith.addf %42, %53 : f32 + %55 = arith.subf %46, %44 : f32 + %56 = arith.mulf %55, %36 : f32 + %57 = arith.subf %47, %45 : f32 + %58 = arith.mulf %57, %14 : f32 + %59 = arith.addf %56, %58 : f32 + %60 = arith.mulf %43, %59 : f32 + %61 = arith.addf %41, %60 : f32 + affine.store %61, %alloca[%arg6] : memref + affine.store %54, %alloca_3[%arg6] : memref + } + } + %subview = memref.subview %alloca_3[0] [%c6] [1] : memref to memref> + %subview_4 = memref.subview %arg4[0, %arg5, 0, 0] [1, 1, %c6, 1] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.mulf %in, %cst_0 : f32 + %2 = arith.mulf %1, %cst : f32 + linalg.yield %2 : f32 + } + %subview_5 = memref.subview %alloca[0] [%c6] [1] : memref to memref> + %subview_6 = memref.subview %arg4[0, %arg5, 0, 1] [1, 1, %c6, 1] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview_5 : memref>) outs(%subview_6 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.mulf %in, %cst_0 : f32 + %2 = arith.mulf %1, %cst : f32 + linalg.yield %2 : f32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu.mlir new file mode 100644 index 000000000000..4c03a34c573a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu.mlir @@ -0,0 +1,96 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 7.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 6 { + affine.for %arg4 = 0 to 6 { + %0 = affine.load %arg1[0, %arg3, %arg4, 0] : memref + %1 = arith.addf %0, %cst_2 : f32 + %2 = arith.mulf %1, %cst_1 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = affine.load %arg1[0, %arg3, %arg4, 1] : memref + %5 = arith.addf %4, %cst_2 : f32 + %6 = arith.mulf %5, %cst_1 : f32 + %7 = arith.mulf %6, %cst : f32 + %8 = arith.fptosi %3 : f32 to i32 + %9 = arith.fptosi %7 : f32 to i32 + %10 = arith.addi %8, %c1_i32 : i32 + %11 = arith.addi %9, %c1_i32 : i32 + %12 = arith.sitofp %8 : i32 to f32 + %13 = arith.subf %3, %12 : f32 + %14 = arith.sitofp %9 : i32 to f32 + %15 = arith.subf %7, %14 : f32 + %16 = arith.cmpi sge, %8, %c0_i32 : i32 + %17 = arith.cmpi slt, %8, %c8_i32 : i32 + %18 = arith.cmpi sge, %9, %c0_i32 : i32 + %19 = arith.cmpi slt, %9, %c8_i32 : i32 + %20 = arith.andi %18, %19 : i1 + %21 = arith.andi %17, %20 : i1 + %22 = arith.andi %16, %21 : i1 + %23 = arith.cmpi sge, %10, %c0_i32 : i32 + %24 = arith.cmpi slt, %10, %c8_i32 : i32 + %25 = arith.andi %24, %20 : i1 + %26 = arith.andi %23, %25 : i1 + %27 = arith.cmpi sge, %11, %c0_i32 : i32 + %28 = arith.cmpi slt, %11, %c8_i32 : i32 + %29 = arith.andi %27, %28 : i1 + %30 = arith.andi %17, %29 : i1 + %31 = arith.andi %16, %30 : i1 + %32 = arith.andi %24, %29 : i1 + %33 = arith.andi %23, %32 : i1 + %34 = arith.subf %cst_2, %13 : f32 + %35 = arith.subf %cst_2, %15 : f32 + %36 = arith.mulf %34, %35 : f32 + %37 = arith.index_cast %9 : i32 to index + %38 = arith.index_cast %8 : i32 to index + %39 = arith.mulf %13, %35 : f32 + %40 = arith.index_cast %10 : i32 to index + %41 = arith.mulf %34, %15 : f32 + %42 = arith.index_cast %11 : i32 to index + %43 = arith.mulf %13, %15 : f32 + affine.for %arg5 = 0 to 3 { + %44 = scf.if %22 -> (f32) { + %48 = memref.load %arg0[%c0, %arg5, %37, %38] : memref + %49 = arith.mulf %36, %48 : f32 + %50 = arith.addf %49, %cst_0 : f32 + scf.yield %50 : f32 + } else { + scf.yield %cst_0 : f32 + } + %45 = scf.if %26 -> (f32) { + %48 = memref.load %arg0[%c0, %arg5, %37, %40] : memref + %49 = arith.mulf %39, %48 : f32 + %50 = arith.addf %44, %49 : f32 + scf.yield %50 : f32 + } else { + scf.yield %44 : f32 + } + %46 = scf.if %31 -> (f32) { + %48 = memref.load %arg0[%c0, %arg5, %42, %38] : memref + %49 = arith.mulf %41, %48 : f32 + %50 = arith.addf %45, %49 : f32 + scf.yield %50 : f32 + } else { + scf.yield %45 : f32 + } + %47 = scf.if %33 -> (f32) { + %48 = memref.load %arg0[%c0, %arg5, %42, %40] : memref + %49 = arith.mulf %43, %48 : f32 + %50 = arith.addf %46, %49 : f32 + scf.yield %50 : f32 + } else { + scf.yield %46 : f32 + } + affine.store %47, %arg2[0, %arg5, %arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu/debuf.mlir new file mode 100644 index 000000000000..4af697880a6a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu/debuf.mlir @@ -0,0 +1,89 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %c3 = arith.constant 3 : index + %c0 = arith.constant 0 : index + %c6 = arith.constant 6 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0] [1, %c3, %c6, %c6] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[0, 0, 0, 0] [1, %c6, %c6, 1] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %0[0, 0, 0, 1] [1, %c6, %c6, 1] [1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_3, %extracted_slice_4 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %4 = arith.addf %in, %cst : f32 + %5 = arith.mulf %4, %cst_0 : f32 + %6 = arith.mulf %5, %cst_2 : f32 + %7 = arith.addf %in_5, %cst : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.mulf %8, %cst_2 : f32 + %10 = arith.fptosi %6 : f32 to i32 + %11 = arith.fptosi %9 : f32 to i32 + %12 = arith.addi %10, %c1_i32 : i32 + %13 = arith.addi %11, %c1_i32 : i32 + %14 = arith.sitofp %10 : i32 to f32 + %15 = arith.subf %6, %14 : f32 + %16 = arith.sitofp %11 : i32 to f32 + %17 = arith.subf %9, %16 : f32 + %18 = arith.cmpi sge, %10, %c0_i32 : i32 + %19 = arith.cmpi slt, %10, %c8_i32 : i32 + %20 = arith.cmpi sge, %11, %c0_i32 : i32 + %21 = arith.cmpi slt, %11, %c8_i32 : i32 + %22 = arith.andi %20, %21 : i1 + %23 = arith.andi %19, %22 : i1 + %24 = arith.andi %18, %23 : i1 + %25 = arith.cmpi sge, %12, %c0_i32 : i32 + %26 = arith.cmpi slt, %12, %c8_i32 : i32 + %27 = arith.andi %26, %22 : i1 + %28 = arith.andi %25, %27 : i1 + %29 = arith.cmpi sge, %13, %c0_i32 : i32 + %30 = arith.cmpi slt, %13, %c8_i32 : i32 + %31 = arith.andi %29, %30 : i1 + %32 = arith.andi %19, %31 : i1 + %33 = arith.andi %18, %32 : i1 + %34 = arith.andi %26, %31 : i1 + %35 = arith.andi %25, %34 : i1 + %36 = arith.subf %cst, %15 : f32 + %37 = arith.subf %cst, %17 : f32 + %38 = arith.mulf %36, %37 : f32 + %39 = arith.index_cast %11 : i32 to index + %40 = arith.index_cast %10 : i32 to index + %41 = arith.mulf %15, %37 : f32 + %42 = arith.index_cast %12 : i32 to index + %43 = arith.mulf %36, %17 : f32 + %44 = arith.index_cast %13 : i32 to index + %45 = arith.mulf %15, %17 : f32 + %46 = linalg.index 2 : index + %47 = memref.load %arg0[%c0, %46, %39, %40] : memref + %48 = arith.mulf %38, %47 : f32 + %49 = arith.addf %48, %cst_1 : f32 + %50 = arith.select %24, %49, %cst_1 : f32 + %51 = memref.load %arg0[%c0, %46, %39, %42] : memref + %52 = arith.mulf %41, %51 : f32 + %53 = arith.addf %50, %52 : f32 + %54 = arith.select %28, %53, %50 : f32 + %55 = memref.load %arg0[%c0, %46, %44, %40] : memref + %56 = arith.mulf %43, %55 : f32 + %57 = arith.addf %54, %56 : f32 + %58 = arith.select %33, %57, %54 : f32 + %59 = memref.load %arg0[%c0, %46, %44, %42] : memref + %60 = arith.mulf %45, %59 : f32 + %61 = arith.addf %58, %60 : f32 + %62 = arith.select %35, %61, %58 : f32 + linalg.yield %62 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0, 0, 0] [1, %c3, %c6, %c6] [1, 1, 1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu/matched.mlir new file mode 100644 index 000000000000..4af697880a6a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu/matched.mlir @@ -0,0 +1,89 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %c3 = arith.constant 3 : index + %c0 = arith.constant 0 : index + %c6 = arith.constant 6 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0] [1, %c3, %c6, %c6] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[0, 0, 0, 0] [1, %c6, %c6, 1] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %0[0, 0, 0, 1] [1, %c6, %c6, 1] [1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_3, %extracted_slice_4 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %4 = arith.addf %in, %cst : f32 + %5 = arith.mulf %4, %cst_0 : f32 + %6 = arith.mulf %5, %cst_2 : f32 + %7 = arith.addf %in_5, %cst : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.mulf %8, %cst_2 : f32 + %10 = arith.fptosi %6 : f32 to i32 + %11 = arith.fptosi %9 : f32 to i32 + %12 = arith.addi %10, %c1_i32 : i32 + %13 = arith.addi %11, %c1_i32 : i32 + %14 = arith.sitofp %10 : i32 to f32 + %15 = arith.subf %6, %14 : f32 + %16 = arith.sitofp %11 : i32 to f32 + %17 = arith.subf %9, %16 : f32 + %18 = arith.cmpi sge, %10, %c0_i32 : i32 + %19 = arith.cmpi slt, %10, %c8_i32 : i32 + %20 = arith.cmpi sge, %11, %c0_i32 : i32 + %21 = arith.cmpi slt, %11, %c8_i32 : i32 + %22 = arith.andi %20, %21 : i1 + %23 = arith.andi %19, %22 : i1 + %24 = arith.andi %18, %23 : i1 + %25 = arith.cmpi sge, %12, %c0_i32 : i32 + %26 = arith.cmpi slt, %12, %c8_i32 : i32 + %27 = arith.andi %26, %22 : i1 + %28 = arith.andi %25, %27 : i1 + %29 = arith.cmpi sge, %13, %c0_i32 : i32 + %30 = arith.cmpi slt, %13, %c8_i32 : i32 + %31 = arith.andi %29, %30 : i1 + %32 = arith.andi %19, %31 : i1 + %33 = arith.andi %18, %32 : i1 + %34 = arith.andi %26, %31 : i1 + %35 = arith.andi %25, %34 : i1 + %36 = arith.subf %cst, %15 : f32 + %37 = arith.subf %cst, %17 : f32 + %38 = arith.mulf %36, %37 : f32 + %39 = arith.index_cast %11 : i32 to index + %40 = arith.index_cast %10 : i32 to index + %41 = arith.mulf %15, %37 : f32 + %42 = arith.index_cast %12 : i32 to index + %43 = arith.mulf %36, %17 : f32 + %44 = arith.index_cast %13 : i32 to index + %45 = arith.mulf %15, %17 : f32 + %46 = linalg.index 2 : index + %47 = memref.load %arg0[%c0, %46, %39, %40] : memref + %48 = arith.mulf %38, %47 : f32 + %49 = arith.addf %48, %cst_1 : f32 + %50 = arith.select %24, %49, %cst_1 : f32 + %51 = memref.load %arg0[%c0, %46, %39, %42] : memref + %52 = arith.mulf %41, %51 : f32 + %53 = arith.addf %50, %52 : f32 + %54 = arith.select %28, %53, %50 : f32 + %55 = memref.load %arg0[%c0, %46, %44, %40] : memref + %56 = arith.mulf %43, %55 : f32 + %57 = arith.addf %54, %56 : f32 + %58 = arith.select %33, %57, %54 : f32 + %59 = memref.load %arg0[%c0, %46, %44, %42] : memref + %60 = arith.mulf %45, %59 : f32 + %61 = arith.addf %58, %60 : f32 + %62 = arith.select %35, %61, %58 : f32 + linalg.yield %62 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0, 0, 0] [1, %c3, %c6, %c6] [1, 1, 1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu/orig.mlir new file mode 100644 index 000000000000..4c03a34c573a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu/orig.mlir @@ -0,0 +1,96 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 7.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 6 { + affine.for %arg4 = 0 to 6 { + %0 = affine.load %arg1[0, %arg3, %arg4, 0] : memref + %1 = arith.addf %0, %cst_2 : f32 + %2 = arith.mulf %1, %cst_1 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = affine.load %arg1[0, %arg3, %arg4, 1] : memref + %5 = arith.addf %4, %cst_2 : f32 + %6 = arith.mulf %5, %cst_1 : f32 + %7 = arith.mulf %6, %cst : f32 + %8 = arith.fptosi %3 : f32 to i32 + %9 = arith.fptosi %7 : f32 to i32 + %10 = arith.addi %8, %c1_i32 : i32 + %11 = arith.addi %9, %c1_i32 : i32 + %12 = arith.sitofp %8 : i32 to f32 + %13 = arith.subf %3, %12 : f32 + %14 = arith.sitofp %9 : i32 to f32 + %15 = arith.subf %7, %14 : f32 + %16 = arith.cmpi sge, %8, %c0_i32 : i32 + %17 = arith.cmpi slt, %8, %c8_i32 : i32 + %18 = arith.cmpi sge, %9, %c0_i32 : i32 + %19 = arith.cmpi slt, %9, %c8_i32 : i32 + %20 = arith.andi %18, %19 : i1 + %21 = arith.andi %17, %20 : i1 + %22 = arith.andi %16, %21 : i1 + %23 = arith.cmpi sge, %10, %c0_i32 : i32 + %24 = arith.cmpi slt, %10, %c8_i32 : i32 + %25 = arith.andi %24, %20 : i1 + %26 = arith.andi %23, %25 : i1 + %27 = arith.cmpi sge, %11, %c0_i32 : i32 + %28 = arith.cmpi slt, %11, %c8_i32 : i32 + %29 = arith.andi %27, %28 : i1 + %30 = arith.andi %17, %29 : i1 + %31 = arith.andi %16, %30 : i1 + %32 = arith.andi %24, %29 : i1 + %33 = arith.andi %23, %32 : i1 + %34 = arith.subf %cst_2, %13 : f32 + %35 = arith.subf %cst_2, %15 : f32 + %36 = arith.mulf %34, %35 : f32 + %37 = arith.index_cast %9 : i32 to index + %38 = arith.index_cast %8 : i32 to index + %39 = arith.mulf %13, %35 : f32 + %40 = arith.index_cast %10 : i32 to index + %41 = arith.mulf %34, %15 : f32 + %42 = arith.index_cast %11 : i32 to index + %43 = arith.mulf %13, %15 : f32 + affine.for %arg5 = 0 to 3 { + %44 = scf.if %22 -> (f32) { + %48 = memref.load %arg0[%c0, %arg5, %37, %38] : memref + %49 = arith.mulf %36, %48 : f32 + %50 = arith.addf %49, %cst_0 : f32 + scf.yield %50 : f32 + } else { + scf.yield %cst_0 : f32 + } + %45 = scf.if %26 -> (f32) { + %48 = memref.load %arg0[%c0, %arg5, %37, %40] : memref + %49 = arith.mulf %39, %48 : f32 + %50 = arith.addf %44, %49 : f32 + scf.yield %50 : f32 + } else { + scf.yield %44 : f32 + } + %46 = scf.if %31 -> (f32) { + %48 = memref.load %arg0[%c0, %arg5, %42, %38] : memref + %49 = arith.mulf %41, %48 : f32 + %50 = arith.addf %45, %49 : f32 + scf.yield %50 : f32 + } else { + scf.yield %45 : f32 + } + %47 = scf.if %33 -> (f32) { + %48 = memref.load %arg0[%c0, %arg5, %42, %40] : memref + %49 = arith.mulf %43, %48 : f32 + %50 = arith.addf %46, %49 : f32 + scf.yield %50 : f32 + } else { + scf.yield %46 : f32 + } + affine.store %47, %arg2[0, %arg5, %arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu/raised.mlir new file mode 100644 index 000000000000..b2ff378548fe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu/raised.mlir @@ -0,0 +1,84 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c6 = arith.constant 6 : index + %c0 = arith.constant 0 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 7.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg1[0, 0, 0, 0] [1, %c6, %c6, 1] [1, 1, 1, 1] : memref to memref> + %subview_3 = memref.subview %arg1[0, 0, 0, 1] [1, %c6, %c6, 1] [1, 1, 1, 1] : memref to memref> + %subview_4 = memref.subview %arg2[0, 0, 0, 0] [1, %c3, %c6, %c6] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview, %subview_3 : memref>, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %0 = arith.addf %in, %cst_2 : f32 + %1 = arith.mulf %0, %cst_1 : f32 + %2 = arith.mulf %1, %cst : f32 + %3 = arith.addf %in_5, %cst_2 : f32 + %4 = arith.mulf %3, %cst_1 : f32 + %5 = arith.mulf %4, %cst : f32 + %6 = arith.fptosi %2 : f32 to i32 + %7 = arith.fptosi %5 : f32 to i32 + %8 = arith.addi %6, %c1_i32 : i32 + %9 = arith.addi %7, %c1_i32 : i32 + %10 = arith.sitofp %6 : i32 to f32 + %11 = arith.subf %2, %10 : f32 + %12 = arith.sitofp %7 : i32 to f32 + %13 = arith.subf %5, %12 : f32 + %14 = arith.cmpi sge, %6, %c0_i32 : i32 + %15 = arith.cmpi slt, %6, %c8_i32 : i32 + %16 = arith.cmpi sge, %7, %c0_i32 : i32 + %17 = arith.cmpi slt, %7, %c8_i32 : i32 + %18 = arith.andi %16, %17 : i1 + %19 = arith.andi %15, %18 : i1 + %20 = arith.andi %14, %19 : i1 + %21 = arith.cmpi sge, %8, %c0_i32 : i32 + %22 = arith.cmpi slt, %8, %c8_i32 : i32 + %23 = arith.andi %22, %18 : i1 + %24 = arith.andi %21, %23 : i1 + %25 = arith.cmpi sge, %9, %c0_i32 : i32 + %26 = arith.cmpi slt, %9, %c8_i32 : i32 + %27 = arith.andi %25, %26 : i1 + %28 = arith.andi %15, %27 : i1 + %29 = arith.andi %14, %28 : i1 + %30 = arith.andi %22, %27 : i1 + %31 = arith.andi %21, %30 : i1 + %32 = arith.subf %cst_2, %11 : f32 + %33 = arith.subf %cst_2, %13 : f32 + %34 = arith.mulf %32, %33 : f32 + %35 = arith.index_cast %7 : i32 to index + %36 = arith.index_cast %6 : i32 to index + %37 = arith.mulf %11, %33 : f32 + %38 = arith.index_cast %8 : i32 to index + %39 = arith.mulf %32, %13 : f32 + %40 = arith.index_cast %9 : i32 to index + %41 = arith.mulf %11, %13 : f32 + %42 = linalg.index 2 : index + %43 = memref.load %arg0[%c0, %42, %35, %36] : memref + %44 = arith.mulf %34, %43 : f32 + %45 = arith.addf %44, %cst_0 : f32 + %46 = arith.select %20, %45, %cst_0 : f32 + %47 = memref.load %arg0[%c0, %42, %35, %38] : memref + %48 = arith.mulf %37, %47 : f32 + %49 = arith.addf %46, %48 : f32 + %50 = arith.select %24, %49, %46 : f32 + %51 = memref.load %arg0[%c0, %42, %40, %36] : memref + %52 = arith.mulf %39, %51 : f32 + %53 = arith.addf %50, %52 : f32 + %54 = arith.select %29, %53, %50 : f32 + %55 = memref.load %arg0[%c0, %42, %40, %38] : memref + %56 = arith.mulf %41, %55 : f32 + %57 = arith.addf %54, %56 : f32 + %58 = arith.select %31, %57, %54 : f32 + linalg.yield %58 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu_debuf.mlir new file mode 100644 index 000000000000..4af697880a6a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu_debuf.mlir @@ -0,0 +1,89 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %c3 = arith.constant 3 : index + %c0 = arith.constant 0 : index + %c6 = arith.constant 6 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0] [1, %c3, %c6, %c6] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[0, 0, 0, 0] [1, %c6, %c6, 1] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %0[0, 0, 0, 1] [1, %c6, %c6, 1] [1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_3, %extracted_slice_4 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %4 = arith.addf %in, %cst : f32 + %5 = arith.mulf %4, %cst_0 : f32 + %6 = arith.mulf %5, %cst_2 : f32 + %7 = arith.addf %in_5, %cst : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.mulf %8, %cst_2 : f32 + %10 = arith.fptosi %6 : f32 to i32 + %11 = arith.fptosi %9 : f32 to i32 + %12 = arith.addi %10, %c1_i32 : i32 + %13 = arith.addi %11, %c1_i32 : i32 + %14 = arith.sitofp %10 : i32 to f32 + %15 = arith.subf %6, %14 : f32 + %16 = arith.sitofp %11 : i32 to f32 + %17 = arith.subf %9, %16 : f32 + %18 = arith.cmpi sge, %10, %c0_i32 : i32 + %19 = arith.cmpi slt, %10, %c8_i32 : i32 + %20 = arith.cmpi sge, %11, %c0_i32 : i32 + %21 = arith.cmpi slt, %11, %c8_i32 : i32 + %22 = arith.andi %20, %21 : i1 + %23 = arith.andi %19, %22 : i1 + %24 = arith.andi %18, %23 : i1 + %25 = arith.cmpi sge, %12, %c0_i32 : i32 + %26 = arith.cmpi slt, %12, %c8_i32 : i32 + %27 = arith.andi %26, %22 : i1 + %28 = arith.andi %25, %27 : i1 + %29 = arith.cmpi sge, %13, %c0_i32 : i32 + %30 = arith.cmpi slt, %13, %c8_i32 : i32 + %31 = arith.andi %29, %30 : i1 + %32 = arith.andi %19, %31 : i1 + %33 = arith.andi %18, %32 : i1 + %34 = arith.andi %26, %31 : i1 + %35 = arith.andi %25, %34 : i1 + %36 = arith.subf %cst, %15 : f32 + %37 = arith.subf %cst, %17 : f32 + %38 = arith.mulf %36, %37 : f32 + %39 = arith.index_cast %11 : i32 to index + %40 = arith.index_cast %10 : i32 to index + %41 = arith.mulf %15, %37 : f32 + %42 = arith.index_cast %12 : i32 to index + %43 = arith.mulf %36, %17 : f32 + %44 = arith.index_cast %13 : i32 to index + %45 = arith.mulf %15, %17 : f32 + %46 = linalg.index 2 : index + %47 = memref.load %arg0[%c0, %46, %39, %40] : memref + %48 = arith.mulf %38, %47 : f32 + %49 = arith.addf %48, %cst_1 : f32 + %50 = arith.select %24, %49, %cst_1 : f32 + %51 = memref.load %arg0[%c0, %46, %39, %42] : memref + %52 = arith.mulf %41, %51 : f32 + %53 = arith.addf %50, %52 : f32 + %54 = arith.select %28, %53, %50 : f32 + %55 = memref.load %arg0[%c0, %46, %44, %40] : memref + %56 = arith.mulf %43, %55 : f32 + %57 = arith.addf %54, %56 : f32 + %58 = arith.select %33, %57, %54 : f32 + %59 = memref.load %arg0[%c0, %46, %44, %42] : memref + %60 = arith.mulf %45, %59 : f32 + %61 = arith.addf %58, %60 : f32 + %62 = arith.select %35, %61, %58 : f32 + linalg.yield %62 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0, 0, 0] [1, %c3, %c6, %c6] [1, 1, 1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu_linalg.mlir new file mode 100644 index 000000000000..b2ff378548fe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_cpu_linalg.mlir @@ -0,0 +1,84 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c6 = arith.constant 6 : index + %c0 = arith.constant 0 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 7.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg1[0, 0, 0, 0] [1, %c6, %c6, 1] [1, 1, 1, 1] : memref to memref> + %subview_3 = memref.subview %arg1[0, 0, 0, 1] [1, %c6, %c6, 1] [1, 1, 1, 1] : memref to memref> + %subview_4 = memref.subview %arg2[0, 0, 0, 0] [1, %c3, %c6, %c6] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview, %subview_3 : memref>, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %0 = arith.addf %in, %cst_2 : f32 + %1 = arith.mulf %0, %cst_1 : f32 + %2 = arith.mulf %1, %cst : f32 + %3 = arith.addf %in_5, %cst_2 : f32 + %4 = arith.mulf %3, %cst_1 : f32 + %5 = arith.mulf %4, %cst : f32 + %6 = arith.fptosi %2 : f32 to i32 + %7 = arith.fptosi %5 : f32 to i32 + %8 = arith.addi %6, %c1_i32 : i32 + %9 = arith.addi %7, %c1_i32 : i32 + %10 = arith.sitofp %6 : i32 to f32 + %11 = arith.subf %2, %10 : f32 + %12 = arith.sitofp %7 : i32 to f32 + %13 = arith.subf %5, %12 : f32 + %14 = arith.cmpi sge, %6, %c0_i32 : i32 + %15 = arith.cmpi slt, %6, %c8_i32 : i32 + %16 = arith.cmpi sge, %7, %c0_i32 : i32 + %17 = arith.cmpi slt, %7, %c8_i32 : i32 + %18 = arith.andi %16, %17 : i1 + %19 = arith.andi %15, %18 : i1 + %20 = arith.andi %14, %19 : i1 + %21 = arith.cmpi sge, %8, %c0_i32 : i32 + %22 = arith.cmpi slt, %8, %c8_i32 : i32 + %23 = arith.andi %22, %18 : i1 + %24 = arith.andi %21, %23 : i1 + %25 = arith.cmpi sge, %9, %c0_i32 : i32 + %26 = arith.cmpi slt, %9, %c8_i32 : i32 + %27 = arith.andi %25, %26 : i1 + %28 = arith.andi %15, %27 : i1 + %29 = arith.andi %14, %28 : i1 + %30 = arith.andi %22, %27 : i1 + %31 = arith.andi %21, %30 : i1 + %32 = arith.subf %cst_2, %11 : f32 + %33 = arith.subf %cst_2, %13 : f32 + %34 = arith.mulf %32, %33 : f32 + %35 = arith.index_cast %7 : i32 to index + %36 = arith.index_cast %6 : i32 to index + %37 = arith.mulf %11, %33 : f32 + %38 = arith.index_cast %8 : i32 to index + %39 = arith.mulf %32, %13 : f32 + %40 = arith.index_cast %9 : i32 to index + %41 = arith.mulf %11, %13 : f32 + %42 = linalg.index 2 : index + %43 = memref.load %arg0[%c0, %42, %35, %36] : memref + %44 = arith.mulf %34, %43 : f32 + %45 = arith.addf %44, %cst_0 : f32 + %46 = arith.select %20, %45, %cst_0 : f32 + %47 = memref.load %arg0[%c0, %42, %35, %38] : memref + %48 = arith.mulf %37, %47 : f32 + %49 = arith.addf %46, %48 : f32 + %50 = arith.select %24, %49, %46 : f32 + %51 = memref.load %arg0[%c0, %42, %40, %36] : memref + %52 = arith.mulf %39, %51 : f32 + %53 = arith.addf %50, %52 : f32 + %54 = arith.select %29, %53, %50 : f32 + %55 = memref.load %arg0[%c0, %42, %40, %38] : memref + %56 = arith.mulf %41, %55 : f32 + %57 = arith.addf %54, %56 : f32 + %58 = arith.select %31, %57, %54 : f32 + linalg.yield %58 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu.mlir new file mode 100644 index 000000000000..181213094381 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_fallback_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 256 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.cmpi sge, %0, %c0_i32 : i32 + %2 = scf.if %1 -> (f32) { + %3 = arith.index_cast %0 : i32 to index + %4 = memref.load %arg0[%3] : memref + scf.yield %4 : f32 + } else { + scf.yield %cst : f32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu/debuf.mlir new file mode 100644 index 000000000000..f28ecf3e470e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_fallback_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.cmpi sge, %4, %c0_i32 : i32 + %6 = arith.index_cast %4 : i32 to index + %7 = memref.load %arg0[%6] : memref + %8 = arith.select %5, %7, %cst : f32 + linalg.yield %8 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu/matched.mlir new file mode 100644 index 000000000000..f28ecf3e470e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_fallback_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.cmpi sge, %4, %c0_i32 : i32 + %6 = arith.index_cast %4 : i32 to index + %7 = memref.load %arg0[%6] : memref + %8 = arith.select %5, %7, %cst : f32 + linalg.yield %8 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu/orig.mlir new file mode 100644 index 000000000000..181213094381 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu/orig.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_fallback_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 256 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.cmpi sge, %0, %c0_i32 : i32 + %2 = scf.if %1 -> (f32) { + %3 = arith.index_cast %0 : i32 to index + %4 = memref.load %arg0[%3] : memref + scf.yield %4 : f32 + } else { + scf.yield %cst : f32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu/raised.mlir new file mode 100644 index 000000000000..331e2426aeda --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_fallback_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg1[%0] : memref + %2 = arith.cmpi sge, %1, %c0_i32 : i32 + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%3] : memref + %5 = arith.select %2, %4, %cst : f32 + linalg.yield %5 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu_debuf.mlir new file mode 100644 index 000000000000..f28ecf3e470e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_fallback_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.cmpi sge, %4, %c0_i32 : i32 + %6 = arith.index_cast %4 : i32 to index + %7 = memref.load %arg0[%6] : memref + %8 = arith.select %5, %7, %cst : f32 + linalg.yield %8 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu_linalg.mlir new file mode 100644 index 000000000000..331e2426aeda --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_fallback_cpu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_fallback_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg1[%0] : memref + %2 = arith.cmpi sge, %1, %c0_i32 : i32 + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%3] : memref + %5 = arith.select %2, %4, %cst : f32 + linalg.yield %5 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu.mlir new file mode 100644 index 000000000000..d21798348047 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_quantized_cpu(%arg0: memref, %arg1: f32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %c255_i32 = arith.constant 255 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 256 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.extui %0 : i8 to i32 + %2 = arith.subi %1, %arg2 : i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.mulf %3, %arg1 : f32 + %5 = arith.divf %4, %arg1 : f32 + %6 = arith.fptosi %5 : f32 to i32 + %7 = arith.addi %6, %arg2 : i32 + %8 = arith.cmpi slt, %7, %c0_i32 : i32 + %9 = arith.select %8, %c0_i32, %7 : i32 + %10 = scf.if %8 -> (i1) { + scf.yield %false : i1 + } else { + %13 = arith.cmpi sgt, %7, %c255_i32 : i32 + scf.yield %13 : i1 + } + %11 = arith.select %10, %c255_i32, %9 : i32 + %12 = arith.trunci %11 : i32 to i8 + affine.store %12, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu/debuf.mlir new file mode 100644 index 000000000000..bf85e9cd6956 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu/debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_quantized_cpu(%arg0: memref, %arg1: f32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c255_i32 = arith.constant 255 : i32 + %false = arith.constant false + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i8, %out: i8): + %4 = arith.extui %in : i8 to i32 + %5 = arith.subi %4, %arg2 : i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.mulf %6, %arg1 : f32 + %8 = arith.divf %7, %arg1 : f32 + %9 = arith.fptosi %8 : f32 to i32 + %10 = arith.addi %9, %arg2 : i32 + %11 = arith.cmpi slt, %10, %c0_i32 : i32 + %12 = arith.select %11, %c0_i32, %10 : i32 + %13 = arith.cmpi sgt, %10, %c255_i32 : i32 + %14 = arith.select %11, %false, %13 : i1 + %15 = arith.select %14, %c255_i32, %12 : i32 + %16 = arith.trunci %15 : i32 to i8 + linalg.yield %16 : i8 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu/matched.mlir new file mode 100644 index 000000000000..bf85e9cd6956 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu/matched.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_quantized_cpu(%arg0: memref, %arg1: f32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c255_i32 = arith.constant 255 : i32 + %false = arith.constant false + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i8, %out: i8): + %4 = arith.extui %in : i8 to i32 + %5 = arith.subi %4, %arg2 : i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.mulf %6, %arg1 : f32 + %8 = arith.divf %7, %arg1 : f32 + %9 = arith.fptosi %8 : f32 to i32 + %10 = arith.addi %9, %arg2 : i32 + %11 = arith.cmpi slt, %10, %c0_i32 : i32 + %12 = arith.select %11, %c0_i32, %10 : i32 + %13 = arith.cmpi sgt, %10, %c255_i32 : i32 + %14 = arith.select %11, %false, %13 : i1 + %15 = arith.select %14, %c255_i32, %12 : i32 + %16 = arith.trunci %15 : i32 to i8 + linalg.yield %16 : i8 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu/orig.mlir new file mode 100644 index 000000000000..d21798348047 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu/orig.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_quantized_cpu(%arg0: memref, %arg1: f32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %c255_i32 = arith.constant 255 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 256 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.extui %0 : i8 to i32 + %2 = arith.subi %1, %arg2 : i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.mulf %3, %arg1 : f32 + %5 = arith.divf %4, %arg1 : f32 + %6 = arith.fptosi %5 : f32 to i32 + %7 = arith.addi %6, %arg2 : i32 + %8 = arith.cmpi slt, %7, %c0_i32 : i32 + %9 = arith.select %8, %c0_i32, %7 : i32 + %10 = scf.if %8 -> (i1) { + scf.yield %false : i1 + } else { + %13 = arith.cmpi sgt, %7, %c255_i32 : i32 + scf.yield %13 : i1 + } + %11 = arith.select %10, %c255_i32, %9 : i32 + %12 = arith.trunci %11 : i32 to i8 + affine.store %12, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu/raised.mlir new file mode 100644 index 000000000000..efa1b0fbabfe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu/raised.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_quantized_cpu(%arg0: memref, %arg1: f32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %c255_i32 = arith.constant 255 : i32 + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg3 : memref) { + ^bb0(%in: i8, %out: i8): + %0 = arith.extui %in : i8 to i32 + %1 = arith.subi %0, %arg2 : i32 + %2 = arith.sitofp %1 : i32 to f32 + %3 = arith.mulf %2, %arg1 : f32 + %4 = arith.divf %3, %arg1 : f32 + %5 = arith.fptosi %4 : f32 to i32 + %6 = arith.addi %5, %arg2 : i32 + %7 = arith.cmpi slt, %6, %c0_i32 : i32 + %8 = arith.select %7, %c0_i32, %6 : i32 + %9 = arith.cmpi sgt, %6, %c255_i32 : i32 + %10 = arith.select %7, %false, %9 : i1 + %11 = arith.select %10, %c255_i32, %8 : i32 + %12 = arith.trunci %11 : i32 to i8 + linalg.yield %12 : i8 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu_debuf.mlir new file mode 100644 index 000000000000..bf85e9cd6956 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu_debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_quantized_cpu(%arg0: memref, %arg1: f32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c255_i32 = arith.constant 255 : i32 + %false = arith.constant false + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i8, %out: i8): + %4 = arith.extui %in : i8 to i32 + %5 = arith.subi %4, %arg2 : i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.mulf %6, %arg1 : f32 + %8 = arith.divf %7, %arg1 : f32 + %9 = arith.fptosi %8 : f32 to i32 + %10 = arith.addi %9, %arg2 : i32 + %11 = arith.cmpi slt, %10, %c0_i32 : i32 + %12 = arith.select %11, %c0_i32, %10 : i32 + %13 = arith.cmpi sgt, %10, %c255_i32 : i32 + %14 = arith.select %11, %false, %13 : i1 + %15 = arith.select %14, %c255_i32, %12 : i32 + %16 = arith.trunci %15 : i32 to i8 + linalg.yield %16 : i8 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu_linalg.mlir new file mode 100644 index 000000000000..efa1b0fbabfe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_2d_quantized_cpu_linalg.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_2d_quantized_cpu(%arg0: memref, %arg1: f32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %c255_i32 = arith.constant 255 : i32 + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg3 : memref) { + ^bb0(%in: i8, %out: i8): + %0 = arith.extui %in : i8 to i32 + %1 = arith.subi %0, %arg2 : i32 + %2 = arith.sitofp %1 : i32 to f32 + %3 = arith.mulf %2, %arg1 : f32 + %4 = arith.divf %3, %arg1 : f32 + %5 = arith.fptosi %4 : f32 to i32 + %6 = arith.addi %5, %arg2 : i32 + %7 = arith.cmpi slt, %6, %c0_i32 : i32 + %8 = arith.select %7, %c0_i32, %6 : i32 + %9 = arith.cmpi sgt, %6, %c255_i32 : i32 + %10 = arith.select %7, %false, %9 : i1 + %11 = arith.select %10, %c255_i32, %8 : i32 + %12 = arith.trunci %11 : i32 to i8 + linalg.yield %12 : i8 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu.mlir new file mode 100644 index 000000000000..c7d9d86cc383 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu.mlir @@ -0,0 +1,95 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 6.000000e+00 : f32 + %cst_0 = arith.constant 7.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %cst_4 = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 672 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_4, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 6 { + %1 = affine.load %arg1[0, %arg3, %arg4, %arg5, 0] : memref + %2 = arith.addf %1, %cst_3 : f32 + %3 = arith.mulf %2, %cst_2 : f32 + %4 = arith.mulf %3, %cst_0 : f32 + %5 = affine.load %arg1[0, %arg3, %arg4, %arg5, 1] : memref + %6 = arith.addf %5, %cst_3 : f32 + %7 = arith.mulf %6, %cst_2 : f32 + %8 = arith.mulf %7, %cst : f32 + %9 = affine.load %arg1[0, %arg3, %arg4, %arg5, 2] : memref + %10 = arith.addf %9, %cst_3 : f32 + %11 = arith.mulf %10, %cst_2 : f32 + %12 = arith.mulf %11, %cst_1 : f32 + %13 = arith.fptosi %4 : f32 to i32 + %14 = arith.fptosi %8 : f32 to i32 + %15 = arith.fptosi %12 : f32 to i32 + %16 = arith.sitofp %13 : i32 to f32 + %17 = arith.subf %4, %16 : f32 + %18 = arith.sitofp %14 : i32 to f32 + %19 = arith.subf %8, %18 : f32 + %20 = arith.sitofp %15 : i32 to f32 + %21 = arith.subf %12, %20 : f32 + %22 = arith.subf %cst_3, %17 : f32 + %23 = arith.subf %cst_3, %19 : f32 + %24 = arith.subf %cst_3, %21 : f32 + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 2 { + %25 = arith.index_cast %arg7 : index to i32 + %26 = arith.addi %15, %25 : i32 + %27 = arith.cmpi sge, %26, %c0_i32 : i32 + %28 = arith.cmpi slt, %26, %c6_i32 : i32 + %29 = arith.index_cast %26 : i32 to index + %30 = arith.cmpi ne, %25, %c0_i32 : i32 + %31 = arith.select %30, %21, %24 : f32 + affine.for %arg8 = 0 to 2 { + %32 = arith.index_cast %arg8 : index to i32 + %33 = arith.addi %14, %32 : i32 + %34 = arith.cmpi sge, %33, %c0_i32 : i32 + %35 = arith.cmpi slt, %33, %c7_i32 : i32 + %36 = arith.index_cast %33 : i32 to index + %37 = arith.cmpi ne, %32, %c0_i32 : i32 + %38 = arith.select %37, %19, %23 : f32 + affine.for %arg9 = 0 to 2 { + %39 = arith.index_cast %arg9 : index to i32 + %40 = arith.addi %13, %39 : i32 + %41 = arith.cmpi sge, %40, %c0_i32 : i32 + %42 = arith.cmpi slt, %40, %c8_i32 : i32 + %43 = arith.andi %41, %42 : i1 + %44 = arith.andi %35, %43 : i1 + %45 = arith.andi %34, %44 : i1 + %46 = arith.andi %28, %45 : i1 + %47 = arith.andi %27, %46 : i1 + scf.if %47 { + %48 = arith.index_cast %40 : i32 to index + %49 = affine.load %arg0[0, %arg6, %arg3, %arg4, %arg5] : memref + %50 = arith.mulf %49, %31 : f32 + %51 = arith.mulf %50, %38 : f32 + %52 = arith.cmpi ne, %39, %c0_i32 : i32 + %53 = arith.select %52, %17, %22 : f32 + %54 = arith.mulf %51, %53 : f32 + %55 = memref.load %arg2[%c0, %arg6, %29, %36, %48] : memref + %56 = arith.addf %55, %54 : f32 + memref.store %56, %arg2[%c0, %arg6, %29, %36, %48] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..8f13803101f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu/debuf.mlir @@ -0,0 +1,100 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c6_i32 = arith.constant 6 : i32 + %c7_i32 = arith.constant 7 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 7.000000e+00 : f32 + %cst_4 = arith.constant 6.000000e+00 : f32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 672 { + %3 = arith.index_cast %arg3 : index to i32 + %4 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %4 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 6 { + %extracted = tensor.extract %0[%c0, %arg3, %arg4, %arg5, %c0] : tensor + %3 = arith.addf %extracted, %cst_0 : f32 + %4 = arith.mulf %3, %cst_1 : f32 + %5 = arith.mulf %4, %cst_3 : f32 + %extracted_5 = tensor.extract %0[%c0, %arg3, %arg4, %arg5, %c1] : tensor + %6 = arith.addf %extracted_5, %cst_0 : f32 + %7 = arith.mulf %6, %cst_1 : f32 + %8 = arith.mulf %7, %cst_4 : f32 + %extracted_6 = tensor.extract %0[%c0, %arg3, %arg4, %arg5, %c2] : tensor + %9 = arith.addf %extracted_6, %cst_0 : f32 + %10 = arith.mulf %9, %cst_1 : f32 + %11 = arith.mulf %10, %cst_2 : f32 + %12 = arith.fptosi %5 : f32 to i32 + %13 = arith.fptosi %8 : f32 to i32 + %14 = arith.fptosi %11 : f32 to i32 + %15 = arith.sitofp %12 : i32 to f32 + %16 = arith.subf %5, %15 : f32 + %17 = arith.sitofp %13 : i32 to f32 + %18 = arith.subf %8, %17 : f32 + %19 = arith.sitofp %14 : i32 to f32 + %20 = arith.subf %11, %19 : f32 + %21 = arith.subf %cst_0, %16 : f32 + %22 = arith.subf %cst_0, %18 : f32 + %23 = arith.subf %cst_0, %20 : f32 + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 2 { + %24 = arith.index_cast %arg7 : index to i32 + %25 = arith.addi %14, %24 : i32 + %26 = arith.cmpi sge, %25, %c0_i32 : i32 + %27 = arith.cmpi slt, %25, %c6_i32 : i32 + %28 = arith.index_cast %25 : i32 to index + %29 = arith.cmpi ne, %24, %c0_i32 : i32 + %30 = arith.select %29, %20, %23 : f32 + affine.for %arg8 = 0 to 2 { + %31 = arith.index_cast %arg8 : index to i32 + %32 = arith.addi %13, %31 : i32 + %33 = arith.cmpi sge, %32, %c0_i32 : i32 + %34 = arith.cmpi slt, %32, %c7_i32 : i32 + %35 = arith.index_cast %32 : i32 to index + %36 = arith.cmpi ne, %31, %c0_i32 : i32 + %37 = arith.select %36, %18, %22 : f32 + affine.for %arg9 = 0 to 2 { + %38 = arith.index_cast %arg9 : index to i32 + %39 = arith.addi %12, %38 : i32 + %40 = arith.cmpi sge, %39, %c0_i32 : i32 + %41 = arith.cmpi slt, %39, %c8_i32 : i32 + %42 = arith.andi %40, %41 : i1 + %43 = arith.andi %34, %42 : i1 + %44 = arith.andi %33, %43 : i1 + %45 = arith.andi %27, %44 : i1 + %46 = arith.andi %26, %45 : i1 + scf.if %46 { + %47 = arith.index_cast %39 : i32 to index + %extracted_7 = tensor.extract %1[%c0, %arg6, %arg3, %arg4, %arg5] : tensor + %48 = arith.mulf %extracted_7, %30 : f32 + %49 = arith.mulf %48, %37 : f32 + %50 = arith.cmpi ne, %38, %c0_i32 : i32 + %51 = arith.select %50, %16, %21 : f32 + %52 = arith.mulf %49, %51 : f32 + %53 = memref.load %arg2[%c0, %arg6, %28, %35, %47] : memref + %54 = arith.addf %53, %52 : f32 + memref.store %54, %arg2[%c0, %arg6, %28, %35, %47] : memref + } + } + } + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..8f13803101f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu/matched.mlir @@ -0,0 +1,100 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c6_i32 = arith.constant 6 : i32 + %c7_i32 = arith.constant 7 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 7.000000e+00 : f32 + %cst_4 = arith.constant 6.000000e+00 : f32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 672 { + %3 = arith.index_cast %arg3 : index to i32 + %4 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %4 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 6 { + %extracted = tensor.extract %0[%c0, %arg3, %arg4, %arg5, %c0] : tensor + %3 = arith.addf %extracted, %cst_0 : f32 + %4 = arith.mulf %3, %cst_1 : f32 + %5 = arith.mulf %4, %cst_3 : f32 + %extracted_5 = tensor.extract %0[%c0, %arg3, %arg4, %arg5, %c1] : tensor + %6 = arith.addf %extracted_5, %cst_0 : f32 + %7 = arith.mulf %6, %cst_1 : f32 + %8 = arith.mulf %7, %cst_4 : f32 + %extracted_6 = tensor.extract %0[%c0, %arg3, %arg4, %arg5, %c2] : tensor + %9 = arith.addf %extracted_6, %cst_0 : f32 + %10 = arith.mulf %9, %cst_1 : f32 + %11 = arith.mulf %10, %cst_2 : f32 + %12 = arith.fptosi %5 : f32 to i32 + %13 = arith.fptosi %8 : f32 to i32 + %14 = arith.fptosi %11 : f32 to i32 + %15 = arith.sitofp %12 : i32 to f32 + %16 = arith.subf %5, %15 : f32 + %17 = arith.sitofp %13 : i32 to f32 + %18 = arith.subf %8, %17 : f32 + %19 = arith.sitofp %14 : i32 to f32 + %20 = arith.subf %11, %19 : f32 + %21 = arith.subf %cst_0, %16 : f32 + %22 = arith.subf %cst_0, %18 : f32 + %23 = arith.subf %cst_0, %20 : f32 + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 2 { + %24 = arith.index_cast %arg7 : index to i32 + %25 = arith.addi %14, %24 : i32 + %26 = arith.cmpi sge, %25, %c0_i32 : i32 + %27 = arith.cmpi slt, %25, %c6_i32 : i32 + %28 = arith.index_cast %25 : i32 to index + %29 = arith.cmpi ne, %24, %c0_i32 : i32 + %30 = arith.select %29, %20, %23 : f32 + affine.for %arg8 = 0 to 2 { + %31 = arith.index_cast %arg8 : index to i32 + %32 = arith.addi %13, %31 : i32 + %33 = arith.cmpi sge, %32, %c0_i32 : i32 + %34 = arith.cmpi slt, %32, %c7_i32 : i32 + %35 = arith.index_cast %32 : i32 to index + %36 = arith.cmpi ne, %31, %c0_i32 : i32 + %37 = arith.select %36, %18, %22 : f32 + affine.for %arg9 = 0 to 2 { + %38 = arith.index_cast %arg9 : index to i32 + %39 = arith.addi %12, %38 : i32 + %40 = arith.cmpi sge, %39, %c0_i32 : i32 + %41 = arith.cmpi slt, %39, %c8_i32 : i32 + %42 = arith.andi %40, %41 : i1 + %43 = arith.andi %34, %42 : i1 + %44 = arith.andi %33, %43 : i1 + %45 = arith.andi %27, %44 : i1 + %46 = arith.andi %26, %45 : i1 + scf.if %46 { + %47 = arith.index_cast %39 : i32 to index + %extracted_7 = tensor.extract %1[%c0, %arg6, %arg3, %arg4, %arg5] : tensor + %48 = arith.mulf %extracted_7, %30 : f32 + %49 = arith.mulf %48, %37 : f32 + %50 = arith.cmpi ne, %38, %c0_i32 : i32 + %51 = arith.select %50, %16, %21 : f32 + %52 = arith.mulf %49, %51 : f32 + %53 = memref.load %arg2[%c0, %arg6, %28, %35, %47] : memref + %54 = arith.addf %53, %52 : f32 + memref.store %54, %arg2[%c0, %arg6, %28, %35, %47] : memref + } + } + } + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..c7d9d86cc383 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu/orig.mlir @@ -0,0 +1,95 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 6.000000e+00 : f32 + %cst_0 = arith.constant 7.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %cst_4 = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 672 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_4, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 6 { + %1 = affine.load %arg1[0, %arg3, %arg4, %arg5, 0] : memref + %2 = arith.addf %1, %cst_3 : f32 + %3 = arith.mulf %2, %cst_2 : f32 + %4 = arith.mulf %3, %cst_0 : f32 + %5 = affine.load %arg1[0, %arg3, %arg4, %arg5, 1] : memref + %6 = arith.addf %5, %cst_3 : f32 + %7 = arith.mulf %6, %cst_2 : f32 + %8 = arith.mulf %7, %cst : f32 + %9 = affine.load %arg1[0, %arg3, %arg4, %arg5, 2] : memref + %10 = arith.addf %9, %cst_3 : f32 + %11 = arith.mulf %10, %cst_2 : f32 + %12 = arith.mulf %11, %cst_1 : f32 + %13 = arith.fptosi %4 : f32 to i32 + %14 = arith.fptosi %8 : f32 to i32 + %15 = arith.fptosi %12 : f32 to i32 + %16 = arith.sitofp %13 : i32 to f32 + %17 = arith.subf %4, %16 : f32 + %18 = arith.sitofp %14 : i32 to f32 + %19 = arith.subf %8, %18 : f32 + %20 = arith.sitofp %15 : i32 to f32 + %21 = arith.subf %12, %20 : f32 + %22 = arith.subf %cst_3, %17 : f32 + %23 = arith.subf %cst_3, %19 : f32 + %24 = arith.subf %cst_3, %21 : f32 + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 2 { + %25 = arith.index_cast %arg7 : index to i32 + %26 = arith.addi %15, %25 : i32 + %27 = arith.cmpi sge, %26, %c0_i32 : i32 + %28 = arith.cmpi slt, %26, %c6_i32 : i32 + %29 = arith.index_cast %26 : i32 to index + %30 = arith.cmpi ne, %25, %c0_i32 : i32 + %31 = arith.select %30, %21, %24 : f32 + affine.for %arg8 = 0 to 2 { + %32 = arith.index_cast %arg8 : index to i32 + %33 = arith.addi %14, %32 : i32 + %34 = arith.cmpi sge, %33, %c0_i32 : i32 + %35 = arith.cmpi slt, %33, %c7_i32 : i32 + %36 = arith.index_cast %33 : i32 to index + %37 = arith.cmpi ne, %32, %c0_i32 : i32 + %38 = arith.select %37, %19, %23 : f32 + affine.for %arg9 = 0 to 2 { + %39 = arith.index_cast %arg9 : index to i32 + %40 = arith.addi %13, %39 : i32 + %41 = arith.cmpi sge, %40, %c0_i32 : i32 + %42 = arith.cmpi slt, %40, %c8_i32 : i32 + %43 = arith.andi %41, %42 : i1 + %44 = arith.andi %35, %43 : i1 + %45 = arith.andi %34, %44 : i1 + %46 = arith.andi %28, %45 : i1 + %47 = arith.andi %27, %46 : i1 + scf.if %47 { + %48 = arith.index_cast %40 : i32 to index + %49 = affine.load %arg0[0, %arg6, %arg3, %arg4, %arg5] : memref + %50 = arith.mulf %49, %31 : f32 + %51 = arith.mulf %50, %38 : f32 + %52 = arith.cmpi ne, %39, %c0_i32 : i32 + %53 = arith.select %52, %17, %22 : f32 + %54 = arith.mulf %51, %53 : f32 + %55 = memref.load %arg2[%c0, %arg6, %29, %36, %48] : memref + %56 = arith.addf %55, %54 : f32 + memref.store %56, %arg2[%c0, %arg6, %29, %36, %48] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..6d8d22682cf8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu/raised.mlir @@ -0,0 +1,96 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 6.000000e+00 : f32 + %cst_0 = arith.constant 7.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %cst_4 = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 672 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_4, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 6 { + %1 = affine.load %arg1[0, %arg3, %arg4, %arg5, 0] : memref + %2 = arith.addf %1, %cst_3 : f32 + %3 = arith.mulf %2, %cst_2 : f32 + %4 = arith.mulf %3, %cst_0 : f32 + %5 = affine.load %arg1[0, %arg3, %arg4, %arg5, 1] : memref + %6 = arith.addf %5, %cst_3 : f32 + %7 = arith.mulf %6, %cst_2 : f32 + %8 = arith.mulf %7, %cst : f32 + %9 = affine.load %arg1[0, %arg3, %arg4, %arg5, 2] : memref + %10 = arith.addf %9, %cst_3 : f32 + %11 = arith.mulf %10, %cst_2 : f32 + %12 = arith.mulf %11, %cst_1 : f32 + %13 = arith.fptosi %4 : f32 to i32 + %14 = arith.fptosi %8 : f32 to i32 + %15 = arith.fptosi %12 : f32 to i32 + %16 = arith.sitofp %13 : i32 to f32 + %17 = arith.subf %4, %16 : f32 + %18 = arith.sitofp %14 : i32 to f32 + %19 = arith.subf %8, %18 : f32 + %20 = arith.sitofp %15 : i32 to f32 + %21 = arith.subf %12, %20 : f32 + %22 = arith.subf %cst_3, %17 : f32 + %23 = arith.subf %cst_3, %19 : f32 + %24 = arith.subf %cst_3, %21 : f32 + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 2 { + %25 = arith.index_cast %arg7 : index to i32 + %26 = arith.addi %15, %25 : i32 + %27 = arith.cmpi sge, %26, %c0_i32 : i32 + %28 = arith.cmpi slt, %26, %c6_i32 : i32 + %29 = arith.index_cast %26 : i32 to index + %30 = arith.cmpi ne, %25, %c0_i32 : i32 + %31 = arith.select %30, %21, %24 : f32 + affine.for %arg8 = 0 to 2 { + %32 = arith.index_cast %arg8 : index to i32 + %33 = arith.addi %14, %32 : i32 + %34 = arith.cmpi sge, %33, %c0_i32 : i32 + %35 = arith.cmpi slt, %33, %c7_i32 : i32 + %36 = arith.index_cast %33 : i32 to index + %37 = arith.cmpi ne, %32, %c0_i32 : i32 + %38 = arith.select %37, %19, %23 : f32 + affine.for %arg9 = 0 to 2 { + %39 = arith.index_cast %arg9 : index to i32 + %40 = arith.addi %13, %39 : i32 + %41 = arith.cmpi sge, %40, %c0_i32 : i32 + %42 = arith.cmpi slt, %40, %c8_i32 : i32 + %43 = arith.andi %41, %42 : i1 + %44 = arith.andi %35, %43 : i1 + %45 = arith.andi %34, %44 : i1 + %46 = arith.andi %28, %45 : i1 + %47 = arith.andi %27, %46 : i1 + scf.if %47 { + %48 = arith.index_cast %40 : i32 to index + %49 = affine.load %arg0[0, %arg6, %arg3, %arg4, %arg5] : memref + %50 = arith.mulf %49, %31 : f32 + %51 = arith.mulf %50, %38 : f32 + %52 = arith.cmpi ne, %39, %c0_i32 : i32 + %53 = arith.select %52, %17, %22 : f32 + %54 = arith.mulf %51, %53 : f32 + %55 = memref.load %arg2[%c0, %arg6, %29, %36, %48] : memref + %56 = arith.addf %55, %54 : f32 + memref.store %56, %arg2[%c0, %arg6, %29, %36, %48] : memref + } + } + } + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..8f13803101f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu_debuf.mlir @@ -0,0 +1,100 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c6_i32 = arith.constant 6 : i32 + %c7_i32 = arith.constant 7 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 7.000000e+00 : f32 + %cst_4 = arith.constant 6.000000e+00 : f32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 672 { + %3 = arith.index_cast %arg3 : index to i32 + %4 = llvm.getelementptr %2[%3] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %4 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 6 { + %extracted = tensor.extract %0[%c0, %arg3, %arg4, %arg5, %c0] : tensor + %3 = arith.addf %extracted, %cst_0 : f32 + %4 = arith.mulf %3, %cst_1 : f32 + %5 = arith.mulf %4, %cst_3 : f32 + %extracted_5 = tensor.extract %0[%c0, %arg3, %arg4, %arg5, %c1] : tensor + %6 = arith.addf %extracted_5, %cst_0 : f32 + %7 = arith.mulf %6, %cst_1 : f32 + %8 = arith.mulf %7, %cst_4 : f32 + %extracted_6 = tensor.extract %0[%c0, %arg3, %arg4, %arg5, %c2] : tensor + %9 = arith.addf %extracted_6, %cst_0 : f32 + %10 = arith.mulf %9, %cst_1 : f32 + %11 = arith.mulf %10, %cst_2 : f32 + %12 = arith.fptosi %5 : f32 to i32 + %13 = arith.fptosi %8 : f32 to i32 + %14 = arith.fptosi %11 : f32 to i32 + %15 = arith.sitofp %12 : i32 to f32 + %16 = arith.subf %5, %15 : f32 + %17 = arith.sitofp %13 : i32 to f32 + %18 = arith.subf %8, %17 : f32 + %19 = arith.sitofp %14 : i32 to f32 + %20 = arith.subf %11, %19 : f32 + %21 = arith.subf %cst_0, %16 : f32 + %22 = arith.subf %cst_0, %18 : f32 + %23 = arith.subf %cst_0, %20 : f32 + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 2 { + %24 = arith.index_cast %arg7 : index to i32 + %25 = arith.addi %14, %24 : i32 + %26 = arith.cmpi sge, %25, %c0_i32 : i32 + %27 = arith.cmpi slt, %25, %c6_i32 : i32 + %28 = arith.index_cast %25 : i32 to index + %29 = arith.cmpi ne, %24, %c0_i32 : i32 + %30 = arith.select %29, %20, %23 : f32 + affine.for %arg8 = 0 to 2 { + %31 = arith.index_cast %arg8 : index to i32 + %32 = arith.addi %13, %31 : i32 + %33 = arith.cmpi sge, %32, %c0_i32 : i32 + %34 = arith.cmpi slt, %32, %c7_i32 : i32 + %35 = arith.index_cast %32 : i32 to index + %36 = arith.cmpi ne, %31, %c0_i32 : i32 + %37 = arith.select %36, %18, %22 : f32 + affine.for %arg9 = 0 to 2 { + %38 = arith.index_cast %arg9 : index to i32 + %39 = arith.addi %12, %38 : i32 + %40 = arith.cmpi sge, %39, %c0_i32 : i32 + %41 = arith.cmpi slt, %39, %c8_i32 : i32 + %42 = arith.andi %40, %41 : i1 + %43 = arith.andi %34, %42 : i1 + %44 = arith.andi %33, %43 : i1 + %45 = arith.andi %27, %44 : i1 + %46 = arith.andi %26, %45 : i1 + scf.if %46 { + %47 = arith.index_cast %39 : i32 to index + %extracted_7 = tensor.extract %1[%c0, %arg6, %arg3, %arg4, %arg5] : tensor + %48 = arith.mulf %extracted_7, %30 : f32 + %49 = arith.mulf %48, %37 : f32 + %50 = arith.cmpi ne, %38, %c0_i32 : i32 + %51 = arith.select %50, %16, %21 : f32 + %52 = arith.mulf %49, %51 : f32 + %53 = memref.load %arg2[%c0, %arg6, %28, %35, %47] : memref + %54 = arith.addf %53, %52 : f32 + memref.store %54, %arg2[%c0, %arg6, %28, %35, %47] : memref + } + } + } + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..6d8d22682cf8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_3d_backward_cpu_linalg.mlir @@ -0,0 +1,96 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 6.000000e+00 : f32 + %cst_0 = arith.constant 7.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %cst_4 = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c7_i32 = arith.constant 7 : i32 + %c6_i32 = arith.constant 6 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 672 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst_4, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 6 { + %1 = affine.load %arg1[0, %arg3, %arg4, %arg5, 0] : memref + %2 = arith.addf %1, %cst_3 : f32 + %3 = arith.mulf %2, %cst_2 : f32 + %4 = arith.mulf %3, %cst_0 : f32 + %5 = affine.load %arg1[0, %arg3, %arg4, %arg5, 1] : memref + %6 = arith.addf %5, %cst_3 : f32 + %7 = arith.mulf %6, %cst_2 : f32 + %8 = arith.mulf %7, %cst : f32 + %9 = affine.load %arg1[0, %arg3, %arg4, %arg5, 2] : memref + %10 = arith.addf %9, %cst_3 : f32 + %11 = arith.mulf %10, %cst_2 : f32 + %12 = arith.mulf %11, %cst_1 : f32 + %13 = arith.fptosi %4 : f32 to i32 + %14 = arith.fptosi %8 : f32 to i32 + %15 = arith.fptosi %12 : f32 to i32 + %16 = arith.sitofp %13 : i32 to f32 + %17 = arith.subf %4, %16 : f32 + %18 = arith.sitofp %14 : i32 to f32 + %19 = arith.subf %8, %18 : f32 + %20 = arith.sitofp %15 : i32 to f32 + %21 = arith.subf %12, %20 : f32 + %22 = arith.subf %cst_3, %17 : f32 + %23 = arith.subf %cst_3, %19 : f32 + %24 = arith.subf %cst_3, %21 : f32 + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 2 { + %25 = arith.index_cast %arg7 : index to i32 + %26 = arith.addi %15, %25 : i32 + %27 = arith.cmpi sge, %26, %c0_i32 : i32 + %28 = arith.cmpi slt, %26, %c6_i32 : i32 + %29 = arith.index_cast %26 : i32 to index + %30 = arith.cmpi ne, %25, %c0_i32 : i32 + %31 = arith.select %30, %21, %24 : f32 + affine.for %arg8 = 0 to 2 { + %32 = arith.index_cast %arg8 : index to i32 + %33 = arith.addi %14, %32 : i32 + %34 = arith.cmpi sge, %33, %c0_i32 : i32 + %35 = arith.cmpi slt, %33, %c7_i32 : i32 + %36 = arith.index_cast %33 : i32 to index + %37 = arith.cmpi ne, %32, %c0_i32 : i32 + %38 = arith.select %37, %19, %23 : f32 + affine.for %arg9 = 0 to 2 { + %39 = arith.index_cast %arg9 : index to i32 + %40 = arith.addi %13, %39 : i32 + %41 = arith.cmpi sge, %40, %c0_i32 : i32 + %42 = arith.cmpi slt, %40, %c8_i32 : i32 + %43 = arith.andi %41, %42 : i1 + %44 = arith.andi %35, %43 : i1 + %45 = arith.andi %34, %44 : i1 + %46 = arith.andi %28, %45 : i1 + %47 = arith.andi %27, %46 : i1 + scf.if %47 { + %48 = arith.index_cast %40 : i32 to index + %49 = affine.load %arg0[0, %arg6, %arg3, %arg4, %arg5] : memref + %50 = arith.mulf %49, %31 : f32 + %51 = arith.mulf %50, %38 : f32 + %52 = arith.cmpi ne, %39, %c0_i32 : i32 + %53 = arith.select %52, %17, %22 : f32 + %54 = arith.mulf %51, %53 : f32 + %55 = memref.load %arg2[%c0, %arg6, %29, %36, %48] : memref + %56 = arith.addf %55, %54 : f32 + memref.store %56, %arg2[%c0, %arg6, %29, %36, %48] : memref + } + } + } + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu.mlir new file mode 100644 index 000000000000..eea2d2cd9db9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu.mlir @@ -0,0 +1,94 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 7.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %cst_3 = arith.constant 5.000000e-01 : f32 + %cst_4 = arith.constant 1.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 6 { + %0 = affine.load %arg1[0, %arg3, %arg4, %arg5, 0] : memref + %1 = arith.addf %0, %cst_4 : f32 + %2 = arith.mulf %1, %cst_3 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = affine.load %arg1[0, %arg3, %arg4, %arg5, 1] : memref + %5 = arith.addf %4, %cst_4 : f32 + %6 = arith.mulf %5, %cst_3 : f32 + %7 = arith.mulf %6, %cst_0 : f32 + %8 = affine.load %arg1[0, %arg3, %arg4, %arg5, 2] : memref + %9 = arith.addf %8, %cst_4 : f32 + %10 = arith.mulf %9, %cst_3 : f32 + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.fptosi %3 : f32 to i32 + %13 = arith.fptosi %7 : f32 to i32 + %14 = arith.fptosi %11 : f32 to i32 + %15 = arith.sitofp %12 : i32 to f32 + %16 = arith.subf %3, %15 : f32 + %17 = arith.sitofp %13 : i32 to f32 + %18 = arith.subf %7, %17 : f32 + %19 = arith.sitofp %14 : i32 to f32 + %20 = arith.subf %11, %19 : f32 + %21 = arith.subf %cst_4, %16 : f32 + %22 = arith.subf %cst_4, %18 : f32 + %23 = arith.subf %cst_4, %20 : f32 + affine.for %arg6 = 0 to 2 { + %24 = affine.for %arg7 = 0 to 2 iter_args(%arg8 = %cst_2) -> (f32) { + %25 = arith.index_cast %arg7 : index to i32 + %26 = arith.addi %14, %25 : i32 + %27 = arith.cmpi sge, %26, %c0_i32 : i32 + %28 = arith.cmpi slt, %26, %c6_i32 : i32 + %29 = arith.index_cast %26 : i32 to index + %30 = arith.cmpi ne, %25, %c0_i32 : i32 + %31 = arith.select %30, %20, %23 : f32 + %32 = affine.for %arg9 = 0 to 2 iter_args(%arg10 = %arg8) -> (f32) { + %33 = arith.index_cast %arg9 : index to i32 + %34 = arith.addi %13, %33 : i32 + %35 = arith.cmpi sge, %34, %c0_i32 : i32 + %36 = arith.cmpi slt, %34, %c7_i32 : i32 + %37 = arith.index_cast %34 : i32 to index + %38 = arith.cmpi ne, %33, %c0_i32 : i32 + %39 = arith.select %38, %18, %22 : f32 + %40 = affine.for %arg11 = 0 to 2 iter_args(%arg12 = %arg10) -> (f32) { + %41 = arith.index_cast %arg11 : index to i32 + %42 = arith.addi %12, %41 : i32 + %43 = arith.cmpi sge, %42, %c0_i32 : i32 + %44 = arith.cmpi slt, %42, %c8_i32 : i32 + %45 = arith.andi %43, %44 : i1 + %46 = arith.andi %36, %45 : i1 + %47 = arith.andi %35, %46 : i1 + %48 = arith.andi %28, %47 : i1 + %49 = arith.andi %27, %48 : i1 + %50 = scf.if %49 -> (f32) { + %51 = arith.index_cast %42 : i32 to index + %52 = memref.load %arg0[%c0, %arg6, %29, %37, %51] : memref + %53 = arith.mulf %52, %31 : f32 + %54 = arith.mulf %53, %39 : f32 + %55 = arith.cmpi ne, %41, %c0_i32 : i32 + %56 = arith.select %55, %16, %21 : f32 + %57 = arith.mulf %54, %56 : f32 + %58 = arith.addf %arg12, %57 : f32 + scf.yield %58 : f32 + } else { + scf.yield %arg12 : f32 + } + affine.yield %50 : f32 + } + affine.yield %40 : f32 + } + affine.yield %32 : f32 + } + affine.store %24, %arg2[0, %arg6, %arg3, %arg4, %arg5] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu/debuf.mlir new file mode 100644 index 000000000000..3d0ec6060b29 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu/debuf.mlir @@ -0,0 +1,111 @@ +#map = affine_map<(d0, d1) -> (d1, d0)> +#map1 = affine_map<(d0, d1, d2, d3, d4)[s0, s1] -> (0, d1, s0, s1, d0)> +#map2 = affine_map<(d0)[s0, s1] -> (0, s0, s1, d0, 0)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0)> +#map4 = affine_map<(d0)[s0, s1] -> (0, s0, s1, d0, 1)> +#map5 = affine_map<(d0)[s0, s1] -> (0, s0, s1, d0, 2)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %c7_i32 = arith.constant 7 : i32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 6.000000e+00 : f32 + %cst_4 = arith.constant 7.000000e+00 : f32 + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = affine.for %arg3 = 0 to 4 iter_args(%arg4 = %1) -> (tensor) { + %4 = affine.for %arg5 = 0 to 5 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted_slice = tensor.extract_slice %arg6[0, 0, %arg3, %arg5, 0] [1, %c2, 1, 1, %c6] [1, 1, 1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst_1 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %arg6[0, 0, %arg3, %arg5, 0] [1, %c2, 1, 1, %c6] [1, 1, 1, 1, 1] : tensor into tensor + %6 = polygeist.submap(%inserted_slice, %arg3, %arg5, %c6, %c2, %c2, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index, index) -> tensor + %7 = polygeist.submap(%0, %arg3, %arg5, %c6) {map = #map2} : (tensor, index, index, index) -> tensor + %8 = polygeist.submap(%7, %c6, %c2, %c2, %c2, %c2) {map = #map3} : (tensor, index, index, index, index, index) -> tensor + %9 = polygeist.submap(%0, %arg3, %arg5, %c6) {map = #map4} : (tensor, index, index, index) -> tensor + %10 = polygeist.submap(%9, %c6, %c2, %c2, %c2, %c2) {map = #map3} : (tensor, index, index, index, index, index) -> tensor + %11 = polygeist.submap(%0, %arg3, %arg5, %c6) {map = #map5} : (tensor, index, index, index) -> tensor + %12 = polygeist.submap(%11, %c6, %c2, %c2, %c2, %c2) {map = #map3} : (tensor, index, index, index, index, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map6, #map6, #map6, #map6], iterator_types = ["parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%8, %10, %12 : tensor, tensor, tensor) outs(%6 : tensor) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32): + %15 = arith.addf %in, %cst : f32 + %16 = arith.mulf %15, %cst_0 : f32 + %17 = arith.mulf %16, %cst_4 : f32 + %18 = arith.addf %in_5, %cst : f32 + %19 = arith.mulf %18, %cst_0 : f32 + %20 = arith.mulf %19, %cst_3 : f32 + %21 = arith.addf %in_6, %cst : f32 + %22 = arith.mulf %21, %cst_0 : f32 + %23 = arith.mulf %22, %cst_2 : f32 + %24 = arith.fptosi %17 : f32 to i32 + %25 = arith.fptosi %20 : f32 to i32 + %26 = arith.fptosi %23 : f32 to i32 + %27 = arith.sitofp %24 : i32 to f32 + %28 = arith.subf %17, %27 : f32 + %29 = arith.sitofp %25 : i32 to f32 + %30 = arith.subf %20, %29 : f32 + %31 = arith.sitofp %26 : i32 to f32 + %32 = arith.subf %23, %31 : f32 + %33 = arith.subf %cst, %28 : f32 + %34 = arith.subf %cst, %30 : f32 + %35 = arith.subf %cst, %32 : f32 + %36 = linalg.index 1 : index + %37 = linalg.index 2 : index + %38 = arith.index_cast %37 : index to i32 + %39 = arith.addi %26, %38 : i32 + %40 = arith.cmpi sge, %39, %c0_i32 : i32 + %41 = arith.cmpi slt, %39, %c6_i32 : i32 + %42 = arith.index_cast %39 : i32 to index + %43 = arith.cmpi ne, %38, %c0_i32 : i32 + %44 = arith.select %43, %32, %35 : f32 + %45 = linalg.index 3 : index + %46 = arith.index_cast %45 : index to i32 + %47 = arith.addi %25, %46 : i32 + %48 = arith.cmpi sge, %47, %c0_i32 : i32 + %49 = arith.cmpi slt, %47, %c7_i32 : i32 + %50 = arith.index_cast %47 : i32 to index + %51 = arith.cmpi ne, %46, %c0_i32 : i32 + %52 = arith.select %51, %30, %34 : f32 + %53 = linalg.index 4 : index + %54 = arith.index_cast %53 : index to i32 + %55 = arith.addi %24, %54 : i32 + %56 = arith.cmpi sge, %55, %c0_i32 : i32 + %57 = arith.cmpi slt, %55, %c8_i32 : i32 + %58 = arith.andi %56, %57 : i1 + %59 = arith.andi %49, %58 : i1 + %60 = arith.andi %48, %59 : i1 + %61 = arith.andi %41, %60 : i1 + %62 = arith.andi %40, %61 : i1 + %63 = arith.index_cast %55 : i32 to index + %64 = memref.load %arg0[%c0, %36, %42, %50, %63] : memref + %65 = arith.mulf %64, %44 : f32 + %66 = arith.mulf %65, %52 : f32 + %67 = arith.cmpi ne, %54, %c0_i32 : i32 + %68 = arith.select %67, %28, %33 : f32 + %69 = arith.mulf %66, %68 : f32 + %70 = arith.addf %out, %69 : f32 + %71 = arith.select %62, %70, %out : f32 + linalg.yield %71 : f32 + } -> tensor + %14 = polygeist.submapInverse(%inserted_slice, %13, %arg3, %arg5, %c6, %c2, %c2, %c2, %c2) {map = #map1} : (tensor, tensor, index, index, index, index, index, index, index) -> tensor + affine.yield %14 : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu/matched.mlir new file mode 100644 index 000000000000..6392817c7a1a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu/matched.mlir @@ -0,0 +1,108 @@ +#map = affine_map<(d0, d1) -> (d1, d0)> +#map1 = affine_map<(d0, d1, d2, d3, d4)[s0, s1] -> (0, d1, s0, s1, d0)> +#map2 = affine_map<(d0)[s0, s1] -> (0, s0, s1, d0, 0)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0)> +#map4 = affine_map<(d0)[s0, s1] -> (0, s0, s1, d0, 1)> +#map5 = affine_map<(d0)[s0, s1] -> (0, s0, s1, d0, 2)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %c7_i32 = arith.constant 7 : i32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 6.000000e+00 : f32 + %cst_4 = arith.constant 7.000000e+00 : f32 + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = affine.for %arg3 = 0 to 4 iter_args(%arg4 = %1) -> (tensor) { + %4 = affine.for %arg5 = 0 to 5 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted_slice = tensor.extract_slice %arg6[0, 0, %arg3, %arg5, 0] [1, %c2, 1, 1, %c6] [1, 1, 1, 1, 1] : tensor to tensor + %5 = kernel.launch @memset_zero_2D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %5 into %arg6[0, 0, %arg3, %arg5, 0] [1, %c2, 1, 1, %c6] [1, 1, 1, 1, 1] : tensor into tensor + %6 = polygeist.submap(%inserted_slice, %arg3, %arg5, %c6, %c2, %c2, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index, index) -> tensor + %7 = polygeist.submap(%0, %arg3, %arg5, %c6) {map = #map2} : (tensor, index, index, index) -> tensor + %8 = polygeist.submap(%7, %c6, %c2, %c2, %c2, %c2) {map = #map3} : (tensor, index, index, index, index, index) -> tensor + %9 = polygeist.submap(%0, %arg3, %arg5, %c6) {map = #map4} : (tensor, index, index, index) -> tensor + %10 = polygeist.submap(%9, %c6, %c2, %c2, %c2, %c2) {map = #map3} : (tensor, index, index, index, index, index) -> tensor + %11 = polygeist.submap(%0, %arg3, %arg5, %c6) {map = #map5} : (tensor, index, index, index) -> tensor + %12 = polygeist.submap(%11, %c6, %c2, %c2, %c2, %c2) {map = #map3} : (tensor, index, index, index, index, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map6, #map6, #map6, #map6], iterator_types = ["parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%8, %10, %12 : tensor, tensor, tensor) outs(%6 : tensor) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32): + %15 = arith.addf %in, %cst : f32 + %16 = arith.mulf %15, %cst_0 : f32 + %17 = arith.mulf %16, %cst_4 : f32 + %18 = arith.addf %in_5, %cst : f32 + %19 = arith.mulf %18, %cst_0 : f32 + %20 = arith.mulf %19, %cst_3 : f32 + %21 = arith.addf %in_6, %cst : f32 + %22 = arith.mulf %21, %cst_0 : f32 + %23 = arith.mulf %22, %cst_2 : f32 + %24 = arith.fptosi %17 : f32 to i32 + %25 = arith.fptosi %20 : f32 to i32 + %26 = arith.fptosi %23 : f32 to i32 + %27 = arith.sitofp %24 : i32 to f32 + %28 = arith.subf %17, %27 : f32 + %29 = arith.sitofp %25 : i32 to f32 + %30 = arith.subf %20, %29 : f32 + %31 = arith.sitofp %26 : i32 to f32 + %32 = arith.subf %23, %31 : f32 + %33 = arith.subf %cst, %28 : f32 + %34 = arith.subf %cst, %30 : f32 + %35 = arith.subf %cst, %32 : f32 + %36 = linalg.index 1 : index + %37 = linalg.index 2 : index + %38 = arith.index_cast %37 : index to i32 + %39 = arith.addi %26, %38 : i32 + %40 = arith.cmpi sge, %39, %c0_i32 : i32 + %41 = arith.cmpi slt, %39, %c6_i32 : i32 + %42 = arith.index_cast %39 : i32 to index + %43 = arith.cmpi ne, %38, %c0_i32 : i32 + %44 = arith.select %43, %32, %35 : f32 + %45 = linalg.index 3 : index + %46 = arith.index_cast %45 : index to i32 + %47 = arith.addi %25, %46 : i32 + %48 = arith.cmpi sge, %47, %c0_i32 : i32 + %49 = arith.cmpi slt, %47, %c7_i32 : i32 + %50 = arith.index_cast %47 : i32 to index + %51 = arith.cmpi ne, %46, %c0_i32 : i32 + %52 = arith.select %51, %30, %34 : f32 + %53 = linalg.index 4 : index + %54 = arith.index_cast %53 : index to i32 + %55 = arith.addi %24, %54 : i32 + %56 = arith.cmpi sge, %55, %c0_i32 : i32 + %57 = arith.cmpi slt, %55, %c8_i32 : i32 + %58 = arith.andi %56, %57 : i1 + %59 = arith.andi %49, %58 : i1 + %60 = arith.andi %48, %59 : i1 + %61 = arith.andi %41, %60 : i1 + %62 = arith.andi %40, %61 : i1 + %63 = arith.index_cast %55 : i32 to index + %64 = memref.load %arg0[%c0, %36, %42, %50, %63] : memref + %65 = arith.mulf %64, %44 : f32 + %66 = arith.mulf %65, %52 : f32 + %67 = arith.cmpi ne, %54, %c0_i32 : i32 + %68 = arith.select %67, %28, %33 : f32 + %69 = arith.mulf %66, %68 : f32 + %70 = arith.addf %out, %69 : f32 + %71 = arith.select %62, %70, %out : f32 + linalg.yield %71 : f32 + } -> tensor + %14 = polygeist.submapInverse(%inserted_slice, %13, %arg3, %arg5, %c6, %c2, %c2, %c2, %c2) {map = #map1} : (tensor, tensor, index, index, index, index, index, index, index) -> tensor + affine.yield %14 : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu/orig.mlir new file mode 100644 index 000000000000..eea2d2cd9db9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu/orig.mlir @@ -0,0 +1,94 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 7.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %cst_3 = arith.constant 5.000000e-01 : f32 + %cst_4 = arith.constant 1.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 6 { + %0 = affine.load %arg1[0, %arg3, %arg4, %arg5, 0] : memref + %1 = arith.addf %0, %cst_4 : f32 + %2 = arith.mulf %1, %cst_3 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = affine.load %arg1[0, %arg3, %arg4, %arg5, 1] : memref + %5 = arith.addf %4, %cst_4 : f32 + %6 = arith.mulf %5, %cst_3 : f32 + %7 = arith.mulf %6, %cst_0 : f32 + %8 = affine.load %arg1[0, %arg3, %arg4, %arg5, 2] : memref + %9 = arith.addf %8, %cst_4 : f32 + %10 = arith.mulf %9, %cst_3 : f32 + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.fptosi %3 : f32 to i32 + %13 = arith.fptosi %7 : f32 to i32 + %14 = arith.fptosi %11 : f32 to i32 + %15 = arith.sitofp %12 : i32 to f32 + %16 = arith.subf %3, %15 : f32 + %17 = arith.sitofp %13 : i32 to f32 + %18 = arith.subf %7, %17 : f32 + %19 = arith.sitofp %14 : i32 to f32 + %20 = arith.subf %11, %19 : f32 + %21 = arith.subf %cst_4, %16 : f32 + %22 = arith.subf %cst_4, %18 : f32 + %23 = arith.subf %cst_4, %20 : f32 + affine.for %arg6 = 0 to 2 { + %24 = affine.for %arg7 = 0 to 2 iter_args(%arg8 = %cst_2) -> (f32) { + %25 = arith.index_cast %arg7 : index to i32 + %26 = arith.addi %14, %25 : i32 + %27 = arith.cmpi sge, %26, %c0_i32 : i32 + %28 = arith.cmpi slt, %26, %c6_i32 : i32 + %29 = arith.index_cast %26 : i32 to index + %30 = arith.cmpi ne, %25, %c0_i32 : i32 + %31 = arith.select %30, %20, %23 : f32 + %32 = affine.for %arg9 = 0 to 2 iter_args(%arg10 = %arg8) -> (f32) { + %33 = arith.index_cast %arg9 : index to i32 + %34 = arith.addi %13, %33 : i32 + %35 = arith.cmpi sge, %34, %c0_i32 : i32 + %36 = arith.cmpi slt, %34, %c7_i32 : i32 + %37 = arith.index_cast %34 : i32 to index + %38 = arith.cmpi ne, %33, %c0_i32 : i32 + %39 = arith.select %38, %18, %22 : f32 + %40 = affine.for %arg11 = 0 to 2 iter_args(%arg12 = %arg10) -> (f32) { + %41 = arith.index_cast %arg11 : index to i32 + %42 = arith.addi %12, %41 : i32 + %43 = arith.cmpi sge, %42, %c0_i32 : i32 + %44 = arith.cmpi slt, %42, %c8_i32 : i32 + %45 = arith.andi %43, %44 : i1 + %46 = arith.andi %36, %45 : i1 + %47 = arith.andi %35, %46 : i1 + %48 = arith.andi %28, %47 : i1 + %49 = arith.andi %27, %48 : i1 + %50 = scf.if %49 -> (f32) { + %51 = arith.index_cast %42 : i32 to index + %52 = memref.load %arg0[%c0, %arg6, %29, %37, %51] : memref + %53 = arith.mulf %52, %31 : f32 + %54 = arith.mulf %53, %39 : f32 + %55 = arith.cmpi ne, %41, %c0_i32 : i32 + %56 = arith.select %55, %16, %21 : f32 + %57 = arith.mulf %54, %56 : f32 + %58 = arith.addf %arg12, %57 : f32 + scf.yield %58 : f32 + } else { + scf.yield %arg12 : f32 + } + affine.yield %50 : f32 + } + affine.yield %40 : f32 + } + affine.yield %32 : f32 + } + affine.store %24, %arg2[0, %arg6, %arg3, %arg4, %arg5] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu/raised.mlir new file mode 100644 index 000000000000..7ea1617af840 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu/raised.mlir @@ -0,0 +1,103 @@ +#map = affine_map<(d0, d1) -> (d1, d0)> +#map1 = affine_map<(d0, d1, d2, d3, d4)[s0, s1] -> (0, d1, s0, s1, d0)> +#map2 = affine_map<(d0)[s0, s1] -> (0, s0, s1, d0, 0)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0)> +#map4 = affine_map<(d0)[s0, s1] -> (0, s0, s1, d0, 1)> +#map5 = affine_map<(d0)[s0, s1] -> (0, s0, s1, d0, 2)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c6 = arith.constant 6 : index + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %cst = arith.constant 7.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %cst_3 = arith.constant 5.000000e-01 : f32 + %cst_4 = arith.constant 1.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 5 { + %subview = memref.subview %arg2[0, 0, %arg3, %arg4, 0] [1, %c2, 1, 1, %c6] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_2 : f32 + } + %0 = polygeist.submap(%arg2, %arg3, %arg4, %c6, %c2, %c2, %c2, %c2) {map = #map1} : (memref, index, index, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %arg3, %arg4, %c6) {map = #map2} : (memref, index, index, index) -> memref + %2 = polygeist.submap(%1, %c6, %c2, %c2, %c2, %c2) {map = #map3} : (memref, index, index, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg4, %c6) {map = #map4} : (memref, index, index, index) -> memref + %4 = polygeist.submap(%3, %c6, %c2, %c2, %c2, %c2) {map = #map3} : (memref, index, index, index, index, index) -> memref + %5 = polygeist.submap(%arg1, %arg3, %arg4, %c6) {map = #map5} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%5, %c6, %c2, %c2, %c2, %c2) {map = #map3} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map6, #map6, #map6], iterator_types = ["parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%2, %4, %6 : memref, memref, memref) outs(%0 : memref) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32): + %7 = arith.addf %in, %cst_4 : f32 + %8 = arith.mulf %7, %cst_3 : f32 + %9 = arith.mulf %8, %cst : f32 + %10 = arith.addf %in_5, %cst_4 : f32 + %11 = arith.mulf %10, %cst_3 : f32 + %12 = arith.mulf %11, %cst_0 : f32 + %13 = arith.addf %in_6, %cst_4 : f32 + %14 = arith.mulf %13, %cst_3 : f32 + %15 = arith.mulf %14, %cst_1 : f32 + %16 = arith.fptosi %9 : f32 to i32 + %17 = arith.fptosi %12 : f32 to i32 + %18 = arith.fptosi %15 : f32 to i32 + %19 = arith.sitofp %16 : i32 to f32 + %20 = arith.subf %9, %19 : f32 + %21 = arith.sitofp %17 : i32 to f32 + %22 = arith.subf %12, %21 : f32 + %23 = arith.sitofp %18 : i32 to f32 + %24 = arith.subf %15, %23 : f32 + %25 = arith.subf %cst_4, %20 : f32 + %26 = arith.subf %cst_4, %22 : f32 + %27 = arith.subf %cst_4, %24 : f32 + %28 = linalg.index 1 : index + %29 = linalg.index 2 : index + %30 = arith.index_cast %29 : index to i32 + %31 = arith.addi %18, %30 : i32 + %32 = arith.cmpi sge, %31, %c0_i32 : i32 + %33 = arith.cmpi slt, %31, %c6_i32 : i32 + %34 = arith.index_cast %31 : i32 to index + %35 = arith.cmpi ne, %30, %c0_i32 : i32 + %36 = arith.select %35, %24, %27 : f32 + %37 = linalg.index 3 : index + %38 = arith.index_cast %37 : index to i32 + %39 = arith.addi %17, %38 : i32 + %40 = arith.cmpi sge, %39, %c0_i32 : i32 + %41 = arith.cmpi slt, %39, %c7_i32 : i32 + %42 = arith.index_cast %39 : i32 to index + %43 = arith.cmpi ne, %38, %c0_i32 : i32 + %44 = arith.select %43, %22, %26 : f32 + %45 = linalg.index 4 : index + %46 = arith.index_cast %45 : index to i32 + %47 = arith.addi %16, %46 : i32 + %48 = arith.cmpi sge, %47, %c0_i32 : i32 + %49 = arith.cmpi slt, %47, %c8_i32 : i32 + %50 = arith.andi %48, %49 : i1 + %51 = arith.andi %41, %50 : i1 + %52 = arith.andi %40, %51 : i1 + %53 = arith.andi %33, %52 : i1 + %54 = arith.andi %32, %53 : i1 + %55 = arith.index_cast %47 : i32 to index + %56 = memref.load %arg0[%c0, %28, %34, %42, %55] : memref + %57 = arith.mulf %56, %36 : f32 + %58 = arith.mulf %57, %44 : f32 + %59 = arith.cmpi ne, %46, %c0_i32 : i32 + %60 = arith.select %59, %20, %25 : f32 + %61 = arith.mulf %58, %60 : f32 + %62 = arith.addf %out, %61 : f32 + %63 = arith.select %54, %62, %out : f32 + linalg.yield %63 : f32 + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu_debuf.mlir new file mode 100644 index 000000000000..3d0ec6060b29 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu_debuf.mlir @@ -0,0 +1,111 @@ +#map = affine_map<(d0, d1) -> (d1, d0)> +#map1 = affine_map<(d0, d1, d2, d3, d4)[s0, s1] -> (0, d1, s0, s1, d0)> +#map2 = affine_map<(d0)[s0, s1] -> (0, s0, s1, d0, 0)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0)> +#map4 = affine_map<(d0)[s0, s1] -> (0, s0, s1, d0, 1)> +#map5 = affine_map<(d0)[s0, s1] -> (0, s0, s1, d0, 2)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %c7_i32 = arith.constant 7 : i32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 6.000000e+00 : f32 + %cst_4 = arith.constant 7.000000e+00 : f32 + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = affine.for %arg3 = 0 to 4 iter_args(%arg4 = %1) -> (tensor) { + %4 = affine.for %arg5 = 0 to 5 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted_slice = tensor.extract_slice %arg6[0, 0, %arg3, %arg5, 0] [1, %c2, 1, 1, %c6] [1, 1, 1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst_1 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %arg6[0, 0, %arg3, %arg5, 0] [1, %c2, 1, 1, %c6] [1, 1, 1, 1, 1] : tensor into tensor + %6 = polygeist.submap(%inserted_slice, %arg3, %arg5, %c6, %c2, %c2, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index, index) -> tensor + %7 = polygeist.submap(%0, %arg3, %arg5, %c6) {map = #map2} : (tensor, index, index, index) -> tensor + %8 = polygeist.submap(%7, %c6, %c2, %c2, %c2, %c2) {map = #map3} : (tensor, index, index, index, index, index) -> tensor + %9 = polygeist.submap(%0, %arg3, %arg5, %c6) {map = #map4} : (tensor, index, index, index) -> tensor + %10 = polygeist.submap(%9, %c6, %c2, %c2, %c2, %c2) {map = #map3} : (tensor, index, index, index, index, index) -> tensor + %11 = polygeist.submap(%0, %arg3, %arg5, %c6) {map = #map5} : (tensor, index, index, index) -> tensor + %12 = polygeist.submap(%11, %c6, %c2, %c2, %c2, %c2) {map = #map3} : (tensor, index, index, index, index, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map6, #map6, #map6, #map6], iterator_types = ["parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%8, %10, %12 : tensor, tensor, tensor) outs(%6 : tensor) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32): + %15 = arith.addf %in, %cst : f32 + %16 = arith.mulf %15, %cst_0 : f32 + %17 = arith.mulf %16, %cst_4 : f32 + %18 = arith.addf %in_5, %cst : f32 + %19 = arith.mulf %18, %cst_0 : f32 + %20 = arith.mulf %19, %cst_3 : f32 + %21 = arith.addf %in_6, %cst : f32 + %22 = arith.mulf %21, %cst_0 : f32 + %23 = arith.mulf %22, %cst_2 : f32 + %24 = arith.fptosi %17 : f32 to i32 + %25 = arith.fptosi %20 : f32 to i32 + %26 = arith.fptosi %23 : f32 to i32 + %27 = arith.sitofp %24 : i32 to f32 + %28 = arith.subf %17, %27 : f32 + %29 = arith.sitofp %25 : i32 to f32 + %30 = arith.subf %20, %29 : f32 + %31 = arith.sitofp %26 : i32 to f32 + %32 = arith.subf %23, %31 : f32 + %33 = arith.subf %cst, %28 : f32 + %34 = arith.subf %cst, %30 : f32 + %35 = arith.subf %cst, %32 : f32 + %36 = linalg.index 1 : index + %37 = linalg.index 2 : index + %38 = arith.index_cast %37 : index to i32 + %39 = arith.addi %26, %38 : i32 + %40 = arith.cmpi sge, %39, %c0_i32 : i32 + %41 = arith.cmpi slt, %39, %c6_i32 : i32 + %42 = arith.index_cast %39 : i32 to index + %43 = arith.cmpi ne, %38, %c0_i32 : i32 + %44 = arith.select %43, %32, %35 : f32 + %45 = linalg.index 3 : index + %46 = arith.index_cast %45 : index to i32 + %47 = arith.addi %25, %46 : i32 + %48 = arith.cmpi sge, %47, %c0_i32 : i32 + %49 = arith.cmpi slt, %47, %c7_i32 : i32 + %50 = arith.index_cast %47 : i32 to index + %51 = arith.cmpi ne, %46, %c0_i32 : i32 + %52 = arith.select %51, %30, %34 : f32 + %53 = linalg.index 4 : index + %54 = arith.index_cast %53 : index to i32 + %55 = arith.addi %24, %54 : i32 + %56 = arith.cmpi sge, %55, %c0_i32 : i32 + %57 = arith.cmpi slt, %55, %c8_i32 : i32 + %58 = arith.andi %56, %57 : i1 + %59 = arith.andi %49, %58 : i1 + %60 = arith.andi %48, %59 : i1 + %61 = arith.andi %41, %60 : i1 + %62 = arith.andi %40, %61 : i1 + %63 = arith.index_cast %55 : i32 to index + %64 = memref.load %arg0[%c0, %36, %42, %50, %63] : memref + %65 = arith.mulf %64, %44 : f32 + %66 = arith.mulf %65, %52 : f32 + %67 = arith.cmpi ne, %54, %c0_i32 : i32 + %68 = arith.select %67, %28, %33 : f32 + %69 = arith.mulf %66, %68 : f32 + %70 = arith.addf %out, %69 : f32 + %71 = arith.select %62, %70, %out : f32 + linalg.yield %71 : f32 + } -> tensor + %14 = polygeist.submapInverse(%inserted_slice, %13, %arg3, %arg5, %c6, %c2, %c2, %c2, %c2) {map = #map1} : (tensor, tensor, index, index, index, index, index, index, index) -> tensor + affine.yield %14 : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu_linalg.mlir new file mode 100644 index 000000000000..7ea1617af840 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_grid_sampler_3d_cpu_linalg.mlir @@ -0,0 +1,103 @@ +#map = affine_map<(d0, d1) -> (d1, d0)> +#map1 = affine_map<(d0, d1, d2, d3, d4)[s0, s1] -> (0, d1, s0, s1, d0)> +#map2 = affine_map<(d0)[s0, s1] -> (0, s0, s1, d0, 0)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0)> +#map4 = affine_map<(d0)[s0, s1] -> (0, s0, s1, d0, 1)> +#map5 = affine_map<(d0)[s0, s1] -> (0, s0, s1, d0, 2)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_grid_sampler_3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c6 = arith.constant 6 : index + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %cst = arith.constant 7.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %cst_3 = arith.constant 5.000000e-01 : f32 + %cst_4 = arith.constant 1.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 5 { + %subview = memref.subview %arg2[0, 0, %arg3, %arg4, 0] [1, %c2, 1, 1, %c6] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_2 : f32 + } + %0 = polygeist.submap(%arg2, %arg3, %arg4, %c6, %c2, %c2, %c2, %c2) {map = #map1} : (memref, index, index, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %arg3, %arg4, %c6) {map = #map2} : (memref, index, index, index) -> memref + %2 = polygeist.submap(%1, %c6, %c2, %c2, %c2, %c2) {map = #map3} : (memref, index, index, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg4, %c6) {map = #map4} : (memref, index, index, index) -> memref + %4 = polygeist.submap(%3, %c6, %c2, %c2, %c2, %c2) {map = #map3} : (memref, index, index, index, index, index) -> memref + %5 = polygeist.submap(%arg1, %arg3, %arg4, %c6) {map = #map5} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%5, %c6, %c2, %c2, %c2, %c2) {map = #map3} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map6, #map6, #map6], iterator_types = ["parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%2, %4, %6 : memref, memref, memref) outs(%0 : memref) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32): + %7 = arith.addf %in, %cst_4 : f32 + %8 = arith.mulf %7, %cst_3 : f32 + %9 = arith.mulf %8, %cst : f32 + %10 = arith.addf %in_5, %cst_4 : f32 + %11 = arith.mulf %10, %cst_3 : f32 + %12 = arith.mulf %11, %cst_0 : f32 + %13 = arith.addf %in_6, %cst_4 : f32 + %14 = arith.mulf %13, %cst_3 : f32 + %15 = arith.mulf %14, %cst_1 : f32 + %16 = arith.fptosi %9 : f32 to i32 + %17 = arith.fptosi %12 : f32 to i32 + %18 = arith.fptosi %15 : f32 to i32 + %19 = arith.sitofp %16 : i32 to f32 + %20 = arith.subf %9, %19 : f32 + %21 = arith.sitofp %17 : i32 to f32 + %22 = arith.subf %12, %21 : f32 + %23 = arith.sitofp %18 : i32 to f32 + %24 = arith.subf %15, %23 : f32 + %25 = arith.subf %cst_4, %20 : f32 + %26 = arith.subf %cst_4, %22 : f32 + %27 = arith.subf %cst_4, %24 : f32 + %28 = linalg.index 1 : index + %29 = linalg.index 2 : index + %30 = arith.index_cast %29 : index to i32 + %31 = arith.addi %18, %30 : i32 + %32 = arith.cmpi sge, %31, %c0_i32 : i32 + %33 = arith.cmpi slt, %31, %c6_i32 : i32 + %34 = arith.index_cast %31 : i32 to index + %35 = arith.cmpi ne, %30, %c0_i32 : i32 + %36 = arith.select %35, %24, %27 : f32 + %37 = linalg.index 3 : index + %38 = arith.index_cast %37 : index to i32 + %39 = arith.addi %17, %38 : i32 + %40 = arith.cmpi sge, %39, %c0_i32 : i32 + %41 = arith.cmpi slt, %39, %c7_i32 : i32 + %42 = arith.index_cast %39 : i32 to index + %43 = arith.cmpi ne, %38, %c0_i32 : i32 + %44 = arith.select %43, %22, %26 : f32 + %45 = linalg.index 4 : index + %46 = arith.index_cast %45 : index to i32 + %47 = arith.addi %16, %46 : i32 + %48 = arith.cmpi sge, %47, %c0_i32 : i32 + %49 = arith.cmpi slt, %47, %c8_i32 : i32 + %50 = arith.andi %48, %49 : i1 + %51 = arith.andi %41, %50 : i1 + %52 = arith.andi %40, %51 : i1 + %53 = arith.andi %33, %52 : i1 + %54 = arith.andi %32, %53 : i1 + %55 = arith.index_cast %47 : i32 to index + %56 = memref.load %arg0[%c0, %28, %34, %42, %55] : memref + %57 = arith.mulf %56, %36 : f32 + %58 = arith.mulf %57, %44 : f32 + %59 = arith.cmpi ne, %46, %c0_i32 : i32 + %60 = arith.select %59, %20, %25 : f32 + %61 = arith.mulf %58, %60 : f32 + %62 = arith.addf %out, %61 : f32 + %63 = arith.select %54, %62, %out : f32 + linalg.yield %63 : f32 + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_group_norm_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_group_norm_backward_cpu.mlir new file mode 100644 index 000000000000..7a5490ca0bc7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_group_norm_backward_cpu.mlir @@ -0,0 +1,46 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_group_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.200000e+01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.load %arg2[%arg6, %arg7] : memref + %1:2 = affine.for %arg8 = 0 to 2 iter_args(%arg9 = %cst_0, %arg10 = %cst_0) -> (f32, f32) { + %2 = affine.load %arg4[%arg7, %arg8] : memref + %3:2 = affine.for %arg11 = 0 to 16 iter_args(%arg12 = %arg9, %arg13 = %arg10) -> (f32, f32) { + %4 = affine.load %arg0[%arg6, %arg7, %arg8, %arg11] : memref + %5 = arith.mulf %4, %2 : f32 + %6 = arith.addf %arg13, %5 : f32 + %7 = affine.load %arg1[%arg6, %arg7, %arg8, %arg11] : memref + %8 = arith.subf %7, %0 : f32 + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg12, %9 : f32 + affine.yield %10, %6 : f32, f32 + } + affine.yield %3#0, %3#1 : f32, f32 + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 16 { + %2 = affine.load %arg0[%arg6, %arg7, %arg8, %arg9] : memref + %3 = affine.load %arg4[%arg7, %arg8] : memref + %4 = arith.mulf %2, %3 : f32 + %5 = affine.load %arg3[%arg6, %arg7] : memref + %6 = arith.divf %5, %cst : f32 + %7 = arith.mulf %4, %cst : f32 + %8 = arith.subf %7, %1#1 : f32 + %9 = affine.load %arg1[%arg6, %arg7, %arg8, %arg9] : memref + %10 = affine.load %arg2[%arg6, %arg7] : memref + %11 = arith.subf %9, %10 : f32 + %12 = arith.mulf %11, %5 : f32 + %13 = arith.mulf %12, %5 : f32 + %14 = arith.mulf %13, %1#0 : f32 + %15 = arith.subf %8, %14 : f32 + %16 = arith.mulf %6, %15 : f32 + affine.store %16, %arg5[%arg6, %arg7, %arg8, %arg9] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_group_norm_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_group_norm_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..0a55a619e277 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_group_norm_backward_cpu/debuf.mlir @@ -0,0 +1,81 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1, d2) -> (d0)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map4 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_group_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 3.200000e+01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg6 = 0 to 4 { + %alloca = memref.alloca(%c4) : memref + %alloca_1 = memref.alloca(%c4) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + affine.for %arg7 = 0 to 4 { + %2 = affine.load %arg2[%arg6, %arg7] : memref + %alloca_9 = memref.alloca(%c2) : memref + %alloca_10 = memref.alloca(%c2) : memref + affine.for %arg8 = 0 to 2 { + %3 = affine.load %alloca[%arg7] : memref + %4 = affine.load %alloca_1[%arg7] : memref + %5 = affine.load %arg4[%arg7, %arg8] : memref + affine.store %3, %alloca_9[%arg8] : memref + affine.store %4, %alloca_10[%arg8] : memref + %subview_11 = memref.subview %arg0[%arg6, %arg7, %arg8, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %arg1[%arg6, %arg7, %arg8, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_13 = memref.subview %alloca_9[%arg8] [1] [1] : memref to memref> + %subview_14 = memref.subview %alloca_10[%arg8] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview_11, %subview_12 : memref>, memref>) outs(%subview_13, %subview_14 : memref>, memref>) { + ^bb0(%in: f32, %in_15: f32, %out: f32, %out_16: f32): + %8 = arith.mulf %in, %5 : f32 + %9 = arith.addf %out_16, %8 : f32 + %10 = arith.subf %in_15, %2 : f32 + %11 = arith.mulf %8, %10 : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12, %9 : f32, f32 + } + %6 = affine.load %alloca_9[%arg8] : memref + %7 = affine.load %alloca_10[%arg8] : memref + affine.store %6, %alloca[%arg7] : memref + affine.store %7, %alloca_1[%arg7] : memref + } + } {polygeist.was_parallel} + %subview = memref.subview %arg0[%arg6, 0, 0, 0] [1, %c4, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg4[0, 0] [%c4, %c2] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg3[%arg6, 0] [1, %c4] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg1[%arg6, 0, 0, 0] [1, %c4, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %subview_5 = memref.subview %arg2[%arg6, 0] [1, %c4] [1, 1] : memref to memref> + %subview_6 = memref.subview %arg5[%arg6, 0, 0, 0] [1, %c4, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %0 = polygeist.submap(%alloca, %c4) {map = #map} : (memref, index) -> memref + %subview_7 = memref.subview %0[0] [%c4] [1] : memref to memref> + %1 = polygeist.submap(%alloca_1, %c4) {map = #map} : (memref, index) -> memref + %subview_8 = memref.subview %1[0] [%c4] [1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map3, #map4, #map2, #map3, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview_7, %subview_8, %subview, %subview_2, %subview_3, %subview_4, %subview_5 : memref>, memref>, memref>, memref>, memref>, memref>, memref>) outs(%subview_6 : memref>) { + ^bb0(%in: f32, %in_9: f32, %in_10: f32, %in_11: f32, %in_12: f32, %in_13: f32, %in_14: f32, %out: f32): + %2 = arith.mulf %in_10, %in_11 : f32 + %3 = arith.divf %in_12, %cst : f32 + %4 = arith.mulf %2, %cst : f32 + %5 = arith.subf %4, %in_9 : f32 + %6 = arith.subf %in_13, %in_14 : f32 + %7 = arith.mulf %6, %in_12 : f32 + %8 = arith.mulf %7, %in_12 : f32 + %9 = arith.mulf %8, %in : f32 + %10 = arith.subf %5, %9 : f32 + %11 = arith.mulf %3, %10 : f32 + linalg.yield %11 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_group_norm_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_group_norm_backward_cpu/matched.mlir new file mode 100644 index 000000000000..0a55a619e277 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_group_norm_backward_cpu/matched.mlir @@ -0,0 +1,81 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1, d2) -> (d0)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map4 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_group_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 3.200000e+01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg6 = 0 to 4 { + %alloca = memref.alloca(%c4) : memref + %alloca_1 = memref.alloca(%c4) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + affine.for %arg7 = 0 to 4 { + %2 = affine.load %arg2[%arg6, %arg7] : memref + %alloca_9 = memref.alloca(%c2) : memref + %alloca_10 = memref.alloca(%c2) : memref + affine.for %arg8 = 0 to 2 { + %3 = affine.load %alloca[%arg7] : memref + %4 = affine.load %alloca_1[%arg7] : memref + %5 = affine.load %arg4[%arg7, %arg8] : memref + affine.store %3, %alloca_9[%arg8] : memref + affine.store %4, %alloca_10[%arg8] : memref + %subview_11 = memref.subview %arg0[%arg6, %arg7, %arg8, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %arg1[%arg6, %arg7, %arg8, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_13 = memref.subview %alloca_9[%arg8] [1] [1] : memref to memref> + %subview_14 = memref.subview %alloca_10[%arg8] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview_11, %subview_12 : memref>, memref>) outs(%subview_13, %subview_14 : memref>, memref>) { + ^bb0(%in: f32, %in_15: f32, %out: f32, %out_16: f32): + %8 = arith.mulf %in, %5 : f32 + %9 = arith.addf %out_16, %8 : f32 + %10 = arith.subf %in_15, %2 : f32 + %11 = arith.mulf %8, %10 : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12, %9 : f32, f32 + } + %6 = affine.load %alloca_9[%arg8] : memref + %7 = affine.load %alloca_10[%arg8] : memref + affine.store %6, %alloca[%arg7] : memref + affine.store %7, %alloca_1[%arg7] : memref + } + } {polygeist.was_parallel} + %subview = memref.subview %arg0[%arg6, 0, 0, 0] [1, %c4, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg4[0, 0] [%c4, %c2] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg3[%arg6, 0] [1, %c4] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg1[%arg6, 0, 0, 0] [1, %c4, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %subview_5 = memref.subview %arg2[%arg6, 0] [1, %c4] [1, 1] : memref to memref> + %subview_6 = memref.subview %arg5[%arg6, 0, 0, 0] [1, %c4, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %0 = polygeist.submap(%alloca, %c4) {map = #map} : (memref, index) -> memref + %subview_7 = memref.subview %0[0] [%c4] [1] : memref to memref> + %1 = polygeist.submap(%alloca_1, %c4) {map = #map} : (memref, index) -> memref + %subview_8 = memref.subview %1[0] [%c4] [1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map3, #map4, #map2, #map3, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview_7, %subview_8, %subview, %subview_2, %subview_3, %subview_4, %subview_5 : memref>, memref>, memref>, memref>, memref>, memref>, memref>) outs(%subview_6 : memref>) { + ^bb0(%in: f32, %in_9: f32, %in_10: f32, %in_11: f32, %in_12: f32, %in_13: f32, %in_14: f32, %out: f32): + %2 = arith.mulf %in_10, %in_11 : f32 + %3 = arith.divf %in_12, %cst : f32 + %4 = arith.mulf %2, %cst : f32 + %5 = arith.subf %4, %in_9 : f32 + %6 = arith.subf %in_13, %in_14 : f32 + %7 = arith.mulf %6, %in_12 : f32 + %8 = arith.mulf %7, %in_12 : f32 + %9 = arith.mulf %8, %in : f32 + %10 = arith.subf %5, %9 : f32 + %11 = arith.mulf %3, %10 : f32 + linalg.yield %11 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_group_norm_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_group_norm_backward_cpu/orig.mlir new file mode 100644 index 000000000000..7a5490ca0bc7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_group_norm_backward_cpu/orig.mlir @@ -0,0 +1,46 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_group_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.200000e+01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.load %arg2[%arg6, %arg7] : memref + %1:2 = affine.for %arg8 = 0 to 2 iter_args(%arg9 = %cst_0, %arg10 = %cst_0) -> (f32, f32) { + %2 = affine.load %arg4[%arg7, %arg8] : memref + %3:2 = affine.for %arg11 = 0 to 16 iter_args(%arg12 = %arg9, %arg13 = %arg10) -> (f32, f32) { + %4 = affine.load %arg0[%arg6, %arg7, %arg8, %arg11] : memref + %5 = arith.mulf %4, %2 : f32 + %6 = arith.addf %arg13, %5 : f32 + %7 = affine.load %arg1[%arg6, %arg7, %arg8, %arg11] : memref + %8 = arith.subf %7, %0 : f32 + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg12, %9 : f32 + affine.yield %10, %6 : f32, f32 + } + affine.yield %3#0, %3#1 : f32, f32 + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 16 { + %2 = affine.load %arg0[%arg6, %arg7, %arg8, %arg9] : memref + %3 = affine.load %arg4[%arg7, %arg8] : memref + %4 = arith.mulf %2, %3 : f32 + %5 = affine.load %arg3[%arg6, %arg7] : memref + %6 = arith.divf %5, %cst : f32 + %7 = arith.mulf %4, %cst : f32 + %8 = arith.subf %7, %1#1 : f32 + %9 = affine.load %arg1[%arg6, %arg7, %arg8, %arg9] : memref + %10 = affine.load %arg2[%arg6, %arg7] : memref + %11 = arith.subf %9, %10 : f32 + %12 = arith.mulf %11, %5 : f32 + %13 = arith.mulf %12, %5 : f32 + %14 = arith.mulf %13, %1#0 : f32 + %15 = arith.subf %8, %14 : f32 + %16 = arith.mulf %6, %15 : f32 + affine.store %16, %arg5[%arg6, %arg7, %arg8, %arg9] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_group_norm_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_group_norm_backward_cpu/raised.mlir new file mode 100644 index 000000000000..0a55a619e277 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_group_norm_backward_cpu/raised.mlir @@ -0,0 +1,81 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1, d2) -> (d0)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map4 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_group_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 3.200000e+01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg6 = 0 to 4 { + %alloca = memref.alloca(%c4) : memref + %alloca_1 = memref.alloca(%c4) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + affine.for %arg7 = 0 to 4 { + %2 = affine.load %arg2[%arg6, %arg7] : memref + %alloca_9 = memref.alloca(%c2) : memref + %alloca_10 = memref.alloca(%c2) : memref + affine.for %arg8 = 0 to 2 { + %3 = affine.load %alloca[%arg7] : memref + %4 = affine.load %alloca_1[%arg7] : memref + %5 = affine.load %arg4[%arg7, %arg8] : memref + affine.store %3, %alloca_9[%arg8] : memref + affine.store %4, %alloca_10[%arg8] : memref + %subview_11 = memref.subview %arg0[%arg6, %arg7, %arg8, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %arg1[%arg6, %arg7, %arg8, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_13 = memref.subview %alloca_9[%arg8] [1] [1] : memref to memref> + %subview_14 = memref.subview %alloca_10[%arg8] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview_11, %subview_12 : memref>, memref>) outs(%subview_13, %subview_14 : memref>, memref>) { + ^bb0(%in: f32, %in_15: f32, %out: f32, %out_16: f32): + %8 = arith.mulf %in, %5 : f32 + %9 = arith.addf %out_16, %8 : f32 + %10 = arith.subf %in_15, %2 : f32 + %11 = arith.mulf %8, %10 : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12, %9 : f32, f32 + } + %6 = affine.load %alloca_9[%arg8] : memref + %7 = affine.load %alloca_10[%arg8] : memref + affine.store %6, %alloca[%arg7] : memref + affine.store %7, %alloca_1[%arg7] : memref + } + } {polygeist.was_parallel} + %subview = memref.subview %arg0[%arg6, 0, 0, 0] [1, %c4, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg4[0, 0] [%c4, %c2] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg3[%arg6, 0] [1, %c4] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg1[%arg6, 0, 0, 0] [1, %c4, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %subview_5 = memref.subview %arg2[%arg6, 0] [1, %c4] [1, 1] : memref to memref> + %subview_6 = memref.subview %arg5[%arg6, 0, 0, 0] [1, %c4, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %0 = polygeist.submap(%alloca, %c4) {map = #map} : (memref, index) -> memref + %subview_7 = memref.subview %0[0] [%c4] [1] : memref to memref> + %1 = polygeist.submap(%alloca_1, %c4) {map = #map} : (memref, index) -> memref + %subview_8 = memref.subview %1[0] [%c4] [1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map3, #map4, #map2, #map3, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview_7, %subview_8, %subview, %subview_2, %subview_3, %subview_4, %subview_5 : memref>, memref>, memref>, memref>, memref>, memref>, memref>) outs(%subview_6 : memref>) { + ^bb0(%in: f32, %in_9: f32, %in_10: f32, %in_11: f32, %in_12: f32, %in_13: f32, %in_14: f32, %out: f32): + %2 = arith.mulf %in_10, %in_11 : f32 + %3 = arith.divf %in_12, %cst : f32 + %4 = arith.mulf %2, %cst : f32 + %5 = arith.subf %4, %in_9 : f32 + %6 = arith.subf %in_13, %in_14 : f32 + %7 = arith.mulf %6, %in_12 : f32 + %8 = arith.mulf %7, %in_12 : f32 + %9 = arith.mulf %8, %in : f32 + %10 = arith.subf %5, %9 : f32 + %11 = arith.mulf %3, %10 : f32 + linalg.yield %11 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_group_norm_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_group_norm_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..0a55a619e277 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_group_norm_backward_cpu_debuf.mlir @@ -0,0 +1,81 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1, d2) -> (d0)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map4 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_group_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 3.200000e+01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg6 = 0 to 4 { + %alloca = memref.alloca(%c4) : memref + %alloca_1 = memref.alloca(%c4) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + affine.for %arg7 = 0 to 4 { + %2 = affine.load %arg2[%arg6, %arg7] : memref + %alloca_9 = memref.alloca(%c2) : memref + %alloca_10 = memref.alloca(%c2) : memref + affine.for %arg8 = 0 to 2 { + %3 = affine.load %alloca[%arg7] : memref + %4 = affine.load %alloca_1[%arg7] : memref + %5 = affine.load %arg4[%arg7, %arg8] : memref + affine.store %3, %alloca_9[%arg8] : memref + affine.store %4, %alloca_10[%arg8] : memref + %subview_11 = memref.subview %arg0[%arg6, %arg7, %arg8, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %arg1[%arg6, %arg7, %arg8, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_13 = memref.subview %alloca_9[%arg8] [1] [1] : memref to memref> + %subview_14 = memref.subview %alloca_10[%arg8] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview_11, %subview_12 : memref>, memref>) outs(%subview_13, %subview_14 : memref>, memref>) { + ^bb0(%in: f32, %in_15: f32, %out: f32, %out_16: f32): + %8 = arith.mulf %in, %5 : f32 + %9 = arith.addf %out_16, %8 : f32 + %10 = arith.subf %in_15, %2 : f32 + %11 = arith.mulf %8, %10 : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12, %9 : f32, f32 + } + %6 = affine.load %alloca_9[%arg8] : memref + %7 = affine.load %alloca_10[%arg8] : memref + affine.store %6, %alloca[%arg7] : memref + affine.store %7, %alloca_1[%arg7] : memref + } + } {polygeist.was_parallel} + %subview = memref.subview %arg0[%arg6, 0, 0, 0] [1, %c4, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg4[0, 0] [%c4, %c2] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg3[%arg6, 0] [1, %c4] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg1[%arg6, 0, 0, 0] [1, %c4, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %subview_5 = memref.subview %arg2[%arg6, 0] [1, %c4] [1, 1] : memref to memref> + %subview_6 = memref.subview %arg5[%arg6, 0, 0, 0] [1, %c4, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %0 = polygeist.submap(%alloca, %c4) {map = #map} : (memref, index) -> memref + %subview_7 = memref.subview %0[0] [%c4] [1] : memref to memref> + %1 = polygeist.submap(%alloca_1, %c4) {map = #map} : (memref, index) -> memref + %subview_8 = memref.subview %1[0] [%c4] [1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map3, #map4, #map2, #map3, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview_7, %subview_8, %subview, %subview_2, %subview_3, %subview_4, %subview_5 : memref>, memref>, memref>, memref>, memref>, memref>, memref>) outs(%subview_6 : memref>) { + ^bb0(%in: f32, %in_9: f32, %in_10: f32, %in_11: f32, %in_12: f32, %in_13: f32, %in_14: f32, %out: f32): + %2 = arith.mulf %in_10, %in_11 : f32 + %3 = arith.divf %in_12, %cst : f32 + %4 = arith.mulf %2, %cst : f32 + %5 = arith.subf %4, %in_9 : f32 + %6 = arith.subf %in_13, %in_14 : f32 + %7 = arith.mulf %6, %in_12 : f32 + %8 = arith.mulf %7, %in_12 : f32 + %9 = arith.mulf %8, %in : f32 + %10 = arith.subf %5, %9 : f32 + %11 = arith.mulf %3, %10 : f32 + linalg.yield %11 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_group_norm_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_group_norm_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..0a55a619e277 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_group_norm_backward_cpu_linalg.mlir @@ -0,0 +1,81 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0, d1, d2) -> (d0)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map4 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_group_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 3.200000e+01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg6 = 0 to 4 { + %alloca = memref.alloca(%c4) : memref + %alloca_1 = memref.alloca(%c4) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + affine.for %arg7 = 0 to 4 { + %2 = affine.load %arg2[%arg6, %arg7] : memref + %alloca_9 = memref.alloca(%c2) : memref + %alloca_10 = memref.alloca(%c2) : memref + affine.for %arg8 = 0 to 2 { + %3 = affine.load %alloca[%arg7] : memref + %4 = affine.load %alloca_1[%arg7] : memref + %5 = affine.load %arg4[%arg7, %arg8] : memref + affine.store %3, %alloca_9[%arg8] : memref + affine.store %4, %alloca_10[%arg8] : memref + %subview_11 = memref.subview %arg0[%arg6, %arg7, %arg8, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_12 = memref.subview %arg1[%arg6, %arg7, %arg8, 0] [1, 1, 1, %c16] [1, 1, 1, 1] : memref to memref> + %subview_13 = memref.subview %alloca_9[%arg8] [1] [1] : memref to memref> + %subview_14 = memref.subview %alloca_10[%arg8] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview_11, %subview_12 : memref>, memref>) outs(%subview_13, %subview_14 : memref>, memref>) { + ^bb0(%in: f32, %in_15: f32, %out: f32, %out_16: f32): + %8 = arith.mulf %in, %5 : f32 + %9 = arith.addf %out_16, %8 : f32 + %10 = arith.subf %in_15, %2 : f32 + %11 = arith.mulf %8, %10 : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12, %9 : f32, f32 + } + %6 = affine.load %alloca_9[%arg8] : memref + %7 = affine.load %alloca_10[%arg8] : memref + affine.store %6, %alloca[%arg7] : memref + affine.store %7, %alloca_1[%arg7] : memref + } + } {polygeist.was_parallel} + %subview = memref.subview %arg0[%arg6, 0, 0, 0] [1, %c4, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg4[0, 0] [%c4, %c2] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg3[%arg6, 0] [1, %c4] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg1[%arg6, 0, 0, 0] [1, %c4, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %subview_5 = memref.subview %arg2[%arg6, 0] [1, %c4] [1, 1] : memref to memref> + %subview_6 = memref.subview %arg5[%arg6, 0, 0, 0] [1, %c4, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %0 = polygeist.submap(%alloca, %c4) {map = #map} : (memref, index) -> memref + %subview_7 = memref.subview %0[0] [%c4] [1] : memref to memref> + %1 = polygeist.submap(%alloca_1, %c4) {map = #map} : (memref, index) -> memref + %subview_8 = memref.subview %1[0] [%c4] [1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map3, #map4, #map2, #map3, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview_7, %subview_8, %subview, %subview_2, %subview_3, %subview_4, %subview_5 : memref>, memref>, memref>, memref>, memref>, memref>, memref>) outs(%subview_6 : memref>) { + ^bb0(%in: f32, %in_9: f32, %in_10: f32, %in_11: f32, %in_12: f32, %in_13: f32, %in_14: f32, %out: f32): + %2 = arith.mulf %in_10, %in_11 : f32 + %3 = arith.divf %in_12, %cst : f32 + %4 = arith.mulf %2, %cst : f32 + %5 = arith.subf %4, %in_9 : f32 + %6 = arith.subf %in_13, %in_14 : f32 + %7 = arith.mulf %6, %in_12 : f32 + %8 = arith.mulf %7, %in_12 : f32 + %9 = arith.mulf %8, %in : f32 + %10 = arith.subf %5, %9 : f32 + %11 = arith.mulf %3, %10 : f32 + linalg.yield %11 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_group_norm_cpu.mlir b/issues/aten_c_kernels/results/aten_group_norm_cpu.mlir new file mode 100644 index 000000000000..f4134fe866af --- /dev/null +++ b/issues/aten_c_kernels/results/aten_group_norm_cpu.mlir @@ -0,0 +1,51 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_group_norm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.200000e+01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 2 iter_args(%arg10 = %cst_1) -> (f32) { + %7 = affine.for %arg11 = 0 to 16 iter_args(%arg12 = %arg10) -> (f32) { + %8 = affine.load %arg0[%arg7, %arg8, %arg9, %arg11] : memref + %9 = arith.addf %arg12, %8 : f32 + affine.yield %9 : f32 + } + affine.yield %7 : f32 + } + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg5[%arg7, %arg8] : memref + %2 = affine.for %arg9 = 0 to 2 iter_args(%arg10 = %cst_1) -> (f32) { + %7 = affine.for %arg11 = 0 to 16 iter_args(%arg12 = %arg10) -> (f32) { + %8 = affine.load %arg0[%arg7, %arg8, %arg9, %arg11] : memref + %9 = arith.subf %8, %1 : f32 + %10 = arith.mulf %9, %9 : f32 + %11 = arith.addf %arg12, %10 : f32 + affine.yield %11 : f32 + } + affine.yield %7 : f32 + } + %3 = arith.divf %2, %cst : f32 + %4 = arith.addf %3, %arg3 : f32 + %5 = math.sqrt %4 : f32 + %6 = arith.divf %cst_0, %5 : f32 + affine.store %6, %arg6[%arg7, %arg8] : memref + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 16 { + %7 = affine.load %arg0[%arg7, %arg8, %arg9, %arg10] : memref + %8 = affine.load %arg5[%arg7, %arg8] : memref + %9 = arith.subf %7, %8 : f32 + %10 = affine.load %arg6[%arg7, %arg8] : memref + %11 = arith.mulf %9, %10 : f32 + %12 = affine.load %arg1[%arg8, %arg9] : memref + %13 = arith.mulf %11, %12 : f32 + %14 = affine.load %arg2[%arg8, %arg9] : memref + %15 = arith.addf %13, %14 : f32 + affine.store %15, %arg4[%arg7, %arg8, %arg9, %arg10] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_group_norm_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_group_norm_cpu/debuf.mlir new file mode 100644 index 000000000000..74271a16aee8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_group_norm_cpu/debuf.mlir @@ -0,0 +1,77 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_group_norm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 3.200000e+01 : f32 + %c16 = arith.constant 16 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = bufferization.to_tensor %arg6 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7:3 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %5, %arg9 = %4, %arg10 = %3) -> (tensor, tensor, tensor) { + %11:3 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %arg8, %arg13 = %arg9, %arg14 = %arg10) -> (tensor, tensor, tensor) { + %alloca = memref.alloca() : memref + %12 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %12[] : tensor + %extracted_slice = tensor.extract_slice %6[%arg7, %arg11, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : tensor to tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %22 = arith.addf %out, %in : f32 + linalg.yield %22 : f32 + } -> tensor + %extracted = tensor.extract %13[] : tensor + %14 = arith.divf %extracted, %cst_1 : f32 + %inserted_2 = tensor.insert %14 into %arg13[%arg7, %arg11] : tensor + %alloca_3 = memref.alloca() : memref + %15 = bufferization.to_tensor %alloca_3 : memref + %inserted_4 = tensor.insert %cst into %15[] : tensor + %extracted_slice_5 = tensor.extract_slice %6[%arg7, %arg11, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : tensor to tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%extracted_slice_5 : tensor) outs(%inserted_4 : tensor) { + ^bb0(%in: f32, %out: f32): + %22 = arith.subf %in, %14 : f32 + %23 = arith.mulf %22, %22 : f32 + %24 = arith.addf %out, %23 : f32 + linalg.yield %24 : f32 + } -> tensor + %extracted_6 = tensor.extract %16[] : tensor + %17 = arith.divf %extracted_6, %cst_1 : f32 + %18 = arith.addf %17, %arg3 : f32 + %19 = math.sqrt %18 : f32 + %20 = arith.divf %cst_0, %19 : f32 + %inserted_7 = tensor.insert %20 into %arg14[%arg7, %arg11] : tensor + %extracted_slice_8 = tensor.extract_slice %arg12[%arg7, %arg11, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_9 = tensor.extract_slice %inserted_2[%arg7, %arg11] [1, 1] [1, 1] : tensor to tensor + %extracted_slice_10 = tensor.extract_slice %inserted_7[%arg7, %arg11] [1, 1] [1, 1] : tensor to tensor + %extracted_slice_11 = tensor.extract_slice %2[%arg7, %arg11, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_12 = tensor.extract_slice %1[%arg11, 0] [1, %c2] [1, 1] : tensor to tensor + %extracted_slice_13 = tensor.extract_slice %0[%arg11, 0] [1, %c2] [1, 1] : tensor to tensor + %21 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1, #map2, #map2, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_11, %extracted_slice_9, %extracted_slice_10, %extracted_slice_12, %extracted_slice_13 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_8 : tensor) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %in_17: f32, %out: f32): + %22 = arith.subf %in, %in_14 : f32 + %23 = arith.mulf %22, %in_15 : f32 + %24 = arith.mulf %23, %in_16 : f32 + %25 = arith.addf %24, %in_17 : f32 + linalg.yield %25 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %21 into %arg12[%arg7, %arg11, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_2, %inserted_7 : tensor, tensor, tensor + } + affine.yield %11#0, %11#1, %11#2 : tensor, tensor, tensor + } + %8 = bufferization.to_memref %7#2 : memref + memref.copy %8, %arg6 : memref to memref + %9 = bufferization.to_memref %7#1 : memref + memref.copy %9, %arg5 : memref to memref + %10 = bufferization.to_memref %7#0 : memref + memref.copy %10, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_group_norm_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_group_norm_cpu/matched.mlir new file mode 100644 index 000000000000..74271a16aee8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_group_norm_cpu/matched.mlir @@ -0,0 +1,77 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_group_norm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 3.200000e+01 : f32 + %c16 = arith.constant 16 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = bufferization.to_tensor %arg6 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7:3 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %5, %arg9 = %4, %arg10 = %3) -> (tensor, tensor, tensor) { + %11:3 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %arg8, %arg13 = %arg9, %arg14 = %arg10) -> (tensor, tensor, tensor) { + %alloca = memref.alloca() : memref + %12 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %12[] : tensor + %extracted_slice = tensor.extract_slice %6[%arg7, %arg11, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : tensor to tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %22 = arith.addf %out, %in : f32 + linalg.yield %22 : f32 + } -> tensor + %extracted = tensor.extract %13[] : tensor + %14 = arith.divf %extracted, %cst_1 : f32 + %inserted_2 = tensor.insert %14 into %arg13[%arg7, %arg11] : tensor + %alloca_3 = memref.alloca() : memref + %15 = bufferization.to_tensor %alloca_3 : memref + %inserted_4 = tensor.insert %cst into %15[] : tensor + %extracted_slice_5 = tensor.extract_slice %6[%arg7, %arg11, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : tensor to tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%extracted_slice_5 : tensor) outs(%inserted_4 : tensor) { + ^bb0(%in: f32, %out: f32): + %22 = arith.subf %in, %14 : f32 + %23 = arith.mulf %22, %22 : f32 + %24 = arith.addf %out, %23 : f32 + linalg.yield %24 : f32 + } -> tensor + %extracted_6 = tensor.extract %16[] : tensor + %17 = arith.divf %extracted_6, %cst_1 : f32 + %18 = arith.addf %17, %arg3 : f32 + %19 = math.sqrt %18 : f32 + %20 = arith.divf %cst_0, %19 : f32 + %inserted_7 = tensor.insert %20 into %arg14[%arg7, %arg11] : tensor + %extracted_slice_8 = tensor.extract_slice %arg12[%arg7, %arg11, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_9 = tensor.extract_slice %inserted_2[%arg7, %arg11] [1, 1] [1, 1] : tensor to tensor + %extracted_slice_10 = tensor.extract_slice %inserted_7[%arg7, %arg11] [1, 1] [1, 1] : tensor to tensor + %extracted_slice_11 = tensor.extract_slice %2[%arg7, %arg11, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_12 = tensor.extract_slice %1[%arg11, 0] [1, %c2] [1, 1] : tensor to tensor + %extracted_slice_13 = tensor.extract_slice %0[%arg11, 0] [1, %c2] [1, 1] : tensor to tensor + %21 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1, #map2, #map2, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_11, %extracted_slice_9, %extracted_slice_10, %extracted_slice_12, %extracted_slice_13 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_8 : tensor) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %in_17: f32, %out: f32): + %22 = arith.subf %in, %in_14 : f32 + %23 = arith.mulf %22, %in_15 : f32 + %24 = arith.mulf %23, %in_16 : f32 + %25 = arith.addf %24, %in_17 : f32 + linalg.yield %25 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %21 into %arg12[%arg7, %arg11, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_2, %inserted_7 : tensor, tensor, tensor + } + affine.yield %11#0, %11#1, %11#2 : tensor, tensor, tensor + } + %8 = bufferization.to_memref %7#2 : memref + memref.copy %8, %arg6 : memref to memref + %9 = bufferization.to_memref %7#1 : memref + memref.copy %9, %arg5 : memref to memref + %10 = bufferization.to_memref %7#0 : memref + memref.copy %10, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_group_norm_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_group_norm_cpu/orig.mlir new file mode 100644 index 000000000000..f4134fe866af --- /dev/null +++ b/issues/aten_c_kernels/results/aten_group_norm_cpu/orig.mlir @@ -0,0 +1,51 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_group_norm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.200000e+01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 2 iter_args(%arg10 = %cst_1) -> (f32) { + %7 = affine.for %arg11 = 0 to 16 iter_args(%arg12 = %arg10) -> (f32) { + %8 = affine.load %arg0[%arg7, %arg8, %arg9, %arg11] : memref + %9 = arith.addf %arg12, %8 : f32 + affine.yield %9 : f32 + } + affine.yield %7 : f32 + } + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg5[%arg7, %arg8] : memref + %2 = affine.for %arg9 = 0 to 2 iter_args(%arg10 = %cst_1) -> (f32) { + %7 = affine.for %arg11 = 0 to 16 iter_args(%arg12 = %arg10) -> (f32) { + %8 = affine.load %arg0[%arg7, %arg8, %arg9, %arg11] : memref + %9 = arith.subf %8, %1 : f32 + %10 = arith.mulf %9, %9 : f32 + %11 = arith.addf %arg12, %10 : f32 + affine.yield %11 : f32 + } + affine.yield %7 : f32 + } + %3 = arith.divf %2, %cst : f32 + %4 = arith.addf %3, %arg3 : f32 + %5 = math.sqrt %4 : f32 + %6 = arith.divf %cst_0, %5 : f32 + affine.store %6, %arg6[%arg7, %arg8] : memref + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 16 { + %7 = affine.load %arg0[%arg7, %arg8, %arg9, %arg10] : memref + %8 = affine.load %arg5[%arg7, %arg8] : memref + %9 = arith.subf %7, %8 : f32 + %10 = affine.load %arg6[%arg7, %arg8] : memref + %11 = arith.mulf %9, %10 : f32 + %12 = affine.load %arg1[%arg8, %arg9] : memref + %13 = arith.mulf %11, %12 : f32 + %14 = affine.load %arg2[%arg8, %arg9] : memref + %15 = arith.addf %13, %14 : f32 + affine.store %15, %arg4[%arg7, %arg8, %arg9, %arg10] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_group_norm_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_group_norm_cpu/raised.mlir new file mode 100644 index 000000000000..7cffeb9e3ee0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_group_norm_cpu/raised.mlir @@ -0,0 +1,59 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_group_norm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 3.200000e+01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %alloca = memref.alloca() : memref + affine.store %cst_1, %alloca[] : memref + %subview = memref.subview %arg0[%arg7, %arg8, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %7 = arith.addf %out, %in : f32 + linalg.yield %7 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg5[%arg7, %arg8] : memref + %alloca_2 = memref.alloca() : memref + affine.store %cst_1, %alloca_2[] : memref + %subview_3 = memref.subview %arg0[%arg7, %arg8, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"]} ins(%subview_3 : memref>) outs(%alloca_2 : memref) { + ^bb0(%in: f32, %out: f32): + %7 = arith.subf %in, %1 : f32 + %8 = arith.mulf %7, %7 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } + %2 = affine.load %alloca_2[] : memref + %3 = arith.divf %2, %cst : f32 + %4 = arith.addf %3, %arg3 : f32 + %5 = math.sqrt %4 : f32 + %6 = arith.divf %cst_0, %5 : f32 + affine.store %6, %arg6[%arg7, %arg8] : memref + %subview_4 = memref.subview %arg0[%arg7, %arg8, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %subview_5 = memref.subview %arg5[%arg7, %arg8] [1, 1] [1, 1] : memref to memref> + %subview_6 = memref.subview %arg6[%arg7, %arg8] [1, 1] [1, 1] : memref to memref> + %subview_7 = memref.subview %arg1[%arg8, 0] [1, %c2] [1, 1] : memref to memref> + %subview_8 = memref.subview %arg2[%arg8, 0] [1, %c2] [1, 1] : memref to memref> + %subview_9 = memref.subview %arg4[%arg7, %arg8, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map1, #map2, #map2, #map], iterator_types = ["parallel", "parallel"]} ins(%subview_4, %subview_5, %subview_6, %subview_7, %subview_8 : memref>, memref>, memref>, memref>, memref>) outs(%subview_9 : memref>) { + ^bb0(%in: f32, %in_10: f32, %in_11: f32, %in_12: f32, %in_13: f32, %out: f32): + %7 = arith.subf %in, %in_10 : f32 + %8 = arith.mulf %7, %in_11 : f32 + %9 = arith.mulf %8, %in_12 : f32 + %10 = arith.addf %9, %in_13 : f32 + linalg.yield %10 : f32 + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_group_norm_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_group_norm_cpu_debuf.mlir new file mode 100644 index 000000000000..74271a16aee8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_group_norm_cpu_debuf.mlir @@ -0,0 +1,77 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_group_norm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 3.200000e+01 : f32 + %c16 = arith.constant 16 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = bufferization.to_tensor %arg6 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7:3 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %5, %arg9 = %4, %arg10 = %3) -> (tensor, tensor, tensor) { + %11:3 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %arg8, %arg13 = %arg9, %arg14 = %arg10) -> (tensor, tensor, tensor) { + %alloca = memref.alloca() : memref + %12 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %12[] : tensor + %extracted_slice = tensor.extract_slice %6[%arg7, %arg11, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : tensor to tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %22 = arith.addf %out, %in : f32 + linalg.yield %22 : f32 + } -> tensor + %extracted = tensor.extract %13[] : tensor + %14 = arith.divf %extracted, %cst_1 : f32 + %inserted_2 = tensor.insert %14 into %arg13[%arg7, %arg11] : tensor + %alloca_3 = memref.alloca() : memref + %15 = bufferization.to_tensor %alloca_3 : memref + %inserted_4 = tensor.insert %cst into %15[] : tensor + %extracted_slice_5 = tensor.extract_slice %6[%arg7, %arg11, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : tensor to tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%extracted_slice_5 : tensor) outs(%inserted_4 : tensor) { + ^bb0(%in: f32, %out: f32): + %22 = arith.subf %in, %14 : f32 + %23 = arith.mulf %22, %22 : f32 + %24 = arith.addf %out, %23 : f32 + linalg.yield %24 : f32 + } -> tensor + %extracted_6 = tensor.extract %16[] : tensor + %17 = arith.divf %extracted_6, %cst_1 : f32 + %18 = arith.addf %17, %arg3 : f32 + %19 = math.sqrt %18 : f32 + %20 = arith.divf %cst_0, %19 : f32 + %inserted_7 = tensor.insert %20 into %arg14[%arg7, %arg11] : tensor + %extracted_slice_8 = tensor.extract_slice %arg12[%arg7, %arg11, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_9 = tensor.extract_slice %inserted_2[%arg7, %arg11] [1, 1] [1, 1] : tensor to tensor + %extracted_slice_10 = tensor.extract_slice %inserted_7[%arg7, %arg11] [1, 1] [1, 1] : tensor to tensor + %extracted_slice_11 = tensor.extract_slice %2[%arg7, %arg11, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : tensor to tensor + %extracted_slice_12 = tensor.extract_slice %1[%arg11, 0] [1, %c2] [1, 1] : tensor to tensor + %extracted_slice_13 = tensor.extract_slice %0[%arg11, 0] [1, %c2] [1, 1] : tensor to tensor + %21 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1, #map2, #map2, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_11, %extracted_slice_9, %extracted_slice_10, %extracted_slice_12, %extracted_slice_13 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_8 : tensor) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %in_17: f32, %out: f32): + %22 = arith.subf %in, %in_14 : f32 + %23 = arith.mulf %22, %in_15 : f32 + %24 = arith.mulf %23, %in_16 : f32 + %25 = arith.addf %24, %in_17 : f32 + linalg.yield %25 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %21 into %arg12[%arg7, %arg11, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_2, %inserted_7 : tensor, tensor, tensor + } + affine.yield %11#0, %11#1, %11#2 : tensor, tensor, tensor + } + %8 = bufferization.to_memref %7#2 : memref + memref.copy %8, %arg6 : memref to memref + %9 = bufferization.to_memref %7#1 : memref + memref.copy %9, %arg5 : memref to memref + %10 = bufferization.to_memref %7#0 : memref + memref.copy %10, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_group_norm_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_group_norm_cpu_linalg.mlir new file mode 100644 index 000000000000..7cffeb9e3ee0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_group_norm_cpu_linalg.mlir @@ -0,0 +1,59 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_group_norm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 3.200000e+01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %alloca = memref.alloca() : memref + affine.store %cst_1, %alloca[] : memref + %subview = memref.subview %arg0[%arg7, %arg8, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %7 = arith.addf %out, %in : f32 + linalg.yield %7 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg5[%arg7, %arg8] : memref + %alloca_2 = memref.alloca() : memref + affine.store %cst_1, %alloca_2[] : memref + %subview_3 = memref.subview %arg0[%arg7, %arg8, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction", "reduction"]} ins(%subview_3 : memref>) outs(%alloca_2 : memref) { + ^bb0(%in: f32, %out: f32): + %7 = arith.subf %in, %1 : f32 + %8 = arith.mulf %7, %7 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } + %2 = affine.load %alloca_2[] : memref + %3 = arith.divf %2, %cst : f32 + %4 = arith.addf %3, %arg3 : f32 + %5 = math.sqrt %4 : f32 + %6 = arith.divf %cst_0, %5 : f32 + affine.store %6, %arg6[%arg7, %arg8] : memref + %subview_4 = memref.subview %arg0[%arg7, %arg8, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : memref to memref> + %subview_5 = memref.subview %arg5[%arg7, %arg8] [1, 1] [1, 1] : memref to memref> + %subview_6 = memref.subview %arg6[%arg7, %arg8] [1, 1] [1, 1] : memref to memref> + %subview_7 = memref.subview %arg1[%arg8, 0] [1, %c2] [1, 1] : memref to memref> + %subview_8 = memref.subview %arg2[%arg8, 0] [1, %c2] [1, 1] : memref to memref> + %subview_9 = memref.subview %arg4[%arg7, %arg8, 0, 0] [1, 1, %c2, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map1, #map2, #map2, #map], iterator_types = ["parallel", "parallel"]} ins(%subview_4, %subview_5, %subview_6, %subview_7, %subview_8 : memref>, memref>, memref>, memref>, memref>) outs(%subview_9 : memref>) { + ^bb0(%in: f32, %in_10: f32, %in_11: f32, %in_12: f32, %in_13: f32, %out: f32): + %7 = arith.subf %in, %in_10 : f32 + %8 = arith.mulf %7, %in_11 : f32 + %9 = arith.mulf %8, %in_12 : f32 + %10 = arith.addf %9, %in_13 : f32 + linalg.yield %10 : f32 + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gt.mlir b/issues/aten_c_kernels/results/aten_gt.mlir new file mode 100644 index 000000000000..e597460959f6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gt.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gt(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf ogt, %0, %1 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gt/debuf.mlir b/issues/aten_c_kernels/results/aten_gt/debuf.mlir new file mode 100644 index 000000000000..efc2968a772d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gt/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gt(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gt/matched.mlir b/issues/aten_c_kernels/results/aten_gt/matched.mlir new file mode 100644 index 000000000000..efc2968a772d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gt/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gt(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gt/orig.mlir b/issues/aten_c_kernels/results/aten_gt/orig.mlir new file mode 100644 index 000000000000..e597460959f6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gt/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gt(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf ogt, %0, %1 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_gt/raised.mlir b/issues/aten_c_kernels/results/aten_gt/raised.mlir new file mode 100644 index 000000000000..7f97a45b9a34 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gt/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gt(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %in_0 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gt_debuf.mlir b/issues/aten_c_kernels/results/aten_gt_debuf.mlir new file mode 100644 index 000000000000..efc2968a772d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gt_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gt(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_gt_linalg.mlir b/issues/aten_c_kernels/results/aten_gt_linalg.mlir new file mode 100644 index 000000000000..7f97a45b9a34 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_gt_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_gt(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %in_0 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardshrink.mlir b/issues/aten_c_kernels/results/aten_hardshrink.mlir new file mode 100644 index 000000000000..1da3aedeabf5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardshrink.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardshrink(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = arith.negf %arg1 : f32 + affine.for %arg3 = 0 to 4096 { + %1 = affine.load %arg0[%arg3] : memref + %2 = arith.cmpf oge, %1, %0 : f32 + %3 = arith.cmpf ole, %1, %arg1 : f32 + %4 = arith.andi %2, %3 : i1 + %5 = arith.select %4, %cst, %1 : f32 + affine.store %5, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_hardshrink/debuf.mlir b/issues/aten_c_kernels/results/aten_hardshrink/debuf.mlir new file mode 100644 index 000000000000..3141c3d2f74e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardshrink/debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardshrink(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.negf %arg1 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf oge, %in, %2 : f32 + %6 = arith.cmpf ole, %in, %arg1 : f32 + %7 = arith.andi %5, %6 : i1 + %8 = arith.select %7, %cst, %in : f32 + linalg.yield %8 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardshrink/matched.mlir b/issues/aten_c_kernels/results/aten_hardshrink/matched.mlir new file mode 100644 index 000000000000..3141c3d2f74e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardshrink/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardshrink(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.negf %arg1 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf oge, %in, %2 : f32 + %6 = arith.cmpf ole, %in, %arg1 : f32 + %7 = arith.andi %5, %6 : i1 + %8 = arith.select %7, %cst, %in : f32 + linalg.yield %8 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardshrink/orig.mlir b/issues/aten_c_kernels/results/aten_hardshrink/orig.mlir new file mode 100644 index 000000000000..1da3aedeabf5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardshrink/orig.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardshrink(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = arith.negf %arg1 : f32 + affine.for %arg3 = 0 to 4096 { + %1 = affine.load %arg0[%arg3] : memref + %2 = arith.cmpf oge, %1, %0 : f32 + %3 = arith.cmpf ole, %1, %arg1 : f32 + %4 = arith.andi %2, %3 : i1 + %5 = arith.select %4, %cst, %1 : f32 + affine.store %5, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_hardshrink/raised.mlir b/issues/aten_c_kernels/results/aten_hardshrink/raised.mlir new file mode 100644 index 000000000000..9df08288890d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardshrink/raised.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardshrink(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = arith.negf %arg1 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.cmpf oge, %in, %0 : f32 + %2 = arith.cmpf ole, %in, %arg1 : f32 + %3 = arith.andi %1, %2 : i1 + %4 = arith.select %3, %cst, %in : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardshrink_debuf.mlir b/issues/aten_c_kernels/results/aten_hardshrink_debuf.mlir new file mode 100644 index 000000000000..3141c3d2f74e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardshrink_debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardshrink(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.negf %arg1 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf oge, %in, %2 : f32 + %6 = arith.cmpf ole, %in, %arg1 : f32 + %7 = arith.andi %5, %6 : i1 + %8 = arith.select %7, %cst, %in : f32 + linalg.yield %8 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardshrink_linalg.mlir b/issues/aten_c_kernels/results/aten_hardshrink_linalg.mlir new file mode 100644 index 000000000000..9df08288890d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardshrink_linalg.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardshrink(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = arith.negf %arg1 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.cmpf oge, %in, %0 : f32 + %2 = arith.cmpf ole, %in, %arg1 : f32 + %3 = arith.andi %1, %2 : i1 + %4 = arith.select %3, %cst, %in : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardsigmoid.mlir b/issues/aten_c_kernels/results/aten_hardsigmoid.mlir new file mode 100644 index 000000000000..5c1600931305 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardsigmoid.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardsigmoid(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 6.000000e+00 : f32 + %cst_2 = arith.constant 3.000000e+00 : f32 + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.addf %0, %cst_2 : f32 + %2 = arith.divf %1, %cst_1 : f32 + %3 = arith.cmpf olt, %2, %cst_0 : f32 + %4 = scf.if %3 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %5 = arith.cmpf ogt, %2, %cst : f32 + %6 = arith.select %5, %cst, %2 : f32 + scf.yield %6 : f32 + } + affine.store %4, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_hardsigmoid/debuf.mlir b/issues/aten_c_kernels/results/aten_hardsigmoid/debuf.mlir new file mode 100644 index 000000000000..53649facfdfa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardsigmoid/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardsigmoid(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %in, %cst : f32 + %5 = arith.divf %4, %cst_0 : f32 + %6 = arith.cmpf olt, %5, %cst_1 : f32 + %7 = arith.cmpf ogt, %5, %cst_2 : f32 + %8 = arith.select %7, %cst_2, %5 : f32 + %9 = arith.select %6, %cst_1, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardsigmoid/matched.mlir b/issues/aten_c_kernels/results/aten_hardsigmoid/matched.mlir new file mode 100644 index 000000000000..53649facfdfa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardsigmoid/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardsigmoid(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %in, %cst : f32 + %5 = arith.divf %4, %cst_0 : f32 + %6 = arith.cmpf olt, %5, %cst_1 : f32 + %7 = arith.cmpf ogt, %5, %cst_2 : f32 + %8 = arith.select %7, %cst_2, %5 : f32 + %9 = arith.select %6, %cst_1, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardsigmoid/orig.mlir b/issues/aten_c_kernels/results/aten_hardsigmoid/orig.mlir new file mode 100644 index 000000000000..5c1600931305 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardsigmoid/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardsigmoid(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 6.000000e+00 : f32 + %cst_2 = arith.constant 3.000000e+00 : f32 + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.addf %0, %cst_2 : f32 + %2 = arith.divf %1, %cst_1 : f32 + %3 = arith.cmpf olt, %2, %cst_0 : f32 + %4 = scf.if %3 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %5 = arith.cmpf ogt, %2, %cst : f32 + %6 = arith.select %5, %cst, %2 : f32 + scf.yield %6 : f32 + } + affine.store %4, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_hardsigmoid/raised.mlir b/issues/aten_c_kernels/results/aten_hardsigmoid/raised.mlir new file mode 100644 index 000000000000..d66a29c932fa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardsigmoid/raised.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardsigmoid(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 6.000000e+00 : f32 + %cst_2 = arith.constant 3.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.addf %in, %cst_2 : f32 + %1 = arith.divf %0, %cst_1 : f32 + %2 = arith.cmpf olt, %1, %cst_0 : f32 + %3 = arith.cmpf ogt, %1, %cst : f32 + %4 = arith.select %3, %cst, %1 : f32 + %5 = arith.select %2, %cst_0, %4 : f32 + linalg.yield %5 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardsigmoid_backward.mlir b/issues/aten_c_kernels/results/aten_hardsigmoid_backward.mlir new file mode 100644 index 000000000000..3911714d9bc7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardsigmoid_backward.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardsigmoid_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 0.166666672 : f32 + %cst_1 = arith.constant 3.000000e+00 : f32 + %cst_2 = arith.constant -3.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.cmpf ogt, %0, %cst_2 : f32 + %2 = arith.cmpf olt, %0, %cst_1 : f32 + %3 = arith.andi %1, %2 : i1 + %4 = scf.if %3 -> (f32) { + %5 = affine.load %arg0[%arg3] : memref + %6 = arith.mulf %5, %cst_0 : f32 + scf.yield %6 : f32 + } else { + scf.yield %cst : f32 + } + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_hardsigmoid_backward/debuf.mlir b/issues/aten_c_kernels/results/aten_hardsigmoid_backward/debuf.mlir new file mode 100644 index 000000000000..f4eeaa10f47f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardsigmoid_backward/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardsigmoid_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.000000e+00 : f32 + %cst_0 = arith.constant 3.000000e+00 : f32 + %cst_1 = arith.constant 0.166666672 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %cst : f32 + %6 = arith.cmpf olt, %in, %cst_0 : f32 + %7 = arith.andi %5, %6 : i1 + %8 = arith.mulf %in_3, %cst_1 : f32 + %9 = arith.select %7, %8, %cst_2 : f32 + linalg.yield %9 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardsigmoid_backward/matched.mlir b/issues/aten_c_kernels/results/aten_hardsigmoid_backward/matched.mlir new file mode 100644 index 000000000000..f4eeaa10f47f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardsigmoid_backward/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardsigmoid_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.000000e+00 : f32 + %cst_0 = arith.constant 3.000000e+00 : f32 + %cst_1 = arith.constant 0.166666672 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %cst : f32 + %6 = arith.cmpf olt, %in, %cst_0 : f32 + %7 = arith.andi %5, %6 : i1 + %8 = arith.mulf %in_3, %cst_1 : f32 + %9 = arith.select %7, %8, %cst_2 : f32 + linalg.yield %9 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardsigmoid_backward/orig.mlir b/issues/aten_c_kernels/results/aten_hardsigmoid_backward/orig.mlir new file mode 100644 index 000000000000..3911714d9bc7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardsigmoid_backward/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardsigmoid_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 0.166666672 : f32 + %cst_1 = arith.constant 3.000000e+00 : f32 + %cst_2 = arith.constant -3.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.cmpf ogt, %0, %cst_2 : f32 + %2 = arith.cmpf olt, %0, %cst_1 : f32 + %3 = arith.andi %1, %2 : i1 + %4 = scf.if %3 -> (f32) { + %5 = affine.load %arg0[%arg3] : memref + %6 = arith.mulf %5, %cst_0 : f32 + scf.yield %6 : f32 + } else { + scf.yield %cst : f32 + } + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_hardsigmoid_backward/raised.mlir b/issues/aten_c_kernels/results/aten_hardsigmoid_backward/raised.mlir new file mode 100644 index 000000000000..61d89b1ed0d6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardsigmoid_backward/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardsigmoid_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 0.166666672 : f32 + %cst_1 = arith.constant 3.000000e+00 : f32 + %cst_2 = arith.constant -3.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %cst_2 : f32 + %1 = arith.cmpf olt, %in, %cst_1 : f32 + %2 = arith.andi %0, %1 : i1 + %3 = arith.mulf %in_3, %cst_0 : f32 + %4 = arith.select %2, %3, %cst : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardsigmoid_backward_debuf.mlir b/issues/aten_c_kernels/results/aten_hardsigmoid_backward_debuf.mlir new file mode 100644 index 000000000000..f4eeaa10f47f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardsigmoid_backward_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardsigmoid_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.000000e+00 : f32 + %cst_0 = arith.constant 3.000000e+00 : f32 + %cst_1 = arith.constant 0.166666672 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %cst : f32 + %6 = arith.cmpf olt, %in, %cst_0 : f32 + %7 = arith.andi %5, %6 : i1 + %8 = arith.mulf %in_3, %cst_1 : f32 + %9 = arith.select %7, %8, %cst_2 : f32 + linalg.yield %9 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardsigmoid_backward_linalg.mlir b/issues/aten_c_kernels/results/aten_hardsigmoid_backward_linalg.mlir new file mode 100644 index 000000000000..61d89b1ed0d6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardsigmoid_backward_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardsigmoid_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 0.166666672 : f32 + %cst_1 = arith.constant 3.000000e+00 : f32 + %cst_2 = arith.constant -3.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %cst_2 : f32 + %1 = arith.cmpf olt, %in, %cst_1 : f32 + %2 = arith.andi %0, %1 : i1 + %3 = arith.mulf %in_3, %cst_0 : f32 + %4 = arith.select %2, %3, %cst : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardsigmoid_debuf.mlir b/issues/aten_c_kernels/results/aten_hardsigmoid_debuf.mlir new file mode 100644 index 000000000000..53649facfdfa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardsigmoid_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardsigmoid(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %in, %cst : f32 + %5 = arith.divf %4, %cst_0 : f32 + %6 = arith.cmpf olt, %5, %cst_1 : f32 + %7 = arith.cmpf ogt, %5, %cst_2 : f32 + %8 = arith.select %7, %cst_2, %5 : f32 + %9 = arith.select %6, %cst_1, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardsigmoid_linalg.mlir b/issues/aten_c_kernels/results/aten_hardsigmoid_linalg.mlir new file mode 100644 index 000000000000..d66a29c932fa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardsigmoid_linalg.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardsigmoid(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 6.000000e+00 : f32 + %cst_2 = arith.constant 3.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.addf %in, %cst_2 : f32 + %1 = arith.divf %0, %cst_1 : f32 + %2 = arith.cmpf olt, %1, %cst_0 : f32 + %3 = arith.cmpf ogt, %1, %cst : f32 + %4 = arith.select %3, %cst, %1 : f32 + %5 = arith.select %2, %cst_0, %4 : f32 + linalg.yield %5 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardswish.mlir b/issues/aten_c_kernels/results/aten_hardswish.mlir new file mode 100644 index 000000000000..74f4306d7051 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardswish.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardswish(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 6.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 3.000000e+00 : f32 + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.addf %0, %cst_1 : f32 + %2 = arith.cmpf olt, %1, %cst_0 : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %6 = arith.cmpf ogt, %1, %cst : f32 + %7 = arith.select %6, %cst, %1 : f32 + scf.yield %7 : f32 + } + %4 = arith.mulf %0, %3 : f32 + %5 = arith.divf %4, %cst : f32 + affine.store %5, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_hardswish/debuf.mlir b/issues/aten_c_kernels/results/aten_hardswish/debuf.mlir new file mode 100644 index 000000000000..6ebadd470d6b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardswish/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardswish(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 6.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %in, %cst : f32 + %5 = arith.cmpf olt, %4, %cst_0 : f32 + %6 = arith.cmpf ogt, %4, %cst_1 : f32 + %7 = arith.select %6, %cst_1, %4 : f32 + %8 = arith.select %5, %cst_0, %7 : f32 + %9 = arith.mulf %in, %8 : f32 + %10 = arith.divf %9, %cst_1 : f32 + linalg.yield %10 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardswish/matched.mlir b/issues/aten_c_kernels/results/aten_hardswish/matched.mlir new file mode 100644 index 000000000000..6ebadd470d6b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardswish/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardswish(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 6.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %in, %cst : f32 + %5 = arith.cmpf olt, %4, %cst_0 : f32 + %6 = arith.cmpf ogt, %4, %cst_1 : f32 + %7 = arith.select %6, %cst_1, %4 : f32 + %8 = arith.select %5, %cst_0, %7 : f32 + %9 = arith.mulf %in, %8 : f32 + %10 = arith.divf %9, %cst_1 : f32 + linalg.yield %10 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardswish/orig.mlir b/issues/aten_c_kernels/results/aten_hardswish/orig.mlir new file mode 100644 index 000000000000..74f4306d7051 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardswish/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardswish(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 6.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 3.000000e+00 : f32 + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.addf %0, %cst_1 : f32 + %2 = arith.cmpf olt, %1, %cst_0 : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %6 = arith.cmpf ogt, %1, %cst : f32 + %7 = arith.select %6, %cst, %1 : f32 + scf.yield %7 : f32 + } + %4 = arith.mulf %0, %3 : f32 + %5 = arith.divf %4, %cst : f32 + affine.store %5, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_hardswish/raised.mlir b/issues/aten_c_kernels/results/aten_hardswish/raised.mlir new file mode 100644 index 000000000000..92b683602071 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardswish/raised.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardswish(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 6.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 3.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.addf %in, %cst_1 : f32 + %1 = arith.cmpf olt, %0, %cst_0 : f32 + %2 = arith.cmpf ogt, %0, %cst : f32 + %3 = arith.select %2, %cst, %0 : f32 + %4 = arith.select %1, %cst_0, %3 : f32 + %5 = arith.mulf %in, %4 : f32 + %6 = arith.divf %5, %cst : f32 + linalg.yield %6 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardswish_backward.mlir b/issues/aten_c_kernels/results/aten_hardswish_backward.mlir new file mode 100644 index 000000000000..ebeb964c84cd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardswish_backward.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardswish_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 3.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant -3.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.cmpf ole, %0, %cst_2 : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %cst_1 : f32 + } else { + %3 = arith.cmpf olt, %0, %cst_0 : f32 + %4 = scf.if %3 -> (f32) { + %5 = affine.load %arg0[%arg3] : memref + %6 = arith.divf %0, %cst_0 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.mulf %5, %7 : f32 + scf.yield %8 : f32 + } else { + %5 = affine.load %arg0[%arg3] : memref + scf.yield %5 : f32 + } + scf.yield %4 : f32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_hardswish_backward/debuf.mlir b/issues/aten_c_kernels/results/aten_hardswish_backward/debuf.mlir new file mode 100644 index 000000000000..df68279242f0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardswish_backward/debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardswish_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 3.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0, %0 : tensor, tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_3: f32, %in_4: f32, %out: f32): + %5 = arith.cmpf ole, %in, %cst : f32 + %6 = arith.cmpf olt, %in, %cst_1 : f32 + %7 = arith.divf %in, %cst_1 : f32 + %8 = arith.addf %7, %cst_2 : f32 + %9 = arith.mulf %in_3, %8 : f32 + %10 = arith.select %6, %9, %in_4 : f32 + %11 = arith.select %5, %cst_0, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardswish_backward/matched.mlir b/issues/aten_c_kernels/results/aten_hardswish_backward/matched.mlir new file mode 100644 index 000000000000..df68279242f0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardswish_backward/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardswish_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 3.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0, %0 : tensor, tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_3: f32, %in_4: f32, %out: f32): + %5 = arith.cmpf ole, %in, %cst : f32 + %6 = arith.cmpf olt, %in, %cst_1 : f32 + %7 = arith.divf %in, %cst_1 : f32 + %8 = arith.addf %7, %cst_2 : f32 + %9 = arith.mulf %in_3, %8 : f32 + %10 = arith.select %6, %9, %in_4 : f32 + %11 = arith.select %5, %cst_0, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardswish_backward/orig.mlir b/issues/aten_c_kernels/results/aten_hardswish_backward/orig.mlir new file mode 100644 index 000000000000..ebeb964c84cd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardswish_backward/orig.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardswish_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 3.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant -3.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.cmpf ole, %0, %cst_2 : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %cst_1 : f32 + } else { + %3 = arith.cmpf olt, %0, %cst_0 : f32 + %4 = scf.if %3 -> (f32) { + %5 = affine.load %arg0[%arg3] : memref + %6 = arith.divf %0, %cst_0 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.mulf %5, %7 : f32 + scf.yield %8 : f32 + } else { + %5 = affine.load %arg0[%arg3] : memref + scf.yield %5 : f32 + } + scf.yield %4 : f32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_hardswish_backward/raised.mlir b/issues/aten_c_kernels/results/aten_hardswish_backward/raised.mlir new file mode 100644 index 000000000000..e9e585447c3a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardswish_backward/raised.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardswish_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 3.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant -3.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0, %arg0 : memref, memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_3: f32, %in_4: f32, %out: f32): + %0 = arith.cmpf ole, %in, %cst_2 : f32 + %1 = arith.cmpf olt, %in, %cst_0 : f32 + %2 = arith.divf %in, %cst_0 : f32 + %3 = arith.addf %2, %cst : f32 + %4 = arith.mulf %in_3, %3 : f32 + %5 = arith.select %1, %4, %in_4 : f32 + %6 = arith.select %0, %cst_1, %5 : f32 + linalg.yield %6 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardswish_backward_debuf.mlir b/issues/aten_c_kernels/results/aten_hardswish_backward_debuf.mlir new file mode 100644 index 000000000000..df68279242f0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardswish_backward_debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardswish_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 3.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0, %0 : tensor, tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_3: f32, %in_4: f32, %out: f32): + %5 = arith.cmpf ole, %in, %cst : f32 + %6 = arith.cmpf olt, %in, %cst_1 : f32 + %7 = arith.divf %in, %cst_1 : f32 + %8 = arith.addf %7, %cst_2 : f32 + %9 = arith.mulf %in_3, %8 : f32 + %10 = arith.select %6, %9, %in_4 : f32 + %11 = arith.select %5, %cst_0, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardswish_backward_linalg.mlir b/issues/aten_c_kernels/results/aten_hardswish_backward_linalg.mlir new file mode 100644 index 000000000000..e9e585447c3a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardswish_backward_linalg.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardswish_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 3.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant -3.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0, %arg0 : memref, memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_3: f32, %in_4: f32, %out: f32): + %0 = arith.cmpf ole, %in, %cst_2 : f32 + %1 = arith.cmpf olt, %in, %cst_0 : f32 + %2 = arith.divf %in, %cst_0 : f32 + %3 = arith.addf %2, %cst : f32 + %4 = arith.mulf %in_3, %3 : f32 + %5 = arith.select %1, %4, %in_4 : f32 + %6 = arith.select %0, %cst_1, %5 : f32 + linalg.yield %6 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardswish_debuf.mlir b/issues/aten_c_kernels/results/aten_hardswish_debuf.mlir new file mode 100644 index 000000000000..6ebadd470d6b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardswish_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardswish(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 6.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %in, %cst : f32 + %5 = arith.cmpf olt, %4, %cst_0 : f32 + %6 = arith.cmpf ogt, %4, %cst_1 : f32 + %7 = arith.select %6, %cst_1, %4 : f32 + %8 = arith.select %5, %cst_0, %7 : f32 + %9 = arith.mulf %in, %8 : f32 + %10 = arith.divf %9, %cst_1 : f32 + linalg.yield %10 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardswish_linalg.mlir b/issues/aten_c_kernels/results/aten_hardswish_linalg.mlir new file mode 100644 index 000000000000..92b683602071 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardswish_linalg.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardswish(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 6.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 3.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.addf %in, %cst_1 : f32 + %1 = arith.cmpf olt, %0, %cst_0 : f32 + %2 = arith.cmpf ogt, %0, %cst : f32 + %3 = arith.select %2, %cst, %0 : f32 + %4 = arith.select %1, %cst_0, %3 : f32 + %5 = arith.mulf %in, %4 : f32 + %6 = arith.divf %5, %cst : f32 + linalg.yield %6 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardtanh.mlir b/issues/aten_c_kernels/results/aten_hardtanh.mlir new file mode 100644 index 000000000000..aaa56f9e30c4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardtanh.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardtanh(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 256 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.cmpf olt, %0, %arg2 : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %arg2 : f32 + } else { + %3 = arith.cmpf ogt, %0, %arg3 : f32 + %4 = arith.select %3, %arg3, %0 : f32 + scf.yield %4 : f32 + } + affine.store %2, %arg1[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_hardtanh/debuf.mlir b/issues/aten_c_kernels/results/aten_hardtanh/debuf.mlir new file mode 100644 index 000000000000..f93a7a6f3b36 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardtanh/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardtanh(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %arg2 : f32 + %5 = arith.cmpf ogt, %in, %arg3 : f32 + %6 = arith.select %5, %arg3, %in : f32 + %7 = arith.select %4, %arg2, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardtanh/matched.mlir b/issues/aten_c_kernels/results/aten_hardtanh/matched.mlir new file mode 100644 index 000000000000..f93a7a6f3b36 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardtanh/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardtanh(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %arg2 : f32 + %5 = arith.cmpf ogt, %in, %arg3 : f32 + %6 = arith.select %5, %arg3, %in : f32 + %7 = arith.select %4, %arg2, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardtanh/orig.mlir b/issues/aten_c_kernels/results/aten_hardtanh/orig.mlir new file mode 100644 index 000000000000..aaa56f9e30c4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardtanh/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardtanh(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 256 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.cmpf olt, %0, %arg2 : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %arg2 : f32 + } else { + %3 = arith.cmpf ogt, %0, %arg3 : f32 + %4 = arith.select %3, %arg3, %0 : f32 + scf.yield %4 : f32 + } + affine.store %2, %arg1[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_hardtanh/raised.mlir b/issues/aten_c_kernels/results/aten_hardtanh/raised.mlir new file mode 100644 index 000000000000..01ef52aec950 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardtanh/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardtanh(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %arg2 : f32 + %1 = arith.cmpf ogt, %in, %arg3 : f32 + %2 = arith.select %1, %arg3, %in : f32 + %3 = arith.select %0, %arg2, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardtanh_backward.mlir b/issues/aten_c_kernels/results/aten_hardtanh_backward.mlir new file mode 100644 index 000000000000..d3de861b37fe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardtanh_backward.mlir @@ -0,0 +1,24 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardtanh_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 4096 { + %0 = affine.load %arg1[%arg5] : memref + %1 = arith.cmpf ole, %0, %arg2 : f32 + %2 = scf.if %1 -> (i1) { + scf.yield %true : i1 + } else { + %4 = arith.cmpf oge, %0, %arg3 : f32 + scf.yield %4 : i1 + } + %3 = scf.if %2 -> (f32) { + scf.yield %cst : f32 + } else { + %4 = affine.load %arg0[%arg5] : memref + scf.yield %4 : f32 + } + affine.store %3, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_hardtanh_backward/debuf.mlir b/issues/aten_c_kernels/results/aten_hardtanh_backward/debuf.mlir new file mode 100644 index 000000000000..725ffdd9040b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardtanh_backward/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardtanh_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %true = arith.constant true + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf ole, %in, %arg2 : f32 + %6 = arith.cmpf oge, %in, %arg3 : f32 + %7 = arith.select %5, %true, %6 : i1 + %8 = arith.select %7, %cst, %in_0 : f32 + linalg.yield %8 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardtanh_backward/matched.mlir b/issues/aten_c_kernels/results/aten_hardtanh_backward/matched.mlir new file mode 100644 index 000000000000..725ffdd9040b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardtanh_backward/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardtanh_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %true = arith.constant true + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf ole, %in, %arg2 : f32 + %6 = arith.cmpf oge, %in, %arg3 : f32 + %7 = arith.select %5, %true, %6 : i1 + %8 = arith.select %7, %cst, %in_0 : f32 + linalg.yield %8 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardtanh_backward/orig.mlir b/issues/aten_c_kernels/results/aten_hardtanh_backward/orig.mlir new file mode 100644 index 000000000000..d3de861b37fe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardtanh_backward/orig.mlir @@ -0,0 +1,24 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardtanh_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 4096 { + %0 = affine.load %arg1[%arg5] : memref + %1 = arith.cmpf ole, %0, %arg2 : f32 + %2 = scf.if %1 -> (i1) { + scf.yield %true : i1 + } else { + %4 = arith.cmpf oge, %0, %arg3 : f32 + scf.yield %4 : i1 + } + %3 = scf.if %2 -> (f32) { + scf.yield %cst : f32 + } else { + %4 = affine.load %arg0[%arg5] : memref + scf.yield %4 : f32 + } + affine.store %3, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_hardtanh_backward/raised.mlir b/issues/aten_c_kernels/results/aten_hardtanh_backward/raised.mlir new file mode 100644 index 000000000000..86c48cb4a575 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardtanh_backward/raised.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardtanh_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0 : memref, memref) outs(%arg4 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf ole, %in, %arg2 : f32 + %1 = arith.cmpf oge, %in, %arg3 : f32 + %2 = arith.select %0, %true, %1 : i1 + %3 = arith.select %2, %cst, %in_0 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardtanh_backward_debuf.mlir b/issues/aten_c_kernels/results/aten_hardtanh_backward_debuf.mlir new file mode 100644 index 000000000000..725ffdd9040b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardtanh_backward_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardtanh_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %true = arith.constant true + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf ole, %in, %arg2 : f32 + %6 = arith.cmpf oge, %in, %arg3 : f32 + %7 = arith.select %5, %true, %6 : i1 + %8 = arith.select %7, %cst, %in_0 : f32 + linalg.yield %8 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardtanh_backward_linalg.mlir b/issues/aten_c_kernels/results/aten_hardtanh_backward_linalg.mlir new file mode 100644 index 000000000000..86c48cb4a575 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardtanh_backward_linalg.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardtanh_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0 : memref, memref) outs(%arg4 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf ole, %in, %arg2 : f32 + %1 = arith.cmpf oge, %in, %arg3 : f32 + %2 = arith.select %0, %true, %1 : i1 + %3 = arith.select %2, %cst, %in_0 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardtanh_debuf.mlir b/issues/aten_c_kernels/results/aten_hardtanh_debuf.mlir new file mode 100644 index 000000000000..f93a7a6f3b36 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardtanh_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardtanh(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %arg2 : f32 + %5 = arith.cmpf ogt, %in, %arg3 : f32 + %6 = arith.select %5, %arg3, %in : f32 + %7 = arith.select %4, %arg2, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hardtanh_linalg.mlir b/issues/aten_c_kernels/results/aten_hardtanh_linalg.mlir new file mode 100644 index 000000000000..01ef52aec950 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hardtanh_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hardtanh(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %arg2 : f32 + %1 = arith.cmpf ogt, %in, %arg3 : f32 + %2 = arith.select %1, %arg3, %in : f32 + %3 = arith.select %0, %arg2, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_heaviside.mlir b/issues/aten_c_kernels/results/aten_heaviside.mlir new file mode 100644 index 000000000000..809e03fa71d0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_heaviside.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_heaviside(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf oeq, %0, %cst : f32 + %2 = scf.if %1 -> (f32) { + %3 = affine.load %arg1[%arg3] : memref + scf.yield %3 : f32 + } else { + %3 = arith.cmpf ogt, %0, %cst : f32 + %4 = arith.extui %3 : i1 to i32 + %5 = arith.sitofp %4 : i32 to f32 + scf.yield %5 : f32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_heaviside/debuf.mlir b/issues/aten_c_kernels/results/aten_heaviside/debuf.mlir new file mode 100644 index 000000000000..ebe604c46d45 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_heaviside/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_heaviside(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf oeq, %in, %cst : f32 + %6 = arith.cmpf ogt, %in, %cst : f32 + %7 = arith.extui %6 : i1 to i32 + %8 = arith.sitofp %7 : i32 to f32 + %9 = arith.select %5, %in_0, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_heaviside/matched.mlir b/issues/aten_c_kernels/results/aten_heaviside/matched.mlir new file mode 100644 index 000000000000..ebe604c46d45 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_heaviside/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_heaviside(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf oeq, %in, %cst : f32 + %6 = arith.cmpf ogt, %in, %cst : f32 + %7 = arith.extui %6 : i1 to i32 + %8 = arith.sitofp %7 : i32 to f32 + %9 = arith.select %5, %in_0, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_heaviside/orig.mlir b/issues/aten_c_kernels/results/aten_heaviside/orig.mlir new file mode 100644 index 000000000000..809e03fa71d0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_heaviside/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_heaviside(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf oeq, %0, %cst : f32 + %2 = scf.if %1 -> (f32) { + %3 = affine.load %arg1[%arg3] : memref + scf.yield %3 : f32 + } else { + %3 = arith.cmpf ogt, %0, %cst : f32 + %4 = arith.extui %3 : i1 to i32 + %5 = arith.sitofp %4 : i32 to f32 + scf.yield %5 : f32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_heaviside/raised.mlir b/issues/aten_c_kernels/results/aten_heaviside/raised.mlir new file mode 100644 index 000000000000..7cccea10fc7f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_heaviside/raised.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_heaviside(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf oeq, %in, %cst : f32 + %1 = arith.cmpf ogt, %in, %cst : f32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.select %0, %in_0, %3 : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_heaviside_debuf.mlir b/issues/aten_c_kernels/results/aten_heaviside_debuf.mlir new file mode 100644 index 000000000000..ebe604c46d45 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_heaviside_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_heaviside(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf oeq, %in, %cst : f32 + %6 = arith.cmpf ogt, %in, %cst : f32 + %7 = arith.extui %6 : i1 to i32 + %8 = arith.sitofp %7 : i32 to f32 + %9 = arith.select %5, %in_0, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_heaviside_linalg.mlir b/issues/aten_c_kernels/results/aten_heaviside_linalg.mlir new file mode 100644 index 000000000000..7cccea10fc7f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_heaviside_linalg.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_heaviside(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf oeq, %in, %cst : f32 + %1 = arith.cmpf ogt, %in, %cst : f32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.select %0, %in_0, %3 : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hermite_polynomial_h.mlir b/issues/aten_c_kernels/results/aten_hermite_polynomial_h.mlir new file mode 100644 index 000000000000..b2d09189242a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hermite_polynomial_h.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hermite_polynomial_h(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_hermite_hf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_hermite_hf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_hermite_polynomial_h/debuf.mlir b/issues/aten_c_kernels/results/aten_hermite_polynomial_h/debuf.mlir new file mode 100644 index 000000000000..c7aa27743d9f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hermite_polynomial_h/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hermite_polynomial_h(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_hermite_hf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_hermite_hf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_hermite_polynomial_h/matched.mlir b/issues/aten_c_kernels/results/aten_hermite_polynomial_h/matched.mlir new file mode 100644 index 000000000000..c7aa27743d9f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hermite_polynomial_h/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hermite_polynomial_h(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_hermite_hf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_hermite_hf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_hermite_polynomial_h/orig.mlir b/issues/aten_c_kernels/results/aten_hermite_polynomial_h/orig.mlir new file mode 100644 index 000000000000..b2d09189242a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hermite_polynomial_h/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hermite_polynomial_h(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_hermite_hf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_hermite_hf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_hermite_polynomial_h/raised.mlir b/issues/aten_c_kernels/results/aten_hermite_polynomial_h/raised.mlir new file mode 100644 index 000000000000..98c600e7ce48 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hermite_polynomial_h/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hermite_polynomial_h(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_hermite_hf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_hermite_hf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_hermite_polynomial_h_debuf.mlir b/issues/aten_c_kernels/results/aten_hermite_polynomial_h_debuf.mlir new file mode 100644 index 000000000000..c7aa27743d9f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hermite_polynomial_h_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hermite_polynomial_h(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_hermite_hf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_hermite_hf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_hermite_polynomial_h_linalg.mlir b/issues/aten_c_kernels/results/aten_hermite_polynomial_h_linalg.mlir new file mode 100644 index 000000000000..98c600e7ce48 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hermite_polynomial_h_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hermite_polynomial_h(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_hermite_hf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_hermite_hf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_hermite_polynomial_he.mlir b/issues/aten_c_kernels/results/aten_hermite_polynomial_he.mlir new file mode 100644 index 000000000000..635bd271b971 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hermite_polynomial_he.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hermite_polynomial_he(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_hermite_hef(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_hermite_hef(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_hermite_polynomial_he/debuf.mlir b/issues/aten_c_kernels/results/aten_hermite_polynomial_he/debuf.mlir new file mode 100644 index 000000000000..6eb39e18ae3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hermite_polynomial_he/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hermite_polynomial_he(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_hermite_hef(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_hermite_hef(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_hermite_polynomial_he/matched.mlir b/issues/aten_c_kernels/results/aten_hermite_polynomial_he/matched.mlir new file mode 100644 index 000000000000..6eb39e18ae3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hermite_polynomial_he/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hermite_polynomial_he(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_hermite_hef(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_hermite_hef(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_hermite_polynomial_he/orig.mlir b/issues/aten_c_kernels/results/aten_hermite_polynomial_he/orig.mlir new file mode 100644 index 000000000000..635bd271b971 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hermite_polynomial_he/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hermite_polynomial_he(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_hermite_hef(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_hermite_hef(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_hermite_polynomial_he/raised.mlir b/issues/aten_c_kernels/results/aten_hermite_polynomial_he/raised.mlir new file mode 100644 index 000000000000..b390f3edf582 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hermite_polynomial_he/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hermite_polynomial_he(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_hermite_hef(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_hermite_hef(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_hermite_polynomial_he_debuf.mlir b/issues/aten_c_kernels/results/aten_hermite_polynomial_he_debuf.mlir new file mode 100644 index 000000000000..6eb39e18ae3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hermite_polynomial_he_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hermite_polynomial_he(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_hermite_hef(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_hermite_hef(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_hermite_polynomial_he_linalg.mlir b/issues/aten_c_kernels/results/aten_hermite_polynomial_he_linalg.mlir new file mode 100644 index 000000000000..b390f3edf582 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hermite_polynomial_he_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hermite_polynomial_he(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_hermite_hef(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_hermite_hef(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu.mlir b/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu.mlir new file mode 100644 index 000000000000..68d9f143d081 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogram_select_outer_bin_edges_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = affine.load %arg0[0] : memref + %1:2 = affine.for %arg3 = 1 to 4096 iter_args(%arg4 = %0, %arg5 = %0) -> (f32, f32) { + %2 = affine.load %arg0[%arg3] : memref + %3 = arith.cmpf olt, %2, %arg5 : f32 + %4 = arith.select %3, %2, %arg5 : f32 + %5 = arith.cmpf ogt, %2, %arg4 : f32 + %6 = arith.select %5, %2, %arg4 : f32 + affine.yield %6, %4 : f32, f32 + } + affine.store %1#1, %arg1[0] : memref + affine.store %1#0, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu/debuf.mlir new file mode 100644 index 000000000000..c5d7845b3167 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu/debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogram_select_outer_bin_edges_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted = tensor.extract %0[%c0] : tensor + %3 = tensor.empty() : tensor + %inserted = tensor.insert %extracted into %3[] : tensor + %4 = tensor.empty() : tensor + %inserted_0 = tensor.insert %extracted into %4[] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %5:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted, %inserted_0 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_5: f32): + %8 = arith.cmpf olt, %in, %out_5 : f32 + %9 = arith.select %8, %in, %out_5 : f32 + %10 = arith.cmpf ogt, %in, %out : f32 + %11 = arith.select %10, %in, %out : f32 + linalg.yield %11, %9 : f32, f32 + } -> (tensor, tensor) + %extracted_1 = tensor.extract %5#0[] : tensor + %extracted_2 = tensor.extract %5#1[] : tensor + %inserted_3 = tensor.insert %extracted_2 into %1[%c0] : tensor + %6 = bufferization.to_memref %inserted_3 : memref + memref.copy %6, %arg1 : memref to memref + %inserted_4 = tensor.insert %extracted_1 into %2[%c0] : tensor + %7 = bufferization.to_memref %inserted_4 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu/matched.mlir new file mode 100644 index 000000000000..c5d7845b3167 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu/matched.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogram_select_outer_bin_edges_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted = tensor.extract %0[%c0] : tensor + %3 = tensor.empty() : tensor + %inserted = tensor.insert %extracted into %3[] : tensor + %4 = tensor.empty() : tensor + %inserted_0 = tensor.insert %extracted into %4[] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %5:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted, %inserted_0 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_5: f32): + %8 = arith.cmpf olt, %in, %out_5 : f32 + %9 = arith.select %8, %in, %out_5 : f32 + %10 = arith.cmpf ogt, %in, %out : f32 + %11 = arith.select %10, %in, %out : f32 + linalg.yield %11, %9 : f32, f32 + } -> (tensor, tensor) + %extracted_1 = tensor.extract %5#0[] : tensor + %extracted_2 = tensor.extract %5#1[] : tensor + %inserted_3 = tensor.insert %extracted_2 into %1[%c0] : tensor + %6 = bufferization.to_memref %inserted_3 : memref + memref.copy %6, %arg1 : memref to memref + %inserted_4 = tensor.insert %extracted_1 into %2[%c0] : tensor + %7 = bufferization.to_memref %inserted_4 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu/orig.mlir new file mode 100644 index 000000000000..68d9f143d081 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu/orig.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogram_select_outer_bin_edges_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = affine.load %arg0[0] : memref + %1:2 = affine.for %arg3 = 1 to 4096 iter_args(%arg4 = %0, %arg5 = %0) -> (f32, f32) { + %2 = affine.load %arg0[%arg3] : memref + %3 = arith.cmpf olt, %2, %arg5 : f32 + %4 = arith.select %3, %2, %arg5 : f32 + %5 = arith.cmpf ogt, %2, %arg4 : f32 + %6 = arith.select %5, %2, %arg4 : f32 + affine.yield %6, %4 : f32, f32 + } + affine.store %1#1, %arg1[0] : memref + affine.store %1#0, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu/raised.mlir new file mode 100644 index 000000000000..0122b81d1941 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu/raised.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogram_select_outer_bin_edges_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %0 = affine.load %arg0[0] : memref + %alloca = memref.alloca() : memref + affine.store %0, %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %0, %alloca_0[] : memref + %subview = memref.subview %arg0[1] [%c4095] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca, %alloca_0 : memref, memref) { + ^bb0(%in: f32, %out: f32, %out_1: f32): + %3 = arith.cmpf olt, %in, %out_1 : f32 + %4 = arith.select %3, %in, %out_1 : f32 + %5 = arith.cmpf ogt, %in, %out : f32 + %6 = arith.select %5, %in, %out : f32 + linalg.yield %6, %4 : f32, f32 + } + %1 = affine.load %alloca[] : memref + %2 = affine.load %alloca_0[] : memref + affine.store %2, %arg1[0] : memref + affine.store %1, %arg2[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu_debuf.mlir new file mode 100644 index 000000000000..c5d7845b3167 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu_debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogram_select_outer_bin_edges_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted = tensor.extract %0[%c0] : tensor + %3 = tensor.empty() : tensor + %inserted = tensor.insert %extracted into %3[] : tensor + %4 = tensor.empty() : tensor + %inserted_0 = tensor.insert %extracted into %4[] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %5:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted, %inserted_0 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_5: f32): + %8 = arith.cmpf olt, %in, %out_5 : f32 + %9 = arith.select %8, %in, %out_5 : f32 + %10 = arith.cmpf ogt, %in, %out : f32 + %11 = arith.select %10, %in, %out : f32 + linalg.yield %11, %9 : f32, f32 + } -> (tensor, tensor) + %extracted_1 = tensor.extract %5#0[] : tensor + %extracted_2 = tensor.extract %5#1[] : tensor + %inserted_3 = tensor.insert %extracted_2 into %1[%c0] : tensor + %6 = bufferization.to_memref %inserted_3 : memref + memref.copy %6, %arg1 : memref to memref + %inserted_4 = tensor.insert %extracted_1 into %2[%c0] : tensor + %7 = bufferization.to_memref %inserted_4 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu_linalg.mlir new file mode 100644 index 000000000000..0122b81d1941 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogram_select_outer_bin_edges_cpu_linalg.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogram_select_outer_bin_edges_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %0 = affine.load %arg0[0] : memref + %alloca = memref.alloca() : memref + affine.store %0, %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %0, %alloca_0[] : memref + %subview = memref.subview %arg0[1] [%c4095] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca, %alloca_0 : memref, memref) { + ^bb0(%in: f32, %out: f32, %out_1: f32): + %3 = arith.cmpf olt, %in, %out_1 : f32 + %4 = arith.select %3, %in, %out_1 : f32 + %5 = arith.cmpf ogt, %in, %out : f32 + %6 = arith.select %5, %in, %out : f32 + linalg.yield %6, %4 : f32, f32 + } + %1 = affine.load %alloca[] : memref + %2 = affine.load %alloca_0[] : memref + affine.store %2, %arg1[0] : memref + affine.store %1, %arg2[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_histogramdd_cpu.mlir b/issues/aten_c_kernels/results/aten_histogramdd_cpu.mlir new file mode 100644 index 000000000000..3780f4747e65 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogramdd_cpu.mlir @@ -0,0 +1,45 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogramdd_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.200000e+01 : f32 + %cst_0 = arith.constant 1.600000e+01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c12_i32 = arith.constant 12 : i32 + %c16_i32 = arith.constant 16 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg7 = 0 to 16 { + affine.for %arg8 = 0 to 12 { + affine.store %cst_1, %arg6[%arg7, %arg8] : memref + } + } + %0 = arith.subf %arg3, %arg2 : f32 + %1 = arith.subf %arg5, %arg4 : f32 + affine.for %arg7 = 0 to 4096 { + %2 = affine.load %arg0[%arg7, 0] : memref + %3 = arith.subf %2, %arg2 : f32 + %4 = arith.mulf %3, %cst_0 : f32 + %5 = arith.divf %4, %0 : f32 + %6 = arith.fptosi %5 : f32 to i32 + %7 = affine.load %arg0[%arg7, 1] : memref + %8 = arith.subf %7, %arg4 : f32 + %9 = arith.mulf %8, %cst : f32 + %10 = arith.divf %9, %1 : f32 + %11 = arith.fptosi %10 : f32 to i32 + %12 = arith.cmpi sge, %6, %c0_i32 : i32 + %13 = arith.cmpi slt, %6, %c16_i32 : i32 + %14 = arith.cmpi sge, %11, %c0_i32 : i32 + %15 = arith.cmpi slt, %11, %c12_i32 : i32 + %16 = arith.andi %14, %15 : i1 + %17 = arith.andi %13, %16 : i1 + %18 = arith.andi %12, %17 : i1 + scf.if %18 { + %19 = arith.index_cast %6 : i32 to index + %20 = arith.index_cast %11 : i32 to index + %21 = affine.load %arg1[%arg7] : memref + %22 = memref.load %arg6[%19, %20] : memref + %23 = arith.addf %22, %21 : f32 + memref.store %23, %arg6[%19, %20] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_histogramdd_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_histogramdd_cpu/debuf.mlir new file mode 100644 index 000000000000..61cb111a6d49 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogramdd_cpu/debuf.mlir @@ -0,0 +1,61 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogramdd_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c16_i32 = arith.constant 16 : i32 + %c12_i32 = arith.constant 12 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.600000e+01 : f32 + %cst_1 = arith.constant 1.200000e+01 : f32 + %c12 = arith.constant 12 : index + %c16 = arith.constant 16 : index + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c12] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [%c16, %c12] [1, 1] : tensor into tensor + %4 = arith.subf %arg3, %arg2 : f32 + %5 = arith.subf %arg5, %arg4 : f32 + %6 = affine.for %arg7 = 0 to 4096 iter_args(%arg8 = %inserted_slice) -> (tensor) { + %extracted = tensor.extract %2[%arg7, %c0] : tensor + %8 = arith.subf %extracted, %arg2 : f32 + %9 = arith.mulf %8, %cst_0 : f32 + %10 = arith.divf %9, %4 : f32 + %11 = arith.fptosi %10 : f32 to i32 + %extracted_2 = tensor.extract %2[%arg7, %c1] : tensor + %12 = arith.subf %extracted_2, %arg4 : f32 + %13 = arith.mulf %12, %cst_1 : f32 + %14 = arith.divf %13, %5 : f32 + %15 = arith.fptosi %14 : f32 to i32 + %16 = arith.cmpi sge, %11, %c0_i32 : i32 + %17 = arith.cmpi slt, %11, %c16_i32 : i32 + %18 = arith.cmpi sge, %15, %c0_i32 : i32 + %19 = arith.cmpi slt, %15, %c12_i32 : i32 + %20 = arith.andi %18, %19 : i1 + %21 = arith.andi %17, %20 : i1 + %22 = arith.andi %16, %21 : i1 + %23 = scf.if %22 -> (tensor) { + %24 = arith.index_cast %11 : i32 to index + %25 = arith.index_cast %15 : i32 to index + %extracted_3 = tensor.extract %1[%arg7] : tensor + %extracted_4 = tensor.extract %arg8[%24, %25] : tensor + %26 = arith.addf %extracted_4, %extracted_3 : f32 + %inserted = tensor.insert %26 into %arg8[%24, %25] : tensor + scf.yield %inserted : tensor + } else { + scf.yield %arg8 : tensor + } + affine.yield %23 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg6 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_histogramdd_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_histogramdd_cpu/matched.mlir new file mode 100644 index 000000000000..5fd4890faaa3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogramdd_cpu/matched.mlir @@ -0,0 +1,58 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogramdd_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c16_i32 = arith.constant 16 : i32 + %c12_i32 = arith.constant 12 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.600000e+01 : f32 + %cst_1 = arith.constant 1.200000e+01 : f32 + %c12 = arith.constant 12 : index + %c16 = arith.constant 16 : index + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c12] [1, 1] : tensor to tensor + %3 = kernel.launch @memset_zero_2D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [%c16, %c12] [1, 1] : tensor into tensor + %4 = arith.subf %arg3, %arg2 : f32 + %5 = arith.subf %arg5, %arg4 : f32 + %6 = affine.for %arg7 = 0 to 4096 iter_args(%arg8 = %inserted_slice) -> (tensor) { + %extracted = tensor.extract %2[%arg7, %c0] : tensor + %8 = arith.subf %extracted, %arg2 : f32 + %9 = arith.mulf %8, %cst_0 : f32 + %10 = arith.divf %9, %4 : f32 + %11 = arith.fptosi %10 : f32 to i32 + %extracted_2 = tensor.extract %2[%arg7, %c1] : tensor + %12 = arith.subf %extracted_2, %arg4 : f32 + %13 = arith.mulf %12, %cst_1 : f32 + %14 = arith.divf %13, %5 : f32 + %15 = arith.fptosi %14 : f32 to i32 + %16 = arith.cmpi sge, %11, %c0_i32 : i32 + %17 = arith.cmpi slt, %11, %c16_i32 : i32 + %18 = arith.cmpi sge, %15, %c0_i32 : i32 + %19 = arith.cmpi slt, %15, %c12_i32 : i32 + %20 = arith.andi %18, %19 : i1 + %21 = arith.andi %17, %20 : i1 + %22 = arith.andi %16, %21 : i1 + %23 = scf.if %22 -> (tensor) { + %24 = arith.index_cast %11 : i32 to index + %25 = arith.index_cast %15 : i32 to index + %extracted_3 = tensor.extract %1[%arg7] : tensor + %extracted_4 = tensor.extract %arg8[%24, %25] : tensor + %26 = arith.addf %extracted_4, %extracted_3 : f32 + %inserted = tensor.insert %26 into %arg8[%24, %25] : tensor + scf.yield %inserted : tensor + } else { + scf.yield %arg8 : tensor + } + affine.yield %23 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg6 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_histogramdd_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_histogramdd_cpu/orig.mlir new file mode 100644 index 000000000000..3780f4747e65 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogramdd_cpu/orig.mlir @@ -0,0 +1,45 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogramdd_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.200000e+01 : f32 + %cst_0 = arith.constant 1.600000e+01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c12_i32 = arith.constant 12 : i32 + %c16_i32 = arith.constant 16 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg7 = 0 to 16 { + affine.for %arg8 = 0 to 12 { + affine.store %cst_1, %arg6[%arg7, %arg8] : memref + } + } + %0 = arith.subf %arg3, %arg2 : f32 + %1 = arith.subf %arg5, %arg4 : f32 + affine.for %arg7 = 0 to 4096 { + %2 = affine.load %arg0[%arg7, 0] : memref + %3 = arith.subf %2, %arg2 : f32 + %4 = arith.mulf %3, %cst_0 : f32 + %5 = arith.divf %4, %0 : f32 + %6 = arith.fptosi %5 : f32 to i32 + %7 = affine.load %arg0[%arg7, 1] : memref + %8 = arith.subf %7, %arg4 : f32 + %9 = arith.mulf %8, %cst : f32 + %10 = arith.divf %9, %1 : f32 + %11 = arith.fptosi %10 : f32 to i32 + %12 = arith.cmpi sge, %6, %c0_i32 : i32 + %13 = arith.cmpi slt, %6, %c16_i32 : i32 + %14 = arith.cmpi sge, %11, %c0_i32 : i32 + %15 = arith.cmpi slt, %11, %c12_i32 : i32 + %16 = arith.andi %14, %15 : i1 + %17 = arith.andi %13, %16 : i1 + %18 = arith.andi %12, %17 : i1 + scf.if %18 { + %19 = arith.index_cast %6 : i32 to index + %20 = arith.index_cast %11 : i32 to index + %21 = affine.load %arg1[%arg7] : memref + %22 = memref.load %arg6[%19, %20] : memref + %23 = arith.addf %22, %21 : f32 + memref.store %23, %arg6[%19, %20] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_histogramdd_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_histogramdd_cpu/raised.mlir new file mode 100644 index 000000000000..f8b4dd55d50e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogramdd_cpu/raised.mlir @@ -0,0 +1,49 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogramdd_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c12 = arith.constant 12 : index + %cst = arith.constant 1.200000e+01 : f32 + %cst_0 = arith.constant 1.600000e+01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c12_i32 = arith.constant 12 : i32 + %c16_i32 = arith.constant 16 : i32 + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg6[0, 0] [%c16, %c12] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_1 : f32 + } + %0 = arith.subf %arg3, %arg2 : f32 + %1 = arith.subf %arg5, %arg4 : f32 + affine.for %arg7 = 0 to 4096 { + %2 = affine.load %arg0[%arg7, 0] : memref + %3 = arith.subf %2, %arg2 : f32 + %4 = arith.mulf %3, %cst_0 : f32 + %5 = arith.divf %4, %0 : f32 + %6 = arith.fptosi %5 : f32 to i32 + %7 = affine.load %arg0[%arg7, 1] : memref + %8 = arith.subf %7, %arg4 : f32 + %9 = arith.mulf %8, %cst : f32 + %10 = arith.divf %9, %1 : f32 + %11 = arith.fptosi %10 : f32 to i32 + %12 = arith.cmpi sge, %6, %c0_i32 : i32 + %13 = arith.cmpi slt, %6, %c16_i32 : i32 + %14 = arith.cmpi sge, %11, %c0_i32 : i32 + %15 = arith.cmpi slt, %11, %c12_i32 : i32 + %16 = arith.andi %14, %15 : i1 + %17 = arith.andi %13, %16 : i1 + %18 = arith.andi %12, %17 : i1 + scf.if %18 { + %19 = arith.index_cast %6 : i32 to index + %20 = arith.index_cast %11 : i32 to index + %21 = affine.load %arg1[%arg7] : memref + %22 = memref.load %arg6[%19, %20] : memref + %23 = arith.addf %22, %21 : f32 + memref.store %23, %arg6[%19, %20] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_histogramdd_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_histogramdd_cpu_debuf.mlir new file mode 100644 index 000000000000..61cb111a6d49 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogramdd_cpu_debuf.mlir @@ -0,0 +1,61 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogramdd_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c16_i32 = arith.constant 16 : i32 + %c12_i32 = arith.constant 12 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.600000e+01 : f32 + %cst_1 = arith.constant 1.200000e+01 : f32 + %c12 = arith.constant 12 : index + %c16 = arith.constant 16 : index + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c12] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [%c16, %c12] [1, 1] : tensor into tensor + %4 = arith.subf %arg3, %arg2 : f32 + %5 = arith.subf %arg5, %arg4 : f32 + %6 = affine.for %arg7 = 0 to 4096 iter_args(%arg8 = %inserted_slice) -> (tensor) { + %extracted = tensor.extract %2[%arg7, %c0] : tensor + %8 = arith.subf %extracted, %arg2 : f32 + %9 = arith.mulf %8, %cst_0 : f32 + %10 = arith.divf %9, %4 : f32 + %11 = arith.fptosi %10 : f32 to i32 + %extracted_2 = tensor.extract %2[%arg7, %c1] : tensor + %12 = arith.subf %extracted_2, %arg4 : f32 + %13 = arith.mulf %12, %cst_1 : f32 + %14 = arith.divf %13, %5 : f32 + %15 = arith.fptosi %14 : f32 to i32 + %16 = arith.cmpi sge, %11, %c0_i32 : i32 + %17 = arith.cmpi slt, %11, %c16_i32 : i32 + %18 = arith.cmpi sge, %15, %c0_i32 : i32 + %19 = arith.cmpi slt, %15, %c12_i32 : i32 + %20 = arith.andi %18, %19 : i1 + %21 = arith.andi %17, %20 : i1 + %22 = arith.andi %16, %21 : i1 + %23 = scf.if %22 -> (tensor) { + %24 = arith.index_cast %11 : i32 to index + %25 = arith.index_cast %15 : i32 to index + %extracted_3 = tensor.extract %1[%arg7] : tensor + %extracted_4 = tensor.extract %arg8[%24, %25] : tensor + %26 = arith.addf %extracted_4, %extracted_3 : f32 + %inserted = tensor.insert %26 into %arg8[%24, %25] : tensor + scf.yield %inserted : tensor + } else { + scf.yield %arg8 : tensor + } + affine.yield %23 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg6 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_histogramdd_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_histogramdd_cpu_linalg.mlir new file mode 100644 index 000000000000..f8b4dd55d50e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogramdd_cpu_linalg.mlir @@ -0,0 +1,49 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogramdd_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: f32, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c12 = arith.constant 12 : index + %cst = arith.constant 1.200000e+01 : f32 + %cst_0 = arith.constant 1.600000e+01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c12_i32 = arith.constant 12 : i32 + %c16_i32 = arith.constant 16 : i32 + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg6[0, 0] [%c16, %c12] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_1 : f32 + } + %0 = arith.subf %arg3, %arg2 : f32 + %1 = arith.subf %arg5, %arg4 : f32 + affine.for %arg7 = 0 to 4096 { + %2 = affine.load %arg0[%arg7, 0] : memref + %3 = arith.subf %2, %arg2 : f32 + %4 = arith.mulf %3, %cst_0 : f32 + %5 = arith.divf %4, %0 : f32 + %6 = arith.fptosi %5 : f32 to i32 + %7 = affine.load %arg0[%arg7, 1] : memref + %8 = arith.subf %7, %arg4 : f32 + %9 = arith.mulf %8, %cst : f32 + %10 = arith.divf %9, %1 : f32 + %11 = arith.fptosi %10 : f32 to i32 + %12 = arith.cmpi sge, %6, %c0_i32 : i32 + %13 = arith.cmpi slt, %6, %c16_i32 : i32 + %14 = arith.cmpi sge, %11, %c0_i32 : i32 + %15 = arith.cmpi slt, %11, %c12_i32 : i32 + %16 = arith.andi %14, %15 : i1 + %17 = arith.andi %13, %16 : i1 + %18 = arith.andi %12, %17 : i1 + scf.if %18 { + %19 = arith.index_cast %6 : i32 to index + %20 = arith.index_cast %11 : i32 to index + %21 = affine.load %arg1[%arg7] : memref + %22 = memref.load %arg6[%19, %20] : memref + %23 = arith.addf %22, %21 : f32 + memref.store %23, %arg6[%19, %20] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu.mlir b/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu.mlir new file mode 100644 index 000000000000..fe509eae1c85 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogramdd_linear_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c192_i32 = arith.constant 192 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 192 { + affine.store %cst, %arg2[%arg3] : memref + } + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpi sge, %0, %c0_i32 : i32 + scf.if %1 { + %2 = affine.load %arg0[%arg3] : memref + %3 = arith.cmpi slt, %2, %c192_i32 : i32 + scf.if %3 { + %4 = affine.load %arg0[%arg3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = affine.load %arg1[%arg3] : memref + %7 = memref.load %arg2[%5] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg2[%5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu/debuf.mlir new file mode 100644 index 000000000000..fab9315602b8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu/debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogramdd_linear_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c192_i32 = arith.constant 192 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = affine.for %arg3 = 0 to 4096 iter_args(%arg4 = %3) -> (tensor) { + %extracted = tensor.extract %2[%arg3] : tensor + %6 = arith.cmpi sge, %extracted, %c0_i32 : i32 + %7 = scf.if %6 -> (tensor) { + %extracted_0 = tensor.extract %2[%arg3] : tensor + %8 = arith.cmpi slt, %extracted_0, %c192_i32 : i32 + %9 = scf.if %8 -> (tensor) { + %extracted_1 = tensor.extract %2[%arg3] : tensor + %10 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %1[%arg3] : tensor + %extracted_3 = tensor.extract %arg4[%10] : tensor + %11 = arith.addf %extracted_3, %extracted_2 : f32 + %inserted = tensor.insert %11 into %arg4[%10] : tensor + scf.yield %inserted : tensor + } else { + scf.yield %arg4 : tensor + } + scf.yield %9 : tensor + } else { + scf.yield %arg4 : tensor + } + affine.yield %7 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu/matched.mlir new file mode 100644 index 000000000000..daa75f86c910 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu/matched.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogramdd_linear_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c192_i32 = arith.constant 192 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %4 = affine.for %arg3 = 0 to 4096 iter_args(%arg4 = %3) -> (tensor) { + %extracted = tensor.extract %2[%arg3] : tensor + %6 = arith.cmpi sge, %extracted, %c0_i32 : i32 + %7 = scf.if %6 -> (tensor) { + %extracted_0 = tensor.extract %2[%arg3] : tensor + %8 = arith.cmpi slt, %extracted_0, %c192_i32 : i32 + %9 = scf.if %8 -> (tensor) { + %extracted_1 = tensor.extract %2[%arg3] : tensor + %10 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %1[%arg3] : tensor + %extracted_3 = tensor.extract %arg4[%10] : tensor + %11 = arith.addf %extracted_3, %extracted_2 : f32 + %inserted = tensor.insert %11 into %arg4[%10] : tensor + scf.yield %inserted : tensor + } else { + scf.yield %arg4 : tensor + } + scf.yield %9 : tensor + } else { + scf.yield %arg4 : tensor + } + affine.yield %7 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu/orig.mlir new file mode 100644 index 000000000000..fe509eae1c85 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu/orig.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogramdd_linear_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c192_i32 = arith.constant 192 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 192 { + affine.store %cst, %arg2[%arg3] : memref + } + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpi sge, %0, %c0_i32 : i32 + scf.if %1 { + %2 = affine.load %arg0[%arg3] : memref + %3 = arith.cmpi slt, %2, %c192_i32 : i32 + scf.if %3 { + %4 = affine.load %arg0[%arg3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = affine.load %arg1[%arg3] : memref + %7 = memref.load %arg2[%5] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg2[%5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu/raised.mlir new file mode 100644 index 000000000000..77411e249e8c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu/raised.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogramdd_linear_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c192_i32 = arith.constant 192 : i32 + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpi sge, %0, %c0_i32 : i32 + scf.if %1 { + %2 = affine.load %arg0[%arg3] : memref + %3 = arith.cmpi slt, %2, %c192_i32 : i32 + scf.if %3 { + %4 = affine.load %arg0[%arg3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = affine.load %arg1[%arg3] : memref + %7 = memref.load %arg2[%5] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg2[%5] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu_debuf.mlir new file mode 100644 index 000000000000..fab9315602b8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu_debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogramdd_linear_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c192_i32 = arith.constant 192 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = affine.for %arg3 = 0 to 4096 iter_args(%arg4 = %3) -> (tensor) { + %extracted = tensor.extract %2[%arg3] : tensor + %6 = arith.cmpi sge, %extracted, %c0_i32 : i32 + %7 = scf.if %6 -> (tensor) { + %extracted_0 = tensor.extract %2[%arg3] : tensor + %8 = arith.cmpi slt, %extracted_0, %c192_i32 : i32 + %9 = scf.if %8 -> (tensor) { + %extracted_1 = tensor.extract %2[%arg3] : tensor + %10 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %1[%arg3] : tensor + %extracted_3 = tensor.extract %arg4[%10] : tensor + %11 = arith.addf %extracted_3, %extracted_2 : f32 + %inserted = tensor.insert %11 into %arg4[%10] : tensor + scf.yield %inserted : tensor + } else { + scf.yield %arg4 : tensor + } + scf.yield %9 : tensor + } else { + scf.yield %arg4 : tensor + } + affine.yield %7 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu_linalg.mlir new file mode 100644 index 000000000000..77411e249e8c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_histogramdd_linear_cpu_linalg.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_histogramdd_linear_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c192_i32 = arith.constant 192 : i32 + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpi sge, %0, %c0_i32 : i32 + scf.if %1 { + %2 = affine.load %arg0[%arg3] : memref + %3 = arith.cmpi slt, %2, %c192_i32 : i32 + scf.if %3 { + %4 = affine.load %arg0[%arg3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = affine.load %arg1[%arg3] : memref + %7 = memref.load %arg2[%5] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg2[%5] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu.mlir new file mode 100644 index 000000000000..925c9a1f97ba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_host_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 32 { + %0 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg3, %arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.for %arg4 = 0 to 64 { + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = affine.load %arg0[%arg3, %arg4] : memref + %3 = arith.subf %2, %0 : f32 + %4 = arith.mulf %1, %3 : f32 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..8dafce7d3958 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu/debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_host_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %alloca = memref.alloca() : memref + %7 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %7[] : tensor + %extracted_slice = tensor.extract_slice %4[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %10 = arith.mulf %in, %in_4 : f32 + %11 = arith.addf %out, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %extracted = tensor.extract %8[] : tensor + %extracted_slice_1 = tensor.extract_slice %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %1[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3, %extracted_slice_2 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %10 = arith.subf %in_4, %extracted : f32 + %11 = arith.mulf %in, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %9 into %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu/matched.mlir new file mode 100644 index 000000000000..5affb3e9bb17 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu/matched.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_host_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %alloca = memref.alloca() : memref + %7 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %7[] : tensor + %extracted_slice = tensor.extract_slice %4[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %8 = kernel.launch @cublasSdot(%extracted_slice, %extracted_slice_0, %inserted) : (tensor, tensor, tensor) -> tensor + %extracted = tensor.extract %8[] : tensor + %extracted_slice_1 = tensor.extract_slice %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %1[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3, %extracted_slice_2 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %10 = arith.subf %in_4, %extracted : f32 + %11 = arith.mulf %in, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %9 into %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu/orig.mlir new file mode 100644 index 000000000000..925c9a1f97ba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_host_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 32 { + %0 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg3, %arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.for %arg4 = 0 to 64 { + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = affine.load %arg0[%arg3, %arg4] : memref + %3 = arith.subf %2, %0 : f32 + %4 = arith.mulf %1, %3 : f32 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu/raised.mlir new file mode 100644 index 000000000000..0cda9aed99a0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu/raised.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_host_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 32 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %1 = arith.mulf %in, %in_5 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + %0 = affine.load %alloca[] : memref + %subview_2 = memref.subview %arg1[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg0[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg2[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%subview_2, %subview_3 : memref>, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %1 = arith.subf %in_5, %0 : f32 + %2 = arith.mulf %in, %1 : f32 + linalg.yield %2 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..8dafce7d3958 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu_debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_host_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %alloca = memref.alloca() : memref + %7 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %7[] : tensor + %extracted_slice = tensor.extract_slice %4[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %10 = arith.mulf %in, %in_4 : f32 + %11 = arith.addf %out, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %extracted = tensor.extract %8[] : tensor + %extracted_slice_1 = tensor.extract_slice %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %1[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3, %extracted_slice_2 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %10 = arith.subf %in_4, %extracted : f32 + %11 = arith.mulf %in, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %9 into %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..0cda9aed99a0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_host_softmax_backward_cpu_linalg.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_host_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 32 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %1 = arith.mulf %in, %in_5 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + %0 = affine.load %alloca[] : memref + %subview_2 = memref.subview %arg1[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg0[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg2[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%subview_2, %subview_3 : memref>, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %1 = arith.subf %in_5, %0 : f32 + %2 = arith.mulf %in, %1 : f32 + linalg.yield %2 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_host_softmax_cpu.mlir b/issues/aten_c_kernels/results/aten_host_softmax_cpu.mlir new file mode 100644 index 000000000000..5a3258d76533 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_host_softmax_cpu.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_host_softmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 32 { + %0 = affine.load %arg0[%arg2, 0] : memref + %1 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %0) -> (f32) { + %3 = affine.load %arg0[%arg2, %arg3] : memref + %4 = arith.cmpf ogt, %3, %arg4 : f32 + %5 = arith.select %4, %3, %arg4 : f32 + affine.yield %5 : f32 + } + %2 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %cst) -> (f32) { + %3 = affine.load %arg0[%arg2, %arg3] : memref + %4 = arith.subf %3, %1 : f32 + %5 = math.exp %4 : f32 + affine.store %5, %arg1[%arg2, %arg3] : memref + %6 = arith.addf %arg4, %5 : f32 + affine.yield %6 : f32 + } + affine.for %arg3 = 0 to 64 { + %3 = affine.load %arg1[%arg2, %arg3] : memref + %4 = arith.divf %3, %2 : f32 + affine.store %4, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_host_softmax_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_host_softmax_cpu/debuf.mlir new file mode 100644 index 000000000000..f95d636e81ea --- /dev/null +++ b/issues/aten_c_kernels/results/aten_host_softmax_cpu/debuf.mlir @@ -0,0 +1,50 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_host_softmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c63 = arith.constant 63 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %0) -> (tensor) { + %extracted = tensor.extract %1[%arg2, %c0] : tensor + %alloca = memref.alloca() : memref + %4 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %extracted into %4[] : tensor + %extracted_slice = tensor.extract_slice %1[%arg2, 1] [1, %c63] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %9 = arith.cmpf ogt, %in, %out : f32 + %10 = arith.select %9, %in, %out : f32 + linalg.yield %10 : f32 + } -> tensor + %extracted_0 = tensor.extract %5[] : tensor + %alloca_1 = memref.alloca() : memref + %6 = bufferization.to_tensor %alloca_1 : memref + %inserted_2 = tensor.insert %cst into %6[] : tensor + %extracted_slice_3 = tensor.extract_slice %1[%arg2, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %arg3[%arg2, 0] [1, %c64] [1, 1] : tensor to tensor + %7:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%extracted_slice_4, %inserted_2 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_6: f32): + %9 = arith.subf %in, %extracted_0 : f32 + %10 = math.exp %9 : f32 + %11 = arith.addf %out_6, %10 : f32 + linalg.yield %10, %11 : f32, f32 + } -> (tensor, tensor) + %extracted_5 = tensor.extract %7#1[] : tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%7#0 : tensor) { + ^bb0(%out: f32): + %9 = arith.divf %out, %extracted_5 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %8 into %arg3[%arg2, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_host_softmax_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_host_softmax_cpu/matched.mlir new file mode 100644 index 000000000000..54b4c78e66e1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_host_softmax_cpu/matched.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_host_softmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c63 = arith.constant 63 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %0) -> (tensor) { + %extracted = tensor.extract %1[%arg2, %c0] : tensor + %alloca = memref.alloca() : memref + %4 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %extracted into %4[] : tensor + %extracted_slice = tensor.extract_slice %1[%arg2, 1] [1, %c63] [1, 1] : tensor to tensor + %8 = kernel.launch @cudnnSoftmaxForwardOut_tensor(%extracted_slice_3, %extracted_slice_4) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %8 into %arg3[%arg2, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_host_softmax_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_host_softmax_cpu/orig.mlir new file mode 100644 index 000000000000..5a3258d76533 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_host_softmax_cpu/orig.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_host_softmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 32 { + %0 = affine.load %arg0[%arg2, 0] : memref + %1 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %0) -> (f32) { + %3 = affine.load %arg0[%arg2, %arg3] : memref + %4 = arith.cmpf ogt, %3, %arg4 : f32 + %5 = arith.select %4, %3, %arg4 : f32 + affine.yield %5 : f32 + } + %2 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %cst) -> (f32) { + %3 = affine.load %arg0[%arg2, %arg3] : memref + %4 = arith.subf %3, %1 : f32 + %5 = math.exp %4 : f32 + affine.store %5, %arg1[%arg2, %arg3] : memref + %6 = arith.addf %arg4, %5 : f32 + affine.yield %6 : f32 + } + affine.for %arg3 = 0 to 64 { + %3 = affine.load %arg1[%arg2, %arg3] : memref + %4 = arith.divf %3, %2 : f32 + affine.store %4, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_host_softmax_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_host_softmax_cpu/raised.mlir new file mode 100644 index 000000000000..00bec917071b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_host_softmax_cpu/raised.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_host_softmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c63 = arith.constant 63 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 32 { + %0 = affine.load %arg0[%arg2, 0] : memref + %alloca = memref.alloca() : memref + affine.store %0, %alloca[] : memref + %subview = memref.subview %arg0[%arg2, 1] [1, %c63] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %3 = arith.cmpf ogt, %in, %out : f32 + %4 = arith.select %3, %in, %out : f32 + linalg.yield %4 : f32 + } + %1 = affine.load %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %cst, %alloca_0[] : memref + %subview_1 = memref.subview %arg0[%arg2, 0] [1, %c64] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg1[%arg2, 0] [1, %c64] [1, 1] : memref to memref> + %subview_3 = memref.subview %alloca_0[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview_1 : memref>) outs(%subview_2, %subview_3 : memref>, memref>) { + ^bb0(%in: f32, %out: f32, %out_5: f32): + %3 = arith.subf %in, %1 : f32 + %4 = math.exp %3 : f32 + %5 = arith.addf %out_5, %4 : f32 + linalg.yield %4, %5 : f32, f32 + } + %2 = affine.load %alloca_0[] : memref + %subview_4 = memref.subview %arg1[%arg2, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview_4 : memref>) { + ^bb0(%out: f32): + %3 = arith.divf %out, %2 : f32 + linalg.yield %3 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_host_softmax_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_host_softmax_cpu_debuf.mlir new file mode 100644 index 000000000000..f95d636e81ea --- /dev/null +++ b/issues/aten_c_kernels/results/aten_host_softmax_cpu_debuf.mlir @@ -0,0 +1,50 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_host_softmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c63 = arith.constant 63 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %0) -> (tensor) { + %extracted = tensor.extract %1[%arg2, %c0] : tensor + %alloca = memref.alloca() : memref + %4 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %extracted into %4[] : tensor + %extracted_slice = tensor.extract_slice %1[%arg2, 1] [1, %c63] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %9 = arith.cmpf ogt, %in, %out : f32 + %10 = arith.select %9, %in, %out : f32 + linalg.yield %10 : f32 + } -> tensor + %extracted_0 = tensor.extract %5[] : tensor + %alloca_1 = memref.alloca() : memref + %6 = bufferization.to_tensor %alloca_1 : memref + %inserted_2 = tensor.insert %cst into %6[] : tensor + %extracted_slice_3 = tensor.extract_slice %1[%arg2, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %arg3[%arg2, 0] [1, %c64] [1, 1] : tensor to tensor + %7:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%extracted_slice_4, %inserted_2 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_6: f32): + %9 = arith.subf %in, %extracted_0 : f32 + %10 = math.exp %9 : f32 + %11 = arith.addf %out_6, %10 : f32 + linalg.yield %10, %11 : f32, f32 + } -> (tensor, tensor) + %extracted_5 = tensor.extract %7#1[] : tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%7#0 : tensor) { + ^bb0(%out: f32): + %9 = arith.divf %out, %extracted_5 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %8 into %arg3[%arg2, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_host_softmax_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_host_softmax_cpu_linalg.mlir new file mode 100644 index 000000000000..00bec917071b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_host_softmax_cpu_linalg.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_host_softmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c63 = arith.constant 63 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 32 { + %0 = affine.load %arg0[%arg2, 0] : memref + %alloca = memref.alloca() : memref + affine.store %0, %alloca[] : memref + %subview = memref.subview %arg0[%arg2, 1] [1, %c63] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %3 = arith.cmpf ogt, %in, %out : f32 + %4 = arith.select %3, %in, %out : f32 + linalg.yield %4 : f32 + } + %1 = affine.load %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %cst, %alloca_0[] : memref + %subview_1 = memref.subview %arg0[%arg2, 0] [1, %c64] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg1[%arg2, 0] [1, %c64] [1, 1] : memref to memref> + %subview_3 = memref.subview %alloca_0[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview_1 : memref>) outs(%subview_2, %subview_3 : memref>, memref>) { + ^bb0(%in: f32, %out: f32, %out_5: f32): + %3 = arith.subf %in, %1 : f32 + %4 = math.exp %3 : f32 + %5 = arith.addf %out_5, %4 : f32 + linalg.yield %4, %5 : f32, f32 + } + %2 = affine.load %alloca_0[] : memref + %subview_4 = memref.subview %arg1[%arg2, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview_4 : memref>) { + ^bb0(%out: f32): + %3 = arith.divf %out, %2 : f32 + linalg.yield %3 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hspmm_cpu.mlir b/issues/aten_c_kernels/results/aten_hspmm_cpu.mlir new file mode 100644 index 000000000000..c74ad3f0acee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hspmm_cpu.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hspmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + affine.for %arg6 = 0 to 48 { + affine.store %cst, %arg4[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 0 to 512 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg0[%arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg5] : memref + %3 = affine.load %arg1[%arg5] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg3[%4, %arg6] : memref + %6 = arith.mulf %2, %5 : f32 + %7 = memref.load %arg4[%1, %arg6] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg4[%1, %arg6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_hspmm_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_hspmm_cpu/debuf.mlir new file mode 100644 index 000000000000..459e7942079a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hspmm_cpu/debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hspmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c64, %c48] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %8 = affine.for %arg7 = 0 to 48 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %9 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg5] : tensor + %extracted_1 = tensor.extract %3[%arg5] : tensor + %10 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %1[%10, %arg7] : tensor + %11 = arith.mulf %extracted_0, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg8[%9, %arg7] : tensor + %12 = arith.addf %extracted_3, %11 : f32 + %inserted = tensor.insert %12 into %arg8[%9, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %8 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hspmm_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_hspmm_cpu/matched.mlir new file mode 100644 index 000000000000..753861c40a75 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hspmm_cpu/matched.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hspmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %5 = kernel.launch @memset_zero_2D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c64, %c48] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %8 = affine.for %arg7 = 0 to 48 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %9 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg5] : tensor + %extracted_1 = tensor.extract %3[%arg5] : tensor + %10 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %1[%10, %arg7] : tensor + %11 = arith.mulf %extracted_0, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg8[%9, %arg7] : tensor + %12 = arith.addf %extracted_3, %11 : f32 + %inserted = tensor.insert %12 into %arg8[%9, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %8 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hspmm_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_hspmm_cpu/orig.mlir new file mode 100644 index 000000000000..c74ad3f0acee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hspmm_cpu/orig.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hspmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + affine.for %arg6 = 0 to 48 { + affine.store %cst, %arg4[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 0 to 512 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg0[%arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg5] : memref + %3 = affine.load %arg1[%arg5] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg3[%4, %arg6] : memref + %6 = arith.mulf %2, %5 : f32 + %7 = memref.load %arg4[%1, %arg6] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg4[%1, %arg6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_hspmm_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_hspmm_cpu/raised.mlir new file mode 100644 index 000000000000..8541744987ea --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hspmm_cpu/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hspmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg4[0, 0] [%c64, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg5 = 0 to 512 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg0[%arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg5] : memref + %3 = affine.load %arg1[%arg5] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg3[%4, %arg6] : memref + %6 = arith.mulf %2, %5 : f32 + %7 = memref.load %arg4[%1, %arg6] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg4[%1, %arg6] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hspmm_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_hspmm_cpu_debuf.mlir new file mode 100644 index 000000000000..459e7942079a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hspmm_cpu_debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hspmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c64, %c48] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %8 = affine.for %arg7 = 0 to 48 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %9 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg5] : tensor + %extracted_1 = tensor.extract %3[%arg5] : tensor + %10 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %1[%10, %arg7] : tensor + %11 = arith.mulf %extracted_0, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg8[%9, %arg7] : tensor + %12 = arith.addf %extracted_3, %11 : f32 + %inserted = tensor.insert %12 into %arg8[%9, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %8 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hspmm_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_hspmm_cpu_linalg.mlir new file mode 100644 index 000000000000..8541744987ea --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hspmm_cpu_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hspmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg4[0, 0] [%c64, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg5 = 0 to 512 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg0[%arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg5] : memref + %3 = affine.load %arg1[%arg5] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg3[%4, %arg6] : memref + %6 = arith.mulf %2, %5 : f32 + %7 = memref.load %arg4[%1, %arg6] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg4[%1, %arg6] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_huber_backward.mlir b/issues/aten_c_kernels/results/aten_huber_backward.mlir new file mode 100644 index 000000000000..28907a945875 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_huber_backward.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_huber_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.negf %arg3 : f32 + %1 = arith.negf %arg2 : f32 + %2 = arith.mulf %1, %arg3 : f32 + %3 = arith.mulf %arg2, %arg3 : f32 + affine.for %arg5 = 0 to 4096 { + %4 = affine.load %arg0[%arg5] : memref + %5 = affine.load %arg1[%arg5] : memref + %6 = arith.subf %4, %5 : f32 + %7 = arith.cmpf olt, %6, %0 : f32 + %8 = scf.if %7 -> (f32) { + scf.yield %2 : f32 + } else { + %9 = arith.cmpf ogt, %6, %arg3 : f32 + %10 = scf.if %9 -> (f32) { + scf.yield %3 : f32 + } else { + %11 = arith.mulf %arg2, %6 : f32 + scf.yield %11 : f32 + } + scf.yield %10 : f32 + } + affine.store %8, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_huber_backward/debuf.mlir b/issues/aten_c_kernels/results/aten_huber_backward/debuf.mlir new file mode 100644 index 000000000000..387439fe609a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_huber_backward/debuf.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_huber_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = arith.negf %arg3 : f32 + %4 = arith.negf %arg2 : f32 + %5 = arith.mulf %4, %arg3 : f32 + %6 = arith.mulf %arg2, %arg3 : f32 + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %9 = arith.subf %in, %in_0 : f32 + %10 = arith.cmpf olt, %9, %3 : f32 + %11 = arith.cmpf ogt, %9, %arg3 : f32 + %12 = arith.mulf %arg2, %9 : f32 + %13 = arith.select %11, %6, %12 : f32 + %14 = arith.select %10, %5, %13 : f32 + linalg.yield %14 : f32 + } -> tensor + %8 = bufferization.to_memref %7 : memref + memref.copy %8, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_huber_backward/matched.mlir b/issues/aten_c_kernels/results/aten_huber_backward/matched.mlir new file mode 100644 index 000000000000..387439fe609a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_huber_backward/matched.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_huber_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = arith.negf %arg3 : f32 + %4 = arith.negf %arg2 : f32 + %5 = arith.mulf %4, %arg3 : f32 + %6 = arith.mulf %arg2, %arg3 : f32 + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %9 = arith.subf %in, %in_0 : f32 + %10 = arith.cmpf olt, %9, %3 : f32 + %11 = arith.cmpf ogt, %9, %arg3 : f32 + %12 = arith.mulf %arg2, %9 : f32 + %13 = arith.select %11, %6, %12 : f32 + %14 = arith.select %10, %5, %13 : f32 + linalg.yield %14 : f32 + } -> tensor + %8 = bufferization.to_memref %7 : memref + memref.copy %8, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_huber_backward/orig.mlir b/issues/aten_c_kernels/results/aten_huber_backward/orig.mlir new file mode 100644 index 000000000000..28907a945875 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_huber_backward/orig.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_huber_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.negf %arg3 : f32 + %1 = arith.negf %arg2 : f32 + %2 = arith.mulf %1, %arg3 : f32 + %3 = arith.mulf %arg2, %arg3 : f32 + affine.for %arg5 = 0 to 4096 { + %4 = affine.load %arg0[%arg5] : memref + %5 = affine.load %arg1[%arg5] : memref + %6 = arith.subf %4, %5 : f32 + %7 = arith.cmpf olt, %6, %0 : f32 + %8 = scf.if %7 -> (f32) { + scf.yield %2 : f32 + } else { + %9 = arith.cmpf ogt, %6, %arg3 : f32 + %10 = scf.if %9 -> (f32) { + scf.yield %3 : f32 + } else { + %11 = arith.mulf %arg2, %6 : f32 + scf.yield %11 : f32 + } + scf.yield %10 : f32 + } + affine.store %8, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_huber_backward/raised.mlir b/issues/aten_c_kernels/results/aten_huber_backward/raised.mlir new file mode 100644 index 000000000000..e560f6924349 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_huber_backward/raised.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_huber_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.negf %arg3 : f32 + %1 = arith.negf %arg2 : f32 + %2 = arith.mulf %1, %arg3 : f32 + %3 = arith.mulf %arg2, %arg3 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg4 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %4 = arith.subf %in, %in_0 : f32 + %5 = arith.cmpf olt, %4, %0 : f32 + %6 = arith.cmpf ogt, %4, %arg3 : f32 + %7 = arith.mulf %arg2, %4 : f32 + %8 = arith.select %6, %3, %7 : f32 + %9 = arith.select %5, %2, %8 : f32 + linalg.yield %9 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_huber_backward_debuf.mlir b/issues/aten_c_kernels/results/aten_huber_backward_debuf.mlir new file mode 100644 index 000000000000..387439fe609a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_huber_backward_debuf.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_huber_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = arith.negf %arg3 : f32 + %4 = arith.negf %arg2 : f32 + %5 = arith.mulf %4, %arg3 : f32 + %6 = arith.mulf %arg2, %arg3 : f32 + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %9 = arith.subf %in, %in_0 : f32 + %10 = arith.cmpf olt, %9, %3 : f32 + %11 = arith.cmpf ogt, %9, %arg3 : f32 + %12 = arith.mulf %arg2, %9 : f32 + %13 = arith.select %11, %6, %12 : f32 + %14 = arith.select %10, %5, %13 : f32 + linalg.yield %14 : f32 + } -> tensor + %8 = bufferization.to_memref %7 : memref + memref.copy %8, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_huber_backward_linalg.mlir b/issues/aten_c_kernels/results/aten_huber_backward_linalg.mlir new file mode 100644 index 000000000000..e560f6924349 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_huber_backward_linalg.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_huber_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.negf %arg3 : f32 + %1 = arith.negf %arg2 : f32 + %2 = arith.mulf %1, %arg3 : f32 + %3 = arith.mulf %arg2, %arg3 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg4 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %4 = arith.subf %in, %in_0 : f32 + %5 = arith.cmpf olt, %4, %0 : f32 + %6 = arith.cmpf ogt, %4, %arg3 : f32 + %7 = arith.mulf %arg2, %4 : f32 + %8 = arith.select %6, %3, %7 : f32 + %9 = arith.select %5, %2, %8 : f32 + linalg.yield %9 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_huber_elementwise.mlir b/issues/aten_c_kernels/results/aten_huber_elementwise.mlir new file mode 100644 index 000000000000..782b110119b3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_huber_elementwise.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_huber_elementwise(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %0 = arith.mulf %arg2, %cst : f32 + affine.for %arg4 = 0 to 4096 { + %1 = affine.load %arg0[%arg4] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.subf %1, %2 : f32 + %4 = arith.cmpf olt, %3, %cst_0 : f32 + %5 = scf.if %4 -> (f32) { + %8 = arith.negf %3 : f32 + scf.yield %8 : f32 + } else { + scf.yield %3 : f32 + } + %6 = arith.cmpf olt, %5, %arg2 : f32 + %7 = scf.if %6 -> (f32) { + %8 = arith.mulf %3, %cst : f32 + %9 = arith.mulf %8, %3 : f32 + scf.yield %9 : f32 + } else { + %8 = arith.subf %5, %0 : f32 + %9 = arith.mulf %arg2, %8 : f32 + scf.yield %9 : f32 + } + affine.store %7, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_huber_elementwise/debuf.mlir b/issues/aten_c_kernels/results/aten_huber_elementwise/debuf.mlir new file mode 100644 index 000000000000..6dbecf21b77c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_huber_elementwise/debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_huber_elementwise(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.mulf %arg2, %cst_0 : f32 + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %6 = arith.subf %in, %in_1 : f32 + %7 = arith.cmpf olt, %6, %cst : f32 + %8 = arith.negf %6 : f32 + %9 = arith.select %7, %8, %6 : f32 + %10 = arith.cmpf olt, %9, %arg2 : f32 + %11 = arith.mulf %6, %cst_0 : f32 + %12 = arith.mulf %11, %6 : f32 + %13 = arith.subf %9, %3 : f32 + %14 = arith.mulf %arg2, %13 : f32 + %15 = arith.select %10, %12, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_huber_elementwise/matched.mlir b/issues/aten_c_kernels/results/aten_huber_elementwise/matched.mlir new file mode 100644 index 000000000000..6dbecf21b77c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_huber_elementwise/matched.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_huber_elementwise(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.mulf %arg2, %cst_0 : f32 + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %6 = arith.subf %in, %in_1 : f32 + %7 = arith.cmpf olt, %6, %cst : f32 + %8 = arith.negf %6 : f32 + %9 = arith.select %7, %8, %6 : f32 + %10 = arith.cmpf olt, %9, %arg2 : f32 + %11 = arith.mulf %6, %cst_0 : f32 + %12 = arith.mulf %11, %6 : f32 + %13 = arith.subf %9, %3 : f32 + %14 = arith.mulf %arg2, %13 : f32 + %15 = arith.select %10, %12, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_huber_elementwise/orig.mlir b/issues/aten_c_kernels/results/aten_huber_elementwise/orig.mlir new file mode 100644 index 000000000000..782b110119b3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_huber_elementwise/orig.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_huber_elementwise(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %0 = arith.mulf %arg2, %cst : f32 + affine.for %arg4 = 0 to 4096 { + %1 = affine.load %arg0[%arg4] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.subf %1, %2 : f32 + %4 = arith.cmpf olt, %3, %cst_0 : f32 + %5 = scf.if %4 -> (f32) { + %8 = arith.negf %3 : f32 + scf.yield %8 : f32 + } else { + scf.yield %3 : f32 + } + %6 = arith.cmpf olt, %5, %arg2 : f32 + %7 = scf.if %6 -> (f32) { + %8 = arith.mulf %3, %cst : f32 + %9 = arith.mulf %8, %3 : f32 + scf.yield %9 : f32 + } else { + %8 = arith.subf %5, %0 : f32 + %9 = arith.mulf %arg2, %8 : f32 + scf.yield %9 : f32 + } + affine.store %7, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_huber_elementwise/raised.mlir b/issues/aten_c_kernels/results/aten_huber_elementwise/raised.mlir new file mode 100644 index 000000000000..eea3220b59ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_huber_elementwise/raised.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_huber_elementwise(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %0 = arith.mulf %arg2, %cst : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %1 = arith.subf %in, %in_1 : f32 + %2 = arith.cmpf olt, %1, %cst_0 : f32 + %3 = arith.negf %1 : f32 + %4 = arith.select %2, %3, %1 : f32 + %5 = arith.cmpf olt, %4, %arg2 : f32 + %6 = arith.mulf %1, %cst : f32 + %7 = arith.mulf %6, %1 : f32 + %8 = arith.subf %4, %0 : f32 + %9 = arith.mulf %arg2, %8 : f32 + %10 = arith.select %5, %7, %9 : f32 + linalg.yield %10 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_huber_elementwise_debuf.mlir b/issues/aten_c_kernels/results/aten_huber_elementwise_debuf.mlir new file mode 100644 index 000000000000..6dbecf21b77c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_huber_elementwise_debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_huber_elementwise(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.mulf %arg2, %cst_0 : f32 + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %6 = arith.subf %in, %in_1 : f32 + %7 = arith.cmpf olt, %6, %cst : f32 + %8 = arith.negf %6 : f32 + %9 = arith.select %7, %8, %6 : f32 + %10 = arith.cmpf olt, %9, %arg2 : f32 + %11 = arith.mulf %6, %cst_0 : f32 + %12 = arith.mulf %11, %6 : f32 + %13 = arith.subf %9, %3 : f32 + %14 = arith.mulf %arg2, %13 : f32 + %15 = arith.select %10, %12, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_huber_elementwise_linalg.mlir b/issues/aten_c_kernels/results/aten_huber_elementwise_linalg.mlir new file mode 100644 index 000000000000..eea3220b59ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_huber_elementwise_linalg.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_huber_elementwise(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %0 = arith.mulf %arg2, %cst : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %1 = arith.subf %in, %in_1 : f32 + %2 = arith.cmpf olt, %1, %cst_0 : f32 + %3 = arith.negf %1 : f32 + %4 = arith.select %2, %3, %1 : f32 + %5 = arith.cmpf olt, %4, %arg2 : f32 + %6 = arith.mulf %1, %cst : f32 + %7 = arith.mulf %6, %1 : f32 + %8 = arith.subf %4, %0 : f32 + %9 = arith.mulf %arg2, %8 : f32 + %10 = arith.select %5, %7, %9 : f32 + linalg.yield %10 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_hypot.mlir b/issues/aten_c_kernels/results/aten_hypot.mlir new file mode 100644 index 000000000000..974788209992 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hypot.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hypot(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @hypotf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @hypotf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_hypot/debuf.mlir b/issues/aten_c_kernels/results/aten_hypot/debuf.mlir new file mode 100644 index 000000000000..7d760ebba30d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hypot/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hypot(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @hypotf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @hypotf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_hypot/matched.mlir b/issues/aten_c_kernels/results/aten_hypot/matched.mlir new file mode 100644 index 000000000000..7d760ebba30d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hypot/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hypot(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @hypotf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @hypotf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_hypot/orig.mlir b/issues/aten_c_kernels/results/aten_hypot/orig.mlir new file mode 100644 index 000000000000..974788209992 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hypot/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hypot(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @hypotf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @hypotf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_hypot/raised.mlir b/issues/aten_c_kernels/results/aten_hypot/raised.mlir new file mode 100644 index 000000000000..f14c2b978b75 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hypot/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hypot(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @hypotf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @hypotf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_hypot_debuf.mlir b/issues/aten_c_kernels/results/aten_hypot_debuf.mlir new file mode 100644 index 000000000000..7d760ebba30d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hypot_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hypot(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @hypotf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @hypotf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_hypot_linalg.mlir b/issues/aten_c_kernels/results/aten_hypot_linalg.mlir new file mode 100644 index 000000000000..f14c2b978b75 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_hypot_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_hypot(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @hypotf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @hypotf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i0.mlir b/issues/aten_c_kernels/results/aten_i0.mlir new file mode 100644 index 000000000000..b4fc900b1553 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i0.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_i0f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_i0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_i0/debuf.mlir b/issues/aten_c_kernels/results/aten_i0/debuf.mlir new file mode 100644 index 000000000000..92bd965a2191 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i0/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_i0f(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_i0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i0/matched.mlir b/issues/aten_c_kernels/results/aten_i0/matched.mlir new file mode 100644 index 000000000000..92bd965a2191 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i0/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_i0f(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_i0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i0/orig.mlir b/issues/aten_c_kernels/results/aten_i0/orig.mlir new file mode 100644 index 000000000000..b4fc900b1553 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i0/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_i0f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_i0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_i0/raised.mlir b/issues/aten_c_kernels/results/aten_i0/raised.mlir new file mode 100644 index 000000000000..fe918de3ffd3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i0/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_i0f(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_i0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i0_debuf.mlir b/issues/aten_c_kernels/results/aten_i0_debuf.mlir new file mode 100644 index 000000000000..92bd965a2191 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i0_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_i0f(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_i0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i0_linalg.mlir b/issues/aten_c_kernels/results/aten_i0_linalg.mlir new file mode 100644 index 000000000000..fe918de3ffd3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i0_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_i0f(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_i0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i0e.mlir b/issues/aten_c_kernels/results/aten_i0e.mlir new file mode 100644 index 000000000000..21b086f3c259 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i0e.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i0e(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_i0ef(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_i0ef(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_i0e/debuf.mlir b/issues/aten_c_kernels/results/aten_i0e/debuf.mlir new file mode 100644 index 000000000000..64552532dd59 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i0e/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i0e(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_i0ef(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_i0ef(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i0e/matched.mlir b/issues/aten_c_kernels/results/aten_i0e/matched.mlir new file mode 100644 index 000000000000..64552532dd59 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i0e/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i0e(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_i0ef(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_i0ef(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i0e/orig.mlir b/issues/aten_c_kernels/results/aten_i0e/orig.mlir new file mode 100644 index 000000000000..21b086f3c259 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i0e/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i0e(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_i0ef(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_i0ef(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_i0e/raised.mlir b/issues/aten_c_kernels/results/aten_i0e/raised.mlir new file mode 100644 index 000000000000..bd6fa78d74ea --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i0e/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i0e(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_i0ef(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_i0ef(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i0e_debuf.mlir b/issues/aten_c_kernels/results/aten_i0e_debuf.mlir new file mode 100644 index 000000000000..64552532dd59 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i0e_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i0e(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_i0ef(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_i0ef(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i0e_linalg.mlir b/issues/aten_c_kernels/results/aten_i0e_linalg.mlir new file mode 100644 index 000000000000..bd6fa78d74ea --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i0e_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i0e(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_i0ef(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_i0ef(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i1.mlir b/issues/aten_c_kernels/results/aten_i1.mlir new file mode 100644 index 000000000000..2d39b77b9a37 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i1.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_i1f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_i1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_i1/debuf.mlir b/issues/aten_c_kernels/results/aten_i1/debuf.mlir new file mode 100644 index 000000000000..79e22943c23b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i1/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_i1f(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_i1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i1/matched.mlir b/issues/aten_c_kernels/results/aten_i1/matched.mlir new file mode 100644 index 000000000000..79e22943c23b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i1/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_i1f(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_i1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i1/orig.mlir b/issues/aten_c_kernels/results/aten_i1/orig.mlir new file mode 100644 index 000000000000..2d39b77b9a37 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i1/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_i1f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_i1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_i1/raised.mlir b/issues/aten_c_kernels/results/aten_i1/raised.mlir new file mode 100644 index 000000000000..f77abfb6b729 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i1/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_i1f(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_i1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i1_debuf.mlir b/issues/aten_c_kernels/results/aten_i1_debuf.mlir new file mode 100644 index 000000000000..79e22943c23b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i1_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_i1f(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_i1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i1_linalg.mlir b/issues/aten_c_kernels/results/aten_i1_linalg.mlir new file mode 100644 index 000000000000..f77abfb6b729 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i1_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_i1f(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_i1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i1e.mlir b/issues/aten_c_kernels/results/aten_i1e.mlir new file mode 100644 index 000000000000..b6d373966e4f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i1e.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i1e(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_i1ef(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_i1ef(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_i1e/debuf.mlir b/issues/aten_c_kernels/results/aten_i1e/debuf.mlir new file mode 100644 index 000000000000..9b9a740389c2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i1e/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i1e(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_i1ef(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_i1ef(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i1e/matched.mlir b/issues/aten_c_kernels/results/aten_i1e/matched.mlir new file mode 100644 index 000000000000..9b9a740389c2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i1e/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i1e(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_i1ef(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_i1ef(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i1e/orig.mlir b/issues/aten_c_kernels/results/aten_i1e/orig.mlir new file mode 100644 index 000000000000..b6d373966e4f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i1e/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i1e(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_i1ef(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_i1ef(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_i1e/raised.mlir b/issues/aten_c_kernels/results/aten_i1e/raised.mlir new file mode 100644 index 000000000000..ddef5e1e9fe2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i1e/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i1e(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_i1ef(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_i1ef(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i1e_debuf.mlir b/issues/aten_c_kernels/results/aten_i1e_debuf.mlir new file mode 100644 index 000000000000..9b9a740389c2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i1e_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i1e(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_i1ef(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_i1ef(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_i1e_linalg.mlir b/issues/aten_c_kernels/results/aten_i1e_linalg.mlir new file mode 100644 index 000000000000..ddef5e1e9fe2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_i1e_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_i1e(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_i1ef(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_i1ef(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_ifftshift_cpu.mlir b/issues/aten_c_kernels/results/aten_ifftshift_cpu.mlir new file mode 100644 index 000000000000..ae4b1e94e8eb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ifftshift_cpu.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ifftshift_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-129 = arith.constant -129 : index + %c-255 = arith.constant -255 : index + %c-1 = arith.constant -1 : index + %c128 = arith.constant 128 : index + %c0 = arith.constant 0 : index + %c255 = arith.constant 255 : index + affine.for %arg2 = 0 to 255 { + %0 = arith.addi %arg2, %c128 : index + %1 = arith.cmpi slt, %0, %c0 : index + %2 = arith.subi %c-129, %arg2 : index + %3 = arith.select %1, %2, %0 : index + %4 = arith.divsi %3, %c255 : index + %5 = arith.subi %c-1, %4 : index + %6 = arith.select %1, %5, %4 : index + %7 = arith.muli %6, %c-255 : index + %8 = arith.addi %arg2, %7 : index + %9 = arith.addi %8, %c128 : index + %10 = memref.load %arg0[%9] : memref + affine.store %10, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_ifftshift_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_ifftshift_cpu/debuf.mlir new file mode 100644 index 000000000000..69c0a09d1c10 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ifftshift_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ifftshift_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c128 = arith.constant 128 : index + %c-1 = arith.constant -1 : index + %c-255 = arith.constant -255 : index + %c-129 = arith.constant -129 : index + %c0 = arith.constant 0 : index + %c255 = arith.constant 255 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.addi %3, %c128 : index + %5 = arith.cmpi slt, %4, %c0 : index + %6 = arith.subi %c-129, %3 : index + %7 = arith.select %5, %6, %4 : index + %8 = arith.divsi %7, %c255 : index + %9 = arith.subi %c-1, %8 : index + %10 = arith.select %5, %9, %8 : index + %11 = arith.muli %10, %c-255 : index + %12 = arith.addi %3, %11 : index + %13 = arith.addi %12, %c128 : index + %14 = memref.load %arg0[%13] : memref + linalg.yield %14 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ifftshift_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_ifftshift_cpu/matched.mlir new file mode 100644 index 000000000000..69c0a09d1c10 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ifftshift_cpu/matched.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ifftshift_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c128 = arith.constant 128 : index + %c-1 = arith.constant -1 : index + %c-255 = arith.constant -255 : index + %c-129 = arith.constant -129 : index + %c0 = arith.constant 0 : index + %c255 = arith.constant 255 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.addi %3, %c128 : index + %5 = arith.cmpi slt, %4, %c0 : index + %6 = arith.subi %c-129, %3 : index + %7 = arith.select %5, %6, %4 : index + %8 = arith.divsi %7, %c255 : index + %9 = arith.subi %c-1, %8 : index + %10 = arith.select %5, %9, %8 : index + %11 = arith.muli %10, %c-255 : index + %12 = arith.addi %3, %11 : index + %13 = arith.addi %12, %c128 : index + %14 = memref.load %arg0[%13] : memref + linalg.yield %14 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ifftshift_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_ifftshift_cpu/orig.mlir new file mode 100644 index 000000000000..ae4b1e94e8eb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ifftshift_cpu/orig.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ifftshift_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-129 = arith.constant -129 : index + %c-255 = arith.constant -255 : index + %c-1 = arith.constant -1 : index + %c128 = arith.constant 128 : index + %c0 = arith.constant 0 : index + %c255 = arith.constant 255 : index + affine.for %arg2 = 0 to 255 { + %0 = arith.addi %arg2, %c128 : index + %1 = arith.cmpi slt, %0, %c0 : index + %2 = arith.subi %c-129, %arg2 : index + %3 = arith.select %1, %2, %0 : index + %4 = arith.divsi %3, %c255 : index + %5 = arith.subi %c-1, %4 : index + %6 = arith.select %1, %5, %4 : index + %7 = arith.muli %6, %c-255 : index + %8 = arith.addi %arg2, %7 : index + %9 = arith.addi %8, %c128 : index + %10 = memref.load %arg0[%9] : memref + affine.store %10, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_ifftshift_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_ifftshift_cpu/raised.mlir new file mode 100644 index 000000000000..d62df0d903a7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ifftshift_cpu/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ifftshift_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c255 = arith.constant 255 : index + %c0 = arith.constant 0 : index + %c-129 = arith.constant -129 : index + %c-255 = arith.constant -255 : index + %c-1 = arith.constant -1 : index + %c128 = arith.constant 128 : index + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = arith.addi %0, %c128 : index + %2 = arith.cmpi slt, %1, %c0 : index + %3 = arith.subi %c-129, %0 : index + %4 = arith.select %2, %3, %1 : index + %5 = arith.divsi %4, %c255 : index + %6 = arith.subi %c-1, %5 : index + %7 = arith.select %2, %6, %5 : index + %8 = arith.muli %7, %c-255 : index + %9 = arith.addi %0, %8 : index + %10 = arith.addi %9, %c128 : index + %11 = memref.load %arg0[%10] : memref + linalg.yield %11 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ifftshift_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_ifftshift_cpu_debuf.mlir new file mode 100644 index 000000000000..69c0a09d1c10 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ifftshift_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ifftshift_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c128 = arith.constant 128 : index + %c-1 = arith.constant -1 : index + %c-255 = arith.constant -255 : index + %c-129 = arith.constant -129 : index + %c0 = arith.constant 0 : index + %c255 = arith.constant 255 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.addi %3, %c128 : index + %5 = arith.cmpi slt, %4, %c0 : index + %6 = arith.subi %c-129, %3 : index + %7 = arith.select %5, %6, %4 : index + %8 = arith.divsi %7, %c255 : index + %9 = arith.subi %c-1, %8 : index + %10 = arith.select %5, %9, %8 : index + %11 = arith.muli %10, %c-255 : index + %12 = arith.addi %3, %11 : index + %13 = arith.addi %12, %c128 : index + %14 = memref.load %arg0[%13] : memref + linalg.yield %14 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ifftshift_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_ifftshift_cpu_linalg.mlir new file mode 100644 index 000000000000..d62df0d903a7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ifftshift_cpu_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ifftshift_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c255 = arith.constant 255 : index + %c0 = arith.constant 0 : index + %c-129 = arith.constant -129 : index + %c-255 = arith.constant -255 : index + %c-1 = arith.constant -1 : index + %c128 = arith.constant 128 : index + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = arith.addi %0, %c128 : index + %2 = arith.cmpi slt, %1, %c0 : index + %3 = arith.subi %c-129, %0 : index + %4 = arith.select %2, %3, %1 : index + %5 = arith.divsi %4, %c255 : index + %6 = arith.subi %c-1, %5 : index + %7 = arith.select %2, %6, %5 : index + %8 = arith.muli %7, %c-255 : index + %9 = arith.addi %0, %8 : index + %10 = arith.addi %9, %c128 : index + %11 = memref.load %arg0[%10] : memref + linalg.yield %11 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_igamma.mlir b/issues/aten_c_kernels/results/aten_igamma.mlir new file mode 100644 index 000000000000..9d2abb0badf1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_igamma.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_igamma(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_igammaf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_igammaf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_igamma/debuf.mlir b/issues/aten_c_kernels/results/aten_igamma/debuf.mlir new file mode 100644 index 000000000000..ecfcb54fb8a4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_igamma/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_igamma(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_igammaf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_igammaf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_igamma/matched.mlir b/issues/aten_c_kernels/results/aten_igamma/matched.mlir new file mode 100644 index 000000000000..ecfcb54fb8a4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_igamma/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_igamma(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_igammaf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_igammaf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_igamma/orig.mlir b/issues/aten_c_kernels/results/aten_igamma/orig.mlir new file mode 100644 index 000000000000..9d2abb0badf1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_igamma/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_igamma(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_igammaf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_igammaf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_igamma/raised.mlir b/issues/aten_c_kernels/results/aten_igamma/raised.mlir new file mode 100644 index 000000000000..12706330606b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_igamma/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_igamma(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_igammaf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_igammaf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_igamma_debuf.mlir b/issues/aten_c_kernels/results/aten_igamma_debuf.mlir new file mode 100644 index 000000000000..ecfcb54fb8a4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_igamma_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_igamma(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_igammaf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_igammaf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_igamma_linalg.mlir b/issues/aten_c_kernels/results/aten_igamma_linalg.mlir new file mode 100644 index 000000000000..12706330606b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_igamma_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_igamma(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_igammaf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_igammaf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_igammac.mlir b/issues/aten_c_kernels/results/aten_igammac.mlir new file mode 100644 index 000000000000..3d8c1aa3c7bc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_igammac.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_igammac(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_igammacf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_igammacf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_igammac/debuf.mlir b/issues/aten_c_kernels/results/aten_igammac/debuf.mlir new file mode 100644 index 000000000000..dd75af743391 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_igammac/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_igammac(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_igammacf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_igammacf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_igammac/matched.mlir b/issues/aten_c_kernels/results/aten_igammac/matched.mlir new file mode 100644 index 000000000000..dd75af743391 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_igammac/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_igammac(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_igammacf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_igammacf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_igammac/orig.mlir b/issues/aten_c_kernels/results/aten_igammac/orig.mlir new file mode 100644 index 000000000000..3d8c1aa3c7bc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_igammac/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_igammac(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_igammacf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_igammacf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_igammac/raised.mlir b/issues/aten_c_kernels/results/aten_igammac/raised.mlir new file mode 100644 index 000000000000..5dabdb99e62f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_igammac/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_igammac(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_igammacf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_igammacf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_igammac_debuf.mlir b/issues/aten_c_kernels/results/aten_igammac_debuf.mlir new file mode 100644 index 000000000000..dd75af743391 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_igammac_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_igammac(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_igammacf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_igammacf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_igammac_linalg.mlir b/issues/aten_c_kernels/results/aten_igammac_linalg.mlir new file mode 100644 index 000000000000..5dabdb99e62f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_igammac_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_igammac(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_igammacf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_igammacf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_im2col.mlir b/issues/aten_c_kernels/results/aten_im2col.mlir new file mode 100644 index 000000000000..15305409132d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_im2col.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_im2col(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 6 { + affine.for %arg7 = 0 to 6 { + %0 = affine.load %arg0[%arg2, %arg3, %arg6 + %arg4, %arg7 + %arg5] : memref + affine.store %0, %arg1[%arg2, %arg3, %arg4, %arg5, %arg6, %arg7] : memref + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_im2col/debuf.mlir b/issues/aten_c_kernels/results/aten_im2col/debuf.mlir new file mode 100644 index 000000000000..9d20cf77760e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_im2col/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2, d5 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_im2col(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c3, %c3, %c3, %c6, %c6) {map = #map} : (tensor, index, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_im2col/matched.mlir b/issues/aten_c_kernels/results/aten_im2col/matched.mlir new file mode 100644 index 000000000000..9d20cf77760e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_im2col/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2, d5 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_im2col(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c3, %c3, %c3, %c6, %c6) {map = #map} : (tensor, index, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_im2col/orig.mlir b/issues/aten_c_kernels/results/aten_im2col/orig.mlir new file mode 100644 index 000000000000..15305409132d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_im2col/orig.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_im2col(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 6 { + affine.for %arg7 = 0 to 6 { + %0 = affine.load %arg0[%arg2, %arg3, %arg6 + %arg4, %arg7 + %arg5] : memref + affine.store %0, %arg1[%arg2, %arg3, %arg4, %arg5, %arg6, %arg7] : memref + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_im2col/raised.mlir b/issues/aten_c_kernels/results/aten_im2col/raised.mlir new file mode 100644 index 000000000000..ff1ca8f2a49e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_im2col/raised.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2, d5 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_im2col(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %0 = polygeist.submap(%arg0, %c2, %c3, %c3, %c3, %c6, %c6) {map = #map} : (memref, index, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_im2col_debuf.mlir b/issues/aten_c_kernels/results/aten_im2col_debuf.mlir new file mode 100644 index 000000000000..9d20cf77760e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_im2col_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2, d5 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_im2col(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c3, %c3, %c3, %c6, %c6) {map = #map} : (tensor, index, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_im2col_linalg.mlir b/issues/aten_c_kernels/results/aten_im2col_linalg.mlir new file mode 100644 index 000000000000..ff1ca8f2a49e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_im2col_linalg.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2, d5 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_im2col(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %0 = polygeist.submap(%arg0, %c2, %c3, %c3, %c3, %c6, %c6) {map = #map} : (memref, index, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_copy_cpu.mlir b/issues/aten_c_kernels/results/aten_index_copy_cpu.mlir new file mode 100644 index 000000000000..4cc6e369e177 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_copy_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_copy_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + memref.store %2, %arg0[%1, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_copy_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_index_copy_cpu/debuf.mlir new file mode 100644 index 000000000000..c7550bde65ec --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_copy_cpu/debuf.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_copy_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3, %arg5] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%6, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_copy_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_index_copy_cpu/matched.mlir new file mode 100644 index 000000000000..c7550bde65ec --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_copy_cpu/matched.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_copy_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3, %arg5] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%6, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_copy_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_index_copy_cpu/orig.mlir new file mode 100644 index 000000000000..4cc6e369e177 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_copy_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_copy_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + memref.store %2, %arg0[%1, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_copy_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_index_copy_cpu/raised.mlir new file mode 100644 index 000000000000..c079f2cc62c2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_copy_cpu/raised.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_copy_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + memref.store %2, %arg0[%1, %arg4] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_copy_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_index_copy_cpu_debuf.mlir new file mode 100644 index 000000000000..c7550bde65ec --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_copy_cpu_debuf.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_copy_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3, %arg5] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%6, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_copy_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_index_copy_cpu_linalg.mlir new file mode 100644 index 000000000000..c079f2cc62c2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_copy_cpu_linalg.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_copy_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + memref.store %2, %arg0[%1, %arg4] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_cpu.mlir b/issues/aten_c_kernels/results/aten_index_cpu.mlir new file mode 100644 index 000000000000..4c93a741ffae --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1, %arg4] : memref + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_index_cpu/debuf.mlir new file mode 100644 index 000000000000..52b9f54248a9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_cpu/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%6, %4] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_index_cpu/matched.mlir new file mode 100644 index 000000000000..52b9f54248a9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_cpu/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%6, %4] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_index_cpu/orig.mlir new file mode 100644 index 000000000000..4c93a741ffae --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1, %arg4] : memref + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_index_cpu/raised.mlir new file mode 100644 index 000000000000..42ef1bf17c5d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_cpu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg2[0, 0] [%c32, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = memref.load %arg1[%0] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3, %1] : memref + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_index_cpu_debuf.mlir new file mode 100644 index 000000000000..52b9f54248a9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_cpu_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%6, %4] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c64] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_index_cpu_linalg.mlir new file mode 100644 index 000000000000..42ef1bf17c5d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_cpu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg2[0, 0] [%c32, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = memref.load %arg1[%0] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3, %1] : memref + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_fill_cpu.mlir b/issues/aten_c_kernels/results/aten_index_fill_cpu.mlir new file mode 100644 index 000000000000..0f9de55df216 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_fill_cpu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + memref.store %arg2, %arg0[%1, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_fill_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_index_fill_cpu/debuf.mlir new file mode 100644 index 000000000000..e07291bdd1cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_fill_cpu/debuf.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %1) -> (tensor) { + %4 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %0[%arg3] : tensor + %5 = arith.index_cast %extracted : i32 to index + %inserted = tensor.insert %arg2 into %arg6[%5, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_fill_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_index_fill_cpu/matched.mlir new file mode 100644 index 000000000000..e07291bdd1cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_fill_cpu/matched.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %1) -> (tensor) { + %4 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %0[%arg3] : tensor + %5 = arith.index_cast %extracted : i32 to index + %inserted = tensor.insert %arg2 into %arg6[%5, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_fill_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_index_fill_cpu/orig.mlir new file mode 100644 index 000000000000..0f9de55df216 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_fill_cpu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + memref.store %arg2, %arg0[%1, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_fill_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_index_fill_cpu/raised.mlir new file mode 100644 index 000000000000..d6fef3f16c48 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_fill_cpu/raised.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + memref.store %arg2, %arg0[%1, %arg4] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_fill_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_index_fill_cpu_debuf.mlir new file mode 100644 index 000000000000..e07291bdd1cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_fill_cpu_debuf.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %1) -> (tensor) { + %4 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %0[%arg3] : tensor + %5 = arith.index_cast %extracted : i32 to index + %inserted = tensor.insert %arg2 into %arg6[%5, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_fill_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_index_fill_cpu_linalg.mlir new file mode 100644 index 000000000000..d6fef3f16c48 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_fill_cpu_linalg.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + memref.store %arg2, %arg0[%1, %arg4] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_put_cpu.mlir b/issues/aten_c_kernels/results/aten_index_put_cpu.mlir new file mode 100644 index 000000000000..61a90438492c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_put_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_put_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg3, %c0_i32 : i32 + affine.for %arg4 = 0 to 32 { + scf.if %0 { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg4] : memref + %4 = memref.load %arg0[%2] : memref + %5 = arith.addf %4, %3 : f32 + memref.store %5, %arg0[%2] : memref + } else { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg4] : memref + memref.store %3, %arg0[%2] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_put_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_index_put_cpu/debuf.mlir new file mode 100644 index 000000000000..ac3b839021a8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_put_cpu/debuf.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_put_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = arith.cmpi ne, %arg3, %c0_i32 : i32 + %4 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %2) -> (tensor) { + %6 = scf.if %3 -> (tensor) { + %extracted = tensor.extract %1[%arg4] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg4] : tensor + %extracted_1 = tensor.extract %arg5[%7] : tensor + %8 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %8 into %arg5[%7] : tensor + scf.yield %inserted : tensor + } else { + %extracted = tensor.extract %1[%arg4] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg4] : tensor + %inserted = tensor.insert %extracted_0 into %arg5[%7] : tensor + scf.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_put_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_index_put_cpu/matched.mlir new file mode 100644 index 000000000000..ac3b839021a8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_put_cpu/matched.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_put_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = arith.cmpi ne, %arg3, %c0_i32 : i32 + %4 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %2) -> (tensor) { + %6 = scf.if %3 -> (tensor) { + %extracted = tensor.extract %1[%arg4] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg4] : tensor + %extracted_1 = tensor.extract %arg5[%7] : tensor + %8 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %8 into %arg5[%7] : tensor + scf.yield %inserted : tensor + } else { + %extracted = tensor.extract %1[%arg4] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg4] : tensor + %inserted = tensor.insert %extracted_0 into %arg5[%7] : tensor + scf.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_put_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_index_put_cpu/orig.mlir new file mode 100644 index 000000000000..61a90438492c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_put_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_put_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg3, %c0_i32 : i32 + affine.for %arg4 = 0 to 32 { + scf.if %0 { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg4] : memref + %4 = memref.load %arg0[%2] : memref + %5 = arith.addf %4, %3 : f32 + memref.store %5, %arg0[%2] : memref + } else { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg4] : memref + memref.store %3, %arg0[%2] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_put_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_index_put_cpu/raised.mlir new file mode 100644 index 000000000000..8d417e8b0f64 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_put_cpu/raised.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_put_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg3, %c0_i32 : i32 + affine.for %arg4 = 0 to 32 { + scf.if %0 { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg4] : memref + %4 = memref.load %arg0[%2] : memref + %5 = arith.addf %4, %3 : f32 + memref.store %5, %arg0[%2] : memref + } else { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg4] : memref + memref.store %3, %arg0[%2] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_put_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_index_put_cpu_debuf.mlir new file mode 100644 index 000000000000..ac3b839021a8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_put_cpu_debuf.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_put_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = arith.cmpi ne, %arg3, %c0_i32 : i32 + %4 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %2) -> (tensor) { + %6 = scf.if %3 -> (tensor) { + %extracted = tensor.extract %1[%arg4] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg4] : tensor + %extracted_1 = tensor.extract %arg5[%7] : tensor + %8 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %8 into %arg5[%7] : tensor + scf.yield %inserted : tensor + } else { + %extracted = tensor.extract %1[%arg4] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg4] : tensor + %inserted = tensor.insert %extracted_0 into %arg5[%7] : tensor + scf.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_put_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_index_put_cpu_linalg.mlir new file mode 100644 index 000000000000..8d417e8b0f64 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_put_cpu_linalg.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_put_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg3, %c0_i32 : i32 + affine.for %arg4 = 0 to 32 { + scf.if %0 { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg4] : memref + %4 = memref.load %arg0[%2] : memref + %5 = arith.addf %4, %3 : f32 + memref.store %5, %arg0[%2] : memref + } else { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg4] : memref + memref.store %3, %arg0[%2] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_put_impl_cpu.mlir b/issues/aten_c_kernels/results/aten_index_put_impl_cpu.mlir new file mode 100644 index 000000000000..a76fb9356936 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_put_impl_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_put_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3] : memref + memref.store %2, %arg0[%1] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_put_impl_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_index_put_impl_cpu/debuf.mlir new file mode 100644 index 000000000000..6baf0dddf404 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_put_impl_cpu/debuf.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_put_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 512 iter_args(%arg4 = %2) -> (tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %5 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3] : tensor + %inserted = tensor.insert %extracted_0 into %arg4[%5] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_put_impl_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_index_put_impl_cpu/matched.mlir new file mode 100644 index 000000000000..6baf0dddf404 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_put_impl_cpu/matched.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_put_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 512 iter_args(%arg4 = %2) -> (tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %5 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3] : tensor + %inserted = tensor.insert %extracted_0 into %arg4[%5] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_put_impl_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_index_put_impl_cpu/orig.mlir new file mode 100644 index 000000000000..a76fb9356936 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_put_impl_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_put_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3] : memref + memref.store %2, %arg0[%1] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_put_impl_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_index_put_impl_cpu/raised.mlir new file mode 100644 index 000000000000..477994e9f449 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_put_impl_cpu/raised.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_put_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3] : memref + memref.store %2, %arg0[%1] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_put_impl_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_index_put_impl_cpu_debuf.mlir new file mode 100644 index 000000000000..6baf0dddf404 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_put_impl_cpu_debuf.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_put_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 512 iter_args(%arg4 = %2) -> (tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %5 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3] : tensor + %inserted = tensor.insert %extracted_0 into %arg4[%5] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_put_impl_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_index_put_impl_cpu_linalg.mlir new file mode 100644 index 000000000000..477994e9f449 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_put_impl_cpu_linalg.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_put_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3] : memref + memref.store %2, %arg0[%1] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu.mlir b/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu.mlir new file mode 100644 index 000000000000..4a7e068300e1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_reduce_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + affine.store %cst, %arg2[%arg3] : memref + } + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3] : memref + %3 = memref.load %arg2[%1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg2[%1] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu/debuf.mlir new file mode 100644 index 000000000000..b26b9232452d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu/debuf.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_reduce_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = affine.for %arg3 = 0 to 512 iter_args(%arg4 = %3) -> (tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg3] : tensor + %extracted_1 = tensor.extract %arg4[%6] : tensor + %7 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %7 into %arg4[%6] : tensor + affine.yield %inserted : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu/matched.mlir new file mode 100644 index 000000000000..883d3f4c1daf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_reduce_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %4 = affine.for %arg3 = 0 to 512 iter_args(%arg4 = %3) -> (tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg3] : tensor + %extracted_1 = tensor.extract %arg4[%6] : tensor + %7 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %7 into %arg4[%6] : tensor + affine.yield %inserted : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu/orig.mlir new file mode 100644 index 000000000000..4a7e068300e1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_reduce_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + affine.store %cst, %arg2[%arg3] : memref + } + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3] : memref + %3 = memref.load %arg2[%1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg2[%1] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu/raised.mlir new file mode 100644 index 000000000000..3e5437947702 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_reduce_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3] : memref + %3 = memref.load %arg2[%1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg2[%1] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu_debuf.mlir new file mode 100644 index 000000000000..b26b9232452d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu_debuf.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_reduce_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = affine.for %arg3 = 0 to 512 iter_args(%arg4 = %3) -> (tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg3] : tensor + %extracted_1 = tensor.extract %arg4[%6] : tensor + %7 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %7 into %arg4[%6] : tensor + affine.yield %inserted : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu_linalg.mlir new file mode 100644 index 000000000000..3e5437947702 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_reduce_impl_cpu_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_reduce_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3] : memref + %3 = memref.load %arg2[%1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg2[%1] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_select_dim1_cpu.mlir b/issues/aten_c_kernels/results/aten_index_select_dim1_cpu.mlir new file mode 100644 index 000000000000..e855ac444f20 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_dim1_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_dim1_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 16 { + %0 = affine.load %arg1[%arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%arg3, %1] : memref + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_select_dim1_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_index_select_dim1_cpu/debuf.mlir new file mode 100644 index 000000000000..dd1495808cf8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_dim1_cpu/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_dim1_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c16] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%4] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%3, %6] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c16] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_select_dim1_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_index_select_dim1_cpu/matched.mlir new file mode 100644 index 000000000000..dd1495808cf8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_dim1_cpu/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_dim1_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c16] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%4] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%3, %6] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c16] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_select_dim1_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_index_select_dim1_cpu/orig.mlir new file mode 100644 index 000000000000..e855ac444f20 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_dim1_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_dim1_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 16 { + %0 = affine.load %arg1[%arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%arg3, %1] : memref + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_select_dim1_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_index_select_dim1_cpu/raised.mlir new file mode 100644 index 000000000000..fddaf7df5888 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_dim1_cpu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_dim1_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %subview = memref.subview %arg2[0, 0] [%c32, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = memref.load %arg1[%1] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%0, %3] : memref + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_select_dim1_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_index_select_dim1_cpu_debuf.mlir new file mode 100644 index 000000000000..dd1495808cf8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_dim1_cpu_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_dim1_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c16] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%4] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%3, %6] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c16] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_select_dim1_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_index_select_dim1_cpu_linalg.mlir new file mode 100644 index 000000000000..fddaf7df5888 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_dim1_cpu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_dim1_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %subview = memref.subview %arg2[0, 0] [%c32, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = memref.load %arg1[%1] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%0, %3] : memref + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_select_out_cpu.mlir b/issues/aten_c_kernels/results/aten_index_select_out_cpu.mlir new file mode 100644 index 000000000000..41dbb7563d68 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_out_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1, %arg4] : memref + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_select_out_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_index_select_out_cpu/debuf.mlir new file mode 100644 index 000000000000..eedd0361f105 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_out_cpu/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%6, %4] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_select_out_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_index_select_out_cpu/matched.mlir new file mode 100644 index 000000000000..eedd0361f105 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_out_cpu/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%6, %4] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_select_out_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_index_select_out_cpu/orig.mlir new file mode 100644 index 000000000000..41dbb7563d68 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_out_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1, %arg4] : memref + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_select_out_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_index_select_out_cpu/raised.mlir new file mode 100644 index 000000000000..e4d4d4090b32 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_out_cpu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg2[0, 0] [%c16, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = memref.load %arg1[%0] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3, %1] : memref + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_select_out_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_index_select_out_cpu_debuf.mlir new file mode 100644 index 000000000000..eedd0361f105 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_out_cpu_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%6, %4] : memref + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_select_out_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_index_select_out_cpu_linalg.mlir new file mode 100644 index 000000000000..e4d4d4090b32 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_out_cpu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg2[0, 0] [%c16, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = memref.load %arg1[%0] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3, %1] : memref + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_select_sparse_cpu.mlir b/issues/aten_c_kernels/results/aten_index_select_sparse_cpu.mlir new file mode 100644 index 000000000000..157a6f136ab7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_sparse_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 128 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1] : memref + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_select_sparse_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_index_select_sparse_cpu/debuf.mlir new file mode 100644 index 000000000000..995c1ea5b7d6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_sparse_cpu/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%5] : memref + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_select_sparse_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_index_select_sparse_cpu/matched.mlir new file mode 100644 index 000000000000..995c1ea5b7d6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_sparse_cpu/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%5] : memref + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_select_sparse_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_index_select_sparse_cpu/orig.mlir new file mode 100644 index 000000000000..157a6f136ab7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_sparse_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 128 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1] : memref + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_index_select_sparse_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_index_select_sparse_cpu/raised.mlir new file mode 100644 index 000000000000..2de8a1de2218 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_sparse_cpu/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg1[%0] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%2] : memref + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_select_sparse_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_index_select_sparse_cpu_debuf.mlir new file mode 100644 index 000000000000..995c1ea5b7d6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_sparse_cpu_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%5] : memref + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_index_select_sparse_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_index_select_sparse_cpu_linalg.mlir new file mode 100644 index 000000000000..2de8a1de2218 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_index_select_sparse_cpu_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_index_select_sparse_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg1[%0] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%2] : memref + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_int4pack_mm_cpu.mlir b/issues/aten_c_kernels/results/aten_int4pack_mm_cpu.mlir new file mode 100644 index 000000000000..920e0dd32299 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int4pack_mm_cpu.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int4pack_mm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c15_i32 = arith.constant 15 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + affine.for %arg5 = 0 to 32 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg3[%arg6] : memref + %1 = affine.load %arg2[%arg6] : memref + %2 = affine.for %arg7 = 0 to 64 iter_args(%arg8 = %cst) -> (f32) { + %3 = arith.index_cast %arg7 : index to i32 + %4 = arith.cmpi slt, %arg7, %c0 : index + %5 = arith.subi %c-1, %arg7 : index + %6 = arith.select %4, %5, %arg7 : index + %7 = arith.divsi %6, %c2 : index + %8 = arith.subi %c-1, %7 : index + %9 = arith.select %4, %8, %7 : index + %10 = memref.load %arg1[%arg6, %9] : memref + %11 = arith.extui %10 : i8 to i32 + %12 = arith.andi %3, %c1_i32 : i32 + %13 = arith.muli %12, %c4_i32 : i32 + %14 = arith.shrsi %11, %13 : i32 + %15 = arith.andi %14, %c15_i32 : i32 + %16 = affine.load %arg0[%arg5, %arg7] : memref + %17 = arith.sitofp %15 : i32 to f32 + %18 = arith.subf %17, %0 : f32 + %19 = arith.mulf %16, %18 : f32 + %20 = arith.mulf %19, %1 : f32 + %21 = arith.addf %arg8, %20 : f32 + affine.yield %21 : f32 + } + affine.store %2, %arg4[%arg5, %arg6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_int4pack_mm_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_int4pack_mm_cpu/debuf.mlir new file mode 100644 index 000000000000..c07196839067 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int4pack_mm_cpu/debuf.mlir @@ -0,0 +1,64 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int4pack_mm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c15_i32 = arith.constant 15 : i32 + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %2) -> (tensor) { + %extracted_slice = tensor.extract_slice %arg6[%arg5, 0] [1, %c48] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %arg6[%arg5, 0] [1, %c48] [1, 1] : tensor into tensor + %6 = polygeist.submap(%inserted_slice, %arg5, %c48, %c64) {map = #map1} : (tensor, index, index, index) -> tensor + %7 = polygeist.submap(%1, %c48) {map = #map} : (tensor, index) -> tensor + %8 = polygeist.submap(%7, %c48, %c64) {map = #map2} : (tensor, index, index) -> tensor + %9 = polygeist.submap(%0, %c48) {map = #map} : (tensor, index) -> tensor + %10 = polygeist.submap(%9, %c48, %c64) {map = #map2} : (tensor, index, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%10, %8 : tensor, tensor) outs(%6 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %13 = linalg.index 0 : index + %14 = linalg.index 1 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.cmpi slt, %14, %c0 : index + %17 = arith.subi %c-1, %14 : index + %18 = arith.select %16, %17, %14 : index + %19 = arith.divsi %18, %c2 : index + %20 = arith.subi %c-1, %19 : index + %21 = arith.select %16, %20, %19 : index + %22 = memref.load %arg1[%13, %21] : memref + %23 = arith.extui %22 : i8 to i32 + %24 = arith.andi %15, %c1_i32 : i32 + %25 = arith.muli %24, %c4_i32 : i32 + %26 = arith.shrsi %23, %25 : i32 + %27 = arith.andi %26, %c15_i32 : i32 + %28 = memref.load %arg0[%arg5, %14] : memref + %29 = arith.sitofp %27 : i32 to f32 + %30 = arith.subf %29, %in : f32 + %31 = arith.mulf %28, %30 : f32 + %32 = arith.mulf %31, %in_0 : f32 + %33 = arith.addf %out, %32 : f32 + linalg.yield %33 : f32 + } -> tensor + %12 = polygeist.submapInverse(%inserted_slice, %11, %arg5, %c48, %c64) {map = #map1} : (tensor, tensor, index, index, index) -> tensor + affine.yield %12 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_int4pack_mm_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_int4pack_mm_cpu/matched.mlir new file mode 100644 index 000000000000..2a15a5b130d1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int4pack_mm_cpu/matched.mlir @@ -0,0 +1,61 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int4pack_mm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c15_i32 = arith.constant 15 : i32 + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %2) -> (tensor) { + %extracted_slice = tensor.extract_slice %arg6[%arg5, 0] [1, %c48] [1, 1] : tensor to tensor + %5 = kernel.launch @memset_zero_1D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %5 into %arg6[%arg5, 0] [1, %c48] [1, 1] : tensor into tensor + %6 = polygeist.submap(%inserted_slice, %arg5, %c48, %c64) {map = #map1} : (tensor, index, index, index) -> tensor + %7 = polygeist.submap(%1, %c48) {map = #map} : (tensor, index) -> tensor + %8 = polygeist.submap(%7, %c48, %c64) {map = #map2} : (tensor, index, index) -> tensor + %9 = polygeist.submap(%0, %c48) {map = #map} : (tensor, index) -> tensor + %10 = polygeist.submap(%9, %c48, %c64) {map = #map2} : (tensor, index, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%10, %8 : tensor, tensor) outs(%6 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %13 = linalg.index 0 : index + %14 = linalg.index 1 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.cmpi slt, %14, %c0 : index + %17 = arith.subi %c-1, %14 : index + %18 = arith.select %16, %17, %14 : index + %19 = arith.divsi %18, %c2 : index + %20 = arith.subi %c-1, %19 : index + %21 = arith.select %16, %20, %19 : index + %22 = memref.load %arg1[%13, %21] : memref + %23 = arith.extui %22 : i8 to i32 + %24 = arith.andi %15, %c1_i32 : i32 + %25 = arith.muli %24, %c4_i32 : i32 + %26 = arith.shrsi %23, %25 : i32 + %27 = arith.andi %26, %c15_i32 : i32 + %28 = memref.load %arg0[%arg5, %14] : memref + %29 = arith.sitofp %27 : i32 to f32 + %30 = arith.subf %29, %in : f32 + %31 = arith.mulf %28, %30 : f32 + %32 = arith.mulf %31, %in_0 : f32 + %33 = arith.addf %out, %32 : f32 + linalg.yield %33 : f32 + } -> tensor + %12 = polygeist.submapInverse(%inserted_slice, %11, %arg5, %c48, %c64) {map = #map1} : (tensor, tensor, index, index, index) -> tensor + affine.yield %12 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_int4pack_mm_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_int4pack_mm_cpu/orig.mlir new file mode 100644 index 000000000000..920e0dd32299 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int4pack_mm_cpu/orig.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int4pack_mm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c15_i32 = arith.constant 15 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + affine.for %arg5 = 0 to 32 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg3[%arg6] : memref + %1 = affine.load %arg2[%arg6] : memref + %2 = affine.for %arg7 = 0 to 64 iter_args(%arg8 = %cst) -> (f32) { + %3 = arith.index_cast %arg7 : index to i32 + %4 = arith.cmpi slt, %arg7, %c0 : index + %5 = arith.subi %c-1, %arg7 : index + %6 = arith.select %4, %5, %arg7 : index + %7 = arith.divsi %6, %c2 : index + %8 = arith.subi %c-1, %7 : index + %9 = arith.select %4, %8, %7 : index + %10 = memref.load %arg1[%arg6, %9] : memref + %11 = arith.extui %10 : i8 to i32 + %12 = arith.andi %3, %c1_i32 : i32 + %13 = arith.muli %12, %c4_i32 : i32 + %14 = arith.shrsi %11, %13 : i32 + %15 = arith.andi %14, %c15_i32 : i32 + %16 = affine.load %arg0[%arg5, %arg7] : memref + %17 = arith.sitofp %15 : i32 to f32 + %18 = arith.subf %17, %0 : f32 + %19 = arith.mulf %16, %18 : f32 + %20 = arith.mulf %19, %1 : f32 + %21 = arith.addf %arg8, %20 : f32 + affine.yield %21 : f32 + } + affine.store %2, %arg4[%arg5, %arg6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_int4pack_mm_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_int4pack_mm_cpu/raised.mlir new file mode 100644 index 000000000000..bf4eb8ec0dab --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int4pack_mm_cpu/raised.mlir @@ -0,0 +1,56 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int4pack_mm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c15_i32 = arith.constant 15 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + affine.for %arg5 = 0 to 32 { + %subview = memref.subview %arg4[%arg5, 0] [1, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg4, %arg5, %c48, %c64) {map = #map1} : (memref, index, index, index) -> memref + %1 = polygeist.submap(%arg3, %c48) {map = #map} : (memref, index) -> memref + %2 = polygeist.submap(%1, %c48, %c64) {map = #map2} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg2, %c48) {map = #map} : (memref, index) -> memref + %4 = polygeist.submap(%3, %c48, %c64) {map = #map2} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"]} ins(%2, %4 : memref, memref) outs(%0 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = linalg.index 0 : index + %6 = linalg.index 1 : index + %7 = arith.index_cast %6 : index to i32 + %8 = arith.cmpi slt, %6, %c0 : index + %9 = arith.subi %c-1, %6 : index + %10 = arith.select %8, %9, %6 : index + %11 = arith.divsi %10, %c2 : index + %12 = arith.subi %c-1, %11 : index + %13 = arith.select %8, %12, %11 : index + %14 = memref.load %arg1[%5, %13] : memref + %15 = arith.extui %14 : i8 to i32 + %16 = arith.andi %7, %c1_i32 : i32 + %17 = arith.muli %16, %c4_i32 : i32 + %18 = arith.shrsi %15, %17 : i32 + %19 = arith.andi %18, %c15_i32 : i32 + %20 = memref.load %arg0[%arg5, %6] : memref + %21 = arith.sitofp %19 : i32 to f32 + %22 = arith.subf %21, %in : f32 + %23 = arith.mulf %20, %22 : f32 + %24 = arith.mulf %23, %in_0 : f32 + %25 = arith.addf %out, %24 : f32 + linalg.yield %25 : f32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_int4pack_mm_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_int4pack_mm_cpu_debuf.mlir new file mode 100644 index 000000000000..c07196839067 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int4pack_mm_cpu_debuf.mlir @@ -0,0 +1,64 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int4pack_mm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c15_i32 = arith.constant 15 : i32 + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %2) -> (tensor) { + %extracted_slice = tensor.extract_slice %arg6[%arg5, 0] [1, %c48] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %arg6[%arg5, 0] [1, %c48] [1, 1] : tensor into tensor + %6 = polygeist.submap(%inserted_slice, %arg5, %c48, %c64) {map = #map1} : (tensor, index, index, index) -> tensor + %7 = polygeist.submap(%1, %c48) {map = #map} : (tensor, index) -> tensor + %8 = polygeist.submap(%7, %c48, %c64) {map = #map2} : (tensor, index, index) -> tensor + %9 = polygeist.submap(%0, %c48) {map = #map} : (tensor, index) -> tensor + %10 = polygeist.submap(%9, %c48, %c64) {map = #map2} : (tensor, index, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%10, %8 : tensor, tensor) outs(%6 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %13 = linalg.index 0 : index + %14 = linalg.index 1 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.cmpi slt, %14, %c0 : index + %17 = arith.subi %c-1, %14 : index + %18 = arith.select %16, %17, %14 : index + %19 = arith.divsi %18, %c2 : index + %20 = arith.subi %c-1, %19 : index + %21 = arith.select %16, %20, %19 : index + %22 = memref.load %arg1[%13, %21] : memref + %23 = arith.extui %22 : i8 to i32 + %24 = arith.andi %15, %c1_i32 : i32 + %25 = arith.muli %24, %c4_i32 : i32 + %26 = arith.shrsi %23, %25 : i32 + %27 = arith.andi %26, %c15_i32 : i32 + %28 = memref.load %arg0[%arg5, %14] : memref + %29 = arith.sitofp %27 : i32 to f32 + %30 = arith.subf %29, %in : f32 + %31 = arith.mulf %28, %30 : f32 + %32 = arith.mulf %31, %in_0 : f32 + %33 = arith.addf %out, %32 : f32 + linalg.yield %33 : f32 + } -> tensor + %12 = polygeist.submapInverse(%inserted_slice, %11, %arg5, %c48, %c64) {map = #map1} : (tensor, tensor, index, index, index) -> tensor + affine.yield %12 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_int4pack_mm_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_int4pack_mm_cpu_linalg.mlir new file mode 100644 index 000000000000..bf4eb8ec0dab --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int4pack_mm_cpu_linalg.mlir @@ -0,0 +1,56 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int4pack_mm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c15_i32 = arith.constant 15 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + affine.for %arg5 = 0 to 32 { + %subview = memref.subview %arg4[%arg5, 0] [1, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg4, %arg5, %c48, %c64) {map = #map1} : (memref, index, index, index) -> memref + %1 = polygeist.submap(%arg3, %c48) {map = #map} : (memref, index) -> memref + %2 = polygeist.submap(%1, %c48, %c64) {map = #map2} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg2, %c48) {map = #map} : (memref, index) -> memref + %4 = polygeist.submap(%3, %c48, %c64) {map = #map2} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"]} ins(%2, %4 : memref, memref) outs(%0 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = linalg.index 0 : index + %6 = linalg.index 1 : index + %7 = arith.index_cast %6 : index to i32 + %8 = arith.cmpi slt, %6, %c0 : index + %9 = arith.subi %c-1, %6 : index + %10 = arith.select %8, %9, %6 : index + %11 = arith.divsi %10, %c2 : index + %12 = arith.subi %c-1, %11 : index + %13 = arith.select %8, %12, %11 : index + %14 = memref.load %arg1[%5, %13] : memref + %15 = arith.extui %14 : i8 to i32 + %16 = arith.andi %7, %c1_i32 : i32 + %17 = arith.muli %16, %c4_i32 : i32 + %18 = arith.shrsi %15, %17 : i32 + %19 = arith.andi %18, %c15_i32 : i32 + %20 = memref.load %arg0[%arg5, %6] : memref + %21 = arith.sitofp %19 : i32 to f32 + %22 = arith.subf %21, %in : f32 + %23 = arith.mulf %20, %22 : f32 + %24 = arith.mulf %23, %in_0 : f32 + %25 = arith.addf %out, %24 : f32 + linalg.yield %25 : f32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_int8pack_mm_cpu.mlir b/issues/aten_c_kernels/results/aten_int8pack_mm_cpu.mlir new file mode 100644 index 000000000000..442b56642a42 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int8pack_mm_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int8pack_mm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 48 { + affine.store %cst, %arg3[%arg4, %arg5] : memref + affine.for %arg6 = 0 to 64 { + %0 = affine.load %arg0[%arg4, %arg6] : memref + %1 = affine.load %arg1[%arg5, %arg6] : memref + %2 = arith.sitofp %1 : i8 to f32 + %3 = arith.mulf %0, %2 : f32 + %4 = affine.load %arg2[%arg5] : memref + %5 = arith.mulf %3, %4 : f32 + %6 = affine.load %arg3[%arg4, %arg5] : memref + %7 = arith.addf %6, %5 : f32 + affine.store %7, %arg3[%arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_int8pack_mm_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_int8pack_mm_cpu/debuf.mlir new file mode 100644 index 000000000000..3c4391cee0a2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int8pack_mm_cpu/debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map3 = affine_map<(d0, d1, d2) -> (d1)> +#map4 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int8pack_mm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %3[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c48, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %2[0] [%c48] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1, %extracted_slice_2 : tensor, tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_3: i8, %in_4: f32, %out: f32): + %7 = arith.sitofp %in_3 : i8 to f32 + %8 = arith.mulf %in, %7 : f32 + %9 = arith.mulf %8, %in_4 : f32 + %10 = arith.addf %out, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %3[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_int8pack_mm_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_int8pack_mm_cpu/matched.mlir new file mode 100644 index 000000000000..8dc5bcfc7b58 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int8pack_mm_cpu/matched.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map3 = affine_map<(d0, d1, d2) -> (d1)> +#map4 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int8pack_mm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %3[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %4 = kernel.launch @memset_zero_2D_f32(%extracted_slice) : (tensor) -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c48, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %2[0] [%c48] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1, %extracted_slice_2 : tensor, tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_3: i8, %in_4: f32, %out: f32): + %7 = arith.sitofp %in_3 : i8 to f32 + %8 = arith.mulf %in, %7 : f32 + %9 = arith.mulf %8, %in_4 : f32 + %10 = arith.addf %out, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %3[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_int8pack_mm_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_int8pack_mm_cpu/orig.mlir new file mode 100644 index 000000000000..442b56642a42 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int8pack_mm_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int8pack_mm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 48 { + affine.store %cst, %arg3[%arg4, %arg5] : memref + affine.for %arg6 = 0 to 64 { + %0 = affine.load %arg0[%arg4, %arg6] : memref + %1 = affine.load %arg1[%arg5, %arg6] : memref + %2 = arith.sitofp %1 : i8 to f32 + %3 = arith.mulf %0, %2 : f32 + %4 = affine.load %arg2[%arg5] : memref + %5 = arith.mulf %3, %4 : f32 + %6 = affine.load %arg3[%arg4, %arg5] : memref + %7 = arith.addf %6, %5 : f32 + affine.store %7, %arg3[%arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_int8pack_mm_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_int8pack_mm_cpu/raised.mlir new file mode 100644 index 000000000000..214040a5f8c8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int8pack_mm_cpu/raised.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map3 = affine_map<(d0, d1, d2) -> (d1)> +#map4 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int8pack_mm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg3[0, 0] [%c32, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0] [%c48, %c64] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0] [%c48] [1] : memref to memref> + %subview_3 = memref.subview %arg3[0, 0] [%c32, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1, %subview_2 : memref>, memref>, memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f32, %in_4: i8, %in_5: f32, %out: f32): + %0 = arith.sitofp %in_4 : i8 to f32 + %1 = arith.mulf %in, %0 : f32 + %2 = arith.mulf %1, %in_5 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_int8pack_mm_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_int8pack_mm_cpu_debuf.mlir new file mode 100644 index 000000000000..3c4391cee0a2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int8pack_mm_cpu_debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map3 = affine_map<(d0, d1, d2) -> (d1)> +#map4 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int8pack_mm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %3[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c48, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %2[0] [%c48] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1, %extracted_slice_2 : tensor, tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_3: i8, %in_4: f32, %out: f32): + %7 = arith.sitofp %in_3 : i8 to f32 + %8 = arith.mulf %in, %7 : f32 + %9 = arith.mulf %8, %in_4 : f32 + %10 = arith.addf %out, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %3[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_int8pack_mm_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_int8pack_mm_cpu_linalg.mlir new file mode 100644 index 000000000000..214040a5f8c8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int8pack_mm_cpu_linalg.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map3 = affine_map<(d0, d1, d2) -> (d1)> +#map4 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int8pack_mm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg3[0, 0] [%c32, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0] [%c48, %c64] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0] [%c48] [1] : memref to memref> + %subview_3 = memref.subview %arg3[0, 0] [%c32, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1, %subview_2 : memref>, memref>, memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f32, %in_4: i8, %in_5: f32, %out: f32): + %0 = arith.sitofp %in_4 : i8 to f32 + %1 = arith.mulf %in, %0 : f32 + %2 = arith.mulf %1, %in_5 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_int_mm_out_cpu.mlir b/issues/aten_c_kernels/results/aten_int_mm_out_cpu.mlir new file mode 100644 index 000000000000..0ef0d0812394 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int_mm_out_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int_mm_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 48 { + %0 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %c0_i32) -> (i32) { + %1 = affine.load %arg0[%arg3, %arg5] : memref + %2 = arith.extsi %1 : i8 to i32 + %3 = affine.load %arg1[%arg5, %arg4] : memref + %4 = arith.extsi %3 : i8 to i32 + %5 = arith.muli %2, %4 : i32 + %6 = arith.addi %arg6, %5 : i32 + affine.yield %6 : i32 + } + affine.store %0, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_int_mm_out_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_int_mm_out_cpu/debuf.mlir new file mode 100644 index 000000000000..8a7a413c3619 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int_mm_out_cpu/debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int_mm_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: i8, %in_2: i8, %out: i32): + %6 = arith.extsi %in : i8 to i32 + %7 = arith.extsi %in_2 : i8 to i32 + %8 = arith.muli %6, %7 : i32 + %9 = arith.addi %out, %8 : i32 + linalg.yield %9 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_int_mm_out_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_int_mm_out_cpu/matched.mlir new file mode 100644 index 000000000000..8a7a413c3619 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int_mm_out_cpu/matched.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int_mm_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: i8, %in_2: i8, %out: i32): + %6 = arith.extsi %in : i8 to i32 + %7 = arith.extsi %in_2 : i8 to i32 + %8 = arith.muli %6, %7 : i32 + %9 = arith.addi %out, %8 : i32 + linalg.yield %9 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_int_mm_out_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_int_mm_out_cpu/orig.mlir new file mode 100644 index 000000000000..0ef0d0812394 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int_mm_out_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int_mm_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 48 { + %0 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %c0_i32) -> (i32) { + %1 = affine.load %arg0[%arg3, %arg5] : memref + %2 = arith.extsi %1 : i8 to i32 + %3 = affine.load %arg1[%arg5, %arg4] : memref + %4 = arith.extsi %3 : i8 to i32 + %5 = arith.muli %2, %4 : i32 + %6 = arith.addi %arg6, %5 : i32 + affine.yield %6 : i32 + } + affine.store %0, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_int_mm_out_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_int_mm_out_cpu/raised.mlir new file mode 100644 index 000000000000..e3a605469404 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int_mm_out_cpu/raised.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int_mm_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg2[0, 0] [%c32, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview_0 = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0] [%c64, %c48] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0] [%c32, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: i8, %in_3: i8, %out: i32): + %0 = arith.extsi %in : i8 to i32 + %1 = arith.extsi %in_3 : i8 to i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.addi %out, %2 : i32 + linalg.yield %3 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_int_mm_out_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_int_mm_out_cpu_debuf.mlir new file mode 100644 index 000000000000..8a7a413c3619 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int_mm_out_cpu_debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int_mm_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c32, %c48] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: i8, %in_2: i8, %out: i32): + %6 = arith.extsi %in : i8 to i32 + %7 = arith.extsi %in_2 : i8 to i32 + %8 = arith.muli %6, %7 : i32 + %9 = arith.addi %out, %8 : i32 + linalg.yield %9 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0] [%c32, %c48] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_int_mm_out_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_int_mm_out_cpu_linalg.mlir new file mode 100644 index 000000000000..e3a605469404 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_int_mm_out_cpu_linalg.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_int_mm_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg2[0, 0] [%c32, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview_0 = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0] [%c64, %c48] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0] [%c32, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: i8, %in_3: i8, %out: i32): + %0 = arith.extsi %in : i8 to i32 + %1 = arith.extsi %in_3 : i8 to i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.addi %out, %2 : i32 + linalg.yield %3 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_isin_default_cpu.mlir b/issues/aten_c_kernels/results/aten_isin_default_cpu.mlir new file mode 100644 index 000000000000..206277e4287b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isin_default_cpu.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isin_default_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = llvm.mlir.undef : i32 + %alloca = memref.alloca() : memref + affine.store %0, %alloca[] : memref + affine.for %arg3 = 0 to 4096 { + affine.store %c0_i32, %alloca[] : memref + %1 = affine.load %arg0[%arg3] : memref + affine.for %arg4 = 0 to 257 { + %3 = affine.load %arg1[%arg4] : memref + %4 = arith.cmpf oeq, %1, %3 : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = affine.load %alloca[] : memref + %7 = arith.ori %6, %5 : i32 + affine.store %7, %alloca[] : memref + } + %2 = affine.load %alloca[] : memref + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_isin_default_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_isin_default_cpu/debuf.mlir new file mode 100644 index 000000000000..e486b100de6f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isin_default_cpu/debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isin_default_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c257 = arith.constant 257 : index + %c4096 = arith.constant 4096 : index + %0 = bufferization.to_tensor %arg2 : memref + %alloca = memref.alloca(%c4096) : memref + %1 = bufferization.to_tensor %alloca : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %alloca : memref to memref + %subview = memref.subview %arg1[0] [%c257] [1] : memref to memref> + %4 = polygeist.submap(%arg0, %c4096) {map = #map} : (memref, index) -> memref + %subview_0 = memref.subview %4[0] [%c4096] [1] : memref to memref> + %subview_1 = memref.subview %alloca[0] [%c4096] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "reduction"]} ins(%subview_0, %subview : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: i32): + %7 = arith.cmpf oeq, %in, %in_2 : f32 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.ori %out, %8 : i32 + linalg.yield %9 : i32 + } + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%2 : tensor) outs(%0 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_isin_default_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_isin_default_cpu/matched.mlir new file mode 100644 index 000000000000..51df9f5f3f71 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isin_default_cpu/matched.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isin_default_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c257 = arith.constant 257 : index + %c4096 = arith.constant 4096 : index + %0 = bufferization.to_tensor %arg2 : memref + %alloca = memref.alloca(%c4096) : memref + %1 = bufferization.to_tensor %alloca : memref + %2 = kernel.launch @memset_zero_1D(%1) : (tensor) -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %alloca : memref to memref + %subview = memref.subview %arg1[0] [%c257] [1] : memref to memref> + %4 = polygeist.submap(%arg0, %c4096) {map = #map} : (memref, index) -> memref + %subview_0 = memref.subview %4[0] [%c4096] [1] : memref to memref> + %subview_1 = memref.subview %alloca[0] [%c4096] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "reduction"]} ins(%subview_0, %subview : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: i32): + %7 = arith.cmpf oeq, %in, %in_2 : f32 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.ori %out, %8 : i32 + linalg.yield %9 : i32 + } + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%2 : tensor) outs(%0 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_isin_default_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_isin_default_cpu/orig.mlir new file mode 100644 index 000000000000..206277e4287b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isin_default_cpu/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isin_default_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = llvm.mlir.undef : i32 + %alloca = memref.alloca() : memref + affine.store %0, %alloca[] : memref + affine.for %arg3 = 0 to 4096 { + affine.store %c0_i32, %alloca[] : memref + %1 = affine.load %arg0[%arg3] : memref + affine.for %arg4 = 0 to 257 { + %3 = affine.load %arg1[%arg4] : memref + %4 = arith.cmpf oeq, %1, %3 : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = affine.load %alloca[] : memref + %7 = arith.ori %6, %5 : i32 + affine.store %7, %alloca[] : memref + } + %2 = affine.load %alloca[] : memref + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_isin_default_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_isin_default_cpu/raised.mlir new file mode 100644 index 000000000000..d40f7716b36c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isin_default_cpu/raised.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isin_default_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4096 = arith.constant 4096 : index + %c257 = arith.constant 257 : index + %c0_i32 = arith.constant 0 : i32 + %0 = llvm.mlir.undef : i32 + %alloca = memref.alloca() : memref + affine.store %0, %alloca[] : memref + %alloca_0 = memref.alloca(%c4096) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_0 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg1[0] [%c257] [1] : memref to memref> + %1 = polygeist.submap(%arg0, %c4096) {map = #map} : (memref, index) -> memref + %subview_1 = memref.subview %1[0] [%c4096] [1] : memref to memref> + %subview_2 = memref.subview %alloca_0[0] [%c4096] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "reduction"]} ins(%subview_1, %subview : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: i32): + %2 = arith.cmpf oeq, %in, %in_3 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.ori %out, %3 : i32 + linalg.yield %4 : i32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca_0 : memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_isin_default_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_isin_default_cpu_debuf.mlir new file mode 100644 index 000000000000..e486b100de6f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isin_default_cpu_debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isin_default_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c257 = arith.constant 257 : index + %c4096 = arith.constant 4096 : index + %0 = bufferization.to_tensor %arg2 : memref + %alloca = memref.alloca(%c4096) : memref + %1 = bufferization.to_tensor %alloca : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %alloca : memref to memref + %subview = memref.subview %arg1[0] [%c257] [1] : memref to memref> + %4 = polygeist.submap(%arg0, %c4096) {map = #map} : (memref, index) -> memref + %subview_0 = memref.subview %4[0] [%c4096] [1] : memref to memref> + %subview_1 = memref.subview %alloca[0] [%c4096] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "reduction"]} ins(%subview_0, %subview : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: i32): + %7 = arith.cmpf oeq, %in, %in_2 : f32 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.ori %out, %8 : i32 + linalg.yield %9 : i32 + } + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%2 : tensor) outs(%0 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_isin_default_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_isin_default_cpu_linalg.mlir new file mode 100644 index 000000000000..d40f7716b36c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isin_default_cpu_linalg.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isin_default_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4096 = arith.constant 4096 : index + %c257 = arith.constant 257 : index + %c0_i32 = arith.constant 0 : i32 + %0 = llvm.mlir.undef : i32 + %alloca = memref.alloca() : memref + affine.store %0, %alloca[] : memref + %alloca_0 = memref.alloca(%c4096) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_0 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg1[0] [%c257] [1] : memref to memref> + %1 = polygeist.submap(%arg0, %c4096) {map = #map} : (memref, index) -> memref + %subview_1 = memref.subview %1[0] [%c4096] [1] : memref to memref> + %subview_2 = memref.subview %alloca_0[0] [%c4096] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "reduction"]} ins(%subview_1, %subview : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: i32): + %2 = arith.cmpf oeq, %in, %in_3 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.ori %out, %3 : i32 + linalg.yield %4 : i32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca_0 : memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_isneginf.mlir b/issues/aten_c_kernels/results/aten_isneginf.mlir new file mode 100644 index 000000000000..4972f2ba3290 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isneginf.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isneginf(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.negf %arg1 : f32 + affine.for %arg3 = 0 to 4096 { + %1 = affine.load %arg0[%arg3] : memref + %2 = arith.cmpf olt, %1, %0 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_isneginf/debuf.mlir b/issues/aten_c_kernels/results/aten_isneginf/debuf.mlir new file mode 100644 index 000000000000..7fc327a6817a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isneginf/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isneginf(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.negf %arg1 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %2 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_isneginf/matched.mlir b/issues/aten_c_kernels/results/aten_isneginf/matched.mlir new file mode 100644 index 000000000000..7fc327a6817a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isneginf/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isneginf(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.negf %arg1 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %2 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_isneginf/orig.mlir b/issues/aten_c_kernels/results/aten_isneginf/orig.mlir new file mode 100644 index 000000000000..4972f2ba3290 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isneginf/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isneginf(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.negf %arg1 : f32 + affine.for %arg3 = 0 to 4096 { + %1 = affine.load %arg0[%arg3] : memref + %2 = arith.cmpf olt, %1, %0 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_isneginf/raised.mlir b/issues/aten_c_kernels/results/aten_isneginf/raised.mlir new file mode 100644 index 000000000000..35ddac54a783 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isneginf/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isneginf(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.negf %arg1 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.cmpf olt, %in, %0 : f32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.sitofp %2 : i32 to f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_isneginf_debuf.mlir b/issues/aten_c_kernels/results/aten_isneginf_debuf.mlir new file mode 100644 index 000000000000..7fc327a6817a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isneginf_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isneginf(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.negf %arg1 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %2 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_isneginf_linalg.mlir b/issues/aten_c_kernels/results/aten_isneginf_linalg.mlir new file mode 100644 index 000000000000..35ddac54a783 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isneginf_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isneginf(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.negf %arg1 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.cmpf olt, %in, %0 : f32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.sitofp %2 : i32 to f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_isposinf.mlir b/issues/aten_c_kernels/results/aten_isposinf.mlir new file mode 100644 index 000000000000..616e379f8b0b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isposinf.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isposinf(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf ogt, %0, %arg1 : f32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.sitofp %2 : i32 to f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_isposinf/debuf.mlir b/issues/aten_c_kernels/results/aten_isposinf/debuf.mlir new file mode 100644 index 000000000000..c46a679dc0cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isposinf/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isposinf(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %arg1 : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.sitofp %5 : i32 to f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_isposinf/matched.mlir b/issues/aten_c_kernels/results/aten_isposinf/matched.mlir new file mode 100644 index 000000000000..c46a679dc0cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isposinf/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isposinf(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %arg1 : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.sitofp %5 : i32 to f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_isposinf/orig.mlir b/issues/aten_c_kernels/results/aten_isposinf/orig.mlir new file mode 100644 index 000000000000..616e379f8b0b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isposinf/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isposinf(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf ogt, %0, %arg1 : f32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.sitofp %2 : i32 to f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_isposinf/raised.mlir b/issues/aten_c_kernels/results/aten_isposinf/raised.mlir new file mode 100644 index 000000000000..01012e34195c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isposinf/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isposinf(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %arg1 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_isposinf_debuf.mlir b/issues/aten_c_kernels/results/aten_isposinf_debuf.mlir new file mode 100644 index 000000000000..c46a679dc0cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isposinf_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isposinf(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %arg1 : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.sitofp %5 : i32 to f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_isposinf_linalg.mlir b/issues/aten_c_kernels/results/aten_isposinf_linalg.mlir new file mode 100644 index 000000000000..01012e34195c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_isposinf_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_isposinf(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %arg1 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu.mlir b/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu.mlir new file mode 100644 index 000000000000..a29f0c996995 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_jagged_to_padded_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 64 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.addi %1, %0 : i32 + %3 = affine.load %arg1[%arg3 + 1] : memref + %4 = arith.cmpi slt, %2, %3 : i32 + %5 = scf.if %4 -> (f32) { + %6 = arith.index_cast %2 : i32 to index + %7 = memref.load %arg0[%6] : memref + scf.yield %7 : f32 + } else { + scf.yield %cst : f32 + } + affine.store %5, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu/debuf.mlir new file mode 100644 index 000000000000..d1f42efc7ce2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu/debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_jagged_to_padded_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %6 = arith.index_cast %arg5 : index to i32 + %extracted = tensor.extract %1[%arg3] : tensor + %7 = arith.addi %extracted, %6 : i32 + %8 = affine.apply #map(%arg3) + %extracted_0 = tensor.extract %1[%8] : tensor + %9 = arith.cmpi slt, %7, %extracted_0 : i32 + %10 = arith.index_cast %7 : i32 to index + %extracted_1 = tensor.extract %2[%10] : tensor + %11 = arith.select %9, %extracted_1, %cst : f32 + %inserted = tensor.insert %11 into %arg6[%arg3, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu/matched.mlir new file mode 100644 index 000000000000..d1f42efc7ce2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu/matched.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_jagged_to_padded_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %6 = arith.index_cast %arg5 : index to i32 + %extracted = tensor.extract %1[%arg3] : tensor + %7 = arith.addi %extracted, %6 : i32 + %8 = affine.apply #map(%arg3) + %extracted_0 = tensor.extract %1[%8] : tensor + %9 = arith.cmpi slt, %7, %extracted_0 : i32 + %10 = arith.index_cast %7 : i32 to index + %extracted_1 = tensor.extract %2[%10] : tensor + %11 = arith.select %9, %extracted_1, %cst : f32 + %inserted = tensor.insert %11 into %arg6[%arg3, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu/orig.mlir new file mode 100644 index 000000000000..a29f0c996995 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_jagged_to_padded_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 64 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.addi %1, %0 : i32 + %3 = affine.load %arg1[%arg3 + 1] : memref + %4 = arith.cmpi slt, %2, %3 : i32 + %5 = scf.if %4 -> (f32) { + %6 = arith.index_cast %2 : i32 to index + %7 = memref.load %arg0[%6] : memref + scf.yield %7 : f32 + } else { + scf.yield %cst : f32 + } + affine.store %5, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu/raised.mlir new file mode 100644 index 000000000000..2db86032350a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu/raised.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_jagged_to_padded_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 64 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.addi %1, %0 : i32 + %3 = affine.load %arg1[%arg3 + 1] : memref + %4 = arith.cmpi slt, %2, %3 : i32 + %5 = arith.index_cast %2 : i32 to index + %6 = memref.load %arg0[%5] : memref + %7 = arith.select %4, %6, %cst : f32 + affine.store %7, %arg2[%arg3, %arg4] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu_debuf.mlir new file mode 100644 index 000000000000..d1f42efc7ce2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu_debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_jagged_to_padded_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %6 = arith.index_cast %arg5 : index to i32 + %extracted = tensor.extract %1[%arg3] : tensor + %7 = arith.addi %extracted, %6 : i32 + %8 = affine.apply #map(%arg3) + %extracted_0 = tensor.extract %1[%8] : tensor + %9 = arith.cmpi slt, %7, %extracted_0 : i32 + %10 = arith.index_cast %7 : i32 to index + %extracted_1 = tensor.extract %2[%10] : tensor + %11 = arith.select %9, %extracted_1, %cst : f32 + %inserted = tensor.insert %11 into %arg6[%arg3, %arg5] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu_linalg.mlir new file mode 100644 index 000000000000..2db86032350a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_jagged_to_padded_cpu_linalg.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_jagged_to_padded_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 64 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.addi %1, %0 : i32 + %3 = affine.load %arg1[%arg3 + 1] : memref + %4 = arith.cmpi slt, %2, %3 : i32 + %5 = arith.index_cast %2 : i32 to index + %6 = memref.load %arg0[%5] : memref + %7 = arith.select %4, %6, %cst : f32 + affine.store %7, %arg2[%arg3, %arg4] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_joint_scaling_cpu.mlir b/issues/aten_c_kernels/results/aten_joint_scaling_cpu.mlir new file mode 100644 index 000000000000..bd6c843cee69 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_joint_scaling_cpu.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_joint_scaling_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0:2 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %cst, %arg5 = %cst) -> (f32, f32) { + %2 = affine.load %arg0[%arg3] : memref + %3 = arith.cmpf olt, %2, %cst : f32 + %4 = scf.if %3 -> (f32) { + %12 = arith.negf %2 : f32 + scf.yield %12 : f32 + } else { + scf.yield %2 : f32 + } + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf olt, %5, %cst : f32 + %7 = scf.if %6 -> (f32) { + %12 = arith.negf %5 : f32 + scf.yield %12 : f32 + } else { + scf.yield %5 : f32 + } + %8 = arith.cmpf ogt, %4, %arg5 : f32 + %9 = arith.select %8, %4, %arg5 : f32 + %10 = arith.cmpf ogt, %7, %arg4 : f32 + %11 = arith.select %10, %7, %arg4 : f32 + affine.yield %11, %9 : f32, f32 + } + %1 = arith.mulf %0#1, %0#0 : f32 + affine.store %1, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_joint_scaling_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_joint_scaling_cpu/debuf.mlir new file mode 100644 index 000000000000..535962b71ab0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_joint_scaling_cpu/debuf.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_joint_scaling_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %3[] : tensor + %4 = tensor.empty() : tensor + %inserted_0 = tensor.insert %cst into %4[] : tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%1 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %9 = arith.cmpf olt, %in, %cst : f32 + %10 = arith.negf %in : f32 + %11 = arith.select %9, %10, %in : f32 + %12 = arith.cmpf ogt, %11, %out : f32 + %13 = arith.select %12, %11, %out : f32 + linalg.yield %13 : f32 + } -> tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %9 = arith.cmpf olt, %in, %cst : f32 + %10 = arith.negf %in : f32 + %11 = arith.select %9, %10, %in : f32 + %12 = arith.cmpf ogt, %11, %out : f32 + %13 = arith.select %12, %11, %out : f32 + linalg.yield %13 : f32 + } -> tensor + %extracted = tensor.extract %5[] : tensor + %extracted_1 = tensor.extract %6[] : tensor + %7 = arith.mulf %extracted_1, %extracted : f32 + %inserted_2 = tensor.insert %7 into %2[%c0] : tensor + %8 = bufferization.to_memref %inserted_2 : memref + memref.copy %8, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_joint_scaling_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_joint_scaling_cpu/matched.mlir new file mode 100644 index 000000000000..535962b71ab0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_joint_scaling_cpu/matched.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_joint_scaling_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %3[] : tensor + %4 = tensor.empty() : tensor + %inserted_0 = tensor.insert %cst into %4[] : tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%1 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %9 = arith.cmpf olt, %in, %cst : f32 + %10 = arith.negf %in : f32 + %11 = arith.select %9, %10, %in : f32 + %12 = arith.cmpf ogt, %11, %out : f32 + %13 = arith.select %12, %11, %out : f32 + linalg.yield %13 : f32 + } -> tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %9 = arith.cmpf olt, %in, %cst : f32 + %10 = arith.negf %in : f32 + %11 = arith.select %9, %10, %in : f32 + %12 = arith.cmpf ogt, %11, %out : f32 + %13 = arith.select %12, %11, %out : f32 + linalg.yield %13 : f32 + } -> tensor + %extracted = tensor.extract %5[] : tensor + %extracted_1 = tensor.extract %6[] : tensor + %7 = arith.mulf %extracted_1, %extracted : f32 + %inserted_2 = tensor.insert %7 into %2[%c0] : tensor + %8 = bufferization.to_memref %inserted_2 : memref + memref.copy %8, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_joint_scaling_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_joint_scaling_cpu/orig.mlir new file mode 100644 index 000000000000..bd6c843cee69 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_joint_scaling_cpu/orig.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_joint_scaling_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0:2 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %cst, %arg5 = %cst) -> (f32, f32) { + %2 = affine.load %arg0[%arg3] : memref + %3 = arith.cmpf olt, %2, %cst : f32 + %4 = scf.if %3 -> (f32) { + %12 = arith.negf %2 : f32 + scf.yield %12 : f32 + } else { + scf.yield %2 : f32 + } + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf olt, %5, %cst : f32 + %7 = scf.if %6 -> (f32) { + %12 = arith.negf %5 : f32 + scf.yield %12 : f32 + } else { + scf.yield %5 : f32 + } + %8 = arith.cmpf ogt, %4, %arg5 : f32 + %9 = arith.select %8, %4, %arg5 : f32 + %10 = arith.cmpf ogt, %7, %arg4 : f32 + %11 = arith.select %10, %7, %arg4 : f32 + affine.yield %11, %9 : f32, f32 + } + %1 = arith.mulf %0#1, %0#0 : f32 + affine.store %1, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_joint_scaling_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_joint_scaling_cpu/raised.mlir new file mode 100644 index 000000000000..f1b5d4a41845 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_joint_scaling_cpu/raised.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_joint_scaling_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %cst, %alloca_0[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg1 : memref) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %3 = arith.cmpf olt, %in, %cst : f32 + %4 = arith.negf %in : f32 + %5 = arith.select %3, %4, %in : f32 + %6 = arith.cmpf ogt, %5, %out : f32 + %7 = arith.select %6, %5, %out : f32 + linalg.yield %7 : f32 + } + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca_0 : memref) { + ^bb0(%in: f32, %out: f32): + %3 = arith.cmpf olt, %in, %cst : f32 + %4 = arith.negf %in : f32 + %5 = arith.select %3, %4, %in : f32 + %6 = arith.cmpf ogt, %5, %out : f32 + %7 = arith.select %6, %5, %out : f32 + linalg.yield %7 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = affine.load %alloca_0[] : memref + %2 = arith.mulf %1, %0 : f32 + affine.store %2, %arg2[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_joint_scaling_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_joint_scaling_cpu_debuf.mlir new file mode 100644 index 000000000000..535962b71ab0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_joint_scaling_cpu_debuf.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_joint_scaling_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %3[] : tensor + %4 = tensor.empty() : tensor + %inserted_0 = tensor.insert %cst into %4[] : tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%1 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %9 = arith.cmpf olt, %in, %cst : f32 + %10 = arith.negf %in : f32 + %11 = arith.select %9, %10, %in : f32 + %12 = arith.cmpf ogt, %11, %out : f32 + %13 = arith.select %12, %11, %out : f32 + linalg.yield %13 : f32 + } -> tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %9 = arith.cmpf olt, %in, %cst : f32 + %10 = arith.negf %in : f32 + %11 = arith.select %9, %10, %in : f32 + %12 = arith.cmpf ogt, %11, %out : f32 + %13 = arith.select %12, %11, %out : f32 + linalg.yield %13 : f32 + } -> tensor + %extracted = tensor.extract %5[] : tensor + %extracted_1 = tensor.extract %6[] : tensor + %7 = arith.mulf %extracted_1, %extracted : f32 + %inserted_2 = tensor.insert %7 into %2[%c0] : tensor + %8 = bufferization.to_memref %inserted_2 : memref + memref.copy %8, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_joint_scaling_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_joint_scaling_cpu_linalg.mlir new file mode 100644 index 000000000000..f1b5d4a41845 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_joint_scaling_cpu_linalg.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_joint_scaling_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %cst, %alloca_0[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg1 : memref) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %3 = arith.cmpf olt, %in, %cst : f32 + %4 = arith.negf %in : f32 + %5 = arith.select %3, %4, %in : f32 + %6 = arith.cmpf ogt, %5, %out : f32 + %7 = arith.select %6, %5, %out : f32 + linalg.yield %7 : f32 + } + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca_0 : memref) { + ^bb0(%in: f32, %out: f32): + %3 = arith.cmpf olt, %in, %cst : f32 + %4 = arith.negf %in : f32 + %5 = arith.select %3, %4, %in : f32 + %6 = arith.cmpf ogt, %5, %out : f32 + %7 = arith.select %6, %5, %out : f32 + linalg.yield %7 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = affine.load %alloca_0[] : memref + %2 = arith.mulf %1, %0 : f32 + affine.store %2, %arg2[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_kaiser_window.mlir b/issues/aten_c_kernels/results/aten_kaiser_window.mlir new file mode 100644 index 000000000000..aad71a153e56 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kaiser_window.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kaiser_window(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = func.call @calc_kaiserf(%0, %arg1) : (f32, f32) -> f32 + affine.store %1, %arg2[%arg3] : memref + } + return + } + func.func private @calc_kaiserf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_kaiser_window/debuf.mlir b/issues/aten_c_kernels/results/aten_kaiser_window/debuf.mlir new file mode 100644 index 000000000000..0c40b60b08f9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kaiser_window/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kaiser_window(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_kaiserf(%in, %arg1) : (f32, f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } + func.func private @calc_kaiserf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_kaiser_window/matched.mlir b/issues/aten_c_kernels/results/aten_kaiser_window/matched.mlir new file mode 100644 index 000000000000..0c40b60b08f9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kaiser_window/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kaiser_window(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_kaiserf(%in, %arg1) : (f32, f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } + func.func private @calc_kaiserf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_kaiser_window/orig.mlir b/issues/aten_c_kernels/results/aten_kaiser_window/orig.mlir new file mode 100644 index 000000000000..aad71a153e56 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kaiser_window/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kaiser_window(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = func.call @calc_kaiserf(%0, %arg1) : (f32, f32) -> f32 + affine.store %1, %arg2[%arg3] : memref + } + return + } + func.func private @calc_kaiserf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_kaiser_window/raised.mlir b/issues/aten_c_kernels/results/aten_kaiser_window/raised.mlir new file mode 100644 index 000000000000..0621d66dcbdf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kaiser_window/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kaiser_window(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_kaiserf(%in, %arg1) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_kaiserf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_kaiser_window_debuf.mlir b/issues/aten_c_kernels/results/aten_kaiser_window_debuf.mlir new file mode 100644 index 000000000000..0c40b60b08f9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kaiser_window_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kaiser_window(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_kaiserf(%in, %arg1) : (f32, f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } + func.func private @calc_kaiserf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_kaiser_window_linalg.mlir b/issues/aten_c_kernels/results/aten_kaiser_window_linalg.mlir new file mode 100644 index 000000000000..0621d66dcbdf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kaiser_window_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kaiser_window(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_kaiserf(%in, %arg1) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_kaiserf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_kron_impl_cpu.mlir b/issues/aten_c_kernels/results/aten_kron_impl_cpu.mlir new file mode 100644 index 000000000000..b2885d15d541 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kron_impl_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kron_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 12 { + affine.for %arg5 = 0 to 8 { + affine.for %arg6 = 0 to 10 { + %0 = affine.load %arg0[%arg3, %arg4] : memref + %1 = affine.load %arg1[%arg5, %arg6] : memref + %2 = arith.mulf %0, %1 : f32 + affine.store %2, %arg2[%arg5 + %arg3 * 8, %arg6 + %arg4 * 10] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_kron_impl_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_kron_impl_cpu/debuf.mlir new file mode 100644 index 000000000000..84f51d2b87cd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kron_impl_cpu/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 8, d3 + d1 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kron_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c12 = arith.constant 12 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c12] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c10] [1, 1] : tensor to tensor + %3 = polygeist.submap(%2, %c16, %c12, %c8, %c10) {map = #map} : (tensor, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + linalg.yield %7 : f32 + } -> tensor + %5 = polygeist.submapInverse(%2, %4, %c16, %c12, %c8, %c10) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_kron_impl_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_kron_impl_cpu/matched.mlir new file mode 100644 index 000000000000..84f51d2b87cd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kron_impl_cpu/matched.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 8, d3 + d1 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kron_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c12 = arith.constant 12 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c12] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c10] [1, 1] : tensor to tensor + %3 = polygeist.submap(%2, %c16, %c12, %c8, %c10) {map = #map} : (tensor, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + linalg.yield %7 : f32 + } -> tensor + %5 = polygeist.submapInverse(%2, %4, %c16, %c12, %c8, %c10) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_kron_impl_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_kron_impl_cpu/orig.mlir new file mode 100644 index 000000000000..b2885d15d541 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kron_impl_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kron_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 12 { + affine.for %arg5 = 0 to 8 { + affine.for %arg6 = 0 to 10 { + %0 = affine.load %arg0[%arg3, %arg4] : memref + %1 = affine.load %arg1[%arg5, %arg6] : memref + %2 = arith.mulf %0, %1 : f32 + affine.store %2, %arg2[%arg5 + %arg3 * 8, %arg6 + %arg4 * 10] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_kron_impl_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_kron_impl_cpu/raised.mlir new file mode 100644 index 000000000000..cd5790660e64 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kron_impl_cpu/raised.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 8, d3 + d1 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kron_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c12 = arith.constant 12 : index + %c8 = arith.constant 8 : index + %c10 = arith.constant 10 : index + %subview = memref.subview %arg0[0, 0] [%c16, %c12] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c10] [1, 1] : memref to memref> + %0 = polygeist.submap(%arg2, %c16, %c12, %c8, %c10) {map = #map} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%0 : memref) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %1 = arith.mulf %in, %in_1 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_kron_impl_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_kron_impl_cpu_debuf.mlir new file mode 100644 index 000000000000..84f51d2b87cd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kron_impl_cpu_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 8, d3 + d1 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kron_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c12 = arith.constant 12 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c12] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c10] [1, 1] : tensor to tensor + %3 = polygeist.submap(%2, %c16, %c12, %c8, %c10) {map = #map} : (tensor, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + linalg.yield %7 : f32 + } -> tensor + %5 = polygeist.submapInverse(%2, %4, %c16, %c12, %c8, %c10) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_kron_impl_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_kron_impl_cpu_linalg.mlir new file mode 100644 index 000000000000..cd5790660e64 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kron_impl_cpu_linalg.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 8, d3 + d1 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kron_impl_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c12 = arith.constant 12 : index + %c8 = arith.constant 8 : index + %c10 = arith.constant 10 : index + %subview = memref.subview %arg0[0, 0] [%c16, %c12] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c10] [1, 1] : memref to memref> + %0 = polygeist.submap(%arg2, %c16, %c12, %c8, %c10) {map = #map} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%0 : memref) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %1 = arith.mulf %in, %in_1 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_kron_out_cpu.mlir b/issues/aten_c_kernels/results/aten_kron_out_cpu.mlir new file mode 100644 index 000000000000..9bd4c964c86d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kron_out_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kron_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 12 { + affine.for %arg5 = 0 to 8 { + affine.for %arg6 = 0 to 10 { + %0 = affine.load %arg0[%arg3, %arg4] : memref + %1 = affine.load %arg1[%arg5, %arg6] : memref + %2 = arith.mulf %0, %1 : f32 + affine.store %2, %arg2[%arg5 + %arg3 * 8, %arg6 + %arg4 * 10] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_kron_out_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_kron_out_cpu/debuf.mlir new file mode 100644 index 000000000000..617aeaf361ea --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kron_out_cpu/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 8, d3 + d1 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kron_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c12 = arith.constant 12 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c12] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c10] [1, 1] : tensor to tensor + %3 = polygeist.submap(%2, %c16, %c12, %c8, %c10) {map = #map} : (tensor, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + linalg.yield %7 : f32 + } -> tensor + %5 = polygeist.submapInverse(%2, %4, %c16, %c12, %c8, %c10) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_kron_out_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_kron_out_cpu/matched.mlir new file mode 100644 index 000000000000..617aeaf361ea --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kron_out_cpu/matched.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 8, d3 + d1 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kron_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c12 = arith.constant 12 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c12] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c10] [1, 1] : tensor to tensor + %3 = polygeist.submap(%2, %c16, %c12, %c8, %c10) {map = #map} : (tensor, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + linalg.yield %7 : f32 + } -> tensor + %5 = polygeist.submapInverse(%2, %4, %c16, %c12, %c8, %c10) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_kron_out_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_kron_out_cpu/orig.mlir new file mode 100644 index 000000000000..9bd4c964c86d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kron_out_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kron_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 12 { + affine.for %arg5 = 0 to 8 { + affine.for %arg6 = 0 to 10 { + %0 = affine.load %arg0[%arg3, %arg4] : memref + %1 = affine.load %arg1[%arg5, %arg6] : memref + %2 = arith.mulf %0, %1 : f32 + affine.store %2, %arg2[%arg5 + %arg3 * 8, %arg6 + %arg4 * 10] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_kron_out_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_kron_out_cpu/raised.mlir new file mode 100644 index 000000000000..913b5a7f96cd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kron_out_cpu/raised.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 8, d3 + d1 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kron_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c12 = arith.constant 12 : index + %c8 = arith.constant 8 : index + %c10 = arith.constant 10 : index + %subview = memref.subview %arg0[0, 0] [%c16, %c12] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c10] [1, 1] : memref to memref> + %0 = polygeist.submap(%arg2, %c16, %c12, %c8, %c10) {map = #map} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%0 : memref) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %1 = arith.mulf %in, %in_1 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_kron_out_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_kron_out_cpu_debuf.mlir new file mode 100644 index 000000000000..617aeaf361ea --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kron_out_cpu_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 8, d3 + d1 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kron_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c10 = arith.constant 10 : index + %c8 = arith.constant 8 : index + %c12 = arith.constant 12 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c12] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c10] [1, 1] : tensor to tensor + %3 = polygeist.submap(%2, %c16, %c12, %c8, %c10) {map = #map} : (tensor, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + linalg.yield %7 : f32 + } -> tensor + %5 = polygeist.submapInverse(%2, %4, %c16, %c12, %c8, %c10) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_kron_out_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_kron_out_cpu_linalg.mlir new file mode 100644 index 000000000000..913b5a7f96cd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kron_out_cpu_linalg.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 8, d3 + d1 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kron_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c12 = arith.constant 12 : index + %c8 = arith.constant 8 : index + %c10 = arith.constant 10 : index + %subview = memref.subview %arg0[0, 0] [%c16, %c12] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c10] [1, 1] : memref to memref> + %0 = polygeist.submap(%arg2, %c16, %c12, %c8, %c10) {map = #map} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%0 : memref) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %1 = arith.mulf %in, %in_1 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_kthvalue_cpu.mlir b/issues/aten_c_kernels/results/aten_kthvalue_cpu.mlir new file mode 100644 index 000000000000..b295c3d9c9fb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kthvalue_cpu.mlir @@ -0,0 +1,29 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kthvalue_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg1 : i32 to index + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to #map()[%0] { + %2 = arith.index_cast %arg4 : index to i32 + %3 = affine.for %arg5 = #map1(%arg4) to 63 iter_args(%arg6 = %2) -> (i32) { + %7 = arith.index_cast %arg5 : index to i32 + %8 = affine.load %arg0[%arg3, %arg5] : memref + %9 = arith.index_cast %arg6 : i32 to index + %10 = memref.load %arg0[%arg3, %9] : memref + %11 = arith.cmpf olt, %8, %10 : f32 + %12 = arith.select %11, %7, %arg6 : i32 + affine.yield %12 : i32 + } + %4 = affine.load %arg0[%arg3, %arg4] : memref + %5 = arith.index_cast %3 : i32 to index + %6 = memref.load %arg0[%arg3, %5] : memref + affine.store %6, %arg0[%arg3, %arg4] : memref + memref.store %4, %arg0[%arg3, %5] : memref + } + %1 = affine.load %arg0[%arg3, symbol(%0)] : memref + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_kthvalue_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_kthvalue_cpu/debuf.mlir new file mode 100644 index 000000000000..503d025a8e14 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kthvalue_cpu/debuf.mlir @@ -0,0 +1,53 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +#map2 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kthvalue_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = arith.index_cast %arg1 : i32 to index + %4 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %2) -> (tensor) { + %8 = affine.apply #map()[%3] + %alloca = memref.alloca(%8) : memref + %9 = bufferization.to_tensor %alloca : memref + %10:2 = affine.for %arg5 = 0 to #map()[%3] iter_args(%arg6 = %9, %arg7 = %arg4) -> (tensor, tensor) { + %11 = arith.index_cast %arg5 : index to i32 + %inserted = tensor.insert %11 into %arg6[%arg5] : tensor + %12 = affine.for %arg8 = #map1(%arg5) to 63 iter_args(%arg9 = %inserted) -> (tensor) { + %extracted_5 = tensor.extract %arg9[%arg5] : tensor + %14 = arith.index_cast %arg8 : index to i32 + %extracted_6 = tensor.extract %arg7[%arg3, %arg8] : tensor + %15 = arith.index_cast %extracted_5 : i32 to index + %extracted_7 = tensor.extract %arg7[%arg3, %15] : tensor + %16 = arith.cmpf olt, %extracted_6, %extracted_7 : f32 + %17 = arith.select %16, %14, %extracted_5 : i32 + %inserted_8 = tensor.insert %17 into %arg9[%arg5] : tensor + affine.yield %inserted_8 : tensor + } + %extracted = tensor.extract %12[%arg5] : tensor + %extracted_1 = tensor.extract %arg7[%arg3, %arg5] : tensor + %13 = arith.index_cast %extracted : i32 to index + %extracted_2 = tensor.extract %arg7[%arg3, %13] : tensor + %inserted_3 = tensor.insert %extracted_2 into %arg7[%arg3, %arg5] : tensor + %inserted_4 = tensor.insert %extracted_1 into %inserted_3[%arg3, %13] : tensor + affine.yield %12, %inserted_4 : tensor, tensor + } + affine.yield %10#1 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg0 : memref to memref + %extracted_slice = tensor.extract_slice %1[0] [%c16] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, %3] [%c16, 1] [1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %1[0] [%c16] [1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_kthvalue_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_kthvalue_cpu/matched.mlir new file mode 100644 index 000000000000..22cc16c07aa6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kthvalue_cpu/matched.mlir @@ -0,0 +1,50 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +#map2 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kthvalue_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = arith.index_cast %arg1 : i32 to index + %4 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %2) -> (tensor) { + %8 = affine.apply #map()[%3] + %alloca = memref.alloca(%8) : memref + %9 = bufferization.to_tensor %alloca : memref + %10:2 = affine.for %arg5 = 0 to #map()[%3] iter_args(%arg6 = %9, %arg7 = %arg4) -> (tensor, tensor) { + %11 = arith.index_cast %arg5 : index to i32 + %inserted = tensor.insert %11 into %arg6[%arg5] : tensor + %12 = affine.for %arg8 = #map1(%arg5) to 63 iter_args(%arg9 = %inserted) -> (tensor) { + %extracted_5 = tensor.extract %arg9[%arg5] : tensor + %14 = arith.index_cast %arg8 : index to i32 + %extracted_6 = tensor.extract %arg7[%arg3, %arg8] : tensor + %15 = arith.index_cast %extracted_5 : i32 to index + %extracted_7 = tensor.extract %arg7[%arg3, %15] : tensor + %16 = arith.cmpf olt, %extracted_6, %extracted_7 : f32 + %17 = arith.select %16, %14, %extracted_5 : i32 + %inserted_8 = tensor.insert %17 into %arg9[%arg5] : tensor + affine.yield %inserted_8 : tensor + } + %extracted = tensor.extract %12[%arg5] : tensor + %extracted_1 = tensor.extract %arg7[%arg3, %arg5] : tensor + %13 = arith.index_cast %extracted : i32 to index + %extracted_2 = tensor.extract %arg7[%arg3, %13] : tensor + %inserted_3 = tensor.insert %extracted_2 into %arg7[%arg3, %arg5] : tensor + %inserted_4 = tensor.insert %extracted_1 into %inserted_3[%arg3, %13] : tensor + affine.yield %12, %inserted_4 : tensor, tensor + } + affine.yield %10#1 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg0 : memref to memref + %extracted_slice = tensor.extract_slice %1[0] [%c16] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, %3] [%c16, 1] [1, 1] : tensor to tensor + %6 = kernel.launch @cudaCopy1D_f32_tensor(%extracted_slice_0, %extracted_slice) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %6 into %1[0] [%c16] [1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_kthvalue_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_kthvalue_cpu/orig.mlir new file mode 100644 index 000000000000..b295c3d9c9fb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kthvalue_cpu/orig.mlir @@ -0,0 +1,29 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kthvalue_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg1 : i32 to index + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to #map()[%0] { + %2 = arith.index_cast %arg4 : index to i32 + %3 = affine.for %arg5 = #map1(%arg4) to 63 iter_args(%arg6 = %2) -> (i32) { + %7 = arith.index_cast %arg5 : index to i32 + %8 = affine.load %arg0[%arg3, %arg5] : memref + %9 = arith.index_cast %arg6 : i32 to index + %10 = memref.load %arg0[%arg3, %9] : memref + %11 = arith.cmpf olt, %8, %10 : f32 + %12 = arith.select %11, %7, %arg6 : i32 + affine.yield %12 : i32 + } + %4 = affine.load %arg0[%arg3, %arg4] : memref + %5 = arith.index_cast %3 : i32 to index + %6 = memref.load %arg0[%arg3, %5] : memref + affine.store %6, %arg0[%arg3, %arg4] : memref + memref.store %4, %arg0[%arg3, %5] : memref + } + %1 = affine.load %arg0[%arg3, symbol(%0)] : memref + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_kthvalue_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_kthvalue_cpu/raised.mlir new file mode 100644 index 000000000000..b67cca2162a4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kthvalue_cpu/raised.mlir @@ -0,0 +1,41 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +#map2 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kthvalue_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %0 = arith.index_cast %arg1 : i32 to index + affine.for %arg3 = 0 to 16 { + %1 = affine.apply #map()[%0] + %alloca = memref.alloca(%1) : memref + affine.for %arg4 = 0 to #map()[%0] { + %2 = arith.index_cast %arg4 : index to i32 + affine.store %2, %alloca[%arg4] : memref + affine.for %arg5 = #map1(%arg4) to 63 { + %7 = affine.load %alloca[%arg4] : memref + %8 = arith.index_cast %arg5 : index to i32 + %9 = affine.load %arg0[%arg3, %arg5] : memref + %10 = arith.index_cast %7 : i32 to index + %11 = memref.load %arg0[%arg3, %10] : memref + %12 = arith.cmpf olt, %9, %11 : f32 + %13 = arith.select %12, %8, %7 : i32 + affine.store %13, %alloca[%arg4] : memref + } + %3 = affine.load %alloca[%arg4] : memref + %4 = affine.load %arg0[%arg3, %arg4] : memref + %5 = arith.index_cast %3 : i32 to index + %6 = memref.load %arg0[%arg3, %5] : memref + affine.store %6, %arg0[%arg3, %arg4] : memref + memref.store %4, %arg0[%arg3, %5] : memref + } + } + %subview = memref.subview %arg0[0, %0] [%c16, 1] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg2[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_kthvalue_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_kthvalue_cpu_debuf.mlir new file mode 100644 index 000000000000..503d025a8e14 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kthvalue_cpu_debuf.mlir @@ -0,0 +1,53 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +#map2 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kthvalue_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = arith.index_cast %arg1 : i32 to index + %4 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %2) -> (tensor) { + %8 = affine.apply #map()[%3] + %alloca = memref.alloca(%8) : memref + %9 = bufferization.to_tensor %alloca : memref + %10:2 = affine.for %arg5 = 0 to #map()[%3] iter_args(%arg6 = %9, %arg7 = %arg4) -> (tensor, tensor) { + %11 = arith.index_cast %arg5 : index to i32 + %inserted = tensor.insert %11 into %arg6[%arg5] : tensor + %12 = affine.for %arg8 = #map1(%arg5) to 63 iter_args(%arg9 = %inserted) -> (tensor) { + %extracted_5 = tensor.extract %arg9[%arg5] : tensor + %14 = arith.index_cast %arg8 : index to i32 + %extracted_6 = tensor.extract %arg7[%arg3, %arg8] : tensor + %15 = arith.index_cast %extracted_5 : i32 to index + %extracted_7 = tensor.extract %arg7[%arg3, %15] : tensor + %16 = arith.cmpf olt, %extracted_6, %extracted_7 : f32 + %17 = arith.select %16, %14, %extracted_5 : i32 + %inserted_8 = tensor.insert %17 into %arg9[%arg5] : tensor + affine.yield %inserted_8 : tensor + } + %extracted = tensor.extract %12[%arg5] : tensor + %extracted_1 = tensor.extract %arg7[%arg3, %arg5] : tensor + %13 = arith.index_cast %extracted : i32 to index + %extracted_2 = tensor.extract %arg7[%arg3, %13] : tensor + %inserted_3 = tensor.insert %extracted_2 into %arg7[%arg3, %arg5] : tensor + %inserted_4 = tensor.insert %extracted_1 into %inserted_3[%arg3, %13] : tensor + affine.yield %12, %inserted_4 : tensor, tensor + } + affine.yield %10#1 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg0 : memref to memref + %extracted_slice = tensor.extract_slice %1[0] [%c16] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, %3] [%c16, 1] [1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %1[0] [%c16] [1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_kthvalue_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_kthvalue_cpu_linalg.mlir new file mode 100644 index 000000000000..b67cca2162a4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_kthvalue_cpu_linalg.mlir @@ -0,0 +1,41 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +#map2 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_kthvalue_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %0 = arith.index_cast %arg1 : i32 to index + affine.for %arg3 = 0 to 16 { + %1 = affine.apply #map()[%0] + %alloca = memref.alloca(%1) : memref + affine.for %arg4 = 0 to #map()[%0] { + %2 = arith.index_cast %arg4 : index to i32 + affine.store %2, %alloca[%arg4] : memref + affine.for %arg5 = #map1(%arg4) to 63 { + %7 = affine.load %alloca[%arg4] : memref + %8 = arith.index_cast %arg5 : index to i32 + %9 = affine.load %arg0[%arg3, %arg5] : memref + %10 = arith.index_cast %7 : i32 to index + %11 = memref.load %arg0[%arg3, %10] : memref + %12 = arith.cmpf olt, %9, %11 : f32 + %13 = arith.select %12, %8, %7 : i32 + affine.store %13, %alloca[%arg4] : memref + } + %3 = affine.load %alloca[%arg4] : memref + %4 = affine.load %arg0[%arg3, %arg4] : memref + %5 = arith.index_cast %3 : i32 to index + %6 = memref.load %arg0[%arg3, %5] : memref + affine.store %6, %arg0[%arg3, %arg4] : memref + memref.store %4, %arg0[%arg3, %5] : memref + } + } + %subview = memref.subview %arg0[0, %0] [%c16, 1] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg2[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_l1_loss.mlir b/issues/aten_c_kernels/results/aten_l1_loss.mlir new file mode 100644 index 000000000000..3f0828ae3af3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_l1_loss.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_l1_loss(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.560000e+02 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.store %cst_0, %arg2[0] : memref + affine.for %arg3 = 0 to 256 { + %2 = affine.load %arg0[%arg3] : memref + %3 = affine.load %arg1[%arg3] : memref + %4 = arith.subf %2, %3 : f32 + %5 = arith.cmpf olt, %4, %cst_0 : f32 + %6 = scf.if %5 -> (f32) { + %9 = arith.negf %4 : f32 + scf.yield %9 : f32 + } else { + scf.yield %4 : f32 + } + %7 = affine.load %arg2[0] : memref + %8 = arith.addf %7, %6 : f32 + affine.store %8, %arg2[0] : memref + } + %0 = affine.load %arg2[0] : memref + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_l1_loss/debuf.mlir b/issues/aten_c_kernels/results/aten_l1_loss/debuf.mlir new file mode 100644 index 000000000000..23d18837e8f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_l1_loss/debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_l1_loss(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 2.560000e+02 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.subf %in, %in_2 : f32 + %7 = arith.cmpf olt, %6, %cst : f32 + %8 = arith.negf %6 : f32 + %9 = arith.select %7, %8, %6 : f32 + %10 = arith.addf %out, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %extracted = tensor.extract %inserted_slice[%c0] : tensor + %4 = arith.divf %extracted, %cst_0 : f32 + %inserted_1 = tensor.insert %4 into %inserted_slice[%c0] : tensor + %5 = bufferization.to_memref %inserted_1 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_l1_loss/matched.mlir b/issues/aten_c_kernels/results/aten_l1_loss/matched.mlir new file mode 100644 index 000000000000..23d18837e8f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_l1_loss/matched.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_l1_loss(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 2.560000e+02 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.subf %in, %in_2 : f32 + %7 = arith.cmpf olt, %6, %cst : f32 + %8 = arith.negf %6 : f32 + %9 = arith.select %7, %8, %6 : f32 + %10 = arith.addf %out, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %extracted = tensor.extract %inserted_slice[%c0] : tensor + %4 = arith.divf %extracted, %cst_0 : f32 + %inserted_1 = tensor.insert %4 into %inserted_slice[%c0] : tensor + %5 = bufferization.to_memref %inserted_1 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_l1_loss/orig.mlir b/issues/aten_c_kernels/results/aten_l1_loss/orig.mlir new file mode 100644 index 000000000000..3f0828ae3af3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_l1_loss/orig.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_l1_loss(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.560000e+02 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.store %cst_0, %arg2[0] : memref + affine.for %arg3 = 0 to 256 { + %2 = affine.load %arg0[%arg3] : memref + %3 = affine.load %arg1[%arg3] : memref + %4 = arith.subf %2, %3 : f32 + %5 = arith.cmpf olt, %4, %cst_0 : f32 + %6 = scf.if %5 -> (f32) { + %9 = arith.negf %4 : f32 + scf.yield %9 : f32 + } else { + scf.yield %4 : f32 + } + %7 = affine.load %arg2[0] : memref + %8 = arith.addf %7, %6 : f32 + affine.store %8, %arg2[0] : memref + } + %0 = affine.load %arg2[0] : memref + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_l1_loss/raised.mlir b/issues/aten_c_kernels/results/aten_l1_loss/raised.mlir new file mode 100644 index 000000000000..7a7b3ed90784 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_l1_loss/raised.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_l1_loss(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.560000e+02 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.store %cst_0, %arg2[0] : memref + %subview = memref.subview %arg2[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%arg0, %arg1 : memref, memref) outs(%subview : memref>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.subf %in, %in_1 : f32 + %3 = arith.cmpf olt, %2, %cst_0 : f32 + %4 = arith.negf %2 : f32 + %5 = arith.select %3, %4, %2 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } + %0 = affine.load %arg2[0] : memref + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg2[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_l1_loss_debuf.mlir b/issues/aten_c_kernels/results/aten_l1_loss_debuf.mlir new file mode 100644 index 000000000000..23d18837e8f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_l1_loss_debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_l1_loss(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 2.560000e+02 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %inserted = tensor.insert %cst into %2[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.subf %in, %in_2 : f32 + %7 = arith.cmpf olt, %6, %cst : f32 + %8 = arith.negf %6 : f32 + %9 = arith.select %7, %8, %6 : f32 + %10 = arith.addf %out, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %inserted[0] [1] [1] : tensor into tensor + %extracted = tensor.extract %inserted_slice[%c0] : tensor + %4 = arith.divf %extracted, %cst_0 : f32 + %inserted_1 = tensor.insert %4 into %inserted_slice[%c0] : tensor + %5 = bufferization.to_memref %inserted_1 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_l1_loss_linalg.mlir b/issues/aten_c_kernels/results/aten_l1_loss_linalg.mlir new file mode 100644 index 000000000000..7a7b3ed90784 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_l1_loss_linalg.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_l1_loss(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.560000e+02 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.store %cst_0, %arg2[0] : memref + %subview = memref.subview %arg2[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%arg0, %arg1 : memref, memref) outs(%subview : memref>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.subf %in, %in_1 : f32 + %3 = arith.cmpf olt, %2, %cst_0 : f32 + %4 = arith.negf %2 : f32 + %5 = arith.select %3, %4, %2 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } + %0 = affine.load %arg2[0] : memref + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg2[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_laguerre_polynomial_l.mlir b/issues/aten_c_kernels/results/aten_laguerre_polynomial_l.mlir new file mode 100644 index 000000000000..1fd385adce23 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_laguerre_polynomial_l.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_laguerre_polynomial_l(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_laguerre_lf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_laguerre_lf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_laguerre_polynomial_l/debuf.mlir b/issues/aten_c_kernels/results/aten_laguerre_polynomial_l/debuf.mlir new file mode 100644 index 000000000000..b290fb721d7c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_laguerre_polynomial_l/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_laguerre_polynomial_l(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_laguerre_lf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_laguerre_lf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_laguerre_polynomial_l/matched.mlir b/issues/aten_c_kernels/results/aten_laguerre_polynomial_l/matched.mlir new file mode 100644 index 000000000000..b290fb721d7c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_laguerre_polynomial_l/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_laguerre_polynomial_l(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_laguerre_lf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_laguerre_lf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_laguerre_polynomial_l/orig.mlir b/issues/aten_c_kernels/results/aten_laguerre_polynomial_l/orig.mlir new file mode 100644 index 000000000000..1fd385adce23 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_laguerre_polynomial_l/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_laguerre_polynomial_l(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_laguerre_lf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_laguerre_lf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_laguerre_polynomial_l/raised.mlir b/issues/aten_c_kernels/results/aten_laguerre_polynomial_l/raised.mlir new file mode 100644 index 000000000000..6106bde40eb1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_laguerre_polynomial_l/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_laguerre_polynomial_l(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_laguerre_lf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_laguerre_lf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_laguerre_polynomial_l_debuf.mlir b/issues/aten_c_kernels/results/aten_laguerre_polynomial_l_debuf.mlir new file mode 100644 index 000000000000..b290fb721d7c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_laguerre_polynomial_l_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_laguerre_polynomial_l(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_laguerre_lf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_laguerre_lf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_laguerre_polynomial_l_linalg.mlir b/issues/aten_c_kernels/results/aten_laguerre_polynomial_l_linalg.mlir new file mode 100644 index 000000000000..6106bde40eb1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_laguerre_polynomial_l_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_laguerre_polynomial_l(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_laguerre_lf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_laguerre_lf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_layer_norm.mlir b/issues/aten_c_kernels/results/aten_layer_norm.mlir new file mode 100644 index 000000000000..dc7cd54609c4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm.mlir @@ -0,0 +1,44 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 1.280000e+02 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + %alloca_2 = memref.alloca() : memref + affine.store %cst_1, %alloca_2[] : memref + affine.store %cst_1, %alloca[] : memref + affine.for %arg5 = 0 to 128 { + %7 = affine.load %arg0[%arg5] : memref + %8 = affine.load %alloca_2[] : memref + %9 = arith.addf %8, %7 : f32 + affine.store %9, %alloca_2[] : memref + } + %0 = affine.load %alloca_2[] : memref + %1 = arith.divf %0, %cst_0 : f32 + affine.store %1, %alloca_2[] : memref + affine.for %arg5 = 0 to 128 { + %7 = affine.load %arg0[%arg5] : memref + %8 = arith.subf %7, %1 : f32 + %9 = arith.mulf %8, %8 : f32 + %10 = affine.load %alloca[] : memref + %11 = arith.addf %10, %9 : f32 + affine.store %11, %alloca[] : memref + } + %2 = affine.load %alloca[] : memref + %3 = arith.divf %2, %cst_0 : f32 + %4 = arith.addf %3, %arg4 : f32 + %5 = math.sqrt %4 : f32 + %6 = arith.divf %cst, %5 : f32 + affine.for %arg5 = 0 to 128 { + %7 = affine.load %arg0[%arg5] : memref + %8 = arith.subf %7, %1 : f32 + %9 = arith.mulf %8, %6 : f32 + %10 = affine.load %arg1[%arg5] : memref + %11 = arith.mulf %9, %10 : f32 + %12 = affine.load %arg2[%arg5] : memref + %13 = arith.addf %11, %12 : f32 + affine.store %13, %arg3[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_layer_norm/debuf.mlir b/issues/aten_c_kernels/results/aten_layer_norm/debuf.mlir new file mode 100644 index 000000000000..dcd49bd8903e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm/debuf.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.280000e+02 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = tensor.empty() : tensor + %5 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %5[] : tensor + %inserted_2 = tensor.insert %cst into %4[] : tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %15 = arith.addf %out, %in : f32 + linalg.yield %15 : f32 + } -> tensor + %extracted = tensor.extract %6[] : tensor + %7 = arith.divf %extracted, %cst_0 : f32 + %8 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted_2 : tensor) { + ^bb0(%in: f32, %out: f32): + %15 = arith.subf %in, %7 : f32 + %16 = arith.mulf %15, %15 : f32 + %17 = arith.addf %out, %16 : f32 + linalg.yield %17 : f32 + } -> tensor + %extracted_3 = tensor.extract %8[] : tensor + %9 = arith.divf %extracted_3, %cst_0 : f32 + %10 = arith.addf %9, %arg4 : f32 + %11 = math.sqrt %10 : f32 + %12 = arith.divf %cst_1, %11 : f32 + %13 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_4: f32, %in_5: f32, %out: f32): + %15 = arith.subf %in, %7 : f32 + %16 = arith.mulf %15, %12 : f32 + %17 = arith.mulf %16, %in_4 : f32 + %18 = arith.addf %17, %in_5 : f32 + linalg.yield %18 : f32 + } -> tensor + %14 = bufferization.to_memref %13 : memref + memref.copy %14, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_layer_norm/matched.mlir b/issues/aten_c_kernels/results/aten_layer_norm/matched.mlir new file mode 100644 index 000000000000..dcd49bd8903e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm/matched.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.280000e+02 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = tensor.empty() : tensor + %5 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %5[] : tensor + %inserted_2 = tensor.insert %cst into %4[] : tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %15 = arith.addf %out, %in : f32 + linalg.yield %15 : f32 + } -> tensor + %extracted = tensor.extract %6[] : tensor + %7 = arith.divf %extracted, %cst_0 : f32 + %8 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted_2 : tensor) { + ^bb0(%in: f32, %out: f32): + %15 = arith.subf %in, %7 : f32 + %16 = arith.mulf %15, %15 : f32 + %17 = arith.addf %out, %16 : f32 + linalg.yield %17 : f32 + } -> tensor + %extracted_3 = tensor.extract %8[] : tensor + %9 = arith.divf %extracted_3, %cst_0 : f32 + %10 = arith.addf %9, %arg4 : f32 + %11 = math.sqrt %10 : f32 + %12 = arith.divf %cst_1, %11 : f32 + %13 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_4: f32, %in_5: f32, %out: f32): + %15 = arith.subf %in, %7 : f32 + %16 = arith.mulf %15, %12 : f32 + %17 = arith.mulf %16, %in_4 : f32 + %18 = arith.addf %17, %in_5 : f32 + linalg.yield %18 : f32 + } -> tensor + %14 = bufferization.to_memref %13 : memref + memref.copy %14, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_layer_norm/orig.mlir b/issues/aten_c_kernels/results/aten_layer_norm/orig.mlir new file mode 100644 index 000000000000..dc7cd54609c4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm/orig.mlir @@ -0,0 +1,44 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 1.280000e+02 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + %alloca_2 = memref.alloca() : memref + affine.store %cst_1, %alloca_2[] : memref + affine.store %cst_1, %alloca[] : memref + affine.for %arg5 = 0 to 128 { + %7 = affine.load %arg0[%arg5] : memref + %8 = affine.load %alloca_2[] : memref + %9 = arith.addf %8, %7 : f32 + affine.store %9, %alloca_2[] : memref + } + %0 = affine.load %alloca_2[] : memref + %1 = arith.divf %0, %cst_0 : f32 + affine.store %1, %alloca_2[] : memref + affine.for %arg5 = 0 to 128 { + %7 = affine.load %arg0[%arg5] : memref + %8 = arith.subf %7, %1 : f32 + %9 = arith.mulf %8, %8 : f32 + %10 = affine.load %alloca[] : memref + %11 = arith.addf %10, %9 : f32 + affine.store %11, %alloca[] : memref + } + %2 = affine.load %alloca[] : memref + %3 = arith.divf %2, %cst_0 : f32 + %4 = arith.addf %3, %arg4 : f32 + %5 = math.sqrt %4 : f32 + %6 = arith.divf %cst, %5 : f32 + affine.for %arg5 = 0 to 128 { + %7 = affine.load %arg0[%arg5] : memref + %8 = arith.subf %7, %1 : f32 + %9 = arith.mulf %8, %6 : f32 + %10 = affine.load %arg1[%arg5] : memref + %11 = arith.mulf %9, %10 : f32 + %12 = affine.load %arg2[%arg5] : memref + %13 = arith.addf %11, %12 : f32 + affine.store %13, %arg3[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_layer_norm/raised.mlir b/issues/aten_c_kernels/results/aten_layer_norm/raised.mlir new file mode 100644 index 000000000000..927c18c1c387 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm/raised.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 1.280000e+02 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + %alloca_2 = memref.alloca() : memref + affine.store %cst_1, %alloca_2[] : memref + affine.store %cst_1, %alloca[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca_2 : memref) { + ^bb0(%in: f32, %out: f32): + %7 = arith.addf %out, %in : f32 + linalg.yield %7 : f32 + } + %0 = affine.load %alloca_2[] : memref + %1 = arith.divf %0, %cst_0 : f32 + affine.store %1, %alloca_2[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %7 = arith.subf %in, %1 : f32 + %8 = arith.mulf %7, %7 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } + %2 = affine.load %alloca[] : memref + %3 = arith.divf %2, %cst_0 : f32 + %4 = arith.addf %3, %arg4 : f32 + %5 = math.sqrt %4 : f32 + %6 = arith.divf %cst, %5 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg2 : memref, memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_3: f32, %in_4: f32, %out: f32): + %7 = arith.subf %in, %1 : f32 + %8 = arith.mulf %7, %6 : f32 + %9 = arith.mulf %8, %in_3 : f32 + %10 = arith.addf %9, %in_4 : f32 + linalg.yield %10 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu.mlir new file mode 100644 index 000000000000..d854e4a39ef5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu.mlir @@ -0,0 +1,53 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 6.400000e+01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg8 = 0 to 64 { + affine.store %cst_0, %arg6[%arg8] : memref + affine.store %cst_0, %arg7[%arg8] : memref + } + affine.for %arg8 = 0 to 16 { + %0:2 = affine.for %arg9 = 0 to 64 iter_args(%arg10 = %cst_0, %arg11 = %cst_0) -> (f32, f32) { + %1 = affine.load %arg0[%arg8, %arg9] : memref + %2 = affine.load %arg4[%arg9] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg11, %3 : f32 + %5 = affine.load %arg1[%arg8, %arg9] : memref + %6 = affine.load %arg2[%arg8] : memref + %7 = arith.subf %5, %6 : f32 + %8 = arith.mulf %3, %7 : f32 + %9 = arith.addf %arg10, %8 : f32 + %10 = arith.mulf %1, %7 : f32 + %11 = affine.load %arg3[%arg8] : memref + %12 = arith.mulf %10, %11 : f32 + %13 = affine.load %arg6[%arg9] : memref + %14 = arith.addf %13, %12 : f32 + affine.store %14, %arg6[%arg9] : memref + %15 = affine.load %arg0[%arg8, %arg9] : memref + %16 = affine.load %arg7[%arg9] : memref + %17 = arith.addf %16, %15 : f32 + affine.store %17, %arg7[%arg9] : memref + affine.yield %9, %4 : f32, f32 + } + affine.for %arg9 = 0 to 64 { + %1 = affine.load %arg0[%arg8, %arg9] : memref + %2 = affine.load %arg4[%arg9] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = affine.load %arg3[%arg8] : memref + %5 = arith.divf %4, %cst : f32 + %6 = arith.mulf %3, %cst : f32 + %7 = arith.subf %6, %0#1 : f32 + %8 = affine.load %arg1[%arg8, %arg9] : memref + %9 = affine.load %arg2[%arg8] : memref + %10 = arith.subf %8, %9 : f32 + %11 = arith.mulf %10, %4 : f32 + %12 = arith.mulf %11, %4 : f32 + %13 = arith.mulf %12, %0#0 : f32 + %14 = arith.subf %7, %13 : f32 + %15 = arith.mulf %5, %14 : f32 + affine.store %15, %arg5[%arg8, %arg9] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..be0c583d4671 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu/debuf.mlir @@ -0,0 +1,93 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 6.400000e+01 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = bufferization.to_tensor %arg7 : memref + %6 = bufferization.to_tensor %arg6 : memref + %7 = bufferization.to_tensor %arg5 : memref + %8 = bufferization.to_tensor %arg4 : memref + %9 = bufferization.to_tensor %arg3 : memref + %10 = bufferization.to_tensor %arg2 : memref + %11 = bufferization.to_tensor %arg1 : memref + %12 = bufferization.to_tensor %arg0 : memref + %13 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%6 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %14 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%5 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %15:3 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %7, %arg10 = %13, %arg11 = %14) -> (tensor, tensor, tensor) { + %alloca = memref.alloca() : memref + %19 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %19[] : tensor + %alloca_1 = memref.alloca() : memref + %20 = bufferization.to_tensor %alloca_1 : memref + %inserted_2 = tensor.insert %cst into %20[] : tensor + %extracted_slice = tensor.extract_slice %12[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %12[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %11[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %10[%arg8] [1] [1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %9[%arg8] [1] [1] : tensor to tensor + %extracted_slice_7 = tensor.extract_slice %8[0] [%c64] [1] : tensor to tensor + %extracted_slice_8 = tensor.extract_slice %arg10[0] [%c64] [1] : tensor to tensor + %extracted_slice_9 = tensor.extract_slice %arg11[0] [%c64] [1] : tensor to tensor + %21:4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map1, #map1, #map, #map, #map, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_7, %extracted_slice_4, %extracted_slice_5, %extracted_slice_6, %extracted_slice_3 : tensor, tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_8, %extracted_slice_9, %inserted, %inserted_2 : tensor, tensor, tensor, tensor) { + ^bb0(%in: f32, %in_19: f32, %in_20: f32, %in_21: f32, %in_22: f32, %in_23: f32, %out: f32, %out_24: f32, %out_25: f32, %out_26: f32): + %23 = arith.mulf %in, %in_19 : f32 + %24 = arith.addf %out_26, %23 : f32 + %25 = arith.subf %in_20, %in_21 : f32 + %26 = arith.mulf %23, %25 : f32 + %27 = arith.addf %out_25, %26 : f32 + %28 = arith.mulf %in, %25 : f32 + %29 = arith.mulf %28, %in_22 : f32 + %30 = arith.addf %out, %29 : f32 + %31 = arith.addf %out_24, %in_23 : f32 + linalg.yield %30, %31, %27, %24 : f32, f32, f32, f32 + } -> (tensor, tensor, tensor, tensor) + %inserted_slice = tensor.insert_slice %21#1 into %arg11[0] [%c64] [1] : tensor into tensor + %inserted_slice_10 = tensor.insert_slice %21#0 into %arg10[0] [%c64] [1] : tensor into tensor + %extracted = tensor.extract %21#2[] : tensor + %extracted_11 = tensor.extract %21#3[] : tensor + %extracted_slice_12 = tensor.extract_slice %arg9[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_13 = tensor.extract_slice %4[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_14 = tensor.extract_slice %3[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_15 = tensor.extract_slice %2[%arg8] [1] [1] : tensor to tensor + %extracted_slice_16 = tensor.extract_slice %1[%arg8] [1] [1] : tensor to tensor + %extracted_slice_17 = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1, #map, #map1, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_13, %extracted_slice_17, %extracted_slice_16, %extracted_slice_14, %extracted_slice_15 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_12 : tensor) { + ^bb0(%in: f32, %in_19: f32, %in_20: f32, %in_21: f32, %in_22: f32, %out: f32): + %23 = arith.mulf %in, %in_19 : f32 + %24 = arith.divf %in_20, %cst_0 : f32 + %25 = arith.mulf %23, %cst_0 : f32 + %26 = arith.subf %25, %extracted_11 : f32 + %27 = arith.subf %in_21, %in_22 : f32 + %28 = arith.mulf %27, %in_20 : f32 + %29 = arith.mulf %28, %in_20 : f32 + %30 = arith.mulf %29, %extracted : f32 + %31 = arith.subf %26, %30 : f32 + %32 = arith.mulf %24, %31 : f32 + linalg.yield %32 : f32 + } -> tensor + %inserted_slice_18 = tensor.insert_slice %22 into %arg9[%arg8, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice_18, %inserted_slice_10, %inserted_slice : tensor, tensor, tensor + } + %16 = bufferization.to_memref %15#2 : memref + memref.copy %16, %arg7 : memref to memref + %17 = bufferization.to_memref %15#1 : memref + memref.copy %17, %arg6 : memref to memref + %18 = bufferization.to_memref %15#0 : memref + memref.copy %18, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu/matched.mlir new file mode 100644 index 000000000000..942a04c13655 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu/matched.mlir @@ -0,0 +1,87 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 6.400000e+01 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = bufferization.to_tensor %arg7 : memref + %6 = bufferization.to_tensor %arg6 : memref + %7 = bufferization.to_tensor %arg5 : memref + %8 = bufferization.to_tensor %arg4 : memref + %9 = bufferization.to_tensor %arg3 : memref + %10 = bufferization.to_tensor %arg2 : memref + %11 = bufferization.to_tensor %arg1 : memref + %12 = bufferization.to_tensor %arg0 : memref + %13 = kernel.launch @memset_zero_1D_f32(%6) : (tensor) -> tensor + %14 = kernel.launch @memset_zero_1D_f32(%5) : (tensor) -> tensor + %15:3 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %7, %arg10 = %13, %arg11 = %14) -> (tensor, tensor, tensor) { + %alloca = memref.alloca() : memref + %19 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %19[] : tensor + %alloca_1 = memref.alloca() : memref + %20 = bufferization.to_tensor %alloca_1 : memref + %inserted_2 = tensor.insert %cst into %20[] : tensor + %extracted_slice = tensor.extract_slice %12[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %12[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %11[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %10[%arg8] [1] [1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %9[%arg8] [1] [1] : tensor to tensor + %extracted_slice_7 = tensor.extract_slice %8[0] [%c64] [1] : tensor to tensor + %extracted_slice_8 = tensor.extract_slice %arg10[0] [%c64] [1] : tensor to tensor + %extracted_slice_9 = tensor.extract_slice %arg11[0] [%c64] [1] : tensor to tensor + %21:4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map1, #map1, #map, #map, #map, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_7, %extracted_slice_4, %extracted_slice_5, %extracted_slice_6, %extracted_slice_3 : tensor, tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_8, %extracted_slice_9, %inserted, %inserted_2 : tensor, tensor, tensor, tensor) { + ^bb0(%in: f32, %in_19: f32, %in_20: f32, %in_21: f32, %in_22: f32, %in_23: f32, %out: f32, %out_24: f32, %out_25: f32, %out_26: f32): + %23 = arith.mulf %in, %in_19 : f32 + %24 = arith.addf %out_26, %23 : f32 + %25 = arith.subf %in_20, %in_21 : f32 + %26 = arith.mulf %23, %25 : f32 + %27 = arith.addf %out_25, %26 : f32 + %28 = arith.mulf %in, %25 : f32 + %29 = arith.mulf %28, %in_22 : f32 + %30 = arith.addf %out, %29 : f32 + %31 = arith.addf %out_24, %in_23 : f32 + linalg.yield %30, %31, %27, %24 : f32, f32, f32, f32 + } -> (tensor, tensor, tensor, tensor) + %inserted_slice = tensor.insert_slice %21#1 into %arg11[0] [%c64] [1] : tensor into tensor + %inserted_slice_10 = tensor.insert_slice %21#0 into %arg10[0] [%c64] [1] : tensor into tensor + %extracted = tensor.extract %21#2[] : tensor + %extracted_11 = tensor.extract %21#3[] : tensor + %extracted_slice_12 = tensor.extract_slice %arg9[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_13 = tensor.extract_slice %4[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_14 = tensor.extract_slice %3[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_15 = tensor.extract_slice %2[%arg8] [1] [1] : tensor to tensor + %extracted_slice_16 = tensor.extract_slice %1[%arg8] [1] [1] : tensor to tensor + %extracted_slice_17 = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1, #map, #map1, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_13, %extracted_slice_17, %extracted_slice_16, %extracted_slice_14, %extracted_slice_15 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_12 : tensor) { + ^bb0(%in: f32, %in_19: f32, %in_20: f32, %in_21: f32, %in_22: f32, %out: f32): + %23 = arith.mulf %in, %in_19 : f32 + %24 = arith.divf %in_20, %cst_0 : f32 + %25 = arith.mulf %23, %cst_0 : f32 + %26 = arith.subf %25, %extracted_11 : f32 + %27 = arith.subf %in_21, %in_22 : f32 + %28 = arith.mulf %27, %in_20 : f32 + %29 = arith.mulf %28, %in_20 : f32 + %30 = arith.mulf %29, %extracted : f32 + %31 = arith.subf %26, %30 : f32 + %32 = arith.mulf %24, %31 : f32 + linalg.yield %32 : f32 + } -> tensor + %inserted_slice_18 = tensor.insert_slice %22 into %arg9[%arg8, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice_18, %inserted_slice_10, %inserted_slice : tensor, tensor, tensor + } + %16 = bufferization.to_memref %15#2 : memref + memref.copy %16, %arg7 : memref to memref + %17 = bufferization.to_memref %15#1 : memref + memref.copy %17, %arg6 : memref to memref + %18 = bufferization.to_memref %15#0 : memref + memref.copy %18, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu/orig.mlir new file mode 100644 index 000000000000..d854e4a39ef5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu/orig.mlir @@ -0,0 +1,53 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 6.400000e+01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg8 = 0 to 64 { + affine.store %cst_0, %arg6[%arg8] : memref + affine.store %cst_0, %arg7[%arg8] : memref + } + affine.for %arg8 = 0 to 16 { + %0:2 = affine.for %arg9 = 0 to 64 iter_args(%arg10 = %cst_0, %arg11 = %cst_0) -> (f32, f32) { + %1 = affine.load %arg0[%arg8, %arg9] : memref + %2 = affine.load %arg4[%arg9] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg11, %3 : f32 + %5 = affine.load %arg1[%arg8, %arg9] : memref + %6 = affine.load %arg2[%arg8] : memref + %7 = arith.subf %5, %6 : f32 + %8 = arith.mulf %3, %7 : f32 + %9 = arith.addf %arg10, %8 : f32 + %10 = arith.mulf %1, %7 : f32 + %11 = affine.load %arg3[%arg8] : memref + %12 = arith.mulf %10, %11 : f32 + %13 = affine.load %arg6[%arg9] : memref + %14 = arith.addf %13, %12 : f32 + affine.store %14, %arg6[%arg9] : memref + %15 = affine.load %arg0[%arg8, %arg9] : memref + %16 = affine.load %arg7[%arg9] : memref + %17 = arith.addf %16, %15 : f32 + affine.store %17, %arg7[%arg9] : memref + affine.yield %9, %4 : f32, f32 + } + affine.for %arg9 = 0 to 64 { + %1 = affine.load %arg0[%arg8, %arg9] : memref + %2 = affine.load %arg4[%arg9] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = affine.load %arg3[%arg8] : memref + %5 = arith.divf %4, %cst : f32 + %6 = arith.mulf %3, %cst : f32 + %7 = arith.subf %6, %0#1 : f32 + %8 = affine.load %arg1[%arg8, %arg9] : memref + %9 = affine.load %arg2[%arg8] : memref + %10 = arith.subf %8, %9 : f32 + %11 = arith.mulf %10, %4 : f32 + %12 = arith.mulf %11, %4 : f32 + %13 = arith.mulf %12, %0#0 : f32 + %14 = arith.subf %7, %13 : f32 + %15 = arith.mulf %5, %14 : f32 + affine.store %15, %arg5[%arg8, %arg9] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu/raised.mlir new file mode 100644 index 000000000000..9904cecfc894 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu/raised.mlir @@ -0,0 +1,70 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %cst = arith.constant 6.400000e+01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg6 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg7 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + affine.for %arg8 = 0 to 16 { + %alloca = memref.alloca() : memref + affine.store %cst_0, %alloca[] : memref + %alloca_1 = memref.alloca() : memref + affine.store %cst_0, %alloca_1[] : memref + %subview = memref.subview %arg0[%arg8, 0] [1, %c64] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg4[0] [%c64] [1] : memref to memref> + %subview_3 = memref.subview %arg1[%arg8, 0] [1, %c64] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg2[%arg8] [1] [1] : memref to memref> + %subview_5 = memref.subview %arg3[%arg8] [1] [1] : memref to memref> + %subview_6 = memref.subview %arg0[%arg8, 0] [1, %c64] [1, 1] : memref to memref> + %subview_7 = memref.subview %arg6[0] [%c64] [1] : memref to memref> + %subview_8 = memref.subview %arg7[0] [%c64] [1] : memref to memref> + %subview_9 = memref.subview %alloca[] [] [] : memref to memref> + %subview_10 = memref.subview %alloca_1[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map1, #map1, #map, #map, #map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview, %subview_2, %subview_3, %subview_4, %subview_5, %subview_6 : memref>, memref>, memref>, memref>, memref>, memref>) outs(%subview_7, %subview_8, %subview_9, %subview_10 : memref>, memref>, memref>, memref>) { + ^bb0(%in: f32, %in_17: f32, %in_18: f32, %in_19: f32, %in_20: f32, %in_21: f32, %out: f32, %out_22: f32, %out_23: f32, %out_24: f32): + %2 = arith.mulf %in, %in_17 : f32 + %3 = arith.addf %out_24, %2 : f32 + %4 = arith.subf %in_18, %in_19 : f32 + %5 = arith.mulf %2, %4 : f32 + %6 = arith.addf %out_23, %5 : f32 + %7 = arith.mulf %in, %4 : f32 + %8 = arith.mulf %7, %in_20 : f32 + %9 = arith.addf %out, %8 : f32 + %10 = arith.addf %out_22, %in_21 : f32 + linalg.yield %9, %10, %6, %3 : f32, f32, f32, f32 + } + %0 = affine.load %alloca[] : memref + %1 = affine.load %alloca_1[] : memref + %subview_11 = memref.subview %arg0[%arg8, 0] [1, %c64] [1, 1] : memref to memref> + %subview_12 = memref.subview %arg4[0] [%c64] [1] : memref to memref> + %subview_13 = memref.subview %arg3[%arg8] [1] [1] : memref to memref> + %subview_14 = memref.subview %arg1[%arg8, 0] [1, %c64] [1, 1] : memref to memref> + %subview_15 = memref.subview %arg2[%arg8] [1] [1] : memref to memref> + %subview_16 = memref.subview %arg5[%arg8, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1, #map, #map1, #map], iterator_types = ["parallel"]} ins(%subview_11, %subview_12, %subview_13, %subview_14, %subview_15 : memref>, memref>, memref>, memref>, memref>) outs(%subview_16 : memref>) { + ^bb0(%in: f32, %in_17: f32, %in_18: f32, %in_19: f32, %in_20: f32, %out: f32): + %2 = arith.mulf %in, %in_17 : f32 + %3 = arith.divf %in_18, %cst : f32 + %4 = arith.mulf %2, %cst : f32 + %5 = arith.subf %4, %1 : f32 + %6 = arith.subf %in_19, %in_20 : f32 + %7 = arith.mulf %6, %in_18 : f32 + %8 = arith.mulf %7, %in_18 : f32 + %9 = arith.mulf %8, %0 : f32 + %10 = arith.subf %5, %9 : f32 + %11 = arith.mulf %3, %10 : f32 + linalg.yield %11 : f32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..be0c583d4671 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu_debuf.mlir @@ -0,0 +1,93 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 6.400000e+01 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = bufferization.to_tensor %arg7 : memref + %6 = bufferization.to_tensor %arg6 : memref + %7 = bufferization.to_tensor %arg5 : memref + %8 = bufferization.to_tensor %arg4 : memref + %9 = bufferization.to_tensor %arg3 : memref + %10 = bufferization.to_tensor %arg2 : memref + %11 = bufferization.to_tensor %arg1 : memref + %12 = bufferization.to_tensor %arg0 : memref + %13 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%6 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %14 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%5 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %15:3 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %7, %arg10 = %13, %arg11 = %14) -> (tensor, tensor, tensor) { + %alloca = memref.alloca() : memref + %19 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %19[] : tensor + %alloca_1 = memref.alloca() : memref + %20 = bufferization.to_tensor %alloca_1 : memref + %inserted_2 = tensor.insert %cst into %20[] : tensor + %extracted_slice = tensor.extract_slice %12[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %12[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %11[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %10[%arg8] [1] [1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %9[%arg8] [1] [1] : tensor to tensor + %extracted_slice_7 = tensor.extract_slice %8[0] [%c64] [1] : tensor to tensor + %extracted_slice_8 = tensor.extract_slice %arg10[0] [%c64] [1] : tensor to tensor + %extracted_slice_9 = tensor.extract_slice %arg11[0] [%c64] [1] : tensor to tensor + %21:4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map1, #map1, #map, #map, #map, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_7, %extracted_slice_4, %extracted_slice_5, %extracted_slice_6, %extracted_slice_3 : tensor, tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_8, %extracted_slice_9, %inserted, %inserted_2 : tensor, tensor, tensor, tensor) { + ^bb0(%in: f32, %in_19: f32, %in_20: f32, %in_21: f32, %in_22: f32, %in_23: f32, %out: f32, %out_24: f32, %out_25: f32, %out_26: f32): + %23 = arith.mulf %in, %in_19 : f32 + %24 = arith.addf %out_26, %23 : f32 + %25 = arith.subf %in_20, %in_21 : f32 + %26 = arith.mulf %23, %25 : f32 + %27 = arith.addf %out_25, %26 : f32 + %28 = arith.mulf %in, %25 : f32 + %29 = arith.mulf %28, %in_22 : f32 + %30 = arith.addf %out, %29 : f32 + %31 = arith.addf %out_24, %in_23 : f32 + linalg.yield %30, %31, %27, %24 : f32, f32, f32, f32 + } -> (tensor, tensor, tensor, tensor) + %inserted_slice = tensor.insert_slice %21#1 into %arg11[0] [%c64] [1] : tensor into tensor + %inserted_slice_10 = tensor.insert_slice %21#0 into %arg10[0] [%c64] [1] : tensor into tensor + %extracted = tensor.extract %21#2[] : tensor + %extracted_11 = tensor.extract %21#3[] : tensor + %extracted_slice_12 = tensor.extract_slice %arg9[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_13 = tensor.extract_slice %4[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_14 = tensor.extract_slice %3[%arg8, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_15 = tensor.extract_slice %2[%arg8] [1] [1] : tensor to tensor + %extracted_slice_16 = tensor.extract_slice %1[%arg8] [1] [1] : tensor to tensor + %extracted_slice_17 = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1, #map, #map1, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_13, %extracted_slice_17, %extracted_slice_16, %extracted_slice_14, %extracted_slice_15 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_12 : tensor) { + ^bb0(%in: f32, %in_19: f32, %in_20: f32, %in_21: f32, %in_22: f32, %out: f32): + %23 = arith.mulf %in, %in_19 : f32 + %24 = arith.divf %in_20, %cst_0 : f32 + %25 = arith.mulf %23, %cst_0 : f32 + %26 = arith.subf %25, %extracted_11 : f32 + %27 = arith.subf %in_21, %in_22 : f32 + %28 = arith.mulf %27, %in_20 : f32 + %29 = arith.mulf %28, %in_20 : f32 + %30 = arith.mulf %29, %extracted : f32 + %31 = arith.subf %26, %30 : f32 + %32 = arith.mulf %24, %31 : f32 + linalg.yield %32 : f32 + } -> tensor + %inserted_slice_18 = tensor.insert_slice %22 into %arg9[%arg8, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice_18, %inserted_slice_10, %inserted_slice : tensor, tensor, tensor + } + %16 = bufferization.to_memref %15#2 : memref + memref.copy %16, %arg7 : memref to memref + %17 = bufferization.to_memref %15#1 : memref + memref.copy %17, %arg6 : memref to memref + %18 = bufferization.to_memref %15#0 : memref + memref.copy %18, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..9904cecfc894 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm_backward_cpu_linalg.mlir @@ -0,0 +1,70 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %cst = arith.constant 6.400000e+01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg6 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg7 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_0 : f32 + } + affine.for %arg8 = 0 to 16 { + %alloca = memref.alloca() : memref + affine.store %cst_0, %alloca[] : memref + %alloca_1 = memref.alloca() : memref + affine.store %cst_0, %alloca_1[] : memref + %subview = memref.subview %arg0[%arg8, 0] [1, %c64] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg4[0] [%c64] [1] : memref to memref> + %subview_3 = memref.subview %arg1[%arg8, 0] [1, %c64] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg2[%arg8] [1] [1] : memref to memref> + %subview_5 = memref.subview %arg3[%arg8] [1] [1] : memref to memref> + %subview_6 = memref.subview %arg0[%arg8, 0] [1, %c64] [1, 1] : memref to memref> + %subview_7 = memref.subview %arg6[0] [%c64] [1] : memref to memref> + %subview_8 = memref.subview %arg7[0] [%c64] [1] : memref to memref> + %subview_9 = memref.subview %alloca[] [] [] : memref to memref> + %subview_10 = memref.subview %alloca_1[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map1, #map1, #map, #map, #map, #map1, #map1], iterator_types = ["reduction"]} ins(%subview, %subview_2, %subview_3, %subview_4, %subview_5, %subview_6 : memref>, memref>, memref>, memref>, memref>, memref>) outs(%subview_7, %subview_8, %subview_9, %subview_10 : memref>, memref>, memref>, memref>) { + ^bb0(%in: f32, %in_17: f32, %in_18: f32, %in_19: f32, %in_20: f32, %in_21: f32, %out: f32, %out_22: f32, %out_23: f32, %out_24: f32): + %2 = arith.mulf %in, %in_17 : f32 + %3 = arith.addf %out_24, %2 : f32 + %4 = arith.subf %in_18, %in_19 : f32 + %5 = arith.mulf %2, %4 : f32 + %6 = arith.addf %out_23, %5 : f32 + %7 = arith.mulf %in, %4 : f32 + %8 = arith.mulf %7, %in_20 : f32 + %9 = arith.addf %out, %8 : f32 + %10 = arith.addf %out_22, %in_21 : f32 + linalg.yield %9, %10, %6, %3 : f32, f32, f32, f32 + } + %0 = affine.load %alloca[] : memref + %1 = affine.load %alloca_1[] : memref + %subview_11 = memref.subview %arg0[%arg8, 0] [1, %c64] [1, 1] : memref to memref> + %subview_12 = memref.subview %arg4[0] [%c64] [1] : memref to memref> + %subview_13 = memref.subview %arg3[%arg8] [1] [1] : memref to memref> + %subview_14 = memref.subview %arg1[%arg8, 0] [1, %c64] [1, 1] : memref to memref> + %subview_15 = memref.subview %arg2[%arg8] [1] [1] : memref to memref> + %subview_16 = memref.subview %arg5[%arg8, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1, #map, #map1, #map], iterator_types = ["parallel"]} ins(%subview_11, %subview_12, %subview_13, %subview_14, %subview_15 : memref>, memref>, memref>, memref>, memref>) outs(%subview_16 : memref>) { + ^bb0(%in: f32, %in_17: f32, %in_18: f32, %in_19: f32, %in_20: f32, %out: f32): + %2 = arith.mulf %in, %in_17 : f32 + %3 = arith.divf %in_18, %cst : f32 + %4 = arith.mulf %2, %cst : f32 + %5 = arith.subf %4, %1 : f32 + %6 = arith.subf %in_19, %in_20 : f32 + %7 = arith.mulf %6, %in_18 : f32 + %8 = arith.mulf %7, %in_18 : f32 + %9 = arith.mulf %8, %0 : f32 + %10 = arith.subf %5, %9 : f32 + %11 = arith.mulf %3, %10 : f32 + linalg.yield %11 : f32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend.mlir b/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend.mlir new file mode 100644 index 000000000000..a442d8f15e68 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm_cpu_backend(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 6.400000e+01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + affine.for %arg7 = 0 to 16 { + %0 = affine.for %arg8 = 0 to 64 iter_args(%arg9 = %cst_1) -> (f32) { + %7 = affine.load %arg0[%arg7, %arg8] : memref + %8 = arith.addf %arg9, %7 : f32 + affine.yield %8 : f32 + } + %1 = arith.divf %0, %cst_0 : f32 + affine.store %1, %arg5[%arg7] : memref + %2 = affine.for %arg8 = 0 to 64 iter_args(%arg9 = %cst_1) -> (f32) { + %7 = affine.load %arg0[%arg7, %arg8] : memref + %8 = arith.subf %7, %1 : f32 + %9 = arith.mulf %8, %8 : f32 + %10 = arith.addf %arg9, %9 : f32 + affine.yield %10 : f32 + } + %3 = arith.divf %2, %cst_0 : f32 + %4 = arith.addf %3, %arg3 : f32 + %5 = math.sqrt %4 : f32 + %6 = arith.divf %cst, %5 : f32 + affine.store %6, %arg6[%arg7] : memref + affine.for %arg8 = 0 to 64 { + %7 = affine.load %arg0[%arg7, %arg8] : memref + %8 = affine.load %arg5[%arg7] : memref + %9 = arith.subf %7, %8 : f32 + %10 = affine.load %arg6[%arg7] : memref + %11 = arith.mulf %9, %10 : f32 + %12 = affine.load %arg1[%arg8] : memref + %13 = arith.mulf %11, %12 : f32 + %14 = affine.load %arg2[%arg8] : memref + %15 = arith.addf %13, %14 : f32 + affine.store %15, %arg4[%arg7, %arg8] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend/debuf.mlir b/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend/debuf.mlir new file mode 100644 index 000000000000..0aa7f7c11225 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend/debuf.mlir @@ -0,0 +1,72 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm_cpu_backend(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 6.400000e+01 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = bufferization.to_tensor %arg6 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7:3 = affine.for %arg7 = 0 to 16 iter_args(%arg8 = %5, %arg9 = %4, %arg10 = %3) -> (tensor, tensor, tensor) { + %alloca = memref.alloca() : memref + %11 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %11[] : tensor + %extracted_slice = tensor.extract_slice %6[%arg7, 0] [1, %c64] [1, 1] : tensor to tensor + %12 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %21 = arith.addf %out, %in : f32 + linalg.yield %21 : f32 + } -> tensor + %extracted = tensor.extract %12[] : tensor + %13 = arith.divf %extracted, %cst_0 : f32 + %inserted_2 = tensor.insert %13 into %arg9[%arg7] : tensor + %alloca_3 = memref.alloca() : memref + %14 = bufferization.to_tensor %alloca_3 : memref + %inserted_4 = tensor.insert %cst into %14[] : tensor + %extracted_slice_5 = tensor.extract_slice %6[%arg7, 0] [1, %c64] [1, 1] : tensor to tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_5 : tensor) outs(%inserted_4 : tensor) { + ^bb0(%in: f32, %out: f32): + %21 = arith.subf %in, %13 : f32 + %22 = arith.mulf %21, %21 : f32 + %23 = arith.addf %out, %22 : f32 + linalg.yield %23 : f32 + } -> tensor + %extracted_6 = tensor.extract %15[] : tensor + %16 = arith.divf %extracted_6, %cst_0 : f32 + %17 = arith.addf %16, %arg3 : f32 + %18 = math.sqrt %17 : f32 + %19 = arith.divf %cst_1, %18 : f32 + %inserted_7 = tensor.insert %19 into %arg10[%arg7] : tensor + %extracted_slice_8 = tensor.extract_slice %arg8[%arg7, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_9 = tensor.extract_slice %inserted_2[%arg7] [1] [1] : tensor to tensor + %extracted_slice_10 = tensor.extract_slice %inserted_7[%arg7] [1] [1] : tensor to tensor + %extracted_slice_11 = tensor.extract_slice %2[%arg7, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_12 = tensor.extract_slice %1[0] [%c64] [1] : tensor to tensor + %extracted_slice_13 = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %20 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_11, %extracted_slice_9, %extracted_slice_10, %extracted_slice_12, %extracted_slice_13 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_8 : tensor) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %in_17: f32, %out: f32): + %21 = arith.subf %in, %in_14 : f32 + %22 = arith.mulf %21, %in_15 : f32 + %23 = arith.mulf %22, %in_16 : f32 + %24 = arith.addf %23, %in_17 : f32 + linalg.yield %24 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %20 into %arg8[%arg7, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_2, %inserted_7 : tensor, tensor, tensor + } + %8 = bufferization.to_memref %7#2 : memref + memref.copy %8, %arg6 : memref to memref + %9 = bufferization.to_memref %7#1 : memref + memref.copy %9, %arg5 : memref to memref + %10 = bufferization.to_memref %7#0 : memref + memref.copy %10, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend/matched.mlir b/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend/matched.mlir new file mode 100644 index 000000000000..0aa7f7c11225 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend/matched.mlir @@ -0,0 +1,72 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm_cpu_backend(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 6.400000e+01 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = bufferization.to_tensor %arg6 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7:3 = affine.for %arg7 = 0 to 16 iter_args(%arg8 = %5, %arg9 = %4, %arg10 = %3) -> (tensor, tensor, tensor) { + %alloca = memref.alloca() : memref + %11 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %11[] : tensor + %extracted_slice = tensor.extract_slice %6[%arg7, 0] [1, %c64] [1, 1] : tensor to tensor + %12 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %21 = arith.addf %out, %in : f32 + linalg.yield %21 : f32 + } -> tensor + %extracted = tensor.extract %12[] : tensor + %13 = arith.divf %extracted, %cst_0 : f32 + %inserted_2 = tensor.insert %13 into %arg9[%arg7] : tensor + %alloca_3 = memref.alloca() : memref + %14 = bufferization.to_tensor %alloca_3 : memref + %inserted_4 = tensor.insert %cst into %14[] : tensor + %extracted_slice_5 = tensor.extract_slice %6[%arg7, 0] [1, %c64] [1, 1] : tensor to tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_5 : tensor) outs(%inserted_4 : tensor) { + ^bb0(%in: f32, %out: f32): + %21 = arith.subf %in, %13 : f32 + %22 = arith.mulf %21, %21 : f32 + %23 = arith.addf %out, %22 : f32 + linalg.yield %23 : f32 + } -> tensor + %extracted_6 = tensor.extract %15[] : tensor + %16 = arith.divf %extracted_6, %cst_0 : f32 + %17 = arith.addf %16, %arg3 : f32 + %18 = math.sqrt %17 : f32 + %19 = arith.divf %cst_1, %18 : f32 + %inserted_7 = tensor.insert %19 into %arg10[%arg7] : tensor + %extracted_slice_8 = tensor.extract_slice %arg8[%arg7, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_9 = tensor.extract_slice %inserted_2[%arg7] [1] [1] : tensor to tensor + %extracted_slice_10 = tensor.extract_slice %inserted_7[%arg7] [1] [1] : tensor to tensor + %extracted_slice_11 = tensor.extract_slice %2[%arg7, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_12 = tensor.extract_slice %1[0] [%c64] [1] : tensor to tensor + %extracted_slice_13 = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %20 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_11, %extracted_slice_9, %extracted_slice_10, %extracted_slice_12, %extracted_slice_13 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_8 : tensor) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %in_17: f32, %out: f32): + %21 = arith.subf %in, %in_14 : f32 + %22 = arith.mulf %21, %in_15 : f32 + %23 = arith.mulf %22, %in_16 : f32 + %24 = arith.addf %23, %in_17 : f32 + linalg.yield %24 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %20 into %arg8[%arg7, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_2, %inserted_7 : tensor, tensor, tensor + } + %8 = bufferization.to_memref %7#2 : memref + memref.copy %8, %arg6 : memref to memref + %9 = bufferization.to_memref %7#1 : memref + memref.copy %9, %arg5 : memref to memref + %10 = bufferization.to_memref %7#0 : memref + memref.copy %10, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend/orig.mlir b/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend/orig.mlir new file mode 100644 index 000000000000..a442d8f15e68 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend/orig.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm_cpu_backend(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 6.400000e+01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + affine.for %arg7 = 0 to 16 { + %0 = affine.for %arg8 = 0 to 64 iter_args(%arg9 = %cst_1) -> (f32) { + %7 = affine.load %arg0[%arg7, %arg8] : memref + %8 = arith.addf %arg9, %7 : f32 + affine.yield %8 : f32 + } + %1 = arith.divf %0, %cst_0 : f32 + affine.store %1, %arg5[%arg7] : memref + %2 = affine.for %arg8 = 0 to 64 iter_args(%arg9 = %cst_1) -> (f32) { + %7 = affine.load %arg0[%arg7, %arg8] : memref + %8 = arith.subf %7, %1 : f32 + %9 = arith.mulf %8, %8 : f32 + %10 = arith.addf %arg9, %9 : f32 + affine.yield %10 : f32 + } + %3 = arith.divf %2, %cst_0 : f32 + %4 = arith.addf %3, %arg3 : f32 + %5 = math.sqrt %4 : f32 + %6 = arith.divf %cst, %5 : f32 + affine.store %6, %arg6[%arg7] : memref + affine.for %arg8 = 0 to 64 { + %7 = affine.load %arg0[%arg7, %arg8] : memref + %8 = affine.load %arg5[%arg7] : memref + %9 = arith.subf %7, %8 : f32 + %10 = affine.load %arg6[%arg7] : memref + %11 = arith.mulf %9, %10 : f32 + %12 = affine.load %arg1[%arg8] : memref + %13 = arith.mulf %11, %12 : f32 + %14 = affine.load %arg2[%arg8] : memref + %15 = arith.addf %13, %14 : f32 + affine.store %15, %arg4[%arg7, %arg8] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend/raised.mlir b/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend/raised.mlir new file mode 100644 index 000000000000..09c86dbd1178 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend/raised.mlir @@ -0,0 +1,55 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm_cpu_backend(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 6.400000e+01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + affine.for %arg7 = 0 to 16 { + %alloca = memref.alloca() : memref + affine.store %cst_1, %alloca[] : memref + %subview = memref.subview %arg0[%arg7, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %7 = arith.addf %out, %in : f32 + linalg.yield %7 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst_0 : f32 + affine.store %1, %arg5[%arg7] : memref + %alloca_2 = memref.alloca() : memref + affine.store %cst_1, %alloca_2[] : memref + %subview_3 = memref.subview %arg0[%arg7, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview_3 : memref>) outs(%alloca_2 : memref) { + ^bb0(%in: f32, %out: f32): + %7 = arith.subf %in, %1 : f32 + %8 = arith.mulf %7, %7 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } + %2 = affine.load %alloca_2[] : memref + %3 = arith.divf %2, %cst_0 : f32 + %4 = arith.addf %3, %arg3 : f32 + %5 = math.sqrt %4 : f32 + %6 = arith.divf %cst, %5 : f32 + affine.store %6, %arg6[%arg7] : memref + %subview_4 = memref.subview %arg0[%arg7, 0] [1, %c64] [1, 1] : memref to memref> + %subview_5 = memref.subview %arg5[%arg7] [1] [1] : memref to memref> + %subview_6 = memref.subview %arg6[%arg7] [1] [1] : memref to memref> + %subview_7 = memref.subview %arg1[0] [%c64] [1] : memref to memref> + %subview_8 = memref.subview %arg2[0] [%c64] [1] : memref to memref> + %subview_9 = memref.subview %arg4[%arg7, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map1, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview_4, %subview_5, %subview_6, %subview_7, %subview_8 : memref>, memref>, memref>, memref>, memref>) outs(%subview_9 : memref>) { + ^bb0(%in: f32, %in_10: f32, %in_11: f32, %in_12: f32, %in_13: f32, %out: f32): + %7 = arith.subf %in, %in_10 : f32 + %8 = arith.mulf %7, %in_11 : f32 + %9 = arith.mulf %8, %in_12 : f32 + %10 = arith.addf %9, %in_13 : f32 + linalg.yield %10 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend_debuf.mlir b/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend_debuf.mlir new file mode 100644 index 000000000000..0aa7f7c11225 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend_debuf.mlir @@ -0,0 +1,72 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm_cpu_backend(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 6.400000e+01 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = bufferization.to_tensor %arg6 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7:3 = affine.for %arg7 = 0 to 16 iter_args(%arg8 = %5, %arg9 = %4, %arg10 = %3) -> (tensor, tensor, tensor) { + %alloca = memref.alloca() : memref + %11 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %11[] : tensor + %extracted_slice = tensor.extract_slice %6[%arg7, 0] [1, %c64] [1, 1] : tensor to tensor + %12 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %21 = arith.addf %out, %in : f32 + linalg.yield %21 : f32 + } -> tensor + %extracted = tensor.extract %12[] : tensor + %13 = arith.divf %extracted, %cst_0 : f32 + %inserted_2 = tensor.insert %13 into %arg9[%arg7] : tensor + %alloca_3 = memref.alloca() : memref + %14 = bufferization.to_tensor %alloca_3 : memref + %inserted_4 = tensor.insert %cst into %14[] : tensor + %extracted_slice_5 = tensor.extract_slice %6[%arg7, 0] [1, %c64] [1, 1] : tensor to tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_5 : tensor) outs(%inserted_4 : tensor) { + ^bb0(%in: f32, %out: f32): + %21 = arith.subf %in, %13 : f32 + %22 = arith.mulf %21, %21 : f32 + %23 = arith.addf %out, %22 : f32 + linalg.yield %23 : f32 + } -> tensor + %extracted_6 = tensor.extract %15[] : tensor + %16 = arith.divf %extracted_6, %cst_0 : f32 + %17 = arith.addf %16, %arg3 : f32 + %18 = math.sqrt %17 : f32 + %19 = arith.divf %cst_1, %18 : f32 + %inserted_7 = tensor.insert %19 into %arg10[%arg7] : tensor + %extracted_slice_8 = tensor.extract_slice %arg8[%arg7, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_9 = tensor.extract_slice %inserted_2[%arg7] [1] [1] : tensor to tensor + %extracted_slice_10 = tensor.extract_slice %inserted_7[%arg7] [1] [1] : tensor to tensor + %extracted_slice_11 = tensor.extract_slice %2[%arg7, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_12 = tensor.extract_slice %1[0] [%c64] [1] : tensor to tensor + %extracted_slice_13 = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %20 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_11, %extracted_slice_9, %extracted_slice_10, %extracted_slice_12, %extracted_slice_13 : tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_8 : tensor) { + ^bb0(%in: f32, %in_14: f32, %in_15: f32, %in_16: f32, %in_17: f32, %out: f32): + %21 = arith.subf %in, %in_14 : f32 + %22 = arith.mulf %21, %in_15 : f32 + %23 = arith.mulf %22, %in_16 : f32 + %24 = arith.addf %23, %in_17 : f32 + linalg.yield %24 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %20 into %arg8[%arg7, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_2, %inserted_7 : tensor, tensor, tensor + } + %8 = bufferization.to_memref %7#2 : memref + memref.copy %8, %arg6 : memref to memref + %9 = bufferization.to_memref %7#1 : memref + memref.copy %9, %arg5 : memref to memref + %10 = bufferization.to_memref %7#0 : memref + memref.copy %10, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend_linalg.mlir b/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend_linalg.mlir new file mode 100644 index 000000000000..09c86dbd1178 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm_cpu_backend_linalg.mlir @@ -0,0 +1,55 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm_cpu_backend(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 6.400000e+01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + affine.for %arg7 = 0 to 16 { + %alloca = memref.alloca() : memref + affine.store %cst_1, %alloca[] : memref + %subview = memref.subview %arg0[%arg7, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %7 = arith.addf %out, %in : f32 + linalg.yield %7 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst_0 : f32 + affine.store %1, %arg5[%arg7] : memref + %alloca_2 = memref.alloca() : memref + affine.store %cst_1, %alloca_2[] : memref + %subview_3 = memref.subview %arg0[%arg7, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview_3 : memref>) outs(%alloca_2 : memref) { + ^bb0(%in: f32, %out: f32): + %7 = arith.subf %in, %1 : f32 + %8 = arith.mulf %7, %7 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } + %2 = affine.load %alloca_2[] : memref + %3 = arith.divf %2, %cst_0 : f32 + %4 = arith.addf %3, %arg3 : f32 + %5 = math.sqrt %4 : f32 + %6 = arith.divf %cst, %5 : f32 + affine.store %6, %arg6[%arg7] : memref + %subview_4 = memref.subview %arg0[%arg7, 0] [1, %c64] [1, 1] : memref to memref> + %subview_5 = memref.subview %arg5[%arg7] [1] [1] : memref to memref> + %subview_6 = memref.subview %arg6[%arg7] [1] [1] : memref to memref> + %subview_7 = memref.subview %arg1[0] [%c64] [1] : memref to memref> + %subview_8 = memref.subview %arg2[0] [%c64] [1] : memref to memref> + %subview_9 = memref.subview %arg4[%arg7, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map1, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview_4, %subview_5, %subview_6, %subview_7, %subview_8 : memref>, memref>, memref>, memref>, memref>) outs(%subview_9 : memref>) { + ^bb0(%in: f32, %in_10: f32, %in_11: f32, %in_12: f32, %in_13: f32, %out: f32): + %7 = arith.subf %in, %in_10 : f32 + %8 = arith.mulf %7, %in_11 : f32 + %9 = arith.mulf %8, %in_12 : f32 + %10 = arith.addf %9, %in_13 : f32 + linalg.yield %10 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_layer_norm_debuf.mlir b/issues/aten_c_kernels/results/aten_layer_norm_debuf.mlir new file mode 100644 index 000000000000..dcd49bd8903e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm_debuf.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.280000e+02 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = tensor.empty() : tensor + %5 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %5[] : tensor + %inserted_2 = tensor.insert %cst into %4[] : tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %15 = arith.addf %out, %in : f32 + linalg.yield %15 : f32 + } -> tensor + %extracted = tensor.extract %6[] : tensor + %7 = arith.divf %extracted, %cst_0 : f32 + %8 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted_2 : tensor) { + ^bb0(%in: f32, %out: f32): + %15 = arith.subf %in, %7 : f32 + %16 = arith.mulf %15, %15 : f32 + %17 = arith.addf %out, %16 : f32 + linalg.yield %17 : f32 + } -> tensor + %extracted_3 = tensor.extract %8[] : tensor + %9 = arith.divf %extracted_3, %cst_0 : f32 + %10 = arith.addf %9, %arg4 : f32 + %11 = math.sqrt %10 : f32 + %12 = arith.divf %cst_1, %11 : f32 + %13 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_4: f32, %in_5: f32, %out: f32): + %15 = arith.subf %in, %7 : f32 + %16 = arith.mulf %15, %12 : f32 + %17 = arith.mulf %16, %in_4 : f32 + %18 = arith.addf %17, %in_5 : f32 + linalg.yield %18 : f32 + } -> tensor + %14 = bufferization.to_memref %13 : memref + memref.copy %14, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_layer_norm_linalg.mlir b/issues/aten_c_kernels/results/aten_layer_norm_linalg.mlir new file mode 100644 index 000000000000..927c18c1c387 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_layer_norm_linalg.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_layer_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 1.280000e+02 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + %alloca_2 = memref.alloca() : memref + affine.store %cst_1, %alloca_2[] : memref + affine.store %cst_1, %alloca[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca_2 : memref) { + ^bb0(%in: f32, %out: f32): + %7 = arith.addf %out, %in : f32 + linalg.yield %7 : f32 + } + %0 = affine.load %alloca_2[] : memref + %1 = arith.divf %0, %cst_0 : f32 + affine.store %1, %alloca_2[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %7 = arith.subf %in, %1 : f32 + %8 = arith.mulf %7, %7 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } + %2 = affine.load %alloca[] : memref + %3 = arith.divf %2, %cst_0 : f32 + %4 = arith.addf %3, %arg4 : f32 + %5 = math.sqrt %4 : f32 + %6 = arith.divf %cst, %5 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg2 : memref, memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_3: f32, %in_4: f32, %out: f32): + %7 = arith.subf %in, %1 : f32 + %8 = arith.mulf %7, %6 : f32 + %9 = arith.mulf %8, %in_3 : f32 + %10 = arith.addf %9, %in_4 : f32 + linalg.yield %10 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lcm_i32.mlir b/issues/aten_c_kernels/results/aten_lcm_i32.mlir new file mode 100644 index 000000000000..9a4829ad0093 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lcm_i32.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lcm_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpi slt, %0, %c0_i32 : i32 + %2 = scf.if %1 -> (i32) { + %9 = arith.subi %c0_i32, %0 : i32 + scf.yield %9 : i32 + } else { + scf.yield %0 : i32 + } + %3 = affine.load %arg1[%arg3] : memref + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = scf.if %4 -> (i32) { + %9 = arith.subi %c0_i32, %3 : i32 + scf.yield %9 : i32 + } else { + scf.yield %3 : i32 + } + %6:2 = scf.while (%arg4 = %5, %arg5 = %2) : (i32, i32) -> (i32, i32) { + %9 = arith.cmpi ne, %arg4, %c0_i32 : i32 + scf.condition(%9) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %9 = arith.remsi %arg4, %arg5 : i32 + scf.yield %9, %arg5 : i32, i32 + } + %7 = arith.cmpi eq, %6#0, %c0_i32 : i32 + %8 = scf.if %7 -> (i32) { + scf.yield %c0_i32 : i32 + } else { + %9 = arith.divsi %2, %6#0 : i32 + %10 = arith.muli %9, %5 : i32 + scf.yield %10 : i32 + } + affine.store %8, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_lcm_i32/debuf.mlir b/issues/aten_c_kernels/results/aten_lcm_i32/debuf.mlir new file mode 100644 index 000000000000..e1c47e72005b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lcm_i32/debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lcm_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.cmpi slt, %in, %c0_i32 : i32 + %6 = arith.subi %c0_i32, %in : i32 + %7 = arith.select %5, %6, %in : i32 + %8 = arith.cmpi slt, %in_0, %c0_i32 : i32 + %9 = arith.subi %c0_i32, %in_0 : i32 + %10 = arith.select %8, %9, %in_0 : i32 + %11:2 = scf.while (%arg3 = %10, %arg4 = %7) : (i32, i32) -> (i32, i32) { + %16 = arith.cmpi ne, %arg3, %c0_i32 : i32 + scf.condition(%16) %arg4, %arg3 : i32, i32 + } do { + ^bb0(%arg3: i32, %arg4: i32): + %16 = arith.remsi %arg3, %arg4 : i32 + scf.yield %16, %arg4 : i32, i32 + } + %12 = arith.cmpi eq, %11#0, %c0_i32 : i32 + %13 = arith.divsi %7, %11#0 : i32 + %14 = arith.muli %13, %10 : i32 + %15 = arith.select %12, %c0_i32, %14 : i32 + linalg.yield %15 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lcm_i32/matched.mlir b/issues/aten_c_kernels/results/aten_lcm_i32/matched.mlir new file mode 100644 index 000000000000..e1c47e72005b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lcm_i32/matched.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lcm_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.cmpi slt, %in, %c0_i32 : i32 + %6 = arith.subi %c0_i32, %in : i32 + %7 = arith.select %5, %6, %in : i32 + %8 = arith.cmpi slt, %in_0, %c0_i32 : i32 + %9 = arith.subi %c0_i32, %in_0 : i32 + %10 = arith.select %8, %9, %in_0 : i32 + %11:2 = scf.while (%arg3 = %10, %arg4 = %7) : (i32, i32) -> (i32, i32) { + %16 = arith.cmpi ne, %arg3, %c0_i32 : i32 + scf.condition(%16) %arg4, %arg3 : i32, i32 + } do { + ^bb0(%arg3: i32, %arg4: i32): + %16 = arith.remsi %arg3, %arg4 : i32 + scf.yield %16, %arg4 : i32, i32 + } + %12 = arith.cmpi eq, %11#0, %c0_i32 : i32 + %13 = arith.divsi %7, %11#0 : i32 + %14 = arith.muli %13, %10 : i32 + %15 = arith.select %12, %c0_i32, %14 : i32 + linalg.yield %15 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lcm_i32/orig.mlir b/issues/aten_c_kernels/results/aten_lcm_i32/orig.mlir new file mode 100644 index 000000000000..9a4829ad0093 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lcm_i32/orig.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lcm_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpi slt, %0, %c0_i32 : i32 + %2 = scf.if %1 -> (i32) { + %9 = arith.subi %c0_i32, %0 : i32 + scf.yield %9 : i32 + } else { + scf.yield %0 : i32 + } + %3 = affine.load %arg1[%arg3] : memref + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = scf.if %4 -> (i32) { + %9 = arith.subi %c0_i32, %3 : i32 + scf.yield %9 : i32 + } else { + scf.yield %3 : i32 + } + %6:2 = scf.while (%arg4 = %5, %arg5 = %2) : (i32, i32) -> (i32, i32) { + %9 = arith.cmpi ne, %arg4, %c0_i32 : i32 + scf.condition(%9) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %9 = arith.remsi %arg4, %arg5 : i32 + scf.yield %9, %arg5 : i32, i32 + } + %7 = arith.cmpi eq, %6#0, %c0_i32 : i32 + %8 = scf.if %7 -> (i32) { + scf.yield %c0_i32 : i32 + } else { + %9 = arith.divsi %2, %6#0 : i32 + %10 = arith.muli %9, %5 : i32 + scf.yield %10 : i32 + } + affine.store %8, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_lcm_i32/raised.mlir b/issues/aten_c_kernels/results/aten_lcm_i32/raised.mlir new file mode 100644 index 000000000000..6ce7f27bf7a6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lcm_i32/raised.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lcm_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %0 = arith.cmpi slt, %in, %c0_i32 : i32 + %1 = arith.subi %c0_i32, %in : i32 + %2 = arith.select %0, %1, %in : i32 + %3 = arith.cmpi slt, %in_0, %c0_i32 : i32 + %4 = arith.subi %c0_i32, %in_0 : i32 + %5 = arith.select %3, %4, %in_0 : i32 + %6:2 = scf.while (%arg3 = %5, %arg4 = %2) : (i32, i32) -> (i32, i32) { + %11 = arith.cmpi ne, %arg3, %c0_i32 : i32 + scf.condition(%11) %arg4, %arg3 : i32, i32 + } do { + ^bb0(%arg3: i32, %arg4: i32): + %11 = arith.remsi %arg3, %arg4 : i32 + scf.yield %11, %arg4 : i32, i32 + } + %7 = arith.cmpi eq, %6#0, %c0_i32 : i32 + %8 = arith.divsi %2, %6#0 : i32 + %9 = arith.muli %8, %5 : i32 + %10 = arith.select %7, %c0_i32, %9 : i32 + linalg.yield %10 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lcm_i32_debuf.mlir b/issues/aten_c_kernels/results/aten_lcm_i32_debuf.mlir new file mode 100644 index 000000000000..e1c47e72005b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lcm_i32_debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lcm_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.cmpi slt, %in, %c0_i32 : i32 + %6 = arith.subi %c0_i32, %in : i32 + %7 = arith.select %5, %6, %in : i32 + %8 = arith.cmpi slt, %in_0, %c0_i32 : i32 + %9 = arith.subi %c0_i32, %in_0 : i32 + %10 = arith.select %8, %9, %in_0 : i32 + %11:2 = scf.while (%arg3 = %10, %arg4 = %7) : (i32, i32) -> (i32, i32) { + %16 = arith.cmpi ne, %arg3, %c0_i32 : i32 + scf.condition(%16) %arg4, %arg3 : i32, i32 + } do { + ^bb0(%arg3: i32, %arg4: i32): + %16 = arith.remsi %arg3, %arg4 : i32 + scf.yield %16, %arg4 : i32, i32 + } + %12 = arith.cmpi eq, %11#0, %c0_i32 : i32 + %13 = arith.divsi %7, %11#0 : i32 + %14 = arith.muli %13, %10 : i32 + %15 = arith.select %12, %c0_i32, %14 : i32 + linalg.yield %15 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lcm_i32_linalg.mlir b/issues/aten_c_kernels/results/aten_lcm_i32_linalg.mlir new file mode 100644 index 000000000000..6ce7f27bf7a6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lcm_i32_linalg.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lcm_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %0 = arith.cmpi slt, %in, %c0_i32 : i32 + %1 = arith.subi %c0_i32, %in : i32 + %2 = arith.select %0, %1, %in : i32 + %3 = arith.cmpi slt, %in_0, %c0_i32 : i32 + %4 = arith.subi %c0_i32, %in_0 : i32 + %5 = arith.select %3, %4, %in_0 : i32 + %6:2 = scf.while (%arg3 = %5, %arg4 = %2) : (i32, i32) -> (i32, i32) { + %11 = arith.cmpi ne, %arg3, %c0_i32 : i32 + scf.condition(%11) %arg4, %arg3 : i32, i32 + } do { + ^bb0(%arg3: i32, %arg4: i32): + %11 = arith.remsi %arg3, %arg4 : i32 + scf.yield %11, %arg4 : i32, i32 + } + %7 = arith.cmpi eq, %6#0, %c0_i32 : i32 + %8 = arith.divsi %2, %6#0 : i32 + %9 = arith.muli %8, %5 : i32 + %10 = arith.select %7, %c0_i32, %9 : i32 + linalg.yield %10 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ldexp.mlir b/issues/aten_c_kernels/results/aten_ldexp.mlir new file mode 100644 index 000000000000..8fc71c8726d3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ldexp.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ldexp(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @ldexpf(%0, %1) : (f32, i32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @ldexpf(f32, i32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_ldexp/debuf.mlir b/issues/aten_c_kernels/results/aten_ldexp/debuf.mlir new file mode 100644 index 000000000000..5777050cf3e7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ldexp/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ldexp(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: i32, %out: f32): + %5 = func.call @ldexpf(%in, %in_0) : (f32, i32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @ldexpf(f32, i32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_ldexp/matched.mlir b/issues/aten_c_kernels/results/aten_ldexp/matched.mlir new file mode 100644 index 000000000000..5777050cf3e7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ldexp/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ldexp(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: i32, %out: f32): + %5 = func.call @ldexpf(%in, %in_0) : (f32, i32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @ldexpf(f32, i32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_ldexp/orig.mlir b/issues/aten_c_kernels/results/aten_ldexp/orig.mlir new file mode 100644 index 000000000000..8fc71c8726d3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ldexp/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ldexp(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @ldexpf(%0, %1) : (f32, i32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @ldexpf(f32, i32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_ldexp/raised.mlir b/issues/aten_c_kernels/results/aten_ldexp/raised.mlir new file mode 100644 index 000000000000..d2b469645598 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ldexp/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ldexp(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: i32, %out: f32): + %0 = func.call @ldexpf(%in, %in_0) : (f32, i32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @ldexpf(f32, i32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_ldexp_debuf.mlir b/issues/aten_c_kernels/results/aten_ldexp_debuf.mlir new file mode 100644 index 000000000000..5777050cf3e7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ldexp_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ldexp(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: i32, %out: f32): + %5 = func.call @ldexpf(%in, %in_0) : (f32, i32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @ldexpf(f32, i32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_ldexp_linalg.mlir b/issues/aten_c_kernels/results/aten_ldexp_linalg.mlir new file mode 100644 index 000000000000..d2b469645598 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ldexp_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ldexp(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: i32, %out: f32): + %0 = func.call @ldexpf(%in, %in_0) : (f32, i32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @ldexpf(f32, i32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_le.mlir b/issues/aten_c_kernels/results/aten_le.mlir new file mode 100644 index 000000000000..ba5d23aed357 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_le.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_le(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf ole, %0, %1 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_le/debuf.mlir b/issues/aten_c_kernels/results/aten_le/debuf.mlir new file mode 100644 index 000000000000..9a486eca3f8c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_le/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_le(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf ole, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_le/matched.mlir b/issues/aten_c_kernels/results/aten_le/matched.mlir new file mode 100644 index 000000000000..9a486eca3f8c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_le/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_le(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf ole, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_le/orig.mlir b/issues/aten_c_kernels/results/aten_le/orig.mlir new file mode 100644 index 000000000000..ba5d23aed357 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_le/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_le(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf ole, %0, %1 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_le/raised.mlir b/issues/aten_c_kernels/results/aten_le/raised.mlir new file mode 100644 index 000000000000..f96b94773ba4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_le/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_le(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf ole, %in, %in_0 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_le_debuf.mlir b/issues/aten_c_kernels/results/aten_le_debuf.mlir new file mode 100644 index 000000000000..9a486eca3f8c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_le_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_le(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf ole, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_le_linalg.mlir b/issues/aten_c_kernels/results/aten_le_linalg.mlir new file mode 100644 index 000000000000..f96b94773ba4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_le_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_le(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf ole, %in, %in_0 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_leaky_relu.mlir b/issues/aten_c_kernels/results/aten_leaky_relu.mlir new file mode 100644 index 000000000000..91c718c55e4f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_leaky_relu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_leaky_relu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 256 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf oge, %0, %cst : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %0 : f32 + } else { + %3 = arith.mulf %arg2, %0 : f32 + scf.yield %3 : f32 + } + affine.store %2, %arg1[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_leaky_relu/debuf.mlir b/issues/aten_c_kernels/results/aten_leaky_relu/debuf.mlir new file mode 100644 index 000000000000..ad7f9b96d2de --- /dev/null +++ b/issues/aten_c_kernels/results/aten_leaky_relu/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_leaky_relu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf oge, %in, %cst : f32 + %5 = arith.mulf %arg2, %in : f32 + %6 = arith.select %4, %in, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_leaky_relu/matched.mlir b/issues/aten_c_kernels/results/aten_leaky_relu/matched.mlir new file mode 100644 index 000000000000..ad7f9b96d2de --- /dev/null +++ b/issues/aten_c_kernels/results/aten_leaky_relu/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_leaky_relu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf oge, %in, %cst : f32 + %5 = arith.mulf %arg2, %in : f32 + %6 = arith.select %4, %in, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_leaky_relu/orig.mlir b/issues/aten_c_kernels/results/aten_leaky_relu/orig.mlir new file mode 100644 index 000000000000..91c718c55e4f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_leaky_relu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_leaky_relu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 256 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf oge, %0, %cst : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %0 : f32 + } else { + %3 = arith.mulf %arg2, %0 : f32 + scf.yield %3 : f32 + } + affine.store %2, %arg1[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_leaky_relu/raised.mlir b/issues/aten_c_kernels/results/aten_leaky_relu/raised.mlir new file mode 100644 index 000000000000..50c503b48e89 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_leaky_relu/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_leaky_relu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf oge, %in, %cst : f32 + %1 = arith.mulf %arg2, %in : f32 + %2 = arith.select %0, %in, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_leaky_relu_debuf.mlir b/issues/aten_c_kernels/results/aten_leaky_relu_debuf.mlir new file mode 100644 index 000000000000..ad7f9b96d2de --- /dev/null +++ b/issues/aten_c_kernels/results/aten_leaky_relu_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_leaky_relu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf oge, %in, %cst : f32 + %5 = arith.mulf %arg2, %in : f32 + %6 = arith.select %4, %in, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_leaky_relu_linalg.mlir b/issues/aten_c_kernels/results/aten_leaky_relu_linalg.mlir new file mode 100644 index 000000000000..50c503b48e89 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_leaky_relu_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_leaky_relu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf oge, %in, %cst : f32 + %1 = arith.mulf %arg2, %in : f32 + %2 = arith.select %0, %in, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_legendre_polynomial_p.mlir b/issues/aten_c_kernels/results/aten_legendre_polynomial_p.mlir new file mode 100644 index 000000000000..c872a49e93e7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_legendre_polynomial_p.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_legendre_polynomial_p(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_legendre_pf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_legendre_pf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_legendre_polynomial_p/debuf.mlir b/issues/aten_c_kernels/results/aten_legendre_polynomial_p/debuf.mlir new file mode 100644 index 000000000000..f85425cdbbb2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_legendre_polynomial_p/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_legendre_polynomial_p(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_legendre_pf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_legendre_pf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_legendre_polynomial_p/matched.mlir b/issues/aten_c_kernels/results/aten_legendre_polynomial_p/matched.mlir new file mode 100644 index 000000000000..f85425cdbbb2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_legendre_polynomial_p/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_legendre_polynomial_p(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_legendre_pf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_legendre_pf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_legendre_polynomial_p/orig.mlir b/issues/aten_c_kernels/results/aten_legendre_polynomial_p/orig.mlir new file mode 100644 index 000000000000..c872a49e93e7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_legendre_polynomial_p/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_legendre_polynomial_p(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_legendre_pf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_legendre_pf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_legendre_polynomial_p/raised.mlir b/issues/aten_c_kernels/results/aten_legendre_polynomial_p/raised.mlir new file mode 100644 index 000000000000..0b373eb2f362 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_legendre_polynomial_p/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_legendre_polynomial_p(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_legendre_pf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_legendre_pf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_legendre_polynomial_p_debuf.mlir b/issues/aten_c_kernels/results/aten_legendre_polynomial_p_debuf.mlir new file mode 100644 index 000000000000..f85425cdbbb2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_legendre_polynomial_p_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_legendre_polynomial_p(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_legendre_pf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_legendre_pf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_legendre_polynomial_p_linalg.mlir b/issues/aten_c_kernels/results/aten_legendre_polynomial_p_linalg.mlir new file mode 100644 index 000000000000..0b373eb2f362 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_legendre_polynomial_p_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_legendre_polynomial_p(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_legendre_pf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_legendre_pf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_lerp.mlir b/issues/aten_c_kernels/results/aten_lerp.mlir new file mode 100644 index 000000000000..e250a08a6c56 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 256 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg2[%arg4] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.subf %2, %0 : f32 + %4 = arith.mulf %1, %3 : f32 + %5 = arith.addf %0, %4 : f32 + affine.store %5, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_lerp/debuf.mlir b/issues/aten_c_kernels/results/aten_lerp/debuf.mlir new file mode 100644 index 000000000000..374a8dd6fa02 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %2, %1 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.subf %in_1, %in : f32 + %7 = arith.mulf %in_0, %6 : f32 + %8 = arith.addf %in, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp/matched.mlir b/issues/aten_c_kernels/results/aten_lerp/matched.mlir new file mode 100644 index 000000000000..374a8dd6fa02 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp/matched.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %2, %1 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.subf %in_1, %in : f32 + %7 = arith.mulf %in_0, %6 : f32 + %8 = arith.addf %in, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp/orig.mlir b/issues/aten_c_kernels/results/aten_lerp/orig.mlir new file mode 100644 index 000000000000..e250a08a6c56 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 256 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg2[%arg4] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.subf %2, %0 : f32 + %4 = arith.mulf %1, %3 : f32 + %5 = arith.addf %0, %4 : f32 + affine.store %5, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_lerp/raised.mlir b/issues/aten_c_kernels/results/aten_lerp/raised.mlir new file mode 100644 index 000000000000..71259c855ec0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg2, %arg1 : memref, memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.subf %in_1, %in : f32 + %1 = arith.mulf %in_0, %0 : f32 + %2 = arith.addf %in, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_debuf.mlir b/issues/aten_c_kernels/results/aten_lerp_debuf.mlir new file mode 100644 index 000000000000..374a8dd6fa02 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %2, %1 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.subf %in_1, %in : f32 + %7 = arith.mulf %in_0, %6 : f32 + %8 = arith.addf %in, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_linalg.mlir b/issues/aten_c_kernels/results/aten_lerp_linalg.mlir new file mode 100644 index 000000000000..71259c855ec0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg2, %arg1 : memref, memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.subf %in_1, %in : f32 + %1 = arith.mulf %in_0, %0 : f32 + %2 = arith.addf %in, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_scalar.mlir b/issues/aten_c_kernels/results/aten_lerp_scalar.mlir new file mode 100644 index 000000000000..3f5a53b33ef1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_scalar.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_scalar(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.subf %1, %0 : f32 + %3 = arith.mulf %arg2, %2 : f32 + %4 = arith.addf %0, %3 : f32 + affine.store %4, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_lerp_scalar/debuf.mlir b/issues/aten_c_kernels/results/aten_lerp_scalar/debuf.mlir new file mode 100644 index 000000000000..37bb60cb3276 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_scalar/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_scalar(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in_0, %in : f32 + %6 = arith.mulf %arg2, %5 : f32 + %7 = arith.addf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_scalar/matched.mlir b/issues/aten_c_kernels/results/aten_lerp_scalar/matched.mlir new file mode 100644 index 000000000000..37bb60cb3276 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_scalar/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_scalar(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in_0, %in : f32 + %6 = arith.mulf %arg2, %5 : f32 + %7 = arith.addf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_scalar/orig.mlir b/issues/aten_c_kernels/results/aten_lerp_scalar/orig.mlir new file mode 100644 index 000000000000..3f5a53b33ef1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_scalar/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_scalar(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.subf %1, %0 : f32 + %3 = arith.mulf %arg2, %2 : f32 + %4 = arith.addf %0, %3 : f32 + affine.store %4, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_lerp_scalar/raised.mlir b/issues/aten_c_kernels/results/aten_lerp_scalar/raised.mlir new file mode 100644 index 000000000000..9633c2489fad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_scalar/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_scalar(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.subf %in_0, %in : f32 + %1 = arith.mulf %arg2, %0 : f32 + %2 = arith.addf %in, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_scalar_cpu.mlir b/issues/aten_c_kernels/results/aten_lerp_scalar_cpu.mlir new file mode 100644 index 000000000000..1207e7805808 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_scalar_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_scalar_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.subf %1, %0 : f32 + %3 = arith.mulf %arg2, %2 : f32 + %4 = arith.addf %0, %3 : f32 + affine.store %4, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_lerp_scalar_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_lerp_scalar_cpu/debuf.mlir new file mode 100644 index 000000000000..7c168d696384 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_scalar_cpu/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_scalar_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in_0, %in : f32 + %6 = arith.mulf %arg2, %5 : f32 + %7 = arith.addf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_scalar_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_lerp_scalar_cpu/matched.mlir new file mode 100644 index 000000000000..7c168d696384 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_scalar_cpu/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_scalar_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in_0, %in : f32 + %6 = arith.mulf %arg2, %5 : f32 + %7 = arith.addf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_scalar_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_lerp_scalar_cpu/orig.mlir new file mode 100644 index 000000000000..1207e7805808 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_scalar_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_scalar_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.subf %1, %0 : f32 + %3 = arith.mulf %arg2, %2 : f32 + %4 = arith.addf %0, %3 : f32 + affine.store %4, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_lerp_scalar_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_lerp_scalar_cpu/raised.mlir new file mode 100644 index 000000000000..fc04cafde4fa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_scalar_cpu/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_scalar_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.subf %in_0, %in : f32 + %1 = arith.mulf %arg2, %0 : f32 + %2 = arith.addf %in, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_scalar_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_lerp_scalar_cpu_debuf.mlir new file mode 100644 index 000000000000..7c168d696384 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_scalar_cpu_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_scalar_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in_0, %in : f32 + %6 = arith.mulf %arg2, %5 : f32 + %7 = arith.addf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_scalar_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_lerp_scalar_cpu_linalg.mlir new file mode 100644 index 000000000000..fc04cafde4fa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_scalar_cpu_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_scalar_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.subf %in_0, %in : f32 + %1 = arith.mulf %arg2, %0 : f32 + %2 = arith.addf %in, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_scalar_debuf.mlir b/issues/aten_c_kernels/results/aten_lerp_scalar_debuf.mlir new file mode 100644 index 000000000000..37bb60cb3276 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_scalar_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_scalar(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in_0, %in : f32 + %6 = arith.mulf %arg2, %5 : f32 + %7 = arith.addf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_scalar_linalg.mlir b/issues/aten_c_kernels/results/aten_lerp_scalar_linalg.mlir new file mode 100644 index 000000000000..9633c2489fad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_scalar_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_scalar(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.subf %in_0, %in : f32 + %1 = arith.mulf %arg2, %0 : f32 + %2 = arith.addf %in, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_tensor_cpu.mlir b/issues/aten_c_kernels/results/aten_lerp_tensor_cpu.mlir new file mode 100644 index 000000000000..4f3db81e53e8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_tensor_cpu.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_tensor_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg2[%arg4] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.subf %2, %0 : f32 + %4 = arith.mulf %1, %3 : f32 + %5 = arith.addf %0, %4 : f32 + affine.store %5, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_lerp_tensor_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_lerp_tensor_cpu/debuf.mlir new file mode 100644 index 000000000000..2b44111704f6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_tensor_cpu/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_tensor_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %2, %1 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.subf %in_1, %in : f32 + %7 = arith.mulf %in_0, %6 : f32 + %8 = arith.addf %in, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_tensor_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_lerp_tensor_cpu/matched.mlir new file mode 100644 index 000000000000..2b44111704f6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_tensor_cpu/matched.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_tensor_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %2, %1 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.subf %in_1, %in : f32 + %7 = arith.mulf %in_0, %6 : f32 + %8 = arith.addf %in, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_tensor_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_lerp_tensor_cpu/orig.mlir new file mode 100644 index 000000000000..4f3db81e53e8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_tensor_cpu/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_tensor_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg2[%arg4] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.subf %2, %0 : f32 + %4 = arith.mulf %1, %3 : f32 + %5 = arith.addf %0, %4 : f32 + affine.store %5, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_lerp_tensor_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_lerp_tensor_cpu/raised.mlir new file mode 100644 index 000000000000..5ee3432fa9f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_tensor_cpu/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_tensor_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg2, %arg1 : memref, memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.subf %in_1, %in : f32 + %1 = arith.mulf %in_0, %0 : f32 + %2 = arith.addf %in, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_tensor_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_lerp_tensor_cpu_debuf.mlir new file mode 100644 index 000000000000..2b44111704f6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_tensor_cpu_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_tensor_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %2, %1 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.subf %in_1, %in : f32 + %7 = arith.mulf %in_0, %6 : f32 + %8 = arith.addf %in, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lerp_tensor_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_lerp_tensor_cpu_linalg.mlir new file mode 100644 index 000000000000..5ee3432fa9f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lerp_tensor_cpu_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lerp_tensor_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg2, %arg1 : memref, memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.subf %in_1, %in : f32 + %1 = arith.mulf %in_0, %0 : f32 + %2 = arith.addf %in, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lgamma.mlir b/issues/aten_c_kernels/results/aten_lgamma.mlir new file mode 100644 index 000000000000..4aa3d41bacd0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lgamma.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lgamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @lgammaf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @lgammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_lgamma/debuf.mlir b/issues/aten_c_kernels/results/aten_lgamma/debuf.mlir new file mode 100644 index 000000000000..c3301007574a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lgamma/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lgamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @lgammaf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @lgammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_lgamma/matched.mlir b/issues/aten_c_kernels/results/aten_lgamma/matched.mlir new file mode 100644 index 000000000000..c3301007574a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lgamma/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lgamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @lgammaf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @lgammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_lgamma/orig.mlir b/issues/aten_c_kernels/results/aten_lgamma/orig.mlir new file mode 100644 index 000000000000..4aa3d41bacd0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lgamma/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lgamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @lgammaf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @lgammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_lgamma/raised.mlir b/issues/aten_c_kernels/results/aten_lgamma/raised.mlir new file mode 100644 index 000000000000..196321429945 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lgamma/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lgamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @lgammaf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @lgammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_lgamma_debuf.mlir b/issues/aten_c_kernels/results/aten_lgamma_debuf.mlir new file mode 100644 index 000000000000..c3301007574a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lgamma_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lgamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @lgammaf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @lgammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_lgamma_linalg.mlir b/issues/aten_c_kernels/results/aten_lgamma_linalg.mlir new file mode 100644 index 000000000000..196321429945 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lgamma_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lgamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @lgammaf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @lgammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_linalg_powsum_cpu.mlir b/issues/aten_c_kernels/results/aten_linalg_powsum_cpu.mlir new file mode 100644 index 000000000000..00e88a4bdf56 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linalg_powsum_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linalg_powsum_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 32 { + %0 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = arith.cmpf olt, %1, %cst : f32 + %3 = scf.if %2 -> (f32) { + %6 = arith.negf %1 : f32 + scf.yield %6 : f32 + } else { + scf.yield %1 : f32 + } + %4 = math.powf %3, %arg1 : f32 + %5 = arith.addf %arg5, %4 : f32 + affine.yield %5 : f32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_linalg_powsum_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_linalg_powsum_cpu/debuf.mlir new file mode 100644 index 000000000000..271e2ac28c92 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linalg_powsum_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linalg_powsum_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %cst : f32 + %6 = arith.negf %in : f32 + %7 = arith.select %5, %6, %in : f32 + %8 = math.powf %7, %arg1 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_linalg_powsum_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_linalg_powsum_cpu/matched.mlir new file mode 100644 index 000000000000..98d52a1df182 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linalg_powsum_cpu/matched.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linalg_powsum_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = kernel.launch @memset_zero_1D_f32(%1) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %cst : f32 + %6 = arith.negf %in : f32 + %7 = arith.select %5, %6, %in : f32 + %8 = math.powf %7, %arg1 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_linalg_powsum_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_linalg_powsum_cpu/orig.mlir new file mode 100644 index 000000000000..00e88a4bdf56 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linalg_powsum_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linalg_powsum_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 32 { + %0 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = arith.cmpf olt, %1, %cst : f32 + %3 = scf.if %2 -> (f32) { + %6 = arith.negf %1 : f32 + scf.yield %6 : f32 + } else { + scf.yield %1 : f32 + } + %4 = math.powf %3, %arg1 : f32 + %5 = arith.addf %arg5, %4 : f32 + affine.yield %5 : f32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_linalg_powsum_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_linalg_powsum_cpu/raised.mlir new file mode 100644 index 000000000000..e02995e76835 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linalg_powsum_cpu/raised.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linalg_powsum_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg2[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %cst : f32 + %1 = arith.negf %in : f32 + %2 = arith.select %0, %1, %in : f32 + %3 = math.powf %2, %arg1 : f32 + %4 = arith.addf %out, %3 : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_linalg_powsum_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_linalg_powsum_cpu_debuf.mlir new file mode 100644 index 000000000000..271e2ac28c92 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linalg_powsum_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linalg_powsum_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %cst : f32 + %6 = arith.negf %in : f32 + %7 = arith.select %5, %6, %in : f32 + %8 = math.powf %7, %arg1 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_linalg_powsum_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_linalg_powsum_cpu_linalg.mlir new file mode 100644 index 000000000000..e02995e76835 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linalg_powsum_cpu_linalg.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linalg_powsum_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg2[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %cst : f32 + %1 = arith.negf %in : f32 + %2 = arith.select %0, %1, %in : f32 + %3 = math.powf %2, %arg1 : f32 + %4 = arith.addf %out, %3 : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_linear_combination_cpu.mlir b/issues/aten_c_kernels/results/aten_linear_combination_cpu.mlir new file mode 100644 index 000000000000..7ae810d67797 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linear_combination_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linear_combination_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + affine.for %arg3 = 0 to 4096 { + affine.store %cst, %alloca[] : memref + affine.for %arg4 = 0 to 4 { + %2 = affine.load %arg1[%arg4] : memref + %3 = affine.load %arg0[%arg4, %arg3] : memref + %4 = arith.mulf %2, %3 : f32 + %5 = affine.load %alloca[] : memref + %6 = arith.addf %5, %4 : f32 + affine.store %6, %alloca[] : memref + } + %1 = affine.load %alloca[] : memref + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_linear_combination_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_linear_combination_cpu/debuf.mlir new file mode 100644 index 000000000000..6553d88c171f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linear_combination_cpu/debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linear_combination_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c4 = arith.constant 4 : index + %c4096 = arith.constant 4096 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = tensor.empty(%c4096) : tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%3 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %1[0] [%c4] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c4, %c4096] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %4[0] [%c4096] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %8 = arith.mulf %in, %in_2 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %4[0] [%c4096] [1] : tensor into tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_linear_combination_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_linear_combination_cpu/matched.mlir new file mode 100644 index 000000000000..b5ba12d779a4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linear_combination_cpu/matched.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linear_combination_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c4 = arith.constant 4 : index + %c4096 = arith.constant 4096 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = tensor.empty(%c4096) : tensor + %4 = kernel.launch @memset_zero_1D_f32(%3) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %1[0] [%c4] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c4, %c4096] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %4[0] [%c4096] [1] : tensor to tensor + %5 = kernel.launch @cublasSgemv_T(%extracted_slice_0, %extracted_slice, %extracted_slice_1) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %5 into %4[0] [%c4096] [1] : tensor into tensor + %6 = kernel.launch @cudaCopy1D_f32_tensor(%inserted_slice, %2) : (tensor, tensor) -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_linear_combination_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_linear_combination_cpu/orig.mlir new file mode 100644 index 000000000000..7ae810d67797 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linear_combination_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linear_combination_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + affine.for %arg3 = 0 to 4096 { + affine.store %cst, %alloca[] : memref + affine.for %arg4 = 0 to 4 { + %2 = affine.load %arg1[%arg4] : memref + %3 = affine.load %arg0[%arg4, %arg3] : memref + %4 = arith.mulf %2, %3 : f32 + %5 = affine.load %alloca[] : memref + %6 = arith.addf %5, %4 : f32 + affine.store %6, %alloca[] : memref + } + %1 = affine.load %alloca[] : memref + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_linear_combination_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_linear_combination_cpu/raised.mlir new file mode 100644 index 000000000000..d86e88cf6e26 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linear_combination_cpu/raised.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linear_combination_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4096 = arith.constant 4096 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %alloca_0 = memref.alloca(%c4096) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_0 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg1[0] [%c4] [1] : memref to memref> + %subview_1 = memref.subview %arg0[0, 0] [%c4, %c4096] [1, 1] : memref to memref> + %subview_2 = memref.subview %alloca_0[0] [%c4096] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %1 = arith.mulf %in, %in_3 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca_0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_linear_combination_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_linear_combination_cpu_debuf.mlir new file mode 100644 index 000000000000..6553d88c171f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linear_combination_cpu_debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linear_combination_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c4 = arith.constant 4 : index + %c4096 = arith.constant 4096 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = tensor.empty(%c4096) : tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%3 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %1[0] [%c4] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c4, %c4096] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %4[0] [%c4096] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %8 = arith.mulf %in, %in_2 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %4[0] [%c4096] [1] : tensor into tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_linear_combination_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_linear_combination_cpu_linalg.mlir new file mode 100644 index 000000000000..d86e88cf6e26 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linear_combination_cpu_linalg.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linear_combination_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4096 = arith.constant 4096 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %alloca_0 = memref.alloca(%c4096) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_0 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg1[0] [%c4] [1] : memref to memref> + %subview_1 = memref.subview %arg0[0, 0] [%c4, %c4096] [1, 1] : memref to memref> + %subview_2 = memref.subview %alloca_0[0] [%c4096] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %1 = arith.mulf %in, %in_3 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca_0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_linspace.mlir b/issues/aten_c_kernels/results/aten_linspace.mlir new file mode 100644 index 000000000000..c7f62a2e141d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linspace.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linspace(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.mulf %1, %arg1 : f32 + %3 = arith.addf %arg0, %2 : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_linspace/debuf.mlir b/issues/aten_c_kernels/results/aten_linspace/debuf.mlir new file mode 100644 index 000000000000..021f01905f28 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linspace/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linspace(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.sitofp %4 : i32 to f32 + %6 = arith.mulf %5, %arg1 : f32 + %7 = arith.addf %arg0, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_linspace/matched.mlir b/issues/aten_c_kernels/results/aten_linspace/matched.mlir new file mode 100644 index 000000000000..021f01905f28 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linspace/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linspace(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.sitofp %4 : i32 to f32 + %6 = arith.mulf %5, %arg1 : f32 + %7 = arith.addf %arg0, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_linspace/orig.mlir b/issues/aten_c_kernels/results/aten_linspace/orig.mlir new file mode 100644 index 000000000000..c7f62a2e141d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linspace/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linspace(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.mulf %1, %arg1 : f32 + %3 = arith.addf %arg0, %2 : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_linspace/raised.mlir b/issues/aten_c_kernels/results/aten_linspace/raised.mlir new file mode 100644 index 000000000000..40ba4ada6bf9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linspace/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linspace(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.sitofp %1 : i32 to f32 + %3 = arith.mulf %2, %arg1 : f32 + %4 = arith.addf %arg0, %3 : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_linspace_debuf.mlir b/issues/aten_c_kernels/results/aten_linspace_debuf.mlir new file mode 100644 index 000000000000..021f01905f28 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linspace_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linspace(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.sitofp %4 : i32 to f32 + %6 = arith.mulf %5, %arg1 : f32 + %7 = arith.addf %arg0, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_linspace_linalg.mlir b/issues/aten_c_kernels/results/aten_linspace_linalg.mlir new file mode 100644 index 000000000000..40ba4ada6bf9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_linspace_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_linspace(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.sitofp %1 : i32 to f32 + %3 = arith.mulf %2, %arg1 : f32 + %4 = arith.addf %arg0, %3 : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_log.mlir b/issues/aten_c_kernels/results/aten_log.mlir new file mode 100644 index 000000000000..fc71ff802cf0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @logf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_log/debuf.mlir b/issues/aten_c_kernels/results/aten_log/debuf.mlir new file mode 100644 index 000000000000..1e27b3c52f96 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.log %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log/matched.mlir b/issues/aten_c_kernels/results/aten_log/matched.mlir new file mode 100644 index 000000000000..1e27b3c52f96 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.log %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log/orig.mlir b/issues/aten_c_kernels/results/aten_log/orig.mlir new file mode 100644 index 000000000000..fc71ff802cf0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @logf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_log/raised.mlir b/issues/aten_c_kernels/results/aten_log/raised.mlir new file mode 100644 index 000000000000..fd1b93570485 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.log %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log10.mlir b/issues/aten_c_kernels/results/aten_log10.mlir new file mode 100644 index 000000000000..bd9842766406 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log10.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log10(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @log10f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @log10f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_log10/debuf.mlir b/issues/aten_c_kernels/results/aten_log10/debuf.mlir new file mode 100644 index 000000000000..cf24efde91a8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log10/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log10(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.log10 %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @log10f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log10/matched.mlir b/issues/aten_c_kernels/results/aten_log10/matched.mlir new file mode 100644 index 000000000000..cf24efde91a8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log10/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log10(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.log10 %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @log10f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log10/orig.mlir b/issues/aten_c_kernels/results/aten_log10/orig.mlir new file mode 100644 index 000000000000..bd9842766406 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log10/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log10(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @log10f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @log10f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_log10/raised.mlir b/issues/aten_c_kernels/results/aten_log10/raised.mlir new file mode 100644 index 000000000000..2a1e0cb30653 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log10/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log10(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.log10 %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @log10f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log10_debuf.mlir b/issues/aten_c_kernels/results/aten_log10_debuf.mlir new file mode 100644 index 000000000000..cf24efde91a8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log10_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log10(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.log10 %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @log10f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log10_linalg.mlir b/issues/aten_c_kernels/results/aten_log10_linalg.mlir new file mode 100644 index 000000000000..2a1e0cb30653 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log10_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log10(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.log10 %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @log10f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log1p.mlir b/issues/aten_c_kernels/results/aten_log1p.mlir new file mode 100644 index 000000000000..38e0babf32fd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log1p.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log1p(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @log1pf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_log1p/debuf.mlir b/issues/aten_c_kernels/results/aten_log1p/debuf.mlir new file mode 100644 index 000000000000..3fda75b187e7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log1p/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log1p(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.log1p %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log1p/matched.mlir b/issues/aten_c_kernels/results/aten_log1p/matched.mlir new file mode 100644 index 000000000000..3fda75b187e7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log1p/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log1p(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.log1p %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log1p/orig.mlir b/issues/aten_c_kernels/results/aten_log1p/orig.mlir new file mode 100644 index 000000000000..38e0babf32fd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log1p/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log1p(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @log1pf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_log1p/raised.mlir b/issues/aten_c_kernels/results/aten_log1p/raised.mlir new file mode 100644 index 000000000000..9fba30753e84 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log1p/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log1p(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.log1p %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log1p_debuf.mlir b/issues/aten_c_kernels/results/aten_log1p_debuf.mlir new file mode 100644 index 000000000000..3fda75b187e7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log1p_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log1p(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.log1p %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log1p_linalg.mlir b/issues/aten_c_kernels/results/aten_log1p_linalg.mlir new file mode 100644 index 000000000000..9fba30753e84 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log1p_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log1p(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.log1p %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log2.mlir b/issues/aten_c_kernels/results/aten_log2.mlir new file mode 100644 index 000000000000..849ee0542aa8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log2.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log2(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @log2f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @log2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_log2/debuf.mlir b/issues/aten_c_kernels/results/aten_log2/debuf.mlir new file mode 100644 index 000000000000..bc195e4ef54c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log2/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log2(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.log2 %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @log2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log2/matched.mlir b/issues/aten_c_kernels/results/aten_log2/matched.mlir new file mode 100644 index 000000000000..bc195e4ef54c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log2/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log2(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.log2 %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @log2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log2/orig.mlir b/issues/aten_c_kernels/results/aten_log2/orig.mlir new file mode 100644 index 000000000000..849ee0542aa8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log2/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log2(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @log2f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @log2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_log2/raised.mlir b/issues/aten_c_kernels/results/aten_log2/raised.mlir new file mode 100644 index 000000000000..85a80f5faa29 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log2/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log2(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.log2 %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @log2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log2_debuf.mlir b/issues/aten_c_kernels/results/aten_log2_debuf.mlir new file mode 100644 index 000000000000..bc195e4ef54c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log2_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log2(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.log2 %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @log2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log2_linalg.mlir b/issues/aten_c_kernels/results/aten_log2_linalg.mlir new file mode 100644 index 000000000000..85a80f5faa29 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log2_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log2(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.log2 %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @log2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log_debuf.mlir b/issues/aten_c_kernels/results/aten_log_debuf.mlir new file mode 100644 index 000000000000..1e27b3c52f96 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.log %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log_linalg.mlir b/issues/aten_c_kernels/results/aten_log_linalg.mlir new file mode 100644 index 000000000000..fd1b93570485 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.log %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log_ndtr.mlir b/issues/aten_c_kernels/results/aten_log_ndtr.mlir new file mode 100644 index 000000000000..b0be190f5bcf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_ndtr.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_ndtr(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_log_ndtrf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_log_ndtrf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_log_ndtr/debuf.mlir b/issues/aten_c_kernels/results/aten_log_ndtr/debuf.mlir new file mode 100644 index 000000000000..d35fb7c060c4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_ndtr/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_ndtr(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_log_ndtrf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_log_ndtrf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log_ndtr/matched.mlir b/issues/aten_c_kernels/results/aten_log_ndtr/matched.mlir new file mode 100644 index 000000000000..d35fb7c060c4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_ndtr/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_ndtr(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_log_ndtrf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_log_ndtrf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log_ndtr/orig.mlir b/issues/aten_c_kernels/results/aten_log_ndtr/orig.mlir new file mode 100644 index 000000000000..b0be190f5bcf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_ndtr/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_ndtr(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_log_ndtrf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_log_ndtrf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_log_ndtr/raised.mlir b/issues/aten_c_kernels/results/aten_log_ndtr/raised.mlir new file mode 100644 index 000000000000..8ca4ef275447 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_ndtr/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_ndtr(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_log_ndtrf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_log_ndtrf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log_ndtr_debuf.mlir b/issues/aten_c_kernels/results/aten_log_ndtr_debuf.mlir new file mode 100644 index 000000000000..d35fb7c060c4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_ndtr_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_ndtr(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_log_ndtrf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_log_ndtrf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log_ndtr_linalg.mlir b/issues/aten_c_kernels/results/aten_log_ndtr_linalg.mlir new file mode 100644 index 000000000000..8ca4ef275447 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_ndtr_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_ndtr(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_log_ndtrf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_log_ndtrf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log_normal_cpu.mlir b/issues/aten_c_kernels/results/aten_log_normal_cpu.mlir new file mode 100644 index 000000000000..beabebba1a00 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_normal_cpu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_normal_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.mulf %arg2, %0 : f32 + %2 = arith.addf %arg1, %1 : f32 + %3 = math.exp %2 : f32 + affine.store %3, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_log_normal_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_log_normal_cpu/debuf.mlir new file mode 100644 index 000000000000..336128e7c4ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_normal_cpu/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_normal_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %arg2, %in : f32 + %5 = arith.addf %arg1, %4 : f32 + %6 = math.exp %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_log_normal_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_log_normal_cpu/matched.mlir new file mode 100644 index 000000000000..336128e7c4ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_normal_cpu/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_normal_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %arg2, %in : f32 + %5 = arith.addf %arg1, %4 : f32 + %6 = math.exp %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_log_normal_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_log_normal_cpu/orig.mlir new file mode 100644 index 000000000000..beabebba1a00 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_normal_cpu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_normal_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.mulf %arg2, %0 : f32 + %2 = arith.addf %arg1, %1 : f32 + %3 = math.exp %2 : f32 + affine.store %3, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_log_normal_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_log_normal_cpu/raised.mlir new file mode 100644 index 000000000000..deab435c0429 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_normal_cpu/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_normal_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %arg2, %in : f32 + %1 = arith.addf %arg1, %0 : f32 + %2 = math.exp %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_log_normal_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_log_normal_cpu_debuf.mlir new file mode 100644 index 000000000000..336128e7c4ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_normal_cpu_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_normal_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %arg2, %in : f32 + %5 = arith.addf %arg1, %4 : f32 + %6 = math.exp %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_log_normal_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_log_normal_cpu_linalg.mlir new file mode 100644 index 000000000000..deab435c0429 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_normal_cpu_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_normal_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %arg2, %in : f32 + %1 = arith.addf %arg1, %0 : f32 + %2 = math.exp %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu.mlir new file mode 100644 index 000000000000..0b9d6f8043a3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_sigmoid_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -1.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.cmpf olt, %0, %cst_1 : f32 + %2 = arith.select %1, %cst_0, %cst_1 : f32 + %3 = arith.select %1, %cst_0, %cst : f32 + %4 = affine.load %arg1[%arg4] : memref + %5 = arith.addf %4, %cst_0 : f32 + %6 = arith.divf %4, %5 : f32 + %7 = arith.mulf %3, %6 : f32 + %8 = arith.subf %2, %7 : f32 + %9 = affine.load %arg2[%arg4] : memref + %10 = arith.mulf %8, %9 : f32 + affine.store %10, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..a03de4f9b185 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_sigmoid_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant -1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %in_3: f32, %out: f32): + %6 = arith.cmpf olt, %in, %cst : f32 + %7 = arith.select %6, %cst_0, %cst : f32 + %8 = arith.select %6, %cst_0, %cst_1 : f32 + %9 = arith.addf %in_2, %cst_0 : f32 + %10 = arith.divf %in_2, %9 : f32 + %11 = arith.mulf %8, %10 : f32 + %12 = arith.subf %7, %11 : f32 + %13 = arith.mulf %12, %in_3 : f32 + linalg.yield %13 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu/matched.mlir new file mode 100644 index 000000000000..a03de4f9b185 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu/matched.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_sigmoid_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant -1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %in_3: f32, %out: f32): + %6 = arith.cmpf olt, %in, %cst : f32 + %7 = arith.select %6, %cst_0, %cst : f32 + %8 = arith.select %6, %cst_0, %cst_1 : f32 + %9 = arith.addf %in_2, %cst_0 : f32 + %10 = arith.divf %in_2, %9 : f32 + %11 = arith.mulf %8, %10 : f32 + %12 = arith.subf %7, %11 : f32 + %13 = arith.mulf %12, %in_3 : f32 + linalg.yield %13 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu/orig.mlir new file mode 100644 index 000000000000..0b9d6f8043a3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_sigmoid_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -1.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.cmpf olt, %0, %cst_1 : f32 + %2 = arith.select %1, %cst_0, %cst_1 : f32 + %3 = arith.select %1, %cst_0, %cst : f32 + %4 = affine.load %arg1[%arg4] : memref + %5 = arith.addf %4, %cst_0 : f32 + %6 = arith.divf %4, %5 : f32 + %7 = arith.mulf %3, %6 : f32 + %8 = arith.subf %2, %7 : f32 + %9 = affine.load %arg2[%arg4] : memref + %10 = arith.mulf %8, %9 : f32 + affine.store %10, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu/raised.mlir new file mode 100644 index 000000000000..180243c238cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu/raised.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_sigmoid_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -1.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg2 : memref, memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_2: f32, %in_3: f32, %out: f32): + %0 = arith.cmpf olt, %in, %cst_1 : f32 + %1 = arith.select %0, %cst_0, %cst_1 : f32 + %2 = arith.select %0, %cst_0, %cst : f32 + %3 = arith.addf %in_2, %cst_0 : f32 + %4 = arith.divf %in_2, %3 : f32 + %5 = arith.mulf %2, %4 : f32 + %6 = arith.subf %1, %5 : f32 + %7 = arith.mulf %6, %in_3 : f32 + linalg.yield %7 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..a03de4f9b185 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_sigmoid_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant -1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %in_3: f32, %out: f32): + %6 = arith.cmpf olt, %in, %cst : f32 + %7 = arith.select %6, %cst_0, %cst : f32 + %8 = arith.select %6, %cst_0, %cst_1 : f32 + %9 = arith.addf %in_2, %cst_0 : f32 + %10 = arith.divf %in_2, %9 : f32 + %11 = arith.mulf %8, %10 : f32 + %12 = arith.subf %7, %11 : f32 + %13 = arith.mulf %12, %in_3 : f32 + linalg.yield %13 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..180243c238cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_sigmoid_backward_cpu_linalg.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_sigmoid_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -1.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg2 : memref, memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_2: f32, %in_3: f32, %out: f32): + %0 = arith.cmpf olt, %in, %cst_1 : f32 + %1 = arith.select %0, %cst_0, %cst_1 : f32 + %2 = arith.select %0, %cst_0, %cst : f32 + %3 = arith.addf %in_2, %cst_0 : f32 + %4 = arith.divf %in_2, %3 : f32 + %5 = arith.mulf %2, %4 : f32 + %6 = arith.subf %1, %5 : f32 + %7 = arith.mulf %6, %in_3 : f32 + linalg.yield %7 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_log_sigmoid_cpu.mlir b/issues/aten_c_kernels/results/aten_log_sigmoid_cpu.mlir new file mode 100644 index 000000000000..037c48f1a550 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_sigmoid_cpu.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_sigmoid_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf olt, %0, %cst : f32 + %2 = scf.if %1 -> (f32) { + %10 = arith.negf %0 : f32 + scf.yield %10 : f32 + } else { + scf.yield %0 : f32 + } + %3 = arith.negf %2 : f32 + %4 = math.exp %3 : f32 + affine.store %4, %arg2[%arg3] : memref + %5 = affine.load %arg0[%arg3] : memref + %6 = arith.cmpf olt, %5, %cst : f32 + %7 = arith.select %6, %5, %cst : f32 + %8 = func.call @log1pf(%4) : (f32) -> f32 + %9 = arith.subf %7, %8 : f32 + affine.store %9, %arg1[%arg3] : memref + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_log_sigmoid_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_log_sigmoid_cpu/debuf.mlir new file mode 100644 index 000000000000..d979ba484e9e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_sigmoid_cpu/debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_sigmoid_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %0 : tensor, tensor) outs(%2, %1 : tensor, tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32, %out_1: f32): + %6 = arith.cmpf olt, %in, %cst : f32 + %7 = arith.negf %in : f32 + %8 = arith.select %6, %7, %in : f32 + %9 = arith.negf %8 : f32 + %10 = math.exp %9 : f32 + %11 = arith.cmpf olt, %in_0, %cst : f32 + %12 = arith.select %11, %in_0, %cst : f32 + %13 = math.log1p %10 : f32 + %14 = arith.subf %12, %13 : f32 + linalg.yield %10, %14 : f32, f32 + } -> (tensor, tensor) + %4 = bufferization.to_memref %3#0 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#1 : memref + memref.copy %5, %arg1 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log_sigmoid_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_log_sigmoid_cpu/matched.mlir new file mode 100644 index 000000000000..d979ba484e9e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_sigmoid_cpu/matched.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_sigmoid_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %0 : tensor, tensor) outs(%2, %1 : tensor, tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32, %out_1: f32): + %6 = arith.cmpf olt, %in, %cst : f32 + %7 = arith.negf %in : f32 + %8 = arith.select %6, %7, %in : f32 + %9 = arith.negf %8 : f32 + %10 = math.exp %9 : f32 + %11 = arith.cmpf olt, %in_0, %cst : f32 + %12 = arith.select %11, %in_0, %cst : f32 + %13 = math.log1p %10 : f32 + %14 = arith.subf %12, %13 : f32 + linalg.yield %10, %14 : f32, f32 + } -> (tensor, tensor) + %4 = bufferization.to_memref %3#0 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#1 : memref + memref.copy %5, %arg1 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log_sigmoid_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_log_sigmoid_cpu/orig.mlir new file mode 100644 index 000000000000..037c48f1a550 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_sigmoid_cpu/orig.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_sigmoid_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf olt, %0, %cst : f32 + %2 = scf.if %1 -> (f32) { + %10 = arith.negf %0 : f32 + scf.yield %10 : f32 + } else { + scf.yield %0 : f32 + } + %3 = arith.negf %2 : f32 + %4 = math.exp %3 : f32 + affine.store %4, %arg2[%arg3] : memref + %5 = affine.load %arg0[%arg3] : memref + %6 = arith.cmpf olt, %5, %cst : f32 + %7 = arith.select %6, %5, %cst : f32 + %8 = func.call @log1pf(%4) : (f32) -> f32 + %9 = arith.subf %7, %8 : f32 + affine.store %9, %arg1[%arg3] : memref + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_log_sigmoid_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_log_sigmoid_cpu/raised.mlir new file mode 100644 index 000000000000..346f2a69e883 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_sigmoid_cpu/raised.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_sigmoid_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg0 : memref, memref) outs(%arg2, %arg1 : memref, memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32, %out_1: f32): + %0 = arith.cmpf olt, %in, %cst : f32 + %1 = arith.negf %in : f32 + %2 = arith.select %0, %1, %in : f32 + %3 = arith.negf %2 : f32 + %4 = math.exp %3 : f32 + %5 = arith.cmpf olt, %in_0, %cst : f32 + %6 = arith.select %5, %in_0, %cst : f32 + %7 = math.log1p %4 : f32 + %8 = arith.subf %6, %7 : f32 + linalg.yield %4, %8 : f32, f32 + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log_sigmoid_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_log_sigmoid_cpu_debuf.mlir new file mode 100644 index 000000000000..d979ba484e9e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_sigmoid_cpu_debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_sigmoid_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %0 : tensor, tensor) outs(%2, %1 : tensor, tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32, %out_1: f32): + %6 = arith.cmpf olt, %in, %cst : f32 + %7 = arith.negf %in : f32 + %8 = arith.select %6, %7, %in : f32 + %9 = arith.negf %8 : f32 + %10 = math.exp %9 : f32 + %11 = arith.cmpf olt, %in_0, %cst : f32 + %12 = arith.select %11, %in_0, %cst : f32 + %13 = math.log1p %10 : f32 + %14 = arith.subf %12, %13 : f32 + linalg.yield %10, %14 : f32, f32 + } -> (tensor, tensor) + %4 = bufferization.to_memref %3#0 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#1 : memref + memref.copy %5, %arg1 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_log_sigmoid_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_log_sigmoid_cpu_linalg.mlir new file mode 100644 index 000000000000..346f2a69e883 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_log_sigmoid_cpu_linalg.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_log_sigmoid_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg0 : memref, memref) outs(%arg2, %arg1 : memref, memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32, %out_1: f32): + %0 = arith.cmpf olt, %in, %cst : f32 + %1 = arith.negf %in : f32 + %2 = arith.select %0, %1, %in : f32 + %3 = arith.negf %2 : f32 + %4 = math.exp %3 : f32 + %5 = arith.cmpf olt, %in_0, %cst : f32 + %6 = arith.select %5, %in_0, %cst : f32 + %7 = math.log1p %4 : f32 + %8 = arith.subf %6, %7 : f32 + linalg.yield %4, %8 : f32, f32 + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_logaddexp.mlir b/issues/aten_c_kernels/results/aten_logaddexp.mlir new file mode 100644 index 000000000000..d1094b03d651 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logaddexp.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logaddexp(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.subf %0, %1 : f32 + %3 = arith.cmpf olt, %2, %cst : f32 + %4 = scf.if %3 -> (f32) { + %11 = arith.negf %2 : f32 + scf.yield %11 : f32 + } else { + scf.yield %2 : f32 + } + %5 = arith.cmpf ogt, %0, %1 : f32 + %6 = arith.select %5, %0, %1 : f32 + %7 = arith.negf %4 : f32 + %8 = math.exp %7 : f32 + %9 = func.call @log1pf(%8) : (f32) -> f32 + %10 = arith.addf %6, %9 : f32 + affine.store %10, %arg2[%arg3] : memref + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_logaddexp/debuf.mlir b/issues/aten_c_kernels/results/aten_logaddexp/debuf.mlir new file mode 100644 index 000000000000..388e438571fb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logaddexp/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logaddexp(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in, %in_0 : f32 + %6 = arith.cmpf olt, %5, %cst : f32 + %7 = arith.negf %5 : f32 + %8 = arith.select %6, %7, %5 : f32 + %9 = arith.cmpf ogt, %in, %in_0 : f32 + %10 = arith.select %9, %in, %in_0 : f32 + %11 = arith.negf %8 : f32 + %12 = math.exp %11 : f32 + %13 = math.log1p %12 : f32 + %14 = arith.addf %10, %13 : f32 + linalg.yield %14 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_logaddexp/matched.mlir b/issues/aten_c_kernels/results/aten_logaddexp/matched.mlir new file mode 100644 index 000000000000..388e438571fb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logaddexp/matched.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logaddexp(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in, %in_0 : f32 + %6 = arith.cmpf olt, %5, %cst : f32 + %7 = arith.negf %5 : f32 + %8 = arith.select %6, %7, %5 : f32 + %9 = arith.cmpf ogt, %in, %in_0 : f32 + %10 = arith.select %9, %in, %in_0 : f32 + %11 = arith.negf %8 : f32 + %12 = math.exp %11 : f32 + %13 = math.log1p %12 : f32 + %14 = arith.addf %10, %13 : f32 + linalg.yield %14 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_logaddexp/orig.mlir b/issues/aten_c_kernels/results/aten_logaddexp/orig.mlir new file mode 100644 index 000000000000..d1094b03d651 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logaddexp/orig.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logaddexp(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.subf %0, %1 : f32 + %3 = arith.cmpf olt, %2, %cst : f32 + %4 = scf.if %3 -> (f32) { + %11 = arith.negf %2 : f32 + scf.yield %11 : f32 + } else { + scf.yield %2 : f32 + } + %5 = arith.cmpf ogt, %0, %1 : f32 + %6 = arith.select %5, %0, %1 : f32 + %7 = arith.negf %4 : f32 + %8 = math.exp %7 : f32 + %9 = func.call @log1pf(%8) : (f32) -> f32 + %10 = arith.addf %6, %9 : f32 + affine.store %10, %arg2[%arg3] : memref + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_logaddexp/raised.mlir b/issues/aten_c_kernels/results/aten_logaddexp/raised.mlir new file mode 100644 index 000000000000..85ca99c2ddae --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logaddexp/raised.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logaddexp(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.subf %in, %in_0 : f32 + %1 = arith.cmpf olt, %0, %cst : f32 + %2 = arith.negf %0 : f32 + %3 = arith.select %1, %2, %0 : f32 + %4 = arith.cmpf ogt, %in, %in_0 : f32 + %5 = arith.select %4, %in, %in_0 : f32 + %6 = arith.negf %3 : f32 + %7 = math.exp %6 : f32 + %8 = math.log1p %7 : f32 + %9 = arith.addf %5, %8 : f32 + linalg.yield %9 : f32 + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_logaddexp2.mlir b/issues/aten_c_kernels/results/aten_logaddexp2.mlir new file mode 100644 index 000000000000..384b79ee0228 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logaddexp2.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logaddexp2(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.44269502 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.subf %0, %1 : f32 + %3 = arith.cmpf olt, %2, %cst_0 : f32 + %4 = scf.if %3 -> (f32) { + %12 = arith.negf %2 : f32 + scf.yield %12 : f32 + } else { + scf.yield %2 : f32 + } + %5 = arith.cmpf ogt, %0, %1 : f32 + %6 = arith.select %5, %0, %1 : f32 + %7 = arith.negf %4 : f32 + %8 = func.call @exp2f(%7) : (f32) -> f32 + %9 = func.call @log1pf(%8) : (f32) -> f32 + %10 = arith.mulf %9, %cst : f32 + %11 = arith.addf %6, %10 : f32 + affine.store %11, %arg2[%arg3] : memref + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} + func.func private @exp2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_logaddexp2/debuf.mlir b/issues/aten_c_kernels/results/aten_logaddexp2/debuf.mlir new file mode 100644 index 000000000000..2e5f75f71048 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logaddexp2/debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logaddexp2(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.44269502 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %5 = arith.subf %in, %in_1 : f32 + %6 = arith.cmpf olt, %5, %cst : f32 + %7 = arith.negf %5 : f32 + %8 = arith.select %6, %7, %5 : f32 + %9 = arith.cmpf ogt, %in, %in_1 : f32 + %10 = arith.select %9, %in, %in_1 : f32 + %11 = arith.negf %8 : f32 + %12 = math.exp2 %11 : f32 + %13 = math.log1p %12 : f32 + %14 = arith.mulf %13, %cst_0 : f32 + %15 = arith.addf %10, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} + func.func private @exp2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_logaddexp2/matched.mlir b/issues/aten_c_kernels/results/aten_logaddexp2/matched.mlir new file mode 100644 index 000000000000..2e5f75f71048 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logaddexp2/matched.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logaddexp2(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.44269502 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %5 = arith.subf %in, %in_1 : f32 + %6 = arith.cmpf olt, %5, %cst : f32 + %7 = arith.negf %5 : f32 + %8 = arith.select %6, %7, %5 : f32 + %9 = arith.cmpf ogt, %in, %in_1 : f32 + %10 = arith.select %9, %in, %in_1 : f32 + %11 = arith.negf %8 : f32 + %12 = math.exp2 %11 : f32 + %13 = math.log1p %12 : f32 + %14 = arith.mulf %13, %cst_0 : f32 + %15 = arith.addf %10, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} + func.func private @exp2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_logaddexp2/orig.mlir b/issues/aten_c_kernels/results/aten_logaddexp2/orig.mlir new file mode 100644 index 000000000000..384b79ee0228 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logaddexp2/orig.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logaddexp2(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.44269502 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.subf %0, %1 : f32 + %3 = arith.cmpf olt, %2, %cst_0 : f32 + %4 = scf.if %3 -> (f32) { + %12 = arith.negf %2 : f32 + scf.yield %12 : f32 + } else { + scf.yield %2 : f32 + } + %5 = arith.cmpf ogt, %0, %1 : f32 + %6 = arith.select %5, %0, %1 : f32 + %7 = arith.negf %4 : f32 + %8 = func.call @exp2f(%7) : (f32) -> f32 + %9 = func.call @log1pf(%8) : (f32) -> f32 + %10 = arith.mulf %9, %cst : f32 + %11 = arith.addf %6, %10 : f32 + affine.store %11, %arg2[%arg3] : memref + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} + func.func private @exp2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_logaddexp2/raised.mlir b/issues/aten_c_kernels/results/aten_logaddexp2/raised.mlir new file mode 100644 index 000000000000..ec70cf6bd97b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logaddexp2/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logaddexp2(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.44269502 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %0 = arith.subf %in, %in_1 : f32 + %1 = arith.cmpf olt, %0, %cst_0 : f32 + %2 = arith.negf %0 : f32 + %3 = arith.select %1, %2, %0 : f32 + %4 = arith.cmpf ogt, %in, %in_1 : f32 + %5 = arith.select %4, %in, %in_1 : f32 + %6 = arith.negf %3 : f32 + %7 = math.exp2 %6 : f32 + %8 = math.log1p %7 : f32 + %9 = arith.mulf %8, %cst : f32 + %10 = arith.addf %5, %9 : f32 + linalg.yield %10 : f32 + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} + func.func private @exp2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_logaddexp2_debuf.mlir b/issues/aten_c_kernels/results/aten_logaddexp2_debuf.mlir new file mode 100644 index 000000000000..2e5f75f71048 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logaddexp2_debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logaddexp2(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.44269502 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %5 = arith.subf %in, %in_1 : f32 + %6 = arith.cmpf olt, %5, %cst : f32 + %7 = arith.negf %5 : f32 + %8 = arith.select %6, %7, %5 : f32 + %9 = arith.cmpf ogt, %in, %in_1 : f32 + %10 = arith.select %9, %in, %in_1 : f32 + %11 = arith.negf %8 : f32 + %12 = math.exp2 %11 : f32 + %13 = math.log1p %12 : f32 + %14 = arith.mulf %13, %cst_0 : f32 + %15 = arith.addf %10, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} + func.func private @exp2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_logaddexp2_linalg.mlir b/issues/aten_c_kernels/results/aten_logaddexp2_linalg.mlir new file mode 100644 index 000000000000..ec70cf6bd97b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logaddexp2_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logaddexp2(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.44269502 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %0 = arith.subf %in, %in_1 : f32 + %1 = arith.cmpf olt, %0, %cst_0 : f32 + %2 = arith.negf %0 : f32 + %3 = arith.select %1, %2, %0 : f32 + %4 = arith.cmpf ogt, %in, %in_1 : f32 + %5 = arith.select %4, %in, %in_1 : f32 + %6 = arith.negf %3 : f32 + %7 = math.exp2 %6 : f32 + %8 = math.log1p %7 : f32 + %9 = arith.mulf %8, %cst : f32 + %10 = arith.addf %5, %9 : f32 + linalg.yield %10 : f32 + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} + func.func private @exp2f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_logaddexp_debuf.mlir b/issues/aten_c_kernels/results/aten_logaddexp_debuf.mlir new file mode 100644 index 000000000000..388e438571fb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logaddexp_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logaddexp(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in, %in_0 : f32 + %6 = arith.cmpf olt, %5, %cst : f32 + %7 = arith.negf %5 : f32 + %8 = arith.select %6, %7, %5 : f32 + %9 = arith.cmpf ogt, %in, %in_0 : f32 + %10 = arith.select %9, %in, %in_0 : f32 + %11 = arith.negf %8 : f32 + %12 = math.exp %11 : f32 + %13 = math.log1p %12 : f32 + %14 = arith.addf %10, %13 : f32 + linalg.yield %14 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_logaddexp_linalg.mlir b/issues/aten_c_kernels/results/aten_logaddexp_linalg.mlir new file mode 100644 index 000000000000..85ca99c2ddae --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logaddexp_linalg.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logaddexp(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.subf %in, %in_0 : f32 + %1 = arith.cmpf olt, %0, %cst : f32 + %2 = arith.negf %0 : f32 + %3 = arith.select %1, %2, %0 : f32 + %4 = arith.cmpf ogt, %in, %in_0 : f32 + %5 = arith.select %4, %in, %in_0 : f32 + %6 = arith.negf %3 : f32 + %7 = math.exp %6 : f32 + %8 = math.log1p %7 : f32 + %9 = arith.addf %5, %8 : f32 + linalg.yield %9 : f32 + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_logcumsumexp_cpu.mlir b/issues/aten_c_kernels/results/aten_logcumsumexp_cpu.mlir new file mode 100644 index 000000000000..16358f017def --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logcumsumexp_cpu.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logcumsumexp_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 32 { + %0 = affine.load %arg0[%arg2, 0] : memref + affine.store %0, %arg1[%arg2, 0] : memref + %1 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %0) -> (f32) { + %2 = affine.load %arg0[%arg2, %arg3] : memref + %3 = arith.cmpf ogt, %arg4, %2 : f32 + %4 = arith.select %3, %arg4, %2 : f32 + %5 = arith.subf %arg4, %2 : f32 + %6 = arith.cmpf olt, %5, %cst : f32 + %7 = scf.if %6 -> (f32) { + %12 = arith.negf %5 : f32 + scf.yield %12 : f32 + } else { + scf.yield %5 : f32 + } + %8 = arith.negf %7 : f32 + %9 = math.exp %8 : f32 + %10 = func.call @log1pf(%9) : (f32) -> f32 + %11 = arith.addf %4, %10 : f32 + affine.store %11, %arg1[%arg2, %arg3] : memref + affine.yield %11 : f32 + } + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_logcumsumexp_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_logcumsumexp_cpu/debuf.mlir new file mode 100644 index 000000000000..10858ba78caa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logcumsumexp_cpu/debuf.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logcumsumexp_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c63 = arith.constant 63 : index + %c32 = arith.constant 32 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3:2 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %1, %arg4 = %2) -> (tensor, tensor) { + %extracted = tensor.extract %0[%arg2, %c0] : tensor + %inserted = tensor.insert %extracted into %arg3[%arg2, %c0] : tensor + %inserted_0 = tensor.insert %extracted into %arg4[%arg2] : tensor + %extracted_slice = tensor.extract_slice %0[%arg2, 1] [1, %c63] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %inserted[%arg2, 1] [1, %c63] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %inserted_0[%arg2] [1] [1] : tensor to tensor + %5:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_1, %extracted_slice_2 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_4: f32): + %6 = arith.cmpf ogt, %out_4, %in : f32 + %7 = arith.select %6, %out_4, %in : f32 + %8 = arith.subf %out_4, %in : f32 + %9 = arith.cmpf olt, %8, %cst : f32 + %10 = arith.negf %8 : f32 + %11 = arith.select %9, %10, %8 : f32 + %12 = arith.negf %11 : f32 + %13 = math.exp %12 : f32 + %14 = math.log1p %13 : f32 + %15 = arith.addf %7, %14 : f32 + linalg.yield %15, %15 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %5#0 into %inserted[%arg2, 1] [1, %c63] [1, 1] : tensor into tensor + %inserted_slice_3 = tensor.insert_slice %5#1 into %inserted_0[%arg2] [1] [1] : tensor into tensor + affine.yield %inserted_slice, %inserted_slice_3 : tensor, tensor + } + %4 = bufferization.to_memref %3#0 : memref + memref.copy %4, %arg1 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_logcumsumexp_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_logcumsumexp_cpu/matched.mlir new file mode 100644 index 000000000000..10858ba78caa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logcumsumexp_cpu/matched.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logcumsumexp_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c63 = arith.constant 63 : index + %c32 = arith.constant 32 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3:2 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %1, %arg4 = %2) -> (tensor, tensor) { + %extracted = tensor.extract %0[%arg2, %c0] : tensor + %inserted = tensor.insert %extracted into %arg3[%arg2, %c0] : tensor + %inserted_0 = tensor.insert %extracted into %arg4[%arg2] : tensor + %extracted_slice = tensor.extract_slice %0[%arg2, 1] [1, %c63] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %inserted[%arg2, 1] [1, %c63] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %inserted_0[%arg2] [1] [1] : tensor to tensor + %5:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_1, %extracted_slice_2 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_4: f32): + %6 = arith.cmpf ogt, %out_4, %in : f32 + %7 = arith.select %6, %out_4, %in : f32 + %8 = arith.subf %out_4, %in : f32 + %9 = arith.cmpf olt, %8, %cst : f32 + %10 = arith.negf %8 : f32 + %11 = arith.select %9, %10, %8 : f32 + %12 = arith.negf %11 : f32 + %13 = math.exp %12 : f32 + %14 = math.log1p %13 : f32 + %15 = arith.addf %7, %14 : f32 + linalg.yield %15, %15 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %5#0 into %inserted[%arg2, 1] [1, %c63] [1, 1] : tensor into tensor + %inserted_slice_3 = tensor.insert_slice %5#1 into %inserted_0[%arg2] [1] [1] : tensor into tensor + affine.yield %inserted_slice, %inserted_slice_3 : tensor, tensor + } + %4 = bufferization.to_memref %3#0 : memref + memref.copy %4, %arg1 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_logcumsumexp_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_logcumsumexp_cpu/orig.mlir new file mode 100644 index 000000000000..16358f017def --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logcumsumexp_cpu/orig.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logcumsumexp_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 32 { + %0 = affine.load %arg0[%arg2, 0] : memref + affine.store %0, %arg1[%arg2, 0] : memref + %1 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %0) -> (f32) { + %2 = affine.load %arg0[%arg2, %arg3] : memref + %3 = arith.cmpf ogt, %arg4, %2 : f32 + %4 = arith.select %3, %arg4, %2 : f32 + %5 = arith.subf %arg4, %2 : f32 + %6 = arith.cmpf olt, %5, %cst : f32 + %7 = scf.if %6 -> (f32) { + %12 = arith.negf %5 : f32 + scf.yield %12 : f32 + } else { + scf.yield %5 : f32 + } + %8 = arith.negf %7 : f32 + %9 = math.exp %8 : f32 + %10 = func.call @log1pf(%9) : (f32) -> f32 + %11 = arith.addf %4, %10 : f32 + affine.store %11, %arg1[%arg2, %arg3] : memref + affine.yield %11 : f32 + } + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_logcumsumexp_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_logcumsumexp_cpu/raised.mlir new file mode 100644 index 000000000000..bf8e741ba3a1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logcumsumexp_cpu/raised.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logcumsumexp_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c63 = arith.constant 63 : index + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca(%c32) : memref + affine.for %arg2 = 0 to 32 { + %0 = affine.load %arg0[%arg2, 0] : memref + affine.store %0, %arg1[%arg2, 0] : memref + affine.store %0, %alloca[%arg2] : memref + %subview = memref.subview %arg0[%arg2, 1] [1, %c63] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[%arg2, 1] [1, %c63] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[%arg2] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%subview_0, %subview_1 : memref>, memref>) { + ^bb0(%in: f32, %out: f32, %out_2: f32): + %1 = arith.cmpf ogt, %out_2, %in : f32 + %2 = arith.select %1, %out_2, %in : f32 + %3 = arith.subf %out_2, %in : f32 + %4 = arith.cmpf olt, %3, %cst : f32 + %5 = arith.negf %3 : f32 + %6 = arith.select %4, %5, %3 : f32 + %7 = arith.negf %6 : f32 + %8 = math.exp %7 : f32 + %9 = math.log1p %8 : f32 + %10 = arith.addf %2, %9 : f32 + linalg.yield %10, %10 : f32, f32 + } + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_logcumsumexp_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_logcumsumexp_cpu_debuf.mlir new file mode 100644 index 000000000000..10858ba78caa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logcumsumexp_cpu_debuf.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logcumsumexp_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c63 = arith.constant 63 : index + %c32 = arith.constant 32 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3:2 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %1, %arg4 = %2) -> (tensor, tensor) { + %extracted = tensor.extract %0[%arg2, %c0] : tensor + %inserted = tensor.insert %extracted into %arg3[%arg2, %c0] : tensor + %inserted_0 = tensor.insert %extracted into %arg4[%arg2] : tensor + %extracted_slice = tensor.extract_slice %0[%arg2, 1] [1, %c63] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %inserted[%arg2, 1] [1, %c63] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %inserted_0[%arg2] [1] [1] : tensor to tensor + %5:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_1, %extracted_slice_2 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_4: f32): + %6 = arith.cmpf ogt, %out_4, %in : f32 + %7 = arith.select %6, %out_4, %in : f32 + %8 = arith.subf %out_4, %in : f32 + %9 = arith.cmpf olt, %8, %cst : f32 + %10 = arith.negf %8 : f32 + %11 = arith.select %9, %10, %8 : f32 + %12 = arith.negf %11 : f32 + %13 = math.exp %12 : f32 + %14 = math.log1p %13 : f32 + %15 = arith.addf %7, %14 : f32 + linalg.yield %15, %15 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %5#0 into %inserted[%arg2, 1] [1, %c63] [1, 1] : tensor into tensor + %inserted_slice_3 = tensor.insert_slice %5#1 into %inserted_0[%arg2] [1] [1] : tensor into tensor + affine.yield %inserted_slice, %inserted_slice_3 : tensor, tensor + } + %4 = bufferization.to_memref %3#0 : memref + memref.copy %4, %arg1 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_logcumsumexp_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_logcumsumexp_cpu_linalg.mlir new file mode 100644 index 000000000000..bf8e741ba3a1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logcumsumexp_cpu_linalg.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logcumsumexp_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c63 = arith.constant 63 : index + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca(%c32) : memref + affine.for %arg2 = 0 to 32 { + %0 = affine.load %arg0[%arg2, 0] : memref + affine.store %0, %arg1[%arg2, 0] : memref + affine.store %0, %alloca[%arg2] : memref + %subview = memref.subview %arg0[%arg2, 1] [1, %c63] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[%arg2, 1] [1, %c63] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[%arg2] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%subview_0, %subview_1 : memref>, memref>) { + ^bb0(%in: f32, %out: f32, %out_2: f32): + %1 = arith.cmpf ogt, %out_2, %in : f32 + %2 = arith.select %1, %out_2, %in : f32 + %3 = arith.subf %out_2, %in : f32 + %4 = arith.cmpf olt, %3, %cst : f32 + %5 = arith.negf %3 : f32 + %6 = arith.select %4, %5, %3 : f32 + %7 = arith.negf %6 : f32 + %8 = math.exp %7 : f32 + %9 = math.log1p %8 : f32 + %10 = arith.addf %2, %9 : f32 + linalg.yield %10, %10 : f32, f32 + } + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_logical_and.mlir b/issues/aten_c_kernels/results/aten_logical_and.mlir new file mode 100644 index 000000000000..730d0242e909 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_and.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_and(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf une, %0, %cst : f32 + %2 = scf.if %1 -> (i1) { + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf une, %5, %cst : f32 + scf.yield %6 : i1 + } else { + scf.yield %false : i1 + } + %3 = arith.extsi %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_logical_and/debuf.mlir b/issues/aten_c_kernels/results/aten_logical_and/debuf.mlir new file mode 100644 index 000000000000..9c99fa5f0f12 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_and/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_and(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %false = arith.constant false + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf une, %in, %cst : f32 + %6 = arith.cmpf une, %in_0, %cst : f32 + %7 = arith.select %5, %6, %false : i1 + %8 = arith.extsi %7 : i1 to i32 + %9 = arith.sitofp %8 : i32 to f32 + linalg.yield %9 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_and/matched.mlir b/issues/aten_c_kernels/results/aten_logical_and/matched.mlir new file mode 100644 index 000000000000..9c99fa5f0f12 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_and/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_and(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %false = arith.constant false + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf une, %in, %cst : f32 + %6 = arith.cmpf une, %in_0, %cst : f32 + %7 = arith.select %5, %6, %false : i1 + %8 = arith.extsi %7 : i1 to i32 + %9 = arith.sitofp %8 : i32 to f32 + linalg.yield %9 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_and/orig.mlir b/issues/aten_c_kernels/results/aten_logical_and/orig.mlir new file mode 100644 index 000000000000..730d0242e909 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_and/orig.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_and(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf une, %0, %cst : f32 + %2 = scf.if %1 -> (i1) { + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf une, %5, %cst : f32 + scf.yield %6 : i1 + } else { + scf.yield %false : i1 + } + %3 = arith.extsi %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_logical_and/raised.mlir b/issues/aten_c_kernels/results/aten_logical_and/raised.mlir new file mode 100644 index 000000000000..b3e19bfb82ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_and/raised.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_and(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf une, %in, %cst : f32 + %1 = arith.cmpf une, %in_0, %cst : f32 + %2 = arith.select %0, %1, %false : i1 + %3 = arith.extsi %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_and_debuf.mlir b/issues/aten_c_kernels/results/aten_logical_and_debuf.mlir new file mode 100644 index 000000000000..9c99fa5f0f12 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_and_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_and(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %false = arith.constant false + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf une, %in, %cst : f32 + %6 = arith.cmpf une, %in_0, %cst : f32 + %7 = arith.select %5, %6, %false : i1 + %8 = arith.extsi %7 : i1 to i32 + %9 = arith.sitofp %8 : i32 to f32 + linalg.yield %9 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_and_linalg.mlir b/issues/aten_c_kernels/results/aten_logical_and_linalg.mlir new file mode 100644 index 000000000000..b3e19bfb82ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_and_linalg.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_and(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf une, %in, %cst : f32 + %1 = arith.cmpf une, %in_0, %cst : f32 + %2 = arith.select %0, %1, %false : i1 + %3 = arith.extsi %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_not_f32.mlir b/issues/aten_c_kernels/results/aten_logical_not_f32.mlir new file mode 100644 index 000000000000..4379801940a7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_not_f32.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_not_f32(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.cmpf une, %0, %cst : f32 + %2 = arith.xori %1, %true : i1 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_logical_not_f32/debuf.mlir b/issues/aten_c_kernels/results/aten_logical_not_f32/debuf.mlir new file mode 100644 index 000000000000..7ff984aa20ac --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_not_f32/debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_not_f32(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %true = arith.constant true + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf une, %in, %cst : f32 + %5 = arith.xori %4, %true : i1 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_not_f32/matched.mlir b/issues/aten_c_kernels/results/aten_logical_not_f32/matched.mlir new file mode 100644 index 000000000000..7ff984aa20ac --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_not_f32/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_not_f32(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %true = arith.constant true + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf une, %in, %cst : f32 + %5 = arith.xori %4, %true : i1 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_not_f32/orig.mlir b/issues/aten_c_kernels/results/aten_logical_not_f32/orig.mlir new file mode 100644 index 000000000000..4379801940a7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_not_f32/orig.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_not_f32(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.cmpf une, %0, %cst : f32 + %2 = arith.xori %1, %true : i1 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_logical_not_f32/raised.mlir b/issues/aten_c_kernels/results/aten_logical_not_f32/raised.mlir new file mode 100644 index 000000000000..6fab0c1f40f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_not_f32/raised.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_not_f32(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf une, %in, %cst : f32 + %1 = arith.xori %0, %true : i1 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.sitofp %2 : i32 to f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_not_f32_debuf.mlir b/issues/aten_c_kernels/results/aten_logical_not_f32_debuf.mlir new file mode 100644 index 000000000000..7ff984aa20ac --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_not_f32_debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_not_f32(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %true = arith.constant true + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf une, %in, %cst : f32 + %5 = arith.xori %4, %true : i1 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_not_f32_linalg.mlir b/issues/aten_c_kernels/results/aten_logical_not_f32_linalg.mlir new file mode 100644 index 000000000000..6fab0c1f40f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_not_f32_linalg.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_not_f32(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf une, %in, %cst : f32 + %1 = arith.xori %0, %true : i1 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.sitofp %2 : i32 to f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_or.mlir b/issues/aten_c_kernels/results/aten_logical_or.mlir new file mode 100644 index 000000000000..cd3383b1eef8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_or.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_or(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf une, %0, %cst : f32 + %2 = scf.if %1 -> (i1) { + scf.yield %true : i1 + } else { + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf une, %5, %cst : f32 + scf.yield %6 : i1 + } + %3 = arith.extsi %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_logical_or/debuf.mlir b/issues/aten_c_kernels/results/aten_logical_or/debuf.mlir new file mode 100644 index 000000000000..477bb9d783aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_or/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_or(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %true = arith.constant true + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf une, %in, %cst : f32 + %6 = arith.cmpf une, %in_0, %cst : f32 + %7 = arith.select %5, %true, %6 : i1 + %8 = arith.extsi %7 : i1 to i32 + %9 = arith.sitofp %8 : i32 to f32 + linalg.yield %9 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_or/matched.mlir b/issues/aten_c_kernels/results/aten_logical_or/matched.mlir new file mode 100644 index 000000000000..477bb9d783aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_or/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_or(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %true = arith.constant true + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf une, %in, %cst : f32 + %6 = arith.cmpf une, %in_0, %cst : f32 + %7 = arith.select %5, %true, %6 : i1 + %8 = arith.extsi %7 : i1 to i32 + %9 = arith.sitofp %8 : i32 to f32 + linalg.yield %9 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_or/orig.mlir b/issues/aten_c_kernels/results/aten_logical_or/orig.mlir new file mode 100644 index 000000000000..cd3383b1eef8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_or/orig.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_or(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf une, %0, %cst : f32 + %2 = scf.if %1 -> (i1) { + scf.yield %true : i1 + } else { + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf une, %5, %cst : f32 + scf.yield %6 : i1 + } + %3 = arith.extsi %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_logical_or/raised.mlir b/issues/aten_c_kernels/results/aten_logical_or/raised.mlir new file mode 100644 index 000000000000..4e502b3c7f2f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_or/raised.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_or(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf une, %in, %cst : f32 + %1 = arith.cmpf une, %in_0, %cst : f32 + %2 = arith.select %0, %true, %1 : i1 + %3 = arith.extsi %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_or_debuf.mlir b/issues/aten_c_kernels/results/aten_logical_or_debuf.mlir new file mode 100644 index 000000000000..477bb9d783aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_or_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_or(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %true = arith.constant true + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf une, %in, %cst : f32 + %6 = arith.cmpf une, %in_0, %cst : f32 + %7 = arith.select %5, %true, %6 : i1 + %8 = arith.extsi %7 : i1 to i32 + %9 = arith.sitofp %8 : i32 to f32 + linalg.yield %9 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_or_linalg.mlir b/issues/aten_c_kernels/results/aten_logical_or_linalg.mlir new file mode 100644 index 000000000000..4e502b3c7f2f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_or_linalg.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_or(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf une, %in, %cst : f32 + %1 = arith.cmpf une, %in_0, %cst : f32 + %2 = arith.select %0, %true, %1 : i1 + %3 = arith.extsi %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_xor.mlir b/issues/aten_c_kernels/results/aten_logical_xor.mlir new file mode 100644 index 000000000000..53880684123b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_xor.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_xor(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf une, %0, %cst : f32 + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.cmpf une, %2, %cst : f32 + %4 = arith.cmpi ne, %1, %3 : i1 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.sitofp %5 : i32 to f32 + affine.store %6, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_logical_xor/debuf.mlir b/issues/aten_c_kernels/results/aten_logical_xor/debuf.mlir new file mode 100644 index 000000000000..fe884a7c4882 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_xor/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_xor(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf une, %in, %cst : f32 + %6 = arith.cmpf une, %in_0, %cst : f32 + %7 = arith.cmpi ne, %5, %6 : i1 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.sitofp %8 : i32 to f32 + linalg.yield %9 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_xor/matched.mlir b/issues/aten_c_kernels/results/aten_logical_xor/matched.mlir new file mode 100644 index 000000000000..fe884a7c4882 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_xor/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_xor(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf une, %in, %cst : f32 + %6 = arith.cmpf une, %in_0, %cst : f32 + %7 = arith.cmpi ne, %5, %6 : i1 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.sitofp %8 : i32 to f32 + linalg.yield %9 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_xor/orig.mlir b/issues/aten_c_kernels/results/aten_logical_xor/orig.mlir new file mode 100644 index 000000000000..53880684123b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_xor/orig.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_xor(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf une, %0, %cst : f32 + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.cmpf une, %2, %cst : f32 + %4 = arith.cmpi ne, %1, %3 : i1 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.sitofp %5 : i32 to f32 + affine.store %6, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_logical_xor/raised.mlir b/issues/aten_c_kernels/results/aten_logical_xor/raised.mlir new file mode 100644 index 000000000000..62314b2d5806 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_xor/raised.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_xor(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf une, %in, %cst : f32 + %1 = arith.cmpf une, %in_0, %cst : f32 + %2 = arith.cmpi ne, %0, %1 : i1 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_xor_debuf.mlir b/issues/aten_c_kernels/results/aten_logical_xor_debuf.mlir new file mode 100644 index 000000000000..fe884a7c4882 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_xor_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_xor(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf une, %in, %cst : f32 + %6 = arith.cmpf une, %in_0, %cst : f32 + %7 = arith.cmpi ne, %5, %6 : i1 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.sitofp %8 : i32 to f32 + linalg.yield %9 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logical_xor_linalg.mlir b/issues/aten_c_kernels/results/aten_logical_xor_linalg.mlir new file mode 100644 index 000000000000..62314b2d5806 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logical_xor_linalg.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logical_xor(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf une, %in, %cst : f32 + %1 = arith.cmpf une, %in_0, %cst : f32 + %2 = arith.cmpi ne, %0, %1 : i1 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logit.mlir b/issues/aten_c_kernels/results/aten_logit.mlir new file mode 100644 index 000000000000..7b849b402b63 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logit.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logit(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = arith.subf %cst, %arg1 : f32 + affine.for %arg3 = 0 to 4096 { + %1 = affine.load %arg0[%arg3] : memref + %2 = arith.cmpf olt, %1, %arg1 : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %arg1 : f32 + } else { + %7 = arith.cmpf ogt, %1, %0 : f32 + %8 = arith.select %7, %0, %1 : f32 + scf.yield %8 : f32 + } + %4 = arith.subf %cst, %3 : f32 + %5 = arith.divf %3, %4 : f32 + %6 = func.call @logf(%5) : (f32) -> f32 + affine.store %6, %arg2[%arg3] : memref + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_logit/debuf.mlir b/issues/aten_c_kernels/results/aten_logit/debuf.mlir new file mode 100644 index 000000000000..34989093d809 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logit/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logit(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.subf %cst, %arg1 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %arg1 : f32 + %6 = arith.cmpf ogt, %in, %2 : f32 + %7 = arith.select %6, %2, %in : f32 + %8 = arith.select %5, %arg1, %7 : f32 + %9 = arith.subf %cst, %8 : f32 + %10 = arith.divf %8, %9 : f32 + %11 = math.log %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_logit/matched.mlir b/issues/aten_c_kernels/results/aten_logit/matched.mlir new file mode 100644 index 000000000000..34989093d809 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logit/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logit(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.subf %cst, %arg1 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %arg1 : f32 + %6 = arith.cmpf ogt, %in, %2 : f32 + %7 = arith.select %6, %2, %in : f32 + %8 = arith.select %5, %arg1, %7 : f32 + %9 = arith.subf %cst, %8 : f32 + %10 = arith.divf %8, %9 : f32 + %11 = math.log %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_logit/orig.mlir b/issues/aten_c_kernels/results/aten_logit/orig.mlir new file mode 100644 index 000000000000..7b849b402b63 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logit/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logit(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = arith.subf %cst, %arg1 : f32 + affine.for %arg3 = 0 to 4096 { + %1 = affine.load %arg0[%arg3] : memref + %2 = arith.cmpf olt, %1, %arg1 : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %arg1 : f32 + } else { + %7 = arith.cmpf ogt, %1, %0 : f32 + %8 = arith.select %7, %0, %1 : f32 + scf.yield %8 : f32 + } + %4 = arith.subf %cst, %3 : f32 + %5 = arith.divf %3, %4 : f32 + %6 = func.call @logf(%5) : (f32) -> f32 + affine.store %6, %arg2[%arg3] : memref + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_logit/raised.mlir b/issues/aten_c_kernels/results/aten_logit/raised.mlir new file mode 100644 index 000000000000..dc1501383eeb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logit/raised.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logit(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = arith.subf %cst, %arg1 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.cmpf olt, %in, %arg1 : f32 + %2 = arith.cmpf ogt, %in, %0 : f32 + %3 = arith.select %2, %0, %in : f32 + %4 = arith.select %1, %arg1, %3 : f32 + %5 = arith.subf %cst, %4 : f32 + %6 = arith.divf %4, %5 : f32 + %7 = math.log %6 : f32 + linalg.yield %7 : f32 + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_logit_backward.mlir b/issues/aten_c_kernels/results/aten_logit_backward.mlir new file mode 100644 index 000000000000..b4e971b33383 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logit_backward.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logit_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = arith.subf %cst_0, %arg2 : f32 + affine.for %arg4 = 0 to 4096 { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.cmpf olt, %1, %arg2 : f32 + %3 = scf.if %2 -> (i1) { + scf.yield %true : i1 + } else { + %5 = arith.cmpf ogt, %1, %0 : f32 + scf.yield %5 : i1 + } + %4 = scf.if %3 -> (f32) { + scf.yield %cst : f32 + } else { + %5 = affine.load %arg0[%arg4] : memref + %6 = arith.subf %cst_0, %1 : f32 + %7 = arith.mulf %1, %6 : f32 + %8 = arith.divf %5, %7 : f32 + scf.yield %8 : f32 + } + affine.store %4, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_logit_backward/debuf.mlir b/issues/aten_c_kernels/results/aten_logit_backward/debuf.mlir new file mode 100644 index 000000000000..c0fde23e9937 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logit_backward/debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logit_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %true = arith.constant true + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.subf %cst, %arg2 : f32 + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %6 = arith.cmpf olt, %in, %arg2 : f32 + %7 = arith.cmpf ogt, %in, %3 : f32 + %8 = arith.select %6, %true, %7 : i1 + %9 = arith.subf %cst, %in : f32 + %10 = arith.mulf %in, %9 : f32 + %11 = arith.divf %in_1, %10 : f32 + %12 = arith.select %8, %cst_0, %11 : f32 + linalg.yield %12 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logit_backward/matched.mlir b/issues/aten_c_kernels/results/aten_logit_backward/matched.mlir new file mode 100644 index 000000000000..c0fde23e9937 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logit_backward/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logit_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %true = arith.constant true + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.subf %cst, %arg2 : f32 + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %6 = arith.cmpf olt, %in, %arg2 : f32 + %7 = arith.cmpf ogt, %in, %3 : f32 + %8 = arith.select %6, %true, %7 : i1 + %9 = arith.subf %cst, %in : f32 + %10 = arith.mulf %in, %9 : f32 + %11 = arith.divf %in_1, %10 : f32 + %12 = arith.select %8, %cst_0, %11 : f32 + linalg.yield %12 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logit_backward/orig.mlir b/issues/aten_c_kernels/results/aten_logit_backward/orig.mlir new file mode 100644 index 000000000000..b4e971b33383 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logit_backward/orig.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logit_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = arith.subf %cst_0, %arg2 : f32 + affine.for %arg4 = 0 to 4096 { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.cmpf olt, %1, %arg2 : f32 + %3 = scf.if %2 -> (i1) { + scf.yield %true : i1 + } else { + %5 = arith.cmpf ogt, %1, %0 : f32 + scf.yield %5 : i1 + } + %4 = scf.if %3 -> (f32) { + scf.yield %cst : f32 + } else { + %5 = affine.load %arg0[%arg4] : memref + %6 = arith.subf %cst_0, %1 : f32 + %7 = arith.mulf %1, %6 : f32 + %8 = arith.divf %5, %7 : f32 + scf.yield %8 : f32 + } + affine.store %4, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_logit_backward/raised.mlir b/issues/aten_c_kernels/results/aten_logit_backward/raised.mlir new file mode 100644 index 000000000000..37cf4830b229 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logit_backward/raised.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logit_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = arith.subf %cst_0, %arg2 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %1 = arith.cmpf olt, %in, %arg2 : f32 + %2 = arith.cmpf ogt, %in, %0 : f32 + %3 = arith.select %1, %true, %2 : i1 + %4 = arith.subf %cst_0, %in : f32 + %5 = arith.mulf %in, %4 : f32 + %6 = arith.divf %in_1, %5 : f32 + %7 = arith.select %3, %cst, %6 : f32 + linalg.yield %7 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logit_backward_debuf.mlir b/issues/aten_c_kernels/results/aten_logit_backward_debuf.mlir new file mode 100644 index 000000000000..c0fde23e9937 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logit_backward_debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logit_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %true = arith.constant true + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.subf %cst, %arg2 : f32 + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %6 = arith.cmpf olt, %in, %arg2 : f32 + %7 = arith.cmpf ogt, %in, %3 : f32 + %8 = arith.select %6, %true, %7 : i1 + %9 = arith.subf %cst, %in : f32 + %10 = arith.mulf %in, %9 : f32 + %11 = arith.divf %in_1, %10 : f32 + %12 = arith.select %8, %cst_0, %11 : f32 + linalg.yield %12 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logit_backward_linalg.mlir b/issues/aten_c_kernels/results/aten_logit_backward_linalg.mlir new file mode 100644 index 000000000000..37cf4830b229 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logit_backward_linalg.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logit_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = arith.subf %cst_0, %arg2 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %1 = arith.cmpf olt, %in, %arg2 : f32 + %2 = arith.cmpf ogt, %in, %0 : f32 + %3 = arith.select %1, %true, %2 : i1 + %4 = arith.subf %cst_0, %in : f32 + %5 = arith.mulf %in, %4 : f32 + %6 = arith.divf %in_1, %5 : f32 + %7 = arith.select %3, %cst, %6 : f32 + linalg.yield %7 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logit_debuf.mlir b/issues/aten_c_kernels/results/aten_logit_debuf.mlir new file mode 100644 index 000000000000..34989093d809 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logit_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logit(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.subf %cst, %arg1 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %arg1 : f32 + %6 = arith.cmpf ogt, %in, %2 : f32 + %7 = arith.select %6, %2, %in : f32 + %8 = arith.select %5, %arg1, %7 : f32 + %9 = arith.subf %cst, %8 : f32 + %10 = arith.divf %8, %9 : f32 + %11 = math.log %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_logit_linalg.mlir b/issues/aten_c_kernels/results/aten_logit_linalg.mlir new file mode 100644 index 000000000000..dc1501383eeb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logit_linalg.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logit(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = arith.subf %cst, %arg1 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.cmpf olt, %in, %arg1 : f32 + %2 = arith.cmpf ogt, %in, %0 : f32 + %3 = arith.select %2, %0, %in : f32 + %4 = arith.select %1, %arg1, %3 : f32 + %5 = arith.subf %cst, %4 : f32 + %6 = arith.divf %4, %5 : f32 + %7 = math.log %6 : f32 + linalg.yield %7 : f32 + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_logspace_cpu.mlir b/issues/aten_c_kernels/results/aten_logspace_cpu.mlir new file mode 100644 index 000000000000..81afb86394d2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logspace_cpu.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logspace_cpu(%arg0: f32, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.550000e+02 : f32 + %0 = arith.subf %arg1, %arg0 : f32 + affine.for %arg4 = 0 to 256 { + %1 = arith.index_cast %arg4 : index to i32 + %2 = arith.sitofp %1 : i32 to f32 + %3 = arith.mulf %0, %2 : f32 + %4 = arith.divf %3, %cst : f32 + %5 = arith.addf %arg0, %4 : f32 + %6 = math.powf %arg2, %5 : f32 + affine.store %6, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_logspace_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_logspace_cpu/debuf.mlir new file mode 100644 index 000000000000..8cdc54e6ff2f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logspace_cpu/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logspace_cpu(%arg0: f32, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.550000e+02 : f32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = arith.subf %arg1, %arg0 : f32 + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %4 = linalg.index 0 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.mulf %1, %6 : f32 + %8 = arith.divf %7, %cst : f32 + %9 = arith.addf %arg0, %8 : f32 + %10 = math.powf %arg2, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logspace_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_logspace_cpu/matched.mlir new file mode 100644 index 000000000000..8cdc54e6ff2f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logspace_cpu/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logspace_cpu(%arg0: f32, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.550000e+02 : f32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = arith.subf %arg1, %arg0 : f32 + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %4 = linalg.index 0 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.mulf %1, %6 : f32 + %8 = arith.divf %7, %cst : f32 + %9 = arith.addf %arg0, %8 : f32 + %10 = math.powf %arg2, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logspace_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_logspace_cpu/orig.mlir new file mode 100644 index 000000000000..81afb86394d2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logspace_cpu/orig.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logspace_cpu(%arg0: f32, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.550000e+02 : f32 + %0 = arith.subf %arg1, %arg0 : f32 + affine.for %arg4 = 0 to 256 { + %1 = arith.index_cast %arg4 : index to i32 + %2 = arith.sitofp %1 : i32 to f32 + %3 = arith.mulf %0, %2 : f32 + %4 = arith.divf %3, %cst : f32 + %5 = arith.addf %arg0, %4 : f32 + %6 = math.powf %arg2, %5 : f32 + affine.store %6, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_logspace_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_logspace_cpu/raised.mlir new file mode 100644 index 000000000000..1ce962fc858f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logspace_cpu/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logspace_cpu(%arg0: f32, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.550000e+02 : f32 + %0 = arith.subf %arg1, %arg0 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg3 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.mulf %0, %3 : f32 + %5 = arith.divf %4, %cst : f32 + %6 = arith.addf %arg0, %5 : f32 + %7 = math.powf %arg2, %6 : f32 + linalg.yield %7 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logspace_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_logspace_cpu_debuf.mlir new file mode 100644 index 000000000000..8cdc54e6ff2f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logspace_cpu_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logspace_cpu(%arg0: f32, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.550000e+02 : f32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = arith.subf %arg1, %arg0 : f32 + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %4 = linalg.index 0 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.mulf %1, %6 : f32 + %8 = arith.divf %7, %cst : f32 + %9 = arith.addf %arg0, %8 : f32 + %10 = math.powf %arg2, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_logspace_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_logspace_cpu_linalg.mlir new file mode 100644 index 000000000000..1ce962fc858f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_logspace_cpu_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_logspace_cpu(%arg0: f32, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.550000e+02 : f32 + %0 = arith.subf %arg1, %arg0 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg3 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.mulf %0, %3 : f32 + %5 = arith.divf %4, %cst : f32 + %6 = arith.addf %arg0, %5 : f32 + %7 = math.powf %arg2, %6 : f32 + linalg.yield %7 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lower_bound_cpu.mlir b/issues/aten_c_kernels/results/aten_lower_bound_cpu.mlir new file mode 100644 index 000000000000..6eeb3fb78356 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lower_bound_cpu.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lower_bound_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c256_i32 = arith.constant 256 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0:2 = scf.while (%arg4 = %c256_i32, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %1 = arith.cmpi slt, %arg5, %arg4 : i32 + scf.condition(%1) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %1 = arith.addi %arg4, %arg5 : i32 + %2 = arith.divsi %1, %c2_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3] : memref + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf olt, %4, %5 : f32 + %7 = arith.select %6, %arg5, %2 : i32 + %8 = scf.if %6 -> (i32) { + %9 = arith.addi %2, %c1_i32 : i32 + scf.yield %9 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %7, %8 : i32, i32 + } + affine.store %0#0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_lower_bound_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_lower_bound_cpu/debuf.mlir new file mode 100644 index 000000000000..362c3cf50877 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lower_bound_cpu/debuf.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lower_bound_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c256_i32 = arith.constant 256 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c256_i32, %arg6 = %c0_i32) : (i32, i32) -> (i32, i32) { + %6 = arith.cmpi slt, %arg6, %arg5 : i32 + scf.condition(%6) %arg6, %arg5 : i32, i32 + } do { + ^bb0(%arg5: i32, %arg6: i32): + %6 = arith.addi %arg5, %arg6 : i32 + %7 = arith.divsi %6, %c2_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %extracted = tensor.extract %2[%8] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %9 = arith.cmpf olt, %extracted, %extracted_0 : f32 + %10 = arith.select %9, %arg6, %7 : i32 + %11 = arith.addi %7, %c1_i32 : i32 + %12 = arith.select %9, %11, %arg5 : i32 + scf.yield %10, %12 : i32, i32 + } + %inserted = tensor.insert %5#0 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lower_bound_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_lower_bound_cpu/matched.mlir new file mode 100644 index 000000000000..362c3cf50877 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lower_bound_cpu/matched.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lower_bound_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c256_i32 = arith.constant 256 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c256_i32, %arg6 = %c0_i32) : (i32, i32) -> (i32, i32) { + %6 = arith.cmpi slt, %arg6, %arg5 : i32 + scf.condition(%6) %arg6, %arg5 : i32, i32 + } do { + ^bb0(%arg5: i32, %arg6: i32): + %6 = arith.addi %arg5, %arg6 : i32 + %7 = arith.divsi %6, %c2_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %extracted = tensor.extract %2[%8] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %9 = arith.cmpf olt, %extracted, %extracted_0 : f32 + %10 = arith.select %9, %arg6, %7 : i32 + %11 = arith.addi %7, %c1_i32 : i32 + %12 = arith.select %9, %11, %arg5 : i32 + scf.yield %10, %12 : i32, i32 + } + %inserted = tensor.insert %5#0 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lower_bound_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_lower_bound_cpu/orig.mlir new file mode 100644 index 000000000000..6eeb3fb78356 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lower_bound_cpu/orig.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lower_bound_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c256_i32 = arith.constant 256 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0:2 = scf.while (%arg4 = %c256_i32, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %1 = arith.cmpi slt, %arg5, %arg4 : i32 + scf.condition(%1) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %1 = arith.addi %arg4, %arg5 : i32 + %2 = arith.divsi %1, %c2_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3] : memref + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf olt, %4, %5 : f32 + %7 = arith.select %6, %arg5, %2 : i32 + %8 = scf.if %6 -> (i32) { + %9 = arith.addi %2, %c1_i32 : i32 + scf.yield %9 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %7, %8 : i32, i32 + } + affine.store %0#0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_lower_bound_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_lower_bound_cpu/raised.mlir new file mode 100644 index 000000000000..66c41b74bdaa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lower_bound_cpu/raised.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lower_bound_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c256_i32 = arith.constant 256 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0:2 = scf.while (%arg4 = %c256_i32, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %1 = arith.cmpi slt, %arg5, %arg4 : i32 + scf.condition(%1) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %1 = arith.addi %arg4, %arg5 : i32 + %2 = arith.divsi %1, %c2_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3] : memref + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf olt, %4, %5 : f32 + %7 = arith.select %6, %arg5, %2 : i32 + %8 = arith.addi %2, %c1_i32 : i32 + %9 = arith.select %6, %8, %arg4 : i32 + scf.yield %7, %9 : i32, i32 + } + affine.store %0#0, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lower_bound_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_lower_bound_cpu_debuf.mlir new file mode 100644 index 000000000000..362c3cf50877 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lower_bound_cpu_debuf.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lower_bound_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c256_i32 = arith.constant 256 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c256_i32, %arg6 = %c0_i32) : (i32, i32) -> (i32, i32) { + %6 = arith.cmpi slt, %arg6, %arg5 : i32 + scf.condition(%6) %arg6, %arg5 : i32, i32 + } do { + ^bb0(%arg5: i32, %arg6: i32): + %6 = arith.addi %arg5, %arg6 : i32 + %7 = arith.divsi %6, %c2_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %extracted = tensor.extract %2[%8] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %9 = arith.cmpf olt, %extracted, %extracted_0 : f32 + %10 = arith.select %9, %arg6, %7 : i32 + %11 = arith.addi %7, %c1_i32 : i32 + %12 = arith.select %9, %11, %arg5 : i32 + scf.yield %10, %12 : i32, i32 + } + %inserted = tensor.insert %5#0 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lower_bound_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_lower_bound_cpu_linalg.mlir new file mode 100644 index 000000000000..66c41b74bdaa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lower_bound_cpu_linalg.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lower_bound_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c256_i32 = arith.constant 256 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0:2 = scf.while (%arg4 = %c256_i32, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %1 = arith.cmpi slt, %arg5, %arg4 : i32 + scf.condition(%1) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %1 = arith.addi %arg4, %arg5 : i32 + %2 = arith.divsi %1, %c2_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3] : memref + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf olt, %4, %5 : f32 + %7 = arith.select %6, %arg5, %2 : i32 + %8 = arith.addi %2, %c1_i32 : i32 + %9 = arith.select %6, %8, %arg4 : i32 + scf.yield %7, %9 : i32, i32 + } + affine.store %0#0, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lshift_i32.mlir b/issues/aten_c_kernels/results/aten_lshift_i32.mlir new file mode 100644 index 000000000000..fb5f42ba7637 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lshift_i32.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lshift_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.shli %0, %1 : i32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_lshift_i32/debuf.mlir b/issues/aten_c_kernels/results/aten_lshift_i32/debuf.mlir new file mode 100644 index 000000000000..b200c05167b0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lshift_i32/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lshift_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.shli %in, %in_0 : i32 + linalg.yield %5 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lshift_i32/matched.mlir b/issues/aten_c_kernels/results/aten_lshift_i32/matched.mlir new file mode 100644 index 000000000000..b200c05167b0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lshift_i32/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lshift_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.shli %in, %in_0 : i32 + linalg.yield %5 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lshift_i32/orig.mlir b/issues/aten_c_kernels/results/aten_lshift_i32/orig.mlir new file mode 100644 index 000000000000..fb5f42ba7637 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lshift_i32/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lshift_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.shli %0, %1 : i32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_lshift_i32/raised.mlir b/issues/aten_c_kernels/results/aten_lshift_i32/raised.mlir new file mode 100644 index 000000000000..c4bf71c3e507 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lshift_i32/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lshift_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %0 = arith.shli %in, %in_0 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lshift_i32_debuf.mlir b/issues/aten_c_kernels/results/aten_lshift_i32_debuf.mlir new file mode 100644 index 000000000000..b200c05167b0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lshift_i32_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lshift_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.shli %in, %in_0 : i32 + linalg.yield %5 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lshift_i32_linalg.mlir b/issues/aten_c_kernels/results/aten_lshift_i32_linalg.mlir new file mode 100644 index 000000000000..c4bf71c3e507 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lshift_i32_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lshift_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %0 = arith.shli %in, %in_0 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lt.mlir b/issues/aten_c_kernels/results/aten_lt.mlir new file mode 100644 index 000000000000..01055936e553 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lt.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lt(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf olt, %0, %1 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_lt/debuf.mlir b/issues/aten_c_kernels/results/aten_lt/debuf.mlir new file mode 100644 index 000000000000..39eb67110afd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lt/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lt(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf olt, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lt/matched.mlir b/issues/aten_c_kernels/results/aten_lt/matched.mlir new file mode 100644 index 000000000000..39eb67110afd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lt/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lt(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf olt, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lt/orig.mlir b/issues/aten_c_kernels/results/aten_lt/orig.mlir new file mode 100644 index 000000000000..01055936e553 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lt/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lt(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf olt, %0, %1 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_lt/raised.mlir b/issues/aten_c_kernels/results/aten_lt/raised.mlir new file mode 100644 index 000000000000..275dd5c0895f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lt/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lt(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf olt, %in, %in_0 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lt_debuf.mlir b/issues/aten_c_kernels/results/aten_lt_debuf.mlir new file mode 100644 index 000000000000..39eb67110afd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lt_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lt(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf olt, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_lt_linalg.mlir b/issues/aten_c_kernels/results/aten_lt_linalg.mlir new file mode 100644 index 000000000000..275dd5c0895f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_lt_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_lt(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf olt, %in, %in_0 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_fill_cpu.mlir b/issues/aten_c_kernels/results/aten_masked_fill_cpu.mlir new file mode 100644 index 000000000000..2f64bf208fb1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_fill_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.cmpi ne, %0, %c0_i32 : i32 + scf.if %1 { + affine.store %arg2, %arg0[%arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_masked_fill_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_masked_fill_cpu/debuf.mlir new file mode 100644 index 000000000000..a800995bbc40 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_fill_cpu/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1 : tensor) outs(%0 : tensor) { + ^bb0(%in: i32, %out: f32): + %4 = arith.cmpi ne, %in, %c0_i32 : i32 + %5 = arith.select %4, %arg2, %out : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_fill_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_masked_fill_cpu/matched.mlir new file mode 100644 index 000000000000..a800995bbc40 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_fill_cpu/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1 : tensor) outs(%0 : tensor) { + ^bb0(%in: i32, %out: f32): + %4 = arith.cmpi ne, %in, %c0_i32 : i32 + %5 = arith.select %4, %arg2, %out : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_fill_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_masked_fill_cpu/orig.mlir new file mode 100644 index 000000000000..2f64bf208fb1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_fill_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.cmpi ne, %0, %c0_i32 : i32 + scf.if %1 { + affine.store %arg2, %arg0[%arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_masked_fill_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_masked_fill_cpu/raised.mlir new file mode 100644 index 000000000000..dad6b7922d35 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_fill_cpu/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg1 : memref) outs(%arg0 : memref) { + ^bb0(%in: i32, %out: f32): + %0 = arith.cmpi ne, %in, %c0_i32 : i32 + %1 = arith.select %0, %arg2, %out : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_fill_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_masked_fill_cpu_debuf.mlir new file mode 100644 index 000000000000..a800995bbc40 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_fill_cpu_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1 : tensor) outs(%0 : tensor) { + ^bb0(%in: i32, %out: f32): + %4 = arith.cmpi ne, %in, %c0_i32 : i32 + %5 = arith.select %4, %arg2, %out : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_fill_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_masked_fill_cpu_linalg.mlir new file mode 100644 index 000000000000..dad6b7922d35 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_fill_cpu_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg1 : memref) outs(%arg0 : memref) { + ^bb0(%in: i32, %out: f32): + %0 = arith.cmpi ne, %in, %c0_i32 : i32 + %1 = arith.select %0, %arg2, %out : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_scale.mlir b/issues/aten_c_kernels/results/aten_masked_scale.mlir new file mode 100644 index 000000000000..71ac2391401c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scale.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scale(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.mulf %0, %arg1 : f32 + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_masked_scale/debuf.mlir b/issues/aten_c_kernels/results/aten_masked_scale/debuf.mlir new file mode 100644 index 000000000000..cff6dd95cede --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scale/debuf.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scale(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %arg1 : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_scale/matched.mlir b/issues/aten_c_kernels/results/aten_masked_scale/matched.mlir new file mode 100644 index 000000000000..cff6dd95cede --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scale/matched.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scale(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %arg1 : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_scale/orig.mlir b/issues/aten_c_kernels/results/aten_masked_scale/orig.mlir new file mode 100644 index 000000000000..71ac2391401c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scale/orig.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scale(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.mulf %0, %arg1 : f32 + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_masked_scale/raised.mlir b/issues/aten_c_kernels/results/aten_masked_scale/raised.mlir new file mode 100644 index 000000000000..f7cca7c1251f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scale/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scale(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %arg1 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_scale_debuf.mlir b/issues/aten_c_kernels/results/aten_masked_scale_debuf.mlir new file mode 100644 index 000000000000..cff6dd95cede --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scale_debuf.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scale(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %arg1 : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_scale_linalg.mlir b/issues/aten_c_kernels/results/aten_masked_scale_linalg.mlir new file mode 100644 index 000000000000..f7cca7c1251f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scale_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scale(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %arg1 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu.mlir new file mode 100644 index 000000000000..ff1620a43ddf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scatter_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg3 = 0 to 512 iter_args(%arg4 = %c0_i32) -> (i32) { + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i32) { + %4 = arith.addi %arg4, %c1_i32 : i32 + %5 = arith.index_cast %arg4 : i32 to index + %6 = affine.load %arg0[%arg3] : memref + memref.store %6, %arg2[%5] : memref + scf.yield %4 : i32 + } else { + scf.yield %arg4 : i32 + } + affine.yield %3 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..8883e33298a9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu/debuf.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scatter_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %3[] : tensor + %4:2 = affine.for %arg3 = 0 to 512 iter_args(%arg4 = %inserted, %arg5 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg4[] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %6 = arith.cmpi ne, %extracted_0, %c0_i32 : i32 + %7:2 = scf.if %6 -> (i32, tensor) { + %8 = arith.addi %extracted, %c1_i32 : i32 + %9 = arith.index_cast %extracted : i32 to index + %extracted_2 = tensor.extract %2[%arg3] : tensor + %inserted_3 = tensor.insert %extracted_2 into %arg5[%9] : tensor + scf.yield %8, %inserted_3 : i32, tensor + } else { + scf.yield %extracted, %arg5 : i32, tensor + } + %inserted_1 = tensor.insert %7#0 into %arg4[] : tensor + affine.yield %inserted_1, %7#1 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu/matched.mlir new file mode 100644 index 000000000000..8883e33298a9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu/matched.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scatter_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %3[] : tensor + %4:2 = affine.for %arg3 = 0 to 512 iter_args(%arg4 = %inserted, %arg5 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg4[] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %6 = arith.cmpi ne, %extracted_0, %c0_i32 : i32 + %7:2 = scf.if %6 -> (i32, tensor) { + %8 = arith.addi %extracted, %c1_i32 : i32 + %9 = arith.index_cast %extracted : i32 to index + %extracted_2 = tensor.extract %2[%arg3] : tensor + %inserted_3 = tensor.insert %extracted_2 into %arg5[%9] : tensor + scf.yield %8, %inserted_3 : i32, tensor + } else { + scf.yield %extracted, %arg5 : i32, tensor + } + %inserted_1 = tensor.insert %7#0 into %arg4[] : tensor + affine.yield %inserted_1, %7#1 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu/orig.mlir new file mode 100644 index 000000000000..ff1620a43ddf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu/orig.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scatter_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg3 = 0 to 512 iter_args(%arg4 = %c0_i32) -> (i32) { + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i32) { + %4 = arith.addi %arg4, %c1_i32 : i32 + %5 = arith.index_cast %arg4 : i32 to index + %6 = affine.load %arg0[%arg3] : memref + memref.store %6, %arg2[%5] : memref + scf.yield %4 : i32 + } else { + scf.yield %arg4 : i32 + } + affine.yield %3 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu/raised.mlir new file mode 100644 index 000000000000..ceb33b4158a7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu/raised.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scatter_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg3 = 0 to 512 { + %0 = affine.load %alloca[] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i32) { + %4 = arith.addi %0, %c1_i32 : i32 + %5 = arith.index_cast %0 : i32 to index + %6 = affine.load %arg0[%arg3] : memref + memref.store %6, %arg2[%5] : memref + scf.yield %4 : i32 + } else { + scf.yield %0 : i32 + } + affine.store %3, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..8883e33298a9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu_debuf.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scatter_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %3[] : tensor + %4:2 = affine.for %arg3 = 0 to 512 iter_args(%arg4 = %inserted, %arg5 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg4[] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %6 = arith.cmpi ne, %extracted_0, %c0_i32 : i32 + %7:2 = scf.if %6 -> (i32, tensor) { + %8 = arith.addi %extracted, %c1_i32 : i32 + %9 = arith.index_cast %extracted : i32 to index + %extracted_2 = tensor.extract %2[%arg3] : tensor + %inserted_3 = tensor.insert %extracted_2 into %arg5[%9] : tensor + scf.yield %8, %inserted_3 : i32, tensor + } else { + scf.yield %extracted, %arg5 : i32, tensor + } + %inserted_1 = tensor.insert %7#0 into %arg4[] : tensor + affine.yield %inserted_1, %7#1 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..ceb33b4158a7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scatter_backward_cpu_linalg.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scatter_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg3 = 0 to 512 { + %0 = affine.load %alloca[] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i32) { + %4 = arith.addi %0, %c1_i32 : i32 + %5 = arith.index_cast %0 : i32 to index + %6 = affine.load %arg0[%arg3] : memref + memref.store %6, %arg2[%5] : memref + scf.yield %4 : i32 + } else { + scf.yield %0 : i32 + } + affine.store %3, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_scatter_cpu.mlir b/issues/aten_c_kernels/results/aten_masked_scatter_cpu.mlir new file mode 100644 index 000000000000..2fa4b27bb0be --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scatter_cpu.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scatter_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %c0_i32) -> (i32) { + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i32) { + %4 = arith.addi %arg4, %c1_i32 : i32 + %5 = arith.index_cast %arg4 : i32 to index + %6 = memref.load %arg2[%5] : memref + affine.store %6, %arg0[%arg3] : memref + scf.yield %4 : i32 + } else { + scf.yield %arg4 : i32 + } + affine.yield %3 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_masked_scatter_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_masked_scatter_cpu/debuf.mlir new file mode 100644 index 000000000000..c65de182628d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scatter_cpu/debuf.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scatter_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %3[] : tensor + %4:2 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %inserted, %arg5 = %2) -> (tensor, tensor) { + %extracted = tensor.extract %arg4[] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %6 = arith.cmpi ne, %extracted_0, %c0_i32 : i32 + %7:2 = scf.if %6 -> (i32, tensor) { + %8 = arith.addi %extracted, %c1_i32 : i32 + %9 = arith.index_cast %extracted : i32 to index + %extracted_2 = tensor.extract %0[%9] : tensor + %inserted_3 = tensor.insert %extracted_2 into %arg5[%arg3] : tensor + scf.yield %8, %inserted_3 : i32, tensor + } else { + scf.yield %extracted, %arg5 : i32, tensor + } + %inserted_1 = tensor.insert %7#0 into %arg4[] : tensor + affine.yield %inserted_1, %7#1 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_scatter_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_masked_scatter_cpu/matched.mlir new file mode 100644 index 000000000000..c65de182628d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scatter_cpu/matched.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scatter_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %3[] : tensor + %4:2 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %inserted, %arg5 = %2) -> (tensor, tensor) { + %extracted = tensor.extract %arg4[] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %6 = arith.cmpi ne, %extracted_0, %c0_i32 : i32 + %7:2 = scf.if %6 -> (i32, tensor) { + %8 = arith.addi %extracted, %c1_i32 : i32 + %9 = arith.index_cast %extracted : i32 to index + %extracted_2 = tensor.extract %0[%9] : tensor + %inserted_3 = tensor.insert %extracted_2 into %arg5[%arg3] : tensor + scf.yield %8, %inserted_3 : i32, tensor + } else { + scf.yield %extracted, %arg5 : i32, tensor + } + %inserted_1 = tensor.insert %7#0 into %arg4[] : tensor + affine.yield %inserted_1, %7#1 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_scatter_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_masked_scatter_cpu/orig.mlir new file mode 100644 index 000000000000..2fa4b27bb0be --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scatter_cpu/orig.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scatter_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %c0_i32) -> (i32) { + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i32) { + %4 = arith.addi %arg4, %c1_i32 : i32 + %5 = arith.index_cast %arg4 : i32 to index + %6 = memref.load %arg2[%5] : memref + affine.store %6, %arg0[%arg3] : memref + scf.yield %4 : i32 + } else { + scf.yield %arg4 : i32 + } + affine.yield %3 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_masked_scatter_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_masked_scatter_cpu/raised.mlir new file mode 100644 index 000000000000..b28545f588e0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scatter_cpu/raised.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scatter_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg3 = 0 to 128 { + %0 = affine.load %alloca[] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i32) { + %4 = arith.addi %0, %c1_i32 : i32 + %5 = arith.index_cast %0 : i32 to index + %6 = memref.load %arg2[%5] : memref + affine.store %6, %arg0[%arg3] : memref + scf.yield %4 : i32 + } else { + scf.yield %0 : i32 + } + affine.store %3, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_scatter_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_masked_scatter_cpu_debuf.mlir new file mode 100644 index 000000000000..c65de182628d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scatter_cpu_debuf.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scatter_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %3[] : tensor + %4:2 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %inserted, %arg5 = %2) -> (tensor, tensor) { + %extracted = tensor.extract %arg4[] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %6 = arith.cmpi ne, %extracted_0, %c0_i32 : i32 + %7:2 = scf.if %6 -> (i32, tensor) { + %8 = arith.addi %extracted, %c1_i32 : i32 + %9 = arith.index_cast %extracted : i32 to index + %extracted_2 = tensor.extract %0[%9] : tensor + %inserted_3 = tensor.insert %extracted_2 into %arg5[%arg3] : tensor + scf.yield %8, %inserted_3 : i32, tensor + } else { + scf.yield %extracted, %arg5 : i32, tensor + } + %inserted_1 = tensor.insert %7#0 into %arg4[] : tensor + affine.yield %inserted_1, %7#1 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_scatter_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_masked_scatter_cpu_linalg.mlir new file mode 100644 index 000000000000..b28545f588e0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_scatter_cpu_linalg.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_scatter_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg3 = 0 to 128 { + %0 = affine.load %alloca[] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i32) { + %4 = arith.addi %0, %c1_i32 : i32 + %5 = arith.index_cast %0 : i32 to index + %6 = memref.load %arg2[%5] : memref + affine.store %6, %arg0[%arg3] : memref + scf.yield %4 : i32 + } else { + scf.yield %0 : i32 + } + affine.store %3, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_select_cpu.mlir b/issues/aten_c_kernels/results/aten_masked_select_cpu.mlir new file mode 100644 index 000000000000..058c449d1f10 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_select_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_select_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg4 = 0 to 128 iter_args(%arg5 = %c0_i32) -> (i32) { + affine.store %arg5, %arg3[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i32) { + %4 = arith.addi %arg5, %c1_i32 : i32 + %5 = arith.index_cast %arg5 : i32 to index + %6 = affine.load %arg0[%arg4] : memref + memref.store %6, %arg2[%5] : memref + scf.yield %4 : i32 + } else { + scf.yield %arg5 : i32 + } + affine.yield %3 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_masked_select_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_masked_select_cpu/debuf.mlir new file mode 100644 index 000000000000..38193c17d0e1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_select_cpu/debuf.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_select_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %4[] : tensor + %5:3 = affine.for %arg4 = 0 to 128 iter_args(%arg5 = %inserted, %arg6 = %1, %arg7 = %0) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg5[] : tensor + %inserted_0 = tensor.insert %extracted into %arg7[%arg4] : tensor + %extracted_1 = tensor.extract %2[%arg4] : tensor + %8 = arith.cmpi ne, %extracted_1, %c0_i32 : i32 + %9:2 = scf.if %8 -> (i32, tensor) { + %10 = arith.addi %extracted, %c1_i32 : i32 + %11 = arith.index_cast %extracted : i32 to index + %extracted_3 = tensor.extract %3[%arg4] : tensor + %inserted_4 = tensor.insert %extracted_3 into %arg6[%11] : tensor + scf.yield %10, %inserted_4 : i32, tensor + } else { + scf.yield %extracted, %arg6 : i32, tensor + } + %inserted_2 = tensor.insert %9#0 into %arg5[] : tensor + affine.yield %inserted_2, %9#1, %inserted_0 : tensor, tensor, tensor + } + %6 = bufferization.to_memref %5#2 : memref + memref.copy %6, %arg3 : memref to memref + %7 = bufferization.to_memref %5#1 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_select_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_masked_select_cpu/matched.mlir new file mode 100644 index 000000000000..38193c17d0e1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_select_cpu/matched.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_select_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %4[] : tensor + %5:3 = affine.for %arg4 = 0 to 128 iter_args(%arg5 = %inserted, %arg6 = %1, %arg7 = %0) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg5[] : tensor + %inserted_0 = tensor.insert %extracted into %arg7[%arg4] : tensor + %extracted_1 = tensor.extract %2[%arg4] : tensor + %8 = arith.cmpi ne, %extracted_1, %c0_i32 : i32 + %9:2 = scf.if %8 -> (i32, tensor) { + %10 = arith.addi %extracted, %c1_i32 : i32 + %11 = arith.index_cast %extracted : i32 to index + %extracted_3 = tensor.extract %3[%arg4] : tensor + %inserted_4 = tensor.insert %extracted_3 into %arg6[%11] : tensor + scf.yield %10, %inserted_4 : i32, tensor + } else { + scf.yield %extracted, %arg6 : i32, tensor + } + %inserted_2 = tensor.insert %9#0 into %arg5[] : tensor + affine.yield %inserted_2, %9#1, %inserted_0 : tensor, tensor, tensor + } + %6 = bufferization.to_memref %5#2 : memref + memref.copy %6, %arg3 : memref to memref + %7 = bufferization.to_memref %5#1 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_select_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_masked_select_cpu/orig.mlir new file mode 100644 index 000000000000..058c449d1f10 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_select_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_select_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg4 = 0 to 128 iter_args(%arg5 = %c0_i32) -> (i32) { + affine.store %arg5, %arg3[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i32) { + %4 = arith.addi %arg5, %c1_i32 : i32 + %5 = arith.index_cast %arg5 : i32 to index + %6 = affine.load %arg0[%arg4] : memref + memref.store %6, %arg2[%5] : memref + scf.yield %4 : i32 + } else { + scf.yield %arg5 : i32 + } + affine.yield %3 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_masked_select_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_masked_select_cpu/raised.mlir new file mode 100644 index 000000000000..df3c97bda2d0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_select_cpu/raised.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_select_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg4 = 0 to 128 { + %0 = affine.load %alloca[] : memref + affine.store %0, %arg3[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i32) { + %4 = arith.addi %0, %c1_i32 : i32 + %5 = arith.index_cast %0 : i32 to index + %6 = affine.load %arg0[%arg4] : memref + memref.store %6, %arg2[%5] : memref + scf.yield %4 : i32 + } else { + scf.yield %0 : i32 + } + affine.store %3, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_select_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_masked_select_cpu_debuf.mlir new file mode 100644 index 000000000000..38193c17d0e1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_select_cpu_debuf.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_select_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %4[] : tensor + %5:3 = affine.for %arg4 = 0 to 128 iter_args(%arg5 = %inserted, %arg6 = %1, %arg7 = %0) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg5[] : tensor + %inserted_0 = tensor.insert %extracted into %arg7[%arg4] : tensor + %extracted_1 = tensor.extract %2[%arg4] : tensor + %8 = arith.cmpi ne, %extracted_1, %c0_i32 : i32 + %9:2 = scf.if %8 -> (i32, tensor) { + %10 = arith.addi %extracted, %c1_i32 : i32 + %11 = arith.index_cast %extracted : i32 to index + %extracted_3 = tensor.extract %3[%arg4] : tensor + %inserted_4 = tensor.insert %extracted_3 into %arg6[%11] : tensor + scf.yield %10, %inserted_4 : i32, tensor + } else { + scf.yield %extracted, %arg6 : i32, tensor + } + %inserted_2 = tensor.insert %9#0 into %arg5[] : tensor + affine.yield %inserted_2, %9#1, %inserted_0 : tensor, tensor, tensor + } + %6 = bufferization.to_memref %5#2 : memref + memref.copy %6, %arg3 : memref to memref + %7 = bufferization.to_memref %5#1 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_select_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_masked_select_cpu_linalg.mlir new file mode 100644 index 000000000000..df3c97bda2d0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_select_cpu_linalg.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_select_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg4 = 0 to 128 { + %0 = affine.load %alloca[] : memref + affine.store %0, %arg3[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i32) { + %4 = arith.addi %0, %c1_i32 : i32 + %5 = arith.index_cast %0 : i32 to index + %6 = affine.load %arg0[%arg4] : memref + memref.store %6, %arg2[%5] : memref + scf.yield %4 : i32 + } else { + scf.yield %0 : i32 + } + affine.store %3, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_select_serial_cpu.mlir b/issues/aten_c_kernels/results/aten_masked_select_serial_cpu.mlir new file mode 100644 index 000000000000..ef845318559f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_select_serial_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_select_serial_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg4 = 0 to 128 iter_args(%arg5 = %c0_i32) -> (i32) { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i32) { + %4 = arith.addi %arg5, %c1_i32 : i32 + %5 = arith.index_cast %arg5 : i32 to index + %6 = affine.load %arg0[%arg4] : memref + memref.store %6, %arg2[%5] : memref + scf.yield %4 : i32 + } else { + scf.yield %arg5 : i32 + } + affine.yield %3 : i32 + } + affine.store %0, %arg3[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_masked_select_serial_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_masked_select_serial_cpu/debuf.mlir new file mode 100644 index 000000000000..123140cacf28 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_select_serial_cpu/debuf.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_select_serial_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %c0_i32 into %0[%c0] : tensor + %4:2 = affine.for %arg4 = 0 to 128 iter_args(%arg5 = %1, %arg6 = %inserted) -> (tensor, tensor) { + %extracted = tensor.extract %arg6[%c0] : tensor + %extracted_0 = tensor.extract %2[%arg4] : tensor + %7 = arith.cmpi ne, %extracted_0, %c0_i32 : i32 + %8:2 = scf.if %7 -> (i32, tensor) { + %9 = arith.addi %extracted, %c1_i32 : i32 + %10 = arith.index_cast %extracted : i32 to index + %extracted_2 = tensor.extract %3[%arg4] : tensor + %inserted_3 = tensor.insert %extracted_2 into %arg5[%10] : tensor + scf.yield %9, %inserted_3 : i32, tensor + } else { + scf.yield %extracted, %arg5 : i32, tensor + } + %inserted_1 = tensor.insert %8#0 into %arg6[%c0] : tensor + affine.yield %8#1, %inserted_1 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg3 : memref to memref + %6 = bufferization.to_memref %4#0 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_select_serial_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_masked_select_serial_cpu/matched.mlir new file mode 100644 index 000000000000..123140cacf28 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_select_serial_cpu/matched.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_select_serial_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %c0_i32 into %0[%c0] : tensor + %4:2 = affine.for %arg4 = 0 to 128 iter_args(%arg5 = %1, %arg6 = %inserted) -> (tensor, tensor) { + %extracted = tensor.extract %arg6[%c0] : tensor + %extracted_0 = tensor.extract %2[%arg4] : tensor + %7 = arith.cmpi ne, %extracted_0, %c0_i32 : i32 + %8:2 = scf.if %7 -> (i32, tensor) { + %9 = arith.addi %extracted, %c1_i32 : i32 + %10 = arith.index_cast %extracted : i32 to index + %extracted_2 = tensor.extract %3[%arg4] : tensor + %inserted_3 = tensor.insert %extracted_2 into %arg5[%10] : tensor + scf.yield %9, %inserted_3 : i32, tensor + } else { + scf.yield %extracted, %arg5 : i32, tensor + } + %inserted_1 = tensor.insert %8#0 into %arg6[%c0] : tensor + affine.yield %8#1, %inserted_1 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg3 : memref to memref + %6 = bufferization.to_memref %4#0 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_select_serial_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_masked_select_serial_cpu/orig.mlir new file mode 100644 index 000000000000..ef845318559f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_select_serial_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_select_serial_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg4 = 0 to 128 iter_args(%arg5 = %c0_i32) -> (i32) { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i32) { + %4 = arith.addi %arg5, %c1_i32 : i32 + %5 = arith.index_cast %arg5 : i32 to index + %6 = affine.load %arg0[%arg4] : memref + memref.store %6, %arg2[%5] : memref + scf.yield %4 : i32 + } else { + scf.yield %arg5 : i32 + } + affine.yield %3 : i32 + } + affine.store %0, %arg3[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_masked_select_serial_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_masked_select_serial_cpu/raised.mlir new file mode 100644 index 000000000000..9bc2f3a80552 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_select_serial_cpu/raised.mlir @@ -0,0 +1,24 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_select_serial_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg3[0] : memref + affine.for %arg4 = 0 to 128 { + %0 = affine.load %arg3[0] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i32) { + %4 = arith.addi %0, %c1_i32 : i32 + %5 = arith.index_cast %0 : i32 to index + %6 = affine.load %arg0[%arg4] : memref + memref.store %6, %arg2[%5] : memref + scf.yield %4 : i32 + } else { + scf.yield %0 : i32 + } + affine.store %3, %arg3[0] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_select_serial_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_masked_select_serial_cpu_debuf.mlir new file mode 100644 index 000000000000..123140cacf28 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_select_serial_cpu_debuf.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_select_serial_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %c0_i32 into %0[%c0] : tensor + %4:2 = affine.for %arg4 = 0 to 128 iter_args(%arg5 = %1, %arg6 = %inserted) -> (tensor, tensor) { + %extracted = tensor.extract %arg6[%c0] : tensor + %extracted_0 = tensor.extract %2[%arg4] : tensor + %7 = arith.cmpi ne, %extracted_0, %c0_i32 : i32 + %8:2 = scf.if %7 -> (i32, tensor) { + %9 = arith.addi %extracted, %c1_i32 : i32 + %10 = arith.index_cast %extracted : i32 to index + %extracted_2 = tensor.extract %3[%arg4] : tensor + %inserted_3 = tensor.insert %extracted_2 into %arg5[%10] : tensor + scf.yield %9, %inserted_3 : i32, tensor + } else { + scf.yield %extracted, %arg5 : i32, tensor + } + %inserted_1 = tensor.insert %8#0 into %arg6[%c0] : tensor + affine.yield %8#1, %inserted_1 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg3 : memref to memref + %6 = bufferization.to_memref %4#0 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_masked_select_serial_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_masked_select_serial_cpu_linalg.mlir new file mode 100644 index 000000000000..9bc2f3a80552 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_masked_select_serial_cpu_linalg.mlir @@ -0,0 +1,24 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_masked_select_serial_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg3[0] : memref + affine.for %arg4 = 0 to 128 { + %0 = affine.load %arg3[0] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.cmpi ne, %1, %c0_i32 : i32 + %3 = scf.if %2 -> (i32) { + %4 = arith.addi %0, %c1_i32 : i32 + %5 = arith.index_cast %0 : i32 to index + %6 = affine.load %arg0[%arg4] : memref + memref.store %6, %arg2[%5] : memref + scf.yield %4 : i32 + } else { + scf.yield %0 : i32 + } + affine.store %3, %arg3[0] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_all_cpu.mlir b/issues/aten_c_kernels/results/aten_max_all_cpu.mlir new file mode 100644 index 000000000000..3fde83e7d126 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_all_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = affine.load %arg0[0] : memref + %1 = affine.for %arg2 = 1 to 4096 iter_args(%arg3 = %0) -> (f32) { + %2 = affine.load %arg0[%arg2] : memref + %3 = arith.cmpf ogt, %2, %arg3 : f32 + %4 = arith.select %3, %2, %arg3 : f32 + affine.yield %4 : f32 + } + affine.store %1, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_all_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_max_all_cpu/debuf.mlir new file mode 100644 index 000000000000..f9ac2e4ff844 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_all_cpu/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted = tensor.extract %0[%c0] : tensor + %inserted = tensor.insert %extracted into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %out : f32 + %5 = arith.select %4, %in, %out : f32 + linalg.yield %5 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_all_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_max_all_cpu/matched.mlir new file mode 100644 index 000000000000..f9ac2e4ff844 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_all_cpu/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted = tensor.extract %0[%c0] : tensor + %inserted = tensor.insert %extracted into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %out : f32 + %5 = arith.select %4, %in, %out : f32 + linalg.yield %5 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_all_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_max_all_cpu/orig.mlir new file mode 100644 index 000000000000..3fde83e7d126 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_all_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = affine.load %arg0[0] : memref + %1 = affine.for %arg2 = 1 to 4096 iter_args(%arg3 = %0) -> (f32) { + %2 = affine.load %arg0[%arg2] : memref + %3 = arith.cmpf ogt, %2, %arg3 : f32 + %4 = arith.select %3, %2, %arg3 : f32 + affine.yield %4 : f32 + } + affine.store %1, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_all_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_max_all_cpu/raised.mlir new file mode 100644 index 000000000000..be8e3da9d27c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_all_cpu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %0 = affine.load %arg0[0] : memref + affine.store %0, %arg1[0] : memref + %subview = memref.subview %arg0[1] [%c4095] [1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.cmpf ogt, %in, %out : f32 + %2 = arith.select %1, %in, %out : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_all_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_max_all_cpu_debuf.mlir new file mode 100644 index 000000000000..f9ac2e4ff844 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_all_cpu_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted = tensor.extract %0[%c0] : tensor + %inserted = tensor.insert %extracted into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %out : f32 + %5 = arith.select %4, %in, %out : f32 + linalg.yield %5 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_all_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_max_all_cpu_linalg.mlir new file mode 100644 index 000000000000..be8e3da9d27c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_all_cpu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %0 = affine.load %arg0[0] : memref + affine.store %0, %arg1[0] : memref + %subview = memref.subview %arg0[1] [%c4095] [1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.cmpf ogt, %in, %out : f32 + %2 = arith.select %1, %in, %out : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool1d_cpu.mlir b/issues/aten_c_kernels/results/aten_max_pool1d_cpu.mlir new file mode 100644 index 000000000000..e540fd7ad605 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool1d_cpu.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool1d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + %0:2 = affine.for %arg5 = #map(%arg4) to #map1(%arg4) iter_args(%arg6 = %c0_i32, %arg7 = %cst) -> (i32, f32) { + %1 = arith.index_cast %arg5 : index to i32 + %2 = affine.load %arg0[%arg5 + %arg3 * 6] : memref + %3 = arith.cmpf ogt, %2, %arg7 : f32 + %4 = arith.select %3, %1, %arg6 : i32 + %5 = arith.select %3, %2, %arg7 : f32 + affine.yield %4, %5 : i32, f32 + } + affine.store %0#1, %arg1[%arg4 + %arg3 * 3] : memref + affine.store %0#0, %arg2[%arg4 + %arg3 * 3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_pool1d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_max_pool1d_cpu/debuf.mlir new file mode 100644 index 000000000000..a7a0abbf8766 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool1d_cpu/debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0)[s0] -> (d0 + s0 * 3)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool1d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2:2 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %alloca = memref.alloca(%c3) : memref + %5 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %6 = bufferization.to_tensor %alloca_0 : memref + %7 = polygeist.submap(%arg4, %arg3, %c3) {map = #map} : (tensor, index, index) -> tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%6 : tensor) outs(%7 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %9 = polygeist.submapInverse(%arg4, %8, %arg3, %c3) {map = #map} : (tensor, tensor, index, index) -> tensor + %10 = polygeist.submap(%arg5, %arg3, %c3) {map = #map} : (tensor, index, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%5 : tensor) outs(%10 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %12 = polygeist.submapInverse(%arg5, %11, %arg3, %c3) {map = #map} : (tensor, tensor, index, index) -> tensor + affine.yield %9, %12 : tensor, tensor + } + %3 = bufferization.to_memref %2#1 : memref + memref.copy %3, %arg2 : memref to memref + %4 = bufferization.to_memref %2#0 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool1d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_max_pool1d_cpu/matched.mlir new file mode 100644 index 000000000000..81bebde77b92 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool1d_cpu/matched.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0)[s0] -> (d0 + s0 * 3)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool1d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2:2 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %alloca = memref.alloca(%c3) : memref + %5 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %6 = bufferization.to_tensor %alloca_0 : memref + %7 = polygeist.submap(%arg4, %arg3, %c3) {map = #map} : (tensor, index, index) -> tensor + %8 = kernel.launch @cudaCopy1D_f32_tensor(%6, %7) : (tensor, tensor) -> tensor + %9 = polygeist.submapInverse(%arg4, %8, %arg3, %c3) {map = #map} : (tensor, tensor, index, index) -> tensor + %10 = polygeist.submap(%arg5, %arg3, %c3) {map = #map} : (tensor, index, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%5 : tensor) outs(%10 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %12 = polygeist.submapInverse(%arg5, %11, %arg3, %c3) {map = #map} : (tensor, tensor, index, index) -> tensor + affine.yield %9, %12 : tensor, tensor + } + %3 = bufferization.to_memref %2#1 : memref + memref.copy %3, %arg2 : memref to memref + %4 = bufferization.to_memref %2#0 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool1d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_max_pool1d_cpu/orig.mlir new file mode 100644 index 000000000000..e540fd7ad605 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool1d_cpu/orig.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool1d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + %0:2 = affine.for %arg5 = #map(%arg4) to #map1(%arg4) iter_args(%arg6 = %c0_i32, %arg7 = %cst) -> (i32, f32) { + %1 = arith.index_cast %arg5 : index to i32 + %2 = affine.load %arg0[%arg5 + %arg3 * 6] : memref + %3 = arith.cmpf ogt, %2, %arg7 : f32 + %4 = arith.select %3, %1, %arg6 : i32 + %5 = arith.select %3, %2, %arg7 : f32 + affine.yield %4, %5 : i32, f32 + } + affine.store %0#1, %arg1[%arg4 + %arg3 * 3] : memref + affine.store %0#0, %arg2[%arg4 + %arg3 * 3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_pool1d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_max_pool1d_cpu/raised.mlir new file mode 100644 index 000000000000..12d054a1c7d2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool1d_cpu/raised.mlir @@ -0,0 +1,60 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 6)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +#map4 = affine_map<(d0) -> (d0 * 2)> +#map5 = affine_map<(d0) -> (d0 * 2 + 2)> +#map6 = affine_map<(d0)[s0] -> (d0 + s0 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool1d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + affine.for %arg3 = 0 to 2 { + %alloca = memref.alloca(%c3) : memref + %alloca_0 = memref.alloca(%c3) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_0 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg0, %arg3, %c3, %c6) {map = #map1} : (memref, index, index, index) -> memref + %subview = memref.subview %alloca[0] [%c3] [1] : memref to memref> + %subview_1 = memref.subview %alloca_0[0] [%c3] [1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3, #map3], iterator_types = ["parallel", "reduction"]} ins(%0 : memref) outs(%subview, %subview_1 : memref>, memref>) { + ^bb0(%in: f32, %out: i32, %out_2: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.cmpf ogt, %in, %out_2 : f32 + %7 = arith.select %6, %5, %out : i32 + %8 = arith.select %6, %in, %out_2 : f32 + %9 = linalg.index 1 : index + %10 = affine.apply #map4(%3) + %11 = arith.cmpi sge, %9, %10 : index + %12 = affine.apply #map5(%3) + %13 = arith.cmpi slt, %9, %12 : index + %14 = arith.andi %11, %13 : i1 + %15 = arith.select %14, %7, %out : i32 + %16 = arith.select %14, %8, %out_2 : f32 + linalg.yield %15, %16 : i32, f32 + } + %1 = polygeist.submap(%arg1, %arg3, %c3) {map = #map6} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca_0 : memref) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %2 = polygeist.submap(%arg2, %arg3, %c3) {map = #map6} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca : memref) outs(%2 : memref) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool1d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_max_pool1d_cpu_debuf.mlir new file mode 100644 index 000000000000..a7a0abbf8766 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool1d_cpu_debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0)[s0] -> (d0 + s0 * 3)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool1d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2:2 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %alloca = memref.alloca(%c3) : memref + %5 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c3) : memref + %6 = bufferization.to_tensor %alloca_0 : memref + %7 = polygeist.submap(%arg4, %arg3, %c3) {map = #map} : (tensor, index, index) -> tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%6 : tensor) outs(%7 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %9 = polygeist.submapInverse(%arg4, %8, %arg3, %c3) {map = #map} : (tensor, tensor, index, index) -> tensor + %10 = polygeist.submap(%arg5, %arg3, %c3) {map = #map} : (tensor, index, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%5 : tensor) outs(%10 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %12 = polygeist.submapInverse(%arg5, %11, %arg3, %c3) {map = #map} : (tensor, tensor, index, index) -> tensor + affine.yield %9, %12 : tensor, tensor + } + %3 = bufferization.to_memref %2#1 : memref + memref.copy %3, %arg2 : memref to memref + %4 = bufferization.to_memref %2#0 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool1d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_max_pool1d_cpu_linalg.mlir new file mode 100644 index 000000000000..12d054a1c7d2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool1d_cpu_linalg.mlir @@ -0,0 +1,60 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 6)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +#map4 = affine_map<(d0) -> (d0 * 2)> +#map5 = affine_map<(d0) -> (d0 * 2 + 2)> +#map6 = affine_map<(d0)[s0] -> (d0 + s0 * 3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool1d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + affine.for %arg3 = 0 to 2 { + %alloca = memref.alloca(%c3) : memref + %alloca_0 = memref.alloca(%c3) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_0 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg0, %arg3, %c3, %c6) {map = #map1} : (memref, index, index, index) -> memref + %subview = memref.subview %alloca[0] [%c3] [1] : memref to memref> + %subview_1 = memref.subview %alloca_0[0] [%c3] [1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3, #map3], iterator_types = ["parallel", "reduction"]} ins(%0 : memref) outs(%subview, %subview_1 : memref>, memref>) { + ^bb0(%in: f32, %out: i32, %out_2: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.cmpf ogt, %in, %out_2 : f32 + %7 = arith.select %6, %5, %out : i32 + %8 = arith.select %6, %in, %out_2 : f32 + %9 = linalg.index 1 : index + %10 = affine.apply #map4(%3) + %11 = arith.cmpi sge, %9, %10 : index + %12 = affine.apply #map5(%3) + %13 = arith.cmpi slt, %9, %12 : index + %14 = arith.andi %11, %13 : i1 + %15 = arith.select %14, %7, %out : i32 + %16 = arith.select %14, %8, %out_2 : f32 + linalg.yield %15, %16 : i32, f32 + } + %1 = polygeist.submap(%arg1, %arg3, %c3) {map = #map6} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca_0 : memref) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %2 = polygeist.submap(%arg2, %arg3, %c3) {map = #map6} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca : memref) outs(%2 : memref) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool2d.mlir b/issues/aten_c_kernels/results/aten_max_pool2d.mlir new file mode 100644 index 000000000000..79b8ceae5a46 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool2d.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.40282347E+38 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 8 { + affine.store %cst, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 8 { + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 2 { + %0 = affine.load %arg0[%arg2, %arg3, %arg6 + %arg4 * 2, %arg7 + %arg5 * 2] : memref + %1 = affine.load %arg1[%arg2, %arg3, %arg4, %arg5] : memref + %2 = arith.cmpf ogt, %0, %1 : f32 + %3 = arith.select %2, %0, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_pool2d/debuf.mlir b/issues/aten_c_kernels/results/aten_max_pool2d/debuf.mlir new file mode 100644 index 000000000000..35c4752153ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool2d/debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2 * 2, d5 + d3 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.40282347E+38 : f32 + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0] [%c2, %c8, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c8, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%3 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.cmpf ogt, %in, %out : f32 + %7 = arith.select %6, %in, %out : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0, 0, 0] [%c2, %c8, %c8, %c8] [1, 1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool2d/matched.mlir b/issues/aten_c_kernels/results/aten_max_pool2d/matched.mlir new file mode 100644 index 000000000000..44b35c8eede4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool2d/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2 * 2, d5 + d3 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.40282347E+38 : f32 + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0] [%c2, %c8, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %3 = polygeist.submap(%0, %c2, %c8, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index) -> tensor + %4 = kernel.launch @cudnnMaxPoolFwd_batched(%3, %extracted_slice) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0, 0, 0] [%c2, %c8, %c8, %c8] [1, 1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool2d/orig.mlir b/issues/aten_c_kernels/results/aten_max_pool2d/orig.mlir new file mode 100644 index 000000000000..79b8ceae5a46 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool2d/orig.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.40282347E+38 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 8 { + affine.store %cst, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 8 { + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 2 { + %0 = affine.load %arg0[%arg2, %arg3, %arg6 + %arg4 * 2, %arg7 + %arg5 * 2] : memref + %1 = affine.load %arg1[%arg2, %arg3, %arg4, %arg5] : memref + %2 = arith.cmpf ogt, %0, %1 : f32 + %3 = arith.select %2, %0, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_pool2d/raised.mlir b/issues/aten_c_kernels/results/aten_max_pool2d/raised.mlir new file mode 100644 index 000000000000..60f6efc333a9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool2d/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2 * 2, d5 + d3 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %cst = arith.constant -3.40282347E+38 : f32 + %subview = memref.subview %arg1[0, 0, 0, 0] [%c2, %c8, %c8, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c8, %c8, %c8, %c2, %c2) {map = #map1} : (memref, index, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg1[0, 0, 0, 0] [%c2, %c8, %c8, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"]} ins(%0 : memref) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.cmpf ogt, %in, %out : f32 + %2 = arith.select %1, %in, %out : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool2d_debuf.mlir b/issues/aten_c_kernels/results/aten_max_pool2d_debuf.mlir new file mode 100644 index 000000000000..35c4752153ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool2d_debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2 * 2, d5 + d3 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.40282347E+38 : f32 + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0] [%c2, %c8, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = polygeist.submap(%0, %c2, %c8, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%3 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.cmpf ogt, %in, %out : f32 + %7 = arith.select %6, %in, %out : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0, 0, 0] [%c2, %c8, %c8, %c8] [1, 1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool2d_linalg.mlir b/issues/aten_c_kernels/results/aten_max_pool2d_linalg.mlir new file mode 100644 index 000000000000..60f6efc333a9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool2d_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 + d2 * 2, d5 + d3 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %cst = arith.constant -3.40282347E+38 : f32 + %subview = memref.subview %arg1[0, 0, 0, 0] [%c2, %c8, %c8, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg0, %c2, %c8, %c8, %c8, %c2, %c2) {map = #map1} : (memref, index, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg1[0, 0, 0, 0] [%c2, %c8, %c8, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"]} ins(%0 : memref) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.cmpf ogt, %in, %out : f32 + %2 = arith.select %1, %in, %out : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu.mlir new file mode 100644 index 000000000000..0f99e8088aef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c336_i32 = arith.constant 336 : i32 + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 672 { + affine.store %cst, %arg2[%arg3] : memref + } + affine.for %arg3 = 0 to 2 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.muli %0, %c336_i32 : i32 + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 4 { + %2 = affine.load %arg1[%arg3 * 36 + %arg6 + %arg4 * 12 + %arg5 * 4] : memref + %3 = arith.addi %1, %2 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = affine.load %arg0[%arg3 * 36 + %arg6 + %arg4 * 12 + %arg5 * 4] : memref + %6 = memref.load %arg2[%4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg2[%4] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..0131b1e24df1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu/debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0 * 36 + d1 + d2 * 12 + d3 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c336_i32 = arith.constant 336 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %3) -> (tensor) { + %6 = arith.index_cast %arg3 : index to i32 + %7 = arith.muli %6, %c336_i32 : i32 + %8 = affine.for %arg5 = 0 to 3 iter_args(%arg6 = %arg4) -> (tensor) { + %9 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %arg6) -> (tensor) { + %10 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %arg8) -> (tensor) { + %11 = affine.apply #map1(%arg3, %arg9, %arg5, %arg7) + %extracted = tensor.extract %1[%11] : tensor + %12 = arith.addi %7, %extracted : i32 + %13 = arith.index_cast %12 : i32 to index + %14 = affine.apply #map1(%arg3, %arg9, %arg5, %arg7) + %extracted_0 = tensor.extract %2[%14] : tensor + %extracted_1 = tensor.extract %arg10[%13] : tensor + %15 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %15 into %arg10[%13] : tensor + affine.yield %inserted : tensor + } + affine.yield %10 : tensor + } + affine.yield %9 : tensor + } + affine.yield %8 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..6b174be62293 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu/matched.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0 * 36 + d1 + d2 * 12 + d3 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c336_i32 = arith.constant 336 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %4 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %3) -> (tensor) { + %6 = arith.index_cast %arg3 : index to i32 + %7 = arith.muli %6, %c336_i32 : i32 + %8 = affine.for %arg5 = 0 to 3 iter_args(%arg6 = %arg4) -> (tensor) { + %9 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %arg6) -> (tensor) { + %10 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %arg8) -> (tensor) { + %11 = affine.apply #map1(%arg3, %arg9, %arg5, %arg7) + %extracted = tensor.extract %1[%11] : tensor + %12 = arith.addi %7, %extracted : i32 + %13 = arith.index_cast %12 : i32 to index + %14 = affine.apply #map1(%arg3, %arg9, %arg5, %arg7) + %extracted_0 = tensor.extract %2[%14] : tensor + %extracted_1 = tensor.extract %arg10[%13] : tensor + %15 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %15 into %arg10[%13] : tensor + affine.yield %inserted : tensor + } + affine.yield %10 : tensor + } + affine.yield %9 : tensor + } + affine.yield %8 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..0f99e8088aef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu/orig.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c336_i32 = arith.constant 336 : i32 + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 672 { + affine.store %cst, %arg2[%arg3] : memref + } + affine.for %arg3 = 0 to 2 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.muli %0, %c336_i32 : i32 + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 4 { + %2 = affine.load %arg1[%arg3 * 36 + %arg6 + %arg4 * 12 + %arg5 * 4] : memref + %3 = arith.addi %1, %2 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = affine.load %arg0[%arg3 * 36 + %arg6 + %arg4 * 12 + %arg5 * 4] : memref + %6 = memref.load %arg2[%4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg2[%4] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..d5a06458b5bc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu/raised.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c336_i32 = arith.constant 336 : i32 + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 2 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.muli %0, %c336_i32 : i32 + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 4 { + %2 = affine.load %arg1[%arg3 * 36 + %arg6 + %arg4 * 12 + %arg5 * 4] : memref + %3 = arith.addi %1, %2 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = affine.load %arg0[%arg3 * 36 + %arg6 + %arg4 * 12 + %arg5 * 4] : memref + %6 = memref.load %arg2[%4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg2[%4] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..0131b1e24df1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu_debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0 * 36 + d1 + d2 * 12 + d3 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c336_i32 = arith.constant 336 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %3) -> (tensor) { + %6 = arith.index_cast %arg3 : index to i32 + %7 = arith.muli %6, %c336_i32 : i32 + %8 = affine.for %arg5 = 0 to 3 iter_args(%arg6 = %arg4) -> (tensor) { + %9 = affine.for %arg7 = 0 to 3 iter_args(%arg8 = %arg6) -> (tensor) { + %10 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %arg8) -> (tensor) { + %11 = affine.apply #map1(%arg3, %arg9, %arg5, %arg7) + %extracted = tensor.extract %1[%11] : tensor + %12 = arith.addi %7, %extracted : i32 + %13 = arith.index_cast %12 : i32 to index + %14 = affine.apply #map1(%arg3, %arg9, %arg5, %arg7) + %extracted_0 = tensor.extract %2[%14] : tensor + %extracted_1 = tensor.extract %arg10[%13] : tensor + %15 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %15 into %arg10[%13] : tensor + affine.yield %inserted : tensor + } + affine.yield %10 : tensor + } + affine.yield %9 : tensor + } + affine.yield %8 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..d5a06458b5bc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool3d_backward_cpu_linalg.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool3d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c336_i32 = arith.constant 336 : i32 + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 2 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.muli %0, %c336_i32 : i32 + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 4 { + %2 = affine.load %arg1[%arg3 * 36 + %arg6 + %arg4 * 12 + %arg5 * 4] : memref + %3 = arith.addi %1, %2 : i32 + %4 = arith.index_cast %3 : i32 to index + %5 = affine.load %arg0[%arg3 * 36 + %arg6 + %arg4 * 12 + %arg5 * 4] : memref + %6 = memref.load %arg2[%4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg2[%4] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool3d_cpu.mlir b/issues/aten_c_kernels/results/aten_max_pool3d_cpu.mlir new file mode 100644 index 000000000000..ac42ea6d0cc4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool3d_cpu.mlir @@ -0,0 +1,45 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c8_i32 = arith.constant 8 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 4 { + %0:2 = affine.for %arg7 = #map(%arg4) to #map1(%arg4) iter_args(%arg8 = %c0_i32, %arg9 = %cst) -> (i32, f32) { + %1 = arith.index_cast %arg7 : index to i32 + %2 = arith.muli %1, %c7_i32 : i32 + %3:2 = affine.for %arg10 = #map(%arg5) to #map1(%arg5) iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (i32, f32) { + %4 = arith.index_cast %arg10 : index to i32 + %5 = arith.addi %2, %4 : i32 + %6 = arith.muli %5, %c8_i32 : i32 + %7:2 = affine.for %arg13 = #map(%arg6) to #map1(%arg6) iter_args(%arg14 = %arg11, %arg15 = %arg12) -> (i32, f32) { + %8 = arith.index_cast %arg13 : index to i32 + %9 = affine.load %arg0[%arg7 * 56 + %arg13 + %arg3 * 336 + %arg10 * 8] : memref + %10 = arith.cmpf ogt, %9, %arg15 : f32 + %11 = arith.select %10, %9, %arg15 : f32 + %12 = scf.if %10 -> (i32) { + %13 = arith.addi %6, %8 : i32 + scf.yield %13 : i32 + } else { + scf.yield %arg14 : i32 + } + affine.yield %12, %11 : i32, f32 + } + affine.yield %7#0, %7#1 : i32, f32 + } + affine.yield %3#0, %3#1 : i32, f32 + } + affine.store %0#1, %arg1[%arg3 * 36 + %arg6 + %arg4 * 12 + %arg5 * 4] : memref + affine.store %0#0, %arg2[%arg3 * 36 + %arg6 + %arg4 * 12 + %arg5 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_pool3d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_max_pool3d_cpu/debuf.mlir new file mode 100644 index 000000000000..48649bc46561 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool3d_cpu/debuf.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 36 + s1 * 12 + s2 * 4)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2:2 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %5:2 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %6:2 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (tensor, tensor) { + %alloca = memref.alloca(%c4) : memref + %7 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c4) : memref + %8 = bufferization.to_tensor %alloca_0 : memref + %9 = polygeist.submap(%arg10, %arg3, %arg6, %arg9, %c4) {map = #map} : (tensor, index, index, index, index) -> tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%8 : tensor) outs(%9 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %11 = polygeist.submapInverse(%arg10, %10, %arg3, %arg6, %arg9, %c4) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %12 = polygeist.submap(%arg11, %arg3, %arg6, %arg9, %c4) {map = #map} : (tensor, index, index, index, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%7 : tensor) outs(%12 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %14 = polygeist.submapInverse(%arg11, %13, %arg3, %arg6, %arg9, %c4) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + affine.yield %11, %14 : tensor, tensor + } + affine.yield %6#0, %6#1 : tensor, tensor + } + affine.yield %5#0, %5#1 : tensor, tensor + } + %3 = bufferization.to_memref %2#1 : memref + memref.copy %3, %arg2 : memref to memref + %4 = bufferization.to_memref %2#0 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool3d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_max_pool3d_cpu/matched.mlir new file mode 100644 index 000000000000..2f96ea119593 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool3d_cpu/matched.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 36 + s1 * 12 + s2 * 4)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2:2 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %5:2 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %6:2 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (tensor, tensor) { + %alloca = memref.alloca(%c4) : memref + %7 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c4) : memref + %8 = bufferization.to_tensor %alloca_0 : memref + %9 = polygeist.submap(%arg10, %arg3, %arg6, %arg9, %c4) {map = #map} : (tensor, index, index, index, index) -> tensor + %10 = kernel.launch @cudaCopy1D_f32_tensor(%8, %9) : (tensor, tensor) -> tensor + %11 = polygeist.submapInverse(%arg10, %10, %arg3, %arg6, %arg9, %c4) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %12 = polygeist.submap(%arg11, %arg3, %arg6, %arg9, %c4) {map = #map} : (tensor, index, index, index, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%7 : tensor) outs(%12 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %14 = polygeist.submapInverse(%arg11, %13, %arg3, %arg6, %arg9, %c4) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + affine.yield %11, %14 : tensor, tensor + } + affine.yield %6#0, %6#1 : tensor, tensor + } + affine.yield %5#0, %5#1 : tensor, tensor + } + %3 = bufferization.to_memref %2#1 : memref + memref.copy %3, %arg2 : memref to memref + %4 = bufferization.to_memref %2#0 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool3d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_max_pool3d_cpu/orig.mlir new file mode 100644 index 000000000000..ac42ea6d0cc4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool3d_cpu/orig.mlir @@ -0,0 +1,45 @@ +#map = affine_map<(d0) -> (d0 * 2)> +#map1 = affine_map<(d0) -> (d0 * 2 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c8_i32 = arith.constant 8 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 4 { + %0:2 = affine.for %arg7 = #map(%arg4) to #map1(%arg4) iter_args(%arg8 = %c0_i32, %arg9 = %cst) -> (i32, f32) { + %1 = arith.index_cast %arg7 : index to i32 + %2 = arith.muli %1, %c7_i32 : i32 + %3:2 = affine.for %arg10 = #map(%arg5) to #map1(%arg5) iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (i32, f32) { + %4 = arith.index_cast %arg10 : index to i32 + %5 = arith.addi %2, %4 : i32 + %6 = arith.muli %5, %c8_i32 : i32 + %7:2 = affine.for %arg13 = #map(%arg6) to #map1(%arg6) iter_args(%arg14 = %arg11, %arg15 = %arg12) -> (i32, f32) { + %8 = arith.index_cast %arg13 : index to i32 + %9 = affine.load %arg0[%arg7 * 56 + %arg13 + %arg3 * 336 + %arg10 * 8] : memref + %10 = arith.cmpf ogt, %9, %arg15 : f32 + %11 = arith.select %10, %9, %arg15 : f32 + %12 = scf.if %10 -> (i32) { + %13 = arith.addi %6, %8 : i32 + scf.yield %13 : i32 + } else { + scf.yield %arg14 : i32 + } + affine.yield %12, %11 : i32, f32 + } + affine.yield %7#0, %7#1 : i32, f32 + } + affine.yield %3#0, %3#1 : i32, f32 + } + affine.store %0#1, %arg1[%arg3 * 36 + %arg6 + %arg4 * 12 + %arg5 * 4] : memref + affine.store %0#0, %arg2[%arg3 * 36 + %arg6 + %arg4 * 12 + %arg5 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_pool3d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_max_pool3d_cpu/raised.mlir new file mode 100644 index 000000000000..83bcd72341fe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool3d_cpu/raised.mlir @@ -0,0 +1,94 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 * 2)> +#map2 = affine_map<(d0) -> (d0 * 2 + 2)> +#map3 = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 56 + s1 * 336 + s2 * 8)> +#map4 = affine_map<(d0) -> ()> +#map5 = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 36 + s1 * 12 + s2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c8 = arith.constant 8 : index + %c0_i32 = arith.constant 0 : i32 + %c8_i32 = arith.constant 8 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + %alloca = memref.alloca(%c4) : memref + %alloca_0 = memref.alloca(%c4) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_0 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = #map1(%arg4) to #map2(%arg4) { + %2 = affine.load %alloca[%arg6] : memref + %3 = affine.load %alloca_0[%arg6] : memref + %4 = arith.index_cast %arg7 : index to i32 + %5 = arith.muli %4, %c7_i32 : i32 + %alloca_1 = memref.alloca() : memref + affine.store %2, %alloca_1[] : memref + %alloca_2 = memref.alloca() : memref + affine.store %3, %alloca_2[] : memref + affine.for %arg8 = #map1(%arg5) to #map2(%arg5) { + %8 = affine.load %alloca_1[] : memref + %9 = affine.load %alloca_2[] : memref + %10 = arith.index_cast %arg8 : index to i32 + %11 = arith.addi %5, %10 : i32 + %12 = arith.muli %11, %c8_i32 : i32 + %alloca_3 = memref.alloca() : memref + affine.store %8, %alloca_3[] : memref + %alloca_4 = memref.alloca() : memref + affine.store %9, %alloca_4[] : memref + %13 = polygeist.submap(%arg0, %arg7, %arg3, %arg8, %c8) {map = #map3} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map4, #map4], iterator_types = ["reduction"]} ins(%13 : memref) outs(%alloca_3, %alloca_4 : memref, memref) { + ^bb0(%in: f32, %out: i32, %out_5: f32): + %16 = linalg.index 0 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.cmpf ogt, %in, %out_5 : f32 + %19 = arith.select %18, %in, %out_5 : f32 + %20 = arith.addi %12, %17 : i32 + %21 = arith.select %18, %20, %out : i32 + %22 = linalg.index 0 : index + %23 = affine.apply #map1(%arg6) + %24 = arith.cmpi sge, %22, %23 : index + %25 = affine.apply #map2(%arg6) + %26 = arith.cmpi slt, %22, %25 : index + %27 = arith.andi %24, %26 : i1 + %28 = arith.select %27, %21, %out : i32 + %29 = arith.select %27, %19, %out_5 : f32 + linalg.yield %28, %29 : i32, f32 + } + %14 = affine.load %alloca_3[] : memref + %15 = affine.load %alloca_4[] : memref + affine.store %14, %alloca_1[] : memref + affine.store %15, %alloca_2[] : memref + } + %6 = affine.load %alloca_1[] : memref + %7 = affine.load %alloca_2[] : memref + affine.store %6, %alloca[%arg6] : memref + affine.store %7, %alloca_0[%arg6] : memref + } + } {polygeist.was_parallel} + %0 = polygeist.submap(%arg1, %arg3, %arg4, %arg5, %c4) {map = #map5} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca_0 : memref) outs(%0 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %1 = polygeist.submap(%arg2, %arg3, %arg4, %arg5, %c4) {map = #map5} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca : memref) outs(%1 : memref) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool3d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_max_pool3d_cpu_debuf.mlir new file mode 100644 index 000000000000..48649bc46561 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool3d_cpu_debuf.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 36 + s1 * 12 + s2 * 4)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2:2 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %1, %arg5 = %0) -> (tensor, tensor) { + %5:2 = affine.for %arg6 = 0 to 3 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %6:2 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (tensor, tensor) { + %alloca = memref.alloca(%c4) : memref + %7 = bufferization.to_tensor %alloca : memref + %alloca_0 = memref.alloca(%c4) : memref + %8 = bufferization.to_tensor %alloca_0 : memref + %9 = polygeist.submap(%arg10, %arg3, %arg6, %arg9, %c4) {map = #map} : (tensor, index, index, index, index) -> tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%8 : tensor) outs(%9 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %11 = polygeist.submapInverse(%arg10, %10, %arg3, %arg6, %arg9, %c4) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %12 = polygeist.submap(%arg11, %arg3, %arg6, %arg9, %c4) {map = #map} : (tensor, index, index, index, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%7 : tensor) outs(%12 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %14 = polygeist.submapInverse(%arg11, %13, %arg3, %arg6, %arg9, %c4) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + affine.yield %11, %14 : tensor, tensor + } + affine.yield %6#0, %6#1 : tensor, tensor + } + affine.yield %5#0, %5#1 : tensor, tensor + } + %3 = bufferization.to_memref %2#1 : memref + memref.copy %3, %arg2 : memref to memref + %4 = bufferization.to_memref %2#0 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_pool3d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_max_pool3d_cpu_linalg.mlir new file mode 100644 index 000000000000..83bcd72341fe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_pool3d_cpu_linalg.mlir @@ -0,0 +1,94 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 * 2)> +#map2 = affine_map<(d0) -> (d0 * 2 + 2)> +#map3 = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 56 + s1 * 336 + s2 * 8)> +#map4 = affine_map<(d0) -> ()> +#map5 = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 36 + s1 * 12 + s2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_pool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c8 = arith.constant 8 : index + %c0_i32 = arith.constant 0 : i32 + %c8_i32 = arith.constant 8 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 3 { + %alloca = memref.alloca(%c4) : memref + %alloca_0 = memref.alloca(%c4) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_0 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = #map1(%arg4) to #map2(%arg4) { + %2 = affine.load %alloca[%arg6] : memref + %3 = affine.load %alloca_0[%arg6] : memref + %4 = arith.index_cast %arg7 : index to i32 + %5 = arith.muli %4, %c7_i32 : i32 + %alloca_1 = memref.alloca() : memref + affine.store %2, %alloca_1[] : memref + %alloca_2 = memref.alloca() : memref + affine.store %3, %alloca_2[] : memref + affine.for %arg8 = #map1(%arg5) to #map2(%arg5) { + %8 = affine.load %alloca_1[] : memref + %9 = affine.load %alloca_2[] : memref + %10 = arith.index_cast %arg8 : index to i32 + %11 = arith.addi %5, %10 : i32 + %12 = arith.muli %11, %c8_i32 : i32 + %alloca_3 = memref.alloca() : memref + affine.store %8, %alloca_3[] : memref + %alloca_4 = memref.alloca() : memref + affine.store %9, %alloca_4[] : memref + %13 = polygeist.submap(%arg0, %arg7, %arg3, %arg8, %c8) {map = #map3} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map4, #map4], iterator_types = ["reduction"]} ins(%13 : memref) outs(%alloca_3, %alloca_4 : memref, memref) { + ^bb0(%in: f32, %out: i32, %out_5: f32): + %16 = linalg.index 0 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.cmpf ogt, %in, %out_5 : f32 + %19 = arith.select %18, %in, %out_5 : f32 + %20 = arith.addi %12, %17 : i32 + %21 = arith.select %18, %20, %out : i32 + %22 = linalg.index 0 : index + %23 = affine.apply #map1(%arg6) + %24 = arith.cmpi sge, %22, %23 : index + %25 = affine.apply #map2(%arg6) + %26 = arith.cmpi slt, %22, %25 : index + %27 = arith.andi %24, %26 : i1 + %28 = arith.select %27, %21, %out : i32 + %29 = arith.select %27, %19, %out_5 : f32 + linalg.yield %28, %29 : i32, f32 + } + %14 = affine.load %alloca_3[] : memref + %15 = affine.load %alloca_4[] : memref + affine.store %14, %alloca_1[] : memref + affine.store %15, %alloca_2[] : memref + } + %6 = affine.load %alloca_1[] : memref + %7 = affine.load %alloca_2[] : memref + affine.store %6, %alloca[%arg6] : memref + affine.store %7, %alloca_0[%arg6] : memref + } + } {polygeist.was_parallel} + %0 = polygeist.submap(%arg1, %arg3, %arg4, %arg5, %c4) {map = #map5} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca_0 : memref) outs(%0 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %1 = polygeist.submap(%arg2, %arg3, %arg4, %arg5, %c4) {map = #map5} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca : memref) outs(%1 : memref) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_reduce_cpu.mlir b/issues/aten_c_kernels/results/aten_max_reduce_cpu.mlir new file mode 100644 index 000000000000..a30e9a27faf3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_reduce_cpu.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %1 = affine.load %arg0[0] : memref + affine.store %1, %alloca[] : memref + affine.for %arg2 = 1 to 4096 { + %3 = affine.load %arg0[%arg2] : memref + %4 = affine.load %alloca[] : memref + %5 = arith.cmpf ogt, %3, %4 : f32 + %6 = arith.select %5, %3, %4 : f32 + affine.store %6, %alloca[] : memref + } + %2 = affine.load %alloca[] : memref + affine.store %2, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_reduce_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_max_reduce_cpu/debuf.mlir new file mode 100644 index 000000000000..a08241e1e385 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_reduce_cpu/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %3 = llvm.mlir.undef : f32 + %inserted = tensor.insert %3 into %2[] : tensor + %extracted = tensor.extract %0[%c0] : tensor + %inserted_0 = tensor.insert %extracted into %inserted[] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.cmpf ogt, %in, %out : f32 + %7 = arith.select %6, %in, %out : f32 + linalg.yield %7 : f32 + } -> tensor + %extracted_1 = tensor.extract %4[] : tensor + %inserted_2 = tensor.insert %extracted_1 into %1[%c0] : tensor + %5 = bufferization.to_memref %inserted_2 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_reduce_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_max_reduce_cpu/matched.mlir new file mode 100644 index 000000000000..a08241e1e385 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_reduce_cpu/matched.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %3 = llvm.mlir.undef : f32 + %inserted = tensor.insert %3 into %2[] : tensor + %extracted = tensor.extract %0[%c0] : tensor + %inserted_0 = tensor.insert %extracted into %inserted[] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.cmpf ogt, %in, %out : f32 + %7 = arith.select %6, %in, %out : f32 + linalg.yield %7 : f32 + } -> tensor + %extracted_1 = tensor.extract %4[] : tensor + %inserted_2 = tensor.insert %extracted_1 into %1[%c0] : tensor + %5 = bufferization.to_memref %inserted_2 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_reduce_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_max_reduce_cpu/orig.mlir new file mode 100644 index 000000000000..a30e9a27faf3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_reduce_cpu/orig.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %1 = affine.load %arg0[0] : memref + affine.store %1, %alloca[] : memref + affine.for %arg2 = 1 to 4096 { + %3 = affine.load %arg0[%arg2] : memref + %4 = affine.load %alloca[] : memref + %5 = arith.cmpf ogt, %3, %4 : f32 + %6 = arith.select %5, %3, %4 : f32 + affine.store %6, %alloca[] : memref + } + %2 = affine.load %alloca[] : memref + affine.store %2, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_reduce_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_max_reduce_cpu/raised.mlir new file mode 100644 index 000000000000..b63386d62fdd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_reduce_cpu/raised.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %1 = affine.load %arg0[0] : memref + affine.store %1, %alloca[] : memref + %subview = memref.subview %arg0[1] [%c4095] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %3 = arith.cmpf ogt, %in, %out : f32 + %4 = arith.select %3, %in, %out : f32 + linalg.yield %4 : f32 + } + %2 = affine.load %alloca[] : memref + affine.store %2, %arg1[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_reduce_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_max_reduce_cpu_debuf.mlir new file mode 100644 index 000000000000..a08241e1e385 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_reduce_cpu_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %3 = llvm.mlir.undef : f32 + %inserted = tensor.insert %3 into %2[] : tensor + %extracted = tensor.extract %0[%c0] : tensor + %inserted_0 = tensor.insert %extracted into %inserted[] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.cmpf ogt, %in, %out : f32 + %7 = arith.select %6, %in, %out : f32 + linalg.yield %7 : f32 + } -> tensor + %extracted_1 = tensor.extract %4[] : tensor + %inserted_2 = tensor.insert %extracted_1 into %1[%c0] : tensor + %5 = bufferization.to_memref %inserted_2 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_reduce_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_max_reduce_cpu_linalg.mlir new file mode 100644 index 000000000000..b63386d62fdd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_reduce_cpu_linalg.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %1 = affine.load %arg0[0] : memref + affine.store %1, %alloca[] : memref + %subview = memref.subview %arg0[1] [%c4095] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %3 = arith.cmpf ogt, %in, %out : f32 + %4 = arith.select %3, %in, %out : f32 + linalg.yield %4 : f32 + } + %2 = affine.load %alloca[] : memref + affine.store %2, %arg1[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_unpool2d_cpu.mlir b/issues/aten_c_kernels/results/aten_max_unpool2d_cpu.mlir new file mode 100644 index 000000000000..c69d639244cc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool2d_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 512 { + affine.store %cst, %arg2[0, %arg3] : memref + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3, %arg4] : memref + memref.store %2, %arg2[%arg3, %1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_unpool2d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_max_unpool2d_cpu/debuf.mlir new file mode 100644 index 000000000000..2f365c88c28c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool2d_cpu/debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c512 = arith.constant 512 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [1, %c512] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [1, %c512] [1, 1] : tensor into tensor + %4 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %6 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg3, %arg5] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%arg3, %7] : tensor + affine.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_unpool2d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_max_unpool2d_cpu/matched.mlir new file mode 100644 index 000000000000..f08151d23cd1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool2d_cpu/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c512 = arith.constant 512 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [1, %c512] [1, 1] : tensor to tensor + %3 = kernel.launch @memset_zero_1D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [1, %c512] [1, 1] : tensor into tensor + %4 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %6 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg3, %arg5] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%arg3, %7] : tensor + affine.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_unpool2d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_max_unpool2d_cpu/orig.mlir new file mode 100644 index 000000000000..c69d639244cc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool2d_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 512 { + affine.store %cst, %arg2[0, %arg3] : memref + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3, %arg4] : memref + memref.store %2, %arg2[%arg3, %1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_unpool2d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_max_unpool2d_cpu/raised.mlir new file mode 100644 index 000000000000..a83495a024cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool2d_cpu/raised.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c512 = arith.constant 512 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0] [1, %c512] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3, %arg4] : memref + memref.store %2, %arg2[%arg3, %1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_unpool2d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_max_unpool2d_cpu_debuf.mlir new file mode 100644 index 000000000000..2f365c88c28c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool2d_cpu_debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c512 = arith.constant 512 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [1, %c512] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [1, %c512] [1, 1] : tensor into tensor + %4 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %6 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg3, %arg5] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%arg3, %7] : tensor + affine.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_unpool2d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_max_unpool2d_cpu_linalg.mlir new file mode 100644 index 000000000000..a83495a024cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool2d_cpu_linalg.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool2d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c512 = arith.constant 512 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0] [1, %c512] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3, %arg4] : memref + memref.store %2, %arg2[%arg3, %1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_unpool3d_cpu.mlir b/issues/aten_c_kernels/results/aten_max_unpool3d_cpu.mlir new file mode 100644 index 000000000000..a1bb43a67114 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool3d_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 1024 { + affine.store %cst, %arg2[0, %arg3] : memref + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3, %arg4] : memref + memref.store %2, %arg2[%arg3, %1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_unpool3d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_max_unpool3d_cpu/debuf.mlir new file mode 100644 index 000000000000..29c186fb0f37 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool3d_cpu/debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1024 = arith.constant 1024 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [1, %c1024] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [1, %c1024] [1, 1] : tensor into tensor + %4 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %6 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg3, %arg5] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%arg3, %7] : tensor + affine.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_unpool3d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_max_unpool3d_cpu/matched.mlir new file mode 100644 index 000000000000..b81789eff5a1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool3d_cpu/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1024 = arith.constant 1024 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [1, %c1024] [1, 1] : tensor to tensor + %3 = kernel.launch @memset_zero_1D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [1, %c1024] [1, 1] : tensor into tensor + %4 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %6 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg3, %arg5] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%arg3, %7] : tensor + affine.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_unpool3d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_max_unpool3d_cpu/orig.mlir new file mode 100644 index 000000000000..a1bb43a67114 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool3d_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 1024 { + affine.store %cst, %arg2[0, %arg3] : memref + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3, %arg4] : memref + memref.store %2, %arg2[%arg3, %1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_unpool3d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_max_unpool3d_cpu/raised.mlir new file mode 100644 index 000000000000..9c44f484cc8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool3d_cpu/raised.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1024 = arith.constant 1024 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0] [1, %c1024] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3, %arg4] : memref + memref.store %2, %arg2[%arg3, %1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_unpool3d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_max_unpool3d_cpu_debuf.mlir new file mode 100644 index 000000000000..29c186fb0f37 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool3d_cpu_debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1024 = arith.constant 1024 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [1, %c1024] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [1, %c1024] [1, 1] : tensor into tensor + %4 = affine.for %arg3 = 0 to 2 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %6 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg3, %arg5] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%arg3, %7] : tensor + affine.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_unpool3d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_max_unpool3d_cpu_linalg.mlir new file mode 100644 index 000000000000..9c44f484cc8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool3d_cpu_linalg.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool3d_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1024 = arith.constant 1024 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0] [1, %c1024] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg3, %arg4] : memref + memref.store %2, %arg2[%arg3, %1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu.mlir new file mode 100644 index 000000000000..019368b12075 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1] : memref + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..ae292fee0443 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%5] : memref + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu/matched.mlir new file mode 100644 index 000000000000..ae292fee0443 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%5] : memref + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu/orig.mlir new file mode 100644 index 000000000000..019368b12075 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1] : memref + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu/raised.mlir new file mode 100644 index 000000000000..57bcb2fccb34 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg1[%0] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%2] : memref + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..ae292fee0443 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%5] : memref + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..57bcb2fccb34 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_unpool_backward_cpu_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_unpool_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg1[%0] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%2] : memref + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_values_cpu.mlir b/issues/aten_c_kernels/results/aten_max_values_cpu.mlir new file mode 100644 index 000000000000..193af833069a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_values_cpu.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_values_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 32 { + %0 = affine.load %arg0[%arg2, 0] : memref + %1 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %0) -> (f32) { + %2 = affine.load %arg0[%arg2, %arg3] : memref + %3 = arith.cmpf ogt, %2, %arg4 : f32 + %4 = arith.select %3, %2, %arg4 : f32 + affine.yield %4 : f32 + } + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_values_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_max_values_cpu/debuf.mlir new file mode 100644 index 000000000000..4565c337a7cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_values_cpu/debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_values_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c63 = arith.constant 63 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c32] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 1] [%c32, %c63] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %out : f32 + %6 = arith.select %5, %in, %out : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_values_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_max_values_cpu/matched.mlir new file mode 100644 index 000000000000..6389e6f53e2b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_values_cpu/matched.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_values_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c63 = arith.constant 63 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c32] [1] : tensor to tensor + %2 = kernel.launch @cudaCopy1D_f32_tensor(%extracted_slice, %extracted_slice_0) : (tensor, tensor) -> tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 1] [%c32, %c63] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %out : f32 + %6 = arith.select %5, %in, %out : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_values_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_max_values_cpu/orig.mlir new file mode 100644 index 000000000000..193af833069a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_values_cpu/orig.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_values_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 32 { + %0 = affine.load %arg0[%arg2, 0] : memref + %1 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %0) -> (f32) { + %2 = affine.load %arg0[%arg2, %arg3] : memref + %3 = arith.cmpf ogt, %2, %arg4 : f32 + %4 = arith.select %3, %2, %arg4 : f32 + affine.yield %4 : f32 + } + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_max_values_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_max_values_cpu/raised.mlir new file mode 100644 index 000000000000..ad8e9819a839 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_values_cpu/raised.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_values_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c63 = arith.constant 63 : index + %subview = memref.subview %arg0[0, 0] [%c32, 1] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_1 = memref.subview %arg0[0, 1] [%c32, %c63] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg1[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview_1 : memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %out : f32 + %1 = arith.select %0, %in, %out : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_values_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_max_values_cpu_debuf.mlir new file mode 100644 index 000000000000..4565c337a7cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_values_cpu_debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_values_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c63 = arith.constant 63 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c32] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 1] [%c32, %c63] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %out : f32 + %6 = arith.select %5, %in, %out : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_max_values_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_max_values_cpu_linalg.mlir new file mode 100644 index 000000000000..ad8e9819a839 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_max_values_cpu_linalg.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_max_values_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c63 = arith.constant 63 : index + %subview = memref.subview %arg0[0, 0] [%c32, 1] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_1 = memref.subview %arg0[0, 1] [%c32, %c63] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg1[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview_1 : memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %out : f32 + %1 = arith.select %0, %in, %out : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_maximum.mlir b/issues/aten_c_kernels/results/aten_maximum.mlir new file mode 100644 index 000000000000..b94f4ac5ecc5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_maximum.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_maximum(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf ogt, %0, %1 : f32 + %3 = arith.select %2, %0, %1 : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_maximum/debuf.mlir b/issues/aten_c_kernels/results/aten_maximum/debuf.mlir new file mode 100644 index 000000000000..74a8067372e0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_maximum/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_maximum(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %in_0 : f32 + %6 = arith.select %5, %in, %in_0 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_maximum/matched.mlir b/issues/aten_c_kernels/results/aten_maximum/matched.mlir new file mode 100644 index 000000000000..74a8067372e0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_maximum/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_maximum(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %in_0 : f32 + %6 = arith.select %5, %in, %in_0 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_maximum/orig.mlir b/issues/aten_c_kernels/results/aten_maximum/orig.mlir new file mode 100644 index 000000000000..b94f4ac5ecc5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_maximum/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_maximum(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf ogt, %0, %1 : f32 + %3 = arith.select %2, %0, %1 : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_maximum/raised.mlir b/issues/aten_c_kernels/results/aten_maximum/raised.mlir new file mode 100644 index 000000000000..064557fb7443 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_maximum/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_maximum(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %in_0 : f32 + %1 = arith.select %0, %in, %in_0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_maximum_debuf.mlir b/issues/aten_c_kernels/results/aten_maximum_debuf.mlir new file mode 100644 index 000000000000..74a8067372e0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_maximum_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_maximum(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %in_0 : f32 + %6 = arith.select %5, %in, %in_0 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_maximum_linalg.mlir b/issues/aten_c_kernels/results/aten_maximum_linalg.mlir new file mode 100644 index 000000000000..064557fb7443 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_maximum_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_maximum(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %in_0 : f32 + %1 = arith.select %0, %in, %in_0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mean.mlir b/issues/aten_c_kernels/results/aten_mean.mlir new file mode 100644 index 000000000000..462acd127747 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mean.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mean(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.560000e+02 : f64 + %cst_0 = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref + affine.store %cst_0, %alloca[] : memref + affine.for %arg2 = 0 to 256 { + %2 = affine.load %arg0[%arg2] : memref + %3 = affine.load %alloca[] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %alloca[] : memref + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f64 + affine.store %1, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_mean/debuf.mlir b/issues/aten_c_kernels/results/aten_mean/debuf.mlir new file mode 100644 index 000000000000..d20be2a18f08 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mean/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mean(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %cst_0 = arith.constant 2.560000e+02 : f64 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %2[] : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f64, %out: f64): + %6 = arith.addf %out, %in : f64 + linalg.yield %6 : f64 + } -> tensor + %extracted = tensor.extract %3[] : tensor + %4 = arith.divf %extracted, %cst_0 : f64 + %inserted_1 = tensor.insert %4 into %1[%c0] : tensor + %5 = bufferization.to_memref %inserted_1 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mean/matched.mlir b/issues/aten_c_kernels/results/aten_mean/matched.mlir new file mode 100644 index 000000000000..d20be2a18f08 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mean/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mean(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %cst_0 = arith.constant 2.560000e+02 : f64 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %2[] : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f64, %out: f64): + %6 = arith.addf %out, %in : f64 + linalg.yield %6 : f64 + } -> tensor + %extracted = tensor.extract %3[] : tensor + %4 = arith.divf %extracted, %cst_0 : f64 + %inserted_1 = tensor.insert %4 into %1[%c0] : tensor + %5 = bufferization.to_memref %inserted_1 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mean/orig.mlir b/issues/aten_c_kernels/results/aten_mean/orig.mlir new file mode 100644 index 000000000000..462acd127747 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mean/orig.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mean(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.560000e+02 : f64 + %cst_0 = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref + affine.store %cst_0, %alloca[] : memref + affine.for %arg2 = 0 to 256 { + %2 = affine.load %arg0[%arg2] : memref + %3 = affine.load %alloca[] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %alloca[] : memref + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f64 + affine.store %1, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_mean/raised.mlir b/issues/aten_c_kernels/results/aten_mean/raised.mlir new file mode 100644 index 000000000000..4754ea2d9b65 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mean/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mean(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.560000e+02 : f64 + %cst_0 = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref + affine.store %cst_0, %alloca[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca : memref) { + ^bb0(%in: f64, %out: f64): + %2 = arith.addf %out, %in : f64 + linalg.yield %2 : f64 + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f64 + affine.store %1, %arg1[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mean_debuf.mlir b/issues/aten_c_kernels/results/aten_mean_debuf.mlir new file mode 100644 index 000000000000..d20be2a18f08 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mean_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mean(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %cst_0 = arith.constant 2.560000e+02 : f64 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %2[] : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f64, %out: f64): + %6 = arith.addf %out, %in : f64 + linalg.yield %6 : f64 + } -> tensor + %extracted = tensor.extract %3[] : tensor + %4 = arith.divf %extracted, %cst_0 : f64 + %inserted_1 = tensor.insert %4 into %1[%c0] : tensor + %5 = bufferization.to_memref %inserted_1 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mean_linalg.mlir b/issues/aten_c_kernels/results/aten_mean_linalg.mlir new file mode 100644 index 000000000000..4754ea2d9b65 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mean_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mean(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.560000e+02 : f64 + %cst_0 = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref + affine.store %cst_0, %alloca[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca : memref) { + ^bb0(%in: f64, %out: f64): + %2 = arith.addf %out, %in : f64 + linalg.yield %2 : f64 + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f64 + affine.store %1, %arg1[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_median_indices_cpu.mlir b/issues/aten_c_kernels/results/aten_median_indices_cpu.mlir new file mode 100644 index 000000000000..390b55113cd8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_median_indices_cpu.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_median_indices_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c31_i32 = arith.constant 31 : i32 + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 32 { + %1 = arith.index_cast %arg4 : index to i32 + %2 = affine.for %arg5 = #map(%arg4) to 63 iter_args(%arg6 = %1) -> (i32) { + %6 = arith.index_cast %arg5 : index to i32 + %7 = affine.load %arg0[%arg3, %arg5] : memref + %8 = arith.index_cast %arg6 : i32 to index + %9 = memref.load %arg0[%arg3, %8] : memref + %10 = arith.cmpf olt, %7, %9 : f32 + %11 = arith.select %10, %6, %arg6 : i32 + affine.yield %11 : i32 + } + %3 = affine.load %arg0[%arg3, %arg4] : memref + %4 = arith.index_cast %2 : i32 to index + %5 = memref.load %arg0[%arg3, %4] : memref + affine.store %5, %arg0[%arg3, %arg4] : memref + memref.store %3, %arg0[%arg3, %4] : memref + } + %0 = affine.load %arg0[%arg3, 31] : memref + affine.store %0, %arg1[%arg3] : memref + affine.store %c31_i32, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_median_indices_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_median_indices_cpu/debuf.mlir new file mode 100644 index 000000000000..f9f8a18abcd9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_median_indices_cpu/debuf.mlir @@ -0,0 +1,59 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_median_indices_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c31_i32 = arith.constant 31 : i32 + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %3) -> (tensor) { + %alloca = memref.alloca(%c32) : memref + %10 = bufferization.to_tensor %alloca : memref + %11:2 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %10, %arg7 = %arg4) -> (tensor, tensor) { + %12 = arith.index_cast %arg5 : index to i32 + %inserted = tensor.insert %12 into %arg6[%arg5] : tensor + %13 = affine.for %arg8 = #map(%arg5) to 63 iter_args(%arg9 = %inserted) -> (tensor) { + %extracted_5 = tensor.extract %arg9[%arg5] : tensor + %15 = arith.index_cast %arg8 : index to i32 + %extracted_6 = tensor.extract %arg7[%arg3, %arg8] : tensor + %16 = arith.index_cast %extracted_5 : i32 to index + %extracted_7 = tensor.extract %arg7[%arg3, %16] : tensor + %17 = arith.cmpf olt, %extracted_6, %extracted_7 : f32 + %18 = arith.select %17, %15, %extracted_5 : i32 + %inserted_8 = tensor.insert %18 into %arg9[%arg5] : tensor + affine.yield %inserted_8 : tensor + } + %extracted = tensor.extract %13[%arg5] : tensor + %extracted_1 = tensor.extract %arg7[%arg3, %arg5] : tensor + %14 = arith.index_cast %extracted : i32 to index + %extracted_2 = tensor.extract %arg7[%arg3, %14] : tensor + %inserted_3 = tensor.insert %extracted_2 into %arg7[%arg3, %arg5] : tensor + %inserted_4 = tensor.insert %extracted_1 into %inserted_3[%arg3, %14] : tensor + affine.yield %13, %inserted_4 : tensor, tensor + } + affine.yield %11#1 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg0 : memref to memref + %extracted_slice = tensor.extract_slice %2[0] [%c16] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 31] [%c16, 1] [1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %2[0] [%c16] [1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg1 : memref to memref + %8 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %c31_i32 : i32 + } -> tensor + %9 = bufferization.to_memref %8 : memref + memref.copy %9, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_median_indices_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_median_indices_cpu/matched.mlir new file mode 100644 index 000000000000..96d1b6a1195d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_median_indices_cpu/matched.mlir @@ -0,0 +1,56 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_median_indices_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c31_i32 = arith.constant 31 : i32 + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %3) -> (tensor) { + %alloca = memref.alloca(%c32) : memref + %10 = bufferization.to_tensor %alloca : memref + %11:2 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %10, %arg7 = %arg4) -> (tensor, tensor) { + %12 = arith.index_cast %arg5 : index to i32 + %inserted = tensor.insert %12 into %arg6[%arg5] : tensor + %13 = affine.for %arg8 = #map(%arg5) to 63 iter_args(%arg9 = %inserted) -> (tensor) { + %extracted_5 = tensor.extract %arg9[%arg5] : tensor + %15 = arith.index_cast %arg8 : index to i32 + %extracted_6 = tensor.extract %arg7[%arg3, %arg8] : tensor + %16 = arith.index_cast %extracted_5 : i32 to index + %extracted_7 = tensor.extract %arg7[%arg3, %16] : tensor + %17 = arith.cmpf olt, %extracted_6, %extracted_7 : f32 + %18 = arith.select %17, %15, %extracted_5 : i32 + %inserted_8 = tensor.insert %18 into %arg9[%arg5] : tensor + affine.yield %inserted_8 : tensor + } + %extracted = tensor.extract %13[%arg5] : tensor + %extracted_1 = tensor.extract %arg7[%arg3, %arg5] : tensor + %14 = arith.index_cast %extracted : i32 to index + %extracted_2 = tensor.extract %arg7[%arg3, %14] : tensor + %inserted_3 = tensor.insert %extracted_2 into %arg7[%arg3, %arg5] : tensor + %inserted_4 = tensor.insert %extracted_1 into %inserted_3[%arg3, %14] : tensor + affine.yield %13, %inserted_4 : tensor, tensor + } + affine.yield %11#1 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg0 : memref to memref + %extracted_slice = tensor.extract_slice %2[0] [%c16] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 31] [%c16, 1] [1, 1] : tensor to tensor + %6 = kernel.launch @cudaCopy1D_f32_tensor(%extracted_slice_0, %extracted_slice) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %6 into %2[0] [%c16] [1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg1 : memref to memref + %8 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %c31_i32 : i32 + } -> tensor + %9 = bufferization.to_memref %8 : memref + memref.copy %9, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_median_indices_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_median_indices_cpu/orig.mlir new file mode 100644 index 000000000000..390b55113cd8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_median_indices_cpu/orig.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_median_indices_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c31_i32 = arith.constant 31 : i32 + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 32 { + %1 = arith.index_cast %arg4 : index to i32 + %2 = affine.for %arg5 = #map(%arg4) to 63 iter_args(%arg6 = %1) -> (i32) { + %6 = arith.index_cast %arg5 : index to i32 + %7 = affine.load %arg0[%arg3, %arg5] : memref + %8 = arith.index_cast %arg6 : i32 to index + %9 = memref.load %arg0[%arg3, %8] : memref + %10 = arith.cmpf olt, %7, %9 : f32 + %11 = arith.select %10, %6, %arg6 : i32 + affine.yield %11 : i32 + } + %3 = affine.load %arg0[%arg3, %arg4] : memref + %4 = arith.index_cast %2 : i32 to index + %5 = memref.load %arg0[%arg3, %4] : memref + affine.store %5, %arg0[%arg3, %arg4] : memref + memref.store %3, %arg0[%arg3, %4] : memref + } + %0 = affine.load %arg0[%arg3, 31] : memref + affine.store %0, %arg1[%arg3] : memref + affine.store %c31_i32, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_median_indices_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_median_indices_cpu/raised.mlir new file mode 100644 index 000000000000..a0909caca0ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_median_indices_cpu/raised.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_median_indices_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %c31_i32 = arith.constant 31 : i32 + affine.for %arg3 = 0 to 16 { + %alloca = memref.alloca(%c32) : memref + affine.for %arg4 = 0 to 32 { + %0 = arith.index_cast %arg4 : index to i32 + affine.store %0, %alloca[%arg4] : memref + affine.for %arg5 = #map(%arg4) to 63 { + %5 = affine.load %alloca[%arg4] : memref + %6 = arith.index_cast %arg5 : index to i32 + %7 = affine.load %arg0[%arg3, %arg5] : memref + %8 = arith.index_cast %5 : i32 to index + %9 = memref.load %arg0[%arg3, %8] : memref + %10 = arith.cmpf olt, %7, %9 : f32 + %11 = arith.select %10, %6, %5 : i32 + affine.store %11, %alloca[%arg4] : memref + } + %1 = affine.load %alloca[%arg4] : memref + %2 = affine.load %arg0[%arg3, %arg4] : memref + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg3, %3] : memref + affine.store %4, %arg0[%arg3, %arg4] : memref + memref.store %2, %arg0[%arg3, %3] : memref + } + } + %subview = memref.subview %arg0[0, 31] [%c16, 1] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: i32): + linalg.yield %c31_i32 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_median_indices_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_median_indices_cpu_debuf.mlir new file mode 100644 index 000000000000..f9f8a18abcd9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_median_indices_cpu_debuf.mlir @@ -0,0 +1,59 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_median_indices_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c31_i32 = arith.constant 31 : i32 + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %3) -> (tensor) { + %alloca = memref.alloca(%c32) : memref + %10 = bufferization.to_tensor %alloca : memref + %11:2 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %10, %arg7 = %arg4) -> (tensor, tensor) { + %12 = arith.index_cast %arg5 : index to i32 + %inserted = tensor.insert %12 into %arg6[%arg5] : tensor + %13 = affine.for %arg8 = #map(%arg5) to 63 iter_args(%arg9 = %inserted) -> (tensor) { + %extracted_5 = tensor.extract %arg9[%arg5] : tensor + %15 = arith.index_cast %arg8 : index to i32 + %extracted_6 = tensor.extract %arg7[%arg3, %arg8] : tensor + %16 = arith.index_cast %extracted_5 : i32 to index + %extracted_7 = tensor.extract %arg7[%arg3, %16] : tensor + %17 = arith.cmpf olt, %extracted_6, %extracted_7 : f32 + %18 = arith.select %17, %15, %extracted_5 : i32 + %inserted_8 = tensor.insert %18 into %arg9[%arg5] : tensor + affine.yield %inserted_8 : tensor + } + %extracted = tensor.extract %13[%arg5] : tensor + %extracted_1 = tensor.extract %arg7[%arg3, %arg5] : tensor + %14 = arith.index_cast %extracted : i32 to index + %extracted_2 = tensor.extract %arg7[%arg3, %14] : tensor + %inserted_3 = tensor.insert %extracted_2 into %arg7[%arg3, %arg5] : tensor + %inserted_4 = tensor.insert %extracted_1 into %inserted_3[%arg3, %14] : tensor + affine.yield %13, %inserted_4 : tensor, tensor + } + affine.yield %11#1 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg0 : memref to memref + %extracted_slice = tensor.extract_slice %2[0] [%c16] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 31] [%c16, 1] [1, 1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %2[0] [%c16] [1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice : memref + memref.copy %7, %arg1 : memref to memref + %8 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %c31_i32 : i32 + } -> tensor + %9 = bufferization.to_memref %8 : memref + memref.copy %9, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_median_indices_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_median_indices_cpu_linalg.mlir new file mode 100644 index 000000000000..a0909caca0ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_median_indices_cpu_linalg.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_median_indices_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %c31_i32 = arith.constant 31 : i32 + affine.for %arg3 = 0 to 16 { + %alloca = memref.alloca(%c32) : memref + affine.for %arg4 = 0 to 32 { + %0 = arith.index_cast %arg4 : index to i32 + affine.store %0, %alloca[%arg4] : memref + affine.for %arg5 = #map(%arg4) to 63 { + %5 = affine.load %alloca[%arg4] : memref + %6 = arith.index_cast %arg5 : index to i32 + %7 = affine.load %arg0[%arg3, %arg5] : memref + %8 = arith.index_cast %5 : i32 to index + %9 = memref.load %arg0[%arg3, %8] : memref + %10 = arith.cmpf olt, %7, %9 : f32 + %11 = arith.select %10, %6, %5 : i32 + affine.store %11, %alloca[%arg4] : memref + } + %1 = affine.load %alloca[%arg4] : memref + %2 = affine.load %arg0[%arg3, %arg4] : memref + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg3, %3] : memref + affine.store %4, %arg0[%arg3, %arg4] : memref + memref.store %2, %arg0[%arg3, %3] : memref + } + } + %subview = memref.subview %arg0[0, 31] [%c16, 1] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: i32): + linalg.yield %c31_i32 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_min_all_cpu.mlir b/issues/aten_c_kernels/results/aten_min_all_cpu.mlir new file mode 100644 index 000000000000..e345c1a8b6fa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_all_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = affine.load %arg0[0] : memref + %1 = affine.for %arg2 = 1 to 4096 iter_args(%arg3 = %0) -> (f32) { + %2 = affine.load %arg0[%arg2] : memref + %3 = arith.cmpf olt, %2, %arg3 : f32 + %4 = arith.select %3, %2, %arg3 : f32 + affine.yield %4 : f32 + } + affine.store %1, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_min_all_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_min_all_cpu/debuf.mlir new file mode 100644 index 000000000000..cffcfa2654cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_all_cpu/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted = tensor.extract %0[%c0] : tensor + %inserted = tensor.insert %extracted into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %out : f32 + %5 = arith.select %4, %in, %out : f32 + linalg.yield %5 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_min_all_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_min_all_cpu/matched.mlir new file mode 100644 index 000000000000..cffcfa2654cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_all_cpu/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted = tensor.extract %0[%c0] : tensor + %inserted = tensor.insert %extracted into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %out : f32 + %5 = arith.select %4, %in, %out : f32 + linalg.yield %5 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_min_all_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_min_all_cpu/orig.mlir new file mode 100644 index 000000000000..e345c1a8b6fa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_all_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = affine.load %arg0[0] : memref + %1 = affine.for %arg2 = 1 to 4096 iter_args(%arg3 = %0) -> (f32) { + %2 = affine.load %arg0[%arg2] : memref + %3 = arith.cmpf olt, %2, %arg3 : f32 + %4 = arith.select %3, %2, %arg3 : f32 + affine.yield %4 : f32 + } + affine.store %1, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_min_all_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_min_all_cpu/raised.mlir new file mode 100644 index 000000000000..16bde76272ca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_all_cpu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %0 = affine.load %arg0[0] : memref + affine.store %0, %arg1[0] : memref + %subview = memref.subview %arg0[1] [%c4095] [1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.cmpf olt, %in, %out : f32 + %2 = arith.select %1, %in, %out : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_min_all_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_min_all_cpu_debuf.mlir new file mode 100644 index 000000000000..cffcfa2654cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_all_cpu_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted = tensor.extract %0[%c0] : tensor + %inserted = tensor.insert %extracted into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %out : f32 + %5 = arith.select %4, %in, %out : f32 + linalg.yield %5 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_min_all_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_min_all_cpu_linalg.mlir new file mode 100644 index 000000000000..16bde76272ca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_all_cpu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %0 = affine.load %arg0[0] : memref + affine.store %0, %arg1[0] : memref + %subview = memref.subview %arg0[1] [%c4095] [1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = arith.cmpf olt, %in, %out : f32 + %2 = arith.select %1, %in, %out : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_min_reduce_cpu.mlir b/issues/aten_c_kernels/results/aten_min_reduce_cpu.mlir new file mode 100644 index 000000000000..e812920f53d9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_reduce_cpu.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %1 = affine.load %arg0[0] : memref + affine.store %1, %alloca[] : memref + affine.for %arg2 = 1 to 4096 { + %3 = affine.load %arg0[%arg2] : memref + %4 = affine.load %alloca[] : memref + %5 = arith.cmpf olt, %3, %4 : f32 + %6 = arith.select %5, %3, %4 : f32 + affine.store %6, %alloca[] : memref + } + %2 = affine.load %alloca[] : memref + affine.store %2, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_min_reduce_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_min_reduce_cpu/debuf.mlir new file mode 100644 index 000000000000..a0903bba3420 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_reduce_cpu/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %3 = llvm.mlir.undef : f32 + %inserted = tensor.insert %3 into %2[] : tensor + %extracted = tensor.extract %0[%c0] : tensor + %inserted_0 = tensor.insert %extracted into %inserted[] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.cmpf olt, %in, %out : f32 + %7 = arith.select %6, %in, %out : f32 + linalg.yield %7 : f32 + } -> tensor + %extracted_1 = tensor.extract %4[] : tensor + %inserted_2 = tensor.insert %extracted_1 into %1[%c0] : tensor + %5 = bufferization.to_memref %inserted_2 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_min_reduce_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_min_reduce_cpu/matched.mlir new file mode 100644 index 000000000000..a0903bba3420 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_reduce_cpu/matched.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %3 = llvm.mlir.undef : f32 + %inserted = tensor.insert %3 into %2[] : tensor + %extracted = tensor.extract %0[%c0] : tensor + %inserted_0 = tensor.insert %extracted into %inserted[] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.cmpf olt, %in, %out : f32 + %7 = arith.select %6, %in, %out : f32 + linalg.yield %7 : f32 + } -> tensor + %extracted_1 = tensor.extract %4[] : tensor + %inserted_2 = tensor.insert %extracted_1 into %1[%c0] : tensor + %5 = bufferization.to_memref %inserted_2 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_min_reduce_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_min_reduce_cpu/orig.mlir new file mode 100644 index 000000000000..e812920f53d9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_reduce_cpu/orig.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %1 = affine.load %arg0[0] : memref + affine.store %1, %alloca[] : memref + affine.for %arg2 = 1 to 4096 { + %3 = affine.load %arg0[%arg2] : memref + %4 = affine.load %alloca[] : memref + %5 = arith.cmpf olt, %3, %4 : f32 + %6 = arith.select %5, %3, %4 : f32 + affine.store %6, %alloca[] : memref + } + %2 = affine.load %alloca[] : memref + affine.store %2, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_min_reduce_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_min_reduce_cpu/raised.mlir new file mode 100644 index 000000000000..dd6adb1bc61b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_reduce_cpu/raised.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %1 = affine.load %arg0[0] : memref + affine.store %1, %alloca[] : memref + %subview = memref.subview %arg0[1] [%c4095] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %3 = arith.cmpf olt, %in, %out : f32 + %4 = arith.select %3, %in, %out : f32 + linalg.yield %4 : f32 + } + %2 = affine.load %alloca[] : memref + affine.store %2, %arg1[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_min_reduce_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_min_reduce_cpu_debuf.mlir new file mode 100644 index 000000000000..a0903bba3420 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_reduce_cpu_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %3 = llvm.mlir.undef : f32 + %inserted = tensor.insert %3 into %2[] : tensor + %extracted = tensor.extract %0[%c0] : tensor + %inserted_0 = tensor.insert %extracted into %inserted[] : tensor + %extracted_slice = tensor.extract_slice %0[1] [%c4095] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.cmpf olt, %in, %out : f32 + %7 = arith.select %6, %in, %out : f32 + linalg.yield %7 : f32 + } -> tensor + %extracted_1 = tensor.extract %4[] : tensor + %inserted_2 = tensor.insert %extracted_1 into %1[%c0] : tensor + %5 = bufferization.to_memref %inserted_2 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_min_reduce_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_min_reduce_cpu_linalg.mlir new file mode 100644 index 000000000000..dd6adb1bc61b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_reduce_cpu_linalg.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4095 = arith.constant 4095 : index + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %1 = affine.load %arg0[0] : memref + affine.store %1, %alloca[] : memref + %subview = memref.subview %arg0[1] [%c4095] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %3 = arith.cmpf olt, %in, %out : f32 + %4 = arith.select %3, %in, %out : f32 + linalg.yield %4 : f32 + } + %2 = affine.load %alloca[] : memref + affine.store %2, %arg1[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_min_values_cpu.mlir b/issues/aten_c_kernels/results/aten_min_values_cpu.mlir new file mode 100644 index 000000000000..7d972113ecc7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_values_cpu.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_values_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 32 { + %0 = affine.load %arg0[%arg2, 0] : memref + %1 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %0) -> (f32) { + %2 = affine.load %arg0[%arg2, %arg3] : memref + %3 = arith.cmpf olt, %2, %arg4 : f32 + %4 = arith.select %3, %2, %arg4 : f32 + affine.yield %4 : f32 + } + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_min_values_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_min_values_cpu/debuf.mlir new file mode 100644 index 000000000000..25a32cd9ee71 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_values_cpu/debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_values_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c63 = arith.constant 63 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c32] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 1] [%c32, %c63] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %out : f32 + %6 = arith.select %5, %in, %out : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_min_values_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_min_values_cpu/matched.mlir new file mode 100644 index 000000000000..4f8e6c0d839e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_values_cpu/matched.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_values_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c63 = arith.constant 63 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c32] [1] : tensor to tensor + %2 = kernel.launch @cudaCopy1D_f32_tensor(%extracted_slice, %extracted_slice_0) : (tensor, tensor) -> tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 1] [%c32, %c63] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %out : f32 + %6 = arith.select %5, %in, %out : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_min_values_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_min_values_cpu/orig.mlir new file mode 100644 index 000000000000..7d972113ecc7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_values_cpu/orig.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_values_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 32 { + %0 = affine.load %arg0[%arg2, 0] : memref + %1 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %0) -> (f32) { + %2 = affine.load %arg0[%arg2, %arg3] : memref + %3 = arith.cmpf olt, %2, %arg4 : f32 + %4 = arith.select %3, %2, %arg4 : f32 + affine.yield %4 : f32 + } + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_min_values_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_min_values_cpu/raised.mlir new file mode 100644 index 000000000000..dedcb536d4ed --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_values_cpu/raised.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_values_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c63 = arith.constant 63 : index + %subview = memref.subview %arg0[0, 0] [%c32, 1] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_1 = memref.subview %arg0[0, 1] [%c32, %c63] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg1[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview_1 : memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %out : f32 + %1 = arith.select %0, %in, %out : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_min_values_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_min_values_cpu_debuf.mlir new file mode 100644 index 000000000000..25a32cd9ee71 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_values_cpu_debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_values_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c63 = arith.constant 63 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c32] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %extracted_slice_1 = tensor.extract_slice %0[0, 1] [%c32, %c63] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %out : f32 + %6 = arith.select %5, %in, %out : f32 + linalg.yield %6 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_min_values_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_min_values_cpu_linalg.mlir new file mode 100644 index 000000000000..dedcb536d4ed --- /dev/null +++ b/issues/aten_c_kernels/results/aten_min_values_cpu_linalg.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_min_values_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c63 = arith.constant 63 : index + %subview = memref.subview %arg0[0, 0] [%c32, 1] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_1 = memref.subview %arg0[0, 1] [%c32, %c63] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg1[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview_1 : memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %out : f32 + %1 = arith.select %0, %in, %out : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_minimum.mlir b/issues/aten_c_kernels/results/aten_minimum.mlir new file mode 100644 index 000000000000..1fbcb2277fa7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_minimum.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_minimum(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf olt, %0, %1 : f32 + %3 = arith.select %2, %0, %1 : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_minimum/debuf.mlir b/issues/aten_c_kernels/results/aten_minimum/debuf.mlir new file mode 100644 index 000000000000..e5a3811865b2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_minimum/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_minimum(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf olt, %in, %in_0 : f32 + %6 = arith.select %5, %in, %in_0 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_minimum/matched.mlir b/issues/aten_c_kernels/results/aten_minimum/matched.mlir new file mode 100644 index 000000000000..e5a3811865b2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_minimum/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_minimum(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf olt, %in, %in_0 : f32 + %6 = arith.select %5, %in, %in_0 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_minimum/orig.mlir b/issues/aten_c_kernels/results/aten_minimum/orig.mlir new file mode 100644 index 000000000000..1fbcb2277fa7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_minimum/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_minimum(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf olt, %0, %1 : f32 + %3 = arith.select %2, %0, %1 : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_minimum/raised.mlir b/issues/aten_c_kernels/results/aten_minimum/raised.mlir new file mode 100644 index 000000000000..f5c2ce4a7892 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_minimum/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_minimum(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf olt, %in, %in_0 : f32 + %1 = arith.select %0, %in, %in_0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_minimum_debuf.mlir b/issues/aten_c_kernels/results/aten_minimum_debuf.mlir new file mode 100644 index 000000000000..e5a3811865b2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_minimum_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_minimum(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf olt, %in, %in_0 : f32 + %6 = arith.select %5, %in, %in_0 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_minimum_linalg.mlir b/issues/aten_c_kernels/results/aten_minimum_linalg.mlir new file mode 100644 index 000000000000..f5c2ce4a7892 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_minimum_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_minimum(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf olt, %in, %in_0 : f32 + %1 = arith.select %0, %in, %in_0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mish.mlir b/issues/aten_c_kernels/results/aten_mish.mlir new file mode 100644 index 000000000000..6beeb93f338a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mish.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mish(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = math.exp %0 : f32 + %2 = func.call @log1pf(%1) : (f32) -> f32 + %3 = math.tanh %2 : f32 + %4 = arith.mulf %0, %3 : f32 + affine.store %4, %arg1[%arg2] : memref + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_mish/debuf.mlir b/issues/aten_c_kernels/results/aten_mish/debuf.mlir new file mode 100644 index 000000000000..fd43c4c1b72e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mish/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mish(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.exp %in : f32 + %5 = math.log1p %4 : f32 + %6 = math.tanh %5 : f32 + %7 = arith.mulf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_mish/matched.mlir b/issues/aten_c_kernels/results/aten_mish/matched.mlir new file mode 100644 index 000000000000..fd43c4c1b72e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mish/matched.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mish(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.exp %in : f32 + %5 = math.log1p %4 : f32 + %6 = math.tanh %5 : f32 + %7 = arith.mulf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_mish/orig.mlir b/issues/aten_c_kernels/results/aten_mish/orig.mlir new file mode 100644 index 000000000000..6beeb93f338a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mish/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mish(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = math.exp %0 : f32 + %2 = func.call @log1pf(%1) : (f32) -> f32 + %3 = math.tanh %2 : f32 + %4 = arith.mulf %0, %3 : f32 + affine.store %4, %arg1[%arg2] : memref + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_mish/raised.mlir b/issues/aten_c_kernels/results/aten_mish/raised.mlir new file mode 100644 index 000000000000..3e5693bf0dee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mish/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mish(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.exp %in : f32 + %1 = math.log1p %0 : f32 + %2 = math.tanh %1 : f32 + %3 = arith.mulf %in, %2 : f32 + linalg.yield %3 : f32 + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_mish_backward.mlir b/issues/aten_c_kernels/results/aten_mish_backward.mlir new file mode 100644 index 000000000000..9aa74301e189 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mish_backward.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mish_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.negf %0 : f32 + %2 = math.exp %1 : f32 + %3 = arith.addf %2, %cst : f32 + %4 = arith.divf %cst, %3 : f32 + %5 = math.exp %0 : f32 + %6 = func.call @log1pf(%5) : (f32) -> f32 + %7 = math.tanh %6 : f32 + %8 = affine.load %arg0[%arg3] : memref + %9 = affine.load %arg1[%arg3] : memref + %10 = arith.mulf %9, %4 : f32 + %11 = arith.mulf %7, %7 : f32 + %12 = arith.subf %cst, %11 : f32 + %13 = arith.mulf %10, %12 : f32 + %14 = arith.addf %7, %13 : f32 + %15 = arith.mulf %8, %14 : f32 + affine.store %15, %arg2[%arg3] : memref + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_mish_backward/debuf.mlir b/issues/aten_c_kernels/results/aten_mish_backward/debuf.mlir new file mode 100644 index 000000000000..e3db0bb5c3a7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mish_backward/debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mish_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0, %1 : tensor, tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %5 = arith.negf %in : f32 + %6 = math.exp %5 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.divf %cst, %7 : f32 + %9 = math.exp %in : f32 + %10 = math.log1p %9 : f32 + %11 = math.tanh %10 : f32 + %12 = arith.mulf %in_1, %8 : f32 + %13 = arith.mulf %11, %11 : f32 + %14 = arith.subf %cst, %13 : f32 + %15 = arith.mulf %12, %14 : f32 + %16 = arith.addf %11, %15 : f32 + %17 = arith.mulf %in_0, %16 : f32 + linalg.yield %17 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_mish_backward/matched.mlir b/issues/aten_c_kernels/results/aten_mish_backward/matched.mlir new file mode 100644 index 000000000000..e3db0bb5c3a7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mish_backward/matched.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mish_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0, %1 : tensor, tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %5 = arith.negf %in : f32 + %6 = math.exp %5 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.divf %cst, %7 : f32 + %9 = math.exp %in : f32 + %10 = math.log1p %9 : f32 + %11 = math.tanh %10 : f32 + %12 = arith.mulf %in_1, %8 : f32 + %13 = arith.mulf %11, %11 : f32 + %14 = arith.subf %cst, %13 : f32 + %15 = arith.mulf %12, %14 : f32 + %16 = arith.addf %11, %15 : f32 + %17 = arith.mulf %in_0, %16 : f32 + linalg.yield %17 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_mish_backward/orig.mlir b/issues/aten_c_kernels/results/aten_mish_backward/orig.mlir new file mode 100644 index 000000000000..9aa74301e189 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mish_backward/orig.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mish_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.negf %0 : f32 + %2 = math.exp %1 : f32 + %3 = arith.addf %2, %cst : f32 + %4 = arith.divf %cst, %3 : f32 + %5 = math.exp %0 : f32 + %6 = func.call @log1pf(%5) : (f32) -> f32 + %7 = math.tanh %6 : f32 + %8 = affine.load %arg0[%arg3] : memref + %9 = affine.load %arg1[%arg3] : memref + %10 = arith.mulf %9, %4 : f32 + %11 = arith.mulf %7, %7 : f32 + %12 = arith.subf %cst, %11 : f32 + %13 = arith.mulf %10, %12 : f32 + %14 = arith.addf %7, %13 : f32 + %15 = arith.mulf %8, %14 : f32 + affine.store %15, %arg2[%arg3] : memref + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_mish_backward/raised.mlir b/issues/aten_c_kernels/results/aten_mish_backward/raised.mlir new file mode 100644 index 000000000000..f0f1c8385460 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mish_backward/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mish_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0, %arg1 : memref, memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.negf %in : f32 + %1 = math.exp %0 : f32 + %2 = arith.addf %1, %cst : f32 + %3 = arith.divf %cst, %2 : f32 + %4 = math.exp %in : f32 + %5 = math.log1p %4 : f32 + %6 = math.tanh %5 : f32 + %7 = arith.mulf %in_1, %3 : f32 + %8 = arith.mulf %6, %6 : f32 + %9 = arith.subf %cst, %8 : f32 + %10 = arith.mulf %7, %9 : f32 + %11 = arith.addf %6, %10 : f32 + %12 = arith.mulf %in_0, %11 : f32 + linalg.yield %12 : f32 + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_mish_backward_debuf.mlir b/issues/aten_c_kernels/results/aten_mish_backward_debuf.mlir new file mode 100644 index 000000000000..e3db0bb5c3a7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mish_backward_debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mish_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0, %1 : tensor, tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %5 = arith.negf %in : f32 + %6 = math.exp %5 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.divf %cst, %7 : f32 + %9 = math.exp %in : f32 + %10 = math.log1p %9 : f32 + %11 = math.tanh %10 : f32 + %12 = arith.mulf %in_1, %8 : f32 + %13 = arith.mulf %11, %11 : f32 + %14 = arith.subf %cst, %13 : f32 + %15 = arith.mulf %12, %14 : f32 + %16 = arith.addf %11, %15 : f32 + %17 = arith.mulf %in_0, %16 : f32 + linalg.yield %17 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_mish_backward_linalg.mlir b/issues/aten_c_kernels/results/aten_mish_backward_linalg.mlir new file mode 100644 index 000000000000..f0f1c8385460 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mish_backward_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mish_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0, %arg1 : memref, memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.negf %in : f32 + %1 = math.exp %0 : f32 + %2 = arith.addf %1, %cst : f32 + %3 = arith.divf %cst, %2 : f32 + %4 = math.exp %in : f32 + %5 = math.log1p %4 : f32 + %6 = math.tanh %5 : f32 + %7 = arith.mulf %in_1, %3 : f32 + %8 = arith.mulf %6, %6 : f32 + %9 = arith.subf %cst, %8 : f32 + %10 = arith.mulf %7, %9 : f32 + %11 = arith.addf %6, %10 : f32 + %12 = arith.mulf %in_0, %11 : f32 + linalg.yield %12 : f32 + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_mish_debuf.mlir b/issues/aten_c_kernels/results/aten_mish_debuf.mlir new file mode 100644 index 000000000000..fd43c4c1b72e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mish_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mish(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.exp %in : f32 + %5 = math.log1p %4 : f32 + %6 = math.tanh %5 : f32 + %7 = arith.mulf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_mish_linalg.mlir b/issues/aten_c_kernels/results/aten_mish_linalg.mlir new file mode 100644 index 000000000000..3e5693bf0dee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mish_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mish(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.exp %in : f32 + %1 = math.log1p %0 : f32 + %2 = math.tanh %1 : f32 + %3 = arith.mulf %in, %2 : f32 + linalg.yield %3 : f32 + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_mm.mlir b/issues/aten_c_kernels/results/aten_mm.mlir new file mode 100644 index 000000000000..0f1803377dfa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mm.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mm(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 16 { + affine.store %cst, %arg2[%arg3, %arg4] : memref + } + } + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 16 { + %0 = affine.load %arg0[%arg3, %arg5] : memref + %1 = affine.load %arg1[%arg5, %arg4] : memref + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %arg2[%arg3, %arg4] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_mm/debuf.mlir b/issues/aten_c_kernels/results/aten_mm/debuf.mlir new file mode 100644 index 000000000000..2fa86a193dd5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mm/debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mm(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %6 = arith.mulf %in, %in_2 : f64 + %7 = arith.addf %out, %6 : f64 + linalg.yield %7 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0] [%c16, %c16] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mm/matched.mlir b/issues/aten_c_kernels/results/aten_mm/matched.mlir new file mode 100644 index 000000000000..bcc3f9bac527 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mm/matched.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mm(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %extracted_slice_0_contract_4_tc0 = tensor.cast %extracted_slice_0 : tensor to tensor<*xf64> + + %extracted_slice_1_contract_4_tc1 = tensor.cast %extracted_slice_1 : tensor to tensor<*xf64> + + %extracted_slice_contract_4_tc2 = tensor.cast %extracted_slice : tensor to tensor<*xf64> + + %v4_tdyn = kernel.launch @cutensornetContraction2_f64(%extracted_slice_0_contract_4_tc0, %extracted_slice_1_contract_4_tc1, %extracted_slice_contract_4_tc2) {contraction_maps = [affine_map<(d0, d1, d2) -> (d0, d2)>, affine_map<(d0, d1, d2) -> (d2, d1)>, affine_map<(d0, d1, d2) -> (d0, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %4 = tensor.cast %v4_tdyn : tensor<*xf64> to tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0] [%c16, %c16] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mm/orig.mlir b/issues/aten_c_kernels/results/aten_mm/orig.mlir new file mode 100644 index 000000000000..0f1803377dfa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mm/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mm(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 16 { + affine.store %cst, %arg2[%arg3, %arg4] : memref + } + } + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 16 { + %0 = affine.load %arg0[%arg3, %arg5] : memref + %1 = affine.load %arg1[%arg5, %arg4] : memref + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %arg2[%arg3, %arg4] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_mm/raised.mlir b/issues/aten_c_kernels/results/aten_mm/raised.mlir new file mode 100644 index 000000000000..85a2212f0fcb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mm/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mm(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f64 + %subview = memref.subview %arg2[0, 0] [%c16, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_0 = memref.subview %arg0[0, 0] [%c16, %c16] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0] [%c16, %c16] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0] [%c16, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f64, %in_3: f64, %out: f64): + %0 = arith.mulf %in, %in_3 : f64 + %1 = arith.addf %out, %0 : f64 + linalg.yield %1 : f64 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mm_debuf.mlir b/issues/aten_c_kernels/results/aten_mm_debuf.mlir new file mode 100644 index 000000000000..2fa86a193dd5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mm_debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mm(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %6 = arith.mulf %in, %in_2 : f64 + %7 = arith.addf %out, %6 : f64 + linalg.yield %7 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0] [%c16, %c16] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mm_linalg.mlir b/issues/aten_c_kernels/results/aten_mm_linalg.mlir new file mode 100644 index 000000000000..85a2212f0fcb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mm_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mm(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f64 + %subview = memref.subview %arg2[0, 0] [%c16, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_0 = memref.subview %arg0[0, 0] [%c16, %c16] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0] [%c16, %c16] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0] [%c16, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f64, %in_3: f64, %out: f64): + %0 = arith.mulf %in, %in_3 : f64 + %1 = arith.addf %out, %0 : f64 + linalg.yield %1 : f64 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mode_cpu.mlir b/issues/aten_c_kernels/results/aten_mode_cpu.mlir new file mode 100644 index 000000000000..5d74c865df62 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mode_cpu.mlir @@ -0,0 +1,74 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mode_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<64xi32> + %alloca_0 = memref.alloca() : memref<64xf32> + affine.for %arg3 = 0 to 64 { + %4 = arith.index_cast %arg3 : index to i32 + %5 = affine.load %arg0[%arg3] : memref + affine.store %5, %alloca_0[%arg3] : memref<64xf32> + affine.store %4, %alloca[%arg3] : memref<64xi32> + } + affine.for %arg3 = 1 to 64 { + %4 = arith.index_cast %arg3 : index to i32 + %5 = affine.load %alloca_0[%arg3] : memref<64xf32> + %6 = affine.load %alloca[%arg3] : memref<64xi32> + %7 = arith.addi %4, %c-1_i32 : i32 + %8 = scf.while (%arg4 = %7) : (i32) -> i32 { + %11 = arith.cmpi sge, %arg4, %c0_i32 : i32 + %12:2 = scf.if %11 -> (i1, i32) { + %13 = arith.index_cast %arg4 : i32 to index + %14 = memref.load %alloca_0[%13] : memref<64xf32> + %15 = arith.cmpf ogt, %14, %5 : f32 + %16 = scf.if %15 -> (i32) { + %17 = arith.addi %arg4, %c1_i32 : i32 + %18 = arith.index_cast %17 : i32 to index + memref.store %14, %alloca_0[%18] : memref<64xf32> + %19 = memref.load %alloca[%13] : memref<64xi32> + memref.store %19, %alloca[%18] : memref<64xi32> + %20 = arith.addi %arg4, %c-1_i32 : i32 + scf.yield %20 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %15, %16 : i1, i32 + } else { + scf.yield %false, %arg4 : i1, i32 + } + scf.condition(%12#0) %12#1 : i32 + } do { + ^bb0(%arg4: i32): + scf.yield %arg4 : i32 + } + %9 = arith.addi %8, %c1_i32 : i32 + %10 = arith.index_cast %9 : i32 to index + memref.store %5, %alloca_0[%10] : memref<64xf32> + memref.store %6, %alloca[%10] : memref<64xi32> + } + %0:3 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %c0_i32, %arg5 = %c1_i32, %arg6 = %c1_i32) -> (i32, i32, i32) { + %4 = arith.index_cast %arg3 : index to i32 + %5 = affine.load %alloca_0[%arg3] : memref<64xf32> + %6 = affine.load %alloca_0[%arg3 - 1] : memref<64xf32> + %7 = arith.cmpf oeq, %5, %6 : f32 + %8 = scf.if %7 -> (i32) { + %12 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %12 : i32 + } else { + scf.yield %c1_i32 : i32 + } + %9 = arith.cmpi sgt, %8, %arg6 : i32 + %10 = arith.select %9, %4, %arg4 : i32 + %11 = arith.select %9, %8, %arg6 : i32 + affine.yield %10, %8, %11 : i32, i32, i32 + } + %1 = arith.index_cast %0#0 : i32 to index + %2 = affine.load %alloca_0[symbol(%1)] : memref<64xf32> + affine.store %2, %arg1[0] : memref + %3 = affine.load %alloca[symbol(%1)] : memref<64xi32> + affine.store %3, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_mode_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_mode_cpu/debuf.mlir new file mode 100644 index 000000000000..752f645946ba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mode_cpu/debuf.mlir @@ -0,0 +1,104 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mode_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c-1_i32 = arith.constant -1 : i32 + %c63 = arith.constant 63 : index + %c64 = arith.constant 64 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<64xi32> + %4 = tensor.empty() : tensor<64xf32> + %alloca = memref.alloca() : memref<64xf32> + %5 = bufferization.to_tensor %alloca : memref<64xf32> + %extracted_slice = tensor.extract_slice %4[0] [%c64] [1] : tensor<64xf32> to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c64] [1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %4[0] [%c64] [1] : tensor into tensor<64xf32> + %extracted_slice_1 = tensor.extract_slice %3[0] [%c64] [1] : tensor<64xi32> to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice_1 : tensor) { + ^bb0(%out: i32): + %16 = linalg.index 0 : index + %17 = arith.index_cast %16 : index to i32 + linalg.yield %17 : i32 + } -> tensor + %inserted_slice_2 = tensor.insert_slice %7 into %3[0] [%c64] [1] : tensor into tensor<64xi32> + %8:2 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %inserted_slice_2, %arg5 = %inserted_slice) -> (tensor<64xi32>, tensor<64xf32>) { + %16 = arith.index_cast %arg3 : index to i32 + %extracted_11 = tensor.extract %arg5[%arg3] : tensor<64xf32> + %extracted_12 = tensor.extract %arg4[%arg3] : tensor<64xi32> + %17 = arith.addi %16, %c-1_i32 : i32 + %18:3 = scf.while (%arg6 = %17, %arg7 = %arg4, %arg8 = %arg5) : (i32, tensor<64xi32>, tensor<64xf32>) -> (i32, tensor<64xi32>, tensor<64xf32>) { + %21 = arith.cmpi sge, %arg6, %c0_i32 : i32 + %22:4 = scf.if %21 -> (i1, i32, tensor<64xi32>, tensor<64xf32>) { + %23 = arith.index_cast %arg6 : i32 to index + %extracted_15 = tensor.extract %arg8[%23] : tensor<64xf32> + %24 = arith.cmpf ogt, %extracted_15, %extracted_11 : f32 + %25:3 = scf.if %24 -> (i32, tensor<64xi32>, tensor<64xf32>) { + %26 = arith.addi %arg6, %c1_i32 : i32 + %27 = arith.index_cast %26 : i32 to index + %inserted_16 = tensor.insert %extracted_15 into %arg8[%27] : tensor<64xf32> + %extracted_17 = tensor.extract %arg7[%23] : tensor<64xi32> + %inserted_18 = tensor.insert %extracted_17 into %arg7[%27] : tensor<64xi32> + %28 = arith.addi %arg6, %c-1_i32 : i32 + scf.yield %28, %inserted_18, %inserted_16 : i32, tensor<64xi32>, tensor<64xf32> + } else { + scf.yield %arg6, %arg7, %arg8 : i32, tensor<64xi32>, tensor<64xf32> + } + scf.yield %24, %25#0, %25#1, %25#2 : i1, i32, tensor<64xi32>, tensor<64xf32> + } else { + scf.yield %false, %arg6, %arg7, %arg8 : i1, i32, tensor<64xi32>, tensor<64xf32> + } + scf.condition(%22#0) %22#1, %22#2, %22#3 : i32, tensor<64xi32>, tensor<64xf32> + } do { + ^bb0(%arg6: i32, %arg7: tensor<64xi32>, %arg8: tensor<64xf32>): + scf.yield %arg6, %arg7, %arg8 : i32, tensor<64xi32>, tensor<64xf32> + } + %19 = arith.addi %18#0, %c1_i32 : i32 + %20 = arith.index_cast %19 : i32 to index + %inserted_13 = tensor.insert %extracted_11 into %18#2[%20] : tensor<64xf32> + %inserted_14 = tensor.insert %extracted_12 into %18#1[%20] : tensor<64xi32> + affine.yield %inserted_14, %inserted_13 : tensor<64xi32>, tensor<64xf32> + } + %9 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %9[] : tensor + %10 = tensor.empty() : tensor + %inserted_3 = tensor.insert %c1_i32 into %10[] : tensor + %11 = tensor.empty() : tensor + %inserted_4 = tensor.insert %c1_i32 into %11[] : tensor + %extracted_slice_5 = tensor.extract_slice %5[1] [%c63] [1] : tensor<64xf32> to tensor + %extracted_slice_6 = tensor.extract_slice %5[0] [%c63] [1] : tensor<64xf32> to tensor + %12:3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_5, %extracted_slice_6 : tensor, tensor) outs(%inserted, %inserted_3, %inserted_4 : tensor, tensor, tensor) { + ^bb0(%in: f32, %in_11: f32, %out: i32, %out_12: i32, %out_13: i32): + %16 = linalg.index 0 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.cmpf oeq, %in, %in_11 : f32 + %19 = arith.addi %out_12, %c1_i32 : i32 + %20 = arith.select %18, %19, %c1_i32 : i32 + %21 = arith.cmpi sgt, %20, %out_13 : i32 + %22 = arith.select %21, %17, %out : i32 + %23 = arith.select %21, %20, %out_13 : i32 + linalg.yield %22, %20, %23 : i32, i32, i32 + } -> (tensor, tensor, tensor) + %extracted = tensor.extract %12#0[] : tensor + %13 = arith.index_cast %extracted : i32 to index + %extracted_7 = tensor.extract %8#1[%13] : tensor<64xf32> + %inserted_8 = tensor.insert %extracted_7 into %1[%c0] : tensor + %14 = bufferization.to_memref %inserted_8 : memref + memref.copy %14, %arg1 : memref to memref + %extracted_9 = tensor.extract %8#0[%13] : tensor<64xi32> + %inserted_10 = tensor.insert %extracted_9 into %0[%c0] : tensor + %15 = bufferization.to_memref %inserted_10 : memref + memref.copy %15, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mode_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_mode_cpu/matched.mlir new file mode 100644 index 000000000000..0963667614e8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mode_cpu/matched.mlir @@ -0,0 +1,101 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mode_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c-1_i32 = arith.constant -1 : i32 + %c63 = arith.constant 63 : index + %c64 = arith.constant 64 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<64xi32> + %4 = tensor.empty() : tensor<64xf32> + %alloca = memref.alloca() : memref<64xf32> + %5 = bufferization.to_tensor %alloca : memref<64xf32> + %extracted_slice = tensor.extract_slice %4[0] [%c64] [1] : tensor<64xf32> to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c64] [1] : tensor to tensor + %6 = kernel.launch @cudaCopy1D_f32_tensor(%extracted_slice_0, %extracted_slice) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %6 into %4[0] [%c64] [1] : tensor into tensor<64xf32> + %extracted_slice_1 = tensor.extract_slice %3[0] [%c64] [1] : tensor<64xi32> to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice_1 : tensor) { + ^bb0(%out: i32): + %16 = linalg.index 0 : index + %17 = arith.index_cast %16 : index to i32 + linalg.yield %17 : i32 + } -> tensor + %inserted_slice_2 = tensor.insert_slice %7 into %3[0] [%c64] [1] : tensor into tensor<64xi32> + %8:2 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %inserted_slice_2, %arg5 = %inserted_slice) -> (tensor<64xi32>, tensor<64xf32>) { + %16 = arith.index_cast %arg3 : index to i32 + %extracted_11 = tensor.extract %arg5[%arg3] : tensor<64xf32> + %extracted_12 = tensor.extract %arg4[%arg3] : tensor<64xi32> + %17 = arith.addi %16, %c-1_i32 : i32 + %18:3 = scf.while (%arg6 = %17, %arg7 = %arg4, %arg8 = %arg5) : (i32, tensor<64xi32>, tensor<64xf32>) -> (i32, tensor<64xi32>, tensor<64xf32>) { + %21 = arith.cmpi sge, %arg6, %c0_i32 : i32 + %22:4 = scf.if %21 -> (i1, i32, tensor<64xi32>, tensor<64xf32>) { + %23 = arith.index_cast %arg6 : i32 to index + %extracted_15 = tensor.extract %arg8[%23] : tensor<64xf32> + %24 = arith.cmpf ogt, %extracted_15, %extracted_11 : f32 + %25:3 = scf.if %24 -> (i32, tensor<64xi32>, tensor<64xf32>) { + %26 = arith.addi %arg6, %c1_i32 : i32 + %27 = arith.index_cast %26 : i32 to index + %inserted_16 = tensor.insert %extracted_15 into %arg8[%27] : tensor<64xf32> + %extracted_17 = tensor.extract %arg7[%23] : tensor<64xi32> + %inserted_18 = tensor.insert %extracted_17 into %arg7[%27] : tensor<64xi32> + %28 = arith.addi %arg6, %c-1_i32 : i32 + scf.yield %28, %inserted_18, %inserted_16 : i32, tensor<64xi32>, tensor<64xf32> + } else { + scf.yield %arg6, %arg7, %arg8 : i32, tensor<64xi32>, tensor<64xf32> + } + scf.yield %24, %25#0, %25#1, %25#2 : i1, i32, tensor<64xi32>, tensor<64xf32> + } else { + scf.yield %false, %arg6, %arg7, %arg8 : i1, i32, tensor<64xi32>, tensor<64xf32> + } + scf.condition(%22#0) %22#1, %22#2, %22#3 : i32, tensor<64xi32>, tensor<64xf32> + } do { + ^bb0(%arg6: i32, %arg7: tensor<64xi32>, %arg8: tensor<64xf32>): + scf.yield %arg6, %arg7, %arg8 : i32, tensor<64xi32>, tensor<64xf32> + } + %19 = arith.addi %18#0, %c1_i32 : i32 + %20 = arith.index_cast %19 : i32 to index + %inserted_13 = tensor.insert %extracted_11 into %18#2[%20] : tensor<64xf32> + %inserted_14 = tensor.insert %extracted_12 into %18#1[%20] : tensor<64xi32> + affine.yield %inserted_14, %inserted_13 : tensor<64xi32>, tensor<64xf32> + } + %9 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %9[] : tensor + %10 = tensor.empty() : tensor + %inserted_3 = tensor.insert %c1_i32 into %10[] : tensor + %11 = tensor.empty() : tensor + %inserted_4 = tensor.insert %c1_i32 into %11[] : tensor + %extracted_slice_5 = tensor.extract_slice %5[1] [%c63] [1] : tensor<64xf32> to tensor + %extracted_slice_6 = tensor.extract_slice %5[0] [%c63] [1] : tensor<64xf32> to tensor + %12:3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_5, %extracted_slice_6 : tensor, tensor) outs(%inserted, %inserted_3, %inserted_4 : tensor, tensor, tensor) { + ^bb0(%in: f32, %in_11: f32, %out: i32, %out_12: i32, %out_13: i32): + %16 = linalg.index 0 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.cmpf oeq, %in, %in_11 : f32 + %19 = arith.addi %out_12, %c1_i32 : i32 + %20 = arith.select %18, %19, %c1_i32 : i32 + %21 = arith.cmpi sgt, %20, %out_13 : i32 + %22 = arith.select %21, %17, %out : i32 + %23 = arith.select %21, %20, %out_13 : i32 + linalg.yield %22, %20, %23 : i32, i32, i32 + } -> (tensor, tensor, tensor) + %extracted = tensor.extract %12#0[] : tensor + %13 = arith.index_cast %extracted : i32 to index + %extracted_7 = tensor.extract %8#1[%13] : tensor<64xf32> + %inserted_8 = tensor.insert %extracted_7 into %1[%c0] : tensor + %14 = bufferization.to_memref %inserted_8 : memref + memref.copy %14, %arg1 : memref to memref + %extracted_9 = tensor.extract %8#0[%13] : tensor<64xi32> + %inserted_10 = tensor.insert %extracted_9 into %0[%c0] : tensor + %15 = bufferization.to_memref %inserted_10 : memref + memref.copy %15, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mode_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_mode_cpu/orig.mlir new file mode 100644 index 000000000000..5d74c865df62 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mode_cpu/orig.mlir @@ -0,0 +1,74 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mode_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<64xi32> + %alloca_0 = memref.alloca() : memref<64xf32> + affine.for %arg3 = 0 to 64 { + %4 = arith.index_cast %arg3 : index to i32 + %5 = affine.load %arg0[%arg3] : memref + affine.store %5, %alloca_0[%arg3] : memref<64xf32> + affine.store %4, %alloca[%arg3] : memref<64xi32> + } + affine.for %arg3 = 1 to 64 { + %4 = arith.index_cast %arg3 : index to i32 + %5 = affine.load %alloca_0[%arg3] : memref<64xf32> + %6 = affine.load %alloca[%arg3] : memref<64xi32> + %7 = arith.addi %4, %c-1_i32 : i32 + %8 = scf.while (%arg4 = %7) : (i32) -> i32 { + %11 = arith.cmpi sge, %arg4, %c0_i32 : i32 + %12:2 = scf.if %11 -> (i1, i32) { + %13 = arith.index_cast %arg4 : i32 to index + %14 = memref.load %alloca_0[%13] : memref<64xf32> + %15 = arith.cmpf ogt, %14, %5 : f32 + %16 = scf.if %15 -> (i32) { + %17 = arith.addi %arg4, %c1_i32 : i32 + %18 = arith.index_cast %17 : i32 to index + memref.store %14, %alloca_0[%18] : memref<64xf32> + %19 = memref.load %alloca[%13] : memref<64xi32> + memref.store %19, %alloca[%18] : memref<64xi32> + %20 = arith.addi %arg4, %c-1_i32 : i32 + scf.yield %20 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %15, %16 : i1, i32 + } else { + scf.yield %false, %arg4 : i1, i32 + } + scf.condition(%12#0) %12#1 : i32 + } do { + ^bb0(%arg4: i32): + scf.yield %arg4 : i32 + } + %9 = arith.addi %8, %c1_i32 : i32 + %10 = arith.index_cast %9 : i32 to index + memref.store %5, %alloca_0[%10] : memref<64xf32> + memref.store %6, %alloca[%10] : memref<64xi32> + } + %0:3 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %c0_i32, %arg5 = %c1_i32, %arg6 = %c1_i32) -> (i32, i32, i32) { + %4 = arith.index_cast %arg3 : index to i32 + %5 = affine.load %alloca_0[%arg3] : memref<64xf32> + %6 = affine.load %alloca_0[%arg3 - 1] : memref<64xf32> + %7 = arith.cmpf oeq, %5, %6 : f32 + %8 = scf.if %7 -> (i32) { + %12 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %12 : i32 + } else { + scf.yield %c1_i32 : i32 + } + %9 = arith.cmpi sgt, %8, %arg6 : i32 + %10 = arith.select %9, %4, %arg4 : i32 + %11 = arith.select %9, %8, %arg6 : i32 + affine.yield %10, %8, %11 : i32, i32, i32 + } + %1 = arith.index_cast %0#0 : i32 to index + %2 = affine.load %alloca_0[symbol(%1)] : memref<64xf32> + affine.store %2, %arg1[0] : memref + %3 = affine.load %alloca[symbol(%1)] : memref<64xi32> + affine.store %3, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_mode_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_mode_cpu/raised.mlir new file mode 100644 index 000000000000..0c70ec7bf848 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mode_cpu/raised.mlir @@ -0,0 +1,94 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mode_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c63 = arith.constant 63 : index + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<64xi32> + %alloca_0 = memref.alloca() : memref<64xf32> + %subview = memref.subview %arg0[0] [%c64] [1] : memref to memref> + %subview_1 = memref.subview %alloca_0[0] [%c64] [1] : memref<64xf32> to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_2 = memref.subview %alloca[0] [%c64] [1] : memref<64xi32> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview_2 : memref>) { + ^bb0(%out: i32): + %4 = linalg.index 0 : index + %5 = arith.index_cast %4 : index to i32 + linalg.yield %5 : i32 + } + affine.for %arg3 = 1 to 64 { + %4 = arith.index_cast %arg3 : index to i32 + %5 = affine.load %alloca_0[%arg3] : memref<64xf32> + %6 = affine.load %alloca[%arg3] : memref<64xi32> + %7 = arith.addi %4, %c-1_i32 : i32 + %8 = scf.while (%arg4 = %7) : (i32) -> i32 { + %11 = arith.cmpi sge, %arg4, %c0_i32 : i32 + %12:2 = scf.if %11 -> (i1, i32) { + %13 = arith.index_cast %arg4 : i32 to index + %14 = memref.load %alloca_0[%13] : memref<64xf32> + %15 = arith.cmpf ogt, %14, %5 : f32 + %16 = scf.if %15 -> (i32) { + %17 = arith.addi %arg4, %c1_i32 : i32 + %18 = arith.index_cast %17 : i32 to index + memref.store %14, %alloca_0[%18] : memref<64xf32> + %19 = memref.load %alloca[%13] : memref<64xi32> + memref.store %19, %alloca[%18] : memref<64xi32> + %20 = arith.addi %arg4, %c-1_i32 : i32 + scf.yield %20 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %15, %16 : i1, i32 + } else { + scf.yield %false, %arg4 : i1, i32 + } + scf.condition(%12#0) %12#1 : i32 + } do { + ^bb0(%arg4: i32): + scf.yield %arg4 : i32 + } + %9 = arith.addi %8, %c1_i32 : i32 + %10 = arith.index_cast %9 : i32 to index + memref.store %5, %alloca_0[%10] : memref<64xf32> + memref.store %6, %alloca[%10] : memref<64xi32> + } + %alloca_3 = memref.alloca() : memref + affine.store %c0_i32, %alloca_3[] : memref + %alloca_4 = memref.alloca() : memref + affine.store %c1_i32, %alloca_4[] : memref + %alloca_5 = memref.alloca() : memref + affine.store %c1_i32, %alloca_5[] : memref + %subview_6 = memref.subview %alloca_0[1] [%c63] [1] : memref<64xf32> to memref> + %subview_7 = memref.subview %alloca_0[0] [%c63] [1] : memref<64xf32> to memref> + %subview_8 = memref.subview %alloca_3[] [] [] : memref to memref> + %subview_9 = memref.subview %alloca_4[] [] [] : memref to memref> + %subview_10 = memref.subview %alloca_5[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1, #map1, #map1], iterator_types = ["reduction"]} ins(%subview_6, %subview_7 : memref>, memref>) outs(%subview_8, %subview_9, %subview_10 : memref>, memref>, memref>) { + ^bb0(%in: f32, %in_11: f32, %out: i32, %out_12: i32, %out_13: i32): + %4 = linalg.index 0 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.cmpf oeq, %in, %in_11 : f32 + %7 = arith.addi %out_12, %c1_i32 : i32 + %8 = arith.select %6, %7, %c1_i32 : i32 + %9 = arith.cmpi sgt, %8, %out_13 : i32 + %10 = arith.select %9, %5, %out : i32 + %11 = arith.select %9, %8, %out_13 : i32 + linalg.yield %10, %8, %11 : i32, i32, i32 + } + %0 = affine.load %alloca_3[] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %alloca_0[symbol(%1)] : memref<64xf32> + affine.store %2, %arg1[0] : memref + %3 = affine.load %alloca[symbol(%1)] : memref<64xi32> + affine.store %3, %arg2[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mode_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_mode_cpu_debuf.mlir new file mode 100644 index 000000000000..752f645946ba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mode_cpu_debuf.mlir @@ -0,0 +1,104 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mode_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c-1_i32 = arith.constant -1 : i32 + %c63 = arith.constant 63 : index + %c64 = arith.constant 64 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<64xi32> + %4 = tensor.empty() : tensor<64xf32> + %alloca = memref.alloca() : memref<64xf32> + %5 = bufferization.to_tensor %alloca : memref<64xf32> + %extracted_slice = tensor.extract_slice %4[0] [%c64] [1] : tensor<64xf32> to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c64] [1] : tensor to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %4[0] [%c64] [1] : tensor into tensor<64xf32> + %extracted_slice_1 = tensor.extract_slice %3[0] [%c64] [1] : tensor<64xi32> to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice_1 : tensor) { + ^bb0(%out: i32): + %16 = linalg.index 0 : index + %17 = arith.index_cast %16 : index to i32 + linalg.yield %17 : i32 + } -> tensor + %inserted_slice_2 = tensor.insert_slice %7 into %3[0] [%c64] [1] : tensor into tensor<64xi32> + %8:2 = affine.for %arg3 = 1 to 64 iter_args(%arg4 = %inserted_slice_2, %arg5 = %inserted_slice) -> (tensor<64xi32>, tensor<64xf32>) { + %16 = arith.index_cast %arg3 : index to i32 + %extracted_11 = tensor.extract %arg5[%arg3] : tensor<64xf32> + %extracted_12 = tensor.extract %arg4[%arg3] : tensor<64xi32> + %17 = arith.addi %16, %c-1_i32 : i32 + %18:3 = scf.while (%arg6 = %17, %arg7 = %arg4, %arg8 = %arg5) : (i32, tensor<64xi32>, tensor<64xf32>) -> (i32, tensor<64xi32>, tensor<64xf32>) { + %21 = arith.cmpi sge, %arg6, %c0_i32 : i32 + %22:4 = scf.if %21 -> (i1, i32, tensor<64xi32>, tensor<64xf32>) { + %23 = arith.index_cast %arg6 : i32 to index + %extracted_15 = tensor.extract %arg8[%23] : tensor<64xf32> + %24 = arith.cmpf ogt, %extracted_15, %extracted_11 : f32 + %25:3 = scf.if %24 -> (i32, tensor<64xi32>, tensor<64xf32>) { + %26 = arith.addi %arg6, %c1_i32 : i32 + %27 = arith.index_cast %26 : i32 to index + %inserted_16 = tensor.insert %extracted_15 into %arg8[%27] : tensor<64xf32> + %extracted_17 = tensor.extract %arg7[%23] : tensor<64xi32> + %inserted_18 = tensor.insert %extracted_17 into %arg7[%27] : tensor<64xi32> + %28 = arith.addi %arg6, %c-1_i32 : i32 + scf.yield %28, %inserted_18, %inserted_16 : i32, tensor<64xi32>, tensor<64xf32> + } else { + scf.yield %arg6, %arg7, %arg8 : i32, tensor<64xi32>, tensor<64xf32> + } + scf.yield %24, %25#0, %25#1, %25#2 : i1, i32, tensor<64xi32>, tensor<64xf32> + } else { + scf.yield %false, %arg6, %arg7, %arg8 : i1, i32, tensor<64xi32>, tensor<64xf32> + } + scf.condition(%22#0) %22#1, %22#2, %22#3 : i32, tensor<64xi32>, tensor<64xf32> + } do { + ^bb0(%arg6: i32, %arg7: tensor<64xi32>, %arg8: tensor<64xf32>): + scf.yield %arg6, %arg7, %arg8 : i32, tensor<64xi32>, tensor<64xf32> + } + %19 = arith.addi %18#0, %c1_i32 : i32 + %20 = arith.index_cast %19 : i32 to index + %inserted_13 = tensor.insert %extracted_11 into %18#2[%20] : tensor<64xf32> + %inserted_14 = tensor.insert %extracted_12 into %18#1[%20] : tensor<64xi32> + affine.yield %inserted_14, %inserted_13 : tensor<64xi32>, tensor<64xf32> + } + %9 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %9[] : tensor + %10 = tensor.empty() : tensor + %inserted_3 = tensor.insert %c1_i32 into %10[] : tensor + %11 = tensor.empty() : tensor + %inserted_4 = tensor.insert %c1_i32 into %11[] : tensor + %extracted_slice_5 = tensor.extract_slice %5[1] [%c63] [1] : tensor<64xf32> to tensor + %extracted_slice_6 = tensor.extract_slice %5[0] [%c63] [1] : tensor<64xf32> to tensor + %12:3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_5, %extracted_slice_6 : tensor, tensor) outs(%inserted, %inserted_3, %inserted_4 : tensor, tensor, tensor) { + ^bb0(%in: f32, %in_11: f32, %out: i32, %out_12: i32, %out_13: i32): + %16 = linalg.index 0 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.cmpf oeq, %in, %in_11 : f32 + %19 = arith.addi %out_12, %c1_i32 : i32 + %20 = arith.select %18, %19, %c1_i32 : i32 + %21 = arith.cmpi sgt, %20, %out_13 : i32 + %22 = arith.select %21, %17, %out : i32 + %23 = arith.select %21, %20, %out_13 : i32 + linalg.yield %22, %20, %23 : i32, i32, i32 + } -> (tensor, tensor, tensor) + %extracted = tensor.extract %12#0[] : tensor + %13 = arith.index_cast %extracted : i32 to index + %extracted_7 = tensor.extract %8#1[%13] : tensor<64xf32> + %inserted_8 = tensor.insert %extracted_7 into %1[%c0] : tensor + %14 = bufferization.to_memref %inserted_8 : memref + memref.copy %14, %arg1 : memref to memref + %extracted_9 = tensor.extract %8#0[%13] : tensor<64xi32> + %inserted_10 = tensor.insert %extracted_9 into %0[%c0] : tensor + %15 = bufferization.to_memref %inserted_10 : memref + memref.copy %15, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mode_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_mode_cpu_linalg.mlir new file mode 100644 index 000000000000..0c70ec7bf848 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mode_cpu_linalg.mlir @@ -0,0 +1,94 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mode_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c63 = arith.constant 63 : index + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<64xi32> + %alloca_0 = memref.alloca() : memref<64xf32> + %subview = memref.subview %arg0[0] [%c64] [1] : memref to memref> + %subview_1 = memref.subview %alloca_0[0] [%c64] [1] : memref<64xf32> to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_2 = memref.subview %alloca[0] [%c64] [1] : memref<64xi32> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview_2 : memref>) { + ^bb0(%out: i32): + %4 = linalg.index 0 : index + %5 = arith.index_cast %4 : index to i32 + linalg.yield %5 : i32 + } + affine.for %arg3 = 1 to 64 { + %4 = arith.index_cast %arg3 : index to i32 + %5 = affine.load %alloca_0[%arg3] : memref<64xf32> + %6 = affine.load %alloca[%arg3] : memref<64xi32> + %7 = arith.addi %4, %c-1_i32 : i32 + %8 = scf.while (%arg4 = %7) : (i32) -> i32 { + %11 = arith.cmpi sge, %arg4, %c0_i32 : i32 + %12:2 = scf.if %11 -> (i1, i32) { + %13 = arith.index_cast %arg4 : i32 to index + %14 = memref.load %alloca_0[%13] : memref<64xf32> + %15 = arith.cmpf ogt, %14, %5 : f32 + %16 = scf.if %15 -> (i32) { + %17 = arith.addi %arg4, %c1_i32 : i32 + %18 = arith.index_cast %17 : i32 to index + memref.store %14, %alloca_0[%18] : memref<64xf32> + %19 = memref.load %alloca[%13] : memref<64xi32> + memref.store %19, %alloca[%18] : memref<64xi32> + %20 = arith.addi %arg4, %c-1_i32 : i32 + scf.yield %20 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %15, %16 : i1, i32 + } else { + scf.yield %false, %arg4 : i1, i32 + } + scf.condition(%12#0) %12#1 : i32 + } do { + ^bb0(%arg4: i32): + scf.yield %arg4 : i32 + } + %9 = arith.addi %8, %c1_i32 : i32 + %10 = arith.index_cast %9 : i32 to index + memref.store %5, %alloca_0[%10] : memref<64xf32> + memref.store %6, %alloca[%10] : memref<64xi32> + } + %alloca_3 = memref.alloca() : memref + affine.store %c0_i32, %alloca_3[] : memref + %alloca_4 = memref.alloca() : memref + affine.store %c1_i32, %alloca_4[] : memref + %alloca_5 = memref.alloca() : memref + affine.store %c1_i32, %alloca_5[] : memref + %subview_6 = memref.subview %alloca_0[1] [%c63] [1] : memref<64xf32> to memref> + %subview_7 = memref.subview %alloca_0[0] [%c63] [1] : memref<64xf32> to memref> + %subview_8 = memref.subview %alloca_3[] [] [] : memref to memref> + %subview_9 = memref.subview %alloca_4[] [] [] : memref to memref> + %subview_10 = memref.subview %alloca_5[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1, #map1, #map1], iterator_types = ["reduction"]} ins(%subview_6, %subview_7 : memref>, memref>) outs(%subview_8, %subview_9, %subview_10 : memref>, memref>, memref>) { + ^bb0(%in: f32, %in_11: f32, %out: i32, %out_12: i32, %out_13: i32): + %4 = linalg.index 0 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.cmpf oeq, %in, %in_11 : f32 + %7 = arith.addi %out_12, %c1_i32 : i32 + %8 = arith.select %6, %7, %c1_i32 : i32 + %9 = arith.cmpi sgt, %8, %out_13 : i32 + %10 = arith.select %9, %5, %out : i32 + %11 = arith.select %9, %8, %out_13 : i32 + linalg.yield %10, %8, %11 : i32, i32, i32 + } + %0 = affine.load %alloca_3[] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %alloca_0[symbol(%1)] : memref<64xf32> + affine.store %2, %arg1[0] : memref + %3 = affine.load %alloca[symbol(%1)] : memref<64xi32> + affine.store %3, %arg2[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_i0.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_i0.mlir new file mode 100644 index 000000000000..ea95d87868cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_i0.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_i0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @modified_bessel_i0_forwardf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @modified_bessel_i0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_i0/debuf.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_i0/debuf.mlir new file mode 100644 index 000000000000..644996352457 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_i0/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_i0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @modified_bessel_i0_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @modified_bessel_i0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_i0/matched.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_i0/matched.mlir new file mode 100644 index 000000000000..644996352457 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_i0/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_i0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @modified_bessel_i0_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @modified_bessel_i0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_i0/orig.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_i0/orig.mlir new file mode 100644 index 000000000000..ea95d87868cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_i0/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_i0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @modified_bessel_i0_forwardf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @modified_bessel_i0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_i0/raised.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_i0/raised.mlir new file mode 100644 index 000000000000..7cce8a1e7eba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_i0/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_i0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @modified_bessel_i0_forwardf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @modified_bessel_i0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_i0_debuf.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_i0_debuf.mlir new file mode 100644 index 000000000000..644996352457 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_i0_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_i0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @modified_bessel_i0_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @modified_bessel_i0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_i0_linalg.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_i0_linalg.mlir new file mode 100644 index 000000000000..7cce8a1e7eba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_i0_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_i0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @modified_bessel_i0_forwardf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @modified_bessel_i0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_i1.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_i1.mlir new file mode 100644 index 000000000000..826d34e7e276 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_i1.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_i1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @modified_bessel_i1_forwardf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @modified_bessel_i1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_i1/debuf.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_i1/debuf.mlir new file mode 100644 index 000000000000..6e7dae9b3ea4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_i1/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_i1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @modified_bessel_i1_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @modified_bessel_i1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_i1/matched.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_i1/matched.mlir new file mode 100644 index 000000000000..6e7dae9b3ea4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_i1/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_i1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @modified_bessel_i1_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @modified_bessel_i1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_i1/orig.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_i1/orig.mlir new file mode 100644 index 000000000000..826d34e7e276 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_i1/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_i1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @modified_bessel_i1_forwardf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @modified_bessel_i1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_i1/raised.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_i1/raised.mlir new file mode 100644 index 000000000000..8c77e3ed58e6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_i1/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_i1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @modified_bessel_i1_forwardf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @modified_bessel_i1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_i1_debuf.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_i1_debuf.mlir new file mode 100644 index 000000000000..6e7dae9b3ea4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_i1_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_i1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @modified_bessel_i1_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @modified_bessel_i1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_i1_linalg.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_i1_linalg.mlir new file mode 100644 index 000000000000..8c77e3ed58e6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_i1_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_i1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @modified_bessel_i1_forwardf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @modified_bessel_i1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_k0.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_k0.mlir new file mode 100644 index 000000000000..c968db7b2a27 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_k0.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_k0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @modified_bessel_k0_forwardf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @modified_bessel_k0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_k0/debuf.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_k0/debuf.mlir new file mode 100644 index 000000000000..034d24b254fe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_k0/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_k0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @modified_bessel_k0_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @modified_bessel_k0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_k0/matched.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_k0/matched.mlir new file mode 100644 index 000000000000..034d24b254fe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_k0/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_k0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @modified_bessel_k0_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @modified_bessel_k0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_k0/orig.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_k0/orig.mlir new file mode 100644 index 000000000000..c968db7b2a27 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_k0/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_k0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @modified_bessel_k0_forwardf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @modified_bessel_k0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_k0/raised.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_k0/raised.mlir new file mode 100644 index 000000000000..1715ee9ca50e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_k0/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_k0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @modified_bessel_k0_forwardf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @modified_bessel_k0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_k0_debuf.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_k0_debuf.mlir new file mode 100644 index 000000000000..034d24b254fe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_k0_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_k0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @modified_bessel_k0_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @modified_bessel_k0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_k0_linalg.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_k0_linalg.mlir new file mode 100644 index 000000000000..1715ee9ca50e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_k0_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_k0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @modified_bessel_k0_forwardf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @modified_bessel_k0_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_k1.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_k1.mlir new file mode 100644 index 000000000000..76557c6db649 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_k1.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_k1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @modified_bessel_k1_forwardf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @modified_bessel_k1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_k1/debuf.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_k1/debuf.mlir new file mode 100644 index 000000000000..afddd596b94b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_k1/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_k1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @modified_bessel_k1_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @modified_bessel_k1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_k1/matched.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_k1/matched.mlir new file mode 100644 index 000000000000..afddd596b94b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_k1/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_k1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @modified_bessel_k1_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @modified_bessel_k1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_k1/orig.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_k1/orig.mlir new file mode 100644 index 000000000000..76557c6db649 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_k1/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_k1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @modified_bessel_k1_forwardf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @modified_bessel_k1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_k1/raised.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_k1/raised.mlir new file mode 100644 index 000000000000..6bfe97537eac --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_k1/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_k1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @modified_bessel_k1_forwardf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @modified_bessel_k1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_k1_debuf.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_k1_debuf.mlir new file mode 100644 index 000000000000..afddd596b94b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_k1_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_k1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @modified_bessel_k1_forwardf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @modified_bessel_k1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_modified_bessel_k1_linalg.mlir b/issues/aten_c_kernels/results/aten_modified_bessel_k1_linalg.mlir new file mode 100644 index 000000000000..6bfe97537eac --- /dev/null +++ b/issues/aten_c_kernels/results/aten_modified_bessel_k1_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_modified_bessel_k1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @modified_bessel_k1_forwardf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @modified_bessel_k1_forwardf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_mse_backward.mlir b/issues/aten_c_kernels/results/aten_mse_backward.mlir new file mode 100644 index 000000000000..6572f47150d0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_backward.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.subf %0, %1 : f32 + %3 = arith.mulf %arg2, %2 : f32 + affine.store %3, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_mse_backward/debuf.mlir b/issues/aten_c_kernels/results/aten_mse_backward/debuf.mlir new file mode 100644 index 000000000000..4ef4fd5b0eda --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_backward/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in, %in_0 : f32 + %6 = arith.mulf %arg2, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mse_backward/matched.mlir b/issues/aten_c_kernels/results/aten_mse_backward/matched.mlir new file mode 100644 index 000000000000..4ef4fd5b0eda --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_backward/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in, %in_0 : f32 + %6 = arith.mulf %arg2, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mse_backward/orig.mlir b/issues/aten_c_kernels/results/aten_mse_backward/orig.mlir new file mode 100644 index 000000000000..6572f47150d0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_backward/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.subf %0, %1 : f32 + %3 = arith.mulf %arg2, %2 : f32 + affine.store %3, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_mse_backward/raised.mlir b/issues/aten_c_kernels/results/aten_mse_backward/raised.mlir new file mode 100644 index 000000000000..c6524d2502a4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_backward/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.subf %in, %in_0 : f32 + %1 = arith.mulf %arg2, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mse_backward_debuf.mlir b/issues/aten_c_kernels/results/aten_mse_backward_debuf.mlir new file mode 100644 index 000000000000..4ef4fd5b0eda --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_backward_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in, %in_0 : f32 + %6 = arith.mulf %arg2, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mse_backward_linalg.mlir b/issues/aten_c_kernels/results/aten_mse_backward_linalg.mlir new file mode 100644 index 000000000000..c6524d2502a4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_backward_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.subf %in, %in_0 : f32 + %1 = arith.mulf %arg2, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mse_elementwise.mlir b/issues/aten_c_kernels/results/aten_mse_elementwise.mlir new file mode 100644 index 000000000000..d25fa4a9066d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_elementwise.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_elementwise(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.subf %0, %1 : f32 + %3 = arith.mulf %2, %2 : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_mse_elementwise/debuf.mlir b/issues/aten_c_kernels/results/aten_mse_elementwise/debuf.mlir new file mode 100644 index 000000000000..0df7d8e7461a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_elementwise/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_elementwise(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in, %in_0 : f32 + %6 = arith.mulf %5, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mse_elementwise/matched.mlir b/issues/aten_c_kernels/results/aten_mse_elementwise/matched.mlir new file mode 100644 index 000000000000..0df7d8e7461a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_elementwise/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_elementwise(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in, %in_0 : f32 + %6 = arith.mulf %5, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mse_elementwise/orig.mlir b/issues/aten_c_kernels/results/aten_mse_elementwise/orig.mlir new file mode 100644 index 000000000000..d25fa4a9066d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_elementwise/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_elementwise(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.subf %0, %1 : f32 + %3 = arith.mulf %2, %2 : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_mse_elementwise/raised.mlir b/issues/aten_c_kernels/results/aten_mse_elementwise/raised.mlir new file mode 100644 index 000000000000..e4bed2fee68f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_elementwise/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_elementwise(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.subf %in, %in_0 : f32 + %1 = arith.mulf %0, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mse_elementwise_debuf.mlir b/issues/aten_c_kernels/results/aten_mse_elementwise_debuf.mlir new file mode 100644 index 000000000000..0df7d8e7461a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_elementwise_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_elementwise(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in, %in_0 : f32 + %6 = arith.mulf %5, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mse_elementwise_linalg.mlir b/issues/aten_c_kernels/results/aten_mse_elementwise_linalg.mlir new file mode 100644 index 000000000000..e4bed2fee68f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_elementwise_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_elementwise(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.subf %in, %in_0 : f32 + %1 = arith.mulf %0, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mse_loss.mlir b/issues/aten_c_kernels/results/aten_mse_loss.mlir new file mode 100644 index 000000000000..212057efdd41 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_loss.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_loss(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.560000e+02 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_0, %alloca[] : memref + affine.for %arg4 = 0 to 256 { + %2 = affine.load %arg0[%arg4] : memref + %3 = affine.load %arg1[%arg4] : memref + %4 = arith.subf %2, %3 : f32 + %5 = arith.mulf %4, %4 : f32 + affine.store %5, %arg2[%arg4] : memref + } + affine.for %arg4 = 0 to 256 { + %2 = affine.load %arg2[%arg4] : memref + %3 = affine.load %alloca[] : memref + %4 = arith.addf %3, %2 : f32 + affine.store %4, %alloca[] : memref + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg3[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_mse_loss/debuf.mlir b/issues/aten_c_kernels/results/aten_mse_loss/debuf.mlir new file mode 100644 index 000000000000..bed201d1f8eb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_loss/debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_loss(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 2.560000e+02 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %4[] : tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %10 = arith.subf %in, %in_2 : f32 + %11 = arith.mulf %10, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%5 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %10 = arith.addf %out, %in : f32 + linalg.yield %10 : f32 + } -> tensor + %extracted = tensor.extract %7[] : tensor + %8 = arith.divf %extracted, %cst_0 : f32 + %inserted_1 = tensor.insert %8 into %3[%c0] : tensor + %9 = bufferization.to_memref %inserted_1 : memref + memref.copy %9, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mse_loss/matched.mlir b/issues/aten_c_kernels/results/aten_mse_loss/matched.mlir new file mode 100644 index 000000000000..bed201d1f8eb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_loss/matched.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_loss(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 2.560000e+02 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %4[] : tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %10 = arith.subf %in, %in_2 : f32 + %11 = arith.mulf %10, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%5 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %10 = arith.addf %out, %in : f32 + linalg.yield %10 : f32 + } -> tensor + %extracted = tensor.extract %7[] : tensor + %8 = arith.divf %extracted, %cst_0 : f32 + %inserted_1 = tensor.insert %8 into %3[%c0] : tensor + %9 = bufferization.to_memref %inserted_1 : memref + memref.copy %9, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mse_loss/orig.mlir b/issues/aten_c_kernels/results/aten_mse_loss/orig.mlir new file mode 100644 index 000000000000..212057efdd41 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_loss/orig.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_loss(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.560000e+02 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_0, %alloca[] : memref + affine.for %arg4 = 0 to 256 { + %2 = affine.load %arg0[%arg4] : memref + %3 = affine.load %arg1[%arg4] : memref + %4 = arith.subf %2, %3 : f32 + %5 = arith.mulf %4, %4 : f32 + affine.store %5, %arg2[%arg4] : memref + } + affine.for %arg4 = 0 to 256 { + %2 = affine.load %arg2[%arg4] : memref + %3 = affine.load %alloca[] : memref + %4 = arith.addf %3, %2 : f32 + affine.store %4, %alloca[] : memref + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg3[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_mse_loss/raised.mlir b/issues/aten_c_kernels/results/aten_mse_loss/raised.mlir new file mode 100644 index 000000000000..2e7353276b8a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_loss/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_loss(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.560000e+02 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_0, %alloca[] : memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.subf %in, %in_1 : f32 + %3 = arith.mulf %2, %2 : f32 + linalg.yield %3 : f32 + } + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg2 : memref) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.addf %out, %in : f32 + linalg.yield %2 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg3[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mse_loss_debuf.mlir b/issues/aten_c_kernels/results/aten_mse_loss_debuf.mlir new file mode 100644 index 000000000000..bed201d1f8eb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_loss_debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_loss(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 2.560000e+02 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %4[] : tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %10 = arith.subf %in, %in_2 : f32 + %11 = arith.mulf %10, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%5 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %10 = arith.addf %out, %in : f32 + linalg.yield %10 : f32 + } -> tensor + %extracted = tensor.extract %7[] : tensor + %8 = arith.divf %extracted, %cst_0 : f32 + %inserted_1 = tensor.insert %8 into %3[%c0] : tensor + %9 = bufferization.to_memref %inserted_1 : memref + memref.copy %9, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mse_loss_linalg.mlir b/issues/aten_c_kernels/results/aten_mse_loss_linalg.mlir new file mode 100644 index 000000000000..2e7353276b8a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mse_loss_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mse_loss(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.560000e+02 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_0, %alloca[] : memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.subf %in, %in_1 : f32 + %3 = arith.mulf %2, %2 : f32 + linalg.yield %3 : f32 + } + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg2 : memref) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.addf %out, %in : f32 + linalg.yield %2 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f32 + affine.store %1, %arg3[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mul.mlir b/issues/aten_c_kernels/results/aten_mul.mlir new file mode 100644 index 000000000000..201aefa53fbb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mul.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mul(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.mulf %0, %1 : f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_mul/debuf.mlir b/issues/aten_c_kernels/results/aten_mul/debuf.mlir new file mode 100644 index 000000000000..7c68ebb4e38b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mul/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mul(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mul/matched.mlir b/issues/aten_c_kernels/results/aten_mul/matched.mlir new file mode 100644 index 000000000000..7c68ebb4e38b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mul/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mul(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mul/orig.mlir b/issues/aten_c_kernels/results/aten_mul/orig.mlir new file mode 100644 index 000000000000..201aefa53fbb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mul/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mul(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.mulf %0, %1 : f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_mul/raised.mlir b/issues/aten_c_kernels/results/aten_mul/raised.mlir new file mode 100644 index 000000000000..d74f3350d62c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mul/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mul(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mul_debuf.mlir b/issues/aten_c_kernels/results/aten_mul_debuf.mlir new file mode 100644 index 000000000000..7c68ebb4e38b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mul_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mul(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mul_linalg.mlir b/issues/aten_c_kernels/results/aten_mul_linalg.mlir new file mode 100644 index 000000000000..d74f3350d62c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mul_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mul(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu.mlir new file mode 100644 index 000000000000..fc814a558fad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu.mlir @@ -0,0 +1,51 @@ +#set = affine_set<()[s0] : (s0 - 1 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multi_margin_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: i32, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 2.000000e+00 : f32 + %cst_2 = arith.constant 1.600000e+01 : f32 + %0 = arith.index_cast %arg4 : i32 to index + affine.for %arg7 = 0 to 32 { + %1 = affine.load %arg1[%arg7] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %cst) -> (f32) { + %5 = arith.index_cast %arg8 : index to i32 + affine.store %cst, %arg6[%arg7, %arg8] : memref + %6 = arith.cmpi ne, %5, %1 : i32 + %7 = scf.if %6 -> (f32) { + %8 = memref.load %arg0[%arg7, %2] : memref + %9 = arith.subf %arg3, %8 : f32 + %10 = affine.load %arg0[%arg7, %arg8] : memref + %11 = arith.addf %9, %10 : f32 + %12 = arith.cmpf ogt, %11, %cst : f32 + %13 = scf.if %12 -> (f32) { + %14 = affine.load %arg5[%arg7] : memref + %15 = memref.load %arg2[%2] : memref + %16 = arith.mulf %14, %15 : f32 + %17 = affine.if #set()[%0] -> f32 { + affine.yield %cst_0 : f32 + } else { + %21 = arith.mulf %11, %cst_1 : f32 + affine.yield %21 : f32 + } + %18 = arith.mulf %16, %17 : f32 + %19 = arith.divf %18, %cst_2 : f32 + affine.store %19, %arg6[%arg7, %arg8] : memref + %20 = arith.addf %arg9, %19 : f32 + scf.yield %20 : f32 + } else { + scf.yield %arg9 : f32 + } + scf.yield %13 : f32 + } else { + scf.yield %arg9 : f32 + } + affine.yield %7 : f32 + } + %4 = arith.negf %3 : f32 + memref.store %4, %arg6[%arg7, %2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..1ecef2df8349 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu/debuf.mlir @@ -0,0 +1,72 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multi_margin_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: i32, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.600000e+01 : f32 + %cst_0 = arith.constant 2.000000e+00 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = arith.index_cast %arg4 : i32 to index + %6 = tensor.empty(%c32) : tensor + %7:2 = affine.for %arg7 = 0 to 32 iter_args(%arg8 = %6, %arg9 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %3[%arg7] : tensor + %9 = arith.index_cast %extracted : i32 to index + %inserted = tensor.insert %cst_2 into %arg8[%arg7] : tensor + %extracted_slice = tensor.extract_slice %arg9[%arg7, 0] [1, %c16] [1, 1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst_2 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %10 into %arg9[%arg7, 0] [1, %c16] [1, 1] : tensor into tensor + %11:2 = affine.for %arg10 = 0 to 16 iter_args(%arg11 = %inserted, %arg12 = %inserted_slice) -> (tensor, tensor) { + %extracted_5 = tensor.extract %arg11[%arg7] : tensor + %13 = arith.index_cast %arg10 : index to i32 + %14 = arith.cmpi ne, %13, %extracted : i32 + %15:2 = scf.if %14 -> (f32, tensor) { + %extracted_7 = tensor.extract %4[%arg7, %9] : tensor + %16 = arith.subf %arg3, %extracted_7 : f32 + %extracted_8 = tensor.extract %4[%arg7, %arg10] : tensor + %17 = arith.addf %16, %extracted_8 : f32 + %18 = arith.cmpf ogt, %17, %cst_2 : f32 + %19:2 = scf.if %18 -> (f32, tensor) { + %extracted_9 = tensor.extract %1[%arg7] : tensor + %extracted_10 = tensor.extract %2[%9] : tensor + %20 = arith.mulf %extracted_9, %extracted_10 : f32 + %21 = affine.apply #map1()[%5] + %22 = arith.cmpi eq, %21, %c0 : index + %23 = arith.mulf %17, %cst_0 : f32 + %24 = arith.select %22, %cst_1, %23 : f32 + %25 = arith.mulf %20, %24 : f32 + %26 = arith.divf %25, %cst : f32 + %inserted_11 = tensor.insert %26 into %arg12[%arg7, %arg10] : tensor + %27 = arith.addf %extracted_5, %26 : f32 + scf.yield %27, %inserted_11 : f32, tensor + } else { + scf.yield %extracted_5, %arg12 : f32, tensor + } + scf.yield %19#0, %19#1 : f32, tensor + } else { + scf.yield %extracted_5, %arg12 : f32, tensor + } + %inserted_6 = tensor.insert %15#0 into %arg11[%arg7] : tensor + affine.yield %inserted_6, %15#1 : tensor, tensor + } + %extracted_3 = tensor.extract %11#0[%arg7] : tensor + %12 = arith.negf %extracted_3 : f32 + %inserted_4 = tensor.insert %12 into %11#1[%arg7, %9] : tensor + affine.yield %11#0, %inserted_4 : tensor, tensor + } + %8 = bufferization.to_memref %7#1 : memref + memref.copy %8, %arg6 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu/matched.mlir new file mode 100644 index 000000000000..4e4e8bfa242b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu/matched.mlir @@ -0,0 +1,69 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multi_margin_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: i32, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.600000e+01 : f32 + %cst_0 = arith.constant 2.000000e+00 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = arith.index_cast %arg4 : i32 to index + %6 = tensor.empty(%c32) : tensor + %7:2 = affine.for %arg7 = 0 to 32 iter_args(%arg8 = %6, %arg9 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %3[%arg7] : tensor + %9 = arith.index_cast %extracted : i32 to index + %inserted = tensor.insert %cst_2 into %arg8[%arg7] : tensor + %extracted_slice = tensor.extract_slice %arg9[%arg7, 0] [1, %c16] [1, 1] : tensor to tensor + %10 = kernel.launch @memset_zero_1D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %10 into %arg9[%arg7, 0] [1, %c16] [1, 1] : tensor into tensor + %11:2 = affine.for %arg10 = 0 to 16 iter_args(%arg11 = %inserted, %arg12 = %inserted_slice) -> (tensor, tensor) { + %extracted_5 = tensor.extract %arg11[%arg7] : tensor + %13 = arith.index_cast %arg10 : index to i32 + %14 = arith.cmpi ne, %13, %extracted : i32 + %15:2 = scf.if %14 -> (f32, tensor) { + %extracted_7 = tensor.extract %4[%arg7, %9] : tensor + %16 = arith.subf %arg3, %extracted_7 : f32 + %extracted_8 = tensor.extract %4[%arg7, %arg10] : tensor + %17 = arith.addf %16, %extracted_8 : f32 + %18 = arith.cmpf ogt, %17, %cst_2 : f32 + %19:2 = scf.if %18 -> (f32, tensor) { + %extracted_9 = tensor.extract %1[%arg7] : tensor + %extracted_10 = tensor.extract %2[%9] : tensor + %20 = arith.mulf %extracted_9, %extracted_10 : f32 + %21 = affine.apply #map1()[%5] + %22 = arith.cmpi eq, %21, %c0 : index + %23 = arith.mulf %17, %cst_0 : f32 + %24 = arith.select %22, %cst_1, %23 : f32 + %25 = arith.mulf %20, %24 : f32 + %26 = arith.divf %25, %cst : f32 + %inserted_11 = tensor.insert %26 into %arg12[%arg7, %arg10] : tensor + %27 = arith.addf %extracted_5, %26 : f32 + scf.yield %27, %inserted_11 : f32, tensor + } else { + scf.yield %extracted_5, %arg12 : f32, tensor + } + scf.yield %19#0, %19#1 : f32, tensor + } else { + scf.yield %extracted_5, %arg12 : f32, tensor + } + %inserted_6 = tensor.insert %15#0 into %arg11[%arg7] : tensor + affine.yield %inserted_6, %15#1 : tensor, tensor + } + %extracted_3 = tensor.extract %11#0[%arg7] : tensor + %12 = arith.negf %extracted_3 : f32 + %inserted_4 = tensor.insert %12 into %11#1[%arg7, %9] : tensor + affine.yield %11#0, %inserted_4 : tensor, tensor + } + %8 = bufferization.to_memref %7#1 : memref + memref.copy %8, %arg6 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu/orig.mlir new file mode 100644 index 000000000000..fc814a558fad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu/orig.mlir @@ -0,0 +1,51 @@ +#set = affine_set<()[s0] : (s0 - 1 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multi_margin_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: i32, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 2.000000e+00 : f32 + %cst_2 = arith.constant 1.600000e+01 : f32 + %0 = arith.index_cast %arg4 : i32 to index + affine.for %arg7 = 0 to 32 { + %1 = affine.load %arg1[%arg7] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %cst) -> (f32) { + %5 = arith.index_cast %arg8 : index to i32 + affine.store %cst, %arg6[%arg7, %arg8] : memref + %6 = arith.cmpi ne, %5, %1 : i32 + %7 = scf.if %6 -> (f32) { + %8 = memref.load %arg0[%arg7, %2] : memref + %9 = arith.subf %arg3, %8 : f32 + %10 = affine.load %arg0[%arg7, %arg8] : memref + %11 = arith.addf %9, %10 : f32 + %12 = arith.cmpf ogt, %11, %cst : f32 + %13 = scf.if %12 -> (f32) { + %14 = affine.load %arg5[%arg7] : memref + %15 = memref.load %arg2[%2] : memref + %16 = arith.mulf %14, %15 : f32 + %17 = affine.if #set()[%0] -> f32 { + affine.yield %cst_0 : f32 + } else { + %21 = arith.mulf %11, %cst_1 : f32 + affine.yield %21 : f32 + } + %18 = arith.mulf %16, %17 : f32 + %19 = arith.divf %18, %cst_2 : f32 + affine.store %19, %arg6[%arg7, %arg8] : memref + %20 = arith.addf %arg9, %19 : f32 + scf.yield %20 : f32 + } else { + scf.yield %arg9 : f32 + } + scf.yield %13 : f32 + } else { + scf.yield %arg9 : f32 + } + affine.yield %7 : f32 + } + %4 = arith.negf %3 : f32 + memref.store %4, %arg6[%arg7, %2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu/raised.mlir new file mode 100644 index 000000000000..1d23786b7253 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu/raised.mlir @@ -0,0 +1,62 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multi_margin_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: i32, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %c0 = arith.constant 0 : index + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 2.000000e+00 : f32 + %cst_2 = arith.constant 1.600000e+01 : f32 + %0 = arith.index_cast %arg4 : i32 to index + %alloca = memref.alloca(%c32) : memref + affine.for %arg7 = 0 to 32 { + %1 = affine.load %arg1[%arg7] : memref + %2 = arith.index_cast %1 : i32 to index + affine.store %cst, %alloca[%arg7] : memref + %subview = memref.subview %arg6[%arg7, 0] [1, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg8 = 0 to 16 { + %5 = affine.load %alloca[%arg7] : memref + %6 = arith.index_cast %arg8 : index to i32 + %7 = arith.cmpi ne, %6, %1 : i32 + %8 = scf.if %7 -> (f32) { + %9 = memref.load %arg0[%arg7, %2] : memref + %10 = arith.subf %arg3, %9 : f32 + %11 = affine.load %arg0[%arg7, %arg8] : memref + %12 = arith.addf %10, %11 : f32 + %13 = arith.cmpf ogt, %12, %cst : f32 + %14 = scf.if %13 -> (f32) { + %15 = affine.load %arg5[%arg7] : memref + %16 = memref.load %arg2[%2] : memref + %17 = arith.mulf %15, %16 : f32 + %18 = affine.apply #map1()[%0] + %19 = arith.cmpi eq, %18, %c0 : index + %20 = arith.mulf %12, %cst_1 : f32 + %21 = arith.select %19, %cst_0, %20 : f32 + %22 = arith.mulf %17, %21 : f32 + %23 = arith.divf %22, %cst_2 : f32 + affine.store %23, %arg6[%arg7, %arg8] : memref + %24 = arith.addf %5, %23 : f32 + scf.yield %24 : f32 + } else { + scf.yield %5 : f32 + } + scf.yield %14 : f32 + } else { + scf.yield %5 : f32 + } + affine.store %8, %alloca[%arg7] : memref + } + %3 = affine.load %alloca[%arg7] : memref + %4 = arith.negf %3 : f32 + memref.store %4, %arg6[%arg7, %2] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..1ecef2df8349 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu_debuf.mlir @@ -0,0 +1,72 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multi_margin_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: i32, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.600000e+01 : f32 + %cst_0 = arith.constant 2.000000e+00 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = arith.index_cast %arg4 : i32 to index + %6 = tensor.empty(%c32) : tensor + %7:2 = affine.for %arg7 = 0 to 32 iter_args(%arg8 = %6, %arg9 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %3[%arg7] : tensor + %9 = arith.index_cast %extracted : i32 to index + %inserted = tensor.insert %cst_2 into %arg8[%arg7] : tensor + %extracted_slice = tensor.extract_slice %arg9[%arg7, 0] [1, %c16] [1, 1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst_2 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %10 into %arg9[%arg7, 0] [1, %c16] [1, 1] : tensor into tensor + %11:2 = affine.for %arg10 = 0 to 16 iter_args(%arg11 = %inserted, %arg12 = %inserted_slice) -> (tensor, tensor) { + %extracted_5 = tensor.extract %arg11[%arg7] : tensor + %13 = arith.index_cast %arg10 : index to i32 + %14 = arith.cmpi ne, %13, %extracted : i32 + %15:2 = scf.if %14 -> (f32, tensor) { + %extracted_7 = tensor.extract %4[%arg7, %9] : tensor + %16 = arith.subf %arg3, %extracted_7 : f32 + %extracted_8 = tensor.extract %4[%arg7, %arg10] : tensor + %17 = arith.addf %16, %extracted_8 : f32 + %18 = arith.cmpf ogt, %17, %cst_2 : f32 + %19:2 = scf.if %18 -> (f32, tensor) { + %extracted_9 = tensor.extract %1[%arg7] : tensor + %extracted_10 = tensor.extract %2[%9] : tensor + %20 = arith.mulf %extracted_9, %extracted_10 : f32 + %21 = affine.apply #map1()[%5] + %22 = arith.cmpi eq, %21, %c0 : index + %23 = arith.mulf %17, %cst_0 : f32 + %24 = arith.select %22, %cst_1, %23 : f32 + %25 = arith.mulf %20, %24 : f32 + %26 = arith.divf %25, %cst : f32 + %inserted_11 = tensor.insert %26 into %arg12[%arg7, %arg10] : tensor + %27 = arith.addf %extracted_5, %26 : f32 + scf.yield %27, %inserted_11 : f32, tensor + } else { + scf.yield %extracted_5, %arg12 : f32, tensor + } + scf.yield %19#0, %19#1 : f32, tensor + } else { + scf.yield %extracted_5, %arg12 : f32, tensor + } + %inserted_6 = tensor.insert %15#0 into %arg11[%arg7] : tensor + affine.yield %inserted_6, %15#1 : tensor, tensor + } + %extracted_3 = tensor.extract %11#0[%arg7] : tensor + %12 = arith.negf %extracted_3 : f32 + %inserted_4 = tensor.insert %12 into %11#1[%arg7, %9] : tensor + affine.yield %11#0, %inserted_4 : tensor, tensor + } + %8 = bufferization.to_memref %7#1 : memref + memref.copy %8, %arg6 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..1d23786b7253 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multi_margin_loss_backward_cpu_linalg.mlir @@ -0,0 +1,62 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multi_margin_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: i32, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %c0 = arith.constant 0 : index + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 2.000000e+00 : f32 + %cst_2 = arith.constant 1.600000e+01 : f32 + %0 = arith.index_cast %arg4 : i32 to index + %alloca = memref.alloca(%c32) : memref + affine.for %arg7 = 0 to 32 { + %1 = affine.load %arg1[%arg7] : memref + %2 = arith.index_cast %1 : i32 to index + affine.store %cst, %alloca[%arg7] : memref + %subview = memref.subview %arg6[%arg7, 0] [1, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg8 = 0 to 16 { + %5 = affine.load %alloca[%arg7] : memref + %6 = arith.index_cast %arg8 : index to i32 + %7 = arith.cmpi ne, %6, %1 : i32 + %8 = scf.if %7 -> (f32) { + %9 = memref.load %arg0[%arg7, %2] : memref + %10 = arith.subf %arg3, %9 : f32 + %11 = affine.load %arg0[%arg7, %arg8] : memref + %12 = arith.addf %10, %11 : f32 + %13 = arith.cmpf ogt, %12, %cst : f32 + %14 = scf.if %13 -> (f32) { + %15 = affine.load %arg5[%arg7] : memref + %16 = memref.load %arg2[%2] : memref + %17 = arith.mulf %15, %16 : f32 + %18 = affine.apply #map1()[%0] + %19 = arith.cmpi eq, %18, %c0 : index + %20 = arith.mulf %12, %cst_1 : f32 + %21 = arith.select %19, %cst_0, %20 : f32 + %22 = arith.mulf %17, %21 : f32 + %23 = arith.divf %22, %cst_2 : f32 + affine.store %23, %arg6[%arg7, %arg8] : memref + %24 = arith.addf %5, %23 : f32 + scf.yield %24 : f32 + } else { + scf.yield %5 : f32 + } + scf.yield %14 : f32 + } else { + scf.yield %5 : f32 + } + affine.store %8, %alloca[%arg7] : memref + } + %3 = affine.load %alloca[%arg7] : memref + %4 = arith.negf %3 : f32 + memref.store %4, %arg6[%arg7, %2] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu.mlir b/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu.mlir new file mode 100644 index 000000000000..55ae98452846 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu.mlir @@ -0,0 +1,44 @@ +#set = affine_set<()[s0] : (s0 - 1 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multi_margin_loss_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.600000e+01 : f32 + %0 = arith.index_cast %arg4 : i32 to index + affine.for %arg6 = 0 to 32 { + %1 = affine.load %arg1[%arg6] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.for %arg7 = 0 to 16 iter_args(%arg8 = %cst) -> (f32) { + %7 = arith.index_cast %arg7 : index to i32 + %8 = arith.cmpi ne, %7, %1 : i32 + %9 = scf.if %8 -> (f32) { + %10 = memref.load %arg0[%arg6, %2] : memref + %11 = arith.subf %arg3, %10 : f32 + %12 = affine.load %arg0[%arg6, %arg7] : memref + %13 = arith.addf %11, %12 : f32 + %14 = arith.cmpf ogt, %13, %cst : f32 + %15 = scf.if %14 -> (f32) { + %16 = affine.if #set()[%0] -> f32 { + affine.yield %13 : f32 + } else { + %18 = arith.mulf %13, %13 : f32 + affine.yield %18 : f32 + } + %17 = arith.addf %arg8, %16 : f32 + scf.yield %17 : f32 + } else { + scf.yield %arg8 : f32 + } + scf.yield %15 : f32 + } else { + scf.yield %arg8 : f32 + } + affine.yield %9 : f32 + } + %4 = memref.load %arg2[%2] : memref + %5 = arith.mulf %3, %4 : f32 + %6 = arith.divf %5, %cst_0 : f32 + affine.store %6, %arg5[%arg6] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu/debuf.mlir new file mode 100644 index 000000000000..42e180fc8534 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu/debuf.mlir @@ -0,0 +1,61 @@ +#map = affine_map<(d0)[s0] -> (s0)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multi_margin_loss_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.600000e+01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = arith.index_cast %arg4 : i32 to index + %4 = tensor.empty(%c32) : tensor + %5:2 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %4, %arg8 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %2[%arg6] : tensor + %7 = arith.index_cast %extracted : i32 to index + %inserted = tensor.insert %cst_0 into %arg7[%arg6] : tensor + %8 = polygeist.submap(%inserted, %arg6, %c16) {map = #map} : (tensor, index, index) -> tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction"], library_call = ""} outs(%8 : tensor) { + ^bb0(%out: f32): + %13 = linalg.index 0 : index + %14 = arith.index_cast %13 : index to i32 + %15 = arith.cmpi ne, %14, %extracted : i32 + %16 = scf.if %15 -> (f32) { + %17 = memref.load %arg0[%arg6, %7] : memref + %18 = arith.subf %arg3, %17 : f32 + %19 = memref.load %arg0[%arg6, %13] : memref + %20 = arith.addf %18, %19 : f32 + %21 = arith.cmpf ogt, %20, %cst_0 : f32 + %22 = scf.if %21 -> (f32) { + %23 = affine.apply #map2()[%3] + %24 = arith.cmpi eq, %23, %c0 : index + %25 = arith.mulf %20, %20 : f32 + %26 = arith.select %24, %20, %25 : f32 + %27 = arith.addf %out, %26 : f32 + scf.yield %27 : f32 + } else { + scf.yield %out : f32 + } + scf.yield %22 : f32 + } else { + scf.yield %out : f32 + } + linalg.yield %16 : f32 + } -> tensor + %10 = polygeist.submapInverse(%inserted, %9, %arg6, %c16) {map = #map} : (tensor, tensor, index, index) -> tensor + %extracted_1 = tensor.extract %10[%arg6] : tensor + %extracted_2 = tensor.extract %1[%7] : tensor + %11 = arith.mulf %extracted_1, %extracted_2 : f32 + %12 = arith.divf %11, %cst : f32 + %inserted_3 = tensor.insert %12 into %arg8[%arg6] : tensor + affine.yield %10, %inserted_3 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu/matched.mlir new file mode 100644 index 000000000000..42e180fc8534 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu/matched.mlir @@ -0,0 +1,61 @@ +#map = affine_map<(d0)[s0] -> (s0)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multi_margin_loss_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.600000e+01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = arith.index_cast %arg4 : i32 to index + %4 = tensor.empty(%c32) : tensor + %5:2 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %4, %arg8 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %2[%arg6] : tensor + %7 = arith.index_cast %extracted : i32 to index + %inserted = tensor.insert %cst_0 into %arg7[%arg6] : tensor + %8 = polygeist.submap(%inserted, %arg6, %c16) {map = #map} : (tensor, index, index) -> tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction"], library_call = ""} outs(%8 : tensor) { + ^bb0(%out: f32): + %13 = linalg.index 0 : index + %14 = arith.index_cast %13 : index to i32 + %15 = arith.cmpi ne, %14, %extracted : i32 + %16 = scf.if %15 -> (f32) { + %17 = memref.load %arg0[%arg6, %7] : memref + %18 = arith.subf %arg3, %17 : f32 + %19 = memref.load %arg0[%arg6, %13] : memref + %20 = arith.addf %18, %19 : f32 + %21 = arith.cmpf ogt, %20, %cst_0 : f32 + %22 = scf.if %21 -> (f32) { + %23 = affine.apply #map2()[%3] + %24 = arith.cmpi eq, %23, %c0 : index + %25 = arith.mulf %20, %20 : f32 + %26 = arith.select %24, %20, %25 : f32 + %27 = arith.addf %out, %26 : f32 + scf.yield %27 : f32 + } else { + scf.yield %out : f32 + } + scf.yield %22 : f32 + } else { + scf.yield %out : f32 + } + linalg.yield %16 : f32 + } -> tensor + %10 = polygeist.submapInverse(%inserted, %9, %arg6, %c16) {map = #map} : (tensor, tensor, index, index) -> tensor + %extracted_1 = tensor.extract %10[%arg6] : tensor + %extracted_2 = tensor.extract %1[%7] : tensor + %11 = arith.mulf %extracted_1, %extracted_2 : f32 + %12 = arith.divf %11, %cst : f32 + %inserted_3 = tensor.insert %12 into %arg8[%arg6] : tensor + affine.yield %10, %inserted_3 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu/orig.mlir new file mode 100644 index 000000000000..55ae98452846 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu/orig.mlir @@ -0,0 +1,44 @@ +#set = affine_set<()[s0] : (s0 - 1 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multi_margin_loss_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.600000e+01 : f32 + %0 = arith.index_cast %arg4 : i32 to index + affine.for %arg6 = 0 to 32 { + %1 = affine.load %arg1[%arg6] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.for %arg7 = 0 to 16 iter_args(%arg8 = %cst) -> (f32) { + %7 = arith.index_cast %arg7 : index to i32 + %8 = arith.cmpi ne, %7, %1 : i32 + %9 = scf.if %8 -> (f32) { + %10 = memref.load %arg0[%arg6, %2] : memref + %11 = arith.subf %arg3, %10 : f32 + %12 = affine.load %arg0[%arg6, %arg7] : memref + %13 = arith.addf %11, %12 : f32 + %14 = arith.cmpf ogt, %13, %cst : f32 + %15 = scf.if %14 -> (f32) { + %16 = affine.if #set()[%0] -> f32 { + affine.yield %13 : f32 + } else { + %18 = arith.mulf %13, %13 : f32 + affine.yield %18 : f32 + } + %17 = arith.addf %arg8, %16 : f32 + scf.yield %17 : f32 + } else { + scf.yield %arg8 : f32 + } + scf.yield %15 : f32 + } else { + scf.yield %arg8 : f32 + } + affine.yield %9 : f32 + } + %4 = memref.load %arg2[%2] : memref + %5 = arith.mulf %3, %4 : f32 + %6 = arith.divf %5, %cst_0 : f32 + affine.store %6, %arg5[%arg6] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu/raised.mlir new file mode 100644 index 000000000000..81b271fdfdba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu/raised.mlir @@ -0,0 +1,54 @@ +#map = affine_map<(d0)[s0] -> (s0)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multi_margin_loss_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %c0 = arith.constant 0 : index + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.600000e+01 : f32 + %0 = arith.index_cast %arg4 : i32 to index + %alloca = memref.alloca(%c32) : memref + affine.for %arg6 = 0 to 32 { + %1 = affine.load %arg1[%arg6] : memref + %2 = arith.index_cast %1 : i32 to index + affine.store %cst, %alloca[%arg6] : memref + %3 = polygeist.submap(%alloca, %arg6, %c16) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction"]} outs(%3 : memref) { + ^bb0(%out: f32): + %8 = linalg.index 0 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.cmpi ne, %9, %1 : i32 + %11 = scf.if %10 -> (f32) { + %12 = memref.load %arg0[%arg6, %2] : memref + %13 = arith.subf %arg3, %12 : f32 + %14 = memref.load %arg0[%arg6, %8] : memref + %15 = arith.addf %13, %14 : f32 + %16 = arith.cmpf ogt, %15, %cst : f32 + %17 = scf.if %16 -> (f32) { + %18 = affine.apply #map2()[%0] + %19 = arith.cmpi eq, %18, %c0 : index + %20 = arith.mulf %15, %15 : f32 + %21 = arith.select %19, %15, %20 : f32 + %22 = arith.addf %out, %21 : f32 + scf.yield %22 : f32 + } else { + scf.yield %out : f32 + } + scf.yield %17 : f32 + } else { + scf.yield %out : f32 + } + linalg.yield %11 : f32 + } + %4 = affine.load %alloca[%arg6] : memref + %5 = memref.load %arg2[%2] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.divf %6, %cst_0 : f32 + affine.store %7, %arg5[%arg6] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu_debuf.mlir new file mode 100644 index 000000000000..42e180fc8534 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu_debuf.mlir @@ -0,0 +1,61 @@ +#map = affine_map<(d0)[s0] -> (s0)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multi_margin_loss_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.600000e+01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = arith.index_cast %arg4 : i32 to index + %4 = tensor.empty(%c32) : tensor + %5:2 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %4, %arg8 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %2[%arg6] : tensor + %7 = arith.index_cast %extracted : i32 to index + %inserted = tensor.insert %cst_0 into %arg7[%arg6] : tensor + %8 = polygeist.submap(%inserted, %arg6, %c16) {map = #map} : (tensor, index, index) -> tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction"], library_call = ""} outs(%8 : tensor) { + ^bb0(%out: f32): + %13 = linalg.index 0 : index + %14 = arith.index_cast %13 : index to i32 + %15 = arith.cmpi ne, %14, %extracted : i32 + %16 = scf.if %15 -> (f32) { + %17 = memref.load %arg0[%arg6, %7] : memref + %18 = arith.subf %arg3, %17 : f32 + %19 = memref.load %arg0[%arg6, %13] : memref + %20 = arith.addf %18, %19 : f32 + %21 = arith.cmpf ogt, %20, %cst_0 : f32 + %22 = scf.if %21 -> (f32) { + %23 = affine.apply #map2()[%3] + %24 = arith.cmpi eq, %23, %c0 : index + %25 = arith.mulf %20, %20 : f32 + %26 = arith.select %24, %20, %25 : f32 + %27 = arith.addf %out, %26 : f32 + scf.yield %27 : f32 + } else { + scf.yield %out : f32 + } + scf.yield %22 : f32 + } else { + scf.yield %out : f32 + } + linalg.yield %16 : f32 + } -> tensor + %10 = polygeist.submapInverse(%inserted, %9, %arg6, %c16) {map = #map} : (tensor, tensor, index, index) -> tensor + %extracted_1 = tensor.extract %10[%arg6] : tensor + %extracted_2 = tensor.extract %1[%7] : tensor + %11 = arith.mulf %extracted_1, %extracted_2 : f32 + %12 = arith.divf %11, %cst : f32 + %inserted_3 = tensor.insert %12 into %arg8[%arg6] : tensor + affine.yield %10, %inserted_3 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu_linalg.mlir new file mode 100644 index 000000000000..81b271fdfdba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multi_margin_loss_cpu_linalg.mlir @@ -0,0 +1,54 @@ +#map = affine_map<(d0)[s0] -> (s0)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multi_margin_loss_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %c0 = arith.constant 0 : index + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.600000e+01 : f32 + %0 = arith.index_cast %arg4 : i32 to index + %alloca = memref.alloca(%c32) : memref + affine.for %arg6 = 0 to 32 { + %1 = affine.load %arg1[%arg6] : memref + %2 = arith.index_cast %1 : i32 to index + affine.store %cst, %alloca[%arg6] : memref + %3 = polygeist.submap(%alloca, %arg6, %c16) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction"]} outs(%3 : memref) { + ^bb0(%out: f32): + %8 = linalg.index 0 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.cmpi ne, %9, %1 : i32 + %11 = scf.if %10 -> (f32) { + %12 = memref.load %arg0[%arg6, %2] : memref + %13 = arith.subf %arg3, %12 : f32 + %14 = memref.load %arg0[%arg6, %8] : memref + %15 = arith.addf %13, %14 : f32 + %16 = arith.cmpf ogt, %15, %cst : f32 + %17 = scf.if %16 -> (f32) { + %18 = affine.apply #map2()[%0] + %19 = arith.cmpi eq, %18, %c0 : index + %20 = arith.mulf %15, %15 : f32 + %21 = arith.select %19, %15, %20 : f32 + %22 = arith.addf %out, %21 : f32 + scf.yield %22 : f32 + } else { + scf.yield %out : f32 + } + scf.yield %17 : f32 + } else { + scf.yield %out : f32 + } + linalg.yield %11 : f32 + } + %4 = affine.load %alloca[%arg6] : memref + %5 = memref.load %arg2[%2] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.divf %6, %cst_0 : f32 + affine.store %7, %arg5[%arg6] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu.mlir new file mode 100644 index 000000000000..364c0a48ce2f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu.mlir @@ -0,0 +1,56 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multilabel_margin_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.600000e+01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = llvm.mlir.undef : f32 + %1 = affine.for %arg4 = 0 to 16 iter_args(%arg5 = %0) -> (f32) { + affine.for %arg6 = 0 to 16 { + affine.store %cst_1, %arg3[%arg4, %arg6] : memref + } + %2 = affine.for %arg6 = 0 to 4 iter_args(%arg7 = %arg5) -> (f32) { + %3 = affine.load %arg1[%arg4, %arg6] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %arg7) -> (f32) { + %6 = arith.index_cast %arg8 : index to i32 + %7 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %c0_i32) -> (i32) { + %10 = affine.load %arg1[%arg4, %arg10] : memref + %11 = arith.cmpi eq, %10, %6 : i32 + %12 = arith.extui %11 : i1 to i32 + %13 = arith.ori %arg11, %12 : i32 + affine.yield %13 : i32 + } + %8 = arith.cmpi ne, %7, %c0_i32 : i32 + %9 = scf.if %8 -> (f32) { + scf.yield %arg9 : f32 + } else { + %10 = memref.load %arg0[%arg4, %4] : memref + %11 = arith.subf %cst_0, %10 : f32 + %12 = affine.load %arg0[%arg4, %arg8] : memref + %13 = arith.addf %11, %12 : f32 + %14 = arith.cmpf ogt, %13, %cst_1 : f32 + %15 = scf.if %14 -> (f32) { + %16 = affine.load %arg2[%arg4] : memref + %17 = arith.divf %16, %cst : f32 + %18 = affine.load %arg3[%arg4, %arg8] : memref + %19 = arith.addf %18, %17 : f32 + affine.store %19, %arg3[%arg4, %arg8] : memref + %20 = memref.load %arg3[%arg4, %4] : memref + %21 = arith.subf %20, %17 : f32 + memref.store %21, %arg3[%arg4, %4] : memref + scf.yield %17 : f32 + } else { + scf.yield %arg9 : f32 + } + scf.yield %15 : f32 + } + affine.yield %9 : f32 + } + affine.yield %5 : f32 + } + affine.yield %2 : f32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..9ac3363f8e78 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu/debuf.mlir @@ -0,0 +1,88 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multilabel_margin_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 1.600000e+01 : f32 + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = llvm.mlir.undef : f32 + %5 = tensor.empty() : tensor + %inserted = tensor.insert %4 into %5[] : tensor + %6:2 = affine.for %arg4 = 0 to 16 iter_args(%arg5 = %inserted, %arg6 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg5[] : tensor + %extracted_slice = tensor.extract_slice %arg6[%arg4, 0] [1, %c16] [1, 1] : tensor to tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %8 into %arg6[%arg4, 0] [1, %c16] [1, 1] : tensor into tensor + %inserted_2 = tensor.insert %extracted into %arg5[] : tensor + %9:2 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %inserted_2, %arg9 = %inserted_slice) -> (tensor, tensor) { + %extracted_3 = tensor.extract %2[%arg4, %arg7] : tensor + %10 = arith.index_cast %extracted_3 : i32 to index + %alloca = memref.alloca(%c16) : memref + %11 = bufferization.to_tensor %alloca : memref + %12 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%11 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice_4 = tensor.extract_slice %12[0] [%c16] [1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %2[%arg4, 0] [1, %c4] [1, 1] : tensor to tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_5 : tensor) outs(%extracted_slice_4 : tensor) { + ^bb0(%in: i32, %out: i32): + %15 = linalg.index 0 : index + %16 = arith.index_cast %15 : index to i32 + %17 = arith.cmpi eq, %in, %16 : i32 + %18 = arith.extui %17 : i1 to i32 + %19 = arith.ori %out, %18 : i32 + linalg.yield %19 : i32 + } -> tensor + %inserted_slice_6 = tensor.insert_slice %13 into %12[0] [%c16] [1] : tensor into tensor + %14:2 = affine.for %arg10 = 0 to 16 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (tensor, tensor) { + %extracted_7 = tensor.extract %arg11[] : tensor + %extracted_8 = tensor.extract %inserted_slice_6[%arg10] : tensor + %15 = arith.cmpi ne, %extracted_8, %c0_i32 : i32 + %16:2 = scf.if %15 -> (f32, tensor) { + scf.yield %extracted_7, %arg12 : f32, tensor + } else { + %extracted_10 = tensor.extract %3[%arg4, %10] : tensor + %17 = arith.subf %cst_0, %extracted_10 : f32 + %extracted_11 = tensor.extract %3[%arg4, %arg10] : tensor + %18 = arith.addf %17, %extracted_11 : f32 + %19 = arith.cmpf ogt, %18, %cst : f32 + %20:2 = scf.if %19 -> (f32, tensor) { + %extracted_12 = tensor.extract %1[%arg4] : tensor + %21 = arith.divf %extracted_12, %cst_1 : f32 + %extracted_13 = tensor.extract %arg12[%arg4, %arg10] : tensor + %22 = arith.addf %extracted_13, %21 : f32 + %inserted_14 = tensor.insert %22 into %arg12[%arg4, %arg10] : tensor + %extracted_15 = tensor.extract %inserted_14[%arg4, %10] : tensor + %23 = arith.subf %extracted_15, %21 : f32 + %inserted_16 = tensor.insert %23 into %inserted_14[%arg4, %10] : tensor + scf.yield %21, %inserted_16 : f32, tensor + } else { + scf.yield %extracted_7, %arg12 : f32, tensor + } + scf.yield %20#0, %20#1 : f32, tensor + } + %inserted_9 = tensor.insert %16#0 into %arg11[] : tensor + affine.yield %inserted_9, %16#1 : tensor, tensor + } + affine.yield %14#0, %14#1 : tensor, tensor + } + affine.yield %9#0, %9#1 : tensor, tensor + } + %7 = bufferization.to_memref %6#1 : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu/matched.mlir new file mode 100644 index 000000000000..c7e9d91d579f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu/matched.mlir @@ -0,0 +1,82 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multilabel_margin_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 1.600000e+01 : f32 + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = llvm.mlir.undef : f32 + %5 = tensor.empty() : tensor + %inserted = tensor.insert %4 into %5[] : tensor + %6:2 = affine.for %arg4 = 0 to 16 iter_args(%arg5 = %inserted, %arg6 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg5[] : tensor + %extracted_slice = tensor.extract_slice %arg6[%arg4, 0] [1, %c16] [1, 1] : tensor to tensor + %8 = kernel.launch @memset_zero_1D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %8 into %arg6[%arg4, 0] [1, %c16] [1, 1] : tensor into tensor + %inserted_2 = tensor.insert %extracted into %arg5[] : tensor + %9:2 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %inserted_2, %arg9 = %inserted_slice) -> (tensor, tensor) { + %extracted_3 = tensor.extract %2[%arg4, %arg7] : tensor + %10 = arith.index_cast %extracted_3 : i32 to index + %alloca = memref.alloca(%c16) : memref + %11 = bufferization.to_tensor %alloca : memref + %12 = kernel.launch @memset_zero_1D(%11) : (tensor) -> tensor + %extracted_slice_4 = tensor.extract_slice %12[0] [%c16] [1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %2[%arg4, 0] [1, %c4] [1, 1] : tensor to tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_5 : tensor) outs(%extracted_slice_4 : tensor) { + ^bb0(%in: i32, %out: i32): + %15 = linalg.index 0 : index + %16 = arith.index_cast %15 : index to i32 + %17 = arith.cmpi eq, %in, %16 : i32 + %18 = arith.extui %17 : i1 to i32 + %19 = arith.ori %out, %18 : i32 + linalg.yield %19 : i32 + } -> tensor + %inserted_slice_6 = tensor.insert_slice %13 into %12[0] [%c16] [1] : tensor into tensor + %14:2 = affine.for %arg10 = 0 to 16 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (tensor, tensor) { + %extracted_7 = tensor.extract %arg11[] : tensor + %extracted_8 = tensor.extract %inserted_slice_6[%arg10] : tensor + %15 = arith.cmpi ne, %extracted_8, %c0_i32 : i32 + %16:2 = scf.if %15 -> (f32, tensor) { + scf.yield %extracted_7, %arg12 : f32, tensor + } else { + %extracted_10 = tensor.extract %3[%arg4, %10] : tensor + %17 = arith.subf %cst_0, %extracted_10 : f32 + %extracted_11 = tensor.extract %3[%arg4, %arg10] : tensor + %18 = arith.addf %17, %extracted_11 : f32 + %19 = arith.cmpf ogt, %18, %cst : f32 + %20:2 = scf.if %19 -> (f32, tensor) { + %extracted_12 = tensor.extract %1[%arg4] : tensor + %21 = arith.divf %extracted_12, %cst_1 : f32 + %extracted_13 = tensor.extract %arg12[%arg4, %arg10] : tensor + %22 = arith.addf %extracted_13, %21 : f32 + %inserted_14 = tensor.insert %22 into %arg12[%arg4, %arg10] : tensor + %extracted_15 = tensor.extract %inserted_14[%arg4, %10] : tensor + %23 = arith.subf %extracted_15, %21 : f32 + %inserted_16 = tensor.insert %23 into %inserted_14[%arg4, %10] : tensor + scf.yield %21, %inserted_16 : f32, tensor + } else { + scf.yield %extracted_7, %arg12 : f32, tensor + } + scf.yield %20#0, %20#1 : f32, tensor + } + %inserted_9 = tensor.insert %16#0 into %arg11[] : tensor + affine.yield %inserted_9, %16#1 : tensor, tensor + } + affine.yield %14#0, %14#1 : tensor, tensor + } + affine.yield %9#0, %9#1 : tensor, tensor + } + %7 = bufferization.to_memref %6#1 : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu/orig.mlir new file mode 100644 index 000000000000..364c0a48ce2f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu/orig.mlir @@ -0,0 +1,56 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multilabel_margin_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.600000e+01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = llvm.mlir.undef : f32 + %1 = affine.for %arg4 = 0 to 16 iter_args(%arg5 = %0) -> (f32) { + affine.for %arg6 = 0 to 16 { + affine.store %cst_1, %arg3[%arg4, %arg6] : memref + } + %2 = affine.for %arg6 = 0 to 4 iter_args(%arg7 = %arg5) -> (f32) { + %3 = affine.load %arg1[%arg4, %arg6] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %arg7) -> (f32) { + %6 = arith.index_cast %arg8 : index to i32 + %7 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %c0_i32) -> (i32) { + %10 = affine.load %arg1[%arg4, %arg10] : memref + %11 = arith.cmpi eq, %10, %6 : i32 + %12 = arith.extui %11 : i1 to i32 + %13 = arith.ori %arg11, %12 : i32 + affine.yield %13 : i32 + } + %8 = arith.cmpi ne, %7, %c0_i32 : i32 + %9 = scf.if %8 -> (f32) { + scf.yield %arg9 : f32 + } else { + %10 = memref.load %arg0[%arg4, %4] : memref + %11 = arith.subf %cst_0, %10 : f32 + %12 = affine.load %arg0[%arg4, %arg8] : memref + %13 = arith.addf %11, %12 : f32 + %14 = arith.cmpf ogt, %13, %cst_1 : f32 + %15 = scf.if %14 -> (f32) { + %16 = affine.load %arg2[%arg4] : memref + %17 = arith.divf %16, %cst : f32 + %18 = affine.load %arg3[%arg4, %arg8] : memref + %19 = arith.addf %18, %17 : f32 + affine.store %19, %arg3[%arg4, %arg8] : memref + %20 = memref.load %arg3[%arg4, %4] : memref + %21 = arith.subf %20, %17 : f32 + memref.store %21, %arg3[%arg4, %4] : memref + scf.yield %17 : f32 + } else { + scf.yield %arg9 : f32 + } + scf.yield %15 : f32 + } + affine.yield %9 : f32 + } + affine.yield %5 : f32 + } + affine.yield %2 : f32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu/raised.mlir new file mode 100644 index 000000000000..9d156ea02fea --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu/raised.mlir @@ -0,0 +1,76 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multilabel_margin_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 1.600000e+01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = llvm.mlir.undef : f32 + %alloca = memref.alloca() : memref + affine.store %0, %alloca[] : memref + affine.for %arg4 = 0 to 16 { + %1 = affine.load %alloca[] : memref + %subview = memref.subview %arg3[%arg4, 0] [1, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_1 : f32 + } + affine.store %1, %alloca[] : memref + affine.for %arg5 = 0 to 4 { + %2 = affine.load %arg1[%arg4, %arg5] : memref + %3 = arith.index_cast %2 : i32 to index + %alloca_2 = memref.alloca(%c16) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_2 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview_3 = memref.subview %arg1[%arg4, 0] [1, %c4] [1, 1] : memref to memref> + %subview_4 = memref.subview %alloca_2[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview_3 : memref>) outs(%subview_4 : memref>) { + ^bb0(%in: i32, %out: i32): + %4 = linalg.index 0 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.cmpi eq, %in, %5 : i32 + %7 = arith.extui %6 : i1 to i32 + %8 = arith.ori %out, %7 : i32 + linalg.yield %8 : i32 + } + affine.for %arg6 = 0 to 16 { + %4 = affine.load %alloca[] : memref + %5 = affine.load %alloca_2[%arg6] : memref + %6 = arith.cmpi ne, %5, %c0_i32 : i32 + %7 = scf.if %6 -> (f32) { + scf.yield %4 : f32 + } else { + %8 = memref.load %arg0[%arg4, %3] : memref + %9 = arith.subf %cst_0, %8 : f32 + %10 = affine.load %arg0[%arg4, %arg6] : memref + %11 = arith.addf %9, %10 : f32 + %12 = arith.cmpf ogt, %11, %cst_1 : f32 + %13 = scf.if %12 -> (f32) { + %14 = affine.load %arg2[%arg4] : memref + %15 = arith.divf %14, %cst : f32 + %16 = affine.load %arg3[%arg4, %arg6] : memref + %17 = arith.addf %16, %15 : f32 + affine.store %17, %arg3[%arg4, %arg6] : memref + %18 = memref.load %arg3[%arg4, %3] : memref + %19 = arith.subf %18, %15 : f32 + memref.store %19, %arg3[%arg4, %3] : memref + scf.yield %15 : f32 + } else { + scf.yield %4 : f32 + } + scf.yield %13 : f32 + } + affine.store %7, %alloca[] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..9ac3363f8e78 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu_debuf.mlir @@ -0,0 +1,88 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multilabel_margin_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 1.600000e+01 : f32 + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = llvm.mlir.undef : f32 + %5 = tensor.empty() : tensor + %inserted = tensor.insert %4 into %5[] : tensor + %6:2 = affine.for %arg4 = 0 to 16 iter_args(%arg5 = %inserted, %arg6 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg5[] : tensor + %extracted_slice = tensor.extract_slice %arg6[%arg4, 0] [1, %c16] [1, 1] : tensor to tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %8 into %arg6[%arg4, 0] [1, %c16] [1, 1] : tensor into tensor + %inserted_2 = tensor.insert %extracted into %arg5[] : tensor + %9:2 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %inserted_2, %arg9 = %inserted_slice) -> (tensor, tensor) { + %extracted_3 = tensor.extract %2[%arg4, %arg7] : tensor + %10 = arith.index_cast %extracted_3 : i32 to index + %alloca = memref.alloca(%c16) : memref + %11 = bufferization.to_tensor %alloca : memref + %12 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%11 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice_4 = tensor.extract_slice %12[0] [%c16] [1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %2[%arg4, 0] [1, %c4] [1, 1] : tensor to tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice_5 : tensor) outs(%extracted_slice_4 : tensor) { + ^bb0(%in: i32, %out: i32): + %15 = linalg.index 0 : index + %16 = arith.index_cast %15 : index to i32 + %17 = arith.cmpi eq, %in, %16 : i32 + %18 = arith.extui %17 : i1 to i32 + %19 = arith.ori %out, %18 : i32 + linalg.yield %19 : i32 + } -> tensor + %inserted_slice_6 = tensor.insert_slice %13 into %12[0] [%c16] [1] : tensor into tensor + %14:2 = affine.for %arg10 = 0 to 16 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (tensor, tensor) { + %extracted_7 = tensor.extract %arg11[] : tensor + %extracted_8 = tensor.extract %inserted_slice_6[%arg10] : tensor + %15 = arith.cmpi ne, %extracted_8, %c0_i32 : i32 + %16:2 = scf.if %15 -> (f32, tensor) { + scf.yield %extracted_7, %arg12 : f32, tensor + } else { + %extracted_10 = tensor.extract %3[%arg4, %10] : tensor + %17 = arith.subf %cst_0, %extracted_10 : f32 + %extracted_11 = tensor.extract %3[%arg4, %arg10] : tensor + %18 = arith.addf %17, %extracted_11 : f32 + %19 = arith.cmpf ogt, %18, %cst : f32 + %20:2 = scf.if %19 -> (f32, tensor) { + %extracted_12 = tensor.extract %1[%arg4] : tensor + %21 = arith.divf %extracted_12, %cst_1 : f32 + %extracted_13 = tensor.extract %arg12[%arg4, %arg10] : tensor + %22 = arith.addf %extracted_13, %21 : f32 + %inserted_14 = tensor.insert %22 into %arg12[%arg4, %arg10] : tensor + %extracted_15 = tensor.extract %inserted_14[%arg4, %10] : tensor + %23 = arith.subf %extracted_15, %21 : f32 + %inserted_16 = tensor.insert %23 into %inserted_14[%arg4, %10] : tensor + scf.yield %21, %inserted_16 : f32, tensor + } else { + scf.yield %extracted_7, %arg12 : f32, tensor + } + scf.yield %20#0, %20#1 : f32, tensor + } + %inserted_9 = tensor.insert %16#0 into %arg11[] : tensor + affine.yield %inserted_9, %16#1 : tensor, tensor + } + affine.yield %14#0, %14#1 : tensor, tensor + } + affine.yield %9#0, %9#1 : tensor, tensor + } + %7 = bufferization.to_memref %6#1 : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..9d156ea02fea --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_backward_cpu_linalg.mlir @@ -0,0 +1,76 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multilabel_margin_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 1.600000e+01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = llvm.mlir.undef : f32 + %alloca = memref.alloca() : memref + affine.store %0, %alloca[] : memref + affine.for %arg4 = 0 to 16 { + %1 = affine.load %alloca[] : memref + %subview = memref.subview %arg3[%arg4, 0] [1, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst_1 : f32 + } + affine.store %1, %alloca[] : memref + affine.for %arg5 = 0 to 4 { + %2 = affine.load %arg1[%arg4, %arg5] : memref + %3 = arith.index_cast %2 : i32 to index + %alloca_2 = memref.alloca(%c16) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca_2 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview_3 = memref.subview %arg1[%arg4, 0] [1, %c4] [1, 1] : memref to memref> + %subview_4 = memref.subview %alloca_2[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview_3 : memref>) outs(%subview_4 : memref>) { + ^bb0(%in: i32, %out: i32): + %4 = linalg.index 0 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.cmpi eq, %in, %5 : i32 + %7 = arith.extui %6 : i1 to i32 + %8 = arith.ori %out, %7 : i32 + linalg.yield %8 : i32 + } + affine.for %arg6 = 0 to 16 { + %4 = affine.load %alloca[] : memref + %5 = affine.load %alloca_2[%arg6] : memref + %6 = arith.cmpi ne, %5, %c0_i32 : i32 + %7 = scf.if %6 -> (f32) { + scf.yield %4 : f32 + } else { + %8 = memref.load %arg0[%arg4, %3] : memref + %9 = arith.subf %cst_0, %8 : f32 + %10 = affine.load %arg0[%arg4, %arg6] : memref + %11 = arith.addf %9, %10 : f32 + %12 = arith.cmpf ogt, %11, %cst_1 : f32 + %13 = scf.if %12 -> (f32) { + %14 = affine.load %arg2[%arg4] : memref + %15 = arith.divf %14, %cst : f32 + %16 = affine.load %arg3[%arg4, %arg6] : memref + %17 = arith.addf %16, %15 : f32 + affine.store %17, %arg3[%arg4, %arg6] : memref + %18 = memref.load %arg3[%arg4, %3] : memref + %19 = arith.subf %18, %15 : f32 + memref.store %19, %arg3[%arg4, %3] : memref + scf.yield %15 : f32 + } else { + scf.yield %4 : f32 + } + scf.yield %13 : f32 + } + affine.store %7, %alloca[] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu.mlir b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu.mlir new file mode 100644 index 000000000000..cb85cdb53047 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu.mlir @@ -0,0 +1,48 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multilabel_margin_loss_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.600000e+01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = llvm.mlir.undef : f32 + %1 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %0) -> (f32) { + %2:2 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %arg4, %arg7 = %cst_1) -> (f32, f32) { + %4 = affine.load %arg1[%arg3, %arg5] : memref + %5 = arith.index_cast %4 : i32 to index + %6:2 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %arg6, %arg10 = %arg7) -> (f32, f32) { + %7 = arith.index_cast %arg8 : index to i32 + %8 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %c0_i32) -> (i32) { + %11 = affine.load %arg1[%arg3, %arg11] : memref + %12 = arith.cmpi eq, %11, %7 : i32 + %13 = arith.extui %12 : i1 to i32 + %14 = arith.ori %arg12, %13 : i32 + affine.yield %14 : i32 + } + %9 = arith.cmpi eq, %8, %c0_i32 : i32 + %10:2 = scf.if %9 -> (f32, f32) { + %11 = memref.load %arg0[%arg3, %5] : memref + %12 = arith.subf %cst_0, %11 : f32 + %13 = affine.load %arg0[%arg3, %arg8] : memref + %14 = arith.addf %12, %13 : f32 + %15 = arith.cmpf ogt, %14, %cst_1 : f32 + %16 = scf.if %15 -> (f32) { + %17 = arith.addf %arg10, %14 : f32 + scf.yield %17 : f32 + } else { + scf.yield %arg10 : f32 + } + scf.yield %14, %16 : f32, f32 + } else { + scf.yield %arg9, %arg10 : f32, f32 + } + affine.yield %10#0, %10#1 : f32, f32 + } + affine.yield %6#0, %6#1 : f32, f32 + } + %3 = arith.divf %2#1, %cst : f32 + affine.store %3, %arg2[%arg3] : memref + affine.yield %2#0 : f32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu/debuf.mlir new file mode 100644 index 000000000000..032cb149de23 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu/debuf.mlir @@ -0,0 +1,84 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multilabel_margin_loss_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 1.600000e+01 : f32 + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = llvm.mlir.undef : f32 + %4 = tensor.empty() : tensor + %inserted = tensor.insert %3 into %4[] : tensor + %5 = tensor.empty(%c16) : tensor + %6 = tensor.empty(%c16) : tensor + %7:4 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %inserted, %arg5 = %5, %arg6 = %6, %arg7 = %0) -> (tensor, tensor, tensor, tensor) { + %extracted = tensor.extract %arg4[] : tensor + %inserted_2 = tensor.insert %extracted into %arg5[%arg3] : tensor + %inserted_3 = tensor.insert %cst into %arg6[%arg3] : tensor + %alloca = memref.alloca(%c4) : memref + %9 = bufferization.to_tensor %alloca : memref + %alloca_4 = memref.alloca(%c4) : memref + %10 = bufferization.to_tensor %alloca_4 : memref + %11:4 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %inserted_2, %arg10 = %inserted_3, %arg11 = %9, %arg12 = %10) -> (tensor, tensor, tensor, tensor) { + %extracted_9 = tensor.extract %arg9[%arg3] : tensor + %extracted_10 = tensor.extract %arg10[%arg3] : tensor + %extracted_11 = tensor.extract %1[%arg3, %arg8] : tensor + %13 = arith.index_cast %extracted_11 : i32 to index + %inserted_12 = tensor.insert %extracted_9 into %arg11[%arg8] : tensor + %inserted_13 = tensor.insert %extracted_10 into %arg12[%arg8] : tensor + %alloca_14 = memref.alloca(%c16) : memref + %14 = bufferization.to_tensor %alloca_14 : memref + %15:3 = affine.for %arg13 = 0 to 16 iter_args(%arg14 = %inserted_12, %arg15 = %inserted_13, %arg16 = %14) -> (tensor, tensor, tensor) { + %extracted_19 = tensor.extract %arg14[%arg8] : tensor + %extracted_20 = tensor.extract %arg15[%arg8] : tensor + %16 = arith.index_cast %arg13 : index to i32 + %inserted_21 = tensor.insert %c0_i32 into %arg16[%arg13] : tensor + %extracted_slice = tensor.extract_slice %inserted_21[%arg13] [1] [1] : tensor to tensor + %extracted_slice_22 = tensor.extract_slice %1[%arg3, 0] [1, %c4] [1, 1] : tensor to tensor + %17 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_22 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: i32, %out: i32): + %26 = arith.cmpi eq, %in, %16 : i32 + %27 = arith.extui %26 : i1 to i32 + %28 = arith.ori %out, %27 : i32 + linalg.yield %28 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %17 into %inserted_21[%arg13] [1] [1] : tensor into tensor + %extracted_23 = tensor.extract %inserted_slice[%arg13] : tensor + %18 = arith.cmpi eq, %extracted_23, %c0_i32 : i32 + %extracted_24 = tensor.extract %2[%arg3, %13] : tensor + %19 = arith.subf %cst_0, %extracted_24 : f32 + %extracted_25 = tensor.extract %2[%arg3, %arg13] : tensor + %20 = arith.addf %19, %extracted_25 : f32 + %21 = arith.cmpf ogt, %20, %cst : f32 + %22 = arith.addf %extracted_20, %20 : f32 + %23 = arith.select %21, %22, %extracted_20 : f32 + %24 = arith.select %18, %20, %extracted_19 : f32 + %25 = arith.select %18, %23, %extracted_20 : f32 + %inserted_26 = tensor.insert %24 into %arg14[%arg8] : tensor + %inserted_27 = tensor.insert %25 into %arg15[%arg8] : tensor + affine.yield %inserted_26, %inserted_27, %inserted_slice : tensor, tensor, tensor + } + %extracted_15 = tensor.extract %15#0[%arg8] : tensor + %extracted_16 = tensor.extract %15#1[%arg8] : tensor + %inserted_17 = tensor.insert %extracted_15 into %arg9[%arg3] : tensor + %inserted_18 = tensor.insert %extracted_16 into %arg10[%arg3] : tensor + affine.yield %inserted_17, %inserted_18, %15#0, %15#1 : tensor, tensor, tensor, tensor + } + %extracted_5 = tensor.extract %11#0[%arg3] : tensor + %extracted_6 = tensor.extract %11#1[%arg3] : tensor + %12 = arith.divf %extracted_6, %cst_1 : f32 + %inserted_7 = tensor.insert %12 into %arg7[%arg3] : tensor + %inserted_8 = tensor.insert %extracted_5 into %arg4[] : tensor + affine.yield %inserted_8, %11#0, %11#1, %inserted_7 : tensor, tensor, tensor, tensor + } + %8 = bufferization.to_memref %7#3 : memref + memref.copy %8, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu/matched.mlir new file mode 100644 index 000000000000..032cb149de23 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu/matched.mlir @@ -0,0 +1,84 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multilabel_margin_loss_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 1.600000e+01 : f32 + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = llvm.mlir.undef : f32 + %4 = tensor.empty() : tensor + %inserted = tensor.insert %3 into %4[] : tensor + %5 = tensor.empty(%c16) : tensor + %6 = tensor.empty(%c16) : tensor + %7:4 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %inserted, %arg5 = %5, %arg6 = %6, %arg7 = %0) -> (tensor, tensor, tensor, tensor) { + %extracted = tensor.extract %arg4[] : tensor + %inserted_2 = tensor.insert %extracted into %arg5[%arg3] : tensor + %inserted_3 = tensor.insert %cst into %arg6[%arg3] : tensor + %alloca = memref.alloca(%c4) : memref + %9 = bufferization.to_tensor %alloca : memref + %alloca_4 = memref.alloca(%c4) : memref + %10 = bufferization.to_tensor %alloca_4 : memref + %11:4 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %inserted_2, %arg10 = %inserted_3, %arg11 = %9, %arg12 = %10) -> (tensor, tensor, tensor, tensor) { + %extracted_9 = tensor.extract %arg9[%arg3] : tensor + %extracted_10 = tensor.extract %arg10[%arg3] : tensor + %extracted_11 = tensor.extract %1[%arg3, %arg8] : tensor + %13 = arith.index_cast %extracted_11 : i32 to index + %inserted_12 = tensor.insert %extracted_9 into %arg11[%arg8] : tensor + %inserted_13 = tensor.insert %extracted_10 into %arg12[%arg8] : tensor + %alloca_14 = memref.alloca(%c16) : memref + %14 = bufferization.to_tensor %alloca_14 : memref + %15:3 = affine.for %arg13 = 0 to 16 iter_args(%arg14 = %inserted_12, %arg15 = %inserted_13, %arg16 = %14) -> (tensor, tensor, tensor) { + %extracted_19 = tensor.extract %arg14[%arg8] : tensor + %extracted_20 = tensor.extract %arg15[%arg8] : tensor + %16 = arith.index_cast %arg13 : index to i32 + %inserted_21 = tensor.insert %c0_i32 into %arg16[%arg13] : tensor + %extracted_slice = tensor.extract_slice %inserted_21[%arg13] [1] [1] : tensor to tensor + %extracted_slice_22 = tensor.extract_slice %1[%arg3, 0] [1, %c4] [1, 1] : tensor to tensor + %17 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_22 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: i32, %out: i32): + %26 = arith.cmpi eq, %in, %16 : i32 + %27 = arith.extui %26 : i1 to i32 + %28 = arith.ori %out, %27 : i32 + linalg.yield %28 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %17 into %inserted_21[%arg13] [1] [1] : tensor into tensor + %extracted_23 = tensor.extract %inserted_slice[%arg13] : tensor + %18 = arith.cmpi eq, %extracted_23, %c0_i32 : i32 + %extracted_24 = tensor.extract %2[%arg3, %13] : tensor + %19 = arith.subf %cst_0, %extracted_24 : f32 + %extracted_25 = tensor.extract %2[%arg3, %arg13] : tensor + %20 = arith.addf %19, %extracted_25 : f32 + %21 = arith.cmpf ogt, %20, %cst : f32 + %22 = arith.addf %extracted_20, %20 : f32 + %23 = arith.select %21, %22, %extracted_20 : f32 + %24 = arith.select %18, %20, %extracted_19 : f32 + %25 = arith.select %18, %23, %extracted_20 : f32 + %inserted_26 = tensor.insert %24 into %arg14[%arg8] : tensor + %inserted_27 = tensor.insert %25 into %arg15[%arg8] : tensor + affine.yield %inserted_26, %inserted_27, %inserted_slice : tensor, tensor, tensor + } + %extracted_15 = tensor.extract %15#0[%arg8] : tensor + %extracted_16 = tensor.extract %15#1[%arg8] : tensor + %inserted_17 = tensor.insert %extracted_15 into %arg9[%arg3] : tensor + %inserted_18 = tensor.insert %extracted_16 into %arg10[%arg3] : tensor + affine.yield %inserted_17, %inserted_18, %15#0, %15#1 : tensor, tensor, tensor, tensor + } + %extracted_5 = tensor.extract %11#0[%arg3] : tensor + %extracted_6 = tensor.extract %11#1[%arg3] : tensor + %12 = arith.divf %extracted_6, %cst_1 : f32 + %inserted_7 = tensor.insert %12 into %arg7[%arg3] : tensor + %inserted_8 = tensor.insert %extracted_5 into %arg4[] : tensor + affine.yield %inserted_8, %11#0, %11#1, %inserted_7 : tensor, tensor, tensor, tensor + } + %8 = bufferization.to_memref %7#3 : memref + memref.copy %8, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu/orig.mlir new file mode 100644 index 000000000000..cb85cdb53047 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu/orig.mlir @@ -0,0 +1,48 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multilabel_margin_loss_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.600000e+01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = llvm.mlir.undef : f32 + %1 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %0) -> (f32) { + %2:2 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %arg4, %arg7 = %cst_1) -> (f32, f32) { + %4 = affine.load %arg1[%arg3, %arg5] : memref + %5 = arith.index_cast %4 : i32 to index + %6:2 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %arg6, %arg10 = %arg7) -> (f32, f32) { + %7 = arith.index_cast %arg8 : index to i32 + %8 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %c0_i32) -> (i32) { + %11 = affine.load %arg1[%arg3, %arg11] : memref + %12 = arith.cmpi eq, %11, %7 : i32 + %13 = arith.extui %12 : i1 to i32 + %14 = arith.ori %arg12, %13 : i32 + affine.yield %14 : i32 + } + %9 = arith.cmpi eq, %8, %c0_i32 : i32 + %10:2 = scf.if %9 -> (f32, f32) { + %11 = memref.load %arg0[%arg3, %5] : memref + %12 = arith.subf %cst_0, %11 : f32 + %13 = affine.load %arg0[%arg3, %arg8] : memref + %14 = arith.addf %12, %13 : f32 + %15 = arith.cmpf ogt, %14, %cst_1 : f32 + %16 = scf.if %15 -> (f32) { + %17 = arith.addf %arg10, %14 : f32 + scf.yield %17 : f32 + } else { + scf.yield %arg10 : f32 + } + scf.yield %14, %16 : f32, f32 + } else { + scf.yield %arg9, %arg10 : f32, f32 + } + affine.yield %10#0, %10#1 : f32, f32 + } + affine.yield %6#0, %6#1 : f32, f32 + } + %3 = arith.divf %2#1, %cst : f32 + affine.store %3, %arg2[%arg3] : memref + affine.yield %2#0 : f32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu/raised.mlir new file mode 100644 index 000000000000..37deebfb2104 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu/raised.mlir @@ -0,0 +1,72 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multilabel_margin_loss_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 1.600000e+01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = llvm.mlir.undef : f32 + %alloca = memref.alloca() : memref + affine.store %0, %alloca[] : memref + %alloca_2 = memref.alloca(%c16) : memref + %alloca_3 = memref.alloca(%c16) : memref + affine.for %arg3 = 0 to 16 { + %1 = affine.load %alloca[] : memref + affine.store %1, %alloca_2[%arg3] : memref + affine.store %cst_1, %alloca_3[%arg3] : memref + %alloca_4 = memref.alloca(%c4) : memref + %alloca_5 = memref.alloca(%c4) : memref + affine.for %arg4 = 0 to 4 { + %5 = affine.load %alloca_2[%arg3] : memref + %6 = affine.load %alloca_3[%arg3] : memref + %7 = affine.load %arg1[%arg3, %arg4] : memref + %8 = arith.index_cast %7 : i32 to index + affine.store %5, %alloca_4[%arg4] : memref + affine.store %6, %alloca_5[%arg4] : memref + %alloca_6 = memref.alloca(%c16) : memref + affine.for %arg5 = 0 to 16 { + %11 = affine.load %alloca_4[%arg4] : memref + %12 = affine.load %alloca_5[%arg4] : memref + %13 = arith.index_cast %arg5 : index to i32 + affine.store %c0_i32, %alloca_6[%arg5] : memref + %subview = memref.subview %arg1[%arg3, 0] [1, %c4] [1, 1] : memref to memref> + %subview_7 = memref.subview %alloca_6[%arg5] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%subview_7 : memref>) { + ^bb0(%in: i32, %out: i32): + %25 = arith.cmpi eq, %in, %13 : i32 + %26 = arith.extui %25 : i1 to i32 + %27 = arith.ori %out, %26 : i32 + linalg.yield %27 : i32 + } + %14 = affine.load %alloca_6[%arg5] : memref + %15 = arith.cmpi eq, %14, %c0_i32 : i32 + %16 = memref.load %arg0[%arg3, %8] : memref + %17 = arith.subf %cst_0, %16 : f32 + %18 = affine.load %arg0[%arg3, %arg5] : memref + %19 = arith.addf %17, %18 : f32 + %20 = arith.cmpf ogt, %19, %cst_1 : f32 + %21 = arith.addf %12, %19 : f32 + %22 = arith.select %20, %21, %12 : f32 + %23 = arith.select %15, %19, %11 : f32 + %24 = arith.select %15, %22, %12 : f32 + affine.store %23, %alloca_4[%arg4] : memref + affine.store %24, %alloca_5[%arg4] : memref + } + %9 = affine.load %alloca_4[%arg4] : memref + %10 = affine.load %alloca_5[%arg4] : memref + affine.store %9, %alloca_2[%arg3] : memref + affine.store %10, %alloca_3[%arg3] : memref + } + %2 = affine.load %alloca_2[%arg3] : memref + %3 = affine.load %alloca_3[%arg3] : memref + %4 = arith.divf %3, %cst : f32 + affine.store %4, %arg2[%arg3] : memref + affine.store %2, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu_debuf.mlir new file mode 100644 index 000000000000..032cb149de23 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu_debuf.mlir @@ -0,0 +1,84 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multilabel_margin_loss_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 1.600000e+01 : f32 + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = llvm.mlir.undef : f32 + %4 = tensor.empty() : tensor + %inserted = tensor.insert %3 into %4[] : tensor + %5 = tensor.empty(%c16) : tensor + %6 = tensor.empty(%c16) : tensor + %7:4 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %inserted, %arg5 = %5, %arg6 = %6, %arg7 = %0) -> (tensor, tensor, tensor, tensor) { + %extracted = tensor.extract %arg4[] : tensor + %inserted_2 = tensor.insert %extracted into %arg5[%arg3] : tensor + %inserted_3 = tensor.insert %cst into %arg6[%arg3] : tensor + %alloca = memref.alloca(%c4) : memref + %9 = bufferization.to_tensor %alloca : memref + %alloca_4 = memref.alloca(%c4) : memref + %10 = bufferization.to_tensor %alloca_4 : memref + %11:4 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %inserted_2, %arg10 = %inserted_3, %arg11 = %9, %arg12 = %10) -> (tensor, tensor, tensor, tensor) { + %extracted_9 = tensor.extract %arg9[%arg3] : tensor + %extracted_10 = tensor.extract %arg10[%arg3] : tensor + %extracted_11 = tensor.extract %1[%arg3, %arg8] : tensor + %13 = arith.index_cast %extracted_11 : i32 to index + %inserted_12 = tensor.insert %extracted_9 into %arg11[%arg8] : tensor + %inserted_13 = tensor.insert %extracted_10 into %arg12[%arg8] : tensor + %alloca_14 = memref.alloca(%c16) : memref + %14 = bufferization.to_tensor %alloca_14 : memref + %15:3 = affine.for %arg13 = 0 to 16 iter_args(%arg14 = %inserted_12, %arg15 = %inserted_13, %arg16 = %14) -> (tensor, tensor, tensor) { + %extracted_19 = tensor.extract %arg14[%arg8] : tensor + %extracted_20 = tensor.extract %arg15[%arg8] : tensor + %16 = arith.index_cast %arg13 : index to i32 + %inserted_21 = tensor.insert %c0_i32 into %arg16[%arg13] : tensor + %extracted_slice = tensor.extract_slice %inserted_21[%arg13] [1] [1] : tensor to tensor + %extracted_slice_22 = tensor.extract_slice %1[%arg3, 0] [1, %c4] [1, 1] : tensor to tensor + %17 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_22 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: i32, %out: i32): + %26 = arith.cmpi eq, %in, %16 : i32 + %27 = arith.extui %26 : i1 to i32 + %28 = arith.ori %out, %27 : i32 + linalg.yield %28 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %17 into %inserted_21[%arg13] [1] [1] : tensor into tensor + %extracted_23 = tensor.extract %inserted_slice[%arg13] : tensor + %18 = arith.cmpi eq, %extracted_23, %c0_i32 : i32 + %extracted_24 = tensor.extract %2[%arg3, %13] : tensor + %19 = arith.subf %cst_0, %extracted_24 : f32 + %extracted_25 = tensor.extract %2[%arg3, %arg13] : tensor + %20 = arith.addf %19, %extracted_25 : f32 + %21 = arith.cmpf ogt, %20, %cst : f32 + %22 = arith.addf %extracted_20, %20 : f32 + %23 = arith.select %21, %22, %extracted_20 : f32 + %24 = arith.select %18, %20, %extracted_19 : f32 + %25 = arith.select %18, %23, %extracted_20 : f32 + %inserted_26 = tensor.insert %24 into %arg14[%arg8] : tensor + %inserted_27 = tensor.insert %25 into %arg15[%arg8] : tensor + affine.yield %inserted_26, %inserted_27, %inserted_slice : tensor, tensor, tensor + } + %extracted_15 = tensor.extract %15#0[%arg8] : tensor + %extracted_16 = tensor.extract %15#1[%arg8] : tensor + %inserted_17 = tensor.insert %extracted_15 into %arg9[%arg3] : tensor + %inserted_18 = tensor.insert %extracted_16 into %arg10[%arg3] : tensor + affine.yield %inserted_17, %inserted_18, %15#0, %15#1 : tensor, tensor, tensor, tensor + } + %extracted_5 = tensor.extract %11#0[%arg3] : tensor + %extracted_6 = tensor.extract %11#1[%arg3] : tensor + %12 = arith.divf %extracted_6, %cst_1 : f32 + %inserted_7 = tensor.insert %12 into %arg7[%arg3] : tensor + %inserted_8 = tensor.insert %extracted_5 into %arg4[] : tensor + affine.yield %inserted_8, %11#0, %11#1, %inserted_7 : tensor, tensor, tensor, tensor + } + %8 = bufferization.to_memref %7#3 : memref + memref.copy %8, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu_linalg.mlir new file mode 100644 index 000000000000..37deebfb2104 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multilabel_margin_loss_forward_cpu_linalg.mlir @@ -0,0 +1,72 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multilabel_margin_loss_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 1.600000e+01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = llvm.mlir.undef : f32 + %alloca = memref.alloca() : memref + affine.store %0, %alloca[] : memref + %alloca_2 = memref.alloca(%c16) : memref + %alloca_3 = memref.alloca(%c16) : memref + affine.for %arg3 = 0 to 16 { + %1 = affine.load %alloca[] : memref + affine.store %1, %alloca_2[%arg3] : memref + affine.store %cst_1, %alloca_3[%arg3] : memref + %alloca_4 = memref.alloca(%c4) : memref + %alloca_5 = memref.alloca(%c4) : memref + affine.for %arg4 = 0 to 4 { + %5 = affine.load %alloca_2[%arg3] : memref + %6 = affine.load %alloca_3[%arg3] : memref + %7 = affine.load %arg1[%arg3, %arg4] : memref + %8 = arith.index_cast %7 : i32 to index + affine.store %5, %alloca_4[%arg4] : memref + affine.store %6, %alloca_5[%arg4] : memref + %alloca_6 = memref.alloca(%c16) : memref + affine.for %arg5 = 0 to 16 { + %11 = affine.load %alloca_4[%arg4] : memref + %12 = affine.load %alloca_5[%arg4] : memref + %13 = arith.index_cast %arg5 : index to i32 + affine.store %c0_i32, %alloca_6[%arg5] : memref + %subview = memref.subview %arg1[%arg3, 0] [1, %c4] [1, 1] : memref to memref> + %subview_7 = memref.subview %alloca_6[%arg5] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%subview_7 : memref>) { + ^bb0(%in: i32, %out: i32): + %25 = arith.cmpi eq, %in, %13 : i32 + %26 = arith.extui %25 : i1 to i32 + %27 = arith.ori %out, %26 : i32 + linalg.yield %27 : i32 + } + %14 = affine.load %alloca_6[%arg5] : memref + %15 = arith.cmpi eq, %14, %c0_i32 : i32 + %16 = memref.load %arg0[%arg3, %8] : memref + %17 = arith.subf %cst_0, %16 : f32 + %18 = affine.load %arg0[%arg3, %arg5] : memref + %19 = arith.addf %17, %18 : f32 + %20 = arith.cmpf ogt, %19, %cst_1 : f32 + %21 = arith.addf %12, %19 : f32 + %22 = arith.select %20, %21, %12 : f32 + %23 = arith.select %15, %19, %11 : f32 + %24 = arith.select %15, %22, %12 : f32 + affine.store %23, %alloca_4[%arg4] : memref + affine.store %24, %alloca_5[%arg4] : memref + } + %9 = affine.load %alloca_4[%arg4] : memref + %10 = affine.load %alloca_5[%arg4] : memref + affine.store %9, %alloca_2[%arg3] : memref + affine.store %10, %alloca_3[%arg3] : memref + } + %2 = affine.load %alloca_2[%arg3] : memref + %3 = affine.load %alloca_3[%arg3] : memref + %4 = arith.divf %3, %cst : f32 + affine.store %4, %arg2[%arg3] : memref + affine.store %2, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu.mlir b/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu.mlir new file mode 100644 index 000000000000..a90dcb02fbd4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu.mlir @@ -0,0 +1,45 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multinomial_with_replacement_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %c31_i32 = arith.constant 31 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<32xf32> + affine.for %arg3 = 0 to 8 { + %0 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = arith.addf %arg5, %1 : f32 + affine.store %2, %alloca[%arg4] : memref<32xf32> + affine.yield %2 : f32 + } + affine.for %arg4 = 0 to 16 { + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = arith.mulf %1, %0 : f32 + %3 = scf.while (%arg5 = %c0_i32) : (i32) -> i32 { + %4 = arith.cmpi slt, %arg5, %c31_i32 : i32 + %5:2 = scf.if %4 -> (i1, i32) { + %6 = arith.index_cast %arg5 : i32 to index + %7 = memref.load %alloca[%6] : memref<32xf32> + %8 = arith.cmpf olt, %7, %2 : f32 + %9 = scf.if %8 -> (i32) { + %10 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %10 : i32 + } else { + scf.yield %arg5 : i32 + } + scf.yield %8, %9 : i1, i32 + } else { + scf.yield %false, %arg5 : i1, i32 + } + scf.condition(%5#0) %5#1 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + affine.store %3, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu/debuf.mlir new file mode 100644 index 000000000000..bb17ba0d789f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu/debuf.mlir @@ -0,0 +1,57 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multinomial_with_replacement_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c31_i32 = arith.constant 31 : i32 + %false = arith.constant false + %c32 = arith.constant 32 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<32xf32> + %4 = tensor.empty(%c8) : tensor + %5:3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %3, %arg5 = %4, %arg6 = %0) -> (tensor<32xf32>, tensor, tensor) { + %inserted = tensor.insert %cst into %arg5[%arg3] : tensor + %extracted_slice = tensor.extract_slice %arg4[0] [%c32] [1] : tensor<32xf32> to tensor + %extracted_slice_0 = tensor.extract_slice %inserted[%arg3] [1] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[%arg3, 0] [1, %c32] [1, 1] : tensor to tensor + %7:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice, %extracted_slice_0 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_3: f32): + %9 = arith.addf %out_3, %in : f32 + linalg.yield %9, %9 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %7#1 into %inserted[%arg3] [1] [1] : tensor into tensor + %inserted_slice_2 = tensor.insert_slice %7#0 into %arg4[0] [%c32] [1] : tensor into tensor<32xf32> + %extracted = tensor.extract %inserted_slice[%arg3] : tensor + %8 = affine.for %arg7 = 0 to 16 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted_3 = tensor.extract %1[%arg3, %arg7] : tensor + %9 = arith.mulf %extracted_3, %extracted : f32 + %10 = scf.while (%arg9 = %c0_i32) : (i32) -> i32 { + %11 = arith.cmpi slt, %arg9, %c31_i32 : i32 + %12 = arith.index_cast %arg9 : i32 to index + %extracted_5 = tensor.extract %inserted_slice_2[%12] : tensor<32xf32> + %13 = arith.cmpf olt, %extracted_5, %9 : f32 + %14 = arith.addi %arg9, %c1_i32 : i32 + %15 = arith.select %13, %14, %arg9 : i32 + %16 = arith.select %11, %13, %false : i1 + %17 = arith.select %11, %15, %arg9 : i32 + scf.condition(%16) %17 : i32 + } do { + ^bb0(%arg9: i32): + scf.yield %arg9 : i32 + } + %inserted_4 = tensor.insert %10 into %arg8[%arg3, %arg7] : tensor + affine.yield %inserted_4 : tensor + } + affine.yield %inserted_slice_2, %inserted_slice, %8 : tensor<32xf32>, tensor, tensor + } + %6 = bufferization.to_memref %5#2 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu/matched.mlir new file mode 100644 index 000000000000..bb17ba0d789f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu/matched.mlir @@ -0,0 +1,57 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multinomial_with_replacement_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c31_i32 = arith.constant 31 : i32 + %false = arith.constant false + %c32 = arith.constant 32 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<32xf32> + %4 = tensor.empty(%c8) : tensor + %5:3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %3, %arg5 = %4, %arg6 = %0) -> (tensor<32xf32>, tensor, tensor) { + %inserted = tensor.insert %cst into %arg5[%arg3] : tensor + %extracted_slice = tensor.extract_slice %arg4[0] [%c32] [1] : tensor<32xf32> to tensor + %extracted_slice_0 = tensor.extract_slice %inserted[%arg3] [1] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[%arg3, 0] [1, %c32] [1, 1] : tensor to tensor + %7:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice, %extracted_slice_0 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_3: f32): + %9 = arith.addf %out_3, %in : f32 + linalg.yield %9, %9 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %7#1 into %inserted[%arg3] [1] [1] : tensor into tensor + %inserted_slice_2 = tensor.insert_slice %7#0 into %arg4[0] [%c32] [1] : tensor into tensor<32xf32> + %extracted = tensor.extract %inserted_slice[%arg3] : tensor + %8 = affine.for %arg7 = 0 to 16 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted_3 = tensor.extract %1[%arg3, %arg7] : tensor + %9 = arith.mulf %extracted_3, %extracted : f32 + %10 = scf.while (%arg9 = %c0_i32) : (i32) -> i32 { + %11 = arith.cmpi slt, %arg9, %c31_i32 : i32 + %12 = arith.index_cast %arg9 : i32 to index + %extracted_5 = tensor.extract %inserted_slice_2[%12] : tensor<32xf32> + %13 = arith.cmpf olt, %extracted_5, %9 : f32 + %14 = arith.addi %arg9, %c1_i32 : i32 + %15 = arith.select %13, %14, %arg9 : i32 + %16 = arith.select %11, %13, %false : i1 + %17 = arith.select %11, %15, %arg9 : i32 + scf.condition(%16) %17 : i32 + } do { + ^bb0(%arg9: i32): + scf.yield %arg9 : i32 + } + %inserted_4 = tensor.insert %10 into %arg8[%arg3, %arg7] : tensor + affine.yield %inserted_4 : tensor + } + affine.yield %inserted_slice_2, %inserted_slice, %8 : tensor<32xf32>, tensor, tensor + } + %6 = bufferization.to_memref %5#2 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu/orig.mlir new file mode 100644 index 000000000000..a90dcb02fbd4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu/orig.mlir @@ -0,0 +1,45 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multinomial_with_replacement_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %c31_i32 = arith.constant 31 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<32xf32> + affine.for %arg3 = 0 to 8 { + %0 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = arith.addf %arg5, %1 : f32 + affine.store %2, %alloca[%arg4] : memref<32xf32> + affine.yield %2 : f32 + } + affine.for %arg4 = 0 to 16 { + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = arith.mulf %1, %0 : f32 + %3 = scf.while (%arg5 = %c0_i32) : (i32) -> i32 { + %4 = arith.cmpi slt, %arg5, %c31_i32 : i32 + %5:2 = scf.if %4 -> (i1, i32) { + %6 = arith.index_cast %arg5 : i32 to index + %7 = memref.load %alloca[%6] : memref<32xf32> + %8 = arith.cmpf olt, %7, %2 : f32 + %9 = scf.if %8 -> (i32) { + %10 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %10 : i32 + } else { + scf.yield %arg5 : i32 + } + scf.yield %8, %9 : i1, i32 + } else { + scf.yield %false, %arg5 : i1, i32 + } + scf.condition(%5#0) %5#1 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + affine.store %3, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu/raised.mlir new file mode 100644 index 000000000000..a4aeb4bb5f4a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu/raised.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multinomial_with_replacement_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c32 = arith.constant 32 : index + %false = arith.constant false + %c31_i32 = arith.constant 31 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<32xf32> + %alloca_0 = memref.alloca(%c8) : memref + affine.for %arg3 = 0 to 8 { + affine.store %cst, %alloca_0[%arg3] : memref + %subview = memref.subview %arg0[%arg3, 0] [1, %c32] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[0] [%c32] [1] : memref<32xf32> to memref> + %subview_2 = memref.subview %alloca_0[%arg3] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%subview_1, %subview_2 : memref>, memref>) { + ^bb0(%in: f32, %out: f32, %out_3: f32): + %1 = arith.addf %out_3, %in : f32 + linalg.yield %1, %1 : f32, f32 + } + %0 = affine.load %alloca_0[%arg3] : memref + affine.for %arg4 = 0 to 16 { + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = arith.mulf %1, %0 : f32 + %3 = scf.while (%arg5 = %c0_i32) : (i32) -> i32 { + %4 = arith.cmpi slt, %arg5, %c31_i32 : i32 + %5 = arith.index_cast %arg5 : i32 to index + %6 = memref.load %alloca[%5] : memref<32xf32> + %7 = arith.cmpf olt, %6, %2 : f32 + %8 = arith.addi %arg5, %c1_i32 : i32 + %9 = arith.select %7, %8, %arg5 : i32 + %10 = arith.select %4, %7, %false : i1 + %11 = arith.select %4, %9, %arg5 : i32 + scf.condition(%10) %11 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + affine.store %3, %arg2[%arg3, %arg4] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu_debuf.mlir new file mode 100644 index 000000000000..bb17ba0d789f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu_debuf.mlir @@ -0,0 +1,57 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multinomial_with_replacement_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c31_i32 = arith.constant 31 : i32 + %false = arith.constant false + %c32 = arith.constant 32 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<32xf32> + %4 = tensor.empty(%c8) : tensor + %5:3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %3, %arg5 = %4, %arg6 = %0) -> (tensor<32xf32>, tensor, tensor) { + %inserted = tensor.insert %cst into %arg5[%arg3] : tensor + %extracted_slice = tensor.extract_slice %arg4[0] [%c32] [1] : tensor<32xf32> to tensor + %extracted_slice_0 = tensor.extract_slice %inserted[%arg3] [1] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[%arg3, 0] [1, %c32] [1, 1] : tensor to tensor + %7:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice, %extracted_slice_0 : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_3: f32): + %9 = arith.addf %out_3, %in : f32 + linalg.yield %9, %9 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %7#1 into %inserted[%arg3] [1] [1] : tensor into tensor + %inserted_slice_2 = tensor.insert_slice %7#0 into %arg4[0] [%c32] [1] : tensor into tensor<32xf32> + %extracted = tensor.extract %inserted_slice[%arg3] : tensor + %8 = affine.for %arg7 = 0 to 16 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted_3 = tensor.extract %1[%arg3, %arg7] : tensor + %9 = arith.mulf %extracted_3, %extracted : f32 + %10 = scf.while (%arg9 = %c0_i32) : (i32) -> i32 { + %11 = arith.cmpi slt, %arg9, %c31_i32 : i32 + %12 = arith.index_cast %arg9 : i32 to index + %extracted_5 = tensor.extract %inserted_slice_2[%12] : tensor<32xf32> + %13 = arith.cmpf olt, %extracted_5, %9 : f32 + %14 = arith.addi %arg9, %c1_i32 : i32 + %15 = arith.select %13, %14, %arg9 : i32 + %16 = arith.select %11, %13, %false : i1 + %17 = arith.select %11, %15, %arg9 : i32 + scf.condition(%16) %17 : i32 + } do { + ^bb0(%arg9: i32): + scf.yield %arg9 : i32 + } + %inserted_4 = tensor.insert %10 into %arg8[%arg3, %arg7] : tensor + affine.yield %inserted_4 : tensor + } + affine.yield %inserted_slice_2, %inserted_slice, %8 : tensor<32xf32>, tensor, tensor + } + %6 = bufferization.to_memref %5#2 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu_linalg.mlir new file mode 100644 index 000000000000..a4aeb4bb5f4a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_multinomial_with_replacement_cpu_linalg.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_multinomial_with_replacement_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c32 = arith.constant 32 : index + %false = arith.constant false + %c31_i32 = arith.constant 31 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<32xf32> + %alloca_0 = memref.alloca(%c8) : memref + affine.for %arg3 = 0 to 8 { + affine.store %cst, %alloca_0[%arg3] : memref + %subview = memref.subview %arg0[%arg3, 0] [1, %c32] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[0] [%c32] [1] : memref<32xf32> to memref> + %subview_2 = memref.subview %alloca_0[%arg3] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%subview_1, %subview_2 : memref>, memref>) { + ^bb0(%in: f32, %out: f32, %out_3: f32): + %1 = arith.addf %out_3, %in : f32 + linalg.yield %1, %1 : f32, f32 + } + %0 = affine.load %alloca_0[%arg3] : memref + affine.for %arg4 = 0 to 16 { + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = arith.mulf %1, %0 : f32 + %3 = scf.while (%arg5 = %c0_i32) : (i32) -> i32 { + %4 = arith.cmpi slt, %arg5, %c31_i32 : i32 + %5 = arith.index_cast %arg5 : i32 to index + %6 = memref.load %alloca[%5] : memref<32xf32> + %7 = arith.cmpf olt, %6, %2 : f32 + %8 = arith.addi %arg5, %c1_i32 : i32 + %9 = arith.select %7, %8, %arg5 : i32 + %10 = arith.select %4, %7, %false : i1 + %11 = arith.select %4, %9, %arg5 : i32 + scf.condition(%10) %11 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + affine.store %3, %arg2[%arg3, %arg4] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mv.mlir b/issues/aten_c_kernels/results/aten_mv.mlir new file mode 100644 index 000000000000..28e57f8cbf23 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mv.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mv(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 64 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg0[%arg3, %arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %arg2[%arg3] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg2[%arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_mv/debuf.mlir b/issues/aten_c_kernels/results/aten_mv/debuf.mlir new file mode 100644 index 000000000000..88a783d0dbf7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mv/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mv(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c64] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0] [%c64] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %5 = arith.mulf %in, %in_2 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c64] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mv/matched.mlir b/issues/aten_c_kernels/results/aten_mv/matched.mlir new file mode 100644 index 000000000000..635ff521f49b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mv/matched.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mv(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c64] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0] [%c64] [1] : tensor to tensor + %3 = kernel.launch @cublasDgemv(%extracted_slice, %extracted_slice_0, %extracted_slice_1) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c64] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mv/orig.mlir b/issues/aten_c_kernels/results/aten_mv/orig.mlir new file mode 100644 index 000000000000..28e57f8cbf23 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mv/orig.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mv(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 64 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg0[%arg3, %arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %arg2[%arg3] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg2[%arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_mv/raised.mlir b/issues/aten_c_kernels/results/aten_mv/raised.mlir new file mode 100644 index 000000000000..25715b8d6969 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mv/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mv(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 0] [%c64, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c64] [1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c64] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %0 = arith.mulf %in, %in_2 : f64 + %1 = arith.addf %out, %0 : f64 + linalg.yield %1 : f64 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mv_debuf.mlir b/issues/aten_c_kernels/results/aten_mv_debuf.mlir new file mode 100644 index 000000000000..88a783d0dbf7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mv_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mv(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c64] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0] [%c64] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %5 = arith.mulf %in, %in_2 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c64] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_mv_linalg.mlir b/issues/aten_c_kernels/results/aten_mv_linalg.mlir new file mode 100644 index 000000000000..25715b8d6969 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_mv_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_mv(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 0] [%c64, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c64] [1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c64] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %0 = arith.mulf %in, %in_2 : f64 + %1 = arith.addf %out, %0 : f64 + linalg.yield %1 : f64 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nan_to_num.mlir b/issues/aten_c_kernels/results/aten_nan_to_num.mlir new file mode 100644 index 000000000000..107215af60fc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nan_to_num.mlir @@ -0,0 +1,24 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nan_to_num(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.negf %arg4 : f32 + affine.for %arg6 = 0 to 4096 { + %1 = affine.load %arg0[%arg6] : memref + %2 = arith.cmpf une, %1, %1 : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %arg1 : f32 + } else { + %4 = arith.cmpf ogt, %1, %arg4 : f32 + %5 = scf.if %4 -> (f32) { + scf.yield %arg2 : f32 + } else { + %6 = arith.cmpf olt, %1, %0 : f32 + %7 = arith.select %6, %arg3, %1 : f32 + scf.yield %7 : f32 + } + scf.yield %5 : f32 + } + affine.store %3, %arg5[%arg6] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nan_to_num/debuf.mlir b/issues/aten_c_kernels/results/aten_nan_to_num/debuf.mlir new file mode 100644 index 000000000000..95bd1e4d0019 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nan_to_num/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nan_to_num(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = arith.negf %arg4 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf une, %in, %in : f32 + %6 = arith.cmpf ogt, %in, %arg4 : f32 + %7 = arith.cmpf olt, %in, %2 : f32 + %8 = arith.select %7, %arg3, %in : f32 + %9 = arith.select %6, %arg2, %8 : f32 + %10 = arith.select %5, %arg1, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nan_to_num/matched.mlir b/issues/aten_c_kernels/results/aten_nan_to_num/matched.mlir new file mode 100644 index 000000000000..95bd1e4d0019 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nan_to_num/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nan_to_num(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = arith.negf %arg4 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf une, %in, %in : f32 + %6 = arith.cmpf ogt, %in, %arg4 : f32 + %7 = arith.cmpf olt, %in, %2 : f32 + %8 = arith.select %7, %arg3, %in : f32 + %9 = arith.select %6, %arg2, %8 : f32 + %10 = arith.select %5, %arg1, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nan_to_num/orig.mlir b/issues/aten_c_kernels/results/aten_nan_to_num/orig.mlir new file mode 100644 index 000000000000..107215af60fc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nan_to_num/orig.mlir @@ -0,0 +1,24 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nan_to_num(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.negf %arg4 : f32 + affine.for %arg6 = 0 to 4096 { + %1 = affine.load %arg0[%arg6] : memref + %2 = arith.cmpf une, %1, %1 : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %arg1 : f32 + } else { + %4 = arith.cmpf ogt, %1, %arg4 : f32 + %5 = scf.if %4 -> (f32) { + scf.yield %arg2 : f32 + } else { + %6 = arith.cmpf olt, %1, %0 : f32 + %7 = arith.select %6, %arg3, %1 : f32 + scf.yield %7 : f32 + } + scf.yield %5 : f32 + } + affine.store %3, %arg5[%arg6] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nan_to_num/raised.mlir b/issues/aten_c_kernels/results/aten_nan_to_num/raised.mlir new file mode 100644 index 000000000000..29f02d7794da --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nan_to_num/raised.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nan_to_num(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.negf %arg4 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg5 : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.cmpf une, %in, %in : f32 + %2 = arith.cmpf ogt, %in, %arg4 : f32 + %3 = arith.cmpf olt, %in, %0 : f32 + %4 = arith.select %3, %arg3, %in : f32 + %5 = arith.select %2, %arg2, %4 : f32 + %6 = arith.select %1, %arg1, %5 : f32 + linalg.yield %6 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nan_to_num_debuf.mlir b/issues/aten_c_kernels/results/aten_nan_to_num_debuf.mlir new file mode 100644 index 000000000000..95bd1e4d0019 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nan_to_num_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nan_to_num(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = arith.negf %arg4 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf une, %in, %in : f32 + %6 = arith.cmpf ogt, %in, %arg4 : f32 + %7 = arith.cmpf olt, %in, %2 : f32 + %8 = arith.select %7, %arg3, %in : f32 + %9 = arith.select %6, %arg2, %8 : f32 + %10 = arith.select %5, %arg1, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nan_to_num_linalg.mlir b/issues/aten_c_kernels/results/aten_nan_to_num_linalg.mlir new file mode 100644 index 000000000000..29f02d7794da --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nan_to_num_linalg.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nan_to_num(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: f32, %arg4: f32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.negf %arg4 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg5 : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.cmpf une, %in, %in : f32 + %2 = arith.cmpf ogt, %in, %arg4 : f32 + %3 = arith.cmpf olt, %in, %0 : f32 + %4 = arith.select %3, %arg3, %in : f32 + %5 = arith.select %2, %arg2, %4 : f32 + %6 = arith.select %1, %arg1, %5 : f32 + linalg.yield %6 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nansum_cpu.mlir b/issues/aten_c_kernels/results/aten_nansum_cpu.mlir new file mode 100644 index 000000000000..f8636516c305 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nansum_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nansum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 16 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2, %arg3] : memref + %2 = arith.cmpf oeq, %1, %1 : f32 + %3 = scf.if %2 -> (f32) { + %4 = arith.addf %arg4, %1 : f32 + scf.yield %4 : f32 + } else { + scf.yield %arg4 : f32 + } + affine.yield %3 : f32 + } + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nansum_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nansum_cpu/debuf.mlir new file mode 100644 index 000000000000..23a876619a56 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nansum_cpu/debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nansum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c16] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf oeq, %in, %in : f32 + %6 = arith.addf %out, %in : f32 + %7 = arith.select %5, %6, %out : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c16] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nansum_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nansum_cpu/matched.mlir new file mode 100644 index 000000000000..b47539650659 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nansum_cpu/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nansum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = kernel.launch @memset_zero_1D_f32(%1) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c16] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf oeq, %in, %in : f32 + %6 = arith.addf %out, %in : f32 + %7 = arith.select %5, %6, %out : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c16] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nansum_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nansum_cpu/orig.mlir new file mode 100644 index 000000000000..f8636516c305 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nansum_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nansum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 16 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2, %arg3] : memref + %2 = arith.cmpf oeq, %1, %1 : f32 + %3 = scf.if %2 -> (f32) { + %4 = arith.addf %arg4, %1 : f32 + scf.yield %4 : f32 + } else { + scf.yield %arg4 : f32 + } + affine.yield %3 : f32 + } + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nansum_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nansum_cpu/raised.mlir new file mode 100644 index 000000000000..2337214095b0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nansum_cpu/raised.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nansum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf oeq, %in, %in : f32 + %1 = arith.addf %out, %in : f32 + %2 = arith.select %0, %1, %out : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nansum_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nansum_cpu_debuf.mlir new file mode 100644 index 000000000000..23a876619a56 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nansum_cpu_debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nansum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c16] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf oeq, %in, %in : f32 + %6 = arith.addf %out, %in : f32 + %7 = arith.select %5, %6, %out : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c16] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nansum_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nansum_cpu_linalg.mlir new file mode 100644 index 000000000000..2337214095b0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nansum_cpu_linalg.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nansum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf oeq, %in, %in : f32 + %1 = arith.addf %out, %in : f32 + %2 = arith.select %0, %1, %out : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu.mlir b/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu.mlir new file mode 100644 index 000000000000..bc816d2c6870 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_narrow_copy_dense_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 32 { + affine.for %arg3 = 0 to 16 { + %0 = affine.load %arg0[%arg2, %arg3 + 8] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu/debuf.mlir new file mode 100644 index 000000000000..0ac4e90a8f54 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_narrow_copy_dense_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 8] [%c32, %c16] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c32, %c16] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c32, %c16] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu/matched.mlir new file mode 100644 index 000000000000..f064c8e3d79c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_narrow_copy_dense_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 8] [%c32, %c16] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c32, %c16] [1, 1] : tensor to tensor + %2 = kernel.launch @cudaCopy2D_f32_tensor(%extracted_slice, %extracted_slice_0) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c32, %c16] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu/orig.mlir new file mode 100644 index 000000000000..bc816d2c6870 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_narrow_copy_dense_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 32 { + affine.for %arg3 = 0 to 16 { + %0 = affine.load %arg0[%arg2, %arg3 + 8] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu/raised.mlir new file mode 100644 index 000000000000..bed2718230b9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_narrow_copy_dense_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %subview = memref.subview %arg0[0, 8] [%c32, %c16] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c32, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu_debuf.mlir new file mode 100644 index 000000000000..0ac4e90a8f54 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_narrow_copy_dense_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 8] [%c32, %c16] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c32, %c16] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c32, %c16] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu_linalg.mlir new file mode 100644 index 000000000000..bed2718230b9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_narrow_copy_dense_cpu_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_narrow_copy_dense_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %subview = memref.subview %arg0[0, 8] [%c32, %c16] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c32, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ndtri.mlir b/issues/aten_c_kernels/results/aten_ndtri.mlir new file mode 100644 index 000000000000..b8502fd8058c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ndtri.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ndtri(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_ndtrif(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_ndtrif(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_ndtri/debuf.mlir b/issues/aten_c_kernels/results/aten_ndtri/debuf.mlir new file mode 100644 index 000000000000..eeef3ae8103f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ndtri/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ndtri(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_ndtrif(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_ndtrif(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_ndtri/matched.mlir b/issues/aten_c_kernels/results/aten_ndtri/matched.mlir new file mode 100644 index 000000000000..eeef3ae8103f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ndtri/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ndtri(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_ndtrif(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_ndtrif(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_ndtri/orig.mlir b/issues/aten_c_kernels/results/aten_ndtri/orig.mlir new file mode 100644 index 000000000000..b8502fd8058c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ndtri/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ndtri(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_ndtrif(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_ndtrif(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_ndtri/raised.mlir b/issues/aten_c_kernels/results/aten_ndtri/raised.mlir new file mode 100644 index 000000000000..3990024428ed --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ndtri/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ndtri(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_ndtrif(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_ndtrif(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_ndtri_debuf.mlir b/issues/aten_c_kernels/results/aten_ndtri_debuf.mlir new file mode 100644 index 000000000000..eeef3ae8103f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ndtri_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ndtri(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_ndtrif(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_ndtrif(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_ndtri_linalg.mlir b/issues/aten_c_kernels/results/aten_ndtri_linalg.mlir new file mode 100644 index 000000000000..3990024428ed --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ndtri_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ndtri(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_ndtrif(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_ndtrif(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_ne.mlir b/issues/aten_c_kernels/results/aten_ne.mlir new file mode 100644 index 000000000000..913e8a08b5d9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ne.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ne(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf une, %0, %1 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_ne/debuf.mlir b/issues/aten_c_kernels/results/aten_ne/debuf.mlir new file mode 100644 index 000000000000..6e46ca2ec16d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ne/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ne(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf une, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ne/matched.mlir b/issues/aten_c_kernels/results/aten_ne/matched.mlir new file mode 100644 index 000000000000..6e46ca2ec16d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ne/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ne(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf une, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ne/orig.mlir b/issues/aten_c_kernels/results/aten_ne/orig.mlir new file mode 100644 index 000000000000..913e8a08b5d9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ne/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ne(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpf une, %0, %1 : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.sitofp %3 : i32 to f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_ne/raised.mlir b/issues/aten_c_kernels/results/aten_ne/raised.mlir new file mode 100644 index 000000000000..1d0af7930cd0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ne/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ne(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf une, %in, %in_0 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ne_debuf.mlir b/issues/aten_c_kernels/results/aten_ne_debuf.mlir new file mode 100644 index 000000000000..6e46ca2ec16d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ne_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ne(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf une, %in, %in_0 : f32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.sitofp %6 : i32 to f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_ne_linalg.mlir b/issues/aten_c_kernels/results/aten_ne_linalg.mlir new file mode 100644 index 000000000000..1d0af7930cd0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_ne_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_ne(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf une, %in, %in_0 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_neg.mlir b/issues/aten_c_kernels/results/aten_neg.mlir new file mode 100644 index 000000000000..62dcf01d034c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_neg.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_neg(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.negf %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_neg/debuf.mlir b/issues/aten_c_kernels/results/aten_neg/debuf.mlir new file mode 100644 index 000000000000..f0b5da2bbc2e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_neg/debuf.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_neg(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.negf %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_neg/matched.mlir b/issues/aten_c_kernels/results/aten_neg/matched.mlir new file mode 100644 index 000000000000..f0b5da2bbc2e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_neg/matched.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_neg(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.negf %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_neg/orig.mlir b/issues/aten_c_kernels/results/aten_neg/orig.mlir new file mode 100644 index 000000000000..62dcf01d034c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_neg/orig.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_neg(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.negf %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_neg/raised.mlir b/issues/aten_c_kernels/results/aten_neg/raised.mlir new file mode 100644 index 000000000000..1ac6205accda --- /dev/null +++ b/issues/aten_c_kernels/results/aten_neg/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_neg(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.negf %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_neg_debuf.mlir b/issues/aten_c_kernels/results/aten_neg_debuf.mlir new file mode 100644 index 000000000000..f0b5da2bbc2e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_neg_debuf.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_neg(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.negf %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_neg_linalg.mlir b/issues/aten_c_kernels/results/aten_neg_linalg.mlir new file mode 100644 index 000000000000..1ac6205accda --- /dev/null +++ b/issues/aten_c_kernels/results/aten_neg_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_neg(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.negf %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_all_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_all_cpu.mlir new file mode 100644 index 000000000000..ddfbc4360f3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_all_cpu.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_all_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 8 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = scf.for %arg4 = %c0 to %1 step %c1 iter_args(%arg5 = %c1_i32) -> (i32) { + %3 = memref.load %arg0[%arg3, %arg4] : memref + %4 = arith.cmpi ne, %3, %c0_i32 : i32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.andi %arg5, %5 : i32 + scf.yield %6 : i32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_all_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_all_cpu/debuf.mlir new file mode 100644 index 000000000000..d69af97bc22f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_all_cpu/debuf.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_all_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %5 = arith.index_cast %extracted : i32 to index + %6 = scf.for %arg5 = %c0 to %5 step %c1 iter_args(%arg6 = %c1_i32) -> (i32) { + %extracted_0 = tensor.extract %2[%arg3, %arg5] : tensor + %7 = arith.cmpi ne, %extracted_0, %c0_i32 : i32 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.andi %arg6, %8 : i32 + scf.yield %9 : i32 + } + %inserted = tensor.insert %6 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_all_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_all_cpu/matched.mlir new file mode 100644 index 000000000000..d69af97bc22f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_all_cpu/matched.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_all_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %5 = arith.index_cast %extracted : i32 to index + %6 = scf.for %arg5 = %c0 to %5 step %c1 iter_args(%arg6 = %c1_i32) -> (i32) { + %extracted_0 = tensor.extract %2[%arg3, %arg5] : tensor + %7 = arith.cmpi ne, %extracted_0, %c0_i32 : i32 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.andi %arg6, %8 : i32 + scf.yield %9 : i32 + } + %inserted = tensor.insert %6 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_all_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_all_cpu/orig.mlir new file mode 100644 index 000000000000..ddfbc4360f3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_all_cpu/orig.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_all_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 8 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = scf.for %arg4 = %c0 to %1 step %c1 iter_args(%arg5 = %c1_i32) -> (i32) { + %3 = memref.load %arg0[%arg3, %arg4] : memref + %4 = arith.cmpi ne, %3, %c0_i32 : i32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.andi %arg5, %5 : i32 + scf.yield %6 : i32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_all_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_all_cpu/raised.mlir new file mode 100644 index 000000000000..445f483d3771 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_all_cpu/raised.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_all_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 8 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = scf.for %arg4 = %c0 to %1 step %c1 iter_args(%arg5 = %c1_i32) -> (i32) { + %3 = memref.load %arg0[%arg3, %arg4] : memref + %4 = arith.cmpi ne, %3, %c0_i32 : i32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.andi %arg5, %5 : i32 + scf.yield %6 : i32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_all_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_all_cpu_debuf.mlir new file mode 100644 index 000000000000..d69af97bc22f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_all_cpu_debuf.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_all_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %5 = arith.index_cast %extracted : i32 to index + %6 = scf.for %arg5 = %c0 to %5 step %c1 iter_args(%arg6 = %c1_i32) -> (i32) { + %extracted_0 = tensor.extract %2[%arg3, %arg5] : tensor + %7 = arith.cmpi ne, %extracted_0, %c0_i32 : i32 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.andi %arg6, %8 : i32 + scf.yield %9 : i32 + } + %inserted = tensor.insert %6 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_all_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_all_cpu_linalg.mlir new file mode 100644 index 000000000000..445f483d3771 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_all_cpu_linalg.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_all_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 8 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = scf.for %arg4 = %c0 to %1 step %c1 iter_args(%arg5 = %c1_i32) -> (i32) { + %3 = memref.load %arg0[%arg3, %arg4] : memref + %4 = arith.cmpi ne, %3, %c0_i32 : i32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.andi %arg5, %5 : i32 + scf.yield %6 : i32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu.mlir new file mode 100644 index 000000000000..7ea6a9571b16 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_batch_offsets_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg1[0] : memref + affine.for %arg2 = 0 to 64 { + %0 = affine.load %arg1[%arg2] : memref + %1 = affine.load %arg0[%arg2] : memref + %2 = arith.addi %0, %1 : i32 + affine.store %2, %arg1[%arg2 + 1] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu/debuf.mlir new file mode 100644 index 000000000000..c80df99d7c82 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_batch_offsets_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64 = arith.constant 64 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %c0_i32 into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [%c64] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %inserted[1] [%c64] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %4 = arith.addi %in, %in_2 : i32 + linalg.yield %4 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[1] [%c64] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu/matched.mlir new file mode 100644 index 000000000000..c80df99d7c82 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_batch_offsets_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64 = arith.constant 64 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %c0_i32 into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [%c64] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %inserted[1] [%c64] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %4 = arith.addi %in, %in_2 : i32 + linalg.yield %4 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[1] [%c64] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu/orig.mlir new file mode 100644 index 000000000000..7ea6a9571b16 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_batch_offsets_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg1[0] : memref + affine.for %arg2 = 0 to 64 { + %0 = affine.load %arg1[%arg2] : memref + %1 = affine.load %arg0[%arg2] : memref + %2 = arith.addi %0, %1 : i32 + affine.store %2, %arg1[%arg2 + 1] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu/raised.mlir new file mode 100644 index 000000000000..edf83bc3bf0b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu/raised.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_batch_offsets_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg1[0] : memref + %subview = memref.subview %arg1[0] [%c64] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0] [%c64] [1] : memref to memref> + %subview_1 = memref.subview %arg1[1] [%c64] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %0 = arith.addi %in, %in_2 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu_debuf.mlir new file mode 100644 index 000000000000..c80df99d7c82 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_batch_offsets_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64 = arith.constant 64 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %c0_i32 into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [%c64] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %inserted[1] [%c64] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %4 = arith.addi %in, %in_2 : i32 + linalg.yield %4 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[1] [%c64] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu_linalg.mlir new file mode 100644 index 000000000000..edf83bc3bf0b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_batch_offsets_cpu_linalg.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_batch_offsets_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg1[0] : memref + %subview = memref.subview %arg1[0] [%c64] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0] [%c64] [1] : memref to memref> + %subview_1 = memref.subview %arg1[1] [%c64] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %0 = arith.addi %in, %in_2 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_bmm_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_bmm_cpu.mlir new file mode 100644 index 000000000000..f0e2996a1043 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_bmm_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_bmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 20 { + %0 = affine.for %arg6 = 0 to 24 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4, %arg6] : memref + %2 = affine.load %arg1[%arg3, %arg6, %arg5] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg7, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_bmm_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_bmm_cpu/debuf.mlir new file mode 100644 index 000000000000..0e511fbe2d9b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_bmm_cpu/debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_bmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c8, %c24, %c20] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_bmm_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_bmm_cpu/matched.mlir new file mode 100644 index 000000000000..0e511fbe2d9b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_bmm_cpu/matched.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_bmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c8, %c24, %c20] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_bmm_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_bmm_cpu/orig.mlir new file mode 100644 index 000000000000..f0e2996a1043 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_bmm_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_bmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 20 { + %0 = affine.for %arg6 = 0 to 24 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4, %arg6] : memref + %2 = affine.load %arg1[%arg3, %arg6, %arg5] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg7, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_bmm_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_bmm_cpu/raised.mlir new file mode 100644 index 000000000000..daf7a8eb4558 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_bmm_cpu/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_bmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %c20 = arith.constant 20 : index + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0] [%c8, %c24, %c20] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_bmm_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_bmm_cpu_debuf.mlir new file mode 100644 index 000000000000..0e511fbe2d9b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_bmm_cpu_debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_bmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c8, %c24, %c20] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_bmm_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_bmm_cpu_linalg.mlir new file mode 100644 index 000000000000..daf7a8eb4558 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_bmm_cpu_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_bmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %c20 = arith.constant 20 : index + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0] [%c8, %c24, %c20] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_clone_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_clone_cpu.mlir new file mode 100644 index 000000000000..f5f91916cd5b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_clone_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_clone_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 8 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_clone_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_clone_cpu/debuf.mlir new file mode 100644 index 000000000000..4a6172269b72 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_clone_cpu/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_clone_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_clone_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_clone_cpu/matched.mlir new file mode 100644 index 000000000000..098a70fd9f6f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_clone_cpu/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_clone_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %2 = kernel.launch @cudaCopy2D_f32_tensor(%extracted_slice, %extracted_slice_0) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_clone_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_clone_cpu/orig.mlir new file mode 100644 index 000000000000..f5f91916cd5b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_clone_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_clone_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 8 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_clone_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_clone_cpu/raised.mlir new file mode 100644 index 000000000000..154ebae70688 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_clone_cpu/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_clone_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 0] [%c8, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_clone_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_clone_cpu_debuf.mlir new file mode 100644 index 000000000000..4a6172269b72 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_clone_cpu_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_clone_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_clone_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_clone_cpu_linalg.mlir new file mode 100644 index 000000000000..154ebae70688 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_clone_cpu_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_clone_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 0] [%c8, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_from_padded_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_from_padded_cpu.mlir new file mode 100644 index 000000000000..1f872a249b00 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_from_padded_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_from_padded_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 80 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpi slt, %0, %1 : i32 + %3 = scf.if %2 -> (f32) { + %4 = affine.load %arg0[%arg3, %arg4] : memref + scf.yield %4 : f32 + } else { + scf.yield %cst : f32 + } + affine.store %3, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_from_padded_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_from_padded_cpu/debuf.mlir new file mode 100644 index 000000000000..e5453849fe3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_from_padded_cpu/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_from_padded_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c80 = arith.constant 80 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %1[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: f32, %out: f32): + %5 = linalg.index 1 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.cmpi slt, %6, %in : i32 + %8 = arith.select %7, %in_2, %cst : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c8, %c80] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_from_padded_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_from_padded_cpu/matched.mlir new file mode 100644 index 000000000000..e5453849fe3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_from_padded_cpu/matched.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_from_padded_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c80 = arith.constant 80 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %1[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: f32, %out: f32): + %5 = linalg.index 1 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.cmpi slt, %6, %in : i32 + %8 = arith.select %7, %in_2, %cst : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c8, %c80] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_from_padded_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_from_padded_cpu/orig.mlir new file mode 100644 index 000000000000..1f872a249b00 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_from_padded_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_from_padded_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 80 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.cmpi slt, %0, %1 : i32 + %3 = scf.if %2 -> (f32) { + %4 = affine.load %arg0[%arg3, %arg4] : memref + scf.yield %4 : f32 + } else { + scf.yield %cst : f32 + } + affine.store %3, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_from_padded_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_from_padded_cpu/raised.mlir new file mode 100644 index 000000000000..75b491a119be --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_from_padded_cpu/raised.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_from_padded_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c80 = arith.constant 80 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg1[0] [%c8] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c8, %c80] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0] [%c8, %c80] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: f32, %out: f32): + %0 = linalg.index 1 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.cmpi slt, %1, %in : i32 + %3 = arith.select %2, %in_2, %cst : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_from_padded_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_from_padded_cpu_debuf.mlir new file mode 100644 index 000000000000..e5453849fe3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_from_padded_cpu_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_from_padded_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c80 = arith.constant 80 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %1[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: f32, %out: f32): + %5 = linalg.index 1 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.cmpi slt, %6, %in : i32 + %8 = arith.select %7, %in_2, %cst : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c8, %c80] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_from_padded_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_from_padded_cpu_linalg.mlir new file mode 100644 index 000000000000..75b491a119be --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_from_padded_cpu_linalg.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_from_padded_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c80 = arith.constant 80 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg1[0] [%c8] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c8, %c80] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0] [%c8, %c80] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: f32, %out: f32): + %0 = linalg.index 1 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.cmpi slt, %1, %in : i32 + %3 = arith.select %2, %in_2, %cst : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu.mlir new file mode 100644 index 000000000000..49d7c141476b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_matmul_broadcast_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 20 { + %0 = affine.for %arg6 = 0 to 24 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4, %arg6] : memref + %2 = affine.load %arg1[%arg6, %arg5] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg7, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu/debuf.mlir new file mode 100644 index 000000000000..786b52a5aba7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu/debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_matmul_broadcast_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c24, %c20] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu/matched.mlir new file mode 100644 index 000000000000..9c9f389ba69a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_matmul_broadcast_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c24, %c20] [1, 1] : tensor to tensor + %4 = kernel.launch @cublasSgemm_strided_batched_broadcast_rhs(%extracted_slice_0, %extracted_slice_1, %extracted_slice) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu/orig.mlir new file mode 100644 index 000000000000..49d7c141476b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_matmul_broadcast_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 20 { + %0 = affine.for %arg6 = 0 to 24 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4, %arg6] : memref + %2 = affine.load %arg1[%arg6, %arg5] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg7, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu/raised.mlir new file mode 100644 index 000000000000..2a3a1c4d24e6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_matmul_broadcast_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %c20 = arith.constant 20 : index + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0] [%c24, %c20] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu_debuf.mlir new file mode 100644 index 000000000000..786b52a5aba7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu_debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_matmul_broadcast_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c24, %c20] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu_linalg.mlir new file mode 100644 index 000000000000..2a3a1c4d24e6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_matmul_broadcast_cpu_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_matmul_broadcast_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %c20 = arith.constant 20 : index + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0] [%c24, %c20] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0, 0] [%c8, %c16, %c20] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_pad_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_pad_cpu.mlir new file mode 100644 index 000000000000..93f00dacbec9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_pad_cpu.mlir @@ -0,0 +1,18 @@ +#set = affine_set<(d0) : (-d0 + 63 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_pad_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 8 { + affine.for %arg3 = 0 to 80 { + %0 = affine.if #set(%arg3) -> f32 { + %1 = affine.load %arg0[%arg2, %arg3] : memref + affine.yield %1 : f32 + } else { + affine.yield %cst : f32 + } + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_pad_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_pad_cpu/debuf.mlir new file mode 100644 index 000000000000..cdd584d16b72 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_pad_cpu/debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (-d0 + 63)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_pad_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c80 = arith.constant 80 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = linalg.index 1 : index + %5 = affine.apply #map1(%4) + %6 = arith.cmpi sge, %5, %c0 : index + %7 = arith.select %6, %in, %cst : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c8, %c80] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_pad_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_pad_cpu/matched.mlir new file mode 100644 index 000000000000..cdd584d16b72 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_pad_cpu/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (-d0 + 63)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_pad_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c80 = arith.constant 80 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = linalg.index 1 : index + %5 = affine.apply #map1(%4) + %6 = arith.cmpi sge, %5, %c0 : index + %7 = arith.select %6, %in, %cst : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c8, %c80] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_pad_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_pad_cpu/orig.mlir new file mode 100644 index 000000000000..93f00dacbec9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_pad_cpu/orig.mlir @@ -0,0 +1,18 @@ +#set = affine_set<(d0) : (-d0 + 63 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_pad_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 8 { + affine.for %arg3 = 0 to 80 { + %0 = affine.if #set(%arg3) -> f32 { + %1 = affine.load %arg0[%arg2, %arg3] : memref + affine.yield %1 : f32 + } else { + affine.yield %cst : f32 + } + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_pad_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_pad_cpu/raised.mlir new file mode 100644 index 000000000000..0bdb9ba1d500 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_pad_cpu/raised.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (-d0 + 63)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_pad_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c80 = arith.constant 80 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg0[0, 0] [%c8, %c80] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c80] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = linalg.index 1 : index + %1 = affine.apply #map1(%0) + %2 = arith.cmpi sge, %1, %c0 : index + %3 = arith.select %2, %in, %cst : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_pad_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_pad_cpu_debuf.mlir new file mode 100644 index 000000000000..cdd584d16b72 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_pad_cpu_debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (-d0 + 63)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_pad_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c80 = arith.constant 80 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = linalg.index 1 : index + %5 = affine.apply #map1(%4) + %6 = arith.cmpi sge, %5, %c0 : index + %7 = arith.select %6, %in, %cst : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c8, %c80] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_pad_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_pad_cpu_linalg.mlir new file mode 100644 index 000000000000..0bdb9ba1d500 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_pad_cpu_linalg.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (-d0 + 63)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_pad_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c80 = arith.constant 80 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg0[0, 0] [%c8, %c80] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c80] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = linalg.index 1 : index + %1 = affine.apply #map1(%0) + %2 = arith.cmpi sge, %1, %c0 : index + %3 = arith.select %2, %in, %cst : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_select_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_select_cpu.mlir new file mode 100644 index 000000000000..f2de1d7ea0f7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_select_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_select_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 8 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%arg3, %1] : memref + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_select_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_select_cpu/debuf.mlir new file mode 100644 index 000000000000..0ca23c868901 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_select_cpu/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_select_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%3, %5] : memref + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_select_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_select_cpu/matched.mlir new file mode 100644 index 000000000000..0ca23c868901 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_select_cpu/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_select_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%3, %5] : memref + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_select_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_select_cpu/orig.mlir new file mode 100644 index 000000000000..f2de1d7ea0f7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_select_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_select_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 8 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%arg3, %1] : memref + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_select_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_select_cpu/raised.mlir new file mode 100644 index 000000000000..6c95a58517ed --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_select_cpu/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_select_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg1[%0] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%0, %2] : memref + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_select_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_select_cpu_debuf.mlir new file mode 100644 index 000000000000..0ca23c868901 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_select_cpu_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_select_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%3, %5] : memref + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_select_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_select_cpu_linalg.mlir new file mode 100644 index 000000000000..6c95a58517ed --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_select_cpu_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_select_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg1[%0] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%0, %2] : memref + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu.mlir new file mode 100644 index 000000000000..52c6fdfb0eed --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + %0 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg3, %arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.for %arg4 = 0 to 64 { + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = affine.load %arg0[%arg3, %arg4] : memref + %3 = arith.subf %2, %0 : f32 + %4 = arith.mulf %1, %3 : f32 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..5185c5d74ec2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu/debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %2) -> (tensor) { + %alloca = memref.alloca() : memref + %7 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %7[] : tensor + %extracted_slice = tensor.extract_slice %4[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %10 = arith.mulf %in, %in_4 : f32 + %11 = arith.addf %out, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %extracted = tensor.extract %8[] : tensor + %extracted_slice_1 = tensor.extract_slice %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %1[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3, %extracted_slice_2 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %10 = arith.subf %in_4, %extracted : f32 + %11 = arith.mulf %in, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %9 into %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu/matched.mlir new file mode 100644 index 000000000000..a73df798c549 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu/matched.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %2) -> (tensor) { + %alloca = memref.alloca() : memref + %7 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %7[] : tensor + %extracted_slice = tensor.extract_slice %4[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %8 = kernel.launch @cublasSdot(%extracted_slice, %extracted_slice_0, %inserted) : (tensor, tensor, tensor) -> tensor + %extracted = tensor.extract %8[] : tensor + %extracted_slice_1 = tensor.extract_slice %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %1[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3, %extracted_slice_2 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %10 = arith.subf %in_4, %extracted : f32 + %11 = arith.mulf %in, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %9 into %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu/orig.mlir new file mode 100644 index 000000000000..52c6fdfb0eed --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + %0 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg3, %arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.for %arg4 = 0 to 64 { + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = affine.load %arg0[%arg3, %arg4] : memref + %3 = arith.subf %2, %0 : f32 + %4 = arith.mulf %1, %3 : f32 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu/raised.mlir new file mode 100644 index 000000000000..96df7d3752ae --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu/raised.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %1 = arith.mulf %in, %in_5 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + %0 = affine.load %alloca[] : memref + %subview_2 = memref.subview %arg1[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg0[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg2[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%subview_2, %subview_3 : memref>, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %1 = arith.subf %in_5, %0 : f32 + %2 = arith.mulf %in, %1 : f32 + linalg.yield %2 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..5185c5d74ec2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu_debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %2) -> (tensor) { + %alloca = memref.alloca() : memref + %7 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %7[] : tensor + %extracted_slice = tensor.extract_slice %4[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %10 = arith.mulf %in, %in_4 : f32 + %11 = arith.addf %out, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %extracted = tensor.extract %8[] : tensor + %extracted_slice_1 = tensor.extract_slice %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %1[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3, %extracted_slice_2 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %10 = arith.subf %in_4, %extracted : f32 + %11 = arith.mulf %in, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %9 into %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..96df7d3752ae --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_backward_cpu_linalg.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %1 = arith.mulf %in, %in_5 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + %0 = affine.load %alloca[] : memref + %subview_2 = memref.subview %arg1[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg0[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg2[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%subview_2, %subview_3 : memref>, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %1 = arith.subf %in_5, %0 : f32 + %2 = arith.mulf %in, %1 : f32 + linalg.yield %2 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_cpu.mlir new file mode 100644 index 000000000000..f5ffe19cafc7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_cpu.mlir @@ -0,0 +1,38 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 8 { + %0:2 = scf.while (%arg4 = %c0_i32, %arg5 = %cst) : (i32, f32) -> (f32, i32) { + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.cmpi slt, %arg4, %2 : i32 + scf.condition(%3) %arg5, %arg4 : f32, i32 + } do { + ^bb0(%arg4: f32, %arg5: i32): + %2 = arith.index_cast %arg5 : i32 to index + %3 = memref.load %arg0[%arg3, %2] : memref + %4 = math.exp %3 : f32 + memref.store %4, %arg2[%arg3, %2] : memref + %5 = memref.load %arg2[%arg3, %2] : memref + %6 = arith.addf %arg4, %5 : f32 + %7 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %7, %6 : i32, f32 + } + %1 = scf.while (%arg4 = %c0_i32) : (i32) -> i32 { + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.cmpi slt, %arg4, %2 : i32 + scf.condition(%3) %arg4 : i32 + } do { + ^bb0(%arg4: i32): + %2 = arith.index_cast %arg4 : i32 to index + %3 = memref.load %arg2[%arg3, %2] : memref + %4 = arith.divf %3, %0#0 : f32 + memref.store %4, %arg2[%arg3, %2] : memref + %5 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %5 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_cpu/debuf.mlir new file mode 100644 index 000000000000..9beb2468f003 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_cpu/debuf.mlir @@ -0,0 +1,45 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %5:3 = scf.while (%arg5 = %c0_i32, %arg6 = %cst, %arg7 = %arg4) : (i32, f32, tensor) -> (f32, i32, tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %7 = arith.cmpi slt, %arg5, %extracted : i32 + scf.condition(%7) %arg6, %arg5, %arg7 : f32, i32, tensor + } do { + ^bb0(%arg5: f32, %arg6: i32, %arg7: tensor): + %7 = arith.index_cast %arg6 : i32 to index + %extracted = tensor.extract %2[%arg3, %7] : tensor + %8 = math.exp %extracted : f32 + %inserted = tensor.insert %8 into %arg7[%arg3, %7] : tensor + %extracted_0 = tensor.extract %inserted[%arg3, %7] : tensor + %9 = arith.addf %arg5, %extracted_0 : f32 + %10 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %10, %9, %inserted : i32, f32, tensor + } + %6:2 = scf.while (%arg5 = %c0_i32, %arg6 = %5#2) : (i32, tensor) -> (i32, tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %7 = arith.cmpi slt, %arg5, %extracted : i32 + scf.condition(%7) %arg5, %arg6 : i32, tensor + } do { + ^bb0(%arg5: i32, %arg6: tensor): + %7 = arith.index_cast %arg5 : i32 to index + %extracted = tensor.extract %arg6[%arg3, %7] : tensor + %8 = arith.divf %extracted, %5#0 : f32 + %inserted = tensor.insert %8 into %arg6[%arg3, %7] : tensor + %9 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %9, %inserted : i32, tensor + } + affine.yield %6#1 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_cpu/matched.mlir new file mode 100644 index 000000000000..9beb2468f003 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_cpu/matched.mlir @@ -0,0 +1,45 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %5:3 = scf.while (%arg5 = %c0_i32, %arg6 = %cst, %arg7 = %arg4) : (i32, f32, tensor) -> (f32, i32, tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %7 = arith.cmpi slt, %arg5, %extracted : i32 + scf.condition(%7) %arg6, %arg5, %arg7 : f32, i32, tensor + } do { + ^bb0(%arg5: f32, %arg6: i32, %arg7: tensor): + %7 = arith.index_cast %arg6 : i32 to index + %extracted = tensor.extract %2[%arg3, %7] : tensor + %8 = math.exp %extracted : f32 + %inserted = tensor.insert %8 into %arg7[%arg3, %7] : tensor + %extracted_0 = tensor.extract %inserted[%arg3, %7] : tensor + %9 = arith.addf %arg5, %extracted_0 : f32 + %10 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %10, %9, %inserted : i32, f32, tensor + } + %6:2 = scf.while (%arg5 = %c0_i32, %arg6 = %5#2) : (i32, tensor) -> (i32, tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %7 = arith.cmpi slt, %arg5, %extracted : i32 + scf.condition(%7) %arg5, %arg6 : i32, tensor + } do { + ^bb0(%arg5: i32, %arg6: tensor): + %7 = arith.index_cast %arg5 : i32 to index + %extracted = tensor.extract %arg6[%arg3, %7] : tensor + %8 = arith.divf %extracted, %5#0 : f32 + %inserted = tensor.insert %8 into %arg6[%arg3, %7] : tensor + %9 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %9, %inserted : i32, tensor + } + affine.yield %6#1 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_cpu/orig.mlir new file mode 100644 index 000000000000..f5ffe19cafc7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_cpu/orig.mlir @@ -0,0 +1,38 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 8 { + %0:2 = scf.while (%arg4 = %c0_i32, %arg5 = %cst) : (i32, f32) -> (f32, i32) { + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.cmpi slt, %arg4, %2 : i32 + scf.condition(%3) %arg5, %arg4 : f32, i32 + } do { + ^bb0(%arg4: f32, %arg5: i32): + %2 = arith.index_cast %arg5 : i32 to index + %3 = memref.load %arg0[%arg3, %2] : memref + %4 = math.exp %3 : f32 + memref.store %4, %arg2[%arg3, %2] : memref + %5 = memref.load %arg2[%arg3, %2] : memref + %6 = arith.addf %arg4, %5 : f32 + %7 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %7, %6 : i32, f32 + } + %1 = scf.while (%arg4 = %c0_i32) : (i32) -> i32 { + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.cmpi slt, %arg4, %2 : i32 + scf.condition(%3) %arg4 : i32 + } do { + ^bb0(%arg4: i32): + %2 = arith.index_cast %arg4 : i32 to index + %3 = memref.load %arg2[%arg3, %2] : memref + %4 = arith.divf %3, %0#0 : f32 + memref.store %4, %arg2[%arg3, %2] : memref + %5 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %5 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_cpu/raised.mlir new file mode 100644 index 000000000000..8338c78c18bc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_cpu/raised.mlir @@ -0,0 +1,39 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 8 { + %0:2 = scf.while (%arg4 = %c0_i32, %arg5 = %cst) : (i32, f32) -> (f32, i32) { + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.cmpi slt, %arg4, %2 : i32 + scf.condition(%3) %arg5, %arg4 : f32, i32 + } do { + ^bb0(%arg4: f32, %arg5: i32): + %2 = arith.index_cast %arg5 : i32 to index + %3 = memref.load %arg0[%arg3, %2] : memref + %4 = math.exp %3 : f32 + memref.store %4, %arg2[%arg3, %2] : memref + %5 = memref.load %arg2[%arg3, %2] : memref + %6 = arith.addf %arg4, %5 : f32 + %7 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %7, %6 : i32, f32 + } + %1 = scf.while (%arg4 = %c0_i32) : (i32) -> i32 { + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.cmpi slt, %arg4, %2 : i32 + scf.condition(%3) %arg4 : i32 + } do { + ^bb0(%arg4: i32): + %2 = arith.index_cast %arg4 : i32 to index + %3 = memref.load %arg2[%arg3, %2] : memref + %4 = arith.divf %3, %0#0 : f32 + memref.store %4, %arg2[%arg3, %2] : memref + %5 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %5 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_cpu_debuf.mlir new file mode 100644 index 000000000000..9beb2468f003 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_cpu_debuf.mlir @@ -0,0 +1,45 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %5:3 = scf.while (%arg5 = %c0_i32, %arg6 = %cst, %arg7 = %arg4) : (i32, f32, tensor) -> (f32, i32, tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %7 = arith.cmpi slt, %arg5, %extracted : i32 + scf.condition(%7) %arg6, %arg5, %arg7 : f32, i32, tensor + } do { + ^bb0(%arg5: f32, %arg6: i32, %arg7: tensor): + %7 = arith.index_cast %arg6 : i32 to index + %extracted = tensor.extract %2[%arg3, %7] : tensor + %8 = math.exp %extracted : f32 + %inserted = tensor.insert %8 into %arg7[%arg3, %7] : tensor + %extracted_0 = tensor.extract %inserted[%arg3, %7] : tensor + %9 = arith.addf %arg5, %extracted_0 : f32 + %10 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %10, %9, %inserted : i32, f32, tensor + } + %6:2 = scf.while (%arg5 = %c0_i32, %arg6 = %5#2) : (i32, tensor) -> (i32, tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %7 = arith.cmpi slt, %arg5, %extracted : i32 + scf.condition(%7) %arg5, %arg6 : i32, tensor + } do { + ^bb0(%arg5: i32, %arg6: tensor): + %7 = arith.index_cast %arg5 : i32 to index + %extracted = tensor.extract %arg6[%arg3, %7] : tensor + %8 = arith.divf %extracted, %5#0 : f32 + %inserted = tensor.insert %8 into %arg6[%arg3, %7] : tensor + %9 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %9, %inserted : i32, tensor + } + affine.yield %6#1 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_cpu_linalg.mlir new file mode 100644 index 000000000000..8338c78c18bc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_cpu_linalg.mlir @@ -0,0 +1,39 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 8 { + %0:2 = scf.while (%arg4 = %c0_i32, %arg5 = %cst) : (i32, f32) -> (f32, i32) { + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.cmpi slt, %arg4, %2 : i32 + scf.condition(%3) %arg5, %arg4 : f32, i32 + } do { + ^bb0(%arg4: f32, %arg5: i32): + %2 = arith.index_cast %arg5 : i32 to index + %3 = memref.load %arg0[%arg3, %2] : memref + %4 = math.exp %3 : f32 + memref.store %4, %arg2[%arg3, %2] : memref + %5 = memref.load %arg2[%arg3, %2] : memref + %6 = arith.addf %arg4, %5 : f32 + %7 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %7, %6 : i32, f32 + } + %1 = scf.while (%arg4 = %c0_i32) : (i32) -> i32 { + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.cmpi slt, %arg4, %2 : i32 + scf.condition(%3) %arg4 : i32 + } do { + ^bb0(%arg4: i32): + %2 = arith.index_cast %arg4 : i32 to index + %3 = memref.load %arg2[%arg3, %2] : memref + %4 = arith.divf %3, %0#0 : f32 + memref.store %4, %arg2[%arg3, %2] : memref + %5 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %5 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu.mlir new file mode 100644 index 000000000000..28cd2be0ac3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_dropout_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + %0 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = math.exp %1 : f32 + %3 = affine.load %arg1[%arg3, %arg4] : memref + %4 = arith.mulf %2, %3 : f32 + affine.store %4, %arg2[%arg3, %arg4] : memref + %5 = arith.addf %arg5, %4 : f32 + affine.yield %5 : f32 + } + affine.for %arg4 = 0 to 64 { + %1 = affine.load %arg2[%arg3, %arg4] : memref + %2 = arith.divf %1, %0 : f32 + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu/debuf.mlir new file mode 100644 index 000000000000..4807c3c2a00e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu/debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_dropout_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %alloca = memref.alloca() : memref + %5 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %5[] : tensor + %extracted_slice = tensor.extract_slice %2[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %6:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1, %inserted : tensor, tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32, %out_3: f32): + %8 = math.exp %in : f32 + %9 = arith.mulf %8, %in_2 : f32 + %10 = arith.addf %out_3, %9 : f32 + linalg.yield %9, %10 : f32, f32 + } -> (tensor, tensor) + %extracted = tensor.extract %6#1[] : tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%6#0 : tensor) { + ^bb0(%out: f32): + %8 = arith.divf %out, %extracted : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %7 into %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu/matched.mlir new file mode 100644 index 000000000000..4807c3c2a00e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu/matched.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_dropout_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %alloca = memref.alloca() : memref + %5 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %5[] : tensor + %extracted_slice = tensor.extract_slice %2[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %6:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1, %inserted : tensor, tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32, %out_3: f32): + %8 = math.exp %in : f32 + %9 = arith.mulf %8, %in_2 : f32 + %10 = arith.addf %out_3, %9 : f32 + linalg.yield %9, %10 : f32, f32 + } -> (tensor, tensor) + %extracted = tensor.extract %6#1[] : tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%6#0 : tensor) { + ^bb0(%out: f32): + %8 = arith.divf %out, %extracted : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %7 into %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu/orig.mlir new file mode 100644 index 000000000000..28cd2be0ac3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_dropout_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + %0 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = math.exp %1 : f32 + %3 = affine.load %arg1[%arg3, %arg4] : memref + %4 = arith.mulf %2, %3 : f32 + affine.store %4, %arg2[%arg3, %arg4] : memref + %5 = arith.addf %arg5, %4 : f32 + affine.yield %5 : f32 + } + affine.for %arg4 = 0 to 64 { + %1 = affine.load %arg2[%arg3, %arg4] : memref + %2 = arith.divf %1, %0 : f32 + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu/raised.mlir new file mode 100644 index 000000000000..43e35f67f50e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu/raised.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_dropout_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_2 = memref.subview %alloca[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map1], iterator_types = ["reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1, %subview_2 : memref>, memref>) { + ^bb0(%in: f32, %in_4: f32, %out: f32, %out_5: f32): + %1 = math.exp %in : f32 + %2 = arith.mulf %1, %in_4 : f32 + %3 = arith.addf %out_5, %2 : f32 + linalg.yield %2, %3 : f32, f32 + } + %0 = affine.load %alloca[] : memref + %subview_3 = memref.subview %arg2[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview_3 : memref>) { + ^bb0(%out: f32): + %1 = arith.divf %out, %0 : f32 + linalg.yield %1 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu_debuf.mlir new file mode 100644 index 000000000000..4807c3c2a00e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu_debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_dropout_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %alloca = memref.alloca() : memref + %5 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %5[] : tensor + %extracted_slice = tensor.extract_slice %2[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %6:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1, %inserted : tensor, tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32, %out_3: f32): + %8 = math.exp %in : f32 + %9 = arith.mulf %8, %in_2 : f32 + %10 = arith.addf %out_3, %9 : f32 + linalg.yield %9, %10 : f32, f32 + } -> (tensor, tensor) + %extracted = tensor.extract %6#1[] : tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%6#0 : tensor) { + ^bb0(%out: f32): + %8 = arith.divf %out, %extracted : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %7 into %arg4[%arg3, 0] [1, %c64] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu_linalg.mlir new file mode 100644 index 000000000000..43e35f67f50e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_softmax_dropout_cpu_linalg.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_softmax_dropout_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + %subview_2 = memref.subview %alloca[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map1], iterator_types = ["reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1, %subview_2 : memref>, memref>) { + ^bb0(%in: f32, %in_4: f32, %out: f32, %out_5: f32): + %1 = math.exp %in : f32 + %2 = arith.mulf %1, %in_4 : f32 + %3 = arith.addf %out_5, %2 : f32 + linalg.yield %2, %3 : f32, f32 + } + %0 = affine.load %alloca[] : memref + %subview_3 = memref.subview %arg2[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview_3 : memref>) { + ^bb0(%out: f32): + %1 = arith.divf %out, %0 : f32 + linalg.yield %1 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_squeeze_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_squeeze_cpu.mlir new file mode 100644 index 000000000000..378fbf41c36d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_squeeze_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_squeeze_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 8 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg2, 0, %arg3] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_squeeze_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_squeeze_cpu/debuf.mlir new file mode 100644 index 000000000000..bc50404ab912 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_squeeze_cpu/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_squeeze_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c8, 1, %c64] [1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_squeeze_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_squeeze_cpu/matched.mlir new file mode 100644 index 000000000000..4fb55c97b5b0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_squeeze_cpu/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_squeeze_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c8, 1, %c64] [1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %2 = kernel.launch @cudaCopy2D_f32_tensor(%extracted_slice, %extracted_slice_0) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_squeeze_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_squeeze_cpu/orig.mlir new file mode 100644 index 000000000000..378fbf41c36d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_squeeze_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_squeeze_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 8 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg2, 0, %arg3] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_squeeze_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_squeeze_cpu/raised.mlir new file mode 100644 index 000000000000..780b66eb201e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_squeeze_cpu/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_squeeze_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 0, 0] [%c8, 1, %c64] [1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_squeeze_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_squeeze_cpu_debuf.mlir new file mode 100644 index 000000000000..bc50404ab912 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_squeeze_cpu_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_squeeze_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c8, 1, %c64] [1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_squeeze_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_squeeze_cpu_linalg.mlir new file mode 100644 index 000000000000..780b66eb201e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_squeeze_cpu_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_squeeze_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 0, 0] [%c8, 1, %c64] [1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu.mlir new file mode 100644 index 000000000000..6830c30fe23a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_sum_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 8 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg2] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..9ea33a387383 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu/debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_sum_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu/matched.mlir new file mode 100644 index 000000000000..9ea33a387383 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_sum_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu/orig.mlir new file mode 100644 index 000000000000..6830c30fe23a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_sum_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 8 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg2] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu/raised.mlir new file mode 100644 index 000000000000..73c3fd6ed520 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_sum_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0] [%c8] [1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..9ea33a387383 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu_debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_sum_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..73c3fd6ed520 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_sum_backward_cpu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_sum_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0] [%c8] [1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu.mlir new file mode 100644 index 000000000000..b2f11d11c5c7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_sum_dim_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = scf.for %arg4 = %c0 to %1 step %c1 iter_args(%arg5 = %cst) -> (f32) { + %3 = memref.load %arg0[%arg3, %arg4] : memref + %4 = arith.addf %arg5, %3 : f32 + scf.yield %4 : f32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu/debuf.mlir new file mode 100644 index 000000000000..180dcbb1f168 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu/debuf.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_sum_dim_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %5 = arith.index_cast %extracted : i32 to index + %6 = scf.for %arg5 = %c0 to %5 step %c1 iter_args(%arg6 = %cst) -> (f32) { + %extracted_0 = tensor.extract %2[%arg3, %arg5] : tensor + %7 = arith.addf %arg6, %extracted_0 : f32 + scf.yield %7 : f32 + } + %inserted = tensor.insert %6 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu/matched.mlir new file mode 100644 index 000000000000..180dcbb1f168 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu/matched.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_sum_dim_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %5 = arith.index_cast %extracted : i32 to index + %6 = scf.for %arg5 = %c0 to %5 step %c1 iter_args(%arg6 = %cst) -> (f32) { + %extracted_0 = tensor.extract %2[%arg3, %arg5] : tensor + %7 = arith.addf %arg6, %extracted_0 : f32 + scf.yield %7 : f32 + } + %inserted = tensor.insert %6 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu/orig.mlir new file mode 100644 index 000000000000..b2f11d11c5c7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu/orig.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_sum_dim_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = scf.for %arg4 = %c0 to %1 step %c1 iter_args(%arg5 = %cst) -> (f32) { + %3 = memref.load %arg0[%arg3, %arg4] : memref + %4 = arith.addf %arg5, %3 : f32 + scf.yield %4 : f32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu/raised.mlir new file mode 100644 index 000000000000..3e8537fdc3a9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu/raised.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_sum_dim_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = scf.for %arg4 = %c0 to %1 step %c1 iter_args(%arg5 = %cst) -> (f32) { + %3 = memref.load %arg0[%arg3, %arg4] : memref + %4 = arith.addf %arg5, %3 : f32 + scf.yield %4 : f32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu_debuf.mlir new file mode 100644 index 000000000000..180dcbb1f168 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu_debuf.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_sum_dim_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %5 = arith.index_cast %extracted : i32 to index + %6 = scf.for %arg5 = %c0 to %5 step %c1 iter_args(%arg6 = %cst) -> (f32) { + %extracted_0 = tensor.extract %2[%arg3, %arg5] : tensor + %7 = arith.addf %arg6, %extracted_0 : f32 + scf.yield %7 : f32 + } + %inserted = tensor.insert %6 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu_linalg.mlir new file mode 100644 index 000000000000..3e8537fdc3a9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_sum_dim_cpu_linalg.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_sum_dim_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = scf.for %arg4 = %c0 to %1 step %c1 iter_args(%arg5 = %cst) -> (f32) { + %3 = memref.load %arg0[%arg3, %arg4] : memref + %4 = arith.addf %arg5, %3 : f32 + scf.yield %4 : f32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_to_mask_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_to_mask_cpu.mlir new file mode 100644 index 000000000000..7f52bb9145cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_to_mask_cpu.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_to_mask_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 8 { + affine.for %arg3 = 0 to 64 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = affine.load %arg0[%arg2] : memref + %2 = arith.cmpi slt, %0, %1 : i32 + %3 = arith.extui %2 : i1 to i32 + affine.store %3, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_to_mask_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_to_mask_cpu/debuf.mlir new file mode 100644 index 000000000000..8ea16ddf117b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_to_mask_cpu/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_to_mask_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.cmpi slt, %5, %in : i32 + %7 = arith.extui %6 : i1 to i32 + linalg.yield %7 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_to_mask_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_to_mask_cpu/matched.mlir new file mode 100644 index 000000000000..8ea16ddf117b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_to_mask_cpu/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_to_mask_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.cmpi slt, %5, %in : i32 + %7 = arith.extui %6 : i1 to i32 + linalg.yield %7 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_to_mask_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_to_mask_cpu/orig.mlir new file mode 100644 index 000000000000..7f52bb9145cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_to_mask_cpu/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_to_mask_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 8 { + affine.for %arg3 = 0 to 64 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = affine.load %arg0[%arg2] : memref + %2 = arith.cmpi slt, %0, %1 : i32 + %3 = arith.extui %2 : i1 to i32 + affine.store %3, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_to_mask_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_to_mask_cpu/raised.mlir new file mode 100644 index 000000000000..548815fff3fd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_to_mask_cpu/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_to_mask_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0] [%c8] [1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: i32, %out: i32): + %0 = linalg.index 1 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.cmpi slt, %1, %in : i32 + %3 = arith.extui %2 : i1 to i32 + linalg.yield %3 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_to_mask_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_to_mask_cpu_debuf.mlir new file mode 100644 index 000000000000..8ea16ddf117b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_to_mask_cpu_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_to_mask_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.cmpi slt, %5, %in : i32 + %7 = arith.extui %6 : i1 to i32 + linalg.yield %7 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_to_mask_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_to_mask_cpu_linalg.mlir new file mode 100644 index 000000000000..548815fff3fd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_to_mask_cpu_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_to_mask_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0] [%c8] [1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: i32, %out: i32): + %0 = linalg.index 1 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.cmpi slt, %1, %in : i32 + %3 = arith.extui %2 : i1 to i32 + linalg.yield %3 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_to_padded_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_to_padded_cpu.mlir new file mode 100644 index 000000000000..e9b1bc95c73e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_to_padded_cpu.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_to_padded_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 80 { + %0 = arith.index_cast %arg5 : index to i32 + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.cmpi slt, %0, %1 : i32 + %3 = scf.if %2 -> (f32) { + %4 = affine.load %arg0[%arg4, %arg5] : memref + scf.yield %4 : f32 + } else { + scf.yield %arg2 : f32 + } + affine.store %3, %arg3[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_to_padded_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_to_padded_cpu/debuf.mlir new file mode 100644 index 000000000000..80d926b62c3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_to_padded_cpu/debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_to_padded_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c80 = arith.constant 80 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %1[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: f32, %out: f32): + %5 = linalg.index 1 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.cmpi slt, %6, %in : i32 + %8 = arith.select %7, %in_2, %arg2 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c8, %c80] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_to_padded_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_to_padded_cpu/matched.mlir new file mode 100644 index 000000000000..80d926b62c3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_to_padded_cpu/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_to_padded_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c80 = arith.constant 80 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %1[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: f32, %out: f32): + %5 = linalg.index 1 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.cmpi slt, %6, %in : i32 + %8 = arith.select %7, %in_2, %arg2 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c8, %c80] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_to_padded_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_to_padded_cpu/orig.mlir new file mode 100644 index 000000000000..e9b1bc95c73e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_to_padded_cpu/orig.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_to_padded_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 80 { + %0 = arith.index_cast %arg5 : index to i32 + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.cmpi slt, %0, %1 : i32 + %3 = scf.if %2 -> (f32) { + %4 = affine.load %arg0[%arg4, %arg5] : memref + scf.yield %4 : f32 + } else { + scf.yield %arg2 : f32 + } + affine.store %3, %arg3[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_to_padded_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_to_padded_cpu/raised.mlir new file mode 100644 index 000000000000..543373f9a772 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_to_padded_cpu/raised.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_to_padded_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c80 = arith.constant 80 : index + %subview = memref.subview %arg1[0] [%c8] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c8, %c80] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg3[0, 0] [%c8, %c80] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: f32, %out: f32): + %0 = linalg.index 1 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.cmpi slt, %1, %in : i32 + %3 = arith.select %2, %in_2, %arg2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_to_padded_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_to_padded_cpu_debuf.mlir new file mode 100644 index 000000000000..80d926b62c3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_to_padded_cpu_debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_to_padded_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c80 = arith.constant 80 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %1[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c8, %c80] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: f32, %out: f32): + %5 = linalg.index 1 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.cmpi slt, %6, %in : i32 + %8 = arith.select %7, %in_2, %arg2 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c8, %c80] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_to_padded_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_to_padded_cpu_linalg.mlir new file mode 100644 index 000000000000..543373f9a772 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_to_padded_cpu_linalg.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_to_padded_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c80 = arith.constant 80 : index + %subview = memref.subview %arg1[0] [%c8] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c8, %c80] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg3[0, 0] [%c8, %c80] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: f32, %out: f32): + %0 = linalg.index 1 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.cmpi slt, %1, %in : i32 + %3 = arith.select %2, %in_2, %arg2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_where_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_where_cpu.mlir new file mode 100644 index 000000000000..0fa5c4d19d4d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_where_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_where_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg0[%arg4, %arg5] : memref + %1 = arith.cmpi ne, %0, %c0_i32 : i32 + %2 = scf.if %1 -> (f32) { + %3 = affine.load %arg1[%arg4, %arg5] : memref + scf.yield %3 : f32 + } else { + %3 = affine.load %arg2[%arg4, %arg5] : memref + scf.yield %3 : f32 + } + affine.store %2, %arg3[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_where_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_where_cpu/debuf.mlir new file mode 100644 index 000000000000..57496b9ddc2e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_where_cpu/debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_where_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %3[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1 : tensor, tensor, tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: i32, %in_3: f32, %in_4: f32, %out: f32): + %6 = arith.cmpi ne, %in, %c0_i32 : i32 + %7 = arith.select %6, %in_3, %in_4 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_where_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_where_cpu/matched.mlir new file mode 100644 index 000000000000..57496b9ddc2e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_where_cpu/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_where_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %3[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1 : tensor, tensor, tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: i32, %in_3: f32, %in_4: f32, %out: f32): + %6 = arith.cmpi ne, %in, %c0_i32 : i32 + %7 = arith.select %6, %in_3, %in_4 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_where_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_where_cpu/orig.mlir new file mode 100644 index 000000000000..0fa5c4d19d4d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_where_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_where_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg0[%arg4, %arg5] : memref + %1 = arith.cmpi ne, %0, %c0_i32 : i32 + %2 = scf.if %1 -> (f32) { + %3 = affine.load %arg1[%arg4, %arg5] : memref + scf.yield %3 : f32 + } else { + %3 = affine.load %arg2[%arg4, %arg5] : memref + scf.yield %3 : f32 + } + affine.store %2, %arg3[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_where_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_where_cpu/raised.mlir new file mode 100644 index 000000000000..9fba41e3f3af --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_where_cpu/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_where_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c64 = arith.constant 64 : index + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg0[0, 0] [%c8, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0] [%c8, %c64] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg3[0, 0] [%c8, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview, %subview_0, %subview_1 : memref>, memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: i32, %in_3: f32, %in_4: f32, %out: f32): + %0 = arith.cmpi ne, %in, %c0_i32 : i32 + %1 = arith.select %0, %in_3, %in_4 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_where_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_where_cpu_debuf.mlir new file mode 100644 index 000000000000..57496b9ddc2e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_where_cpu_debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_where_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %3[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1 : tensor, tensor, tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: i32, %in_3: f32, %in_4: f32, %out: f32): + %6 = arith.cmpi ne, %in, %c0_i32 : i32 + %7 = arith.select %6, %in_3, %in_4 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_where_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_where_cpu_linalg.mlir new file mode 100644 index 000000000000..9fba41e3f3af --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_where_cpu_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_where_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c64 = arith.constant 64 : index + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg0[0, 0] [%c8, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0] [%c8, %c64] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg3[0, 0] [%c8, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview, %subview_0, %subview_1 : memref>, memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: i32, %in_3: f32, %in_4: f32, %out: f32): + %0 = arith.cmpi ne, %in, %c0_i32 : i32 + %1 = arith.select %0, %in_3, %in_4 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_where_out_cpu.mlir b/issues/aten_c_kernels/results/aten_nested_where_out_cpu.mlir new file mode 100644 index 000000000000..7601634a7503 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_where_out_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_where_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg0[%arg4, %arg5] : memref + %1 = arith.cmpi ne, %0, %c0_i32 : i32 + %2 = scf.if %1 -> (f32) { + %3 = affine.load %arg1[%arg4, %arg5] : memref + scf.yield %3 : f32 + } else { + %3 = affine.load %arg2[%arg4, %arg5] : memref + scf.yield %3 : f32 + } + affine.store %2, %arg3[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_where_out_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nested_where_out_cpu/debuf.mlir new file mode 100644 index 000000000000..b9484a352d27 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_where_out_cpu/debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_where_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %3[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1 : tensor, tensor, tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: i32, %in_3: f32, %in_4: f32, %out: f32): + %6 = arith.cmpi ne, %in, %c0_i32 : i32 + %7 = arith.select %6, %in_3, %in_4 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_where_out_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nested_where_out_cpu/matched.mlir new file mode 100644 index 000000000000..b9484a352d27 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_where_out_cpu/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_where_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %3[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1 : tensor, tensor, tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: i32, %in_3: f32, %in_4: f32, %out: f32): + %6 = arith.cmpi ne, %in, %c0_i32 : i32 + %7 = arith.select %6, %in_3, %in_4 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_where_out_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nested_where_out_cpu/orig.mlir new file mode 100644 index 000000000000..7601634a7503 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_where_out_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_where_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg0[%arg4, %arg5] : memref + %1 = arith.cmpi ne, %0, %c0_i32 : i32 + %2 = scf.if %1 -> (f32) { + %3 = affine.load %arg1[%arg4, %arg5] : memref + scf.yield %3 : f32 + } else { + %3 = affine.load %arg2[%arg4, %arg5] : memref + scf.yield %3 : f32 + } + affine.store %2, %arg3[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nested_where_out_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nested_where_out_cpu/raised.mlir new file mode 100644 index 000000000000..a9b4b16521bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_where_out_cpu/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_where_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c64 = arith.constant 64 : index + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg0[0, 0] [%c8, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0] [%c8, %c64] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg3[0, 0] [%c8, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview, %subview_0, %subview_1 : memref>, memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: i32, %in_3: f32, %in_4: f32, %out: f32): + %0 = arith.cmpi ne, %in, %c0_i32 : i32 + %1 = arith.select %0, %in_3, %in_4 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_where_out_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nested_where_out_cpu_debuf.mlir new file mode 100644 index 000000000000..b9484a352d27 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_where_out_cpu_debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_where_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %3[0, 0] [%c8, %c64] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0, %extracted_slice_1 : tensor, tensor, tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: i32, %in_3: f32, %in_4: f32, %out: f32): + %6 = arith.cmpi ne, %in, %c0_i32 : i32 + %7 = arith.select %6, %in_3, %in_4 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0, 0] [%c8, %c64] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nested_where_out_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nested_where_out_cpu_linalg.mlir new file mode 100644 index 000000000000..a9b4b16521bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nested_where_out_cpu_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nested_where_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c64 = arith.constant 64 : index + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg0[0, 0] [%c8, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c8, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0] [%c8, %c64] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg3[0, 0] [%c8, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview, %subview_0, %subview_1 : memref>, memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: i32, %in_3: f32, %in_4: f32, %out: f32): + %0 = arith.cmpi ne, %in, %c0_i32 : i32 + %1 = arith.select %0, %in_3, %in_4 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nextafter.mlir b/issues/aten_c_kernels/results/aten_nextafter.mlir new file mode 100644 index 000000000000..b3d13e049b84 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nextafter.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nextafter(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @nextafterf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @nextafterf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_nextafter/debuf.mlir b/issues/aten_c_kernels/results/aten_nextafter/debuf.mlir new file mode 100644 index 000000000000..a31f21173fcf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nextafter/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nextafter(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @nextafterf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @nextafterf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_nextafter/matched.mlir b/issues/aten_c_kernels/results/aten_nextafter/matched.mlir new file mode 100644 index 000000000000..a31f21173fcf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nextafter/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nextafter(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @nextafterf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @nextafterf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_nextafter/orig.mlir b/issues/aten_c_kernels/results/aten_nextafter/orig.mlir new file mode 100644 index 000000000000..b3d13e049b84 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nextafter/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nextafter(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @nextafterf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @nextafterf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_nextafter/raised.mlir b/issues/aten_c_kernels/results/aten_nextafter/raised.mlir new file mode 100644 index 000000000000..0455d1648d49 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nextafter/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nextafter(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @nextafterf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @nextafterf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_nextafter_debuf.mlir b/issues/aten_c_kernels/results/aten_nextafter_debuf.mlir new file mode 100644 index 000000000000..a31f21173fcf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nextafter_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nextafter(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @nextafterf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @nextafterf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_nextafter_linalg.mlir b/issues/aten_c_kernels/results/aten_nextafter_linalg.mlir new file mode 100644 index 000000000000..0455d1648d49 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nextafter_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nextafter(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @nextafterf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @nextafterf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu.mlir new file mode 100644 index 000000000000..b03f58e7c991 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg3) : (memref) -> !llvm.ptr + affine.for %arg4 = 0 to 8192 { + %1 = arith.index_cast %arg4 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 16 { + %1 = affine.load %arg1[%arg4, %arg5, %arg6] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg0[%arg4, %arg5, %arg6] : memref + %4 = arith.negf %3 : f32 + %5 = memref.load %arg2[%2] : memref + %6 = arith.mulf %4, %5 : f32 + memref.store %6, %arg3[%arg4, %2, %arg5, %arg6] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..3fcf51c404d2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu/debuf.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = "polygeist.memref2pointer"(%arg3) : (memref) -> !llvm.ptr + affine.for %arg4 = 0 to 8192 { + %4 = arith.index_cast %arg4 : index to i32 + %5 = llvm.getelementptr %3[%4] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %5 : f32, !llvm.ptr + } + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 16 { + %extracted = tensor.extract %1[%arg4, %arg5, %arg6] : tensor + %4 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg4, %arg5, %arg6] : tensor + %5 = arith.negf %extracted_0 : f32 + %extracted_1 = tensor.extract %0[%4] : tensor + %6 = arith.mulf %5, %extracted_1 : f32 + memref.store %6, %arg3[%arg4, %4, %arg5, %arg6] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..3fcf51c404d2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu/matched.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = "polygeist.memref2pointer"(%arg3) : (memref) -> !llvm.ptr + affine.for %arg4 = 0 to 8192 { + %4 = arith.index_cast %arg4 : index to i32 + %5 = llvm.getelementptr %3[%4] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %5 : f32, !llvm.ptr + } + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 16 { + %extracted = tensor.extract %1[%arg4, %arg5, %arg6] : tensor + %4 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg4, %arg5, %arg6] : tensor + %5 = arith.negf %extracted_0 : f32 + %extracted_1 = tensor.extract %0[%4] : tensor + %6 = arith.mulf %5, %extracted_1 : f32 + memref.store %6, %arg3[%arg4, %4, %arg5, %arg6] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..b03f58e7c991 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu/orig.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg3) : (memref) -> !llvm.ptr + affine.for %arg4 = 0 to 8192 { + %1 = arith.index_cast %arg4 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 16 { + %1 = affine.load %arg1[%arg4, %arg5, %arg6] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg0[%arg4, %arg5, %arg6] : memref + %4 = arith.negf %3 : f32 + %5 = memref.load %arg2[%2] : memref + %6 = arith.mulf %4, %5 : f32 + memref.store %6, %arg3[%arg4, %2, %arg5, %arg6] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..8e57748c511c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu/raised.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg3) : (memref) -> !llvm.ptr + affine.for %arg4 = 0 to 8192 { + %1 = arith.index_cast %arg4 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 16 { + %1 = affine.load %arg1[%arg4, %arg5, %arg6] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg0[%arg4, %arg5, %arg6] : memref + %4 = arith.negf %3 : f32 + %5 = memref.load %arg2[%2] : memref + %6 = arith.mulf %4, %5 : f32 + memref.store %6, %arg3[%arg4, %2, %arg5, %arg6] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..3fcf51c404d2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu_debuf.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = "polygeist.memref2pointer"(%arg3) : (memref) -> !llvm.ptr + affine.for %arg4 = 0 to 8192 { + %4 = arith.index_cast %arg4 : index to i32 + %5 = llvm.getelementptr %3[%4] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %5 : f32, !llvm.ptr + } + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 16 { + %extracted = tensor.extract %1[%arg4, %arg5, %arg6] : tensor + %4 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg4, %arg5, %arg6] : tensor + %5 = arith.negf %extracted_0 : f32 + %extracted_1 = tensor.extract %0[%4] : tensor + %6 = arith.mulf %5, %extracted_1 : f32 + memref.store %6, %arg3[%arg4, %4, %arg5, %arg6] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..8e57748c511c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss2d_backward_cpu_linalg.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss2d_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg3) : (memref) -> !llvm.ptr + affine.for %arg4 = 0 to 8192 { + %1 = arith.index_cast %arg4 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 16 { + %1 = affine.load %arg1[%arg4, %arg5, %arg6] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg0[%arg4, %arg5, %arg6] : memref + %4 = arith.negf %3 : f32 + %5 = memref.load %arg2[%2] : memref + %6 = arith.mulf %4, %5 : f32 + memref.store %6, %arg3[%arg4, %2, %arg5, %arg6] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu.mlir b/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu.mlir new file mode 100644 index 000000000000..27f525303ebe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss2d_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 16 { + %0 = affine.load %arg1[%arg4, %arg5, %arg6] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%arg4, %1, %arg5, %arg6] : memref + %3 = arith.negf %2 : f32 + %4 = memref.load %arg2[%1] : memref + %5 = arith.mulf %3, %4 : f32 + affine.store %5, %arg3[%arg4, %arg5, %arg6] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu/debuf.mlir new file mode 100644 index 000000000000..4f559240f167 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu/debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss2d_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c4, %c16, %c16] [1, 1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = linalg.index 2 : index + %6 = memref.load %arg1[%3, %4, %5] : memref + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg0[%3, %7, %4, %5] : memref + %9 = arith.negf %8 : f32 + %10 = memref.load %arg2[%7] : memref + %11 = arith.mulf %9, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0, 0] [%c4, %c16, %c16] [1, 1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu/matched.mlir new file mode 100644 index 000000000000..4f559240f167 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss2d_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c4, %c16, %c16] [1, 1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = linalg.index 2 : index + %6 = memref.load %arg1[%3, %4, %5] : memref + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg0[%3, %7, %4, %5] : memref + %9 = arith.negf %8 : f32 + %10 = memref.load %arg2[%7] : memref + %11 = arith.mulf %9, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0, 0] [%c4, %c16, %c16] [1, 1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu/orig.mlir new file mode 100644 index 000000000000..27f525303ebe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu/orig.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss2d_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 16 { + %0 = affine.load %arg1[%arg4, %arg5, %arg6] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%arg4, %1, %arg5, %arg6] : memref + %3 = arith.negf %2 : f32 + %4 = memref.load %arg2[%1] : memref + %5 = arith.mulf %3, %4 : f32 + affine.store %5, %arg3[%arg4, %arg5, %arg6] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu/raised.mlir new file mode 100644 index 000000000000..b1cd7f41d6ab --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu/raised.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss2d_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %subview = memref.subview %arg3[0, 0, 0] [%c4, %c16, %c16] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = linalg.index 2 : index + %3 = memref.load %arg1[%0, %1, %2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg0[%0, %4, %1, %2] : memref + %6 = arith.negf %5 : f32 + %7 = memref.load %arg2[%4] : memref + %8 = arith.mulf %6, %7 : f32 + linalg.yield %8 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu_debuf.mlir new file mode 100644 index 000000000000..4f559240f167 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu_debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss2d_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c4, %c16, %c16] [1, 1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = linalg.index 2 : index + %6 = memref.load %arg1[%3, %4, %5] : memref + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg0[%3, %7, %4, %5] : memref + %9 = arith.negf %8 : f32 + %10 = memref.load %arg2[%7] : memref + %11 = arith.mulf %9, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0, 0] [%c4, %c16, %c16] [1, 1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu_linalg.mlir new file mode 100644 index 000000000000..b1cd7f41d6ab --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss2d_forward_cpu_linalg.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss2d_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %subview = memref.subview %arg3[0, 0, 0] [%c4, %c16, %c16] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = linalg.index 2 : index + %3 = memref.load %arg1[%0, %1, %2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg0[%0, %4, %1, %2] : memref + %6 = arith.negf %5 : f32 + %7 = memref.load %arg2[%4] : memref + %8 = arith.mulf %6, %7 : f32 + linalg.yield %8 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu.mlir new file mode 100644 index 000000000000..8c85e57c37a0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 16 { + affine.store %cst, %arg3[%arg4, %arg5] : memref + } + } + affine.for %arg4 = 0 to 32 { + %0 = affine.load %arg1[%arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg4] : memref + %3 = arith.negf %2 : f32 + %4 = memref.load %arg2[%1] : memref + %5 = arith.mulf %3, %4 : f32 + memref.store %5, %arg3[%arg4, %1] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..7b3e902f3e20 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c16] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %0[0, 0] [%c32, %c16] [1, 1] : tensor into tensor + %5 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %inserted_slice) -> (tensor) { + %extracted = tensor.extract %2[%arg4] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %3[%arg4] : tensor + %8 = arith.negf %extracted_0 : f32 + %extracted_1 = tensor.extract %1[%7] : tensor + %9 = arith.mulf %8, %extracted_1 : f32 + %inserted = tensor.insert %9 into %arg5[%arg4, %7] : tensor + affine.yield %inserted : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu/matched.mlir new file mode 100644 index 000000000000..dd9566db4560 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu/matched.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c16] [1, 1] : tensor to tensor + %4 = kernel.launch @memset_zero_2D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %4 into %0[0, 0] [%c32, %c16] [1, 1] : tensor into tensor + %5 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %inserted_slice) -> (tensor) { + %extracted = tensor.extract %2[%arg4] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %3[%arg4] : tensor + %8 = arith.negf %extracted_0 : f32 + %extracted_1 = tensor.extract %1[%7] : tensor + %9 = arith.mulf %8, %extracted_1 : f32 + %inserted = tensor.insert %9 into %arg5[%arg4, %7] : tensor + affine.yield %inserted : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu/orig.mlir new file mode 100644 index 000000000000..8c85e57c37a0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 16 { + affine.store %cst, %arg3[%arg4, %arg5] : memref + } + } + affine.for %arg4 = 0 to 32 { + %0 = affine.load %arg1[%arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg4] : memref + %3 = arith.negf %2 : f32 + %4 = memref.load %arg2[%1] : memref + %5 = arith.mulf %3, %4 : f32 + memref.store %5, %arg3[%arg4, %1] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu/raised.mlir new file mode 100644 index 000000000000..b849b1276250 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu/raised.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg3[0, 0] [%c32, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg4 = 0 to 32 { + %0 = affine.load %arg1[%arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg4] : memref + %3 = arith.negf %2 : f32 + %4 = memref.load %arg2[%1] : memref + %5 = arith.mulf %3, %4 : f32 + memref.store %5, %arg3[%arg4, %1] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..7b3e902f3e20 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c16] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %0[0, 0] [%c32, %c16] [1, 1] : tensor into tensor + %5 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %inserted_slice) -> (tensor) { + %extracted = tensor.extract %2[%arg4] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %3[%arg4] : tensor + %8 = arith.negf %extracted_0 : f32 + %extracted_1 = tensor.extract %1[%7] : tensor + %9 = arith.mulf %8, %extracted_1 : f32 + %inserted = tensor.insert %9 into %arg5[%arg4, %7] : tensor + affine.yield %inserted : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..b849b1276250 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss_backward_cpu_linalg.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg3[0, 0] [%c32, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg4 = 0 to 32 { + %0 = affine.load %arg1[%arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg0[%arg4] : memref + %3 = arith.negf %2 : f32 + %4 = memref.load %arg2[%1] : memref + %5 = arith.mulf %3, %4 : f32 + memref.store %5, %arg3[%arg4, %1] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu.mlir b/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu.mlir new file mode 100644 index 000000000000..86b6e20aee29 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %cst) -> (f32) { + %1 = affine.load %arg1[%arg5] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg5, %2] : memref + %4 = arith.negf %3 : f32 + %5 = memref.load %arg2[%2] : memref + %6 = arith.mulf %4, %5 : f32 + affine.store %6, %arg3[%arg5] : memref + %7 = memref.load %arg2[%2] : memref + %8 = arith.addf %arg6, %7 : f32 + affine.yield %8 : f32 + } + affine.store %0, %arg4[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu/debuf.mlir new file mode 100644 index 000000000000..e853e7f81632 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu/debuf.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %cst into %0[%c0] : tensor + %5:2 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %1, %arg7 = %inserted) -> (tensor, tensor) { + %extracted = tensor.extract %arg7[%c0] : tensor + %extracted_0 = tensor.extract %3[%arg5] : tensor + %8 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %4[%arg5, %8] : tensor + %9 = arith.negf %extracted_1 : f32 + %extracted_2 = tensor.extract %2[%8] : tensor + %10 = arith.mulf %9, %extracted_2 : f32 + %inserted_3 = tensor.insert %10 into %arg6[%arg5] : tensor + %extracted_4 = tensor.extract %2[%8] : tensor + %11 = arith.addf %extracted, %extracted_4 : f32 + %inserted_5 = tensor.insert %11 into %arg7[%c0] : tensor + affine.yield %inserted_3, %inserted_5 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg4 : memref to memref + %7 = bufferization.to_memref %5#0 : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu/matched.mlir new file mode 100644 index 000000000000..e853e7f81632 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu/matched.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %cst into %0[%c0] : tensor + %5:2 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %1, %arg7 = %inserted) -> (tensor, tensor) { + %extracted = tensor.extract %arg7[%c0] : tensor + %extracted_0 = tensor.extract %3[%arg5] : tensor + %8 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %4[%arg5, %8] : tensor + %9 = arith.negf %extracted_1 : f32 + %extracted_2 = tensor.extract %2[%8] : tensor + %10 = arith.mulf %9, %extracted_2 : f32 + %inserted_3 = tensor.insert %10 into %arg6[%arg5] : tensor + %extracted_4 = tensor.extract %2[%8] : tensor + %11 = arith.addf %extracted, %extracted_4 : f32 + %inserted_5 = tensor.insert %11 into %arg7[%c0] : tensor + affine.yield %inserted_3, %inserted_5 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg4 : memref to memref + %7 = bufferization.to_memref %5#0 : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu/orig.mlir new file mode 100644 index 000000000000..86b6e20aee29 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu/orig.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %cst) -> (f32) { + %1 = affine.load %arg1[%arg5] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg5, %2] : memref + %4 = arith.negf %3 : f32 + %5 = memref.load %arg2[%2] : memref + %6 = arith.mulf %4, %5 : f32 + affine.store %6, %arg3[%arg5] : memref + %7 = memref.load %arg2[%2] : memref + %8 = arith.addf %arg6, %7 : f32 + affine.yield %8 : f32 + } + affine.store %0, %arg4[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu/raised.mlir new file mode 100644 index 000000000000..4b1888c8843a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu/raised.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.store %cst, %arg4[0] : memref + affine.for %arg5 = 0 to 32 { + %0 = affine.load %arg4[0] : memref + %1 = affine.load %arg1[%arg5] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg5, %2] : memref + %4 = arith.negf %3 : f32 + %5 = memref.load %arg2[%2] : memref + %6 = arith.mulf %4, %5 : f32 + affine.store %6, %arg3[%arg5] : memref + %7 = memref.load %arg2[%2] : memref + %8 = arith.addf %0, %7 : f32 + affine.store %8, %arg4[0] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu_debuf.mlir new file mode 100644 index 000000000000..e853e7f81632 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu_debuf.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %cst into %0[%c0] : tensor + %5:2 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %1, %arg7 = %inserted) -> (tensor, tensor) { + %extracted = tensor.extract %arg7[%c0] : tensor + %extracted_0 = tensor.extract %3[%arg5] : tensor + %8 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %4[%arg5, %8] : tensor + %9 = arith.negf %extracted_1 : f32 + %extracted_2 = tensor.extract %2[%8] : tensor + %10 = arith.mulf %9, %extracted_2 : f32 + %inserted_3 = tensor.insert %10 into %arg6[%arg5] : tensor + %extracted_4 = tensor.extract %2[%8] : tensor + %11 = arith.addf %extracted, %extracted_4 : f32 + %inserted_5 = tensor.insert %11 into %arg7[%c0] : tensor + affine.yield %inserted_3, %inserted_5 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg4 : memref to memref + %7 = bufferization.to_memref %5#0 : memref + memref.copy %7, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu_linalg.mlir new file mode 100644 index 000000000000..4b1888c8843a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nll_loss_forward_cpu_linalg.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nll_loss_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.store %cst, %arg4[0] : memref + affine.for %arg5 = 0 to 32 { + %0 = affine.load %arg4[0] : memref + %1 = affine.load %arg1[%arg5] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg5, %2] : memref + %4 = arith.negf %3 : f32 + %5 = memref.load %arg2[%2] : memref + %6 = arith.mulf %4, %5 : f32 + affine.store %6, %arg3[%arg5] : memref + %7 = memref.load %arg2[%2] : memref + %8 = arith.addf %0, %7 : f32 + affine.store %8, %arg4[0] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nonzero_out_cpu.mlir b/issues/aten_c_kernels/results/aten_nonzero_out_cpu.mlir new file mode 100644 index 000000000000..c0f68c7f3790 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nonzero_out_cpu.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nonzero_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %c0_i32) -> (i32) { + %1 = arith.index_cast %arg4 : index to i32 + %2 = affine.for %arg6 = 0 to 64 iter_args(%arg7 = %arg5) -> (i32) { + %3 = arith.index_cast %arg6 : index to i32 + %4 = affine.load %arg0[%arg4, %arg6] : memref + %5 = arith.cmpf une, %4, %cst : f32 + %6 = scf.if %5 -> (i32) { + %7 = arith.index_cast %arg7 : i32 to index + memref.store %1, %arg1[%7] : memref + %8 = arith.addi %arg7, %c1_i32 : i32 + memref.store %3, %arg2[%7] : memref + scf.yield %8 : i32 + } else { + scf.yield %arg7 : i32 + } + affine.yield %6 : i32 + } + affine.yield %2 : i32 + } + affine.store %0, %arg3[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nonzero_out_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_nonzero_out_cpu/debuf.mlir new file mode 100644 index 000000000000..821ffc064c4e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nonzero_out_cpu/debuf.mlir @@ -0,0 +1,42 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nonzero_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %c0_i32 into %0[%c0] : tensor + %4:3 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %2, %arg6 = %1, %arg7 = %inserted) -> (tensor, tensor, tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9:3 = affine.for %arg8 = 0 to 64 iter_args(%arg9 = %arg5, %arg10 = %arg6, %arg11 = %arg7) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg11[%c0] : tensor + %10 = arith.index_cast %arg8 : index to i32 + %extracted_0 = tensor.extract %3[%arg4, %arg8] : tensor + %11 = arith.cmpf une, %extracted_0, %cst : f32 + %12:3 = scf.if %11 -> (i32, tensor, tensor) { + %13 = arith.index_cast %extracted : i32 to index + %inserted_2 = tensor.insert %8 into %arg9[%13] : tensor + %14 = arith.addi %extracted, %c1_i32 : i32 + %inserted_3 = tensor.insert %10 into %arg10[%13] : tensor + scf.yield %14, %inserted_2, %inserted_3 : i32, tensor, tensor + } else { + scf.yield %extracted, %arg9, %arg10 : i32, tensor, tensor + } + %inserted_1 = tensor.insert %12#0 into %arg11[%c0] : tensor + affine.yield %12#1, %12#2, %inserted_1 : tensor, tensor, tensor + } + affine.yield %9#0, %9#1, %9#2 : tensor, tensor, tensor + } + %5 = bufferization.to_memref %4#2 : memref + memref.copy %5, %arg3 : memref to memref + %6 = bufferization.to_memref %4#1 : memref + memref.copy %6, %arg2 : memref to memref + %7 = bufferization.to_memref %4#0 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nonzero_out_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_nonzero_out_cpu/matched.mlir new file mode 100644 index 000000000000..821ffc064c4e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nonzero_out_cpu/matched.mlir @@ -0,0 +1,42 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nonzero_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %c0_i32 into %0[%c0] : tensor + %4:3 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %2, %arg6 = %1, %arg7 = %inserted) -> (tensor, tensor, tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9:3 = affine.for %arg8 = 0 to 64 iter_args(%arg9 = %arg5, %arg10 = %arg6, %arg11 = %arg7) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg11[%c0] : tensor + %10 = arith.index_cast %arg8 : index to i32 + %extracted_0 = tensor.extract %3[%arg4, %arg8] : tensor + %11 = arith.cmpf une, %extracted_0, %cst : f32 + %12:3 = scf.if %11 -> (i32, tensor, tensor) { + %13 = arith.index_cast %extracted : i32 to index + %inserted_2 = tensor.insert %8 into %arg9[%13] : tensor + %14 = arith.addi %extracted, %c1_i32 : i32 + %inserted_3 = tensor.insert %10 into %arg10[%13] : tensor + scf.yield %14, %inserted_2, %inserted_3 : i32, tensor, tensor + } else { + scf.yield %extracted, %arg9, %arg10 : i32, tensor, tensor + } + %inserted_1 = tensor.insert %12#0 into %arg11[%c0] : tensor + affine.yield %12#1, %12#2, %inserted_1 : tensor, tensor, tensor + } + affine.yield %9#0, %9#1, %9#2 : tensor, tensor, tensor + } + %5 = bufferization.to_memref %4#2 : memref + memref.copy %5, %arg3 : memref to memref + %6 = bufferization.to_memref %4#1 : memref + memref.copy %6, %arg2 : memref to memref + %7 = bufferization.to_memref %4#0 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nonzero_out_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_nonzero_out_cpu/orig.mlir new file mode 100644 index 000000000000..c0f68c7f3790 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nonzero_out_cpu/orig.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nonzero_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %c0_i32) -> (i32) { + %1 = arith.index_cast %arg4 : index to i32 + %2 = affine.for %arg6 = 0 to 64 iter_args(%arg7 = %arg5) -> (i32) { + %3 = arith.index_cast %arg6 : index to i32 + %4 = affine.load %arg0[%arg4, %arg6] : memref + %5 = arith.cmpf une, %4, %cst : f32 + %6 = scf.if %5 -> (i32) { + %7 = arith.index_cast %arg7 : i32 to index + memref.store %1, %arg1[%7] : memref + %8 = arith.addi %arg7, %c1_i32 : i32 + memref.store %3, %arg2[%7] : memref + scf.yield %8 : i32 + } else { + scf.yield %arg7 : i32 + } + affine.yield %6 : i32 + } + affine.yield %2 : i32 + } + affine.store %0, %arg3[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_nonzero_out_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_nonzero_out_cpu/raised.mlir new file mode 100644 index 000000000000..dd5a7d003362 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nonzero_out_cpu/raised.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nonzero_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg3[0] : memref + affine.for %arg4 = 0 to 32 { + %0 = arith.index_cast %arg4 : index to i32 + affine.for %arg5 = 0 to 64 { + %1 = affine.load %arg3[0] : memref + %2 = arith.index_cast %arg5 : index to i32 + %3 = affine.load %arg0[%arg4, %arg5] : memref + %4 = arith.cmpf une, %3, %cst : f32 + %5 = scf.if %4 -> (i32) { + %6 = arith.index_cast %1 : i32 to index + memref.store %0, %arg1[%6] : memref + %7 = arith.addi %1, %c1_i32 : i32 + memref.store %2, %arg2[%6] : memref + scf.yield %7 : i32 + } else { + scf.yield %1 : i32 + } + affine.store %5, %arg3[0] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nonzero_out_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_nonzero_out_cpu_debuf.mlir new file mode 100644 index 000000000000..821ffc064c4e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nonzero_out_cpu_debuf.mlir @@ -0,0 +1,42 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nonzero_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %c0_i32 into %0[%c0] : tensor + %4:3 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %2, %arg6 = %1, %arg7 = %inserted) -> (tensor, tensor, tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9:3 = affine.for %arg8 = 0 to 64 iter_args(%arg9 = %arg5, %arg10 = %arg6, %arg11 = %arg7) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg11[%c0] : tensor + %10 = arith.index_cast %arg8 : index to i32 + %extracted_0 = tensor.extract %3[%arg4, %arg8] : tensor + %11 = arith.cmpf une, %extracted_0, %cst : f32 + %12:3 = scf.if %11 -> (i32, tensor, tensor) { + %13 = arith.index_cast %extracted : i32 to index + %inserted_2 = tensor.insert %8 into %arg9[%13] : tensor + %14 = arith.addi %extracted, %c1_i32 : i32 + %inserted_3 = tensor.insert %10 into %arg10[%13] : tensor + scf.yield %14, %inserted_2, %inserted_3 : i32, tensor, tensor + } else { + scf.yield %extracted, %arg9, %arg10 : i32, tensor, tensor + } + %inserted_1 = tensor.insert %12#0 into %arg11[%c0] : tensor + affine.yield %12#1, %12#2, %inserted_1 : tensor, tensor, tensor + } + affine.yield %9#0, %9#1, %9#2 : tensor, tensor, tensor + } + %5 = bufferization.to_memref %4#2 : memref + memref.copy %5, %arg3 : memref to memref + %6 = bufferization.to_memref %4#1 : memref + memref.copy %6, %arg2 : memref to memref + %7 = bufferization.to_memref %4#0 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_nonzero_out_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_nonzero_out_cpu_linalg.mlir new file mode 100644 index 000000000000..dd5a7d003362 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_nonzero_out_cpu_linalg.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_nonzero_out_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg3[0] : memref + affine.for %arg4 = 0 to 32 { + %0 = arith.index_cast %arg4 : index to i32 + affine.for %arg5 = 0 to 64 { + %1 = affine.load %arg3[0] : memref + %2 = arith.index_cast %arg5 : index to i32 + %3 = affine.load %arg0[%arg4, %arg5] : memref + %4 = arith.cmpf une, %3, %cst : f32 + %5 = scf.if %4 -> (i32) { + %6 = arith.index_cast %1 : i32 to index + memref.store %0, %arg1[%6] : memref + %7 = arith.addi %1, %c1_i32 : i32 + memref.store %2, %arg2[%6] : memref + scf.yield %7 : i32 + } else { + scf.yield %1 : i32 + } + affine.store %5, %arg3[0] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_norm_cpu.mlir b/issues/aten_c_kernels/results/aten_norm_cpu.mlir new file mode 100644 index 000000000000..37e86e682607 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_norm_cpu.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_norm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 32 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %cst) -> (f32) { + %2 = affine.load %arg0[%arg2, %arg3] : memref + %3 = arith.mulf %2, %2 : f32 + %4 = arith.addf %arg4, %3 : f32 + affine.yield %4 : f32 + } + %1 = math.sqrt %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_norm_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_norm_cpu/debuf.mlir new file mode 100644 index 000000000000..0adfd23530e3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_norm_cpu/debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_norm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = arith.mulf %in, %in : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c32] [1] : tensor into tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = math.sqrt %in : f32 + linalg.yield %7 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_norm_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_norm_cpu/matched.mlir new file mode 100644 index 000000000000..c04d1960591f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_norm_cpu/matched.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_norm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3 = kernel.launch @memset_zero_1D_f32(%2) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = arith.mulf %in, %in : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c32] [1] : tensor into tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = math.sqrt %in : f32 + linalg.yield %7 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_norm_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_norm_cpu/orig.mlir new file mode 100644 index 000000000000..37e86e682607 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_norm_cpu/orig.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_norm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 32 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %cst) -> (f32) { + %2 = affine.load %arg0[%arg2, %arg3] : memref + %3 = arith.mulf %2, %2 : f32 + %4 = arith.addf %arg4, %3 : f32 + affine.yield %4 : f32 + } + %1 = math.sqrt %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_norm_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_norm_cpu/raised.mlir new file mode 100644 index 000000000000..b5c365df3c78 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_norm_cpu/raised.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_norm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca(%c32) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %alloca[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %in : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.sqrt %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_norm_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_norm_cpu_debuf.mlir new file mode 100644 index 000000000000..0adfd23530e3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_norm_cpu_debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_norm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = arith.mulf %in, %in : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c32] [1] : tensor into tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = math.sqrt %in : f32 + linalg.yield %7 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_norm_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_norm_cpu_linalg.mlir new file mode 100644 index 000000000000..b5c365df3c78 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_norm_cpu_linalg.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_norm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca(%c32) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %alloca[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %in : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.sqrt %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_normal_cpu.mlir b/issues/aten_c_kernels/results/aten_normal_cpu.mlir new file mode 100644 index 000000000000..92636fc2300d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_normal_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_normal_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.mulf %arg2, %0 : f32 + %2 = arith.addf %arg1, %1 : f32 + affine.store %2, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_normal_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_normal_cpu/debuf.mlir new file mode 100644 index 000000000000..6a120d6c4c9c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_normal_cpu/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_normal_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %arg2, %in : f32 + %5 = arith.addf %arg1, %4 : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_normal_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_normal_cpu/matched.mlir new file mode 100644 index 000000000000..6a120d6c4c9c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_normal_cpu/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_normal_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %arg2, %in : f32 + %5 = arith.addf %arg1, %4 : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_normal_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_normal_cpu/orig.mlir new file mode 100644 index 000000000000..92636fc2300d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_normal_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_normal_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.mulf %arg2, %0 : f32 + %2 = arith.addf %arg1, %1 : f32 + affine.store %2, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_normal_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_normal_cpu/raised.mlir new file mode 100644 index 000000000000..43767124df8a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_normal_cpu/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_normal_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %arg2, %in : f32 + %1 = arith.addf %arg1, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_normal_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_normal_cpu_debuf.mlir new file mode 100644 index 000000000000..6a120d6c4c9c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_normal_cpu_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_normal_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %arg2, %in : f32 + %5 = arith.addf %arg1, %4 : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_normal_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_normal_cpu_linalg.mlir new file mode 100644 index 000000000000..43767124df8a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_normal_cpu_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_normal_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %arg2, %in : f32 + %1 = arith.addf %arg1, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_or_reduce_cpu.mlir b/issues/aten_c_kernels/results/aten_or_reduce_cpu.mlir new file mode 100644 index 000000000000..f5f2eab93f44 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_or_reduce_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_or_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 32 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %c0_i32) -> (i32) { + %1 = arith.cmpi ne, %arg4, %c0_i32 : i32 + %2 = scf.if %1 -> (i1) { + scf.yield %true : i1 + } else { + %4 = affine.load %arg0[%arg2, %arg3] : memref + %5 = arith.cmpi ne, %4, %c0_i32 : i32 + scf.yield %5 : i1 + } + %3 = arith.extsi %2 : i1 to i32 + affine.yield %3 : i32 + } + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_or_reduce_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_or_reduce_cpu/debuf.mlir new file mode 100644 index 000000000000..4ebe0174b7fe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_or_reduce_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_or_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %true = arith.constant true + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.cmpi ne, %out, %c0_i32 : i32 + %6 = arith.cmpi ne, %in, %c0_i32 : i32 + %7 = arith.select %5, %true, %6 : i1 + %8 = arith.extsi %7 : i1 to i32 + linalg.yield %8 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_or_reduce_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_or_reduce_cpu/matched.mlir new file mode 100644 index 000000000000..4e67909c4f0d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_or_reduce_cpu/matched.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_or_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %true = arith.constant true + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = kernel.launch @memset_zero_1D(%1) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.cmpi ne, %out, %c0_i32 : i32 + %6 = arith.cmpi ne, %in, %c0_i32 : i32 + %7 = arith.select %5, %true, %6 : i1 + %8 = arith.extsi %7 : i1 to i32 + linalg.yield %8 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_or_reduce_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_or_reduce_cpu/orig.mlir new file mode 100644 index 000000000000..f5f2eab93f44 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_or_reduce_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_or_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 32 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %c0_i32) -> (i32) { + %1 = arith.cmpi ne, %arg4, %c0_i32 : i32 + %2 = scf.if %1 -> (i1) { + scf.yield %true : i1 + } else { + %4 = affine.load %arg0[%arg2, %arg3] : memref + %5 = arith.cmpi ne, %4, %c0_i32 : i32 + scf.yield %5 : i1 + } + %3 = arith.extsi %2 : i1 to i32 + affine.yield %3 : i32 + } + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_or_reduce_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_or_reduce_cpu/raised.mlir new file mode 100644 index 000000000000..938007294eb7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_or_reduce_cpu/raised.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_or_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %true = arith.constant true + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: i32, %out: i32): + %0 = arith.cmpi ne, %out, %c0_i32 : i32 + %1 = arith.cmpi ne, %in, %c0_i32 : i32 + %2 = arith.select %0, %true, %1 : i1 + %3 = arith.extsi %2 : i1 to i32 + linalg.yield %3 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_or_reduce_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_or_reduce_cpu_debuf.mlir new file mode 100644 index 000000000000..4ebe0174b7fe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_or_reduce_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_or_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %true = arith.constant true + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.cmpi ne, %out, %c0_i32 : i32 + %6 = arith.cmpi ne, %in, %c0_i32 : i32 + %7 = arith.select %5, %true, %6 : i1 + %8 = arith.extsi %7 : i1 to i32 + linalg.yield %8 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_or_reduce_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_or_reduce_cpu_linalg.mlir new file mode 100644 index 000000000000..938007294eb7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_or_reduce_cpu_linalg.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_or_reduce_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %true = arith.constant true + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: i32, %out: i32): + %0 = arith.cmpi ne, %out, %c0_i32 : i32 + %1 = arith.cmpi ne, %in, %c0_i32 : i32 + %2 = arith.select %0, %true, %1 : i1 + %3 = arith.extsi %2 : i1 to i32 + linalg.yield %3 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_outer.mlir b/issues/aten_c_kernels/results/aten_outer.mlir new file mode 100644 index 000000000000..2f18cde44acd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_outer.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_outer(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 24 { + affine.store %cst, %arg2[%arg3, %arg4] : memref + } + } + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 24 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %arg2[%arg3, %arg4] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_outer/debuf.mlir b/issues/aten_c_kernels/results/aten_outer/debuf.mlir new file mode 100644 index 000000000000..faef00dfb012 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_outer/debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_outer(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0] [%c32] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0] [%c24] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %6 = arith.mulf %in, %in_2 : f64 + %7 = arith.addf %out, %6 : f64 + linalg.yield %7 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0] [%c32, %c24] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_outer/matched.mlir b/issues/aten_c_kernels/results/aten_outer/matched.mlir new file mode 100644 index 000000000000..29010f8b912a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_outer/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_outer(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0] [%c32] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0] [%c24] [1] : tensor to tensor + %4 = kernel.launch @cublasDgemm_outer_product(%extracted_slice_0, %extracted_slice_1, %extracted_slice) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0] [%c32, %c24] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_outer/orig.mlir b/issues/aten_c_kernels/results/aten_outer/orig.mlir new file mode 100644 index 000000000000..2f18cde44acd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_outer/orig.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_outer(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 24 { + affine.store %cst, %arg2[%arg3, %arg4] : memref + } + } + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 24 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %arg2[%arg3, %arg4] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_outer/raised.mlir b/issues/aten_c_kernels/results/aten_outer/raised.mlir new file mode 100644 index 000000000000..d14ccef7e068 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_outer/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_outer(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f64 + %subview = memref.subview %arg2[0, 0] [%c32, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_0 = memref.subview %arg0[0] [%c32] [1] : memref to memref> + %subview_1 = memref.subview %arg1[0] [%c24] [1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0] [%c32, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map], iterator_types = ["parallel", "parallel"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f64, %in_3: f64, %out: f64): + %0 = arith.mulf %in, %in_3 : f64 + %1 = arith.addf %out, %0 : f64 + linalg.yield %1 : f64 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_outer_debuf.mlir b/issues/aten_c_kernels/results/aten_outer_debuf.mlir new file mode 100644 index 000000000000..faef00dfb012 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_outer_debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_outer(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0] [%c32] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0] [%c24] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %6 = arith.mulf %in, %in_2 : f64 + %7 = arith.addf %out, %6 : f64 + linalg.yield %7 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0] [%c32, %c24] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_outer_linalg.mlir b/issues/aten_c_kernels/results/aten_outer_linalg.mlir new file mode 100644 index 000000000000..d14ccef7e068 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_outer_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_outer(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f64 + %subview = memref.subview %arg2[0, 0] [%c32, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_0 = memref.subview %arg0[0] [%c32] [1] : memref to memref> + %subview_1 = memref.subview %arg1[0] [%c24] [1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0] [%c32, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map], iterator_types = ["parallel", "parallel"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f64, %in_3: f64, %out: f64): + %0 = arith.mulf %in, %in_3 : f64 + %1 = arith.addf %out, %0 : f64 + linalg.yield %1 : f64 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu.mlir b/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu.mlir new file mode 100644 index 000000000000..4e278086c517 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_padded_to_jagged_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 8 { + %0 = scf.while (%arg4 = %c0_i32) : (i32) -> i32 { + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.addi %1, %arg4 : i32 + %3 = affine.load %arg1[%arg3 + 1] : memref + %4 = arith.cmpi slt, %2, %3 : i32 + scf.condition(%4) %arg4 : i32 + } do { + ^bb0(%arg4: i32): + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.addi %1, %arg4 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.index_cast %arg4 : i32 to index + %5 = memref.load %arg0[%arg3, %4] : memref + memref.store %5, %arg2[%3] : memref + %6 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %6 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu/debuf.mlir new file mode 100644 index 000000000000..7783d1c8989d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu/debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_padded_to_jagged_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c0_i32, %arg6 = %arg4) : (i32, tensor) -> (i32, tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %6 = arith.addi %extracted, %arg5 : i32 + %7 = affine.apply #map(%arg3) + %extracted_0 = tensor.extract %1[%7] : tensor + %8 = arith.cmpi slt, %6, %extracted_0 : i32 + scf.condition(%8) %arg5, %arg6 : i32, tensor + } do { + ^bb0(%arg5: i32, %arg6: tensor): + %extracted = tensor.extract %1[%arg3] : tensor + %6 = arith.addi %extracted, %arg5 : i32 + %7 = arith.index_cast %6 : i32 to index + %8 = arith.index_cast %arg5 : i32 to index + %extracted_0 = tensor.extract %2[%arg3, %8] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%7] : tensor + %9 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %9, %inserted : i32, tensor + } + affine.yield %5#1 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu/matched.mlir new file mode 100644 index 000000000000..7783d1c8989d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu/matched.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_padded_to_jagged_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c0_i32, %arg6 = %arg4) : (i32, tensor) -> (i32, tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %6 = arith.addi %extracted, %arg5 : i32 + %7 = affine.apply #map(%arg3) + %extracted_0 = tensor.extract %1[%7] : tensor + %8 = arith.cmpi slt, %6, %extracted_0 : i32 + scf.condition(%8) %arg5, %arg6 : i32, tensor + } do { + ^bb0(%arg5: i32, %arg6: tensor): + %extracted = tensor.extract %1[%arg3] : tensor + %6 = arith.addi %extracted, %arg5 : i32 + %7 = arith.index_cast %6 : i32 to index + %8 = arith.index_cast %arg5 : i32 to index + %extracted_0 = tensor.extract %2[%arg3, %8] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%7] : tensor + %9 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %9, %inserted : i32, tensor + } + affine.yield %5#1 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu/orig.mlir new file mode 100644 index 000000000000..4e278086c517 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu/orig.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_padded_to_jagged_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 8 { + %0 = scf.while (%arg4 = %c0_i32) : (i32) -> i32 { + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.addi %1, %arg4 : i32 + %3 = affine.load %arg1[%arg3 + 1] : memref + %4 = arith.cmpi slt, %2, %3 : i32 + scf.condition(%4) %arg4 : i32 + } do { + ^bb0(%arg4: i32): + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.addi %1, %arg4 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.index_cast %arg4 : i32 to index + %5 = memref.load %arg0[%arg3, %4] : memref + memref.store %5, %arg2[%3] : memref + %6 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %6 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu/raised.mlir new file mode 100644 index 000000000000..e77cf5b4c2b5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu/raised.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_padded_to_jagged_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 8 { + %0 = scf.while (%arg4 = %c0_i32) : (i32) -> i32 { + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.addi %1, %arg4 : i32 + %3 = affine.load %arg1[%arg3 + 1] : memref + %4 = arith.cmpi slt, %2, %3 : i32 + scf.condition(%4) %arg4 : i32 + } do { + ^bb0(%arg4: i32): + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.addi %1, %arg4 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.index_cast %arg4 : i32 to index + %5 = memref.load %arg0[%arg3, %4] : memref + memref.store %5, %arg2[%3] : memref + %6 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %6 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu_debuf.mlir new file mode 100644 index 000000000000..7783d1c8989d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu_debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_padded_to_jagged_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c0_i32, %arg6 = %arg4) : (i32, tensor) -> (i32, tensor) { + %extracted = tensor.extract %1[%arg3] : tensor + %6 = arith.addi %extracted, %arg5 : i32 + %7 = affine.apply #map(%arg3) + %extracted_0 = tensor.extract %1[%7] : tensor + %8 = arith.cmpi slt, %6, %extracted_0 : i32 + scf.condition(%8) %arg5, %arg6 : i32, tensor + } do { + ^bb0(%arg5: i32, %arg6: tensor): + %extracted = tensor.extract %1[%arg3] : tensor + %6 = arith.addi %extracted, %arg5 : i32 + %7 = arith.index_cast %6 : i32 to index + %8 = arith.index_cast %arg5 : i32 to index + %extracted_0 = tensor.extract %2[%arg3, %8] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%7] : tensor + %9 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %9, %inserted : i32, tensor + } + affine.yield %5#1 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu_linalg.mlir new file mode 100644 index 000000000000..e77cf5b4c2b5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_padded_to_jagged_cpu_linalg.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_padded_to_jagged_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 8 { + %0 = scf.while (%arg4 = %c0_i32) : (i32) -> i32 { + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.addi %1, %arg4 : i32 + %3 = affine.load %arg1[%arg3 + 1] : memref + %4 = arith.cmpi slt, %2, %3 : i32 + scf.condition(%4) %arg4 : i32 + } do { + ^bb0(%arg4: i32): + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.addi %1, %arg4 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = arith.index_cast %arg4 : i32 to index + %5 = memref.load %arg0[%arg3, %4] : memref + memref.store %5, %arg2[%3] : memref + %6 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %6 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pdist_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_pdist_backward_cpu.mlir new file mode 100644 index 000000000000..58331651fb75 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pdist_backward_cpu.mlir @@ -0,0 +1,76 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pdist_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c31_i32 = arith.constant 31 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + %alloca = memref.alloca() : memref<120xf32> + affine.for %arg3 = 0 to 16 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.subi %c31_i32, %0 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg4 = #map(%arg3) to 16 { + %4 = arith.index_cast %arg4 : index to i32 + %5 = arith.subi %4, %0 : i32 + %6 = arith.addi %5, %c-1_i32 : i32 + %7 = arith.addi %3, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + memref.store %cst, %alloca[%8] : memref<120xf32> + %9 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %cst) -> (f32) { + %12 = affine.load %arg0[%arg3, %arg5] : memref + %13 = affine.load %arg0[%arg4, %arg5] : memref + %14 = arith.subf %12, %13 : f32 + %15 = arith.mulf %14, %14 : f32 + %16 = arith.addf %arg6, %15 : f32 + memref.store %16, %alloca[%8] : memref<120xf32> + affine.yield %16 : f32 + } + %10 = memref.load %alloca[%8] : memref<120xf32> + %11 = math.sqrt %10 : f32 + memref.store %11, %alloca[%8] : memref<120xf32> + } + } + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 32 { + affine.store %cst, %arg2[%arg3, %arg4] : memref + } + } + affine.for %arg3 = 0 to 16 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.subi %c31_i32, %0 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg4 = #map(%arg3) to 16 { + %4 = arith.index_cast %arg4 : index to i32 + %5 = arith.subi %4, %0 : i32 + %6 = arith.addi %5, %c-1_i32 : i32 + %7 = arith.addi %3, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = memref.load %alloca[%8] : memref<120xf32> + %10 = arith.cmpf oeq, %9, %cst : f32 + %11 = scf.if %10 -> (f32) { + scf.yield %cst : f32 + } else { + %12 = memref.load %arg1[%8] : memref + %13 = arith.divf %12, %9 : f32 + scf.yield %13 : f32 + } + affine.for %arg5 = 0 to 32 { + %12 = affine.load %arg0[%arg3, %arg5] : memref + %13 = affine.load %arg0[%arg4, %arg5] : memref + %14 = arith.subf %12, %13 : f32 + %15 = arith.mulf %11, %14 : f32 + %16 = affine.load %arg2[%arg3, %arg5] : memref + %17 = arith.addf %16, %15 : f32 + affine.store %17, %arg2[%arg3, %arg5] : memref + %18 = affine.load %arg2[%arg4, %arg5] : memref + %19 = arith.subf %18, %15 : f32 + affine.store %19, %arg2[%arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_pdist_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_pdist_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..22466361f61d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pdist_backward_cpu/debuf.mlir @@ -0,0 +1,92 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pdist_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c31_i32 = arith.constant 31 : i32 + %c-1_i32 = arith.constant -1 : i32 + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<120xf32> + %4 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %3) -> (tensor<120xf32>) { + %8 = arith.index_cast %arg3 : index to i32 + %9 = arith.subi %c31_i32, %8 : i32 + %10 = arith.muli %8, %9 : i32 + %11 = arith.divsi %10, %c2_i32 : i32 + %12 = affine.for %arg5 = #map(%arg3) to 16 iter_args(%arg6 = %arg4) -> (tensor<120xf32>) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.subi %13, %8 : i32 + %15 = arith.addi %14, %c-1_i32 : i32 + %16 = arith.addi %11, %15 : i32 + %17 = arith.index_cast %16 : i32 to index + %inserted = tensor.insert %cst into %arg6[%17] : tensor<120xf32> + %alloca = memref.alloca() : memref + %18 = bufferization.to_tensor %alloca : memref + %inserted_0 = tensor.insert %cst into %18[] : tensor + %19:2 = affine.for %arg7 = 0 to 32 iter_args(%arg8 = %inserted, %arg9 = %inserted_0) -> (tensor<120xf32>, tensor) { + %extracted_2 = tensor.extract %arg9[] : tensor + %extracted_3 = tensor.extract %2[%arg3, %arg7] : tensor + %extracted_4 = tensor.extract %2[%arg5, %arg7] : tensor + %21 = arith.subf %extracted_3, %extracted_4 : f32 + %22 = arith.mulf %21, %21 : f32 + %23 = arith.addf %extracted_2, %22 : f32 + %inserted_5 = tensor.insert %23 into %arg8[%17] : tensor<120xf32> + %inserted_6 = tensor.insert %23 into %arg9[] : tensor + affine.yield %inserted_5, %inserted_6 : tensor<120xf32>, tensor + } + %extracted = tensor.extract %19#0[%17] : tensor<120xf32> + %20 = math.sqrt %extracted : f32 + %inserted_1 = tensor.insert %20 into %19#0[%17] : tensor<120xf32> + affine.yield %inserted_1 : tensor<120xf32> + } + affine.yield %12 : tensor<120xf32> + } + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c32] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c16, %c32] [1, 1] : tensor into tensor + %6 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %8 = arith.index_cast %arg3 : index to i32 + %9 = arith.subi %c31_i32, %8 : i32 + %10 = arith.muli %8, %9 : i32 + %11 = arith.divsi %10, %c2_i32 : i32 + %12 = affine.for %arg5 = #map(%arg3) to 16 iter_args(%arg6 = %arg4) -> (tensor) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.subi %13, %8 : i32 + %15 = arith.addi %14, %c-1_i32 : i32 + %16 = arith.addi %11, %15 : i32 + %17 = arith.index_cast %16 : i32 to index + %extracted = tensor.extract %4[%17] : tensor<120xf32> + %18 = arith.cmpf oeq, %extracted, %cst : f32 + %extracted_0 = tensor.extract %1[%17] : tensor + %19 = arith.divf %extracted_0, %extracted : f32 + %20 = arith.select %18, %cst, %19 : f32 + %21 = affine.for %arg7 = 0 to 32 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted_1 = tensor.extract %2[%arg3, %arg7] : tensor + %extracted_2 = tensor.extract %2[%arg5, %arg7] : tensor + %22 = arith.subf %extracted_1, %extracted_2 : f32 + %23 = arith.mulf %20, %22 : f32 + %extracted_3 = tensor.extract %arg8[%arg3, %arg7] : tensor + %24 = arith.addf %extracted_3, %23 : f32 + %inserted = tensor.insert %24 into %arg8[%arg3, %arg7] : tensor + %extracted_4 = tensor.extract %inserted[%arg5, %arg7] : tensor + %25 = arith.subf %extracted_4, %23 : f32 + %inserted_5 = tensor.insert %25 into %inserted[%arg5, %arg7] : tensor + affine.yield %inserted_5 : tensor + } + affine.yield %21 : tensor + } + affine.yield %12 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pdist_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_pdist_backward_cpu/matched.mlir new file mode 100644 index 000000000000..70a4330822ed --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pdist_backward_cpu/matched.mlir @@ -0,0 +1,89 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pdist_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c31_i32 = arith.constant 31 : i32 + %c-1_i32 = arith.constant -1 : i32 + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<120xf32> + %4 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %3) -> (tensor<120xf32>) { + %8 = arith.index_cast %arg3 : index to i32 + %9 = arith.subi %c31_i32, %8 : i32 + %10 = arith.muli %8, %9 : i32 + %11 = arith.divsi %10, %c2_i32 : i32 + %12 = affine.for %arg5 = #map(%arg3) to 16 iter_args(%arg6 = %arg4) -> (tensor<120xf32>) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.subi %13, %8 : i32 + %15 = arith.addi %14, %c-1_i32 : i32 + %16 = arith.addi %11, %15 : i32 + %17 = arith.index_cast %16 : i32 to index + %inserted = tensor.insert %cst into %arg6[%17] : tensor<120xf32> + %alloca = memref.alloca() : memref + %18 = bufferization.to_tensor %alloca : memref + %inserted_0 = tensor.insert %cst into %18[] : tensor + %19:2 = affine.for %arg7 = 0 to 32 iter_args(%arg8 = %inserted, %arg9 = %inserted_0) -> (tensor<120xf32>, tensor) { + %extracted_2 = tensor.extract %arg9[] : tensor + %extracted_3 = tensor.extract %2[%arg3, %arg7] : tensor + %extracted_4 = tensor.extract %2[%arg5, %arg7] : tensor + %21 = arith.subf %extracted_3, %extracted_4 : f32 + %22 = arith.mulf %21, %21 : f32 + %23 = arith.addf %extracted_2, %22 : f32 + %inserted_5 = tensor.insert %23 into %arg8[%17] : tensor<120xf32> + %inserted_6 = tensor.insert %23 into %arg9[] : tensor + affine.yield %inserted_5, %inserted_6 : tensor<120xf32>, tensor + } + %extracted = tensor.extract %19#0[%17] : tensor<120xf32> + %20 = math.sqrt %extracted : f32 + %inserted_1 = tensor.insert %20 into %19#0[%17] : tensor<120xf32> + affine.yield %inserted_1 : tensor<120xf32> + } + affine.yield %12 : tensor<120xf32> + } + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c32] [1, 1] : tensor to tensor + %5 = kernel.launch @memset_zero_2D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c16, %c32] [1, 1] : tensor into tensor + %6 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %8 = arith.index_cast %arg3 : index to i32 + %9 = arith.subi %c31_i32, %8 : i32 + %10 = arith.muli %8, %9 : i32 + %11 = arith.divsi %10, %c2_i32 : i32 + %12 = affine.for %arg5 = #map(%arg3) to 16 iter_args(%arg6 = %arg4) -> (tensor) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.subi %13, %8 : i32 + %15 = arith.addi %14, %c-1_i32 : i32 + %16 = arith.addi %11, %15 : i32 + %17 = arith.index_cast %16 : i32 to index + %extracted = tensor.extract %4[%17] : tensor<120xf32> + %18 = arith.cmpf oeq, %extracted, %cst : f32 + %extracted_0 = tensor.extract %1[%17] : tensor + %19 = arith.divf %extracted_0, %extracted : f32 + %20 = arith.select %18, %cst, %19 : f32 + %21 = affine.for %arg7 = 0 to 32 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted_1 = tensor.extract %2[%arg3, %arg7] : tensor + %extracted_2 = tensor.extract %2[%arg5, %arg7] : tensor + %22 = arith.subf %extracted_1, %extracted_2 : f32 + %23 = arith.mulf %20, %22 : f32 + %extracted_3 = tensor.extract %arg8[%arg3, %arg7] : tensor + %24 = arith.addf %extracted_3, %23 : f32 + %inserted = tensor.insert %24 into %arg8[%arg3, %arg7] : tensor + %extracted_4 = tensor.extract %inserted[%arg5, %arg7] : tensor + %25 = arith.subf %extracted_4, %23 : f32 + %inserted_5 = tensor.insert %25 into %inserted[%arg5, %arg7] : tensor + affine.yield %inserted_5 : tensor + } + affine.yield %21 : tensor + } + affine.yield %12 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pdist_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_pdist_backward_cpu/orig.mlir new file mode 100644 index 000000000000..58331651fb75 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pdist_backward_cpu/orig.mlir @@ -0,0 +1,76 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pdist_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c31_i32 = arith.constant 31 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + %alloca = memref.alloca() : memref<120xf32> + affine.for %arg3 = 0 to 16 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.subi %c31_i32, %0 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg4 = #map(%arg3) to 16 { + %4 = arith.index_cast %arg4 : index to i32 + %5 = arith.subi %4, %0 : i32 + %6 = arith.addi %5, %c-1_i32 : i32 + %7 = arith.addi %3, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + memref.store %cst, %alloca[%8] : memref<120xf32> + %9 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %cst) -> (f32) { + %12 = affine.load %arg0[%arg3, %arg5] : memref + %13 = affine.load %arg0[%arg4, %arg5] : memref + %14 = arith.subf %12, %13 : f32 + %15 = arith.mulf %14, %14 : f32 + %16 = arith.addf %arg6, %15 : f32 + memref.store %16, %alloca[%8] : memref<120xf32> + affine.yield %16 : f32 + } + %10 = memref.load %alloca[%8] : memref<120xf32> + %11 = math.sqrt %10 : f32 + memref.store %11, %alloca[%8] : memref<120xf32> + } + } + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 32 { + affine.store %cst, %arg2[%arg3, %arg4] : memref + } + } + affine.for %arg3 = 0 to 16 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.subi %c31_i32, %0 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg4 = #map(%arg3) to 16 { + %4 = arith.index_cast %arg4 : index to i32 + %5 = arith.subi %4, %0 : i32 + %6 = arith.addi %5, %c-1_i32 : i32 + %7 = arith.addi %3, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = memref.load %alloca[%8] : memref<120xf32> + %10 = arith.cmpf oeq, %9, %cst : f32 + %11 = scf.if %10 -> (f32) { + scf.yield %cst : f32 + } else { + %12 = memref.load %arg1[%8] : memref + %13 = arith.divf %12, %9 : f32 + scf.yield %13 : f32 + } + affine.for %arg5 = 0 to 32 { + %12 = affine.load %arg0[%arg3, %arg5] : memref + %13 = affine.load %arg0[%arg4, %arg5] : memref + %14 = arith.subf %12, %13 : f32 + %15 = arith.mulf %11, %14 : f32 + %16 = affine.load %arg2[%arg3, %arg5] : memref + %17 = arith.addf %16, %15 : f32 + affine.store %17, %arg2[%arg3, %arg5] : memref + %18 = affine.load %arg2[%arg4, %arg5] : memref + %19 = arith.subf %18, %15 : f32 + affine.store %19, %arg2[%arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_pdist_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_pdist_backward_cpu/raised.mlir new file mode 100644 index 000000000000..867a7860da6b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pdist_backward_cpu/raised.mlir @@ -0,0 +1,79 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pdist_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %c-1_i32 = arith.constant -1 : i32 + %c31_i32 = arith.constant 31 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + %alloca = memref.alloca() : memref<120xf32> + affine.for %arg3 = 0 to 16 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.subi %c31_i32, %0 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg4 = #map(%arg3) to 16 { + %4 = arith.index_cast %arg4 : index to i32 + %5 = arith.subi %4, %0 : i32 + %6 = arith.addi %5, %c-1_i32 : i32 + %7 = arith.addi %3, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + memref.store %cst, %alloca[%8] : memref<120xf32> + %alloca_0 = memref.alloca() : memref + affine.store %cst, %alloca_0[] : memref + affine.for %arg5 = 0 to 32 { + %11 = affine.load %alloca_0[] : memref + %12 = affine.load %arg0[%arg3, %arg5] : memref + %13 = affine.load %arg0[%arg4, %arg5] : memref + %14 = arith.subf %12, %13 : f32 + %15 = arith.mulf %14, %14 : f32 + %16 = arith.addf %11, %15 : f32 + memref.store %16, %alloca[%8] : memref<120xf32> + affine.store %16, %alloca_0[] : memref + } + %9 = memref.load %alloca[%8] : memref<120xf32> + %10 = math.sqrt %9 : f32 + memref.store %10, %alloca[%8] : memref<120xf32> + } + } + %subview = memref.subview %arg2[0, 0] [%c16, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 16 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.subi %c31_i32, %0 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg4 = #map(%arg3) to 16 { + %4 = arith.index_cast %arg4 : index to i32 + %5 = arith.subi %4, %0 : i32 + %6 = arith.addi %5, %c-1_i32 : i32 + %7 = arith.addi %3, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = memref.load %alloca[%8] : memref<120xf32> + %10 = arith.cmpf oeq, %9, %cst : f32 + %11 = memref.load %arg1[%8] : memref + %12 = arith.divf %11, %9 : f32 + %13 = arith.select %10, %cst, %12 : f32 + affine.for %arg5 = 0 to 32 { + %14 = affine.load %arg0[%arg3, %arg5] : memref + %15 = affine.load %arg0[%arg4, %arg5] : memref + %16 = arith.subf %14, %15 : f32 + %17 = arith.mulf %13, %16 : f32 + %18 = affine.load %arg2[%arg3, %arg5] : memref + %19 = arith.addf %18, %17 : f32 + affine.store %19, %arg2[%arg3, %arg5] : memref + %20 = affine.load %arg2[%arg4, %arg5] : memref + %21 = arith.subf %20, %17 : f32 + affine.store %21, %arg2[%arg4, %arg5] : memref + } {polygeist.was_parallel} + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pdist_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_pdist_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..22466361f61d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pdist_backward_cpu_debuf.mlir @@ -0,0 +1,92 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pdist_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c31_i32 = arith.constant 31 : i32 + %c-1_i32 = arith.constant -1 : i32 + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<120xf32> + %4 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %3) -> (tensor<120xf32>) { + %8 = arith.index_cast %arg3 : index to i32 + %9 = arith.subi %c31_i32, %8 : i32 + %10 = arith.muli %8, %9 : i32 + %11 = arith.divsi %10, %c2_i32 : i32 + %12 = affine.for %arg5 = #map(%arg3) to 16 iter_args(%arg6 = %arg4) -> (tensor<120xf32>) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.subi %13, %8 : i32 + %15 = arith.addi %14, %c-1_i32 : i32 + %16 = arith.addi %11, %15 : i32 + %17 = arith.index_cast %16 : i32 to index + %inserted = tensor.insert %cst into %arg6[%17] : tensor<120xf32> + %alloca = memref.alloca() : memref + %18 = bufferization.to_tensor %alloca : memref + %inserted_0 = tensor.insert %cst into %18[] : tensor + %19:2 = affine.for %arg7 = 0 to 32 iter_args(%arg8 = %inserted, %arg9 = %inserted_0) -> (tensor<120xf32>, tensor) { + %extracted_2 = tensor.extract %arg9[] : tensor + %extracted_3 = tensor.extract %2[%arg3, %arg7] : tensor + %extracted_4 = tensor.extract %2[%arg5, %arg7] : tensor + %21 = arith.subf %extracted_3, %extracted_4 : f32 + %22 = arith.mulf %21, %21 : f32 + %23 = arith.addf %extracted_2, %22 : f32 + %inserted_5 = tensor.insert %23 into %arg8[%17] : tensor<120xf32> + %inserted_6 = tensor.insert %23 into %arg9[] : tensor + affine.yield %inserted_5, %inserted_6 : tensor<120xf32>, tensor + } + %extracted = tensor.extract %19#0[%17] : tensor<120xf32> + %20 = math.sqrt %extracted : f32 + %inserted_1 = tensor.insert %20 into %19#0[%17] : tensor<120xf32> + affine.yield %inserted_1 : tensor<120xf32> + } + affine.yield %12 : tensor<120xf32> + } + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c32] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c16, %c32] [1, 1] : tensor into tensor + %6 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %8 = arith.index_cast %arg3 : index to i32 + %9 = arith.subi %c31_i32, %8 : i32 + %10 = arith.muli %8, %9 : i32 + %11 = arith.divsi %10, %c2_i32 : i32 + %12 = affine.for %arg5 = #map(%arg3) to 16 iter_args(%arg6 = %arg4) -> (tensor) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.subi %13, %8 : i32 + %15 = arith.addi %14, %c-1_i32 : i32 + %16 = arith.addi %11, %15 : i32 + %17 = arith.index_cast %16 : i32 to index + %extracted = tensor.extract %4[%17] : tensor<120xf32> + %18 = arith.cmpf oeq, %extracted, %cst : f32 + %extracted_0 = tensor.extract %1[%17] : tensor + %19 = arith.divf %extracted_0, %extracted : f32 + %20 = arith.select %18, %cst, %19 : f32 + %21 = affine.for %arg7 = 0 to 32 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted_1 = tensor.extract %2[%arg3, %arg7] : tensor + %extracted_2 = tensor.extract %2[%arg5, %arg7] : tensor + %22 = arith.subf %extracted_1, %extracted_2 : f32 + %23 = arith.mulf %20, %22 : f32 + %extracted_3 = tensor.extract %arg8[%arg3, %arg7] : tensor + %24 = arith.addf %extracted_3, %23 : f32 + %inserted = tensor.insert %24 into %arg8[%arg3, %arg7] : tensor + %extracted_4 = tensor.extract %inserted[%arg5, %arg7] : tensor + %25 = arith.subf %extracted_4, %23 : f32 + %inserted_5 = tensor.insert %25 into %inserted[%arg5, %arg7] : tensor + affine.yield %inserted_5 : tensor + } + affine.yield %21 : tensor + } + affine.yield %12 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pdist_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_pdist_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..867a7860da6b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pdist_backward_cpu_linalg.mlir @@ -0,0 +1,79 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pdist_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %c-1_i32 = arith.constant -1 : i32 + %c31_i32 = arith.constant 31 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + %alloca = memref.alloca() : memref<120xf32> + affine.for %arg3 = 0 to 16 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.subi %c31_i32, %0 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg4 = #map(%arg3) to 16 { + %4 = arith.index_cast %arg4 : index to i32 + %5 = arith.subi %4, %0 : i32 + %6 = arith.addi %5, %c-1_i32 : i32 + %7 = arith.addi %3, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + memref.store %cst, %alloca[%8] : memref<120xf32> + %alloca_0 = memref.alloca() : memref + affine.store %cst, %alloca_0[] : memref + affine.for %arg5 = 0 to 32 { + %11 = affine.load %alloca_0[] : memref + %12 = affine.load %arg0[%arg3, %arg5] : memref + %13 = affine.load %arg0[%arg4, %arg5] : memref + %14 = arith.subf %12, %13 : f32 + %15 = arith.mulf %14, %14 : f32 + %16 = arith.addf %11, %15 : f32 + memref.store %16, %alloca[%8] : memref<120xf32> + affine.store %16, %alloca_0[] : memref + } + %9 = memref.load %alloca[%8] : memref<120xf32> + %10 = math.sqrt %9 : f32 + memref.store %10, %alloca[%8] : memref<120xf32> + } + } + %subview = memref.subview %arg2[0, 0] [%c16, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 16 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.subi %c31_i32, %0 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg4 = #map(%arg3) to 16 { + %4 = arith.index_cast %arg4 : index to i32 + %5 = arith.subi %4, %0 : i32 + %6 = arith.addi %5, %c-1_i32 : i32 + %7 = arith.addi %3, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = memref.load %alloca[%8] : memref<120xf32> + %10 = arith.cmpf oeq, %9, %cst : f32 + %11 = memref.load %arg1[%8] : memref + %12 = arith.divf %11, %9 : f32 + %13 = arith.select %10, %cst, %12 : f32 + affine.for %arg5 = 0 to 32 { + %14 = affine.load %arg0[%arg3, %arg5] : memref + %15 = affine.load %arg0[%arg4, %arg5] : memref + %16 = arith.subf %14, %15 : f32 + %17 = arith.mulf %13, %16 : f32 + %18 = affine.load %arg2[%arg3, %arg5] : memref + %19 = arith.addf %18, %17 : f32 + affine.store %19, %arg2[%arg3, %arg5] : memref + %20 = affine.load %arg2[%arg4, %arg5] : memref + %21 = arith.subf %20, %17 : f32 + affine.store %21, %arg2[%arg4, %arg5] : memref + } {polygeist.was_parallel} + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pdist_forward_cpu.mlir b/issues/aten_c_kernels/results/aten_pdist_forward_cpu.mlir new file mode 100644 index 000000000000..90ae2b6ac444 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pdist_forward_cpu.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pdist_forward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c31_i32 = arith.constant 31 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 16 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.subi %c31_i32, %0 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg3 = #map(%arg2) to 16 { + %4 = arith.index_cast %arg3 : index to i32 + %5 = arith.subi %4, %0 : i32 + %6 = arith.addi %5, %c-1_i32 : i32 + %7 = arith.addi %3, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + memref.store %cst, %arg1[%8] : memref + affine.for %arg4 = 0 to 32 { + %9 = affine.load %arg0[%arg2, %arg4] : memref + %10 = affine.load %arg0[%arg3, %arg4] : memref + %11 = arith.subf %9, %10 : f32 + %12 = arith.mulf %11, %11 : f32 + %13 = memref.load %arg1[%8] : memref + %14 = arith.addf %13, %12 : f32 + memref.store %14, %arg1[%8] : memref + } + } + } + affine.for %arg2 = 0 to 120 { + %0 = affine.load %arg1[%arg2] : memref + %1 = math.sqrt %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_pdist_forward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_pdist_forward_cpu/debuf.mlir new file mode 100644 index 000000000000..e49e95c40d30 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pdist_forward_cpu/debuf.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pdist_forward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c31_i32 = arith.constant 31 : i32 + %c-1_i32 = arith.constant -1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 16 iter_args(%arg3 = %0) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.subi %c31_i32, %5 : i32 + %7 = arith.muli %5, %6 : i32 + %8 = arith.divsi %7, %c2_i32 : i32 + %9 = affine.for %arg4 = #map(%arg2) to 16 iter_args(%arg5 = %arg3) -> (tensor) { + %10 = arith.index_cast %arg4 : index to i32 + %11 = arith.subi %10, %5 : i32 + %12 = arith.addi %11, %c-1_i32 : i32 + %13 = arith.addi %8, %12 : i32 + %14 = arith.index_cast %13 : i32 to index + %inserted = tensor.insert %cst into %arg5[%14] : tensor + %15 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %inserted) -> (tensor) { + %extracted = tensor.extract %1[%arg2, %arg6] : tensor + %extracted_0 = tensor.extract %1[%arg4, %arg6] : tensor + %16 = arith.subf %extracted, %extracted_0 : f32 + %17 = arith.mulf %16, %16 : f32 + %extracted_1 = tensor.extract %arg7[%14] : tensor + %18 = arith.addf %extracted_1, %17 : f32 + %inserted_2 = tensor.insert %18 into %arg7[%14] : tensor + affine.yield %inserted_2 : tensor + } + affine.yield %15 : tensor + } + affine.yield %9 : tensor + } + %3 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + %5 = math.sqrt %out : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pdist_forward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_pdist_forward_cpu/matched.mlir new file mode 100644 index 000000000000..e49e95c40d30 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pdist_forward_cpu/matched.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pdist_forward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c31_i32 = arith.constant 31 : i32 + %c-1_i32 = arith.constant -1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 16 iter_args(%arg3 = %0) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.subi %c31_i32, %5 : i32 + %7 = arith.muli %5, %6 : i32 + %8 = arith.divsi %7, %c2_i32 : i32 + %9 = affine.for %arg4 = #map(%arg2) to 16 iter_args(%arg5 = %arg3) -> (tensor) { + %10 = arith.index_cast %arg4 : index to i32 + %11 = arith.subi %10, %5 : i32 + %12 = arith.addi %11, %c-1_i32 : i32 + %13 = arith.addi %8, %12 : i32 + %14 = arith.index_cast %13 : i32 to index + %inserted = tensor.insert %cst into %arg5[%14] : tensor + %15 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %inserted) -> (tensor) { + %extracted = tensor.extract %1[%arg2, %arg6] : tensor + %extracted_0 = tensor.extract %1[%arg4, %arg6] : tensor + %16 = arith.subf %extracted, %extracted_0 : f32 + %17 = arith.mulf %16, %16 : f32 + %extracted_1 = tensor.extract %arg7[%14] : tensor + %18 = arith.addf %extracted_1, %17 : f32 + %inserted_2 = tensor.insert %18 into %arg7[%14] : tensor + affine.yield %inserted_2 : tensor + } + affine.yield %15 : tensor + } + affine.yield %9 : tensor + } + %3 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + %5 = math.sqrt %out : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pdist_forward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_pdist_forward_cpu/orig.mlir new file mode 100644 index 000000000000..90ae2b6ac444 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pdist_forward_cpu/orig.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pdist_forward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c31_i32 = arith.constant 31 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 16 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.subi %c31_i32, %0 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg3 = #map(%arg2) to 16 { + %4 = arith.index_cast %arg3 : index to i32 + %5 = arith.subi %4, %0 : i32 + %6 = arith.addi %5, %c-1_i32 : i32 + %7 = arith.addi %3, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + memref.store %cst, %arg1[%8] : memref + affine.for %arg4 = 0 to 32 { + %9 = affine.load %arg0[%arg2, %arg4] : memref + %10 = affine.load %arg0[%arg3, %arg4] : memref + %11 = arith.subf %9, %10 : f32 + %12 = arith.mulf %11, %11 : f32 + %13 = memref.load %arg1[%8] : memref + %14 = arith.addf %13, %12 : f32 + memref.store %14, %arg1[%8] : memref + } + } + } + affine.for %arg2 = 0 to 120 { + %0 = affine.load %arg1[%arg2] : memref + %1 = math.sqrt %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_pdist_forward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_pdist_forward_cpu/raised.mlir new file mode 100644 index 000000000000..a4bce7f6309d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pdist_forward_cpu/raised.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pdist_forward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c31_i32 = arith.constant 31 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 16 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.subi %c31_i32, %0 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg3 = #map(%arg2) to 16 { + %4 = arith.index_cast %arg3 : index to i32 + %5 = arith.subi %4, %0 : i32 + %6 = arith.addi %5, %c-1_i32 : i32 + %7 = arith.addi %3, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + memref.store %cst, %arg1[%8] : memref + affine.for %arg4 = 0 to 32 { + %9 = affine.load %arg0[%arg2, %arg4] : memref + %10 = affine.load %arg0[%arg3, %arg4] : memref + %11 = arith.subf %9, %10 : f32 + %12 = arith.mulf %11, %11 : f32 + %13 = memref.load %arg1[%8] : memref + %14 = arith.addf %13, %12 : f32 + memref.store %14, %arg1[%8] : memref + } + } + } + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + %0 = math.sqrt %out : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pdist_forward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_pdist_forward_cpu_debuf.mlir new file mode 100644 index 000000000000..e49e95c40d30 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pdist_forward_cpu_debuf.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pdist_forward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c31_i32 = arith.constant 31 : i32 + %c-1_i32 = arith.constant -1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 16 iter_args(%arg3 = %0) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.subi %c31_i32, %5 : i32 + %7 = arith.muli %5, %6 : i32 + %8 = arith.divsi %7, %c2_i32 : i32 + %9 = affine.for %arg4 = #map(%arg2) to 16 iter_args(%arg5 = %arg3) -> (tensor) { + %10 = arith.index_cast %arg4 : index to i32 + %11 = arith.subi %10, %5 : i32 + %12 = arith.addi %11, %c-1_i32 : i32 + %13 = arith.addi %8, %12 : i32 + %14 = arith.index_cast %13 : i32 to index + %inserted = tensor.insert %cst into %arg5[%14] : tensor + %15 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %inserted) -> (tensor) { + %extracted = tensor.extract %1[%arg2, %arg6] : tensor + %extracted_0 = tensor.extract %1[%arg4, %arg6] : tensor + %16 = arith.subf %extracted, %extracted_0 : f32 + %17 = arith.mulf %16, %16 : f32 + %extracted_1 = tensor.extract %arg7[%14] : tensor + %18 = arith.addf %extracted_1, %17 : f32 + %inserted_2 = tensor.insert %18 into %arg7[%14] : tensor + affine.yield %inserted_2 : tensor + } + affine.yield %15 : tensor + } + affine.yield %9 : tensor + } + %3 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + %5 = math.sqrt %out : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pdist_forward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_pdist_forward_cpu_linalg.mlir new file mode 100644 index 000000000000..a4bce7f6309d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pdist_forward_cpu_linalg.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pdist_forward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c31_i32 = arith.constant 31 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 16 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.subi %c31_i32, %0 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg3 = #map(%arg2) to 16 { + %4 = arith.index_cast %arg3 : index to i32 + %5 = arith.subi %4, %0 : i32 + %6 = arith.addi %5, %c-1_i32 : i32 + %7 = arith.addi %3, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + memref.store %cst, %arg1[%8] : memref + affine.for %arg4 = 0 to 32 { + %9 = affine.load %arg0[%arg2, %arg4] : memref + %10 = affine.load %arg0[%arg3, %arg4] : memref + %11 = arith.subf %9, %10 : f32 + %12 = arith.mulf %11, %11 : f32 + %13 = memref.load %arg1[%8] : memref + %14 = arith.addf %13, %12 : f32 + memref.store %14, %arg1[%8] : memref + } + } + } + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + %0 = math.sqrt %out : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu.mlir b/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu.mlir new file mode 100644 index 000000000000..85d57e28dc3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_permute_sparse_coo_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 512 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1, %arg4] : memref + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu/debuf.mlir new file mode 100644 index 000000000000..b328d687f5aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_permute_sparse_coo_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c512 = arith.constant 512 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c3, %c512] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: i32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%6, %4] : memref + linalg.yield %7 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c3, %c512] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu/matched.mlir new file mode 100644 index 000000000000..b328d687f5aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_permute_sparse_coo_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c512 = arith.constant 512 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c3, %c512] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: i32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%6, %4] : memref + linalg.yield %7 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c3, %c512] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu/orig.mlir new file mode 100644 index 000000000000..85d57e28dc3e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_permute_sparse_coo_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 512 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1, %arg4] : memref + affine.store %2, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu/raised.mlir new file mode 100644 index 000000000000..62d5914d12f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_permute_sparse_coo_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c512 = arith.constant 512 : index + %subview = memref.subview %arg2[0, 0] [%c3, %c512] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: i32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = memref.load %arg1[%0] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3, %1] : memref + linalg.yield %4 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu_debuf.mlir new file mode 100644 index 000000000000..b328d687f5aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_permute_sparse_coo_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c512 = arith.constant 512 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c3, %c512] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: i32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = memref.load %arg1[%3] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg0[%6, %4] : memref + linalg.yield %7 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c3, %c512] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu_linalg.mlir new file mode 100644 index 000000000000..62d5914d12f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_permute_sparse_coo_cpu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_permute_sparse_coo_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c512 = arith.constant 512 : index + %subview = memref.subview %arg2[0, 0] [%c3, %c512] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: i32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = memref.load %arg1[%0] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3, %1] : memref + linalg.yield %4 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pixel_shuffle.mlir b/issues/aten_c_kernels/results/aten_pixel_shuffle.mlir new file mode 100644 index 000000000000..d12a4e3bd35e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_shuffle.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_shuffle(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.load %arg0[%arg2, %arg3, %arg4, %arg5, %arg6, %arg7] : memref + affine.store %0, %arg1[%arg2, %arg3, %arg4 + %arg6 * 2, %arg5 + %arg7 * 2] : memref + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_pixel_shuffle/debuf.mlir b/issues/aten_c_kernels/results/aten_pixel_shuffle/debuf.mlir new file mode 100644 index 000000000000..a6d6ee4161a9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_shuffle/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 * 2 + d2, d5 * 2 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_shuffle(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0, 0, 0] [%c2, %c3, %c2, %c2, %c4, %c4] [1, 1, 1, 1, 1, 1] : tensor to tensor + %2 = polygeist.submap(%1, %c2, %c3, %c2, %c2, %c4, %c4) {map = #map} : (tensor, index, index, index, index, index, index) -> tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %4 = polygeist.submapInverse(%1, %3, %c2, %c3, %c2, %c2, %c4, %c4) {map = #map} : (tensor, tensor, index, index, index, index, index, index) -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pixel_shuffle/matched.mlir b/issues/aten_c_kernels/results/aten_pixel_shuffle/matched.mlir new file mode 100644 index 000000000000..a6d6ee4161a9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_shuffle/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 * 2 + d2, d5 * 2 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_shuffle(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0, 0, 0] [%c2, %c3, %c2, %c2, %c4, %c4] [1, 1, 1, 1, 1, 1] : tensor to tensor + %2 = polygeist.submap(%1, %c2, %c3, %c2, %c2, %c4, %c4) {map = #map} : (tensor, index, index, index, index, index, index) -> tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %4 = polygeist.submapInverse(%1, %3, %c2, %c3, %c2, %c2, %c4, %c4) {map = #map} : (tensor, tensor, index, index, index, index, index, index) -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pixel_shuffle/orig.mlir b/issues/aten_c_kernels/results/aten_pixel_shuffle/orig.mlir new file mode 100644 index 000000000000..d12a4e3bd35e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_shuffle/orig.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_shuffle(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.load %arg0[%arg2, %arg3, %arg4, %arg5, %arg6, %arg7] : memref + affine.store %0, %arg1[%arg2, %arg3, %arg4 + %arg6 * 2, %arg5 + %arg7 * 2] : memref + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_pixel_shuffle/raised.mlir b/issues/aten_c_kernels/results/aten_pixel_shuffle/raised.mlir new file mode 100644 index 000000000000..5b18bf5e7857 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_shuffle/raised.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 * 2 + d2, d5 * 2 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_shuffle(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %subview = memref.subview %arg0[0, 0, 0, 0, 0, 0] [%c2, %c3, %c2, %c2, %c4, %c4] [1, 1, 1, 1, 1, 1] : memref to memref> + %0 = polygeist.submap(%arg1, %c2, %c3, %c2, %c2, %c4, %c4) {map = #map} : (memref, index, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%0 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend.mlir b/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend.mlir new file mode 100644 index 000000000000..af28badf9a28 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_shuffle_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 3 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 2 { + %0 = affine.load %arg0[0, %arg6 + %arg5 * 2 + %arg2 * 4, %arg3, %arg4] : memref + affine.store %0, %arg1[0, %arg2, %arg5 + %arg3 * 2, %arg6 + %arg4 * 2] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend/debuf.mlir b/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend/debuf.mlir new file mode 100644 index 000000000000..c54d963b8ba0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (0, d4 + d3 * 2 + d0 * 4, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (0, d0, d3 + d1 * 2, d4 + d2 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_shuffle_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c3, %c8, %c8, %c2, %c2) {map = #map} : (tensor, index, index, index, index, index) -> tensor + %3 = polygeist.submap(%1, %c3, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submapInverse(%1, %4, %c3, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, tensor, index, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend/matched.mlir b/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend/matched.mlir new file mode 100644 index 000000000000..c54d963b8ba0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (0, d4 + d3 * 2 + d0 * 4, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (0, d0, d3 + d1 * 2, d4 + d2 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_shuffle_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c3, %c8, %c8, %c2, %c2) {map = #map} : (tensor, index, index, index, index, index) -> tensor + %3 = polygeist.submap(%1, %c3, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submapInverse(%1, %4, %c3, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, tensor, index, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend/orig.mlir b/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend/orig.mlir new file mode 100644 index 000000000000..af28badf9a28 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_shuffle_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 3 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 2 { + %0 = affine.load %arg0[0, %arg6 + %arg5 * 2 + %arg2 * 4, %arg3, %arg4] : memref + affine.store %0, %arg1[0, %arg2, %arg5 + %arg3 * 2, %arg6 + %arg4 * 2] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend/raised.mlir b/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend/raised.mlir new file mode 100644 index 000000000000..7ae391c44796 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend/raised.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (0, d4 + d3 * 2 + d0 * 4, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (0, d0, d3 + d1 * 2, d4 + d2 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_shuffle_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = polygeist.submap(%arg0, %c3, %c8, %c8, %c2, %c2) {map = #map} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %c3, %c8, %c8, %c2, %c2) {map = #map1} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend_debuf.mlir b/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend_debuf.mlir new file mode 100644 index 000000000000..c54d963b8ba0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (0, d4 + d3 * 2 + d0 * 4, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (0, d0, d3 + d1 * 2, d4 + d2 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_shuffle_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c3, %c8, %c8, %c2, %c2) {map = #map} : (tensor, index, index, index, index, index) -> tensor + %3 = polygeist.submap(%1, %c3, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submapInverse(%1, %4, %c3, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, tensor, index, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend_linalg.mlir b/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend_linalg.mlir new file mode 100644 index 000000000000..7ae391c44796 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_shuffle_cpu_backend_linalg.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (0, d4 + d3 * 2 + d0 * 4, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (0, d0, d3 + d1 * 2, d4 + d2 * 2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_shuffle_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = polygeist.submap(%arg0, %c3, %c8, %c8, %c2, %c2) {map = #map} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %c3, %c8, %c8, %c2, %c2) {map = #map1} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pixel_shuffle_debuf.mlir b/issues/aten_c_kernels/results/aten_pixel_shuffle_debuf.mlir new file mode 100644 index 000000000000..a6d6ee4161a9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_shuffle_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 * 2 + d2, d5 * 2 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_shuffle(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0, 0, 0] [%c2, %c3, %c2, %c2, %c4, %c4] [1, 1, 1, 1, 1, 1] : tensor to tensor + %2 = polygeist.submap(%1, %c2, %c3, %c2, %c2, %c4, %c4) {map = #map} : (tensor, index, index, index, index, index, index) -> tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %4 = polygeist.submapInverse(%1, %3, %c2, %c3, %c2, %c2, %c4, %c4) {map = #map} : (tensor, tensor, index, index, index, index, index, index) -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pixel_shuffle_linalg.mlir b/issues/aten_c_kernels/results/aten_pixel_shuffle_linalg.mlir new file mode 100644 index 000000000000..5b18bf5e7857 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_shuffle_linalg.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d4 * 2 + d2, d5 * 2 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_shuffle(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %subview = memref.subview %arg0[0, 0, 0, 0, 0, 0] [%c2, %c3, %c2, %c2, %c4, %c4] [1, 1, 1, 1, 1, 1] : memref to memref> + %0 = polygeist.submap(%arg1, %c2, %c3, %c2, %c2, %c4, %c4) {map = #map} : (memref, index, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%0 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend.mlir b/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend.mlir new file mode 100644 index 000000000000..f89d813e52e9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_unshuffle_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 3 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 2 { + %0 = affine.load %arg0[0, %arg2, %arg5 + %arg3 * 2, %arg6 + %arg4 * 2] : memref + affine.store %0, %arg1[0, %arg6 + %arg5 * 2 + %arg2 * 4, %arg3, %arg4] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend/debuf.mlir b/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend/debuf.mlir new file mode 100644 index 000000000000..8ae52a7c84db --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (0, d0, d3 + d1 * 2, d4 + d2 * 2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (0, d4 + d3 * 2 + d0 * 4, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_unshuffle_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c3, %c8, %c8, %c2, %c2) {map = #map} : (tensor, index, index, index, index, index) -> tensor + %3 = polygeist.submap(%1, %c3, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submapInverse(%1, %4, %c3, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, tensor, index, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend/matched.mlir b/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend/matched.mlir new file mode 100644 index 000000000000..8ae52a7c84db --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (0, d0, d3 + d1 * 2, d4 + d2 * 2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (0, d4 + d3 * 2 + d0 * 4, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_unshuffle_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c3, %c8, %c8, %c2, %c2) {map = #map} : (tensor, index, index, index, index, index) -> tensor + %3 = polygeist.submap(%1, %c3, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submapInverse(%1, %4, %c3, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, tensor, index, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend/orig.mlir b/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend/orig.mlir new file mode 100644 index 000000000000..f89d813e52e9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_unshuffle_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 3 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 2 { + %0 = affine.load %arg0[0, %arg2, %arg5 + %arg3 * 2, %arg6 + %arg4 * 2] : memref + affine.store %0, %arg1[0, %arg6 + %arg5 * 2 + %arg2 * 4, %arg3, %arg4] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend/raised.mlir b/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend/raised.mlir new file mode 100644 index 000000000000..2366c95a98d2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend/raised.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (0, d0, d3 + d1 * 2, d4 + d2 * 2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (0, d4 + d3 * 2 + d0 * 4, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_unshuffle_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = polygeist.submap(%arg0, %c3, %c8, %c8, %c2, %c2) {map = #map} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %c3, %c8, %c8, %c2, %c2) {map = #map1} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend_debuf.mlir b/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend_debuf.mlir new file mode 100644 index 000000000000..8ae52a7c84db --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (0, d0, d3 + d1 * 2, d4 + d2 * 2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (0, d4 + d3 * 2 + d0 * 4, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_unshuffle_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c3, %c8, %c8, %c2, %c2) {map = #map} : (tensor, index, index, index, index, index) -> tensor + %3 = polygeist.submap(%1, %c3, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %5 = polygeist.submapInverse(%1, %4, %c3, %c8, %c8, %c2, %c2) {map = #map1} : (tensor, tensor, index, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend_linalg.mlir b/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend_linalg.mlir new file mode 100644 index 000000000000..2366c95a98d2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pixel_unshuffle_cpu_backend_linalg.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (0, d0, d3 + d1 * 2, d4 + d2 * 2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (0, d4 + d3 * 2 + d0 * 4, d1, d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pixel_unshuffle_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = polygeist.submap(%arg0, %c3, %c8, %c8, %c2, %c2) {map = #map} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %c3, %c8, %c8, %c2, %c2) {map = #map1} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_poisson_transform_cpu.mlir b/issues/aten_c_kernels/results/aten_poisson_transform_cpu.mlir new file mode 100644 index 000000000000..98511db72412 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_poisson_transform_cpu.mlir @@ -0,0 +1,40 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_poisson_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c64_i32 = arith.constant 64 : i32 + %cst = arith.constant 1.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 1024 { + %0:2 = scf.while (%arg4 = %c0_i32, %arg5 = %cst) : (i32, f32) -> (i32, f32) { + %2 = arith.cmpi slt, %arg4, %c64_i32 : i32 + %3:3 = scf.if %2 -> (i1, i32, f32) { + %4 = affine.load %arg0[%arg3] : memref + %5 = arith.negf %4 : f32 + %6 = math.exp %5 : f32 + %7 = arith.cmpf ogt, %arg5, %6 : f32 + %8:2 = scf.if %7 -> (i32, f32) { + %9 = arith.addi %arg4, %c1_i32 : i32 + %10 = arith.index_cast %arg4 : i32 to index + %11 = memref.load %arg1[%arg3, %10] : memref + %12 = arith.mulf %arg5, %11 : f32 + scf.yield %9, %12 : i32, f32 + } else { + scf.yield %arg4, %arg5 : i32, f32 + } + scf.yield %7, %8#0, %8#1 : i1, i32, f32 + } else { + scf.yield %false, %arg4, %arg5 : i1, i32, f32 + } + scf.condition(%3#0) %3#1, %3#2 : i32, f32 + } do { + ^bb0(%arg4: i32, %arg5: f32): + scf.yield %arg4, %arg5 : i32, f32 + } + %1 = arith.addi %0#0, %c-1_i32 : i32 + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_poisson_transform_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_poisson_transform_cpu/debuf.mlir new file mode 100644 index 000000000000..b80c13efdbd1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_poisson_transform_cpu/debuf.mlir @@ -0,0 +1,42 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_poisson_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 1.000000e+00 : f32 + %c64_i32 = arith.constant 64 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c-1_i32 = arith.constant -1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c0_i32, %arg6 = %cst) : (i32, f32) -> (i32, f32) { + %7 = arith.cmpi slt, %arg5, %c64_i32 : i32 + %extracted = tensor.extract %2[%arg3] : tensor + %8 = arith.negf %extracted : f32 + %9 = math.exp %8 : f32 + %10 = arith.cmpf ogt, %arg6, %9 : f32 + %11 = arith.addi %arg5, %c1_i32 : i32 + %12 = arith.index_cast %arg5 : i32 to index + %extracted_0 = tensor.extract %1[%arg3, %12] : tensor + %13 = arith.mulf %arg6, %extracted_0 : f32 + %14 = arith.select %10, %11, %arg5 : i32 + %15 = arith.select %10, %13, %arg6 : f32 + %16 = arith.select %7, %10, %false : i1 + %17 = arith.select %7, %14, %arg5 : i32 + %18 = arith.select %7, %15, %arg6 : f32 + scf.condition(%16) %17, %18 : i32, f32 + } do { + ^bb0(%arg5: i32, %arg6: f32): + scf.yield %arg5, %arg6 : i32, f32 + } + %6 = arith.addi %5#0, %c-1_i32 : i32 + %inserted = tensor.insert %6 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_poisson_transform_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_poisson_transform_cpu/matched.mlir new file mode 100644 index 000000000000..b80c13efdbd1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_poisson_transform_cpu/matched.mlir @@ -0,0 +1,42 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_poisson_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 1.000000e+00 : f32 + %c64_i32 = arith.constant 64 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c-1_i32 = arith.constant -1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c0_i32, %arg6 = %cst) : (i32, f32) -> (i32, f32) { + %7 = arith.cmpi slt, %arg5, %c64_i32 : i32 + %extracted = tensor.extract %2[%arg3] : tensor + %8 = arith.negf %extracted : f32 + %9 = math.exp %8 : f32 + %10 = arith.cmpf ogt, %arg6, %9 : f32 + %11 = arith.addi %arg5, %c1_i32 : i32 + %12 = arith.index_cast %arg5 : i32 to index + %extracted_0 = tensor.extract %1[%arg3, %12] : tensor + %13 = arith.mulf %arg6, %extracted_0 : f32 + %14 = arith.select %10, %11, %arg5 : i32 + %15 = arith.select %10, %13, %arg6 : f32 + %16 = arith.select %7, %10, %false : i1 + %17 = arith.select %7, %14, %arg5 : i32 + %18 = arith.select %7, %15, %arg6 : f32 + scf.condition(%16) %17, %18 : i32, f32 + } do { + ^bb0(%arg5: i32, %arg6: f32): + scf.yield %arg5, %arg6 : i32, f32 + } + %6 = arith.addi %5#0, %c-1_i32 : i32 + %inserted = tensor.insert %6 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_poisson_transform_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_poisson_transform_cpu/orig.mlir new file mode 100644 index 000000000000..98511db72412 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_poisson_transform_cpu/orig.mlir @@ -0,0 +1,40 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_poisson_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c64_i32 = arith.constant 64 : i32 + %cst = arith.constant 1.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 1024 { + %0:2 = scf.while (%arg4 = %c0_i32, %arg5 = %cst) : (i32, f32) -> (i32, f32) { + %2 = arith.cmpi slt, %arg4, %c64_i32 : i32 + %3:3 = scf.if %2 -> (i1, i32, f32) { + %4 = affine.load %arg0[%arg3] : memref + %5 = arith.negf %4 : f32 + %6 = math.exp %5 : f32 + %7 = arith.cmpf ogt, %arg5, %6 : f32 + %8:2 = scf.if %7 -> (i32, f32) { + %9 = arith.addi %arg4, %c1_i32 : i32 + %10 = arith.index_cast %arg4 : i32 to index + %11 = memref.load %arg1[%arg3, %10] : memref + %12 = arith.mulf %arg5, %11 : f32 + scf.yield %9, %12 : i32, f32 + } else { + scf.yield %arg4, %arg5 : i32, f32 + } + scf.yield %7, %8#0, %8#1 : i1, i32, f32 + } else { + scf.yield %false, %arg4, %arg5 : i1, i32, f32 + } + scf.condition(%3#0) %3#1, %3#2 : i32, f32 + } do { + ^bb0(%arg4: i32, %arg5: f32): + scf.yield %arg4, %arg5 : i32, f32 + } + %1 = arith.addi %0#0, %c-1_i32 : i32 + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_poisson_transform_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_poisson_transform_cpu/raised.mlir new file mode 100644 index 000000000000..32b80659a78d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_poisson_transform_cpu/raised.mlir @@ -0,0 +1,36 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_poisson_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c64_i32 = arith.constant 64 : i32 + %cst = arith.constant 1.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 1024 { + %0:2 = scf.while (%arg4 = %c0_i32, %arg5 = %cst) : (i32, f32) -> (i32, f32) { + %2 = arith.cmpi slt, %arg4, %c64_i32 : i32 + %3 = affine.load %arg0[%arg3] : memref + %4 = arith.negf %3 : f32 + %5 = math.exp %4 : f32 + %6 = arith.cmpf ogt, %arg5, %5 : f32 + %7 = arith.addi %arg4, %c1_i32 : i32 + %8 = arith.index_cast %arg4 : i32 to index + %9 = memref.load %arg1[%arg3, %8] : memref + %10 = arith.mulf %arg5, %9 : f32 + %11 = arith.select %6, %7, %arg4 : i32 + %12 = arith.select %6, %10, %arg5 : f32 + %13 = arith.select %2, %6, %false : i1 + %14 = arith.select %2, %11, %arg4 : i32 + %15 = arith.select %2, %12, %arg5 : f32 + scf.condition(%13) %14, %15 : i32, f32 + } do { + ^bb0(%arg4: i32, %arg5: f32): + scf.yield %arg4, %arg5 : i32, f32 + } + %1 = arith.addi %0#0, %c-1_i32 : i32 + affine.store %1, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_poisson_transform_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_poisson_transform_cpu_debuf.mlir new file mode 100644 index 000000000000..b80c13efdbd1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_poisson_transform_cpu_debuf.mlir @@ -0,0 +1,42 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_poisson_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 1.000000e+00 : f32 + %c64_i32 = arith.constant 64 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c-1_i32 = arith.constant -1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c0_i32, %arg6 = %cst) : (i32, f32) -> (i32, f32) { + %7 = arith.cmpi slt, %arg5, %c64_i32 : i32 + %extracted = tensor.extract %2[%arg3] : tensor + %8 = arith.negf %extracted : f32 + %9 = math.exp %8 : f32 + %10 = arith.cmpf ogt, %arg6, %9 : f32 + %11 = arith.addi %arg5, %c1_i32 : i32 + %12 = arith.index_cast %arg5 : i32 to index + %extracted_0 = tensor.extract %1[%arg3, %12] : tensor + %13 = arith.mulf %arg6, %extracted_0 : f32 + %14 = arith.select %10, %11, %arg5 : i32 + %15 = arith.select %10, %13, %arg6 : f32 + %16 = arith.select %7, %10, %false : i1 + %17 = arith.select %7, %14, %arg5 : i32 + %18 = arith.select %7, %15, %arg6 : f32 + scf.condition(%16) %17, %18 : i32, f32 + } do { + ^bb0(%arg5: i32, %arg6: f32): + scf.yield %arg5, %arg6 : i32, f32 + } + %6 = arith.addi %5#0, %c-1_i32 : i32 + %inserted = tensor.insert %6 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_poisson_transform_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_poisson_transform_cpu_linalg.mlir new file mode 100644 index 000000000000..32b80659a78d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_poisson_transform_cpu_linalg.mlir @@ -0,0 +1,36 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_poisson_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c64_i32 = arith.constant 64 : i32 + %cst = arith.constant 1.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 1024 { + %0:2 = scf.while (%arg4 = %c0_i32, %arg5 = %cst) : (i32, f32) -> (i32, f32) { + %2 = arith.cmpi slt, %arg4, %c64_i32 : i32 + %3 = affine.load %arg0[%arg3] : memref + %4 = arith.negf %3 : f32 + %5 = math.exp %4 : f32 + %6 = arith.cmpf ogt, %arg5, %5 : f32 + %7 = arith.addi %arg4, %c1_i32 : i32 + %8 = arith.index_cast %arg4 : i32 to index + %9 = memref.load %arg1[%arg3, %8] : memref + %10 = arith.mulf %arg5, %9 : f32 + %11 = arith.select %6, %7, %arg4 : i32 + %12 = arith.select %6, %10, %arg5 : f32 + %13 = arith.select %2, %6, %false : i1 + %14 = arith.select %2, %11, %arg4 : i32 + %15 = arith.select %2, %12, %arg5 : f32 + scf.condition(%13) %14, %15 : i32, f32 + } do { + ^bb0(%arg4: i32, %arg5: f32): + scf.yield %arg4, %arg5 : i32, f32 + } + %1 = arith.addi %0#0, %c-1_i32 : i32 + affine.store %1, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_polar_scalarized.mlir b/issues/aten_c_kernels/results/aten_polar_scalarized.mlir new file mode 100644 index 000000000000..5c76ae531ff3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_polar_scalarized.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_polar_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = func.call @cosf(%1) : (f32) -> f32 + %3 = arith.mulf %0, %2 : f32 + affine.store %3, %arg2[%arg4] : memref + %4 = affine.load %arg0[%arg4] : memref + %5 = affine.load %arg1[%arg4] : memref + %6 = func.call @sinf(%5) : (f32) -> f32 + %7 = arith.mulf %4, %6 : f32 + affine.store %7, %arg3[%arg4] : memref + } + return + } + func.func private @cosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_polar_scalarized/debuf.mlir b/issues/aten_c_kernels/results/aten_polar_scalarized/debuf.mlir new file mode 100644 index 000000000000..ab8ba3d16cb2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_polar_scalarized/debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_polar_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %8 = math.cos %in_0 : f32 + %9 = arith.mulf %in, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %8 = math.sin %in_0 : f32 + %9 = arith.mulf %in, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg3 : memref to memref + return + } + func.func private @cosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_polar_scalarized/matched.mlir b/issues/aten_c_kernels/results/aten_polar_scalarized/matched.mlir new file mode 100644 index 000000000000..ab8ba3d16cb2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_polar_scalarized/matched.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_polar_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %8 = math.cos %in_0 : f32 + %9 = arith.mulf %in, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %8 = math.sin %in_0 : f32 + %9 = arith.mulf %in, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg3 : memref to memref + return + } + func.func private @cosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_polar_scalarized/orig.mlir b/issues/aten_c_kernels/results/aten_polar_scalarized/orig.mlir new file mode 100644 index 000000000000..5c76ae531ff3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_polar_scalarized/orig.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_polar_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = func.call @cosf(%1) : (f32) -> f32 + %3 = arith.mulf %0, %2 : f32 + affine.store %3, %arg2[%arg4] : memref + %4 = affine.load %arg0[%arg4] : memref + %5 = affine.load %arg1[%arg4] : memref + %6 = func.call @sinf(%5) : (f32) -> f32 + %7 = arith.mulf %4, %6 : f32 + affine.store %7, %arg3[%arg4] : memref + } + return + } + func.func private @cosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_polar_scalarized/raised.mlir b/issues/aten_c_kernels/results/aten_polar_scalarized/raised.mlir new file mode 100644 index 000000000000..438b3a766322 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_polar_scalarized/raised.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_polar_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = math.cos %in_0 : f32 + %1 = arith.mulf %in, %0 : f32 + linalg.yield %1 : f32 + } + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = math.sin %in_0 : f32 + %1 = arith.mulf %in, %0 : f32 + linalg.yield %1 : f32 + } + return + } + func.func private @cosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_polar_scalarized_debuf.mlir b/issues/aten_c_kernels/results/aten_polar_scalarized_debuf.mlir new file mode 100644 index 000000000000..ab8ba3d16cb2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_polar_scalarized_debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_polar_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %8 = math.cos %in_0 : f32 + %9 = arith.mulf %in, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %8 = math.sin %in_0 : f32 + %9 = arith.mulf %in, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg3 : memref to memref + return + } + func.func private @cosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_polar_scalarized_linalg.mlir b/issues/aten_c_kernels/results/aten_polar_scalarized_linalg.mlir new file mode 100644 index 000000000000..438b3a766322 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_polar_scalarized_linalg.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_polar_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = math.cos %in_0 : f32 + %1 = arith.mulf %in, %0 : f32 + linalg.yield %1 : f32 + } + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = math.sin %in_0 : f32 + %1 = arith.mulf %in, %0 : f32 + linalg.yield %1 : f32 + } + return + } + func.func private @cosf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_polygamma.mlir b/issues/aten_c_kernels/results/aten_polygamma.mlir new file mode 100644 index 000000000000..144977d7b464 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_polygamma.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_polygamma(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = func.call @calc_polygammaf(%arg1, %0) : (i32, f32) -> f32 + affine.store %1, %arg2[%arg3] : memref + } + return + } + func.func private @calc_polygammaf(i32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_polygamma/debuf.mlir b/issues/aten_c_kernels/results/aten_polygamma/debuf.mlir new file mode 100644 index 000000000000..42bafb021ce1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_polygamma/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_polygamma(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_polygammaf(%arg1, %in) : (i32, f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } + func.func private @calc_polygammaf(i32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_polygamma/matched.mlir b/issues/aten_c_kernels/results/aten_polygamma/matched.mlir new file mode 100644 index 000000000000..42bafb021ce1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_polygamma/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_polygamma(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_polygammaf(%arg1, %in) : (i32, f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } + func.func private @calc_polygammaf(i32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_polygamma/orig.mlir b/issues/aten_c_kernels/results/aten_polygamma/orig.mlir new file mode 100644 index 000000000000..144977d7b464 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_polygamma/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_polygamma(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = func.call @calc_polygammaf(%arg1, %0) : (i32, f32) -> f32 + affine.store %1, %arg2[%arg3] : memref + } + return + } + func.func private @calc_polygammaf(i32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_polygamma/raised.mlir b/issues/aten_c_kernels/results/aten_polygamma/raised.mlir new file mode 100644 index 000000000000..2ccbca465648 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_polygamma/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_polygamma(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_polygammaf(%arg1, %in) : (i32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_polygammaf(i32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_polygamma_debuf.mlir b/issues/aten_c_kernels/results/aten_polygamma_debuf.mlir new file mode 100644 index 000000000000..42bafb021ce1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_polygamma_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_polygamma(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_polygammaf(%arg1, %in) : (i32, f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } + func.func private @calc_polygammaf(i32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_polygamma_linalg.mlir b/issues/aten_c_kernels/results/aten_polygamma_linalg.mlir new file mode 100644 index 000000000000..2ccbca465648 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_polygamma_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_polygamma(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_polygammaf(%arg1, %in) : (i32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_polygammaf(i32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_pow.mlir b/issues/aten_c_kernels/results/aten_pow.mlir new file mode 100644 index 000000000000..4d9937aecd68 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pow.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pow(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = math.powf %0, %1 : f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_pow/debuf.mlir b/issues/aten_c_kernels/results/aten_pow/debuf.mlir new file mode 100644 index 000000000000..946d165a94d9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pow/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pow(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = math.powf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pow/matched.mlir b/issues/aten_c_kernels/results/aten_pow/matched.mlir new file mode 100644 index 000000000000..946d165a94d9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pow/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pow(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = math.powf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pow/orig.mlir b/issues/aten_c_kernels/results/aten_pow/orig.mlir new file mode 100644 index 000000000000..4d9937aecd68 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pow/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pow(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = math.powf %0, %1 : f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_pow/raised.mlir b/issues/aten_c_kernels/results/aten_pow/raised.mlir new file mode 100644 index 000000000000..cf57fbd42df0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pow/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pow(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = math.powf %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pow_debuf.mlir b/issues/aten_c_kernels/results/aten_pow_debuf.mlir new file mode 100644 index 000000000000..946d165a94d9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pow_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pow(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = math.powf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pow_linalg.mlir b/issues/aten_c_kernels/results/aten_pow_linalg.mlir new file mode 100644 index 000000000000..cf57fbd42df0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pow_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pow(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = math.powf %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pow_tensor_scalar.mlir b/issues/aten_c_kernels/results/aten_pow_tensor_scalar.mlir new file mode 100644 index 000000000000..eaa323be0392 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pow_tensor_scalar.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pow_tensor_scalar(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = math.powf %0, %arg1 : f32 + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_pow_tensor_scalar/debuf.mlir b/issues/aten_c_kernels/results/aten_pow_tensor_scalar/debuf.mlir new file mode 100644 index 000000000000..ec2d3d4c0286 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pow_tensor_scalar/debuf.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pow_tensor_scalar(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.powf %in, %arg1 : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pow_tensor_scalar/matched.mlir b/issues/aten_c_kernels/results/aten_pow_tensor_scalar/matched.mlir new file mode 100644 index 000000000000..ec2d3d4c0286 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pow_tensor_scalar/matched.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pow_tensor_scalar(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.powf %in, %arg1 : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pow_tensor_scalar/orig.mlir b/issues/aten_c_kernels/results/aten_pow_tensor_scalar/orig.mlir new file mode 100644 index 000000000000..eaa323be0392 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pow_tensor_scalar/orig.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pow_tensor_scalar(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = math.powf %0, %arg1 : f32 + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_pow_tensor_scalar/raised.mlir b/issues/aten_c_kernels/results/aten_pow_tensor_scalar/raised.mlir new file mode 100644 index 000000000000..1142a7a7c22f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pow_tensor_scalar/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pow_tensor_scalar(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.powf %in, %arg1 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pow_tensor_scalar_debuf.mlir b/issues/aten_c_kernels/results/aten_pow_tensor_scalar_debuf.mlir new file mode 100644 index 000000000000..ec2d3d4c0286 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pow_tensor_scalar_debuf.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pow_tensor_scalar(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.powf %in, %arg1 : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_pow_tensor_scalar_linalg.mlir b/issues/aten_c_kernels/results/aten_pow_tensor_scalar_linalg.mlir new file mode 100644 index 000000000000..1142a7a7c22f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_pow_tensor_scalar_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_pow_tensor_scalar(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.powf %in, %arg1 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_powsum_cpu.mlir b/issues/aten_c_kernels/results/aten_powsum_cpu.mlir new file mode 100644 index 000000000000..b2a38670ea76 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_powsum_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_powsum_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 32 { + %0 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = arith.cmpf olt, %1, %cst : f32 + %3 = scf.if %2 -> (f32) { + %6 = arith.negf %1 : f32 + scf.yield %6 : f32 + } else { + scf.yield %1 : f32 + } + %4 = math.powf %3, %arg1 : f32 + %5 = arith.addf %arg5, %4 : f32 + affine.yield %5 : f32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_powsum_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_powsum_cpu/debuf.mlir new file mode 100644 index 000000000000..11dda99c9e1c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_powsum_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_powsum_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %cst : f32 + %6 = arith.negf %in : f32 + %7 = arith.select %5, %6, %in : f32 + %8 = math.powf %7, %arg1 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_powsum_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_powsum_cpu/matched.mlir new file mode 100644 index 000000000000..ccde4c5f838d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_powsum_cpu/matched.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_powsum_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = kernel.launch @memset_zero_1D_f32(%1) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %cst : f32 + %6 = arith.negf %in : f32 + %7 = arith.select %5, %6, %in : f32 + %8 = math.powf %7, %arg1 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_powsum_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_powsum_cpu/orig.mlir new file mode 100644 index 000000000000..b2a38670ea76 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_powsum_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_powsum_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 32 { + %0 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = arith.cmpf olt, %1, %cst : f32 + %3 = scf.if %2 -> (f32) { + %6 = arith.negf %1 : f32 + scf.yield %6 : f32 + } else { + scf.yield %1 : f32 + } + %4 = math.powf %3, %arg1 : f32 + %5 = arith.addf %arg5, %4 : f32 + affine.yield %5 : f32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_powsum_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_powsum_cpu/raised.mlir new file mode 100644 index 000000000000..be8b140b73a5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_powsum_cpu/raised.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_powsum_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg2[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %cst : f32 + %1 = arith.negf %in : f32 + %2 = arith.select %0, %1, %in : f32 + %3 = math.powf %2, %arg1 : f32 + %4 = arith.addf %out, %3 : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_powsum_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_powsum_cpu_debuf.mlir new file mode 100644 index 000000000000..11dda99c9e1c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_powsum_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_powsum_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf olt, %in, %cst : f32 + %6 = arith.negf %in : f32 + %7 = arith.select %5, %6, %in : f32 + %8 = math.powf %7, %arg1 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_powsum_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_powsum_cpu_linalg.mlir new file mode 100644 index 000000000000..be8b140b73a5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_powsum_cpu_linalg.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_powsum_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg2[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %cst : f32 + %1 = arith.negf %in : f32 + %2 = arith.select %0, %1, %in : f32 + %3 = math.powf %2, %arg1 : f32 + %4 = arith.addf %out, %3 : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_prod.mlir b/issues/aten_c_kernels/results/aten_prod.mlir new file mode 100644 index 000000000000..accdabb94c7a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_prod.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_prod(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.store %cst, %arg1[0] : memref + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = affine.load %arg1[0] : memref + %2 = arith.mulf %1, %0 : f32 + affine.store %2, %arg1[0] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_prod/debuf.mlir b/issues/aten_c_kernels/results/aten_prod/debuf.mlir new file mode 100644 index 000000000000..1ea05b9dc69c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_prod/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_prod(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %cst into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_prod/matched.mlir b/issues/aten_c_kernels/results/aten_prod/matched.mlir new file mode 100644 index 000000000000..1ea05b9dc69c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_prod/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_prod(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %cst into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_prod/orig.mlir b/issues/aten_c_kernels/results/aten_prod/orig.mlir new file mode 100644 index 000000000000..accdabb94c7a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_prod/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_prod(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.store %cst, %arg1[0] : memref + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = affine.load %arg1[0] : memref + %2 = arith.mulf %1, %0 : f32 + affine.store %2, %arg1[0] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_prod/raised.mlir b/issues/aten_c_kernels/results/aten_prod/raised.mlir new file mode 100644 index 000000000000..8675f8995f28 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_prod/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_prod(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.store %cst, %arg1[0] : memref + %subview = memref.subview %arg1[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %out, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_prod_debuf.mlir b/issues/aten_c_kernels/results/aten_prod_debuf.mlir new file mode 100644 index 000000000000..1ea05b9dc69c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_prod_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_prod(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %cst into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_prod_linalg.mlir b/issues/aten_c_kernels/results/aten_prod_linalg.mlir new file mode 100644 index 000000000000..8675f8995f28 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_prod_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_prod(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.store %cst, %arg1[0] : memref + %subview = memref.subview %arg1[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %out, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_put_cpu.mlir b/issues/aten_c_kernels/results/aten_put_cpu.mlir new file mode 100644 index 000000000000..d82299ab63fe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_put_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_put_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg3, %c0_i32 : i32 + affine.for %arg4 = 0 to 32 { + scf.if %0 { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg4] : memref + %4 = memref.load %arg0[%2] : memref + %5 = arith.addf %4, %3 : f32 + memref.store %5, %arg0[%2] : memref + } else { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg4] : memref + memref.store %3, %arg0[%2] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_put_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_put_cpu/debuf.mlir new file mode 100644 index 000000000000..18eef93fbc8f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_put_cpu/debuf.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_put_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = arith.cmpi ne, %arg3, %c0_i32 : i32 + %4 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %2) -> (tensor) { + %6 = scf.if %3 -> (tensor) { + %extracted = tensor.extract %1[%arg4] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg4] : tensor + %extracted_1 = tensor.extract %arg5[%7] : tensor + %8 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %8 into %arg5[%7] : tensor + scf.yield %inserted : tensor + } else { + %extracted = tensor.extract %1[%arg4] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg4] : tensor + %inserted = tensor.insert %extracted_0 into %arg5[%7] : tensor + scf.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_put_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_put_cpu/matched.mlir new file mode 100644 index 000000000000..18eef93fbc8f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_put_cpu/matched.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_put_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = arith.cmpi ne, %arg3, %c0_i32 : i32 + %4 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %2) -> (tensor) { + %6 = scf.if %3 -> (tensor) { + %extracted = tensor.extract %1[%arg4] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg4] : tensor + %extracted_1 = tensor.extract %arg5[%7] : tensor + %8 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %8 into %arg5[%7] : tensor + scf.yield %inserted : tensor + } else { + %extracted = tensor.extract %1[%arg4] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg4] : tensor + %inserted = tensor.insert %extracted_0 into %arg5[%7] : tensor + scf.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_put_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_put_cpu/orig.mlir new file mode 100644 index 000000000000..d82299ab63fe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_put_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_put_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg3, %c0_i32 : i32 + affine.for %arg4 = 0 to 32 { + scf.if %0 { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg4] : memref + %4 = memref.load %arg0[%2] : memref + %5 = arith.addf %4, %3 : f32 + memref.store %5, %arg0[%2] : memref + } else { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg4] : memref + memref.store %3, %arg0[%2] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_put_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_put_cpu/raised.mlir new file mode 100644 index 000000000000..9660aac23288 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_put_cpu/raised.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_put_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg3, %c0_i32 : i32 + affine.for %arg4 = 0 to 32 { + scf.if %0 { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg4] : memref + %4 = memref.load %arg0[%2] : memref + %5 = arith.addf %4, %3 : f32 + memref.store %5, %arg0[%2] : memref + } else { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg4] : memref + memref.store %3, %arg0[%2] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_put_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_put_cpu_debuf.mlir new file mode 100644 index 000000000000..18eef93fbc8f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_put_cpu_debuf.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_put_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = arith.cmpi ne, %arg3, %c0_i32 : i32 + %4 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %2) -> (tensor) { + %6 = scf.if %3 -> (tensor) { + %extracted = tensor.extract %1[%arg4] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg4] : tensor + %extracted_1 = tensor.extract %arg5[%7] : tensor + %8 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %8 into %arg5[%7] : tensor + scf.yield %inserted : tensor + } else { + %extracted = tensor.extract %1[%arg4] : tensor + %7 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg4] : tensor + %inserted = tensor.insert %extracted_0 into %arg5[%7] : tensor + scf.yield %inserted : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_put_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_put_cpu_linalg.mlir new file mode 100644 index 000000000000..9660aac23288 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_put_cpu_linalg.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_put_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg3, %c0_i32 : i32 + affine.for %arg4 = 0 to 32 { + scf.if %0 { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg4] : memref + %4 = memref.load %arg0[%2] : memref + %5 = arith.addf %4, %3 : f32 + memref.store %5, %arg0[%2] : memref + } else { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg4] : memref + memref.store %3, %arg0[%2] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu.mlir b/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu.mlir new file mode 100644 index 000000000000..7cd90a2be7a7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quant_col_offsets_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64_i32 = arith.constant 64 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.muli %arg1, %c64_i32 : i32 + affine.for %arg3 = 0 to 48 { + %1 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %c0_i32) -> (i32) { + %3 = affine.load %arg0[%arg4, %arg3] : memref + %4 = arith.extsi %3 : i8 to i32 + %5 = arith.addi %arg5, %4 : i32 + affine.yield %5 : i32 + } + %2 = arith.subi %1, %0 : i32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu/debuf.mlir new file mode 100644 index 000000000000..46fd5cc0e4f7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu/debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quant_col_offsets_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64_i32 = arith.constant 64 : i32 + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.muli %arg1, %c64_i32 : i32 + %3 = tensor.empty(%c48) : tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%3 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %4[0] [%c48] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i8, %out: i32): + %8 = arith.extsi %in : i8 to i32 + %9 = arith.addi %out, %8 : i32 + linalg.yield %9 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %4[0] [%c48] [1] : tensor into tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + %8 = arith.subi %in, %2 : i32 + linalg.yield %8 : i32 + } -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu/matched.mlir new file mode 100644 index 000000000000..cd32ab08f69f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu/matched.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quant_col_offsets_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64_i32 = arith.constant 64 : i32 + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.muli %arg1, %c64_i32 : i32 + %3 = tensor.empty(%c48) : tensor + %4 = kernel.launch @memset_zero_1D(%3) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %4[0] [%c48] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i8, %out: i32): + %8 = arith.extsi %in : i8 to i32 + %9 = arith.addi %out, %8 : i32 + linalg.yield %9 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %4[0] [%c48] [1] : tensor into tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + %8 = arith.subi %in, %2 : i32 + linalg.yield %8 : i32 + } -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu/orig.mlir new file mode 100644 index 000000000000..7cd90a2be7a7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu/orig.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quant_col_offsets_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64_i32 = arith.constant 64 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.muli %arg1, %c64_i32 : i32 + affine.for %arg3 = 0 to 48 { + %1 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %c0_i32) -> (i32) { + %3 = affine.load %arg0[%arg4, %arg3] : memref + %4 = arith.extsi %3 : i8 to i32 + %5 = arith.addi %arg5, %4 : i32 + affine.yield %5 : i32 + } + %2 = arith.subi %1, %0 : i32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu/raised.mlir new file mode 100644 index 000000000000..2428da8d3d43 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu/raised.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quant_col_offsets_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %c64_i32 = arith.constant 64 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.muli %arg1, %c64_i32 : i32 + %alloca = memref.alloca(%c48) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c64, %c48] [1, 1] : memref to memref> + %subview_0 = memref.subview %alloca[0] [%c48] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: i8, %out: i32): + %1 = arith.extsi %in : i8 to i32 + %2 = arith.addi %out, %1 : i32 + linalg.yield %2 : i32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca : memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %out: i32): + %1 = arith.subi %in, %0 : i32 + linalg.yield %1 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu_debuf.mlir new file mode 100644 index 000000000000..46fd5cc0e4f7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu_debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quant_col_offsets_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64_i32 = arith.constant 64 : i32 + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.muli %arg1, %c64_i32 : i32 + %3 = tensor.empty(%c48) : tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%3 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %4[0] [%c48] [1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i8, %out: i32): + %8 = arith.extsi %in : i8 to i32 + %9 = arith.addi %out, %8 : i32 + linalg.yield %9 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %4[0] [%c48] [1] : tensor into tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + %8 = arith.subi %in, %2 : i32 + linalg.yield %8 : i32 + } -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu_linalg.mlir new file mode 100644 index 000000000000..2428da8d3d43 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quant_col_offsets_cpu_linalg.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quant_col_offsets_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %c64_i32 = arith.constant 64 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.muli %arg1, %c64_i32 : i32 + %alloca = memref.alloca(%c48) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c64, %c48] [1, 1] : memref to memref> + %subview_0 = memref.subview %alloca[0] [%c48] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: i8, %out: i32): + %1 = arith.extsi %in : i8 to i32 + %2 = arith.addi %out, %1 : i32 + linalg.yield %2 : i32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca : memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %out: i32): + %1 = arith.subi %in, %0 : i32 + linalg.yield %1 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_quant_saturation_cpu.mlir b/issues/aten_c_kernels/results/aten_quant_saturation_cpu.mlir new file mode 100644 index 000000000000..18e37af4a0ae --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quant_saturation_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quant_saturation_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %c127_i32 = arith.constant 127 : i32 + %c-128_i32 = arith.constant -128 : i32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.cmpi slt, %0, %c-128_i32 : i32 + %2 = arith.select %1, %c-128_i32, %0 : i32 + %3 = scf.if %1 -> (i1) { + scf.yield %false : i1 + } else { + %6 = arith.cmpi sgt, %0, %c127_i32 : i32 + scf.yield %6 : i1 + } + %4 = arith.select %3, %c127_i32, %2 : i32 + %5 = arith.trunci %4 : i32 to i8 + affine.store %5, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_quant_saturation_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_quant_saturation_cpu/debuf.mlir new file mode 100644 index 000000000000..8cf135cafcf6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quant_saturation_cpu/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quant_saturation_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-128_i32 = arith.constant -128 : i32 + %c127_i32 = arith.constant 127 : i32 + %false = arith.constant false + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i8): + %4 = arith.cmpi slt, %in, %c-128_i32 : i32 + %5 = arith.select %4, %c-128_i32, %in : i32 + %6 = arith.cmpi sgt, %in, %c127_i32 : i32 + %7 = arith.select %4, %false, %6 : i1 + %8 = arith.select %7, %c127_i32, %5 : i32 + %9 = arith.trunci %8 : i32 to i8 + linalg.yield %9 : i8 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_quant_saturation_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_quant_saturation_cpu/matched.mlir new file mode 100644 index 000000000000..8cf135cafcf6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quant_saturation_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quant_saturation_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-128_i32 = arith.constant -128 : i32 + %c127_i32 = arith.constant 127 : i32 + %false = arith.constant false + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i8): + %4 = arith.cmpi slt, %in, %c-128_i32 : i32 + %5 = arith.select %4, %c-128_i32, %in : i32 + %6 = arith.cmpi sgt, %in, %c127_i32 : i32 + %7 = arith.select %4, %false, %6 : i1 + %8 = arith.select %7, %c127_i32, %5 : i32 + %9 = arith.trunci %8 : i32 to i8 + linalg.yield %9 : i8 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_quant_saturation_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_quant_saturation_cpu/orig.mlir new file mode 100644 index 000000000000..18e37af4a0ae --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quant_saturation_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quant_saturation_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %c127_i32 = arith.constant 127 : i32 + %c-128_i32 = arith.constant -128 : i32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.cmpi slt, %0, %c-128_i32 : i32 + %2 = arith.select %1, %c-128_i32, %0 : i32 + %3 = scf.if %1 -> (i1) { + scf.yield %false : i1 + } else { + %6 = arith.cmpi sgt, %0, %c127_i32 : i32 + scf.yield %6 : i1 + } + %4 = arith.select %3, %c127_i32, %2 : i32 + %5 = arith.trunci %4 : i32 to i8 + affine.store %5, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_quant_saturation_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_quant_saturation_cpu/raised.mlir new file mode 100644 index 000000000000..2fde65b33093 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quant_saturation_cpu/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quant_saturation_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %c127_i32 = arith.constant 127 : i32 + %c-128_i32 = arith.constant -128 : i32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: i32, %out: i8): + %0 = arith.cmpi slt, %in, %c-128_i32 : i32 + %1 = arith.select %0, %c-128_i32, %in : i32 + %2 = arith.cmpi sgt, %in, %c127_i32 : i32 + %3 = arith.select %0, %false, %2 : i1 + %4 = arith.select %3, %c127_i32, %1 : i32 + %5 = arith.trunci %4 : i32 to i8 + linalg.yield %5 : i8 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_quant_saturation_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_quant_saturation_cpu_debuf.mlir new file mode 100644 index 000000000000..8cf135cafcf6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quant_saturation_cpu_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quant_saturation_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-128_i32 = arith.constant -128 : i32 + %c127_i32 = arith.constant 127 : i32 + %false = arith.constant false + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i8): + %4 = arith.cmpi slt, %in, %c-128_i32 : i32 + %5 = arith.select %4, %c-128_i32, %in : i32 + %6 = arith.cmpi sgt, %in, %c127_i32 : i32 + %7 = arith.select %4, %false, %6 : i1 + %8 = arith.select %7, %c127_i32, %5 : i32 + %9 = arith.trunci %8 : i32 to i8 + linalg.yield %9 : i8 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_quant_saturation_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_quant_saturation_cpu_linalg.mlir new file mode 100644 index 000000000000..2fde65b33093 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quant_saturation_cpu_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quant_saturation_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %c127_i32 = arith.constant 127 : i32 + %c-128_i32 = arith.constant -128 : i32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: i32, %out: i8): + %0 = arith.cmpi slt, %in, %c-128_i32 : i32 + %1 = arith.select %0, %c-128_i32, %in : i32 + %2 = arith.cmpi sgt, %in, %c127_i32 : i32 + %3 = arith.select %0, %false, %2 : i1 + %4 = arith.select %3, %c127_i32, %1 : i32 + %5 = arith.trunci %4 : i32 to i8 + linalg.yield %5 : i8 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_quick_select_cpu.mlir b/issues/aten_c_kernels/results/aten_quick_select_cpu.mlir new file mode 100644 index 000000000000..750ccfd7f49c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quick_select_cpu.mlir @@ -0,0 +1,27 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quick_select_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg1 : i32 to index + affine.for %arg3 = 0 to #map()[%0] { + %2 = arith.index_cast %arg3 : index to i32 + %3 = affine.for %arg4 = #map1(%arg3) to 127 iter_args(%arg5 = %2) -> (i32) { + %7 = arith.index_cast %arg4 : index to i32 + %8 = affine.load %arg0[%arg4] : memref + %9 = arith.index_cast %arg5 : i32 to index + %10 = memref.load %arg0[%9] : memref + %11 = arith.cmpf olt, %8, %10 : f32 + %12 = arith.select %11, %7, %arg5 : i32 + affine.yield %12 : i32 + } + %4 = affine.load %arg0[%arg3] : memref + %5 = arith.index_cast %3 : i32 to index + %6 = memref.load %arg0[%5] : memref + affine.store %6, %arg0[%arg3] : memref + memref.store %4, %arg0[%5] : memref + } + %1 = affine.load %arg0[symbol(%0)] : memref + affine.store %1, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_quick_select_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_quick_select_cpu/debuf.mlir new file mode 100644 index 000000000000..7dd24dd364b5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quick_select_cpu/debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quick_select_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = arith.index_cast %arg1 : i32 to index + %3 = affine.apply #map()[%2] + %4 = tensor.empty(%3) : tensor + %5:2 = affine.for %arg3 = 0 to #map()[%2] iter_args(%arg4 = %4, %arg5 = %1) -> (tensor, tensor) { + %8 = arith.index_cast %arg3 : index to i32 + %inserted_0 = tensor.insert %8 into %arg4[%arg3] : tensor + %9 = affine.for %arg6 = #map1(%arg3) to 127 iter_args(%arg7 = %inserted_0) -> (tensor) { + %extracted_6 = tensor.extract %arg7[%arg3] : tensor + %11 = arith.index_cast %arg6 : index to i32 + %extracted_7 = tensor.extract %arg5[%arg6] : tensor + %12 = arith.index_cast %extracted_6 : i32 to index + %extracted_8 = tensor.extract %arg5[%12] : tensor + %13 = arith.cmpf olt, %extracted_7, %extracted_8 : f32 + %14 = arith.select %13, %11, %extracted_6 : i32 + %inserted_9 = tensor.insert %14 into %arg7[%arg3] : tensor + affine.yield %inserted_9 : tensor + } + %extracted_1 = tensor.extract %9[%arg3] : tensor + %extracted_2 = tensor.extract %arg5[%arg3] : tensor + %10 = arith.index_cast %extracted_1 : i32 to index + %extracted_3 = tensor.extract %arg5[%10] : tensor + %inserted_4 = tensor.insert %extracted_3 into %arg5[%arg3] : tensor + %inserted_5 = tensor.insert %extracted_2 into %inserted_4[%10] : tensor + affine.yield %9, %inserted_5 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg0 : memref to memref + %extracted = tensor.extract %5#1[%2] : tensor + %inserted = tensor.insert %extracted into %0[%c0] : tensor + %7 = bufferization.to_memref %inserted : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_quick_select_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_quick_select_cpu/matched.mlir new file mode 100644 index 000000000000..7dd24dd364b5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quick_select_cpu/matched.mlir @@ -0,0 +1,42 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quick_select_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = arith.index_cast %arg1 : i32 to index + %3 = affine.apply #map()[%2] + %4 = tensor.empty(%3) : tensor + %5:2 = affine.for %arg3 = 0 to #map()[%2] iter_args(%arg4 = %4, %arg5 = %1) -> (tensor, tensor) { + %8 = arith.index_cast %arg3 : index to i32 + %inserted_0 = tensor.insert %8 into %arg4[%arg3] : tensor + %9 = affine.for %arg6 = #map1(%arg3) to 127 iter_args(%arg7 = %inserted_0) -> (tensor) { + %extracted_6 = tensor.extract %arg7[%arg3] : tensor + %11 = arith.index_cast %arg6 : index to i32 + %extracted_7 = tensor.extract %arg5[%arg6] : tensor + %12 = arith.index_cast %extracted_6 : i32 to index + %extracted_8 = tensor.extract %arg5[%12] : tensor + %13 = arith.cmpf olt, %extracted_7, %extracted_8 : f32 + %14 = arith.select %13, %11, %extracted_6 : i32 + %inserted_9 = tensor.insert %14 into %arg7[%arg3] : tensor + affine.yield %inserted_9 : tensor + } + %extracted_1 = tensor.extract %9[%arg3] : tensor + %extracted_2 = tensor.extract %arg5[%arg3] : tensor + %10 = arith.index_cast %extracted_1 : i32 to index + %extracted_3 = tensor.extract %arg5[%10] : tensor + %inserted_4 = tensor.insert %extracted_3 into %arg5[%arg3] : tensor + %inserted_5 = tensor.insert %extracted_2 into %inserted_4[%10] : tensor + affine.yield %9, %inserted_5 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg0 : memref to memref + %extracted = tensor.extract %5#1[%2] : tensor + %inserted = tensor.insert %extracted into %0[%c0] : tensor + %7 = bufferization.to_memref %inserted : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_quick_select_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_quick_select_cpu/orig.mlir new file mode 100644 index 000000000000..750ccfd7f49c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quick_select_cpu/orig.mlir @@ -0,0 +1,27 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quick_select_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg1 : i32 to index + affine.for %arg3 = 0 to #map()[%0] { + %2 = arith.index_cast %arg3 : index to i32 + %3 = affine.for %arg4 = #map1(%arg3) to 127 iter_args(%arg5 = %2) -> (i32) { + %7 = arith.index_cast %arg4 : index to i32 + %8 = affine.load %arg0[%arg4] : memref + %9 = arith.index_cast %arg5 : i32 to index + %10 = memref.load %arg0[%9] : memref + %11 = arith.cmpf olt, %8, %10 : f32 + %12 = arith.select %11, %7, %arg5 : i32 + affine.yield %12 : i32 + } + %4 = affine.load %arg0[%arg3] : memref + %5 = arith.index_cast %3 : i32 to index + %6 = memref.load %arg0[%5] : memref + affine.store %6, %arg0[%arg3] : memref + memref.store %4, %arg0[%5] : memref + } + %1 = affine.load %arg0[symbol(%0)] : memref + affine.store %1, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_quick_select_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_quick_select_cpu/raised.mlir new file mode 100644 index 000000000000..c729d8be2185 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quick_select_cpu/raised.mlir @@ -0,0 +1,33 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quick_select_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg1 : i32 to index + %1 = affine.apply #map()[%0] + %alloca = memref.alloca(%1) : memref + affine.for %arg3 = 0 to #map()[%0] { + %3 = arith.index_cast %arg3 : index to i32 + affine.store %3, %alloca[%arg3] : memref + affine.for %arg4 = #map1(%arg3) to 127 { + %8 = affine.load %alloca[%arg3] : memref + %9 = arith.index_cast %arg4 : index to i32 + %10 = affine.load %arg0[%arg4] : memref + %11 = arith.index_cast %8 : i32 to index + %12 = memref.load %arg0[%11] : memref + %13 = arith.cmpf olt, %10, %12 : f32 + %14 = arith.select %13, %9, %8 : i32 + affine.store %14, %alloca[%arg3] : memref + } + %4 = affine.load %alloca[%arg3] : memref + %5 = affine.load %arg0[%arg3] : memref + %6 = arith.index_cast %4 : i32 to index + %7 = memref.load %arg0[%6] : memref + affine.store %7, %arg0[%arg3] : memref + memref.store %5, %arg0[%6] : memref + } + %2 = affine.load %arg0[symbol(%0)] : memref + affine.store %2, %arg2[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_quick_select_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_quick_select_cpu_debuf.mlir new file mode 100644 index 000000000000..7dd24dd364b5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quick_select_cpu_debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quick_select_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = arith.index_cast %arg1 : i32 to index + %3 = affine.apply #map()[%2] + %4 = tensor.empty(%3) : tensor + %5:2 = affine.for %arg3 = 0 to #map()[%2] iter_args(%arg4 = %4, %arg5 = %1) -> (tensor, tensor) { + %8 = arith.index_cast %arg3 : index to i32 + %inserted_0 = tensor.insert %8 into %arg4[%arg3] : tensor + %9 = affine.for %arg6 = #map1(%arg3) to 127 iter_args(%arg7 = %inserted_0) -> (tensor) { + %extracted_6 = tensor.extract %arg7[%arg3] : tensor + %11 = arith.index_cast %arg6 : index to i32 + %extracted_7 = tensor.extract %arg5[%arg6] : tensor + %12 = arith.index_cast %extracted_6 : i32 to index + %extracted_8 = tensor.extract %arg5[%12] : tensor + %13 = arith.cmpf olt, %extracted_7, %extracted_8 : f32 + %14 = arith.select %13, %11, %extracted_6 : i32 + %inserted_9 = tensor.insert %14 into %arg7[%arg3] : tensor + affine.yield %inserted_9 : tensor + } + %extracted_1 = tensor.extract %9[%arg3] : tensor + %extracted_2 = tensor.extract %arg5[%arg3] : tensor + %10 = arith.index_cast %extracted_1 : i32 to index + %extracted_3 = tensor.extract %arg5[%10] : tensor + %inserted_4 = tensor.insert %extracted_3 into %arg5[%arg3] : tensor + %inserted_5 = tensor.insert %extracted_2 into %inserted_4[%10] : tensor + affine.yield %9, %inserted_5 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg0 : memref to memref + %extracted = tensor.extract %5#1[%2] : tensor + %inserted = tensor.insert %extracted into %0[%c0] : tensor + %7 = bufferization.to_memref %inserted : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_quick_select_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_quick_select_cpu_linalg.mlir new file mode 100644 index 000000000000..c729d8be2185 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_quick_select_cpu_linalg.mlir @@ -0,0 +1,33 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_quick_select_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg1 : i32 to index + %1 = affine.apply #map()[%0] + %alloca = memref.alloca(%1) : memref + affine.for %arg3 = 0 to #map()[%0] { + %3 = arith.index_cast %arg3 : index to i32 + affine.store %3, %alloca[%arg3] : memref + affine.for %arg4 = #map1(%arg3) to 127 { + %8 = affine.load %alloca[%arg3] : memref + %9 = arith.index_cast %arg4 : index to i32 + %10 = affine.load %arg0[%arg4] : memref + %11 = arith.index_cast %8 : i32 to index + %12 = memref.load %arg0[%11] : memref + %13 = arith.cmpf olt, %10, %12 : f32 + %14 = arith.select %13, %9, %8 : i32 + affine.store %14, %alloca[%arg3] : memref + } + %4 = affine.load %alloca[%arg3] : memref + %5 = affine.load %arg0[%arg3] : memref + %6 = arith.index_cast %4 : i32 to index + %7 = memref.load %arg0[%6] : memref + affine.store %7, %arg0[%arg3] : memref + memref.store %5, %arg0[%6] : memref + } + %2 = affine.load %arg0[symbol(%0)] : memref + affine.store %2, %arg2[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_random_cpu.mlir b/issues/aten_c_kernels/results/aten_random_cpu.mlir new file mode 100644 index 000000000000..ae8302c5a7c5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_cpu.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.remui %0, %arg1 : i32 + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_random_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_random_cpu/debuf.mlir new file mode 100644 index 000000000000..82b551bffb4b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_cpu/debuf.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + %4 = arith.remui %in, %arg1 : i32 + linalg.yield %4 : i32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_random_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_random_cpu/matched.mlir new file mode 100644 index 000000000000..82b551bffb4b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_cpu/matched.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + %4 = arith.remui %in, %arg1 : i32 + linalg.yield %4 : i32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_random_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_random_cpu/orig.mlir new file mode 100644 index 000000000000..ae8302c5a7c5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_cpu/orig.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.remui %0, %arg1 : i32 + affine.store %1, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_random_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_random_cpu/raised.mlir new file mode 100644 index 000000000000..34617cdbded9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_cpu/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %out: i32): + %0 = arith.remui %in, %arg1 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_random_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_random_cpu_debuf.mlir new file mode 100644 index 000000000000..82b551bffb4b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_cpu_debuf.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + %4 = arith.remui %in, %arg1 : i32 + linalg.yield %4 : i32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_random_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_random_cpu_linalg.mlir new file mode 100644 index 000000000000..34617cdbded9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_cpu_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %out: i32): + %0 = arith.remui %in, %arg1 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_random_from_to_cpu.mlir b/issues/aten_c_kernels/results/aten_random_from_to_cpu.mlir new file mode 100644 index 000000000000..b235830c8b49 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_from_to_cpu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_from_to_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.subi %arg2, %arg1 : i32 + affine.for %arg4 = 0 to 4096 { + %1 = affine.load %arg0[%arg4] : memref + %2 = arith.remui %1, %0 : i32 + %3 = arith.addi %arg1, %2 : i32 + affine.store %3, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_random_from_to_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_random_from_to_cpu/debuf.mlir new file mode 100644 index 000000000000..3f81047acf6e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_from_to_cpu/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_from_to_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = arith.subi %arg2, %arg1 : i32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.remui %in, %2 : i32 + %6 = arith.addi %arg1, %5 : i32 + linalg.yield %6 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_random_from_to_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_random_from_to_cpu/matched.mlir new file mode 100644 index 000000000000..3f81047acf6e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_from_to_cpu/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_from_to_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = arith.subi %arg2, %arg1 : i32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.remui %in, %2 : i32 + %6 = arith.addi %arg1, %5 : i32 + linalg.yield %6 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_random_from_to_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_random_from_to_cpu/orig.mlir new file mode 100644 index 000000000000..b235830c8b49 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_from_to_cpu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_from_to_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.subi %arg2, %arg1 : i32 + affine.for %arg4 = 0 to 4096 { + %1 = affine.load %arg0[%arg4] : memref + %2 = arith.remui %1, %0 : i32 + %3 = arith.addi %arg1, %2 : i32 + affine.store %3, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_random_from_to_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_random_from_to_cpu/raised.mlir new file mode 100644 index 000000000000..b41358a414d9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_from_to_cpu/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_from_to_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.subi %arg2, %arg1 : i32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg3 : memref) { + ^bb0(%in: i32, %out: i32): + %1 = arith.remui %in, %0 : i32 + %2 = arith.addi %arg1, %1 : i32 + linalg.yield %2 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_random_from_to_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_random_from_to_cpu_debuf.mlir new file mode 100644 index 000000000000..3f81047acf6e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_from_to_cpu_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_from_to_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = arith.subi %arg2, %arg1 : i32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.remui %in, %2 : i32 + %6 = arith.addi %arg1, %5 : i32 + linalg.yield %6 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_random_from_to_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_random_from_to_cpu_linalg.mlir new file mode 100644 index 000000000000..b41358a414d9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_from_to_cpu_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_from_to_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.subi %arg2, %arg1 : i32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg3 : memref) { + ^bb0(%in: i32, %out: i32): + %1 = arith.remui %in, %0 : i32 + %2 = arith.addi %arg1, %1 : i32 + linalg.yield %2 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu.mlir b/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu.mlir new file mode 100644 index 000000000000..fce0694aa3cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu.mlir @@ -0,0 +1,9 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_full_64_bits_range_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu/debuf.mlir new file mode 100644 index 000000000000..7b43058e16ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu/debuf.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_full_64_bits_range_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i64, %out: i64): + linalg.yield %in : i64 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu/matched.mlir new file mode 100644 index 000000000000..7b43058e16ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu/matched.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_full_64_bits_range_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i64, %out: i64): + linalg.yield %in : i64 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu/orig.mlir new file mode 100644 index 000000000000..fce0694aa3cf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu/orig.mlir @@ -0,0 +1,9 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_full_64_bits_range_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu/raised.mlir new file mode 100644 index 000000000000..2b3e5fc29c55 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu/raised.mlir @@ -0,0 +1,11 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_full_64_bits_range_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: i64, %out: i64): + linalg.yield %in : i64 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu_debuf.mlir new file mode 100644 index 000000000000..7b43058e16ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu_debuf.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_full_64_bits_range_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: i64, %out: i64): + linalg.yield %in : i64 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu_linalg.mlir new file mode 100644 index 000000000000..2b3e5fc29c55 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_random_full_64_bits_range_cpu_linalg.mlir @@ -0,0 +1,11 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_random_full_64_bits_range_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: i64, %out: i64): + linalg.yield %in : i64 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_randperm_cpu.mlir b/issues/aten_c_kernels/results/aten_randperm_cpu.mlir new file mode 100644 index 000000000000..f3bc449bcd92 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_randperm_cpu.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_randperm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %c1_i32 = arith.constant 1 : i32 + affine.for %arg2 = 0 to 256 { + %0 = arith.index_cast %arg2 : index to i32 + affine.store %0, %arg1[%arg2] : memref + } + affine.for %arg2 = 1 to 256 { + %0 = arith.subi %c256, %arg2 : index + %1 = arith.index_cast %0 : index to i32 + %2 = affine.load %arg0[-%arg2 + 256] : memref + %3 = arith.addi %1, %c1_i32 : i32 + %4 = arith.remui %2, %3 : i32 + %5 = affine.load %arg1[-%arg2 + 256] : memref + %6 = arith.index_cast %4 : i32 to index + %7 = memref.load %arg1[%6] : memref + affine.store %7, %arg1[-%arg2 + 256] : memref + memref.store %5, %arg1[%6] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_randperm_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_randperm_cpu/debuf.mlir new file mode 100644 index 000000000000..72d056955093 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_randperm_cpu/debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 256)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_randperm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c256 = arith.constant 256 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: i32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + linalg.yield %6 : i32 + } -> tensor + %3 = affine.for %arg2 = 1 to 256 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.subi %c256, %arg2 : index + %6 = arith.index_cast %5 : index to i32 + %7 = affine.apply #map1(%arg2) + %extracted = tensor.extract %1[%7] : tensor + %8 = arith.addi %6, %c1_i32 : i32 + %9 = arith.remui %extracted, %8 : i32 + %10 = affine.apply #map1(%arg2) + %extracted_0 = tensor.extract %arg3[%10] : tensor + %11 = arith.index_cast %9 : i32 to index + %extracted_1 = tensor.extract %arg3[%11] : tensor + %12 = affine.apply #map1(%arg2) + %inserted = tensor.insert %extracted_1 into %arg3[%12] : tensor + %inserted_2 = tensor.insert %extracted_0 into %inserted[%11] : tensor + affine.yield %inserted_2 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_randperm_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_randperm_cpu/matched.mlir new file mode 100644 index 000000000000..72d056955093 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_randperm_cpu/matched.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 256)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_randperm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c256 = arith.constant 256 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: i32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + linalg.yield %6 : i32 + } -> tensor + %3 = affine.for %arg2 = 1 to 256 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.subi %c256, %arg2 : index + %6 = arith.index_cast %5 : index to i32 + %7 = affine.apply #map1(%arg2) + %extracted = tensor.extract %1[%7] : tensor + %8 = arith.addi %6, %c1_i32 : i32 + %9 = arith.remui %extracted, %8 : i32 + %10 = affine.apply #map1(%arg2) + %extracted_0 = tensor.extract %arg3[%10] : tensor + %11 = arith.index_cast %9 : i32 to index + %extracted_1 = tensor.extract %arg3[%11] : tensor + %12 = affine.apply #map1(%arg2) + %inserted = tensor.insert %extracted_1 into %arg3[%12] : tensor + %inserted_2 = tensor.insert %extracted_0 into %inserted[%11] : tensor + affine.yield %inserted_2 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_randperm_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_randperm_cpu/orig.mlir new file mode 100644 index 000000000000..f3bc449bcd92 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_randperm_cpu/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_randperm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %c1_i32 = arith.constant 1 : i32 + affine.for %arg2 = 0 to 256 { + %0 = arith.index_cast %arg2 : index to i32 + affine.store %0, %arg1[%arg2] : memref + } + affine.for %arg2 = 1 to 256 { + %0 = arith.subi %c256, %arg2 : index + %1 = arith.index_cast %0 : index to i32 + %2 = affine.load %arg0[-%arg2 + 256] : memref + %3 = arith.addi %1, %c1_i32 : i32 + %4 = arith.remui %2, %3 : i32 + %5 = affine.load %arg1[-%arg2 + 256] : memref + %6 = arith.index_cast %4 : i32 to index + %7 = memref.load %arg1[%6] : memref + affine.store %7, %arg1[-%arg2 + 256] : memref + memref.store %5, %arg1[%6] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_randperm_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_randperm_cpu/raised.mlir new file mode 100644 index 000000000000..48d998960d21 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_randperm_cpu/raised.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_randperm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %c1_i32 = arith.constant 1 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: i32): + %0 = linalg.index 0 : index + %1 = arith.index_cast %0 : index to i32 + linalg.yield %1 : i32 + } + affine.for %arg2 = 1 to 256 { + %0 = arith.subi %c256, %arg2 : index + %1 = arith.index_cast %0 : index to i32 + %2 = affine.load %arg0[-%arg2 + 256] : memref + %3 = arith.addi %1, %c1_i32 : i32 + %4 = arith.remui %2, %3 : i32 + %5 = affine.load %arg1[-%arg2 + 256] : memref + %6 = arith.index_cast %4 : i32 to index + %7 = memref.load %arg1[%6] : memref + affine.store %7, %arg1[-%arg2 + 256] : memref + memref.store %5, %arg1[%6] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_randperm_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_randperm_cpu_debuf.mlir new file mode 100644 index 000000000000..72d056955093 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_randperm_cpu_debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 256)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_randperm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c256 = arith.constant 256 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: i32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + linalg.yield %6 : i32 + } -> tensor + %3 = affine.for %arg2 = 1 to 256 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.subi %c256, %arg2 : index + %6 = arith.index_cast %5 : index to i32 + %7 = affine.apply #map1(%arg2) + %extracted = tensor.extract %1[%7] : tensor + %8 = arith.addi %6, %c1_i32 : i32 + %9 = arith.remui %extracted, %8 : i32 + %10 = affine.apply #map1(%arg2) + %extracted_0 = tensor.extract %arg3[%10] : tensor + %11 = arith.index_cast %9 : i32 to index + %extracted_1 = tensor.extract %arg3[%11] : tensor + %12 = affine.apply #map1(%arg2) + %inserted = tensor.insert %extracted_1 into %arg3[%12] : tensor + %inserted_2 = tensor.insert %extracted_0 into %inserted[%11] : tensor + affine.yield %inserted_2 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_randperm_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_randperm_cpu_linalg.mlir new file mode 100644 index 000000000000..48d998960d21 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_randperm_cpu_linalg.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_randperm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %c1_i32 = arith.constant 1 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: i32): + %0 = linalg.index 0 : index + %1 = arith.index_cast %0 : index to i32 + linalg.yield %1 : i32 + } + affine.for %arg2 = 1 to 256 { + %0 = arith.subi %c256, %arg2 : index + %1 = arith.index_cast %0 : index to i32 + %2 = affine.load %arg0[-%arg2 + 256] : memref + %3 = arith.addi %1, %c1_i32 : i32 + %4 = arith.remui %2, %3 : i32 + %5 = affine.load %arg1[-%arg2 + 256] : memref + %6 = arith.index_cast %4 : i32 to index + %7 = memref.load %arg1[%6] : memref + affine.store %7, %arg1[-%arg2 + 256] : memref + memref.store %5, %arg1[%6] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_range_out_cpu.mlir b/issues/aten_c_kernels/results/aten_range_out_cpu.mlir new file mode 100644 index 000000000000..dbc5d513b0bb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_range_out_cpu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_range_out_cpu(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 256 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.mulf %1, %arg1 : f32 + %3 = arith.addf %arg0, %2 : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_range_out_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_range_out_cpu/debuf.mlir new file mode 100644 index 000000000000..e815e10dfe14 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_range_out_cpu/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_range_out_cpu(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.sitofp %4 : i32 to f32 + %6 = arith.mulf %5, %arg1 : f32 + %7 = arith.addf %arg0, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_range_out_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_range_out_cpu/matched.mlir new file mode 100644 index 000000000000..e815e10dfe14 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_range_out_cpu/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_range_out_cpu(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.sitofp %4 : i32 to f32 + %6 = arith.mulf %5, %arg1 : f32 + %7 = arith.addf %arg0, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_range_out_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_range_out_cpu/orig.mlir new file mode 100644 index 000000000000..dbc5d513b0bb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_range_out_cpu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_range_out_cpu(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 256 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.mulf %1, %arg1 : f32 + %3 = arith.addf %arg0, %2 : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_range_out_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_range_out_cpu/raised.mlir new file mode 100644 index 000000000000..3ca48b743e03 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_range_out_cpu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_range_out_cpu(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.sitofp %1 : i32 to f32 + %3 = arith.mulf %2, %arg1 : f32 + %4 = arith.addf %arg0, %3 : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_range_out_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_range_out_cpu_debuf.mlir new file mode 100644 index 000000000000..e815e10dfe14 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_range_out_cpu_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_range_out_cpu(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.sitofp %4 : i32 to f32 + %6 = arith.mulf %5, %arg1 : f32 + %7 = arith.addf %arg0, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_range_out_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_range_out_cpu_linalg.mlir new file mode 100644 index 000000000000..3ca48b743e03 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_range_out_cpu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_range_out_cpu(%arg0: f32, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.sitofp %1 : i32 to f32 + %3 = arith.mulf %2, %arg1 : f32 + %4 = arith.addf %arg0, %3 : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reciprocal.mlir b/issues/aten_c_kernels/results/aten_reciprocal.mlir new file mode 100644 index 000000000000..08da68358a9a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reciprocal.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reciprocal(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.divf %cst, %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reciprocal/debuf.mlir b/issues/aten_c_kernels/results/aten_reciprocal/debuf.mlir new file mode 100644 index 000000000000..bef6b79d45f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reciprocal/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reciprocal(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.divf %cst, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reciprocal/matched.mlir b/issues/aten_c_kernels/results/aten_reciprocal/matched.mlir new file mode 100644 index 000000000000..bef6b79d45f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reciprocal/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reciprocal(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.divf %cst, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reciprocal/orig.mlir b/issues/aten_c_kernels/results/aten_reciprocal/orig.mlir new file mode 100644 index 000000000000..08da68358a9a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reciprocal/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reciprocal(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.divf %cst, %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reciprocal/raised.mlir b/issues/aten_c_kernels/results/aten_reciprocal/raised.mlir new file mode 100644 index 000000000000..f5b35b77a2cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reciprocal/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reciprocal(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.divf %cst, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reciprocal_debuf.mlir b/issues/aten_c_kernels/results/aten_reciprocal_debuf.mlir new file mode 100644 index 000000000000..bef6b79d45f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reciprocal_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reciprocal(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.divf %cst, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reciprocal_linalg.mlir b/issues/aten_c_kernels/results/aten_reciprocal_linalg.mlir new file mode 100644 index 000000000000..f5b35b77a2cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reciprocal_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reciprocal(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.divf %cst, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu.mlir b/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu.mlir new file mode 100644 index 000000000000..60134d005c1b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflect_conj_tri_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 64 { + affine.for %arg3 = #map(%arg2) to 64 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + affine.store %0, %arg0[%arg3, %arg2] : memref + %1 = affine.load %arg1[%arg2, %arg3] : memref + %2 = arith.negf %1 : f32 + affine.store %2, %arg1[%arg3, %arg2] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu/debuf.mlir new file mode 100644 index 000000000000..2d5bcd80515a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu/debuf.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflect_conj_tri_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %1[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = linalg.index 0 : index + %7 = linalg.index 1 : index + %8 = affine.apply #map2(%6) + %9 = arith.cmpi sge, %7, %8 : index + %10 = arith.select %9, %in, %out : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c64, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg0 : memref to memref + %extracted_slice_1 = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = linalg.index 0 : index + %7 = arith.negf %in : f32 + %8 = linalg.index 1 : index + %9 = affine.apply #map2(%6) + %10 = arith.cmpi sge, %8, %9 : index + %11 = arith.select %10, %7, %out : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice_3 = tensor.insert_slice %4 into %0[0, 0] [%c64, %c64] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice_3 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu/matched.mlir new file mode 100644 index 000000000000..2d5bcd80515a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu/matched.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflect_conj_tri_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %1[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = linalg.index 0 : index + %7 = linalg.index 1 : index + %8 = affine.apply #map2(%6) + %9 = arith.cmpi sge, %7, %8 : index + %10 = arith.select %9, %in, %out : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c64, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg0 : memref to memref + %extracted_slice_1 = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = linalg.index 0 : index + %7 = arith.negf %in : f32 + %8 = linalg.index 1 : index + %9 = affine.apply #map2(%6) + %10 = arith.cmpi sge, %8, %9 : index + %11 = arith.select %10, %7, %out : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice_3 = tensor.insert_slice %4 into %0[0, 0] [%c64, %c64] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice_3 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu/orig.mlir new file mode 100644 index 000000000000..60134d005c1b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu/orig.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflect_conj_tri_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 64 { + affine.for %arg3 = #map(%arg2) to 64 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + affine.store %0, %arg0[%arg3, %arg2] : memref + %1 = affine.load %arg1[%arg2, %arg3] : memref + %2 = arith.negf %1 : f32 + affine.store %2, %arg1[%arg3, %arg2] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu/raised.mlir new file mode 100644 index 000000000000..317f23318b5a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu/raised.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflect_conj_tri_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 0] [%c64, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c64, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = affine.apply #map2(%0) + %3 = arith.cmpi sge, %1, %2 : index + %4 = arith.select %3, %in, %out : f32 + linalg.yield %4 : f32 + } + %subview_1 = memref.subview %arg1[0, 0] [%c64, %c64] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg1[0, 0] [%c64, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview_1 : memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = linalg.index 0 : index + %1 = arith.negf %in : f32 + %2 = linalg.index 1 : index + %3 = affine.apply #map2(%0) + %4 = arith.cmpi sge, %2, %3 : index + %5 = arith.select %4, %1, %out : f32 + linalg.yield %5 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu_debuf.mlir new file mode 100644 index 000000000000..2d5bcd80515a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu_debuf.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflect_conj_tri_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %1[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = linalg.index 0 : index + %7 = linalg.index 1 : index + %8 = affine.apply #map2(%6) + %9 = arith.cmpi sge, %7, %8 : index + %10 = arith.select %9, %in, %out : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c64, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg0 : memref to memref + %extracted_slice_1 = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = linalg.index 0 : index + %7 = arith.negf %in : f32 + %8 = linalg.index 1 : index + %9 = affine.apply #map2(%6) + %10 = arith.cmpi sge, %8, %9 : index + %11 = arith.select %10, %7, %out : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice_3 = tensor.insert_slice %4 into %0[0, 0] [%c64, %c64] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice_3 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu_linalg.mlir new file mode 100644 index 000000000000..317f23318b5a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflect_conj_tri_cpu_linalg.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflect_conj_tri_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 0] [%c64, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c64, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = affine.apply #map2(%0) + %3 = arith.cmpi sge, %1, %2 : index + %4 = arith.select %3, %in, %out : f32 + linalg.yield %4 : f32 + } + %subview_1 = memref.subview %arg1[0, 0] [%c64, %c64] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg1[0, 0] [%c64, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview_1 : memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = linalg.index 0 : index + %1 = arith.negf %in : f32 + %2 = linalg.index 1 : index + %3 = affine.apply #map2(%0) + %4 = arith.cmpi sge, %2, %3 : index + %5 = arith.select %4, %1, %out : f32 + linalg.yield %5 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu.mlir new file mode 100644 index 000000000000..132c5b40e852 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu.mlir @@ -0,0 +1,41 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-2_i32 = arith.constant -2 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 8 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.if #set(%arg3) -> i32 { + %12 = arith.subi %c2_i32, %2 : i32 + affine.yield %12 : i32 + } else { + affine.yield %3 : i32 + } + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = scf.if %5 -> (i32) { + %12 = arith.subi %c6_i32, %4 : i32 + scf.yield %12 : i32 + } else { + scf.yield %4 : i32 + } + %7 = arith.addi %1, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[%arg3 + %arg2 * 8] : memref + %10 = memref.load %arg1[%8] : memref + %11 = arith.addf %10, %9 : f32 + memref.store %11, %arg1[%8] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..36afa411f07d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu/debuf.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1) -> (d0 + d1 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = affine.apply #map1(%arg4) + %11 = arith.cmpi sge, %10, %c0 : index + %12 = arith.subi %c2_i32, %8 : i32 + %13 = arith.select %11, %12, %9 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.subi %c6_i32, %13 : i32 + %16 = arith.select %14, %15, %13 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = affine.apply #map2(%arg4, %arg2) + %extracted = tensor.extract %1[%19] : tensor + %extracted_0 = tensor.extract %arg5[%18] : tensor + %20 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %20 into %arg5[%18] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..3ca12a8cec30 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu/matched.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1) -> (d0 + d1 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = affine.apply #map1(%arg4) + %11 = arith.cmpi sge, %10, %c0 : index + %12 = arith.subi %c2_i32, %8 : i32 + %13 = arith.select %11, %12, %9 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.subi %c6_i32, %13 : i32 + %16 = arith.select %14, %15, %13 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = affine.apply #map2(%arg4, %arg2) + %extracted = tensor.extract %1[%19] : tensor + %extracted_0 = tensor.extract %arg5[%18] : tensor + %20 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %20 into %arg5[%18] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..132c5b40e852 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu/orig.mlir @@ -0,0 +1,41 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-2_i32 = arith.constant -2 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 8 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.if #set(%arg3) -> i32 { + %12 = arith.subi %c2_i32, %2 : i32 + affine.yield %12 : i32 + } else { + affine.yield %3 : i32 + } + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = scf.if %5 -> (i32) { + %12 = arith.subi %c6_i32, %4 : i32 + scf.yield %12 : i32 + } else { + scf.yield %4 : i32 + } + %7 = arith.addi %1, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[%arg3 + %arg2 * 8] : memref + %10 = memref.load %arg1[%8] : memref + %11 = arith.addf %10, %9 : f32 + memref.store %11, %arg1[%8] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..bfadaef8cd4b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu/raised.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c-2_i32 = arith.constant -2 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.apply #map1(%arg3) + %5 = arith.cmpi sge, %4, %c0 : index + %6 = arith.subi %c2_i32, %2 : i32 + %7 = arith.select %5, %6, %3 : i32 + %8 = arith.cmpi sge, %7, %c4_i32 : i32 + %9 = arith.subi %c6_i32, %7 : i32 + %10 = arith.select %8, %9, %7 : i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = affine.load %arg0[%arg3 + %arg2 * 8] : memref + %14 = memref.load %arg1[%12] : memref + %15 = arith.addf %14, %13 : f32 + memref.store %15, %arg1[%12] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..36afa411f07d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu_debuf.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1) -> (d0 + d1 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = affine.apply #map1(%arg4) + %11 = arith.cmpi sge, %10, %c0 : index + %12 = arith.subi %c2_i32, %8 : i32 + %13 = arith.select %11, %12, %9 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.subi %c6_i32, %13 : i32 + %16 = arith.select %14, %15, %13 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = affine.apply #map2(%arg4, %arg2) + %extracted = tensor.extract %1[%19] : tensor + %extracted_0 = tensor.extract %arg5[%18] : tensor + %20 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %20 into %arg5[%18] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..bfadaef8cd4b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad1d_backward_cpu_linalg.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c-2_i32 = arith.constant -2 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.apply #map1(%arg3) + %5 = arith.cmpi sge, %4, %c0 : index + %6 = arith.subi %c2_i32, %2 : i32 + %7 = arith.select %5, %6, %3 : i32 + %8 = arith.cmpi sge, %7, %c4_i32 : i32 + %9 = arith.subi %c6_i32, %7 : i32 + %10 = arith.select %8, %9, %7 : i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = affine.load %arg0[%arg3 + %arg2 * 8] : memref + %14 = memref.load %arg1[%12] : memref + %15 = arith.addf %14, %13 : f32 + memref.store %15, %arg1[%12] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu.mlir b/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu.mlir new file mode 100644 index 000000000000..60b82b86322a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu.mlir @@ -0,0 +1,35 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-2_i32 = arith.constant -2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.if #set(%arg3) -> i32 { + %10 = arith.subi %c2_i32, %2 : i32 + affine.yield %10 : i32 + } else { + affine.yield %3 : i32 + } + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = scf.if %5 -> (i32) { + %10 = arith.subi %c6_i32, %4 : i32 + scf.yield %10 : i32 + } else { + scf.yield %4 : i32 + } + %7 = arith.addi %1, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = memref.load %arg0[%8] : memref + affine.store %9, %arg1[%arg3 + %arg2 * 8] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu/debuf.mlir new file mode 100644 index 000000000000..0f9dc1b4abd4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu/debuf.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 8)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c6_i32 = arith.constant 6 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.apply #map2(%8) + %12 = arith.cmpi sge, %11, %c0 : index + %13 = arith.subi %c2_i32, %9 : i32 + %14 = arith.select %12, %13, %10 : i32 + %15 = arith.cmpi sge, %14, %c4_i32 : i32 + %16 = arith.subi %c6_i32, %14 : i32 + %17 = arith.select %15, %16, %14 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg0[%19] : memref + linalg.yield %20 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu/matched.mlir new file mode 100644 index 000000000000..0f9dc1b4abd4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu/matched.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 8)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c6_i32 = arith.constant 6 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.apply #map2(%8) + %12 = arith.cmpi sge, %11, %c0 : index + %13 = arith.subi %c2_i32, %9 : i32 + %14 = arith.select %12, %13, %10 : i32 + %15 = arith.cmpi sge, %14, %c4_i32 : i32 + %16 = arith.subi %c6_i32, %14 : i32 + %17 = arith.select %15, %16, %14 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg0[%19] : memref + linalg.yield %20 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu/orig.mlir new file mode 100644 index 000000000000..60b82b86322a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu/orig.mlir @@ -0,0 +1,35 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-2_i32 = arith.constant -2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.if #set(%arg3) -> i32 { + %10 = arith.subi %c2_i32, %2 : i32 + affine.yield %10 : i32 + } else { + affine.yield %3 : i32 + } + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = scf.if %5 -> (i32) { + %10 = arith.subi %c6_i32, %4 : i32 + scf.yield %10 : i32 + } else { + scf.yield %4 : i32 + } + %7 = arith.addi %1, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = memref.load %arg0[%8] : memref + affine.store %9, %arg1[%arg3 + %arg2 * 8] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu/raised.mlir new file mode 100644 index 000000000000..48d3cd679a75 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu/raised.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 8)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %c-2_i32 = arith.constant -2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + %0 = polygeist.submap(%arg1, %c2, %c8) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.addi %5, %c-2_i32 : i32 + %7 = affine.apply #map2(%4) + %8 = arith.cmpi sge, %7, %c0 : index + %9 = arith.subi %c2_i32, %5 : i32 + %10 = arith.select %8, %9, %6 : i32 + %11 = arith.cmpi sge, %10, %c4_i32 : i32 + %12 = arith.subi %c6_i32, %10 : i32 + %13 = arith.select %11, %12, %10 : i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = memref.load %arg0[%15] : memref + linalg.yield %16 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu_debuf.mlir new file mode 100644 index 000000000000..0f9dc1b4abd4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu_debuf.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 8)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c6_i32 = arith.constant 6 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.apply #map2(%8) + %12 = arith.cmpi sge, %11, %c0 : index + %13 = arith.subi %c2_i32, %9 : i32 + %14 = arith.select %12, %13, %10 : i32 + %15 = arith.cmpi sge, %14, %c4_i32 : i32 + %16 = arith.subi %c6_i32, %14 : i32 + %17 = arith.select %15, %16, %14 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg0[%19] : memref + linalg.yield %20 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu_linalg.mlir new file mode 100644 index 000000000000..48d3cd679a75 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad1d_cpu_linalg.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 8)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %c-2_i32 = arith.constant -2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + %0 = polygeist.submap(%arg1, %c2, %c8) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.addi %5, %c-2_i32 : i32 + %7 = affine.apply #map2(%4) + %8 = arith.cmpi sge, %7, %c0 : index + %9 = arith.subi %c2_i32, %5 : i32 + %10 = arith.select %8, %9, %6 : i32 + %11 = arith.cmpi sge, %10, %c4_i32 : i32 + %12 = arith.subi %c6_i32, %10 : i32 + %13 = arith.select %11, %12, %10 : i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = memref.load %arg0[%15] : memref + linalg.yield %16 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d.mlir new file mode 100644 index 000000000000..ddec62a5670d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d.mlir @@ -0,0 +1,44 @@ +#set = affine_set<(d0) : (d0 == 0)> +#set1 = affine_set<(d0) : (d0 - 9 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c6_i32 = arith.constant 6 : i32 + %c1_i32 = arith.constant 1 : i32 + affine.for %arg2 = 0 to 3 { + affine.for %arg3 = 0 to 10 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = affine.if #set(%arg3) -> i32 { + affine.yield %c1_i32 : i32 + } else { + %3 = affine.if #set1(%arg3) -> i32 { + affine.yield %c6_i32 : i32 + } else { + %4 = arith.addi %0, %c-1_i32 : i32 + affine.yield %4 : i32 + } + affine.yield %3 : i32 + } + %2 = arith.index_cast %1 : i32 to index + affine.for %arg4 = 0 to 10 { + %3 = arith.index_cast %arg4 : index to i32 + %4 = affine.if #set(%arg4) -> i32 { + affine.yield %c1_i32 : i32 + } else { + %7 = affine.if #set1(%arg4) -> i32 { + affine.yield %c6_i32 : i32 + } else { + %8 = arith.addi %3, %c-1_i32 : i32 + affine.yield %8 : i32 + } + affine.yield %7 : i32 + } + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%arg2, %2, %5] : memref + affine.store %6, %arg1[%arg2, %arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d/debuf.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d/debuf.mlir new file mode 100644 index 000000000000..7342bb5cc8de --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d/debuf.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0) -> (d0 - 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c6_i32 = arith.constant 6 : i32 + %c-1_i32 = arith.constant -1 : i32 + %c10 = arith.constant 10 : index + %c0 = arith.constant 0 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c3, %c10, %c10] [1, 1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.cmpi eq, %4, %c0 : index + %7 = affine.apply #map1(%4) + %8 = arith.cmpi eq, %7, %c0 : index + %9 = arith.addi %5, %c-1_i32 : i32 + %10 = arith.select %8, %c6_i32, %9 : i32 + %11 = arith.select %6, %c1_i32, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = linalg.index 2 : index + %14 = arith.index_cast %13 : index to i32 + %15 = arith.cmpi eq, %13, %c0 : index + %16 = affine.apply #map1(%13) + %17 = arith.cmpi eq, %16, %c0 : index + %18 = arith.addi %14, %c-1_i32 : i32 + %19 = arith.select %17, %c6_i32, %18 : i32 + %20 = arith.select %15, %c1_i32, %19 : i32 + %21 = arith.index_cast %20 : i32 to index + %22 = memref.load %arg0[%3, %12, %21] : memref + linalg.yield %22 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0, 0] [%c3, %c10, %c10] [1, 1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d/matched.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d/matched.mlir new file mode 100644 index 000000000000..7342bb5cc8de --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d/matched.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0) -> (d0 - 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c6_i32 = arith.constant 6 : i32 + %c-1_i32 = arith.constant -1 : i32 + %c10 = arith.constant 10 : index + %c0 = arith.constant 0 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c3, %c10, %c10] [1, 1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.cmpi eq, %4, %c0 : index + %7 = affine.apply #map1(%4) + %8 = arith.cmpi eq, %7, %c0 : index + %9 = arith.addi %5, %c-1_i32 : i32 + %10 = arith.select %8, %c6_i32, %9 : i32 + %11 = arith.select %6, %c1_i32, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = linalg.index 2 : index + %14 = arith.index_cast %13 : index to i32 + %15 = arith.cmpi eq, %13, %c0 : index + %16 = affine.apply #map1(%13) + %17 = arith.cmpi eq, %16, %c0 : index + %18 = arith.addi %14, %c-1_i32 : i32 + %19 = arith.select %17, %c6_i32, %18 : i32 + %20 = arith.select %15, %c1_i32, %19 : i32 + %21 = arith.index_cast %20 : i32 to index + %22 = memref.load %arg0[%3, %12, %21] : memref + linalg.yield %22 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0, 0] [%c3, %c10, %c10] [1, 1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d/orig.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d/orig.mlir new file mode 100644 index 000000000000..ddec62a5670d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d/orig.mlir @@ -0,0 +1,44 @@ +#set = affine_set<(d0) : (d0 == 0)> +#set1 = affine_set<(d0) : (d0 - 9 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c6_i32 = arith.constant 6 : i32 + %c1_i32 = arith.constant 1 : i32 + affine.for %arg2 = 0 to 3 { + affine.for %arg3 = 0 to 10 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = affine.if #set(%arg3) -> i32 { + affine.yield %c1_i32 : i32 + } else { + %3 = affine.if #set1(%arg3) -> i32 { + affine.yield %c6_i32 : i32 + } else { + %4 = arith.addi %0, %c-1_i32 : i32 + affine.yield %4 : i32 + } + affine.yield %3 : i32 + } + %2 = arith.index_cast %1 : i32 to index + affine.for %arg4 = 0 to 10 { + %3 = arith.index_cast %arg4 : index to i32 + %4 = affine.if #set(%arg4) -> i32 { + affine.yield %c1_i32 : i32 + } else { + %7 = affine.if #set1(%arg4) -> i32 { + affine.yield %c6_i32 : i32 + } else { + %8 = arith.addi %3, %c-1_i32 : i32 + affine.yield %8 : i32 + } + affine.yield %7 : i32 + } + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%arg2, %2, %5] : memref + affine.store %6, %arg1[%arg2, %arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d/raised.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d/raised.mlir new file mode 100644 index 000000000000..2989bb4ee999 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d/raised.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0) -> (d0 - 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c0 = arith.constant 0 : index + %c10 = arith.constant 10 : index + %c-1_i32 = arith.constant -1 : i32 + %c6_i32 = arith.constant 6 : i32 + %c1_i32 = arith.constant 1 : i32 + %subview = memref.subview %arg1[0, 0, 0] [%c3, %c10, %c10] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.cmpi eq, %1, %c0 : index + %4 = affine.apply #map1(%1) + %5 = arith.cmpi eq, %4, %c0 : index + %6 = arith.addi %2, %c-1_i32 : i32 + %7 = arith.select %5, %c6_i32, %6 : i32 + %8 = arith.select %3, %c1_i32, %7 : i32 + %9 = arith.index_cast %8 : i32 to index + %10 = linalg.index 2 : index + %11 = arith.index_cast %10 : index to i32 + %12 = arith.cmpi eq, %10, %c0 : index + %13 = affine.apply #map1(%10) + %14 = arith.cmpi eq, %13, %c0 : index + %15 = arith.addi %11, %c-1_i32 : i32 + %16 = arith.select %14, %c6_i32, %15 : i32 + %17 = arith.select %12, %c1_i32, %16 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = memref.load %arg0[%0, %9, %18] : memref + linalg.yield %19 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu.mlir new file mode 100644 index 000000000000..19e89ad85337 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu.mlir @@ -0,0 +1,62 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-2_i32 = arith.constant -2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 40 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.if #set(%arg3) -> i32 { + %9 = arith.subi %c2_i32, %2 : i32 + affine.yield %9 : i32 + } else { + affine.yield %3 : i32 + } + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = scf.if %5 -> (i32) { + %9 = arith.subi %c6_i32, %4 : i32 + scf.yield %9 : i32 + } else { + scf.yield %4 : i32 + } + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.if #set(%arg4) -> i32 { + %19 = arith.subi %c2_i32, %9 : i32 + affine.yield %19 : i32 + } else { + affine.yield %10 : i32 + } + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = scf.if %12 -> (i32) { + %19 = arith.subi %c8_i32, %11 : i32 + scf.yield %19 : i32 + } else { + scf.yield %11 : i32 + } + %14 = arith.addi %8, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = affine.load %arg0[%arg4 + %arg2 * 72 + %arg3 * 9] : memref + %17 = memref.load %arg1[%15] : memref + %18 = arith.addf %17, %16 : f32 + memref.store %18, %arg1[%15] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..438f4c6d8058 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu/debuf.mlir @@ -0,0 +1,63 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1, d2) -> (d0 + d1 * 72 + d2 * 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c6_i32 = arith.constant 6 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = affine.apply #map1(%arg4) + %11 = arith.cmpi sge, %10, %c0 : index + %12 = arith.subi %c2_i32, %8 : i32 + %13 = arith.select %11, %12, %9 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.subi %c6_i32, %13 : i32 + %16 = arith.select %14, %15, %13 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = affine.for %arg6 = 0 to 9 iter_args(%arg7 = %arg5) -> (tensor) { + %20 = arith.index_cast %arg6 : index to i32 + %21 = arith.addi %20, %c-2_i32 : i32 + %22 = affine.apply #map1(%arg6) + %23 = arith.cmpi sge, %22, %c0 : index + %24 = arith.subi %c2_i32, %20 : i32 + %25 = arith.select %23, %24, %21 : i32 + %26 = arith.cmpi sge, %25, %c5_i32 : i32 + %27 = arith.subi %c8_i32, %25 : i32 + %28 = arith.select %26, %27, %25 : i32 + %29 = arith.addi %18, %28 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = affine.apply #map2(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%31] : tensor + %extracted_0 = tensor.extract %arg7[%30] : tensor + %32 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %32 into %arg7[%30] : tensor + affine.yield %inserted : tensor + } + affine.yield %19 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..46249f1b195f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu/matched.mlir @@ -0,0 +1,60 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1, d2) -> (d0 + d1 * 72 + d2 * 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c6_i32 = arith.constant 6 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = affine.apply #map1(%arg4) + %11 = arith.cmpi sge, %10, %c0 : index + %12 = arith.subi %c2_i32, %8 : i32 + %13 = arith.select %11, %12, %9 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.subi %c6_i32, %13 : i32 + %16 = arith.select %14, %15, %13 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = affine.for %arg6 = 0 to 9 iter_args(%arg7 = %arg5) -> (tensor) { + %20 = arith.index_cast %arg6 : index to i32 + %21 = arith.addi %20, %c-2_i32 : i32 + %22 = affine.apply #map1(%arg6) + %23 = arith.cmpi sge, %22, %c0 : index + %24 = arith.subi %c2_i32, %20 : i32 + %25 = arith.select %23, %24, %21 : i32 + %26 = arith.cmpi sge, %25, %c5_i32 : i32 + %27 = arith.subi %c8_i32, %25 : i32 + %28 = arith.select %26, %27, %25 : i32 + %29 = arith.addi %18, %28 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = affine.apply #map2(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%31] : tensor + %extracted_0 = tensor.extract %arg7[%30] : tensor + %32 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %32 into %arg7[%30] : tensor + affine.yield %inserted : tensor + } + affine.yield %19 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..19e89ad85337 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu/orig.mlir @@ -0,0 +1,62 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-2_i32 = arith.constant -2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 40 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.if #set(%arg3) -> i32 { + %9 = arith.subi %c2_i32, %2 : i32 + affine.yield %9 : i32 + } else { + affine.yield %3 : i32 + } + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = scf.if %5 -> (i32) { + %9 = arith.subi %c6_i32, %4 : i32 + scf.yield %9 : i32 + } else { + scf.yield %4 : i32 + } + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.if #set(%arg4) -> i32 { + %19 = arith.subi %c2_i32, %9 : i32 + affine.yield %19 : i32 + } else { + affine.yield %10 : i32 + } + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = scf.if %12 -> (i32) { + %19 = arith.subi %c8_i32, %11 : i32 + scf.yield %19 : i32 + } else { + scf.yield %11 : i32 + } + %14 = arith.addi %8, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = affine.load %arg0[%arg4 + %arg2 * 72 + %arg3 * 9] : memref + %17 = memref.load %arg1[%15] : memref + %18 = arith.addf %17, %16 : f32 + memref.store %18, %arg1[%15] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..1e89d7c46c93 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu/raised.mlir @@ -0,0 +1,54 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c-2_i32 = arith.constant -2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.apply #map1(%arg3) + %5 = arith.cmpi sge, %4, %c0 : index + %6 = arith.subi %c2_i32, %2 : i32 + %7 = arith.select %5, %6, %3 : i32 + %8 = arith.cmpi sge, %7, %c4_i32 : i32 + %9 = arith.subi %c6_i32, %7 : i32 + %10 = arith.select %8, %9, %7 : i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %13 = arith.index_cast %arg4 : index to i32 + %14 = arith.addi %13, %c-2_i32 : i32 + %15 = affine.apply #map1(%arg4) + %16 = arith.cmpi sge, %15, %c0 : index + %17 = arith.subi %c2_i32, %13 : i32 + %18 = arith.select %16, %17, %14 : i32 + %19 = arith.cmpi sge, %18, %c5_i32 : i32 + %20 = arith.subi %c8_i32, %18 : i32 + %21 = arith.select %19, %20, %18 : i32 + %22 = arith.addi %12, %21 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = affine.load %arg0[%arg4 + %arg2 * 72 + %arg3 * 9] : memref + %25 = memref.load %arg1[%23] : memref + %26 = arith.addf %25, %24 : f32 + memref.store %26, %arg1[%23] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..438f4c6d8058 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu_debuf.mlir @@ -0,0 +1,63 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1, d2) -> (d0 + d1 * 72 + d2 * 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c6_i32 = arith.constant 6 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = affine.apply #map1(%arg4) + %11 = arith.cmpi sge, %10, %c0 : index + %12 = arith.subi %c2_i32, %8 : i32 + %13 = arith.select %11, %12, %9 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.subi %c6_i32, %13 : i32 + %16 = arith.select %14, %15, %13 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = affine.for %arg6 = 0 to 9 iter_args(%arg7 = %arg5) -> (tensor) { + %20 = arith.index_cast %arg6 : index to i32 + %21 = arith.addi %20, %c-2_i32 : i32 + %22 = affine.apply #map1(%arg6) + %23 = arith.cmpi sge, %22, %c0 : index + %24 = arith.subi %c2_i32, %20 : i32 + %25 = arith.select %23, %24, %21 : i32 + %26 = arith.cmpi sge, %25, %c5_i32 : i32 + %27 = arith.subi %c8_i32, %25 : i32 + %28 = arith.select %26, %27, %25 : i32 + %29 = arith.addi %18, %28 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = affine.apply #map2(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%31] : tensor + %extracted_0 = tensor.extract %arg7[%30] : tensor + %32 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %32 into %arg7[%30] : tensor + affine.yield %inserted : tensor + } + affine.yield %19 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..1e89d7c46c93 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d_backward_cpu_linalg.mlir @@ -0,0 +1,54 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c-2_i32 = arith.constant -2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.apply #map1(%arg3) + %5 = arith.cmpi sge, %4, %c0 : index + %6 = arith.subi %c2_i32, %2 : i32 + %7 = arith.select %5, %6, %3 : i32 + %8 = arith.cmpi sge, %7, %c4_i32 : i32 + %9 = arith.subi %c6_i32, %7 : i32 + %10 = arith.select %8, %9, %7 : i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %13 = arith.index_cast %arg4 : index to i32 + %14 = arith.addi %13, %c-2_i32 : i32 + %15 = affine.apply #map1(%arg4) + %16 = arith.cmpi sge, %15, %c0 : index + %17 = arith.subi %c2_i32, %13 : i32 + %18 = arith.select %16, %17, %14 : i32 + %19 = arith.cmpi sge, %18, %c5_i32 : i32 + %20 = arith.subi %c8_i32, %18 : i32 + %21 = arith.select %19, %20, %18 : i32 + %22 = arith.addi %12, %21 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = affine.load %arg0[%arg4 + %arg2 * 72 + %arg3 * 9] : memref + %25 = memref.load %arg1[%23] : memref + %26 = arith.addf %25, %24 : f32 + memref.store %26, %arg1[%23] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu.mlir new file mode 100644 index 000000000000..d6d6b6cfb24b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu.mlir @@ -0,0 +1,56 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-2_i32 = arith.constant -2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c8_i32 = arith.constant 8 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.if #set(%arg3) -> i32 { + %9 = arith.subi %c2_i32, %2 : i32 + affine.yield %9 : i32 + } else { + affine.yield %3 : i32 + } + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = scf.if %5 -> (i32) { + %9 = arith.subi %c6_i32, %4 : i32 + scf.yield %9 : i32 + } else { + scf.yield %4 : i32 + } + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.if #set(%arg4) -> i32 { + %17 = arith.subi %c2_i32, %9 : i32 + affine.yield %17 : i32 + } else { + affine.yield %10 : i32 + } + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = scf.if %12 -> (i32) { + %17 = arith.subi %c8_i32, %11 : i32 + scf.yield %17 : i32 + } else { + scf.yield %11 : i32 + } + %14 = arith.addi %8, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = memref.load %arg0[%15] : memref + affine.store %16, %arg1[%arg4 + %arg2 * 72 + %arg3 * 9] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu/debuf.mlir new file mode 100644 index 000000000000..594a9ac70af0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu/debuf.mlir @@ -0,0 +1,56 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 72 + d1 * 9)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c8_i32 = arith.constant 8 : i32 + %c6_i32 = arith.constant 6 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8, %c9) {map = #map} : (tensor, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.apply #map2(%8) + %12 = arith.cmpi sge, %11, %c0 : index + %13 = arith.subi %c2_i32, %9 : i32 + %14 = arith.select %12, %13, %10 : i32 + %15 = arith.cmpi sge, %14, %c4_i32 : i32 + %16 = arith.subi %c6_i32, %14 : i32 + %17 = arith.select %15, %16, %14 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = linalg.index 2 : index + %21 = arith.index_cast %20 : index to i32 + %22 = arith.addi %21, %c-2_i32 : i32 + %23 = affine.apply #map2(%20) + %24 = arith.cmpi sge, %23, %c0 : index + %25 = arith.subi %c2_i32, %21 : i32 + %26 = arith.select %24, %25, %22 : i32 + %27 = arith.cmpi sge, %26, %c5_i32 : i32 + %28 = arith.subi %c8_i32, %26 : i32 + %29 = arith.select %27, %28, %26 : i32 + %30 = arith.addi %19, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %arg0[%31] : memref + linalg.yield %32 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8, %c9) {map = #map} : (tensor, tensor, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu/matched.mlir new file mode 100644 index 000000000000..594a9ac70af0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu/matched.mlir @@ -0,0 +1,56 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 72 + d1 * 9)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c8_i32 = arith.constant 8 : i32 + %c6_i32 = arith.constant 6 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8, %c9) {map = #map} : (tensor, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.apply #map2(%8) + %12 = arith.cmpi sge, %11, %c0 : index + %13 = arith.subi %c2_i32, %9 : i32 + %14 = arith.select %12, %13, %10 : i32 + %15 = arith.cmpi sge, %14, %c4_i32 : i32 + %16 = arith.subi %c6_i32, %14 : i32 + %17 = arith.select %15, %16, %14 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = linalg.index 2 : index + %21 = arith.index_cast %20 : index to i32 + %22 = arith.addi %21, %c-2_i32 : i32 + %23 = affine.apply #map2(%20) + %24 = arith.cmpi sge, %23, %c0 : index + %25 = arith.subi %c2_i32, %21 : i32 + %26 = arith.select %24, %25, %22 : i32 + %27 = arith.cmpi sge, %26, %c5_i32 : i32 + %28 = arith.subi %c8_i32, %26 : i32 + %29 = arith.select %27, %28, %26 : i32 + %30 = arith.addi %19, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %arg0[%31] : memref + linalg.yield %32 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8, %c9) {map = #map} : (tensor, tensor, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu/orig.mlir new file mode 100644 index 000000000000..d6d6b6cfb24b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu/orig.mlir @@ -0,0 +1,56 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-2_i32 = arith.constant -2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c8_i32 = arith.constant 8 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.if #set(%arg3) -> i32 { + %9 = arith.subi %c2_i32, %2 : i32 + affine.yield %9 : i32 + } else { + affine.yield %3 : i32 + } + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = scf.if %5 -> (i32) { + %9 = arith.subi %c6_i32, %4 : i32 + scf.yield %9 : i32 + } else { + scf.yield %4 : i32 + } + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.if #set(%arg4) -> i32 { + %17 = arith.subi %c2_i32, %9 : i32 + affine.yield %17 : i32 + } else { + affine.yield %10 : i32 + } + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = scf.if %12 -> (i32) { + %17 = arith.subi %c8_i32, %11 : i32 + scf.yield %17 : i32 + } else { + scf.yield %11 : i32 + } + %14 = arith.addi %8, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = memref.load %arg0[%15] : memref + affine.store %16, %arg1[%arg4 + %arg2 * 72 + %arg3 * 9] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu/raised.mlir new file mode 100644 index 000000000000..58b53e248901 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu/raised.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 72 + d1 * 9)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %c9 = arith.constant 9 : index + %c-2_i32 = arith.constant -2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c8_i32 = arith.constant 8 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + %0 = polygeist.submap(%arg1, %c2, %c8, %c9) {map = #map} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.addi %5, %c-2_i32 : i32 + %7 = affine.apply #map2(%4) + %8 = arith.cmpi sge, %7, %c0 : index + %9 = arith.subi %c2_i32, %5 : i32 + %10 = arith.select %8, %9, %6 : i32 + %11 = arith.cmpi sge, %10, %c4_i32 : i32 + %12 = arith.subi %c6_i32, %10 : i32 + %13 = arith.select %11, %12, %10 : i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = linalg.index 2 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.addi %17, %c-2_i32 : i32 + %19 = affine.apply #map2(%16) + %20 = arith.cmpi sge, %19, %c0 : index + %21 = arith.subi %c2_i32, %17 : i32 + %22 = arith.select %20, %21, %18 : i32 + %23 = arith.cmpi sge, %22, %c5_i32 : i32 + %24 = arith.subi %c8_i32, %22 : i32 + %25 = arith.select %23, %24, %22 : i32 + %26 = arith.addi %15, %25 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = memref.load %arg0[%27] : memref + linalg.yield %28 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu_debuf.mlir new file mode 100644 index 000000000000..594a9ac70af0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu_debuf.mlir @@ -0,0 +1,56 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 72 + d1 * 9)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c8_i32 = arith.constant 8 : i32 + %c6_i32 = arith.constant 6 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8, %c9) {map = #map} : (tensor, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.apply #map2(%8) + %12 = arith.cmpi sge, %11, %c0 : index + %13 = arith.subi %c2_i32, %9 : i32 + %14 = arith.select %12, %13, %10 : i32 + %15 = arith.cmpi sge, %14, %c4_i32 : i32 + %16 = arith.subi %c6_i32, %14 : i32 + %17 = arith.select %15, %16, %14 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = linalg.index 2 : index + %21 = arith.index_cast %20 : index to i32 + %22 = arith.addi %21, %c-2_i32 : i32 + %23 = affine.apply #map2(%20) + %24 = arith.cmpi sge, %23, %c0 : index + %25 = arith.subi %c2_i32, %21 : i32 + %26 = arith.select %24, %25, %22 : i32 + %27 = arith.cmpi sge, %26, %c5_i32 : i32 + %28 = arith.subi %c8_i32, %26 : i32 + %29 = arith.select %27, %28, %26 : i32 + %30 = arith.addi %19, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %arg0[%31] : memref + linalg.yield %32 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8, %c9) {map = #map} : (tensor, tensor, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu_linalg.mlir new file mode 100644 index 000000000000..58b53e248901 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d_cpu_linalg.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 72 + d1 * 9)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %c9 = arith.constant 9 : index + %c-2_i32 = arith.constant -2 : i32 + %c6_i32 = arith.constant 6 : i32 + %c8_i32 = arith.constant 8 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + %0 = polygeist.submap(%arg1, %c2, %c8, %c9) {map = #map} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.addi %5, %c-2_i32 : i32 + %7 = affine.apply #map2(%4) + %8 = arith.cmpi sge, %7, %c0 : index + %9 = arith.subi %c2_i32, %5 : i32 + %10 = arith.select %8, %9, %6 : i32 + %11 = arith.cmpi sge, %10, %c4_i32 : i32 + %12 = arith.subi %c6_i32, %10 : i32 + %13 = arith.select %11, %12, %10 : i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = linalg.index 2 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.addi %17, %c-2_i32 : i32 + %19 = affine.apply #map2(%16) + %20 = arith.cmpi sge, %19, %c0 : index + %21 = arith.subi %c2_i32, %17 : i32 + %22 = arith.select %20, %21, %18 : i32 + %23 = arith.cmpi sge, %22, %c5_i32 : i32 + %24 = arith.subi %c8_i32, %22 : i32 + %25 = arith.select %23, %24, %22 : i32 + %26 = arith.addi %15, %25 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = memref.load %arg0[%27] : memref + linalg.yield %28 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d_debuf.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d_debuf.mlir new file mode 100644 index 000000000000..7342bb5cc8de --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d_debuf.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0) -> (d0 - 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c6_i32 = arith.constant 6 : i32 + %c-1_i32 = arith.constant -1 : i32 + %c10 = arith.constant 10 : index + %c0 = arith.constant 0 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c3, %c10, %c10] [1, 1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.cmpi eq, %4, %c0 : index + %7 = affine.apply #map1(%4) + %8 = arith.cmpi eq, %7, %c0 : index + %9 = arith.addi %5, %c-1_i32 : i32 + %10 = arith.select %8, %c6_i32, %9 : i32 + %11 = arith.select %6, %c1_i32, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = linalg.index 2 : index + %14 = arith.index_cast %13 : index to i32 + %15 = arith.cmpi eq, %13, %c0 : index + %16 = affine.apply #map1(%13) + %17 = arith.cmpi eq, %16, %c0 : index + %18 = arith.addi %14, %c-1_i32 : i32 + %19 = arith.select %17, %c6_i32, %18 : i32 + %20 = arith.select %15, %c1_i32, %19 : i32 + %21 = arith.index_cast %20 : i32 to index + %22 = memref.load %arg0[%3, %12, %21] : memref + linalg.yield %22 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0, 0] [%c3, %c10, %c10] [1, 1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad2d_linalg.mlir b/issues/aten_c_kernels/results/aten_reflection_pad2d_linalg.mlir new file mode 100644 index 000000000000..2989bb4ee999 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad2d_linalg.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0) -> (d0 - 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c0 = arith.constant 0 : index + %c10 = arith.constant 10 : index + %c-1_i32 = arith.constant -1 : i32 + %c6_i32 = arith.constant 6 : i32 + %c1_i32 = arith.constant 1 : i32 + %subview = memref.subview %arg1[0, 0, 0] [%c3, %c10, %c10] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.cmpi eq, %1, %c0 : index + %4 = affine.apply #map1(%1) + %5 = arith.cmpi eq, %4, %c0 : index + %6 = arith.addi %2, %c-1_i32 : i32 + %7 = arith.select %5, %c6_i32, %6 : i32 + %8 = arith.select %3, %c1_i32, %7 : i32 + %9 = arith.index_cast %8 : i32 to index + %10 = linalg.index 2 : index + %11 = arith.index_cast %10 : index to i32 + %12 = arith.cmpi eq, %10, %c0 : index + %13 = affine.apply #map1(%10) + %14 = arith.cmpi eq, %13, %c0 : index + %15 = arith.addi %11, %c-1_i32 : i32 + %16 = arith.select %14, %c6_i32, %15 : i32 + %17 = arith.select %12, %c1_i32, %16 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = memref.load %arg0[%0, %9, %18] : memref + linalg.yield %19 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu.mlir new file mode 100644 index 000000000000..be35812bbb44 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu.mlir @@ -0,0 +1,82 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-2_i32 = arith.constant -2 : i32 + %c10_i32 = arith.constant 10 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 240 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.if #set(%arg3) -> i32 { + %9 = arith.subi %c2_i32, %2 : i32 + affine.yield %9 : i32 + } else { + affine.yield %3 : i32 + } + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = scf.if %5 -> (i32) { + %9 = arith.subi %c6_i32, %4 : i32 + scf.yield %9 : i32 + } else { + scf.yield %4 : i32 + } + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.if #set(%arg4) -> i32 { + %16 = arith.subi %c2_i32, %9 : i32 + affine.yield %16 : i32 + } else { + affine.yield %10 : i32 + } + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = scf.if %12 -> (i32) { + %16 = arith.subi %c8_i32, %11 : i32 + scf.yield %16 : i32 + } else { + scf.yield %11 : i32 + } + %14 = arith.addi %8, %13 : i32 + %15 = arith.muli %14, %c6_i32 : i32 + affine.for %arg5 = 0 to 10 { + %16 = arith.index_cast %arg5 : index to i32 + %17 = arith.addi %16, %c-2_i32 : i32 + %18 = affine.if #set(%arg5) -> i32 { + %26 = arith.subi %c2_i32, %16 : i32 + affine.yield %26 : i32 + } else { + affine.yield %17 : i32 + } + %19 = arith.cmpi sge, %18, %c6_i32 : i32 + %20 = scf.if %19 -> (i32) { + %26 = arith.subi %c10_i32, %18 : i32 + scf.yield %26 : i32 + } else { + scf.yield %18 : i32 + } + %21 = arith.addi %15, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = affine.load %arg0[%arg2 * 720 + %arg5 + %arg3 * 90 + %arg4 * 10] : memref + %24 = memref.load %arg1[%22] : memref + %25 = arith.addf %24, %23 : f32 + memref.store %25, %arg1[%22] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..7814124c3620 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu/debuf.mlir @@ -0,0 +1,78 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0 * 720 + d1 + d2 * 90 + d3 * 10)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c10_i32 = arith.constant 10 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = affine.apply #map1(%arg4) + %11 = arith.cmpi sge, %10, %c0 : index + %12 = arith.subi %c2_i32, %8 : i32 + %13 = arith.select %11, %12, %9 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.subi %c6_i32, %13 : i32 + %16 = arith.select %14, %15, %13 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = affine.for %arg6 = 0 to 9 iter_args(%arg7 = %arg5) -> (tensor) { + %20 = arith.index_cast %arg6 : index to i32 + %21 = arith.addi %20, %c-2_i32 : i32 + %22 = affine.apply #map1(%arg6) + %23 = arith.cmpi sge, %22, %c0 : index + %24 = arith.subi %c2_i32, %20 : i32 + %25 = arith.select %23, %24, %21 : i32 + %26 = arith.cmpi sge, %25, %c5_i32 : i32 + %27 = arith.subi %c8_i32, %25 : i32 + %28 = arith.select %26, %27, %25 : i32 + %29 = arith.addi %18, %28 : i32 + %30 = arith.muli %29, %c6_i32 : i32 + %31 = affine.for %arg8 = 0 to 10 iter_args(%arg9 = %arg7) -> (tensor) { + %32 = arith.index_cast %arg8 : index to i32 + %33 = arith.addi %32, %c-2_i32 : i32 + %34 = affine.apply #map1(%arg8) + %35 = arith.cmpi sge, %34, %c0 : index + %36 = arith.subi %c2_i32, %32 : i32 + %37 = arith.select %35, %36, %33 : i32 + %38 = arith.cmpi sge, %37, %c6_i32 : i32 + %39 = arith.subi %c10_i32, %37 : i32 + %40 = arith.select %38, %39, %37 : i32 + %41 = arith.addi %30, %40 : i32 + %42 = arith.index_cast %41 : i32 to index + %43 = affine.apply #map2(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%43] : tensor + %extracted_0 = tensor.extract %arg9[%42] : tensor + %44 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %44 into %arg9[%42] : tensor + affine.yield %inserted : tensor + } + affine.yield %31 : tensor + } + affine.yield %19 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..e33ee2164c5a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu/matched.mlir @@ -0,0 +1,75 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0 * 720 + d1 + d2 * 90 + d3 * 10)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c10_i32 = arith.constant 10 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = affine.apply #map1(%arg4) + %11 = arith.cmpi sge, %10, %c0 : index + %12 = arith.subi %c2_i32, %8 : i32 + %13 = arith.select %11, %12, %9 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.subi %c6_i32, %13 : i32 + %16 = arith.select %14, %15, %13 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = affine.for %arg6 = 0 to 9 iter_args(%arg7 = %arg5) -> (tensor) { + %20 = arith.index_cast %arg6 : index to i32 + %21 = arith.addi %20, %c-2_i32 : i32 + %22 = affine.apply #map1(%arg6) + %23 = arith.cmpi sge, %22, %c0 : index + %24 = arith.subi %c2_i32, %20 : i32 + %25 = arith.select %23, %24, %21 : i32 + %26 = arith.cmpi sge, %25, %c5_i32 : i32 + %27 = arith.subi %c8_i32, %25 : i32 + %28 = arith.select %26, %27, %25 : i32 + %29 = arith.addi %18, %28 : i32 + %30 = arith.muli %29, %c6_i32 : i32 + %31 = affine.for %arg8 = 0 to 10 iter_args(%arg9 = %arg7) -> (tensor) { + %32 = arith.index_cast %arg8 : index to i32 + %33 = arith.addi %32, %c-2_i32 : i32 + %34 = affine.apply #map1(%arg8) + %35 = arith.cmpi sge, %34, %c0 : index + %36 = arith.subi %c2_i32, %32 : i32 + %37 = arith.select %35, %36, %33 : i32 + %38 = arith.cmpi sge, %37, %c6_i32 : i32 + %39 = arith.subi %c10_i32, %37 : i32 + %40 = arith.select %38, %39, %37 : i32 + %41 = arith.addi %30, %40 : i32 + %42 = arith.index_cast %41 : i32 to index + %43 = affine.apply #map2(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%43] : tensor + %extracted_0 = tensor.extract %arg9[%42] : tensor + %44 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %44 into %arg9[%42] : tensor + affine.yield %inserted : tensor + } + affine.yield %31 : tensor + } + affine.yield %19 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..be35812bbb44 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu/orig.mlir @@ -0,0 +1,82 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-2_i32 = arith.constant -2 : i32 + %c10_i32 = arith.constant 10 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 240 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.if #set(%arg3) -> i32 { + %9 = arith.subi %c2_i32, %2 : i32 + affine.yield %9 : i32 + } else { + affine.yield %3 : i32 + } + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = scf.if %5 -> (i32) { + %9 = arith.subi %c6_i32, %4 : i32 + scf.yield %9 : i32 + } else { + scf.yield %4 : i32 + } + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.if #set(%arg4) -> i32 { + %16 = arith.subi %c2_i32, %9 : i32 + affine.yield %16 : i32 + } else { + affine.yield %10 : i32 + } + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = scf.if %12 -> (i32) { + %16 = arith.subi %c8_i32, %11 : i32 + scf.yield %16 : i32 + } else { + scf.yield %11 : i32 + } + %14 = arith.addi %8, %13 : i32 + %15 = arith.muli %14, %c6_i32 : i32 + affine.for %arg5 = 0 to 10 { + %16 = arith.index_cast %arg5 : index to i32 + %17 = arith.addi %16, %c-2_i32 : i32 + %18 = affine.if #set(%arg5) -> i32 { + %26 = arith.subi %c2_i32, %16 : i32 + affine.yield %26 : i32 + } else { + affine.yield %17 : i32 + } + %19 = arith.cmpi sge, %18, %c6_i32 : i32 + %20 = scf.if %19 -> (i32) { + %26 = arith.subi %c10_i32, %18 : i32 + scf.yield %26 : i32 + } else { + scf.yield %18 : i32 + } + %21 = arith.addi %15, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = affine.load %arg0[%arg2 * 720 + %arg5 + %arg3 * 90 + %arg4 * 10] : memref + %24 = memref.load %arg1[%22] : memref + %25 = arith.addf %24, %23 : f32 + memref.store %25, %arg1[%22] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..1d78fa460d26 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu/raised.mlir @@ -0,0 +1,68 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c-2_i32 = arith.constant -2 : i32 + %c10_i32 = arith.constant 10 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.apply #map1(%arg3) + %5 = arith.cmpi sge, %4, %c0 : index + %6 = arith.subi %c2_i32, %2 : i32 + %7 = arith.select %5, %6, %3 : i32 + %8 = arith.cmpi sge, %7, %c4_i32 : i32 + %9 = arith.subi %c6_i32, %7 : i32 + %10 = arith.select %8, %9, %7 : i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %13 = arith.index_cast %arg4 : index to i32 + %14 = arith.addi %13, %c-2_i32 : i32 + %15 = affine.apply #map1(%arg4) + %16 = arith.cmpi sge, %15, %c0 : index + %17 = arith.subi %c2_i32, %13 : i32 + %18 = arith.select %16, %17, %14 : i32 + %19 = arith.cmpi sge, %18, %c5_i32 : i32 + %20 = arith.subi %c8_i32, %18 : i32 + %21 = arith.select %19, %20, %18 : i32 + %22 = arith.addi %12, %21 : i32 + %23 = arith.muli %22, %c6_i32 : i32 + affine.for %arg5 = 0 to 10 { + %24 = arith.index_cast %arg5 : index to i32 + %25 = arith.addi %24, %c-2_i32 : i32 + %26 = affine.apply #map1(%arg5) + %27 = arith.cmpi sge, %26, %c0 : index + %28 = arith.subi %c2_i32, %24 : i32 + %29 = arith.select %27, %28, %25 : i32 + %30 = arith.cmpi sge, %29, %c6_i32 : i32 + %31 = arith.subi %c10_i32, %29 : i32 + %32 = arith.select %30, %31, %29 : i32 + %33 = arith.addi %23, %32 : i32 + %34 = arith.index_cast %33 : i32 to index + %35 = affine.load %arg0[%arg2 * 720 + %arg5 + %arg3 * 90 + %arg4 * 10] : memref + %36 = memref.load %arg1[%34] : memref + %37 = arith.addf %36, %35 : f32 + memref.store %37, %arg1[%34] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..7814124c3620 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu_debuf.mlir @@ -0,0 +1,78 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0 * 720 + d1 + d2 * 90 + d3 * 10)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c8_i32 = arith.constant 8 : i32 + %c10_i32 = arith.constant 10 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = affine.apply #map1(%arg4) + %11 = arith.cmpi sge, %10, %c0 : index + %12 = arith.subi %c2_i32, %8 : i32 + %13 = arith.select %11, %12, %9 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.subi %c6_i32, %13 : i32 + %16 = arith.select %14, %15, %13 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = affine.for %arg6 = 0 to 9 iter_args(%arg7 = %arg5) -> (tensor) { + %20 = arith.index_cast %arg6 : index to i32 + %21 = arith.addi %20, %c-2_i32 : i32 + %22 = affine.apply #map1(%arg6) + %23 = arith.cmpi sge, %22, %c0 : index + %24 = arith.subi %c2_i32, %20 : i32 + %25 = arith.select %23, %24, %21 : i32 + %26 = arith.cmpi sge, %25, %c5_i32 : i32 + %27 = arith.subi %c8_i32, %25 : i32 + %28 = arith.select %26, %27, %25 : i32 + %29 = arith.addi %18, %28 : i32 + %30 = arith.muli %29, %c6_i32 : i32 + %31 = affine.for %arg8 = 0 to 10 iter_args(%arg9 = %arg7) -> (tensor) { + %32 = arith.index_cast %arg8 : index to i32 + %33 = arith.addi %32, %c-2_i32 : i32 + %34 = affine.apply #map1(%arg8) + %35 = arith.cmpi sge, %34, %c0 : index + %36 = arith.subi %c2_i32, %32 : i32 + %37 = arith.select %35, %36, %33 : i32 + %38 = arith.cmpi sge, %37, %c6_i32 : i32 + %39 = arith.subi %c10_i32, %37 : i32 + %40 = arith.select %38, %39, %37 : i32 + %41 = arith.addi %30, %40 : i32 + %42 = arith.index_cast %41 : i32 to index + %43 = affine.apply #map2(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%43] : tensor + %extracted_0 = tensor.extract %arg9[%42] : tensor + %44 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %44 into %arg9[%42] : tensor + affine.yield %inserted : tensor + } + affine.yield %31 : tensor + } + affine.yield %19 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..1d78fa460d26 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad3d_backward_cpu_linalg.mlir @@ -0,0 +1,68 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c-2_i32 = arith.constant -2 : i32 + %c10_i32 = arith.constant 10 : i32 + %c8_i32 = arith.constant 8 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.apply #map1(%arg3) + %5 = arith.cmpi sge, %4, %c0 : index + %6 = arith.subi %c2_i32, %2 : i32 + %7 = arith.select %5, %6, %3 : i32 + %8 = arith.cmpi sge, %7, %c4_i32 : i32 + %9 = arith.subi %c6_i32, %7 : i32 + %10 = arith.select %8, %9, %7 : i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %13 = arith.index_cast %arg4 : index to i32 + %14 = arith.addi %13, %c-2_i32 : i32 + %15 = affine.apply #map1(%arg4) + %16 = arith.cmpi sge, %15, %c0 : index + %17 = arith.subi %c2_i32, %13 : i32 + %18 = arith.select %16, %17, %14 : i32 + %19 = arith.cmpi sge, %18, %c5_i32 : i32 + %20 = arith.subi %c8_i32, %18 : i32 + %21 = arith.select %19, %20, %18 : i32 + %22 = arith.addi %12, %21 : i32 + %23 = arith.muli %22, %c6_i32 : i32 + affine.for %arg5 = 0 to 10 { + %24 = arith.index_cast %arg5 : index to i32 + %25 = arith.addi %24, %c-2_i32 : i32 + %26 = affine.apply #map1(%arg5) + %27 = arith.cmpi sge, %26, %c0 : index + %28 = arith.subi %c2_i32, %24 : i32 + %29 = arith.select %27, %28, %25 : i32 + %30 = arith.cmpi sge, %29, %c6_i32 : i32 + %31 = arith.subi %c10_i32, %29 : i32 + %32 = arith.select %30, %31, %29 : i32 + %33 = arith.addi %23, %32 : i32 + %34 = arith.index_cast %33 : i32 to index + %35 = affine.load %arg0[%arg2 * 720 + %arg5 + %arg3 * 90 + %arg4 * 10] : memref + %36 = memref.load %arg1[%34] : memref + %37 = arith.addf %36, %35 : f32 + memref.store %37, %arg1[%34] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu.mlir b/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu.mlir new file mode 100644 index 000000000000..f986692e008c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu.mlir @@ -0,0 +1,76 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-2_i32 = arith.constant -2 : i32 + %c10_i32 = arith.constant 10 : i32 + %c8_i32 = arith.constant 8 : i32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.if #set(%arg3) -> i32 { + %9 = arith.subi %c2_i32, %2 : i32 + affine.yield %9 : i32 + } else { + affine.yield %3 : i32 + } + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = scf.if %5 -> (i32) { + %9 = arith.subi %c6_i32, %4 : i32 + scf.yield %9 : i32 + } else { + scf.yield %4 : i32 + } + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.if #set(%arg4) -> i32 { + %16 = arith.subi %c2_i32, %9 : i32 + affine.yield %16 : i32 + } else { + affine.yield %10 : i32 + } + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = scf.if %12 -> (i32) { + %16 = arith.subi %c8_i32, %11 : i32 + scf.yield %16 : i32 + } else { + scf.yield %11 : i32 + } + %14 = arith.addi %8, %13 : i32 + %15 = arith.muli %14, %c6_i32 : i32 + affine.for %arg5 = 0 to 10 { + %16 = arith.index_cast %arg5 : index to i32 + %17 = arith.addi %16, %c-2_i32 : i32 + %18 = affine.if #set(%arg5) -> i32 { + %24 = arith.subi %c2_i32, %16 : i32 + affine.yield %24 : i32 + } else { + affine.yield %17 : i32 + } + %19 = arith.cmpi sge, %18, %c6_i32 : i32 + %20 = scf.if %19 -> (i32) { + %24 = arith.subi %c10_i32, %18 : i32 + scf.yield %24 : i32 + } else { + scf.yield %18 : i32 + } + %21 = arith.addi %15, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = memref.load %arg0[%22] : memref + affine.store %23, %arg1[%arg2 * 720 + %arg5 + %arg3 * 90 + %arg4 * 10] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu/debuf.mlir new file mode 100644 index 000000000000..6f0c96ed0f84 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu/debuf.mlir @@ -0,0 +1,70 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 720 + d1 * 90 + d2 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %c8_i32 = arith.constant 8 : i32 + %c10_i32 = arith.constant 10 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c10 = arith.constant 10 : index + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8, %c9, %c10) {map = #map} : (tensor, index, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.apply #map2(%8) + %12 = arith.cmpi sge, %11, %c0 : index + %13 = arith.subi %c2_i32, %9 : i32 + %14 = arith.select %12, %13, %10 : i32 + %15 = arith.cmpi sge, %14, %c4_i32 : i32 + %16 = arith.subi %c6_i32, %14 : i32 + %17 = arith.select %15, %16, %14 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = linalg.index 2 : index + %21 = arith.index_cast %20 : index to i32 + %22 = arith.addi %21, %c-2_i32 : i32 + %23 = affine.apply #map2(%20) + %24 = arith.cmpi sge, %23, %c0 : index + %25 = arith.subi %c2_i32, %21 : i32 + %26 = arith.select %24, %25, %22 : i32 + %27 = arith.cmpi sge, %26, %c5_i32 : i32 + %28 = arith.subi %c8_i32, %26 : i32 + %29 = arith.select %27, %28, %26 : i32 + %30 = arith.addi %19, %29 : i32 + %31 = arith.muli %30, %c6_i32 : i32 + %32 = linalg.index 3 : index + %33 = arith.index_cast %32 : index to i32 + %34 = arith.addi %33, %c-2_i32 : i32 + %35 = affine.apply #map2(%32) + %36 = arith.cmpi sge, %35, %c0 : index + %37 = arith.subi %c2_i32, %33 : i32 + %38 = arith.select %36, %37, %34 : i32 + %39 = arith.cmpi sge, %38, %c6_i32 : i32 + %40 = arith.subi %c10_i32, %38 : i32 + %41 = arith.select %39, %40, %38 : i32 + %42 = arith.addi %31, %41 : i32 + %43 = arith.index_cast %42 : i32 to index + %44 = memref.load %arg0[%43] : memref + linalg.yield %44 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8, %c9, %c10) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu/matched.mlir new file mode 100644 index 000000000000..6f0c96ed0f84 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu/matched.mlir @@ -0,0 +1,70 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 720 + d1 * 90 + d2 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %c8_i32 = arith.constant 8 : i32 + %c10_i32 = arith.constant 10 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c10 = arith.constant 10 : index + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8, %c9, %c10) {map = #map} : (tensor, index, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.apply #map2(%8) + %12 = arith.cmpi sge, %11, %c0 : index + %13 = arith.subi %c2_i32, %9 : i32 + %14 = arith.select %12, %13, %10 : i32 + %15 = arith.cmpi sge, %14, %c4_i32 : i32 + %16 = arith.subi %c6_i32, %14 : i32 + %17 = arith.select %15, %16, %14 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = linalg.index 2 : index + %21 = arith.index_cast %20 : index to i32 + %22 = arith.addi %21, %c-2_i32 : i32 + %23 = affine.apply #map2(%20) + %24 = arith.cmpi sge, %23, %c0 : index + %25 = arith.subi %c2_i32, %21 : i32 + %26 = arith.select %24, %25, %22 : i32 + %27 = arith.cmpi sge, %26, %c5_i32 : i32 + %28 = arith.subi %c8_i32, %26 : i32 + %29 = arith.select %27, %28, %26 : i32 + %30 = arith.addi %19, %29 : i32 + %31 = arith.muli %30, %c6_i32 : i32 + %32 = linalg.index 3 : index + %33 = arith.index_cast %32 : index to i32 + %34 = arith.addi %33, %c-2_i32 : i32 + %35 = affine.apply #map2(%32) + %36 = arith.cmpi sge, %35, %c0 : index + %37 = arith.subi %c2_i32, %33 : i32 + %38 = arith.select %36, %37, %34 : i32 + %39 = arith.cmpi sge, %38, %c6_i32 : i32 + %40 = arith.subi %c10_i32, %38 : i32 + %41 = arith.select %39, %40, %38 : i32 + %42 = arith.addi %31, %41 : i32 + %43 = arith.index_cast %42 : i32 to index + %44 = memref.load %arg0[%43] : memref + linalg.yield %44 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8, %c9, %c10) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu/orig.mlir new file mode 100644 index 000000000000..f986692e008c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu/orig.mlir @@ -0,0 +1,76 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-2_i32 = arith.constant -2 : i32 + %c10_i32 = arith.constant 10 : i32 + %c8_i32 = arith.constant 8 : i32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = affine.if #set(%arg3) -> i32 { + %9 = arith.subi %c2_i32, %2 : i32 + affine.yield %9 : i32 + } else { + affine.yield %3 : i32 + } + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = scf.if %5 -> (i32) { + %9 = arith.subi %c6_i32, %4 : i32 + scf.yield %9 : i32 + } else { + scf.yield %4 : i32 + } + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.if #set(%arg4) -> i32 { + %16 = arith.subi %c2_i32, %9 : i32 + affine.yield %16 : i32 + } else { + affine.yield %10 : i32 + } + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = scf.if %12 -> (i32) { + %16 = arith.subi %c8_i32, %11 : i32 + scf.yield %16 : i32 + } else { + scf.yield %11 : i32 + } + %14 = arith.addi %8, %13 : i32 + %15 = arith.muli %14, %c6_i32 : i32 + affine.for %arg5 = 0 to 10 { + %16 = arith.index_cast %arg5 : index to i32 + %17 = arith.addi %16, %c-2_i32 : i32 + %18 = affine.if #set(%arg5) -> i32 { + %24 = arith.subi %c2_i32, %16 : i32 + affine.yield %24 : i32 + } else { + affine.yield %17 : i32 + } + %19 = arith.cmpi sge, %18, %c6_i32 : i32 + %20 = scf.if %19 -> (i32) { + %24 = arith.subi %c10_i32, %18 : i32 + scf.yield %24 : i32 + } else { + scf.yield %18 : i32 + } + %21 = arith.addi %15, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = memref.load %arg0[%22] : memref + affine.store %23, %arg1[%arg2 * 720 + %arg5 + %arg3 * 90 + %arg4 * 10] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu/raised.mlir new file mode 100644 index 000000000000..18aed28b7074 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu/raised.mlir @@ -0,0 +1,66 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 720 + d1 * 90 + d2 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %c9 = arith.constant 9 : index + %c10 = arith.constant 10 : index + %c-2_i32 = arith.constant -2 : i32 + %c10_i32 = arith.constant 10 : i32 + %c8_i32 = arith.constant 8 : i32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + %0 = polygeist.submap(%arg1, %c2, %c8, %c9, %c10) {map = #map} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.addi %5, %c-2_i32 : i32 + %7 = affine.apply #map2(%4) + %8 = arith.cmpi sge, %7, %c0 : index + %9 = arith.subi %c2_i32, %5 : i32 + %10 = arith.select %8, %9, %6 : i32 + %11 = arith.cmpi sge, %10, %c4_i32 : i32 + %12 = arith.subi %c6_i32, %10 : i32 + %13 = arith.select %11, %12, %10 : i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = linalg.index 2 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.addi %17, %c-2_i32 : i32 + %19 = affine.apply #map2(%16) + %20 = arith.cmpi sge, %19, %c0 : index + %21 = arith.subi %c2_i32, %17 : i32 + %22 = arith.select %20, %21, %18 : i32 + %23 = arith.cmpi sge, %22, %c5_i32 : i32 + %24 = arith.subi %c8_i32, %22 : i32 + %25 = arith.select %23, %24, %22 : i32 + %26 = arith.addi %15, %25 : i32 + %27 = arith.muli %26, %c6_i32 : i32 + %28 = linalg.index 3 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.addi %29, %c-2_i32 : i32 + %31 = affine.apply #map2(%28) + %32 = arith.cmpi sge, %31, %c0 : index + %33 = arith.subi %c2_i32, %29 : i32 + %34 = arith.select %32, %33, %30 : i32 + %35 = arith.cmpi sge, %34, %c6_i32 : i32 + %36 = arith.subi %c10_i32, %34 : i32 + %37 = arith.select %35, %36, %34 : i32 + %38 = arith.addi %27, %37 : i32 + %39 = arith.index_cast %38 : i32 to index + %40 = memref.load %arg0[%39] : memref + linalg.yield %40 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu_debuf.mlir new file mode 100644 index 000000000000..6f0c96ed0f84 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu_debuf.mlir @@ -0,0 +1,70 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 720 + d1 * 90 + d2 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %c8_i32 = arith.constant 8 : i32 + %c10_i32 = arith.constant 10 : i32 + %c-2_i32 = arith.constant -2 : i32 + %c10 = arith.constant 10 : index + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8, %c9, %c10) {map = #map} : (tensor, index, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = affine.apply #map2(%8) + %12 = arith.cmpi sge, %11, %c0 : index + %13 = arith.subi %c2_i32, %9 : i32 + %14 = arith.select %12, %13, %10 : i32 + %15 = arith.cmpi sge, %14, %c4_i32 : i32 + %16 = arith.subi %c6_i32, %14 : i32 + %17 = arith.select %15, %16, %14 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = linalg.index 2 : index + %21 = arith.index_cast %20 : index to i32 + %22 = arith.addi %21, %c-2_i32 : i32 + %23 = affine.apply #map2(%20) + %24 = arith.cmpi sge, %23, %c0 : index + %25 = arith.subi %c2_i32, %21 : i32 + %26 = arith.select %24, %25, %22 : i32 + %27 = arith.cmpi sge, %26, %c5_i32 : i32 + %28 = arith.subi %c8_i32, %26 : i32 + %29 = arith.select %27, %28, %26 : i32 + %30 = arith.addi %19, %29 : i32 + %31 = arith.muli %30, %c6_i32 : i32 + %32 = linalg.index 3 : index + %33 = arith.index_cast %32 : index to i32 + %34 = arith.addi %33, %c-2_i32 : i32 + %35 = affine.apply #map2(%32) + %36 = arith.cmpi sge, %35, %c0 : index + %37 = arith.subi %c2_i32, %33 : i32 + %38 = arith.select %36, %37, %34 : i32 + %39 = arith.cmpi sge, %38, %c6_i32 : i32 + %40 = arith.subi %c10_i32, %38 : i32 + %41 = arith.select %39, %40, %38 : i32 + %42 = arith.addi %31, %41 : i32 + %43 = arith.index_cast %42 : i32 to index + %44 = memref.load %arg0[%43] : memref + linalg.yield %44 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8, %c9, %c10) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu_linalg.mlir new file mode 100644 index 000000000000..18aed28b7074 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_reflection_pad3d_cpu_linalg.mlir @@ -0,0 +1,66 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 720 + d1 * 90 + d2 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_reflection_pad3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %c9 = arith.constant 9 : index + %c10 = arith.constant 10 : index + %c-2_i32 = arith.constant -2 : i32 + %c10_i32 = arith.constant 10 : i32 + %c8_i32 = arith.constant 8 : i32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + %0 = polygeist.submap(%arg1, %c2, %c8, %c9, %c10) {map = #map} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.addi %5, %c-2_i32 : i32 + %7 = affine.apply #map2(%4) + %8 = arith.cmpi sge, %7, %c0 : index + %9 = arith.subi %c2_i32, %5 : i32 + %10 = arith.select %8, %9, %6 : i32 + %11 = arith.cmpi sge, %10, %c4_i32 : i32 + %12 = arith.subi %c6_i32, %10 : i32 + %13 = arith.select %11, %12, %10 : i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = linalg.index 2 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.addi %17, %c-2_i32 : i32 + %19 = affine.apply #map2(%16) + %20 = arith.cmpi sge, %19, %c0 : index + %21 = arith.subi %c2_i32, %17 : i32 + %22 = arith.select %20, %21, %18 : i32 + %23 = arith.cmpi sge, %22, %c5_i32 : i32 + %24 = arith.subi %c8_i32, %22 : i32 + %25 = arith.select %23, %24, %22 : i32 + %26 = arith.addi %15, %25 : i32 + %27 = arith.muli %26, %c6_i32 : i32 + %28 = linalg.index 3 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.addi %29, %c-2_i32 : i32 + %31 = affine.apply #map2(%28) + %32 = arith.cmpi sge, %31, %c0 : index + %33 = arith.subi %c2_i32, %29 : i32 + %34 = arith.select %32, %33, %30 : i32 + %35 = arith.cmpi sge, %34, %c6_i32 : i32 + %36 = arith.subi %c10_i32, %34 : i32 + %37 = arith.select %35, %36, %34 : i32 + %38 = arith.addi %27, %37 : i32 + %39 = arith.index_cast %38 : i32 to index + %40 = memref.load %arg0[%39] : memref + linalg.yield %40 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_relu.mlir b/issues/aten_c_kernels/results/aten_relu.mlir new file mode 100644 index 000000000000..eaa9e16a21f6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_relu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_relu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.cmpf ogt, %0, %cst : f32 + %2 = arith.select %1, %0, %cst : f32 + affine.store %2, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_relu/debuf.mlir b/issues/aten_c_kernels/results/aten_relu/debuf.mlir new file mode 100644 index 000000000000..8517f35235c0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_relu/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_relu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %cst : f32 + %5 = arith.select %4, %in, %cst : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_relu/matched.mlir b/issues/aten_c_kernels/results/aten_relu/matched.mlir new file mode 100644 index 000000000000..8517f35235c0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_relu/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_relu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %cst : f32 + %5 = arith.select %4, %in, %cst : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_relu/orig.mlir b/issues/aten_c_kernels/results/aten_relu/orig.mlir new file mode 100644 index 000000000000..eaa9e16a21f6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_relu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_relu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.cmpf ogt, %0, %cst : f32 + %2 = arith.select %1, %0, %cst : f32 + affine.store %2, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_relu/raised.mlir b/issues/aten_c_kernels/results/aten_relu/raised.mlir new file mode 100644 index 000000000000..a01c361fd07b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_relu/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_relu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %cst : f32 + %1 = arith.select %0, %in, %cst : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_relu_debuf.mlir b/issues/aten_c_kernels/results/aten_relu_debuf.mlir new file mode 100644 index 000000000000..8517f35235c0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_relu_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_relu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %cst : f32 + %5 = arith.select %4, %in, %cst : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_relu_linalg.mlir b/issues/aten_c_kernels/results/aten_relu_linalg.mlir new file mode 100644 index 000000000000..a01c361fd07b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_relu_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_relu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %cst : f32 + %1 = arith.select %0, %in, %cst : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_remainder.mlir b/issues/aten_c_kernels/results/aten_remainder.mlir new file mode 100644 index 000000000000..a856175eadb8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_remainder.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_remainder(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @remainderf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @remainderf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_remainder/debuf.mlir b/issues/aten_c_kernels/results/aten_remainder/debuf.mlir new file mode 100644 index 000000000000..8a26ce4324ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_remainder/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_remainder(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @remainderf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @remainderf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_remainder/matched.mlir b/issues/aten_c_kernels/results/aten_remainder/matched.mlir new file mode 100644 index 000000000000..8a26ce4324ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_remainder/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_remainder(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @remainderf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @remainderf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_remainder/orig.mlir b/issues/aten_c_kernels/results/aten_remainder/orig.mlir new file mode 100644 index 000000000000..a856175eadb8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_remainder/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_remainder(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @remainderf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @remainderf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_remainder/raised.mlir b/issues/aten_c_kernels/results/aten_remainder/raised.mlir new file mode 100644 index 000000000000..a407d05b3c3a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_remainder/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_remainder(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @remainderf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @remainderf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_remainder_debuf.mlir b/issues/aten_c_kernels/results/aten_remainder_debuf.mlir new file mode 100644 index 000000000000..8a26ce4324ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_remainder_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_remainder(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @remainderf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @remainderf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_remainder_linalg.mlir b/issues/aten_c_kernels/results/aten_remainder_linalg.mlir new file mode 100644 index 000000000000..a407d05b3c3a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_remainder_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_remainder(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @remainderf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @remainderf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_renorm_scale_factor.mlir b/issues/aten_c_kernels/results/aten_renorm_scale_factor.mlir new file mode 100644 index 000000000000..75628b543c5f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_renorm_scale_factor.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_renorm_scale_factor(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e-07 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf ogt, %0, %arg1 : f32 + %2 = scf.if %1 -> (f32) { + %3 = arith.addf %0, %cst_0 : f32 + %4 = arith.divf %arg1, %3 : f32 + scf.yield %4 : f32 + } else { + scf.yield %cst : f32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_renorm_scale_factor/debuf.mlir b/issues/aten_c_kernels/results/aten_renorm_scale_factor/debuf.mlir new file mode 100644 index 000000000000..11047d89f4ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_renorm_scale_factor/debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_renorm_scale_factor(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-07 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %arg1 : f32 + %5 = arith.addf %in, %cst : f32 + %6 = arith.divf %arg1, %5 : f32 + %7 = arith.select %4, %6, %cst_0 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_renorm_scale_factor/matched.mlir b/issues/aten_c_kernels/results/aten_renorm_scale_factor/matched.mlir new file mode 100644 index 000000000000..11047d89f4ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_renorm_scale_factor/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_renorm_scale_factor(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-07 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %arg1 : f32 + %5 = arith.addf %in, %cst : f32 + %6 = arith.divf %arg1, %5 : f32 + %7 = arith.select %4, %6, %cst_0 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_renorm_scale_factor/orig.mlir b/issues/aten_c_kernels/results/aten_renorm_scale_factor/orig.mlir new file mode 100644 index 000000000000..75628b543c5f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_renorm_scale_factor/orig.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_renorm_scale_factor(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e-07 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpf ogt, %0, %arg1 : f32 + %2 = scf.if %1 -> (f32) { + %3 = arith.addf %0, %cst_0 : f32 + %4 = arith.divf %arg1, %3 : f32 + scf.yield %4 : f32 + } else { + scf.yield %cst : f32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_renorm_scale_factor/raised.mlir b/issues/aten_c_kernels/results/aten_renorm_scale_factor/raised.mlir new file mode 100644 index 000000000000..0ebbaadf1ddd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_renorm_scale_factor/raised.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_renorm_scale_factor(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e-07 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %arg1 : f32 + %1 = arith.addf %in, %cst_0 : f32 + %2 = arith.divf %arg1, %1 : f32 + %3 = arith.select %0, %2, %cst : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_renorm_scale_factor_debuf.mlir b/issues/aten_c_kernels/results/aten_renorm_scale_factor_debuf.mlir new file mode 100644 index 000000000000..11047d89f4ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_renorm_scale_factor_debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_renorm_scale_factor(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-07 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf ogt, %in, %arg1 : f32 + %5 = arith.addf %in, %cst : f32 + %6 = arith.divf %arg1, %5 : f32 + %7 = arith.select %4, %6, %cst_0 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_renorm_scale_factor_linalg.mlir b/issues/aten_c_kernels/results/aten_renorm_scale_factor_linalg.mlir new file mode 100644 index 000000000000..0ebbaadf1ddd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_renorm_scale_factor_linalg.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_renorm_scale_factor(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e-07 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf ogt, %in, %arg1 : f32 + %1 = arith.addf %in, %cst_0 : f32 + %2 = arith.divf %arg1, %1 : f32 + %3 = arith.select %0, %2, %cst : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_repeat_compute_cpu.mlir b/issues/aten_c_kernels/results/aten_repeat_compute_cpu.mlir new file mode 100644 index 000000000000..ecae4bec39d9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_repeat_compute_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_repeat_compute_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg3] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_repeat_compute_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_repeat_compute_cpu/debuf.mlir new file mode 100644 index 000000000000..56726a5059bf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_repeat_compute_cpu/debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_repeat_compute_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c4, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_repeat_compute_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_repeat_compute_cpu/matched.mlir new file mode 100644 index 000000000000..56726a5059bf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_repeat_compute_cpu/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_repeat_compute_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c4, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_repeat_compute_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_repeat_compute_cpu/orig.mlir new file mode 100644 index 000000000000..ecae4bec39d9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_repeat_compute_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_repeat_compute_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg3] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_repeat_compute_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_repeat_compute_cpu/raised.mlir new file mode 100644 index 000000000000..d89cfa585ddf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_repeat_compute_cpu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_repeat_compute_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0] [%c64] [1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c4, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_repeat_compute_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_repeat_compute_cpu_debuf.mlir new file mode 100644 index 000000000000..56726a5059bf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_repeat_compute_cpu_debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_repeat_compute_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c4, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_repeat_compute_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_repeat_compute_cpu_linalg.mlir new file mode 100644 index 000000000000..d89cfa585ddf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_repeat_compute_cpu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_repeat_compute_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0] [%c64] [1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c4, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu.mlir b/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu.mlir new file mode 100644 index 000000000000..72c18b4842a5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_repeat_tensor_shape_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg3] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu/debuf.mlir new file mode 100644 index 000000000000..a5ae2b1ae4a2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu/debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_repeat_tensor_shape_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c4, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu/matched.mlir new file mode 100644 index 000000000000..a5ae2b1ae4a2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_repeat_tensor_shape_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c4, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu/orig.mlir new file mode 100644 index 000000000000..72c18b4842a5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_repeat_tensor_shape_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg3] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu/raised.mlir new file mode 100644 index 000000000000..cb9cb496f2b8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_repeat_tensor_shape_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0] [%c64] [1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c4, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu_debuf.mlir new file mode 100644 index 000000000000..a5ae2b1ae4a2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu_debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_repeat_tensor_shape_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c4, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu_linalg.mlir new file mode 100644 index 000000000000..cb9cb496f2b8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_repeat_tensor_shape_cpu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_repeat_tensor_shape_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0] [%c64] [1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c4, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu.mlir new file mode 100644 index 000000000000..607c2f1239db --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu.mlir @@ -0,0 +1,38 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 8 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.if #set(%arg3) -> i1 { + affine.yield %false : i1 + } else { + %13 = arith.cmpi sge, %3, %c4_i32 : i32 + affine.yield %13 : i1 + } + %7 = arith.select %6, %c3_i32, %5 : i32 + %8 = arith.addi %1, %7 : i32 + %9 = arith.index_cast %8 : i32 to index + %10 = affine.load %arg0[%arg3 + %arg2 * 8] : memref + %11 = memref.load %arg1[%9] : memref + %12 = arith.addf %11, %10 : f32 + memref.store %12, %arg1[%9] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..31fcc6b417f9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu/debuf.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1) -> (d0 + d1 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = arith.cmpi slt, %9, %c0_i32 : i32 + %11 = arith.select %10, %c0_i32, %9 : i32 + %12 = affine.apply #map1(%arg4) + %13 = arith.cmpi sge, %12, %c0 : index + %14 = arith.cmpi sge, %9, %c4_i32 : i32 + %15 = arith.select %13, %false, %14 : i1 + %16 = arith.select %15, %c3_i32, %11 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = affine.apply #map2(%arg4, %arg2) + %extracted = tensor.extract %1[%19] : tensor + %extracted_0 = tensor.extract %arg5[%18] : tensor + %20 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %20 into %arg5[%18] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..a3e97645749c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu/matched.mlir @@ -0,0 +1,45 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1) -> (d0 + d1 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = arith.cmpi slt, %9, %c0_i32 : i32 + %11 = arith.select %10, %c0_i32, %9 : i32 + %12 = affine.apply #map1(%arg4) + %13 = arith.cmpi sge, %12, %c0 : index + %14 = arith.cmpi sge, %9, %c4_i32 : i32 + %15 = arith.select %13, %false, %14 : i1 + %16 = arith.select %15, %c3_i32, %11 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = affine.apply #map2(%arg4, %arg2) + %extracted = tensor.extract %1[%19] : tensor + %extracted_0 = tensor.extract %arg5[%18] : tensor + %20 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %20 into %arg5[%18] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..607c2f1239db --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu/orig.mlir @@ -0,0 +1,38 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 8 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.if #set(%arg3) -> i1 { + affine.yield %false : i1 + } else { + %13 = arith.cmpi sge, %3, %c4_i32 : i32 + affine.yield %13 : i1 + } + %7 = arith.select %6, %c3_i32, %5 : i32 + %8 = arith.addi %1, %7 : i32 + %9 = arith.index_cast %8 : i32 to index + %10 = affine.load %arg0[%arg3 + %arg2 * 8] : memref + %11 = memref.load %arg1[%9] : memref + %12 = arith.addf %11, %10 : f32 + memref.store %12, %arg1[%9] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..e288d7696b7a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu/raised.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.apply #map1(%arg3) + %7 = arith.cmpi sge, %6, %c0 : index + %8 = arith.cmpi sge, %3, %c4_i32 : i32 + %9 = arith.select %7, %false, %8 : i1 + %10 = arith.select %9, %c3_i32, %5 : i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = affine.load %arg0[%arg3 + %arg2 * 8] : memref + %14 = memref.load %arg1[%12] : memref + %15 = arith.addf %14, %13 : f32 + memref.store %15, %arg1[%12] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..31fcc6b417f9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu_debuf.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1) -> (d0 + d1 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = arith.cmpi slt, %9, %c0_i32 : i32 + %11 = arith.select %10, %c0_i32, %9 : i32 + %12 = affine.apply #map1(%arg4) + %13 = arith.cmpi sge, %12, %c0 : index + %14 = arith.cmpi sge, %9, %c4_i32 : i32 + %15 = arith.select %13, %false, %14 : i1 + %16 = arith.select %15, %c3_i32, %11 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = affine.apply #map2(%arg4, %arg2) + %extracted = tensor.extract %1[%19] : tensor + %extracted_0 = tensor.extract %arg5[%18] : tensor + %20 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %20 into %arg5[%18] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..e288d7696b7a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad1d_backward_cpu_linalg.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.apply #map1(%arg3) + %7 = arith.cmpi sge, %6, %c0 : index + %8 = arith.cmpi sge, %3, %c4_i32 : i32 + %9 = arith.select %7, %false, %8 : i1 + %10 = arith.select %9, %c3_i32, %5 : i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = affine.load %arg0[%arg3 + %arg2 * 8] : memref + %14 = memref.load %arg1[%12] : memref + %15 = arith.addf %14, %13 : f32 + memref.store %15, %arg1[%12] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad1d_cpu.mlir b/issues/aten_c_kernels/results/aten_replication_pad1d_cpu.mlir new file mode 100644 index 000000000000..58ff0089f38c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad1d_cpu.mlir @@ -0,0 +1,32 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.if #set(%arg3) -> i1 { + affine.yield %false : i1 + } else { + %11 = arith.cmpi sge, %3, %c4_i32 : i32 + affine.yield %11 : i1 + } + %7 = arith.select %6, %c3_i32, %5 : i32 + %8 = arith.addi %1, %7 : i32 + %9 = arith.index_cast %8 : i32 to index + %10 = memref.load %arg0[%9] : memref + affine.store %10, %arg1[%arg3 + %arg2 * 8] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_replication_pad1d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_replication_pad1d_cpu/debuf.mlir new file mode 100644 index 000000000000..21b8a13a2a8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad1d_cpu/debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 8)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = arith.cmpi slt, %10, %c0_i32 : i32 + %12 = arith.select %11, %c0_i32, %10 : i32 + %13 = affine.apply #map2(%8) + %14 = arith.cmpi sge, %13, %c0 : index + %15 = arith.cmpi sge, %10, %c4_i32 : i32 + %16 = arith.select %14, %false, %15 : i1 + %17 = arith.select %16, %c3_i32, %12 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg0[%19] : memref + linalg.yield %20 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad1d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_replication_pad1d_cpu/matched.mlir new file mode 100644 index 000000000000..21b8a13a2a8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad1d_cpu/matched.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 8)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = arith.cmpi slt, %10, %c0_i32 : i32 + %12 = arith.select %11, %c0_i32, %10 : i32 + %13 = affine.apply #map2(%8) + %14 = arith.cmpi sge, %13, %c0 : index + %15 = arith.cmpi sge, %10, %c4_i32 : i32 + %16 = arith.select %14, %false, %15 : i1 + %17 = arith.select %16, %c3_i32, %12 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg0[%19] : memref + linalg.yield %20 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad1d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_replication_pad1d_cpu/orig.mlir new file mode 100644 index 000000000000..58ff0089f38c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad1d_cpu/orig.mlir @@ -0,0 +1,32 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.if #set(%arg3) -> i1 { + affine.yield %false : i1 + } else { + %11 = arith.cmpi sge, %3, %c4_i32 : i32 + affine.yield %11 : i1 + } + %7 = arith.select %6, %c3_i32, %5 : i32 + %8 = arith.addi %1, %7 : i32 + %9 = arith.index_cast %8 : i32 to index + %10 = memref.load %arg0[%9] : memref + affine.store %10, %arg1[%arg3 + %arg2 * 8] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_replication_pad1d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_replication_pad1d_cpu/raised.mlir new file mode 100644 index 000000000000..768e6fb8938e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad1d_cpu/raised.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 8)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %c4_i32 = arith.constant 4 : i32 + %0 = polygeist.submap(%arg1, %c2, %c8) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.addi %5, %c-2_i32 : i32 + %7 = arith.cmpi slt, %6, %c0_i32 : i32 + %8 = arith.select %7, %c0_i32, %6 : i32 + %9 = affine.apply #map2(%4) + %10 = arith.cmpi sge, %9, %c0 : index + %11 = arith.cmpi sge, %6, %c4_i32 : i32 + %12 = arith.select %10, %false, %11 : i1 + %13 = arith.select %12, %c3_i32, %8 : i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = memref.load %arg0[%15] : memref + linalg.yield %16 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad1d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_replication_pad1d_cpu_debuf.mlir new file mode 100644 index 000000000000..21b8a13a2a8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad1d_cpu_debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 8)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = arith.cmpi slt, %10, %c0_i32 : i32 + %12 = arith.select %11, %c0_i32, %10 : i32 + %13 = affine.apply #map2(%8) + %14 = arith.cmpi sge, %13, %c0 : index + %15 = arith.cmpi sge, %10, %c4_i32 : i32 + %16 = arith.select %14, %false, %15 : i1 + %17 = arith.select %16, %c3_i32, %12 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg0[%19] : memref + linalg.yield %20 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad1d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_replication_pad1d_cpu_linalg.mlir new file mode 100644 index 000000000000..768e6fb8938e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad1d_cpu_linalg.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 8)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %c4_i32 = arith.constant 4 : i32 + %0 = polygeist.submap(%arg1, %c2, %c8) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.addi %5, %c-2_i32 : i32 + %7 = arith.cmpi slt, %6, %c0_i32 : i32 + %8 = arith.select %7, %c0_i32, %6 : i32 + %9 = affine.apply #map2(%4) + %10 = arith.cmpi sge, %9, %c0 : index + %11 = arith.cmpi sge, %6, %c4_i32 : i32 + %12 = arith.select %10, %false, %11 : i1 + %13 = arith.select %12, %c3_i32, %8 : i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = memref.load %arg0[%15] : memref + linalg.yield %16 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d.mlir new file mode 100644 index 000000000000..f7c337b5ca95 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d.mlir @@ -0,0 +1,44 @@ +#set = affine_set<(d0) : (d0 == 0)> +#set1 = affine_set<(d0) : (d0 - 9 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c7_i32 = arith.constant 7 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 3 { + affine.for %arg3 = 0 to 10 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = affine.if #set(%arg3) -> i32 { + affine.yield %c0_i32 : i32 + } else { + %3 = affine.if #set1(%arg3) -> i32 { + affine.yield %c7_i32 : i32 + } else { + %4 = arith.addi %0, %c-1_i32 : i32 + affine.yield %4 : i32 + } + affine.yield %3 : i32 + } + %2 = arith.index_cast %1 : i32 to index + affine.for %arg4 = 0 to 10 { + %3 = arith.index_cast %arg4 : index to i32 + %4 = affine.if #set(%arg4) -> i32 { + affine.yield %c0_i32 : i32 + } else { + %7 = affine.if #set1(%arg4) -> i32 { + affine.yield %c7_i32 : i32 + } else { + %8 = arith.addi %3, %c-1_i32 : i32 + affine.yield %8 : i32 + } + affine.yield %7 : i32 + } + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%arg2, %2, %5] : memref + affine.store %6, %arg1[%arg2, %arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d/debuf.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d/debuf.mlir new file mode 100644 index 000000000000..41b32b98e3db --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d/debuf.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0) -> (d0 - 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c7_i32 = arith.constant 7 : i32 + %c-1_i32 = arith.constant -1 : i32 + %c10 = arith.constant 10 : index + %c0 = arith.constant 0 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c3, %c10, %c10] [1, 1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.cmpi eq, %4, %c0 : index + %7 = affine.apply #map1(%4) + %8 = arith.cmpi eq, %7, %c0 : index + %9 = arith.addi %5, %c-1_i32 : i32 + %10 = arith.select %8, %c7_i32, %9 : i32 + %11 = arith.select %6, %c0_i32, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = linalg.index 2 : index + %14 = arith.index_cast %13 : index to i32 + %15 = arith.cmpi eq, %13, %c0 : index + %16 = affine.apply #map1(%13) + %17 = arith.cmpi eq, %16, %c0 : index + %18 = arith.addi %14, %c-1_i32 : i32 + %19 = arith.select %17, %c7_i32, %18 : i32 + %20 = arith.select %15, %c0_i32, %19 : i32 + %21 = arith.index_cast %20 : i32 to index + %22 = memref.load %arg0[%3, %12, %21] : memref + linalg.yield %22 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0, 0] [%c3, %c10, %c10] [1, 1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d/matched.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d/matched.mlir new file mode 100644 index 000000000000..41b32b98e3db --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d/matched.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0) -> (d0 - 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c7_i32 = arith.constant 7 : i32 + %c-1_i32 = arith.constant -1 : i32 + %c10 = arith.constant 10 : index + %c0 = arith.constant 0 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c3, %c10, %c10] [1, 1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.cmpi eq, %4, %c0 : index + %7 = affine.apply #map1(%4) + %8 = arith.cmpi eq, %7, %c0 : index + %9 = arith.addi %5, %c-1_i32 : i32 + %10 = arith.select %8, %c7_i32, %9 : i32 + %11 = arith.select %6, %c0_i32, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = linalg.index 2 : index + %14 = arith.index_cast %13 : index to i32 + %15 = arith.cmpi eq, %13, %c0 : index + %16 = affine.apply #map1(%13) + %17 = arith.cmpi eq, %16, %c0 : index + %18 = arith.addi %14, %c-1_i32 : i32 + %19 = arith.select %17, %c7_i32, %18 : i32 + %20 = arith.select %15, %c0_i32, %19 : i32 + %21 = arith.index_cast %20 : i32 to index + %22 = memref.load %arg0[%3, %12, %21] : memref + linalg.yield %22 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0, 0] [%c3, %c10, %c10] [1, 1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d/orig.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d/orig.mlir new file mode 100644 index 000000000000..f7c337b5ca95 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d/orig.mlir @@ -0,0 +1,44 @@ +#set = affine_set<(d0) : (d0 == 0)> +#set1 = affine_set<(d0) : (d0 - 9 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %c7_i32 = arith.constant 7 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 3 { + affine.for %arg3 = 0 to 10 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = affine.if #set(%arg3) -> i32 { + affine.yield %c0_i32 : i32 + } else { + %3 = affine.if #set1(%arg3) -> i32 { + affine.yield %c7_i32 : i32 + } else { + %4 = arith.addi %0, %c-1_i32 : i32 + affine.yield %4 : i32 + } + affine.yield %3 : i32 + } + %2 = arith.index_cast %1 : i32 to index + affine.for %arg4 = 0 to 10 { + %3 = arith.index_cast %arg4 : index to i32 + %4 = affine.if #set(%arg4) -> i32 { + affine.yield %c0_i32 : i32 + } else { + %7 = affine.if #set1(%arg4) -> i32 { + affine.yield %c7_i32 : i32 + } else { + %8 = arith.addi %3, %c-1_i32 : i32 + affine.yield %8 : i32 + } + affine.yield %7 : i32 + } + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%arg2, %2, %5] : memref + affine.store %6, %arg1[%arg2, %arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d/raised.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d/raised.mlir new file mode 100644 index 000000000000..fb21921bf772 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d/raised.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0) -> (d0 - 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c0 = arith.constant 0 : index + %c10 = arith.constant 10 : index + %c-1_i32 = arith.constant -1 : i32 + %c7_i32 = arith.constant 7 : i32 + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg1[0, 0, 0] [%c3, %c10, %c10] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.cmpi eq, %1, %c0 : index + %4 = affine.apply #map1(%1) + %5 = arith.cmpi eq, %4, %c0 : index + %6 = arith.addi %2, %c-1_i32 : i32 + %7 = arith.select %5, %c7_i32, %6 : i32 + %8 = arith.select %3, %c0_i32, %7 : i32 + %9 = arith.index_cast %8 : i32 to index + %10 = linalg.index 2 : index + %11 = arith.index_cast %10 : index to i32 + %12 = arith.cmpi eq, %10, %c0 : index + %13 = affine.apply #map1(%10) + %14 = arith.cmpi eq, %13, %c0 : index + %15 = arith.addi %11, %c-1_i32 : i32 + %16 = arith.select %14, %c7_i32, %15 : i32 + %17 = arith.select %12, %c0_i32, %16 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = memref.load %arg0[%0, %9, %18] : memref + linalg.yield %19 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu.mlir new file mode 100644 index 000000000000..5544af509c84 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu.mlir @@ -0,0 +1,54 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 40 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.if #set(%arg3) -> i1 { + affine.yield %false : i1 + } else { + %10 = arith.cmpi sge, %3, %c4_i32 : i32 + affine.yield %10 : i1 + } + %7 = arith.select %6, %c3_i32, %5 : i32 + %8 = arith.addi %1, %7 : i32 + %9 = arith.muli %8, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %10 = arith.index_cast %arg4 : index to i32 + %11 = arith.addi %10, %c-2_i32 : i32 + %12 = arith.cmpi slt, %11, %c0_i32 : i32 + %13 = arith.select %12, %c0_i32, %11 : i32 + %14 = affine.if #set(%arg4) -> i1 { + affine.yield %false : i1 + } else { + %21 = arith.cmpi sge, %11, %c5_i32 : i32 + affine.yield %21 : i1 + } + %15 = arith.select %14, %c4_i32, %13 : i32 + %16 = arith.addi %9, %15 : i32 + %17 = arith.index_cast %16 : i32 to index + %18 = affine.load %arg0[%arg4 + %arg2 * 72 + %arg3 * 9] : memref + %19 = memref.load %arg1[%17] : memref + %20 = arith.addf %19, %18 : f32 + memref.store %20, %arg1[%17] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..d3784971b2ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu/debuf.mlir @@ -0,0 +1,63 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1, d2) -> (d0 + d1 * 72 + d2 * 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = arith.cmpi slt, %9, %c0_i32 : i32 + %11 = arith.select %10, %c0_i32, %9 : i32 + %12 = affine.apply #map1(%arg4) + %13 = arith.cmpi sge, %12, %c0 : index + %14 = arith.cmpi sge, %9, %c4_i32 : i32 + %15 = arith.select %13, %false, %14 : i1 + %16 = arith.select %15, %c3_i32, %11 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = affine.for %arg6 = 0 to 9 iter_args(%arg7 = %arg5) -> (tensor) { + %20 = arith.index_cast %arg6 : index to i32 + %21 = arith.addi %20, %c-2_i32 : i32 + %22 = arith.cmpi slt, %21, %c0_i32 : i32 + %23 = arith.select %22, %c0_i32, %21 : i32 + %24 = affine.apply #map1(%arg6) + %25 = arith.cmpi sge, %24, %c0 : index + %26 = arith.cmpi sge, %21, %c5_i32 : i32 + %27 = arith.select %25, %false, %26 : i1 + %28 = arith.select %27, %c4_i32, %23 : i32 + %29 = arith.addi %18, %28 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = affine.apply #map2(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%31] : tensor + %extracted_0 = tensor.extract %arg7[%30] : tensor + %32 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %32 into %arg7[%30] : tensor + affine.yield %inserted : tensor + } + affine.yield %19 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..6e57b859ea0e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu/matched.mlir @@ -0,0 +1,60 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1, d2) -> (d0 + d1 * 72 + d2 * 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = arith.cmpi slt, %9, %c0_i32 : i32 + %11 = arith.select %10, %c0_i32, %9 : i32 + %12 = affine.apply #map1(%arg4) + %13 = arith.cmpi sge, %12, %c0 : index + %14 = arith.cmpi sge, %9, %c4_i32 : i32 + %15 = arith.select %13, %false, %14 : i1 + %16 = arith.select %15, %c3_i32, %11 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = affine.for %arg6 = 0 to 9 iter_args(%arg7 = %arg5) -> (tensor) { + %20 = arith.index_cast %arg6 : index to i32 + %21 = arith.addi %20, %c-2_i32 : i32 + %22 = arith.cmpi slt, %21, %c0_i32 : i32 + %23 = arith.select %22, %c0_i32, %21 : i32 + %24 = affine.apply #map1(%arg6) + %25 = arith.cmpi sge, %24, %c0 : index + %26 = arith.cmpi sge, %21, %c5_i32 : i32 + %27 = arith.select %25, %false, %26 : i1 + %28 = arith.select %27, %c4_i32, %23 : i32 + %29 = arith.addi %18, %28 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = affine.apply #map2(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%31] : tensor + %extracted_0 = tensor.extract %arg7[%30] : tensor + %32 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %32 into %arg7[%30] : tensor + affine.yield %inserted : tensor + } + affine.yield %19 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..5544af509c84 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu/orig.mlir @@ -0,0 +1,54 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 40 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.if #set(%arg3) -> i1 { + affine.yield %false : i1 + } else { + %10 = arith.cmpi sge, %3, %c4_i32 : i32 + affine.yield %10 : i1 + } + %7 = arith.select %6, %c3_i32, %5 : i32 + %8 = arith.addi %1, %7 : i32 + %9 = arith.muli %8, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %10 = arith.index_cast %arg4 : index to i32 + %11 = arith.addi %10, %c-2_i32 : i32 + %12 = arith.cmpi slt, %11, %c0_i32 : i32 + %13 = arith.select %12, %c0_i32, %11 : i32 + %14 = affine.if #set(%arg4) -> i1 { + affine.yield %false : i1 + } else { + %21 = arith.cmpi sge, %11, %c5_i32 : i32 + affine.yield %21 : i1 + } + %15 = arith.select %14, %c4_i32, %13 : i32 + %16 = arith.addi %9, %15 : i32 + %17 = arith.index_cast %16 : i32 to index + %18 = affine.load %arg0[%arg4 + %arg2 * 72 + %arg3 * 9] : memref + %19 = memref.load %arg1[%17] : memref + %20 = arith.addf %19, %18 : f32 + memref.store %20, %arg1[%17] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..1307becc0ea7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu/raised.mlir @@ -0,0 +1,54 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.apply #map1(%arg3) + %7 = arith.cmpi sge, %6, %c0 : index + %8 = arith.cmpi sge, %3, %c4_i32 : i32 + %9 = arith.select %7, %false, %8 : i1 + %10 = arith.select %9, %c3_i32, %5 : i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %13 = arith.index_cast %arg4 : index to i32 + %14 = arith.addi %13, %c-2_i32 : i32 + %15 = arith.cmpi slt, %14, %c0_i32 : i32 + %16 = arith.select %15, %c0_i32, %14 : i32 + %17 = affine.apply #map1(%arg4) + %18 = arith.cmpi sge, %17, %c0 : index + %19 = arith.cmpi sge, %14, %c5_i32 : i32 + %20 = arith.select %18, %false, %19 : i1 + %21 = arith.select %20, %c4_i32, %16 : i32 + %22 = arith.addi %12, %21 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = affine.load %arg0[%arg4 + %arg2 * 72 + %arg3 * 9] : memref + %25 = memref.load %arg1[%23] : memref + %26 = arith.addf %25, %24 : f32 + memref.store %26, %arg1[%23] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..d3784971b2ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu_debuf.mlir @@ -0,0 +1,63 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1, d2) -> (d0 + d1 * 72 + d2 * 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = arith.cmpi slt, %9, %c0_i32 : i32 + %11 = arith.select %10, %c0_i32, %9 : i32 + %12 = affine.apply #map1(%arg4) + %13 = arith.cmpi sge, %12, %c0 : index + %14 = arith.cmpi sge, %9, %c4_i32 : i32 + %15 = arith.select %13, %false, %14 : i1 + %16 = arith.select %15, %c3_i32, %11 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = affine.for %arg6 = 0 to 9 iter_args(%arg7 = %arg5) -> (tensor) { + %20 = arith.index_cast %arg6 : index to i32 + %21 = arith.addi %20, %c-2_i32 : i32 + %22 = arith.cmpi slt, %21, %c0_i32 : i32 + %23 = arith.select %22, %c0_i32, %21 : i32 + %24 = affine.apply #map1(%arg6) + %25 = arith.cmpi sge, %24, %c0 : index + %26 = arith.cmpi sge, %21, %c5_i32 : i32 + %27 = arith.select %25, %false, %26 : i1 + %28 = arith.select %27, %c4_i32, %23 : i32 + %29 = arith.addi %18, %28 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = affine.apply #map2(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%31] : tensor + %extracted_0 = tensor.extract %arg7[%30] : tensor + %32 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %32 into %arg7[%30] : tensor + affine.yield %inserted : tensor + } + affine.yield %19 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..1307becc0ea7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d_backward_cpu_linalg.mlir @@ -0,0 +1,54 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.apply #map1(%arg3) + %7 = arith.cmpi sge, %6, %c0 : index + %8 = arith.cmpi sge, %3, %c4_i32 : i32 + %9 = arith.select %7, %false, %8 : i1 + %10 = arith.select %9, %c3_i32, %5 : i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %13 = arith.index_cast %arg4 : index to i32 + %14 = arith.addi %13, %c-2_i32 : i32 + %15 = arith.cmpi slt, %14, %c0_i32 : i32 + %16 = arith.select %15, %c0_i32, %14 : i32 + %17 = affine.apply #map1(%arg4) + %18 = arith.cmpi sge, %17, %c0 : index + %19 = arith.cmpi sge, %14, %c5_i32 : i32 + %20 = arith.select %18, %false, %19 : i1 + %21 = arith.select %20, %c4_i32, %16 : i32 + %22 = arith.addi %12, %21 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = affine.load %arg0[%arg4 + %arg2 * 72 + %arg3 * 9] : memref + %25 = memref.load %arg1[%23] : memref + %26 = arith.addf %25, %24 : f32 + memref.store %26, %arg1[%23] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d_cpu.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d_cpu.mlir new file mode 100644 index 000000000000..4a276fbc9945 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d_cpu.mlir @@ -0,0 +1,48 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.if #set(%arg3) -> i1 { + affine.yield %false : i1 + } else { + %10 = arith.cmpi sge, %3, %c4_i32 : i32 + affine.yield %10 : i1 + } + %7 = arith.select %6, %c3_i32, %5 : i32 + %8 = arith.addi %1, %7 : i32 + %9 = arith.muli %8, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %10 = arith.index_cast %arg4 : index to i32 + %11 = arith.addi %10, %c-2_i32 : i32 + %12 = arith.cmpi slt, %11, %c0_i32 : i32 + %13 = arith.select %12, %c0_i32, %11 : i32 + %14 = affine.if #set(%arg4) -> i1 { + affine.yield %false : i1 + } else { + %19 = arith.cmpi sge, %11, %c5_i32 : i32 + affine.yield %19 : i1 + } + %15 = arith.select %14, %c4_i32, %13 : i32 + %16 = arith.addi %9, %15 : i32 + %17 = arith.index_cast %16 : i32 to index + %18 = memref.load %arg0[%17] : memref + affine.store %18, %arg1[%arg4 + %arg2 * 72 + %arg3 * 9] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d_cpu/debuf.mlir new file mode 100644 index 000000000000..3e75c2db4aa2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d_cpu/debuf.mlir @@ -0,0 +1,56 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 72 + d1 * 9)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8, %c9) {map = #map} : (tensor, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = arith.cmpi slt, %10, %c0_i32 : i32 + %12 = arith.select %11, %c0_i32, %10 : i32 + %13 = affine.apply #map2(%8) + %14 = arith.cmpi sge, %13, %c0 : index + %15 = arith.cmpi sge, %10, %c4_i32 : i32 + %16 = arith.select %14, %false, %15 : i1 + %17 = arith.select %16, %c3_i32, %12 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = linalg.index 2 : index + %21 = arith.index_cast %20 : index to i32 + %22 = arith.addi %21, %c-2_i32 : i32 + %23 = arith.cmpi slt, %22, %c0_i32 : i32 + %24 = arith.select %23, %c0_i32, %22 : i32 + %25 = affine.apply #map2(%20) + %26 = arith.cmpi sge, %25, %c0 : index + %27 = arith.cmpi sge, %22, %c5_i32 : i32 + %28 = arith.select %26, %false, %27 : i1 + %29 = arith.select %28, %c4_i32, %24 : i32 + %30 = arith.addi %19, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %arg0[%31] : memref + linalg.yield %32 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8, %c9) {map = #map} : (tensor, tensor, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d_cpu/matched.mlir new file mode 100644 index 000000000000..3e75c2db4aa2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d_cpu/matched.mlir @@ -0,0 +1,56 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 72 + d1 * 9)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8, %c9) {map = #map} : (tensor, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = arith.cmpi slt, %10, %c0_i32 : i32 + %12 = arith.select %11, %c0_i32, %10 : i32 + %13 = affine.apply #map2(%8) + %14 = arith.cmpi sge, %13, %c0 : index + %15 = arith.cmpi sge, %10, %c4_i32 : i32 + %16 = arith.select %14, %false, %15 : i1 + %17 = arith.select %16, %c3_i32, %12 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = linalg.index 2 : index + %21 = arith.index_cast %20 : index to i32 + %22 = arith.addi %21, %c-2_i32 : i32 + %23 = arith.cmpi slt, %22, %c0_i32 : i32 + %24 = arith.select %23, %c0_i32, %22 : i32 + %25 = affine.apply #map2(%20) + %26 = arith.cmpi sge, %25, %c0 : index + %27 = arith.cmpi sge, %22, %c5_i32 : i32 + %28 = arith.select %26, %false, %27 : i1 + %29 = arith.select %28, %c4_i32, %24 : i32 + %30 = arith.addi %19, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %arg0[%31] : memref + linalg.yield %32 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8, %c9) {map = #map} : (tensor, tensor, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d_cpu/orig.mlir new file mode 100644 index 000000000000..4a276fbc9945 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d_cpu/orig.mlir @@ -0,0 +1,48 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.if #set(%arg3) -> i1 { + affine.yield %false : i1 + } else { + %10 = arith.cmpi sge, %3, %c4_i32 : i32 + affine.yield %10 : i1 + } + %7 = arith.select %6, %c3_i32, %5 : i32 + %8 = arith.addi %1, %7 : i32 + %9 = arith.muli %8, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %10 = arith.index_cast %arg4 : index to i32 + %11 = arith.addi %10, %c-2_i32 : i32 + %12 = arith.cmpi slt, %11, %c0_i32 : i32 + %13 = arith.select %12, %c0_i32, %11 : i32 + %14 = affine.if #set(%arg4) -> i1 { + affine.yield %false : i1 + } else { + %19 = arith.cmpi sge, %11, %c5_i32 : i32 + affine.yield %19 : i1 + } + %15 = arith.select %14, %c4_i32, %13 : i32 + %16 = arith.addi %9, %15 : i32 + %17 = arith.index_cast %16 : i32 to index + %18 = memref.load %arg0[%17] : memref + affine.store %18, %arg1[%arg4 + %arg2 * 72 + %arg3 * 9] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d_cpu/raised.mlir new file mode 100644 index 000000000000..3d759fc292d0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d_cpu/raised.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 72 + d1 * 9)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %c9 = arith.constant 9 : index + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %0 = polygeist.submap(%arg1, %c2, %c8, %c9) {map = #map} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.addi %5, %c-2_i32 : i32 + %7 = arith.cmpi slt, %6, %c0_i32 : i32 + %8 = arith.select %7, %c0_i32, %6 : i32 + %9 = affine.apply #map2(%4) + %10 = arith.cmpi sge, %9, %c0 : index + %11 = arith.cmpi sge, %6, %c4_i32 : i32 + %12 = arith.select %10, %false, %11 : i1 + %13 = arith.select %12, %c3_i32, %8 : i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = linalg.index 2 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.addi %17, %c-2_i32 : i32 + %19 = arith.cmpi slt, %18, %c0_i32 : i32 + %20 = arith.select %19, %c0_i32, %18 : i32 + %21 = affine.apply #map2(%16) + %22 = arith.cmpi sge, %21, %c0 : index + %23 = arith.cmpi sge, %18, %c5_i32 : i32 + %24 = arith.select %22, %false, %23 : i1 + %25 = arith.select %24, %c4_i32, %20 : i32 + %26 = arith.addi %15, %25 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = memref.load %arg0[%27] : memref + linalg.yield %28 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d_cpu_debuf.mlir new file mode 100644 index 000000000000..3e75c2db4aa2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d_cpu_debuf.mlir @@ -0,0 +1,56 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 72 + d1 * 9)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8, %c9) {map = #map} : (tensor, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = arith.cmpi slt, %10, %c0_i32 : i32 + %12 = arith.select %11, %c0_i32, %10 : i32 + %13 = affine.apply #map2(%8) + %14 = arith.cmpi sge, %13, %c0 : index + %15 = arith.cmpi sge, %10, %c4_i32 : i32 + %16 = arith.select %14, %false, %15 : i1 + %17 = arith.select %16, %c3_i32, %12 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = linalg.index 2 : index + %21 = arith.index_cast %20 : index to i32 + %22 = arith.addi %21, %c-2_i32 : i32 + %23 = arith.cmpi slt, %22, %c0_i32 : i32 + %24 = arith.select %23, %c0_i32, %22 : i32 + %25 = affine.apply #map2(%20) + %26 = arith.cmpi sge, %25, %c0 : index + %27 = arith.cmpi sge, %22, %c5_i32 : i32 + %28 = arith.select %26, %false, %27 : i1 + %29 = arith.select %28, %c4_i32, %24 : i32 + %30 = arith.addi %19, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %arg0[%31] : memref + linalg.yield %32 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8, %c9) {map = #map} : (tensor, tensor, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d_cpu_linalg.mlir new file mode 100644 index 000000000000..3d759fc292d0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d_cpu_linalg.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 72 + d1 * 9)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %c9 = arith.constant 9 : index + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %0 = polygeist.submap(%arg1, %c2, %c8, %c9) {map = #map} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.addi %5, %c-2_i32 : i32 + %7 = arith.cmpi slt, %6, %c0_i32 : i32 + %8 = arith.select %7, %c0_i32, %6 : i32 + %9 = affine.apply #map2(%4) + %10 = arith.cmpi sge, %9, %c0 : index + %11 = arith.cmpi sge, %6, %c4_i32 : i32 + %12 = arith.select %10, %false, %11 : i1 + %13 = arith.select %12, %c3_i32, %8 : i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = linalg.index 2 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.addi %17, %c-2_i32 : i32 + %19 = arith.cmpi slt, %18, %c0_i32 : i32 + %20 = arith.select %19, %c0_i32, %18 : i32 + %21 = affine.apply #map2(%16) + %22 = arith.cmpi sge, %21, %c0 : index + %23 = arith.cmpi sge, %18, %c5_i32 : i32 + %24 = arith.select %22, %false, %23 : i1 + %25 = arith.select %24, %c4_i32, %20 : i32 + %26 = arith.addi %15, %25 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = memref.load %arg0[%27] : memref + linalg.yield %28 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d_debuf.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d_debuf.mlir new file mode 100644 index 000000000000..41b32b98e3db --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d_debuf.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0) -> (d0 - 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c7_i32 = arith.constant 7 : i32 + %c-1_i32 = arith.constant -1 : i32 + %c10 = arith.constant 10 : index + %c0 = arith.constant 0 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c3, %c10, %c10] [1, 1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.cmpi eq, %4, %c0 : index + %7 = affine.apply #map1(%4) + %8 = arith.cmpi eq, %7, %c0 : index + %9 = arith.addi %5, %c-1_i32 : i32 + %10 = arith.select %8, %c7_i32, %9 : i32 + %11 = arith.select %6, %c0_i32, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = linalg.index 2 : index + %14 = arith.index_cast %13 : index to i32 + %15 = arith.cmpi eq, %13, %c0 : index + %16 = affine.apply #map1(%13) + %17 = arith.cmpi eq, %16, %c0 : index + %18 = arith.addi %14, %c-1_i32 : i32 + %19 = arith.select %17, %c7_i32, %18 : i32 + %20 = arith.select %15, %c0_i32, %19 : i32 + %21 = arith.index_cast %20 : i32 to index + %22 = memref.load %arg0[%3, %12, %21] : memref + linalg.yield %22 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0, 0] [%c3, %c10, %c10] [1, 1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad2d_linalg.mlir b/issues/aten_c_kernels/results/aten_replication_pad2d_linalg.mlir new file mode 100644 index 000000000000..fb21921bf772 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad2d_linalg.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0) -> (d0 - 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c0 = arith.constant 0 : index + %c10 = arith.constant 10 : index + %c-1_i32 = arith.constant -1 : i32 + %c7_i32 = arith.constant 7 : i32 + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg1[0, 0, 0] [%c3, %c10, %c10] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.cmpi eq, %1, %c0 : index + %4 = affine.apply #map1(%1) + %5 = arith.cmpi eq, %4, %c0 : index + %6 = arith.addi %2, %c-1_i32 : i32 + %7 = arith.select %5, %c7_i32, %6 : i32 + %8 = arith.select %3, %c0_i32, %7 : i32 + %9 = arith.index_cast %8 : i32 to index + %10 = linalg.index 2 : index + %11 = arith.index_cast %10 : index to i32 + %12 = arith.cmpi eq, %10, %c0 : index + %13 = affine.apply #map1(%10) + %14 = arith.cmpi eq, %13, %c0 : index + %15 = arith.addi %11, %c-1_i32 : i32 + %16 = arith.select %14, %c7_i32, %15 : i32 + %17 = arith.select %12, %c0_i32, %16 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = memref.load %arg0[%0, %9, %18] : memref + linalg.yield %19 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu.mlir new file mode 100644 index 000000000000..3fcc8cf1a31b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu.mlir @@ -0,0 +1,70 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 240 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.if #set(%arg3) -> i1 { + affine.yield %false : i1 + } else { + %10 = arith.cmpi sge, %3, %c4_i32 : i32 + affine.yield %10 : i1 + } + %7 = arith.select %6, %c3_i32, %5 : i32 + %8 = arith.addi %1, %7 : i32 + %9 = arith.muli %8, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %10 = arith.index_cast %arg4 : index to i32 + %11 = arith.addi %10, %c-2_i32 : i32 + %12 = arith.cmpi slt, %11, %c0_i32 : i32 + %13 = arith.select %12, %c0_i32, %11 : i32 + %14 = affine.if #set(%arg4) -> i1 { + affine.yield %false : i1 + } else { + %18 = arith.cmpi sge, %11, %c5_i32 : i32 + affine.yield %18 : i1 + } + %15 = arith.select %14, %c4_i32, %13 : i32 + %16 = arith.addi %9, %15 : i32 + %17 = arith.muli %16, %c6_i32 : i32 + affine.for %arg5 = 0 to 10 { + %18 = arith.index_cast %arg5 : index to i32 + %19 = arith.addi %18, %c-2_i32 : i32 + %20 = arith.cmpi slt, %19, %c0_i32 : i32 + %21 = arith.select %20, %c0_i32, %19 : i32 + %22 = affine.if #set(%arg5) -> i1 { + affine.yield %false : i1 + } else { + %29 = arith.cmpi sge, %19, %c6_i32 : i32 + affine.yield %29 : i1 + } + %23 = arith.select %22, %c5_i32, %21 : i32 + %24 = arith.addi %17, %23 : i32 + %25 = arith.index_cast %24 : i32 to index + %26 = affine.load %arg0[%arg2 * 720 + %arg5 + %arg3 * 90 + %arg4 * 10] : memref + %27 = memref.load %arg1[%25] : memref + %28 = arith.addf %27, %26 : f32 + memref.store %28, %arg1[%25] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..5129d36a56dd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu/debuf.mlir @@ -0,0 +1,78 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0 * 720 + d1 + d2 * 90 + d3 * 10)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = arith.cmpi slt, %9, %c0_i32 : i32 + %11 = arith.select %10, %c0_i32, %9 : i32 + %12 = affine.apply #map1(%arg4) + %13 = arith.cmpi sge, %12, %c0 : index + %14 = arith.cmpi sge, %9, %c4_i32 : i32 + %15 = arith.select %13, %false, %14 : i1 + %16 = arith.select %15, %c3_i32, %11 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = affine.for %arg6 = 0 to 9 iter_args(%arg7 = %arg5) -> (tensor) { + %20 = arith.index_cast %arg6 : index to i32 + %21 = arith.addi %20, %c-2_i32 : i32 + %22 = arith.cmpi slt, %21, %c0_i32 : i32 + %23 = arith.select %22, %c0_i32, %21 : i32 + %24 = affine.apply #map1(%arg6) + %25 = arith.cmpi sge, %24, %c0 : index + %26 = arith.cmpi sge, %21, %c5_i32 : i32 + %27 = arith.select %25, %false, %26 : i1 + %28 = arith.select %27, %c4_i32, %23 : i32 + %29 = arith.addi %18, %28 : i32 + %30 = arith.muli %29, %c6_i32 : i32 + %31 = affine.for %arg8 = 0 to 10 iter_args(%arg9 = %arg7) -> (tensor) { + %32 = arith.index_cast %arg8 : index to i32 + %33 = arith.addi %32, %c-2_i32 : i32 + %34 = arith.cmpi slt, %33, %c0_i32 : i32 + %35 = arith.select %34, %c0_i32, %33 : i32 + %36 = affine.apply #map1(%arg8) + %37 = arith.cmpi sge, %36, %c0 : index + %38 = arith.cmpi sge, %33, %c6_i32 : i32 + %39 = arith.select %37, %false, %38 : i1 + %40 = arith.select %39, %c5_i32, %35 : i32 + %41 = arith.addi %30, %40 : i32 + %42 = arith.index_cast %41 : i32 to index + %43 = affine.apply #map2(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%43] : tensor + %extracted_0 = tensor.extract %arg9[%42] : tensor + %44 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %44 into %arg9[%42] : tensor + affine.yield %inserted : tensor + } + affine.yield %31 : tensor + } + affine.yield %19 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..058b83a599b7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu/matched.mlir @@ -0,0 +1,75 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0 * 720 + d1 + d2 * 90 + d3 * 10)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = arith.cmpi slt, %9, %c0_i32 : i32 + %11 = arith.select %10, %c0_i32, %9 : i32 + %12 = affine.apply #map1(%arg4) + %13 = arith.cmpi sge, %12, %c0 : index + %14 = arith.cmpi sge, %9, %c4_i32 : i32 + %15 = arith.select %13, %false, %14 : i1 + %16 = arith.select %15, %c3_i32, %11 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = affine.for %arg6 = 0 to 9 iter_args(%arg7 = %arg5) -> (tensor) { + %20 = arith.index_cast %arg6 : index to i32 + %21 = arith.addi %20, %c-2_i32 : i32 + %22 = arith.cmpi slt, %21, %c0_i32 : i32 + %23 = arith.select %22, %c0_i32, %21 : i32 + %24 = affine.apply #map1(%arg6) + %25 = arith.cmpi sge, %24, %c0 : index + %26 = arith.cmpi sge, %21, %c5_i32 : i32 + %27 = arith.select %25, %false, %26 : i1 + %28 = arith.select %27, %c4_i32, %23 : i32 + %29 = arith.addi %18, %28 : i32 + %30 = arith.muli %29, %c6_i32 : i32 + %31 = affine.for %arg8 = 0 to 10 iter_args(%arg9 = %arg7) -> (tensor) { + %32 = arith.index_cast %arg8 : index to i32 + %33 = arith.addi %32, %c-2_i32 : i32 + %34 = arith.cmpi slt, %33, %c0_i32 : i32 + %35 = arith.select %34, %c0_i32, %33 : i32 + %36 = affine.apply #map1(%arg8) + %37 = arith.cmpi sge, %36, %c0 : index + %38 = arith.cmpi sge, %33, %c6_i32 : i32 + %39 = arith.select %37, %false, %38 : i1 + %40 = arith.select %39, %c5_i32, %35 : i32 + %41 = arith.addi %30, %40 : i32 + %42 = arith.index_cast %41 : i32 to index + %43 = affine.apply #map2(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%43] : tensor + %extracted_0 = tensor.extract %arg9[%42] : tensor + %44 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %44 into %arg9[%42] : tensor + affine.yield %inserted : tensor + } + affine.yield %31 : tensor + } + affine.yield %19 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..3fcc8cf1a31b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu/orig.mlir @@ -0,0 +1,70 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 240 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.if #set(%arg3) -> i1 { + affine.yield %false : i1 + } else { + %10 = arith.cmpi sge, %3, %c4_i32 : i32 + affine.yield %10 : i1 + } + %7 = arith.select %6, %c3_i32, %5 : i32 + %8 = arith.addi %1, %7 : i32 + %9 = arith.muli %8, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %10 = arith.index_cast %arg4 : index to i32 + %11 = arith.addi %10, %c-2_i32 : i32 + %12 = arith.cmpi slt, %11, %c0_i32 : i32 + %13 = arith.select %12, %c0_i32, %11 : i32 + %14 = affine.if #set(%arg4) -> i1 { + affine.yield %false : i1 + } else { + %18 = arith.cmpi sge, %11, %c5_i32 : i32 + affine.yield %18 : i1 + } + %15 = arith.select %14, %c4_i32, %13 : i32 + %16 = arith.addi %9, %15 : i32 + %17 = arith.muli %16, %c6_i32 : i32 + affine.for %arg5 = 0 to 10 { + %18 = arith.index_cast %arg5 : index to i32 + %19 = arith.addi %18, %c-2_i32 : i32 + %20 = arith.cmpi slt, %19, %c0_i32 : i32 + %21 = arith.select %20, %c0_i32, %19 : i32 + %22 = affine.if #set(%arg5) -> i1 { + affine.yield %false : i1 + } else { + %29 = arith.cmpi sge, %19, %c6_i32 : i32 + affine.yield %29 : i1 + } + %23 = arith.select %22, %c5_i32, %21 : i32 + %24 = arith.addi %17, %23 : i32 + %25 = arith.index_cast %24 : i32 to index + %26 = affine.load %arg0[%arg2 * 720 + %arg5 + %arg3 * 90 + %arg4 * 10] : memref + %27 = memref.load %arg1[%25] : memref + %28 = arith.addf %27, %26 : f32 + memref.store %28, %arg1[%25] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..462db34f92f6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu/raised.mlir @@ -0,0 +1,68 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.apply #map1(%arg3) + %7 = arith.cmpi sge, %6, %c0 : index + %8 = arith.cmpi sge, %3, %c4_i32 : i32 + %9 = arith.select %7, %false, %8 : i1 + %10 = arith.select %9, %c3_i32, %5 : i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %13 = arith.index_cast %arg4 : index to i32 + %14 = arith.addi %13, %c-2_i32 : i32 + %15 = arith.cmpi slt, %14, %c0_i32 : i32 + %16 = arith.select %15, %c0_i32, %14 : i32 + %17 = affine.apply #map1(%arg4) + %18 = arith.cmpi sge, %17, %c0 : index + %19 = arith.cmpi sge, %14, %c5_i32 : i32 + %20 = arith.select %18, %false, %19 : i1 + %21 = arith.select %20, %c4_i32, %16 : i32 + %22 = arith.addi %12, %21 : i32 + %23 = arith.muli %22, %c6_i32 : i32 + affine.for %arg5 = 0 to 10 { + %24 = arith.index_cast %arg5 : index to i32 + %25 = arith.addi %24, %c-2_i32 : i32 + %26 = arith.cmpi slt, %25, %c0_i32 : i32 + %27 = arith.select %26, %c0_i32, %25 : i32 + %28 = affine.apply #map1(%arg5) + %29 = arith.cmpi sge, %28, %c0 : index + %30 = arith.cmpi sge, %25, %c6_i32 : i32 + %31 = arith.select %29, %false, %30 : i1 + %32 = arith.select %31, %c5_i32, %27 : i32 + %33 = arith.addi %23, %32 : i32 + %34 = arith.index_cast %33 : i32 to index + %35 = affine.load %arg0[%arg2 * 720 + %arg5 + %arg3 * 90 + %arg4 * 10] : memref + %36 = memref.load %arg1[%34] : memref + %37 = arith.addf %36, %35 : f32 + memref.store %37, %arg1[%34] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..5129d36a56dd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu_debuf.mlir @@ -0,0 +1,78 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0 * 720 + d1 + d2 * 90 + d3 * 10)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.addi %8, %c-2_i32 : i32 + %10 = arith.cmpi slt, %9, %c0_i32 : i32 + %11 = arith.select %10, %c0_i32, %9 : i32 + %12 = affine.apply #map1(%arg4) + %13 = arith.cmpi sge, %12, %c0 : index + %14 = arith.cmpi sge, %9, %c4_i32 : i32 + %15 = arith.select %13, %false, %14 : i1 + %16 = arith.select %15, %c3_i32, %11 : i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = affine.for %arg6 = 0 to 9 iter_args(%arg7 = %arg5) -> (tensor) { + %20 = arith.index_cast %arg6 : index to i32 + %21 = arith.addi %20, %c-2_i32 : i32 + %22 = arith.cmpi slt, %21, %c0_i32 : i32 + %23 = arith.select %22, %c0_i32, %21 : i32 + %24 = affine.apply #map1(%arg6) + %25 = arith.cmpi sge, %24, %c0 : index + %26 = arith.cmpi sge, %21, %c5_i32 : i32 + %27 = arith.select %25, %false, %26 : i1 + %28 = arith.select %27, %c4_i32, %23 : i32 + %29 = arith.addi %18, %28 : i32 + %30 = arith.muli %29, %c6_i32 : i32 + %31 = affine.for %arg8 = 0 to 10 iter_args(%arg9 = %arg7) -> (tensor) { + %32 = arith.index_cast %arg8 : index to i32 + %33 = arith.addi %32, %c-2_i32 : i32 + %34 = arith.cmpi slt, %33, %c0_i32 : i32 + %35 = arith.select %34, %c0_i32, %33 : i32 + %36 = affine.apply #map1(%arg8) + %37 = arith.cmpi sge, %36, %c0 : index + %38 = arith.cmpi sge, %33, %c6_i32 : i32 + %39 = arith.select %37, %false, %38 : i1 + %40 = arith.select %39, %c5_i32, %35 : i32 + %41 = arith.addi %30, %40 : i32 + %42 = arith.index_cast %41 : i32 to index + %43 = affine.apply #map2(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%43] : tensor + %extracted_0 = tensor.extract %arg9[%42] : tensor + %44 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %44 into %arg9[%42] : tensor + affine.yield %inserted : tensor + } + affine.yield %31 : tensor + } + affine.yield %19 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..462db34f92f6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad3d_backward_cpu_linalg.mlir @@ -0,0 +1,68 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.apply #map1(%arg3) + %7 = arith.cmpi sge, %6, %c0 : index + %8 = arith.cmpi sge, %3, %c4_i32 : i32 + %9 = arith.select %7, %false, %8 : i1 + %10 = arith.select %9, %c3_i32, %5 : i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %13 = arith.index_cast %arg4 : index to i32 + %14 = arith.addi %13, %c-2_i32 : i32 + %15 = arith.cmpi slt, %14, %c0_i32 : i32 + %16 = arith.select %15, %c0_i32, %14 : i32 + %17 = affine.apply #map1(%arg4) + %18 = arith.cmpi sge, %17, %c0 : index + %19 = arith.cmpi sge, %14, %c5_i32 : i32 + %20 = arith.select %18, %false, %19 : i1 + %21 = arith.select %20, %c4_i32, %16 : i32 + %22 = arith.addi %12, %21 : i32 + %23 = arith.muli %22, %c6_i32 : i32 + affine.for %arg5 = 0 to 10 { + %24 = arith.index_cast %arg5 : index to i32 + %25 = arith.addi %24, %c-2_i32 : i32 + %26 = arith.cmpi slt, %25, %c0_i32 : i32 + %27 = arith.select %26, %c0_i32, %25 : i32 + %28 = affine.apply #map1(%arg5) + %29 = arith.cmpi sge, %28, %c0 : index + %30 = arith.cmpi sge, %25, %c6_i32 : i32 + %31 = arith.select %29, %false, %30 : i1 + %32 = arith.select %31, %c5_i32, %27 : i32 + %33 = arith.addi %23, %32 : i32 + %34 = arith.index_cast %33 : i32 to index + %35 = affine.load %arg0[%arg2 * 720 + %arg5 + %arg3 * 90 + %arg4 * 10] : memref + %36 = memref.load %arg1[%34] : memref + %37 = arith.addf %36, %35 : f32 + memref.store %37, %arg1[%34] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad3d_cpu.mlir b/issues/aten_c_kernels/results/aten_replication_pad3d_cpu.mlir new file mode 100644 index 000000000000..802ebd13dc0d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad3d_cpu.mlir @@ -0,0 +1,64 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.if #set(%arg3) -> i1 { + affine.yield %false : i1 + } else { + %10 = arith.cmpi sge, %3, %c4_i32 : i32 + affine.yield %10 : i1 + } + %7 = arith.select %6, %c3_i32, %5 : i32 + %8 = arith.addi %1, %7 : i32 + %9 = arith.muli %8, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %10 = arith.index_cast %arg4 : index to i32 + %11 = arith.addi %10, %c-2_i32 : i32 + %12 = arith.cmpi slt, %11, %c0_i32 : i32 + %13 = arith.select %12, %c0_i32, %11 : i32 + %14 = affine.if #set(%arg4) -> i1 { + affine.yield %false : i1 + } else { + %18 = arith.cmpi sge, %11, %c5_i32 : i32 + affine.yield %18 : i1 + } + %15 = arith.select %14, %c4_i32, %13 : i32 + %16 = arith.addi %9, %15 : i32 + %17 = arith.muli %16, %c6_i32 : i32 + affine.for %arg5 = 0 to 10 { + %18 = arith.index_cast %arg5 : index to i32 + %19 = arith.addi %18, %c-2_i32 : i32 + %20 = arith.cmpi slt, %19, %c0_i32 : i32 + %21 = arith.select %20, %c0_i32, %19 : i32 + %22 = affine.if #set(%arg5) -> i1 { + affine.yield %false : i1 + } else { + %27 = arith.cmpi sge, %19, %c6_i32 : i32 + affine.yield %27 : i1 + } + %23 = arith.select %22, %c5_i32, %21 : i32 + %24 = arith.addi %17, %23 : i32 + %25 = arith.index_cast %24 : i32 to index + %26 = memref.load %arg0[%25] : memref + affine.store %26, %arg1[%arg2 * 720 + %arg5 + %arg3 * 90 + %arg4 * 10] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_replication_pad3d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_replication_pad3d_cpu/debuf.mlir new file mode 100644 index 000000000000..6e4c464afddd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad3d_cpu/debuf.mlir @@ -0,0 +1,70 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 720 + d1 * 90 + d2 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c10 = arith.constant 10 : index + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8, %c9, %c10) {map = #map} : (tensor, index, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = arith.cmpi slt, %10, %c0_i32 : i32 + %12 = arith.select %11, %c0_i32, %10 : i32 + %13 = affine.apply #map2(%8) + %14 = arith.cmpi sge, %13, %c0 : index + %15 = arith.cmpi sge, %10, %c4_i32 : i32 + %16 = arith.select %14, %false, %15 : i1 + %17 = arith.select %16, %c3_i32, %12 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = linalg.index 2 : index + %21 = arith.index_cast %20 : index to i32 + %22 = arith.addi %21, %c-2_i32 : i32 + %23 = arith.cmpi slt, %22, %c0_i32 : i32 + %24 = arith.select %23, %c0_i32, %22 : i32 + %25 = affine.apply #map2(%20) + %26 = arith.cmpi sge, %25, %c0 : index + %27 = arith.cmpi sge, %22, %c5_i32 : i32 + %28 = arith.select %26, %false, %27 : i1 + %29 = arith.select %28, %c4_i32, %24 : i32 + %30 = arith.addi %19, %29 : i32 + %31 = arith.muli %30, %c6_i32 : i32 + %32 = linalg.index 3 : index + %33 = arith.index_cast %32 : index to i32 + %34 = arith.addi %33, %c-2_i32 : i32 + %35 = arith.cmpi slt, %34, %c0_i32 : i32 + %36 = arith.select %35, %c0_i32, %34 : i32 + %37 = affine.apply #map2(%32) + %38 = arith.cmpi sge, %37, %c0 : index + %39 = arith.cmpi sge, %34, %c6_i32 : i32 + %40 = arith.select %38, %false, %39 : i1 + %41 = arith.select %40, %c5_i32, %36 : i32 + %42 = arith.addi %31, %41 : i32 + %43 = arith.index_cast %42 : i32 to index + %44 = memref.load %arg0[%43] : memref + linalg.yield %44 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8, %c9, %c10) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad3d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_replication_pad3d_cpu/matched.mlir new file mode 100644 index 000000000000..6e4c464afddd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad3d_cpu/matched.mlir @@ -0,0 +1,70 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 720 + d1 * 90 + d2 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c10 = arith.constant 10 : index + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8, %c9, %c10) {map = #map} : (tensor, index, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = arith.cmpi slt, %10, %c0_i32 : i32 + %12 = arith.select %11, %c0_i32, %10 : i32 + %13 = affine.apply #map2(%8) + %14 = arith.cmpi sge, %13, %c0 : index + %15 = arith.cmpi sge, %10, %c4_i32 : i32 + %16 = arith.select %14, %false, %15 : i1 + %17 = arith.select %16, %c3_i32, %12 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = linalg.index 2 : index + %21 = arith.index_cast %20 : index to i32 + %22 = arith.addi %21, %c-2_i32 : i32 + %23 = arith.cmpi slt, %22, %c0_i32 : i32 + %24 = arith.select %23, %c0_i32, %22 : i32 + %25 = affine.apply #map2(%20) + %26 = arith.cmpi sge, %25, %c0 : index + %27 = arith.cmpi sge, %22, %c5_i32 : i32 + %28 = arith.select %26, %false, %27 : i1 + %29 = arith.select %28, %c4_i32, %24 : i32 + %30 = arith.addi %19, %29 : i32 + %31 = arith.muli %30, %c6_i32 : i32 + %32 = linalg.index 3 : index + %33 = arith.index_cast %32 : index to i32 + %34 = arith.addi %33, %c-2_i32 : i32 + %35 = arith.cmpi slt, %34, %c0_i32 : i32 + %36 = arith.select %35, %c0_i32, %34 : i32 + %37 = affine.apply #map2(%32) + %38 = arith.cmpi sge, %37, %c0 : index + %39 = arith.cmpi sge, %34, %c6_i32 : i32 + %40 = arith.select %38, %false, %39 : i1 + %41 = arith.select %40, %c5_i32, %36 : i32 + %42 = arith.addi %31, %41 : i32 + %43 = arith.index_cast %42 : i32 to index + %44 = memref.load %arg0[%43] : memref + linalg.yield %44 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8, %c9, %c10) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad3d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_replication_pad3d_cpu/orig.mlir new file mode 100644 index 000000000000..802ebd13dc0d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad3d_cpu/orig.mlir @@ -0,0 +1,64 @@ +#set = affine_set<(d0) : (-d0 + 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 8 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.addi %2, %c-2_i32 : i32 + %4 = arith.cmpi slt, %3, %c0_i32 : i32 + %5 = arith.select %4, %c0_i32, %3 : i32 + %6 = affine.if #set(%arg3) -> i1 { + affine.yield %false : i1 + } else { + %10 = arith.cmpi sge, %3, %c4_i32 : i32 + affine.yield %10 : i1 + } + %7 = arith.select %6, %c3_i32, %5 : i32 + %8 = arith.addi %1, %7 : i32 + %9 = arith.muli %8, %c5_i32 : i32 + affine.for %arg4 = 0 to 9 { + %10 = arith.index_cast %arg4 : index to i32 + %11 = arith.addi %10, %c-2_i32 : i32 + %12 = arith.cmpi slt, %11, %c0_i32 : i32 + %13 = arith.select %12, %c0_i32, %11 : i32 + %14 = affine.if #set(%arg4) -> i1 { + affine.yield %false : i1 + } else { + %18 = arith.cmpi sge, %11, %c5_i32 : i32 + affine.yield %18 : i1 + } + %15 = arith.select %14, %c4_i32, %13 : i32 + %16 = arith.addi %9, %15 : i32 + %17 = arith.muli %16, %c6_i32 : i32 + affine.for %arg5 = 0 to 10 { + %18 = arith.index_cast %arg5 : index to i32 + %19 = arith.addi %18, %c-2_i32 : i32 + %20 = arith.cmpi slt, %19, %c0_i32 : i32 + %21 = arith.select %20, %c0_i32, %19 : i32 + %22 = affine.if #set(%arg5) -> i1 { + affine.yield %false : i1 + } else { + %27 = arith.cmpi sge, %19, %c6_i32 : i32 + affine.yield %27 : i1 + } + %23 = arith.select %22, %c5_i32, %21 : i32 + %24 = arith.addi %17, %23 : i32 + %25 = arith.index_cast %24 : i32 to index + %26 = memref.load %arg0[%25] : memref + affine.store %26, %arg1[%arg2 * 720 + %arg5 + %arg3 * 90 + %arg4 * 10] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_replication_pad3d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_replication_pad3d_cpu/raised.mlir new file mode 100644 index 000000000000..a7fd1d213a2d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad3d_cpu/raised.mlir @@ -0,0 +1,66 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 720 + d1 * 90 + d2 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %c9 = arith.constant 9 : index + %c10 = arith.constant 10 : index + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %0 = polygeist.submap(%arg1, %c2, %c8, %c9, %c10) {map = #map} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.addi %5, %c-2_i32 : i32 + %7 = arith.cmpi slt, %6, %c0_i32 : i32 + %8 = arith.select %7, %c0_i32, %6 : i32 + %9 = affine.apply #map2(%4) + %10 = arith.cmpi sge, %9, %c0 : index + %11 = arith.cmpi sge, %6, %c4_i32 : i32 + %12 = arith.select %10, %false, %11 : i1 + %13 = arith.select %12, %c3_i32, %8 : i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = linalg.index 2 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.addi %17, %c-2_i32 : i32 + %19 = arith.cmpi slt, %18, %c0_i32 : i32 + %20 = arith.select %19, %c0_i32, %18 : i32 + %21 = affine.apply #map2(%16) + %22 = arith.cmpi sge, %21, %c0 : index + %23 = arith.cmpi sge, %18, %c5_i32 : i32 + %24 = arith.select %22, %false, %23 : i1 + %25 = arith.select %24, %c4_i32, %20 : i32 + %26 = arith.addi %15, %25 : i32 + %27 = arith.muli %26, %c6_i32 : i32 + %28 = linalg.index 3 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.addi %29, %c-2_i32 : i32 + %31 = arith.cmpi slt, %30, %c0_i32 : i32 + %32 = arith.select %31, %c0_i32, %30 : i32 + %33 = affine.apply #map2(%28) + %34 = arith.cmpi sge, %33, %c0 : index + %35 = arith.cmpi sge, %30, %c6_i32 : i32 + %36 = arith.select %34, %false, %35 : i1 + %37 = arith.select %36, %c5_i32, %32 : i32 + %38 = arith.addi %27, %37 : i32 + %39 = arith.index_cast %38 : i32 to index + %40 = memref.load %arg0[%39] : memref + linalg.yield %40 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad3d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_replication_pad3d_cpu_debuf.mlir new file mode 100644 index 000000000000..6e4c464afddd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad3d_cpu_debuf.mlir @@ -0,0 +1,70 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 720 + d1 * 90 + d2 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %c3_i32 = arith.constant 3 : i32 + %false = arith.constant false + %c-2_i32 = arith.constant -2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c10 = arith.constant 10 : index + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c8, %c9, %c10) {map = #map} : (tensor, index, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.addi %9, %c-2_i32 : i32 + %11 = arith.cmpi slt, %10, %c0_i32 : i32 + %12 = arith.select %11, %c0_i32, %10 : i32 + %13 = affine.apply #map2(%8) + %14 = arith.cmpi sge, %13, %c0 : index + %15 = arith.cmpi sge, %10, %c4_i32 : i32 + %16 = arith.select %14, %false, %15 : i1 + %17 = arith.select %16, %c3_i32, %12 : i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = linalg.index 2 : index + %21 = arith.index_cast %20 : index to i32 + %22 = arith.addi %21, %c-2_i32 : i32 + %23 = arith.cmpi slt, %22, %c0_i32 : i32 + %24 = arith.select %23, %c0_i32, %22 : i32 + %25 = affine.apply #map2(%20) + %26 = arith.cmpi sge, %25, %c0 : index + %27 = arith.cmpi sge, %22, %c5_i32 : i32 + %28 = arith.select %26, %false, %27 : i1 + %29 = arith.select %28, %c4_i32, %24 : i32 + %30 = arith.addi %19, %29 : i32 + %31 = arith.muli %30, %c6_i32 : i32 + %32 = linalg.index 3 : index + %33 = arith.index_cast %32 : index to i32 + %34 = arith.addi %33, %c-2_i32 : i32 + %35 = arith.cmpi slt, %34, %c0_i32 : i32 + %36 = arith.select %35, %c0_i32, %34 : i32 + %37 = affine.apply #map2(%32) + %38 = arith.cmpi sge, %37, %c0 : index + %39 = arith.cmpi sge, %34, %c6_i32 : i32 + %40 = arith.select %38, %false, %39 : i1 + %41 = arith.select %40, %c5_i32, %36 : i32 + %42 = arith.addi %31, %41 : i32 + %43 = arith.index_cast %42 : i32 to index + %44 = memref.load %arg0[%43] : memref + linalg.yield %44 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c8, %c9, %c10) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_replication_pad3d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_replication_pad3d_cpu_linalg.mlir new file mode 100644 index 000000000000..a7fd1d213a2d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_replication_pad3d_cpu_linalg.mlir @@ -0,0 +1,66 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 720 + d1 * 90 + d2 * 10)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map2 = affine_map<(d0) -> (-d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_replication_pad3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %c9 = arith.constant 9 : index + %c10 = arith.constant 10 : index + %c0_i32 = arith.constant 0 : i32 + %c-2_i32 = arith.constant -2 : i32 + %false = arith.constant false + %c3_i32 = arith.constant 3 : i32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %0 = polygeist.submap(%arg1, %c2, %c8, %c9, %c10) {map = #map} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.addi %5, %c-2_i32 : i32 + %7 = arith.cmpi slt, %6, %c0_i32 : i32 + %8 = arith.select %7, %c0_i32, %6 : i32 + %9 = affine.apply #map2(%4) + %10 = arith.cmpi sge, %9, %c0 : index + %11 = arith.cmpi sge, %6, %c4_i32 : i32 + %12 = arith.select %10, %false, %11 : i1 + %13 = arith.select %12, %c3_i32, %8 : i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = linalg.index 2 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.addi %17, %c-2_i32 : i32 + %19 = arith.cmpi slt, %18, %c0_i32 : i32 + %20 = arith.select %19, %c0_i32, %18 : i32 + %21 = affine.apply #map2(%16) + %22 = arith.cmpi sge, %21, %c0 : index + %23 = arith.cmpi sge, %18, %c5_i32 : i32 + %24 = arith.select %22, %false, %23 : i1 + %25 = arith.select %24, %c4_i32, %20 : i32 + %26 = arith.addi %15, %25 : i32 + %27 = arith.muli %26, %c6_i32 : i32 + %28 = linalg.index 3 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.addi %29, %c-2_i32 : i32 + %31 = arith.cmpi slt, %30, %c0_i32 : i32 + %32 = arith.select %31, %c0_i32, %30 : i32 + %33 = affine.apply #map2(%28) + %34 = arith.cmpi sge, %33, %c0 : index + %35 = arith.cmpi sge, %30, %c6_i32 : i32 + %36 = arith.select %34, %false, %35 : i1 + %37 = arith.select %36, %c5_i32, %32 : i32 + %38 = arith.addi %27, %37 : i32 + %39 = arith.index_cast %38 : i32 to index + %40 = memref.load %arg0[%39] : memref + linalg.yield %40 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rms_norm.mlir b/issues/aten_c_kernels/results/aten_rms_norm.mlir new file mode 100644 index 000000000000..c23f1aad1f67 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rms_norm.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rms_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.280000e+02 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_1, %alloca[] : memref + affine.for %arg4 = 0 to 128 { + %5 = affine.load %arg0[%arg4] : memref + %6 = arith.mulf %5, %5 : f32 + %7 = affine.load %alloca[] : memref + %8 = arith.addf %7, %6 : f32 + affine.store %8, %alloca[] : memref + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f32 + %2 = arith.addf %1, %arg3 : f32 + %3 = math.sqrt %2 : f32 + %4 = arith.divf %cst_0, %3 : f32 + affine.for %arg4 = 0 to 128 { + %5 = affine.load %arg1[%arg4] : memref + %6 = affine.load %arg0[%arg4] : memref + %7 = arith.mulf %4, %6 : f32 + %8 = arith.mulf %5, %7 : f32 + affine.store %8, %arg2[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_rms_norm/debuf.mlir b/issues/aten_c_kernels/results/aten_rms_norm/debuf.mlir new file mode 100644 index 000000000000..a638fcebe6d8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rms_norm/debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rms_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 1.280000e+02 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %3[] : tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %11 = arith.mulf %in, %in : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } -> tensor + %extracted = tensor.extract %4[] : tensor + %5 = arith.divf %extracted, %cst_1 : f32 + %6 = arith.addf %5, %arg3 : f32 + %7 = math.sqrt %6 : f32 + %8 = arith.divf %cst_0, %7 : f32 + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %11 = arith.mulf %8, %in_2 : f32 + %12 = arith.mulf %in, %11 : f32 + linalg.yield %12 : f32 + } -> tensor + %10 = bufferization.to_memref %9 : memref + memref.copy %10, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rms_norm/matched.mlir b/issues/aten_c_kernels/results/aten_rms_norm/matched.mlir new file mode 100644 index 000000000000..5ae20753a57d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rms_norm/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rms_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 1.280000e+02 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %3[] : tensor + %9 = kernel.launch @rmsnorm_f32_tensor(%0, %1, %2) : (tensor, tensor, tensor) -> tensor + %10 = bufferization.to_memref %9 : memref + memref.copy %10, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rms_norm/orig.mlir b/issues/aten_c_kernels/results/aten_rms_norm/orig.mlir new file mode 100644 index 000000000000..c23f1aad1f67 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rms_norm/orig.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rms_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.280000e+02 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_1, %alloca[] : memref + affine.for %arg4 = 0 to 128 { + %5 = affine.load %arg0[%arg4] : memref + %6 = arith.mulf %5, %5 : f32 + %7 = affine.load %alloca[] : memref + %8 = arith.addf %7, %6 : f32 + affine.store %8, %alloca[] : memref + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f32 + %2 = arith.addf %1, %arg3 : f32 + %3 = math.sqrt %2 : f32 + %4 = arith.divf %cst_0, %3 : f32 + affine.for %arg4 = 0 to 128 { + %5 = affine.load %arg1[%arg4] : memref + %6 = affine.load %arg0[%arg4] : memref + %7 = arith.mulf %4, %6 : f32 + %8 = arith.mulf %5, %7 : f32 + affine.store %8, %arg2[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_rms_norm/raised.mlir b/issues/aten_c_kernels/results/aten_rms_norm/raised.mlir new file mode 100644 index 000000000000..26e16542d884 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rms_norm/raised.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rms_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.280000e+02 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_1, %alloca[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %5 = arith.mulf %in, %in : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f32 + %2 = arith.addf %1, %arg3 : f32 + %3 = math.sqrt %2 : f32 + %4 = arith.divf %cst_0, %3 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %4, %in_2 : f32 + %6 = arith.mulf %in, %5 : f32 + linalg.yield %6 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rms_norm_debuf.mlir b/issues/aten_c_kernels/results/aten_rms_norm_debuf.mlir new file mode 100644 index 000000000000..a638fcebe6d8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rms_norm_debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rms_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 1.280000e+02 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %3[] : tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %11 = arith.mulf %in, %in : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } -> tensor + %extracted = tensor.extract %4[] : tensor + %5 = arith.divf %extracted, %cst_1 : f32 + %6 = arith.addf %5, %arg3 : f32 + %7 = math.sqrt %6 : f32 + %8 = arith.divf %cst_0, %7 : f32 + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %11 = arith.mulf %8, %in_2 : f32 + %12 = arith.mulf %in, %11 : f32 + linalg.yield %12 : f32 + } -> tensor + %10 = bufferization.to_memref %9 : memref + memref.copy %10, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rms_norm_linalg.mlir b/issues/aten_c_kernels/results/aten_rms_norm_linalg.mlir new file mode 100644 index 000000000000..26e16542d884 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rms_norm_linalg.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rms_norm(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.280000e+02 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_1, %alloca[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %5 = arith.mulf %in, %in : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst : f32 + %2 = arith.addf %1, %arg3 : f32 + %3 = math.sqrt %2 : f32 + %4 = arith.divf %cst_0, %3 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %5 = arith.mulf %4, %in_2 : f32 + %6 = arith.mulf %in, %5 : f32 + linalg.yield %6 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_round.mlir b/issues/aten_c_kernels/results/aten_round.mlir new file mode 100644 index 000000000000..74a94f4a4c97 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_round.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_round(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @roundf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @roundf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_round/debuf.mlir b/issues/aten_c_kernels/results/aten_round/debuf.mlir new file mode 100644 index 000000000000..211d39ff8938 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_round/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_round(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.round %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @roundf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_round/matched.mlir b/issues/aten_c_kernels/results/aten_round/matched.mlir new file mode 100644 index 000000000000..211d39ff8938 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_round/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_round(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.round %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @roundf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_round/orig.mlir b/issues/aten_c_kernels/results/aten_round/orig.mlir new file mode 100644 index 000000000000..74a94f4a4c97 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_round/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_round(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @roundf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @roundf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_round/raised.mlir b/issues/aten_c_kernels/results/aten_round/raised.mlir new file mode 100644 index 000000000000..87a48dab6919 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_round/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_round(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.round %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @roundf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_round_debuf.mlir b/issues/aten_c_kernels/results/aten_round_debuf.mlir new file mode 100644 index 000000000000..211d39ff8938 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_round_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_round(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.round %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @roundf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_round_decimals.mlir b/issues/aten_c_kernels/results/aten_round_decimals.mlir new file mode 100644 index 000000000000..bc718d7a6c13 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_round_decimals.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_round_decimals(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.mulf %0, %arg1 : f32 + %2 = func.call @roundf(%1) : (f32) -> f32 + %3 = arith.divf %2, %arg1 : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } + func.func private @roundf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_round_decimals/debuf.mlir b/issues/aten_c_kernels/results/aten_round_decimals/debuf.mlir new file mode 100644 index 000000000000..855b4326d6c6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_round_decimals/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_round_decimals(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %arg1 : f32 + %5 = math.round %4 : f32 + %6 = arith.divf %5, %arg1 : f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } + func.func private @roundf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_round_decimals/matched.mlir b/issues/aten_c_kernels/results/aten_round_decimals/matched.mlir new file mode 100644 index 000000000000..855b4326d6c6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_round_decimals/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_round_decimals(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %arg1 : f32 + %5 = math.round %4 : f32 + %6 = arith.divf %5, %arg1 : f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } + func.func private @roundf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_round_decimals/orig.mlir b/issues/aten_c_kernels/results/aten_round_decimals/orig.mlir new file mode 100644 index 000000000000..bc718d7a6c13 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_round_decimals/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_round_decimals(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.mulf %0, %arg1 : f32 + %2 = func.call @roundf(%1) : (f32) -> f32 + %3 = arith.divf %2, %arg1 : f32 + affine.store %3, %arg2[%arg3] : memref + } + return + } + func.func private @roundf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_round_decimals/raised.mlir b/issues/aten_c_kernels/results/aten_round_decimals/raised.mlir new file mode 100644 index 000000000000..02226190cf3a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_round_decimals/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_round_decimals(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %arg1 : f32 + %1 = math.round %0 : f32 + %2 = arith.divf %1, %arg1 : f32 + linalg.yield %2 : f32 + } + return + } + func.func private @roundf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_round_decimals_debuf.mlir b/issues/aten_c_kernels/results/aten_round_decimals_debuf.mlir new file mode 100644 index 000000000000..855b4326d6c6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_round_decimals_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_round_decimals(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %arg1 : f32 + %5 = math.round %4 : f32 + %6 = arith.divf %5, %arg1 : f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg2 : memref to memref + return + } + func.func private @roundf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_round_decimals_linalg.mlir b/issues/aten_c_kernels/results/aten_round_decimals_linalg.mlir new file mode 100644 index 000000000000..02226190cf3a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_round_decimals_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_round_decimals(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %arg1 : f32 + %1 = math.round %0 : f32 + %2 = arith.divf %1, %arg1 : f32 + linalg.yield %2 : f32 + } + return + } + func.func private @roundf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_round_linalg.mlir b/issues/aten_c_kernels/results/aten_round_linalg.mlir new file mode 100644 index 000000000000..87a48dab6919 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_round_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_round(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.round %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @roundf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_rowwise_prune_cpu.mlir b/issues/aten_c_kernels/results/aten_rowwise_prune_cpu.mlir new file mode 100644 index 000000000000..d5df127b0362 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rowwise_prune_cpu.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rowwise_prune_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %0 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %cst) -> (f32) { + %3 = affine.load %arg0[%arg3, %arg4] : memref + %4 = arith.cmpf olt, %3, %cst : f32 + %5 = scf.if %4 -> (f32) { + %7 = arith.negf %3 : f32 + scf.yield %7 : f32 + } else { + scf.yield %3 : f32 + } + %6 = arith.addf %arg5, %5 : f32 + affine.yield %6 : f32 + } + %1 = arith.cmpf ogt, %0, %arg1 : f32 + %2 = arith.extui %1 : i1 to i32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_rowwise_prune_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_rowwise_prune_cpu/debuf.mlir new file mode 100644 index 000000000000..4e3129e561a3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rowwise_prune_cpu/debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rowwise_prune_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = tensor.empty(%c64) : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c32] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c64] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = arith.cmpf olt, %in, %cst : f32 + %8 = arith.negf %in : f32 + %9 = arith.select %7, %8, %in : f32 + %10 = arith.addf %out, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c64] [1] : tensor into tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: i32): + %7 = arith.cmpf ogt, %in, %arg1 : f32 + %8 = arith.extui %7 : i1 to i32 + linalg.yield %8 : i32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rowwise_prune_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_rowwise_prune_cpu/matched.mlir new file mode 100644 index 000000000000..de7d1fa6b2fc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rowwise_prune_cpu/matched.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rowwise_prune_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = tensor.empty(%c64) : tensor + %3 = kernel.launch @memset_zero_1D_f32(%2) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c32] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c64] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = arith.cmpf olt, %in, %cst : f32 + %8 = arith.negf %in : f32 + %9 = arith.select %7, %8, %in : f32 + %10 = arith.addf %out, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c64] [1] : tensor into tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: i32): + %7 = arith.cmpf ogt, %in, %arg1 : f32 + %8 = arith.extui %7 : i1 to i32 + linalg.yield %8 : i32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rowwise_prune_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_rowwise_prune_cpu/orig.mlir new file mode 100644 index 000000000000..d5df127b0362 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rowwise_prune_cpu/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rowwise_prune_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %0 = affine.for %arg4 = 0 to 32 iter_args(%arg5 = %cst) -> (f32) { + %3 = affine.load %arg0[%arg3, %arg4] : memref + %4 = arith.cmpf olt, %3, %cst : f32 + %5 = scf.if %4 -> (f32) { + %7 = arith.negf %3 : f32 + scf.yield %7 : f32 + } else { + scf.yield %3 : f32 + } + %6 = arith.addf %arg5, %5 : f32 + affine.yield %6 : f32 + } + %1 = arith.cmpf ogt, %0, %arg1 : f32 + %2 = arith.extui %1 : i1 to i32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_rowwise_prune_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_rowwise_prune_cpu/raised.mlir new file mode 100644 index 000000000000..35d07b8d0810 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rowwise_prune_cpu/raised.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rowwise_prune_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca(%c64) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c64, %c32] [1, 1] : memref to memref> + %subview_0 = memref.subview %alloca[0] [%c64] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %cst : f32 + %1 = arith.negf %in : f32 + %2 = arith.select %0, %1, %in : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: i32): + %0 = arith.cmpf ogt, %in, %arg1 : f32 + %1 = arith.extui %0 : i1 to i32 + linalg.yield %1 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rowwise_prune_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_rowwise_prune_cpu_debuf.mlir new file mode 100644 index 000000000000..4e3129e561a3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rowwise_prune_cpu_debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rowwise_prune_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = tensor.empty(%c64) : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c32] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c64] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = arith.cmpf olt, %in, %cst : f32 + %8 = arith.negf %in : f32 + %9 = arith.select %7, %8, %in : f32 + %10 = arith.addf %out, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c64] [1] : tensor into tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: i32): + %7 = arith.cmpf ogt, %in, %arg1 : f32 + %8 = arith.extui %7 : i1 to i32 + linalg.yield %8 : i32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rowwise_prune_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_rowwise_prune_cpu_linalg.mlir new file mode 100644 index 000000000000..35d07b8d0810 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rowwise_prune_cpu_linalg.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rowwise_prune_cpu(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca(%c64) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c64, %c32] [1, 1] : memref to memref> + %subview_0 = memref.subview %alloca[0] [%c64] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %cst : f32 + %1 = arith.negf %in : f32 + %2 = arith.select %0, %1, %in : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: i32): + %0 = arith.cmpf ogt, %in, %arg1 : f32 + %1 = arith.extui %0 : i1 to i32 + linalg.yield %1 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rshift_i32.mlir b/issues/aten_c_kernels/results/aten_rshift_i32.mlir new file mode 100644 index 000000000000..e2fe88bc9377 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rshift_i32.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rshift_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.shrsi %0, %1 : i32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_rshift_i32/debuf.mlir b/issues/aten_c_kernels/results/aten_rshift_i32/debuf.mlir new file mode 100644 index 000000000000..1eb07f38d992 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rshift_i32/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rshift_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.shrsi %in, %in_0 : i32 + linalg.yield %5 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rshift_i32/matched.mlir b/issues/aten_c_kernels/results/aten_rshift_i32/matched.mlir new file mode 100644 index 000000000000..1eb07f38d992 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rshift_i32/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rshift_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.shrsi %in, %in_0 : i32 + linalg.yield %5 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rshift_i32/orig.mlir b/issues/aten_c_kernels/results/aten_rshift_i32/orig.mlir new file mode 100644 index 000000000000..e2fe88bc9377 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rshift_i32/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rshift_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.shrsi %0, %1 : i32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_rshift_i32/raised.mlir b/issues/aten_c_kernels/results/aten_rshift_i32/raised.mlir new file mode 100644 index 000000000000..c4ce722c8628 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rshift_i32/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rshift_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %0 = arith.shrsi %in, %in_0 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rshift_i32_debuf.mlir b/issues/aten_c_kernels/results/aten_rshift_i32_debuf.mlir new file mode 100644 index 000000000000..1eb07f38d992 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rshift_i32_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rshift_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.shrsi %in, %in_0 : i32 + linalg.yield %5 : i32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rshift_i32_linalg.mlir b/issues/aten_c_kernels/results/aten_rshift_i32_linalg.mlir new file mode 100644 index 000000000000..c4ce722c8628 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rshift_i32_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rshift_i32(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %0 = arith.shrsi %in, %in_0 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rsqrt.mlir b/issues/aten_c_kernels/results/aten_rsqrt.mlir new file mode 100644 index 000000000000..df69f96a653e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rsqrt.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rsqrt(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = math.sqrt %0 : f32 + %2 = arith.divf %cst, %1 : f32 + affine.store %2, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_rsqrt/debuf.mlir b/issues/aten_c_kernels/results/aten_rsqrt/debuf.mlir new file mode 100644 index 000000000000..618c36407494 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rsqrt/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rsqrt(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.sqrt %in : f32 + %5 = arith.divf %cst, %4 : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rsqrt/matched.mlir b/issues/aten_c_kernels/results/aten_rsqrt/matched.mlir new file mode 100644 index 000000000000..618c36407494 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rsqrt/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rsqrt(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.sqrt %in : f32 + %5 = arith.divf %cst, %4 : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rsqrt/orig.mlir b/issues/aten_c_kernels/results/aten_rsqrt/orig.mlir new file mode 100644 index 000000000000..df69f96a653e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rsqrt/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rsqrt(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = math.sqrt %0 : f32 + %2 = arith.divf %cst, %1 : f32 + affine.store %2, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_rsqrt/raised.mlir b/issues/aten_c_kernels/results/aten_rsqrt/raised.mlir new file mode 100644 index 000000000000..5448f92d9553 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rsqrt/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rsqrt(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.sqrt %in : f32 + %1 = arith.divf %cst, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rsqrt_debuf.mlir b/issues/aten_c_kernels/results/aten_rsqrt_debuf.mlir new file mode 100644 index 000000000000..618c36407494 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rsqrt_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rsqrt(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.sqrt %in : f32 + %5 = arith.divf %cst, %4 : f32 + linalg.yield %5 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_rsqrt_linalg.mlir b/issues/aten_c_kernels/results/aten_rsqrt_linalg.mlir new file mode 100644 index 000000000000..5448f92d9553 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_rsqrt_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_rsqrt(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.sqrt %in : f32 + %1 = arith.divf %cst, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu.mlir b/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu.mlir new file mode 100644 index 000000000000..6173e51977a0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu.mlir @@ -0,0 +1,40 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sample_poisson_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c31_i32 = arith.constant 31 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.negf %0 : f32 + %2 = math.exp %1 : f32 + %3:3 = scf.while (%arg4 = %c0_i32, %arg5 = %2, %arg6 = %2) : (i32, f32, f32) -> (i32, f32, f32) { + %4 = arith.cmpi slt, %arg4, %c31_i32 : i32 + %5:4 = scf.if %4 -> (i1, i32, f32, f32) { + %6 = arith.index_cast %arg4 : i32 to index + %7 = memref.load %arg1[%arg3, %6] : memref + %8 = arith.cmpf ogt, %7, %arg5 : f32 + %9:3 = scf.if %8 -> (i32, f32, f32) { + %10 = arith.addi %arg4, %c1_i32 : i32 + %11 = arith.sitofp %10 : i32 to f32 + %12 = arith.divf %0, %11 : f32 + %13 = arith.mulf %arg6, %12 : f32 + %14 = arith.addf %arg5, %13 : f32 + scf.yield %10, %14, %13 : i32, f32, f32 + } else { + scf.yield %arg4, %arg5, %arg6 : i32, f32, f32 + } + scf.yield %8, %9#0, %9#1, %9#2 : i1, i32, f32, f32 + } else { + scf.yield %false, %arg4, %arg5, %arg6 : i1, i32, f32, f32 + } + scf.condition(%5#0) %5#1, %5#2, %5#3 : i32, f32, f32 + } do { + ^bb0(%arg4: i32, %arg5: f32, %arg6: f32): + scf.yield %arg4, %arg5, %arg6 : i32, f32, f32 + } + affine.store %3#0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu/debuf.mlir new file mode 100644 index 000000000000..1243979fdeb9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu/debuf.mlir @@ -0,0 +1,44 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sample_poisson_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c31_i32 = arith.constant 31 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %0) -> (tensor) { + %extracted = tensor.extract %2[%arg3] : tensor + %5 = arith.negf %extracted : f32 + %6 = math.exp %5 : f32 + %7:3 = scf.while (%arg5 = %c0_i32, %arg6 = %6, %arg7 = %6) : (i32, f32, f32) -> (i32, f32, f32) { + %8 = arith.cmpi slt, %arg5, %c31_i32 : i32 + %9 = arith.index_cast %arg5 : i32 to index + %extracted_0 = tensor.extract %1[%arg3, %9] : tensor + %10 = arith.cmpf ogt, %extracted_0, %arg6 : f32 + %11 = arith.addi %arg5, %c1_i32 : i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.divf %extracted, %12 : f32 + %14 = arith.mulf %arg7, %13 : f32 + %15 = arith.addf %arg6, %14 : f32 + %16 = arith.select %10, %11, %arg5 : i32 + %17 = arith.select %10, %15, %arg6 : f32 + %18 = arith.select %10, %14, %arg7 : f32 + %19 = arith.select %8, %10, %false : i1 + %20 = arith.select %8, %16, %arg5 : i32 + %21 = arith.select %8, %17, %arg6 : f32 + %22 = arith.select %8, %18, %arg7 : f32 + scf.condition(%19) %20, %21, %22 : i32, f32, f32 + } do { + ^bb0(%arg5: i32, %arg6: f32, %arg7: f32): + scf.yield %arg5, %arg6, %arg7 : i32, f32, f32 + } + %inserted = tensor.insert %7#0 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu/matched.mlir new file mode 100644 index 000000000000..1243979fdeb9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu/matched.mlir @@ -0,0 +1,44 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sample_poisson_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c31_i32 = arith.constant 31 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %0) -> (tensor) { + %extracted = tensor.extract %2[%arg3] : tensor + %5 = arith.negf %extracted : f32 + %6 = math.exp %5 : f32 + %7:3 = scf.while (%arg5 = %c0_i32, %arg6 = %6, %arg7 = %6) : (i32, f32, f32) -> (i32, f32, f32) { + %8 = arith.cmpi slt, %arg5, %c31_i32 : i32 + %9 = arith.index_cast %arg5 : i32 to index + %extracted_0 = tensor.extract %1[%arg3, %9] : tensor + %10 = arith.cmpf ogt, %extracted_0, %arg6 : f32 + %11 = arith.addi %arg5, %c1_i32 : i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.divf %extracted, %12 : f32 + %14 = arith.mulf %arg7, %13 : f32 + %15 = arith.addf %arg6, %14 : f32 + %16 = arith.select %10, %11, %arg5 : i32 + %17 = arith.select %10, %15, %arg6 : f32 + %18 = arith.select %10, %14, %arg7 : f32 + %19 = arith.select %8, %10, %false : i1 + %20 = arith.select %8, %16, %arg5 : i32 + %21 = arith.select %8, %17, %arg6 : f32 + %22 = arith.select %8, %18, %arg7 : f32 + scf.condition(%19) %20, %21, %22 : i32, f32, f32 + } do { + ^bb0(%arg5: i32, %arg6: f32, %arg7: f32): + scf.yield %arg5, %arg6, %arg7 : i32, f32, f32 + } + %inserted = tensor.insert %7#0 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu/orig.mlir new file mode 100644 index 000000000000..6173e51977a0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu/orig.mlir @@ -0,0 +1,40 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sample_poisson_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c31_i32 = arith.constant 31 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.negf %0 : f32 + %2 = math.exp %1 : f32 + %3:3 = scf.while (%arg4 = %c0_i32, %arg5 = %2, %arg6 = %2) : (i32, f32, f32) -> (i32, f32, f32) { + %4 = arith.cmpi slt, %arg4, %c31_i32 : i32 + %5:4 = scf.if %4 -> (i1, i32, f32, f32) { + %6 = arith.index_cast %arg4 : i32 to index + %7 = memref.load %arg1[%arg3, %6] : memref + %8 = arith.cmpf ogt, %7, %arg5 : f32 + %9:3 = scf.if %8 -> (i32, f32, f32) { + %10 = arith.addi %arg4, %c1_i32 : i32 + %11 = arith.sitofp %10 : i32 to f32 + %12 = arith.divf %0, %11 : f32 + %13 = arith.mulf %arg6, %12 : f32 + %14 = arith.addf %arg5, %13 : f32 + scf.yield %10, %14, %13 : i32, f32, f32 + } else { + scf.yield %arg4, %arg5, %arg6 : i32, f32, f32 + } + scf.yield %8, %9#0, %9#1, %9#2 : i1, i32, f32, f32 + } else { + scf.yield %false, %arg4, %arg5, %arg6 : i1, i32, f32, f32 + } + scf.condition(%5#0) %5#1, %5#2, %5#3 : i32, f32, f32 + } do { + ^bb0(%arg4: i32, %arg5: f32, %arg6: f32): + scf.yield %arg4, %arg5, %arg6 : i32, f32, f32 + } + affine.store %3#0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu/raised.mlir new file mode 100644 index 000000000000..c6f3200f6d6f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu/raised.mlir @@ -0,0 +1,38 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sample_poisson_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c31_i32 = arith.constant 31 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.negf %0 : f32 + %2 = math.exp %1 : f32 + %3:3 = scf.while (%arg4 = %c0_i32, %arg5 = %2, %arg6 = %2) : (i32, f32, f32) -> (i32, f32, f32) { + %4 = arith.cmpi slt, %arg4, %c31_i32 : i32 + %5 = arith.index_cast %arg4 : i32 to index + %6 = memref.load %arg1[%arg3, %5] : memref + %7 = arith.cmpf ogt, %6, %arg5 : f32 + %8 = arith.addi %arg4, %c1_i32 : i32 + %9 = arith.sitofp %8 : i32 to f32 + %10 = arith.divf %0, %9 : f32 + %11 = arith.mulf %arg6, %10 : f32 + %12 = arith.addf %arg5, %11 : f32 + %13 = arith.select %7, %8, %arg4 : i32 + %14 = arith.select %7, %12, %arg5 : f32 + %15 = arith.select %7, %11, %arg6 : f32 + %16 = arith.select %4, %7, %false : i1 + %17 = arith.select %4, %13, %arg4 : i32 + %18 = arith.select %4, %14, %arg5 : f32 + %19 = arith.select %4, %15, %arg6 : f32 + scf.condition(%16) %17, %18, %19 : i32, f32, f32 + } do { + ^bb0(%arg4: i32, %arg5: f32, %arg6: f32): + scf.yield %arg4, %arg5, %arg6 : i32, f32, f32 + } + affine.store %3#0, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu_debuf.mlir new file mode 100644 index 000000000000..1243979fdeb9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu_debuf.mlir @@ -0,0 +1,44 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sample_poisson_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c31_i32 = arith.constant 31 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %0) -> (tensor) { + %extracted = tensor.extract %2[%arg3] : tensor + %5 = arith.negf %extracted : f32 + %6 = math.exp %5 : f32 + %7:3 = scf.while (%arg5 = %c0_i32, %arg6 = %6, %arg7 = %6) : (i32, f32, f32) -> (i32, f32, f32) { + %8 = arith.cmpi slt, %arg5, %c31_i32 : i32 + %9 = arith.index_cast %arg5 : i32 to index + %extracted_0 = tensor.extract %1[%arg3, %9] : tensor + %10 = arith.cmpf ogt, %extracted_0, %arg6 : f32 + %11 = arith.addi %arg5, %c1_i32 : i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.divf %extracted, %12 : f32 + %14 = arith.mulf %arg7, %13 : f32 + %15 = arith.addf %arg6, %14 : f32 + %16 = arith.select %10, %11, %arg5 : i32 + %17 = arith.select %10, %15, %arg6 : f32 + %18 = arith.select %10, %14, %arg7 : f32 + %19 = arith.select %8, %10, %false : i1 + %20 = arith.select %8, %16, %arg5 : i32 + %21 = arith.select %8, %17, %arg6 : f32 + %22 = arith.select %8, %18, %arg7 : f32 + scf.condition(%19) %20, %21, %22 : i32, f32, f32 + } do { + ^bb0(%arg5: i32, %arg6: f32, %arg7: f32): + scf.yield %arg5, %arg6, %arg7 : i32, f32, f32 + } + %inserted = tensor.insert %7#0 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu_linalg.mlir new file mode 100644 index 000000000000..c6f3200f6d6f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sample_poisson_transform_cpu_linalg.mlir @@ -0,0 +1,38 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sample_poisson_transform_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c31_i32 = arith.constant 31 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.negf %0 : f32 + %2 = math.exp %1 : f32 + %3:3 = scf.while (%arg4 = %c0_i32, %arg5 = %2, %arg6 = %2) : (i32, f32, f32) -> (i32, f32, f32) { + %4 = arith.cmpi slt, %arg4, %c31_i32 : i32 + %5 = arith.index_cast %arg4 : i32 to index + %6 = memref.load %arg1[%arg3, %5] : memref + %7 = arith.cmpf ogt, %6, %arg5 : f32 + %8 = arith.addi %arg4, %c1_i32 : i32 + %9 = arith.sitofp %8 : i32 to f32 + %10 = arith.divf %0, %9 : f32 + %11 = arith.mulf %arg6, %10 : f32 + %12 = arith.addf %arg5, %11 : f32 + %13 = arith.select %7, %8, %arg4 : i32 + %14 = arith.select %7, %12, %arg5 : f32 + %15 = arith.select %7, %11, %arg6 : f32 + %16 = arith.select %4, %7, %false : i1 + %17 = arith.select %4, %13, %arg4 : i32 + %18 = arith.select %4, %14, %arg5 : f32 + %19 = arith.select %4, %15, %arg6 : f32 + scf.condition(%16) %17, %18, %19 : i32, f32, f32 + } do { + ^bb0(%arg4: i32, %arg5: f32, %arg6: f32): + scf.yield %arg4, %arg5, %arg6 : i32, f32, f32 + } + affine.store %3#0, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu.mlir b/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu.mlir new file mode 100644 index 000000000000..d0a031d3bc72 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sampled_addmm_sparse_csr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: f32, %arg6: f32, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + affine.for %arg8 = 0 to 16 { + %0 = affine.load %arg0[%arg8] : memref + %1 = scf.while (%arg9 = %0) : (i32) -> i32 { + %2 = affine.load %arg0[%arg8 + 1] : memref + %3 = arith.cmpi slt, %arg9, %2 : i32 + scf.condition(%3) %arg9 : i32 + } do { + ^bb0(%arg9: i32): + %2 = arith.index_cast %arg9 : i32 to index + %3 = memref.load %arg1[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = affine.for %arg10 = 0 to 32 iter_args(%arg11 = %cst) -> (f32) { + %11 = affine.load %arg3[%arg8, %arg10] : memref + %12 = memref.load %arg4[%arg10, %4] : memref + %13 = arith.mulf %11, %12 : f32 + %14 = arith.addf %arg11, %13 : f32 + affine.yield %14 : f32 + } + %6 = memref.load %arg2[%2] : memref + %7 = arith.mulf %arg6, %6 : f32 + %8 = arith.mulf %arg5, %5 : f32 + %9 = arith.addf %7, %8 : f32 + memref.store %9, %arg7[%2] : memref + %10 = arith.addi %arg9, %c1_i32 : i32 + scf.yield %10 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu/debuf.mlir new file mode 100644 index 000000000000..77207c417967 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu/debuf.mlir @@ -0,0 +1,55 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sampled_addmm_sparse_csr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: f32, %arg6: f32, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg7 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %0) -> (tensor) { + %extracted = tensor.extract %3[%arg8] : tensor + %6:2 = scf.while (%arg10 = %extracted, %arg11 = %arg9) : (i32, tensor) -> (i32, tensor) { + %7 = affine.apply #map(%arg8) + %extracted_0 = tensor.extract %3[%7] : tensor + %8 = arith.cmpi slt, %arg10, %extracted_0 : i32 + scf.condition(%8) %arg10, %arg11 : i32, tensor + } do { + ^bb0(%arg10: i32, %arg11: tensor): + %7 = arith.index_cast %arg10 : i32 to index + %extracted_0 = tensor.extract %2[%7] : tensor + %8 = arith.index_cast %extracted_0 : i32 to index + %alloca = memref.alloca() : memref + %9 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %9[] : tensor + %10 = polygeist.submap(%inserted, %c32) {map = #map1} : (tensor, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction"], library_call = ""} outs(%10 : tensor) { + ^bb0(%out: f32): + %17 = linalg.index 0 : index + %18 = memref.load %arg3[%arg8, %17] : memref + %19 = memref.load %arg4[%17, %8] : memref + %20 = arith.mulf %18, %19 : f32 + %21 = arith.addf %out, %20 : f32 + linalg.yield %21 : f32 + } -> tensor + %12 = polygeist.submapInverse(%inserted, %11, %c32) {map = #map1} : (tensor, tensor, index) -> tensor + %extracted_1 = tensor.extract %12[] : tensor + %extracted_2 = tensor.extract %1[%7] : tensor + %13 = arith.mulf %arg6, %extracted_2 : f32 + %14 = arith.mulf %arg5, %extracted_1 : f32 + %15 = arith.addf %13, %14 : f32 + %inserted_3 = tensor.insert %15 into %arg11[%7] : tensor + %16 = arith.addi %arg10, %c1_i32 : i32 + scf.yield %16, %inserted_3 : i32, tensor + } + affine.yield %6#1 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg7 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu/matched.mlir new file mode 100644 index 000000000000..77207c417967 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu/matched.mlir @@ -0,0 +1,55 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sampled_addmm_sparse_csr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: f32, %arg6: f32, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg7 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %0) -> (tensor) { + %extracted = tensor.extract %3[%arg8] : tensor + %6:2 = scf.while (%arg10 = %extracted, %arg11 = %arg9) : (i32, tensor) -> (i32, tensor) { + %7 = affine.apply #map(%arg8) + %extracted_0 = tensor.extract %3[%7] : tensor + %8 = arith.cmpi slt, %arg10, %extracted_0 : i32 + scf.condition(%8) %arg10, %arg11 : i32, tensor + } do { + ^bb0(%arg10: i32, %arg11: tensor): + %7 = arith.index_cast %arg10 : i32 to index + %extracted_0 = tensor.extract %2[%7] : tensor + %8 = arith.index_cast %extracted_0 : i32 to index + %alloca = memref.alloca() : memref + %9 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %9[] : tensor + %10 = polygeist.submap(%inserted, %c32) {map = #map1} : (tensor, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction"], library_call = ""} outs(%10 : tensor) { + ^bb0(%out: f32): + %17 = linalg.index 0 : index + %18 = memref.load %arg3[%arg8, %17] : memref + %19 = memref.load %arg4[%17, %8] : memref + %20 = arith.mulf %18, %19 : f32 + %21 = arith.addf %out, %20 : f32 + linalg.yield %21 : f32 + } -> tensor + %12 = polygeist.submapInverse(%inserted, %11, %c32) {map = #map1} : (tensor, tensor, index) -> tensor + %extracted_1 = tensor.extract %12[] : tensor + %extracted_2 = tensor.extract %1[%7] : tensor + %13 = arith.mulf %arg6, %extracted_2 : f32 + %14 = arith.mulf %arg5, %extracted_1 : f32 + %15 = arith.addf %13, %14 : f32 + %inserted_3 = tensor.insert %15 into %arg11[%7] : tensor + %16 = arith.addi %arg10, %c1_i32 : i32 + scf.yield %16, %inserted_3 : i32, tensor + } + affine.yield %6#1 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg7 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu/orig.mlir new file mode 100644 index 000000000000..d0a031d3bc72 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu/orig.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sampled_addmm_sparse_csr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: f32, %arg6: f32, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + affine.for %arg8 = 0 to 16 { + %0 = affine.load %arg0[%arg8] : memref + %1 = scf.while (%arg9 = %0) : (i32) -> i32 { + %2 = affine.load %arg0[%arg8 + 1] : memref + %3 = arith.cmpi slt, %arg9, %2 : i32 + scf.condition(%3) %arg9 : i32 + } do { + ^bb0(%arg9: i32): + %2 = arith.index_cast %arg9 : i32 to index + %3 = memref.load %arg1[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = affine.for %arg10 = 0 to 32 iter_args(%arg11 = %cst) -> (f32) { + %11 = affine.load %arg3[%arg8, %arg10] : memref + %12 = memref.load %arg4[%arg10, %4] : memref + %13 = arith.mulf %11, %12 : f32 + %14 = arith.addf %arg11, %13 : f32 + affine.yield %14 : f32 + } + %6 = memref.load %arg2[%2] : memref + %7 = arith.mulf %arg6, %6 : f32 + %8 = arith.mulf %arg5, %5 : f32 + %9 = arith.addf %7, %8 : f32 + memref.store %9, %arg7[%2] : memref + %10 = arith.addi %arg9, %c1_i32 : i32 + scf.yield %10 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu/raised.mlir new file mode 100644 index 000000000000..2b3ba2f9736a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu/raised.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> ()> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sampled_addmm_sparse_csr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: f32, %arg6: f32, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + affine.for %arg8 = 0 to 16 { + %0 = affine.load %arg0[%arg8] : memref + %1 = scf.while (%arg9 = %0) : (i32) -> i32 { + %2 = affine.load %arg0[%arg8 + 1] : memref + %3 = arith.cmpi slt, %arg9, %2 : i32 + scf.condition(%3) %arg9 : i32 + } do { + ^bb0(%arg9: i32): + %2 = arith.index_cast %arg9 : i32 to index + %3 = memref.load %arg1[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %5 = polygeist.submap(%alloca, %c32) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction"]} outs(%5 : memref) { + ^bb0(%out: f32): + %12 = linalg.index 0 : index + %13 = memref.load %arg3[%arg8, %12] : memref + %14 = memref.load %arg4[%12, %4] : memref + %15 = arith.mulf %13, %14 : f32 + %16 = arith.addf %out, %15 : f32 + linalg.yield %16 : f32 + } + %6 = affine.load %alloca[] : memref + %7 = memref.load %arg2[%2] : memref + %8 = arith.mulf %arg6, %7 : f32 + %9 = arith.mulf %arg5, %6 : f32 + %10 = arith.addf %8, %9 : f32 + memref.store %10, %arg7[%2] : memref + %11 = arith.addi %arg9, %c1_i32 : i32 + scf.yield %11 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu_debuf.mlir new file mode 100644 index 000000000000..77207c417967 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu_debuf.mlir @@ -0,0 +1,55 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sampled_addmm_sparse_csr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: f32, %arg6: f32, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg7 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = affine.for %arg8 = 0 to 16 iter_args(%arg9 = %0) -> (tensor) { + %extracted = tensor.extract %3[%arg8] : tensor + %6:2 = scf.while (%arg10 = %extracted, %arg11 = %arg9) : (i32, tensor) -> (i32, tensor) { + %7 = affine.apply #map(%arg8) + %extracted_0 = tensor.extract %3[%7] : tensor + %8 = arith.cmpi slt, %arg10, %extracted_0 : i32 + scf.condition(%8) %arg10, %arg11 : i32, tensor + } do { + ^bb0(%arg10: i32, %arg11: tensor): + %7 = arith.index_cast %arg10 : i32 to index + %extracted_0 = tensor.extract %2[%7] : tensor + %8 = arith.index_cast %extracted_0 : i32 to index + %alloca = memref.alloca() : memref + %9 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %9[] : tensor + %10 = polygeist.submap(%inserted, %c32) {map = #map1} : (tensor, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction"], library_call = ""} outs(%10 : tensor) { + ^bb0(%out: f32): + %17 = linalg.index 0 : index + %18 = memref.load %arg3[%arg8, %17] : memref + %19 = memref.load %arg4[%17, %8] : memref + %20 = arith.mulf %18, %19 : f32 + %21 = arith.addf %out, %20 : f32 + linalg.yield %21 : f32 + } -> tensor + %12 = polygeist.submapInverse(%inserted, %11, %c32) {map = #map1} : (tensor, tensor, index) -> tensor + %extracted_1 = tensor.extract %12[] : tensor + %extracted_2 = tensor.extract %1[%7] : tensor + %13 = arith.mulf %arg6, %extracted_2 : f32 + %14 = arith.mulf %arg5, %extracted_1 : f32 + %15 = arith.addf %13, %14 : f32 + %inserted_3 = tensor.insert %15 into %arg11[%7] : tensor + %16 = arith.addi %arg10, %c1_i32 : i32 + scf.yield %16, %inserted_3 : i32, tensor + } + affine.yield %6#1 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg7 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu_linalg.mlir new file mode 100644 index 000000000000..2b3ba2f9736a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sampled_addmm_sparse_csr_cpu_linalg.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> ()> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sampled_addmm_sparse_csr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: f32, %arg6: f32, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + affine.for %arg8 = 0 to 16 { + %0 = affine.load %arg0[%arg8] : memref + %1 = scf.while (%arg9 = %0) : (i32) -> i32 { + %2 = affine.load %arg0[%arg8 + 1] : memref + %3 = arith.cmpi slt, %arg9, %2 : i32 + scf.condition(%3) %arg9 : i32 + } do { + ^bb0(%arg9: i32): + %2 = arith.index_cast %arg9 : i32 to index + %3 = memref.load %arg1[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %5 = polygeist.submap(%alloca, %c32) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction"]} outs(%5 : memref) { + ^bb0(%out: f32): + %12 = linalg.index 0 : index + %13 = memref.load %arg3[%arg8, %12] : memref + %14 = memref.load %arg4[%12, %4] : memref + %15 = arith.mulf %13, %14 : f32 + %16 = arith.addf %out, %15 : f32 + linalg.yield %16 : f32 + } + %6 = affine.load %alloca[] : memref + %7 = memref.load %arg2[%2] : memref + %8 = arith.mulf %arg6, %7 : f32 + %9 = arith.mulf %arg5, %6 : f32 + %10 = arith.addf %8, %9 : f32 + memref.store %10, %arg7[%2] : memref + %11 = arith.addi %arg9, %c1_i32 : i32 + scf.yield %11 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0.mlir b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0.mlir new file mode 100644 index 000000000000..d190c26c4a68 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scaled_modified_bessel_k0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_scaled_bessel_k0f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_scaled_bessel_k0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0/debuf.mlir b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0/debuf.mlir new file mode 100644 index 000000000000..2633cfcc0d63 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scaled_modified_bessel_k0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_scaled_bessel_k0f(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_scaled_bessel_k0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0/matched.mlir b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0/matched.mlir new file mode 100644 index 000000000000..2633cfcc0d63 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scaled_modified_bessel_k0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_scaled_bessel_k0f(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_scaled_bessel_k0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0/orig.mlir b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0/orig.mlir new file mode 100644 index 000000000000..d190c26c4a68 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scaled_modified_bessel_k0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_scaled_bessel_k0f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_scaled_bessel_k0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0/raised.mlir b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0/raised.mlir new file mode 100644 index 000000000000..74a5cbd37450 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scaled_modified_bessel_k0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_scaled_bessel_k0f(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_scaled_bessel_k0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0_debuf.mlir b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0_debuf.mlir new file mode 100644 index 000000000000..2633cfcc0d63 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scaled_modified_bessel_k0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_scaled_bessel_k0f(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_scaled_bessel_k0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0_linalg.mlir b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0_linalg.mlir new file mode 100644 index 000000000000..74a5cbd37450 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k0_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scaled_modified_bessel_k0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_scaled_bessel_k0f(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_scaled_bessel_k0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1.mlir b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1.mlir new file mode 100644 index 000000000000..e9872aed914b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scaled_modified_bessel_k1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_scaled_bessel_k1f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_scaled_bessel_k1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1/debuf.mlir b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1/debuf.mlir new file mode 100644 index 000000000000..baa4170d9d0f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scaled_modified_bessel_k1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_scaled_bessel_k1f(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_scaled_bessel_k1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1/matched.mlir b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1/matched.mlir new file mode 100644 index 000000000000..baa4170d9d0f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scaled_modified_bessel_k1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_scaled_bessel_k1f(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_scaled_bessel_k1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1/orig.mlir b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1/orig.mlir new file mode 100644 index 000000000000..e9872aed914b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scaled_modified_bessel_k1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_scaled_bessel_k1f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_scaled_bessel_k1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1/raised.mlir b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1/raised.mlir new file mode 100644 index 000000000000..336ec8aa34c8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scaled_modified_bessel_k1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_scaled_bessel_k1f(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_scaled_bessel_k1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1_debuf.mlir b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1_debuf.mlir new file mode 100644 index 000000000000..baa4170d9d0f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scaled_modified_bessel_k1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_scaled_bessel_k1f(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_scaled_bessel_k1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1_linalg.mlir b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1_linalg.mlir new file mode 100644 index 000000000000..336ec8aa34c8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scaled_modified_bessel_k1_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scaled_modified_bessel_k1(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_scaled_bessel_k1f(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_scaled_bessel_k1f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_add_cpu.mlir b/issues/aten_c_kernels/results/aten_scatter_add_cpu.mlir new file mode 100644 index 000000000000..82a33e9ceb68 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_add_cpu.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_add_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + %3 = memref.load %arg0[%arg3, %1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg0[%arg3, %1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_scatter_add_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_scatter_add_cpu/debuf.mlir new file mode 100644 index 000000000000..2c60ec5a4f24 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_add_cpu/debuf.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_add_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3, %arg5] : tensor + %extracted_1 = tensor.extract %arg6[%arg3, %6] : tensor + %7 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %7 into %arg6[%arg3, %6] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_add_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_scatter_add_cpu/matched.mlir new file mode 100644 index 000000000000..2c60ec5a4f24 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_add_cpu/matched.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_add_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3, %arg5] : tensor + %extracted_1 = tensor.extract %arg6[%arg3, %6] : tensor + %7 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %7 into %arg6[%arg3, %6] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_add_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_scatter_add_cpu/orig.mlir new file mode 100644 index 000000000000..82a33e9ceb68 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_add_cpu/orig.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_add_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + %3 = memref.load %arg0[%arg3, %1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg0[%arg3, %1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_scatter_add_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_scatter_add_cpu/raised.mlir new file mode 100644 index 000000000000..2dc14c0e3b3b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_add_cpu/raised.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_add_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + %3 = memref.load %arg0[%arg3, %1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg0[%arg3, %1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_add_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_scatter_add_cpu_debuf.mlir new file mode 100644 index 000000000000..2c60ec5a4f24 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_add_cpu_debuf.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_add_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3, %arg5] : tensor + %extracted_1 = tensor.extract %arg6[%arg3, %6] : tensor + %7 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %7 into %arg6[%arg3, %6] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_add_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_scatter_add_cpu_linalg.mlir new file mode 100644 index 000000000000..2dc14c0e3b3b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_add_cpu_linalg.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_add_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + %3 = memref.load %arg0[%arg3, %1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg0[%arg3, %1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu.mlir b/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu.mlir new file mode 100644 index 000000000000..9dfad5f9774f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_add_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + %3 = memref.load %arg0[%arg3, %1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg0[%arg3, %1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu/debuf.mlir new file mode 100644 index 000000000000..7606367de558 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu/debuf.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_add_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3, %arg5] : tensor + %extracted_1 = tensor.extract %arg6[%arg3, %6] : tensor + %7 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %7 into %arg6[%arg3, %6] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu/matched.mlir new file mode 100644 index 000000000000..7606367de558 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu/matched.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_add_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3, %arg5] : tensor + %extracted_1 = tensor.extract %arg6[%arg3, %6] : tensor + %7 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %7 into %arg6[%arg3, %6] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu/orig.mlir new file mode 100644 index 000000000000..9dfad5f9774f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu/orig.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_add_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + %3 = memref.load %arg0[%arg3, %1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg0[%arg3, %1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu/raised.mlir new file mode 100644 index 000000000000..500bc7cde7a4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu/raised.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_add_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + %3 = memref.load %arg0[%arg3, %1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg0[%arg3, %1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu_debuf.mlir new file mode 100644 index 000000000000..7606367de558 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu_debuf.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_add_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3, %arg5] : tensor + %extracted_1 = tensor.extract %arg6[%arg3, %6] : tensor + %7 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %7 into %arg6[%arg3, %6] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu_linalg.mlir new file mode 100644 index 000000000000..500bc7cde7a4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_add_expanded_index_cpu_linalg.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_add_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + %3 = memref.load %arg0[%arg3, %1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg0[%arg3, %1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_cpu.mlir b/issues/aten_c_kernels/results/aten_scatter_cpu.mlir new file mode 100644 index 000000000000..de1a5cf436a8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + memref.store %2, %arg0[%arg3, %1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_scatter_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_scatter_cpu/debuf.mlir new file mode 100644 index 000000000000..319721eef5c8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_cpu/debuf.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3, %arg5] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%arg3, %6] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_scatter_cpu/matched.mlir new file mode 100644 index 000000000000..319721eef5c8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_cpu/matched.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3, %arg5] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%arg3, %6] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_scatter_cpu/orig.mlir new file mode 100644 index 000000000000..de1a5cf436a8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + memref.store %2, %arg0[%arg3, %1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_scatter_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_scatter_cpu/raised.mlir new file mode 100644 index 000000000000..f9cf07821900 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_cpu/raised.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + memref.store %2, %arg0[%arg3, %1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_scatter_cpu_debuf.mlir new file mode 100644 index 000000000000..319721eef5c8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_cpu_debuf.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3, %arg5] : tensor + %inserted = tensor.insert %extracted_0 into %arg6[%arg3, %6] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_scatter_cpu_linalg.mlir new file mode 100644 index 000000000000..f9cf07821900 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_cpu_linalg.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + memref.store %2, %arg0[%arg3, %1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_fill_cpu.mlir b/issues/aten_c_kernels/results/aten_scatter_fill_cpu.mlir new file mode 100644 index 000000000000..9d0031d1b43d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_fill_cpu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + memref.store %arg2, %arg0[%arg3, %1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_scatter_fill_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_scatter_fill_cpu/debuf.mlir new file mode 100644 index 000000000000..8c34a2e6581e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_fill_cpu/debuf.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %1) -> (tensor) { + %4 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %0[%arg3, %arg5] : tensor + %5 = arith.index_cast %extracted : i32 to index + %inserted = tensor.insert %arg2 into %arg6[%arg3, %5] : tensor + affine.yield %inserted : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_fill_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_scatter_fill_cpu/matched.mlir new file mode 100644 index 000000000000..8c34a2e6581e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_fill_cpu/matched.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %1) -> (tensor) { + %4 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %0[%arg3, %arg5] : tensor + %5 = arith.index_cast %extracted : i32 to index + %inserted = tensor.insert %arg2 into %arg6[%arg3, %5] : tensor + affine.yield %inserted : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_fill_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_scatter_fill_cpu/orig.mlir new file mode 100644 index 000000000000..9d0031d1b43d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_fill_cpu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + memref.store %arg2, %arg0[%arg3, %1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_scatter_fill_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_scatter_fill_cpu/raised.mlir new file mode 100644 index 000000000000..c84880c7e97a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_fill_cpu/raised.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + memref.store %arg2, %arg0[%arg3, %1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_fill_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_scatter_fill_cpu_debuf.mlir new file mode 100644 index 000000000000..8c34a2e6581e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_fill_cpu_debuf.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %1) -> (tensor) { + %4 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %0[%arg3, %arg5] : tensor + %5 = arith.index_cast %extracted : i32 to index + %inserted = tensor.insert %arg2 into %arg6[%arg3, %5] : tensor + affine.yield %inserted : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_fill_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_scatter_fill_cpu_linalg.mlir new file mode 100644 index 000000000000..c84880c7e97a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_fill_cpu_linalg.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_fill_cpu(%arg0: memref, %arg1: memref, %arg2: f32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + memref.store %arg2, %arg0[%arg3, %1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_cpu.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_cpu.mlir new file mode 100644 index 000000000000..4079afe75be4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_cpu.mlir @@ -0,0 +1,52 @@ +#set = affine_set<()[s0] : (s0 == 0)> +#set1 = affine_set<()[s0] : (s0 - 1 == 0)> +#set2 = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg3 : i32 to index + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 64 { + %1 = affine.load %arg1[%arg4, %arg5] : memref + %2 = affine.load %arg2[%arg4, %arg5] : memref + affine.if #set()[%0] { + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.addf %4, %2 : f32 + memref.store %5, %arg0[%arg4, %3] : memref + } else { + affine.if #set1()[%0] { + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.mulf %4, %2 : f32 + memref.store %5, %arg0[%arg4, %3] : memref + } else { + affine.if #set2()[%0] { + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.cmpf ogt, %4, %2 : f32 + %6 = scf.if %5 -> (f32) { + %7 = memref.load %arg0[%arg4, %3] : memref + scf.yield %7 : f32 + } else { + scf.yield %2 : f32 + } + memref.store %6, %arg0[%arg4, %3] : memref + } else { + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.cmpf olt, %4, %2 : f32 + %6 = scf.if %5 -> (f32) { + %7 = memref.load %arg0[%arg4, %3] : memref + scf.yield %7 : f32 + } else { + scf.yield %2 : f32 + } + memref.store %6, %arg0[%arg4, %3] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_cpu/debuf.mlir new file mode 100644 index 000000000000..446c4e42bc51 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_cpu/debuf.mlir @@ -0,0 +1,47 @@ +#set = affine_set<()[s0] : (s0 == 0)> +#set1 = affine_set<()[s0] : (s0 - 1 == 0)> +#set2 = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = arith.index_cast %arg3 : i32 to index + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 64 { + %extracted = tensor.extract %1[%arg4, %arg5] : tensor + %extracted_0 = tensor.extract %0[%arg4, %arg5] : tensor + affine.if #set()[%2] { + %3 = arith.index_cast %extracted : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.addf %4, %extracted_0 : f32 + memref.store %5, %arg0[%arg4, %3] : memref + } else { + affine.if #set1()[%2] { + %3 = arith.index_cast %extracted : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.mulf %4, %extracted_0 : f32 + memref.store %5, %arg0[%arg4, %3] : memref + } else { + affine.if #set2()[%2] { + %3 = arith.index_cast %extracted : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.cmpf ogt, %4, %extracted_0 : f32 + %6 = memref.load %arg0[%arg4, %3] : memref + %7 = arith.select %5, %6, %extracted_0 : f32 + memref.store %7, %arg0[%arg4, %3] : memref + } else { + %3 = arith.index_cast %extracted : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.cmpf olt, %4, %extracted_0 : f32 + %6 = memref.load %arg0[%arg4, %3] : memref + %7 = arith.select %5, %6, %extracted_0 : f32 + memref.store %7, %arg0[%arg4, %3] : memref + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_cpu/matched.mlir new file mode 100644 index 000000000000..446c4e42bc51 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_cpu/matched.mlir @@ -0,0 +1,47 @@ +#set = affine_set<()[s0] : (s0 == 0)> +#set1 = affine_set<()[s0] : (s0 - 1 == 0)> +#set2 = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = arith.index_cast %arg3 : i32 to index + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 64 { + %extracted = tensor.extract %1[%arg4, %arg5] : tensor + %extracted_0 = tensor.extract %0[%arg4, %arg5] : tensor + affine.if #set()[%2] { + %3 = arith.index_cast %extracted : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.addf %4, %extracted_0 : f32 + memref.store %5, %arg0[%arg4, %3] : memref + } else { + affine.if #set1()[%2] { + %3 = arith.index_cast %extracted : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.mulf %4, %extracted_0 : f32 + memref.store %5, %arg0[%arg4, %3] : memref + } else { + affine.if #set2()[%2] { + %3 = arith.index_cast %extracted : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.cmpf ogt, %4, %extracted_0 : f32 + %6 = memref.load %arg0[%arg4, %3] : memref + %7 = arith.select %5, %6, %extracted_0 : f32 + memref.store %7, %arg0[%arg4, %3] : memref + } else { + %3 = arith.index_cast %extracted : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.cmpf olt, %4, %extracted_0 : f32 + %6 = memref.load %arg0[%arg4, %3] : memref + %7 = arith.select %5, %6, %extracted_0 : f32 + memref.store %7, %arg0[%arg4, %3] : memref + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_cpu/orig.mlir new file mode 100644 index 000000000000..4079afe75be4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_cpu/orig.mlir @@ -0,0 +1,52 @@ +#set = affine_set<()[s0] : (s0 == 0)> +#set1 = affine_set<()[s0] : (s0 - 1 == 0)> +#set2 = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg3 : i32 to index + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 64 { + %1 = affine.load %arg1[%arg4, %arg5] : memref + %2 = affine.load %arg2[%arg4, %arg5] : memref + affine.if #set()[%0] { + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.addf %4, %2 : f32 + memref.store %5, %arg0[%arg4, %3] : memref + } else { + affine.if #set1()[%0] { + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.mulf %4, %2 : f32 + memref.store %5, %arg0[%arg4, %3] : memref + } else { + affine.if #set2()[%0] { + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.cmpf ogt, %4, %2 : f32 + %6 = scf.if %5 -> (f32) { + %7 = memref.load %arg0[%arg4, %3] : memref + scf.yield %7 : f32 + } else { + scf.yield %2 : f32 + } + memref.store %6, %arg0[%arg4, %3] : memref + } else { + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.cmpf olt, %4, %2 : f32 + %6 = scf.if %5 -> (f32) { + %7 = memref.load %arg0[%arg4, %3] : memref + scf.yield %7 : f32 + } else { + scf.yield %2 : f32 + } + memref.store %6, %arg0[%arg4, %3] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_cpu/raised.mlir new file mode 100644 index 000000000000..fc59d7a7ac88 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_cpu/raised.mlir @@ -0,0 +1,45 @@ +#set = affine_set<()[s0] : (s0 == 0)> +#set1 = affine_set<()[s0] : (s0 - 1 == 0)> +#set2 = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg3 : i32 to index + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 64 { + %1 = affine.load %arg1[%arg4, %arg5] : memref + %2 = affine.load %arg2[%arg4, %arg5] : memref + affine.if #set()[%0] { + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.addf %4, %2 : f32 + memref.store %5, %arg0[%arg4, %3] : memref + } else { + affine.if #set1()[%0] { + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.mulf %4, %2 : f32 + memref.store %5, %arg0[%arg4, %3] : memref + } else { + affine.if #set2()[%0] { + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.cmpf ogt, %4, %2 : f32 + %6 = memref.load %arg0[%arg4, %3] : memref + %7 = arith.select %5, %6, %2 : f32 + memref.store %7, %arg0[%arg4, %3] : memref + } else { + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.cmpf olt, %4, %2 : f32 + %6 = memref.load %arg0[%arg4, %3] : memref + %7 = arith.select %5, %6, %2 : f32 + memref.store %7, %arg0[%arg4, %3] : memref + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_cpu_debuf.mlir new file mode 100644 index 000000000000..446c4e42bc51 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_cpu_debuf.mlir @@ -0,0 +1,47 @@ +#set = affine_set<()[s0] : (s0 == 0)> +#set1 = affine_set<()[s0] : (s0 - 1 == 0)> +#set2 = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = arith.index_cast %arg3 : i32 to index + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 64 { + %extracted = tensor.extract %1[%arg4, %arg5] : tensor + %extracted_0 = tensor.extract %0[%arg4, %arg5] : tensor + affine.if #set()[%2] { + %3 = arith.index_cast %extracted : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.addf %4, %extracted_0 : f32 + memref.store %5, %arg0[%arg4, %3] : memref + } else { + affine.if #set1()[%2] { + %3 = arith.index_cast %extracted : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.mulf %4, %extracted_0 : f32 + memref.store %5, %arg0[%arg4, %3] : memref + } else { + affine.if #set2()[%2] { + %3 = arith.index_cast %extracted : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.cmpf ogt, %4, %extracted_0 : f32 + %6 = memref.load %arg0[%arg4, %3] : memref + %7 = arith.select %5, %6, %extracted_0 : f32 + memref.store %7, %arg0[%arg4, %3] : memref + } else { + %3 = arith.index_cast %extracted : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.cmpf olt, %4, %extracted_0 : f32 + %6 = memref.load %arg0[%arg4, %3] : memref + %7 = arith.select %5, %6, %extracted_0 : f32 + memref.store %7, %arg0[%arg4, %3] : memref + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_cpu_linalg.mlir new file mode 100644 index 000000000000..fc59d7a7ac88 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_cpu_linalg.mlir @@ -0,0 +1,45 @@ +#set = affine_set<()[s0] : (s0 == 0)> +#set1 = affine_set<()[s0] : (s0 - 1 == 0)> +#set2 = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg3 : i32 to index + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 64 { + %1 = affine.load %arg1[%arg4, %arg5] : memref + %2 = affine.load %arg2[%arg4, %arg5] : memref + affine.if #set()[%0] { + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.addf %4, %2 : f32 + memref.store %5, %arg0[%arg4, %3] : memref + } else { + affine.if #set1()[%0] { + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.mulf %4, %2 : f32 + memref.store %5, %arg0[%arg4, %3] : memref + } else { + affine.if #set2()[%0] { + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.cmpf ogt, %4, %2 : f32 + %6 = memref.load %arg0[%arg4, %3] : memref + %7 = arith.select %5, %6, %2 : f32 + memref.store %7, %arg0[%arg4, %3] : memref + } else { + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg0[%arg4, %3] : memref + %5 = arith.cmpf olt, %4, %2 : f32 + %6 = memref.load %arg0[%arg4, %3] : memref + %7 = arith.select %5, %6, %2 : f32 + memref.store %7, %arg0[%arg4, %3] : memref + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu.mlir new file mode 100644 index 000000000000..f59937de7a46 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%arg3, %1] : memref + %3 = affine.load %arg2[%arg3, %arg4] : memref + %4 = arith.cmpf ogt, %2, %3 : f32 + %5 = scf.if %4 -> (f32) { + %6 = memref.load %arg0[%arg3, %1] : memref + scf.yield %6 : f32 + } else { + scf.yield %3 : f32 + } + memref.store %5, %arg0[%arg3, %1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu/debuf.mlir new file mode 100644 index 000000000000..2e3dd173591b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu/debuf.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %arg6[%arg3, %6] : tensor + %extracted_1 = tensor.extract %0[%arg3, %arg5] : tensor + %7 = arith.cmpf ogt, %extracted_0, %extracted_1 : f32 + %extracted_2 = tensor.extract %arg6[%arg3, %6] : tensor + %8 = arith.select %7, %extracted_2, %extracted_1 : f32 + %inserted = tensor.insert %8 into %arg6[%arg3, %6] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu/matched.mlir new file mode 100644 index 000000000000..2e3dd173591b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu/matched.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %arg6[%arg3, %6] : tensor + %extracted_1 = tensor.extract %0[%arg3, %arg5] : tensor + %7 = arith.cmpf ogt, %extracted_0, %extracted_1 : f32 + %extracted_2 = tensor.extract %arg6[%arg3, %6] : tensor + %8 = arith.select %7, %extracted_2, %extracted_1 : f32 + %inserted = tensor.insert %8 into %arg6[%arg3, %6] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu/orig.mlir new file mode 100644 index 000000000000..f59937de7a46 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu/orig.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%arg3, %1] : memref + %3 = affine.load %arg2[%arg3, %arg4] : memref + %4 = arith.cmpf ogt, %2, %3 : f32 + %5 = scf.if %4 -> (f32) { + %6 = memref.load %arg0[%arg3, %1] : memref + scf.yield %6 : f32 + } else { + scf.yield %3 : f32 + } + memref.store %5, %arg0[%arg3, %1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu/raised.mlir new file mode 100644 index 000000000000..032d5562b719 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu/raised.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%arg3, %1] : memref + %3 = affine.load %arg2[%arg3, %arg4] : memref + %4 = arith.cmpf ogt, %2, %3 : f32 + %5 = memref.load %arg0[%arg3, %1] : memref + %6 = arith.select %4, %5, %3 : f32 + memref.store %6, %arg0[%arg3, %1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu_debuf.mlir new file mode 100644 index 000000000000..2e3dd173591b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu_debuf.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %arg6[%arg3, %6] : tensor + %extracted_1 = tensor.extract %0[%arg3, %arg5] : tensor + %7 = arith.cmpf ogt, %extracted_0, %extracted_1 : f32 + %extracted_2 = tensor.extract %arg6[%arg3, %6] : tensor + %8 = arith.select %7, %extracted_2, %extracted_1 : f32 + %inserted = tensor.insert %8 into %arg6[%arg3, %6] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu_linalg.mlir new file mode 100644 index 000000000000..032d5562b719 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_expanded_index_cpu_linalg.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_expanded_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%arg3, %1] : memref + %3 = affine.load %arg2[%arg3, %arg4] : memref + %4 = arith.cmpf ogt, %2, %3 : f32 + %5 = memref.load %arg0[%arg3, %1] : memref + %6 = arith.select %4, %5, %3 : f32 + memref.store %6, %arg0[%arg3, %1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu.mlir new file mode 100644 index 000000000000..7301b3c86004 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_two_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + %3 = memref.load %arg0[%arg3, %1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg0[%arg3, %1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu/debuf.mlir new file mode 100644 index 000000000000..56241e390dce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu/debuf.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_two_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3, %arg5] : tensor + %extracted_1 = tensor.extract %arg6[%arg3, %6] : tensor + %7 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %7 into %arg6[%arg3, %6] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu/matched.mlir new file mode 100644 index 000000000000..56241e390dce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu/matched.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_two_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3, %arg5] : tensor + %extracted_1 = tensor.extract %arg6[%arg3, %6] : tensor + %7 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %7 into %arg6[%arg3, %6] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu/orig.mlir new file mode 100644 index 000000000000..7301b3c86004 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu/orig.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_two_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + %3 = memref.load %arg0[%arg3, %1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg0[%arg3, %1] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu/raised.mlir new file mode 100644 index 000000000000..0b43dd641a1f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu/raised.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_two_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + %3 = memref.load %arg0[%arg3, %1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg0[%arg3, %1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu_debuf.mlir new file mode 100644 index 000000000000..56241e390dce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu_debuf.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_two_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %2) -> (tensor) { + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %1[%arg3, %arg5] : tensor + %6 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %0[%arg3, %arg5] : tensor + %extracted_1 = tensor.extract %arg6[%arg3, %6] : tensor + %7 = arith.addf %extracted_1, %extracted_0 : f32 + %inserted = tensor.insert %7 into %arg6[%arg3, %6] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu_linalg.mlir new file mode 100644 index 000000000000..0b43dd641a1f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_reduce_two_cpu_linalg.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_reduce_two_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg3, %arg4] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg3, %arg4] : memref + %3 = memref.load %arg0[%arg3, %1] : memref + %4 = arith.addf %3, %2 : f32 + memref.store %4, %arg0[%arg3, %1] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu.mlir b/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu.mlir new file mode 100644 index 000000000000..18960d0846c6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu.mlir @@ -0,0 +1,51 @@ +#set = affine_set<()[s0] : (s0 == 0)> +#set1 = affine_set<()[s0] : (s0 - 1 == 0)> +#set2 = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_scalar_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg3 : i32 to index + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 64 { + %1 = affine.load %arg1[%arg4, %arg5] : memref + affine.if #set()[%0] { + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.addf %3, %arg2 : f32 + memref.store %4, %arg0[%arg4, %2] : memref + } else { + affine.if #set1()[%0] { + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.mulf %3, %arg2 : f32 + memref.store %4, %arg0[%arg4, %2] : memref + } else { + affine.if #set2()[%0] { + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.cmpf ogt, %3, %arg2 : f32 + %5 = scf.if %4 -> (f32) { + %6 = memref.load %arg0[%arg4, %2] : memref + scf.yield %6 : f32 + } else { + scf.yield %arg2 : f32 + } + memref.store %5, %arg0[%arg4, %2] : memref + } else { + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.cmpf olt, %3, %arg2 : f32 + %5 = scf.if %4 -> (f32) { + %6 = memref.load %arg0[%arg4, %2] : memref + scf.yield %6 : f32 + } else { + scf.yield %arg2 : f32 + } + memref.store %5, %arg0[%arg4, %2] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu/debuf.mlir new file mode 100644 index 000000000000..274c32191955 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu/debuf.mlir @@ -0,0 +1,45 @@ +#set = affine_set<()[s0] : (s0 == 0)> +#set1 = affine_set<()[s0] : (s0 - 1 == 0)> +#set2 = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_scalar_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = arith.index_cast %arg3 : i32 to index + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 64 { + %extracted = tensor.extract %0[%arg4, %arg5] : tensor + affine.if #set()[%1] { + %2 = arith.index_cast %extracted : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.addf %3, %arg2 : f32 + memref.store %4, %arg0[%arg4, %2] : memref + } else { + affine.if #set1()[%1] { + %2 = arith.index_cast %extracted : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.mulf %3, %arg2 : f32 + memref.store %4, %arg0[%arg4, %2] : memref + } else { + affine.if #set2()[%1] { + %2 = arith.index_cast %extracted : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.cmpf ogt, %3, %arg2 : f32 + %5 = memref.load %arg0[%arg4, %2] : memref + %6 = arith.select %4, %5, %arg2 : f32 + memref.store %6, %arg0[%arg4, %2] : memref + } else { + %2 = arith.index_cast %extracted : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.cmpf olt, %3, %arg2 : f32 + %5 = memref.load %arg0[%arg4, %2] : memref + %6 = arith.select %4, %5, %arg2 : f32 + memref.store %6, %arg0[%arg4, %2] : memref + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu/matched.mlir new file mode 100644 index 000000000000..274c32191955 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu/matched.mlir @@ -0,0 +1,45 @@ +#set = affine_set<()[s0] : (s0 == 0)> +#set1 = affine_set<()[s0] : (s0 - 1 == 0)> +#set2 = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_scalar_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = arith.index_cast %arg3 : i32 to index + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 64 { + %extracted = tensor.extract %0[%arg4, %arg5] : tensor + affine.if #set()[%1] { + %2 = arith.index_cast %extracted : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.addf %3, %arg2 : f32 + memref.store %4, %arg0[%arg4, %2] : memref + } else { + affine.if #set1()[%1] { + %2 = arith.index_cast %extracted : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.mulf %3, %arg2 : f32 + memref.store %4, %arg0[%arg4, %2] : memref + } else { + affine.if #set2()[%1] { + %2 = arith.index_cast %extracted : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.cmpf ogt, %3, %arg2 : f32 + %5 = memref.load %arg0[%arg4, %2] : memref + %6 = arith.select %4, %5, %arg2 : f32 + memref.store %6, %arg0[%arg4, %2] : memref + } else { + %2 = arith.index_cast %extracted : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.cmpf olt, %3, %arg2 : f32 + %5 = memref.load %arg0[%arg4, %2] : memref + %6 = arith.select %4, %5, %arg2 : f32 + memref.store %6, %arg0[%arg4, %2] : memref + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu/orig.mlir new file mode 100644 index 000000000000..18960d0846c6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu/orig.mlir @@ -0,0 +1,51 @@ +#set = affine_set<()[s0] : (s0 == 0)> +#set1 = affine_set<()[s0] : (s0 - 1 == 0)> +#set2 = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_scalar_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg3 : i32 to index + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 64 { + %1 = affine.load %arg1[%arg4, %arg5] : memref + affine.if #set()[%0] { + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.addf %3, %arg2 : f32 + memref.store %4, %arg0[%arg4, %2] : memref + } else { + affine.if #set1()[%0] { + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.mulf %3, %arg2 : f32 + memref.store %4, %arg0[%arg4, %2] : memref + } else { + affine.if #set2()[%0] { + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.cmpf ogt, %3, %arg2 : f32 + %5 = scf.if %4 -> (f32) { + %6 = memref.load %arg0[%arg4, %2] : memref + scf.yield %6 : f32 + } else { + scf.yield %arg2 : f32 + } + memref.store %5, %arg0[%arg4, %2] : memref + } else { + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.cmpf olt, %3, %arg2 : f32 + %5 = scf.if %4 -> (f32) { + %6 = memref.load %arg0[%arg4, %2] : memref + scf.yield %6 : f32 + } else { + scf.yield %arg2 : f32 + } + memref.store %5, %arg0[%arg4, %2] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu/raised.mlir new file mode 100644 index 000000000000..7b17bfd0cb77 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu/raised.mlir @@ -0,0 +1,44 @@ +#set = affine_set<()[s0] : (s0 == 0)> +#set1 = affine_set<()[s0] : (s0 - 1 == 0)> +#set2 = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_scalar_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg3 : i32 to index + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 64 { + %1 = affine.load %arg1[%arg4, %arg5] : memref + affine.if #set()[%0] { + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.addf %3, %arg2 : f32 + memref.store %4, %arg0[%arg4, %2] : memref + } else { + affine.if #set1()[%0] { + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.mulf %3, %arg2 : f32 + memref.store %4, %arg0[%arg4, %2] : memref + } else { + affine.if #set2()[%0] { + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.cmpf ogt, %3, %arg2 : f32 + %5 = memref.load %arg0[%arg4, %2] : memref + %6 = arith.select %4, %5, %arg2 : f32 + memref.store %6, %arg0[%arg4, %2] : memref + } else { + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.cmpf olt, %3, %arg2 : f32 + %5 = memref.load %arg0[%arg4, %2] : memref + %6 = arith.select %4, %5, %arg2 : f32 + memref.store %6, %arg0[%arg4, %2] : memref + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu_debuf.mlir new file mode 100644 index 000000000000..274c32191955 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu_debuf.mlir @@ -0,0 +1,45 @@ +#set = affine_set<()[s0] : (s0 == 0)> +#set1 = affine_set<()[s0] : (s0 - 1 == 0)> +#set2 = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_scalar_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = arith.index_cast %arg3 : i32 to index + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 64 { + %extracted = tensor.extract %0[%arg4, %arg5] : tensor + affine.if #set()[%1] { + %2 = arith.index_cast %extracted : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.addf %3, %arg2 : f32 + memref.store %4, %arg0[%arg4, %2] : memref + } else { + affine.if #set1()[%1] { + %2 = arith.index_cast %extracted : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.mulf %3, %arg2 : f32 + memref.store %4, %arg0[%arg4, %2] : memref + } else { + affine.if #set2()[%1] { + %2 = arith.index_cast %extracted : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.cmpf ogt, %3, %arg2 : f32 + %5 = memref.load %arg0[%arg4, %2] : memref + %6 = arith.select %4, %5, %arg2 : f32 + memref.store %6, %arg0[%arg4, %2] : memref + } else { + %2 = arith.index_cast %extracted : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.cmpf olt, %3, %arg2 : f32 + %5 = memref.load %arg0[%arg4, %2] : memref + %6 = arith.select %4, %5, %arg2 : f32 + memref.store %6, %arg0[%arg4, %2] : memref + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu_linalg.mlir new file mode 100644 index 000000000000..7b17bfd0cb77 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_scatter_scalar_reduce_cpu_linalg.mlir @@ -0,0 +1,44 @@ +#set = affine_set<()[s0] : (s0 == 0)> +#set1 = affine_set<()[s0] : (s0 - 1 == 0)> +#set2 = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_scatter_scalar_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: i32) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg3 : i32 to index + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 64 { + %1 = affine.load %arg1[%arg4, %arg5] : memref + affine.if #set()[%0] { + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.addf %3, %arg2 : f32 + memref.store %4, %arg0[%arg4, %2] : memref + } else { + affine.if #set1()[%0] { + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.mulf %3, %arg2 : f32 + memref.store %4, %arg0[%arg4, %2] : memref + } else { + affine.if #set2()[%0] { + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.cmpf ogt, %3, %arg2 : f32 + %5 = memref.load %arg0[%arg4, %2] : memref + %6 = arith.select %4, %5, %arg2 : f32 + memref.store %6, %arg0[%arg4, %2] : memref + } else { + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%arg4, %2] : memref + %4 = arith.cmpf olt, %3, %arg2 : f32 + %5 = memref.load %arg0[%arg4, %2] : memref + %6 = arith.select %4, %5, %arg2 : f32 + memref.store %6, %arg0[%arg4, %2] : memref + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_searchsorted_cpu.mlir b/issues/aten_c_kernels/results/aten_searchsorted_cpu.mlir new file mode 100644 index 000000000000..511d7c966bbe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_searchsorted_cpu.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_searchsorted_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c256_i32 = arith.constant 256 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0:2 = scf.while (%arg4 = %c256_i32, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %1 = arith.cmpi slt, %arg5, %arg4 : i32 + scf.condition(%1) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %1 = arith.addi %arg4, %arg5 : i32 + %2 = arith.divsi %1, %c2_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3] : memref + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf olt, %4, %5 : f32 + %7 = arith.select %6, %arg5, %2 : i32 + %8 = scf.if %6 -> (i32) { + %9 = arith.addi %2, %c1_i32 : i32 + scf.yield %9 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %7, %8 : i32, i32 + } + affine.store %0#0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_searchsorted_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_searchsorted_cpu/debuf.mlir new file mode 100644 index 000000000000..594b9c3449d8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_searchsorted_cpu/debuf.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_searchsorted_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c256_i32 = arith.constant 256 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c256_i32, %arg6 = %c0_i32) : (i32, i32) -> (i32, i32) { + %6 = arith.cmpi slt, %arg6, %arg5 : i32 + scf.condition(%6) %arg6, %arg5 : i32, i32 + } do { + ^bb0(%arg5: i32, %arg6: i32): + %6 = arith.addi %arg5, %arg6 : i32 + %7 = arith.divsi %6, %c2_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %extracted = tensor.extract %2[%8] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %9 = arith.cmpf olt, %extracted, %extracted_0 : f32 + %10 = arith.select %9, %arg6, %7 : i32 + %11 = arith.addi %7, %c1_i32 : i32 + %12 = arith.select %9, %11, %arg5 : i32 + scf.yield %10, %12 : i32, i32 + } + %inserted = tensor.insert %5#0 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_searchsorted_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_searchsorted_cpu/matched.mlir new file mode 100644 index 000000000000..594b9c3449d8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_searchsorted_cpu/matched.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_searchsorted_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c256_i32 = arith.constant 256 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c256_i32, %arg6 = %c0_i32) : (i32, i32) -> (i32, i32) { + %6 = arith.cmpi slt, %arg6, %arg5 : i32 + scf.condition(%6) %arg6, %arg5 : i32, i32 + } do { + ^bb0(%arg5: i32, %arg6: i32): + %6 = arith.addi %arg5, %arg6 : i32 + %7 = arith.divsi %6, %c2_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %extracted = tensor.extract %2[%8] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %9 = arith.cmpf olt, %extracted, %extracted_0 : f32 + %10 = arith.select %9, %arg6, %7 : i32 + %11 = arith.addi %7, %c1_i32 : i32 + %12 = arith.select %9, %11, %arg5 : i32 + scf.yield %10, %12 : i32, i32 + } + %inserted = tensor.insert %5#0 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_searchsorted_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_searchsorted_cpu/orig.mlir new file mode 100644 index 000000000000..511d7c966bbe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_searchsorted_cpu/orig.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_searchsorted_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c256_i32 = arith.constant 256 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0:2 = scf.while (%arg4 = %c256_i32, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %1 = arith.cmpi slt, %arg5, %arg4 : i32 + scf.condition(%1) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %1 = arith.addi %arg4, %arg5 : i32 + %2 = arith.divsi %1, %c2_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3] : memref + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf olt, %4, %5 : f32 + %7 = arith.select %6, %arg5, %2 : i32 + %8 = scf.if %6 -> (i32) { + %9 = arith.addi %2, %c1_i32 : i32 + scf.yield %9 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %7, %8 : i32, i32 + } + affine.store %0#0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_searchsorted_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_searchsorted_cpu/raised.mlir new file mode 100644 index 000000000000..24056c1ffb51 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_searchsorted_cpu/raised.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_searchsorted_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c256_i32 = arith.constant 256 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0:2 = scf.while (%arg4 = %c256_i32, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %1 = arith.cmpi slt, %arg5, %arg4 : i32 + scf.condition(%1) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %1 = arith.addi %arg4, %arg5 : i32 + %2 = arith.divsi %1, %c2_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3] : memref + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf olt, %4, %5 : f32 + %7 = arith.select %6, %arg5, %2 : i32 + %8 = arith.addi %2, %c1_i32 : i32 + %9 = arith.select %6, %8, %arg4 : i32 + scf.yield %7, %9 : i32, i32 + } + affine.store %0#0, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_searchsorted_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_searchsorted_cpu_debuf.mlir new file mode 100644 index 000000000000..594b9c3449d8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_searchsorted_cpu_debuf.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_searchsorted_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c256_i32 = arith.constant 256 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c256_i32, %arg6 = %c0_i32) : (i32, i32) -> (i32, i32) { + %6 = arith.cmpi slt, %arg6, %arg5 : i32 + scf.condition(%6) %arg6, %arg5 : i32, i32 + } do { + ^bb0(%arg5: i32, %arg6: i32): + %6 = arith.addi %arg5, %arg6 : i32 + %7 = arith.divsi %6, %c2_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %extracted = tensor.extract %2[%8] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %9 = arith.cmpf olt, %extracted, %extracted_0 : f32 + %10 = arith.select %9, %arg6, %7 : i32 + %11 = arith.addi %7, %c1_i32 : i32 + %12 = arith.select %9, %11, %arg5 : i32 + scf.yield %10, %12 : i32, i32 + } + %inserted = tensor.insert %5#0 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_searchsorted_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_searchsorted_cpu_linalg.mlir new file mode 100644 index 000000000000..24056c1ffb51 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_searchsorted_cpu_linalg.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_searchsorted_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c256_i32 = arith.constant 256 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0:2 = scf.while (%arg4 = %c256_i32, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %1 = arith.cmpi slt, %arg5, %arg4 : i32 + scf.condition(%1) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %1 = arith.addi %arg4, %arg5 : i32 + %2 = arith.divsi %1, %c2_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3] : memref + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf olt, %4, %5 : f32 + %7 = arith.select %6, %arg5, %2 : i32 + %8 = arith.addi %2, %c1_i32 : i32 + %9 = arith.select %6, %8, %arg4 : i32 + scf.yield %7, %9 : i32, i32 + } + affine.store %0#0, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu.mlir new file mode 100644 index 000000000000..efa7672a3409 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu.mlir @@ -0,0 +1,51 @@ +#set = affine_set<()[s0] : (s0 == 0)> +#set1 = affine_set<()[s0] : (s0 - 1 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_segment_reduce_lengths_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = arith.index_cast %arg4 : i32 to index + %1 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %c0_i32) -> (i32) { + %2:2 = scf.while (%arg8 = %c0_i32, %arg9 = %arg7) : (i32, i32) -> (i32, i32) { + %3 = affine.load %arg1[%arg6] : memref + %4 = arith.cmpi slt, %arg8, %3 : i32 + scf.condition(%4) %arg9, %arg8 : i32, i32 + } do { + ^bb0(%arg8: i32, %arg9: i32): + %3 = affine.if #set()[%0] -> f32 { + %7 = affine.load %arg3[%arg6] : memref + affine.yield %7 : f32 + } else { + %7 = affine.if #set1()[%0] -> f32 { + %8 = affine.load %arg3[%arg6] : memref + %9 = affine.load %arg1[%arg6] : memref + %10 = arith.sitofp %9 : i32 to f32 + %11 = arith.divf %8, %10 : f32 + affine.yield %11 : f32 + } else { + %8 = arith.index_cast %arg8 : i32 to index + %9 = memref.load %arg0[%8] : memref + %10 = affine.load %arg2[%arg6] : memref + %11 = arith.cmpf oeq, %9, %10 : f32 + %12 = scf.if %11 -> (f32) { + %13 = affine.load %arg3[%arg6] : memref + scf.yield %13 : f32 + } else { + scf.yield %cst : f32 + } + affine.yield %12 : f32 + } + affine.yield %7 : f32 + } + %4 = arith.addi %arg8, %c1_i32 : i32 + %5 = arith.index_cast %arg8 : i32 to index + memref.store %3, %arg5[%5] : memref + %6 = arith.addi %arg9, %c1_i32 : i32 + scf.yield %6, %4 : i32, i32 + } + affine.yield %2#0 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..49337ba9f25c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu/debuf.mlir @@ -0,0 +1,54 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_segment_reduce_lengths_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = arith.index_cast %arg4 : i32 to index + %6 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %6[] : tensor + %7:2 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %inserted, %arg8 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg7[] : tensor + %9:3 = scf.while (%arg9 = %c0_i32, %arg10 = %extracted, %arg11 = %arg8) : (i32, i32, tensor) -> (i32, i32, tensor) { + %extracted_1 = tensor.extract %3[%arg6] : tensor + %10 = arith.cmpi slt, %arg9, %extracted_1 : i32 + scf.condition(%10) %arg10, %arg9, %arg11 : i32, i32, tensor + } do { + ^bb0(%arg9: i32, %arg10: i32, %arg11: tensor): + %10 = arith.cmpi eq, %5, %c0 : index + %extracted_1 = tensor.extract %1[%arg6] : tensor + %11 = affine.apply #map()[%5] + %12 = arith.cmpi eq, %11, %c0 : index + %extracted_2 = tensor.extract %1[%arg6] : tensor + %extracted_3 = tensor.extract %3[%arg6] : tensor + %13 = arith.sitofp %extracted_3 : i32 to f32 + %14 = arith.divf %extracted_2, %13 : f32 + %15 = arith.index_cast %arg9 : i32 to index + %extracted_4 = tensor.extract %4[%15] : tensor + %extracted_5 = tensor.extract %2[%arg6] : tensor + %16 = arith.cmpf oeq, %extracted_4, %extracted_5 : f32 + %extracted_6 = tensor.extract %1[%arg6] : tensor + %17 = arith.select %16, %extracted_6, %cst : f32 + %18 = arith.select %12, %14, %17 : f32 + %19 = arith.select %10, %extracted_1, %18 : f32 + %20 = arith.addi %arg9, %c1_i32 : i32 + %21 = arith.index_cast %arg9 : i32 to index + %inserted_7 = tensor.insert %19 into %arg11[%21] : tensor + %22 = arith.addi %arg10, %c1_i32 : i32 + scf.yield %22, %20, %inserted_7 : i32, i32, tensor + } + %inserted_0 = tensor.insert %9#0 into %arg7[] : tensor + affine.yield %inserted_0, %9#2 : tensor, tensor + } + %8 = bufferization.to_memref %7#1 : memref + memref.copy %8, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu/matched.mlir new file mode 100644 index 000000000000..49337ba9f25c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu/matched.mlir @@ -0,0 +1,54 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_segment_reduce_lengths_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = arith.index_cast %arg4 : i32 to index + %6 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %6[] : tensor + %7:2 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %inserted, %arg8 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg7[] : tensor + %9:3 = scf.while (%arg9 = %c0_i32, %arg10 = %extracted, %arg11 = %arg8) : (i32, i32, tensor) -> (i32, i32, tensor) { + %extracted_1 = tensor.extract %3[%arg6] : tensor + %10 = arith.cmpi slt, %arg9, %extracted_1 : i32 + scf.condition(%10) %arg10, %arg9, %arg11 : i32, i32, tensor + } do { + ^bb0(%arg9: i32, %arg10: i32, %arg11: tensor): + %10 = arith.cmpi eq, %5, %c0 : index + %extracted_1 = tensor.extract %1[%arg6] : tensor + %11 = affine.apply #map()[%5] + %12 = arith.cmpi eq, %11, %c0 : index + %extracted_2 = tensor.extract %1[%arg6] : tensor + %extracted_3 = tensor.extract %3[%arg6] : tensor + %13 = arith.sitofp %extracted_3 : i32 to f32 + %14 = arith.divf %extracted_2, %13 : f32 + %15 = arith.index_cast %arg9 : i32 to index + %extracted_4 = tensor.extract %4[%15] : tensor + %extracted_5 = tensor.extract %2[%arg6] : tensor + %16 = arith.cmpf oeq, %extracted_4, %extracted_5 : f32 + %extracted_6 = tensor.extract %1[%arg6] : tensor + %17 = arith.select %16, %extracted_6, %cst : f32 + %18 = arith.select %12, %14, %17 : f32 + %19 = arith.select %10, %extracted_1, %18 : f32 + %20 = arith.addi %arg9, %c1_i32 : i32 + %21 = arith.index_cast %arg9 : i32 to index + %inserted_7 = tensor.insert %19 into %arg11[%21] : tensor + %22 = arith.addi %arg10, %c1_i32 : i32 + scf.yield %22, %20, %inserted_7 : i32, i32, tensor + } + %inserted_0 = tensor.insert %9#0 into %arg7[] : tensor + affine.yield %inserted_0, %9#2 : tensor, tensor + } + %8 = bufferization.to_memref %7#1 : memref + memref.copy %8, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu/orig.mlir new file mode 100644 index 000000000000..efa7672a3409 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu/orig.mlir @@ -0,0 +1,51 @@ +#set = affine_set<()[s0] : (s0 == 0)> +#set1 = affine_set<()[s0] : (s0 - 1 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_segment_reduce_lengths_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = arith.index_cast %arg4 : i32 to index + %1 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %c0_i32) -> (i32) { + %2:2 = scf.while (%arg8 = %c0_i32, %arg9 = %arg7) : (i32, i32) -> (i32, i32) { + %3 = affine.load %arg1[%arg6] : memref + %4 = arith.cmpi slt, %arg8, %3 : i32 + scf.condition(%4) %arg9, %arg8 : i32, i32 + } do { + ^bb0(%arg8: i32, %arg9: i32): + %3 = affine.if #set()[%0] -> f32 { + %7 = affine.load %arg3[%arg6] : memref + affine.yield %7 : f32 + } else { + %7 = affine.if #set1()[%0] -> f32 { + %8 = affine.load %arg3[%arg6] : memref + %9 = affine.load %arg1[%arg6] : memref + %10 = arith.sitofp %9 : i32 to f32 + %11 = arith.divf %8, %10 : f32 + affine.yield %11 : f32 + } else { + %8 = arith.index_cast %arg8 : i32 to index + %9 = memref.load %arg0[%8] : memref + %10 = affine.load %arg2[%arg6] : memref + %11 = arith.cmpf oeq, %9, %10 : f32 + %12 = scf.if %11 -> (f32) { + %13 = affine.load %arg3[%arg6] : memref + scf.yield %13 : f32 + } else { + scf.yield %cst : f32 + } + affine.yield %12 : f32 + } + affine.yield %7 : f32 + } + %4 = arith.addi %arg8, %c1_i32 : i32 + %5 = arith.index_cast %arg8 : i32 to index + memref.store %3, %arg5[%5] : memref + %6 = arith.addi %arg9, %c1_i32 : i32 + scf.yield %6, %4 : i32, i32 + } + affine.yield %2#0 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu/raised.mlir new file mode 100644 index 000000000000..d01acc405391 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu/raised.mlir @@ -0,0 +1,46 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_segment_reduce_lengths_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = arith.index_cast %arg4 : i32 to index + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg6 = 0 to 16 { + %1 = affine.load %alloca[] : memref + %2:2 = scf.while (%arg7 = %c0_i32, %arg8 = %1) : (i32, i32) -> (i32, i32) { + %3 = affine.load %arg1[%arg6] : memref + %4 = arith.cmpi slt, %arg7, %3 : i32 + scf.condition(%4) %arg8, %arg7 : i32, i32 + } do { + ^bb0(%arg7: i32, %arg8: i32): + %3 = arith.cmpi eq, %0, %c0 : index + %4 = affine.load %arg3[%arg6] : memref + %5 = affine.apply #map()[%0] + %6 = arith.cmpi eq, %5, %c0 : index + %7 = affine.load %arg3[%arg6] : memref + %8 = affine.load %arg1[%arg6] : memref + %9 = arith.sitofp %8 : i32 to f32 + %10 = arith.divf %7, %9 : f32 + %11 = arith.index_cast %arg7 : i32 to index + %12 = memref.load %arg0[%11] : memref + %13 = affine.load %arg2[%arg6] : memref + %14 = arith.cmpf oeq, %12, %13 : f32 + %15 = affine.load %arg3[%arg6] : memref + %16 = arith.select %14, %15, %cst : f32 + %17 = arith.select %6, %10, %16 : f32 + %18 = arith.select %3, %4, %17 : f32 + %19 = arith.addi %arg7, %c1_i32 : i32 + %20 = arith.index_cast %arg7 : i32 to index + memref.store %18, %arg5[%20] : memref + %21 = arith.addi %arg8, %c1_i32 : i32 + scf.yield %21, %19 : i32, i32 + } + affine.store %2#0, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..49337ba9f25c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu_debuf.mlir @@ -0,0 +1,54 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_segment_reduce_lengths_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = arith.index_cast %arg4 : i32 to index + %6 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %6[] : tensor + %7:2 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %inserted, %arg8 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg7[] : tensor + %9:3 = scf.while (%arg9 = %c0_i32, %arg10 = %extracted, %arg11 = %arg8) : (i32, i32, tensor) -> (i32, i32, tensor) { + %extracted_1 = tensor.extract %3[%arg6] : tensor + %10 = arith.cmpi slt, %arg9, %extracted_1 : i32 + scf.condition(%10) %arg10, %arg9, %arg11 : i32, i32, tensor + } do { + ^bb0(%arg9: i32, %arg10: i32, %arg11: tensor): + %10 = arith.cmpi eq, %5, %c0 : index + %extracted_1 = tensor.extract %1[%arg6] : tensor + %11 = affine.apply #map()[%5] + %12 = arith.cmpi eq, %11, %c0 : index + %extracted_2 = tensor.extract %1[%arg6] : tensor + %extracted_3 = tensor.extract %3[%arg6] : tensor + %13 = arith.sitofp %extracted_3 : i32 to f32 + %14 = arith.divf %extracted_2, %13 : f32 + %15 = arith.index_cast %arg9 : i32 to index + %extracted_4 = tensor.extract %4[%15] : tensor + %extracted_5 = tensor.extract %2[%arg6] : tensor + %16 = arith.cmpf oeq, %extracted_4, %extracted_5 : f32 + %extracted_6 = tensor.extract %1[%arg6] : tensor + %17 = arith.select %16, %extracted_6, %cst : f32 + %18 = arith.select %12, %14, %17 : f32 + %19 = arith.select %10, %extracted_1, %18 : f32 + %20 = arith.addi %arg9, %c1_i32 : i32 + %21 = arith.index_cast %arg9 : i32 to index + %inserted_7 = tensor.insert %19 into %arg11[%21] : tensor + %22 = arith.addi %arg10, %c1_i32 : i32 + scf.yield %22, %20, %inserted_7 : i32, i32, tensor + } + %inserted_0 = tensor.insert %9#0 into %arg7[] : tensor + affine.yield %inserted_0, %9#2 : tensor, tensor + } + %8 = bufferization.to_memref %7#1 : memref + memref.copy %8, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..d01acc405391 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_backward_cpu_linalg.mlir @@ -0,0 +1,46 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_segment_reduce_lengths_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = arith.index_cast %arg4 : i32 to index + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg6 = 0 to 16 { + %1 = affine.load %alloca[] : memref + %2:2 = scf.while (%arg7 = %c0_i32, %arg8 = %1) : (i32, i32) -> (i32, i32) { + %3 = affine.load %arg1[%arg6] : memref + %4 = arith.cmpi slt, %arg7, %3 : i32 + scf.condition(%4) %arg8, %arg7 : i32, i32 + } do { + ^bb0(%arg7: i32, %arg8: i32): + %3 = arith.cmpi eq, %0, %c0 : index + %4 = affine.load %arg3[%arg6] : memref + %5 = affine.apply #map()[%0] + %6 = arith.cmpi eq, %5, %c0 : index + %7 = affine.load %arg3[%arg6] : memref + %8 = affine.load %arg1[%arg6] : memref + %9 = arith.sitofp %8 : i32 to f32 + %10 = arith.divf %7, %9 : f32 + %11 = arith.index_cast %arg7 : i32 to index + %12 = memref.load %arg0[%11] : memref + %13 = affine.load %arg2[%arg6] : memref + %14 = arith.cmpf oeq, %12, %13 : f32 + %15 = affine.load %arg3[%arg6] : memref + %16 = arith.select %14, %15, %cst : f32 + %17 = arith.select %6, %10, %16 : f32 + %18 = arith.select %3, %4, %17 : f32 + %19 = arith.addi %arg7, %c1_i32 : i32 + %20 = arith.index_cast %arg7 : i32 to index + memref.store %18, %arg5[%20] : memref + %21 = arith.addi %arg8, %c1_i32 : i32 + scf.yield %21, %19 : i32, i32 + } + affine.store %2#0, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu.mlir b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu.mlir new file mode 100644 index 000000000000..2ab59ccd4bc0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu.mlir @@ -0,0 +1,73 @@ +#set = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_segment_reduce_lengths_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c0_i32 = arith.constant 0 : i32 + %c2_i32 = arith.constant 2 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c3_i32 = arith.constant 3 : i32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %true = arith.constant true + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %0 = arith.index_cast %arg2 : i32 to index + %1 = arith.cmpi eq, %arg2, %c2_i32 : i32 + %2 = arith.cmpi eq, %arg2, %c0_i32 : i32 + %3 = scf.if %1 -> (f32) { + scf.yield %cst : f32 + } else { + %8 = arith.cmpi eq, %arg2, %c3_i32 : i32 + %9 = arith.select %8, %cst_0, %cst_1 : f32 + scf.yield %9 : f32 + } + %4 = scf.if %2 -> (i1) { + scf.yield %true : i1 + } else { + %8 = arith.cmpi eq, %arg2, %c1_i32 : i32 + scf.yield %8 : i1 + } + %5 = arith.addi %0, %c-1 : index + %6 = arith.cmpi eq, %5, %c0 : index + %7 = affine.for %arg4 = 0 to 16 iter_args(%arg5 = %c0_i32) -> (i32) { + %8 = affine.load %arg1[%arg4] : memref + %9 = arith.index_cast %8 : i32 to index + %10 = arith.index_cast %arg5 : i32 to index + %11 = arith.addi %10, %9 : index + %12 = arith.index_cast %11 : index to i32 + %13 = scf.for %arg6 = %c0 to %9 step %c1 iter_args(%arg7 = %3) -> (f32) { + %17 = arith.addi %10, %arg6 : index + %18 = memref.load %arg0[%17] : memref + %19 = scf.if %4 -> (f32) { + %20 = arith.addf %arg7, %18 : f32 + scf.yield %20 : f32 + } else { + %20 = affine.if #set()[%0] -> f32 { + %21 = arith.cmpf ogt, %arg7, %18 : f32 + %22 = arith.select %21, %arg7, %18 : f32 + affine.yield %22 : f32 + } else { + %21 = arith.cmpf olt, %arg7, %18 : f32 + %22 = arith.select %21, %arg7, %18 : f32 + affine.yield %22 : f32 + } + scf.yield %20 : f32 + } + scf.yield %19 : f32 + } + %14 = arith.cmpi ne, %8, %c0_i32 : i32 + %15 = arith.andi %6, %14 : i1 + %16 = scf.if %15 -> (f32) { + %17 = arith.sitofp %8 : i32 to f32 + %18 = arith.divf %13, %17 : f32 + scf.yield %18 : f32 + } else { + scf.yield %13 : f32 + } + affine.store %16, %arg3[%arg4] : memref + affine.yield %12 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu/debuf.mlir new file mode 100644 index 000000000000..13dee48a227a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu/debuf.mlir @@ -0,0 +1,69 @@ +#map = affine_map<()[s0] -> (s0 - 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_segment_reduce_lengths_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %true = arith.constant true + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %c3_i32 = arith.constant 3 : i32 + %cst_1 = arith.constant -3.40282347E+38 : f32 + %c2_i32 = arith.constant 2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c-1 = arith.constant -1 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = arith.index_cast %arg2 : i32 to index + %4 = arith.cmpi eq, %arg2, %c2_i32 : i32 + %5 = arith.cmpi eq, %arg2, %c0_i32 : i32 + %6 = arith.cmpi eq, %arg2, %c3_i32 : i32 + %7 = arith.select %6, %cst_0, %cst : f32 + %8 = arith.select %4, %cst_1, %7 : f32 + %9 = arith.cmpi eq, %arg2, %c1_i32 : i32 + %10 = arith.select %5, %true, %9 : i1 + %11 = arith.addi %3, %c-1 : index + %12 = arith.cmpi eq, %11, %c0 : index + %13 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %13[] : tensor + %14:2 = affine.for %arg4 = 0 to 16 iter_args(%arg5 = %inserted, %arg6 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg5[] : tensor + %extracted_2 = tensor.extract %1[%arg4] : tensor + %16 = arith.index_cast %extracted_2 : i32 to index + %17 = arith.index_cast %extracted : i32 to index + %18 = arith.addi %17, %16 : index + %19 = arith.index_cast %18 : index to i32 + %20 = scf.for %arg7 = %c0 to %16 step %c1 iter_args(%arg8 = %8) -> (f32) { + %26 = arith.addi %17, %arg7 : index + %extracted_5 = tensor.extract %2[%26] : tensor + %27 = scf.if %10 -> (f32) { + %28 = arith.addf %arg8, %extracted_5 : f32 + scf.yield %28 : f32 + } else { + %28 = affine.apply #map()[%3] + %29 = arith.cmpi eq, %28, %c0 : index + %30 = arith.cmpf ogt, %arg8, %extracted_5 : f32 + %31 = arith.select %30, %arg8, %extracted_5 : f32 + %32 = arith.cmpf olt, %arg8, %extracted_5 : f32 + %33 = arith.select %32, %arg8, %extracted_5 : f32 + %34 = arith.select %29, %31, %33 : f32 + scf.yield %34 : f32 + } + scf.yield %27 : f32 + } + %21 = arith.cmpi ne, %extracted_2, %c0_i32 : i32 + %22 = arith.andi %12, %21 : i1 + %23 = arith.sitofp %extracted_2 : i32 to f32 + %24 = arith.divf %20, %23 : f32 + %25 = arith.select %22, %24, %20 : f32 + %inserted_3 = tensor.insert %25 into %arg6[%arg4] : tensor + %inserted_4 = tensor.insert %19 into %arg5[] : tensor + affine.yield %inserted_4, %inserted_3 : tensor, tensor + } + %15 = bufferization.to_memref %14#1 : memref + memref.copy %15, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu/matched.mlir new file mode 100644 index 000000000000..13dee48a227a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu/matched.mlir @@ -0,0 +1,69 @@ +#map = affine_map<()[s0] -> (s0 - 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_segment_reduce_lengths_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %true = arith.constant true + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %c3_i32 = arith.constant 3 : i32 + %cst_1 = arith.constant -3.40282347E+38 : f32 + %c2_i32 = arith.constant 2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c-1 = arith.constant -1 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = arith.index_cast %arg2 : i32 to index + %4 = arith.cmpi eq, %arg2, %c2_i32 : i32 + %5 = arith.cmpi eq, %arg2, %c0_i32 : i32 + %6 = arith.cmpi eq, %arg2, %c3_i32 : i32 + %7 = arith.select %6, %cst_0, %cst : f32 + %8 = arith.select %4, %cst_1, %7 : f32 + %9 = arith.cmpi eq, %arg2, %c1_i32 : i32 + %10 = arith.select %5, %true, %9 : i1 + %11 = arith.addi %3, %c-1 : index + %12 = arith.cmpi eq, %11, %c0 : index + %13 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %13[] : tensor + %14:2 = affine.for %arg4 = 0 to 16 iter_args(%arg5 = %inserted, %arg6 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg5[] : tensor + %extracted_2 = tensor.extract %1[%arg4] : tensor + %16 = arith.index_cast %extracted_2 : i32 to index + %17 = arith.index_cast %extracted : i32 to index + %18 = arith.addi %17, %16 : index + %19 = arith.index_cast %18 : index to i32 + %20 = scf.for %arg7 = %c0 to %16 step %c1 iter_args(%arg8 = %8) -> (f32) { + %26 = arith.addi %17, %arg7 : index + %extracted_5 = tensor.extract %2[%26] : tensor + %27 = scf.if %10 -> (f32) { + %28 = arith.addf %arg8, %extracted_5 : f32 + scf.yield %28 : f32 + } else { + %28 = affine.apply #map()[%3] + %29 = arith.cmpi eq, %28, %c0 : index + %30 = arith.cmpf ogt, %arg8, %extracted_5 : f32 + %31 = arith.select %30, %arg8, %extracted_5 : f32 + %32 = arith.cmpf olt, %arg8, %extracted_5 : f32 + %33 = arith.select %32, %arg8, %extracted_5 : f32 + %34 = arith.select %29, %31, %33 : f32 + scf.yield %34 : f32 + } + scf.yield %27 : f32 + } + %21 = arith.cmpi ne, %extracted_2, %c0_i32 : i32 + %22 = arith.andi %12, %21 : i1 + %23 = arith.sitofp %extracted_2 : i32 to f32 + %24 = arith.divf %20, %23 : f32 + %25 = arith.select %22, %24, %20 : f32 + %inserted_3 = tensor.insert %25 into %arg6[%arg4] : tensor + %inserted_4 = tensor.insert %19 into %arg5[] : tensor + affine.yield %inserted_4, %inserted_3 : tensor, tensor + } + %15 = bufferization.to_memref %14#1 : memref + memref.copy %15, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu/orig.mlir new file mode 100644 index 000000000000..2ab59ccd4bc0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu/orig.mlir @@ -0,0 +1,73 @@ +#set = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_segment_reduce_lengths_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c0_i32 = arith.constant 0 : i32 + %c2_i32 = arith.constant 2 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c3_i32 = arith.constant 3 : i32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %true = arith.constant true + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %0 = arith.index_cast %arg2 : i32 to index + %1 = arith.cmpi eq, %arg2, %c2_i32 : i32 + %2 = arith.cmpi eq, %arg2, %c0_i32 : i32 + %3 = scf.if %1 -> (f32) { + scf.yield %cst : f32 + } else { + %8 = arith.cmpi eq, %arg2, %c3_i32 : i32 + %9 = arith.select %8, %cst_0, %cst_1 : f32 + scf.yield %9 : f32 + } + %4 = scf.if %2 -> (i1) { + scf.yield %true : i1 + } else { + %8 = arith.cmpi eq, %arg2, %c1_i32 : i32 + scf.yield %8 : i1 + } + %5 = arith.addi %0, %c-1 : index + %6 = arith.cmpi eq, %5, %c0 : index + %7 = affine.for %arg4 = 0 to 16 iter_args(%arg5 = %c0_i32) -> (i32) { + %8 = affine.load %arg1[%arg4] : memref + %9 = arith.index_cast %8 : i32 to index + %10 = arith.index_cast %arg5 : i32 to index + %11 = arith.addi %10, %9 : index + %12 = arith.index_cast %11 : index to i32 + %13 = scf.for %arg6 = %c0 to %9 step %c1 iter_args(%arg7 = %3) -> (f32) { + %17 = arith.addi %10, %arg6 : index + %18 = memref.load %arg0[%17] : memref + %19 = scf.if %4 -> (f32) { + %20 = arith.addf %arg7, %18 : f32 + scf.yield %20 : f32 + } else { + %20 = affine.if #set()[%0] -> f32 { + %21 = arith.cmpf ogt, %arg7, %18 : f32 + %22 = arith.select %21, %arg7, %18 : f32 + affine.yield %22 : f32 + } else { + %21 = arith.cmpf olt, %arg7, %18 : f32 + %22 = arith.select %21, %arg7, %18 : f32 + affine.yield %22 : f32 + } + scf.yield %20 : f32 + } + scf.yield %19 : f32 + } + %14 = arith.cmpi ne, %8, %c0_i32 : i32 + %15 = arith.andi %6, %14 : i1 + %16 = scf.if %15 -> (f32) { + %17 = arith.sitofp %8 : i32 to f32 + %18 = arith.divf %13, %17 : f32 + scf.yield %18 : f32 + } else { + scf.yield %13 : f32 + } + affine.store %16, %arg3[%arg4] : memref + affine.yield %12 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu/raised.mlir new file mode 100644 index 000000000000..c28ab151d1d1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu/raised.mlir @@ -0,0 +1,63 @@ +#map = affine_map<()[s0] -> (s0 - 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_segment_reduce_lengths_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c0_i32 = arith.constant 0 : i32 + %c2_i32 = arith.constant 2 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c3_i32 = arith.constant 3 : i32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %true = arith.constant true + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %0 = arith.index_cast %arg2 : i32 to index + %1 = arith.cmpi eq, %arg2, %c2_i32 : i32 + %2 = arith.cmpi eq, %arg2, %c0_i32 : i32 + %3 = arith.cmpi eq, %arg2, %c3_i32 : i32 + %4 = arith.select %3, %cst_0, %cst_1 : f32 + %5 = arith.select %1, %cst, %4 : f32 + %6 = arith.cmpi eq, %arg2, %c1_i32 : i32 + %7 = arith.select %2, %true, %6 : i1 + %8 = arith.addi %0, %c-1 : index + %9 = arith.cmpi eq, %8, %c0 : index + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg4 = 0 to 16 { + %10 = affine.load %alloca[] : memref + %11 = affine.load %arg1[%arg4] : memref + %12 = arith.index_cast %11 : i32 to index + %13 = arith.index_cast %10 : i32 to index + %14 = arith.addi %13, %12 : index + %15 = arith.index_cast %14 : index to i32 + %16 = scf.for %arg5 = %c0 to %12 step %c1 iter_args(%arg6 = %5) -> (f32) { + %22 = arith.addi %13, %arg5 : index + %23 = memref.load %arg0[%22] : memref + %24 = scf.if %7 -> (f32) { + %25 = arith.addf %arg6, %23 : f32 + scf.yield %25 : f32 + } else { + %25 = affine.apply #map()[%0] + %26 = arith.cmpi eq, %25, %c0 : index + %27 = arith.cmpf ogt, %arg6, %23 : f32 + %28 = arith.select %27, %arg6, %23 : f32 + %29 = arith.cmpf olt, %arg6, %23 : f32 + %30 = arith.select %29, %arg6, %23 : f32 + %31 = arith.select %26, %28, %30 : f32 + scf.yield %31 : f32 + } + scf.yield %24 : f32 + } + %17 = arith.cmpi ne, %11, %c0_i32 : i32 + %18 = arith.andi %9, %17 : i1 + %19 = arith.sitofp %11 : i32 to f32 + %20 = arith.divf %16, %19 : f32 + %21 = arith.select %18, %20, %16 : f32 + affine.store %21, %arg3[%arg4] : memref + affine.store %15, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu_debuf.mlir new file mode 100644 index 000000000000..13dee48a227a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu_debuf.mlir @@ -0,0 +1,69 @@ +#map = affine_map<()[s0] -> (s0 - 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_segment_reduce_lengths_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %true = arith.constant true + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %c3_i32 = arith.constant 3 : i32 + %cst_1 = arith.constant -3.40282347E+38 : f32 + %c2_i32 = arith.constant 2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c-1 = arith.constant -1 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = arith.index_cast %arg2 : i32 to index + %4 = arith.cmpi eq, %arg2, %c2_i32 : i32 + %5 = arith.cmpi eq, %arg2, %c0_i32 : i32 + %6 = arith.cmpi eq, %arg2, %c3_i32 : i32 + %7 = arith.select %6, %cst_0, %cst : f32 + %8 = arith.select %4, %cst_1, %7 : f32 + %9 = arith.cmpi eq, %arg2, %c1_i32 : i32 + %10 = arith.select %5, %true, %9 : i1 + %11 = arith.addi %3, %c-1 : index + %12 = arith.cmpi eq, %11, %c0 : index + %13 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %13[] : tensor + %14:2 = affine.for %arg4 = 0 to 16 iter_args(%arg5 = %inserted, %arg6 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg5[] : tensor + %extracted_2 = tensor.extract %1[%arg4] : tensor + %16 = arith.index_cast %extracted_2 : i32 to index + %17 = arith.index_cast %extracted : i32 to index + %18 = arith.addi %17, %16 : index + %19 = arith.index_cast %18 : index to i32 + %20 = scf.for %arg7 = %c0 to %16 step %c1 iter_args(%arg8 = %8) -> (f32) { + %26 = arith.addi %17, %arg7 : index + %extracted_5 = tensor.extract %2[%26] : tensor + %27 = scf.if %10 -> (f32) { + %28 = arith.addf %arg8, %extracted_5 : f32 + scf.yield %28 : f32 + } else { + %28 = affine.apply #map()[%3] + %29 = arith.cmpi eq, %28, %c0 : index + %30 = arith.cmpf ogt, %arg8, %extracted_5 : f32 + %31 = arith.select %30, %arg8, %extracted_5 : f32 + %32 = arith.cmpf olt, %arg8, %extracted_5 : f32 + %33 = arith.select %32, %arg8, %extracted_5 : f32 + %34 = arith.select %29, %31, %33 : f32 + scf.yield %34 : f32 + } + scf.yield %27 : f32 + } + %21 = arith.cmpi ne, %extracted_2, %c0_i32 : i32 + %22 = arith.andi %12, %21 : i1 + %23 = arith.sitofp %extracted_2 : i32 to f32 + %24 = arith.divf %20, %23 : f32 + %25 = arith.select %22, %24, %20 : f32 + %inserted_3 = tensor.insert %25 into %arg6[%arg4] : tensor + %inserted_4 = tensor.insert %19 into %arg5[] : tensor + affine.yield %inserted_4, %inserted_3 : tensor, tensor + } + %15 = bufferization.to_memref %14#1 : memref + memref.copy %15, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu_linalg.mlir new file mode 100644 index 000000000000..c28ab151d1d1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_segment_reduce_lengths_cpu_linalg.mlir @@ -0,0 +1,63 @@ +#map = affine_map<()[s0] -> (s0 - 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_segment_reduce_lengths_cpu(%arg0: memref, %arg1: memref, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c0_i32 = arith.constant 0 : i32 + %c2_i32 = arith.constant 2 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c3_i32 = arith.constant 3 : i32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %true = arith.constant true + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %0 = arith.index_cast %arg2 : i32 to index + %1 = arith.cmpi eq, %arg2, %c2_i32 : i32 + %2 = arith.cmpi eq, %arg2, %c0_i32 : i32 + %3 = arith.cmpi eq, %arg2, %c3_i32 : i32 + %4 = arith.select %3, %cst_0, %cst_1 : f32 + %5 = arith.select %1, %cst, %4 : f32 + %6 = arith.cmpi eq, %arg2, %c1_i32 : i32 + %7 = arith.select %2, %true, %6 : i1 + %8 = arith.addi %0, %c-1 : index + %9 = arith.cmpi eq, %8, %c0 : index + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg4 = 0 to 16 { + %10 = affine.load %alloca[] : memref + %11 = affine.load %arg1[%arg4] : memref + %12 = arith.index_cast %11 : i32 to index + %13 = arith.index_cast %10 : i32 to index + %14 = arith.addi %13, %12 : index + %15 = arith.index_cast %14 : index to i32 + %16 = scf.for %arg5 = %c0 to %12 step %c1 iter_args(%arg6 = %5) -> (f32) { + %22 = arith.addi %13, %arg5 : index + %23 = memref.load %arg0[%22] : memref + %24 = scf.if %7 -> (f32) { + %25 = arith.addf %arg6, %23 : f32 + scf.yield %25 : f32 + } else { + %25 = affine.apply #map()[%0] + %26 = arith.cmpi eq, %25, %c0 : index + %27 = arith.cmpf ogt, %arg6, %23 : f32 + %28 = arith.select %27, %arg6, %23 : f32 + %29 = arith.cmpf olt, %arg6, %23 : f32 + %30 = arith.select %29, %arg6, %23 : f32 + %31 = arith.select %26, %28, %30 : f32 + scf.yield %31 : f32 + } + scf.yield %24 : f32 + } + %17 = arith.cmpi ne, %11, %c0_i32 : i32 + %18 = arith.andi %9, %17 : i1 + %19 = arith.sitofp %11 : i32 to f32 + %20 = arith.divf %16, %19 : f32 + %21 = arith.select %18, %20, %16 : f32 + affine.store %21, %arg3[%arg4] : memref + affine.store %15, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sgn_complex_scalarized.mlir b/issues/aten_c_kernels/results/aten_sgn_complex_scalarized.mlir new file mode 100644 index 000000000000..612208cc2e10 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sgn_complex_scalarized.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sgn_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = func.call @hypotf(%0, %1) : (f32, f32) -> f32 + %3 = arith.cmpf oeq, %2, %cst : f32 + %4 = scf.if %3 -> (f32) { + scf.yield %cst : f32 + } else { + %6 = affine.load %arg0[%arg4] : memref + %7 = arith.divf %6, %2 : f32 + scf.yield %7 : f32 + } + affine.store %4, %arg2[%arg4] : memref + %5 = scf.if %3 -> (f32) { + scf.yield %cst : f32 + } else { + %6 = affine.load %arg1[%arg4] : memref + %7 = arith.divf %6, %2 : f32 + scf.yield %7 : f32 + } + affine.store %5, %arg3[%arg4] : memref + } + return + } + func.func private @hypotf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_sgn_complex_scalarized/debuf.mlir b/issues/aten_c_kernels/results/aten_sgn_complex_scalarized/debuf.mlir new file mode 100644 index 000000000000..c74da60a9aca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sgn_complex_scalarized/debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sgn_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %0, %1 : tensor, tensor, tensor, tensor) outs(%2, %3 : tensor, tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %in_2: f32, %out: f32, %out_3: f32): + %7 = func.call @hypotf(%in, %in_0) : (f32, f32) -> f32 + %8 = arith.cmpf oeq, %7, %cst : f32 + %9 = arith.divf %in_1, %7 : f32 + %10 = arith.select %8, %cst, %9 : f32 + %11 = arith.divf %in_2, %7 : f32 + %12 = arith.select %8, %cst, %11 : f32 + linalg.yield %10, %12 : f32, f32 + } -> (tensor, tensor) + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg3 : memref to memref + %6 = bufferization.to_memref %4#0 : memref + memref.copy %6, %arg2 : memref to memref + return + } + func.func private @hypotf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sgn_complex_scalarized/matched.mlir b/issues/aten_c_kernels/results/aten_sgn_complex_scalarized/matched.mlir new file mode 100644 index 000000000000..c74da60a9aca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sgn_complex_scalarized/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sgn_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %0, %1 : tensor, tensor, tensor, tensor) outs(%2, %3 : tensor, tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %in_2: f32, %out: f32, %out_3: f32): + %7 = func.call @hypotf(%in, %in_0) : (f32, f32) -> f32 + %8 = arith.cmpf oeq, %7, %cst : f32 + %9 = arith.divf %in_1, %7 : f32 + %10 = arith.select %8, %cst, %9 : f32 + %11 = arith.divf %in_2, %7 : f32 + %12 = arith.select %8, %cst, %11 : f32 + linalg.yield %10, %12 : f32, f32 + } -> (tensor, tensor) + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg3 : memref to memref + %6 = bufferization.to_memref %4#0 : memref + memref.copy %6, %arg2 : memref to memref + return + } + func.func private @hypotf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sgn_complex_scalarized/orig.mlir b/issues/aten_c_kernels/results/aten_sgn_complex_scalarized/orig.mlir new file mode 100644 index 000000000000..612208cc2e10 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sgn_complex_scalarized/orig.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sgn_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = func.call @hypotf(%0, %1) : (f32, f32) -> f32 + %3 = arith.cmpf oeq, %2, %cst : f32 + %4 = scf.if %3 -> (f32) { + scf.yield %cst : f32 + } else { + %6 = affine.load %arg0[%arg4] : memref + %7 = arith.divf %6, %2 : f32 + scf.yield %7 : f32 + } + affine.store %4, %arg2[%arg4] : memref + %5 = scf.if %3 -> (f32) { + scf.yield %cst : f32 + } else { + %6 = affine.load %arg1[%arg4] : memref + %7 = arith.divf %6, %2 : f32 + scf.yield %7 : f32 + } + affine.store %5, %arg3[%arg4] : memref + } + return + } + func.func private @hypotf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_sgn_complex_scalarized/raised.mlir b/issues/aten_c_kernels/results/aten_sgn_complex_scalarized/raised.mlir new file mode 100644 index 000000000000..9e30846839cd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sgn_complex_scalarized/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sgn_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg0, %arg1 : memref, memref, memref, memref) outs(%arg2, %arg3 : memref, memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %in_2: f32, %out: f32, %out_3: f32): + %0 = func.call @hypotf(%in, %in_0) : (f32, f32) -> f32 + %1 = arith.cmpf oeq, %0, %cst : f32 + %2 = arith.divf %in_1, %0 : f32 + %3 = arith.select %1, %cst, %2 : f32 + %4 = arith.divf %in_2, %0 : f32 + %5 = arith.select %1, %cst, %4 : f32 + linalg.yield %3, %5 : f32, f32 + } + return + } + func.func private @hypotf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sgn_complex_scalarized_debuf.mlir b/issues/aten_c_kernels/results/aten_sgn_complex_scalarized_debuf.mlir new file mode 100644 index 000000000000..c74da60a9aca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sgn_complex_scalarized_debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sgn_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %0, %1 : tensor, tensor, tensor, tensor) outs(%2, %3 : tensor, tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %in_2: f32, %out: f32, %out_3: f32): + %7 = func.call @hypotf(%in, %in_0) : (f32, f32) -> f32 + %8 = arith.cmpf oeq, %7, %cst : f32 + %9 = arith.divf %in_1, %7 : f32 + %10 = arith.select %8, %cst, %9 : f32 + %11 = arith.divf %in_2, %7 : f32 + %12 = arith.select %8, %cst, %11 : f32 + linalg.yield %10, %12 : f32, f32 + } -> (tensor, tensor) + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg3 : memref to memref + %6 = bufferization.to_memref %4#0 : memref + memref.copy %6, %arg2 : memref to memref + return + } + func.func private @hypotf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sgn_complex_scalarized_linalg.mlir b/issues/aten_c_kernels/results/aten_sgn_complex_scalarized_linalg.mlir new file mode 100644 index 000000000000..9e30846839cd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sgn_complex_scalarized_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sgn_complex_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg0, %arg1 : memref, memref, memref, memref) outs(%arg2, %arg3 : memref, memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %in_2: f32, %out: f32, %out_3: f32): + %0 = func.call @hypotf(%in, %in_0) : (f32, f32) -> f32 + %1 = arith.cmpf oeq, %0, %cst : f32 + %2 = arith.divf %in_1, %0 : f32 + %3 = arith.select %1, %cst, %2 : f32 + %4 = arith.divf %in_2, %0 : f32 + %5 = arith.select %1, %cst, %4 : f32 + linalg.yield %3, %5 : f32, f32 + } + return + } + func.func private @hypotf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_shrink_backward.mlir b/issues/aten_c_kernels/results/aten_shrink_backward.mlir new file mode 100644 index 000000000000..141689908744 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_shrink_backward.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_shrink_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %false = arith.constant false + %0 = arith.negf %arg2 : f32 + affine.for %arg4 = 0 to 4096 { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.cmpf oge, %1, %0 : f32 + %3 = scf.if %2 -> (i1) { + %5 = arith.cmpf ole, %1, %arg2 : f32 + scf.yield %5 : i1 + } else { + scf.yield %false : i1 + } + %4 = scf.if %3 -> (f32) { + scf.yield %cst : f32 + } else { + %5 = affine.load %arg0[%arg4] : memref + scf.yield %5 : f32 + } + affine.store %4, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_shrink_backward/debuf.mlir b/issues/aten_c_kernels/results/aten_shrink_backward/debuf.mlir new file mode 100644 index 000000000000..ee8eb7f6830d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_shrink_backward/debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_shrink_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.negf %arg2 : f32 + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %6 = arith.cmpf oge, %in, %3 : f32 + %7 = arith.cmpf ole, %in, %arg2 : f32 + %8 = arith.select %6, %7, %false : i1 + %9 = arith.select %8, %cst, %in_0 : f32 + linalg.yield %9 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_shrink_backward/matched.mlir b/issues/aten_c_kernels/results/aten_shrink_backward/matched.mlir new file mode 100644 index 000000000000..ee8eb7f6830d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_shrink_backward/matched.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_shrink_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.negf %arg2 : f32 + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %6 = arith.cmpf oge, %in, %3 : f32 + %7 = arith.cmpf ole, %in, %arg2 : f32 + %8 = arith.select %6, %7, %false : i1 + %9 = arith.select %8, %cst, %in_0 : f32 + linalg.yield %9 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_shrink_backward/orig.mlir b/issues/aten_c_kernels/results/aten_shrink_backward/orig.mlir new file mode 100644 index 000000000000..141689908744 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_shrink_backward/orig.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_shrink_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %false = arith.constant false + %0 = arith.negf %arg2 : f32 + affine.for %arg4 = 0 to 4096 { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.cmpf oge, %1, %0 : f32 + %3 = scf.if %2 -> (i1) { + %5 = arith.cmpf ole, %1, %arg2 : f32 + scf.yield %5 : i1 + } else { + scf.yield %false : i1 + } + %4 = scf.if %3 -> (f32) { + scf.yield %cst : f32 + } else { + %5 = affine.load %arg0[%arg4] : memref + scf.yield %5 : f32 + } + affine.store %4, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_shrink_backward/raised.mlir b/issues/aten_c_kernels/results/aten_shrink_backward/raised.mlir new file mode 100644 index 000000000000..98e0d77215c7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_shrink_backward/raised.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_shrink_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %false = arith.constant false + %0 = arith.negf %arg2 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %1 = arith.cmpf oge, %in, %0 : f32 + %2 = arith.cmpf ole, %in, %arg2 : f32 + %3 = arith.select %1, %2, %false : i1 + %4 = arith.select %3, %cst, %in_0 : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_shrink_backward_debuf.mlir b/issues/aten_c_kernels/results/aten_shrink_backward_debuf.mlir new file mode 100644 index 000000000000..ee8eb7f6830d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_shrink_backward_debuf.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_shrink_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %false = arith.constant false + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.negf %arg2 : f32 + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %6 = arith.cmpf oge, %in, %3 : f32 + %7 = arith.cmpf ole, %in, %arg2 : f32 + %8 = arith.select %6, %7, %false : i1 + %9 = arith.select %8, %cst, %in_0 : f32 + linalg.yield %9 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_shrink_backward_linalg.mlir b/issues/aten_c_kernels/results/aten_shrink_backward_linalg.mlir new file mode 100644 index 000000000000..98e0d77215c7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_shrink_backward_linalg.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_shrink_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %false = arith.constant false + %0 = arith.negf %arg2 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %1 = arith.cmpf oge, %in, %0 : f32 + %2 = arith.cmpf ole, %in, %arg2 : f32 + %3 = arith.select %1, %2, %false : i1 + %4 = arith.select %3, %cst, %in_0 : f32 + linalg.yield %4 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sigmoid.mlir b/issues/aten_c_kernels/results/aten_sigmoid.mlir new file mode 100644 index 000000000000..92beb10640b8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sigmoid.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sigmoid(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.negf %0 : f32 + %2 = math.exp %1 : f32 + %3 = arith.addf %2, %cst : f32 + %4 = arith.divf %cst, %3 : f32 + affine.store %4, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sigmoid/debuf.mlir b/issues/aten_c_kernels/results/aten_sigmoid/debuf.mlir new file mode 100644 index 000000000000..2344c9cf6760 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sigmoid/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sigmoid(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.negf %in : f32 + %5 = math.exp %4 : f32 + %6 = arith.addf %5, %cst : f32 + %7 = arith.divf %cst, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sigmoid/matched.mlir b/issues/aten_c_kernels/results/aten_sigmoid/matched.mlir new file mode 100644 index 000000000000..2344c9cf6760 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sigmoid/matched.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sigmoid(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.negf %in : f32 + %5 = math.exp %4 : f32 + %6 = arith.addf %5, %cst : f32 + %7 = arith.divf %cst, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sigmoid/orig.mlir b/issues/aten_c_kernels/results/aten_sigmoid/orig.mlir new file mode 100644 index 000000000000..92beb10640b8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sigmoid/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sigmoid(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.negf %0 : f32 + %2 = math.exp %1 : f32 + %3 = arith.addf %2, %cst : f32 + %4 = arith.divf %cst, %3 : f32 + affine.store %4, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sigmoid/raised.mlir b/issues/aten_c_kernels/results/aten_sigmoid/raised.mlir new file mode 100644 index 000000000000..7c2b9f7e710c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sigmoid/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sigmoid(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.negf %in : f32 + %1 = math.exp %0 : f32 + %2 = arith.addf %1, %cst : f32 + %3 = arith.divf %cst, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sigmoid_backward.mlir b/issues/aten_c_kernels/results/aten_sigmoid_backward.mlir new file mode 100644 index 000000000000..d32262c4aea1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sigmoid_backward.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sigmoid_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.subf %cst, %1 : f32 + %3 = arith.mulf %0, %2 : f32 + %4 = arith.mulf %3, %1 : f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sigmoid_backward/debuf.mlir b/issues/aten_c_kernels/results/aten_sigmoid_backward/debuf.mlir new file mode 100644 index 000000000000..81fb57aacfd6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sigmoid_backward/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sigmoid_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %cst, %in_0 : f32 + %6 = arith.mulf %in, %5 : f32 + %7 = arith.mulf %6, %in_0 : f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sigmoid_backward/matched.mlir b/issues/aten_c_kernels/results/aten_sigmoid_backward/matched.mlir new file mode 100644 index 000000000000..81fb57aacfd6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sigmoid_backward/matched.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sigmoid_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %cst, %in_0 : f32 + %6 = arith.mulf %in, %5 : f32 + %7 = arith.mulf %6, %in_0 : f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sigmoid_backward/orig.mlir b/issues/aten_c_kernels/results/aten_sigmoid_backward/orig.mlir new file mode 100644 index 000000000000..d32262c4aea1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sigmoid_backward/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sigmoid_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.subf %cst, %1 : f32 + %3 = arith.mulf %0, %2 : f32 + %4 = arith.mulf %3, %1 : f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sigmoid_backward/raised.mlir b/issues/aten_c_kernels/results/aten_sigmoid_backward/raised.mlir new file mode 100644 index 000000000000..c995a6639969 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sigmoid_backward/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sigmoid_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.subf %cst, %in_0 : f32 + %1 = arith.mulf %in, %0 : f32 + %2 = arith.mulf %1, %in_0 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sigmoid_backward_debuf.mlir b/issues/aten_c_kernels/results/aten_sigmoid_backward_debuf.mlir new file mode 100644 index 000000000000..81fb57aacfd6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sigmoid_backward_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sigmoid_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %cst, %in_0 : f32 + %6 = arith.mulf %in, %5 : f32 + %7 = arith.mulf %6, %in_0 : f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sigmoid_backward_linalg.mlir b/issues/aten_c_kernels/results/aten_sigmoid_backward_linalg.mlir new file mode 100644 index 000000000000..c995a6639969 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sigmoid_backward_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sigmoid_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.subf %cst, %in_0 : f32 + %1 = arith.mulf %in, %0 : f32 + %2 = arith.mulf %1, %in_0 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sigmoid_debuf.mlir b/issues/aten_c_kernels/results/aten_sigmoid_debuf.mlir new file mode 100644 index 000000000000..2344c9cf6760 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sigmoid_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sigmoid(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.negf %in : f32 + %5 = math.exp %4 : f32 + %6 = arith.addf %5, %cst : f32 + %7 = arith.divf %cst, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sigmoid_linalg.mlir b/issues/aten_c_kernels/results/aten_sigmoid_linalg.mlir new file mode 100644 index 000000000000..7c2b9f7e710c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sigmoid_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sigmoid(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.negf %in : f32 + %1 = math.exp %0 : f32 + %2 = arith.addf %1, %cst : f32 + %3 = arith.divf %cst, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sign.mlir b/issues/aten_c_kernels/results/aten_sign.mlir new file mode 100644 index 000000000000..e0a7c1f28a54 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sign.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sign(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.cmpf olt, %cst, %0 : f32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.cmpf olt, %0, %cst : f32 + %4 = arith.extui %3 : i1 to i32 + %5 = arith.subi %2, %4 : i32 + %6 = arith.sitofp %5 : i32 to f32 + affine.store %6, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sign/debuf.mlir b/issues/aten_c_kernels/results/aten_sign/debuf.mlir new file mode 100644 index 000000000000..afabd2c7788c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sign/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sign(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %cst, %in : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.cmpf olt, %in, %cst : f32 + %7 = arith.extui %6 : i1 to i32 + %8 = arith.subi %5, %7 : i32 + %9 = arith.sitofp %8 : i32 to f32 + linalg.yield %9 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sign/matched.mlir b/issues/aten_c_kernels/results/aten_sign/matched.mlir new file mode 100644 index 000000000000..afabd2c7788c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sign/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sign(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %cst, %in : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.cmpf olt, %in, %cst : f32 + %7 = arith.extui %6 : i1 to i32 + %8 = arith.subi %5, %7 : i32 + %9 = arith.sitofp %8 : i32 to f32 + linalg.yield %9 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sign/orig.mlir b/issues/aten_c_kernels/results/aten_sign/orig.mlir new file mode 100644 index 000000000000..e0a7c1f28a54 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sign/orig.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sign(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.cmpf olt, %cst, %0 : f32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.cmpf olt, %0, %cst : f32 + %4 = arith.extui %3 : i1 to i32 + %5 = arith.subi %2, %4 : i32 + %6 = arith.sitofp %5 : i32 to f32 + affine.store %6, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sign/raised.mlir b/issues/aten_c_kernels/results/aten_sign/raised.mlir new file mode 100644 index 000000000000..b64361c34e24 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sign/raised.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sign(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %cst, %in : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.cmpf olt, %in, %cst : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.subi %1, %3 : i32 + %5 = arith.sitofp %4 : i32 to f32 + linalg.yield %5 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sign_debuf.mlir b/issues/aten_c_kernels/results/aten_sign_debuf.mlir new file mode 100644 index 000000000000..afabd2c7788c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sign_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sign(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %cst, %in : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.cmpf olt, %in, %cst : f32 + %7 = arith.extui %6 : i1 to i32 + %8 = arith.subi %5, %7 : i32 + %9 = arith.sitofp %8 : i32 to f32 + linalg.yield %9 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sign_linalg.mlir b/issues/aten_c_kernels/results/aten_sign_linalg.mlir new file mode 100644 index 000000000000..b64361c34e24 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sign_linalg.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sign(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %cst, %in : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.cmpf olt, %in, %cst : f32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.subi %1, %3 : i32 + %5 = arith.sitofp %4 : i32 to f32 + linalg.yield %5 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_signbit.mlir b/issues/aten_c_kernels/results/aten_signbit.mlir new file mode 100644 index 000000000000..da81131074b1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_signbit.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_signbit(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.cmpf olt, %0, %cst : f32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.sitofp %2 : i32 to f32 + affine.store %3, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_signbit/debuf.mlir b/issues/aten_c_kernels/results/aten_signbit/debuf.mlir new file mode 100644 index 000000000000..6000ef8b0b69 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_signbit/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_signbit(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %cst : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.sitofp %5 : i32 to f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_signbit/matched.mlir b/issues/aten_c_kernels/results/aten_signbit/matched.mlir new file mode 100644 index 000000000000..6000ef8b0b69 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_signbit/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_signbit(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %cst : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.sitofp %5 : i32 to f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_signbit/orig.mlir b/issues/aten_c_kernels/results/aten_signbit/orig.mlir new file mode 100644 index 000000000000..da81131074b1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_signbit/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_signbit(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.cmpf olt, %0, %cst : f32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.sitofp %2 : i32 to f32 + affine.store %3, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_signbit/raised.mlir b/issues/aten_c_kernels/results/aten_signbit/raised.mlir new file mode 100644 index 000000000000..0996d0bc0e9b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_signbit/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_signbit(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %cst : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_signbit_debuf.mlir b/issues/aten_c_kernels/results/aten_signbit_debuf.mlir new file mode 100644 index 000000000000..6000ef8b0b69 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_signbit_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_signbit(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.cmpf olt, %in, %cst : f32 + %5 = arith.extui %4 : i1 to i32 + %6 = arith.sitofp %5 : i32 to f32 + linalg.yield %6 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_signbit_linalg.mlir b/issues/aten_c_kernels/results/aten_signbit_linalg.mlir new file mode 100644 index 000000000000..0996d0bc0e9b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_signbit_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_signbit(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.cmpf olt, %in, %cst : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.sitofp %1 : i32 to f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_silu.mlir b/issues/aten_c_kernels/results/aten_silu.mlir new file mode 100644 index 000000000000..1866bb639601 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.negf %0 : f32 + %2 = math.exp %1 : f32 + %3 = arith.addf %2, %cst : f32 + %4 = arith.divf %0, %3 : f32 + affine.store %4, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_silu/debuf.mlir b/issues/aten_c_kernels/results/aten_silu/debuf.mlir new file mode 100644 index 000000000000..03a94f6c027c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.negf %in : f32 + %5 = math.exp %4 : f32 + %6 = arith.addf %5, %cst : f32 + %7 = arith.divf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_silu/matched.mlir b/issues/aten_c_kernels/results/aten_silu/matched.mlir new file mode 100644 index 000000000000..03a94f6c027c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu/matched.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.negf %in : f32 + %5 = math.exp %4 : f32 + %6 = arith.addf %5, %cst : f32 + %7 = arith.divf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_silu/orig.mlir b/issues/aten_c_kernels/results/aten_silu/orig.mlir new file mode 100644 index 000000000000..1866bb639601 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.negf %0 : f32 + %2 = math.exp %1 : f32 + %3 = arith.addf %2, %cst : f32 + %4 = arith.divf %0, %3 : f32 + affine.store %4, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_silu/raised.mlir b/issues/aten_c_kernels/results/aten_silu/raised.mlir new file mode 100644 index 000000000000..6d794b9b9020 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.negf %in : f32 + %1 = math.exp %0 : f32 + %2 = arith.addf %1, %cst : f32 + %3 = arith.divf %in, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_silu_backward.mlir b/issues/aten_c_kernels/results/aten_silu_backward.mlir new file mode 100644 index 000000000000..8258101e4e11 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu_backward.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.negf %1 : f32 + %3 = math.exp %2 : f32 + %4 = arith.addf %3, %cst : f32 + %5 = arith.divf %cst, %4 : f32 + %6 = arith.mulf %0, %5 : f32 + %7 = arith.subf %cst, %5 : f32 + %8 = arith.mulf %1, %7 : f32 + %9 = arith.addf %8, %cst : f32 + %10 = arith.mulf %6, %9 : f32 + affine.store %10, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_silu_backward/debuf.mlir b/issues/aten_c_kernels/results/aten_silu_backward/debuf.mlir new file mode 100644 index 000000000000..12b613bd28f8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu_backward/debuf.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.negf %in_0 : f32 + %6 = math.exp %5 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.divf %cst, %7 : f32 + %9 = arith.mulf %in, %8 : f32 + %10 = arith.subf %cst, %8 : f32 + %11 = arith.mulf %in_0, %10 : f32 + %12 = arith.addf %11, %cst : f32 + %13 = arith.mulf %9, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_silu_backward/matched.mlir b/issues/aten_c_kernels/results/aten_silu_backward/matched.mlir new file mode 100644 index 000000000000..12b613bd28f8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu_backward/matched.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.negf %in_0 : f32 + %6 = math.exp %5 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.divf %cst, %7 : f32 + %9 = arith.mulf %in, %8 : f32 + %10 = arith.subf %cst, %8 : f32 + %11 = arith.mulf %in_0, %10 : f32 + %12 = arith.addf %11, %cst : f32 + %13 = arith.mulf %9, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_silu_backward/orig.mlir b/issues/aten_c_kernels/results/aten_silu_backward/orig.mlir new file mode 100644 index 000000000000..8258101e4e11 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu_backward/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.negf %1 : f32 + %3 = math.exp %2 : f32 + %4 = arith.addf %3, %cst : f32 + %5 = arith.divf %cst, %4 : f32 + %6 = arith.mulf %0, %5 : f32 + %7 = arith.subf %cst, %5 : f32 + %8 = arith.mulf %1, %7 : f32 + %9 = arith.addf %8, %cst : f32 + %10 = arith.mulf %6, %9 : f32 + affine.store %10, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_silu_backward/raised.mlir b/issues/aten_c_kernels/results/aten_silu_backward/raised.mlir new file mode 100644 index 000000000000..6d9a06d116d2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu_backward/raised.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.negf %in_0 : f32 + %1 = math.exp %0 : f32 + %2 = arith.addf %1, %cst : f32 + %3 = arith.divf %cst, %2 : f32 + %4 = arith.mulf %in, %3 : f32 + %5 = arith.subf %cst, %3 : f32 + %6 = arith.mulf %in_0, %5 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.mulf %4, %7 : f32 + linalg.yield %8 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_silu_backward_debuf.mlir b/issues/aten_c_kernels/results/aten_silu_backward_debuf.mlir new file mode 100644 index 000000000000..12b613bd28f8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu_backward_debuf.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.negf %in_0 : f32 + %6 = math.exp %5 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.divf %cst, %7 : f32 + %9 = arith.mulf %in, %8 : f32 + %10 = arith.subf %cst, %8 : f32 + %11 = arith.mulf %in_0, %10 : f32 + %12 = arith.addf %11, %cst : f32 + %13 = arith.mulf %9, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_silu_backward_linalg.mlir b/issues/aten_c_kernels/results/aten_silu_backward_linalg.mlir new file mode 100644 index 000000000000..6d9a06d116d2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu_backward_linalg.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.negf %in_0 : f32 + %1 = math.exp %0 : f32 + %2 = arith.addf %1, %cst : f32 + %3 = arith.divf %cst, %2 : f32 + %4 = arith.mulf %in, %3 : f32 + %5 = arith.subf %cst, %3 : f32 + %6 = arith.mulf %in_0, %5 : f32 + %7 = arith.addf %6, %cst : f32 + %8 = arith.mulf %4, %7 : f32 + linalg.yield %8 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_silu_cpu.mlir b/issues/aten_c_kernels/results/aten_silu_cpu.mlir new file mode 100644 index 000000000000..14302ab98bcf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu_cpu.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.negf %0 : f32 + %2 = math.exp %1 : f32 + %3 = arith.addf %2, %cst : f32 + %4 = arith.divf %0, %3 : f32 + affine.store %4, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_silu_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_silu_cpu/debuf.mlir new file mode 100644 index 000000000000..9f0678c94d2a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu_cpu/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.negf %in : f32 + %5 = math.exp %4 : f32 + %6 = arith.addf %5, %cst : f32 + %7 = arith.divf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_silu_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_silu_cpu/matched.mlir new file mode 100644 index 000000000000..9f0678c94d2a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu_cpu/matched.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.negf %in : f32 + %5 = math.exp %4 : f32 + %6 = arith.addf %5, %cst : f32 + %7 = arith.divf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_silu_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_silu_cpu/orig.mlir new file mode 100644 index 000000000000..14302ab98bcf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu_cpu/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.negf %0 : f32 + %2 = math.exp %1 : f32 + %3 = arith.addf %2, %cst : f32 + %4 = arith.divf %0, %3 : f32 + affine.store %4, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_silu_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_silu_cpu/raised.mlir new file mode 100644 index 000000000000..a86f11ebdb26 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu_cpu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.negf %in : f32 + %1 = math.exp %0 : f32 + %2 = arith.addf %1, %cst : f32 + %3 = arith.divf %in, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_silu_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_silu_cpu_debuf.mlir new file mode 100644 index 000000000000..9f0678c94d2a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu_cpu_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.negf %in : f32 + %5 = math.exp %4 : f32 + %6 = arith.addf %5, %cst : f32 + %7 = arith.divf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_silu_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_silu_cpu_linalg.mlir new file mode 100644 index 000000000000..a86f11ebdb26 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu_cpu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.negf %in : f32 + %1 = math.exp %0 : f32 + %2 = arith.addf %1, %cst : f32 + %3 = arith.divf %in, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_silu_debuf.mlir b/issues/aten_c_kernels/results/aten_silu_debuf.mlir new file mode 100644 index 000000000000..03a94f6c027c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.negf %in : f32 + %5 = math.exp %4 : f32 + %6 = arith.addf %5, %cst : f32 + %7 = arith.divf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_silu_linalg.mlir b/issues/aten_c_kernels/results/aten_silu_linalg.mlir new file mode 100644 index 000000000000..6d794b9b9020 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_silu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_silu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.negf %in : f32 + %1 = math.exp %0 : f32 + %2 = arith.addf %1, %cst : f32 + %3 = arith.divf %in, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sin.mlir b/issues/aten_c_kernels/results/aten_sin.mlir new file mode 100644 index 000000000000..df40a0327bb7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sin.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sin(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @sinf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_sin/debuf.mlir b/issues/aten_c_kernels/results/aten_sin/debuf.mlir new file mode 100644 index 000000000000..6336da773eaa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sin/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sin(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.sin %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sin/matched.mlir b/issues/aten_c_kernels/results/aten_sin/matched.mlir new file mode 100644 index 000000000000..6336da773eaa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sin/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sin(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.sin %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sin/orig.mlir b/issues/aten_c_kernels/results/aten_sin/orig.mlir new file mode 100644 index 000000000000..df40a0327bb7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sin/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sin(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @sinf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_sin/raised.mlir b/issues/aten_c_kernels/results/aten_sin/raised.mlir new file mode 100644 index 000000000000..5c9a5dc4623c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sin/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sin(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.sin %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sin_debuf.mlir b/issues/aten_c_kernels/results/aten_sin_debuf.mlir new file mode 100644 index 000000000000..6336da773eaa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sin_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sin(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.sin %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sin_linalg.mlir b/issues/aten_c_kernels/results/aten_sin_linalg.mlir new file mode 100644 index 000000000000..5c9a5dc4623c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sin_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sin(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.sin %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sinc.mlir b/issues/aten_c_kernels/results/aten_sinc.mlir new file mode 100644 index 000000000000..98e58b0e5217 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sinc.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sinc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.14159274 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.cmpf oeq, %0, %cst_1 : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %3 = affine.load %arg0[%arg2] : memref + %4 = arith.mulf %3, %cst : f32 + %5 = func.call @sinf(%4) : (f32) -> f32 + %6 = affine.load %arg0[%arg2] : memref + %7 = arith.mulf %6, %cst : f32 + %8 = arith.divf %5, %7 : f32 + scf.yield %8 : f32 + } + affine.store %2, %arg1[%arg2] : memref + } + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_sinc/debuf.mlir b/issues/aten_c_kernels/results/aten_sinc/debuf.mlir new file mode 100644 index 000000000000..13b20989f440 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sinc/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sinc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 3.14159274 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg0[%3] : memref + %5 = arith.cmpf oeq, %4, %cst : f32 + %6 = scf.if %5 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %7 = memref.load %arg0[%3] : memref + %8 = arith.mulf %7, %cst_1 : f32 + %9 = math.sin %8 : f32 + %10 = memref.load %arg0[%3] : memref + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.divf %9, %11 : f32 + scf.yield %12 : f32 + } + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sinc/matched.mlir b/issues/aten_c_kernels/results/aten_sinc/matched.mlir new file mode 100644 index 000000000000..13b20989f440 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sinc/matched.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sinc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 3.14159274 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg0[%3] : memref + %5 = arith.cmpf oeq, %4, %cst : f32 + %6 = scf.if %5 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %7 = memref.load %arg0[%3] : memref + %8 = arith.mulf %7, %cst_1 : f32 + %9 = math.sin %8 : f32 + %10 = memref.load %arg0[%3] : memref + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.divf %9, %11 : f32 + scf.yield %12 : f32 + } + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sinc/orig.mlir b/issues/aten_c_kernels/results/aten_sinc/orig.mlir new file mode 100644 index 000000000000..98e58b0e5217 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sinc/orig.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sinc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.14159274 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.cmpf oeq, %0, %cst_1 : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %3 = affine.load %arg0[%arg2] : memref + %4 = arith.mulf %3, %cst : f32 + %5 = func.call @sinf(%4) : (f32) -> f32 + %6 = affine.load %arg0[%arg2] : memref + %7 = arith.mulf %6, %cst : f32 + %8 = arith.divf %5, %7 : f32 + scf.yield %8 : f32 + } + affine.store %2, %arg1[%arg2] : memref + } + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_sinc/raised.mlir b/issues/aten_c_kernels/results/aten_sinc/raised.mlir new file mode 100644 index 000000000000..c92520f5268f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sinc/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sinc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.14159274 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg0[%0] : memref + %2 = arith.cmpf oeq, %1, %cst_1 : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %4 = memref.load %arg0[%0] : memref + %5 = arith.mulf %4, %cst : f32 + %6 = math.sin %5 : f32 + %7 = memref.load %arg0[%0] : memref + %8 = arith.mulf %7, %cst : f32 + %9 = arith.divf %6, %8 : f32 + scf.yield %9 : f32 + } + linalg.yield %3 : f32 + } + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sinc_debuf.mlir b/issues/aten_c_kernels/results/aten_sinc_debuf.mlir new file mode 100644 index 000000000000..13b20989f440 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sinc_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sinc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 3.14159274 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg0[%3] : memref + %5 = arith.cmpf oeq, %4, %cst : f32 + %6 = scf.if %5 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %7 = memref.load %arg0[%3] : memref + %8 = arith.mulf %7, %cst_1 : f32 + %9 = math.sin %8 : f32 + %10 = memref.load %arg0[%3] : memref + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.divf %9, %11 : f32 + scf.yield %12 : f32 + } + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sinc_linalg.mlir b/issues/aten_c_kernels/results/aten_sinc_linalg.mlir new file mode 100644 index 000000000000..c92520f5268f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sinc_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sinc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.14159274 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg0[%0] : memref + %2 = arith.cmpf oeq, %1, %cst_1 : f32 + %3 = scf.if %2 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %4 = memref.load %arg0[%0] : memref + %5 = arith.mulf %4, %cst : f32 + %6 = math.sin %5 : f32 + %7 = memref.load %arg0[%0] : memref + %8 = arith.mulf %7, %cst : f32 + %9 = arith.divf %6, %8 : f32 + scf.yield %9 : f32 + } + linalg.yield %3 : f32 + } + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sinh.mlir b/issues/aten_c_kernels/results/aten_sinh.mlir new file mode 100644 index 000000000000..a97543744993 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sinh.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sinh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @sinhf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @sinhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_sinh/debuf.mlir b/issues/aten_c_kernels/results/aten_sinh/debuf.mlir new file mode 100644 index 000000000000..43c670623628 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sinh/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sinh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @sinhf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @sinhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sinh/matched.mlir b/issues/aten_c_kernels/results/aten_sinh/matched.mlir new file mode 100644 index 000000000000..43c670623628 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sinh/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sinh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @sinhf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @sinhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sinh/orig.mlir b/issues/aten_c_kernels/results/aten_sinh/orig.mlir new file mode 100644 index 000000000000..a97543744993 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sinh/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sinh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @sinhf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @sinhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_sinh/raised.mlir b/issues/aten_c_kernels/results/aten_sinh/raised.mlir new file mode 100644 index 000000000000..554f7f2b2146 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sinh/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sinh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @sinhf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @sinhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sinh_debuf.mlir b/issues/aten_c_kernels/results/aten_sinh_debuf.mlir new file mode 100644 index 000000000000..43c670623628 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sinh_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sinh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @sinhf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @sinhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_sinh_linalg.mlir b/issues/aten_c_kernels/results/aten_sinh_linalg.mlir new file mode 100644 index 000000000000..554f7f2b2146 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sinh_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sinh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @sinhf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @sinhf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu.mlir new file mode 100644 index 000000000000..31dc1f39164c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_backward_input_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 6 { + affine.for %arg6 = 0 to 7 { + affine.for %arg7 = 0 to 8 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %1 = affine.load %arg0[%arg3, %arg5, %arg6, %arg7] : memref + %2 = affine.load %arg1[%arg3, %arg4, %arg8, %arg9, %arg10] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = affine.load %arg2[%arg4, %arg5 + %arg8, %arg6 + %arg9, %arg7 + %arg10] : memref + %5 = arith.addf %4, %3 : f32 + affine.store %5, %arg2[%arg4, %arg5 + %arg8, %arg6 + %arg9, %arg7 + %arg10] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu/debuf.mlir new file mode 100644 index 000000000000..304da11abcba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu/debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d2, d3, d4)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d2, d3, d4, d5, d6, d7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_backward_input_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg2, %c2, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref<2x6x7x8x3x3x3xf32> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["reduction", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%1 : memref<2x6x7x8x3x3x3xf32>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu/matched.mlir new file mode 100644 index 000000000000..304da11abcba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu/matched.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d2, d3, d4)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d2, d3, d4, d5, d6, d7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_backward_input_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg2, %c2, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref<2x6x7x8x3x3x3xf32> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["reduction", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%1 : memref<2x6x7x8x3x3x3xf32>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu/orig.mlir new file mode 100644 index 000000000000..31dc1f39164c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu/orig.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_backward_input_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 6 { + affine.for %arg6 = 0 to 7 { + affine.for %arg7 = 0 to 8 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %1 = affine.load %arg0[%arg3, %arg5, %arg6, %arg7] : memref + %2 = affine.load %arg1[%arg3, %arg4, %arg8, %arg9, %arg10] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = affine.load %arg2[%arg4, %arg5 + %arg8, %arg6 + %arg9, %arg7 + %arg10] : memref + %5 = arith.addf %4, %3 : f32 + affine.store %5, %arg2[%arg4, %arg5 + %arg8, %arg6 + %arg9, %arg7 + %arg10] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu/raised.mlir new file mode 100644 index 000000000000..304da11abcba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu/raised.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d2, d3, d4)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d2, d3, d4, d5, d6, d7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_backward_input_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg2, %c2, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref<2x6x7x8x3x3x3xf32> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["reduction", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%1 : memref<2x6x7x8x3x3x3xf32>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu_debuf.mlir new file mode 100644 index 000000000000..304da11abcba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu_debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d2, d3, d4)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d2, d3, d4, d5, d6, d7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_backward_input_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg2, %c2, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref<2x6x7x8x3x3x3xf32> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["reduction", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%1 : memref<2x6x7x8x3x3x3xf32>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu_linalg.mlir new file mode 100644 index 000000000000..304da11abcba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_input_cpu_linalg.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d2, d3, d4)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d2, d3, d4, d5, d6, d7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_backward_input_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 1440 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg2, %c2, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref<2x6x7x8x3x3x3xf32> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["reduction", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%1 : memref<2x6x7x8x3x3x3xf32>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu.mlir new file mode 100644 index 000000000000..d5b1460f5b35 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_backward_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 162 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 6 { + affine.for %arg9 = 0 to 7 { + affine.for %arg10 = 0 to 8 { + %1 = affine.load %arg0[%arg4, %arg8 + %arg5, %arg9 + %arg6, %arg10 + %arg7] : memref + %2 = affine.load %arg1[%arg3, %arg8, %arg9, %arg10] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = affine.load %arg2[%arg3, %arg4, %arg5, %arg6, %arg7] : memref + %5 = arith.addf %4, %3 : f32 + affine.store %5, %arg2[%arg3, %arg4, %arg5, %arg6, %arg7] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu/debuf.mlir new file mode 100644 index 000000000000..0ad107a31939 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu/debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d5 + d2, d6 + d3, d7 + d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_backward_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 162 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %1 = polygeist.submap(%arg0, %c3, %c2, %c3, %c3, %c3, %c6, %c7, %c8) {map = #map} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg2[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%1, %subview : memref, memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu/matched.mlir new file mode 100644 index 000000000000..0ad107a31939 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu/matched.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d5 + d2, d6 + d3, d7 + d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_backward_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 162 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %1 = polygeist.submap(%arg0, %c3, %c2, %c3, %c3, %c3, %c6, %c7, %c8) {map = #map} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg2[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%1, %subview : memref, memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu/orig.mlir new file mode 100644 index 000000000000..d5b1460f5b35 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu/orig.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_backward_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 162 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 3 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 6 { + affine.for %arg9 = 0 to 7 { + affine.for %arg10 = 0 to 8 { + %1 = affine.load %arg0[%arg4, %arg8 + %arg5, %arg9 + %arg6, %arg10 + %arg7] : memref + %2 = affine.load %arg1[%arg3, %arg8, %arg9, %arg10] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = affine.load %arg2[%arg3, %arg4, %arg5, %arg6, %arg7] : memref + %5 = arith.addf %4, %3 : f32 + affine.store %5, %arg2[%arg3, %arg4, %arg5, %arg6, %arg7] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu/raised.mlir new file mode 100644 index 000000000000..0ad107a31939 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu/raised.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d5 + d2, d6 + d3, d7 + d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_backward_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 162 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %1 = polygeist.submap(%arg0, %c3, %c2, %c3, %c3, %c3, %c6, %c7, %c8) {map = #map} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg2[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%1, %subview : memref, memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu_debuf.mlir new file mode 100644 index 000000000000..0ad107a31939 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu_debuf.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d5 + d2, d6 + d3, d7 + d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_backward_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 162 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %1 = polygeist.submap(%arg0, %c3, %c2, %c3, %c3, %c3, %c6, %c7, %c8) {map = #map} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg2[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%1, %subview : memref, memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu_linalg.mlir new file mode 100644 index 000000000000..0ad107a31939 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_backward_weight_cpu_linalg.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d1, d5 + d2, d6 + d3, d7 + d4)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_backward_weight_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg2) : (memref) -> !llvm.ptr + affine.for %arg3 = 0 to 162 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %1 = polygeist.submap(%arg0, %c3, %c2, %c3, %c3, %c3, %c6, %c7, %c8) {map = #map} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg2[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%1, %subview : memref, memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %2 = arith.mulf %in, %in_1 : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu.mlir new file mode 100644 index 000000000000..8725f31f040a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 6 { + affine.for %arg5 = 0 to 7 { + affine.for %arg6 = 0 to 8 { + %0 = affine.for %arg7 = 0 to 2 iter_args(%arg8 = %cst) -> (f32) { + %1 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %arg8) -> (f32) { + %2 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %arg10) -> (f32) { + %3 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %arg12) -> (f32) { + %4 = affine.load %arg0[%arg7, %arg4 + %arg9, %arg5 + %arg11, %arg6 + %arg13] : memref + %5 = affine.load %arg1[%arg3, %arg7, %arg9, %arg11, %arg13] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.addf %arg14, %6 : f32 + affine.yield %7 : f32 + } + affine.yield %3 : f32 + } + affine.yield %2 : f32 + } + affine.yield %1 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu/debuf.mlir new file mode 100644 index 000000000000..91d81f6dbee2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu/debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4, d5 + d1, d6 + d2, d7 + d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d4, d5, d6, d7)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = polygeist.submap(%0, %c3, %c6, %c7, %c8, %c2, %c3, %c3, %c3) {map = #map1} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction", "reduction"], library_call = ""} ins(%4, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu/matched.mlir new file mode 100644 index 000000000000..9edfd6c98776 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4, d5 + d1, d6 + d2, d7 + d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d4, d5, d6, d7)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : tensor to tensor + %4 = polygeist.submap(%0, %c3, %c6, %c7, %c8, %c2, %c3, %c3, %c3) {map = #map1} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : tensor to tensor + %5 = kernel.launch @cudnnConvolution3D_f32(%4, %extracted_slice_0, %extracted_slice) : (tensor, tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu/orig.mlir new file mode 100644 index 000000000000..8725f31f040a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu/orig.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 6 { + affine.for %arg5 = 0 to 7 { + affine.for %arg6 = 0 to 8 { + %0 = affine.for %arg7 = 0 to 2 iter_args(%arg8 = %cst) -> (f32) { + %1 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %arg8) -> (f32) { + %2 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %arg10) -> (f32) { + %3 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %arg12) -> (f32) { + %4 = affine.load %arg0[%arg7, %arg4 + %arg9, %arg5 + %arg11, %arg6 + %arg13] : memref + %5 = affine.load %arg1[%arg3, %arg7, %arg9, %arg11, %arg13] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.addf %arg14, %6 : f32 + affine.yield %7 : f32 + } + affine.yield %3 : f32 + } + affine.yield %2 : f32 + } + affine.yield %1 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu/raised.mlir new file mode 100644 index 000000000000..b8cfc6befedf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu/raised.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4, d5 + d1, d6 + d2, d7 + d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d4, d5, d6, d7)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg0, %c3, %c6, %c7, %c8, %c2, %c3, %c3, %c3) {map = #map1} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg1[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction", "reduction"]} ins(%0, %subview_0 : memref, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %1 = arith.mulf %in, %in_2 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu_debuf.mlir new file mode 100644 index 000000000000..91d81f6dbee2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu_debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4, d5 + d1, d6 + d2, d7 + d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d4, d5, d6, d7)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %4 = polygeist.submap(%0, %c3, %c6, %c7, %c8, %c2, %c3, %c3, %c3) {map = #map1} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction", "reduction"], library_call = ""} ins(%4, %extracted_slice_0 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %7 = arith.mulf %in, %in_1 : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu_linalg.mlir new file mode 100644 index 000000000000..b8cfc6befedf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_slow_conv3d_forward_cpu_linalg.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4, d5 + d1, d6 + d2, d7 + d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d4, d5, d6, d7)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_slow_conv3d_forward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %0 = polygeist.submap(%arg0, %c3, %c6, %c7, %c8, %c2, %c3, %c3, %c3) {map = #map1} : (memref, index, index, index, index, index, index, index, index) -> memref + %subview_0 = memref.subview %arg1[0, 0, 0, 0, 0] [%c3, %c2, %c3, %c3, %c3] [1, 1, 1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0, 0, 0, 0] [%c3, %c6, %c7, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction", "reduction"]} ins(%0, %subview_0 : memref, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %1 = arith.mulf %in, %in_2 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_smooth_l1_backward.mlir b/issues/aten_c_kernels/results/aten_smooth_l1_backward.mlir new file mode 100644 index 000000000000..da115ef8f718 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_smooth_l1_backward.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_smooth_l1_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.negf %arg3 : f32 + %1 = arith.negf %arg2 : f32 + affine.for %arg5 = 0 to 4096 { + %2 = affine.load %arg0[%arg5] : memref + %3 = affine.load %arg1[%arg5] : memref + %4 = arith.subf %2, %3 : f32 + %5 = arith.cmpf ole, %4, %0 : f32 + %6 = scf.if %5 -> (f32) { + scf.yield %1 : f32 + } else { + %7 = arith.cmpf oge, %4, %arg3 : f32 + %8 = scf.if %7 -> (f32) { + scf.yield %arg2 : f32 + } else { + %9 = arith.mulf %arg2, %4 : f32 + %10 = arith.divf %9, %arg3 : f32 + scf.yield %10 : f32 + } + scf.yield %8 : f32 + } + affine.store %6, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_smooth_l1_backward/debuf.mlir b/issues/aten_c_kernels/results/aten_smooth_l1_backward/debuf.mlir new file mode 100644 index 000000000000..ab3d5fdc5ba9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_smooth_l1_backward/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_smooth_l1_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = arith.negf %arg3 : f32 + %4 = arith.negf %arg2 : f32 + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %7 = arith.subf %in, %in_0 : f32 + %8 = arith.cmpf ole, %7, %3 : f32 + %9 = arith.cmpf oge, %7, %arg3 : f32 + %10 = arith.mulf %arg2, %7 : f32 + %11 = arith.divf %10, %arg3 : f32 + %12 = arith.select %9, %arg2, %11 : f32 + %13 = arith.select %8, %4, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_smooth_l1_backward/matched.mlir b/issues/aten_c_kernels/results/aten_smooth_l1_backward/matched.mlir new file mode 100644 index 000000000000..ab3d5fdc5ba9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_smooth_l1_backward/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_smooth_l1_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = arith.negf %arg3 : f32 + %4 = arith.negf %arg2 : f32 + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %7 = arith.subf %in, %in_0 : f32 + %8 = arith.cmpf ole, %7, %3 : f32 + %9 = arith.cmpf oge, %7, %arg3 : f32 + %10 = arith.mulf %arg2, %7 : f32 + %11 = arith.divf %10, %arg3 : f32 + %12 = arith.select %9, %arg2, %11 : f32 + %13 = arith.select %8, %4, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_smooth_l1_backward/orig.mlir b/issues/aten_c_kernels/results/aten_smooth_l1_backward/orig.mlir new file mode 100644 index 000000000000..da115ef8f718 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_smooth_l1_backward/orig.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_smooth_l1_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.negf %arg3 : f32 + %1 = arith.negf %arg2 : f32 + affine.for %arg5 = 0 to 4096 { + %2 = affine.load %arg0[%arg5] : memref + %3 = affine.load %arg1[%arg5] : memref + %4 = arith.subf %2, %3 : f32 + %5 = arith.cmpf ole, %4, %0 : f32 + %6 = scf.if %5 -> (f32) { + scf.yield %1 : f32 + } else { + %7 = arith.cmpf oge, %4, %arg3 : f32 + %8 = scf.if %7 -> (f32) { + scf.yield %arg2 : f32 + } else { + %9 = arith.mulf %arg2, %4 : f32 + %10 = arith.divf %9, %arg3 : f32 + scf.yield %10 : f32 + } + scf.yield %8 : f32 + } + affine.store %6, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_smooth_l1_backward/raised.mlir b/issues/aten_c_kernels/results/aten_smooth_l1_backward/raised.mlir new file mode 100644 index 000000000000..6f89d60392e3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_smooth_l1_backward/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_smooth_l1_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.negf %arg3 : f32 + %1 = arith.negf %arg2 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg4 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %2 = arith.subf %in, %in_0 : f32 + %3 = arith.cmpf ole, %2, %0 : f32 + %4 = arith.cmpf oge, %2, %arg3 : f32 + %5 = arith.mulf %arg2, %2 : f32 + %6 = arith.divf %5, %arg3 : f32 + %7 = arith.select %4, %arg2, %6 : f32 + %8 = arith.select %3, %1, %7 : f32 + linalg.yield %8 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_smooth_l1_backward_debuf.mlir b/issues/aten_c_kernels/results/aten_smooth_l1_backward_debuf.mlir new file mode 100644 index 000000000000..ab3d5fdc5ba9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_smooth_l1_backward_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_smooth_l1_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = arith.negf %arg3 : f32 + %4 = arith.negf %arg2 : f32 + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %7 = arith.subf %in, %in_0 : f32 + %8 = arith.cmpf ole, %7, %3 : f32 + %9 = arith.cmpf oge, %7, %arg3 : f32 + %10 = arith.mulf %arg2, %7 : f32 + %11 = arith.divf %10, %arg3 : f32 + %12 = arith.select %9, %arg2, %11 : f32 + %13 = arith.select %8, %4, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_smooth_l1_backward_linalg.mlir b/issues/aten_c_kernels/results/aten_smooth_l1_backward_linalg.mlir new file mode 100644 index 000000000000..6f89d60392e3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_smooth_l1_backward_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_smooth_l1_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.negf %arg3 : f32 + %1 = arith.negf %arg2 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg4 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %2 = arith.subf %in, %in_0 : f32 + %3 = arith.cmpf ole, %2, %0 : f32 + %4 = arith.cmpf oge, %2, %arg3 : f32 + %5 = arith.mulf %arg2, %2 : f32 + %6 = arith.divf %5, %arg3 : f32 + %7 = arith.select %4, %arg2, %6 : f32 + %8 = arith.select %3, %1, %7 : f32 + linalg.yield %8 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_smooth_l1_elementwise.mlir b/issues/aten_c_kernels/results/aten_smooth_l1_elementwise.mlir new file mode 100644 index 000000000000..6fcf66c2040f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_smooth_l1_elementwise.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_smooth_l1_elementwise(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %0 = arith.mulf %arg2, %cst : f32 + affine.for %arg4 = 0 to 4096 { + %1 = affine.load %arg0[%arg4] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.subf %1, %2 : f32 + %4 = arith.cmpf olt, %3, %cst_0 : f32 + %5 = scf.if %4 -> (f32) { + %8 = arith.negf %3 : f32 + scf.yield %8 : f32 + } else { + scf.yield %3 : f32 + } + %6 = arith.cmpf olt, %5, %arg2 : f32 + %7 = scf.if %6 -> (f32) { + %8 = arith.mulf %3, %cst : f32 + %9 = arith.mulf %8, %3 : f32 + %10 = arith.divf %9, %arg2 : f32 + scf.yield %10 : f32 + } else { + %8 = arith.subf %5, %0 : f32 + scf.yield %8 : f32 + } + affine.store %7, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_smooth_l1_elementwise/debuf.mlir b/issues/aten_c_kernels/results/aten_smooth_l1_elementwise/debuf.mlir new file mode 100644 index 000000000000..b0202e60cda7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_smooth_l1_elementwise/debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_smooth_l1_elementwise(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.mulf %arg2, %cst_0 : f32 + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %6 = arith.subf %in, %in_1 : f32 + %7 = arith.cmpf olt, %6, %cst : f32 + %8 = arith.negf %6 : f32 + %9 = arith.select %7, %8, %6 : f32 + %10 = arith.cmpf olt, %9, %arg2 : f32 + %11 = arith.mulf %6, %cst_0 : f32 + %12 = arith.mulf %11, %6 : f32 + %13 = arith.divf %12, %arg2 : f32 + %14 = arith.subf %9, %3 : f32 + %15 = arith.select %10, %13, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_smooth_l1_elementwise/matched.mlir b/issues/aten_c_kernels/results/aten_smooth_l1_elementwise/matched.mlir new file mode 100644 index 000000000000..b0202e60cda7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_smooth_l1_elementwise/matched.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_smooth_l1_elementwise(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.mulf %arg2, %cst_0 : f32 + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %6 = arith.subf %in, %in_1 : f32 + %7 = arith.cmpf olt, %6, %cst : f32 + %8 = arith.negf %6 : f32 + %9 = arith.select %7, %8, %6 : f32 + %10 = arith.cmpf olt, %9, %arg2 : f32 + %11 = arith.mulf %6, %cst_0 : f32 + %12 = arith.mulf %11, %6 : f32 + %13 = arith.divf %12, %arg2 : f32 + %14 = arith.subf %9, %3 : f32 + %15 = arith.select %10, %13, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_smooth_l1_elementwise/orig.mlir b/issues/aten_c_kernels/results/aten_smooth_l1_elementwise/orig.mlir new file mode 100644 index 000000000000..6fcf66c2040f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_smooth_l1_elementwise/orig.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_smooth_l1_elementwise(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %0 = arith.mulf %arg2, %cst : f32 + affine.for %arg4 = 0 to 4096 { + %1 = affine.load %arg0[%arg4] : memref + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.subf %1, %2 : f32 + %4 = arith.cmpf olt, %3, %cst_0 : f32 + %5 = scf.if %4 -> (f32) { + %8 = arith.negf %3 : f32 + scf.yield %8 : f32 + } else { + scf.yield %3 : f32 + } + %6 = arith.cmpf olt, %5, %arg2 : f32 + %7 = scf.if %6 -> (f32) { + %8 = arith.mulf %3, %cst : f32 + %9 = arith.mulf %8, %3 : f32 + %10 = arith.divf %9, %arg2 : f32 + scf.yield %10 : f32 + } else { + %8 = arith.subf %5, %0 : f32 + scf.yield %8 : f32 + } + affine.store %7, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_smooth_l1_elementwise/raised.mlir b/issues/aten_c_kernels/results/aten_smooth_l1_elementwise/raised.mlir new file mode 100644 index 000000000000..99f4a0731158 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_smooth_l1_elementwise/raised.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_smooth_l1_elementwise(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %0 = arith.mulf %arg2, %cst : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %1 = arith.subf %in, %in_1 : f32 + %2 = arith.cmpf olt, %1, %cst_0 : f32 + %3 = arith.negf %1 : f32 + %4 = arith.select %2, %3, %1 : f32 + %5 = arith.cmpf olt, %4, %arg2 : f32 + %6 = arith.mulf %1, %cst : f32 + %7 = arith.mulf %6, %1 : f32 + %8 = arith.divf %7, %arg2 : f32 + %9 = arith.subf %4, %0 : f32 + %10 = arith.select %5, %8, %9 : f32 + linalg.yield %10 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_smooth_l1_elementwise_debuf.mlir b/issues/aten_c_kernels/results/aten_smooth_l1_elementwise_debuf.mlir new file mode 100644 index 000000000000..b0202e60cda7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_smooth_l1_elementwise_debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_smooth_l1_elementwise(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.mulf %arg2, %cst_0 : f32 + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %6 = arith.subf %in, %in_1 : f32 + %7 = arith.cmpf olt, %6, %cst : f32 + %8 = arith.negf %6 : f32 + %9 = arith.select %7, %8, %6 : f32 + %10 = arith.cmpf olt, %9, %arg2 : f32 + %11 = arith.mulf %6, %cst_0 : f32 + %12 = arith.mulf %11, %6 : f32 + %13 = arith.divf %12, %arg2 : f32 + %14 = arith.subf %9, %3 : f32 + %15 = arith.select %10, %13, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_smooth_l1_elementwise_linalg.mlir b/issues/aten_c_kernels/results/aten_smooth_l1_elementwise_linalg.mlir new file mode 100644 index 000000000000..99f4a0731158 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_smooth_l1_elementwise_linalg.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_smooth_l1_elementwise(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %0 = arith.mulf %arg2, %cst : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_1: f32, %out: f32): + %1 = arith.subf %in, %in_1 : f32 + %2 = arith.cmpf olt, %1, %cst_0 : f32 + %3 = arith.negf %1 : f32 + %4 = arith.select %2, %3, %1 : f32 + %5 = arith.cmpf olt, %4, %arg2 : f32 + %6 = arith.mulf %1, %cst : f32 + %7 = arith.mulf %6, %1 : f32 + %8 = arith.divf %7, %arg2 : f32 + %9 = arith.subf %4, %0 : f32 + %10 = arith.select %5, %8, %9 : f32 + linalg.yield %10 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_draw_cpu.mlir b/issues/aten_c_kernels/results/aten_sobol_draw_cpu.mlir new file mode 100644 index 000000000000..3d1043e699b8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_draw_cpu.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_draw_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.32830644E-10 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 256 { + %0 = arith.index_cast %arg3 : index to i32 + %1:2 = scf.while (%arg4 = %0, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %3 = arith.andi %arg4, %c1_i32 : i32 + %4 = arith.cmpi ne, %3, %c0_i32 : i32 + scf.condition(%4) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %3 = arith.addi %arg4, %c1_i32 : i32 + %4 = arith.shrsi %arg5, %c1_i32 : i32 + scf.yield %4, %3 : i32, i32 + } + %2 = arith.index_cast %1#0 : i32 to index + affine.for %arg4 = 0 to 8 { + %3 = memref.load %arg1[%arg4, %2] : memref + %4 = affine.load %arg0[%arg4] : memref + %5 = arith.xori %4, %3 : i32 + affine.store %5, %arg0[%arg4] : memref + %6 = arith.uitofp %5 : i32 to f32 + %7 = arith.mulf %6, %cst : f32 + affine.store %7, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sobol_draw_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sobol_draw_cpu/debuf.mlir new file mode 100644 index 000000000000..133a9c319359 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_draw_cpu/debuf.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_draw_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 2.32830644E-10 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 256 iter_args(%arg4 = %2, %arg5 = %0) -> (tensor, tensor) { + %6 = arith.index_cast %arg3 : index to i32 + %7:2 = scf.while (%arg6 = %6, %arg7 = %c0_i32) : (i32, i32) -> (i32, i32) { + %10 = arith.andi %arg6, %c1_i32 : i32 + %11 = arith.cmpi ne, %10, %c0_i32 : i32 + scf.condition(%11) %arg7, %arg6 : i32, i32 + } do { + ^bb0(%arg6: i32, %arg7: i32): + %10 = arith.addi %arg6, %c1_i32 : i32 + %11 = arith.shrsi %arg7, %c1_i32 : i32 + scf.yield %11, %10 : i32, i32 + } + %8 = arith.index_cast %7#0 : i32 to index + %9:2 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %extracted = tensor.extract %1[%arg6, %8] : tensor + %extracted_0 = tensor.extract %arg7[%arg6] : tensor + %10 = arith.xori %extracted_0, %extracted : i32 + %inserted = tensor.insert %10 into %arg7[%arg6] : tensor + %11 = arith.uitofp %10 : i32 to f32 + %12 = arith.mulf %11, %cst : f32 + %inserted_1 = tensor.insert %12 into %arg8[%arg3, %arg6] : tensor + affine.yield %inserted, %inserted_1 : tensor, tensor + } + affine.yield %9#0, %9#1 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_draw_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sobol_draw_cpu/matched.mlir new file mode 100644 index 000000000000..133a9c319359 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_draw_cpu/matched.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_draw_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 2.32830644E-10 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 256 iter_args(%arg4 = %2, %arg5 = %0) -> (tensor, tensor) { + %6 = arith.index_cast %arg3 : index to i32 + %7:2 = scf.while (%arg6 = %6, %arg7 = %c0_i32) : (i32, i32) -> (i32, i32) { + %10 = arith.andi %arg6, %c1_i32 : i32 + %11 = arith.cmpi ne, %10, %c0_i32 : i32 + scf.condition(%11) %arg7, %arg6 : i32, i32 + } do { + ^bb0(%arg6: i32, %arg7: i32): + %10 = arith.addi %arg6, %c1_i32 : i32 + %11 = arith.shrsi %arg7, %c1_i32 : i32 + scf.yield %11, %10 : i32, i32 + } + %8 = arith.index_cast %7#0 : i32 to index + %9:2 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %extracted = tensor.extract %1[%arg6, %8] : tensor + %extracted_0 = tensor.extract %arg7[%arg6] : tensor + %10 = arith.xori %extracted_0, %extracted : i32 + %inserted = tensor.insert %10 into %arg7[%arg6] : tensor + %11 = arith.uitofp %10 : i32 to f32 + %12 = arith.mulf %11, %cst : f32 + %inserted_1 = tensor.insert %12 into %arg8[%arg3, %arg6] : tensor + affine.yield %inserted, %inserted_1 : tensor, tensor + } + affine.yield %9#0, %9#1 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_draw_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sobol_draw_cpu/orig.mlir new file mode 100644 index 000000000000..3d1043e699b8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_draw_cpu/orig.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_draw_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.32830644E-10 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 256 { + %0 = arith.index_cast %arg3 : index to i32 + %1:2 = scf.while (%arg4 = %0, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %3 = arith.andi %arg4, %c1_i32 : i32 + %4 = arith.cmpi ne, %3, %c0_i32 : i32 + scf.condition(%4) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %3 = arith.addi %arg4, %c1_i32 : i32 + %4 = arith.shrsi %arg5, %c1_i32 : i32 + scf.yield %4, %3 : i32, i32 + } + %2 = arith.index_cast %1#0 : i32 to index + affine.for %arg4 = 0 to 8 { + %3 = memref.load %arg1[%arg4, %2] : memref + %4 = affine.load %arg0[%arg4] : memref + %5 = arith.xori %4, %3 : i32 + affine.store %5, %arg0[%arg4] : memref + %6 = arith.uitofp %5 : i32 to f32 + %7 = arith.mulf %6, %cst : f32 + affine.store %7, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sobol_draw_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sobol_draw_cpu/raised.mlir new file mode 100644 index 000000000000..83d7b59031d4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_draw_cpu/raised.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_draw_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.32830644E-10 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 256 { + %0 = arith.index_cast %arg3 : index to i32 + %1:2 = scf.while (%arg4 = %0, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %3 = arith.andi %arg4, %c1_i32 : i32 + %4 = arith.cmpi ne, %3, %c0_i32 : i32 + scf.condition(%4) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %3 = arith.addi %arg4, %c1_i32 : i32 + %4 = arith.shrsi %arg5, %c1_i32 : i32 + scf.yield %4, %3 : i32, i32 + } + %2 = arith.index_cast %1#0 : i32 to index + affine.for %arg4 = 0 to 8 { + %3 = memref.load %arg1[%arg4, %2] : memref + %4 = affine.load %arg0[%arg4] : memref + %5 = arith.xori %4, %3 : i32 + affine.store %5, %arg0[%arg4] : memref + %6 = arith.uitofp %5 : i32 to f32 + %7 = arith.mulf %6, %cst : f32 + affine.store %7, %arg2[%arg3, %arg4] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_draw_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sobol_draw_cpu_debuf.mlir new file mode 100644 index 000000000000..133a9c319359 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_draw_cpu_debuf.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_draw_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 2.32830644E-10 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3:2 = affine.for %arg3 = 0 to 256 iter_args(%arg4 = %2, %arg5 = %0) -> (tensor, tensor) { + %6 = arith.index_cast %arg3 : index to i32 + %7:2 = scf.while (%arg6 = %6, %arg7 = %c0_i32) : (i32, i32) -> (i32, i32) { + %10 = arith.andi %arg6, %c1_i32 : i32 + %11 = arith.cmpi ne, %10, %c0_i32 : i32 + scf.condition(%11) %arg7, %arg6 : i32, i32 + } do { + ^bb0(%arg6: i32, %arg7: i32): + %10 = arith.addi %arg6, %c1_i32 : i32 + %11 = arith.shrsi %arg7, %c1_i32 : i32 + scf.yield %11, %10 : i32, i32 + } + %8 = arith.index_cast %7#0 : i32 to index + %9:2 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %extracted = tensor.extract %1[%arg6, %8] : tensor + %extracted_0 = tensor.extract %arg7[%arg6] : tensor + %10 = arith.xori %extracted_0, %extracted : i32 + %inserted = tensor.insert %10 into %arg7[%arg6] : tensor + %11 = arith.uitofp %10 : i32 to f32 + %12 = arith.mulf %11, %cst : f32 + %inserted_1 = tensor.insert %12 into %arg8[%arg3, %arg6] : tensor + affine.yield %inserted, %inserted_1 : tensor, tensor + } + affine.yield %9#0, %9#1 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_draw_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sobol_draw_cpu_linalg.mlir new file mode 100644 index 000000000000..83d7b59031d4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_draw_cpu_linalg.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_draw_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.32830644E-10 : f32 + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 256 { + %0 = arith.index_cast %arg3 : index to i32 + %1:2 = scf.while (%arg4 = %0, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %3 = arith.andi %arg4, %c1_i32 : i32 + %4 = arith.cmpi ne, %3, %c0_i32 : i32 + scf.condition(%4) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %3 = arith.addi %arg4, %c1_i32 : i32 + %4 = arith.shrsi %arg5, %c1_i32 : i32 + scf.yield %4, %3 : i32, i32 + } + %2 = arith.index_cast %1#0 : i32 to index + affine.for %arg4 = 0 to 8 { + %3 = memref.load %arg1[%arg4, %2] : memref + %4 = affine.load %arg0[%arg4] : memref + %5 = arith.xori %4, %3 : i32 + affine.store %5, %arg0[%arg4] : memref + %6 = arith.uitofp %5 : i32 to f32 + %7 = arith.mulf %6, %cst : f32 + affine.store %7, %arg2[%arg3, %arg4] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu.mlir b/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu.mlir new file mode 100644 index 000000000000..18071c60a009 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_fast_forward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 256 { + %0 = arith.index_cast %arg2 : index to i32 + %1:2 = scf.while (%arg3 = %0, %arg4 = %c0_i32) : (i32, i32) -> (i32, i32) { + %3 = arith.andi %arg3, %c1_i32 : i32 + %4 = arith.cmpi ne, %3, %c0_i32 : i32 + scf.condition(%4) %arg4, %arg3 : i32, i32 + } do { + ^bb0(%arg3: i32, %arg4: i32): + %3 = arith.addi %arg3, %c1_i32 : i32 + %4 = arith.shrsi %arg4, %c1_i32 : i32 + scf.yield %4, %3 : i32, i32 + } + %2 = arith.index_cast %1#0 : i32 to index + affine.for %arg3 = 0 to 8 { + %3 = memref.load %arg1[%arg3, %2] : memref + %4 = affine.load %arg0[%arg3] : memref + %5 = arith.xori %4, %3 : i32 + affine.store %5, %arg0[%arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu/debuf.mlir new file mode 100644 index 000000000000..d91060bdba8a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu/debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_fast_forward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c8 = arith.constant 8 : index + %c256 = arith.constant 256 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = polygeist.submap(%0, %c256, %c8) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7:2 = scf.while (%arg2 = %6, %arg3 = %c0_i32) : (i32, i32) -> (i32, i32) { + %12 = arith.andi %arg2, %c1_i32 : i32 + %13 = arith.cmpi ne, %12, %c0_i32 : i32 + scf.condition(%13) %arg3, %arg2 : i32, i32 + } do { + ^bb0(%arg2: i32, %arg3: i32): + %12 = arith.addi %arg2, %c1_i32 : i32 + %13 = arith.shrsi %arg3, %c1_i32 : i32 + scf.yield %13, %12 : i32, i32 + } + %8 = arith.index_cast %7#0 : i32 to index + %9 = linalg.index 1 : index + %10 = memref.load %arg1[%9, %8] : memref + %11 = arith.xori %out, %10 : i32 + linalg.yield %11 : i32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c256, %c8) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu/matched.mlir new file mode 100644 index 000000000000..d91060bdba8a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu/matched.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_fast_forward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c8 = arith.constant 8 : index + %c256 = arith.constant 256 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = polygeist.submap(%0, %c256, %c8) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7:2 = scf.while (%arg2 = %6, %arg3 = %c0_i32) : (i32, i32) -> (i32, i32) { + %12 = arith.andi %arg2, %c1_i32 : i32 + %13 = arith.cmpi ne, %12, %c0_i32 : i32 + scf.condition(%13) %arg3, %arg2 : i32, i32 + } do { + ^bb0(%arg2: i32, %arg3: i32): + %12 = arith.addi %arg2, %c1_i32 : i32 + %13 = arith.shrsi %arg3, %c1_i32 : i32 + scf.yield %13, %12 : i32, i32 + } + %8 = arith.index_cast %7#0 : i32 to index + %9 = linalg.index 1 : index + %10 = memref.load %arg1[%9, %8] : memref + %11 = arith.xori %out, %10 : i32 + linalg.yield %11 : i32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c256, %c8) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu/orig.mlir new file mode 100644 index 000000000000..18071c60a009 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu/orig.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_fast_forward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 256 { + %0 = arith.index_cast %arg2 : index to i32 + %1:2 = scf.while (%arg3 = %0, %arg4 = %c0_i32) : (i32, i32) -> (i32, i32) { + %3 = arith.andi %arg3, %c1_i32 : i32 + %4 = arith.cmpi ne, %3, %c0_i32 : i32 + scf.condition(%4) %arg4, %arg3 : i32, i32 + } do { + ^bb0(%arg3: i32, %arg4: i32): + %3 = arith.addi %arg3, %c1_i32 : i32 + %4 = arith.shrsi %arg4, %c1_i32 : i32 + scf.yield %4, %3 : i32, i32 + } + %2 = arith.index_cast %1#0 : i32 to index + affine.for %arg3 = 0 to 8 { + %3 = memref.load %arg1[%arg3, %2] : memref + %4 = affine.load %arg0[%arg3] : memref + %5 = arith.xori %4, %3 : i32 + affine.store %5, %arg0[%arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu/raised.mlir new file mode 100644 index 000000000000..2ce03ad06954 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu/raised.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_fast_forward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %c8 = arith.constant 8 : index + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = polygeist.submap(%arg0, %c256, %c8) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction", "parallel"]} outs(%0 : memref) { + ^bb0(%out: i32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3:2 = scf.while (%arg2 = %2, %arg3 = %c0_i32) : (i32, i32) -> (i32, i32) { + %8 = arith.andi %arg2, %c1_i32 : i32 + %9 = arith.cmpi ne, %8, %c0_i32 : i32 + scf.condition(%9) %arg3, %arg2 : i32, i32 + } do { + ^bb0(%arg2: i32, %arg3: i32): + %8 = arith.addi %arg2, %c1_i32 : i32 + %9 = arith.shrsi %arg3, %c1_i32 : i32 + scf.yield %9, %8 : i32, i32 + } + %4 = arith.index_cast %3#0 : i32 to index + %5 = linalg.index 1 : index + %6 = memref.load %arg1[%5, %4] : memref + %7 = arith.xori %out, %6 : i32 + linalg.yield %7 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu_debuf.mlir new file mode 100644 index 000000000000..d91060bdba8a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu_debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_fast_forward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c8 = arith.constant 8 : index + %c256 = arith.constant 256 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = polygeist.submap(%0, %c256, %c8) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7:2 = scf.while (%arg2 = %6, %arg3 = %c0_i32) : (i32, i32) -> (i32, i32) { + %12 = arith.andi %arg2, %c1_i32 : i32 + %13 = arith.cmpi ne, %12, %c0_i32 : i32 + scf.condition(%13) %arg3, %arg2 : i32, i32 + } do { + ^bb0(%arg2: i32, %arg3: i32): + %12 = arith.addi %arg2, %c1_i32 : i32 + %13 = arith.shrsi %arg3, %c1_i32 : i32 + scf.yield %13, %12 : i32, i32 + } + %8 = arith.index_cast %7#0 : i32 to index + %9 = linalg.index 1 : index + %10 = memref.load %arg1[%9, %8] : memref + %11 = arith.xori %out, %10 : i32 + linalg.yield %11 : i32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c256, %c8) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu_linalg.mlir new file mode 100644 index 000000000000..2ce03ad06954 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_fast_forward_cpu_linalg.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_fast_forward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c256 = arith.constant 256 : index + %c8 = arith.constant 8 : index + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = polygeist.submap(%arg0, %c256, %c8) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction", "parallel"]} outs(%0 : memref) { + ^bb0(%out: i32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3:2 = scf.while (%arg2 = %2, %arg3 = %c0_i32) : (i32, i32) -> (i32, i32) { + %8 = arith.andi %arg2, %c1_i32 : i32 + %9 = arith.cmpi ne, %8, %c0_i32 : i32 + scf.condition(%9) %arg3, %arg2 : i32, i32 + } do { + ^bb0(%arg2: i32, %arg3: i32): + %8 = arith.addi %arg2, %c1_i32 : i32 + %9 = arith.shrsi %arg3, %c1_i32 : i32 + scf.yield %9, %8 : i32, i32 + } + %4 = arith.index_cast %3#0 : i32 to index + %5 = linalg.index 1 : index + %6 = memref.load %arg1[%5, %4] : memref + %7 = arith.xori %out, %6 : i32 + linalg.yield %7 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_initialize_cpu.mlir b/issues/aten_c_kernels/results/aten_sobol_initialize_cpu.mlir new file mode 100644 index 000000000000..0b505838e7fc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_initialize_cpu.mlir @@ -0,0 +1,9 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_initialize_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 8 { + %0 = affine.load %arg0[%arg2, 0] : memref + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sobol_initialize_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sobol_initialize_cpu/debuf.mlir new file mode 100644 index 000000000000..c576577fc8fd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_initialize_cpu/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_initialize_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c8] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0] [%c8] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_initialize_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sobol_initialize_cpu/matched.mlir new file mode 100644 index 000000000000..c576577fc8fd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_initialize_cpu/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_initialize_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c8] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0] [%c8] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_initialize_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sobol_initialize_cpu/orig.mlir new file mode 100644 index 000000000000..0b505838e7fc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_initialize_cpu/orig.mlir @@ -0,0 +1,9 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_initialize_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 8 { + %0 = affine.load %arg0[%arg2, 0] : memref + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sobol_initialize_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sobol_initialize_cpu/raised.mlir new file mode 100644 index 000000000000..28a0b2805c21 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_initialize_cpu/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_initialize_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %subview = memref.subview %arg0[0, 0] [%c8, 1] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c8] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_initialize_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sobol_initialize_cpu_debuf.mlir new file mode 100644 index 000000000000..c576577fc8fd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_initialize_cpu_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_initialize_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c8, 1] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0] [%c8] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0] [%c8] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_initialize_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sobol_initialize_cpu_linalg.mlir new file mode 100644 index 000000000000..28a0b2805c21 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_initialize_cpu_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_initialize_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %subview = memref.subview %arg0[0, 0] [%c8, 1] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c8] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_scramble_cpu.mlir b/issues/aten_c_kernels/results/aten_sobol_scramble_cpu.mlir new file mode 100644 index 000000000000..734791f21ce8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_scramble_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_scramble_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c7_i32 = arith.constant 7 : i32 + affine.for %arg2 = 0 to 8 { + affine.for %arg3 = 0 to 32 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = affine.load %arg1[%arg2] : memref + %2 = arith.andi %0, %c7_i32 : i32 + %3 = arith.shrui %1, %2 : i32 + %4 = affine.load %arg0[%arg2, %arg3] : memref + %5 = arith.xori %4, %3 : i32 + affine.store %5, %arg0[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sobol_scramble_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sobol_scramble_cpu/debuf.mlir new file mode 100644 index 000000000000..a59e3cd6b5ca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_scramble_cpu/debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_scramble_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c7_i32 = arith.constant 7 : i32 + %c32 = arith.constant 32 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c8, %c32] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.andi %5, %c7_i32 : i32 + %7 = arith.shrui %in, %6 : i32 + %8 = arith.xori %out, %7 : i32 + linalg.yield %8 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %0[0, 0] [%c8, %c32] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_scramble_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sobol_scramble_cpu/matched.mlir new file mode 100644 index 000000000000..a59e3cd6b5ca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_scramble_cpu/matched.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_scramble_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c7_i32 = arith.constant 7 : i32 + %c32 = arith.constant 32 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c8, %c32] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.andi %5, %c7_i32 : i32 + %7 = arith.shrui %in, %6 : i32 + %8 = arith.xori %out, %7 : i32 + linalg.yield %8 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %0[0, 0] [%c8, %c32] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_scramble_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sobol_scramble_cpu/orig.mlir new file mode 100644 index 000000000000..734791f21ce8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_scramble_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_scramble_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c7_i32 = arith.constant 7 : i32 + affine.for %arg2 = 0 to 8 { + affine.for %arg3 = 0 to 32 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = affine.load %arg1[%arg2] : memref + %2 = arith.andi %0, %c7_i32 : i32 + %3 = arith.shrui %1, %2 : i32 + %4 = affine.load %arg0[%arg2, %arg3] : memref + %5 = arith.xori %4, %3 : i32 + affine.store %5, %arg0[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sobol_scramble_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sobol_scramble_cpu/raised.mlir new file mode 100644 index 000000000000..90e5d46d208f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_scramble_cpu/raised.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_scramble_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c32 = arith.constant 32 : index + %c7_i32 = arith.constant 7 : i32 + %subview = memref.subview %arg1[0] [%c8] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c8, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: i32, %out: i32): + %0 = linalg.index 1 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.andi %1, %c7_i32 : i32 + %3 = arith.shrui %in, %2 : i32 + %4 = arith.xori %out, %3 : i32 + linalg.yield %4 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_scramble_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sobol_scramble_cpu_debuf.mlir new file mode 100644 index 000000000000..a59e3cd6b5ca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_scramble_cpu_debuf.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_scramble_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c7_i32 = arith.constant 7 : i32 + %c32 = arith.constant 32 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0] [%c8] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c8, %c32] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.andi %5, %c7_i32 : i32 + %7 = arith.shrui %in, %6 : i32 + %8 = arith.xori %out, %7 : i32 + linalg.yield %8 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %0[0, 0] [%c8, %c32] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sobol_scramble_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sobol_scramble_cpu_linalg.mlir new file mode 100644 index 000000000000..90e5d46d208f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sobol_scramble_cpu_linalg.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sobol_scramble_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c32 = arith.constant 32 : index + %c7_i32 = arith.constant 7 : i32 + %subview = memref.subview %arg1[0] [%c8] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c8, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: i32, %out: i32): + %0 = linalg.index 1 : index + %1 = arith.index_cast %0 : index to i32 + %2 = arith.andi %1, %c7_i32 : i32 + %3 = arith.shrui %in, %2 : i32 + %4 = arith.xori %out, %3 : i32 + linalg.yield %4 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_softmax.mlir b/issues/aten_c_kernels/results/aten_softmax.mlir new file mode 100644 index 000000000000..5aa56a9e8726 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softmax.mlir @@ -0,0 +1,36 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softmax(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant -3.40282347E+38 : f32 + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %alloca_1 = memref.alloca() : memref + affine.store %cst_0, %alloca_1[] : memref + affine.for %arg1 = 0 to 128 { + %3 = affine.load %arg0[%arg1] : memref + %4 = affine.load %alloca_1[] : memref + %5 = arith.cmpf ogt, %3, %4 : f32 + %6 = arith.select %5, %3, %4 : f32 + affine.store %6, %alloca_1[] : memref + } + affine.store %cst, %alloca[] : memref + %1 = affine.load %alloca_1[] : memref + affine.for %arg1 = 0 to 128 { + %3 = affine.load %arg0[%arg1] : memref + %4 = arith.subf %3, %1 : f32 + %5 = math.exp %4 : f32 + affine.store %5, %arg0[%arg1] : memref + %6 = affine.load %alloca[] : memref + %7 = arith.addf %6, %5 : f32 + affine.store %7, %alloca[] : memref + } + %2 = affine.load %alloca[] : memref + affine.for %arg1 = 0 to 128 { + %3 = affine.load %arg0[%arg1] : memref + %4 = arith.divf %3, %2 : f32 + affine.store %4, %arg0[%arg1] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_softmax/debuf.mlir b/issues/aten_c_kernels/results/aten_softmax/debuf.mlir new file mode 100644 index 000000000000..a26044fe8aab --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softmax/debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softmax(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.40282347E+38 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c128 = arith.constant 128 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = tensor.empty() : tensor + %2 = llvm.mlir.undef : f32 + %inserted = tensor.insert %2 into %1[] : tensor + %3 = tensor.empty() : tensor + %inserted_1 = tensor.insert %cst into %3[] : tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted_1 : tensor) { + ^bb0(%in: f32, %out: f32): + %8 = arith.cmpf ogt, %in, %out : f32 + %9 = arith.select %8, %in, %out : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_2 = tensor.insert %cst_0 into %inserted[] : tensor + %extracted = tensor.extract %4[] : tensor + %extracted_slice = tensor.extract_slice %0[0] [%c128] [1] : tensor to tensor + %5:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} outs(%extracted_slice, %inserted_2 : tensor, tensor) { + ^bb0(%out: f32, %out_4: f32): + %8 = arith.subf %out, %extracted : f32 + %9 = math.exp %8 : f32 + %10 = arith.addf %out_4, %9 : f32 + linalg.yield %9, %10 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %5#0 into %0[0] [%c128] [1] : tensor into tensor + %extracted_3 = tensor.extract %5#1[] : tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%inserted_slice : tensor) { + ^bb0(%out: f32): + %8 = arith.divf %out, %extracted_3 : f32 + linalg.yield %8 : f32 + } -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_softmax/matched.mlir b/issues/aten_c_kernels/results/aten_softmax/matched.mlir new file mode 100644 index 000000000000..9b8f38937bf9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softmax/matched.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softmax(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.40282347E+38 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c128 = arith.constant 128 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = tensor.empty() : tensor + %2 = llvm.mlir.undef : f32 + %inserted = tensor.insert %2 into %1[] : tensor + %3 = tensor.empty() : tensor + %inserted_1 = tensor.insert %cst into %3[] : tensor + %6 = kernel.launch @cudnnSoftmaxForward_tensor(%0) : (tensor) -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_softmax/orig.mlir b/issues/aten_c_kernels/results/aten_softmax/orig.mlir new file mode 100644 index 000000000000..5aa56a9e8726 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softmax/orig.mlir @@ -0,0 +1,36 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softmax(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant -3.40282347E+38 : f32 + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %alloca_1 = memref.alloca() : memref + affine.store %cst_0, %alloca_1[] : memref + affine.for %arg1 = 0 to 128 { + %3 = affine.load %arg0[%arg1] : memref + %4 = affine.load %alloca_1[] : memref + %5 = arith.cmpf ogt, %3, %4 : f32 + %6 = arith.select %5, %3, %4 : f32 + affine.store %6, %alloca_1[] : memref + } + affine.store %cst, %alloca[] : memref + %1 = affine.load %alloca_1[] : memref + affine.for %arg1 = 0 to 128 { + %3 = affine.load %arg0[%arg1] : memref + %4 = arith.subf %3, %1 : f32 + %5 = math.exp %4 : f32 + affine.store %5, %arg0[%arg1] : memref + %6 = affine.load %alloca[] : memref + %7 = arith.addf %6, %5 : f32 + affine.store %7, %alloca[] : memref + } + %2 = affine.load %alloca[] : memref + affine.for %arg1 = 0 to 128 { + %3 = affine.load %arg0[%arg1] : memref + %4 = arith.divf %3, %2 : f32 + affine.store %4, %arg0[%arg1] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_softmax/raised.mlir b/issues/aten_c_kernels/results/aten_softmax/raised.mlir new file mode 100644 index 000000000000..c345f688a545 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softmax/raised.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softmax(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %c128 = arith.constant 128 : index + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant -3.40282347E+38 : f32 + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %alloca_1 = memref.alloca() : memref + affine.store %cst_0, %alloca_1[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca_1 : memref) { + ^bb0(%in: f32, %out: f32): + %3 = arith.cmpf ogt, %in, %out : f32 + %4 = arith.select %3, %in, %out : f32 + linalg.yield %4 : f32 + } + affine.store %cst, %alloca[] : memref + %1 = affine.load %alloca_1[] : memref + %subview = memref.subview %arg0[0] [%c128] [1] : memref to memref> + %subview_2 = memref.subview %alloca[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} outs(%subview, %subview_2 : memref>, memref>) { + ^bb0(%out: f32, %out_3: f32): + %3 = arith.subf %out, %1 : f32 + %4 = math.exp %3 : f32 + %5 = arith.addf %out_3, %4 : f32 + linalg.yield %4, %5 : f32, f32 + } + %2 = affine.load %alloca[] : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg0 : memref) { + ^bb0(%out: f32): + %3 = arith.divf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_softmax_debuf.mlir b/issues/aten_c_kernels/results/aten_softmax_debuf.mlir new file mode 100644 index 000000000000..a26044fe8aab --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softmax_debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softmax(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant -3.40282347E+38 : f32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %c128 = arith.constant 128 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = tensor.empty() : tensor + %2 = llvm.mlir.undef : f32 + %inserted = tensor.insert %2 into %1[] : tensor + %3 = tensor.empty() : tensor + %inserted_1 = tensor.insert %cst into %3[] : tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted_1 : tensor) { + ^bb0(%in: f32, %out: f32): + %8 = arith.cmpf ogt, %in, %out : f32 + %9 = arith.select %8, %in, %out : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_2 = tensor.insert %cst_0 into %inserted[] : tensor + %extracted = tensor.extract %4[] : tensor + %extracted_slice = tensor.extract_slice %0[0] [%c128] [1] : tensor to tensor + %5:2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} outs(%extracted_slice, %inserted_2 : tensor, tensor) { + ^bb0(%out: f32, %out_4: f32): + %8 = arith.subf %out, %extracted : f32 + %9 = math.exp %8 : f32 + %10 = arith.addf %out_4, %9 : f32 + linalg.yield %9, %10 : f32, f32 + } -> (tensor, tensor) + %inserted_slice = tensor.insert_slice %5#0 into %0[0] [%c128] [1] : tensor into tensor + %extracted_3 = tensor.extract %5#1[] : tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%inserted_slice : tensor) { + ^bb0(%out: f32): + %8 = arith.divf %out, %extracted_3 : f32 + linalg.yield %8 : f32 + } -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_softmax_linalg.mlir b/issues/aten_c_kernels/results/aten_softmax_linalg.mlir new file mode 100644 index 000000000000..c345f688a545 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softmax_linalg.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softmax(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %c128 = arith.constant 128 : index + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant -3.40282347E+38 : f32 + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f32 + affine.store %0, %alloca[] : memref + %alloca_1 = memref.alloca() : memref + affine.store %cst_0, %alloca_1[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca_1 : memref) { + ^bb0(%in: f32, %out: f32): + %3 = arith.cmpf ogt, %in, %out : f32 + %4 = arith.select %3, %in, %out : f32 + linalg.yield %4 : f32 + } + affine.store %cst, %alloca[] : memref + %1 = affine.load %alloca_1[] : memref + %subview = memref.subview %arg0[0] [%c128] [1] : memref to memref> + %subview_2 = memref.subview %alloca[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} outs(%subview, %subview_2 : memref>, memref>) { + ^bb0(%out: f32, %out_3: f32): + %3 = arith.subf %out, %1 : f32 + %4 = math.exp %3 : f32 + %5 = arith.addf %out_3, %4 : f32 + linalg.yield %4, %5 : f32, f32 + } + %2 = affine.load %alloca[] : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg0 : memref) { + ^bb0(%out: f32): + %3 = arith.divf %out, %2 : f32 + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_softplus.mlir b/issues/aten_c_kernels/results/aten_softplus.mlir new file mode 100644 index 000000000000..b63caab5633e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softplus.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softplus(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg4 = 0 to 256 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.mulf %arg2, %0 : f32 + %2 = arith.cmpf ogt, %1, %arg3 : f32 + %3 = scf.if %2 -> (f32) { + %4 = affine.load %arg0[%arg4] : memref + scf.yield %4 : f32 + } else { + %4 = math.exp %1 : f32 + %5 = arith.addf %4, %cst : f32 + %6 = func.call @logf(%5) : (f32) -> f32 + %7 = arith.divf %6, %arg2 : f32 + scf.yield %7 : f32 + } + affine.store %3, %arg1[%arg4] : memref + } + return + } + func.func private @logf(f32) -> f32 +} diff --git a/issues/aten_c_kernels/results/aten_softplus/cgeist.err b/issues/aten_c_kernels/results/aten_softplus/cgeist.err new file mode 100644 index 000000000000..7af56dfb14e0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softplus/cgeist.err @@ -0,0 +1 @@ +warning: we fall back to libc call for __builtin_logf diff --git a/issues/aten_c_kernels/results/aten_softplus/debuf.mlir b/issues/aten_c_kernels/results/aten_softplus/debuf.mlir new file mode 100644 index 000000000000..b28d6ef34a84 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softplus/debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softplus(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg0[%3] : memref + %5 = arith.mulf %arg2, %4 : f32 + %6 = arith.cmpf ogt, %5, %arg3 : f32 + %7 = scf.if %6 -> (f32) { + %8 = memref.load %arg0[%3] : memref + scf.yield %8 : f32 + } else { + %8 = math.exp %5 : f32 + %9 = arith.addf %8, %cst : f32 + %10 = math.log %9 : f32 + %11 = arith.divf %10, %arg2 : f32 + scf.yield %11 : f32 + } + linalg.yield %7 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } + func.func private @logf(f32) -> f32 +} + diff --git a/issues/aten_c_kernels/results/aten_softplus/matched.mlir b/issues/aten_c_kernels/results/aten_softplus/matched.mlir new file mode 100644 index 000000000000..b28d6ef34a84 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softplus/matched.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softplus(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg0[%3] : memref + %5 = arith.mulf %arg2, %4 : f32 + %6 = arith.cmpf ogt, %5, %arg3 : f32 + %7 = scf.if %6 -> (f32) { + %8 = memref.load %arg0[%3] : memref + scf.yield %8 : f32 + } else { + %8 = math.exp %5 : f32 + %9 = arith.addf %8, %cst : f32 + %10 = math.log %9 : f32 + %11 = arith.divf %10, %arg2 : f32 + scf.yield %11 : f32 + } + linalg.yield %7 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } + func.func private @logf(f32) -> f32 +} + diff --git a/issues/aten_c_kernels/results/aten_softplus/orig.mlir b/issues/aten_c_kernels/results/aten_softplus/orig.mlir new file mode 100644 index 000000000000..b63caab5633e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softplus/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softplus(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg4 = 0 to 256 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.mulf %arg2, %0 : f32 + %2 = arith.cmpf ogt, %1, %arg3 : f32 + %3 = scf.if %2 -> (f32) { + %4 = affine.load %arg0[%arg4] : memref + scf.yield %4 : f32 + } else { + %4 = math.exp %1 : f32 + %5 = arith.addf %4, %cst : f32 + %6 = func.call @logf(%5) : (f32) -> f32 + %7 = arith.divf %6, %arg2 : f32 + scf.yield %7 : f32 + } + affine.store %3, %arg1[%arg4] : memref + } + return + } + func.func private @logf(f32) -> f32 +} diff --git a/issues/aten_c_kernels/results/aten_softplus/raised.mlir b/issues/aten_c_kernels/results/aten_softplus/raised.mlir new file mode 100644 index 000000000000..c7f2e0c0cafb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softplus/raised.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softplus(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg0[%0] : memref + %2 = arith.mulf %arg2, %1 : f32 + %3 = arith.cmpf ogt, %2, %arg3 : f32 + %4 = scf.if %3 -> (f32) { + %5 = memref.load %arg0[%0] : memref + scf.yield %5 : f32 + } else { + %5 = math.exp %2 : f32 + %6 = arith.addf %5, %cst : f32 + %7 = math.log %6 : f32 + %8 = arith.divf %7, %arg2 : f32 + scf.yield %8 : f32 + } + linalg.yield %4 : f32 + } + return + } + func.func private @logf(f32) -> f32 +} + diff --git a/issues/aten_c_kernels/results/aten_softplus_backward.mlir b/issues/aten_c_kernels/results/aten_softplus_backward.mlir new file mode 100644 index 000000000000..f66001d0da33 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softplus_backward.mlir @@ -0,0 +1,24 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softplus_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg5 = 0 to 4096 { + %0 = affine.load %arg1[%arg5] : memref + %1 = arith.mulf %arg2, %0 : f32 + %2 = arith.cmpf ogt, %1, %arg3 : f32 + %3 = scf.if %2 -> (f32) { + %4 = affine.load %arg0[%arg5] : memref + scf.yield %4 : f32 + } else { + %4 = affine.load %arg0[%arg5] : memref + %5 = math.exp %1 : f32 + %6 = arith.addf %5, %cst : f32 + %7 = arith.divf %cst, %6 : f32 + %8 = arith.subf %cst, %7 : f32 + %9 = arith.mulf %4, %8 : f32 + scf.yield %9 : f32 + } + affine.store %3, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_softplus_backward/debuf.mlir b/issues/aten_c_kernels/results/aten_softplus_backward/debuf.mlir new file mode 100644 index 000000000000..0521484d1e75 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softplus_backward/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softplus_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0, %0 : tensor, tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %5 = arith.mulf %arg2, %in : f32 + %6 = arith.cmpf ogt, %5, %arg3 : f32 + %7 = math.exp %5 : f32 + %8 = arith.addf %7, %cst : f32 + %9 = arith.divf %cst, %8 : f32 + %10 = arith.subf %cst, %9 : f32 + %11 = arith.mulf %in_1, %10 : f32 + %12 = arith.select %6, %in_0, %11 : f32 + linalg.yield %12 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_softplus_backward/matched.mlir b/issues/aten_c_kernels/results/aten_softplus_backward/matched.mlir new file mode 100644 index 000000000000..0521484d1e75 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softplus_backward/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softplus_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0, %0 : tensor, tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %5 = arith.mulf %arg2, %in : f32 + %6 = arith.cmpf ogt, %5, %arg3 : f32 + %7 = math.exp %5 : f32 + %8 = arith.addf %7, %cst : f32 + %9 = arith.divf %cst, %8 : f32 + %10 = arith.subf %cst, %9 : f32 + %11 = arith.mulf %in_1, %10 : f32 + %12 = arith.select %6, %in_0, %11 : f32 + linalg.yield %12 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_softplus_backward/orig.mlir b/issues/aten_c_kernels/results/aten_softplus_backward/orig.mlir new file mode 100644 index 000000000000..f66001d0da33 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softplus_backward/orig.mlir @@ -0,0 +1,24 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softplus_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg5 = 0 to 4096 { + %0 = affine.load %arg1[%arg5] : memref + %1 = arith.mulf %arg2, %0 : f32 + %2 = arith.cmpf ogt, %1, %arg3 : f32 + %3 = scf.if %2 -> (f32) { + %4 = affine.load %arg0[%arg5] : memref + scf.yield %4 : f32 + } else { + %4 = affine.load %arg0[%arg5] : memref + %5 = math.exp %1 : f32 + %6 = arith.addf %5, %cst : f32 + %7 = arith.divf %cst, %6 : f32 + %8 = arith.subf %cst, %7 : f32 + %9 = arith.mulf %4, %8 : f32 + scf.yield %9 : f32 + } + affine.store %3, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_softplus_backward/raised.mlir b/issues/aten_c_kernels/results/aten_softplus_backward/raised.mlir new file mode 100644 index 000000000000..36c6adab98f7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softplus_backward/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softplus_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0, %arg0 : memref, memref, memref) outs(%arg4 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.mulf %arg2, %in : f32 + %1 = arith.cmpf ogt, %0, %arg3 : f32 + %2 = math.exp %0 : f32 + %3 = arith.addf %2, %cst : f32 + %4 = arith.divf %cst, %3 : f32 + %5 = arith.subf %cst, %4 : f32 + %6 = arith.mulf %in_1, %5 : f32 + %7 = arith.select %1, %in_0, %6 : f32 + linalg.yield %7 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_softplus_backward_debuf.mlir b/issues/aten_c_kernels/results/aten_softplus_backward_debuf.mlir new file mode 100644 index 000000000000..0521484d1e75 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softplus_backward_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softplus_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0, %0 : tensor, tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %5 = arith.mulf %arg2, %in : f32 + %6 = arith.cmpf ogt, %5, %arg3 : f32 + %7 = math.exp %5 : f32 + %8 = arith.addf %7, %cst : f32 + %9 = arith.divf %cst, %8 : f32 + %10 = arith.subf %cst, %9 : f32 + %11 = arith.mulf %in_1, %10 : f32 + %12 = arith.select %6, %in_0, %11 : f32 + linalg.yield %12 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_softplus_backward_linalg.mlir b/issues/aten_c_kernels/results/aten_softplus_backward_linalg.mlir new file mode 100644 index 000000000000..36c6adab98f7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softplus_backward_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softplus_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0, %arg0 : memref, memref, memref) outs(%arg4 : memref) { + ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.mulf %arg2, %in : f32 + %1 = arith.cmpf ogt, %0, %arg3 : f32 + %2 = math.exp %0 : f32 + %3 = arith.addf %2, %cst : f32 + %4 = arith.divf %cst, %3 : f32 + %5 = arith.subf %cst, %4 : f32 + %6 = arith.mulf %in_1, %5 : f32 + %7 = arith.select %1, %in_0, %6 : f32 + linalg.yield %7 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_softplus_debuf.mlir b/issues/aten_c_kernels/results/aten_softplus_debuf.mlir new file mode 100644 index 000000000000..b28d6ef34a84 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softplus_debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softplus(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg0[%3] : memref + %5 = arith.mulf %arg2, %4 : f32 + %6 = arith.cmpf ogt, %5, %arg3 : f32 + %7 = scf.if %6 -> (f32) { + %8 = memref.load %arg0[%3] : memref + scf.yield %8 : f32 + } else { + %8 = math.exp %5 : f32 + %9 = arith.addf %8, %cst : f32 + %10 = math.log %9 : f32 + %11 = arith.divf %10, %arg2 : f32 + scf.yield %11 : f32 + } + linalg.yield %7 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } + func.func private @logf(f32) -> f32 +} + diff --git a/issues/aten_c_kernels/results/aten_softplus_linalg.mlir b/issues/aten_c_kernels/results/aten_softplus_linalg.mlir new file mode 100644 index 000000000000..c7f2e0c0cafb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softplus_linalg.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softplus(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: f32) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg0[%0] : memref + %2 = arith.mulf %arg2, %1 : f32 + %3 = arith.cmpf ogt, %2, %arg3 : f32 + %4 = scf.if %3 -> (f32) { + %5 = memref.load %arg0[%0] : memref + scf.yield %5 : f32 + } else { + %5 = math.exp %2 : f32 + %6 = arith.addf %5, %cst : f32 + %7 = math.log %6 : f32 + %8 = arith.divf %7, %arg2 : f32 + scf.yield %8 : f32 + } + linalg.yield %4 : f32 + } + return + } + func.func private @logf(f32) -> f32 +} + diff --git a/issues/aten_c_kernels/results/aten_softshrink.mlir b/issues/aten_c_kernels/results/aten_softshrink.mlir new file mode 100644 index 000000000000..3ed64e289dba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softshrink.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softshrink(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = arith.negf %arg1 : f32 + affine.for %arg3 = 0 to 4096 { + %1 = affine.load %arg0[%arg3] : memref + %2 = arith.cmpf ogt, %1, %arg1 : f32 + %3 = scf.if %2 -> (f32) { + %4 = arith.subf %1, %arg1 : f32 + scf.yield %4 : f32 + } else { + %4 = arith.cmpf olt, %1, %0 : f32 + %5 = scf.if %4 -> (f32) { + %6 = arith.addf %1, %arg1 : f32 + scf.yield %6 : f32 + } else { + %6 = arith.mulf %1, %cst : f32 + scf.yield %6 : f32 + } + scf.yield %5 : f32 + } + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_softshrink/debuf.mlir b/issues/aten_c_kernels/results/aten_softshrink/debuf.mlir new file mode 100644 index 000000000000..06e30d6e85ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softshrink/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softshrink(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.negf %arg1 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %arg1 : f32 + %6 = arith.subf %in, %arg1 : f32 + %7 = arith.cmpf olt, %in, %2 : f32 + %8 = arith.addf %in, %arg1 : f32 + %9 = arith.mulf %in, %cst : f32 + %10 = arith.select %7, %8, %9 : f32 + %11 = arith.select %5, %6, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_softshrink/matched.mlir b/issues/aten_c_kernels/results/aten_softshrink/matched.mlir new file mode 100644 index 000000000000..06e30d6e85ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softshrink/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softshrink(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.negf %arg1 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %arg1 : f32 + %6 = arith.subf %in, %arg1 : f32 + %7 = arith.cmpf olt, %in, %2 : f32 + %8 = arith.addf %in, %arg1 : f32 + %9 = arith.mulf %in, %cst : f32 + %10 = arith.select %7, %8, %9 : f32 + %11 = arith.select %5, %6, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_softshrink/orig.mlir b/issues/aten_c_kernels/results/aten_softshrink/orig.mlir new file mode 100644 index 000000000000..3ed64e289dba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softshrink/orig.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softshrink(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = arith.negf %arg1 : f32 + affine.for %arg3 = 0 to 4096 { + %1 = affine.load %arg0[%arg3] : memref + %2 = arith.cmpf ogt, %1, %arg1 : f32 + %3 = scf.if %2 -> (f32) { + %4 = arith.subf %1, %arg1 : f32 + scf.yield %4 : f32 + } else { + %4 = arith.cmpf olt, %1, %0 : f32 + %5 = scf.if %4 -> (f32) { + %6 = arith.addf %1, %arg1 : f32 + scf.yield %6 : f32 + } else { + %6 = arith.mulf %1, %cst : f32 + scf.yield %6 : f32 + } + scf.yield %5 : f32 + } + affine.store %3, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_softshrink/raised.mlir b/issues/aten_c_kernels/results/aten_softshrink/raised.mlir new file mode 100644 index 000000000000..3a7696223cad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softshrink/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softshrink(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = arith.negf %arg1 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.cmpf ogt, %in, %arg1 : f32 + %2 = arith.subf %in, %arg1 : f32 + %3 = arith.cmpf olt, %in, %0 : f32 + %4 = arith.addf %in, %arg1 : f32 + %5 = arith.mulf %in, %cst : f32 + %6 = arith.select %3, %4, %5 : f32 + %7 = arith.select %1, %2, %6 : f32 + linalg.yield %7 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_softshrink_debuf.mlir b/issues/aten_c_kernels/results/aten_softshrink_debuf.mlir new file mode 100644 index 000000000000..06e30d6e85ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softshrink_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softshrink(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.negf %arg1 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.cmpf ogt, %in, %arg1 : f32 + %6 = arith.subf %in, %arg1 : f32 + %7 = arith.cmpf olt, %in, %2 : f32 + %8 = arith.addf %in, %arg1 : f32 + %9 = arith.mulf %in, %cst : f32 + %10 = arith.select %7, %8, %9 : f32 + %11 = arith.select %5, %6, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_softshrink_linalg.mlir b/issues/aten_c_kernels/results/aten_softshrink_linalg.mlir new file mode 100644 index 000000000000..3a7696223cad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_softshrink_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_softshrink(%arg0: memref, %arg1: f32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = arith.negf %arg1 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.cmpf ogt, %in, %arg1 : f32 + %2 = arith.subf %in, %arg1 : f32 + %3 = arith.cmpf olt, %in, %0 : f32 + %4 = arith.addf %in, %arg1 : f32 + %5 = arith.mulf %in, %cst : f32 + %6 = arith.select %3, %4, %5 : f32 + %7 = arith.select %1, %2, %6 : f32 + linalg.yield %7 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sort_cpu.mlir b/issues/aten_c_kernels/results/aten_sort_cpu.mlir new file mode 100644 index 000000000000..433554163e4b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sort_cpu.mlir @@ -0,0 +1,54 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sort_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 64 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg0[%arg3, %arg4] : memref + affine.store %1, %arg1[%arg3, %arg4] : memref + affine.store %0, %arg2[%arg3, %arg4] : memref + } + affine.for %arg4 = 1 to 64 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = affine.load %arg2[%arg3, %arg4] : memref + %3 = arith.addi %0, %c-1_i32 : i32 + %4 = scf.while (%arg5 = %3) : (i32) -> i32 { + %7 = arith.cmpi sge, %arg5, %c0_i32 : i32 + %8:2 = scf.if %7 -> (i1, i32) { + %9 = arith.index_cast %arg5 : i32 to index + %10 = memref.load %arg1[%arg3, %9] : memref + %11 = arith.cmpf olt, %10, %1 : f32 + %12 = scf.if %11 -> (i32) { + %13 = arith.addi %arg5, %c1_i32 : i32 + %14 = arith.index_cast %13 : i32 to index + %15 = memref.load %arg1[%arg3, %9] : memref + memref.store %15, %arg1[%arg3, %14] : memref + %16 = memref.load %arg2[%arg3, %9] : memref + memref.store %16, %arg2[%arg3, %14] : memref + %17 = arith.addi %arg5, %c-1_i32 : i32 + scf.yield %17 : i32 + } else { + scf.yield %arg5 : i32 + } + scf.yield %11, %12 : i1, i32 + } else { + scf.yield %false, %arg5 : i1, i32 + } + scf.condition(%8#0) %8#1 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %5 = arith.addi %4, %c1_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + memref.store %1, %arg1[%arg3, %6] : memref + memref.store %2, %arg2[%arg3, %6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sort_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sort_cpu/debuf.mlir new file mode 100644 index 000000000000..1c81440c47ff --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sort_cpu/debuf.mlir @@ -0,0 +1,76 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sort_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c-1_i32 = arith.constant -1 : i32 + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice_1 : tensor) { + ^bb0(%out: i32): + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + linalg.yield %9 : i32 + } -> tensor + %inserted_slice_2 = tensor.insert_slice %4 into %1[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %5:2 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %inserted_slice, %arg5 = %inserted_slice_2) -> (tensor, tensor) { + %8:2 = affine.for %arg6 = 1 to 64 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %9 = arith.index_cast %arg6 : index to i32 + %extracted = tensor.extract %arg7[%arg3, %arg6] : tensor + %extracted_3 = tensor.extract %arg8[%arg3, %arg6] : tensor + %10 = arith.addi %9, %c-1_i32 : i32 + %11:3 = scf.while (%arg9 = %10, %arg10 = %arg7, %arg11 = %arg8) : (i32, tensor, tensor) -> (i32, tensor, tensor) { + %14 = arith.cmpi sge, %arg9, %c0_i32 : i32 + %15:4 = scf.if %14 -> (i1, i32, tensor, tensor) { + %16 = arith.index_cast %arg9 : i32 to index + %extracted_5 = tensor.extract %arg10[%arg3, %16] : tensor + %17 = arith.cmpf olt, %extracted_5, %extracted : f32 + %18:3 = scf.if %17 -> (i32, tensor, tensor) { + %19 = arith.addi %arg9, %c1_i32 : i32 + %20 = arith.index_cast %19 : i32 to index + %extracted_6 = tensor.extract %arg10[%arg3, %16] : tensor + %inserted_7 = tensor.insert %extracted_6 into %arg10[%arg3, %20] : tensor + %extracted_8 = tensor.extract %arg11[%arg3, %16] : tensor + %inserted_9 = tensor.insert %extracted_8 into %arg11[%arg3, %20] : tensor + %21 = arith.addi %arg9, %c-1_i32 : i32 + scf.yield %21, %inserted_7, %inserted_9 : i32, tensor, tensor + } else { + scf.yield %arg9, %arg10, %arg11 : i32, tensor, tensor + } + scf.yield %17, %18#0, %18#1, %18#2 : i1, i32, tensor, tensor + } else { + scf.yield %false, %arg9, %arg10, %arg11 : i1, i32, tensor, tensor + } + scf.condition(%15#0) %15#1, %15#2, %15#3 : i32, tensor, tensor + } do { + ^bb0(%arg9: i32, %arg10: tensor, %arg11: tensor): + scf.yield %arg9, %arg10, %arg11 : i32, tensor, tensor + } + %12 = arith.addi %11#0, %c1_i32 : i32 + %13 = arith.index_cast %12 : i32 to index + %inserted = tensor.insert %extracted into %11#1[%arg3, %13] : tensor + %inserted_4 = tensor.insert %extracted_3 into %11#2[%arg3, %13] : tensor + affine.yield %inserted, %inserted_4 : tensor, tensor + } + affine.yield %8#0, %8#1 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg2 : memref to memref + %7 = bufferization.to_memref %5#0 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sort_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sort_cpu/matched.mlir new file mode 100644 index 000000000000..8cb0bcfb7b64 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sort_cpu/matched.mlir @@ -0,0 +1,73 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sort_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c-1_i32 = arith.constant -1 : i32 + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %3 = kernel.launch @cudaCopy2D_f32_tensor(%extracted_slice_0, %extracted_slice) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice_1 : tensor) { + ^bb0(%out: i32): + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + linalg.yield %9 : i32 + } -> tensor + %inserted_slice_2 = tensor.insert_slice %4 into %1[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %5:2 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %inserted_slice, %arg5 = %inserted_slice_2) -> (tensor, tensor) { + %8:2 = affine.for %arg6 = 1 to 64 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %9 = arith.index_cast %arg6 : index to i32 + %extracted = tensor.extract %arg7[%arg3, %arg6] : tensor + %extracted_3 = tensor.extract %arg8[%arg3, %arg6] : tensor + %10 = arith.addi %9, %c-1_i32 : i32 + %11:3 = scf.while (%arg9 = %10, %arg10 = %arg7, %arg11 = %arg8) : (i32, tensor, tensor) -> (i32, tensor, tensor) { + %14 = arith.cmpi sge, %arg9, %c0_i32 : i32 + %15:4 = scf.if %14 -> (i1, i32, tensor, tensor) { + %16 = arith.index_cast %arg9 : i32 to index + %extracted_5 = tensor.extract %arg10[%arg3, %16] : tensor + %17 = arith.cmpf olt, %extracted_5, %extracted : f32 + %18:3 = scf.if %17 -> (i32, tensor, tensor) { + %19 = arith.addi %arg9, %c1_i32 : i32 + %20 = arith.index_cast %19 : i32 to index + %extracted_6 = tensor.extract %arg10[%arg3, %16] : tensor + %inserted_7 = tensor.insert %extracted_6 into %arg10[%arg3, %20] : tensor + %extracted_8 = tensor.extract %arg11[%arg3, %16] : tensor + %inserted_9 = tensor.insert %extracted_8 into %arg11[%arg3, %20] : tensor + %21 = arith.addi %arg9, %c-1_i32 : i32 + scf.yield %21, %inserted_7, %inserted_9 : i32, tensor, tensor + } else { + scf.yield %arg9, %arg10, %arg11 : i32, tensor, tensor + } + scf.yield %17, %18#0, %18#1, %18#2 : i1, i32, tensor, tensor + } else { + scf.yield %false, %arg9, %arg10, %arg11 : i1, i32, tensor, tensor + } + scf.condition(%15#0) %15#1, %15#2, %15#3 : i32, tensor, tensor + } do { + ^bb0(%arg9: i32, %arg10: tensor, %arg11: tensor): + scf.yield %arg9, %arg10, %arg11 : i32, tensor, tensor + } + %12 = arith.addi %11#0, %c1_i32 : i32 + %13 = arith.index_cast %12 : i32 to index + %inserted = tensor.insert %extracted into %11#1[%arg3, %13] : tensor + %inserted_4 = tensor.insert %extracted_3 into %11#2[%arg3, %13] : tensor + affine.yield %inserted, %inserted_4 : tensor, tensor + } + affine.yield %8#0, %8#1 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg2 : memref to memref + %7 = bufferization.to_memref %5#0 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sort_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sort_cpu/orig.mlir new file mode 100644 index 000000000000..433554163e4b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sort_cpu/orig.mlir @@ -0,0 +1,54 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sort_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 64 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg0[%arg3, %arg4] : memref + affine.store %1, %arg1[%arg3, %arg4] : memref + affine.store %0, %arg2[%arg3, %arg4] : memref + } + affine.for %arg4 = 1 to 64 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = affine.load %arg2[%arg3, %arg4] : memref + %3 = arith.addi %0, %c-1_i32 : i32 + %4 = scf.while (%arg5 = %3) : (i32) -> i32 { + %7 = arith.cmpi sge, %arg5, %c0_i32 : i32 + %8:2 = scf.if %7 -> (i1, i32) { + %9 = arith.index_cast %arg5 : i32 to index + %10 = memref.load %arg1[%arg3, %9] : memref + %11 = arith.cmpf olt, %10, %1 : f32 + %12 = scf.if %11 -> (i32) { + %13 = arith.addi %arg5, %c1_i32 : i32 + %14 = arith.index_cast %13 : i32 to index + %15 = memref.load %arg1[%arg3, %9] : memref + memref.store %15, %arg1[%arg3, %14] : memref + %16 = memref.load %arg2[%arg3, %9] : memref + memref.store %16, %arg2[%arg3, %14] : memref + %17 = arith.addi %arg5, %c-1_i32 : i32 + scf.yield %17 : i32 + } else { + scf.yield %arg5 : i32 + } + scf.yield %11, %12 : i1, i32 + } else { + scf.yield %false, %arg5 : i1, i32 + } + scf.condition(%8#0) %8#1 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %5 = arith.addi %4, %c1_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + memref.store %1, %arg1[%arg3, %6] : memref + memref.store %2, %arg2[%arg3, %6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sort_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sort_cpu/raised.mlir new file mode 100644 index 000000000000..851b213e9b37 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sort_cpu/raised.mlir @@ -0,0 +1,65 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sort_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c16, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_1 = memref.subview %arg2[0, 0] [%c16, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview_1 : memref>) { + ^bb0(%out: i32): + %0 = linalg.index 1 : index + %1 = arith.index_cast %0 : index to i32 + linalg.yield %1 : i32 + } + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 1 to 64 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = affine.load %arg2[%arg3, %arg4] : memref + %3 = arith.addi %0, %c-1_i32 : i32 + %4 = scf.while (%arg5 = %3) : (i32) -> i32 { + %7 = arith.cmpi sge, %arg5, %c0_i32 : i32 + %8:2 = scf.if %7 -> (i1, i32) { + %9 = arith.index_cast %arg5 : i32 to index + %10 = memref.load %arg1[%arg3, %9] : memref + %11 = arith.cmpf olt, %10, %1 : f32 + %12 = scf.if %11 -> (i32) { + %13 = arith.addi %arg5, %c1_i32 : i32 + %14 = arith.index_cast %13 : i32 to index + %15 = memref.load %arg1[%arg3, %9] : memref + memref.store %15, %arg1[%arg3, %14] : memref + %16 = memref.load %arg2[%arg3, %9] : memref + memref.store %16, %arg2[%arg3, %14] : memref + %17 = arith.addi %arg5, %c-1_i32 : i32 + scf.yield %17 : i32 + } else { + scf.yield %arg5 : i32 + } + scf.yield %11, %12 : i1, i32 + } else { + scf.yield %false, %arg5 : i1, i32 + } + scf.condition(%8#0) %8#1 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %5 = arith.addi %4, %c1_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + memref.store %1, %arg1[%arg3, %6] : memref + memref.store %2, %arg2[%arg3, %6] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sort_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sort_cpu_debuf.mlir new file mode 100644 index 000000000000..1c81440c47ff --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sort_cpu_debuf.mlir @@ -0,0 +1,76 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sort_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c-1_i32 = arith.constant -1 : i32 + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %2[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice_1 : tensor) { + ^bb0(%out: i32): + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + linalg.yield %9 : i32 + } -> tensor + %inserted_slice_2 = tensor.insert_slice %4 into %1[0, 0] [%c16, %c64] [1, 1] : tensor into tensor + %5:2 = affine.for %arg3 = 0 to 16 iter_args(%arg4 = %inserted_slice, %arg5 = %inserted_slice_2) -> (tensor, tensor) { + %8:2 = affine.for %arg6 = 1 to 64 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %9 = arith.index_cast %arg6 : index to i32 + %extracted = tensor.extract %arg7[%arg3, %arg6] : tensor + %extracted_3 = tensor.extract %arg8[%arg3, %arg6] : tensor + %10 = arith.addi %9, %c-1_i32 : i32 + %11:3 = scf.while (%arg9 = %10, %arg10 = %arg7, %arg11 = %arg8) : (i32, tensor, tensor) -> (i32, tensor, tensor) { + %14 = arith.cmpi sge, %arg9, %c0_i32 : i32 + %15:4 = scf.if %14 -> (i1, i32, tensor, tensor) { + %16 = arith.index_cast %arg9 : i32 to index + %extracted_5 = tensor.extract %arg10[%arg3, %16] : tensor + %17 = arith.cmpf olt, %extracted_5, %extracted : f32 + %18:3 = scf.if %17 -> (i32, tensor, tensor) { + %19 = arith.addi %arg9, %c1_i32 : i32 + %20 = arith.index_cast %19 : i32 to index + %extracted_6 = tensor.extract %arg10[%arg3, %16] : tensor + %inserted_7 = tensor.insert %extracted_6 into %arg10[%arg3, %20] : tensor + %extracted_8 = tensor.extract %arg11[%arg3, %16] : tensor + %inserted_9 = tensor.insert %extracted_8 into %arg11[%arg3, %20] : tensor + %21 = arith.addi %arg9, %c-1_i32 : i32 + scf.yield %21, %inserted_7, %inserted_9 : i32, tensor, tensor + } else { + scf.yield %arg9, %arg10, %arg11 : i32, tensor, tensor + } + scf.yield %17, %18#0, %18#1, %18#2 : i1, i32, tensor, tensor + } else { + scf.yield %false, %arg9, %arg10, %arg11 : i1, i32, tensor, tensor + } + scf.condition(%15#0) %15#1, %15#2, %15#3 : i32, tensor, tensor + } do { + ^bb0(%arg9: i32, %arg10: tensor, %arg11: tensor): + scf.yield %arg9, %arg10, %arg11 : i32, tensor, tensor + } + %12 = arith.addi %11#0, %c1_i32 : i32 + %13 = arith.index_cast %12 : i32 to index + %inserted = tensor.insert %extracted into %11#1[%arg3, %13] : tensor + %inserted_4 = tensor.insert %extracted_3 into %11#2[%arg3, %13] : tensor + affine.yield %inserted, %inserted_4 : tensor, tensor + } + affine.yield %8#0, %8#1 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg2 : memref to memref + %7 = bufferization.to_memref %5#0 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sort_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sort_cpu_linalg.mlir new file mode 100644 index 000000000000..851b213e9b37 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sort_cpu_linalg.mlir @@ -0,0 +1,65 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sort_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c16, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_1 = memref.subview %arg2[0, 0] [%c16, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview_1 : memref>) { + ^bb0(%out: i32): + %0 = linalg.index 1 : index + %1 = arith.index_cast %0 : index to i32 + linalg.yield %1 : i32 + } + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 1 to 64 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = affine.load %arg2[%arg3, %arg4] : memref + %3 = arith.addi %0, %c-1_i32 : i32 + %4 = scf.while (%arg5 = %3) : (i32) -> i32 { + %7 = arith.cmpi sge, %arg5, %c0_i32 : i32 + %8:2 = scf.if %7 -> (i1, i32) { + %9 = arith.index_cast %arg5 : i32 to index + %10 = memref.load %arg1[%arg3, %9] : memref + %11 = arith.cmpf olt, %10, %1 : f32 + %12 = scf.if %11 -> (i32) { + %13 = arith.addi %arg5, %c1_i32 : i32 + %14 = arith.index_cast %13 : i32 to index + %15 = memref.load %arg1[%arg3, %9] : memref + memref.store %15, %arg1[%arg3, %14] : memref + %16 = memref.load %arg2[%arg3, %9] : memref + memref.store %16, %arg2[%arg3, %14] : memref + %17 = arith.addi %arg5, %c-1_i32 : i32 + scf.yield %17 : i32 + } else { + scf.yield %arg5 : i32 + } + scf.yield %11, %12 : i1, i32 + } else { + scf.yield %false, %arg5 : i1, i32 + } + scf.condition(%8#0) %8#1 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %5 = arith.addi %4, %c1_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + memref.store %1, %arg1[%arg3, %6] : memref + memref.store %2, %arg2[%arg3, %6] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_add_values_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_add_values_cpu.mlir new file mode 100644 index 000000000000..357b7a08ba91 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_add_values_cpu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_add_values_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 1024 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.mulf %arg2, %1 : f32 + %3 = arith.addf %0, %2 : f32 + affine.store %3, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_add_values_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_add_values_cpu/debuf.mlir new file mode 100644 index 000000000000..c84697adf917 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_add_values_cpu/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_add_values_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %arg2, %in_0 : f32 + %6 = arith.addf %in, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_add_values_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_add_values_cpu/matched.mlir new file mode 100644 index 000000000000..c84697adf917 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_add_values_cpu/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_add_values_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %arg2, %in_0 : f32 + %6 = arith.addf %in, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_add_values_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_add_values_cpu/orig.mlir new file mode 100644 index 000000000000..357b7a08ba91 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_add_values_cpu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_add_values_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg4 = 0 to 1024 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.mulf %arg2, %1 : f32 + %3 = arith.addf %0, %2 : f32 + affine.store %3, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_add_values_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_add_values_cpu/raised.mlir new file mode 100644 index 000000000000..68b8f2f10874 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_add_values_cpu/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_add_values_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %arg2, %in_0 : f32 + %1 = arith.addf %in, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_add_values_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_add_values_cpu_debuf.mlir new file mode 100644 index 000000000000..c84697adf917 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_add_values_cpu_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_add_values_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %arg2, %in_0 : f32 + %6 = arith.addf %in, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_add_values_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_add_values_cpu_linalg.mlir new file mode 100644 index 000000000000..68b8f2f10874 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_add_values_cpu_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_add_values_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %arg2, %in_0 : f32 + %1 = arith.addf %in, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_addmm_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_addmm_cpu.mlir new file mode 100644 index 000000000000..34b41da63b69 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmm_cpu.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + affine.for %arg6 = 0 to 48 { + affine.store %cst, %arg4[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 0 to 512 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg0[%arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg5] : memref + %3 = affine.load %arg1[%arg5] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg3[%4, %arg6] : memref + %6 = arith.mulf %2, %5 : f32 + %7 = memref.load %arg4[%1, %arg6] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg4[%1, %arg6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_addmm_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_addmm_cpu/debuf.mlir new file mode 100644 index 000000000000..a607b7ac2aee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmm_cpu/debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c64, %c48] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %8 = affine.for %arg7 = 0 to 48 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %9 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg5] : tensor + %extracted_1 = tensor.extract %3[%arg5] : tensor + %10 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %1[%10, %arg7] : tensor + %11 = arith.mulf %extracted_0, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg8[%9, %arg7] : tensor + %12 = arith.addf %extracted_3, %11 : f32 + %inserted = tensor.insert %12 into %arg8[%9, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %8 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_addmm_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_addmm_cpu/matched.mlir new file mode 100644 index 000000000000..9e514528b6e0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmm_cpu/matched.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %5 = kernel.launch @memset_zero_2D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c64, %c48] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %8 = affine.for %arg7 = 0 to 48 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %9 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg5] : tensor + %extracted_1 = tensor.extract %3[%arg5] : tensor + %10 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %1[%10, %arg7] : tensor + %11 = arith.mulf %extracted_0, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg8[%9, %arg7] : tensor + %12 = arith.addf %extracted_3, %11 : f32 + %inserted = tensor.insert %12 into %arg8[%9, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %8 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_addmm_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_addmm_cpu/orig.mlir new file mode 100644 index 000000000000..34b41da63b69 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmm_cpu/orig.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + affine.for %arg6 = 0 to 48 { + affine.store %cst, %arg4[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 0 to 512 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg0[%arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg5] : memref + %3 = affine.load %arg1[%arg5] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg3[%4, %arg6] : memref + %6 = arith.mulf %2, %5 : f32 + %7 = memref.load %arg4[%1, %arg6] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg4[%1, %arg6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_addmm_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_addmm_cpu/raised.mlir new file mode 100644 index 000000000000..29bbc5481609 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmm_cpu/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg4[0, 0] [%c64, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg5 = 0 to 512 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg0[%arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg5] : memref + %3 = affine.load %arg1[%arg5] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg3[%4, %arg6] : memref + %6 = arith.mulf %2, %5 : f32 + %7 = memref.load %arg4[%1, %arg6] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg4[%1, %arg6] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_addmm_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_addmm_cpu_debuf.mlir new file mode 100644 index 000000000000..a607b7ac2aee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmm_cpu_debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c64, %c48] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %8 = affine.for %arg7 = 0 to 48 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %9 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg5] : tensor + %extracted_1 = tensor.extract %3[%arg5] : tensor + %10 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %1[%10, %arg7] : tensor + %11 = arith.mulf %extracted_0, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg8[%9, %arg7] : tensor + %12 = arith.addf %extracted_3, %11 : f32 + %inserted = tensor.insert %12 into %arg8[%9, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %8 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_addmm_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_addmm_cpu_linalg.mlir new file mode 100644 index 000000000000..29bbc5481609 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmm_cpu_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg4[0, 0] [%c64, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg5 = 0 to 512 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg0[%arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg5] : memref + %3 = affine.load %arg1[%arg5] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg3[%4, %arg6] : memref + %6 = arith.mulf %2, %5 : f32 + %7 = memref.load %arg4[%1, %arg6] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg4[%1, %arg6] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu.mlir new file mode 100644 index 000000000000..165b9bed76a2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmv_bsr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 4 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg7 = %3 to %2 step %c1 iter_args(%arg8 = %cst) -> (f32) { + %5 = memref.load %arg1[%arg7] : memref + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %arg8) -> (f32) { + %8 = arith.index_cast %arg9 : index to i32 + %9 = memref.load %arg2[%arg7, %arg6, %arg9] : memref + %10 = arith.addi %6, %8 : i32 + %11 = arith.index_cast %10 : i32 to index + %12 = memref.load %arg3[%11] : memref + %13 = arith.mulf %9, %12 : f32 + %14 = arith.addf %arg10, %13 : f32 + affine.yield %14 : f32 + } + scf.yield %7 : f32 + } + affine.store %4, %arg4[%arg6 + %arg5 * 4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu/debuf.mlir new file mode 100644 index 000000000000..0eb58c74741f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu/debuf.mlir @@ -0,0 +1,55 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d0 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmv_bsr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %0) -> (tensor) { + %5 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %2[%arg5] : tensor + %6 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %2[%6] : tensor + %7 = arith.index_cast %extracted_0 : i32 to index + %8 = arith.index_cast %extracted : i32 to index + %9 = scf.for %arg9 = %8 to %7 step %c1 iter_args(%arg10 = %cst) -> (f32) { + %extracted_1 = tensor.extract %1[%arg9] : tensor + %11 = arith.muli %extracted_1, %c4_i32 : i32 + %alloca = memref.alloca() : memref + %12 = bufferization.to_tensor %alloca : memref + %inserted_2 = tensor.insert %arg10 into %12[] : tensor + %13 = polygeist.submap(%inserted_2, %c4) {map = #map1} : (tensor, index) -> tensor + %14 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction"], library_call = ""} outs(%13 : tensor) { + ^bb0(%out: f32): + %16 = linalg.index 0 : index + %17 = arith.index_cast %16 : index to i32 + %18 = memref.load %arg2[%arg9, %arg7, %16] : memref + %19 = arith.addi %11, %17 : i32 + %20 = arith.index_cast %19 : i32 to index + %21 = memref.load %arg3[%20] : memref + %22 = arith.mulf %18, %21 : f32 + %23 = arith.addf %out, %22 : f32 + linalg.yield %23 : f32 + } -> tensor + %15 = polygeist.submapInverse(%inserted_2, %14, %c4) {map = #map1} : (tensor, tensor, index) -> tensor + %extracted_3 = tensor.extract %15[] : tensor + scf.yield %extracted_3 : f32 + } + %10 = affine.apply #map3(%arg7, %arg5) + %inserted = tensor.insert %9 into %arg8[%10] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu/matched.mlir new file mode 100644 index 000000000000..0eb58c74741f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu/matched.mlir @@ -0,0 +1,55 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d0 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmv_bsr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %0) -> (tensor) { + %5 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %2[%arg5] : tensor + %6 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %2[%6] : tensor + %7 = arith.index_cast %extracted_0 : i32 to index + %8 = arith.index_cast %extracted : i32 to index + %9 = scf.for %arg9 = %8 to %7 step %c1 iter_args(%arg10 = %cst) -> (f32) { + %extracted_1 = tensor.extract %1[%arg9] : tensor + %11 = arith.muli %extracted_1, %c4_i32 : i32 + %alloca = memref.alloca() : memref + %12 = bufferization.to_tensor %alloca : memref + %inserted_2 = tensor.insert %arg10 into %12[] : tensor + %13 = polygeist.submap(%inserted_2, %c4) {map = #map1} : (tensor, index) -> tensor + %14 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction"], library_call = ""} outs(%13 : tensor) { + ^bb0(%out: f32): + %16 = linalg.index 0 : index + %17 = arith.index_cast %16 : index to i32 + %18 = memref.load %arg2[%arg9, %arg7, %16] : memref + %19 = arith.addi %11, %17 : i32 + %20 = arith.index_cast %19 : i32 to index + %21 = memref.load %arg3[%20] : memref + %22 = arith.mulf %18, %21 : f32 + %23 = arith.addf %out, %22 : f32 + linalg.yield %23 : f32 + } -> tensor + %15 = polygeist.submapInverse(%inserted_2, %14, %c4) {map = #map1} : (tensor, tensor, index) -> tensor + %extracted_3 = tensor.extract %15[] : tensor + scf.yield %extracted_3 : f32 + } + %10 = affine.apply #map3(%arg7, %arg5) + %inserted = tensor.insert %9 into %arg8[%10] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu/orig.mlir new file mode 100644 index 000000000000..165b9bed76a2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu/orig.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmv_bsr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 4 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg7 = %3 to %2 step %c1 iter_args(%arg8 = %cst) -> (f32) { + %5 = memref.load %arg1[%arg7] : memref + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %arg8) -> (f32) { + %8 = arith.index_cast %arg9 : index to i32 + %9 = memref.load %arg2[%arg7, %arg6, %arg9] : memref + %10 = arith.addi %6, %8 : i32 + %11 = arith.index_cast %10 : i32 to index + %12 = memref.load %arg3[%11] : memref + %13 = arith.mulf %9, %12 : f32 + %14 = arith.addf %arg10, %13 : f32 + affine.yield %14 : f32 + } + scf.yield %7 : f32 + } + affine.store %4, %arg4[%arg6 + %arg5 * 4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu/raised.mlir new file mode 100644 index 000000000000..59f7851f3fd3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu/raised.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> ()> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmv_bsr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 4 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg7 = %3 to %2 step %c1 iter_args(%arg8 = %cst) -> (f32) { + %5 = memref.load %arg1[%arg7] : memref + %6 = arith.muli %5, %c4_i32 : i32 + %alloca = memref.alloca() : memref + affine.store %arg8, %alloca[] : memref + %7 = polygeist.submap(%alloca, %c4) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction"]} outs(%7 : memref) { + ^bb0(%out: f32): + %9 = linalg.index 0 : index + %10 = arith.index_cast %9 : index to i32 + %11 = memref.load %arg2[%arg7, %arg6, %9] : memref + %12 = arith.addi %6, %10 : i32 + %13 = arith.index_cast %12 : i32 to index + %14 = memref.load %arg3[%13] : memref + %15 = arith.mulf %11, %14 : f32 + %16 = arith.addf %out, %15 : f32 + linalg.yield %16 : f32 + } + %8 = affine.load %alloca[] : memref + scf.yield %8 : f32 + } + affine.store %4, %arg4[%arg6 + %arg5 * 4] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu_debuf.mlir new file mode 100644 index 000000000000..0eb58c74741f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu_debuf.mlir @@ -0,0 +1,55 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d0 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmv_bsr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %0) -> (tensor) { + %5 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %2[%arg5] : tensor + %6 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %2[%6] : tensor + %7 = arith.index_cast %extracted_0 : i32 to index + %8 = arith.index_cast %extracted : i32 to index + %9 = scf.for %arg9 = %8 to %7 step %c1 iter_args(%arg10 = %cst) -> (f32) { + %extracted_1 = tensor.extract %1[%arg9] : tensor + %11 = arith.muli %extracted_1, %c4_i32 : i32 + %alloca = memref.alloca() : memref + %12 = bufferization.to_tensor %alloca : memref + %inserted_2 = tensor.insert %arg10 into %12[] : tensor + %13 = polygeist.submap(%inserted_2, %c4) {map = #map1} : (tensor, index) -> tensor + %14 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction"], library_call = ""} outs(%13 : tensor) { + ^bb0(%out: f32): + %16 = linalg.index 0 : index + %17 = arith.index_cast %16 : index to i32 + %18 = memref.load %arg2[%arg9, %arg7, %16] : memref + %19 = arith.addi %11, %17 : i32 + %20 = arith.index_cast %19 : i32 to index + %21 = memref.load %arg3[%20] : memref + %22 = arith.mulf %18, %21 : f32 + %23 = arith.addf %out, %22 : f32 + linalg.yield %23 : f32 + } -> tensor + %15 = polygeist.submapInverse(%inserted_2, %14, %c4) {map = #map1} : (tensor, tensor, index) -> tensor + %extracted_3 = tensor.extract %15[] : tensor + scf.yield %extracted_3 : f32 + } + %10 = affine.apply #map3(%arg7, %arg5) + %inserted = tensor.insert %9 into %arg8[%10] : tensor + affine.yield %inserted : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu_linalg.mlir new file mode 100644 index 000000000000..59f7851f3fd3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmv_bsr_cpu_linalg.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> ()> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmv_bsr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 4 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg7 = %3 to %2 step %c1 iter_args(%arg8 = %cst) -> (f32) { + %5 = memref.load %arg1[%arg7] : memref + %6 = arith.muli %5, %c4_i32 : i32 + %alloca = memref.alloca() : memref + affine.store %arg8, %alloca[] : memref + %7 = polygeist.submap(%alloca, %c4) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction"]} outs(%7 : memref) { + ^bb0(%out: f32): + %9 = linalg.index 0 : index + %10 = arith.index_cast %9 : index to i32 + %11 = memref.load %arg2[%arg7, %arg6, %9] : memref + %12 = arith.addi %6, %10 : i32 + %13 = arith.index_cast %12 : i32 to index + %14 = memref.load %arg3[%13] : memref + %15 = arith.mulf %11, %14 : f32 + %16 = arith.addf %out, %15 : f32 + linalg.yield %16 : f32 + } + %8 = affine.load %alloca[] : memref + scf.yield %8 : f32 + } + affine.store %4, %arg4[%arg6 + %arg5 * 4] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu.mlir new file mode 100644 index 000000000000..98a02a27e718 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmv_csr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg6 = %3 to %2 step %c1 iter_args(%arg7 = %cst) -> (f32) { + %5 = memref.load %arg2[%arg6] : memref + %6 = memref.load %arg1[%arg6] : memref + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg3[%7] : memref + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg7, %9 : f32 + scf.yield %10 : f32 + } + affine.store %4, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu/debuf.mlir new file mode 100644 index 000000000000..21d0b494a60b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu/debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmv_csr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %0) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %7 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %4[%7] : tensor + %8 = arith.index_cast %extracted_0 : i32 to index + %9 = arith.index_cast %extracted : i32 to index + %10 = scf.for %arg7 = %9 to %8 step %c1 iter_args(%arg8 = %cst) -> (f32) { + %extracted_1 = tensor.extract %2[%arg7] : tensor + %extracted_2 = tensor.extract %3[%arg7] : tensor + %11 = arith.index_cast %extracted_2 : i32 to index + %extracted_3 = tensor.extract %1[%11] : tensor + %12 = arith.mulf %extracted_1, %extracted_3 : f32 + %13 = arith.addf %arg8, %12 : f32 + scf.yield %13 : f32 + } + %inserted = tensor.insert %10 into %arg6[%arg5] : tensor + affine.yield %inserted : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu/matched.mlir new file mode 100644 index 000000000000..21d0b494a60b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu/matched.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmv_csr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %0) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %7 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %4[%7] : tensor + %8 = arith.index_cast %extracted_0 : i32 to index + %9 = arith.index_cast %extracted : i32 to index + %10 = scf.for %arg7 = %9 to %8 step %c1 iter_args(%arg8 = %cst) -> (f32) { + %extracted_1 = tensor.extract %2[%arg7] : tensor + %extracted_2 = tensor.extract %3[%arg7] : tensor + %11 = arith.index_cast %extracted_2 : i32 to index + %extracted_3 = tensor.extract %1[%11] : tensor + %12 = arith.mulf %extracted_1, %extracted_3 : f32 + %13 = arith.addf %arg8, %12 : f32 + scf.yield %13 : f32 + } + %inserted = tensor.insert %10 into %arg6[%arg5] : tensor + affine.yield %inserted : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu/orig.mlir new file mode 100644 index 000000000000..98a02a27e718 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmv_csr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg6 = %3 to %2 step %c1 iter_args(%arg7 = %cst) -> (f32) { + %5 = memref.load %arg2[%arg6] : memref + %6 = memref.load %arg1[%arg6] : memref + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg3[%7] : memref + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg7, %9 : f32 + scf.yield %10 : f32 + } + affine.store %4, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu/raised.mlir new file mode 100644 index 000000000000..2af9b9abc8b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu/raised.mlir @@ -0,0 +1,24 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmv_csr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg6 = %3 to %2 step %c1 iter_args(%arg7 = %cst) -> (f32) { + %5 = memref.load %arg2[%arg6] : memref + %6 = memref.load %arg1[%arg6] : memref + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg3[%7] : memref + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg7, %9 : f32 + scf.yield %10 : f32 + } + affine.store %4, %arg4[%arg5] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu_debuf.mlir new file mode 100644 index 000000000000..21d0b494a60b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu_debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmv_csr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %0) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %7 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %4[%7] : tensor + %8 = arith.index_cast %extracted_0 : i32 to index + %9 = arith.index_cast %extracted : i32 to index + %10 = scf.for %arg7 = %9 to %8 step %c1 iter_args(%arg8 = %cst) -> (f32) { + %extracted_1 = tensor.extract %2[%arg7] : tensor + %extracted_2 = tensor.extract %3[%arg7] : tensor + %11 = arith.index_cast %extracted_2 : i32 to index + %extracted_3 = tensor.extract %1[%11] : tensor + %12 = arith.mulf %extracted_1, %extracted_3 : f32 + %13 = arith.addf %arg8, %12 : f32 + scf.yield %13 : f32 + } + %inserted = tensor.insert %10 into %arg6[%arg5] : tensor + affine.yield %inserted : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu_linalg.mlir new file mode 100644 index 000000000000..2af9b9abc8b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_addmv_csr_cpu_linalg.mlir @@ -0,0 +1,24 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_addmv_csr_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg6 = %3 to %2 step %c1 iter_args(%arg7 = %cst) -> (f32) { + %5 = memref.load %arg2[%arg6] : memref + %6 = memref.load %arg1[%arg6] : memref + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg3[%7] : memref + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg7, %9 : f32 + scf.yield %10 : f32 + } + affine.store %4, %arg4[%arg5] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_bmm_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_bmm_cpu.mlir new file mode 100644 index 000000000000..b01356789b57 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_bmm_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_bmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 24 { + %0 = affine.for %arg6 = 0 to 40 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4, %arg6] : memref + %2 = affine.load %arg1[%arg3, %arg6, %arg5] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg7, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_bmm_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_bmm_cpu/debuf.mlir new file mode 100644 index 000000000000..3d202571386b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_bmm_cpu/debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_bmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c40 = arith.constant 40 : index + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c4, %c32, %c40] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c4, %c40, %c24] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_bmm_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_bmm_cpu/matched.mlir new file mode 100644 index 000000000000..3d202571386b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_bmm_cpu/matched.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_bmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c40 = arith.constant 40 : index + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c4, %c32, %c40] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c4, %c40, %c24] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_bmm_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_bmm_cpu/orig.mlir new file mode 100644 index 000000000000..b01356789b57 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_bmm_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_bmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 32 { + affine.for %arg5 = 0 to 24 { + %0 = affine.for %arg6 = 0 to 40 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4, %arg6] : memref + %2 = affine.load %arg1[%arg3, %arg6, %arg5] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg7, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_bmm_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_bmm_cpu/raised.mlir new file mode 100644 index 000000000000..c3fe3e9066ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_bmm_cpu/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_bmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %c40 = arith.constant 40 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c4, %c32, %c40] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0] [%c4, %c40, %c24] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_bmm_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_bmm_cpu_debuf.mlir new file mode 100644 index 000000000000..3d202571386b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_bmm_cpu_debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_bmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c40 = arith.constant 40 : index + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c4, %c32, %c40] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c4, %c40, %c24] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_bmm_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_bmm_cpu_linalg.mlir new file mode 100644 index 000000000000..c3fe3e9066ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_bmm_cpu_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_bmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %c40 = arith.constant 40 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c4, %c32, %c40] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0] [%c4, %c40, %c24] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu.mlir new file mode 100644 index 000000000000..292cb89ab25c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %0 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg3, %arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.for %arg4 = 0 to 8 { + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = affine.load %arg0[%arg3, %arg4] : memref + %3 = arith.subf %2, %0 : f32 + %4 = arith.mulf %1, %3 : f32 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..36fc2e6c43d7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu/debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %2) -> (tensor) { + %alloca = memref.alloca() : memref + %7 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %7[] : tensor + %extracted_slice = tensor.extract_slice %4[%arg3, 0] [1, %c8] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[%arg3, 0] [1, %c8] [1, 1] : tensor to tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %10 = arith.mulf %in, %in_4 : f32 + %11 = arith.addf %out, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %extracted = tensor.extract %8[] : tensor + %extracted_slice_1 = tensor.extract_slice %arg4[%arg3, 0] [1, %c8] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %1[%arg3, 0] [1, %c8] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[%arg3, 0] [1, %c8] [1, 1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3, %extracted_slice_2 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %10 = arith.subf %in_4, %extracted : f32 + %11 = arith.mulf %in, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %9 into %arg4[%arg3, 0] [1, %c8] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu/matched.mlir new file mode 100644 index 000000000000..a94eb8d06ee0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu/matched.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %2) -> (tensor) { + %alloca = memref.alloca() : memref + %7 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %7[] : tensor + %extracted_slice = tensor.extract_slice %4[%arg3, 0] [1, %c8] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[%arg3, 0] [1, %c8] [1, 1] : tensor to tensor + %8 = kernel.launch @cublasSdot(%extracted_slice, %extracted_slice_0, %inserted) : (tensor, tensor, tensor) -> tensor + %extracted = tensor.extract %8[] : tensor + %extracted_slice_1 = tensor.extract_slice %arg4[%arg3, 0] [1, %c8] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %1[%arg3, 0] [1, %c8] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[%arg3, 0] [1, %c8] [1, 1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3, %extracted_slice_2 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %10 = arith.subf %in_4, %extracted : f32 + %11 = arith.mulf %in, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %9 into %arg4[%arg3, 0] [1, %c8] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu/orig.mlir new file mode 100644 index 000000000000..292cb89ab25c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu/orig.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %0 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg3, %arg4] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg5, %3 : f32 + affine.yield %4 : f32 + } + affine.for %arg4 = 0 to 8 { + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = affine.load %arg0[%arg3, %arg4] : memref + %3 = arith.subf %2, %0 : f32 + %4 = arith.mulf %1, %3 : f32 + affine.store %4, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu/raised.mlir new file mode 100644 index 000000000000..f07819aa24d9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu/raised.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[%arg3, 0] [1, %c8] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[%arg3, 0] [1, %c8] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %1 = arith.mulf %in, %in_5 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + %0 = affine.load %alloca[] : memref + %subview_2 = memref.subview %arg1[%arg3, 0] [1, %c8] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg0[%arg3, 0] [1, %c8] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg2[%arg3, 0] [1, %c8] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%subview_2, %subview_3 : memref>, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %1 = arith.subf %in_5, %0 : f32 + %2 = arith.mulf %in, %1 : f32 + linalg.yield %2 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..36fc2e6c43d7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu_debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %2) -> (tensor) { + %alloca = memref.alloca() : memref + %7 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %7[] : tensor + %extracted_slice = tensor.extract_slice %4[%arg3, 0] [1, %c8] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[%arg3, 0] [1, %c8] [1, 1] : tensor to tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %10 = arith.mulf %in, %in_4 : f32 + %11 = arith.addf %out, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %extracted = tensor.extract %8[] : tensor + %extracted_slice_1 = tensor.extract_slice %arg4[%arg3, 0] [1, %c8] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %1[%arg3, 0] [1, %c8] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %0[%arg3, 0] [1, %c8] [1, 1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_3, %extracted_slice_2 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_4: f32, %out: f32): + %10 = arith.subf %in_4, %extracted : f32 + %11 = arith.mulf %in, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %9 into %arg4[%arg3, 0] [1, %c8] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..f07819aa24d9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_backward_cpu_linalg.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_softmax_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[%arg3, 0] [1, %c8] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[%arg3, 0] [1, %c8] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %1 = arith.mulf %in, %in_5 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + %0 = affine.load %alloca[] : memref + %subview_2 = memref.subview %arg1[%arg3, 0] [1, %c8] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg0[%arg3, 0] [1, %c8] [1, 1] : memref to memref> + %subview_4 = memref.subview %arg2[%arg3, 0] [1, %c8] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%subview_2, %subview_3 : memref>, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %in_5: f32, %out: f32): + %1 = arith.subf %in_5, %0 : f32 + %2 = arith.mulf %in, %1 : f32 + linalg.yield %2 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu.mlir new file mode 100644 index 000000000000..8c6c0440f366 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_softmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 64 { + %0 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2, %arg3] : memref + %2 = math.exp %1 : f32 + affine.store %2, %arg1[%arg2, %arg3] : memref + %3 = arith.addf %arg4, %2 : f32 + affine.yield %3 : f32 + } + affine.for %arg3 = 0 to 8 { + %1 = affine.load %arg1[%arg2, %arg3] : memref + %2 = arith.divf %1, %0 : f32 + affine.store %2, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu/debuf.mlir new file mode 100644 index 000000000000..065465cf8fc9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu/debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_softmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 64 iter_args(%arg3 = %0) -> (tensor) { + %alloca = memref.alloca() : memref + %4 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %4[] : tensor + %extracted_slice = tensor.extract_slice %1[%arg2, 0] [1, %c8] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %arg3[%arg2, 0] [1, %c8] [1, 1] : tensor to tensor + %5:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0, %inserted : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_1: f32): + %7 = math.exp %in : f32 + %8 = arith.addf %out_1, %7 : f32 + linalg.yield %7, %8 : f32, f32 + } -> (tensor, tensor) + %extracted = tensor.extract %5#1[] : tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%5#0 : tensor) { + ^bb0(%out: f32): + %7 = arith.divf %out, %extracted : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %arg3[%arg2, 0] [1, %c8] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu/matched.mlir new file mode 100644 index 000000000000..065465cf8fc9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu/matched.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_softmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 64 iter_args(%arg3 = %0) -> (tensor) { + %alloca = memref.alloca() : memref + %4 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %4[] : tensor + %extracted_slice = tensor.extract_slice %1[%arg2, 0] [1, %c8] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %arg3[%arg2, 0] [1, %c8] [1, 1] : tensor to tensor + %5:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0, %inserted : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_1: f32): + %7 = math.exp %in : f32 + %8 = arith.addf %out_1, %7 : f32 + linalg.yield %7, %8 : f32, f32 + } -> (tensor, tensor) + %extracted = tensor.extract %5#1[] : tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%5#0 : tensor) { + ^bb0(%out: f32): + %7 = arith.divf %out, %extracted : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %arg3[%arg2, 0] [1, %c8] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu/orig.mlir new file mode 100644 index 000000000000..8c6c0440f366 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_softmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 64 { + %0 = affine.for %arg3 = 0 to 8 iter_args(%arg4 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2, %arg3] : memref + %2 = math.exp %1 : f32 + affine.store %2, %arg1[%arg2, %arg3] : memref + %3 = arith.addf %arg4, %2 : f32 + affine.yield %3 : f32 + } + affine.for %arg3 = 0 to 8 { + %1 = affine.load %arg1[%arg2, %arg3] : memref + %2 = arith.divf %1, %0 : f32 + affine.store %2, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu/raised.mlir new file mode 100644 index 000000000000..bcee295bd407 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu/raised.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_softmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 64 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[%arg2, 0] [1, %c8] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[%arg2, 0] [1, %c8] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%subview_0, %subview_1 : memref>, memref>) { + ^bb0(%in: f32, %out: f32, %out_3: f32): + %1 = math.exp %in : f32 + %2 = arith.addf %out_3, %1 : f32 + linalg.yield %1, %2 : f32, f32 + } + %0 = affine.load %alloca[] : memref + %subview_2 = memref.subview %arg1[%arg2, 0] [1, %c8] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview_2 : memref>) { + ^bb0(%out: f32): + %1 = arith.divf %out, %0 : f32 + linalg.yield %1 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu_debuf.mlir new file mode 100644 index 000000000000..065465cf8fc9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu_debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_softmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 64 iter_args(%arg3 = %0) -> (tensor) { + %alloca = memref.alloca() : memref + %4 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %4[] : tensor + %extracted_slice = tensor.extract_slice %1[%arg2, 0] [1, %c8] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %arg3[%arg2, 0] [1, %c8] [1, 1] : tensor to tensor + %5:2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0, %inserted : tensor, tensor) { + ^bb0(%in: f32, %out: f32, %out_1: f32): + %7 = math.exp %in : f32 + %8 = arith.addf %out_1, %7 : f32 + linalg.yield %7, %8 : f32, f32 + } -> (tensor, tensor) + %extracted = tensor.extract %5#1[] : tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%5#0 : tensor) { + ^bb0(%out: f32): + %7 = arith.divf %out, %extracted : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %6 into %arg3[%arg2, 0] [1, %c8] [1, 1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu_linalg.mlir new file mode 100644 index 000000000000..bcee295bd407 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_softmax_cpu_linalg.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_softmax_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 64 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[%arg2, 0] [1, %c8] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[%arg2, 0] [1, %c8] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%subview_0, %subview_1 : memref>, memref>) { + ^bb0(%in: f32, %out: f32, %out_3: f32): + %1 = math.exp %in : f32 + %2 = arith.addf %out_3, %1 : f32 + linalg.yield %1, %2 : f32, f32 + } + %0 = affine.load %alloca[] : memref + %subview_2 = memref.subview %arg1[%arg2, 0] [1, %c8] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview_2 : memref>) { + ^bb0(%out: f32): + %1 = arith.divf %out, %0 : f32 + linalg.yield %1 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu.mlir new file mode 100644 index 000000000000..1b82c3a6b415 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_to_csr_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c512_i32 = arith.constant 512 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg2 = 0 to 65 iter_args(%arg3 = %c0_i32) -> (i32) { + %1 = arith.index_cast %arg2 : index to i32 + %2 = scf.while (%arg4 = %arg3) : (i32) -> i32 { + %3 = arith.cmpi slt, %arg4, %c512_i32 : i32 + %4:2 = scf.if %3 -> (i1, i32) { + %5 = arith.index_cast %arg4 : i32 to index + %6 = memref.load %arg0[%5] : memref + %7 = arith.cmpi slt, %6, %1 : i32 + %8 = scf.if %7 -> (i32) { + %9 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %9 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %7, %8 : i1, i32 + } else { + scf.yield %false, %arg4 : i1, i32 + } + scf.condition(%4#0) %4#1 : i32 + } do { + ^bb0(%arg4: i32): + scf.yield %arg4 : i32 + } + affine.store %2, %arg1[%arg2] : memref + affine.yield %2 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu/debuf.mlir new file mode 100644 index 000000000000..59ae76a4f660 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu/debuf.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_to_csr_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c512_i32 = arith.constant 512 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %2[] : tensor + %3:2 = affine.for %arg2 = 0 to 65 iter_args(%arg3 = %inserted, %arg4 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg3[] : tensor + %5 = arith.index_cast %arg2 : index to i32 + %6 = scf.while (%arg5 = %extracted) : (i32) -> i32 { + %7 = arith.cmpi slt, %arg5, %c512_i32 : i32 + %8 = arith.index_cast %arg5 : i32 to index + %extracted_2 = tensor.extract %1[%8] : tensor + %9 = arith.cmpi slt, %extracted_2, %5 : i32 + %10 = arith.addi %arg5, %c1_i32 : i32 + %11 = arith.select %9, %10, %arg5 : i32 + %12 = arith.select %7, %9, %false : i1 + %13 = arith.select %7, %11, %arg5 : i32 + scf.condition(%12) %13 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %inserted_0 = tensor.insert %6 into %arg4[%arg2] : tensor + %inserted_1 = tensor.insert %6 into %arg3[] : tensor + affine.yield %inserted_1, %inserted_0 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu/matched.mlir new file mode 100644 index 000000000000..59ae76a4f660 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu/matched.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_to_csr_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c512_i32 = arith.constant 512 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %2[] : tensor + %3:2 = affine.for %arg2 = 0 to 65 iter_args(%arg3 = %inserted, %arg4 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg3[] : tensor + %5 = arith.index_cast %arg2 : index to i32 + %6 = scf.while (%arg5 = %extracted) : (i32) -> i32 { + %7 = arith.cmpi slt, %arg5, %c512_i32 : i32 + %8 = arith.index_cast %arg5 : i32 to index + %extracted_2 = tensor.extract %1[%8] : tensor + %9 = arith.cmpi slt, %extracted_2, %5 : i32 + %10 = arith.addi %arg5, %c1_i32 : i32 + %11 = arith.select %9, %10, %arg5 : i32 + %12 = arith.select %7, %9, %false : i1 + %13 = arith.select %7, %11, %arg5 : i32 + scf.condition(%12) %13 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %inserted_0 = tensor.insert %6 into %arg4[%arg2] : tensor + %inserted_1 = tensor.insert %6 into %arg3[] : tensor + affine.yield %inserted_1, %inserted_0 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu/orig.mlir new file mode 100644 index 000000000000..1b82c3a6b415 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu/orig.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_to_csr_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c512_i32 = arith.constant 512 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg2 = 0 to 65 iter_args(%arg3 = %c0_i32) -> (i32) { + %1 = arith.index_cast %arg2 : index to i32 + %2 = scf.while (%arg4 = %arg3) : (i32) -> i32 { + %3 = arith.cmpi slt, %arg4, %c512_i32 : i32 + %4:2 = scf.if %3 -> (i1, i32) { + %5 = arith.index_cast %arg4 : i32 to index + %6 = memref.load %arg0[%5] : memref + %7 = arith.cmpi slt, %6, %1 : i32 + %8 = scf.if %7 -> (i32) { + %9 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %9 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %7, %8 : i1, i32 + } else { + scf.yield %false, %arg4 : i1, i32 + } + scf.condition(%4#0) %4#1 : i32 + } do { + ^bb0(%arg4: i32): + scf.yield %arg4 : i32 + } + affine.store %2, %arg1[%arg2] : memref + affine.yield %2 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu/raised.mlir new file mode 100644 index 000000000000..78dd57039eda --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu/raised.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_to_csr_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c512_i32 = arith.constant 512 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg2 = 0 to 65 { + %0 = affine.load %alloca[] : memref + %1 = arith.index_cast %arg2 : index to i32 + %2 = scf.while (%arg3 = %0) : (i32) -> i32 { + %3 = arith.cmpi slt, %arg3, %c512_i32 : i32 + %4 = arith.index_cast %arg3 : i32 to index + %5 = memref.load %arg0[%4] : memref + %6 = arith.cmpi slt, %5, %1 : i32 + %7 = arith.addi %arg3, %c1_i32 : i32 + %8 = arith.select %6, %7, %arg3 : i32 + %9 = arith.select %3, %6, %false : i1 + %10 = arith.select %3, %8, %arg3 : i32 + scf.condition(%9) %10 : i32 + } do { + ^bb0(%arg3: i32): + scf.yield %arg3 : i32 + } + affine.store %2, %arg1[%arg2] : memref + affine.store %2, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu_debuf.mlir new file mode 100644 index 000000000000..59ae76a4f660 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu_debuf.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_to_csr_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c512_i32 = arith.constant 512 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %2[] : tensor + %3:2 = affine.for %arg2 = 0 to 65 iter_args(%arg3 = %inserted, %arg4 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg3[] : tensor + %5 = arith.index_cast %arg2 : index to i32 + %6 = scf.while (%arg5 = %extracted) : (i32) -> i32 { + %7 = arith.cmpi slt, %arg5, %c512_i32 : i32 + %8 = arith.index_cast %arg5 : i32 to index + %extracted_2 = tensor.extract %1[%8] : tensor + %9 = arith.cmpi slt, %extracted_2, %5 : i32 + %10 = arith.addi %arg5, %c1_i32 : i32 + %11 = arith.select %9, %10, %arg5 : i32 + %12 = arith.select %7, %9, %false : i1 + %13 = arith.select %7, %11, %arg5 : i32 + scf.condition(%12) %13 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %inserted_0 = tensor.insert %6 into %arg4[%arg2] : tensor + %inserted_1 = tensor.insert %6 into %arg3[] : tensor + affine.yield %inserted_1, %inserted_0 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu_linalg.mlir new file mode 100644 index 000000000000..78dd57039eda --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_coo_to_csr_cpu_linalg.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_coo_to_csr_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c512_i32 = arith.constant 512 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg2 = 0 to 65 { + %0 = affine.load %alloca[] : memref + %1 = arith.index_cast %arg2 : index to i32 + %2 = scf.while (%arg3 = %0) : (i32) -> i32 { + %3 = arith.cmpi slt, %arg3, %c512_i32 : i32 + %4 = arith.index_cast %arg3 : i32 to index + %5 = memref.load %arg0[%4] : memref + %6 = arith.cmpi slt, %5, %1 : i32 + %7 = arith.addi %arg3, %c1_i32 : i32 + %8 = arith.select %6, %7, %arg3 : i32 + %9 = arith.select %3, %6, %false : i1 + %10 = arith.select %3, %8, %arg3 : i32 + scf.condition(%9) %10 : i32 + } do { + ^bb0(%arg3: i32): + scf.yield %arg3 : i32 + } + affine.store %2, %arg1[%arg2] : memref + affine.store %2, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu.mlir new file mode 100644 index 000000000000..5d24b0965a82 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_add_dense_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg4] : memref + %1 = scf.while (%arg5 = %0) : (i32) -> i32 { + %2 = affine.load %arg1[%arg4 + 1] : memref + %3 = arith.cmpi slt, %arg5, %2 : i32 + scf.condition(%3) %arg5 : i32 + } do { + ^bb0(%arg5: i32): + %2 = arith.index_cast %arg5 : i32 to index + %3 = memref.load %arg2[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg3[%2] : memref + %6 = memref.load %arg0[%arg4, %4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg0[%arg4, %4] : memref + %8 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %8 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu/debuf.mlir new file mode 100644 index 000000000000..e597ab23f984 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu/debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_add_dense_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %3) -> (tensor) { + %extracted = tensor.extract %2[%arg4] : tensor + %6:2 = scf.while (%arg6 = %extracted, %arg7 = %arg5) : (i32, tensor) -> (i32, tensor) { + %7 = affine.apply #map(%arg4) + %extracted_0 = tensor.extract %2[%7] : tensor + %8 = arith.cmpi slt, %arg6, %extracted_0 : i32 + scf.condition(%8) %arg6, %arg7 : i32, tensor + } do { + ^bb0(%arg6: i32, %arg7: tensor): + %7 = arith.index_cast %arg6 : i32 to index + %extracted_0 = tensor.extract %1[%7] : tensor + %8 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %0[%7] : tensor + %extracted_2 = tensor.extract %arg7[%arg4, %8] : tensor + %9 = arith.addf %extracted_2, %extracted_1 : f32 + %inserted = tensor.insert %9 into %arg7[%arg4, %8] : tensor + %10 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %10, %inserted : i32, tensor + } + affine.yield %6#1 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu/matched.mlir new file mode 100644 index 000000000000..e597ab23f984 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu/matched.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_add_dense_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %3) -> (tensor) { + %extracted = tensor.extract %2[%arg4] : tensor + %6:2 = scf.while (%arg6 = %extracted, %arg7 = %arg5) : (i32, tensor) -> (i32, tensor) { + %7 = affine.apply #map(%arg4) + %extracted_0 = tensor.extract %2[%7] : tensor + %8 = arith.cmpi slt, %arg6, %extracted_0 : i32 + scf.condition(%8) %arg6, %arg7 : i32, tensor + } do { + ^bb0(%arg6: i32, %arg7: tensor): + %7 = arith.index_cast %arg6 : i32 to index + %extracted_0 = tensor.extract %1[%7] : tensor + %8 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %0[%7] : tensor + %extracted_2 = tensor.extract %arg7[%arg4, %8] : tensor + %9 = arith.addf %extracted_2, %extracted_1 : f32 + %inserted = tensor.insert %9 into %arg7[%arg4, %8] : tensor + %10 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %10, %inserted : i32, tensor + } + affine.yield %6#1 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu/orig.mlir new file mode 100644 index 000000000000..5d24b0965a82 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu/orig.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_add_dense_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg4] : memref + %1 = scf.while (%arg5 = %0) : (i32) -> i32 { + %2 = affine.load %arg1[%arg4 + 1] : memref + %3 = arith.cmpi slt, %arg5, %2 : i32 + scf.condition(%3) %arg5 : i32 + } do { + ^bb0(%arg5: i32): + %2 = arith.index_cast %arg5 : i32 to index + %3 = memref.load %arg2[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg3[%2] : memref + %6 = memref.load %arg0[%arg4, %4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg0[%arg4, %4] : memref + %8 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %8 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu/raised.mlir new file mode 100644 index 000000000000..14c6b34bb91b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu/raised.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_add_dense_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg4] : memref + %1 = scf.while (%arg5 = %0) : (i32) -> i32 { + %2 = affine.load %arg1[%arg4 + 1] : memref + %3 = arith.cmpi slt, %arg5, %2 : i32 + scf.condition(%3) %arg5 : i32 + } do { + ^bb0(%arg5: i32): + %2 = arith.index_cast %arg5 : i32 to index + %3 = memref.load %arg2[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg3[%2] : memref + %6 = memref.load %arg0[%arg4, %4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg0[%arg4, %4] : memref + %8 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %8 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu_debuf.mlir new file mode 100644 index 000000000000..e597ab23f984 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu_debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_add_dense_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %3) -> (tensor) { + %extracted = tensor.extract %2[%arg4] : tensor + %6:2 = scf.while (%arg6 = %extracted, %arg7 = %arg5) : (i32, tensor) -> (i32, tensor) { + %7 = affine.apply #map(%arg4) + %extracted_0 = tensor.extract %2[%7] : tensor + %8 = arith.cmpi slt, %arg6, %extracted_0 : i32 + scf.condition(%8) %arg6, %arg7 : i32, tensor + } do { + ^bb0(%arg6: i32, %arg7: tensor): + %7 = arith.index_cast %arg6 : i32 to index + %extracted_0 = tensor.extract %1[%7] : tensor + %8 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %0[%7] : tensor + %extracted_2 = tensor.extract %arg7[%arg4, %8] : tensor + %9 = arith.addf %extracted_2, %extracted_1 : f32 + %inserted = tensor.insert %9 into %arg7[%arg4, %8] : tensor + %10 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %10, %inserted : i32, tensor + } + affine.yield %6#1 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu_linalg.mlir new file mode 100644 index 000000000000..14c6b34bb91b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_add_dense_cpu_linalg.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_add_dense_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg1[%arg4] : memref + %1 = scf.while (%arg5 = %0) : (i32) -> i32 { + %2 = affine.load %arg1[%arg4 + 1] : memref + %3 = arith.cmpi slt, %arg5, %2 : i32 + scf.condition(%3) %arg5 : i32 + } do { + ^bb0(%arg5: i32): + %2 = arith.index_cast %arg5 : i32 to index + %3 = memref.load %arg2[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg3[%2] : memref + %6 = memref.load %arg0[%arg4, %4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg0[%arg4, %4] : memref + %8 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %8 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu.mlir new file mode 100644 index 000000000000..59f81006a322 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_addmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg7 = %3 to %2 step %c1 iter_args(%arg8 = %cst) -> (f32) { + %5 = memref.load %arg2[%arg7] : memref + %6 = memref.load %arg1[%arg7] : memref + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg3[%7, %arg6] : memref + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg8, %9 : f32 + scf.yield %10 : f32 + } + affine.store %4, %arg4[%arg5, %arg6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu/debuf.mlir new file mode 100644 index 000000000000..955c625fc57f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu/debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_addmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %0) -> (tensor) { + %7 = affine.for %arg7 = 0 to 48 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %8 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %4[%8] : tensor + %9 = arith.index_cast %extracted_0 : i32 to index + %10 = arith.index_cast %extracted : i32 to index + %11 = scf.for %arg9 = %10 to %9 step %c1 iter_args(%arg10 = %cst) -> (f32) { + %extracted_1 = tensor.extract %2[%arg9] : tensor + %extracted_2 = tensor.extract %3[%arg9] : tensor + %12 = arith.index_cast %extracted_2 : i32 to index + %extracted_3 = tensor.extract %1[%12, %arg7] : tensor + %13 = arith.mulf %extracted_1, %extracted_3 : f32 + %14 = arith.addf %arg10, %13 : f32 + scf.yield %14 : f32 + } + %inserted = tensor.insert %11 into %arg8[%arg5, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu/matched.mlir new file mode 100644 index 000000000000..955c625fc57f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu/matched.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_addmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %0) -> (tensor) { + %7 = affine.for %arg7 = 0 to 48 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %8 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %4[%8] : tensor + %9 = arith.index_cast %extracted_0 : i32 to index + %10 = arith.index_cast %extracted : i32 to index + %11 = scf.for %arg9 = %10 to %9 step %c1 iter_args(%arg10 = %cst) -> (f32) { + %extracted_1 = tensor.extract %2[%arg9] : tensor + %extracted_2 = tensor.extract %3[%arg9] : tensor + %12 = arith.index_cast %extracted_2 : i32 to index + %extracted_3 = tensor.extract %1[%12, %arg7] : tensor + %13 = arith.mulf %extracted_1, %extracted_3 : f32 + %14 = arith.addf %arg10, %13 : f32 + scf.yield %14 : f32 + } + %inserted = tensor.insert %11 into %arg8[%arg5, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu/orig.mlir new file mode 100644 index 000000000000..59f81006a322 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu/orig.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_addmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg7 = %3 to %2 step %c1 iter_args(%arg8 = %cst) -> (f32) { + %5 = memref.load %arg2[%arg7] : memref + %6 = memref.load %arg1[%arg7] : memref + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg3[%7, %arg6] : memref + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg8, %9 : f32 + scf.yield %10 : f32 + } + affine.store %4, %arg4[%arg5, %arg6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu/raised.mlir new file mode 100644 index 000000000000..f900b179bf9f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu/raised.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_addmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg7 = %3 to %2 step %c1 iter_args(%arg8 = %cst) -> (f32) { + %5 = memref.load %arg2[%arg7] : memref + %6 = memref.load %arg1[%arg7] : memref + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg3[%7, %arg6] : memref + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg8, %9 : f32 + scf.yield %10 : f32 + } + affine.store %4, %arg4[%arg5, %arg6] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu_debuf.mlir new file mode 100644 index 000000000000..955c625fc57f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu_debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_addmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %0) -> (tensor) { + %7 = affine.for %arg7 = 0 to 48 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %8 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %4[%8] : tensor + %9 = arith.index_cast %extracted_0 : i32 to index + %10 = arith.index_cast %extracted : i32 to index + %11 = scf.for %arg9 = %10 to %9 step %c1 iter_args(%arg10 = %cst) -> (f32) { + %extracted_1 = tensor.extract %2[%arg9] : tensor + %extracted_2 = tensor.extract %3[%arg9] : tensor + %12 = arith.index_cast %extracted_2 : i32 to index + %extracted_3 = tensor.extract %1[%12, %arg7] : tensor + %13 = arith.mulf %extracted_1, %extracted_3 : f32 + %14 = arith.addf %arg10, %13 : f32 + scf.yield %14 : f32 + } + %inserted = tensor.insert %11 into %arg8[%arg5, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu_linalg.mlir new file mode 100644 index 000000000000..f900b179bf9f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_addmm_cpu_linalg.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_addmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg7 = %3 to %2 step %c1 iter_args(%arg8 = %cst) -> (f32) { + %5 = memref.load %arg2[%arg7] : memref + %6 = memref.load %arg1[%arg7] : memref + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg3[%7, %arg6] : memref + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg8, %9 : f32 + scf.yield %10 : f32 + } + affine.store %4, %arg4[%arg5, %arg6] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu.mlir new file mode 100644 index 000000000000..4dcb14847e4f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg2 = 0 to 512 iter_args(%arg3 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2] : memref + %2 = arith.addf %arg3, %1 : f32 + affine.yield %2 : f32 + } + affine.store %0, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu/debuf.mlir new file mode 100644 index 000000000000..2259118f019a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %cst into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu/matched.mlir new file mode 100644 index 000000000000..2259118f019a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %cst into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu/orig.mlir new file mode 100644 index 000000000000..4dcb14847e4f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg2 = 0 to 512 iter_args(%arg3 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2] : memref + %2 = arith.addf %arg3, %1 : f32 + affine.yield %2 : f32 + } + affine.store %0, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu/raised.mlir new file mode 100644 index 000000000000..7391dc42f53c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.store %cst, %arg1[0] : memref + %subview = memref.subview %arg1[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.addf %out, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu_debuf.mlir new file mode 100644 index 000000000000..2259118f019a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %cst into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu_linalg.mlir new file mode 100644 index 000000000000..7391dc42f53c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_all_cpu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.store %cst, %arg1[0] : memref + %subview = memref.subview %arg1[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.addf %out, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu.mlir new file mode 100644 index 000000000000..a5343df03a8d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_dim0_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 64 { + affine.store %cst, %arg3[%arg4] : memref + } + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg0[%arg4] : memref + %1 = scf.while (%arg5 = %0) : (i32) -> i32 { + %2 = affine.load %arg0[%arg4 + 1] : memref + %3 = arith.cmpi slt, %arg5, %2 : i32 + scf.condition(%3) %arg5 : i32 + } do { + ^bb0(%arg5: i32): + %2 = arith.index_cast %arg5 : i32 to index + %3 = memref.load %arg1[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg2[%2] : memref + %6 = memref.load %arg3[%4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg3[%4] : memref + %8 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %8 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu/debuf.mlir new file mode 100644 index 000000000000..b99125cf6ff4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu/debuf.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_dim0_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %5 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %4) -> (tensor) { + %extracted = tensor.extract %3[%arg4] : tensor + %7:2 = scf.while (%arg6 = %extracted, %arg7 = %arg5) : (i32, tensor) -> (i32, tensor) { + %8 = affine.apply #map1(%arg4) + %extracted_0 = tensor.extract %3[%8] : tensor + %9 = arith.cmpi slt, %arg6, %extracted_0 : i32 + scf.condition(%9) %arg6, %arg7 : i32, tensor + } do { + ^bb0(%arg6: i32, %arg7: tensor): + %8 = arith.index_cast %arg6 : i32 to index + %extracted_0 = tensor.extract %2[%8] : tensor + %9 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %1[%8] : tensor + %extracted_2 = tensor.extract %arg7[%9] : tensor + %10 = arith.addf %extracted_2, %extracted_1 : f32 + %inserted = tensor.insert %10 into %arg7[%9] : tensor + %11 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %11, %inserted : i32, tensor + } + affine.yield %7#1 : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu/matched.mlir new file mode 100644 index 000000000000..814f99efe1e1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu/matched.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_dim0_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %5 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %4) -> (tensor) { + %extracted = tensor.extract %3[%arg4] : tensor + %7:2 = scf.while (%arg6 = %extracted, %arg7 = %arg5) : (i32, tensor) -> (i32, tensor) { + %8 = affine.apply #map1(%arg4) + %extracted_0 = tensor.extract %3[%8] : tensor + %9 = arith.cmpi slt, %arg6, %extracted_0 : i32 + scf.condition(%9) %arg6, %arg7 : i32, tensor + } do { + ^bb0(%arg6: i32, %arg7: tensor): + %8 = arith.index_cast %arg6 : i32 to index + %extracted_0 = tensor.extract %2[%8] : tensor + %9 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %1[%8] : tensor + %extracted_2 = tensor.extract %arg7[%9] : tensor + %10 = arith.addf %extracted_2, %extracted_1 : f32 + %inserted = tensor.insert %10 into %arg7[%9] : tensor + %11 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %11, %inserted : i32, tensor + } + affine.yield %7#1 : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu/orig.mlir new file mode 100644 index 000000000000..a5343df03a8d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu/orig.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_dim0_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 64 { + affine.store %cst, %arg3[%arg4] : memref + } + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg0[%arg4] : memref + %1 = scf.while (%arg5 = %0) : (i32) -> i32 { + %2 = affine.load %arg0[%arg4 + 1] : memref + %3 = arith.cmpi slt, %arg5, %2 : i32 + scf.condition(%3) %arg5 : i32 + } do { + ^bb0(%arg5: i32): + %2 = arith.index_cast %arg5 : i32 to index + %3 = memref.load %arg1[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg2[%2] : memref + %6 = memref.load %arg3[%4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg3[%4] : memref + %8 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %8 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu/raised.mlir new file mode 100644 index 000000000000..a12178183c3c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu/raised.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_dim0_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg3 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg0[%arg4] : memref + %1 = scf.while (%arg5 = %0) : (i32) -> i32 { + %2 = affine.load %arg0[%arg4 + 1] : memref + %3 = arith.cmpi slt, %arg5, %2 : i32 + scf.condition(%3) %arg5 : i32 + } do { + ^bb0(%arg5: i32): + %2 = arith.index_cast %arg5 : i32 to index + %3 = memref.load %arg1[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg2[%2] : memref + %6 = memref.load %arg3[%4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg3[%4] : memref + %8 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %8 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu_debuf.mlir new file mode 100644 index 000000000000..b99125cf6ff4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu_debuf.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_dim0_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %5 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %4) -> (tensor) { + %extracted = tensor.extract %3[%arg4] : tensor + %7:2 = scf.while (%arg6 = %extracted, %arg7 = %arg5) : (i32, tensor) -> (i32, tensor) { + %8 = affine.apply #map1(%arg4) + %extracted_0 = tensor.extract %3[%8] : tensor + %9 = arith.cmpi slt, %arg6, %extracted_0 : i32 + scf.condition(%9) %arg6, %arg7 : i32, tensor + } do { + ^bb0(%arg6: i32, %arg7: tensor): + %8 = arith.index_cast %arg6 : i32 to index + %extracted_0 = tensor.extract %2[%8] : tensor + %9 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %1[%8] : tensor + %extracted_2 = tensor.extract %arg7[%9] : tensor + %10 = arith.addf %extracted_2, %extracted_1 : f32 + %inserted = tensor.insert %10 into %arg7[%9] : tensor + %11 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %11, %inserted : i32, tensor + } + affine.yield %7#1 : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu_linalg.mlir new file mode 100644 index 000000000000..a12178183c3c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim0_cpu_linalg.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_dim0_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg3 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg4 = 0 to 64 { + %0 = affine.load %arg0[%arg4] : memref + %1 = scf.while (%arg5 = %0) : (i32) -> i32 { + %2 = affine.load %arg0[%arg4 + 1] : memref + %3 = arith.cmpi slt, %arg5, %2 : i32 + scf.condition(%3) %arg5 : i32 + } do { + ^bb0(%arg5: i32): + %2 = arith.index_cast %arg5 : i32 to index + %3 = memref.load %arg1[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg2[%2] : memref + %6 = memref.load %arg3[%4] : memref + %7 = arith.addf %6, %5 : f32 + memref.store %7, %arg3[%4] : memref + %8 = arith.addi %arg5, %c1_i32 : i32 + scf.yield %8 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu.mlir new file mode 100644 index 000000000000..d454878cf4c4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_dim1_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg0[%arg3 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg4 = %3 to %2 step %c1 iter_args(%arg5 = %cst) -> (f32) { + %5 = memref.load %arg1[%arg4] : memref + %6 = arith.addf %arg5, %5 : f32 + scf.yield %6 : f32 + } + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu/debuf.mlir new file mode 100644 index 000000000000..8a3abfb9edce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_dim1_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %0) -> (tensor) { + %extracted = tensor.extract %2[%arg3] : tensor + %5 = affine.apply #map(%arg3) + %extracted_0 = tensor.extract %2[%5] : tensor + %6 = arith.index_cast %extracted_0 : i32 to index + %7 = arith.index_cast %extracted : i32 to index + %8 = scf.for %arg5 = %7 to %6 step %c1 iter_args(%arg6 = %cst) -> (f32) { + %extracted_1 = tensor.extract %1[%arg5] : tensor + %9 = arith.addf %arg6, %extracted_1 : f32 + scf.yield %9 : f32 + } + %inserted = tensor.insert %8 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu/matched.mlir new file mode 100644 index 000000000000..8a3abfb9edce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu/matched.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_dim1_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %0) -> (tensor) { + %extracted = tensor.extract %2[%arg3] : tensor + %5 = affine.apply #map(%arg3) + %extracted_0 = tensor.extract %2[%5] : tensor + %6 = arith.index_cast %extracted_0 : i32 to index + %7 = arith.index_cast %extracted : i32 to index + %8 = scf.for %arg5 = %7 to %6 step %c1 iter_args(%arg6 = %cst) -> (f32) { + %extracted_1 = tensor.extract %1[%arg5] : tensor + %9 = arith.addf %arg6, %extracted_1 : f32 + scf.yield %9 : f32 + } + %inserted = tensor.insert %8 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu/orig.mlir new file mode 100644 index 000000000000..d454878cf4c4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu/orig.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_dim1_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg0[%arg3 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg4 = %3 to %2 step %c1 iter_args(%arg5 = %cst) -> (f32) { + %5 = memref.load %arg1[%arg4] : memref + %6 = arith.addf %arg5, %5 : f32 + scf.yield %6 : f32 + } + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu/raised.mlir new file mode 100644 index 000000000000..dfafda18bc01 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu/raised.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_dim1_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg0[%arg3 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg4 = %3 to %2 step %c1 iter_args(%arg5 = %cst) -> (f32) { + %5 = memref.load %arg1[%arg4] : memref + %6 = arith.addf %arg5, %5 : f32 + scf.yield %6 : f32 + } + affine.store %4, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu_debuf.mlir new file mode 100644 index 000000000000..8a3abfb9edce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_dim1_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %0) -> (tensor) { + %extracted = tensor.extract %2[%arg3] : tensor + %5 = affine.apply #map(%arg3) + %extracted_0 = tensor.extract %2[%5] : tensor + %6 = arith.index_cast %extracted_0 : i32 to index + %7 = arith.index_cast %extracted : i32 to index + %8 = scf.for %arg5 = %7 to %6 step %c1 iter_args(%arg6 = %cst) -> (f32) { + %extracted_1 = tensor.extract %1[%arg5] : tensor + %9 = arith.addf %arg6, %extracted_1 : f32 + scf.yield %9 : f32 + } + %inserted = tensor.insert %8 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu_linalg.mlir new file mode 100644 index 000000000000..dfafda18bc01 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_csr_reduce_dim1_cpu_linalg.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_csr_reduce_dim1_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg0[%arg3 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg4 = %3 to %2 step %c1 iter_args(%arg5 = %cst) -> (f32) { + %5 = memref.load %arg1[%arg4] : memref + %6 = arith.addf %arg5, %5 : f32 + scf.yield %6 : f32 + } + affine.store %4, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu.mlir new file mode 100644 index 000000000000..56c92db36d3d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_dense_intersection_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg5 = 0 to 512 { + %0 = affine.load %arg3[%arg5] : memref + %1 = affine.load %arg1[%arg5] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg5] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg0[%2, %4] : memref + %6 = arith.mulf %0, %5 : f32 + affine.store %6, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu/debuf.mlir new file mode 100644 index 000000000000..c0b5637e8417 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_dense_intersection_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg4 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg3[%3] : memref + %5 = memref.load %arg1[%3] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg2[%3] : memref + %8 = arith.index_cast %7 : i32 to index + %9 = memref.load %arg0[%6, %8] : memref + %10 = arith.mulf %4, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu/matched.mlir new file mode 100644 index 000000000000..c0b5637e8417 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_dense_intersection_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg4 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg3[%3] : memref + %5 = memref.load %arg1[%3] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg2[%3] : memref + %8 = arith.index_cast %7 : i32 to index + %9 = memref.load %arg0[%6, %8] : memref + %10 = arith.mulf %4, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu/orig.mlir new file mode 100644 index 000000000000..56c92db36d3d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu/orig.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_dense_intersection_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg5 = 0 to 512 { + %0 = affine.load %arg3[%arg5] : memref + %1 = affine.load %arg1[%arg5] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = affine.load %arg2[%arg5] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg0[%2, %4] : memref + %6 = arith.mulf %0, %5 : f32 + affine.store %6, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu/raised.mlir new file mode 100644 index 000000000000..9a859dd21c38 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_dense_intersection_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg4 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg3[%0] : memref + %2 = memref.load %arg1[%0] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg2[%0] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%3, %5] : memref + %7 = arith.mulf %1, %6 : f32 + linalg.yield %7 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu_debuf.mlir new file mode 100644 index 000000000000..c0b5637e8417 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_dense_intersection_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg4 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg3[%3] : memref + %5 = memref.load %arg1[%3] : memref + %6 = arith.index_cast %5 : i32 to index + %7 = memref.load %arg2[%3] : memref + %8 = arith.index_cast %7 : i32 to index + %9 = memref.load %arg0[%6, %8] : memref + %10 = arith.mulf %4, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu_linalg.mlir new file mode 100644 index 000000000000..9a859dd21c38 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_dense_intersection_cpu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_dense_intersection_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg4 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg3[%0] : memref + %2 = memref.load %arg1[%0] : memref + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg2[%0] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%3, %5] : memref + %7 = arith.mulf %1, %6 : f32 + linalg.yield %7 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu.mlir new file mode 100644 index 000000000000..0311bdac6eaf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_flatten_indices_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 512 { + %0 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %c0_i32) -> (i32) { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.muli %arg5, %1 : i32 + %3 = affine.load %arg0[%arg4, %arg3] : memref + %4 = arith.addi %2, %3 : i32 + affine.yield %4 : i32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu/debuf.mlir new file mode 100644 index 000000000000..6d32edd42cb7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_flatten_indices_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c512 = arith.constant 512 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %1[0] [%c3] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c3, %c512] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c512] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %6 = arith.muli %out, %in : i32 + %7 = arith.addi %6, %in_2 : i32 + linalg.yield %7 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c512] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu/matched.mlir new file mode 100644 index 000000000000..165c2a08215f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu/matched.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_flatten_indices_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c512 = arith.constant 512 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = kernel.launch @memset_zero_1D(%2) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %1[0] [%c3] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c3, %c512] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c512] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %6 = arith.muli %out, %in : i32 + %7 = arith.addi %6, %in_2 : i32 + linalg.yield %7 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c512] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu/orig.mlir new file mode 100644 index 000000000000..0311bdac6eaf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu/orig.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_flatten_indices_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 512 { + %0 = affine.for %arg4 = 0 to 3 iter_args(%arg5 = %c0_i32) -> (i32) { + %1 = affine.load %arg1[%arg4] : memref + %2 = arith.muli %arg5, %1 : i32 + %3 = affine.load %arg0[%arg4, %arg3] : memref + %4 = arith.addi %2, %3 : i32 + affine.yield %4 : i32 + } + affine.store %0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu/raised.mlir new file mode 100644 index 000000000000..3358a11d9527 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_flatten_indices_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c512 = arith.constant 512 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg1[0] [%c3] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c3, %c512] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c512] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %0 = arith.muli %out, %in : i32 + %1 = arith.addi %0, %in_2 : i32 + linalg.yield %1 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu_debuf.mlir new file mode 100644 index 000000000000..6d32edd42cb7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_flatten_indices_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c3 = arith.constant 3 : index + %c512 = arith.constant 512 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %1[0] [%c3] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c3, %c512] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0] [%c512] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %6 = arith.muli %out, %in : i32 + %7 = arith.addi %6, %in_2 : i32 + linalg.yield %7 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c512] [1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu_linalg.mlir new file mode 100644 index 000000000000..3358a11d9527 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_flatten_indices_cpu_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_flatten_indices_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c512 = arith.constant 512 : index + %c3 = arith.constant 3 : index + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg1[0] [%c3] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c3, %c512] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg2[0] [%c512] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %0 = arith.muli %out, %in : i32 + %1 = arith.addi %0, %in_2 : i32 + linalg.yield %1 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu.mlir new file mode 100644 index 000000000000..19f9b5b19d94 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_full_coo_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg2 = 0 to 16 iter_args(%arg3 = %c0_i32) -> (i32) { + %1 = arith.index_cast %arg2 : index to i32 + %2 = arith.index_cast %arg3 : i32 to index + %3 = arith.addi %2, %c32 : index + %4 = arith.index_cast %3 : index to i32 + affine.for %arg4 = 0 to 32 { + %5 = arith.addi %2, %arg4 : index + %6 = arith.index_cast %arg4 : index to i32 + memref.store %1, %arg0[%5] : memref + memref.store %6, %arg1[%5] : memref + } + affine.yield %4 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu/debuf.mlir new file mode 100644 index 000000000000..cc321e7b8650 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu/debuf.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_full_coo_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %2[] : tensor + %3:3 = affine.for %arg2 = 0 to 16 iter_args(%arg3 = %inserted, %arg4 = %1, %arg5 = %0) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg3[] : tensor + %6 = arith.index_cast %arg2 : index to i32 + %7 = arith.index_cast %extracted : i32 to index + %8 = arith.addi %7, %c32 : index + %9 = arith.index_cast %8 : index to i32 + %10:2 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %11 = arith.addi %7, %arg6 : index + %12 = arith.index_cast %arg6 : index to i32 + %inserted_1 = tensor.insert %6 into %arg7[%11] : tensor + %inserted_2 = tensor.insert %12 into %arg8[%11] : tensor + affine.yield %inserted_1, %inserted_2 : tensor, tensor + } + %inserted_0 = tensor.insert %9 into %arg3[] : tensor + affine.yield %inserted_0, %10#0, %10#1 : tensor, tensor, tensor + } + %4 = bufferization.to_memref %3#2 : memref + memref.copy %4, %arg1 : memref to memref + %5 = bufferization.to_memref %3#1 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu/matched.mlir new file mode 100644 index 000000000000..cc321e7b8650 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu/matched.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_full_coo_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %2[] : tensor + %3:3 = affine.for %arg2 = 0 to 16 iter_args(%arg3 = %inserted, %arg4 = %1, %arg5 = %0) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg3[] : tensor + %6 = arith.index_cast %arg2 : index to i32 + %7 = arith.index_cast %extracted : i32 to index + %8 = arith.addi %7, %c32 : index + %9 = arith.index_cast %8 : index to i32 + %10:2 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %11 = arith.addi %7, %arg6 : index + %12 = arith.index_cast %arg6 : index to i32 + %inserted_1 = tensor.insert %6 into %arg7[%11] : tensor + %inserted_2 = tensor.insert %12 into %arg8[%11] : tensor + affine.yield %inserted_1, %inserted_2 : tensor, tensor + } + %inserted_0 = tensor.insert %9 into %arg3[] : tensor + affine.yield %inserted_0, %10#0, %10#1 : tensor, tensor, tensor + } + %4 = bufferization.to_memref %3#2 : memref + memref.copy %4, %arg1 : memref to memref + %5 = bufferization.to_memref %3#1 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu/orig.mlir new file mode 100644 index 000000000000..19f9b5b19d94 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_full_coo_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg2 = 0 to 16 iter_args(%arg3 = %c0_i32) -> (i32) { + %1 = arith.index_cast %arg2 : index to i32 + %2 = arith.index_cast %arg3 : i32 to index + %3 = arith.addi %2, %c32 : index + %4 = arith.index_cast %3 : index to i32 + affine.for %arg4 = 0 to 32 { + %5 = arith.addi %2, %arg4 : index + %6 = arith.index_cast %arg4 : index to i32 + memref.store %1, %arg0[%5] : memref + memref.store %6, %arg1[%5] : memref + } + affine.yield %4 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu/raised.mlir new file mode 100644 index 000000000000..05801fe037eb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu/raised.mlir @@ -0,0 +1,24 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_full_coo_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg2 = 0 to 16 { + %0 = affine.load %alloca[] : memref + %1 = arith.index_cast %arg2 : index to i32 + %2 = arith.index_cast %0 : i32 to index + %3 = arith.addi %2, %c32 : index + %4 = arith.index_cast %3 : index to i32 + affine.for %arg3 = 0 to 32 { + %5 = arith.addi %2, %arg3 : index + %6 = arith.index_cast %arg3 : index to i32 + memref.store %1, %arg0[%5] : memref + memref.store %6, %arg1[%5] : memref + } + affine.store %4, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu_debuf.mlir new file mode 100644 index 000000000000..cc321e7b8650 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu_debuf.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_full_coo_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %2[] : tensor + %3:3 = affine.for %arg2 = 0 to 16 iter_args(%arg3 = %inserted, %arg4 = %1, %arg5 = %0) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg3[] : tensor + %6 = arith.index_cast %arg2 : index to i32 + %7 = arith.index_cast %extracted : i32 to index + %8 = arith.addi %7, %c32 : index + %9 = arith.index_cast %8 : index to i32 + %10:2 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %11 = arith.addi %7, %arg6 : index + %12 = arith.index_cast %arg6 : index to i32 + %inserted_1 = tensor.insert %6 into %arg7[%11] : tensor + %inserted_2 = tensor.insert %12 into %arg8[%11] : tensor + affine.yield %inserted_1, %inserted_2 : tensor, tensor + } + %inserted_0 = tensor.insert %9 into %arg3[] : tensor + affine.yield %inserted_0, %10#0, %10#1 : tensor, tensor, tensor + } + %4 = bufferization.to_memref %3#2 : memref + memref.copy %4, %arg1 : memref to memref + %5 = bufferization.to_memref %3#1 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu_linalg.mlir new file mode 100644 index 000000000000..05801fe037eb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_full_coo_indices_cpu_linalg.mlir @@ -0,0 +1,24 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_full_coo_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg2 = 0 to 16 { + %0 = affine.load %alloca[] : memref + %1 = arith.index_cast %arg2 : index to i32 + %2 = arith.index_cast %0 : i32 to index + %3 = arith.addi %2, %c32 : index + %4 = arith.index_cast %3 : index to i32 + affine.for %arg3 = 0 to 32 { + %5 = arith.addi %2, %arg3 : index + %6 = arith.index_cast %arg3 : index to i32 + memref.store %1, %arg0[%5] : memref + memref.store %6, %arg1[%5] : memref + } + affine.store %4, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu.mlir new file mode 100644 index 000000000000..115ad237b526 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_intersection_apply_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.mulf %0, %1 : f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu/debuf.mlir new file mode 100644 index 000000000000..6fa5a1eb9568 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_intersection_apply_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu/matched.mlir new file mode 100644 index 000000000000..6fa5a1eb9568 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_intersection_apply_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu/orig.mlir new file mode 100644 index 000000000000..115ad237b526 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_intersection_apply_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.mulf %0, %1 : f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu/raised.mlir new file mode 100644 index 000000000000..6a9ac9f90dc3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_intersection_apply_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu_debuf.mlir new file mode 100644 index 000000000000..6fa5a1eb9568 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_intersection_apply_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu_linalg.mlir new file mode 100644 index 000000000000..6a9ac9f90dc3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_intersection_apply_cpu_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_intersection_apply_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu.mlir new file mode 100644 index 000000000000..3a0dc5268fdc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_intersection_launch_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.mulf %0, %1 : f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu/debuf.mlir new file mode 100644 index 000000000000..0be92f91ed65 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_intersection_launch_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu/matched.mlir new file mode 100644 index 000000000000..0be92f91ed65 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_intersection_launch_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu/orig.mlir new file mode 100644 index 000000000000..3a0dc5268fdc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_intersection_launch_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.mulf %0, %1 : f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu/raised.mlir new file mode 100644 index 000000000000..7a4ecb33f03a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_intersection_launch_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu_debuf.mlir new file mode 100644 index 000000000000..0be92f91ed65 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_intersection_launch_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu_linalg.mlir new file mode 100644 index 000000000000..7a4ecb33f03a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_intersection_launch_cpu_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_intersection_launch_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_cpu.mlir new file mode 100644 index 000000000000..4ce0fe6acfca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_cpu.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + affine.for %arg6 = 0 to 64 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg7 = %3 to %2 step %c1 iter_args(%arg8 = %cst) -> (f32) { + %5 = memref.load %arg2[%arg7] : memref + %6 = memref.load %arg1[%arg7] : memref + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg3[%7, %arg6] : memref + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg8, %9 : f32 + scf.yield %10 : f32 + } + affine.store %4, %arg4[%arg5, %arg6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_cpu/debuf.mlir new file mode 100644 index 000000000000..13201e4a466e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_cpu/debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %0) -> (tensor) { + %7 = affine.for %arg7 = 0 to 64 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %8 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %4[%8] : tensor + %9 = arith.index_cast %extracted_0 : i32 to index + %10 = arith.index_cast %extracted : i32 to index + %11 = scf.for %arg9 = %10 to %9 step %c1 iter_args(%arg10 = %cst) -> (f32) { + %extracted_1 = tensor.extract %2[%arg9] : tensor + %extracted_2 = tensor.extract %3[%arg9] : tensor + %12 = arith.index_cast %extracted_2 : i32 to index + %extracted_3 = tensor.extract %1[%12, %arg7] : tensor + %13 = arith.mulf %extracted_1, %extracted_3 : f32 + %14 = arith.addf %arg10, %13 : f32 + scf.yield %14 : f32 + } + %inserted = tensor.insert %11 into %arg8[%arg5, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_cpu/matched.mlir new file mode 100644 index 000000000000..13201e4a466e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_cpu/matched.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %0) -> (tensor) { + %7 = affine.for %arg7 = 0 to 64 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %8 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %4[%8] : tensor + %9 = arith.index_cast %extracted_0 : i32 to index + %10 = arith.index_cast %extracted : i32 to index + %11 = scf.for %arg9 = %10 to %9 step %c1 iter_args(%arg10 = %cst) -> (f32) { + %extracted_1 = tensor.extract %2[%arg9] : tensor + %extracted_2 = tensor.extract %3[%arg9] : tensor + %12 = arith.index_cast %extracted_2 : i32 to index + %extracted_3 = tensor.extract %1[%12, %arg7] : tensor + %13 = arith.mulf %extracted_1, %extracted_3 : f32 + %14 = arith.addf %arg10, %13 : f32 + scf.yield %14 : f32 + } + %inserted = tensor.insert %11 into %arg8[%arg5, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_cpu/orig.mlir new file mode 100644 index 000000000000..4ce0fe6acfca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_cpu/orig.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + affine.for %arg6 = 0 to 64 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg7 = %3 to %2 step %c1 iter_args(%arg8 = %cst) -> (f32) { + %5 = memref.load %arg2[%arg7] : memref + %6 = memref.load %arg1[%arg7] : memref + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg3[%7, %arg6] : memref + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg8, %9 : f32 + scf.yield %10 : f32 + } + affine.store %4, %arg4[%arg5, %arg6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_cpu/raised.mlir new file mode 100644 index 000000000000..9d986482de55 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_cpu/raised.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + affine.for %arg6 = 0 to 64 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg7 = %3 to %2 step %c1 iter_args(%arg8 = %cst) -> (f32) { + %5 = memref.load %arg2[%arg7] : memref + %6 = memref.load %arg1[%arg7] : memref + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg3[%7, %arg6] : memref + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg8, %9 : f32 + scf.yield %10 : f32 + } + affine.store %4, %arg4[%arg5, %arg6] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_cpu_debuf.mlir new file mode 100644 index 000000000000..13201e4a466e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_cpu_debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %0) -> (tensor) { + %7 = affine.for %arg7 = 0 to 64 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %8 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %4[%8] : tensor + %9 = arith.index_cast %extracted_0 : i32 to index + %10 = arith.index_cast %extracted : i32 to index + %11 = scf.for %arg9 = %10 to %9 step %c1 iter_args(%arg10 = %cst) -> (f32) { + %extracted_1 = tensor.extract %2[%arg9] : tensor + %extracted_2 = tensor.extract %3[%arg9] : tensor + %12 = arith.index_cast %extracted_2 : i32 to index + %extracted_3 = tensor.extract %1[%12, %arg7] : tensor + %13 = arith.mulf %extracted_1, %extracted_3 : f32 + %14 = arith.addf %arg10, %13 : f32 + scf.yield %14 : f32 + } + %inserted = tensor.insert %11 into %arg8[%arg5, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_cpu_linalg.mlir new file mode 100644 index 000000000000..9d986482de55 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_cpu_linalg.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + affine.for %arg6 = 0 to 64 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg7 = %3 to %2 step %c1 iter_args(%arg8 = %cst) -> (f32) { + %5 = memref.load %arg2[%arg7] : memref + %6 = memref.load %arg1[%arg7] : memref + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg3[%7, %arg6] : memref + %9 = arith.mulf %5, %8 : f32 + %10 = arith.addf %arg8, %9 : f32 + scf.yield %10 : f32 + } + affine.store %4, %arg4[%arg5, %arg6] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu.mlir new file mode 100644 index 000000000000..67cf7eaebb97 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_csr_to_coo_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + affine.for %arg2 = 0 to 64 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = affine.load %arg0[%arg2] : memref + %2 = scf.while (%arg3 = %1) : (i32) -> i32 { + %3 = affine.load %arg0[%arg2 + 1] : memref + %4 = arith.cmpi slt, %arg3, %3 : i32 + scf.condition(%4) %arg3 : i32 + } do { + ^bb0(%arg3: i32): + %3 = arith.index_cast %arg3 : i32 to index + memref.store %0, %arg1[%3] : memref + %4 = arith.addi %arg3, %c1_i32 : i32 + scf.yield %4 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu/debuf.mlir new file mode 100644 index 000000000000..fc35cf6d42fb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu/debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_csr_to_coo_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 64 iter_args(%arg3 = %0) -> (tensor) { + %4 = arith.index_cast %arg2 : index to i32 + %extracted = tensor.extract %1[%arg2] : tensor + %5:2 = scf.while (%arg4 = %extracted, %arg5 = %arg3) : (i32, tensor) -> (i32, tensor) { + %6 = affine.apply #map(%arg2) + %extracted_0 = tensor.extract %1[%6] : tensor + %7 = arith.cmpi slt, %arg4, %extracted_0 : i32 + scf.condition(%7) %arg4, %arg5 : i32, tensor + } do { + ^bb0(%arg4: i32, %arg5: tensor): + %6 = arith.index_cast %arg4 : i32 to index + %inserted = tensor.insert %4 into %arg5[%6] : tensor + %7 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %7, %inserted : i32, tensor + } + affine.yield %5#1 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu/matched.mlir new file mode 100644 index 000000000000..fc35cf6d42fb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu/matched.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_csr_to_coo_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 64 iter_args(%arg3 = %0) -> (tensor) { + %4 = arith.index_cast %arg2 : index to i32 + %extracted = tensor.extract %1[%arg2] : tensor + %5:2 = scf.while (%arg4 = %extracted, %arg5 = %arg3) : (i32, tensor) -> (i32, tensor) { + %6 = affine.apply #map(%arg2) + %extracted_0 = tensor.extract %1[%6] : tensor + %7 = arith.cmpi slt, %arg4, %extracted_0 : i32 + scf.condition(%7) %arg4, %arg5 : i32, tensor + } do { + ^bb0(%arg4: i32, %arg5: tensor): + %6 = arith.index_cast %arg4 : i32 to index + %inserted = tensor.insert %4 into %arg5[%6] : tensor + %7 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %7, %inserted : i32, tensor + } + affine.yield %5#1 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu/orig.mlir new file mode 100644 index 000000000000..67cf7eaebb97 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu/orig.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_csr_to_coo_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + affine.for %arg2 = 0 to 64 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = affine.load %arg0[%arg2] : memref + %2 = scf.while (%arg3 = %1) : (i32) -> i32 { + %3 = affine.load %arg0[%arg2 + 1] : memref + %4 = arith.cmpi slt, %arg3, %3 : i32 + scf.condition(%4) %arg3 : i32 + } do { + ^bb0(%arg3: i32): + %3 = arith.index_cast %arg3 : i32 to index + memref.store %0, %arg1[%3] : memref + %4 = arith.addi %arg3, %c1_i32 : i32 + scf.yield %4 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu/raised.mlir new file mode 100644 index 000000000000..20ec079833dc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu/raised.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_csr_to_coo_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + affine.for %arg2 = 0 to 64 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = affine.load %arg0[%arg2] : memref + %2 = scf.while (%arg3 = %1) : (i32) -> i32 { + %3 = affine.load %arg0[%arg2 + 1] : memref + %4 = arith.cmpi slt, %arg3, %3 : i32 + scf.condition(%4) %arg3 : i32 + } do { + ^bb0(%arg3: i32): + %3 = arith.index_cast %arg3 : i32 to index + memref.store %0, %arg1[%3] : memref + %4 = arith.addi %arg3, %c1_i32 : i32 + scf.yield %4 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu_debuf.mlir new file mode 100644 index 000000000000..fc35cf6d42fb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu_debuf.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_csr_to_coo_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 64 iter_args(%arg3 = %0) -> (tensor) { + %4 = arith.index_cast %arg2 : index to i32 + %extracted = tensor.extract %1[%arg2] : tensor + %5:2 = scf.while (%arg4 = %extracted, %arg5 = %arg3) : (i32, tensor) -> (i32, tensor) { + %6 = affine.apply #map(%arg2) + %extracted_0 = tensor.extract %1[%6] : tensor + %7 = arith.cmpi slt, %arg4, %extracted_0 : i32 + scf.condition(%7) %arg4, %arg5 : i32, tensor + } do { + ^bb0(%arg4: i32, %arg5: tensor): + %6 = arith.index_cast %arg4 : i32 to index + %inserted = tensor.insert %4 into %arg5[%6] : tensor + %7 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %7, %inserted : i32, tensor + } + affine.yield %5#1 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu_linalg.mlir new file mode 100644 index 000000000000..20ec079833dc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_csr_to_coo_cpu_linalg.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_csr_to_coo_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + affine.for %arg2 = 0 to 64 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = affine.load %arg0[%arg2] : memref + %2 = scf.while (%arg3 = %1) : (i32) -> i32 { + %3 = affine.load %arg0[%arg2 + 1] : memref + %4 = arith.cmpi slt, %arg3, %3 : i32 + scf.condition(%4) %arg3 : i32 + } do { + ^bb0(%arg3: i32): + %3 = arith.index_cast %arg3 : i32 to index + memref.store %0, %arg1[%3] : memref + %4 = arith.addi %arg3, %c1_i32 : i32 + scf.yield %4 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu.mlir new file mode 100644 index 000000000000..9ff684d510cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_maxnnz_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg6 = %3 to %2 step %c1 iter_args(%arg7 = %c0_i32) -> (i32) { + %5 = memref.load %arg1[%arg6] : memref + %6 = arith.addi %5, %c1_i32 : i32 + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg2[%7] : memref + %9 = arith.index_cast %5 : i32 to index + %10 = memref.load %arg2[%9] : memref + %11 = arith.subi %8, %10 : i32 + %12 = arith.addi %arg7, %11 : i32 + scf.yield %12 : i32 + } + affine.store %4, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu/debuf.mlir new file mode 100644 index 000000000000..3518563dd186 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu/debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_maxnnz_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %0) -> (tensor) { + %extracted = tensor.extract %3[%arg5] : tensor + %6 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %3[%6] : tensor + %7 = arith.index_cast %extracted_0 : i32 to index + %8 = arith.index_cast %extracted : i32 to index + %9 = scf.for %arg7 = %8 to %7 step %c1 iter_args(%arg8 = %c0_i32) -> (i32) { + %extracted_1 = tensor.extract %2[%arg7] : tensor + %10 = arith.addi %extracted_1, %c1_i32 : i32 + %11 = arith.index_cast %10 : i32 to index + %extracted_2 = tensor.extract %1[%11] : tensor + %12 = arith.index_cast %extracted_1 : i32 to index + %extracted_3 = tensor.extract %1[%12] : tensor + %13 = arith.subi %extracted_2, %extracted_3 : i32 + %14 = arith.addi %arg8, %13 : i32 + scf.yield %14 : i32 + } + %inserted = tensor.insert %9 into %arg6[%arg5] : tensor + affine.yield %inserted : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu/matched.mlir new file mode 100644 index 000000000000..3518563dd186 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu/matched.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_maxnnz_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %0) -> (tensor) { + %extracted = tensor.extract %3[%arg5] : tensor + %6 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %3[%6] : tensor + %7 = arith.index_cast %extracted_0 : i32 to index + %8 = arith.index_cast %extracted : i32 to index + %9 = scf.for %arg7 = %8 to %7 step %c1 iter_args(%arg8 = %c0_i32) -> (i32) { + %extracted_1 = tensor.extract %2[%arg7] : tensor + %10 = arith.addi %extracted_1, %c1_i32 : i32 + %11 = arith.index_cast %10 : i32 to index + %extracted_2 = tensor.extract %1[%11] : tensor + %12 = arith.index_cast %extracted_1 : i32 to index + %extracted_3 = tensor.extract %1[%12] : tensor + %13 = arith.subi %extracted_2, %extracted_3 : i32 + %14 = arith.addi %arg8, %13 : i32 + scf.yield %14 : i32 + } + %inserted = tensor.insert %9 into %arg6[%arg5] : tensor + affine.yield %inserted : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu/orig.mlir new file mode 100644 index 000000000000..9ff684d510cb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu/orig.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_maxnnz_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg6 = %3 to %2 step %c1 iter_args(%arg7 = %c0_i32) -> (i32) { + %5 = memref.load %arg1[%arg6] : memref + %6 = arith.addi %5, %c1_i32 : i32 + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg2[%7] : memref + %9 = arith.index_cast %5 : i32 to index + %10 = memref.load %arg2[%9] : memref + %11 = arith.subi %8, %10 : i32 + %12 = arith.addi %arg7, %11 : i32 + scf.yield %12 : i32 + } + affine.store %4, %arg4[%arg5] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu/raised.mlir new file mode 100644 index 000000000000..6ea22d8bcbed --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu/raised.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_maxnnz_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg6 = %3 to %2 step %c1 iter_args(%arg7 = %c0_i32) -> (i32) { + %5 = memref.load %arg1[%arg6] : memref + %6 = arith.addi %5, %c1_i32 : i32 + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg2[%7] : memref + %9 = arith.index_cast %5 : i32 to index + %10 = memref.load %arg2[%9] : memref + %11 = arith.subi %8, %10 : i32 + %12 = arith.addi %arg7, %11 : i32 + scf.yield %12 : i32 + } + affine.store %4, %arg4[%arg5] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu_debuf.mlir new file mode 100644 index 000000000000..3518563dd186 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu_debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_maxnnz_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = affine.for %arg5 = 0 to 64 iter_args(%arg6 = %0) -> (tensor) { + %extracted = tensor.extract %3[%arg5] : tensor + %6 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %3[%6] : tensor + %7 = arith.index_cast %extracted_0 : i32 to index + %8 = arith.index_cast %extracted : i32 to index + %9 = scf.for %arg7 = %8 to %7 step %c1 iter_args(%arg8 = %c0_i32) -> (i32) { + %extracted_1 = tensor.extract %2[%arg7] : tensor + %10 = arith.addi %extracted_1, %c1_i32 : i32 + %11 = arith.index_cast %10 : i32 to index + %extracted_2 = tensor.extract %1[%11] : tensor + %12 = arith.index_cast %extracted_1 : i32 to index + %extracted_3 = tensor.extract %1[%12] : tensor + %13 = arith.subi %extracted_2, %extracted_3 : i32 + %14 = arith.addi %arg8, %13 : i32 + scf.yield %14 : i32 + } + %inserted = tensor.insert %9 into %arg6[%arg5] : tensor + affine.yield %inserted : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu_linalg.mlir new file mode 100644 index 000000000000..6ea22d8bcbed --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_matmul_maxnnz_cpu_linalg.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_matmul_maxnnz_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg5 = 0 to 64 { + %0 = affine.load %arg0[%arg5] : memref + %1 = affine.load %arg0[%arg5 + 1] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = arith.index_cast %0 : i32 to index + %4 = scf.for %arg6 = %3 to %2 step %c1 iter_args(%arg7 = %c0_i32) -> (i32) { + %5 = memref.load %arg1[%arg6] : memref + %6 = arith.addi %5, %c1_i32 : i32 + %7 = arith.index_cast %6 : i32 to index + %8 = memref.load %arg2[%7] : memref + %9 = arith.index_cast %5 : i32 to index + %10 = memref.load %arg2[%9] : memref + %11 = arith.subi %8, %10 : i32 + %12 = arith.addi %arg7, %11 : i32 + scf.yield %12 : i32 + } + affine.store %4, %arg4[%arg5] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_mul_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_mul_cpu.mlir new file mode 100644 index 000000000000..8570c9c71249 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_mul_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_mul_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.mulf %0, %1 : f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_mul_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_mul_cpu/debuf.mlir new file mode 100644 index 000000000000..8117f2630d3d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_mul_cpu/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_mul_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_mul_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_mul_cpu/matched.mlir new file mode 100644 index 000000000000..8117f2630d3d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_mul_cpu/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_mul_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_mul_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_mul_cpu/orig.mlir new file mode 100644 index 000000000000..8570c9c71249 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_mul_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_mul_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.mulf %0, %1 : f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_mul_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_mul_cpu/raised.mlir new file mode 100644 index 000000000000..facb71236842 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_mul_cpu/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_mul_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_mul_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_mul_cpu_debuf.mlir new file mode 100644 index 000000000000..8117f2630d3d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_mul_cpu_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_mul_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in, %in_0 : f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_mul_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_mul_cpu_linalg.mlir new file mode 100644 index 000000000000..facb71236842 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_mul_cpu_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_mul_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %in, %in_0 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_norm_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_norm_cpu.mlir new file mode 100644 index 000000000000..9ab81c861592 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_norm_cpu.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_norm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg2 = 0 to 1024 iter_args(%arg3 = %cst) -> (f32) { + %2 = affine.load %arg0[%arg2] : memref + %3 = arith.mulf %2, %2 : f32 + %4 = arith.addf %arg3, %3 : f32 + affine.yield %4 : f32 + } + %1 = math.sqrt %0 : f32 + affine.store %1, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_norm_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_norm_cpu/debuf.mlir new file mode 100644 index 000000000000..c4ff91a622f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_norm_cpu/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_norm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %2[] : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.mulf %in, %in : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %extracted = tensor.extract %3[] : tensor + %4 = math.sqrt %extracted : f32 + %inserted_0 = tensor.insert %4 into %1[%c0] : tensor + %5 = bufferization.to_memref %inserted_0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_norm_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_norm_cpu/matched.mlir new file mode 100644 index 000000000000..c4ff91a622f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_norm_cpu/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_norm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %2[] : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.mulf %in, %in : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %extracted = tensor.extract %3[] : tensor + %4 = math.sqrt %extracted : f32 + %inserted_0 = tensor.insert %4 into %1[%c0] : tensor + %5 = bufferization.to_memref %inserted_0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_norm_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_norm_cpu/orig.mlir new file mode 100644 index 000000000000..9ab81c861592 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_norm_cpu/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_norm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg2 = 0 to 1024 iter_args(%arg3 = %cst) -> (f32) { + %2 = affine.load %arg0[%arg2] : memref + %3 = arith.mulf %2, %2 : f32 + %4 = arith.addf %arg3, %3 : f32 + affine.yield %4 : f32 + } + %1 = math.sqrt %0 : f32 + affine.store %1, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_norm_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_norm_cpu/raised.mlir new file mode 100644 index 000000000000..cc51c4ab63c5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_norm_cpu/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_norm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.mulf %in, %in : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = math.sqrt %0 : f32 + affine.store %1, %arg1[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_norm_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_norm_cpu_debuf.mlir new file mode 100644 index 000000000000..c4ff91a622f5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_norm_cpu_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_norm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %2[] : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %6 = arith.mulf %in, %in : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %extracted = tensor.extract %3[] : tensor + %4 = math.sqrt %extracted : f32 + %inserted_0 = tensor.insert %4 into %1[%c0] : tensor + %5 = bufferization.to_memref %inserted_0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_norm_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_norm_cpu_linalg.mlir new file mode 100644 index 000000000000..cc51c4ab63c5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_norm_cpu_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_norm_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.mulf %in, %in : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = math.sqrt %0 : f32 + affine.store %1, %arg1[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu.mlir new file mode 100644 index 000000000000..d44cb70829f9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_softmax_offsets_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c512_i32 = arith.constant 512 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg2 = 0 to 65 iter_args(%arg3 = %c0_i32) -> (i32) { + %1 = arith.index_cast %arg2 : index to i32 + %2 = scf.while (%arg4 = %arg3) : (i32) -> i32 { + %3 = arith.cmpi slt, %arg4, %c512_i32 : i32 + %4:2 = scf.if %3 -> (i1, i32) { + %5 = arith.index_cast %arg4 : i32 to index + %6 = memref.load %arg0[%5] : memref + %7 = arith.cmpi slt, %6, %1 : i32 + %8 = scf.if %7 -> (i32) { + %9 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %9 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %7, %8 : i1, i32 + } else { + scf.yield %false, %arg4 : i1, i32 + } + scf.condition(%4#0) %4#1 : i32 + } do { + ^bb0(%arg4: i32): + scf.yield %arg4 : i32 + } + affine.store %2, %arg1[%arg2] : memref + affine.yield %2 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu/debuf.mlir new file mode 100644 index 000000000000..875f9cf3f6f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu/debuf.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_softmax_offsets_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c512_i32 = arith.constant 512 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %2[] : tensor + %3:2 = affine.for %arg2 = 0 to 65 iter_args(%arg3 = %inserted, %arg4 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg3[] : tensor + %5 = arith.index_cast %arg2 : index to i32 + %6 = scf.while (%arg5 = %extracted) : (i32) -> i32 { + %7 = arith.cmpi slt, %arg5, %c512_i32 : i32 + %8 = arith.index_cast %arg5 : i32 to index + %extracted_2 = tensor.extract %1[%8] : tensor + %9 = arith.cmpi slt, %extracted_2, %5 : i32 + %10 = arith.addi %arg5, %c1_i32 : i32 + %11 = arith.select %9, %10, %arg5 : i32 + %12 = arith.select %7, %9, %false : i1 + %13 = arith.select %7, %11, %arg5 : i32 + scf.condition(%12) %13 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %inserted_0 = tensor.insert %6 into %arg4[%arg2] : tensor + %inserted_1 = tensor.insert %6 into %arg3[] : tensor + affine.yield %inserted_1, %inserted_0 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu/matched.mlir new file mode 100644 index 000000000000..875f9cf3f6f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu/matched.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_softmax_offsets_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c512_i32 = arith.constant 512 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %2[] : tensor + %3:2 = affine.for %arg2 = 0 to 65 iter_args(%arg3 = %inserted, %arg4 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg3[] : tensor + %5 = arith.index_cast %arg2 : index to i32 + %6 = scf.while (%arg5 = %extracted) : (i32) -> i32 { + %7 = arith.cmpi slt, %arg5, %c512_i32 : i32 + %8 = arith.index_cast %arg5 : i32 to index + %extracted_2 = tensor.extract %1[%8] : tensor + %9 = arith.cmpi slt, %extracted_2, %5 : i32 + %10 = arith.addi %arg5, %c1_i32 : i32 + %11 = arith.select %9, %10, %arg5 : i32 + %12 = arith.select %7, %9, %false : i1 + %13 = arith.select %7, %11, %arg5 : i32 + scf.condition(%12) %13 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %inserted_0 = tensor.insert %6 into %arg4[%arg2] : tensor + %inserted_1 = tensor.insert %6 into %arg3[] : tensor + affine.yield %inserted_1, %inserted_0 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu/orig.mlir new file mode 100644 index 000000000000..d44cb70829f9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu/orig.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_softmax_offsets_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c512_i32 = arith.constant 512 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg2 = 0 to 65 iter_args(%arg3 = %c0_i32) -> (i32) { + %1 = arith.index_cast %arg2 : index to i32 + %2 = scf.while (%arg4 = %arg3) : (i32) -> i32 { + %3 = arith.cmpi slt, %arg4, %c512_i32 : i32 + %4:2 = scf.if %3 -> (i1, i32) { + %5 = arith.index_cast %arg4 : i32 to index + %6 = memref.load %arg0[%5] : memref + %7 = arith.cmpi slt, %6, %1 : i32 + %8 = scf.if %7 -> (i32) { + %9 = arith.addi %arg4, %c1_i32 : i32 + scf.yield %9 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %7, %8 : i1, i32 + } else { + scf.yield %false, %arg4 : i1, i32 + } + scf.condition(%4#0) %4#1 : i32 + } do { + ^bb0(%arg4: i32): + scf.yield %arg4 : i32 + } + affine.store %2, %arg1[%arg2] : memref + affine.yield %2 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu/raised.mlir new file mode 100644 index 000000000000..6c722be7ebf7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu/raised.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_softmax_offsets_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c512_i32 = arith.constant 512 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg2 = 0 to 65 { + %0 = affine.load %alloca[] : memref + %1 = arith.index_cast %arg2 : index to i32 + %2 = scf.while (%arg3 = %0) : (i32) -> i32 { + %3 = arith.cmpi slt, %arg3, %c512_i32 : i32 + %4 = arith.index_cast %arg3 : i32 to index + %5 = memref.load %arg0[%4] : memref + %6 = arith.cmpi slt, %5, %1 : i32 + %7 = arith.addi %arg3, %c1_i32 : i32 + %8 = arith.select %6, %7, %arg3 : i32 + %9 = arith.select %3, %6, %false : i1 + %10 = arith.select %3, %8, %arg3 : i32 + scf.condition(%9) %10 : i32 + } do { + ^bb0(%arg3: i32): + scf.yield %arg3 : i32 + } + affine.store %2, %arg1[%arg2] : memref + affine.store %2, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu_debuf.mlir new file mode 100644 index 000000000000..875f9cf3f6f4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu_debuf.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_softmax_offsets_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c512_i32 = arith.constant 512 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %2[] : tensor + %3:2 = affine.for %arg2 = 0 to 65 iter_args(%arg3 = %inserted, %arg4 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %arg3[] : tensor + %5 = arith.index_cast %arg2 : index to i32 + %6 = scf.while (%arg5 = %extracted) : (i32) -> i32 { + %7 = arith.cmpi slt, %arg5, %c512_i32 : i32 + %8 = arith.index_cast %arg5 : i32 to index + %extracted_2 = tensor.extract %1[%8] : tensor + %9 = arith.cmpi slt, %extracted_2, %5 : i32 + %10 = arith.addi %arg5, %c1_i32 : i32 + %11 = arith.select %9, %10, %arg5 : i32 + %12 = arith.select %7, %9, %false : i1 + %13 = arith.select %7, %11, %arg5 : i32 + scf.condition(%12) %13 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %inserted_0 = tensor.insert %6 into %arg4[%arg2] : tensor + %inserted_1 = tensor.insert %6 into %arg3[] : tensor + affine.yield %inserted_1, %inserted_0 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu_linalg.mlir new file mode 100644 index 000000000000..6c722be7ebf7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_softmax_offsets_cpu_linalg.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_softmax_offsets_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %false = arith.constant false + %c512_i32 = arith.constant 512 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg2 = 0 to 65 { + %0 = affine.load %alloca[] : memref + %1 = arith.index_cast %arg2 : index to i32 + %2 = scf.while (%arg3 = %0) : (i32) -> i32 { + %3 = arith.cmpi slt, %arg3, %c512_i32 : i32 + %4 = arith.index_cast %arg3 : i32 to index + %5 = memref.load %arg0[%4] : memref + %6 = arith.cmpi slt, %5, %1 : i32 + %7 = arith.addi %arg3, %c1_i32 : i32 + %8 = arith.select %6, %7, %arg3 : i32 + %9 = arith.select %3, %6, %false : i1 + %10 = arith.select %3, %8, %arg3 : i32 + scf.condition(%9) %10 : i32 + } do { + ^bb0(%arg3: i32): + scf.yield %arg3 : i32 + } + affine.store %2, %arg1[%arg2] : memref + affine.store %2, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu.mlir new file mode 100644 index 000000000000..e7d3fe1dd6b3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_softmax_pools_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 64 { + %0 = affine.load %arg0[%arg2 + 1] : memref + %1 = affine.load %arg0[%arg2] : memref + %2 = arith.subi %0, %1 : i32 + affine.store %2, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu/debuf.mlir new file mode 100644 index 000000000000..7ca435ab5d1d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu/debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_softmax_pools_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[1] [%c64] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0] [%c64] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %4 = arith.subi %in, %in_2 : i32 + linalg.yield %4 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0] [%c64] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu/matched.mlir new file mode 100644 index 000000000000..7ca435ab5d1d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_softmax_pools_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[1] [%c64] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0] [%c64] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %4 = arith.subi %in, %in_2 : i32 + linalg.yield %4 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0] [%c64] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu/orig.mlir new file mode 100644 index 000000000000..e7d3fe1dd6b3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_softmax_pools_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 64 { + %0 = affine.load %arg0[%arg2 + 1] : memref + %1 = affine.load %arg0[%arg2] : memref + %2 = arith.subi %0, %1 : i32 + affine.store %2, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu/raised.mlir new file mode 100644 index 000000000000..319d2dd2f88f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_softmax_pools_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[1] [%c64] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0] [%c64] [1] : memref to memref> + %subview_1 = memref.subview %arg1[0] [%c64] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %0 = arith.subi %in, %in_2 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu_debuf.mlir new file mode 100644 index 000000000000..7ca435ab5d1d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu_debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_softmax_pools_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[1] [%c64] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %0[0] [%c64] [1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0] [%c64] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %4 = arith.subi %in, %in_2 : i32 + linalg.yield %4 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0] [%c64] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu_linalg.mlir new file mode 100644 index 000000000000..319d2dd2f88f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_softmax_pools_cpu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_softmax_pools_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[1] [%c64] [1] : memref to memref> + %subview_0 = memref.subview %arg0[0] [%c64] [1] : memref to memref> + %subview_1 = memref.subview %arg1[0] [%c64] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: i32, %in_2: i32, %out: i32): + %0 = arith.subi %in, %in_2 : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu.mlir new file mode 100644 index 000000000000..d62bf27d758f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu.mlir @@ -0,0 +1,8 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_sum_backward_cpu(%arg0: f32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 1024 { + affine.store %arg0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..3371c74be60a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu/debuf.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_sum_backward_cpu(%arg0: f32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %arg0 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu/matched.mlir new file mode 100644 index 000000000000..3371c74be60a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu/matched.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_sum_backward_cpu(%arg0: f32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %arg0 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu/orig.mlir new file mode 100644 index 000000000000..d62bf27d758f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu/orig.mlir @@ -0,0 +1,8 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_sum_backward_cpu(%arg0: f32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 1024 { + affine.store %arg0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu/raised.mlir new file mode 100644 index 000000000000..4513e728dd59 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu/raised.mlir @@ -0,0 +1,11 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_sum_backward_cpu(%arg0: f32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %arg0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..3371c74be60a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu_debuf.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_sum_backward_cpu(%arg0: f32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %arg0 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..4513e728dd59 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_sum_backward_cpu_linalg.mlir @@ -0,0 +1,11 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_sum_backward_cpu(%arg0: f32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %arg0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_sum_cpu.mlir b/issues/aten_c_kernels/results/aten_sparse_sum_cpu.mlir new file mode 100644 index 000000000000..722b4ca0c08f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_sum_cpu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg2 = 0 to 1024 iter_args(%arg3 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2] : memref + %2 = arith.addf %arg3, %1 : f32 + affine.yield %2 : f32 + } + affine.store %0, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_sum_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_sum_cpu/debuf.mlir new file mode 100644 index 000000000000..80a6cf15c6ab --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_sum_cpu/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %cst into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_sum_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sparse_sum_cpu/matched.mlir new file mode 100644 index 000000000000..80a6cf15c6ab --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_sum_cpu/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %cst into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_sum_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sparse_sum_cpu/orig.mlir new file mode 100644 index 000000000000..722b4ca0c08f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_sum_cpu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg2 = 0 to 1024 iter_args(%arg3 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2] : memref + %2 = arith.addf %arg3, %1 : f32 + affine.yield %2 : f32 + } + affine.store %0, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sparse_sum_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sparse_sum_cpu/raised.mlir new file mode 100644 index 000000000000..3fe184da51f0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_sum_cpu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.store %cst, %arg1[0] : memref + %subview = memref.subview %arg1[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.addf %out, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_sum_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sparse_sum_cpu_debuf.mlir new file mode 100644 index 000000000000..80a6cf15c6ab --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_sum_cpu_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %cst into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sparse_sum_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sparse_sum_cpu_linalg.mlir new file mode 100644 index 000000000000..3fe184da51f0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sparse_sum_cpu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sparse_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.store %cst, %arg1[0] : memref + %subview = memref.subview %arg1[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.addf %out, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spdiags_cpu.mlir b/issues/aten_c_kernels/results/aten_spdiags_cpu.mlir new file mode 100644 index 000000000000..bbf30c80a199 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spdiags_cpu.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spdiags_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16_i32 = arith.constant 16 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 16 { + affine.store %cst, %arg2[%arg3, %arg4] : memref + } + } + affine.for %arg3 = 0 to 5 { + affine.for %arg4 = 0 to 16 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.addi %0, %1 : i32 + %3 = arith.cmpi sge, %2, %c0_i32 : i32 + %4 = arith.cmpi slt, %2, %c16_i32 : i32 + %5 = arith.andi %3, %4 : i1 + scf.if %5 { + %6 = arith.index_cast %2 : i32 to index + %7 = affine.load %arg1[%arg3] : memref + %8 = arith.cmpi sge, %7, %c0_i32 : i32 + %9 = scf.if %8 -> (i32) { + scf.yield %0 : i32 + } else { + %12 = arith.subi %0, %7 : i32 + scf.yield %12 : i32 + } + %10 = arith.index_cast %9 : i32 to index + %11 = memref.load %arg0[%arg3, %10] : memref + memref.store %11, %arg2[%arg4, %6] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_spdiags_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_spdiags_cpu/debuf.mlir new file mode 100644 index 000000000000..9a49839b3527 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spdiags_cpu/debuf.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spdiags_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c16_i32 = arith.constant 16 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [%c16, %c16] [1, 1] : tensor into tensor + %4 = affine.for %arg3 = 0 to 5 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %6 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %arg4) -> (tensor) { + %7 = arith.index_cast %arg5 : index to i32 + %extracted = tensor.extract %1[%arg3] : tensor + %8 = arith.addi %7, %extracted : i32 + %9 = arith.cmpi sge, %8, %c0_i32 : i32 + %10 = arith.cmpi slt, %8, %c16_i32 : i32 + %11 = arith.andi %9, %10 : i1 + %12 = scf.if %11 -> (tensor) { + %13 = arith.index_cast %8 : i32 to index + %extracted_0 = tensor.extract %1[%arg3] : tensor + %14 = arith.cmpi sge, %extracted_0, %c0_i32 : i32 + %15 = arith.subi %7, %extracted_0 : i32 + %16 = arith.select %14, %7, %15 : i32 + %17 = arith.index_cast %16 : i32 to index + %extracted_1 = tensor.extract %2[%arg3, %17] : tensor + %inserted = tensor.insert %extracted_1 into %arg6[%arg5, %13] : tensor + scf.yield %inserted : tensor + } else { + scf.yield %arg6 : tensor + } + affine.yield %12 : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spdiags_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_spdiags_cpu/matched.mlir new file mode 100644 index 000000000000..48d3a8f082ca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spdiags_cpu/matched.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spdiags_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c16_i32 = arith.constant 16 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %3 = kernel.launch @memset_zero_2D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [%c16, %c16] [1, 1] : tensor into tensor + %4 = affine.for %arg3 = 0 to 5 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %6 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %arg4) -> (tensor) { + %7 = arith.index_cast %arg5 : index to i32 + %extracted = tensor.extract %1[%arg3] : tensor + %8 = arith.addi %7, %extracted : i32 + %9 = arith.cmpi sge, %8, %c0_i32 : i32 + %10 = arith.cmpi slt, %8, %c16_i32 : i32 + %11 = arith.andi %9, %10 : i1 + %12 = scf.if %11 -> (tensor) { + %13 = arith.index_cast %8 : i32 to index + %extracted_0 = tensor.extract %1[%arg3] : tensor + %14 = arith.cmpi sge, %extracted_0, %c0_i32 : i32 + %15 = arith.subi %7, %extracted_0 : i32 + %16 = arith.select %14, %7, %15 : i32 + %17 = arith.index_cast %16 : i32 to index + %extracted_1 = tensor.extract %2[%arg3, %17] : tensor + %inserted = tensor.insert %extracted_1 into %arg6[%arg5, %13] : tensor + scf.yield %inserted : tensor + } else { + scf.yield %arg6 : tensor + } + affine.yield %12 : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spdiags_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_spdiags_cpu/orig.mlir new file mode 100644 index 000000000000..bbf30c80a199 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spdiags_cpu/orig.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spdiags_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c16_i32 = arith.constant 16 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 16 { + affine.store %cst, %arg2[%arg3, %arg4] : memref + } + } + affine.for %arg3 = 0 to 5 { + affine.for %arg4 = 0 to 16 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.addi %0, %1 : i32 + %3 = arith.cmpi sge, %2, %c0_i32 : i32 + %4 = arith.cmpi slt, %2, %c16_i32 : i32 + %5 = arith.andi %3, %4 : i1 + scf.if %5 { + %6 = arith.index_cast %2 : i32 to index + %7 = affine.load %arg1[%arg3] : memref + %8 = arith.cmpi sge, %7, %c0_i32 : i32 + %9 = scf.if %8 -> (i32) { + scf.yield %0 : i32 + } else { + %12 = arith.subi %0, %7 : i32 + scf.yield %12 : i32 + } + %10 = arith.index_cast %9 : i32 to index + %11 = memref.load %arg0[%arg3, %10] : memref + memref.store %11, %arg2[%arg4, %6] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_spdiags_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_spdiags_cpu/raised.mlir new file mode 100644 index 000000000000..247f59d66d68 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spdiags_cpu/raised.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spdiags_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + %c16_i32 = arith.constant 16 : i32 + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg2[0, 0] [%c16, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 5 { + affine.for %arg4 = 0 to 16 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.addi %0, %1 : i32 + %3 = arith.cmpi sge, %2, %c0_i32 : i32 + %4 = arith.cmpi slt, %2, %c16_i32 : i32 + %5 = arith.andi %3, %4 : i1 + scf.if %5 { + %6 = arith.index_cast %2 : i32 to index + %7 = affine.load %arg1[%arg3] : memref + %8 = arith.cmpi sge, %7, %c0_i32 : i32 + %9 = arith.subi %0, %7 : i32 + %10 = arith.select %8, %0, %9 : i32 + %11 = arith.index_cast %10 : i32 to index + %12 = memref.load %arg0[%arg3, %11] : memref + memref.store %12, %arg2[%arg4, %6] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spdiags_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_spdiags_cpu_debuf.mlir new file mode 100644 index 000000000000..9a49839b3527 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spdiags_cpu_debuf.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spdiags_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c16_i32 = arith.constant 16 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c16] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %0[0, 0] [%c16, %c16] [1, 1] : tensor into tensor + %4 = affine.for %arg3 = 0 to 5 iter_args(%arg4 = %inserted_slice) -> (tensor) { + %6 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %arg4) -> (tensor) { + %7 = arith.index_cast %arg5 : index to i32 + %extracted = tensor.extract %1[%arg3] : tensor + %8 = arith.addi %7, %extracted : i32 + %9 = arith.cmpi sge, %8, %c0_i32 : i32 + %10 = arith.cmpi slt, %8, %c16_i32 : i32 + %11 = arith.andi %9, %10 : i1 + %12 = scf.if %11 -> (tensor) { + %13 = arith.index_cast %8 : i32 to index + %extracted_0 = tensor.extract %1[%arg3] : tensor + %14 = arith.cmpi sge, %extracted_0, %c0_i32 : i32 + %15 = arith.subi %7, %extracted_0 : i32 + %16 = arith.select %14, %7, %15 : i32 + %17 = arith.index_cast %16 : i32 to index + %extracted_1 = tensor.extract %2[%arg3, %17] : tensor + %inserted = tensor.insert %extracted_1 into %arg6[%arg5, %13] : tensor + scf.yield %inserted : tensor + } else { + scf.yield %arg6 : tensor + } + affine.yield %12 : tensor + } + affine.yield %6 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spdiags_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_spdiags_cpu_linalg.mlir new file mode 100644 index 000000000000..247f59d66d68 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spdiags_cpu_linalg.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spdiags_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %cst = arith.constant 0.000000e+00 : f32 + %c16_i32 = arith.constant 16 : i32 + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg2[0, 0] [%c16, %c16] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg3 = 0 to 5 { + affine.for %arg4 = 0 to 16 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.addi %0, %1 : i32 + %3 = arith.cmpi sge, %2, %c0_i32 : i32 + %4 = arith.cmpi slt, %2, %c16_i32 : i32 + %5 = arith.andi %3, %4 : i1 + scf.if %5 { + %6 = arith.index_cast %2 : i32 to index + %7 = affine.load %arg1[%arg3] : memref + %8 = arith.cmpi sge, %7, %c0_i32 : i32 + %9 = arith.subi %0, %7 : i32 + %10 = arith.select %8, %0, %9 : i32 + %11 = arith.index_cast %10 : i32 to index + %12 = memref.load %arg0[%arg3, %11] : memref + memref.store %12, %arg2[%arg4, %6] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spherical_bessel_j0.mlir b/issues/aten_c_kernels/results/aten_spherical_bessel_j0.mlir new file mode 100644 index 000000000000..a9698f0d23ac --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spherical_bessel_j0.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spherical_bessel_j0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_spherical_bessel_j0f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_spherical_bessel_j0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_spherical_bessel_j0/debuf.mlir b/issues/aten_c_kernels/results/aten_spherical_bessel_j0/debuf.mlir new file mode 100644 index 000000000000..ecf765c31714 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spherical_bessel_j0/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spherical_bessel_j0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_spherical_bessel_j0f(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_spherical_bessel_j0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_spherical_bessel_j0/matched.mlir b/issues/aten_c_kernels/results/aten_spherical_bessel_j0/matched.mlir new file mode 100644 index 000000000000..ecf765c31714 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spherical_bessel_j0/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spherical_bessel_j0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_spherical_bessel_j0f(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_spherical_bessel_j0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_spherical_bessel_j0/orig.mlir b/issues/aten_c_kernels/results/aten_spherical_bessel_j0/orig.mlir new file mode 100644 index 000000000000..a9698f0d23ac --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spherical_bessel_j0/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spherical_bessel_j0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_spherical_bessel_j0f(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_spherical_bessel_j0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_spherical_bessel_j0/raised.mlir b/issues/aten_c_kernels/results/aten_spherical_bessel_j0/raised.mlir new file mode 100644 index 000000000000..5a1d092b806d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spherical_bessel_j0/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spherical_bessel_j0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_spherical_bessel_j0f(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_spherical_bessel_j0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_spherical_bessel_j0_debuf.mlir b/issues/aten_c_kernels/results/aten_spherical_bessel_j0_debuf.mlir new file mode 100644 index 000000000000..ecf765c31714 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spherical_bessel_j0_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spherical_bessel_j0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_spherical_bessel_j0f(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_spherical_bessel_j0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_spherical_bessel_j0_linalg.mlir b/issues/aten_c_kernels/results/aten_spherical_bessel_j0_linalg.mlir new file mode 100644 index 000000000000..5a1d092b806d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spherical_bessel_j0_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spherical_bessel_j0(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_spherical_bessel_j0f(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_spherical_bessel_j0f(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_split_copy_cpu.mlir b/issues/aten_c_kernels/results/aten_split_copy_cpu.mlir new file mode 100644 index 000000000000..0baf45c94075 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_split_copy_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_split_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4 { + affine.for %arg3 = 0 to 32 { + %0 = affine.load %arg0[%arg3 + %arg2 * 32] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_split_copy_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_split_copy_cpu/debuf.mlir new file mode 100644 index 000000000000..e3146799b64a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_split_copy_cpu/debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 32)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_split_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c4, %c32) {map = #map} : (tensor, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0] [%c4, %c32] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0] [%c4, %c32] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_split_copy_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_split_copy_cpu/matched.mlir new file mode 100644 index 000000000000..e3146799b64a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_split_copy_cpu/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 32)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_split_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c4, %c32) {map = #map} : (tensor, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0] [%c4, %c32] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0] [%c4, %c32] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_split_copy_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_split_copy_cpu/orig.mlir new file mode 100644 index 000000000000..0baf45c94075 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_split_copy_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_split_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4 { + affine.for %arg3 = 0 to 32 { + %0 = affine.load %arg0[%arg3 + %arg2 * 32] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_split_copy_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_split_copy_cpu/raised.mlir new file mode 100644 index 000000000000..85b277877a49 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_split_copy_cpu/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 32)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_split_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c32 = arith.constant 32 : index + %0 = polygeist.submap(%arg0, %c4, %c32) {map = #map} : (memref, index, index) -> memref + %subview = memref.subview %arg1[0, 0] [%c4, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_split_copy_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_split_copy_cpu_debuf.mlir new file mode 100644 index 000000000000..e3146799b64a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_split_copy_cpu_debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 32)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_split_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c4, %c32) {map = #map} : (tensor, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0] [%c4, %c32] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0] [%c4, %c32] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_split_copy_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_split_copy_cpu_linalg.mlir new file mode 100644 index 000000000000..85b277877a49 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_split_copy_cpu_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 32)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_split_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c32 = arith.constant 32 : index + %0 = polygeist.submap(%arg0, %c4, %c32) {map = #map} : (memref, index, index) -> memref + %subview = memref.subview %arg1[0, 0] [%c4, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu.mlir new file mode 100644 index 000000000000..bab677516243 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu.mlir @@ -0,0 +1,52 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %true = arith.constant true + %false = arith.constant false + %c-1_i32 = arith.constant -1 : i32 + %cst = arith.constant 3.40282347E+38 : f32 + %cst_0 = arith.constant -3.40282347E+38 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg4, %c0_i32 : i32 + %1 = arith.select %0, %cst_0, %cst : f32 + affine.for %arg7 = 0 to 16 { + affine.for %arg8 = 0 to 24 { + %2 = affine.load %arg0[%arg7] : memref + %3 = affine.load %arg0[%arg7 + 1] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = arith.index_cast %2 : i32 to index + %6:2 = scf.for %arg9 = %5 to %4 step %c1 iter_args(%arg10 = %c-1_i32, %arg11 = %1) -> (i32, f32) { + %7 = arith.index_cast %arg9 : index to i32 + %8 = memref.load %arg2[%arg9] : memref + %9 = memref.load %arg1[%arg9] : memref + %10 = arith.index_cast %9 : i32 to index + %11 = memref.load %arg3[%10, %arg8] : memref + %12 = arith.mulf %8, %11 : f32 + %13 = scf.if %0 -> (i1) { + %17 = arith.cmpf ogt, %12, %arg11 : f32 + scf.yield %17 : i1 + } else { + scf.yield %false : i1 + } + %14 = scf.if %13 -> (i1) { + scf.yield %true : i1 + } else { + %17 = scf.if %0 -> (i1) { + scf.yield %false : i1 + } else { + %18 = arith.cmpf olt, %12, %arg11 : f32 + scf.yield %18 : i1 + } + scf.yield %17 : i1 + } + %15 = arith.select %14, %7, %arg10 : i32 + %16 = arith.select %14, %12, %arg11 : f32 + scf.yield %15, %16 : i32, f32 + } + affine.store %6#1, %arg5[%arg7, %arg8] : memref + affine.store %6#0, %arg6[%arg7, %arg8] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu/debuf.mlir new file mode 100644 index 000000000000..1aa498068abe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu/debuf.mlir @@ -0,0 +1,55 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %true = arith.constant true + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = bufferization.to_tensor %arg0 : memref + %6 = arith.cmpi ne, %arg4, %c0_i32 : i32 + %7 = arith.select %6, %cst, %cst_0 : f32 + %8:2 = affine.for %arg7 = 0 to 16 iter_args(%arg8 = %1, %arg9 = %0) -> (tensor, tensor) { + %11:2 = affine.for %arg10 = 0 to 24 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (tensor, tensor) { + %extracted = tensor.extract %5[%arg7] : tensor + %12 = affine.apply #map(%arg7) + %extracted_1 = tensor.extract %5[%12] : tensor + %13 = arith.index_cast %extracted_1 : i32 to index + %14 = arith.index_cast %extracted : i32 to index + %15:2 = scf.for %arg13 = %14 to %13 step %c1 iter_args(%arg14 = %c-1_i32, %arg15 = %7) -> (i32, f32) { + %16 = arith.index_cast %arg13 : index to i32 + %extracted_3 = tensor.extract %3[%arg13] : tensor + %extracted_4 = tensor.extract %4[%arg13] : tensor + %17 = arith.index_cast %extracted_4 : i32 to index + %extracted_5 = tensor.extract %2[%17, %arg10] : tensor + %18 = arith.mulf %extracted_3, %extracted_5 : f32 + %19 = arith.cmpf ogt, %18, %arg15 : f32 + %20 = arith.select %6, %19, %false : i1 + %21 = arith.cmpf olt, %18, %arg15 : f32 + %22 = arith.select %6, %false, %21 : i1 + %23 = arith.select %20, %true, %22 : i1 + %24 = arith.select %23, %16, %arg14 : i32 + %25 = arith.select %23, %18, %arg15 : f32 + scf.yield %24, %25 : i32, f32 + } + %inserted = tensor.insert %15#1 into %arg11[%arg7, %arg10] : tensor + %inserted_2 = tensor.insert %15#0 into %arg12[%arg7, %arg10] : tensor + affine.yield %inserted, %inserted_2 : tensor, tensor + } + affine.yield %11#0, %11#1 : tensor, tensor + } + %9 = bufferization.to_memref %8#1 : memref + memref.copy %9, %arg6 : memref to memref + %10 = bufferization.to_memref %8#0 : memref + memref.copy %10, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu/matched.mlir new file mode 100644 index 000000000000..1aa498068abe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu/matched.mlir @@ -0,0 +1,55 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %true = arith.constant true + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = bufferization.to_tensor %arg0 : memref + %6 = arith.cmpi ne, %arg4, %c0_i32 : i32 + %7 = arith.select %6, %cst, %cst_0 : f32 + %8:2 = affine.for %arg7 = 0 to 16 iter_args(%arg8 = %1, %arg9 = %0) -> (tensor, tensor) { + %11:2 = affine.for %arg10 = 0 to 24 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (tensor, tensor) { + %extracted = tensor.extract %5[%arg7] : tensor + %12 = affine.apply #map(%arg7) + %extracted_1 = tensor.extract %5[%12] : tensor + %13 = arith.index_cast %extracted_1 : i32 to index + %14 = arith.index_cast %extracted : i32 to index + %15:2 = scf.for %arg13 = %14 to %13 step %c1 iter_args(%arg14 = %c-1_i32, %arg15 = %7) -> (i32, f32) { + %16 = arith.index_cast %arg13 : index to i32 + %extracted_3 = tensor.extract %3[%arg13] : tensor + %extracted_4 = tensor.extract %4[%arg13] : tensor + %17 = arith.index_cast %extracted_4 : i32 to index + %extracted_5 = tensor.extract %2[%17, %arg10] : tensor + %18 = arith.mulf %extracted_3, %extracted_5 : f32 + %19 = arith.cmpf ogt, %18, %arg15 : f32 + %20 = arith.select %6, %19, %false : i1 + %21 = arith.cmpf olt, %18, %arg15 : f32 + %22 = arith.select %6, %false, %21 : i1 + %23 = arith.select %20, %true, %22 : i1 + %24 = arith.select %23, %16, %arg14 : i32 + %25 = arith.select %23, %18, %arg15 : f32 + scf.yield %24, %25 : i32, f32 + } + %inserted = tensor.insert %15#1 into %arg11[%arg7, %arg10] : tensor + %inserted_2 = tensor.insert %15#0 into %arg12[%arg7, %arg10] : tensor + affine.yield %inserted, %inserted_2 : tensor, tensor + } + affine.yield %11#0, %11#1 : tensor, tensor + } + %9 = bufferization.to_memref %8#1 : memref + memref.copy %9, %arg6 : memref to memref + %10 = bufferization.to_memref %8#0 : memref + memref.copy %10, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu/orig.mlir new file mode 100644 index 000000000000..bab677516243 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu/orig.mlir @@ -0,0 +1,52 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %true = arith.constant true + %false = arith.constant false + %c-1_i32 = arith.constant -1 : i32 + %cst = arith.constant 3.40282347E+38 : f32 + %cst_0 = arith.constant -3.40282347E+38 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg4, %c0_i32 : i32 + %1 = arith.select %0, %cst_0, %cst : f32 + affine.for %arg7 = 0 to 16 { + affine.for %arg8 = 0 to 24 { + %2 = affine.load %arg0[%arg7] : memref + %3 = affine.load %arg0[%arg7 + 1] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = arith.index_cast %2 : i32 to index + %6:2 = scf.for %arg9 = %5 to %4 step %c1 iter_args(%arg10 = %c-1_i32, %arg11 = %1) -> (i32, f32) { + %7 = arith.index_cast %arg9 : index to i32 + %8 = memref.load %arg2[%arg9] : memref + %9 = memref.load %arg1[%arg9] : memref + %10 = arith.index_cast %9 : i32 to index + %11 = memref.load %arg3[%10, %arg8] : memref + %12 = arith.mulf %8, %11 : f32 + %13 = scf.if %0 -> (i1) { + %17 = arith.cmpf ogt, %12, %arg11 : f32 + scf.yield %17 : i1 + } else { + scf.yield %false : i1 + } + %14 = scf.if %13 -> (i1) { + scf.yield %true : i1 + } else { + %17 = scf.if %0 -> (i1) { + scf.yield %false : i1 + } else { + %18 = arith.cmpf olt, %12, %arg11 : f32 + scf.yield %18 : i1 + } + scf.yield %17 : i1 + } + %15 = arith.select %14, %7, %arg10 : i32 + %16 = arith.select %14, %12, %arg11 : f32 + scf.yield %15, %16 : i32, f32 + } + affine.store %6#1, %arg5[%arg7, %arg8] : memref + affine.store %6#0, %arg6[%arg7, %arg8] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu/raised.mlir new file mode 100644 index 000000000000..f4eb29718c7d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu/raised.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %true = arith.constant true + %false = arith.constant false + %c-1_i32 = arith.constant -1 : i32 + %cst = arith.constant 3.40282347E+38 : f32 + %cst_0 = arith.constant -3.40282347E+38 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg4, %c0_i32 : i32 + %1 = arith.select %0, %cst_0, %cst : f32 + affine.for %arg7 = 0 to 16 { + affine.for %arg8 = 0 to 24 { + %2 = affine.load %arg0[%arg7] : memref + %3 = affine.load %arg0[%arg7 + 1] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = arith.index_cast %2 : i32 to index + %6:2 = scf.for %arg9 = %5 to %4 step %c1 iter_args(%arg10 = %c-1_i32, %arg11 = %1) -> (i32, f32) { + %7 = arith.index_cast %arg9 : index to i32 + %8 = memref.load %arg2[%arg9] : memref + %9 = memref.load %arg1[%arg9] : memref + %10 = arith.index_cast %9 : i32 to index + %11 = memref.load %arg3[%10, %arg8] : memref + %12 = arith.mulf %8, %11 : f32 + %13 = arith.cmpf ogt, %12, %arg11 : f32 + %14 = arith.select %0, %13, %false : i1 + %15 = arith.cmpf olt, %12, %arg11 : f32 + %16 = arith.select %0, %false, %15 : i1 + %17 = arith.select %14, %true, %16 : i1 + %18 = arith.select %17, %7, %arg10 : i32 + %19 = arith.select %17, %12, %arg11 : f32 + scf.yield %18, %19 : i32, f32 + } + affine.store %6#1, %arg5[%arg7, %arg8] : memref + affine.store %6#0, %arg6[%arg7, %arg8] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu_debuf.mlir new file mode 100644 index 000000000000..1aa498068abe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu_debuf.mlir @@ -0,0 +1,55 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %true = arith.constant true + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = bufferization.to_tensor %arg0 : memref + %6 = arith.cmpi ne, %arg4, %c0_i32 : i32 + %7 = arith.select %6, %cst, %cst_0 : f32 + %8:2 = affine.for %arg7 = 0 to 16 iter_args(%arg8 = %1, %arg9 = %0) -> (tensor, tensor) { + %11:2 = affine.for %arg10 = 0 to 24 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (tensor, tensor) { + %extracted = tensor.extract %5[%arg7] : tensor + %12 = affine.apply #map(%arg7) + %extracted_1 = tensor.extract %5[%12] : tensor + %13 = arith.index_cast %extracted_1 : i32 to index + %14 = arith.index_cast %extracted : i32 to index + %15:2 = scf.for %arg13 = %14 to %13 step %c1 iter_args(%arg14 = %c-1_i32, %arg15 = %7) -> (i32, f32) { + %16 = arith.index_cast %arg13 : index to i32 + %extracted_3 = tensor.extract %3[%arg13] : tensor + %extracted_4 = tensor.extract %4[%arg13] : tensor + %17 = arith.index_cast %extracted_4 : i32 to index + %extracted_5 = tensor.extract %2[%17, %arg10] : tensor + %18 = arith.mulf %extracted_3, %extracted_5 : f32 + %19 = arith.cmpf ogt, %18, %arg15 : f32 + %20 = arith.select %6, %19, %false : i1 + %21 = arith.cmpf olt, %18, %arg15 : f32 + %22 = arith.select %6, %false, %21 : i1 + %23 = arith.select %20, %true, %22 : i1 + %24 = arith.select %23, %16, %arg14 : i32 + %25 = arith.select %23, %18, %arg15 : f32 + scf.yield %24, %25 : i32, f32 + } + %inserted = tensor.insert %15#1 into %arg11[%arg7, %arg10] : tensor + %inserted_2 = tensor.insert %15#0 into %arg12[%arg7, %arg10] : tensor + affine.yield %inserted, %inserted_2 : tensor, tensor + } + affine.yield %11#0, %11#1 : tensor, tensor + } + %9 = bufferization.to_memref %8#1 : memref + memref.copy %9, %arg6 : memref to memref + %10 = bufferization.to_memref %8#0 : memref + memref.copy %10, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu_linalg.mlir new file mode 100644 index 000000000000..f4eb29718c7d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_arg_cpu_linalg.mlir @@ -0,0 +1,41 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %true = arith.constant true + %false = arith.constant false + %c-1_i32 = arith.constant -1 : i32 + %cst = arith.constant 3.40282347E+38 : f32 + %cst_0 = arith.constant -3.40282347E+38 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg4, %c0_i32 : i32 + %1 = arith.select %0, %cst_0, %cst : f32 + affine.for %arg7 = 0 to 16 { + affine.for %arg8 = 0 to 24 { + %2 = affine.load %arg0[%arg7] : memref + %3 = affine.load %arg0[%arg7 + 1] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = arith.index_cast %2 : i32 to index + %6:2 = scf.for %arg9 = %5 to %4 step %c1 iter_args(%arg10 = %c-1_i32, %arg11 = %1) -> (i32, f32) { + %7 = arith.index_cast %arg9 : index to i32 + %8 = memref.load %arg2[%arg9] : memref + %9 = memref.load %arg1[%arg9] : memref + %10 = arith.index_cast %9 : i32 to index + %11 = memref.load %arg3[%10, %arg8] : memref + %12 = arith.mulf %8, %11 : f32 + %13 = arith.cmpf ogt, %12, %arg11 : f32 + %14 = arith.select %0, %13, %false : i1 + %15 = arith.cmpf olt, %12, %arg11 : f32 + %16 = arith.select %0, %false, %15 : i1 + %17 = arith.select %14, %true, %16 : i1 + %18 = arith.select %17, %7, %arg10 : i32 + %19 = arith.select %17, %12, %arg11 : f32 + scf.yield %18, %19 : i32, f32 + } + affine.store %6#1, %arg5[%arg7, %arg8] : memref + affine.store %6#0, %arg6[%arg7, %arg8] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu.mlir new file mode 100644 index 000000000000..a7d28ab3184e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_input_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg6 = 0 to 96 { + affine.store %cst, %arg5[%arg6] : memref + } + affine.for %arg6 = 0 to 16 { + affine.for %arg7 = 0 to 24 { + %0 = affine.load %arg2[%arg6, %arg7] : memref + %1 = arith.cmpi sge, %0, %c0_i32 : i32 + scf.if %1 { + %2 = arith.index_cast %0 : i32 to index + %3 = affine.load %arg3[%arg6, %arg7] : memref + %4 = memref.load %arg1[%2] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg4[%5, %arg7] : memref + %7 = arith.mulf %3, %6 : f32 + %8 = memref.load %arg5[%2] : memref + %9 = arith.addf %8, %7 : f32 + memref.store %9, %arg5[%2] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu/debuf.mlir new file mode 100644 index 000000000000..06af3efcfc36 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu/debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_input_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %6 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %5) -> (tensor) { + %8 = affine.for %arg8 = 0 to 24 iter_args(%arg9 = %arg7) -> (tensor) { + %extracted = tensor.extract %3[%arg6, %arg8] : tensor + %9 = arith.cmpi sge, %extracted, %c0_i32 : i32 + %10 = scf.if %9 -> (tensor) { + %11 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg6, %arg8] : tensor + %extracted_1 = tensor.extract %4[%11] : tensor + %12 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %1[%12, %arg8] : tensor + %13 = arith.mulf %extracted_0, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg9[%11] : tensor + %14 = arith.addf %extracted_3, %13 : f32 + %inserted = tensor.insert %14 into %arg9[%11] : tensor + scf.yield %inserted : tensor + } else { + scf.yield %arg9 : tensor + } + affine.yield %10 : tensor + } + affine.yield %8 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu/matched.mlir new file mode 100644 index 000000000000..d27588f6b2e5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu/matched.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_input_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %6 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %5) -> (tensor) { + %8 = affine.for %arg8 = 0 to 24 iter_args(%arg9 = %arg7) -> (tensor) { + %extracted = tensor.extract %3[%arg6, %arg8] : tensor + %9 = arith.cmpi sge, %extracted, %c0_i32 : i32 + %10 = scf.if %9 -> (tensor) { + %11 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg6, %arg8] : tensor + %extracted_1 = tensor.extract %4[%11] : tensor + %12 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %1[%12, %arg8] : tensor + %13 = arith.mulf %extracted_0, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg9[%11] : tensor + %14 = arith.addf %extracted_3, %13 : f32 + %inserted = tensor.insert %14 into %arg9[%11] : tensor + scf.yield %inserted : tensor + } else { + scf.yield %arg9 : tensor + } + affine.yield %10 : tensor + } + affine.yield %8 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu/orig.mlir new file mode 100644 index 000000000000..a7d28ab3184e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu/orig.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_input_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg6 = 0 to 96 { + affine.store %cst, %arg5[%arg6] : memref + } + affine.for %arg6 = 0 to 16 { + affine.for %arg7 = 0 to 24 { + %0 = affine.load %arg2[%arg6, %arg7] : memref + %1 = arith.cmpi sge, %0, %c0_i32 : i32 + scf.if %1 { + %2 = arith.index_cast %0 : i32 to index + %3 = affine.load %arg3[%arg6, %arg7] : memref + %4 = memref.load %arg1[%2] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg4[%5, %arg7] : memref + %7 = arith.mulf %3, %6 : f32 + %8 = memref.load %arg5[%2] : memref + %9 = arith.addf %8, %7 : f32 + memref.store %9, %arg5[%2] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu/raised.mlir new file mode 100644 index 000000000000..29661fbd9488 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu/raised.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_input_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg5 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg6 = 0 to 16 { + affine.for %arg7 = 0 to 24 { + %0 = affine.load %arg2[%arg6, %arg7] : memref + %1 = arith.cmpi sge, %0, %c0_i32 : i32 + scf.if %1 { + %2 = arith.index_cast %0 : i32 to index + %3 = affine.load %arg3[%arg6, %arg7] : memref + %4 = memref.load %arg1[%2] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg4[%5, %arg7] : memref + %7 = arith.mulf %3, %6 : f32 + %8 = memref.load %arg5[%2] : memref + %9 = arith.addf %8, %7 : f32 + memref.store %9, %arg5[%2] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu_debuf.mlir new file mode 100644 index 000000000000..06af3efcfc36 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu_debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_input_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %6 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %5) -> (tensor) { + %8 = affine.for %arg8 = 0 to 24 iter_args(%arg9 = %arg7) -> (tensor) { + %extracted = tensor.extract %3[%arg6, %arg8] : tensor + %9 = arith.cmpi sge, %extracted, %c0_i32 : i32 + %10 = scf.if %9 -> (tensor) { + %11 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg6, %arg8] : tensor + %extracted_1 = tensor.extract %4[%11] : tensor + %12 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %1[%12, %arg8] : tensor + %13 = arith.mulf %extracted_0, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg9[%11] : tensor + %14 = arith.addf %extracted_3, %13 : f32 + %inserted = tensor.insert %14 into %arg9[%11] : tensor + scf.yield %inserted : tensor + } else { + scf.yield %arg9 : tensor + } + affine.yield %10 : tensor + } + affine.yield %8 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu_linalg.mlir new file mode 100644 index 000000000000..29661fbd9488 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_arg_cpu_linalg.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_input_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg5 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg6 = 0 to 16 { + affine.for %arg7 = 0 to 24 { + %0 = affine.load %arg2[%arg6, %arg7] : memref + %1 = arith.cmpi sge, %0, %c0_i32 : i32 + scf.if %1 { + %2 = arith.index_cast %0 : i32 to index + %3 = affine.load %arg3[%arg6, %arg7] : memref + %4 = memref.load %arg1[%2] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg4[%5, %arg7] : memref + %7 = arith.mulf %3, %6 : f32 + %8 = memref.load %arg5[%2] : memref + %9 = arith.addf %8, %7 : f32 + memref.store %9, %arg5[%2] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu.mlir new file mode 100644 index 000000000000..e731a2dece60 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_input_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + affine.for %arg5 = 0 to 16 { + %0 = affine.load %arg0[%arg5] : memref + %1 = scf.while (%arg6 = %0) : (i32) -> i32 { + %2 = affine.load %arg0[%arg5 + 1] : memref + %3 = arith.cmpi slt, %arg6, %2 : i32 + scf.condition(%3) %arg6 : i32 + } do { + ^bb0(%arg6: i32): + %2 = arith.index_cast %arg6 : i32 to index + %3 = memref.load %arg1[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = affine.for %arg7 = 0 to 24 iter_args(%arg8 = %cst) -> (f32) { + %7 = affine.load %arg2[%arg5, %arg7] : memref + %8 = memref.load %arg3[%4, %arg7] : memref + %9 = arith.mulf %7, %8 : f32 + %10 = arith.addf %arg8, %9 : f32 + affine.yield %10 : f32 + } + memref.store %5, %arg4[%2] : memref + %6 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %6 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu/debuf.mlir new file mode 100644 index 000000000000..118d5535f63d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu/debuf.mlir @@ -0,0 +1,50 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_input_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %0) -> (tensor) { + %extracted = tensor.extract %2[%arg5] : tensor + %5:2 = scf.while (%arg7 = %extracted, %arg8 = %arg6) : (i32, tensor) -> (i32, tensor) { + %6 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %2[%6] : tensor + %7 = arith.cmpi slt, %arg7, %extracted_0 : i32 + scf.condition(%7) %arg7, %arg8 : i32, tensor + } do { + ^bb0(%arg7: i32, %arg8: tensor): + %6 = arith.index_cast %arg7 : i32 to index + %extracted_0 = tensor.extract %1[%6] : tensor + %7 = arith.index_cast %extracted_0 : i32 to index + %alloca = memref.alloca() : memref + %8 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %8[] : tensor + %9 = polygeist.submap(%inserted, %c24) {map = #map1} : (tensor, index) -> tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction"], library_call = ""} outs(%9 : tensor) { + ^bb0(%out: f32): + %13 = linalg.index 0 : index + %14 = memref.load %arg2[%arg5, %13] : memref + %15 = memref.load %arg3[%7, %13] : memref + %16 = arith.mulf %14, %15 : f32 + %17 = arith.addf %out, %16 : f32 + linalg.yield %17 : f32 + } -> tensor + %11 = polygeist.submapInverse(%inserted, %10, %c24) {map = #map1} : (tensor, tensor, index) -> tensor + %extracted_1 = tensor.extract %11[] : tensor + %inserted_2 = tensor.insert %extracted_1 into %arg8[%6] : tensor + %12 = arith.addi %arg7, %c1_i32 : i32 + scf.yield %12, %inserted_2 : i32, tensor + } + affine.yield %5#1 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu/matched.mlir new file mode 100644 index 000000000000..118d5535f63d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu/matched.mlir @@ -0,0 +1,50 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_input_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %0) -> (tensor) { + %extracted = tensor.extract %2[%arg5] : tensor + %5:2 = scf.while (%arg7 = %extracted, %arg8 = %arg6) : (i32, tensor) -> (i32, tensor) { + %6 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %2[%6] : tensor + %7 = arith.cmpi slt, %arg7, %extracted_0 : i32 + scf.condition(%7) %arg7, %arg8 : i32, tensor + } do { + ^bb0(%arg7: i32, %arg8: tensor): + %6 = arith.index_cast %arg7 : i32 to index + %extracted_0 = tensor.extract %1[%6] : tensor + %7 = arith.index_cast %extracted_0 : i32 to index + %alloca = memref.alloca() : memref + %8 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %8[] : tensor + %9 = polygeist.submap(%inserted, %c24) {map = #map1} : (tensor, index) -> tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction"], library_call = ""} outs(%9 : tensor) { + ^bb0(%out: f32): + %13 = linalg.index 0 : index + %14 = memref.load %arg2[%arg5, %13] : memref + %15 = memref.load %arg3[%7, %13] : memref + %16 = arith.mulf %14, %15 : f32 + %17 = arith.addf %out, %16 : f32 + linalg.yield %17 : f32 + } -> tensor + %11 = polygeist.submapInverse(%inserted, %10, %c24) {map = #map1} : (tensor, tensor, index) -> tensor + %extracted_1 = tensor.extract %11[] : tensor + %inserted_2 = tensor.insert %extracted_1 into %arg8[%6] : tensor + %12 = arith.addi %arg7, %c1_i32 : i32 + scf.yield %12, %inserted_2 : i32, tensor + } + affine.yield %5#1 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu/orig.mlir new file mode 100644 index 000000000000..e731a2dece60 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu/orig.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_input_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + affine.for %arg5 = 0 to 16 { + %0 = affine.load %arg0[%arg5] : memref + %1 = scf.while (%arg6 = %0) : (i32) -> i32 { + %2 = affine.load %arg0[%arg5 + 1] : memref + %3 = arith.cmpi slt, %arg6, %2 : i32 + scf.condition(%3) %arg6 : i32 + } do { + ^bb0(%arg6: i32): + %2 = arith.index_cast %arg6 : i32 to index + %3 = memref.load %arg1[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = affine.for %arg7 = 0 to 24 iter_args(%arg8 = %cst) -> (f32) { + %7 = affine.load %arg2[%arg5, %arg7] : memref + %8 = memref.load %arg3[%4, %arg7] : memref + %9 = arith.mulf %7, %8 : f32 + %10 = arith.addf %arg8, %9 : f32 + affine.yield %10 : f32 + } + memref.store %5, %arg4[%2] : memref + %6 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %6 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu/raised.mlir new file mode 100644 index 000000000000..9ece61421b7b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu/raised.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> ()> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_input_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + affine.for %arg5 = 0 to 16 { + %0 = affine.load %arg0[%arg5] : memref + %1 = scf.while (%arg6 = %0) : (i32) -> i32 { + %2 = affine.load %arg0[%arg5 + 1] : memref + %3 = arith.cmpi slt, %arg6, %2 : i32 + scf.condition(%3) %arg6 : i32 + } do { + ^bb0(%arg6: i32): + %2 = arith.index_cast %arg6 : i32 to index + %3 = memref.load %arg1[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %5 = polygeist.submap(%alloca, %c24) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction"]} outs(%5 : memref) { + ^bb0(%out: f32): + %8 = linalg.index 0 : index + %9 = memref.load %arg2[%arg5, %8] : memref + %10 = memref.load %arg3[%4, %8] : memref + %11 = arith.mulf %9, %10 : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + %6 = affine.load %alloca[] : memref + memref.store %6, %arg4[%2] : memref + %7 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %7 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu_debuf.mlir new file mode 100644 index 000000000000..118d5535f63d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu_debuf.mlir @@ -0,0 +1,50 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_input_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %0) -> (tensor) { + %extracted = tensor.extract %2[%arg5] : tensor + %5:2 = scf.while (%arg7 = %extracted, %arg8 = %arg6) : (i32, tensor) -> (i32, tensor) { + %6 = affine.apply #map(%arg5) + %extracted_0 = tensor.extract %2[%6] : tensor + %7 = arith.cmpi slt, %arg7, %extracted_0 : i32 + scf.condition(%7) %arg7, %arg8 : i32, tensor + } do { + ^bb0(%arg7: i32, %arg8: tensor): + %6 = arith.index_cast %arg7 : i32 to index + %extracted_0 = tensor.extract %1[%6] : tensor + %7 = arith.index_cast %extracted_0 : i32 to index + %alloca = memref.alloca() : memref + %8 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %8[] : tensor + %9 = polygeist.submap(%inserted, %c24) {map = #map1} : (tensor, index) -> tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction"], library_call = ""} outs(%9 : tensor) { + ^bb0(%out: f32): + %13 = linalg.index 0 : index + %14 = memref.load %arg2[%arg5, %13] : memref + %15 = memref.load %arg3[%7, %13] : memref + %16 = arith.mulf %14, %15 : f32 + %17 = arith.addf %out, %16 : f32 + linalg.yield %17 : f32 + } -> tensor + %11 = polygeist.submapInverse(%inserted, %10, %c24) {map = #map1} : (tensor, tensor, index) -> tensor + %extracted_1 = tensor.extract %11[] : tensor + %inserted_2 = tensor.insert %extracted_1 into %arg8[%6] : tensor + %12 = arith.addi %arg7, %c1_i32 : i32 + scf.yield %12, %inserted_2 : i32, tensor + } + affine.yield %5#1 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu_linalg.mlir new file mode 100644 index 000000000000..9ece61421b7b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_input_cpu_linalg.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> ()> +#map1 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_input_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + affine.for %arg5 = 0 to 16 { + %0 = affine.load %arg0[%arg5] : memref + %1 = scf.while (%arg6 = %0) : (i32) -> i32 { + %2 = affine.load %arg0[%arg5 + 1] : memref + %3 = arith.cmpi slt, %arg6, %2 : i32 + scf.condition(%3) %arg6 : i32 + } do { + ^bb0(%arg6: i32): + %2 = arith.index_cast %arg6 : i32 to index + %3 = memref.load %arg1[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %5 = polygeist.submap(%alloca, %c24) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction"]} outs(%5 : memref) { + ^bb0(%out: f32): + %8 = linalg.index 0 : index + %9 = memref.load %arg2[%arg5, %8] : memref + %10 = memref.load %arg3[%4, %8] : memref + %11 = arith.mulf %9, %10 : f32 + %12 = arith.addf %out, %11 : f32 + linalg.yield %12 : f32 + } + %6 = affine.load %alloca[] : memref + memref.store %6, %arg4[%2] : memref + %7 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %7 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu.mlir new file mode 100644 index 000000000000..2ee5e88e9ab5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_other_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg5 = 0 to 32 { + affine.for %arg6 = 0 to 24 { + affine.store %cst, %arg4[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 24 { + %0 = affine.load %arg2[%arg5, %arg6] : memref + %1 = arith.cmpi sge, %0, %c0_i32 : i32 + scf.if %1 { + %2 = arith.index_cast %0 : i32 to index + %3 = memref.load %arg0[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg1[%2] : memref + %6 = affine.load %arg3[%arg5, %arg6] : memref + %7 = arith.mulf %5, %6 : f32 + %8 = memref.load %arg4[%4, %arg6] : memref + %9 = arith.addf %8, %7 : f32 + memref.store %9, %arg4[%4, %arg6] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu/debuf.mlir new file mode 100644 index 000000000000..463bb3044146 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu/debuf.mlir @@ -0,0 +1,46 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_other_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c32, %c24] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %8 = affine.for %arg7 = 0 to 24 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %2[%arg5, %arg7] : tensor + %9 = arith.cmpi sge, %extracted, %c0_i32 : i32 + %10 = scf.if %9 -> (tensor) { + %11 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %4[%11] : tensor + %12 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %3[%11] : tensor + %extracted_2 = tensor.extract %1[%arg5, %arg7] : tensor + %13 = arith.mulf %extracted_1, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg8[%12, %arg7] : tensor + %14 = arith.addf %extracted_3, %13 : f32 + %inserted = tensor.insert %14 into %arg8[%12, %arg7] : tensor + scf.yield %inserted : tensor + } else { + scf.yield %arg8 : tensor + } + affine.yield %10 : tensor + } + affine.yield %8 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu/matched.mlir new file mode 100644 index 000000000000..23df7657ad4f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu/matched.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_other_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %5 = kernel.launch @memset_zero_2D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c32, %c24] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %8 = affine.for %arg7 = 0 to 24 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %2[%arg5, %arg7] : tensor + %9 = arith.cmpi sge, %extracted, %c0_i32 : i32 + %10 = scf.if %9 -> (tensor) { + %11 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %4[%11] : tensor + %12 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %3[%11] : tensor + %extracted_2 = tensor.extract %1[%arg5, %arg7] : tensor + %13 = arith.mulf %extracted_1, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg8[%12, %arg7] : tensor + %14 = arith.addf %extracted_3, %13 : f32 + %inserted = tensor.insert %14 into %arg8[%12, %arg7] : tensor + scf.yield %inserted : tensor + } else { + scf.yield %arg8 : tensor + } + affine.yield %10 : tensor + } + affine.yield %8 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu/orig.mlir new file mode 100644 index 000000000000..2ee5e88e9ab5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu/orig.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_other_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg5 = 0 to 32 { + affine.for %arg6 = 0 to 24 { + affine.store %cst, %arg4[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 24 { + %0 = affine.load %arg2[%arg5, %arg6] : memref + %1 = arith.cmpi sge, %0, %c0_i32 : i32 + scf.if %1 { + %2 = arith.index_cast %0 : i32 to index + %3 = memref.load %arg0[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg1[%2] : memref + %6 = affine.load %arg3[%arg5, %arg6] : memref + %7 = arith.mulf %5, %6 : f32 + %8 = memref.load %arg4[%4, %arg6] : memref + %9 = arith.addf %8, %7 : f32 + memref.store %9, %arg4[%4, %arg6] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu/raised.mlir new file mode 100644 index 000000000000..9000191b21ef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu/raised.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_other_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg4[0, 0] [%c32, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 24 { + %0 = affine.load %arg2[%arg5, %arg6] : memref + %1 = arith.cmpi sge, %0, %c0_i32 : i32 + scf.if %1 { + %2 = arith.index_cast %0 : i32 to index + %3 = memref.load %arg0[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg1[%2] : memref + %6 = affine.load %arg3[%arg5, %arg6] : memref + %7 = arith.mulf %5, %6 : f32 + %8 = memref.load %arg4[%4, %arg6] : memref + %9 = arith.addf %8, %7 : f32 + memref.store %9, %arg4[%4, %arg6] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu_debuf.mlir new file mode 100644 index 000000000000..463bb3044146 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu_debuf.mlir @@ -0,0 +1,46 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_other_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c32, %c24] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %8 = affine.for %arg7 = 0 to 24 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %2[%arg5, %arg7] : tensor + %9 = arith.cmpi sge, %extracted, %c0_i32 : i32 + %10 = scf.if %9 -> (tensor) { + %11 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %4[%11] : tensor + %12 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %3[%11] : tensor + %extracted_2 = tensor.extract %1[%arg5, %arg7] : tensor + %13 = arith.mulf %extracted_1, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg8[%12, %arg7] : tensor + %14 = arith.addf %extracted_3, %13 : f32 + %inserted = tensor.insert %14 into %arg8[%12, %arg7] : tensor + scf.yield %inserted : tensor + } else { + scf.yield %arg8 : tensor + } + affine.yield %10 : tensor + } + affine.yield %8 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu_linalg.mlir new file mode 100644 index 000000000000..9000191b21ef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_arg_cpu_linalg.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_other_arg_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %subview = memref.subview %arg4[0, 0] [%c32, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg5 = 0 to 16 { + affine.for %arg6 = 0 to 24 { + %0 = affine.load %arg2[%arg5, %arg6] : memref + %1 = arith.cmpi sge, %0, %c0_i32 : i32 + scf.if %1 { + %2 = arith.index_cast %0 : i32 to index + %3 = memref.load %arg0[%2] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg1[%2] : memref + %6 = affine.load %arg3[%arg5, %arg6] : memref + %7 = arith.mulf %5, %6 : f32 + %8 = memref.load %arg4[%4, %arg6] : memref + %9 = arith.addf %8, %7 : f32 + memref.store %9, %arg4[%4, %arg6] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu.mlir new file mode 100644 index 000000000000..02e6be6de889 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_other_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 32 { + affine.for %arg6 = 0 to 24 { + affine.store %cst, %arg4[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 0 to 16 { + %0 = affine.load %arg0[%arg5] : memref + %1 = scf.while (%arg6 = %0) : (i32) -> i32 { + %2 = affine.load %arg0[%arg5 + 1] : memref + %3 = arith.cmpi slt, %arg6, %2 : i32 + scf.condition(%3) %arg6 : i32 + } do { + ^bb0(%arg6: i32): + %2 = arith.index_cast %arg6 : i32 to index + affine.for %arg7 = 0 to 24 { + %4 = memref.load %arg1[%2] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg2[%2] : memref + %7 = affine.load %arg3[%arg5, %arg7] : memref + %8 = arith.mulf %6, %7 : f32 + %9 = memref.load %arg4[%5, %arg7] : memref + %10 = arith.addf %9, %8 : f32 + memref.store %10, %arg4[%5, %arg7] : memref + } + %3 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %3 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu/debuf.mlir new file mode 100644 index 000000000000..79da648c8408 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu/debuf.mlir @@ -0,0 +1,51 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_other_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c32, %c24] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %8:2 = scf.while (%arg7 = %extracted, %arg8 = %arg6) : (i32, tensor) -> (i32, tensor) { + %9 = affine.apply #map1(%arg5) + %extracted_0 = tensor.extract %4[%9] : tensor + %10 = arith.cmpi slt, %arg7, %extracted_0 : i32 + scf.condition(%10) %arg7, %arg8 : i32, tensor + } do { + ^bb0(%arg7: i32, %arg8: tensor): + %9 = arith.index_cast %arg7 : i32 to index + %10 = affine.for %arg9 = 0 to 24 iter_args(%arg10 = %arg8) -> (tensor) { + %extracted_0 = tensor.extract %3[%9] : tensor + %12 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %2[%9] : tensor + %extracted_2 = tensor.extract %1[%arg5, %arg9] : tensor + %13 = arith.mulf %extracted_1, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg10[%12, %arg9] : tensor + %14 = arith.addf %extracted_3, %13 : f32 + %inserted = tensor.insert %14 into %arg10[%12, %arg9] : tensor + affine.yield %inserted : tensor + } + %11 = arith.addi %arg7, %c1_i32 : i32 + scf.yield %11, %10 : i32, tensor + } + affine.yield %8#1 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu/matched.mlir new file mode 100644 index 000000000000..4f7c23e9c39a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu/matched.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_other_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %5 = kernel.launch @memset_zero_2D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c32, %c24] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %8:2 = scf.while (%arg7 = %extracted, %arg8 = %arg6) : (i32, tensor) -> (i32, tensor) { + %9 = affine.apply #map1(%arg5) + %extracted_0 = tensor.extract %4[%9] : tensor + %10 = arith.cmpi slt, %arg7, %extracted_0 : i32 + scf.condition(%10) %arg7, %arg8 : i32, tensor + } do { + ^bb0(%arg7: i32, %arg8: tensor): + %9 = arith.index_cast %arg7 : i32 to index + %10 = affine.for %arg9 = 0 to 24 iter_args(%arg10 = %arg8) -> (tensor) { + %extracted_0 = tensor.extract %3[%9] : tensor + %12 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %2[%9] : tensor + %extracted_2 = tensor.extract %1[%arg5, %arg9] : tensor + %13 = arith.mulf %extracted_1, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg10[%12, %arg9] : tensor + %14 = arith.addf %extracted_3, %13 : f32 + %inserted = tensor.insert %14 into %arg10[%12, %arg9] : tensor + affine.yield %inserted : tensor + } + %11 = arith.addi %arg7, %c1_i32 : i32 + scf.yield %11, %10 : i32, tensor + } + affine.yield %8#1 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu/orig.mlir new file mode 100644 index 000000000000..02e6be6de889 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu/orig.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_other_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 32 { + affine.for %arg6 = 0 to 24 { + affine.store %cst, %arg4[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 0 to 16 { + %0 = affine.load %arg0[%arg5] : memref + %1 = scf.while (%arg6 = %0) : (i32) -> i32 { + %2 = affine.load %arg0[%arg5 + 1] : memref + %3 = arith.cmpi slt, %arg6, %2 : i32 + scf.condition(%3) %arg6 : i32 + } do { + ^bb0(%arg6: i32): + %2 = arith.index_cast %arg6 : i32 to index + affine.for %arg7 = 0 to 24 { + %4 = memref.load %arg1[%2] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg2[%2] : memref + %7 = affine.load %arg3[%arg5, %arg7] : memref + %8 = arith.mulf %6, %7 : f32 + %9 = memref.load %arg4[%5, %arg7] : memref + %10 = arith.addf %9, %8 : f32 + memref.store %10, %arg4[%5, %arg7] : memref + } + %3 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %3 : i32 + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu/raised.mlir new file mode 100644 index 000000000000..6e614513c37c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu/raised.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_other_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg4[0, 0] [%c32, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg5 = 0 to 16 { + %0 = affine.load %arg0[%arg5] : memref + %1 = scf.while (%arg6 = %0) : (i32) -> i32 { + %2 = affine.load %arg0[%arg5 + 1] : memref + %3 = arith.cmpi slt, %arg6, %2 : i32 + scf.condition(%3) %arg6 : i32 + } do { + ^bb0(%arg6: i32): + %2 = arith.index_cast %arg6 : i32 to index + affine.for %arg7 = 0 to 24 { + %4 = memref.load %arg1[%2] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg2[%2] : memref + %7 = affine.load %arg3[%arg5, %arg7] : memref + %8 = arith.mulf %6, %7 : f32 + %9 = memref.load %arg4[%5, %arg7] : memref + %10 = arith.addf %9, %8 : f32 + memref.store %10, %arg4[%5, %arg7] : memref + } + %3 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %3 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu_debuf.mlir new file mode 100644 index 000000000000..79da648c8408 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu_debuf.mlir @@ -0,0 +1,51 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_other_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c32, %c24] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %8:2 = scf.while (%arg7 = %extracted, %arg8 = %arg6) : (i32, tensor) -> (i32, tensor) { + %9 = affine.apply #map1(%arg5) + %extracted_0 = tensor.extract %4[%9] : tensor + %10 = arith.cmpi slt, %arg7, %extracted_0 : i32 + scf.condition(%10) %arg7, %arg8 : i32, tensor + } do { + ^bb0(%arg7: i32, %arg8: tensor): + %9 = arith.index_cast %arg7 : i32 to index + %10 = affine.for %arg9 = 0 to 24 iter_args(%arg10 = %arg8) -> (tensor) { + %extracted_0 = tensor.extract %3[%9] : tensor + %12 = arith.index_cast %extracted_0 : i32 to index + %extracted_1 = tensor.extract %2[%9] : tensor + %extracted_2 = tensor.extract %1[%arg5, %arg9] : tensor + %13 = arith.mulf %extracted_1, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg10[%12, %arg9] : tensor + %14 = arith.addf %extracted_3, %13 : f32 + %inserted = tensor.insert %14 into %arg10[%12, %arg9] : tensor + affine.yield %inserted : tensor + } + %11 = arith.addi %arg7, %c1_i32 : i32 + scf.yield %11, %10 : i32, tensor + } + affine.yield %8#1 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu_linalg.mlir new file mode 100644 index 000000000000..6e614513c37c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_backward_other_cpu_linalg.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_backward_other_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg4[0, 0] [%c32, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg5 = 0 to 16 { + %0 = affine.load %arg0[%arg5] : memref + %1 = scf.while (%arg6 = %0) : (i32) -> i32 { + %2 = affine.load %arg0[%arg5 + 1] : memref + %3 = arith.cmpi slt, %arg6, %2 : i32 + scf.condition(%3) %arg6 : i32 + } do { + ^bb0(%arg6: i32): + %2 = arith.index_cast %arg6 : i32 to index + affine.for %arg7 = 0 to 24 { + %4 = memref.load %arg1[%2] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg2[%2] : memref + %7 = affine.load %arg3[%arg5, %arg7] : memref + %8 = arith.mulf %6, %7 : f32 + %9 = memref.load %arg4[%5, %arg7] : memref + %10 = arith.addf %9, %8 : f32 + memref.store %10, %arg4[%5, %arg7] : memref + } + %3 = arith.addi %arg6, %c1_i32 : i32 + scf.yield %3 : i32 + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_cpu.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_cpu.mlir new file mode 100644 index 000000000000..6b67ac9fb087 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_cpu.mlir @@ -0,0 +1,77 @@ +#set = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c0 = arith.constant 0 : index + %c0_i32 = arith.constant 0 : i32 + %c2_i32 = arith.constant 2 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c3_i32 = arith.constant 3 : i32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %true = arith.constant true + %c1 = arith.constant 1 : index + %0 = arith.index_cast %arg4 : i32 to index + %1 = arith.cmpi eq, %arg4, %c2_i32 : i32 + %2 = arith.cmpi eq, %arg4, %c0_i32 : i32 + %3 = scf.if %1 -> (f32) { + scf.yield %cst : f32 + } else { + %7 = arith.cmpi eq, %arg4, %c3_i32 : i32 + %8 = arith.select %7, %cst_0, %cst_1 : f32 + scf.yield %8 : f32 + } + %4 = scf.if %2 -> (i1) { + scf.yield %true : i1 + } else { + %7 = arith.cmpi eq, %arg4, %c1_i32 : i32 + scf.yield %7 : i1 + } + %5 = arith.addi %0, %c-1 : index + %6 = arith.cmpi eq, %5, %c0 : index + affine.for %arg6 = 0 to 16 { + affine.for %arg7 = 0 to 24 { + %7 = affine.load %arg0[%arg6] : memref + %8 = affine.load %arg0[%arg6 + 1] : memref + %9 = arith.index_cast %8 : i32 to index + %10 = arith.index_cast %7 : i32 to index + %11 = scf.for %arg8 = %10 to %9 step %c1 iter_args(%arg9 = %3) -> (f32) { + %15 = memref.load %arg2[%arg8] : memref + %16 = memref.load %arg1[%arg8] : memref + %17 = arith.index_cast %16 : i32 to index + %18 = memref.load %arg3[%17, %arg7] : memref + %19 = arith.mulf %15, %18 : f32 + %20 = scf.if %4 -> (f32) { + %21 = arith.addf %arg9, %19 : f32 + scf.yield %21 : f32 + } else { + %21 = affine.if #set()[%0] -> f32 { + %22 = arith.cmpf ogt, %arg9, %19 : f32 + %23 = arith.select %22, %arg9, %19 : f32 + affine.yield %23 : f32 + } else { + %22 = arith.cmpf olt, %arg9, %19 : f32 + %23 = arith.select %22, %arg9, %19 : f32 + affine.yield %23 : f32 + } + scf.yield %21 : f32 + } + scf.yield %20 : f32 + } + %12 = arith.cmpi sgt, %8, %7 : i32 + %13 = arith.andi %6, %12 : i1 + %14 = scf.if %13 -> (f32) { + %15 = arith.subi %8, %7 : i32 + %16 = arith.sitofp %15 : i32 to f32 + %17 = arith.divf %11, %16 : f32 + scf.yield %17 : f32 + } else { + scf.yield %11 : f32 + } + affine.store %14, %arg5[%arg6, %arg7] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_cpu/debuf.mlir new file mode 100644 index 000000000000..0ca6cc0a2296 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_cpu/debuf.mlir @@ -0,0 +1,75 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<()[s0] -> (s0 - 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %true = arith.constant true + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %c3_i32 = arith.constant 3 : i32 + %cst_1 = arith.constant -3.40282347E+38 : f32 + %c2_i32 = arith.constant 2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %c-1 = arith.constant -1 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = arith.index_cast %arg4 : i32 to index + %6 = arith.cmpi eq, %arg4, %c2_i32 : i32 + %7 = arith.cmpi eq, %arg4, %c0_i32 : i32 + %8 = arith.cmpi eq, %arg4, %c3_i32 : i32 + %9 = arith.select %8, %cst_0, %cst : f32 + %10 = arith.select %6, %cst_1, %9 : f32 + %11 = arith.cmpi eq, %arg4, %c1_i32 : i32 + %12 = arith.select %7, %true, %11 : i1 + %13 = arith.addi %5, %c-1 : index + %14 = arith.cmpi eq, %13, %c0 : index + %15 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %0) -> (tensor) { + %17 = affine.for %arg8 = 0 to 24 iter_args(%arg9 = %arg7) -> (tensor) { + %extracted = tensor.extract %4[%arg6] : tensor + %18 = affine.apply #map(%arg6) + %extracted_2 = tensor.extract %4[%18] : tensor + %19 = arith.index_cast %extracted_2 : i32 to index + %20 = arith.index_cast %extracted : i32 to index + %21 = scf.for %arg10 = %20 to %19 step %c1 iter_args(%arg11 = %10) -> (f32) { + %extracted_3 = tensor.extract %2[%arg10] : tensor + %extracted_4 = tensor.extract %3[%arg10] : tensor + %28 = arith.index_cast %extracted_4 : i32 to index + %extracted_5 = tensor.extract %1[%28, %arg8] : tensor + %29 = arith.mulf %extracted_3, %extracted_5 : f32 + %30 = scf.if %12 -> (f32) { + %31 = arith.addf %arg11, %29 : f32 + scf.yield %31 : f32 + } else { + %31 = affine.apply #map1()[%5] + %32 = arith.cmpi eq, %31, %c0 : index + %33 = arith.cmpf ogt, %arg11, %29 : f32 + %34 = arith.select %33, %arg11, %29 : f32 + %35 = arith.cmpf olt, %arg11, %29 : f32 + %36 = arith.select %35, %arg11, %29 : f32 + %37 = arith.select %32, %34, %36 : f32 + scf.yield %37 : f32 + } + scf.yield %30 : f32 + } + %22 = arith.cmpi sgt, %extracted_2, %extracted : i32 + %23 = arith.andi %14, %22 : i1 + %24 = arith.subi %extracted_2, %extracted : i32 + %25 = arith.sitofp %24 : i32 to f32 + %26 = arith.divf %21, %25 : f32 + %27 = arith.select %23, %26, %21 : f32 + %inserted = tensor.insert %27 into %arg9[%arg6, %arg8] : tensor + affine.yield %inserted : tensor + } + affine.yield %17 : tensor + } + %16 = bufferization.to_memref %15 : memref + memref.copy %16, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_cpu/matched.mlir new file mode 100644 index 000000000000..0ca6cc0a2296 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_cpu/matched.mlir @@ -0,0 +1,75 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<()[s0] -> (s0 - 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %true = arith.constant true + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %c3_i32 = arith.constant 3 : i32 + %cst_1 = arith.constant -3.40282347E+38 : f32 + %c2_i32 = arith.constant 2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %c-1 = arith.constant -1 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = arith.index_cast %arg4 : i32 to index + %6 = arith.cmpi eq, %arg4, %c2_i32 : i32 + %7 = arith.cmpi eq, %arg4, %c0_i32 : i32 + %8 = arith.cmpi eq, %arg4, %c3_i32 : i32 + %9 = arith.select %8, %cst_0, %cst : f32 + %10 = arith.select %6, %cst_1, %9 : f32 + %11 = arith.cmpi eq, %arg4, %c1_i32 : i32 + %12 = arith.select %7, %true, %11 : i1 + %13 = arith.addi %5, %c-1 : index + %14 = arith.cmpi eq, %13, %c0 : index + %15 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %0) -> (tensor) { + %17 = affine.for %arg8 = 0 to 24 iter_args(%arg9 = %arg7) -> (tensor) { + %extracted = tensor.extract %4[%arg6] : tensor + %18 = affine.apply #map(%arg6) + %extracted_2 = tensor.extract %4[%18] : tensor + %19 = arith.index_cast %extracted_2 : i32 to index + %20 = arith.index_cast %extracted : i32 to index + %21 = scf.for %arg10 = %20 to %19 step %c1 iter_args(%arg11 = %10) -> (f32) { + %extracted_3 = tensor.extract %2[%arg10] : tensor + %extracted_4 = tensor.extract %3[%arg10] : tensor + %28 = arith.index_cast %extracted_4 : i32 to index + %extracted_5 = tensor.extract %1[%28, %arg8] : tensor + %29 = arith.mulf %extracted_3, %extracted_5 : f32 + %30 = scf.if %12 -> (f32) { + %31 = arith.addf %arg11, %29 : f32 + scf.yield %31 : f32 + } else { + %31 = affine.apply #map1()[%5] + %32 = arith.cmpi eq, %31, %c0 : index + %33 = arith.cmpf ogt, %arg11, %29 : f32 + %34 = arith.select %33, %arg11, %29 : f32 + %35 = arith.cmpf olt, %arg11, %29 : f32 + %36 = arith.select %35, %arg11, %29 : f32 + %37 = arith.select %32, %34, %36 : f32 + scf.yield %37 : f32 + } + scf.yield %30 : f32 + } + %22 = arith.cmpi sgt, %extracted_2, %extracted : i32 + %23 = arith.andi %14, %22 : i1 + %24 = arith.subi %extracted_2, %extracted : i32 + %25 = arith.sitofp %24 : i32 to f32 + %26 = arith.divf %21, %25 : f32 + %27 = arith.select %23, %26, %21 : f32 + %inserted = tensor.insert %27 into %arg9[%arg6, %arg8] : tensor + affine.yield %inserted : tensor + } + affine.yield %17 : tensor + } + %16 = bufferization.to_memref %15 : memref + memref.copy %16, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_cpu/orig.mlir new file mode 100644 index 000000000000..6b67ac9fb087 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_cpu/orig.mlir @@ -0,0 +1,77 @@ +#set = affine_set<()[s0] : (s0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c0 = arith.constant 0 : index + %c0_i32 = arith.constant 0 : i32 + %c2_i32 = arith.constant 2 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c3_i32 = arith.constant 3 : i32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %true = arith.constant true + %c1 = arith.constant 1 : index + %0 = arith.index_cast %arg4 : i32 to index + %1 = arith.cmpi eq, %arg4, %c2_i32 : i32 + %2 = arith.cmpi eq, %arg4, %c0_i32 : i32 + %3 = scf.if %1 -> (f32) { + scf.yield %cst : f32 + } else { + %7 = arith.cmpi eq, %arg4, %c3_i32 : i32 + %8 = arith.select %7, %cst_0, %cst_1 : f32 + scf.yield %8 : f32 + } + %4 = scf.if %2 -> (i1) { + scf.yield %true : i1 + } else { + %7 = arith.cmpi eq, %arg4, %c1_i32 : i32 + scf.yield %7 : i1 + } + %5 = arith.addi %0, %c-1 : index + %6 = arith.cmpi eq, %5, %c0 : index + affine.for %arg6 = 0 to 16 { + affine.for %arg7 = 0 to 24 { + %7 = affine.load %arg0[%arg6] : memref + %8 = affine.load %arg0[%arg6 + 1] : memref + %9 = arith.index_cast %8 : i32 to index + %10 = arith.index_cast %7 : i32 to index + %11 = scf.for %arg8 = %10 to %9 step %c1 iter_args(%arg9 = %3) -> (f32) { + %15 = memref.load %arg2[%arg8] : memref + %16 = memref.load %arg1[%arg8] : memref + %17 = arith.index_cast %16 : i32 to index + %18 = memref.load %arg3[%17, %arg7] : memref + %19 = arith.mulf %15, %18 : f32 + %20 = scf.if %4 -> (f32) { + %21 = arith.addf %arg9, %19 : f32 + scf.yield %21 : f32 + } else { + %21 = affine.if #set()[%0] -> f32 { + %22 = arith.cmpf ogt, %arg9, %19 : f32 + %23 = arith.select %22, %arg9, %19 : f32 + affine.yield %23 : f32 + } else { + %22 = arith.cmpf olt, %arg9, %19 : f32 + %23 = arith.select %22, %arg9, %19 : f32 + affine.yield %23 : f32 + } + scf.yield %21 : f32 + } + scf.yield %20 : f32 + } + %12 = arith.cmpi sgt, %8, %7 : i32 + %13 = arith.andi %6, %12 : i1 + %14 = scf.if %13 -> (f32) { + %15 = arith.subi %8, %7 : i32 + %16 = arith.sitofp %15 : i32 to f32 + %17 = arith.divf %11, %16 : f32 + scf.yield %17 : f32 + } else { + scf.yield %11 : f32 + } + affine.store %14, %arg5[%arg6, %arg7] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_cpu/raised.mlir new file mode 100644 index 000000000000..723defbb0d0d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_cpu/raised.mlir @@ -0,0 +1,64 @@ +#map = affine_map<()[s0] -> (s0 - 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c0 = arith.constant 0 : index + %c0_i32 = arith.constant 0 : i32 + %c2_i32 = arith.constant 2 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c3_i32 = arith.constant 3 : i32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %true = arith.constant true + %c1 = arith.constant 1 : index + %0 = arith.index_cast %arg4 : i32 to index + %1 = arith.cmpi eq, %arg4, %c2_i32 : i32 + %2 = arith.cmpi eq, %arg4, %c0_i32 : i32 + %3 = arith.cmpi eq, %arg4, %c3_i32 : i32 + %4 = arith.select %3, %cst_0, %cst_1 : f32 + %5 = arith.select %1, %cst, %4 : f32 + %6 = arith.cmpi eq, %arg4, %c1_i32 : i32 + %7 = arith.select %2, %true, %6 : i1 + %8 = arith.addi %0, %c-1 : index + %9 = arith.cmpi eq, %8, %c0 : index + affine.for %arg6 = 0 to 16 { + affine.for %arg7 = 0 to 24 { + %10 = affine.load %arg0[%arg6] : memref + %11 = affine.load %arg0[%arg6 + 1] : memref + %12 = arith.index_cast %11 : i32 to index + %13 = arith.index_cast %10 : i32 to index + %14 = scf.for %arg8 = %13 to %12 step %c1 iter_args(%arg9 = %5) -> (f32) { + %21 = memref.load %arg2[%arg8] : memref + %22 = memref.load %arg1[%arg8] : memref + %23 = arith.index_cast %22 : i32 to index + %24 = memref.load %arg3[%23, %arg7] : memref + %25 = arith.mulf %21, %24 : f32 + %26 = scf.if %7 -> (f32) { + %27 = arith.addf %arg9, %25 : f32 + scf.yield %27 : f32 + } else { + %27 = affine.apply #map()[%0] + %28 = arith.cmpi eq, %27, %c0 : index + %29 = arith.cmpf ogt, %arg9, %25 : f32 + %30 = arith.select %29, %arg9, %25 : f32 + %31 = arith.cmpf olt, %arg9, %25 : f32 + %32 = arith.select %31, %arg9, %25 : f32 + %33 = arith.select %28, %30, %32 : f32 + scf.yield %33 : f32 + } + scf.yield %26 : f32 + } + %15 = arith.cmpi sgt, %11, %10 : i32 + %16 = arith.andi %9, %15 : i1 + %17 = arith.subi %11, %10 : i32 + %18 = arith.sitofp %17 : i32 to f32 + %19 = arith.divf %14, %18 : f32 + %20 = arith.select %16, %19, %14 : f32 + affine.store %20, %arg5[%arg6, %arg7] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_cpu_debuf.mlir new file mode 100644 index 000000000000..0ca6cc0a2296 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_cpu_debuf.mlir @@ -0,0 +1,75 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<()[s0] -> (s0 - 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %true = arith.constant true + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %c3_i32 = arith.constant 3 : i32 + %cst_1 = arith.constant -3.40282347E+38 : f32 + %c2_i32 = arith.constant 2 : i32 + %c0_i32 = arith.constant 0 : i32 + %c0 = arith.constant 0 : index + %c-1 = arith.constant -1 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = arith.index_cast %arg4 : i32 to index + %6 = arith.cmpi eq, %arg4, %c2_i32 : i32 + %7 = arith.cmpi eq, %arg4, %c0_i32 : i32 + %8 = arith.cmpi eq, %arg4, %c3_i32 : i32 + %9 = arith.select %8, %cst_0, %cst : f32 + %10 = arith.select %6, %cst_1, %9 : f32 + %11 = arith.cmpi eq, %arg4, %c1_i32 : i32 + %12 = arith.select %7, %true, %11 : i1 + %13 = arith.addi %5, %c-1 : index + %14 = arith.cmpi eq, %13, %c0 : index + %15 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %0) -> (tensor) { + %17 = affine.for %arg8 = 0 to 24 iter_args(%arg9 = %arg7) -> (tensor) { + %extracted = tensor.extract %4[%arg6] : tensor + %18 = affine.apply #map(%arg6) + %extracted_2 = tensor.extract %4[%18] : tensor + %19 = arith.index_cast %extracted_2 : i32 to index + %20 = arith.index_cast %extracted : i32 to index + %21 = scf.for %arg10 = %20 to %19 step %c1 iter_args(%arg11 = %10) -> (f32) { + %extracted_3 = tensor.extract %2[%arg10] : tensor + %extracted_4 = tensor.extract %3[%arg10] : tensor + %28 = arith.index_cast %extracted_4 : i32 to index + %extracted_5 = tensor.extract %1[%28, %arg8] : tensor + %29 = arith.mulf %extracted_3, %extracted_5 : f32 + %30 = scf.if %12 -> (f32) { + %31 = arith.addf %arg11, %29 : f32 + scf.yield %31 : f32 + } else { + %31 = affine.apply #map1()[%5] + %32 = arith.cmpi eq, %31, %c0 : index + %33 = arith.cmpf ogt, %arg11, %29 : f32 + %34 = arith.select %33, %arg11, %29 : f32 + %35 = arith.cmpf olt, %arg11, %29 : f32 + %36 = arith.select %35, %arg11, %29 : f32 + %37 = arith.select %32, %34, %36 : f32 + scf.yield %37 : f32 + } + scf.yield %30 : f32 + } + %22 = arith.cmpi sgt, %extracted_2, %extracted : i32 + %23 = arith.andi %14, %22 : i1 + %24 = arith.subi %extracted_2, %extracted : i32 + %25 = arith.sitofp %24 : i32 to f32 + %26 = arith.divf %21, %25 : f32 + %27 = arith.select %23, %26, %21 : f32 + %inserted = tensor.insert %27 into %arg9[%arg6, %arg8] : tensor + affine.yield %inserted : tensor + } + affine.yield %17 : tensor + } + %16 = bufferization.to_memref %15 : memref + memref.copy %16, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_spmm_reduce_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_spmm_reduce_cpu_linalg.mlir new file mode 100644 index 000000000000..723defbb0d0d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_spmm_reduce_cpu_linalg.mlir @@ -0,0 +1,64 @@ +#map = affine_map<()[s0] -> (s0 - 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_spmm_reduce_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: i32, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c0 = arith.constant 0 : index + %c0_i32 = arith.constant 0 : i32 + %c2_i32 = arith.constant 2 : i32 + %cst = arith.constant -3.40282347E+38 : f32 + %c3_i32 = arith.constant 3 : i32 + %cst_0 = arith.constant 3.40282347E+38 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %true = arith.constant true + %c1 = arith.constant 1 : index + %0 = arith.index_cast %arg4 : i32 to index + %1 = arith.cmpi eq, %arg4, %c2_i32 : i32 + %2 = arith.cmpi eq, %arg4, %c0_i32 : i32 + %3 = arith.cmpi eq, %arg4, %c3_i32 : i32 + %4 = arith.select %3, %cst_0, %cst_1 : f32 + %5 = arith.select %1, %cst, %4 : f32 + %6 = arith.cmpi eq, %arg4, %c1_i32 : i32 + %7 = arith.select %2, %true, %6 : i1 + %8 = arith.addi %0, %c-1 : index + %9 = arith.cmpi eq, %8, %c0 : index + affine.for %arg6 = 0 to 16 { + affine.for %arg7 = 0 to 24 { + %10 = affine.load %arg0[%arg6] : memref + %11 = affine.load %arg0[%arg6 + 1] : memref + %12 = arith.index_cast %11 : i32 to index + %13 = arith.index_cast %10 : i32 to index + %14 = scf.for %arg8 = %13 to %12 step %c1 iter_args(%arg9 = %5) -> (f32) { + %21 = memref.load %arg2[%arg8] : memref + %22 = memref.load %arg1[%arg8] : memref + %23 = arith.index_cast %22 : i32 to index + %24 = memref.load %arg3[%23, %arg7] : memref + %25 = arith.mulf %21, %24 : f32 + %26 = scf.if %7 -> (f32) { + %27 = arith.addf %arg9, %25 : f32 + scf.yield %27 : f32 + } else { + %27 = affine.apply #map()[%0] + %28 = arith.cmpi eq, %27, %c0 : index + %29 = arith.cmpf ogt, %arg9, %25 : f32 + %30 = arith.select %29, %arg9, %25 : f32 + %31 = arith.cmpf olt, %arg9, %25 : f32 + %32 = arith.select %31, %arg9, %25 : f32 + %33 = arith.select %28, %30, %32 : f32 + scf.yield %33 : f32 + } + scf.yield %26 : f32 + } + %15 = arith.cmpi sgt, %11, %10 : i32 + %16 = arith.andi %9, %15 : i1 + %17 = arith.subi %11, %10 : i32 + %18 = arith.sitofp %17 : i32 to f32 + %19 = arith.divf %14, %18 : f32 + %20 = arith.select %16, %19, %14 : f32 + affine.store %20, %arg5[%arg6, %arg7] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sqrt.mlir b/issues/aten_c_kernels/results/aten_sqrt.mlir new file mode 100644 index 000000000000..1f47c31a45dc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sqrt.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sqrt(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = math.sqrt %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sqrt/debuf.mlir b/issues/aten_c_kernels/results/aten_sqrt/debuf.mlir new file mode 100644 index 000000000000..b10bf94c69d8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sqrt/debuf.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sqrt(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.sqrt %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sqrt/matched.mlir b/issues/aten_c_kernels/results/aten_sqrt/matched.mlir new file mode 100644 index 000000000000..b10bf94c69d8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sqrt/matched.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sqrt(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.sqrt %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sqrt/orig.mlir b/issues/aten_c_kernels/results/aten_sqrt/orig.mlir new file mode 100644 index 000000000000..1f47c31a45dc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sqrt/orig.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sqrt(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = math.sqrt %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sqrt/raised.mlir b/issues/aten_c_kernels/results/aten_sqrt/raised.mlir new file mode 100644 index 000000000000..b57a40cd6cb6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sqrt/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sqrt(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.sqrt %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sqrt_debuf.mlir b/issues/aten_c_kernels/results/aten_sqrt_debuf.mlir new file mode 100644 index 000000000000..b10bf94c69d8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sqrt_debuf.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sqrt(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.sqrt %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sqrt_linalg.mlir b/issues/aten_c_kernels/results/aten_sqrt_linalg.mlir new file mode 100644 index 000000000000..b57a40cd6cb6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sqrt_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sqrt(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.sqrt %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_square.mlir b/issues/aten_c_kernels/results/aten_square.mlir new file mode 100644 index 000000000000..224a6a76202a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_square.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_square(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.mulf %0, %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_square/debuf.mlir b/issues/aten_c_kernels/results/aten_square/debuf.mlir new file mode 100644 index 000000000000..d23dab3e2d5d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_square/debuf.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_square(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_square/matched.mlir b/issues/aten_c_kernels/results/aten_square/matched.mlir new file mode 100644 index 000000000000..d23dab3e2d5d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_square/matched.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_square(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_square/orig.mlir b/issues/aten_c_kernels/results/aten_square/orig.mlir new file mode 100644 index 000000000000..224a6a76202a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_square/orig.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_square(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.mulf %0, %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_square/raised.mlir b/issues/aten_c_kernels/results/aten_square/raised.mlir new file mode 100644 index 000000000000..637b74e0ffa1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_square/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_square(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_square_debuf.mlir b/issues/aten_c_kernels/results/aten_square_debuf.mlir new file mode 100644 index 000000000000..d23dab3e2d5d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_square_debuf.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_square(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.mulf %in, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_square_linalg.mlir b/issues/aten_c_kernels/results/aten_square_linalg.mlir new file mode 100644 index 000000000000..637b74e0ffa1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_square_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_square(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sspaddmm_cpu.mlir b/issues/aten_c_kernels/results/aten_sspaddmm_cpu.mlir new file mode 100644 index 000000000000..4695d5b3ead7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sspaddmm_cpu.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sspaddmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + affine.for %arg6 = 0 to 48 { + affine.store %cst, %arg4[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 0 to 512 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg0[%arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg5] : memref + %3 = affine.load %arg1[%arg5] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg3[%4, %arg6] : memref + %6 = arith.mulf %2, %5 : f32 + %7 = memref.load %arg4[%1, %arg6] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg4[%1, %arg6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sspaddmm_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sspaddmm_cpu/debuf.mlir new file mode 100644 index 000000000000..51a90a95163f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sspaddmm_cpu/debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sspaddmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c64, %c48] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %8 = affine.for %arg7 = 0 to 48 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %9 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg5] : tensor + %extracted_1 = tensor.extract %3[%arg5] : tensor + %10 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %1[%10, %arg7] : tensor + %11 = arith.mulf %extracted_0, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg8[%9, %arg7] : tensor + %12 = arith.addf %extracted_3, %11 : f32 + %inserted = tensor.insert %12 into %arg8[%9, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %8 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sspaddmm_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sspaddmm_cpu/matched.mlir new file mode 100644 index 000000000000..c3bd076d8832 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sspaddmm_cpu/matched.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sspaddmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %5 = kernel.launch @memset_zero_2D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c64, %c48] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %8 = affine.for %arg7 = 0 to 48 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %9 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg5] : tensor + %extracted_1 = tensor.extract %3[%arg5] : tensor + %10 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %1[%10, %arg7] : tensor + %11 = arith.mulf %extracted_0, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg8[%9, %arg7] : tensor + %12 = arith.addf %extracted_3, %11 : f32 + %inserted = tensor.insert %12 into %arg8[%9, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %8 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sspaddmm_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sspaddmm_cpu/orig.mlir new file mode 100644 index 000000000000..4695d5b3ead7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sspaddmm_cpu/orig.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sspaddmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg5 = 0 to 64 { + affine.for %arg6 = 0 to 48 { + affine.store %cst, %arg4[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 0 to 512 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg0[%arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg5] : memref + %3 = affine.load %arg1[%arg5] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg3[%4, %arg6] : memref + %6 = arith.mulf %2, %5 : f32 + %7 = memref.load %arg4[%1, %arg6] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg4[%1, %arg6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sspaddmm_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sspaddmm_cpu/raised.mlir new file mode 100644 index 000000000000..8d2ac27721b3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sspaddmm_cpu/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sspaddmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg4[0, 0] [%c64, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg5 = 0 to 512 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg0[%arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg5] : memref + %3 = affine.load %arg1[%arg5] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg3[%4, %arg6] : memref + %6 = arith.mulf %2, %5 : f32 + %7 = memref.load %arg4[%1, %arg6] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg4[%1, %arg6] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sspaddmm_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sspaddmm_cpu_debuf.mlir new file mode 100644 index 000000000000..51a90a95163f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sspaddmm_cpu_debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sspaddmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c48 = arith.constant 48 : index + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c48] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %0[0, 0] [%c64, %c48] [1, 1] : tensor into tensor + %6 = affine.for %arg5 = 0 to 512 iter_args(%arg6 = %inserted_slice) -> (tensor) { + %8 = affine.for %arg7 = 0 to 48 iter_args(%arg8 = %arg6) -> (tensor) { + %extracted = tensor.extract %4[%arg5] : tensor + %9 = arith.index_cast %extracted : i32 to index + %extracted_0 = tensor.extract %2[%arg5] : tensor + %extracted_1 = tensor.extract %3[%arg5] : tensor + %10 = arith.index_cast %extracted_1 : i32 to index + %extracted_2 = tensor.extract %1[%10, %arg7] : tensor + %11 = arith.mulf %extracted_0, %extracted_2 : f32 + %extracted_3 = tensor.extract %arg8[%9, %arg7] : tensor + %12 = arith.addf %extracted_3, %11 : f32 + %inserted = tensor.insert %12 into %arg8[%9, %arg7] : tensor + affine.yield %inserted : tensor + } + affine.yield %8 : tensor + } + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sspaddmm_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sspaddmm_cpu_linalg.mlir new file mode 100644 index 000000000000..8d2ac27721b3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sspaddmm_cpu_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sspaddmm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c48 = arith.constant 48 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg4[0, 0] [%c64, %c48] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg5 = 0 to 512 { + affine.for %arg6 = 0 to 48 { + %0 = affine.load %arg0[%arg5] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = affine.load %arg2[%arg5] : memref + %3 = affine.load %arg1[%arg5] : memref + %4 = arith.index_cast %3 : i32 to index + %5 = memref.load %arg3[%4, %arg6] : memref + %6 = arith.mulf %2, %5 : f32 + %7 = memref.load %arg4[%1, %arg6] : memref + %8 = arith.addf %7, %6 : f32 + memref.store %8, %arg4[%1, %arg6] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_stack_serial_cpu.mlir b/issues/aten_c_kernels/results/aten_stack_serial_cpu.mlir new file mode 100644 index 000000000000..8713a015fd6b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_stack_serial_cpu.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_stack_serial_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4 { + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 32 { + %0 = affine.load %arg0[%arg2, %arg3, %arg4] : memref + affine.store %0, %arg1[%arg3, %arg2, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_stack_serial_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_stack_serial_cpu/debuf.mlir new file mode 100644 index 000000000000..a1b3f87f3b65 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_stack_serial_cpu/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d0, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_stack_serial_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c4, %c16, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0] [%c16, %c4, %c32] [1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0, 0] [%c16, %c4, %c32] [1, 1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_stack_serial_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_stack_serial_cpu/matched.mlir new file mode 100644 index 000000000000..a1b3f87f3b65 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_stack_serial_cpu/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d0, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_stack_serial_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c4, %c16, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0] [%c16, %c4, %c32] [1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0, 0] [%c16, %c4, %c32] [1, 1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_stack_serial_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_stack_serial_cpu/orig.mlir new file mode 100644 index 000000000000..8713a015fd6b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_stack_serial_cpu/orig.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_stack_serial_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4 { + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 32 { + %0 = affine.load %arg0[%arg2, %arg3, %arg4] : memref + affine.store %0, %arg1[%arg3, %arg2, %arg4] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_stack_serial_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_stack_serial_cpu/raised.mlir new file mode 100644 index 000000000000..c8c1f4327fcf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_stack_serial_cpu/raised.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d0, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_stack_serial_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %subview = memref.subview %arg0[0, 0, 0] [%c4, %c16, %c32] [1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0] [%c16, %c4, %c32] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_stack_serial_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_stack_serial_cpu_debuf.mlir new file mode 100644 index 000000000000..a1b3f87f3b65 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_stack_serial_cpu_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d0, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_stack_serial_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c4, %c16, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0] [%c16, %c4, %c32] [1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0, 0] [%c16, %c4, %c32] [1, 1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_stack_serial_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_stack_serial_cpu_linalg.mlir new file mode 100644 index 000000000000..c8c1f4327fcf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_stack_serial_cpu_linalg.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d0, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_stack_serial_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %c32 = arith.constant 32 : index + %subview = memref.subview %arg0[0, 0, 0] [%c4, %c16, %c32] [1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0] [%c16, %c4, %c32] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu.mlir b/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu.mlir new file mode 100644 index 000000000000..e7198899890b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_standard_gamma_grad_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-03 : f32 + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg1[%arg3] : memref + %1 = affine.load %arg0[%arg3] : memref + %2 = arith.subf %0, %1 : f32 + %3 = arith.addf %1, %cst : f32 + %4 = arith.divf %2, %3 : f32 + %5 = arith.addf %0, %cst : f32 + %6 = func.call @logf(%5) : (f32) -> f32 + %7 = arith.addf %4, %6 : f32 + affine.store %7, %arg2[%arg3] : memref + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu/debuf.mlir new file mode 100644 index 000000000000..779e26dda5bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_standard_gamma_grad_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-03 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in, %in_0 : f32 + %6 = arith.addf %in_0, %cst : f32 + %7 = arith.divf %5, %6 : f32 + %8 = arith.addf %in, %cst : f32 + %9 = math.log %8 : f32 + %10 = arith.addf %7, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu/matched.mlir new file mode 100644 index 000000000000..779e26dda5bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_standard_gamma_grad_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-03 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in, %in_0 : f32 + %6 = arith.addf %in_0, %cst : f32 + %7 = arith.divf %5, %6 : f32 + %8 = arith.addf %in, %cst : f32 + %9 = math.log %8 : f32 + %10 = arith.addf %7, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu/orig.mlir new file mode 100644 index 000000000000..e7198899890b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu/orig.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_standard_gamma_grad_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-03 : f32 + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg1[%arg3] : memref + %1 = affine.load %arg0[%arg3] : memref + %2 = arith.subf %0, %1 : f32 + %3 = arith.addf %1, %cst : f32 + %4 = arith.divf %2, %3 : f32 + %5 = arith.addf %0, %cst : f32 + %6 = func.call @logf(%5) : (f32) -> f32 + %7 = arith.addf %4, %6 : f32 + affine.store %7, %arg2[%arg3] : memref + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu/raised.mlir new file mode 100644 index 000000000000..0847dfacaa5a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu/raised.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_standard_gamma_grad_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-03 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.subf %in, %in_0 : f32 + %1 = arith.addf %in_0, %cst : f32 + %2 = arith.divf %0, %1 : f32 + %3 = arith.addf %in, %cst : f32 + %4 = math.log %3 : f32 + %5 = arith.addf %2, %4 : f32 + linalg.yield %5 : f32 + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu_debuf.mlir new file mode 100644 index 000000000000..779e26dda5bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_standard_gamma_grad_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-03 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.subf %in, %in_0 : f32 + %6 = arith.addf %in_0, %cst : f32 + %7 = arith.divf %5, %6 : f32 + %8 = arith.addf %in, %cst : f32 + %9 = math.log %8 : f32 + %10 = arith.addf %7, %9 : f32 + linalg.yield %10 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu_linalg.mlir new file mode 100644 index 000000000000..0847dfacaa5a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_standard_gamma_grad_cpu_linalg.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_standard_gamma_grad_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-03 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.subf %in, %in_0 : f32 + %1 = arith.addf %in_0, %cst : f32 + %2 = arith.divf %0, %1 : f32 + %3 = arith.addf %in, %cst : f32 + %4 = math.log %3 : f32 + %5 = arith.addf %2, %4 : f32 + linalg.yield %5 : f32 + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_std_var_all_cpu.mlir b/issues/aten_c_kernels/results/aten_std_var_all_cpu.mlir new file mode 100644 index 000000000000..24087a30ea15 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_std_var_all_cpu.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_std_var_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.023000e+03 : f32 + %cst_0 = arith.constant 1.024000e+03 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg2 = 0 to 1024 iter_args(%arg3 = %cst_1) -> (f32) { + %4 = affine.load %arg0[%arg2] : memref + %5 = arith.addf %arg3, %4 : f32 + affine.yield %5 : f32 + } + %1 = arith.divf %0, %cst_0 : f32 + %2 = affine.for %arg2 = 0 to 1024 iter_args(%arg3 = %cst_1) -> (f32) { + %4 = affine.load %arg0[%arg2] : memref + %5 = arith.subf %4, %1 : f32 + %6 = arith.mulf %5, %5 : f32 + %7 = arith.addf %arg3, %6 : f32 + affine.yield %7 : f32 + } + %3 = arith.divf %2, %cst : f32 + affine.store %3, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_std_var_all_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_std_var_all_cpu/debuf.mlir new file mode 100644 index 000000000000..f1683b02e5b6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_std_var_all_cpu/debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_std_var_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.024000e+03 : f32 + %cst_1 = arith.constant 1.023000e+03 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %2[] : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %9 = arith.addf %out, %in : f32 + linalg.yield %9 : f32 + } -> tensor + %extracted = tensor.extract %3[] : tensor + %4 = arith.divf %extracted, %cst_0 : f32 + %5 = tensor.empty() : tensor + %inserted_2 = tensor.insert %cst into %5[] : tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted_2 : tensor) { + ^bb0(%in: f32, %out: f32): + %9 = arith.subf %in, %4 : f32 + %10 = arith.mulf %9, %9 : f32 + %11 = arith.addf %out, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %extracted_3 = tensor.extract %6[] : tensor + %7 = arith.divf %extracted_3, %cst_1 : f32 + %inserted_4 = tensor.insert %7 into %1[%c0] : tensor + %8 = bufferization.to_memref %inserted_4 : memref + memref.copy %8, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_std_var_all_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_std_var_all_cpu/matched.mlir new file mode 100644 index 000000000000..f1683b02e5b6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_std_var_all_cpu/matched.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_std_var_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.024000e+03 : f32 + %cst_1 = arith.constant 1.023000e+03 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %2[] : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %9 = arith.addf %out, %in : f32 + linalg.yield %9 : f32 + } -> tensor + %extracted = tensor.extract %3[] : tensor + %4 = arith.divf %extracted, %cst_0 : f32 + %5 = tensor.empty() : tensor + %inserted_2 = tensor.insert %cst into %5[] : tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted_2 : tensor) { + ^bb0(%in: f32, %out: f32): + %9 = arith.subf %in, %4 : f32 + %10 = arith.mulf %9, %9 : f32 + %11 = arith.addf %out, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %extracted_3 = tensor.extract %6[] : tensor + %7 = arith.divf %extracted_3, %cst_1 : f32 + %inserted_4 = tensor.insert %7 into %1[%c0] : tensor + %8 = bufferization.to_memref %inserted_4 : memref + memref.copy %8, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_std_var_all_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_std_var_all_cpu/orig.mlir new file mode 100644 index 000000000000..24087a30ea15 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_std_var_all_cpu/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_std_var_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.023000e+03 : f32 + %cst_0 = arith.constant 1.024000e+03 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg2 = 0 to 1024 iter_args(%arg3 = %cst_1) -> (f32) { + %4 = affine.load %arg0[%arg2] : memref + %5 = arith.addf %arg3, %4 : f32 + affine.yield %5 : f32 + } + %1 = arith.divf %0, %cst_0 : f32 + %2 = affine.for %arg2 = 0 to 1024 iter_args(%arg3 = %cst_1) -> (f32) { + %4 = affine.load %arg0[%arg2] : memref + %5 = arith.subf %4, %1 : f32 + %6 = arith.mulf %5, %5 : f32 + %7 = arith.addf %arg3, %6 : f32 + affine.yield %7 : f32 + } + %3 = arith.divf %2, %cst : f32 + affine.store %3, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_std_var_all_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_std_var_all_cpu/raised.mlir new file mode 100644 index 000000000000..a10acab0a287 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_std_var_all_cpu/raised.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_std_var_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.023000e+03 : f32 + %cst_0 = arith.constant 1.024000e+03 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_1, %alloca[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst_0 : f32 + %alloca_2 = memref.alloca() : memref + affine.store %cst_1, %alloca_2[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca_2 : memref) { + ^bb0(%in: f32, %out: f32): + %4 = arith.subf %in, %1 : f32 + %5 = arith.mulf %4, %4 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } + %2 = affine.load %alloca_2[] : memref + %3 = arith.divf %2, %cst : f32 + affine.store %3, %arg1[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_std_var_all_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_std_var_all_cpu_debuf.mlir new file mode 100644 index 000000000000..f1683b02e5b6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_std_var_all_cpu_debuf.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_std_var_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.024000e+03 : f32 + %cst_1 = arith.constant 1.023000e+03 : f32 + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %cst into %2[] : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %9 = arith.addf %out, %in : f32 + linalg.yield %9 : f32 + } -> tensor + %extracted = tensor.extract %3[] : tensor + %4 = arith.divf %extracted, %cst_0 : f32 + %5 = tensor.empty() : tensor + %inserted_2 = tensor.insert %cst into %5[] : tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%0 : tensor) outs(%inserted_2 : tensor) { + ^bb0(%in: f32, %out: f32): + %9 = arith.subf %in, %4 : f32 + %10 = arith.mulf %9, %9 : f32 + %11 = arith.addf %out, %10 : f32 + linalg.yield %11 : f32 + } -> tensor + %extracted_3 = tensor.extract %6[] : tensor + %7 = arith.divf %extracted_3, %cst_1 : f32 + %inserted_4 = tensor.insert %7 into %1[%c0] : tensor + %8 = bufferization.to_memref %inserted_4 : memref + memref.copy %8, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_std_var_all_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_std_var_all_cpu_linalg.mlir new file mode 100644 index 000000000000..a10acab0a287 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_std_var_all_cpu_linalg.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_std_var_all_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.023000e+03 : f32 + %cst_0 = arith.constant 1.024000e+03 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_1, %alloca[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = arith.divf %0, %cst_0 : f32 + %alloca_2 = memref.alloca() : memref + affine.store %cst_1, %alloca_2[] : memref + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%arg0 : memref) outs(%alloca_2 : memref) { + ^bb0(%in: f32, %out: f32): + %4 = arith.subf %in, %1 : f32 + %5 = arith.mulf %4, %4 : f32 + %6 = arith.addf %out, %5 : f32 + linalg.yield %6 : f32 + } + %2 = affine.load %alloca_2[] : memref + %3 = arith.divf %2, %cst : f32 + affine.store %3, %arg1[0] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_std_var_cpu.mlir b/issues/aten_c_kernels/results/aten_std_var_cpu.mlir new file mode 100644 index 000000000000..a270285d1033 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_std_var_cpu.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_std_var_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 6.400000e+01 : f32 + %c64_i32 = arith.constant 64 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %0 = arith.subi %c64_i32, %arg1 : i32 + %1 = arith.sitofp %0 : i32 to f32 + affine.for %arg3 = 0 to 32 { + %2 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst_0) -> (f32) { + %7 = affine.load %arg0[%arg3, %arg4] : memref + %8 = arith.addf %arg5, %7 : f32 + affine.yield %8 : f32 + } + %3 = arith.divf %2, %cst : f32 + %4 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst_0) -> (f32) { + %7 = affine.load %arg0[%arg3, %arg4] : memref + %8 = arith.subf %7, %3 : f32 + %9 = arith.mulf %8, %8 : f32 + %10 = arith.addf %arg5, %9 : f32 + affine.yield %10 : f32 + } + %5 = arith.divf %4, %1 : f32 + %6 = math.sqrt %5 : f32 + affine.store %6, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_std_var_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_std_var_cpu/debuf.mlir new file mode 100644 index 000000000000..a9eae3edbd18 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_std_var_cpu/debuf.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_std_var_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64_i32 = arith.constant 64 : i32 + %cst_0 = arith.constant 6.400000e+01 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = arith.subi %c64_i32, %arg1 : i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %0) -> (tensor) { + %alloca = memref.alloca() : memref + %6 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %6[] : tensor + %extracted_slice = tensor.extract_slice %1[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %13 = arith.addf %out, %in : f32 + linalg.yield %13 : f32 + } -> tensor + %extracted = tensor.extract %7[] : tensor + %8 = arith.divf %extracted, %cst_0 : f32 + %alloca_1 = memref.alloca() : memref + %9 = bufferization.to_tensor %alloca_1 : memref + %inserted_2 = tensor.insert %cst into %9[] : tensor + %extracted_slice_3 = tensor.extract_slice %1[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%inserted_2 : tensor) { + ^bb0(%in: f32, %out: f32): + %13 = arith.subf %in, %8 : f32 + %14 = arith.mulf %13, %13 : f32 + %15 = arith.addf %out, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %extracted_4 = tensor.extract %10[] : tensor + %11 = arith.divf %extracted_4, %3 : f32 + %12 = math.sqrt %11 : f32 + %inserted_5 = tensor.insert %12 into %arg4[%arg3] : tensor + affine.yield %inserted_5 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_std_var_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_std_var_cpu/matched.mlir new file mode 100644 index 000000000000..a9eae3edbd18 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_std_var_cpu/matched.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_std_var_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64_i32 = arith.constant 64 : i32 + %cst_0 = arith.constant 6.400000e+01 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = arith.subi %c64_i32, %arg1 : i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %0) -> (tensor) { + %alloca = memref.alloca() : memref + %6 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %6[] : tensor + %extracted_slice = tensor.extract_slice %1[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %13 = arith.addf %out, %in : f32 + linalg.yield %13 : f32 + } -> tensor + %extracted = tensor.extract %7[] : tensor + %8 = arith.divf %extracted, %cst_0 : f32 + %alloca_1 = memref.alloca() : memref + %9 = bufferization.to_tensor %alloca_1 : memref + %inserted_2 = tensor.insert %cst into %9[] : tensor + %extracted_slice_3 = tensor.extract_slice %1[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%inserted_2 : tensor) { + ^bb0(%in: f32, %out: f32): + %13 = arith.subf %in, %8 : f32 + %14 = arith.mulf %13, %13 : f32 + %15 = arith.addf %out, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %extracted_4 = tensor.extract %10[] : tensor + %11 = arith.divf %extracted_4, %3 : f32 + %12 = math.sqrt %11 : f32 + %inserted_5 = tensor.insert %12 into %arg4[%arg3] : tensor + affine.yield %inserted_5 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_std_var_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_std_var_cpu/orig.mlir new file mode 100644 index 000000000000..a270285d1033 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_std_var_cpu/orig.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_std_var_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 6.400000e+01 : f32 + %c64_i32 = arith.constant 64 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %0 = arith.subi %c64_i32, %arg1 : i32 + %1 = arith.sitofp %0 : i32 to f32 + affine.for %arg3 = 0 to 32 { + %2 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst_0) -> (f32) { + %7 = affine.load %arg0[%arg3, %arg4] : memref + %8 = arith.addf %arg5, %7 : f32 + affine.yield %8 : f32 + } + %3 = arith.divf %2, %cst : f32 + %4 = affine.for %arg4 = 0 to 64 iter_args(%arg5 = %cst_0) -> (f32) { + %7 = affine.load %arg0[%arg3, %arg4] : memref + %8 = arith.subf %7, %3 : f32 + %9 = arith.mulf %8, %8 : f32 + %10 = arith.addf %arg5, %9 : f32 + affine.yield %10 : f32 + } + %5 = arith.divf %4, %1 : f32 + %6 = math.sqrt %5 : f32 + affine.store %6, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_std_var_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_std_var_cpu/raised.mlir new file mode 100644 index 000000000000..eecf30a21dd2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_std_var_cpu/raised.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_std_var_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %cst = arith.constant 6.400000e+01 : f32 + %c64_i32 = arith.constant 64 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %0 = arith.subi %c64_i32, %arg1 : i32 + %1 = arith.sitofp %0 : i32 to f32 + affine.for %arg3 = 0 to 32 { + %alloca = memref.alloca() : memref + affine.store %cst_0, %alloca[] : memref + %subview = memref.subview %arg0[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %7 = arith.addf %out, %in : f32 + linalg.yield %7 : f32 + } + %2 = affine.load %alloca[] : memref + %3 = arith.divf %2, %cst : f32 + %alloca_1 = memref.alloca() : memref + affine.store %cst_0, %alloca_1[] : memref + %subview_2 = memref.subview %arg0[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview_2 : memref>) outs(%alloca_1 : memref) { + ^bb0(%in: f32, %out: f32): + %7 = arith.subf %in, %3 : f32 + %8 = arith.mulf %7, %7 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } + %4 = affine.load %alloca_1[] : memref + %5 = arith.divf %4, %1 : f32 + %6 = math.sqrt %5 : f32 + affine.store %6, %arg2[%arg3] : memref + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_std_var_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_std_var_cpu_debuf.mlir new file mode 100644 index 000000000000..a9eae3edbd18 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_std_var_cpu_debuf.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_std_var_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64_i32 = arith.constant 64 : i32 + %cst_0 = arith.constant 6.400000e+01 : f32 + %c64 = arith.constant 64 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = arith.subi %c64_i32, %arg1 : i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = affine.for %arg3 = 0 to 32 iter_args(%arg4 = %0) -> (tensor) { + %alloca = memref.alloca() : memref + %6 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %6[] : tensor + %extracted_slice = tensor.extract_slice %1[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %13 = arith.addf %out, %in : f32 + linalg.yield %13 : f32 + } -> tensor + %extracted = tensor.extract %7[] : tensor + %8 = arith.divf %extracted, %cst_0 : f32 + %alloca_1 = memref.alloca() : memref + %9 = bufferization.to_tensor %alloca_1 : memref + %inserted_2 = tensor.insert %cst into %9[] : tensor + %extracted_slice_3 = tensor.extract_slice %1[%arg3, 0] [1, %c64] [1, 1] : tensor to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%inserted_2 : tensor) { + ^bb0(%in: f32, %out: f32): + %13 = arith.subf %in, %8 : f32 + %14 = arith.mulf %13, %13 : f32 + %15 = arith.addf %out, %14 : f32 + linalg.yield %15 : f32 + } -> tensor + %extracted_4 = tensor.extract %10[] : tensor + %11 = arith.divf %extracted_4, %3 : f32 + %12 = math.sqrt %11 : f32 + %inserted_5 = tensor.insert %12 into %arg4[%arg3] : tensor + affine.yield %inserted_5 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_std_var_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_std_var_cpu_linalg.mlir new file mode 100644 index 000000000000..eecf30a21dd2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_std_var_cpu_linalg.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_std_var_cpu(%arg0: memref, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %cst = arith.constant 6.400000e+01 : f32 + %c64_i32 = arith.constant 64 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %0 = arith.subi %c64_i32, %arg1 : i32 + %1 = arith.sitofp %0 : i32 to f32 + affine.for %arg3 = 0 to 32 { + %alloca = memref.alloca() : memref + affine.store %cst_0, %alloca[] : memref + %subview = memref.subview %arg0[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %7 = arith.addf %out, %in : f32 + linalg.yield %7 : f32 + } + %2 = affine.load %alloca[] : memref + %3 = arith.divf %2, %cst : f32 + %alloca_1 = memref.alloca() : memref + affine.store %cst_0, %alloca_1[] : memref + %subview_2 = memref.subview %arg0[%arg3, 0] [1, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview_2 : memref>) outs(%alloca_1 : memref) { + ^bb0(%in: f32, %out: f32): + %7 = arith.subf %in, %3 : f32 + %8 = arith.mulf %7, %7 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } + %4 = affine.load %alloca_1[] : memref + %5 = arith.divf %4, %1 : f32 + %6 = math.sqrt %5 : f32 + affine.store %6, %arg2[%arg3] : memref + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sum.mlir b/issues/aten_c_kernels/results/aten_sum.mlir new file mode 100644 index 000000000000..9f9863055a23 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sum.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sum(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + affine.for %arg2 = 0 to 16 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 16 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + %1 = affine.load %arg1[%arg2] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg1[%arg2] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sum/debuf.mlir b/issues/aten_c_kernels/results/aten_sum/debuf.mlir new file mode 100644 index 000000000000..7015158e1104 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sum/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sum(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c16] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f64, %out: f64): + %5 = arith.addf %out, %in : f64 + linalg.yield %5 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c16] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sum/matched.mlir b/issues/aten_c_kernels/results/aten_sum/matched.mlir new file mode 100644 index 000000000000..f2b224c15690 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sum/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sum(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = kernel.launch @memset_zero_1D(%1) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c16] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f64, %out: f64): + %5 = arith.addf %out, %in : f64 + linalg.yield %5 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c16] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sum/orig.mlir b/issues/aten_c_kernels/results/aten_sum/orig.mlir new file mode 100644 index 000000000000..9f9863055a23 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sum/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sum(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + affine.for %arg2 = 0 to 16 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 16 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + %1 = affine.load %arg1[%arg2] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg1[%arg2] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sum/raised.mlir b/issues/aten_c_kernels/results/aten_sum/raised.mlir new file mode 100644 index 000000000000..a67b855d1aa1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sum/raised.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sum(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f64 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f64, %out: f64): + %0 = arith.addf %out, %in : f64 + linalg.yield %0 : f64 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sum_cpu_backend.mlir b/issues/aten_c_kernels/results/aten_sum_cpu_backend.mlir new file mode 100644 index 000000000000..14377d3e6a3f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sum_cpu_backend.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sum_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 16 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2, %arg3] : memref + %2 = arith.addf %arg4, %1 : f32 + affine.yield %2 : f32 + } + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sum_cpu_backend/debuf.mlir b/issues/aten_c_kernels/results/aten_sum_cpu_backend/debuf.mlir new file mode 100644 index 000000000000..5525c44f86d5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sum_cpu_backend/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sum_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c16] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.addf %out, %in : f32 + linalg.yield %5 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c16] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sum_cpu_backend/matched.mlir b/issues/aten_c_kernels/results/aten_sum_cpu_backend/matched.mlir new file mode 100644 index 000000000000..32d85d77195d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sum_cpu_backend/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sum_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = kernel.launch @memset_zero_1D_f32(%1) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c16] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.addf %out, %in : f32 + linalg.yield %5 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c16] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sum_cpu_backend/orig.mlir b/issues/aten_c_kernels/results/aten_sum_cpu_backend/orig.mlir new file mode 100644 index 000000000000..14377d3e6a3f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sum_cpu_backend/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sum_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 16 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2, %arg3] : memref + %2 = arith.addf %arg4, %1 : f32 + affine.yield %2 : f32 + } + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sum_cpu_backend/raised.mlir b/issues/aten_c_kernels/results/aten_sum_cpu_backend/raised.mlir new file mode 100644 index 000000000000..1ffab6412156 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sum_cpu_backend/raised.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sum_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.addf %out, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sum_cpu_backend_debuf.mlir b/issues/aten_c_kernels/results/aten_sum_cpu_backend_debuf.mlir new file mode 100644 index 000000000000..5525c44f86d5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sum_cpu_backend_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sum_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c16] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.addf %out, %in : f32 + linalg.yield %5 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c16] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sum_cpu_backend_linalg.mlir b/issues/aten_c_kernels/results/aten_sum_cpu_backend_linalg.mlir new file mode 100644 index 000000000000..1ffab6412156 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sum_cpu_backend_linalg.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sum_cpu_backend(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.addf %out, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sum_debuf.mlir b/issues/aten_c_kernels/results/aten_sum_debuf.mlir new file mode 100644 index 000000000000..7015158e1104 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sum_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sum(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c64 = arith.constant 64 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c16, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c16] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f64, %out: f64): + %5 = arith.addf %out, %in : f64 + linalg.yield %5 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c16] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sum_linalg.mlir b/issues/aten_c_kernels/results/aten_sum_linalg.mlir new file mode 100644 index 000000000000..a67b855d1aa1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sum_linalg.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sum(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f64 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c16] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f64, %out: f64): + %0 = arith.addf %out, %in : f64 + linalg.yield %0 : f64 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu.mlir b/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu.mlir new file mode 100644 index 000000000000..ab25538d1ae0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sumproduct_pair_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 24 { + %0 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4, %arg6] : memref + %2 = affine.load %arg1[%arg3, %arg6, %arg5] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg7, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu/debuf.mlir new file mode 100644 index 000000000000..d729bdccbf55 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu/debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sumproduct_pair_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c8, %c16, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c8, %c32, %c24] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu/matched.mlir new file mode 100644 index 000000000000..d729bdccbf55 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu/matched.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sumproduct_pair_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c8, %c16, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c8, %c32, %c24] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu/orig.mlir new file mode 100644 index 000000000000..ab25538d1ae0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sumproduct_pair_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 16 { + affine.for %arg5 = 0 to 24 { + %0 = affine.for %arg6 = 0 to 32 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg3, %arg4, %arg6] : memref + %2 = affine.load %arg1[%arg3, %arg6, %arg5] : memref + %3 = arith.mulf %1, %2 : f32 + %4 = arith.addf %arg7, %3 : f32 + affine.yield %4 : f32 + } + affine.store %0, %arg2[%arg3, %arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu/raised.mlir new file mode 100644 index 000000000000..0a79b6e91fba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sumproduct_pair_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c8, %c16, %c32] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0] [%c8, %c32, %c24] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu_debuf.mlir new file mode 100644 index 000000000000..d729bdccbf55 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu_debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sumproduct_pair_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %c16 = arith.constant 16 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %extracted_slice = tensor.extract_slice %2[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0] [%c8, %c16, %c32] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c8, %c32, %c24] [1, 1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1 : tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %in_2: f32, %out: f32): + %6 = arith.mulf %in, %in_2 : f32 + %7 = arith.addf %out, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %2[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu_linalg.mlir new file mode 100644 index 000000000000..0a79b6e91fba --- /dev/null +++ b/issues/aten_c_kernels/results/aten_sumproduct_pair_cpu_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_sumproduct_pair_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg2[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0] [%c8, %c16, %c32] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0] [%c8, %c32, %c24] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0, 0] [%c8, %c16, %c24] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_0, %subview_1 : memref>, memref>) outs(%subview_2 : memref>) { + ^bb0(%in: f32, %in_3: f32, %out: f32): + %0 = arith.mulf %in, %in_3 : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_take_cpu.mlir b/issues/aten_c_kernels/results/aten_take_cpu.mlir new file mode 100644 index 000000000000..fe880f34e2e4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_take_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_take_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1] : memref + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_take_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_take_cpu/debuf.mlir new file mode 100644 index 000000000000..3c3df502ad2d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_take_cpu/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_take_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%5] : memref + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_take_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_take_cpu/matched.mlir new file mode 100644 index 000000000000..3c3df502ad2d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_take_cpu/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_take_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%5] : memref + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_take_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_take_cpu/orig.mlir new file mode 100644 index 000000000000..fe880f34e2e4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_take_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_take_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 32 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1] : memref + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_take_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_take_cpu/raised.mlir new file mode 100644 index 000000000000..ba4e75bb9436 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_take_cpu/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_take_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg1[%0] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%2] : memref + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_take_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_take_cpu_debuf.mlir new file mode 100644 index 000000000000..3c3df502ad2d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_take_cpu_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_take_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%5] : memref + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_take_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_take_cpu_linalg.mlir new file mode 100644 index 000000000000..ba4e75bb9436 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_take_cpu_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_take_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg1[%0] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%2] : memref + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_tan.mlir b/issues/aten_c_kernels/results/aten_tan.mlir new file mode 100644 index 000000000000..4f23c27485f1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tan.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tan(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @tanf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @tanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_tan/debuf.mlir b/issues/aten_c_kernels/results/aten_tan/debuf.mlir new file mode 100644 index 000000000000..219104b2ff5c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tan/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tan(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.tan %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @tanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_tan/matched.mlir b/issues/aten_c_kernels/results/aten_tan/matched.mlir new file mode 100644 index 000000000000..219104b2ff5c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tan/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tan(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.tan %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @tanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_tan/orig.mlir b/issues/aten_c_kernels/results/aten_tan/orig.mlir new file mode 100644 index 000000000000..4f23c27485f1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tan/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tan(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @tanf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @tanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_tan/raised.mlir b/issues/aten_c_kernels/results/aten_tan/raised.mlir new file mode 100644 index 000000000000..7e1c6c515b21 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tan/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tan(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.tan %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @tanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_tan_debuf.mlir b/issues/aten_c_kernels/results/aten_tan_debuf.mlir new file mode 100644 index 000000000000..219104b2ff5c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tan_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tan(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.tan %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @tanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_tan_linalg.mlir b/issues/aten_c_kernels/results/aten_tan_linalg.mlir new file mode 100644 index 000000000000..7e1c6c515b21 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tan_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tan(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.tan %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @tanf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_tanh.mlir b/issues/aten_c_kernels/results/aten_tanh.mlir new file mode 100644 index 000000000000..1484a6fa2636 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tanh.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = math.tanh %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_tanh/debuf.mlir b/issues/aten_c_kernels/results/aten_tanh/debuf.mlir new file mode 100644 index 000000000000..a4b6a1ef371f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tanh/debuf.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.tanh %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_tanh/matched.mlir b/issues/aten_c_kernels/results/aten_tanh/matched.mlir new file mode 100644 index 000000000000..a4b6a1ef371f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tanh/matched.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.tanh %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_tanh/orig.mlir b/issues/aten_c_kernels/results/aten_tanh/orig.mlir new file mode 100644 index 000000000000..1484a6fa2636 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tanh/orig.mlir @@ -0,0 +1,10 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 256 { + %0 = affine.load %arg0[%arg2] : memref + %1 = math.tanh %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_tanh/raised.mlir b/issues/aten_c_kernels/results/aten_tanh/raised.mlir new file mode 100644 index 000000000000..6babe32e3d4f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tanh/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.tanh %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_tanh_backward.mlir b/issues/aten_c_kernels/results/aten_tanh_backward.mlir new file mode 100644 index 000000000000..95bdaf18621e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tanh_backward.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tanh_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.mulf %1, %1 : f32 + %3 = arith.subf %cst, %2 : f32 + %4 = arith.mulf %0, %3 : f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_tanh_backward/debuf.mlir b/issues/aten_c_kernels/results/aten_tanh_backward/debuf.mlir new file mode 100644 index 000000000000..aef1bc9485af --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tanh_backward/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tanh_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in_0, %in_0 : f32 + %6 = arith.subf %cst, %5 : f32 + %7 = arith.mulf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_tanh_backward/matched.mlir b/issues/aten_c_kernels/results/aten_tanh_backward/matched.mlir new file mode 100644 index 000000000000..aef1bc9485af --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tanh_backward/matched.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tanh_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in_0, %in_0 : f32 + %6 = arith.subf %cst, %5 : f32 + %7 = arith.mulf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_tanh_backward/orig.mlir b/issues/aten_c_kernels/results/aten_tanh_backward/orig.mlir new file mode 100644 index 000000000000..95bdaf18621e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tanh_backward/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tanh_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = arith.mulf %1, %1 : f32 + %3 = arith.subf %cst, %2 : f32 + %4 = arith.mulf %0, %3 : f32 + affine.store %4, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_tanh_backward/raised.mlir b/issues/aten_c_kernels/results/aten_tanh_backward/raised.mlir new file mode 100644 index 000000000000..52f189522b37 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tanh_backward/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tanh_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %in_0, %in_0 : f32 + %1 = arith.subf %cst, %0 : f32 + %2 = arith.mulf %in, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_tanh_backward_debuf.mlir b/issues/aten_c_kernels/results/aten_tanh_backward_debuf.mlir new file mode 100644 index 000000000000..aef1bc9485af --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tanh_backward_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tanh_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.mulf %in_0, %in_0 : f32 + %6 = arith.subf %cst, %5 : f32 + %7 = arith.mulf %in, %6 : f32 + linalg.yield %7 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_tanh_backward_linalg.mlir b/issues/aten_c_kernels/results/aten_tanh_backward_linalg.mlir new file mode 100644 index 000000000000..52f189522b37 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tanh_backward_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tanh_backward(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.mulf %in_0, %in_0 : f32 + %1 = arith.subf %cst, %0 : f32 + %2 = arith.mulf %in, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_tanh_debuf.mlir b/issues/aten_c_kernels/results/aten_tanh_debuf.mlir new file mode 100644 index 000000000000..a4b6a1ef371f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tanh_debuf.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.tanh %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_tanh_linalg.mlir b/issues/aten_c_kernels/results/aten_tanh_linalg.mlir new file mode 100644 index 000000000000..6babe32e3d4f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tanh_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tanh(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.tanh %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_threshold_backward.mlir b/issues/aten_c_kernels/results/aten_threshold_backward.mlir new file mode 100644 index 000000000000..b81231d8ddaa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_threshold_backward.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_threshold_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg1[%arg4] : memref + %1 = arith.cmpf ole, %0, %arg2 : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %cst : f32 + } else { + %3 = affine.load %arg0[%arg4] : memref + scf.yield %3 : f32 + } + affine.store %2, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_threshold_backward/debuf.mlir b/issues/aten_c_kernels/results/aten_threshold_backward/debuf.mlir new file mode 100644 index 000000000000..fb902fcdfe3f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_threshold_backward/debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_threshold_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf ole, %in, %arg2 : f32 + %6 = arith.select %5, %cst, %in_0 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_threshold_backward/matched.mlir b/issues/aten_c_kernels/results/aten_threshold_backward/matched.mlir new file mode 100644 index 000000000000..fb902fcdfe3f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_threshold_backward/matched.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_threshold_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf ole, %in, %arg2 : f32 + %6 = arith.select %5, %cst, %in_0 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_threshold_backward/orig.mlir b/issues/aten_c_kernels/results/aten_threshold_backward/orig.mlir new file mode 100644 index 000000000000..b81231d8ddaa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_threshold_backward/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_threshold_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg1[%arg4] : memref + %1 = arith.cmpf ole, %0, %arg2 : f32 + %2 = scf.if %1 -> (f32) { + scf.yield %cst : f32 + } else { + %3 = affine.load %arg0[%arg4] : memref + scf.yield %3 : f32 + } + affine.store %2, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_threshold_backward/raised.mlir b/issues/aten_c_kernels/results/aten_threshold_backward/raised.mlir new file mode 100644 index 000000000000..1fbd38814ed7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_threshold_backward/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_threshold_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf ole, %in, %arg2 : f32 + %1 = arith.select %0, %cst, %in_0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_threshold_backward_debuf.mlir b/issues/aten_c_kernels/results/aten_threshold_backward_debuf.mlir new file mode 100644 index 000000000000..fb902fcdfe3f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_threshold_backward_debuf.mlir @@ -0,0 +1,19 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_threshold_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%1, %0 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = arith.cmpf ole, %in, %arg2 : f32 + %6 = arith.select %5, %cst, %in_0 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_threshold_backward_linalg.mlir b/issues/aten_c_kernels/results/aten_threshold_backward_linalg.mlir new file mode 100644 index 000000000000..1fbd38814ed7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_threshold_backward_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_threshold_backward(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg1, %arg0 : memref, memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = arith.cmpf ole, %in, %arg2 : f32 + %1 = arith.select %0, %cst, %in_0 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_topk_cpu.mlir b/issues/aten_c_kernels/results/aten_topk_cpu.mlir new file mode 100644 index 000000000000..39baf2530ce4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_topk_cpu.mlir @@ -0,0 +1,63 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_topk_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<16x64xi32> + %alloca_0 = memref.alloca() : memref<16x64xf32> + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 64 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg0[%arg3, %arg4] : memref + affine.store %1, %alloca_0[%arg3, %arg4] : memref<16x64xf32> + affine.store %0, %alloca[%arg3, %arg4] : memref<16x64xi32> + } + affine.for %arg4 = 1 to 64 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %alloca_0[%arg3, %arg4] : memref<16x64xf32> + %2 = affine.load %alloca[%arg3, %arg4] : memref<16x64xi32> + %3 = arith.addi %0, %c-1_i32 : i32 + %4 = scf.while (%arg5 = %3) : (i32) -> i32 { + %7 = arith.cmpi sge, %arg5, %c0_i32 : i32 + %8:2 = scf.if %7 -> (i1, i32) { + %9 = arith.index_cast %arg5 : i32 to index + %10 = memref.load %alloca_0[%arg3, %9] : memref<16x64xf32> + %11 = arith.cmpf olt, %10, %1 : f32 + %12 = scf.if %11 -> (i32) { + %13 = arith.addi %arg5, %c1_i32 : i32 + %14 = arith.index_cast %13 : i32 to index + memref.store %10, %alloca_0[%arg3, %14] : memref<16x64xf32> + %15 = memref.load %alloca[%arg3, %9] : memref<16x64xi32> + memref.store %15, %alloca[%arg3, %14] : memref<16x64xi32> + %16 = arith.addi %arg5, %c-1_i32 : i32 + scf.yield %16 : i32 + } else { + scf.yield %arg5 : i32 + } + scf.yield %11, %12 : i1, i32 + } else { + scf.yield %false, %arg5 : i1, i32 + } + scf.condition(%8#0) %8#1 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %5 = arith.addi %4, %c1_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + memref.store %1, %alloca_0[%arg3, %6] : memref<16x64xf32> + memref.store %2, %alloca[%arg3, %6] : memref<16x64xi32> + } + } + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 8 { + %0 = affine.load %alloca_0[%arg3, %arg4] : memref<16x64xf32> + affine.store %0, %arg1[%arg3, %arg4] : memref + %1 = affine.load %alloca[%arg3, %arg4] : memref<16x64xi32> + affine.store %1, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_topk_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_topk_cpu/debuf.mlir new file mode 100644 index 000000000000..cb3b319712cd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_topk_cpu/debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_topk_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %alloca = memref.alloca() : memref<16x64xi32> + %2 = bufferization.to_tensor %alloca : memref<16x64xi32> + %alloca_0 = memref.alloca() : memref<16x64xf32> + %3 = bufferization.to_tensor %alloca_0 : memref<16x64xf32> + %extracted_slice = tensor.extract_slice %1[0, 0] [%c16, %c8] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0, 0] [%c16, %c8] [1, 1] : tensor<16x64xf32> to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0] [%c16, %c8] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + %extracted_slice_2 = tensor.extract_slice %0[0, 0] [%c16, %c8] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %2[0, 0] [%c16, %c8] [1, 1] : tensor<16x64xi32> to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %inserted_slice_4 = tensor.insert_slice %6 into %0[0, 0] [%c16, %c8] [1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice_4 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_topk_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_topk_cpu/matched.mlir new file mode 100644 index 000000000000..094c975c9118 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_topk_cpu/matched.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_topk_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %alloca = memref.alloca() : memref<16x64xi32> + %2 = bufferization.to_tensor %alloca : memref<16x64xi32> + %alloca_0 = memref.alloca() : memref<16x64xf32> + %3 = bufferization.to_tensor %alloca_0 : memref<16x64xf32> + %extracted_slice = tensor.extract_slice %1[0, 0] [%c16, %c8] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0, 0] [%c16, %c8] [1, 1] : tensor<16x64xf32> to tensor + %4 = kernel.launch @cudaCopy2D_f32_tensor(%extracted_slice_1, %extracted_slice) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0] [%c16, %c8] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + %extracted_slice_2 = tensor.extract_slice %0[0, 0] [%c16, %c8] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %2[0, 0] [%c16, %c8] [1, 1] : tensor<16x64xi32> to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %inserted_slice_4 = tensor.insert_slice %6 into %0[0, 0] [%c16, %c8] [1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice_4 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_topk_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_topk_cpu/orig.mlir new file mode 100644 index 000000000000..39baf2530ce4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_topk_cpu/orig.mlir @@ -0,0 +1,63 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_topk_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<16x64xi32> + %alloca_0 = memref.alloca() : memref<16x64xf32> + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 64 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %arg0[%arg3, %arg4] : memref + affine.store %1, %alloca_0[%arg3, %arg4] : memref<16x64xf32> + affine.store %0, %alloca[%arg3, %arg4] : memref<16x64xi32> + } + affine.for %arg4 = 1 to 64 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %alloca_0[%arg3, %arg4] : memref<16x64xf32> + %2 = affine.load %alloca[%arg3, %arg4] : memref<16x64xi32> + %3 = arith.addi %0, %c-1_i32 : i32 + %4 = scf.while (%arg5 = %3) : (i32) -> i32 { + %7 = arith.cmpi sge, %arg5, %c0_i32 : i32 + %8:2 = scf.if %7 -> (i1, i32) { + %9 = arith.index_cast %arg5 : i32 to index + %10 = memref.load %alloca_0[%arg3, %9] : memref<16x64xf32> + %11 = arith.cmpf olt, %10, %1 : f32 + %12 = scf.if %11 -> (i32) { + %13 = arith.addi %arg5, %c1_i32 : i32 + %14 = arith.index_cast %13 : i32 to index + memref.store %10, %alloca_0[%arg3, %14] : memref<16x64xf32> + %15 = memref.load %alloca[%arg3, %9] : memref<16x64xi32> + memref.store %15, %alloca[%arg3, %14] : memref<16x64xi32> + %16 = arith.addi %arg5, %c-1_i32 : i32 + scf.yield %16 : i32 + } else { + scf.yield %arg5 : i32 + } + scf.yield %11, %12 : i1, i32 + } else { + scf.yield %false, %arg5 : i1, i32 + } + scf.condition(%8#0) %8#1 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %5 = arith.addi %4, %c1_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + memref.store %1, %alloca_0[%arg3, %6] : memref<16x64xf32> + memref.store %2, %alloca[%arg3, %6] : memref<16x64xi32> + } + } + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 0 to 8 { + %0 = affine.load %alloca_0[%arg3, %arg4] : memref<16x64xf32> + affine.store %0, %arg1[%arg3, %arg4] : memref + %1 = affine.load %alloca[%arg3, %arg4] : memref<16x64xi32> + affine.store %1, %arg2[%arg3, %arg4] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_topk_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_topk_cpu/raised.mlir new file mode 100644 index 000000000000..5472c34a164e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_topk_cpu/raised.mlir @@ -0,0 +1,79 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_topk_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<16x64xi32> + %alloca_0 = memref.alloca() : memref<16x64xf32> + %subview = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca_0[0, 0] [%c16, %c64] [1, 1] : memref<16x64xf32> to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_2 = memref.subview %alloca[0, 0] [%c16, %c64] [1, 1] : memref<16x64xi32> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview_2 : memref>) { + ^bb0(%out: i32): + %0 = linalg.index 1 : index + %1 = arith.index_cast %0 : index to i32 + linalg.yield %1 : i32 + } + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 1 to 64 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %alloca_0[%arg3, %arg4] : memref<16x64xf32> + %2 = affine.load %alloca[%arg3, %arg4] : memref<16x64xi32> + %3 = arith.addi %0, %c-1_i32 : i32 + %4 = scf.while (%arg5 = %3) : (i32) -> i32 { + %7 = arith.cmpi sge, %arg5, %c0_i32 : i32 + %8:2 = scf.if %7 -> (i1, i32) { + %9 = arith.index_cast %arg5 : i32 to index + %10 = memref.load %alloca_0[%arg3, %9] : memref<16x64xf32> + %11 = arith.cmpf olt, %10, %1 : f32 + %12 = scf.if %11 -> (i32) { + %13 = arith.addi %arg5, %c1_i32 : i32 + %14 = arith.index_cast %13 : i32 to index + memref.store %10, %alloca_0[%arg3, %14] : memref<16x64xf32> + %15 = memref.load %alloca[%arg3, %9] : memref<16x64xi32> + memref.store %15, %alloca[%arg3, %14] : memref<16x64xi32> + %16 = arith.addi %arg5, %c-1_i32 : i32 + scf.yield %16 : i32 + } else { + scf.yield %arg5 : i32 + } + scf.yield %11, %12 : i1, i32 + } else { + scf.yield %false, %arg5 : i1, i32 + } + scf.condition(%8#0) %8#1 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %5 = arith.addi %4, %c1_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + memref.store %1, %alloca_0[%arg3, %6] : memref<16x64xf32> + memref.store %2, %alloca[%arg3, %6] : memref<16x64xi32> + } + } + %subview_3 = memref.subview %alloca_0[0, 0] [%c16, %c8] [1, 1] : memref<16x64xf32> to memref> + %subview_4 = memref.subview %arg1[0, 0] [%c16, %c8] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview_3 : memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_5 = memref.subview %alloca[0, 0] [%c16, %c8] [1, 1] : memref<16x64xi32> to memref> + %subview_6 = memref.subview %arg2[0, 0] [%c16, %c8] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview_5 : memref>) outs(%subview_6 : memref>) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_topk_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_topk_cpu_debuf.mlir new file mode 100644 index 000000000000..cb3b319712cd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_topk_cpu_debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_topk_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c16 = arith.constant 16 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %alloca = memref.alloca() : memref<16x64xi32> + %2 = bufferization.to_tensor %alloca : memref<16x64xi32> + %alloca_0 = memref.alloca() : memref<16x64xf32> + %3 = bufferization.to_tensor %alloca_0 : memref<16x64xf32> + %extracted_slice = tensor.extract_slice %1[0, 0] [%c16, %c8] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %3[0, 0] [%c16, %c8] [1, 1] : tensor<16x64xf32> to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_1 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %1[0, 0] [%c16, %c8] [1, 1] : tensor into tensor + %5 = bufferization.to_memref %inserted_slice : memref + memref.copy %5, %arg1 : memref to memref + %extracted_slice_2 = tensor.extract_slice %0[0, 0] [%c16, %c8] [1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %2[0, 0] [%c16, %c8] [1, 1] : tensor<16x64xi32> to tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice_3 : tensor) outs(%extracted_slice_2 : tensor) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } -> tensor + %inserted_slice_4 = tensor.insert_slice %6 into %0[0, 0] [%c16, %c8] [1, 1] : tensor into tensor + %7 = bufferization.to_memref %inserted_slice_4 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_topk_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_topk_cpu_linalg.mlir new file mode 100644 index 000000000000..5472c34a164e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_topk_cpu_linalg.mlir @@ -0,0 +1,79 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_topk_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16 = arith.constant 16 : index + %c64 = arith.constant 64 : index + %c8 = arith.constant 8 : index + %c-1_i32 = arith.constant -1 : i32 + %false = arith.constant false + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<16x64xi32> + %alloca_0 = memref.alloca() : memref<16x64xf32> + %subview = memref.subview %arg0[0, 0] [%c16, %c64] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca_0[0, 0] [%c16, %c64] [1, 1] : memref<16x64xf32> to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_2 = memref.subview %alloca[0, 0] [%c16, %c64] [1, 1] : memref<16x64xi32> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview_2 : memref>) { + ^bb0(%out: i32): + %0 = linalg.index 1 : index + %1 = arith.index_cast %0 : index to i32 + linalg.yield %1 : i32 + } + affine.for %arg3 = 0 to 16 { + affine.for %arg4 = 1 to 64 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = affine.load %alloca_0[%arg3, %arg4] : memref<16x64xf32> + %2 = affine.load %alloca[%arg3, %arg4] : memref<16x64xi32> + %3 = arith.addi %0, %c-1_i32 : i32 + %4 = scf.while (%arg5 = %3) : (i32) -> i32 { + %7 = arith.cmpi sge, %arg5, %c0_i32 : i32 + %8:2 = scf.if %7 -> (i1, i32) { + %9 = arith.index_cast %arg5 : i32 to index + %10 = memref.load %alloca_0[%arg3, %9] : memref<16x64xf32> + %11 = arith.cmpf olt, %10, %1 : f32 + %12 = scf.if %11 -> (i32) { + %13 = arith.addi %arg5, %c1_i32 : i32 + %14 = arith.index_cast %13 : i32 to index + memref.store %10, %alloca_0[%arg3, %14] : memref<16x64xf32> + %15 = memref.load %alloca[%arg3, %9] : memref<16x64xi32> + memref.store %15, %alloca[%arg3, %14] : memref<16x64xi32> + %16 = arith.addi %arg5, %c-1_i32 : i32 + scf.yield %16 : i32 + } else { + scf.yield %arg5 : i32 + } + scf.yield %11, %12 : i1, i32 + } else { + scf.yield %false, %arg5 : i1, i32 + } + scf.condition(%8#0) %8#1 : i32 + } do { + ^bb0(%arg5: i32): + scf.yield %arg5 : i32 + } + %5 = arith.addi %4, %c1_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + memref.store %1, %alloca_0[%arg3, %6] : memref<16x64xf32> + memref.store %2, %alloca[%arg3, %6] : memref<16x64xi32> + } + } + %subview_3 = memref.subview %alloca_0[0, 0] [%c16, %c8] [1, 1] : memref<16x64xf32> to memref> + %subview_4 = memref.subview %arg1[0, 0] [%c16, %c8] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview_3 : memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + %subview_5 = memref.subview %alloca[0, 0] [%c16, %c8] [1, 1] : memref<16x64xi32> to memref> + %subview_6 = memref.subview %arg2[0, 0] [%c16, %c8] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview_5 : memref>) outs(%subview_6 : memref>) { + ^bb0(%in: i32, %out: i32): + linalg.yield %in : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_trace_cpu.mlir b/issues/aten_c_kernels/results/aten_trace_cpu.mlir new file mode 100644 index 000000000000..e15cb8bfccc0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trace_cpu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trace_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg2 = 0 to 64 iter_args(%arg3 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2, %arg2] : memref + %2 = arith.addf %arg3, %1 : f32 + affine.yield %2 : f32 + } + affine.store %0, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_trace_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_trace_cpu/debuf.mlir new file mode 100644 index 000000000000..5856329daa77 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trace_cpu/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0, d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trace_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %cst into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_trace_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_trace_cpu/matched.mlir new file mode 100644 index 000000000000..5856329daa77 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trace_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0, d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trace_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %cst into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_trace_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_trace_cpu/orig.mlir new file mode 100644 index 000000000000..e15cb8bfccc0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trace_cpu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trace_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = affine.for %arg2 = 0 to 64 iter_args(%arg3 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg2, %arg2] : memref + %2 = arith.addf %arg3, %1 : f32 + affine.yield %2 : f32 + } + affine.store %0, %arg1[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_trace_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_trace_cpu/raised.mlir new file mode 100644 index 000000000000..0493927c223e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trace_cpu/raised.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0, d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trace_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.store %cst, %arg1[0] : memref + %subview = memref.subview %arg0[0, 0] [%c64, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.addf %out, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_trace_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_trace_cpu_debuf.mlir new file mode 100644 index 000000000000..5856329daa77 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trace_cpu_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0) -> (d0, d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trace_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %inserted = tensor.insert %cst into %1[%c0] : tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c64, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = arith.addf %out, %in : f32 + linalg.yield %4 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %inserted[0] [1] [1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_trace_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_trace_cpu_linalg.mlir new file mode 100644 index 000000000000..0493927c223e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trace_cpu_linalg.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0, d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trace_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.store %cst, %arg1[0] : memref + %subview = memref.subview %arg0[0, 0] [%c64, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.addf %out, %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu.mlir b/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu.mlir new file mode 100644 index 000000000000..9b3647a46fde --- /dev/null +++ b/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_transform_bias_rescale_qkv_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 16 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 8 { + %0 = affine.load %arg0[%arg6, %arg7, 0, %arg8, %arg9] : memref + %1 = affine.load %arg1[0, %arg8, %arg9] : memref + %2 = arith.addf %0, %1 : f32 + %3 = arith.mulf %2, %arg2 : f32 + affine.store %3, %arg3[%arg6, %arg8, %arg7, %arg9] : memref + %4 = affine.load %arg0[%arg6, %arg7, 1, %arg8, %arg9] : memref + %5 = affine.load %arg1[1, %arg8, %arg9] : memref + %6 = arith.addf %4, %5 : f32 + affine.store %6, %arg4[%arg6, %arg8, %arg7, %arg9] : memref + %7 = affine.load %arg0[%arg6, %arg7, 2, %arg8, %arg9] : memref + %8 = affine.load %arg1[2, %arg8, %arg9] : memref + %9 = arith.addf %7, %8 : f32 + affine.store %9, %arg5[%arg6, %arg8, %arg7, %arg9] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu/debuf.mlir new file mode 100644 index 000000000000..20684e043568 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu/debuf.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d2, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_transform_bias_rescale_qkv_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = bufferization.to_tensor %arg5 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0, 0] [%c2, %c16, 1, %c4, %c8] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0] [1, %c4, %c8] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_10: f32, %out: f32): + %11 = arith.addf %in, %in_10 : f32 + %12 = arith.mulf %11, %arg2 : f32 + linalg.yield %12 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg3 : memref to memref + %extracted_slice_2 = tensor.extract_slice %0[0, 0, 1, 0, 0] [%c2, %c16, 1, %c4, %c8] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %1[1, 0, 0] [1, %c4, %c8] [1, 1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %3[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_2, %extracted_slice_3 : tensor, tensor) outs(%extracted_slice_4 : tensor) { + ^bb0(%in: f32, %in_10: f32, %out: f32): + %11 = arith.addf %in, %in_10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice_5 = tensor.insert_slice %7 into %3[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor into tensor + %8 = bufferization.to_memref %inserted_slice_5 : memref + memref.copy %8, %arg4 : memref to memref + %extracted_slice_6 = tensor.extract_slice %0[0, 0, 2, 0, 0] [%c2, %c16, 1, %c4, %c8] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_7 = tensor.extract_slice %1[2, 0, 0] [1, %c4, %c8] [1, 1, 1] : tensor to tensor + %extracted_slice_8 = tensor.extract_slice %4[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_6, %extracted_slice_7 : tensor, tensor) outs(%extracted_slice_8 : tensor) { + ^bb0(%in: f32, %in_10: f32, %out: f32): + %11 = arith.addf %in, %in_10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice_9 = tensor.insert_slice %9 into %4[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor into tensor + %10 = bufferization.to_memref %inserted_slice_9 : memref + memref.copy %10, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu/matched.mlir new file mode 100644 index 000000000000..20684e043568 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu/matched.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d2, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_transform_bias_rescale_qkv_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = bufferization.to_tensor %arg5 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0, 0] [%c2, %c16, 1, %c4, %c8] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0] [1, %c4, %c8] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_10: f32, %out: f32): + %11 = arith.addf %in, %in_10 : f32 + %12 = arith.mulf %11, %arg2 : f32 + linalg.yield %12 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg3 : memref to memref + %extracted_slice_2 = tensor.extract_slice %0[0, 0, 1, 0, 0] [%c2, %c16, 1, %c4, %c8] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %1[1, 0, 0] [1, %c4, %c8] [1, 1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %3[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_2, %extracted_slice_3 : tensor, tensor) outs(%extracted_slice_4 : tensor) { + ^bb0(%in: f32, %in_10: f32, %out: f32): + %11 = arith.addf %in, %in_10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice_5 = tensor.insert_slice %7 into %3[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor into tensor + %8 = bufferization.to_memref %inserted_slice_5 : memref + memref.copy %8, %arg4 : memref to memref + %extracted_slice_6 = tensor.extract_slice %0[0, 0, 2, 0, 0] [%c2, %c16, 1, %c4, %c8] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_7 = tensor.extract_slice %1[2, 0, 0] [1, %c4, %c8] [1, 1, 1] : tensor to tensor + %extracted_slice_8 = tensor.extract_slice %4[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_6, %extracted_slice_7 : tensor, tensor) outs(%extracted_slice_8 : tensor) { + ^bb0(%in: f32, %in_10: f32, %out: f32): + %11 = arith.addf %in, %in_10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice_9 = tensor.insert_slice %9 into %4[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor into tensor + %10 = bufferization.to_memref %inserted_slice_9 : memref + memref.copy %10, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu/orig.mlir new file mode 100644 index 000000000000..9b3647a46fde --- /dev/null +++ b/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu/orig.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_transform_bias_rescale_qkv_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 16 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 8 { + %0 = affine.load %arg0[%arg6, %arg7, 0, %arg8, %arg9] : memref + %1 = affine.load %arg1[0, %arg8, %arg9] : memref + %2 = arith.addf %0, %1 : f32 + %3 = arith.mulf %2, %arg2 : f32 + affine.store %3, %arg3[%arg6, %arg8, %arg7, %arg9] : memref + %4 = affine.load %arg0[%arg6, %arg7, 1, %arg8, %arg9] : memref + %5 = affine.load %arg1[1, %arg8, %arg9] : memref + %6 = arith.addf %4, %5 : f32 + affine.store %6, %arg4[%arg6, %arg8, %arg7, %arg9] : memref + %7 = affine.load %arg0[%arg6, %arg7, 2, %arg8, %arg9] : memref + %8 = affine.load %arg1[2, %arg8, %arg9] : memref + %9 = arith.addf %7, %8 : f32 + affine.store %9, %arg5[%arg6, %arg8, %arg7, %arg9] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu/raised.mlir new file mode 100644 index 000000000000..a285b3519f3b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu/raised.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d2, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_transform_bias_rescale_qkv_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %c8 = arith.constant 8 : index + %subview = memref.subview %arg0[0, 0, 0, 0, 0] [%c2, %c16, 1, %c4, %c8] [1, 1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0] [1, %c4, %c8] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg3[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_8: f32, %out: f32): + %0 = arith.addf %in, %in_8 : f32 + %1 = arith.mulf %0, %arg2 : f32 + linalg.yield %1 : f32 + } + %subview_2 = memref.subview %arg0[0, 0, 1, 0, 0] [%c2, %c16, 1, %c4, %c8] [1, 1, 1, 1, 1] : memref to memref> + %subview_3 = memref.subview %arg1[1, 0, 0] [1, %c4, %c8] [1, 1, 1] : memref to memref> + %subview_4 = memref.subview %arg4[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_2, %subview_3 : memref>, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %in_8: f32, %out: f32): + %0 = arith.addf %in, %in_8 : f32 + linalg.yield %0 : f32 + } + %subview_5 = memref.subview %arg0[0, 0, 2, 0, 0] [%c2, %c16, 1, %c4, %c8] [1, 1, 1, 1, 1] : memref to memref> + %subview_6 = memref.subview %arg1[2, 0, 0] [1, %c4, %c8] [1, 1, 1] : memref to memref> + %subview_7 = memref.subview %arg5[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_5, %subview_6 : memref>, memref>) outs(%subview_7 : memref>) { + ^bb0(%in: f32, %in_8: f32, %out: f32): + %0 = arith.addf %in, %in_8 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu_debuf.mlir new file mode 100644 index 000000000000..20684e043568 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu_debuf.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d2, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_transform_bias_rescale_qkv_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = bufferization.to_tensor %arg5 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0, 0] [%c2, %c16, 1, %c4, %c8] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0] [1, %c4, %c8] [1, 1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %2[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_10: f32, %out: f32): + %11 = arith.addf %in, %in_10 : f32 + %12 = arith.mulf %11, %arg2 : f32 + linalg.yield %12 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %2[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg3 : memref to memref + %extracted_slice_2 = tensor.extract_slice %0[0, 0, 1, 0, 0] [%c2, %c16, 1, %c4, %c8] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %1[1, 0, 0] [1, %c4, %c8] [1, 1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %3[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor to tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_2, %extracted_slice_3 : tensor, tensor) outs(%extracted_slice_4 : tensor) { + ^bb0(%in: f32, %in_10: f32, %out: f32): + %11 = arith.addf %in, %in_10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice_5 = tensor.insert_slice %7 into %3[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor into tensor + %8 = bufferization.to_memref %inserted_slice_5 : memref + memref.copy %8, %arg4 : memref to memref + %extracted_slice_6 = tensor.extract_slice %0[0, 0, 2, 0, 0] [%c2, %c16, 1, %c4, %c8] [1, 1, 1, 1, 1] : tensor to tensor + %extracted_slice_7 = tensor.extract_slice %1[2, 0, 0] [1, %c4, %c8] [1, 1, 1] : tensor to tensor + %extracted_slice_8 = tensor.extract_slice %4[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_6, %extracted_slice_7 : tensor, tensor) outs(%extracted_slice_8 : tensor) { + ^bb0(%in: f32, %in_10: f32, %out: f32): + %11 = arith.addf %in, %in_10 : f32 + linalg.yield %11 : f32 + } -> tensor + %inserted_slice_9 = tensor.insert_slice %9 into %4[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : tensor into tensor + %10 = bufferization.to_memref %inserted_slice_9 : memref + memref.copy %10, %arg5 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu_linalg.mlir new file mode 100644 index 000000000000..a285b3519f3b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_transform_bias_rescale_qkv_cpu_linalg.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d2, d3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_transform_bias_rescale_qkv_cpu(%arg0: memref, %arg1: memref, %arg2: f32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %c8 = arith.constant 8 : index + %subview = memref.subview %arg0[0, 0, 0, 0, 0] [%c2, %c16, 1, %c4, %c8] [1, 1, 1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0, 0] [1, %c4, %c8] [1, 1, 1] : memref to memref> + %subview_1 = memref.subview %arg3[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_8: f32, %out: f32): + %0 = arith.addf %in, %in_8 : f32 + %1 = arith.mulf %0, %arg2 : f32 + linalg.yield %1 : f32 + } + %subview_2 = memref.subview %arg0[0, 0, 1, 0, 0] [%c2, %c16, 1, %c4, %c8] [1, 1, 1, 1, 1] : memref to memref> + %subview_3 = memref.subview %arg1[1, 0, 0] [1, %c4, %c8] [1, 1, 1] : memref to memref> + %subview_4 = memref.subview %arg4[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_2, %subview_3 : memref>, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f32, %in_8: f32, %out: f32): + %0 = arith.addf %in, %in_8 : f32 + linalg.yield %0 : f32 + } + %subview_5 = memref.subview %arg0[0, 0, 2, 0, 0] [%c2, %c16, 1, %c4, %c8] [1, 1, 1, 1, 1] : memref to memref> + %subview_6 = memref.subview %arg1[2, 0, 0] [1, %c4, %c8] [1, 1, 1] : memref to memref> + %subview_7 = memref.subview %arg5[0, 0, 0, 0] [%c2, %c4, %c16, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_5, %subview_6 : memref>, memref>) outs(%subview_7 : memref>) { + ^bb0(%in: f32, %in_8: f32, %out: f32): + %0 = arith.addf %in, %in_8 : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_transpose_copy.mlir b/issues/aten_c_kernels/results/aten_transpose_copy.mlir new file mode 100644 index 000000000000..d722a877a379 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_transpose_copy.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_transpose_copy(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 32 { + affine.for %arg3 = 0 to 24 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + affine.store %0, %arg1[%arg3, %arg2] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_transpose_copy/debuf.mlir b/issues/aten_c_kernels/results/aten_transpose_copy/debuf.mlir new file mode 100644 index 000000000000..dc58f45f8ceb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_transpose_copy/debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_transpose_copy(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c24, %c32] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c24, %c32] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_transpose_copy/matched.mlir b/issues/aten_c_kernels/results/aten_transpose_copy/matched.mlir new file mode 100644 index 000000000000..dc58f45f8ceb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_transpose_copy/matched.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_transpose_copy(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c24, %c32] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c24, %c32] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_transpose_copy/orig.mlir b/issues/aten_c_kernels/results/aten_transpose_copy/orig.mlir new file mode 100644 index 000000000000..d722a877a379 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_transpose_copy/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_transpose_copy(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 32 { + affine.for %arg3 = 0 to 24 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + affine.store %0, %arg1[%arg3, %arg2] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_transpose_copy/raised.mlir b/issues/aten_c_kernels/results/aten_transpose_copy/raised.mlir new file mode 100644 index 000000000000..ce64aaef2ff6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_transpose_copy/raised.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_transpose_copy(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %subview = memref.subview %arg0[0, 0] [%c32, %c24] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c24, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_transpose_copy_debuf.mlir b/issues/aten_c_kernels/results/aten_transpose_copy_debuf.mlir new file mode 100644 index 000000000000..dc58f45f8ceb --- /dev/null +++ b/issues/aten_c_kernels/results/aten_transpose_copy_debuf.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_transpose_copy(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c24, %c32] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c24, %c32] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_transpose_copy_linalg.mlir b/issues/aten_c_kernels/results/aten_transpose_copy_linalg.mlir new file mode 100644 index 000000000000..ce64aaef2ff6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_transpose_copy_linalg.mlir @@ -0,0 +1,16 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_transpose_copy(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %subview = memref.subview %arg0[0, 0] [%c32, %c24] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c24, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_trigamma.mlir b/issues/aten_c_kernels/results/aten_trigamma.mlir new file mode 100644 index 000000000000..d87e0ff1adce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trigamma.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trigamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_trigammaf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_trigammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_trigamma/debuf.mlir b/issues/aten_c_kernels/results/aten_trigamma/debuf.mlir new file mode 100644 index 000000000000..2de86fa00a40 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trigamma/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trigamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_trigammaf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_trigammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_trigamma/matched.mlir b/issues/aten_c_kernels/results/aten_trigamma/matched.mlir new file mode 100644 index 000000000000..2de86fa00a40 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trigamma/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trigamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_trigammaf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_trigammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_trigamma/orig.mlir b/issues/aten_c_kernels/results/aten_trigamma/orig.mlir new file mode 100644 index 000000000000..d87e0ff1adce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trigamma/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trigamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @calc_trigammaf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @calc_trigammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_trigamma/raised.mlir b/issues/aten_c_kernels/results/aten_trigamma/raised.mlir new file mode 100644 index 000000000000..11de51ae6485 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trigamma/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trigamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_trigammaf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_trigammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_trigamma_debuf.mlir b/issues/aten_c_kernels/results/aten_trigamma_debuf.mlir new file mode 100644 index 000000000000..2de86fa00a40 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trigamma_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trigamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = func.call @calc_trigammaf(%in) : (f32) -> f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @calc_trigammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_trigamma_linalg.mlir b/issues/aten_c_kernels/results/aten_trigamma_linalg.mlir new file mode 100644 index 000000000000..11de51ae6485 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trigamma_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trigamma(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = func.call @calc_trigammaf(%in) : (f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_trigammaf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_tril_indices_cpu.mlir b/issues/aten_c_kernels/results/aten_tril_indices_cpu.mlir new file mode 100644 index 000000000000..ded6952f6380 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tril_indices_cpu.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tril_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + affine.for %arg2 = 0 to 32 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.addi %0, %c1_i32 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg3 = 0 to #map(%arg2) { + %4 = arith.index_cast %arg3 : index to i32 + %5 = arith.addi %3, %4 : i32 + %6 = arith.index_cast %5 : i32 to index + memref.store %0, %arg0[%6] : memref + memref.store %4, %arg1[%6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_tril_indices_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_tril_indices_cpu/debuf.mlir new file mode 100644 index 000000000000..fd3f657b11df --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tril_indices_cpu/debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tril_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2:2 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %1, %arg4 = %0) -> (tensor, tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.addi %5, %c1_i32 : i32 + %7 = arith.muli %5, %6 : i32 + %8 = arith.divsi %7, %c2_i32 : i32 + %9:2 = affine.for %arg5 = 0 to #map(%arg2) iter_args(%arg6 = %arg3, %arg7 = %arg4) -> (tensor, tensor) { + %10 = arith.index_cast %arg5 : index to i32 + %11 = arith.addi %8, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %inserted = tensor.insert %5 into %arg6[%12] : tensor + %inserted_0 = tensor.insert %10 into %arg7[%12] : tensor + affine.yield %inserted, %inserted_0 : tensor, tensor + } + affine.yield %9#0, %9#1 : tensor, tensor + } + %3 = bufferization.to_memref %2#1 : memref + memref.copy %3, %arg1 : memref to memref + %4 = bufferization.to_memref %2#0 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_tril_indices_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_tril_indices_cpu/matched.mlir new file mode 100644 index 000000000000..fd3f657b11df --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tril_indices_cpu/matched.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tril_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2:2 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %1, %arg4 = %0) -> (tensor, tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.addi %5, %c1_i32 : i32 + %7 = arith.muli %5, %6 : i32 + %8 = arith.divsi %7, %c2_i32 : i32 + %9:2 = affine.for %arg5 = 0 to #map(%arg2) iter_args(%arg6 = %arg3, %arg7 = %arg4) -> (tensor, tensor) { + %10 = arith.index_cast %arg5 : index to i32 + %11 = arith.addi %8, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %inserted = tensor.insert %5 into %arg6[%12] : tensor + %inserted_0 = tensor.insert %10 into %arg7[%12] : tensor + affine.yield %inserted, %inserted_0 : tensor, tensor + } + affine.yield %9#0, %9#1 : tensor, tensor + } + %3 = bufferization.to_memref %2#1 : memref + memref.copy %3, %arg1 : memref to memref + %4 = bufferization.to_memref %2#0 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_tril_indices_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_tril_indices_cpu/orig.mlir new file mode 100644 index 000000000000..ded6952f6380 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tril_indices_cpu/orig.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tril_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + affine.for %arg2 = 0 to 32 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.addi %0, %c1_i32 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg3 = 0 to #map(%arg2) { + %4 = arith.index_cast %arg3 : index to i32 + %5 = arith.addi %3, %4 : i32 + %6 = arith.index_cast %5 : i32 to index + memref.store %0, %arg0[%6] : memref + memref.store %4, %arg1[%6] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_tril_indices_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_tril_indices_cpu/raised.mlir new file mode 100644 index 000000000000..5bcf577c2587 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tril_indices_cpu/raised.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tril_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + affine.for %arg2 = 0 to 32 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.addi %0, %c1_i32 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg3 = 0 to #map(%arg2) { + %4 = arith.index_cast %arg3 : index to i32 + %5 = arith.addi %3, %4 : i32 + %6 = arith.index_cast %5 : i32 to index + memref.store %0, %arg0[%6] : memref + memref.store %4, %arg1[%6] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_tril_indices_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_tril_indices_cpu_debuf.mlir new file mode 100644 index 000000000000..fd3f657b11df --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tril_indices_cpu_debuf.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tril_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2:2 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %1, %arg4 = %0) -> (tensor, tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.addi %5, %c1_i32 : i32 + %7 = arith.muli %5, %6 : i32 + %8 = arith.divsi %7, %c2_i32 : i32 + %9:2 = affine.for %arg5 = 0 to #map(%arg2) iter_args(%arg6 = %arg3, %arg7 = %arg4) -> (tensor, tensor) { + %10 = arith.index_cast %arg5 : index to i32 + %11 = arith.addi %8, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %inserted = tensor.insert %5 into %arg6[%12] : tensor + %inserted_0 = tensor.insert %10 into %arg7[%12] : tensor + affine.yield %inserted, %inserted_0 : tensor, tensor + } + affine.yield %9#0, %9#1 : tensor, tensor + } + %3 = bufferization.to_memref %2#1 : memref + memref.copy %3, %arg1 : memref to memref + %4 = bufferization.to_memref %2#0 : memref + memref.copy %4, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_tril_indices_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_tril_indices_cpu_linalg.mlir new file mode 100644 index 000000000000..5bcf577c2587 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_tril_indices_cpu_linalg.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_tril_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + affine.for %arg2 = 0 to 32 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.addi %0, %c1_i32 : i32 + %2 = arith.muli %0, %1 : i32 + %3 = arith.divsi %2, %c2_i32 : i32 + affine.for %arg3 = 0 to #map(%arg2) { + %4 = arith.index_cast %arg3 : index to i32 + %5 = arith.addi %3, %4 : i32 + %6 = arith.index_cast %5 : i32 to index + memref.store %0, %arg0[%6] : memref + memref.store %4, %arg1[%6] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_trilinear_cpu.mlir b/issues/aten_c_kernels/results/aten_trilinear_cpu.mlir new file mode 100644 index 000000000000..99d3e849f684 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trilinear_cpu.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trilinear_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 24 { + %0 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg4, %arg6] : memref + %2 = affine.for %arg8 = 0 to 20 iter_args(%arg9 = %arg7) -> (f32) { + %3 = affine.load %arg1[%arg6, %arg8, %arg5] : memref + %4 = arith.mulf %1, %3 : f32 + %5 = affine.load %arg2[%arg4, %arg8] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.addf %arg9, %6 : f32 + affine.yield %7 : f32 + } + affine.yield %2 : f32 + } + affine.store %0, %arg3[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_trilinear_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_trilinear_cpu/debuf.mlir new file mode 100644 index 000000000000..e28ddae2375f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trilinear_cpu/debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d2, d3, d1)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trilinear_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c24 = arith.constant 24 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %3[0, 0] [%c8, %c24] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c8, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c16, %c20, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %2[0, 0] [%c8, %c20] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1, %extracted_slice_2 : tensor, tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_3: f32, %in_4: f32, %out: f32): + %7 = arith.mulf %in, %in_3 : f32 + %8 = arith.mulf %7, %in_4 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %3[0, 0] [%c8, %c24] [1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_trilinear_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_trilinear_cpu/matched.mlir new file mode 100644 index 000000000000..b1076f76dab7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trilinear_cpu/matched.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d2, d3, d1)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trilinear_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c24 = arith.constant 24 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %3[0, 0] [%c8, %c24] [1, 1] : tensor to tensor + %4 = kernel.launch @memset_zero_2D_f32(%extracted_slice) : (tensor) -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c8, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c16, %c20, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %2[0, 0] [%c8, %c20] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1, %extracted_slice_2 : tensor, tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_3: f32, %in_4: f32, %out: f32): + %7 = arith.mulf %in, %in_3 : f32 + %8 = arith.mulf %7, %in_4 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %3[0, 0] [%c8, %c24] [1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_trilinear_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_trilinear_cpu/orig.mlir new file mode 100644 index 000000000000..99d3e849f684 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trilinear_cpu/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trilinear_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 8 { + affine.for %arg5 = 0 to 24 { + %0 = affine.for %arg6 = 0 to 16 iter_args(%arg7 = %cst) -> (f32) { + %1 = affine.load %arg0[%arg4, %arg6] : memref + %2 = affine.for %arg8 = 0 to 20 iter_args(%arg9 = %arg7) -> (f32) { + %3 = affine.load %arg1[%arg6, %arg8, %arg5] : memref + %4 = arith.mulf %1, %3 : f32 + %5 = affine.load %arg2[%arg4, %arg8] : memref + %6 = arith.mulf %4, %5 : f32 + %7 = arith.addf %arg9, %6 : f32 + affine.yield %7 : f32 + } + affine.yield %2 : f32 + } + affine.store %0, %arg3[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_trilinear_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_trilinear_cpu/raised.mlir new file mode 100644 index 000000000000..0d1c5f4c0eca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trilinear_cpu/raised.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d2, d3, d1)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trilinear_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c24 = arith.constant 24 : index + %c16 = arith.constant 16 : index + %c20 = arith.constant 20 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg3[0, 0] [%c8, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0] [%c8, %c16] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0] [%c16, %c20, %c24] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0] [%c8, %c20] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg3[0, 0] [%c8, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%subview_0, %subview_1, %subview_2 : memref>, memref>, memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f32, %in_4: f32, %in_5: f32, %out: f32): + %0 = arith.mulf %in, %in_4 : f32 + %1 = arith.mulf %0, %in_5 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_trilinear_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_trilinear_cpu_debuf.mlir new file mode 100644 index 000000000000..e28ddae2375f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trilinear_cpu_debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d2, d3, d1)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trilinear_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c20 = arith.constant 20 : index + %c16 = arith.constant 16 : index + %c24 = arith.constant 24 : index + %c8 = arith.constant 8 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %extracted_slice = tensor.extract_slice %3[0, 0] [%c8, %c24] [1, 1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0] [%c8, %c16] [1, 1] : tensor to tensor + %extracted_slice_1 = tensor.extract_slice %1[0, 0, 0] [%c16, %c20, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %2[0, 0] [%c8, %c20] [1, 1] : tensor to tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map1, #map2, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%extracted_slice_0, %extracted_slice_1, %extracted_slice_2 : tensor, tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: f32, %in_3: f32, %in_4: f32, %out: f32): + %7 = arith.mulf %in, %in_3 : f32 + %8 = arith.mulf %7, %in_4 : f32 + %9 = arith.addf %out, %8 : f32 + linalg.yield %9 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %5 into %3[0, 0] [%c8, %c24] [1, 1] : tensor into tensor + %6 = bufferization.to_memref %inserted_slice : memref + memref.copy %6, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_trilinear_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_trilinear_cpu_linalg.mlir new file mode 100644 index 000000000000..0d1c5f4c0eca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trilinear_cpu_linalg.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d2)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d2, d3, d1)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trilinear_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8 = arith.constant 8 : index + %c24 = arith.constant 24 : index + %c16 = arith.constant 16 : index + %c20 = arith.constant 20 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg3[0, 0] [%c8, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0] [%c8, %c16] [1, 1] : memref to memref> + %subview_1 = memref.subview %arg1[0, 0, 0] [%c16, %c20, %c24] [1, 1, 1] : memref to memref> + %subview_2 = memref.subview %arg2[0, 0] [%c8, %c20] [1, 1] : memref to memref> + %subview_3 = memref.subview %arg3[0, 0] [%c8, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%subview_0, %subview_1, %subview_2 : memref>, memref>, memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f32, %in_4: f32, %in_5: f32, %out: f32): + %0 = arith.mulf %in, %in_4 : f32 + %1 = arith.mulf %0, %in_5 : f32 + %2 = arith.addf %out, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_indices_cpu.mlir b/issues/aten_c_kernels/results/aten_triu_indices_cpu.mlir new file mode 100644 index 000000000000..1d96f05c47f0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_indices_cpu.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %c0_i32) -> (i32) { + %1 = arith.index_cast %arg2 : index to i32 + %2 = arith.subi %c32, %arg2 : index + %3 = arith.index_cast %arg3 : i32 to index + %4 = arith.addi %3, %2 : index + %5 = arith.index_cast %4 : index to i32 + affine.for %arg4 = #map(%arg2) to 32 { + %6 = arith.subi %arg4, %arg2 : index + %7 = arith.addi %3, %6 : index + %8 = arith.index_cast %arg4 : index to i32 + memref.store %1, %arg0[%7] : memref + memref.store %8, %arg1[%7] : memref + } + affine.yield %5 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_triu_indices_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_triu_indices_cpu/debuf.mlir new file mode 100644 index 000000000000..33391b2dd898 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_indices_cpu/debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %2[] : tensor + %3:3 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %inserted, %arg4 = %1, %arg5 = %0) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg3[] : tensor + %6 = arith.index_cast %arg2 : index to i32 + %7 = arith.subi %c32, %arg2 : index + %8 = arith.index_cast %extracted : i32 to index + %9 = arith.addi %8, %7 : index + %10 = arith.index_cast %9 : index to i32 + %11:2 = affine.for %arg6 = #map(%arg2) to 32 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %12 = arith.subi %arg6, %arg2 : index + %13 = arith.addi %8, %12 : index + %14 = arith.index_cast %arg6 : index to i32 + %inserted_1 = tensor.insert %6 into %arg7[%13] : tensor + %inserted_2 = tensor.insert %14 into %arg8[%13] : tensor + affine.yield %inserted_1, %inserted_2 : tensor, tensor + } + %inserted_0 = tensor.insert %10 into %arg3[] : tensor + affine.yield %inserted_0, %11#0, %11#1 : tensor, tensor, tensor + } + %4 = bufferization.to_memref %3#2 : memref + memref.copy %4, %arg1 : memref to memref + %5 = bufferization.to_memref %3#1 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_indices_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_triu_indices_cpu/matched.mlir new file mode 100644 index 000000000000..33391b2dd898 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_indices_cpu/matched.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %2[] : tensor + %3:3 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %inserted, %arg4 = %1, %arg5 = %0) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg3[] : tensor + %6 = arith.index_cast %arg2 : index to i32 + %7 = arith.subi %c32, %arg2 : index + %8 = arith.index_cast %extracted : i32 to index + %9 = arith.addi %8, %7 : index + %10 = arith.index_cast %9 : index to i32 + %11:2 = affine.for %arg6 = #map(%arg2) to 32 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %12 = arith.subi %arg6, %arg2 : index + %13 = arith.addi %8, %12 : index + %14 = arith.index_cast %arg6 : index to i32 + %inserted_1 = tensor.insert %6 into %arg7[%13] : tensor + %inserted_2 = tensor.insert %14 into %arg8[%13] : tensor + affine.yield %inserted_1, %inserted_2 : tensor, tensor + } + %inserted_0 = tensor.insert %10 into %arg3[] : tensor + affine.yield %inserted_0, %11#0, %11#1 : tensor, tensor, tensor + } + %4 = bufferization.to_memref %3#2 : memref + memref.copy %4, %arg1 : memref to memref + %5 = bufferization.to_memref %3#1 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_indices_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_triu_indices_cpu/orig.mlir new file mode 100644 index 000000000000..1d96f05c47f0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_indices_cpu/orig.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %c0_i32) -> (i32) { + %1 = arith.index_cast %arg2 : index to i32 + %2 = arith.subi %c32, %arg2 : index + %3 = arith.index_cast %arg3 : i32 to index + %4 = arith.addi %3, %2 : index + %5 = arith.index_cast %4 : index to i32 + affine.for %arg4 = #map(%arg2) to 32 { + %6 = arith.subi %arg4, %arg2 : index + %7 = arith.addi %3, %6 : index + %8 = arith.index_cast %arg4 : index to i32 + memref.store %1, %arg0[%7] : memref + memref.store %8, %arg1[%7] : memref + } + affine.yield %5 : i32 + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_triu_indices_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_triu_indices_cpu/raised.mlir new file mode 100644 index 000000000000..405f69398717 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_indices_cpu/raised.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg2 = 0 to 32 { + %0 = affine.load %alloca[] : memref + %1 = arith.index_cast %arg2 : index to i32 + %2 = arith.subi %c32, %arg2 : index + %3 = arith.index_cast %0 : i32 to index + %4 = arith.addi %3, %2 : index + %5 = arith.index_cast %4 : index to i32 + affine.for %arg3 = #map(%arg2) to 32 { + %6 = arith.subi %arg3, %arg2 : index + %7 = arith.addi %3, %6 : index + %8 = arith.index_cast %arg3 : index to i32 + memref.store %1, %arg0[%7] : memref + memref.store %8, %arg1[%7] : memref + } + affine.store %5, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_indices_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_triu_indices_cpu_debuf.mlir new file mode 100644 index 000000000000..33391b2dd898 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_indices_cpu_debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = tensor.empty() : tensor + %inserted = tensor.insert %c0_i32 into %2[] : tensor + %3:3 = affine.for %arg2 = 0 to 32 iter_args(%arg3 = %inserted, %arg4 = %1, %arg5 = %0) -> (tensor, tensor, tensor) { + %extracted = tensor.extract %arg3[] : tensor + %6 = arith.index_cast %arg2 : index to i32 + %7 = arith.subi %c32, %arg2 : index + %8 = arith.index_cast %extracted : i32 to index + %9 = arith.addi %8, %7 : index + %10 = arith.index_cast %9 : index to i32 + %11:2 = affine.for %arg6 = #map(%arg2) to 32 iter_args(%arg7 = %arg4, %arg8 = %arg5) -> (tensor, tensor) { + %12 = arith.subi %arg6, %arg2 : index + %13 = arith.addi %8, %12 : index + %14 = arith.index_cast %arg6 : index to i32 + %inserted_1 = tensor.insert %6 into %arg7[%13] : tensor + %inserted_2 = tensor.insert %14 into %arg8[%13] : tensor + affine.yield %inserted_1, %inserted_2 : tensor, tensor + } + %inserted_0 = tensor.insert %10 into %arg3[] : tensor + affine.yield %inserted_0, %11#0, %11#1 : tensor, tensor, tensor + } + %4 = bufferization.to_memref %3#2 : memref + memref.copy %4, %arg1 : memref to memref + %5 = bufferization.to_memref %3#1 : memref + memref.copy %5, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_indices_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_triu_indices_cpu_linalg.mlir new file mode 100644 index 000000000000..405f69398717 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_indices_cpu_linalg.mlir @@ -0,0 +1,27 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_indices_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg2 = 0 to 32 { + %0 = affine.load %alloca[] : memref + %1 = arith.index_cast %arg2 : index to i32 + %2 = arith.subi %c32, %arg2 : index + %3 = arith.index_cast %0 : i32 to index + %4 = arith.addi %3, %2 : index + %5 = arith.index_cast %4 : index to i32 + affine.for %arg3 = #map(%arg2) to 32 { + %6 = arith.subi %arg3, %arg2 : index + %7 = arith.addi %3, %6 : index + %8 = arith.index_cast %arg3 : index to i32 + memref.store %1, %arg0[%7] : memref + memref.store %8, %arg1[%7] : memref + } + affine.store %5, %alloca[] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_mask_cpu.mlir b/issues/aten_c_kernels/results/aten_triu_mask_cpu.mlir new file mode 100644 index 000000000000..8b35fdc336e9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_mask_cpu.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_mask_cpu(%arg0: memref, %arg1: i32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 32 { + %0 = arith.index_cast %arg2 : index to i32 + affine.for %arg3 = 0 to 32 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = arith.subi %1, %0 : i32 + %3 = arith.cmpi sge, %2, %arg1 : i32 + %4 = arith.extui %3 : i1 to i32 + affine.store %4, %arg0[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_triu_mask_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_triu_mask_cpu/debuf.mlir new file mode 100644 index 000000000000..bb215c4ad11b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_mask_cpu/debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_mask_cpu(%arg0: memref, %arg1: i32) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c32] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: i32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = linalg.index 1 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.subi %6, %4 : i32 + %8 = arith.cmpi sge, %7, %arg1 : i32 + %9 = arith.extui %8 : i1 to i32 + linalg.yield %9 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c32] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_mask_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_triu_mask_cpu/matched.mlir new file mode 100644 index 000000000000..bb215c4ad11b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_mask_cpu/matched.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_mask_cpu(%arg0: memref, %arg1: i32) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c32] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: i32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = linalg.index 1 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.subi %6, %4 : i32 + %8 = arith.cmpi sge, %7, %arg1 : i32 + %9 = arith.extui %8 : i1 to i32 + linalg.yield %9 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c32] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_mask_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_triu_mask_cpu/orig.mlir new file mode 100644 index 000000000000..8b35fdc336e9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_mask_cpu/orig.mlir @@ -0,0 +1,15 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_mask_cpu(%arg0: memref, %arg1: i32) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 32 { + %0 = arith.index_cast %arg2 : index to i32 + affine.for %arg3 = 0 to 32 { + %1 = arith.index_cast %arg3 : index to i32 + %2 = arith.subi %1, %0 : i32 + %3 = arith.cmpi sge, %2, %arg1 : i32 + %4 = arith.extui %3 : i1 to i32 + affine.store %4, %arg0[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_triu_mask_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_triu_mask_cpu/raised.mlir new file mode 100644 index 000000000000..d20f429201ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_mask_cpu/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_mask_cpu(%arg0: memref, %arg1: i32) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %subview = memref.subview %arg0[0, 0] [%c32, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: i32): + %0 = linalg.index 0 : index + %1 = arith.index_cast %0 : index to i32 + %2 = linalg.index 1 : index + %3 = arith.index_cast %2 : index to i32 + %4 = arith.subi %3, %1 : i32 + %5 = arith.cmpi sge, %4, %arg1 : i32 + %6 = arith.extui %5 : i1 to i32 + linalg.yield %6 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_mask_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_triu_mask_cpu_debuf.mlir new file mode 100644 index 000000000000..bb215c4ad11b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_mask_cpu_debuf.mlir @@ -0,0 +1,24 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_mask_cpu(%arg0: memref, %arg1: i32) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c32] [1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: i32): + %3 = linalg.index 0 : index + %4 = arith.index_cast %3 : index to i32 + %5 = linalg.index 1 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.subi %6, %4 : i32 + %8 = arith.cmpi sge, %7, %arg1 : i32 + %9 = arith.extui %8 : i1 to i32 + linalg.yield %9 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0] [%c32, %c32] [1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_mask_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_triu_mask_cpu_linalg.mlir new file mode 100644 index 000000000000..d20f429201ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_mask_cpu_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_mask_cpu(%arg0: memref, %arg1: i32) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %subview = memref.subview %arg0[0, 0] [%c32, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: i32): + %0 = linalg.index 0 : index + %1 = arith.index_cast %0 : index to i32 + %2 = linalg.index 1 : index + %3 = arith.index_cast %2 : index to i32 + %4 = arith.subi %3, %1 : i32 + %5 = arith.cmpi sge, %4, %arg1 : i32 + %6 = arith.extui %5 : i1 to i32 + linalg.yield %6 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu.mlir b/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu.mlir new file mode 100644 index 000000000000..208caacaea4a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_tril_batch_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg2, %c0_i32 : i32 + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 32 { + %1 = arith.index_cast %arg5 : index to i32 + affine.for %arg6 = 0 to 24 { + %2 = arith.index_cast %arg6 : index to i32 + %3 = scf.if %0 -> (i1) { + %5 = arith.subi %2, %1 : i32 + %6 = arith.cmpi sge, %5, %arg1 : i32 + scf.yield %6 : i1 + } else { + %5 = arith.subi %2, %1 : i32 + %6 = arith.cmpi sle, %5, %arg1 : i32 + scf.yield %6 : i1 + } + %4 = scf.if %3 -> (f32) { + %5 = affine.load %arg0[%arg4, %arg5, %arg6] : memref + scf.yield %5 : f32 + } else { + scf.yield %cst : f32 + } + affine.store %4, %arg3[%arg4, %arg5, %arg6] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu/debuf.mlir new file mode 100644 index 000000000000..18ef016704d6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu/debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_tril_batch_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = linalg.index 1 : index + %6 = arith.index_cast %5 : index to i32 + %7 = linalg.index 2 : index + %8 = arith.index_cast %7 : index to i32 + %9 = arith.subi %8, %6 : i32 + %10 = arith.cmpi sge, %9, %arg1 : i32 + %11 = arith.subi %8, %6 : i32 + %12 = arith.cmpi sle, %11, %arg1 : i32 + %13 = arith.select %2, %10, %12 : i1 + %14 = arith.select %13, %in, %cst : f32 + linalg.yield %14 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu/matched.mlir new file mode 100644 index 000000000000..18ef016704d6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu/matched.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_tril_batch_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = linalg.index 1 : index + %6 = arith.index_cast %5 : index to i32 + %7 = linalg.index 2 : index + %8 = arith.index_cast %7 : index to i32 + %9 = arith.subi %8, %6 : i32 + %10 = arith.cmpi sge, %9, %arg1 : i32 + %11 = arith.subi %8, %6 : i32 + %12 = arith.cmpi sle, %11, %arg1 : i32 + %13 = arith.select %2, %10, %12 : i1 + %14 = arith.select %13, %in, %cst : f32 + linalg.yield %14 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu/orig.mlir new file mode 100644 index 000000000000..208caacaea4a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu/orig.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_tril_batch_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg2, %c0_i32 : i32 + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 32 { + %1 = arith.index_cast %arg5 : index to i32 + affine.for %arg6 = 0 to 24 { + %2 = arith.index_cast %arg6 : index to i32 + %3 = scf.if %0 -> (i1) { + %5 = arith.subi %2, %1 : i32 + %6 = arith.cmpi sge, %5, %arg1 : i32 + scf.yield %6 : i1 + } else { + %5 = arith.subi %2, %1 : i32 + %6 = arith.cmpi sle, %5, %arg1 : i32 + scf.yield %6 : i1 + } + %4 = scf.if %3 -> (f32) { + %5 = affine.load %arg0[%arg4, %arg5, %arg6] : memref + scf.yield %5 : f32 + } else { + scf.yield %cst : f32 + } + affine.store %4, %arg3[%arg4, %arg5, %arg6] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu/raised.mlir new file mode 100644 index 000000000000..d7853306d8e9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu/raised.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_tril_batch_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %subview = memref.subview %arg0[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg3[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = linalg.index 1 : index + %2 = arith.index_cast %1 : index to i32 + %3 = linalg.index 2 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.subi %4, %2 : i32 + %6 = arith.cmpi sge, %5, %arg1 : i32 + %7 = arith.subi %4, %2 : i32 + %8 = arith.cmpi sle, %7, %arg1 : i32 + %9 = arith.select %0, %6, %8 : i1 + %10 = arith.select %9, %in, %cst : f32 + linalg.yield %10 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu_debuf.mlir new file mode 100644 index 000000000000..18ef016704d6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu_debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_tril_batch_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %extracted_slice = tensor.extract_slice %0[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = linalg.index 1 : index + %6 = arith.index_cast %5 : index to i32 + %7 = linalg.index 2 : index + %8 = arith.index_cast %7 : index to i32 + %9 = arith.subi %8, %6 : i32 + %10 = arith.cmpi sge, %9, %arg1 : i32 + %11 = arith.subi %8, %6 : i32 + %12 = arith.cmpi sle, %11, %arg1 : i32 + %13 = arith.select %2, %10, %12 : i1 + %14 = arith.select %13, %in, %cst : f32 + linalg.yield %14 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu_linalg.mlir new file mode 100644 index 000000000000..d7853306d8e9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_tril_batch_cpu_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_tril_batch_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %subview = memref.subview %arg0[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : memref to memref> + %subview_0 = memref.subview %arg3[0, 0, 0] [%c4, %c32, %c24] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = linalg.index 1 : index + %2 = arith.index_cast %1 : index to i32 + %3 = linalg.index 2 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.subi %4, %2 : i32 + %6 = arith.cmpi sge, %5, %arg1 : i32 + %7 = arith.subi %4, %2 : i32 + %8 = arith.cmpi sle, %7, %arg1 : i32 + %9 = arith.select %0, %6, %8 : i1 + %10 = arith.select %9, %in, %cst : f32 + linalg.yield %10 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_tril_single_cpu.mlir b/issues/aten_c_kernels/results/aten_triu_tril_single_cpu.mlir new file mode 100644 index 000000000000..6afe7c41293e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_tril_single_cpu.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_tril_single_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg2, %c0_i32 : i32 + affine.for %arg4 = 0 to 32 { + %1 = arith.index_cast %arg4 : index to i32 + affine.for %arg5 = 0 to 24 { + %2 = arith.index_cast %arg5 : index to i32 + %3 = scf.if %0 -> (i1) { + %5 = arith.subi %2, %1 : i32 + %6 = arith.cmpi sge, %5, %arg1 : i32 + scf.yield %6 : i1 + } else { + %5 = arith.subi %2, %1 : i32 + %6 = arith.cmpi sle, %5, %arg1 : i32 + scf.yield %6 : i1 + } + %4 = scf.if %3 -> (f32) { + %5 = affine.load %arg0[%arg4, %arg5] : memref + scf.yield %5 : f32 + } else { + scf.yield %cst : f32 + } + affine.store %4, %arg3[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_triu_tril_single_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_triu_tril_single_cpu/debuf.mlir new file mode 100644 index 000000000000..fff70f267afa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_tril_single_cpu/debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_tril_single_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = linalg.index 1 : index + %8 = arith.index_cast %7 : index to i32 + %9 = arith.subi %8, %6 : i32 + %10 = arith.cmpi sge, %9, %arg1 : i32 + %11 = arith.subi %8, %6 : i32 + %12 = arith.cmpi sle, %11, %arg1 : i32 + %13 = arith.select %2, %10, %12 : i1 + %14 = arith.select %13, %in, %cst : f32 + linalg.yield %14 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0] [%c32, %c24] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_tril_single_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_triu_tril_single_cpu/matched.mlir new file mode 100644 index 000000000000..fff70f267afa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_tril_single_cpu/matched.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_tril_single_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = linalg.index 1 : index + %8 = arith.index_cast %7 : index to i32 + %9 = arith.subi %8, %6 : i32 + %10 = arith.cmpi sge, %9, %arg1 : i32 + %11 = arith.subi %8, %6 : i32 + %12 = arith.cmpi sle, %11, %arg1 : i32 + %13 = arith.select %2, %10, %12 : i1 + %14 = arith.select %13, %in, %cst : f32 + linalg.yield %14 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0] [%c32, %c24] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_tril_single_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_triu_tril_single_cpu/orig.mlir new file mode 100644 index 000000000000..6afe7c41293e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_tril_single_cpu/orig.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_tril_single_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg2, %c0_i32 : i32 + affine.for %arg4 = 0 to 32 { + %1 = arith.index_cast %arg4 : index to i32 + affine.for %arg5 = 0 to 24 { + %2 = arith.index_cast %arg5 : index to i32 + %3 = scf.if %0 -> (i1) { + %5 = arith.subi %2, %1 : i32 + %6 = arith.cmpi sge, %5, %arg1 : i32 + scf.yield %6 : i1 + } else { + %5 = arith.subi %2, %1 : i32 + %6 = arith.cmpi sle, %5, %arg1 : i32 + scf.yield %6 : i1 + } + %4 = scf.if %3 -> (f32) { + %5 = affine.load %arg0[%arg4, %arg5] : memref + scf.yield %5 : f32 + } else { + scf.yield %cst : f32 + } + affine.store %4, %arg3[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_triu_tril_single_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_triu_tril_single_cpu/raised.mlir new file mode 100644 index 000000000000..c180dbb09c62 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_tril_single_cpu/raised.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_tril_single_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %subview = memref.subview %arg0[0, 0] [%c32, %c24] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg3[0, 0] [%c32, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = linalg.index 1 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.subi %4, %2 : i32 + %6 = arith.cmpi sge, %5, %arg1 : i32 + %7 = arith.subi %4, %2 : i32 + %8 = arith.cmpi sle, %7, %arg1 : i32 + %9 = arith.select %0, %6, %8 : i1 + %10 = arith.select %9, %in, %cst : f32 + linalg.yield %10 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_tril_single_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_triu_tril_single_cpu_debuf.mlir new file mode 100644 index 000000000000..fff70f267afa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_tril_single_cpu_debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_tril_single_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c24 = arith.constant 24 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c32, %c24] [1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = linalg.index 1 : index + %8 = arith.index_cast %7 : index to i32 + %9 = arith.subi %8, %6 : i32 + %10 = arith.cmpi sge, %9, %arg1 : i32 + %11 = arith.subi %8, %6 : i32 + %12 = arith.cmpi sle, %11, %arg1 : i32 + %13 = arith.select %2, %10, %12 : i1 + %14 = arith.select %13, %in, %cst : f32 + linalg.yield %14 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0] [%c32, %c24] [1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_triu_tril_single_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_triu_tril_single_cpu_linalg.mlir new file mode 100644 index 000000000000..c180dbb09c62 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_triu_tril_single_cpu_linalg.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_triu_tril_single_cpu(%arg0: memref, %arg1: i32, %arg2: i32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c24 = arith.constant 24 : index + %cst = arith.constant 0.000000e+00 : f32 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.cmpi ne, %arg2, %c0_i32 : i32 + %subview = memref.subview %arg0[0, 0] [%c32, %c24] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg3[0, 0] [%c32, %c24] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = linalg.index 1 : index + %4 = arith.index_cast %3 : index to i32 + %5 = arith.subi %4, %2 : i32 + %6 = arith.cmpi sge, %5, %arg1 : i32 + %7 = arith.subi %4, %2 : i32 + %8 = arith.cmpi sle, %7, %arg1 : i32 + %9 = arith.select %0, %6, %8 : i1 + %10 = arith.select %9, %in, %cst : f32 + linalg.yield %10 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_trunc.mlir b/issues/aten_c_kernels/results/aten_trunc.mlir new file mode 100644 index 000000000000..f9038e08718a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trunc.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trunc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @truncf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_trunc/debuf.mlir b/issues/aten_c_kernels/results/aten_trunc/debuf.mlir new file mode 100644 index 000000000000..7e85b88f6bbc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trunc/debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trunc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.trunc %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_trunc/matched.mlir b/issues/aten_c_kernels/results/aten_trunc/matched.mlir new file mode 100644 index 000000000000..7e85b88f6bbc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trunc/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trunc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.trunc %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_trunc/orig.mlir b/issues/aten_c_kernels/results/aten_trunc/orig.mlir new file mode 100644 index 000000000000..f9038e08718a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trunc/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trunc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4096 { + %0 = affine.load %arg0[%arg2] : memref + %1 = func.call @truncf(%0) : (f32) -> f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_trunc/raised.mlir b/issues/aten_c_kernels/results/aten_trunc/raised.mlir new file mode 100644 index 000000000000..f300873c20b9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trunc/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trunc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.trunc %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_trunc_debuf.mlir b/issues/aten_c_kernels/results/aten_trunc_debuf.mlir new file mode 100644 index 000000000000..7e85b88f6bbc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trunc_debuf.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trunc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %4 = math.trunc %in : f32 + linalg.yield %4 : f32 + } -> tensor + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_trunc_linalg.mlir b/issues/aten_c_kernels/results/aten_trunc_linalg.mlir new file mode 100644 index 000000000000..f300873c20b9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_trunc_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_trunc(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.trunc %in : f32 + linalg.yield %0 : f32 + } + return + } + func.func private @truncf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_unbind_copy_cpu.mlir b/issues/aten_c_kernels/results/aten_unbind_copy_cpu.mlir new file mode 100644 index 000000000000..7bd5c26b8997 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unbind_copy_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unbind_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unbind_copy_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_unbind_copy_cpu/debuf.mlir new file mode 100644 index 000000000000..e2c44e511f8d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unbind_copy_cpu/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unbind_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c4, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unbind_copy_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_unbind_copy_cpu/matched.mlir new file mode 100644 index 000000000000..6e36f4cb7856 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unbind_copy_cpu/matched.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unbind_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %2 = kernel.launch @cudaCopy2D_f32_tensor(%extracted_slice, %extracted_slice_0) : (tensor, tensor) -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c4, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unbind_copy_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_unbind_copy_cpu/orig.mlir new file mode 100644 index 000000000000..7bd5c26b8997 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unbind_copy_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unbind_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 4 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + affine.store %0, %arg1[%arg2, %arg3] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unbind_copy_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_unbind_copy_cpu/raised.mlir new file mode 100644 index 000000000000..1a9aad2a7ec4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unbind_copy_cpu/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unbind_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 0] [%c4, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c4, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unbind_copy_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_unbind_copy_cpu_debuf.mlir new file mode 100644 index 000000000000..e2c44e511f8d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unbind_copy_cpu_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unbind_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c64 = arith.constant 64 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %1[0, 0] [%c4, %c64] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0] [%c4, %c64] [1, 1] : tensor into tensor + %3 = bufferization.to_memref %inserted_slice : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unbind_copy_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_unbind_copy_cpu_linalg.mlir new file mode 100644 index 000000000000..1a9aad2a7ec4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unbind_copy_cpu_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unbind_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c64 = arith.constant 64 : index + %subview = memref.subview %arg0[0, 0] [%c4, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0, 0] [%c4, %c64] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu.mlir b/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu.mlir new file mode 100644 index 000000000000..56e56e7db319 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 1440 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 6 { + affine.for %arg4 = 0 to 7 { + affine.for %arg5 = 0 to 8 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + %1 = affine.load %arg0[%arg2, %arg6, %arg7, %arg8, %arg3, %arg4, %arg5] : memref + %2 = affine.load %arg1[%arg2, %arg3 + %arg6, %arg4 + %arg7, %arg5 + %arg8] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3 + %arg6, %arg4 + %arg7, %arg5 + %arg8] : memref + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu/debuf.mlir new file mode 100644 index 000000000000..f52a080ec429 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6, d1, d2, d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 1440 { + %2 = arith.index_cast %arg2 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg1, %c2, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.addf %out, %in : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu/matched.mlir new file mode 100644 index 000000000000..f52a080ec429 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu/matched.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6, d1, d2, d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 1440 { + %2 = arith.index_cast %arg2 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg1, %c2, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.addf %out, %in : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu/orig.mlir new file mode 100644 index 000000000000..56e56e7db319 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu/orig.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 1440 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 6 { + affine.for %arg4 = 0 to 7 { + affine.for %arg5 = 0 to 8 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + %1 = affine.load %arg0[%arg2, %arg6, %arg7, %arg8, %arg3, %arg4, %arg5] : memref + %2 = affine.load %arg1[%arg2, %arg3 + %arg6, %arg4 + %arg7, %arg5 + %arg8] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3 + %arg6, %arg4 + %arg7, %arg5 + %arg8] : memref + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu/raised.mlir new file mode 100644 index 000000000000..f52a080ec429 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu/raised.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6, d1, d2, d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 1440 { + %2 = arith.index_cast %arg2 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg1, %c2, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.addf %out, %in : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu_debuf.mlir new file mode 100644 index 000000000000..f52a080ec429 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6, d1, d2, d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 1440 { + %2 = arith.index_cast %arg2 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg1, %c2, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.addf %out, %in : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu_linalg.mlir new file mode 100644 index 000000000000..f52a080ec429 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_acc_cpu_linalg.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6, d1, d2, d3)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 1440 { + %2 = arith.index_cast %arg2 : index to i32 + %3 = llvm.getelementptr %0[%2] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %3 : f32, !llvm.ptr + } + %subview = memref.subview %arg0[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : memref to memref> + %1 = polygeist.submap(%arg1, %c2, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview : memref>) outs(%1 : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.addf %out, %in : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu.mlir b/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu.mlir new file mode 100644 index 000000000000..1f02d1b910ae --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 6 { + affine.for %arg4 = 0 to 7 { + affine.for %arg5 = 0 to 8 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + %0 = affine.load %arg0[%arg2, %arg3 + %arg6, %arg4 + %arg7, %arg5 + %arg8] : memref + affine.store %0, %arg1[%arg2, %arg6, %arg7, %arg8, %arg3, %arg4, %arg5] : memref + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu/debuf.mlir new file mode 100644 index 000000000000..c2d6eab27dca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu/debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c6 = arith.constant 6 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (tensor, index, index, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu/matched.mlir new file mode 100644 index 000000000000..c2d6eab27dca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c6 = arith.constant 6 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (tensor, index, index, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu/orig.mlir new file mode 100644 index 000000000000..1f02d1b910ae --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu/orig.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 6 { + affine.for %arg4 = 0 to 7 { + affine.for %arg5 = 0 to 8 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + %0 = affine.load %arg0[%arg2, %arg3 + %arg6, %arg4 + %arg7, %arg5 + %arg8] : memref + affine.store %0, %arg1[%arg2, %arg6, %arg7, %arg8, %arg3, %arg4, %arg5] : memref + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu/raised.mlir new file mode 100644 index 000000000000..de509d1f9288 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu/raised.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %0 = polygeist.submap(%arg0, %c2, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu_debuf.mlir new file mode 100644 index 000000000000..c2d6eab27dca --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c6 = arith.constant 6 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (tensor, index, index, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu_linalg.mlir new file mode 100644 index 000000000000..de509d1f9288 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_copy_cpu_linalg.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1, d5 + d2, d6 + d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %0 = polygeist.submap(%arg0, %c2, %c6, %c7, %c8, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c6, %c7, %c8] [1, 1, 1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu.mlir b/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu.mlir new file mode 100644 index 000000000000..b671ffc6efe0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu.mlir @@ -0,0 +1,33 @@ +#set = affine_set<(d0, d1, d2, d3, d4, d5) : (-d0 - d1 + 10 >= 0, d0 + d1 - 1 >= 0, -d2 - d3 + 9 >= 0, d2 + d3 - 1 >= 0, d4 + d5 - 1 >= 0, -d4 - d5 + 8 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_zero_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 1440 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 9 { + affine.for %arg5 = 0 to 10 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + affine.if #set(%arg8, %arg5, %arg7, %arg4, %arg3, %arg6) { + %1 = affine.load %arg0[%arg2, %arg6, %arg7, %arg8, %arg3, %arg4, %arg5] : memref + %2 = affine.load %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/debuf.mlir new file mode 100644 index 000000000000..5785c5fd8d97 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/debuf.mlir @@ -0,0 +1,34 @@ +#set = affine_set<(d0, d1, d2, d3, d4, d5) : (-d0 - d1 + 10 >= 0, d0 + d1 - 1 >= 0, -d2 - d3 + 9 >= 0, d2 + d3 - 1 >= 0, d4 + d5 - 1 >= 0, -d4 - d5 + 8 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_zero_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 1440 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 9 { + affine.for %arg5 = 0 to 10 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + affine.if #set(%arg8, %arg5, %arg7, %arg4, %arg3, %arg6) { + %1 = affine.load %arg0[%arg2, %arg6, %arg7, %arg8, %arg3, %arg4, %arg5] : memref + %2 = affine.load %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } + } + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/matched.mlir new file mode 100644 index 000000000000..5785c5fd8d97 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/matched.mlir @@ -0,0 +1,34 @@ +#set = affine_set<(d0, d1, d2, d3, d4, d5) : (-d0 - d1 + 10 >= 0, d0 + d1 - 1 >= 0, -d2 - d3 + 9 >= 0, d2 + d3 - 1 >= 0, d4 + d5 - 1 >= 0, -d4 - d5 + 8 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_zero_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 1440 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 9 { + affine.for %arg5 = 0 to 10 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + affine.if #set(%arg8, %arg5, %arg7, %arg4, %arg3, %arg6) { + %1 = affine.load %arg0[%arg2, %arg6, %arg7, %arg8, %arg3, %arg4, %arg5] : memref + %2 = affine.load %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } + } + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/orig.mlir new file mode 100644 index 000000000000..b671ffc6efe0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/orig.mlir @@ -0,0 +1,33 @@ +#set = affine_set<(d0, d1, d2, d3, d4, d5) : (-d0 - d1 + 10 >= 0, d0 + d1 - 1 >= 0, -d2 - d3 + 9 >= 0, d2 + d3 - 1 >= 0, d4 + d5 - 1 >= 0, -d4 - d5 + 8 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_zero_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 1440 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 9 { + affine.for %arg5 = 0 to 10 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + affine.if #set(%arg8, %arg5, %arg7, %arg4, %arg3, %arg6) { + %1 = affine.load %arg0[%arg2, %arg6, %arg7, %arg8, %arg3, %arg4, %arg5] : memref + %2 = affine.load %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + } + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/raise.err b/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/raise.err new file mode 100644 index 000000000000..17862320e6e2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/raise.err @@ -0,0 +1,68 @@ +/home/arjaiswal/Polygeist/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/orig.mlir:3:3: warning: Distribute+Raising didn't converge, continuing anyway + func.func @aten_unfold3d_zero_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +/home/arjaiswal/Polygeist/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/orig.mlir:3:3: note: see current operation: +func.func @aten_unfold3d_zero_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 1440 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 9 { + affine.for %arg5 = 0 to 10 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + affine.if affine_set<(d0, d1, d2, d3, d4, d5) : (-d0 - d1 + 10 >= 0, d0 + d1 - 1 >= 0, -d2 - d3 + 9 >= 0, d2 + d3 - 1 >= 0, d4 + d5 - 1 >= 0, -d4 - d5 + 8 >= 0)>(%arg8, %arg5, %arg7, %arg4, %arg3, %arg6) { + %1 = affine.load %arg0[%arg2, %arg6, %arg7, %arg8, %arg3, %arg4, %arg5] : memref + %2 = affine.load %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } + } + } + } {polygeist.was_parallel} + return +} +/home/arjaiswal/Polygeist/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/orig.mlir:3:3: warning: scalar reduction fusion didn't converge, continuing anyway + func.func @aten_unfold3d_zero_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +/home/arjaiswal/Polygeist/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/orig.mlir:3:3: note: see current operation: +func.func @aten_unfold3d_zero_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 1440 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 9 { + affine.for %arg5 = 0 to 10 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + affine.if affine_set<(d0, d1, d2, d3, d4, d5) : (-d0 - d1 + 10 >= 0, d0 + d1 - 1 >= 0, -d2 - d3 + 9 >= 0, d2 + d3 - 1 >= 0, d4 + d5 - 1 >= 0, -d4 - d5 + 8 >= 0)>(%arg8, %arg5, %arg7, %arg4, %arg3, %arg6) { + %1 = affine.load %arg0[%arg2, %arg6, %arg7, %arg8, %arg3, %arg4, %arg5] : memref + %2 = affine.load %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } + } + } + } {polygeist.was_parallel} + return +} diff --git a/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/raised.mlir new file mode 100644 index 000000000000..5785c5fd8d97 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu/raised.mlir @@ -0,0 +1,34 @@ +#set = affine_set<(d0, d1, d2, d3, d4, d5) : (-d0 - d1 + 10 >= 0, d0 + d1 - 1 >= 0, -d2 - d3 + 9 >= 0, d2 + d3 - 1 >= 0, d4 + d5 - 1 >= 0, -d4 - d5 + 8 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_zero_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 1440 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 9 { + affine.for %arg5 = 0 to 10 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + affine.if #set(%arg8, %arg5, %arg7, %arg4, %arg3, %arg6) { + %1 = affine.load %arg0[%arg2, %arg6, %arg7, %arg8, %arg3, %arg4, %arg5] : memref + %2 = affine.load %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } + } + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu_debuf.mlir new file mode 100644 index 000000000000..5785c5fd8d97 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu_debuf.mlir @@ -0,0 +1,34 @@ +#set = affine_set<(d0, d1, d2, d3, d4, d5) : (-d0 - d1 + 10 >= 0, d0 + d1 - 1 >= 0, -d2 - d3 + 9 >= 0, d2 + d3 - 1 >= 0, d4 + d5 - 1 >= 0, -d4 - d5 + 8 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_zero_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 1440 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 9 { + affine.for %arg5 = 0 to 10 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + affine.if #set(%arg8, %arg5, %arg7, %arg4, %arg3, %arg6) { + %1 = affine.load %arg0[%arg2, %arg6, %arg7, %arg8, %arg3, %arg4, %arg5] : memref + %2 = affine.load %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } + } + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu_linalg.mlir new file mode 100644 index 000000000000..5785c5fd8d97 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_zero_acc_cpu_linalg.mlir @@ -0,0 +1,34 @@ +#set = affine_set<(d0, d1, d2, d3, d4, d5) : (-d0 - d1 + 10 >= 0, d0 + d1 - 1 >= 0, -d2 - d3 + 9 >= 0, d2 + d3 - 1 >= 0, d4 + d5 - 1 >= 0, -d4 - d5 + 8 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_zero_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = "polygeist.memref2pointer"(%arg1) : (memref) -> !llvm.ptr + affine.for %arg2 = 0 to 1440 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = llvm.getelementptr %0[%1] : (!llvm.ptr, i32) -> !llvm.ptr, f32 + llvm.store %cst, %2 : f32, !llvm.ptr + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 9 { + affine.for %arg5 = 0 to 10 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + affine.if #set(%arg8, %arg5, %arg7, %arg4, %arg3, %arg6) { + %1 = affine.load %arg0[%arg2, %arg6, %arg7, %arg8, %arg3, %arg4, %arg5] : memref + %2 = affine.load %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + %3 = arith.addf %2, %1 : f32 + affine.store %3, %arg1[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } + } + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu.mlir b/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu.mlir new file mode 100644 index 000000000000..2c04f2fdf9c1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu.mlir @@ -0,0 +1,28 @@ +#set = affine_set<(d0, d1, d2, d3, d4, d5) : (-d0 - d1 + 10 >= 0, d0 + d1 - 1 >= 0, -d2 - d3 + 9 >= 0, d2 + d3 - 1 >= 0, d4 + d5 - 1 >= 0, -d4 - d5 + 8 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_zero_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 9 { + affine.for %arg5 = 0 to 10 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + %0 = affine.if #set(%arg8, %arg5, %arg7, %arg4, %arg3, %arg6) -> f32 { + %1 = affine.load %arg0[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + affine.yield %1 : f32 + } else { + affine.yield %cst : f32 + } + affine.store %0, %arg1[%arg2, %arg6, %arg7, %arg8, %arg3, %arg4, %arg5] : memref + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu/debuf.mlir new file mode 100644 index 000000000000..f5606757bc21 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu/debuf.mlir @@ -0,0 +1,57 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1 - 1, d5 + d2 - 1, d6 + d3 - 1)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6, d1, d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (-d0 - d1 + 10)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0 + d1 - 1)> +#map5 = affine_map<(d0, d1, d2, d3, d4, d5) -> (-d2 - d3 + 9)> +#map6 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d2 + d3 - 1)> +#map7 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d4 + d5 - 1)> +#map8 = affine_map<(d0, d1, d2, d3, d4, d5) -> (-d4 - d5 + 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_zero_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c3 = arith.constant 3 : index + %c10 = arith.constant 10 : index + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c8, %c9, %c10, %c3, %c3, %c3) {map = #map} : (tensor, index, index, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c8, %c9, %c10] [1, 1, 1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = linalg.index 1 : index + %6 = linalg.index 2 : index + %7 = linalg.index 3 : index + %8 = linalg.index 4 : index + %9 = linalg.index 5 : index + %10 = linalg.index 6 : index + %11 = affine.apply #map3(%10, %7, %9, %6, %5, %8) + %12 = arith.cmpi sge, %11, %c0 : index + %13 = affine.apply #map4(%10, %7, %9, %6, %5, %8) + %14 = arith.cmpi sge, %13, %c0 : index + %15 = arith.andi %12, %14 : i1 + %16 = affine.apply #map5(%10, %7, %9, %6, %5, %8) + %17 = arith.cmpi sge, %16, %c0 : index + %18 = arith.andi %15, %17 : i1 + %19 = affine.apply #map6(%10, %7, %9, %6, %5, %8) + %20 = arith.cmpi sge, %19, %c0 : index + %21 = arith.andi %18, %20 : i1 + %22 = affine.apply #map7(%10, %7, %9, %6, %5, %8) + %23 = arith.cmpi sge, %22, %c0 : index + %24 = arith.andi %21, %23 : i1 + %25 = affine.apply #map8(%10, %7, %9, %6, %5, %8) + %26 = arith.cmpi sge, %25, %c0 : index + %27 = arith.andi %24, %26 : i1 + %28 = arith.select %27, %in, %cst : f32 + linalg.yield %28 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c8, %c9, %c10] [1, 1, 1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu/matched.mlir new file mode 100644 index 000000000000..f5606757bc21 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu/matched.mlir @@ -0,0 +1,57 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1 - 1, d5 + d2 - 1, d6 + d3 - 1)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6, d1, d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (-d0 - d1 + 10)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0 + d1 - 1)> +#map5 = affine_map<(d0, d1, d2, d3, d4, d5) -> (-d2 - d3 + 9)> +#map6 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d2 + d3 - 1)> +#map7 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d4 + d5 - 1)> +#map8 = affine_map<(d0, d1, d2, d3, d4, d5) -> (-d4 - d5 + 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_zero_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c3 = arith.constant 3 : index + %c10 = arith.constant 10 : index + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c8, %c9, %c10, %c3, %c3, %c3) {map = #map} : (tensor, index, index, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c8, %c9, %c10] [1, 1, 1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = linalg.index 1 : index + %6 = linalg.index 2 : index + %7 = linalg.index 3 : index + %8 = linalg.index 4 : index + %9 = linalg.index 5 : index + %10 = linalg.index 6 : index + %11 = affine.apply #map3(%10, %7, %9, %6, %5, %8) + %12 = arith.cmpi sge, %11, %c0 : index + %13 = affine.apply #map4(%10, %7, %9, %6, %5, %8) + %14 = arith.cmpi sge, %13, %c0 : index + %15 = arith.andi %12, %14 : i1 + %16 = affine.apply #map5(%10, %7, %9, %6, %5, %8) + %17 = arith.cmpi sge, %16, %c0 : index + %18 = arith.andi %15, %17 : i1 + %19 = affine.apply #map6(%10, %7, %9, %6, %5, %8) + %20 = arith.cmpi sge, %19, %c0 : index + %21 = arith.andi %18, %20 : i1 + %22 = affine.apply #map7(%10, %7, %9, %6, %5, %8) + %23 = arith.cmpi sge, %22, %c0 : index + %24 = arith.andi %21, %23 : i1 + %25 = affine.apply #map8(%10, %7, %9, %6, %5, %8) + %26 = arith.cmpi sge, %25, %c0 : index + %27 = arith.andi %24, %26 : i1 + %28 = arith.select %27, %in, %cst : f32 + linalg.yield %28 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c8, %c9, %c10] [1, 1, 1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu/orig.mlir new file mode 100644 index 000000000000..2c04f2fdf9c1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu/orig.mlir @@ -0,0 +1,28 @@ +#set = affine_set<(d0, d1, d2, d3, d4, d5) : (-d0 - d1 + 10 >= 0, d0 + d1 - 1 >= 0, -d2 - d3 + 9 >= 0, d2 + d3 - 1 >= 0, d4 + d5 - 1 >= 0, -d4 - d5 + 8 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_zero_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 9 { + affine.for %arg5 = 0 to 10 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + %0 = affine.if #set(%arg8, %arg5, %arg7, %arg4, %arg3, %arg6) -> f32 { + %1 = affine.load %arg0[%arg2, %arg3 + %arg6 - 1, %arg4 + %arg7 - 1, %arg5 + %arg8 - 1] : memref + affine.yield %1 : f32 + } else { + affine.yield %cst : f32 + } + affine.store %0, %arg1[%arg2, %arg6, %arg7, %arg8, %arg3, %arg4, %arg5] : memref + } + } + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu/raised.mlir new file mode 100644 index 000000000000..b0c0f0b67ec7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu/raised.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1 - 1, d5 + d2 - 1, d6 + d3 - 1)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6, d1, d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (-d0 - d1 + 10)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0 + d1 - 1)> +#map5 = affine_map<(d0, d1, d2, d3, d4, d5) -> (-d2 - d3 + 9)> +#map6 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d2 + d3 - 1)> +#map7 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d4 + d5 - 1)> +#map8 = affine_map<(d0, d1, d2, d3, d4, d5) -> (-d4 - d5 + 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_zero_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %c9 = arith.constant 9 : index + %c10 = arith.constant 10 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = polygeist.submap(%arg0, %c2, %c8, %c9, %c10, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c8, %c9, %c10] [1, 1, 1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = linalg.index 1 : index + %2 = linalg.index 2 : index + %3 = linalg.index 3 : index + %4 = linalg.index 4 : index + %5 = linalg.index 5 : index + %6 = linalg.index 6 : index + %7 = affine.apply #map3(%6, %3, %5, %2, %1, %4) + %8 = arith.cmpi sge, %7, %c0 : index + %9 = affine.apply #map4(%6, %3, %5, %2, %1, %4) + %10 = arith.cmpi sge, %9, %c0 : index + %11 = arith.andi %8, %10 : i1 + %12 = affine.apply #map5(%6, %3, %5, %2, %1, %4) + %13 = arith.cmpi sge, %12, %c0 : index + %14 = arith.andi %11, %13 : i1 + %15 = affine.apply #map6(%6, %3, %5, %2, %1, %4) + %16 = arith.cmpi sge, %15, %c0 : index + %17 = arith.andi %14, %16 : i1 + %18 = affine.apply #map7(%6, %3, %5, %2, %1, %4) + %19 = arith.cmpi sge, %18, %c0 : index + %20 = arith.andi %17, %19 : i1 + %21 = affine.apply #map8(%6, %3, %5, %2, %1, %4) + %22 = arith.cmpi sge, %21, %c0 : index + %23 = arith.andi %20, %22 : i1 + %24 = arith.select %23, %in, %cst : f32 + linalg.yield %24 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu_debuf.mlir new file mode 100644 index 000000000000..f5606757bc21 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu_debuf.mlir @@ -0,0 +1,57 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1 - 1, d5 + d2 - 1, d6 + d3 - 1)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6, d1, d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (-d0 - d1 + 10)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0 + d1 - 1)> +#map5 = affine_map<(d0, d1, d2, d3, d4, d5) -> (-d2 - d3 + 9)> +#map6 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d2 + d3 - 1)> +#map7 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d4 + d5 - 1)> +#map8 = affine_map<(d0, d1, d2, d3, d4, d5) -> (-d4 - d5 + 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_zero_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c3 = arith.constant 3 : index + %c10 = arith.constant 10 : index + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c8, %c9, %c10, %c3, %c3, %c3) {map = #map} : (tensor, index, index, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c8, %c9, %c10] [1, 1, 1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = linalg.index 1 : index + %6 = linalg.index 2 : index + %7 = linalg.index 3 : index + %8 = linalg.index 4 : index + %9 = linalg.index 5 : index + %10 = linalg.index 6 : index + %11 = affine.apply #map3(%10, %7, %9, %6, %5, %8) + %12 = arith.cmpi sge, %11, %c0 : index + %13 = affine.apply #map4(%10, %7, %9, %6, %5, %8) + %14 = arith.cmpi sge, %13, %c0 : index + %15 = arith.andi %12, %14 : i1 + %16 = affine.apply #map5(%10, %7, %9, %6, %5, %8) + %17 = arith.cmpi sge, %16, %c0 : index + %18 = arith.andi %15, %17 : i1 + %19 = affine.apply #map6(%10, %7, %9, %6, %5, %8) + %20 = arith.cmpi sge, %19, %c0 : index + %21 = arith.andi %18, %20 : i1 + %22 = affine.apply #map7(%10, %7, %9, %6, %5, %8) + %23 = arith.cmpi sge, %22, %c0 : index + %24 = arith.andi %21, %23 : i1 + %25 = affine.apply #map8(%10, %7, %9, %6, %5, %8) + %26 = arith.cmpi sge, %25, %c0 : index + %27 = arith.andi %24, %26 : i1 + %28 = arith.select %27, %in, %cst : f32 + linalg.yield %28 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c8, %c9, %c10] [1, 1, 1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu_linalg.mlir new file mode 100644 index 000000000000..b0c0f0b67ec7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold3d_zero_copy_cpu_linalg.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4 + d1 - 1, d5 + d2 - 1, d6 + d3 - 1)> +#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6, d1, d2, d3)> +#map3 = affine_map<(d0, d1, d2, d3, d4, d5) -> (-d0 - d1 + 10)> +#map4 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0 + d1 - 1)> +#map5 = affine_map<(d0, d1, d2, d3, d4, d5) -> (-d2 - d3 + 9)> +#map6 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d2 + d3 - 1)> +#map7 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d4 + d5 - 1)> +#map8 = affine_map<(d0, d1, d2, d3, d4, d5) -> (-d4 - d5 + 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold3d_zero_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c8 = arith.constant 8 : index + %c9 = arith.constant 9 : index + %c10 = arith.constant 10 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 0.000000e+00 : f32 + %0 = polygeist.submap(%arg0, %c2, %c8, %c9, %c10, %c3, %c3, %c3) {map = #map} : (memref, index, index, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0, 0, 0, 0] [%c2, %c3, %c3, %c3, %c8, %c9, %c10] [1, 1, 1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + %1 = linalg.index 1 : index + %2 = linalg.index 2 : index + %3 = linalg.index 3 : index + %4 = linalg.index 4 : index + %5 = linalg.index 5 : index + %6 = linalg.index 6 : index + %7 = affine.apply #map3(%6, %3, %5, %2, %1, %4) + %8 = arith.cmpi sge, %7, %c0 : index + %9 = affine.apply #map4(%6, %3, %5, %2, %1, %4) + %10 = arith.cmpi sge, %9, %c0 : index + %11 = arith.andi %8, %10 : i1 + %12 = affine.apply #map5(%6, %3, %5, %2, %1, %4) + %13 = arith.cmpi sge, %12, %c0 : index + %14 = arith.andi %11, %13 : i1 + %15 = affine.apply #map6(%6, %3, %5, %2, %1, %4) + %16 = arith.cmpi sge, %15, %c0 : index + %17 = arith.andi %14, %16 : i1 + %18 = affine.apply #map7(%6, %3, %5, %2, %1, %4) + %19 = arith.cmpi sge, %18, %c0 : index + %20 = arith.andi %17, %19 : i1 + %21 = affine.apply #map8(%6, %3, %5, %2, %1, %4) + %22 = arith.cmpi sge, %21, %c0 : index + %23 = arith.andi %20, %22 : i1 + %24 = arith.select %23, %in, %cst : f32 + linalg.yield %24 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_unfold_backward_cpu.mlir new file mode 100644 index 000000000000..a0d3c89270b2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold_backward_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 128 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 32 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + %1 = affine.load %arg1[%arg3 + %arg2 * 2] : memref + %2 = arith.addf %1, %0 : f32 + affine.store %2, %arg1[%arg3 + %arg2 * 2] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unfold_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_unfold_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..0fdeaf01ee88 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold_backward_cpu/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1 + d0 * 2)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %3 = polygeist.submap(%2, %c32, %c64) {map = #map1} : (tensor, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = arith.addf %out, %in : f32 + linalg.yield %7 : f32 + } -> tensor + %5 = polygeist.submapInverse(%2, %4, %c32, %c64) {map = #map1} : (tensor, tensor, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_unfold_backward_cpu/matched.mlir new file mode 100644 index 000000000000..1fa08183ffb1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold_backward_cpu/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1 + d0 * 2)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = kernel.launch @memset_zero_1D_f32(%1) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %3 = polygeist.submap(%2, %c32, %c64) {map = #map1} : (tensor, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = arith.addf %out, %in : f32 + linalg.yield %7 : f32 + } -> tensor + %5 = polygeist.submapInverse(%2, %4, %c32, %c64) {map = #map1} : (tensor, tensor, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_unfold_backward_cpu/orig.mlir new file mode 100644 index 000000000000..a0d3c89270b2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold_backward_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 128 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 32 { + affine.for %arg3 = 0 to 64 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + %1 = affine.load %arg1[%arg3 + %arg2 * 2] : memref + %2 = arith.addf %1, %0 : f32 + affine.store %2, %arg1[%arg3 + %arg2 * 2] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unfold_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_unfold_backward_cpu/raised.mlir new file mode 100644 index 000000000000..b383a3161955 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold_backward_cpu/raised.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1 + d0 * 2)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %0 = polygeist.submap(%arg1, %c32, %c64) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%0 : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.addf %out, %in : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_unfold_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..0fdeaf01ee88 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold_backward_cpu_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1 + d0 * 2)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %3 = polygeist.submap(%2, %c32, %c64) {map = #map1} : (tensor, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%extracted_slice : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = arith.addf %out, %in : f32 + linalg.yield %7 : f32 + } -> tensor + %5 = polygeist.submapInverse(%2, %4, %c32, %c64) {map = #map1} : (tensor, tensor, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfold_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_unfold_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..b383a3161955 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfold_backward_cpu_linalg.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1 + d0 * 2)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfold_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %0 = polygeist.submap(%arg1, %c32, %c64) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%0 : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.addf %out, %in : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu.mlir b/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu.mlir new file mode 100644 index 000000000000..15b67ba07acf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfolded2d_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 8 { + affine.store %cst, %arg1[%arg2, %arg3, %arg4] : memref + } + } + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 6 { + affine.for %arg6 = 0 to 6 { + %0 = affine.load %arg0[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + %1 = affine.load %arg1[%arg2, %arg5 + %arg3, %arg6 + %arg4] : memref + %2 = arith.addf %1, %0 : f32 + affine.store %2, %arg1[%arg2, %arg5 + %arg3, %arg6 + %arg4] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu/debuf.mlir new file mode 100644 index 000000000000..a514d5853efe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu/debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfolded2d_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0] [%c2, %c8, %c8] [1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0, 0] [%c2, %c8, %c8] [1, 1, 1] : tensor into tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1] : tensor to tensor + %3 = polygeist.submap(%inserted_slice, %c2, %c3, %c3, %c6, %c6) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = arith.addf %out, %in : f32 + linalg.yield %7 : f32 + } -> tensor + %5 = polygeist.submapInverse(%inserted_slice, %4, %c2, %c3, %c3, %c6, %c6) {map = #map1} : (tensor, tensor, index, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu/matched.mlir new file mode 100644 index 000000000000..a514d5853efe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu/matched.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfolded2d_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0] [%c2, %c8, %c8] [1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0, 0] [%c2, %c8, %c8] [1, 1, 1] : tensor into tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1] : tensor to tensor + %3 = polygeist.submap(%inserted_slice, %c2, %c3, %c3, %c6, %c6) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = arith.addf %out, %in : f32 + linalg.yield %7 : f32 + } -> tensor + %5 = polygeist.submapInverse(%inserted_slice, %4, %c2, %c3, %c3, %c6, %c6) {map = #map1} : (tensor, tensor, index, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu/orig.mlir new file mode 100644 index 000000000000..15b67ba07acf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu/orig.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfolded2d_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 8 { + affine.for %arg4 = 0 to 8 { + affine.store %cst, %arg1[%arg2, %arg3, %arg4] : memref + } + } + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 6 { + affine.for %arg6 = 0 to 6 { + %0 = affine.load %arg0[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + %1 = affine.load %arg1[%arg2, %arg5 + %arg3, %arg6 + %arg4] : memref + %2 = arith.addf %1, %0 : f32 + affine.store %2, %arg1[%arg2, %arg5 + %arg3, %arg6 + %arg4] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu/raised.mlir new file mode 100644 index 000000000000..bd9a0a73d6f8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu/raised.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfolded2d_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg1[0, 0, 0] [%c2, %c8, %c8] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1] : memref to memref> + %0 = polygeist.submap(%arg1, %c2, %c3, %c3, %c6, %c6) {map = #map1} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview_0 : memref>) outs(%0 : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.addf %out, %in : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu_debuf.mlir new file mode 100644 index 000000000000..a514d5853efe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu_debuf.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfolded2d_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %1[0, 0, 0] [%c2, %c8, %c8] [1, 1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %1[0, 0, 0] [%c2, %c8, %c8] [1, 1, 1] : tensor into tensor + %extracted_slice_0 = tensor.extract_slice %0[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1] : tensor to tensor + %3 = polygeist.submap(%inserted_slice, %c2, %c3, %c3, %c6, %c6) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%3 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = arith.addf %out, %in : f32 + linalg.yield %7 : f32 + } -> tensor + %5 = polygeist.submapInverse(%inserted_slice, %4, %c2, %c3, %c3, %c6, %c6) {map = #map1} : (tensor, tensor, index, index, index, index, index) -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu_linalg.mlir new file mode 100644 index 000000000000..bd9a0a73d6f8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfolded2d_acc_cpu_linalg.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfolded2d_acc_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg1[0, 0, 0] [%c2, %c8, %c8] [1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview_0 = memref.subview %arg0[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1] : memref to memref> + %0 = polygeist.submap(%arg1, %c2, %c3, %c3, %c6, %c6) {map = #map1} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%subview_0 : memref>) outs(%0 : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.addf %out, %in : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu.mlir b/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu.mlir new file mode 100644 index 000000000000..449febff89d1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfolded2d_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 6 { + affine.for %arg6 = 0 to 6 { + %0 = affine.load %arg0[%arg2, %arg5 + %arg3, %arg6 + %arg4] : memref + affine.store %0, %arg1[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu/debuf.mlir new file mode 100644 index 000000000000..dc3c87333ff8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu/debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfolded2d_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c3, %c3, %c6, %c6) {map = #map} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu/matched.mlir new file mode 100644 index 000000000000..dc3c87333ff8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu/matched.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfolded2d_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c3, %c3, %c6, %c6) {map = #map} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu/orig.mlir new file mode 100644 index 000000000000..449febff89d1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu/orig.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfolded2d_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 3 { + affine.for %arg5 = 0 to 6 { + affine.for %arg6 = 0 to 6 { + %0 = affine.load %arg0[%arg2, %arg5 + %arg3, %arg6 + %arg4] : memref + affine.store %0, %arg1[%arg2, %arg3, %arg4, %arg5, %arg6] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu/raised.mlir new file mode 100644 index 000000000000..1daf24496c17 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu/raised.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfolded2d_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %0 = polygeist.submap(%arg0, %c2, %c3, %c3, %c6, %c6) {map = #map} : (memref, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu_debuf.mlir new file mode 100644 index 000000000000..dc3c87333ff8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu_debuf.mlir @@ -0,0 +1,22 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfolded2d_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = polygeist.submap(%0, %c2, %c3, %c3, %c6, %c6) {map = #map} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice = tensor.extract_slice %1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%2 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu_linalg.mlir new file mode 100644 index 000000000000..1daf24496c17 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unfolded2d_copy_cpu_linalg.mlir @@ -0,0 +1,17 @@ +#map = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3 + d1, d4 + d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unfolded2d_copy_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %0 = polygeist.submap(%arg0, %c2, %c3, %c3, %c6, %c6) {map = #map} : (memref, index, index, index, index, index) -> memref + %subview = memref.subview %arg1[0, 0, 0, 0, 0] [%c2, %c3, %c3, %c6, %c6] [1, 1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%subview : memref>) { + ^bb0(%in: f32, %out: f32): + linalg.yield %in : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_uniform_cpu.mlir b/issues/aten_c_kernels/results/aten_uniform_cpu.mlir new file mode 100644 index 000000000000..9540e60f6dd7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_uniform_cpu.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_uniform_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.subf %arg2, %arg1 : f32 + affine.for %arg4 = 0 to 4096 { + %1 = affine.load %arg0[%arg4] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = arith.addf %arg1, %2 : f32 + affine.store %3, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_uniform_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_uniform_cpu/debuf.mlir new file mode 100644 index 000000000000..80ced5c8889c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_uniform_cpu/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_uniform_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = arith.subf %arg2, %arg1 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.mulf %2, %in : f32 + %6 = arith.addf %arg1, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_uniform_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_uniform_cpu/matched.mlir new file mode 100644 index 000000000000..80ced5c8889c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_uniform_cpu/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_uniform_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = arith.subf %arg2, %arg1 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.mulf %2, %in : f32 + %6 = arith.addf %arg1, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_uniform_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_uniform_cpu/orig.mlir new file mode 100644 index 000000000000..9540e60f6dd7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_uniform_cpu/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_uniform_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.subf %arg2, %arg1 : f32 + affine.for %arg4 = 0 to 4096 { + %1 = affine.load %arg0[%arg4] : memref + %2 = arith.mulf %0, %1 : f32 + %3 = arith.addf %arg1, %2 : f32 + affine.store %3, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_uniform_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_uniform_cpu/raised.mlir new file mode 100644 index 000000000000..3d100398d888 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_uniform_cpu/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_uniform_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.subf %arg2, %arg1 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.mulf %0, %in : f32 + %2 = arith.addf %arg1, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_uniform_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_uniform_cpu_debuf.mlir new file mode 100644 index 000000000000..80ced5c8889c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_uniform_cpu_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_uniform_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = arith.subf %arg2, %arg1 : f32 + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0 : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %5 = arith.mulf %2, %in : f32 + %6 = arith.addf %arg1, %5 : f32 + linalg.yield %6 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_uniform_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_uniform_cpu_linalg.mlir new file mode 100644 index 000000000000..3d100398d888 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_uniform_cpu_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_uniform_cpu(%arg0: memref, %arg1: f32, %arg2: f32, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.subf %arg2, %arg1 : f32 + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%arg0 : memref) outs(%arg3 : memref) { + ^bb0(%in: f32, %out: f32): + %1 = arith.mulf %0, %in : f32 + %2 = arith.addf %arg1, %1 : f32 + linalg.yield %2 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_bool_cpu.mlir b/issues/aten_c_kernels/results/aten_unique_bool_cpu.mlir new file mode 100644 index 000000000000..18b9cf5af00a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_bool_cpu.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_bool_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg2[1] : memref + affine.store %c0_i32, %arg2[0] : memref + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpi ne, %0, %c0_i32 : i32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg2[%3] : memref + %5 = arith.addi %4, %c1_i32 : i32 + memref.store %5, %arg2[%3] : memref + } + affine.store %c0_i32, %arg1[0] : memref + affine.store %c1_i32, %arg1[1] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unique_bool_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_unique_bool_cpu/debuf.mlir new file mode 100644 index 000000000000..93f44581fc8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_bool_cpu/debuf.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_bool_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %c0_i32 into %0[%c1] : tensor + %inserted_0 = tensor.insert %c0_i32 into %inserted[%c0] : tensor + %3 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %inserted_0) -> (tensor) { + %extracted = tensor.extract %2[%arg3] : tensor + %6 = arith.cmpi ne, %extracted, %c0_i32 : i32 + %7 = arith.extui %6 : i1 to i32 + %8 = arith.index_cast %7 : i32 to index + %extracted_3 = tensor.extract %arg4[%8] : tensor + %9 = arith.addi %extracted_3, %c1_i32 : i32 + %inserted_4 = tensor.insert %9 into %arg4[%8] : tensor + affine.yield %inserted_4 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + %inserted_1 = tensor.insert %c0_i32 into %1[%c0] : tensor + %inserted_2 = tensor.insert %c1_i32 into %inserted_1[%c1] : tensor + %5 = bufferization.to_memref %inserted_2 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_bool_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_unique_bool_cpu/matched.mlir new file mode 100644 index 000000000000..93f44581fc8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_bool_cpu/matched.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_bool_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %c0_i32 into %0[%c1] : tensor + %inserted_0 = tensor.insert %c0_i32 into %inserted[%c0] : tensor + %3 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %inserted_0) -> (tensor) { + %extracted = tensor.extract %2[%arg3] : tensor + %6 = arith.cmpi ne, %extracted, %c0_i32 : i32 + %7 = arith.extui %6 : i1 to i32 + %8 = arith.index_cast %7 : i32 to index + %extracted_3 = tensor.extract %arg4[%8] : tensor + %9 = arith.addi %extracted_3, %c1_i32 : i32 + %inserted_4 = tensor.insert %9 into %arg4[%8] : tensor + affine.yield %inserted_4 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + %inserted_1 = tensor.insert %c0_i32 into %1[%c0] : tensor + %inserted_2 = tensor.insert %c1_i32 into %inserted_1[%c1] : tensor + %5 = bufferization.to_memref %inserted_2 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_bool_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_unique_bool_cpu/orig.mlir new file mode 100644 index 000000000000..18b9cf5af00a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_bool_cpu/orig.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_bool_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg2[1] : memref + affine.store %c0_i32, %arg2[0] : memref + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpi ne, %0, %c0_i32 : i32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg2[%3] : memref + %5 = arith.addi %4, %c1_i32 : i32 + memref.store %5, %arg2[%3] : memref + } + affine.store %c0_i32, %arg1[0] : memref + affine.store %c1_i32, %arg1[1] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unique_bool_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_unique_bool_cpu/raised.mlir new file mode 100644 index 000000000000..7697a087e9af --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_bool_cpu/raised.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_bool_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg2[1] : memref + affine.store %c0_i32, %arg2[0] : memref + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpi ne, %0, %c0_i32 : i32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg2[%3] : memref + %5 = arith.addi %4, %c1_i32 : i32 + memref.store %5, %arg2[%3] : memref + } + affine.store %c0_i32, %arg1[0] : memref + affine.store %c1_i32, %arg1[1] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_bool_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_unique_bool_cpu_debuf.mlir new file mode 100644 index 000000000000..93f44581fc8b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_bool_cpu_debuf.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_bool_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %c0_i32 into %0[%c1] : tensor + %inserted_0 = tensor.insert %c0_i32 into %inserted[%c0] : tensor + %3 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %inserted_0) -> (tensor) { + %extracted = tensor.extract %2[%arg3] : tensor + %6 = arith.cmpi ne, %extracted, %c0_i32 : i32 + %7 = arith.extui %6 : i1 to i32 + %8 = arith.index_cast %7 : i32 to index + %extracted_3 = tensor.extract %arg4[%8] : tensor + %9 = arith.addi %extracted_3, %c1_i32 : i32 + %inserted_4 = tensor.insert %9 into %arg4[%8] : tensor + affine.yield %inserted_4 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + %inserted_1 = tensor.insert %c0_i32 into %1[%c0] : tensor + %inserted_2 = tensor.insert %c1_i32 into %inserted_1[%c1] : tensor + %5 = bufferization.to_memref %inserted_2 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_bool_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_unique_bool_cpu_linalg.mlir new file mode 100644 index 000000000000..7697a087e9af --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_bool_cpu_linalg.mlir @@ -0,0 +1,21 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_bool_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg2[1] : memref + affine.store %c0_i32, %arg2[0] : memref + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg0[%arg3] : memref + %1 = arith.cmpi ne, %0, %c0_i32 : i32 + %2 = arith.extui %1 : i1 to i32 + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg2[%3] : memref + %5 = arith.addi %4, %c1_i32 : i32 + memref.store %5, %arg2[%3] : memref + } + affine.store %c0_i32, %arg1[0] : memref + affine.store %c1_i32, %arg1[1] : memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_consecutive_cpu.mlir b/issues/aten_c_kernels/results/aten_unique_consecutive_cpu.mlir new file mode 100644 index 000000000000..194ffb797026 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_consecutive_cpu.mlir @@ -0,0 +1,30 @@ +#set = affine_set<(d0) : (d0 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_consecutive_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %c0_i32) -> (i32) { + %1 = affine.if #set(%arg3) -> i1 { + affine.yield %true : i1 + } else { + %3 = affine.load %arg0[%arg3] : memref + %4 = affine.load %arg0[%arg3 - 1] : memref + %5 = arith.cmpi ne, %3, %4 : i32 + affine.yield %5 : i1 + } + %2 = scf.if %1 -> (i32) { + %3 = arith.addi %arg4, %c1_i32 : i32 + %4 = arith.index_cast %arg4 : i32 to index + %5 = affine.load %arg0[%arg3] : memref + memref.store %5, %arg1[%4] : memref + scf.yield %3 : i32 + } else { + scf.yield %arg4 : i32 + } + affine.yield %2 : i32 + } + affine.store %0, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unique_consecutive_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_unique_consecutive_cpu/debuf.mlir new file mode 100644 index 000000000000..9518860b475e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_consecutive_cpu/debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_consecutive_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %true = arith.constant true + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %c0_i32 into %0[%c0] : tensor + %3:2 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %1, %arg5 = %inserted) -> (tensor, tensor) { + %extracted = tensor.extract %arg5[%c0] : tensor + %6 = arith.cmpi eq, %arg3, %c0 : index + %extracted_0 = tensor.extract %2[%arg3] : tensor + %7 = affine.apply #map(%arg3) + %extracted_1 = tensor.extract %2[%7] : tensor + %8 = arith.cmpi ne, %extracted_0, %extracted_1 : i32 + %9 = arith.select %6, %true, %8 : i1 + %10:2 = scf.if %9 -> (i32, tensor) { + %11 = arith.addi %extracted, %c1_i32 : i32 + %12 = arith.index_cast %extracted : i32 to index + %extracted_3 = tensor.extract %2[%arg3] : tensor + %inserted_4 = tensor.insert %extracted_3 into %arg4[%12] : tensor + scf.yield %11, %inserted_4 : i32, tensor + } else { + scf.yield %extracted, %arg4 : i32, tensor + } + %inserted_2 = tensor.insert %10#0 into %arg5[%c0] : tensor + affine.yield %10#1, %inserted_2 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_consecutive_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_unique_consecutive_cpu/matched.mlir new file mode 100644 index 000000000000..9518860b475e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_consecutive_cpu/matched.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_consecutive_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %true = arith.constant true + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %c0_i32 into %0[%c0] : tensor + %3:2 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %1, %arg5 = %inserted) -> (tensor, tensor) { + %extracted = tensor.extract %arg5[%c0] : tensor + %6 = arith.cmpi eq, %arg3, %c0 : index + %extracted_0 = tensor.extract %2[%arg3] : tensor + %7 = affine.apply #map(%arg3) + %extracted_1 = tensor.extract %2[%7] : tensor + %8 = arith.cmpi ne, %extracted_0, %extracted_1 : i32 + %9 = arith.select %6, %true, %8 : i1 + %10:2 = scf.if %9 -> (i32, tensor) { + %11 = arith.addi %extracted, %c1_i32 : i32 + %12 = arith.index_cast %extracted : i32 to index + %extracted_3 = tensor.extract %2[%arg3] : tensor + %inserted_4 = tensor.insert %extracted_3 into %arg4[%12] : tensor + scf.yield %11, %inserted_4 : i32, tensor + } else { + scf.yield %extracted, %arg4 : i32, tensor + } + %inserted_2 = tensor.insert %10#0 into %arg5[%c0] : tensor + affine.yield %10#1, %inserted_2 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_consecutive_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_unique_consecutive_cpu/orig.mlir new file mode 100644 index 000000000000..194ffb797026 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_consecutive_cpu/orig.mlir @@ -0,0 +1,30 @@ +#set = affine_set<(d0) : (d0 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_consecutive_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %0 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %c0_i32) -> (i32) { + %1 = affine.if #set(%arg3) -> i1 { + affine.yield %true : i1 + } else { + %3 = affine.load %arg0[%arg3] : memref + %4 = affine.load %arg0[%arg3 - 1] : memref + %5 = arith.cmpi ne, %3, %4 : i32 + affine.yield %5 : i1 + } + %2 = scf.if %1 -> (i32) { + %3 = arith.addi %arg4, %c1_i32 : i32 + %4 = arith.index_cast %arg4 : i32 to index + %5 = affine.load %arg0[%arg3] : memref + memref.store %5, %arg1[%4] : memref + scf.yield %3 : i32 + } else { + scf.yield %arg4 : i32 + } + affine.yield %2 : i32 + } + affine.store %0, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unique_consecutive_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_unique_consecutive_cpu/raised.mlir new file mode 100644 index 000000000000..b54ebbb51022 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_consecutive_cpu/raised.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_consecutive_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %true = arith.constant true + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg2[0] : memref + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg2[0] : memref + %1 = arith.cmpi eq, %arg3, %c0 : index + %2 = affine.load %arg0[%arg3] : memref + %3 = affine.load %arg0[%arg3 - 1] : memref + %4 = arith.cmpi ne, %2, %3 : i32 + %5 = arith.select %1, %true, %4 : i1 + %6 = scf.if %5 -> (i32) { + %7 = arith.addi %0, %c1_i32 : i32 + %8 = arith.index_cast %0 : i32 to index + %9 = affine.load %arg0[%arg3] : memref + memref.store %9, %arg1[%8] : memref + scf.yield %7 : i32 + } else { + scf.yield %0 : i32 + } + affine.store %6, %arg2[0] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_consecutive_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_unique_consecutive_cpu_debuf.mlir new file mode 100644 index 000000000000..9518860b475e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_consecutive_cpu_debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_consecutive_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %true = arith.constant true + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %inserted = tensor.insert %c0_i32 into %0[%c0] : tensor + %3:2 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %1, %arg5 = %inserted) -> (tensor, tensor) { + %extracted = tensor.extract %arg5[%c0] : tensor + %6 = arith.cmpi eq, %arg3, %c0 : index + %extracted_0 = tensor.extract %2[%arg3] : tensor + %7 = affine.apply #map(%arg3) + %extracted_1 = tensor.extract %2[%7] : tensor + %8 = arith.cmpi ne, %extracted_0, %extracted_1 : i32 + %9 = arith.select %6, %true, %8 : i1 + %10:2 = scf.if %9 -> (i32, tensor) { + %11 = arith.addi %extracted, %c1_i32 : i32 + %12 = arith.index_cast %extracted : i32 to index + %extracted_3 = tensor.extract %2[%arg3] : tensor + %inserted_4 = tensor.insert %extracted_3 into %arg4[%12] : tensor + scf.yield %11, %inserted_4 : i32, tensor + } else { + scf.yield %extracted, %arg4 : i32, tensor + } + %inserted_2 = tensor.insert %10#0 into %arg5[%c0] : tensor + affine.yield %10#1, %inserted_2 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg2 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_consecutive_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_unique_consecutive_cpu_linalg.mlir new file mode 100644 index 000000000000..b54ebbb51022 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_consecutive_cpu_linalg.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_consecutive_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %true = arith.constant true + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.store %c0_i32, %arg2[0] : memref + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg2[0] : memref + %1 = arith.cmpi eq, %arg3, %c0 : index + %2 = affine.load %arg0[%arg3] : memref + %3 = affine.load %arg0[%arg3 - 1] : memref + %4 = arith.cmpi ne, %2, %3 : i32 + %5 = arith.select %1, %true, %4 : i1 + %6 = scf.if %5 -> (i32) { + %7 = arith.addi %0, %c1_i32 : i32 + %8 = arith.index_cast %0 : i32 to index + %9 = affine.load %arg0[%arg3] : memref + memref.store %9, %arg1[%8] : memref + scf.yield %7 : i32 + } else { + scf.yield %0 : i32 + } + affine.store %6, %arg2[0] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu.mlir b/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu.mlir new file mode 100644 index 000000000000..3a96840270cc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_dim_impl_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 128 { + %0 = affine.for %arg3 = 0 to #map(%arg2) iter_args(%arg4 = %c1_i32) -> (i32) { + %1 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %c1_i32) -> (i32) { + %5 = affine.load %arg0[%arg2, %arg5] : memref + %6 = affine.load %arg0[%arg3, %arg5] : memref + %7 = arith.cmpf oeq, %5, %6 : f32 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.andi %arg6, %8 : i32 + affine.yield %9 : i32 + } + %2 = arith.cmpi eq, %1, %c0_i32 : i32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.andi %arg4, %3 : i32 + affine.yield %4 : i32 + } + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu/debuf.mlir new file mode 100644 index 000000000000..f1cdbaa949f6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu/debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_dim_impl_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c127 = arith.constant 127 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = affine.for %arg2 = 0 to 128 iter_args(%arg3 = %0) -> (tensor) { + %inserted = tensor.insert %c1_i32 into %arg3[%arg2] : tensor + %alloca = memref.alloca(%arg2) : memref + %3 = bufferization.to_tensor %alloca : memref + %extracted_slice = tensor.extract_slice %inserted[%arg2] [1] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c127] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.cmpi eq, %in, %c0_i32 : i32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.andi %out, %6 : i32 + %8 = linalg.index 0 : index + %9 = arith.cmpi slt, %8, %arg2 : index + %10 = arith.select %9, %7, %out : i32 + linalg.yield %10 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %inserted[%arg2] [1] [1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu/matched.mlir new file mode 100644 index 000000000000..f1cdbaa949f6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu/matched.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_dim_impl_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c127 = arith.constant 127 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = affine.for %arg2 = 0 to 128 iter_args(%arg3 = %0) -> (tensor) { + %inserted = tensor.insert %c1_i32 into %arg3[%arg2] : tensor + %alloca = memref.alloca(%arg2) : memref + %3 = bufferization.to_tensor %alloca : memref + %extracted_slice = tensor.extract_slice %inserted[%arg2] [1] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c127] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.cmpi eq, %in, %c0_i32 : i32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.andi %out, %6 : i32 + %8 = linalg.index 0 : index + %9 = arith.cmpi slt, %8, %arg2 : index + %10 = arith.select %9, %7, %out : i32 + linalg.yield %10 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %inserted[%arg2] [1] [1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu/orig.mlir new file mode 100644 index 000000000000..3a96840270cc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu/orig.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_dim_impl_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 128 { + %0 = affine.for %arg3 = 0 to #map(%arg2) iter_args(%arg4 = %c1_i32) -> (i32) { + %1 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %c1_i32) -> (i32) { + %5 = affine.load %arg0[%arg2, %arg5] : memref + %6 = affine.load %arg0[%arg3, %arg5] : memref + %7 = arith.cmpf oeq, %5, %6 : f32 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.andi %arg6, %8 : i32 + affine.yield %9 : i32 + } + %2 = arith.cmpi eq, %1, %c0_i32 : i32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.andi %arg4, %3 : i32 + affine.yield %4 : i32 + } + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu/raised.mlir new file mode 100644 index 000000000000..fa2506606170 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu/raised.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +#map4 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_dim_impl_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c127 = arith.constant 127 : index + %c16 = arith.constant 16 : index + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 128 { + affine.store %c1_i32, %arg1[%arg2] : memref + %alloca = memref.alloca(%arg2) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + %0 = linalg.index 0 : index + %1 = arith.cmpi slt, %0, %arg2 : index + %2 = arith.select %1, %c1_i32, %out : i32 + linalg.yield %2 : i32 + } + %subview = memref.subview %arg0[%arg2, 0] [1, %c16] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c127, %c16] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[0] [%c127] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_4: f32, %out: i32): + %0 = arith.cmpf oeq, %in, %in_4 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.andi %out, %1 : i32 + linalg.yield %2 : i32 + } + %subview_2 = memref.subview %alloca[0] [%c127] [1] : memref to memref> + %subview_3 = memref.subview %arg1[%arg2] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map4], iterator_types = ["reduction"]} ins(%subview_2 : memref>) outs(%subview_3 : memref>) { + ^bb0(%in: i32, %out: i32): + %0 = arith.cmpi eq, %in, %c0_i32 : i32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.andi %out, %1 : i32 + %3 = linalg.index 0 : index + %4 = arith.cmpi slt, %3, %arg2 : index + %5 = arith.select %4, %2, %out : i32 + linalg.yield %5 : i32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu_debuf.mlir new file mode 100644 index 000000000000..f1cdbaa949f6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu_debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_dim_impl_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c127 = arith.constant 127 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = affine.for %arg2 = 0 to 128 iter_args(%arg3 = %0) -> (tensor) { + %inserted = tensor.insert %c1_i32 into %arg3[%arg2] : tensor + %alloca = memref.alloca(%arg2) : memref + %3 = bufferization.to_tensor %alloca : memref + %extracted_slice = tensor.extract_slice %inserted[%arg2] [1] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c127] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.cmpi eq, %in, %c0_i32 : i32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.andi %out, %6 : i32 + %8 = linalg.index 0 : index + %9 = arith.cmpi slt, %8, %arg2 : index + %10 = arith.select %9, %7, %out : i32 + linalg.yield %10 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %inserted[%arg2] [1] [1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu_linalg.mlir new file mode 100644 index 000000000000..fa2506606170 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_dim_impl_cpu_linalg.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +#map4 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_dim_impl_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c127 = arith.constant 127 : index + %c16 = arith.constant 16 : index + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 128 { + affine.store %c1_i32, %arg1[%arg2] : memref + %alloca = memref.alloca(%arg2) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + %0 = linalg.index 0 : index + %1 = arith.cmpi slt, %0, %arg2 : index + %2 = arith.select %1, %c1_i32, %out : i32 + linalg.yield %2 : i32 + } + %subview = memref.subview %arg0[%arg2, 0] [1, %c16] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c127, %c16] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[0] [%c127] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_4: f32, %out: i32): + %0 = arith.cmpf oeq, %in, %in_4 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.andi %out, %1 : i32 + linalg.yield %2 : i32 + } + %subview_2 = memref.subview %alloca[0] [%c127] [1] : memref to memref> + %subview_3 = memref.subview %arg1[%arg2] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map4], iterator_types = ["reduction"]} ins(%subview_2 : memref>) outs(%subview_3 : memref>) { + ^bb0(%in: i32, %out: i32): + %0 = arith.cmpi eq, %in, %c0_i32 : i32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.andi %out, %1 : i32 + %3 = linalg.index 0 : index + %4 = arith.cmpi slt, %3, %arg2 : index + %5 = arith.select %4, %2, %out : i32 + linalg.yield %5 : i32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_dim_template_cpu.mlir b/issues/aten_c_kernels/results/aten_unique_dim_template_cpu.mlir new file mode 100644 index 000000000000..8b3fb37241cd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_dim_template_cpu.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_dim_template_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 128 { + %0 = affine.for %arg3 = 0 to #map(%arg2) iter_args(%arg4 = %c1_i32) -> (i32) { + %1 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %c1_i32) -> (i32) { + %5 = affine.load %arg0[%arg2, %arg5] : memref + %6 = affine.load %arg0[%arg3, %arg5] : memref + %7 = arith.cmpf oeq, %5, %6 : f32 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.andi %arg6, %8 : i32 + affine.yield %9 : i32 + } + %2 = arith.cmpi eq, %1, %c0_i32 : i32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.andi %arg4, %3 : i32 + affine.yield %4 : i32 + } + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unique_dim_template_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_unique_dim_template_cpu/debuf.mlir new file mode 100644 index 000000000000..3fe3010fa5b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_dim_template_cpu/debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_dim_template_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c127 = arith.constant 127 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = affine.for %arg2 = 0 to 128 iter_args(%arg3 = %0) -> (tensor) { + %inserted = tensor.insert %c1_i32 into %arg3[%arg2] : tensor + %alloca = memref.alloca(%arg2) : memref + %3 = bufferization.to_tensor %alloca : memref + %extracted_slice = tensor.extract_slice %inserted[%arg2] [1] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c127] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.cmpi eq, %in, %c0_i32 : i32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.andi %out, %6 : i32 + %8 = linalg.index 0 : index + %9 = arith.cmpi slt, %8, %arg2 : index + %10 = arith.select %9, %7, %out : i32 + linalg.yield %10 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %inserted[%arg2] [1] [1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_dim_template_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_unique_dim_template_cpu/matched.mlir new file mode 100644 index 000000000000..3fe3010fa5b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_dim_template_cpu/matched.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_dim_template_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c127 = arith.constant 127 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = affine.for %arg2 = 0 to 128 iter_args(%arg3 = %0) -> (tensor) { + %inserted = tensor.insert %c1_i32 into %arg3[%arg2] : tensor + %alloca = memref.alloca(%arg2) : memref + %3 = bufferization.to_tensor %alloca : memref + %extracted_slice = tensor.extract_slice %inserted[%arg2] [1] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c127] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.cmpi eq, %in, %c0_i32 : i32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.andi %out, %6 : i32 + %8 = linalg.index 0 : index + %9 = arith.cmpi slt, %8, %arg2 : index + %10 = arith.select %9, %7, %out : i32 + linalg.yield %10 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %inserted[%arg2] [1] [1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_dim_template_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_unique_dim_template_cpu/orig.mlir new file mode 100644 index 000000000000..8b3fb37241cd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_dim_template_cpu/orig.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_dim_template_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 128 { + %0 = affine.for %arg3 = 0 to #map(%arg2) iter_args(%arg4 = %c1_i32) -> (i32) { + %1 = affine.for %arg5 = 0 to 16 iter_args(%arg6 = %c1_i32) -> (i32) { + %5 = affine.load %arg0[%arg2, %arg5] : memref + %6 = affine.load %arg0[%arg3, %arg5] : memref + %7 = arith.cmpf oeq, %5, %6 : f32 + %8 = arith.extui %7 : i1 to i32 + %9 = arith.andi %arg6, %8 : i32 + affine.yield %9 : i32 + } + %2 = arith.cmpi eq, %1, %c0_i32 : i32 + %3 = arith.extui %2 : i1 to i32 + %4 = arith.andi %arg4, %3 : i32 + affine.yield %4 : i32 + } + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unique_dim_template_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_unique_dim_template_cpu/raised.mlir new file mode 100644 index 000000000000..be57348ac67c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_dim_template_cpu/raised.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +#map4 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_dim_template_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c127 = arith.constant 127 : index + %c16 = arith.constant 16 : index + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 128 { + affine.store %c1_i32, %arg1[%arg2] : memref + %alloca = memref.alloca(%arg2) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + %0 = linalg.index 0 : index + %1 = arith.cmpi slt, %0, %arg2 : index + %2 = arith.select %1, %c1_i32, %out : i32 + linalg.yield %2 : i32 + } + %subview = memref.subview %arg0[%arg2, 0] [1, %c16] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c127, %c16] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[0] [%c127] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_4: f32, %out: i32): + %0 = arith.cmpf oeq, %in, %in_4 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.andi %out, %1 : i32 + linalg.yield %2 : i32 + } + %subview_2 = memref.subview %alloca[0] [%c127] [1] : memref to memref> + %subview_3 = memref.subview %arg1[%arg2] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map4], iterator_types = ["reduction"]} ins(%subview_2 : memref>) outs(%subview_3 : memref>) { + ^bb0(%in: i32, %out: i32): + %0 = arith.cmpi eq, %in, %c0_i32 : i32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.andi %out, %1 : i32 + %3 = linalg.index 0 : index + %4 = arith.cmpi slt, %3, %arg2 : index + %5 = arith.select %4, %2, %out : i32 + linalg.yield %5 : i32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_dim_template_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_unique_dim_template_cpu_debuf.mlir new file mode 100644 index 000000000000..3fe3010fa5b4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_dim_template_cpu_debuf.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_dim_template_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %c127 = arith.constant 127 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = affine.for %arg2 = 0 to 128 iter_args(%arg3 = %0) -> (tensor) { + %inserted = tensor.insert %c1_i32 into %arg3[%arg2] : tensor + %alloca = memref.alloca(%arg2) : memref + %3 = bufferization.to_tensor %alloca : memref + %extracted_slice = tensor.extract_slice %inserted[%arg2] [1] [1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c127] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_0 : tensor) outs(%extracted_slice : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.cmpi eq, %in, %c0_i32 : i32 + %6 = arith.extui %5 : i1 to i32 + %7 = arith.andi %out, %6 : i32 + %8 = linalg.index 0 : index + %9 = arith.cmpi slt, %8, %arg2 : index + %10 = arith.select %9, %7, %out : i32 + linalg.yield %10 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %inserted[%arg2] [1] [1] : tensor into tensor + affine.yield %inserted_slice : tensor + } + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_dim_template_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_unique_dim_template_cpu_linalg.mlir new file mode 100644 index 000000000000..be57348ac67c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_dim_template_cpu_linalg.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +#map4 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_dim_template_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c127 = arith.constant 127 : index + %c16 = arith.constant 16 : index + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 128 { + affine.store %c1_i32, %arg1[%arg2] : memref + %alloca = memref.alloca(%arg2) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: i32): + %0 = linalg.index 0 : index + %1 = arith.cmpi slt, %0, %arg2 : index + %2 = arith.select %1, %c1_i32, %out : i32 + linalg.yield %2 : i32 + } + %subview = memref.subview %arg0[%arg2, 0] [1, %c16] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg0[0, 0] [%c127, %c16] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[0] [%c127] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_4: f32, %out: i32): + %0 = arith.cmpf oeq, %in, %in_4 : f32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.andi %out, %1 : i32 + linalg.yield %2 : i32 + } + %subview_2 = memref.subview %alloca[0] [%c127] [1] : memref to memref> + %subview_3 = memref.subview %arg1[%arg2] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map4], iterator_types = ["reduction"]} ins(%subview_2 : memref>) outs(%subview_3 : memref>) { + ^bb0(%in: i32, %out: i32): + %0 = arith.cmpi eq, %in, %c0_i32 : i32 + %1 = arith.extui %0 : i1 to i32 + %2 = arith.andi %out, %1 : i32 + %3 = linalg.index 0 : index + %4 = arith.cmpi slt, %3, %arg2 : index + %5 = arith.select %4, %2, %out : i32 + linalg.yield %5 : i32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_sorted_cpu.mlir b/issues/aten_c_kernels/results/aten_unique_sorted_cpu.mlir new file mode 100644 index 000000000000..7bfb2658196b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_sorted_cpu.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#set = affine_set<(d0) : (d0 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_sorted_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 1024 { + affine.for %arg4 = #map(%arg3) to 1024 { + %1 = affine.load %arg0[%arg4] : memref + %2 = affine.load %arg0[%arg3] : memref + %3 = arith.cmpi slt, %1, %2 : i32 + scf.if %3 { + affine.store %1, %arg0[%arg3] : memref + affine.store %2, %arg0[%arg4] : memref + } + } + } + %0 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %c0_i32) -> (i32) { + %1 = affine.if #set(%arg3) -> i1 { + affine.yield %true : i1 + } else { + %3 = affine.load %arg0[%arg3] : memref + %4 = affine.load %arg0[%arg3 - 1] : memref + %5 = arith.cmpi ne, %3, %4 : i32 + affine.yield %5 : i1 + } + %2 = scf.if %1 -> (i32) { + %3 = arith.addi %arg4, %c1_i32 : i32 + %4 = arith.index_cast %arg4 : i32 to index + %5 = affine.load %arg0[%arg3] : memref + memref.store %5, %arg1[%4] : memref + scf.yield %3 : i32 + } else { + scf.yield %arg4 : i32 + } + affine.yield %2 : i32 + } + affine.store %0, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unique_sorted_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_unique_sorted_cpu/debuf.mlir new file mode 100644 index 000000000000..bb0ab66b401b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_sorted_cpu/debuf.mlir @@ -0,0 +1,58 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> (d0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_sorted_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %true = arith.constant true + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %2) -> (tensor) { + %8 = affine.for %arg5 = #map(%arg3) to 1024 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %arg6[%arg5] : tensor + %extracted_0 = tensor.extract %arg6[%arg3] : tensor + %9 = arith.cmpi slt, %extracted, %extracted_0 : i32 + %10 = scf.if %9 -> (tensor) { + %inserted_1 = tensor.insert %extracted into %arg6[%arg3] : tensor + %inserted_2 = tensor.insert %extracted_0 into %inserted_1[%arg5] : tensor + scf.yield %inserted_2 : tensor + } else { + scf.yield %arg6 : tensor + } + affine.yield %10 : tensor + } + affine.yield %8 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + %inserted = tensor.insert %c0_i32 into %0[%c0] : tensor + %5:2 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %1, %arg5 = %inserted) -> (tensor, tensor) { + %extracted = tensor.extract %arg5[%c0] : tensor + %8 = arith.cmpi eq, %arg3, %c0 : index + %extracted_0 = tensor.extract %3[%arg3] : tensor + %9 = affine.apply #map1(%arg3) + %extracted_1 = tensor.extract %3[%9] : tensor + %10 = arith.cmpi ne, %extracted_0, %extracted_1 : i32 + %11 = arith.select %8, %true, %10 : i1 + %12:2 = scf.if %11 -> (i32, tensor) { + %13 = arith.addi %extracted, %c1_i32 : i32 + %14 = arith.index_cast %extracted : i32 to index + %extracted_3 = tensor.extract %3[%arg3] : tensor + %inserted_4 = tensor.insert %extracted_3 into %arg4[%14] : tensor + scf.yield %13, %inserted_4 : i32, tensor + } else { + scf.yield %extracted, %arg4 : i32, tensor + } + %inserted_2 = tensor.insert %12#0 into %arg5[%c0] : tensor + affine.yield %12#1, %inserted_2 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg2 : memref to memref + %7 = bufferization.to_memref %5#0 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_sorted_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_unique_sorted_cpu/matched.mlir new file mode 100644 index 000000000000..bb0ab66b401b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_sorted_cpu/matched.mlir @@ -0,0 +1,58 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> (d0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_sorted_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %true = arith.constant true + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %2) -> (tensor) { + %8 = affine.for %arg5 = #map(%arg3) to 1024 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %arg6[%arg5] : tensor + %extracted_0 = tensor.extract %arg6[%arg3] : tensor + %9 = arith.cmpi slt, %extracted, %extracted_0 : i32 + %10 = scf.if %9 -> (tensor) { + %inserted_1 = tensor.insert %extracted into %arg6[%arg3] : tensor + %inserted_2 = tensor.insert %extracted_0 into %inserted_1[%arg5] : tensor + scf.yield %inserted_2 : tensor + } else { + scf.yield %arg6 : tensor + } + affine.yield %10 : tensor + } + affine.yield %8 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + %inserted = tensor.insert %c0_i32 into %0[%c0] : tensor + %5:2 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %1, %arg5 = %inserted) -> (tensor, tensor) { + %extracted = tensor.extract %arg5[%c0] : tensor + %8 = arith.cmpi eq, %arg3, %c0 : index + %extracted_0 = tensor.extract %3[%arg3] : tensor + %9 = affine.apply #map1(%arg3) + %extracted_1 = tensor.extract %3[%9] : tensor + %10 = arith.cmpi ne, %extracted_0, %extracted_1 : i32 + %11 = arith.select %8, %true, %10 : i1 + %12:2 = scf.if %11 -> (i32, tensor) { + %13 = arith.addi %extracted, %c1_i32 : i32 + %14 = arith.index_cast %extracted : i32 to index + %extracted_3 = tensor.extract %3[%arg3] : tensor + %inserted_4 = tensor.insert %extracted_3 into %arg4[%14] : tensor + scf.yield %13, %inserted_4 : i32, tensor + } else { + scf.yield %extracted, %arg4 : i32, tensor + } + %inserted_2 = tensor.insert %12#0 into %arg5[%c0] : tensor + affine.yield %12#1, %inserted_2 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg2 : memref to memref + %7 = bufferization.to_memref %5#0 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_sorted_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_unique_sorted_cpu/orig.mlir new file mode 100644 index 000000000000..7bfb2658196b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_sorted_cpu/orig.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#set = affine_set<(d0) : (d0 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_sorted_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 1024 { + affine.for %arg4 = #map(%arg3) to 1024 { + %1 = affine.load %arg0[%arg4] : memref + %2 = affine.load %arg0[%arg3] : memref + %3 = arith.cmpi slt, %1, %2 : i32 + scf.if %3 { + affine.store %1, %arg0[%arg3] : memref + affine.store %2, %arg0[%arg4] : memref + } + } + } + %0 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %c0_i32) -> (i32) { + %1 = affine.if #set(%arg3) -> i1 { + affine.yield %true : i1 + } else { + %3 = affine.load %arg0[%arg3] : memref + %4 = affine.load %arg0[%arg3 - 1] : memref + %5 = arith.cmpi ne, %3, %4 : i32 + affine.yield %5 : i1 + } + %2 = scf.if %1 -> (i32) { + %3 = arith.addi %arg4, %c1_i32 : i32 + %4 = arith.index_cast %arg4 : i32 to index + %5 = affine.load %arg0[%arg3] : memref + memref.store %5, %arg1[%4] : memref + scf.yield %3 : i32 + } else { + scf.yield %arg4 : i32 + } + affine.yield %2 : i32 + } + affine.store %0, %arg2[0] : memref + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unique_sorted_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_unique_sorted_cpu/raised.mlir new file mode 100644 index 000000000000..9e72e9b3278f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_sorted_cpu/raised.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_sorted_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %true = arith.constant true + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 1024 { + affine.for %arg4 = #map(%arg3) to 1024 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg0[%arg3] : memref + %2 = arith.cmpi slt, %0, %1 : i32 + scf.if %2 { + affine.store %0, %arg0[%arg3] : memref + affine.store %1, %arg0[%arg4] : memref + } + } + } + affine.store %c0_i32, %arg2[0] : memref + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg2[0] : memref + %1 = arith.cmpi eq, %arg3, %c0 : index + %2 = affine.load %arg0[%arg3] : memref + %3 = affine.load %arg0[%arg3 - 1] : memref + %4 = arith.cmpi ne, %2, %3 : i32 + %5 = arith.select %1, %true, %4 : i1 + %6 = scf.if %5 -> (i32) { + %7 = arith.addi %0, %c1_i32 : i32 + %8 = arith.index_cast %0 : i32 to index + %9 = affine.load %arg0[%arg3] : memref + memref.store %9, %arg1[%8] : memref + scf.yield %7 : i32 + } else { + scf.yield %0 : i32 + } + affine.store %6, %arg2[0] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_sorted_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_unique_sorted_cpu_debuf.mlir new file mode 100644 index 000000000000..bb0ab66b401b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_sorted_cpu_debuf.mlir @@ -0,0 +1,58 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0) -> (d0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_sorted_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c1_i32 = arith.constant 1 : i32 + %true = arith.constant true + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %2) -> (tensor) { + %8 = affine.for %arg5 = #map(%arg3) to 1024 iter_args(%arg6 = %arg4) -> (tensor) { + %extracted = tensor.extract %arg6[%arg5] : tensor + %extracted_0 = tensor.extract %arg6[%arg3] : tensor + %9 = arith.cmpi slt, %extracted, %extracted_0 : i32 + %10 = scf.if %9 -> (tensor) { + %inserted_1 = tensor.insert %extracted into %arg6[%arg3] : tensor + %inserted_2 = tensor.insert %extracted_0 into %inserted_1[%arg5] : tensor + scf.yield %inserted_2 : tensor + } else { + scf.yield %arg6 : tensor + } + affine.yield %10 : tensor + } + affine.yield %8 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg0 : memref to memref + %inserted = tensor.insert %c0_i32 into %0[%c0] : tensor + %5:2 = affine.for %arg3 = 0 to 1024 iter_args(%arg4 = %1, %arg5 = %inserted) -> (tensor, tensor) { + %extracted = tensor.extract %arg5[%c0] : tensor + %8 = arith.cmpi eq, %arg3, %c0 : index + %extracted_0 = tensor.extract %3[%arg3] : tensor + %9 = affine.apply #map1(%arg3) + %extracted_1 = tensor.extract %3[%9] : tensor + %10 = arith.cmpi ne, %extracted_0, %extracted_1 : i32 + %11 = arith.select %8, %true, %10 : i1 + %12:2 = scf.if %11 -> (i32, tensor) { + %13 = arith.addi %extracted, %c1_i32 : i32 + %14 = arith.index_cast %extracted : i32 to index + %extracted_3 = tensor.extract %3[%arg3] : tensor + %inserted_4 = tensor.insert %extracted_3 into %arg4[%14] : tensor + scf.yield %13, %inserted_4 : i32, tensor + } else { + scf.yield %extracted, %arg4 : i32, tensor + } + %inserted_2 = tensor.insert %12#0 into %arg5[%c0] : tensor + affine.yield %12#1, %inserted_2 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg2 : memref to memref + %7 = bufferization.to_memref %5#0 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unique_sorted_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_unique_sorted_cpu_linalg.mlir new file mode 100644 index 000000000000..9e72e9b3278f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unique_sorted_cpu_linalg.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unique_sorted_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %true = arith.constant true + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 1024 { + affine.for %arg4 = #map(%arg3) to 1024 { + %0 = affine.load %arg0[%arg4] : memref + %1 = affine.load %arg0[%arg3] : memref + %2 = arith.cmpi slt, %0, %1 : i32 + scf.if %2 { + affine.store %0, %arg0[%arg3] : memref + affine.store %1, %arg0[%arg4] : memref + } + } + } + affine.store %c0_i32, %arg2[0] : memref + affine.for %arg3 = 0 to 1024 { + %0 = affine.load %arg2[0] : memref + %1 = arith.cmpi eq, %arg3, %c0 : index + %2 = affine.load %arg0[%arg3] : memref + %3 = affine.load %arg0[%arg3 - 1] : memref + %4 = arith.cmpi ne, %2, %3 : i32 + %5 = arith.select %1, %true, %4 : i1 + %6 = scf.if %5 -> (i32) { + %7 = arith.addi %0, %c1_i32 : i32 + %8 = arith.index_cast %0 : i32 to index + %9 = affine.load %arg0[%arg3] : memref + memref.store %9, %arg1[%8] : memref + scf.yield %7 : i32 + } else { + scf.yield %0 : i32 + } + affine.store %6, %arg2[0] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unpack_pivots_cpu.mlir b/issues/aten_c_kernels/results/aten_unpack_pivots_cpu.mlir new file mode 100644 index 000000000000..cbe8859e1650 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unpack_pivots_cpu.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unpack_pivots_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + affine.for %arg2 = 0 to 128 { + %0 = arith.index_cast %arg2 : index to i32 + affine.store %0, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 128 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.addi %0, %c-1_i32 : i32 + %2 = affine.load %arg1[%arg2] : memref + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg1[%3] : memref + affine.store %4, %arg1[%arg2] : memref + memref.store %2, %arg1[%3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unpack_pivots_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_unpack_pivots_cpu/debuf.mlir new file mode 100644 index 000000000000..60d2a112893a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unpack_pivots_cpu/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unpack_pivots_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: i32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + linalg.yield %6 : i32 + } -> tensor + %3 = affine.for %arg2 = 0 to 128 iter_args(%arg3 = %2) -> (tensor) { + %extracted = tensor.extract %1[%arg2] : tensor + %5 = arith.addi %extracted, %c-1_i32 : i32 + %extracted_0 = tensor.extract %arg3[%arg2] : tensor + %6 = arith.index_cast %5 : i32 to index + %extracted_1 = tensor.extract %arg3[%6] : tensor + %inserted = tensor.insert %extracted_1 into %arg3[%arg2] : tensor + %inserted_2 = tensor.insert %extracted_0 into %inserted[%6] : tensor + affine.yield %inserted_2 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unpack_pivots_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_unpack_pivots_cpu/matched.mlir new file mode 100644 index 000000000000..60d2a112893a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unpack_pivots_cpu/matched.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unpack_pivots_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: i32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + linalg.yield %6 : i32 + } -> tensor + %3 = affine.for %arg2 = 0 to 128 iter_args(%arg3 = %2) -> (tensor) { + %extracted = tensor.extract %1[%arg2] : tensor + %5 = arith.addi %extracted, %c-1_i32 : i32 + %extracted_0 = tensor.extract %arg3[%arg2] : tensor + %6 = arith.index_cast %5 : i32 to index + %extracted_1 = tensor.extract %arg3[%6] : tensor + %inserted = tensor.insert %extracted_1 into %arg3[%arg2] : tensor + %inserted_2 = tensor.insert %extracted_0 into %inserted[%6] : tensor + affine.yield %inserted_2 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unpack_pivots_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_unpack_pivots_cpu/orig.mlir new file mode 100644 index 000000000000..cbe8859e1650 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unpack_pivots_cpu/orig.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unpack_pivots_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + affine.for %arg2 = 0 to 128 { + %0 = arith.index_cast %arg2 : index to i32 + affine.store %0, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 128 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.addi %0, %c-1_i32 : i32 + %2 = affine.load %arg1[%arg2] : memref + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg1[%3] : memref + affine.store %4, %arg1[%arg2] : memref + memref.store %2, %arg1[%3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unpack_pivots_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_unpack_pivots_cpu/raised.mlir new file mode 100644 index 000000000000..94697f78dcdd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unpack_pivots_cpu/raised.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unpack_pivots_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: i32): + %0 = linalg.index 0 : index + %1 = arith.index_cast %0 : index to i32 + linalg.yield %1 : i32 + } + affine.for %arg2 = 0 to 128 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.addi %0, %c-1_i32 : i32 + %2 = affine.load %arg1[%arg2] : memref + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg1[%3] : memref + affine.store %4, %arg1[%arg2] : memref + memref.store %2, %arg1[%3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unpack_pivots_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_unpack_pivots_cpu_debuf.mlir new file mode 100644 index 000000000000..60d2a112893a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unpack_pivots_cpu_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unpack_pivots_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: i32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + linalg.yield %6 : i32 + } -> tensor + %3 = affine.for %arg2 = 0 to 128 iter_args(%arg3 = %2) -> (tensor) { + %extracted = tensor.extract %1[%arg2] : tensor + %5 = arith.addi %extracted, %c-1_i32 : i32 + %extracted_0 = tensor.extract %arg3[%arg2] : tensor + %6 = arith.index_cast %5 : i32 to index + %extracted_1 = tensor.extract %arg3[%6] : tensor + %inserted = tensor.insert %extracted_1 into %arg3[%arg2] : tensor + %inserted_2 = tensor.insert %extracted_0 into %inserted[%6] : tensor + affine.yield %inserted_2 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unpack_pivots_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_unpack_pivots_cpu_linalg.mlir new file mode 100644 index 000000000000..94697f78dcdd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unpack_pivots_cpu_linalg.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unpack_pivots_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1_i32 = arith.constant -1 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: i32): + %0 = linalg.index 0 : index + %1 = arith.index_cast %0 : index to i32 + linalg.yield %1 : i32 + } + affine.for %arg2 = 0 to 128 { + %0 = affine.load %arg0[%arg2] : memref + %1 = arith.addi %0, %c-1_i32 : i32 + %2 = affine.load %arg1[%arg2] : memref + %3 = arith.index_cast %1 : i32 to index + %4 = memref.load %arg1[%3] : memref + affine.store %4, %arg1[%arg2] : memref + memref.store %2, %arg1[%3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unsafe_index_cpu.mlir b/issues/aten_c_kernels/results/aten_unsafe_index_cpu.mlir new file mode 100644 index 000000000000..e9ac78a043db --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unsafe_index_cpu.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unsafe_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1] : memref + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unsafe_index_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_unsafe_index_cpu/debuf.mlir new file mode 100644 index 000000000000..c7e524e5a2ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unsafe_index_cpu/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unsafe_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%5] : memref + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unsafe_index_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_unsafe_index_cpu/matched.mlir new file mode 100644 index 000000000000..c7e524e5a2ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unsafe_index_cpu/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unsafe_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%5] : memref + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unsafe_index_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_unsafe_index_cpu/orig.mlir new file mode 100644 index 000000000000..e9ac78a043db --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unsafe_index_cpu/orig.mlir @@ -0,0 +1,11 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unsafe_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 512 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.index_cast %0 : i32 to index + %2 = memref.load %arg0[%1] : memref + affine.store %2, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_unsafe_index_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_unsafe_index_cpu/raised.mlir new file mode 100644 index 000000000000..fbd0e98d44f6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unsafe_index_cpu/raised.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unsafe_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg1[%0] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%2] : memref + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unsafe_index_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_unsafe_index_cpu_debuf.mlir new file mode 100644 index 000000000000..c7e524e5a2ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unsafe_index_cpu_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unsafe_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.index_cast %4 : i32 to index + %6 = memref.load %arg0[%5] : memref + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_unsafe_index_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_unsafe_index_cpu_linalg.mlir new file mode 100644 index 000000000000..fbd0e98d44f6 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_unsafe_index_cpu_linalg.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_unsafe_index_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg1[%0] : memref + %2 = arith.index_cast %1 : i32 to index + %3 = memref.load %arg0[%2] : memref + linalg.yield %3 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upper_bound_cpu.mlir b/issues/aten_c_kernels/results/aten_upper_bound_cpu.mlir new file mode 100644 index 000000000000..b23653f92240 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upper_bound_cpu.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upper_bound_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c256_i32 = arith.constant 256 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0:2 = scf.while (%arg4 = %c256_i32, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %1 = arith.cmpi slt, %arg5, %arg4 : i32 + scf.condition(%1) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %1 = arith.addi %arg4, %arg5 : i32 + %2 = arith.divsi %1, %c2_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3] : memref + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf ole, %4, %5 : f32 + %7 = arith.select %6, %arg5, %2 : i32 + %8 = scf.if %6 -> (i32) { + %9 = arith.addi %2, %c1_i32 : i32 + scf.yield %9 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %7, %8 : i32, i32 + } + affine.store %0#0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upper_bound_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upper_bound_cpu/debuf.mlir new file mode 100644 index 000000000000..be478bd792bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upper_bound_cpu/debuf.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upper_bound_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c256_i32 = arith.constant 256 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c256_i32, %arg6 = %c0_i32) : (i32, i32) -> (i32, i32) { + %6 = arith.cmpi slt, %arg6, %arg5 : i32 + scf.condition(%6) %arg6, %arg5 : i32, i32 + } do { + ^bb0(%arg5: i32, %arg6: i32): + %6 = arith.addi %arg5, %arg6 : i32 + %7 = arith.divsi %6, %c2_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %extracted = tensor.extract %2[%8] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %9 = arith.cmpf ole, %extracted, %extracted_0 : f32 + %10 = arith.select %9, %arg6, %7 : i32 + %11 = arith.addi %7, %c1_i32 : i32 + %12 = arith.select %9, %11, %arg5 : i32 + scf.yield %10, %12 : i32, i32 + } + %inserted = tensor.insert %5#0 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upper_bound_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upper_bound_cpu/matched.mlir new file mode 100644 index 000000000000..be478bd792bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upper_bound_cpu/matched.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upper_bound_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c256_i32 = arith.constant 256 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c256_i32, %arg6 = %c0_i32) : (i32, i32) -> (i32, i32) { + %6 = arith.cmpi slt, %arg6, %arg5 : i32 + scf.condition(%6) %arg6, %arg5 : i32, i32 + } do { + ^bb0(%arg5: i32, %arg6: i32): + %6 = arith.addi %arg5, %arg6 : i32 + %7 = arith.divsi %6, %c2_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %extracted = tensor.extract %2[%8] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %9 = arith.cmpf ole, %extracted, %extracted_0 : f32 + %10 = arith.select %9, %arg6, %7 : i32 + %11 = arith.addi %7, %c1_i32 : i32 + %12 = arith.select %9, %11, %arg5 : i32 + scf.yield %10, %12 : i32, i32 + } + %inserted = tensor.insert %5#0 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upper_bound_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upper_bound_cpu/orig.mlir new file mode 100644 index 000000000000..b23653f92240 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upper_bound_cpu/orig.mlir @@ -0,0 +1,32 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upper_bound_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c256_i32 = arith.constant 256 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0:2 = scf.while (%arg4 = %c256_i32, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %1 = arith.cmpi slt, %arg5, %arg4 : i32 + scf.condition(%1) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %1 = arith.addi %arg4, %arg5 : i32 + %2 = arith.divsi %1, %c2_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3] : memref + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf ole, %4, %5 : f32 + %7 = arith.select %6, %arg5, %2 : i32 + %8 = scf.if %6 -> (i32) { + %9 = arith.addi %2, %c1_i32 : i32 + scf.yield %9 : i32 + } else { + scf.yield %arg4 : i32 + } + scf.yield %7, %8 : i32, i32 + } + affine.store %0#0, %arg2[%arg3] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upper_bound_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upper_bound_cpu/raised.mlir new file mode 100644 index 000000000000..e0ee49cf8186 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upper_bound_cpu/raised.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upper_bound_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c256_i32 = arith.constant 256 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0:2 = scf.while (%arg4 = %c256_i32, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %1 = arith.cmpi slt, %arg5, %arg4 : i32 + scf.condition(%1) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %1 = arith.addi %arg4, %arg5 : i32 + %2 = arith.divsi %1, %c2_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3] : memref + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf ole, %4, %5 : f32 + %7 = arith.select %6, %arg5, %2 : i32 + %8 = arith.addi %2, %c1_i32 : i32 + %9 = arith.select %6, %8, %arg4 : i32 + scf.yield %7, %9 : i32, i32 + } + affine.store %0#0, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upper_bound_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upper_bound_cpu_debuf.mlir new file mode 100644 index 000000000000..be478bd792bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upper_bound_cpu_debuf.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upper_bound_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c256_i32 = arith.constant 256 : i32 + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = affine.for %arg3 = 0 to 128 iter_args(%arg4 = %0) -> (tensor) { + %5:2 = scf.while (%arg5 = %c256_i32, %arg6 = %c0_i32) : (i32, i32) -> (i32, i32) { + %6 = arith.cmpi slt, %arg6, %arg5 : i32 + scf.condition(%6) %arg6, %arg5 : i32, i32 + } do { + ^bb0(%arg5: i32, %arg6: i32): + %6 = arith.addi %arg5, %arg6 : i32 + %7 = arith.divsi %6, %c2_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %extracted = tensor.extract %2[%8] : tensor + %extracted_0 = tensor.extract %1[%arg3] : tensor + %9 = arith.cmpf ole, %extracted, %extracted_0 : f32 + %10 = arith.select %9, %arg6, %7 : i32 + %11 = arith.addi %7, %c1_i32 : i32 + %12 = arith.select %9, %11, %arg5 : i32 + scf.yield %10, %12 : i32, i32 + } + %inserted = tensor.insert %5#0 into %arg4[%arg3] : tensor + affine.yield %inserted : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upper_bound_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upper_bound_cpu_linalg.mlir new file mode 100644 index 000000000000..e0ee49cf8186 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upper_bound_cpu_linalg.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upper_bound_cpu(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c256_i32 = arith.constant 256 : i32 + %c0_i32 = arith.constant 0 : i32 + affine.for %arg3 = 0 to 128 { + %0:2 = scf.while (%arg4 = %c256_i32, %arg5 = %c0_i32) : (i32, i32) -> (i32, i32) { + %1 = arith.cmpi slt, %arg5, %arg4 : i32 + scf.condition(%1) %arg5, %arg4 : i32, i32 + } do { + ^bb0(%arg4: i32, %arg5: i32): + %1 = arith.addi %arg4, %arg5 : i32 + %2 = arith.divsi %1, %c2_i32 : i32 + %3 = arith.index_cast %2 : i32 to index + %4 = memref.load %arg0[%3] : memref + %5 = affine.load %arg1[%arg3] : memref + %6 = arith.cmpf ole, %4, %5 : f32 + %7 = arith.select %6, %arg5, %2 : i32 + %8 = arith.addi %2, %c1_i32 : i32 + %9 = arith.select %6, %8, %arg4 : i32 + scf.yield %7, %9 : i32, i32 + } + affine.store %0#0, %arg2[%arg3] : memref + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu.mlir new file mode 100644 index 000000000000..6eaa4f420721 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu.mlir @@ -0,0 +1,185 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant -5.000000e-01 : f32 + %cst_2 = arith.constant 2.500000e+00 : f32 + %cst_3 = arith.constant 1.500000e+00 : f32 + %cst_4 = arith.constant 2.000000e+00 : f32 + %cst_5 = arith.constant 5.000000e-01 : f32 + %cst_6 = arith.constant 1.000000e+00 : f32 + %cst_7 = arith.constant 4.000000e+00 : f32 + %cst_8 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 40 { + affine.store %cst_8, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_5 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_5 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_5 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_5 : f32 + %10 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_8) -> (f32) { + %11 = arith.index_cast %arg5 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.subf %4, %12 : f32 + %14 = arith.cmpf olt, %13, %cst_8 : f32 + %15 = scf.if %14 -> (f32) { + %20 = arith.negf %13 : f32 + scf.yield %20 : f32 + } else { + scf.yield %13 : f32 + } + %16 = arith.cmpf olt, %15, %cst_4 : f32 + %17 = arith.cmpf olt, %15, %cst_6 : f32 + %18 = scf.if %16 -> (f32) { + %20 = scf.if %17 -> (f32) { + %21 = arith.mulf %15, %cst_3 : f32 + %22 = arith.subf %21, %cst_2 : f32 + %23 = arith.mulf %22, %15 : f32 + %24 = arith.mulf %23, %15 : f32 + %25 = arith.addf %24, %cst_6 : f32 + scf.yield %25 : f32 + } else { + %21 = arith.mulf %15, %cst_1 : f32 + %22 = arith.addf %21, %cst_2 : f32 + %23 = arith.mulf %22, %15 : f32 + %24 = arith.subf %23, %cst_7 : f32 + %25 = arith.mulf %24, %15 : f32 + %26 = arith.addf %25, %cst_4 : f32 + scf.yield %26 : f32 + } + scf.yield %20 : f32 + } else { + scf.yield %cst_8 : f32 + } + %19 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %20 = arith.index_cast %arg7 : index to i32 + %21 = arith.sitofp %20 : i32 to f32 + %22 = arith.subf %9, %21 : f32 + %23 = arith.cmpf olt, %22, %cst_8 : f32 + %24 = scf.if %23 -> (f32) { + %30 = arith.negf %22 : f32 + scf.yield %30 : f32 + } else { + scf.yield %22 : f32 + } + %25 = arith.cmpf olt, %24, %cst_4 : f32 + %26 = arith.cmpf olt, %24, %cst_6 : f32 + %27 = scf.if %25 -> (f32) { + %30 = scf.if %26 -> (f32) { + %31 = arith.mulf %24, %cst_3 : f32 + %32 = arith.subf %31, %cst_2 : f32 + %33 = arith.mulf %32, %24 : f32 + %34 = arith.mulf %33, %24 : f32 + %35 = arith.addf %34, %cst_6 : f32 + scf.yield %35 : f32 + } else { + %31 = arith.mulf %24, %cst_1 : f32 + %32 = arith.addf %31, %cst_2 : f32 + %33 = arith.mulf %32, %24 : f32 + %34 = arith.subf %33, %cst_7 : f32 + %35 = arith.mulf %34, %24 : f32 + %36 = arith.addf %35, %cst_4 : f32 + scf.yield %36 : f32 + } + scf.yield %30 : f32 + } else { + scf.yield %cst_8 : f32 + } + %28 = arith.mulf %18, %27 : f32 + %29 = arith.addf %arg8, %28 : f32 + affine.yield %29 : f32 + } + affine.yield %19 : f32 + } + affine.for %arg5 = 0 to 4 { + %11 = arith.index_cast %arg5 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.subf %4, %12 : f32 + %14 = arith.cmpf olt, %13, %cst_8 : f32 + %15 = scf.if %14 -> (f32) { + %19 = arith.negf %13 : f32 + scf.yield %19 : f32 + } else { + scf.yield %13 : f32 + } + %16 = arith.cmpf olt, %15, %cst_4 : f32 + %17 = arith.cmpf olt, %15, %cst_6 : f32 + %18 = scf.if %16 -> (f32) { + %19 = scf.if %17 -> (f32) { + %20 = arith.mulf %15, %cst_3 : f32 + %21 = arith.subf %20, %cst_2 : f32 + %22 = arith.mulf %21, %15 : f32 + %23 = arith.mulf %22, %15 : f32 + %24 = arith.addf %23, %cst_6 : f32 + scf.yield %24 : f32 + } else { + %20 = arith.mulf %15, %cst_1 : f32 + %21 = arith.addf %20, %cst_2 : f32 + %22 = arith.mulf %21, %15 : f32 + %23 = arith.subf %22, %cst_7 : f32 + %24 = arith.mulf %23, %15 : f32 + %25 = arith.addf %24, %cst_4 : f32 + scf.yield %25 : f32 + } + scf.yield %19 : f32 + } else { + scf.yield %cst_8 : f32 + } + affine.for %arg6 = 0 to 5 { + %19 = arith.index_cast %arg6 : index to i32 + %20 = arith.sitofp %19 : i32 to f32 + %21 = arith.subf %9, %20 : f32 + %22 = arith.cmpf olt, %21, %cst_8 : f32 + %23 = scf.if %22 -> (f32) { + %33 = arith.negf %21 : f32 + scf.yield %33 : f32 + } else { + scf.yield %21 : f32 + } + %24 = arith.cmpf olt, %23, %cst_4 : f32 + %25 = arith.cmpf olt, %23, %cst_6 : f32 + %26 = scf.if %24 -> (f32) { + %33 = scf.if %25 -> (f32) { + %34 = arith.mulf %23, %cst_3 : f32 + %35 = arith.subf %34, %cst_2 : f32 + %36 = arith.mulf %35, %23 : f32 + %37 = arith.mulf %36, %23 : f32 + %38 = arith.addf %37, %cst_6 : f32 + scf.yield %38 : f32 + } else { + %34 = arith.mulf %23, %cst_1 : f32 + %35 = arith.addf %34, %cst_2 : f32 + %36 = arith.mulf %35, %23 : f32 + %37 = arith.subf %36, %cst_7 : f32 + %38 = arith.mulf %37, %23 : f32 + %39 = arith.addf %38, %cst_4 : f32 + scf.yield %39 : f32 + } + scf.yield %33 : f32 + } else { + scf.yield %cst_8 : f32 + } + %27 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %28 = arith.mulf %27, %18 : f32 + %29 = arith.mulf %28, %26 : f32 + %30 = arith.divf %29, %10 : f32 + %31 = affine.load %arg1[%arg6 + %arg2 * 20 + %arg5 * 5] : memref + %32 = arith.addf %31, %30 : f32 + affine.store %32, %arg1[%arg6 + %arg2 * 20 + %arg5 * 5] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..9cbec466208f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu/debuf.mlir @@ -0,0 +1,161 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map4 = affine_map<(d0, d1)[s0, s1, s2] -> (s0 + s1 * 56 + s2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %cst_3 = arith.constant 2.000000e+00 : f32 + %cst_4 = arith.constant 1.500000e+00 : f32 + %cst_5 = arith.constant 2.500000e+00 : f32 + %cst_6 = arith.constant -5.000000e-01 : f32 + %cst_7 = arith.constant 6.250000e-01 : f32 + %cst_8 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %6 = arith.index_cast %arg4 : index to i32 + %7 = arith.sitofp %6 : i32 to f32 + %8 = arith.addf %7, %cst_2 : f32 + %9 = arith.mulf %8, %cst_8 : f32 + %10 = arith.subf %9, %cst_2 : f32 + %11 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %12 = arith.index_cast %arg6 : index to i32 + %13 = arith.sitofp %12 : i32 to f32 + %14 = arith.addf %13, %cst_2 : f32 + %15 = arith.mulf %14, %cst_7 : f32 + %16 = arith.subf %15, %cst_2 : f32 + %alloca = memref.alloca() : memref + %17 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %17[] : tensor + %18 = polygeist.submap(%inserted, %c4, %c5) {map = #map1} : (tensor, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%18 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_3 : f32 + %33 = arith.cmpf olt, %31, %cst_1 : f32 + %34 = arith.mulf %31, %cst_4 : f32 + %35 = arith.subf %34, %cst_5 : f32 + %36 = arith.mulf %35, %31 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = arith.addf %37, %cst_1 : f32 + %39 = arith.mulf %31, %cst_6 : f32 + %40 = arith.addf %39, %cst_5 : f32 + %41 = arith.mulf %40, %31 : f32 + %42 = arith.subf %41, %cst_0 : f32 + %43 = arith.mulf %42, %31 : f32 + %44 = arith.addf %43, %cst_3 : f32 + %45 = arith.select %33, %38, %44 : f32 + %46 = arith.select %32, %45, %cst : f32 + %47 = linalg.index 1 : index + %48 = arith.index_cast %47 : index to i32 + %49 = arith.sitofp %48 : i32 to f32 + %50 = arith.subf %16, %49 : f32 + %51 = arith.cmpf olt, %50, %cst : f32 + %52 = arith.negf %50 : f32 + %53 = arith.select %51, %52, %50 : f32 + %54 = arith.cmpf olt, %53, %cst_3 : f32 + %55 = arith.cmpf olt, %53, %cst_1 : f32 + %56 = arith.mulf %53, %cst_4 : f32 + %57 = arith.subf %56, %cst_5 : f32 + %58 = arith.mulf %57, %53 : f32 + %59 = arith.mulf %58, %53 : f32 + %60 = arith.addf %59, %cst_1 : f32 + %61 = arith.mulf %53, %cst_6 : f32 + %62 = arith.addf %61, %cst_5 : f32 + %63 = arith.mulf %62, %53 : f32 + %64 = arith.subf %63, %cst_0 : f32 + %65 = arith.mulf %64, %53 : f32 + %66 = arith.addf %65, %cst_3 : f32 + %67 = arith.select %55, %60, %66 : f32 + %68 = arith.select %54, %67, %cst : f32 + %69 = arith.mulf %46, %68 : f32 + %70 = arith.addf %out, %69 : f32 + linalg.yield %70 : f32 + } -> tensor + %20 = polygeist.submapInverse(%inserted, %19, %c4, %c5) {map = #map1} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %20[] : tensor + %21 = polygeist.submap(%arg7, %arg2, %c4, %c5) {map = #map3} : (tensor, index, index, index) -> tensor + %22 = polygeist.submap(%0, %arg6, %arg2, %arg4, %c4, %c5) {map = #map4} : (tensor, index, index, index, index, index) -> tensor + %23 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%22 : tensor) outs(%21 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_3 : f32 + %33 = arith.cmpf olt, %31, %cst_1 : f32 + %34 = arith.mulf %31, %cst_4 : f32 + %35 = arith.subf %34, %cst_5 : f32 + %36 = arith.mulf %35, %31 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = arith.addf %37, %cst_1 : f32 + %39 = arith.mulf %31, %cst_6 : f32 + %40 = arith.addf %39, %cst_5 : f32 + %41 = arith.mulf %40, %31 : f32 + %42 = arith.subf %41, %cst_0 : f32 + %43 = arith.mulf %42, %31 : f32 + %44 = arith.addf %43, %cst_3 : f32 + %45 = arith.select %33, %38, %44 : f32 + %46 = arith.select %32, %45, %cst : f32 + %47 = linalg.index 1 : index + %48 = arith.index_cast %47 : index to i32 + %49 = arith.sitofp %48 : i32 to f32 + %50 = arith.subf %16, %49 : f32 + %51 = arith.cmpf olt, %50, %cst : f32 + %52 = arith.negf %50 : f32 + %53 = arith.select %51, %52, %50 : f32 + %54 = arith.cmpf olt, %53, %cst_3 : f32 + %55 = arith.cmpf olt, %53, %cst_1 : f32 + %56 = arith.mulf %53, %cst_4 : f32 + %57 = arith.subf %56, %cst_5 : f32 + %58 = arith.mulf %57, %53 : f32 + %59 = arith.mulf %58, %53 : f32 + %60 = arith.addf %59, %cst_1 : f32 + %61 = arith.mulf %53, %cst_6 : f32 + %62 = arith.addf %61, %cst_5 : f32 + %63 = arith.mulf %62, %53 : f32 + %64 = arith.subf %63, %cst_0 : f32 + %65 = arith.mulf %64, %53 : f32 + %66 = arith.addf %65, %cst_3 : f32 + %67 = arith.select %55, %60, %66 : f32 + %68 = arith.select %54, %67, %cst : f32 + %69 = arith.mulf %in, %46 : f32 + %70 = arith.mulf %69, %68 : f32 + %71 = arith.divf %70, %extracted : f32 + %72 = arith.addf %out, %71 : f32 + linalg.yield %72 : f32 + } -> tensor + %24 = polygeist.submapInverse(%arg7, %23, %arg2, %c4, %c5) {map = #map3} : (tensor, tensor, index, index, index) -> tensor + affine.yield %24 : tensor + } + affine.yield %11 : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu/matched.mlir new file mode 100644 index 000000000000..3f0eb1b69014 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu/matched.mlir @@ -0,0 +1,158 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map4 = affine_map<(d0, d1)[s0, s1, s2] -> (s0 + s1 * 56 + s2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %cst_3 = arith.constant 2.000000e+00 : f32 + %cst_4 = arith.constant 1.500000e+00 : f32 + %cst_5 = arith.constant 2.500000e+00 : f32 + %cst_6 = arith.constant -5.000000e-01 : f32 + %cst_7 = arith.constant 6.250000e-01 : f32 + %cst_8 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = kernel.launch @memset_zero_1D_f32(%1) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %6 = arith.index_cast %arg4 : index to i32 + %7 = arith.sitofp %6 : i32 to f32 + %8 = arith.addf %7, %cst_2 : f32 + %9 = arith.mulf %8, %cst_8 : f32 + %10 = arith.subf %9, %cst_2 : f32 + %11 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %12 = arith.index_cast %arg6 : index to i32 + %13 = arith.sitofp %12 : i32 to f32 + %14 = arith.addf %13, %cst_2 : f32 + %15 = arith.mulf %14, %cst_7 : f32 + %16 = arith.subf %15, %cst_2 : f32 + %alloca = memref.alloca() : memref + %17 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %17[] : tensor + %18 = polygeist.submap(%inserted, %c4, %c5) {map = #map1} : (tensor, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%18 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_3 : f32 + %33 = arith.cmpf olt, %31, %cst_1 : f32 + %34 = arith.mulf %31, %cst_4 : f32 + %35 = arith.subf %34, %cst_5 : f32 + %36 = arith.mulf %35, %31 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = arith.addf %37, %cst_1 : f32 + %39 = arith.mulf %31, %cst_6 : f32 + %40 = arith.addf %39, %cst_5 : f32 + %41 = arith.mulf %40, %31 : f32 + %42 = arith.subf %41, %cst_0 : f32 + %43 = arith.mulf %42, %31 : f32 + %44 = arith.addf %43, %cst_3 : f32 + %45 = arith.select %33, %38, %44 : f32 + %46 = arith.select %32, %45, %cst : f32 + %47 = linalg.index 1 : index + %48 = arith.index_cast %47 : index to i32 + %49 = arith.sitofp %48 : i32 to f32 + %50 = arith.subf %16, %49 : f32 + %51 = arith.cmpf olt, %50, %cst : f32 + %52 = arith.negf %50 : f32 + %53 = arith.select %51, %52, %50 : f32 + %54 = arith.cmpf olt, %53, %cst_3 : f32 + %55 = arith.cmpf olt, %53, %cst_1 : f32 + %56 = arith.mulf %53, %cst_4 : f32 + %57 = arith.subf %56, %cst_5 : f32 + %58 = arith.mulf %57, %53 : f32 + %59 = arith.mulf %58, %53 : f32 + %60 = arith.addf %59, %cst_1 : f32 + %61 = arith.mulf %53, %cst_6 : f32 + %62 = arith.addf %61, %cst_5 : f32 + %63 = arith.mulf %62, %53 : f32 + %64 = arith.subf %63, %cst_0 : f32 + %65 = arith.mulf %64, %53 : f32 + %66 = arith.addf %65, %cst_3 : f32 + %67 = arith.select %55, %60, %66 : f32 + %68 = arith.select %54, %67, %cst : f32 + %69 = arith.mulf %46, %68 : f32 + %70 = arith.addf %out, %69 : f32 + linalg.yield %70 : f32 + } -> tensor + %20 = polygeist.submapInverse(%inserted, %19, %c4, %c5) {map = #map1} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %20[] : tensor + %21 = polygeist.submap(%arg7, %arg2, %c4, %c5) {map = #map3} : (tensor, index, index, index) -> tensor + %22 = polygeist.submap(%0, %arg6, %arg2, %arg4, %c4, %c5) {map = #map4} : (tensor, index, index, index, index, index) -> tensor + %23 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%22 : tensor) outs(%21 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_3 : f32 + %33 = arith.cmpf olt, %31, %cst_1 : f32 + %34 = arith.mulf %31, %cst_4 : f32 + %35 = arith.subf %34, %cst_5 : f32 + %36 = arith.mulf %35, %31 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = arith.addf %37, %cst_1 : f32 + %39 = arith.mulf %31, %cst_6 : f32 + %40 = arith.addf %39, %cst_5 : f32 + %41 = arith.mulf %40, %31 : f32 + %42 = arith.subf %41, %cst_0 : f32 + %43 = arith.mulf %42, %31 : f32 + %44 = arith.addf %43, %cst_3 : f32 + %45 = arith.select %33, %38, %44 : f32 + %46 = arith.select %32, %45, %cst : f32 + %47 = linalg.index 1 : index + %48 = arith.index_cast %47 : index to i32 + %49 = arith.sitofp %48 : i32 to f32 + %50 = arith.subf %16, %49 : f32 + %51 = arith.cmpf olt, %50, %cst : f32 + %52 = arith.negf %50 : f32 + %53 = arith.select %51, %52, %50 : f32 + %54 = arith.cmpf olt, %53, %cst_3 : f32 + %55 = arith.cmpf olt, %53, %cst_1 : f32 + %56 = arith.mulf %53, %cst_4 : f32 + %57 = arith.subf %56, %cst_5 : f32 + %58 = arith.mulf %57, %53 : f32 + %59 = arith.mulf %58, %53 : f32 + %60 = arith.addf %59, %cst_1 : f32 + %61 = arith.mulf %53, %cst_6 : f32 + %62 = arith.addf %61, %cst_5 : f32 + %63 = arith.mulf %62, %53 : f32 + %64 = arith.subf %63, %cst_0 : f32 + %65 = arith.mulf %64, %53 : f32 + %66 = arith.addf %65, %cst_3 : f32 + %67 = arith.select %55, %60, %66 : f32 + %68 = arith.select %54, %67, %cst : f32 + %69 = arith.mulf %in, %46 : f32 + %70 = arith.mulf %69, %68 : f32 + %71 = arith.divf %70, %extracted : f32 + %72 = arith.addf %out, %71 : f32 + linalg.yield %72 : f32 + } -> tensor + %24 = polygeist.submapInverse(%arg7, %23, %arg2, %c4, %c5) {map = #map3} : (tensor, tensor, index, index, index) -> tensor + affine.yield %24 : tensor + } + affine.yield %11 : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu/orig.mlir new file mode 100644 index 000000000000..6eaa4f420721 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu/orig.mlir @@ -0,0 +1,185 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant -5.000000e-01 : f32 + %cst_2 = arith.constant 2.500000e+00 : f32 + %cst_3 = arith.constant 1.500000e+00 : f32 + %cst_4 = arith.constant 2.000000e+00 : f32 + %cst_5 = arith.constant 5.000000e-01 : f32 + %cst_6 = arith.constant 1.000000e+00 : f32 + %cst_7 = arith.constant 4.000000e+00 : f32 + %cst_8 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 40 { + affine.store %cst_8, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_5 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_5 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_5 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_5 : f32 + %10 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_8) -> (f32) { + %11 = arith.index_cast %arg5 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.subf %4, %12 : f32 + %14 = arith.cmpf olt, %13, %cst_8 : f32 + %15 = scf.if %14 -> (f32) { + %20 = arith.negf %13 : f32 + scf.yield %20 : f32 + } else { + scf.yield %13 : f32 + } + %16 = arith.cmpf olt, %15, %cst_4 : f32 + %17 = arith.cmpf olt, %15, %cst_6 : f32 + %18 = scf.if %16 -> (f32) { + %20 = scf.if %17 -> (f32) { + %21 = arith.mulf %15, %cst_3 : f32 + %22 = arith.subf %21, %cst_2 : f32 + %23 = arith.mulf %22, %15 : f32 + %24 = arith.mulf %23, %15 : f32 + %25 = arith.addf %24, %cst_6 : f32 + scf.yield %25 : f32 + } else { + %21 = arith.mulf %15, %cst_1 : f32 + %22 = arith.addf %21, %cst_2 : f32 + %23 = arith.mulf %22, %15 : f32 + %24 = arith.subf %23, %cst_7 : f32 + %25 = arith.mulf %24, %15 : f32 + %26 = arith.addf %25, %cst_4 : f32 + scf.yield %26 : f32 + } + scf.yield %20 : f32 + } else { + scf.yield %cst_8 : f32 + } + %19 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %20 = arith.index_cast %arg7 : index to i32 + %21 = arith.sitofp %20 : i32 to f32 + %22 = arith.subf %9, %21 : f32 + %23 = arith.cmpf olt, %22, %cst_8 : f32 + %24 = scf.if %23 -> (f32) { + %30 = arith.negf %22 : f32 + scf.yield %30 : f32 + } else { + scf.yield %22 : f32 + } + %25 = arith.cmpf olt, %24, %cst_4 : f32 + %26 = arith.cmpf olt, %24, %cst_6 : f32 + %27 = scf.if %25 -> (f32) { + %30 = scf.if %26 -> (f32) { + %31 = arith.mulf %24, %cst_3 : f32 + %32 = arith.subf %31, %cst_2 : f32 + %33 = arith.mulf %32, %24 : f32 + %34 = arith.mulf %33, %24 : f32 + %35 = arith.addf %34, %cst_6 : f32 + scf.yield %35 : f32 + } else { + %31 = arith.mulf %24, %cst_1 : f32 + %32 = arith.addf %31, %cst_2 : f32 + %33 = arith.mulf %32, %24 : f32 + %34 = arith.subf %33, %cst_7 : f32 + %35 = arith.mulf %34, %24 : f32 + %36 = arith.addf %35, %cst_4 : f32 + scf.yield %36 : f32 + } + scf.yield %30 : f32 + } else { + scf.yield %cst_8 : f32 + } + %28 = arith.mulf %18, %27 : f32 + %29 = arith.addf %arg8, %28 : f32 + affine.yield %29 : f32 + } + affine.yield %19 : f32 + } + affine.for %arg5 = 0 to 4 { + %11 = arith.index_cast %arg5 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.subf %4, %12 : f32 + %14 = arith.cmpf olt, %13, %cst_8 : f32 + %15 = scf.if %14 -> (f32) { + %19 = arith.negf %13 : f32 + scf.yield %19 : f32 + } else { + scf.yield %13 : f32 + } + %16 = arith.cmpf olt, %15, %cst_4 : f32 + %17 = arith.cmpf olt, %15, %cst_6 : f32 + %18 = scf.if %16 -> (f32) { + %19 = scf.if %17 -> (f32) { + %20 = arith.mulf %15, %cst_3 : f32 + %21 = arith.subf %20, %cst_2 : f32 + %22 = arith.mulf %21, %15 : f32 + %23 = arith.mulf %22, %15 : f32 + %24 = arith.addf %23, %cst_6 : f32 + scf.yield %24 : f32 + } else { + %20 = arith.mulf %15, %cst_1 : f32 + %21 = arith.addf %20, %cst_2 : f32 + %22 = arith.mulf %21, %15 : f32 + %23 = arith.subf %22, %cst_7 : f32 + %24 = arith.mulf %23, %15 : f32 + %25 = arith.addf %24, %cst_4 : f32 + scf.yield %25 : f32 + } + scf.yield %19 : f32 + } else { + scf.yield %cst_8 : f32 + } + affine.for %arg6 = 0 to 5 { + %19 = arith.index_cast %arg6 : index to i32 + %20 = arith.sitofp %19 : i32 to f32 + %21 = arith.subf %9, %20 : f32 + %22 = arith.cmpf olt, %21, %cst_8 : f32 + %23 = scf.if %22 -> (f32) { + %33 = arith.negf %21 : f32 + scf.yield %33 : f32 + } else { + scf.yield %21 : f32 + } + %24 = arith.cmpf olt, %23, %cst_4 : f32 + %25 = arith.cmpf olt, %23, %cst_6 : f32 + %26 = scf.if %24 -> (f32) { + %33 = scf.if %25 -> (f32) { + %34 = arith.mulf %23, %cst_3 : f32 + %35 = arith.subf %34, %cst_2 : f32 + %36 = arith.mulf %35, %23 : f32 + %37 = arith.mulf %36, %23 : f32 + %38 = arith.addf %37, %cst_6 : f32 + scf.yield %38 : f32 + } else { + %34 = arith.mulf %23, %cst_1 : f32 + %35 = arith.addf %34, %cst_2 : f32 + %36 = arith.mulf %35, %23 : f32 + %37 = arith.subf %36, %cst_7 : f32 + %38 = arith.mulf %37, %23 : f32 + %39 = arith.addf %38, %cst_4 : f32 + scf.yield %39 : f32 + } + scf.yield %33 : f32 + } else { + scf.yield %cst_8 : f32 + } + %27 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %28 = arith.mulf %27, %18 : f32 + %29 = arith.mulf %28, %26 : f32 + %30 = arith.divf %29, %10 : f32 + %31 = affine.load %arg1[%arg6 + %arg2 * 20 + %arg5 * 5] : memref + %32 = arith.addf %31, %30 : f32 + affine.store %32, %arg1[%arg6 + %arg2 * 20 + %arg5 * 5] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu/raised.mlir new file mode 100644 index 000000000000..295e4aaa8928 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu/raised.mlir @@ -0,0 +1,151 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1)[s0, s1, s2] -> (s0 + s1 * 56 + s2 * 8)> +#map4 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant -5.000000e-01 : f32 + %cst_2 = arith.constant 2.500000e+00 : f32 + %cst_3 = arith.constant 1.500000e+00 : f32 + %cst_4 = arith.constant 2.000000e+00 : f32 + %cst_5 = arith.constant 5.000000e-01 : f32 + %cst_6 = arith.constant 1.000000e+00 : f32 + %cst_7 = arith.constant 4.000000e+00 : f32 + %cst_8 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_8 : f32 + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_5 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_5 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_5 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_5 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_8, %alloca[] : memref + %10 = polygeist.submap(%alloca, %c4, %c5) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map2], iterator_types = ["reduction", "reduction"]} outs(%10 : memref) { + ^bb0(%out: f32): + %14 = linalg.index 0 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.sitofp %15 : i32 to f32 + %17 = arith.subf %4, %16 : f32 + %18 = arith.cmpf olt, %17, %cst_8 : f32 + %19 = arith.negf %17 : f32 + %20 = arith.select %18, %19, %17 : f32 + %21 = arith.cmpf olt, %20, %cst_4 : f32 + %22 = arith.cmpf olt, %20, %cst_6 : f32 + %23 = arith.mulf %20, %cst_3 : f32 + %24 = arith.subf %23, %cst_2 : f32 + %25 = arith.mulf %24, %20 : f32 + %26 = arith.mulf %25, %20 : f32 + %27 = arith.addf %26, %cst_6 : f32 + %28 = arith.mulf %20, %cst_1 : f32 + %29 = arith.addf %28, %cst_2 : f32 + %30 = arith.mulf %29, %20 : f32 + %31 = arith.subf %30, %cst_7 : f32 + %32 = arith.mulf %31, %20 : f32 + %33 = arith.addf %32, %cst_4 : f32 + %34 = arith.select %22, %27, %33 : f32 + %35 = arith.select %21, %34, %cst_8 : f32 + %36 = linalg.index 1 : index + %37 = arith.index_cast %36 : index to i32 + %38 = arith.sitofp %37 : i32 to f32 + %39 = arith.subf %9, %38 : f32 + %40 = arith.cmpf olt, %39, %cst_8 : f32 + %41 = arith.negf %39 : f32 + %42 = arith.select %40, %41, %39 : f32 + %43 = arith.cmpf olt, %42, %cst_4 : f32 + %44 = arith.cmpf olt, %42, %cst_6 : f32 + %45 = arith.mulf %42, %cst_3 : f32 + %46 = arith.subf %45, %cst_2 : f32 + %47 = arith.mulf %46, %42 : f32 + %48 = arith.mulf %47, %42 : f32 + %49 = arith.addf %48, %cst_6 : f32 + %50 = arith.mulf %42, %cst_1 : f32 + %51 = arith.addf %50, %cst_2 : f32 + %52 = arith.mulf %51, %42 : f32 + %53 = arith.subf %52, %cst_7 : f32 + %54 = arith.mulf %53, %42 : f32 + %55 = arith.addf %54, %cst_4 : f32 + %56 = arith.select %44, %49, %55 : f32 + %57 = arith.select %43, %56, %cst_8 : f32 + %58 = arith.mulf %35, %57 : f32 + %59 = arith.addf %out, %58 : f32 + linalg.yield %59 : f32 + } + %11 = affine.load %alloca[] : memref + %12 = polygeist.submap(%arg0, %arg4, %arg2, %arg3, %c4, %c5) {map = #map3} : (memref, index, index, index, index, index) -> memref + %13 = polygeist.submap(%arg1, %arg2, %c4, %c5) {map = #map4} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%12 : memref) outs(%13 : memref) { + ^bb0(%in: f32, %out: f32): + %14 = linalg.index 0 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.sitofp %15 : i32 to f32 + %17 = arith.subf %4, %16 : f32 + %18 = arith.cmpf olt, %17, %cst_8 : f32 + %19 = arith.negf %17 : f32 + %20 = arith.select %18, %19, %17 : f32 + %21 = arith.cmpf olt, %20, %cst_4 : f32 + %22 = arith.cmpf olt, %20, %cst_6 : f32 + %23 = arith.mulf %20, %cst_3 : f32 + %24 = arith.subf %23, %cst_2 : f32 + %25 = arith.mulf %24, %20 : f32 + %26 = arith.mulf %25, %20 : f32 + %27 = arith.addf %26, %cst_6 : f32 + %28 = arith.mulf %20, %cst_1 : f32 + %29 = arith.addf %28, %cst_2 : f32 + %30 = arith.mulf %29, %20 : f32 + %31 = arith.subf %30, %cst_7 : f32 + %32 = arith.mulf %31, %20 : f32 + %33 = arith.addf %32, %cst_4 : f32 + %34 = arith.select %22, %27, %33 : f32 + %35 = arith.select %21, %34, %cst_8 : f32 + %36 = linalg.index 1 : index + %37 = arith.index_cast %36 : index to i32 + %38 = arith.sitofp %37 : i32 to f32 + %39 = arith.subf %9, %38 : f32 + %40 = arith.cmpf olt, %39, %cst_8 : f32 + %41 = arith.negf %39 : f32 + %42 = arith.select %40, %41, %39 : f32 + %43 = arith.cmpf olt, %42, %cst_4 : f32 + %44 = arith.cmpf olt, %42, %cst_6 : f32 + %45 = arith.mulf %42, %cst_3 : f32 + %46 = arith.subf %45, %cst_2 : f32 + %47 = arith.mulf %46, %42 : f32 + %48 = arith.mulf %47, %42 : f32 + %49 = arith.addf %48, %cst_6 : f32 + %50 = arith.mulf %42, %cst_1 : f32 + %51 = arith.addf %50, %cst_2 : f32 + %52 = arith.mulf %51, %42 : f32 + %53 = arith.subf %52, %cst_7 : f32 + %54 = arith.mulf %53, %42 : f32 + %55 = arith.addf %54, %cst_4 : f32 + %56 = arith.select %44, %49, %55 : f32 + %57 = arith.select %43, %56, %cst_8 : f32 + %58 = arith.mulf %in, %35 : f32 + %59 = arith.mulf %58, %57 : f32 + %60 = arith.divf %59, %11 : f32 + %61 = arith.addf %out, %60 : f32 + linalg.yield %61 : f32 + } + } + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..9cbec466208f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu_debuf.mlir @@ -0,0 +1,161 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map4 = affine_map<(d0, d1)[s0, s1, s2] -> (s0 + s1 * 56 + s2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %cst_3 = arith.constant 2.000000e+00 : f32 + %cst_4 = arith.constant 1.500000e+00 : f32 + %cst_5 = arith.constant 2.500000e+00 : f32 + %cst_6 = arith.constant -5.000000e-01 : f32 + %cst_7 = arith.constant 6.250000e-01 : f32 + %cst_8 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %6 = arith.index_cast %arg4 : index to i32 + %7 = arith.sitofp %6 : i32 to f32 + %8 = arith.addf %7, %cst_2 : f32 + %9 = arith.mulf %8, %cst_8 : f32 + %10 = arith.subf %9, %cst_2 : f32 + %11 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %12 = arith.index_cast %arg6 : index to i32 + %13 = arith.sitofp %12 : i32 to f32 + %14 = arith.addf %13, %cst_2 : f32 + %15 = arith.mulf %14, %cst_7 : f32 + %16 = arith.subf %15, %cst_2 : f32 + %alloca = memref.alloca() : memref + %17 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %17[] : tensor + %18 = polygeist.submap(%inserted, %c4, %c5) {map = #map1} : (tensor, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%18 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_3 : f32 + %33 = arith.cmpf olt, %31, %cst_1 : f32 + %34 = arith.mulf %31, %cst_4 : f32 + %35 = arith.subf %34, %cst_5 : f32 + %36 = arith.mulf %35, %31 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = arith.addf %37, %cst_1 : f32 + %39 = arith.mulf %31, %cst_6 : f32 + %40 = arith.addf %39, %cst_5 : f32 + %41 = arith.mulf %40, %31 : f32 + %42 = arith.subf %41, %cst_0 : f32 + %43 = arith.mulf %42, %31 : f32 + %44 = arith.addf %43, %cst_3 : f32 + %45 = arith.select %33, %38, %44 : f32 + %46 = arith.select %32, %45, %cst : f32 + %47 = linalg.index 1 : index + %48 = arith.index_cast %47 : index to i32 + %49 = arith.sitofp %48 : i32 to f32 + %50 = arith.subf %16, %49 : f32 + %51 = arith.cmpf olt, %50, %cst : f32 + %52 = arith.negf %50 : f32 + %53 = arith.select %51, %52, %50 : f32 + %54 = arith.cmpf olt, %53, %cst_3 : f32 + %55 = arith.cmpf olt, %53, %cst_1 : f32 + %56 = arith.mulf %53, %cst_4 : f32 + %57 = arith.subf %56, %cst_5 : f32 + %58 = arith.mulf %57, %53 : f32 + %59 = arith.mulf %58, %53 : f32 + %60 = arith.addf %59, %cst_1 : f32 + %61 = arith.mulf %53, %cst_6 : f32 + %62 = arith.addf %61, %cst_5 : f32 + %63 = arith.mulf %62, %53 : f32 + %64 = arith.subf %63, %cst_0 : f32 + %65 = arith.mulf %64, %53 : f32 + %66 = arith.addf %65, %cst_3 : f32 + %67 = arith.select %55, %60, %66 : f32 + %68 = arith.select %54, %67, %cst : f32 + %69 = arith.mulf %46, %68 : f32 + %70 = arith.addf %out, %69 : f32 + linalg.yield %70 : f32 + } -> tensor + %20 = polygeist.submapInverse(%inserted, %19, %c4, %c5) {map = #map1} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %20[] : tensor + %21 = polygeist.submap(%arg7, %arg2, %c4, %c5) {map = #map3} : (tensor, index, index, index) -> tensor + %22 = polygeist.submap(%0, %arg6, %arg2, %arg4, %c4, %c5) {map = #map4} : (tensor, index, index, index, index, index) -> tensor + %23 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%22 : tensor) outs(%21 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_3 : f32 + %33 = arith.cmpf olt, %31, %cst_1 : f32 + %34 = arith.mulf %31, %cst_4 : f32 + %35 = arith.subf %34, %cst_5 : f32 + %36 = arith.mulf %35, %31 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = arith.addf %37, %cst_1 : f32 + %39 = arith.mulf %31, %cst_6 : f32 + %40 = arith.addf %39, %cst_5 : f32 + %41 = arith.mulf %40, %31 : f32 + %42 = arith.subf %41, %cst_0 : f32 + %43 = arith.mulf %42, %31 : f32 + %44 = arith.addf %43, %cst_3 : f32 + %45 = arith.select %33, %38, %44 : f32 + %46 = arith.select %32, %45, %cst : f32 + %47 = linalg.index 1 : index + %48 = arith.index_cast %47 : index to i32 + %49 = arith.sitofp %48 : i32 to f32 + %50 = arith.subf %16, %49 : f32 + %51 = arith.cmpf olt, %50, %cst : f32 + %52 = arith.negf %50 : f32 + %53 = arith.select %51, %52, %50 : f32 + %54 = arith.cmpf olt, %53, %cst_3 : f32 + %55 = arith.cmpf olt, %53, %cst_1 : f32 + %56 = arith.mulf %53, %cst_4 : f32 + %57 = arith.subf %56, %cst_5 : f32 + %58 = arith.mulf %57, %53 : f32 + %59 = arith.mulf %58, %53 : f32 + %60 = arith.addf %59, %cst_1 : f32 + %61 = arith.mulf %53, %cst_6 : f32 + %62 = arith.addf %61, %cst_5 : f32 + %63 = arith.mulf %62, %53 : f32 + %64 = arith.subf %63, %cst_0 : f32 + %65 = arith.mulf %64, %53 : f32 + %66 = arith.addf %65, %cst_3 : f32 + %67 = arith.select %55, %60, %66 : f32 + %68 = arith.select %54, %67, %cst : f32 + %69 = arith.mulf %in, %46 : f32 + %70 = arith.mulf %69, %68 : f32 + %71 = arith.divf %70, %extracted : f32 + %72 = arith.addf %out, %71 : f32 + linalg.yield %72 : f32 + } -> tensor + %24 = polygeist.submapInverse(%arg7, %23, %arg2, %c4, %c5) {map = #map3} : (tensor, tensor, index, index, index) -> tensor + affine.yield %24 : tensor + } + affine.yield %11 : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..295e4aaa8928 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_backward_cpu_linalg.mlir @@ -0,0 +1,151 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1)[s0, s1, s2] -> (s0 + s1 * 56 + s2 * 8)> +#map4 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant -5.000000e-01 : f32 + %cst_2 = arith.constant 2.500000e+00 : f32 + %cst_3 = arith.constant 1.500000e+00 : f32 + %cst_4 = arith.constant 2.000000e+00 : f32 + %cst_5 = arith.constant 5.000000e-01 : f32 + %cst_6 = arith.constant 1.000000e+00 : f32 + %cst_7 = arith.constant 4.000000e+00 : f32 + %cst_8 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_8 : f32 + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_5 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_5 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_5 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_5 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_8, %alloca[] : memref + %10 = polygeist.submap(%alloca, %c4, %c5) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map2], iterator_types = ["reduction", "reduction"]} outs(%10 : memref) { + ^bb0(%out: f32): + %14 = linalg.index 0 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.sitofp %15 : i32 to f32 + %17 = arith.subf %4, %16 : f32 + %18 = arith.cmpf olt, %17, %cst_8 : f32 + %19 = arith.negf %17 : f32 + %20 = arith.select %18, %19, %17 : f32 + %21 = arith.cmpf olt, %20, %cst_4 : f32 + %22 = arith.cmpf olt, %20, %cst_6 : f32 + %23 = arith.mulf %20, %cst_3 : f32 + %24 = arith.subf %23, %cst_2 : f32 + %25 = arith.mulf %24, %20 : f32 + %26 = arith.mulf %25, %20 : f32 + %27 = arith.addf %26, %cst_6 : f32 + %28 = arith.mulf %20, %cst_1 : f32 + %29 = arith.addf %28, %cst_2 : f32 + %30 = arith.mulf %29, %20 : f32 + %31 = arith.subf %30, %cst_7 : f32 + %32 = arith.mulf %31, %20 : f32 + %33 = arith.addf %32, %cst_4 : f32 + %34 = arith.select %22, %27, %33 : f32 + %35 = arith.select %21, %34, %cst_8 : f32 + %36 = linalg.index 1 : index + %37 = arith.index_cast %36 : index to i32 + %38 = arith.sitofp %37 : i32 to f32 + %39 = arith.subf %9, %38 : f32 + %40 = arith.cmpf olt, %39, %cst_8 : f32 + %41 = arith.negf %39 : f32 + %42 = arith.select %40, %41, %39 : f32 + %43 = arith.cmpf olt, %42, %cst_4 : f32 + %44 = arith.cmpf olt, %42, %cst_6 : f32 + %45 = arith.mulf %42, %cst_3 : f32 + %46 = arith.subf %45, %cst_2 : f32 + %47 = arith.mulf %46, %42 : f32 + %48 = arith.mulf %47, %42 : f32 + %49 = arith.addf %48, %cst_6 : f32 + %50 = arith.mulf %42, %cst_1 : f32 + %51 = arith.addf %50, %cst_2 : f32 + %52 = arith.mulf %51, %42 : f32 + %53 = arith.subf %52, %cst_7 : f32 + %54 = arith.mulf %53, %42 : f32 + %55 = arith.addf %54, %cst_4 : f32 + %56 = arith.select %44, %49, %55 : f32 + %57 = arith.select %43, %56, %cst_8 : f32 + %58 = arith.mulf %35, %57 : f32 + %59 = arith.addf %out, %58 : f32 + linalg.yield %59 : f32 + } + %11 = affine.load %alloca[] : memref + %12 = polygeist.submap(%arg0, %arg4, %arg2, %arg3, %c4, %c5) {map = #map3} : (memref, index, index, index, index, index) -> memref + %13 = polygeist.submap(%arg1, %arg2, %c4, %c5) {map = #map4} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%12 : memref) outs(%13 : memref) { + ^bb0(%in: f32, %out: f32): + %14 = linalg.index 0 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.sitofp %15 : i32 to f32 + %17 = arith.subf %4, %16 : f32 + %18 = arith.cmpf olt, %17, %cst_8 : f32 + %19 = arith.negf %17 : f32 + %20 = arith.select %18, %19, %17 : f32 + %21 = arith.cmpf olt, %20, %cst_4 : f32 + %22 = arith.cmpf olt, %20, %cst_6 : f32 + %23 = arith.mulf %20, %cst_3 : f32 + %24 = arith.subf %23, %cst_2 : f32 + %25 = arith.mulf %24, %20 : f32 + %26 = arith.mulf %25, %20 : f32 + %27 = arith.addf %26, %cst_6 : f32 + %28 = arith.mulf %20, %cst_1 : f32 + %29 = arith.addf %28, %cst_2 : f32 + %30 = arith.mulf %29, %20 : f32 + %31 = arith.subf %30, %cst_7 : f32 + %32 = arith.mulf %31, %20 : f32 + %33 = arith.addf %32, %cst_4 : f32 + %34 = arith.select %22, %27, %33 : f32 + %35 = arith.select %21, %34, %cst_8 : f32 + %36 = linalg.index 1 : index + %37 = arith.index_cast %36 : index to i32 + %38 = arith.sitofp %37 : i32 to f32 + %39 = arith.subf %9, %38 : f32 + %40 = arith.cmpf olt, %39, %cst_8 : f32 + %41 = arith.negf %39 : f32 + %42 = arith.select %40, %41, %39 : f32 + %43 = arith.cmpf olt, %42, %cst_4 : f32 + %44 = arith.cmpf olt, %42, %cst_6 : f32 + %45 = arith.mulf %42, %cst_3 : f32 + %46 = arith.subf %45, %cst_2 : f32 + %47 = arith.mulf %46, %42 : f32 + %48 = arith.mulf %47, %42 : f32 + %49 = arith.addf %48, %cst_6 : f32 + %50 = arith.mulf %42, %cst_1 : f32 + %51 = arith.addf %50, %cst_2 : f32 + %52 = arith.mulf %51, %42 : f32 + %53 = arith.subf %52, %cst_7 : f32 + %54 = arith.mulf %53, %42 : f32 + %55 = arith.addf %54, %cst_4 : f32 + %56 = arith.select %44, %49, %55 : f32 + %57 = arith.select %43, %56, %cst_8 : f32 + %58 = arith.mulf %in, %35 : f32 + %59 = arith.mulf %58, %57 : f32 + %60 = arith.divf %59, %11 : f32 + %61 = arith.addf %out, %60 : f32 + linalg.yield %61 : f32 + } + } + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu.mlir new file mode 100644 index 000000000000..f4627593d7bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu.mlir @@ -0,0 +1,183 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant -5.000000e-01 : f32 + %cst_2 = arith.constant 2.500000e+00 : f32 + %cst_3 = arith.constant 1.500000e+00 : f32 + %cst_4 = arith.constant 2.000000e+00 : f32 + %cst_5 = arith.constant 0.000000e+00 : f32 + %cst_6 = arith.constant 5.000000e-01 : f32 + %cst_7 = arith.constant 1.000000e+00 : f32 + %cst_8 = arith.constant 4.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_6 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_6 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_6 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_6 : f32 + %10 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_5) -> (f32) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.sitofp %13 : i32 to f32 + %15 = arith.subf %4, %14 : f32 + %16 = arith.cmpf olt, %15, %cst_5 : f32 + %17 = scf.if %16 -> (f32) { + %22 = arith.negf %15 : f32 + scf.yield %22 : f32 + } else { + scf.yield %15 : f32 + } + %18 = arith.cmpf olt, %17, %cst_4 : f32 + %19 = arith.cmpf olt, %17, %cst_7 : f32 + %20 = scf.if %18 -> (f32) { + %22 = scf.if %19 -> (f32) { + %23 = arith.mulf %17, %cst_3 : f32 + %24 = arith.subf %23, %cst_2 : f32 + %25 = arith.mulf %24, %17 : f32 + %26 = arith.mulf %25, %17 : f32 + %27 = arith.addf %26, %cst_7 : f32 + scf.yield %27 : f32 + } else { + %23 = arith.mulf %17, %cst_1 : f32 + %24 = arith.addf %23, %cst_2 : f32 + %25 = arith.mulf %24, %17 : f32 + %26 = arith.subf %25, %cst_8 : f32 + %27 = arith.mulf %26, %17 : f32 + %28 = arith.addf %27, %cst_4 : f32 + scf.yield %28 : f32 + } + scf.yield %22 : f32 + } else { + scf.yield %cst_5 : f32 + } + %21 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %22 = arith.index_cast %arg7 : index to i32 + %23 = arith.sitofp %22 : i32 to f32 + %24 = arith.subf %9, %23 : f32 + %25 = arith.cmpf olt, %24, %cst_5 : f32 + %26 = scf.if %25 -> (f32) { + %32 = arith.negf %24 : f32 + scf.yield %32 : f32 + } else { + scf.yield %24 : f32 + } + %27 = arith.cmpf olt, %26, %cst_4 : f32 + %28 = arith.cmpf olt, %26, %cst_7 : f32 + %29 = scf.if %27 -> (f32) { + %32 = scf.if %28 -> (f32) { + %33 = arith.mulf %26, %cst_3 : f32 + %34 = arith.subf %33, %cst_2 : f32 + %35 = arith.mulf %34, %26 : f32 + %36 = arith.mulf %35, %26 : f32 + %37 = arith.addf %36, %cst_7 : f32 + scf.yield %37 : f32 + } else { + %33 = arith.mulf %26, %cst_1 : f32 + %34 = arith.addf %33, %cst_2 : f32 + %35 = arith.mulf %34, %26 : f32 + %36 = arith.subf %35, %cst_8 : f32 + %37 = arith.mulf %36, %26 : f32 + %38 = arith.addf %37, %cst_4 : f32 + scf.yield %38 : f32 + } + scf.yield %32 : f32 + } else { + scf.yield %cst_5 : f32 + } + %30 = arith.mulf %20, %29 : f32 + %31 = arith.addf %arg8, %30 : f32 + affine.yield %31 : f32 + } + affine.yield %21 : f32 + } + %11 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_5) -> (f32) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.sitofp %13 : i32 to f32 + %15 = arith.subf %4, %14 : f32 + %16 = arith.cmpf olt, %15, %cst_5 : f32 + %17 = scf.if %16 -> (f32) { + %22 = arith.negf %15 : f32 + scf.yield %22 : f32 + } else { + scf.yield %15 : f32 + } + %18 = arith.cmpf olt, %17, %cst_4 : f32 + %19 = arith.cmpf olt, %17, %cst_7 : f32 + %20 = scf.if %18 -> (f32) { + %22 = scf.if %19 -> (f32) { + %23 = arith.mulf %17, %cst_3 : f32 + %24 = arith.subf %23, %cst_2 : f32 + %25 = arith.mulf %24, %17 : f32 + %26 = arith.mulf %25, %17 : f32 + %27 = arith.addf %26, %cst_7 : f32 + scf.yield %27 : f32 + } else { + %23 = arith.mulf %17, %cst_1 : f32 + %24 = arith.addf %23, %cst_2 : f32 + %25 = arith.mulf %24, %17 : f32 + %26 = arith.subf %25, %cst_8 : f32 + %27 = arith.mulf %26, %17 : f32 + %28 = arith.addf %27, %cst_4 : f32 + scf.yield %28 : f32 + } + scf.yield %22 : f32 + } else { + scf.yield %cst_5 : f32 + } + %21 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %22 = arith.index_cast %arg7 : index to i32 + %23 = arith.sitofp %22 : i32 to f32 + %24 = arith.subf %9, %23 : f32 + %25 = arith.cmpf olt, %24, %cst_5 : f32 + %26 = scf.if %25 -> (f32) { + %34 = arith.negf %24 : f32 + scf.yield %34 : f32 + } else { + scf.yield %24 : f32 + } + %27 = arith.cmpf olt, %26, %cst_4 : f32 + %28 = arith.cmpf olt, %26, %cst_7 : f32 + %29 = scf.if %27 -> (f32) { + %34 = scf.if %28 -> (f32) { + %35 = arith.mulf %26, %cst_3 : f32 + %36 = arith.subf %35, %cst_2 : f32 + %37 = arith.mulf %36, %26 : f32 + %38 = arith.mulf %37, %26 : f32 + %39 = arith.addf %38, %cst_7 : f32 + scf.yield %39 : f32 + } else { + %35 = arith.mulf %26, %cst_1 : f32 + %36 = arith.addf %35, %cst_2 : f32 + %37 = arith.mulf %36, %26 : f32 + %38 = arith.subf %37, %cst_8 : f32 + %39 = arith.mulf %38, %26 : f32 + %40 = arith.addf %39, %cst_4 : f32 + scf.yield %40 : f32 + } + scf.yield %34 : f32 + } else { + scf.yield %cst_5 : f32 + } + %30 = affine.load %arg0[%arg7 + %arg2 * 20 + %arg5 * 5] : memref + %31 = arith.mulf %30, %20 : f32 + %32 = arith.mulf %31, %29 : f32 + %33 = arith.addf %arg8, %32 : f32 + affine.yield %33 : f32 + } + affine.yield %21 : f32 + } + %12 = arith.divf %11, %10 : f32 + affine.store %12, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu/debuf.mlir new file mode 100644 index 000000000000..834f73cd973d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu/debuf.mlir @@ -0,0 +1,160 @@ +#map = affine_map<(d0, d1) -> ()> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map3 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 4.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %cst_3 = arith.constant 2.000000e+00 : f32 + %cst_4 = arith.constant 1.500000e+00 : f32 + %cst_5 = arith.constant 2.500000e+00 : f32 + %cst_6 = arith.constant -5.000000e-01 : f32 + %cst_7 = arith.constant 6.250000e-01 : f32 + %cst_8 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %4 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_1 : f32 + %8 = arith.mulf %7, %cst_8 : f32 + %9 = arith.subf %8, %cst_1 : f32 + %10 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %11 = arith.index_cast %arg6 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.addf %12, %cst_1 : f32 + %14 = arith.mulf %13, %cst_7 : f32 + %15 = arith.subf %14, %cst_1 : f32 + %alloca = memref.alloca() : memref + %16 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst_2 into %16[] : tensor + %17 = polygeist.submap(%inserted, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%17 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_2 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_3 : f32 + %33 = arith.cmpf olt, %31, %cst_0 : f32 + %34 = arith.mulf %31, %cst_4 : f32 + %35 = arith.subf %34, %cst_5 : f32 + %36 = arith.mulf %35, %31 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = arith.addf %37, %cst_0 : f32 + %39 = arith.mulf %31, %cst_6 : f32 + %40 = arith.addf %39, %cst_5 : f32 + %41 = arith.mulf %40, %31 : f32 + %42 = arith.subf %41, %cst : f32 + %43 = arith.mulf %42, %31 : f32 + %44 = arith.addf %43, %cst_3 : f32 + %45 = arith.select %33, %38, %44 : f32 + %46 = arith.select %32, %45, %cst_2 : f32 + %47 = linalg.index 1 : index + %48 = arith.index_cast %47 : index to i32 + %49 = arith.sitofp %48 : i32 to f32 + %50 = arith.subf %15, %49 : f32 + %51 = arith.cmpf olt, %50, %cst_2 : f32 + %52 = arith.negf %50 : f32 + %53 = arith.select %51, %52, %50 : f32 + %54 = arith.cmpf olt, %53, %cst_3 : f32 + %55 = arith.cmpf olt, %53, %cst_0 : f32 + %56 = arith.mulf %53, %cst_4 : f32 + %57 = arith.subf %56, %cst_5 : f32 + %58 = arith.mulf %57, %53 : f32 + %59 = arith.mulf %58, %53 : f32 + %60 = arith.addf %59, %cst_0 : f32 + %61 = arith.mulf %53, %cst_6 : f32 + %62 = arith.addf %61, %cst_5 : f32 + %63 = arith.mulf %62, %53 : f32 + %64 = arith.subf %63, %cst : f32 + %65 = arith.mulf %64, %53 : f32 + %66 = arith.addf %65, %cst_3 : f32 + %67 = arith.select %55, %60, %66 : f32 + %68 = arith.select %54, %67, %cst_2 : f32 + %69 = arith.mulf %46, %68 : f32 + %70 = arith.addf %out, %69 : f32 + linalg.yield %70 : f32 + } -> tensor + %19 = polygeist.submapInverse(%inserted, %18, %c4, %c5) {map = #map} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %19[] : tensor + %alloca_9 = memref.alloca() : memref + %20 = bufferization.to_tensor %alloca_9 : memref + %inserted_10 = tensor.insert %cst_2 into %20[] : tensor + %21 = polygeist.submap(%1, %arg2, %c4, %c5) {map = #map2} : (tensor, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map1, #map], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%21 : tensor) outs(%inserted_10 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_2 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_3 : f32 + %33 = arith.cmpf olt, %31, %cst_0 : f32 + %34 = arith.mulf %31, %cst_4 : f32 + %35 = arith.subf %34, %cst_5 : f32 + %36 = arith.mulf %35, %31 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = arith.addf %37, %cst_0 : f32 + %39 = arith.mulf %31, %cst_6 : f32 + %40 = arith.addf %39, %cst_5 : f32 + %41 = arith.mulf %40, %31 : f32 + %42 = arith.subf %41, %cst : f32 + %43 = arith.mulf %42, %31 : f32 + %44 = arith.addf %43, %cst_3 : f32 + %45 = arith.select %33, %38, %44 : f32 + %46 = arith.select %32, %45, %cst_2 : f32 + %47 = linalg.index 1 : index + %48 = arith.index_cast %47 : index to i32 + %49 = arith.sitofp %48 : i32 to f32 + %50 = arith.subf %15, %49 : f32 + %51 = arith.cmpf olt, %50, %cst_2 : f32 + %52 = arith.negf %50 : f32 + %53 = arith.select %51, %52, %50 : f32 + %54 = arith.cmpf olt, %53, %cst_3 : f32 + %55 = arith.cmpf olt, %53, %cst_0 : f32 + %56 = arith.mulf %53, %cst_4 : f32 + %57 = arith.subf %56, %cst_5 : f32 + %58 = arith.mulf %57, %53 : f32 + %59 = arith.mulf %58, %53 : f32 + %60 = arith.addf %59, %cst_0 : f32 + %61 = arith.mulf %53, %cst_6 : f32 + %62 = arith.addf %61, %cst_5 : f32 + %63 = arith.mulf %62, %53 : f32 + %64 = arith.subf %63, %cst : f32 + %65 = arith.mulf %64, %53 : f32 + %66 = arith.addf %65, %cst_3 : f32 + %67 = arith.select %55, %60, %66 : f32 + %68 = arith.select %54, %67, %cst_2 : f32 + %69 = arith.mulf %in, %46 : f32 + %70 = arith.mulf %69, %68 : f32 + %71 = arith.addf %out, %70 : f32 + linalg.yield %71 : f32 + } -> tensor + %extracted_11 = tensor.extract %22[] : tensor + %23 = arith.divf %extracted_11, %extracted : f32 + %24 = affine.apply #map3(%arg6, %arg2, %arg4) + %inserted_12 = tensor.insert %23 into %arg7[%24] : tensor + affine.yield %inserted_12 : tensor + } + affine.yield %10 : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu/matched.mlir new file mode 100644 index 000000000000..834f73cd973d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu/matched.mlir @@ -0,0 +1,160 @@ +#map = affine_map<(d0, d1) -> ()> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map3 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 4.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %cst_3 = arith.constant 2.000000e+00 : f32 + %cst_4 = arith.constant 1.500000e+00 : f32 + %cst_5 = arith.constant 2.500000e+00 : f32 + %cst_6 = arith.constant -5.000000e-01 : f32 + %cst_7 = arith.constant 6.250000e-01 : f32 + %cst_8 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %4 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_1 : f32 + %8 = arith.mulf %7, %cst_8 : f32 + %9 = arith.subf %8, %cst_1 : f32 + %10 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %11 = arith.index_cast %arg6 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.addf %12, %cst_1 : f32 + %14 = arith.mulf %13, %cst_7 : f32 + %15 = arith.subf %14, %cst_1 : f32 + %alloca = memref.alloca() : memref + %16 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst_2 into %16[] : tensor + %17 = polygeist.submap(%inserted, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%17 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_2 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_3 : f32 + %33 = arith.cmpf olt, %31, %cst_0 : f32 + %34 = arith.mulf %31, %cst_4 : f32 + %35 = arith.subf %34, %cst_5 : f32 + %36 = arith.mulf %35, %31 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = arith.addf %37, %cst_0 : f32 + %39 = arith.mulf %31, %cst_6 : f32 + %40 = arith.addf %39, %cst_5 : f32 + %41 = arith.mulf %40, %31 : f32 + %42 = arith.subf %41, %cst : f32 + %43 = arith.mulf %42, %31 : f32 + %44 = arith.addf %43, %cst_3 : f32 + %45 = arith.select %33, %38, %44 : f32 + %46 = arith.select %32, %45, %cst_2 : f32 + %47 = linalg.index 1 : index + %48 = arith.index_cast %47 : index to i32 + %49 = arith.sitofp %48 : i32 to f32 + %50 = arith.subf %15, %49 : f32 + %51 = arith.cmpf olt, %50, %cst_2 : f32 + %52 = arith.negf %50 : f32 + %53 = arith.select %51, %52, %50 : f32 + %54 = arith.cmpf olt, %53, %cst_3 : f32 + %55 = arith.cmpf olt, %53, %cst_0 : f32 + %56 = arith.mulf %53, %cst_4 : f32 + %57 = arith.subf %56, %cst_5 : f32 + %58 = arith.mulf %57, %53 : f32 + %59 = arith.mulf %58, %53 : f32 + %60 = arith.addf %59, %cst_0 : f32 + %61 = arith.mulf %53, %cst_6 : f32 + %62 = arith.addf %61, %cst_5 : f32 + %63 = arith.mulf %62, %53 : f32 + %64 = arith.subf %63, %cst : f32 + %65 = arith.mulf %64, %53 : f32 + %66 = arith.addf %65, %cst_3 : f32 + %67 = arith.select %55, %60, %66 : f32 + %68 = arith.select %54, %67, %cst_2 : f32 + %69 = arith.mulf %46, %68 : f32 + %70 = arith.addf %out, %69 : f32 + linalg.yield %70 : f32 + } -> tensor + %19 = polygeist.submapInverse(%inserted, %18, %c4, %c5) {map = #map} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %19[] : tensor + %alloca_9 = memref.alloca() : memref + %20 = bufferization.to_tensor %alloca_9 : memref + %inserted_10 = tensor.insert %cst_2 into %20[] : tensor + %21 = polygeist.submap(%1, %arg2, %c4, %c5) {map = #map2} : (tensor, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map1, #map], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%21 : tensor) outs(%inserted_10 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_2 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_3 : f32 + %33 = arith.cmpf olt, %31, %cst_0 : f32 + %34 = arith.mulf %31, %cst_4 : f32 + %35 = arith.subf %34, %cst_5 : f32 + %36 = arith.mulf %35, %31 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = arith.addf %37, %cst_0 : f32 + %39 = arith.mulf %31, %cst_6 : f32 + %40 = arith.addf %39, %cst_5 : f32 + %41 = arith.mulf %40, %31 : f32 + %42 = arith.subf %41, %cst : f32 + %43 = arith.mulf %42, %31 : f32 + %44 = arith.addf %43, %cst_3 : f32 + %45 = arith.select %33, %38, %44 : f32 + %46 = arith.select %32, %45, %cst_2 : f32 + %47 = linalg.index 1 : index + %48 = arith.index_cast %47 : index to i32 + %49 = arith.sitofp %48 : i32 to f32 + %50 = arith.subf %15, %49 : f32 + %51 = arith.cmpf olt, %50, %cst_2 : f32 + %52 = arith.negf %50 : f32 + %53 = arith.select %51, %52, %50 : f32 + %54 = arith.cmpf olt, %53, %cst_3 : f32 + %55 = arith.cmpf olt, %53, %cst_0 : f32 + %56 = arith.mulf %53, %cst_4 : f32 + %57 = arith.subf %56, %cst_5 : f32 + %58 = arith.mulf %57, %53 : f32 + %59 = arith.mulf %58, %53 : f32 + %60 = arith.addf %59, %cst_0 : f32 + %61 = arith.mulf %53, %cst_6 : f32 + %62 = arith.addf %61, %cst_5 : f32 + %63 = arith.mulf %62, %53 : f32 + %64 = arith.subf %63, %cst : f32 + %65 = arith.mulf %64, %53 : f32 + %66 = arith.addf %65, %cst_3 : f32 + %67 = arith.select %55, %60, %66 : f32 + %68 = arith.select %54, %67, %cst_2 : f32 + %69 = arith.mulf %in, %46 : f32 + %70 = arith.mulf %69, %68 : f32 + %71 = arith.addf %out, %70 : f32 + linalg.yield %71 : f32 + } -> tensor + %extracted_11 = tensor.extract %22[] : tensor + %23 = arith.divf %extracted_11, %extracted : f32 + %24 = affine.apply #map3(%arg6, %arg2, %arg4) + %inserted_12 = tensor.insert %23 into %arg7[%24] : tensor + affine.yield %inserted_12 : tensor + } + affine.yield %10 : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu/orig.mlir new file mode 100644 index 000000000000..f4627593d7bd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu/orig.mlir @@ -0,0 +1,183 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant -5.000000e-01 : f32 + %cst_2 = arith.constant 2.500000e+00 : f32 + %cst_3 = arith.constant 1.500000e+00 : f32 + %cst_4 = arith.constant 2.000000e+00 : f32 + %cst_5 = arith.constant 0.000000e+00 : f32 + %cst_6 = arith.constant 5.000000e-01 : f32 + %cst_7 = arith.constant 1.000000e+00 : f32 + %cst_8 = arith.constant 4.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_6 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_6 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_6 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_6 : f32 + %10 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_5) -> (f32) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.sitofp %13 : i32 to f32 + %15 = arith.subf %4, %14 : f32 + %16 = arith.cmpf olt, %15, %cst_5 : f32 + %17 = scf.if %16 -> (f32) { + %22 = arith.negf %15 : f32 + scf.yield %22 : f32 + } else { + scf.yield %15 : f32 + } + %18 = arith.cmpf olt, %17, %cst_4 : f32 + %19 = arith.cmpf olt, %17, %cst_7 : f32 + %20 = scf.if %18 -> (f32) { + %22 = scf.if %19 -> (f32) { + %23 = arith.mulf %17, %cst_3 : f32 + %24 = arith.subf %23, %cst_2 : f32 + %25 = arith.mulf %24, %17 : f32 + %26 = arith.mulf %25, %17 : f32 + %27 = arith.addf %26, %cst_7 : f32 + scf.yield %27 : f32 + } else { + %23 = arith.mulf %17, %cst_1 : f32 + %24 = arith.addf %23, %cst_2 : f32 + %25 = arith.mulf %24, %17 : f32 + %26 = arith.subf %25, %cst_8 : f32 + %27 = arith.mulf %26, %17 : f32 + %28 = arith.addf %27, %cst_4 : f32 + scf.yield %28 : f32 + } + scf.yield %22 : f32 + } else { + scf.yield %cst_5 : f32 + } + %21 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %22 = arith.index_cast %arg7 : index to i32 + %23 = arith.sitofp %22 : i32 to f32 + %24 = arith.subf %9, %23 : f32 + %25 = arith.cmpf olt, %24, %cst_5 : f32 + %26 = scf.if %25 -> (f32) { + %32 = arith.negf %24 : f32 + scf.yield %32 : f32 + } else { + scf.yield %24 : f32 + } + %27 = arith.cmpf olt, %26, %cst_4 : f32 + %28 = arith.cmpf olt, %26, %cst_7 : f32 + %29 = scf.if %27 -> (f32) { + %32 = scf.if %28 -> (f32) { + %33 = arith.mulf %26, %cst_3 : f32 + %34 = arith.subf %33, %cst_2 : f32 + %35 = arith.mulf %34, %26 : f32 + %36 = arith.mulf %35, %26 : f32 + %37 = arith.addf %36, %cst_7 : f32 + scf.yield %37 : f32 + } else { + %33 = arith.mulf %26, %cst_1 : f32 + %34 = arith.addf %33, %cst_2 : f32 + %35 = arith.mulf %34, %26 : f32 + %36 = arith.subf %35, %cst_8 : f32 + %37 = arith.mulf %36, %26 : f32 + %38 = arith.addf %37, %cst_4 : f32 + scf.yield %38 : f32 + } + scf.yield %32 : f32 + } else { + scf.yield %cst_5 : f32 + } + %30 = arith.mulf %20, %29 : f32 + %31 = arith.addf %arg8, %30 : f32 + affine.yield %31 : f32 + } + affine.yield %21 : f32 + } + %11 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_5) -> (f32) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.sitofp %13 : i32 to f32 + %15 = arith.subf %4, %14 : f32 + %16 = arith.cmpf olt, %15, %cst_5 : f32 + %17 = scf.if %16 -> (f32) { + %22 = arith.negf %15 : f32 + scf.yield %22 : f32 + } else { + scf.yield %15 : f32 + } + %18 = arith.cmpf olt, %17, %cst_4 : f32 + %19 = arith.cmpf olt, %17, %cst_7 : f32 + %20 = scf.if %18 -> (f32) { + %22 = scf.if %19 -> (f32) { + %23 = arith.mulf %17, %cst_3 : f32 + %24 = arith.subf %23, %cst_2 : f32 + %25 = arith.mulf %24, %17 : f32 + %26 = arith.mulf %25, %17 : f32 + %27 = arith.addf %26, %cst_7 : f32 + scf.yield %27 : f32 + } else { + %23 = arith.mulf %17, %cst_1 : f32 + %24 = arith.addf %23, %cst_2 : f32 + %25 = arith.mulf %24, %17 : f32 + %26 = arith.subf %25, %cst_8 : f32 + %27 = arith.mulf %26, %17 : f32 + %28 = arith.addf %27, %cst_4 : f32 + scf.yield %28 : f32 + } + scf.yield %22 : f32 + } else { + scf.yield %cst_5 : f32 + } + %21 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %22 = arith.index_cast %arg7 : index to i32 + %23 = arith.sitofp %22 : i32 to f32 + %24 = arith.subf %9, %23 : f32 + %25 = arith.cmpf olt, %24, %cst_5 : f32 + %26 = scf.if %25 -> (f32) { + %34 = arith.negf %24 : f32 + scf.yield %34 : f32 + } else { + scf.yield %24 : f32 + } + %27 = arith.cmpf olt, %26, %cst_4 : f32 + %28 = arith.cmpf olt, %26, %cst_7 : f32 + %29 = scf.if %27 -> (f32) { + %34 = scf.if %28 -> (f32) { + %35 = arith.mulf %26, %cst_3 : f32 + %36 = arith.subf %35, %cst_2 : f32 + %37 = arith.mulf %36, %26 : f32 + %38 = arith.mulf %37, %26 : f32 + %39 = arith.addf %38, %cst_7 : f32 + scf.yield %39 : f32 + } else { + %35 = arith.mulf %26, %cst_1 : f32 + %36 = arith.addf %35, %cst_2 : f32 + %37 = arith.mulf %36, %26 : f32 + %38 = arith.subf %37, %cst_8 : f32 + %39 = arith.mulf %38, %26 : f32 + %40 = arith.addf %39, %cst_4 : f32 + scf.yield %40 : f32 + } + scf.yield %34 : f32 + } else { + scf.yield %cst_5 : f32 + } + %30 = affine.load %arg0[%arg7 + %arg2 * 20 + %arg5 * 5] : memref + %31 = arith.mulf %30, %20 : f32 + %32 = arith.mulf %31, %29 : f32 + %33 = arith.addf %arg8, %32 : f32 + affine.yield %33 : f32 + } + affine.yield %21 : f32 + } + %12 = arith.divf %11, %10 : f32 + affine.store %12, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu/raised.mlir new file mode 100644 index 000000000000..078442588758 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu/raised.mlir @@ -0,0 +1,148 @@ +#map = affine_map<(d0, d1) -> ()> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant -5.000000e-01 : f32 + %cst_2 = arith.constant 2.500000e+00 : f32 + %cst_3 = arith.constant 1.500000e+00 : f32 + %cst_4 = arith.constant 2.000000e+00 : f32 + %cst_5 = arith.constant 0.000000e+00 : f32 + %cst_6 = arith.constant 5.000000e-01 : f32 + %cst_7 = arith.constant 1.000000e+00 : f32 + %cst_8 = arith.constant 4.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_6 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_6 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_6 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_6 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_5, %alloca[] : memref + %10 = polygeist.submap(%alloca, %c4, %c5) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction", "reduction"]} outs(%10 : memref) { + ^bb0(%out: f32): + %15 = linalg.index 0 : index + %16 = arith.index_cast %15 : index to i32 + %17 = arith.sitofp %16 : i32 to f32 + %18 = arith.subf %4, %17 : f32 + %19 = arith.cmpf olt, %18, %cst_5 : f32 + %20 = arith.negf %18 : f32 + %21 = arith.select %19, %20, %18 : f32 + %22 = arith.cmpf olt, %21, %cst_4 : f32 + %23 = arith.cmpf olt, %21, %cst_7 : f32 + %24 = arith.mulf %21, %cst_3 : f32 + %25 = arith.subf %24, %cst_2 : f32 + %26 = arith.mulf %25, %21 : f32 + %27 = arith.mulf %26, %21 : f32 + %28 = arith.addf %27, %cst_7 : f32 + %29 = arith.mulf %21, %cst_1 : f32 + %30 = arith.addf %29, %cst_2 : f32 + %31 = arith.mulf %30, %21 : f32 + %32 = arith.subf %31, %cst_8 : f32 + %33 = arith.mulf %32, %21 : f32 + %34 = arith.addf %33, %cst_4 : f32 + %35 = arith.select %23, %28, %34 : f32 + %36 = arith.select %22, %35, %cst_5 : f32 + %37 = linalg.index 1 : index + %38 = arith.index_cast %37 : index to i32 + %39 = arith.sitofp %38 : i32 to f32 + %40 = arith.subf %9, %39 : f32 + %41 = arith.cmpf olt, %40, %cst_5 : f32 + %42 = arith.negf %40 : f32 + %43 = arith.select %41, %42, %40 : f32 + %44 = arith.cmpf olt, %43, %cst_4 : f32 + %45 = arith.cmpf olt, %43, %cst_7 : f32 + %46 = arith.mulf %43, %cst_3 : f32 + %47 = arith.subf %46, %cst_2 : f32 + %48 = arith.mulf %47, %43 : f32 + %49 = arith.mulf %48, %43 : f32 + %50 = arith.addf %49, %cst_7 : f32 + %51 = arith.mulf %43, %cst_1 : f32 + %52 = arith.addf %51, %cst_2 : f32 + %53 = arith.mulf %52, %43 : f32 + %54 = arith.subf %53, %cst_8 : f32 + %55 = arith.mulf %54, %43 : f32 + %56 = arith.addf %55, %cst_4 : f32 + %57 = arith.select %45, %50, %56 : f32 + %58 = arith.select %44, %57, %cst_5 : f32 + %59 = arith.mulf %36, %58 : f32 + %60 = arith.addf %out, %59 : f32 + linalg.yield %60 : f32 + } + %11 = affine.load %alloca[] : memref + %alloca_9 = memref.alloca() : memref + affine.store %cst_5, %alloca_9[] : memref + %12 = polygeist.submap(%arg0, %arg2, %c4, %c5) {map = #map2} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map], iterator_types = ["reduction", "reduction"]} ins(%12 : memref) outs(%alloca_9 : memref) { + ^bb0(%in: f32, %out: f32): + %15 = linalg.index 0 : index + %16 = arith.index_cast %15 : index to i32 + %17 = arith.sitofp %16 : i32 to f32 + %18 = arith.subf %4, %17 : f32 + %19 = arith.cmpf olt, %18, %cst_5 : f32 + %20 = arith.negf %18 : f32 + %21 = arith.select %19, %20, %18 : f32 + %22 = arith.cmpf olt, %21, %cst_4 : f32 + %23 = arith.cmpf olt, %21, %cst_7 : f32 + %24 = arith.mulf %21, %cst_3 : f32 + %25 = arith.subf %24, %cst_2 : f32 + %26 = arith.mulf %25, %21 : f32 + %27 = arith.mulf %26, %21 : f32 + %28 = arith.addf %27, %cst_7 : f32 + %29 = arith.mulf %21, %cst_1 : f32 + %30 = arith.addf %29, %cst_2 : f32 + %31 = arith.mulf %30, %21 : f32 + %32 = arith.subf %31, %cst_8 : f32 + %33 = arith.mulf %32, %21 : f32 + %34 = arith.addf %33, %cst_4 : f32 + %35 = arith.select %23, %28, %34 : f32 + %36 = arith.select %22, %35, %cst_5 : f32 + %37 = linalg.index 1 : index + %38 = arith.index_cast %37 : index to i32 + %39 = arith.sitofp %38 : i32 to f32 + %40 = arith.subf %9, %39 : f32 + %41 = arith.cmpf olt, %40, %cst_5 : f32 + %42 = arith.negf %40 : f32 + %43 = arith.select %41, %42, %40 : f32 + %44 = arith.cmpf olt, %43, %cst_4 : f32 + %45 = arith.cmpf olt, %43, %cst_7 : f32 + %46 = arith.mulf %43, %cst_3 : f32 + %47 = arith.subf %46, %cst_2 : f32 + %48 = arith.mulf %47, %43 : f32 + %49 = arith.mulf %48, %43 : f32 + %50 = arith.addf %49, %cst_7 : f32 + %51 = arith.mulf %43, %cst_1 : f32 + %52 = arith.addf %51, %cst_2 : f32 + %53 = arith.mulf %52, %43 : f32 + %54 = arith.subf %53, %cst_8 : f32 + %55 = arith.mulf %54, %43 : f32 + %56 = arith.addf %55, %cst_4 : f32 + %57 = arith.select %45, %50, %56 : f32 + %58 = arith.select %44, %57, %cst_5 : f32 + %59 = arith.mulf %in, %36 : f32 + %60 = arith.mulf %59, %58 : f32 + %61 = arith.addf %out, %60 : f32 + linalg.yield %61 : f32 + } + %13 = affine.load %alloca_9[] : memref + %14 = arith.divf %13, %11 : f32 + affine.store %14, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu_debuf.mlir new file mode 100644 index 000000000000..834f73cd973d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu_debuf.mlir @@ -0,0 +1,160 @@ +#map = affine_map<(d0, d1) -> ()> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map3 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 4.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %cst_3 = arith.constant 2.000000e+00 : f32 + %cst_4 = arith.constant 1.500000e+00 : f32 + %cst_5 = arith.constant 2.500000e+00 : f32 + %cst_6 = arith.constant -5.000000e-01 : f32 + %cst_7 = arith.constant 6.250000e-01 : f32 + %cst_8 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %4 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_1 : f32 + %8 = arith.mulf %7, %cst_8 : f32 + %9 = arith.subf %8, %cst_1 : f32 + %10 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %11 = arith.index_cast %arg6 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.addf %12, %cst_1 : f32 + %14 = arith.mulf %13, %cst_7 : f32 + %15 = arith.subf %14, %cst_1 : f32 + %alloca = memref.alloca() : memref + %16 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst_2 into %16[] : tensor + %17 = polygeist.submap(%inserted, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%17 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_2 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_3 : f32 + %33 = arith.cmpf olt, %31, %cst_0 : f32 + %34 = arith.mulf %31, %cst_4 : f32 + %35 = arith.subf %34, %cst_5 : f32 + %36 = arith.mulf %35, %31 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = arith.addf %37, %cst_0 : f32 + %39 = arith.mulf %31, %cst_6 : f32 + %40 = arith.addf %39, %cst_5 : f32 + %41 = arith.mulf %40, %31 : f32 + %42 = arith.subf %41, %cst : f32 + %43 = arith.mulf %42, %31 : f32 + %44 = arith.addf %43, %cst_3 : f32 + %45 = arith.select %33, %38, %44 : f32 + %46 = arith.select %32, %45, %cst_2 : f32 + %47 = linalg.index 1 : index + %48 = arith.index_cast %47 : index to i32 + %49 = arith.sitofp %48 : i32 to f32 + %50 = arith.subf %15, %49 : f32 + %51 = arith.cmpf olt, %50, %cst_2 : f32 + %52 = arith.negf %50 : f32 + %53 = arith.select %51, %52, %50 : f32 + %54 = arith.cmpf olt, %53, %cst_3 : f32 + %55 = arith.cmpf olt, %53, %cst_0 : f32 + %56 = arith.mulf %53, %cst_4 : f32 + %57 = arith.subf %56, %cst_5 : f32 + %58 = arith.mulf %57, %53 : f32 + %59 = arith.mulf %58, %53 : f32 + %60 = arith.addf %59, %cst_0 : f32 + %61 = arith.mulf %53, %cst_6 : f32 + %62 = arith.addf %61, %cst_5 : f32 + %63 = arith.mulf %62, %53 : f32 + %64 = arith.subf %63, %cst : f32 + %65 = arith.mulf %64, %53 : f32 + %66 = arith.addf %65, %cst_3 : f32 + %67 = arith.select %55, %60, %66 : f32 + %68 = arith.select %54, %67, %cst_2 : f32 + %69 = arith.mulf %46, %68 : f32 + %70 = arith.addf %out, %69 : f32 + linalg.yield %70 : f32 + } -> tensor + %19 = polygeist.submapInverse(%inserted, %18, %c4, %c5) {map = #map} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %19[] : tensor + %alloca_9 = memref.alloca() : memref + %20 = bufferization.to_tensor %alloca_9 : memref + %inserted_10 = tensor.insert %cst_2 into %20[] : tensor + %21 = polygeist.submap(%1, %arg2, %c4, %c5) {map = #map2} : (tensor, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map1, #map], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%21 : tensor) outs(%inserted_10 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_2 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_3 : f32 + %33 = arith.cmpf olt, %31, %cst_0 : f32 + %34 = arith.mulf %31, %cst_4 : f32 + %35 = arith.subf %34, %cst_5 : f32 + %36 = arith.mulf %35, %31 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = arith.addf %37, %cst_0 : f32 + %39 = arith.mulf %31, %cst_6 : f32 + %40 = arith.addf %39, %cst_5 : f32 + %41 = arith.mulf %40, %31 : f32 + %42 = arith.subf %41, %cst : f32 + %43 = arith.mulf %42, %31 : f32 + %44 = arith.addf %43, %cst_3 : f32 + %45 = arith.select %33, %38, %44 : f32 + %46 = arith.select %32, %45, %cst_2 : f32 + %47 = linalg.index 1 : index + %48 = arith.index_cast %47 : index to i32 + %49 = arith.sitofp %48 : i32 to f32 + %50 = arith.subf %15, %49 : f32 + %51 = arith.cmpf olt, %50, %cst_2 : f32 + %52 = arith.negf %50 : f32 + %53 = arith.select %51, %52, %50 : f32 + %54 = arith.cmpf olt, %53, %cst_3 : f32 + %55 = arith.cmpf olt, %53, %cst_0 : f32 + %56 = arith.mulf %53, %cst_4 : f32 + %57 = arith.subf %56, %cst_5 : f32 + %58 = arith.mulf %57, %53 : f32 + %59 = arith.mulf %58, %53 : f32 + %60 = arith.addf %59, %cst_0 : f32 + %61 = arith.mulf %53, %cst_6 : f32 + %62 = arith.addf %61, %cst_5 : f32 + %63 = arith.mulf %62, %53 : f32 + %64 = arith.subf %63, %cst : f32 + %65 = arith.mulf %64, %53 : f32 + %66 = arith.addf %65, %cst_3 : f32 + %67 = arith.select %55, %60, %66 : f32 + %68 = arith.select %54, %67, %cst_2 : f32 + %69 = arith.mulf %in, %46 : f32 + %70 = arith.mulf %69, %68 : f32 + %71 = arith.addf %out, %70 : f32 + linalg.yield %71 : f32 + } -> tensor + %extracted_11 = tensor.extract %22[] : tensor + %23 = arith.divf %extracted_11, %extracted : f32 + %24 = affine.apply #map3(%arg6, %arg2, %arg4) + %inserted_12 = tensor.insert %23 into %arg7[%24] : tensor + affine.yield %inserted_12 : tensor + } + affine.yield %10 : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu_linalg.mlir new file mode 100644 index 000000000000..078442588758 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_aa_cpu_linalg.mlir @@ -0,0 +1,148 @@ +#map = affine_map<(d0, d1) -> ()> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant -5.000000e-01 : f32 + %cst_2 = arith.constant 2.500000e+00 : f32 + %cst_3 = arith.constant 1.500000e+00 : f32 + %cst_4 = arith.constant 2.000000e+00 : f32 + %cst_5 = arith.constant 0.000000e+00 : f32 + %cst_6 = arith.constant 5.000000e-01 : f32 + %cst_7 = arith.constant 1.000000e+00 : f32 + %cst_8 = arith.constant 4.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_6 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_6 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_6 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_6 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_5, %alloca[] : memref + %10 = polygeist.submap(%alloca, %c4, %c5) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction", "reduction"]} outs(%10 : memref) { + ^bb0(%out: f32): + %15 = linalg.index 0 : index + %16 = arith.index_cast %15 : index to i32 + %17 = arith.sitofp %16 : i32 to f32 + %18 = arith.subf %4, %17 : f32 + %19 = arith.cmpf olt, %18, %cst_5 : f32 + %20 = arith.negf %18 : f32 + %21 = arith.select %19, %20, %18 : f32 + %22 = arith.cmpf olt, %21, %cst_4 : f32 + %23 = arith.cmpf olt, %21, %cst_7 : f32 + %24 = arith.mulf %21, %cst_3 : f32 + %25 = arith.subf %24, %cst_2 : f32 + %26 = arith.mulf %25, %21 : f32 + %27 = arith.mulf %26, %21 : f32 + %28 = arith.addf %27, %cst_7 : f32 + %29 = arith.mulf %21, %cst_1 : f32 + %30 = arith.addf %29, %cst_2 : f32 + %31 = arith.mulf %30, %21 : f32 + %32 = arith.subf %31, %cst_8 : f32 + %33 = arith.mulf %32, %21 : f32 + %34 = arith.addf %33, %cst_4 : f32 + %35 = arith.select %23, %28, %34 : f32 + %36 = arith.select %22, %35, %cst_5 : f32 + %37 = linalg.index 1 : index + %38 = arith.index_cast %37 : index to i32 + %39 = arith.sitofp %38 : i32 to f32 + %40 = arith.subf %9, %39 : f32 + %41 = arith.cmpf olt, %40, %cst_5 : f32 + %42 = arith.negf %40 : f32 + %43 = arith.select %41, %42, %40 : f32 + %44 = arith.cmpf olt, %43, %cst_4 : f32 + %45 = arith.cmpf olt, %43, %cst_7 : f32 + %46 = arith.mulf %43, %cst_3 : f32 + %47 = arith.subf %46, %cst_2 : f32 + %48 = arith.mulf %47, %43 : f32 + %49 = arith.mulf %48, %43 : f32 + %50 = arith.addf %49, %cst_7 : f32 + %51 = arith.mulf %43, %cst_1 : f32 + %52 = arith.addf %51, %cst_2 : f32 + %53 = arith.mulf %52, %43 : f32 + %54 = arith.subf %53, %cst_8 : f32 + %55 = arith.mulf %54, %43 : f32 + %56 = arith.addf %55, %cst_4 : f32 + %57 = arith.select %45, %50, %56 : f32 + %58 = arith.select %44, %57, %cst_5 : f32 + %59 = arith.mulf %36, %58 : f32 + %60 = arith.addf %out, %59 : f32 + linalg.yield %60 : f32 + } + %11 = affine.load %alloca[] : memref + %alloca_9 = memref.alloca() : memref + affine.store %cst_5, %alloca_9[] : memref + %12 = polygeist.submap(%arg0, %arg2, %c4, %c5) {map = #map2} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map], iterator_types = ["reduction", "reduction"]} ins(%12 : memref) outs(%alloca_9 : memref) { + ^bb0(%in: f32, %out: f32): + %15 = linalg.index 0 : index + %16 = arith.index_cast %15 : index to i32 + %17 = arith.sitofp %16 : i32 to f32 + %18 = arith.subf %4, %17 : f32 + %19 = arith.cmpf olt, %18, %cst_5 : f32 + %20 = arith.negf %18 : f32 + %21 = arith.select %19, %20, %18 : f32 + %22 = arith.cmpf olt, %21, %cst_4 : f32 + %23 = arith.cmpf olt, %21, %cst_7 : f32 + %24 = arith.mulf %21, %cst_3 : f32 + %25 = arith.subf %24, %cst_2 : f32 + %26 = arith.mulf %25, %21 : f32 + %27 = arith.mulf %26, %21 : f32 + %28 = arith.addf %27, %cst_7 : f32 + %29 = arith.mulf %21, %cst_1 : f32 + %30 = arith.addf %29, %cst_2 : f32 + %31 = arith.mulf %30, %21 : f32 + %32 = arith.subf %31, %cst_8 : f32 + %33 = arith.mulf %32, %21 : f32 + %34 = arith.addf %33, %cst_4 : f32 + %35 = arith.select %23, %28, %34 : f32 + %36 = arith.select %22, %35, %cst_5 : f32 + %37 = linalg.index 1 : index + %38 = arith.index_cast %37 : index to i32 + %39 = arith.sitofp %38 : i32 to f32 + %40 = arith.subf %9, %39 : f32 + %41 = arith.cmpf olt, %40, %cst_5 : f32 + %42 = arith.negf %40 : f32 + %43 = arith.select %41, %42, %40 : f32 + %44 = arith.cmpf olt, %43, %cst_4 : f32 + %45 = arith.cmpf olt, %43, %cst_7 : f32 + %46 = arith.mulf %43, %cst_3 : f32 + %47 = arith.subf %46, %cst_2 : f32 + %48 = arith.mulf %47, %43 : f32 + %49 = arith.mulf %48, %43 : f32 + %50 = arith.addf %49, %cst_7 : f32 + %51 = arith.mulf %43, %cst_1 : f32 + %52 = arith.addf %51, %cst_2 : f32 + %53 = arith.mulf %52, %43 : f32 + %54 = arith.subf %53, %cst_8 : f32 + %55 = arith.mulf %54, %43 : f32 + %56 = arith.addf %55, %cst_4 : f32 + %57 = arith.select %45, %50, %56 : f32 + %58 = arith.select %44, %57, %cst_5 : f32 + %59 = arith.mulf %in, %36 : f32 + %60 = arith.mulf %59, %58 : f32 + %61 = arith.addf %out, %60 : f32 + linalg.yield %61 : f32 + } + %13 = affine.load %alloca_9[] : memref + %14 = arith.divf %13, %11 : f32 + affine.store %14, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu.mlir new file mode 100644 index 000000000000..78fb2294736d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c5 = arith.constant 5 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + affine.for %arg2 = 0 to 25 { + affine.store %cst, %arg1[0, %arg2] : memref + } + affine.for %arg2 = 0 to 8 { + %0 = arith.muli %arg2, %c5 : index + %1 = arith.cmpi slt, %0, %c0 : index + %2 = arith.subi %c-1, %0 : index + %3 = arith.select %1, %2, %0 : index + %4 = arith.divsi %3, %c8 : index + %5 = arith.subi %c-1, %4 : index + %6 = arith.select %1, %5, %4 : index + affine.for %arg3 = 0 to 8 { + %7 = affine.load %arg0[%arg2, %arg3] : memref + %8 = arith.muli %arg3, %c5 : index + %9 = arith.cmpi slt, %8, %c0 : index + %10 = arith.subi %c-1, %8 : index + %11 = arith.select %9, %10, %8 : index + %12 = arith.divsi %11, %c8 : index + %13 = arith.subi %c-1, %12 : index + %14 = arith.select %9, %13, %12 : index + %15 = memref.load %arg1[%6, %14] : memref + %16 = arith.addf %15, %7 : f32 + memref.store %16, %arg1[%6, %14] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..3ad7bc5c2ecd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu/debuf.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c8 = arith.constant 8 : index + %c5 = arith.constant 5 : index + %c-1 = arith.constant -1 : index + %c0 = arith.constant 0 : index + %c25 = arith.constant 25 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [1, %c25] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %0[0, 0] [1, %c25] [1, 1] : tensor into tensor + %3 = affine.for %arg2 = 0 to 8 iter_args(%arg3 = %inserted_slice) -> (tensor) { + %5 = arith.muli %arg2, %c5 : index + %6 = arith.cmpi slt, %5, %c0 : index + %7 = arith.subi %c-1, %5 : index + %8 = arith.select %6, %7, %5 : index + %9 = arith.divsi %8, %c8 : index + %10 = arith.subi %c-1, %9 : index + %11 = arith.select %6, %10, %9 : index + %12 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %extracted = tensor.extract %1[%arg2, %arg4] : tensor + %13 = arith.muli %arg4, %c5 : index + %14 = arith.cmpi slt, %13, %c0 : index + %15 = arith.subi %c-1, %13 : index + %16 = arith.select %14, %15, %13 : index + %17 = arith.divsi %16, %c8 : index + %18 = arith.subi %c-1, %17 : index + %19 = arith.select %14, %18, %17 : index + %extracted_0 = tensor.extract %arg5[%11, %19] : tensor + %20 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %20 into %arg5[%11, %19] : tensor + affine.yield %inserted : tensor + } + affine.yield %12 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..d675bb53aae9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu/matched.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c8 = arith.constant 8 : index + %c5 = arith.constant 5 : index + %c-1 = arith.constant -1 : index + %c0 = arith.constant 0 : index + %c25 = arith.constant 25 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [1, %c25] [1, 1] : tensor to tensor + %2 = kernel.launch @memset_zero_1D_f32(%extracted_slice) : (tensor) -> tensor + %inserted_slice = tensor.insert_slice %2 into %0[0, 0] [1, %c25] [1, 1] : tensor into tensor + %3 = affine.for %arg2 = 0 to 8 iter_args(%arg3 = %inserted_slice) -> (tensor) { + %5 = arith.muli %arg2, %c5 : index + %6 = arith.cmpi slt, %5, %c0 : index + %7 = arith.subi %c-1, %5 : index + %8 = arith.select %6, %7, %5 : index + %9 = arith.divsi %8, %c8 : index + %10 = arith.subi %c-1, %9 : index + %11 = arith.select %6, %10, %9 : index + %12 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %extracted = tensor.extract %1[%arg2, %arg4] : tensor + %13 = arith.muli %arg4, %c5 : index + %14 = arith.cmpi slt, %13, %c0 : index + %15 = arith.subi %c-1, %13 : index + %16 = arith.select %14, %15, %13 : index + %17 = arith.divsi %16, %c8 : index + %18 = arith.subi %c-1, %17 : index + %19 = arith.select %14, %18, %17 : index + %extracted_0 = tensor.extract %arg5[%11, %19] : tensor + %20 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %20 into %arg5[%11, %19] : tensor + affine.yield %inserted : tensor + } + affine.yield %12 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..78fb2294736d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu/orig.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c5 = arith.constant 5 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %c0 = arith.constant 0 : index + affine.for %arg2 = 0 to 25 { + affine.store %cst, %arg1[0, %arg2] : memref + } + affine.for %arg2 = 0 to 8 { + %0 = arith.muli %arg2, %c5 : index + %1 = arith.cmpi slt, %0, %c0 : index + %2 = arith.subi %c-1, %0 : index + %3 = arith.select %1, %2, %0 : index + %4 = arith.divsi %3, %c8 : index + %5 = arith.subi %c-1, %4 : index + %6 = arith.select %1, %5, %4 : index + affine.for %arg3 = 0 to 8 { + %7 = affine.load %arg0[%arg2, %arg3] : memref + %8 = arith.muli %arg3, %c5 : index + %9 = arith.cmpi slt, %8, %c0 : index + %10 = arith.subi %c-1, %8 : index + %11 = arith.select %9, %10, %8 : index + %12 = arith.divsi %11, %c8 : index + %13 = arith.subi %c-1, %12 : index + %14 = arith.select %9, %13, %12 : index + %15 = memref.load %arg1[%6, %14] : memref + %16 = arith.addf %15, %7 : f32 + memref.store %16, %arg1[%6, %14] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..499846038d82 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu/raised.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c25 = arith.constant 25 : index + %c0 = arith.constant 0 : index + %c-1 = arith.constant -1 : index + %c5 = arith.constant 5 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg1[0, 0] [1, %c25] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 8 { + %0 = arith.muli %arg2, %c5 : index + %1 = arith.cmpi slt, %0, %c0 : index + %2 = arith.subi %c-1, %0 : index + %3 = arith.select %1, %2, %0 : index + %4 = arith.divsi %3, %c8 : index + %5 = arith.subi %c-1, %4 : index + %6 = arith.select %1, %5, %4 : index + affine.for %arg3 = 0 to 8 { + %7 = affine.load %arg0[%arg2, %arg3] : memref + %8 = arith.muli %arg3, %c5 : index + %9 = arith.cmpi slt, %8, %c0 : index + %10 = arith.subi %c-1, %8 : index + %11 = arith.select %9, %10, %8 : index + %12 = arith.divsi %11, %c8 : index + %13 = arith.subi %c-1, %12 : index + %14 = arith.select %9, %13, %12 : index + %15 = memref.load %arg1[%6, %14] : memref + %16 = arith.addf %15, %7 : f32 + memref.store %16, %arg1[%6, %14] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..3ad7bc5c2ecd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu_debuf.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c8 = arith.constant 8 : index + %c5 = arith.constant 5 : index + %c-1 = arith.constant -1 : index + %c0 = arith.constant 0 : index + %c25 = arith.constant 25 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %extracted_slice = tensor.extract_slice %0[0, 0] [1, %c25] [1, 1] : tensor to tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %2 into %0[0, 0] [1, %c25] [1, 1] : tensor into tensor + %3 = affine.for %arg2 = 0 to 8 iter_args(%arg3 = %inserted_slice) -> (tensor) { + %5 = arith.muli %arg2, %c5 : index + %6 = arith.cmpi slt, %5, %c0 : index + %7 = arith.subi %c-1, %5 : index + %8 = arith.select %6, %7, %5 : index + %9 = arith.divsi %8, %c8 : index + %10 = arith.subi %c-1, %9 : index + %11 = arith.select %6, %10, %9 : index + %12 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %arg3) -> (tensor) { + %extracted = tensor.extract %1[%arg2, %arg4] : tensor + %13 = arith.muli %arg4, %c5 : index + %14 = arith.cmpi slt, %13, %c0 : index + %15 = arith.subi %c-1, %13 : index + %16 = arith.select %14, %15, %13 : index + %17 = arith.divsi %16, %c8 : index + %18 = arith.subi %c-1, %17 : index + %19 = arith.select %14, %18, %17 : index + %extracted_0 = tensor.extract %arg5[%11, %19] : tensor + %20 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %20 into %arg5[%11, %19] : tensor + affine.yield %inserted : tensor + } + affine.yield %12 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..499846038d82 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_backward_cpu_linalg.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c25 = arith.constant 25 : index + %c0 = arith.constant 0 : index + %c-1 = arith.constant -1 : index + %c5 = arith.constant 5 : index + %c8 = arith.constant 8 : index + %cst = arith.constant 0.000000e+00 : f32 + %subview = memref.subview %arg1[0, 0] [1, %c25] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 8 { + %0 = arith.muli %arg2, %c5 : index + %1 = arith.cmpi slt, %0, %c0 : index + %2 = arith.subi %c-1, %0 : index + %3 = arith.select %1, %2, %0 : index + %4 = arith.divsi %3, %c8 : index + %5 = arith.subi %c-1, %4 : index + %6 = arith.select %1, %5, %4 : index + affine.for %arg3 = 0 to 8 { + %7 = affine.load %arg0[%arg2, %arg3] : memref + %8 = arith.muli %arg3, %c5 : index + %9 = arith.cmpi slt, %8, %c0 : index + %10 = arith.subi %c-1, %8 : index + %11 = arith.select %9, %10, %8 : index + %12 = arith.divsi %11, %c8 : index + %13 = arith.subi %c-1, %12 : index + %14 = arith.select %9, %13, %12 : index + %15 = memref.load %arg1[%6, %14] : memref + %16 = arith.addf %15, %7 : f32 + memref.store %16, %arg1[%6, %14] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu.mlir new file mode 100644 index 000000000000..91d29dd9e435 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu.mlir @@ -0,0 +1,180 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 1.250000e+00 : f32 + %cst_1 = arith.constant 2.250000e+00 : f32 + %cst_2 = arith.constant 2.000000e+00 : f32 + %cst_3 = arith.constant -7.500000e-01 : f32 + %cst_4 = arith.constant 3.750000e+00 : f32 + %cst_5 = arith.constant 6.000000e+00 : f32 + %cst_6 = arith.constant 3.000000e+00 : f32 + %true = arith.constant true + %c0_i32 = arith.constant 0 : i32 + %false = arith.constant false + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c4_i32 = arith.constant 4 : i32 + %c-1_i32 = arith.constant -1 : i32 + %cst_7 = arith.constant 0.000000e+00 : f32 + %cst_8 = arith.constant 8.000000e+00 : f32 + %cst_9 = arith.constant 5.000000e+00 : f32 + %cst_10 = arith.constant 7.000000e+00 : f32 + %cst_11 = arith.constant 4.000000e+00 : f32 + %cst_12 = arith.constant 5.000000e-01 : f32 + %0 = llvm.mlir.undef : f32 + affine.for %arg2 = 0 to 2 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = arith.muli %1, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %3 = arith.index_cast %arg3 : index to i32 + %4 = arith.sitofp %3 : i32 to f32 + %5 = arith.addf %4, %cst_12 : f32 + %6 = arith.mulf %5, %cst_11 : f32 + %7 = arith.divf %6, %cst_10 : f32 + %8 = arith.subf %7, %cst_12 : f32 + %9 = arith.fptosi %8 : f32 to i32 + %10 = arith.cmpf olt, %8, %cst_7 : f32 + %11 = arith.sitofp %9 : i32 to f32 + %12 = arith.cmpf une, %8, %11 : f32 + %13 = arith.andi %10, %12 : i1 + %14 = scf.if %13 -> (i32) { + %15 = arith.addi %9, %c-1_i32 : i32 + scf.yield %15 : i32 + } else { + scf.yield %9 : i32 + } + affine.for %arg4 = 0 to 8 { + %15 = arith.index_cast %arg4 : index to i32 + %16 = arith.sitofp %15 : i32 to f32 + %17 = arith.addf %16, %cst_12 : f32 + %18 = arith.mulf %17, %cst_9 : f32 + %19 = arith.divf %18, %cst_8 : f32 + %20 = arith.subf %19, %cst_12 : f32 + %21 = arith.fptosi %20 : f32 to i32 + %22 = arith.cmpf olt, %20, %cst_7 : f32 + %23 = arith.sitofp %21 : i32 to f32 + %24 = arith.cmpf une, %20, %23 : f32 + %25 = arith.andi %22, %24 : i1 + %26 = scf.if %25 -> (i32) { + %28 = arith.addi %21, %c-1_i32 : i32 + scf.yield %28 : i32 + } else { + scf.yield %21 : i32 + } + %27 = affine.for %arg5 = -1 to 3 iter_args(%arg6 = %cst_7) -> (f32) { + %28 = arith.index_cast %arg5 : index to i32 + %29 = arith.addi %14, %28 : i32 + %30 = arith.cmpi slt, %29, %c0_i32 : i32 + %31 = arith.select %30, %c0_i32, %29 : i32 + %32 = arith.sitofp %29 : i32 to f32 + %33 = arith.subf %8, %32 : f32 + %34 = scf.if %30 -> (i1) { + scf.yield %false : i1 + } else { + %50 = arith.cmpi sge, %29, %c4_i32 : i32 + scf.yield %50 : i1 + } + %35 = arith.select %34, %c3_i32, %31 : i32 + %36 = arith.addi %2, %35 : i32 + %37 = arith.muli %36, %c5_i32 : i32 + %38 = arith.cmpf olt, %33, %cst_7 : f32 + %39 = scf.if %38 -> (f32) { + %50 = arith.negf %33 : f32 + scf.yield %50 : f32 + } else { + scf.yield %33 : f32 + } + %40 = arith.cmpf olt, %39, %cst : f32 + %41 = arith.xori %40, %true : i1 + %42 = scf.if %40 -> (f32) { + %50 = arith.mulf %39, %cst_0 : f32 + %51 = arith.subf %50, %cst_1 : f32 + %52 = arith.mulf %51, %39 : f32 + %53 = arith.mulf %52, %39 : f32 + %54 = arith.addf %53, %cst : f32 + scf.yield %54 : f32 + } else { + scf.yield %0 : f32 + } + %43 = arith.cmpf olt, %39, %cst_2 : f32 + %44 = arith.andi %43, %41 : i1 + %45 = arith.xori %44, %true : i1 + %46 = arith.andi %45, %41 : i1 + %47 = scf.if %44 -> (f32) { + %50 = arith.mulf %39, %cst_3 : f32 + %51 = arith.addf %50, %cst_4 : f32 + %52 = arith.mulf %51, %39 : f32 + %53 = arith.subf %52, %cst_5 : f32 + %54 = arith.mulf %53, %39 : f32 + %55 = arith.addf %54, %cst_6 : f32 + scf.yield %55 : f32 + } else { + scf.yield %42 : f32 + } + %48 = arith.select %46, %cst_7, %47 : f32 + %49 = affine.for %arg7 = -1 to 3 iter_args(%arg8 = %arg6) -> (f32) { + %50 = arith.index_cast %arg7 : index to i32 + %51 = arith.addi %26, %50 : i32 + %52 = arith.cmpi slt, %51, %c0_i32 : i32 + %53 = arith.select %52, %c0_i32, %51 : i32 + %54 = scf.if %52 -> (i1) { + scf.yield %false : i1 + } else { + %75 = arith.cmpi sge, %51, %c5_i32 : i32 + scf.yield %75 : i1 + } + %55 = arith.select %54, %c4_i32, %53 : i32 + %56 = arith.addi %37, %55 : i32 + %57 = arith.index_cast %56 : i32 to index + %58 = memref.load %arg0[%57] : memref + %59 = arith.mulf %58, %48 : f32 + %60 = arith.sitofp %51 : i32 to f32 + %61 = arith.subf %20, %60 : f32 + %62 = arith.cmpf olt, %61, %cst_7 : f32 + %63 = scf.if %62 -> (f32) { + %75 = arith.negf %61 : f32 + scf.yield %75 : f32 + } else { + scf.yield %61 : f32 + } + %64 = arith.cmpf olt, %63, %cst : f32 + %65 = arith.xori %64, %true : i1 + %66 = scf.if %64 -> (f32) { + %75 = arith.mulf %63, %cst_0 : f32 + %76 = arith.subf %75, %cst_1 : f32 + %77 = arith.mulf %76, %63 : f32 + %78 = arith.mulf %77, %63 : f32 + %79 = arith.addf %78, %cst : f32 + scf.yield %79 : f32 + } else { + scf.yield %0 : f32 + } + %67 = arith.cmpf olt, %63, %cst_2 : f32 + %68 = arith.andi %67, %65 : i1 + %69 = arith.xori %68, %true : i1 + %70 = arith.andi %69, %65 : i1 + %71 = scf.if %68 -> (f32) { + %75 = arith.mulf %63, %cst_3 : f32 + %76 = arith.addf %75, %cst_4 : f32 + %77 = arith.mulf %76, %63 : f32 + %78 = arith.subf %77, %cst_5 : f32 + %79 = arith.mulf %78, %63 : f32 + %80 = arith.addf %79, %cst_6 : f32 + scf.yield %80 : f32 + } else { + scf.yield %66 : f32 + } + %72 = arith.select %70, %cst_7, %71 : f32 + %73 = arith.mulf %59, %72 : f32 + %74 = arith.addf %arg8, %73 : f32 + affine.yield %74 : f32 + } + affine.yield %49 : f32 + } + affine.store %27, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu/debuf.mlir new file mode 100644 index 000000000000..3cef09b09c52 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu/debuf.mlir @@ -0,0 +1,154 @@ +#map = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 8.000000e+00 : f32 + %cst_4 = arith.constant 0.000000e+00 : f32 + %c-1_i32 = arith.constant -1 : i32 + %c4_i32 = arith.constant 4 : i32 + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %false = arith.constant false + %c0_i32 = arith.constant 0 : i32 + %true = arith.constant true + %cst_5 = arith.constant 3.000000e+00 : f32 + %cst_6 = arith.constant 6.000000e+00 : f32 + %cst_7 = arith.constant 3.750000e+00 : f32 + %cst_8 = arith.constant -7.500000e-01 : f32 + %cst_9 = arith.constant 2.000000e+00 : f32 + %cst_10 = arith.constant 2.250000e+00 : f32 + %cst_11 = arith.constant 1.250000e+00 : f32 + %cst_12 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = llvm.mlir.undef : f32 + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.sitofp %8 : i32 to f32 + %10 = arith.addf %9, %cst : f32 + %11 = arith.mulf %10, %cst_0 : f32 + %12 = arith.divf %11, %cst_1 : f32 + %13 = arith.subf %12, %cst : f32 + %14 = arith.fptosi %13 : f32 to i32 + %15 = arith.cmpf olt, %13, %cst_4 : f32 + %16 = arith.sitofp %14 : i32 to f32 + %17 = arith.cmpf une, %13, %16 : f32 + %18 = arith.andi %15, %17 : i1 + %19 = arith.addi %14, %c-1_i32 : i32 + %20 = arith.select %18, %19, %14 : i32 + %21 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %22 = arith.index_cast %arg6 : index to i32 + %23 = arith.sitofp %22 : i32 to f32 + %24 = arith.addf %23, %cst : f32 + %25 = arith.mulf %24, %cst_2 : f32 + %26 = arith.divf %25, %cst_3 : f32 + %27 = arith.subf %26, %cst : f32 + %28 = arith.fptosi %27 : f32 to i32 + %29 = arith.cmpf olt, %27, %cst_4 : f32 + %30 = arith.sitofp %28 : i32 to f32 + %31 = arith.cmpf une, %27, %30 : f32 + %32 = arith.andi %29, %31 : i1 + %33 = arith.addi %28, %c-1_i32 : i32 + %34 = arith.select %32, %33, %28 : i32 + %35 = affine.apply #map(%arg6, %arg2, %arg4) + %inserted = tensor.insert %cst_4 into %arg7[%35] : tensor + %36 = affine.for %arg8 = -1 to 3 iter_args(%arg9 = %inserted) -> (tensor) { + %37 = arith.index_cast %arg8 : index to i32 + %38 = arith.addi %20, %37 : i32 + %39 = arith.cmpi slt, %38, %c0_i32 : i32 + %40 = arith.select %39, %c0_i32, %38 : i32 + %41 = arith.sitofp %38 : i32 to f32 + %42 = arith.subf %13, %41 : f32 + %43 = arith.cmpi sge, %38, %c4_i32 : i32 + %44 = arith.select %39, %false, %43 : i1 + %45 = arith.select %44, %c3_i32, %40 : i32 + %46 = arith.addi %6, %45 : i32 + %47 = arith.muli %46, %c5_i32 : i32 + %48 = arith.cmpf olt, %42, %cst_4 : f32 + %49 = arith.negf %42 : f32 + %50 = arith.select %48, %49, %42 : f32 + %51 = arith.cmpf olt, %50, %cst_12 : f32 + %52 = arith.xori %51, %true : i1 + %53 = arith.mulf %50, %cst_11 : f32 + %54 = arith.subf %53, %cst_10 : f32 + %55 = arith.mulf %54, %50 : f32 + %56 = arith.mulf %55, %50 : f32 + %57 = arith.addf %56, %cst_12 : f32 + %58 = arith.select %51, %57, %2 : f32 + %59 = arith.cmpf olt, %50, %cst_9 : f32 + %60 = arith.andi %59, %52 : i1 + %61 = arith.xori %60, %true : i1 + %62 = arith.andi %61, %52 : i1 + %63 = arith.mulf %50, %cst_8 : f32 + %64 = arith.addf %63, %cst_7 : f32 + %65 = arith.mulf %64, %50 : f32 + %66 = arith.subf %65, %cst_6 : f32 + %67 = arith.mulf %66, %50 : f32 + %68 = arith.addf %67, %cst_5 : f32 + %69 = arith.select %60, %68, %58 : f32 + %70 = arith.select %62, %cst_4, %69 : f32 + %71 = affine.for %arg10 = -1 to 3 iter_args(%arg11 = %arg9) -> (tensor) { + %72 = affine.apply #map(%arg6, %arg2, %arg4) + %extracted = tensor.extract %arg11[%72] : tensor + %73 = arith.index_cast %arg10 : index to i32 + %74 = arith.addi %34, %73 : i32 + %75 = arith.cmpi slt, %74, %c0_i32 : i32 + %76 = arith.select %75, %c0_i32, %74 : i32 + %77 = arith.cmpi sge, %74, %c5_i32 : i32 + %78 = arith.select %75, %false, %77 : i1 + %79 = arith.select %78, %c4_i32, %76 : i32 + %80 = arith.addi %47, %79 : i32 + %81 = arith.index_cast %80 : i32 to index + %extracted_13 = tensor.extract %1[%81] : tensor + %82 = arith.mulf %extracted_13, %70 : f32 + %83 = arith.sitofp %74 : i32 to f32 + %84 = arith.subf %27, %83 : f32 + %85 = arith.cmpf olt, %84, %cst_4 : f32 + %86 = arith.negf %84 : f32 + %87 = arith.select %85, %86, %84 : f32 + %88 = arith.cmpf olt, %87, %cst_12 : f32 + %89 = arith.xori %88, %true : i1 + %90 = arith.mulf %87, %cst_11 : f32 + %91 = arith.subf %90, %cst_10 : f32 + %92 = arith.mulf %91, %87 : f32 + %93 = arith.mulf %92, %87 : f32 + %94 = arith.addf %93, %cst_12 : f32 + %95 = arith.select %88, %94, %2 : f32 + %96 = arith.cmpf olt, %87, %cst_9 : f32 + %97 = arith.andi %96, %89 : i1 + %98 = arith.xori %97, %true : i1 + %99 = arith.andi %98, %89 : i1 + %100 = arith.mulf %87, %cst_8 : f32 + %101 = arith.addf %100, %cst_7 : f32 + %102 = arith.mulf %101, %87 : f32 + %103 = arith.subf %102, %cst_6 : f32 + %104 = arith.mulf %103, %87 : f32 + %105 = arith.addf %104, %cst_5 : f32 + %106 = arith.select %97, %105, %95 : f32 + %107 = arith.select %99, %cst_4, %106 : f32 + %108 = arith.mulf %82, %107 : f32 + %109 = arith.addf %extracted, %108 : f32 + %110 = affine.apply #map(%arg6, %arg2, %arg4) + %inserted_14 = tensor.insert %109 into %arg11[%110] : tensor + affine.yield %inserted_14 : tensor + } + affine.yield %71 : tensor + } + affine.yield %36 : tensor + } + affine.yield %21 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu/matched.mlir new file mode 100644 index 000000000000..3cef09b09c52 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu/matched.mlir @@ -0,0 +1,154 @@ +#map = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 8.000000e+00 : f32 + %cst_4 = arith.constant 0.000000e+00 : f32 + %c-1_i32 = arith.constant -1 : i32 + %c4_i32 = arith.constant 4 : i32 + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %false = arith.constant false + %c0_i32 = arith.constant 0 : i32 + %true = arith.constant true + %cst_5 = arith.constant 3.000000e+00 : f32 + %cst_6 = arith.constant 6.000000e+00 : f32 + %cst_7 = arith.constant 3.750000e+00 : f32 + %cst_8 = arith.constant -7.500000e-01 : f32 + %cst_9 = arith.constant 2.000000e+00 : f32 + %cst_10 = arith.constant 2.250000e+00 : f32 + %cst_11 = arith.constant 1.250000e+00 : f32 + %cst_12 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = llvm.mlir.undef : f32 + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.sitofp %8 : i32 to f32 + %10 = arith.addf %9, %cst : f32 + %11 = arith.mulf %10, %cst_0 : f32 + %12 = arith.divf %11, %cst_1 : f32 + %13 = arith.subf %12, %cst : f32 + %14 = arith.fptosi %13 : f32 to i32 + %15 = arith.cmpf olt, %13, %cst_4 : f32 + %16 = arith.sitofp %14 : i32 to f32 + %17 = arith.cmpf une, %13, %16 : f32 + %18 = arith.andi %15, %17 : i1 + %19 = arith.addi %14, %c-1_i32 : i32 + %20 = arith.select %18, %19, %14 : i32 + %21 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %22 = arith.index_cast %arg6 : index to i32 + %23 = arith.sitofp %22 : i32 to f32 + %24 = arith.addf %23, %cst : f32 + %25 = arith.mulf %24, %cst_2 : f32 + %26 = arith.divf %25, %cst_3 : f32 + %27 = arith.subf %26, %cst : f32 + %28 = arith.fptosi %27 : f32 to i32 + %29 = arith.cmpf olt, %27, %cst_4 : f32 + %30 = arith.sitofp %28 : i32 to f32 + %31 = arith.cmpf une, %27, %30 : f32 + %32 = arith.andi %29, %31 : i1 + %33 = arith.addi %28, %c-1_i32 : i32 + %34 = arith.select %32, %33, %28 : i32 + %35 = affine.apply #map(%arg6, %arg2, %arg4) + %inserted = tensor.insert %cst_4 into %arg7[%35] : tensor + %36 = affine.for %arg8 = -1 to 3 iter_args(%arg9 = %inserted) -> (tensor) { + %37 = arith.index_cast %arg8 : index to i32 + %38 = arith.addi %20, %37 : i32 + %39 = arith.cmpi slt, %38, %c0_i32 : i32 + %40 = arith.select %39, %c0_i32, %38 : i32 + %41 = arith.sitofp %38 : i32 to f32 + %42 = arith.subf %13, %41 : f32 + %43 = arith.cmpi sge, %38, %c4_i32 : i32 + %44 = arith.select %39, %false, %43 : i1 + %45 = arith.select %44, %c3_i32, %40 : i32 + %46 = arith.addi %6, %45 : i32 + %47 = arith.muli %46, %c5_i32 : i32 + %48 = arith.cmpf olt, %42, %cst_4 : f32 + %49 = arith.negf %42 : f32 + %50 = arith.select %48, %49, %42 : f32 + %51 = arith.cmpf olt, %50, %cst_12 : f32 + %52 = arith.xori %51, %true : i1 + %53 = arith.mulf %50, %cst_11 : f32 + %54 = arith.subf %53, %cst_10 : f32 + %55 = arith.mulf %54, %50 : f32 + %56 = arith.mulf %55, %50 : f32 + %57 = arith.addf %56, %cst_12 : f32 + %58 = arith.select %51, %57, %2 : f32 + %59 = arith.cmpf olt, %50, %cst_9 : f32 + %60 = arith.andi %59, %52 : i1 + %61 = arith.xori %60, %true : i1 + %62 = arith.andi %61, %52 : i1 + %63 = arith.mulf %50, %cst_8 : f32 + %64 = arith.addf %63, %cst_7 : f32 + %65 = arith.mulf %64, %50 : f32 + %66 = arith.subf %65, %cst_6 : f32 + %67 = arith.mulf %66, %50 : f32 + %68 = arith.addf %67, %cst_5 : f32 + %69 = arith.select %60, %68, %58 : f32 + %70 = arith.select %62, %cst_4, %69 : f32 + %71 = affine.for %arg10 = -1 to 3 iter_args(%arg11 = %arg9) -> (tensor) { + %72 = affine.apply #map(%arg6, %arg2, %arg4) + %extracted = tensor.extract %arg11[%72] : tensor + %73 = arith.index_cast %arg10 : index to i32 + %74 = arith.addi %34, %73 : i32 + %75 = arith.cmpi slt, %74, %c0_i32 : i32 + %76 = arith.select %75, %c0_i32, %74 : i32 + %77 = arith.cmpi sge, %74, %c5_i32 : i32 + %78 = arith.select %75, %false, %77 : i1 + %79 = arith.select %78, %c4_i32, %76 : i32 + %80 = arith.addi %47, %79 : i32 + %81 = arith.index_cast %80 : i32 to index + %extracted_13 = tensor.extract %1[%81] : tensor + %82 = arith.mulf %extracted_13, %70 : f32 + %83 = arith.sitofp %74 : i32 to f32 + %84 = arith.subf %27, %83 : f32 + %85 = arith.cmpf olt, %84, %cst_4 : f32 + %86 = arith.negf %84 : f32 + %87 = arith.select %85, %86, %84 : f32 + %88 = arith.cmpf olt, %87, %cst_12 : f32 + %89 = arith.xori %88, %true : i1 + %90 = arith.mulf %87, %cst_11 : f32 + %91 = arith.subf %90, %cst_10 : f32 + %92 = arith.mulf %91, %87 : f32 + %93 = arith.mulf %92, %87 : f32 + %94 = arith.addf %93, %cst_12 : f32 + %95 = arith.select %88, %94, %2 : f32 + %96 = arith.cmpf olt, %87, %cst_9 : f32 + %97 = arith.andi %96, %89 : i1 + %98 = arith.xori %97, %true : i1 + %99 = arith.andi %98, %89 : i1 + %100 = arith.mulf %87, %cst_8 : f32 + %101 = arith.addf %100, %cst_7 : f32 + %102 = arith.mulf %101, %87 : f32 + %103 = arith.subf %102, %cst_6 : f32 + %104 = arith.mulf %103, %87 : f32 + %105 = arith.addf %104, %cst_5 : f32 + %106 = arith.select %97, %105, %95 : f32 + %107 = arith.select %99, %cst_4, %106 : f32 + %108 = arith.mulf %82, %107 : f32 + %109 = arith.addf %extracted, %108 : f32 + %110 = affine.apply #map(%arg6, %arg2, %arg4) + %inserted_14 = tensor.insert %109 into %arg11[%110] : tensor + affine.yield %inserted_14 : tensor + } + affine.yield %71 : tensor + } + affine.yield %36 : tensor + } + affine.yield %21 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu/orig.mlir new file mode 100644 index 000000000000..91d29dd9e435 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu/orig.mlir @@ -0,0 +1,180 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 1.250000e+00 : f32 + %cst_1 = arith.constant 2.250000e+00 : f32 + %cst_2 = arith.constant 2.000000e+00 : f32 + %cst_3 = arith.constant -7.500000e-01 : f32 + %cst_4 = arith.constant 3.750000e+00 : f32 + %cst_5 = arith.constant 6.000000e+00 : f32 + %cst_6 = arith.constant 3.000000e+00 : f32 + %true = arith.constant true + %c0_i32 = arith.constant 0 : i32 + %false = arith.constant false + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c4_i32 = arith.constant 4 : i32 + %c-1_i32 = arith.constant -1 : i32 + %cst_7 = arith.constant 0.000000e+00 : f32 + %cst_8 = arith.constant 8.000000e+00 : f32 + %cst_9 = arith.constant 5.000000e+00 : f32 + %cst_10 = arith.constant 7.000000e+00 : f32 + %cst_11 = arith.constant 4.000000e+00 : f32 + %cst_12 = arith.constant 5.000000e-01 : f32 + %0 = llvm.mlir.undef : f32 + affine.for %arg2 = 0 to 2 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = arith.muli %1, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %3 = arith.index_cast %arg3 : index to i32 + %4 = arith.sitofp %3 : i32 to f32 + %5 = arith.addf %4, %cst_12 : f32 + %6 = arith.mulf %5, %cst_11 : f32 + %7 = arith.divf %6, %cst_10 : f32 + %8 = arith.subf %7, %cst_12 : f32 + %9 = arith.fptosi %8 : f32 to i32 + %10 = arith.cmpf olt, %8, %cst_7 : f32 + %11 = arith.sitofp %9 : i32 to f32 + %12 = arith.cmpf une, %8, %11 : f32 + %13 = arith.andi %10, %12 : i1 + %14 = scf.if %13 -> (i32) { + %15 = arith.addi %9, %c-1_i32 : i32 + scf.yield %15 : i32 + } else { + scf.yield %9 : i32 + } + affine.for %arg4 = 0 to 8 { + %15 = arith.index_cast %arg4 : index to i32 + %16 = arith.sitofp %15 : i32 to f32 + %17 = arith.addf %16, %cst_12 : f32 + %18 = arith.mulf %17, %cst_9 : f32 + %19 = arith.divf %18, %cst_8 : f32 + %20 = arith.subf %19, %cst_12 : f32 + %21 = arith.fptosi %20 : f32 to i32 + %22 = arith.cmpf olt, %20, %cst_7 : f32 + %23 = arith.sitofp %21 : i32 to f32 + %24 = arith.cmpf une, %20, %23 : f32 + %25 = arith.andi %22, %24 : i1 + %26 = scf.if %25 -> (i32) { + %28 = arith.addi %21, %c-1_i32 : i32 + scf.yield %28 : i32 + } else { + scf.yield %21 : i32 + } + %27 = affine.for %arg5 = -1 to 3 iter_args(%arg6 = %cst_7) -> (f32) { + %28 = arith.index_cast %arg5 : index to i32 + %29 = arith.addi %14, %28 : i32 + %30 = arith.cmpi slt, %29, %c0_i32 : i32 + %31 = arith.select %30, %c0_i32, %29 : i32 + %32 = arith.sitofp %29 : i32 to f32 + %33 = arith.subf %8, %32 : f32 + %34 = scf.if %30 -> (i1) { + scf.yield %false : i1 + } else { + %50 = arith.cmpi sge, %29, %c4_i32 : i32 + scf.yield %50 : i1 + } + %35 = arith.select %34, %c3_i32, %31 : i32 + %36 = arith.addi %2, %35 : i32 + %37 = arith.muli %36, %c5_i32 : i32 + %38 = arith.cmpf olt, %33, %cst_7 : f32 + %39 = scf.if %38 -> (f32) { + %50 = arith.negf %33 : f32 + scf.yield %50 : f32 + } else { + scf.yield %33 : f32 + } + %40 = arith.cmpf olt, %39, %cst : f32 + %41 = arith.xori %40, %true : i1 + %42 = scf.if %40 -> (f32) { + %50 = arith.mulf %39, %cst_0 : f32 + %51 = arith.subf %50, %cst_1 : f32 + %52 = arith.mulf %51, %39 : f32 + %53 = arith.mulf %52, %39 : f32 + %54 = arith.addf %53, %cst : f32 + scf.yield %54 : f32 + } else { + scf.yield %0 : f32 + } + %43 = arith.cmpf olt, %39, %cst_2 : f32 + %44 = arith.andi %43, %41 : i1 + %45 = arith.xori %44, %true : i1 + %46 = arith.andi %45, %41 : i1 + %47 = scf.if %44 -> (f32) { + %50 = arith.mulf %39, %cst_3 : f32 + %51 = arith.addf %50, %cst_4 : f32 + %52 = arith.mulf %51, %39 : f32 + %53 = arith.subf %52, %cst_5 : f32 + %54 = arith.mulf %53, %39 : f32 + %55 = arith.addf %54, %cst_6 : f32 + scf.yield %55 : f32 + } else { + scf.yield %42 : f32 + } + %48 = arith.select %46, %cst_7, %47 : f32 + %49 = affine.for %arg7 = -1 to 3 iter_args(%arg8 = %arg6) -> (f32) { + %50 = arith.index_cast %arg7 : index to i32 + %51 = arith.addi %26, %50 : i32 + %52 = arith.cmpi slt, %51, %c0_i32 : i32 + %53 = arith.select %52, %c0_i32, %51 : i32 + %54 = scf.if %52 -> (i1) { + scf.yield %false : i1 + } else { + %75 = arith.cmpi sge, %51, %c5_i32 : i32 + scf.yield %75 : i1 + } + %55 = arith.select %54, %c4_i32, %53 : i32 + %56 = arith.addi %37, %55 : i32 + %57 = arith.index_cast %56 : i32 to index + %58 = memref.load %arg0[%57] : memref + %59 = arith.mulf %58, %48 : f32 + %60 = arith.sitofp %51 : i32 to f32 + %61 = arith.subf %20, %60 : f32 + %62 = arith.cmpf olt, %61, %cst_7 : f32 + %63 = scf.if %62 -> (f32) { + %75 = arith.negf %61 : f32 + scf.yield %75 : f32 + } else { + scf.yield %61 : f32 + } + %64 = arith.cmpf olt, %63, %cst : f32 + %65 = arith.xori %64, %true : i1 + %66 = scf.if %64 -> (f32) { + %75 = arith.mulf %63, %cst_0 : f32 + %76 = arith.subf %75, %cst_1 : f32 + %77 = arith.mulf %76, %63 : f32 + %78 = arith.mulf %77, %63 : f32 + %79 = arith.addf %78, %cst : f32 + scf.yield %79 : f32 + } else { + scf.yield %0 : f32 + } + %67 = arith.cmpf olt, %63, %cst_2 : f32 + %68 = arith.andi %67, %65 : i1 + %69 = arith.xori %68, %true : i1 + %70 = arith.andi %69, %65 : i1 + %71 = scf.if %68 -> (f32) { + %75 = arith.mulf %63, %cst_3 : f32 + %76 = arith.addf %75, %cst_4 : f32 + %77 = arith.mulf %76, %63 : f32 + %78 = arith.subf %77, %cst_5 : f32 + %79 = arith.mulf %78, %63 : f32 + %80 = arith.addf %79, %cst_6 : f32 + scf.yield %80 : f32 + } else { + scf.yield %66 : f32 + } + %72 = arith.select %70, %cst_7, %71 : f32 + %73 = arith.mulf %59, %72 : f32 + %74 = arith.addf %arg8, %73 : f32 + affine.yield %74 : f32 + } + affine.yield %49 : f32 + } + affine.store %27, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu/raised.mlir new file mode 100644 index 000000000000..d3245cf067da --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu/raised.mlir @@ -0,0 +1,141 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 1.250000e+00 : f32 + %cst_1 = arith.constant 2.250000e+00 : f32 + %cst_2 = arith.constant 2.000000e+00 : f32 + %cst_3 = arith.constant -7.500000e-01 : f32 + %cst_4 = arith.constant 3.750000e+00 : f32 + %cst_5 = arith.constant 6.000000e+00 : f32 + %cst_6 = arith.constant 3.000000e+00 : f32 + %true = arith.constant true + %c0_i32 = arith.constant 0 : i32 + %false = arith.constant false + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c4_i32 = arith.constant 4 : i32 + %c-1_i32 = arith.constant -1 : i32 + %cst_7 = arith.constant 0.000000e+00 : f32 + %cst_8 = arith.constant 8.000000e+00 : f32 + %cst_9 = arith.constant 5.000000e+00 : f32 + %cst_10 = arith.constant 7.000000e+00 : f32 + %cst_11 = arith.constant 4.000000e+00 : f32 + %cst_12 = arith.constant 5.000000e-01 : f32 + %0 = llvm.mlir.undef : f32 + affine.for %arg2 = 0 to 2 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = arith.muli %1, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %3 = arith.index_cast %arg3 : index to i32 + %4 = arith.sitofp %3 : i32 to f32 + %5 = arith.addf %4, %cst_12 : f32 + %6 = arith.mulf %5, %cst_11 : f32 + %7 = arith.divf %6, %cst_10 : f32 + %8 = arith.subf %7, %cst_12 : f32 + %9 = arith.fptosi %8 : f32 to i32 + %10 = arith.cmpf olt, %8, %cst_7 : f32 + %11 = arith.sitofp %9 : i32 to f32 + %12 = arith.cmpf une, %8, %11 : f32 + %13 = arith.andi %10, %12 : i1 + %14 = arith.addi %9, %c-1_i32 : i32 + %15 = arith.select %13, %14, %9 : i32 + affine.for %arg4 = 0 to 8 { + %16 = arith.index_cast %arg4 : index to i32 + %17 = arith.sitofp %16 : i32 to f32 + %18 = arith.addf %17, %cst_12 : f32 + %19 = arith.mulf %18, %cst_9 : f32 + %20 = arith.divf %19, %cst_8 : f32 + %21 = arith.subf %20, %cst_12 : f32 + %22 = arith.fptosi %21 : f32 to i32 + %23 = arith.cmpf olt, %21, %cst_7 : f32 + %24 = arith.sitofp %22 : i32 to f32 + %25 = arith.cmpf une, %21, %24 : f32 + %26 = arith.andi %23, %25 : i1 + %27 = arith.addi %22, %c-1_i32 : i32 + %28 = arith.select %26, %27, %22 : i32 + affine.store %cst_7, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + affine.for %arg5 = -1 to 3 { + %29 = arith.index_cast %arg5 : index to i32 + %30 = arith.addi %15, %29 : i32 + %31 = arith.cmpi slt, %30, %c0_i32 : i32 + %32 = arith.select %31, %c0_i32, %30 : i32 + %33 = arith.sitofp %30 : i32 to f32 + %34 = arith.subf %8, %33 : f32 + %35 = arith.cmpi sge, %30, %c4_i32 : i32 + %36 = arith.select %31, %false, %35 : i1 + %37 = arith.select %36, %c3_i32, %32 : i32 + %38 = arith.addi %2, %37 : i32 + %39 = arith.muli %38, %c5_i32 : i32 + %40 = arith.cmpf olt, %34, %cst_7 : f32 + %41 = arith.negf %34 : f32 + %42 = arith.select %40, %41, %34 : f32 + %43 = arith.cmpf olt, %42, %cst : f32 + %44 = arith.xori %43, %true : i1 + %45 = arith.mulf %42, %cst_0 : f32 + %46 = arith.subf %45, %cst_1 : f32 + %47 = arith.mulf %46, %42 : f32 + %48 = arith.mulf %47, %42 : f32 + %49 = arith.addf %48, %cst : f32 + %50 = arith.select %43, %49, %0 : f32 + %51 = arith.cmpf olt, %42, %cst_2 : f32 + %52 = arith.andi %51, %44 : i1 + %53 = arith.xori %52, %true : i1 + %54 = arith.andi %53, %44 : i1 + %55 = arith.mulf %42, %cst_3 : f32 + %56 = arith.addf %55, %cst_4 : f32 + %57 = arith.mulf %56, %42 : f32 + %58 = arith.subf %57, %cst_5 : f32 + %59 = arith.mulf %58, %42 : f32 + %60 = arith.addf %59, %cst_6 : f32 + %61 = arith.select %52, %60, %50 : f32 + %62 = arith.select %54, %cst_7, %61 : f32 + affine.for %arg6 = -1 to 3 { + %63 = affine.load %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %64 = arith.index_cast %arg6 : index to i32 + %65 = arith.addi %28, %64 : i32 + %66 = arith.cmpi slt, %65, %c0_i32 : i32 + %67 = arith.select %66, %c0_i32, %65 : i32 + %68 = arith.cmpi sge, %65, %c5_i32 : i32 + %69 = arith.select %66, %false, %68 : i1 + %70 = arith.select %69, %c4_i32, %67 : i32 + %71 = arith.addi %39, %70 : i32 + %72 = arith.index_cast %71 : i32 to index + %73 = memref.load %arg0[%72] : memref + %74 = arith.mulf %73, %62 : f32 + %75 = arith.sitofp %65 : i32 to f32 + %76 = arith.subf %21, %75 : f32 + %77 = arith.cmpf olt, %76, %cst_7 : f32 + %78 = arith.negf %76 : f32 + %79 = arith.select %77, %78, %76 : f32 + %80 = arith.cmpf olt, %79, %cst : f32 + %81 = arith.xori %80, %true : i1 + %82 = arith.mulf %79, %cst_0 : f32 + %83 = arith.subf %82, %cst_1 : f32 + %84 = arith.mulf %83, %79 : f32 + %85 = arith.mulf %84, %79 : f32 + %86 = arith.addf %85, %cst : f32 + %87 = arith.select %80, %86, %0 : f32 + %88 = arith.cmpf olt, %79, %cst_2 : f32 + %89 = arith.andi %88, %81 : i1 + %90 = arith.xori %89, %true : i1 + %91 = arith.andi %90, %81 : i1 + %92 = arith.mulf %79, %cst_3 : f32 + %93 = arith.addf %92, %cst_4 : f32 + %94 = arith.mulf %93, %79 : f32 + %95 = arith.subf %94, %cst_5 : f32 + %96 = arith.mulf %95, %79 : f32 + %97 = arith.addf %96, %cst_6 : f32 + %98 = arith.select %89, %97, %87 : f32 + %99 = arith.select %91, %cst_7, %98 : f32 + %100 = arith.mulf %74, %99 : f32 + %101 = arith.addf %63, %100 : f32 + affine.store %101, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu_debuf.mlir new file mode 100644 index 000000000000..3cef09b09c52 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu_debuf.mlir @@ -0,0 +1,154 @@ +#map = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 8.000000e+00 : f32 + %cst_4 = arith.constant 0.000000e+00 : f32 + %c-1_i32 = arith.constant -1 : i32 + %c4_i32 = arith.constant 4 : i32 + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %false = arith.constant false + %c0_i32 = arith.constant 0 : i32 + %true = arith.constant true + %cst_5 = arith.constant 3.000000e+00 : f32 + %cst_6 = arith.constant 6.000000e+00 : f32 + %cst_7 = arith.constant 3.750000e+00 : f32 + %cst_8 = arith.constant -7.500000e-01 : f32 + %cst_9 = arith.constant 2.000000e+00 : f32 + %cst_10 = arith.constant 2.250000e+00 : f32 + %cst_11 = arith.constant 1.250000e+00 : f32 + %cst_12 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = llvm.mlir.undef : f32 + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.sitofp %8 : i32 to f32 + %10 = arith.addf %9, %cst : f32 + %11 = arith.mulf %10, %cst_0 : f32 + %12 = arith.divf %11, %cst_1 : f32 + %13 = arith.subf %12, %cst : f32 + %14 = arith.fptosi %13 : f32 to i32 + %15 = arith.cmpf olt, %13, %cst_4 : f32 + %16 = arith.sitofp %14 : i32 to f32 + %17 = arith.cmpf une, %13, %16 : f32 + %18 = arith.andi %15, %17 : i1 + %19 = arith.addi %14, %c-1_i32 : i32 + %20 = arith.select %18, %19, %14 : i32 + %21 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %22 = arith.index_cast %arg6 : index to i32 + %23 = arith.sitofp %22 : i32 to f32 + %24 = arith.addf %23, %cst : f32 + %25 = arith.mulf %24, %cst_2 : f32 + %26 = arith.divf %25, %cst_3 : f32 + %27 = arith.subf %26, %cst : f32 + %28 = arith.fptosi %27 : f32 to i32 + %29 = arith.cmpf olt, %27, %cst_4 : f32 + %30 = arith.sitofp %28 : i32 to f32 + %31 = arith.cmpf une, %27, %30 : f32 + %32 = arith.andi %29, %31 : i1 + %33 = arith.addi %28, %c-1_i32 : i32 + %34 = arith.select %32, %33, %28 : i32 + %35 = affine.apply #map(%arg6, %arg2, %arg4) + %inserted = tensor.insert %cst_4 into %arg7[%35] : tensor + %36 = affine.for %arg8 = -1 to 3 iter_args(%arg9 = %inserted) -> (tensor) { + %37 = arith.index_cast %arg8 : index to i32 + %38 = arith.addi %20, %37 : i32 + %39 = arith.cmpi slt, %38, %c0_i32 : i32 + %40 = arith.select %39, %c0_i32, %38 : i32 + %41 = arith.sitofp %38 : i32 to f32 + %42 = arith.subf %13, %41 : f32 + %43 = arith.cmpi sge, %38, %c4_i32 : i32 + %44 = arith.select %39, %false, %43 : i1 + %45 = arith.select %44, %c3_i32, %40 : i32 + %46 = arith.addi %6, %45 : i32 + %47 = arith.muli %46, %c5_i32 : i32 + %48 = arith.cmpf olt, %42, %cst_4 : f32 + %49 = arith.negf %42 : f32 + %50 = arith.select %48, %49, %42 : f32 + %51 = arith.cmpf olt, %50, %cst_12 : f32 + %52 = arith.xori %51, %true : i1 + %53 = arith.mulf %50, %cst_11 : f32 + %54 = arith.subf %53, %cst_10 : f32 + %55 = arith.mulf %54, %50 : f32 + %56 = arith.mulf %55, %50 : f32 + %57 = arith.addf %56, %cst_12 : f32 + %58 = arith.select %51, %57, %2 : f32 + %59 = arith.cmpf olt, %50, %cst_9 : f32 + %60 = arith.andi %59, %52 : i1 + %61 = arith.xori %60, %true : i1 + %62 = arith.andi %61, %52 : i1 + %63 = arith.mulf %50, %cst_8 : f32 + %64 = arith.addf %63, %cst_7 : f32 + %65 = arith.mulf %64, %50 : f32 + %66 = arith.subf %65, %cst_6 : f32 + %67 = arith.mulf %66, %50 : f32 + %68 = arith.addf %67, %cst_5 : f32 + %69 = arith.select %60, %68, %58 : f32 + %70 = arith.select %62, %cst_4, %69 : f32 + %71 = affine.for %arg10 = -1 to 3 iter_args(%arg11 = %arg9) -> (tensor) { + %72 = affine.apply #map(%arg6, %arg2, %arg4) + %extracted = tensor.extract %arg11[%72] : tensor + %73 = arith.index_cast %arg10 : index to i32 + %74 = arith.addi %34, %73 : i32 + %75 = arith.cmpi slt, %74, %c0_i32 : i32 + %76 = arith.select %75, %c0_i32, %74 : i32 + %77 = arith.cmpi sge, %74, %c5_i32 : i32 + %78 = arith.select %75, %false, %77 : i1 + %79 = arith.select %78, %c4_i32, %76 : i32 + %80 = arith.addi %47, %79 : i32 + %81 = arith.index_cast %80 : i32 to index + %extracted_13 = tensor.extract %1[%81] : tensor + %82 = arith.mulf %extracted_13, %70 : f32 + %83 = arith.sitofp %74 : i32 to f32 + %84 = arith.subf %27, %83 : f32 + %85 = arith.cmpf olt, %84, %cst_4 : f32 + %86 = arith.negf %84 : f32 + %87 = arith.select %85, %86, %84 : f32 + %88 = arith.cmpf olt, %87, %cst_12 : f32 + %89 = arith.xori %88, %true : i1 + %90 = arith.mulf %87, %cst_11 : f32 + %91 = arith.subf %90, %cst_10 : f32 + %92 = arith.mulf %91, %87 : f32 + %93 = arith.mulf %92, %87 : f32 + %94 = arith.addf %93, %cst_12 : f32 + %95 = arith.select %88, %94, %2 : f32 + %96 = arith.cmpf olt, %87, %cst_9 : f32 + %97 = arith.andi %96, %89 : i1 + %98 = arith.xori %97, %true : i1 + %99 = arith.andi %98, %89 : i1 + %100 = arith.mulf %87, %cst_8 : f32 + %101 = arith.addf %100, %cst_7 : f32 + %102 = arith.mulf %101, %87 : f32 + %103 = arith.subf %102, %cst_6 : f32 + %104 = arith.mulf %103, %87 : f32 + %105 = arith.addf %104, %cst_5 : f32 + %106 = arith.select %97, %105, %95 : f32 + %107 = arith.select %99, %cst_4, %106 : f32 + %108 = arith.mulf %82, %107 : f32 + %109 = arith.addf %extracted, %108 : f32 + %110 = affine.apply #map(%arg6, %arg2, %arg4) + %inserted_14 = tensor.insert %109 into %arg11[%110] : tensor + affine.yield %inserted_14 : tensor + } + affine.yield %71 : tensor + } + affine.yield %36 : tensor + } + affine.yield %21 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu_linalg.mlir new file mode 100644 index 000000000000..d3245cf067da --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bicubic2d_cpu_linalg.mlir @@ -0,0 +1,141 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bicubic2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 1.250000e+00 : f32 + %cst_1 = arith.constant 2.250000e+00 : f32 + %cst_2 = arith.constant 2.000000e+00 : f32 + %cst_3 = arith.constant -7.500000e-01 : f32 + %cst_4 = arith.constant 3.750000e+00 : f32 + %cst_5 = arith.constant 6.000000e+00 : f32 + %cst_6 = arith.constant 3.000000e+00 : f32 + %true = arith.constant true + %c0_i32 = arith.constant 0 : i32 + %false = arith.constant false + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c4_i32 = arith.constant 4 : i32 + %c-1_i32 = arith.constant -1 : i32 + %cst_7 = arith.constant 0.000000e+00 : f32 + %cst_8 = arith.constant 8.000000e+00 : f32 + %cst_9 = arith.constant 5.000000e+00 : f32 + %cst_10 = arith.constant 7.000000e+00 : f32 + %cst_11 = arith.constant 4.000000e+00 : f32 + %cst_12 = arith.constant 5.000000e-01 : f32 + %0 = llvm.mlir.undef : f32 + affine.for %arg2 = 0 to 2 { + %1 = arith.index_cast %arg2 : index to i32 + %2 = arith.muli %1, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %3 = arith.index_cast %arg3 : index to i32 + %4 = arith.sitofp %3 : i32 to f32 + %5 = arith.addf %4, %cst_12 : f32 + %6 = arith.mulf %5, %cst_11 : f32 + %7 = arith.divf %6, %cst_10 : f32 + %8 = arith.subf %7, %cst_12 : f32 + %9 = arith.fptosi %8 : f32 to i32 + %10 = arith.cmpf olt, %8, %cst_7 : f32 + %11 = arith.sitofp %9 : i32 to f32 + %12 = arith.cmpf une, %8, %11 : f32 + %13 = arith.andi %10, %12 : i1 + %14 = arith.addi %9, %c-1_i32 : i32 + %15 = arith.select %13, %14, %9 : i32 + affine.for %arg4 = 0 to 8 { + %16 = arith.index_cast %arg4 : index to i32 + %17 = arith.sitofp %16 : i32 to f32 + %18 = arith.addf %17, %cst_12 : f32 + %19 = arith.mulf %18, %cst_9 : f32 + %20 = arith.divf %19, %cst_8 : f32 + %21 = arith.subf %20, %cst_12 : f32 + %22 = arith.fptosi %21 : f32 to i32 + %23 = arith.cmpf olt, %21, %cst_7 : f32 + %24 = arith.sitofp %22 : i32 to f32 + %25 = arith.cmpf une, %21, %24 : f32 + %26 = arith.andi %23, %25 : i1 + %27 = arith.addi %22, %c-1_i32 : i32 + %28 = arith.select %26, %27, %22 : i32 + affine.store %cst_7, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + affine.for %arg5 = -1 to 3 { + %29 = arith.index_cast %arg5 : index to i32 + %30 = arith.addi %15, %29 : i32 + %31 = arith.cmpi slt, %30, %c0_i32 : i32 + %32 = arith.select %31, %c0_i32, %30 : i32 + %33 = arith.sitofp %30 : i32 to f32 + %34 = arith.subf %8, %33 : f32 + %35 = arith.cmpi sge, %30, %c4_i32 : i32 + %36 = arith.select %31, %false, %35 : i1 + %37 = arith.select %36, %c3_i32, %32 : i32 + %38 = arith.addi %2, %37 : i32 + %39 = arith.muli %38, %c5_i32 : i32 + %40 = arith.cmpf olt, %34, %cst_7 : f32 + %41 = arith.negf %34 : f32 + %42 = arith.select %40, %41, %34 : f32 + %43 = arith.cmpf olt, %42, %cst : f32 + %44 = arith.xori %43, %true : i1 + %45 = arith.mulf %42, %cst_0 : f32 + %46 = arith.subf %45, %cst_1 : f32 + %47 = arith.mulf %46, %42 : f32 + %48 = arith.mulf %47, %42 : f32 + %49 = arith.addf %48, %cst : f32 + %50 = arith.select %43, %49, %0 : f32 + %51 = arith.cmpf olt, %42, %cst_2 : f32 + %52 = arith.andi %51, %44 : i1 + %53 = arith.xori %52, %true : i1 + %54 = arith.andi %53, %44 : i1 + %55 = arith.mulf %42, %cst_3 : f32 + %56 = arith.addf %55, %cst_4 : f32 + %57 = arith.mulf %56, %42 : f32 + %58 = arith.subf %57, %cst_5 : f32 + %59 = arith.mulf %58, %42 : f32 + %60 = arith.addf %59, %cst_6 : f32 + %61 = arith.select %52, %60, %50 : f32 + %62 = arith.select %54, %cst_7, %61 : f32 + affine.for %arg6 = -1 to 3 { + %63 = affine.load %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %64 = arith.index_cast %arg6 : index to i32 + %65 = arith.addi %28, %64 : i32 + %66 = arith.cmpi slt, %65, %c0_i32 : i32 + %67 = arith.select %66, %c0_i32, %65 : i32 + %68 = arith.cmpi sge, %65, %c5_i32 : i32 + %69 = arith.select %66, %false, %68 : i1 + %70 = arith.select %69, %c4_i32, %67 : i32 + %71 = arith.addi %39, %70 : i32 + %72 = arith.index_cast %71 : i32 to index + %73 = memref.load %arg0[%72] : memref + %74 = arith.mulf %73, %62 : f32 + %75 = arith.sitofp %65 : i32 to f32 + %76 = arith.subf %21, %75 : f32 + %77 = arith.cmpf olt, %76, %cst_7 : f32 + %78 = arith.negf %76 : f32 + %79 = arith.select %77, %78, %76 : f32 + %80 = arith.cmpf olt, %79, %cst : f32 + %81 = arith.xori %80, %true : i1 + %82 = arith.mulf %79, %cst_0 : f32 + %83 = arith.subf %82, %cst_1 : f32 + %84 = arith.mulf %83, %79 : f32 + %85 = arith.mulf %84, %79 : f32 + %86 = arith.addf %85, %cst : f32 + %87 = arith.select %80, %86, %0 : f32 + %88 = arith.cmpf olt, %79, %cst_2 : f32 + %89 = arith.andi %88, %81 : i1 + %90 = arith.xori %89, %true : i1 + %91 = arith.andi %90, %81 : i1 + %92 = arith.mulf %79, %cst_3 : f32 + %93 = arith.addf %92, %cst_4 : f32 + %94 = arith.mulf %93, %79 : f32 + %95 = arith.subf %94, %cst_5 : f32 + %96 = arith.mulf %95, %79 : f32 + %97 = arith.addf %96, %cst_6 : f32 + %98 = arith.select %89, %97, %87 : f32 + %99 = arith.select %91, %cst_7, %98 : f32 + %100 = arith.mulf %74, %99 : f32 + %101 = arith.addf %63, %100 : f32 + affine.store %101, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d.mlir new file mode 100644 index 000000000000..f47997108df7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d.mlir @@ -0,0 +1,69 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 8 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = arith.remsi %0, %c2_i32 : i32 + %2 = arith.sitofp %1 : i32 to f32 + %3 = arith.mulf %2, %cst_0 : f32 + %4 = arith.subf %cst, %3 : f32 + %5 = arith.divsi %0, %c2_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + %7 = arith.addi %5, %c1_i32 : i32 + %8 = arith.cmpi slt, %7, %c4_i32 : i32 + %9 = arith.select %8, %7, %5 : i32 + %10 = arith.index_cast %9 : i32 to index + %11 = arith.cmpi slt, %arg4, %c0 : index + %12 = arith.subi %c-1, %arg4 : index + %13 = arith.select %11, %12, %arg4 : index + %14 = arith.divsi %13, %c2 : index + %15 = arith.subi %c-1, %14 : index + %16 = arith.select %11, %15, %14 : index + affine.for %arg5 = 0 to 8 { + %17 = arith.index_cast %arg5 : index to i32 + %18 = arith.remsi %17, %c2_i32 : i32 + %19 = arith.sitofp %18 : i32 to f32 + %20 = arith.mulf %19, %cst_0 : f32 + %21 = arith.subf %cst, %20 : f32 + %22 = arith.divsi %17, %c2_i32 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = arith.cmpi slt, %arg5, %c0 : index + %25 = arith.subi %c-1, %arg5 : index + %26 = arith.select %24, %25, %arg5 : index + %27 = arith.divsi %26, %c2 : index + %28 = arith.subi %c-1, %27 : index + %29 = arith.select %24, %28, %27 : index + %30 = memref.load %arg0[%arg2, %arg3, %16, %29] : memref + %31 = arith.mulf %21, %30 : f32 + %32 = arith.addi %22, %c1_i32 : i32 + %33 = arith.cmpi slt, %32, %c4_i32 : i32 + %34 = arith.select %33, %32, %22 : i32 + %35 = arith.index_cast %34 : i32 to index + %36 = memref.load %arg0[%arg2, %arg3, %6, %35] : memref + %37 = arith.mulf %20, %36 : f32 + %38 = arith.addf %31, %37 : f32 + %39 = arith.mulf %4, %38 : f32 + %40 = memref.load %arg0[%arg2, %arg3, %10, %23] : memref + %41 = arith.mulf %21, %40 : f32 + %42 = memref.load %arg0[%arg2, %arg3, %10, %35] : memref + %43 = arith.mulf %20, %42 : f32 + %44 = arith.addf %41, %43 : f32 + %45 = arith.mulf %3, %44 : f32 + %46 = arith.addf %39, %45 : f32 + affine.store %46, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d/debuf.mlir new file mode 100644 index 000000000000..9c07ce3790ae --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d/debuf.mlir @@ -0,0 +1,77 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %c-1 = arith.constant -1 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0] [%c2, %c3, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = linalg.index 2 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.remsi %6, %c2_i32 : i32 + %8 = arith.sitofp %7 : i32 to f32 + %9 = arith.mulf %8, %cst : f32 + %10 = arith.subf %cst_0, %9 : f32 + %11 = arith.divsi %6, %c2_i32 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = arith.addi %11, %c1_i32 : i32 + %14 = arith.cmpi slt, %13, %c4_i32 : i32 + %15 = arith.select %14, %13, %11 : i32 + %16 = arith.index_cast %15 : i32 to index + %17 = arith.cmpi slt, %5, %c0 : index + %18 = arith.subi %c-1, %5 : index + %19 = arith.select %17, %18, %5 : index + %20 = arith.divsi %19, %c2 : index + %21 = arith.subi %c-1, %20 : index + %22 = arith.select %17, %21, %20 : index + %23 = linalg.index 3 : index + %24 = arith.index_cast %23 : index to i32 + %25 = arith.remsi %24, %c2_i32 : i32 + %26 = arith.sitofp %25 : i32 to f32 + %27 = arith.mulf %26, %cst : f32 + %28 = arith.subf %cst_0, %27 : f32 + %29 = arith.divsi %24, %c2_i32 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = arith.cmpi slt, %23, %c0 : index + %32 = arith.subi %c-1, %23 : index + %33 = arith.select %31, %32, %23 : index + %34 = arith.divsi %33, %c2 : index + %35 = arith.subi %c-1, %34 : index + %36 = arith.select %31, %35, %34 : index + %37 = memref.load %arg0[%3, %4, %22, %36] : memref + %38 = arith.mulf %28, %37 : f32 + %39 = arith.addi %29, %c1_i32 : i32 + %40 = arith.cmpi slt, %39, %c4_i32 : i32 + %41 = arith.select %40, %39, %29 : i32 + %42 = arith.index_cast %41 : i32 to index + %43 = memref.load %arg0[%3, %4, %12, %42] : memref + %44 = arith.mulf %27, %43 : f32 + %45 = arith.addf %38, %44 : f32 + %46 = arith.mulf %10, %45 : f32 + %47 = memref.load %arg0[%3, %4, %16, %30] : memref + %48 = arith.mulf %28, %47 : f32 + %49 = memref.load %arg0[%3, %4, %16, %42] : memref + %50 = arith.mulf %27, %49 : f32 + %51 = arith.addf %48, %50 : f32 + %52 = arith.mulf %9, %51 : f32 + %53 = arith.addf %46, %52 : f32 + linalg.yield %53 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0, 0, 0] [%c2, %c3, %c8, %c8] [1, 1, 1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d/matched.mlir new file mode 100644 index 000000000000..9c07ce3790ae --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d/matched.mlir @@ -0,0 +1,77 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %c-1 = arith.constant -1 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0] [%c2, %c3, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = linalg.index 2 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.remsi %6, %c2_i32 : i32 + %8 = arith.sitofp %7 : i32 to f32 + %9 = arith.mulf %8, %cst : f32 + %10 = arith.subf %cst_0, %9 : f32 + %11 = arith.divsi %6, %c2_i32 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = arith.addi %11, %c1_i32 : i32 + %14 = arith.cmpi slt, %13, %c4_i32 : i32 + %15 = arith.select %14, %13, %11 : i32 + %16 = arith.index_cast %15 : i32 to index + %17 = arith.cmpi slt, %5, %c0 : index + %18 = arith.subi %c-1, %5 : index + %19 = arith.select %17, %18, %5 : index + %20 = arith.divsi %19, %c2 : index + %21 = arith.subi %c-1, %20 : index + %22 = arith.select %17, %21, %20 : index + %23 = linalg.index 3 : index + %24 = arith.index_cast %23 : index to i32 + %25 = arith.remsi %24, %c2_i32 : i32 + %26 = arith.sitofp %25 : i32 to f32 + %27 = arith.mulf %26, %cst : f32 + %28 = arith.subf %cst_0, %27 : f32 + %29 = arith.divsi %24, %c2_i32 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = arith.cmpi slt, %23, %c0 : index + %32 = arith.subi %c-1, %23 : index + %33 = arith.select %31, %32, %23 : index + %34 = arith.divsi %33, %c2 : index + %35 = arith.subi %c-1, %34 : index + %36 = arith.select %31, %35, %34 : index + %37 = memref.load %arg0[%3, %4, %22, %36] : memref + %38 = arith.mulf %28, %37 : f32 + %39 = arith.addi %29, %c1_i32 : i32 + %40 = arith.cmpi slt, %39, %c4_i32 : i32 + %41 = arith.select %40, %39, %29 : i32 + %42 = arith.index_cast %41 : i32 to index + %43 = memref.load %arg0[%3, %4, %12, %42] : memref + %44 = arith.mulf %27, %43 : f32 + %45 = arith.addf %38, %44 : f32 + %46 = arith.mulf %10, %45 : f32 + %47 = memref.load %arg0[%3, %4, %16, %30] : memref + %48 = arith.mulf %28, %47 : f32 + %49 = memref.load %arg0[%3, %4, %16, %42] : memref + %50 = arith.mulf %27, %49 : f32 + %51 = arith.addf %48, %50 : f32 + %52 = arith.mulf %9, %51 : f32 + %53 = arith.addf %46, %52 : f32 + linalg.yield %53 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0, 0, 0] [%c2, %c3, %c8, %c8] [1, 1, 1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d/orig.mlir new file mode 100644 index 000000000000..f47997108df7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d/orig.mlir @@ -0,0 +1,69 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 3 { + affine.for %arg4 = 0 to 8 { + %0 = arith.index_cast %arg4 : index to i32 + %1 = arith.remsi %0, %c2_i32 : i32 + %2 = arith.sitofp %1 : i32 to f32 + %3 = arith.mulf %2, %cst_0 : f32 + %4 = arith.subf %cst, %3 : f32 + %5 = arith.divsi %0, %c2_i32 : i32 + %6 = arith.index_cast %5 : i32 to index + %7 = arith.addi %5, %c1_i32 : i32 + %8 = arith.cmpi slt, %7, %c4_i32 : i32 + %9 = arith.select %8, %7, %5 : i32 + %10 = arith.index_cast %9 : i32 to index + %11 = arith.cmpi slt, %arg4, %c0 : index + %12 = arith.subi %c-1, %arg4 : index + %13 = arith.select %11, %12, %arg4 : index + %14 = arith.divsi %13, %c2 : index + %15 = arith.subi %c-1, %14 : index + %16 = arith.select %11, %15, %14 : index + affine.for %arg5 = 0 to 8 { + %17 = arith.index_cast %arg5 : index to i32 + %18 = arith.remsi %17, %c2_i32 : i32 + %19 = arith.sitofp %18 : i32 to f32 + %20 = arith.mulf %19, %cst_0 : f32 + %21 = arith.subf %cst, %20 : f32 + %22 = arith.divsi %17, %c2_i32 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = arith.cmpi slt, %arg5, %c0 : index + %25 = arith.subi %c-1, %arg5 : index + %26 = arith.select %24, %25, %arg5 : index + %27 = arith.divsi %26, %c2 : index + %28 = arith.subi %c-1, %27 : index + %29 = arith.select %24, %28, %27 : index + %30 = memref.load %arg0[%arg2, %arg3, %16, %29] : memref + %31 = arith.mulf %21, %30 : f32 + %32 = arith.addi %22, %c1_i32 : i32 + %33 = arith.cmpi slt, %32, %c4_i32 : i32 + %34 = arith.select %33, %32, %22 : i32 + %35 = arith.index_cast %34 : i32 to index + %36 = memref.load %arg0[%arg2, %arg3, %6, %35] : memref + %37 = arith.mulf %20, %36 : f32 + %38 = arith.addf %31, %37 : f32 + %39 = arith.mulf %4, %38 : f32 + %40 = memref.load %arg0[%arg2, %arg3, %10, %23] : memref + %41 = arith.mulf %21, %40 : f32 + %42 = memref.load %arg0[%arg2, %arg3, %10, %35] : memref + %43 = arith.mulf %20, %42 : f32 + %44 = arith.addf %41, %43 : f32 + %45 = arith.mulf %3, %44 : f32 + %46 = arith.addf %39, %45 : f32 + affine.store %46, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d/raised.mlir new file mode 100644 index 000000000000..7a5a145fba42 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d/raised.mlir @@ -0,0 +1,73 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %subview = memref.subview %arg1[0, 0, 0, 0] [%c2, %c3, %c8, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = linalg.index 2 : index + %3 = arith.index_cast %2 : index to i32 + %4 = arith.remsi %3, %c2_i32 : i32 + %5 = arith.sitofp %4 : i32 to f32 + %6 = arith.mulf %5, %cst_0 : f32 + %7 = arith.subf %cst, %6 : f32 + %8 = arith.divsi %3, %c2_i32 : i32 + %9 = arith.index_cast %8 : i32 to index + %10 = arith.addi %8, %c1_i32 : i32 + %11 = arith.cmpi slt, %10, %c4_i32 : i32 + %12 = arith.select %11, %10, %8 : i32 + %13 = arith.index_cast %12 : i32 to index + %14 = arith.cmpi slt, %2, %c0 : index + %15 = arith.subi %c-1, %2 : index + %16 = arith.select %14, %15, %2 : index + %17 = arith.divsi %16, %c2 : index + %18 = arith.subi %c-1, %17 : index + %19 = arith.select %14, %18, %17 : index + %20 = linalg.index 3 : index + %21 = arith.index_cast %20 : index to i32 + %22 = arith.remsi %21, %c2_i32 : i32 + %23 = arith.sitofp %22 : i32 to f32 + %24 = arith.mulf %23, %cst_0 : f32 + %25 = arith.subf %cst, %24 : f32 + %26 = arith.divsi %21, %c2_i32 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = arith.cmpi slt, %20, %c0 : index + %29 = arith.subi %c-1, %20 : index + %30 = arith.select %28, %29, %20 : index + %31 = arith.divsi %30, %c2 : index + %32 = arith.subi %c-1, %31 : index + %33 = arith.select %28, %32, %31 : index + %34 = memref.load %arg0[%0, %1, %19, %33] : memref + %35 = arith.mulf %25, %34 : f32 + %36 = arith.addi %26, %c1_i32 : i32 + %37 = arith.cmpi slt, %36, %c4_i32 : i32 + %38 = arith.select %37, %36, %26 : i32 + %39 = arith.index_cast %38 : i32 to index + %40 = memref.load %arg0[%0, %1, %9, %39] : memref + %41 = arith.mulf %24, %40 : f32 + %42 = arith.addf %35, %41 : f32 + %43 = arith.mulf %7, %42 : f32 + %44 = memref.load %arg0[%0, %1, %13, %27] : memref + %45 = arith.mulf %25, %44 : f32 + %46 = memref.load %arg0[%0, %1, %13, %39] : memref + %47 = arith.mulf %24, %46 : f32 + %48 = arith.addf %45, %47 : f32 + %49 = arith.mulf %6, %48 : f32 + %50 = arith.addf %43, %49 : f32 + linalg.yield %50 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu.mlir new file mode 100644 index 000000000000..db79e24643c2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu.mlir @@ -0,0 +1,116 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %cst_3 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 40 { + affine.store %cst_3, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_1 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_1 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_1 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_1 : f32 + %10 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_3) -> (f32) { + %11 = arith.index_cast %arg5 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.subf %4, %12 : f32 + %14 = arith.cmpf olt, %13, %cst_3 : f32 + %15 = scf.if %14 -> (f32) { + %19 = arith.negf %13 : f32 + scf.yield %19 : f32 + } else { + scf.yield %13 : f32 + } + %16 = arith.cmpf olt, %15, %cst_2 : f32 + %17 = scf.if %16 -> (f32) { + %19 = arith.subf %cst_2, %15 : f32 + scf.yield %19 : f32 + } else { + scf.yield %cst_3 : f32 + } + %18 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %19 = arith.index_cast %arg7 : index to i32 + %20 = arith.sitofp %19 : i32 to f32 + %21 = arith.subf %9, %20 : f32 + %22 = arith.cmpf olt, %21, %cst_3 : f32 + %23 = scf.if %22 -> (f32) { + %28 = arith.negf %21 : f32 + scf.yield %28 : f32 + } else { + scf.yield %21 : f32 + } + %24 = arith.cmpf olt, %23, %cst_2 : f32 + %25 = scf.if %24 -> (f32) { + %28 = arith.subf %cst_2, %23 : f32 + scf.yield %28 : f32 + } else { + scf.yield %cst_3 : f32 + } + %26 = arith.mulf %17, %25 : f32 + %27 = arith.addf %arg8, %26 : f32 + affine.yield %27 : f32 + } + affine.yield %18 : f32 + } + affine.for %arg5 = 0 to 4 { + %11 = arith.index_cast %arg5 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.subf %4, %12 : f32 + %14 = arith.cmpf olt, %13, %cst_3 : f32 + %15 = scf.if %14 -> (f32) { + %18 = arith.negf %13 : f32 + scf.yield %18 : f32 + } else { + scf.yield %13 : f32 + } + %16 = arith.cmpf olt, %15, %cst_2 : f32 + %17 = scf.if %16 -> (f32) { + %18 = arith.subf %cst_2, %15 : f32 + scf.yield %18 : f32 + } else { + scf.yield %cst_3 : f32 + } + affine.for %arg6 = 0 to 5 { + %18 = arith.index_cast %arg6 : index to i32 + %19 = arith.sitofp %18 : i32 to f32 + %20 = arith.subf %9, %19 : f32 + %21 = arith.cmpf olt, %20, %cst_3 : f32 + %22 = scf.if %21 -> (f32) { + %31 = arith.negf %20 : f32 + scf.yield %31 : f32 + } else { + scf.yield %20 : f32 + } + %23 = arith.cmpf olt, %22, %cst_2 : f32 + %24 = scf.if %23 -> (f32) { + %31 = arith.subf %cst_2, %22 : f32 + scf.yield %31 : f32 + } else { + scf.yield %cst_3 : f32 + } + %25 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %26 = arith.mulf %25, %17 : f32 + %27 = arith.mulf %26, %24 : f32 + %28 = arith.divf %27, %10 : f32 + %29 = affine.load %arg1[%arg6 + %arg2 * 20 + %arg5 * 5] : memref + %30 = arith.addf %29, %28 : f32 + affine.store %30, %arg1[%arg6 + %arg2 * 20 + %arg5 * 5] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..85f68c24fffd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu/debuf.mlir @@ -0,0 +1,108 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map4 = affine_map<(d0, d1)[s0, s1, s2] -> (s0 + s1 * 56 + s2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 6.250000e-01 : f32 + %cst_3 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %6 = arith.index_cast %arg4 : index to i32 + %7 = arith.sitofp %6 : i32 to f32 + %8 = arith.addf %7, %cst_1 : f32 + %9 = arith.mulf %8, %cst_3 : f32 + %10 = arith.subf %9, %cst_1 : f32 + %11 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %12 = arith.index_cast %arg6 : index to i32 + %13 = arith.sitofp %12 : i32 to f32 + %14 = arith.addf %13, %cst_1 : f32 + %15 = arith.mulf %14, %cst_2 : f32 + %16 = arith.subf %15, %cst_1 : f32 + %alloca = memref.alloca() : memref + %17 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %17[] : tensor + %18 = polygeist.submap(%inserted, %c4, %c5) {map = #map1} : (tensor, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%18 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_0 : f32 + %33 = arith.subf %cst_0, %31 : f32 + %34 = arith.select %32, %33, %cst : f32 + %35 = linalg.index 1 : index + %36 = arith.index_cast %35 : index to i32 + %37 = arith.sitofp %36 : i32 to f32 + %38 = arith.subf %16, %37 : f32 + %39 = arith.cmpf olt, %38, %cst : f32 + %40 = arith.negf %38 : f32 + %41 = arith.select %39, %40, %38 : f32 + %42 = arith.cmpf olt, %41, %cst_0 : f32 + %43 = arith.subf %cst_0, %41 : f32 + %44 = arith.select %42, %43, %cst : f32 + %45 = arith.mulf %34, %44 : f32 + %46 = arith.addf %out, %45 : f32 + linalg.yield %46 : f32 + } -> tensor + %20 = polygeist.submapInverse(%inserted, %19, %c4, %c5) {map = #map1} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %20[] : tensor + %21 = polygeist.submap(%arg7, %arg2, %c4, %c5) {map = #map3} : (tensor, index, index, index) -> tensor + %22 = polygeist.submap(%0, %arg6, %arg2, %arg4, %c4, %c5) {map = #map4} : (tensor, index, index, index, index, index) -> tensor + %23 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%22 : tensor) outs(%21 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_0 : f32 + %33 = arith.subf %cst_0, %31 : f32 + %34 = arith.select %32, %33, %cst : f32 + %35 = linalg.index 1 : index + %36 = arith.index_cast %35 : index to i32 + %37 = arith.sitofp %36 : i32 to f32 + %38 = arith.subf %16, %37 : f32 + %39 = arith.cmpf olt, %38, %cst : f32 + %40 = arith.negf %38 : f32 + %41 = arith.select %39, %40, %38 : f32 + %42 = arith.cmpf olt, %41, %cst_0 : f32 + %43 = arith.subf %cst_0, %41 : f32 + %44 = arith.select %42, %43, %cst : f32 + %45 = arith.mulf %in, %34 : f32 + %46 = arith.mulf %45, %44 : f32 + %47 = arith.divf %46, %extracted : f32 + %48 = arith.addf %out, %47 : f32 + linalg.yield %48 : f32 + } -> tensor + %24 = polygeist.submapInverse(%arg7, %23, %arg2, %c4, %c5) {map = #map3} : (tensor, tensor, index, index, index) -> tensor + affine.yield %24 : tensor + } + affine.yield %11 : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu/matched.mlir new file mode 100644 index 000000000000..e13771d01a1c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu/matched.mlir @@ -0,0 +1,105 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map4 = affine_map<(d0, d1)[s0, s1, s2] -> (s0 + s1 * 56 + s2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 6.250000e-01 : f32 + %cst_3 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = kernel.launch @memset_zero_1D_f32(%1) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %6 = arith.index_cast %arg4 : index to i32 + %7 = arith.sitofp %6 : i32 to f32 + %8 = arith.addf %7, %cst_1 : f32 + %9 = arith.mulf %8, %cst_3 : f32 + %10 = arith.subf %9, %cst_1 : f32 + %11 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %12 = arith.index_cast %arg6 : index to i32 + %13 = arith.sitofp %12 : i32 to f32 + %14 = arith.addf %13, %cst_1 : f32 + %15 = arith.mulf %14, %cst_2 : f32 + %16 = arith.subf %15, %cst_1 : f32 + %alloca = memref.alloca() : memref + %17 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %17[] : tensor + %18 = polygeist.submap(%inserted, %c4, %c5) {map = #map1} : (tensor, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%18 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_0 : f32 + %33 = arith.subf %cst_0, %31 : f32 + %34 = arith.select %32, %33, %cst : f32 + %35 = linalg.index 1 : index + %36 = arith.index_cast %35 : index to i32 + %37 = arith.sitofp %36 : i32 to f32 + %38 = arith.subf %16, %37 : f32 + %39 = arith.cmpf olt, %38, %cst : f32 + %40 = arith.negf %38 : f32 + %41 = arith.select %39, %40, %38 : f32 + %42 = arith.cmpf olt, %41, %cst_0 : f32 + %43 = arith.subf %cst_0, %41 : f32 + %44 = arith.select %42, %43, %cst : f32 + %45 = arith.mulf %34, %44 : f32 + %46 = arith.addf %out, %45 : f32 + linalg.yield %46 : f32 + } -> tensor + %20 = polygeist.submapInverse(%inserted, %19, %c4, %c5) {map = #map1} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %20[] : tensor + %21 = polygeist.submap(%arg7, %arg2, %c4, %c5) {map = #map3} : (tensor, index, index, index) -> tensor + %22 = polygeist.submap(%0, %arg6, %arg2, %arg4, %c4, %c5) {map = #map4} : (tensor, index, index, index, index, index) -> tensor + %23 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%22 : tensor) outs(%21 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_0 : f32 + %33 = arith.subf %cst_0, %31 : f32 + %34 = arith.select %32, %33, %cst : f32 + %35 = linalg.index 1 : index + %36 = arith.index_cast %35 : index to i32 + %37 = arith.sitofp %36 : i32 to f32 + %38 = arith.subf %16, %37 : f32 + %39 = arith.cmpf olt, %38, %cst : f32 + %40 = arith.negf %38 : f32 + %41 = arith.select %39, %40, %38 : f32 + %42 = arith.cmpf olt, %41, %cst_0 : f32 + %43 = arith.subf %cst_0, %41 : f32 + %44 = arith.select %42, %43, %cst : f32 + %45 = arith.mulf %in, %34 : f32 + %46 = arith.mulf %45, %44 : f32 + %47 = arith.divf %46, %extracted : f32 + %48 = arith.addf %out, %47 : f32 + linalg.yield %48 : f32 + } -> tensor + %24 = polygeist.submapInverse(%arg7, %23, %arg2, %c4, %c5) {map = #map3} : (tensor, tensor, index, index, index) -> tensor + affine.yield %24 : tensor + } + affine.yield %11 : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu/orig.mlir new file mode 100644 index 000000000000..db79e24643c2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu/orig.mlir @@ -0,0 +1,116 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %cst_3 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 40 { + affine.store %cst_3, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_1 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_1 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_1 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_1 : f32 + %10 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_3) -> (f32) { + %11 = arith.index_cast %arg5 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.subf %4, %12 : f32 + %14 = arith.cmpf olt, %13, %cst_3 : f32 + %15 = scf.if %14 -> (f32) { + %19 = arith.negf %13 : f32 + scf.yield %19 : f32 + } else { + scf.yield %13 : f32 + } + %16 = arith.cmpf olt, %15, %cst_2 : f32 + %17 = scf.if %16 -> (f32) { + %19 = arith.subf %cst_2, %15 : f32 + scf.yield %19 : f32 + } else { + scf.yield %cst_3 : f32 + } + %18 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %19 = arith.index_cast %arg7 : index to i32 + %20 = arith.sitofp %19 : i32 to f32 + %21 = arith.subf %9, %20 : f32 + %22 = arith.cmpf olt, %21, %cst_3 : f32 + %23 = scf.if %22 -> (f32) { + %28 = arith.negf %21 : f32 + scf.yield %28 : f32 + } else { + scf.yield %21 : f32 + } + %24 = arith.cmpf olt, %23, %cst_2 : f32 + %25 = scf.if %24 -> (f32) { + %28 = arith.subf %cst_2, %23 : f32 + scf.yield %28 : f32 + } else { + scf.yield %cst_3 : f32 + } + %26 = arith.mulf %17, %25 : f32 + %27 = arith.addf %arg8, %26 : f32 + affine.yield %27 : f32 + } + affine.yield %18 : f32 + } + affine.for %arg5 = 0 to 4 { + %11 = arith.index_cast %arg5 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.subf %4, %12 : f32 + %14 = arith.cmpf olt, %13, %cst_3 : f32 + %15 = scf.if %14 -> (f32) { + %18 = arith.negf %13 : f32 + scf.yield %18 : f32 + } else { + scf.yield %13 : f32 + } + %16 = arith.cmpf olt, %15, %cst_2 : f32 + %17 = scf.if %16 -> (f32) { + %18 = arith.subf %cst_2, %15 : f32 + scf.yield %18 : f32 + } else { + scf.yield %cst_3 : f32 + } + affine.for %arg6 = 0 to 5 { + %18 = arith.index_cast %arg6 : index to i32 + %19 = arith.sitofp %18 : i32 to f32 + %20 = arith.subf %9, %19 : f32 + %21 = arith.cmpf olt, %20, %cst_3 : f32 + %22 = scf.if %21 -> (f32) { + %31 = arith.negf %20 : f32 + scf.yield %31 : f32 + } else { + scf.yield %20 : f32 + } + %23 = arith.cmpf olt, %22, %cst_2 : f32 + %24 = scf.if %23 -> (f32) { + %31 = arith.subf %cst_2, %22 : f32 + scf.yield %31 : f32 + } else { + scf.yield %cst_3 : f32 + } + %25 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %26 = arith.mulf %25, %17 : f32 + %27 = arith.mulf %26, %24 : f32 + %28 = arith.divf %27, %10 : f32 + %29 = affine.load %arg1[%arg6 + %arg2 * 20 + %arg5 * 5] : memref + %30 = arith.addf %29, %28 : f32 + affine.store %30, %arg1[%arg6 + %arg2 * 20 + %arg5 * 5] : memref + } + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu/raised.mlir new file mode 100644 index 000000000000..b6d005a27e9f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu/raised.mlir @@ -0,0 +1,98 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1)[s0, s1, s2] -> (s0 + s1 * 56 + s2 * 8)> +#map4 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %cst_3 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_3 : f32 + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_1 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_1 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_1 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_1 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_3, %alloca[] : memref + %10 = polygeist.submap(%alloca, %c4, %c5) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map2], iterator_types = ["reduction", "reduction"]} outs(%10 : memref) { + ^bb0(%out: f32): + %14 = linalg.index 0 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.sitofp %15 : i32 to f32 + %17 = arith.subf %4, %16 : f32 + %18 = arith.cmpf olt, %17, %cst_3 : f32 + %19 = arith.negf %17 : f32 + %20 = arith.select %18, %19, %17 : f32 + %21 = arith.cmpf olt, %20, %cst_2 : f32 + %22 = arith.subf %cst_2, %20 : f32 + %23 = arith.select %21, %22, %cst_3 : f32 + %24 = linalg.index 1 : index + %25 = arith.index_cast %24 : index to i32 + %26 = arith.sitofp %25 : i32 to f32 + %27 = arith.subf %9, %26 : f32 + %28 = arith.cmpf olt, %27, %cst_3 : f32 + %29 = arith.negf %27 : f32 + %30 = arith.select %28, %29, %27 : f32 + %31 = arith.cmpf olt, %30, %cst_2 : f32 + %32 = arith.subf %cst_2, %30 : f32 + %33 = arith.select %31, %32, %cst_3 : f32 + %34 = arith.mulf %23, %33 : f32 + %35 = arith.addf %out, %34 : f32 + linalg.yield %35 : f32 + } + %11 = affine.load %alloca[] : memref + %12 = polygeist.submap(%arg0, %arg4, %arg2, %arg3, %c4, %c5) {map = #map3} : (memref, index, index, index, index, index) -> memref + %13 = polygeist.submap(%arg1, %arg2, %c4, %c5) {map = #map4} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%12 : memref) outs(%13 : memref) { + ^bb0(%in: f32, %out: f32): + %14 = linalg.index 0 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.sitofp %15 : i32 to f32 + %17 = arith.subf %4, %16 : f32 + %18 = arith.cmpf olt, %17, %cst_3 : f32 + %19 = arith.negf %17 : f32 + %20 = arith.select %18, %19, %17 : f32 + %21 = arith.cmpf olt, %20, %cst_2 : f32 + %22 = arith.subf %cst_2, %20 : f32 + %23 = arith.select %21, %22, %cst_3 : f32 + %24 = linalg.index 1 : index + %25 = arith.index_cast %24 : index to i32 + %26 = arith.sitofp %25 : i32 to f32 + %27 = arith.subf %9, %26 : f32 + %28 = arith.cmpf olt, %27, %cst_3 : f32 + %29 = arith.negf %27 : f32 + %30 = arith.select %28, %29, %27 : f32 + %31 = arith.cmpf olt, %30, %cst_2 : f32 + %32 = arith.subf %cst_2, %30 : f32 + %33 = arith.select %31, %32, %cst_3 : f32 + %34 = arith.mulf %in, %23 : f32 + %35 = arith.mulf %34, %33 : f32 + %36 = arith.divf %35, %11 : f32 + %37 = arith.addf %out, %36 : f32 + linalg.yield %37 : f32 + } + } + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..85f68c24fffd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu_debuf.mlir @@ -0,0 +1,108 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map4 = affine_map<(d0, d1)[s0, s1, s2] -> (s0 + s1 * 56 + s2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 6.250000e-01 : f32 + %cst_3 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %6 = arith.index_cast %arg4 : index to i32 + %7 = arith.sitofp %6 : i32 to f32 + %8 = arith.addf %7, %cst_1 : f32 + %9 = arith.mulf %8, %cst_3 : f32 + %10 = arith.subf %9, %cst_1 : f32 + %11 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %12 = arith.index_cast %arg6 : index to i32 + %13 = arith.sitofp %12 : i32 to f32 + %14 = arith.addf %13, %cst_1 : f32 + %15 = arith.mulf %14, %cst_2 : f32 + %16 = arith.subf %15, %cst_1 : f32 + %alloca = memref.alloca() : memref + %17 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %17[] : tensor + %18 = polygeist.submap(%inserted, %c4, %c5) {map = #map1} : (tensor, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%18 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_0 : f32 + %33 = arith.subf %cst_0, %31 : f32 + %34 = arith.select %32, %33, %cst : f32 + %35 = linalg.index 1 : index + %36 = arith.index_cast %35 : index to i32 + %37 = arith.sitofp %36 : i32 to f32 + %38 = arith.subf %16, %37 : f32 + %39 = arith.cmpf olt, %38, %cst : f32 + %40 = arith.negf %38 : f32 + %41 = arith.select %39, %40, %38 : f32 + %42 = arith.cmpf olt, %41, %cst_0 : f32 + %43 = arith.subf %cst_0, %41 : f32 + %44 = arith.select %42, %43, %cst : f32 + %45 = arith.mulf %34, %44 : f32 + %46 = arith.addf %out, %45 : f32 + linalg.yield %46 : f32 + } -> tensor + %20 = polygeist.submapInverse(%inserted, %19, %c4, %c5) {map = #map1} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %20[] : tensor + %21 = polygeist.submap(%arg7, %arg2, %c4, %c5) {map = #map3} : (tensor, index, index, index) -> tensor + %22 = polygeist.submap(%0, %arg6, %arg2, %arg4, %c4, %c5) {map = #map4} : (tensor, index, index, index, index, index) -> tensor + %23 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%22 : tensor) outs(%21 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_0 : f32 + %33 = arith.subf %cst_0, %31 : f32 + %34 = arith.select %32, %33, %cst : f32 + %35 = linalg.index 1 : index + %36 = arith.index_cast %35 : index to i32 + %37 = arith.sitofp %36 : i32 to f32 + %38 = arith.subf %16, %37 : f32 + %39 = arith.cmpf olt, %38, %cst : f32 + %40 = arith.negf %38 : f32 + %41 = arith.select %39, %40, %38 : f32 + %42 = arith.cmpf olt, %41, %cst_0 : f32 + %43 = arith.subf %cst_0, %41 : f32 + %44 = arith.select %42, %43, %cst : f32 + %45 = arith.mulf %in, %34 : f32 + %46 = arith.mulf %45, %44 : f32 + %47 = arith.divf %46, %extracted : f32 + %48 = arith.addf %out, %47 : f32 + linalg.yield %48 : f32 + } -> tensor + %24 = polygeist.submapInverse(%arg7, %23, %arg2, %c4, %c5) {map = #map3} : (tensor, tensor, index, index, index) -> tensor + affine.yield %24 : tensor + } + affine.yield %11 : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..b6d005a27e9f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_backward_cpu_linalg.mlir @@ -0,0 +1,98 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1)[s0, s1, s2] -> (s0 + s1 * 56 + s2 * 8)> +#map4 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %cst_3 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_3 : f32 + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_1 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_1 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_1 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_1 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_3, %alloca[] : memref + %10 = polygeist.submap(%alloca, %c4, %c5) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map2], iterator_types = ["reduction", "reduction"]} outs(%10 : memref) { + ^bb0(%out: f32): + %14 = linalg.index 0 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.sitofp %15 : i32 to f32 + %17 = arith.subf %4, %16 : f32 + %18 = arith.cmpf olt, %17, %cst_3 : f32 + %19 = arith.negf %17 : f32 + %20 = arith.select %18, %19, %17 : f32 + %21 = arith.cmpf olt, %20, %cst_2 : f32 + %22 = arith.subf %cst_2, %20 : f32 + %23 = arith.select %21, %22, %cst_3 : f32 + %24 = linalg.index 1 : index + %25 = arith.index_cast %24 : index to i32 + %26 = arith.sitofp %25 : i32 to f32 + %27 = arith.subf %9, %26 : f32 + %28 = arith.cmpf olt, %27, %cst_3 : f32 + %29 = arith.negf %27 : f32 + %30 = arith.select %28, %29, %27 : f32 + %31 = arith.cmpf olt, %30, %cst_2 : f32 + %32 = arith.subf %cst_2, %30 : f32 + %33 = arith.select %31, %32, %cst_3 : f32 + %34 = arith.mulf %23, %33 : f32 + %35 = arith.addf %out, %34 : f32 + linalg.yield %35 : f32 + } + %11 = affine.load %alloca[] : memref + %12 = polygeist.submap(%arg0, %arg4, %arg2, %arg3, %c4, %c5) {map = #map3} : (memref, index, index, index, index, index) -> memref + %13 = polygeist.submap(%arg1, %arg2, %c4, %c5) {map = #map4} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%12 : memref) outs(%13 : memref) { + ^bb0(%in: f32, %out: f32): + %14 = linalg.index 0 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.sitofp %15 : i32 to f32 + %17 = arith.subf %4, %16 : f32 + %18 = arith.cmpf olt, %17, %cst_3 : f32 + %19 = arith.negf %17 : f32 + %20 = arith.select %18, %19, %17 : f32 + %21 = arith.cmpf olt, %20, %cst_2 : f32 + %22 = arith.subf %cst_2, %20 : f32 + %23 = arith.select %21, %22, %cst_3 : f32 + %24 = linalg.index 1 : index + %25 = arith.index_cast %24 : index to i32 + %26 = arith.sitofp %25 : i32 to f32 + %27 = arith.subf %9, %26 : f32 + %28 = arith.cmpf olt, %27, %cst_3 : f32 + %29 = arith.negf %27 : f32 + %30 = arith.select %28, %29, %27 : f32 + %31 = arith.cmpf olt, %30, %cst_2 : f32 + %32 = arith.subf %cst_2, %30 : f32 + %33 = arith.select %31, %32, %cst_3 : f32 + %34 = arith.mulf %in, %23 : f32 + %35 = arith.mulf %34, %33 : f32 + %36 = arith.divf %35, %11 : f32 + %37 = arith.addf %out, %36 : f32 + linalg.yield %37 : f32 + } + } + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu.mlir new file mode 100644 index 000000000000..38692e664ba7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu.mlir @@ -0,0 +1,114 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %cst_3 = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_2 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_2 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_2 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_2 : f32 + %10 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_1) -> (f32) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.sitofp %13 : i32 to f32 + %15 = arith.subf %4, %14 : f32 + %16 = arith.cmpf olt, %15, %cst_1 : f32 + %17 = scf.if %16 -> (f32) { + %21 = arith.negf %15 : f32 + scf.yield %21 : f32 + } else { + scf.yield %15 : f32 + } + %18 = arith.cmpf olt, %17, %cst_3 : f32 + %19 = scf.if %18 -> (f32) { + %21 = arith.subf %cst_3, %17 : f32 + scf.yield %21 : f32 + } else { + scf.yield %cst_1 : f32 + } + %20 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %21 = arith.index_cast %arg7 : index to i32 + %22 = arith.sitofp %21 : i32 to f32 + %23 = arith.subf %9, %22 : f32 + %24 = arith.cmpf olt, %23, %cst_1 : f32 + %25 = scf.if %24 -> (f32) { + %30 = arith.negf %23 : f32 + scf.yield %30 : f32 + } else { + scf.yield %23 : f32 + } + %26 = arith.cmpf olt, %25, %cst_3 : f32 + %27 = scf.if %26 -> (f32) { + %30 = arith.subf %cst_3, %25 : f32 + scf.yield %30 : f32 + } else { + scf.yield %cst_1 : f32 + } + %28 = arith.mulf %19, %27 : f32 + %29 = arith.addf %arg8, %28 : f32 + affine.yield %29 : f32 + } + affine.yield %20 : f32 + } + %11 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_1) -> (f32) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.sitofp %13 : i32 to f32 + %15 = arith.subf %4, %14 : f32 + %16 = arith.cmpf olt, %15, %cst_1 : f32 + %17 = scf.if %16 -> (f32) { + %21 = arith.negf %15 : f32 + scf.yield %21 : f32 + } else { + scf.yield %15 : f32 + } + %18 = arith.cmpf olt, %17, %cst_3 : f32 + %19 = scf.if %18 -> (f32) { + %21 = arith.subf %cst_3, %17 : f32 + scf.yield %21 : f32 + } else { + scf.yield %cst_1 : f32 + } + %20 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %21 = arith.index_cast %arg7 : index to i32 + %22 = arith.sitofp %21 : i32 to f32 + %23 = arith.subf %9, %22 : f32 + %24 = arith.cmpf olt, %23, %cst_1 : f32 + %25 = scf.if %24 -> (f32) { + %32 = arith.negf %23 : f32 + scf.yield %32 : f32 + } else { + scf.yield %23 : f32 + } + %26 = arith.cmpf olt, %25, %cst_3 : f32 + %27 = scf.if %26 -> (f32) { + %32 = arith.subf %cst_3, %25 : f32 + scf.yield %32 : f32 + } else { + scf.yield %cst_1 : f32 + } + %28 = affine.load %arg0[%arg7 + %arg2 * 20 + %arg5 * 5] : memref + %29 = arith.mulf %28, %19 : f32 + %30 = arith.mulf %29, %27 : f32 + %31 = arith.addf %arg8, %30 : f32 + affine.yield %31 : f32 + } + affine.yield %20 : f32 + } + %12 = arith.divf %11, %10 : f32 + affine.store %12, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu/debuf.mlir new file mode 100644 index 000000000000..ef9443e8adc3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu/debuf.mlir @@ -0,0 +1,107 @@ +#map = affine_map<(d0, d1) -> ()> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map3 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant 6.250000e-01 : f32 + %cst_3 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %4 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_0 : f32 + %8 = arith.mulf %7, %cst_3 : f32 + %9 = arith.subf %8, %cst_0 : f32 + %10 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %11 = arith.index_cast %arg6 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.addf %12, %cst_0 : f32 + %14 = arith.mulf %13, %cst_2 : f32 + %15 = arith.subf %14, %cst_0 : f32 + %alloca = memref.alloca() : memref + %16 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst_1 into %16[] : tensor + %17 = polygeist.submap(%inserted, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%17 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_1 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst : f32 + %33 = arith.subf %cst, %31 : f32 + %34 = arith.select %32, %33, %cst_1 : f32 + %35 = linalg.index 1 : index + %36 = arith.index_cast %35 : index to i32 + %37 = arith.sitofp %36 : i32 to f32 + %38 = arith.subf %15, %37 : f32 + %39 = arith.cmpf olt, %38, %cst_1 : f32 + %40 = arith.negf %38 : f32 + %41 = arith.select %39, %40, %38 : f32 + %42 = arith.cmpf olt, %41, %cst : f32 + %43 = arith.subf %cst, %41 : f32 + %44 = arith.select %42, %43, %cst_1 : f32 + %45 = arith.mulf %34, %44 : f32 + %46 = arith.addf %out, %45 : f32 + linalg.yield %46 : f32 + } -> tensor + %19 = polygeist.submapInverse(%inserted, %18, %c4, %c5) {map = #map} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %19[] : tensor + %alloca_4 = memref.alloca() : memref + %20 = bufferization.to_tensor %alloca_4 : memref + %inserted_5 = tensor.insert %cst_1 into %20[] : tensor + %21 = polygeist.submap(%1, %arg2, %c4, %c5) {map = #map2} : (tensor, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map1, #map], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%21 : tensor) outs(%inserted_5 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_1 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst : f32 + %33 = arith.subf %cst, %31 : f32 + %34 = arith.select %32, %33, %cst_1 : f32 + %35 = linalg.index 1 : index + %36 = arith.index_cast %35 : index to i32 + %37 = arith.sitofp %36 : i32 to f32 + %38 = arith.subf %15, %37 : f32 + %39 = arith.cmpf olt, %38, %cst_1 : f32 + %40 = arith.negf %38 : f32 + %41 = arith.select %39, %40, %38 : f32 + %42 = arith.cmpf olt, %41, %cst : f32 + %43 = arith.subf %cst, %41 : f32 + %44 = arith.select %42, %43, %cst_1 : f32 + %45 = arith.mulf %in, %34 : f32 + %46 = arith.mulf %45, %44 : f32 + %47 = arith.addf %out, %46 : f32 + linalg.yield %47 : f32 + } -> tensor + %extracted_6 = tensor.extract %22[] : tensor + %23 = arith.divf %extracted_6, %extracted : f32 + %24 = affine.apply #map3(%arg6, %arg2, %arg4) + %inserted_7 = tensor.insert %23 into %arg7[%24] : tensor + affine.yield %inserted_7 : tensor + } + affine.yield %10 : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu/matched.mlir new file mode 100644 index 000000000000..ef9443e8adc3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu/matched.mlir @@ -0,0 +1,107 @@ +#map = affine_map<(d0, d1) -> ()> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map3 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant 6.250000e-01 : f32 + %cst_3 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %4 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_0 : f32 + %8 = arith.mulf %7, %cst_3 : f32 + %9 = arith.subf %8, %cst_0 : f32 + %10 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %11 = arith.index_cast %arg6 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.addf %12, %cst_0 : f32 + %14 = arith.mulf %13, %cst_2 : f32 + %15 = arith.subf %14, %cst_0 : f32 + %alloca = memref.alloca() : memref + %16 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst_1 into %16[] : tensor + %17 = polygeist.submap(%inserted, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%17 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_1 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst : f32 + %33 = arith.subf %cst, %31 : f32 + %34 = arith.select %32, %33, %cst_1 : f32 + %35 = linalg.index 1 : index + %36 = arith.index_cast %35 : index to i32 + %37 = arith.sitofp %36 : i32 to f32 + %38 = arith.subf %15, %37 : f32 + %39 = arith.cmpf olt, %38, %cst_1 : f32 + %40 = arith.negf %38 : f32 + %41 = arith.select %39, %40, %38 : f32 + %42 = arith.cmpf olt, %41, %cst : f32 + %43 = arith.subf %cst, %41 : f32 + %44 = arith.select %42, %43, %cst_1 : f32 + %45 = arith.mulf %34, %44 : f32 + %46 = arith.addf %out, %45 : f32 + linalg.yield %46 : f32 + } -> tensor + %19 = polygeist.submapInverse(%inserted, %18, %c4, %c5) {map = #map} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %19[] : tensor + %alloca_4 = memref.alloca() : memref + %20 = bufferization.to_tensor %alloca_4 : memref + %inserted_5 = tensor.insert %cst_1 into %20[] : tensor + %21 = polygeist.submap(%1, %arg2, %c4, %c5) {map = #map2} : (tensor, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map1, #map], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%21 : tensor) outs(%inserted_5 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_1 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst : f32 + %33 = arith.subf %cst, %31 : f32 + %34 = arith.select %32, %33, %cst_1 : f32 + %35 = linalg.index 1 : index + %36 = arith.index_cast %35 : index to i32 + %37 = arith.sitofp %36 : i32 to f32 + %38 = arith.subf %15, %37 : f32 + %39 = arith.cmpf olt, %38, %cst_1 : f32 + %40 = arith.negf %38 : f32 + %41 = arith.select %39, %40, %38 : f32 + %42 = arith.cmpf olt, %41, %cst : f32 + %43 = arith.subf %cst, %41 : f32 + %44 = arith.select %42, %43, %cst_1 : f32 + %45 = arith.mulf %in, %34 : f32 + %46 = arith.mulf %45, %44 : f32 + %47 = arith.addf %out, %46 : f32 + linalg.yield %47 : f32 + } -> tensor + %extracted_6 = tensor.extract %22[] : tensor + %23 = arith.divf %extracted_6, %extracted : f32 + %24 = affine.apply #map3(%arg6, %arg2, %arg4) + %inserted_7 = tensor.insert %23 into %arg7[%24] : tensor + affine.yield %inserted_7 : tensor + } + affine.yield %10 : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu/orig.mlir new file mode 100644 index 000000000000..38692e664ba7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu/orig.mlir @@ -0,0 +1,114 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %cst_3 = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_2 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_2 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_2 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_2 : f32 + %10 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_1) -> (f32) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.sitofp %13 : i32 to f32 + %15 = arith.subf %4, %14 : f32 + %16 = arith.cmpf olt, %15, %cst_1 : f32 + %17 = scf.if %16 -> (f32) { + %21 = arith.negf %15 : f32 + scf.yield %21 : f32 + } else { + scf.yield %15 : f32 + } + %18 = arith.cmpf olt, %17, %cst_3 : f32 + %19 = scf.if %18 -> (f32) { + %21 = arith.subf %cst_3, %17 : f32 + scf.yield %21 : f32 + } else { + scf.yield %cst_1 : f32 + } + %20 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %21 = arith.index_cast %arg7 : index to i32 + %22 = arith.sitofp %21 : i32 to f32 + %23 = arith.subf %9, %22 : f32 + %24 = arith.cmpf olt, %23, %cst_1 : f32 + %25 = scf.if %24 -> (f32) { + %30 = arith.negf %23 : f32 + scf.yield %30 : f32 + } else { + scf.yield %23 : f32 + } + %26 = arith.cmpf olt, %25, %cst_3 : f32 + %27 = scf.if %26 -> (f32) { + %30 = arith.subf %cst_3, %25 : f32 + scf.yield %30 : f32 + } else { + scf.yield %cst_1 : f32 + } + %28 = arith.mulf %19, %27 : f32 + %29 = arith.addf %arg8, %28 : f32 + affine.yield %29 : f32 + } + affine.yield %20 : f32 + } + %11 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_1) -> (f32) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.sitofp %13 : i32 to f32 + %15 = arith.subf %4, %14 : f32 + %16 = arith.cmpf olt, %15, %cst_1 : f32 + %17 = scf.if %16 -> (f32) { + %21 = arith.negf %15 : f32 + scf.yield %21 : f32 + } else { + scf.yield %15 : f32 + } + %18 = arith.cmpf olt, %17, %cst_3 : f32 + %19 = scf.if %18 -> (f32) { + %21 = arith.subf %cst_3, %17 : f32 + scf.yield %21 : f32 + } else { + scf.yield %cst_1 : f32 + } + %20 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %21 = arith.index_cast %arg7 : index to i32 + %22 = arith.sitofp %21 : i32 to f32 + %23 = arith.subf %9, %22 : f32 + %24 = arith.cmpf olt, %23, %cst_1 : f32 + %25 = scf.if %24 -> (f32) { + %32 = arith.negf %23 : f32 + scf.yield %32 : f32 + } else { + scf.yield %23 : f32 + } + %26 = arith.cmpf olt, %25, %cst_3 : f32 + %27 = scf.if %26 -> (f32) { + %32 = arith.subf %cst_3, %25 : f32 + scf.yield %32 : f32 + } else { + scf.yield %cst_1 : f32 + } + %28 = affine.load %arg0[%arg7 + %arg2 * 20 + %arg5 * 5] : memref + %29 = arith.mulf %28, %19 : f32 + %30 = arith.mulf %29, %27 : f32 + %31 = arith.addf %arg8, %30 : f32 + affine.yield %31 : f32 + } + affine.yield %20 : f32 + } + %12 = arith.divf %11, %10 : f32 + affine.store %12, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu/raised.mlir new file mode 100644 index 000000000000..3c2cced339d4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu/raised.mlir @@ -0,0 +1,95 @@ +#map = affine_map<(d0, d1) -> ()> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %cst_3 = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_2 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_2 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_2 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_2 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_1, %alloca[] : memref + %10 = polygeist.submap(%alloca, %c4, %c5) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction", "reduction"]} outs(%10 : memref) { + ^bb0(%out: f32): + %15 = linalg.index 0 : index + %16 = arith.index_cast %15 : index to i32 + %17 = arith.sitofp %16 : i32 to f32 + %18 = arith.subf %4, %17 : f32 + %19 = arith.cmpf olt, %18, %cst_1 : f32 + %20 = arith.negf %18 : f32 + %21 = arith.select %19, %20, %18 : f32 + %22 = arith.cmpf olt, %21, %cst_3 : f32 + %23 = arith.subf %cst_3, %21 : f32 + %24 = arith.select %22, %23, %cst_1 : f32 + %25 = linalg.index 1 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_1 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_3 : f32 + %33 = arith.subf %cst_3, %31 : f32 + %34 = arith.select %32, %33, %cst_1 : f32 + %35 = arith.mulf %24, %34 : f32 + %36 = arith.addf %out, %35 : f32 + linalg.yield %36 : f32 + } + %11 = affine.load %alloca[] : memref + %alloca_4 = memref.alloca() : memref + affine.store %cst_1, %alloca_4[] : memref + %12 = polygeist.submap(%arg0, %arg2, %c4, %c5) {map = #map2} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map], iterator_types = ["reduction", "reduction"]} ins(%12 : memref) outs(%alloca_4 : memref) { + ^bb0(%in: f32, %out: f32): + %15 = linalg.index 0 : index + %16 = arith.index_cast %15 : index to i32 + %17 = arith.sitofp %16 : i32 to f32 + %18 = arith.subf %4, %17 : f32 + %19 = arith.cmpf olt, %18, %cst_1 : f32 + %20 = arith.negf %18 : f32 + %21 = arith.select %19, %20, %18 : f32 + %22 = arith.cmpf olt, %21, %cst_3 : f32 + %23 = arith.subf %cst_3, %21 : f32 + %24 = arith.select %22, %23, %cst_1 : f32 + %25 = linalg.index 1 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_1 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_3 : f32 + %33 = arith.subf %cst_3, %31 : f32 + %34 = arith.select %32, %33, %cst_1 : f32 + %35 = arith.mulf %in, %24 : f32 + %36 = arith.mulf %35, %34 : f32 + %37 = arith.addf %out, %36 : f32 + linalg.yield %37 : f32 + } + %13 = affine.load %alloca_4[] : memref + %14 = arith.divf %13, %11 : f32 + affine.store %14, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu_debuf.mlir new file mode 100644 index 000000000000..ef9443e8adc3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu_debuf.mlir @@ -0,0 +1,107 @@ +#map = affine_map<(d0, d1) -> ()> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map3 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant 6.250000e-01 : f32 + %cst_3 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %4 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_0 : f32 + %8 = arith.mulf %7, %cst_3 : f32 + %9 = arith.subf %8, %cst_0 : f32 + %10 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %11 = arith.index_cast %arg6 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.addf %12, %cst_0 : f32 + %14 = arith.mulf %13, %cst_2 : f32 + %15 = arith.subf %14, %cst_0 : f32 + %alloca = memref.alloca() : memref + %16 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst_1 into %16[] : tensor + %17 = polygeist.submap(%inserted, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%17 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_1 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst : f32 + %33 = arith.subf %cst, %31 : f32 + %34 = arith.select %32, %33, %cst_1 : f32 + %35 = linalg.index 1 : index + %36 = arith.index_cast %35 : index to i32 + %37 = arith.sitofp %36 : i32 to f32 + %38 = arith.subf %15, %37 : f32 + %39 = arith.cmpf olt, %38, %cst_1 : f32 + %40 = arith.negf %38 : f32 + %41 = arith.select %39, %40, %38 : f32 + %42 = arith.cmpf olt, %41, %cst : f32 + %43 = arith.subf %cst, %41 : f32 + %44 = arith.select %42, %43, %cst_1 : f32 + %45 = arith.mulf %34, %44 : f32 + %46 = arith.addf %out, %45 : f32 + linalg.yield %46 : f32 + } -> tensor + %19 = polygeist.submapInverse(%inserted, %18, %c4, %c5) {map = #map} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %19[] : tensor + %alloca_4 = memref.alloca() : memref + %20 = bufferization.to_tensor %alloca_4 : memref + %inserted_5 = tensor.insert %cst_1 into %20[] : tensor + %21 = polygeist.submap(%1, %arg2, %c4, %c5) {map = #map2} : (tensor, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map1, #map], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%21 : tensor) outs(%inserted_5 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_1 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst : f32 + %33 = arith.subf %cst, %31 : f32 + %34 = arith.select %32, %33, %cst_1 : f32 + %35 = linalg.index 1 : index + %36 = arith.index_cast %35 : index to i32 + %37 = arith.sitofp %36 : i32 to f32 + %38 = arith.subf %15, %37 : f32 + %39 = arith.cmpf olt, %38, %cst_1 : f32 + %40 = arith.negf %38 : f32 + %41 = arith.select %39, %40, %38 : f32 + %42 = arith.cmpf olt, %41, %cst : f32 + %43 = arith.subf %cst, %41 : f32 + %44 = arith.select %42, %43, %cst_1 : f32 + %45 = arith.mulf %in, %34 : f32 + %46 = arith.mulf %45, %44 : f32 + %47 = arith.addf %out, %46 : f32 + linalg.yield %47 : f32 + } -> tensor + %extracted_6 = tensor.extract %22[] : tensor + %23 = arith.divf %extracted_6, %extracted : f32 + %24 = affine.apply #map3(%arg6, %arg2, %arg4) + %inserted_7 = tensor.insert %23 into %arg7[%24] : tensor + affine.yield %inserted_7 : tensor + } + affine.yield %10 : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu_linalg.mlir new file mode 100644 index 000000000000..3c2cced339d4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_aa_cpu_linalg.mlir @@ -0,0 +1,95 @@ +#map = affine_map<(d0, d1) -> ()> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %cst_3 = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_2 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_2 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_2 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_2 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_1, %alloca[] : memref + %10 = polygeist.submap(%alloca, %c4, %c5) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction", "reduction"]} outs(%10 : memref) { + ^bb0(%out: f32): + %15 = linalg.index 0 : index + %16 = arith.index_cast %15 : index to i32 + %17 = arith.sitofp %16 : i32 to f32 + %18 = arith.subf %4, %17 : f32 + %19 = arith.cmpf olt, %18, %cst_1 : f32 + %20 = arith.negf %18 : f32 + %21 = arith.select %19, %20, %18 : f32 + %22 = arith.cmpf olt, %21, %cst_3 : f32 + %23 = arith.subf %cst_3, %21 : f32 + %24 = arith.select %22, %23, %cst_1 : f32 + %25 = linalg.index 1 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_1 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_3 : f32 + %33 = arith.subf %cst_3, %31 : f32 + %34 = arith.select %32, %33, %cst_1 : f32 + %35 = arith.mulf %24, %34 : f32 + %36 = arith.addf %out, %35 : f32 + linalg.yield %36 : f32 + } + %11 = affine.load %alloca[] : memref + %alloca_4 = memref.alloca() : memref + affine.store %cst_1, %alloca_4[] : memref + %12 = polygeist.submap(%arg0, %arg2, %c4, %c5) {map = #map2} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map], iterator_types = ["reduction", "reduction"]} ins(%12 : memref) outs(%alloca_4 : memref) { + ^bb0(%in: f32, %out: f32): + %15 = linalg.index 0 : index + %16 = arith.index_cast %15 : index to i32 + %17 = arith.sitofp %16 : i32 to f32 + %18 = arith.subf %4, %17 : f32 + %19 = arith.cmpf olt, %18, %cst_1 : f32 + %20 = arith.negf %18 : f32 + %21 = arith.select %19, %20, %18 : f32 + %22 = arith.cmpf olt, %21, %cst_3 : f32 + %23 = arith.subf %cst_3, %21 : f32 + %24 = arith.select %22, %23, %cst_1 : f32 + %25 = linalg.index 1 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_1 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_3 : f32 + %33 = arith.subf %cst_3, %31 : f32 + %34 = arith.select %32, %33, %cst_1 : f32 + %35 = arith.mulf %in, %24 : f32 + %36 = arith.mulf %35, %34 : f32 + %37 = arith.addf %out, %36 : f32 + linalg.yield %37 : f32 + } + %13 = affine.load %alloca_4[] : memref + %14 = arith.divf %13, %11 : f32 + affine.store %14, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu.mlir new file mode 100644 index 000000000000..f74a71e542f0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu.mlir @@ -0,0 +1,92 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e+00 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %cst_3 = arith.constant 4.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e-01 : f32 + %cst_5 = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 40 { + affine.store %cst_5, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_4 : f32 + %5 = arith.mulf %4, %cst_3 : f32 + %6 = arith.divf %5, %cst_2 : f32 + %7 = arith.subf %6, %cst_4 : f32 + %8 = arith.cmpf olt, %7, %cst_5 : f32 + %9 = arith.select %8, %cst_5, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + %13 = arith.sitofp %10 : i32 to f32 + %14 = arith.subf %9, %13 : f32 + %15 = arith.subf %cst_1, %14 : f32 + %16 = arith.addi %10, %c1_i32 : i32 + %17 = arith.cmpi slt, %16, %c4_i32 : i32 + %18 = arith.select %17, %16, %10 : i32 + %19 = arith.addi %1, %18 : i32 + %20 = arith.muli %19, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %21 = arith.index_cast %arg4 : index to i32 + %22 = arith.sitofp %21 : i32 to f32 + %23 = arith.addf %22, %cst_4 : f32 + %24 = arith.mulf %23, %cst_0 : f32 + %25 = arith.divf %24, %cst : f32 + %26 = arith.subf %25, %cst_4 : f32 + %27 = arith.cmpf olt, %26, %cst_5 : f32 + %28 = arith.select %27, %cst_5, %26 : f32 + %29 = arith.fptosi %28 : f32 to i32 + %30 = arith.addi %12, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %33 = arith.mulf %32, %15 : f32 + %34 = arith.sitofp %29 : i32 to f32 + %35 = arith.subf %28, %34 : f32 + %36 = arith.subf %cst_1, %35 : f32 + %37 = arith.mulf %33, %36 : f32 + %38 = memref.load %arg1[%31] : memref + %39 = arith.addf %38, %37 : f32 + memref.store %39, %arg1[%31] : memref + %40 = arith.addi %29, %c1_i32 : i32 + %41 = arith.cmpi slt, %40, %c5_i32 : i32 + %42 = arith.select %41, %40, %29 : i32 + %43 = arith.addi %12, %42 : i32 + %44 = arith.index_cast %43 : i32 to index + %45 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %46 = arith.mulf %45, %15 : f32 + %47 = arith.mulf %46, %35 : f32 + %48 = memref.load %arg1[%44] : memref + %49 = arith.addf %48, %47 : f32 + memref.store %49, %arg1[%44] : memref + %50 = arith.addi %20, %29 : i32 + %51 = arith.index_cast %50 : i32 to index + %52 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %53 = arith.mulf %52, %14 : f32 + %54 = arith.mulf %53, %36 : f32 + %55 = memref.load %arg1[%51] : memref + %56 = arith.addf %55, %54 : f32 + memref.store %56, %arg1[%51] : memref + %57 = arith.addi %20, %42 : i32 + %58 = arith.index_cast %57 : i32 to index + %59 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %60 = arith.mulf %59, %14 : f32 + %61 = arith.mulf %60, %35 : f32 + %62 = memref.load %arg1[%58] : memref + %63 = arith.addf %62, %61 : f32 + memref.store %63, %arg1[%58] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..fad4bf5ab2ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu/debuf.mlir @@ -0,0 +1,107 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.000000e+00 : f32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e+00 : f32 + %cst_5 = arith.constant 8.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.sitofp %8 : i32 to f32 + %10 = arith.addf %9, %cst_0 : f32 + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.divf %11, %cst_2 : f32 + %13 = arith.subf %12, %cst_0 : f32 + %14 = arith.cmpf olt, %13, %cst : f32 + %15 = arith.select %14, %cst, %13 : f32 + %16 = arith.fptosi %15 : f32 to i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = arith.sitofp %16 : i32 to f32 + %20 = arith.subf %15, %19 : f32 + %21 = arith.subf %cst_3, %20 : f32 + %22 = arith.addi %16, %c1_i32 : i32 + %23 = arith.cmpi slt, %22, %c4_i32 : i32 + %24 = arith.select %23, %22, %16 : i32 + %25 = arith.addi %6, %24 : i32 + %26 = arith.muli %25, %c5_i32 : i32 + %27 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %28 = arith.index_cast %arg6 : index to i32 + %29 = arith.sitofp %28 : i32 to f32 + %30 = arith.addf %29, %cst_0 : f32 + %31 = arith.mulf %30, %cst_4 : f32 + %32 = arith.divf %31, %cst_5 : f32 + %33 = arith.subf %32, %cst_0 : f32 + %34 = arith.cmpf olt, %33, %cst : f32 + %35 = arith.select %34, %cst, %33 : f32 + %36 = arith.fptosi %35 : f32 to i32 + %37 = arith.addi %18, %36 : i32 + %38 = arith.index_cast %37 : i32 to index + %39 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%39] : tensor + %40 = arith.mulf %extracted, %21 : f32 + %41 = arith.sitofp %36 : i32 to f32 + %42 = arith.subf %35, %41 : f32 + %43 = arith.subf %cst_3, %42 : f32 + %44 = arith.mulf %40, %43 : f32 + %extracted_6 = tensor.extract %arg7[%38] : tensor + %45 = arith.addf %extracted_6, %44 : f32 + %inserted = tensor.insert %45 into %arg7[%38] : tensor + %46 = arith.addi %36, %c1_i32 : i32 + %47 = arith.cmpi slt, %46, %c5_i32 : i32 + %48 = arith.select %47, %46, %36 : i32 + %49 = arith.addi %18, %48 : i32 + %50 = arith.index_cast %49 : i32 to index + %51 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted_7 = tensor.extract %1[%51] : tensor + %52 = arith.mulf %extracted_7, %21 : f32 + %53 = arith.mulf %52, %42 : f32 + %extracted_8 = tensor.extract %inserted[%50] : tensor + %54 = arith.addf %extracted_8, %53 : f32 + %inserted_9 = tensor.insert %54 into %inserted[%50] : tensor + %55 = arith.addi %26, %36 : i32 + %56 = arith.index_cast %55 : i32 to index + %57 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted_10 = tensor.extract %1[%57] : tensor + %58 = arith.mulf %extracted_10, %20 : f32 + %59 = arith.mulf %58, %43 : f32 + %extracted_11 = tensor.extract %inserted_9[%56] : tensor + %60 = arith.addf %extracted_11, %59 : f32 + %inserted_12 = tensor.insert %60 into %inserted_9[%56] : tensor + %61 = arith.addi %26, %48 : i32 + %62 = arith.index_cast %61 : i32 to index + %63 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted_13 = tensor.extract %1[%63] : tensor + %64 = arith.mulf %extracted_13, %20 : f32 + %65 = arith.mulf %64, %42 : f32 + %extracted_14 = tensor.extract %inserted_12[%62] : tensor + %66 = arith.addf %extracted_14, %65 : f32 + %inserted_15 = tensor.insert %66 into %inserted_12[%62] : tensor + affine.yield %inserted_15 : tensor + } + affine.yield %27 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..3009651f0bd9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu/matched.mlir @@ -0,0 +1,104 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.000000e+00 : f32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e+00 : f32 + %cst_5 = arith.constant 8.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.sitofp %8 : i32 to f32 + %10 = arith.addf %9, %cst_0 : f32 + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.divf %11, %cst_2 : f32 + %13 = arith.subf %12, %cst_0 : f32 + %14 = arith.cmpf olt, %13, %cst : f32 + %15 = arith.select %14, %cst, %13 : f32 + %16 = arith.fptosi %15 : f32 to i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = arith.sitofp %16 : i32 to f32 + %20 = arith.subf %15, %19 : f32 + %21 = arith.subf %cst_3, %20 : f32 + %22 = arith.addi %16, %c1_i32 : i32 + %23 = arith.cmpi slt, %22, %c4_i32 : i32 + %24 = arith.select %23, %22, %16 : i32 + %25 = arith.addi %6, %24 : i32 + %26 = arith.muli %25, %c5_i32 : i32 + %27 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %28 = arith.index_cast %arg6 : index to i32 + %29 = arith.sitofp %28 : i32 to f32 + %30 = arith.addf %29, %cst_0 : f32 + %31 = arith.mulf %30, %cst_4 : f32 + %32 = arith.divf %31, %cst_5 : f32 + %33 = arith.subf %32, %cst_0 : f32 + %34 = arith.cmpf olt, %33, %cst : f32 + %35 = arith.select %34, %cst, %33 : f32 + %36 = arith.fptosi %35 : f32 to i32 + %37 = arith.addi %18, %36 : i32 + %38 = arith.index_cast %37 : i32 to index + %39 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%39] : tensor + %40 = arith.mulf %extracted, %21 : f32 + %41 = arith.sitofp %36 : i32 to f32 + %42 = arith.subf %35, %41 : f32 + %43 = arith.subf %cst_3, %42 : f32 + %44 = arith.mulf %40, %43 : f32 + %extracted_6 = tensor.extract %arg7[%38] : tensor + %45 = arith.addf %extracted_6, %44 : f32 + %inserted = tensor.insert %45 into %arg7[%38] : tensor + %46 = arith.addi %36, %c1_i32 : i32 + %47 = arith.cmpi slt, %46, %c5_i32 : i32 + %48 = arith.select %47, %46, %36 : i32 + %49 = arith.addi %18, %48 : i32 + %50 = arith.index_cast %49 : i32 to index + %51 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted_7 = tensor.extract %1[%51] : tensor + %52 = arith.mulf %extracted_7, %21 : f32 + %53 = arith.mulf %52, %42 : f32 + %extracted_8 = tensor.extract %inserted[%50] : tensor + %54 = arith.addf %extracted_8, %53 : f32 + %inserted_9 = tensor.insert %54 into %inserted[%50] : tensor + %55 = arith.addi %26, %36 : i32 + %56 = arith.index_cast %55 : i32 to index + %57 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted_10 = tensor.extract %1[%57] : tensor + %58 = arith.mulf %extracted_10, %20 : f32 + %59 = arith.mulf %58, %43 : f32 + %extracted_11 = tensor.extract %inserted_9[%56] : tensor + %60 = arith.addf %extracted_11, %59 : f32 + %inserted_12 = tensor.insert %60 into %inserted_9[%56] : tensor + %61 = arith.addi %26, %48 : i32 + %62 = arith.index_cast %61 : i32 to index + %63 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted_13 = tensor.extract %1[%63] : tensor + %64 = arith.mulf %extracted_13, %20 : f32 + %65 = arith.mulf %64, %42 : f32 + %extracted_14 = tensor.extract %inserted_12[%62] : tensor + %66 = arith.addf %extracted_14, %65 : f32 + %inserted_15 = tensor.insert %66 into %inserted_12[%62] : tensor + affine.yield %inserted_15 : tensor + } + affine.yield %27 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..f74a71e542f0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu/orig.mlir @@ -0,0 +1,92 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e+00 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %cst_3 = arith.constant 4.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e-01 : f32 + %cst_5 = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 40 { + affine.store %cst_5, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_4 : f32 + %5 = arith.mulf %4, %cst_3 : f32 + %6 = arith.divf %5, %cst_2 : f32 + %7 = arith.subf %6, %cst_4 : f32 + %8 = arith.cmpf olt, %7, %cst_5 : f32 + %9 = arith.select %8, %cst_5, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + %13 = arith.sitofp %10 : i32 to f32 + %14 = arith.subf %9, %13 : f32 + %15 = arith.subf %cst_1, %14 : f32 + %16 = arith.addi %10, %c1_i32 : i32 + %17 = arith.cmpi slt, %16, %c4_i32 : i32 + %18 = arith.select %17, %16, %10 : i32 + %19 = arith.addi %1, %18 : i32 + %20 = arith.muli %19, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %21 = arith.index_cast %arg4 : index to i32 + %22 = arith.sitofp %21 : i32 to f32 + %23 = arith.addf %22, %cst_4 : f32 + %24 = arith.mulf %23, %cst_0 : f32 + %25 = arith.divf %24, %cst : f32 + %26 = arith.subf %25, %cst_4 : f32 + %27 = arith.cmpf olt, %26, %cst_5 : f32 + %28 = arith.select %27, %cst_5, %26 : f32 + %29 = arith.fptosi %28 : f32 to i32 + %30 = arith.addi %12, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %33 = arith.mulf %32, %15 : f32 + %34 = arith.sitofp %29 : i32 to f32 + %35 = arith.subf %28, %34 : f32 + %36 = arith.subf %cst_1, %35 : f32 + %37 = arith.mulf %33, %36 : f32 + %38 = memref.load %arg1[%31] : memref + %39 = arith.addf %38, %37 : f32 + memref.store %39, %arg1[%31] : memref + %40 = arith.addi %29, %c1_i32 : i32 + %41 = arith.cmpi slt, %40, %c5_i32 : i32 + %42 = arith.select %41, %40, %29 : i32 + %43 = arith.addi %12, %42 : i32 + %44 = arith.index_cast %43 : i32 to index + %45 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %46 = arith.mulf %45, %15 : f32 + %47 = arith.mulf %46, %35 : f32 + %48 = memref.load %arg1[%44] : memref + %49 = arith.addf %48, %47 : f32 + memref.store %49, %arg1[%44] : memref + %50 = arith.addi %20, %29 : i32 + %51 = arith.index_cast %50 : i32 to index + %52 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %53 = arith.mulf %52, %14 : f32 + %54 = arith.mulf %53, %36 : f32 + %55 = memref.load %arg1[%51] : memref + %56 = arith.addf %55, %54 : f32 + memref.store %56, %arg1[%51] : memref + %57 = arith.addi %20, %42 : i32 + %58 = arith.index_cast %57 : i32 to index + %59 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %60 = arith.mulf %59, %14 : f32 + %61 = arith.mulf %60, %35 : f32 + %62 = memref.load %arg1[%58] : memref + %63 = arith.addf %62, %61 : f32 + memref.store %63, %arg1[%58] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..4e64f8826caf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu/raised.mlir @@ -0,0 +1,95 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e+00 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %cst_3 = arith.constant 4.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e-01 : f32 + %cst_5 = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_5 : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_4 : f32 + %5 = arith.mulf %4, %cst_3 : f32 + %6 = arith.divf %5, %cst_2 : f32 + %7 = arith.subf %6, %cst_4 : f32 + %8 = arith.cmpf olt, %7, %cst_5 : f32 + %9 = arith.select %8, %cst_5, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + %13 = arith.sitofp %10 : i32 to f32 + %14 = arith.subf %9, %13 : f32 + %15 = arith.subf %cst_1, %14 : f32 + %16 = arith.addi %10, %c1_i32 : i32 + %17 = arith.cmpi slt, %16, %c4_i32 : i32 + %18 = arith.select %17, %16, %10 : i32 + %19 = arith.addi %1, %18 : i32 + %20 = arith.muli %19, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %21 = arith.index_cast %arg4 : index to i32 + %22 = arith.sitofp %21 : i32 to f32 + %23 = arith.addf %22, %cst_4 : f32 + %24 = arith.mulf %23, %cst_0 : f32 + %25 = arith.divf %24, %cst : f32 + %26 = arith.subf %25, %cst_4 : f32 + %27 = arith.cmpf olt, %26, %cst_5 : f32 + %28 = arith.select %27, %cst_5, %26 : f32 + %29 = arith.fptosi %28 : f32 to i32 + %30 = arith.addi %12, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %33 = arith.mulf %32, %15 : f32 + %34 = arith.sitofp %29 : i32 to f32 + %35 = arith.subf %28, %34 : f32 + %36 = arith.subf %cst_1, %35 : f32 + %37 = arith.mulf %33, %36 : f32 + %38 = memref.load %arg1[%31] : memref + %39 = arith.addf %38, %37 : f32 + memref.store %39, %arg1[%31] : memref + %40 = arith.addi %29, %c1_i32 : i32 + %41 = arith.cmpi slt, %40, %c5_i32 : i32 + %42 = arith.select %41, %40, %29 : i32 + %43 = arith.addi %12, %42 : i32 + %44 = arith.index_cast %43 : i32 to index + %45 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %46 = arith.mulf %45, %15 : f32 + %47 = arith.mulf %46, %35 : f32 + %48 = memref.load %arg1[%44] : memref + %49 = arith.addf %48, %47 : f32 + memref.store %49, %arg1[%44] : memref + %50 = arith.addi %20, %29 : i32 + %51 = arith.index_cast %50 : i32 to index + %52 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %53 = arith.mulf %52, %14 : f32 + %54 = arith.mulf %53, %36 : f32 + %55 = memref.load %arg1[%51] : memref + %56 = arith.addf %55, %54 : f32 + memref.store %56, %arg1[%51] : memref + %57 = arith.addi %20, %42 : i32 + %58 = arith.index_cast %57 : i32 to index + %59 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %60 = arith.mulf %59, %14 : f32 + %61 = arith.mulf %60, %35 : f32 + %62 = memref.load %arg1[%58] : memref + %63 = arith.addf %62, %61 : f32 + memref.store %63, %arg1[%58] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..fad4bf5ab2ce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu_debuf.mlir @@ -0,0 +1,107 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.000000e+00 : f32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e+00 : f32 + %cst_5 = arith.constant 8.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.sitofp %8 : i32 to f32 + %10 = arith.addf %9, %cst_0 : f32 + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.divf %11, %cst_2 : f32 + %13 = arith.subf %12, %cst_0 : f32 + %14 = arith.cmpf olt, %13, %cst : f32 + %15 = arith.select %14, %cst, %13 : f32 + %16 = arith.fptosi %15 : f32 to i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = arith.sitofp %16 : i32 to f32 + %20 = arith.subf %15, %19 : f32 + %21 = arith.subf %cst_3, %20 : f32 + %22 = arith.addi %16, %c1_i32 : i32 + %23 = arith.cmpi slt, %22, %c4_i32 : i32 + %24 = arith.select %23, %22, %16 : i32 + %25 = arith.addi %6, %24 : i32 + %26 = arith.muli %25, %c5_i32 : i32 + %27 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %28 = arith.index_cast %arg6 : index to i32 + %29 = arith.sitofp %28 : i32 to f32 + %30 = arith.addf %29, %cst_0 : f32 + %31 = arith.mulf %30, %cst_4 : f32 + %32 = arith.divf %31, %cst_5 : f32 + %33 = arith.subf %32, %cst_0 : f32 + %34 = arith.cmpf olt, %33, %cst : f32 + %35 = arith.select %34, %cst, %33 : f32 + %36 = arith.fptosi %35 : f32 to i32 + %37 = arith.addi %18, %36 : i32 + %38 = arith.index_cast %37 : i32 to index + %39 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%39] : tensor + %40 = arith.mulf %extracted, %21 : f32 + %41 = arith.sitofp %36 : i32 to f32 + %42 = arith.subf %35, %41 : f32 + %43 = arith.subf %cst_3, %42 : f32 + %44 = arith.mulf %40, %43 : f32 + %extracted_6 = tensor.extract %arg7[%38] : tensor + %45 = arith.addf %extracted_6, %44 : f32 + %inserted = tensor.insert %45 into %arg7[%38] : tensor + %46 = arith.addi %36, %c1_i32 : i32 + %47 = arith.cmpi slt, %46, %c5_i32 : i32 + %48 = arith.select %47, %46, %36 : i32 + %49 = arith.addi %18, %48 : i32 + %50 = arith.index_cast %49 : i32 to index + %51 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted_7 = tensor.extract %1[%51] : tensor + %52 = arith.mulf %extracted_7, %21 : f32 + %53 = arith.mulf %52, %42 : f32 + %extracted_8 = tensor.extract %inserted[%50] : tensor + %54 = arith.addf %extracted_8, %53 : f32 + %inserted_9 = tensor.insert %54 into %inserted[%50] : tensor + %55 = arith.addi %26, %36 : i32 + %56 = arith.index_cast %55 : i32 to index + %57 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted_10 = tensor.extract %1[%57] : tensor + %58 = arith.mulf %extracted_10, %20 : f32 + %59 = arith.mulf %58, %43 : f32 + %extracted_11 = tensor.extract %inserted_9[%56] : tensor + %60 = arith.addf %extracted_11, %59 : f32 + %inserted_12 = tensor.insert %60 into %inserted_9[%56] : tensor + %61 = arith.addi %26, %48 : i32 + %62 = arith.index_cast %61 : i32 to index + %63 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted_13 = tensor.extract %1[%63] : tensor + %64 = arith.mulf %extracted_13, %20 : f32 + %65 = arith.mulf %64, %42 : f32 + %extracted_14 = tensor.extract %inserted_12[%62] : tensor + %66 = arith.addf %extracted_14, %65 : f32 + %inserted_15 = tensor.insert %66 into %inserted_12[%62] : tensor + affine.yield %inserted_15 : tensor + } + affine.yield %27 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..4e64f8826caf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_backward_cpu_linalg.mlir @@ -0,0 +1,95 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e+00 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %cst_3 = arith.constant 4.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e-01 : f32 + %cst_5 = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_5 : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_4 : f32 + %5 = arith.mulf %4, %cst_3 : f32 + %6 = arith.divf %5, %cst_2 : f32 + %7 = arith.subf %6, %cst_4 : f32 + %8 = arith.cmpf olt, %7, %cst_5 : f32 + %9 = arith.select %8, %cst_5, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + %13 = arith.sitofp %10 : i32 to f32 + %14 = arith.subf %9, %13 : f32 + %15 = arith.subf %cst_1, %14 : f32 + %16 = arith.addi %10, %c1_i32 : i32 + %17 = arith.cmpi slt, %16, %c4_i32 : i32 + %18 = arith.select %17, %16, %10 : i32 + %19 = arith.addi %1, %18 : i32 + %20 = arith.muli %19, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %21 = arith.index_cast %arg4 : index to i32 + %22 = arith.sitofp %21 : i32 to f32 + %23 = arith.addf %22, %cst_4 : f32 + %24 = arith.mulf %23, %cst_0 : f32 + %25 = arith.divf %24, %cst : f32 + %26 = arith.subf %25, %cst_4 : f32 + %27 = arith.cmpf olt, %26, %cst_5 : f32 + %28 = arith.select %27, %cst_5, %26 : f32 + %29 = arith.fptosi %28 : f32 to i32 + %30 = arith.addi %12, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %33 = arith.mulf %32, %15 : f32 + %34 = arith.sitofp %29 : i32 to f32 + %35 = arith.subf %28, %34 : f32 + %36 = arith.subf %cst_1, %35 : f32 + %37 = arith.mulf %33, %36 : f32 + %38 = memref.load %arg1[%31] : memref + %39 = arith.addf %38, %37 : f32 + memref.store %39, %arg1[%31] : memref + %40 = arith.addi %29, %c1_i32 : i32 + %41 = arith.cmpi slt, %40, %c5_i32 : i32 + %42 = arith.select %41, %40, %29 : i32 + %43 = arith.addi %12, %42 : i32 + %44 = arith.index_cast %43 : i32 to index + %45 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %46 = arith.mulf %45, %15 : f32 + %47 = arith.mulf %46, %35 : f32 + %48 = memref.load %arg1[%44] : memref + %49 = arith.addf %48, %47 : f32 + memref.store %49, %arg1[%44] : memref + %50 = arith.addi %20, %29 : i32 + %51 = arith.index_cast %50 : i32 to index + %52 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %53 = arith.mulf %52, %14 : f32 + %54 = arith.mulf %53, %36 : f32 + %55 = memref.load %arg1[%51] : memref + %56 = arith.addf %55, %54 : f32 + memref.store %56, %arg1[%51] : memref + %57 = arith.addi %20, %42 : i32 + %58 = arith.index_cast %57 : i32 to index + %59 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %60 = arith.mulf %59, %14 : f32 + %61 = arith.mulf %60, %35 : f32 + %62 = memref.load %arg1[%58] : memref + %63 = arith.addf %62, %61 : f32 + memref.store %63, %arg1[%58] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu.mlir new file mode 100644 index 000000000000..42144a1b2405 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu.mlir @@ -0,0 +1,81 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e+00 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %cst_3 = arith.constant 7.000000e+00 : f32 + %cst_4 = arith.constant 4.000000e+00 : f32 + %cst_5 = arith.constant 5.000000e-01 : f32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_5 : f32 + %5 = arith.mulf %4, %cst_4 : f32 + %6 = arith.divf %5, %cst_3 : f32 + %7 = arith.subf %6, %cst_5 : f32 + %8 = arith.cmpf olt, %7, %cst_2 : f32 + %9 = arith.select %8, %cst_2, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + %13 = arith.sitofp %10 : i32 to f32 + %14 = arith.subf %9, %13 : f32 + %15 = arith.subf %cst_1, %14 : f32 + %16 = arith.addi %10, %c1_i32 : i32 + %17 = arith.cmpi slt, %16, %c4_i32 : i32 + %18 = arith.select %17, %16, %10 : i32 + %19 = arith.addi %1, %18 : i32 + %20 = arith.muli %19, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %21 = arith.index_cast %arg4 : index to i32 + %22 = arith.sitofp %21 : i32 to f32 + %23 = arith.addf %22, %cst_5 : f32 + %24 = arith.mulf %23, %cst_0 : f32 + %25 = arith.divf %24, %cst : f32 + %26 = arith.subf %25, %cst_5 : f32 + %27 = arith.cmpf olt, %26, %cst_2 : f32 + %28 = arith.select %27, %cst_2, %26 : f32 + %29 = arith.fptosi %28 : f32 to i32 + %30 = arith.addi %12, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %arg0[%31] : memref + %33 = arith.mulf %32, %15 : f32 + %34 = arith.sitofp %29 : i32 to f32 + %35 = arith.subf %28, %34 : f32 + %36 = arith.subf %cst_1, %35 : f32 + %37 = arith.mulf %33, %36 : f32 + %38 = arith.addi %29, %c1_i32 : i32 + %39 = arith.cmpi slt, %38, %c5_i32 : i32 + %40 = arith.select %39, %38, %29 : i32 + %41 = arith.addi %12, %40 : i32 + %42 = arith.index_cast %41 : i32 to index + %43 = memref.load %arg0[%42] : memref + %44 = arith.mulf %43, %15 : f32 + %45 = arith.mulf %44, %35 : f32 + %46 = arith.addf %37, %45 : f32 + %47 = arith.addi %20, %29 : i32 + %48 = arith.index_cast %47 : i32 to index + %49 = memref.load %arg0[%48] : memref + %50 = arith.mulf %49, %14 : f32 + %51 = arith.mulf %50, %36 : f32 + %52 = arith.addf %46, %51 : f32 + %53 = arith.addi %20, %40 : i32 + %54 = arith.index_cast %53 : i32 to index + %55 = memref.load %arg0[%54] : memref + %56 = arith.mulf %55, %14 : f32 + %57 = arith.mulf %56, %35 : f32 + %58 = arith.addf %52, %57 : f32 + affine.store %58, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu/debuf.mlir new file mode 100644 index 000000000000..5a42381bae66 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu/debuf.mlir @@ -0,0 +1,92 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 56 + d1 * 8)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e+00 : f32 + %cst_5 = arith.constant 8.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8) {map = #map} : (tensor, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.sitofp %9 : i32 to f32 + %11 = arith.addf %10, %cst : f32 + %12 = arith.mulf %11, %cst_0 : f32 + %13 = arith.divf %12, %cst_1 : f32 + %14 = arith.subf %13, %cst : f32 + %15 = arith.cmpf olt, %14, %cst_2 : f32 + %16 = arith.select %15, %cst_2, %14 : f32 + %17 = arith.fptosi %16 : f32 to i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = arith.sitofp %17 : i32 to f32 + %21 = arith.subf %16, %20 : f32 + %22 = arith.subf %cst_3, %21 : f32 + %23 = arith.addi %17, %c1_i32 : i32 + %24 = arith.cmpi slt, %23, %c4_i32 : i32 + %25 = arith.select %24, %23, %17 : i32 + %26 = arith.addi %7, %25 : i32 + %27 = arith.muli %26, %c5_i32 : i32 + %28 = linalg.index 2 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.sitofp %29 : i32 to f32 + %31 = arith.addf %30, %cst : f32 + %32 = arith.mulf %31, %cst_4 : f32 + %33 = arith.divf %32, %cst_5 : f32 + %34 = arith.subf %33, %cst : f32 + %35 = arith.cmpf olt, %34, %cst_2 : f32 + %36 = arith.select %35, %cst_2, %34 : f32 + %37 = arith.fptosi %36 : f32 to i32 + %38 = arith.addi %19, %37 : i32 + %39 = arith.index_cast %38 : i32 to index + %40 = memref.load %arg0[%39] : memref + %41 = arith.mulf %40, %22 : f32 + %42 = arith.sitofp %37 : i32 to f32 + %43 = arith.subf %36, %42 : f32 + %44 = arith.subf %cst_3, %43 : f32 + %45 = arith.mulf %41, %44 : f32 + %46 = arith.addi %37, %c1_i32 : i32 + %47 = arith.cmpi slt, %46, %c5_i32 : i32 + %48 = arith.select %47, %46, %37 : i32 + %49 = arith.addi %19, %48 : i32 + %50 = arith.index_cast %49 : i32 to index + %51 = memref.load %arg0[%50] : memref + %52 = arith.mulf %51, %22 : f32 + %53 = arith.mulf %52, %43 : f32 + %54 = arith.addf %45, %53 : f32 + %55 = arith.addi %27, %37 : i32 + %56 = arith.index_cast %55 : i32 to index + %57 = memref.load %arg0[%56] : memref + %58 = arith.mulf %57, %21 : f32 + %59 = arith.mulf %58, %44 : f32 + %60 = arith.addf %54, %59 : f32 + %61 = arith.addi %27, %48 : i32 + %62 = arith.index_cast %61 : i32 to index + %63 = memref.load %arg0[%62] : memref + %64 = arith.mulf %63, %21 : f32 + %65 = arith.mulf %64, %43 : f32 + %66 = arith.addf %60, %65 : f32 + linalg.yield %66 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8) {map = #map} : (tensor, tensor, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu/matched.mlir new file mode 100644 index 000000000000..5a42381bae66 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu/matched.mlir @@ -0,0 +1,92 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 56 + d1 * 8)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e+00 : f32 + %cst_5 = arith.constant 8.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8) {map = #map} : (tensor, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.sitofp %9 : i32 to f32 + %11 = arith.addf %10, %cst : f32 + %12 = arith.mulf %11, %cst_0 : f32 + %13 = arith.divf %12, %cst_1 : f32 + %14 = arith.subf %13, %cst : f32 + %15 = arith.cmpf olt, %14, %cst_2 : f32 + %16 = arith.select %15, %cst_2, %14 : f32 + %17 = arith.fptosi %16 : f32 to i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = arith.sitofp %17 : i32 to f32 + %21 = arith.subf %16, %20 : f32 + %22 = arith.subf %cst_3, %21 : f32 + %23 = arith.addi %17, %c1_i32 : i32 + %24 = arith.cmpi slt, %23, %c4_i32 : i32 + %25 = arith.select %24, %23, %17 : i32 + %26 = arith.addi %7, %25 : i32 + %27 = arith.muli %26, %c5_i32 : i32 + %28 = linalg.index 2 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.sitofp %29 : i32 to f32 + %31 = arith.addf %30, %cst : f32 + %32 = arith.mulf %31, %cst_4 : f32 + %33 = arith.divf %32, %cst_5 : f32 + %34 = arith.subf %33, %cst : f32 + %35 = arith.cmpf olt, %34, %cst_2 : f32 + %36 = arith.select %35, %cst_2, %34 : f32 + %37 = arith.fptosi %36 : f32 to i32 + %38 = arith.addi %19, %37 : i32 + %39 = arith.index_cast %38 : i32 to index + %40 = memref.load %arg0[%39] : memref + %41 = arith.mulf %40, %22 : f32 + %42 = arith.sitofp %37 : i32 to f32 + %43 = arith.subf %36, %42 : f32 + %44 = arith.subf %cst_3, %43 : f32 + %45 = arith.mulf %41, %44 : f32 + %46 = arith.addi %37, %c1_i32 : i32 + %47 = arith.cmpi slt, %46, %c5_i32 : i32 + %48 = arith.select %47, %46, %37 : i32 + %49 = arith.addi %19, %48 : i32 + %50 = arith.index_cast %49 : i32 to index + %51 = memref.load %arg0[%50] : memref + %52 = arith.mulf %51, %22 : f32 + %53 = arith.mulf %52, %43 : f32 + %54 = arith.addf %45, %53 : f32 + %55 = arith.addi %27, %37 : i32 + %56 = arith.index_cast %55 : i32 to index + %57 = memref.load %arg0[%56] : memref + %58 = arith.mulf %57, %21 : f32 + %59 = arith.mulf %58, %44 : f32 + %60 = arith.addf %54, %59 : f32 + %61 = arith.addi %27, %48 : i32 + %62 = arith.index_cast %61 : i32 to index + %63 = memref.load %arg0[%62] : memref + %64 = arith.mulf %63, %21 : f32 + %65 = arith.mulf %64, %43 : f32 + %66 = arith.addf %60, %65 : f32 + linalg.yield %66 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8) {map = #map} : (tensor, tensor, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu/orig.mlir new file mode 100644 index 000000000000..42144a1b2405 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu/orig.mlir @@ -0,0 +1,81 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e+00 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %cst_3 = arith.constant 7.000000e+00 : f32 + %cst_4 = arith.constant 4.000000e+00 : f32 + %cst_5 = arith.constant 5.000000e-01 : f32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_5 : f32 + %5 = arith.mulf %4, %cst_4 : f32 + %6 = arith.divf %5, %cst_3 : f32 + %7 = arith.subf %6, %cst_5 : f32 + %8 = arith.cmpf olt, %7, %cst_2 : f32 + %9 = arith.select %8, %cst_2, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + %13 = arith.sitofp %10 : i32 to f32 + %14 = arith.subf %9, %13 : f32 + %15 = arith.subf %cst_1, %14 : f32 + %16 = arith.addi %10, %c1_i32 : i32 + %17 = arith.cmpi slt, %16, %c4_i32 : i32 + %18 = arith.select %17, %16, %10 : i32 + %19 = arith.addi %1, %18 : i32 + %20 = arith.muli %19, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %21 = arith.index_cast %arg4 : index to i32 + %22 = arith.sitofp %21 : i32 to f32 + %23 = arith.addf %22, %cst_5 : f32 + %24 = arith.mulf %23, %cst_0 : f32 + %25 = arith.divf %24, %cst : f32 + %26 = arith.subf %25, %cst_5 : f32 + %27 = arith.cmpf olt, %26, %cst_2 : f32 + %28 = arith.select %27, %cst_2, %26 : f32 + %29 = arith.fptosi %28 : f32 to i32 + %30 = arith.addi %12, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %arg0[%31] : memref + %33 = arith.mulf %32, %15 : f32 + %34 = arith.sitofp %29 : i32 to f32 + %35 = arith.subf %28, %34 : f32 + %36 = arith.subf %cst_1, %35 : f32 + %37 = arith.mulf %33, %36 : f32 + %38 = arith.addi %29, %c1_i32 : i32 + %39 = arith.cmpi slt, %38, %c5_i32 : i32 + %40 = arith.select %39, %38, %29 : i32 + %41 = arith.addi %12, %40 : i32 + %42 = arith.index_cast %41 : i32 to index + %43 = memref.load %arg0[%42] : memref + %44 = arith.mulf %43, %15 : f32 + %45 = arith.mulf %44, %35 : f32 + %46 = arith.addf %37, %45 : f32 + %47 = arith.addi %20, %29 : i32 + %48 = arith.index_cast %47 : i32 to index + %49 = memref.load %arg0[%48] : memref + %50 = arith.mulf %49, %14 : f32 + %51 = arith.mulf %50, %36 : f32 + %52 = arith.addf %46, %51 : f32 + %53 = arith.addi %20, %40 : i32 + %54 = arith.index_cast %53 : i32 to index + %55 = memref.load %arg0[%54] : memref + %56 = arith.mulf %55, %14 : f32 + %57 = arith.mulf %56, %35 : f32 + %58 = arith.addf %52, %57 : f32 + affine.store %58, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu/raised.mlir new file mode 100644 index 000000000000..6bb83040f3ed --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu/raised.mlir @@ -0,0 +1,88 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 56 + d1 * 8)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e+00 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %cst_3 = arith.constant 7.000000e+00 : f32 + %cst_4 = arith.constant 4.000000e+00 : f32 + %cst_5 = arith.constant 5.000000e-01 : f32 + %0 = polygeist.submap(%arg1, %c2, %c7, %c8) {map = #map} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_5 : f32 + %8 = arith.mulf %7, %cst_4 : f32 + %9 = arith.divf %8, %cst_3 : f32 + %10 = arith.subf %9, %cst_5 : f32 + %11 = arith.cmpf olt, %10, %cst_2 : f32 + %12 = arith.select %11, %cst_2, %10 : f32 + %13 = arith.fptosi %12 : f32 to i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = arith.sitofp %13 : i32 to f32 + %17 = arith.subf %12, %16 : f32 + %18 = arith.subf %cst_1, %17 : f32 + %19 = arith.addi %13, %c1_i32 : i32 + %20 = arith.cmpi slt, %19, %c4_i32 : i32 + %21 = arith.select %20, %19, %13 : i32 + %22 = arith.addi %3, %21 : i32 + %23 = arith.muli %22, %c5_i32 : i32 + %24 = linalg.index 2 : index + %25 = arith.index_cast %24 : index to i32 + %26 = arith.sitofp %25 : i32 to f32 + %27 = arith.addf %26, %cst_5 : f32 + %28 = arith.mulf %27, %cst_0 : f32 + %29 = arith.divf %28, %cst : f32 + %30 = arith.subf %29, %cst_5 : f32 + %31 = arith.cmpf olt, %30, %cst_2 : f32 + %32 = arith.select %31, %cst_2, %30 : f32 + %33 = arith.fptosi %32 : f32 to i32 + %34 = arith.addi %15, %33 : i32 + %35 = arith.index_cast %34 : i32 to index + %36 = memref.load %arg0[%35] : memref + %37 = arith.mulf %36, %18 : f32 + %38 = arith.sitofp %33 : i32 to f32 + %39 = arith.subf %32, %38 : f32 + %40 = arith.subf %cst_1, %39 : f32 + %41 = arith.mulf %37, %40 : f32 + %42 = arith.addi %33, %c1_i32 : i32 + %43 = arith.cmpi slt, %42, %c5_i32 : i32 + %44 = arith.select %43, %42, %33 : i32 + %45 = arith.addi %15, %44 : i32 + %46 = arith.index_cast %45 : i32 to index + %47 = memref.load %arg0[%46] : memref + %48 = arith.mulf %47, %18 : f32 + %49 = arith.mulf %48, %39 : f32 + %50 = arith.addf %41, %49 : f32 + %51 = arith.addi %23, %33 : i32 + %52 = arith.index_cast %51 : i32 to index + %53 = memref.load %arg0[%52] : memref + %54 = arith.mulf %53, %17 : f32 + %55 = arith.mulf %54, %40 : f32 + %56 = arith.addf %50, %55 : f32 + %57 = arith.addi %23, %44 : i32 + %58 = arith.index_cast %57 : i32 to index + %59 = memref.load %arg0[%58] : memref + %60 = arith.mulf %59, %17 : f32 + %61 = arith.mulf %60, %39 : f32 + %62 = arith.addf %56, %61 : f32 + linalg.yield %62 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu_debuf.mlir new file mode 100644 index 000000000000..5a42381bae66 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu_debuf.mlir @@ -0,0 +1,92 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 56 + d1 * 8)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e+00 : f32 + %cst_5 = arith.constant 8.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8) {map = #map} : (tensor, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.sitofp %9 : i32 to f32 + %11 = arith.addf %10, %cst : f32 + %12 = arith.mulf %11, %cst_0 : f32 + %13 = arith.divf %12, %cst_1 : f32 + %14 = arith.subf %13, %cst : f32 + %15 = arith.cmpf olt, %14, %cst_2 : f32 + %16 = arith.select %15, %cst_2, %14 : f32 + %17 = arith.fptosi %16 : f32 to i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = arith.sitofp %17 : i32 to f32 + %21 = arith.subf %16, %20 : f32 + %22 = arith.subf %cst_3, %21 : f32 + %23 = arith.addi %17, %c1_i32 : i32 + %24 = arith.cmpi slt, %23, %c4_i32 : i32 + %25 = arith.select %24, %23, %17 : i32 + %26 = arith.addi %7, %25 : i32 + %27 = arith.muli %26, %c5_i32 : i32 + %28 = linalg.index 2 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.sitofp %29 : i32 to f32 + %31 = arith.addf %30, %cst : f32 + %32 = arith.mulf %31, %cst_4 : f32 + %33 = arith.divf %32, %cst_5 : f32 + %34 = arith.subf %33, %cst : f32 + %35 = arith.cmpf olt, %34, %cst_2 : f32 + %36 = arith.select %35, %cst_2, %34 : f32 + %37 = arith.fptosi %36 : f32 to i32 + %38 = arith.addi %19, %37 : i32 + %39 = arith.index_cast %38 : i32 to index + %40 = memref.load %arg0[%39] : memref + %41 = arith.mulf %40, %22 : f32 + %42 = arith.sitofp %37 : i32 to f32 + %43 = arith.subf %36, %42 : f32 + %44 = arith.subf %cst_3, %43 : f32 + %45 = arith.mulf %41, %44 : f32 + %46 = arith.addi %37, %c1_i32 : i32 + %47 = arith.cmpi slt, %46, %c5_i32 : i32 + %48 = arith.select %47, %46, %37 : i32 + %49 = arith.addi %19, %48 : i32 + %50 = arith.index_cast %49 : i32 to index + %51 = memref.load %arg0[%50] : memref + %52 = arith.mulf %51, %22 : f32 + %53 = arith.mulf %52, %43 : f32 + %54 = arith.addf %45, %53 : f32 + %55 = arith.addi %27, %37 : i32 + %56 = arith.index_cast %55 : i32 to index + %57 = memref.load %arg0[%56] : memref + %58 = arith.mulf %57, %21 : f32 + %59 = arith.mulf %58, %44 : f32 + %60 = arith.addf %54, %59 : f32 + %61 = arith.addi %27, %48 : i32 + %62 = arith.index_cast %61 : i32 to index + %63 = memref.load %arg0[%62] : memref + %64 = arith.mulf %63, %21 : f32 + %65 = arith.mulf %64, %43 : f32 + %66 = arith.addf %60, %65 : f32 + linalg.yield %66 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8) {map = #map} : (tensor, tensor, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu_linalg.mlir new file mode 100644 index 000000000000..6bb83040f3ed --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_cpu_linalg.mlir @@ -0,0 +1,88 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 56 + d1 * 8)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 8.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e+00 : f32 + %cst_1 = arith.constant 1.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %cst_3 = arith.constant 7.000000e+00 : f32 + %cst_4 = arith.constant 4.000000e+00 : f32 + %cst_5 = arith.constant 5.000000e-01 : f32 + %0 = polygeist.submap(%arg1, %c2, %c7, %c8) {map = #map} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_5 : f32 + %8 = arith.mulf %7, %cst_4 : f32 + %9 = arith.divf %8, %cst_3 : f32 + %10 = arith.subf %9, %cst_5 : f32 + %11 = arith.cmpf olt, %10, %cst_2 : f32 + %12 = arith.select %11, %cst_2, %10 : f32 + %13 = arith.fptosi %12 : f32 to i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = arith.sitofp %13 : i32 to f32 + %17 = arith.subf %12, %16 : f32 + %18 = arith.subf %cst_1, %17 : f32 + %19 = arith.addi %13, %c1_i32 : i32 + %20 = arith.cmpi slt, %19, %c4_i32 : i32 + %21 = arith.select %20, %19, %13 : i32 + %22 = arith.addi %3, %21 : i32 + %23 = arith.muli %22, %c5_i32 : i32 + %24 = linalg.index 2 : index + %25 = arith.index_cast %24 : index to i32 + %26 = arith.sitofp %25 : i32 to f32 + %27 = arith.addf %26, %cst_5 : f32 + %28 = arith.mulf %27, %cst_0 : f32 + %29 = arith.divf %28, %cst : f32 + %30 = arith.subf %29, %cst_5 : f32 + %31 = arith.cmpf olt, %30, %cst_2 : f32 + %32 = arith.select %31, %cst_2, %30 : f32 + %33 = arith.fptosi %32 : f32 to i32 + %34 = arith.addi %15, %33 : i32 + %35 = arith.index_cast %34 : i32 to index + %36 = memref.load %arg0[%35] : memref + %37 = arith.mulf %36, %18 : f32 + %38 = arith.sitofp %33 : i32 to f32 + %39 = arith.subf %32, %38 : f32 + %40 = arith.subf %cst_1, %39 : f32 + %41 = arith.mulf %37, %40 : f32 + %42 = arith.addi %33, %c1_i32 : i32 + %43 = arith.cmpi slt, %42, %c5_i32 : i32 + %44 = arith.select %43, %42, %33 : i32 + %45 = arith.addi %15, %44 : i32 + %46 = arith.index_cast %45 : i32 to index + %47 = memref.load %arg0[%46] : memref + %48 = arith.mulf %47, %18 : f32 + %49 = arith.mulf %48, %39 : f32 + %50 = arith.addf %41, %49 : f32 + %51 = arith.addi %23, %33 : i32 + %52 = arith.index_cast %51 : i32 to index + %53 = memref.load %arg0[%52] : memref + %54 = arith.mulf %53, %17 : f32 + %55 = arith.mulf %54, %40 : f32 + %56 = arith.addf %50, %55 : f32 + %57 = arith.addi %23, %44 : i32 + %58 = arith.index_cast %57 : i32 to index + %59 = memref.load %arg0[%58] : memref + %60 = arith.mulf %59, %17 : f32 + %61 = arith.mulf %60, %39 : f32 + %62 = arith.addf %56, %61 : f32 + linalg.yield %62 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_debuf.mlir new file mode 100644 index 000000000000..9c07ce3790ae --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_debuf.mlir @@ -0,0 +1,77 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %c-1 = arith.constant -1 : index + %c8 = arith.constant 8 : index + %c3 = arith.constant 3 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0] [%c2, %c3, %c8, %c8] [1, 1, 1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = linalg.index 2 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.remsi %6, %c2_i32 : i32 + %8 = arith.sitofp %7 : i32 to f32 + %9 = arith.mulf %8, %cst : f32 + %10 = arith.subf %cst_0, %9 : f32 + %11 = arith.divsi %6, %c2_i32 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = arith.addi %11, %c1_i32 : i32 + %14 = arith.cmpi slt, %13, %c4_i32 : i32 + %15 = arith.select %14, %13, %11 : i32 + %16 = arith.index_cast %15 : i32 to index + %17 = arith.cmpi slt, %5, %c0 : index + %18 = arith.subi %c-1, %5 : index + %19 = arith.select %17, %18, %5 : index + %20 = arith.divsi %19, %c2 : index + %21 = arith.subi %c-1, %20 : index + %22 = arith.select %17, %21, %20 : index + %23 = linalg.index 3 : index + %24 = arith.index_cast %23 : index to i32 + %25 = arith.remsi %24, %c2_i32 : i32 + %26 = arith.sitofp %25 : i32 to f32 + %27 = arith.mulf %26, %cst : f32 + %28 = arith.subf %cst_0, %27 : f32 + %29 = arith.divsi %24, %c2_i32 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = arith.cmpi slt, %23, %c0 : index + %32 = arith.subi %c-1, %23 : index + %33 = arith.select %31, %32, %23 : index + %34 = arith.divsi %33, %c2 : index + %35 = arith.subi %c-1, %34 : index + %36 = arith.select %31, %35, %34 : index + %37 = memref.load %arg0[%3, %4, %22, %36] : memref + %38 = arith.mulf %28, %37 : f32 + %39 = arith.addi %29, %c1_i32 : i32 + %40 = arith.cmpi slt, %39, %c4_i32 : i32 + %41 = arith.select %40, %39, %29 : i32 + %42 = arith.index_cast %41 : i32 to index + %43 = memref.load %arg0[%3, %4, %12, %42] : memref + %44 = arith.mulf %27, %43 : f32 + %45 = arith.addf %38, %44 : f32 + %46 = arith.mulf %10, %45 : f32 + %47 = memref.load %arg0[%3, %4, %16, %30] : memref + %48 = arith.mulf %28, %47 : f32 + %49 = memref.load %arg0[%3, %4, %16, %42] : memref + %50 = arith.mulf %27, %49 : f32 + %51 = arith.addf %48, %50 : f32 + %52 = arith.mulf %9, %51 : f32 + %53 = arith.addf %46, %52 : f32 + linalg.yield %53 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0, 0, 0] [%c2, %c3, %c8, %c8] [1, 1, 1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_bilinear2d_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_linalg.mlir new file mode 100644 index 000000000000..7a5a145fba42 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_bilinear2d_linalg.mlir @@ -0,0 +1,73 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_bilinear2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c3 = arith.constant 3 : index + %c8 = arith.constant 8 : index + %c-1 = arith.constant -1 : index + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %subview = memref.subview %arg1[0, 0, 0, 0] [%c2, %c3, %c8, %c8] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = linalg.index 2 : index + %3 = arith.index_cast %2 : index to i32 + %4 = arith.remsi %3, %c2_i32 : i32 + %5 = arith.sitofp %4 : i32 to f32 + %6 = arith.mulf %5, %cst_0 : f32 + %7 = arith.subf %cst, %6 : f32 + %8 = arith.divsi %3, %c2_i32 : i32 + %9 = arith.index_cast %8 : i32 to index + %10 = arith.addi %8, %c1_i32 : i32 + %11 = arith.cmpi slt, %10, %c4_i32 : i32 + %12 = arith.select %11, %10, %8 : i32 + %13 = arith.index_cast %12 : i32 to index + %14 = arith.cmpi slt, %2, %c0 : index + %15 = arith.subi %c-1, %2 : index + %16 = arith.select %14, %15, %2 : index + %17 = arith.divsi %16, %c2 : index + %18 = arith.subi %c-1, %17 : index + %19 = arith.select %14, %18, %17 : index + %20 = linalg.index 3 : index + %21 = arith.index_cast %20 : index to i32 + %22 = arith.remsi %21, %c2_i32 : i32 + %23 = arith.sitofp %22 : i32 to f32 + %24 = arith.mulf %23, %cst_0 : f32 + %25 = arith.subf %cst, %24 : f32 + %26 = arith.divsi %21, %c2_i32 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = arith.cmpi slt, %20, %c0 : index + %29 = arith.subi %c-1, %20 : index + %30 = arith.select %28, %29, %20 : index + %31 = arith.divsi %30, %c2 : index + %32 = arith.subi %c-1, %31 : index + %33 = arith.select %28, %32, %31 : index + %34 = memref.load %arg0[%0, %1, %19, %33] : memref + %35 = arith.mulf %25, %34 : f32 + %36 = arith.addi %26, %c1_i32 : i32 + %37 = arith.cmpi slt, %36, %c4_i32 : i32 + %38 = arith.select %37, %36, %26 : i32 + %39 = arith.index_cast %38 : i32 to index + %40 = memref.load %arg0[%0, %1, %9, %39] : memref + %41 = arith.mulf %24, %40 : f32 + %42 = arith.addf %35, %41 : f32 + %43 = arith.mulf %7, %42 : f32 + %44 = memref.load %arg0[%0, %1, %13, %27] : memref + %45 = arith.mulf %25, %44 : f32 + %46 = memref.load %arg0[%0, %1, %13, %39] : memref + %47 = arith.mulf %24, %46 : f32 + %48 = arith.addf %45, %47 : f32 + %49 = arith.mulf %6, %48 : f32 + %50 = arith.addf %43, %49 : f32 + linalg.yield %50 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu.mlir new file mode 100644 index 000000000000..92ea33d27681 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu.mlir @@ -0,0 +1,172 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_lanczos2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant 3.28986812 : f32 + %cst_2 = arith.constant 3.14159274 : f32 + %cst_3 = arith.constant 3.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e-01 : f32 + %cst_5 = arith.constant 1.000000e+00 : f32 + %cst_6 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 40 { + affine.store %cst_6, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_4 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_4 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_4 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_4 : f32 + %10 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_6) -> (f32) { + %11 = arith.index_cast %arg5 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.subf %4, %12 : f32 + %14 = arith.cmpf olt, %13, %cst_6 : f32 + %15 = scf.if %14 -> (f32) { + %23 = arith.negf %13 : f32 + scf.yield %23 : f32 + } else { + scf.yield %13 : f32 + } + %16 = arith.cmpf olt, %15, %cst_3 : f32 + %17 = arith.cmpf oeq, %15, %cst_6 : f32 + %18 = arith.mulf %15, %cst_2 : f32 + %19 = arith.divf %18, %cst_3 : f32 + %20 = arith.mulf %15, %cst_1 : f32 + %21 = arith.mulf %20, %15 : f32 + %22 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %23 = arith.index_cast %arg7 : index to i32 + %24 = arith.sitofp %23 : i32 to f32 + %25 = arith.subf %9, %24 : f32 + %26 = arith.cmpf olt, %25, %cst_6 : f32 + %27 = scf.if %26 -> (f32) { + %34 = arith.negf %25 : f32 + scf.yield %34 : f32 + } else { + scf.yield %25 : f32 + } + %28 = scf.if %16 -> (f32) { + %34 = scf.if %17 -> (f32) { + scf.yield %cst_5 : f32 + } else { + %35 = func.call @sinf(%18) : (f32) -> f32 + %36 = func.call @sinf(%19) : (f32) -> f32 + %37 = arith.mulf %35, %36 : f32 + %38 = arith.divf %37, %21 : f32 + scf.yield %38 : f32 + } + scf.yield %34 : f32 + } else { + scf.yield %cst_6 : f32 + } + %29 = arith.cmpf olt, %27, %cst_3 : f32 + %30 = arith.cmpf oeq, %27, %cst_6 : f32 + %31 = scf.if %29 -> (f32) { + %34 = scf.if %30 -> (f32) { + scf.yield %cst_5 : f32 + } else { + %35 = arith.mulf %27, %cst_2 : f32 + %36 = func.call @sinf(%35) : (f32) -> f32 + %37 = arith.divf %35, %cst_3 : f32 + %38 = func.call @sinf(%37) : (f32) -> f32 + %39 = arith.mulf %36, %38 : f32 + %40 = arith.mulf %27, %cst_1 : f32 + %41 = arith.mulf %40, %27 : f32 + %42 = arith.divf %39, %41 : f32 + scf.yield %42 : f32 + } + scf.yield %34 : f32 + } else { + scf.yield %cst_6 : f32 + } + %32 = arith.mulf %28, %31 : f32 + %33 = arith.addf %arg8, %32 : f32 + affine.yield %33 : f32 + } + affine.yield %22 : f32 + } + affine.for %arg5 = 0 to 4 { + %11 = arith.index_cast %arg5 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.subf %4, %12 : f32 + %14 = arith.cmpf olt, %13, %cst_6 : f32 + %15 = scf.if %14 -> (f32) { + %22 = arith.negf %13 : f32 + scf.yield %22 : f32 + } else { + scf.yield %13 : f32 + } + %16 = arith.cmpf olt, %15, %cst_3 : f32 + %17 = arith.cmpf oeq, %15, %cst_6 : f32 + %18 = arith.mulf %15, %cst_2 : f32 + %19 = arith.divf %18, %cst_3 : f32 + %20 = arith.mulf %15, %cst_1 : f32 + %21 = arith.mulf %20, %15 : f32 + affine.for %arg6 = 0 to 5 { + %22 = arith.index_cast %arg6 : index to i32 + %23 = arith.sitofp %22 : i32 to f32 + %24 = arith.subf %9, %23 : f32 + %25 = arith.cmpf olt, %24, %cst_6 : f32 + %26 = scf.if %25 -> (f32) { + %37 = arith.negf %24 : f32 + scf.yield %37 : f32 + } else { + scf.yield %24 : f32 + } + %27 = scf.if %16 -> (f32) { + %37 = scf.if %17 -> (f32) { + scf.yield %cst_5 : f32 + } else { + %38 = func.call @sinf(%18) : (f32) -> f32 + %39 = func.call @sinf(%19) : (f32) -> f32 + %40 = arith.mulf %38, %39 : f32 + %41 = arith.divf %40, %21 : f32 + scf.yield %41 : f32 + } + scf.yield %37 : f32 + } else { + scf.yield %cst_6 : f32 + } + %28 = arith.cmpf olt, %26, %cst_3 : f32 + %29 = arith.cmpf oeq, %26, %cst_6 : f32 + %30 = scf.if %28 -> (f32) { + %37 = scf.if %29 -> (f32) { + scf.yield %cst_5 : f32 + } else { + %38 = arith.mulf %26, %cst_2 : f32 + %39 = func.call @sinf(%38) : (f32) -> f32 + %40 = arith.divf %38, %cst_3 : f32 + %41 = func.call @sinf(%40) : (f32) -> f32 + %42 = arith.mulf %39, %41 : f32 + %43 = arith.mulf %26, %cst_1 : f32 + %44 = arith.mulf %43, %26 : f32 + %45 = arith.divf %42, %44 : f32 + scf.yield %45 : f32 + } + scf.yield %37 : f32 + } else { + scf.yield %cst_6 : f32 + } + %31 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %32 = arith.mulf %31, %27 : f32 + %33 = arith.mulf %32, %30 : f32 + %34 = arith.divf %33, %10 : f32 + %35 = affine.load %arg1[%arg6 + %arg2 * 20 + %arg5 * 5] : memref + %36 = arith.addf %35, %34 : f32 + affine.store %36, %arg1[%arg6 + %arg2 * 20 + %arg5 * 5] : memref + } + } + } + } + } + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..3d1e47231814 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu/debuf.mlir @@ -0,0 +1,180 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map4 = affine_map<(d0, d1)[s0, s1, s2] -> (s0 + s1 * 56 + s2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_lanczos2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 3.000000e+00 : f32 + %cst_3 = arith.constant 3.14159274 : f32 + %cst_4 = arith.constant 3.28986812 : f32 + %cst_5 = arith.constant 6.250000e-01 : f32 + %cst_6 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %6 = arith.index_cast %arg4 : index to i32 + %7 = arith.sitofp %6 : i32 to f32 + %8 = arith.addf %7, %cst_1 : f32 + %9 = arith.mulf %8, %cst_6 : f32 + %10 = arith.subf %9, %cst_1 : f32 + %11 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %12 = arith.index_cast %arg6 : index to i32 + %13 = arith.sitofp %12 : i32 to f32 + %14 = arith.addf %13, %cst_1 : f32 + %15 = arith.mulf %14, %cst_5 : f32 + %16 = arith.subf %15, %cst_1 : f32 + %alloca = memref.alloca() : memref + %17 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %17[] : tensor + %18 = polygeist.submap(%inserted, %c4, %c5) {map = #map1} : (tensor, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%18 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_2 : f32 + %33 = arith.cmpf oeq, %31, %cst : f32 + %34 = arith.mulf %31, %cst_3 : f32 + %35 = arith.divf %34, %cst_2 : f32 + %36 = arith.mulf %31, %cst_4 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = linalg.index 1 : index + %39 = arith.index_cast %38 : index to i32 + %40 = arith.sitofp %39 : i32 to f32 + %41 = arith.subf %16, %40 : f32 + %42 = arith.cmpf olt, %41, %cst : f32 + %43 = arith.negf %41 : f32 + %44 = arith.select %42, %43, %41 : f32 + %45 = scf.if %32 -> (f32) { + %51 = scf.if %33 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %52 = math.sin %34 : f32 + %53 = math.sin %35 : f32 + %54 = arith.mulf %52, %53 : f32 + %55 = arith.divf %54, %37 : f32 + scf.yield %55 : f32 + } + scf.yield %51 : f32 + } else { + scf.yield %cst : f32 + } + %46 = arith.cmpf olt, %44, %cst_2 : f32 + %47 = arith.cmpf oeq, %44, %cst : f32 + %48 = scf.if %46 -> (f32) { + %51 = scf.if %47 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %52 = arith.mulf %44, %cst_3 : f32 + %53 = math.sin %52 : f32 + %54 = arith.divf %52, %cst_2 : f32 + %55 = math.sin %54 : f32 + %56 = arith.mulf %53, %55 : f32 + %57 = arith.mulf %44, %cst_4 : f32 + %58 = arith.mulf %57, %44 : f32 + %59 = arith.divf %56, %58 : f32 + scf.yield %59 : f32 + } + scf.yield %51 : f32 + } else { + scf.yield %cst : f32 + } + %49 = arith.mulf %45, %48 : f32 + %50 = arith.addf %out, %49 : f32 + linalg.yield %50 : f32 + } -> tensor + %20 = polygeist.submapInverse(%inserted, %19, %c4, %c5) {map = #map1} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %20[] : tensor + %21 = polygeist.submap(%arg7, %arg2, %c4, %c5) {map = #map3} : (tensor, index, index, index) -> tensor + %22 = polygeist.submap(%0, %arg6, %arg2, %arg4, %c4, %c5) {map = #map4} : (tensor, index, index, index, index, index) -> tensor + %23 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%22 : tensor) outs(%21 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_2 : f32 + %33 = arith.cmpf oeq, %31, %cst : f32 + %34 = arith.mulf %31, %cst_3 : f32 + %35 = arith.divf %34, %cst_2 : f32 + %36 = arith.mulf %31, %cst_4 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = linalg.index 1 : index + %39 = arith.index_cast %38 : index to i32 + %40 = arith.sitofp %39 : i32 to f32 + %41 = arith.subf %16, %40 : f32 + %42 = arith.cmpf olt, %41, %cst : f32 + %43 = arith.negf %41 : f32 + %44 = arith.select %42, %43, %41 : f32 + %45 = scf.if %32 -> (f32) { + %53 = scf.if %33 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %54 = math.sin %34 : f32 + %55 = math.sin %35 : f32 + %56 = arith.mulf %54, %55 : f32 + %57 = arith.divf %56, %37 : f32 + scf.yield %57 : f32 + } + scf.yield %53 : f32 + } else { + scf.yield %cst : f32 + } + %46 = arith.cmpf olt, %44, %cst_2 : f32 + %47 = arith.cmpf oeq, %44, %cst : f32 + %48 = scf.if %46 -> (f32) { + %53 = scf.if %47 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %54 = arith.mulf %44, %cst_3 : f32 + %55 = math.sin %54 : f32 + %56 = arith.divf %54, %cst_2 : f32 + %57 = math.sin %56 : f32 + %58 = arith.mulf %55, %57 : f32 + %59 = arith.mulf %44, %cst_4 : f32 + %60 = arith.mulf %59, %44 : f32 + %61 = arith.divf %58, %60 : f32 + scf.yield %61 : f32 + } + scf.yield %53 : f32 + } else { + scf.yield %cst : f32 + } + %49 = arith.mulf %in, %45 : f32 + %50 = arith.mulf %49, %48 : f32 + %51 = arith.divf %50, %extracted : f32 + %52 = arith.addf %out, %51 : f32 + linalg.yield %52 : f32 + } -> tensor + %24 = polygeist.submapInverse(%arg7, %23, %arg2, %c4, %c5) {map = #map3} : (tensor, tensor, index, index, index) -> tensor + affine.yield %24 : tensor + } + affine.yield %11 : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu/matched.mlir new file mode 100644 index 000000000000..590d7ad3377d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu/matched.mlir @@ -0,0 +1,177 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map4 = affine_map<(d0, d1)[s0, s1, s2] -> (s0 + s1 * 56 + s2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_lanczos2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 3.000000e+00 : f32 + %cst_3 = arith.constant 3.14159274 : f32 + %cst_4 = arith.constant 3.28986812 : f32 + %cst_5 = arith.constant 6.250000e-01 : f32 + %cst_6 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = kernel.launch @memset_zero_1D_f32(%1) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %6 = arith.index_cast %arg4 : index to i32 + %7 = arith.sitofp %6 : i32 to f32 + %8 = arith.addf %7, %cst_1 : f32 + %9 = arith.mulf %8, %cst_6 : f32 + %10 = arith.subf %9, %cst_1 : f32 + %11 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %12 = arith.index_cast %arg6 : index to i32 + %13 = arith.sitofp %12 : i32 to f32 + %14 = arith.addf %13, %cst_1 : f32 + %15 = arith.mulf %14, %cst_5 : f32 + %16 = arith.subf %15, %cst_1 : f32 + %alloca = memref.alloca() : memref + %17 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %17[] : tensor + %18 = polygeist.submap(%inserted, %c4, %c5) {map = #map1} : (tensor, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%18 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_2 : f32 + %33 = arith.cmpf oeq, %31, %cst : f32 + %34 = arith.mulf %31, %cst_3 : f32 + %35 = arith.divf %34, %cst_2 : f32 + %36 = arith.mulf %31, %cst_4 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = linalg.index 1 : index + %39 = arith.index_cast %38 : index to i32 + %40 = arith.sitofp %39 : i32 to f32 + %41 = arith.subf %16, %40 : f32 + %42 = arith.cmpf olt, %41, %cst : f32 + %43 = arith.negf %41 : f32 + %44 = arith.select %42, %43, %41 : f32 + %45 = scf.if %32 -> (f32) { + %51 = scf.if %33 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %52 = math.sin %34 : f32 + %53 = math.sin %35 : f32 + %54 = arith.mulf %52, %53 : f32 + %55 = arith.divf %54, %37 : f32 + scf.yield %55 : f32 + } + scf.yield %51 : f32 + } else { + scf.yield %cst : f32 + } + %46 = arith.cmpf olt, %44, %cst_2 : f32 + %47 = arith.cmpf oeq, %44, %cst : f32 + %48 = scf.if %46 -> (f32) { + %51 = scf.if %47 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %52 = arith.mulf %44, %cst_3 : f32 + %53 = math.sin %52 : f32 + %54 = arith.divf %52, %cst_2 : f32 + %55 = math.sin %54 : f32 + %56 = arith.mulf %53, %55 : f32 + %57 = arith.mulf %44, %cst_4 : f32 + %58 = arith.mulf %57, %44 : f32 + %59 = arith.divf %56, %58 : f32 + scf.yield %59 : f32 + } + scf.yield %51 : f32 + } else { + scf.yield %cst : f32 + } + %49 = arith.mulf %45, %48 : f32 + %50 = arith.addf %out, %49 : f32 + linalg.yield %50 : f32 + } -> tensor + %20 = polygeist.submapInverse(%inserted, %19, %c4, %c5) {map = #map1} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %20[] : tensor + %21 = polygeist.submap(%arg7, %arg2, %c4, %c5) {map = #map3} : (tensor, index, index, index) -> tensor + %22 = polygeist.submap(%0, %arg6, %arg2, %arg4, %c4, %c5) {map = #map4} : (tensor, index, index, index, index, index) -> tensor + %23 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%22 : tensor) outs(%21 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_2 : f32 + %33 = arith.cmpf oeq, %31, %cst : f32 + %34 = arith.mulf %31, %cst_3 : f32 + %35 = arith.divf %34, %cst_2 : f32 + %36 = arith.mulf %31, %cst_4 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = linalg.index 1 : index + %39 = arith.index_cast %38 : index to i32 + %40 = arith.sitofp %39 : i32 to f32 + %41 = arith.subf %16, %40 : f32 + %42 = arith.cmpf olt, %41, %cst : f32 + %43 = arith.negf %41 : f32 + %44 = arith.select %42, %43, %41 : f32 + %45 = scf.if %32 -> (f32) { + %53 = scf.if %33 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %54 = math.sin %34 : f32 + %55 = math.sin %35 : f32 + %56 = arith.mulf %54, %55 : f32 + %57 = arith.divf %56, %37 : f32 + scf.yield %57 : f32 + } + scf.yield %53 : f32 + } else { + scf.yield %cst : f32 + } + %46 = arith.cmpf olt, %44, %cst_2 : f32 + %47 = arith.cmpf oeq, %44, %cst : f32 + %48 = scf.if %46 -> (f32) { + %53 = scf.if %47 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %54 = arith.mulf %44, %cst_3 : f32 + %55 = math.sin %54 : f32 + %56 = arith.divf %54, %cst_2 : f32 + %57 = math.sin %56 : f32 + %58 = arith.mulf %55, %57 : f32 + %59 = arith.mulf %44, %cst_4 : f32 + %60 = arith.mulf %59, %44 : f32 + %61 = arith.divf %58, %60 : f32 + scf.yield %61 : f32 + } + scf.yield %53 : f32 + } else { + scf.yield %cst : f32 + } + %49 = arith.mulf %in, %45 : f32 + %50 = arith.mulf %49, %48 : f32 + %51 = arith.divf %50, %extracted : f32 + %52 = arith.addf %out, %51 : f32 + linalg.yield %52 : f32 + } -> tensor + %24 = polygeist.submapInverse(%arg7, %23, %arg2, %c4, %c5) {map = #map3} : (tensor, tensor, index, index, index) -> tensor + affine.yield %24 : tensor + } + affine.yield %11 : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu/orig.mlir new file mode 100644 index 000000000000..92ea33d27681 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu/orig.mlir @@ -0,0 +1,172 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_lanczos2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant 3.28986812 : f32 + %cst_2 = arith.constant 3.14159274 : f32 + %cst_3 = arith.constant 3.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e-01 : f32 + %cst_5 = arith.constant 1.000000e+00 : f32 + %cst_6 = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 40 { + affine.store %cst_6, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_4 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_4 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_4 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_4 : f32 + %10 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_6) -> (f32) { + %11 = arith.index_cast %arg5 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.subf %4, %12 : f32 + %14 = arith.cmpf olt, %13, %cst_6 : f32 + %15 = scf.if %14 -> (f32) { + %23 = arith.negf %13 : f32 + scf.yield %23 : f32 + } else { + scf.yield %13 : f32 + } + %16 = arith.cmpf olt, %15, %cst_3 : f32 + %17 = arith.cmpf oeq, %15, %cst_6 : f32 + %18 = arith.mulf %15, %cst_2 : f32 + %19 = arith.divf %18, %cst_3 : f32 + %20 = arith.mulf %15, %cst_1 : f32 + %21 = arith.mulf %20, %15 : f32 + %22 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %23 = arith.index_cast %arg7 : index to i32 + %24 = arith.sitofp %23 : i32 to f32 + %25 = arith.subf %9, %24 : f32 + %26 = arith.cmpf olt, %25, %cst_6 : f32 + %27 = scf.if %26 -> (f32) { + %34 = arith.negf %25 : f32 + scf.yield %34 : f32 + } else { + scf.yield %25 : f32 + } + %28 = scf.if %16 -> (f32) { + %34 = scf.if %17 -> (f32) { + scf.yield %cst_5 : f32 + } else { + %35 = func.call @sinf(%18) : (f32) -> f32 + %36 = func.call @sinf(%19) : (f32) -> f32 + %37 = arith.mulf %35, %36 : f32 + %38 = arith.divf %37, %21 : f32 + scf.yield %38 : f32 + } + scf.yield %34 : f32 + } else { + scf.yield %cst_6 : f32 + } + %29 = arith.cmpf olt, %27, %cst_3 : f32 + %30 = arith.cmpf oeq, %27, %cst_6 : f32 + %31 = scf.if %29 -> (f32) { + %34 = scf.if %30 -> (f32) { + scf.yield %cst_5 : f32 + } else { + %35 = arith.mulf %27, %cst_2 : f32 + %36 = func.call @sinf(%35) : (f32) -> f32 + %37 = arith.divf %35, %cst_3 : f32 + %38 = func.call @sinf(%37) : (f32) -> f32 + %39 = arith.mulf %36, %38 : f32 + %40 = arith.mulf %27, %cst_1 : f32 + %41 = arith.mulf %40, %27 : f32 + %42 = arith.divf %39, %41 : f32 + scf.yield %42 : f32 + } + scf.yield %34 : f32 + } else { + scf.yield %cst_6 : f32 + } + %32 = arith.mulf %28, %31 : f32 + %33 = arith.addf %arg8, %32 : f32 + affine.yield %33 : f32 + } + affine.yield %22 : f32 + } + affine.for %arg5 = 0 to 4 { + %11 = arith.index_cast %arg5 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.subf %4, %12 : f32 + %14 = arith.cmpf olt, %13, %cst_6 : f32 + %15 = scf.if %14 -> (f32) { + %22 = arith.negf %13 : f32 + scf.yield %22 : f32 + } else { + scf.yield %13 : f32 + } + %16 = arith.cmpf olt, %15, %cst_3 : f32 + %17 = arith.cmpf oeq, %15, %cst_6 : f32 + %18 = arith.mulf %15, %cst_2 : f32 + %19 = arith.divf %18, %cst_3 : f32 + %20 = arith.mulf %15, %cst_1 : f32 + %21 = arith.mulf %20, %15 : f32 + affine.for %arg6 = 0 to 5 { + %22 = arith.index_cast %arg6 : index to i32 + %23 = arith.sitofp %22 : i32 to f32 + %24 = arith.subf %9, %23 : f32 + %25 = arith.cmpf olt, %24, %cst_6 : f32 + %26 = scf.if %25 -> (f32) { + %37 = arith.negf %24 : f32 + scf.yield %37 : f32 + } else { + scf.yield %24 : f32 + } + %27 = scf.if %16 -> (f32) { + %37 = scf.if %17 -> (f32) { + scf.yield %cst_5 : f32 + } else { + %38 = func.call @sinf(%18) : (f32) -> f32 + %39 = func.call @sinf(%19) : (f32) -> f32 + %40 = arith.mulf %38, %39 : f32 + %41 = arith.divf %40, %21 : f32 + scf.yield %41 : f32 + } + scf.yield %37 : f32 + } else { + scf.yield %cst_6 : f32 + } + %28 = arith.cmpf olt, %26, %cst_3 : f32 + %29 = arith.cmpf oeq, %26, %cst_6 : f32 + %30 = scf.if %28 -> (f32) { + %37 = scf.if %29 -> (f32) { + scf.yield %cst_5 : f32 + } else { + %38 = arith.mulf %26, %cst_2 : f32 + %39 = func.call @sinf(%38) : (f32) -> f32 + %40 = arith.divf %38, %cst_3 : f32 + %41 = func.call @sinf(%40) : (f32) -> f32 + %42 = arith.mulf %39, %41 : f32 + %43 = arith.mulf %26, %cst_1 : f32 + %44 = arith.mulf %43, %26 : f32 + %45 = arith.divf %42, %44 : f32 + scf.yield %45 : f32 + } + scf.yield %37 : f32 + } else { + scf.yield %cst_6 : f32 + } + %31 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %32 = arith.mulf %31, %27 : f32 + %33 = arith.mulf %32, %30 : f32 + %34 = arith.divf %33, %10 : f32 + %35 = affine.load %arg1[%arg6 + %arg2 * 20 + %arg5 * 5] : memref + %36 = arith.addf %35, %34 : f32 + affine.store %36, %arg1[%arg6 + %arg2 * 20 + %arg5 * 5] : memref + } + } + } + } + } + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu/raised.mlir new file mode 100644 index 000000000000..54f7118e9d8d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu/raised.mlir @@ -0,0 +1,170 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1)[s0, s1, s2] -> (s0 + s1 * 56 + s2 * 8)> +#map4 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_lanczos2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant 3.28986812 : f32 + %cst_2 = arith.constant 3.14159274 : f32 + %cst_3 = arith.constant 3.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e-01 : f32 + %cst_5 = arith.constant 1.000000e+00 : f32 + %cst_6 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_6 : f32 + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_4 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_4 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_4 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_4 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_6, %alloca[] : memref + %10 = polygeist.submap(%alloca, %c4, %c5) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map2], iterator_types = ["reduction", "reduction"]} outs(%10 : memref) { + ^bb0(%out: f32): + %14 = linalg.index 0 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.sitofp %15 : i32 to f32 + %17 = arith.subf %4, %16 : f32 + %18 = arith.cmpf olt, %17, %cst_6 : f32 + %19 = arith.negf %17 : f32 + %20 = arith.select %18, %19, %17 : f32 + %21 = arith.cmpf olt, %20, %cst_3 : f32 + %22 = arith.cmpf oeq, %20, %cst_6 : f32 + %23 = arith.mulf %20, %cst_2 : f32 + %24 = arith.divf %23, %cst_3 : f32 + %25 = arith.mulf %20, %cst_1 : f32 + %26 = arith.mulf %25, %20 : f32 + %27 = linalg.index 1 : index + %28 = arith.index_cast %27 : index to i32 + %29 = arith.sitofp %28 : i32 to f32 + %30 = arith.subf %9, %29 : f32 + %31 = arith.cmpf olt, %30, %cst_6 : f32 + %32 = arith.negf %30 : f32 + %33 = arith.select %31, %32, %30 : f32 + %34 = scf.if %21 -> (f32) { + %40 = scf.if %22 -> (f32) { + scf.yield %cst_5 : f32 + } else { + %41 = math.sin %23 : f32 + %42 = math.sin %24 : f32 + %43 = arith.mulf %41, %42 : f32 + %44 = arith.divf %43, %26 : f32 + scf.yield %44 : f32 + } + scf.yield %40 : f32 + } else { + scf.yield %cst_6 : f32 + } + %35 = arith.cmpf olt, %33, %cst_3 : f32 + %36 = arith.cmpf oeq, %33, %cst_6 : f32 + %37 = scf.if %35 -> (f32) { + %40 = scf.if %36 -> (f32) { + scf.yield %cst_5 : f32 + } else { + %41 = arith.mulf %33, %cst_2 : f32 + %42 = math.sin %41 : f32 + %43 = arith.divf %41, %cst_3 : f32 + %44 = math.sin %43 : f32 + %45 = arith.mulf %42, %44 : f32 + %46 = arith.mulf %33, %cst_1 : f32 + %47 = arith.mulf %46, %33 : f32 + %48 = arith.divf %45, %47 : f32 + scf.yield %48 : f32 + } + scf.yield %40 : f32 + } else { + scf.yield %cst_6 : f32 + } + %38 = arith.mulf %34, %37 : f32 + %39 = arith.addf %out, %38 : f32 + linalg.yield %39 : f32 + } + %11 = affine.load %alloca[] : memref + %12 = polygeist.submap(%arg0, %arg4, %arg2, %arg3, %c4, %c5) {map = #map3} : (memref, index, index, index, index, index) -> memref + %13 = polygeist.submap(%arg1, %arg2, %c4, %c5) {map = #map4} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%12 : memref) outs(%13 : memref) { + ^bb0(%in: f32, %out: f32): + %14 = linalg.index 0 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.sitofp %15 : i32 to f32 + %17 = arith.subf %4, %16 : f32 + %18 = arith.cmpf olt, %17, %cst_6 : f32 + %19 = arith.negf %17 : f32 + %20 = arith.select %18, %19, %17 : f32 + %21 = arith.cmpf olt, %20, %cst_3 : f32 + %22 = arith.cmpf oeq, %20, %cst_6 : f32 + %23 = arith.mulf %20, %cst_2 : f32 + %24 = arith.divf %23, %cst_3 : f32 + %25 = arith.mulf %20, %cst_1 : f32 + %26 = arith.mulf %25, %20 : f32 + %27 = linalg.index 1 : index + %28 = arith.index_cast %27 : index to i32 + %29 = arith.sitofp %28 : i32 to f32 + %30 = arith.subf %9, %29 : f32 + %31 = arith.cmpf olt, %30, %cst_6 : f32 + %32 = arith.negf %30 : f32 + %33 = arith.select %31, %32, %30 : f32 + %34 = scf.if %21 -> (f32) { + %42 = scf.if %22 -> (f32) { + scf.yield %cst_5 : f32 + } else { + %43 = math.sin %23 : f32 + %44 = math.sin %24 : f32 + %45 = arith.mulf %43, %44 : f32 + %46 = arith.divf %45, %26 : f32 + scf.yield %46 : f32 + } + scf.yield %42 : f32 + } else { + scf.yield %cst_6 : f32 + } + %35 = arith.cmpf olt, %33, %cst_3 : f32 + %36 = arith.cmpf oeq, %33, %cst_6 : f32 + %37 = scf.if %35 -> (f32) { + %42 = scf.if %36 -> (f32) { + scf.yield %cst_5 : f32 + } else { + %43 = arith.mulf %33, %cst_2 : f32 + %44 = math.sin %43 : f32 + %45 = arith.divf %43, %cst_3 : f32 + %46 = math.sin %45 : f32 + %47 = arith.mulf %44, %46 : f32 + %48 = arith.mulf %33, %cst_1 : f32 + %49 = arith.mulf %48, %33 : f32 + %50 = arith.divf %47, %49 : f32 + scf.yield %50 : f32 + } + scf.yield %42 : f32 + } else { + scf.yield %cst_6 : f32 + } + %38 = arith.mulf %in, %34 : f32 + %39 = arith.mulf %38, %37 : f32 + %40 = arith.divf %39, %11 : f32 + %41 = arith.addf %out, %40 : f32 + linalg.yield %41 : f32 + } + } + } + } + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..3d1e47231814 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu_debuf.mlir @@ -0,0 +1,180 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map4 = affine_map<(d0, d1)[s0, s1, s2] -> (s0 + s1 * 56 + s2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_lanczos2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 1.000000e+00 : f32 + %cst_1 = arith.constant 5.000000e-01 : f32 + %cst_2 = arith.constant 3.000000e+00 : f32 + %cst_3 = arith.constant 3.14159274 : f32 + %cst_4 = arith.constant 3.28986812 : f32 + %cst_5 = arith.constant 6.250000e-01 : f32 + %cst_6 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %6 = arith.index_cast %arg4 : index to i32 + %7 = arith.sitofp %6 : i32 to f32 + %8 = arith.addf %7, %cst_1 : f32 + %9 = arith.mulf %8, %cst_6 : f32 + %10 = arith.subf %9, %cst_1 : f32 + %11 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %12 = arith.index_cast %arg6 : index to i32 + %13 = arith.sitofp %12 : i32 to f32 + %14 = arith.addf %13, %cst_1 : f32 + %15 = arith.mulf %14, %cst_5 : f32 + %16 = arith.subf %15, %cst_1 : f32 + %alloca = memref.alloca() : memref + %17 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %17[] : tensor + %18 = polygeist.submap(%inserted, %c4, %c5) {map = #map1} : (tensor, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%18 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_2 : f32 + %33 = arith.cmpf oeq, %31, %cst : f32 + %34 = arith.mulf %31, %cst_3 : f32 + %35 = arith.divf %34, %cst_2 : f32 + %36 = arith.mulf %31, %cst_4 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = linalg.index 1 : index + %39 = arith.index_cast %38 : index to i32 + %40 = arith.sitofp %39 : i32 to f32 + %41 = arith.subf %16, %40 : f32 + %42 = arith.cmpf olt, %41, %cst : f32 + %43 = arith.negf %41 : f32 + %44 = arith.select %42, %43, %41 : f32 + %45 = scf.if %32 -> (f32) { + %51 = scf.if %33 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %52 = math.sin %34 : f32 + %53 = math.sin %35 : f32 + %54 = arith.mulf %52, %53 : f32 + %55 = arith.divf %54, %37 : f32 + scf.yield %55 : f32 + } + scf.yield %51 : f32 + } else { + scf.yield %cst : f32 + } + %46 = arith.cmpf olt, %44, %cst_2 : f32 + %47 = arith.cmpf oeq, %44, %cst : f32 + %48 = scf.if %46 -> (f32) { + %51 = scf.if %47 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %52 = arith.mulf %44, %cst_3 : f32 + %53 = math.sin %52 : f32 + %54 = arith.divf %52, %cst_2 : f32 + %55 = math.sin %54 : f32 + %56 = arith.mulf %53, %55 : f32 + %57 = arith.mulf %44, %cst_4 : f32 + %58 = arith.mulf %57, %44 : f32 + %59 = arith.divf %56, %58 : f32 + scf.yield %59 : f32 + } + scf.yield %51 : f32 + } else { + scf.yield %cst : f32 + } + %49 = arith.mulf %45, %48 : f32 + %50 = arith.addf %out, %49 : f32 + linalg.yield %50 : f32 + } -> tensor + %20 = polygeist.submapInverse(%inserted, %19, %c4, %c5) {map = #map1} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %20[] : tensor + %21 = polygeist.submap(%arg7, %arg2, %c4, %c5) {map = #map3} : (tensor, index, index, index) -> tensor + %22 = polygeist.submap(%0, %arg6, %arg2, %arg4, %c4, %c5) {map = #map4} : (tensor, index, index, index, index, index) -> tensor + %23 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%22 : tensor) outs(%21 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %10, %27 : f32 + %29 = arith.cmpf olt, %28, %cst : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_2 : f32 + %33 = arith.cmpf oeq, %31, %cst : f32 + %34 = arith.mulf %31, %cst_3 : f32 + %35 = arith.divf %34, %cst_2 : f32 + %36 = arith.mulf %31, %cst_4 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = linalg.index 1 : index + %39 = arith.index_cast %38 : index to i32 + %40 = arith.sitofp %39 : i32 to f32 + %41 = arith.subf %16, %40 : f32 + %42 = arith.cmpf olt, %41, %cst : f32 + %43 = arith.negf %41 : f32 + %44 = arith.select %42, %43, %41 : f32 + %45 = scf.if %32 -> (f32) { + %53 = scf.if %33 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %54 = math.sin %34 : f32 + %55 = math.sin %35 : f32 + %56 = arith.mulf %54, %55 : f32 + %57 = arith.divf %56, %37 : f32 + scf.yield %57 : f32 + } + scf.yield %53 : f32 + } else { + scf.yield %cst : f32 + } + %46 = arith.cmpf olt, %44, %cst_2 : f32 + %47 = arith.cmpf oeq, %44, %cst : f32 + %48 = scf.if %46 -> (f32) { + %53 = scf.if %47 -> (f32) { + scf.yield %cst_0 : f32 + } else { + %54 = arith.mulf %44, %cst_3 : f32 + %55 = math.sin %54 : f32 + %56 = arith.divf %54, %cst_2 : f32 + %57 = math.sin %56 : f32 + %58 = arith.mulf %55, %57 : f32 + %59 = arith.mulf %44, %cst_4 : f32 + %60 = arith.mulf %59, %44 : f32 + %61 = arith.divf %58, %60 : f32 + scf.yield %61 : f32 + } + scf.yield %53 : f32 + } else { + scf.yield %cst : f32 + } + %49 = arith.mulf %in, %45 : f32 + %50 = arith.mulf %49, %48 : f32 + %51 = arith.divf %50, %extracted : f32 + %52 = arith.addf %out, %51 : f32 + linalg.yield %52 : f32 + } -> tensor + %24 = polygeist.submapInverse(%arg7, %23, %arg2, %c4, %c5) {map = #map3} : (tensor, tensor, index, index, index) -> tensor + affine.yield %24 : tensor + } + affine.yield %11 : tensor + } + affine.yield %5 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..54f7118e9d8d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_backward_cpu_linalg.mlir @@ -0,0 +1,170 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> ()> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1)[s0, s1, s2] -> (s0 + s1 * 56 + s2 * 8)> +#map4 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_lanczos2d_aa_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant 3.28986812 : f32 + %cst_2 = arith.constant 3.14159274 : f32 + %cst_3 = arith.constant 3.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e-01 : f32 + %cst_5 = arith.constant 1.000000e+00 : f32 + %cst_6 = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_6 : f32 + } + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_4 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_4 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_4 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_4 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_6, %alloca[] : memref + %10 = polygeist.submap(%alloca, %c4, %c5) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map2], iterator_types = ["reduction", "reduction"]} outs(%10 : memref) { + ^bb0(%out: f32): + %14 = linalg.index 0 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.sitofp %15 : i32 to f32 + %17 = arith.subf %4, %16 : f32 + %18 = arith.cmpf olt, %17, %cst_6 : f32 + %19 = arith.negf %17 : f32 + %20 = arith.select %18, %19, %17 : f32 + %21 = arith.cmpf olt, %20, %cst_3 : f32 + %22 = arith.cmpf oeq, %20, %cst_6 : f32 + %23 = arith.mulf %20, %cst_2 : f32 + %24 = arith.divf %23, %cst_3 : f32 + %25 = arith.mulf %20, %cst_1 : f32 + %26 = arith.mulf %25, %20 : f32 + %27 = linalg.index 1 : index + %28 = arith.index_cast %27 : index to i32 + %29 = arith.sitofp %28 : i32 to f32 + %30 = arith.subf %9, %29 : f32 + %31 = arith.cmpf olt, %30, %cst_6 : f32 + %32 = arith.negf %30 : f32 + %33 = arith.select %31, %32, %30 : f32 + %34 = scf.if %21 -> (f32) { + %40 = scf.if %22 -> (f32) { + scf.yield %cst_5 : f32 + } else { + %41 = math.sin %23 : f32 + %42 = math.sin %24 : f32 + %43 = arith.mulf %41, %42 : f32 + %44 = arith.divf %43, %26 : f32 + scf.yield %44 : f32 + } + scf.yield %40 : f32 + } else { + scf.yield %cst_6 : f32 + } + %35 = arith.cmpf olt, %33, %cst_3 : f32 + %36 = arith.cmpf oeq, %33, %cst_6 : f32 + %37 = scf.if %35 -> (f32) { + %40 = scf.if %36 -> (f32) { + scf.yield %cst_5 : f32 + } else { + %41 = arith.mulf %33, %cst_2 : f32 + %42 = math.sin %41 : f32 + %43 = arith.divf %41, %cst_3 : f32 + %44 = math.sin %43 : f32 + %45 = arith.mulf %42, %44 : f32 + %46 = arith.mulf %33, %cst_1 : f32 + %47 = arith.mulf %46, %33 : f32 + %48 = arith.divf %45, %47 : f32 + scf.yield %48 : f32 + } + scf.yield %40 : f32 + } else { + scf.yield %cst_6 : f32 + } + %38 = arith.mulf %34, %37 : f32 + %39 = arith.addf %out, %38 : f32 + linalg.yield %39 : f32 + } + %11 = affine.load %alloca[] : memref + %12 = polygeist.submap(%arg0, %arg4, %arg2, %arg3, %c4, %c5) {map = #map3} : (memref, index, index, index, index, index) -> memref + %13 = polygeist.submap(%arg1, %arg2, %c4, %c5) {map = #map4} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%12 : memref) outs(%13 : memref) { + ^bb0(%in: f32, %out: f32): + %14 = linalg.index 0 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.sitofp %15 : i32 to f32 + %17 = arith.subf %4, %16 : f32 + %18 = arith.cmpf olt, %17, %cst_6 : f32 + %19 = arith.negf %17 : f32 + %20 = arith.select %18, %19, %17 : f32 + %21 = arith.cmpf olt, %20, %cst_3 : f32 + %22 = arith.cmpf oeq, %20, %cst_6 : f32 + %23 = arith.mulf %20, %cst_2 : f32 + %24 = arith.divf %23, %cst_3 : f32 + %25 = arith.mulf %20, %cst_1 : f32 + %26 = arith.mulf %25, %20 : f32 + %27 = linalg.index 1 : index + %28 = arith.index_cast %27 : index to i32 + %29 = arith.sitofp %28 : i32 to f32 + %30 = arith.subf %9, %29 : f32 + %31 = arith.cmpf olt, %30, %cst_6 : f32 + %32 = arith.negf %30 : f32 + %33 = arith.select %31, %32, %30 : f32 + %34 = scf.if %21 -> (f32) { + %42 = scf.if %22 -> (f32) { + scf.yield %cst_5 : f32 + } else { + %43 = math.sin %23 : f32 + %44 = math.sin %24 : f32 + %45 = arith.mulf %43, %44 : f32 + %46 = arith.divf %45, %26 : f32 + scf.yield %46 : f32 + } + scf.yield %42 : f32 + } else { + scf.yield %cst_6 : f32 + } + %35 = arith.cmpf olt, %33, %cst_3 : f32 + %36 = arith.cmpf oeq, %33, %cst_6 : f32 + %37 = scf.if %35 -> (f32) { + %42 = scf.if %36 -> (f32) { + scf.yield %cst_5 : f32 + } else { + %43 = arith.mulf %33, %cst_2 : f32 + %44 = math.sin %43 : f32 + %45 = arith.divf %43, %cst_3 : f32 + %46 = math.sin %45 : f32 + %47 = arith.mulf %44, %46 : f32 + %48 = arith.mulf %33, %cst_1 : f32 + %49 = arith.mulf %48, %33 : f32 + %50 = arith.divf %47, %49 : f32 + scf.yield %50 : f32 + } + scf.yield %42 : f32 + } else { + scf.yield %cst_6 : f32 + } + %38 = arith.mulf %in, %34 : f32 + %39 = arith.mulf %38, %37 : f32 + %40 = arith.divf %39, %11 : f32 + %41 = arith.addf %out, %40 : f32 + linalg.yield %41 : f32 + } + } + } + } + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu.mlir new file mode 100644 index 000000000000..10c800f417ef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu.mlir @@ -0,0 +1,170 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_lanczos2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant 3.28986812 : f32 + %cst_2 = arith.constant 3.14159274 : f32 + %cst_3 = arith.constant 3.000000e+00 : f32 + %cst_4 = arith.constant 0.000000e+00 : f32 + %cst_5 = arith.constant 5.000000e-01 : f32 + %cst_6 = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_5 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_5 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_5 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_5 : f32 + %10 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_4) -> (f32) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.sitofp %13 : i32 to f32 + %15 = arith.subf %4, %14 : f32 + %16 = arith.cmpf olt, %15, %cst_4 : f32 + %17 = scf.if %16 -> (f32) { + %25 = arith.negf %15 : f32 + scf.yield %25 : f32 + } else { + scf.yield %15 : f32 + } + %18 = arith.cmpf olt, %17, %cst_3 : f32 + %19 = arith.cmpf oeq, %17, %cst_4 : f32 + %20 = arith.mulf %17, %cst_2 : f32 + %21 = arith.divf %20, %cst_3 : f32 + %22 = arith.mulf %17, %cst_1 : f32 + %23 = arith.mulf %22, %17 : f32 + %24 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %25 = arith.index_cast %arg7 : index to i32 + %26 = arith.sitofp %25 : i32 to f32 + %27 = arith.subf %9, %26 : f32 + %28 = arith.cmpf olt, %27, %cst_4 : f32 + %29 = scf.if %28 -> (f32) { + %36 = arith.negf %27 : f32 + scf.yield %36 : f32 + } else { + scf.yield %27 : f32 + } + %30 = scf.if %18 -> (f32) { + %36 = scf.if %19 -> (f32) { + scf.yield %cst_6 : f32 + } else { + %37 = func.call @sinf(%20) : (f32) -> f32 + %38 = func.call @sinf(%21) : (f32) -> f32 + %39 = arith.mulf %37, %38 : f32 + %40 = arith.divf %39, %23 : f32 + scf.yield %40 : f32 + } + scf.yield %36 : f32 + } else { + scf.yield %cst_4 : f32 + } + %31 = arith.cmpf olt, %29, %cst_3 : f32 + %32 = arith.cmpf oeq, %29, %cst_4 : f32 + %33 = scf.if %31 -> (f32) { + %36 = scf.if %32 -> (f32) { + scf.yield %cst_6 : f32 + } else { + %37 = arith.mulf %29, %cst_2 : f32 + %38 = func.call @sinf(%37) : (f32) -> f32 + %39 = arith.divf %37, %cst_3 : f32 + %40 = func.call @sinf(%39) : (f32) -> f32 + %41 = arith.mulf %38, %40 : f32 + %42 = arith.mulf %29, %cst_1 : f32 + %43 = arith.mulf %42, %29 : f32 + %44 = arith.divf %41, %43 : f32 + scf.yield %44 : f32 + } + scf.yield %36 : f32 + } else { + scf.yield %cst_4 : f32 + } + %34 = arith.mulf %30, %33 : f32 + %35 = arith.addf %arg8, %34 : f32 + affine.yield %35 : f32 + } + affine.yield %24 : f32 + } + %11 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_4) -> (f32) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.sitofp %13 : i32 to f32 + %15 = arith.subf %4, %14 : f32 + %16 = arith.cmpf olt, %15, %cst_4 : f32 + %17 = scf.if %16 -> (f32) { + %25 = arith.negf %15 : f32 + scf.yield %25 : f32 + } else { + scf.yield %15 : f32 + } + %18 = arith.cmpf olt, %17, %cst_3 : f32 + %19 = arith.cmpf oeq, %17, %cst_4 : f32 + %20 = arith.mulf %17, %cst_2 : f32 + %21 = arith.divf %20, %cst_3 : f32 + %22 = arith.mulf %17, %cst_1 : f32 + %23 = arith.mulf %22, %17 : f32 + %24 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %25 = arith.index_cast %arg7 : index to i32 + %26 = arith.sitofp %25 : i32 to f32 + %27 = arith.subf %9, %26 : f32 + %28 = arith.cmpf olt, %27, %cst_4 : f32 + %29 = scf.if %28 -> (f32) { + %38 = arith.negf %27 : f32 + scf.yield %38 : f32 + } else { + scf.yield %27 : f32 + } + %30 = scf.if %18 -> (f32) { + %38 = scf.if %19 -> (f32) { + scf.yield %cst_6 : f32 + } else { + %39 = func.call @sinf(%20) : (f32) -> f32 + %40 = func.call @sinf(%21) : (f32) -> f32 + %41 = arith.mulf %39, %40 : f32 + %42 = arith.divf %41, %23 : f32 + scf.yield %42 : f32 + } + scf.yield %38 : f32 + } else { + scf.yield %cst_4 : f32 + } + %31 = arith.cmpf olt, %29, %cst_3 : f32 + %32 = arith.cmpf oeq, %29, %cst_4 : f32 + %33 = scf.if %31 -> (f32) { + %38 = scf.if %32 -> (f32) { + scf.yield %cst_6 : f32 + } else { + %39 = arith.mulf %29, %cst_2 : f32 + %40 = func.call @sinf(%39) : (f32) -> f32 + %41 = arith.divf %39, %cst_3 : f32 + %42 = func.call @sinf(%41) : (f32) -> f32 + %43 = arith.mulf %40, %42 : f32 + %44 = arith.mulf %29, %cst_1 : f32 + %45 = arith.mulf %44, %29 : f32 + %46 = arith.divf %43, %45 : f32 + scf.yield %46 : f32 + } + scf.yield %38 : f32 + } else { + scf.yield %cst_4 : f32 + } + %34 = affine.load %arg0[%arg7 + %arg2 * 20 + %arg5 * 5] : memref + %35 = arith.mulf %34, %30 : f32 + %36 = arith.mulf %35, %33 : f32 + %37 = arith.addf %arg8, %36 : f32 + affine.yield %37 : f32 + } + affine.yield %24 : f32 + } + %12 = arith.divf %11, %10 : f32 + affine.store %12, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu/debuf.mlir new file mode 100644 index 000000000000..29e9c829a530 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu/debuf.mlir @@ -0,0 +1,179 @@ +#map = affine_map<(d0, d1) -> ()> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map3 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_lanczos2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant 3.000000e+00 : f32 + %cst_3 = arith.constant 3.14159274 : f32 + %cst_4 = arith.constant 3.28986812 : f32 + %cst_5 = arith.constant 6.250000e-01 : f32 + %cst_6 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %4 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_0 : f32 + %8 = arith.mulf %7, %cst_6 : f32 + %9 = arith.subf %8, %cst_0 : f32 + %10 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %11 = arith.index_cast %arg6 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.addf %12, %cst_0 : f32 + %14 = arith.mulf %13, %cst_5 : f32 + %15 = arith.subf %14, %cst_0 : f32 + %alloca = memref.alloca() : memref + %16 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst_1 into %16[] : tensor + %17 = polygeist.submap(%inserted, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%17 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_1 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_2 : f32 + %33 = arith.cmpf oeq, %31, %cst_1 : f32 + %34 = arith.mulf %31, %cst_3 : f32 + %35 = arith.divf %34, %cst_2 : f32 + %36 = arith.mulf %31, %cst_4 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = linalg.index 1 : index + %39 = arith.index_cast %38 : index to i32 + %40 = arith.sitofp %39 : i32 to f32 + %41 = arith.subf %15, %40 : f32 + %42 = arith.cmpf olt, %41, %cst_1 : f32 + %43 = arith.negf %41 : f32 + %44 = arith.select %42, %43, %41 : f32 + %45 = scf.if %32 -> (f32) { + %51 = scf.if %33 -> (f32) { + scf.yield %cst : f32 + } else { + %52 = math.sin %34 : f32 + %53 = math.sin %35 : f32 + %54 = arith.mulf %52, %53 : f32 + %55 = arith.divf %54, %37 : f32 + scf.yield %55 : f32 + } + scf.yield %51 : f32 + } else { + scf.yield %cst_1 : f32 + } + %46 = arith.cmpf olt, %44, %cst_2 : f32 + %47 = arith.cmpf oeq, %44, %cst_1 : f32 + %48 = scf.if %46 -> (f32) { + %51 = scf.if %47 -> (f32) { + scf.yield %cst : f32 + } else { + %52 = arith.mulf %44, %cst_3 : f32 + %53 = math.sin %52 : f32 + %54 = arith.divf %52, %cst_2 : f32 + %55 = math.sin %54 : f32 + %56 = arith.mulf %53, %55 : f32 + %57 = arith.mulf %44, %cst_4 : f32 + %58 = arith.mulf %57, %44 : f32 + %59 = arith.divf %56, %58 : f32 + scf.yield %59 : f32 + } + scf.yield %51 : f32 + } else { + scf.yield %cst_1 : f32 + } + %49 = arith.mulf %45, %48 : f32 + %50 = arith.addf %out, %49 : f32 + linalg.yield %50 : f32 + } -> tensor + %19 = polygeist.submapInverse(%inserted, %18, %c4, %c5) {map = #map} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %19[] : tensor + %alloca_7 = memref.alloca() : memref + %20 = bufferization.to_tensor %alloca_7 : memref + %inserted_8 = tensor.insert %cst_1 into %20[] : tensor + %21 = polygeist.submap(%1, %arg2, %c4, %c5) {map = #map2} : (tensor, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map1, #map], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%21 : tensor) outs(%inserted_8 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_1 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_2 : f32 + %33 = arith.cmpf oeq, %31, %cst_1 : f32 + %34 = arith.mulf %31, %cst_3 : f32 + %35 = arith.divf %34, %cst_2 : f32 + %36 = arith.mulf %31, %cst_4 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = linalg.index 1 : index + %39 = arith.index_cast %38 : index to i32 + %40 = arith.sitofp %39 : i32 to f32 + %41 = arith.subf %15, %40 : f32 + %42 = arith.cmpf olt, %41, %cst_1 : f32 + %43 = arith.negf %41 : f32 + %44 = arith.select %42, %43, %41 : f32 + %45 = scf.if %32 -> (f32) { + %52 = scf.if %33 -> (f32) { + scf.yield %cst : f32 + } else { + %53 = math.sin %34 : f32 + %54 = math.sin %35 : f32 + %55 = arith.mulf %53, %54 : f32 + %56 = arith.divf %55, %37 : f32 + scf.yield %56 : f32 + } + scf.yield %52 : f32 + } else { + scf.yield %cst_1 : f32 + } + %46 = arith.cmpf olt, %44, %cst_2 : f32 + %47 = arith.cmpf oeq, %44, %cst_1 : f32 + %48 = scf.if %46 -> (f32) { + %52 = scf.if %47 -> (f32) { + scf.yield %cst : f32 + } else { + %53 = arith.mulf %44, %cst_3 : f32 + %54 = math.sin %53 : f32 + %55 = arith.divf %53, %cst_2 : f32 + %56 = math.sin %55 : f32 + %57 = arith.mulf %54, %56 : f32 + %58 = arith.mulf %44, %cst_4 : f32 + %59 = arith.mulf %58, %44 : f32 + %60 = arith.divf %57, %59 : f32 + scf.yield %60 : f32 + } + scf.yield %52 : f32 + } else { + scf.yield %cst_1 : f32 + } + %49 = arith.mulf %in, %45 : f32 + %50 = arith.mulf %49, %48 : f32 + %51 = arith.addf %out, %50 : f32 + linalg.yield %51 : f32 + } -> tensor + %extracted_9 = tensor.extract %22[] : tensor + %23 = arith.divf %extracted_9, %extracted : f32 + %24 = affine.apply #map3(%arg6, %arg2, %arg4) + %inserted_10 = tensor.insert %23 into %arg7[%24] : tensor + affine.yield %inserted_10 : tensor + } + affine.yield %10 : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu/matched.mlir new file mode 100644 index 000000000000..29e9c829a530 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu/matched.mlir @@ -0,0 +1,179 @@ +#map = affine_map<(d0, d1) -> ()> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map3 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_lanczos2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant 3.000000e+00 : f32 + %cst_3 = arith.constant 3.14159274 : f32 + %cst_4 = arith.constant 3.28986812 : f32 + %cst_5 = arith.constant 6.250000e-01 : f32 + %cst_6 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %4 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_0 : f32 + %8 = arith.mulf %7, %cst_6 : f32 + %9 = arith.subf %8, %cst_0 : f32 + %10 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %11 = arith.index_cast %arg6 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.addf %12, %cst_0 : f32 + %14 = arith.mulf %13, %cst_5 : f32 + %15 = arith.subf %14, %cst_0 : f32 + %alloca = memref.alloca() : memref + %16 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst_1 into %16[] : tensor + %17 = polygeist.submap(%inserted, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%17 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_1 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_2 : f32 + %33 = arith.cmpf oeq, %31, %cst_1 : f32 + %34 = arith.mulf %31, %cst_3 : f32 + %35 = arith.divf %34, %cst_2 : f32 + %36 = arith.mulf %31, %cst_4 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = linalg.index 1 : index + %39 = arith.index_cast %38 : index to i32 + %40 = arith.sitofp %39 : i32 to f32 + %41 = arith.subf %15, %40 : f32 + %42 = arith.cmpf olt, %41, %cst_1 : f32 + %43 = arith.negf %41 : f32 + %44 = arith.select %42, %43, %41 : f32 + %45 = scf.if %32 -> (f32) { + %51 = scf.if %33 -> (f32) { + scf.yield %cst : f32 + } else { + %52 = math.sin %34 : f32 + %53 = math.sin %35 : f32 + %54 = arith.mulf %52, %53 : f32 + %55 = arith.divf %54, %37 : f32 + scf.yield %55 : f32 + } + scf.yield %51 : f32 + } else { + scf.yield %cst_1 : f32 + } + %46 = arith.cmpf olt, %44, %cst_2 : f32 + %47 = arith.cmpf oeq, %44, %cst_1 : f32 + %48 = scf.if %46 -> (f32) { + %51 = scf.if %47 -> (f32) { + scf.yield %cst : f32 + } else { + %52 = arith.mulf %44, %cst_3 : f32 + %53 = math.sin %52 : f32 + %54 = arith.divf %52, %cst_2 : f32 + %55 = math.sin %54 : f32 + %56 = arith.mulf %53, %55 : f32 + %57 = arith.mulf %44, %cst_4 : f32 + %58 = arith.mulf %57, %44 : f32 + %59 = arith.divf %56, %58 : f32 + scf.yield %59 : f32 + } + scf.yield %51 : f32 + } else { + scf.yield %cst_1 : f32 + } + %49 = arith.mulf %45, %48 : f32 + %50 = arith.addf %out, %49 : f32 + linalg.yield %50 : f32 + } -> tensor + %19 = polygeist.submapInverse(%inserted, %18, %c4, %c5) {map = #map} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %19[] : tensor + %alloca_7 = memref.alloca() : memref + %20 = bufferization.to_tensor %alloca_7 : memref + %inserted_8 = tensor.insert %cst_1 into %20[] : tensor + %21 = polygeist.submap(%1, %arg2, %c4, %c5) {map = #map2} : (tensor, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map1, #map], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%21 : tensor) outs(%inserted_8 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_1 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_2 : f32 + %33 = arith.cmpf oeq, %31, %cst_1 : f32 + %34 = arith.mulf %31, %cst_3 : f32 + %35 = arith.divf %34, %cst_2 : f32 + %36 = arith.mulf %31, %cst_4 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = linalg.index 1 : index + %39 = arith.index_cast %38 : index to i32 + %40 = arith.sitofp %39 : i32 to f32 + %41 = arith.subf %15, %40 : f32 + %42 = arith.cmpf olt, %41, %cst_1 : f32 + %43 = arith.negf %41 : f32 + %44 = arith.select %42, %43, %41 : f32 + %45 = scf.if %32 -> (f32) { + %52 = scf.if %33 -> (f32) { + scf.yield %cst : f32 + } else { + %53 = math.sin %34 : f32 + %54 = math.sin %35 : f32 + %55 = arith.mulf %53, %54 : f32 + %56 = arith.divf %55, %37 : f32 + scf.yield %56 : f32 + } + scf.yield %52 : f32 + } else { + scf.yield %cst_1 : f32 + } + %46 = arith.cmpf olt, %44, %cst_2 : f32 + %47 = arith.cmpf oeq, %44, %cst_1 : f32 + %48 = scf.if %46 -> (f32) { + %52 = scf.if %47 -> (f32) { + scf.yield %cst : f32 + } else { + %53 = arith.mulf %44, %cst_3 : f32 + %54 = math.sin %53 : f32 + %55 = arith.divf %53, %cst_2 : f32 + %56 = math.sin %55 : f32 + %57 = arith.mulf %54, %56 : f32 + %58 = arith.mulf %44, %cst_4 : f32 + %59 = arith.mulf %58, %44 : f32 + %60 = arith.divf %57, %59 : f32 + scf.yield %60 : f32 + } + scf.yield %52 : f32 + } else { + scf.yield %cst_1 : f32 + } + %49 = arith.mulf %in, %45 : f32 + %50 = arith.mulf %49, %48 : f32 + %51 = arith.addf %out, %50 : f32 + linalg.yield %51 : f32 + } -> tensor + %extracted_9 = tensor.extract %22[] : tensor + %23 = arith.divf %extracted_9, %extracted : f32 + %24 = affine.apply #map3(%arg6, %arg2, %arg4) + %inserted_10 = tensor.insert %23 into %arg7[%24] : tensor + affine.yield %inserted_10 : tensor + } + affine.yield %10 : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu/orig.mlir new file mode 100644 index 000000000000..10c800f417ef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu/orig.mlir @@ -0,0 +1,170 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_lanczos2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant 3.28986812 : f32 + %cst_2 = arith.constant 3.14159274 : f32 + %cst_3 = arith.constant 3.000000e+00 : f32 + %cst_4 = arith.constant 0.000000e+00 : f32 + %cst_5 = arith.constant 5.000000e-01 : f32 + %cst_6 = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_5 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_5 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_5 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_5 : f32 + %10 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_4) -> (f32) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.sitofp %13 : i32 to f32 + %15 = arith.subf %4, %14 : f32 + %16 = arith.cmpf olt, %15, %cst_4 : f32 + %17 = scf.if %16 -> (f32) { + %25 = arith.negf %15 : f32 + scf.yield %25 : f32 + } else { + scf.yield %15 : f32 + } + %18 = arith.cmpf olt, %17, %cst_3 : f32 + %19 = arith.cmpf oeq, %17, %cst_4 : f32 + %20 = arith.mulf %17, %cst_2 : f32 + %21 = arith.divf %20, %cst_3 : f32 + %22 = arith.mulf %17, %cst_1 : f32 + %23 = arith.mulf %22, %17 : f32 + %24 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %25 = arith.index_cast %arg7 : index to i32 + %26 = arith.sitofp %25 : i32 to f32 + %27 = arith.subf %9, %26 : f32 + %28 = arith.cmpf olt, %27, %cst_4 : f32 + %29 = scf.if %28 -> (f32) { + %36 = arith.negf %27 : f32 + scf.yield %36 : f32 + } else { + scf.yield %27 : f32 + } + %30 = scf.if %18 -> (f32) { + %36 = scf.if %19 -> (f32) { + scf.yield %cst_6 : f32 + } else { + %37 = func.call @sinf(%20) : (f32) -> f32 + %38 = func.call @sinf(%21) : (f32) -> f32 + %39 = arith.mulf %37, %38 : f32 + %40 = arith.divf %39, %23 : f32 + scf.yield %40 : f32 + } + scf.yield %36 : f32 + } else { + scf.yield %cst_4 : f32 + } + %31 = arith.cmpf olt, %29, %cst_3 : f32 + %32 = arith.cmpf oeq, %29, %cst_4 : f32 + %33 = scf.if %31 -> (f32) { + %36 = scf.if %32 -> (f32) { + scf.yield %cst_6 : f32 + } else { + %37 = arith.mulf %29, %cst_2 : f32 + %38 = func.call @sinf(%37) : (f32) -> f32 + %39 = arith.divf %37, %cst_3 : f32 + %40 = func.call @sinf(%39) : (f32) -> f32 + %41 = arith.mulf %38, %40 : f32 + %42 = arith.mulf %29, %cst_1 : f32 + %43 = arith.mulf %42, %29 : f32 + %44 = arith.divf %41, %43 : f32 + scf.yield %44 : f32 + } + scf.yield %36 : f32 + } else { + scf.yield %cst_4 : f32 + } + %34 = arith.mulf %30, %33 : f32 + %35 = arith.addf %arg8, %34 : f32 + affine.yield %35 : f32 + } + affine.yield %24 : f32 + } + %11 = affine.for %arg5 = 0 to 4 iter_args(%arg6 = %cst_4) -> (f32) { + %13 = arith.index_cast %arg5 : index to i32 + %14 = arith.sitofp %13 : i32 to f32 + %15 = arith.subf %4, %14 : f32 + %16 = arith.cmpf olt, %15, %cst_4 : f32 + %17 = scf.if %16 -> (f32) { + %25 = arith.negf %15 : f32 + scf.yield %25 : f32 + } else { + scf.yield %15 : f32 + } + %18 = arith.cmpf olt, %17, %cst_3 : f32 + %19 = arith.cmpf oeq, %17, %cst_4 : f32 + %20 = arith.mulf %17, %cst_2 : f32 + %21 = arith.divf %20, %cst_3 : f32 + %22 = arith.mulf %17, %cst_1 : f32 + %23 = arith.mulf %22, %17 : f32 + %24 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %arg6) -> (f32) { + %25 = arith.index_cast %arg7 : index to i32 + %26 = arith.sitofp %25 : i32 to f32 + %27 = arith.subf %9, %26 : f32 + %28 = arith.cmpf olt, %27, %cst_4 : f32 + %29 = scf.if %28 -> (f32) { + %38 = arith.negf %27 : f32 + scf.yield %38 : f32 + } else { + scf.yield %27 : f32 + } + %30 = scf.if %18 -> (f32) { + %38 = scf.if %19 -> (f32) { + scf.yield %cst_6 : f32 + } else { + %39 = func.call @sinf(%20) : (f32) -> f32 + %40 = func.call @sinf(%21) : (f32) -> f32 + %41 = arith.mulf %39, %40 : f32 + %42 = arith.divf %41, %23 : f32 + scf.yield %42 : f32 + } + scf.yield %38 : f32 + } else { + scf.yield %cst_4 : f32 + } + %31 = arith.cmpf olt, %29, %cst_3 : f32 + %32 = arith.cmpf oeq, %29, %cst_4 : f32 + %33 = scf.if %31 -> (f32) { + %38 = scf.if %32 -> (f32) { + scf.yield %cst_6 : f32 + } else { + %39 = arith.mulf %29, %cst_2 : f32 + %40 = func.call @sinf(%39) : (f32) -> f32 + %41 = arith.divf %39, %cst_3 : f32 + %42 = func.call @sinf(%41) : (f32) -> f32 + %43 = arith.mulf %40, %42 : f32 + %44 = arith.mulf %29, %cst_1 : f32 + %45 = arith.mulf %44, %29 : f32 + %46 = arith.divf %43, %45 : f32 + scf.yield %46 : f32 + } + scf.yield %38 : f32 + } else { + scf.yield %cst_4 : f32 + } + %34 = affine.load %arg0[%arg7 + %arg2 * 20 + %arg5 * 5] : memref + %35 = arith.mulf %34, %30 : f32 + %36 = arith.mulf %35, %33 : f32 + %37 = arith.addf %arg8, %36 : f32 + affine.yield %37 : f32 + } + affine.yield %24 : f32 + } + %12 = arith.divf %11, %10 : f32 + affine.store %12, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} diff --git a/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu/raised.mlir new file mode 100644 index 000000000000..73298c5800d3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu/raised.mlir @@ -0,0 +1,167 @@ +#map = affine_map<(d0, d1) -> ()> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_lanczos2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant 3.28986812 : f32 + %cst_2 = arith.constant 3.14159274 : f32 + %cst_3 = arith.constant 3.000000e+00 : f32 + %cst_4 = arith.constant 0.000000e+00 : f32 + %cst_5 = arith.constant 5.000000e-01 : f32 + %cst_6 = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_5 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_5 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_5 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_5 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_4, %alloca[] : memref + %10 = polygeist.submap(%alloca, %c4, %c5) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction", "reduction"]} outs(%10 : memref) { + ^bb0(%out: f32): + %15 = linalg.index 0 : index + %16 = arith.index_cast %15 : index to i32 + %17 = arith.sitofp %16 : i32 to f32 + %18 = arith.subf %4, %17 : f32 + %19 = arith.cmpf olt, %18, %cst_4 : f32 + %20 = arith.negf %18 : f32 + %21 = arith.select %19, %20, %18 : f32 + %22 = arith.cmpf olt, %21, %cst_3 : f32 + %23 = arith.cmpf oeq, %21, %cst_4 : f32 + %24 = arith.mulf %21, %cst_2 : f32 + %25 = arith.divf %24, %cst_3 : f32 + %26 = arith.mulf %21, %cst_1 : f32 + %27 = arith.mulf %26, %21 : f32 + %28 = linalg.index 1 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.sitofp %29 : i32 to f32 + %31 = arith.subf %9, %30 : f32 + %32 = arith.cmpf olt, %31, %cst_4 : f32 + %33 = arith.negf %31 : f32 + %34 = arith.select %32, %33, %31 : f32 + %35 = scf.if %22 -> (f32) { + %41 = scf.if %23 -> (f32) { + scf.yield %cst_6 : f32 + } else { + %42 = math.sin %24 : f32 + %43 = math.sin %25 : f32 + %44 = arith.mulf %42, %43 : f32 + %45 = arith.divf %44, %27 : f32 + scf.yield %45 : f32 + } + scf.yield %41 : f32 + } else { + scf.yield %cst_4 : f32 + } + %36 = arith.cmpf olt, %34, %cst_3 : f32 + %37 = arith.cmpf oeq, %34, %cst_4 : f32 + %38 = scf.if %36 -> (f32) { + %41 = scf.if %37 -> (f32) { + scf.yield %cst_6 : f32 + } else { + %42 = arith.mulf %34, %cst_2 : f32 + %43 = math.sin %42 : f32 + %44 = arith.divf %42, %cst_3 : f32 + %45 = math.sin %44 : f32 + %46 = arith.mulf %43, %45 : f32 + %47 = arith.mulf %34, %cst_1 : f32 + %48 = arith.mulf %47, %34 : f32 + %49 = arith.divf %46, %48 : f32 + scf.yield %49 : f32 + } + scf.yield %41 : f32 + } else { + scf.yield %cst_4 : f32 + } + %39 = arith.mulf %35, %38 : f32 + %40 = arith.addf %out, %39 : f32 + linalg.yield %40 : f32 + } + %11 = affine.load %alloca[] : memref + %alloca_7 = memref.alloca() : memref + affine.store %cst_4, %alloca_7[] : memref + %12 = polygeist.submap(%arg0, %arg2, %c4, %c5) {map = #map2} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map], iterator_types = ["reduction", "reduction"]} ins(%12 : memref) outs(%alloca_7 : memref) { + ^bb0(%in: f32, %out: f32): + %15 = linalg.index 0 : index + %16 = arith.index_cast %15 : index to i32 + %17 = arith.sitofp %16 : i32 to f32 + %18 = arith.subf %4, %17 : f32 + %19 = arith.cmpf olt, %18, %cst_4 : f32 + %20 = arith.negf %18 : f32 + %21 = arith.select %19, %20, %18 : f32 + %22 = arith.cmpf olt, %21, %cst_3 : f32 + %23 = arith.cmpf oeq, %21, %cst_4 : f32 + %24 = arith.mulf %21, %cst_2 : f32 + %25 = arith.divf %24, %cst_3 : f32 + %26 = arith.mulf %21, %cst_1 : f32 + %27 = arith.mulf %26, %21 : f32 + %28 = linalg.index 1 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.sitofp %29 : i32 to f32 + %31 = arith.subf %9, %30 : f32 + %32 = arith.cmpf olt, %31, %cst_4 : f32 + %33 = arith.negf %31 : f32 + %34 = arith.select %32, %33, %31 : f32 + %35 = scf.if %22 -> (f32) { + %42 = scf.if %23 -> (f32) { + scf.yield %cst_6 : f32 + } else { + %43 = math.sin %24 : f32 + %44 = math.sin %25 : f32 + %45 = arith.mulf %43, %44 : f32 + %46 = arith.divf %45, %27 : f32 + scf.yield %46 : f32 + } + scf.yield %42 : f32 + } else { + scf.yield %cst_4 : f32 + } + %36 = arith.cmpf olt, %34, %cst_3 : f32 + %37 = arith.cmpf oeq, %34, %cst_4 : f32 + %38 = scf.if %36 -> (f32) { + %42 = scf.if %37 -> (f32) { + scf.yield %cst_6 : f32 + } else { + %43 = arith.mulf %34, %cst_2 : f32 + %44 = math.sin %43 : f32 + %45 = arith.divf %43, %cst_3 : f32 + %46 = math.sin %45 : f32 + %47 = arith.mulf %44, %46 : f32 + %48 = arith.mulf %34, %cst_1 : f32 + %49 = arith.mulf %48, %34 : f32 + %50 = arith.divf %47, %49 : f32 + scf.yield %50 : f32 + } + scf.yield %42 : f32 + } else { + scf.yield %cst_4 : f32 + } + %39 = arith.mulf %in, %35 : f32 + %40 = arith.mulf %39, %38 : f32 + %41 = arith.addf %out, %40 : f32 + linalg.yield %41 : f32 + } + %13 = affine.load %alloca_7[] : memref + %14 = arith.divf %13, %11 : f32 + affine.store %14, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu_debuf.mlir new file mode 100644 index 000000000000..29e9c829a530 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu_debuf.mlir @@ -0,0 +1,179 @@ +#map = affine_map<(d0, d1) -> ()> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +#map3 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_lanczos2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 0.000000e+00 : f32 + %cst_2 = arith.constant 3.000000e+00 : f32 + %cst_3 = arith.constant 3.14159274 : f32 + %cst_4 = arith.constant 3.28986812 : f32 + %cst_5 = arith.constant 6.250000e-01 : f32 + %cst_6 = arith.constant 0.571428597 : f32 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %0) -> (tensor) { + %4 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_0 : f32 + %8 = arith.mulf %7, %cst_6 : f32 + %9 = arith.subf %8, %cst_0 : f32 + %10 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %11 = arith.index_cast %arg6 : index to i32 + %12 = arith.sitofp %11 : i32 to f32 + %13 = arith.addf %12, %cst_0 : f32 + %14 = arith.mulf %13, %cst_5 : f32 + %15 = arith.subf %14, %cst_0 : f32 + %alloca = memref.alloca() : memref + %16 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst_1 into %16[] : tensor + %17 = polygeist.submap(%inserted, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["reduction", "reduction"], library_call = ""} outs(%17 : tensor) { + ^bb0(%out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_1 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_2 : f32 + %33 = arith.cmpf oeq, %31, %cst_1 : f32 + %34 = arith.mulf %31, %cst_3 : f32 + %35 = arith.divf %34, %cst_2 : f32 + %36 = arith.mulf %31, %cst_4 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = linalg.index 1 : index + %39 = arith.index_cast %38 : index to i32 + %40 = arith.sitofp %39 : i32 to f32 + %41 = arith.subf %15, %40 : f32 + %42 = arith.cmpf olt, %41, %cst_1 : f32 + %43 = arith.negf %41 : f32 + %44 = arith.select %42, %43, %41 : f32 + %45 = scf.if %32 -> (f32) { + %51 = scf.if %33 -> (f32) { + scf.yield %cst : f32 + } else { + %52 = math.sin %34 : f32 + %53 = math.sin %35 : f32 + %54 = arith.mulf %52, %53 : f32 + %55 = arith.divf %54, %37 : f32 + scf.yield %55 : f32 + } + scf.yield %51 : f32 + } else { + scf.yield %cst_1 : f32 + } + %46 = arith.cmpf olt, %44, %cst_2 : f32 + %47 = arith.cmpf oeq, %44, %cst_1 : f32 + %48 = scf.if %46 -> (f32) { + %51 = scf.if %47 -> (f32) { + scf.yield %cst : f32 + } else { + %52 = arith.mulf %44, %cst_3 : f32 + %53 = math.sin %52 : f32 + %54 = arith.divf %52, %cst_2 : f32 + %55 = math.sin %54 : f32 + %56 = arith.mulf %53, %55 : f32 + %57 = arith.mulf %44, %cst_4 : f32 + %58 = arith.mulf %57, %44 : f32 + %59 = arith.divf %56, %58 : f32 + scf.yield %59 : f32 + } + scf.yield %51 : f32 + } else { + scf.yield %cst_1 : f32 + } + %49 = arith.mulf %45, %48 : f32 + %50 = arith.addf %out, %49 : f32 + linalg.yield %50 : f32 + } -> tensor + %19 = polygeist.submapInverse(%inserted, %18, %c4, %c5) {map = #map} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %19[] : tensor + %alloca_7 = memref.alloca() : memref + %20 = bufferization.to_tensor %alloca_7 : memref + %inserted_8 = tensor.insert %cst_1 into %20[] : tensor + %21 = polygeist.submap(%1, %arg2, %c4, %c5) {map = #map2} : (tensor, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map1, #map], iterator_types = ["reduction", "reduction"], library_call = ""} ins(%21 : tensor) outs(%inserted_8 : tensor) { + ^bb0(%in: f32, %out: f32): + %25 = linalg.index 0 : index + %26 = arith.index_cast %25 : index to i32 + %27 = arith.sitofp %26 : i32 to f32 + %28 = arith.subf %9, %27 : f32 + %29 = arith.cmpf olt, %28, %cst_1 : f32 + %30 = arith.negf %28 : f32 + %31 = arith.select %29, %30, %28 : f32 + %32 = arith.cmpf olt, %31, %cst_2 : f32 + %33 = arith.cmpf oeq, %31, %cst_1 : f32 + %34 = arith.mulf %31, %cst_3 : f32 + %35 = arith.divf %34, %cst_2 : f32 + %36 = arith.mulf %31, %cst_4 : f32 + %37 = arith.mulf %36, %31 : f32 + %38 = linalg.index 1 : index + %39 = arith.index_cast %38 : index to i32 + %40 = arith.sitofp %39 : i32 to f32 + %41 = arith.subf %15, %40 : f32 + %42 = arith.cmpf olt, %41, %cst_1 : f32 + %43 = arith.negf %41 : f32 + %44 = arith.select %42, %43, %41 : f32 + %45 = scf.if %32 -> (f32) { + %52 = scf.if %33 -> (f32) { + scf.yield %cst : f32 + } else { + %53 = math.sin %34 : f32 + %54 = math.sin %35 : f32 + %55 = arith.mulf %53, %54 : f32 + %56 = arith.divf %55, %37 : f32 + scf.yield %56 : f32 + } + scf.yield %52 : f32 + } else { + scf.yield %cst_1 : f32 + } + %46 = arith.cmpf olt, %44, %cst_2 : f32 + %47 = arith.cmpf oeq, %44, %cst_1 : f32 + %48 = scf.if %46 -> (f32) { + %52 = scf.if %47 -> (f32) { + scf.yield %cst : f32 + } else { + %53 = arith.mulf %44, %cst_3 : f32 + %54 = math.sin %53 : f32 + %55 = arith.divf %53, %cst_2 : f32 + %56 = math.sin %55 : f32 + %57 = arith.mulf %54, %56 : f32 + %58 = arith.mulf %44, %cst_4 : f32 + %59 = arith.mulf %58, %44 : f32 + %60 = arith.divf %57, %59 : f32 + scf.yield %60 : f32 + } + scf.yield %52 : f32 + } else { + scf.yield %cst_1 : f32 + } + %49 = arith.mulf %in, %45 : f32 + %50 = arith.mulf %49, %48 : f32 + %51 = arith.addf %out, %50 : f32 + linalg.yield %51 : f32 + } -> tensor + %extracted_9 = tensor.extract %22[] : tensor + %23 = arith.divf %extracted_9, %extracted : f32 + %24 = affine.apply #map3(%arg6, %arg2, %arg4) + %inserted_10 = tensor.insert %23 into %arg7[%24] : tensor + affine.yield %inserted_10 : tensor + } + affine.yield %10 : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu_linalg.mlir new file mode 100644 index 000000000000..73298c5800d3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_lanczos2d_aa_cpu_linalg.mlir @@ -0,0 +1,167 @@ +#map = affine_map<(d0, d1) -> ()> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 20 + d0 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_lanczos2d_aa_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.571428597 : f32 + %cst_0 = arith.constant 6.250000e-01 : f32 + %cst_1 = arith.constant 3.28986812 : f32 + %cst_2 = arith.constant 3.14159274 : f32 + %cst_3 = arith.constant 3.000000e+00 : f32 + %cst_4 = arith.constant 0.000000e+00 : f32 + %cst_5 = arith.constant 5.000000e-01 : f32 + %cst_6 = arith.constant 1.000000e+00 : f32 + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 7 { + %0 = arith.index_cast %arg3 : index to i32 + %1 = arith.sitofp %0 : i32 to f32 + %2 = arith.addf %1, %cst_5 : f32 + %3 = arith.mulf %2, %cst : f32 + %4 = arith.subf %3, %cst_5 : f32 + affine.for %arg4 = 0 to 8 { + %5 = arith.index_cast %arg4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_5 : f32 + %8 = arith.mulf %7, %cst_0 : f32 + %9 = arith.subf %8, %cst_5 : f32 + %alloca = memref.alloca() : memref + affine.store %cst_4, %alloca[] : memref + %10 = polygeist.submap(%alloca, %c4, %c5) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["reduction", "reduction"]} outs(%10 : memref) { + ^bb0(%out: f32): + %15 = linalg.index 0 : index + %16 = arith.index_cast %15 : index to i32 + %17 = arith.sitofp %16 : i32 to f32 + %18 = arith.subf %4, %17 : f32 + %19 = arith.cmpf olt, %18, %cst_4 : f32 + %20 = arith.negf %18 : f32 + %21 = arith.select %19, %20, %18 : f32 + %22 = arith.cmpf olt, %21, %cst_3 : f32 + %23 = arith.cmpf oeq, %21, %cst_4 : f32 + %24 = arith.mulf %21, %cst_2 : f32 + %25 = arith.divf %24, %cst_3 : f32 + %26 = arith.mulf %21, %cst_1 : f32 + %27 = arith.mulf %26, %21 : f32 + %28 = linalg.index 1 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.sitofp %29 : i32 to f32 + %31 = arith.subf %9, %30 : f32 + %32 = arith.cmpf olt, %31, %cst_4 : f32 + %33 = arith.negf %31 : f32 + %34 = arith.select %32, %33, %31 : f32 + %35 = scf.if %22 -> (f32) { + %41 = scf.if %23 -> (f32) { + scf.yield %cst_6 : f32 + } else { + %42 = math.sin %24 : f32 + %43 = math.sin %25 : f32 + %44 = arith.mulf %42, %43 : f32 + %45 = arith.divf %44, %27 : f32 + scf.yield %45 : f32 + } + scf.yield %41 : f32 + } else { + scf.yield %cst_4 : f32 + } + %36 = arith.cmpf olt, %34, %cst_3 : f32 + %37 = arith.cmpf oeq, %34, %cst_4 : f32 + %38 = scf.if %36 -> (f32) { + %41 = scf.if %37 -> (f32) { + scf.yield %cst_6 : f32 + } else { + %42 = arith.mulf %34, %cst_2 : f32 + %43 = math.sin %42 : f32 + %44 = arith.divf %42, %cst_3 : f32 + %45 = math.sin %44 : f32 + %46 = arith.mulf %43, %45 : f32 + %47 = arith.mulf %34, %cst_1 : f32 + %48 = arith.mulf %47, %34 : f32 + %49 = arith.divf %46, %48 : f32 + scf.yield %49 : f32 + } + scf.yield %41 : f32 + } else { + scf.yield %cst_4 : f32 + } + %39 = arith.mulf %35, %38 : f32 + %40 = arith.addf %out, %39 : f32 + linalg.yield %40 : f32 + } + %11 = affine.load %alloca[] : memref + %alloca_7 = memref.alloca() : memref + affine.store %cst_4, %alloca_7[] : memref + %12 = polygeist.submap(%arg0, %arg2, %c4, %c5) {map = #map2} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map], iterator_types = ["reduction", "reduction"]} ins(%12 : memref) outs(%alloca_7 : memref) { + ^bb0(%in: f32, %out: f32): + %15 = linalg.index 0 : index + %16 = arith.index_cast %15 : index to i32 + %17 = arith.sitofp %16 : i32 to f32 + %18 = arith.subf %4, %17 : f32 + %19 = arith.cmpf olt, %18, %cst_4 : f32 + %20 = arith.negf %18 : f32 + %21 = arith.select %19, %20, %18 : f32 + %22 = arith.cmpf olt, %21, %cst_3 : f32 + %23 = arith.cmpf oeq, %21, %cst_4 : f32 + %24 = arith.mulf %21, %cst_2 : f32 + %25 = arith.divf %24, %cst_3 : f32 + %26 = arith.mulf %21, %cst_1 : f32 + %27 = arith.mulf %26, %21 : f32 + %28 = linalg.index 1 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.sitofp %29 : i32 to f32 + %31 = arith.subf %9, %30 : f32 + %32 = arith.cmpf olt, %31, %cst_4 : f32 + %33 = arith.negf %31 : f32 + %34 = arith.select %32, %33, %31 : f32 + %35 = scf.if %22 -> (f32) { + %42 = scf.if %23 -> (f32) { + scf.yield %cst_6 : f32 + } else { + %43 = math.sin %24 : f32 + %44 = math.sin %25 : f32 + %45 = arith.mulf %43, %44 : f32 + %46 = arith.divf %45, %27 : f32 + scf.yield %46 : f32 + } + scf.yield %42 : f32 + } else { + scf.yield %cst_4 : f32 + } + %36 = arith.cmpf olt, %34, %cst_3 : f32 + %37 = arith.cmpf oeq, %34, %cst_4 : f32 + %38 = scf.if %36 -> (f32) { + %42 = scf.if %37 -> (f32) { + scf.yield %cst_6 : f32 + } else { + %43 = arith.mulf %34, %cst_2 : f32 + %44 = math.sin %43 : f32 + %45 = arith.divf %43, %cst_3 : f32 + %46 = math.sin %45 : f32 + %47 = arith.mulf %44, %46 : f32 + %48 = arith.mulf %34, %cst_1 : f32 + %49 = arith.mulf %48, %34 : f32 + %50 = arith.divf %47, %49 : f32 + scf.yield %50 : f32 + } + scf.yield %42 : f32 + } else { + scf.yield %cst_4 : f32 + } + %39 = arith.mulf %in, %35 : f32 + %40 = arith.mulf %39, %38 : f32 + %41 = arith.addf %out, %40 : f32 + linalg.yield %41 : f32 + } + %13 = affine.load %alloca_7[] : memref + %14 = arith.divf %13, %11 : f32 + affine.store %14, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + return + } + func.func private @sinf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu.mlir new file mode 100644 index 000000000000..42dbfc65c93e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu.mlir @@ -0,0 +1,50 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_linear1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_0 = arith.constant 7.000000e+00 : f32 + %cst_1 = arith.constant 4.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %cst_3 = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 8 { + affine.store %cst_3, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_2 : f32 + %5 = arith.mulf %4, %cst_1 : f32 + %6 = arith.divf %5, %cst_0 : f32 + %7 = arith.subf %6, %cst_2 : f32 + %8 = arith.cmpf olt, %7, %cst_3 : f32 + %9 = arith.select %8, %cst_3, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = affine.load %arg0[%arg3 + %arg2 * 7] : memref + %14 = arith.sitofp %10 : i32 to f32 + %15 = arith.subf %9, %14 : f32 + %16 = arith.subf %cst, %15 : f32 + %17 = arith.mulf %13, %16 : f32 + %18 = memref.load %arg1[%12] : memref + %19 = arith.addf %18, %17 : f32 + memref.store %19, %arg1[%12] : memref + %20 = arith.addi %10, %c1_i32 : i32 + %21 = arith.cmpi slt, %20, %c4_i32 : i32 + %22 = arith.select %21, %20, %10 : i32 + %23 = arith.addi %1, %22 : i32 + %24 = arith.index_cast %23 : i32 to index + %25 = affine.load %arg0[%arg3 + %arg2 * 7] : memref + %26 = arith.mulf %25, %15 : f32 + %27 = memref.load %arg1[%24] : memref + %28 = arith.addf %27, %26 : f32 + memref.store %28, %arg1[%24] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..f54f1a14407b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu/debuf.mlir @@ -0,0 +1,62 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0 + d1 * 7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_linear1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.000000e+00 : f32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.sitofp %8 : i32 to f32 + %10 = arith.addf %9, %cst_0 : f32 + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.divf %11, %cst_2 : f32 + %13 = arith.subf %12, %cst_0 : f32 + %14 = arith.cmpf olt, %13, %cst : f32 + %15 = arith.select %14, %cst, %13 : f32 + %16 = arith.fptosi %15 : f32 to i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = affine.apply #map1(%arg4, %arg2) + %extracted = tensor.extract %1[%19] : tensor + %20 = arith.sitofp %16 : i32 to f32 + %21 = arith.subf %15, %20 : f32 + %22 = arith.subf %cst_3, %21 : f32 + %23 = arith.mulf %extracted, %22 : f32 + %extracted_4 = tensor.extract %arg5[%18] : tensor + %24 = arith.addf %extracted_4, %23 : f32 + %inserted = tensor.insert %24 into %arg5[%18] : tensor + %25 = arith.addi %16, %c1_i32 : i32 + %26 = arith.cmpi slt, %25, %c4_i32 : i32 + %27 = arith.select %26, %25, %16 : i32 + %28 = arith.addi %6, %27 : i32 + %29 = arith.index_cast %28 : i32 to index + %30 = affine.apply #map1(%arg4, %arg2) + %extracted_5 = tensor.extract %1[%30] : tensor + %31 = arith.mulf %extracted_5, %21 : f32 + %extracted_6 = tensor.extract %inserted[%29] : tensor + %32 = arith.addf %extracted_6, %31 : f32 + %inserted_7 = tensor.insert %32 into %inserted[%29] : tensor + affine.yield %inserted_7 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..ccbc2cd7ef28 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu/matched.mlir @@ -0,0 +1,59 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0 + d1 * 7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_linear1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.000000e+00 : f32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.sitofp %8 : i32 to f32 + %10 = arith.addf %9, %cst_0 : f32 + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.divf %11, %cst_2 : f32 + %13 = arith.subf %12, %cst_0 : f32 + %14 = arith.cmpf olt, %13, %cst : f32 + %15 = arith.select %14, %cst, %13 : f32 + %16 = arith.fptosi %15 : f32 to i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = affine.apply #map1(%arg4, %arg2) + %extracted = tensor.extract %1[%19] : tensor + %20 = arith.sitofp %16 : i32 to f32 + %21 = arith.subf %15, %20 : f32 + %22 = arith.subf %cst_3, %21 : f32 + %23 = arith.mulf %extracted, %22 : f32 + %extracted_4 = tensor.extract %arg5[%18] : tensor + %24 = arith.addf %extracted_4, %23 : f32 + %inserted = tensor.insert %24 into %arg5[%18] : tensor + %25 = arith.addi %16, %c1_i32 : i32 + %26 = arith.cmpi slt, %25, %c4_i32 : i32 + %27 = arith.select %26, %25, %16 : i32 + %28 = arith.addi %6, %27 : i32 + %29 = arith.index_cast %28 : i32 to index + %30 = affine.apply #map1(%arg4, %arg2) + %extracted_5 = tensor.extract %1[%30] : tensor + %31 = arith.mulf %extracted_5, %21 : f32 + %extracted_6 = tensor.extract %inserted[%29] : tensor + %32 = arith.addf %extracted_6, %31 : f32 + %inserted_7 = tensor.insert %32 into %inserted[%29] : tensor + affine.yield %inserted_7 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..42dbfc65c93e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu/orig.mlir @@ -0,0 +1,50 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_linear1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_0 = arith.constant 7.000000e+00 : f32 + %cst_1 = arith.constant 4.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %cst_3 = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 8 { + affine.store %cst_3, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_2 : f32 + %5 = arith.mulf %4, %cst_1 : f32 + %6 = arith.divf %5, %cst_0 : f32 + %7 = arith.subf %6, %cst_2 : f32 + %8 = arith.cmpf olt, %7, %cst_3 : f32 + %9 = arith.select %8, %cst_3, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = affine.load %arg0[%arg3 + %arg2 * 7] : memref + %14 = arith.sitofp %10 : i32 to f32 + %15 = arith.subf %9, %14 : f32 + %16 = arith.subf %cst, %15 : f32 + %17 = arith.mulf %13, %16 : f32 + %18 = memref.load %arg1[%12] : memref + %19 = arith.addf %18, %17 : f32 + memref.store %19, %arg1[%12] : memref + %20 = arith.addi %10, %c1_i32 : i32 + %21 = arith.cmpi slt, %20, %c4_i32 : i32 + %22 = arith.select %21, %20, %10 : i32 + %23 = arith.addi %1, %22 : i32 + %24 = arith.index_cast %23 : i32 to index + %25 = affine.load %arg0[%arg3 + %arg2 * 7] : memref + %26 = arith.mulf %25, %15 : f32 + %27 = memref.load %arg1[%24] : memref + %28 = arith.addf %27, %26 : f32 + memref.store %28, %arg1[%24] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..c7ff18109ee2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu/raised.mlir @@ -0,0 +1,53 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_linear1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_0 = arith.constant 7.000000e+00 : f32 + %cst_1 = arith.constant 4.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %cst_3 = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_3 : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_2 : f32 + %5 = arith.mulf %4, %cst_1 : f32 + %6 = arith.divf %5, %cst_0 : f32 + %7 = arith.subf %6, %cst_2 : f32 + %8 = arith.cmpf olt, %7, %cst_3 : f32 + %9 = arith.select %8, %cst_3, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = affine.load %arg0[%arg3 + %arg2 * 7] : memref + %14 = arith.sitofp %10 : i32 to f32 + %15 = arith.subf %9, %14 : f32 + %16 = arith.subf %cst, %15 : f32 + %17 = arith.mulf %13, %16 : f32 + %18 = memref.load %arg1[%12] : memref + %19 = arith.addf %18, %17 : f32 + memref.store %19, %arg1[%12] : memref + %20 = arith.addi %10, %c1_i32 : i32 + %21 = arith.cmpi slt, %20, %c4_i32 : i32 + %22 = arith.select %21, %20, %10 : i32 + %23 = arith.addi %1, %22 : i32 + %24 = arith.index_cast %23 : i32 to index + %25 = affine.load %arg0[%arg3 + %arg2 * 7] : memref + %26 = arith.mulf %25, %15 : f32 + %27 = memref.load %arg1[%24] : memref + %28 = arith.addf %27, %26 : f32 + memref.store %28, %arg1[%24] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..f54f1a14407b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu_debuf.mlir @@ -0,0 +1,62 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0 + d1 * 7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_linear1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.000000e+00 : f32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.sitofp %8 : i32 to f32 + %10 = arith.addf %9, %cst_0 : f32 + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.divf %11, %cst_2 : f32 + %13 = arith.subf %12, %cst_0 : f32 + %14 = arith.cmpf olt, %13, %cst : f32 + %15 = arith.select %14, %cst, %13 : f32 + %16 = arith.fptosi %15 : f32 to i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = affine.apply #map1(%arg4, %arg2) + %extracted = tensor.extract %1[%19] : tensor + %20 = arith.sitofp %16 : i32 to f32 + %21 = arith.subf %15, %20 : f32 + %22 = arith.subf %cst_3, %21 : f32 + %23 = arith.mulf %extracted, %22 : f32 + %extracted_4 = tensor.extract %arg5[%18] : tensor + %24 = arith.addf %extracted_4, %23 : f32 + %inserted = tensor.insert %24 into %arg5[%18] : tensor + %25 = arith.addi %16, %c1_i32 : i32 + %26 = arith.cmpi slt, %25, %c4_i32 : i32 + %27 = arith.select %26, %25, %16 : i32 + %28 = arith.addi %6, %27 : i32 + %29 = arith.index_cast %28 : i32 to index + %30 = affine.apply #map1(%arg4, %arg2) + %extracted_5 = tensor.extract %1[%30] : tensor + %31 = arith.mulf %extracted_5, %21 : f32 + %extracted_6 = tensor.extract %inserted[%29] : tensor + %32 = arith.addf %extracted_6, %31 : f32 + %inserted_7 = tensor.insert %32 into %inserted[%29] : tensor + affine.yield %inserted_7 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..c7ff18109ee2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_linear1d_backward_cpu_linalg.mlir @@ -0,0 +1,53 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_linear1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_0 = arith.constant 7.000000e+00 : f32 + %cst_1 = arith.constant 4.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e-01 : f32 + %cst_3 = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_3 : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_2 : f32 + %5 = arith.mulf %4, %cst_1 : f32 + %6 = arith.divf %5, %cst_0 : f32 + %7 = arith.subf %6, %cst_2 : f32 + %8 = arith.cmpf olt, %7, %cst_3 : f32 + %9 = arith.select %8, %cst_3, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = affine.load %arg0[%arg3 + %arg2 * 7] : memref + %14 = arith.sitofp %10 : i32 to f32 + %15 = arith.subf %9, %14 : f32 + %16 = arith.subf %cst, %15 : f32 + %17 = arith.mulf %13, %16 : f32 + %18 = memref.load %arg1[%12] : memref + %19 = arith.addf %18, %17 : f32 + memref.store %19, %arg1[%12] : memref + %20 = arith.addi %10, %c1_i32 : i32 + %21 = arith.cmpi slt, %20, %c4_i32 : i32 + %22 = arith.select %21, %20, %10 : i32 + %23 = arith.addi %1, %22 : i32 + %24 = arith.index_cast %23 : i32 to index + %25 = affine.load %arg0[%arg3 + %arg2 * 7] : memref + %26 = arith.mulf %25, %15 : f32 + %27 = memref.load %arg1[%24] : memref + %28 = arith.addf %27, %26 : f32 + memref.store %28, %arg1[%24] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu.mlir new file mode 100644 index 000000000000..4d5fa0c99f9f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu.mlir @@ -0,0 +1,43 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_linear1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 4.000000e+00 : f32 + %cst_3 = arith.constant 5.000000e-01 : f32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_3 : f32 + %5 = arith.mulf %4, %cst_2 : f32 + %6 = arith.divf %5, %cst_1 : f32 + %7 = arith.subf %6, %cst_3 : f32 + %8 = arith.cmpf olt, %7, %cst_0 : f32 + %9 = arith.select %8, %cst_0, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = memref.load %arg0[%12] : memref + %14 = arith.sitofp %10 : i32 to f32 + %15 = arith.subf %9, %14 : f32 + %16 = arith.subf %cst, %15 : f32 + %17 = arith.mulf %13, %16 : f32 + %18 = arith.addi %10, %c1_i32 : i32 + %19 = arith.cmpi slt, %18, %c4_i32 : i32 + %20 = arith.select %19, %18, %10 : i32 + %21 = arith.addi %1, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = memref.load %arg0[%22] : memref + %24 = arith.mulf %23, %15 : f32 + %25 = arith.addf %17, %24 : f32 + affine.store %25, %arg1[%arg3 + %arg2 * 7] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu/debuf.mlir new file mode 100644 index 000000000000..262ee88996e2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu/debuf.mlir @@ -0,0 +1,54 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 7)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_linear1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.sitofp %9 : i32 to f32 + %11 = arith.addf %10, %cst : f32 + %12 = arith.mulf %11, %cst_0 : f32 + %13 = arith.divf %12, %cst_1 : f32 + %14 = arith.subf %13, %cst : f32 + %15 = arith.cmpf olt, %14, %cst_2 : f32 + %16 = arith.select %15, %cst_2, %14 : f32 + %17 = arith.fptosi %16 : f32 to i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg0[%19] : memref + %21 = arith.sitofp %17 : i32 to f32 + %22 = arith.subf %16, %21 : f32 + %23 = arith.subf %cst_3, %22 : f32 + %24 = arith.mulf %20, %23 : f32 + %25 = arith.addi %17, %c1_i32 : i32 + %26 = arith.cmpi slt, %25, %c4_i32 : i32 + %27 = arith.select %26, %25, %17 : i32 + %28 = arith.addi %7, %27 : i32 + %29 = arith.index_cast %28 : i32 to index + %30 = memref.load %arg0[%29] : memref + %31 = arith.mulf %30, %22 : f32 + %32 = arith.addf %24, %31 : f32 + linalg.yield %32 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu/matched.mlir new file mode 100644 index 000000000000..262ee88996e2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu/matched.mlir @@ -0,0 +1,54 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 7)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_linear1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.sitofp %9 : i32 to f32 + %11 = arith.addf %10, %cst : f32 + %12 = arith.mulf %11, %cst_0 : f32 + %13 = arith.divf %12, %cst_1 : f32 + %14 = arith.subf %13, %cst : f32 + %15 = arith.cmpf olt, %14, %cst_2 : f32 + %16 = arith.select %15, %cst_2, %14 : f32 + %17 = arith.fptosi %16 : f32 to i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg0[%19] : memref + %21 = arith.sitofp %17 : i32 to f32 + %22 = arith.subf %16, %21 : f32 + %23 = arith.subf %cst_3, %22 : f32 + %24 = arith.mulf %20, %23 : f32 + %25 = arith.addi %17, %c1_i32 : i32 + %26 = arith.cmpi slt, %25, %c4_i32 : i32 + %27 = arith.select %26, %25, %17 : i32 + %28 = arith.addi %7, %27 : i32 + %29 = arith.index_cast %28 : i32 to index + %30 = memref.load %arg0[%29] : memref + %31 = arith.mulf %30, %22 : f32 + %32 = arith.addf %24, %31 : f32 + linalg.yield %32 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu/orig.mlir new file mode 100644 index 000000000000..4d5fa0c99f9f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu/orig.mlir @@ -0,0 +1,43 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_linear1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 4.000000e+00 : f32 + %cst_3 = arith.constant 5.000000e-01 : f32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_3 : f32 + %5 = arith.mulf %4, %cst_2 : f32 + %6 = arith.divf %5, %cst_1 : f32 + %7 = arith.subf %6, %cst_3 : f32 + %8 = arith.cmpf olt, %7, %cst_0 : f32 + %9 = arith.select %8, %cst_0, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.index_cast %11 : i32 to index + %13 = memref.load %arg0[%12] : memref + %14 = arith.sitofp %10 : i32 to f32 + %15 = arith.subf %9, %14 : f32 + %16 = arith.subf %cst, %15 : f32 + %17 = arith.mulf %13, %16 : f32 + %18 = arith.addi %10, %c1_i32 : i32 + %19 = arith.cmpi slt, %18, %c4_i32 : i32 + %20 = arith.select %19, %18, %10 : i32 + %21 = arith.addi %1, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = memref.load %arg0[%22] : memref + %24 = arith.mulf %23, %15 : f32 + %25 = arith.addf %17, %24 : f32 + affine.store %25, %arg1[%arg3 + %arg2 * 7] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu/raised.mlir new file mode 100644 index 000000000000..e8ba04a15b92 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu/raised.mlir @@ -0,0 +1,50 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 7)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_linear1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %cst = arith.constant 1.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 4.000000e+00 : f32 + %cst_3 = arith.constant 5.000000e-01 : f32 + %0 = polygeist.submap(%arg1, %c2, %c7) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_3 : f32 + %8 = arith.mulf %7, %cst_2 : f32 + %9 = arith.divf %8, %cst_1 : f32 + %10 = arith.subf %9, %cst_3 : f32 + %11 = arith.cmpf olt, %10, %cst_0 : f32 + %12 = arith.select %11, %cst_0, %10 : f32 + %13 = arith.fptosi %12 : f32 to i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = memref.load %arg0[%15] : memref + %17 = arith.sitofp %13 : i32 to f32 + %18 = arith.subf %12, %17 : f32 + %19 = arith.subf %cst, %18 : f32 + %20 = arith.mulf %16, %19 : f32 + %21 = arith.addi %13, %c1_i32 : i32 + %22 = arith.cmpi slt, %21, %c4_i32 : i32 + %23 = arith.select %22, %21, %13 : i32 + %24 = arith.addi %3, %23 : i32 + %25 = arith.index_cast %24 : i32 to index + %26 = memref.load %arg0[%25] : memref + %27 = arith.mulf %26, %18 : f32 + %28 = arith.addf %20, %27 : f32 + linalg.yield %28 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu_debuf.mlir new file mode 100644 index 000000000000..262ee88996e2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu_debuf.mlir @@ -0,0 +1,54 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 7)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_linear1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.sitofp %9 : i32 to f32 + %11 = arith.addf %10, %cst : f32 + %12 = arith.mulf %11, %cst_0 : f32 + %13 = arith.divf %12, %cst_1 : f32 + %14 = arith.subf %13, %cst : f32 + %15 = arith.cmpf olt, %14, %cst_2 : f32 + %16 = arith.select %15, %cst_2, %14 : f32 + %17 = arith.fptosi %16 : f32 to i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg0[%19] : memref + %21 = arith.sitofp %17 : i32 to f32 + %22 = arith.subf %16, %21 : f32 + %23 = arith.subf %cst_3, %22 : f32 + %24 = arith.mulf %20, %23 : f32 + %25 = arith.addi %17, %c1_i32 : i32 + %26 = arith.cmpi slt, %25, %c4_i32 : i32 + %27 = arith.select %26, %25, %17 : i32 + %28 = arith.addi %7, %27 : i32 + %29 = arith.index_cast %28 : i32 to index + %30 = memref.load %arg0[%29] : memref + %31 = arith.mulf %30, %22 : f32 + %32 = arith.addf %24, %31 : f32 + linalg.yield %32 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu_linalg.mlir new file mode 100644 index 000000000000..e8ba04a15b92 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_linear1d_cpu_linalg.mlir @@ -0,0 +1,50 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 7)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_linear1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %cst = arith.constant 1.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst_0 = arith.constant 0.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 4.000000e+00 : f32 + %cst_3 = arith.constant 5.000000e-01 : f32 + %0 = polygeist.submap(%arg1, %c2, %c7) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_3 : f32 + %8 = arith.mulf %7, %cst_2 : f32 + %9 = arith.divf %8, %cst_1 : f32 + %10 = arith.subf %9, %cst_3 : f32 + %11 = arith.cmpf olt, %10, %cst_0 : f32 + %12 = arith.select %11, %cst_0, %10 : f32 + %13 = arith.fptosi %12 : f32 to i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = memref.load %arg0[%15] : memref + %17 = arith.sitofp %13 : i32 to f32 + %18 = arith.subf %12, %17 : f32 + %19 = arith.subf %cst, %18 : f32 + %20 = arith.mulf %16, %19 : f32 + %21 = arith.addi %13, %c1_i32 : i32 + %22 = arith.cmpi slt, %21, %c4_i32 : i32 + %23 = arith.select %22, %21, %13 : i32 + %24 = arith.addi %3, %23 : i32 + %25 = arith.index_cast %24 : i32 to index + %26 = memref.load %arg0[%25] : memref + %27 = arith.mulf %26, %18 : f32 + %28 = arith.addf %20, %27 : f32 + linalg.yield %28 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu.mlir new file mode 100644 index 000000000000..b5be3a9d1724 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 8 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[%arg3 + %arg2 * 7] : memref + %10 = memref.load %arg1[%8] : memref + %11 = arith.addf %10, %9 : f32 + memref.store %11, %arg1[%8] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..64cb5026dc54 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu/debuf.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0 + d1 * 7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c4_i32 : i32 + %10 = arith.divsi %9, %c7_i32 : i32 + %11 = arith.cmpi sge, %10, %c4_i32 : i32 + %12 = arith.select %11, %c3_i32, %10 : i32 + %13 = arith.addi %6, %12 : i32 + %14 = arith.index_cast %13 : i32 to index + %15 = affine.apply #map1(%arg4, %arg2) + %extracted = tensor.extract %1[%15] : tensor + %extracted_0 = tensor.extract %arg5[%14] : tensor + %16 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %16 into %arg5[%14] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..fa16c522388e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu/matched.mlir @@ -0,0 +1,37 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0 + d1 * 7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c4_i32 : i32 + %10 = arith.divsi %9, %c7_i32 : i32 + %11 = arith.cmpi sge, %10, %c4_i32 : i32 + %12 = arith.select %11, %c3_i32, %10 : i32 + %13 = arith.addi %6, %12 : i32 + %14 = arith.index_cast %13 : i32 to index + %15 = affine.apply #map1(%arg4, %arg2) + %extracted = tensor.extract %1[%15] : tensor + %extracted_0 = tensor.extract %arg5[%14] : tensor + %16 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %16 into %arg5[%14] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..b5be3a9d1724 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu/orig.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 8 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[%arg3 + %arg2 * 7] : memref + %10 = memref.load %arg1[%8] : memref + %11 = arith.addf %10, %9 : f32 + memref.store %11, %arg1[%8] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..4baff3949bb9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu/raised.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[%arg3 + %arg2 * 7] : memref + %10 = memref.load %arg1[%8] : memref + %11 = arith.addf %10, %9 : f32 + memref.store %11, %arg1[%8] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..64cb5026dc54 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu_debuf.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0 + d1 * 7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c4_i32 : i32 + %10 = arith.divsi %9, %c7_i32 : i32 + %11 = arith.cmpi sge, %10, %c4_i32 : i32 + %12 = arith.select %11, %c3_i32, %10 : i32 + %13 = arith.addi %6, %12 : i32 + %14 = arith.index_cast %13 : i32 to index + %15 = affine.apply #map1(%arg4, %arg2) + %extracted = tensor.extract %1[%15] : tensor + %extracted_0 = tensor.extract %arg5[%14] : tensor + %16 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %16 into %arg5[%14] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..4baff3949bb9 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest1d_backward_cpu_linalg.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = affine.load %arg0[%arg3 + %arg2 * 7] : memref + %10 = memref.load %arg1[%8] : memref + %11 = arith.addf %10, %9 : f32 + memref.store %11, %arg1[%8] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu.mlir new file mode 100644 index 000000000000..1e17b4cb04fd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = memref.load %arg0[%8] : memref + affine.store %9, %arg1[%arg3 + %arg2 * 7] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu/debuf.mlir new file mode 100644 index 000000000000..39c48d50fef4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu/debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 7)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c4_i32 : i32 + %11 = arith.divsi %10, %c7_i32 : i32 + %12 = arith.cmpi sge, %11, %c4_i32 : i32 + %13 = arith.select %12, %c3_i32, %11 : i32 + %14 = arith.addi %7, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = memref.load %arg0[%15] : memref + linalg.yield %16 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu/matched.mlir new file mode 100644 index 000000000000..39c48d50fef4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu/matched.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 7)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c4_i32 : i32 + %11 = arith.divsi %10, %c7_i32 : i32 + %12 = arith.cmpi sge, %11, %c4_i32 : i32 + %13 = arith.select %12, %c3_i32, %11 : i32 + %14 = arith.addi %7, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = memref.load %arg0[%15] : memref + linalg.yield %16 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu/orig.mlir new file mode 100644 index 000000000000..1e17b4cb04fd --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu/orig.mlir @@ -0,0 +1,23 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = memref.load %arg0[%8] : memref + affine.store %9, %arg1[%arg3 + %arg2 * 7] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu/raised.mlir new file mode 100644 index 000000000000..d078d184f48b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu/raised.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 7)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %c4_i32 = arith.constant 4 : i32 + %0 = polygeist.submap(%arg1, %c2, %c7) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = arith.divsi %6, %c7_i32 : i32 + %8 = arith.cmpi sge, %7, %c4_i32 : i32 + %9 = arith.select %8, %c3_i32, %7 : i32 + %10 = arith.addi %3, %9 : i32 + %11 = arith.index_cast %10 : i32 to index + %12 = memref.load %arg0[%11] : memref + linalg.yield %12 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu_debuf.mlir new file mode 100644 index 000000000000..39c48d50fef4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu_debuf.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 7)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c4_i32 : i32 + %11 = arith.divsi %10, %c7_i32 : i32 + %12 = arith.cmpi sge, %11, %c4_i32 : i32 + %13 = arith.select %12, %c3_i32, %11 : i32 + %14 = arith.addi %7, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = memref.load %arg0[%15] : memref + linalg.yield %16 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu_linalg.mlir new file mode 100644 index 000000000000..d078d184f48b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest1d_cpu_linalg.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 7)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %c4_i32 = arith.constant 4 : i32 + %0 = polygeist.submap(%arg1, %c2, %c7) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = arith.divsi %6, %c7_i32 : i32 + %8 = arith.cmpi sge, %7, %c4_i32 : i32 + %9 = arith.select %8, %c3_i32, %7 : i32 + %10 = arith.addi %3, %9 : i32 + %11 = arith.index_cast %10 : i32 to index + %12 = memref.load %arg0[%11] : memref + linalg.yield %12 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d.mlir new file mode 100644 index 000000000000..65617aa6b327 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 16 { + %0 = arith.cmpi slt, %arg4, %c0 : index + %1 = arith.subi %c-1, %arg4 : index + %2 = arith.select %0, %1, %arg4 : index + %3 = arith.divsi %2, %c2 : index + %4 = arith.subi %c-1, %3 : index + %5 = arith.select %0, %4, %3 : index + affine.for %arg5 = 0 to 16 { + %6 = arith.cmpi slt, %arg5, %c0 : index + %7 = arith.subi %c-1, %arg5 : index + %8 = arith.select %6, %7, %arg5 : index + %9 = arith.divsi %8, %c2 : index + %10 = arith.subi %c-1, %9 : index + %11 = arith.select %6, %10, %9 : index + %12 = memref.load %arg0[%arg2, %arg3, %5, %11] : memref + affine.store %12, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d/debuf.mlir new file mode 100644 index 000000000000..4762de649493 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d/debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0] [%c2, %c4, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = linalg.index 2 : index + %6 = arith.cmpi slt, %5, %c0 : index + %7 = arith.subi %c-1, %5 : index + %8 = arith.select %6, %7, %5 : index + %9 = arith.divsi %8, %c2 : index + %10 = arith.subi %c-1, %9 : index + %11 = arith.select %6, %10, %9 : index + %12 = linalg.index 3 : index + %13 = arith.cmpi slt, %12, %c0 : index + %14 = arith.subi %c-1, %12 : index + %15 = arith.select %13, %14, %12 : index + %16 = arith.divsi %15, %c2 : index + %17 = arith.subi %c-1, %16 : index + %18 = arith.select %13, %17, %16 : index + %19 = memref.load %arg0[%3, %4, %11, %18] : memref + linalg.yield %19 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0, 0, 0] [%c2, %c4, %c16, %c16] [1, 1, 1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d/matched.mlir new file mode 100644 index 000000000000..4762de649493 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d/matched.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0] [%c2, %c4, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = linalg.index 2 : index + %6 = arith.cmpi slt, %5, %c0 : index + %7 = arith.subi %c-1, %5 : index + %8 = arith.select %6, %7, %5 : index + %9 = arith.divsi %8, %c2 : index + %10 = arith.subi %c-1, %9 : index + %11 = arith.select %6, %10, %9 : index + %12 = linalg.index 3 : index + %13 = arith.cmpi slt, %12, %c0 : index + %14 = arith.subi %c-1, %12 : index + %15 = arith.select %13, %14, %12 : index + %16 = arith.divsi %15, %c2 : index + %17 = arith.subi %c-1, %16 : index + %18 = arith.select %13, %17, %16 : index + %19 = memref.load %arg0[%3, %4, %11, %18] : memref + linalg.yield %19 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0, 0, 0] [%c2, %c4, %c16, %c16] [1, 1, 1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d/orig.mlir new file mode 100644 index 000000000000..65617aa6b327 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d/orig.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + affine.for %arg2 = 0 to 2 { + affine.for %arg3 = 0 to 4 { + affine.for %arg4 = 0 to 16 { + %0 = arith.cmpi slt, %arg4, %c0 : index + %1 = arith.subi %c-1, %arg4 : index + %2 = arith.select %0, %1, %arg4 : index + %3 = arith.divsi %2, %c2 : index + %4 = arith.subi %c-1, %3 : index + %5 = arith.select %0, %4, %3 : index + affine.for %arg5 = 0 to 16 { + %6 = arith.cmpi slt, %arg5, %c0 : index + %7 = arith.subi %c-1, %arg5 : index + %8 = arith.select %6, %7, %arg5 : index + %9 = arith.divsi %8, %c2 : index + %10 = arith.subi %c-1, %9 : index + %11 = arith.select %6, %10, %9 : index + %12 = memref.load %arg0[%arg2, %arg3, %5, %11] : memref + affine.store %12, %arg1[%arg2, %arg3, %arg4, %arg5] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d/raised.mlir new file mode 100644 index 000000000000..e3c2a1b8e82e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d/raised.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %c-1 = arith.constant -1 : index + %subview = memref.subview %arg1[0, 0, 0, 0] [%c2, %c4, %c16, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = linalg.index 2 : index + %3 = arith.cmpi slt, %2, %c0 : index + %4 = arith.subi %c-1, %2 : index + %5 = arith.select %3, %4, %2 : index + %6 = arith.divsi %5, %c2 : index + %7 = arith.subi %c-1, %6 : index + %8 = arith.select %3, %7, %6 : index + %9 = linalg.index 3 : index + %10 = arith.cmpi slt, %9, %c0 : index + %11 = arith.subi %c-1, %9 : index + %12 = arith.select %10, %11, %9 : index + %13 = arith.divsi %12, %c2 : index + %14 = arith.subi %c-1, %13 : index + %15 = arith.select %10, %14, %13 : index + %16 = memref.load %arg0[%0, %1, %8, %15] : memref + linalg.yield %16 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu.mlir new file mode 100644 index 000000000000..610e07ba2996 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu.mlir @@ -0,0 +1,40 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8_i32 = arith.constant 8 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 40 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c5_i32 : i32 + %11 = arith.divsi %10, %c8_i32 : i32 + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = arith.select %12, %c4_i32, %11 : i32 + %14 = arith.addi %8, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %17 = memref.load %arg1[%15] : memref + %18 = arith.addf %17, %16 : f32 + memref.store %18, %arg1[%15] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..d3f11dcafbce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu/debuf.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c8_i32 = arith.constant 8 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c4_i32 : i32 + %10 = arith.divsi %9, %c7_i32 : i32 + %11 = arith.cmpi sge, %10, %c4_i32 : i32 + %12 = arith.select %11, %c3_i32, %10 : i32 + %13 = arith.addi %6, %12 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %16 = arith.index_cast %arg6 : index to i32 + %17 = arith.muli %16, %c5_i32 : i32 + %18 = arith.divsi %17, %c8_i32 : i32 + %19 = arith.cmpi sge, %18, %c5_i32 : i32 + %20 = arith.select %19, %c4_i32, %18 : i32 + %21 = arith.addi %14, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%23] : tensor + %extracted_0 = tensor.extract %arg7[%22] : tensor + %24 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %24 into %arg7[%22] : tensor + affine.yield %inserted : tensor + } + affine.yield %15 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..9a6964d2baf8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu/matched.mlir @@ -0,0 +1,49 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c8_i32 = arith.constant 8 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c4_i32 : i32 + %10 = arith.divsi %9, %c7_i32 : i32 + %11 = arith.cmpi sge, %10, %c4_i32 : i32 + %12 = arith.select %11, %c3_i32, %10 : i32 + %13 = arith.addi %6, %12 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %16 = arith.index_cast %arg6 : index to i32 + %17 = arith.muli %16, %c5_i32 : i32 + %18 = arith.divsi %17, %c8_i32 : i32 + %19 = arith.cmpi sge, %18, %c5_i32 : i32 + %20 = arith.select %19, %c4_i32, %18 : i32 + %21 = arith.addi %14, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%23] : tensor + %extracted_0 = tensor.extract %arg7[%22] : tensor + %24 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %24 into %arg7[%22] : tensor + affine.yield %inserted : tensor + } + affine.yield %15 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..610e07ba2996 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu/orig.mlir @@ -0,0 +1,40 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8_i32 = arith.constant 8 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 40 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c5_i32 : i32 + %11 = arith.divsi %10, %c8_i32 : i32 + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = arith.select %12, %c4_i32, %11 : i32 + %14 = arith.addi %8, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %17 = memref.load %arg1[%15] : memref + %18 = arith.addf %17, %16 : f32 + memref.store %18, %arg1[%15] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..991b7fb192a8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu/raised.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8_i32 = arith.constant 8 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c5_i32 : i32 + %11 = arith.divsi %10, %c8_i32 : i32 + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = arith.select %12, %c4_i32, %11 : i32 + %14 = arith.addi %8, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %17 = memref.load %arg1[%15] : memref + %18 = arith.addf %17, %16 : f32 + memref.store %18, %arg1[%15] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..d3f11dcafbce --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu_debuf.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c8_i32 = arith.constant 8 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c4_i32 : i32 + %10 = arith.divsi %9, %c7_i32 : i32 + %11 = arith.cmpi sge, %10, %c4_i32 : i32 + %12 = arith.select %11, %c3_i32, %10 : i32 + %13 = arith.addi %6, %12 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %16 = arith.index_cast %arg6 : index to i32 + %17 = arith.muli %16, %c5_i32 : i32 + %18 = arith.divsi %17, %c8_i32 : i32 + %19 = arith.cmpi sge, %18, %c5_i32 : i32 + %20 = arith.select %19, %c4_i32, %18 : i32 + %21 = arith.addi %14, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%23] : tensor + %extracted_0 = tensor.extract %arg7[%22] : tensor + %24 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %24 into %arg7[%22] : tensor + affine.yield %inserted : tensor + } + affine.yield %15 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..991b7fb192a8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d_backward_cpu_linalg.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8_i32 = arith.constant 8 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c5_i32 : i32 + %11 = arith.divsi %10, %c8_i32 : i32 + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = arith.select %12, %c4_i32, %11 : i32 + %14 = arith.addi %8, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %17 = memref.load %arg1[%15] : memref + %18 = arith.addf %17, %16 : f32 + memref.store %18, %arg1[%15] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu.mlir new file mode 100644 index 000000000000..d7e7d2e09e95 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8_i32 = arith.constant 8 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c5_i32 : i32 + %11 = arith.divsi %10, %c8_i32 : i32 + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = arith.select %12, %c4_i32, %11 : i32 + %14 = arith.addi %8, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = memref.load %arg0[%15] : memref + affine.store %16, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu/debuf.mlir new file mode 100644 index 000000000000..5fa4953c7286 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu/debuf.mlir @@ -0,0 +1,45 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 56 + d1 * 8)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %c8_i32 = arith.constant 8 : i32 + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8) {map = #map} : (tensor, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c4_i32 : i32 + %11 = arith.divsi %10, %c7_i32 : i32 + %12 = arith.cmpi sge, %11, %c4_i32 : i32 + %13 = arith.select %12, %c3_i32, %11 : i32 + %14 = arith.addi %7, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = linalg.index 2 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = arith.divsi %18, %c8_i32 : i32 + %20 = arith.cmpi sge, %19, %c5_i32 : i32 + %21 = arith.select %20, %c4_i32, %19 : i32 + %22 = arith.addi %15, %21 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = memref.load %arg0[%23] : memref + linalg.yield %24 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8) {map = #map} : (tensor, tensor, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu/matched.mlir new file mode 100644 index 000000000000..5fa4953c7286 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu/matched.mlir @@ -0,0 +1,45 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 56 + d1 * 8)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %c8_i32 = arith.constant 8 : i32 + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8) {map = #map} : (tensor, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c4_i32 : i32 + %11 = arith.divsi %10, %c7_i32 : i32 + %12 = arith.cmpi sge, %11, %c4_i32 : i32 + %13 = arith.select %12, %c3_i32, %11 : i32 + %14 = arith.addi %7, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = linalg.index 2 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = arith.divsi %18, %c8_i32 : i32 + %20 = arith.cmpi sge, %19, %c5_i32 : i32 + %21 = arith.select %20, %c4_i32, %19 : i32 + %22 = arith.addi %15, %21 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = memref.load %arg0[%23] : memref + linalg.yield %24 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8) {map = #map} : (tensor, tensor, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu/orig.mlir new file mode 100644 index 000000000000..d7e7d2e09e95 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu/orig.mlir @@ -0,0 +1,34 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c8_i32 = arith.constant 8 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c5_i32 : i32 + %11 = arith.divsi %10, %c8_i32 : i32 + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = arith.select %12, %c4_i32, %11 : i32 + %14 = arith.addi %8, %13 : i32 + %15 = arith.index_cast %14 : i32 to index + %16 = memref.load %arg0[%15] : memref + affine.store %16, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu/raised.mlir new file mode 100644 index 000000000000..cbef881826e2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu/raised.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 56 + d1 * 8)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c8_i32 = arith.constant 8 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %c4_i32 = arith.constant 4 : i32 + %0 = polygeist.submap(%arg1, %c2, %c7, %c8) {map = #map} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = arith.divsi %6, %c7_i32 : i32 + %8 = arith.cmpi sge, %7, %c4_i32 : i32 + %9 = arith.select %8, %c3_i32, %7 : i32 + %10 = arith.addi %3, %9 : i32 + %11 = arith.muli %10, %c5_i32 : i32 + %12 = linalg.index 2 : index + %13 = arith.index_cast %12 : index to i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = arith.divsi %14, %c8_i32 : i32 + %16 = arith.cmpi sge, %15, %c5_i32 : i32 + %17 = arith.select %16, %c4_i32, %15 : i32 + %18 = arith.addi %11, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg0[%19] : memref + linalg.yield %20 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu_debuf.mlir new file mode 100644 index 000000000000..5fa4953c7286 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu_debuf.mlir @@ -0,0 +1,45 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 56 + d1 * 8)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %c8_i32 = arith.constant 8 : i32 + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8) {map = #map} : (tensor, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c4_i32 : i32 + %11 = arith.divsi %10, %c7_i32 : i32 + %12 = arith.cmpi sge, %11, %c4_i32 : i32 + %13 = arith.select %12, %c3_i32, %11 : i32 + %14 = arith.addi %7, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = linalg.index 2 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = arith.divsi %18, %c8_i32 : i32 + %20 = arith.cmpi sge, %19, %c5_i32 : i32 + %21 = arith.select %20, %c4_i32, %19 : i32 + %22 = arith.addi %15, %21 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = memref.load %arg0[%23] : memref + linalg.yield %24 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8) {map = #map} : (tensor, tensor, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu_linalg.mlir new file mode 100644 index 000000000000..cbef881826e2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d_cpu_linalg.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 56 + d1 * 8)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c8_i32 = arith.constant 8 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %c4_i32 = arith.constant 4 : i32 + %0 = polygeist.submap(%arg1, %c2, %c7, %c8) {map = #map} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = arith.divsi %6, %c7_i32 : i32 + %8 = arith.cmpi sge, %7, %c4_i32 : i32 + %9 = arith.select %8, %c3_i32, %7 : i32 + %10 = arith.addi %3, %9 : i32 + %11 = arith.muli %10, %c5_i32 : i32 + %12 = linalg.index 2 : index + %13 = arith.index_cast %12 : index to i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = arith.divsi %14, %c8_i32 : i32 + %16 = arith.cmpi sge, %15, %c5_i32 : i32 + %17 = arith.select %16, %c4_i32, %15 : i32 + %18 = arith.addi %11, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg0[%19] : memref + linalg.yield %20 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d_debuf.mlir new file mode 100644 index 000000000000..4762de649493 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d_debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c16 = arith.constant 16 : index + %c4 = arith.constant 4 : index + %c0 = arith.constant 0 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %extracted_slice = tensor.extract_slice %0[0, 0, 0, 0] [%c2, %c4, %c16, %c16] [1, 1, 1, 1] : tensor to tensor + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = linalg.index 1 : index + %5 = linalg.index 2 : index + %6 = arith.cmpi slt, %5, %c0 : index + %7 = arith.subi %c-1, %5 : index + %8 = arith.select %6, %7, %5 : index + %9 = arith.divsi %8, %c2 : index + %10 = arith.subi %c-1, %9 : index + %11 = arith.select %6, %10, %9 : index + %12 = linalg.index 3 : index + %13 = arith.cmpi slt, %12, %c0 : index + %14 = arith.subi %c-1, %12 : index + %15 = arith.select %13, %14, %12 : index + %16 = arith.divsi %15, %c2 : index + %17 = arith.subi %c-1, %16 : index + %18 = arith.select %13, %17, %16 : index + %19 = memref.load %arg0[%3, %4, %11, %18] : memref + linalg.yield %19 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %1 into %0[0, 0, 0, 0] [%c2, %c4, %c16, %c16] [1, 1, 1, 1] : tensor into tensor + %2 = bufferization.to_memref %inserted_slice : memref + memref.copy %2, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest2d_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest2d_linalg.mlir new file mode 100644 index 000000000000..e3c2a1b8e82e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest2d_linalg.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest2d(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %c4 = arith.constant 4 : index + %c16 = arith.constant 16 : index + %c-1 = arith.constant -1 : index + %subview = memref.subview %arg1[0, 0, 0, 0] [%c2, %c4, %c16, %c16] [1, 1, 1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = linalg.index 1 : index + %2 = linalg.index 2 : index + %3 = arith.cmpi slt, %2, %c0 : index + %4 = arith.subi %c-1, %2 : index + %5 = arith.select %3, %4, %2 : index + %6 = arith.divsi %5, %c2 : index + %7 = arith.subi %c-1, %6 : index + %8 = arith.select %3, %7, %6 : index + %9 = linalg.index 3 : index + %10 = arith.cmpi slt, %9, %c0 : index + %11 = arith.subi %c-1, %9 : index + %12 = arith.select %10, %11, %9 : index + %13 = arith.divsi %12, %c2 : index + %14 = arith.subi %c-1, %13 : index + %15 = arith.select %10, %14, %13 : index + %16 = memref.load %arg0[%0, %1, %8, %15] : memref + linalg.yield %16 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu.mlir new file mode 100644 index 000000000000..155e716c59e8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu.mlir @@ -0,0 +1,51 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c9_i32 = arith.constant 9 : i32 + %c8_i32 = arith.constant 8 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 240 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c5_i32 : i32 + %11 = arith.divsi %10, %c8_i32 : i32 + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = arith.select %12, %c4_i32, %11 : i32 + %14 = arith.addi %8, %13 : i32 + %15 = arith.muli %14, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %16 = arith.index_cast %arg5 : index to i32 + %17 = arith.muli %16, %c6_i32 : i32 + %18 = arith.divsi %17, %c9_i32 : i32 + %19 = arith.cmpi sge, %18, %c6_i32 : i32 + %20 = arith.select %19, %c5_i32, %18 : i32 + %21 = arith.addi %15, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %24 = memref.load %arg1[%22] : memref + %25 = arith.addf %24, %23 : f32 + memref.store %25, %arg1[%22] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..2ecc01307458 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu/debuf.mlir @@ -0,0 +1,64 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0 * 504 + d1 + d2 * 72 + d3 * 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c8_i32 = arith.constant 8 : i32 + %c9_i32 = arith.constant 9 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c4_i32 : i32 + %10 = arith.divsi %9, %c7_i32 : i32 + %11 = arith.cmpi sge, %10, %c4_i32 : i32 + %12 = arith.select %11, %c3_i32, %10 : i32 + %13 = arith.addi %6, %12 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %16 = arith.index_cast %arg6 : index to i32 + %17 = arith.muli %16, %c5_i32 : i32 + %18 = arith.divsi %17, %c8_i32 : i32 + %19 = arith.cmpi sge, %18, %c5_i32 : i32 + %20 = arith.select %19, %c4_i32, %18 : i32 + %21 = arith.addi %14, %20 : i32 + %22 = arith.muli %21, %c6_i32 : i32 + %23 = affine.for %arg8 = 0 to 9 iter_args(%arg9 = %arg7) -> (tensor) { + %24 = arith.index_cast %arg8 : index to i32 + %25 = arith.muli %24, %c6_i32 : i32 + %26 = arith.divsi %25, %c9_i32 : i32 + %27 = arith.cmpi sge, %26, %c6_i32 : i32 + %28 = arith.select %27, %c5_i32, %26 : i32 + %29 = arith.addi %22, %28 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%31] : tensor + %extracted_0 = tensor.extract %arg9[%30] : tensor + %32 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %32 into %arg9[%30] : tensor + affine.yield %inserted : tensor + } + affine.yield %23 : tensor + } + affine.yield %15 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..66579adb715f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu/matched.mlir @@ -0,0 +1,61 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0 * 504 + d1 + d2 * 72 + d3 * 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c8_i32 = arith.constant 8 : i32 + %c9_i32 = arith.constant 9 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c4_i32 : i32 + %10 = arith.divsi %9, %c7_i32 : i32 + %11 = arith.cmpi sge, %10, %c4_i32 : i32 + %12 = arith.select %11, %c3_i32, %10 : i32 + %13 = arith.addi %6, %12 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %16 = arith.index_cast %arg6 : index to i32 + %17 = arith.muli %16, %c5_i32 : i32 + %18 = arith.divsi %17, %c8_i32 : i32 + %19 = arith.cmpi sge, %18, %c5_i32 : i32 + %20 = arith.select %19, %c4_i32, %18 : i32 + %21 = arith.addi %14, %20 : i32 + %22 = arith.muli %21, %c6_i32 : i32 + %23 = affine.for %arg8 = 0 to 9 iter_args(%arg9 = %arg7) -> (tensor) { + %24 = arith.index_cast %arg8 : index to i32 + %25 = arith.muli %24, %c6_i32 : i32 + %26 = arith.divsi %25, %c9_i32 : i32 + %27 = arith.cmpi sge, %26, %c6_i32 : i32 + %28 = arith.select %27, %c5_i32, %26 : i32 + %29 = arith.addi %22, %28 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%31] : tensor + %extracted_0 = tensor.extract %arg9[%30] : tensor + %32 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %32 into %arg9[%30] : tensor + affine.yield %inserted : tensor + } + affine.yield %23 : tensor + } + affine.yield %15 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..155e716c59e8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu/orig.mlir @@ -0,0 +1,51 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c9_i32 = arith.constant 9 : i32 + %c8_i32 = arith.constant 8 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 240 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c5_i32 : i32 + %11 = arith.divsi %10, %c8_i32 : i32 + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = arith.select %12, %c4_i32, %11 : i32 + %14 = arith.addi %8, %13 : i32 + %15 = arith.muli %14, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %16 = arith.index_cast %arg5 : index to i32 + %17 = arith.muli %16, %c6_i32 : i32 + %18 = arith.divsi %17, %c9_i32 : i32 + %19 = arith.cmpi sge, %18, %c6_i32 : i32 + %20 = arith.select %19, %c5_i32, %18 : i32 + %21 = arith.addi %15, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %24 = memref.load %arg1[%22] : memref + %25 = arith.addf %24, %23 : f32 + memref.store %25, %arg1[%22] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..405fb92028a5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu/raised.mlir @@ -0,0 +1,54 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c9_i32 = arith.constant 9 : i32 + %c8_i32 = arith.constant 8 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c5_i32 : i32 + %11 = arith.divsi %10, %c8_i32 : i32 + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = arith.select %12, %c4_i32, %11 : i32 + %14 = arith.addi %8, %13 : i32 + %15 = arith.muli %14, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %16 = arith.index_cast %arg5 : index to i32 + %17 = arith.muli %16, %c6_i32 : i32 + %18 = arith.divsi %17, %c9_i32 : i32 + %19 = arith.cmpi sge, %18, %c6_i32 : i32 + %20 = arith.select %19, %c5_i32, %18 : i32 + %21 = arith.addi %15, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %24 = memref.load %arg1[%22] : memref + %25 = arith.addf %24, %23 : f32 + memref.store %25, %arg1[%22] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..2ecc01307458 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu_debuf.mlir @@ -0,0 +1,64 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0 * 504 + d1 + d2 * 72 + d3 * 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c8_i32 = arith.constant 8 : i32 + %c9_i32 = arith.constant 9 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c4_i32 : i32 + %10 = arith.divsi %9, %c7_i32 : i32 + %11 = arith.cmpi sge, %10, %c4_i32 : i32 + %12 = arith.select %11, %c3_i32, %10 : i32 + %13 = arith.addi %6, %12 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %16 = arith.index_cast %arg6 : index to i32 + %17 = arith.muli %16, %c5_i32 : i32 + %18 = arith.divsi %17, %c8_i32 : i32 + %19 = arith.cmpi sge, %18, %c5_i32 : i32 + %20 = arith.select %19, %c4_i32, %18 : i32 + %21 = arith.addi %14, %20 : i32 + %22 = arith.muli %21, %c6_i32 : i32 + %23 = affine.for %arg8 = 0 to 9 iter_args(%arg9 = %arg7) -> (tensor) { + %24 = arith.index_cast %arg8 : index to i32 + %25 = arith.muli %24, %c6_i32 : i32 + %26 = arith.divsi %25, %c9_i32 : i32 + %27 = arith.cmpi sge, %26, %c6_i32 : i32 + %28 = arith.select %27, %c5_i32, %26 : i32 + %29 = arith.addi %22, %28 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%31] : tensor + %extracted_0 = tensor.extract %arg9[%30] : tensor + %32 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %32 into %arg9[%30] : tensor + affine.yield %inserted : tensor + } + affine.yield %23 : tensor + } + affine.yield %15 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..405fb92028a5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest3d_backward_cpu_linalg.mlir @@ -0,0 +1,54 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c9_i32 = arith.constant 9 : i32 + %c8_i32 = arith.constant 8 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c5_i32 : i32 + %11 = arith.divsi %10, %c8_i32 : i32 + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = arith.select %12, %c4_i32, %11 : i32 + %14 = arith.addi %8, %13 : i32 + %15 = arith.muli %14, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %16 = arith.index_cast %arg5 : index to i32 + %17 = arith.muli %16, %c6_i32 : i32 + %18 = arith.divsi %17, %c9_i32 : i32 + %19 = arith.cmpi sge, %18, %c6_i32 : i32 + %20 = arith.select %19, %c5_i32, %18 : i32 + %21 = arith.addi %15, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %24 = memref.load %arg1[%22] : memref + %25 = arith.addf %24, %23 : f32 + memref.store %25, %arg1[%22] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu.mlir new file mode 100644 index 000000000000..fdd07cf0adfe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu.mlir @@ -0,0 +1,45 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c9_i32 = arith.constant 9 : i32 + %c6_i32 = arith.constant 6 : i32 + %c8_i32 = arith.constant 8 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c5_i32 : i32 + %11 = arith.divsi %10, %c8_i32 : i32 + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = arith.select %12, %c4_i32, %11 : i32 + %14 = arith.addi %8, %13 : i32 + %15 = arith.muli %14, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %16 = arith.index_cast %arg5 : index to i32 + %17 = arith.muli %16, %c6_i32 : i32 + %18 = arith.divsi %17, %c9_i32 : i32 + %19 = arith.cmpi sge, %18, %c6_i32 : i32 + %20 = arith.select %19, %c5_i32, %18 : i32 + %21 = arith.addi %15, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = memref.load %arg0[%22] : memref + affine.store %23, %arg1[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu/debuf.mlir new file mode 100644 index 000000000000..37b8833902a2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu/debuf.mlir @@ -0,0 +1,56 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 504 + d1 * 72 + d2 * 9)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %c8_i32 = arith.constant 8 : i32 + %c6_i32 = arith.constant 6 : i32 + %c9_i32 = arith.constant 9 : i32 + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8, %c9) {map = #map} : (tensor, index, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c4_i32 : i32 + %11 = arith.divsi %10, %c7_i32 : i32 + %12 = arith.cmpi sge, %11, %c4_i32 : i32 + %13 = arith.select %12, %c3_i32, %11 : i32 + %14 = arith.addi %7, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = linalg.index 2 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = arith.divsi %18, %c8_i32 : i32 + %20 = arith.cmpi sge, %19, %c5_i32 : i32 + %21 = arith.select %20, %c4_i32, %19 : i32 + %22 = arith.addi %15, %21 : i32 + %23 = arith.muli %22, %c6_i32 : i32 + %24 = linalg.index 3 : index + %25 = arith.index_cast %24 : index to i32 + %26 = arith.muli %25, %c6_i32 : i32 + %27 = arith.divsi %26, %c9_i32 : i32 + %28 = arith.cmpi sge, %27, %c6_i32 : i32 + %29 = arith.select %28, %c5_i32, %27 : i32 + %30 = arith.addi %23, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %arg0[%31] : memref + linalg.yield %32 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8, %c9) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu/matched.mlir new file mode 100644 index 000000000000..37b8833902a2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu/matched.mlir @@ -0,0 +1,56 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 504 + d1 * 72 + d2 * 9)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %c8_i32 = arith.constant 8 : i32 + %c6_i32 = arith.constant 6 : i32 + %c9_i32 = arith.constant 9 : i32 + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8, %c9) {map = #map} : (tensor, index, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c4_i32 : i32 + %11 = arith.divsi %10, %c7_i32 : i32 + %12 = arith.cmpi sge, %11, %c4_i32 : i32 + %13 = arith.select %12, %c3_i32, %11 : i32 + %14 = arith.addi %7, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = linalg.index 2 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = arith.divsi %18, %c8_i32 : i32 + %20 = arith.cmpi sge, %19, %c5_i32 : i32 + %21 = arith.select %20, %c4_i32, %19 : i32 + %22 = arith.addi %15, %21 : i32 + %23 = arith.muli %22, %c6_i32 : i32 + %24 = linalg.index 3 : index + %25 = arith.index_cast %24 : index to i32 + %26 = arith.muli %25, %c6_i32 : i32 + %27 = arith.divsi %26, %c9_i32 : i32 + %28 = arith.cmpi sge, %27, %c6_i32 : i32 + %29 = arith.select %28, %c5_i32, %27 : i32 + %30 = arith.addi %23, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %arg0[%31] : memref + linalg.yield %32 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8, %c9) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu/orig.mlir new file mode 100644 index 000000000000..fdd07cf0adfe --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu/orig.mlir @@ -0,0 +1,45 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c9_i32 = arith.constant 9 : i32 + %c6_i32 = arith.constant 6 : i32 + %c8_i32 = arith.constant 8 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = arith.divsi %3, %c7_i32 : i32 + %5 = arith.cmpi sge, %4, %c4_i32 : i32 + %6 = arith.select %5, %c3_i32, %4 : i32 + %7 = arith.addi %1, %6 : i32 + %8 = arith.muli %7, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %9 = arith.index_cast %arg4 : index to i32 + %10 = arith.muli %9, %c5_i32 : i32 + %11 = arith.divsi %10, %c8_i32 : i32 + %12 = arith.cmpi sge, %11, %c5_i32 : i32 + %13 = arith.select %12, %c4_i32, %11 : i32 + %14 = arith.addi %8, %13 : i32 + %15 = arith.muli %14, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %16 = arith.index_cast %arg5 : index to i32 + %17 = arith.muli %16, %c6_i32 : i32 + %18 = arith.divsi %17, %c9_i32 : i32 + %19 = arith.cmpi sge, %18, %c6_i32 : i32 + %20 = arith.select %19, %c5_i32, %18 : i32 + %21 = arith.addi %15, %20 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = memref.load %arg0[%22] : memref + affine.store %23, %arg1[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu/raised.mlir new file mode 100644 index 000000000000..2670959d951c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu/raised.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 504 + d1 * 72 + d2 * 9)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c9 = arith.constant 9 : index + %c9_i32 = arith.constant 9 : i32 + %c6_i32 = arith.constant 6 : i32 + %c8_i32 = arith.constant 8 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %c4_i32 = arith.constant 4 : i32 + %0 = polygeist.submap(%arg1, %c2, %c7, %c8, %c9) {map = #map} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = arith.divsi %6, %c7_i32 : i32 + %8 = arith.cmpi sge, %7, %c4_i32 : i32 + %9 = arith.select %8, %c3_i32, %7 : i32 + %10 = arith.addi %3, %9 : i32 + %11 = arith.muli %10, %c5_i32 : i32 + %12 = linalg.index 2 : index + %13 = arith.index_cast %12 : index to i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = arith.divsi %14, %c8_i32 : i32 + %16 = arith.cmpi sge, %15, %c5_i32 : i32 + %17 = arith.select %16, %c4_i32, %15 : i32 + %18 = arith.addi %11, %17 : i32 + %19 = arith.muli %18, %c6_i32 : i32 + %20 = linalg.index 3 : index + %21 = arith.index_cast %20 : index to i32 + %22 = arith.muli %21, %c6_i32 : i32 + %23 = arith.divsi %22, %c9_i32 : i32 + %24 = arith.cmpi sge, %23, %c6_i32 : i32 + %25 = arith.select %24, %c5_i32, %23 : i32 + %26 = arith.addi %19, %25 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = memref.load %arg0[%27] : memref + linalg.yield %28 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu_debuf.mlir new file mode 100644 index 000000000000..37b8833902a2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu_debuf.mlir @@ -0,0 +1,56 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 504 + d1 * 72 + d2 * 9)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c7_i32 = arith.constant 7 : i32 + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %c8_i32 = arith.constant 8 : i32 + %c6_i32 = arith.constant 6 : i32 + %c9_i32 = arith.constant 9 : i32 + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8, %c9) {map = #map} : (tensor, index, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c4_i32 : i32 + %11 = arith.divsi %10, %c7_i32 : i32 + %12 = arith.cmpi sge, %11, %c4_i32 : i32 + %13 = arith.select %12, %c3_i32, %11 : i32 + %14 = arith.addi %7, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = linalg.index 2 : index + %17 = arith.index_cast %16 : index to i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = arith.divsi %18, %c8_i32 : i32 + %20 = arith.cmpi sge, %19, %c5_i32 : i32 + %21 = arith.select %20, %c4_i32, %19 : i32 + %22 = arith.addi %15, %21 : i32 + %23 = arith.muli %22, %c6_i32 : i32 + %24 = linalg.index 3 : index + %25 = arith.index_cast %24 : index to i32 + %26 = arith.muli %25, %c6_i32 : i32 + %27 = arith.divsi %26, %c9_i32 : i32 + %28 = arith.cmpi sge, %27, %c6_i32 : i32 + %29 = arith.select %28, %c5_i32, %27 : i32 + %30 = arith.addi %23, %29 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %arg0[%31] : memref + linalg.yield %32 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8, %c9) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu_linalg.mlir new file mode 100644 index 000000000000..2670959d951c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest3d_cpu_linalg.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 504 + d1 * 72 + d2 * 9)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c9 = arith.constant 9 : index + %c9_i32 = arith.constant 9 : i32 + %c6_i32 = arith.constant 6 : i32 + %c8_i32 = arith.constant 8 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7_i32 = arith.constant 7 : i32 + %c4_i32 = arith.constant 4 : i32 + %0 = polygeist.submap(%arg1, %c2, %c7, %c8, %c9) {map = #map} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = arith.divsi %6, %c7_i32 : i32 + %8 = arith.cmpi sge, %7, %c4_i32 : i32 + %9 = arith.select %8, %c3_i32, %7 : i32 + %10 = arith.addi %3, %9 : i32 + %11 = arith.muli %10, %c5_i32 : i32 + %12 = linalg.index 2 : index + %13 = arith.index_cast %12 : index to i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = arith.divsi %14, %c8_i32 : i32 + %16 = arith.cmpi sge, %15, %c5_i32 : i32 + %17 = arith.select %16, %c4_i32, %15 : i32 + %18 = arith.addi %11, %17 : i32 + %19 = arith.muli %18, %c6_i32 : i32 + %20 = linalg.index 3 : index + %21 = arith.index_cast %20 : index to i32 + %22 = arith.muli %21, %c6_i32 : i32 + %23 = arith.divsi %22, %c9_i32 : i32 + %24 = arith.cmpi sge, %23, %c6_i32 : i32 + %25 = arith.select %24, %c5_i32, %23 : i32 + %26 = arith.addi %19, %25 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = memref.load %arg0[%27] : memref + linalg.yield %28 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu.mlir new file mode 100644 index 000000000000..f884b5cdb6aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu.mlir @@ -0,0 +1,33 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 8 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.index_cast %9 : i32 to index + %11 = affine.load %arg0[%arg3 + %arg2 * 7] : memref + %12 = memref.load %arg1[%10] : memref + %13 = arith.addf %12, %11 : f32 + memref.store %13, %arg1[%10] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..a51a6c7a264f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu/debuf.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0 + d1 * 7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c2_i32 : i32 + %10 = arith.addi %9, %c1_i32 : i32 + %11 = arith.muli %10, %c4_i32 : i32 + %12 = arith.divsi %11, %c14_i32 : i32 + %13 = arith.cmpi sge, %12, %c4_i32 : i32 + %14 = arith.select %13, %c3_i32, %12 : i32 + %15 = arith.addi %6, %14 : i32 + %16 = arith.index_cast %15 : i32 to index + %17 = affine.apply #map1(%arg4, %arg2) + %extracted = tensor.extract %1[%17] : tensor + %extracted_0 = tensor.extract %arg5[%16] : tensor + %18 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %18 into %arg5[%16] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..3d2c4e5695d5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu/matched.mlir @@ -0,0 +1,41 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0 + d1 * 7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c2_i32 : i32 + %10 = arith.addi %9, %c1_i32 : i32 + %11 = arith.muli %10, %c4_i32 : i32 + %12 = arith.divsi %11, %c14_i32 : i32 + %13 = arith.cmpi sge, %12, %c4_i32 : i32 + %14 = arith.select %13, %c3_i32, %12 : i32 + %15 = arith.addi %6, %14 : i32 + %16 = arith.index_cast %15 : i32 to index + %17 = affine.apply #map1(%arg4, %arg2) + %extracted = tensor.extract %1[%17] : tensor + %extracted_0 = tensor.extract %arg5[%16] : tensor + %18 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %18 into %arg5[%16] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..f884b5cdb6aa --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu/orig.mlir @@ -0,0 +1,33 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 8 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.index_cast %9 : i32 to index + %11 = affine.load %arg0[%arg3 + %arg2 * 7] : memref + %12 = memref.load %arg1[%10] : memref + %13 = arith.addf %12, %11 : f32 + memref.store %13, %arg1[%10] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..154b41d678ef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu/raised.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.index_cast %9 : i32 to index + %11 = affine.load %arg0[%arg3 + %arg2 * 7] : memref + %12 = memref.load %arg1[%10] : memref + %13 = arith.addf %12, %11 : f32 + memref.store %13, %arg1[%10] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..a51a6c7a264f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu_debuf.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0 + d1 * 7)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c2_i32 : i32 + %10 = arith.addi %9, %c1_i32 : i32 + %11 = arith.muli %10, %c4_i32 : i32 + %12 = arith.divsi %11, %c14_i32 : i32 + %13 = arith.cmpi sge, %12, %c4_i32 : i32 + %14 = arith.select %13, %c3_i32, %12 : i32 + %15 = arith.addi %6, %14 : i32 + %16 = arith.index_cast %15 : i32 to index + %17 = affine.apply #map1(%arg4, %arg2) + %extracted = tensor.extract %1[%17] : tensor + %extracted_0 = tensor.extract %arg5[%16] : tensor + %18 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %18 into %arg5[%16] : tensor + affine.yield %inserted : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..154b41d678ef --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_backward_cpu_linalg.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact1d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.index_cast %9 : i32 to index + %11 = affine.load %arg0[%arg3 + %arg2 * 7] : memref + %12 = memref.load %arg1[%10] : memref + %13 = arith.addf %12, %11 : f32 + memref.store %13, %arg1[%10] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu.mlir new file mode 100644 index 000000000000..2ab7c18e543d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.index_cast %9 : i32 to index + %11 = memref.load %arg0[%10] : memref + affine.store %11, %arg1[%arg3 + %arg2 * 7] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu/debuf.mlir new file mode 100644 index 000000000000..027e392b3c55 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu/debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 7)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c2_i32 : i32 + %11 = arith.addi %10, %c1_i32 : i32 + %12 = arith.muli %11, %c4_i32 : i32 + %13 = arith.divsi %12, %c14_i32 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.select %14, %c3_i32, %13 : i32 + %16 = arith.addi %7, %15 : i32 + %17 = arith.index_cast %16 : i32 to index + %18 = memref.load %arg0[%17] : memref + linalg.yield %18 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu/matched.mlir new file mode 100644 index 000000000000..027e392b3c55 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu/matched.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 7)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c2_i32 : i32 + %11 = arith.addi %10, %c1_i32 : i32 + %12 = arith.muli %11, %c4_i32 : i32 + %13 = arith.divsi %12, %c14_i32 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.select %14, %c3_i32, %13 : i32 + %16 = arith.addi %7, %15 : i32 + %17 = arith.index_cast %16 : i32 to index + %18 = memref.load %arg0[%17] : memref + linalg.yield %18 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu/orig.mlir new file mode 100644 index 000000000000..2ab7c18e543d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu/orig.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.index_cast %9 : i32 to index + %11 = memref.load %arg0[%10] : memref + affine.store %11, %arg1[%arg3 + %arg2 * 7] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu/raised.mlir new file mode 100644 index 000000000000..c5079cefb02c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu/raised.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 7)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %0 = polygeist.submap(%arg1, %c2, %c7) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.muli %5, %c2_i32 : i32 + %7 = arith.addi %6, %c1_i32 : i32 + %8 = arith.muli %7, %c4_i32 : i32 + %9 = arith.divsi %8, %c14_i32 : i32 + %10 = arith.cmpi sge, %9, %c4_i32 : i32 + %11 = arith.select %10, %c3_i32, %9 : i32 + %12 = arith.addi %3, %11 : i32 + %13 = arith.index_cast %12 : i32 to index + %14 = memref.load %arg0[%13] : memref + linalg.yield %14 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu_debuf.mlir new file mode 100644 index 000000000000..027e392b3c55 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu_debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 7)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7) {map = #map} : (tensor, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c2_i32 : i32 + %11 = arith.addi %10, %c1_i32 : i32 + %12 = arith.muli %11, %c4_i32 : i32 + %13 = arith.divsi %12, %c14_i32 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.select %14, %c3_i32, %13 : i32 + %16 = arith.addi %7, %15 : i32 + %17 = arith.index_cast %16 : i32 to index + %18 = memref.load %arg0[%17] : memref + linalg.yield %18 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7) {map = #map} : (tensor, tensor, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu_linalg.mlir new file mode 100644 index 000000000000..c5079cefb02c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact1d_cpu_linalg.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 7)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact1d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %0 = polygeist.submap(%arg1, %c2, %c7) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.muli %5, %c2_i32 : i32 + %7 = arith.addi %6, %c1_i32 : i32 + %8 = arith.muli %7, %c4_i32 : i32 + %9 = arith.divsi %8, %c14_i32 : i32 + %10 = arith.cmpi sge, %9, %c4_i32 : i32 + %11 = arith.select %10, %c3_i32, %9 : i32 + %12 = arith.addi %3, %11 : i32 + %13 = arith.index_cast %12 : i32 to index + %14 = memref.load %arg0[%13] : memref + linalg.yield %14 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu.mlir new file mode 100644 index 000000000000..37967573131d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu.mlir @@ -0,0 +1,46 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16_i32 = arith.constant 16 : i32 + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 40 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.muli %9, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %11 = arith.index_cast %arg4 : index to i32 + %12 = arith.muli %11, %c2_i32 : i32 + %13 = arith.addi %12, %c1_i32 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = arith.divsi %14, %c16_i32 : i32 + %16 = arith.cmpi sge, %15, %c5_i32 : i32 + %17 = arith.select %16, %c4_i32, %15 : i32 + %18 = arith.addi %10, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %21 = memref.load %arg1[%19] : memref + %22 = arith.addf %21, %20 : f32 + memref.store %22, %arg1[%19] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..69434bd3cf61 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu/debuf.mlir @@ -0,0 +1,58 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %c16_i32 = arith.constant 16 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c2_i32 : i32 + %10 = arith.addi %9, %c1_i32 : i32 + %11 = arith.muli %10, %c4_i32 : i32 + %12 = arith.divsi %11, %c14_i32 : i32 + %13 = arith.cmpi sge, %12, %c4_i32 : i32 + %14 = arith.select %13, %c3_i32, %12 : i32 + %15 = arith.addi %6, %14 : i32 + %16 = arith.muli %15, %c5_i32 : i32 + %17 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %18 = arith.index_cast %arg6 : index to i32 + %19 = arith.muli %18, %c2_i32 : i32 + %20 = arith.addi %19, %c1_i32 : i32 + %21 = arith.muli %20, %c5_i32 : i32 + %22 = arith.divsi %21, %c16_i32 : i32 + %23 = arith.cmpi sge, %22, %c5_i32 : i32 + %24 = arith.select %23, %c4_i32, %22 : i32 + %25 = arith.addi %16, %24 : i32 + %26 = arith.index_cast %25 : i32 to index + %27 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%27] : tensor + %extracted_0 = tensor.extract %arg7[%26] : tensor + %28 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %28 into %arg7[%26] : tensor + affine.yield %inserted : tensor + } + affine.yield %17 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..36fb89bf8fcf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu/matched.mlir @@ -0,0 +1,55 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %c16_i32 = arith.constant 16 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c2_i32 : i32 + %10 = arith.addi %9, %c1_i32 : i32 + %11 = arith.muli %10, %c4_i32 : i32 + %12 = arith.divsi %11, %c14_i32 : i32 + %13 = arith.cmpi sge, %12, %c4_i32 : i32 + %14 = arith.select %13, %c3_i32, %12 : i32 + %15 = arith.addi %6, %14 : i32 + %16 = arith.muli %15, %c5_i32 : i32 + %17 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %18 = arith.index_cast %arg6 : index to i32 + %19 = arith.muli %18, %c2_i32 : i32 + %20 = arith.addi %19, %c1_i32 : i32 + %21 = arith.muli %20, %c5_i32 : i32 + %22 = arith.divsi %21, %c16_i32 : i32 + %23 = arith.cmpi sge, %22, %c5_i32 : i32 + %24 = arith.select %23, %c4_i32, %22 : i32 + %25 = arith.addi %16, %24 : i32 + %26 = arith.index_cast %25 : i32 to index + %27 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%27] : tensor + %extracted_0 = tensor.extract %arg7[%26] : tensor + %28 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %28 into %arg7[%26] : tensor + affine.yield %inserted : tensor + } + affine.yield %17 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..37967573131d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu/orig.mlir @@ -0,0 +1,46 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16_i32 = arith.constant 16 : i32 + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 40 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.muli %9, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %11 = arith.index_cast %arg4 : index to i32 + %12 = arith.muli %11, %c2_i32 : i32 + %13 = arith.addi %12, %c1_i32 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = arith.divsi %14, %c16_i32 : i32 + %16 = arith.cmpi sge, %15, %c5_i32 : i32 + %17 = arith.select %16, %c4_i32, %15 : i32 + %18 = arith.addi %10, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %21 = memref.load %arg1[%19] : memref + %22 = arith.addf %21, %20 : f32 + memref.store %22, %arg1[%19] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..ad6c1684e734 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu/raised.mlir @@ -0,0 +1,49 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16_i32 = arith.constant 16 : i32 + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.muli %9, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %11 = arith.index_cast %arg4 : index to i32 + %12 = arith.muli %11, %c2_i32 : i32 + %13 = arith.addi %12, %c1_i32 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = arith.divsi %14, %c16_i32 : i32 + %16 = arith.cmpi sge, %15, %c5_i32 : i32 + %17 = arith.select %16, %c4_i32, %15 : i32 + %18 = arith.addi %10, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %21 = memref.load %arg1[%19] : memref + %22 = arith.addf %21, %20 : f32 + memref.store %22, %arg1[%19] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..69434bd3cf61 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu_debuf.mlir @@ -0,0 +1,58 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2) -> (d0 + d1 * 56 + d2 * 8)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %c16_i32 = arith.constant 16 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c2_i32 : i32 + %10 = arith.addi %9, %c1_i32 : i32 + %11 = arith.muli %10, %c4_i32 : i32 + %12 = arith.divsi %11, %c14_i32 : i32 + %13 = arith.cmpi sge, %12, %c4_i32 : i32 + %14 = arith.select %13, %c3_i32, %12 : i32 + %15 = arith.addi %6, %14 : i32 + %16 = arith.muli %15, %c5_i32 : i32 + %17 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %18 = arith.index_cast %arg6 : index to i32 + %19 = arith.muli %18, %c2_i32 : i32 + %20 = arith.addi %19, %c1_i32 : i32 + %21 = arith.muli %20, %c5_i32 : i32 + %22 = arith.divsi %21, %c16_i32 : i32 + %23 = arith.cmpi sge, %22, %c5_i32 : i32 + %24 = arith.select %23, %c4_i32, %22 : i32 + %25 = arith.addi %16, %24 : i32 + %26 = arith.index_cast %25 : i32 to index + %27 = affine.apply #map1(%arg6, %arg2, %arg4) + %extracted = tensor.extract %1[%27] : tensor + %extracted_0 = tensor.extract %arg7[%26] : tensor + %28 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %28 into %arg7[%26] : tensor + affine.yield %inserted : tensor + } + affine.yield %17 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..ad6c1684e734 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_backward_cpu_linalg.mlir @@ -0,0 +1,49 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact2d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16_i32 = arith.constant 16 : i32 + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.muli %9, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %11 = arith.index_cast %arg4 : index to i32 + %12 = arith.muli %11, %c2_i32 : i32 + %13 = arith.addi %12, %c1_i32 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = arith.divsi %14, %c16_i32 : i32 + %16 = arith.cmpi sge, %15, %c5_i32 : i32 + %17 = arith.select %16, %c4_i32, %15 : i32 + %18 = arith.addi %10, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = affine.load %arg0[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + %21 = memref.load %arg1[%19] : memref + %22 = arith.addf %21, %20 : f32 + memref.store %22, %arg1[%19] : memref + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu.mlir new file mode 100644 index 000000000000..528fe76c4f96 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu.mlir @@ -0,0 +1,40 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16_i32 = arith.constant 16 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.muli %9, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %11 = arith.index_cast %arg4 : index to i32 + %12 = arith.muli %11, %c2_i32 : i32 + %13 = arith.addi %12, %c1_i32 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = arith.divsi %14, %c16_i32 : i32 + %16 = arith.cmpi sge, %15, %c5_i32 : i32 + %17 = arith.select %16, %c4_i32, %15 : i32 + %18 = arith.addi %10, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg0[%19] : memref + affine.store %20, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu/debuf.mlir new file mode 100644 index 000000000000..8a05539c263f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu/debuf.mlir @@ -0,0 +1,51 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 56 + d1 * 8)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %c16_i32 = arith.constant 16 : i32 + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8) {map = #map} : (tensor, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c2_i32 : i32 + %11 = arith.addi %10, %c1_i32 : i32 + %12 = arith.muli %11, %c4_i32 : i32 + %13 = arith.divsi %12, %c14_i32 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.select %14, %c3_i32, %13 : i32 + %16 = arith.addi %7, %15 : i32 + %17 = arith.muli %16, %c5_i32 : i32 + %18 = linalg.index 2 : index + %19 = arith.index_cast %18 : index to i32 + %20 = arith.muli %19, %c2_i32 : i32 + %21 = arith.addi %20, %c1_i32 : i32 + %22 = arith.muli %21, %c5_i32 : i32 + %23 = arith.divsi %22, %c16_i32 : i32 + %24 = arith.cmpi sge, %23, %c5_i32 : i32 + %25 = arith.select %24, %c4_i32, %23 : i32 + %26 = arith.addi %17, %25 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = memref.load %arg0[%27] : memref + linalg.yield %28 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8) {map = #map} : (tensor, tensor, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu/matched.mlir new file mode 100644 index 000000000000..8a05539c263f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu/matched.mlir @@ -0,0 +1,51 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 56 + d1 * 8)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %c16_i32 = arith.constant 16 : i32 + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8) {map = #map} : (tensor, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c2_i32 : i32 + %11 = arith.addi %10, %c1_i32 : i32 + %12 = arith.muli %11, %c4_i32 : i32 + %13 = arith.divsi %12, %c14_i32 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.select %14, %c3_i32, %13 : i32 + %16 = arith.addi %7, %15 : i32 + %17 = arith.muli %16, %c5_i32 : i32 + %18 = linalg.index 2 : index + %19 = arith.index_cast %18 : index to i32 + %20 = arith.muli %19, %c2_i32 : i32 + %21 = arith.addi %20, %c1_i32 : i32 + %22 = arith.muli %21, %c5_i32 : i32 + %23 = arith.divsi %22, %c16_i32 : i32 + %24 = arith.cmpi sge, %23, %c5_i32 : i32 + %25 = arith.select %24, %c4_i32, %23 : i32 + %26 = arith.addi %17, %25 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = memref.load %arg0[%27] : memref + linalg.yield %28 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8) {map = #map} : (tensor, tensor, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu/orig.mlir new file mode 100644 index 000000000000..528fe76c4f96 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu/orig.mlir @@ -0,0 +1,40 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c16_i32 = arith.constant 16 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.muli %9, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %11 = arith.index_cast %arg4 : index to i32 + %12 = arith.muli %11, %c2_i32 : i32 + %13 = arith.addi %12, %c1_i32 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = arith.divsi %14, %c16_i32 : i32 + %16 = arith.cmpi sge, %15, %c5_i32 : i32 + %17 = arith.select %16, %c4_i32, %15 : i32 + %18 = arith.addi %10, %17 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg0[%19] : memref + affine.store %20, %arg1[%arg4 + %arg2 * 56 + %arg3 * 8] : memref + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu/raised.mlir new file mode 100644 index 000000000000..955a84d4bfda --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu/raised.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 56 + d1 * 8)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c16_i32 = arith.constant 16 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %0 = polygeist.submap(%arg1, %c2, %c7, %c8) {map = #map} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.muli %5, %c2_i32 : i32 + %7 = arith.addi %6, %c1_i32 : i32 + %8 = arith.muli %7, %c4_i32 : i32 + %9 = arith.divsi %8, %c14_i32 : i32 + %10 = arith.cmpi sge, %9, %c4_i32 : i32 + %11 = arith.select %10, %c3_i32, %9 : i32 + %12 = arith.addi %3, %11 : i32 + %13 = arith.muli %12, %c5_i32 : i32 + %14 = linalg.index 2 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.muli %15, %c2_i32 : i32 + %17 = arith.addi %16, %c1_i32 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = arith.divsi %18, %c16_i32 : i32 + %20 = arith.cmpi sge, %19, %c5_i32 : i32 + %21 = arith.select %20, %c4_i32, %19 : i32 + %22 = arith.addi %13, %21 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = memref.load %arg0[%23] : memref + linalg.yield %24 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu_debuf.mlir new file mode 100644 index 000000000000..8a05539c263f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu_debuf.mlir @@ -0,0 +1,51 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 56 + d1 * 8)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %c16_i32 = arith.constant 16 : i32 + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8) {map = #map} : (tensor, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c2_i32 : i32 + %11 = arith.addi %10, %c1_i32 : i32 + %12 = arith.muli %11, %c4_i32 : i32 + %13 = arith.divsi %12, %c14_i32 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.select %14, %c3_i32, %13 : i32 + %16 = arith.addi %7, %15 : i32 + %17 = arith.muli %16, %c5_i32 : i32 + %18 = linalg.index 2 : index + %19 = arith.index_cast %18 : index to i32 + %20 = arith.muli %19, %c2_i32 : i32 + %21 = arith.addi %20, %c1_i32 : i32 + %22 = arith.muli %21, %c5_i32 : i32 + %23 = arith.divsi %22, %c16_i32 : i32 + %24 = arith.cmpi sge, %23, %c5_i32 : i32 + %25 = arith.select %24, %c4_i32, %23 : i32 + %26 = arith.addi %17, %25 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = memref.load %arg0[%27] : memref + linalg.yield %28 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8) {map = #map} : (tensor, tensor, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu_linalg.mlir new file mode 100644 index 000000000000..955a84d4bfda --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact2d_cpu_linalg.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0, d1, d2) -> (d2 + d0 * 56 + d1 * 8)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact2d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c16_i32 = arith.constant 16 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %0 = polygeist.submap(%arg1, %c2, %c7, %c8) {map = #map} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.muli %5, %c2_i32 : i32 + %7 = arith.addi %6, %c1_i32 : i32 + %8 = arith.muli %7, %c4_i32 : i32 + %9 = arith.divsi %8, %c14_i32 : i32 + %10 = arith.cmpi sge, %9, %c4_i32 : i32 + %11 = arith.select %10, %c3_i32, %9 : i32 + %12 = arith.addi %3, %11 : i32 + %13 = arith.muli %12, %c5_i32 : i32 + %14 = linalg.index 2 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.muli %15, %c2_i32 : i32 + %17 = arith.addi %16, %c1_i32 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = arith.divsi %18, %c16_i32 : i32 + %20 = arith.cmpi sge, %19, %c5_i32 : i32 + %21 = arith.select %20, %c4_i32, %19 : i32 + %22 = arith.addi %13, %21 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = memref.load %arg0[%23] : memref + linalg.yield %24 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu.mlir new file mode 100644 index 000000000000..5b75f1443e9a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu.mlir @@ -0,0 +1,59 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c18_i32 = arith.constant 18 : i32 + %c16_i32 = arith.constant 16 : i32 + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 240 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.muli %9, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %11 = arith.index_cast %arg4 : index to i32 + %12 = arith.muli %11, %c2_i32 : i32 + %13 = arith.addi %12, %c1_i32 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = arith.divsi %14, %c16_i32 : i32 + %16 = arith.cmpi sge, %15, %c5_i32 : i32 + %17 = arith.select %16, %c4_i32, %15 : i32 + %18 = arith.addi %10, %17 : i32 + %19 = arith.muli %18, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %20 = arith.index_cast %arg5 : index to i32 + %21 = arith.muli %20, %c2_i32 : i32 + %22 = arith.addi %21, %c1_i32 : i32 + %23 = arith.muli %22, %c6_i32 : i32 + %24 = arith.divsi %23, %c18_i32 : i32 + %25 = arith.cmpi sge, %24, %c6_i32 : i32 + %26 = arith.select %25, %c5_i32, %24 : i32 + %27 = arith.addi %19, %26 : i32 + %28 = arith.index_cast %27 : i32 to index + %29 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %30 = memref.load %arg1[%28] : memref + %31 = arith.addf %30, %29 : f32 + memref.store %31, %arg1[%28] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..9019cca711ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu/debuf.mlir @@ -0,0 +1,72 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0 * 504 + d1 + d2 * 72 + d3 * 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %c16_i32 = arith.constant 16 : i32 + %c18_i32 = arith.constant 18 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c2_i32 : i32 + %10 = arith.addi %9, %c1_i32 : i32 + %11 = arith.muli %10, %c4_i32 : i32 + %12 = arith.divsi %11, %c14_i32 : i32 + %13 = arith.cmpi sge, %12, %c4_i32 : i32 + %14 = arith.select %13, %c3_i32, %12 : i32 + %15 = arith.addi %6, %14 : i32 + %16 = arith.muli %15, %c5_i32 : i32 + %17 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %18 = arith.index_cast %arg6 : index to i32 + %19 = arith.muli %18, %c2_i32 : i32 + %20 = arith.addi %19, %c1_i32 : i32 + %21 = arith.muli %20, %c5_i32 : i32 + %22 = arith.divsi %21, %c16_i32 : i32 + %23 = arith.cmpi sge, %22, %c5_i32 : i32 + %24 = arith.select %23, %c4_i32, %22 : i32 + %25 = arith.addi %16, %24 : i32 + %26 = arith.muli %25, %c6_i32 : i32 + %27 = affine.for %arg8 = 0 to 9 iter_args(%arg9 = %arg7) -> (tensor) { + %28 = arith.index_cast %arg8 : index to i32 + %29 = arith.muli %28, %c2_i32 : i32 + %30 = arith.addi %29, %c1_i32 : i32 + %31 = arith.muli %30, %c6_i32 : i32 + %32 = arith.divsi %31, %c18_i32 : i32 + %33 = arith.cmpi sge, %32, %c6_i32 : i32 + %34 = arith.select %33, %c5_i32, %32 : i32 + %35 = arith.addi %26, %34 : i32 + %36 = arith.index_cast %35 : i32 to index + %37 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%37] : tensor + %extracted_0 = tensor.extract %arg9[%36] : tensor + %38 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %38 into %arg9[%36] : tensor + affine.yield %inserted : tensor + } + affine.yield %27 : tensor + } + affine.yield %17 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..cf92b6f10110 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu/matched.mlir @@ -0,0 +1,69 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0 * 504 + d1 + d2 * 72 + d3 * 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %c16_i32 = arith.constant 16 : i32 + %c18_i32 = arith.constant 18 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c2_i32 : i32 + %10 = arith.addi %9, %c1_i32 : i32 + %11 = arith.muli %10, %c4_i32 : i32 + %12 = arith.divsi %11, %c14_i32 : i32 + %13 = arith.cmpi sge, %12, %c4_i32 : i32 + %14 = arith.select %13, %c3_i32, %12 : i32 + %15 = arith.addi %6, %14 : i32 + %16 = arith.muli %15, %c5_i32 : i32 + %17 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %18 = arith.index_cast %arg6 : index to i32 + %19 = arith.muli %18, %c2_i32 : i32 + %20 = arith.addi %19, %c1_i32 : i32 + %21 = arith.muli %20, %c5_i32 : i32 + %22 = arith.divsi %21, %c16_i32 : i32 + %23 = arith.cmpi sge, %22, %c5_i32 : i32 + %24 = arith.select %23, %c4_i32, %22 : i32 + %25 = arith.addi %16, %24 : i32 + %26 = arith.muli %25, %c6_i32 : i32 + %27 = affine.for %arg8 = 0 to 9 iter_args(%arg9 = %arg7) -> (tensor) { + %28 = arith.index_cast %arg8 : index to i32 + %29 = arith.muli %28, %c2_i32 : i32 + %30 = arith.addi %29, %c1_i32 : i32 + %31 = arith.muli %30, %c6_i32 : i32 + %32 = arith.divsi %31, %c18_i32 : i32 + %33 = arith.cmpi sge, %32, %c6_i32 : i32 + %34 = arith.select %33, %c5_i32, %32 : i32 + %35 = arith.addi %26, %34 : i32 + %36 = arith.index_cast %35 : i32 to index + %37 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%37] : tensor + %extracted_0 = tensor.extract %arg9[%36] : tensor + %38 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %38 into %arg9[%36] : tensor + affine.yield %inserted : tensor + } + affine.yield %27 : tensor + } + affine.yield %17 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..5b75f1443e9a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu/orig.mlir @@ -0,0 +1,59 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c18_i32 = arith.constant 18 : i32 + %c16_i32 = arith.constant 16 : i32 + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 240 { + affine.store %cst, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.muli %9, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %11 = arith.index_cast %arg4 : index to i32 + %12 = arith.muli %11, %c2_i32 : i32 + %13 = arith.addi %12, %c1_i32 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = arith.divsi %14, %c16_i32 : i32 + %16 = arith.cmpi sge, %15, %c5_i32 : i32 + %17 = arith.select %16, %c4_i32, %15 : i32 + %18 = arith.addi %10, %17 : i32 + %19 = arith.muli %18, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %20 = arith.index_cast %arg5 : index to i32 + %21 = arith.muli %20, %c2_i32 : i32 + %22 = arith.addi %21, %c1_i32 : i32 + %23 = arith.muli %22, %c6_i32 : i32 + %24 = arith.divsi %23, %c18_i32 : i32 + %25 = arith.cmpi sge, %24, %c6_i32 : i32 + %26 = arith.select %25, %c5_i32, %24 : i32 + %27 = arith.addi %19, %26 : i32 + %28 = arith.index_cast %27 : i32 to index + %29 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %30 = memref.load %arg1[%28] : memref + %31 = arith.addf %30, %29 : f32 + memref.store %31, %arg1[%28] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..e0b3ae7a8b9a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu/raised.mlir @@ -0,0 +1,62 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c18_i32 = arith.constant 18 : i32 + %c16_i32 = arith.constant 16 : i32 + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.muli %9, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %11 = arith.index_cast %arg4 : index to i32 + %12 = arith.muli %11, %c2_i32 : i32 + %13 = arith.addi %12, %c1_i32 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = arith.divsi %14, %c16_i32 : i32 + %16 = arith.cmpi sge, %15, %c5_i32 : i32 + %17 = arith.select %16, %c4_i32, %15 : i32 + %18 = arith.addi %10, %17 : i32 + %19 = arith.muli %18, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %20 = arith.index_cast %arg5 : index to i32 + %21 = arith.muli %20, %c2_i32 : i32 + %22 = arith.addi %21, %c1_i32 : i32 + %23 = arith.muli %22, %c6_i32 : i32 + %24 = arith.divsi %23, %c18_i32 : i32 + %25 = arith.cmpi sge, %24, %c6_i32 : i32 + %26 = arith.select %25, %c5_i32, %24 : i32 + %27 = arith.addi %19, %26 : i32 + %28 = arith.index_cast %27 : i32 to index + %29 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %30 = memref.load %arg1[%28] : memref + %31 = arith.addf %30, %29 : f32 + memref.store %31, %arg1[%28] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..9019cca711ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu_debuf.mlir @@ -0,0 +1,72 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0 * 504 + d1 + d2 * 72 + d3 * 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %c16_i32 = arith.constant 16 : i32 + %c18_i32 = arith.constant 18 : i32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.muli %8, %c2_i32 : i32 + %10 = arith.addi %9, %c1_i32 : i32 + %11 = arith.muli %10, %c4_i32 : i32 + %12 = arith.divsi %11, %c14_i32 : i32 + %13 = arith.cmpi sge, %12, %c4_i32 : i32 + %14 = arith.select %13, %c3_i32, %12 : i32 + %15 = arith.addi %6, %14 : i32 + %16 = arith.muli %15, %c5_i32 : i32 + %17 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %18 = arith.index_cast %arg6 : index to i32 + %19 = arith.muli %18, %c2_i32 : i32 + %20 = arith.addi %19, %c1_i32 : i32 + %21 = arith.muli %20, %c5_i32 : i32 + %22 = arith.divsi %21, %c16_i32 : i32 + %23 = arith.cmpi sge, %22, %c5_i32 : i32 + %24 = arith.select %23, %c4_i32, %22 : i32 + %25 = arith.addi %16, %24 : i32 + %26 = arith.muli %25, %c6_i32 : i32 + %27 = affine.for %arg8 = 0 to 9 iter_args(%arg9 = %arg7) -> (tensor) { + %28 = arith.index_cast %arg8 : index to i32 + %29 = arith.muli %28, %c2_i32 : i32 + %30 = arith.addi %29, %c1_i32 : i32 + %31 = arith.muli %30, %c6_i32 : i32 + %32 = arith.divsi %31, %c18_i32 : i32 + %33 = arith.cmpi sge, %32, %c6_i32 : i32 + %34 = arith.select %33, %c5_i32, %32 : i32 + %35 = arith.addi %26, %34 : i32 + %36 = arith.index_cast %35 : i32 to index + %37 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%37] : tensor + %extracted_0 = tensor.extract %arg9[%36] : tensor + %38 = arith.addf %extracted_0, %extracted : f32 + %inserted = tensor.insert %38 into %arg9[%36] : tensor + affine.yield %inserted : tensor + } + affine.yield %27 : tensor + } + affine.yield %17 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..e0b3ae7a8b9a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_backward_cpu_linalg.mlir @@ -0,0 +1,62 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c18_i32 = arith.constant 18 : i32 + %c16_i32 = arith.constant 16 : i32 + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2_i32 = arith.constant 2 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.muli %9, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %11 = arith.index_cast %arg4 : index to i32 + %12 = arith.muli %11, %c2_i32 : i32 + %13 = arith.addi %12, %c1_i32 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = arith.divsi %14, %c16_i32 : i32 + %16 = arith.cmpi sge, %15, %c5_i32 : i32 + %17 = arith.select %16, %c4_i32, %15 : i32 + %18 = arith.addi %10, %17 : i32 + %19 = arith.muli %18, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %20 = arith.index_cast %arg5 : index to i32 + %21 = arith.muli %20, %c2_i32 : i32 + %22 = arith.addi %21, %c1_i32 : i32 + %23 = arith.muli %22, %c6_i32 : i32 + %24 = arith.divsi %23, %c18_i32 : i32 + %25 = arith.cmpi sge, %24, %c6_i32 : i32 + %26 = arith.select %25, %c5_i32, %24 : i32 + %27 = arith.addi %19, %26 : i32 + %28 = arith.index_cast %27 : i32 to index + %29 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %30 = memref.load %arg1[%28] : memref + %31 = arith.addf %30, %29 : f32 + memref.store %31, %arg1[%28] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu.mlir new file mode 100644 index 000000000000..f53491a060bf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu.mlir @@ -0,0 +1,53 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c18_i32 = arith.constant 18 : i32 + %c6_i32 = arith.constant 6 : i32 + %c16_i32 = arith.constant 16 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.muli %9, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %11 = arith.index_cast %arg4 : index to i32 + %12 = arith.muli %11, %c2_i32 : i32 + %13 = arith.addi %12, %c1_i32 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = arith.divsi %14, %c16_i32 : i32 + %16 = arith.cmpi sge, %15, %c5_i32 : i32 + %17 = arith.select %16, %c4_i32, %15 : i32 + %18 = arith.addi %10, %17 : i32 + %19 = arith.muli %18, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %20 = arith.index_cast %arg5 : index to i32 + %21 = arith.muli %20, %c2_i32 : i32 + %22 = arith.addi %21, %c1_i32 : i32 + %23 = arith.muli %22, %c6_i32 : i32 + %24 = arith.divsi %23, %c18_i32 : i32 + %25 = arith.cmpi sge, %24, %c6_i32 : i32 + %26 = arith.select %25, %c5_i32, %24 : i32 + %27 = arith.addi %19, %26 : i32 + %28 = arith.index_cast %27 : i32 to index + %29 = memref.load %arg0[%28] : memref + affine.store %29, %arg1[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu/debuf.mlir new file mode 100644 index 000000000000..b2a47acc2b58 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu/debuf.mlir @@ -0,0 +1,64 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 504 + d1 * 72 + d2 * 9)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %c16_i32 = arith.constant 16 : i32 + %c6_i32 = arith.constant 6 : i32 + %c18_i32 = arith.constant 18 : i32 + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8, %c9) {map = #map} : (tensor, index, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c2_i32 : i32 + %11 = arith.addi %10, %c1_i32 : i32 + %12 = arith.muli %11, %c4_i32 : i32 + %13 = arith.divsi %12, %c14_i32 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.select %14, %c3_i32, %13 : i32 + %16 = arith.addi %7, %15 : i32 + %17 = arith.muli %16, %c5_i32 : i32 + %18 = linalg.index 2 : index + %19 = arith.index_cast %18 : index to i32 + %20 = arith.muli %19, %c2_i32 : i32 + %21 = arith.addi %20, %c1_i32 : i32 + %22 = arith.muli %21, %c5_i32 : i32 + %23 = arith.divsi %22, %c16_i32 : i32 + %24 = arith.cmpi sge, %23, %c5_i32 : i32 + %25 = arith.select %24, %c4_i32, %23 : i32 + %26 = arith.addi %17, %25 : i32 + %27 = arith.muli %26, %c6_i32 : i32 + %28 = linalg.index 3 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.muli %29, %c2_i32 : i32 + %31 = arith.addi %30, %c1_i32 : i32 + %32 = arith.muli %31, %c6_i32 : i32 + %33 = arith.divsi %32, %c18_i32 : i32 + %34 = arith.cmpi sge, %33, %c6_i32 : i32 + %35 = arith.select %34, %c5_i32, %33 : i32 + %36 = arith.addi %27, %35 : i32 + %37 = arith.index_cast %36 : i32 to index + %38 = memref.load %arg0[%37] : memref + linalg.yield %38 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8, %c9) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu/matched.mlir new file mode 100644 index 000000000000..b2a47acc2b58 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu/matched.mlir @@ -0,0 +1,64 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 504 + d1 * 72 + d2 * 9)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %c16_i32 = arith.constant 16 : i32 + %c6_i32 = arith.constant 6 : i32 + %c18_i32 = arith.constant 18 : i32 + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8, %c9) {map = #map} : (tensor, index, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c2_i32 : i32 + %11 = arith.addi %10, %c1_i32 : i32 + %12 = arith.muli %11, %c4_i32 : i32 + %13 = arith.divsi %12, %c14_i32 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.select %14, %c3_i32, %13 : i32 + %16 = arith.addi %7, %15 : i32 + %17 = arith.muli %16, %c5_i32 : i32 + %18 = linalg.index 2 : index + %19 = arith.index_cast %18 : index to i32 + %20 = arith.muli %19, %c2_i32 : i32 + %21 = arith.addi %20, %c1_i32 : i32 + %22 = arith.muli %21, %c5_i32 : i32 + %23 = arith.divsi %22, %c16_i32 : i32 + %24 = arith.cmpi sge, %23, %c5_i32 : i32 + %25 = arith.select %24, %c4_i32, %23 : i32 + %26 = arith.addi %17, %25 : i32 + %27 = arith.muli %26, %c6_i32 : i32 + %28 = linalg.index 3 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.muli %29, %c2_i32 : i32 + %31 = arith.addi %30, %c1_i32 : i32 + %32 = arith.muli %31, %c6_i32 : i32 + %33 = arith.divsi %32, %c18_i32 : i32 + %34 = arith.cmpi sge, %33, %c6_i32 : i32 + %35 = arith.select %34, %c5_i32, %33 : i32 + %36 = arith.addi %27, %35 : i32 + %37 = arith.index_cast %36 : i32 to index + %38 = memref.load %arg0[%37] : memref + linalg.yield %38 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8, %c9) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu/orig.mlir new file mode 100644 index 000000000000..f53491a060bf --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu/orig.mlir @@ -0,0 +1,53 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c18_i32 = arith.constant 18 : i32 + %c6_i32 = arith.constant 6 : i32 + %c16_i32 = arith.constant 16 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.muli %2, %c2_i32 : i32 + %4 = arith.addi %3, %c1_i32 : i32 + %5 = arith.muli %4, %c4_i32 : i32 + %6 = arith.divsi %5, %c14_i32 : i32 + %7 = arith.cmpi sge, %6, %c4_i32 : i32 + %8 = arith.select %7, %c3_i32, %6 : i32 + %9 = arith.addi %1, %8 : i32 + %10 = arith.muli %9, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %11 = arith.index_cast %arg4 : index to i32 + %12 = arith.muli %11, %c2_i32 : i32 + %13 = arith.addi %12, %c1_i32 : i32 + %14 = arith.muli %13, %c5_i32 : i32 + %15 = arith.divsi %14, %c16_i32 : i32 + %16 = arith.cmpi sge, %15, %c5_i32 : i32 + %17 = arith.select %16, %c4_i32, %15 : i32 + %18 = arith.addi %10, %17 : i32 + %19 = arith.muli %18, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %20 = arith.index_cast %arg5 : index to i32 + %21 = arith.muli %20, %c2_i32 : i32 + %22 = arith.addi %21, %c1_i32 : i32 + %23 = arith.muli %22, %c6_i32 : i32 + %24 = arith.divsi %23, %c18_i32 : i32 + %25 = arith.cmpi sge, %24, %c6_i32 : i32 + %26 = arith.select %25, %c5_i32, %24 : i32 + %27 = arith.addi %19, %26 : i32 + %28 = arith.index_cast %27 : i32 to index + %29 = memref.load %arg0[%28] : memref + affine.store %29, %arg1[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu/raised.mlir new file mode 100644 index 000000000000..ba197c161bf8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu/raised.mlir @@ -0,0 +1,60 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 504 + d1 * 72 + d2 * 9)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c9 = arith.constant 9 : index + %c18_i32 = arith.constant 18 : i32 + %c6_i32 = arith.constant 6 : i32 + %c16_i32 = arith.constant 16 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %0 = polygeist.submap(%arg1, %c2, %c7, %c8, %c9) {map = #map} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.muli %5, %c2_i32 : i32 + %7 = arith.addi %6, %c1_i32 : i32 + %8 = arith.muli %7, %c4_i32 : i32 + %9 = arith.divsi %8, %c14_i32 : i32 + %10 = arith.cmpi sge, %9, %c4_i32 : i32 + %11 = arith.select %10, %c3_i32, %9 : i32 + %12 = arith.addi %3, %11 : i32 + %13 = arith.muli %12, %c5_i32 : i32 + %14 = linalg.index 2 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.muli %15, %c2_i32 : i32 + %17 = arith.addi %16, %c1_i32 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = arith.divsi %18, %c16_i32 : i32 + %20 = arith.cmpi sge, %19, %c5_i32 : i32 + %21 = arith.select %20, %c4_i32, %19 : i32 + %22 = arith.addi %13, %21 : i32 + %23 = arith.muli %22, %c6_i32 : i32 + %24 = linalg.index 3 : index + %25 = arith.index_cast %24 : index to i32 + %26 = arith.muli %25, %c2_i32 : i32 + %27 = arith.addi %26, %c1_i32 : i32 + %28 = arith.muli %27, %c6_i32 : i32 + %29 = arith.divsi %28, %c18_i32 : i32 + %30 = arith.cmpi sge, %29, %c6_i32 : i32 + %31 = arith.select %30, %c5_i32, %29 : i32 + %32 = arith.addi %23, %31 : i32 + %33 = arith.index_cast %32 : i32 to index + %34 = memref.load %arg0[%33] : memref + linalg.yield %34 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu_debuf.mlir new file mode 100644 index 000000000000..b2a47acc2b58 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu_debuf.mlir @@ -0,0 +1,64 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 504 + d1 * 72 + d2 * 9)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2_i32 = arith.constant 2 : i32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %c14_i32 = arith.constant 14 : i32 + %c3_i32 = arith.constant 3 : i32 + %c5_i32 = arith.constant 5 : i32 + %c16_i32 = arith.constant 16 : i32 + %c6_i32 = arith.constant 6 : i32 + %c18_i32 = arith.constant 18 : i32 + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8, %c9) {map = #map} : (tensor, index, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.muli %9, %c2_i32 : i32 + %11 = arith.addi %10, %c1_i32 : i32 + %12 = arith.muli %11, %c4_i32 : i32 + %13 = arith.divsi %12, %c14_i32 : i32 + %14 = arith.cmpi sge, %13, %c4_i32 : i32 + %15 = arith.select %14, %c3_i32, %13 : i32 + %16 = arith.addi %7, %15 : i32 + %17 = arith.muli %16, %c5_i32 : i32 + %18 = linalg.index 2 : index + %19 = arith.index_cast %18 : index to i32 + %20 = arith.muli %19, %c2_i32 : i32 + %21 = arith.addi %20, %c1_i32 : i32 + %22 = arith.muli %21, %c5_i32 : i32 + %23 = arith.divsi %22, %c16_i32 : i32 + %24 = arith.cmpi sge, %23, %c5_i32 : i32 + %25 = arith.select %24, %c4_i32, %23 : i32 + %26 = arith.addi %17, %25 : i32 + %27 = arith.muli %26, %c6_i32 : i32 + %28 = linalg.index 3 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.muli %29, %c2_i32 : i32 + %31 = arith.addi %30, %c1_i32 : i32 + %32 = arith.muli %31, %c6_i32 : i32 + %33 = arith.divsi %32, %c18_i32 : i32 + %34 = arith.cmpi sge, %33, %c6_i32 : i32 + %35 = arith.select %34, %c5_i32, %33 : i32 + %36 = arith.addi %27, %35 : i32 + %37 = arith.index_cast %36 : i32 to index + %38 = memref.load %arg0[%37] : memref + linalg.yield %38 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8, %c9) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu_linalg.mlir new file mode 100644 index 000000000000..ba197c161bf8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_nearest_exact3d_cpu_linalg.mlir @@ -0,0 +1,60 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 504 + d1 * 72 + d2 * 9)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_nearest_exact3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c9 = arith.constant 9 : index + %c18_i32 = arith.constant 18 : i32 + %c6_i32 = arith.constant 6 : i32 + %c16_i32 = arith.constant 16 : i32 + %c5_i32 = arith.constant 5 : i32 + %c3_i32 = arith.constant 3 : i32 + %c14_i32 = arith.constant 14 : i32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %c2_i32 = arith.constant 2 : i32 + %0 = polygeist.submap(%arg1, %c2, %c7, %c8, %c9) {map = #map} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.muli %5, %c2_i32 : i32 + %7 = arith.addi %6, %c1_i32 : i32 + %8 = arith.muli %7, %c4_i32 : i32 + %9 = arith.divsi %8, %c14_i32 : i32 + %10 = arith.cmpi sge, %9, %c4_i32 : i32 + %11 = arith.select %10, %c3_i32, %9 : i32 + %12 = arith.addi %3, %11 : i32 + %13 = arith.muli %12, %c5_i32 : i32 + %14 = linalg.index 2 : index + %15 = arith.index_cast %14 : index to i32 + %16 = arith.muli %15, %c2_i32 : i32 + %17 = arith.addi %16, %c1_i32 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = arith.divsi %18, %c16_i32 : i32 + %20 = arith.cmpi sge, %19, %c5_i32 : i32 + %21 = arith.select %20, %c4_i32, %19 : i32 + %22 = arith.addi %13, %21 : i32 + %23 = arith.muli %22, %c6_i32 : i32 + %24 = linalg.index 3 : index + %25 = arith.index_cast %24 : index to i32 + %26 = arith.muli %25, %c2_i32 : i32 + %27 = arith.addi %26, %c1_i32 : i32 + %28 = arith.muli %27, %c6_i32 : i32 + %29 = arith.divsi %28, %c18_i32 : i32 + %30 = arith.cmpi sge, %29, %c6_i32 : i32 + %31 = arith.select %30, %c5_i32, %29 : i32 + %32 = arith.addi %23, %31 : i32 + %33 = arith.index_cast %32 : i32 to index + %34 = memref.load %arg0[%33] : memref + linalg.yield %34 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu.mlir new file mode 100644 index 000000000000..1583ccbcba49 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu.mlir @@ -0,0 +1,160 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_trilinear3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 9.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %cst_1 = arith.constant 8.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_4 = arith.constant 7.000000e+00 : f32 + %cst_5 = arith.constant 4.000000e+00 : f32 + %cst_6 = arith.constant 5.000000e-01 : f32 + %cst_7 = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 240 { + affine.store %cst_7, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_6 : f32 + %5 = arith.mulf %4, %cst_5 : f32 + %6 = arith.divf %5, %cst_4 : f32 + %7 = arith.subf %6, %cst_6 : f32 + %8 = arith.cmpf olt, %7, %cst_7 : f32 + %9 = arith.select %8, %cst_7, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + %13 = arith.sitofp %10 : i32 to f32 + %14 = arith.subf %9, %13 : f32 + %15 = arith.subf %cst_3, %14 : f32 + %16 = arith.addi %10, %c1_i32 : i32 + %17 = arith.cmpi slt, %16, %c4_i32 : i32 + %18 = arith.select %17, %16, %10 : i32 + %19 = arith.addi %1, %18 : i32 + %20 = arith.muli %19, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %21 = arith.index_cast %arg4 : index to i32 + %22 = arith.sitofp %21 : i32 to f32 + %23 = arith.addf %22, %cst_6 : f32 + %24 = arith.mulf %23, %cst_2 : f32 + %25 = arith.divf %24, %cst_1 : f32 + %26 = arith.subf %25, %cst_6 : f32 + %27 = arith.cmpf olt, %26, %cst_7 : f32 + %28 = arith.select %27, %cst_7, %26 : f32 + %29 = arith.fptosi %28 : f32 to i32 + %30 = arith.addi %12, %29 : i32 + %31 = arith.muli %30, %c6_i32 : i32 + %32 = arith.sitofp %29 : i32 to f32 + %33 = arith.subf %28, %32 : f32 + %34 = arith.subf %cst_3, %33 : f32 + %35 = arith.addi %29, %c1_i32 : i32 + %36 = arith.cmpi slt, %35, %c5_i32 : i32 + %37 = arith.select %36, %35, %29 : i32 + %38 = arith.addi %12, %37 : i32 + %39 = arith.muli %38, %c6_i32 : i32 + %40 = arith.addi %20, %29 : i32 + %41 = arith.muli %40, %c6_i32 : i32 + %42 = arith.addi %20, %37 : i32 + %43 = arith.muli %42, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %44 = arith.index_cast %arg5 : index to i32 + %45 = arith.sitofp %44 : i32 to f32 + %46 = arith.addf %45, %cst_6 : f32 + %47 = arith.mulf %46, %cst_0 : f32 + %48 = arith.divf %47, %cst : f32 + %49 = arith.subf %48, %cst_6 : f32 + %50 = arith.cmpf olt, %49, %cst_7 : f32 + %51 = arith.select %50, %cst_7, %49 : f32 + %52 = arith.fptosi %51 : f32 to i32 + %53 = arith.addi %31, %52 : i32 + %54 = arith.index_cast %53 : i32 to index + %55 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %56 = arith.mulf %55, %15 : f32 + %57 = arith.mulf %56, %34 : f32 + %58 = arith.sitofp %52 : i32 to f32 + %59 = arith.subf %51, %58 : f32 + %60 = arith.subf %cst_3, %59 : f32 + %61 = arith.mulf %57, %60 : f32 + %62 = memref.load %arg1[%54] : memref + %63 = arith.addf %62, %61 : f32 + memref.store %63, %arg1[%54] : memref + %64 = arith.addi %52, %c1_i32 : i32 + %65 = arith.cmpi slt, %64, %c6_i32 : i32 + %66 = arith.select %65, %64, %52 : i32 + %67 = arith.addi %31, %66 : i32 + %68 = arith.index_cast %67 : i32 to index + %69 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %70 = arith.mulf %69, %15 : f32 + %71 = arith.mulf %70, %34 : f32 + %72 = arith.mulf %71, %59 : f32 + %73 = memref.load %arg1[%68] : memref + %74 = arith.addf %73, %72 : f32 + memref.store %74, %arg1[%68] : memref + %75 = arith.addi %39, %52 : i32 + %76 = arith.index_cast %75 : i32 to index + %77 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %78 = arith.mulf %77, %15 : f32 + %79 = arith.mulf %78, %33 : f32 + %80 = arith.mulf %79, %60 : f32 + %81 = memref.load %arg1[%76] : memref + %82 = arith.addf %81, %80 : f32 + memref.store %82, %arg1[%76] : memref + %83 = arith.addi %39, %66 : i32 + %84 = arith.index_cast %83 : i32 to index + %85 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %86 = arith.mulf %85, %15 : f32 + %87 = arith.mulf %86, %33 : f32 + %88 = arith.mulf %87, %59 : f32 + %89 = memref.load %arg1[%84] : memref + %90 = arith.addf %89, %88 : f32 + memref.store %90, %arg1[%84] : memref + %91 = arith.addi %41, %52 : i32 + %92 = arith.index_cast %91 : i32 to index + %93 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %94 = arith.mulf %93, %14 : f32 + %95 = arith.mulf %94, %34 : f32 + %96 = arith.mulf %95, %60 : f32 + %97 = memref.load %arg1[%92] : memref + %98 = arith.addf %97, %96 : f32 + memref.store %98, %arg1[%92] : memref + %99 = arith.addi %41, %66 : i32 + %100 = arith.index_cast %99 : i32 to index + %101 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %102 = arith.mulf %101, %14 : f32 + %103 = arith.mulf %102, %34 : f32 + %104 = arith.mulf %103, %59 : f32 + %105 = memref.load %arg1[%100] : memref + %106 = arith.addf %105, %104 : f32 + memref.store %106, %arg1[%100] : memref + %107 = arith.addi %43, %52 : i32 + %108 = arith.index_cast %107 : i32 to index + %109 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %110 = arith.mulf %109, %14 : f32 + %111 = arith.mulf %110, %33 : f32 + %112 = arith.mulf %111, %60 : f32 + %113 = memref.load %arg1[%108] : memref + %114 = arith.addf %113, %112 : f32 + memref.store %114, %arg1[%108] : memref + %115 = arith.addi %43, %66 : i32 + %116 = arith.index_cast %115 : i32 to index + %117 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %118 = arith.mulf %117, %14 : f32 + %119 = arith.mulf %118, %33 : f32 + %120 = arith.mulf %119, %59 : f32 + %121 = memref.load %arg1[%116] : memref + %122 = arith.addf %121, %120 : f32 + memref.store %122, %arg1[%116] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..a1b852845c5e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu/debuf.mlir @@ -0,0 +1,180 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0 * 504 + d1 + d2 * 72 + d3 * 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_trilinear3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.000000e+00 : f32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e+00 : f32 + %cst_5 = arith.constant 8.000000e+00 : f32 + %cst_6 = arith.constant 6.000000e+00 : f32 + %cst_7 = arith.constant 9.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.sitofp %8 : i32 to f32 + %10 = arith.addf %9, %cst_0 : f32 + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.divf %11, %cst_2 : f32 + %13 = arith.subf %12, %cst_0 : f32 + %14 = arith.cmpf olt, %13, %cst : f32 + %15 = arith.select %14, %cst, %13 : f32 + %16 = arith.fptosi %15 : f32 to i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = arith.sitofp %16 : i32 to f32 + %20 = arith.subf %15, %19 : f32 + %21 = arith.subf %cst_3, %20 : f32 + %22 = arith.addi %16, %c1_i32 : i32 + %23 = arith.cmpi slt, %22, %c4_i32 : i32 + %24 = arith.select %23, %22, %16 : i32 + %25 = arith.addi %6, %24 : i32 + %26 = arith.muli %25, %c5_i32 : i32 + %27 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %28 = arith.index_cast %arg6 : index to i32 + %29 = arith.sitofp %28 : i32 to f32 + %30 = arith.addf %29, %cst_0 : f32 + %31 = arith.mulf %30, %cst_4 : f32 + %32 = arith.divf %31, %cst_5 : f32 + %33 = arith.subf %32, %cst_0 : f32 + %34 = arith.cmpf olt, %33, %cst : f32 + %35 = arith.select %34, %cst, %33 : f32 + %36 = arith.fptosi %35 : f32 to i32 + %37 = arith.addi %18, %36 : i32 + %38 = arith.muli %37, %c6_i32 : i32 + %39 = arith.sitofp %36 : i32 to f32 + %40 = arith.subf %35, %39 : f32 + %41 = arith.subf %cst_3, %40 : f32 + %42 = arith.addi %36, %c1_i32 : i32 + %43 = arith.cmpi slt, %42, %c5_i32 : i32 + %44 = arith.select %43, %42, %36 : i32 + %45 = arith.addi %18, %44 : i32 + %46 = arith.muli %45, %c6_i32 : i32 + %47 = arith.addi %26, %36 : i32 + %48 = arith.muli %47, %c6_i32 : i32 + %49 = arith.addi %26, %44 : i32 + %50 = arith.muli %49, %c6_i32 : i32 + %51 = affine.for %arg8 = 0 to 9 iter_args(%arg9 = %arg7) -> (tensor) { + %52 = arith.index_cast %arg8 : index to i32 + %53 = arith.sitofp %52 : i32 to f32 + %54 = arith.addf %53, %cst_0 : f32 + %55 = arith.mulf %54, %cst_6 : f32 + %56 = arith.divf %55, %cst_7 : f32 + %57 = arith.subf %56, %cst_0 : f32 + %58 = arith.cmpf olt, %57, %cst : f32 + %59 = arith.select %58, %cst, %57 : f32 + %60 = arith.fptosi %59 : f32 to i32 + %61 = arith.addi %38, %60 : i32 + %62 = arith.index_cast %61 : i32 to index + %63 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%63] : tensor + %64 = arith.mulf %extracted, %21 : f32 + %65 = arith.mulf %64, %41 : f32 + %66 = arith.sitofp %60 : i32 to f32 + %67 = arith.subf %59, %66 : f32 + %68 = arith.subf %cst_3, %67 : f32 + %69 = arith.mulf %65, %68 : f32 + %extracted_8 = tensor.extract %arg9[%62] : tensor + %70 = arith.addf %extracted_8, %69 : f32 + %inserted = tensor.insert %70 into %arg9[%62] : tensor + %71 = arith.addi %60, %c1_i32 : i32 + %72 = arith.cmpi slt, %71, %c6_i32 : i32 + %73 = arith.select %72, %71, %60 : i32 + %74 = arith.addi %38, %73 : i32 + %75 = arith.index_cast %74 : i32 to index + %76 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_9 = tensor.extract %1[%76] : tensor + %77 = arith.mulf %extracted_9, %21 : f32 + %78 = arith.mulf %77, %41 : f32 + %79 = arith.mulf %78, %67 : f32 + %extracted_10 = tensor.extract %inserted[%75] : tensor + %80 = arith.addf %extracted_10, %79 : f32 + %inserted_11 = tensor.insert %80 into %inserted[%75] : tensor + %81 = arith.addi %46, %60 : i32 + %82 = arith.index_cast %81 : i32 to index + %83 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_12 = tensor.extract %1[%83] : tensor + %84 = arith.mulf %extracted_12, %21 : f32 + %85 = arith.mulf %84, %40 : f32 + %86 = arith.mulf %85, %68 : f32 + %extracted_13 = tensor.extract %inserted_11[%82] : tensor + %87 = arith.addf %extracted_13, %86 : f32 + %inserted_14 = tensor.insert %87 into %inserted_11[%82] : tensor + %88 = arith.addi %46, %73 : i32 + %89 = arith.index_cast %88 : i32 to index + %90 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_15 = tensor.extract %1[%90] : tensor + %91 = arith.mulf %extracted_15, %21 : f32 + %92 = arith.mulf %91, %40 : f32 + %93 = arith.mulf %92, %67 : f32 + %extracted_16 = tensor.extract %inserted_14[%89] : tensor + %94 = arith.addf %extracted_16, %93 : f32 + %inserted_17 = tensor.insert %94 into %inserted_14[%89] : tensor + %95 = arith.addi %48, %60 : i32 + %96 = arith.index_cast %95 : i32 to index + %97 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_18 = tensor.extract %1[%97] : tensor + %98 = arith.mulf %extracted_18, %20 : f32 + %99 = arith.mulf %98, %41 : f32 + %100 = arith.mulf %99, %68 : f32 + %extracted_19 = tensor.extract %inserted_17[%96] : tensor + %101 = arith.addf %extracted_19, %100 : f32 + %inserted_20 = tensor.insert %101 into %inserted_17[%96] : tensor + %102 = arith.addi %48, %73 : i32 + %103 = arith.index_cast %102 : i32 to index + %104 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_21 = tensor.extract %1[%104] : tensor + %105 = arith.mulf %extracted_21, %20 : f32 + %106 = arith.mulf %105, %41 : f32 + %107 = arith.mulf %106, %67 : f32 + %extracted_22 = tensor.extract %inserted_20[%103] : tensor + %108 = arith.addf %extracted_22, %107 : f32 + %inserted_23 = tensor.insert %108 into %inserted_20[%103] : tensor + %109 = arith.addi %50, %60 : i32 + %110 = arith.index_cast %109 : i32 to index + %111 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_24 = tensor.extract %1[%111] : tensor + %112 = arith.mulf %extracted_24, %20 : f32 + %113 = arith.mulf %112, %40 : f32 + %114 = arith.mulf %113, %68 : f32 + %extracted_25 = tensor.extract %inserted_23[%110] : tensor + %115 = arith.addf %extracted_25, %114 : f32 + %inserted_26 = tensor.insert %115 into %inserted_23[%110] : tensor + %116 = arith.addi %50, %73 : i32 + %117 = arith.index_cast %116 : i32 to index + %118 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_27 = tensor.extract %1[%118] : tensor + %119 = arith.mulf %extracted_27, %20 : f32 + %120 = arith.mulf %119, %40 : f32 + %121 = arith.mulf %120, %67 : f32 + %extracted_28 = tensor.extract %inserted_26[%117] : tensor + %122 = arith.addf %extracted_28, %121 : f32 + %inserted_29 = tensor.insert %122 into %inserted_26[%117] : tensor + affine.yield %inserted_29 : tensor + } + affine.yield %51 : tensor + } + affine.yield %27 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu/matched.mlir new file mode 100644 index 000000000000..384d96bce7f3 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu/matched.mlir @@ -0,0 +1,177 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0 * 504 + d1 + d2 * 72 + d3 * 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_trilinear3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.000000e+00 : f32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e+00 : f32 + %cst_5 = arith.constant 8.000000e+00 : f32 + %cst_6 = arith.constant 6.000000e+00 : f32 + %cst_7 = arith.constant 9.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.sitofp %8 : i32 to f32 + %10 = arith.addf %9, %cst_0 : f32 + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.divf %11, %cst_2 : f32 + %13 = arith.subf %12, %cst_0 : f32 + %14 = arith.cmpf olt, %13, %cst : f32 + %15 = arith.select %14, %cst, %13 : f32 + %16 = arith.fptosi %15 : f32 to i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = arith.sitofp %16 : i32 to f32 + %20 = arith.subf %15, %19 : f32 + %21 = arith.subf %cst_3, %20 : f32 + %22 = arith.addi %16, %c1_i32 : i32 + %23 = arith.cmpi slt, %22, %c4_i32 : i32 + %24 = arith.select %23, %22, %16 : i32 + %25 = arith.addi %6, %24 : i32 + %26 = arith.muli %25, %c5_i32 : i32 + %27 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %28 = arith.index_cast %arg6 : index to i32 + %29 = arith.sitofp %28 : i32 to f32 + %30 = arith.addf %29, %cst_0 : f32 + %31 = arith.mulf %30, %cst_4 : f32 + %32 = arith.divf %31, %cst_5 : f32 + %33 = arith.subf %32, %cst_0 : f32 + %34 = arith.cmpf olt, %33, %cst : f32 + %35 = arith.select %34, %cst, %33 : f32 + %36 = arith.fptosi %35 : f32 to i32 + %37 = arith.addi %18, %36 : i32 + %38 = arith.muli %37, %c6_i32 : i32 + %39 = arith.sitofp %36 : i32 to f32 + %40 = arith.subf %35, %39 : f32 + %41 = arith.subf %cst_3, %40 : f32 + %42 = arith.addi %36, %c1_i32 : i32 + %43 = arith.cmpi slt, %42, %c5_i32 : i32 + %44 = arith.select %43, %42, %36 : i32 + %45 = arith.addi %18, %44 : i32 + %46 = arith.muli %45, %c6_i32 : i32 + %47 = arith.addi %26, %36 : i32 + %48 = arith.muli %47, %c6_i32 : i32 + %49 = arith.addi %26, %44 : i32 + %50 = arith.muli %49, %c6_i32 : i32 + %51 = affine.for %arg8 = 0 to 9 iter_args(%arg9 = %arg7) -> (tensor) { + %52 = arith.index_cast %arg8 : index to i32 + %53 = arith.sitofp %52 : i32 to f32 + %54 = arith.addf %53, %cst_0 : f32 + %55 = arith.mulf %54, %cst_6 : f32 + %56 = arith.divf %55, %cst_7 : f32 + %57 = arith.subf %56, %cst_0 : f32 + %58 = arith.cmpf olt, %57, %cst : f32 + %59 = arith.select %58, %cst, %57 : f32 + %60 = arith.fptosi %59 : f32 to i32 + %61 = arith.addi %38, %60 : i32 + %62 = arith.index_cast %61 : i32 to index + %63 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%63] : tensor + %64 = arith.mulf %extracted, %21 : f32 + %65 = arith.mulf %64, %41 : f32 + %66 = arith.sitofp %60 : i32 to f32 + %67 = arith.subf %59, %66 : f32 + %68 = arith.subf %cst_3, %67 : f32 + %69 = arith.mulf %65, %68 : f32 + %extracted_8 = tensor.extract %arg9[%62] : tensor + %70 = arith.addf %extracted_8, %69 : f32 + %inserted = tensor.insert %70 into %arg9[%62] : tensor + %71 = arith.addi %60, %c1_i32 : i32 + %72 = arith.cmpi slt, %71, %c6_i32 : i32 + %73 = arith.select %72, %71, %60 : i32 + %74 = arith.addi %38, %73 : i32 + %75 = arith.index_cast %74 : i32 to index + %76 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_9 = tensor.extract %1[%76] : tensor + %77 = arith.mulf %extracted_9, %21 : f32 + %78 = arith.mulf %77, %41 : f32 + %79 = arith.mulf %78, %67 : f32 + %extracted_10 = tensor.extract %inserted[%75] : tensor + %80 = arith.addf %extracted_10, %79 : f32 + %inserted_11 = tensor.insert %80 into %inserted[%75] : tensor + %81 = arith.addi %46, %60 : i32 + %82 = arith.index_cast %81 : i32 to index + %83 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_12 = tensor.extract %1[%83] : tensor + %84 = arith.mulf %extracted_12, %21 : f32 + %85 = arith.mulf %84, %40 : f32 + %86 = arith.mulf %85, %68 : f32 + %extracted_13 = tensor.extract %inserted_11[%82] : tensor + %87 = arith.addf %extracted_13, %86 : f32 + %inserted_14 = tensor.insert %87 into %inserted_11[%82] : tensor + %88 = arith.addi %46, %73 : i32 + %89 = arith.index_cast %88 : i32 to index + %90 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_15 = tensor.extract %1[%90] : tensor + %91 = arith.mulf %extracted_15, %21 : f32 + %92 = arith.mulf %91, %40 : f32 + %93 = arith.mulf %92, %67 : f32 + %extracted_16 = tensor.extract %inserted_14[%89] : tensor + %94 = arith.addf %extracted_16, %93 : f32 + %inserted_17 = tensor.insert %94 into %inserted_14[%89] : tensor + %95 = arith.addi %48, %60 : i32 + %96 = arith.index_cast %95 : i32 to index + %97 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_18 = tensor.extract %1[%97] : tensor + %98 = arith.mulf %extracted_18, %20 : f32 + %99 = arith.mulf %98, %41 : f32 + %100 = arith.mulf %99, %68 : f32 + %extracted_19 = tensor.extract %inserted_17[%96] : tensor + %101 = arith.addf %extracted_19, %100 : f32 + %inserted_20 = tensor.insert %101 into %inserted_17[%96] : tensor + %102 = arith.addi %48, %73 : i32 + %103 = arith.index_cast %102 : i32 to index + %104 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_21 = tensor.extract %1[%104] : tensor + %105 = arith.mulf %extracted_21, %20 : f32 + %106 = arith.mulf %105, %41 : f32 + %107 = arith.mulf %106, %67 : f32 + %extracted_22 = tensor.extract %inserted_20[%103] : tensor + %108 = arith.addf %extracted_22, %107 : f32 + %inserted_23 = tensor.insert %108 into %inserted_20[%103] : tensor + %109 = arith.addi %50, %60 : i32 + %110 = arith.index_cast %109 : i32 to index + %111 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_24 = tensor.extract %1[%111] : tensor + %112 = arith.mulf %extracted_24, %20 : f32 + %113 = arith.mulf %112, %40 : f32 + %114 = arith.mulf %113, %68 : f32 + %extracted_25 = tensor.extract %inserted_23[%110] : tensor + %115 = arith.addf %extracted_25, %114 : f32 + %inserted_26 = tensor.insert %115 into %inserted_23[%110] : tensor + %116 = arith.addi %50, %73 : i32 + %117 = arith.index_cast %116 : i32 to index + %118 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_27 = tensor.extract %1[%118] : tensor + %119 = arith.mulf %extracted_27, %20 : f32 + %120 = arith.mulf %119, %40 : f32 + %121 = arith.mulf %120, %67 : f32 + %extracted_28 = tensor.extract %inserted_26[%117] : tensor + %122 = arith.addf %extracted_28, %121 : f32 + %inserted_29 = tensor.insert %122 into %inserted_26[%117] : tensor + affine.yield %inserted_29 : tensor + } + affine.yield %51 : tensor + } + affine.yield %27 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu/orig.mlir new file mode 100644 index 000000000000..1583ccbcba49 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu/orig.mlir @@ -0,0 +1,160 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_trilinear3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 9.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %cst_1 = arith.constant 8.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_4 = arith.constant 7.000000e+00 : f32 + %cst_5 = arith.constant 4.000000e+00 : f32 + %cst_6 = arith.constant 5.000000e-01 : f32 + %cst_7 = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + affine.for %arg2 = 0 to 240 { + affine.store %cst_7, %arg1[%arg2] : memref + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_6 : f32 + %5 = arith.mulf %4, %cst_5 : f32 + %6 = arith.divf %5, %cst_4 : f32 + %7 = arith.subf %6, %cst_6 : f32 + %8 = arith.cmpf olt, %7, %cst_7 : f32 + %9 = arith.select %8, %cst_7, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + %13 = arith.sitofp %10 : i32 to f32 + %14 = arith.subf %9, %13 : f32 + %15 = arith.subf %cst_3, %14 : f32 + %16 = arith.addi %10, %c1_i32 : i32 + %17 = arith.cmpi slt, %16, %c4_i32 : i32 + %18 = arith.select %17, %16, %10 : i32 + %19 = arith.addi %1, %18 : i32 + %20 = arith.muli %19, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %21 = arith.index_cast %arg4 : index to i32 + %22 = arith.sitofp %21 : i32 to f32 + %23 = arith.addf %22, %cst_6 : f32 + %24 = arith.mulf %23, %cst_2 : f32 + %25 = arith.divf %24, %cst_1 : f32 + %26 = arith.subf %25, %cst_6 : f32 + %27 = arith.cmpf olt, %26, %cst_7 : f32 + %28 = arith.select %27, %cst_7, %26 : f32 + %29 = arith.fptosi %28 : f32 to i32 + %30 = arith.addi %12, %29 : i32 + %31 = arith.muli %30, %c6_i32 : i32 + %32 = arith.sitofp %29 : i32 to f32 + %33 = arith.subf %28, %32 : f32 + %34 = arith.subf %cst_3, %33 : f32 + %35 = arith.addi %29, %c1_i32 : i32 + %36 = arith.cmpi slt, %35, %c5_i32 : i32 + %37 = arith.select %36, %35, %29 : i32 + %38 = arith.addi %12, %37 : i32 + %39 = arith.muli %38, %c6_i32 : i32 + %40 = arith.addi %20, %29 : i32 + %41 = arith.muli %40, %c6_i32 : i32 + %42 = arith.addi %20, %37 : i32 + %43 = arith.muli %42, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %44 = arith.index_cast %arg5 : index to i32 + %45 = arith.sitofp %44 : i32 to f32 + %46 = arith.addf %45, %cst_6 : f32 + %47 = arith.mulf %46, %cst_0 : f32 + %48 = arith.divf %47, %cst : f32 + %49 = arith.subf %48, %cst_6 : f32 + %50 = arith.cmpf olt, %49, %cst_7 : f32 + %51 = arith.select %50, %cst_7, %49 : f32 + %52 = arith.fptosi %51 : f32 to i32 + %53 = arith.addi %31, %52 : i32 + %54 = arith.index_cast %53 : i32 to index + %55 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %56 = arith.mulf %55, %15 : f32 + %57 = arith.mulf %56, %34 : f32 + %58 = arith.sitofp %52 : i32 to f32 + %59 = arith.subf %51, %58 : f32 + %60 = arith.subf %cst_3, %59 : f32 + %61 = arith.mulf %57, %60 : f32 + %62 = memref.load %arg1[%54] : memref + %63 = arith.addf %62, %61 : f32 + memref.store %63, %arg1[%54] : memref + %64 = arith.addi %52, %c1_i32 : i32 + %65 = arith.cmpi slt, %64, %c6_i32 : i32 + %66 = arith.select %65, %64, %52 : i32 + %67 = arith.addi %31, %66 : i32 + %68 = arith.index_cast %67 : i32 to index + %69 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %70 = arith.mulf %69, %15 : f32 + %71 = arith.mulf %70, %34 : f32 + %72 = arith.mulf %71, %59 : f32 + %73 = memref.load %arg1[%68] : memref + %74 = arith.addf %73, %72 : f32 + memref.store %74, %arg1[%68] : memref + %75 = arith.addi %39, %52 : i32 + %76 = arith.index_cast %75 : i32 to index + %77 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %78 = arith.mulf %77, %15 : f32 + %79 = arith.mulf %78, %33 : f32 + %80 = arith.mulf %79, %60 : f32 + %81 = memref.load %arg1[%76] : memref + %82 = arith.addf %81, %80 : f32 + memref.store %82, %arg1[%76] : memref + %83 = arith.addi %39, %66 : i32 + %84 = arith.index_cast %83 : i32 to index + %85 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %86 = arith.mulf %85, %15 : f32 + %87 = arith.mulf %86, %33 : f32 + %88 = arith.mulf %87, %59 : f32 + %89 = memref.load %arg1[%84] : memref + %90 = arith.addf %89, %88 : f32 + memref.store %90, %arg1[%84] : memref + %91 = arith.addi %41, %52 : i32 + %92 = arith.index_cast %91 : i32 to index + %93 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %94 = arith.mulf %93, %14 : f32 + %95 = arith.mulf %94, %34 : f32 + %96 = arith.mulf %95, %60 : f32 + %97 = memref.load %arg1[%92] : memref + %98 = arith.addf %97, %96 : f32 + memref.store %98, %arg1[%92] : memref + %99 = arith.addi %41, %66 : i32 + %100 = arith.index_cast %99 : i32 to index + %101 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %102 = arith.mulf %101, %14 : f32 + %103 = arith.mulf %102, %34 : f32 + %104 = arith.mulf %103, %59 : f32 + %105 = memref.load %arg1[%100] : memref + %106 = arith.addf %105, %104 : f32 + memref.store %106, %arg1[%100] : memref + %107 = arith.addi %43, %52 : i32 + %108 = arith.index_cast %107 : i32 to index + %109 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %110 = arith.mulf %109, %14 : f32 + %111 = arith.mulf %110, %33 : f32 + %112 = arith.mulf %111, %60 : f32 + %113 = memref.load %arg1[%108] : memref + %114 = arith.addf %113, %112 : f32 + memref.store %114, %arg1[%108] : memref + %115 = arith.addi %43, %66 : i32 + %116 = arith.index_cast %115 : i32 to index + %117 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %118 = arith.mulf %117, %14 : f32 + %119 = arith.mulf %118, %33 : f32 + %120 = arith.mulf %119, %59 : f32 + %121 = memref.load %arg1[%116] : memref + %122 = arith.addf %121, %120 : f32 + memref.store %122, %arg1[%116] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu/raised.mlir new file mode 100644 index 000000000000..e28215c45e1b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu/raised.mlir @@ -0,0 +1,163 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_trilinear3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 9.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %cst_1 = arith.constant 8.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_4 = arith.constant 7.000000e+00 : f32 + %cst_5 = arith.constant 4.000000e+00 : f32 + %cst_6 = arith.constant 5.000000e-01 : f32 + %cst_7 = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_7 : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_6 : f32 + %5 = arith.mulf %4, %cst_5 : f32 + %6 = arith.divf %5, %cst_4 : f32 + %7 = arith.subf %6, %cst_6 : f32 + %8 = arith.cmpf olt, %7, %cst_7 : f32 + %9 = arith.select %8, %cst_7, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + %13 = arith.sitofp %10 : i32 to f32 + %14 = arith.subf %9, %13 : f32 + %15 = arith.subf %cst_3, %14 : f32 + %16 = arith.addi %10, %c1_i32 : i32 + %17 = arith.cmpi slt, %16, %c4_i32 : i32 + %18 = arith.select %17, %16, %10 : i32 + %19 = arith.addi %1, %18 : i32 + %20 = arith.muli %19, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %21 = arith.index_cast %arg4 : index to i32 + %22 = arith.sitofp %21 : i32 to f32 + %23 = arith.addf %22, %cst_6 : f32 + %24 = arith.mulf %23, %cst_2 : f32 + %25 = arith.divf %24, %cst_1 : f32 + %26 = arith.subf %25, %cst_6 : f32 + %27 = arith.cmpf olt, %26, %cst_7 : f32 + %28 = arith.select %27, %cst_7, %26 : f32 + %29 = arith.fptosi %28 : f32 to i32 + %30 = arith.addi %12, %29 : i32 + %31 = arith.muli %30, %c6_i32 : i32 + %32 = arith.sitofp %29 : i32 to f32 + %33 = arith.subf %28, %32 : f32 + %34 = arith.subf %cst_3, %33 : f32 + %35 = arith.addi %29, %c1_i32 : i32 + %36 = arith.cmpi slt, %35, %c5_i32 : i32 + %37 = arith.select %36, %35, %29 : i32 + %38 = arith.addi %12, %37 : i32 + %39 = arith.muli %38, %c6_i32 : i32 + %40 = arith.addi %20, %29 : i32 + %41 = arith.muli %40, %c6_i32 : i32 + %42 = arith.addi %20, %37 : i32 + %43 = arith.muli %42, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %44 = arith.index_cast %arg5 : index to i32 + %45 = arith.sitofp %44 : i32 to f32 + %46 = arith.addf %45, %cst_6 : f32 + %47 = arith.mulf %46, %cst_0 : f32 + %48 = arith.divf %47, %cst : f32 + %49 = arith.subf %48, %cst_6 : f32 + %50 = arith.cmpf olt, %49, %cst_7 : f32 + %51 = arith.select %50, %cst_7, %49 : f32 + %52 = arith.fptosi %51 : f32 to i32 + %53 = arith.addi %31, %52 : i32 + %54 = arith.index_cast %53 : i32 to index + %55 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %56 = arith.mulf %55, %15 : f32 + %57 = arith.mulf %56, %34 : f32 + %58 = arith.sitofp %52 : i32 to f32 + %59 = arith.subf %51, %58 : f32 + %60 = arith.subf %cst_3, %59 : f32 + %61 = arith.mulf %57, %60 : f32 + %62 = memref.load %arg1[%54] : memref + %63 = arith.addf %62, %61 : f32 + memref.store %63, %arg1[%54] : memref + %64 = arith.addi %52, %c1_i32 : i32 + %65 = arith.cmpi slt, %64, %c6_i32 : i32 + %66 = arith.select %65, %64, %52 : i32 + %67 = arith.addi %31, %66 : i32 + %68 = arith.index_cast %67 : i32 to index + %69 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %70 = arith.mulf %69, %15 : f32 + %71 = arith.mulf %70, %34 : f32 + %72 = arith.mulf %71, %59 : f32 + %73 = memref.load %arg1[%68] : memref + %74 = arith.addf %73, %72 : f32 + memref.store %74, %arg1[%68] : memref + %75 = arith.addi %39, %52 : i32 + %76 = arith.index_cast %75 : i32 to index + %77 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %78 = arith.mulf %77, %15 : f32 + %79 = arith.mulf %78, %33 : f32 + %80 = arith.mulf %79, %60 : f32 + %81 = memref.load %arg1[%76] : memref + %82 = arith.addf %81, %80 : f32 + memref.store %82, %arg1[%76] : memref + %83 = arith.addi %39, %66 : i32 + %84 = arith.index_cast %83 : i32 to index + %85 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %86 = arith.mulf %85, %15 : f32 + %87 = arith.mulf %86, %33 : f32 + %88 = arith.mulf %87, %59 : f32 + %89 = memref.load %arg1[%84] : memref + %90 = arith.addf %89, %88 : f32 + memref.store %90, %arg1[%84] : memref + %91 = arith.addi %41, %52 : i32 + %92 = arith.index_cast %91 : i32 to index + %93 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %94 = arith.mulf %93, %14 : f32 + %95 = arith.mulf %94, %34 : f32 + %96 = arith.mulf %95, %60 : f32 + %97 = memref.load %arg1[%92] : memref + %98 = arith.addf %97, %96 : f32 + memref.store %98, %arg1[%92] : memref + %99 = arith.addi %41, %66 : i32 + %100 = arith.index_cast %99 : i32 to index + %101 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %102 = arith.mulf %101, %14 : f32 + %103 = arith.mulf %102, %34 : f32 + %104 = arith.mulf %103, %59 : f32 + %105 = memref.load %arg1[%100] : memref + %106 = arith.addf %105, %104 : f32 + memref.store %106, %arg1[%100] : memref + %107 = arith.addi %43, %52 : i32 + %108 = arith.index_cast %107 : i32 to index + %109 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %110 = arith.mulf %109, %14 : f32 + %111 = arith.mulf %110, %33 : f32 + %112 = arith.mulf %111, %60 : f32 + %113 = memref.load %arg1[%108] : memref + %114 = arith.addf %113, %112 : f32 + memref.store %114, %arg1[%108] : memref + %115 = arith.addi %43, %66 : i32 + %116 = arith.index_cast %115 : i32 to index + %117 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %118 = arith.mulf %117, %14 : f32 + %119 = arith.mulf %118, %33 : f32 + %120 = arith.mulf %119, %59 : f32 + %121 = memref.load %arg1[%116] : memref + %122 = arith.addf %121, %120 : f32 + memref.store %122, %arg1[%116] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..a1b852845c5e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu_debuf.mlir @@ -0,0 +1,180 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0 * 504 + d1 + d2 * 72 + d3 * 9)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_trilinear3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4_i32 = arith.constant 4 : i32 + %c5_i32 = arith.constant 5 : i32 + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant 5.000000e-01 : f32 + %cst_1 = arith.constant 4.000000e+00 : f32 + %cst_2 = arith.constant 7.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e+00 : f32 + %cst_5 = arith.constant 8.000000e+00 : f32 + %cst_6 = arith.constant 6.000000e+00 : f32 + %cst_7 = arith.constant 9.000000e+00 : f32 + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %3 = affine.for %arg2 = 0 to 2 iter_args(%arg3 = %2) -> (tensor) { + %5 = arith.index_cast %arg2 : index to i32 + %6 = arith.muli %5, %c4_i32 : i32 + %7 = affine.for %arg4 = 0 to 7 iter_args(%arg5 = %arg3) -> (tensor) { + %8 = arith.index_cast %arg4 : index to i32 + %9 = arith.sitofp %8 : i32 to f32 + %10 = arith.addf %9, %cst_0 : f32 + %11 = arith.mulf %10, %cst_1 : f32 + %12 = arith.divf %11, %cst_2 : f32 + %13 = arith.subf %12, %cst_0 : f32 + %14 = arith.cmpf olt, %13, %cst : f32 + %15 = arith.select %14, %cst, %13 : f32 + %16 = arith.fptosi %15 : f32 to i32 + %17 = arith.addi %6, %16 : i32 + %18 = arith.muli %17, %c5_i32 : i32 + %19 = arith.sitofp %16 : i32 to f32 + %20 = arith.subf %15, %19 : f32 + %21 = arith.subf %cst_3, %20 : f32 + %22 = arith.addi %16, %c1_i32 : i32 + %23 = arith.cmpi slt, %22, %c4_i32 : i32 + %24 = arith.select %23, %22, %16 : i32 + %25 = arith.addi %6, %24 : i32 + %26 = arith.muli %25, %c5_i32 : i32 + %27 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %arg5) -> (tensor) { + %28 = arith.index_cast %arg6 : index to i32 + %29 = arith.sitofp %28 : i32 to f32 + %30 = arith.addf %29, %cst_0 : f32 + %31 = arith.mulf %30, %cst_4 : f32 + %32 = arith.divf %31, %cst_5 : f32 + %33 = arith.subf %32, %cst_0 : f32 + %34 = arith.cmpf olt, %33, %cst : f32 + %35 = arith.select %34, %cst, %33 : f32 + %36 = arith.fptosi %35 : f32 to i32 + %37 = arith.addi %18, %36 : i32 + %38 = arith.muli %37, %c6_i32 : i32 + %39 = arith.sitofp %36 : i32 to f32 + %40 = arith.subf %35, %39 : f32 + %41 = arith.subf %cst_3, %40 : f32 + %42 = arith.addi %36, %c1_i32 : i32 + %43 = arith.cmpi slt, %42, %c5_i32 : i32 + %44 = arith.select %43, %42, %36 : i32 + %45 = arith.addi %18, %44 : i32 + %46 = arith.muli %45, %c6_i32 : i32 + %47 = arith.addi %26, %36 : i32 + %48 = arith.muli %47, %c6_i32 : i32 + %49 = arith.addi %26, %44 : i32 + %50 = arith.muli %49, %c6_i32 : i32 + %51 = affine.for %arg8 = 0 to 9 iter_args(%arg9 = %arg7) -> (tensor) { + %52 = arith.index_cast %arg8 : index to i32 + %53 = arith.sitofp %52 : i32 to f32 + %54 = arith.addf %53, %cst_0 : f32 + %55 = arith.mulf %54, %cst_6 : f32 + %56 = arith.divf %55, %cst_7 : f32 + %57 = arith.subf %56, %cst_0 : f32 + %58 = arith.cmpf olt, %57, %cst : f32 + %59 = arith.select %58, %cst, %57 : f32 + %60 = arith.fptosi %59 : f32 to i32 + %61 = arith.addi %38, %60 : i32 + %62 = arith.index_cast %61 : i32 to index + %63 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted = tensor.extract %1[%63] : tensor + %64 = arith.mulf %extracted, %21 : f32 + %65 = arith.mulf %64, %41 : f32 + %66 = arith.sitofp %60 : i32 to f32 + %67 = arith.subf %59, %66 : f32 + %68 = arith.subf %cst_3, %67 : f32 + %69 = arith.mulf %65, %68 : f32 + %extracted_8 = tensor.extract %arg9[%62] : tensor + %70 = arith.addf %extracted_8, %69 : f32 + %inserted = tensor.insert %70 into %arg9[%62] : tensor + %71 = arith.addi %60, %c1_i32 : i32 + %72 = arith.cmpi slt, %71, %c6_i32 : i32 + %73 = arith.select %72, %71, %60 : i32 + %74 = arith.addi %38, %73 : i32 + %75 = arith.index_cast %74 : i32 to index + %76 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_9 = tensor.extract %1[%76] : tensor + %77 = arith.mulf %extracted_9, %21 : f32 + %78 = arith.mulf %77, %41 : f32 + %79 = arith.mulf %78, %67 : f32 + %extracted_10 = tensor.extract %inserted[%75] : tensor + %80 = arith.addf %extracted_10, %79 : f32 + %inserted_11 = tensor.insert %80 into %inserted[%75] : tensor + %81 = arith.addi %46, %60 : i32 + %82 = arith.index_cast %81 : i32 to index + %83 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_12 = tensor.extract %1[%83] : tensor + %84 = arith.mulf %extracted_12, %21 : f32 + %85 = arith.mulf %84, %40 : f32 + %86 = arith.mulf %85, %68 : f32 + %extracted_13 = tensor.extract %inserted_11[%82] : tensor + %87 = arith.addf %extracted_13, %86 : f32 + %inserted_14 = tensor.insert %87 into %inserted_11[%82] : tensor + %88 = arith.addi %46, %73 : i32 + %89 = arith.index_cast %88 : i32 to index + %90 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_15 = tensor.extract %1[%90] : tensor + %91 = arith.mulf %extracted_15, %21 : f32 + %92 = arith.mulf %91, %40 : f32 + %93 = arith.mulf %92, %67 : f32 + %extracted_16 = tensor.extract %inserted_14[%89] : tensor + %94 = arith.addf %extracted_16, %93 : f32 + %inserted_17 = tensor.insert %94 into %inserted_14[%89] : tensor + %95 = arith.addi %48, %60 : i32 + %96 = arith.index_cast %95 : i32 to index + %97 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_18 = tensor.extract %1[%97] : tensor + %98 = arith.mulf %extracted_18, %20 : f32 + %99 = arith.mulf %98, %41 : f32 + %100 = arith.mulf %99, %68 : f32 + %extracted_19 = tensor.extract %inserted_17[%96] : tensor + %101 = arith.addf %extracted_19, %100 : f32 + %inserted_20 = tensor.insert %101 into %inserted_17[%96] : tensor + %102 = arith.addi %48, %73 : i32 + %103 = arith.index_cast %102 : i32 to index + %104 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_21 = tensor.extract %1[%104] : tensor + %105 = arith.mulf %extracted_21, %20 : f32 + %106 = arith.mulf %105, %41 : f32 + %107 = arith.mulf %106, %67 : f32 + %extracted_22 = tensor.extract %inserted_20[%103] : tensor + %108 = arith.addf %extracted_22, %107 : f32 + %inserted_23 = tensor.insert %108 into %inserted_20[%103] : tensor + %109 = arith.addi %50, %60 : i32 + %110 = arith.index_cast %109 : i32 to index + %111 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_24 = tensor.extract %1[%111] : tensor + %112 = arith.mulf %extracted_24, %20 : f32 + %113 = arith.mulf %112, %40 : f32 + %114 = arith.mulf %113, %68 : f32 + %extracted_25 = tensor.extract %inserted_23[%110] : tensor + %115 = arith.addf %extracted_25, %114 : f32 + %inserted_26 = tensor.insert %115 into %inserted_23[%110] : tensor + %116 = arith.addi %50, %73 : i32 + %117 = arith.index_cast %116 : i32 to index + %118 = affine.apply #map1(%arg2, %arg8, %arg4, %arg6) + %extracted_27 = tensor.extract %1[%118] : tensor + %119 = arith.mulf %extracted_27, %20 : f32 + %120 = arith.mulf %119, %40 : f32 + %121 = arith.mulf %120, %67 : f32 + %extracted_28 = tensor.extract %inserted_26[%117] : tensor + %122 = arith.addf %extracted_28, %121 : f32 + %inserted_29 = tensor.insert %122 into %inserted_26[%117] : tensor + affine.yield %inserted_29 : tensor + } + affine.yield %51 : tensor + } + affine.yield %27 : tensor + } + affine.yield %7 : tensor + } + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..e28215c45e1b --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_backward_cpu_linalg.mlir @@ -0,0 +1,163 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_trilinear3d_backward_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 9.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %cst_1 = arith.constant 8.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %cst_4 = arith.constant 7.000000e+00 : f32 + %cst_5 = arith.constant 4.000000e+00 : f32 + %cst_6 = arith.constant 5.000000e-01 : f32 + %cst_7 = arith.constant 0.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c5_i32 = arith.constant 5 : i32 + %c4_i32 = arith.constant 4 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: f32): + linalg.yield %cst_7 : f32 + } + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_6 : f32 + %5 = arith.mulf %4, %cst_5 : f32 + %6 = arith.divf %5, %cst_4 : f32 + %7 = arith.subf %6, %cst_6 : f32 + %8 = arith.cmpf olt, %7, %cst_7 : f32 + %9 = arith.select %8, %cst_7, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + %13 = arith.sitofp %10 : i32 to f32 + %14 = arith.subf %9, %13 : f32 + %15 = arith.subf %cst_3, %14 : f32 + %16 = arith.addi %10, %c1_i32 : i32 + %17 = arith.cmpi slt, %16, %c4_i32 : i32 + %18 = arith.select %17, %16, %10 : i32 + %19 = arith.addi %1, %18 : i32 + %20 = arith.muli %19, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %21 = arith.index_cast %arg4 : index to i32 + %22 = arith.sitofp %21 : i32 to f32 + %23 = arith.addf %22, %cst_6 : f32 + %24 = arith.mulf %23, %cst_2 : f32 + %25 = arith.divf %24, %cst_1 : f32 + %26 = arith.subf %25, %cst_6 : f32 + %27 = arith.cmpf olt, %26, %cst_7 : f32 + %28 = arith.select %27, %cst_7, %26 : f32 + %29 = arith.fptosi %28 : f32 to i32 + %30 = arith.addi %12, %29 : i32 + %31 = arith.muli %30, %c6_i32 : i32 + %32 = arith.sitofp %29 : i32 to f32 + %33 = arith.subf %28, %32 : f32 + %34 = arith.subf %cst_3, %33 : f32 + %35 = arith.addi %29, %c1_i32 : i32 + %36 = arith.cmpi slt, %35, %c5_i32 : i32 + %37 = arith.select %36, %35, %29 : i32 + %38 = arith.addi %12, %37 : i32 + %39 = arith.muli %38, %c6_i32 : i32 + %40 = arith.addi %20, %29 : i32 + %41 = arith.muli %40, %c6_i32 : i32 + %42 = arith.addi %20, %37 : i32 + %43 = arith.muli %42, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %44 = arith.index_cast %arg5 : index to i32 + %45 = arith.sitofp %44 : i32 to f32 + %46 = arith.addf %45, %cst_6 : f32 + %47 = arith.mulf %46, %cst_0 : f32 + %48 = arith.divf %47, %cst : f32 + %49 = arith.subf %48, %cst_6 : f32 + %50 = arith.cmpf olt, %49, %cst_7 : f32 + %51 = arith.select %50, %cst_7, %49 : f32 + %52 = arith.fptosi %51 : f32 to i32 + %53 = arith.addi %31, %52 : i32 + %54 = arith.index_cast %53 : i32 to index + %55 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %56 = arith.mulf %55, %15 : f32 + %57 = arith.mulf %56, %34 : f32 + %58 = arith.sitofp %52 : i32 to f32 + %59 = arith.subf %51, %58 : f32 + %60 = arith.subf %cst_3, %59 : f32 + %61 = arith.mulf %57, %60 : f32 + %62 = memref.load %arg1[%54] : memref + %63 = arith.addf %62, %61 : f32 + memref.store %63, %arg1[%54] : memref + %64 = arith.addi %52, %c1_i32 : i32 + %65 = arith.cmpi slt, %64, %c6_i32 : i32 + %66 = arith.select %65, %64, %52 : i32 + %67 = arith.addi %31, %66 : i32 + %68 = arith.index_cast %67 : i32 to index + %69 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %70 = arith.mulf %69, %15 : f32 + %71 = arith.mulf %70, %34 : f32 + %72 = arith.mulf %71, %59 : f32 + %73 = memref.load %arg1[%68] : memref + %74 = arith.addf %73, %72 : f32 + memref.store %74, %arg1[%68] : memref + %75 = arith.addi %39, %52 : i32 + %76 = arith.index_cast %75 : i32 to index + %77 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %78 = arith.mulf %77, %15 : f32 + %79 = arith.mulf %78, %33 : f32 + %80 = arith.mulf %79, %60 : f32 + %81 = memref.load %arg1[%76] : memref + %82 = arith.addf %81, %80 : f32 + memref.store %82, %arg1[%76] : memref + %83 = arith.addi %39, %66 : i32 + %84 = arith.index_cast %83 : i32 to index + %85 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %86 = arith.mulf %85, %15 : f32 + %87 = arith.mulf %86, %33 : f32 + %88 = arith.mulf %87, %59 : f32 + %89 = memref.load %arg1[%84] : memref + %90 = arith.addf %89, %88 : f32 + memref.store %90, %arg1[%84] : memref + %91 = arith.addi %41, %52 : i32 + %92 = arith.index_cast %91 : i32 to index + %93 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %94 = arith.mulf %93, %14 : f32 + %95 = arith.mulf %94, %34 : f32 + %96 = arith.mulf %95, %60 : f32 + %97 = memref.load %arg1[%92] : memref + %98 = arith.addf %97, %96 : f32 + memref.store %98, %arg1[%92] : memref + %99 = arith.addi %41, %66 : i32 + %100 = arith.index_cast %99 : i32 to index + %101 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %102 = arith.mulf %101, %14 : f32 + %103 = arith.mulf %102, %34 : f32 + %104 = arith.mulf %103, %59 : f32 + %105 = memref.load %arg1[%100] : memref + %106 = arith.addf %105, %104 : f32 + memref.store %106, %arg1[%100] : memref + %107 = arith.addi %43, %52 : i32 + %108 = arith.index_cast %107 : i32 to index + %109 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %110 = arith.mulf %109, %14 : f32 + %111 = arith.mulf %110, %33 : f32 + %112 = arith.mulf %111, %60 : f32 + %113 = memref.load %arg1[%108] : memref + %114 = arith.addf %113, %112 : f32 + memref.store %114, %arg1[%108] : memref + %115 = arith.addi %43, %66 : i32 + %116 = arith.index_cast %115 : i32 to index + %117 = affine.load %arg0[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + %118 = arith.mulf %117, %14 : f32 + %119 = arith.mulf %118, %33 : f32 + %120 = arith.mulf %119, %59 : f32 + %121 = memref.load %arg1[%116] : memref + %122 = arith.addf %121, %120 : f32 + memref.store %122, %arg1[%116] : memref + } + } + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu.mlir b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu.mlir new file mode 100644 index 000000000000..9094795c3ed4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu.mlir @@ -0,0 +1,141 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_trilinear3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 9.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %cst_1 = arith.constant 8.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst_4 = arith.constant 0.000000e+00 : f32 + %cst_5 = arith.constant 7.000000e+00 : f32 + %cst_6 = arith.constant 4.000000e+00 : f32 + %cst_7 = arith.constant 5.000000e-01 : f32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_7 : f32 + %5 = arith.mulf %4, %cst_6 : f32 + %6 = arith.divf %5, %cst_5 : f32 + %7 = arith.subf %6, %cst_7 : f32 + %8 = arith.cmpf olt, %7, %cst_4 : f32 + %9 = arith.select %8, %cst_4, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + %13 = arith.sitofp %10 : i32 to f32 + %14 = arith.subf %9, %13 : f32 + %15 = arith.subf %cst_3, %14 : f32 + %16 = arith.addi %10, %c1_i32 : i32 + %17 = arith.cmpi slt, %16, %c4_i32 : i32 + %18 = arith.select %17, %16, %10 : i32 + %19 = arith.addi %1, %18 : i32 + %20 = arith.muli %19, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %21 = arith.index_cast %arg4 : index to i32 + %22 = arith.sitofp %21 : i32 to f32 + %23 = arith.addf %22, %cst_7 : f32 + %24 = arith.mulf %23, %cst_2 : f32 + %25 = arith.divf %24, %cst_1 : f32 + %26 = arith.subf %25, %cst_7 : f32 + %27 = arith.cmpf olt, %26, %cst_4 : f32 + %28 = arith.select %27, %cst_4, %26 : f32 + %29 = arith.fptosi %28 : f32 to i32 + %30 = arith.addi %12, %29 : i32 + %31 = arith.muli %30, %c6_i32 : i32 + %32 = arith.sitofp %29 : i32 to f32 + %33 = arith.subf %28, %32 : f32 + %34 = arith.subf %cst_3, %33 : f32 + %35 = arith.addi %29, %c1_i32 : i32 + %36 = arith.cmpi slt, %35, %c5_i32 : i32 + %37 = arith.select %36, %35, %29 : i32 + %38 = arith.addi %12, %37 : i32 + %39 = arith.muli %38, %c6_i32 : i32 + %40 = arith.addi %20, %29 : i32 + %41 = arith.muli %40, %c6_i32 : i32 + %42 = arith.addi %20, %37 : i32 + %43 = arith.muli %42, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %44 = arith.index_cast %arg5 : index to i32 + %45 = arith.sitofp %44 : i32 to f32 + %46 = arith.addf %45, %cst_7 : f32 + %47 = arith.mulf %46, %cst_0 : f32 + %48 = arith.divf %47, %cst : f32 + %49 = arith.subf %48, %cst_7 : f32 + %50 = arith.cmpf olt, %49, %cst_4 : f32 + %51 = arith.select %50, %cst_4, %49 : f32 + %52 = arith.fptosi %51 : f32 to i32 + %53 = arith.addi %31, %52 : i32 + %54 = arith.index_cast %53 : i32 to index + %55 = memref.load %arg0[%54] : memref + %56 = arith.mulf %55, %15 : f32 + %57 = arith.mulf %56, %34 : f32 + %58 = arith.sitofp %52 : i32 to f32 + %59 = arith.subf %51, %58 : f32 + %60 = arith.subf %cst_3, %59 : f32 + %61 = arith.mulf %57, %60 : f32 + %62 = arith.addi %52, %c1_i32 : i32 + %63 = arith.cmpi slt, %62, %c6_i32 : i32 + %64 = arith.select %63, %62, %52 : i32 + %65 = arith.addi %31, %64 : i32 + %66 = arith.index_cast %65 : i32 to index + %67 = memref.load %arg0[%66] : memref + %68 = arith.mulf %67, %15 : f32 + %69 = arith.mulf %68, %34 : f32 + %70 = arith.mulf %69, %59 : f32 + %71 = arith.addf %61, %70 : f32 + %72 = arith.addi %39, %52 : i32 + %73 = arith.index_cast %72 : i32 to index + %74 = memref.load %arg0[%73] : memref + %75 = arith.mulf %74, %15 : f32 + %76 = arith.mulf %75, %33 : f32 + %77 = arith.mulf %76, %60 : f32 + %78 = arith.addf %71, %77 : f32 + %79 = arith.addi %39, %64 : i32 + %80 = arith.index_cast %79 : i32 to index + %81 = memref.load %arg0[%80] : memref + %82 = arith.mulf %81, %15 : f32 + %83 = arith.mulf %82, %33 : f32 + %84 = arith.mulf %83, %59 : f32 + %85 = arith.addf %78, %84 : f32 + %86 = arith.addi %41, %52 : i32 + %87 = arith.index_cast %86 : i32 to index + %88 = memref.load %arg0[%87] : memref + %89 = arith.mulf %88, %14 : f32 + %90 = arith.mulf %89, %34 : f32 + %91 = arith.mulf %90, %60 : f32 + %92 = arith.addf %85, %91 : f32 + %93 = arith.addi %41, %64 : i32 + %94 = arith.index_cast %93 : i32 to index + %95 = memref.load %arg0[%94] : memref + %96 = arith.mulf %95, %14 : f32 + %97 = arith.mulf %96, %34 : f32 + %98 = arith.mulf %97, %59 : f32 + %99 = arith.addf %92, %98 : f32 + %100 = arith.addi %43, %52 : i32 + %101 = arith.index_cast %100 : i32 to index + %102 = memref.load %arg0[%101] : memref + %103 = arith.mulf %102, %14 : f32 + %104 = arith.mulf %103, %33 : f32 + %105 = arith.mulf %104, %60 : f32 + %106 = arith.addf %99, %105 : f32 + %107 = arith.addi %43, %64 : i32 + %108 = arith.index_cast %107 : i32 to index + %109 = memref.load %arg0[%108] : memref + %110 = arith.mulf %109, %14 : f32 + %111 = arith.mulf %110, %33 : f32 + %112 = arith.mulf %111, %59 : f32 + %113 = arith.addf %106, %112 : f32 + affine.store %113, %arg1[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu/debuf.mlir new file mode 100644 index 000000000000..52ca392f5af1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu/debuf.mlir @@ -0,0 +1,152 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 504 + d1 * 72 + d2 * 9)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_trilinear3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e+00 : f32 + %cst_5 = arith.constant 8.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %cst_6 = arith.constant 6.000000e+00 : f32 + %cst_7 = arith.constant 9.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8, %c9) {map = #map} : (tensor, index, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.sitofp %9 : i32 to f32 + %11 = arith.addf %10, %cst : f32 + %12 = arith.mulf %11, %cst_0 : f32 + %13 = arith.divf %12, %cst_1 : f32 + %14 = arith.subf %13, %cst : f32 + %15 = arith.cmpf olt, %14, %cst_2 : f32 + %16 = arith.select %15, %cst_2, %14 : f32 + %17 = arith.fptosi %16 : f32 to i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = arith.sitofp %17 : i32 to f32 + %21 = arith.subf %16, %20 : f32 + %22 = arith.subf %cst_3, %21 : f32 + %23 = arith.addi %17, %c1_i32 : i32 + %24 = arith.cmpi slt, %23, %c4_i32 : i32 + %25 = arith.select %24, %23, %17 : i32 + %26 = arith.addi %7, %25 : i32 + %27 = arith.muli %26, %c5_i32 : i32 + %28 = linalg.index 2 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.sitofp %29 : i32 to f32 + %31 = arith.addf %30, %cst : f32 + %32 = arith.mulf %31, %cst_4 : f32 + %33 = arith.divf %32, %cst_5 : f32 + %34 = arith.subf %33, %cst : f32 + %35 = arith.cmpf olt, %34, %cst_2 : f32 + %36 = arith.select %35, %cst_2, %34 : f32 + %37 = arith.fptosi %36 : f32 to i32 + %38 = arith.addi %19, %37 : i32 + %39 = arith.muli %38, %c6_i32 : i32 + %40 = arith.sitofp %37 : i32 to f32 + %41 = arith.subf %36, %40 : f32 + %42 = arith.subf %cst_3, %41 : f32 + %43 = arith.addi %37, %c1_i32 : i32 + %44 = arith.cmpi slt, %43, %c5_i32 : i32 + %45 = arith.select %44, %43, %37 : i32 + %46 = arith.addi %19, %45 : i32 + %47 = arith.muli %46, %c6_i32 : i32 + %48 = arith.addi %27, %37 : i32 + %49 = arith.muli %48, %c6_i32 : i32 + %50 = arith.addi %27, %45 : i32 + %51 = arith.muli %50, %c6_i32 : i32 + %52 = linalg.index 3 : index + %53 = arith.index_cast %52 : index to i32 + %54 = arith.sitofp %53 : i32 to f32 + %55 = arith.addf %54, %cst : f32 + %56 = arith.mulf %55, %cst_6 : f32 + %57 = arith.divf %56, %cst_7 : f32 + %58 = arith.subf %57, %cst : f32 + %59 = arith.cmpf olt, %58, %cst_2 : f32 + %60 = arith.select %59, %cst_2, %58 : f32 + %61 = arith.fptosi %60 : f32 to i32 + %62 = arith.addi %39, %61 : i32 + %63 = arith.index_cast %62 : i32 to index + %64 = memref.load %arg0[%63] : memref + %65 = arith.mulf %64, %22 : f32 + %66 = arith.mulf %65, %42 : f32 + %67 = arith.sitofp %61 : i32 to f32 + %68 = arith.subf %60, %67 : f32 + %69 = arith.subf %cst_3, %68 : f32 + %70 = arith.mulf %66, %69 : f32 + %71 = arith.addi %61, %c1_i32 : i32 + %72 = arith.cmpi slt, %71, %c6_i32 : i32 + %73 = arith.select %72, %71, %61 : i32 + %74 = arith.addi %39, %73 : i32 + %75 = arith.index_cast %74 : i32 to index + %76 = memref.load %arg0[%75] : memref + %77 = arith.mulf %76, %22 : f32 + %78 = arith.mulf %77, %42 : f32 + %79 = arith.mulf %78, %68 : f32 + %80 = arith.addf %70, %79 : f32 + %81 = arith.addi %47, %61 : i32 + %82 = arith.index_cast %81 : i32 to index + %83 = memref.load %arg0[%82] : memref + %84 = arith.mulf %83, %22 : f32 + %85 = arith.mulf %84, %41 : f32 + %86 = arith.mulf %85, %69 : f32 + %87 = arith.addf %80, %86 : f32 + %88 = arith.addi %47, %73 : i32 + %89 = arith.index_cast %88 : i32 to index + %90 = memref.load %arg0[%89] : memref + %91 = arith.mulf %90, %22 : f32 + %92 = arith.mulf %91, %41 : f32 + %93 = arith.mulf %92, %68 : f32 + %94 = arith.addf %87, %93 : f32 + %95 = arith.addi %49, %61 : i32 + %96 = arith.index_cast %95 : i32 to index + %97 = memref.load %arg0[%96] : memref + %98 = arith.mulf %97, %21 : f32 + %99 = arith.mulf %98, %42 : f32 + %100 = arith.mulf %99, %69 : f32 + %101 = arith.addf %94, %100 : f32 + %102 = arith.addi %49, %73 : i32 + %103 = arith.index_cast %102 : i32 to index + %104 = memref.load %arg0[%103] : memref + %105 = arith.mulf %104, %21 : f32 + %106 = arith.mulf %105, %42 : f32 + %107 = arith.mulf %106, %68 : f32 + %108 = arith.addf %101, %107 : f32 + %109 = arith.addi %51, %61 : i32 + %110 = arith.index_cast %109 : i32 to index + %111 = memref.load %arg0[%110] : memref + %112 = arith.mulf %111, %21 : f32 + %113 = arith.mulf %112, %41 : f32 + %114 = arith.mulf %113, %69 : f32 + %115 = arith.addf %108, %114 : f32 + %116 = arith.addi %51, %73 : i32 + %117 = arith.index_cast %116 : i32 to index + %118 = memref.load %arg0[%117] : memref + %119 = arith.mulf %118, %21 : f32 + %120 = arith.mulf %119, %41 : f32 + %121 = arith.mulf %120, %68 : f32 + %122 = arith.addf %115, %121 : f32 + linalg.yield %122 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8, %c9) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu/matched.mlir new file mode 100644 index 000000000000..52ca392f5af1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu/matched.mlir @@ -0,0 +1,152 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 504 + d1 * 72 + d2 * 9)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_trilinear3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e+00 : f32 + %cst_5 = arith.constant 8.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %cst_6 = arith.constant 6.000000e+00 : f32 + %cst_7 = arith.constant 9.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8, %c9) {map = #map} : (tensor, index, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.sitofp %9 : i32 to f32 + %11 = arith.addf %10, %cst : f32 + %12 = arith.mulf %11, %cst_0 : f32 + %13 = arith.divf %12, %cst_1 : f32 + %14 = arith.subf %13, %cst : f32 + %15 = arith.cmpf olt, %14, %cst_2 : f32 + %16 = arith.select %15, %cst_2, %14 : f32 + %17 = arith.fptosi %16 : f32 to i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = arith.sitofp %17 : i32 to f32 + %21 = arith.subf %16, %20 : f32 + %22 = arith.subf %cst_3, %21 : f32 + %23 = arith.addi %17, %c1_i32 : i32 + %24 = arith.cmpi slt, %23, %c4_i32 : i32 + %25 = arith.select %24, %23, %17 : i32 + %26 = arith.addi %7, %25 : i32 + %27 = arith.muli %26, %c5_i32 : i32 + %28 = linalg.index 2 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.sitofp %29 : i32 to f32 + %31 = arith.addf %30, %cst : f32 + %32 = arith.mulf %31, %cst_4 : f32 + %33 = arith.divf %32, %cst_5 : f32 + %34 = arith.subf %33, %cst : f32 + %35 = arith.cmpf olt, %34, %cst_2 : f32 + %36 = arith.select %35, %cst_2, %34 : f32 + %37 = arith.fptosi %36 : f32 to i32 + %38 = arith.addi %19, %37 : i32 + %39 = arith.muli %38, %c6_i32 : i32 + %40 = arith.sitofp %37 : i32 to f32 + %41 = arith.subf %36, %40 : f32 + %42 = arith.subf %cst_3, %41 : f32 + %43 = arith.addi %37, %c1_i32 : i32 + %44 = arith.cmpi slt, %43, %c5_i32 : i32 + %45 = arith.select %44, %43, %37 : i32 + %46 = arith.addi %19, %45 : i32 + %47 = arith.muli %46, %c6_i32 : i32 + %48 = arith.addi %27, %37 : i32 + %49 = arith.muli %48, %c6_i32 : i32 + %50 = arith.addi %27, %45 : i32 + %51 = arith.muli %50, %c6_i32 : i32 + %52 = linalg.index 3 : index + %53 = arith.index_cast %52 : index to i32 + %54 = arith.sitofp %53 : i32 to f32 + %55 = arith.addf %54, %cst : f32 + %56 = arith.mulf %55, %cst_6 : f32 + %57 = arith.divf %56, %cst_7 : f32 + %58 = arith.subf %57, %cst : f32 + %59 = arith.cmpf olt, %58, %cst_2 : f32 + %60 = arith.select %59, %cst_2, %58 : f32 + %61 = arith.fptosi %60 : f32 to i32 + %62 = arith.addi %39, %61 : i32 + %63 = arith.index_cast %62 : i32 to index + %64 = memref.load %arg0[%63] : memref + %65 = arith.mulf %64, %22 : f32 + %66 = arith.mulf %65, %42 : f32 + %67 = arith.sitofp %61 : i32 to f32 + %68 = arith.subf %60, %67 : f32 + %69 = arith.subf %cst_3, %68 : f32 + %70 = arith.mulf %66, %69 : f32 + %71 = arith.addi %61, %c1_i32 : i32 + %72 = arith.cmpi slt, %71, %c6_i32 : i32 + %73 = arith.select %72, %71, %61 : i32 + %74 = arith.addi %39, %73 : i32 + %75 = arith.index_cast %74 : i32 to index + %76 = memref.load %arg0[%75] : memref + %77 = arith.mulf %76, %22 : f32 + %78 = arith.mulf %77, %42 : f32 + %79 = arith.mulf %78, %68 : f32 + %80 = arith.addf %70, %79 : f32 + %81 = arith.addi %47, %61 : i32 + %82 = arith.index_cast %81 : i32 to index + %83 = memref.load %arg0[%82] : memref + %84 = arith.mulf %83, %22 : f32 + %85 = arith.mulf %84, %41 : f32 + %86 = arith.mulf %85, %69 : f32 + %87 = arith.addf %80, %86 : f32 + %88 = arith.addi %47, %73 : i32 + %89 = arith.index_cast %88 : i32 to index + %90 = memref.load %arg0[%89] : memref + %91 = arith.mulf %90, %22 : f32 + %92 = arith.mulf %91, %41 : f32 + %93 = arith.mulf %92, %68 : f32 + %94 = arith.addf %87, %93 : f32 + %95 = arith.addi %49, %61 : i32 + %96 = arith.index_cast %95 : i32 to index + %97 = memref.load %arg0[%96] : memref + %98 = arith.mulf %97, %21 : f32 + %99 = arith.mulf %98, %42 : f32 + %100 = arith.mulf %99, %69 : f32 + %101 = arith.addf %94, %100 : f32 + %102 = arith.addi %49, %73 : i32 + %103 = arith.index_cast %102 : i32 to index + %104 = memref.load %arg0[%103] : memref + %105 = arith.mulf %104, %21 : f32 + %106 = arith.mulf %105, %42 : f32 + %107 = arith.mulf %106, %68 : f32 + %108 = arith.addf %101, %107 : f32 + %109 = arith.addi %51, %61 : i32 + %110 = arith.index_cast %109 : i32 to index + %111 = memref.load %arg0[%110] : memref + %112 = arith.mulf %111, %21 : f32 + %113 = arith.mulf %112, %41 : f32 + %114 = arith.mulf %113, %69 : f32 + %115 = arith.addf %108, %114 : f32 + %116 = arith.addi %51, %73 : i32 + %117 = arith.index_cast %116 : i32 to index + %118 = memref.load %arg0[%117] : memref + %119 = arith.mulf %118, %21 : f32 + %120 = arith.mulf %119, %41 : f32 + %121 = arith.mulf %120, %68 : f32 + %122 = arith.addf %115, %121 : f32 + linalg.yield %122 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8, %c9) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu/orig.mlir new file mode 100644 index 000000000000..9094795c3ed4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu/orig.mlir @@ -0,0 +1,141 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_trilinear3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 9.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %cst_1 = arith.constant 8.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst_4 = arith.constant 0.000000e+00 : f32 + %cst_5 = arith.constant 7.000000e+00 : f32 + %cst_6 = arith.constant 4.000000e+00 : f32 + %cst_7 = arith.constant 5.000000e-01 : f32 + affine.for %arg2 = 0 to 2 { + %0 = arith.index_cast %arg2 : index to i32 + %1 = arith.muli %0, %c4_i32 : i32 + affine.for %arg3 = 0 to 7 { + %2 = arith.index_cast %arg3 : index to i32 + %3 = arith.sitofp %2 : i32 to f32 + %4 = arith.addf %3, %cst_7 : f32 + %5 = arith.mulf %4, %cst_6 : f32 + %6 = arith.divf %5, %cst_5 : f32 + %7 = arith.subf %6, %cst_7 : f32 + %8 = arith.cmpf olt, %7, %cst_4 : f32 + %9 = arith.select %8, %cst_4, %7 : f32 + %10 = arith.fptosi %9 : f32 to i32 + %11 = arith.addi %1, %10 : i32 + %12 = arith.muli %11, %c5_i32 : i32 + %13 = arith.sitofp %10 : i32 to f32 + %14 = arith.subf %9, %13 : f32 + %15 = arith.subf %cst_3, %14 : f32 + %16 = arith.addi %10, %c1_i32 : i32 + %17 = arith.cmpi slt, %16, %c4_i32 : i32 + %18 = arith.select %17, %16, %10 : i32 + %19 = arith.addi %1, %18 : i32 + %20 = arith.muli %19, %c5_i32 : i32 + affine.for %arg4 = 0 to 8 { + %21 = arith.index_cast %arg4 : index to i32 + %22 = arith.sitofp %21 : i32 to f32 + %23 = arith.addf %22, %cst_7 : f32 + %24 = arith.mulf %23, %cst_2 : f32 + %25 = arith.divf %24, %cst_1 : f32 + %26 = arith.subf %25, %cst_7 : f32 + %27 = arith.cmpf olt, %26, %cst_4 : f32 + %28 = arith.select %27, %cst_4, %26 : f32 + %29 = arith.fptosi %28 : f32 to i32 + %30 = arith.addi %12, %29 : i32 + %31 = arith.muli %30, %c6_i32 : i32 + %32 = arith.sitofp %29 : i32 to f32 + %33 = arith.subf %28, %32 : f32 + %34 = arith.subf %cst_3, %33 : f32 + %35 = arith.addi %29, %c1_i32 : i32 + %36 = arith.cmpi slt, %35, %c5_i32 : i32 + %37 = arith.select %36, %35, %29 : i32 + %38 = arith.addi %12, %37 : i32 + %39 = arith.muli %38, %c6_i32 : i32 + %40 = arith.addi %20, %29 : i32 + %41 = arith.muli %40, %c6_i32 : i32 + %42 = arith.addi %20, %37 : i32 + %43 = arith.muli %42, %c6_i32 : i32 + affine.for %arg5 = 0 to 9 { + %44 = arith.index_cast %arg5 : index to i32 + %45 = arith.sitofp %44 : i32 to f32 + %46 = arith.addf %45, %cst_7 : f32 + %47 = arith.mulf %46, %cst_0 : f32 + %48 = arith.divf %47, %cst : f32 + %49 = arith.subf %48, %cst_7 : f32 + %50 = arith.cmpf olt, %49, %cst_4 : f32 + %51 = arith.select %50, %cst_4, %49 : f32 + %52 = arith.fptosi %51 : f32 to i32 + %53 = arith.addi %31, %52 : i32 + %54 = arith.index_cast %53 : i32 to index + %55 = memref.load %arg0[%54] : memref + %56 = arith.mulf %55, %15 : f32 + %57 = arith.mulf %56, %34 : f32 + %58 = arith.sitofp %52 : i32 to f32 + %59 = arith.subf %51, %58 : f32 + %60 = arith.subf %cst_3, %59 : f32 + %61 = arith.mulf %57, %60 : f32 + %62 = arith.addi %52, %c1_i32 : i32 + %63 = arith.cmpi slt, %62, %c6_i32 : i32 + %64 = arith.select %63, %62, %52 : i32 + %65 = arith.addi %31, %64 : i32 + %66 = arith.index_cast %65 : i32 to index + %67 = memref.load %arg0[%66] : memref + %68 = arith.mulf %67, %15 : f32 + %69 = arith.mulf %68, %34 : f32 + %70 = arith.mulf %69, %59 : f32 + %71 = arith.addf %61, %70 : f32 + %72 = arith.addi %39, %52 : i32 + %73 = arith.index_cast %72 : i32 to index + %74 = memref.load %arg0[%73] : memref + %75 = arith.mulf %74, %15 : f32 + %76 = arith.mulf %75, %33 : f32 + %77 = arith.mulf %76, %60 : f32 + %78 = arith.addf %71, %77 : f32 + %79 = arith.addi %39, %64 : i32 + %80 = arith.index_cast %79 : i32 to index + %81 = memref.load %arg0[%80] : memref + %82 = arith.mulf %81, %15 : f32 + %83 = arith.mulf %82, %33 : f32 + %84 = arith.mulf %83, %59 : f32 + %85 = arith.addf %78, %84 : f32 + %86 = arith.addi %41, %52 : i32 + %87 = arith.index_cast %86 : i32 to index + %88 = memref.load %arg0[%87] : memref + %89 = arith.mulf %88, %14 : f32 + %90 = arith.mulf %89, %34 : f32 + %91 = arith.mulf %90, %60 : f32 + %92 = arith.addf %85, %91 : f32 + %93 = arith.addi %41, %64 : i32 + %94 = arith.index_cast %93 : i32 to index + %95 = memref.load %arg0[%94] : memref + %96 = arith.mulf %95, %14 : f32 + %97 = arith.mulf %96, %34 : f32 + %98 = arith.mulf %97, %59 : f32 + %99 = arith.addf %92, %98 : f32 + %100 = arith.addi %43, %52 : i32 + %101 = arith.index_cast %100 : i32 to index + %102 = memref.load %arg0[%101] : memref + %103 = arith.mulf %102, %14 : f32 + %104 = arith.mulf %103, %33 : f32 + %105 = arith.mulf %104, %60 : f32 + %106 = arith.addf %99, %105 : f32 + %107 = arith.addi %43, %64 : i32 + %108 = arith.index_cast %107 : i32 to index + %109 = memref.load %arg0[%108] : memref + %110 = arith.mulf %109, %14 : f32 + %111 = arith.mulf %110, %33 : f32 + %112 = arith.mulf %111, %59 : f32 + %113 = arith.addf %106, %112 : f32 + affine.store %113, %arg1[%arg2 * 504 + %arg5 + %arg3 * 72 + %arg4 * 9] : memref + } + } + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu/raised.mlir new file mode 100644 index 000000000000..1f1a63095783 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu/raised.mlir @@ -0,0 +1,148 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 504 + d1 * 72 + d2 * 9)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_trilinear3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c9 = arith.constant 9 : index + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 9.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %cst_1 = arith.constant 8.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst_4 = arith.constant 0.000000e+00 : f32 + %cst_5 = arith.constant 7.000000e+00 : f32 + %cst_6 = arith.constant 4.000000e+00 : f32 + %cst_7 = arith.constant 5.000000e-01 : f32 + %0 = polygeist.submap(%arg1, %c2, %c7, %c8, %c9) {map = #map} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_7 : f32 + %8 = arith.mulf %7, %cst_6 : f32 + %9 = arith.divf %8, %cst_5 : f32 + %10 = arith.subf %9, %cst_7 : f32 + %11 = arith.cmpf olt, %10, %cst_4 : f32 + %12 = arith.select %11, %cst_4, %10 : f32 + %13 = arith.fptosi %12 : f32 to i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = arith.sitofp %13 : i32 to f32 + %17 = arith.subf %12, %16 : f32 + %18 = arith.subf %cst_3, %17 : f32 + %19 = arith.addi %13, %c1_i32 : i32 + %20 = arith.cmpi slt, %19, %c4_i32 : i32 + %21 = arith.select %20, %19, %13 : i32 + %22 = arith.addi %3, %21 : i32 + %23 = arith.muli %22, %c5_i32 : i32 + %24 = linalg.index 2 : index + %25 = arith.index_cast %24 : index to i32 + %26 = arith.sitofp %25 : i32 to f32 + %27 = arith.addf %26, %cst_7 : f32 + %28 = arith.mulf %27, %cst_2 : f32 + %29 = arith.divf %28, %cst_1 : f32 + %30 = arith.subf %29, %cst_7 : f32 + %31 = arith.cmpf olt, %30, %cst_4 : f32 + %32 = arith.select %31, %cst_4, %30 : f32 + %33 = arith.fptosi %32 : f32 to i32 + %34 = arith.addi %15, %33 : i32 + %35 = arith.muli %34, %c6_i32 : i32 + %36 = arith.sitofp %33 : i32 to f32 + %37 = arith.subf %32, %36 : f32 + %38 = arith.subf %cst_3, %37 : f32 + %39 = arith.addi %33, %c1_i32 : i32 + %40 = arith.cmpi slt, %39, %c5_i32 : i32 + %41 = arith.select %40, %39, %33 : i32 + %42 = arith.addi %15, %41 : i32 + %43 = arith.muli %42, %c6_i32 : i32 + %44 = arith.addi %23, %33 : i32 + %45 = arith.muli %44, %c6_i32 : i32 + %46 = arith.addi %23, %41 : i32 + %47 = arith.muli %46, %c6_i32 : i32 + %48 = linalg.index 3 : index + %49 = arith.index_cast %48 : index to i32 + %50 = arith.sitofp %49 : i32 to f32 + %51 = arith.addf %50, %cst_7 : f32 + %52 = arith.mulf %51, %cst_0 : f32 + %53 = arith.divf %52, %cst : f32 + %54 = arith.subf %53, %cst_7 : f32 + %55 = arith.cmpf olt, %54, %cst_4 : f32 + %56 = arith.select %55, %cst_4, %54 : f32 + %57 = arith.fptosi %56 : f32 to i32 + %58 = arith.addi %35, %57 : i32 + %59 = arith.index_cast %58 : i32 to index + %60 = memref.load %arg0[%59] : memref + %61 = arith.mulf %60, %18 : f32 + %62 = arith.mulf %61, %38 : f32 + %63 = arith.sitofp %57 : i32 to f32 + %64 = arith.subf %56, %63 : f32 + %65 = arith.subf %cst_3, %64 : f32 + %66 = arith.mulf %62, %65 : f32 + %67 = arith.addi %57, %c1_i32 : i32 + %68 = arith.cmpi slt, %67, %c6_i32 : i32 + %69 = arith.select %68, %67, %57 : i32 + %70 = arith.addi %35, %69 : i32 + %71 = arith.index_cast %70 : i32 to index + %72 = memref.load %arg0[%71] : memref + %73 = arith.mulf %72, %18 : f32 + %74 = arith.mulf %73, %38 : f32 + %75 = arith.mulf %74, %64 : f32 + %76 = arith.addf %66, %75 : f32 + %77 = arith.addi %43, %57 : i32 + %78 = arith.index_cast %77 : i32 to index + %79 = memref.load %arg0[%78] : memref + %80 = arith.mulf %79, %18 : f32 + %81 = arith.mulf %80, %37 : f32 + %82 = arith.mulf %81, %65 : f32 + %83 = arith.addf %76, %82 : f32 + %84 = arith.addi %43, %69 : i32 + %85 = arith.index_cast %84 : i32 to index + %86 = memref.load %arg0[%85] : memref + %87 = arith.mulf %86, %18 : f32 + %88 = arith.mulf %87, %37 : f32 + %89 = arith.mulf %88, %64 : f32 + %90 = arith.addf %83, %89 : f32 + %91 = arith.addi %45, %57 : i32 + %92 = arith.index_cast %91 : i32 to index + %93 = memref.load %arg0[%92] : memref + %94 = arith.mulf %93, %17 : f32 + %95 = arith.mulf %94, %38 : f32 + %96 = arith.mulf %95, %65 : f32 + %97 = arith.addf %90, %96 : f32 + %98 = arith.addi %45, %69 : i32 + %99 = arith.index_cast %98 : i32 to index + %100 = memref.load %arg0[%99] : memref + %101 = arith.mulf %100, %17 : f32 + %102 = arith.mulf %101, %38 : f32 + %103 = arith.mulf %102, %64 : f32 + %104 = arith.addf %97, %103 : f32 + %105 = arith.addi %47, %57 : i32 + %106 = arith.index_cast %105 : i32 to index + %107 = memref.load %arg0[%106] : memref + %108 = arith.mulf %107, %17 : f32 + %109 = arith.mulf %108, %37 : f32 + %110 = arith.mulf %109, %65 : f32 + %111 = arith.addf %104, %110 : f32 + %112 = arith.addi %47, %69 : i32 + %113 = arith.index_cast %112 : i32 to index + %114 = memref.load %arg0[%113] : memref + %115 = arith.mulf %114, %17 : f32 + %116 = arith.mulf %115, %37 : f32 + %117 = arith.mulf %116, %64 : f32 + %118 = arith.addf %111, %117 : f32 + linalg.yield %118 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu_debuf.mlir new file mode 100644 index 000000000000..52ca392f5af1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu_debuf.mlir @@ -0,0 +1,152 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 504 + d1 * 72 + d2 * 9)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_trilinear3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f32 + %cst_0 = arith.constant 4.000000e+00 : f32 + %cst_1 = arith.constant 7.000000e+00 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %c1_i32 = arith.constant 1 : i32 + %c4_i32 = arith.constant 4 : i32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %cst_4 = arith.constant 5.000000e+00 : f32 + %cst_5 = arith.constant 8.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %cst_6 = arith.constant 6.000000e+00 : f32 + %cst_7 = arith.constant 9.000000e+00 : f32 + %c6_i32 = arith.constant 6 : i32 + %c9 = arith.constant 9 : index + %c8 = arith.constant 8 : index + %c7 = arith.constant 7 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = polygeist.submap(%0, %c2, %c7, %c8, %c9) {map = #map} : (tensor, index, index, index, index) -> tensor + %2 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: f32): + %5 = linalg.index 0 : index + %6 = arith.index_cast %5 : index to i32 + %7 = arith.muli %6, %c4_i32 : i32 + %8 = linalg.index 1 : index + %9 = arith.index_cast %8 : index to i32 + %10 = arith.sitofp %9 : i32 to f32 + %11 = arith.addf %10, %cst : f32 + %12 = arith.mulf %11, %cst_0 : f32 + %13 = arith.divf %12, %cst_1 : f32 + %14 = arith.subf %13, %cst : f32 + %15 = arith.cmpf olt, %14, %cst_2 : f32 + %16 = arith.select %15, %cst_2, %14 : f32 + %17 = arith.fptosi %16 : f32 to i32 + %18 = arith.addi %7, %17 : i32 + %19 = arith.muli %18, %c5_i32 : i32 + %20 = arith.sitofp %17 : i32 to f32 + %21 = arith.subf %16, %20 : f32 + %22 = arith.subf %cst_3, %21 : f32 + %23 = arith.addi %17, %c1_i32 : i32 + %24 = arith.cmpi slt, %23, %c4_i32 : i32 + %25 = arith.select %24, %23, %17 : i32 + %26 = arith.addi %7, %25 : i32 + %27 = arith.muli %26, %c5_i32 : i32 + %28 = linalg.index 2 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.sitofp %29 : i32 to f32 + %31 = arith.addf %30, %cst : f32 + %32 = arith.mulf %31, %cst_4 : f32 + %33 = arith.divf %32, %cst_5 : f32 + %34 = arith.subf %33, %cst : f32 + %35 = arith.cmpf olt, %34, %cst_2 : f32 + %36 = arith.select %35, %cst_2, %34 : f32 + %37 = arith.fptosi %36 : f32 to i32 + %38 = arith.addi %19, %37 : i32 + %39 = arith.muli %38, %c6_i32 : i32 + %40 = arith.sitofp %37 : i32 to f32 + %41 = arith.subf %36, %40 : f32 + %42 = arith.subf %cst_3, %41 : f32 + %43 = arith.addi %37, %c1_i32 : i32 + %44 = arith.cmpi slt, %43, %c5_i32 : i32 + %45 = arith.select %44, %43, %37 : i32 + %46 = arith.addi %19, %45 : i32 + %47 = arith.muli %46, %c6_i32 : i32 + %48 = arith.addi %27, %37 : i32 + %49 = arith.muli %48, %c6_i32 : i32 + %50 = arith.addi %27, %45 : i32 + %51 = arith.muli %50, %c6_i32 : i32 + %52 = linalg.index 3 : index + %53 = arith.index_cast %52 : index to i32 + %54 = arith.sitofp %53 : i32 to f32 + %55 = arith.addf %54, %cst : f32 + %56 = arith.mulf %55, %cst_6 : f32 + %57 = arith.divf %56, %cst_7 : f32 + %58 = arith.subf %57, %cst : f32 + %59 = arith.cmpf olt, %58, %cst_2 : f32 + %60 = arith.select %59, %cst_2, %58 : f32 + %61 = arith.fptosi %60 : f32 to i32 + %62 = arith.addi %39, %61 : i32 + %63 = arith.index_cast %62 : i32 to index + %64 = memref.load %arg0[%63] : memref + %65 = arith.mulf %64, %22 : f32 + %66 = arith.mulf %65, %42 : f32 + %67 = arith.sitofp %61 : i32 to f32 + %68 = arith.subf %60, %67 : f32 + %69 = arith.subf %cst_3, %68 : f32 + %70 = arith.mulf %66, %69 : f32 + %71 = arith.addi %61, %c1_i32 : i32 + %72 = arith.cmpi slt, %71, %c6_i32 : i32 + %73 = arith.select %72, %71, %61 : i32 + %74 = arith.addi %39, %73 : i32 + %75 = arith.index_cast %74 : i32 to index + %76 = memref.load %arg0[%75] : memref + %77 = arith.mulf %76, %22 : f32 + %78 = arith.mulf %77, %42 : f32 + %79 = arith.mulf %78, %68 : f32 + %80 = arith.addf %70, %79 : f32 + %81 = arith.addi %47, %61 : i32 + %82 = arith.index_cast %81 : i32 to index + %83 = memref.load %arg0[%82] : memref + %84 = arith.mulf %83, %22 : f32 + %85 = arith.mulf %84, %41 : f32 + %86 = arith.mulf %85, %69 : f32 + %87 = arith.addf %80, %86 : f32 + %88 = arith.addi %47, %73 : i32 + %89 = arith.index_cast %88 : i32 to index + %90 = memref.load %arg0[%89] : memref + %91 = arith.mulf %90, %22 : f32 + %92 = arith.mulf %91, %41 : f32 + %93 = arith.mulf %92, %68 : f32 + %94 = arith.addf %87, %93 : f32 + %95 = arith.addi %49, %61 : i32 + %96 = arith.index_cast %95 : i32 to index + %97 = memref.load %arg0[%96] : memref + %98 = arith.mulf %97, %21 : f32 + %99 = arith.mulf %98, %42 : f32 + %100 = arith.mulf %99, %69 : f32 + %101 = arith.addf %94, %100 : f32 + %102 = arith.addi %49, %73 : i32 + %103 = arith.index_cast %102 : i32 to index + %104 = memref.load %arg0[%103] : memref + %105 = arith.mulf %104, %21 : f32 + %106 = arith.mulf %105, %42 : f32 + %107 = arith.mulf %106, %68 : f32 + %108 = arith.addf %101, %107 : f32 + %109 = arith.addi %51, %61 : i32 + %110 = arith.index_cast %109 : i32 to index + %111 = memref.load %arg0[%110] : memref + %112 = arith.mulf %111, %21 : f32 + %113 = arith.mulf %112, %41 : f32 + %114 = arith.mulf %113, %69 : f32 + %115 = arith.addf %108, %114 : f32 + %116 = arith.addi %51, %73 : i32 + %117 = arith.index_cast %116 : i32 to index + %118 = memref.load %arg0[%117] : memref + %119 = arith.mulf %118, %21 : f32 + %120 = arith.mulf %119, %41 : f32 + %121 = arith.mulf %120, %68 : f32 + %122 = arith.addf %115, %121 : f32 + linalg.yield %122 : f32 + } -> tensor + %3 = polygeist.submapInverse(%0, %2, %c2, %c7, %c8, %c9) {map = #map} : (tensor, tensor, index, index, index, index) -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu_linalg.mlir new file mode 100644 index 000000000000..1f1a63095783 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_upsample_trilinear3d_cpu_linalg.mlir @@ -0,0 +1,148 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 504 + d1 * 72 + d2 * 9)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_upsample_trilinear3d_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c7 = arith.constant 7 : index + %c8 = arith.constant 8 : index + %c9 = arith.constant 9 : index + %c6_i32 = arith.constant 6 : i32 + %cst = arith.constant 9.000000e+00 : f32 + %cst_0 = arith.constant 6.000000e+00 : f32 + %c5_i32 = arith.constant 5 : i32 + %cst_1 = arith.constant 8.000000e+00 : f32 + %cst_2 = arith.constant 5.000000e+00 : f32 + %cst_3 = arith.constant 1.000000e+00 : f32 + %c4_i32 = arith.constant 4 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst_4 = arith.constant 0.000000e+00 : f32 + %cst_5 = arith.constant 7.000000e+00 : f32 + %cst_6 = arith.constant 4.000000e+00 : f32 + %cst_7 = arith.constant 5.000000e-01 : f32 + %0 = polygeist.submap(%arg1, %c2, %c7, %c8, %c9) {map = #map} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%0 : memref) { + ^bb0(%out: f32): + %1 = linalg.index 0 : index + %2 = arith.index_cast %1 : index to i32 + %3 = arith.muli %2, %c4_i32 : i32 + %4 = linalg.index 1 : index + %5 = arith.index_cast %4 : index to i32 + %6 = arith.sitofp %5 : i32 to f32 + %7 = arith.addf %6, %cst_7 : f32 + %8 = arith.mulf %7, %cst_6 : f32 + %9 = arith.divf %8, %cst_5 : f32 + %10 = arith.subf %9, %cst_7 : f32 + %11 = arith.cmpf olt, %10, %cst_4 : f32 + %12 = arith.select %11, %cst_4, %10 : f32 + %13 = arith.fptosi %12 : f32 to i32 + %14 = arith.addi %3, %13 : i32 + %15 = arith.muli %14, %c5_i32 : i32 + %16 = arith.sitofp %13 : i32 to f32 + %17 = arith.subf %12, %16 : f32 + %18 = arith.subf %cst_3, %17 : f32 + %19 = arith.addi %13, %c1_i32 : i32 + %20 = arith.cmpi slt, %19, %c4_i32 : i32 + %21 = arith.select %20, %19, %13 : i32 + %22 = arith.addi %3, %21 : i32 + %23 = arith.muli %22, %c5_i32 : i32 + %24 = linalg.index 2 : index + %25 = arith.index_cast %24 : index to i32 + %26 = arith.sitofp %25 : i32 to f32 + %27 = arith.addf %26, %cst_7 : f32 + %28 = arith.mulf %27, %cst_2 : f32 + %29 = arith.divf %28, %cst_1 : f32 + %30 = arith.subf %29, %cst_7 : f32 + %31 = arith.cmpf olt, %30, %cst_4 : f32 + %32 = arith.select %31, %cst_4, %30 : f32 + %33 = arith.fptosi %32 : f32 to i32 + %34 = arith.addi %15, %33 : i32 + %35 = arith.muli %34, %c6_i32 : i32 + %36 = arith.sitofp %33 : i32 to f32 + %37 = arith.subf %32, %36 : f32 + %38 = arith.subf %cst_3, %37 : f32 + %39 = arith.addi %33, %c1_i32 : i32 + %40 = arith.cmpi slt, %39, %c5_i32 : i32 + %41 = arith.select %40, %39, %33 : i32 + %42 = arith.addi %15, %41 : i32 + %43 = arith.muli %42, %c6_i32 : i32 + %44 = arith.addi %23, %33 : i32 + %45 = arith.muli %44, %c6_i32 : i32 + %46 = arith.addi %23, %41 : i32 + %47 = arith.muli %46, %c6_i32 : i32 + %48 = linalg.index 3 : index + %49 = arith.index_cast %48 : index to i32 + %50 = arith.sitofp %49 : i32 to f32 + %51 = arith.addf %50, %cst_7 : f32 + %52 = arith.mulf %51, %cst_0 : f32 + %53 = arith.divf %52, %cst : f32 + %54 = arith.subf %53, %cst_7 : f32 + %55 = arith.cmpf olt, %54, %cst_4 : f32 + %56 = arith.select %55, %cst_4, %54 : f32 + %57 = arith.fptosi %56 : f32 to i32 + %58 = arith.addi %35, %57 : i32 + %59 = arith.index_cast %58 : i32 to index + %60 = memref.load %arg0[%59] : memref + %61 = arith.mulf %60, %18 : f32 + %62 = arith.mulf %61, %38 : f32 + %63 = arith.sitofp %57 : i32 to f32 + %64 = arith.subf %56, %63 : f32 + %65 = arith.subf %cst_3, %64 : f32 + %66 = arith.mulf %62, %65 : f32 + %67 = arith.addi %57, %c1_i32 : i32 + %68 = arith.cmpi slt, %67, %c6_i32 : i32 + %69 = arith.select %68, %67, %57 : i32 + %70 = arith.addi %35, %69 : i32 + %71 = arith.index_cast %70 : i32 to index + %72 = memref.load %arg0[%71] : memref + %73 = arith.mulf %72, %18 : f32 + %74 = arith.mulf %73, %38 : f32 + %75 = arith.mulf %74, %64 : f32 + %76 = arith.addf %66, %75 : f32 + %77 = arith.addi %43, %57 : i32 + %78 = arith.index_cast %77 : i32 to index + %79 = memref.load %arg0[%78] : memref + %80 = arith.mulf %79, %18 : f32 + %81 = arith.mulf %80, %37 : f32 + %82 = arith.mulf %81, %65 : f32 + %83 = arith.addf %76, %82 : f32 + %84 = arith.addi %43, %69 : i32 + %85 = arith.index_cast %84 : i32 to index + %86 = memref.load %arg0[%85] : memref + %87 = arith.mulf %86, %18 : f32 + %88 = arith.mulf %87, %37 : f32 + %89 = arith.mulf %88, %64 : f32 + %90 = arith.addf %83, %89 : f32 + %91 = arith.addi %45, %57 : i32 + %92 = arith.index_cast %91 : i32 to index + %93 = memref.load %arg0[%92] : memref + %94 = arith.mulf %93, %17 : f32 + %95 = arith.mulf %94, %38 : f32 + %96 = arith.mulf %95, %65 : f32 + %97 = arith.addf %90, %96 : f32 + %98 = arith.addi %45, %69 : i32 + %99 = arith.index_cast %98 : i32 to index + %100 = memref.load %arg0[%99] : memref + %101 = arith.mulf %100, %17 : f32 + %102 = arith.mulf %101, %38 : f32 + %103 = arith.mulf %102, %64 : f32 + %104 = arith.addf %97, %103 : f32 + %105 = arith.addi %47, %57 : i32 + %106 = arith.index_cast %105 : i32 to index + %107 = memref.load %arg0[%106] : memref + %108 = arith.mulf %107, %17 : f32 + %109 = arith.mulf %108, %37 : f32 + %110 = arith.mulf %109, %65 : f32 + %111 = arith.addf %104, %110 : f32 + %112 = arith.addi %47, %69 : i32 + %113 = arith.index_cast %112 : i32 to index + %114 = memref.load %arg0[%113] : memref + %115 = arith.mulf %114, %17 : f32 + %116 = arith.mulf %115, %37 : f32 + %117 = arith.mulf %116, %64 : f32 + %118 = arith.addf %111, %117 : f32 + linalg.yield %118 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_vector_norm_out_cpu.mlir b/issues/aten_c_kernels/results/aten_vector_norm_out_cpu.mlir new file mode 100644 index 000000000000..d8ae7cdea69d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_vector_norm_out_cpu.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_vector_norm_out_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 32 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %cst) -> (f32) { + %2 = affine.load %arg0[%arg2, %arg3] : memref + %3 = arith.mulf %2, %2 : f32 + %4 = arith.addf %arg4, %3 : f32 + affine.yield %4 : f32 + } + %1 = math.sqrt %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_vector_norm_out_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_vector_norm_out_cpu/debuf.mlir new file mode 100644 index 000000000000..74ee00d03308 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_vector_norm_out_cpu/debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_vector_norm_out_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = arith.mulf %in, %in : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c32] [1] : tensor into tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = math.sqrt %in : f32 + linalg.yield %7 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_vector_norm_out_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_vector_norm_out_cpu/matched.mlir new file mode 100644 index 000000000000..75cca6529119 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_vector_norm_out_cpu/matched.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_vector_norm_out_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3 = kernel.launch @memset_zero_1D_f32(%2) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = arith.mulf %in, %in : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c32] [1] : tensor into tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = math.sqrt %in : f32 + linalg.yield %7 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_vector_norm_out_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_vector_norm_out_cpu/orig.mlir new file mode 100644 index 000000000000..d8ae7cdea69d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_vector_norm_out_cpu/orig.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_vector_norm_out_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg2 = 0 to 32 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %cst) -> (f32) { + %2 = affine.load %arg0[%arg2, %arg3] : memref + %3 = arith.mulf %2, %2 : f32 + %4 = arith.addf %arg4, %3 : f32 + affine.yield %4 : f32 + } + %1 = math.sqrt %0 : f32 + affine.store %1, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_vector_norm_out_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_vector_norm_out_cpu/raised.mlir new file mode 100644 index 000000000000..46313ab3819a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_vector_norm_out_cpu/raised.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_vector_norm_out_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca(%c32) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %alloca[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %in : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.sqrt %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_vector_norm_out_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_vector_norm_out_cpu_debuf.mlir new file mode 100644 index 000000000000..74ee00d03308 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_vector_norm_out_cpu_debuf.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_vector_norm_out_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty(%c32) : tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%2 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %4 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = arith.mulf %in, %in : f32 + %8 = arith.addf %out, %7 : f32 + linalg.yield %8 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %4 into %3[0] [%c32] [1] : tensor into tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice : tensor) outs(%1 : tensor) { + ^bb0(%in: f32, %out: f32): + %7 = math.sqrt %in : f32 + linalg.yield %7 : f32 + } -> tensor + %6 = bufferization.to_memref %5 : memref + memref.copy %6, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_vector_norm_out_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_vector_norm_out_cpu_linalg.mlir new file mode 100644 index 000000000000..46313ab3819a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_vector_norm_out_cpu_linalg.mlir @@ -0,0 +1,30 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_vector_norm_out_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %cst = arith.constant 0.000000e+00 : f32 + %alloca = memref.alloca(%c32) : memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%alloca : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %alloca[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: f32, %out: f32): + %0 = arith.mulf %in, %in : f32 + %1 = arith.addf %out, %0 : f32 + linalg.yield %1 : f32 + } + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%alloca : memref) outs(%arg1 : memref) { + ^bb0(%in: f32, %out: f32): + %0 = math.sqrt %in : f32 + linalg.yield %0 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu.mlir b/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu.mlir new file mode 100644 index 000000000000..ec5d35507893 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg6 = 0 to 8 { + %0 = affine.for %arg7 = 0 to 32 iter_args(%arg8 = %cst) -> (f32) { + %3 = affine.load %arg0[%arg6, %arg7] : memref + %4 = affine.load %arg1[%arg6, %arg7] : memref + %5 = arith.mulf %3, %4 : f32 + %6 = arith.addf %arg8, %5 : f32 + affine.yield %6 : f32 + } + %1 = affine.load %arg3[%arg6] : memref + %2 = arith.divf %0, %1 : f32 + affine.store %2, %arg5[%arg6] : memref + affine.for %arg7 = 0 to 32 { + %3 = affine.load %arg2[%arg6] : memref + %4 = affine.load %arg3[%arg6] : memref + %5 = arith.divf %3, %4 : f32 + %6 = affine.load %arg0[%arg6, %arg7] : memref + %7 = affine.load %arg1[%arg6, %arg7] : memref + %8 = arith.mulf %7, %0 : f32 + %9 = arith.mulf %4, %4 : f32 + %10 = arith.divf %8, %9 : f32 + %11 = arith.subf %6, %10 : f32 + %12 = arith.mulf %5, %11 : f32 + affine.store %12, %arg4[%arg6, %arg7] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu/debuf.mlir new file mode 100644 index 000000000000..b19bbfc9ceee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu/debuf.mlir @@ -0,0 +1,57 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg3 : memref + %7 = bufferization.to_tensor %arg1 : memref + %8 = bufferization.to_tensor %arg0 : memref + %9:2 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %5, %arg8 = %4) -> (tensor, tensor) { + %alloca = memref.alloca() : memref + %12 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %12[] : tensor + %extracted_slice = tensor.extract_slice %8[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %7[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %in_8: f32, %out: f32): + %16 = arith.mulf %in, %in_8 : f32 + %17 = arith.addf %out, %16 : f32 + linalg.yield %17 : f32 + } -> tensor + %extracted = tensor.extract %13[] : tensor + %extracted_1 = tensor.extract %6[%arg6] : tensor + %14 = arith.divf %extracted, %extracted_1 : f32 + %inserted_2 = tensor.insert %14 into %arg8[%arg6] : tensor + %extracted_slice_3 = tensor.extract_slice %arg7[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %3[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %2[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %1[%arg6] [1] [1] : tensor to tensor + %extracted_slice_7 = tensor.extract_slice %0[%arg6] [1] [1] : tensor to tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_6, %extracted_slice_7, %extracted_slice_4, %extracted_slice_5 : tensor, tensor, tensor, tensor) outs(%extracted_slice_3 : tensor) { + ^bb0(%in: f32, %in_8: f32, %in_9: f32, %in_10: f32, %out: f32): + %16 = arith.divf %in, %in_8 : f32 + %17 = arith.mulf %in_10, %extracted : f32 + %18 = arith.mulf %in_8, %in_8 : f32 + %19 = arith.divf %17, %18 : f32 + %20 = arith.subf %in_9, %19 : f32 + %21 = arith.mulf %16, %20 : f32 + linalg.yield %21 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %15 into %arg7[%arg6, 0] [1, %c32] [1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_2 : tensor, tensor + } + %10 = bufferization.to_memref %9#1 : memref + memref.copy %10, %arg5 : memref to memref + %11 = bufferization.to_memref %9#0 : memref + memref.copy %11, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu/matched.mlir new file mode 100644 index 000000000000..513de47bf86a --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu/matched.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg3 : memref + %7 = bufferization.to_tensor %arg1 : memref + %8 = bufferization.to_tensor %arg0 : memref + %9:2 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %5, %arg8 = %4) -> (tensor, tensor) { + %alloca = memref.alloca() : memref + %12 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %12[] : tensor + %extracted_slice = tensor.extract_slice %8[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %7[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %13 = kernel.launch @cublasSdot(%extracted_slice, %extracted_slice_0, %inserted) : (tensor, tensor, tensor) -> tensor + %extracted = tensor.extract %13[] : tensor + %extracted_1 = tensor.extract %6[%arg6] : tensor + %14 = arith.divf %extracted, %extracted_1 : f32 + %inserted_2 = tensor.insert %14 into %arg8[%arg6] : tensor + %extracted_slice_3 = tensor.extract_slice %arg7[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %3[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %2[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %1[%arg6] [1] [1] : tensor to tensor + %extracted_slice_7 = tensor.extract_slice %0[%arg6] [1] [1] : tensor to tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_6, %extracted_slice_7, %extracted_slice_4, %extracted_slice_5 : tensor, tensor, tensor, tensor) outs(%extracted_slice_3 : tensor) { + ^bb0(%in: f32, %in_8: f32, %in_9: f32, %in_10: f32, %out: f32): + %16 = arith.divf %in, %in_8 : f32 + %17 = arith.mulf %in_10, %extracted : f32 + %18 = arith.mulf %in_8, %in_8 : f32 + %19 = arith.divf %17, %18 : f32 + %20 = arith.subf %in_9, %19 : f32 + %21 = arith.mulf %16, %20 : f32 + linalg.yield %21 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %15 into %arg7[%arg6, 0] [1, %c32] [1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_2 : tensor, tensor + } + %10 = bufferization.to_memref %9#1 : memref + memref.copy %10, %arg5 : memref to memref + %11 = bufferization.to_memref %9#0 : memref + memref.copy %11, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu/orig.mlir new file mode 100644 index 000000000000..ec5d35507893 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu/orig.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg6 = 0 to 8 { + %0 = affine.for %arg7 = 0 to 32 iter_args(%arg8 = %cst) -> (f32) { + %3 = affine.load %arg0[%arg6, %arg7] : memref + %4 = affine.load %arg1[%arg6, %arg7] : memref + %5 = arith.mulf %3, %4 : f32 + %6 = arith.addf %arg8, %5 : f32 + affine.yield %6 : f32 + } + %1 = affine.load %arg3[%arg6] : memref + %2 = arith.divf %0, %1 : f32 + affine.store %2, %arg5[%arg6] : memref + affine.for %arg7 = 0 to 32 { + %3 = affine.load %arg2[%arg6] : memref + %4 = affine.load %arg3[%arg6] : memref + %5 = arith.divf %3, %4 : f32 + %6 = affine.load %arg0[%arg6, %arg7] : memref + %7 = affine.load %arg1[%arg6, %arg7] : memref + %8 = arith.mulf %7, %0 : f32 + %9 = arith.mulf %4, %4 : f32 + %10 = arith.divf %8, %9 : f32 + %11 = arith.subf %6, %10 : f32 + %12 = arith.mulf %5, %11 : f32 + affine.store %12, %arg4[%arg6, %arg7] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu/raised.mlir new file mode 100644 index 000000000000..22f648a67ea1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu/raised.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg6 = 0 to 8 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[%arg6, 0] [1, %c32] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[%arg6, 0] [1, %c32] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_7: f32, %out: f32): + %3 = arith.mulf %in, %in_7 : f32 + %4 = arith.addf %out, %3 : f32 + linalg.yield %4 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = affine.load %arg3[%arg6] : memref + %2 = arith.divf %0, %1 : f32 + affine.store %2, %arg5[%arg6] : memref + %subview_2 = memref.subview %arg2[%arg6] [1] [1] : memref to memref> + %subview_3 = memref.subview %arg3[%arg6] [1] [1] : memref to memref> + %subview_4 = memref.subview %arg0[%arg6, 0] [1, %c32] [1, 1] : memref to memref> + %subview_5 = memref.subview %arg1[%arg6, 0] [1, %c32] [1, 1] : memref to memref> + %subview_6 = memref.subview %arg4[%arg6, 0] [1, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview_2, %subview_3, %subview_4, %subview_5 : memref>, memref>, memref>, memref>) outs(%subview_6 : memref>) { + ^bb0(%in: f32, %in_7: f32, %in_8: f32, %in_9: f32, %out: f32): + %3 = arith.divf %in, %in_7 : f32 + %4 = arith.mulf %in_9, %0 : f32 + %5 = arith.mulf %in_7, %in_7 : f32 + %6 = arith.divf %4, %5 : f32 + %7 = arith.subf %in_8, %6 : f32 + %8 = arith.mulf %3, %7 : f32 + linalg.yield %8 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu_debuf.mlir new file mode 100644 index 000000000000..b19bbfc9ceee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu_debuf.mlir @@ -0,0 +1,57 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg3 : memref + %7 = bufferization.to_tensor %arg1 : memref + %8 = bufferization.to_tensor %arg0 : memref + %9:2 = affine.for %arg6 = 0 to 8 iter_args(%arg7 = %5, %arg8 = %4) -> (tensor, tensor) { + %alloca = memref.alloca() : memref + %12 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %12[] : tensor + %extracted_slice = tensor.extract_slice %8[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %7[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice, %extracted_slice_0 : tensor, tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %in_8: f32, %out: f32): + %16 = arith.mulf %in, %in_8 : f32 + %17 = arith.addf %out, %16 : f32 + linalg.yield %17 : f32 + } -> tensor + %extracted = tensor.extract %13[] : tensor + %extracted_1 = tensor.extract %6[%arg6] : tensor + %14 = arith.divf %extracted, %extracted_1 : f32 + %inserted_2 = tensor.insert %14 into %arg8[%arg6] : tensor + %extracted_slice_3 = tensor.extract_slice %arg7[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %3[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_5 = tensor.extract_slice %2[%arg6, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_6 = tensor.extract_slice %1[%arg6] [1] [1] : tensor to tensor + %extracted_slice_7 = tensor.extract_slice %0[%arg6] [1] [1] : tensor to tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_6, %extracted_slice_7, %extracted_slice_4, %extracted_slice_5 : tensor, tensor, tensor, tensor) outs(%extracted_slice_3 : tensor) { + ^bb0(%in: f32, %in_8: f32, %in_9: f32, %in_10: f32, %out: f32): + %16 = arith.divf %in, %in_8 : f32 + %17 = arith.mulf %in_10, %extracted : f32 + %18 = arith.mulf %in_8, %in_8 : f32 + %19 = arith.divf %17, %18 : f32 + %20 = arith.subf %in_9, %19 : f32 + %21 = arith.mulf %16, %20 : f32 + linalg.yield %21 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %15 into %arg7[%arg6, 0] [1, %c32] [1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_2 : tensor, tensor + } + %10 = bufferization.to_memref %9#1 : memref + memref.copy %10, %arg5 : memref to memref + %11 = bufferization.to_memref %9#0 : memref + memref.copy %11, %arg4 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu_linalg.mlir new file mode 100644 index 000000000000..22f648a67ea1 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_norm_backward_cpu_linalg.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_norm_backward_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg6 = 0 to 8 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[%arg6, 0] [1, %c32] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[%arg6, 0] [1, %c32] [1, 1] : memref to memref> + %subview_1 = memref.subview %alloca[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map, #map, #map1], iterator_types = ["reduction"]} ins(%subview, %subview_0 : memref>, memref>) outs(%subview_1 : memref>) { + ^bb0(%in: f32, %in_7: f32, %out: f32): + %3 = arith.mulf %in, %in_7 : f32 + %4 = arith.addf %out, %3 : f32 + linalg.yield %4 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = affine.load %arg3[%arg6] : memref + %2 = arith.divf %0, %1 : f32 + affine.store %2, %arg5[%arg6] : memref + %subview_2 = memref.subview %arg2[%arg6] [1] [1] : memref to memref> + %subview_3 = memref.subview %arg3[%arg6] [1] [1] : memref to memref> + %subview_4 = memref.subview %arg0[%arg6, 0] [1, %c32] [1, 1] : memref to memref> + %subview_5 = memref.subview %arg1[%arg6, 0] [1, %c32] [1, 1] : memref to memref> + %subview_6 = memref.subview %arg4[%arg6, 0] [1, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map1, #map, #map, #map], iterator_types = ["parallel"]} ins(%subview_2, %subview_3, %subview_4, %subview_5 : memref>, memref>, memref>, memref>) outs(%subview_6 : memref>) { + ^bb0(%in: f32, %in_7: f32, %in_8: f32, %in_9: f32, %out: f32): + %3 = arith.divf %in, %in_7 : f32 + %4 = arith.mulf %in_9, %0 : f32 + %5 = arith.mulf %in_7, %in_7 : f32 + %6 = arith.divf %4, %5 : f32 + %7 = arith.subf %in_8, %6 : f32 + %8 = arith.mulf %3, %7 : f32 + linalg.yield %8 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_weight_norm_cpu.mlir b/issues/aten_c_kernels/results/aten_weight_norm_cpu.mlir new file mode 100644 index 000000000000..93ef4f7137bc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_norm_cpu.mlir @@ -0,0 +1,24 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_norm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 8 { + %0 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %cst) -> (f32) { + %2 = affine.load %arg0[%arg4, %arg5] : memref + %3 = arith.mulf %2, %2 : f32 + %4 = arith.addf %arg6, %3 : f32 + affine.yield %4 : f32 + } + %1 = math.sqrt %0 : f32 + affine.store %1, %arg3[%arg4] : memref + affine.for %arg5 = 0 to 32 { + %2 = affine.load %arg1[%arg4] : memref + %3 = affine.load %arg0[%arg4, %arg5] : memref + %4 = arith.mulf %2, %3 : f32 + %5 = affine.load %arg3[%arg4] : memref + %6 = arith.divf %4, %5 : f32 + affine.store %6, %arg2[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_weight_norm_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_weight_norm_cpu/debuf.mlir new file mode 100644 index 000000000000..116611c61fb7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_norm_cpu/debuf.mlir @@ -0,0 +1,46 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_norm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5:2 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %3, %arg6 = %2) -> (tensor, tensor) { + %alloca = memref.alloca() : memref + %8 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %8[] : tensor + %extracted_slice = tensor.extract_slice %4[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = arith.mulf %in, %in : f32 + %13 = arith.addf %out, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %extracted = tensor.extract %9[] : tensor + %10 = math.sqrt %extracted : f32 + %inserted_0 = tensor.insert %10 into %arg6[%arg4] : tensor + %extracted_slice_1 = tensor.extract_slice %arg5[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %inserted_0[%arg4] [1] [1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %1[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %0[%arg4] [1] [1] : tensor to tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map1, #map, #map1, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_4, %extracted_slice_3, %extracted_slice_2 : tensor, tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32): + %12 = arith.mulf %in, %in_5 : f32 + %13 = arith.divf %12, %in_6 : f32 + linalg.yield %13 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %11 into %arg5[%arg4, 0] [1, %c32] [1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_0 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg3 : memref to memref + %7 = bufferization.to_memref %5#0 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_weight_norm_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_weight_norm_cpu/matched.mlir new file mode 100644 index 000000000000..116611c61fb7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_norm_cpu/matched.mlir @@ -0,0 +1,46 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_norm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5:2 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %3, %arg6 = %2) -> (tensor, tensor) { + %alloca = memref.alloca() : memref + %8 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %8[] : tensor + %extracted_slice = tensor.extract_slice %4[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = arith.mulf %in, %in : f32 + %13 = arith.addf %out, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %extracted = tensor.extract %9[] : tensor + %10 = math.sqrt %extracted : f32 + %inserted_0 = tensor.insert %10 into %arg6[%arg4] : tensor + %extracted_slice_1 = tensor.extract_slice %arg5[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %inserted_0[%arg4] [1] [1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %1[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %0[%arg4] [1] [1] : tensor to tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map1, #map, #map1, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_4, %extracted_slice_3, %extracted_slice_2 : tensor, tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32): + %12 = arith.mulf %in, %in_5 : f32 + %13 = arith.divf %12, %in_6 : f32 + linalg.yield %13 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %11 into %arg5[%arg4, 0] [1, %c32] [1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_0 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg3 : memref to memref + %7 = bufferization.to_memref %5#0 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_weight_norm_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_weight_norm_cpu/orig.mlir new file mode 100644 index 000000000000..93ef4f7137bc --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_norm_cpu/orig.mlir @@ -0,0 +1,24 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_norm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 8 { + %0 = affine.for %arg5 = 0 to 32 iter_args(%arg6 = %cst) -> (f32) { + %2 = affine.load %arg0[%arg4, %arg5] : memref + %3 = arith.mulf %2, %2 : f32 + %4 = arith.addf %arg6, %3 : f32 + affine.yield %4 : f32 + } + %1 = math.sqrt %0 : f32 + affine.store %1, %arg3[%arg4] : memref + affine.for %arg5 = 0 to 32 { + %2 = affine.load %arg1[%arg4] : memref + %3 = affine.load %arg0[%arg4, %arg5] : memref + %4 = arith.mulf %2, %3 : f32 + %5 = affine.load %arg3[%arg4] : memref + %6 = arith.divf %4, %5 : f32 + affine.store %6, %arg2[%arg4, %arg5] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_weight_norm_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_weight_norm_cpu/raised.mlir new file mode 100644 index 000000000000..944d17d9372d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_norm_cpu/raised.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_norm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 8 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[%arg4, 0] [1, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.mulf %in, %in : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = math.sqrt %0 : f32 + affine.store %1, %arg3[%arg4] : memref + %subview_0 = memref.subview %arg1[%arg4] [1] [1] : memref to memref> + %subview_1 = memref.subview %arg0[%arg4, 0] [1, %c32] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg3[%arg4] [1] [1] : memref to memref> + %subview_3 = memref.subview %arg2[%arg4, 0] [1, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map, #map1, #map], iterator_types = ["parallel"]} ins(%subview_0, %subview_1, %subview_2 : memref>, memref>, memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f32, %in_4: f32, %in_5: f32, %out: f32): + %2 = arith.mulf %in, %in_4 : f32 + %3 = arith.divf %2, %in_5 : f32 + linalg.yield %3 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_weight_norm_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_weight_norm_cpu_debuf.mlir new file mode 100644 index 000000000000..116611c61fb7 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_norm_cpu_debuf.mlir @@ -0,0 +1,46 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_norm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5:2 = affine.for %arg4 = 0 to 8 iter_args(%arg5 = %3, %arg6 = %2) -> (tensor, tensor) { + %alloca = memref.alloca() : memref + %8 = bufferization.to_tensor %alloca : memref + %inserted = tensor.insert %cst into %8[] : tensor + %extracted_slice = tensor.extract_slice %4[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map, #map1], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%inserted : tensor) { + ^bb0(%in: f32, %out: f32): + %12 = arith.mulf %in, %in : f32 + %13 = arith.addf %out, %12 : f32 + linalg.yield %13 : f32 + } -> tensor + %extracted = tensor.extract %9[] : tensor + %10 = math.sqrt %extracted : f32 + %inserted_0 = tensor.insert %10 into %arg6[%arg4] : tensor + %extracted_slice_1 = tensor.extract_slice %arg5[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_2 = tensor.extract_slice %inserted_0[%arg4] [1] [1] : tensor to tensor + %extracted_slice_3 = tensor.extract_slice %1[%arg4, 0] [1, %c32] [1, 1] : tensor to tensor + %extracted_slice_4 = tensor.extract_slice %0[%arg4] [1] [1] : tensor to tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map1, #map, #map1, #map], iterator_types = ["parallel"], library_call = ""} ins(%extracted_slice_4, %extracted_slice_3, %extracted_slice_2 : tensor, tensor, tensor) outs(%extracted_slice_1 : tensor) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32): + %12 = arith.mulf %in, %in_5 : f32 + %13 = arith.divf %12, %in_6 : f32 + linalg.yield %13 : f32 + } -> tensor + %inserted_slice = tensor.insert_slice %11 into %arg5[%arg4, 0] [1, %c32] [1, 1] : tensor into tensor + affine.yield %inserted_slice, %inserted_0 : tensor, tensor + } + %6 = bufferization.to_memref %5#1 : memref + memref.copy %6, %arg3 : memref to memref + %7 = bufferization.to_memref %5#0 : memref + memref.copy %7, %arg2 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_weight_norm_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_weight_norm_cpu_linalg.mlir new file mode 100644 index 000000000000..944d17d9372d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_norm_cpu_linalg.mlir @@ -0,0 +1,34 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_norm_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg4 = 0 to 8 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %subview = memref.subview %arg0[%arg4, 0] [1, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["reduction"]} ins(%subview : memref>) outs(%alloca : memref) { + ^bb0(%in: f32, %out: f32): + %2 = arith.mulf %in, %in : f32 + %3 = arith.addf %out, %2 : f32 + linalg.yield %3 : f32 + } + %0 = affine.load %alloca[] : memref + %1 = math.sqrt %0 : f32 + affine.store %1, %arg3[%arg4] : memref + %subview_0 = memref.subview %arg1[%arg4] [1] [1] : memref to memref> + %subview_1 = memref.subview %arg0[%arg4, 0] [1, %c32] [1, 1] : memref to memref> + %subview_2 = memref.subview %arg3[%arg4] [1] [1] : memref to memref> + %subview_3 = memref.subview %arg2[%arg4, 0] [1, %c32] [1, 1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map, #map1, #map], iterator_types = ["parallel"]} ins(%subview_0, %subview_1, %subview_2 : memref>, memref>, memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f32, %in_4: f32, %in_5: f32, %out: f32): + %2 = arith.mulf %in, %in_4 : f32 + %3 = arith.divf %2, %in_5 : f32 + linalg.yield %3 : f32 + } + } {polygeist.was_parallel} + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu.mlir b/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu.mlir new file mode 100644 index 000000000000..abdc6c0f1100 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_to_int4pack_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c4_i32 = arith.constant 4 : i32 + %c15_i32 = arith.constant 15 : i32 + %c0 = arith.constant 0 : index + affine.for %arg2 = 0 to 48 { + affine.for %arg3 = 0 to 64 step 2 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + %1 = arith.extui %0 : i8 to i32 + %2 = arith.andi %1, %c15_i32 : i32 + %3 = affine.load %arg0[%arg2, %arg3 + 1] : memref + %4 = arith.extui %3 : i8 to i32 + %5 = arith.andi %4, %c15_i32 : i32 + %6 = arith.shli %5, %c4_i32 : i32 + %7 = arith.ori %2, %6 : i32 + %8 = arith.trunci %7 : i32 to i8 + %9 = arith.cmpi slt, %arg3, %c0 : index + %10 = arith.subi %c-1, %arg3 : index + %11 = arith.select %9, %10, %arg3 : index + %12 = arith.divsi %11, %c2 : index + %13 = arith.subi %c-1, %12 : index + %14 = arith.select %9, %13, %12 : index + memref.store %8, %arg1[%arg2, %14] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu/debuf.mlir new file mode 100644 index 000000000000..c8a6a7fb69c0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu/debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0, d1) -> (d1 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_to_int4pack_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c15_i32 = arith.constant 15 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 48 iter_args(%arg3 = %0) -> (tensor) { + %4 = affine.for %arg4 = 0 to 64 step 2 iter_args(%arg5 = %arg3) -> (tensor) { + %extracted = tensor.extract %1[%arg2, %arg4] : tensor + %5 = arith.extui %extracted : i8 to i32 + %6 = arith.andi %5, %c15_i32 : i32 + %7 = affine.apply #map(%arg2, %arg4) + %extracted_0 = tensor.extract %1[%arg2, %7] : tensor + %8 = arith.extui %extracted_0 : i8 to i32 + %9 = arith.andi %8, %c15_i32 : i32 + %10 = arith.shli %9, %c4_i32 : i32 + %11 = arith.ori %6, %10 : i32 + %12 = arith.trunci %11 : i32 to i8 + %13 = arith.cmpi slt, %arg4, %c0 : index + %14 = arith.subi %c-1, %arg4 : index + %15 = arith.select %13, %14, %arg4 : index + %16 = arith.divsi %15, %c2 : index + %17 = arith.subi %c-1, %16 : index + %18 = arith.select %13, %17, %16 : index + %inserted = tensor.insert %12 into %arg5[%arg2, %18] : tensor + affine.yield %inserted : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu/matched.mlir new file mode 100644 index 000000000000..c8a6a7fb69c0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu/matched.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0, d1) -> (d1 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_to_int4pack_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c15_i32 = arith.constant 15 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 48 iter_args(%arg3 = %0) -> (tensor) { + %4 = affine.for %arg4 = 0 to 64 step 2 iter_args(%arg5 = %arg3) -> (tensor) { + %extracted = tensor.extract %1[%arg2, %arg4] : tensor + %5 = arith.extui %extracted : i8 to i32 + %6 = arith.andi %5, %c15_i32 : i32 + %7 = affine.apply #map(%arg2, %arg4) + %extracted_0 = tensor.extract %1[%arg2, %7] : tensor + %8 = arith.extui %extracted_0 : i8 to i32 + %9 = arith.andi %8, %c15_i32 : i32 + %10 = arith.shli %9, %c4_i32 : i32 + %11 = arith.ori %6, %10 : i32 + %12 = arith.trunci %11 : i32 to i8 + %13 = arith.cmpi slt, %arg4, %c0 : index + %14 = arith.subi %c-1, %arg4 : index + %15 = arith.select %13, %14, %arg4 : index + %16 = arith.divsi %15, %c2 : index + %17 = arith.subi %c-1, %16 : index + %18 = arith.select %13, %17, %16 : index + %inserted = tensor.insert %12 into %arg5[%arg2, %18] : tensor + affine.yield %inserted : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu/orig.mlir new file mode 100644 index 000000000000..abdc6c0f1100 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu/orig.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_to_int4pack_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c4_i32 = arith.constant 4 : i32 + %c15_i32 = arith.constant 15 : i32 + %c0 = arith.constant 0 : index + affine.for %arg2 = 0 to 48 { + affine.for %arg3 = 0 to 64 step 2 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + %1 = arith.extui %0 : i8 to i32 + %2 = arith.andi %1, %c15_i32 : i32 + %3 = affine.load %arg0[%arg2, %arg3 + 1] : memref + %4 = arith.extui %3 : i8 to i32 + %5 = arith.andi %4, %c15_i32 : i32 + %6 = arith.shli %5, %c4_i32 : i32 + %7 = arith.ori %2, %6 : i32 + %8 = arith.trunci %7 : i32 to i8 + %9 = arith.cmpi slt, %arg3, %c0 : index + %10 = arith.subi %c-1, %arg3 : index + %11 = arith.select %9, %10, %arg3 : index + %12 = arith.divsi %11, %c2 : index + %13 = arith.subi %c-1, %12 : index + %14 = arith.select %9, %13, %12 : index + memref.store %8, %arg1[%arg2, %14] : memref + } + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu/raised.mlir new file mode 100644 index 000000000000..240e119758ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu/raised.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_to_int4pack_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c4_i32 = arith.constant 4 : i32 + %c15_i32 = arith.constant 15 : i32 + %c0 = arith.constant 0 : index + affine.for %arg2 = 0 to 48 { + affine.for %arg3 = 0 to 64 step 2 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + %1 = arith.extui %0 : i8 to i32 + %2 = arith.andi %1, %c15_i32 : i32 + %3 = affine.load %arg0[%arg2, %arg3 + 1] : memref + %4 = arith.extui %3 : i8 to i32 + %5 = arith.andi %4, %c15_i32 : i32 + %6 = arith.shli %5, %c4_i32 : i32 + %7 = arith.ori %2, %6 : i32 + %8 = arith.trunci %7 : i32 to i8 + %9 = arith.cmpi slt, %arg3, %c0 : index + %10 = arith.subi %c-1, %arg3 : index + %11 = arith.select %9, %10, %arg3 : index + %12 = arith.divsi %11, %c2 : index + %13 = arith.subi %c-1, %12 : index + %14 = arith.select %9, %13, %12 : index + memref.store %8, %arg1[%arg2, %14] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu_debuf.mlir new file mode 100644 index 000000000000..c8a6a7fb69c0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu_debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0, d1) -> (d1 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_to_int4pack_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c15_i32 = arith.constant 15 : i32 + %c4_i32 = arith.constant 4 : i32 + %c2 = arith.constant 2 : index + %c-1 = arith.constant -1 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = bufferization.to_tensor %arg0 : memref + %2 = affine.for %arg2 = 0 to 48 iter_args(%arg3 = %0) -> (tensor) { + %4 = affine.for %arg4 = 0 to 64 step 2 iter_args(%arg5 = %arg3) -> (tensor) { + %extracted = tensor.extract %1[%arg2, %arg4] : tensor + %5 = arith.extui %extracted : i8 to i32 + %6 = arith.andi %5, %c15_i32 : i32 + %7 = affine.apply #map(%arg2, %arg4) + %extracted_0 = tensor.extract %1[%arg2, %7] : tensor + %8 = arith.extui %extracted_0 : i8 to i32 + %9 = arith.andi %8, %c15_i32 : i32 + %10 = arith.shli %9, %c4_i32 : i32 + %11 = arith.ori %6, %10 : i32 + %12 = arith.trunci %11 : i32 to i8 + %13 = arith.cmpi slt, %arg4, %c0 : index + %14 = arith.subi %c-1, %arg4 : index + %15 = arith.select %13, %14, %arg4 : index + %16 = arith.divsi %15, %c2 : index + %17 = arith.subi %c-1, %16 : index + %18 = arith.select %13, %17, %16 : index + %inserted = tensor.insert %12 into %arg5[%arg2, %18] : tensor + affine.yield %inserted : tensor + } + affine.yield %4 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu_linalg.mlir new file mode 100644 index 000000000000..240e119758ee --- /dev/null +++ b/issues/aten_c_kernels/results/aten_weight_to_int4pack_cpu_linalg.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_weight_to_int4pack_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c-1 = arith.constant -1 : index + %c2 = arith.constant 2 : index + %c4_i32 = arith.constant 4 : i32 + %c15_i32 = arith.constant 15 : i32 + %c0 = arith.constant 0 : index + affine.for %arg2 = 0 to 48 { + affine.for %arg3 = 0 to 64 step 2 { + %0 = affine.load %arg0[%arg2, %arg3] : memref + %1 = arith.extui %0 : i8 to i32 + %2 = arith.andi %1, %c15_i32 : i32 + %3 = affine.load %arg0[%arg2, %arg3 + 1] : memref + %4 = arith.extui %3 : i8 to i32 + %5 = arith.andi %4, %c15_i32 : i32 + %6 = arith.shli %5, %c4_i32 : i32 + %7 = arith.ori %2, %6 : i32 + %8 = arith.trunci %7 : i32 to i8 + %9 = arith.cmpi slt, %arg3, %c0 : index + %10 = arith.subi %c-1, %arg3 : index + %11 = arith.select %9, %10, %arg3 : index + %12 = arith.divsi %11, %c2 : index + %13 = arith.subi %c-1, %12 : index + %14 = arith.select %9, %13, %12 : index + memref.store %8, %arg1[%arg2, %14] : memref + } + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_where_cpu.mlir b/issues/aten_c_kernels/results/aten_where_cpu.mlir new file mode 100644 index 000000000000..ef0243e4de63 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_where_cpu.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_where_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.cmpi ne, %0, %c0_i32 : i32 + %2 = scf.if %1 -> (f32) { + %3 = affine.load %arg1[%arg4] : memref + scf.yield %3 : f32 + } else { + %3 = affine.load %arg2[%arg4] : memref + scf.yield %3 : f32 + } + affine.store %2, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_where_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_where_cpu/debuf.mlir new file mode 100644 index 000000000000..607b273eb612 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_where_cpu/debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_where_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: i32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.cmpi ne, %in, %c0_i32 : i32 + %7 = arith.select %6, %in_0, %in_1 : f32 + linalg.yield %7 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_where_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_where_cpu/matched.mlir new file mode 100644 index 000000000000..607b273eb612 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_where_cpu/matched.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_where_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: i32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.cmpi ne, %in, %c0_i32 : i32 + %7 = arith.select %6, %in_0, %in_1 : f32 + linalg.yield %7 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_where_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_where_cpu/orig.mlir new file mode 100644 index 000000000000..ef0243e4de63 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_where_cpu/orig.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_where_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg4 = 0 to 4096 { + %0 = affine.load %arg0[%arg4] : memref + %1 = arith.cmpi ne, %0, %c0_i32 : i32 + %2 = scf.if %1 -> (f32) { + %3 = affine.load %arg1[%arg4] : memref + scf.yield %3 : f32 + } else { + %3 = affine.load %arg2[%arg4] : memref + scf.yield %3 : f32 + } + affine.store %2, %arg3[%arg4] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_where_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_where_cpu/raised.mlir new file mode 100644 index 000000000000..81ef82500d4f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_where_cpu/raised.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_where_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg2 : memref, memref, memref) outs(%arg3 : memref) { + ^bb0(%in: i32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.cmpi ne, %in, %c0_i32 : i32 + %1 = arith.select %0, %in_0, %in_1 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_where_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_where_cpu_debuf.mlir new file mode 100644 index 000000000000..607b273eb612 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_where_cpu_debuf.mlir @@ -0,0 +1,20 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_where_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1, %2 : tensor, tensor, tensor) outs(%3 : tensor) { + ^bb0(%in: i32, %in_0: f32, %in_1: f32, %out: f32): + %6 = arith.cmpi ne, %in, %c0_i32 : i32 + %7 = arith.select %6, %in_0, %in_1 : f32 + linalg.yield %7 : f32 + } -> tensor + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg3 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_where_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_where_cpu_linalg.mlir new file mode 100644 index 000000000000..81ef82500d4f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_where_cpu_linalg.mlir @@ -0,0 +1,14 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_where_cpu(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1, %arg2 : memref, memref, memref) outs(%arg3 : memref) { + ^bb0(%in: i32, %in_0: f32, %in_1: f32, %out: f32): + %0 = arith.cmpi ne, %in, %c0_i32 : i32 + %1 = arith.select %0, %in_0, %in_1 : f32 + linalg.yield %1 : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_xlog1py.mlir b/issues/aten_c_kernels/results/aten_xlog1py.mlir new file mode 100644 index 000000000000..ebb3aed2381e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xlog1py.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xlog1py(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.cmpf une, %0, %0 : f32 + %2 = scf.if %1 -> (f32) { + %3 = affine.load %arg1[%arg3] : memref + scf.yield %3 : f32 + } else { + %3 = affine.load %arg0[%arg3] : memref + %4 = arith.cmpf oeq, %3, %cst : f32 + %5 = scf.if %4 -> (f32) { + scf.yield %cst : f32 + } else { + %6 = affine.load %arg0[%arg3] : memref + %7 = affine.load %arg1[%arg3] : memref + %8 = func.call @log1pf(%7) : (f32) -> f32 + %9 = arith.mulf %6, %8 : f32 + scf.yield %9 : f32 + } + scf.yield %5 : f32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_xlog1py/debuf.mlir b/issues/aten_c_kernels/results/aten_xlog1py/debuf.mlir new file mode 100644 index 000000000000..f80940abbdd5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xlog1py/debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xlog1py(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.cmpf une, %4, %4 : f32 + %6 = scf.if %5 -> (f32) { + %7 = memref.load %arg1[%3] : memref + scf.yield %7 : f32 + } else { + %7 = memref.load %arg0[%3] : memref + %8 = arith.cmpf oeq, %7, %cst : f32 + %9 = scf.if %8 -> (f32) { + scf.yield %cst : f32 + } else { + %10 = memref.load %arg0[%3] : memref + %11 = memref.load %arg1[%3] : memref + %12 = math.log1p %11 : f32 + %13 = arith.mulf %10, %12 : f32 + scf.yield %13 : f32 + } + scf.yield %9 : f32 + } + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_xlog1py/matched.mlir b/issues/aten_c_kernels/results/aten_xlog1py/matched.mlir new file mode 100644 index 000000000000..f80940abbdd5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xlog1py/matched.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xlog1py(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.cmpf une, %4, %4 : f32 + %6 = scf.if %5 -> (f32) { + %7 = memref.load %arg1[%3] : memref + scf.yield %7 : f32 + } else { + %7 = memref.load %arg0[%3] : memref + %8 = arith.cmpf oeq, %7, %cst : f32 + %9 = scf.if %8 -> (f32) { + scf.yield %cst : f32 + } else { + %10 = memref.load %arg0[%3] : memref + %11 = memref.load %arg1[%3] : memref + %12 = math.log1p %11 : f32 + %13 = arith.mulf %10, %12 : f32 + scf.yield %13 : f32 + } + scf.yield %9 : f32 + } + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_xlog1py/orig.mlir b/issues/aten_c_kernels/results/aten_xlog1py/orig.mlir new file mode 100644 index 000000000000..ebb3aed2381e --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xlog1py/orig.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xlog1py(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.cmpf une, %0, %0 : f32 + %2 = scf.if %1 -> (f32) { + %3 = affine.load %arg1[%arg3] : memref + scf.yield %3 : f32 + } else { + %3 = affine.load %arg0[%arg3] : memref + %4 = arith.cmpf oeq, %3, %cst : f32 + %5 = scf.if %4 -> (f32) { + scf.yield %cst : f32 + } else { + %6 = affine.load %arg0[%arg3] : memref + %7 = affine.load %arg1[%arg3] : memref + %8 = func.call @log1pf(%7) : (f32) -> f32 + %9 = arith.mulf %6, %8 : f32 + scf.yield %9 : f32 + } + scf.yield %5 : f32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_xlog1py/raised.mlir b/issues/aten_c_kernels/results/aten_xlog1py/raised.mlir new file mode 100644 index 000000000000..4fe2191e838d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xlog1py/raised.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xlog1py(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg1[%0] : memref + %2 = arith.cmpf une, %1, %1 : f32 + %3 = scf.if %2 -> (f32) { + %4 = memref.load %arg1[%0] : memref + scf.yield %4 : f32 + } else { + %4 = memref.load %arg0[%0] : memref + %5 = arith.cmpf oeq, %4, %cst : f32 + %6 = scf.if %5 -> (f32) { + scf.yield %cst : f32 + } else { + %7 = memref.load %arg0[%0] : memref + %8 = memref.load %arg1[%0] : memref + %9 = math.log1p %8 : f32 + %10 = arith.mulf %7, %9 : f32 + scf.yield %10 : f32 + } + scf.yield %6 : f32 + } + linalg.yield %3 : f32 + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_xlog1py_debuf.mlir b/issues/aten_c_kernels/results/aten_xlog1py_debuf.mlir new file mode 100644 index 000000000000..f80940abbdd5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xlog1py_debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xlog1py(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.cmpf une, %4, %4 : f32 + %6 = scf.if %5 -> (f32) { + %7 = memref.load %arg1[%3] : memref + scf.yield %7 : f32 + } else { + %7 = memref.load %arg0[%3] : memref + %8 = arith.cmpf oeq, %7, %cst : f32 + %9 = scf.if %8 -> (f32) { + scf.yield %cst : f32 + } else { + %10 = memref.load %arg0[%3] : memref + %11 = memref.load %arg1[%3] : memref + %12 = math.log1p %11 : f32 + %13 = arith.mulf %10, %12 : f32 + scf.yield %13 : f32 + } + scf.yield %9 : f32 + } + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_xlog1py_linalg.mlir b/issues/aten_c_kernels/results/aten_xlog1py_linalg.mlir new file mode 100644 index 000000000000..4fe2191e838d --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xlog1py_linalg.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xlog1py(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg1[%0] : memref + %2 = arith.cmpf une, %1, %1 : f32 + %3 = scf.if %2 -> (f32) { + %4 = memref.load %arg1[%0] : memref + scf.yield %4 : f32 + } else { + %4 = memref.load %arg0[%0] : memref + %5 = arith.cmpf oeq, %4, %cst : f32 + %6 = scf.if %5 -> (f32) { + scf.yield %cst : f32 + } else { + %7 = memref.load %arg0[%0] : memref + %8 = memref.load %arg1[%0] : memref + %9 = math.log1p %8 : f32 + %10 = arith.mulf %7, %9 : f32 + scf.yield %10 : f32 + } + scf.yield %6 : f32 + } + linalg.yield %3 : f32 + } + return + } + func.func private @log1pf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_xlogy.mlir b/issues/aten_c_kernels/results/aten_xlogy.mlir new file mode 100644 index 000000000000..2ced0c31e3da --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xlogy.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xlogy(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.cmpf une, %0, %0 : f32 + %2 = scf.if %1 -> (f32) { + %3 = affine.load %arg1[%arg3] : memref + scf.yield %3 : f32 + } else { + %3 = affine.load %arg0[%arg3] : memref + %4 = arith.cmpf oeq, %3, %cst : f32 + %5 = scf.if %4 -> (f32) { + scf.yield %cst : f32 + } else { + %6 = affine.load %arg0[%arg3] : memref + %7 = affine.load %arg1[%arg3] : memref + %8 = func.call @logf(%7) : (f32) -> f32 + %9 = arith.mulf %6, %8 : f32 + scf.yield %9 : f32 + } + scf.yield %5 : f32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_xlogy/debuf.mlir b/issues/aten_c_kernels/results/aten_xlogy/debuf.mlir new file mode 100644 index 000000000000..8ba63bcf0f8c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xlogy/debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xlogy(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.cmpf une, %4, %4 : f32 + %6 = scf.if %5 -> (f32) { + %7 = memref.load %arg1[%3] : memref + scf.yield %7 : f32 + } else { + %7 = memref.load %arg0[%3] : memref + %8 = arith.cmpf oeq, %7, %cst : f32 + %9 = scf.if %8 -> (f32) { + scf.yield %cst : f32 + } else { + %10 = memref.load %arg0[%3] : memref + %11 = memref.load %arg1[%3] : memref + %12 = math.log %11 : f32 + %13 = arith.mulf %10, %12 : f32 + scf.yield %13 : f32 + } + scf.yield %9 : f32 + } + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_xlogy/matched.mlir b/issues/aten_c_kernels/results/aten_xlogy/matched.mlir new file mode 100644 index 000000000000..8ba63bcf0f8c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xlogy/matched.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xlogy(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.cmpf une, %4, %4 : f32 + %6 = scf.if %5 -> (f32) { + %7 = memref.load %arg1[%3] : memref + scf.yield %7 : f32 + } else { + %7 = memref.load %arg0[%3] : memref + %8 = arith.cmpf oeq, %7, %cst : f32 + %9 = scf.if %8 -> (f32) { + scf.yield %cst : f32 + } else { + %10 = memref.load %arg0[%3] : memref + %11 = memref.load %arg1[%3] : memref + %12 = math.log %11 : f32 + %13 = arith.mulf %10, %12 : f32 + scf.yield %13 : f32 + } + scf.yield %9 : f32 + } + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_xlogy/orig.mlir b/issues/aten_c_kernels/results/aten_xlogy/orig.mlir new file mode 100644 index 000000000000..2ced0c31e3da --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xlogy/orig.mlir @@ -0,0 +1,29 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xlogy(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg1[%arg3] : memref + %1 = arith.cmpf une, %0, %0 : f32 + %2 = scf.if %1 -> (f32) { + %3 = affine.load %arg1[%arg3] : memref + scf.yield %3 : f32 + } else { + %3 = affine.load %arg0[%arg3] : memref + %4 = arith.cmpf oeq, %3, %cst : f32 + %5 = scf.if %4 -> (f32) { + scf.yield %cst : f32 + } else { + %6 = affine.load %arg0[%arg3] : memref + %7 = affine.load %arg1[%arg3] : memref + %8 = func.call @logf(%7) : (f32) -> f32 + %9 = arith.mulf %6, %8 : f32 + scf.yield %9 : f32 + } + scf.yield %5 : f32 + } + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_xlogy/raised.mlir b/issues/aten_c_kernels/results/aten_xlogy/raised.mlir new file mode 100644 index 000000000000..1f09c93fcea0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xlogy/raised.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xlogy(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg1[%0] : memref + %2 = arith.cmpf une, %1, %1 : f32 + %3 = scf.if %2 -> (f32) { + %4 = memref.load %arg1[%0] : memref + scf.yield %4 : f32 + } else { + %4 = memref.load %arg0[%0] : memref + %5 = arith.cmpf oeq, %4, %cst : f32 + %6 = scf.if %5 -> (f32) { + scf.yield %cst : f32 + } else { + %7 = memref.load %arg0[%0] : memref + %8 = memref.load %arg1[%0] : memref + %9 = math.log %8 : f32 + %10 = arith.mulf %7, %9 : f32 + scf.yield %10 : f32 + } + scf.yield %6 : f32 + } + linalg.yield %3 : f32 + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_xlogy_debuf.mlir b/issues/aten_c_kernels/results/aten_xlogy_debuf.mlir new file mode 100644 index 000000000000..8ba63bcf0f8c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xlogy_debuf.mlir @@ -0,0 +1,36 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xlogy(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg2 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + %3 = linalg.index 0 : index + %4 = memref.load %arg1[%3] : memref + %5 = arith.cmpf une, %4, %4 : f32 + %6 = scf.if %5 -> (f32) { + %7 = memref.load %arg1[%3] : memref + scf.yield %7 : f32 + } else { + %7 = memref.load %arg0[%3] : memref + %8 = arith.cmpf oeq, %7, %cst : f32 + %9 = scf.if %8 -> (f32) { + scf.yield %cst : f32 + } else { + %10 = memref.load %arg0[%3] : memref + %11 = memref.load %arg1[%3] : memref + %12 = math.log %11 : f32 + %13 = arith.mulf %10, %12 : f32 + scf.yield %13 : f32 + } + scf.yield %9 : f32 + } + linalg.yield %6 : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg2 : memref to memref + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_xlogy_linalg.mlir b/issues/aten_c_kernels/results/aten_xlogy_linalg.mlir new file mode 100644 index 000000000000..1f09c93fcea0 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xlogy_linalg.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xlogy(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg2 : memref) { + ^bb0(%out: f32): + %0 = linalg.index 0 : index + %1 = memref.load %arg1[%0] : memref + %2 = arith.cmpf une, %1, %1 : f32 + %3 = scf.if %2 -> (f32) { + %4 = memref.load %arg1[%0] : memref + scf.yield %4 : f32 + } else { + %4 = memref.load %arg0[%0] : memref + %5 = arith.cmpf oeq, %4, %cst : f32 + %6 = scf.if %5 -> (f32) { + scf.yield %cst : f32 + } else { + %7 = memref.load %arg0[%0] : memref + %8 = memref.load %arg1[%0] : memref + %9 = math.log %8 : f32 + %10 = arith.mulf %7, %9 : f32 + scf.yield %10 : f32 + } + scf.yield %6 : f32 + } + linalg.yield %3 : f32 + } + return + } + func.func private @logf(f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_xor_sum_cpu.mlir b/issues/aten_c_kernels/results/aten_xor_sum_cpu.mlir new file mode 100644 index 000000000000..f84185afad17 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xor_sum_cpu.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xor_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 32 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %c0_i32) -> (i32) { + %1 = affine.load %arg0[%arg2, %arg3] : memref + %2 = arith.xori %arg4, %1 : i32 + affine.yield %2 : i32 + } + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_xor_sum_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_xor_sum_cpu/debuf.mlir new file mode 100644 index 000000000000..0712751533d2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xor_sum_cpu/debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xor_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.xori %out, %in : i32 + linalg.yield %5 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_xor_sum_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_xor_sum_cpu/matched.mlir new file mode 100644 index 000000000000..bd1651349d10 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xor_sum_cpu/matched.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xor_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = kernel.launch @memset_zero_1D(%1) : (tensor) -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.xori %out, %in : i32 + linalg.yield %5 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_xor_sum_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_xor_sum_cpu/orig.mlir new file mode 100644 index 000000000000..f84185afad17 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xor_sum_cpu/orig.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xor_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + affine.for %arg2 = 0 to 32 { + %0 = affine.for %arg3 = 0 to 64 iter_args(%arg4 = %c0_i32) -> (i32) { + %1 = affine.load %arg0[%arg2, %arg3] : memref + %2 = arith.xori %arg4, %1 : i32 + affine.yield %2 : i32 + } + affine.store %0, %arg1[%arg2] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_xor_sum_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_xor_sum_cpu/raised.mlir new file mode 100644 index 000000000000..d11ac5b826d5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xor_sum_cpu/raised.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xor_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: i32, %out: i32): + %0 = arith.xori %out, %in : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_xor_sum_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_xor_sum_cpu_debuf.mlir new file mode 100644 index 000000000000..0712751533d2 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xor_sum_cpu_debuf.mlir @@ -0,0 +1,28 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xor_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %c64 = arith.constant 64 : index + %c32 = arith.constant 32 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%1 : tensor) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } -> tensor + %extracted_slice = tensor.extract_slice %0[0, 0] [%c32, %c64] [1, 1] : tensor to tensor + %extracted_slice_0 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %3 = linalg.generic {doc = "", indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%extracted_slice : tensor) outs(%extracted_slice_0 : tensor) { + ^bb0(%in: i32, %out: i32): + %5 = arith.xori %out, %in : i32 + linalg.yield %5 : i32 + } -> tensor + %inserted_slice = tensor.insert_slice %3 into %2[0] [%c32] [1] : tensor into tensor + %4 = bufferization.to_memref %inserted_slice : memref + memref.copy %4, %arg1 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_xor_sum_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_xor_sum_cpu_linalg.mlir new file mode 100644 index 000000000000..d11ac5b826d5 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_xor_sum_cpu_linalg.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_xor_sum_cpu(%arg0: memref, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c32 = arith.constant 32 : index + %c64 = arith.constant 64 : index + %c0_i32 = arith.constant 0 : i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg1 : memref) { + ^bb0(%out: i32): + linalg.yield %c0_i32 : i32 + } + %subview = memref.subview %arg0[0, 0] [%c32, %c64] [1, 1] : memref to memref> + %subview_0 = memref.subview %arg1[0] [%c32] [1] : memref to memref> + linalg.generic {indexing_maps = [#map1, #map2], iterator_types = ["parallel", "reduction"]} ins(%subview : memref>) outs(%subview_0 : memref>) { + ^bb0(%in: i32, %out: i32): + %0 = arith.xori %out, %in : i32 + linalg.yield %0 : i32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_zeros_cpu.mlir b/issues/aten_c_kernels/results/aten_zeros_cpu.mlir new file mode 100644 index 000000000000..ea7180e909d8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_zeros_cpu.mlir @@ -0,0 +1,9 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_zeros_cpu(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg1 = 0 to 4096 { + affine.store %cst, %arg0[%arg1] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_zeros_cpu/debuf.mlir b/issues/aten_c_kernels/results/aten_zeros_cpu/debuf.mlir new file mode 100644 index 000000000000..7c899738882f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_zeros_cpu/debuf.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_zeros_cpu(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_zeros_cpu/matched.mlir b/issues/aten_c_kernels/results/aten_zeros_cpu/matched.mlir new file mode 100644 index 000000000000..b9b689641f4c --- /dev/null +++ b/issues/aten_c_kernels/results/aten_zeros_cpu/matched.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_zeros_cpu(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = kernel.launch @memset_zero_1D_f32(%0) : (tensor) -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_zeros_cpu/orig.mlir b/issues/aten_c_kernels/results/aten_zeros_cpu/orig.mlir new file mode 100644 index 000000000000..ea7180e909d8 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_zeros_cpu/orig.mlir @@ -0,0 +1,9 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_zeros_cpu(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %arg1 = 0 to 4096 { + affine.store %cst, %arg0[%arg1] : memref + } + return + } +} diff --git a/issues/aten_c_kernels/results/aten_zeros_cpu/raised.mlir b/issues/aten_c_kernels/results/aten_zeros_cpu/raised.mlir new file mode 100644 index 000000000000..47210d9edbc4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_zeros_cpu/raised.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_zeros_cpu(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg0 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_zeros_cpu_debuf.mlir b/issues/aten_c_kernels/results/aten_zeros_cpu_debuf.mlir new file mode 100644 index 000000000000..7c899738882f --- /dev/null +++ b/issues/aten_c_kernels/results/aten_zeros_cpu_debuf.mlir @@ -0,0 +1,15 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_zeros_cpu(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %0 = bufferization.to_tensor %arg0 : memref + %1 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%0 : tensor) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } -> tensor + %2 = bufferization.to_memref %1 : memref + memref.copy %2, %arg0 : memref to memref + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_zeros_cpu_linalg.mlir b/issues/aten_c_kernels/results/aten_zeros_cpu_linalg.mlir new file mode 100644 index 000000000000..47210d9edbc4 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_zeros_cpu_linalg.mlir @@ -0,0 +1,12 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_zeros_cpu(%arg0: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%arg0 : memref) { + ^bb0(%out: f32): + linalg.yield %cst : f32 + } + return + } +} + diff --git a/issues/aten_c_kernels/results/aten_zeta.mlir b/issues/aten_c_kernels/results/aten_zeta.mlir new file mode 100644 index 000000000000..ff04f6d38507 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_zeta.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_zeta(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_zetaf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_zetaf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_zeta/debuf.mlir b/issues/aten_c_kernels/results/aten_zeta/debuf.mlir new file mode 100644 index 000000000000..7cd754959cad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_zeta/debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_zeta(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_zetaf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_zetaf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_zeta/matched.mlir b/issues/aten_c_kernels/results/aten_zeta/matched.mlir new file mode 100644 index 000000000000..7cd754959cad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_zeta/matched.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_zeta(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_zetaf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_zetaf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_zeta/orig.mlir b/issues/aten_c_kernels/results/aten_zeta/orig.mlir new file mode 100644 index 000000000000..ff04f6d38507 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_zeta/orig.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_zeta(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg3 = 0 to 4096 { + %0 = affine.load %arg0[%arg3] : memref + %1 = affine.load %arg1[%arg3] : memref + %2 = func.call @calc_zetaf(%0, %1) : (f32, f32) -> f32 + affine.store %2, %arg2[%arg3] : memref + } + return + } + func.func private @calc_zetaf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} diff --git a/issues/aten_c_kernels/results/aten_zeta/raised.mlir b/issues/aten_c_kernels/results/aten_zeta/raised.mlir new file mode 100644 index 000000000000..932caa5e9478 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_zeta/raised.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_zeta(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_zetaf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_zetaf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_zeta_debuf.mlir b/issues/aten_c_kernels/results/aten_zeta_debuf.mlir new file mode 100644 index 000000000000..7cd754959cad --- /dev/null +++ b/issues/aten_c_kernels/results/aten_zeta_debuf.mlir @@ -0,0 +1,18 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_zeta(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%0, %1 : tensor, tensor) outs(%2 : tensor) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %5 = func.call @calc_zetaf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %5 : f32 + } -> tensor + %4 = bufferization.to_memref %3 : memref + memref.copy %4, %arg2 : memref to memref + return + } + func.func private @calc_zetaf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/aten_zeta_linalg.mlir b/issues/aten_c_kernels/results/aten_zeta_linalg.mlir new file mode 100644 index 000000000000..932caa5e9478 --- /dev/null +++ b/issues/aten_c_kernels/results/aten_zeta_linalg.mlir @@ -0,0 +1,13 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @aten_zeta(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%arg0, %arg1 : memref, memref) outs(%arg2 : memref) { + ^bb0(%in: f32, %in_0: f32, %out: f32): + %0 = func.call @calc_zetaf(%in, %in_0) : (f32, f32) -> f32 + linalg.yield %0 : f32 + } + return + } + func.func private @calc_zetaf(f32, f32) -> f32 attributes {llvm.linkage = #llvm.linkage, polygeist.pure} +} + diff --git a/issues/aten_c_kernels/results/summary.tsv b/issues/aten_c_kernels/results/summary.tsv new file mode 100644 index 000000000000..78841bd23911 --- /dev/null +++ b/issues/aten_c_kernels/results/summary.tsv @@ -0,0 +1,599 @@ +kernel status linalg_ops residual_loops kernel_launches matched_symbols +aten_abs pass 1 0 0 - +aten_acos pass 1 0 0 - +aten_acosh pass 1 0 0 - +aten_adaptive_avg_pool2d pass 2 0 0 - +aten_adaptive_avg_pool2d_backward_cpu pass 1 5 1 memset_zero_1D_f32 +aten_adaptive_avg_pool2d_cpu pass 1 5 0 - +aten_adaptive_avg_pool3d pass 2 0 0 - +aten_adaptive_avg_pool3d_backward_cpu pass 1 7 1 memset_zero_1D_f32 +aten_adaptive_avg_pool3d_cpu pass 0 7 0 - +aten_adaptive_max_pool1d_cpu pass 0 3 0 - +aten_adaptive_max_pool2d_backward_cpu pass 1 3 1 memset_zero_1D_f32 +aten_adaptive_max_pool2d_cpu pass 0 5 0 - +aten_adaptive_max_pool3d_backward_cpu pass 1 4 1 memset_zero_1D_f32 +aten_adaptive_max_pool3d_cpu pass 0 7 0 - +aten_adaptive_max_pool3d_legacy_backward_cpu pass 0 5 0 - +aten_adaptive_max_pool3d_legacy_cpu pass 0 7 0 - +aten_add pass 1 0 1 cudnnAddTensor_batched +aten_add_clamp pass 1 0 0 - +aten_addcdiv pass 1 0 0 - +aten_addcmul pass 1 0 0 - +aten_addmm pass 2 0 1 cublasDgemm +aten_addr_elementwise pass 1 0 0 - +aten_airy_ai pass 1 0 0 - +aten_allany_dims_cpu pass 2 0 0 - +aten_aminmax_allreduce_cpu pass 1 0 0 - +aten_aminmax_cpu pass 2 0 0 - +aten_amp_update_scale_cpu pass 0 0 0 - +aten_and_reduce_cpu pass 2 0 0 - +aten_angle_complex_scalarized pass 1 0 0 - +aten_angle_real pass 1 0 0 - +aten_arange_cpu pass 1 0 0 - +aten_argmax_cpu pass 4 0 2 cudaCopy1D_f32_tensor,memset_zero_1D +aten_argmin_cpu pass 4 0 2 cudaCopy1D_f32_tensor,memset_zero_1D +aten_as_complex_cpu pass 2 0 2 cudaCopy1D_f32_tensor +aten_asin pass 1 0 0 - +aten_asinh pass 1 0 0 - +aten_atan pass 1 0 0 - +aten_atan2 pass 1 0 0 - +aten_atanh pass 1 0 0 - +aten_avg_pool2d pass 2 0 0 - +aten_avg_pool2d_backward_cpu pass 2 0 1 memset_zero_1D_f32 +aten_avg_pool2d_cpu pass 4 4 0 - +aten_avg_pool3d pass 2 0 0 - +aten_avg_pool3d_backward_cpu pass 2 0 1 memset_zero_1D_f32 +aten_avg_pool3d_cpu pass 4 6 0 - +aten_batch_norm pass 1 0 1 cudnnBatchNormalizationForwardInference +aten_batch_norm_backward_cpu pass 2 2 0 - +aten_batch_norm_backward_template_cpu pass 4 3 0 - +aten_batch_norm_collect_stats_cpu pass 2 1 0 - +aten_batch_norm_cpu_entry pass 1 0 0 - +aten_batch_norm_stats_cpu pass 2 1 0 - +aten_batch_norm_transform_cpu pass 1 0 0 - +aten_bernoulli_scalar_cpu pass 1 0 0 - +aten_bernoulli_tensor_cpu pass 1 0 0 - +aten_bessel_j0 pass 1 0 0 - +aten_bessel_j1 pass 1 0 0 - +aten_bessel_y0 pass 1 0 0 - +aten_bessel_y1 pass 1 0 0 - +aten_bf16_dot_cpu pass 1 0 1 cublasSdot +aten_bf16_gemv_trans_cpu pass 2 0 2 cublasSgemv_T,memset_zero_1D_f32 +aten_bilinear_cpu pass 2 0 1 memset_zero_2D_f32 +aten_binary_cross_entropy pass 1 0 0 - +aten_binary_search_strided_rightmost_cpu pass 0 2 0 - +aten_bincount_cpu pass 1 1 1 memset_zero_1D_f32 +aten_binomial_transform_cpu pass 0 2 0 - +aten_bitwise_and_i32 pass 1 0 0 - +aten_bitwise_not_i32 pass 1 0 0 - +aten_bitwise_or_i32 pass 1 0 0 - +aten_bitwise_xor_i32 pass 1 0 0 - +aten_blas_axpy_cpu pass 1 0 0 - +aten_blas_copy_cpu pass 1 0 1 cudaCopy1D_f32_tensor +aten_blas_dot_naive_cpu pass 1 0 1 cublasSdot +aten_blas_gemv_generic_cpu pass 2 0 2 cublasSgemv,memset_zero_1D_f32 +aten_blas_scale_cpu pass 1 0 0 - +aten_blas_sum_cpu pass 1 0 0 - +aten_block_diag_cpu pass 2 0 1 memset_zero_2D_f32 +aten_bmm pass 2 0 0 - +aten_cartesian_prod_cpu pass 2 0 0 - +aten_cat_serial_cpu pass 2 0 2 cudaCopy2D_f32_tensor +aten_cat_sparse_cpu pass 2 0 1 cudaCopy2D_f32_tensor +aten_cauchy_cpu pass 1 0 0 - +aten_cdist_backward_cpu pass 3 2 1 memset_zero_2D_f32 +aten_cdist_cpu pass 3 1 0 - +aten_ceil pass 1 0 0 - +aten_channel_shuffle pass 1 0 0 - +aten_channel_shuffle_cpu pass 1 0 0 - +aten_chebyshev_polynomial_t pass 1 0 0 - +aten_chebyshev_polynomial_u pass 1 0 0 - +aten_chebyshev_polynomial_v pass 1 0 0 - +aten_chebyshev_polynomial_w pass 1 0 0 - +aten_circular_pad_cpu pass 1 0 0 - +aten_clamp pass 1 0 0 - +aten_clamp_cpu pass 1 0 0 - +aten_clamp_max_scalar_cpu pass 1 0 0 - +aten_clamp_min_scalar_cpu pass 1 0 0 - +aten_clamp_scalar_cpu pass 1 0 0 - +aten_coalesce_sparse_cpu pass 0 1 0 - +aten_col2im_cpu pass 1 1 0 - +aten_combinations_cpu pass 0 2 0 - +aten_complex_scalarized pass 2 0 2 cudaCopy1D_f32_tensor +aten_compressed_block_convert_cpu pass 0 2 0 - +aten_conj_complex_scalarized pass 2 0 1 cudaCopy1D_f32_tensor +aten_constant_pad_nd_cpu pass 2 0 1 cudaCopy1D_f32_tensor +aten_conv1d pass 2 0 0 - +aten_conv2d pass 2 0 1 cudnnConvolutionFwd_batched +aten_conv2d_columns_cpu pass 1 0 0 - +aten_conv3d pass 2 0 1 cudnnConvolution3D_f32_bias +aten_conv3d_columns_cpu pass 1 0 0 - +aten_conv_tbc_backward_cpu pass 1 1 0 - +aten_conv_tbc_cpu pass 2 0 0 - +aten_conv_transpose2d pass 2 0 0 - +aten_conv_transpose3d_backward_cpu pass 2 0 1 cudnnConvolution3D_f32 +aten_conv_transpose3d_cpu pass 1 1 0 - +aten_conv_transpose3d_grad_weight_cpu pass 1 1 0 - +aten_convert_coo_to_csr_cpu pass 0 2 0 - +aten_convert_csr_to_coo_cpu pass 0 2 0 - +aten_copy_cpu pass 1 0 1 cudaCopy1D_f32_tensor +aten_copy_tensor_array_cpu pass 1 0 1 cudaCopy2D_f32_tensor +aten_copysign pass 1 0 0 - +aten_cos pass 1 0 0 - +aten_cosh pass 1 0 0 - +aten_count_nonzero_cpu pass 1 0 0 - +aten_count_nonzero_impl_cpu pass 2 0 1 memset_zero_1D +aten_cpu_blas_gemm_batched_cpu pass 2 0 0 - +aten_cpu_blas_gemm_cpu pass 2 0 0 - +aten_cpu_blas_gemm_strided_batched_cpu pass 2 0 0 - +aten_cross pass 3 0 0 - +aten_cross_cpu_backend pass 3 0 0 - +aten_ctc_loss_backward_cpu pass 2 5 1 memset_zero_2D_f32 +aten_ctc_loss_cpu pass 3 4 0 - +aten_cummax_cummin_cpu pass 3 0 2 cudaCopy1D_f32_tensor,memset_zero_1D +aten_cumprod_backward_cpu pass 2 2 1 memset_zero_1D_f32 +aten_cumprod_cpu pass 2 0 0 - +aten_cumsum pass 1 0 0 - +aten_dense_sparse_add_cpu pass 1 1 1 cudaCopy2D_f32_tensor +aten_depthwise_conv3x3_cpu pass 2 0 0 - +aten_diff_cpu pass 1 0 0 - +aten_digamma pass 1 0 0 - +aten_dilated_convolution_cpu pass 2 0 0 - +aten_dirichlet_grad_cpu pass 1 0 0 - +aten_dirichlet_transform_cpu pass 2 1 0 - +aten_div pass 1 0 0 - +aten_div_floor pass 1 0 0 - +aten_div_trunc pass 1 0 0 - +aten_dot pass 1 0 1 cublasDdot +aten_dropout_feature_noise_cpu pass 1 0 0 - +aten_dyn_quant_matmul_4bit_cpu pass 2 1 1 memset_zero_1D_f32 +aten_dyn_quant_pack_4bit_weight_cpu pass 1 2 0 - +aten_eig_complex_vectors_cpu pass 0 2 0 - +aten_elu pass 1 0 0 - +aten_elu_backward pass 1 0 0 - +aten_embedding pass 1 0 0 - +aten_embedding_bag_backward_max_cpu pass 1 2 1 memset_zero_1D_f32 +aten_embedding_bag_backward_sum_cpu pass 1 3 1 memset_zero_1D_f32 +aten_embedding_bag_counts_cpu pass 1 1 1 memset_zero_1D +aten_embedding_bag_counts_uniq_cpu pass 2 0 1 memset_zero_1D +aten_embedding_bag_max_cpu pass 0 5 0 - +aten_embedding_bag_per_sample_backward_cpu pass 2 1 1 memset_zero_1D_f32 +aten_entr pass 1 0 0 - +aten_eq pass 1 0 0 - +aten_equal_cpu pass 1 0 0 - +aten_erf pass 1 0 0 - +aten_erfc pass 1 0 0 - +aten_erfcx pass 1 0 0 - +aten_erfinv pass 1 0 0 - +aten_exp pass 1 0 0 - +aten_exp2 pass 1 0 0 - +aten_expm1 pass 1 0 0 - +aten_exponential_cpu pass 1 0 0 - +aten_eye_cpu pass 1 0 0 - +aten_fast_cat_dim0_cpu pass 1 0 1 cudaCopy2D_f32_tensor +aten_fft_conjugate_symmetry_cpu pass 2 0 0 - +aten_fftshift_cpu pass 1 0 0 - +aten_fill pass 1 0 0 - +aten_fill_diagonal_cpu pass 1 0 0 - +aten_flash_attention_backward_cpu pass 5 7 0 - +aten_flash_attention_cpu pass 4 3 2 cublasSdot,memset_zero_1D_f32 +aten_flatten_indices_launch_cpu pass 2 0 1 memset_zero_1D +aten_flatten_nd_linear_cpu pass 2 0 1 cublasSgemm_strided_batched_broadcast_rhs +aten_flip_cpu pass 1 0 0 - +aten_flip_tensor_transform_cpu pass 1 0 0 - +aten_floor pass 1 0 0 - +aten_fmax pass 1 0 0 - +aten_fmin pass 1 0 0 - +aten_fmod pass 1 0 0 - +aten_fp16_dot_cpu pass 1 0 1 cublasSdot +aten_fp16_gemv_f16arith_cpu pass 2 0 2 cublasSgemv,memset_zero_1D_f32 +aten_fp16_gemv_f32arith_cpu pass 2 0 2 cublasSgemv,memset_zero_1D_f32 +aten_fp16_gemv_notrans_cpu pass 2 0 2 cublasSgemv,memset_zero_1D_f32 +aten_fp16_gemv_trans_cpu pass 2 0 2 cublasSgemv_T,memset_zero_1D_f32 +aten_frac pass 1 0 0 - +aten_fractional_max_pool2d_backward_cpu pass 0 5 0 - +aten_fractional_max_pool2d_cpu pass 4 6 1 cudaCopy1D_f32_tensor +aten_fractional_max_pool3d_backward_cpu pass 0 5 0 - +aten_fractional_max_pool3d_cpu pass 4 7 1 cudaCopy1D_f32_tensor +aten_fused_adagrad_cpu pass 1 0 0 - +aten_fused_adam_cpu pass 0 1 0 - +aten_fused_sgd_cpu pass 0 1 0 - +aten_gamma_transform_cpu pass 1 0 0 - +aten_gather_cpu pass 1 0 0 - +aten_gather_expanded_index_cpu pass 1 0 0 - +aten_gcd_i32 pass 1 1 0 - +aten_ge pass 1 0 0 - +aten_gelu pass 1 0 1 gelu_tanh_f32_tensor +aten_gelu_backward_cpu_exact pass 1 0 0 - +aten_gelu_backward_cpu_tanh pass 1 0 0 - +aten_gelu_cpu_exact pass 1 0 0 - +aten_gelu_cpu_tanh pass 1 0 1 gelu_tanh_f32_tensor +aten_gemm_notrans_cpu pass 1 0 0 - +aten_gemm_transa_cpu pass 1 0 0 - +aten_gemm_transab_cpu pass 1 0 0 - +aten_gemm_transb_cpu pass 1 0 0 - +aten_geometric_cpu pass 1 0 0 - +aten_glu pass 1 0 0 - +aten_glu_backward pass 1 0 0 - +aten_glu_jvp pass 1 0 0 - +aten_gradient_cpu pass 1 0 0 - +aten_gradient_float_cpu pass 1 0 0 - +aten_grid_sampler_2d_backward_cpu pass 4 4 2 memset_zero_1D_f32 +aten_grid_sampler_2d_cpu pass 1 0 0 - +aten_grid_sampler_2d_fallback_cpu pass 1 0 0 - +aten_grid_sampler_2d_quantized_cpu pass 1 0 0 - +aten_grid_sampler_3d_backward_cpu pass 0 8 0 - +aten_grid_sampler_3d_cpu pass 2 2 1 memset_zero_2D_f32 +aten_group_norm_backward_cpu pass 4 3 0 - +aten_group_norm_cpu pass 3 2 0 - +aten_gt pass 1 0 0 - +aten_hardshrink pass 1 0 0 - +aten_hardsigmoid pass 1 0 0 - +aten_hardsigmoid_backward pass 1 0 0 - +aten_hardswish pass 1 0 0 - +aten_hardswish_backward pass 1 0 0 - +aten_hardtanh pass 1 0 0 - +aten_hardtanh_backward pass 1 0 0 - +aten_heaviside pass 1 0 0 - +aten_hermite_polynomial_h pass 1 0 0 - +aten_hermite_polynomial_he pass 1 0 0 - +aten_histogram_select_outer_bin_edges_cpu pass 1 0 0 - +aten_histogramdd_cpu pass 1 1 1 memset_zero_2D_f32 +aten_histogramdd_linear_cpu pass 1 1 1 memset_zero_1D_f32 +aten_host_softmax_backward_cpu pass 2 1 1 cublasSdot +aten_host_softmax_cpu pass 3 1 1 cudnnSoftmaxForwardOut_tensor +aten_hspmm_cpu pass 1 2 1 memset_zero_2D_f32 +aten_huber_backward pass 1 0 0 - +aten_huber_elementwise pass 1 0 0 - +aten_hypot pass 1 0 0 - +aten_i0 pass 1 0 0 - +aten_i0e pass 1 0 0 - +aten_i1 pass 1 0 0 - +aten_i1e pass 1 0 0 - +aten_ifftshift_cpu pass 1 0 0 - +aten_igamma pass 1 0 0 - +aten_igammac pass 1 0 0 - +aten_im2col pass 1 0 0 - +aten_index_copy_cpu pass 0 2 0 - +aten_index_cpu pass 1 0 0 - +aten_index_fill_cpu pass 0 2 0 - +aten_index_put_cpu pass 0 1 0 - +aten_index_put_impl_cpu pass 0 1 0 - +aten_index_reduce_impl_cpu pass 1 1 1 memset_zero_1D_f32 +aten_index_select_dim1_cpu pass 1 0 0 - +aten_index_select_out_cpu pass 1 0 0 - +aten_index_select_sparse_cpu pass 1 0 0 - +aten_int4pack_mm_cpu pass 2 1 1 memset_zero_1D_f32 +aten_int8pack_mm_cpu pass 2 0 1 memset_zero_2D_f32 +aten_int_mm_out_cpu pass 2 0 0 - +aten_isin_default_cpu pass 3 0 1 memset_zero_1D +aten_isneginf pass 1 0 0 - +aten_isposinf pass 1 0 0 - +aten_jagged_to_padded_cpu pass 0 2 0 - +aten_joint_scaling_cpu pass 2 0 0 - +aten_kaiser_window pass 1 0 0 - +aten_kron_impl_cpu pass 1 0 0 - +aten_kron_out_cpu pass 1 0 0 - +aten_kthvalue_cpu pass 1 3 1 cudaCopy1D_f32_tensor +aten_l1_loss pass 1 0 0 - +aten_laguerre_polynomial_l pass 1 0 0 - +aten_layer_norm pass 3 0 0 - +aten_layer_norm_backward_cpu pass 4 1 2 memset_zero_1D_f32 +aten_layer_norm_cpu_backend pass 3 1 0 - +aten_lcm_i32 pass 1 1 0 - +aten_ldexp pass 1 0 0 - +aten_le pass 1 0 0 - +aten_leaky_relu pass 1 0 0 - +aten_legendre_polynomial_p pass 1 0 0 - +aten_lerp pass 1 0 0 - +aten_lerp_scalar pass 1 0 0 - +aten_lerp_scalar_cpu pass 1 0 0 - +aten_lerp_tensor_cpu pass 1 0 0 - +aten_lgamma pass 1 0 0 - +aten_linalg_powsum_cpu pass 2 0 1 memset_zero_1D_f32 +aten_linear_combination_cpu pass 3 0 3 cublasSgemv_T,cudaCopy1D_f32_tensor,memset_zero_1D_f32 +aten_linspace pass 1 0 0 - +aten_log pass 1 0 0 - +aten_log10 pass 1 0 0 - +aten_log1p pass 1 0 0 - +aten_log2 pass 1 0 0 - +aten_log_ndtr pass 1 0 0 - +aten_log_normal_cpu pass 1 0 0 - +aten_log_sigmoid_backward_cpu pass 1 0 0 - +aten_log_sigmoid_cpu pass 1 0 0 - +aten_logaddexp pass 1 0 0 - +aten_logaddexp2 pass 1 0 0 - +aten_logcumsumexp_cpu pass 1 1 0 - +aten_logical_and pass 1 0 0 - +aten_logical_not_f32 pass 1 0 0 - +aten_logical_or pass 1 0 0 - +aten_logical_xor pass 1 0 0 - +aten_logit pass 1 0 0 - +aten_logit_backward pass 1 0 0 - +aten_logspace_cpu pass 1 0 0 - +aten_lower_bound_cpu pass 0 2 0 - +aten_lshift_i32 pass 1 0 0 - +aten_lt pass 1 0 0 - +aten_masked_fill_cpu pass 1 0 0 - +aten_masked_scale pass 1 0 0 - +aten_masked_scatter_backward_cpu pass 0 1 0 - +aten_masked_scatter_cpu pass 0 1 0 - +aten_masked_select_cpu pass 0 1 0 - +aten_masked_select_serial_cpu pass 0 1 0 - +aten_max_all_cpu pass 1 0 0 - +aten_max_pool1d_cpu pass 5 1 1 cudaCopy1D_f32_tensor +aten_max_pool2d pass 2 0 1 cudnnMaxPoolFwd_batched +aten_max_pool3d_backward_cpu pass 1 4 1 memset_zero_1D_f32 +aten_max_pool3d_cpu pass 5 6 1 cudaCopy1D_f32_tensor +aten_max_reduce_cpu pass 1 0 0 - +aten_max_unpool2d_cpu pass 1 2 1 memset_zero_1D_f32 +aten_max_unpool3d_cpu pass 1 2 1 memset_zero_1D_f32 +aten_max_unpool_backward_cpu pass 1 0 0 - +aten_max_values_cpu pass 2 0 1 cudaCopy1D_f32_tensor +aten_maximum pass 1 0 0 - +aten_mean pass 1 0 0 - +aten_median_indices_cpu pass 2 3 1 cudaCopy1D_f32_tensor +aten_min_all_cpu pass 1 0 0 - +aten_min_reduce_cpu pass 1 0 0 - +aten_min_values_cpu pass 2 0 1 cudaCopy1D_f32_tensor +aten_minimum pass 1 0 0 - +aten_mish pass 1 0 0 - +aten_mish_backward pass 1 0 0 - +aten_mm pass 2 0 1 cutensornetContraction2_f64 +aten_mode_cpu pass 3 2 1 cudaCopy1D_f32_tensor +aten_modified_bessel_i0 pass 1 0 0 - +aten_modified_bessel_i1 pass 1 0 0 - +aten_modified_bessel_k0 pass 1 0 0 - +aten_modified_bessel_k1 pass 1 0 0 - +aten_mse_backward pass 1 0 0 - +aten_mse_elementwise pass 1 0 0 - +aten_mse_loss pass 2 0 0 - +aten_mul pass 1 0 0 - +aten_multi_margin_loss_backward_cpu pass 1 2 1 memset_zero_1D_f32 +aten_multi_margin_loss_cpu pass 1 1 0 - +aten_multilabel_margin_loss_backward_cpu pass 3 3 2 memset_zero_1D,memset_zero_1D_f32 +aten_multilabel_margin_loss_forward_cpu pass 1 3 0 - +aten_multinomial_with_replacement_cpu pass 1 3 0 - +aten_mv pass 1 0 1 cublasDgemv +aten_nan_to_num pass 1 0 0 - +aten_nansum_cpu pass 2 0 1 memset_zero_1D_f32 +aten_narrow_copy_dense_cpu pass 1 0 1 cudaCopy2D_f32_tensor +aten_ndtri pass 1 0 0 - +aten_ne pass 1 0 0 - +aten_neg pass 1 0 0 - +aten_nested_all_cpu pass 0 2 0 - +aten_nested_batch_offsets_cpu pass 1 0 0 - +aten_nested_bmm_cpu pass 2 0 0 - +aten_nested_clone_cpu pass 1 0 1 cudaCopy2D_f32_tensor +aten_nested_from_padded_cpu pass 1 0 0 - +aten_nested_matmul_broadcast_cpu pass 2 0 1 cublasSgemm_strided_batched_broadcast_rhs +aten_nested_pad_cpu pass 1 0 0 - +aten_nested_select_cpu pass 1 0 0 - +aten_nested_softmax_backward_cpu pass 2 1 1 cublasSdot +aten_nested_softmax_cpu pass 0 3 0 - +aten_nested_softmax_dropout_cpu pass 2 1 0 - +aten_nested_squeeze_cpu pass 1 0 1 cudaCopy2D_f32_tensor +aten_nested_sum_backward_cpu pass 1 0 0 - +aten_nested_sum_dim_cpu pass 0 2 0 - +aten_nested_to_mask_cpu pass 1 0 0 - +aten_nested_to_padded_cpu pass 1 0 0 - +aten_nested_where_cpu pass 1 0 0 - +aten_nested_where_out_cpu pass 1 0 0 - +aten_nextafter pass 1 0 0 - +aten_nll_loss2d_backward_cpu pass 0 4 0 - +aten_nll_loss2d_forward_cpu pass 1 0 0 - +aten_nll_loss_backward_cpu pass 1 1 1 memset_zero_2D_f32 +aten_nll_loss_forward_cpu pass 0 1 0 - +aten_nonzero_out_cpu pass 0 2 0 - +aten_norm_cpu pass 3 0 1 memset_zero_1D_f32 +aten_normal_cpu pass 1 0 0 - +aten_or_reduce_cpu pass 2 0 1 memset_zero_1D +aten_outer pass 2 0 1 cublasDgemm_outer_product +aten_padded_to_jagged_cpu pass 0 2 0 - +aten_pdist_backward_cpu pass 1 6 1 memset_zero_2D_f32 +aten_pdist_forward_cpu pass 1 3 0 - +aten_permute_sparse_coo_cpu pass 1 0 0 - +aten_pixel_shuffle pass 1 0 0 - +aten_pixel_shuffle_cpu_backend pass 1 0 0 - +aten_pixel_unshuffle_cpu_backend pass 1 0 0 - +aten_poisson_transform_cpu pass 0 2 0 - +aten_polar_scalarized pass 2 0 0 - +aten_polygamma pass 1 0 0 - +aten_pow pass 1 0 0 - +aten_pow_tensor_scalar pass 1 0 0 - +aten_powsum_cpu pass 2 0 1 memset_zero_1D_f32 +aten_prod pass 1 0 0 - +aten_put_cpu pass 0 1 0 - +aten_quant_col_offsets_cpu pass 3 0 1 memset_zero_1D +aten_quant_saturation_cpu pass 1 0 0 - +aten_quick_select_cpu pass 0 2 0 - +aten_random_cpu pass 1 0 0 - +aten_random_from_to_cpu pass 1 0 0 - +aten_random_full_64_bits_range_cpu pass 1 0 0 - +aten_randperm_cpu pass 1 1 0 - +aten_range_out_cpu pass 1 0 0 - +aten_reciprocal pass 1 0 0 - +aten_reflect_conj_tri_cpu pass 2 0 0 - +aten_reflection_pad1d_backward_cpu pass 1 2 1 memset_zero_1D_f32 +aten_reflection_pad1d_cpu pass 1 0 0 - +aten_reflection_pad2d pass 1 0 0 - +aten_reflection_pad2d_backward_cpu pass 1 3 1 memset_zero_1D_f32 +aten_reflection_pad2d_cpu pass 1 0 0 - +aten_reflection_pad3d_backward_cpu pass 1 4 1 memset_zero_1D_f32 +aten_reflection_pad3d_cpu pass 1 0 0 - +aten_relu pass 1 0 0 - +aten_remainder pass 1 0 0 - +aten_renorm_scale_factor pass 1 0 0 - +aten_repeat_compute_cpu pass 1 0 0 - +aten_repeat_tensor_shape_cpu pass 1 0 0 - +aten_replication_pad1d_backward_cpu pass 1 2 1 memset_zero_1D_f32 +aten_replication_pad1d_cpu pass 1 0 0 - +aten_replication_pad2d pass 1 0 0 - +aten_replication_pad2d_backward_cpu pass 1 3 1 memset_zero_1D_f32 +aten_replication_pad2d_cpu pass 1 0 0 - +aten_replication_pad3d_backward_cpu pass 1 4 1 memset_zero_1D_f32 +aten_replication_pad3d_cpu pass 1 0 0 - +aten_rms_norm pass 2 0 1 rmsnorm_f32_tensor +aten_round pass 1 0 0 - +aten_round_decimals pass 1 0 0 - +aten_rowwise_prune_cpu pass 3 0 1 memset_zero_1D_f32 +aten_rshift_i32 pass 1 0 0 - +aten_rsqrt pass 1 0 0 - +aten_sample_poisson_transform_cpu pass 0 2 0 - +aten_sampled_addmm_sparse_csr_cpu pass 1 2 0 - +aten_scaled_modified_bessel_k0 pass 1 0 0 - +aten_scaled_modified_bessel_k1 pass 1 0 0 - +aten_scatter_add_cpu pass 0 2 0 - +aten_scatter_add_expanded_index_cpu pass 0 2 0 - +aten_scatter_cpu pass 0 2 0 - +aten_scatter_fill_cpu pass 0 2 0 - +aten_scatter_reduce_cpu pass 0 2 0 - +aten_scatter_reduce_expanded_index_cpu pass 0 2 0 - +aten_scatter_reduce_two_cpu pass 0 2 0 - +aten_scatter_scalar_reduce_cpu pass 0 2 0 - +aten_searchsorted_cpu pass 0 2 0 - +aten_segment_reduce_lengths_backward_cpu pass 0 2 0 - +aten_segment_reduce_lengths_cpu pass 0 2 0 - +aten_sgn_complex_scalarized pass 1 0 0 - +aten_shrink_backward pass 1 0 0 - +aten_sigmoid pass 1 0 0 - +aten_sigmoid_backward pass 1 0 0 - +aten_sign pass 1 0 0 - +aten_signbit pass 1 0 0 - +aten_silu pass 1 0 0 - +aten_silu_backward pass 1 0 0 - +aten_silu_cpu pass 1 0 0 - +aten_sin pass 1 0 0 - +aten_sinc pass 1 0 0 - +aten_sinh pass 1 0 0 - +aten_slow_conv3d_backward_input_cpu pass 1 1 0 - +aten_slow_conv3d_backward_weight_cpu pass 1 1 0 - +aten_slow_conv3d_forward_cpu pass 2 0 1 cudnnConvolution3D_f32 +aten_smooth_l1_backward pass 1 0 0 - +aten_smooth_l1_elementwise pass 1 0 0 - +aten_sobol_draw_cpu pass 0 3 0 - +aten_sobol_fast_forward_cpu pass 1 1 0 - +aten_sobol_initialize_cpu pass 1 0 0 - +aten_sobol_scramble_cpu pass 1 0 0 - +aten_softmax pass 3 0 1 cudnnSoftmaxForward_tensor +aten_softplus pass 1 0 0 - +aten_softplus_backward pass 1 0 0 - +aten_softshrink pass 1 0 0 - +aten_sort_cpu pass 2 3 1 cudaCopy2D_f32_tensor +aten_sparse_add_values_cpu pass 1 0 0 - +aten_sparse_addmm_cpu pass 1 2 1 memset_zero_2D_f32 +aten_sparse_addmv_bsr_cpu pass 1 3 0 - +aten_sparse_addmv_csr_cpu pass 0 2 0 - +aten_sparse_bmm_cpu pass 2 0 0 - +aten_sparse_coo_softmax_backward_cpu pass 2 1 1 cublasSdot +aten_sparse_coo_softmax_cpu pass 2 1 0 - +aten_sparse_coo_to_csr_cpu pass 0 2 0 - +aten_sparse_csr_add_dense_cpu pass 0 2 0 - +aten_sparse_csr_addmm_cpu pass 0 3 0 - +aten_sparse_csr_reduce_all_cpu pass 1 0 0 - +aten_sparse_csr_reduce_dim0_cpu pass 1 2 1 memset_zero_1D_f32 +aten_sparse_csr_reduce_dim1_cpu pass 0 2 0 - +aten_sparse_dense_intersection_cpu pass 1 0 0 - +aten_sparse_flatten_indices_cpu pass 2 0 1 memset_zero_1D +aten_sparse_full_coo_indices_cpu pass 0 2 0 - +aten_sparse_intersection_apply_cpu pass 1 0 0 - +aten_sparse_intersection_launch_cpu pass 1 0 0 - +aten_sparse_matmul_cpu pass 0 3 0 - +aten_sparse_matmul_csr_to_coo_cpu pass 0 2 0 - +aten_sparse_matmul_maxnnz_cpu pass 0 2 0 - +aten_sparse_mul_cpu pass 1 0 0 - +aten_sparse_norm_cpu pass 1 0 0 - +aten_sparse_softmax_offsets_cpu pass 0 2 0 - +aten_sparse_softmax_pools_cpu pass 1 0 0 - +aten_sparse_sum_backward_cpu pass 1 0 0 - +aten_sparse_sum_cpu pass 1 0 0 - +aten_spdiags_cpu pass 1 2 1 memset_zero_2D_f32 +aten_spherical_bessel_j0 pass 1 0 0 - +aten_split_copy_cpu pass 1 0 0 - +aten_spmm_reduce_arg_cpu pass 0 3 0 - +aten_spmm_reduce_backward_input_arg_cpu pass 1 2 1 memset_zero_1D_f32 +aten_spmm_reduce_backward_input_cpu pass 1 2 0 - +aten_spmm_reduce_backward_other_arg_cpu pass 1 2 1 memset_zero_2D_f32 +aten_spmm_reduce_backward_other_cpu pass 1 3 1 memset_zero_2D_f32 +aten_spmm_reduce_cpu pass 0 3 0 - +aten_sqrt pass 1 0 0 - +aten_square pass 1 0 0 - +aten_sspaddmm_cpu pass 1 2 1 memset_zero_2D_f32 +aten_stack_serial_cpu pass 1 0 0 - +aten_standard_gamma_grad_cpu pass 1 0 0 - +aten_std_var_all_cpu pass 2 0 0 - +aten_std_var_cpu pass 2 1 0 - +aten_sum pass 2 0 1 memset_zero_1D +aten_sum_cpu_backend pass 2 0 1 memset_zero_1D_f32 +aten_sumproduct_pair_cpu pass 2 0 0 - +aten_take_cpu pass 1 0 0 - +aten_tan pass 1 0 0 - +aten_tanh pass 1 0 0 - +aten_tanh_backward pass 1 0 0 - +aten_threshold_backward pass 1 0 0 - +aten_topk_cpu pass 4 3 1 cudaCopy2D_f32_tensor +aten_trace_cpu pass 1 0 0 - +aten_transform_bias_rescale_qkv_cpu pass 3 0 0 - +aten_transpose_copy pass 1 0 0 - +aten_trigamma pass 1 0 0 - +aten_tril_indices_cpu pass 0 2 0 - +aten_trilinear_cpu pass 2 0 1 memset_zero_2D_f32 +aten_triu_indices_cpu pass 0 2 0 - +aten_triu_mask_cpu pass 1 0 0 - +aten_triu_tril_batch_cpu pass 1 0 0 - +aten_triu_tril_single_cpu pass 1 0 0 - +aten_trunc pass 1 0 0 - +aten_unbind_copy_cpu pass 1 0 1 cudaCopy2D_f32_tensor +aten_unfold3d_acc_cpu pass 1 1 0 - +aten_unfold3d_copy_cpu pass 1 0 0 - +aten_unfold3d_zero_acc_cpu pass 0 8 0 - +aten_unfold3d_zero_copy_cpu pass 1 0 0 - +aten_unfold_backward_cpu pass 2 0 1 memset_zero_1D_f32 +aten_unfolded2d_acc_cpu pass 2 0 0 - +aten_unfolded2d_copy_cpu pass 1 0 0 - +aten_uniform_cpu pass 1 0 0 - +aten_unique_bool_cpu pass 0 1 0 - +aten_unique_consecutive_cpu pass 0 1 0 - +aten_unique_dim_impl_cpu pass 3 1 0 - +aten_unique_dim_template_cpu pass 3 1 0 - +aten_unique_sorted_cpu pass 0 3 0 - +aten_unpack_pivots_cpu pass 1 1 0 - +aten_unsafe_index_cpu pass 1 0 0 - +aten_upper_bound_cpu pass 0 2 0 - +aten_upsample_bicubic2d_aa_backward_cpu pass 3 3 1 memset_zero_1D_f32 +aten_upsample_bicubic2d_aa_cpu pass 2 3 0 - +aten_upsample_bicubic2d_backward_cpu pass 1 2 1 memset_zero_1D_f32 +aten_upsample_bicubic2d_cpu pass 0 5 0 - +aten_upsample_bilinear2d pass 1 0 0 - +aten_upsample_bilinear2d_aa_backward_cpu pass 3 3 1 memset_zero_1D_f32 +aten_upsample_bilinear2d_aa_cpu pass 2 3 0 - +aten_upsample_bilinear2d_backward_cpu pass 1 3 1 memset_zero_1D_f32 +aten_upsample_bilinear2d_cpu pass 1 0 0 - +aten_upsample_lanczos2d_aa_backward_cpu pass 3 3 1 memset_zero_1D_f32 +aten_upsample_lanczos2d_aa_cpu pass 2 3 0 - +aten_upsample_linear1d_backward_cpu pass 1 2 1 memset_zero_1D_f32 +aten_upsample_linear1d_cpu pass 1 0 0 - +aten_upsample_nearest1d_backward_cpu pass 1 2 1 memset_zero_1D_f32 +aten_upsample_nearest1d_cpu pass 1 0 0 - +aten_upsample_nearest2d pass 1 0 0 - +aten_upsample_nearest2d_backward_cpu pass 1 3 1 memset_zero_1D_f32 +aten_upsample_nearest2d_cpu pass 1 0 0 - +aten_upsample_nearest3d_backward_cpu pass 1 4 1 memset_zero_1D_f32 +aten_upsample_nearest3d_cpu pass 1 0 0 - +aten_upsample_nearest_exact1d_backward_cpu pass 1 2 1 memset_zero_1D_f32 +aten_upsample_nearest_exact1d_cpu pass 1 0 0 - +aten_upsample_nearest_exact2d_backward_cpu pass 1 3 1 memset_zero_1D_f32 +aten_upsample_nearest_exact2d_cpu pass 1 0 0 - +aten_upsample_nearest_exact3d_backward_cpu pass 1 4 1 memset_zero_1D_f32 +aten_upsample_nearest_exact3d_cpu pass 1 0 0 - +aten_upsample_trilinear3d_backward_cpu pass 1 4 1 memset_zero_1D_f32 +aten_upsample_trilinear3d_cpu pass 1 0 0 - +aten_vector_norm_out_cpu pass 3 0 1 memset_zero_1D_f32 +aten_weight_norm_backward_cpu pass 2 1 1 cublasSdot +aten_weight_norm_cpu pass 2 1 0 - +aten_weight_to_int4pack_cpu pass 0 2 0 - +aten_where_cpu pass 1 0 0 - +aten_xlog1py pass 1 0 0 - +aten_xlogy pass 1 0 0 - +aten_xor_sum_cpu pass 2 0 1 memset_zero_1D +aten_zeros_cpu pass 1 0 1 memset_zero_1D_f32 +aten_zeta pass 1 0 0 - diff --git a/issues/aten_c_kernels/silicon_results/device_residency_comparison.csv b/issues/aten_c_kernels/silicon_results/device_residency_comparison.csv new file mode 100644 index 000000000000..4e489a61929b --- /dev/null +++ b/issues/aten_c_kernels/silicon_results/device_residency_comparison.csv @@ -0,0 +1,41 @@ +kernel,correctness,problem,mapped_raised_us,device_resident_us,resident_cuda_us,mapped_over_resident,device_over_resident,mapped_over_device,hardware,statistic,notes +aten_add,PASS,B32 C64 H64 W64,955.712004,581.417594,542.347229,1.762177,1.072039,1.643762,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_addmm,PASS,M512 N512 K512,3818.009561,3812.051204,3778.838379,1.010366,1.008789,1.001563,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_as_complex_cpu,PASS,N=8388608,49486.598372,27545.449603,27387.167969,1.806926,1.005779,1.796543,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_batch_norm,PASS,B32 C64 H64 W64,653.036777,455.651199,392.196808,1.665074,1.161792,1.433194,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_bf16_dot_cpu,PASS,K=16777216 scalarized-f32,858.924771,809.969602,764.019165,1.124219,1.060143,1.060441,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_bf16_gemv_trans_cpu,PASS,M=4096 K=8192 scalarized-f32 trans,907.321600,983.500795,793.395142,1.143594,1.239610,0.922543,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_blas_copy_cpu,PASS,N=16777216,6829.843204,860.761595,697.302368,9.794665,1.234417,7.934651,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_blas_dot_naive_cpu,PASS,N=K=16777216,858.073588,807.825604,763.835205,1.123375,1.057591,1.062202,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_blas_gemv_generic_cpu,PASS,M=4096 K=8192,884.396816,821.988797,758.952026,1.165287,1.083058,1.075923,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_cat_serial_cpu,PASS,R=4096 M=4096 K=2048,6822.777633,746.528001,701.761597,9.722358,1.063791,9.139346,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_complex_scalarized,PASS,N=8388608,6865.696004,745.959999,700.889587,9.795688,1.064305,9.203839,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_conv2d,PASS,B8 IC32 OC64 H64 W64 KH3 KW3,854.982389,799.564796,436.988770,1.956532,1.829715,1.069310,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_conv3d,PASS,B1 IC8 OC16 D48 H48 W48 K3,884.665595,747.268798,447.262390,1.977957,1.670762,1.183865,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_conv_transpose3d_backward_cpu,PASS,C8 O16 D48 H48 W48 K3,764.467195,744.934403,449.039978,1.702448,1.658949,1.026221,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_copy_cpu,PASS,N=16777216,6786.847999,728.097593,695.990417,9.751353,1.046132,9.321344,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_copy_tensor_array_cpu,PASS,B=4096 N=4096,6802.419201,728.841603,697.036743,9.759054,1.045629,9.333193,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_dot,PASS,N8388608,878.323196,811.854401,766.452759,1.145959,1.059236,1.081873,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_fast_cat_dim0_cpu,PASS,B=4096 N=4096,6839.865586,727.584003,696.750366,9.816809,1.044253,9.400792,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_flatten_nd_linear_cpu,PASS,B16 M256 N256 K256,239.180820,205.689599,177.688004,1.346072,1.157589,1.162824,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_fp16_dot_cpu,PASS,K=16777216 scalarized-f32,857.900782,808.041601,764.278442,1.122498,1.057261,1.061704,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_fp16_gemv_f16arith_cpu,PASS,M=4096 K=8192 scalarized-f32,887.705572,817.222393,758.612854,1.170169,1.077259,1.086247,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_fp16_gemv_f32arith_cpu,PASS,M=4096 K=8192 scalarized-f32,881.356793,816.739199,758.652771,1.161739,1.076565,1.079117,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_fp16_gemv_notrans_cpu,PASS,M=4096 K=8192 scalarized-f32,881.727971,817.724795,758.255981,1.162837,1.078428,1.078270,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_fp16_gemv_trans_cpu,PASS,M=4096 K=8192 scalarized-f32 trans,905.977562,859.198393,793.486450,1.141768,1.082814,1.054445,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_gelu,PASS,N8388608,13344.268780,13047.495997,437.297546,30.515307,29.836655,1.022746,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_gelu_cpu_tanh,PASS,N=8388608,13357.612770,13104.711997,437.297546,30.545821,29.967495,1.019298,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_linear_combination_cpu,PASS,N=8388608 terms=4,26803.936018,8614.001598,892.532837,30.031316,9.651187,3.111671,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_max_pool2d,PASS,B32 C64 H64 W64 K2 S2,307.315215,249.563204,220.708786,1.392401,1.130735,1.231412,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_mm,PASS,M512 N512 K512,3822.054388,3818.451194,3772.609863,1.013106,1.012151,1.000944,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_mv,PASS,M4096 K4096,893.203216,846.494408,814.979126,1.095983,1.038670,1.055179,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_narrow_copy_dense_cpu,PASS,R=4096 C=4096 S=1024 L=2048,4895.276809,460.636802,439.467194,11.139118,1.048171,10.627194,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_nested_clone_cpu,PASS,B=4096 N=4096,6831.084797,732.243201,695.862427,9.816717,1.052282,9.328984,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_nested_matmul_broadcast_cpu,PASS,B16 M256 N256 K256,240.403228,205.353601,176.012802,1.365828,1.166697,1.170679,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_nested_squeeze_cpu,PASS,B=4096 N=4096,6792.927999,734.804804,696.092773,9.758653,1.055613,9.244534,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_outer,PASS,M=4096 N=4096 f64,3854.073631,3849.785600,3810.022217,1.011562,1.010437,1.001114,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_rms_norm,PASS,N8388608,13051.795214,2067.921602,841.404785,15.511910,2.457701,6.311552,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,RMS reduction reassociation tolerance 2e-3 +aten_slow_conv3d_forward_cpu,PASS,C8 O16 D48 H48 W48 K3,726.438407,663.596799,364.764832,1.991525,1.819246,1.094698,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_softmax,PASS,N8388608,28666.707221,29239.145608,29212.042969,0.981332,1.000928,0.980422,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_unbind_copy_cpu,PASS,B=4096 N=4096,6792.947184,736.286398,702.041626,9.675989,1.048779,9.225958,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated +aten_zeros_cpu,PASS,N=16777216,2255.948773,392.128003,374.880005,6.017789,1.046009,5.753093,Jetson Orin sm87 MAXN CUDA 12.6,median process runs 2-4; 20 timed calls/process,correctness-gated diff --git a/issues/aten_c_kernels/silicon_results/gemv_device_residency_comparison.csv b/issues/aten_c_kernels/silicon_results/gemv_device_residency_comparison.csv new file mode 100644 index 000000000000..7ca7c2f0b40a --- /dev/null +++ b/issues/aten_c_kernels/silicon_results/gemv_device_residency_comparison.csv @@ -0,0 +1,2 @@ +kernel,problem,correctness,mapped_raised_us,device_raised_us,resident_cuda_us,mapped_over_resident,device_over_resident,mapped_over_device,statistic,hardware,notes +aten_blas_gemv_generic_cpu,M=4096 K=8192,PASS,881.804805,821.800006,758.952026,1.161872,1.082809,1.073016,warm median of process runs 2-4,Jetson Orin sm87 CUDA 12.6,mapped raised 5 iterations; device raised and resident 20 iterations; A/x upload and y download outside timed region; direct-buffer lowering; max_abs=0.0008430481 diff --git a/issues/aten_c_kernels/silicon_results/large_problem_comparison.csv b/issues/aten_c_kernels/silicon_results/large_problem_comparison.csv new file mode 100644 index 000000000000..9534d173b1e7 --- /dev/null +++ b/issues/aten_c_kernels/silicon_results/large_problem_comparison.csv @@ -0,0 +1,78 @@ +kernel,executable_status,correctness,problem,raised_us,resident_cuda_us,raised_over_resident,baseline,statistic,hardware,notes +aten_adaptive_avg_pool2d,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,2 Linalg ops; no whole-kernel library match +aten_adaptive_avg_pool3d,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,2 Linalg ops; no whole-kernel library match +aten_add,EXECUTED,PASS,B32 C64 H64 W64,955.712004,542.347229,1.762177,cuDNN AddTensor,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_addmm,EXECUTED,PASS,M512 N512 K512,3818.009561,3778.838379,1.010366,cuBLAS Dgemm beta=.5 alpha=1.25,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_as_complex_cpu,EXECUTED,PASS,N=8388608,49486.598372,27387.167969,1.806926,2x cudaMemcpy2D D2D,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_avg_pool2d,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,2 Linalg ops; no whole-kernel library match +aten_avg_pool3d,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,2 Linalg ops; no whole-kernel library match +aten_batch_norm,EXECUTED,PASS,B32 C64 H64 W64,653.036777,392.196808,1.665074,cuDNN BatchNormalizationForwardInference,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_bf16_dot_cpu,EXECUTED,PASS,K=16777216 scalarized-f32,858.924771,764.019165,1.124219,cuBLAS Sdot,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_bf16_gemv_trans_cpu,EXECUTED,PASS,M=4096 K=8192 scalarized-f32 trans,907.321600,793.395142,1.143594,cuBLAS Sgemv,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_binary_cross_entropy,RAISING_INCOMPLETE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,external logf leaves one residual loop +aten_blas_copy_cpu,EXECUTED,PASS,N=16777216,6829.843204,697.302368,9.794665,cudaMemcpy D2D,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_blas_dot_naive_cpu,EXECUTED,PASS,N=K=16777216,858.073588,763.835205,1.123375,cuBLAS Sdot,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_blas_gemv_generic_cpu,EXECUTED,PASS,M=4096 K=8192,884.396816,758.952026,1.165287,cuBLAS Sgemv,warm median of process runs 2-4,Jetson Orin sm87 CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_bmm,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,2 Linalg ops; no batched GEMM route +aten_cat_serial_cpu,EXECUTED,PASS,R=4096 M=4096 K=2048,6822.777633,701.761597,9.722358,2x cudaMemcpy D2D,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_channel_shuffle,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,layout transform intentionally rejected as copy +aten_clamp,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no whole-kernel library match +aten_complex_scalarized,EXECUTED,PASS,N=8388608,6865.696004,700.889587,9.795688,2x cudaMemcpy D2D,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_conv1d,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,2 Linalg ops; no 1D convolution route +aten_conv2d,EXECUTED,PASS,B8 IC32 OC64 H64 W64 KH3 KW3,854.982389,436.988770,1.956532,cuDNN ConvolutionForward,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_conv3d,EXECUTED,PASS,B1 IC8 OC16 D48 H48 W48 K3,884.665595,447.262390,1.977957,cuDNN Conv3D + bias,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_conv_transpose2d,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,2 Linalg ops; no transposed convolution route +aten_conv_transpose3d_backward_cpu,EXECUTED,PASS,C8 O16 D48 H48 W48 K3,764.467195,449.039978,1.702448,cuDNN Conv3D,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_copy_cpu,EXECUTED,PASS,N=16777216,6786.847999,695.990417,9.751353,cudaMemcpy D2D,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_copy_tensor_array_cpu,EXECUTED,PASS,B=4096 N=4096,6802.419201,697.036743,9.759054,cudaMemcpy D2D,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_cross,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,3 Linalg ops; no cross-product composition +aten_cumsum,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,scan raises to Linalg but has no scan route +aten_dot,EXECUTED,PASS,N8388608,878.323196,766.452759,1.145959,cuBLAS Ddot,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_elu,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no whole-kernel library match +aten_embedding,RAISING_INCOMPLETE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,indexed gather leaves 2 residual loops +aten_fast_cat_dim0_cpu,EXECUTED,PASS,B=4096 N=4096,6839.865586,696.750366,9.816809,cudaMemcpy D2D,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_flatten_nd_linear_cpu,EXECUTED,PASS,B16 M256 N256 K256,239.180820,177.688004,1.346072,"cuBLAS SgemmStridedBatched, broadcast RHS",warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_fp16_dot_cpu,EXECUTED,PASS,K=16777216 scalarized-f32,857.900782,764.278442,1.122498,cuBLAS Sdot,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_fp16_gemv_f16arith_cpu,EXECUTED,PASS,M=4096 K=8192 scalarized-f32,887.705572,758.612854,1.170169,cuBLAS Sgemv,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_fp16_gemv_f32arith_cpu,EXECUTED,PASS,M=4096 K=8192 scalarized-f32,881.356793,758.652771,1.161739,cuBLAS Sgemv,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_fp16_gemv_notrans_cpu,EXECUTED,PASS,M=4096 K=8192 scalarized-f32,881.727971,758.255981,1.162837,cuBLAS Sgemv,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_fp16_gemv_trans_cpu,EXECUTED,PASS,M=4096 K=8192 scalarized-f32 trans,905.977562,793.486450,1.141768,cuBLAS Sgemv,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_gelu,EXECUTED,PASS,N8388608,13344.268780,437.297546,30.515307,fused CUDA GELU kernel,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_gelu_cpu_tanh,EXECUTED,PASS,N=8388608,13357.612770,437.297546,30.545821,fused CUDA GELU (equivalent prior baseline),warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_hardsigmoid,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no whole-kernel library match +aten_hardswish,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no whole-kernel library match +aten_hardtanh,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no whole-kernel library match +aten_im2col,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,window gather intentionally rejected as copy +aten_l1_loss,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no reduction composition +aten_layer_norm,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,3 Linalg ops; composition not in library +aten_leaky_relu,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no whole-kernel library match +aten_lerp,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no whole-kernel library match +aten_linear_combination_cpu,EXECUTED,PASS,N=8388608 terms=4,26803.936018,892.532837,30.031316,cuBLAS Sgemv,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_max_pool2d,EXECUTED,PASS,B32 C64 H64 W64 K2 S2,307.315215,220.708786,1.392401,cuDNN PoolingForward,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_mean,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; reduction-plus-scale composition absent +aten_mm,EXECUTED,PASS,M512 N512 K512,3822.054388,3772.609863,1.013106,cuBLAS Dgemm beta=0,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_mse_loss,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,2 Linalg ops; reduction composition absent +aten_mv,EXECUTED,PASS,M4096 K4096,893.203216,814.979126,1.095983,cuBLAS Dgemv beta=1,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_narrow_copy_dense_cpu,EXECUTED,PASS,R=4096 C=4096 S=1024 L=2048,4895.276809,439.467194,11.139118,cudaMemcpy2D D2D,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_nested_clone_cpu,EXECUTED,PASS,B=4096 N=4096,6831.084797,695.862427,9.816717,cudaMemcpy D2D,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_nested_matmul_broadcast_cpu,EXECUTED,PASS,B16 M256 N256 K256,240.403228,176.012802,1.365828,"cuBLAS SgemmStridedBatched, broadcast RHS",warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_nested_squeeze_cpu,EXECUTED,PASS,B=4096 N=4096,6792.927999,696.092773,9.758653,cudaMemcpy D2D,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_outer,EXECUTED,PASS,M=4096 N=4096 f64,3854.073631,3810.022217,1.011562,cuBLAS Dgemm outer product,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_pixel_shuffle,UNSAFE_MATCH_NOT_EXECUTED,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,rank-6 copy candidate does not yet prove the submap layout is preserved by the runtime +aten_prod,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no product reduction route +aten_reflection_pad2d,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no reflection-padding route +aten_relu,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no whole-kernel library match +aten_replication_pad2d,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no replication-padding route +aten_rms_norm,EXECUTED,PASS,N8388608,13051.795214,841.404785,15.511910,fused CUDA RMSNorm reduction plus scale,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_sigmoid,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no whole-kernel library match +aten_silu,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no whole-kernel library match +aten_slow_conv3d_forward_cpu,EXECUTED,PASS,C8 O16 D48 H48 W48 K3,726.438407,364.764832,1.991525,cuDNN Conv3D,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_softmax,EXECUTED,PASS,N8388608,28666.707221,29212.042969,0.981332,cuDNN SoftmaxForward,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_softplus,RAISING_INCOMPLETE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,external logf/expf and branch leave one residual loop +aten_sum,PARTIAL_MATCH_NOT_EXECUTABLE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,only output memset matched +aten_tanh,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no whole-kernel library match +aten_transpose_copy,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,permuted indexing intentionally rejected as copy +aten_unbind_copy_cpu,EXECUTED,PASS,B=4096 N=4096,6792.947184,702.041626,9.675989,cudaMemcpy D2D,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated +aten_upsample_bilinear2d,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no bilinear-resampling route +aten_upsample_nearest2d,RAISED_NO_LIBRARY_ROUTE,—,—,—,—,—,—,—,Jetson Orin sm87 MAXN,1 Linalg op; no nearest-neighbor route +aten_zeros_cpu,EXECUTED,PASS,N=16777216,2255.948773,374.880005,6.017789,cudaMemset,warm median of process runs 2-4,Jetson Orin sm87 MAXN CUDA 12.6,mapped and cudaMalloc device-resident raised paths correctness-gated diff --git a/issues/aten_c_kernels/silicon_results/logs/full_match_large_run_1.log b/issues/aten_c_kernels/silicon_results/logs/full_match_large_run_1.log new file mode 100644 index 000000000000..9c09bd7b6a8b --- /dev/null +++ b/issues/aten_c_kernels/silicon_results/logs/full_match_large_run_1.log @@ -0,0 +1,200 @@ +====run=1 exe=aten_as_complex_cpu +kernel=aten_as_complex_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_as_complex_cpu iterations=5 raised_gpu_us=49718.937604 +rc=0 +====run=1 exe=aten_as_complex_cpu_resident +kernel=aten_as_complex_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=27406.308594 +rc=0 +====run=1 exe=aten_bf16_dot_cpu +kernel=aten_bf16_dot_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_bf16_dot_cpu iterations=5 raised_gpu_us=858.655991 +rc=0 +====run=1 exe=aten_bf16_dot_cpu_resident +kernel=aten_bf16_dot_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=764.255981 +rc=0 +====run=1 exe=aten_bf16_gemv_trans_cpu +kernel=aten_bf16_gemv_trans_cpu correctness=PASS max_abs=4.3392181396484375e-05 max_rel=8.6217938438954985e-06 +kernel=aten_bf16_gemv_trans_cpu iterations=5 raised_gpu_us=131427.539233 +rc=0 +====run=1 exe=aten_bf16_gemv_trans_cpu_resident +kernel=aten_bf16_gemv_trans_cpu correctness=PASS max_abs=4.3392181396484375e-05 iterations=20 resident_cuda_us=793.662415 +rc=0 +====run=1 exe=aten_blas_copy_cpu +kernel=aten_blas_copy_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_blas_copy_cpu iterations=5 raised_gpu_us=6835.270394 +rc=0 +====run=1 exe=aten_blas_copy_cpu_resident +kernel=aten_blas_copy_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=728.004761 +rc=0 +====run=1 exe=aten_blas_dot_naive_cpu +kernel=aten_blas_dot_naive_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_blas_dot_naive_cpu iterations=5 raised_gpu_us=857.900828 +rc=0 +====run=1 exe=aten_blas_dot_naive_cpu_resident +kernel=aten_blas_dot_naive_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=764.361633 +rc=0 +====run=1 exe=aten_blas_gemv_generic_cpu +kernel=aten_blas_gemv_generic_cpu correctness=PASS max_abs=0.000843048095703125 max_rel=1.7227638058081928e-05 +kernel=aten_blas_gemv_generic_cpu iterations=5 raised_gpu_us=132157.107163 +rc=0 +====run=1 exe=aten_blas_gemv_generic_cpu_resident +kernel=aten_blas_gemv_generic_cpu correctness=PASS max_abs=0.000843048095703125 iterations=20 resident_cuda_us=758.244812 +rc=0 +====run=1 exe=aten_cat_serial_cpu +kernel=aten_cat_serial_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_cat_serial_cpu iterations=5 raised_gpu_us=6885.612803 +rc=0 +====run=1 exe=aten_cat_serial_cpu_resident +kernel=aten_cat_serial_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=703.348755 +rc=0 +====run=1 exe=aten_complex_scalarized +kernel=aten_complex_scalarized correctness=PASS max_abs=0 max_rel=0 +kernel=aten_complex_scalarized iterations=5 raised_gpu_us=6874.380773 +rc=0 +====run=1 exe=aten_complex_scalarized_resident +kernel=aten_complex_scalarized correctness=PASS max_abs=0 iterations=20 resident_cuda_us=702.881653 +rc=0 +====run=1 exe=aten_conv3d +kernel=aten_conv3d correctness=PASS max_abs=0.00017541646957397461 max_rel=0.00017541646957397461 +kernel=aten_conv3d iterations=5 raised_gpu_us=898.137596 +rc=0 +====run=1 exe=aten_conv3d_resident +kernel=aten_conv3d correctness=PASS max_abs=0.00017541646957397461 iterations=20 resident_cuda_us=447.416016 +rc=0 +====run=1 exe=aten_conv_transpose3d_backward_cpu +kernel=aten_conv_transpose3d_backward_cpu correctness=PASS max_abs=0.00020104646682739258 max_rel=0.00020104646682739258 +kernel=aten_conv_transpose3d_backward_cpu iterations=5 raised_gpu_us=768.153602 +rc=0 +====run=1 exe=aten_conv_transpose3d_backward_cpu_resident +kernel=aten_conv_transpose3d_backward_cpu correctness=PASS max_abs=0.00020104646682739258 iterations=20 resident_cuda_us=451.179199 +rc=0 +====run=1 exe=aten_copy_cpu +kernel=aten_copy_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_copy_cpu iterations=5 raised_gpu_us=6837.702403 +rc=0 +====run=1 exe=aten_copy_cpu_resident +kernel=aten_copy_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=699.331177 +rc=0 +====run=1 exe=aten_copy_tensor_array_cpu +kernel=aten_copy_tensor_array_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_copy_tensor_array_cpu iterations=5 raised_gpu_us=6871.936005 +rc=0 +====run=1 exe=aten_copy_tensor_array_cpu_resident +kernel=aten_copy_tensor_array_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=698.627197 +rc=0 +====run=1 exe=aten_fast_cat_dim0_cpu +kernel=aten_fast_cat_dim0_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_fast_cat_dim0_cpu iterations=5 raised_gpu_us=6848.345604 +rc=0 +====run=1 exe=aten_fast_cat_dim0_cpu_resident +kernel=aten_fast_cat_dim0_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=700.379211 +rc=0 +====run=1 exe=aten_flatten_nd_linear_cpu +kernel=aten_flatten_nd_linear_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_flatten_nd_linear_cpu iterations=5 raised_gpu_us=5835.801642 +rc=0 +====run=1 exe=aten_flatten_nd_linear_cpu_resident +kernel=aten_flatten_nd_linear_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=176.265594 +rc=0 +====run=1 exe=aten_fp16_dot_cpu +kernel=aten_fp16_dot_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_fp16_dot_cpu iterations=5 raised_gpu_us=857.600011 +rc=0 +====run=1 exe=aten_fp16_dot_cpu_resident +kernel=aten_fp16_dot_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=764.198364 +rc=0 +====run=1 exe=aten_fp16_gemv_f16arith_cpu +kernel=aten_fp16_gemv_f16arith_cpu correctness=PASS max_abs=0.000843048095703125 max_rel=1.7227638058081928e-05 +kernel=aten_fp16_gemv_f16arith_cpu iterations=5 raised_gpu_us=131874.540821 +rc=0 +====run=1 exe=aten_fp16_gemv_f16arith_cpu_resident +kernel=aten_fp16_gemv_f16arith_cpu correctness=PASS max_abs=0.000843048095703125 iterations=20 resident_cuda_us=758.534363 +rc=0 +====run=1 exe=aten_fp16_gemv_f32arith_cpu +kernel=aten_fp16_gemv_f32arith_cpu correctness=PASS max_abs=0.000843048095703125 max_rel=1.7227638058081928e-05 +kernel=aten_fp16_gemv_f32arith_cpu iterations=5 raised_gpu_us=131086.400012 +rc=0 +====run=1 exe=aten_fp16_gemv_f32arith_cpu_resident +kernel=aten_fp16_gemv_f32arith_cpu correctness=PASS max_abs=0.000843048095703125 iterations=20 resident_cuda_us=757.601624 +rc=0 +====run=1 exe=aten_fp16_gemv_notrans_cpu +kernel=aten_fp16_gemv_notrans_cpu correctness=PASS max_abs=0.000843048095703125 max_rel=1.7227638058081928e-05 +kernel=aten_fp16_gemv_notrans_cpu iterations=5 raised_gpu_us=131776.236789 +rc=0 +====run=1 exe=aten_fp16_gemv_notrans_cpu_resident +kernel=aten_fp16_gemv_notrans_cpu correctness=PASS max_abs=0.000843048095703125 iterations=20 resident_cuda_us=758.491150 +rc=0 +====run=1 exe=aten_fp16_gemv_trans_cpu +kernel=aten_fp16_gemv_trans_cpu correctness=PASS max_abs=4.3392181396484375e-05 max_rel=8.6217938438954985e-06 +kernel=aten_fp16_gemv_trans_cpu iterations=5 raised_gpu_us=132558.540814 +rc=0 +====run=1 exe=aten_fp16_gemv_trans_cpu_resident +kernel=aten_fp16_gemv_trans_cpu correctness=PASS max_abs=4.3392181396484375e-05 iterations=20 resident_cuda_us=794.176025 +rc=0 +====run=1 exe=aten_gelu_cpu_tanh +kernel=aten_gelu_cpu_tanh correctness=PASS max_abs=7.4505805969238281e-09 max_rel=7.4505805969238281e-09 +kernel=aten_gelu_cpu_tanh iterations=5 raised_gpu_us=13283.609599 +rc=0 +====run=1 exe=aten_linear_combination_cpu +kernel=aten_linear_combination_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_linear_combination_cpu iterations=5 raised_gpu_us=140788.787231 +rc=0 +====run=1 exe=aten_linear_combination_cpu_resident +kernel=aten_linear_combination_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=895.083191 +rc=0 +====run=1 exe=aten_narrow_copy_dense_cpu +kernel=aten_narrow_copy_dense_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_narrow_copy_dense_cpu iterations=5 raised_gpu_us=4912.147205 +rc=0 +====run=1 exe=aten_narrow_copy_dense_cpu_resident +kernel=aten_narrow_copy_dense_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=440.830414 +rc=0 +====run=1 exe=aten_nested_clone_cpu +kernel=aten_nested_clone_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_nested_clone_cpu iterations=5 raised_gpu_us=6798.630394 +rc=0 +====run=1 exe=aten_nested_clone_cpu_resident +kernel=aten_nested_clone_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=697.160034 +rc=0 +====run=1 exe=aten_nested_matmul_broadcast_cpu +kernel=aten_nested_matmul_broadcast_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_nested_matmul_broadcast_cpu iterations=5 raised_gpu_us=5853.804806 +rc=0 +====run=1 exe=aten_nested_matmul_broadcast_cpu_resident +kernel=aten_nested_matmul_broadcast_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=176.078400 +rc=0 +====run=1 exe=aten_nested_squeeze_cpu +kernel=aten_nested_squeeze_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_nested_squeeze_cpu iterations=5 raised_gpu_us=6800.063979 +rc=0 +====run=1 exe=aten_nested_squeeze_cpu_resident +kernel=aten_nested_squeeze_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=697.612793 +rc=0 +====run=1 exe=aten_outer +kernel=aten_outer correctness=PASS max_abs=0 max_rel=0 +kernel=aten_outer iterations=5 raised_gpu_us=96177.676786 +rc=0 +====run=1 exe=aten_outer_resident +kernel=aten_outer correctness=PASS max_abs=0 iterations=20 resident_cuda_us=3810.537842 +rc=0 +====run=1 exe=aten_slow_conv3d_forward_cpu +kernel=aten_slow_conv3d_forward_cpu correctness=PASS max_abs=0.0001754462718963623 max_rel=0.0001754462718963623 +kernel=aten_slow_conv3d_forward_cpu iterations=5 raised_gpu_us=729.017612 +rc=0 +====run=1 exe=aten_slow_conv3d_forward_cpu_resident +kernel=aten_slow_conv3d_forward_cpu correctness=PASS max_abs=0.0001754462718963623 iterations=20 resident_cuda_us=363.286407 +rc=0 +====run=1 exe=aten_unbind_copy_cpu +kernel=aten_unbind_copy_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_unbind_copy_cpu iterations=5 raised_gpu_us=6783.238426 +rc=0 +====run=1 exe=aten_unbind_copy_cpu_resident +kernel=aten_unbind_copy_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=697.944031 +rc=0 +====run=1 exe=aten_zeros_cpu +kernel=aten_zeros_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_zeros_cpu iterations=5 raised_gpu_us=2252.409607 +rc=0 +====run=1 exe=aten_zeros_cpu_resident +kernel=aten_zeros_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=374.590393 +rc=0 diff --git a/issues/aten_c_kernels/silicon_results/logs/full_match_large_run_2.log b/issues/aten_c_kernels/silicon_results/logs/full_match_large_run_2.log new file mode 100644 index 000000000000..7e8ea0c5f5a1 --- /dev/null +++ b/issues/aten_c_kernels/silicon_results/logs/full_match_large_run_2.log @@ -0,0 +1,200 @@ +====run=2 exe=aten_as_complex_cpu +kernel=aten_as_complex_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_as_complex_cpu iterations=5 raised_gpu_us=49286.361597 +rc=0 +====run=2 exe=aten_as_complex_cpu_resident +kernel=aten_as_complex_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=27396.021484 +rc=0 +====run=2 exe=aten_bf16_dot_cpu +kernel=aten_bf16_dot_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_bf16_dot_cpu iterations=5 raised_gpu_us=860.857591 +rc=0 +====run=2 exe=aten_bf16_dot_cpu_resident +kernel=aten_bf16_dot_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=764.019165 +rc=0 +====run=2 exe=aten_bf16_gemv_trans_cpu +kernel=aten_bf16_gemv_trans_cpu correctness=PASS max_abs=4.3392181396484375e-05 max_rel=8.6217938438954985e-06 +kernel=aten_bf16_gemv_trans_cpu iterations=5 raised_gpu_us=131550.726388 +rc=0 +====run=2 exe=aten_bf16_gemv_trans_cpu_resident +kernel=aten_bf16_gemv_trans_cpu correctness=PASS max_abs=4.3392181396484375e-05 iterations=20 resident_cuda_us=792.595215 +rc=0 +====run=2 exe=aten_blas_copy_cpu +kernel=aten_blas_copy_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_blas_copy_cpu iterations=5 raised_gpu_us=6781.152030 +rc=0 +====run=2 exe=aten_blas_copy_cpu_resident +kernel=aten_blas_copy_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=697.302368 +rc=0 +====run=2 exe=aten_blas_dot_naive_cpu +kernel=aten_blas_dot_naive_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_blas_dot_naive_cpu iterations=5 raised_gpu_us=858.687982 +rc=0 +====run=2 exe=aten_blas_dot_naive_cpu_resident +kernel=aten_blas_dot_naive_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=763.783997 +rc=0 +====run=2 exe=aten_blas_gemv_generic_cpu +kernel=aten_blas_gemv_generic_cpu correctness=PASS max_abs=0.000843048095703125 max_rel=1.7227638058081928e-05 +kernel=aten_blas_gemv_generic_cpu iterations=5 raised_gpu_us=131270.528026 +rc=0 +====run=2 exe=aten_blas_gemv_generic_cpu_resident +kernel=aten_blas_gemv_generic_cpu correctness=PASS max_abs=0.000843048095703125 iterations=20 resident_cuda_us=758.811157 +rc=0 +====run=2 exe=aten_cat_serial_cpu +kernel=aten_cat_serial_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_cat_serial_cpu iterations=5 raised_gpu_us=6858.604774 +rc=0 +====run=2 exe=aten_cat_serial_cpu_resident +kernel=aten_cat_serial_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=701.761597 +rc=0 +====run=2 exe=aten_complex_scalarized +kernel=aten_complex_scalarized correctness=PASS max_abs=0 max_rel=0 +kernel=aten_complex_scalarized iterations=5 raised_gpu_us=6877.004821 +rc=0 +====run=2 exe=aten_complex_scalarized_resident +kernel=aten_complex_scalarized correctness=PASS max_abs=0 iterations=20 resident_cuda_us=700.889587 +rc=0 +====run=2 exe=aten_conv3d +kernel=aten_conv3d correctness=PASS max_abs=0.00017541646957397461 max_rel=0.00017541646957397461 +kernel=aten_conv3d iterations=5 raised_gpu_us=880.415970 +rc=0 +====run=2 exe=aten_conv3d_resident +kernel=aten_conv3d correctness=PASS max_abs=0.00017541646957397461 iterations=20 resident_cuda_us=446.788757 +rc=0 +====run=2 exe=aten_conv_transpose3d_backward_cpu +kernel=aten_conv_transpose3d_backward_cpu correctness=PASS max_abs=0.00020104646682739258 max_rel=0.00020104646682739258 +kernel=aten_conv_transpose3d_backward_cpu iterations=5 raised_gpu_us=759.596797 +rc=0 +====run=2 exe=aten_conv_transpose3d_backward_cpu_resident +kernel=aten_conv_transpose3d_backward_cpu correctness=PASS max_abs=0.00020104646682739258 iterations=20 resident_cuda_us=449.039978 +rc=0 +====run=2 exe=aten_copy_cpu +kernel=aten_copy_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_copy_cpu iterations=5 raised_gpu_us=6846.035179 +rc=0 +====run=2 exe=aten_copy_cpu_resident +kernel=aten_copy_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=695.990417 +rc=0 +====run=2 exe=aten_copy_tensor_array_cpu +kernel=aten_copy_tensor_array_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_copy_tensor_array_cpu iterations=5 raised_gpu_us=6855.795207 +rc=0 +====run=2 exe=aten_copy_tensor_array_cpu_resident +kernel=aten_copy_tensor_array_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=697.036743 +rc=0 +====run=2 exe=aten_fast_cat_dim0_cpu +kernel=aten_fast_cat_dim0_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_fast_cat_dim0_cpu iterations=5 raised_gpu_us=6833.747216 +rc=0 +====run=2 exe=aten_fast_cat_dim0_cpu_resident +kernel=aten_fast_cat_dim0_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=696.750366 +rc=0 +====run=2 exe=aten_flatten_nd_linear_cpu +kernel=aten_flatten_nd_linear_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_flatten_nd_linear_cpu iterations=5 raised_gpu_us=5835.564760 +rc=0 +====run=2 exe=aten_flatten_nd_linear_cpu_resident +kernel=aten_flatten_nd_linear_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=177.745605 +rc=0 +====run=2 exe=aten_fp16_dot_cpu +kernel=aten_fp16_dot_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_fp16_dot_cpu iterations=5 raised_gpu_us=858.368026 +rc=0 +====run=2 exe=aten_fp16_dot_cpu_resident +kernel=aten_fp16_dot_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=763.676819 +rc=0 +====run=2 exe=aten_fp16_gemv_f16arith_cpu +kernel=aten_fp16_gemv_f16arith_cpu correctness=PASS max_abs=0.000843048095703125 max_rel=1.7227638058081928e-05 +kernel=aten_fp16_gemv_f16arith_cpu iterations=5 raised_gpu_us=131869.497616 +rc=0 +====run=2 exe=aten_fp16_gemv_f16arith_cpu_resident +kernel=aten_fp16_gemv_f16arith_cpu correctness=PASS max_abs=0.000843048095703125 iterations=20 resident_cuda_us=758.612854 +rc=0 +====run=2 exe=aten_fp16_gemv_f32arith_cpu +kernel=aten_fp16_gemv_f32arith_cpu correctness=PASS max_abs=0.000843048095703125 max_rel=1.7227638058081928e-05 +kernel=aten_fp16_gemv_f32arith_cpu iterations=5 raised_gpu_us=131109.555205 +rc=0 +====run=2 exe=aten_fp16_gemv_f32arith_cpu_resident +kernel=aten_fp16_gemv_f32arith_cpu correctness=PASS max_abs=0.000843048095703125 iterations=20 resident_cuda_us=758.251160 +rc=0 +====run=2 exe=aten_fp16_gemv_notrans_cpu +kernel=aten_fp16_gemv_notrans_cpu correctness=PASS max_abs=0.000843048095703125 max_rel=1.7227638058081928e-05 +kernel=aten_fp16_gemv_notrans_cpu iterations=5 raised_gpu_us=131065.881625 +rc=0 +====run=2 exe=aten_fp16_gemv_notrans_cpu_resident +kernel=aten_fp16_gemv_notrans_cpu correctness=PASS max_abs=0.000843048095703125 iterations=20 resident_cuda_us=758.198364 +rc=0 +====run=2 exe=aten_fp16_gemv_trans_cpu +kernel=aten_fp16_gemv_trans_cpu correctness=PASS max_abs=4.3392181396484375e-05 max_rel=8.6217938438954985e-06 +kernel=aten_fp16_gemv_trans_cpu iterations=5 raised_gpu_us=131274.880003 +rc=0 +====run=2 exe=aten_fp16_gemv_trans_cpu_resident +kernel=aten_fp16_gemv_trans_cpu correctness=PASS max_abs=4.3392181396484375e-05 iterations=20 resident_cuda_us=793.486450 +rc=0 +====run=2 exe=aten_gelu_cpu_tanh +kernel=aten_gelu_cpu_tanh correctness=PASS max_abs=7.4505805969238281e-09 max_rel=7.4505805969238281e-09 +kernel=aten_gelu_cpu_tanh iterations=5 raised_gpu_us=13309.574407 +rc=0 +====run=2 exe=aten_linear_combination_cpu +kernel=aten_linear_combination_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_linear_combination_cpu iterations=5 raised_gpu_us=139998.816000 +rc=0 +====run=2 exe=aten_linear_combination_cpu_resident +kernel=aten_linear_combination_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=892.532837 +rc=0 +====run=2 exe=aten_narrow_copy_dense_cpu +kernel=aten_narrow_copy_dense_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_narrow_copy_dense_cpu iterations=5 raised_gpu_us=4881.964810 +rc=0 +====run=2 exe=aten_narrow_copy_dense_cpu_resident +kernel=aten_narrow_copy_dense_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=435.326355 +rc=0 +====run=2 exe=aten_nested_clone_cpu +kernel=aten_nested_clone_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_nested_clone_cpu iterations=5 raised_gpu_us=6793.510402 +rc=0 +====run=2 exe=aten_nested_clone_cpu_resident +kernel=aten_nested_clone_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=695.646362 +rc=0 +====run=2 exe=aten_nested_matmul_broadcast_cpu +kernel=aten_nested_matmul_broadcast_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_nested_matmul_broadcast_cpu iterations=5 raised_gpu_us=5811.590422 +rc=0 +====run=2 exe=aten_nested_matmul_broadcast_cpu_resident +kernel=aten_nested_matmul_broadcast_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=176.496002 +rc=0 +====run=2 exe=aten_nested_squeeze_cpu +kernel=aten_nested_squeeze_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_nested_squeeze_cpu iterations=5 raised_gpu_us=6794.816023 +rc=0 +====run=2 exe=aten_nested_squeeze_cpu_resident +kernel=aten_nested_squeeze_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=695.518433 +rc=0 +====run=2 exe=aten_outer +kernel=aten_outer correctness=PASS max_abs=0 max_rel=0 +kernel=aten_outer iterations=5 raised_gpu_us=95524.895983 +rc=0 +====run=2 exe=aten_outer_resident +kernel=aten_outer correctness=PASS max_abs=0 iterations=20 resident_cuda_us=3809.686279 +rc=0 +====run=2 exe=aten_slow_conv3d_forward_cpu +kernel=aten_slow_conv3d_forward_cpu correctness=PASS max_abs=0.0001754462718963623 max_rel=0.0001754462718963623 +kernel=aten_slow_conv3d_forward_cpu iterations=5 raised_gpu_us=724.435179 +rc=0 +====run=2 exe=aten_slow_conv3d_forward_cpu_resident +kernel=aten_slow_conv3d_forward_cpu correctness=PASS max_abs=0.0001754462718963623 iterations=20 resident_cuda_us=364.764832 +rc=0 +====run=2 exe=aten_unbind_copy_cpu +kernel=aten_unbind_copy_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_unbind_copy_cpu iterations=5 raised_gpu_us=6789.606391 +rc=0 +====run=2 exe=aten_unbind_copy_cpu_resident +kernel=aten_unbind_copy_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=702.041626 +rc=0 +====run=2 exe=aten_zeros_cpu +kernel=aten_zeros_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_zeros_cpu iterations=5 raised_gpu_us=2252.172818 +rc=0 +====run=2 exe=aten_zeros_cpu_resident +kernel=aten_zeros_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=374.724792 +rc=0 diff --git a/issues/aten_c_kernels/silicon_results/logs/full_match_large_run_3.log b/issues/aten_c_kernels/silicon_results/logs/full_match_large_run_3.log new file mode 100644 index 000000000000..53a0a1306479 --- /dev/null +++ b/issues/aten_c_kernels/silicon_results/logs/full_match_large_run_3.log @@ -0,0 +1,200 @@ +====run=3 exe=aten_as_complex_cpu +kernel=aten_as_complex_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_as_complex_cpu iterations=5 raised_gpu_us=49321.433622 +rc=0 +====run=3 exe=aten_as_complex_cpu_resident +kernel=aten_as_complex_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=27387.167969 +rc=0 +====run=3 exe=aten_bf16_dot_cpu +kernel=aten_bf16_dot_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_bf16_dot_cpu iterations=5 raised_gpu_us=858.393591 +rc=0 +====run=3 exe=aten_bf16_dot_cpu_resident +kernel=aten_bf16_dot_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=763.996765 +rc=0 +====run=3 exe=aten_bf16_gemv_trans_cpu +kernel=aten_bf16_gemv_trans_cpu correctness=PASS max_abs=4.3392181396484375e-05 max_rel=8.6217938438954985e-06 +kernel=aten_bf16_gemv_trans_cpu iterations=5 raised_gpu_us=131473.228801 +rc=0 +====run=3 exe=aten_bf16_gemv_trans_cpu_resident +kernel=aten_bf16_gemv_trans_cpu correctness=PASS max_abs=4.3392181396484375e-05 iterations=20 resident_cuda_us=793.395142 +rc=0 +====run=3 exe=aten_blas_copy_cpu +kernel=aten_blas_copy_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_blas_copy_cpu iterations=5 raised_gpu_us=6789.318426 +rc=0 +====run=3 exe=aten_blas_copy_cpu_resident +kernel=aten_blas_copy_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=695.982422 +rc=0 +====run=3 exe=aten_blas_dot_naive_cpu +kernel=aten_blas_dot_naive_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_blas_dot_naive_cpu iterations=5 raised_gpu_us=859.955186 +rc=0 +====run=3 exe=aten_blas_dot_naive_cpu_resident +kernel=aten_blas_dot_naive_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=763.835205 +rc=0 +====run=3 exe=aten_blas_gemv_generic_cpu +kernel=aten_blas_gemv_generic_cpu correctness=PASS max_abs=0.000843048095703125 max_rel=1.7227638058081928e-05 +kernel=aten_blas_gemv_generic_cpu iterations=5 raised_gpu_us=132122.124825 +rc=0 +====run=3 exe=aten_blas_gemv_generic_cpu_resident +kernel=aten_blas_gemv_generic_cpu correctness=PASS max_abs=0.000843048095703125 iterations=20 resident_cuda_us=758.147156 +rc=0 +====run=3 exe=aten_cat_serial_cpu +kernel=aten_cat_serial_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_cat_serial_cpu iterations=5 raised_gpu_us=6830.624025 +rc=0 +====run=3 exe=aten_cat_serial_cpu_resident +kernel=aten_cat_serial_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=700.267212 +rc=0 +====run=3 exe=aten_complex_scalarized +kernel=aten_complex_scalarized correctness=PASS max_abs=0 max_rel=0 +kernel=aten_complex_scalarized iterations=5 raised_gpu_us=6823.833613 +rc=0 +====run=3 exe=aten_complex_scalarized_resident +kernel=aten_complex_scalarized correctness=PASS max_abs=0 iterations=20 resident_cuda_us=700.574402 +rc=0 +====run=3 exe=aten_conv3d +kernel=aten_conv3d correctness=PASS max_abs=0.00017541646957397461 max_rel=0.00017541646957397461 +kernel=aten_conv3d iterations=5 raised_gpu_us=889.433594 +rc=0 +====run=3 exe=aten_conv3d_resident +kernel=aten_conv3d correctness=PASS max_abs=0.00017541646957397461 iterations=20 resident_cuda_us=447.875183 +rc=0 +====run=3 exe=aten_conv_transpose3d_backward_cpu +kernel=aten_conv_transpose3d_backward_cpu correctness=PASS max_abs=0.00020104646682739258 max_rel=0.00020104646682739258 +kernel=aten_conv_transpose3d_backward_cpu iterations=5 raised_gpu_us=757.100806 +rc=0 +====run=3 exe=aten_conv_transpose3d_backward_cpu_resident +kernel=aten_conv_transpose3d_backward_cpu correctness=PASS max_abs=0.00020104646682739258 iterations=20 resident_cuda_us=445.305573 +rc=0 +====run=3 exe=aten_copy_cpu +kernel=aten_copy_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_copy_cpu iterations=5 raised_gpu_us=6809.145585 +rc=0 +====run=3 exe=aten_copy_cpu_resident +kernel=aten_copy_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=695.895996 +rc=0 +====run=3 exe=aten_copy_tensor_array_cpu +kernel=aten_copy_tensor_array_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_copy_tensor_array_cpu iterations=5 raised_gpu_us=6798.252789 +rc=0 +====run=3 exe=aten_copy_tensor_array_cpu_resident +kernel=aten_copy_tensor_array_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=695.919983 +rc=0 +====run=3 exe=aten_fast_cat_dim0_cpu +kernel=aten_fast_cat_dim0_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_fast_cat_dim0_cpu iterations=5 raised_gpu_us=6817.343971 +rc=0 +====run=3 exe=aten_fast_cat_dim0_cpu_resident +kernel=aten_fast_cat_dim0_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=696.444763 +rc=0 +====run=3 exe=aten_flatten_nd_linear_cpu +kernel=aten_flatten_nd_linear_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_flatten_nd_linear_cpu iterations=5 raised_gpu_us=5868.844781 +rc=0 +====run=3 exe=aten_flatten_nd_linear_cpu_resident +kernel=aten_flatten_nd_linear_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=174.992004 +rc=0 +====run=3 exe=aten_fp16_dot_cpu +kernel=aten_fp16_dot_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_fp16_dot_cpu iterations=5 raised_gpu_us=858.105626 +rc=0 +====run=3 exe=aten_fp16_dot_cpu_resident +kernel=aten_fp16_dot_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=764.278442 +rc=0 +====run=3 exe=aten_fp16_gemv_f16arith_cpu +kernel=aten_fp16_gemv_f16arith_cpu correctness=PASS max_abs=0.000843048095703125 max_rel=1.7227638058081928e-05 +kernel=aten_fp16_gemv_f16arith_cpu iterations=5 raised_gpu_us=132921.286440 +rc=0 +====run=3 exe=aten_fp16_gemv_f16arith_cpu_resident +kernel=aten_fp16_gemv_f16arith_cpu correctness=PASS max_abs=0.000843048095703125 iterations=20 resident_cuda_us=758.161560 +rc=0 +====run=3 exe=aten_fp16_gemv_f32arith_cpu +kernel=aten_fp16_gemv_f32arith_cpu correctness=PASS max_abs=0.000843048095703125 max_rel=1.7227638058081928e-05 +kernel=aten_fp16_gemv_f32arith_cpu iterations=5 raised_gpu_us=131792.767998 +rc=0 +====run=3 exe=aten_fp16_gemv_f32arith_cpu_resident +kernel=aten_fp16_gemv_f32arith_cpu correctness=PASS max_abs=0.000843048095703125 iterations=20 resident_cuda_us=758.652771 +rc=0 +====run=3 exe=aten_fp16_gemv_notrans_cpu +kernel=aten_fp16_gemv_notrans_cpu correctness=PASS max_abs=0.000843048095703125 max_rel=1.7227638058081928e-05 +kernel=aten_fp16_gemv_notrans_cpu iterations=5 raised_gpu_us=131711.859209 +rc=0 +====run=3 exe=aten_fp16_gemv_notrans_cpu_resident +kernel=aten_fp16_gemv_notrans_cpu correctness=PASS max_abs=0.000843048095703125 iterations=20 resident_cuda_us=758.255981 +rc=0 +====run=3 exe=aten_fp16_gemv_trans_cpu +kernel=aten_fp16_gemv_trans_cpu correctness=PASS max_abs=4.3392181396484375e-05 max_rel=8.6217938438954985e-06 +kernel=aten_fp16_gemv_trans_cpu iterations=5 raised_gpu_us=131673.113629 +rc=0 +====run=3 exe=aten_fp16_gemv_trans_cpu_resident +kernel=aten_fp16_gemv_trans_cpu correctness=PASS max_abs=4.3392181396484375e-05 iterations=20 resident_cuda_us=792.694397 +rc=0 +====run=3 exe=aten_gelu_cpu_tanh +kernel=aten_gelu_cpu_tanh correctness=PASS max_abs=7.4505805969238281e-09 max_rel=7.4505805969238281e-09 +kernel=aten_gelu_cpu_tanh iterations=5 raised_gpu_us=13260.614406 +rc=0 +====run=3 exe=aten_linear_combination_cpu +kernel=aten_linear_combination_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_linear_combination_cpu iterations=5 raised_gpu_us=139820.294408 +rc=0 +====run=3 exe=aten_linear_combination_cpu_resident +kernel=aten_linear_combination_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=889.011230 +rc=0 +====run=3 exe=aten_narrow_copy_dense_cpu +kernel=aten_narrow_copy_dense_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_narrow_copy_dense_cpu iterations=5 raised_gpu_us=4897.503974 +rc=0 +====run=3 exe=aten_narrow_copy_dense_cpu_resident +kernel=aten_narrow_copy_dense_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=439.467194 +rc=0 +====run=3 exe=aten_nested_clone_cpu +kernel=aten_nested_clone_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_nested_clone_cpu iterations=5 raised_gpu_us=6792.185595 +rc=0 +====run=3 exe=aten_nested_clone_cpu_resident +kernel=aten_nested_clone_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=695.862427 +rc=0 +====run=3 exe=aten_nested_matmul_broadcast_cpu +kernel=aten_nested_matmul_broadcast_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_nested_matmul_broadcast_cpu iterations=5 raised_gpu_us=5861.004768 +rc=0 +====run=3 exe=aten_nested_matmul_broadcast_cpu_resident +kernel=aten_nested_matmul_broadcast_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=175.089600 +rc=0 +====run=3 exe=aten_nested_squeeze_cpu +kernel=aten_nested_squeeze_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_nested_squeeze_cpu iterations=5 raised_gpu_us=6820.204807 +rc=0 +====run=3 exe=aten_nested_squeeze_cpu_resident +kernel=aten_nested_squeeze_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=696.092773 +rc=0 +====run=3 exe=aten_outer +kernel=aten_outer correctness=PASS max_abs=0 max_rel=0 +kernel=aten_outer iterations=5 raised_gpu_us=95861.388789 +rc=0 +====run=3 exe=aten_outer_resident +kernel=aten_outer correctness=PASS max_abs=0 iterations=20 resident_cuda_us=3810.022217 +rc=0 +====run=3 exe=aten_slow_conv3d_forward_cpu +kernel=aten_slow_conv3d_forward_cpu correctness=PASS max_abs=0.0001754462718963623 max_rel=0.0001754462718963623 +kernel=aten_slow_conv3d_forward_cpu iterations=5 raised_gpu_us=720.614381 +rc=0 +====run=3 exe=aten_slow_conv3d_forward_cpu_resident +kernel=aten_slow_conv3d_forward_cpu correctness=PASS max_abs=0.0001754462718963623 iterations=20 resident_cuda_us=363.052795 +rc=0 +====run=3 exe=aten_unbind_copy_cpu +kernel=aten_unbind_copy_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_unbind_copy_cpu iterations=5 raised_gpu_us=6815.814367 +rc=0 +====run=3 exe=aten_unbind_copy_cpu_resident +kernel=aten_unbind_copy_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=697.712036 +rc=0 +====run=3 exe=aten_zeros_cpu +kernel=aten_zeros_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_zeros_cpu iterations=5 raised_gpu_us=2253.414411 +rc=0 +====run=3 exe=aten_zeros_cpu_resident +kernel=aten_zeros_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=374.880005 +rc=0 diff --git a/issues/aten_c_kernels/silicon_results/logs/full_match_large_run_4.log b/issues/aten_c_kernels/silicon_results/logs/full_match_large_run_4.log new file mode 100644 index 000000000000..1fe40d5838a6 --- /dev/null +++ b/issues/aten_c_kernels/silicon_results/logs/full_match_large_run_4.log @@ -0,0 +1,200 @@ +====run=4 exe=aten_as_complex_cpu +kernel=aten_as_complex_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_as_complex_cpu iterations=5 raised_gpu_us=49374.342384 +rc=0 +====run=4 exe=aten_as_complex_cpu_resident +kernel=aten_as_complex_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=27376.496094 +rc=0 +====run=4 exe=aten_bf16_dot_cpu +kernel=aten_bf16_dot_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_bf16_dot_cpu iterations=5 raised_gpu_us=857.593631 +rc=0 +====run=4 exe=aten_bf16_dot_cpu_resident +kernel=aten_bf16_dot_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=765.609619 +rc=0 +====run=4 exe=aten_bf16_gemv_trans_cpu +kernel=aten_bf16_gemv_trans_cpu correctness=PASS max_abs=4.3392181396484375e-05 max_rel=8.6217938438954985e-06 +kernel=aten_bf16_gemv_trans_cpu iterations=5 raised_gpu_us=131067.161635 +rc=0 +====run=4 exe=aten_bf16_gemv_trans_cpu_resident +kernel=aten_bf16_gemv_trans_cpu correctness=PASS max_abs=4.3392181396484375e-05 iterations=20 resident_cuda_us=793.521606 +rc=0 +====run=4 exe=aten_blas_copy_cpu +kernel=aten_blas_copy_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_blas_copy_cpu iterations=5 raised_gpu_us=6789.798383 +rc=0 +====run=4 exe=aten_blas_copy_cpu_resident +kernel=aten_blas_copy_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=697.783997 +rc=0 +====run=4 exe=aten_blas_dot_naive_cpu +kernel=aten_blas_dot_naive_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_blas_dot_naive_cpu iterations=5 raised_gpu_us=859.673601 +rc=0 +====run=4 exe=aten_blas_dot_naive_cpu_resident +kernel=aten_blas_dot_naive_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=767.897583 +rc=0 +====run=4 exe=aten_blas_gemv_generic_cpu +kernel=aten_blas_gemv_generic_cpu correctness=PASS max_abs=0.000843048095703125 max_rel=1.7227638058081928e-05 +kernel=aten_blas_gemv_generic_cpu iterations=5 raised_gpu_us=130748.627195 +rc=0 +====run=4 exe=aten_blas_gemv_generic_cpu_resident +kernel=aten_blas_gemv_generic_cpu correctness=PASS max_abs=0.000843048095703125 iterations=20 resident_cuda_us=758.670349 +rc=0 +====run=4 exe=aten_cat_serial_cpu +kernel=aten_cat_serial_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_cat_serial_cpu iterations=5 raised_gpu_us=6855.807966 +rc=0 +====run=4 exe=aten_cat_serial_cpu_resident +kernel=aten_cat_serial_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=703.883179 +rc=0 +====run=4 exe=aten_complex_scalarized +kernel=aten_complex_scalarized correctness=PASS max_abs=0 max_rel=0 +kernel=aten_complex_scalarized iterations=5 raised_gpu_us=6809.024001 +rc=0 +====run=4 exe=aten_complex_scalarized_resident +kernel=aten_complex_scalarized correctness=PASS max_abs=0 iterations=20 resident_cuda_us=706.017578 +rc=0 +====run=4 exe=aten_conv3d +kernel=aten_conv3d correctness=PASS max_abs=0.00017541646957397461 max_rel=0.00017541646957397461 +kernel=aten_conv3d iterations=5 raised_gpu_us=888.787163 +rc=0 +====run=4 exe=aten_conv3d_resident +kernel=aten_conv3d correctness=PASS max_abs=0.00017541646957397461 iterations=20 resident_cuda_us=447.262390 +rc=0 +====run=4 exe=aten_conv_transpose3d_backward_cpu +kernel=aten_conv_transpose3d_backward_cpu correctness=PASS max_abs=0.00020104646682739258 max_rel=0.00020104646682739258 +kernel=aten_conv_transpose3d_backward_cpu iterations=5 raised_gpu_us=762.112020 +rc=0 +====run=4 exe=aten_conv_transpose3d_backward_cpu_resident +kernel=aten_conv_transpose3d_backward_cpu correctness=PASS max_abs=0.00020104646682739258 iterations=20 resident_cuda_us=450.630371 +rc=0 +====run=4 exe=aten_copy_cpu +kernel=aten_copy_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_copy_cpu iterations=5 raised_gpu_us=6793.926423 +rc=0 +====run=4 exe=aten_copy_cpu_resident +kernel=aten_copy_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=700.593628 +rc=0 +====run=4 exe=aten_copy_tensor_array_cpu +kernel=aten_copy_tensor_array_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_copy_tensor_array_cpu iterations=5 raised_gpu_us=6792.851212 +rc=0 +====run=4 exe=aten_copy_tensor_array_cpu_resident +kernel=aten_copy_tensor_array_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=701.948792 +rc=0 +====run=4 exe=aten_fast_cat_dim0_cpu +kernel=aten_fast_cat_dim0_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_fast_cat_dim0_cpu iterations=5 raised_gpu_us=6815.904006 +rc=0 +====run=4 exe=aten_fast_cat_dim0_cpu_resident +kernel=aten_fast_cat_dim0_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=705.291199 +rc=0 +====run=4 exe=aten_flatten_nd_linear_cpu +kernel=aten_flatten_nd_linear_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_flatten_nd_linear_cpu iterations=5 raised_gpu_us=5881.875195 +rc=0 +====run=4 exe=aten_flatten_nd_linear_cpu_resident +kernel=aten_flatten_nd_linear_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=177.688004 +rc=0 +====run=4 exe=aten_fp16_dot_cpu +kernel=aten_fp16_dot_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_fp16_dot_cpu iterations=5 raised_gpu_us=860.953610 +rc=0 +====run=4 exe=aten_fp16_dot_cpu_resident +kernel=aten_fp16_dot_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=766.012817 +rc=0 +====run=4 exe=aten_fp16_gemv_f16arith_cpu +kernel=aten_fp16_gemv_f16arith_cpu correctness=PASS max_abs=0.000843048095703125 max_rel=1.7227638058081928e-05 +kernel=aten_fp16_gemv_f16arith_cpu iterations=5 raised_gpu_us=131057.926407 +rc=0 +====run=4 exe=aten_fp16_gemv_f16arith_cpu_resident +kernel=aten_fp16_gemv_f16arith_cpu correctness=PASS max_abs=0.000843048095703125 iterations=20 resident_cuda_us=759.084839 +rc=0 +====run=4 exe=aten_fp16_gemv_f32arith_cpu +kernel=aten_fp16_gemv_f32arith_cpu correctness=PASS max_abs=0.000843048095703125 max_rel=1.7227638058081928e-05 +kernel=aten_fp16_gemv_f32arith_cpu iterations=5 raised_gpu_us=131485.100789 +rc=0 +====run=4 exe=aten_fp16_gemv_f32arith_cpu_resident +kernel=aten_fp16_gemv_f32arith_cpu correctness=PASS max_abs=0.000843048095703125 iterations=20 resident_cuda_us=760.508850 +rc=0 +====run=4 exe=aten_fp16_gemv_notrans_cpu +kernel=aten_fp16_gemv_notrans_cpu correctness=PASS max_abs=0.000843048095703125 max_rel=1.7227638058081928e-05 +kernel=aten_fp16_gemv_notrans_cpu iterations=5 raised_gpu_us=131555.417599 +rc=0 +====run=4 exe=aten_fp16_gemv_notrans_cpu_resident +kernel=aten_fp16_gemv_notrans_cpu correctness=PASS max_abs=0.000843048095703125 iterations=20 resident_cuda_us=758.366394 +rc=0 +====run=4 exe=aten_fp16_gemv_trans_cpu +kernel=aten_fp16_gemv_trans_cpu correctness=PASS max_abs=4.3392181396484375e-05 max_rel=8.6217938438954985e-06 +kernel=aten_fp16_gemv_trans_cpu iterations=5 raised_gpu_us=131346.623972 +rc=0 +====run=4 exe=aten_fp16_gemv_trans_cpu_resident +kernel=aten_fp16_gemv_trans_cpu correctness=PASS max_abs=4.3392181396484375e-05 iterations=20 resident_cuda_us=794.387207 +rc=0 +====run=4 exe=aten_gelu_cpu_tanh +kernel=aten_gelu_cpu_tanh correctness=PASS max_abs=7.4505805969238281e-09 max_rel=7.4505805969238281e-09 +kernel=aten_gelu_cpu_tanh iterations=5 raised_gpu_us=13367.391983 +rc=0 +====run=4 exe=aten_linear_combination_cpu +kernel=aten_linear_combination_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_linear_combination_cpu iterations=5 raised_gpu_us=140224.940795 +rc=0 +====run=4 exe=aten_linear_combination_cpu_resident +kernel=aten_linear_combination_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=908.297668 +rc=0 +====run=4 exe=aten_narrow_copy_dense_cpu +kernel=aten_narrow_copy_dense_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_narrow_copy_dense_cpu iterations=5 raised_gpu_us=4890.854377 +rc=0 +====run=4 exe=aten_narrow_copy_dense_cpu_resident +kernel=aten_narrow_copy_dense_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=440.625641 +rc=0 +====run=4 exe=aten_nested_clone_cpu +kernel=aten_nested_clone_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_nested_clone_cpu iterations=5 raised_gpu_us=6791.392015 +rc=0 +====run=4 exe=aten_nested_clone_cpu_resident +kernel=aten_nested_clone_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=707.091187 +rc=0 +====run=4 exe=aten_nested_matmul_broadcast_cpu +kernel=aten_nested_matmul_broadcast_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_nested_matmul_broadcast_cpu iterations=5 raised_gpu_us=5949.900812 +rc=0 +====run=4 exe=aten_nested_matmul_broadcast_cpu_resident +kernel=aten_nested_matmul_broadcast_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=176.012802 +rc=0 +====run=4 exe=aten_nested_squeeze_cpu +kernel=aten_nested_squeeze_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_nested_squeeze_cpu iterations=5 raised_gpu_us=6801.740779 +rc=0 +====run=4 exe=aten_nested_squeeze_cpu_resident +kernel=aten_nested_squeeze_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=706.105591 +rc=0 +====run=4 exe=aten_outer +kernel=aten_outer correctness=PASS max_abs=0 max_rel=0 +kernel=aten_outer iterations=5 raised_gpu_us=96109.945606 +rc=0 +====run=4 exe=aten_outer_resident +kernel=aten_outer correctness=PASS max_abs=0 iterations=20 resident_cuda_us=3810.421143 +rc=0 +====run=4 exe=aten_slow_conv3d_forward_cpu +kernel=aten_slow_conv3d_forward_cpu correctness=PASS max_abs=0.0001754462718963623 max_rel=0.0001754462718963623 +kernel=aten_slow_conv3d_forward_cpu iterations=5 raised_gpu_us=718.323234 +rc=0 +====run=4 exe=aten_slow_conv3d_forward_cpu_resident +kernel=aten_slow_conv3d_forward_cpu correctness=PASS max_abs=0.0001754462718963623 iterations=20 resident_cuda_us=366.329590 +rc=0 +====run=4 exe=aten_unbind_copy_cpu +kernel=aten_unbind_copy_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_unbind_copy_cpu iterations=5 raised_gpu_us=6846.912019 +rc=0 +====run=4 exe=aten_unbind_copy_cpu_resident +kernel=aten_unbind_copy_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=708.494385 +rc=0 +====run=4 exe=aten_zeros_cpu +kernel=aten_zeros_cpu correctness=PASS max_abs=0 max_rel=0 +kernel=aten_zeros_cpu iterations=5 raised_gpu_us=2254.963201 +rc=0 +====run=4 exe=aten_zeros_cpu_resident +kernel=aten_zeros_cpu correctness=PASS max_abs=0 iterations=20 resident_cuda_us=375.071991 +rc=0 diff --git a/issues/bool_argument_i1_to_i8_min.cpp b/issues/bool_argument_i1_to_i8_min.cpp new file mode 100644 index 000000000000..3e978ea7cd75 --- /dev/null +++ b/issues/bool_argument_i1_to_i8_min.cpp @@ -0,0 +1,5 @@ +extern void takes_bool(bool); + +void bool_argument_i1_to_i8_min(void *ptr) { + takes_bool(ptr != nullptr); +} diff --git a/issues/canonicalize_crash.mlir b/issues/canonicalize_crash.mlir new file mode 100644 index 000000000000..7b6d445f7faf --- /dev/null +++ b/issues/canonicalize_crash.mlir @@ -0,0 +1,27 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.000000e-01 : f64 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<1300x1300xf32> + %alloca_0 = memref.alloca() : memref<1300x1300xf32> + affine.for %arg1 = 1 to 1299 { + affine.for %arg2 = 1 to 1299 { + %0 = affine.load %alloca_0[%arg1, %arg2] : memref<1300x1300xf32> + %1 = affine.load %alloca_0[%arg1, %arg2 - 1] : memref<1300x1300xf32> + %2 = arith.addf %0, %1 : f32 + %3 = affine.load %alloca_0[%arg1, %arg2 + 1] : memref<1300x1300xf32> + %4 = arith.addf %2, %3 : f32 + %5 = affine.load %alloca_0[%arg1 + 1, %arg2] : memref<1300x1300xf32> + %6 = arith.addf %4, %5 : f32 + %7 = affine.load %alloca_0[%arg1 - 1, %arg2] : memref<1300x1300xf32> + %8 = arith.addf %6, %7 : f32 + %9 = arith.extf %8 : f32 to f64 + %10 = arith.mulf %9, %cst : f64 + %11 = arith.truncf %10 : f64 to f32 + affine.store %11, %alloca[%arg1, %arg2] : memref<1300x1300xf32> + } + } + return %c0_i32 : i32 + } +} diff --git a/issues/cufft_runtime_smoke.c b/issues/cufft_runtime_smoke.c new file mode 100644 index 000000000000..45dd4e3aef2d --- /dev/null +++ b/issues/cufft_runtime_smoke.c @@ -0,0 +1,63 @@ +#include +#include + +#include "../runtime/polygeist_cublas_rt.h" + +static int close_double(double a, double b) { + double d = fabs(a - b); + return d < 1.0e-9; +} + +static int close_float(float a, float b) { + float d = fabsf(a - b); + return d < 1.0e-4f; +} + +int main(void) { + const double in64[8] = { + 1.0, 0.0, + 2.0, 0.0, + 0.0, 0.0, + -1.0, 0.0, + }; + const double expect64[8] = { + 2.0, 0.0, + 1.0, -3.0, + 0.0, 0.0, + 1.0, 3.0, + }; + double out64[8] = {0}; + polygeist_cufft_z2z_1d(4, 0, in64, out64); + for (int i = 0; i < 8; ++i) { + if (!close_double(out64[i], expect64[i])) { + fprintf(stderr, "z2z mismatch at %d: got %.17g expected %.17g\n", + i, out64[i], expect64[i]); + return 1; + } + } + + const float in32[8] = { + 1.0f, 0.0f, + 2.0f, 0.0f, + 0.0f, 0.0f, + -1.0f, 0.0f, + }; + const float expect32[8] = { + 2.0f, 0.0f, + 1.0f, -3.0f, + 0.0f, 0.0f, + 1.0f, 3.0f, + }; + float out32[8] = {0}; + polygeist_cufft_c2c_1d(4, 0, in32, out32); + for (int i = 0; i < 8; ++i) { + if (!close_float(out32[i], expect32[i])) { + fprintf(stderr, "c2c mismatch at %d: got %.9g expected %.9g\n", + i, out32[i], expect32[i]); + return 1; + } + } + + printf("cufft_runtime_smoke ok\n"); + return 0; +} diff --git a/issues/fft_dft1d_extracted.c b/issues/fft_dft1d_extracted.c new file mode 100644 index 000000000000..5f7b5a5a9748 --- /dev/null +++ b/issues/fft_dft1d_extracted.c @@ -0,0 +1,83 @@ +#include + +#define FFT_N 4 +#define FFT_TWOPI 6.28318530717958647692528676655900576 + +void fft_dft1d_z2z_forward(const double in[FFT_N][2], + double out[FFT_N][2]) { + for (int k = 0; k < FFT_N; ++k) { + double sum_re = 0.0; + double sum_im = 0.0; + for (int n = 0; n < FFT_N; ++n) { + double angle = -FFT_TWOPI * (double)k * (double)n / (double)FFT_N; + double c = cos(angle); + double s = sin(angle); + double ar = in[n][0]; + double ai = in[n][1]; + sum_re += ar * c - ai * s; + sum_im += ar * s + ai * c; + } + out[k][0] = sum_re; + out[k][1] = sum_im; + } +} + +void fft_dft1d_z2z_inverse(const double in[FFT_N][2], + double out[FFT_N][2]) { + for (int k = 0; k < FFT_N; ++k) { + double sum_re = 0.0; + double sum_im = 0.0; + for (int n = 0; n < FFT_N; ++n) { + double angle = FFT_TWOPI * (double)k * (double)n / (double)FFT_N; + double c = cos(angle); + double s = sin(angle); + double ar = in[n][0]; + double ai = in[n][1]; + sum_re += ar * c - ai * s; + sum_im += ar * s + ai * c; + } + out[k][0] = sum_re; + out[k][1] = sum_im; + } +} + +void fft_dft1d_z2z_forward_inplace_accum(const double in[FFT_N][2], + double out[FFT_N][2]) { + for (int k = 0; k < FFT_N; ++k) { + out[k][0] = 0.0; + out[k][1] = 0.0; + } + for (int k = 0; k < FFT_N; ++k) { + for (int n = 0; n < FFT_N; ++n) { + double angle = -FFT_TWOPI * (double)k * (double)n / (double)FFT_N; + double c = cos(angle); + double s = sin(angle); + double ar = in[n][0]; + double ai = in[n][1]; + out[k][0] += ar * c - ai * s; + out[k][1] += ar * s + ai * c; + } + } +} + +void fft_dft1d_z2z_forward_interleaved(const double in[FFT_N][2], + double out[FFT_N][2]) { + for (int k = 0; k < FFT_N; ++k) + for (int component = 0; component < 2; ++component) + out[k][component] = 0.0; + + for (int k = 0; k < FFT_N; ++k) { + for (int component = 0; component < 2; ++component) { + for (int n = 0; n < FFT_N; ++n) { + double angle = -FFT_TWOPI * (double)k * (double)n / (double)FFT_N; + double c = cos(angle); + double s = sin(angle); + double ar = in[n][0]; + double ai = in[n][1]; + double value = component == 0 ? (ar * c - ai * s) + : (ar * s + ai * c); + out[k][component] += value; + } + } + } +} diff --git a/issues/fft_dft1d_harness.c b/issues/fft_dft1d_harness.c new file mode 100644 index 000000000000..2077f613d339 --- /dev/null +++ b/issues/fft_dft1d_harness.c @@ -0,0 +1,37 @@ +#include +#include + +#define FFT_N 4 + +void fft_dft1d_z2z_forward_interleaved(const double in[FFT_N][2], + double out[FFT_N][2]); + +int main(void) { + const double in[FFT_N][2] = { + {1.0, 0.0}, + {2.0, 0.0}, + {0.0, 0.0}, + {-1.0, 0.0}, + }; + const double expected[FFT_N][2] = { + {2.0, 0.0}, + {1.0, -3.0}, + {0.0, 0.0}, + {1.0, 3.0}, + }; + double out[FFT_N][2] = {{0.0, 0.0}}; + fft_dft1d_z2z_forward_interleaved(in, out); + for (int i = 0; i < FFT_N; ++i) { + for (int c = 0; c < 2; ++c) { + double diff = fabs(out[i][c] - expected[i][c]); + if (diff > 1.0e-9) { + fprintf(stderr, + "fft mismatch at (%d,%d): got %.17g expected %.17g\n", + i, c, out[i][c], expected[i][c]); + return 1; + } + } + } + printf("fft_dft1d_interleaved ok\n"); + return 0; +} diff --git a/issues/function_pointer_conditional_min.cpp b/issues/function_pointer_conditional_min.cpp new file mode 100644 index 000000000000..395dbdfaefb3 --- /dev/null +++ b/issues/function_pointer_conditional_min.cpp @@ -0,0 +1,8 @@ +using callback_t = void (*)(void *, void *, int, char *); + +void callback_impl(void *, void *, int, char *) {} + +callback_t choose_callback(bool use_null) { + return use_null ? nullptr : callback_impl; +} + diff --git a/issues/gemv_to_gemm_probe.c b/issues/gemv_to_gemm_probe.c new file mode 100644 index 000000000000..115290e26e25 --- /dev/null +++ b/issues/gemv_to_gemm_probe.c @@ -0,0 +1,18 @@ +void batched_gemv_as_gemm(int batches, int rows, int cols, + double A[rows][cols], + double X[batches][cols], + double Y[batches][rows]) { + for (int b = 0; b < batches; ++b) { + for (int i = 0; i < rows; ++i) { + Y[b][i] = 0.0; + } + } + + for (int b = 0; b < batches; ++b) { + for (int i = 0; i < rows; ++i) { + for (int k = 0; k < cols; ++k) { + Y[b][i] += X[b][k] * A[i][k]; + } + } + } +} diff --git a/issues/ggml_alloc_signature_internal_probe.c b/issues/ggml_alloc_signature_internal_probe.c new file mode 100644 index 000000000000..71d0d7a2b60a --- /dev/null +++ b/issues/ggml_alloc_signature_internal_probe.c @@ -0,0 +1,32 @@ +#include "ggml-alloc.h" +#include "ggml-backend-impl.h" +#include "ggml.h" +#include "ggml-impl.h" + +enum ggml_status isolate_tallocr_internal( + struct ggml_tallocr * talloc, + struct ggml_tensor * tensor) { + (void)talloc; + (void)tensor; + return (enum ggml_status)0; +} + +bool isolate_gallocr_internal( + ggml_gallocr_t galloc, + struct ggml_cgraph * graph, + const int * node_buffer_ids, + const int * leaf_buffer_ids) { + (void)galloc; + (void)graph; + (void)node_buffer_ids; + (void)leaf_buffer_ids; + return false; +} + +ggml_backend_buffer_t isolate_backend_alloc_internal( + struct ggml_context * ctx, + ggml_backend_buffer_type_t buft) { + (void)ctx; + (void)buft; + return (ggml_backend_buffer_t)0; +} diff --git a/issues/ggml_alloc_signature_public_probe.c b/issues/ggml_alloc_signature_public_probe.c new file mode 100644 index 000000000000..f0bc04918bc6 --- /dev/null +++ b/issues/ggml_alloc_signature_public_probe.c @@ -0,0 +1,29 @@ +#include "ggml-alloc.h" + +enum ggml_status isolate_tallocr_public( + struct ggml_tallocr * talloc, + struct ggml_tensor * tensor) { + (void)talloc; + (void)tensor; + return (enum ggml_status)0; +} + +bool isolate_gallocr_public( + ggml_gallocr_t galloc, + struct ggml_cgraph * graph, + const int * node_buffer_ids, + const int * leaf_buffer_ids) { + (void)galloc; + (void)graph; + (void)node_buffer_ids; + (void)leaf_buffer_ids; + return false; +} + +ggml_backend_buffer_t isolate_backend_alloc_public( + struct ggml_context * ctx, + ggml_backend_buffer_type_t buft) { + (void)ctx; + (void)buft; + return (ggml_backend_buffer_t)0; +} diff --git a/issues/incomplete_record_ptr_min.cpp b/issues/incomplete_record_ptr_min.cpp new file mode 100644 index 000000000000..8227a189c457 --- /dev/null +++ b/issues/incomplete_record_ptr_min.cpp @@ -0,0 +1,8 @@ +struct Incomplete; + +struct Holder { + Incomplete *ptr; +}; + +void use_holder(Holder h) { (void)h.ptr; } + diff --git a/issues/mfem_c_kernels/.gitignore b/issues/mfem_c_kernels/.gitignore new file mode 100644 index 000000000000..397b4a7624e3 --- /dev/null +++ b/issues/mfem_c_kernels/.gitignore @@ -0,0 +1 @@ +*.log diff --git a/issues/mfem_c_kernels/MATCHING.md b/issues/mfem_c_kernels/MATCHING.md new file mode 100644 index 000000000000..2b59b32f5b6c --- /dev/null +++ b/issues/mfem_c_kernels/MATCHING.md @@ -0,0 +1,70 @@ +# MFEM normalized-kernel matcher results + +The matcher sweep is reproducible with: + +```sh +python3 scripts/correctness/mfem_match_sweep.py +``` + +It debufferizes every fully raised normalized kernel, runs the matcher in +dry-run mode, and also stores the rewritten `kernel.launch` MLIR. + +## Semantic matching result + +- normalized kernels tested: 20 +- debufferization successes: 20 +- matcher process successes: 20 +- kernels with one or more matches: 12 +- kernels without a match: 8 +- matched stage groups: 98 +- emitted `kernel.launch` operations: 98 + +Matched stage symbols: + +- 92 `cublasGemmFor1x1Conv` +- 5 `cublasDaxpby` +- 1 `cudnnAddTensor_batched` + +No match represents an entire FEM operator. All hits are individual contraction +or pointwise stages inside a larger interpolation/operator/integration graph. + +Per-kernel matched stage groups: + +- 3D curl-curl: 29 +- 3D diffusion: 14 +- 3D div-div: 12 +- 3D convection: 11 +- 3D gradient integration: 9 +- 3D gradient interpolation: 8 +- 3D mass: 5 +- 3D value interpolation: 3 +- 3D value integration: 2 +- 2D curl-curl: 2 +- 2D div-div: 2 +- 2D convection: 1 + +The eight unmatched kernels are 2D value interpolation/integration, 2D +gradient interpolation/integration, 2D mass, 2D diffusion, and 2D/3D +elasticity. + +## Executable-library legality audit + +Currently executable matches: **0**. + +The semantic matcher does not enforce the implemented ABI constraints: + +- `cublasGemmFor1x1Conv` lowering requires three rank-4 `f32` tensor bases. + MFEM uses `f64`, and matched operands include rank-3 and rank-5 tensors. +- `cublasDaxpby` lowering requires four operands (`x`, `y`, alpha, beta) and + rank-1 `f64` tensors. The MFEM rewrite emits two rank-3 operands. +- `cudnnAddTensor_batched` requires rank-4 `f32`; the MFEM stage is `f64`. + +There is also a rewrite defect for several multi-stage 3D matches: generated +tensor-cast SSA names are reused, so injecting canonical definitions or parsing +the rewritten module reports duplicate SSA definitions. + +These results are therefore useful candidate matches, not deployable CUDA +library mappings. The matcher needs an ABI/shape/type legality filter before +emission. For these tensor contractions, a general `f64` batched GEMM or +cuTENSOR-style contraction definition is a more natural backend candidate than +the current `f32` 1x1-convolution-specific entry. diff --git a/issues/mfem_c_kernels/README.md b/issues/mfem_c_kernels/README.md new file mode 100644 index 000000000000..2d4adc5df03f --- /dev/null +++ b/issues/mfem_c_kernels/README.md @@ -0,0 +1,41 @@ +# MFEM concrete C raising corpus + +This directory stores concrete C versions of numerical kernels extracted from +MFEM. It is intentionally not a collection of wrappers around MFEM: templates, +`DeviceTensor`, `Reshape`, `MFEM_FORALL`, and backend-selection macros have been +specialized away so that the remaining code is the numerical loop algorithm +seen by a compiler after C++ specialization. + +The extraction is pinned to MFEM commit +`951cf8886b9c0c33fb36a2f0ede268c8d6a0d8b5`. Every entry in `manifest.csv` +records its upstream file and symbol. Concrete tensor sizes are `D1D=4`, +`Q1D=5`, and `VDIM=2`, using `double`. Arrays use ordinary row-major C layout. + +`original/` preserves faithful, directly recognizable algorithm structure, +including local scratch arrays. If raising requires a structural rewrite, the +rewrite must be added under `normalized/` rather than replacing the original. + +Run the frontend and raising survey with: + +```sh +python3 scripts/correctness/mfem_raise_sweep.py +``` + +Validate every normalized implementation against its faithful original with: + +```sh +python3 scripts/correctness/mfem_validate_extractions.py +``` + +Run library matching on all fully raised normalized kernels with: + +```sh +python3 scripts/correctness/mfem_match_sweep.py +``` + +See `MATCHING.md` for the distinction between semantic stage matches and +currently executable ABI-valid library mappings. + +The generated MLIR and logs are placed under +`issues/mfem_c_kernels/results/`, while `summary.csv` records frontend success, +raising success, Linalg operation count, and residual loop count. diff --git a/issues/mfem_c_kernels/STATUS.md b/issues/mfem_c_kernels/STATUS.md new file mode 100644 index 000000000000..b17367b49cbe --- /dev/null +++ b/issues/mfem_c_kernels/STATUS.md @@ -0,0 +1,45 @@ +# MFEM extraction and raising status + +Upstream MFEM is pinned at `951cf8886b9c0c33fb36a2f0ede268c8d6a0d8b5`. + +The current manifest contains 40 concrete kernels: + +- 20 faithful originals: H1 value/gradient interpolation and integration, + partial-assembly mass, diffusion and convection, elasticity quadrature work, + 2D/3D H(curl) curl-curl, and 2D/3D H(div) div-div. +- 20 normalized variants covering every faithful original. These use scratch + slicing, explicit contraction stages, component specialization for staggered + spaces, and scalarized pointwise elasticity outputs. + +Current sweep result: + +- cgeist frontend: 40/40 +- affine/Linalg pipeline: 40/40 +- fully raised with no residual affine/scf loops: 20/40 +- normalized variants fully raised: 20/20 +- emitted Linalg operations: 999 +- residual loops in the 20 faithful originals: 154 + +All normalized variants are numerically equivalent to their originals. Value +and gradient maps compare exactly for the tested inputs. Across complete mass, +diffusion, convection, elasticity, curl-curl, and div-div operators, the largest +observed original-versus-normalized error is `7.2e-15`. Adjoint checks for +value/gradient maps and symmetry checks for mass, diffusion, curl-curl, and +div-div are within `1.2e-14`. + +The successful normalization is structural: scratch is indexed by component or +element and survives across explicit stages. This removes false reuse +dependencies while retaining sum factorization. It increases temporary +storage, so future lowering should recover GPU shared-memory reuse after the +high-level computation has been recognized. + +One compiler defect was isolated while doing this. See +`problems/remove_iter_args_post_reduction_use.c`: `remove-iter-args` can create +an invalid dominance relation when a reduction result is combined with a load +defined after the reduction. Splitting the pointwise multiply into its own +stage avoids the defect and better exposes the FEM pipeline. + +The planned normalization and source-coverage list is complete. Further work +should focus on making these structural normalizations automatic and lowering +the expanded logical scratch tensors back to reused GPU shared memory after +Linalg recognition. diff --git a/issues/mfem_c_kernels/application_extractions/HOST_CORRECTNESS_2026_08_03.md b/issues/mfem_c_kernels/application_extractions/HOST_CORRECTNESS_2026_08_03.md new file mode 100644 index 000000000000..0bc8c790a4f8 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/HOST_CORRECTNESS_2026_08_03.md @@ -0,0 +1,65 @@ +# MFEM larger-application correctness debug — updated 2026-08-04 + +All harness-supported executable MFEM application extractions now pass the +complete raise, debufferize, matcher, ABI-lowering, LLVM, wrapper, and runtime +pipeline on both the host CPU shim and the attached Jetson. + +Common specialization: FP64, `NE=2`, `D1D=4`, `Q1D=5`. These are deliberately +small correctness fixtures, not performance-sized GPU workloads. + +| Function | Library launches | Host gate | Warm Jetson gate | +|---|---:|---|---| +| `mfem_app_mtop_iso_elasticity_dfem_2d` | 12 | PASS, exact | PASS, `3.47e-18` | +| `mfem_app_dfem_minimal_surface_2d` | 6 | PASS, exact | PASS, `8.67e-19` | +| `mfem_app_ex35p_h1_3d` | 19 | PASS, `6.94e-18` | PASS, `6.94e-18` | +| `mfem_app_ex35p_hcurl_3d` | 29 | PASS, `4.86e-17` | PASS, `4.86e-17` | +| `mfem_app_ex35p_hdiv_3d` | 12 | PASS, `4.86e-17` | PASS, `4.86e-17` | +| `mfem_app_ex9p_mass_convection_2d` | 9 | PASS, `6.94e-18` | PASS, `6.94e-18` | +| `mfem_app_grad_div_3d` | 12 | PASS, `4.86e-17` | PASS, `4.86e-17` | +| `mfem_app_abs_l1_mass_3d` | 5 | PASS, `6.94e-18` | PASS, `6.94e-18` | +| `mfem_app_abs_l1_diffusion_3d` | 14 | PASS, exact | PASS, `2.71e-20` | +| `mfem_app_abs_l1_curlcurl_3d` | 29 | PASS, `4.86e-17` | PASS, `4.86e-17` | + +`mfem_app_navier_tgv_pa_operators_3d` is now also executable. Scratch-sliced +normalizations for vector mass, vector diffusion, discrete gradient, and +nonlinear vector convection reduce its residual loops from 26 to zero. The +raised IR contains 720 Linalg ops, the matcher emits 70 cuTensorNet calls, and +the independent direct-C host comparison passes with +`max_abs=max_rel=4.163336e-17`. + +## Failure causes and fixes + +The original failures were independent bugs that happened to surface in the +same end-to-end table: + +- **Partial submap treated as a reshape.** A contiguous view was incorrectly + assumed to cover its full base tensor. This produced invalid narrowing + casts and wrong second-half write-back. Fast reshape lowering now requires + statically proven full coverage; partial views use affine materialization. +- **Dropped multi-output results.** Recursive debufferization retained only + one result from some H(curl)/H(div) multi-output generics. The application + pipeline now uses joint multi-root debufferization. +- **Incomplete contraction ABI metadata.** Output slices lost physical + strides and affine constant base offsets. The lowering now preserves both, + and snapshots opaque-call results so live results do not alias one buffer. +- **Unsafe computed-submap library calls.** One-shot bufferization can choose + an earlier aliased base for an opaque raw-pointer call. Until library calls + are represented by a bufferizable op, contractions over computed submap + bases remain residual Linalg instead of being emitted unsafely. +- **Malformed DAXPBY match.** Rank-N/two-operand pointwise candidates were + emitted against a rank-1/four-operand ABI. The matcher now emits only the + exact supported form and supplies its scalar coefficients. +- **Store-to-load dependence lost during raising.** ex9 stored `new_r` and + reloaded `r[i]` for a dot product; raising made the reload an independent + old-value input. Exact-address post-store loads are now forwarded from the + stored SSA value. +- **Jetson host-registration cache exhaustion.** Larger graphs exceeded the + fixed 256-entry persistent registration cache. A full cache now evicts and + unregisters the least-recently used completed-call mapping. + +The corrected warm silicon measurements are recorded in +`../silicon_results/2026-08-03_mfem_applications_jetson.log` and published in +the MFEM CE page. Because these fixtures are tiny and each recognized stage +becomes a separate cuTensorNet plan/launch, the timings are dominated by host +planning and launch overhead; they are correctness evidence, not speedup +evidence. diff --git a/issues/mfem_c_kernels/application_extractions/MFEM_NATIVE_GPU_BASELINES.md b/issues/mfem_c_kernels/application_extractions/MFEM_NATIVE_GPU_BASELINES.md new file mode 100644 index 000000000000..826a18f12135 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/MFEM_NATIVE_GPU_BASELINES.md @@ -0,0 +1,44 @@ +# MFEM native GPU baselines + +MFEM's optimized GPU implementations are not generally standalone `.cu` +files. They are C++ partial-assembly kernels expressed with +`MFEM_HOST_DEVICE`, `mfem::forall`, `MFEM_FOREACH_THREAD`, and shared-memory +templates. A CUDA-enabled MFEM build compiles these lambdas into native CUDA +kernels. + +The native implementations corresponding to the extracted application stages +are: + +- Scalar mass: `fem/integ/bilininteg_mass_kernels.hpp`, + `SmemPAMassApply3D` and `PAMassApply3D`. +- Vector mass: `fem/integ/bilininteg_vecmass_pa.hpp`, + `SmemPAVectorMassApply3D`. +- Scalar diffusion: `fem/integ/bilininteg_diffusion_pa.cpp` and its shared + tensor-product kernels. +- Vector diffusion: `fem/integ/bilininteg_vecdiffusion_pa.hpp`, + `SmemPAVectorDiffusionApply3D`. +- Nonlinear vector convection: + `fem/integ/nonlininteg_vecconvection_pa.cpp`, + `SmemPAConvectionNLApply3D`. +- Discrete gradient: `fem/integ/bilininteg_gradient_pa.cpp`, + `PAGradientApply3D` and `SmemPAGradientApply3D`. +- H(curl) mass and curl-curl: + `fem/integ/bilininteg_hcurl_kernels.hpp`, including + `SmemPACurlCurlApply3D`. +- H(div) mass and div-div: `fem/integ/bilininteg_hdiv_kernels.hpp`, including + `SmemPAHdivMassApply3D` and `PADivDivApply3D`. + +MFEM already provides a suitable performance driver in +`tests/benchmarks/bench_assembly_levels.cpp`. Its `BK1` through `BK6` partial +assembly cases exercise scalar/vector mass and scalar/vector diffusion over +roughly 1,000 to 10,000,000 degrees of freedom. The larger applications +`examples/ex35p.cpp`, `miniapps/mtop/mtop_test_iso_elasticity.cpp`, +`miniapps/dfem/dfem-minimal-surface.cpp`, and +`miniapps/fluids/navier/navier_tgv.cpp` provide whole-application native GPU +baselines. + +The attached Jetson currently supplies CUDA 12.6 runtime libraries but no +`nvcc`, NVRTC, CUDA development toolkit, or CUDA-enabled MFEM build. Therefore +the native source mapping is complete, but performance execution is blocked +until a CUDA compiler toolkit is installed and MFEM is rebuilt with +`MFEM_USE_CUDA=YES` for the Jetson architecture. diff --git a/issues/mfem_c_kernels/application_extractions/README.md b/issues/mfem_c_kernels/application_extractions/README.md new file mode 100644 index 000000000000..b31465ae2df5 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/README.md @@ -0,0 +1,27 @@ +# Larger MFEM application C hot paths + +These files preserve one concrete numerical operator application from each +larger MFEM example or miniapp. They omit mesh I/O, MPI communication, command +line handling, global restriction/prolongation, and iterative solver control. +Those operations do not contain the tensor-product loops targeted by the +raising pipeline. + +The extractions use FP64 with `D1D=4` and `Q1D=5`. The element count defaults +to `NE=2` for fast correctness tests and can be changed at compile time with +`-DMFEM_BENCH_NE=`. Pointer extents, scratch tensors, output checks, and +the ABI wrapper scale with this value. `manifest.csv` records the upstream +call site, coverage, and every +represented operator family. Solver convergence, MPI communication, mesh +handling, and global restriction/prolongation remain application orchestration +rather than element tensor kernels. The ex9p entry includes one complete PCG +algebra iteration; its data-dependent convergence loop remains outside the +extraction. + +Run: + +```sh +python3 scripts/correctness/mfem_application_raise_sweep.py +``` + +Outputs are written to `results/`, including frontend, raised, debufferized, +matched MLIR, per-entry logs, and `summary.csv`. diff --git a/issues/mfem_c_kernels/application_extractions/RESULTS_2026_07_31.md b/issues/mfem_c_kernels/application_extractions/RESULTS_2026_07_31.md new file mode 100644 index 000000000000..1691e0da614f --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/RESULTS_2026_07_31.md @@ -0,0 +1,73 @@ +# Larger MFEM application extraction and raising results + +## Summary + +- Applications represented: 7 +- Concrete operator entries: 11 +- Entries with complete declared operator-family coverage: 11/11 +- Frontend successes: 11/11 +- Raising-pipeline successes: 11/11 +- Entries with no residual loops: 11/11 +- Raised Linalg operations: 1570 +- Residual loops: 0 +- Semantic matcher groups: 344 +- Emitted candidate `kernel.launch` operations: 224 + +Coverage and raising are reported separately. All numerical operator families +declared by these application entries are now present in C, and every extracted +entry reaches loop-free Linalg. Mesh handling, restriction/prolongation, MPI +communication, and data-dependent solver control remain application +orchestration rather than element tensor kernels. + +## Per-entry results + +- `mtop_iso_elasticity`: interpolation, elasticity quadrature function, and + integration; 76 Linalg operations, zero loops, 16 matches. +- `dfem_minimal_surface`: interpolation, nonlinear minimal-surface quadrature + function, and integration; 36 Linalg operations, zero loops, 8 matches. +- `ex35p` H1: diffusion + mass; 94 Linalg operations, zero loops, 19 matches. +- `ex35p` H(curl): curl-curl + H(curl) `VectorFEMass`; 166 Linalg operations + with zero residual loops and 29 matches. +- `ex35p` H(div): div-div + H(div) `VectorFEMass`; 86 Linalg operations and + zero residual loops with 12 matches. +- `ex9p`: mass + convection + one complete PCG algebra iteration; 46 Linalg + operations, zero loops, 10 matches. The convergence loop remains solver + control. +- `grad_div`: div-div + H(div) `VectorFEMass`; 86 Linalg operations, zero + residual loops, and 12 matches. +- `abs_l1_jacobi`: complete mass and diffusion branches remain loop-free with + 24/70 Linalg operations and 5/14 matches. The completed curl-curl + H(curl) + mass branch now has 166 Linalg operations, zero residual loops, and 29 + matches. +- `navier_tgv`: vector mass, vector diffusion, nonlinear vector convection, + pressure diffusion, discrete divergence, and discrete gradient are all + extracted. Scratch-sliced staging produces 720 Linalg operations, zero + residual loops, 190 semantic candidates, and 70 emitted library calls. The + direct-C host and Jetson comparisons pass with `max_abs=max_rel=4.16e-17`. + +## Interpretation + +The scalar additive-reduction fusion now recognizes a zero-initialized private +scratch reduction followed by `output[index] += scratch`. It seeds the Linalg +reduction directly from the selected output element and preserves projected +output indexing maps while enclosing parallel loops are raised. This closes +the direct-contraction raising gap for H(curl), H(div), grad-div, and the +curl-curl smoother without requiring stage-sliced source rewrites. + +The former Navier loops combined several tensor-product stages inside each +vector-component loop. The raising pass deliberately rejects a loop body +containing multiple dependent `linalg.generic` operations. The extracted C +now makes those boundaries explicit: it packs one component into contiguous +scratch, invokes the existing scalar interpolation/integration stages, applies +the pointwise physics, and scatters the result back. Components are statically +specialized, and value/gradient scatters are separate loop nests, so every loop +contains at most one raisable tensor stage. + +The matched Jetson graph is correctness evidence, not an optimization result: +70 tiny cuTensorNet calls take 142.37 ms/application versus 0.948 ms for the +independent aarch64 `-O3` reference. Warm per-call host planning/dispatch +dominates device execution. Plan caching or fused-stage lowering is required +before this decomposition can be performance competitive. + +Matcher results are semantic candidates, not performance claims. Candidate +launches still require ABI, numerical-correctness, and profitability checks. diff --git a/issues/mfem_c_kernels/application_extractions/abs_l1_jacobi_operators.c b/issues/mfem_c_kernels/application_extractions/abs_l1_jacobi_operators.c new file mode 100644 index 000000000000..5ab6aad0184b --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/abs_l1_jacobi_operators.c @@ -0,0 +1,29 @@ +/* miniapps/diag-smoothers/abs-l1-jacobi.cpp:279-309. */ +#include "stage_kernels.h" + +#ifndef MFEM_BENCH_NE +#define MFEM_BENCH_NE 2 +#endif +// polygeist-arg-extents mfem_app_abs_l1_mass_3d: B=20, Bt=20, op=125*MFEM_BENCH_NE, x=64*MFEM_BENCH_NE, y=64*MFEM_BENCH_NE +void mfem_app_abs_l1_mass_3d(const double *B, const double *Bt, + const double *op, const double *x, double *y) { + mfem_pa_mass_apply_3d_stage_sliced(B, Bt, op, x, y); +} + +// polygeist-arg-extents mfem_app_abs_l1_diffusion_3d: B=20, G=20, Bt=20, Gt=20, op=750*MFEM_BENCH_NE, x=64*MFEM_BENCH_NE, y=64*MFEM_BENCH_NE +void mfem_app_abs_l1_diffusion_3d( + const double *B, const double *G, const double *Bt, const double *Gt, + const double *op, const double *x, double *y) { + mfem_pa_diffusion_apply_3d_stage_sliced(B, G, Bt, Gt, op, x, y); +} + +// polygeist-arg-extents mfem_app_abs_l1_curlcurl_3d: Bo=15, Bc=20, Bot=15, Bct=20, G=20, Gt=20, curl_op=750*MFEM_BENCH_NE, mass_op=750*MFEM_BENCH_NE, x=144*MFEM_BENCH_NE, y=144*MFEM_BENCH_NE +void mfem_app_abs_l1_curlcurl_3d( + const double *Bo, const double *Bc, const double *Bot, const double *Bct, + const double *G, const double *Gt, const double *curl_op, + const double *mass_op, + const double *x, double *y) { + mfem_pa_curlcurl_apply_3d_stage_sliced( + Bo, Bc, Bot, Bct, G, Gt, curl_op, x, y); + mfem_pa_hcurl_mass_apply_3d_direct(Bo, Bc, Bot, Bct, mass_op, x, y); +} diff --git a/issues/mfem_c_kernels/application_extractions/debug_hdiv_stages.c b/issues/mfem_c_kernels/application_extractions/debug_hdiv_stages.c new file mode 100644 index 000000000000..7bdebd88e0a5 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/debug_hdiv_stages.c @@ -0,0 +1,26 @@ +#include "stage_kernels.h" + +// Small correctness-isolation entry points for the two operators composed by +// mfem_app_ex35p_hdiv_3d. They intentionally keep the application ABI so the +// same deterministic harness data can be used for each half independently. +// polygeist-arg-extents mfem_debug_hdiv_divdiv_only: Bo=15, Bc=20, Bot=15, Bct=20, G=20, Gt=20, div_op=250, mass_op=1500, x=216, y=216 +void mfem_debug_hdiv_divdiv_only( + const double *Bo, const double *Bc, const double *Bot, const double *Bct, + const double *G, const double *Gt, const double *div_op, + const double *mass_op, const double *x, double *y) { + (void)Bc; + (void)Bct; + (void)mass_op; + mfem_pa_divdiv_apply_3d_stage_sliced(Bo, Bot, G, Gt, div_op, x, y); +} + +// polygeist-arg-extents mfem_debug_hdiv_mass_only: Bo=15, Bc=20, Bot=15, Bct=20, G=20, Gt=20, div_op=250, mass_op=1500, x=216, y=216 +void mfem_debug_hdiv_mass_only( + const double *Bo, const double *Bc, const double *Bot, const double *Bct, + const double *G, const double *Gt, const double *div_op, + const double *mass_op, const double *x, double *y) { + (void)G; + (void)Gt; + (void)div_op; + mfem_pa_hdiv_mass_apply_3d_direct(Bo, Bc, Bot, Bct, mass_op, x, y); +} diff --git a/issues/mfem_c_kernels/application_extractions/debug_mtop_stages.c b/issues/mfem_c_kernels/application_extractions/debug_mtop_stages.c new file mode 100644 index 000000000000..0c18037151d9 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/debug_mtop_stages.c @@ -0,0 +1,39 @@ +#include "stage_kernels.h" + +// polygeist-arg-extents mfem_debug_mtop_interp: B=20, G=20, x=64, unused3=50, unused4=50, unused5=200, unused6=25, out=200 +void mfem_debug_mtop_interp( + const double *B, const double *G, const double *x, + const double *unused3, const double *unused4, const double *unused5, + const double *unused6, double *out) { + (void)unused3; (void)unused4; (void)unused5; (void)unused6; + mfem_interp_grad_2d_stage_sliced(x, B, G, out); + mfem_interp_grad_2d_stage_sliced(x + 32, B, G, out + 100); +} + +// polygeist-arg-extents mfem_debug_mtop_qpoint: unused0=20, unused1=20, Q=200, lambda=50, mu=50, J=200, weights=25, out=200 +void mfem_debug_mtop_qpoint( + const double *unused0, const double *unused1, const double *Q, + const double *lambda, const double *mu, const double *J, + const double *weights, double *out) { + (void)unused0; (void)unused1; + mfem_elasticity_qpoint_2d_scalarized(lambda, mu, J, weights, Q, out); +} + +// polygeist-arg-extents mfem_debug_mtop_integrate: B=20, G=20, unused2=64, unused3=50, unused4=50, stress=200, unused6=25, out=64 +void mfem_debug_mtop_integrate( + const double *B, const double *G, const double *unused2, + const double *unused3, const double *unused4, const double *stress, + const double *unused6, double *out) { + (void)unused2; (void)unused3; (void)unused4; (void)unused6; + mfem_integrate_grad_2d_stage_sliced(stress, B, G, out); + mfem_integrate_grad_2d_stage_sliced(stress + 100, B, G, out + 32); +} + +// polygeist-arg-extents mfem_debug_mtop_integrate_second: B=20, G=20, unused2=64, unused3=50, unused4=50, stress=200, unused6=25, out=32 +void mfem_debug_mtop_integrate_second( + const double *B, const double *G, const double *unused2, + const double *unused3, const double *unused4, const double *stress, + const double *unused6, double *out) { + (void)unused2; (void)unused3; (void)unused4; (void)unused6; + mfem_integrate_grad_2d_stage_sliced(stress + 100, B, G, out); +} diff --git a/issues/mfem_c_kernels/application_extractions/dfem_minimal_surface_2d.c b/issues/mfem_c_kernels/application_extractions/dfem_minimal_surface_2d.c new file mode 100644 index 000000000000..4d81f5919ea6 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/dfem_minimal_surface_2d.c @@ -0,0 +1,43 @@ +/* + * miniapps/dfem/dfem-minimal-surface.cpp:308-356. + * The scalar field is represented by component zero of the existing padded + * two-component extraction; component one is ignored. + */ +#include "stage_kernels.h" + +#ifndef MFEM_BENCH_NE +#define MFEM_BENCH_NE 2 +#endif +// polygeist-arg-extents mfem_app_dfem_minimal_surface_2d: B=20, G=20, field_padded=16*MFEM_BENCH_NE, jacobian=50*MFEM_BENCH_NE, weights=25, y_padded=16*MFEM_BENCH_NE +void mfem_app_dfem_minimal_surface_2d( + const double *B, const double *G, const double *field_padded, + const double *jacobian, const double *weights, double *y_padded) { + double grad[50 * MFEM_BENCH_NE]; + double flux[50 * MFEM_BENCH_NE]; + mfem_interp_grad_2d_stage_sliced(field_padded, B, G, grad); + for (int qx = 0; qx < 5; ++qx) { + for (int qy = 0; qy < 5; ++qy) { + int p = qy + 5 * qx; + double g0 = grad[p]; + double g1 = grad[p + 25]; + double j00 = jacobian[4 * p]; + double j01 = jacobian[4 * p + 1]; + double j10 = jacobian[4 * p + 2]; + double j11 = jacobian[4 * p + 3]; + double det = j00 * j11 - j01 * j10; + double i00 = j11 / det; + double i01 = -j01 / det; + double i10 = -j10 / det; + double i11 = j00 / det; + double x0 = g0 * i00 + g1 * i10; + double x1 = g0 * i01 + g1 * i11; + double coeff = 1.0 / __builtin_sqrt(1.0 + x0 * x0 + x1 * x1); + double scale = coeff * det * weights[p]; + flux[p] = scale * (x0 * i00 + x1 * i01); + flux[p + 25] = scale * (x0 * i10 + x1 * i11); + flux[p + 50] = 0.0; + flux[p + 75] = 0.0; + } + } + mfem_integrate_grad_2d_stage_sliced(flux, B, G, y_padded); +} diff --git a/issues/mfem_c_kernels/application_extractions/ex35p_pa_operators.c b/issues/mfem_c_kernels/application_extractions/ex35p_pa_operators.c new file mode 100644 index 000000000000..ccaf2633caad --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/ex35p_pa_operators.c @@ -0,0 +1,32 @@ +/* examples/ex35p.cpp:369-388: the three partial-assembly problem branches. */ +#include "stage_kernels.h" + +#ifndef MFEM_BENCH_NE +#define MFEM_BENCH_NE 2 +#endif +// polygeist-arg-extents mfem_app_ex35p_h1_3d: B=20, G=20, Bt=20, Gt=20, diff_op=750*MFEM_BENCH_NE, mass_op=125*MFEM_BENCH_NE, x=64*MFEM_BENCH_NE, y=64*MFEM_BENCH_NE +void mfem_app_ex35p_h1_3d( + const double *B, const double *G, const double *Bt, const double *Gt, + const double *diff_op, const double *mass_op, const double *x, double *y) { + mfem_pa_diffusion_apply_3d_stage_sliced(B, G, Bt, Gt, diff_op, x, y); + mfem_pa_mass_apply_3d_stage_sliced(B, Bt, mass_op, x, y); +} + +// polygeist-arg-extents mfem_app_ex35p_hcurl_3d: Bo=15, Bc=20, Bot=15, Bct=20, G=20, Gt=20, curl_op=750*MFEM_BENCH_NE, mass_op=750*MFEM_BENCH_NE, x=144*MFEM_BENCH_NE, y=144*MFEM_BENCH_NE +void mfem_app_ex35p_hcurl_3d( + const double *Bo, const double *Bc, const double *Bot, const double *Bct, + const double *G, const double *Gt, const double *curl_op, const double *mass_op, + const double *x, double *y) { + mfem_pa_curlcurl_apply_3d_stage_sliced( + Bo, Bc, Bot, Bct, G, Gt, curl_op, x, y); + mfem_pa_hcurl_mass_apply_3d_direct(Bo, Bc, Bot, Bct, mass_op, x, y); +} + +// polygeist-arg-extents mfem_app_ex35p_hdiv_3d: Bo=15, Bc=20, Bot=15, Bct=20, G=20, Gt=20, div_op=125*MFEM_BENCH_NE, mass_op=750*MFEM_BENCH_NE, x=108*MFEM_BENCH_NE, y=108*MFEM_BENCH_NE +void mfem_app_ex35p_hdiv_3d( + const double *Bo, const double *Bc, const double *Bot, const double *Bct, + const double *G, const double *Gt, const double *div_op, + const double *mass_op, const double *x, double *y) { + mfem_pa_divdiv_apply_3d_stage_sliced(Bo, Bot, G, Gt, div_op, x, y); + mfem_pa_hdiv_mass_apply_3d_direct(Bo, Bc, Bot, Bct, mass_op, x, y); +} diff --git a/issues/mfem_c_kernels/application_extractions/ex9p_mass_convection_2d.c b/issues/mfem_c_kernels/application_extractions/ex9p_mass_convection_2d.c new file mode 100644 index 000000000000..2d986728a69f --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/ex9p_mass_convection_2d.c @@ -0,0 +1,30 @@ +/* + * Hot-path C extraction for MFEM examples/ex9p.cpp. + * + * Upstream application: + * examples/ex9p.cpp:388-404 (partial-assembly mass and convection forms) + * examples/ex9p.cpp:704-709 (FE_Evolution::Mult) + * + * This represents one element-batch evaluation of the two PA forms. The + * global true/local-DOF maps and solver convergence control remain application + * orchestration. One complete preconditioned-CG algebra iteration is included. + */ + +#include "stage_kernels.h" + +#ifndef MFEM_BENCH_NE +#define MFEM_BENCH_NE 2 +#endif +// polygeist-arg-extents mfem_app_ex9p_mass_convection_2d: B=20, G=20, Bt=20, mass_op=25*MFEM_BENCH_NE, convection_op=50*MFEM_BENCH_NE, x=16*MFEM_BENCH_NE, inv_diag=16*MFEM_BENCH_NE, mass_y=16*MFEM_BENCH_NE, convection_y=16*MFEM_BENCH_NE, residual=16*MFEM_BENCH_NE, preconditioned=16*MFEM_BENCH_NE, direction=16*MFEM_BENCH_NE, r_dot_z=1 +void mfem_app_ex9p_mass_convection_2d( + const double *B, const double *G, const double *Bt, + const double *mass_op, const double *convection_op, const double *x, + const double *inv_diag, double alpha, double beta, + double *mass_y, double *convection_y, double *residual, + double *preconditioned, double *direction, double *r_dot_z) { + mfem_pa_mass_apply_2d_stage_sliced(B, Bt, mass_op, x, mass_y); + mfem_pa_convection_apply_2d_stage_sliced( + B, G, Bt, convection_op, x, convection_y); + mfem_mass_pcg_step_2d(mass_y, inv_diag, alpha, beta, convection_y, + residual, preconditioned, direction, r_dot_z); +} diff --git a/issues/mfem_c_kernels/application_extractions/grad_div_3d.c b/issues/mfem_c_kernels/application_extractions/grad_div_3d.c new file mode 100644 index 000000000000..896c68180023 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/grad_div_3d.c @@ -0,0 +1,14 @@ +/* miniapps/hdiv-linear-solver/grad_div.cpp:203-206. */ +#include "stage_kernels.h" + +#ifndef MFEM_BENCH_NE +#define MFEM_BENCH_NE 2 +#endif +// polygeist-arg-extents mfem_app_grad_div_3d: Bo=15, Bc=20, Bot=15, Bct=20, G=20, Gt=20, div_op=125*MFEM_BENCH_NE, mass_op=750*MFEM_BENCH_NE, x=108*MFEM_BENCH_NE, y=108*MFEM_BENCH_NE +void mfem_app_grad_div_3d( + const double *Bo, const double *Bc, const double *Bot, const double *Bct, + const double *G, const double *Gt, const double *div_op, + const double *mass_op, const double *x, double *y) { + mfem_pa_divdiv_apply_3d_stage_sliced(Bo, Bot, G, Gt, div_op, x, y); + mfem_pa_hdiv_mass_apply_3d_direct(Bo, Bc, Bot, Bct, mass_op, x, y); +} diff --git a/issues/mfem_c_kernels/application_extractions/manifest.csv b/issues/mfem_c_kernels/application_extractions/manifest.csv new file mode 100644 index 000000000000..a861ce937712 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/manifest.csv @@ -0,0 +1,12 @@ +application,source,support_source,function,coverage,operator_families,upstream_file,upstream_lines,missing_operator +mtop_iso_elasticity,mtop_iso_elasticity_dfem_2d.c,,mfem_app_mtop_iso_elasticity_dfem_2d,complete_hot_path,interpolation;elasticity_qpoint;integration,miniapps/mtop/mtop_solvers.cpp,376-410, +dfem_minimal_surface,dfem_minimal_surface_2d.c,,mfem_app_dfem_minimal_surface_2d,complete_hot_path,interpolation;minimal_surface_qpoint;integration,miniapps/dfem/dfem-minimal-surface.cpp,308-356, +ex35p,ex35p_pa_operators.c,,mfem_app_ex35p_h1_3d,complete_operator_branch,Diffusion;Mass,examples/ex35p.cpp,369-376, +ex35p,ex35p_pa_operators.c,missing_stage_kernels.c,mfem_app_ex35p_hcurl_3d,complete_operator_branch,CurlCurl;VectorFEMass_Hcurl,examples/ex35p.cpp,379-382, +ex35p,ex35p_pa_operators.c,missing_stage_kernels.c,mfem_app_ex35p_hdiv_3d,complete_operator_branch,DivDiv;VectorFEMass_Hdiv,examples/ex35p.cpp,385-388, +ex9p,ex9p_mass_convection_2d.c,missing_stage_kernels.c,mfem_app_ex9p_mass_convection_2d,complete_element_and_solver_iteration,Mass;Convection;PCG_iteration,examples/ex9p.cpp,388-404;704-709, +grad_div,grad_div_3d.c,missing_stage_kernels.c,mfem_app_grad_div_3d,complete_operator_branch,DivDiv;VectorFEMass_Hdiv,miniapps/hdiv-linear-solver/grad_div.cpp,203-206, +abs_l1_jacobi,abs_l1_jacobi_operators.c,,mfem_app_abs_l1_mass_3d,complete_operator_branch,Mass,miniapps/diag-smoothers/abs-l1-jacobi.cpp,279-309, +abs_l1_jacobi,abs_l1_jacobi_operators.c,,mfem_app_abs_l1_diffusion_3d,complete_operator_branch,Diffusion,miniapps/diag-smoothers/abs-l1-jacobi.cpp,279-309, +abs_l1_jacobi,abs_l1_jacobi_operators.c,missing_stage_kernels.c,mfem_app_abs_l1_curlcurl_3d,complete_operator_branch,CurlCurl;VectorFEMass_Hcurl,miniapps/diag-smoothers/abs-l1-jacobi.cpp,294-301, +navier_tgv,navier_tgv_pressure_diffusion_3d.c,missing_stage_kernels.c,mfem_app_navier_tgv_pa_operators_3d,complete_pa_operator_families,VectorMass;VectorDiffusion;VectorConvectionNLF;pressure_Diffusion;discrete_divergence;discrete_gradient,miniapps/fluids/navier/navier_solver.cpp,128-205, diff --git a/issues/mfem_c_kernels/application_extractions/mfem_application_jetson_harness.c b/issues/mfem_c_kernels/application_extractions/mfem_application_jetson_harness.c new file mode 100644 index 000000000000..ff47862fb0b6 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/mfem_application_jetson_harness.c @@ -0,0 +1,413 @@ +#include +#include +#include +#include +#include +#include + +#ifndef BENCH_ITERS +#define BENCH_ITERS 20 +#endif +#ifndef MFEM_BENCH_NE +#define MFEM_BENCH_NE 2 +#endif + +#define MAX_EXTENT (2250 * MFEM_BENCH_NE) +#define MAX_OUTPUTS 6 + +static double args[13][MAX_EXTENT]; +static double initial_state[MAX_OUTPUTS][MAX_EXTENT]; +static double reference_state[MAX_OUTPUTS][MAX_EXTENT]; +static double raised_state[MAX_OUTPUTS][MAX_EXTENT]; + +#if defined(MFEM_APP_MTOP) +#define APP_NAME "mtop_iso_elasticity_dfem_2d" +#define OUTPUT_COUNT 1 +static const int64_t output_extents[] = {32 * MFEM_BENCH_NE}; +extern void mfem_app_mtop_iso_elasticity_dfem_2d( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, double *); +extern void mfem_app_mtop_iso_elasticity_dfem_2d_reference( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, double *); +static void run_raised(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_mtop_iso_elasticity_dfem_2d( + args[0], args[1], args[2], args[3], args[4], args[5], args[6], state[0]); +} +static void run_reference(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_mtop_iso_elasticity_dfem_2d_reference( + args[0], args[1], args[2], args[3], args[4], args[5], args[6], state[0]); +} +#elif defined(MFEM_APP_MINIMAL_SURFACE) +#define APP_NAME "dfem_minimal_surface_2d" +#define OUTPUT_COUNT 1 +static const int64_t output_extents[] = {16 * MFEM_BENCH_NE}; +extern void mfem_app_dfem_minimal_surface_2d( + const double *, const double *, const double *, const double *, + const double *, double *); +extern void mfem_app_dfem_minimal_surface_2d_reference( + const double *, const double *, const double *, const double *, + const double *, double *); +static void run_raised(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_dfem_minimal_surface_2d( + args[0], args[1], args[2], args[3], args[4], state[0]); +} +static void run_reference(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_dfem_minimal_surface_2d_reference( + args[0], args[1], args[2], args[3], args[4], state[0]); +} +#elif defined(MFEM_APP_EX35P_H1) +#define APP_NAME "ex35p_h1_3d" +#define OUTPUT_COUNT 1 +static const int64_t output_extents[] = {64 * MFEM_BENCH_NE}; +extern void mfem_app_ex35p_h1_3d( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, double *); +extern void mfem_app_ex35p_h1_3d_reference( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, double *); +static void run_raised(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_ex35p_h1_3d(args[0], args[1], args[2], args[3], args[4], args[5], + args[6], state[0]); +} +static void run_reference(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_ex35p_h1_3d_reference( + args[0], args[1], args[2], args[3], args[4], args[5], args[6], state[0]); +} +#elif defined(MFEM_APP_EX35P_HCURL) +#define APP_NAME "ex35p_hcurl_3d" +#define OUTPUT_COUNT 1 +static const int64_t output_extents[] = {144 * MFEM_BENCH_NE}; +extern void mfem_app_ex35p_hcurl_3d( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, const double *, + const double *, double *); +extern void mfem_app_ex35p_hcurl_3d_reference( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, const double *, + const double *, double *); +static void run_raised(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_ex35p_hcurl_3d(args[0], args[1], args[2], args[3], args[4], args[5], + args[6], args[7], args[8], state[0]); +} +static void run_reference(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_ex35p_hcurl_3d_reference( + args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], + args[8], state[0]); +} +#elif defined(MFEM_APP_EX35P_HDIV) +#define APP_NAME "ex35p_hdiv_3d" +#define OUTPUT_COUNT 1 +static const int64_t output_extents[] = {108 * MFEM_BENCH_NE}; +extern void mfem_app_ex35p_hdiv_3d( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, const double *, + const double *, double *); +extern void mfem_app_ex35p_hdiv_3d_reference( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, const double *, + const double *, double *); +static void run_raised(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_ex35p_hdiv_3d(args[0], args[1], args[2], args[3], args[4], args[5], + args[6], args[7], args[8], state[0]); +} +static void run_reference(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_ex35p_hdiv_3d_reference( + args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], + args[8], state[0]); +} +#elif defined(MFEM_DEBUG_HDIV_DIVDIV) || defined(MFEM_DEBUG_HDIV_MASS) +#if defined(MFEM_DEBUG_HDIV_DIVDIV) +#define APP_NAME "debug_hdiv_divdiv_only" +#define DEBUG_HDIV_FUNCTION mfem_debug_hdiv_divdiv_only +#else +#define APP_NAME "debug_hdiv_mass_only" +#define DEBUG_HDIV_FUNCTION mfem_debug_hdiv_mass_only +#endif +#define OUTPUT_COUNT 1 +static const int64_t output_extents[] = {108 * MFEM_BENCH_NE}; +extern void DEBUG_HDIV_FUNCTION( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, const double *, + const double *, double *); +#define DEBUG_HDIV_REFERENCE_IMPL(name) name##_reference +#define DEBUG_HDIV_REFERENCE(name) DEBUG_HDIV_REFERENCE_IMPL(name) +extern void DEBUG_HDIV_REFERENCE(DEBUG_HDIV_FUNCTION)( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, const double *, + const double *, double *); +static void run_raised(double state[MAX_OUTPUTS][MAX_EXTENT]) { + DEBUG_HDIV_FUNCTION(args[0], args[1], args[2], args[3], args[4], args[5], + args[6], args[7], args[8], state[0]); +} +static void run_reference(double state[MAX_OUTPUTS][MAX_EXTENT]) { + DEBUG_HDIV_REFERENCE(DEBUG_HDIV_FUNCTION)( + args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], + args[8], state[0]); +} +#elif defined(MFEM_DEBUG_MTOP_INTERP) || defined(MFEM_DEBUG_MTOP_QPOINT) || defined(MFEM_DEBUG_MTOP_INTEGRATE) || defined(MFEM_DEBUG_MTOP_INTEGRATE_SECOND) +#if defined(MFEM_DEBUG_MTOP_INTERP) +#define APP_NAME "debug_mtop_interp" +#define DEBUG_MTOP_FUNCTION mfem_debug_mtop_interp +#define DEBUG_MTOP_EXTENT 200 +#elif defined(MFEM_DEBUG_MTOP_QPOINT) +#define APP_NAME "debug_mtop_qpoint" +#define DEBUG_MTOP_FUNCTION mfem_debug_mtop_qpoint +#define DEBUG_MTOP_EXTENT 200 +#elif defined(MFEM_DEBUG_MTOP_INTEGRATE) +#define APP_NAME "debug_mtop_integrate" +#define DEBUG_MTOP_FUNCTION mfem_debug_mtop_integrate +#define DEBUG_MTOP_EXTENT 64 +#else +#define APP_NAME "debug_mtop_integrate_second" +#define DEBUG_MTOP_FUNCTION mfem_debug_mtop_integrate_second +#define DEBUG_MTOP_EXTENT 32 +#endif +#define OUTPUT_COUNT 1 +static const int64_t output_extents[] = {DEBUG_MTOP_EXTENT}; +extern void DEBUG_MTOP_FUNCTION( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, double *); +#define DEBUG_MTOP_REFERENCE_IMPL(name) name##_reference +#define DEBUG_MTOP_REFERENCE(name) DEBUG_MTOP_REFERENCE_IMPL(name) +extern void DEBUG_MTOP_REFERENCE(DEBUG_MTOP_FUNCTION)( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, double *); +static void run_raised(double state[MAX_OUTPUTS][MAX_EXTENT]) { + DEBUG_MTOP_FUNCTION(args[0], args[1], args[2], args[3], args[4], args[5], + args[6], state[0]); +} +static void run_reference(double state[MAX_OUTPUTS][MAX_EXTENT]) { + DEBUG_MTOP_REFERENCE(DEBUG_MTOP_FUNCTION)( + args[0], args[1], args[2], args[3], args[4], args[5], args[6], state[0]); +} +#elif defined(MFEM_APP_EX9P) +#define APP_NAME "ex9p_mass_convection_2d" +#define OUTPUT_COUNT 6 +static const int64_t output_extents[] = { + 16 * MFEM_BENCH_NE, 16 * MFEM_BENCH_NE, 16 * MFEM_BENCH_NE, + 16 * MFEM_BENCH_NE, 16 * MFEM_BENCH_NE, 1}; +extern void mfem_app_ex9p_mass_convection_2d( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, double, double, double *, + double *, double *, double *, double *, double *); +extern void mfem_app_ex9p_mass_convection_2d_reference( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, double, double, double *, + double *, double *, double *, double *, double *); +static void run_raised(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_ex9p_mass_convection_2d( + args[0], args[1], args[2], args[3], args[4], args[5], args[6], 0.125, + 0.25, state[0], state[1], state[2], state[3], state[4], state[5]); +} +static void run_reference(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_ex9p_mass_convection_2d_reference( + args[0], args[1], args[2], args[3], args[4], args[5], args[6], 0.125, + 0.25, state[0], state[1], state[2], state[3], state[4], state[5]); +} +#elif defined(MFEM_APP_GRAD_DIV) +#define APP_NAME "grad_div_3d" +#define OUTPUT_COUNT 1 +static const int64_t output_extents[] = {108 * MFEM_BENCH_NE}; +extern void mfem_app_grad_div_3d( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, const double *, + const double *, double *); +extern void mfem_app_grad_div_3d_reference( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, const double *, + const double *, double *); +static void run_raised(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_grad_div_3d(args[0], args[1], args[2], args[3], args[4], args[5], + args[6], args[7], args[8], state[0]); +} +static void run_reference(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_grad_div_3d_reference( + args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], + args[8], state[0]); +} +#elif defined(MFEM_APP_ABS_MASS) +#define APP_NAME "abs_l1_mass_3d" +#define OUTPUT_COUNT 1 +static const int64_t output_extents[] = {64 * MFEM_BENCH_NE}; +extern void mfem_app_abs_l1_mass_3d( + const double *, const double *, const double *, const double *, double *); +extern void mfem_app_abs_l1_mass_3d_reference( + const double *, const double *, const double *, const double *, double *); +static void run_raised(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_abs_l1_mass_3d(args[0], args[1], args[2], args[3], state[0]); +} +static void run_reference(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_abs_l1_mass_3d_reference( + args[0], args[1], args[2], args[3], state[0]); +} +#elif defined(MFEM_APP_ABS_DIFFUSION) +#define APP_NAME "abs_l1_diffusion_3d" +#define OUTPUT_COUNT 1 +static const int64_t output_extents[] = {64 * MFEM_BENCH_NE}; +extern void mfem_app_abs_l1_diffusion_3d( + const double *, const double *, const double *, const double *, + const double *, const double *, double *); +extern void mfem_app_abs_l1_diffusion_3d_reference( + const double *, const double *, const double *, const double *, + const double *, const double *, double *); +static void run_raised(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_abs_l1_diffusion_3d( + args[0], args[1], args[2], args[3], args[4], args[5], state[0]); +} +static void run_reference(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_abs_l1_diffusion_3d_reference( + args[0], args[1], args[2], args[3], args[4], args[5], state[0]); +} +#elif defined(MFEM_APP_ABS_CURLCURL) +#define APP_NAME "abs_l1_curlcurl_3d" +#define OUTPUT_COUNT 1 +static const int64_t output_extents[] = {144 * MFEM_BENCH_NE}; +extern void mfem_app_abs_l1_curlcurl_3d( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, const double *, + const double *, double *); +extern void mfem_app_abs_l1_curlcurl_3d_reference( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, const double *, + const double *, double *); +static void run_raised(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_abs_l1_curlcurl_3d( + args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], + args[8], state[0]); +} +static void run_reference(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_abs_l1_curlcurl_3d_reference( + args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], + args[8], state[0]); +} +#elif defined(MFEM_APP_NAVIER) +#define APP_NAME "navier_tgv_pa_operators_3d" +#define OUTPUT_COUNT 2 +static const int64_t output_extents[] = { + 192 * MFEM_BENCH_NE, 64 * MFEM_BENCH_NE}; +extern void mfem_app_navier_tgv_pa_operators_3d( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, double *, double *); +extern void mfem_app_navier_tgv_pa_operators_3d_direct_reference( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, double *, double *); +static void run_raised(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_navier_tgv_pa_operators_3d( + args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], + args[8], args[9], args[10], state[0], state[1]); +} +static void run_reference(double state[MAX_OUTPUTS][MAX_EXTENT]) { + mfem_app_navier_tgv_pa_operators_3d_direct_reference( + args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], + args[8], args[9], args[10], state[0], state[1]); +} +#else +#error "Select one MFEM_APP_* application" +#endif + +static double seconds(void) { + struct timespec value; + clock_gettime(CLOCK_MONOTONIC, &value); + return (double)value.tv_sec + 1.0e-9 * (double)value.tv_nsec; +} + +static void initialize_data(void) { + for (int a = 0; a < 13; ++a) + for (int i = 0; i < MAX_EXTENT; ++i) + args[a][i] = ((double)((i * 17 + a * 13 + 5) % 101) - 50.0) / 257.0; + for (int i = 0; i < MAX_EXTENT; ++i) { + args[3][i] += 0.75; + args[4][i] += 0.5; + args[6][i] += 1.0; + } + +#if defined(MFEM_APP_MTOP) + for (int p = 0; p < 25 * MFEM_BENCH_NE; ++p) { + args[5][4 * p] = 1.0 + 0.001 * p; + args[5][4 * p + 1] = 0.03; + args[5][4 * p + 2] = -0.02; + args[5][4 * p + 3] = 1.1 + 0.001 * p; + } +#elif defined(MFEM_APP_MINIMAL_SURFACE) + for (int p = 0; p < 25 * MFEM_BENCH_NE; ++p) { + args[3][4 * p] = 1.0 + 0.001 * p; + args[3][4 * p + 1] = 0.03; + args[3][4 * p + 2] = -0.02; + args[3][4 * p + 3] = 1.1 + 0.001 * p; + } +#endif + + for (int output = 0; output < MAX_OUTPUTS; ++output) + for (int i = 0; i < MAX_EXTENT; ++i) + initial_state[output][i] = + ((double)((i * 11 + output * 7 + 3) % 37) - 18.0) / 509.0; +} + +static void reset_states(void) { + memcpy(reference_state, initial_state, sizeof(initial_state)); + memcpy(raised_state, initial_state, sizeof(initial_state)); +} + +int main(void) { + /* Compile-time element sweeps intentionally use large automatic scratch + * tensors in the extracted direct and normalized algorithms. Raise the + * soft stack limit to the process hard limit before either path executes. */ + struct rlimit stack_limit; + if (getrlimit(RLIMIT_STACK, &stack_limit) == 0) { + stack_limit.rlim_cur = stack_limit.rlim_max; + (void)setrlimit(RLIMIT_STACK, &stack_limit); + } + initialize_data(); + reset_states(); + run_reference(reference_state); + run_raised(raised_state); + + double max_abs = 0.0; + double max_rel = 0.0; + for (int output = 0; output < OUTPUT_COUNT; ++output) { + for (int64_t i = 0; i < output_extents[output]; ++i) { + double abs_error = fabs(reference_state[output][i] - raised_state[output][i]); + double scale = fmax(1.0, fabs(reference_state[output][i])); + double rel_error = abs_error / scale; +#ifdef MFEM_DEBUG_MISMATCHES + if (abs_error > 1.0e-12) + printf("mismatch output=%d index=%lld reference=%.17g raised=%.17g " + "abs=%.17g\n", + output, (long long)i, reference_state[output][i], + raised_state[output][i], abs_error); +#endif + if (abs_error > max_abs) + max_abs = abs_error; + if (rel_error > max_rel) + max_rel = rel_error; + } + } + int correct = isfinite(max_abs) && max_rel <= 1.0e-10; + printf("application=%s correctness=%s max_abs=%.17g max_rel=%.17g\n", + APP_NAME, correct ? "PASS" : "FAIL", max_abs, max_rel); + if (!correct) + return 2; + + reset_states(); + run_reference(reference_state); + memcpy(reference_state, initial_state, sizeof(initial_state)); + double start = seconds(); + for (int i = 0; i < BENCH_ITERS; ++i) + run_reference(reference_state); + double cpu_us = (seconds() - start) * 1.0e6 / BENCH_ITERS; + + reset_states(); + run_raised(raised_state); + memcpy(raised_state, initial_state, sizeof(initial_state)); + start = seconds(); + for (int i = 0; i < BENCH_ITERS; ++i) + run_raised(raised_state); + double raised_us = (seconds() - start) * 1.0e6 / BENCH_ITERS; + + printf("application=%s iterations=%d cpu_reference_us=%.6f raised_gpu_us=%.6f speedup=%.6f\n", + APP_NAME, BENCH_ITERS, cpu_us, raised_us, cpu_us / raised_us); + return 0; +} diff --git a/issues/mfem_c_kernels/application_extractions/mfem_ne_scale_validation.c b/issues/mfem_c_kernels/application_extractions/mfem_ne_scale_validation.c new file mode 100644 index 000000000000..00d80a044636 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/mfem_ne_scale_validation.c @@ -0,0 +1,73 @@ +/* C-level validation for the application extraction's element-count scaling. + * This deliberately bypasses Polygeist and the library matcher: every + * scratch-sliced normalization is compared with its direct loop algorithm. */ +#include +#include +#include + +#ifndef MFEM_BENCH_NE +#define MFEM_BENCH_NE 2 +#endif + +#include "stage_kernels.h" + +#define MAX_DATA (2250 * MFEM_BENCH_NE) +#define MAX_FIELD (192 * MFEM_BENCH_NE) + +static double data[MAX_DATA], x[MAX_FIELD], initial[MAX_FIELD]; +static double direct_y[MAX_FIELD], sliced_y[MAX_FIELD]; +static double B[20], G[20]; + +static void initialize(void) { + for (int i = 0; i < 20; ++i) { + B[i] = ((i * 17 + 5) % 29 - 14.0) / 53.0; + G[i] = ((i * 11 + 7) % 31 - 15.0) / 47.0; + } + for (int i = 0; i < MAX_DATA; ++i) + data[i] = ((i * 13 + 3) % 37 - 18.0) / 71.0; + for (int i = 0; i < MAX_FIELD; ++i) { + x[i] = ((i * 19 + 2) % 41 - 20.0) / 83.0; + initial[i] = ((i * 7 + 1) % 23 - 11.0) / 97.0; + } +} + +static double compare(int extent) { + double result = 0.0; + for (int i = 0; i < extent; ++i) + result = fmax(result, fabs(direct_y[i] - sliced_y[i])); + return result; +} + +static void reset(void) { + memcpy(direct_y, initial, sizeof(initial)); + memcpy(sliced_y, initial, sizeof(initial)); +} + +int main(void) { + initialize(); + + reset(); + mfem_pa_vector_mass_apply_3d_direct(B, data, x, direct_y); + mfem_pa_vector_mass_apply_3d_sliced(B, data, x, sliced_y); + printf("stage=vector_mass ne=%d max_abs=%.17g\n", MFEM_BENCH_NE, + compare(192 * MFEM_BENCH_NE)); + + reset(); + mfem_pa_vector_diffusion_apply_3d_direct(B, G, data, x, direct_y); + mfem_pa_vector_diffusion_apply_3d_sliced(B, G, data, x, sliced_y); + printf("stage=vector_diffusion ne=%d max_abs=%.17g\n", MFEM_BENCH_NE, + compare(192 * MFEM_BENCH_NE)); + + reset(); + mfem_pa_vector_convection_nl_apply_3d_direct(B, G, data, x, direct_y); + mfem_pa_vector_convection_nl_apply_3d_sliced(B, G, data, x, sliced_y); + printf("stage=vector_convection ne=%d max_abs=%.17g\n", MFEM_BENCH_NE, + compare(192 * MFEM_BENCH_NE)); + + reset(); + mfem_pa_discrete_gradient_apply_3d_direct(B, G, data, x, direct_y); + mfem_pa_discrete_gradient_apply_3d_sliced(B, G, data, x, sliced_y); + printf("stage=discrete_gradient ne=%d max_abs=%.17g\n", MFEM_BENCH_NE, + compare(192 * MFEM_BENCH_NE)); + return 0; +} diff --git a/issues/mfem_c_kernels/application_extractions/missing_stage_kernels.c b/issues/mfem_c_kernels/application_extractions/missing_stage_kernels.c new file mode 100644 index 000000000000..1ac3aef0075c --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/missing_stage_kernels.c @@ -0,0 +1,515 @@ +/* + * Concrete FP64 D1D=4, Q1D=5 application kernels omitted from the + * original MFEM application extraction. The loop equations follow the PA + * apply kernels in fem/integ. They use direct tensor contractions here so + * that the extracted C records semantics without MFEM's device wrappers. + */ +#ifndef MFEM_BENCH_NE +#define MFEM_BENCH_NE 2 +#endif +enum { MF_D=4, MF_E=3, MF_Q=5, MF_NE=MFEM_BENCH_NE, + MF_Q3=125, MF_D3=64 }; +#define MF_S(x,y,z,e) ((x)+MF_D*((y)+MF_D*((z)+MF_D*(e)))) +#define MF_V(x,y,z,c,e) ((x)+MF_D*((y)+MF_D*((z)+MF_D*((c)+3*(e))))) +#define MF_QI(x,y,z) ((x)+MF_Q*((y)+MF_Q*(z))) +#define MF_VQ(x,y,z,c,e) (MF_QI(x,y,z)+MF_Q3*((c)+3*(e))) + +/* fem/integ/bilininteg_hcurl_kernels.cpp:280-469. */ +void mfem_pa_hcurl_mass_apply_3d_direct( + const double *Bo, const double *Bc, const double *Bot, const double *Bct, + const double *op, const double *X, double *Y) { + double q[MF_NE][3][MF_Q][MF_Q][MF_Q]; +#define HC_FWD(C,NX,NY,NZ,MX,MY,MZ,OFF) \ + for(int e=0;e (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 144)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 125)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 375)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 500)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 250)> +#map22 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 625)> +#map23 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 144)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map26 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map27 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 3)> +#map28 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 4)> +#map29 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 4)> +#map30 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 3 + d0 * 144)> +#map31 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map32 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +#map33 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 3)> +#map34 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 4)> +#map35 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 4 + d0 * 144 + 48)> +#map36 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 3)> +#map37 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 16 + d5 * 4 + d0 * 144 + 96)> +#map38 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750)> +#map39 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 125)> +#map40 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 250)> +#map41 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 375)> +#map42 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 500)> +#map43 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 625)> +#map44 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 5)> +#map45 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 5)> +#map46 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 5)> +#map47 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_abs_l1_curlcurl_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg9 : memref + %1 = bufferization.to_tensor %arg8 : memref + %2 = bufferization.to_tensor %arg7 : memref + %3 = bufferization.to_tensor %arg6 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg3 : memref + %7 = bufferization.to_tensor %arg2 : memref + %8 = bufferization.to_tensor %arg1 : memref + %9 = bufferization.to_tensor %arg0 : memref + %10 = tensor.empty() : tensor<2x4x4x4xf64> + %11 = tensor.empty() : tensor<2x4x4x4xf64> + %12 = tensor.empty() : tensor<2x4x4x4xf64> + %13 = tensor.empty() : tensor<2x4x4x4xf64> + %14 = tensor.empty() : tensor<2x4x4x4xf64> + %15 = tensor.empty() : tensor<2x4x4x4xf64> + %16 = tensor.empty() : tensor<2x5x4x4xf64> + %17 = tensor.empty() : tensor<2x5x4x4xf64> + %18 = tensor.empty() : tensor<2x5x4x4xf64> + %19 = tensor.empty() : tensor<2x5x4x4xf64> + %20 = tensor.empty() : tensor<2x5x4x4xf64> + %21 = tensor.empty() : tensor<2x5x4x4xf64> + %22 = tensor.empty() : tensor<2x5x5x4xf64> + %23 = tensor.empty() : tensor<2x5x5x4xf64> + %24 = tensor.empty() : tensor<2x5x5x4xf64> + %25 = tensor.empty() : tensor<2x5x5x4xf64> + %26 = tensor.empty() : tensor<2x5x5x4xf64> + %27 = tensor.empty() : tensor<2x5x5x4xf64> + %28 = tensor.empty() : tensor<2x5x5x5xf64> + %29 = tensor.empty() : tensor<2x5x5x5xf64> + %30 = tensor.empty() : tensor<2x5x5x5xf64> + %31 = tensor.empty() : tensor<2x5x5x5xf64> + %32 = tensor.empty() : tensor<2x5x5x5xf64> + %33 = tensor.empty() : tensor<2x5x5x5xf64> + %34 = tensor.empty() : tensor<2x4x5x5xf64> + %35 = tensor.empty() : tensor<2x4x5x5xf64> + %36 = tensor.empty() : tensor<2x4x5x5xf64> + %37 = tensor.empty() : tensor<2x4x5x5xf64> + %38 = tensor.empty() : tensor<2x4x5x5xf64> + %39 = tensor.empty() : tensor<2x4x5x5xf64> + %40 = tensor.empty() : tensor<2x4x4x5xf64> + %41 = tensor.empty() : tensor<2x4x4x5xf64> + %42 = tensor.empty() : tensor<2x4x4x5xf64> + %43 = tensor.empty() : tensor<2x4x4x5xf64> + %44 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice = tensor.extract_slice %44[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %45 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %45 into %44[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %46 = polygeist.submap(%9, %c2, %c4, %c4, %c5, %c3) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %47 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c3) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %48 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%47, %46 : tensor, tensor) outs(%inserted_slice : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_0 = tensor.extract_slice %39[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %49 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_0 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_1 = tensor.extract_slice %48[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %50 = polygeist.submap(%5, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %51 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_1, %50 : tensor, tensor) outs(%49 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_2 = tensor.extract_slice %38[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %52 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_2 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_3 = tensor.extract_slice %48[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %53 = polygeist.submap(%8, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %54 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_3, %53 : tensor, tensor) outs(%52 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_4 = tensor.extract_slice %33[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_4 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %56 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %57 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%51, %56 : tensor, tensor) outs(%55 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_5 = tensor.extract_slice %32[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %58 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_5 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %59 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %60 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%54, %59 : tensor, tensor) outs(%58 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_6 = tensor.extract_slice %43[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %61 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_6 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %62 = polygeist.submap(%5, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %63 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %64 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%63, %62 : tensor, tensor) outs(%61 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_7 = tensor.extract_slice %42[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %65 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_7 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %66 = polygeist.submap(%8, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %67 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %68 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%67, %66 : tensor, tensor) outs(%65 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_8 = tensor.extract_slice %37[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %69 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_8 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %70 = polygeist.submap(%9, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %71 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%64, %70 : tensor, tensor) outs(%69 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_9 = tensor.extract_slice %36[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %72 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_9 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %73 = polygeist.submap(%9, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %74 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%68, %73 : tensor, tensor) outs(%72 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_10 = tensor.extract_slice %31[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %75 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_10 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %76 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %77 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%71, %76 : tensor, tensor) outs(%75 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_11 = tensor.extract_slice %30[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %78 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_11 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %79 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %80 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%74, %79 : tensor, tensor) outs(%78 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_12 = tensor.extract_slice %41[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %81 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_12 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %82 = polygeist.submap(%5, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %83 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %84 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%83, %82 : tensor, tensor) outs(%81 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_13 = tensor.extract_slice %40[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %85 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_13 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %86 = polygeist.submap(%8, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %87 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %88 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%87, %86 : tensor, tensor) outs(%85 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_14 = tensor.extract_slice %35[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %89 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_14 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %90 = polygeist.submap(%8, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %91 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%84, %90 : tensor, tensor) outs(%89 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_15 = tensor.extract_slice %34[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %92 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_15 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %93 = polygeist.submap(%5, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %94 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%88, %93 : tensor, tensor) outs(%92 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_16 = tensor.extract_slice %29[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %95 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_16 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %96 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %97 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%91, %96 : tensor, tensor) outs(%95 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_17 = tensor.extract_slice %28[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %98 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_17 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %99 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %100 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%94, %99 : tensor, tensor) outs(%98 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_18 = tensor.extract_slice %27[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %101 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_18 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %102 = polygeist.submap(%7, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %103 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %104 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %105 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %106 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%103, %100, %80, %104, %60, %97, %105, %77, %57, %102 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%101 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_19 = tensor.extract_slice %21[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %107 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_19 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %108 = polygeist.submap(%6, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %109 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%106, %108 : tensor, tensor) outs(%107 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_20 = tensor.extract_slice %15[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %110 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_20 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %111 = polygeist.submap(%4, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %112 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%109, %111 : tensor, tensor) outs(%110 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_21 = tensor.extract_slice %26[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %113 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_21 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %114 = polygeist.submap(%7, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %115 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %116 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %117 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %118 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%115, %100, %80, %116, %60, %97, %117, %77, %57, %114 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%113 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_22 = tensor.extract_slice %20[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %119 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_22 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %120 = polygeist.submap(%4, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %121 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%118, %120 : tensor, tensor) outs(%119 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_23 = tensor.extract_slice %14[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %122 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_23 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %123 = polygeist.submap(%6, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %124 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%121, %123 : tensor, tensor) outs(%122 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_24 = tensor.extract_slice %25[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %125 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_24 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %126 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %127 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %128 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %129 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %130 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%127, %100, %80, %128, %60, %97, %129, %77, %57, %126 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%125 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_25 = tensor.extract_slice %19[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %131 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_25 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %132 = polygeist.submap(%7, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %133 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%130, %132 : tensor, tensor) outs(%131 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_26 = tensor.extract_slice %13[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %134 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_26 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %135 = polygeist.submap(%6, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %136 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%133, %135 : tensor, tensor) outs(%134 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_27 = tensor.extract_slice %24[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %137 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_27 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %138 = polygeist.submap(%6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %139 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %140 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %141 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %142 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%139, %100, %80, %140, %60, %97, %141, %77, %57, %138 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%137 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_28 = tensor.extract_slice %18[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %143 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_28 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %144 = polygeist.submap(%7, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %145 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%142, %144 : tensor, tensor) outs(%143 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_29 = tensor.extract_slice %12[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %146 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_29 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %147 = polygeist.submap(%4, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %148 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%145, %147 : tensor, tensor) outs(%146 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_30 = tensor.extract_slice %23[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %149 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_30 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %150 = polygeist.submap(%6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %151 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %152 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %153 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %154 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%151, %100, %80, %152, %60, %97, %153, %77, %57, %150 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%149 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_31 = tensor.extract_slice %17[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %155 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_31 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %156 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %157 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%154, %156 : tensor, tensor) outs(%155 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_32 = tensor.extract_slice %11[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %158 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_32 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %159 = polygeist.submap(%7, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %160 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%157, %159 : tensor, tensor) outs(%158 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_33 = tensor.extract_slice %22[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %161 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_33 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %162 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %163 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %164 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %165 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %166 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%163, %100, %80, %164, %60, %97, %165, %77, %57, %162 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%161 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_34 = tensor.extract_slice %16[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %167 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_34 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %168 = polygeist.submap(%6, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %169 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%166, %168 : tensor, tensor) outs(%167 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_35 = tensor.extract_slice %10[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %170 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_35 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %171 = polygeist.submap(%7, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %172 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%169, %171 : tensor, tensor) outs(%170 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %173 = polygeist.submap(%0, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, index, index, index, index) -> tensor + %174 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%112, %124 : tensor, tensor) outs(%173 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.subf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %175 = polygeist.submapInverse(%0, %174, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, tensor, index, index, index, index) -> tensor + %176 = polygeist.submap(%175, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, index, index, index, index) -> tensor + %177 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%136, %148 : tensor, tensor) outs(%176 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.subf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %178 = polygeist.submapInverse(%175, %177, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, tensor, index, index, index, index) -> tensor + %179 = polygeist.submap(%178, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, index, index, index, index) -> tensor + %180 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%160, %172 : tensor, tensor) outs(%179 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.subf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %181 = polygeist.submapInverse(%178, %180, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, tensor, index, index, index, index) -> tensor + %182 = tensor.empty() : tensor<2x3x5x5x5xf64> + %extracted_slice_36 = tensor.extract_slice %182[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %183 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_36 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %184 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map27} : (tensor, index, index, index, index, index, index, index) -> tensor + %185 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map28} : (tensor, index, index, index, index, index, index, index) -> tensor + %186 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map29} : (tensor, index, index, index, index, index, index, index) -> tensor + %187 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map30} : (tensor, index, index, index, index, index, index, index) -> tensor + %188 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%185, %186, %187, %184 : tensor, tensor, tensor, tensor) outs(%183 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %inserted_slice_37 = tensor.insert_slice %188 into %182[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_38 = tensor.extract_slice %inserted_slice_37[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %189 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_38 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %190 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map33} : (tensor, index, index, index, index, index, index, index) -> tensor + %191 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map28} : (tensor, index, index, index, index, index, index, index) -> tensor + %192 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map34} : (tensor, index, index, index, index, index, index, index) -> tensor + %193 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map35} : (tensor, index, index, index, index, index, index, index) -> tensor + %194 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%191, %190, %193, %192 : tensor, tensor, tensor, tensor) outs(%189 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %inserted_slice_39 = tensor.insert_slice %194 into %inserted_slice_37[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_40 = tensor.extract_slice %inserted_slice_39[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %195 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_40 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %196 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map36} : (tensor, index, index, index, index, index, index, index) -> tensor + %197 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map29} : (tensor, index, index, index, index, index, index, index) -> tensor + %198 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map34} : (tensor, index, index, index, index, index, index, index) -> tensor + %199 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map37} : (tensor, index, index, index, index, index, index, index) -> tensor + %200 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%196, %197, %199, %198 : tensor, tensor, tensor, tensor) outs(%195 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %inserted_slice_41 = tensor.insert_slice %200 into %inserted_slice_39[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_42 = tensor.extract_slice %inserted_slice_41[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %extracted_slice_43 = tensor.extract_slice %inserted_slice_41[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %201 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map38} : (tensor, index, index, index, index) -> tensor + %202 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index) -> tensor + %203 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index) -> tensor + %204 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index) -> tensor + %205 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map41} : (tensor, index, index, index, index) -> tensor + %206 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map42} : (tensor, index, index, index, index) -> tensor + %207 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index) -> tensor + %208 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map42} : (tensor, index, index, index, index) -> tensor + %209 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map43} : (tensor, index, index, index, index) -> tensor + %210:3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%201, %202, %203, %204, %205, %206, %207, %208, %209 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_42, %extracted_slice_43, %200 : tensor, tensor, tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %out: f64, %out_55: f64, %out_56: f64): + %230 = arith.mulf %in, %out : f64 + %231 = arith.mulf %in_47, %out_55 : f64 + %232 = arith.addf %230, %231 : f64 + %233 = arith.mulf %in_48, %out_56 : f64 + %234 = arith.addf %232, %233 : f64 + %235 = arith.mulf %in_49, %out : f64 + %236 = arith.mulf %in_50, %out_55 : f64 + %237 = arith.addf %235, %236 : f64 + %238 = arith.mulf %in_51, %out_56 : f64 + %239 = arith.addf %237, %238 : f64 + %240 = arith.mulf %in_52, %out : f64 + %241 = arith.mulf %in_53, %out_55 : f64 + %242 = arith.addf %240, %241 : f64 + %243 = arith.mulf %in_54, %out_56 : f64 + %244 = arith.addf %242, %243 : f64 + linalg.yield %234, %239, %244 : f64, f64, f64 + } -> (tensor, tensor, tensor) + %inserted_slice_44 = tensor.insert_slice %210#2 into %inserted_slice_39[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_45 = tensor.extract_slice %inserted_slice_44[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %211 = polygeist.submap(%7, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map44} : (tensor, index, index, index, index, index, index, index) -> tensor + %212 = polygeist.submap(%6, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map45} : (tensor, index, index, index, index, index, index, index) -> tensor + %213 = polygeist.submap(%6, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map46} : (tensor, index, index, index, index, index, index, index) -> tensor + %214 = polygeist.submap(%181, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, index, index, index, index) -> tensor + %215 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%212, %213, %extracted_slice_45, %211 : tensor, tensor, tensor, tensor) outs(%214 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %216 = polygeist.submapInverse(%181, %215, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, tensor, index, index, index, index) -> tensor + %extracted_slice_46 = tensor.extract_slice %inserted_slice_44[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %217 = polygeist.submap(%7, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map46} : (tensor, index, index, index, index, index, index, index) -> tensor + %218 = polygeist.submap(%6, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map45} : (tensor, index, index, index, index, index, index, index) -> tensor + %219 = polygeist.submap(%6, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map44} : (tensor, index, index, index, index, index, index, index) -> tensor + %220 = polygeist.submap(%216, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, index, index, index, index) -> tensor + %221 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%218, %217, %extracted_slice_46, %219 : tensor, tensor, tensor, tensor) outs(%220 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %222 = polygeist.submapInverse(%216, %221, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, tensor, index, index, index, index) -> tensor + %223 = polygeist.submap(%7, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map45} : (tensor, index, index, index, index, index, index, index) -> tensor + %224 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map46} : (tensor, index, index, index, index, index, index, index) -> tensor + %225 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map44} : (tensor, index, index, index, index, index, index, index) -> tensor + %226 = polygeist.submap(%222, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, index, index, index, index) -> tensor + %227 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%223, %224, %210#2, %225 : tensor, tensor, tensor, tensor) outs(%226 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %228 = polygeist.submapInverse(%222, %227, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, tensor, index, index, index, index) -> tensor + %229 = bufferization.to_memref %228 : memref + memref.copy %229, %arg9 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d.frontend.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d.frontend.mlir new file mode 100644 index 000000000000..b61f88a41839 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d.frontend.mlir @@ -0,0 +1,1882 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_abs_l1_curlcurl_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_13 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_14 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_15 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_16 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_21 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_22 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_23 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_24 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_25 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_26 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_27 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_28 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_29 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_30 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_31 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_32 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_33 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg8[%arg11 * 12 + %arg14 + %arg12 * 3 + %arg10 * 144] : memref + %2 = affine.load %arg0[%arg14 + %arg13 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_33[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg14 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_28[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg14 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_27[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_28[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg14 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_22[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_27[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg14 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_21[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg8[%arg11 * 12 + %arg14 + %arg12 * 4 + %arg10 * 144 + 48] : memref + %2 = affine.load %arg4[%arg14 + %arg13 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_32[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg8[%arg11 * 12 + %arg14 + %arg12 * 4 + %arg10 * 144 + 48] : memref + %2 = affine.load %arg1[%arg14 + %arg13 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_31[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_32[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg14 + %arg12 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_26[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_31[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg14 + %arg12 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_25[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_26[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg14 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_20[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_25[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg14 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_19[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg8[%arg11 * 16 + %arg14 + %arg12 * 4 + %arg10 * 144 + 96] : memref + %2 = affine.load %arg4[%arg14 + %arg13 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_30[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg8[%arg11 * 16 + %arg14 + %arg12 * 4 + %arg10 * 144 + 96] : memref + %2 = affine.load %arg1[%arg14 + %arg13 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_29[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_30[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg14 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_24[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_29[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg14 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_23[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_24[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg14 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_18[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_23[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg14 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_17[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg14 + %arg13 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg15, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_16[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_16[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg14 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg14 + %arg13 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg15, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_15[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg14 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg14 + %arg13 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg15, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_14[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg14 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5] : memref + %2 = affine.load %alloca_17[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg14 + %arg13 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg15, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_13[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg14 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5] : memref + %2 = affine.load %alloca_17[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg14 + %arg13 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg15, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_12[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg14 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg14 + %arg13 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg15, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_11[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg14 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.load %alloca_4[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_3[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg9[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg10 * 144] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg9[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg10 * 144] : memref + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.load %alloca_2[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_1[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg9[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg10 * 144 + 48] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg9[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg10 * 144 + 48] : memref + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 4 { + %0 = affine.load %alloca_0[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + %1 = affine.load %alloca[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg9[%arg11 * 16 + %arg13 + %arg12 * 4 + %arg10 * 144 + 96] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg9[%arg11 * 16 + %arg13 + %arg12 * 4 + %arg10 * 144 + 96] : memref + } + } + } + } + %alloca_34 = memref.alloca() : memref<2x3x5x5x5xf64> + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg14 + %arg11 * 4] : memref + %2 = affine.for %arg16 = 0 to 4 iter_args(%arg17 = %arg15) -> (f64) { + %3 = affine.load %arg1[%arg16 + %arg12 * 4] : memref + %4 = affine.for %arg18 = 0 to 3 iter_args(%arg19 = %arg17) -> (f64) { + %5 = affine.load %arg8[%arg14 * 12 + %arg18 + %arg16 * 3 + %arg10 * 144] : memref + %6 = affine.load %arg0[%arg18 + %arg13 * 3] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg19, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca_34[%arg10, 0, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg14 + %arg11 * 4] : memref + %2 = affine.for %arg16 = 0 to 3 iter_args(%arg17 = %arg15) -> (f64) { + %3 = affine.load %arg0[%arg16 + %arg12 * 3] : memref + %4 = affine.for %arg18 = 0 to 4 iter_args(%arg19 = %arg17) -> (f64) { + %5 = affine.load %arg8[%arg14 * 12 + %arg18 + %arg16 * 4 + %arg10 * 144 + 48] : memref + %6 = affine.load %arg1[%arg18 + %arg13 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg19, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca_34[%arg10, 1, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg14 + %arg11 * 3] : memref + %2 = affine.for %arg16 = 0 to 4 iter_args(%arg17 = %arg15) -> (f64) { + %3 = affine.load %arg1[%arg16 + %arg12 * 4] : memref + %4 = affine.for %arg18 = 0 to 4 iter_args(%arg19 = %arg17) -> (f64) { + %5 = affine.load %arg8[%arg14 * 16 + %arg18 + %arg16 * 4 + %arg10 * 144 + 96] : memref + %6 = affine.load %arg1[%arg18 + %arg13 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg19, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca_34[%arg10, 2, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.load %alloca_34[%arg10, 0, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %1 = affine.load %alloca_34[%arg10, 1, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %2 = affine.load %alloca_34[%arg10, 2, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %3 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750] : memref + %4 = arith.mulf %3, %0 : f64 + %5 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 125] : memref + %6 = arith.mulf %5, %1 : f64 + %7 = arith.addf %4, %6 : f64 + %8 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 250] : memref + %9 = arith.mulf %8, %2 : f64 + %10 = arith.addf %7, %9 : f64 + affine.store %10, %alloca_34[%arg10, 0, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %11 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 125] : memref + %12 = arith.mulf %11, %0 : f64 + %13 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 375] : memref + %14 = arith.mulf %13, %1 : f64 + %15 = arith.addf %12, %14 : f64 + %16 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 500] : memref + %17 = arith.mulf %16, %2 : f64 + %18 = arith.addf %15, %17 : f64 + affine.store %18, %alloca_34[%arg10, 1, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %19 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 250] : memref + %20 = arith.mulf %19, %0 : f64 + %21 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 500] : memref + %22 = arith.mulf %21, %1 : f64 + %23 = arith.addf %20, %22 : f64 + %24 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 625] : memref + %25 = arith.mulf %24, %2 : f64 + %26 = arith.addf %23, %25 : f64 + affine.store %26, %alloca_34[%arg10, 2, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %arg3[%arg14 + %arg11 * 5] : memref + %4 = affine.for %arg16 = 0 to 5 iter_args(%arg17 = %arg15) -> (f64) { + %5 = affine.load %arg3[%arg16 + %arg12 * 5] : memref + %6 = affine.for %arg18 = 0 to 5 iter_args(%arg19 = %arg17) -> (f64) { + %7 = affine.load %alloca_34[%arg10, 0, %arg14, %arg16, %arg18] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg2[%arg18 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg19, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg9[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg10 * 144] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg10 * 144] : memref + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %arg3[%arg14 + %arg11 * 5] : memref + %4 = affine.for %arg16 = 0 to 5 iter_args(%arg17 = %arg15) -> (f64) { + %5 = affine.load %arg2[%arg16 + %arg12 * 5] : memref + %6 = affine.for %arg18 = 0 to 5 iter_args(%arg19 = %arg17) -> (f64) { + %7 = affine.load %alloca_34[%arg10, 1, %arg14, %arg16, %arg18] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg3[%arg18 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg19, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg9[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg10 * 144 + 48] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg10 * 144 + 48] : memref + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %arg2[%arg14 + %arg11 * 5] : memref + %4 = affine.for %arg16 = 0 to 5 iter_args(%arg17 = %arg15) -> (f64) { + %5 = affine.load %arg3[%arg16 + %arg12 * 5] : memref + %6 = affine.for %arg18 = 0 to 5 iter_args(%arg19 = %arg17) -> (f64) { + %7 = affine.load %alloca_34[%arg10, 2, %arg14, %arg16, %arg18] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg3[%arg18 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg19, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg9[%arg11 * 16 + %arg13 + %arg12 * 4 + %arg10 * 144 + 96] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 16 + %arg13 + %arg12 * 4 + %arg10 * 144 + 96] : memref + } + } + } + } + return + } + func.func @mfem_pa_curlcurl_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_13 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_14 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_15 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_16 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_21 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_22 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_23 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_24 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_25 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_26 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_27 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_28 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_29 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_30 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_31 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_32 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_33 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 3 + %arg9 * 144] : memref + %2 = affine.load %arg0[%arg13 + %arg12 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_33[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_28[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_27[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_28[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_22[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_27[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_21[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %2 = affine.load %arg4[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_32[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %2 = affine.load %arg1[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_31[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_32[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg13 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_26[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_31[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg13 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_25[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_26[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_20[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_25[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_19[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 16 + %arg13 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %2 = affine.load %arg4[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_30[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 16 + %arg13 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %2 = affine.load %arg1[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_29[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_30[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_24[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_29[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_23[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_24[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg13 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_18[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_23[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg13 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_17[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_16[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_16[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_15[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_14[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_13[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_12[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_11[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.load %alloca_4[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_3[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 12 + %arg12 + %arg11 * 3 + %arg9 * 144] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 12 + %arg12 + %arg11 * 3 + %arg9 * 144] : memref + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.load %alloca_2[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_1[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 12 + %arg12 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 12 + %arg12 + %arg11 * 4 + %arg9 * 144 + 48] : memref + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.load %alloca_0[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 16 + %arg12 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 16 + %arg12 + %arg11 * 4 + %arg9 * 144 + 96] : memref + } + } + } + } + return + } + func.func @mfem_pa_hcurl_mass_apply_3d_direct(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x3x5x5x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg11 + %arg8 * 4] : memref + %2 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %arg12) -> (f64) { + %3 = affine.load %arg1[%arg13 + %arg9 * 4] : memref + %4 = affine.for %arg15 = 0 to 3 iter_args(%arg16 = %arg14) -> (f64) { + %5 = affine.load %arg5[%arg11 * 12 + %arg15 + %arg13 * 3 + %arg7 * 144] : memref + %6 = affine.load %arg0[%arg15 + %arg10 * 3] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg16, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca[%arg7, 0, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg11 + %arg8 * 4] : memref + %2 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %arg12) -> (f64) { + %3 = affine.load %arg0[%arg13 + %arg9 * 3] : memref + %4 = affine.for %arg15 = 0 to 4 iter_args(%arg16 = %arg14) -> (f64) { + %5 = affine.load %arg5[%arg11 * 12 + %arg15 + %arg13 * 4 + %arg7 * 144 + 48] : memref + %6 = affine.load %arg1[%arg15 + %arg10 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg16, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca[%arg7, 1, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %2 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %arg12) -> (f64) { + %3 = affine.load %arg1[%arg13 + %arg9 * 4] : memref + %4 = affine.for %arg15 = 0 to 4 iter_args(%arg16 = %arg14) -> (f64) { + %5 = affine.load %arg5[%arg11 * 16 + %arg15 + %arg13 * 4 + %arg7 * 144 + 96] : memref + %6 = affine.load %arg1[%arg15 + %arg10 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg16, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca[%arg7, 2, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.load %alloca[%arg7, 0, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %1 = affine.load %alloca[%arg7, 1, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %2 = affine.load %alloca[%arg7, 2, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %3 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750] : memref + %4 = arith.mulf %3, %0 : f64 + %5 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 125] : memref + %6 = arith.mulf %5, %1 : f64 + %7 = arith.addf %4, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 250] : memref + %9 = arith.mulf %8, %2 : f64 + %10 = arith.addf %7, %9 : f64 + affine.store %10, %alloca[%arg7, 0, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %11 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 125] : memref + %12 = arith.mulf %11, %0 : f64 + %13 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 375] : memref + %14 = arith.mulf %13, %1 : f64 + %15 = arith.addf %12, %14 : f64 + %16 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 500] : memref + %17 = arith.mulf %16, %2 : f64 + %18 = arith.addf %15, %17 : f64 + affine.store %18, %alloca[%arg7, 1, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %19 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 250] : memref + %20 = arith.mulf %19, %0 : f64 + %21 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 500] : memref + %22 = arith.mulf %21, %1 : f64 + %23 = arith.addf %20, %22 : f64 + %24 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 625] : memref + %25 = arith.mulf %24, %2 : f64 + %26 = arith.addf %23, %25 : f64 + affine.store %26, %alloca[%arg7, 2, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %4 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %arg12) -> (f64) { + %5 = affine.load %arg3[%arg13 + %arg9 * 5] : memref + %6 = affine.for %arg15 = 0 to 5 iter_args(%arg16 = %arg14) -> (f64) { + %7 = affine.load %alloca[%arg7, 0, %arg11, %arg13, %arg15] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg2[%arg15 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg16, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 144] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 144] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %4 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %arg12) -> (f64) { + %5 = affine.load %arg2[%arg13 + %arg9 * 5] : memref + %6 = affine.for %arg15 = 0 to 5 iter_args(%arg16 = %arg14) -> (f64) { + %7 = affine.load %alloca[%arg7, 1, %arg11, %arg13, %arg15] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg3[%arg15 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg16, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 144 + 48] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 144 + 48] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %4 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %arg12) -> (f64) { + %5 = affine.load %arg3[%arg13 + %arg9 * 5] : memref + %6 = affine.for %arg15 = 0 to 5 iter_args(%arg16 = %arg14) -> (f64) { + %7 = affine.load %alloca[%arg7, 2, %arg11, %arg13, %arg15] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg3[%arg15 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg16, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg6[%arg8 * 16 + %arg10 + %arg9 * 4 + %arg7 * 144 + 96] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 16 + %arg10 + %arg9 * 4 + %arg7 * 144 + 96] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d.matched.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d.matched.mlir new file mode 100644 index 000000000000..51a00b9c99d7 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d.matched.mlir @@ -0,0 +1,498 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 144)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 125)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 375)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 500)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 250)> +#map22 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 625)> +#map23 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 144)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map26 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map27 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 3)> +#map28 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 4)> +#map29 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 4)> +#map30 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 3 + d0 * 144)> +#map31 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map32 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +#map33 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 3)> +#map34 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 4)> +#map35 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 4 + d0 * 144 + 48)> +#map36 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 3)> +#map37 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 16 + d5 * 4 + d0 * 144 + 96)> +#map38 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750)> +#map39 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 125)> +#map40 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 250)> +#map41 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 375)> +#map42 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 500)> +#map43 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 625)> +#map44 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 5)> +#map45 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 5)> +#map46 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 5)> +#map47 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_abs_l1_curlcurl_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg9 : memref + %1 = bufferization.to_tensor %arg8 : memref + %2 = bufferization.to_tensor %arg7 : memref + %3 = bufferization.to_tensor %arg6 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg3 : memref + %7 = bufferization.to_tensor %arg2 : memref + %8 = bufferization.to_tensor %arg1 : memref + %9 = bufferization.to_tensor %arg0 : memref + %10 = tensor.empty() : tensor<2x4x4x4xf64> + %11 = tensor.empty() : tensor<2x4x4x4xf64> + %12 = tensor.empty() : tensor<2x4x4x4xf64> + %13 = tensor.empty() : tensor<2x4x4x4xf64> + %14 = tensor.empty() : tensor<2x4x4x4xf64> + %15 = tensor.empty() : tensor<2x4x4x4xf64> + %16 = tensor.empty() : tensor<2x5x4x4xf64> + %17 = tensor.empty() : tensor<2x5x4x4xf64> + %18 = tensor.empty() : tensor<2x5x4x4xf64> + %19 = tensor.empty() : tensor<2x5x4x4xf64> + %20 = tensor.empty() : tensor<2x5x4x4xf64> + %21 = tensor.empty() : tensor<2x5x4x4xf64> + %22 = tensor.empty() : tensor<2x5x5x4xf64> + %23 = tensor.empty() : tensor<2x5x5x4xf64> + %24 = tensor.empty() : tensor<2x5x5x4xf64> + %25 = tensor.empty() : tensor<2x5x5x4xf64> + %26 = tensor.empty() : tensor<2x5x5x4xf64> + %27 = tensor.empty() : tensor<2x5x5x4xf64> + %28 = tensor.empty() : tensor<2x5x5x5xf64> + %29 = tensor.empty() : tensor<2x5x5x5xf64> + %30 = tensor.empty() : tensor<2x5x5x5xf64> + %31 = tensor.empty() : tensor<2x5x5x5xf64> + %32 = tensor.empty() : tensor<2x5x5x5xf64> + %33 = tensor.empty() : tensor<2x5x5x5xf64> + %34 = tensor.empty() : tensor<2x4x5x5xf64> + %35 = tensor.empty() : tensor<2x4x5x5xf64> + %36 = tensor.empty() : tensor<2x4x5x5xf64> + %37 = tensor.empty() : tensor<2x4x5x5xf64> + %38 = tensor.empty() : tensor<2x4x5x5xf64> + %39 = tensor.empty() : tensor<2x4x5x5xf64> + %40 = tensor.empty() : tensor<2x4x4x5xf64> + %41 = tensor.empty() : tensor<2x4x4x5xf64> + %42 = tensor.empty() : tensor<2x4x4x5xf64> + %43 = tensor.empty() : tensor<2x4x4x5xf64> + %44 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice = tensor.extract_slice %44[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %45 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %45 into %44[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %46 = polygeist.submap(%9, %c2, %c4, %c4, %c5, %c3) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %47 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c3) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %inserted_slice_contract_48_tc2 = tensor.cast %inserted_slice : tensor<2x4x4x5xf64> to tensor + + %v48_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%47, %46, %inserted_slice_contract_48_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %48 = tensor.cast %v48_tdyn : tensor to tensor<2x4x4x5xf64> + %extracted_slice_0 = tensor.extract_slice %39[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_1 = tensor.extract_slice %48[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %50 = polygeist.submap(%5, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %51 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_1, %50, %extracted_slice_0) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_2 = tensor.extract_slice %38[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_3 = tensor.extract_slice %48[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %53 = polygeist.submap(%8, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %54 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_3, %53, %extracted_slice_2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_4 = tensor.extract_slice %33[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %56 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %57 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%51, %56, %extracted_slice_4) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_5 = tensor.extract_slice %32[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %59 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %60 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%54, %59, %extracted_slice_5) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_6 = tensor.extract_slice %43[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %62 = polygeist.submap(%5, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %63 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %64 = kernel.launch @cutensornetContraction2_f64_r5r5r4(%63, %62, %extracted_slice_6) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_7 = tensor.extract_slice %42[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %66 = polygeist.submap(%8, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %67 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %68 = kernel.launch @cutensornetContraction2_f64_r5r5r4(%67, %66, %extracted_slice_7) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_8 = tensor.extract_slice %37[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %70 = polygeist.submap(%9, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %71 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%64, %70, %extracted_slice_8) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_9 = tensor.extract_slice %36[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %73 = polygeist.submap(%9, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %74 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%68, %73, %extracted_slice_9) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_10 = tensor.extract_slice %31[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %76 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %77 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%71, %76, %extracted_slice_10) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_11 = tensor.extract_slice %30[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %79 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %80 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%74, %79, %extracted_slice_11) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_12 = tensor.extract_slice %41[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %82 = polygeist.submap(%5, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %83 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %84 = kernel.launch @cutensornetContraction2_f64_r5r5r4(%83, %82, %extracted_slice_12) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_13 = tensor.extract_slice %40[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %86 = polygeist.submap(%8, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %87 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %88 = kernel.launch @cutensornetContraction2_f64_r5r5r4(%87, %86, %extracted_slice_13) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_14 = tensor.extract_slice %35[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %90 = polygeist.submap(%8, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %91 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%84, %90, %extracted_slice_14) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_15 = tensor.extract_slice %34[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %93 = polygeist.submap(%5, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %94 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%88, %93, %extracted_slice_15) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_16 = tensor.extract_slice %29[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %96 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %97 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%91, %96, %extracted_slice_16) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_17 = tensor.extract_slice %28[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %99 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %100 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%94, %99, %extracted_slice_17) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_18 = tensor.extract_slice %27[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %101 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_18 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %102 = polygeist.submap(%7, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %103 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %104 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %105 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %106 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%103, %100, %80, %104, %60, %97, %105, %77, %57, %102 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%101 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_19 = tensor.extract_slice %21[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %108 = polygeist.submap(%6, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %109 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%106, %108, %extracted_slice_19) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_20 = tensor.extract_slice %15[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %111 = polygeist.submap(%4, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %112 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%109, %111, %extracted_slice_20) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_21 = tensor.extract_slice %26[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %113 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_21 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %114 = polygeist.submap(%7, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %115 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %116 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %117 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %118 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%115, %100, %80, %116, %60, %97, %117, %77, %57, %114 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%113 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_22 = tensor.extract_slice %20[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %120 = polygeist.submap(%4, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %121 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%118, %120, %extracted_slice_22) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_23 = tensor.extract_slice %14[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %123 = polygeist.submap(%6, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %124 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%121, %123, %extracted_slice_23) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_24 = tensor.extract_slice %25[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %125 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_24 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %126 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %127 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %128 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %129 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %130 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%127, %100, %80, %128, %60, %97, %129, %77, %57, %126 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%125 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_25 = tensor.extract_slice %19[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %132 = polygeist.submap(%7, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %133 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%130, %132, %extracted_slice_25) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_26 = tensor.extract_slice %13[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %135 = polygeist.submap(%6, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %136 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%133, %135, %extracted_slice_26) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_27 = tensor.extract_slice %24[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %137 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_27 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %138 = polygeist.submap(%6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %139 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %140 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %141 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %142 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%139, %100, %80, %140, %60, %97, %141, %77, %57, %138 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%137 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_28 = tensor.extract_slice %18[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %144 = polygeist.submap(%7, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %145 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%142, %144, %extracted_slice_28) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_29 = tensor.extract_slice %12[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %147 = polygeist.submap(%4, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %148 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%145, %147, %extracted_slice_29) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_30 = tensor.extract_slice %23[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %149 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_30 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %150 = polygeist.submap(%6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %151 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %152 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %153 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %154 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%151, %100, %80, %152, %60, %97, %153, %77, %57, %150 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%149 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_31 = tensor.extract_slice %17[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %156 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %157 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%154, %156, %extracted_slice_31) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_32 = tensor.extract_slice %11[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %159 = polygeist.submap(%7, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %160 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%157, %159, %extracted_slice_32) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_33 = tensor.extract_slice %22[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %161 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_33 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %162 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %163 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %164 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %165 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %166 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%163, %100, %80, %164, %60, %97, %165, %77, %57, %162 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%161 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_34 = tensor.extract_slice %16[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %168 = polygeist.submap(%6, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %169 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%166, %168, %extracted_slice_34) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_35 = tensor.extract_slice %10[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %171 = polygeist.submap(%7, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %172 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%169, %171, %extracted_slice_35) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %173 = polygeist.submap(%0, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, index, index, index, index) -> tensor + %174 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%112, %124 : tensor, tensor) outs(%173 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.subf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %175 = polygeist.submapInverse(%0, %174, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, tensor, index, index, index, index) -> tensor + %176 = polygeist.submap(%175, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, index, index, index, index) -> tensor + %177 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%136, %148 : tensor, tensor) outs(%176 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.subf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %178 = polygeist.submapInverse(%175, %177, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, tensor, index, index, index, index) -> tensor + %179 = polygeist.submap(%178, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, index, index, index, index) -> tensor + %180 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%160, %172 : tensor, tensor) outs(%179 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.subf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %181 = polygeist.submapInverse(%178, %180, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, tensor, index, index, index, index) -> tensor + %182 = tensor.empty() : tensor<2x3x5x5x5xf64> + %extracted_slice_36 = tensor.extract_slice %182[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %183 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_36 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %184 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map27} : (tensor, index, index, index, index, index, index, index) -> tensor + %185 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map28} : (tensor, index, index, index, index, index, index, index) -> tensor + %186 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map29} : (tensor, index, index, index, index, index, index, index) -> tensor + %187 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map30} : (tensor, index, index, index, index, index, index, index) -> tensor + %188 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%185, %186, %187, %184 : tensor, tensor, tensor, tensor) outs(%183 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %inserted_slice_37 = tensor.insert_slice %188 into %182[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_38 = tensor.extract_slice %inserted_slice_37[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %189 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_38 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %190 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map33} : (tensor, index, index, index, index, index, index, index) -> tensor + %191 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map28} : (tensor, index, index, index, index, index, index, index) -> tensor + %192 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map34} : (tensor, index, index, index, index, index, index, index) -> tensor + %193 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map35} : (tensor, index, index, index, index, index, index, index) -> tensor + %194 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%191, %190, %193, %192 : tensor, tensor, tensor, tensor) outs(%189 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %inserted_slice_39 = tensor.insert_slice %194 into %inserted_slice_37[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_40 = tensor.extract_slice %inserted_slice_39[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %195 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_40 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %196 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map36} : (tensor, index, index, index, index, index, index, index) -> tensor + %197 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map29} : (tensor, index, index, index, index, index, index, index) -> tensor + %198 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map34} : (tensor, index, index, index, index, index, index, index) -> tensor + %199 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map37} : (tensor, index, index, index, index, index, index, index) -> tensor + %200 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%196, %197, %199, %198 : tensor, tensor, tensor, tensor) outs(%195 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %inserted_slice_41 = tensor.insert_slice %200 into %inserted_slice_39[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_42 = tensor.extract_slice %inserted_slice_41[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %extracted_slice_43 = tensor.extract_slice %inserted_slice_41[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %201 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map38} : (tensor, index, index, index, index) -> tensor + %202 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index) -> tensor + %203 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index) -> tensor + %204 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index) -> tensor + %205 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map41} : (tensor, index, index, index, index) -> tensor + %206 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map42} : (tensor, index, index, index, index) -> tensor + %207 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index) -> tensor + %208 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map42} : (tensor, index, index, index, index) -> tensor + %209 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map43} : (tensor, index, index, index, index) -> tensor + %210:3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%201, %202, %203, %204, %205, %206, %207, %208, %209 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_42, %extracted_slice_43, %200 : tensor, tensor, tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %out: f64, %out_55: f64, %out_56: f64): + %230 = arith.mulf %in, %out : f64 + %231 = arith.mulf %in_47, %out_55 : f64 + %232 = arith.addf %230, %231 : f64 + %233 = arith.mulf %in_48, %out_56 : f64 + %234 = arith.addf %232, %233 : f64 + %235 = arith.mulf %in_49, %out : f64 + %236 = arith.mulf %in_50, %out_55 : f64 + %237 = arith.addf %235, %236 : f64 + %238 = arith.mulf %in_51, %out_56 : f64 + %239 = arith.addf %237, %238 : f64 + %240 = arith.mulf %in_52, %out : f64 + %241 = arith.mulf %in_53, %out_55 : f64 + %242 = arith.addf %240, %241 : f64 + %243 = arith.mulf %in_54, %out_56 : f64 + %244 = arith.addf %242, %243 : f64 + linalg.yield %234, %239, %244 : f64, f64, f64 + } -> (tensor, tensor, tensor) + %inserted_slice_44 = tensor.insert_slice %210#2 into %inserted_slice_39[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_45 = tensor.extract_slice %inserted_slice_44[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %211 = polygeist.submap(%7, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map44} : (tensor, index, index, index, index, index, index, index) -> tensor + %212 = polygeist.submap(%6, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map45} : (tensor, index, index, index, index, index, index, index) -> tensor + %213 = polygeist.submap(%6, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map46} : (tensor, index, index, index, index, index, index, index) -> tensor + %214 = polygeist.submap(%181, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, index, index, index, index) -> tensor + %215 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%212, %213, %extracted_slice_45, %211 : tensor, tensor, tensor, tensor) outs(%214 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %216 = polygeist.submapInverse(%181, %215, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, tensor, index, index, index, index) -> tensor + %extracted_slice_46 = tensor.extract_slice %inserted_slice_44[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %217 = polygeist.submap(%7, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map46} : (tensor, index, index, index, index, index, index, index) -> tensor + %218 = polygeist.submap(%6, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map45} : (tensor, index, index, index, index, index, index, index) -> tensor + %219 = polygeist.submap(%6, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map44} : (tensor, index, index, index, index, index, index, index) -> tensor + %220 = polygeist.submap(%216, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, index, index, index, index) -> tensor + %221 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%218, %217, %extracted_slice_46, %219 : tensor, tensor, tensor, tensor) outs(%220 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %222 = polygeist.submapInverse(%216, %221, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, tensor, index, index, index, index) -> tensor + %223 = polygeist.submap(%7, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map45} : (tensor, index, index, index, index, index, index, index) -> tensor + %224 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map46} : (tensor, index, index, index, index, index, index, index) -> tensor + %225 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map44} : (tensor, index, index, index, index, index, index, index) -> tensor + %226 = polygeist.submap(%222, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, index, index, index, index) -> tensor + %227 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%223, %224, %210#2, %225 : tensor, tensor, tensor, tensor) outs(%226 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %228 = polygeist.submapInverse(%222, %227, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, tensor, index, index, index, index) -> tensor + %229 = bufferization.to_memref %228 : memref + memref.copy %229, %arg9 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d.raised.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d.raised.mlir new file mode 100644 index 000000000000..c80c8f212b15 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d.raised.mlir @@ -0,0 +1,831 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 144)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 125)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 375)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 500)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 250)> +#map22 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 625)> +#map23 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 144)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map26 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map27 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 4)> +#map28 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 4)> +#map29 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 3 + d0 * 144)> +#map30 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 3)> +#map31 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map32 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +#map33 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 3)> +#map34 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 4 + d0 * 144 + 48)> +#map35 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 4)> +#map36 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 3)> +#map37 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 16 + d5 * 4 + d0 * 144 + 96)> +#map38 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750)> +#map39 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 125)> +#map40 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 250)> +#map41 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 375)> +#map42 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 500)> +#map43 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 625)> +#map44 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 5)> +#map45 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 5)> +#map46 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 5)> +#map47 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_abs_l1_curlcurl_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_13 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_14 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_15 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_16 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_21 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_22 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_23 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_24 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_25 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_26 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_27 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_28 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_29 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_30 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_31 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_32 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_33 = memref.alloca() : memref<2x4x4x5xf64> + %subview = memref.subview %alloca_33[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg8, %c2, %c4, %c4, %c5, %c3) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c3) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_33 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_34 = memref.subview %alloca_28[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_34 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_35 = memref.subview %alloca_33[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %2 = polygeist.submap(%arg4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_36 = memref.subview %alloca_28[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_35, %2 : memref>, memref) outs(%subview_36 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_37 = memref.subview %alloca_27[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_37 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_38 = memref.subview %alloca_33[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %3 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_39 = memref.subview %alloca_27[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_38, %3 : memref>, memref) outs(%subview_39 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_40 = memref.subview %alloca_22[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_40 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_41 = memref.subview %alloca_28[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %4 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_42 = memref.subview %alloca_22[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_41, %4 : memref>, memref) outs(%subview_42 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_43 = memref.subview %alloca_21[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_43 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_44 = memref.subview %alloca_27[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %5 = polygeist.submap(%arg4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_45 = memref.subview %alloca_21[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_44, %5 : memref>, memref) outs(%subview_45 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_46 = memref.subview %alloca_32[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_46 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg8, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (memref, index, index, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_47 = memref.subview %alloca_32[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%6, %7 : memref, memref) outs(%subview_47 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_48 = memref.subview %alloca_31[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_48 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg8, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (memref, index, index, index, index, index) -> memref + %9 = polygeist.submap(%arg1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_49 = memref.subview %alloca_31[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%8, %9 : memref, memref) outs(%subview_49 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_50 = memref.subview %alloca_26[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_50 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_51 = memref.subview %alloca_32[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %10 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (memref, index, index, index, index, index) -> memref + %subview_52 = memref.subview %alloca_26[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_51, %10 : memref>, memref) outs(%subview_52 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_53 = memref.subview %alloca_25[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_53 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_54 = memref.subview %alloca_31[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %11 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (memref, index, index, index, index, index) -> memref + %subview_55 = memref.subview %alloca_25[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_54, %11 : memref>, memref) outs(%subview_55 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_56 = memref.subview %alloca_20[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_56 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_57 = memref.subview %alloca_26[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %12 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_58 = memref.subview %alloca_20[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_57, %12 : memref>, memref) outs(%subview_58 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_59 = memref.subview %alloca_19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_59 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_60 = memref.subview %alloca_25[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %13 = polygeist.submap(%arg4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_61 = memref.subview %alloca_19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_60, %13 : memref>, memref) outs(%subview_61 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_62 = memref.subview %alloca_30[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_62 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg8, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %15 = polygeist.submap(%arg4, %c2, %c3, %c4, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_63 = memref.subview %alloca_30[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%14, %15 : memref, memref) outs(%subview_63 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_64 = memref.subview %alloca_29[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_64 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %16 = polygeist.submap(%arg8, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %17 = polygeist.submap(%arg1, %c2, %c3, %c4, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_65 = memref.subview %alloca_29[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%16, %17 : memref, memref) outs(%subview_65 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_66 = memref.subview %alloca_24[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_66 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_67 = memref.subview %alloca_30[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %18 = polygeist.submap(%arg1, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_68 = memref.subview %alloca_24[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_67, %18 : memref>, memref) outs(%subview_68 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_69 = memref.subview %alloca_23[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_69 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_70 = memref.subview %alloca_29[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %19 = polygeist.submap(%arg4, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_71 = memref.subview %alloca_23[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_70, %19 : memref>, memref) outs(%subview_71 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_72 = memref.subview %alloca_18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_72 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_73 = memref.subview %alloca_24[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %20 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (memref, index, index, index, index, index) -> memref + %subview_74 = memref.subview %alloca_18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_73, %20 : memref>, memref) outs(%subview_74 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_75 = memref.subview %alloca_17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_75 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_76 = memref.subview %alloca_23[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %21 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (memref, index, index, index, index, index) -> memref + %subview_77 = memref.subview %alloca_17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_76, %21 : memref>, memref) outs(%subview_77 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_78 = memref.subview %alloca_16[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_78 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %22 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %subview_79 = memref.subview %alloca_17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_80 = memref.subview %alloca_19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %23 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_81 = memref.subview %alloca_21[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_82 = memref.subview %alloca_18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %24 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %subview_83 = memref.subview %alloca_20[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_84 = memref.subview %alloca_22[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %25 = polygeist.submap(%arg2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_85 = memref.subview %alloca_16[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%22, %subview_79, %subview_80, %23, %subview_81, %subview_82, %24, %subview_83, %subview_84, %25 : memref, memref>, memref>, memref, memref>, memref>, memref, memref>, memref>, memref) outs(%subview_85 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %in_184: f64, %in_185: f64, %in_186: f64, %in_187: f64, %in_188: f64, %in_189: f64, %out: f64): + %94 = arith.subf %in_181, %in_182 : f64 + %95 = arith.mulf %in, %94 : f64 + %96 = arith.subf %in_184, %in_185 : f64 + %97 = arith.mulf %in_183, %96 : f64 + %98 = arith.addf %95, %97 : f64 + %99 = arith.subf %in_187, %in_188 : f64 + %100 = arith.mulf %in_186, %99 : f64 + %101 = arith.addf %98, %100 : f64 + %102 = arith.mulf %101, %in_189 : f64 + %103 = arith.addf %out, %102 : f64 + linalg.yield %103 : f64 + } + %subview_86 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_86 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_87 = memref.subview %alloca_16[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %26 = polygeist.submap(%arg3, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + %subview_88 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_87, %26 : memref>, memref) outs(%subview_88 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_89 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_89 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_90 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %27 = polygeist.submap(%arg5, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + %subview_91 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_90, %27 : memref>, memref) outs(%subview_91 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_92 = memref.subview %alloca_15[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_92 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %28 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %subview_93 = memref.subview %alloca_17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_94 = memref.subview %alloca_19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %29 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %subview_95 = memref.subview %alloca_21[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_96 = memref.subview %alloca_18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %30 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map22} : (memref, index, index, index, index, index) -> memref + %subview_97 = memref.subview %alloca_20[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_98 = memref.subview %alloca_22[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %31 = polygeist.submap(%arg2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_99 = memref.subview %alloca_15[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%28, %subview_93, %subview_94, %29, %subview_95, %subview_96, %30, %subview_97, %subview_98, %31 : memref, memref>, memref>, memref, memref>, memref>, memref, memref>, memref>, memref) outs(%subview_99 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %in_184: f64, %in_185: f64, %in_186: f64, %in_187: f64, %in_188: f64, %in_189: f64, %out: f64): + %94 = arith.subf %in_181, %in_182 : f64 + %95 = arith.mulf %in, %94 : f64 + %96 = arith.subf %in_184, %in_185 : f64 + %97 = arith.mulf %in_183, %96 : f64 + %98 = arith.addf %95, %97 : f64 + %99 = arith.subf %in_187, %in_188 : f64 + %100 = arith.mulf %in_186, %99 : f64 + %101 = arith.addf %98, %100 : f64 + %102 = arith.mulf %101, %in_189 : f64 + %103 = arith.addf %out, %102 : f64 + linalg.yield %103 : f64 + } + %subview_100 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_100 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_101 = memref.subview %alloca_15[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %32 = polygeist.submap(%arg5, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + %subview_102 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_101, %32 : memref>, memref) outs(%subview_102 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_103 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_103 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_104 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %33 = polygeist.submap(%arg3, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + %subview_105 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_104, %33 : memref>, memref) outs(%subview_105 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_106 = memref.subview %alloca_14[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_106 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %34 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %subview_107 = memref.subview %alloca_17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_108 = memref.subview %alloca_19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %35 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %subview_109 = memref.subview %alloca_21[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_110 = memref.subview %alloca_18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %36 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map22} : (memref, index, index, index, index, index) -> memref + %subview_111 = memref.subview %alloca_20[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_112 = memref.subview %alloca_22[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %37 = polygeist.submap(%arg5, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_113 = memref.subview %alloca_14[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%34, %subview_107, %subview_108, %35, %subview_109, %subview_110, %36, %subview_111, %subview_112, %37 : memref, memref>, memref>, memref, memref>, memref>, memref, memref>, memref>, memref) outs(%subview_113 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %in_184: f64, %in_185: f64, %in_186: f64, %in_187: f64, %in_188: f64, %in_189: f64, %out: f64): + %94 = arith.subf %in_181, %in_182 : f64 + %95 = arith.mulf %in, %94 : f64 + %96 = arith.subf %in_184, %in_185 : f64 + %97 = arith.mulf %in_183, %96 : f64 + %98 = arith.addf %95, %97 : f64 + %99 = arith.subf %in_187, %in_188 : f64 + %100 = arith.mulf %in_186, %99 : f64 + %101 = arith.addf %98, %100 : f64 + %102 = arith.mulf %101, %in_189 : f64 + %103 = arith.addf %out, %102 : f64 + linalg.yield %103 : f64 + } + %subview_114 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_114 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_115 = memref.subview %alloca_14[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %38 = polygeist.submap(%arg2, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + %subview_116 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_115, %38 : memref>, memref) outs(%subview_116 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_117 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_117 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_118 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %39 = polygeist.submap(%arg3, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + %subview_119 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_118, %39 : memref>, memref) outs(%subview_119 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_120 = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_120 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %40 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (memref, index, index, index, index, index) -> memref + %subview_121 = memref.subview %alloca_17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_122 = memref.subview %alloca_19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %41 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %subview_123 = memref.subview %alloca_21[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_124 = memref.subview %alloca_18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %42 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %subview_125 = memref.subview %alloca_20[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_126 = memref.subview %alloca_22[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %43 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_127 = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%40, %subview_121, %subview_122, %41, %subview_123, %subview_124, %42, %subview_125, %subview_126, %43 : memref, memref>, memref>, memref, memref>, memref>, memref, memref>, memref>, memref) outs(%subview_127 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %in_184: f64, %in_185: f64, %in_186: f64, %in_187: f64, %in_188: f64, %in_189: f64, %out: f64): + %94 = arith.subf %in_181, %in_182 : f64 + %95 = arith.mulf %in, %94 : f64 + %96 = arith.subf %in_184, %in_185 : f64 + %97 = arith.mulf %in_183, %96 : f64 + %98 = arith.addf %95, %97 : f64 + %99 = arith.subf %in_187, %in_188 : f64 + %100 = arith.mulf %in_186, %99 : f64 + %101 = arith.addf %98, %100 : f64 + %102 = arith.mulf %101, %in_189 : f64 + %103 = arith.addf %out, %102 : f64 + linalg.yield %103 : f64 + } + %subview_128 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_128 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_129 = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %44 = polygeist.submap(%arg2, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + %subview_130 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_129, %44 : memref>, memref) outs(%subview_130 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_131 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_131 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_132 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %45 = polygeist.submap(%arg5, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + %subview_133 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_132, %45 : memref>, memref) outs(%subview_133 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_134 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_134 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %46 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (memref, index, index, index, index, index) -> memref + %subview_135 = memref.subview %alloca_17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_136 = memref.subview %alloca_19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %47 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %subview_137 = memref.subview %alloca_21[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_138 = memref.subview %alloca_18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %48 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %subview_139 = memref.subview %alloca_20[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_140 = memref.subview %alloca_22[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %49 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_141 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%46, %subview_135, %subview_136, %47, %subview_137, %subview_138, %48, %subview_139, %subview_140, %49 : memref, memref>, memref>, memref, memref>, memref>, memref, memref>, memref>, memref) outs(%subview_141 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %in_184: f64, %in_185: f64, %in_186: f64, %in_187: f64, %in_188: f64, %in_189: f64, %out: f64): + %94 = arith.subf %in_181, %in_182 : f64 + %95 = arith.mulf %in, %94 : f64 + %96 = arith.subf %in_184, %in_185 : f64 + %97 = arith.mulf %in_183, %96 : f64 + %98 = arith.addf %95, %97 : f64 + %99 = arith.subf %in_187, %in_188 : f64 + %100 = arith.mulf %in_186, %99 : f64 + %101 = arith.addf %98, %100 : f64 + %102 = arith.mulf %101, %in_189 : f64 + %103 = arith.addf %out, %102 : f64 + linalg.yield %103 : f64 + } + %subview_142 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_142 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_143 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %50 = polygeist.submap(%arg5, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + %subview_144 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_143, %50 : memref>, memref) outs(%subview_144 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_145 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_145 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_146 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %51 = polygeist.submap(%arg2, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + %subview_147 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_146, %51 : memref>, memref) outs(%subview_147 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_148 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_148 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %52 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %subview_149 = memref.subview %alloca_17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_150 = memref.subview %alloca_19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %53 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_151 = memref.subview %alloca_21[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_152 = memref.subview %alloca_18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %54 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %subview_153 = memref.subview %alloca_20[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_154 = memref.subview %alloca_22[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %55 = polygeist.submap(%arg5, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_155 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%52, %subview_149, %subview_150, %53, %subview_151, %subview_152, %54, %subview_153, %subview_154, %55 : memref, memref>, memref>, memref, memref>, memref>, memref, memref>, memref>, memref) outs(%subview_155 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %in_184: f64, %in_185: f64, %in_186: f64, %in_187: f64, %in_188: f64, %in_189: f64, %out: f64): + %94 = arith.subf %in_181, %in_182 : f64 + %95 = arith.mulf %in, %94 : f64 + %96 = arith.subf %in_184, %in_185 : f64 + %97 = arith.mulf %in_183, %96 : f64 + %98 = arith.addf %95, %97 : f64 + %99 = arith.subf %in_187, %in_188 : f64 + %100 = arith.mulf %in_186, %99 : f64 + %101 = arith.addf %98, %100 : f64 + %102 = arith.mulf %101, %in_189 : f64 + %103 = arith.addf %out, %102 : f64 + linalg.yield %103 : f64 + } + %subview_156 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_156 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_157 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %56 = polygeist.submap(%arg3, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + %subview_158 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_157, %56 : memref>, memref) outs(%subview_158 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_159 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_159 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_160 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %57 = polygeist.submap(%arg2, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + %subview_161 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_160, %57 : memref>, memref) outs(%subview_161 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_162 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_163 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %58 = polygeist.submap(%arg9, %c2, %c4, %c4, %c3) {map = #map24} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_162, %subview_163 : memref>, memref>) outs(%58 : memref) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.subf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_164 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_165 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %59 = polygeist.submap(%arg9, %c2, %c4, %c3, %c4) {map = #map25} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_164, %subview_165 : memref>, memref>) outs(%59 : memref) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.subf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_166 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_167 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %60 = polygeist.submap(%arg9, %c2, %c3, %c4, %c4) {map = #map26} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_166, %subview_167 : memref>, memref>) outs(%60 : memref) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.subf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %alloca_168 = memref.alloca() : memref<2x3x5x5x5xf64> + %subview_169 = memref.subview %alloca_168[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_169 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %61 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map27} : (memref, index, index, index, index, index, index, index) -> memref + %62 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map28} : (memref, index, index, index, index, index, index, index) -> memref + %63 = polygeist.submap(%arg8, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map29} : (memref, index, index, index, index, index, index, index) -> memref + %64 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map30} : (memref, index, index, index, index, index, index, index) -> memref + %subview_170 = memref.subview %alloca_168[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%61, %62, %63, %64 : memref, memref, memref, memref) outs(%subview_170 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %out: f64): + %94 = arith.mulf %in_182, %in_183 : f64 + %95 = arith.mulf %94, %in_181 : f64 + %96 = arith.mulf %95, %in : f64 + %97 = arith.addf %out, %96 : f64 + linalg.yield %97 : f64 + } + %subview_171 = memref.subview %alloca_168[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_171 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %65 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map27} : (memref, index, index, index, index, index, index, index) -> memref + %66 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map33} : (memref, index, index, index, index, index, index, index) -> memref + %67 = polygeist.submap(%arg8, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map34} : (memref, index, index, index, index, index, index, index) -> memref + %68 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map35} : (memref, index, index, index, index, index, index, index) -> memref + %subview_172 = memref.subview %alloca_168[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%65, %66, %67, %68 : memref, memref, memref, memref) outs(%subview_172 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %out: f64): + %94 = arith.mulf %in_182, %in_183 : f64 + %95 = arith.mulf %94, %in_181 : f64 + %96 = arith.mulf %95, %in : f64 + %97 = arith.addf %out, %96 : f64 + linalg.yield %97 : f64 + } + %subview_173 = memref.subview %alloca_168[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_173 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %69 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map36} : (memref, index, index, index, index, index, index, index) -> memref + %70 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map28} : (memref, index, index, index, index, index, index, index) -> memref + %71 = polygeist.submap(%arg8, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map37} : (memref, index, index, index, index, index, index, index) -> memref + %72 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map35} : (memref, index, index, index, index, index, index, index) -> memref + %subview_174 = memref.subview %alloca_168[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%69, %70, %71, %72 : memref, memref, memref, memref) outs(%subview_174 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %out: f64): + %94 = arith.mulf %in_182, %in_183 : f64 + %95 = arith.mulf %94, %in_181 : f64 + %96 = arith.mulf %95, %in : f64 + %97 = arith.addf %out, %96 : f64 + linalg.yield %97 : f64 + } + %73 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map38} : (memref, index, index, index, index) -> memref + %74 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map39} : (memref, index, index, index, index) -> memref + %75 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map40} : (memref, index, index, index, index) -> memref + %76 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map39} : (memref, index, index, index, index) -> memref + %77 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map41} : (memref, index, index, index, index) -> memref + %78 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map42} : (memref, index, index, index, index) -> memref + %79 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map40} : (memref, index, index, index, index) -> memref + %80 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map42} : (memref, index, index, index, index) -> memref + %81 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map43} : (memref, index, index, index, index) -> memref + %subview_175 = memref.subview %alloca_168[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %subview_176 = memref.subview %alloca_168[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %subview_177 = memref.subview %alloca_168[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%73, %74, %75, %76, %77, %78, %79, %80, %81 : memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%subview_175, %subview_176, %subview_177 : memref>, memref>, memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %in_184: f64, %in_185: f64, %in_186: f64, %in_187: f64, %in_188: f64, %out: f64, %out_189: f64, %out_190: f64): + %94 = arith.mulf %in, %out : f64 + %95 = arith.mulf %in_181, %out_189 : f64 + %96 = arith.addf %94, %95 : f64 + %97 = arith.mulf %in_182, %out_190 : f64 + %98 = arith.addf %96, %97 : f64 + %99 = arith.mulf %in_183, %out : f64 + %100 = arith.mulf %in_184, %out_189 : f64 + %101 = arith.addf %99, %100 : f64 + %102 = arith.mulf %in_185, %out_190 : f64 + %103 = arith.addf %101, %102 : f64 + %104 = arith.mulf %in_186, %out : f64 + %105 = arith.mulf %in_187, %out_189 : f64 + %106 = arith.addf %104, %105 : f64 + %107 = arith.mulf %in_188, %out_190 : f64 + %108 = arith.addf %106, %107 : f64 + linalg.yield %98, %103, %108 : f64, f64, f64 + } + %82 = polygeist.submap(%arg3, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map44} : (memref, index, index, index, index, index, index, index) -> memref + %83 = polygeist.submap(%arg3, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map45} : (memref, index, index, index, index, index, index, index) -> memref + %subview_178 = memref.subview %alloca_168[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %84 = polygeist.submap(%arg2, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map46} : (memref, index, index, index, index, index, index, index) -> memref + %85 = polygeist.submap(%arg9, %c2, %c4, %c4, %c3) {map = #map24} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%82, %83, %subview_178, %84 : memref, memref, memref>, memref) outs(%85 : memref) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %out: f64): + %94 = arith.mulf %in_182, %in_183 : f64 + %95 = arith.mulf %94, %in_181 : f64 + %96 = arith.mulf %95, %in : f64 + %97 = arith.addf %out, %96 : f64 + linalg.yield %97 : f64 + } + %86 = polygeist.submap(%arg3, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map44} : (memref, index, index, index, index, index, index, index) -> memref + %87 = polygeist.submap(%arg2, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map45} : (memref, index, index, index, index, index, index, index) -> memref + %subview_179 = memref.subview %alloca_168[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %88 = polygeist.submap(%arg3, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map46} : (memref, index, index, index, index, index, index, index) -> memref + %89 = polygeist.submap(%arg9, %c2, %c4, %c3, %c4) {map = #map25} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%86, %87, %subview_179, %88 : memref, memref, memref>, memref) outs(%89 : memref) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %out: f64): + %94 = arith.mulf %in_182, %in_183 : f64 + %95 = arith.mulf %94, %in_181 : f64 + %96 = arith.mulf %95, %in : f64 + %97 = arith.addf %out, %96 : f64 + linalg.yield %97 : f64 + } + %90 = polygeist.submap(%arg2, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map44} : (memref, index, index, index, index, index, index, index) -> memref + %91 = polygeist.submap(%arg3, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map45} : (memref, index, index, index, index, index, index, index) -> memref + %subview_180 = memref.subview %alloca_168[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %92 = polygeist.submap(%arg3, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map46} : (memref, index, index, index, index, index, index, index) -> memref + %93 = polygeist.submap(%arg9, %c2, %c3, %c4, %c4) {map = #map26} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%90, %91, %subview_180, %92 : memref, memref, memref>, memref) outs(%93 : memref) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %out: f64): + %94 = arith.mulf %in_182, %in_183 : f64 + %95 = arith.mulf %94, %in_181 : f64 + %96 = arith.mulf %95, %in : f64 + %97 = arith.addf %out, %96 : f64 + linalg.yield %97 : f64 + } + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d_partial.debufferized.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d_partial.debufferized.mlir new file mode 100644 index 000000000000..5ba30cad4f42 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d_partial.debufferized.mlir @@ -0,0 +1,563 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 144)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 125)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 375)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 500)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 250)> +#map22 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 625)> +#map23 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 144)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map26 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_abs_l1_curlcurl_3d_partial(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg8 : memref + %1 = bufferization.to_tensor %arg7 : memref + %2 = bufferization.to_tensor %arg6 : memref + %3 = bufferization.to_tensor %arg5 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = bufferization.to_tensor %arg3 : memref + %6 = bufferization.to_tensor %arg2 : memref + %7 = bufferization.to_tensor %arg1 : memref + %8 = bufferization.to_tensor %arg0 : memref + %9 = tensor.empty() : tensor<2x4x4x4xf64> + %10 = tensor.empty() : tensor<2x4x4x4xf64> + %11 = tensor.empty() : tensor<2x4x4x4xf64> + %12 = tensor.empty() : tensor<2x4x4x4xf64> + %13 = tensor.empty() : tensor<2x4x4x4xf64> + %14 = tensor.empty() : tensor<2x4x4x4xf64> + %15 = tensor.empty() : tensor<2x5x4x4xf64> + %16 = tensor.empty() : tensor<2x5x4x4xf64> + %17 = tensor.empty() : tensor<2x5x4x4xf64> + %18 = tensor.empty() : tensor<2x5x4x4xf64> + %19 = tensor.empty() : tensor<2x5x4x4xf64> + %20 = tensor.empty() : tensor<2x5x4x4xf64> + %21 = tensor.empty() : tensor<2x5x5x4xf64> + %22 = tensor.empty() : tensor<2x5x5x4xf64> + %23 = tensor.empty() : tensor<2x5x5x4xf64> + %24 = tensor.empty() : tensor<2x5x5x4xf64> + %25 = tensor.empty() : tensor<2x5x5x4xf64> + %26 = tensor.empty() : tensor<2x5x5x4xf64> + %27 = tensor.empty() : tensor<2x5x5x5xf64> + %28 = tensor.empty() : tensor<2x5x5x5xf64> + %29 = tensor.empty() : tensor<2x5x5x5xf64> + %30 = tensor.empty() : tensor<2x5x5x5xf64> + %31 = tensor.empty() : tensor<2x5x5x5xf64> + %32 = tensor.empty() : tensor<2x5x5x5xf64> + %33 = tensor.empty() : tensor<2x4x5x5xf64> + %34 = tensor.empty() : tensor<2x4x5x5xf64> + %35 = tensor.empty() : tensor<2x4x5x5xf64> + %36 = tensor.empty() : tensor<2x4x5x5xf64> + %37 = tensor.empty() : tensor<2x4x5x5xf64> + %38 = tensor.empty() : tensor<2x4x5x5xf64> + %39 = tensor.empty() : tensor<2x4x4x5xf64> + %40 = tensor.empty() : tensor<2x4x4x5xf64> + %41 = tensor.empty() : tensor<2x4x4x5xf64> + %42 = tensor.empty() : tensor<2x4x4x5xf64> + %43 = tensor.empty() : tensor<2x4x4x5xf64> + %44 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%43 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %45 = polygeist.submap(%8, %c2, %c4, %c4, %c5, %c3) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %46 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c3) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %47 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%46, %45 : tensor, tensor) outs(%44 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x5xf64> + %48 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%38 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %49 = polygeist.submap(%4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %50 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%47, %49 : tensor<2x4x4x5xf64>, tensor) outs(%48 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %51 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%37 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %52 = polygeist.submap(%7, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %53 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%47, %52 : tensor<2x4x4x5xf64>, tensor) outs(%51 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %54 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%32 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %55 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %56 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%50, %55 : tensor<2x4x5x5xf64>, tensor) outs(%54 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %57 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%31 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %58 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %59 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%53, %58 : tensor<2x4x5x5xf64>, tensor) outs(%57 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %60 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%42 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %61 = polygeist.submap(%4, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %62 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%62, %61 : tensor, tensor) outs(%60 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x5xf64> + %64 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%41 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %65 = polygeist.submap(%7, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %66 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %67 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%66, %65 : tensor, tensor) outs(%64 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x5xf64> + %68 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%36 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %69 = polygeist.submap(%8, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %70 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%63, %69 : tensor<2x4x4x5xf64>, tensor) outs(%68 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %71 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%35 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %72 = polygeist.submap(%8, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %73 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%67, %72 : tensor<2x4x4x5xf64>, tensor) outs(%71 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %74 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%30 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %75 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %76 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%70, %75 : tensor<2x4x5x5xf64>, tensor) outs(%74 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %77 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%29 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %78 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %79 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%73, %78 : tensor<2x4x5x5xf64>, tensor) outs(%77 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %80 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%40 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %81 = polygeist.submap(%4, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %82 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %83 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%82, %81 : tensor, tensor) outs(%80 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x5xf64> + %84 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%39 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %85 = polygeist.submap(%7, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %86 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %87 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%86, %85 : tensor, tensor) outs(%84 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x5xf64> + %88 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%34 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %89 = polygeist.submap(%7, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %90 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%83, %89 : tensor<2x4x4x5xf64>, tensor) outs(%88 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %91 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%33 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %92 = polygeist.submap(%4, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %93 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%87, %92 : tensor<2x4x4x5xf64>, tensor) outs(%91 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %94 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%28 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %95 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %96 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%90, %95 : tensor<2x4x5x5xf64>, tensor) outs(%94 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %97 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%27 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %98 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %99 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%93, %98 : tensor<2x4x5x5xf64>, tensor) outs(%97 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %100 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%26 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %101 = polygeist.submap(%6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %102 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %103 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %104 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %105 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%102, %99, %79, %103, %59, %96, %104, %76, %56, %101 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%100 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %106 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%20 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %107 = polygeist.submap(%5, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %108 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%105, %107 : tensor<2x5x5x4xf64>, tensor) outs(%106 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %109 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%14 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %110 = polygeist.submap(%3, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %111 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%108, %110 : tensor<2x5x4x4xf64>, tensor) outs(%109 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %112 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%25 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %113 = polygeist.submap(%6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %114 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %115 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %116 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %117 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%114, %99, %79, %115, %59, %96, %116, %76, %56, %113 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%112 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %118 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%19 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %119 = polygeist.submap(%3, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %120 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%117, %119 : tensor<2x5x5x4xf64>, tensor) outs(%118 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %121 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%13 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %122 = polygeist.submap(%5, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %123 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%120, %122 : tensor<2x5x4x4xf64>, tensor) outs(%121 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %124 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%24 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %125 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %126 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %127 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %128 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %129 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%126, %99, %79, %127, %59, %96, %128, %76, %56, %125 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%124 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %130 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%18 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %131 = polygeist.submap(%6, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %132 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%129, %131 : tensor<2x5x5x4xf64>, tensor) outs(%130 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %133 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %134 = polygeist.submap(%5, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %135 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%132, %134 : tensor<2x5x4x4xf64>, tensor) outs(%133 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %136 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%23 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %137 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %138 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %139 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %140 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %141 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%138, %99, %79, %139, %59, %96, %140, %76, %56, %137 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%136 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %142 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%17 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %143 = polygeist.submap(%6, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %144 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%141, %143 : tensor<2x5x5x4xf64>, tensor) outs(%142 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %145 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %146 = polygeist.submap(%3, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %147 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%144, %146 : tensor<2x5x4x4xf64>, tensor) outs(%145 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %148 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%22 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %149 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %150 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %151 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %152 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %153 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%150, %99, %79, %151, %59, %96, %152, %76, %56, %149 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%148 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %154 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%16 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %155 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %156 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%153, %155 : tensor<2x5x5x4xf64>, tensor) outs(%154 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %157 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %158 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %159 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%156, %158 : tensor<2x5x4x4xf64>, tensor) outs(%157 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %160 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%21 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %161 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %162 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %163 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %164 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %165 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%162, %99, %79, %163, %59, %96, %164, %76, %56, %161 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%160 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %166 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%15 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %167 = polygeist.submap(%5, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %168 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%165, %167 : tensor<2x5x5x4xf64>, tensor) outs(%166 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %169 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %170 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %171 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%168, %170 : tensor<2x5x4x4xf64>, tensor) outs(%169 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %172 = polygeist.submap(%0, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, index, index, index, index) -> tensor + %173 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%111, %123 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%172 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %174 = polygeist.submapInverse(%0, %173, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, tensor, index, index, index, index) -> tensor + %175 = polygeist.submap(%174, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, index, index, index, index) -> tensor + %176 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%135, %147 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%175 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %177 = polygeist.submapInverse(%174, %176, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, tensor, index, index, index, index) -> tensor + %178 = polygeist.submap(%177, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, index, index, index, index) -> tensor + %179 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%159, %171 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%178 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %180 = polygeist.submapInverse(%177, %179, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, tensor, index, index, index, index) -> tensor + %181 = bufferization.to_memref %180 : memref + memref.copy %181, %arg8 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d_partial.frontend.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d_partial.frontend.mlir new file mode 100644 index 000000000000..ea0e44d151b2 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d_partial.frontend.mlir @@ -0,0 +1,1476 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_abs_l1_curlcurl_3d_partial(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_13 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_14 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_15 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_16 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_21 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_22 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_23 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_24 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_25 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_26 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_27 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_28 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_29 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_30 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_31 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_32 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_33 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 3 + %arg9 * 144] : memref + %2 = affine.load %arg0[%arg13 + %arg12 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_33[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_28[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_27[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_28[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_22[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_27[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_21[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %2 = affine.load %arg4[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_32[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %2 = affine.load %arg1[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_31[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_32[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg13 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_26[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_31[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg13 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_25[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_26[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_20[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_25[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_19[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 16 + %arg13 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %2 = affine.load %arg4[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_30[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 16 + %arg13 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %2 = affine.load %arg1[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_29[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_30[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_24[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_29[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_23[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_24[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg13 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_18[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_23[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg13 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_17[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_16[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_16[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_15[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_14[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_13[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_12[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_11[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.load %alloca_4[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_3[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 12 + %arg12 + %arg11 * 3 + %arg9 * 144] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 12 + %arg12 + %arg11 * 3 + %arg9 * 144] : memref + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.load %alloca_2[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_1[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 12 + %arg12 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 12 + %arg12 + %arg11 * 4 + %arg9 * 144 + 48] : memref + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.load %alloca_0[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 16 + %arg12 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 16 + %arg12 + %arg11 * 4 + %arg9 * 144 + 96] : memref + } + } + } + } + return + } + func.func @mfem_pa_curlcurl_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_13 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_14 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_15 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_16 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_21 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_22 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_23 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_24 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_25 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_26 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_27 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_28 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_29 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_30 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_31 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_32 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_33 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 3 + %arg9 * 144] : memref + %2 = affine.load %arg0[%arg13 + %arg12 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_33[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_28[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_27[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_28[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_22[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_27[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_21[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %2 = affine.load %arg4[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_32[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %2 = affine.load %arg1[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_31[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_32[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg13 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_26[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_31[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg13 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_25[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_26[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_20[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_25[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_19[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 16 + %arg13 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %2 = affine.load %arg4[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_30[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 16 + %arg13 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %2 = affine.load %arg1[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_29[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_30[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_24[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_29[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_23[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_24[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg13 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_18[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_23[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg13 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_17[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_16[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_16[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_15[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_14[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_13[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_12[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_11[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.load %alloca_4[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_3[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 12 + %arg12 + %arg11 * 3 + %arg9 * 144] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 12 + %arg12 + %arg11 * 3 + %arg9 * 144] : memref + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.load %alloca_2[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_1[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 12 + %arg12 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 12 + %arg12 + %arg11 * 4 + %arg9 * 144 + 48] : memref + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.load %alloca_0[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 16 + %arg12 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 16 + %arg12 + %arg11 * 4 + %arg9 * 144 + 96] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d_partial.matched.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d_partial.matched.mlir new file mode 100644 index 000000000000..9a677c47de1f --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d_partial.matched.mlir @@ -0,0 +1,466 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 144)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 125)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 375)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 500)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 250)> +#map22 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 625)> +#map23 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 144)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map26 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_abs_l1_curlcurl_3d_partial(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg8 : memref + %1 = bufferization.to_tensor %arg7 : memref + %2 = bufferization.to_tensor %arg6 : memref + %3 = bufferization.to_tensor %arg5 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = bufferization.to_tensor %arg3 : memref + %6 = bufferization.to_tensor %arg2 : memref + %7 = bufferization.to_tensor %arg1 : memref + %8 = bufferization.to_tensor %arg0 : memref + %9 = tensor.empty() : tensor<2x4x4x4xf64> + %10 = tensor.empty() : tensor<2x4x4x4xf64> + %11 = tensor.empty() : tensor<2x4x4x4xf64> + %12 = tensor.empty() : tensor<2x4x4x4xf64> + %13 = tensor.empty() : tensor<2x4x4x4xf64> + %14 = tensor.empty() : tensor<2x4x4x4xf64> + %15 = tensor.empty() : tensor<2x5x4x4xf64> + %16 = tensor.empty() : tensor<2x5x4x4xf64> + %17 = tensor.empty() : tensor<2x5x4x4xf64> + %18 = tensor.empty() : tensor<2x5x4x4xf64> + %19 = tensor.empty() : tensor<2x5x4x4xf64> + %20 = tensor.empty() : tensor<2x5x4x4xf64> + %21 = tensor.empty() : tensor<2x5x5x4xf64> + %22 = tensor.empty() : tensor<2x5x5x4xf64> + %23 = tensor.empty() : tensor<2x5x5x4xf64> + %24 = tensor.empty() : tensor<2x5x5x4xf64> + %25 = tensor.empty() : tensor<2x5x5x4xf64> + %26 = tensor.empty() : tensor<2x5x5x4xf64> + %27 = tensor.empty() : tensor<2x5x5x5xf64> + %28 = tensor.empty() : tensor<2x5x5x5xf64> + %29 = tensor.empty() : tensor<2x5x5x5xf64> + %30 = tensor.empty() : tensor<2x5x5x5xf64> + %31 = tensor.empty() : tensor<2x5x5x5xf64> + %32 = tensor.empty() : tensor<2x5x5x5xf64> + %33 = tensor.empty() : tensor<2x4x5x5xf64> + %34 = tensor.empty() : tensor<2x4x5x5xf64> + %35 = tensor.empty() : tensor<2x4x5x5xf64> + %36 = tensor.empty() : tensor<2x4x5x5xf64> + %37 = tensor.empty() : tensor<2x4x5x5xf64> + %38 = tensor.empty() : tensor<2x4x5x5xf64> + %39 = tensor.empty() : tensor<2x4x4x5xf64> + %40 = tensor.empty() : tensor<2x4x4x5xf64> + %41 = tensor.empty() : tensor<2x4x4x5xf64> + %42 = tensor.empty() : tensor<2x4x4x5xf64> + %43 = tensor.empty() : tensor<2x4x4x5xf64> + %45 = polygeist.submap(%8, %c2, %c4, %c4, %c5, %c3) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %46 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c3) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v43_contract_47_tc2 = tensor.cast %43 : tensor<2x4x4x5xf64> to tensor + + %v47_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%46, %45, %v43_contract_47_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %47 = tensor.cast %v47_tdyn : tensor to tensor<2x4x4x5xf64> + %49 = polygeist.submap(%4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v47_contract_50_tc0 = tensor.cast %47 : tensor<2x4x4x5xf64> to tensor + + %v38_contract_50_tc2 = tensor.cast %38 : tensor<2x4x5x5xf64> to tensor + + %v50_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v47_contract_50_tc0, %49, %v38_contract_50_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %50 = tensor.cast %v50_tdyn : tensor to tensor<2x4x5x5xf64> + %52 = polygeist.submap(%7, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v47_contract_53_tc0 = tensor.cast %47 : tensor<2x4x4x5xf64> to tensor + + %v37_contract_53_tc2 = tensor.cast %37 : tensor<2x4x5x5xf64> to tensor + + %v53_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v47_contract_53_tc0, %52, %v37_contract_53_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %53 = tensor.cast %v53_tdyn : tensor to tensor<2x4x5x5xf64> + %55 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v50_contract_56_tc0 = tensor.cast %50 : tensor<2x4x5x5xf64> to tensor + + %v32_contract_56_tc2 = tensor.cast %32 : tensor<2x5x5x5xf64> to tensor + + %v56_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v50_contract_56_tc0, %55, %v32_contract_56_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %56 = tensor.cast %v56_tdyn : tensor to tensor<2x5x5x5xf64> + %58 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v53_contract_59_tc0 = tensor.cast %53 : tensor<2x4x5x5xf64> to tensor + + %v31_contract_59_tc2 = tensor.cast %31 : tensor<2x5x5x5xf64> to tensor + + %v59_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v53_contract_59_tc0, %58, %v31_contract_59_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %59 = tensor.cast %v59_tdyn : tensor to tensor<2x5x5x5xf64> + %61 = polygeist.submap(%4, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %62 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %v42_contract_63_tc2 = tensor.cast %42 : tensor<2x4x4x5xf64> to tensor + + %v63_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%62, %61, %v42_contract_63_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %63 = tensor.cast %v63_tdyn : tensor to tensor<2x4x4x5xf64> + %65 = polygeist.submap(%7, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %66 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %v41_contract_67_tc2 = tensor.cast %41 : tensor<2x4x4x5xf64> to tensor + + %v67_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%66, %65, %v41_contract_67_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %67 = tensor.cast %v67_tdyn : tensor to tensor<2x4x4x5xf64> + %69 = polygeist.submap(%8, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %v63_contract_70_tc0 = tensor.cast %63 : tensor<2x4x4x5xf64> to tensor + + %v36_contract_70_tc2 = tensor.cast %36 : tensor<2x4x5x5xf64> to tensor + + %v70_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v63_contract_70_tc0, %69, %v36_contract_70_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %70 = tensor.cast %v70_tdyn : tensor to tensor<2x4x5x5xf64> + %72 = polygeist.submap(%8, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %v67_contract_73_tc0 = tensor.cast %67 : tensor<2x4x4x5xf64> to tensor + + %v35_contract_73_tc2 = tensor.cast %35 : tensor<2x4x5x5xf64> to tensor + + %v73_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v67_contract_73_tc0, %72, %v35_contract_73_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %73 = tensor.cast %v73_tdyn : tensor to tensor<2x4x5x5xf64> + %75 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v70_contract_76_tc0 = tensor.cast %70 : tensor<2x4x5x5xf64> to tensor + + %v30_contract_76_tc2 = tensor.cast %30 : tensor<2x5x5x5xf64> to tensor + + %v76_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v70_contract_76_tc0, %75, %v30_contract_76_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %76 = tensor.cast %v76_tdyn : tensor to tensor<2x5x5x5xf64> + %78 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v73_contract_79_tc0 = tensor.cast %73 : tensor<2x4x5x5xf64> to tensor + + %v29_contract_79_tc2 = tensor.cast %29 : tensor<2x5x5x5xf64> to tensor + + %v79_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v73_contract_79_tc0, %78, %v29_contract_79_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %79 = tensor.cast %v79_tdyn : tensor to tensor<2x5x5x5xf64> + %81 = polygeist.submap(%4, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %82 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %v40_contract_83_tc2 = tensor.cast %40 : tensor<2x4x4x5xf64> to tensor + + %v83_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%82, %81, %v40_contract_83_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %83 = tensor.cast %v83_tdyn : tensor to tensor<2x4x4x5xf64> + %85 = polygeist.submap(%7, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %86 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %v39_contract_87_tc2 = tensor.cast %39 : tensor<2x4x4x5xf64> to tensor + + %v87_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%86, %85, %v39_contract_87_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %87 = tensor.cast %v87_tdyn : tensor to tensor<2x4x4x5xf64> + %89 = polygeist.submap(%7, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v83_contract_90_tc0 = tensor.cast %83 : tensor<2x4x4x5xf64> to tensor + + %v34_contract_90_tc2 = tensor.cast %34 : tensor<2x4x5x5xf64> to tensor + + %v90_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v83_contract_90_tc0, %89, %v34_contract_90_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %90 = tensor.cast %v90_tdyn : tensor to tensor<2x4x5x5xf64> + %92 = polygeist.submap(%4, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v87_contract_93_tc0 = tensor.cast %87 : tensor<2x4x4x5xf64> to tensor + + %v33_contract_93_tc2 = tensor.cast %33 : tensor<2x4x5x5xf64> to tensor + + %v93_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v87_contract_93_tc0, %92, %v33_contract_93_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %93 = tensor.cast %v93_tdyn : tensor to tensor<2x4x5x5xf64> + %95 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %v90_contract_96_tc0 = tensor.cast %90 : tensor<2x4x5x5xf64> to tensor + + %v28_contract_96_tc2 = tensor.cast %28 : tensor<2x5x5x5xf64> to tensor + + %v96_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v90_contract_96_tc0, %95, %v28_contract_96_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %96 = tensor.cast %v96_tdyn : tensor to tensor<2x5x5x5xf64> + %98 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %v93_contract_99_tc0 = tensor.cast %93 : tensor<2x4x5x5xf64> to tensor + + %v27_contract_99_tc2 = tensor.cast %27 : tensor<2x5x5x5xf64> to tensor + + %v99_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v93_contract_99_tc0, %98, %v27_contract_99_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %99 = tensor.cast %v99_tdyn : tensor to tensor<2x5x5x5xf64> + %100 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%26 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %101 = polygeist.submap(%6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %102 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %103 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %104 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %105 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%102, %99, %79, %103, %59, %96, %104, %76, %56, %101 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%100 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %107 = polygeist.submap(%5, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v105_contract_108_tc0 = tensor.cast %105 : tensor<2x5x5x4xf64> to tensor + + %v20_contract_108_tc2 = tensor.cast %20 : tensor<2x5x4x4xf64> to tensor + + %v108_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v105_contract_108_tc0, %107, %v20_contract_108_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %108 = tensor.cast %v108_tdyn : tensor to tensor<2x5x4x4xf64> + %110 = polygeist.submap(%3, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v108_contract_111_tc0 = tensor.cast %108 : tensor<2x5x4x4xf64> to tensor + + %v14_contract_111_tc2 = tensor.cast %14 : tensor<2x4x4x4xf64> to tensor + + %v111_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v108_contract_111_tc0, %110, %v14_contract_111_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %111 = tensor.cast %v111_tdyn : tensor to tensor<2x4x4x4xf64> + %112 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%25 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %113 = polygeist.submap(%6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %114 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %115 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %116 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %117 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%114, %99, %79, %115, %59, %96, %116, %76, %56, %113 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%112 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %119 = polygeist.submap(%3, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v117_contract_120_tc0 = tensor.cast %117 : tensor<2x5x5x4xf64> to tensor + + %v19_contract_120_tc2 = tensor.cast %19 : tensor<2x5x4x4xf64> to tensor + + %v120_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v117_contract_120_tc0, %119, %v19_contract_120_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %120 = tensor.cast %v120_tdyn : tensor to tensor<2x5x4x4xf64> + %122 = polygeist.submap(%5, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v120_contract_123_tc0 = tensor.cast %120 : tensor<2x5x4x4xf64> to tensor + + %v13_contract_123_tc2 = tensor.cast %13 : tensor<2x4x4x4xf64> to tensor + + %v123_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v120_contract_123_tc0, %122, %v13_contract_123_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %123 = tensor.cast %v123_tdyn : tensor to tensor<2x4x4x4xf64> + %124 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%24 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %125 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %126 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %127 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %128 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %129 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%126, %99, %79, %127, %59, %96, %128, %76, %56, %125 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%124 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %131 = polygeist.submap(%6, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v129_contract_132_tc0 = tensor.cast %129 : tensor<2x5x5x4xf64> to tensor + + %v18_contract_132_tc2 = tensor.cast %18 : tensor<2x5x4x4xf64> to tensor + + %v132_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v129_contract_132_tc0, %131, %v18_contract_132_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %132 = tensor.cast %v132_tdyn : tensor to tensor<2x5x4x4xf64> + %134 = polygeist.submap(%5, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v132_contract_135_tc0 = tensor.cast %132 : tensor<2x5x4x4xf64> to tensor + + %v12_contract_135_tc2 = tensor.cast %12 : tensor<2x4x4x4xf64> to tensor + + %v135_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v132_contract_135_tc0, %134, %v12_contract_135_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %135 = tensor.cast %v135_tdyn : tensor to tensor<2x4x4x4xf64> + %136 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%23 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %137 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %138 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %139 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %140 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %141 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%138, %99, %79, %139, %59, %96, %140, %76, %56, %137 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%136 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %143 = polygeist.submap(%6, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v141_contract_144_tc0 = tensor.cast %141 : tensor<2x5x5x4xf64> to tensor + + %v17_contract_144_tc2 = tensor.cast %17 : tensor<2x5x4x4xf64> to tensor + + %v144_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v141_contract_144_tc0, %143, %v17_contract_144_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %144 = tensor.cast %v144_tdyn : tensor to tensor<2x5x4x4xf64> + %146 = polygeist.submap(%3, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v144_contract_147_tc0 = tensor.cast %144 : tensor<2x5x4x4xf64> to tensor + + %v11_contract_147_tc2 = tensor.cast %11 : tensor<2x4x4x4xf64> to tensor + + %v147_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v144_contract_147_tc0, %146, %v11_contract_147_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %147 = tensor.cast %v147_tdyn : tensor to tensor<2x4x4x4xf64> + %148 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%22 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %149 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %150 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %151 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %152 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %153 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%150, %99, %79, %151, %59, %96, %152, %76, %56, %149 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%148 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %155 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v153_contract_156_tc0 = tensor.cast %153 : tensor<2x5x5x4xf64> to tensor + + %v16_contract_156_tc2 = tensor.cast %16 : tensor<2x5x4x4xf64> to tensor + + %v156_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v153_contract_156_tc0, %155, %v16_contract_156_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %156 = tensor.cast %v156_tdyn : tensor to tensor<2x5x4x4xf64> + %158 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v156_contract_159_tc0 = tensor.cast %156 : tensor<2x5x4x4xf64> to tensor + + %v10_contract_159_tc2 = tensor.cast %10 : tensor<2x4x4x4xf64> to tensor + + %v159_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v156_contract_159_tc0, %158, %v10_contract_159_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %159 = tensor.cast %v159_tdyn : tensor to tensor<2x4x4x4xf64> + %160 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%21 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %161 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %162 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %163 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %164 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %165 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%162, %99, %79, %163, %59, %96, %164, %76, %56, %161 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%160 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %167 = polygeist.submap(%5, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v165_contract_168_tc0 = tensor.cast %165 : tensor<2x5x5x4xf64> to tensor + + %v15_contract_168_tc2 = tensor.cast %15 : tensor<2x5x4x4xf64> to tensor + + %v168_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v165_contract_168_tc0, %167, %v15_contract_168_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %168 = tensor.cast %v168_tdyn : tensor to tensor<2x5x4x4xf64> + %170 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v168_contract_171_tc0 = tensor.cast %168 : tensor<2x5x4x4xf64> to tensor + + %v9_contract_171_tc2 = tensor.cast %9 : tensor<2x4x4x4xf64> to tensor + + %v171_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v168_contract_171_tc0, %170, %v9_contract_171_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %171 = tensor.cast %v171_tdyn : tensor to tensor<2x4x4x4xf64> + %172 = polygeist.submap(%0, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, index, index, index, index) -> tensor + %173 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%111, %123 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%172 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %174 = polygeist.submapInverse(%0, %173, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, tensor, index, index, index, index) -> tensor + %175 = polygeist.submap(%174, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, index, index, index, index) -> tensor + %176 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%135, %147 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%175 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %177 = polygeist.submapInverse(%174, %176, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, tensor, index, index, index, index) -> tensor + %178 = polygeist.submap(%177, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, index, index, index, index) -> tensor + %179 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%159, %171 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%178 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %180 = polygeist.submapInverse(%177, %179, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, tensor, index, index, index, index) -> tensor + %181 = bufferization.to_memref %180 : memref + memref.copy %181, %arg8 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d_partial.raised.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d_partial.raised.mlir new file mode 100644 index 000000000000..419621422fa5 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_curlcurl_3d_partial.raised.mlir @@ -0,0 +1,549 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 144)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 125)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 375)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 500)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 250)> +#map22 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 625)> +#map23 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 144)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map26 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_abs_l1_curlcurl_3d_partial(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_13 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_14 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_15 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_16 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_21 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_22 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_23 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_24 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_25 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_26 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_27 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_28 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_29 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_30 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_31 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_32 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_33 = memref.alloca() : memref<2x4x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_33 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg7, %c2, %c4, %c4, %c5, %c3) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c3) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_33 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_28 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_33, %2 : memref<2x4x4x5xf64>, memref) outs(%alloca_28 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_27 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %3 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_33, %3 : memref<2x4x4x5xf64>, memref) outs(%alloca_27 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_22 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_28, %4 : memref<2x4x5x5xf64>, memref) outs(%alloca_22 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_21 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %5 = polygeist.submap(%arg4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_27, %5 : memref<2x4x5x5xf64>, memref) outs(%alloca_21 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_32 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg7, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (memref, index, index, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%6, %7 : memref, memref) outs(%alloca_32 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_31 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg7, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (memref, index, index, index, index, index) -> memref + %9 = polygeist.submap(%arg1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%8, %9 : memref, memref) outs(%alloca_31 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_26 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %10 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_32, %10 : memref<2x4x4x5xf64>, memref) outs(%alloca_26 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_25 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %11 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_31, %11 : memref<2x4x4x5xf64>, memref) outs(%alloca_25 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_20 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %12 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_26, %12 : memref<2x4x5x5xf64>, memref) outs(%alloca_20 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_19 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %13 = polygeist.submap(%arg4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_25, %13 : memref<2x4x5x5xf64>, memref) outs(%alloca_19 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_30 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg7, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %15 = polygeist.submap(%arg4, %c2, %c3, %c4, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%14, %15 : memref, memref) outs(%alloca_30 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_29 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %16 = polygeist.submap(%arg7, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %17 = polygeist.submap(%arg1, %c2, %c3, %c4, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%16, %17 : memref, memref) outs(%alloca_29 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_24 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %18 = polygeist.submap(%arg1, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_30, %18 : memref<2x4x4x5xf64>, memref) outs(%alloca_24 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_23 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %19 = polygeist.submap(%arg4, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_29, %19 : memref<2x4x4x5xf64>, memref) outs(%alloca_23 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_18 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %20 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_24, %20 : memref<2x4x5x5xf64>, memref) outs(%alloca_18 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_17 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %21 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_23, %21 : memref<2x4x5x5xf64>, memref) outs(%alloca_17 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_16 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %22 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %23 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %24 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %25 = polygeist.submap(%arg2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%22, %alloca_17, %alloca_19, %23, %alloca_21, %alloca_18, %24, %alloca_20, %alloca_22, %25 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_16 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_10 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %26 = polygeist.submap(%arg3, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_16, %26 : memref<2x5x5x4xf64>, memref) outs(%alloca_10 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_4 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %27 = polygeist.submap(%arg5, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_10, %27 : memref<2x5x4x4xf64>, memref) outs(%alloca_4 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_15 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %28 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %29 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %30 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map22} : (memref, index, index, index, index, index) -> memref + %31 = polygeist.submap(%arg2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%28, %alloca_17, %alloca_19, %29, %alloca_21, %alloca_18, %30, %alloca_20, %alloca_22, %31 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_15 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_9 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %32 = polygeist.submap(%arg5, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_15, %32 : memref<2x5x5x4xf64>, memref) outs(%alloca_9 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %33 = polygeist.submap(%arg3, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_9, %33 : memref<2x5x4x4xf64>, memref) outs(%alloca_3 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_14 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %34 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %35 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %36 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map22} : (memref, index, index, index, index, index) -> memref + %37 = polygeist.submap(%arg5, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%34, %alloca_17, %alloca_19, %35, %alloca_21, %alloca_18, %36, %alloca_20, %alloca_22, %37 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_14 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_8 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %38 = polygeist.submap(%arg2, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_14, %38 : memref<2x5x5x4xf64>, memref) outs(%alloca_8 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %39 = polygeist.submap(%arg3, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_8, %39 : memref<2x5x4x4xf64>, memref) outs(%alloca_2 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_13 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %40 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (memref, index, index, index, index, index) -> memref + %41 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %42 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %43 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%40, %alloca_17, %alloca_19, %41, %alloca_21, %alloca_18, %42, %alloca_20, %alloca_22, %43 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_13 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_7 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %44 = polygeist.submap(%arg2, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_13, %44 : memref<2x5x5x4xf64>, memref) outs(%alloca_7 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %45 = polygeist.submap(%arg5, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_7, %45 : memref<2x5x4x4xf64>, memref) outs(%alloca_1 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_12 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %46 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (memref, index, index, index, index, index) -> memref + %47 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %48 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %49 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%46, %alloca_17, %alloca_19, %47, %alloca_21, %alloca_18, %48, %alloca_20, %alloca_22, %49 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_12 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_6 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %50 = polygeist.submap(%arg5, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_12, %50 : memref<2x5x5x4xf64>, memref) outs(%alloca_6 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %51 = polygeist.submap(%arg2, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_6, %51 : memref<2x5x4x4xf64>, memref) outs(%alloca_0 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_11 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %52 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %53 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %54 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %55 = polygeist.submap(%arg5, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%52, %alloca_17, %alloca_19, %53, %alloca_21, %alloca_18, %54, %alloca_20, %alloca_22, %55 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_11 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_5 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %56 = polygeist.submap(%arg3, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_11, %56 : memref<2x5x5x4xf64>, memref) outs(%alloca_5 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %57 = polygeist.submap(%arg2, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_5, %57 : memref<2x5x4x4xf64>, memref) outs(%alloca : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + %58 = polygeist.submap(%arg8, %c2, %c4, %c4, %c3) {map = #map24} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%alloca_4, %alloca_3 : memref<2x4x4x4xf64>, memref<2x4x4x4xf64>) outs(%58 : memref) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.subf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + %59 = polygeist.submap(%arg8, %c2, %c4, %c3, %c4) {map = #map25} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%alloca_2, %alloca_1 : memref<2x4x4x4xf64>, memref<2x4x4x4xf64>) outs(%59 : memref) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.subf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + %60 = polygeist.submap(%arg8, %c2, %c3, %c4, %c4) {map = #map26} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%alloca_0, %alloca : memref<2x4x4x4xf64>, memref<2x4x4x4xf64>) outs(%60 : memref) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.subf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_diffusion_3d.debufferized.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_diffusion_3d.debufferized.mlir new file mode 100644 index 000000000000..a795682d241d --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_diffusion_3d.debufferized.mlir @@ -0,0 +1,300 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 750)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 125)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 250)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 375)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 500)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 625)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_abs_l1_diffusion_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x4x4x4xf64> + %8 = tensor.empty() : tensor<2x4x4x4xf64> + %9 = tensor.empty() : tensor<2x4x4x4xf64> + %10 = tensor.empty() : tensor<2x5x4x4xf64> + %11 = tensor.empty() : tensor<2x5x4x4xf64> + %12 = tensor.empty() : tensor<2x5x4x4xf64> + %13 = tensor.empty() : tensor<2x5x5x4xf64> + %14 = tensor.empty() : tensor<2x5x5x4xf64> + %15 = tensor.empty() : tensor<2x5x5x4xf64> + %16 = tensor.empty() : tensor<2x5x5x5xf64> + %17 = tensor.empty() : tensor<2x5x5x5xf64> + %18 = tensor.empty() : tensor<2x5x5x5xf64> + %19 = tensor.empty() : tensor<2x4x5x5xf64> + %20 = tensor.empty() : tensor<2x4x5x5xf64> + %21 = tensor.empty() : tensor<2x4x5x5xf64> + %22 = tensor.empty() : tensor<2x4x4x5xf64> + %23 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice = tensor.extract_slice %23[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %24 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %24 into %23[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %25 = polygeist.submap(%6, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %26 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %27 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%26, %25 : tensor, tensor) outs(%inserted_slice : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_20: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_0 = tensor.extract_slice %22[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_0 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_1 = tensor.insert_slice %28 into %22[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %29 = polygeist.submap(%5, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %30 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %31 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%30, %29 : tensor, tensor) outs(%inserted_slice_1 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_20: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_2 = tensor.extract_slice %21[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %32 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_2 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_3 = tensor.extract_slice %31[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %33 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %34 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_3, %33 : tensor, tensor) outs(%32 : tensor) { + ^bb0(%in: f64, %in_20: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor + %extracted_slice_4 = tensor.extract_slice %20[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %35 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_4 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_5 = tensor.extract_slice %27[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %36 = polygeist.submap(%5, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %37 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_5, %36 : tensor, tensor) outs(%35 : tensor) { + ^bb0(%in: f64, %in_20: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor + %extracted_slice_6 = tensor.extract_slice %19[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %38 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_6 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_7 = tensor.extract_slice %27[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %39 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %40 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_7, %39 : tensor, tensor) outs(%38 : tensor) { + ^bb0(%in: f64, %in_20: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor + %extracted_slice_8 = tensor.extract_slice %18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %41 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_8 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %42 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %43 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%34, %42 : tensor, tensor) outs(%41 : tensor) { + ^bb0(%in: f64, %in_20: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor + %extracted_slice_9 = tensor.extract_slice %17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %44 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_9 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %45 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %46 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%37, %45 : tensor, tensor) outs(%44 : tensor) { + ^bb0(%in: f64, %in_20: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor + %extracted_slice_10 = tensor.extract_slice %16[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %47 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_10 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %48 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %49 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%40, %48 : tensor, tensor) outs(%47 : tensor) { + ^bb0(%in: f64, %in_20: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor + %extracted_slice_11 = tensor.extract_slice %15[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %50 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_11 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %51 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %52 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %53 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %54 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%52, %43, %53, %46, %54, %49, %51 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%50 : tensor) { + ^bb0(%in: f64, %in_20: f64, %in_21: f64, %in_22: f64, %in_23: f64, %in_24: f64, %in_25: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.mulf %in_21, %in_22 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_23, %in_24 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_25 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor + %extracted_slice_12 = tensor.extract_slice %14[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %56 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_12 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %57 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %58 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %59 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %60 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %61 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%58, %43, %59, %46, %60, %49, %57 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%56 : tensor) { + ^bb0(%in: f64, %in_20: f64, %in_21: f64, %in_22: f64, %in_23: f64, %in_24: f64, %in_25: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.mulf %in_21, %in_22 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_23, %in_24 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_25 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor + %extracted_slice_13 = tensor.extract_slice %13[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %62 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_13 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %63 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %64 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %65 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %66 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %67 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%64, %43, %65, %46, %66, %49, %63 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%62 : tensor) { + ^bb0(%in: f64, %in_20: f64, %in_21: f64, %in_22: f64, %in_23: f64, %in_24: f64, %in_25: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.mulf %in_21, %in_22 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_23, %in_24 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_25 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor + %extracted_slice_14 = tensor.extract_slice %12[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %68 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_14 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %69 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %70 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%55, %69 : tensor, tensor) outs(%68 : tensor) { + ^bb0(%in: f64, %in_20: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor + %extracted_slice_15 = tensor.extract_slice %11[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %71 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_15 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %72 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %73 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%61, %72 : tensor, tensor) outs(%71 : tensor) { + ^bb0(%in: f64, %in_20: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor + %extracted_slice_16 = tensor.extract_slice %10[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %74 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_16 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %75 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %76 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%67, %75 : tensor, tensor) outs(%74 : tensor) { + ^bb0(%in: f64, %in_20: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor + %extracted_slice_17 = tensor.extract_slice %9[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %77 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_17 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %78 = polygeist.submap(%4, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %79 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%70, %78 : tensor, tensor) outs(%77 : tensor) { + ^bb0(%in: f64, %in_20: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor + %extracted_slice_18 = tensor.extract_slice %8[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %80 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_18 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %81 = polygeist.submap(%4, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %82 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%73, %81 : tensor, tensor) outs(%80 : tensor) { + ^bb0(%in: f64, %in_20: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor + %extracted_slice_19 = tensor.extract_slice %7[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %83 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_19 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %84 = polygeist.submap(%3, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %85 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%76, %84 : tensor, tensor) outs(%83 : tensor) { + ^bb0(%in: f64, %in_20: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor + %86 = polygeist.submap(%0, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %87 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%79, %82, %85 : tensor, tensor, tensor) outs(%86 : tensor) { + ^bb0(%in: f64, %in_20: f64, %in_21: f64, %out: f64): + %90 = arith.addf %in, %in_20 : f64 + %91 = arith.addf %90, %in_21 : f64 + %92 = arith.addf %out, %91 : f64 + linalg.yield %92 : f64 + } -> tensor + %88 = polygeist.submapInverse(%0, %87, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %89 = bufferization.to_memref %88 : memref + memref.copy %89, %arg6 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_diffusion_3d.frontend.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_diffusion_3d.frontend.mlir new file mode 100644 index 000000000000..92e1e98f88d7 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_diffusion_3d.frontend.mlir @@ -0,0 +1,680 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_abs_l1_diffusion_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_14 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_15 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg7 * 64 + %arg11 + %arg8 * 16 + %arg9 * 4] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_15[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg7 * 64 + %arg11 + %arg8 * 16 + %arg9 * 4] : memref + %2 = affine.load %arg1[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_14[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg9 * 5 + %arg7 * 750] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 125] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 250] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg3[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_7[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 125] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 375] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 500] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 250] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 500] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 625] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.load %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg6[%arg7 * 64 + %arg10 + %arg8 * 16 + %arg9 * 4] : memref + %6 = arith.addf %5, %4 : f64 + affine.store %6, %arg6[%arg7 * 64 + %arg10 + %arg8 * 16 + %arg9 * 4] : memref + } + } + } + } + return + } + func.func @mfem_pa_diffusion_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_14 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_15 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg7 * 64 + %arg11 + %arg8 * 16 + %arg9 * 4] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_15[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg7 * 64 + %arg11 + %arg8 * 16 + %arg9 * 4] : memref + %2 = affine.load %arg1[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_14[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg9 * 5 + %arg7 * 750] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 125] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 250] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg3[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_7[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 125] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 375] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 500] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 250] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 500] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 625] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.load %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg6[%arg7 * 64 + %arg10 + %arg8 * 16 + %arg9 * 4] : memref + %6 = arith.addf %5, %4 : f64 + affine.store %6, %arg6[%arg7 * 64 + %arg10 + %arg8 * 16 + %arg9 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_diffusion_3d.matched.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_diffusion_3d.matched.mlir new file mode 100644 index 000000000000..827ab9592e04 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_diffusion_3d.matched.mlir @@ -0,0 +1,190 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 750)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 125)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 250)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 375)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 500)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 625)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_abs_l1_diffusion_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x4x4x4xf64> + %8 = tensor.empty() : tensor<2x4x4x4xf64> + %9 = tensor.empty() : tensor<2x4x4x4xf64> + %10 = tensor.empty() : tensor<2x5x4x4xf64> + %11 = tensor.empty() : tensor<2x5x4x4xf64> + %12 = tensor.empty() : tensor<2x5x4x4xf64> + %13 = tensor.empty() : tensor<2x5x5x4xf64> + %14 = tensor.empty() : tensor<2x5x5x4xf64> + %15 = tensor.empty() : tensor<2x5x5x4xf64> + %16 = tensor.empty() : tensor<2x5x5x5xf64> + %17 = tensor.empty() : tensor<2x5x5x5xf64> + %18 = tensor.empty() : tensor<2x5x5x5xf64> + %19 = tensor.empty() : tensor<2x4x5x5xf64> + %20 = tensor.empty() : tensor<2x4x5x5xf64> + %21 = tensor.empty() : tensor<2x4x5x5xf64> + %22 = tensor.empty() : tensor<2x4x4x5xf64> + %23 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice = tensor.extract_slice %23[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %24 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %24 into %23[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %25 = polygeist.submap(%6, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %26 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %inserted_slice_contract_27_tc2 = tensor.cast %inserted_slice : tensor<2x4x4x5xf64> to tensor + + %v27_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%26, %25, %inserted_slice_contract_27_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %27 = tensor.cast %v27_tdyn : tensor to tensor<2x4x4x5xf64> + %extracted_slice_0 = tensor.extract_slice %22[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_0 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_1 = tensor.insert_slice %28 into %22[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %29 = polygeist.submap(%5, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %30 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %inserted_slice_1_contract_31_tc2 = tensor.cast %inserted_slice_1 : tensor<2x4x4x5xf64> to tensor + + %v31_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%30, %29, %inserted_slice_1_contract_31_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %31 = tensor.cast %v31_tdyn : tensor to tensor<2x4x4x5xf64> + %extracted_slice_2 = tensor.extract_slice %21[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_3 = tensor.extract_slice %31[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %33 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %34 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_3, %33, %extracted_slice_2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_4 = tensor.extract_slice %20[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_5 = tensor.extract_slice %27[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %36 = polygeist.submap(%5, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %37 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_5, %36, %extracted_slice_4) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_6 = tensor.extract_slice %19[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_7 = tensor.extract_slice %27[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %39 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %40 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_7, %39, %extracted_slice_6) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_8 = tensor.extract_slice %18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %42 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %43 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%34, %42, %extracted_slice_8) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_9 = tensor.extract_slice %17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %45 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %46 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%37, %45, %extracted_slice_9) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_10 = tensor.extract_slice %16[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %48 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %49 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%40, %48, %extracted_slice_10) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_11 = tensor.extract_slice %15[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %50 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_11 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %51 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %52 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %53 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %54 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%52, %43, %53, %46, %54, %49, %51 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%50 : tensor) { + ^bb0(%in: f64, %in_20: f64, %in_21: f64, %in_22: f64, %in_23: f64, %in_24: f64, %in_25: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.mulf %in_21, %in_22 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_23, %in_24 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_25 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor + %extracted_slice_12 = tensor.extract_slice %14[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %56 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_12 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %57 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %58 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %59 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %60 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %61 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%58, %43, %59, %46, %60, %49, %57 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%56 : tensor) { + ^bb0(%in: f64, %in_20: f64, %in_21: f64, %in_22: f64, %in_23: f64, %in_24: f64, %in_25: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.mulf %in_21, %in_22 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_23, %in_24 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_25 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor + %extracted_slice_13 = tensor.extract_slice %13[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %62 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_13 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %63 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %64 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %65 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %66 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %67 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%64, %43, %65, %46, %66, %49, %63 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%62 : tensor) { + ^bb0(%in: f64, %in_20: f64, %in_21: f64, %in_22: f64, %in_23: f64, %in_24: f64, %in_25: f64, %out: f64): + %90 = arith.mulf %in, %in_20 : f64 + %91 = arith.mulf %in_21, %in_22 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_23, %in_24 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_25 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor + %extracted_slice_14 = tensor.extract_slice %12[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %69 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %70 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%55, %69, %extracted_slice_14) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_15 = tensor.extract_slice %11[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %72 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %73 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%61, %72, %extracted_slice_15) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_16 = tensor.extract_slice %10[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %75 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %76 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%67, %75, %extracted_slice_16) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_17 = tensor.extract_slice %9[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %78 = polygeist.submap(%4, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %79 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%70, %78, %extracted_slice_17) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_18 = tensor.extract_slice %8[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %81 = polygeist.submap(%4, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %82 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%73, %81, %extracted_slice_18) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_19 = tensor.extract_slice %7[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %84 = polygeist.submap(%3, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %85 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%76, %84, %extracted_slice_19) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %86 = polygeist.submap(%0, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %87 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%79, %82, %85 : tensor, tensor, tensor) outs(%86 : tensor) { + ^bb0(%in: f64, %in_20: f64, %in_21: f64, %out: f64): + %90 = arith.addf %in, %in_20 : f64 + %91 = arith.addf %90, %in_21 : f64 + %92 = arith.addf %out, %91 : f64 + linalg.yield %92 : f64 + } -> tensor + %88 = polygeist.submapInverse(%0, %87, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %89 = bufferization.to_memref %88 : memref + memref.copy %89, %arg6 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_diffusion_3d.raised.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_diffusion_3d.raised.mlir new file mode 100644 index 000000000000..2b20860bb5ce --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_diffusion_3d.raised.mlir @@ -0,0 +1,324 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 750)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 125)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 250)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 375)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 500)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 625)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_abs_l1_diffusion_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_14 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_15 = memref.alloca() : memref<2x4x4x5xf64> + %subview = memref.subview %alloca_15[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg5, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_15 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_71: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + %subview_16 = memref.subview %alloca_14[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_16 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg5, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%2, %3 : memref, memref) outs(%alloca_14 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_71: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + %subview_17 = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_17 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_18 = memref.subview %alloca_14[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %4 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_19 = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_18, %4 : memref>, memref) outs(%subview_19 : memref>) { + ^bb0(%in: f64, %in_71: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + %subview_20 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_20 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_21 = memref.subview %alloca_15[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %5 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_22 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_21, %5 : memref>, memref) outs(%subview_22 : memref>) { + ^bb0(%in: f64, %in_71: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + %subview_23 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_23 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_24 = memref.subview %alloca_15[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %6 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_25 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_24, %6 : memref>, memref) outs(%subview_25 : memref>) { + ^bb0(%in: f64, %in_71: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + %subview_26 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_26 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_27 = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %7 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_28 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_27, %7 : memref>, memref) outs(%subview_28 : memref>) { + ^bb0(%in: f64, %in_71: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + %subview_29 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_29 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_30 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %8 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_31 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_30, %8 : memref>, memref) outs(%subview_31 : memref>) { + ^bb0(%in: f64, %in_71: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + %subview_32 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_32 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_33 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %9 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_34 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_33, %9 : memref>, memref) outs(%subview_34 : memref>) { + ^bb0(%in: f64, %in_71: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + %subview_35 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_35 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %10 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (memref, index, index, index, index, index) -> memref + %subview_36 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %11 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_37 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %12 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (memref, index, index, index, index, index) -> memref + %subview_38 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %13 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_39 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%10, %subview_36, %11, %subview_37, %12, %subview_38, %13 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_39 : memref>) { + ^bb0(%in: f64, %in_71: f64, %in_72: f64, %in_73: f64, %in_74: f64, %in_75: f64, %in_76: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.mulf %in_72, %in_73 : f64 + %31 = arith.addf %29, %30 : f64 + %32 = arith.mulf %in_74, %in_75 : f64 + %33 = arith.addf %31, %32 : f64 + %34 = arith.mulf %33, %in_76 : f64 + %35 = arith.addf %out, %34 : f64 + linalg.yield %35 : f64 + } + %subview_40 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_40 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_41 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %15 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %subview_42 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %16 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_43 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %17 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_44 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%14, %subview_41, %15, %subview_42, %16, %subview_43, %17 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_44 : memref>) { + ^bb0(%in: f64, %in_71: f64, %in_72: f64, %in_73: f64, %in_74: f64, %in_75: f64, %in_76: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.mulf %in_72, %in_73 : f64 + %31 = arith.addf %29, %30 : f64 + %32 = arith.mulf %in_74, %in_75 : f64 + %33 = arith.addf %31, %32 : f64 + %34 = arith.mulf %33, %in_76 : f64 + %35 = arith.addf %out, %34 : f64 + linalg.yield %35 : f64 + } + %subview_45 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_45 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %18 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (memref, index, index, index, index, index) -> memref + %subview_46 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %19 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_47 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %20 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %subview_48 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %21 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_49 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%18, %subview_46, %19, %subview_47, %20, %subview_48, %21 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_49 : memref>) { + ^bb0(%in: f64, %in_71: f64, %in_72: f64, %in_73: f64, %in_74: f64, %in_75: f64, %in_76: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.mulf %in_72, %in_73 : f64 + %31 = arith.addf %29, %30 : f64 + %32 = arith.mulf %in_74, %in_75 : f64 + %33 = arith.addf %31, %32 : f64 + %34 = arith.mulf %33, %in_76 : f64 + %35 = arith.addf %out, %34 : f64 + linalg.yield %35 : f64 + } + %subview_50 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_50 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_51 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %22 = polygeist.submap(%arg2, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_52 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_51, %22 : memref>, memref) outs(%subview_52 : memref>) { + ^bb0(%in: f64, %in_71: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + %subview_53 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_53 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_54 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %23 = polygeist.submap(%arg3, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_55 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_54, %23 : memref>, memref) outs(%subview_55 : memref>) { + ^bb0(%in: f64, %in_71: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + %subview_56 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_56 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_57 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %24 = polygeist.submap(%arg2, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_58 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_57, %24 : memref>, memref) outs(%subview_58 : memref>) { + ^bb0(%in: f64, %in_71: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + %subview_59 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_59 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_60 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %25 = polygeist.submap(%arg2, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %subview_61 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_60, %25 : memref>, memref) outs(%subview_61 : memref>) { + ^bb0(%in: f64, %in_71: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + %subview_62 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_62 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_63 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %26 = polygeist.submap(%arg2, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %subview_64 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_63, %26 : memref>, memref) outs(%subview_64 : memref>) { + ^bb0(%in: f64, %in_71: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + %subview_65 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_65 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_66 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %27 = polygeist.submap(%arg3, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %subview_67 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_66, %27 : memref>, memref) outs(%subview_67 : memref>) { + ^bb0(%in: f64, %in_71: f64, %out: f64): + %29 = arith.mulf %in, %in_71 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + %subview_68 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_69 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_70 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %28 = polygeist.submap(%arg6, %c2, %c4, %c4, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_68, %subview_69, %subview_70 : memref>, memref>, memref>) outs(%28 : memref) { + ^bb0(%in: f64, %in_71: f64, %in_72: f64, %out: f64): + %29 = arith.addf %in, %in_71 : f64 + %30 = arith.addf %29, %in_72 : f64 + %31 = arith.addf %out, %30 : f64 + linalg.yield %31 : f64 + } + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_mass_3d.debufferized.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_mass_3d.debufferized.mlir new file mode 100644 index 000000000000..55c5563979ec --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_mass_3d.debufferized.mlir @@ -0,0 +1,115 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 125 + d1 * 25 + d2 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map14 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_abs_l1_mass_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = tensor.empty() : tensor<2x5x4x4xf64> + %6 = tensor.empty() : tensor<2x5x5x4xf64> + %7 = tensor.empty() : tensor<2x5x5x5xf64> + %8 = tensor.empty() : tensor<2x4x5x5xf64> + %9 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice = tensor.extract_slice %9[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %10 into %9[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %11 = polygeist.submap(%4, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %12 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%11, %12 : tensor, tensor) outs(%inserted_slice : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_5: f64, %out: f64): + %33 = arith.mulf %in, %in_5 : f64 + %34 = arith.addf %out, %33 : f64 + linalg.yield %34 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_0 = tensor.extract_slice %8[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %14 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_0 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_1 = tensor.extract_slice %13[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %15 = polygeist.submap(%4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%15, %extracted_slice_1 : tensor, tensor) outs(%14 : tensor) { + ^bb0(%in: f64, %in_5: f64, %out: f64): + %33 = arith.mulf %in, %in_5 : f64 + %34 = arith.addf %out, %33 : f64 + linalg.yield %34 : f64 + } -> tensor + %extracted_slice_2 = tensor.extract_slice %7[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %17 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_2 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %18 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map3, #map8, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%18, %16 : tensor, tensor) outs(%17 : tensor) { + ^bb0(%in: f64, %in_5: f64, %out: f64): + %33 = arith.mulf %in, %in_5 : f64 + %34 = arith.addf %out, %33 : f64 + linalg.yield %34 : f64 + } -> tensor + %20 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map9} : (tensor, index, index, index, index) -> tensor + %21 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%20 : tensor) outs(%19 : tensor) { + ^bb0(%in: f64, %out: f64): + %33 = arith.mulf %out, %in : f64 + linalg.yield %33 : f64 + } -> tensor + %extracted_slice_3 = tensor.extract_slice %6[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_3 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %23 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %24 = linalg.generic {doc = "", indexing_maps = [#map3, #map11, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%23, %21 : tensor, tensor) outs(%22 : tensor) { + ^bb0(%in: f64, %in_5: f64, %out: f64): + %33 = arith.mulf %in, %in_5 : f64 + %34 = arith.addf %out, %33 : f64 + linalg.yield %34 : f64 + } -> tensor + %extracted_slice_4 = tensor.extract_slice %5[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_4 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %26 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %27 = linalg.generic {doc = "", indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%26, %24 : tensor, tensor) outs(%25 : tensor) { + ^bb0(%in: f64, %in_5: f64, %out: f64): + %33 = arith.mulf %in, %in_5 : f64 + %34 = arith.addf %out, %33 : f64 + linalg.yield %34 : f64 + } -> tensor + %28 = polygeist.submap(%3, %c2, %c4, %c4, %c4, %c5) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %29 = polygeist.submap(%0, %c2, %c4, %c4, %c4) {map = #map14} : (tensor, index, index, index, index) -> tensor<2x4x4x4xf64> + %30 = linalg.generic {doc = "", indexing_maps = [#map3, #map8, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%28, %27 : tensor, tensor) outs(%29 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_5: f64, %out: f64): + %33 = arith.mulf %in, %in_5 : f64 + %34 = arith.addf %out, %33 : f64 + linalg.yield %34 : f64 + } -> tensor<2x4x4x4xf64> + %31 = polygeist.submapInverse(%0, %30, %c2, %c4, %c4, %c4) {map = #map14} : (tensor, tensor<2x4x4x4xf64>, index, index, index, index) -> tensor + %32 = bufferization.to_memref %31 : memref + memref.copy %32, %arg4 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_mass_3d.frontend.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_mass_3d.frontend.mlir new file mode 100644 index 000000000000..4fc00404197e --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_mass_3d.frontend.mlir @@ -0,0 +1,240 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_abs_l1_mass_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_2 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %2 = affine.load %arg3[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %2 = affine.load %alloca_3[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %2 = affine.load %alloca_2[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.load %arg2[%arg5 * 125 + %arg8 + %arg6 * 25 + %arg7 * 5] : memref + %1 = affine.load %alloca_1[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + %2 = arith.mulf %1, %0 : f64 + affine.store %2, %alloca_1[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg9 + %arg8 * 5] : memref + %2 = affine.load %alloca_1[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg9 + %arg7 * 5] : memref + %2 = affine.load %alloca_0[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %3 = affine.load %arg1[%arg9 + %arg6 * 5] : memref + %4 = affine.load %alloca[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg10, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg4[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg4[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + } + } + } + } + return + } + func.func @mfem_pa_mass_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_2 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %2 = affine.load %arg3[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %2 = affine.load %alloca_3[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %2 = affine.load %alloca_2[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.load %arg2[%arg5 * 125 + %arg8 + %arg6 * 25 + %arg7 * 5] : memref + %1 = affine.load %alloca_1[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + %2 = arith.mulf %1, %0 : f64 + affine.store %2, %alloca_1[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg9 + %arg8 * 5] : memref + %2 = affine.load %alloca_1[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg9 + %arg7 * 5] : memref + %2 = affine.load %alloca_0[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %3 = affine.load %arg1[%arg9 + %arg6 * 5] : memref + %4 = affine.load %alloca[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg10, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg4[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg4[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_mass_3d.matched.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_mass_3d.matched.mlir new file mode 100644 index 000000000000..bec84506edab --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_mass_3d.matched.mlir @@ -0,0 +1,78 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 125 + d1 * 25 + d2 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map14 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_abs_l1_mass_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = tensor.empty() : tensor<2x5x4x4xf64> + %6 = tensor.empty() : tensor<2x5x5x4xf64> + %7 = tensor.empty() : tensor<2x5x5x5xf64> + %8 = tensor.empty() : tensor<2x4x5x5xf64> + %9 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice = tensor.extract_slice %9[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %10 into %9[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %11 = polygeist.submap(%4, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %12 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %inserted_slice_contract_13_tc2 = tensor.cast %inserted_slice : tensor<2x4x4x5xf64> to tensor + + %v13_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%11, %12, %inserted_slice_contract_13_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %13 = tensor.cast %v13_tdyn : tensor to tensor<2x4x4x5xf64> + %extracted_slice_0 = tensor.extract_slice %8[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_1 = tensor.extract_slice %13[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %15 = polygeist.submap(%4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %16 = kernel.launch @cutensornetContraction2_f64_r5r4r4(%15, %extracted_slice_1, %extracted_slice_0) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_2 = tensor.extract_slice %7[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %18 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %19 = kernel.launch @cutensornetContraction2_f64_r5r4r4(%18, %16, %extracted_slice_2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %20 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map9} : (tensor, index, index, index, index) -> tensor + %21 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%20 : tensor) outs(%19 : tensor) { + ^bb0(%in: f64, %out: f64): + %33 = arith.mulf %out, %in : f64 + linalg.yield %33 : f64 + } -> tensor + %extracted_slice_3 = tensor.extract_slice %6[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %23 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %24 = kernel.launch @cutensornetContraction2_f64_r5r4r4(%23, %21, %extracted_slice_3) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_4 = tensor.extract_slice %5[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %26 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %27 = kernel.launch @cutensornetContraction2_f64_r5r4r4(%26, %24, %extracted_slice_4) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %28 = polygeist.submap(%3, %c2, %c4, %c4, %c4, %c5) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %29 = polygeist.submap(%0, %c2, %c4, %c4, %c4) {map = #map14} : (tensor, index, index, index, index) -> tensor<2x4x4x4xf64> + %30 = linalg.generic {doc = "", indexing_maps = [#map3, #map8, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%28, %27 : tensor, tensor) outs(%29 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_5: f64, %out: f64): + %33 = arith.mulf %in, %in_5 : f64 + %34 = arith.addf %out, %33 : f64 + linalg.yield %34 : f64 + } -> tensor<2x4x4x4xf64> + %31 = polygeist.submapInverse(%0, %30, %c2, %c4, %c4, %c4) {map = #map14} : (tensor, tensor<2x4x4x4xf64>, index, index, index, index) -> tensor + %32 = bufferization.to_memref %31 : memref + memref.copy %32, %arg4 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_mass_3d.raised.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_mass_3d.raised.mlir new file mode 100644 index 000000000000..33bb98dfa70b --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_abs_l1_mass_3d.raised.mlir @@ -0,0 +1,115 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 125 + d1 * 25 + d2 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map14 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_abs_l1_mass_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_2 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x5xf64> + %subview = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg3, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_3 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_18: f64, %out: f64): + %9 = arith.mulf %in, %in_18 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %subview_4 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_4 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_5 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %subview_6 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%2, %subview_5 : memref, memref>) outs(%subview_6 : memref>) { + ^bb0(%in: f64, %in_18: f64, %out: f64): + %9 = arith.mulf %in, %in_18 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %subview_7 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_7 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %3 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_8 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %subview_9 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map8, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%3, %subview_8 : memref, memref>) outs(%subview_9 : memref>) { + ^bb0(%in: f64, %in_18: f64, %out: f64): + %9 = arith.mulf %in, %in_18 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %4 = polygeist.submap(%arg2, %c2, %c5, %c5, %c5) {map = #map9} : (memref, index, index, index, index) -> memref + %subview_10 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%4 : memref) outs(%subview_10 : memref>) { + ^bb0(%in: f64, %out: f64): + %9 = arith.mulf %out, %in : f64 + linalg.yield %9 : f64 + } + %subview_11 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_11 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %5 = polygeist.submap(%arg1, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_12 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_13 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map11, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%5, %subview_12 : memref, memref>) outs(%subview_13 : memref>) { + ^bb0(%in: f64, %in_18: f64, %out: f64): + %9 = arith.mulf %in, %in_18 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %subview_14 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_14 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg1, %c2, %c5, %c4, %c4, %c5) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_15 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %subview_16 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%6, %subview_15 : memref, memref>) outs(%subview_16 : memref>) { + ^bb0(%in: f64, %in_18: f64, %out: f64): + %9 = arith.mulf %in, %in_18 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %7 = polygeist.submap(%arg1, %c2, %c4, %c4, %c4, %c5) {map = #map13} : (memref, index, index, index, index, index) -> memref + %subview_17 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %8 = polygeist.submap(%arg4, %c2, %c4, %c4, %c4) {map = #map14} : (memref, index, index, index, index) -> memref<2x4x4x4xf64> + linalg.generic {indexing_maps = [#map3, #map8, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%7, %subview_17 : memref, memref>) outs(%8 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_18: f64, %out: f64): + %9 = arith.mulf %in, %in_18 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_dfem_minimal_surface_2d.debufferized.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_dfem_minimal_surface_2d.debufferized.mlir new file mode 100644 index 000000000000..743a0b84824f --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_dfem_minimal_surface_2d.debufferized.mlir @@ -0,0 +1,219 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map8 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50 + 25)> +#map9 = affine_map<(d0, d1) -> (d1 + d0 * 5)> +#map10 = affine_map<(d0, d1) -> (d1 + d0 * 5 + 25)> +#map11 = affine_map<(d0, d1) -> (d1 + d0 * 5 + 50)> +#map12 = affine_map<(d0, d1) -> (d1 + d0 * 5 + 75)> +#map13 = affine_map<(d0, d1) -> (d1 * 4 + d0 * 20)> +#map14 = affine_map<(d0, d1) -> (d1 * 4 + d0 * 20 + 1)> +#map15 = affine_map<(d0, d1) -> (d1 * 4 + d0 * 20 + 2)> +#map16 = affine_map<(d0, d1) -> (d1 * 4 + d0 * 20 + 3)> +#map17 = affine_map<(d0, d1) -> (d0, d1)> +#map18 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d2)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50 + 25)> +#map21 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d1)> +#map22 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_dfem_minimal_surface_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f64 + %cst_0 = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = bufferization.to_tensor %arg0 : memref + %6 = tensor.empty() : tensor<100xf64> + %7 = tensor.empty() : tensor<100xf64> + %8 = tensor.empty() : tensor<2x4x5xf64> + %9 = tensor.empty() : tensor<2x4x5xf64> + %extracted_slice = tensor.extract_slice %9[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %10 into %9[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %11 = polygeist.submap(%5, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %12 = polygeist.submap(%3, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%12, %11 : tensor, tensor) outs(%inserted_slice : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_13: f64, %out: f64): + %67 = arith.mulf %in, %in_13 : f64 + %68 = arith.addf %out, %67 : f64 + linalg.yield %68 : f64 + } -> tensor<2x4x5xf64> + %extracted_slice_1 = tensor.extract_slice %8[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %14 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_1 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %inserted_slice_2 = tensor.insert_slice %14 into %8[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %15 = polygeist.submap(%4, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %16 = polygeist.submap(%3, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %17 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%16, %15 : tensor, tensor) outs(%inserted_slice_2 : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_13: f64, %out: f64): + %67 = arith.mulf %in, %in_13 : f64 + %68 = arith.addf %out, %67 : f64 + linalg.yield %68 : f64 + } -> tensor<2x4x5xf64> + %18 = polygeist.submap(%7, %c2, %c5, %c5) {map = #map5} : (tensor<100xf64>, index, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%18 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %20 = polygeist.submapInverse(%7, %19, %c2, %c5, %c5) {map = #map5} : (tensor<100xf64>, tensor, index, index, index) -> tensor<100xf64> + %21 = polygeist.submap(%20, %c2, %c5, %c5) {map = #map5} : (tensor<100xf64>, index, index, index) -> tensor<2x5x5xf64> + %extracted_slice_3 = tensor.extract_slice %17[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %22 = polygeist.submap(%5, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %23 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_3, %22 : tensor, tensor) outs(%21 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %in_13: f64, %out: f64): + %67 = arith.mulf %in, %in_13 : f64 + %68 = arith.addf %out, %67 : f64 + linalg.yield %68 : f64 + } -> tensor<2x5x5xf64> + %24 = polygeist.submapInverse(%20, %23, %c2, %c5, %c5) {map = #map5} : (tensor<100xf64>, tensor<2x5x5xf64>, index, index, index) -> tensor<100xf64> + %25 = polygeist.submap(%24, %c2, %c5, %c5) {map = #map8} : (tensor<100xf64>, index, index, index) -> tensor + %26 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%25 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %27 = polygeist.submapInverse(%24, %26, %c2, %c5, %c5) {map = #map8} : (tensor<100xf64>, tensor, index, index, index) -> tensor<100xf64> + %28 = polygeist.submap(%27, %c2, %c5, %c5) {map = #map8} : (tensor<100xf64>, index, index, index) -> tensor<2x5x5xf64> + %extracted_slice_4 = tensor.extract_slice %13[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %29 = polygeist.submap(%4, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %30 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_4, %29 : tensor, tensor) outs(%28 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %in_13: f64, %out: f64): + %67 = arith.mulf %in, %in_13 : f64 + %68 = arith.addf %out, %67 : f64 + linalg.yield %68 : f64 + } -> tensor<2x5x5xf64> + %31 = polygeist.submapInverse(%27, %30, %c2, %c5, %c5) {map = #map8} : (tensor<100xf64>, tensor<2x5x5xf64>, index, index, index) -> tensor<100xf64> + %32 = polygeist.submap(%6, %c5, %c5) {map = #map9} : (tensor<100xf64>, index, index) -> tensor + %33 = polygeist.submap(%6, %c5, %c5) {map = #map10} : (tensor<100xf64>, index, index) -> tensor + %34 = polygeist.submap(%6, %c5, %c5) {map = #map11} : (tensor<100xf64>, index, index) -> tensor + %35 = polygeist.submap(%6, %c5, %c5) {map = #map12} : (tensor<100xf64>, index, index) -> tensor + %36 = polygeist.submap(%31, %c5, %c5) {map = #map9} : (tensor<100xf64>, index, index) -> tensor + %37 = polygeist.submap(%31, %c5, %c5) {map = #map10} : (tensor<100xf64>, index, index) -> tensor + %38 = polygeist.submap(%2, %c5, %c5) {map = #map13} : (tensor, index, index) -> tensor + %39 = polygeist.submap(%2, %c5, %c5) {map = #map14} : (tensor, index, index) -> tensor + %40 = polygeist.submap(%2, %c5, %c5) {map = #map15} : (tensor, index, index) -> tensor + %41 = polygeist.submap(%2, %c5, %c5) {map = #map16} : (tensor, index, index) -> tensor + %42 = polygeist.submap(%1, %c5, %c5) {map = #map9} : (tensor, index, index) -> tensor + %43:4 = linalg.generic {doc = "", indexing_maps = [#map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%36, %37, %38, %39, %40, %41, %42 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%32, %33, %34, %35 : tensor, tensor, tensor, tensor) { + ^bb0(%in: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %in_18: f64, %out: f64, %out_19: f64, %out_20: f64, %out_21: f64): + %67 = arith.mulf %in_14, %in_17 : f64 + %68 = arith.mulf %in_15, %in_16 : f64 + %69 = arith.subf %67, %68 : f64 + %70 = arith.divf %in_17, %69 : f64 + %71 = arith.negf %in_15 : f64 + %72 = arith.divf %71, %69 : f64 + %73 = arith.negf %in_16 : f64 + %74 = arith.divf %73, %69 : f64 + %75 = arith.divf %in_14, %69 : f64 + %76 = arith.mulf %in, %70 : f64 + %77 = arith.mulf %in_13, %74 : f64 + %78 = arith.addf %76, %77 : f64 + %79 = arith.mulf %in, %72 : f64 + %80 = arith.mulf %in_13, %75 : f64 + %81 = arith.addf %79, %80 : f64 + %82 = arith.mulf %78, %78 : f64 + %83 = arith.addf %82, %cst : f64 + %84 = arith.mulf %81, %81 : f64 + %85 = arith.addf %83, %84 : f64 + %86 = math.sqrt %85 : f64 + %87 = arith.divf %cst, %86 : f64 + %88 = arith.mulf %87, %69 : f64 + %89 = arith.mulf %88, %in_18 : f64 + %90 = arith.mulf %78, %70 : f64 + %91 = arith.mulf %81, %72 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %89, %92 : f64 + %94 = arith.mulf %78, %74 : f64 + %95 = arith.mulf %81, %75 : f64 + %96 = arith.addf %94, %95 : f64 + %97 = arith.mulf %89, %96 : f64 + linalg.yield %93, %97, %cst_0, %cst_0 : f64, f64, f64, f64 + } -> (tensor, tensor, tensor, tensor) + %44 = polygeist.submapInverse(%6, %43#3, %c5, %c5) {map = #map12} : (tensor<100xf64>, tensor, index, index) -> tensor<100xf64> + %45 = tensor.empty() : tensor<2x4x4xf64> + %46 = tensor.empty() : tensor<2x4x4xf64> + %47 = tensor.empty() : tensor<2x5x4xf64> + %48 = tensor.empty() : tensor<2x5x4xf64> + %extracted_slice_5 = tensor.extract_slice %48[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %49 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_5 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %inserted_slice_6 = tensor.insert_slice %49 into %48[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor into tensor<2x5x4xf64> + %50 = polygeist.submap(%44, %c2, %c5, %c4, %c5) {map = #map18} : (tensor<100xf64>, index, index, index, index) -> tensor + %51 = polygeist.submap(%4, %c2, %c5, %c4, %c5) {map = #map19} : (tensor, index, index, index, index) -> tensor + %52 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%50, %51 : tensor, tensor) outs(%inserted_slice_6 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_13: f64, %out: f64): + %67 = arith.mulf %in, %in_13 : f64 + %68 = arith.addf %out, %67 : f64 + linalg.yield %68 : f64 + } -> tensor<2x5x4xf64> + %extracted_slice_7 = tensor.extract_slice %47[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %53 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_7 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %inserted_slice_8 = tensor.insert_slice %53 into %47[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor into tensor<2x5x4xf64> + %54 = polygeist.submap(%44, %c2, %c5, %c4, %c5) {map = #map20} : (tensor<100xf64>, index, index, index, index) -> tensor + %55 = polygeist.submap(%5, %c2, %c5, %c4, %c5) {map = #map19} : (tensor, index, index, index, index) -> tensor + %56 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%54, %55 : tensor, tensor) outs(%inserted_slice_8 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_13: f64, %out: f64): + %67 = arith.mulf %in, %in_13 : f64 + %68 = arith.addf %out, %67 : f64 + linalg.yield %68 : f64 + } -> tensor<2x5x4xf64> + %extracted_slice_9 = tensor.extract_slice %46[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : tensor<2x4x4xf64> to tensor + %57 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_9 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %extracted_slice_10 = tensor.extract_slice %52[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %58 = polygeist.submap(%5, %c2, %c4, %c4, %c5) {map = #map21} : (tensor, index, index, index, index) -> tensor + %59 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_10, %58 : tensor, tensor) outs(%57 : tensor) { + ^bb0(%in: f64, %in_13: f64, %out: f64): + %67 = arith.mulf %in, %in_13 : f64 + %68 = arith.addf %out, %67 : f64 + linalg.yield %68 : f64 + } -> tensor + %extracted_slice_11 = tensor.extract_slice %45[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : tensor<2x4x4xf64> to tensor + %60 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_11 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %extracted_slice_12 = tensor.extract_slice %56[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %61 = polygeist.submap(%4, %c2, %c4, %c4, %c5) {map = #map21} : (tensor, index, index, index, index) -> tensor + %62 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_12, %61 : tensor, tensor) outs(%60 : tensor) { + ^bb0(%in: f64, %in_13: f64, %out: f64): + %67 = arith.mulf %in, %in_13 : f64 + %68 = arith.addf %out, %67 : f64 + linalg.yield %68 : f64 + } -> tensor + %63 = polygeist.submap(%0, %c2, %c4, %c4) {map = #map22} : (tensor, index, index, index) -> tensor + %64 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%59, %62 : tensor, tensor) outs(%63 : tensor) { + ^bb0(%in: f64, %in_13: f64, %out: f64): + %67 = arith.addf %in, %in_13 : f64 + %68 = arith.addf %out, %67 : f64 + linalg.yield %68 : f64 + } -> tensor + %65 = polygeist.submapInverse(%0, %64, %c2, %c4, %c4) {map = #map22} : (tensor, tensor, index, index, index) -> tensor + %66 = bufferization.to_memref %65 : memref + memref.copy %66, %arg5 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_dfem_minimal_surface_2d.frontend.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_dfem_minimal_surface_2d.frontend.mlir new file mode 100644 index 000000000000..52cac8f51f07 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_dfem_minimal_surface_2d.frontend.mlir @@ -0,0 +1,323 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_dfem_minimal_surface_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %cst_0 = arith.constant 1.000000e+00 : f64 + %alloca = memref.alloca() : memref<100xf64> + %alloca_1 = memref.alloca() : memref<100xf64> + %alloca_2 = memref.alloca() : memref<2x4x5xf64> + %alloca_3 = memref.alloca() : memref<2x4x5xf64> + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg2[%arg9 + %arg6 * 16 + %arg7 * 4] : memref + %2 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg6, %arg7, %arg8] : memref<2x4x5xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg2[%arg9 + %arg6 * 16 + %arg7 * 4] : memref + %2 = affine.load %arg1[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg6, %arg7, %arg8] : memref<2x4x5xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg6, %arg9, %arg8] : memref<2x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg7 + %arg6 * 50 + %arg8 * 5] : memref<100xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg6, %arg9, %arg8] : memref<2x4x5xf64> + %2 = affine.load %arg1[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg7 + %arg6 * 50 + %arg8 * 5 + 25] : memref<100xf64> + } + } + } + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.load %alloca_1[%arg7 + %arg6 * 5] : memref<100xf64> + %1 = affine.load %alloca_1[%arg7 + %arg6 * 5 + 25] : memref<100xf64> + %2 = affine.load %arg3[%arg7 * 4 + %arg6 * 20] : memref + %3 = affine.load %arg3[%arg7 * 4 + %arg6 * 20 + 1] : memref + %4 = affine.load %arg3[%arg7 * 4 + %arg6 * 20 + 2] : memref + %5 = affine.load %arg3[%arg7 * 4 + %arg6 * 20 + 3] : memref + %6 = arith.mulf %2, %5 : f64 + %7 = arith.mulf %3, %4 : f64 + %8 = arith.subf %6, %7 : f64 + %9 = arith.divf %5, %8 : f64 + %10 = arith.negf %3 : f64 + %11 = arith.divf %10, %8 : f64 + %12 = arith.negf %4 : f64 + %13 = arith.divf %12, %8 : f64 + %14 = arith.divf %2, %8 : f64 + %15 = arith.mulf %0, %9 : f64 + %16 = arith.mulf %1, %13 : f64 + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %0, %11 : f64 + %19 = arith.mulf %1, %14 : f64 + %20 = arith.addf %18, %19 : f64 + %21 = arith.mulf %17, %17 : f64 + %22 = arith.addf %21, %cst_0 : f64 + %23 = arith.mulf %20, %20 : f64 + %24 = arith.addf %22, %23 : f64 + %25 = math.sqrt %24 : f64 + %26 = arith.divf %cst_0, %25 : f64 + %27 = arith.mulf %26, %8 : f64 + %28 = affine.load %arg4[%arg7 + %arg6 * 5] : memref + %29 = arith.mulf %27, %28 : f64 + %30 = arith.mulf %17, %9 : f64 + %31 = arith.mulf %20, %11 : f64 + %32 = arith.addf %30, %31 : f64 + %33 = arith.mulf %29, %32 : f64 + affine.store %33, %alloca[%arg7 + %arg6 * 5] : memref<100xf64> + %34 = arith.mulf %17, %13 : f64 + %35 = arith.mulf %20, %14 : f64 + %36 = arith.addf %34, %35 : f64 + %37 = arith.mulf %29, %36 : f64 + affine.store %37, %alloca[%arg7 + %arg6 * 5 + 25] : memref<100xf64> + affine.store %cst, %alloca[%arg7 + %arg6 * 5 + 50] : memref<100xf64> + affine.store %cst, %alloca[%arg7 + %arg6 * 5 + 75] : memref<100xf64> + } + } + %alloca_4 = memref.alloca() : memref<2x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4xf64> + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg7 + %arg6 * 50 + %arg9 * 5] : memref<100xf64> + %2 = affine.load %arg1[%arg8 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg6, %arg7, %arg8] : memref<2x5x4xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg7 + %arg6 * 50 + %arg9 * 5 + 25] : memref<100xf64> + %2 = affine.load %arg0[%arg8 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg6, %arg7, %arg8] : memref<2x5x4xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg6, %arg9, %arg8] : memref<2x5x4xf64> + %2 = affine.load %arg0[%arg7 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg6, %arg7, %arg8] : memref<2x4x4xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg6, %arg9, %arg8] : memref<2x5x4xf64> + %2 = affine.load %arg1[%arg7 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg6, %arg7, %arg8] : memref<2x4x4xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_5[%arg6, %arg7, %arg8] : memref<2x4x4xf64> + %1 = affine.load %alloca_4[%arg6, %arg7, %arg8] : memref<2x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %arg5[%arg8 + %arg6 * 16 + %arg7 * 4] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg5[%arg8 + %arg6 * 16 + %arg7 * 4] : memref + } + } + } + return + } + func.func @mfem_interp_grad_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x5xf64> + %alloca_0 = memref.alloca() : memref<2x4x5xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg7 + %arg4 * 16 + %arg5 * 4] : memref + %2 = affine.load %arg1[%arg7 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg4, %arg5, %arg6] : memref<2x4x5xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg7 + %arg4 * 16 + %arg5 * 4] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg4, %arg5, %arg6] : memref<2x4x5xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg4, %arg7, %arg6] : memref<2x4x5xf64> + %2 = affine.load %arg1[%arg7 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %arg3[%arg5 + %arg4 * 50 + %arg6 * 5] : memref + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca_0[%arg4, %arg7, %arg6] : memref<2x4x5xf64> + %2 = affine.load %arg2[%arg7 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %arg3[%arg5 + %arg4 * 50 + %arg6 * 5 + 25] : memref + } + } + } + return + } + func.func @mfem_integrate_grad_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 4 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg5 + %arg4 * 50 + %arg7 * 5] : memref + %2 = affine.load %arg2[%arg6 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg4, %arg5, %arg6] : memref<2x5x4xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 4 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg5 + %arg4 * 50 + %arg7 * 5 + 25] : memref + %2 = affine.load %arg1[%arg6 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg4, %arg5, %arg6] : memref<2x5x4xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg4, %arg7, %arg6] : memref<2x5x4xf64> + %2 = affine.load %arg1[%arg5 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg4, %arg5, %arg6] : memref<2x4x4xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca_1[%arg4, %arg7, %arg6] : memref<2x5x4xf64> + %2 = affine.load %arg2[%arg5 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg4, %arg5, %arg6] : memref<2x4x4xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + %0 = affine.load %alloca_0[%arg4, %arg5, %arg6] : memref<2x4x4xf64> + %1 = affine.load %alloca[%arg4, %arg5, %arg6] : memref<2x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %arg3[%arg6 + %arg4 * 16 + %arg5 * 4] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg3[%arg6 + %arg4 * 16 + %arg5 * 4] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_dfem_minimal_surface_2d.matched.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_dfem_minimal_surface_2d.matched.mlir new file mode 100644 index 000000000000..7fa39c8f76d8 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_dfem_minimal_surface_2d.matched.mlir @@ -0,0 +1,235 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map8 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50 + 25)> +#map9 = affine_map<(d0, d1) -> (d1 + d0 * 5)> +#map10 = affine_map<(d0, d1) -> (d1 + d0 * 5 + 25)> +#map11 = affine_map<(d0, d1) -> (d1 + d0 * 5 + 50)> +#map12 = affine_map<(d0, d1) -> (d1 + d0 * 5 + 75)> +#map13 = affine_map<(d0, d1) -> (d1 * 4 + d0 * 20)> +#map14 = affine_map<(d0, d1) -> (d1 * 4 + d0 * 20 + 1)> +#map15 = affine_map<(d0, d1) -> (d1 * 4 + d0 * 20 + 2)> +#map16 = affine_map<(d0, d1) -> (d1 * 4 + d0 * 20 + 3)> +#map17 = affine_map<(d0, d1) -> (d0, d1)> +#map18 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d2)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50 + 25)> +#map21 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d1)> +#map22 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_dfem_minimal_surface_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f64 + %cst_0 = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = bufferization.to_tensor %arg0 : memref + %6 = tensor.empty() : tensor<100xf64> + %7 = tensor.empty() : tensor<100xf64> + %8 = tensor.empty() : tensor<2x4x5xf64> + %9 = tensor.empty() : tensor<2x4x5xf64> + %extracted_slice = tensor.extract_slice %9[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %10 into %9[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %11 = polygeist.submap(%5, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %12 = polygeist.submap(%3, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v12_contract_13_tc0 = tensor.cast %12 : tensor to tensor<*xf64> + + %v11_contract_13_tc1 = tensor.cast %11 : tensor to tensor<*xf64> + + %inserted_slice_contract_13_tc2 = tensor.cast %inserted_slice : tensor<2x4x5xf64> to tensor<*xf64> + + %v13_tdyn = kernel.launch @cutensornetContraction2_f64(%v12_contract_13_tc0, %v11_contract_13_tc1, %inserted_slice_contract_13_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %13 = tensor.cast %v13_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %extracted_slice_1 = tensor.extract_slice %8[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %14 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_1 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %inserted_slice_2 = tensor.insert_slice %14 into %8[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %15 = polygeist.submap(%4, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %16 = polygeist.submap(%3, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v16_contract_17_tc0 = tensor.cast %16 : tensor to tensor<*xf64> + + %v15_contract_17_tc1 = tensor.cast %15 : tensor to tensor<*xf64> + + %inserted_slice_2_contract_17_tc2 = tensor.cast %inserted_slice_2 : tensor<2x4x5xf64> to tensor<*xf64> + + %v17_tdyn = kernel.launch @cutensornetContraction2_f64(%v16_contract_17_tc0, %v15_contract_17_tc1, %inserted_slice_2_contract_17_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %17 = tensor.cast %v17_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %18 = polygeist.submap(%7, %c2, %c5, %c5) {map = #map5} : (tensor<100xf64>, index, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%18 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %20 = polygeist.submapInverse(%7, %19, %c2, %c5, %c5) {map = #map5} : (tensor<100xf64>, tensor, index, index, index) -> tensor<100xf64> + %21 = polygeist.submap(%20, %c2, %c5, %c5) {map = #map5} : (tensor<100xf64>, index, index, index) -> tensor<2x5x5xf64> + %extracted_slice_3 = tensor.extract_slice %17[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %22 = polygeist.submap(%5, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %extracted_slice_3_contract_23_tc0 = tensor.cast %extracted_slice_3 : tensor to tensor<*xf64> + + %v22_contract_23_tc1 = tensor.cast %22 : tensor to tensor<*xf64> + + %v21_contract_23_tc2 = tensor.cast %21 : tensor<2x5x5xf64> to tensor<*xf64> + + %v23_tdyn = kernel.launch @cutensornetContraction2_f64(%extracted_slice_3_contract_23_tc0, %v22_contract_23_tc1, %v21_contract_23_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %23 = tensor.cast %v23_tdyn : tensor<*xf64> to tensor<2x5x5xf64> + %24 = polygeist.submapInverse(%20, %23, %c2, %c5, %c5) {map = #map5} : (tensor<100xf64>, tensor<2x5x5xf64>, index, index, index) -> tensor<100xf64> + %25 = polygeist.submap(%24, %c2, %c5, %c5) {map = #map8} : (tensor<100xf64>, index, index, index) -> tensor + %26 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%25 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %27 = polygeist.submapInverse(%24, %26, %c2, %c5, %c5) {map = #map8} : (tensor<100xf64>, tensor, index, index, index) -> tensor<100xf64> + %28 = polygeist.submap(%27, %c2, %c5, %c5) {map = #map8} : (tensor<100xf64>, index, index, index) -> tensor<2x5x5xf64> + %extracted_slice_4 = tensor.extract_slice %13[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %29 = polygeist.submap(%4, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %extracted_slice_4_contract_30_tc0 = tensor.cast %extracted_slice_4 : tensor to tensor<*xf64> + + %v29_contract_30_tc1 = tensor.cast %29 : tensor to tensor<*xf64> + + %v28_contract_30_tc2 = tensor.cast %28 : tensor<2x5x5xf64> to tensor<*xf64> + + %v30_tdyn = kernel.launch @cutensornetContraction2_f64(%extracted_slice_4_contract_30_tc0, %v29_contract_30_tc1, %v28_contract_30_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %30 = tensor.cast %v30_tdyn : tensor<*xf64> to tensor<2x5x5xf64> + %31 = polygeist.submapInverse(%27, %30, %c2, %c5, %c5) {map = #map8} : (tensor<100xf64>, tensor<2x5x5xf64>, index, index, index) -> tensor<100xf64> + %32 = polygeist.submap(%6, %c5, %c5) {map = #map9} : (tensor<100xf64>, index, index) -> tensor + %33 = polygeist.submap(%6, %c5, %c5) {map = #map10} : (tensor<100xf64>, index, index) -> tensor + %34 = polygeist.submap(%6, %c5, %c5) {map = #map11} : (tensor<100xf64>, index, index) -> tensor + %35 = polygeist.submap(%6, %c5, %c5) {map = #map12} : (tensor<100xf64>, index, index) -> tensor + %36 = polygeist.submap(%31, %c5, %c5) {map = #map9} : (tensor<100xf64>, index, index) -> tensor + %37 = polygeist.submap(%31, %c5, %c5) {map = #map10} : (tensor<100xf64>, index, index) -> tensor + %38 = polygeist.submap(%2, %c5, %c5) {map = #map13} : (tensor, index, index) -> tensor + %39 = polygeist.submap(%2, %c5, %c5) {map = #map14} : (tensor, index, index) -> tensor + %40 = polygeist.submap(%2, %c5, %c5) {map = #map15} : (tensor, index, index) -> tensor + %41 = polygeist.submap(%2, %c5, %c5) {map = #map16} : (tensor, index, index) -> tensor + %42 = polygeist.submap(%1, %c5, %c5) {map = #map9} : (tensor, index, index) -> tensor + %43:4 = linalg.generic {doc = "", indexing_maps = [#map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%36, %37, %38, %39, %40, %41, %42 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%32, %33, %34, %35 : tensor, tensor, tensor, tensor) { + ^bb0(%in: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %in_18: f64, %out: f64, %out_19: f64, %out_20: f64, %out_21: f64): + %67 = arith.mulf %in_14, %in_17 : f64 + %68 = arith.mulf %in_15, %in_16 : f64 + %69 = arith.subf %67, %68 : f64 + %70 = arith.divf %in_17, %69 : f64 + %71 = arith.negf %in_15 : f64 + %72 = arith.divf %71, %69 : f64 + %73 = arith.negf %in_16 : f64 + %74 = arith.divf %73, %69 : f64 + %75 = arith.divf %in_14, %69 : f64 + %76 = arith.mulf %in, %70 : f64 + %77 = arith.mulf %in_13, %74 : f64 + %78 = arith.addf %76, %77 : f64 + %79 = arith.mulf %in, %72 : f64 + %80 = arith.mulf %in_13, %75 : f64 + %81 = arith.addf %79, %80 : f64 + %82 = arith.mulf %78, %78 : f64 + %83 = arith.addf %82, %cst : f64 + %84 = arith.mulf %81, %81 : f64 + %85 = arith.addf %83, %84 : f64 + %86 = math.sqrt %85 : f64 + %87 = arith.divf %cst, %86 : f64 + %88 = arith.mulf %87, %69 : f64 + %89 = arith.mulf %88, %in_18 : f64 + %90 = arith.mulf %78, %70 : f64 + %91 = arith.mulf %81, %72 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %89, %92 : f64 + %94 = arith.mulf %78, %74 : f64 + %95 = arith.mulf %81, %75 : f64 + %96 = arith.addf %94, %95 : f64 + %97 = arith.mulf %89, %96 : f64 + linalg.yield %93, %97, %cst_0, %cst_0 : f64, f64, f64, f64 + } -> (tensor, tensor, tensor, tensor) + %44 = polygeist.submapInverse(%6, %43#3, %c5, %c5) {map = #map12} : (tensor<100xf64>, tensor, index, index) -> tensor<100xf64> + %45 = tensor.empty() : tensor<2x4x4xf64> + %46 = tensor.empty() : tensor<2x4x4xf64> + %47 = tensor.empty() : tensor<2x5x4xf64> + %48 = tensor.empty() : tensor<2x5x4xf64> + %extracted_slice_5 = tensor.extract_slice %48[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %49 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_5 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %inserted_slice_6 = tensor.insert_slice %49 into %48[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor into tensor<2x5x4xf64> + %50 = polygeist.submap(%44, %c2, %c5, %c4, %c5) {map = #map18} : (tensor<100xf64>, index, index, index, index) -> tensor + %51 = polygeist.submap(%4, %c2, %c5, %c4, %c5) {map = #map19} : (tensor, index, index, index, index) -> tensor + %v50_contract_52_tc0 = tensor.cast %50 : tensor to tensor<*xf64> + + %v51_contract_52_tc1 = tensor.cast %51 : tensor to tensor<*xf64> + + %inserted_slice_6_contract_52_tc2 = tensor.cast %inserted_slice_6 : tensor<2x5x4xf64> to tensor<*xf64> + + %v52_tdyn = kernel.launch @cutensornetContraction2_f64(%v50_contract_52_tc0, %v51_contract_52_tc1, %inserted_slice_6_contract_52_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %52 = tensor.cast %v52_tdyn : tensor<*xf64> to tensor<2x5x4xf64> + %extracted_slice_7 = tensor.extract_slice %47[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %53 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_7 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %inserted_slice_8 = tensor.insert_slice %53 into %47[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor into tensor<2x5x4xf64> + %54 = polygeist.submap(%44, %c2, %c5, %c4, %c5) {map = #map20} : (tensor<100xf64>, index, index, index, index) -> tensor + %55 = polygeist.submap(%5, %c2, %c5, %c4, %c5) {map = #map19} : (tensor, index, index, index, index) -> tensor + %v54_contract_56_tc0 = tensor.cast %54 : tensor to tensor<*xf64> + + %v55_contract_56_tc1 = tensor.cast %55 : tensor to tensor<*xf64> + + %inserted_slice_8_contract_56_tc2 = tensor.cast %inserted_slice_8 : tensor<2x5x4xf64> to tensor<*xf64> + + %v56_tdyn = kernel.launch @cutensornetContraction2_f64(%v54_contract_56_tc0, %v55_contract_56_tc1, %inserted_slice_8_contract_56_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %56 = tensor.cast %v56_tdyn : tensor<*xf64> to tensor<2x5x4xf64> + %extracted_slice_9 = tensor.extract_slice %46[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : tensor<2x4x4xf64> to tensor + %extracted_slice_10 = tensor.extract_slice %52[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %58 = polygeist.submap(%5, %c2, %c4, %c4, %c5) {map = #map21} : (tensor, index, index, index, index) -> tensor + %extracted_slice_10_contract_59_tc0 = tensor.cast %extracted_slice_10 : tensor to tensor<*xf64> + + %v58_contract_59_tc1 = tensor.cast %58 : tensor to tensor<*xf64> + + %extracted_slice_9_contract_59_tc2 = tensor.cast %extracted_slice_9 : tensor to tensor<*xf64> + + %v59_tdyn = kernel.launch @cutensornetContraction2_f64(%extracted_slice_10_contract_59_tc0, %v58_contract_59_tc1, %extracted_slice_9_contract_59_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %59 = tensor.cast %v59_tdyn : tensor<*xf64> to tensor + %extracted_slice_11 = tensor.extract_slice %45[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : tensor<2x4x4xf64> to tensor + %extracted_slice_12 = tensor.extract_slice %56[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %61 = polygeist.submap(%4, %c2, %c4, %c4, %c5) {map = #map21} : (tensor, index, index, index, index) -> tensor + %extracted_slice_12_contract_62_tc0 = tensor.cast %extracted_slice_12 : tensor to tensor<*xf64> + + %v61_contract_62_tc1 = tensor.cast %61 : tensor to tensor<*xf64> + + %extracted_slice_11_contract_62_tc2 = tensor.cast %extracted_slice_11 : tensor to tensor<*xf64> + + %v62_tdyn = kernel.launch @cutensornetContraction2_f64(%extracted_slice_12_contract_62_tc0, %v61_contract_62_tc1, %extracted_slice_11_contract_62_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %62 = tensor.cast %v62_tdyn : tensor<*xf64> to tensor + %63 = polygeist.submap(%0, %c2, %c4, %c4) {map = #map22} : (tensor, index, index, index) -> tensor + %64 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%59, %62 : tensor, tensor) outs(%63 : tensor) { + ^bb0(%in: f64, %in_13: f64, %out: f64): + %67 = arith.addf %in, %in_13 : f64 + %68 = arith.addf %out, %67 : f64 + linalg.yield %68 : f64 + } -> tensor + %65 = polygeist.submapInverse(%0, %64, %c2, %c4, %c4) {map = #map22} : (tensor, tensor, index, index, index) -> tensor + %66 = bufferization.to_memref %65 : memref + memref.copy %66, %arg5 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_dfem_minimal_surface_2d.raised.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_dfem_minimal_surface_2d.raised.mlir new file mode 100644 index 000000000000..d066ab666f2b --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_dfem_minimal_surface_2d.raised.mlir @@ -0,0 +1,205 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map8 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50 + 25)> +#map9 = affine_map<(d0, d1) -> (d1 + d0 * 5)> +#map10 = affine_map<(d0, d1) -> (d1 + d0 * 5 + 25)> +#map11 = affine_map<(d0, d1) -> (d1 * 4 + d0 * 20)> +#map12 = affine_map<(d0, d1) -> (d1 * 4 + d0 * 20 + 1)> +#map13 = affine_map<(d0, d1) -> (d1 * 4 + d0 * 20 + 2)> +#map14 = affine_map<(d0, d1) -> (d1 * 4 + d0 * 20 + 3)> +#map15 = affine_map<(d0, d1) -> (d1 + d0 * 5 + 50)> +#map16 = affine_map<(d0, d1) -> (d1 + d0 * 5 + 75)> +#map17 = affine_map<(d0, d1) -> (d0, d1)> +#map18 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d2)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50 + 25)> +#map21 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d1)> +#map22 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_dfem_minimal_surface_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %cst_0 = arith.constant 1.000000e+00 : f64 + %alloca = memref.alloca() : memref<100xf64> + %alloca_1 = memref.alloca() : memref<100xf64> + %alloca_2 = memref.alloca() : memref<2x4x5xf64> + %alloca_3 = memref.alloca() : memref<2x4x5xf64> + %subview = memref.subview %alloca_3[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg2, %c2, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_3 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_21: f64, %out: f64): + %28 = arith.mulf %in, %in_21 : f64 + %29 = arith.addf %out, %28 : f64 + linalg.yield %29 : f64 + } + %subview_4 = memref.subview %alloca_2[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_4 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg2, %c2, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%2, %3 : memref, memref) outs(%alloca_2 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_21: f64, %out: f64): + %28 = arith.mulf %in, %in_21 : f64 + %29 = arith.addf %out, %28 : f64 + linalg.yield %29 : f64 + } + %4 = polygeist.submap(%alloca_1, %c2, %c5, %c5) {map = #map5} : (memref<100xf64>, index, index, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%4 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_5 = memref.subview %alloca_2[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + %5 = polygeist.submap(%arg0, %c2, %c5, %c5, %c4) {map = #map6} : (memref, index, index, index, index) -> memref + %6 = polygeist.submap(%alloca_1, %c2, %c5, %c5) {map = #map5} : (memref<100xf64>, index, index, index) -> memref<2x5x5xf64> + linalg.generic {indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_5, %5 : memref>, memref) outs(%6 : memref<2x5x5xf64>) { + ^bb0(%in: f64, %in_21: f64, %out: f64): + %28 = arith.mulf %in, %in_21 : f64 + %29 = arith.addf %out, %28 : f64 + linalg.yield %29 : f64 + } + %7 = polygeist.submap(%alloca_1, %c2, %c5, %c5) {map = #map8} : (memref<100xf64>, index, index, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%7 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_6 = memref.subview %alloca_3[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + %8 = polygeist.submap(%arg1, %c2, %c5, %c5, %c4) {map = #map6} : (memref, index, index, index, index) -> memref + %9 = polygeist.submap(%alloca_1, %c2, %c5, %c5) {map = #map8} : (memref<100xf64>, index, index, index) -> memref<2x5x5xf64> + linalg.generic {indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_6, %8 : memref>, memref) outs(%9 : memref<2x5x5xf64>) { + ^bb0(%in: f64, %in_21: f64, %out: f64): + %28 = arith.mulf %in, %in_21 : f64 + %29 = arith.addf %out, %28 : f64 + linalg.yield %29 : f64 + } + %10 = polygeist.submap(%alloca_1, %c5, %c5) {map = #map9} : (memref<100xf64>, index, index) -> memref + %11 = polygeist.submap(%alloca_1, %c5, %c5) {map = #map10} : (memref<100xf64>, index, index) -> memref + %12 = polygeist.submap(%arg3, %c5, %c5) {map = #map11} : (memref, index, index) -> memref + %13 = polygeist.submap(%arg3, %c5, %c5) {map = #map12} : (memref, index, index) -> memref + %14 = polygeist.submap(%arg3, %c5, %c5) {map = #map13} : (memref, index, index) -> memref + %15 = polygeist.submap(%arg3, %c5, %c5) {map = #map14} : (memref, index, index) -> memref + %16 = polygeist.submap(%arg4, %c5, %c5) {map = #map9} : (memref, index, index) -> memref + %17 = polygeist.submap(%alloca, %c5, %c5) {map = #map9} : (memref<100xf64>, index, index) -> memref + %18 = polygeist.submap(%alloca, %c5, %c5) {map = #map10} : (memref<100xf64>, index, index) -> memref + %19 = polygeist.submap(%alloca, %c5, %c5) {map = #map15} : (memref<100xf64>, index, index) -> memref + %20 = polygeist.submap(%alloca, %c5, %c5) {map = #map16} : (memref<100xf64>, index, index) -> memref + linalg.generic {indexing_maps = [#map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17], iterator_types = ["parallel", "parallel"]} ins(%10, %11, %12, %13, %14, %15, %16 : memref, memref, memref, memref, memref, memref, memref) outs(%17, %18, %19, %20 : memref, memref, memref, memref) { + ^bb0(%in: f64, %in_21: f64, %in_22: f64, %in_23: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64, %out_27: f64, %out_28: f64, %out_29: f64): + %28 = arith.mulf %in_22, %in_25 : f64 + %29 = arith.mulf %in_23, %in_24 : f64 + %30 = arith.subf %28, %29 : f64 + %31 = arith.divf %in_25, %30 : f64 + %32 = arith.negf %in_23 : f64 + %33 = arith.divf %32, %30 : f64 + %34 = arith.negf %in_24 : f64 + %35 = arith.divf %34, %30 : f64 + %36 = arith.divf %in_22, %30 : f64 + %37 = arith.mulf %in, %31 : f64 + %38 = arith.mulf %in_21, %35 : f64 + %39 = arith.addf %37, %38 : f64 + %40 = arith.mulf %in, %33 : f64 + %41 = arith.mulf %in_21, %36 : f64 + %42 = arith.addf %40, %41 : f64 + %43 = arith.mulf %39, %39 : f64 + %44 = arith.addf %43, %cst_0 : f64 + %45 = arith.mulf %42, %42 : f64 + %46 = arith.addf %44, %45 : f64 + %47 = math.sqrt %46 : f64 + %48 = arith.divf %cst_0, %47 : f64 + %49 = arith.mulf %48, %30 : f64 + %50 = arith.mulf %49, %in_26 : f64 + %51 = arith.mulf %39, %31 : f64 + %52 = arith.mulf %42, %33 : f64 + %53 = arith.addf %51, %52 : f64 + %54 = arith.mulf %50, %53 : f64 + %55 = arith.mulf %39, %35 : f64 + %56 = arith.mulf %42, %36 : f64 + %57 = arith.addf %55, %56 : f64 + %58 = arith.mulf %50, %57 : f64 + linalg.yield %54, %58, %cst, %cst : f64, f64, f64, f64 + } + %alloca_7 = memref.alloca() : memref<2x4x4xf64> + %alloca_8 = memref.alloca() : memref<2x4x4xf64> + %alloca_9 = memref.alloca() : memref<2x5x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x4xf64> + %subview_11 = memref.subview %alloca_10[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_11 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %21 = polygeist.submap(%alloca, %c2, %c5, %c4, %c5) {map = #map18} : (memref<100xf64>, index, index, index, index) -> memref + %22 = polygeist.submap(%arg1, %c2, %c5, %c4, %c5) {map = #map19} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%21, %22 : memref, memref) outs(%alloca_10 : memref<2x5x4xf64>) { + ^bb0(%in: f64, %in_21: f64, %out: f64): + %28 = arith.mulf %in, %in_21 : f64 + %29 = arith.addf %out, %28 : f64 + linalg.yield %29 : f64 + } + %subview_12 = memref.subview %alloca_9[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_12 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %23 = polygeist.submap(%alloca, %c2, %c5, %c4, %c5) {map = #map20} : (memref<100xf64>, index, index, index, index) -> memref + %24 = polygeist.submap(%arg0, %c2, %c5, %c4, %c5) {map = #map19} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%23, %24 : memref, memref) outs(%alloca_9 : memref<2x5x4xf64>) { + ^bb0(%in: f64, %in_21: f64, %out: f64): + %28 = arith.mulf %in, %in_21 : f64 + %29 = arith.addf %out, %28 : f64 + linalg.yield %29 : f64 + } + %subview_13 = memref.subview %alloca_8[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_13 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_14 = memref.subview %alloca_10[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + %25 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5) {map = #map21} : (memref, index, index, index, index) -> memref + %subview_15 = memref.subview %alloca_8[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_14, %25 : memref>, memref) outs(%subview_15 : memref>) { + ^bb0(%in: f64, %in_21: f64, %out: f64): + %28 = arith.mulf %in, %in_21 : f64 + %29 = arith.addf %out, %28 : f64 + linalg.yield %29 : f64 + } + %subview_16 = memref.subview %alloca_7[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_16 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_17 = memref.subview %alloca_9[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + %26 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5) {map = #map21} : (memref, index, index, index, index) -> memref + %subview_18 = memref.subview %alloca_7[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_17, %26 : memref>, memref) outs(%subview_18 : memref>) { + ^bb0(%in: f64, %in_21: f64, %out: f64): + %28 = arith.mulf %in, %in_21 : f64 + %29 = arith.addf %out, %28 : f64 + linalg.yield %29 : f64 + } + %subview_19 = memref.subview %alloca_8[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + %subview_20 = memref.subview %alloca_7[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + %27 = polygeist.submap(%arg5, %c2, %c4, %c4) {map = #map22} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview_19, %subview_20 : memref>, memref>) outs(%27 : memref) { + ^bb0(%in: f64, %in_21: f64, %out: f64): + %28 = arith.addf %in, %in_21 : f64 + %29 = arith.addf %out, %28 : f64 + linalg.yield %29 : f64 + } + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_h1_3d.debufferized.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_h1_3d.debufferized.mlir new file mode 100644 index 000000000000..c1a56ea2db42 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_h1_3d.debufferized.mlir @@ -0,0 +1,385 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 750)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 125)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 250)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 375)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 500)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 625)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 125 + d1 * 25 + d2 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_h1_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg7 : memref + %1 = bufferization.to_tensor %arg6 : memref + %2 = bufferization.to_tensor %arg5 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = bufferization.to_tensor %arg3 : memref + %5 = bufferization.to_tensor %arg2 : memref + %6 = bufferization.to_tensor %arg1 : memref + %7 = bufferization.to_tensor %arg0 : memref + %8 = tensor.empty() : tensor<2x4x4x4xf64> + %9 = tensor.empty() : tensor<2x4x4x4xf64> + %10 = tensor.empty() : tensor<2x4x4x4xf64> + %11 = tensor.empty() : tensor<2x5x4x4xf64> + %12 = tensor.empty() : tensor<2x5x4x4xf64> + %13 = tensor.empty() : tensor<2x5x4x4xf64> + %14 = tensor.empty() : tensor<2x5x5x4xf64> + %15 = tensor.empty() : tensor<2x5x5x4xf64> + %16 = tensor.empty() : tensor<2x5x5x4xf64> + %17 = tensor.empty() : tensor<2x5x5x5xf64> + %18 = tensor.empty() : tensor<2x5x5x5xf64> + %19 = tensor.empty() : tensor<2x5x5x5xf64> + %20 = tensor.empty() : tensor<2x4x5x5xf64> + %21 = tensor.empty() : tensor<2x4x5x5xf64> + %22 = tensor.empty() : tensor<2x4x5x5xf64> + %23 = tensor.empty() : tensor<2x4x4x5xf64> + %24 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice = tensor.extract_slice %24[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %25 into %24[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %26 = polygeist.submap(%7, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %27 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%27, %26 : tensor, tensor) outs(%inserted_slice : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_0 = tensor.extract_slice %23[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %29 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_0 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_1 = tensor.insert_slice %29 into %23[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %30 = polygeist.submap(%6, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %31 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %32 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%31, %30 : tensor, tensor) outs(%inserted_slice_1 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_2 = tensor.extract_slice %22[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %33 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_2 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_3 = tensor.extract_slice %32[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %34 = polygeist.submap(%7, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %35 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_3, %34 : tensor, tensor) outs(%33 : tensor) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor + %extracted_slice_4 = tensor.extract_slice %21[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %36 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_4 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_5 = tensor.extract_slice %28[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %37 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %38 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_5, %37 : tensor, tensor) outs(%36 : tensor) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor + %extracted_slice_6 = tensor.extract_slice %20[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %39 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_6 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_7 = tensor.extract_slice %28[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %40 = polygeist.submap(%7, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %41 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_7, %40 : tensor, tensor) outs(%39 : tensor) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor + %extracted_slice_8 = tensor.extract_slice %19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %42 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_8 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %43 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %44 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%35, %43 : tensor, tensor) outs(%42 : tensor) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor + %extracted_slice_9 = tensor.extract_slice %18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %45 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_9 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %46 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %47 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%38, %46 : tensor, tensor) outs(%45 : tensor) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor + %extracted_slice_10 = tensor.extract_slice %17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %48 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_10 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %49 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %50 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%41, %49 : tensor, tensor) outs(%48 : tensor) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor + %extracted_slice_11 = tensor.extract_slice %16[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %51 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_11 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %52 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %53 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %54 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %55 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %56 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%53, %44, %54, %47, %55, %50, %52 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%51 : tensor) { + ^bb0(%in: f64, %in_27: f64, %in_28: f64, %in_29: f64, %in_30: f64, %in_31: f64, %in_32: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.mulf %in_28, %in_29 : f64 + %120 = arith.addf %118, %119 : f64 + %121 = arith.mulf %in_30, %in_31 : f64 + %122 = arith.addf %120, %121 : f64 + %123 = arith.mulf %122, %in_32 : f64 + %124 = arith.addf %out, %123 : f64 + linalg.yield %124 : f64 + } -> tensor + %extracted_slice_12 = tensor.extract_slice %15[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %57 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_12 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %58 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %59 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %60 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %61 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %62 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%59, %44, %60, %47, %61, %50, %58 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%57 : tensor) { + ^bb0(%in: f64, %in_27: f64, %in_28: f64, %in_29: f64, %in_30: f64, %in_31: f64, %in_32: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.mulf %in_28, %in_29 : f64 + %120 = arith.addf %118, %119 : f64 + %121 = arith.mulf %in_30, %in_31 : f64 + %122 = arith.addf %120, %121 : f64 + %123 = arith.mulf %122, %in_32 : f64 + %124 = arith.addf %out, %123 : f64 + linalg.yield %124 : f64 + } -> tensor + %extracted_slice_13 = tensor.extract_slice %14[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_13 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %64 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %65 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %66 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %67 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %68 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%65, %44, %66, %47, %67, %50, %64 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%63 : tensor) { + ^bb0(%in: f64, %in_27: f64, %in_28: f64, %in_29: f64, %in_30: f64, %in_31: f64, %in_32: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.mulf %in_28, %in_29 : f64 + %120 = arith.addf %118, %119 : f64 + %121 = arith.mulf %in_30, %in_31 : f64 + %122 = arith.addf %120, %121 : f64 + %123 = arith.mulf %122, %in_32 : f64 + %124 = arith.addf %out, %123 : f64 + linalg.yield %124 : f64 + } -> tensor + %extracted_slice_14 = tensor.extract_slice %13[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %69 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_14 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %70 = polygeist.submap(%5, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %71 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%56, %70 : tensor, tensor) outs(%69 : tensor) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor + %extracted_slice_15 = tensor.extract_slice %12[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %72 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_15 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %73 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %74 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%62, %73 : tensor, tensor) outs(%72 : tensor) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor + %extracted_slice_16 = tensor.extract_slice %11[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %75 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_16 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %76 = polygeist.submap(%5, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %77 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%68, %76 : tensor, tensor) outs(%75 : tensor) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor + %extracted_slice_17 = tensor.extract_slice %10[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %78 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_17 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %79 = polygeist.submap(%5, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %80 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%71, %79 : tensor, tensor) outs(%78 : tensor) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor + %extracted_slice_18 = tensor.extract_slice %9[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %81 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_18 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %82 = polygeist.submap(%5, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %83 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%74, %82 : tensor, tensor) outs(%81 : tensor) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor + %extracted_slice_19 = tensor.extract_slice %8[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %84 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_19 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %85 = polygeist.submap(%4, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %86 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%77, %85 : tensor, tensor) outs(%84 : tensor) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor + %87 = polygeist.submap(%0, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %88 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%80, %83, %86 : tensor, tensor, tensor) outs(%87 : tensor) { + ^bb0(%in: f64, %in_27: f64, %in_28: f64, %out: f64): + %118 = arith.addf %in, %in_27 : f64 + %119 = arith.addf %118, %in_28 : f64 + %120 = arith.addf %out, %119 : f64 + linalg.yield %120 : f64 + } -> tensor + %89 = polygeist.submapInverse(%0, %88, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %90 = tensor.empty() : tensor<2x5x4x4xf64> + %91 = tensor.empty() : tensor<2x5x5x4xf64> + %92 = tensor.empty() : tensor<2x5x5x5xf64> + %93 = tensor.empty() : tensor<2x4x5x5xf64> + %94 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_20 = tensor.extract_slice %94[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %95 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_20 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_21 = tensor.insert_slice %95 into %94[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %96 = polygeist.submap(%7, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %97 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %98 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%96, %97 : tensor, tensor) outs(%inserted_slice_21 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_22 = tensor.extract_slice %93[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %99 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_22 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_23 = tensor.extract_slice %98[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %100 = polygeist.submap(%7, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %101 = linalg.generic {doc = "", indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%100, %extracted_slice_23 : tensor, tensor) outs(%99 : tensor) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor + %extracted_slice_24 = tensor.extract_slice %92[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %102 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_24 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %103 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %104 = linalg.generic {doc = "", indexing_maps = [#map3, #map8, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%103, %101 : tensor, tensor) outs(%102 : tensor) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor + %105 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map20} : (tensor, index, index, index, index) -> tensor + %106 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%105 : tensor) outs(%104 : tensor) { + ^bb0(%in: f64, %out: f64): + %118 = arith.mulf %out, %in : f64 + linalg.yield %118 : f64 + } -> tensor + %extracted_slice_25 = tensor.extract_slice %91[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %107 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_25 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %108 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %109 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%108, %106 : tensor, tensor) outs(%107 : tensor) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor + %extracted_slice_26 = tensor.extract_slice %90[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %110 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_26 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %111 = polygeist.submap(%5, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %112 = linalg.generic {doc = "", indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%111, %109 : tensor, tensor) outs(%110 : tensor) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor + %113 = polygeist.submap(%5, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %114 = polygeist.submap(%89, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor<2x4x4x4xf64> + %115 = linalg.generic {doc = "", indexing_maps = [#map3, #map8, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%113, %112 : tensor, tensor) outs(%114 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor<2x4x4x4xf64> + %116 = polygeist.submapInverse(%89, %115, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor<2x4x4x4xf64>, index, index, index, index) -> tensor + %117 = bufferization.to_memref %116 : memref + memref.copy %117, %arg7 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_h1_3d.frontend.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_h1_3d.frontend.mlir new file mode 100644 index 000000000000..98afaee029ca --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_h1_3d.frontend.mlir @@ -0,0 +1,914 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_h1_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_14 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_15 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + %0 = affine.for %arg12 = 0 to 4 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg8 * 64 + %arg12 + %arg9 * 16 + %arg10 * 4] : memref + %2 = affine.load %arg0[%arg12 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_15[%arg8, %arg9, %arg10, %arg11] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + %0 = affine.for %arg12 = 0 to 4 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg8 * 64 + %arg12 + %arg9 * 16 + %arg10 * 4] : memref + %2 = affine.load %arg1[%arg12 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_14[%arg8, %arg9, %arg10, %arg11] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + %0 = affine.for %arg12 = 0 to 4 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg8, %arg9, %arg12, %arg11] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg12 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg8, %arg9, %arg10, %arg11] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + %0 = affine.for %arg12 = 0 to 4 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg8, %arg9, %arg12, %arg11] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg12 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg8, %arg9, %arg10, %arg11] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + %0 = affine.for %arg12 = 0 to 4 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg8, %arg9, %arg12, %arg11] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg12 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg8, %arg9, %arg10, %arg11] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + %0 = affine.for %arg12 = 0 to 4 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg8, %arg12, %arg10, %arg11] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg12 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg8, %arg9, %arg10, %arg11] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + %0 = affine.for %arg12 = 0 to 4 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg8, %arg12, %arg10, %arg11] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg12 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg8, %arg9, %arg10, %arg11] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + %0 = affine.for %arg12 = 0 to 4 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg8, %arg12, %arg10, %arg11] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg12 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg8, %arg9, %arg10, %arg11] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + %0 = affine.for %arg12 = 0 to 5 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg9 * 25 + %arg12 + %arg10 * 5 + %arg8 * 750] : memref + %2 = affine.load %alloca_10[%arg8, %arg9, %arg10, %arg12] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg9 * 25 + %arg12 + %arg8 * 750 + %arg10 * 5 + 125] : memref + %5 = affine.load %alloca_9[%arg8, %arg9, %arg10, %arg12] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg9 * 25 + %arg12 + %arg8 * 750 + %arg10 * 5 + 250] : memref + %9 = affine.load %alloca_8[%arg8, %arg9, %arg10, %arg12] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg3[%arg12 + %arg11 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg13, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_7[%arg8, %arg9, %arg10, %arg11] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + %0 = affine.for %arg12 = 0 to 5 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg9 * 25 + %arg12 + %arg8 * 750 + %arg10 * 5 + 125] : memref + %2 = affine.load %alloca_10[%arg8, %arg9, %arg10, %arg12] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg9 * 25 + %arg12 + %arg8 * 750 + %arg10 * 5 + 375] : memref + %5 = affine.load %alloca_9[%arg8, %arg9, %arg10, %arg12] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg9 * 25 + %arg12 + %arg8 * 750 + %arg10 * 5 + 500] : memref + %9 = affine.load %alloca_8[%arg8, %arg9, %arg10, %arg12] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg12 + %arg11 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg13, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_6[%arg8, %arg9, %arg10, %arg11] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + %0 = affine.for %arg12 = 0 to 5 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg9 * 25 + %arg12 + %arg8 * 750 + %arg10 * 5 + 250] : memref + %2 = affine.load %alloca_10[%arg8, %arg9, %arg10, %arg12] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg9 * 25 + %arg12 + %arg8 * 750 + %arg10 * 5 + 500] : memref + %5 = affine.load %alloca_9[%arg8, %arg9, %arg10, %arg12] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg9 * 25 + %arg12 + %arg8 * 750 + %arg10 * 5 + 625] : memref + %9 = affine.load %alloca_8[%arg8, %arg9, %arg10, %arg12] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg12 + %arg11 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg13, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_5[%arg8, %arg9, %arg10, %arg11] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + %0 = affine.for %arg12 = 0 to 5 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg8, %arg9, %arg12, %arg11] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg12 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg8, %arg9, %arg10, %arg11] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + %0 = affine.for %arg12 = 0 to 5 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg8, %arg9, %arg12, %arg11] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg12 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg8, %arg9, %arg10, %arg11] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + %0 = affine.for %arg12 = 0 to 5 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg8, %arg9, %arg12, %arg11] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg12 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg8, %arg9, %arg10, %arg11] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + %0 = affine.for %arg12 = 0 to 5 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg8, %arg12, %arg10, %arg11] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg12 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg8, %arg9, %arg10, %arg11] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + %0 = affine.for %arg12 = 0 to 5 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg8, %arg12, %arg10, %arg11] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg12 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg8, %arg9, %arg10, %arg11] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + %0 = affine.for %arg12 = 0 to 5 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg8, %arg12, %arg10, %arg11] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg12 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg8, %arg9, %arg10, %arg11] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + %0 = affine.load %alloca_1[%arg8, %arg9, %arg10, %arg11] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_0[%arg8, %arg9, %arg10, %arg11] : memref<2x4x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %alloca[%arg8, %arg9, %arg10, %arg11] : memref<2x4x4x4xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg7[%arg8 * 64 + %arg11 + %arg9 * 16 + %arg10 * 4] : memref + %6 = arith.addf %5, %4 : f64 + affine.store %6, %arg7[%arg8 * 64 + %arg11 + %arg9 * 16 + %arg10 * 4] : memref + } + } + } + } + %alloca_16 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + %0 = affine.for %arg12 = 0 to 4 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg12 + %arg11 * 4] : memref + %2 = affine.load %arg6[%arg8 * 64 + %arg12 + %arg9 * 16 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_20[%arg8, %arg9, %arg10, %arg11] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + %0 = affine.for %arg12 = 0 to 4 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg12 + %arg10 * 4] : memref + %2 = affine.load %alloca_20[%arg8, %arg9, %arg12, %arg11] : memref<2x4x4x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_19[%arg8, %arg9, %arg10, %arg11] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + %0 = affine.for %arg12 = 0 to 4 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg12 + %arg9 * 4] : memref + %2 = affine.load %alloca_19[%arg8, %arg12, %arg10, %arg11] : memref<2x4x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_18[%arg8, %arg9, %arg10, %arg11] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + %0 = affine.load %arg5[%arg8 * 125 + %arg11 + %arg9 * 25 + %arg10 * 5] : memref + %1 = affine.load %alloca_18[%arg8, %arg9, %arg10, %arg11] : memref<2x5x5x5xf64> + %2 = arith.mulf %1, %0 : f64 + affine.store %2, %alloca_18[%arg8, %arg9, %arg10, %arg11] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + %0 = affine.for %arg12 = 0 to 5 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %arg2[%arg12 + %arg11 * 5] : memref + %2 = affine.load %alloca_18[%arg8, %arg9, %arg10, %arg12] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_17[%arg8, %arg9, %arg10, %arg11] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + %0 = affine.for %arg12 = 0 to 5 iter_args(%arg13 = %cst) -> (f64) { + %1 = affine.load %arg2[%arg12 + %arg10 * 5] : memref + %2 = affine.load %alloca_17[%arg8, %arg9, %arg12, %arg11] : memref<2x5x5x4xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_16[%arg8, %arg9, %arg10, %arg11] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + %0 = affine.for %arg12 = 0 to 5 iter_args(%arg13 = %cst) -> (f64) { + %3 = affine.load %arg2[%arg12 + %arg9 * 5] : memref + %4 = affine.load %alloca_16[%arg8, %arg12, %arg10, %arg11] : memref<2x5x4x4xf64> + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg13, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg7[%arg8 * 64 + %arg11 + %arg9 * 16 + %arg10 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg7[%arg8 * 64 + %arg11 + %arg9 * 16 + %arg10 * 4] : memref + } + } + } + } + return + } + func.func @mfem_pa_diffusion_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_14 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_15 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg7 * 64 + %arg11 + %arg8 * 16 + %arg9 * 4] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_15[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg7 * 64 + %arg11 + %arg8 * 16 + %arg9 * 4] : memref + %2 = affine.load %arg1[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_14[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg9 * 5 + %arg7 * 750] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 125] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 250] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg3[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_7[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 125] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 375] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 500] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 250] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 500] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 625] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.load %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg6[%arg7 * 64 + %arg10 + %arg8 * 16 + %arg9 * 4] : memref + %6 = arith.addf %5, %4 : f64 + affine.store %6, %arg6[%arg7 * 64 + %arg10 + %arg8 * 16 + %arg9 * 4] : memref + } + } + } + } + return + } + func.func @mfem_pa_mass_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_2 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %2 = affine.load %arg3[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %2 = affine.load %alloca_3[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %2 = affine.load %alloca_2[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.load %arg2[%arg5 * 125 + %arg8 + %arg6 * 25 + %arg7 * 5] : memref + %1 = affine.load %alloca_1[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + %2 = arith.mulf %1, %0 : f64 + affine.store %2, %alloca_1[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg9 + %arg8 * 5] : memref + %2 = affine.load %alloca_1[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg9 + %arg7 * 5] : memref + %2 = affine.load %alloca_0[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %3 = affine.load %arg1[%arg9 + %arg6 * 5] : memref + %4 = affine.load %alloca[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg10, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg4[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg4[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_h1_3d.matched.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_h1_3d.matched.mlir new file mode 100644 index 000000000000..e7b015ea9580 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_h1_3d.matched.mlir @@ -0,0 +1,238 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 750)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 125)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 250)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 375)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 500)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 625)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 125 + d1 * 25 + d2 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_h1_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg7 : memref + %1 = bufferization.to_tensor %arg6 : memref + %2 = bufferization.to_tensor %arg5 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = bufferization.to_tensor %arg3 : memref + %5 = bufferization.to_tensor %arg2 : memref + %6 = bufferization.to_tensor %arg1 : memref + %7 = bufferization.to_tensor %arg0 : memref + %8 = tensor.empty() : tensor<2x4x4x4xf64> + %9 = tensor.empty() : tensor<2x4x4x4xf64> + %10 = tensor.empty() : tensor<2x4x4x4xf64> + %11 = tensor.empty() : tensor<2x5x4x4xf64> + %12 = tensor.empty() : tensor<2x5x4x4xf64> + %13 = tensor.empty() : tensor<2x5x4x4xf64> + %14 = tensor.empty() : tensor<2x5x5x4xf64> + %15 = tensor.empty() : tensor<2x5x5x4xf64> + %16 = tensor.empty() : tensor<2x5x5x4xf64> + %17 = tensor.empty() : tensor<2x5x5x5xf64> + %18 = tensor.empty() : tensor<2x5x5x5xf64> + %19 = tensor.empty() : tensor<2x5x5x5xf64> + %20 = tensor.empty() : tensor<2x4x5x5xf64> + %21 = tensor.empty() : tensor<2x4x5x5xf64> + %22 = tensor.empty() : tensor<2x4x5x5xf64> + %23 = tensor.empty() : tensor<2x4x4x5xf64> + %24 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice = tensor.extract_slice %24[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %25 into %24[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %26 = polygeist.submap(%7, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %27 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %inserted_slice_contract_28_tc2 = tensor.cast %inserted_slice : tensor<2x4x4x5xf64> to tensor + + %v28_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%27, %26, %inserted_slice_contract_28_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %28 = tensor.cast %v28_tdyn : tensor to tensor<2x4x4x5xf64> + %extracted_slice_0 = tensor.extract_slice %23[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %29 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_0 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_1 = tensor.insert_slice %29 into %23[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %30 = polygeist.submap(%6, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %31 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %inserted_slice_1_contract_32_tc2 = tensor.cast %inserted_slice_1 : tensor<2x4x4x5xf64> to tensor + + %v32_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%31, %30, %inserted_slice_1_contract_32_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %32 = tensor.cast %v32_tdyn : tensor to tensor<2x4x4x5xf64> + %extracted_slice_2 = tensor.extract_slice %22[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_3 = tensor.extract_slice %32[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %34 = polygeist.submap(%7, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %35 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_3, %34, %extracted_slice_2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_4 = tensor.extract_slice %21[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_5 = tensor.extract_slice %28[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %37 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %38 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_5, %37, %extracted_slice_4) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_6 = tensor.extract_slice %20[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_7 = tensor.extract_slice %28[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %40 = polygeist.submap(%7, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %41 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_7, %40, %extracted_slice_6) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_8 = tensor.extract_slice %19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %43 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %44 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%35, %43, %extracted_slice_8) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_9 = tensor.extract_slice %18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %46 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %47 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%38, %46, %extracted_slice_9) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_10 = tensor.extract_slice %17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %49 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %50 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%41, %49, %extracted_slice_10) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_11 = tensor.extract_slice %16[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %51 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_11 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %52 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %53 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %54 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %55 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %56 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%53, %44, %54, %47, %55, %50, %52 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%51 : tensor) { + ^bb0(%in: f64, %in_27: f64, %in_28: f64, %in_29: f64, %in_30: f64, %in_31: f64, %in_32: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.mulf %in_28, %in_29 : f64 + %120 = arith.addf %118, %119 : f64 + %121 = arith.mulf %in_30, %in_31 : f64 + %122 = arith.addf %120, %121 : f64 + %123 = arith.mulf %122, %in_32 : f64 + %124 = arith.addf %out, %123 : f64 + linalg.yield %124 : f64 + } -> tensor + %extracted_slice_12 = tensor.extract_slice %15[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %57 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_12 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %58 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %59 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %60 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %61 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %62 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%59, %44, %60, %47, %61, %50, %58 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%57 : tensor) { + ^bb0(%in: f64, %in_27: f64, %in_28: f64, %in_29: f64, %in_30: f64, %in_31: f64, %in_32: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.mulf %in_28, %in_29 : f64 + %120 = arith.addf %118, %119 : f64 + %121 = arith.mulf %in_30, %in_31 : f64 + %122 = arith.addf %120, %121 : f64 + %123 = arith.mulf %122, %in_32 : f64 + %124 = arith.addf %out, %123 : f64 + linalg.yield %124 : f64 + } -> tensor + %extracted_slice_13 = tensor.extract_slice %14[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_13 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %64 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %65 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %66 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %67 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %68 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%65, %44, %66, %47, %67, %50, %64 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%63 : tensor) { + ^bb0(%in: f64, %in_27: f64, %in_28: f64, %in_29: f64, %in_30: f64, %in_31: f64, %in_32: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.mulf %in_28, %in_29 : f64 + %120 = arith.addf %118, %119 : f64 + %121 = arith.mulf %in_30, %in_31 : f64 + %122 = arith.addf %120, %121 : f64 + %123 = arith.mulf %122, %in_32 : f64 + %124 = arith.addf %out, %123 : f64 + linalg.yield %124 : f64 + } -> tensor + %extracted_slice_14 = tensor.extract_slice %13[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %70 = polygeist.submap(%5, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %71 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%56, %70, %extracted_slice_14) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_15 = tensor.extract_slice %12[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %73 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %74 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%62, %73, %extracted_slice_15) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_16 = tensor.extract_slice %11[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %76 = polygeist.submap(%5, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %77 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%68, %76, %extracted_slice_16) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_17 = tensor.extract_slice %10[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %79 = polygeist.submap(%5, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %80 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%71, %79, %extracted_slice_17) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_18 = tensor.extract_slice %9[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %82 = polygeist.submap(%5, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %83 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%74, %82, %extracted_slice_18) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_19 = tensor.extract_slice %8[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %85 = polygeist.submap(%4, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %86 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%77, %85, %extracted_slice_19) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %87 = polygeist.submap(%0, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %88 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%80, %83, %86 : tensor, tensor, tensor) outs(%87 : tensor) { + ^bb0(%in: f64, %in_27: f64, %in_28: f64, %out: f64): + %118 = arith.addf %in, %in_27 : f64 + %119 = arith.addf %118, %in_28 : f64 + %120 = arith.addf %out, %119 : f64 + linalg.yield %120 : f64 + } -> tensor + %89 = polygeist.submapInverse(%0, %88, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %90 = tensor.empty() : tensor<2x5x4x4xf64> + %91 = tensor.empty() : tensor<2x5x5x4xf64> + %92 = tensor.empty() : tensor<2x5x5x5xf64> + %93 = tensor.empty() : tensor<2x4x5x5xf64> + %94 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_20 = tensor.extract_slice %94[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %95 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_20 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_21 = tensor.insert_slice %95 into %94[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %96 = polygeist.submap(%7, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %97 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %inserted_slice_21_contract_98_tc2 = tensor.cast %inserted_slice_21 : tensor<2x4x4x5xf64> to tensor + + %v98_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%96, %97, %inserted_slice_21_contract_98_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %98 = tensor.cast %v98_tdyn : tensor to tensor<2x4x4x5xf64> + %extracted_slice_22 = tensor.extract_slice %93[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_23 = tensor.extract_slice %98[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %100 = polygeist.submap(%7, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %101 = kernel.launch @cutensornetContraction2_f64_r5r4r4(%100, %extracted_slice_23, %extracted_slice_22) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_24 = tensor.extract_slice %92[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %103 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %104 = kernel.launch @cutensornetContraction2_f64_r5r4r4(%103, %101, %extracted_slice_24) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %105 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map20} : (tensor, index, index, index, index) -> tensor + %106 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%105 : tensor) outs(%104 : tensor) { + ^bb0(%in: f64, %out: f64): + %118 = arith.mulf %out, %in : f64 + linalg.yield %118 : f64 + } -> tensor + %extracted_slice_25 = tensor.extract_slice %91[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %108 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %109 = kernel.launch @cutensornetContraction2_f64_r5r4r4(%108, %106, %extracted_slice_25) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_26 = tensor.extract_slice %90[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %111 = polygeist.submap(%5, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %112 = kernel.launch @cutensornetContraction2_f64_r5r4r4(%111, %109, %extracted_slice_26) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %113 = polygeist.submap(%5, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %114 = polygeist.submap(%89, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor<2x4x4x4xf64> + %115 = linalg.generic {doc = "", indexing_maps = [#map3, #map8, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%113, %112 : tensor, tensor) outs(%114 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_27: f64, %out: f64): + %118 = arith.mulf %in, %in_27 : f64 + %119 = arith.addf %out, %118 : f64 + linalg.yield %119 : f64 + } -> tensor<2x4x4x4xf64> + %116 = polygeist.submapInverse(%89, %115, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor<2x4x4x4xf64>, index, index, index, index) -> tensor + %117 = bufferization.to_memref %116 : memref + memref.copy %117, %arg7 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_h1_3d.raised.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_h1_3d.raised.mlir new file mode 100644 index 000000000000..c85d840c697b --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_h1_3d.raised.mlir @@ -0,0 +1,415 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 750)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 125)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 250)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 375)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 500)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 625)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 125 + d1 * 25 + d2 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_h1_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_14 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_15 = memref.alloca() : memref<2x4x4x5xf64> + %subview = memref.subview %alloca_15[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg6, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_15 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_16 = memref.subview %alloca_14[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_16 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg6, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%2, %3 : memref, memref) outs(%alloca_14 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_17 = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_17 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_18 = memref.subview %alloca_14[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %4 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_19 = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_18, %4 : memref>, memref) outs(%subview_19 : memref>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_20 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_20 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_21 = memref.subview %alloca_15[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %5 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_22 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_21, %5 : memref>, memref) outs(%subview_22 : memref>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_23 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_23 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_24 = memref.subview %alloca_15[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %6 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_25 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_24, %6 : memref>, memref) outs(%subview_25 : memref>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_26 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_26 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_27 = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %7 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_28 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_27, %7 : memref>, memref) outs(%subview_28 : memref>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_29 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_29 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_30 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %8 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_31 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_30, %8 : memref>, memref) outs(%subview_31 : memref>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_32 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_32 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_33 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %9 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_34 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_33, %9 : memref>, memref) outs(%subview_34 : memref>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_35 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_35 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %10 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (memref, index, index, index, index, index) -> memref + %subview_36 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %11 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_37 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %12 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (memref, index, index, index, index, index) -> memref + %subview_38 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %13 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_39 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%10, %subview_36, %11, %subview_37, %12, %subview_38, %13 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_39 : memref>) { + ^bb0(%in: f64, %in_91: f64, %in_92: f64, %in_93: f64, %in_94: f64, %in_95: f64, %in_96: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.mulf %in_92, %in_93 : f64 + %40 = arith.addf %38, %39 : f64 + %41 = arith.mulf %in_94, %in_95 : f64 + %42 = arith.addf %40, %41 : f64 + %43 = arith.mulf %42, %in_96 : f64 + %44 = arith.addf %out, %43 : f64 + linalg.yield %44 : f64 + } + %subview_40 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_40 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_41 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %15 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %subview_42 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %16 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_43 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %17 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_44 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%14, %subview_41, %15, %subview_42, %16, %subview_43, %17 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_44 : memref>) { + ^bb0(%in: f64, %in_91: f64, %in_92: f64, %in_93: f64, %in_94: f64, %in_95: f64, %in_96: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.mulf %in_92, %in_93 : f64 + %40 = arith.addf %38, %39 : f64 + %41 = arith.mulf %in_94, %in_95 : f64 + %42 = arith.addf %40, %41 : f64 + %43 = arith.mulf %42, %in_96 : f64 + %44 = arith.addf %out, %43 : f64 + linalg.yield %44 : f64 + } + %subview_45 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_45 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %18 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (memref, index, index, index, index, index) -> memref + %subview_46 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %19 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_47 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %20 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %subview_48 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %21 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_49 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%18, %subview_46, %19, %subview_47, %20, %subview_48, %21 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_49 : memref>) { + ^bb0(%in: f64, %in_91: f64, %in_92: f64, %in_93: f64, %in_94: f64, %in_95: f64, %in_96: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.mulf %in_92, %in_93 : f64 + %40 = arith.addf %38, %39 : f64 + %41 = arith.mulf %in_94, %in_95 : f64 + %42 = arith.addf %40, %41 : f64 + %43 = arith.mulf %42, %in_96 : f64 + %44 = arith.addf %out, %43 : f64 + linalg.yield %44 : f64 + } + %subview_50 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_50 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_51 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %22 = polygeist.submap(%arg2, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_52 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_51, %22 : memref>, memref) outs(%subview_52 : memref>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_53 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_53 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_54 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %23 = polygeist.submap(%arg3, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_55 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_54, %23 : memref>, memref) outs(%subview_55 : memref>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_56 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_56 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_57 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %24 = polygeist.submap(%arg2, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_58 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_57, %24 : memref>, memref) outs(%subview_58 : memref>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_59 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_59 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_60 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %25 = polygeist.submap(%arg2, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %subview_61 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_60, %25 : memref>, memref) outs(%subview_61 : memref>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_62 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_62 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_63 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %26 = polygeist.submap(%arg2, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %subview_64 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_63, %26 : memref>, memref) outs(%subview_64 : memref>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_65 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_65 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_66 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %27 = polygeist.submap(%arg3, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %subview_67 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_66, %27 : memref>, memref) outs(%subview_67 : memref>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_68 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_69 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_70 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %28 = polygeist.submap(%arg7, %c2, %c4, %c4, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_68, %subview_69, %subview_70 : memref>, memref>, memref>) outs(%28 : memref) { + ^bb0(%in: f64, %in_91: f64, %in_92: f64, %out: f64): + %38 = arith.addf %in, %in_91 : f64 + %39 = arith.addf %38, %in_92 : f64 + %40 = arith.addf %out, %39 : f64 + linalg.yield %40 : f64 + } + %alloca_71 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_72 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_73 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_74 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_75 = memref.alloca() : memref<2x4x4x5xf64> + %subview_76 = memref.subview %alloca_75[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_76 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %29 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + %30 = polygeist.submap(%arg6, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%29, %30 : memref, memref) outs(%alloca_75 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_77 = memref.subview %alloca_74[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_77 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %31 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_78 = memref.subview %alloca_75[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %subview_79 = memref.subview %alloca_74[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%31, %subview_78 : memref, memref>) outs(%subview_79 : memref>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_80 = memref.subview %alloca_73[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_80 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %32 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_81 = memref.subview %alloca_74[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %subview_82 = memref.subview %alloca_73[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map8, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%32, %subview_81 : memref, memref>) outs(%subview_82 : memref>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %33 = polygeist.submap(%arg5, %c2, %c5, %c5, %c5) {map = #map20} : (memref, index, index, index, index) -> memref + %subview_83 = memref.subview %alloca_73[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%33 : memref) outs(%subview_83 : memref>) { + ^bb0(%in: f64, %out: f64): + %38 = arith.mulf %out, %in : f64 + linalg.yield %38 : f64 + } + %subview_84 = memref.subview %alloca_72[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_84 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %34 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_85 = memref.subview %alloca_73[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_86 = memref.subview %alloca_72[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map13, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%34, %subview_85 : memref, memref>) outs(%subview_86 : memref>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %subview_87 = memref.subview %alloca_71[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_87 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %35 = polygeist.submap(%arg2, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_88 = memref.subview %alloca_72[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %subview_89 = memref.subview %alloca_71[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%35, %subview_88 : memref, memref>) outs(%subview_89 : memref>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + %36 = polygeist.submap(%arg2, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %subview_90 = memref.subview %alloca_71[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %37 = polygeist.submap(%arg7, %c2, %c4, %c4, %c4) {map = #map19} : (memref, index, index, index, index) -> memref<2x4x4x4xf64> + linalg.generic {indexing_maps = [#map3, #map8, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%36, %subview_90 : memref, memref>) outs(%37 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_91: f64, %out: f64): + %38 = arith.mulf %in, %in_91 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d.debufferized.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d.debufferized.mlir new file mode 100644 index 000000000000..386b572eadaf --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d.debufferized.mlir @@ -0,0 +1,751 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 144)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 125)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 375)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 500)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 250)> +#map22 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 625)> +#map23 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 144)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map26 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map27 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 3)> +#map28 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 4)> +#map29 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 4)> +#map30 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 3 + d0 * 144)> +#map31 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map32 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +#map33 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 3)> +#map34 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 4)> +#map35 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 4 + d0 * 144 + 48)> +#map36 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 3)> +#map37 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 16 + d5 * 4 + d0 * 144 + 96)> +#map38 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750)> +#map39 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 125)> +#map40 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 250)> +#map41 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 375)> +#map42 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 500)> +#map43 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 625)> +#map44 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 5)> +#map45 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 5)> +#map46 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 5)> +#map47 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_hcurl_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg9 : memref + %1 = bufferization.to_tensor %arg8 : memref + %2 = bufferization.to_tensor %arg7 : memref + %3 = bufferization.to_tensor %arg6 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg3 : memref + %7 = bufferization.to_tensor %arg2 : memref + %8 = bufferization.to_tensor %arg1 : memref + %9 = bufferization.to_tensor %arg0 : memref + %10 = tensor.empty() : tensor<2x4x4x4xf64> + %11 = tensor.empty() : tensor<2x4x4x4xf64> + %12 = tensor.empty() : tensor<2x4x4x4xf64> + %13 = tensor.empty() : tensor<2x4x4x4xf64> + %14 = tensor.empty() : tensor<2x4x4x4xf64> + %15 = tensor.empty() : tensor<2x4x4x4xf64> + %16 = tensor.empty() : tensor<2x5x4x4xf64> + %17 = tensor.empty() : tensor<2x5x4x4xf64> + %18 = tensor.empty() : tensor<2x5x4x4xf64> + %19 = tensor.empty() : tensor<2x5x4x4xf64> + %20 = tensor.empty() : tensor<2x5x4x4xf64> + %21 = tensor.empty() : tensor<2x5x4x4xf64> + %22 = tensor.empty() : tensor<2x5x5x4xf64> + %23 = tensor.empty() : tensor<2x5x5x4xf64> + %24 = tensor.empty() : tensor<2x5x5x4xf64> + %25 = tensor.empty() : tensor<2x5x5x4xf64> + %26 = tensor.empty() : tensor<2x5x5x4xf64> + %27 = tensor.empty() : tensor<2x5x5x4xf64> + %28 = tensor.empty() : tensor<2x5x5x5xf64> + %29 = tensor.empty() : tensor<2x5x5x5xf64> + %30 = tensor.empty() : tensor<2x5x5x5xf64> + %31 = tensor.empty() : tensor<2x5x5x5xf64> + %32 = tensor.empty() : tensor<2x5x5x5xf64> + %33 = tensor.empty() : tensor<2x5x5x5xf64> + %34 = tensor.empty() : tensor<2x4x5x5xf64> + %35 = tensor.empty() : tensor<2x4x5x5xf64> + %36 = tensor.empty() : tensor<2x4x5x5xf64> + %37 = tensor.empty() : tensor<2x4x5x5xf64> + %38 = tensor.empty() : tensor<2x4x5x5xf64> + %39 = tensor.empty() : tensor<2x4x5x5xf64> + %40 = tensor.empty() : tensor<2x4x4x5xf64> + %41 = tensor.empty() : tensor<2x4x4x5xf64> + %42 = tensor.empty() : tensor<2x4x4x5xf64> + %43 = tensor.empty() : tensor<2x4x4x5xf64> + %44 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice = tensor.extract_slice %44[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %45 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %45 into %44[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %46 = polygeist.submap(%9, %c2, %c4, %c4, %c5, %c3) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %47 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c3) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %48 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%47, %46 : tensor, tensor) outs(%inserted_slice : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_0 = tensor.extract_slice %39[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %49 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_0 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_1 = tensor.extract_slice %48[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %50 = polygeist.submap(%5, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %51 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_1, %50 : tensor, tensor) outs(%49 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_2 = tensor.extract_slice %38[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %52 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_2 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_3 = tensor.extract_slice %48[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %53 = polygeist.submap(%8, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %54 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_3, %53 : tensor, tensor) outs(%52 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_4 = tensor.extract_slice %33[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_4 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %56 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %57 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%51, %56 : tensor, tensor) outs(%55 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_5 = tensor.extract_slice %32[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %58 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_5 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %59 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %60 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%54, %59 : tensor, tensor) outs(%58 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_6 = tensor.extract_slice %43[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %61 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_6 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %62 = polygeist.submap(%5, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %63 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %64 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%63, %62 : tensor, tensor) outs(%61 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_7 = tensor.extract_slice %42[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %65 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_7 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %66 = polygeist.submap(%8, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %67 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %68 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%67, %66 : tensor, tensor) outs(%65 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_8 = tensor.extract_slice %37[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %69 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_8 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %70 = polygeist.submap(%9, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %71 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%64, %70 : tensor, tensor) outs(%69 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_9 = tensor.extract_slice %36[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %72 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_9 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %73 = polygeist.submap(%9, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %74 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%68, %73 : tensor, tensor) outs(%72 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_10 = tensor.extract_slice %31[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %75 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_10 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %76 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %77 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%71, %76 : tensor, tensor) outs(%75 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_11 = tensor.extract_slice %30[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %78 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_11 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %79 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %80 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%74, %79 : tensor, tensor) outs(%78 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_12 = tensor.extract_slice %41[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %81 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_12 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %82 = polygeist.submap(%5, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %83 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %84 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%83, %82 : tensor, tensor) outs(%81 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_13 = tensor.extract_slice %40[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %85 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_13 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %86 = polygeist.submap(%8, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %87 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %88 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%87, %86 : tensor, tensor) outs(%85 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_14 = tensor.extract_slice %35[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %89 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_14 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %90 = polygeist.submap(%8, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %91 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%84, %90 : tensor, tensor) outs(%89 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_15 = tensor.extract_slice %34[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %92 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_15 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %93 = polygeist.submap(%5, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %94 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%88, %93 : tensor, tensor) outs(%92 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_16 = tensor.extract_slice %29[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %95 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_16 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %96 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %97 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%91, %96 : tensor, tensor) outs(%95 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_17 = tensor.extract_slice %28[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %98 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_17 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %99 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %100 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%94, %99 : tensor, tensor) outs(%98 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_18 = tensor.extract_slice %27[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %101 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_18 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %102 = polygeist.submap(%7, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %103 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %104 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %105 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %106 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%103, %100, %80, %104, %60, %97, %105, %77, %57, %102 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%101 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_19 = tensor.extract_slice %21[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %107 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_19 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %108 = polygeist.submap(%6, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %109 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%106, %108 : tensor, tensor) outs(%107 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_20 = tensor.extract_slice %15[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %110 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_20 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %111 = polygeist.submap(%4, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %112 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%109, %111 : tensor, tensor) outs(%110 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_21 = tensor.extract_slice %26[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %113 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_21 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %114 = polygeist.submap(%7, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %115 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %116 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %117 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %118 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%115, %100, %80, %116, %60, %97, %117, %77, %57, %114 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%113 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_22 = tensor.extract_slice %20[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %119 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_22 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %120 = polygeist.submap(%4, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %121 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%118, %120 : tensor, tensor) outs(%119 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_23 = tensor.extract_slice %14[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %122 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_23 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %123 = polygeist.submap(%6, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %124 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%121, %123 : tensor, tensor) outs(%122 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_24 = tensor.extract_slice %25[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %125 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_24 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %126 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %127 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %128 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %129 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %130 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%127, %100, %80, %128, %60, %97, %129, %77, %57, %126 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%125 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_25 = tensor.extract_slice %19[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %131 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_25 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %132 = polygeist.submap(%7, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %133 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%130, %132 : tensor, tensor) outs(%131 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_26 = tensor.extract_slice %13[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %134 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_26 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %135 = polygeist.submap(%6, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %136 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%133, %135 : tensor, tensor) outs(%134 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_27 = tensor.extract_slice %24[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %137 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_27 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %138 = polygeist.submap(%6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %139 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %140 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %141 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %142 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%139, %100, %80, %140, %60, %97, %141, %77, %57, %138 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%137 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_28 = tensor.extract_slice %18[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %143 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_28 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %144 = polygeist.submap(%7, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %145 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%142, %144 : tensor, tensor) outs(%143 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_29 = tensor.extract_slice %12[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %146 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_29 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %147 = polygeist.submap(%4, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %148 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%145, %147 : tensor, tensor) outs(%146 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_30 = tensor.extract_slice %23[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %149 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_30 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %150 = polygeist.submap(%6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %151 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %152 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %153 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %154 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%151, %100, %80, %152, %60, %97, %153, %77, %57, %150 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%149 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_31 = tensor.extract_slice %17[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %155 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_31 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %156 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %157 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%154, %156 : tensor, tensor) outs(%155 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_32 = tensor.extract_slice %11[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %158 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_32 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %159 = polygeist.submap(%7, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %160 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%157, %159 : tensor, tensor) outs(%158 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_33 = tensor.extract_slice %22[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %161 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_33 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %162 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %163 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %164 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %165 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %166 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%163, %100, %80, %164, %60, %97, %165, %77, %57, %162 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%161 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_34 = tensor.extract_slice %16[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %167 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_34 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %168 = polygeist.submap(%6, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %169 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%166, %168 : tensor, tensor) outs(%167 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %extracted_slice_35 = tensor.extract_slice %10[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %170 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_35 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %171 = polygeist.submap(%7, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %172 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%169, %171 : tensor, tensor) outs(%170 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.mulf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %173 = polygeist.submap(%0, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, index, index, index, index) -> tensor + %174 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%112, %124 : tensor, tensor) outs(%173 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.subf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %175 = polygeist.submapInverse(%0, %174, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, tensor, index, index, index, index) -> tensor + %176 = polygeist.submap(%175, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, index, index, index, index) -> tensor + %177 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%136, %148 : tensor, tensor) outs(%176 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.subf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %178 = polygeist.submapInverse(%175, %177, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, tensor, index, index, index, index) -> tensor + %179 = polygeist.submap(%178, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, index, index, index, index) -> tensor + %180 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%160, %172 : tensor, tensor) outs(%179 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.subf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %181 = polygeist.submapInverse(%178, %180, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, tensor, index, index, index, index) -> tensor + %182 = tensor.empty() : tensor<2x3x5x5x5xf64> + %extracted_slice_36 = tensor.extract_slice %182[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %183 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_36 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %184 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map27} : (tensor, index, index, index, index, index, index, index) -> tensor + %185 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map28} : (tensor, index, index, index, index, index, index, index) -> tensor + %186 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map29} : (tensor, index, index, index, index, index, index, index) -> tensor + %187 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map30} : (tensor, index, index, index, index, index, index, index) -> tensor + %188 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%185, %186, %187, %184 : tensor, tensor, tensor, tensor) outs(%183 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %inserted_slice_37 = tensor.insert_slice %188 into %182[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_38 = tensor.extract_slice %inserted_slice_37[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %189 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_38 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %190 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map33} : (tensor, index, index, index, index, index, index, index) -> tensor + %191 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map28} : (tensor, index, index, index, index, index, index, index) -> tensor + %192 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map34} : (tensor, index, index, index, index, index, index, index) -> tensor + %193 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map35} : (tensor, index, index, index, index, index, index, index) -> tensor + %194 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%191, %190, %193, %192 : tensor, tensor, tensor, tensor) outs(%189 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %inserted_slice_39 = tensor.insert_slice %194 into %inserted_slice_37[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_40 = tensor.extract_slice %inserted_slice_39[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %195 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_40 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %196 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map36} : (tensor, index, index, index, index, index, index, index) -> tensor + %197 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map29} : (tensor, index, index, index, index, index, index, index) -> tensor + %198 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map34} : (tensor, index, index, index, index, index, index, index) -> tensor + %199 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map37} : (tensor, index, index, index, index, index, index, index) -> tensor + %200 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%196, %197, %199, %198 : tensor, tensor, tensor, tensor) outs(%195 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %inserted_slice_41 = tensor.insert_slice %200 into %inserted_slice_39[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_42 = tensor.extract_slice %inserted_slice_41[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %extracted_slice_43 = tensor.extract_slice %inserted_slice_41[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %201 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map38} : (tensor, index, index, index, index) -> tensor + %202 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index) -> tensor + %203 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index) -> tensor + %204 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index) -> tensor + %205 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map41} : (tensor, index, index, index, index) -> tensor + %206 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map42} : (tensor, index, index, index, index) -> tensor + %207 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index) -> tensor + %208 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map42} : (tensor, index, index, index, index) -> tensor + %209 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map43} : (tensor, index, index, index, index) -> tensor + %210:3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%201, %202, %203, %204, %205, %206, %207, %208, %209 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_42, %extracted_slice_43, %200 : tensor, tensor, tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %out: f64, %out_55: f64, %out_56: f64): + %230 = arith.mulf %in, %out : f64 + %231 = arith.mulf %in_47, %out_55 : f64 + %232 = arith.addf %230, %231 : f64 + %233 = arith.mulf %in_48, %out_56 : f64 + %234 = arith.addf %232, %233 : f64 + %235 = arith.mulf %in_49, %out : f64 + %236 = arith.mulf %in_50, %out_55 : f64 + %237 = arith.addf %235, %236 : f64 + %238 = arith.mulf %in_51, %out_56 : f64 + %239 = arith.addf %237, %238 : f64 + %240 = arith.mulf %in_52, %out : f64 + %241 = arith.mulf %in_53, %out_55 : f64 + %242 = arith.addf %240, %241 : f64 + %243 = arith.mulf %in_54, %out_56 : f64 + %244 = arith.addf %242, %243 : f64 + linalg.yield %234, %239, %244 : f64, f64, f64 + } -> (tensor, tensor, tensor) + %inserted_slice_44 = tensor.insert_slice %210#2 into %inserted_slice_39[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_45 = tensor.extract_slice %inserted_slice_44[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %211 = polygeist.submap(%7, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map44} : (tensor, index, index, index, index, index, index, index) -> tensor + %212 = polygeist.submap(%6, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map45} : (tensor, index, index, index, index, index, index, index) -> tensor + %213 = polygeist.submap(%6, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map46} : (tensor, index, index, index, index, index, index, index) -> tensor + %214 = polygeist.submap(%181, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, index, index, index, index) -> tensor + %215 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%212, %213, %extracted_slice_45, %211 : tensor, tensor, tensor, tensor) outs(%214 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %216 = polygeist.submapInverse(%181, %215, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, tensor, index, index, index, index) -> tensor + %extracted_slice_46 = tensor.extract_slice %inserted_slice_44[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %217 = polygeist.submap(%7, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map46} : (tensor, index, index, index, index, index, index, index) -> tensor + %218 = polygeist.submap(%6, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map45} : (tensor, index, index, index, index, index, index, index) -> tensor + %219 = polygeist.submap(%6, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map44} : (tensor, index, index, index, index, index, index, index) -> tensor + %220 = polygeist.submap(%216, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, index, index, index, index) -> tensor + %221 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%218, %217, %extracted_slice_46, %219 : tensor, tensor, tensor, tensor) outs(%220 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %222 = polygeist.submapInverse(%216, %221, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, tensor, index, index, index, index) -> tensor + %223 = polygeist.submap(%7, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map45} : (tensor, index, index, index, index, index, index, index) -> tensor + %224 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map46} : (tensor, index, index, index, index, index, index, index) -> tensor + %225 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map44} : (tensor, index, index, index, index, index, index, index) -> tensor + %226 = polygeist.submap(%222, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, index, index, index, index) -> tensor + %227 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%223, %224, %210#2, %225 : tensor, tensor, tensor, tensor) outs(%226 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %228 = polygeist.submapInverse(%222, %227, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, tensor, index, index, index, index) -> tensor + %229 = bufferization.to_memref %228 : memref + memref.copy %229, %arg9 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d.frontend.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d.frontend.mlir new file mode 100644 index 000000000000..7864b173598c --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d.frontend.mlir @@ -0,0 +1,1882 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_hcurl_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_13 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_14 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_15 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_16 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_21 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_22 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_23 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_24 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_25 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_26 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_27 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_28 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_29 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_30 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_31 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_32 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_33 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg8[%arg11 * 12 + %arg14 + %arg12 * 3 + %arg10 * 144] : memref + %2 = affine.load %arg0[%arg14 + %arg13 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_33[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg14 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_28[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg14 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_27[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_28[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg14 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_22[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_27[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg14 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_21[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg8[%arg11 * 12 + %arg14 + %arg12 * 4 + %arg10 * 144 + 48] : memref + %2 = affine.load %arg4[%arg14 + %arg13 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_32[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg8[%arg11 * 12 + %arg14 + %arg12 * 4 + %arg10 * 144 + 48] : memref + %2 = affine.load %arg1[%arg14 + %arg13 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_31[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_32[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg14 + %arg12 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_26[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_31[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg14 + %arg12 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_25[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_26[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg14 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_20[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_25[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg14 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_19[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg8[%arg11 * 16 + %arg14 + %arg12 * 4 + %arg10 * 144 + 96] : memref + %2 = affine.load %arg4[%arg14 + %arg13 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_30[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg8[%arg11 * 16 + %arg14 + %arg12 * 4 + %arg10 * 144 + 96] : memref + %2 = affine.load %arg1[%arg14 + %arg13 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_29[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_30[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg14 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_24[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_29[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg14 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_23[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_24[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg14 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_18[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_23[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg14 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_17[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg14 + %arg13 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg15, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_16[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_16[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg14 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg14 + %arg13 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg15, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_15[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg14 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg14 + %arg13 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg15, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_14[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg14 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5] : memref + %2 = affine.load %alloca_17[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg14 + %arg13 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg15, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_13[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg14 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5] : memref + %2 = affine.load %alloca_17[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg14 + %arg13 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg15, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_12[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg14 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg10 * 750 + %arg14 + %arg11 * 25 + %arg12 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg14 + %arg13 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg15, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_11[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg14 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.load %alloca_4[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_3[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg9[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg10 * 144] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg9[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg10 * 144] : memref + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.load %alloca_2[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_1[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg9[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg10 * 144 + 48] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg9[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg10 * 144 + 48] : memref + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 4 { + %0 = affine.load %alloca_0[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + %1 = affine.load %alloca[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg9[%arg11 * 16 + %arg13 + %arg12 * 4 + %arg10 * 144 + 96] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg9[%arg11 * 16 + %arg13 + %arg12 * 4 + %arg10 * 144 + 96] : memref + } + } + } + } + %alloca_34 = memref.alloca() : memref<2x3x5x5x5xf64> + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg14 + %arg11 * 4] : memref + %2 = affine.for %arg16 = 0 to 4 iter_args(%arg17 = %arg15) -> (f64) { + %3 = affine.load %arg1[%arg16 + %arg12 * 4] : memref + %4 = affine.for %arg18 = 0 to 3 iter_args(%arg19 = %arg17) -> (f64) { + %5 = affine.load %arg8[%arg14 * 12 + %arg18 + %arg16 * 3 + %arg10 * 144] : memref + %6 = affine.load %arg0[%arg18 + %arg13 * 3] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg19, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca_34[%arg10, 0, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg14 + %arg11 * 4] : memref + %2 = affine.for %arg16 = 0 to 3 iter_args(%arg17 = %arg15) -> (f64) { + %3 = affine.load %arg0[%arg16 + %arg12 * 3] : memref + %4 = affine.for %arg18 = 0 to 4 iter_args(%arg19 = %arg17) -> (f64) { + %5 = affine.load %arg8[%arg14 * 12 + %arg18 + %arg16 * 4 + %arg10 * 144 + 48] : memref + %6 = affine.load %arg1[%arg18 + %arg13 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg19, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca_34[%arg10, 1, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg14 + %arg11 * 3] : memref + %2 = affine.for %arg16 = 0 to 4 iter_args(%arg17 = %arg15) -> (f64) { + %3 = affine.load %arg1[%arg16 + %arg12 * 4] : memref + %4 = affine.for %arg18 = 0 to 4 iter_args(%arg19 = %arg17) -> (f64) { + %5 = affine.load %arg8[%arg14 * 16 + %arg18 + %arg16 * 4 + %arg10 * 144 + 96] : memref + %6 = affine.load %arg1[%arg18 + %arg13 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg19, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca_34[%arg10, 2, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.load %alloca_34[%arg10, 0, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %1 = affine.load %alloca_34[%arg10, 1, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %2 = affine.load %alloca_34[%arg10, 2, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %3 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750] : memref + %4 = arith.mulf %3, %0 : f64 + %5 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 125] : memref + %6 = arith.mulf %5, %1 : f64 + %7 = arith.addf %4, %6 : f64 + %8 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 250] : memref + %9 = arith.mulf %8, %2 : f64 + %10 = arith.addf %7, %9 : f64 + affine.store %10, %alloca_34[%arg10, 0, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %11 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 125] : memref + %12 = arith.mulf %11, %0 : f64 + %13 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 375] : memref + %14 = arith.mulf %13, %1 : f64 + %15 = arith.addf %12, %14 : f64 + %16 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 500] : memref + %17 = arith.mulf %16, %2 : f64 + %18 = arith.addf %15, %17 : f64 + affine.store %18, %alloca_34[%arg10, 1, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %19 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 250] : memref + %20 = arith.mulf %19, %0 : f64 + %21 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 500] : memref + %22 = arith.mulf %21, %1 : f64 + %23 = arith.addf %20, %22 : f64 + %24 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 625] : memref + %25 = arith.mulf %24, %2 : f64 + %26 = arith.addf %23, %25 : f64 + affine.store %26, %alloca_34[%arg10, 2, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %arg3[%arg14 + %arg11 * 5] : memref + %4 = affine.for %arg16 = 0 to 5 iter_args(%arg17 = %arg15) -> (f64) { + %5 = affine.load %arg3[%arg16 + %arg12 * 5] : memref + %6 = affine.for %arg18 = 0 to 5 iter_args(%arg19 = %arg17) -> (f64) { + %7 = affine.load %alloca_34[%arg10, 0, %arg14, %arg16, %arg18] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg2[%arg18 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg19, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg9[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg10 * 144] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg10 * 144] : memref + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %arg3[%arg14 + %arg11 * 5] : memref + %4 = affine.for %arg16 = 0 to 5 iter_args(%arg17 = %arg15) -> (f64) { + %5 = affine.load %arg2[%arg16 + %arg12 * 5] : memref + %6 = affine.for %arg18 = 0 to 5 iter_args(%arg19 = %arg17) -> (f64) { + %7 = affine.load %alloca_34[%arg10, 1, %arg14, %arg16, %arg18] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg3[%arg18 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg19, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg9[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg10 * 144 + 48] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg10 * 144 + 48] : memref + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %arg2[%arg14 + %arg11 * 5] : memref + %4 = affine.for %arg16 = 0 to 5 iter_args(%arg17 = %arg15) -> (f64) { + %5 = affine.load %arg3[%arg16 + %arg12 * 5] : memref + %6 = affine.for %arg18 = 0 to 5 iter_args(%arg19 = %arg17) -> (f64) { + %7 = affine.load %alloca_34[%arg10, 2, %arg14, %arg16, %arg18] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg3[%arg18 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg19, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg9[%arg11 * 16 + %arg13 + %arg12 * 4 + %arg10 * 144 + 96] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 16 + %arg13 + %arg12 * 4 + %arg10 * 144 + 96] : memref + } + } + } + } + return + } + func.func @mfem_pa_curlcurl_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_13 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_14 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_15 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_16 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_21 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_22 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_23 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_24 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_25 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_26 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_27 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_28 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_29 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_30 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_31 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_32 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_33 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 3 + %arg9 * 144] : memref + %2 = affine.load %arg0[%arg13 + %arg12 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_33[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_28[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_27[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_28[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_22[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_27[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_21[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %2 = affine.load %arg4[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_32[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %2 = affine.load %arg1[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_31[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_32[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg13 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_26[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_31[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg13 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_25[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_26[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_20[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_25[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_19[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 16 + %arg13 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %2 = affine.load %arg4[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_30[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 16 + %arg13 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %2 = affine.load %arg1[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_29[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_30[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_24[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_29[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_23[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_24[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg13 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_18[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_23[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg13 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_17[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_16[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_16[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_15[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_14[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_13[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_12[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_11[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.load %alloca_4[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_3[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 12 + %arg12 + %arg11 * 3 + %arg9 * 144] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 12 + %arg12 + %arg11 * 3 + %arg9 * 144] : memref + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.load %alloca_2[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_1[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 12 + %arg12 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 12 + %arg12 + %arg11 * 4 + %arg9 * 144 + 48] : memref + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.load %alloca_0[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 16 + %arg12 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 16 + %arg12 + %arg11 * 4 + %arg9 * 144 + 96] : memref + } + } + } + } + return + } + func.func @mfem_pa_hcurl_mass_apply_3d_direct(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x3x5x5x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg11 + %arg8 * 4] : memref + %2 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %arg12) -> (f64) { + %3 = affine.load %arg1[%arg13 + %arg9 * 4] : memref + %4 = affine.for %arg15 = 0 to 3 iter_args(%arg16 = %arg14) -> (f64) { + %5 = affine.load %arg5[%arg11 * 12 + %arg15 + %arg13 * 3 + %arg7 * 144] : memref + %6 = affine.load %arg0[%arg15 + %arg10 * 3] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg16, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca[%arg7, 0, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg11 + %arg8 * 4] : memref + %2 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %arg12) -> (f64) { + %3 = affine.load %arg0[%arg13 + %arg9 * 3] : memref + %4 = affine.for %arg15 = 0 to 4 iter_args(%arg16 = %arg14) -> (f64) { + %5 = affine.load %arg5[%arg11 * 12 + %arg15 + %arg13 * 4 + %arg7 * 144 + 48] : memref + %6 = affine.load %arg1[%arg15 + %arg10 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg16, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca[%arg7, 1, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %2 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %arg12) -> (f64) { + %3 = affine.load %arg1[%arg13 + %arg9 * 4] : memref + %4 = affine.for %arg15 = 0 to 4 iter_args(%arg16 = %arg14) -> (f64) { + %5 = affine.load %arg5[%arg11 * 16 + %arg15 + %arg13 * 4 + %arg7 * 144 + 96] : memref + %6 = affine.load %arg1[%arg15 + %arg10 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg16, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca[%arg7, 2, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.load %alloca[%arg7, 0, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %1 = affine.load %alloca[%arg7, 1, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %2 = affine.load %alloca[%arg7, 2, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %3 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750] : memref + %4 = arith.mulf %3, %0 : f64 + %5 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 125] : memref + %6 = arith.mulf %5, %1 : f64 + %7 = arith.addf %4, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 250] : memref + %9 = arith.mulf %8, %2 : f64 + %10 = arith.addf %7, %9 : f64 + affine.store %10, %alloca[%arg7, 0, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %11 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 125] : memref + %12 = arith.mulf %11, %0 : f64 + %13 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 375] : memref + %14 = arith.mulf %13, %1 : f64 + %15 = arith.addf %12, %14 : f64 + %16 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 500] : memref + %17 = arith.mulf %16, %2 : f64 + %18 = arith.addf %15, %17 : f64 + affine.store %18, %alloca[%arg7, 1, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %19 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 250] : memref + %20 = arith.mulf %19, %0 : f64 + %21 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 500] : memref + %22 = arith.mulf %21, %1 : f64 + %23 = arith.addf %20, %22 : f64 + %24 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 625] : memref + %25 = arith.mulf %24, %2 : f64 + %26 = arith.addf %23, %25 : f64 + affine.store %26, %alloca[%arg7, 2, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %4 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %arg12) -> (f64) { + %5 = affine.load %arg3[%arg13 + %arg9 * 5] : memref + %6 = affine.for %arg15 = 0 to 5 iter_args(%arg16 = %arg14) -> (f64) { + %7 = affine.load %alloca[%arg7, 0, %arg11, %arg13, %arg15] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg2[%arg15 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg16, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 144] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 144] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %4 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %arg12) -> (f64) { + %5 = affine.load %arg2[%arg13 + %arg9 * 5] : memref + %6 = affine.for %arg15 = 0 to 5 iter_args(%arg16 = %arg14) -> (f64) { + %7 = affine.load %alloca[%arg7, 1, %arg11, %arg13, %arg15] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg3[%arg15 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg16, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 144 + 48] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 144 + 48] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %4 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %arg12) -> (f64) { + %5 = affine.load %arg3[%arg13 + %arg9 * 5] : memref + %6 = affine.for %arg15 = 0 to 5 iter_args(%arg16 = %arg14) -> (f64) { + %7 = affine.load %alloca[%arg7, 2, %arg11, %arg13, %arg15] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg3[%arg15 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg16, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg6[%arg8 * 16 + %arg10 + %arg9 * 4 + %arg7 * 144 + 96] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 16 + %arg10 + %arg9 * 4 + %arg7 * 144 + 96] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d.matched.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d.matched.mlir new file mode 100644 index 000000000000..eb6de74bd42c --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d.matched.mlir @@ -0,0 +1,498 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 144)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 125)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 375)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 500)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 250)> +#map22 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 625)> +#map23 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 144)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map26 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map27 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 3)> +#map28 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 4)> +#map29 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 4)> +#map30 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 3 + d0 * 144)> +#map31 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map32 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +#map33 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 3)> +#map34 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 4)> +#map35 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 4 + d0 * 144 + 48)> +#map36 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 3)> +#map37 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 16 + d5 * 4 + d0 * 144 + 96)> +#map38 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750)> +#map39 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 125)> +#map40 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 250)> +#map41 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 375)> +#map42 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 500)> +#map43 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 625)> +#map44 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 5)> +#map45 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 5)> +#map46 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 5)> +#map47 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_hcurl_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg9 : memref + %1 = bufferization.to_tensor %arg8 : memref + %2 = bufferization.to_tensor %arg7 : memref + %3 = bufferization.to_tensor %arg6 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg3 : memref + %7 = bufferization.to_tensor %arg2 : memref + %8 = bufferization.to_tensor %arg1 : memref + %9 = bufferization.to_tensor %arg0 : memref + %10 = tensor.empty() : tensor<2x4x4x4xf64> + %11 = tensor.empty() : tensor<2x4x4x4xf64> + %12 = tensor.empty() : tensor<2x4x4x4xf64> + %13 = tensor.empty() : tensor<2x4x4x4xf64> + %14 = tensor.empty() : tensor<2x4x4x4xf64> + %15 = tensor.empty() : tensor<2x4x4x4xf64> + %16 = tensor.empty() : tensor<2x5x4x4xf64> + %17 = tensor.empty() : tensor<2x5x4x4xf64> + %18 = tensor.empty() : tensor<2x5x4x4xf64> + %19 = tensor.empty() : tensor<2x5x4x4xf64> + %20 = tensor.empty() : tensor<2x5x4x4xf64> + %21 = tensor.empty() : tensor<2x5x4x4xf64> + %22 = tensor.empty() : tensor<2x5x5x4xf64> + %23 = tensor.empty() : tensor<2x5x5x4xf64> + %24 = tensor.empty() : tensor<2x5x5x4xf64> + %25 = tensor.empty() : tensor<2x5x5x4xf64> + %26 = tensor.empty() : tensor<2x5x5x4xf64> + %27 = tensor.empty() : tensor<2x5x5x4xf64> + %28 = tensor.empty() : tensor<2x5x5x5xf64> + %29 = tensor.empty() : tensor<2x5x5x5xf64> + %30 = tensor.empty() : tensor<2x5x5x5xf64> + %31 = tensor.empty() : tensor<2x5x5x5xf64> + %32 = tensor.empty() : tensor<2x5x5x5xf64> + %33 = tensor.empty() : tensor<2x5x5x5xf64> + %34 = tensor.empty() : tensor<2x4x5x5xf64> + %35 = tensor.empty() : tensor<2x4x5x5xf64> + %36 = tensor.empty() : tensor<2x4x5x5xf64> + %37 = tensor.empty() : tensor<2x4x5x5xf64> + %38 = tensor.empty() : tensor<2x4x5x5xf64> + %39 = tensor.empty() : tensor<2x4x5x5xf64> + %40 = tensor.empty() : tensor<2x4x4x5xf64> + %41 = tensor.empty() : tensor<2x4x4x5xf64> + %42 = tensor.empty() : tensor<2x4x4x5xf64> + %43 = tensor.empty() : tensor<2x4x4x5xf64> + %44 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice = tensor.extract_slice %44[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %45 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %45 into %44[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %46 = polygeist.submap(%9, %c2, %c4, %c4, %c5, %c3) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %47 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c3) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %inserted_slice_contract_48_tc2 = tensor.cast %inserted_slice : tensor<2x4x4x5xf64> to tensor + + %v48_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%47, %46, %inserted_slice_contract_48_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %48 = tensor.cast %v48_tdyn : tensor to tensor<2x4x4x5xf64> + %extracted_slice_0 = tensor.extract_slice %39[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_1 = tensor.extract_slice %48[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %50 = polygeist.submap(%5, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %51 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_1, %50, %extracted_slice_0) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_2 = tensor.extract_slice %38[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_3 = tensor.extract_slice %48[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %53 = polygeist.submap(%8, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %54 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_3, %53, %extracted_slice_2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_4 = tensor.extract_slice %33[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %56 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %57 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%51, %56, %extracted_slice_4) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_5 = tensor.extract_slice %32[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %59 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %60 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%54, %59, %extracted_slice_5) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_6 = tensor.extract_slice %43[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %62 = polygeist.submap(%5, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %63 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %64 = kernel.launch @cutensornetContraction2_f64_r5r5r4(%63, %62, %extracted_slice_6) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_7 = tensor.extract_slice %42[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %66 = polygeist.submap(%8, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %67 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %68 = kernel.launch @cutensornetContraction2_f64_r5r5r4(%67, %66, %extracted_slice_7) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_8 = tensor.extract_slice %37[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %70 = polygeist.submap(%9, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %71 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%64, %70, %extracted_slice_8) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_9 = tensor.extract_slice %36[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %73 = polygeist.submap(%9, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %74 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%68, %73, %extracted_slice_9) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_10 = tensor.extract_slice %31[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %76 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %77 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%71, %76, %extracted_slice_10) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_11 = tensor.extract_slice %30[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %79 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %80 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%74, %79, %extracted_slice_11) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_12 = tensor.extract_slice %41[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %82 = polygeist.submap(%5, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %83 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %84 = kernel.launch @cutensornetContraction2_f64_r5r5r4(%83, %82, %extracted_slice_12) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_13 = tensor.extract_slice %40[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %86 = polygeist.submap(%8, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %87 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %88 = kernel.launch @cutensornetContraction2_f64_r5r5r4(%87, %86, %extracted_slice_13) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_14 = tensor.extract_slice %35[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %90 = polygeist.submap(%8, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %91 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%84, %90, %extracted_slice_14) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_15 = tensor.extract_slice %34[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %93 = polygeist.submap(%5, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %94 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%88, %93, %extracted_slice_15) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_16 = tensor.extract_slice %29[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %96 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %97 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%91, %96, %extracted_slice_16) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_17 = tensor.extract_slice %28[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %99 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %100 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%94, %99, %extracted_slice_17) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_18 = tensor.extract_slice %27[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %101 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_18 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %102 = polygeist.submap(%7, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %103 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %104 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %105 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %106 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%103, %100, %80, %104, %60, %97, %105, %77, %57, %102 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%101 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_19 = tensor.extract_slice %21[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %108 = polygeist.submap(%6, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %109 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%106, %108, %extracted_slice_19) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_20 = tensor.extract_slice %15[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %111 = polygeist.submap(%4, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %112 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%109, %111, %extracted_slice_20) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_21 = tensor.extract_slice %26[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %113 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_21 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %114 = polygeist.submap(%7, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %115 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %116 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %117 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %118 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%115, %100, %80, %116, %60, %97, %117, %77, %57, %114 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%113 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_22 = tensor.extract_slice %20[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %120 = polygeist.submap(%4, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %121 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%118, %120, %extracted_slice_22) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_23 = tensor.extract_slice %14[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %123 = polygeist.submap(%6, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %124 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%121, %123, %extracted_slice_23) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_24 = tensor.extract_slice %25[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %125 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_24 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %126 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %127 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %128 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %129 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %130 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%127, %100, %80, %128, %60, %97, %129, %77, %57, %126 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%125 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_25 = tensor.extract_slice %19[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %132 = polygeist.submap(%7, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %133 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%130, %132, %extracted_slice_25) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_26 = tensor.extract_slice %13[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %135 = polygeist.submap(%6, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %136 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%133, %135, %extracted_slice_26) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_27 = tensor.extract_slice %24[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %137 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_27 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %138 = polygeist.submap(%6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %139 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %140 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %141 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %142 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%139, %100, %80, %140, %60, %97, %141, %77, %57, %138 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%137 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_28 = tensor.extract_slice %18[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %144 = polygeist.submap(%7, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %145 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%142, %144, %extracted_slice_28) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_29 = tensor.extract_slice %12[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %147 = polygeist.submap(%4, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %148 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%145, %147, %extracted_slice_29) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_30 = tensor.extract_slice %23[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %149 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_30 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %150 = polygeist.submap(%6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %151 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %152 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %153 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %154 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%151, %100, %80, %152, %60, %97, %153, %77, %57, %150 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%149 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_31 = tensor.extract_slice %17[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %156 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %157 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%154, %156, %extracted_slice_31) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_32 = tensor.extract_slice %11[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %159 = polygeist.submap(%7, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %160 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%157, %159, %extracted_slice_32) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_33 = tensor.extract_slice %22[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %161 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_33 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %162 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %163 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %164 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %165 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %166 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%163, %100, %80, %164, %60, %97, %165, %77, %57, %162 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%161 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %in_55: f64, %out: f64): + %230 = arith.subf %in_47, %in_48 : f64 + %231 = arith.mulf %in, %230 : f64 + %232 = arith.subf %in_50, %in_51 : f64 + %233 = arith.mulf %in_49, %232 : f64 + %234 = arith.addf %231, %233 : f64 + %235 = arith.subf %in_53, %in_54 : f64 + %236 = arith.mulf %in_52, %235 : f64 + %237 = arith.addf %234, %236 : f64 + %238 = arith.mulf %237, %in_55 : f64 + %239 = arith.addf %out, %238 : f64 + linalg.yield %239 : f64 + } -> tensor + %extracted_slice_34 = tensor.extract_slice %16[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %168 = polygeist.submap(%6, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %169 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%166, %168, %extracted_slice_34) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_35 = tensor.extract_slice %10[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %171 = polygeist.submap(%7, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %172 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%169, %171, %extracted_slice_35) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %173 = polygeist.submap(%0, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, index, index, index, index) -> tensor + %174 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%112, %124 : tensor, tensor) outs(%173 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.subf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %175 = polygeist.submapInverse(%0, %174, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, tensor, index, index, index, index) -> tensor + %176 = polygeist.submap(%175, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, index, index, index, index) -> tensor + %177 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%136, %148 : tensor, tensor) outs(%176 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.subf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %178 = polygeist.submapInverse(%175, %177, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, tensor, index, index, index, index) -> tensor + %179 = polygeist.submap(%178, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, index, index, index, index) -> tensor + %180 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%160, %172 : tensor, tensor) outs(%179 : tensor) { + ^bb0(%in: f64, %in_47: f64, %out: f64): + %230 = arith.subf %in, %in_47 : f64 + %231 = arith.addf %out, %230 : f64 + linalg.yield %231 : f64 + } -> tensor + %181 = polygeist.submapInverse(%178, %180, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, tensor, index, index, index, index) -> tensor + %182 = tensor.empty() : tensor<2x3x5x5x5xf64> + %extracted_slice_36 = tensor.extract_slice %182[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %183 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_36 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %184 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map27} : (tensor, index, index, index, index, index, index, index) -> tensor + %185 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map28} : (tensor, index, index, index, index, index, index, index) -> tensor + %186 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map29} : (tensor, index, index, index, index, index, index, index) -> tensor + %187 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map30} : (tensor, index, index, index, index, index, index, index) -> tensor + %188 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%185, %186, %187, %184 : tensor, tensor, tensor, tensor) outs(%183 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %inserted_slice_37 = tensor.insert_slice %188 into %182[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_38 = tensor.extract_slice %inserted_slice_37[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %189 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_38 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %190 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map33} : (tensor, index, index, index, index, index, index, index) -> tensor + %191 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map28} : (tensor, index, index, index, index, index, index, index) -> tensor + %192 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map34} : (tensor, index, index, index, index, index, index, index) -> tensor + %193 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map35} : (tensor, index, index, index, index, index, index, index) -> tensor + %194 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%191, %190, %193, %192 : tensor, tensor, tensor, tensor) outs(%189 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %inserted_slice_39 = tensor.insert_slice %194 into %inserted_slice_37[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_40 = tensor.extract_slice %inserted_slice_39[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %195 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_40 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %196 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map36} : (tensor, index, index, index, index, index, index, index) -> tensor + %197 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map29} : (tensor, index, index, index, index, index, index, index) -> tensor + %198 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map34} : (tensor, index, index, index, index, index, index, index) -> tensor + %199 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map37} : (tensor, index, index, index, index, index, index, index) -> tensor + %200 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%196, %197, %199, %198 : tensor, tensor, tensor, tensor) outs(%195 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %inserted_slice_41 = tensor.insert_slice %200 into %inserted_slice_39[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_42 = tensor.extract_slice %inserted_slice_41[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %extracted_slice_43 = tensor.extract_slice %inserted_slice_41[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %201 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map38} : (tensor, index, index, index, index) -> tensor + %202 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index) -> tensor + %203 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index) -> tensor + %204 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index) -> tensor + %205 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map41} : (tensor, index, index, index, index) -> tensor + %206 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map42} : (tensor, index, index, index, index) -> tensor + %207 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index) -> tensor + %208 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map42} : (tensor, index, index, index, index) -> tensor + %209 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map43} : (tensor, index, index, index, index) -> tensor + %210:3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%201, %202, %203, %204, %205, %206, %207, %208, %209 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_42, %extracted_slice_43, %200 : tensor, tensor, tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %in_54: f64, %out: f64, %out_55: f64, %out_56: f64): + %230 = arith.mulf %in, %out : f64 + %231 = arith.mulf %in_47, %out_55 : f64 + %232 = arith.addf %230, %231 : f64 + %233 = arith.mulf %in_48, %out_56 : f64 + %234 = arith.addf %232, %233 : f64 + %235 = arith.mulf %in_49, %out : f64 + %236 = arith.mulf %in_50, %out_55 : f64 + %237 = arith.addf %235, %236 : f64 + %238 = arith.mulf %in_51, %out_56 : f64 + %239 = arith.addf %237, %238 : f64 + %240 = arith.mulf %in_52, %out : f64 + %241 = arith.mulf %in_53, %out_55 : f64 + %242 = arith.addf %240, %241 : f64 + %243 = arith.mulf %in_54, %out_56 : f64 + %244 = arith.addf %242, %243 : f64 + linalg.yield %234, %239, %244 : f64, f64, f64 + } -> (tensor, tensor, tensor) + %inserted_slice_44 = tensor.insert_slice %210#2 into %inserted_slice_39[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_45 = tensor.extract_slice %inserted_slice_44[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %211 = polygeist.submap(%7, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map44} : (tensor, index, index, index, index, index, index, index) -> tensor + %212 = polygeist.submap(%6, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map45} : (tensor, index, index, index, index, index, index, index) -> tensor + %213 = polygeist.submap(%6, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map46} : (tensor, index, index, index, index, index, index, index) -> tensor + %214 = polygeist.submap(%181, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, index, index, index, index) -> tensor + %215 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%212, %213, %extracted_slice_45, %211 : tensor, tensor, tensor, tensor) outs(%214 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %216 = polygeist.submapInverse(%181, %215, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, tensor, index, index, index, index) -> tensor + %extracted_slice_46 = tensor.extract_slice %inserted_slice_44[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %217 = polygeist.submap(%7, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map46} : (tensor, index, index, index, index, index, index, index) -> tensor + %218 = polygeist.submap(%6, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map45} : (tensor, index, index, index, index, index, index, index) -> tensor + %219 = polygeist.submap(%6, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map44} : (tensor, index, index, index, index, index, index, index) -> tensor + %220 = polygeist.submap(%216, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, index, index, index, index) -> tensor + %221 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%218, %217, %extracted_slice_46, %219 : tensor, tensor, tensor, tensor) outs(%220 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %222 = polygeist.submapInverse(%216, %221, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, tensor, index, index, index, index) -> tensor + %223 = polygeist.submap(%7, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map45} : (tensor, index, index, index, index, index, index, index) -> tensor + %224 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map46} : (tensor, index, index, index, index, index, index, index) -> tensor + %225 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map44} : (tensor, index, index, index, index, index, index, index) -> tensor + %226 = polygeist.submap(%222, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, index, index, index, index) -> tensor + %227 = linalg.generic {doc = "", indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%223, %224, %210#2, %225 : tensor, tensor, tensor, tensor) outs(%226 : tensor) { + ^bb0(%in: f64, %in_47: f64, %in_48: f64, %in_49: f64, %out: f64): + %230 = arith.mulf %in_48, %in_49 : f64 + %231 = arith.mulf %230, %in_47 : f64 + %232 = arith.mulf %231, %in : f64 + %233 = arith.addf %out, %232 : f64 + linalg.yield %233 : f64 + } -> tensor + %228 = polygeist.submapInverse(%222, %227, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, tensor, index, index, index, index) -> tensor + %229 = bufferization.to_memref %228 : memref + memref.copy %229, %arg9 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d.raised.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d.raised.mlir new file mode 100644 index 000000000000..a941175c8aae --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d.raised.mlir @@ -0,0 +1,831 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 144)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 125)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 375)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 500)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 250)> +#map22 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 625)> +#map23 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 144)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map26 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map27 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 4)> +#map28 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 4)> +#map29 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 3 + d0 * 144)> +#map30 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 3)> +#map31 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map32 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +#map33 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 3)> +#map34 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 4 + d0 * 144 + 48)> +#map35 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 4)> +#map36 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 3)> +#map37 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 16 + d5 * 4 + d0 * 144 + 96)> +#map38 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750)> +#map39 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 125)> +#map40 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 250)> +#map41 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 375)> +#map42 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 500)> +#map43 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 625)> +#map44 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 5)> +#map45 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 5)> +#map46 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 5)> +#map47 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_hcurl_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_13 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_14 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_15 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_16 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_21 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_22 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_23 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_24 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_25 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_26 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_27 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_28 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_29 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_30 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_31 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_32 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_33 = memref.alloca() : memref<2x4x4x5xf64> + %subview = memref.subview %alloca_33[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg8, %c2, %c4, %c4, %c5, %c3) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c3) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_33 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_34 = memref.subview %alloca_28[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_34 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_35 = memref.subview %alloca_33[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %2 = polygeist.submap(%arg4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_36 = memref.subview %alloca_28[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_35, %2 : memref>, memref) outs(%subview_36 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_37 = memref.subview %alloca_27[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_37 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_38 = memref.subview %alloca_33[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %3 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_39 = memref.subview %alloca_27[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_38, %3 : memref>, memref) outs(%subview_39 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_40 = memref.subview %alloca_22[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_40 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_41 = memref.subview %alloca_28[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %4 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_42 = memref.subview %alloca_22[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_41, %4 : memref>, memref) outs(%subview_42 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_43 = memref.subview %alloca_21[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_43 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_44 = memref.subview %alloca_27[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %5 = polygeist.submap(%arg4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_45 = memref.subview %alloca_21[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_44, %5 : memref>, memref) outs(%subview_45 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_46 = memref.subview %alloca_32[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_46 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg8, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (memref, index, index, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_47 = memref.subview %alloca_32[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%6, %7 : memref, memref) outs(%subview_47 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_48 = memref.subview %alloca_31[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_48 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg8, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (memref, index, index, index, index, index) -> memref + %9 = polygeist.submap(%arg1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_49 = memref.subview %alloca_31[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%8, %9 : memref, memref) outs(%subview_49 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_50 = memref.subview %alloca_26[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_50 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_51 = memref.subview %alloca_32[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %10 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (memref, index, index, index, index, index) -> memref + %subview_52 = memref.subview %alloca_26[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_51, %10 : memref>, memref) outs(%subview_52 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_53 = memref.subview %alloca_25[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_53 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_54 = memref.subview %alloca_31[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %11 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (memref, index, index, index, index, index) -> memref + %subview_55 = memref.subview %alloca_25[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_54, %11 : memref>, memref) outs(%subview_55 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_56 = memref.subview %alloca_20[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_56 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_57 = memref.subview %alloca_26[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %12 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_58 = memref.subview %alloca_20[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_57, %12 : memref>, memref) outs(%subview_58 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_59 = memref.subview %alloca_19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_59 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_60 = memref.subview %alloca_25[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %13 = polygeist.submap(%arg4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_61 = memref.subview %alloca_19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_60, %13 : memref>, memref) outs(%subview_61 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_62 = memref.subview %alloca_30[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_62 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg8, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %15 = polygeist.submap(%arg4, %c2, %c3, %c4, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_63 = memref.subview %alloca_30[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%14, %15 : memref, memref) outs(%subview_63 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_64 = memref.subview %alloca_29[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_64 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %16 = polygeist.submap(%arg8, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %17 = polygeist.submap(%arg1, %c2, %c3, %c4, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_65 = memref.subview %alloca_29[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%16, %17 : memref, memref) outs(%subview_65 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_66 = memref.subview %alloca_24[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_66 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_67 = memref.subview %alloca_30[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %18 = polygeist.submap(%arg1, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_68 = memref.subview %alloca_24[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_67, %18 : memref>, memref) outs(%subview_68 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_69 = memref.subview %alloca_23[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_69 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_70 = memref.subview %alloca_29[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %19 = polygeist.submap(%arg4, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_71 = memref.subview %alloca_23[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_70, %19 : memref>, memref) outs(%subview_71 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_72 = memref.subview %alloca_18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_72 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_73 = memref.subview %alloca_24[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %20 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (memref, index, index, index, index, index) -> memref + %subview_74 = memref.subview %alloca_18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_73, %20 : memref>, memref) outs(%subview_74 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_75 = memref.subview %alloca_17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_75 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_76 = memref.subview %alloca_23[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %21 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (memref, index, index, index, index, index) -> memref + %subview_77 = memref.subview %alloca_17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_76, %21 : memref>, memref) outs(%subview_77 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_78 = memref.subview %alloca_16[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_78 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %22 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %subview_79 = memref.subview %alloca_17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_80 = memref.subview %alloca_19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %23 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_81 = memref.subview %alloca_21[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_82 = memref.subview %alloca_18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %24 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %subview_83 = memref.subview %alloca_20[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_84 = memref.subview %alloca_22[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %25 = polygeist.submap(%arg2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_85 = memref.subview %alloca_16[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%22, %subview_79, %subview_80, %23, %subview_81, %subview_82, %24, %subview_83, %subview_84, %25 : memref, memref>, memref>, memref, memref>, memref>, memref, memref>, memref>, memref) outs(%subview_85 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %in_184: f64, %in_185: f64, %in_186: f64, %in_187: f64, %in_188: f64, %in_189: f64, %out: f64): + %94 = arith.subf %in_181, %in_182 : f64 + %95 = arith.mulf %in, %94 : f64 + %96 = arith.subf %in_184, %in_185 : f64 + %97 = arith.mulf %in_183, %96 : f64 + %98 = arith.addf %95, %97 : f64 + %99 = arith.subf %in_187, %in_188 : f64 + %100 = arith.mulf %in_186, %99 : f64 + %101 = arith.addf %98, %100 : f64 + %102 = arith.mulf %101, %in_189 : f64 + %103 = arith.addf %out, %102 : f64 + linalg.yield %103 : f64 + } + %subview_86 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_86 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_87 = memref.subview %alloca_16[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %26 = polygeist.submap(%arg3, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + %subview_88 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_87, %26 : memref>, memref) outs(%subview_88 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_89 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_89 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_90 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %27 = polygeist.submap(%arg5, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + %subview_91 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_90, %27 : memref>, memref) outs(%subview_91 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_92 = memref.subview %alloca_15[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_92 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %28 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %subview_93 = memref.subview %alloca_17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_94 = memref.subview %alloca_19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %29 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %subview_95 = memref.subview %alloca_21[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_96 = memref.subview %alloca_18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %30 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map22} : (memref, index, index, index, index, index) -> memref + %subview_97 = memref.subview %alloca_20[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_98 = memref.subview %alloca_22[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %31 = polygeist.submap(%arg2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_99 = memref.subview %alloca_15[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%28, %subview_93, %subview_94, %29, %subview_95, %subview_96, %30, %subview_97, %subview_98, %31 : memref, memref>, memref>, memref, memref>, memref>, memref, memref>, memref>, memref) outs(%subview_99 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %in_184: f64, %in_185: f64, %in_186: f64, %in_187: f64, %in_188: f64, %in_189: f64, %out: f64): + %94 = arith.subf %in_181, %in_182 : f64 + %95 = arith.mulf %in, %94 : f64 + %96 = arith.subf %in_184, %in_185 : f64 + %97 = arith.mulf %in_183, %96 : f64 + %98 = arith.addf %95, %97 : f64 + %99 = arith.subf %in_187, %in_188 : f64 + %100 = arith.mulf %in_186, %99 : f64 + %101 = arith.addf %98, %100 : f64 + %102 = arith.mulf %101, %in_189 : f64 + %103 = arith.addf %out, %102 : f64 + linalg.yield %103 : f64 + } + %subview_100 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_100 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_101 = memref.subview %alloca_15[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %32 = polygeist.submap(%arg5, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + %subview_102 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_101, %32 : memref>, memref) outs(%subview_102 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_103 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_103 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_104 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %33 = polygeist.submap(%arg3, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + %subview_105 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_104, %33 : memref>, memref) outs(%subview_105 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_106 = memref.subview %alloca_14[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_106 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %34 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %subview_107 = memref.subview %alloca_17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_108 = memref.subview %alloca_19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %35 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %subview_109 = memref.subview %alloca_21[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_110 = memref.subview %alloca_18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %36 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map22} : (memref, index, index, index, index, index) -> memref + %subview_111 = memref.subview %alloca_20[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_112 = memref.subview %alloca_22[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %37 = polygeist.submap(%arg5, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_113 = memref.subview %alloca_14[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%34, %subview_107, %subview_108, %35, %subview_109, %subview_110, %36, %subview_111, %subview_112, %37 : memref, memref>, memref>, memref, memref>, memref>, memref, memref>, memref>, memref) outs(%subview_113 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %in_184: f64, %in_185: f64, %in_186: f64, %in_187: f64, %in_188: f64, %in_189: f64, %out: f64): + %94 = arith.subf %in_181, %in_182 : f64 + %95 = arith.mulf %in, %94 : f64 + %96 = arith.subf %in_184, %in_185 : f64 + %97 = arith.mulf %in_183, %96 : f64 + %98 = arith.addf %95, %97 : f64 + %99 = arith.subf %in_187, %in_188 : f64 + %100 = arith.mulf %in_186, %99 : f64 + %101 = arith.addf %98, %100 : f64 + %102 = arith.mulf %101, %in_189 : f64 + %103 = arith.addf %out, %102 : f64 + linalg.yield %103 : f64 + } + %subview_114 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_114 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_115 = memref.subview %alloca_14[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %38 = polygeist.submap(%arg2, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + %subview_116 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_115, %38 : memref>, memref) outs(%subview_116 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_117 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_117 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_118 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %39 = polygeist.submap(%arg3, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + %subview_119 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_118, %39 : memref>, memref) outs(%subview_119 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_120 = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_120 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %40 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (memref, index, index, index, index, index) -> memref + %subview_121 = memref.subview %alloca_17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_122 = memref.subview %alloca_19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %41 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %subview_123 = memref.subview %alloca_21[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_124 = memref.subview %alloca_18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %42 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %subview_125 = memref.subview %alloca_20[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_126 = memref.subview %alloca_22[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %43 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_127 = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%40, %subview_121, %subview_122, %41, %subview_123, %subview_124, %42, %subview_125, %subview_126, %43 : memref, memref>, memref>, memref, memref>, memref>, memref, memref>, memref>, memref) outs(%subview_127 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %in_184: f64, %in_185: f64, %in_186: f64, %in_187: f64, %in_188: f64, %in_189: f64, %out: f64): + %94 = arith.subf %in_181, %in_182 : f64 + %95 = arith.mulf %in, %94 : f64 + %96 = arith.subf %in_184, %in_185 : f64 + %97 = arith.mulf %in_183, %96 : f64 + %98 = arith.addf %95, %97 : f64 + %99 = arith.subf %in_187, %in_188 : f64 + %100 = arith.mulf %in_186, %99 : f64 + %101 = arith.addf %98, %100 : f64 + %102 = arith.mulf %101, %in_189 : f64 + %103 = arith.addf %out, %102 : f64 + linalg.yield %103 : f64 + } + %subview_128 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_128 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_129 = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %44 = polygeist.submap(%arg2, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + %subview_130 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_129, %44 : memref>, memref) outs(%subview_130 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_131 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_131 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_132 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %45 = polygeist.submap(%arg5, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + %subview_133 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_132, %45 : memref>, memref) outs(%subview_133 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_134 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_134 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %46 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (memref, index, index, index, index, index) -> memref + %subview_135 = memref.subview %alloca_17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_136 = memref.subview %alloca_19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %47 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %subview_137 = memref.subview %alloca_21[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_138 = memref.subview %alloca_18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %48 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %subview_139 = memref.subview %alloca_20[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_140 = memref.subview %alloca_22[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %49 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_141 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%46, %subview_135, %subview_136, %47, %subview_137, %subview_138, %48, %subview_139, %subview_140, %49 : memref, memref>, memref>, memref, memref>, memref>, memref, memref>, memref>, memref) outs(%subview_141 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %in_184: f64, %in_185: f64, %in_186: f64, %in_187: f64, %in_188: f64, %in_189: f64, %out: f64): + %94 = arith.subf %in_181, %in_182 : f64 + %95 = arith.mulf %in, %94 : f64 + %96 = arith.subf %in_184, %in_185 : f64 + %97 = arith.mulf %in_183, %96 : f64 + %98 = arith.addf %95, %97 : f64 + %99 = arith.subf %in_187, %in_188 : f64 + %100 = arith.mulf %in_186, %99 : f64 + %101 = arith.addf %98, %100 : f64 + %102 = arith.mulf %101, %in_189 : f64 + %103 = arith.addf %out, %102 : f64 + linalg.yield %103 : f64 + } + %subview_142 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_142 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_143 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %50 = polygeist.submap(%arg5, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + %subview_144 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_143, %50 : memref>, memref) outs(%subview_144 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_145 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_145 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_146 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %51 = polygeist.submap(%arg2, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + %subview_147 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_146, %51 : memref>, memref) outs(%subview_147 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_148 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_148 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %52 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %subview_149 = memref.subview %alloca_17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_150 = memref.subview %alloca_19[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %53 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_151 = memref.subview %alloca_21[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_152 = memref.subview %alloca_18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %54 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %subview_153 = memref.subview %alloca_20[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_154 = memref.subview %alloca_22[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %55 = polygeist.submap(%arg5, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_155 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%52, %subview_149, %subview_150, %53, %subview_151, %subview_152, %54, %subview_153, %subview_154, %55 : memref, memref>, memref>, memref, memref>, memref>, memref, memref>, memref>, memref) outs(%subview_155 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %in_184: f64, %in_185: f64, %in_186: f64, %in_187: f64, %in_188: f64, %in_189: f64, %out: f64): + %94 = arith.subf %in_181, %in_182 : f64 + %95 = arith.mulf %in, %94 : f64 + %96 = arith.subf %in_184, %in_185 : f64 + %97 = arith.mulf %in_183, %96 : f64 + %98 = arith.addf %95, %97 : f64 + %99 = arith.subf %in_187, %in_188 : f64 + %100 = arith.mulf %in_186, %99 : f64 + %101 = arith.addf %98, %100 : f64 + %102 = arith.mulf %101, %in_189 : f64 + %103 = arith.addf %out, %102 : f64 + linalg.yield %103 : f64 + } + %subview_156 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_156 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_157 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %56 = polygeist.submap(%arg3, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + %subview_158 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_157, %56 : memref>, memref) outs(%subview_158 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_159 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_159 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_160 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %57 = polygeist.submap(%arg2, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + %subview_161 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_160, %57 : memref>, memref) outs(%subview_161 : memref>) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.mulf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_162 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_163 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c4, %c4, %c3] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %58 = polygeist.submap(%arg9, %c2, %c4, %c4, %c3) {map = #map24} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_162, %subview_163 : memref>, memref>) outs(%58 : memref) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.subf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_164 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_165 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c4, %c3, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %59 = polygeist.submap(%arg9, %c2, %c4, %c3, %c4) {map = #map25} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_164, %subview_165 : memref>, memref>) outs(%59 : memref) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.subf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %subview_166 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_167 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c3, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %60 = polygeist.submap(%arg9, %c2, %c3, %c4, %c4) {map = #map26} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_166, %subview_167 : memref>, memref>) outs(%60 : memref) { + ^bb0(%in: f64, %in_181: f64, %out: f64): + %94 = arith.subf %in, %in_181 : f64 + %95 = arith.addf %out, %94 : f64 + linalg.yield %95 : f64 + } + %alloca_168 = memref.alloca() : memref<2x3x5x5x5xf64> + %subview_169 = memref.subview %alloca_168[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_169 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %61 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map27} : (memref, index, index, index, index, index, index, index) -> memref + %62 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map28} : (memref, index, index, index, index, index, index, index) -> memref + %63 = polygeist.submap(%arg8, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map29} : (memref, index, index, index, index, index, index, index) -> memref + %64 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4, %c4, %c3) {map = #map30} : (memref, index, index, index, index, index, index, index) -> memref + %subview_170 = memref.subview %alloca_168[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%61, %62, %63, %64 : memref, memref, memref, memref) outs(%subview_170 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %out: f64): + %94 = arith.mulf %in_182, %in_183 : f64 + %95 = arith.mulf %94, %in_181 : f64 + %96 = arith.mulf %95, %in : f64 + %97 = arith.addf %out, %96 : f64 + linalg.yield %97 : f64 + } + %subview_171 = memref.subview %alloca_168[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_171 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %65 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map27} : (memref, index, index, index, index, index, index, index) -> memref + %66 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map33} : (memref, index, index, index, index, index, index, index) -> memref + %67 = polygeist.submap(%arg8, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map34} : (memref, index, index, index, index, index, index, index) -> memref + %68 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4, %c3, %c4) {map = #map35} : (memref, index, index, index, index, index, index, index) -> memref + %subview_172 = memref.subview %alloca_168[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%65, %66, %67, %68 : memref, memref, memref, memref) outs(%subview_172 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %out: f64): + %94 = arith.mulf %in_182, %in_183 : f64 + %95 = arith.mulf %94, %in_181 : f64 + %96 = arith.mulf %95, %in : f64 + %97 = arith.addf %out, %96 : f64 + linalg.yield %97 : f64 + } + %subview_173 = memref.subview %alloca_168[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_173 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %69 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map36} : (memref, index, index, index, index, index, index, index) -> memref + %70 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map28} : (memref, index, index, index, index, index, index, index) -> memref + %71 = polygeist.submap(%arg8, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map37} : (memref, index, index, index, index, index, index, index) -> memref + %72 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c3, %c4, %c4) {map = #map35} : (memref, index, index, index, index, index, index, index) -> memref + %subview_174 = memref.subview %alloca_168[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map31, #map31, #map31, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%69, %70, %71, %72 : memref, memref, memref, memref) outs(%subview_174 : memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %out: f64): + %94 = arith.mulf %in_182, %in_183 : f64 + %95 = arith.mulf %94, %in_181 : f64 + %96 = arith.mulf %95, %in : f64 + %97 = arith.addf %out, %96 : f64 + linalg.yield %97 : f64 + } + %73 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map38} : (memref, index, index, index, index) -> memref + %74 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map39} : (memref, index, index, index, index) -> memref + %75 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map40} : (memref, index, index, index, index) -> memref + %76 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map39} : (memref, index, index, index, index) -> memref + %77 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map41} : (memref, index, index, index, index) -> memref + %78 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map42} : (memref, index, index, index, index) -> memref + %79 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map40} : (memref, index, index, index, index) -> memref + %80 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map42} : (memref, index, index, index, index) -> memref + %81 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map43} : (memref, index, index, index, index) -> memref + %subview_175 = memref.subview %alloca_168[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %subview_176 = memref.subview %alloca_168[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %subview_177 = memref.subview %alloca_168[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%73, %74, %75, %76, %77, %78, %79, %80, %81 : memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%subview_175, %subview_176, %subview_177 : memref>, memref>, memref>) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %in_184: f64, %in_185: f64, %in_186: f64, %in_187: f64, %in_188: f64, %out: f64, %out_189: f64, %out_190: f64): + %94 = arith.mulf %in, %out : f64 + %95 = arith.mulf %in_181, %out_189 : f64 + %96 = arith.addf %94, %95 : f64 + %97 = arith.mulf %in_182, %out_190 : f64 + %98 = arith.addf %96, %97 : f64 + %99 = arith.mulf %in_183, %out : f64 + %100 = arith.mulf %in_184, %out_189 : f64 + %101 = arith.addf %99, %100 : f64 + %102 = arith.mulf %in_185, %out_190 : f64 + %103 = arith.addf %101, %102 : f64 + %104 = arith.mulf %in_186, %out : f64 + %105 = arith.mulf %in_187, %out_189 : f64 + %106 = arith.addf %104, %105 : f64 + %107 = arith.mulf %in_188, %out_190 : f64 + %108 = arith.addf %106, %107 : f64 + linalg.yield %98, %103, %108 : f64, f64, f64 + } + %82 = polygeist.submap(%arg3, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map44} : (memref, index, index, index, index, index, index, index) -> memref + %83 = polygeist.submap(%arg3, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map45} : (memref, index, index, index, index, index, index, index) -> memref + %subview_178 = memref.subview %alloca_168[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %84 = polygeist.submap(%arg2, %c2, %c4, %c4, %c3, %c5, %c5, %c5) {map = #map46} : (memref, index, index, index, index, index, index, index) -> memref + %85 = polygeist.submap(%arg9, %c2, %c4, %c4, %c3) {map = #map24} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%82, %83, %subview_178, %84 : memref, memref, memref>, memref) outs(%85 : memref) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %out: f64): + %94 = arith.mulf %in_182, %in_183 : f64 + %95 = arith.mulf %94, %in_181 : f64 + %96 = arith.mulf %95, %in : f64 + %97 = arith.addf %out, %96 : f64 + linalg.yield %97 : f64 + } + %86 = polygeist.submap(%arg3, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map44} : (memref, index, index, index, index, index, index, index) -> memref + %87 = polygeist.submap(%arg2, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map45} : (memref, index, index, index, index, index, index, index) -> memref + %subview_179 = memref.subview %alloca_168[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %88 = polygeist.submap(%arg3, %c2, %c4, %c3, %c4, %c5, %c5, %c5) {map = #map46} : (memref, index, index, index, index, index, index, index) -> memref + %89 = polygeist.submap(%arg9, %c2, %c4, %c3, %c4) {map = #map25} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%86, %87, %subview_179, %88 : memref, memref, memref>, memref) outs(%89 : memref) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %out: f64): + %94 = arith.mulf %in_182, %in_183 : f64 + %95 = arith.mulf %94, %in_181 : f64 + %96 = arith.mulf %95, %in : f64 + %97 = arith.addf %out, %96 : f64 + linalg.yield %97 : f64 + } + %90 = polygeist.submap(%arg2, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map44} : (memref, index, index, index, index, index, index, index) -> memref + %91 = polygeist.submap(%arg3, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map45} : (memref, index, index, index, index, index, index, index) -> memref + %subview_180 = memref.subview %alloca_168[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %92 = polygeist.submap(%arg3, %c2, %c3, %c4, %c4, %c5, %c5, %c5) {map = #map46} : (memref, index, index, index, index, index, index, index) -> memref + %93 = polygeist.submap(%arg9, %c2, %c3, %c4, %c4) {map = #map26} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map31, #map31, #map47, #map31, #map32], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%90, %91, %subview_180, %92 : memref, memref, memref>, memref) outs(%93 : memref) { + ^bb0(%in: f64, %in_181: f64, %in_182: f64, %in_183: f64, %out: f64): + %94 = arith.mulf %in_182, %in_183 : f64 + %95 = arith.mulf %94, %in_181 : f64 + %96 = arith.mulf %95, %in : f64 + %97 = arith.addf %out, %96 : f64 + linalg.yield %97 : f64 + } + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d_partial.debufferized.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d_partial.debufferized.mlir new file mode 100644 index 000000000000..ff9af4c20cda --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d_partial.debufferized.mlir @@ -0,0 +1,563 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 144)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 125)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 375)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 500)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 250)> +#map22 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 625)> +#map23 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 144)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map26 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_hcurl_3d_partial(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg8 : memref + %1 = bufferization.to_tensor %arg7 : memref + %2 = bufferization.to_tensor %arg6 : memref + %3 = bufferization.to_tensor %arg5 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = bufferization.to_tensor %arg3 : memref + %6 = bufferization.to_tensor %arg2 : memref + %7 = bufferization.to_tensor %arg1 : memref + %8 = bufferization.to_tensor %arg0 : memref + %9 = tensor.empty() : tensor<2x4x4x4xf64> + %10 = tensor.empty() : tensor<2x4x4x4xf64> + %11 = tensor.empty() : tensor<2x4x4x4xf64> + %12 = tensor.empty() : tensor<2x4x4x4xf64> + %13 = tensor.empty() : tensor<2x4x4x4xf64> + %14 = tensor.empty() : tensor<2x4x4x4xf64> + %15 = tensor.empty() : tensor<2x5x4x4xf64> + %16 = tensor.empty() : tensor<2x5x4x4xf64> + %17 = tensor.empty() : tensor<2x5x4x4xf64> + %18 = tensor.empty() : tensor<2x5x4x4xf64> + %19 = tensor.empty() : tensor<2x5x4x4xf64> + %20 = tensor.empty() : tensor<2x5x4x4xf64> + %21 = tensor.empty() : tensor<2x5x5x4xf64> + %22 = tensor.empty() : tensor<2x5x5x4xf64> + %23 = tensor.empty() : tensor<2x5x5x4xf64> + %24 = tensor.empty() : tensor<2x5x5x4xf64> + %25 = tensor.empty() : tensor<2x5x5x4xf64> + %26 = tensor.empty() : tensor<2x5x5x4xf64> + %27 = tensor.empty() : tensor<2x5x5x5xf64> + %28 = tensor.empty() : tensor<2x5x5x5xf64> + %29 = tensor.empty() : tensor<2x5x5x5xf64> + %30 = tensor.empty() : tensor<2x5x5x5xf64> + %31 = tensor.empty() : tensor<2x5x5x5xf64> + %32 = tensor.empty() : tensor<2x5x5x5xf64> + %33 = tensor.empty() : tensor<2x4x5x5xf64> + %34 = tensor.empty() : tensor<2x4x5x5xf64> + %35 = tensor.empty() : tensor<2x4x5x5xf64> + %36 = tensor.empty() : tensor<2x4x5x5xf64> + %37 = tensor.empty() : tensor<2x4x5x5xf64> + %38 = tensor.empty() : tensor<2x4x5x5xf64> + %39 = tensor.empty() : tensor<2x4x4x5xf64> + %40 = tensor.empty() : tensor<2x4x4x5xf64> + %41 = tensor.empty() : tensor<2x4x4x5xf64> + %42 = tensor.empty() : tensor<2x4x4x5xf64> + %43 = tensor.empty() : tensor<2x4x4x5xf64> + %44 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%43 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %45 = polygeist.submap(%8, %c2, %c4, %c4, %c5, %c3) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %46 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c3) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %47 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%46, %45 : tensor, tensor) outs(%44 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x5xf64> + %48 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%38 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %49 = polygeist.submap(%4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %50 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%47, %49 : tensor<2x4x4x5xf64>, tensor) outs(%48 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %51 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%37 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %52 = polygeist.submap(%7, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %53 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%47, %52 : tensor<2x4x4x5xf64>, tensor) outs(%51 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %54 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%32 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %55 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %56 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%50, %55 : tensor<2x4x5x5xf64>, tensor) outs(%54 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %57 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%31 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %58 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %59 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%53, %58 : tensor<2x4x5x5xf64>, tensor) outs(%57 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %60 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%42 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %61 = polygeist.submap(%4, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %62 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%62, %61 : tensor, tensor) outs(%60 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x5xf64> + %64 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%41 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %65 = polygeist.submap(%7, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %66 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %67 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%66, %65 : tensor, tensor) outs(%64 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x5xf64> + %68 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%36 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %69 = polygeist.submap(%8, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %70 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%63, %69 : tensor<2x4x4x5xf64>, tensor) outs(%68 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %71 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%35 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %72 = polygeist.submap(%8, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %73 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%67, %72 : tensor<2x4x4x5xf64>, tensor) outs(%71 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %74 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%30 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %75 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %76 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%70, %75 : tensor<2x4x5x5xf64>, tensor) outs(%74 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %77 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%29 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %78 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %79 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%73, %78 : tensor<2x4x5x5xf64>, tensor) outs(%77 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %80 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%40 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %81 = polygeist.submap(%4, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %82 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %83 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%82, %81 : tensor, tensor) outs(%80 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x5xf64> + %84 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%39 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %85 = polygeist.submap(%7, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %86 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %87 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%86, %85 : tensor, tensor) outs(%84 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x5xf64> + %88 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%34 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %89 = polygeist.submap(%7, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %90 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%83, %89 : tensor<2x4x4x5xf64>, tensor) outs(%88 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %91 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%33 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %92 = polygeist.submap(%4, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %93 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%87, %92 : tensor<2x4x4x5xf64>, tensor) outs(%91 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %94 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%28 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %95 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %96 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%90, %95 : tensor<2x4x5x5xf64>, tensor) outs(%94 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %97 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%27 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %98 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %99 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%93, %98 : tensor<2x4x5x5xf64>, tensor) outs(%97 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %100 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%26 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %101 = polygeist.submap(%6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %102 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %103 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %104 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %105 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%102, %99, %79, %103, %59, %96, %104, %76, %56, %101 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%100 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %106 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%20 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %107 = polygeist.submap(%5, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %108 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%105, %107 : tensor<2x5x5x4xf64>, tensor) outs(%106 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %109 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%14 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %110 = polygeist.submap(%3, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %111 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%108, %110 : tensor<2x5x4x4xf64>, tensor) outs(%109 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %112 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%25 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %113 = polygeist.submap(%6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %114 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %115 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %116 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %117 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%114, %99, %79, %115, %59, %96, %116, %76, %56, %113 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%112 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %118 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%19 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %119 = polygeist.submap(%3, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %120 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%117, %119 : tensor<2x5x5x4xf64>, tensor) outs(%118 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %121 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%13 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %122 = polygeist.submap(%5, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %123 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%120, %122 : tensor<2x5x4x4xf64>, tensor) outs(%121 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %124 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%24 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %125 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %126 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %127 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %128 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %129 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%126, %99, %79, %127, %59, %96, %128, %76, %56, %125 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%124 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %130 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%18 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %131 = polygeist.submap(%6, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %132 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%129, %131 : tensor<2x5x5x4xf64>, tensor) outs(%130 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %133 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %134 = polygeist.submap(%5, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %135 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%132, %134 : tensor<2x5x4x4xf64>, tensor) outs(%133 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %136 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%23 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %137 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %138 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %139 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %140 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %141 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%138, %99, %79, %139, %59, %96, %140, %76, %56, %137 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%136 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %142 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%17 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %143 = polygeist.submap(%6, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %144 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%141, %143 : tensor<2x5x5x4xf64>, tensor) outs(%142 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %145 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %146 = polygeist.submap(%3, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %147 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%144, %146 : tensor<2x5x4x4xf64>, tensor) outs(%145 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %148 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%22 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %149 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %150 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %151 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %152 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %153 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%150, %99, %79, %151, %59, %96, %152, %76, %56, %149 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%148 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %154 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%16 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %155 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %156 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%153, %155 : tensor<2x5x5x4xf64>, tensor) outs(%154 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %157 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %158 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %159 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%156, %158 : tensor<2x5x4x4xf64>, tensor) outs(%157 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %160 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%21 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %161 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %162 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %163 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %164 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %165 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%162, %99, %79, %163, %59, %96, %164, %76, %56, %161 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%160 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %166 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%15 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %167 = polygeist.submap(%5, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %168 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%165, %167 : tensor<2x5x5x4xf64>, tensor) outs(%166 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %169 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %170 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %171 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%168, %170 : tensor<2x5x4x4xf64>, tensor) outs(%169 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %172 = polygeist.submap(%0, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, index, index, index, index) -> tensor + %173 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%111, %123 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%172 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %174 = polygeist.submapInverse(%0, %173, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, tensor, index, index, index, index) -> tensor + %175 = polygeist.submap(%174, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, index, index, index, index) -> tensor + %176 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%135, %147 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%175 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %177 = polygeist.submapInverse(%174, %176, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, tensor, index, index, index, index) -> tensor + %178 = polygeist.submap(%177, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, index, index, index, index) -> tensor + %179 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%159, %171 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%178 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %180 = polygeist.submapInverse(%177, %179, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, tensor, index, index, index, index) -> tensor + %181 = bufferization.to_memref %180 : memref + memref.copy %181, %arg8 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d_partial.frontend.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d_partial.frontend.mlir new file mode 100644 index 000000000000..5ef6d91e57c5 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d_partial.frontend.mlir @@ -0,0 +1,1476 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_hcurl_3d_partial(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_13 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_14 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_15 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_16 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_21 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_22 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_23 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_24 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_25 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_26 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_27 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_28 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_29 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_30 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_31 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_32 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_33 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 3 + %arg9 * 144] : memref + %2 = affine.load %arg0[%arg13 + %arg12 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_33[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_28[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_27[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_28[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_22[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_27[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_21[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %2 = affine.load %arg4[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_32[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %2 = affine.load %arg1[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_31[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_32[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg13 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_26[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_31[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg13 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_25[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_26[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_20[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_25[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_19[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 16 + %arg13 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %2 = affine.load %arg4[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_30[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 16 + %arg13 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %2 = affine.load %arg1[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_29[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_30[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_24[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_29[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_23[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_24[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg13 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_18[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_23[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg13 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_17[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_16[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_16[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_15[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_14[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_13[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_12[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_11[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.load %alloca_4[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_3[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 12 + %arg12 + %arg11 * 3 + %arg9 * 144] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 12 + %arg12 + %arg11 * 3 + %arg9 * 144] : memref + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.load %alloca_2[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_1[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 12 + %arg12 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 12 + %arg12 + %arg11 * 4 + %arg9 * 144 + 48] : memref + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.load %alloca_0[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 16 + %arg12 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 16 + %arg12 + %arg11 * 4 + %arg9 * 144 + 96] : memref + } + } + } + } + return + } + func.func @mfem_pa_curlcurl_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_13 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_14 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_15 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_16 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_21 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_22 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_23 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_24 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_25 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_26 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_27 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_28 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_29 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_30 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_31 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_32 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_33 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 3 + %arg9 * 144] : memref + %2 = affine.load %arg0[%arg13 + %arg12 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_33[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_28[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_27[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_28[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_22[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_27[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_21[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %2 = affine.load %arg4[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_32[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %2 = affine.load %arg1[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_31[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_32[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg13 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_26[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_31[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg13 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_25[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_26[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_20[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_25[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_19[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 16 + %arg13 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %2 = affine.load %arg4[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_30[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 16 + %arg13 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %2 = affine.load %arg1[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_29[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_30[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_24[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_29[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_23[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_24[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg13 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_18[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_23[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg13 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_17[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_16[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_16[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_15[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_14[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_13[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_12[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_11[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.load %alloca_4[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_3[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 12 + %arg12 + %arg11 * 3 + %arg9 * 144] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 12 + %arg12 + %arg11 * 3 + %arg9 * 144] : memref + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.load %alloca_2[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_1[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 12 + %arg12 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 12 + %arg12 + %arg11 * 4 + %arg9 * 144 + 48] : memref + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.load %alloca_0[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 16 + %arg12 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 16 + %arg12 + %arg11 * 4 + %arg9 * 144 + 96] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d_partial.matched.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d_partial.matched.mlir new file mode 100644 index 000000000000..65b0ac53cf8c --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d_partial.matched.mlir @@ -0,0 +1,466 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 144)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 125)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 375)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 500)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 250)> +#map22 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 625)> +#map23 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 144)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map26 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_hcurl_3d_partial(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg8 : memref + %1 = bufferization.to_tensor %arg7 : memref + %2 = bufferization.to_tensor %arg6 : memref + %3 = bufferization.to_tensor %arg5 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = bufferization.to_tensor %arg3 : memref + %6 = bufferization.to_tensor %arg2 : memref + %7 = bufferization.to_tensor %arg1 : memref + %8 = bufferization.to_tensor %arg0 : memref + %9 = tensor.empty() : tensor<2x4x4x4xf64> + %10 = tensor.empty() : tensor<2x4x4x4xf64> + %11 = tensor.empty() : tensor<2x4x4x4xf64> + %12 = tensor.empty() : tensor<2x4x4x4xf64> + %13 = tensor.empty() : tensor<2x4x4x4xf64> + %14 = tensor.empty() : tensor<2x4x4x4xf64> + %15 = tensor.empty() : tensor<2x5x4x4xf64> + %16 = tensor.empty() : tensor<2x5x4x4xf64> + %17 = tensor.empty() : tensor<2x5x4x4xf64> + %18 = tensor.empty() : tensor<2x5x4x4xf64> + %19 = tensor.empty() : tensor<2x5x4x4xf64> + %20 = tensor.empty() : tensor<2x5x4x4xf64> + %21 = tensor.empty() : tensor<2x5x5x4xf64> + %22 = tensor.empty() : tensor<2x5x5x4xf64> + %23 = tensor.empty() : tensor<2x5x5x4xf64> + %24 = tensor.empty() : tensor<2x5x5x4xf64> + %25 = tensor.empty() : tensor<2x5x5x4xf64> + %26 = tensor.empty() : tensor<2x5x5x4xf64> + %27 = tensor.empty() : tensor<2x5x5x5xf64> + %28 = tensor.empty() : tensor<2x5x5x5xf64> + %29 = tensor.empty() : tensor<2x5x5x5xf64> + %30 = tensor.empty() : tensor<2x5x5x5xf64> + %31 = tensor.empty() : tensor<2x5x5x5xf64> + %32 = tensor.empty() : tensor<2x5x5x5xf64> + %33 = tensor.empty() : tensor<2x4x5x5xf64> + %34 = tensor.empty() : tensor<2x4x5x5xf64> + %35 = tensor.empty() : tensor<2x4x5x5xf64> + %36 = tensor.empty() : tensor<2x4x5x5xf64> + %37 = tensor.empty() : tensor<2x4x5x5xf64> + %38 = tensor.empty() : tensor<2x4x5x5xf64> + %39 = tensor.empty() : tensor<2x4x4x5xf64> + %40 = tensor.empty() : tensor<2x4x4x5xf64> + %41 = tensor.empty() : tensor<2x4x4x5xf64> + %42 = tensor.empty() : tensor<2x4x4x5xf64> + %43 = tensor.empty() : tensor<2x4x4x5xf64> + %45 = polygeist.submap(%8, %c2, %c4, %c4, %c5, %c3) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %46 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c3) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v43_contract_47_tc2 = tensor.cast %43 : tensor<2x4x4x5xf64> to tensor + + %v47_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%46, %45, %v43_contract_47_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %47 = tensor.cast %v47_tdyn : tensor to tensor<2x4x4x5xf64> + %49 = polygeist.submap(%4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v47_contract_50_tc0 = tensor.cast %47 : tensor<2x4x4x5xf64> to tensor + + %v38_contract_50_tc2 = tensor.cast %38 : tensor<2x4x5x5xf64> to tensor + + %v50_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v47_contract_50_tc0, %49, %v38_contract_50_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %50 = tensor.cast %v50_tdyn : tensor to tensor<2x4x5x5xf64> + %52 = polygeist.submap(%7, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v47_contract_53_tc0 = tensor.cast %47 : tensor<2x4x4x5xf64> to tensor + + %v37_contract_53_tc2 = tensor.cast %37 : tensor<2x4x5x5xf64> to tensor + + %v53_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v47_contract_53_tc0, %52, %v37_contract_53_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %53 = tensor.cast %v53_tdyn : tensor to tensor<2x4x5x5xf64> + %55 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v50_contract_56_tc0 = tensor.cast %50 : tensor<2x4x5x5xf64> to tensor + + %v32_contract_56_tc2 = tensor.cast %32 : tensor<2x5x5x5xf64> to tensor + + %v56_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v50_contract_56_tc0, %55, %v32_contract_56_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %56 = tensor.cast %v56_tdyn : tensor to tensor<2x5x5x5xf64> + %58 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v53_contract_59_tc0 = tensor.cast %53 : tensor<2x4x5x5xf64> to tensor + + %v31_contract_59_tc2 = tensor.cast %31 : tensor<2x5x5x5xf64> to tensor + + %v59_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v53_contract_59_tc0, %58, %v31_contract_59_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %59 = tensor.cast %v59_tdyn : tensor to tensor<2x5x5x5xf64> + %61 = polygeist.submap(%4, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %62 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %v42_contract_63_tc2 = tensor.cast %42 : tensor<2x4x4x5xf64> to tensor + + %v63_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%62, %61, %v42_contract_63_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %63 = tensor.cast %v63_tdyn : tensor to tensor<2x4x4x5xf64> + %65 = polygeist.submap(%7, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %66 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %v41_contract_67_tc2 = tensor.cast %41 : tensor<2x4x4x5xf64> to tensor + + %v67_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%66, %65, %v41_contract_67_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %67 = tensor.cast %v67_tdyn : tensor to tensor<2x4x4x5xf64> + %69 = polygeist.submap(%8, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %v63_contract_70_tc0 = tensor.cast %63 : tensor<2x4x4x5xf64> to tensor + + %v36_contract_70_tc2 = tensor.cast %36 : tensor<2x4x5x5xf64> to tensor + + %v70_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v63_contract_70_tc0, %69, %v36_contract_70_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %70 = tensor.cast %v70_tdyn : tensor to tensor<2x4x5x5xf64> + %72 = polygeist.submap(%8, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %v67_contract_73_tc0 = tensor.cast %67 : tensor<2x4x4x5xf64> to tensor + + %v35_contract_73_tc2 = tensor.cast %35 : tensor<2x4x5x5xf64> to tensor + + %v73_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v67_contract_73_tc0, %72, %v35_contract_73_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %73 = tensor.cast %v73_tdyn : tensor to tensor<2x4x5x5xf64> + %75 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v70_contract_76_tc0 = tensor.cast %70 : tensor<2x4x5x5xf64> to tensor + + %v30_contract_76_tc2 = tensor.cast %30 : tensor<2x5x5x5xf64> to tensor + + %v76_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v70_contract_76_tc0, %75, %v30_contract_76_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %76 = tensor.cast %v76_tdyn : tensor to tensor<2x5x5x5xf64> + %78 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v73_contract_79_tc0 = tensor.cast %73 : tensor<2x4x5x5xf64> to tensor + + %v29_contract_79_tc2 = tensor.cast %29 : tensor<2x5x5x5xf64> to tensor + + %v79_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v73_contract_79_tc0, %78, %v29_contract_79_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %79 = tensor.cast %v79_tdyn : tensor to tensor<2x5x5x5xf64> + %81 = polygeist.submap(%4, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %82 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %v40_contract_83_tc2 = tensor.cast %40 : tensor<2x4x4x5xf64> to tensor + + %v83_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%82, %81, %v40_contract_83_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %83 = tensor.cast %v83_tdyn : tensor to tensor<2x4x4x5xf64> + %85 = polygeist.submap(%7, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %86 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %v39_contract_87_tc2 = tensor.cast %39 : tensor<2x4x4x5xf64> to tensor + + %v87_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%86, %85, %v39_contract_87_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %87 = tensor.cast %v87_tdyn : tensor to tensor<2x4x4x5xf64> + %89 = polygeist.submap(%7, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v83_contract_90_tc0 = tensor.cast %83 : tensor<2x4x4x5xf64> to tensor + + %v34_contract_90_tc2 = tensor.cast %34 : tensor<2x4x5x5xf64> to tensor + + %v90_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v83_contract_90_tc0, %89, %v34_contract_90_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %90 = tensor.cast %v90_tdyn : tensor to tensor<2x4x5x5xf64> + %92 = polygeist.submap(%4, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v87_contract_93_tc0 = tensor.cast %87 : tensor<2x4x4x5xf64> to tensor + + %v33_contract_93_tc2 = tensor.cast %33 : tensor<2x4x5x5xf64> to tensor + + %v93_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v87_contract_93_tc0, %92, %v33_contract_93_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %93 = tensor.cast %v93_tdyn : tensor to tensor<2x4x5x5xf64> + %95 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %v90_contract_96_tc0 = tensor.cast %90 : tensor<2x4x5x5xf64> to tensor + + %v28_contract_96_tc2 = tensor.cast %28 : tensor<2x5x5x5xf64> to tensor + + %v96_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v90_contract_96_tc0, %95, %v28_contract_96_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %96 = tensor.cast %v96_tdyn : tensor to tensor<2x5x5x5xf64> + %98 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %v93_contract_99_tc0 = tensor.cast %93 : tensor<2x4x5x5xf64> to tensor + + %v27_contract_99_tc2 = tensor.cast %27 : tensor<2x5x5x5xf64> to tensor + + %v99_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v93_contract_99_tc0, %98, %v27_contract_99_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %99 = tensor.cast %v99_tdyn : tensor to tensor<2x5x5x5xf64> + %100 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%26 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %101 = polygeist.submap(%6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %102 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %103 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %104 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %105 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%102, %99, %79, %103, %59, %96, %104, %76, %56, %101 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%100 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %107 = polygeist.submap(%5, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v105_contract_108_tc0 = tensor.cast %105 : tensor<2x5x5x4xf64> to tensor + + %v20_contract_108_tc2 = tensor.cast %20 : tensor<2x5x4x4xf64> to tensor + + %v108_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v105_contract_108_tc0, %107, %v20_contract_108_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %108 = tensor.cast %v108_tdyn : tensor to tensor<2x5x4x4xf64> + %110 = polygeist.submap(%3, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v108_contract_111_tc0 = tensor.cast %108 : tensor<2x5x4x4xf64> to tensor + + %v14_contract_111_tc2 = tensor.cast %14 : tensor<2x4x4x4xf64> to tensor + + %v111_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v108_contract_111_tc0, %110, %v14_contract_111_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %111 = tensor.cast %v111_tdyn : tensor to tensor<2x4x4x4xf64> + %112 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%25 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %113 = polygeist.submap(%6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %114 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %115 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %116 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %117 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%114, %99, %79, %115, %59, %96, %116, %76, %56, %113 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%112 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %119 = polygeist.submap(%3, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v117_contract_120_tc0 = tensor.cast %117 : tensor<2x5x5x4xf64> to tensor + + %v19_contract_120_tc2 = tensor.cast %19 : tensor<2x5x4x4xf64> to tensor + + %v120_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v117_contract_120_tc0, %119, %v19_contract_120_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %120 = tensor.cast %v120_tdyn : tensor to tensor<2x5x4x4xf64> + %122 = polygeist.submap(%5, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v120_contract_123_tc0 = tensor.cast %120 : tensor<2x5x4x4xf64> to tensor + + %v13_contract_123_tc2 = tensor.cast %13 : tensor<2x4x4x4xf64> to tensor + + %v123_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v120_contract_123_tc0, %122, %v13_contract_123_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %123 = tensor.cast %v123_tdyn : tensor to tensor<2x4x4x4xf64> + %124 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%24 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %125 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %126 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %127 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %128 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %129 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%126, %99, %79, %127, %59, %96, %128, %76, %56, %125 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%124 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %131 = polygeist.submap(%6, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v129_contract_132_tc0 = tensor.cast %129 : tensor<2x5x5x4xf64> to tensor + + %v18_contract_132_tc2 = tensor.cast %18 : tensor<2x5x4x4xf64> to tensor + + %v132_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v129_contract_132_tc0, %131, %v18_contract_132_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %132 = tensor.cast %v132_tdyn : tensor to tensor<2x5x4x4xf64> + %134 = polygeist.submap(%5, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v132_contract_135_tc0 = tensor.cast %132 : tensor<2x5x4x4xf64> to tensor + + %v12_contract_135_tc2 = tensor.cast %12 : tensor<2x4x4x4xf64> to tensor + + %v135_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v132_contract_135_tc0, %134, %v12_contract_135_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %135 = tensor.cast %v135_tdyn : tensor to tensor<2x4x4x4xf64> + %136 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%23 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %137 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %138 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %139 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %140 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %141 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%138, %99, %79, %139, %59, %96, %140, %76, %56, %137 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%136 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %143 = polygeist.submap(%6, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v141_contract_144_tc0 = tensor.cast %141 : tensor<2x5x5x4xf64> to tensor + + %v17_contract_144_tc2 = tensor.cast %17 : tensor<2x5x4x4xf64> to tensor + + %v144_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v141_contract_144_tc0, %143, %v17_contract_144_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %144 = tensor.cast %v144_tdyn : tensor to tensor<2x5x4x4xf64> + %146 = polygeist.submap(%3, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v144_contract_147_tc0 = tensor.cast %144 : tensor<2x5x4x4xf64> to tensor + + %v11_contract_147_tc2 = tensor.cast %11 : tensor<2x4x4x4xf64> to tensor + + %v147_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v144_contract_147_tc0, %146, %v11_contract_147_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %147 = tensor.cast %v147_tdyn : tensor to tensor<2x4x4x4xf64> + %148 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%22 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %149 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %150 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %151 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %152 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %153 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%150, %99, %79, %151, %59, %96, %152, %76, %56, %149 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%148 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %155 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v153_contract_156_tc0 = tensor.cast %153 : tensor<2x5x5x4xf64> to tensor + + %v16_contract_156_tc2 = tensor.cast %16 : tensor<2x5x4x4xf64> to tensor + + %v156_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v153_contract_156_tc0, %155, %v16_contract_156_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %156 = tensor.cast %v156_tdyn : tensor to tensor<2x5x4x4xf64> + %158 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v156_contract_159_tc0 = tensor.cast %156 : tensor<2x5x4x4xf64> to tensor + + %v10_contract_159_tc2 = tensor.cast %10 : tensor<2x4x4x4xf64> to tensor + + %v159_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v156_contract_159_tc0, %158, %v10_contract_159_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %159 = tensor.cast %v159_tdyn : tensor to tensor<2x4x4x4xf64> + %160 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%21 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %161 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %162 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %163 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %164 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %165 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%162, %99, %79, %163, %59, %96, %164, %76, %56, %161 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%160 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %167 = polygeist.submap(%5, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v165_contract_168_tc0 = tensor.cast %165 : tensor<2x5x5x4xf64> to tensor + + %v15_contract_168_tc2 = tensor.cast %15 : tensor<2x5x4x4xf64> to tensor + + %v168_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v165_contract_168_tc0, %167, %v15_contract_168_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %168 = tensor.cast %v168_tdyn : tensor to tensor<2x5x4x4xf64> + %170 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v168_contract_171_tc0 = tensor.cast %168 : tensor<2x5x4x4xf64> to tensor + + %v9_contract_171_tc2 = tensor.cast %9 : tensor<2x4x4x4xf64> to tensor + + %v171_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v168_contract_171_tc0, %170, %v9_contract_171_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %171 = tensor.cast %v171_tdyn : tensor to tensor<2x4x4x4xf64> + %172 = polygeist.submap(%0, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, index, index, index, index) -> tensor + %173 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%111, %123 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%172 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %174 = polygeist.submapInverse(%0, %173, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, tensor, index, index, index, index) -> tensor + %175 = polygeist.submap(%174, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, index, index, index, index) -> tensor + %176 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%135, %147 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%175 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %177 = polygeist.submapInverse(%174, %176, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, tensor, index, index, index, index) -> tensor + %178 = polygeist.submap(%177, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, index, index, index, index) -> tensor + %179 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%159, %171 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%178 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %180 = polygeist.submapInverse(%177, %179, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, tensor, index, index, index, index) -> tensor + %181 = bufferization.to_memref %180 : memref + memref.copy %181, %arg8 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d_partial.raised.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d_partial.raised.mlir new file mode 100644 index 000000000000..8e408d5ee5eb --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hcurl_3d_partial.raised.mlir @@ -0,0 +1,549 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 144)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 125)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 375)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 500)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 250)> +#map22 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 625)> +#map23 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 144)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map26 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_hcurl_3d_partial(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_13 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_14 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_15 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_16 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_21 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_22 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_23 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_24 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_25 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_26 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_27 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_28 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_29 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_30 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_31 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_32 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_33 = memref.alloca() : memref<2x4x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_33 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg7, %c2, %c4, %c4, %c5, %c3) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c3) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_33 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_28 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_33, %2 : memref<2x4x4x5xf64>, memref) outs(%alloca_28 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_27 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %3 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_33, %3 : memref<2x4x4x5xf64>, memref) outs(%alloca_27 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_22 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_28, %4 : memref<2x4x5x5xf64>, memref) outs(%alloca_22 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_21 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %5 = polygeist.submap(%arg4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_27, %5 : memref<2x4x5x5xf64>, memref) outs(%alloca_21 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_32 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg7, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (memref, index, index, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%6, %7 : memref, memref) outs(%alloca_32 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_31 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg7, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (memref, index, index, index, index, index) -> memref + %9 = polygeist.submap(%arg1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%8, %9 : memref, memref) outs(%alloca_31 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_26 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %10 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_32, %10 : memref<2x4x4x5xf64>, memref) outs(%alloca_26 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_25 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %11 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_31, %11 : memref<2x4x4x5xf64>, memref) outs(%alloca_25 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_20 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %12 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_26, %12 : memref<2x4x5x5xf64>, memref) outs(%alloca_20 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_19 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %13 = polygeist.submap(%arg4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_25, %13 : memref<2x4x5x5xf64>, memref) outs(%alloca_19 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_30 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg7, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %15 = polygeist.submap(%arg4, %c2, %c3, %c4, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%14, %15 : memref, memref) outs(%alloca_30 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_29 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %16 = polygeist.submap(%arg7, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %17 = polygeist.submap(%arg1, %c2, %c3, %c4, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%16, %17 : memref, memref) outs(%alloca_29 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_24 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %18 = polygeist.submap(%arg1, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_30, %18 : memref<2x4x4x5xf64>, memref) outs(%alloca_24 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_23 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %19 = polygeist.submap(%arg4, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_29, %19 : memref<2x4x4x5xf64>, memref) outs(%alloca_23 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_18 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %20 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_24, %20 : memref<2x4x5x5xf64>, memref) outs(%alloca_18 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_17 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %21 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_23, %21 : memref<2x4x5x5xf64>, memref) outs(%alloca_17 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_16 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %22 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %23 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %24 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %25 = polygeist.submap(%arg2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%22, %alloca_17, %alloca_19, %23, %alloca_21, %alloca_18, %24, %alloca_20, %alloca_22, %25 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_16 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_10 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %26 = polygeist.submap(%arg3, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_16, %26 : memref<2x5x5x4xf64>, memref) outs(%alloca_10 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_4 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %27 = polygeist.submap(%arg5, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_10, %27 : memref<2x5x4x4xf64>, memref) outs(%alloca_4 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_15 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %28 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %29 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %30 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map22} : (memref, index, index, index, index, index) -> memref + %31 = polygeist.submap(%arg2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%28, %alloca_17, %alloca_19, %29, %alloca_21, %alloca_18, %30, %alloca_20, %alloca_22, %31 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_15 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_9 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %32 = polygeist.submap(%arg5, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_15, %32 : memref<2x5x5x4xf64>, memref) outs(%alloca_9 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %33 = polygeist.submap(%arg3, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_9, %33 : memref<2x5x4x4xf64>, memref) outs(%alloca_3 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_14 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %34 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %35 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %36 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map22} : (memref, index, index, index, index, index) -> memref + %37 = polygeist.submap(%arg5, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%34, %alloca_17, %alloca_19, %35, %alloca_21, %alloca_18, %36, %alloca_20, %alloca_22, %37 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_14 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_8 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %38 = polygeist.submap(%arg2, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_14, %38 : memref<2x5x5x4xf64>, memref) outs(%alloca_8 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %39 = polygeist.submap(%arg3, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_8, %39 : memref<2x5x4x4xf64>, memref) outs(%alloca_2 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_13 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %40 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (memref, index, index, index, index, index) -> memref + %41 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %42 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %43 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%40, %alloca_17, %alloca_19, %41, %alloca_21, %alloca_18, %42, %alloca_20, %alloca_22, %43 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_13 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_7 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %44 = polygeist.submap(%arg2, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_13, %44 : memref<2x5x5x4xf64>, memref) outs(%alloca_7 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %45 = polygeist.submap(%arg5, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_7, %45 : memref<2x5x4x4xf64>, memref) outs(%alloca_1 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_12 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %46 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (memref, index, index, index, index, index) -> memref + %47 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %48 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %49 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%46, %alloca_17, %alloca_19, %47, %alloca_21, %alloca_18, %48, %alloca_20, %alloca_22, %49 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_12 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_6 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %50 = polygeist.submap(%arg5, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_12, %50 : memref<2x5x5x4xf64>, memref) outs(%alloca_6 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %51 = polygeist.submap(%arg2, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_6, %51 : memref<2x5x4x4xf64>, memref) outs(%alloca_0 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_11 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %52 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %53 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %54 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %55 = polygeist.submap(%arg5, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%52, %alloca_17, %alloca_19, %53, %alloca_21, %alloca_18, %54, %alloca_20, %alloca_22, %55 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_11 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_5 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %56 = polygeist.submap(%arg3, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_11, %56 : memref<2x5x5x4xf64>, memref) outs(%alloca_5 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %57 = polygeist.submap(%arg2, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_5, %57 : memref<2x5x4x4xf64>, memref) outs(%alloca : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + %58 = polygeist.submap(%arg8, %c2, %c4, %c4, %c3) {map = #map24} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%alloca_4, %alloca_3 : memref<2x4x4x4xf64>, memref<2x4x4x4xf64>) outs(%58 : memref) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.subf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + %59 = polygeist.submap(%arg8, %c2, %c4, %c3, %c4) {map = #map25} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%alloca_2, %alloca_1 : memref<2x4x4x4xf64>, memref<2x4x4x4xf64>) outs(%59 : memref) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.subf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + %60 = polygeist.submap(%arg8, %c2, %c3, %c4, %c4) {map = #map26} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%alloca_0, %alloca : memref<2x4x4x4xf64>, memref<2x4x4x4xf64>) outs(%60 : memref) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.subf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d.debufferized.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d.debufferized.mlir new file mode 100644 index 000000000000..2e75c9cd6a25 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d.debufferized.mlir @@ -0,0 +1,430 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 108)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 125 + d1 * 25 + d2 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 108)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map21 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map22 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 3)> +#map23 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 3)> +#map24 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 4)> +#map25 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 4 + d0 * 108)> +#map26 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map27 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +#map28 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 3)> +#map29 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 4)> +#map30 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 3 + d0 * 108 + 36)> +#map31 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 4)> +#map32 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 9 + d5 * 3 + d0 * 108 + 72)> +#map33 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750)> +#map34 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 125)> +#map35 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 250)> +#map36 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 375)> +#map37 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 500)> +#map38 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 625)> +#map39 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 5)> +#map40 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 5)> +#map41 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 5)> +#map42 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_hdiv_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg9 : memref + %1 = bufferization.to_tensor %arg8 : memref + %2 = bufferization.to_tensor %arg7 : memref + %3 = bufferization.to_tensor %arg6 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg3 : memref + %7 = bufferization.to_tensor %arg2 : memref + %8 = bufferization.to_tensor %arg1 : memref + %9 = bufferization.to_tensor %arg0 : memref + %10 = tensor.empty() : tensor<2x5x4x4xf64> + %11 = tensor.empty() : tensor<2x5x4x4xf64> + %12 = tensor.empty() : tensor<2x5x4x4xf64> + %13 = tensor.empty() : tensor<2x5x5x4xf64> + %14 = tensor.empty() : tensor<2x5x5x4xf64> + %15 = tensor.empty() : tensor<2x5x5x4xf64> + %16 = tensor.empty() : tensor<2x5x5x5xf64> + %17 = tensor.empty() : tensor<2x5x5x5xf64> + %18 = tensor.empty() : tensor<2x5x5x5xf64> + %19 = tensor.empty() : tensor<2x4x5x5xf64> + %20 = tensor.empty() : tensor<2x4x5x5xf64> + %21 = tensor.empty() : tensor<2x4x5x5xf64> + %22 = tensor.empty() : tensor<2x4x4x5xf64> + %23 = tensor.empty() : tensor<2x4x4x5xf64> + %24 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice = tensor.extract_slice %24[0, 0, 0, 0] [%c2, %c3, %c3, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %26 = polygeist.submap(%5, %c2, %c3, %c3, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %27 = polygeist.submap(%1, %c2, %c3, %c3, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%27, %26 : tensor, tensor) outs(%25 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %21[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %29 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_0 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %30 = polygeist.submap(%9, %c2, %c3, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %31 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%28, %30 : tensor, tensor) outs(%29 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_1 = tensor.extract_slice %18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %32 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_1 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %33 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %34 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%31, %33 : tensor, tensor) outs(%32 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_2 = tensor.extract_slice %23[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %35 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_2 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %36 = polygeist.submap(%9, %c2, %c3, %c4, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %37 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c3) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %38 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%37, %36 : tensor, tensor) outs(%35 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_3 = tensor.extract_slice %20[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %39 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_3 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %40 = polygeist.submap(%5, %c2, %c3, %c5, %c5, %c4) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %41 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%38, %40 : tensor, tensor) outs(%39 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_4 = tensor.extract_slice %17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %42 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_4 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %43 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %44 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%41, %43 : tensor, tensor) outs(%42 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_5 = tensor.extract_slice %22[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %45 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_5 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %46 = polygeist.submap(%9, %c2, %c4, %c3, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %47 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c3) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %48 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%47, %46 : tensor, tensor) outs(%45 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_6 = tensor.extract_slice %19[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %49 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_6 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %50 = polygeist.submap(%9, %c2, %c4, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %51 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%48, %50 : tensor, tensor) outs(%49 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_7 = tensor.extract_slice %16[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %52 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_7 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %53 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %54 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%51, %53 : tensor, tensor) outs(%52 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_8 = tensor.extract_slice %15[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_8 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %56 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %57 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %58 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%57, %34, %44, %54, %56 : tensor, tensor, tensor, tensor, tensor) outs(%55 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %in_27: f64, %out: f64): + %136 = arith.addf %in_24, %in_25 : f64 + %137 = arith.addf %136, %in_26 : f64 + %138 = arith.mulf %in, %137 : f64 + %139 = arith.mulf %138, %in_27 : f64 + %140 = arith.addf %out, %139 : f64 + linalg.yield %140 : f64 + } -> tensor + %extracted_slice_9 = tensor.extract_slice %14[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %59 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_9 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %60 = polygeist.submap(%7, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %61 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %62 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%61, %34, %44, %54, %60 : tensor, tensor, tensor, tensor, tensor) outs(%59 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %in_27: f64, %out: f64): + %136 = arith.addf %in_24, %in_25 : f64 + %137 = arith.addf %136, %in_26 : f64 + %138 = arith.mulf %in, %137 : f64 + %139 = arith.mulf %138, %in_27 : f64 + %140 = arith.addf %out, %139 : f64 + linalg.yield %140 : f64 + } -> tensor + %extracted_slice_10 = tensor.extract_slice %13[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_10 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %64 = polygeist.submap(%7, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %65 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %66 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%65, %34, %44, %54, %64 : tensor, tensor, tensor, tensor, tensor) outs(%63 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %in_27: f64, %out: f64): + %136 = arith.addf %in_24, %in_25 : f64 + %137 = arith.addf %136, %in_26 : f64 + %138 = arith.mulf %in, %137 : f64 + %139 = arith.mulf %138, %in_27 : f64 + %140 = arith.addf %out, %139 : f64 + linalg.yield %140 : f64 + } -> tensor + %extracted_slice_11 = tensor.extract_slice %12[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %67 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_11 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %68 = polygeist.submap(%7, %c2, %c5, %c3, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %69 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%58, %68 : tensor, tensor) outs(%67 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_12 = tensor.extract_slice %11[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %70 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_12 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %71 = polygeist.submap(%4, %c2, %c5, %c4, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %72 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%62, %71 : tensor, tensor) outs(%70 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_13 = tensor.extract_slice %10[0, 0, 0, 0] [%c2, %c5, %c3, %c3] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %73 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_13 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %74 = polygeist.submap(%7, %c2, %c5, %c3, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %75 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%66, %74 : tensor, tensor) outs(%73 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %76 = polygeist.submap(%7, %c2, %c3, %c3, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %77 = polygeist.submap(%0, %c2, %c3, %c3, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor<2x3x3x4xf64> + %78 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%69, %76 : tensor, tensor) outs(%77 : tensor<2x3x3x4xf64>) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor<2x3x3x4xf64> + %79 = polygeist.submapInverse(%0, %78, %c2, %c3, %c3, %c4) {map = #map19} : (tensor, tensor<2x3x3x4xf64>, index, index, index, index) -> tensor + %80 = polygeist.submap(%7, %c2, %c3, %c4, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %81 = polygeist.submap(%79, %c2, %c3, %c4, %c3) {map = #map20} : (tensor, index, index, index, index) -> tensor<2x3x4x3xf64> + %82 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%72, %80 : tensor, tensor) outs(%81 : tensor<2x3x4x3xf64>) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor<2x3x4x3xf64> + %83 = polygeist.submapInverse(%79, %82, %c2, %c3, %c4, %c3) {map = #map20} : (tensor, tensor<2x3x4x3xf64>, index, index, index, index) -> tensor + %84 = polygeist.submap(%4, %c2, %c4, %c3, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %85 = polygeist.submap(%83, %c2, %c4, %c3, %c3) {map = #map21} : (tensor, index, index, index, index) -> tensor<2x4x3x3xf64> + %86 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%75, %84 : tensor, tensor) outs(%85 : tensor<2x4x3x3xf64>) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor<2x4x3x3xf64> + %87 = polygeist.submapInverse(%83, %86, %c2, %c4, %c3, %c3) {map = #map21} : (tensor, tensor<2x4x3x3xf64>, index, index, index, index) -> tensor + %88 = tensor.empty() : tensor<2x3x5x5x5xf64> + %extracted_slice_14 = tensor.extract_slice %88[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %89 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_14 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %90 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map22} : (tensor, index, index, index, index, index, index, index) -> tensor + %91 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map23} : (tensor, index, index, index, index, index, index, index) -> tensor + %92 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map24} : (tensor, index, index, index, index, index, index, index) -> tensor + %93 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map25} : (tensor, index, index, index, index, index, index, index) -> tensor + %94 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%90, %91, %93, %92 : tensor, tensor, tensor, tensor) outs(%89 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %94 into %88[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_15 = tensor.extract_slice %inserted_slice[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %95 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_15 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %96 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map22} : (tensor, index, index, index, index, index, index, index) -> tensor + %97 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map28} : (tensor, index, index, index, index, index, index, index) -> tensor + %98 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map29} : (tensor, index, index, index, index, index, index, index) -> tensor + %99 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map30} : (tensor, index, index, index, index, index, index, index) -> tensor + %100 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%96, %98, %99, %97 : tensor, tensor, tensor, tensor) outs(%95 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %inserted_slice_16 = tensor.insert_slice %100 into %inserted_slice[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_17 = tensor.extract_slice %inserted_slice_16[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %101 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_17 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %102 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map23} : (tensor, index, index, index, index, index, index, index) -> tensor + %103 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map28} : (tensor, index, index, index, index, index, index, index) -> tensor + %104 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map31} : (tensor, index, index, index, index, index, index, index) -> tensor + %105 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map32} : (tensor, index, index, index, index, index, index, index) -> tensor + %106 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%104, %102, %105, %103 : tensor, tensor, tensor, tensor) outs(%101 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %inserted_slice_18 = tensor.insert_slice %106 into %inserted_slice_16[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_19 = tensor.extract_slice %inserted_slice_18[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %extracted_slice_20 = tensor.extract_slice %inserted_slice_18[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %107 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map33} : (tensor, index, index, index, index) -> tensor + %108 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map34} : (tensor, index, index, index, index) -> tensor + %109 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map35} : (tensor, index, index, index, index) -> tensor + %110 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map34} : (tensor, index, index, index, index) -> tensor + %111 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map36} : (tensor, index, index, index, index) -> tensor + %112 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map37} : (tensor, index, index, index, index) -> tensor + %113 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map35} : (tensor, index, index, index, index) -> tensor + %114 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map37} : (tensor, index, index, index, index) -> tensor + %115 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map38} : (tensor, index, index, index, index) -> tensor + %116:3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%107, %108, %109, %110, %111, %112, %113, %114, %115 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_19, %extracted_slice_20, %106 : tensor, tensor, tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %in_27: f64, %in_28: f64, %in_29: f64, %in_30: f64, %in_31: f64, %out: f64, %out_32: f64, %out_33: f64): + %136 = arith.mulf %in, %out : f64 + %137 = arith.mulf %in_24, %out_32 : f64 + %138 = arith.addf %136, %137 : f64 + %139 = arith.mulf %in_25, %out_33 : f64 + %140 = arith.addf %138, %139 : f64 + %141 = arith.mulf %in_26, %out : f64 + %142 = arith.mulf %in_27, %out_32 : f64 + %143 = arith.addf %141, %142 : f64 + %144 = arith.mulf %in_28, %out_33 : f64 + %145 = arith.addf %143, %144 : f64 + %146 = arith.mulf %in_29, %out : f64 + %147 = arith.mulf %in_30, %out_32 : f64 + %148 = arith.addf %146, %147 : f64 + %149 = arith.mulf %in_31, %out_33 : f64 + %150 = arith.addf %148, %149 : f64 + linalg.yield %140, %145, %150 : f64, f64, f64 + } -> (tensor, tensor, tensor) + %inserted_slice_21 = tensor.insert_slice %116#2 into %inserted_slice_16[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_22 = tensor.extract_slice %inserted_slice_21[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %117 = polygeist.submap(%7, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index, index, index, index) -> tensor + %118 = polygeist.submap(%7, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index, index, index, index) -> tensor + %119 = polygeist.submap(%6, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map41} : (tensor, index, index, index, index, index, index, index) -> tensor + %120 = polygeist.submap(%87, %c2, %c3, %c3, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %121 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%117, %118, %extracted_slice_22, %119 : tensor, tensor, tensor, tensor) outs(%120 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %122 = polygeist.submapInverse(%87, %121, %c2, %c3, %c3, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %extracted_slice_23 = tensor.extract_slice %inserted_slice_21[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %123 = polygeist.submap(%7, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index, index, index, index) -> tensor + %124 = polygeist.submap(%7, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map41} : (tensor, index, index, index, index, index, index, index) -> tensor + %125 = polygeist.submap(%6, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index, index, index, index) -> tensor + %126 = polygeist.submap(%122, %c2, %c3, %c4, %c3) {map = #map20} : (tensor, index, index, index, index) -> tensor + %127 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%123, %125, %extracted_slice_23, %124 : tensor, tensor, tensor, tensor) outs(%126 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %128 = polygeist.submapInverse(%122, %127, %c2, %c3, %c4, %c3) {map = #map20} : (tensor, tensor, index, index, index, index) -> tensor + %129 = polygeist.submap(%7, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index, index, index, index) -> tensor + %130 = polygeist.submap(%7, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map41} : (tensor, index, index, index, index, index, index, index) -> tensor + %131 = polygeist.submap(%6, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index, index, index, index) -> tensor + %132 = polygeist.submap(%128, %c2, %c4, %c3, %c3) {map = #map21} : (tensor, index, index, index, index) -> tensor + %133 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%131, %129, %116#2, %130 : tensor, tensor, tensor, tensor) outs(%132 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %134 = polygeist.submapInverse(%128, %133, %c2, %c4, %c3, %c3) {map = #map21} : (tensor, tensor, index, index, index, index) -> tensor + %135 = bufferization.to_memref %134 : memref + memref.copy %135, %arg9 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d.frontend.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d.frontend.mlir new file mode 100644 index 000000000000..d4f9bed8438c --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d.frontend.mlir @@ -0,0 +1,1070 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_hdiv_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_8 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg8[%arg11 * 12 + %arg14 + %arg12 * 4 + %arg10 * 108] : memref + %2 = affine.load %arg4[%arg14 + %arg13 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg14 + %arg12 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg14 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg8[%arg11 * 12 + %arg14 + %arg12 * 3 + %arg10 * 108 + 36] : memref + %2 = affine.load %arg0[%arg14 + %arg13 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg14 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg14 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg8[%arg11 * 9 + %arg14 + %arg12 * 3 + %arg10 * 108 + 72] : memref + %2 = affine.load %arg0[%arg14 + %arg13 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg14 + %arg12 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg14 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 125 + %arg14 + %arg11 * 25 + %arg12 * 5] : memref + %2 = affine.load %alloca_7[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg5[%arg14 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg15, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_4[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 125 + %arg14 + %arg11 * 25 + %arg12 * 5] : memref + %2 = affine.load %alloca_7[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg2[%arg14 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg15, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_3[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 125 + %arg14 + %arg11 * 25 + %arg12 * 5] : memref + %2 = affine.load %alloca_7[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg2[%arg14 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg15, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_2[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %alloca_1[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %4 = affine.load %arg2[%arg14 + %arg11 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg15, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg9[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg10 * 108] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg10 * 108] : memref + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %alloca_0[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %4 = affine.load %arg2[%arg14 + %arg11 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg15, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg9[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg10 * 108 + 36] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg10 * 108 + 36] : memref + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %4 = affine.load %arg5[%arg14 + %arg11 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg15, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg9[%arg11 * 9 + %arg13 + %arg12 * 3 + %arg10 * 108 + 72] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 9 + %arg13 + %arg12 * 3 + %arg10 * 108 + 72] : memref + } + } + } + } + %alloca_14 = memref.alloca() : memref<2x3x5x5x5xf64> + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg14 + %arg11 * 3] : memref + %2 = affine.for %arg16 = 0 to 3 iter_args(%arg17 = %arg15) -> (f64) { + %3 = affine.load %arg0[%arg16 + %arg12 * 3] : memref + %4 = affine.for %arg18 = 0 to 4 iter_args(%arg19 = %arg17) -> (f64) { + %5 = affine.load %arg8[%arg14 * 12 + %arg18 + %arg16 * 4 + %arg10 * 108] : memref + %6 = affine.load %arg1[%arg18 + %arg13 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg19, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca_14[%arg10, 0, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg14 + %arg11 * 3] : memref + %2 = affine.for %arg16 = 0 to 4 iter_args(%arg17 = %arg15) -> (f64) { + %3 = affine.load %arg1[%arg16 + %arg12 * 4] : memref + %4 = affine.for %arg18 = 0 to 3 iter_args(%arg19 = %arg17) -> (f64) { + %5 = affine.load %arg8[%arg14 * 12 + %arg18 + %arg16 * 3 + %arg10 * 108 + 36] : memref + %6 = affine.load %arg0[%arg18 + %arg13 * 3] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg19, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca_14[%arg10, 1, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg14 + %arg11 * 4] : memref + %2 = affine.for %arg16 = 0 to 3 iter_args(%arg17 = %arg15) -> (f64) { + %3 = affine.load %arg0[%arg16 + %arg12 * 3] : memref + %4 = affine.for %arg18 = 0 to 3 iter_args(%arg19 = %arg17) -> (f64) { + %5 = affine.load %arg8[%arg14 * 9 + %arg18 + %arg16 * 3 + %arg10 * 108 + 72] : memref + %6 = affine.load %arg0[%arg18 + %arg13 * 3] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg19, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca_14[%arg10, 2, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.load %alloca_14[%arg10, 0, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %1 = affine.load %alloca_14[%arg10, 1, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %2 = affine.load %alloca_14[%arg10, 2, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %3 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750] : memref + %4 = arith.mulf %3, %0 : f64 + %5 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 125] : memref + %6 = arith.mulf %5, %1 : f64 + %7 = arith.addf %4, %6 : f64 + %8 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 250] : memref + %9 = arith.mulf %8, %2 : f64 + %10 = arith.addf %7, %9 : f64 + affine.store %10, %alloca_14[%arg10, 0, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %11 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 125] : memref + %12 = arith.mulf %11, %0 : f64 + %13 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 375] : memref + %14 = arith.mulf %13, %1 : f64 + %15 = arith.addf %12, %14 : f64 + %16 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 500] : memref + %17 = arith.mulf %16, %2 : f64 + %18 = arith.addf %15, %17 : f64 + affine.store %18, %alloca_14[%arg10, 1, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %19 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 250] : memref + %20 = arith.mulf %19, %0 : f64 + %21 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 500] : memref + %22 = arith.mulf %21, %1 : f64 + %23 = arith.addf %20, %22 : f64 + %24 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 625] : memref + %25 = arith.mulf %24, %2 : f64 + %26 = arith.addf %23, %25 : f64 + affine.store %26, %alloca_14[%arg10, 2, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %arg2[%arg14 + %arg11 * 5] : memref + %4 = affine.for %arg16 = 0 to 5 iter_args(%arg17 = %arg15) -> (f64) { + %5 = affine.load %arg2[%arg16 + %arg12 * 5] : memref + %6 = affine.for %arg18 = 0 to 5 iter_args(%arg19 = %arg17) -> (f64) { + %7 = affine.load %alloca_14[%arg10, 0, %arg14, %arg16, %arg18] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg3[%arg18 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg19, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg9[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg10 * 108] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg10 * 108] : memref + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %arg2[%arg14 + %arg11 * 5] : memref + %4 = affine.for %arg16 = 0 to 5 iter_args(%arg17 = %arg15) -> (f64) { + %5 = affine.load %arg3[%arg16 + %arg12 * 5] : memref + %6 = affine.for %arg18 = 0 to 5 iter_args(%arg19 = %arg17) -> (f64) { + %7 = affine.load %alloca_14[%arg10, 1, %arg14, %arg16, %arg18] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg2[%arg18 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg19, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg9[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg10 * 108 + 36] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg10 * 108 + 36] : memref + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %arg3[%arg14 + %arg11 * 5] : memref + %4 = affine.for %arg16 = 0 to 5 iter_args(%arg17 = %arg15) -> (f64) { + %5 = affine.load %arg2[%arg16 + %arg12 * 5] : memref + %6 = affine.for %arg18 = 0 to 5 iter_args(%arg19 = %arg17) -> (f64) { + %7 = affine.load %alloca_14[%arg10, 2, %arg14, %arg16, %arg18] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg2[%arg18 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg19, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg9[%arg11 * 9 + %arg13 + %arg12 * 3 + %arg10 * 108 + 72] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 9 + %arg13 + %arg12 * 3 + %arg10 * 108 + 72] : memref + } + } + } + } + return + } + func.func @mfem_pa_divdiv_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_8 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 12 + %arg11 + %arg9 * 4 + %arg7 * 108] : memref + %2 = affine.load %arg2[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 12 + %arg11 + %arg9 * 3 + %arg7 * 108 + 36] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 9 + %arg11 + %arg9 * 3 + %arg7 * 108 + 72] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg3[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg1[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg1[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca_1[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg1[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca_0[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg1[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + } + } + } + } + return + } + func.func @mfem_pa_hdiv_mass_apply_3d_direct(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x3x5x5x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %2 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %arg12) -> (f64) { + %3 = affine.load %arg0[%arg13 + %arg9 * 3] : memref + %4 = affine.for %arg15 = 0 to 4 iter_args(%arg16 = %arg14) -> (f64) { + %5 = affine.load %arg5[%arg11 * 12 + %arg15 + %arg13 * 4 + %arg7 * 108] : memref + %6 = affine.load %arg1[%arg15 + %arg10 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg16, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca[%arg7, 0, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %2 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %arg12) -> (f64) { + %3 = affine.load %arg1[%arg13 + %arg9 * 4] : memref + %4 = affine.for %arg15 = 0 to 3 iter_args(%arg16 = %arg14) -> (f64) { + %5 = affine.load %arg5[%arg11 * 12 + %arg15 + %arg13 * 3 + %arg7 * 108 + 36] : memref + %6 = affine.load %arg0[%arg15 + %arg10 * 3] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg16, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca[%arg7, 1, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg11 + %arg8 * 4] : memref + %2 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %arg12) -> (f64) { + %3 = affine.load %arg0[%arg13 + %arg9 * 3] : memref + %4 = affine.for %arg15 = 0 to 3 iter_args(%arg16 = %arg14) -> (f64) { + %5 = affine.load %arg5[%arg11 * 9 + %arg15 + %arg13 * 3 + %arg7 * 108 + 72] : memref + %6 = affine.load %arg0[%arg15 + %arg10 * 3] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg16, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca[%arg7, 2, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.load %alloca[%arg7, 0, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %1 = affine.load %alloca[%arg7, 1, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %2 = affine.load %alloca[%arg7, 2, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %3 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750] : memref + %4 = arith.mulf %3, %0 : f64 + %5 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 125] : memref + %6 = arith.mulf %5, %1 : f64 + %7 = arith.addf %4, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 250] : memref + %9 = arith.mulf %8, %2 : f64 + %10 = arith.addf %7, %9 : f64 + affine.store %10, %alloca[%arg7, 0, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %11 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 125] : memref + %12 = arith.mulf %11, %0 : f64 + %13 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 375] : memref + %14 = arith.mulf %13, %1 : f64 + %15 = arith.addf %12, %14 : f64 + %16 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 500] : memref + %17 = arith.mulf %16, %2 : f64 + %18 = arith.addf %15, %17 : f64 + affine.store %18, %alloca[%arg7, 1, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %19 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 250] : memref + %20 = arith.mulf %19, %0 : f64 + %21 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 500] : memref + %22 = arith.mulf %21, %1 : f64 + %23 = arith.addf %20, %22 : f64 + %24 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 625] : memref + %25 = arith.mulf %24, %2 : f64 + %26 = arith.addf %23, %25 : f64 + affine.store %26, %alloca[%arg7, 2, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %4 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %arg12) -> (f64) { + %5 = affine.load %arg2[%arg13 + %arg9 * 5] : memref + %6 = affine.for %arg15 = 0 to 5 iter_args(%arg16 = %arg14) -> (f64) { + %7 = affine.load %alloca[%arg7, 0, %arg11, %arg13, %arg15] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg3[%arg15 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg16, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %4 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %arg12) -> (f64) { + %5 = affine.load %arg3[%arg13 + %arg9 * 5] : memref + %6 = affine.for %arg15 = 0 to 5 iter_args(%arg16 = %arg14) -> (f64) { + %7 = affine.load %alloca[%arg7, 1, %arg11, %arg13, %arg15] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg2[%arg15 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg16, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %4 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %arg12) -> (f64) { + %5 = affine.load %arg2[%arg13 + %arg9 * 5] : memref + %6 = affine.for %arg15 = 0 to 5 iter_args(%arg16 = %arg14) -> (f64) { + %7 = affine.load %alloca[%arg7, 2, %arg11, %arg13, %arg15] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg2[%arg15 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg16, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d.matched.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d.matched.mlir new file mode 100644 index 000000000000..8a4469cc68bd --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d.matched.mlir @@ -0,0 +1,322 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 108)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 125 + d1 * 25 + d2 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 108)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map21 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map22 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 3)> +#map23 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 3)> +#map24 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 4)> +#map25 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 4 + d0 * 108)> +#map26 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map27 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +#map28 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 3)> +#map29 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 4)> +#map30 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 3 + d0 * 108 + 36)> +#map31 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 4)> +#map32 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 9 + d5 * 3 + d0 * 108 + 72)> +#map33 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750)> +#map34 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 125)> +#map35 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 250)> +#map36 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 375)> +#map37 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 500)> +#map38 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 625)> +#map39 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 5)> +#map40 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 5)> +#map41 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 5)> +#map42 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_hdiv_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg9 : memref + %1 = bufferization.to_tensor %arg8 : memref + %2 = bufferization.to_tensor %arg7 : memref + %3 = bufferization.to_tensor %arg6 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg3 : memref + %7 = bufferization.to_tensor %arg2 : memref + %8 = bufferization.to_tensor %arg1 : memref + %9 = bufferization.to_tensor %arg0 : memref + %10 = tensor.empty() : tensor<2x5x4x4xf64> + %11 = tensor.empty() : tensor<2x5x4x4xf64> + %12 = tensor.empty() : tensor<2x5x4x4xf64> + %13 = tensor.empty() : tensor<2x5x5x4xf64> + %14 = tensor.empty() : tensor<2x5x5x4xf64> + %15 = tensor.empty() : tensor<2x5x5x4xf64> + %16 = tensor.empty() : tensor<2x5x5x5xf64> + %17 = tensor.empty() : tensor<2x5x5x5xf64> + %18 = tensor.empty() : tensor<2x5x5x5xf64> + %19 = tensor.empty() : tensor<2x4x5x5xf64> + %20 = tensor.empty() : tensor<2x4x5x5xf64> + %21 = tensor.empty() : tensor<2x4x5x5xf64> + %22 = tensor.empty() : tensor<2x4x4x5xf64> + %23 = tensor.empty() : tensor<2x4x4x5xf64> + %24 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice = tensor.extract_slice %24[0, 0, 0, 0] [%c2, %c3, %c3, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %26 = polygeist.submap(%5, %c2, %c3, %c3, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %27 = polygeist.submap(%1, %c2, %c3, %c3, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %28 = kernel.launch @cutensornetContraction2_f64_r5r5r4(%27, %26, %extracted_slice) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_0 = tensor.extract_slice %21[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %30 = polygeist.submap(%9, %c2, %c3, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %31 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%28, %30, %extracted_slice_0) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_1 = tensor.extract_slice %18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %33 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %34 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%31, %33, %extracted_slice_1) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_2 = tensor.extract_slice %23[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %36 = polygeist.submap(%9, %c2, %c3, %c4, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %37 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c3) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %38 = kernel.launch @cutensornetContraction2_f64_r5r5r4(%37, %36, %extracted_slice_2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_3 = tensor.extract_slice %20[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %40 = polygeist.submap(%5, %c2, %c3, %c5, %c5, %c4) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %41 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%38, %40, %extracted_slice_3) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_4 = tensor.extract_slice %17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %43 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %44 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%41, %43, %extracted_slice_4) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_5 = tensor.extract_slice %22[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %46 = polygeist.submap(%9, %c2, %c4, %c3, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %47 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c3) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %48 = kernel.launch @cutensornetContraction2_f64_r5r5r4(%47, %46, %extracted_slice_5) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_6 = tensor.extract_slice %19[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %50 = polygeist.submap(%9, %c2, %c4, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %51 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%48, %50, %extracted_slice_6) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_7 = tensor.extract_slice %16[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %53 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %54 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%51, %53, %extracted_slice_7) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_8 = tensor.extract_slice %15[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_8 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %56 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %57 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %58 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%57, %34, %44, %54, %56 : tensor, tensor, tensor, tensor, tensor) outs(%55 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %in_27: f64, %out: f64): + %136 = arith.addf %in_24, %in_25 : f64 + %137 = arith.addf %136, %in_26 : f64 + %138 = arith.mulf %in, %137 : f64 + %139 = arith.mulf %138, %in_27 : f64 + %140 = arith.addf %out, %139 : f64 + linalg.yield %140 : f64 + } -> tensor + %extracted_slice_9 = tensor.extract_slice %14[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %59 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_9 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %60 = polygeist.submap(%7, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %61 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %62 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%61, %34, %44, %54, %60 : tensor, tensor, tensor, tensor, tensor) outs(%59 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %in_27: f64, %out: f64): + %136 = arith.addf %in_24, %in_25 : f64 + %137 = arith.addf %136, %in_26 : f64 + %138 = arith.mulf %in, %137 : f64 + %139 = arith.mulf %138, %in_27 : f64 + %140 = arith.addf %out, %139 : f64 + linalg.yield %140 : f64 + } -> tensor + %extracted_slice_10 = tensor.extract_slice %13[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_10 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %64 = polygeist.submap(%7, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %65 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %66 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%65, %34, %44, %54, %64 : tensor, tensor, tensor, tensor, tensor) outs(%63 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %in_27: f64, %out: f64): + %136 = arith.addf %in_24, %in_25 : f64 + %137 = arith.addf %136, %in_26 : f64 + %138 = arith.mulf %in, %137 : f64 + %139 = arith.mulf %138, %in_27 : f64 + %140 = arith.addf %out, %139 : f64 + linalg.yield %140 : f64 + } -> tensor + %extracted_slice_11 = tensor.extract_slice %12[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %68 = polygeist.submap(%7, %c2, %c5, %c3, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %69 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%58, %68, %extracted_slice_11) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_12 = tensor.extract_slice %11[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %71 = polygeist.submap(%4, %c2, %c5, %c4, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %72 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%62, %71, %extracted_slice_12) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_13 = tensor.extract_slice %10[0, 0, 0, 0] [%c2, %c5, %c3, %c3] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %74 = polygeist.submap(%7, %c2, %c5, %c3, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %75 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%66, %74, %extracted_slice_13) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %76 = polygeist.submap(%7, %c2, %c3, %c3, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %77 = polygeist.submap(%0, %c2, %c3, %c3, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor<2x3x3x4xf64> + %78 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%69, %76 : tensor, tensor) outs(%77 : tensor<2x3x3x4xf64>) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor<2x3x3x4xf64> + %79 = polygeist.submapInverse(%0, %78, %c2, %c3, %c3, %c4) {map = #map19} : (tensor, tensor<2x3x3x4xf64>, index, index, index, index) -> tensor + %80 = polygeist.submap(%7, %c2, %c3, %c4, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %81 = polygeist.submap(%79, %c2, %c3, %c4, %c3) {map = #map20} : (tensor, index, index, index, index) -> tensor<2x3x4x3xf64> + %82 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%72, %80 : tensor, tensor) outs(%81 : tensor<2x3x4x3xf64>) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor<2x3x4x3xf64> + %83 = polygeist.submapInverse(%79, %82, %c2, %c3, %c4, %c3) {map = #map20} : (tensor, tensor<2x3x4x3xf64>, index, index, index, index) -> tensor + %84 = polygeist.submap(%4, %c2, %c4, %c3, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %85 = polygeist.submap(%83, %c2, %c4, %c3, %c3) {map = #map21} : (tensor, index, index, index, index) -> tensor<2x4x3x3xf64> + %86 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%75, %84 : tensor, tensor) outs(%85 : tensor<2x4x3x3xf64>) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor<2x4x3x3xf64> + %87 = polygeist.submapInverse(%83, %86, %c2, %c4, %c3, %c3) {map = #map21} : (tensor, tensor<2x4x3x3xf64>, index, index, index, index) -> tensor + %88 = tensor.empty() : tensor<2x3x5x5x5xf64> + %extracted_slice_14 = tensor.extract_slice %88[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %89 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_14 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %90 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map22} : (tensor, index, index, index, index, index, index, index) -> tensor + %91 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map23} : (tensor, index, index, index, index, index, index, index) -> tensor + %92 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map24} : (tensor, index, index, index, index, index, index, index) -> tensor + %93 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map25} : (tensor, index, index, index, index, index, index, index) -> tensor + %94 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%90, %91, %93, %92 : tensor, tensor, tensor, tensor) outs(%89 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %94 into %88[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_15 = tensor.extract_slice %inserted_slice[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %95 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_15 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %96 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map22} : (tensor, index, index, index, index, index, index, index) -> tensor + %97 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map28} : (tensor, index, index, index, index, index, index, index) -> tensor + %98 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map29} : (tensor, index, index, index, index, index, index, index) -> tensor + %99 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map30} : (tensor, index, index, index, index, index, index, index) -> tensor + %100 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%96, %98, %99, %97 : tensor, tensor, tensor, tensor) outs(%95 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %inserted_slice_16 = tensor.insert_slice %100 into %inserted_slice[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_17 = tensor.extract_slice %inserted_slice_16[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %101 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_17 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %102 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map23} : (tensor, index, index, index, index, index, index, index) -> tensor + %103 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map28} : (tensor, index, index, index, index, index, index, index) -> tensor + %104 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map31} : (tensor, index, index, index, index, index, index, index) -> tensor + %105 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map32} : (tensor, index, index, index, index, index, index, index) -> tensor + %106 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%104, %102, %105, %103 : tensor, tensor, tensor, tensor) outs(%101 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %inserted_slice_18 = tensor.insert_slice %106 into %inserted_slice_16[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_19 = tensor.extract_slice %inserted_slice_18[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %extracted_slice_20 = tensor.extract_slice %inserted_slice_18[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %107 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map33} : (tensor, index, index, index, index) -> tensor + %108 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map34} : (tensor, index, index, index, index) -> tensor + %109 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map35} : (tensor, index, index, index, index) -> tensor + %110 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map34} : (tensor, index, index, index, index) -> tensor + %111 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map36} : (tensor, index, index, index, index) -> tensor + %112 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map37} : (tensor, index, index, index, index) -> tensor + %113 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map35} : (tensor, index, index, index, index) -> tensor + %114 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map37} : (tensor, index, index, index, index) -> tensor + %115 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map38} : (tensor, index, index, index, index) -> tensor + %116:3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%107, %108, %109, %110, %111, %112, %113, %114, %115 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_19, %extracted_slice_20, %106 : tensor, tensor, tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %in_27: f64, %in_28: f64, %in_29: f64, %in_30: f64, %in_31: f64, %out: f64, %out_32: f64, %out_33: f64): + %136 = arith.mulf %in, %out : f64 + %137 = arith.mulf %in_24, %out_32 : f64 + %138 = arith.addf %136, %137 : f64 + %139 = arith.mulf %in_25, %out_33 : f64 + %140 = arith.addf %138, %139 : f64 + %141 = arith.mulf %in_26, %out : f64 + %142 = arith.mulf %in_27, %out_32 : f64 + %143 = arith.addf %141, %142 : f64 + %144 = arith.mulf %in_28, %out_33 : f64 + %145 = arith.addf %143, %144 : f64 + %146 = arith.mulf %in_29, %out : f64 + %147 = arith.mulf %in_30, %out_32 : f64 + %148 = arith.addf %146, %147 : f64 + %149 = arith.mulf %in_31, %out_33 : f64 + %150 = arith.addf %148, %149 : f64 + linalg.yield %140, %145, %150 : f64, f64, f64 + } -> (tensor, tensor, tensor) + %inserted_slice_21 = tensor.insert_slice %116#2 into %inserted_slice_16[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_22 = tensor.extract_slice %inserted_slice_21[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %117 = polygeist.submap(%7, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index, index, index, index) -> tensor + %118 = polygeist.submap(%7, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index, index, index, index) -> tensor + %119 = polygeist.submap(%6, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map41} : (tensor, index, index, index, index, index, index, index) -> tensor + %120 = polygeist.submap(%87, %c2, %c3, %c3, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %121 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%117, %118, %extracted_slice_22, %119 : tensor, tensor, tensor, tensor) outs(%120 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %122 = polygeist.submapInverse(%87, %121, %c2, %c3, %c3, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %extracted_slice_23 = tensor.extract_slice %inserted_slice_21[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %123 = polygeist.submap(%7, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index, index, index, index) -> tensor + %124 = polygeist.submap(%7, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map41} : (tensor, index, index, index, index, index, index, index) -> tensor + %125 = polygeist.submap(%6, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index, index, index, index) -> tensor + %126 = polygeist.submap(%122, %c2, %c3, %c4, %c3) {map = #map20} : (tensor, index, index, index, index) -> tensor + %127 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%123, %125, %extracted_slice_23, %124 : tensor, tensor, tensor, tensor) outs(%126 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %128 = polygeist.submapInverse(%122, %127, %c2, %c3, %c4, %c3) {map = #map20} : (tensor, tensor, index, index, index, index) -> tensor + %129 = polygeist.submap(%7, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index, index, index, index) -> tensor + %130 = polygeist.submap(%7, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map41} : (tensor, index, index, index, index, index, index, index) -> tensor + %131 = polygeist.submap(%6, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index, index, index, index) -> tensor + %132 = polygeist.submap(%128, %c2, %c4, %c3, %c3) {map = #map21} : (tensor, index, index, index, index) -> tensor + %133 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%131, %129, %116#2, %130 : tensor, tensor, tensor, tensor) outs(%132 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %134 = polygeist.submapInverse(%128, %133, %c2, %c4, %c3, %c3) {map = #map21} : (tensor, tensor, index, index, index, index) -> tensor + %135 = bufferization.to_memref %134 : memref + memref.copy %135, %arg9 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d.raised.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d.raised.mlir new file mode 100644 index 000000000000..022f89bca299 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d.raised.mlir @@ -0,0 +1,449 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 108)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 125 + d1 * 25 + d2 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 108)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map21 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map22 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 3)> +#map23 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 3)> +#map24 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 4 + d0 * 108)> +#map25 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 4)> +#map26 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map27 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +#map28 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 4)> +#map29 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 3 + d0 * 108 + 36)> +#map30 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 3)> +#map31 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 4)> +#map32 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 9 + d5 * 3 + d0 * 108 + 72)> +#map33 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750)> +#map34 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 125)> +#map35 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 250)> +#map36 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 375)> +#map37 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 500)> +#map38 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 625)> +#map39 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 5)> +#map40 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 5)> +#map41 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 5)> +#map42 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_hdiv_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_8 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x4x5xf64> + %subview = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c3, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg8, %c2, %c3, %c3, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg4, %c2, %c3, %c3, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + %subview_14 = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c3, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%subview_14 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_15 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_15 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_16 = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c3, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %2 = polygeist.submap(%arg0, %c2, %c3, %c5, %c5, %c3) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_17 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_16, %2 : memref>, memref) outs(%subview_17 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_18 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_18 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_19 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %3 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_20 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_19, %3 : memref>, memref) outs(%subview_20 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_21 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_21 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg8, %c2, %c3, %c4, %c5, %c3) {map = #map9} : (memref, index, index, index, index, index) -> memref + %5 = polygeist.submap(%arg0, %c2, %c3, %c4, %c5, %c3) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_22 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%4, %5 : memref, memref) outs(%subview_22 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_23 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_23 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_24 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %6 = polygeist.submap(%arg4, %c2, %c3, %c5, %c5, %c4) {map = #map11} : (memref, index, index, index, index, index) -> memref + %subview_25 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_24, %6 : memref>, memref) outs(%subview_25 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_26 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_26 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_27 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %7 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_28 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_27, %7 : memref>, memref) outs(%subview_28 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_29 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_29 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg8, %c2, %c4, %c3, %c5, %c3) {map = #map12} : (memref, index, index, index, index, index) -> memref + %9 = polygeist.submap(%arg0, %c2, %c4, %c3, %c5, %c3) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_30 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%8, %9 : memref, memref) outs(%subview_30 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_31 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_31 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_32 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %10 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c3) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_33 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_32, %10 : memref>, memref) outs(%subview_33 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_34 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_34 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_35 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %11 = polygeist.submap(%arg4, %c2, %c5, %c5, %c5, %c4) {map = #map13} : (memref, index, index, index, index, index) -> memref + %subview_36 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_35, %11 : memref>, memref) outs(%subview_36 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_37 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_37 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %12 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %subview_38 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_39 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_40 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %13 = polygeist.submap(%arg5, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_41 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%12, %subview_38, %subview_39, %subview_40, %13 : memref, memref>, memref>, memref>, memref) outs(%subview_41 : memref>) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %in_80: f64, %out: f64): + %60 = arith.addf %in_77, %in_78 : f64 + %61 = arith.addf %60, %in_79 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.mulf %62, %in_80 : f64 + %64 = arith.addf %out, %63 : f64 + linalg.yield %64 : f64 + } + %subview_42 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_42 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %subview_43 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_44 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_45 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %15 = polygeist.submap(%arg2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_46 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%14, %subview_43, %subview_44, %subview_45, %15 : memref, memref>, memref>, memref>, memref) outs(%subview_46 : memref>) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %in_80: f64, %out: f64): + %60 = arith.addf %in_77, %in_78 : f64 + %61 = arith.addf %60, %in_79 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.mulf %62, %in_80 : f64 + %64 = arith.addf %out, %63 : f64 + linalg.yield %64 : f64 + } + %subview_47 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_47 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %16 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %subview_48 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_49 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_50 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %17 = polygeist.submap(%arg2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_51 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%16, %subview_48, %subview_49, %subview_50, %17 : memref, memref>, memref>, memref>, memref) outs(%subview_51 : memref>) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %in_80: f64, %out: f64): + %60 = arith.addf %in_77, %in_78 : f64 + %61 = arith.addf %60, %in_79 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.mulf %62, %in_80 : f64 + %64 = arith.addf %out, %63 : f64 + linalg.yield %64 : f64 + } + %subview_52 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_52 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_53 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %18 = polygeist.submap(%arg2, %c2, %c5, %c3, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_54 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_53, %18 : memref>, memref) outs(%subview_54 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_55 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_55 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_56 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %19 = polygeist.submap(%arg5, %c2, %c5, %c4, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_57 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_56, %19 : memref>, memref) outs(%subview_57 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_58 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c5, %c3, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_58 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_59 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %20 = polygeist.submap(%arg2, %c2, %c5, %c3, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_60 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c5, %c3, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_59, %20 : memref>, memref) outs(%subview_60 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_61 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %21 = polygeist.submap(%arg2, %c2, %c3, %c3, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %22 = polygeist.submap(%arg9, %c2, %c3, %c3, %c4) {map = #map19} : (memref, index, index, index, index) -> memref<2x3x3x4xf64> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_61, %21 : memref>, memref) outs(%22 : memref<2x3x3x4xf64>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_62 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %23 = polygeist.submap(%arg2, %c2, %c3, %c4, %c3, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %24 = polygeist.submap(%arg9, %c2, %c3, %c4, %c3) {map = #map20} : (memref, index, index, index, index) -> memref<2x3x4x3xf64> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_62, %23 : memref>, memref) outs(%24 : memref<2x3x4x3xf64>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_63 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c5, %c3, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %25 = polygeist.submap(%arg5, %c2, %c4, %c3, %c3, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %26 = polygeist.submap(%arg9, %c2, %c4, %c3, %c3) {map = #map21} : (memref, index, index, index, index) -> memref<2x4x3x3xf64> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_63, %25 : memref>, memref) outs(%26 : memref<2x4x3x3xf64>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %alloca_64 = memref.alloca() : memref<2x3x5x5x5xf64> + %subview_65 = memref.subview %alloca_64[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_65 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %27 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map22} : (memref, index, index, index, index, index, index, index) -> memref + %28 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map23} : (memref, index, index, index, index, index, index, index) -> memref + %29 = polygeist.submap(%arg8, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map24} : (memref, index, index, index, index, index, index, index) -> memref + %30 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map25} : (memref, index, index, index, index, index, index, index) -> memref + %subview_66 = memref.subview %alloca_64[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%27, %28, %29, %30 : memref, memref, memref, memref) outs(%subview_66 : memref>) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %out: f64): + %60 = arith.mulf %in_78, %in_79 : f64 + %61 = arith.mulf %60, %in_77 : f64 + %62 = arith.mulf %61, %in : f64 + %63 = arith.addf %out, %62 : f64 + linalg.yield %63 : f64 + } + %subview_67 = memref.subview %alloca_64[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_67 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %31 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map22} : (memref, index, index, index, index, index, index, index) -> memref + %32 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map28} : (memref, index, index, index, index, index, index, index) -> memref + %33 = polygeist.submap(%arg8, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map29} : (memref, index, index, index, index, index, index, index) -> memref + %34 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map30} : (memref, index, index, index, index, index, index, index) -> memref + %subview_68 = memref.subview %alloca_64[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%31, %32, %33, %34 : memref, memref, memref, memref) outs(%subview_68 : memref>) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %out: f64): + %60 = arith.mulf %in_78, %in_79 : f64 + %61 = arith.mulf %60, %in_77 : f64 + %62 = arith.mulf %61, %in : f64 + %63 = arith.addf %out, %62 : f64 + linalg.yield %63 : f64 + } + %subview_69 = memref.subview %alloca_64[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_69 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %35 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map31} : (memref, index, index, index, index, index, index, index) -> memref + %36 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map23} : (memref, index, index, index, index, index, index, index) -> memref + %37 = polygeist.submap(%arg8, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map32} : (memref, index, index, index, index, index, index, index) -> memref + %38 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map30} : (memref, index, index, index, index, index, index, index) -> memref + %subview_70 = memref.subview %alloca_64[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%35, %36, %37, %38 : memref, memref, memref, memref) outs(%subview_70 : memref>) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %out: f64): + %60 = arith.mulf %in_78, %in_79 : f64 + %61 = arith.mulf %60, %in_77 : f64 + %62 = arith.mulf %61, %in : f64 + %63 = arith.addf %out, %62 : f64 + linalg.yield %63 : f64 + } + %39 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map33} : (memref, index, index, index, index) -> memref + %40 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map34} : (memref, index, index, index, index) -> memref + %41 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map35} : (memref, index, index, index, index) -> memref + %42 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map34} : (memref, index, index, index, index) -> memref + %43 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map36} : (memref, index, index, index, index) -> memref + %44 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map37} : (memref, index, index, index, index) -> memref + %45 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map35} : (memref, index, index, index, index) -> memref + %46 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map37} : (memref, index, index, index, index) -> memref + %47 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map38} : (memref, index, index, index, index) -> memref + %subview_71 = memref.subview %alloca_64[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %subview_72 = memref.subview %alloca_64[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %subview_73 = memref.subview %alloca_64[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%39, %40, %41, %42, %43, %44, %45, %46, %47 : memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%subview_71, %subview_72, %subview_73 : memref>, memref>, memref>) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %in_80: f64, %in_81: f64, %in_82: f64, %in_83: f64, %in_84: f64, %out: f64, %out_85: f64, %out_86: f64): + %60 = arith.mulf %in, %out : f64 + %61 = arith.mulf %in_77, %out_85 : f64 + %62 = arith.addf %60, %61 : f64 + %63 = arith.mulf %in_78, %out_86 : f64 + %64 = arith.addf %62, %63 : f64 + %65 = arith.mulf %in_79, %out : f64 + %66 = arith.mulf %in_80, %out_85 : f64 + %67 = arith.addf %65, %66 : f64 + %68 = arith.mulf %in_81, %out_86 : f64 + %69 = arith.addf %67, %68 : f64 + %70 = arith.mulf %in_82, %out : f64 + %71 = arith.mulf %in_83, %out_85 : f64 + %72 = arith.addf %70, %71 : f64 + %73 = arith.mulf %in_84, %out_86 : f64 + %74 = arith.addf %72, %73 : f64 + linalg.yield %64, %69, %74 : f64, f64, f64 + } + %48 = polygeist.submap(%arg2, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map39} : (memref, index, index, index, index, index, index, index) -> memref + %49 = polygeist.submap(%arg2, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map40} : (memref, index, index, index, index, index, index, index) -> memref + %subview_74 = memref.subview %alloca_64[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %50 = polygeist.submap(%arg3, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map41} : (memref, index, index, index, index, index, index, index) -> memref + %51 = polygeist.submap(%arg9, %c2, %c3, %c3, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%48, %49, %subview_74, %50 : memref, memref, memref>, memref) outs(%51 : memref) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %out: f64): + %60 = arith.mulf %in_78, %in_79 : f64 + %61 = arith.mulf %60, %in_77 : f64 + %62 = arith.mulf %61, %in : f64 + %63 = arith.addf %out, %62 : f64 + linalg.yield %63 : f64 + } + %52 = polygeist.submap(%arg2, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map39} : (memref, index, index, index, index, index, index, index) -> memref + %53 = polygeist.submap(%arg3, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map40} : (memref, index, index, index, index, index, index, index) -> memref + %subview_75 = memref.subview %alloca_64[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %54 = polygeist.submap(%arg2, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map41} : (memref, index, index, index, index, index, index, index) -> memref + %55 = polygeist.submap(%arg9, %c2, %c3, %c4, %c3) {map = #map20} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%52, %53, %subview_75, %54 : memref, memref, memref>, memref) outs(%55 : memref) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %out: f64): + %60 = arith.mulf %in_78, %in_79 : f64 + %61 = arith.mulf %60, %in_77 : f64 + %62 = arith.mulf %61, %in : f64 + %63 = arith.addf %out, %62 : f64 + linalg.yield %63 : f64 + } + %56 = polygeist.submap(%arg3, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map39} : (memref, index, index, index, index, index, index, index) -> memref + %57 = polygeist.submap(%arg2, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map40} : (memref, index, index, index, index, index, index, index) -> memref + %subview_76 = memref.subview %alloca_64[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %58 = polygeist.submap(%arg2, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map41} : (memref, index, index, index, index, index, index, index) -> memref + %59 = polygeist.submap(%arg9, %c2, %c4, %c3, %c3) {map = #map21} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%56, %57, %subview_76, %58 : memref, memref, memref>, memref) outs(%59 : memref) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %out: f64): + %60 = arith.mulf %in_78, %in_79 : f64 + %61 = arith.mulf %60, %in_77 : f64 + %62 = arith.mulf %61, %in : f64 + %63 = arith.addf %out, %62 : f64 + linalg.yield %63 : f64 + } + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d_partial.debufferized.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d_partial.debufferized.mlir new file mode 100644 index 000000000000..0955e8311e00 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d_partial.debufferized.mlir @@ -0,0 +1,263 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 108)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 125 + d1 * 25 + d2 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 4 + d0 * 108)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_hdiv_3d_partial(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x5x4x4xf64> + %8 = tensor.empty() : tensor<2x5x4x4xf64> + %9 = tensor.empty() : tensor<2x5x4x4xf64> + %10 = tensor.empty() : tensor<2x5x5x4xf64> + %11 = tensor.empty() : tensor<2x5x5x4xf64> + %12 = tensor.empty() : tensor<2x5x5x4xf64> + %13 = tensor.empty() : tensor<2x5x5x5xf64> + %14 = tensor.empty() : tensor<2x5x5x5xf64> + %15 = tensor.empty() : tensor<2x5x5x5xf64> + %16 = tensor.empty() : tensor<2x4x5x5xf64> + %17 = tensor.empty() : tensor<2x4x5x5xf64> + %18 = tensor.empty() : tensor<2x4x5x5xf64> + %19 = tensor.empty() : tensor<2x4x4x5xf64> + %20 = tensor.empty() : tensor<2x4x4x5xf64> + %21 = tensor.empty() : tensor<2x4x4x5xf64> + %22 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%21 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %23 = polygeist.submap(%4, %c2, %c3, %c3, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %24 = polygeist.submap(%1, %c2, %c3, %c3, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%24, %23 : tensor, tensor) outs(%22 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x4x5xf64> + %26 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%18 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %27 = polygeist.submap(%6, %c2, %c3, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%25, %27 : tensor<2x4x4x5xf64>, tensor) outs(%26 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x5x5xf64> + %29 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%15 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %30 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %31 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%28, %30 : tensor<2x4x5x5xf64>, tensor) outs(%29 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x5x5xf64> + %32 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%20 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %33 = polygeist.submap(%6, %c2, %c3, %c4, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %34 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c3) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %35 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%34, %33 : tensor, tensor) outs(%32 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x4x5xf64> + %36 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%17 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %37 = polygeist.submap(%4, %c2, %c3, %c5, %c5, %c4) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %38 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%35, %37 : tensor<2x4x4x5xf64>, tensor) outs(%36 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x5x5xf64> + %39 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%14 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %40 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %41 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%38, %40 : tensor<2x4x5x5xf64>, tensor) outs(%39 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x5x5xf64> + %42 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%19 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %43 = polygeist.submap(%6, %c2, %c4, %c3, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %44 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c3) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %45 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%44, %43 : tensor, tensor) outs(%42 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x4x5xf64> + %46 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%16 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %47 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %48 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%45, %47 : tensor<2x4x4x5xf64>, tensor) outs(%46 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x5x5xf64> + %49 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%13 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %50 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %51 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%48, %50 : tensor<2x4x5x5xf64>, tensor) outs(%49 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x5x5xf64> + %52 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %53 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %54 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%54, %31, %41, %51, %53 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%52 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %56 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %57 = polygeist.submap(%5, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %58 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %59 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%58, %31, %41, %51, %57 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%56 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %60 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %61 = polygeist.submap(%5, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %62 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%62, %31, %41, %51, %61 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%60 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %64 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %65 = polygeist.submap(%5, %c2, %c5, %c3, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %66 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%55, %65 : tensor<2x5x5x4xf64>, tensor) outs(%64 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x4x4xf64> + %67 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %68 = polygeist.submap(%3, %c2, %c5, %c4, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %69 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%59, %68 : tensor<2x5x5x4xf64>, tensor) outs(%67 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x4x4xf64> + %70 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%7 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %71 = polygeist.submap(%5, %c2, %c5, %c3, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %72 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%63, %71 : tensor<2x5x5x4xf64>, tensor) outs(%70 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x4x4xf64> + %73 = polygeist.submap(%5, %c2, %c3, %c3, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %74 = polygeist.submap(%0, %c2, %c3, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %75 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%66, %73 : tensor<2x5x4x4xf64>, tensor) outs(%74 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %76 = polygeist.submapInverse(%0, %75, %c2, %c3, %c3, %c4, %c5) {map = #map19} : (tensor, tensor, index, index, index, index, index) -> tensor + %77 = polygeist.submap(%5, %c2, %c3, %c4, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %78 = polygeist.submap(%76, %c2, %c3, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %79 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%69, %77 : tensor<2x5x4x4xf64>, tensor) outs(%78 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %80 = polygeist.submapInverse(%76, %79, %c2, %c3, %c4, %c3, %c5) {map = #map20} : (tensor, tensor, index, index, index, index, index) -> tensor + %81 = polygeist.submap(%3, %c2, %c4, %c3, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %82 = polygeist.submap(%80, %c2, %c4, %c3, %c3, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %83 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%72, %81 : tensor<2x5x4x4xf64>, tensor) outs(%82 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %84 = polygeist.submapInverse(%80, %83, %c2, %c4, %c3, %c3, %c5) {map = #map21} : (tensor, tensor, index, index, index, index, index) -> tensor + %85 = bufferization.to_memref %84 : memref + memref.copy %85, %arg6 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d_partial.frontend.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d_partial.frontend.mlir new file mode 100644 index 000000000000..084c432b98c5 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d_partial.frontend.mlir @@ -0,0 +1,664 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_hdiv_3d_partial(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_8 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 12 + %arg11 + %arg9 * 4 + %arg7 * 108] : memref + %2 = affine.load %arg2[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 12 + %arg11 + %arg9 * 3 + %arg7 * 108 + 36] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 9 + %arg11 + %arg9 * 3 + %arg7 * 108 + 72] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg3[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg1[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg1[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca_1[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg1[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca_0[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg1[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + } + } + } + } + return + } + func.func @mfem_pa_divdiv_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_8 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 12 + %arg11 + %arg9 * 4 + %arg7 * 108] : memref + %2 = affine.load %arg2[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 12 + %arg11 + %arg9 * 3 + %arg7 * 108 + 36] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 9 + %arg11 + %arg9 * 3 + %arg7 * 108 + 72] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg3[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg1[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg1[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca_1[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg1[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca_0[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg1[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d_partial.matched.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d_partial.matched.mlir new file mode 100644 index 000000000000..da8baac69faa --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d_partial.matched.mlir @@ -0,0 +1,221 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 108)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 125 + d1 * 25 + d2 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 4 + d0 * 108)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_hdiv_3d_partial(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x5x4x4xf64> + %8 = tensor.empty() : tensor<2x5x4x4xf64> + %9 = tensor.empty() : tensor<2x5x4x4xf64> + %10 = tensor.empty() : tensor<2x5x5x4xf64> + %11 = tensor.empty() : tensor<2x5x5x4xf64> + %12 = tensor.empty() : tensor<2x5x5x4xf64> + %13 = tensor.empty() : tensor<2x5x5x5xf64> + %14 = tensor.empty() : tensor<2x5x5x5xf64> + %15 = tensor.empty() : tensor<2x5x5x5xf64> + %16 = tensor.empty() : tensor<2x4x5x5xf64> + %17 = tensor.empty() : tensor<2x4x5x5xf64> + %18 = tensor.empty() : tensor<2x4x5x5xf64> + %19 = tensor.empty() : tensor<2x4x4x5xf64> + %20 = tensor.empty() : tensor<2x4x4x5xf64> + %21 = tensor.empty() : tensor<2x4x4x5xf64> + %23 = polygeist.submap(%4, %c2, %c3, %c3, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %24 = polygeist.submap(%1, %c2, %c3, %c3, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v21_contract_25_tc2 = tensor.cast %21 : tensor<2x4x4x5xf64> to tensor + + %v25_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%24, %23, %v21_contract_25_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %25 = tensor.cast %v25_tdyn : tensor to tensor<2x4x4x5xf64> + %27 = polygeist.submap(%6, %c2, %c3, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v25_contract_28_tc0 = tensor.cast %25 : tensor<2x4x4x5xf64> to tensor + + %v18_contract_28_tc2 = tensor.cast %18 : tensor<2x4x5x5xf64> to tensor + + %v28_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v25_contract_28_tc0, %27, %v18_contract_28_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %28 = tensor.cast %v28_tdyn : tensor to tensor<2x4x5x5xf64> + %30 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v28_contract_31_tc0 = tensor.cast %28 : tensor<2x4x5x5xf64> to tensor + + %v15_contract_31_tc2 = tensor.cast %15 : tensor<2x5x5x5xf64> to tensor + + %v31_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v28_contract_31_tc0, %30, %v15_contract_31_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %31 = tensor.cast %v31_tdyn : tensor to tensor<2x5x5x5xf64> + %33 = polygeist.submap(%6, %c2, %c3, %c4, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %34 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c3) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %v20_contract_35_tc2 = tensor.cast %20 : tensor<2x4x4x5xf64> to tensor + + %v35_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%34, %33, %v20_contract_35_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %35 = tensor.cast %v35_tdyn : tensor to tensor<2x4x4x5xf64> + %37 = polygeist.submap(%4, %c2, %c3, %c5, %c5, %c4) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %v35_contract_38_tc0 = tensor.cast %35 : tensor<2x4x4x5xf64> to tensor + + %v17_contract_38_tc2 = tensor.cast %17 : tensor<2x4x5x5xf64> to tensor + + %v38_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v35_contract_38_tc0, %37, %v17_contract_38_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %38 = tensor.cast %v38_tdyn : tensor to tensor<2x4x5x5xf64> + %40 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v38_contract_41_tc0 = tensor.cast %38 : tensor<2x4x5x5xf64> to tensor + + %v14_contract_41_tc2 = tensor.cast %14 : tensor<2x5x5x5xf64> to tensor + + %v41_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v38_contract_41_tc0, %40, %v14_contract_41_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %41 = tensor.cast %v41_tdyn : tensor to tensor<2x5x5x5xf64> + %43 = polygeist.submap(%6, %c2, %c4, %c3, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %44 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c3) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %v19_contract_45_tc2 = tensor.cast %19 : tensor<2x4x4x5xf64> to tensor + + %v45_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%44, %43, %v19_contract_45_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %45 = tensor.cast %v45_tdyn : tensor to tensor<2x4x4x5xf64> + %47 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v45_contract_48_tc0 = tensor.cast %45 : tensor<2x4x4x5xf64> to tensor + + %v16_contract_48_tc2 = tensor.cast %16 : tensor<2x4x5x5xf64> to tensor + + %v48_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v45_contract_48_tc0, %47, %v16_contract_48_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %48 = tensor.cast %v48_tdyn : tensor to tensor<2x4x5x5xf64> + %50 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %v48_contract_51_tc0 = tensor.cast %48 : tensor<2x4x5x5xf64> to tensor + + %v13_contract_51_tc2 = tensor.cast %13 : tensor<2x5x5x5xf64> to tensor + + %v51_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v48_contract_51_tc0, %50, %v13_contract_51_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %51 = tensor.cast %v51_tdyn : tensor to tensor<2x5x5x5xf64> + %52 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %53 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %54 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%54, %31, %41, %51, %53 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%52 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %56 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %57 = polygeist.submap(%5, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %58 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %59 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%58, %31, %41, %51, %57 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%56 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %60 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %61 = polygeist.submap(%5, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %62 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%62, %31, %41, %51, %61 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%60 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %65 = polygeist.submap(%5, %c2, %c5, %c3, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %v55_contract_66_tc0 = tensor.cast %55 : tensor<2x5x5x4xf64> to tensor + + %v9_contract_66_tc2 = tensor.cast %9 : tensor<2x5x4x4xf64> to tensor + + %v66_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v55_contract_66_tc0, %65, %v9_contract_66_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %66 = tensor.cast %v66_tdyn : tensor to tensor<2x5x4x4xf64> + %68 = polygeist.submap(%3, %c2, %c5, %c4, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %v59_contract_69_tc0 = tensor.cast %59 : tensor<2x5x5x4xf64> to tensor + + %v8_contract_69_tc2 = tensor.cast %8 : tensor<2x5x4x4xf64> to tensor + + %v69_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v59_contract_69_tc0, %68, %v8_contract_69_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %69 = tensor.cast %v69_tdyn : tensor to tensor<2x5x4x4xf64> + %71 = polygeist.submap(%5, %c2, %c5, %c3, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %v63_contract_72_tc0 = tensor.cast %63 : tensor<2x5x5x4xf64> to tensor + + %v7_contract_72_tc2 = tensor.cast %7 : tensor<2x5x4x4xf64> to tensor + + %v72_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v63_contract_72_tc0, %71, %v7_contract_72_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %72 = tensor.cast %v72_tdyn : tensor to tensor<2x5x4x4xf64> + %73 = polygeist.submap(%5, %c2, %c3, %c3, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %74 = polygeist.submap(%0, %c2, %c3, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %75 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%66, %73 : tensor<2x5x4x4xf64>, tensor) outs(%74 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %76 = polygeist.submapInverse(%0, %75, %c2, %c3, %c3, %c4, %c5) {map = #map19} : (tensor, tensor, index, index, index, index, index) -> tensor + %77 = polygeist.submap(%5, %c2, %c3, %c4, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %78 = polygeist.submap(%76, %c2, %c3, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %79 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%69, %77 : tensor<2x5x4x4xf64>, tensor) outs(%78 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %80 = polygeist.submapInverse(%76, %79, %c2, %c3, %c4, %c3, %c5) {map = #map20} : (tensor, tensor, index, index, index, index, index) -> tensor + %81 = polygeist.submap(%3, %c2, %c4, %c3, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %82 = polygeist.submap(%80, %c2, %c4, %c3, %c3, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %83 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%72, %81 : tensor<2x5x4x4xf64>, tensor) outs(%82 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %84 = polygeist.submapInverse(%80, %83, %c2, %c4, %c3, %c3, %c5) {map = #map21} : (tensor, tensor, index, index, index, index, index) -> tensor + %85 = bufferization.to_memref %84 : memref + memref.copy %85, %arg6 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d_partial.raised.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d_partial.raised.mlir new file mode 100644 index 000000000000..64d49b9cc97e --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex35p_hdiv_3d_partial.raised.mlir @@ -0,0 +1,251 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 108)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 125 + d1 * 25 + d2 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 4 + d0 * 108)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex35p_hdiv_3d_partial(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_8 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_13 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg5, %c2, %c3, %c3, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg2, %c2, %c3, %c3, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_13 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_10 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg0, %c2, %c3, %c5, %c5, %c3) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_13, %2 : memref<2x4x4x5xf64>, memref) outs(%alloca_10 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_7 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %3 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_10, %3 : memref<2x4x5x5xf64>, memref) outs(%alloca_7 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_12 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg5, %c2, %c3, %c4, %c5, %c3) {map = #map9} : (memref, index, index, index, index, index) -> memref + %5 = polygeist.submap(%arg0, %c2, %c3, %c4, %c5, %c3) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%4, %5 : memref, memref) outs(%alloca_12 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_9 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg2, %c2, %c3, %c5, %c5, %c4) {map = #map11} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_12, %6 : memref<2x4x4x5xf64>, memref) outs(%alloca_9 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_6 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %7 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_9, %7 : memref<2x4x5x5xf64>, memref) outs(%alloca_6 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_11 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg5, %c2, %c4, %c3, %c5, %c3) {map = #map12} : (memref, index, index, index, index, index) -> memref + %9 = polygeist.submap(%arg0, %c2, %c4, %c3, %c5, %c3) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%8, %9 : memref, memref) outs(%alloca_11 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_8 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %10 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c3) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_11, %10 : memref<2x4x4x5xf64>, memref) outs(%alloca_8 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_5 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %11 = polygeist.submap(%arg2, %c2, %c5, %c5, %c5, %c4) {map = #map13} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_8, %11 : memref<2x4x5x5xf64>, memref) outs(%alloca_5 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_4 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %12 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %13 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%12, %alloca_7, %alloca_6, %alloca_5, %13 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_4 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %27 = arith.addf %in_14, %in_15 : f64 + %28 = arith.addf %27, %in_16 : f64 + %29 = arith.mulf %in, %28 : f64 + %30 = arith.mulf %29, %in_17 : f64 + %31 = arith.addf %out, %30 : f64 + linalg.yield %31 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg4, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %15 = polygeist.submap(%arg1, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%14, %alloca_7, %alloca_6, %alloca_5, %15 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_3 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %27 = arith.addf %in_14, %in_15 : f64 + %28 = arith.addf %27, %in_16 : f64 + %29 = arith.mulf %in, %28 : f64 + %30 = arith.mulf %29, %in_17 : f64 + %31 = arith.addf %out, %30 : f64 + linalg.yield %31 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %16 = polygeist.submap(%arg4, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %17 = polygeist.submap(%arg1, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%16, %alloca_7, %alloca_6, %alloca_5, %17 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_2 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %27 = arith.addf %in_14, %in_15 : f64 + %28 = arith.addf %27, %in_16 : f64 + %29 = arith.mulf %in, %28 : f64 + %30 = arith.mulf %29, %in_17 : f64 + %31 = arith.addf %out, %30 : f64 + linalg.yield %31 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %18 = polygeist.submap(%arg1, %c2, %c5, %c3, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_4, %18 : memref<2x5x5x4xf64>, memref) outs(%alloca_1 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %19 = polygeist.submap(%arg3, %c2, %c5, %c4, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_3, %19 : memref<2x5x5x4xf64>, memref) outs(%alloca_0 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %20 = polygeist.submap(%arg1, %c2, %c5, %c3, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_2, %20 : memref<2x5x5x4xf64>, memref) outs(%alloca : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + %21 = polygeist.submap(%arg1, %c2, %c3, %c3, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %22 = polygeist.submap(%arg6, %c2, %c3, %c3, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_1, %21 : memref<2x5x4x4xf64>, memref) outs(%22 : memref) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + %23 = polygeist.submap(%arg1, %c2, %c3, %c4, %c3, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %24 = polygeist.submap(%arg6, %c2, %c3, %c4, %c3, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_0, %23 : memref<2x5x4x4xf64>, memref) outs(%24 : memref) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + %25 = polygeist.submap(%arg3, %c2, %c4, %c3, %c3, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %26 = polygeist.submap(%arg6, %c2, %c4, %c3, %c3, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca, %25 : memref<2x5x4x4xf64>, memref) outs(%26 : memref) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex9p_mass_convection_2d.debufferized.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex9p_mass_convection_2d.debufferized.mlir new file mode 100644 index 000000000000..ac99d95f918b --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex9p_mass_convection_2d.debufferized.mlir @@ -0,0 +1,236 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2) -> (d2 + d0 * 25 + d1 * 5)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map11 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +#map12 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 50 + d1 * 5)> +#map13 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 50 + d1 * 5 + 25)> +#map14 = affine_map<(d0) -> (d0)> +#map15 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex9p_mass_convection_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: f64, %arg8: f64, %arg9: memref, %arg10: memref, %arg11: memref, %arg12: memref, %arg13: memref, %arg14: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg14 : memref + %1 = bufferization.to_tensor %arg13 : memref + %2 = bufferization.to_tensor %arg12 : memref + %3 = bufferization.to_tensor %arg11 : memref + %4 = bufferization.to_tensor %arg10 : memref + %5 = bufferization.to_tensor %arg9 : memref + %6 = bufferization.to_tensor %arg6 : memref + %7 = bufferization.to_tensor %arg5 : memref + %8 = bufferization.to_tensor %arg4 : memref + %9 = bufferization.to_tensor %arg3 : memref + %10 = bufferization.to_tensor %arg2 : memref + %11 = bufferization.to_tensor %arg1 : memref + %12 = bufferization.to_tensor %arg0 : memref + %13 = tensor.empty() : tensor<2x5x4xf64> + %14 = tensor.empty() : tensor<2x5x5xf64> + %15 = tensor.empty() : tensor<2x4x5xf64> + %extracted_slice = tensor.extract_slice %15[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %16 into %15[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %17 = polygeist.submap(%12, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %18 = polygeist.submap(%7, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%17, %18 : tensor, tensor) outs(%inserted_slice : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_25: f64, %out: f64): + %71 = arith.mulf %in, %in_25 : f64 + %72 = arith.addf %out, %71 : f64 + linalg.yield %72 : f64 + } -> tensor<2x4x5xf64> + %extracted_slice_0 = tensor.extract_slice %14[0, 0, 0] [%c2, %c5, %c5] [1, 1, 1] : tensor<2x5x5xf64> to tensor + %20 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_0 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_1 = tensor.extract_slice %19[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %21 = polygeist.submap(%12, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%21, %extracted_slice_1 : tensor, tensor) outs(%20 : tensor) { + ^bb0(%in: f64, %in_25: f64, %out: f64): + %71 = arith.mulf %in, %in_25 : f64 + %72 = arith.addf %out, %71 : f64 + linalg.yield %72 : f64 + } -> tensor + %23 = polygeist.submap(%9, %c2, %c5, %c5) {map = #map7} : (tensor, index, index, index) -> tensor + %24 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%23 : tensor) outs(%22 : tensor) { + ^bb0(%in: f64, %out: f64): + %71 = arith.mulf %out, %in : f64 + linalg.yield %71 : f64 + } -> tensor + %extracted_slice_2 = tensor.extract_slice %13[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_2 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %26 = polygeist.submap(%10, %c2, %c5, %c4, %c5) {map = #map8} : (tensor, index, index, index, index) -> tensor + %27 = linalg.generic {doc = "", indexing_maps = [#map3, #map9, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%26, %24 : tensor, tensor) outs(%25 : tensor) { + ^bb0(%in: f64, %in_25: f64, %out: f64): + %71 = arith.mulf %in, %in_25 : f64 + %72 = arith.addf %out, %71 : f64 + linalg.yield %72 : f64 + } -> tensor + %28 = polygeist.submap(%10, %c2, %c4, %c4, %c5) {map = #map10} : (tensor, index, index, index, index) -> tensor + %29 = polygeist.submap(%5, %c2, %c4, %c4) {map = #map11} : (tensor, index, index, index) -> tensor<2x4x4xf64> + %30 = linalg.generic {doc = "", indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%28, %27 : tensor, tensor) outs(%29 : tensor<2x4x4xf64>) { + ^bb0(%in: f64, %in_25: f64, %out: f64): + %71 = arith.mulf %in, %in_25 : f64 + %72 = arith.addf %out, %71 : f64 + linalg.yield %72 : f64 + } -> tensor<2x4x4xf64> + %31 = polygeist.submapInverse(%5, %30, %c2, %c4, %c4) {map = #map11} : (tensor, tensor<2x4x4xf64>, index, index, index) -> tensor + %32 = bufferization.to_memref %31 : memref + memref.copy %32, %arg9 : memref to memref + %33 = tensor.empty() : tensor<2x4x4xf64> + %34 = tensor.empty() : tensor<2x5x4xf64> + %35 = tensor.empty() : tensor<2x5x5xf64> + %36 = tensor.empty() : tensor<2x5x5xf64> + %37 = tensor.empty() : tensor<2x4x5xf64> + %38 = tensor.empty() : tensor<2x4x5xf64> + %extracted_slice_3 = tensor.extract_slice %38[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %39 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_3 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_4 = tensor.insert_slice %39 into %38[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %40 = polygeist.submap(%12, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %41 = polygeist.submap(%7, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %42 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%41, %40 : tensor, tensor) outs(%inserted_slice_4 : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_25: f64, %out: f64): + %71 = arith.mulf %in, %in_25 : f64 + %72 = arith.addf %out, %71 : f64 + linalg.yield %72 : f64 + } -> tensor<2x4x5xf64> + %extracted_slice_5 = tensor.extract_slice %37[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %43 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_5 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_6 = tensor.insert_slice %43 into %37[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %44 = polygeist.submap(%11, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %45 = polygeist.submap(%7, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %46 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%45, %44 : tensor, tensor) outs(%inserted_slice_6 : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_25: f64, %out: f64): + %71 = arith.mulf %in, %in_25 : f64 + %72 = arith.addf %out, %71 : f64 + linalg.yield %72 : f64 + } -> tensor<2x4x5xf64> + %extracted_slice_7 = tensor.extract_slice %36[0, 0, 0] [%c2, %c5, %c5] [1, 1, 1] : tensor<2x5x5xf64> to tensor + %47 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_7 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_8 = tensor.extract_slice %46[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %48 = polygeist.submap(%12, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %49 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_8, %48 : tensor, tensor) outs(%47 : tensor) { + ^bb0(%in: f64, %in_25: f64, %out: f64): + %71 = arith.mulf %in, %in_25 : f64 + %72 = arith.addf %out, %71 : f64 + linalg.yield %72 : f64 + } -> tensor + %extracted_slice_9 = tensor.extract_slice %35[0, 0, 0] [%c2, %c5, %c5] [1, 1, 1] : tensor<2x5x5xf64> to tensor + %50 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_9 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_10 = tensor.extract_slice %42[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %51 = polygeist.submap(%11, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %52 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_10, %51 : tensor, tensor) outs(%50 : tensor) { + ^bb0(%in: f64, %in_25: f64, %out: f64): + %71 = arith.mulf %in, %in_25 : f64 + %72 = arith.addf %out, %71 : f64 + linalg.yield %72 : f64 + } -> tensor + %extracted_slice_11 = tensor.extract_slice %34[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %53 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_11 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %54 = polygeist.submap(%10, %c2, %c5, %c4, %c5) {map = #map8} : (tensor, index, index, index, index) -> tensor + %55 = polygeist.submap(%8, %c2, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index) -> tensor + %56 = polygeist.submap(%8, %c2, %c5, %c4, %c5) {map = #map13} : (tensor, index, index, index, index) -> tensor + %57 = linalg.generic {doc = "", indexing_maps = [#map3, #map9, #map3, #map9, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%55, %49, %56, %52, %54 : tensor, tensor, tensor, tensor, tensor) outs(%53 : tensor) { + ^bb0(%in: f64, %in_25: f64, %in_26: f64, %in_27: f64, %in_28: f64, %out: f64): + %71 = arith.mulf %in, %in_25 : f64 + %72 = arith.mulf %in_26, %in_27 : f64 + %73 = arith.addf %71, %72 : f64 + %74 = arith.mulf %73, %in_28 : f64 + %75 = arith.addf %out, %74 : f64 + linalg.yield %75 : f64 + } -> tensor + %extracted_slice_12 = tensor.extract_slice %33[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : tensor<2x4x4xf64> to tensor + %58 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_12 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %59 = polygeist.submap(%10, %c2, %c4, %c4, %c5) {map = #map10} : (tensor, index, index, index, index) -> tensor + %60 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%57, %59 : tensor, tensor) outs(%58 : tensor) { + ^bb0(%in: f64, %in_25: f64, %out: f64): + %71 = arith.mulf %in, %in_25 : f64 + %72 = arith.addf %out, %71 : f64 + linalg.yield %72 : f64 + } -> tensor + %61 = polygeist.submap(%4, %c2, %c4, %c4) {map = #map11} : (tensor, index, index, index) -> tensor + %62 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%60 : tensor) outs(%61 : tensor) { + ^bb0(%in: f64, %out: f64): + %71 = arith.addf %out, %in : f64 + linalg.yield %71 : f64 + } -> tensor + %63 = polygeist.submapInverse(%4, %62, %c2, %c4, %c4) {map = #map11} : (tensor, tensor, index, index, index) -> tensor + %inserted = tensor.insert %cst into %0[%c0] : tensor + %extracted_slice_13 = tensor.extract_slice %6[0] [%c32] [1] : tensor to tensor + %extracted_slice_14 = tensor.extract_slice %31[0] [%c32] [1] : tensor to tensor + %extracted_slice_15 = tensor.extract_slice %63[0] [%c32] [1] : tensor to tensor + %extracted_slice_16 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %extracted_slice_17 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %extracted_slice_18 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %extracted_slice_19 = tensor.extract_slice %1[0] [%c32] [1] : tensor to tensor + %extracted_slice_20 = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %64:4 = linalg.generic {doc = "", indexing_maps = [#map14, #map14, #map14, #map14, #map14, #map14, #map14, #map15], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_19, %extracted_slice_14, %extracted_slice_13, %extracted_slice_16 : tensor, tensor, tensor, tensor) outs(%extracted_slice_15, %extracted_slice_17, %extracted_slice_18, %extracted_slice_20 : tensor, tensor, tensor, tensor) { + ^bb0(%in: f64, %in_25: f64, %in_26: f64, %in_27: f64, %out: f64, %out_28: f64, %out_29: f64, %out_30: f64): + %71 = arith.mulf %arg7, %in : f64 + %72 = arith.addf %out, %71 : f64 + %73 = arith.mulf %arg7, %in_25 : f64 + %74 = arith.subf %out_28, %73 : f64 + %75 = arith.mulf %in_26, %74 : f64 + %76 = arith.mulf %in_27, %75 : f64 + %77 = arith.addf %out_30, %76 : f64 + linalg.yield %72, %74, %75, %77 : f64, f64, f64, f64 + } -> (tensor, tensor, tensor, tensor) + %inserted_slice_21 = tensor.insert_slice %64#3 into %inserted[0] [1] [1] : tensor into tensor + %65 = bufferization.to_memref %inserted_slice_21 : memref + memref.copy %65, %arg14 : memref to memref + %inserted_slice_22 = tensor.insert_slice %64#2 into %2[0] [%c32] [1] : tensor into tensor + %66 = bufferization.to_memref %inserted_slice_22 : memref + memref.copy %66, %arg12 : memref to memref + %inserted_slice_23 = tensor.insert_slice %64#1 into %3[0] [%c32] [1] : tensor into tensor + %67 = bufferization.to_memref %inserted_slice_23 : memref + memref.copy %67, %arg11 : memref to memref + %inserted_slice_24 = tensor.insert_slice %64#0 into %63[0] [%c32] [1] : tensor into tensor + %68 = bufferization.to_memref %inserted_slice_24 : memref + memref.copy %68, %arg10 : memref to memref + %69 = linalg.generic {doc = "", indexing_maps = [#map14, #map14], iterator_types = ["parallel"], library_call = ""} ins(%inserted_slice_22 : tensor) outs(%1 : tensor) { + ^bb0(%in: f64, %out: f64): + %71 = arith.mulf %arg8, %out : f64 + %72 = arith.addf %in, %71 : f64 + linalg.yield %72 : f64 + } -> tensor + %70 = bufferization.to_memref %69 : memref + memref.copy %70, %arg13 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex9p_mass_convection_2d.frontend.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex9p_mass_convection_2d.frontend.mlir new file mode 100644 index 000000000000..9ae053424a69 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex9p_mass_convection_2d.frontend.mlir @@ -0,0 +1,426 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex9p_mass_convection_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: f64, %arg8: f64, %arg9: memref, %arg10: memref, %arg11: memref, %arg12: memref, %arg13: memref, %arg14: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x5xf64> + %alloca_1 = memref.alloca() : memref<2x4x5xf64> + affine.for %arg15 = 0 to 2 { + affine.for %arg16 = 0 to 4 { + affine.for %arg17 = 0 to 5 { + %1 = affine.for %arg18 = 0 to 4 iter_args(%arg19 = %cst) -> (f64) { + %2 = affine.load %arg0[%arg18 + %arg17 * 4] : memref + %3 = affine.load %arg5[%arg18 + %arg15 * 16 + %arg16 * 4] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %arg19, %4 : f64 + affine.yield %5 : f64 + } + affine.store %1, %alloca_1[%arg15, %arg16, %arg17] : memref<2x4x5xf64> + } + } + } + affine.for %arg15 = 0 to 2 { + affine.for %arg16 = 0 to 5 { + affine.for %arg17 = 0 to 5 { + %1 = affine.for %arg18 = 0 to 4 iter_args(%arg19 = %cst) -> (f64) { + %2 = affine.load %arg0[%arg18 + %arg16 * 4] : memref + %3 = affine.load %alloca_1[%arg15, %arg18, %arg17] : memref<2x4x5xf64> + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %arg19, %4 : f64 + affine.yield %5 : f64 + } + affine.store %1, %alloca_0[%arg15, %arg16, %arg17] : memref<2x5x5xf64> + } + } + } + affine.for %arg15 = 0 to 2 { + affine.for %arg16 = 0 to 5 { + affine.for %arg17 = 0 to 5 { + %1 = affine.load %arg3[%arg17 + %arg15 * 25 + %arg16 * 5] : memref + %2 = affine.load %alloca_0[%arg15, %arg16, %arg17] : memref<2x5x5xf64> + %3 = arith.mulf %2, %1 : f64 + affine.store %3, %alloca_0[%arg15, %arg16, %arg17] : memref<2x5x5xf64> + } + } + } + affine.for %arg15 = 0 to 2 { + affine.for %arg16 = 0 to 5 { + affine.for %arg17 = 0 to 4 { + %1 = affine.for %arg18 = 0 to 5 iter_args(%arg19 = %cst) -> (f64) { + %2 = affine.load %arg2[%arg18 + %arg17 * 5] : memref + %3 = affine.load %alloca_0[%arg15, %arg16, %arg18] : memref<2x5x5xf64> + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %arg19, %4 : f64 + affine.yield %5 : f64 + } + affine.store %1, %alloca[%arg15, %arg16, %arg17] : memref<2x5x4xf64> + } + } + } + affine.for %arg15 = 0 to 2 { + affine.for %arg16 = 0 to 4 { + affine.for %arg17 = 0 to 4 { + %1 = affine.for %arg18 = 0 to 5 iter_args(%arg19 = %cst) -> (f64) { + %4 = affine.load %arg2[%arg18 + %arg16 * 5] : memref + %5 = affine.load %alloca[%arg15, %arg18, %arg17] : memref<2x5x4xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %arg19, %6 : f64 + affine.yield %7 : f64 + } + %2 = affine.load %arg9[%arg17 + %arg15 * 16 + %arg16 * 4] : memref + %3 = arith.addf %2, %1 : f64 + affine.store %3, %arg9[%arg17 + %arg15 * 16 + %arg16 * 4] : memref + } + } + } + %alloca_2 = memref.alloca() : memref<2x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5xf64> + %alloca_5 = memref.alloca() : memref<2x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x4x5xf64> + %alloca_7 = memref.alloca() : memref<2x4x5xf64> + affine.for %arg15 = 0 to 2 { + affine.for %arg16 = 0 to 4 { + affine.for %arg17 = 0 to 5 { + %1 = affine.for %arg18 = 0 to 4 iter_args(%arg19 = %cst) -> (f64) { + %2 = affine.load %arg5[%arg18 + %arg15 * 16 + %arg16 * 4] : memref + %3 = affine.load %arg0[%arg18 + %arg17 * 4] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %arg19, %4 : f64 + affine.yield %5 : f64 + } + affine.store %1, %alloca_7[%arg15, %arg16, %arg17] : memref<2x4x5xf64> + } + } + } + affine.for %arg15 = 0 to 2 { + affine.for %arg16 = 0 to 4 { + affine.for %arg17 = 0 to 5 { + %1 = affine.for %arg18 = 0 to 4 iter_args(%arg19 = %cst) -> (f64) { + %2 = affine.load %arg5[%arg18 + %arg15 * 16 + %arg16 * 4] : memref + %3 = affine.load %arg1[%arg18 + %arg17 * 4] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %arg19, %4 : f64 + affine.yield %5 : f64 + } + affine.store %1, %alloca_6[%arg15, %arg16, %arg17] : memref<2x4x5xf64> + } + } + } + affine.for %arg15 = 0 to 2 { + affine.for %arg16 = 0 to 5 { + affine.for %arg17 = 0 to 5 { + %1 = affine.for %arg18 = 0 to 4 iter_args(%arg19 = %cst) -> (f64) { + %2 = affine.load %alloca_6[%arg15, %arg18, %arg17] : memref<2x4x5xf64> + %3 = affine.load %arg0[%arg18 + %arg16 * 4] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %arg19, %4 : f64 + affine.yield %5 : f64 + } + affine.store %1, %alloca_5[%arg15, %arg16, %arg17] : memref<2x5x5xf64> + } + } + } + affine.for %arg15 = 0 to 2 { + affine.for %arg16 = 0 to 5 { + affine.for %arg17 = 0 to 5 { + %1 = affine.for %arg18 = 0 to 4 iter_args(%arg19 = %cst) -> (f64) { + %2 = affine.load %alloca_7[%arg15, %arg18, %arg17] : memref<2x4x5xf64> + %3 = affine.load %arg1[%arg18 + %arg16 * 4] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %arg19, %4 : f64 + affine.yield %5 : f64 + } + affine.store %1, %alloca_4[%arg15, %arg16, %arg17] : memref<2x5x5xf64> + } + } + } + affine.for %arg15 = 0 to 2 { + affine.for %arg16 = 0 to 5 { + affine.for %arg17 = 0 to 4 { + %1 = affine.for %arg18 = 0 to 5 iter_args(%arg19 = %cst) -> (f64) { + %2 = affine.load %arg4[%arg18 + %arg15 * 50 + %arg16 * 5] : memref + %3 = affine.load %alloca_5[%arg15, %arg16, %arg18] : memref<2x5x5xf64> + %4 = arith.mulf %2, %3 : f64 + %5 = affine.load %arg4[%arg18 + %arg15 * 50 + %arg16 * 5 + 25] : memref + %6 = affine.load %alloca_4[%arg15, %arg16, %arg18] : memref<2x5x5xf64> + %7 = arith.mulf %5, %6 : f64 + %8 = arith.addf %4, %7 : f64 + %9 = affine.load %arg2[%arg18 + %arg17 * 5] : memref + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %arg19, %10 : f64 + affine.yield %11 : f64 + } + affine.store %1, %alloca_3[%arg15, %arg16, %arg17] : memref<2x5x4xf64> + } + } + } + affine.for %arg15 = 0 to 2 { + affine.for %arg16 = 0 to 4 { + affine.for %arg17 = 0 to 4 { + %1 = affine.for %arg18 = 0 to 5 iter_args(%arg19 = %cst) -> (f64) { + %2 = affine.load %alloca_3[%arg15, %arg18, %arg17] : memref<2x5x4xf64> + %3 = affine.load %arg2[%arg18 + %arg16 * 5] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %arg19, %4 : f64 + affine.yield %5 : f64 + } + affine.store %1, %alloca_2[%arg15, %arg16, %arg17] : memref<2x4x4xf64> + } + } + } + affine.for %arg15 = 0 to 2 { + affine.for %arg16 = 0 to 4 { + affine.for %arg17 = 0 to 4 { + %1 = affine.load %alloca_2[%arg15, %arg16, %arg17] : memref<2x4x4xf64> + %2 = affine.load %arg10[%arg17 + %arg15 * 16 + %arg16 * 4] : memref + %3 = arith.addf %2, %1 : f64 + affine.store %3, %arg10[%arg17 + %arg15 * 16 + %arg16 * 4] : memref + } + } + } + %0 = affine.for %arg15 = 0 to 32 iter_args(%arg16 = %cst) -> (f64) { + %1 = affine.load %arg13[%arg15] : memref + %2 = arith.mulf %arg7, %1 : f64 + %3 = affine.load %arg10[%arg15] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg10[%arg15] : memref + %5 = affine.load %arg9[%arg15] : memref + %6 = arith.mulf %arg7, %5 : f64 + %7 = affine.load %arg11[%arg15] : memref + %8 = arith.subf %7, %6 : f64 + affine.store %8, %arg11[%arg15] : memref + %9 = affine.load %arg6[%arg15] : memref + %10 = arith.mulf %9, %8 : f64 + affine.store %10, %arg12[%arg15] : memref + %11 = affine.load %arg11[%arg15] : memref + %12 = arith.mulf %11, %10 : f64 + %13 = arith.addf %arg16, %12 : f64 + affine.yield %13 : f64 + } + affine.for %arg15 = 0 to 32 { + %1 = affine.load %arg12[%arg15] : memref + %2 = affine.load %arg13[%arg15] : memref + %3 = arith.mulf %arg8, %2 : f64 + %4 = arith.addf %1, %3 : f64 + affine.store %4, %arg13[%arg15] : memref + } + affine.store %0, %arg14[0] : memref + return + } + func.func @mfem_pa_mass_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x5xf64> + %alloca_1 = memref.alloca() : memref<2x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg8 + %arg7 * 4] : memref + %2 = affine.load %arg3[%arg8 + %arg5 * 16 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg5, %arg6, %arg7] : memref<2x4x5xf64> + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg8 + %arg6 * 4] : memref + %2 = affine.load %alloca_1[%arg5, %arg8, %arg7] : memref<2x4x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg5, %arg6, %arg7] : memref<2x5x5xf64> + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.load %arg2[%arg7 + %arg5 * 25 + %arg6 * 5] : memref + %1 = affine.load %alloca_0[%arg5, %arg6, %arg7] : memref<2x5x5xf64> + %2 = arith.mulf %1, %0 : f64 + affine.store %2, %alloca_0[%arg5, %arg6, %arg7] : memref<2x5x5xf64> + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg8 + %arg7 * 5] : memref + %2 = affine.load %alloca_0[%arg5, %arg6, %arg8] : memref<2x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg5, %arg6, %arg7] : memref<2x5x4xf64> + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %3 = affine.load %arg1[%arg8 + %arg6 * 5] : memref + %4 = affine.load %alloca[%arg5, %arg8, %arg7] : memref<2x5x4xf64> + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg9, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg4[%arg7 + %arg5 * 16 + %arg6 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg4[%arg7 + %arg5 * 16 + %arg6 * 4] : memref + } + } + } + return + } + func.func @mfem_pa_convection_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x5xf64> + %alloca_2 = memref.alloca() : memref<2x5x5xf64> + %alloca_3 = memref.alloca() : memref<2x4x5xf64> + %alloca_4 = memref.alloca() : memref<2x4x5xf64> + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg9 + %arg6 * 16 + %arg7 * 4] : memref + %2 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg6, %arg7, %arg8] : memref<2x4x5xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg9 + %arg6 * 16 + %arg7 * 4] : memref + %2 = affine.load %arg1[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg6, %arg7, %arg8] : memref<2x4x5xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg6, %arg9, %arg8] : memref<2x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg6, %arg7, %arg8] : memref<2x5x5xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg6, %arg9, %arg8] : memref<2x4x5xf64> + %2 = affine.load %arg1[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg6, %arg7, %arg8] : memref<2x5x5xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg3[%arg9 + %arg6 * 50 + %arg7 * 5] : memref + %2 = affine.load %alloca_2[%arg6, %arg7, %arg9] : memref<2x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg3[%arg9 + %arg6 * 50 + %arg7 * 5 + 25] : memref + %5 = affine.load %alloca_1[%arg6, %arg7, %arg9] : memref<2x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg2[%arg9 + %arg8 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg10, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_0[%arg6, %arg7, %arg8] : memref<2x5x4xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_0[%arg6, %arg9, %arg8] : memref<2x5x4xf64> + %2 = affine.load %arg2[%arg9 + %arg7 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg6, %arg7, %arg8] : memref<2x4x4xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca[%arg6, %arg7, %arg8] : memref<2x4x4xf64> + %1 = affine.load %arg5[%arg8 + %arg6 * 16 + %arg7 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg5[%arg8 + %arg6 * 16 + %arg7 * 4] : memref + } + } + } + return + } + func.func @mfem_mass_pcg_step_2d(%arg0: memref, %arg1: memref, %arg2: f64, %arg3: f64, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = affine.for %arg9 = 0 to 32 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg9] : memref + %2 = arith.mulf %arg2, %1 : f64 + %3 = affine.load %arg4[%arg9] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg4[%arg9] : memref + %5 = affine.load %arg0[%arg9] : memref + %6 = arith.mulf %arg2, %5 : f64 + %7 = affine.load %arg5[%arg9] : memref + %8 = arith.subf %7, %6 : f64 + affine.store %8, %arg5[%arg9] : memref + %9 = affine.load %arg1[%arg9] : memref + %10 = arith.mulf %9, %8 : f64 + affine.store %10, %arg6[%arg9] : memref + %11 = affine.load %arg5[%arg9] : memref + %12 = arith.mulf %11, %10 : f64 + %13 = arith.addf %arg10, %12 : f64 + affine.yield %13 : f64 + } + affine.for %arg9 = 0 to 32 { + %1 = affine.load %arg6[%arg9] : memref + %2 = affine.load %arg7[%arg9] : memref + %3 = arith.mulf %arg3, %2 : f64 + %4 = arith.addf %1, %3 : f64 + affine.store %4, %arg7[%arg9] : memref + } + affine.store %0, %arg8[0] : memref + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex9p_mass_convection_2d.matched.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex9p_mass_convection_2d.matched.mlir new file mode 100644 index 000000000000..c7d4c5712ad2 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex9p_mass_convection_2d.matched.mlir @@ -0,0 +1,231 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2) -> (d2 + d0 * 25 + d1 * 5)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map11 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +#map12 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 50 + d1 * 5)> +#map13 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 50 + d1 * 5 + 25)> +#map14 = affine_map<(d0) -> (d0)> +#map15 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex9p_mass_convection_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: f64, %arg8: f64, %arg9: memref, %arg10: memref, %arg11: memref, %arg12: memref, %arg13: memref, %arg14: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c32 = arith.constant 32 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg14 : memref + %1 = bufferization.to_tensor %arg13 : memref + %2 = bufferization.to_tensor %arg12 : memref + %3 = bufferization.to_tensor %arg11 : memref + %4 = bufferization.to_tensor %arg10 : memref + %5 = bufferization.to_tensor %arg9 : memref + %6 = bufferization.to_tensor %arg6 : memref + %7 = bufferization.to_tensor %arg5 : memref + %8 = bufferization.to_tensor %arg4 : memref + %9 = bufferization.to_tensor %arg3 : memref + %10 = bufferization.to_tensor %arg2 : memref + %11 = bufferization.to_tensor %arg1 : memref + %12 = bufferization.to_tensor %arg0 : memref + %13 = tensor.empty() : tensor<2x5x4xf64> + %14 = tensor.empty() : tensor<2x5x5xf64> + %15 = tensor.empty() : tensor<2x4x5xf64> + %extracted_slice = tensor.extract_slice %15[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %16 into %15[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %17 = polygeist.submap(%12, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %18 = polygeist.submap(%7, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v17_contract_19_tc0 = tensor.cast %17 : tensor to tensor<*xf64> + + %v18_contract_19_tc1 = tensor.cast %18 : tensor to tensor<*xf64> + + %inserted_slice_contract_19_tc2 = tensor.cast %inserted_slice : tensor<2x4x5xf64> to tensor<*xf64> + + %v19_tdyn = kernel.launch @cutensornetContraction2_f64(%v17_contract_19_tc0, %v18_contract_19_tc1, %inserted_slice_contract_19_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %19 = tensor.cast %v19_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %extracted_slice_0 = tensor.extract_slice %14[0, 0, 0] [%c2, %c5, %c5] [1, 1, 1] : tensor<2x5x5xf64> to tensor + %extracted_slice_1 = tensor.extract_slice %19[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %21 = polygeist.submap(%12, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %v21_contract_22_tc0 = tensor.cast %21 : tensor to tensor<*xf64> + + %extracted_slice_1_contract_22_tc1 = tensor.cast %extracted_slice_1 : tensor to tensor<*xf64> + + %extracted_slice_0_contract_22_tc2 = tensor.cast %extracted_slice_0 : tensor to tensor<*xf64> + + %v22_tdyn = kernel.launch @cutensornetContraction2_f64(%v21_contract_22_tc0, %extracted_slice_1_contract_22_tc1, %extracted_slice_0_contract_22_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %22 = tensor.cast %v22_tdyn : tensor<*xf64> to tensor + %23 = polygeist.submap(%9, %c2, %c5, %c5) {map = #map7} : (tensor, index, index, index) -> tensor + %24 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%23 : tensor) outs(%22 : tensor) { + ^bb0(%in: f64, %out: f64): + %71 = arith.mulf %out, %in : f64 + linalg.yield %71 : f64 + } -> tensor + %extracted_slice_2 = tensor.extract_slice %13[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %26 = polygeist.submap(%10, %c2, %c5, %c4, %c5) {map = #map8} : (tensor, index, index, index, index) -> tensor + %v26_contract_27_tc0 = tensor.cast %26 : tensor to tensor<*xf64> + + %v24_contract_27_tc1 = tensor.cast %24 : tensor to tensor<*xf64> + + %extracted_slice_2_contract_27_tc2 = tensor.cast %extracted_slice_2 : tensor to tensor<*xf64> + + %v27_tdyn = kernel.launch @cutensornetContraction2_f64(%v26_contract_27_tc0, %v24_contract_27_tc1, %extracted_slice_2_contract_27_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %27 = tensor.cast %v27_tdyn : tensor<*xf64> to tensor + %28 = polygeist.submap(%10, %c2, %c4, %c4, %c5) {map = #map10} : (tensor, index, index, index, index) -> tensor + %29 = polygeist.submap(%5, %c2, %c4, %c4) {map = #map11} : (tensor, index, index, index) -> tensor<2x4x4xf64> + %30 = linalg.generic {doc = "", indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%28, %27 : tensor, tensor) outs(%29 : tensor<2x4x4xf64>) { + ^bb0(%in: f64, %in_25: f64, %out: f64): + %71 = arith.mulf %in, %in_25 : f64 + %72 = arith.addf %out, %71 : f64 + linalg.yield %72 : f64 + } -> tensor<2x4x4xf64> + %31 = polygeist.submapInverse(%5, %30, %c2, %c4, %c4) {map = #map11} : (tensor, tensor<2x4x4xf64>, index, index, index) -> tensor + %32 = bufferization.to_memref %31 : memref + memref.copy %32, %arg9 : memref to memref + %33 = tensor.empty() : tensor<2x4x4xf64> + %34 = tensor.empty() : tensor<2x5x4xf64> + %35 = tensor.empty() : tensor<2x5x5xf64> + %36 = tensor.empty() : tensor<2x5x5xf64> + %37 = tensor.empty() : tensor<2x4x5xf64> + %38 = tensor.empty() : tensor<2x4x5xf64> + %extracted_slice_3 = tensor.extract_slice %38[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %39 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_3 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_4 = tensor.insert_slice %39 into %38[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %40 = polygeist.submap(%12, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %41 = polygeist.submap(%7, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v41_contract_42_tc0 = tensor.cast %41 : tensor to tensor<*xf64> + + %v40_contract_42_tc1 = tensor.cast %40 : tensor to tensor<*xf64> + + %inserted_slice_4_contract_42_tc2 = tensor.cast %inserted_slice_4 : tensor<2x4x5xf64> to tensor<*xf64> + + %v42_tdyn = kernel.launch @cutensornetContraction2_f64(%v41_contract_42_tc0, %v40_contract_42_tc1, %inserted_slice_4_contract_42_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %42 = tensor.cast %v42_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %extracted_slice_5 = tensor.extract_slice %37[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %43 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_5 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_6 = tensor.insert_slice %43 into %37[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %44 = polygeist.submap(%11, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %45 = polygeist.submap(%7, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v45_contract_46_tc0 = tensor.cast %45 : tensor to tensor<*xf64> + + %v44_contract_46_tc1 = tensor.cast %44 : tensor to tensor<*xf64> + + %inserted_slice_6_contract_46_tc2 = tensor.cast %inserted_slice_6 : tensor<2x4x5xf64> to tensor<*xf64> + + %v46_tdyn = kernel.launch @cutensornetContraction2_f64(%v45_contract_46_tc0, %v44_contract_46_tc1, %inserted_slice_6_contract_46_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %46 = tensor.cast %v46_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %extracted_slice_7 = tensor.extract_slice %36[0, 0, 0] [%c2, %c5, %c5] [1, 1, 1] : tensor<2x5x5xf64> to tensor + %extracted_slice_8 = tensor.extract_slice %46[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %48 = polygeist.submap(%12, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %extracted_slice_8_contract_49_tc0 = tensor.cast %extracted_slice_8 : tensor to tensor<*xf64> + + %v48_contract_49_tc1 = tensor.cast %48 : tensor to tensor<*xf64> + + %extracted_slice_7_contract_49_tc2 = tensor.cast %extracted_slice_7 : tensor to tensor<*xf64> + + %v49_tdyn = kernel.launch @cutensornetContraction2_f64(%extracted_slice_8_contract_49_tc0, %v48_contract_49_tc1, %extracted_slice_7_contract_49_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %49 = tensor.cast %v49_tdyn : tensor<*xf64> to tensor + %extracted_slice_9 = tensor.extract_slice %35[0, 0, 0] [%c2, %c5, %c5] [1, 1, 1] : tensor<2x5x5xf64> to tensor + %extracted_slice_10 = tensor.extract_slice %42[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %51 = polygeist.submap(%11, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %extracted_slice_10_contract_52_tc0 = tensor.cast %extracted_slice_10 : tensor to tensor<*xf64> + + %v51_contract_52_tc1 = tensor.cast %51 : tensor to tensor<*xf64> + + %extracted_slice_9_contract_52_tc2 = tensor.cast %extracted_slice_9 : tensor to tensor<*xf64> + + %v52_tdyn = kernel.launch @cutensornetContraction2_f64(%extracted_slice_10_contract_52_tc0, %v51_contract_52_tc1, %extracted_slice_9_contract_52_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %52 = tensor.cast %v52_tdyn : tensor<*xf64> to tensor + %extracted_slice_11 = tensor.extract_slice %34[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %53 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_11 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %54 = polygeist.submap(%10, %c2, %c5, %c4, %c5) {map = #map8} : (tensor, index, index, index, index) -> tensor + %55 = polygeist.submap(%8, %c2, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index) -> tensor + %56 = polygeist.submap(%8, %c2, %c5, %c4, %c5) {map = #map13} : (tensor, index, index, index, index) -> tensor + %57 = linalg.generic {doc = "", indexing_maps = [#map3, #map9, #map3, #map9, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%55, %49, %56, %52, %54 : tensor, tensor, tensor, tensor, tensor) outs(%53 : tensor) { + ^bb0(%in: f64, %in_25: f64, %in_26: f64, %in_27: f64, %in_28: f64, %out: f64): + %71 = arith.mulf %in, %in_25 : f64 + %72 = arith.mulf %in_26, %in_27 : f64 + %73 = arith.addf %71, %72 : f64 + %74 = arith.mulf %73, %in_28 : f64 + %75 = arith.addf %out, %74 : f64 + linalg.yield %75 : f64 + } -> tensor + %extracted_slice_12 = tensor.extract_slice %33[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : tensor<2x4x4xf64> to tensor + %59 = polygeist.submap(%10, %c2, %c4, %c4, %c5) {map = #map10} : (tensor, index, index, index, index) -> tensor + %v57_contract_60_tc0 = tensor.cast %57 : tensor to tensor<*xf64> + + %v59_contract_60_tc1 = tensor.cast %59 : tensor to tensor<*xf64> + + %extracted_slice_12_contract_60_tc2 = tensor.cast %extracted_slice_12 : tensor to tensor<*xf64> + + %v60_tdyn = kernel.launch @cutensornetContraction2_f64(%v57_contract_60_tc0, %v59_contract_60_tc1, %extracted_slice_12_contract_60_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %60 = tensor.cast %v60_tdyn : tensor<*xf64> to tensor + %61 = polygeist.submap(%4, %c2, %c4, %c4) {map = #map11} : (tensor, index, index, index) -> tensor + %62 = kernel.launch @cublasDaxpby(%60, %61) : (tensor, tensor) -> tensor + %63 = polygeist.submapInverse(%4, %62, %c2, %c4, %c4) {map = #map11} : (tensor, tensor, index, index, index) -> tensor + %inserted = tensor.insert %cst into %0[%c0] : tensor + %extracted_slice_13 = tensor.extract_slice %6[0] [%c32] [1] : tensor to tensor + %extracted_slice_14 = tensor.extract_slice %31[0] [%c32] [1] : tensor to tensor + %extracted_slice_15 = tensor.extract_slice %63[0] [%c32] [1] : tensor to tensor + %extracted_slice_16 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %extracted_slice_17 = tensor.extract_slice %3[0] [%c32] [1] : tensor to tensor + %extracted_slice_18 = tensor.extract_slice %2[0] [%c32] [1] : tensor to tensor + %extracted_slice_19 = tensor.extract_slice %1[0] [%c32] [1] : tensor to tensor + %extracted_slice_20 = tensor.extract_slice %inserted[0] [1] [1] : tensor to tensor + %64:4 = linalg.generic {doc = "", indexing_maps = [#map14, #map14, #map14, #map14, #map14, #map14, #map14, #map15], iterator_types = ["reduction"], library_call = ""} ins(%extracted_slice_19, %extracted_slice_14, %extracted_slice_13, %extracted_slice_16 : tensor, tensor, tensor, tensor) outs(%extracted_slice_15, %extracted_slice_17, %extracted_slice_18, %extracted_slice_20 : tensor, tensor, tensor, tensor) { + ^bb0(%in: f64, %in_25: f64, %in_26: f64, %in_27: f64, %out: f64, %out_28: f64, %out_29: f64, %out_30: f64): + %71 = arith.mulf %arg7, %in : f64 + %72 = arith.addf %out, %71 : f64 + %73 = arith.mulf %arg7, %in_25 : f64 + %74 = arith.subf %out_28, %73 : f64 + %75 = arith.mulf %in_26, %74 : f64 + %76 = arith.mulf %in_27, %75 : f64 + %77 = arith.addf %out_30, %76 : f64 + linalg.yield %72, %74, %75, %77 : f64, f64, f64, f64 + } -> (tensor, tensor, tensor, tensor) + %inserted_slice_21 = tensor.insert_slice %64#3 into %inserted[0] [1] [1] : tensor into tensor + %65 = bufferization.to_memref %inserted_slice_21 : memref + memref.copy %65, %arg14 : memref to memref + %inserted_slice_22 = tensor.insert_slice %64#2 into %2[0] [%c32] [1] : tensor into tensor + %66 = bufferization.to_memref %inserted_slice_22 : memref + memref.copy %66, %arg12 : memref to memref + %inserted_slice_23 = tensor.insert_slice %64#1 into %3[0] [%c32] [1] : tensor into tensor + %67 = bufferization.to_memref %inserted_slice_23 : memref + memref.copy %67, %arg11 : memref to memref + %inserted_slice_24 = tensor.insert_slice %64#0 into %63[0] [%c32] [1] : tensor into tensor + %68 = bufferization.to_memref %inserted_slice_24 : memref + memref.copy %68, %arg10 : memref to memref + %69 = kernel.launch @cublasDaxpby(%inserted_slice_22, %1, %arg8) : (tensor, tensor, f64) -> tensor + %70 = bufferization.to_memref %69 : memref + memref.copy %70, %arg13 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex9p_mass_convection_2d.raised.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex9p_mass_convection_2d.raised.mlir new file mode 100644 index 000000000000..ecb39ffae5fb --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_ex9p_mass_convection_2d.raised.mlir @@ -0,0 +1,214 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2) -> (d2 + d0 * 25 + d1 * 5)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map11 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +#map12 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 50 + d1 * 5)> +#map13 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 50 + d1 * 5 + 25)> +#map14 = affine_map<(d0) -> (d0)> +#map15 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_ex9p_mass_convection_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: f64, %arg8: f64, %arg9: memref, %arg10: memref, %arg11: memref, %arg12: memref, %arg13: memref, %arg14: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c32 = arith.constant 32 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x5xf64> + %alloca_1 = memref.alloca() : memref<2x4x5xf64> + %subview = memref.subview %alloca_1[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg0, %c2, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg5, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_1 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_40: f64, %out: f64): + %18 = arith.mulf %in, %in_40 : f64 + %19 = arith.addf %out, %18 : f64 + linalg.yield %19 : f64 + } + %subview_2 = memref.subview %alloca_0[0, 0, 0] [%c2, %c5, %c5] [1, 1, 1] : memref<2x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_2 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg0, %c2, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index) -> memref + %subview_3 = memref.subview %alloca_1[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + %subview_4 = memref.subview %alloca_0[0, 0, 0] [%c2, %c5, %c5] [1, 1, 1] : memref<2x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%2, %subview_3 : memref, memref>) outs(%subview_4 : memref>) { + ^bb0(%in: f64, %in_40: f64, %out: f64): + %18 = arith.mulf %in, %in_40 : f64 + %19 = arith.addf %out, %18 : f64 + linalg.yield %19 : f64 + } + %3 = polygeist.submap(%arg3, %c2, %c5, %c5) {map = #map7} : (memref, index, index, index) -> memref + %subview_5 = memref.subview %alloca_0[0, 0, 0] [%c2, %c5, %c5] [1, 1, 1] : memref<2x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3 : memref) outs(%subview_5 : memref>) { + ^bb0(%in: f64, %out: f64): + %18 = arith.mulf %out, %in : f64 + linalg.yield %18 : f64 + } + %subview_6 = memref.subview %alloca[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_6 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg2, %c2, %c5, %c4, %c5) {map = #map8} : (memref, index, index, index, index) -> memref + %subview_7 = memref.subview %alloca_0[0, 0, 0] [%c2, %c5, %c5] [1, 1, 1] : memref<2x5x5xf64> to memref> + %subview_8 = memref.subview %alloca[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map9, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%4, %subview_7 : memref, memref>) outs(%subview_8 : memref>) { + ^bb0(%in: f64, %in_40: f64, %out: f64): + %18 = arith.mulf %in, %in_40 : f64 + %19 = arith.addf %out, %18 : f64 + linalg.yield %19 : f64 + } + %5 = polygeist.submap(%arg2, %c2, %c4, %c4, %c5) {map = #map10} : (memref, index, index, index, index) -> memref + %subview_9 = memref.subview %alloca[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + %6 = polygeist.submap(%arg9, %c2, %c4, %c4) {map = #map11} : (memref, index, index, index) -> memref<2x4x4xf64> + linalg.generic {indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%5, %subview_9 : memref, memref>) outs(%6 : memref<2x4x4xf64>) { + ^bb0(%in: f64, %in_40: f64, %out: f64): + %18 = arith.mulf %in, %in_40 : f64 + %19 = arith.addf %out, %18 : f64 + linalg.yield %19 : f64 + } + %alloca_10 = memref.alloca() : memref<2x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x5xf64> + %alloca_13 = memref.alloca() : memref<2x5x5xf64> + %alloca_14 = memref.alloca() : memref<2x4x5xf64> + %alloca_15 = memref.alloca() : memref<2x4x5xf64> + %subview_16 = memref.subview %alloca_15[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_16 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %7 = polygeist.submap(%arg5, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + %8 = polygeist.submap(%arg0, %c2, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%7, %8 : memref, memref) outs(%alloca_15 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_40: f64, %out: f64): + %18 = arith.mulf %in, %in_40 : f64 + %19 = arith.addf %out, %18 : f64 + linalg.yield %19 : f64 + } + %subview_17 = memref.subview %alloca_14[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_17 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %9 = polygeist.submap(%arg5, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + %10 = polygeist.submap(%arg1, %c2, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%9, %10 : memref, memref) outs(%alloca_14 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_40: f64, %out: f64): + %18 = arith.mulf %in, %in_40 : f64 + %19 = arith.addf %out, %18 : f64 + linalg.yield %19 : f64 + } + %subview_18 = memref.subview %alloca_13[0, 0, 0] [%c2, %c5, %c5] [1, 1, 1] : memref<2x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_18 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_19 = memref.subview %alloca_14[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + %11 = polygeist.submap(%arg0, %c2, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index) -> memref + %subview_20 = memref.subview %alloca_13[0, 0, 0] [%c2, %c5, %c5] [1, 1, 1] : memref<2x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_19, %11 : memref>, memref) outs(%subview_20 : memref>) { + ^bb0(%in: f64, %in_40: f64, %out: f64): + %18 = arith.mulf %in, %in_40 : f64 + %19 = arith.addf %out, %18 : f64 + linalg.yield %19 : f64 + } + %subview_21 = memref.subview %alloca_12[0, 0, 0] [%c2, %c5, %c5] [1, 1, 1] : memref<2x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_21 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_22 = memref.subview %alloca_15[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + %12 = polygeist.submap(%arg1, %c2, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index) -> memref + %subview_23 = memref.subview %alloca_12[0, 0, 0] [%c2, %c5, %c5] [1, 1, 1] : memref<2x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_22, %12 : memref>, memref) outs(%subview_23 : memref>) { + ^bb0(%in: f64, %in_40: f64, %out: f64): + %18 = arith.mulf %in, %in_40 : f64 + %19 = arith.addf %out, %18 : f64 + linalg.yield %19 : f64 + } + %subview_24 = memref.subview %alloca_11[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_24 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %13 = polygeist.submap(%arg4, %c2, %c5, %c4, %c5) {map = #map12} : (memref, index, index, index, index) -> memref + %subview_25 = memref.subview %alloca_13[0, 0, 0] [%c2, %c5, %c5] [1, 1, 1] : memref<2x5x5xf64> to memref> + %14 = polygeist.submap(%arg4, %c2, %c5, %c4, %c5) {map = #map13} : (memref, index, index, index, index) -> memref + %subview_26 = memref.subview %alloca_12[0, 0, 0] [%c2, %c5, %c5] [1, 1, 1] : memref<2x5x5xf64> to memref> + %15 = polygeist.submap(%arg2, %c2, %c5, %c4, %c5) {map = #map8} : (memref, index, index, index, index) -> memref + %subview_27 = memref.subview %alloca_11[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map9, #map3, #map9, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%13, %subview_25, %14, %subview_26, %15 : memref, memref>, memref, memref>, memref) outs(%subview_27 : memref>) { + ^bb0(%in: f64, %in_40: f64, %in_41: f64, %in_42: f64, %in_43: f64, %out: f64): + %18 = arith.mulf %in, %in_40 : f64 + %19 = arith.mulf %in_41, %in_42 : f64 + %20 = arith.addf %18, %19 : f64 + %21 = arith.mulf %20, %in_43 : f64 + %22 = arith.addf %out, %21 : f64 + linalg.yield %22 : f64 + } + %subview_28 = memref.subview %alloca_10[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_28 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_29 = memref.subview %alloca_11[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + %16 = polygeist.submap(%arg2, %c2, %c4, %c4, %c5) {map = #map10} : (memref, index, index, index, index) -> memref + %subview_30 = memref.subview %alloca_10[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_29, %16 : memref>, memref) outs(%subview_30 : memref>) { + ^bb0(%in: f64, %in_40: f64, %out: f64): + %18 = arith.mulf %in, %in_40 : f64 + %19 = arith.addf %out, %18 : f64 + linalg.yield %19 : f64 + } + %subview_31 = memref.subview %alloca_10[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + %17 = polygeist.submap(%arg10, %c2, %c4, %c4) {map = #map11} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview_31 : memref>) outs(%17 : memref) { + ^bb0(%in: f64, %out: f64): + %18 = arith.addf %out, %in : f64 + linalg.yield %18 : f64 + } + affine.store %cst, %arg14[0] : memref + %subview_32 = memref.subview %arg13[0] [%c32] [1] : memref to memref> + %subview_33 = memref.subview %arg9[0] [%c32] [1] : memref to memref> + %subview_34 = memref.subview %arg6[0] [%c32] [1] : memref to memref> + %subview_35 = memref.subview %arg11[0] [%c32] [1] : memref to memref> + %subview_36 = memref.subview %arg10[0] [%c32] [1] : memref to memref> + %subview_37 = memref.subview %arg11[0] [%c32] [1] : memref to memref> + %subview_38 = memref.subview %arg12[0] [%c32] [1] : memref to memref> + %subview_39 = memref.subview %arg14[0] [1] [1] : memref to memref> + linalg.generic {indexing_maps = [#map14, #map14, #map14, #map14, #map14, #map14, #map14, #map15], iterator_types = ["reduction"]} ins(%subview_32, %subview_33, %subview_34, %subview_35 : memref>, memref>, memref>, memref>) outs(%subview_36, %subview_37, %subview_38, %subview_39 : memref>, memref>, memref>, memref>) { + ^bb0(%in: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64, %out_43: f64, %out_44: f64, %out_45: f64): + %18 = arith.mulf %arg7, %in : f64 + %19 = arith.addf %out, %18 : f64 + %20 = arith.mulf %arg7, %in_40 : f64 + %21 = arith.subf %out_43, %20 : f64 + %22 = arith.mulf %in_41, %21 : f64 + %23 = arith.mulf %in_42, %22 : f64 + %24 = arith.addf %out_45, %23 : f64 + linalg.yield %19, %21, %22, %24 : f64, f64, f64, f64 + } + linalg.generic {indexing_maps = [#map14, #map14], iterator_types = ["parallel"]} ins(%arg12 : memref) outs(%arg13 : memref) { + ^bb0(%in: f64, %out: f64): + %18 = arith.mulf %arg8, %out : f64 + %19 = arith.addf %in, %18 : f64 + linalg.yield %19 : f64 + } + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d.debufferized.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d.debufferized.mlir new file mode 100644 index 000000000000..d1c62e3888ef --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d.debufferized.mlir @@ -0,0 +1,430 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 108)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 125 + d1 * 25 + d2 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 108)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map21 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map22 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 3)> +#map23 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 3)> +#map24 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 4)> +#map25 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 4 + d0 * 108)> +#map26 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map27 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +#map28 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 3)> +#map29 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 4)> +#map30 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 3 + d0 * 108 + 36)> +#map31 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 4)> +#map32 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 9 + d5 * 3 + d0 * 108 + 72)> +#map33 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750)> +#map34 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 125)> +#map35 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 250)> +#map36 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 375)> +#map37 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 500)> +#map38 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 625)> +#map39 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 5)> +#map40 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 5)> +#map41 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 5)> +#map42 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_grad_div_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg9 : memref + %1 = bufferization.to_tensor %arg8 : memref + %2 = bufferization.to_tensor %arg7 : memref + %3 = bufferization.to_tensor %arg6 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg3 : memref + %7 = bufferization.to_tensor %arg2 : memref + %8 = bufferization.to_tensor %arg1 : memref + %9 = bufferization.to_tensor %arg0 : memref + %10 = tensor.empty() : tensor<2x5x4x4xf64> + %11 = tensor.empty() : tensor<2x5x4x4xf64> + %12 = tensor.empty() : tensor<2x5x4x4xf64> + %13 = tensor.empty() : tensor<2x5x5x4xf64> + %14 = tensor.empty() : tensor<2x5x5x4xf64> + %15 = tensor.empty() : tensor<2x5x5x4xf64> + %16 = tensor.empty() : tensor<2x5x5x5xf64> + %17 = tensor.empty() : tensor<2x5x5x5xf64> + %18 = tensor.empty() : tensor<2x5x5x5xf64> + %19 = tensor.empty() : tensor<2x4x5x5xf64> + %20 = tensor.empty() : tensor<2x4x5x5xf64> + %21 = tensor.empty() : tensor<2x4x5x5xf64> + %22 = tensor.empty() : tensor<2x4x4x5xf64> + %23 = tensor.empty() : tensor<2x4x4x5xf64> + %24 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice = tensor.extract_slice %24[0, 0, 0, 0] [%c2, %c3, %c3, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %26 = polygeist.submap(%5, %c2, %c3, %c3, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %27 = polygeist.submap(%1, %c2, %c3, %c3, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%27, %26 : tensor, tensor) outs(%25 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_0 = tensor.extract_slice %21[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %29 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_0 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %30 = polygeist.submap(%9, %c2, %c3, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %31 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%28, %30 : tensor, tensor) outs(%29 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_1 = tensor.extract_slice %18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %32 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_1 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %33 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %34 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%31, %33 : tensor, tensor) outs(%32 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_2 = tensor.extract_slice %23[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %35 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_2 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %36 = polygeist.submap(%9, %c2, %c3, %c4, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %37 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c3) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %38 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%37, %36 : tensor, tensor) outs(%35 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_3 = tensor.extract_slice %20[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %39 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_3 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %40 = polygeist.submap(%5, %c2, %c3, %c5, %c5, %c4) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %41 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%38, %40 : tensor, tensor) outs(%39 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_4 = tensor.extract_slice %17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %42 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_4 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %43 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %44 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%41, %43 : tensor, tensor) outs(%42 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_5 = tensor.extract_slice %22[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %45 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_5 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %46 = polygeist.submap(%9, %c2, %c4, %c3, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %47 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c3) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %48 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%47, %46 : tensor, tensor) outs(%45 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_6 = tensor.extract_slice %19[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %49 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_6 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %50 = polygeist.submap(%9, %c2, %c4, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %51 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%48, %50 : tensor, tensor) outs(%49 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_7 = tensor.extract_slice %16[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %52 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_7 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %53 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %54 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%51, %53 : tensor, tensor) outs(%52 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_8 = tensor.extract_slice %15[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_8 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %56 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %57 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %58 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%57, %34, %44, %54, %56 : tensor, tensor, tensor, tensor, tensor) outs(%55 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %in_27: f64, %out: f64): + %136 = arith.addf %in_24, %in_25 : f64 + %137 = arith.addf %136, %in_26 : f64 + %138 = arith.mulf %in, %137 : f64 + %139 = arith.mulf %138, %in_27 : f64 + %140 = arith.addf %out, %139 : f64 + linalg.yield %140 : f64 + } -> tensor + %extracted_slice_9 = tensor.extract_slice %14[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %59 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_9 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %60 = polygeist.submap(%7, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %61 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %62 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%61, %34, %44, %54, %60 : tensor, tensor, tensor, tensor, tensor) outs(%59 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %in_27: f64, %out: f64): + %136 = arith.addf %in_24, %in_25 : f64 + %137 = arith.addf %136, %in_26 : f64 + %138 = arith.mulf %in, %137 : f64 + %139 = arith.mulf %138, %in_27 : f64 + %140 = arith.addf %out, %139 : f64 + linalg.yield %140 : f64 + } -> tensor + %extracted_slice_10 = tensor.extract_slice %13[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_10 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %64 = polygeist.submap(%7, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %65 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %66 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%65, %34, %44, %54, %64 : tensor, tensor, tensor, tensor, tensor) outs(%63 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %in_27: f64, %out: f64): + %136 = arith.addf %in_24, %in_25 : f64 + %137 = arith.addf %136, %in_26 : f64 + %138 = arith.mulf %in, %137 : f64 + %139 = arith.mulf %138, %in_27 : f64 + %140 = arith.addf %out, %139 : f64 + linalg.yield %140 : f64 + } -> tensor + %extracted_slice_11 = tensor.extract_slice %12[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %67 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_11 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %68 = polygeist.submap(%7, %c2, %c5, %c3, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %69 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%58, %68 : tensor, tensor) outs(%67 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_12 = tensor.extract_slice %11[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %70 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_12 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %71 = polygeist.submap(%4, %c2, %c5, %c4, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %72 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%62, %71 : tensor, tensor) outs(%70 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %extracted_slice_13 = tensor.extract_slice %10[0, 0, 0, 0] [%c2, %c5, %c3, %c3] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %73 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_13 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %74 = polygeist.submap(%7, %c2, %c5, %c3, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %75 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%66, %74 : tensor, tensor) outs(%73 : tensor) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor + %76 = polygeist.submap(%7, %c2, %c3, %c3, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %77 = polygeist.submap(%0, %c2, %c3, %c3, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor<2x3x3x4xf64> + %78 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%69, %76 : tensor, tensor) outs(%77 : tensor<2x3x3x4xf64>) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor<2x3x3x4xf64> + %79 = polygeist.submapInverse(%0, %78, %c2, %c3, %c3, %c4) {map = #map19} : (tensor, tensor<2x3x3x4xf64>, index, index, index, index) -> tensor + %80 = polygeist.submap(%7, %c2, %c3, %c4, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %81 = polygeist.submap(%79, %c2, %c3, %c4, %c3) {map = #map20} : (tensor, index, index, index, index) -> tensor<2x3x4x3xf64> + %82 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%72, %80 : tensor, tensor) outs(%81 : tensor<2x3x4x3xf64>) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor<2x3x4x3xf64> + %83 = polygeist.submapInverse(%79, %82, %c2, %c3, %c4, %c3) {map = #map20} : (tensor, tensor<2x3x4x3xf64>, index, index, index, index) -> tensor + %84 = polygeist.submap(%4, %c2, %c4, %c3, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %85 = polygeist.submap(%83, %c2, %c4, %c3, %c3) {map = #map21} : (tensor, index, index, index, index) -> tensor<2x4x3x3xf64> + %86 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%75, %84 : tensor, tensor) outs(%85 : tensor<2x4x3x3xf64>) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor<2x4x3x3xf64> + %87 = polygeist.submapInverse(%83, %86, %c2, %c4, %c3, %c3) {map = #map21} : (tensor, tensor<2x4x3x3xf64>, index, index, index, index) -> tensor + %88 = tensor.empty() : tensor<2x3x5x5x5xf64> + %extracted_slice_14 = tensor.extract_slice %88[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %89 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_14 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %90 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map22} : (tensor, index, index, index, index, index, index, index) -> tensor + %91 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map23} : (tensor, index, index, index, index, index, index, index) -> tensor + %92 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map24} : (tensor, index, index, index, index, index, index, index) -> tensor + %93 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map25} : (tensor, index, index, index, index, index, index, index) -> tensor + %94 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%90, %91, %93, %92 : tensor, tensor, tensor, tensor) outs(%89 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %94 into %88[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_15 = tensor.extract_slice %inserted_slice[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %95 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_15 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %96 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map22} : (tensor, index, index, index, index, index, index, index) -> tensor + %97 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map28} : (tensor, index, index, index, index, index, index, index) -> tensor + %98 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map29} : (tensor, index, index, index, index, index, index, index) -> tensor + %99 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map30} : (tensor, index, index, index, index, index, index, index) -> tensor + %100 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%96, %98, %99, %97 : tensor, tensor, tensor, tensor) outs(%95 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %inserted_slice_16 = tensor.insert_slice %100 into %inserted_slice[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_17 = tensor.extract_slice %inserted_slice_16[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %101 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_17 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %102 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map23} : (tensor, index, index, index, index, index, index, index) -> tensor + %103 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map28} : (tensor, index, index, index, index, index, index, index) -> tensor + %104 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map31} : (tensor, index, index, index, index, index, index, index) -> tensor + %105 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map32} : (tensor, index, index, index, index, index, index, index) -> tensor + %106 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%104, %102, %105, %103 : tensor, tensor, tensor, tensor) outs(%101 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %inserted_slice_18 = tensor.insert_slice %106 into %inserted_slice_16[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_19 = tensor.extract_slice %inserted_slice_18[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %extracted_slice_20 = tensor.extract_slice %inserted_slice_18[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %107 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map33} : (tensor, index, index, index, index) -> tensor + %108 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map34} : (tensor, index, index, index, index) -> tensor + %109 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map35} : (tensor, index, index, index, index) -> tensor + %110 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map34} : (tensor, index, index, index, index) -> tensor + %111 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map36} : (tensor, index, index, index, index) -> tensor + %112 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map37} : (tensor, index, index, index, index) -> tensor + %113 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map35} : (tensor, index, index, index, index) -> tensor + %114 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map37} : (tensor, index, index, index, index) -> tensor + %115 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map38} : (tensor, index, index, index, index) -> tensor + %116:3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%107, %108, %109, %110, %111, %112, %113, %114, %115 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_19, %extracted_slice_20, %106 : tensor, tensor, tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %in_27: f64, %in_28: f64, %in_29: f64, %in_30: f64, %in_31: f64, %out: f64, %out_32: f64, %out_33: f64): + %136 = arith.mulf %in, %out : f64 + %137 = arith.mulf %in_24, %out_32 : f64 + %138 = arith.addf %136, %137 : f64 + %139 = arith.mulf %in_25, %out_33 : f64 + %140 = arith.addf %138, %139 : f64 + %141 = arith.mulf %in_26, %out : f64 + %142 = arith.mulf %in_27, %out_32 : f64 + %143 = arith.addf %141, %142 : f64 + %144 = arith.mulf %in_28, %out_33 : f64 + %145 = arith.addf %143, %144 : f64 + %146 = arith.mulf %in_29, %out : f64 + %147 = arith.mulf %in_30, %out_32 : f64 + %148 = arith.addf %146, %147 : f64 + %149 = arith.mulf %in_31, %out_33 : f64 + %150 = arith.addf %148, %149 : f64 + linalg.yield %140, %145, %150 : f64, f64, f64 + } -> (tensor, tensor, tensor) + %inserted_slice_21 = tensor.insert_slice %116#2 into %inserted_slice_16[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_22 = tensor.extract_slice %inserted_slice_21[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %117 = polygeist.submap(%7, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index, index, index, index) -> tensor + %118 = polygeist.submap(%7, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index, index, index, index) -> tensor + %119 = polygeist.submap(%6, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map41} : (tensor, index, index, index, index, index, index, index) -> tensor + %120 = polygeist.submap(%87, %c2, %c3, %c3, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %121 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%117, %118, %extracted_slice_22, %119 : tensor, tensor, tensor, tensor) outs(%120 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %122 = polygeist.submapInverse(%87, %121, %c2, %c3, %c3, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %extracted_slice_23 = tensor.extract_slice %inserted_slice_21[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %123 = polygeist.submap(%7, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index, index, index, index) -> tensor + %124 = polygeist.submap(%7, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map41} : (tensor, index, index, index, index, index, index, index) -> tensor + %125 = polygeist.submap(%6, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index, index, index, index) -> tensor + %126 = polygeist.submap(%122, %c2, %c3, %c4, %c3) {map = #map20} : (tensor, index, index, index, index) -> tensor + %127 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%123, %125, %extracted_slice_23, %124 : tensor, tensor, tensor, tensor) outs(%126 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %128 = polygeist.submapInverse(%122, %127, %c2, %c3, %c4, %c3) {map = #map20} : (tensor, tensor, index, index, index, index) -> tensor + %129 = polygeist.submap(%7, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index, index, index, index) -> tensor + %130 = polygeist.submap(%7, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map41} : (tensor, index, index, index, index, index, index, index) -> tensor + %131 = polygeist.submap(%6, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index, index, index, index) -> tensor + %132 = polygeist.submap(%128, %c2, %c4, %c3, %c3) {map = #map21} : (tensor, index, index, index, index) -> tensor + %133 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%131, %129, %116#2, %130 : tensor, tensor, tensor, tensor) outs(%132 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %134 = polygeist.submapInverse(%128, %133, %c2, %c4, %c3, %c3) {map = #map21} : (tensor, tensor, index, index, index, index) -> tensor + %135 = bufferization.to_memref %134 : memref + memref.copy %135, %arg9 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d.frontend.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d.frontend.mlir new file mode 100644 index 000000000000..c126e4473b17 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d.frontend.mlir @@ -0,0 +1,1070 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_grad_div_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_8 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg8[%arg11 * 12 + %arg14 + %arg12 * 4 + %arg10 * 108] : memref + %2 = affine.load %arg4[%arg14 + %arg13 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg14 + %arg12 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg14 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg8[%arg11 * 12 + %arg14 + %arg12 * 3 + %arg10 * 108 + 36] : memref + %2 = affine.load %arg0[%arg14 + %arg13 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg14 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg14 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg8[%arg11 * 9 + %arg14 + %arg12 * 3 + %arg10 * 108 + 72] : memref + %2 = affine.load %arg0[%arg14 + %arg13 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg10, %arg11, %arg12, %arg13] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg10, %arg11, %arg14, %arg13] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg14 + %arg12 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg10, %arg11, %arg12, %arg13] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg10, %arg14, %arg12, %arg13] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg14 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 125 + %arg14 + %arg11 * 25 + %arg12 * 5] : memref + %2 = affine.load %alloca_7[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg5[%arg14 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg15, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_4[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 125 + %arg14 + %arg11 * 25 + %arg12 * 5] : memref + %2 = affine.load %alloca_7[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg2[%arg14 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg15, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_3[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg10 * 125 + %arg14 + %arg11 * 25 + %arg12 * 5] : memref + %2 = affine.load %alloca_7[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg10, %arg11, %arg12, %arg14] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg2[%arg14 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg15, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_2[%arg10, %arg11, %arg12, %arg13] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg10, %arg11, %arg14, %arg13] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg14 + %arg12 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg15, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg10, %arg11, %arg12, %arg13] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %alloca_1[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %4 = affine.load %arg2[%arg14 + %arg11 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg15, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg9[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg10 * 108] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg10 * 108] : memref + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %alloca_0[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %4 = affine.load %arg2[%arg14 + %arg11 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg15, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg9[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg10 * 108 + 36] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg10 * 108 + 36] : memref + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg10, %arg14, %arg12, %arg13] : memref<2x5x4x4xf64> + %4 = affine.load %arg5[%arg14 + %arg11 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg15, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg9[%arg11 * 9 + %arg13 + %arg12 * 3 + %arg10 * 108 + 72] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 9 + %arg13 + %arg12 * 3 + %arg10 * 108 + 72] : memref + } + } + } + } + %alloca_14 = memref.alloca() : memref<2x3x5x5x5xf64> + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg14 + %arg11 * 3] : memref + %2 = affine.for %arg16 = 0 to 3 iter_args(%arg17 = %arg15) -> (f64) { + %3 = affine.load %arg0[%arg16 + %arg12 * 3] : memref + %4 = affine.for %arg18 = 0 to 4 iter_args(%arg19 = %arg17) -> (f64) { + %5 = affine.load %arg8[%arg14 * 12 + %arg18 + %arg16 * 4 + %arg10 * 108] : memref + %6 = affine.load %arg1[%arg18 + %arg13 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg19, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca_14[%arg10, 0, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 3 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg14 + %arg11 * 3] : memref + %2 = affine.for %arg16 = 0 to 4 iter_args(%arg17 = %arg15) -> (f64) { + %3 = affine.load %arg1[%arg16 + %arg12 * 4] : memref + %4 = affine.for %arg18 = 0 to 3 iter_args(%arg19 = %arg17) -> (f64) { + %5 = affine.load %arg8[%arg14 * 12 + %arg18 + %arg16 * 3 + %arg10 * 108 + 36] : memref + %6 = affine.load %arg0[%arg18 + %arg13 * 3] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg19, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca_14[%arg10, 1, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.for %arg14 = 0 to 4 iter_args(%arg15 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg14 + %arg11 * 4] : memref + %2 = affine.for %arg16 = 0 to 3 iter_args(%arg17 = %arg15) -> (f64) { + %3 = affine.load %arg0[%arg16 + %arg12 * 3] : memref + %4 = affine.for %arg18 = 0 to 3 iter_args(%arg19 = %arg17) -> (f64) { + %5 = affine.load %arg8[%arg14 * 9 + %arg18 + %arg16 * 3 + %arg10 * 108 + 72] : memref + %6 = affine.load %arg0[%arg18 + %arg13 * 3] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg19, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca_14[%arg10, 2, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %0 = affine.load %alloca_14[%arg10, 0, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %1 = affine.load %alloca_14[%arg10, 1, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %2 = affine.load %alloca_14[%arg10, 2, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %3 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750] : memref + %4 = arith.mulf %3, %0 : f64 + %5 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 125] : memref + %6 = arith.mulf %5, %1 : f64 + %7 = arith.addf %4, %6 : f64 + %8 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 250] : memref + %9 = arith.mulf %8, %2 : f64 + %10 = arith.addf %7, %9 : f64 + affine.store %10, %alloca_14[%arg10, 0, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %11 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 125] : memref + %12 = arith.mulf %11, %0 : f64 + %13 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 375] : memref + %14 = arith.mulf %13, %1 : f64 + %15 = arith.addf %12, %14 : f64 + %16 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 500] : memref + %17 = arith.mulf %16, %2 : f64 + %18 = arith.addf %15, %17 : f64 + affine.store %18, %alloca_14[%arg10, 1, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + %19 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 250] : memref + %20 = arith.mulf %19, %0 : f64 + %21 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 500] : memref + %22 = arith.mulf %21, %1 : f64 + %23 = arith.addf %20, %22 : f64 + %24 = affine.load %arg7[%arg11 * 25 + %arg13 + %arg12 * 5 + %arg10 * 750 + 625] : memref + %25 = arith.mulf %24, %2 : f64 + %26 = arith.addf %23, %25 : f64 + affine.store %26, %alloca_14[%arg10, 2, %arg11, %arg12, %arg13] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %arg2[%arg14 + %arg11 * 5] : memref + %4 = affine.for %arg16 = 0 to 5 iter_args(%arg17 = %arg15) -> (f64) { + %5 = affine.load %arg2[%arg16 + %arg12 * 5] : memref + %6 = affine.for %arg18 = 0 to 5 iter_args(%arg19 = %arg17) -> (f64) { + %7 = affine.load %alloca_14[%arg10, 0, %arg14, %arg16, %arg18] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg3[%arg18 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg19, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg9[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg10 * 108] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg10 * 108] : memref + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %arg2[%arg14 + %arg11 * 5] : memref + %4 = affine.for %arg16 = 0 to 5 iter_args(%arg17 = %arg15) -> (f64) { + %5 = affine.load %arg3[%arg16 + %arg12 * 5] : memref + %6 = affine.for %arg18 = 0 to 5 iter_args(%arg19 = %arg17) -> (f64) { + %7 = affine.load %alloca_14[%arg10, 1, %arg14, %arg16, %arg18] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg2[%arg18 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg19, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg9[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg10 * 108 + 36] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg10 * 108 + 36] : memref + } + } + } + } + affine.for %arg10 = 0 to 2 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 3 { + %0 = affine.for %arg14 = 0 to 5 iter_args(%arg15 = %cst) -> (f64) { + %3 = affine.load %arg3[%arg14 + %arg11 * 5] : memref + %4 = affine.for %arg16 = 0 to 5 iter_args(%arg17 = %arg15) -> (f64) { + %5 = affine.load %arg2[%arg16 + %arg12 * 5] : memref + %6 = affine.for %arg18 = 0 to 5 iter_args(%arg19 = %arg17) -> (f64) { + %7 = affine.load %alloca_14[%arg10, 2, %arg14, %arg16, %arg18] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg2[%arg18 + %arg13 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg19, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg9[%arg11 * 9 + %arg13 + %arg12 * 3 + %arg10 * 108 + 72] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg9[%arg11 * 9 + %arg13 + %arg12 * 3 + %arg10 * 108 + 72] : memref + } + } + } + } + return + } + func.func @mfem_pa_divdiv_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_8 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 12 + %arg11 + %arg9 * 4 + %arg7 * 108] : memref + %2 = affine.load %arg2[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 12 + %arg11 + %arg9 * 3 + %arg7 * 108 + 36] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 9 + %arg11 + %arg9 * 3 + %arg7 * 108 + 72] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg3[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg1[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg1[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca_1[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg1[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca_0[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg1[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + } + } + } + } + return + } + func.func @mfem_pa_hdiv_mass_apply_3d_direct(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x3x5x5x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %2 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %arg12) -> (f64) { + %3 = affine.load %arg0[%arg13 + %arg9 * 3] : memref + %4 = affine.for %arg15 = 0 to 4 iter_args(%arg16 = %arg14) -> (f64) { + %5 = affine.load %arg5[%arg11 * 12 + %arg15 + %arg13 * 4 + %arg7 * 108] : memref + %6 = affine.load %arg1[%arg15 + %arg10 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg16, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca[%arg7, 0, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %2 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %arg12) -> (f64) { + %3 = affine.load %arg1[%arg13 + %arg9 * 4] : memref + %4 = affine.for %arg15 = 0 to 3 iter_args(%arg16 = %arg14) -> (f64) { + %5 = affine.load %arg5[%arg11 * 12 + %arg15 + %arg13 * 3 + %arg7 * 108 + 36] : memref + %6 = affine.load %arg0[%arg15 + %arg10 * 3] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg16, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca[%arg7, 1, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg11 + %arg8 * 4] : memref + %2 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %arg12) -> (f64) { + %3 = affine.load %arg0[%arg13 + %arg9 * 3] : memref + %4 = affine.for %arg15 = 0 to 3 iter_args(%arg16 = %arg14) -> (f64) { + %5 = affine.load %arg5[%arg11 * 9 + %arg15 + %arg13 * 3 + %arg7 * 108 + 72] : memref + %6 = affine.load %arg0[%arg15 + %arg10 * 3] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.mulf %7, %3 : f64 + %9 = arith.mulf %8, %1 : f64 + %10 = arith.addf %arg16, %9 : f64 + affine.yield %10 : f64 + } + affine.yield %4 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca[%arg7, 2, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.load %alloca[%arg7, 0, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %1 = affine.load %alloca[%arg7, 1, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %2 = affine.load %alloca[%arg7, 2, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %3 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750] : memref + %4 = arith.mulf %3, %0 : f64 + %5 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 125] : memref + %6 = arith.mulf %5, %1 : f64 + %7 = arith.addf %4, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 250] : memref + %9 = arith.mulf %8, %2 : f64 + %10 = arith.addf %7, %9 : f64 + affine.store %10, %alloca[%arg7, 0, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %11 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 125] : memref + %12 = arith.mulf %11, %0 : f64 + %13 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 375] : memref + %14 = arith.mulf %13, %1 : f64 + %15 = arith.addf %12, %14 : f64 + %16 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 500] : memref + %17 = arith.mulf %16, %2 : f64 + %18 = arith.addf %15, %17 : f64 + affine.store %18, %alloca[%arg7, 1, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + %19 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 250] : memref + %20 = arith.mulf %19, %0 : f64 + %21 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 500] : memref + %22 = arith.mulf %21, %1 : f64 + %23 = arith.addf %20, %22 : f64 + %24 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750 + 625] : memref + %25 = arith.mulf %24, %2 : f64 + %26 = arith.addf %23, %25 : f64 + affine.store %26, %alloca[%arg7, 2, %arg8, %arg9, %arg10] : memref<2x3x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %4 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %arg12) -> (f64) { + %5 = affine.load %arg2[%arg13 + %arg9 * 5] : memref + %6 = affine.for %arg15 = 0 to 5 iter_args(%arg16 = %arg14) -> (f64) { + %7 = affine.load %alloca[%arg7, 0, %arg11, %arg13, %arg15] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg3[%arg15 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg16, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %4 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %arg12) -> (f64) { + %5 = affine.load %arg3[%arg13 + %arg9 * 5] : memref + %6 = affine.for %arg15 = 0 to 5 iter_args(%arg16 = %arg14) -> (f64) { + %7 = affine.load %alloca[%arg7, 1, %arg11, %arg13, %arg15] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg2[%arg15 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg16, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %4 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %arg12) -> (f64) { + %5 = affine.load %arg2[%arg13 + %arg9 * 5] : memref + %6 = affine.for %arg15 = 0 to 5 iter_args(%arg16 = %arg14) -> (f64) { + %7 = affine.load %alloca[%arg7, 2, %arg11, %arg13, %arg15] : memref<2x3x5x5x5xf64> + %8 = affine.load %arg2[%arg15 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg16, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d.matched.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d.matched.mlir new file mode 100644 index 000000000000..9f3bc2ae10a4 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d.matched.mlir @@ -0,0 +1,322 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 108)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 125 + d1 * 25 + d2 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 108)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map21 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map22 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 3)> +#map23 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 3)> +#map24 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 4)> +#map25 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 4 + d0 * 108)> +#map26 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map27 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +#map28 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 3)> +#map29 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 4)> +#map30 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 3 + d0 * 108 + 36)> +#map31 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 4)> +#map32 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 9 + d5 * 3 + d0 * 108 + 72)> +#map33 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750)> +#map34 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 125)> +#map35 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 250)> +#map36 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 375)> +#map37 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 500)> +#map38 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 625)> +#map39 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 5)> +#map40 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 5)> +#map41 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 5)> +#map42 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_grad_div_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg9 : memref + %1 = bufferization.to_tensor %arg8 : memref + %2 = bufferization.to_tensor %arg7 : memref + %3 = bufferization.to_tensor %arg6 : memref + %4 = bufferization.to_tensor %arg5 : memref + %5 = bufferization.to_tensor %arg4 : memref + %6 = bufferization.to_tensor %arg3 : memref + %7 = bufferization.to_tensor %arg2 : memref + %8 = bufferization.to_tensor %arg1 : memref + %9 = bufferization.to_tensor %arg0 : memref + %10 = tensor.empty() : tensor<2x5x4x4xf64> + %11 = tensor.empty() : tensor<2x5x4x4xf64> + %12 = tensor.empty() : tensor<2x5x4x4xf64> + %13 = tensor.empty() : tensor<2x5x5x4xf64> + %14 = tensor.empty() : tensor<2x5x5x4xf64> + %15 = tensor.empty() : tensor<2x5x5x4xf64> + %16 = tensor.empty() : tensor<2x5x5x5xf64> + %17 = tensor.empty() : tensor<2x5x5x5xf64> + %18 = tensor.empty() : tensor<2x5x5x5xf64> + %19 = tensor.empty() : tensor<2x4x5x5xf64> + %20 = tensor.empty() : tensor<2x4x5x5xf64> + %21 = tensor.empty() : tensor<2x4x5x5xf64> + %22 = tensor.empty() : tensor<2x4x4x5xf64> + %23 = tensor.empty() : tensor<2x4x4x5xf64> + %24 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice = tensor.extract_slice %24[0, 0, 0, 0] [%c2, %c3, %c3, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %26 = polygeist.submap(%5, %c2, %c3, %c3, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %27 = polygeist.submap(%1, %c2, %c3, %c3, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %28 = kernel.launch @cutensornetContraction2_f64_r5r5r4(%27, %26, %extracted_slice) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_0 = tensor.extract_slice %21[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %30 = polygeist.submap(%9, %c2, %c3, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %31 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%28, %30, %extracted_slice_0) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_1 = tensor.extract_slice %18[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %33 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %34 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%31, %33, %extracted_slice_1) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_2 = tensor.extract_slice %23[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %36 = polygeist.submap(%9, %c2, %c3, %c4, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %37 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c3) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %38 = kernel.launch @cutensornetContraction2_f64_r5r5r4(%37, %36, %extracted_slice_2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_3 = tensor.extract_slice %20[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %40 = polygeist.submap(%5, %c2, %c3, %c5, %c5, %c4) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %41 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%38, %40, %extracted_slice_3) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_4 = tensor.extract_slice %17[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %43 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %44 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%41, %43, %extracted_slice_4) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_5 = tensor.extract_slice %22[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %46 = polygeist.submap(%9, %c2, %c4, %c3, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %47 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c3) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %48 = kernel.launch @cutensornetContraction2_f64_r5r5r4(%47, %46, %extracted_slice_5) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_6 = tensor.extract_slice %19[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %50 = polygeist.submap(%9, %c2, %c4, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %51 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%48, %50, %extracted_slice_6) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_7 = tensor.extract_slice %16[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %53 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %54 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%51, %53, %extracted_slice_7) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_8 = tensor.extract_slice %15[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_8 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %56 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %57 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %58 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%57, %34, %44, %54, %56 : tensor, tensor, tensor, tensor, tensor) outs(%55 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %in_27: f64, %out: f64): + %136 = arith.addf %in_24, %in_25 : f64 + %137 = arith.addf %136, %in_26 : f64 + %138 = arith.mulf %in, %137 : f64 + %139 = arith.mulf %138, %in_27 : f64 + %140 = arith.addf %out, %139 : f64 + linalg.yield %140 : f64 + } -> tensor + %extracted_slice_9 = tensor.extract_slice %14[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %59 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_9 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %60 = polygeist.submap(%7, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %61 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %62 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%61, %34, %44, %54, %60 : tensor, tensor, tensor, tensor, tensor) outs(%59 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %in_27: f64, %out: f64): + %136 = arith.addf %in_24, %in_25 : f64 + %137 = arith.addf %136, %in_26 : f64 + %138 = arith.mulf %in, %137 : f64 + %139 = arith.mulf %138, %in_27 : f64 + %140 = arith.addf %out, %139 : f64 + linalg.yield %140 : f64 + } -> tensor + %extracted_slice_10 = tensor.extract_slice %13[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_10 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %64 = polygeist.submap(%7, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %65 = polygeist.submap(%3, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %66 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%65, %34, %44, %54, %64 : tensor, tensor, tensor, tensor, tensor) outs(%63 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %in_27: f64, %out: f64): + %136 = arith.addf %in_24, %in_25 : f64 + %137 = arith.addf %136, %in_26 : f64 + %138 = arith.mulf %in, %137 : f64 + %139 = arith.mulf %138, %in_27 : f64 + %140 = arith.addf %out, %139 : f64 + linalg.yield %140 : f64 + } -> tensor + %extracted_slice_11 = tensor.extract_slice %12[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %68 = polygeist.submap(%7, %c2, %c5, %c3, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %69 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%58, %68, %extracted_slice_11) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_12 = tensor.extract_slice %11[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %71 = polygeist.submap(%4, %c2, %c5, %c4, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %72 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%62, %71, %extracted_slice_12) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_13 = tensor.extract_slice %10[0, 0, 0, 0] [%c2, %c5, %c3, %c3] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %74 = polygeist.submap(%7, %c2, %c5, %c3, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %75 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%66, %74, %extracted_slice_13) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %76 = polygeist.submap(%7, %c2, %c3, %c3, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %77 = polygeist.submap(%0, %c2, %c3, %c3, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor<2x3x3x4xf64> + %78 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%69, %76 : tensor, tensor) outs(%77 : tensor<2x3x3x4xf64>) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor<2x3x3x4xf64> + %79 = polygeist.submapInverse(%0, %78, %c2, %c3, %c3, %c4) {map = #map19} : (tensor, tensor<2x3x3x4xf64>, index, index, index, index) -> tensor + %80 = polygeist.submap(%7, %c2, %c3, %c4, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %81 = polygeist.submap(%79, %c2, %c3, %c4, %c3) {map = #map20} : (tensor, index, index, index, index) -> tensor<2x3x4x3xf64> + %82 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%72, %80 : tensor, tensor) outs(%81 : tensor<2x3x4x3xf64>) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor<2x3x4x3xf64> + %83 = polygeist.submapInverse(%79, %82, %c2, %c3, %c4, %c3) {map = #map20} : (tensor, tensor<2x3x4x3xf64>, index, index, index, index) -> tensor + %84 = polygeist.submap(%4, %c2, %c4, %c3, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %85 = polygeist.submap(%83, %c2, %c4, %c3, %c3) {map = #map21} : (tensor, index, index, index, index) -> tensor<2x4x3x3xf64> + %86 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%75, %84 : tensor, tensor) outs(%85 : tensor<2x4x3x3xf64>) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %136 = arith.mulf %in, %in_24 : f64 + %137 = arith.addf %out, %136 : f64 + linalg.yield %137 : f64 + } -> tensor<2x4x3x3xf64> + %87 = polygeist.submapInverse(%83, %86, %c2, %c4, %c3, %c3) {map = #map21} : (tensor, tensor<2x4x3x3xf64>, index, index, index, index) -> tensor + %88 = tensor.empty() : tensor<2x3x5x5x5xf64> + %extracted_slice_14 = tensor.extract_slice %88[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %89 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_14 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %90 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map22} : (tensor, index, index, index, index, index, index, index) -> tensor + %91 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map23} : (tensor, index, index, index, index, index, index, index) -> tensor + %92 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map24} : (tensor, index, index, index, index, index, index, index) -> tensor + %93 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map25} : (tensor, index, index, index, index, index, index, index) -> tensor + %94 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%90, %91, %93, %92 : tensor, tensor, tensor, tensor) outs(%89 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %94 into %88[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_15 = tensor.extract_slice %inserted_slice[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %95 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_15 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %96 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map22} : (tensor, index, index, index, index, index, index, index) -> tensor + %97 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map28} : (tensor, index, index, index, index, index, index, index) -> tensor + %98 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map29} : (tensor, index, index, index, index, index, index, index) -> tensor + %99 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map30} : (tensor, index, index, index, index, index, index, index) -> tensor + %100 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%96, %98, %99, %97 : tensor, tensor, tensor, tensor) outs(%95 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %inserted_slice_16 = tensor.insert_slice %100 into %inserted_slice[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_17 = tensor.extract_slice %inserted_slice_16[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %101 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_17 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %102 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map23} : (tensor, index, index, index, index, index, index, index) -> tensor + %103 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map28} : (tensor, index, index, index, index, index, index, index) -> tensor + %104 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map31} : (tensor, index, index, index, index, index, index, index) -> tensor + %105 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map32} : (tensor, index, index, index, index, index, index, index) -> tensor + %106 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%104, %102, %105, %103 : tensor, tensor, tensor, tensor) outs(%101 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %inserted_slice_18 = tensor.insert_slice %106 into %inserted_slice_16[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_19 = tensor.extract_slice %inserted_slice_18[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %extracted_slice_20 = tensor.extract_slice %inserted_slice_18[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %107 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map33} : (tensor, index, index, index, index) -> tensor + %108 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map34} : (tensor, index, index, index, index) -> tensor + %109 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map35} : (tensor, index, index, index, index) -> tensor + %110 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map34} : (tensor, index, index, index, index) -> tensor + %111 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map36} : (tensor, index, index, index, index) -> tensor + %112 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map37} : (tensor, index, index, index, index) -> tensor + %113 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map35} : (tensor, index, index, index, index) -> tensor + %114 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map37} : (tensor, index, index, index, index) -> tensor + %115 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map38} : (tensor, index, index, index, index) -> tensor + %116:3 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%107, %108, %109, %110, %111, %112, %113, %114, %115 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%extracted_slice_19, %extracted_slice_20, %106 : tensor, tensor, tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %in_27: f64, %in_28: f64, %in_29: f64, %in_30: f64, %in_31: f64, %out: f64, %out_32: f64, %out_33: f64): + %136 = arith.mulf %in, %out : f64 + %137 = arith.mulf %in_24, %out_32 : f64 + %138 = arith.addf %136, %137 : f64 + %139 = arith.mulf %in_25, %out_33 : f64 + %140 = arith.addf %138, %139 : f64 + %141 = arith.mulf %in_26, %out : f64 + %142 = arith.mulf %in_27, %out_32 : f64 + %143 = arith.addf %141, %142 : f64 + %144 = arith.mulf %in_28, %out_33 : f64 + %145 = arith.addf %143, %144 : f64 + %146 = arith.mulf %in_29, %out : f64 + %147 = arith.mulf %in_30, %out_32 : f64 + %148 = arith.addf %146, %147 : f64 + %149 = arith.mulf %in_31, %out_33 : f64 + %150 = arith.addf %148, %149 : f64 + linalg.yield %140, %145, %150 : f64, f64, f64 + } -> (tensor, tensor, tensor) + %inserted_slice_21 = tensor.insert_slice %116#2 into %inserted_slice_16[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor into tensor<2x3x5x5x5xf64> + %extracted_slice_22 = tensor.extract_slice %inserted_slice_21[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %117 = polygeist.submap(%7, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index, index, index, index) -> tensor + %118 = polygeist.submap(%7, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index, index, index, index) -> tensor + %119 = polygeist.submap(%6, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map41} : (tensor, index, index, index, index, index, index, index) -> tensor + %120 = polygeist.submap(%87, %c2, %c3, %c3, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %121 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%117, %118, %extracted_slice_22, %119 : tensor, tensor, tensor, tensor) outs(%120 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %122 = polygeist.submapInverse(%87, %121, %c2, %c3, %c3, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %extracted_slice_23 = tensor.extract_slice %inserted_slice_21[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : tensor<2x3x5x5x5xf64> to tensor + %123 = polygeist.submap(%7, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index, index, index, index) -> tensor + %124 = polygeist.submap(%7, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map41} : (tensor, index, index, index, index, index, index, index) -> tensor + %125 = polygeist.submap(%6, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index, index, index, index) -> tensor + %126 = polygeist.submap(%122, %c2, %c3, %c4, %c3) {map = #map20} : (tensor, index, index, index, index) -> tensor + %127 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%123, %125, %extracted_slice_23, %124 : tensor, tensor, tensor, tensor) outs(%126 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %128 = polygeist.submapInverse(%122, %127, %c2, %c3, %c4, %c3) {map = #map20} : (tensor, tensor, index, index, index, index) -> tensor + %129 = polygeist.submap(%7, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map40} : (tensor, index, index, index, index, index, index, index) -> tensor + %130 = polygeist.submap(%7, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map41} : (tensor, index, index, index, index, index, index, index) -> tensor + %131 = polygeist.submap(%6, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map39} : (tensor, index, index, index, index, index, index, index) -> tensor + %132 = polygeist.submap(%128, %c2, %c4, %c3, %c3) {map = #map21} : (tensor, index, index, index, index) -> tensor + %133 = linalg.generic {doc = "", indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%131, %129, %116#2, %130 : tensor, tensor, tensor, tensor) outs(%132 : tensor) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %in_26: f64, %out: f64): + %136 = arith.mulf %in_25, %in_26 : f64 + %137 = arith.mulf %136, %in_24 : f64 + %138 = arith.mulf %137, %in : f64 + %139 = arith.addf %out, %138 : f64 + linalg.yield %139 : f64 + } -> tensor + %134 = polygeist.submapInverse(%128, %133, %c2, %c4, %c3, %c3) {map = #map21} : (tensor, tensor, index, index, index, index) -> tensor + %135 = bufferization.to_memref %134 : memref + memref.copy %135, %arg9 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d.raised.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d.raised.mlir new file mode 100644 index 000000000000..d0ed35b4441b --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d.raised.mlir @@ -0,0 +1,449 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 108)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 125 + d1 * 25 + d2 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 108)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map21 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map22 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 3)> +#map23 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 3)> +#map24 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 4 + d0 * 108)> +#map25 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 4)> +#map26 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map27 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +#map28 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 4)> +#map29 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 12 + d5 * 3 + d0 * 108 + 36)> +#map30 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 3)> +#map31 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 4)> +#map32 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d4 * 9 + d5 * 3 + d0 * 108 + 72)> +#map33 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750)> +#map34 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 125)> +#map35 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 250)> +#map36 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 375)> +#map37 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 500)> +#map38 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 750 + 625)> +#map39 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 + d1 * 5)> +#map40 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 + d2 * 5)> +#map41 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 + d3 * 5)> +#map42 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_grad_div_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_8 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x4x5xf64> + %subview = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c3, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg8, %c2, %c3, %c3, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg4, %c2, %c3, %c3, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + %subview_14 = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c3, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%subview_14 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_15 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_15 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_16 = memref.subview %alloca_13[0, 0, 0, 0] [%c2, %c3, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %2 = polygeist.submap(%arg0, %c2, %c3, %c5, %c5, %c3) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_17 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_16, %2 : memref>, memref) outs(%subview_17 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_18 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_18 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_19 = memref.subview %alloca_10[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %3 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_20 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_19, %3 : memref>, memref) outs(%subview_20 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_21 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_21 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg8, %c2, %c3, %c4, %c5, %c3) {map = #map9} : (memref, index, index, index, index, index) -> memref + %5 = polygeist.submap(%arg0, %c2, %c3, %c4, %c5, %c3) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_22 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%4, %5 : memref, memref) outs(%subview_22 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_23 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_23 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_24 = memref.subview %alloca_12[0, 0, 0, 0] [%c2, %c3, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %6 = polygeist.submap(%arg4, %c2, %c3, %c5, %c5, %c4) {map = #map11} : (memref, index, index, index, index, index) -> memref + %subview_25 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_24, %6 : memref>, memref) outs(%subview_25 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_26 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_26 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_27 = memref.subview %alloca_9[0, 0, 0, 0] [%c2, %c3, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %7 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (memref, index, index, index, index, index) -> memref + %subview_28 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_27, %7 : memref>, memref) outs(%subview_28 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_29 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_29 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg8, %c2, %c4, %c3, %c5, %c3) {map = #map12} : (memref, index, index, index, index, index) -> memref + %9 = polygeist.submap(%arg0, %c2, %c4, %c3, %c5, %c3) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_30 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%8, %9 : memref, memref) outs(%subview_30 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_31 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_31 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_32 = memref.subview %alloca_11[0, 0, 0, 0] [%c2, %c4, %c3, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %10 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c3) {map = #map5} : (memref, index, index, index, index, index) -> memref + %subview_33 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_32, %10 : memref>, memref) outs(%subview_33 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_34 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_34 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_35 = memref.subview %alloca_8[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %11 = polygeist.submap(%arg4, %c2, %c5, %c5, %c5, %c4) {map = #map13} : (memref, index, index, index, index, index) -> memref + %subview_36 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_35, %11 : memref>, memref) outs(%subview_36 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_37 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_37 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %12 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %subview_38 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_39 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_40 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %13 = polygeist.submap(%arg5, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_41 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%12, %subview_38, %subview_39, %subview_40, %13 : memref, memref>, memref>, memref>, memref) outs(%subview_41 : memref>) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %in_80: f64, %out: f64): + %60 = arith.addf %in_77, %in_78 : f64 + %61 = arith.addf %60, %in_79 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.mulf %62, %in_80 : f64 + %64 = arith.addf %out, %63 : f64 + linalg.yield %64 : f64 + } + %subview_42 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_42 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %subview_43 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_44 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_45 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %15 = polygeist.submap(%arg2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_46 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%14, %subview_43, %subview_44, %subview_45, %15 : memref, memref>, memref>, memref>, memref) outs(%subview_46 : memref>) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %in_80: f64, %out: f64): + %60 = arith.addf %in_77, %in_78 : f64 + %61 = arith.addf %60, %in_79 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.mulf %62, %in_80 : f64 + %64 = arith.addf %out, %63 : f64 + linalg.yield %64 : f64 + } + %subview_47 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_47 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %16 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %subview_48 = memref.subview %alloca_7[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_49 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_50 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %17 = polygeist.submap(%arg2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_51 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%16, %subview_48, %subview_49, %subview_50, %17 : memref, memref>, memref>, memref>, memref) outs(%subview_51 : memref>) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %in_80: f64, %out: f64): + %60 = arith.addf %in_77, %in_78 : f64 + %61 = arith.addf %60, %in_79 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.mulf %62, %in_80 : f64 + %64 = arith.addf %out, %63 : f64 + linalg.yield %64 : f64 + } + %subview_52 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_52 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_53 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %18 = polygeist.submap(%arg2, %c2, %c5, %c3, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_54 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_53, %18 : memref>, memref) outs(%subview_54 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_55 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_55 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_56 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %19 = polygeist.submap(%arg5, %c2, %c5, %c4, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_57 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_56, %19 : memref>, memref) outs(%subview_57 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_58 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c5, %c3, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_58 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_59 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c5, %c5, %c3] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %20 = polygeist.submap(%arg2, %c2, %c5, %c3, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_60 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c5, %c3, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_59, %20 : memref>, memref) outs(%subview_60 : memref>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_61 = memref.subview %alloca_1[0, 0, 0, 0] [%c2, %c5, %c3, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %21 = polygeist.submap(%arg2, %c2, %c3, %c3, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %22 = polygeist.submap(%arg9, %c2, %c3, %c3, %c4) {map = #map19} : (memref, index, index, index, index) -> memref<2x3x3x4xf64> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_61, %21 : memref>, memref) outs(%22 : memref<2x3x3x4xf64>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_62 = memref.subview %alloca_0[0, 0, 0, 0] [%c2, %c5, %c4, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %23 = polygeist.submap(%arg2, %c2, %c3, %c4, %c3, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %24 = polygeist.submap(%arg9, %c2, %c3, %c4, %c3) {map = #map20} : (memref, index, index, index, index) -> memref<2x3x4x3xf64> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_62, %23 : memref>, memref) outs(%24 : memref<2x3x4x3xf64>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %subview_63 = memref.subview %alloca[0, 0, 0, 0] [%c2, %c5, %c3, %c3] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %25 = polygeist.submap(%arg5, %c2, %c4, %c3, %c3, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %26 = polygeist.submap(%arg9, %c2, %c4, %c3, %c3) {map = #map21} : (memref, index, index, index, index) -> memref<2x4x3x3xf64> + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_63, %25 : memref>, memref) outs(%26 : memref<2x4x3x3xf64>) { + ^bb0(%in: f64, %in_77: f64, %out: f64): + %60 = arith.mulf %in, %in_77 : f64 + %61 = arith.addf %out, %60 : f64 + linalg.yield %61 : f64 + } + %alloca_64 = memref.alloca() : memref<2x3x5x5x5xf64> + %subview_65 = memref.subview %alloca_64[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_65 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %27 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map22} : (memref, index, index, index, index, index, index, index) -> memref + %28 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map23} : (memref, index, index, index, index, index, index, index) -> memref + %29 = polygeist.submap(%arg8, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map24} : (memref, index, index, index, index, index, index, index) -> memref + %30 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c3, %c3, %c4) {map = #map25} : (memref, index, index, index, index, index, index, index) -> memref + %subview_66 = memref.subview %alloca_64[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%27, %28, %29, %30 : memref, memref, memref, memref) outs(%subview_66 : memref>) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %out: f64): + %60 = arith.mulf %in_78, %in_79 : f64 + %61 = arith.mulf %60, %in_77 : f64 + %62 = arith.mulf %61, %in : f64 + %63 = arith.addf %out, %62 : f64 + linalg.yield %63 : f64 + } + %subview_67 = memref.subview %alloca_64[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_67 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %31 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map22} : (memref, index, index, index, index, index, index, index) -> memref + %32 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map28} : (memref, index, index, index, index, index, index, index) -> memref + %33 = polygeist.submap(%arg8, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map29} : (memref, index, index, index, index, index, index, index) -> memref + %34 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3, %c4, %c3) {map = #map30} : (memref, index, index, index, index, index, index, index) -> memref + %subview_68 = memref.subview %alloca_64[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%31, %32, %33, %34 : memref, memref, memref, memref) outs(%subview_68 : memref>) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %out: f64): + %60 = arith.mulf %in_78, %in_79 : f64 + %61 = arith.mulf %60, %in_77 : f64 + %62 = arith.mulf %61, %in : f64 + %63 = arith.addf %out, %62 : f64 + linalg.yield %63 : f64 + } + %subview_69 = memref.subview %alloca_64[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_69 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %35 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map31} : (memref, index, index, index, index, index, index, index) -> memref + %36 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map23} : (memref, index, index, index, index, index, index, index) -> memref + %37 = polygeist.submap(%arg8, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map32} : (memref, index, index, index, index, index, index, index) -> memref + %38 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4, %c3, %c3) {map = #map30} : (memref, index, index, index, index, index, index, index) -> memref + %subview_70 = memref.subview %alloca_64[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map26, #map26, #map26, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%35, %36, %37, %38 : memref, memref, memref, memref) outs(%subview_70 : memref>) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %out: f64): + %60 = arith.mulf %in_78, %in_79 : f64 + %61 = arith.mulf %60, %in_77 : f64 + %62 = arith.mulf %61, %in : f64 + %63 = arith.addf %out, %62 : f64 + linalg.yield %63 : f64 + } + %39 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map33} : (memref, index, index, index, index) -> memref + %40 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map34} : (memref, index, index, index, index) -> memref + %41 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map35} : (memref, index, index, index, index) -> memref + %42 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map34} : (memref, index, index, index, index) -> memref + %43 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map36} : (memref, index, index, index, index) -> memref + %44 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map37} : (memref, index, index, index, index) -> memref + %45 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map35} : (memref, index, index, index, index) -> memref + %46 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map37} : (memref, index, index, index, index) -> memref + %47 = polygeist.submap(%arg7, %c2, %c5, %c5, %c5) {map = #map38} : (memref, index, index, index, index) -> memref + %subview_71 = memref.subview %alloca_64[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %subview_72 = memref.subview %alloca_64[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %subview_73 = memref.subview %alloca_64[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%39, %40, %41, %42, %43, %44, %45, %46, %47 : memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%subview_71, %subview_72, %subview_73 : memref>, memref>, memref>) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %in_80: f64, %in_81: f64, %in_82: f64, %in_83: f64, %in_84: f64, %out: f64, %out_85: f64, %out_86: f64): + %60 = arith.mulf %in, %out : f64 + %61 = arith.mulf %in_77, %out_85 : f64 + %62 = arith.addf %60, %61 : f64 + %63 = arith.mulf %in_78, %out_86 : f64 + %64 = arith.addf %62, %63 : f64 + %65 = arith.mulf %in_79, %out : f64 + %66 = arith.mulf %in_80, %out_85 : f64 + %67 = arith.addf %65, %66 : f64 + %68 = arith.mulf %in_81, %out_86 : f64 + %69 = arith.addf %67, %68 : f64 + %70 = arith.mulf %in_82, %out : f64 + %71 = arith.mulf %in_83, %out_85 : f64 + %72 = arith.addf %70, %71 : f64 + %73 = arith.mulf %in_84, %out_86 : f64 + %74 = arith.addf %72, %73 : f64 + linalg.yield %64, %69, %74 : f64, f64, f64 + } + %48 = polygeist.submap(%arg2, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map39} : (memref, index, index, index, index, index, index, index) -> memref + %49 = polygeist.submap(%arg2, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map40} : (memref, index, index, index, index, index, index, index) -> memref + %subview_74 = memref.subview %alloca_64[0, 0, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %50 = polygeist.submap(%arg3, %c2, %c3, %c3, %c4, %c5, %c5, %c5) {map = #map41} : (memref, index, index, index, index, index, index, index) -> memref + %51 = polygeist.submap(%arg9, %c2, %c3, %c3, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%48, %49, %subview_74, %50 : memref, memref, memref>, memref) outs(%51 : memref) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %out: f64): + %60 = arith.mulf %in_78, %in_79 : f64 + %61 = arith.mulf %60, %in_77 : f64 + %62 = arith.mulf %61, %in : f64 + %63 = arith.addf %out, %62 : f64 + linalg.yield %63 : f64 + } + %52 = polygeist.submap(%arg2, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map39} : (memref, index, index, index, index, index, index, index) -> memref + %53 = polygeist.submap(%arg3, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map40} : (memref, index, index, index, index, index, index, index) -> memref + %subview_75 = memref.subview %alloca_64[0, 1, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %54 = polygeist.submap(%arg2, %c2, %c3, %c4, %c3, %c5, %c5, %c5) {map = #map41} : (memref, index, index, index, index, index, index, index) -> memref + %55 = polygeist.submap(%arg9, %c2, %c3, %c4, %c3) {map = #map20} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%52, %53, %subview_75, %54 : memref, memref, memref>, memref) outs(%55 : memref) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %out: f64): + %60 = arith.mulf %in_78, %in_79 : f64 + %61 = arith.mulf %60, %in_77 : f64 + %62 = arith.mulf %61, %in : f64 + %63 = arith.addf %out, %62 : f64 + linalg.yield %63 : f64 + } + %56 = polygeist.submap(%arg3, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map39} : (memref, index, index, index, index, index, index, index) -> memref + %57 = polygeist.submap(%arg2, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map40} : (memref, index, index, index, index, index, index, index) -> memref + %subview_76 = memref.subview %alloca_64[0, 2, 0, 0, 0] [%c2, 1, %c5, %c5, %c5] [1, 1, 1, 1, 1] : memref<2x3x5x5x5xf64> to memref> + %58 = polygeist.submap(%arg2, %c2, %c4, %c3, %c3, %c5, %c5, %c5) {map = #map41} : (memref, index, index, index, index, index, index, index) -> memref + %59 = polygeist.submap(%arg9, %c2, %c4, %c3, %c3) {map = #map21} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map26, #map26, #map42, #map26, #map27], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%56, %57, %subview_76, %58 : memref, memref, memref>, memref) outs(%59 : memref) { + ^bb0(%in: f64, %in_77: f64, %in_78: f64, %in_79: f64, %out: f64): + %60 = arith.mulf %in_78, %in_79 : f64 + %61 = arith.mulf %60, %in_77 : f64 + %62 = arith.mulf %61, %in : f64 + %63 = arith.addf %out, %62 : f64 + linalg.yield %63 : f64 + } + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d_partial.debufferized.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d_partial.debufferized.mlir new file mode 100644 index 000000000000..639e6d613408 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d_partial.debufferized.mlir @@ -0,0 +1,263 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 108)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 125 + d1 * 25 + d2 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 4 + d0 * 108)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_grad_div_3d_partial(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x5x4x4xf64> + %8 = tensor.empty() : tensor<2x5x4x4xf64> + %9 = tensor.empty() : tensor<2x5x4x4xf64> + %10 = tensor.empty() : tensor<2x5x5x4xf64> + %11 = tensor.empty() : tensor<2x5x5x4xf64> + %12 = tensor.empty() : tensor<2x5x5x4xf64> + %13 = tensor.empty() : tensor<2x5x5x5xf64> + %14 = tensor.empty() : tensor<2x5x5x5xf64> + %15 = tensor.empty() : tensor<2x5x5x5xf64> + %16 = tensor.empty() : tensor<2x4x5x5xf64> + %17 = tensor.empty() : tensor<2x4x5x5xf64> + %18 = tensor.empty() : tensor<2x4x5x5xf64> + %19 = tensor.empty() : tensor<2x4x4x5xf64> + %20 = tensor.empty() : tensor<2x4x4x5xf64> + %21 = tensor.empty() : tensor<2x4x4x5xf64> + %22 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%21 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %23 = polygeist.submap(%4, %c2, %c3, %c3, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %24 = polygeist.submap(%1, %c2, %c3, %c3, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%24, %23 : tensor, tensor) outs(%22 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x4x5xf64> + %26 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%18 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %27 = polygeist.submap(%6, %c2, %c3, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%25, %27 : tensor<2x4x4x5xf64>, tensor) outs(%26 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x5x5xf64> + %29 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%15 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %30 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %31 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%28, %30 : tensor<2x4x5x5xf64>, tensor) outs(%29 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x5x5xf64> + %32 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%20 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %33 = polygeist.submap(%6, %c2, %c3, %c4, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %34 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c3) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %35 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%34, %33 : tensor, tensor) outs(%32 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x4x5xf64> + %36 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%17 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %37 = polygeist.submap(%4, %c2, %c3, %c5, %c5, %c4) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %38 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%35, %37 : tensor<2x4x4x5xf64>, tensor) outs(%36 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x5x5xf64> + %39 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%14 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %40 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %41 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%38, %40 : tensor<2x4x5x5xf64>, tensor) outs(%39 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x5x5xf64> + %42 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%19 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %43 = polygeist.submap(%6, %c2, %c4, %c3, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %44 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c3) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %45 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%44, %43 : tensor, tensor) outs(%42 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x4x5xf64> + %46 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%16 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %47 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %48 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%45, %47 : tensor<2x4x4x5xf64>, tensor) outs(%46 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x5x5xf64> + %49 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%13 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %50 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %51 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%48, %50 : tensor<2x4x5x5xf64>, tensor) outs(%49 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x5x5xf64> + %52 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %53 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %54 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%54, %31, %41, %51, %53 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%52 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %56 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %57 = polygeist.submap(%5, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %58 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %59 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%58, %31, %41, %51, %57 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%56 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %60 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %61 = polygeist.submap(%5, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %62 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%62, %31, %41, %51, %61 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%60 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %64 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %65 = polygeist.submap(%5, %c2, %c5, %c3, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %66 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%55, %65 : tensor<2x5x5x4xf64>, tensor) outs(%64 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x4x4xf64> + %67 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %68 = polygeist.submap(%3, %c2, %c5, %c4, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %69 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%59, %68 : tensor<2x5x5x4xf64>, tensor) outs(%67 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x4x4xf64> + %70 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%7 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %71 = polygeist.submap(%5, %c2, %c5, %c3, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %72 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%63, %71 : tensor<2x5x5x4xf64>, tensor) outs(%70 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x4x4xf64> + %73 = polygeist.submap(%5, %c2, %c3, %c3, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %74 = polygeist.submap(%0, %c2, %c3, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %75 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%66, %73 : tensor<2x5x4x4xf64>, tensor) outs(%74 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %76 = polygeist.submapInverse(%0, %75, %c2, %c3, %c3, %c4, %c5) {map = #map19} : (tensor, tensor, index, index, index, index, index) -> tensor + %77 = polygeist.submap(%5, %c2, %c3, %c4, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %78 = polygeist.submap(%76, %c2, %c3, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %79 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%69, %77 : tensor<2x5x4x4xf64>, tensor) outs(%78 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %80 = polygeist.submapInverse(%76, %79, %c2, %c3, %c4, %c3, %c5) {map = #map20} : (tensor, tensor, index, index, index, index, index) -> tensor + %81 = polygeist.submap(%3, %c2, %c4, %c3, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %82 = polygeist.submap(%80, %c2, %c4, %c3, %c3, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %83 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%72, %81 : tensor<2x5x4x4xf64>, tensor) outs(%82 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %84 = polygeist.submapInverse(%80, %83, %c2, %c4, %c3, %c3, %c5) {map = #map21} : (tensor, tensor, index, index, index, index, index) -> tensor + %85 = bufferization.to_memref %84 : memref + memref.copy %85, %arg6 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d_partial.frontend.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d_partial.frontend.mlir new file mode 100644 index 000000000000..387092cf824f --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d_partial.frontend.mlir @@ -0,0 +1,664 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_grad_div_3d_partial(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_8 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 12 + %arg11 + %arg9 * 4 + %arg7 * 108] : memref + %2 = affine.load %arg2[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 12 + %arg11 + %arg9 * 3 + %arg7 * 108 + 36] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 9 + %arg11 + %arg9 * 3 + %arg7 * 108 + 72] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg3[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg1[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg1[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca_1[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg1[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca_0[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg1[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + } + } + } + } + return + } + func.func @mfem_pa_divdiv_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_8 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 12 + %arg11 + %arg9 * 4 + %arg7 * 108] : memref + %2 = affine.load %arg2[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 12 + %arg11 + %arg9 * 3 + %arg7 * 108 + 36] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 9 + %arg11 + %arg9 * 3 + %arg7 * 108 + 72] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg3[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg1[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg1[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca_1[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg1[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca_0[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg1[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d_partial.matched.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d_partial.matched.mlir new file mode 100644 index 000000000000..768dadf84f81 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d_partial.matched.mlir @@ -0,0 +1,221 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 108)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 125 + d1 * 25 + d2 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 4 + d0 * 108)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_grad_div_3d_partial(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x5x4x4xf64> + %8 = tensor.empty() : tensor<2x5x4x4xf64> + %9 = tensor.empty() : tensor<2x5x4x4xf64> + %10 = tensor.empty() : tensor<2x5x5x4xf64> + %11 = tensor.empty() : tensor<2x5x5x4xf64> + %12 = tensor.empty() : tensor<2x5x5x4xf64> + %13 = tensor.empty() : tensor<2x5x5x5xf64> + %14 = tensor.empty() : tensor<2x5x5x5xf64> + %15 = tensor.empty() : tensor<2x5x5x5xf64> + %16 = tensor.empty() : tensor<2x4x5x5xf64> + %17 = tensor.empty() : tensor<2x4x5x5xf64> + %18 = tensor.empty() : tensor<2x4x5x5xf64> + %19 = tensor.empty() : tensor<2x4x4x5xf64> + %20 = tensor.empty() : tensor<2x4x4x5xf64> + %21 = tensor.empty() : tensor<2x4x4x5xf64> + %23 = polygeist.submap(%4, %c2, %c3, %c3, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %24 = polygeist.submap(%1, %c2, %c3, %c3, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v21_contract_25_tc2 = tensor.cast %21 : tensor<2x4x4x5xf64> to tensor + + %v25_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%24, %23, %v21_contract_25_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %25 = tensor.cast %v25_tdyn : tensor to tensor<2x4x4x5xf64> + %27 = polygeist.submap(%6, %c2, %c3, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v25_contract_28_tc0 = tensor.cast %25 : tensor<2x4x4x5xf64> to tensor + + %v18_contract_28_tc2 = tensor.cast %18 : tensor<2x4x5x5xf64> to tensor + + %v28_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v25_contract_28_tc0, %27, %v18_contract_28_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %28 = tensor.cast %v28_tdyn : tensor to tensor<2x4x5x5xf64> + %30 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v28_contract_31_tc0 = tensor.cast %28 : tensor<2x4x5x5xf64> to tensor + + %v15_contract_31_tc2 = tensor.cast %15 : tensor<2x5x5x5xf64> to tensor + + %v31_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v28_contract_31_tc0, %30, %v15_contract_31_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %31 = tensor.cast %v31_tdyn : tensor to tensor<2x5x5x5xf64> + %33 = polygeist.submap(%6, %c2, %c3, %c4, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %34 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c3) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %v20_contract_35_tc2 = tensor.cast %20 : tensor<2x4x4x5xf64> to tensor + + %v35_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%34, %33, %v20_contract_35_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %35 = tensor.cast %v35_tdyn : tensor to tensor<2x4x4x5xf64> + %37 = polygeist.submap(%4, %c2, %c3, %c5, %c5, %c4) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %v35_contract_38_tc0 = tensor.cast %35 : tensor<2x4x4x5xf64> to tensor + + %v17_contract_38_tc2 = tensor.cast %17 : tensor<2x4x5x5xf64> to tensor + + %v38_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v35_contract_38_tc0, %37, %v17_contract_38_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %38 = tensor.cast %v38_tdyn : tensor to tensor<2x4x5x5xf64> + %40 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v38_contract_41_tc0 = tensor.cast %38 : tensor<2x4x5x5xf64> to tensor + + %v14_contract_41_tc2 = tensor.cast %14 : tensor<2x5x5x5xf64> to tensor + + %v41_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v38_contract_41_tc0, %40, %v14_contract_41_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %41 = tensor.cast %v41_tdyn : tensor to tensor<2x5x5x5xf64> + %43 = polygeist.submap(%6, %c2, %c4, %c3, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %44 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c3) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %v19_contract_45_tc2 = tensor.cast %19 : tensor<2x4x4x5xf64> to tensor + + %v45_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%44, %43, %v19_contract_45_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %45 = tensor.cast %v45_tdyn : tensor to tensor<2x4x4x5xf64> + %47 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v45_contract_48_tc0 = tensor.cast %45 : tensor<2x4x4x5xf64> to tensor + + %v16_contract_48_tc2 = tensor.cast %16 : tensor<2x4x5x5xf64> to tensor + + %v48_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v45_contract_48_tc0, %47, %v16_contract_48_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %48 = tensor.cast %v48_tdyn : tensor to tensor<2x4x5x5xf64> + %50 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %v48_contract_51_tc0 = tensor.cast %48 : tensor<2x4x5x5xf64> to tensor + + %v13_contract_51_tc2 = tensor.cast %13 : tensor<2x5x5x5xf64> to tensor + + %v51_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v48_contract_51_tc0, %50, %v13_contract_51_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %51 = tensor.cast %v51_tdyn : tensor to tensor<2x5x5x5xf64> + %52 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %53 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %54 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%54, %31, %41, %51, %53 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%52 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %56 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %57 = polygeist.submap(%5, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %58 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %59 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%58, %31, %41, %51, %57 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%56 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %60 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %61 = polygeist.submap(%5, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %62 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%62, %31, %41, %51, %61 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%60 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %65 = polygeist.submap(%5, %c2, %c5, %c3, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %v55_contract_66_tc0 = tensor.cast %55 : tensor<2x5x5x4xf64> to tensor + + %v9_contract_66_tc2 = tensor.cast %9 : tensor<2x5x4x4xf64> to tensor + + %v66_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v55_contract_66_tc0, %65, %v9_contract_66_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %66 = tensor.cast %v66_tdyn : tensor to tensor<2x5x4x4xf64> + %68 = polygeist.submap(%3, %c2, %c5, %c4, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %v59_contract_69_tc0 = tensor.cast %59 : tensor<2x5x5x4xf64> to tensor + + %v8_contract_69_tc2 = tensor.cast %8 : tensor<2x5x4x4xf64> to tensor + + %v69_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v59_contract_69_tc0, %68, %v8_contract_69_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %69 = tensor.cast %v69_tdyn : tensor to tensor<2x5x4x4xf64> + %71 = polygeist.submap(%5, %c2, %c5, %c3, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %v63_contract_72_tc0 = tensor.cast %63 : tensor<2x5x5x4xf64> to tensor + + %v7_contract_72_tc2 = tensor.cast %7 : tensor<2x5x4x4xf64> to tensor + + %v72_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v63_contract_72_tc0, %71, %v7_contract_72_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %72 = tensor.cast %v72_tdyn : tensor to tensor<2x5x4x4xf64> + %73 = polygeist.submap(%5, %c2, %c3, %c3, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %74 = polygeist.submap(%0, %c2, %c3, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %75 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%66, %73 : tensor<2x5x4x4xf64>, tensor) outs(%74 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %76 = polygeist.submapInverse(%0, %75, %c2, %c3, %c3, %c4, %c5) {map = #map19} : (tensor, tensor, index, index, index, index, index) -> tensor + %77 = polygeist.submap(%5, %c2, %c3, %c4, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %78 = polygeist.submap(%76, %c2, %c3, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %79 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%69, %77 : tensor<2x5x4x4xf64>, tensor) outs(%78 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %80 = polygeist.submapInverse(%76, %79, %c2, %c3, %c4, %c3, %c5) {map = #map20} : (tensor, tensor, index, index, index, index, index) -> tensor + %81 = polygeist.submap(%3, %c2, %c4, %c3, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %82 = polygeist.submap(%80, %c2, %c4, %c3, %c3, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %83 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%72, %81 : tensor<2x5x4x4xf64>, tensor) outs(%82 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %84 = polygeist.submapInverse(%80, %83, %c2, %c4, %c3, %c3, %c5) {map = #map21} : (tensor, tensor, index, index, index, index, index) -> tensor + %85 = bufferization.to_memref %84 : memref + memref.copy %85, %arg6 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d_partial.raised.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d_partial.raised.mlir new file mode 100644 index 000000000000..0925190fe60a --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_grad_div_3d_partial.raised.mlir @@ -0,0 +1,251 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 108)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 125 + d1 * 25 + d2 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 4 + d0 * 108)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_grad_div_3d_partial(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_8 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_13 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg5, %c2, %c3, %c3, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg2, %c2, %c3, %c3, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_13 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_10 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg0, %c2, %c3, %c5, %c5, %c3) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_13, %2 : memref<2x4x4x5xf64>, memref) outs(%alloca_10 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_7 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %3 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_10, %3 : memref<2x4x5x5xf64>, memref) outs(%alloca_7 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_12 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg5, %c2, %c3, %c4, %c5, %c3) {map = #map9} : (memref, index, index, index, index, index) -> memref + %5 = polygeist.submap(%arg0, %c2, %c3, %c4, %c5, %c3) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%4, %5 : memref, memref) outs(%alloca_12 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_9 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg2, %c2, %c3, %c5, %c5, %c4) {map = #map11} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_12, %6 : memref<2x4x4x5xf64>, memref) outs(%alloca_9 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_6 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %7 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_9, %7 : memref<2x4x5x5xf64>, memref) outs(%alloca_6 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_11 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg5, %c2, %c4, %c3, %c5, %c3) {map = #map12} : (memref, index, index, index, index, index) -> memref + %9 = polygeist.submap(%arg0, %c2, %c4, %c3, %c5, %c3) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%8, %9 : memref, memref) outs(%alloca_11 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_8 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %10 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c3) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_11, %10 : memref<2x4x4x5xf64>, memref) outs(%alloca_8 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_5 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %11 = polygeist.submap(%arg2, %c2, %c5, %c5, %c5, %c4) {map = #map13} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_8, %11 : memref<2x4x5x5xf64>, memref) outs(%alloca_5 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_4 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %12 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %13 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%12, %alloca_7, %alloca_6, %alloca_5, %13 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_4 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %27 = arith.addf %in_14, %in_15 : f64 + %28 = arith.addf %27, %in_16 : f64 + %29 = arith.mulf %in, %28 : f64 + %30 = arith.mulf %29, %in_17 : f64 + %31 = arith.addf %out, %30 : f64 + linalg.yield %31 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg4, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %15 = polygeist.submap(%arg1, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%14, %alloca_7, %alloca_6, %alloca_5, %15 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_3 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %27 = arith.addf %in_14, %in_15 : f64 + %28 = arith.addf %27, %in_16 : f64 + %29 = arith.mulf %in, %28 : f64 + %30 = arith.mulf %29, %in_17 : f64 + %31 = arith.addf %out, %30 : f64 + linalg.yield %31 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %16 = polygeist.submap(%arg4, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %17 = polygeist.submap(%arg1, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%16, %alloca_7, %alloca_6, %alloca_5, %17 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_2 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %27 = arith.addf %in_14, %in_15 : f64 + %28 = arith.addf %27, %in_16 : f64 + %29 = arith.mulf %in, %28 : f64 + %30 = arith.mulf %29, %in_17 : f64 + %31 = arith.addf %out, %30 : f64 + linalg.yield %31 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %18 = polygeist.submap(%arg1, %c2, %c5, %c3, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_4, %18 : memref<2x5x5x4xf64>, memref) outs(%alloca_1 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %19 = polygeist.submap(%arg3, %c2, %c5, %c4, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_3, %19 : memref<2x5x5x4xf64>, memref) outs(%alloca_0 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %20 = polygeist.submap(%arg1, %c2, %c5, %c3, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_2, %20 : memref<2x5x5x4xf64>, memref) outs(%alloca : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + %21 = polygeist.submap(%arg1, %c2, %c3, %c3, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %22 = polygeist.submap(%arg6, %c2, %c3, %c3, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_1, %21 : memref<2x5x4x4xf64>, memref) outs(%22 : memref) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + %23 = polygeist.submap(%arg1, %c2, %c3, %c4, %c3, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %24 = polygeist.submap(%arg6, %c2, %c3, %c4, %c3, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_0, %23 : memref<2x5x4x4xf64>, memref) outs(%24 : memref) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + %25 = polygeist.submap(%arg3, %c2, %c4, %c3, %c3, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %26 = polygeist.submap(%arg6, %c2, %c4, %c3, %c3, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca, %25 : memref<2x5x4x4xf64>, memref) outs(%26 : memref) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_mtop_iso_elasticity_dfem_2d.debufferized.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_mtop_iso_elasticity_dfem_2d.debufferized.mlir new file mode 100644 index 000000000000..f56b89d9d92c --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_mtop_iso_elasticity_dfem_2d.debufferized.mlir @@ -0,0 +1,446 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map8 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50 + 25)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4 + 32)> +#map10 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50 + 100)> +#map11 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50 + 125)> +#map12 = affine_map<(d0, d1) -> (d1 + d0 * 100)> +#map13 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 25)> +#map14 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 50)> +#map15 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 75)> +#map16 = affine_map<(d0, d1) -> (d1 + d0 * 25)> +#map17 = affine_map<(d0, d1) -> (d0, d1)> +#map18 = affine_map<(d0, d1) -> (d1)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d2)> +#map21 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50 + 25)> +#map22 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d1)> +#map23 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50 + 100)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50 + 125)> +#map26 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4 + 32)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_mtop_iso_elasticity_dfem_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c25 = arith.constant 25 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg7 : memref + %1 = bufferization.to_tensor %arg6 : memref + %2 = bufferization.to_tensor %arg5 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = bufferization.to_tensor %arg3 : memref + %5 = bufferization.to_tensor %arg2 : memref + %6 = bufferization.to_tensor %arg1 : memref + %7 = bufferization.to_tensor %arg0 : memref + %8 = tensor.empty() : tensor<200xf64> + %9 = tensor.empty() : tensor<200xf64> + %10 = tensor.empty() : tensor<2x4x5xf64> + %11 = tensor.empty() : tensor<2x4x5xf64> + %extracted_slice = tensor.extract_slice %11[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %12 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %12 into %11[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %13 = polygeist.submap(%7, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %14 = polygeist.submap(%5, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%14, %13 : tensor, tensor) outs(%inserted_slice : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.mulf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor<2x4x5xf64> + %extracted_slice_0 = tensor.extract_slice %10[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_0 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_1 = tensor.insert_slice %16 into %10[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %17 = polygeist.submap(%6, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %18 = polygeist.submap(%5, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%18, %17 : tensor, tensor) outs(%inserted_slice_1 : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.mulf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor<2x4x5xf64> + %20 = polygeist.submap(%9, %c2, %c5, %c5) {map = #map5} : (tensor<200xf64>, index, index, index) -> tensor + %21 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%20 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %22 = polygeist.submapInverse(%9, %21, %c2, %c5, %c5) {map = #map5} : (tensor<200xf64>, tensor, index, index, index) -> tensor<200xf64> + %23 = polygeist.submap(%22, %c2, %c5, %c5) {map = #map5} : (tensor<200xf64>, index, index, index) -> tensor<2x5x5xf64> + %extracted_slice_2 = tensor.extract_slice %19[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %24 = polygeist.submap(%7, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_2, %24 : tensor, tensor) outs(%23 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.mulf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor<2x5x5xf64> + %26 = polygeist.submapInverse(%22, %25, %c2, %c5, %c5) {map = #map5} : (tensor<200xf64>, tensor<2x5x5xf64>, index, index, index) -> tensor<200xf64> + %27 = polygeist.submap(%26, %c2, %c5, %c5) {map = #map8} : (tensor<200xf64>, index, index, index) -> tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%27 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %29 = polygeist.submapInverse(%26, %28, %c2, %c5, %c5) {map = #map8} : (tensor<200xf64>, tensor, index, index, index) -> tensor<200xf64> + %30 = polygeist.submap(%29, %c2, %c5, %c5) {map = #map8} : (tensor<200xf64>, index, index, index) -> tensor<2x5x5xf64> + %extracted_slice_3 = tensor.extract_slice %15[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %31 = polygeist.submap(%6, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %32 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_3, %31 : tensor, tensor) outs(%30 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.mulf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor<2x5x5xf64> + %33 = polygeist.submapInverse(%29, %32, %c2, %c5, %c5) {map = #map8} : (tensor<200xf64>, tensor<2x5x5xf64>, index, index, index) -> tensor<200xf64> + %34 = tensor.empty() : tensor<2x4x5xf64> + %35 = tensor.empty() : tensor<2x4x5xf64> + %extracted_slice_4 = tensor.extract_slice %35[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %36 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_4 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_5 = tensor.insert_slice %36 into %35[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %37 = polygeist.submap(%7, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %38 = polygeist.submap(%5, %c2, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index) -> tensor + %39 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%38, %37 : tensor, tensor) outs(%inserted_slice_5 : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.mulf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor<2x4x5xf64> + %extracted_slice_6 = tensor.extract_slice %34[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %40 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_6 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_7 = tensor.insert_slice %40 into %34[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %41 = polygeist.submap(%6, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %42 = polygeist.submap(%5, %c2, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index) -> tensor + %43 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%42, %41 : tensor, tensor) outs(%inserted_slice_7 : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.mulf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor<2x4x5xf64> + %44 = polygeist.submap(%33, %c2, %c5, %c5) {map = #map10} : (tensor<200xf64>, index, index, index) -> tensor + %45 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%44 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %46 = polygeist.submapInverse(%33, %45, %c2, %c5, %c5) {map = #map10} : (tensor<200xf64>, tensor, index, index, index) -> tensor<200xf64> + %47 = polygeist.submap(%46, %c2, %c5, %c5) {map = #map10} : (tensor<200xf64>, index, index, index) -> tensor<2x5x5xf64> + %extracted_slice_8 = tensor.extract_slice %43[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %48 = polygeist.submap(%7, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %49 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_8, %48 : tensor, tensor) outs(%47 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.mulf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor<2x5x5xf64> + %50 = polygeist.submapInverse(%46, %49, %c2, %c5, %c5) {map = #map10} : (tensor<200xf64>, tensor<2x5x5xf64>, index, index, index) -> tensor<200xf64> + %51 = polygeist.submap(%50, %c2, %c5, %c5) {map = #map11} : (tensor<200xf64>, index, index, index) -> tensor + %52 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%51 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %53 = polygeist.submapInverse(%50, %52, %c2, %c5, %c5) {map = #map11} : (tensor<200xf64>, tensor, index, index, index) -> tensor<200xf64> + %54 = polygeist.submap(%53, %c2, %c5, %c5) {map = #map11} : (tensor<200xf64>, index, index, index) -> tensor<2x5x5xf64> + %extracted_slice_9 = tensor.extract_slice %39[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %55 = polygeist.submap(%6, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %56 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_9, %55 : tensor, tensor) outs(%54 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.mulf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor<2x5x5xf64> + %57 = polygeist.submapInverse(%53, %56, %c2, %c5, %c5) {map = #map11} : (tensor<200xf64>, tensor<2x5x5xf64>, index, index, index) -> tensor<200xf64> + %58 = polygeist.submap(%8, %c2, %c25) {map = #map12} : (tensor<200xf64>, index, index) -> tensor + %59 = polygeist.submap(%57, %c2, %c25) {map = #map12} : (tensor<200xf64>, index, index) -> tensor + %60 = polygeist.submap(%57, %c2, %c25) {map = #map13} : (tensor<200xf64>, index, index) -> tensor + %61 = polygeist.submap(%57, %c2, %c25) {map = #map14} : (tensor<200xf64>, index, index) -> tensor + %62 = polygeist.submap(%57, %c2, %c25) {map = #map15} : (tensor<200xf64>, index, index) -> tensor + %63 = polygeist.submap(%4, %c2, %c25) {map = #map16} : (tensor, index, index) -> tensor + %64 = polygeist.submap(%3, %c2, %c25) {map = #map16} : (tensor, index, index) -> tensor + %65 = polygeist.submap(%2, %c2, %c25) {map = #map12} : (tensor, index, index) -> tensor + %66 = polygeist.submap(%2, %c2, %c25) {map = #map13} : (tensor, index, index) -> tensor + %67 = polygeist.submap(%2, %c2, %c25) {map = #map14} : (tensor, index, index) -> tensor + %68 = polygeist.submap(%2, %c2, %c25) {map = #map15} : (tensor, index, index) -> tensor + %extracted_slice_10 = tensor.extract_slice %1[0] [%c25] [1] : tensor to tensor + %69 = linalg.generic {doc = "", indexing_maps = [#map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map18, #map17, #map17, #map17], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%65, %66, %67, %68, %59, %60, %61, %62, %extracted_slice_10, %63, %64 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%58 : tensor) { + ^bb0(%in: f64, %in_30: f64, %in_31: f64, %in_32: f64, %in_33: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %out: f64): + %153 = arith.mulf %in, %in_32 : f64 + %154 = arith.mulf %in_30, %in_31 : f64 + %155 = arith.subf %153, %154 : f64 + %156 = arith.divf %in_32, %155 : f64 + %157 = arith.negf %in_30 : f64 + %158 = arith.divf %157, %155 : f64 + %159 = arith.addf %in_33, %in_36 : f64 + %160 = arith.mulf %in_37, %155 : f64 + %161 = arith.mulf %in_38, %156 : f64 + %162 = arith.mulf %161, %159 : f64 + %163 = arith.addf %in_33, %in_33 : f64 + %164 = arith.mulf %156, %163 : f64 + %165 = arith.addf %in_34, %in_35 : f64 + %166 = arith.mulf %158, %165 : f64 + %167 = arith.addf %164, %166 : f64 + %168 = arith.mulf %in_39, %167 : f64 + %169 = arith.addf %162, %168 : f64 + %170 = arith.mulf %160, %169 : f64 + linalg.yield %170 : f64 + } -> tensor + %70 = polygeist.submapInverse(%8, %69, %c2, %c25) {map = #map12} : (tensor<200xf64>, tensor, index, index) -> tensor<200xf64> + %71 = polygeist.submap(%70, %c2, %c25) {map = #map14} : (tensor<200xf64>, index, index) -> tensor + %72 = polygeist.submap(%57, %c2, %c25) {map = #map12} : (tensor<200xf64>, index, index) -> tensor + %73 = polygeist.submap(%57, %c2, %c25) {map = #map13} : (tensor<200xf64>, index, index) -> tensor + %74 = polygeist.submap(%57, %c2, %c25) {map = #map14} : (tensor<200xf64>, index, index) -> tensor + %75 = polygeist.submap(%57, %c2, %c25) {map = #map15} : (tensor<200xf64>, index, index) -> tensor + %76 = polygeist.submap(%4, %c2, %c25) {map = #map16} : (tensor, index, index) -> tensor + %77 = polygeist.submap(%3, %c2, %c25) {map = #map16} : (tensor, index, index) -> tensor + %78 = polygeist.submap(%2, %c2, %c25) {map = #map12} : (tensor, index, index) -> tensor + %79 = polygeist.submap(%2, %c2, %c25) {map = #map13} : (tensor, index, index) -> tensor + %80 = polygeist.submap(%2, %c2, %c25) {map = #map14} : (tensor, index, index) -> tensor + %81 = polygeist.submap(%2, %c2, %c25) {map = #map15} : (tensor, index, index) -> tensor + %extracted_slice_11 = tensor.extract_slice %1[0] [%c25] [1] : tensor to tensor + %82 = linalg.generic {doc = "", indexing_maps = [#map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map18, #map17, #map17, #map17], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%78, %79, %80, %81, %72, %73, %74, %75, %extracted_slice_11, %76, %77 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%71 : tensor) { + ^bb0(%in: f64, %in_30: f64, %in_31: f64, %in_32: f64, %in_33: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %out: f64): + %153 = arith.mulf %in, %in_32 : f64 + %154 = arith.mulf %in_30, %in_31 : f64 + %155 = arith.subf %153, %154 : f64 + %156 = arith.divf %in_32, %155 : f64 + %157 = arith.negf %in_30 : f64 + %158 = arith.divf %157, %155 : f64 + %159 = arith.addf %in_33, %in_36 : f64 + %160 = arith.mulf %in_37, %155 : f64 + %161 = arith.mulf %in_38, %158 : f64 + %162 = arith.mulf %161, %159 : f64 + %163 = arith.addf %in_35, %in_34 : f64 + %164 = arith.mulf %156, %163 : f64 + %165 = arith.addf %in_36, %in_36 : f64 + %166 = arith.mulf %158, %165 : f64 + %167 = arith.addf %164, %166 : f64 + %168 = arith.mulf %in_39, %167 : f64 + %169 = arith.addf %162, %168 : f64 + %170 = arith.mulf %160, %169 : f64 + linalg.yield %170 : f64 + } -> tensor + %83 = polygeist.submapInverse(%70, %82, %c2, %c25) {map = #map14} : (tensor<200xf64>, tensor, index, index) -> tensor<200xf64> + %84 = polygeist.submap(%83, %c2, %c25) {map = #map13} : (tensor<200xf64>, index, index) -> tensor + %85 = polygeist.submap(%57, %c2, %c25) {map = #map12} : (tensor<200xf64>, index, index) -> tensor + %86 = polygeist.submap(%57, %c2, %c25) {map = #map13} : (tensor<200xf64>, index, index) -> tensor + %87 = polygeist.submap(%57, %c2, %c25) {map = #map14} : (tensor<200xf64>, index, index) -> tensor + %88 = polygeist.submap(%57, %c2, %c25) {map = #map15} : (tensor<200xf64>, index, index) -> tensor + %89 = polygeist.submap(%4, %c2, %c25) {map = #map16} : (tensor, index, index) -> tensor + %90 = polygeist.submap(%3, %c2, %c25) {map = #map16} : (tensor, index, index) -> tensor + %91 = polygeist.submap(%2, %c2, %c25) {map = #map12} : (tensor, index, index) -> tensor + %92 = polygeist.submap(%2, %c2, %c25) {map = #map13} : (tensor, index, index) -> tensor + %93 = polygeist.submap(%2, %c2, %c25) {map = #map14} : (tensor, index, index) -> tensor + %94 = polygeist.submap(%2, %c2, %c25) {map = #map15} : (tensor, index, index) -> tensor + %extracted_slice_12 = tensor.extract_slice %1[0] [%c25] [1] : tensor to tensor + %95 = linalg.generic {doc = "", indexing_maps = [#map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map18, #map17, #map17, #map17], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%91, %92, %93, %94, %85, %86, %87, %88, %extracted_slice_12, %89, %90 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%84 : tensor) { + ^bb0(%in: f64, %in_30: f64, %in_31: f64, %in_32: f64, %in_33: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %out: f64): + %153 = arith.mulf %in, %in_32 : f64 + %154 = arith.mulf %in_30, %in_31 : f64 + %155 = arith.subf %153, %154 : f64 + %156 = arith.negf %in_31 : f64 + %157 = arith.divf %156, %155 : f64 + %158 = arith.divf %in, %155 : f64 + %159 = arith.addf %in_33, %in_36 : f64 + %160 = arith.mulf %in_37, %155 : f64 + %161 = arith.mulf %in_38, %157 : f64 + %162 = arith.mulf %161, %159 : f64 + %163 = arith.addf %in_33, %in_33 : f64 + %164 = arith.mulf %157, %163 : f64 + %165 = arith.addf %in_34, %in_35 : f64 + %166 = arith.mulf %158, %165 : f64 + %167 = arith.addf %164, %166 : f64 + %168 = arith.mulf %in_39, %167 : f64 + %169 = arith.addf %162, %168 : f64 + %170 = arith.mulf %160, %169 : f64 + linalg.yield %170 : f64 + } -> tensor + %96 = polygeist.submapInverse(%83, %95, %c2, %c25) {map = #map13} : (tensor<200xf64>, tensor, index, index) -> tensor<200xf64> + %97 = polygeist.submap(%96, %c2, %c25) {map = #map15} : (tensor<200xf64>, index, index) -> tensor + %98 = polygeist.submap(%57, %c2, %c25) {map = #map12} : (tensor<200xf64>, index, index) -> tensor + %99 = polygeist.submap(%57, %c2, %c25) {map = #map13} : (tensor<200xf64>, index, index) -> tensor + %100 = polygeist.submap(%57, %c2, %c25) {map = #map14} : (tensor<200xf64>, index, index) -> tensor + %101 = polygeist.submap(%57, %c2, %c25) {map = #map15} : (tensor<200xf64>, index, index) -> tensor + %102 = polygeist.submap(%4, %c2, %c25) {map = #map16} : (tensor, index, index) -> tensor + %103 = polygeist.submap(%3, %c2, %c25) {map = #map16} : (tensor, index, index) -> tensor + %104 = polygeist.submap(%2, %c2, %c25) {map = #map12} : (tensor, index, index) -> tensor + %105 = polygeist.submap(%2, %c2, %c25) {map = #map13} : (tensor, index, index) -> tensor + %106 = polygeist.submap(%2, %c2, %c25) {map = #map14} : (tensor, index, index) -> tensor + %107 = polygeist.submap(%2, %c2, %c25) {map = #map15} : (tensor, index, index) -> tensor + %extracted_slice_13 = tensor.extract_slice %1[0] [%c25] [1] : tensor to tensor + %108 = linalg.generic {doc = "", indexing_maps = [#map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map18, #map17, #map17, #map17], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%104, %105, %106, %107, %98, %99, %100, %101, %extracted_slice_13, %102, %103 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%97 : tensor) { + ^bb0(%in: f64, %in_30: f64, %in_31: f64, %in_32: f64, %in_33: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %out: f64): + %153 = arith.mulf %in, %in_32 : f64 + %154 = arith.mulf %in_30, %in_31 : f64 + %155 = arith.subf %153, %154 : f64 + %156 = arith.negf %in_31 : f64 + %157 = arith.divf %156, %155 : f64 + %158 = arith.divf %in, %155 : f64 + %159 = arith.addf %in_33, %in_36 : f64 + %160 = arith.mulf %in_37, %155 : f64 + %161 = arith.mulf %in_38, %158 : f64 + %162 = arith.mulf %161, %159 : f64 + %163 = arith.addf %in_35, %in_34 : f64 + %164 = arith.mulf %157, %163 : f64 + %165 = arith.addf %in_36, %in_36 : f64 + %166 = arith.mulf %158, %165 : f64 + %167 = arith.addf %164, %166 : f64 + %168 = arith.mulf %in_39, %167 : f64 + %169 = arith.addf %162, %168 : f64 + %170 = arith.mulf %160, %169 : f64 + linalg.yield %170 : f64 + } -> tensor + %109 = polygeist.submapInverse(%96, %108, %c2, %c25) {map = #map15} : (tensor<200xf64>, tensor, index, index) -> tensor<200xf64> + %110 = tensor.empty() : tensor<2x4x4xf64> + %111 = tensor.empty() : tensor<2x4x4xf64> + %112 = tensor.empty() : tensor<2x5x4xf64> + %113 = tensor.empty() : tensor<2x5x4xf64> + %extracted_slice_14 = tensor.extract_slice %113[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %114 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_14 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_15 = tensor.insert_slice %114 into %113[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor into tensor<2x5x4xf64> + %115 = polygeist.submap(%109, %c2, %c5, %c4, %c5) {map = #map19} : (tensor<200xf64>, index, index, index, index) -> tensor + %116 = polygeist.submap(%6, %c2, %c5, %c4, %c5) {map = #map20} : (tensor, index, index, index, index) -> tensor + %117 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%115, %116 : tensor, tensor) outs(%inserted_slice_15 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.mulf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor<2x5x4xf64> + %extracted_slice_16 = tensor.extract_slice %112[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %118 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_16 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_17 = tensor.insert_slice %118 into %112[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor into tensor<2x5x4xf64> + %119 = polygeist.submap(%109, %c2, %c5, %c4, %c5) {map = #map21} : (tensor<200xf64>, index, index, index, index) -> tensor + %120 = polygeist.submap(%7, %c2, %c5, %c4, %c5) {map = #map20} : (tensor, index, index, index, index) -> tensor + %121 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%119, %120 : tensor, tensor) outs(%inserted_slice_17 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.mulf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor<2x5x4xf64> + %extracted_slice_18 = tensor.extract_slice %111[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : tensor<2x4x4xf64> to tensor + %122 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_18 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_19 = tensor.extract_slice %117[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %123 = polygeist.submap(%7, %c2, %c4, %c4, %c5) {map = #map22} : (tensor, index, index, index, index) -> tensor + %124 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_19, %123 : tensor, tensor) outs(%122 : tensor) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.mulf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor + %extracted_slice_20 = tensor.extract_slice %110[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : tensor<2x4x4xf64> to tensor + %125 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_20 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_21 = tensor.extract_slice %121[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %126 = polygeist.submap(%6, %c2, %c4, %c4, %c5) {map = #map22} : (tensor, index, index, index, index) -> tensor + %127 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_21, %126 : tensor, tensor) outs(%125 : tensor) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.mulf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor + %128 = polygeist.submap(%0, %c2, %c4, %c4) {map = #map23} : (tensor, index, index, index) -> tensor + %129 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%124, %127 : tensor, tensor) outs(%128 : tensor) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.addf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor + %130 = polygeist.submapInverse(%0, %129, %c2, %c4, %c4) {map = #map23} : (tensor, tensor, index, index, index) -> tensor + %131 = tensor.empty() : tensor<2x4x4xf64> + %132 = tensor.empty() : tensor<2x4x4xf64> + %133 = tensor.empty() : tensor<2x5x4xf64> + %134 = tensor.empty() : tensor<2x5x4xf64> + %extracted_slice_22 = tensor.extract_slice %134[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %135 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_22 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_23 = tensor.insert_slice %135 into %134[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor into tensor<2x5x4xf64> + %136 = polygeist.submap(%109, %c2, %c5, %c4, %c5) {map = #map24} : (tensor<200xf64>, index, index, index, index) -> tensor + %137 = polygeist.submap(%6, %c2, %c5, %c4, %c5) {map = #map20} : (tensor, index, index, index, index) -> tensor + %138 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%136, %137 : tensor, tensor) outs(%inserted_slice_23 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.mulf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor<2x5x4xf64> + %extracted_slice_24 = tensor.extract_slice %133[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %139 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_24 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_25 = tensor.insert_slice %139 into %133[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor into tensor<2x5x4xf64> + %140 = polygeist.submap(%109, %c2, %c5, %c4, %c5) {map = #map25} : (tensor<200xf64>, index, index, index, index) -> tensor + %141 = polygeist.submap(%7, %c2, %c5, %c4, %c5) {map = #map20} : (tensor, index, index, index, index) -> tensor + %142 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%140, %141 : tensor, tensor) outs(%inserted_slice_25 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.mulf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor<2x5x4xf64> + %extracted_slice_26 = tensor.extract_slice %132[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : tensor<2x4x4xf64> to tensor + %143 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_26 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_27 = tensor.extract_slice %138[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %144 = polygeist.submap(%7, %c2, %c4, %c4, %c5) {map = #map22} : (tensor, index, index, index, index) -> tensor + %145 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_27, %144 : tensor, tensor) outs(%143 : tensor) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.mulf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor + %extracted_slice_28 = tensor.extract_slice %131[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : tensor<2x4x4xf64> to tensor + %146 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_28 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_29 = tensor.extract_slice %142[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %147 = polygeist.submap(%6, %c2, %c4, %c4, %c5) {map = #map22} : (tensor, index, index, index, index) -> tensor + %148 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_29, %147 : tensor, tensor) outs(%146 : tensor) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.mulf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor + %149 = polygeist.submap(%130, %c2, %c4, %c4) {map = #map26} : (tensor, index, index, index) -> tensor + %150 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%145, %148 : tensor, tensor) outs(%149 : tensor) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.addf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor + %151 = polygeist.submapInverse(%130, %150, %c2, %c4, %c4) {map = #map26} : (tensor, tensor, index, index, index) -> tensor + %152 = bufferization.to_memref %151 : memref + memref.copy %152, %arg7 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_mtop_iso_elasticity_dfem_2d.frontend.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_mtop_iso_elasticity_dfem_2d.frontend.mlir new file mode 100644 index 000000000000..d194dcead6b4 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_mtop_iso_elasticity_dfem_2d.frontend.mlir @@ -0,0 +1,681 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_mtop_iso_elasticity_dfem_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<200xf64> + %alloca_0 = memref.alloca() : memref<200xf64> + %alloca_1 = memref.alloca() : memref<2x4x5xf64> + %alloca_2 = memref.alloca() : memref<2x4x5xf64> + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg2[%arg11 + %arg8 * 16 + %arg9 * 4] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg8, %arg9, %arg10] : memref<2x4x5xf64> + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg2[%arg11 + %arg8 * 16 + %arg9 * 4] : memref + %2 = affine.load %arg1[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg8, %arg9, %arg10] : memref<2x4x5xf64> + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_1[%arg8, %arg11, %arg10] : memref<2x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg9 + %arg8 * 50 + %arg10 * 5] : memref<200xf64> + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg8, %arg11, %arg10] : memref<2x4x5xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg9 + %arg8 * 50 + %arg10 * 5 + 25] : memref<200xf64> + } + } + } + %alloca_3 = memref.alloca() : memref<2x4x5xf64> + %alloca_4 = memref.alloca() : memref<2x4x5xf64> + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg2[%arg11 + %arg8 * 16 + %arg9 * 4 + 32] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg8, %arg9, %arg10] : memref<2x4x5xf64> + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg2[%arg11 + %arg8 * 16 + %arg9 * 4 + 32] : memref + %2 = affine.load %arg1[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg8, %arg9, %arg10] : memref<2x4x5xf64> + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg8, %arg11, %arg10] : memref<2x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg9 + %arg8 * 50 + %arg10 * 5 + 100] : memref<200xf64> + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg8, %arg11, %arg10] : memref<2x4x5xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg9 + %arg8 * 50 + %arg10 * 5 + 125] : memref<200xf64> + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 25 { + %0 = affine.load %arg5[%arg9 + %arg8 * 100] : memref + %1 = affine.load %arg5[%arg9 + %arg8 * 100 + 25] : memref + %2 = affine.load %arg5[%arg9 + %arg8 * 100 + 50] : memref + %3 = affine.load %arg5[%arg9 + %arg8 * 100 + 75] : memref + %4 = arith.mulf %0, %3 : f64 + %5 = arith.mulf %1, %2 : f64 + %6 = arith.subf %4, %5 : f64 + %7 = arith.divf %3, %6 : f64 + %8 = arith.negf %1 : f64 + %9 = arith.divf %8, %6 : f64 + %10 = affine.load %alloca_0[%arg9 + %arg8 * 100] : memref<200xf64> + %11 = affine.load %alloca_0[%arg9 + %arg8 * 100 + 25] : memref<200xf64> + %12 = affine.load %alloca_0[%arg9 + %arg8 * 100 + 50] : memref<200xf64> + %13 = affine.load %alloca_0[%arg9 + %arg8 * 100 + 75] : memref<200xf64> + %14 = arith.addf %10, %13 : f64 + %15 = affine.load %arg6[%arg9] : memref + %16 = arith.mulf %15, %6 : f64 + %17 = affine.load %arg3[%arg9 + %arg8 * 25] : memref + %18 = affine.load %arg4[%arg9 + %arg8 * 25] : memref + %19 = arith.mulf %17, %7 : f64 + %20 = arith.mulf %19, %14 : f64 + %21 = arith.addf %10, %10 : f64 + %22 = arith.mulf %7, %21 : f64 + %23 = arith.addf %11, %12 : f64 + %24 = arith.mulf %9, %23 : f64 + %25 = arith.addf %22, %24 : f64 + %26 = arith.mulf %18, %25 : f64 + %27 = arith.addf %20, %26 : f64 + %28 = arith.mulf %16, %27 : f64 + affine.store %28, %alloca[%arg9 + %arg8 * 100] : memref<200xf64> + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 25 { + %0 = affine.load %arg5[%arg9 + %arg8 * 100] : memref + %1 = affine.load %arg5[%arg9 + %arg8 * 100 + 25] : memref + %2 = affine.load %arg5[%arg9 + %arg8 * 100 + 50] : memref + %3 = affine.load %arg5[%arg9 + %arg8 * 100 + 75] : memref + %4 = arith.mulf %0, %3 : f64 + %5 = arith.mulf %1, %2 : f64 + %6 = arith.subf %4, %5 : f64 + %7 = arith.divf %3, %6 : f64 + %8 = arith.negf %1 : f64 + %9 = arith.divf %8, %6 : f64 + %10 = affine.load %alloca_0[%arg9 + %arg8 * 100] : memref<200xf64> + %11 = affine.load %alloca_0[%arg9 + %arg8 * 100 + 25] : memref<200xf64> + %12 = affine.load %alloca_0[%arg9 + %arg8 * 100 + 50] : memref<200xf64> + %13 = affine.load %alloca_0[%arg9 + %arg8 * 100 + 75] : memref<200xf64> + %14 = arith.addf %10, %13 : f64 + %15 = affine.load %arg6[%arg9] : memref + %16 = arith.mulf %15, %6 : f64 + %17 = affine.load %arg3[%arg9 + %arg8 * 25] : memref + %18 = affine.load %arg4[%arg9 + %arg8 * 25] : memref + %19 = arith.mulf %17, %9 : f64 + %20 = arith.mulf %19, %14 : f64 + %21 = arith.addf %12, %11 : f64 + %22 = arith.mulf %7, %21 : f64 + %23 = arith.addf %13, %13 : f64 + %24 = arith.mulf %9, %23 : f64 + %25 = arith.addf %22, %24 : f64 + %26 = arith.mulf %18, %25 : f64 + %27 = arith.addf %20, %26 : f64 + %28 = arith.mulf %16, %27 : f64 + affine.store %28, %alloca[%arg9 + %arg8 * 100 + 50] : memref<200xf64> + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 25 { + %0 = affine.load %arg5[%arg9 + %arg8 * 100] : memref + %1 = affine.load %arg5[%arg9 + %arg8 * 100 + 25] : memref + %2 = affine.load %arg5[%arg9 + %arg8 * 100 + 50] : memref + %3 = affine.load %arg5[%arg9 + %arg8 * 100 + 75] : memref + %4 = arith.mulf %0, %3 : f64 + %5 = arith.mulf %1, %2 : f64 + %6 = arith.subf %4, %5 : f64 + %7 = arith.negf %2 : f64 + %8 = arith.divf %7, %6 : f64 + %9 = arith.divf %0, %6 : f64 + %10 = affine.load %alloca_0[%arg9 + %arg8 * 100] : memref<200xf64> + %11 = affine.load %alloca_0[%arg9 + %arg8 * 100 + 25] : memref<200xf64> + %12 = affine.load %alloca_0[%arg9 + %arg8 * 100 + 50] : memref<200xf64> + %13 = affine.load %alloca_0[%arg9 + %arg8 * 100 + 75] : memref<200xf64> + %14 = arith.addf %10, %13 : f64 + %15 = affine.load %arg6[%arg9] : memref + %16 = arith.mulf %15, %6 : f64 + %17 = affine.load %arg3[%arg9 + %arg8 * 25] : memref + %18 = affine.load %arg4[%arg9 + %arg8 * 25] : memref + %19 = arith.mulf %17, %8 : f64 + %20 = arith.mulf %19, %14 : f64 + %21 = arith.addf %10, %10 : f64 + %22 = arith.mulf %8, %21 : f64 + %23 = arith.addf %11, %12 : f64 + %24 = arith.mulf %9, %23 : f64 + %25 = arith.addf %22, %24 : f64 + %26 = arith.mulf %18, %25 : f64 + %27 = arith.addf %20, %26 : f64 + %28 = arith.mulf %16, %27 : f64 + affine.store %28, %alloca[%arg9 + %arg8 * 100 + 25] : memref<200xf64> + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 25 { + %0 = affine.load %arg5[%arg9 + %arg8 * 100] : memref + %1 = affine.load %arg5[%arg9 + %arg8 * 100 + 25] : memref + %2 = affine.load %arg5[%arg9 + %arg8 * 100 + 50] : memref + %3 = affine.load %arg5[%arg9 + %arg8 * 100 + 75] : memref + %4 = arith.mulf %0, %3 : f64 + %5 = arith.mulf %1, %2 : f64 + %6 = arith.subf %4, %5 : f64 + %7 = arith.negf %2 : f64 + %8 = arith.divf %7, %6 : f64 + %9 = arith.divf %0, %6 : f64 + %10 = affine.load %alloca_0[%arg9 + %arg8 * 100] : memref<200xf64> + %11 = affine.load %alloca_0[%arg9 + %arg8 * 100 + 25] : memref<200xf64> + %12 = affine.load %alloca_0[%arg9 + %arg8 * 100 + 50] : memref<200xf64> + %13 = affine.load %alloca_0[%arg9 + %arg8 * 100 + 75] : memref<200xf64> + %14 = arith.addf %10, %13 : f64 + %15 = affine.load %arg6[%arg9] : memref + %16 = arith.mulf %15, %6 : f64 + %17 = affine.load %arg3[%arg9 + %arg8 * 25] : memref + %18 = affine.load %arg4[%arg9 + %arg8 * 25] : memref + %19 = arith.mulf %17, %9 : f64 + %20 = arith.mulf %19, %14 : f64 + %21 = arith.addf %12, %11 : f64 + %22 = arith.mulf %8, %21 : f64 + %23 = arith.addf %13, %13 : f64 + %24 = arith.mulf %9, %23 : f64 + %25 = arith.addf %22, %24 : f64 + %26 = arith.mulf %18, %25 : f64 + %27 = arith.addf %20, %26 : f64 + %28 = arith.mulf %16, %27 : f64 + affine.store %28, %alloca[%arg9 + %arg8 * 100 + 75] : memref<200xf64> + } + } + %alloca_5 = memref.alloca() : memref<2x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x4x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x4xf64> + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg9 + %arg8 * 50 + %arg11 * 5] : memref<200xf64> + %2 = affine.load %arg1[%arg10 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg8, %arg9, %arg10] : memref<2x5x4xf64> + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg9 + %arg8 * 50 + %arg11 * 5 + 25] : memref<200xf64> + %2 = affine.load %arg0[%arg10 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg8, %arg9, %arg10] : memref<2x5x4xf64> + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg8, %arg11, %arg10] : memref<2x5x4xf64> + %2 = affine.load %arg0[%arg9 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg8, %arg9, %arg10] : memref<2x4x4xf64> + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg8, %arg11, %arg10] : memref<2x5x4xf64> + %2 = affine.load %arg1[%arg9 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg8, %arg9, %arg10] : memref<2x4x4xf64> + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.load %alloca_6[%arg8, %arg9, %arg10] : memref<2x4x4xf64> + %1 = affine.load %alloca_5[%arg8, %arg9, %arg10] : memref<2x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %arg7[%arg10 + %arg8 * 16 + %arg9 * 4] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg7[%arg10 + %arg8 * 16 + %arg9 * 4] : memref + } + } + } + %alloca_9 = memref.alloca() : memref<2x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x4xf64> + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg9 + %arg8 * 50 + %arg11 * 5 + 100] : memref<200xf64> + %2 = affine.load %arg1[%arg10 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg8, %arg9, %arg10] : memref<2x5x4xf64> + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg9 + %arg8 * 50 + %arg11 * 5 + 125] : memref<200xf64> + %2 = affine.load %arg0[%arg10 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg8, %arg9, %arg10] : memref<2x5x4xf64> + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg8, %arg11, %arg10] : memref<2x5x4xf64> + %2 = affine.load %arg0[%arg9 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg8, %arg9, %arg10] : memref<2x4x4xf64> + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg8, %arg11, %arg10] : memref<2x5x4xf64> + %2 = affine.load %arg1[%arg9 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg8, %arg9, %arg10] : memref<2x4x4xf64> + } + } + } + affine.for %arg8 = 0 to 2 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.load %alloca_10[%arg8, %arg9, %arg10] : memref<2x4x4xf64> + %1 = affine.load %alloca_9[%arg8, %arg9, %arg10] : memref<2x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %arg7[%arg10 + %arg8 * 16 + %arg9 * 4 + 32] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg7[%arg10 + %arg8 * 16 + %arg9 * 4 + 32] : memref + } + } + } + return + } + func.func @mfem_interp_grad_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x5xf64> + %alloca_0 = memref.alloca() : memref<2x4x5xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg7 + %arg4 * 16 + %arg5 * 4] : memref + %2 = affine.load %arg1[%arg7 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg4, %arg5, %arg6] : memref<2x4x5xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg7 + %arg4 * 16 + %arg5 * 4] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg4, %arg5, %arg6] : memref<2x4x5xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg4, %arg7, %arg6] : memref<2x4x5xf64> + %2 = affine.load %arg1[%arg7 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %arg3[%arg5 + %arg4 * 50 + %arg6 * 5] : memref + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca_0[%arg4, %arg7, %arg6] : memref<2x4x5xf64> + %2 = affine.load %arg2[%arg7 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %arg3[%arg5 + %arg4 * 50 + %arg6 * 5 + 25] : memref + } + } + } + return + } + func.func @mfem_elasticity_qpoint_2d_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 25 { + %0 = affine.load %arg2[%arg7 + %arg6 * 100] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 100 + 25] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 100 + 50] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 100 + 75] : memref + %4 = arith.mulf %0, %3 : f64 + %5 = arith.mulf %1, %2 : f64 + %6 = arith.subf %4, %5 : f64 + %7 = arith.divf %3, %6 : f64 + %8 = arith.negf %1 : f64 + %9 = arith.divf %8, %6 : f64 + %10 = affine.load %arg4[%arg7 + %arg6 * 100] : memref + %11 = affine.load %arg4[%arg7 + %arg6 * 100 + 25] : memref + %12 = affine.load %arg4[%arg7 + %arg6 * 100 + 50] : memref + %13 = affine.load %arg4[%arg7 + %arg6 * 100 + 75] : memref + %14 = arith.addf %10, %13 : f64 + %15 = affine.load %arg3[%arg7] : memref + %16 = arith.mulf %15, %6 : f64 + %17 = affine.load %arg0[%arg7 + %arg6 * 25] : memref + %18 = affine.load %arg1[%arg7 + %arg6 * 25] : memref + %19 = arith.mulf %17, %7 : f64 + %20 = arith.mulf %19, %14 : f64 + %21 = arith.addf %10, %10 : f64 + %22 = arith.mulf %7, %21 : f64 + %23 = arith.addf %11, %12 : f64 + %24 = arith.mulf %9, %23 : f64 + %25 = arith.addf %22, %24 : f64 + %26 = arith.mulf %18, %25 : f64 + %27 = arith.addf %20, %26 : f64 + %28 = arith.mulf %16, %27 : f64 + affine.store %28, %arg5[%arg7 + %arg6 * 100] : memref + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 25 { + %0 = affine.load %arg2[%arg7 + %arg6 * 100] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 100 + 25] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 100 + 50] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 100 + 75] : memref + %4 = arith.mulf %0, %3 : f64 + %5 = arith.mulf %1, %2 : f64 + %6 = arith.subf %4, %5 : f64 + %7 = arith.divf %3, %6 : f64 + %8 = arith.negf %1 : f64 + %9 = arith.divf %8, %6 : f64 + %10 = affine.load %arg4[%arg7 + %arg6 * 100] : memref + %11 = affine.load %arg4[%arg7 + %arg6 * 100 + 25] : memref + %12 = affine.load %arg4[%arg7 + %arg6 * 100 + 50] : memref + %13 = affine.load %arg4[%arg7 + %arg6 * 100 + 75] : memref + %14 = arith.addf %10, %13 : f64 + %15 = affine.load %arg3[%arg7] : memref + %16 = arith.mulf %15, %6 : f64 + %17 = affine.load %arg0[%arg7 + %arg6 * 25] : memref + %18 = affine.load %arg1[%arg7 + %arg6 * 25] : memref + %19 = arith.mulf %17, %9 : f64 + %20 = arith.mulf %19, %14 : f64 + %21 = arith.addf %12, %11 : f64 + %22 = arith.mulf %7, %21 : f64 + %23 = arith.addf %13, %13 : f64 + %24 = arith.mulf %9, %23 : f64 + %25 = arith.addf %22, %24 : f64 + %26 = arith.mulf %18, %25 : f64 + %27 = arith.addf %20, %26 : f64 + %28 = arith.mulf %16, %27 : f64 + affine.store %28, %arg5[%arg7 + %arg6 * 100 + 50] : memref + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 25 { + %0 = affine.load %arg2[%arg7 + %arg6 * 100] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 100 + 25] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 100 + 50] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 100 + 75] : memref + %4 = arith.mulf %0, %3 : f64 + %5 = arith.mulf %1, %2 : f64 + %6 = arith.subf %4, %5 : f64 + %7 = arith.negf %2 : f64 + %8 = arith.divf %7, %6 : f64 + %9 = arith.divf %0, %6 : f64 + %10 = affine.load %arg4[%arg7 + %arg6 * 100] : memref + %11 = affine.load %arg4[%arg7 + %arg6 * 100 + 25] : memref + %12 = affine.load %arg4[%arg7 + %arg6 * 100 + 50] : memref + %13 = affine.load %arg4[%arg7 + %arg6 * 100 + 75] : memref + %14 = arith.addf %10, %13 : f64 + %15 = affine.load %arg3[%arg7] : memref + %16 = arith.mulf %15, %6 : f64 + %17 = affine.load %arg0[%arg7 + %arg6 * 25] : memref + %18 = affine.load %arg1[%arg7 + %arg6 * 25] : memref + %19 = arith.mulf %17, %8 : f64 + %20 = arith.mulf %19, %14 : f64 + %21 = arith.addf %10, %10 : f64 + %22 = arith.mulf %8, %21 : f64 + %23 = arith.addf %11, %12 : f64 + %24 = arith.mulf %9, %23 : f64 + %25 = arith.addf %22, %24 : f64 + %26 = arith.mulf %18, %25 : f64 + %27 = arith.addf %20, %26 : f64 + %28 = arith.mulf %16, %27 : f64 + affine.store %28, %arg5[%arg7 + %arg6 * 100 + 25] : memref + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 25 { + %0 = affine.load %arg2[%arg7 + %arg6 * 100] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 100 + 25] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 100 + 50] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 100 + 75] : memref + %4 = arith.mulf %0, %3 : f64 + %5 = arith.mulf %1, %2 : f64 + %6 = arith.subf %4, %5 : f64 + %7 = arith.negf %2 : f64 + %8 = arith.divf %7, %6 : f64 + %9 = arith.divf %0, %6 : f64 + %10 = affine.load %arg4[%arg7 + %arg6 * 100] : memref + %11 = affine.load %arg4[%arg7 + %arg6 * 100 + 25] : memref + %12 = affine.load %arg4[%arg7 + %arg6 * 100 + 50] : memref + %13 = affine.load %arg4[%arg7 + %arg6 * 100 + 75] : memref + %14 = arith.addf %10, %13 : f64 + %15 = affine.load %arg3[%arg7] : memref + %16 = arith.mulf %15, %6 : f64 + %17 = affine.load %arg0[%arg7 + %arg6 * 25] : memref + %18 = affine.load %arg1[%arg7 + %arg6 * 25] : memref + %19 = arith.mulf %17, %9 : f64 + %20 = arith.mulf %19, %14 : f64 + %21 = arith.addf %12, %11 : f64 + %22 = arith.mulf %8, %21 : f64 + %23 = arith.addf %13, %13 : f64 + %24 = arith.mulf %9, %23 : f64 + %25 = arith.addf %22, %24 : f64 + %26 = arith.mulf %18, %25 : f64 + %27 = arith.addf %20, %26 : f64 + %28 = arith.mulf %16, %27 : f64 + affine.store %28, %arg5[%arg7 + %arg6 * 100 + 75] : memref + } + } + return + } + func.func @mfem_integrate_grad_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 4 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg5 + %arg4 * 50 + %arg7 * 5] : memref + %2 = affine.load %arg2[%arg6 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg4, %arg5, %arg6] : memref<2x5x4xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 4 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg5 + %arg4 * 50 + %arg7 * 5 + 25] : memref + %2 = affine.load %arg1[%arg6 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg4, %arg5, %arg6] : memref<2x5x4xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg4, %arg7, %arg6] : memref<2x5x4xf64> + %2 = affine.load %arg1[%arg5 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg4, %arg5, %arg6] : memref<2x4x4xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca_1[%arg4, %arg7, %arg6] : memref<2x5x4xf64> + %2 = affine.load %arg2[%arg5 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg4, %arg5, %arg6] : memref<2x4x4xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + %0 = affine.load %alloca_0[%arg4, %arg5, %arg6] : memref<2x4x4xf64> + %1 = affine.load %alloca[%arg4, %arg5, %arg6] : memref<2x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %arg3[%arg6 + %arg4 * 16 + %arg5 * 4] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg3[%arg6 + %arg4 * 16 + %arg5 * 4] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_mtop_iso_elasticity_dfem_2d.matched.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_mtop_iso_elasticity_dfem_2d.matched.mlir new file mode 100644 index 000000000000..4f416f68b0dc --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_mtop_iso_elasticity_dfem_2d.matched.mlir @@ -0,0 +1,478 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map8 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50 + 25)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4 + 32)> +#map10 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50 + 100)> +#map11 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50 + 125)> +#map12 = affine_map<(d0, d1) -> (d1 + d0 * 100)> +#map13 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 25)> +#map14 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 50)> +#map15 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 75)> +#map16 = affine_map<(d0, d1) -> (d1 + d0 * 25)> +#map17 = affine_map<(d0, d1) -> (d0, d1)> +#map18 = affine_map<(d0, d1) -> (d1)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d2)> +#map21 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50 + 25)> +#map22 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d1)> +#map23 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50 + 100)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50 + 125)> +#map26 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4 + 32)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_mtop_iso_elasticity_dfem_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c25 = arith.constant 25 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg7 : memref + %1 = bufferization.to_tensor %arg6 : memref + %2 = bufferization.to_tensor %arg5 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = bufferization.to_tensor %arg3 : memref + %5 = bufferization.to_tensor %arg2 : memref + %6 = bufferization.to_tensor %arg1 : memref + %7 = bufferization.to_tensor %arg0 : memref + %8 = tensor.empty() : tensor<200xf64> + %9 = tensor.empty() : tensor<200xf64> + %10 = tensor.empty() : tensor<2x4x5xf64> + %11 = tensor.empty() : tensor<2x4x5xf64> + %extracted_slice = tensor.extract_slice %11[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %12 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %12 into %11[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %13 = polygeist.submap(%7, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %14 = polygeist.submap(%5, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v14_contract_15_tc0 = tensor.cast %14 : tensor to tensor<*xf64> + + %v13_contract_15_tc1 = tensor.cast %13 : tensor to tensor<*xf64> + + %inserted_slice_contract_15_tc2 = tensor.cast %inserted_slice : tensor<2x4x5xf64> to tensor<*xf64> + + %v15_tdyn = kernel.launch @cutensornetContraction2_f64(%v14_contract_15_tc0, %v13_contract_15_tc1, %inserted_slice_contract_15_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %15 = tensor.cast %v15_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %extracted_slice_0 = tensor.extract_slice %10[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_0 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_1 = tensor.insert_slice %16 into %10[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %17 = polygeist.submap(%6, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %18 = polygeist.submap(%5, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v18_contract_19_tc0 = tensor.cast %18 : tensor to tensor<*xf64> + + %v17_contract_19_tc1 = tensor.cast %17 : tensor to tensor<*xf64> + + %inserted_slice_1_contract_19_tc2 = tensor.cast %inserted_slice_1 : tensor<2x4x5xf64> to tensor<*xf64> + + %v19_tdyn = kernel.launch @cutensornetContraction2_f64(%v18_contract_19_tc0, %v17_contract_19_tc1, %inserted_slice_1_contract_19_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %19 = tensor.cast %v19_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %20 = polygeist.submap(%9, %c2, %c5, %c5) {map = #map5} : (tensor<200xf64>, index, index, index) -> tensor + %21 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%20 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %22 = polygeist.submapInverse(%9, %21, %c2, %c5, %c5) {map = #map5} : (tensor<200xf64>, tensor, index, index, index) -> tensor<200xf64> + %23 = polygeist.submap(%22, %c2, %c5, %c5) {map = #map5} : (tensor<200xf64>, index, index, index) -> tensor<2x5x5xf64> + %extracted_slice_2 = tensor.extract_slice %19[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %24 = polygeist.submap(%7, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %extracted_slice_2_contract_25_tc0 = tensor.cast %extracted_slice_2 : tensor to tensor<*xf64> + + %v24_contract_25_tc1 = tensor.cast %24 : tensor to tensor<*xf64> + + %v23_contract_25_tc2 = tensor.cast %23 : tensor<2x5x5xf64> to tensor<*xf64> + + %v25_tdyn = kernel.launch @cutensornetContraction2_f64(%extracted_slice_2_contract_25_tc0, %v24_contract_25_tc1, %v23_contract_25_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %25 = tensor.cast %v25_tdyn : tensor<*xf64> to tensor<2x5x5xf64> + %26 = polygeist.submapInverse(%22, %25, %c2, %c5, %c5) {map = #map5} : (tensor<200xf64>, tensor<2x5x5xf64>, index, index, index) -> tensor<200xf64> + %27 = polygeist.submap(%26, %c2, %c5, %c5) {map = #map8} : (tensor<200xf64>, index, index, index) -> tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%27 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %29 = polygeist.submapInverse(%26, %28, %c2, %c5, %c5) {map = #map8} : (tensor<200xf64>, tensor, index, index, index) -> tensor<200xf64> + %30 = polygeist.submap(%29, %c2, %c5, %c5) {map = #map8} : (tensor<200xf64>, index, index, index) -> tensor<2x5x5xf64> + %extracted_slice_3 = tensor.extract_slice %15[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %31 = polygeist.submap(%6, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %extracted_slice_3_contract_32_tc0 = tensor.cast %extracted_slice_3 : tensor to tensor<*xf64> + + %v31_contract_32_tc1 = tensor.cast %31 : tensor to tensor<*xf64> + + %v30_contract_32_tc2 = tensor.cast %30 : tensor<2x5x5xf64> to tensor<*xf64> + + %v32_tdyn = kernel.launch @cutensornetContraction2_f64(%extracted_slice_3_contract_32_tc0, %v31_contract_32_tc1, %v30_contract_32_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %32 = tensor.cast %v32_tdyn : tensor<*xf64> to tensor<2x5x5xf64> + %33 = polygeist.submapInverse(%29, %32, %c2, %c5, %c5) {map = #map8} : (tensor<200xf64>, tensor<2x5x5xf64>, index, index, index) -> tensor<200xf64> + %34 = tensor.empty() : tensor<2x4x5xf64> + %35 = tensor.empty() : tensor<2x4x5xf64> + %extracted_slice_4 = tensor.extract_slice %35[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %36 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_4 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_5 = tensor.insert_slice %36 into %35[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %37 = polygeist.submap(%7, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %38 = polygeist.submap(%5, %c2, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index) -> tensor + %v38_contract_39_tc0 = tensor.cast %38 : tensor to tensor<*xf64> + + %v37_contract_39_tc1 = tensor.cast %37 : tensor to tensor<*xf64> + + %inserted_slice_5_contract_39_tc2 = tensor.cast %inserted_slice_5 : tensor<2x4x5xf64> to tensor<*xf64> + + %v39_tdyn = kernel.launch @cutensornetContraction2_f64(%v38_contract_39_tc0, %v37_contract_39_tc1, %inserted_slice_5_contract_39_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %39 = tensor.cast %v39_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %extracted_slice_6 = tensor.extract_slice %34[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %40 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_6 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_7 = tensor.insert_slice %40 into %34[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor into tensor<2x4x5xf64> + %41 = polygeist.submap(%6, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %42 = polygeist.submap(%5, %c2, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index) -> tensor + %v42_contract_43_tc0 = tensor.cast %42 : tensor to tensor<*xf64> + + %v41_contract_43_tc1 = tensor.cast %41 : tensor to tensor<*xf64> + + %inserted_slice_7_contract_43_tc2 = tensor.cast %inserted_slice_7 : tensor<2x4x5xf64> to tensor<*xf64> + + %v43_tdyn = kernel.launch @cutensornetContraction2_f64(%v42_contract_43_tc0, %v41_contract_43_tc1, %inserted_slice_7_contract_43_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %43 = tensor.cast %v43_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %44 = polygeist.submap(%33, %c2, %c5, %c5) {map = #map10} : (tensor<200xf64>, index, index, index) -> tensor + %45 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%44 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %46 = polygeist.submapInverse(%33, %45, %c2, %c5, %c5) {map = #map10} : (tensor<200xf64>, tensor, index, index, index) -> tensor<200xf64> + %47 = polygeist.submap(%46, %c2, %c5, %c5) {map = #map10} : (tensor<200xf64>, index, index, index) -> tensor<2x5x5xf64> + %extracted_slice_8 = tensor.extract_slice %43[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %48 = polygeist.submap(%7, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %extracted_slice_8_contract_49_tc0 = tensor.cast %extracted_slice_8 : tensor to tensor<*xf64> + + %v48_contract_49_tc1 = tensor.cast %48 : tensor to tensor<*xf64> + + %v47_contract_49_tc2 = tensor.cast %47 : tensor<2x5x5xf64> to tensor<*xf64> + + %v49_tdyn = kernel.launch @cutensornetContraction2_f64(%extracted_slice_8_contract_49_tc0, %v48_contract_49_tc1, %v47_contract_49_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %49 = tensor.cast %v49_tdyn : tensor<*xf64> to tensor<2x5x5xf64> + %50 = polygeist.submapInverse(%46, %49, %c2, %c5, %c5) {map = #map10} : (tensor<200xf64>, tensor<2x5x5xf64>, index, index, index) -> tensor<200xf64> + %51 = polygeist.submap(%50, %c2, %c5, %c5) {map = #map11} : (tensor<200xf64>, index, index, index) -> tensor + %52 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%51 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %53 = polygeist.submapInverse(%50, %52, %c2, %c5, %c5) {map = #map11} : (tensor<200xf64>, tensor, index, index, index) -> tensor<200xf64> + %54 = polygeist.submap(%53, %c2, %c5, %c5) {map = #map11} : (tensor<200xf64>, index, index, index) -> tensor<2x5x5xf64> + %extracted_slice_9 = tensor.extract_slice %39[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : tensor<2x4x5xf64> to tensor + %55 = polygeist.submap(%6, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %extracted_slice_9_contract_56_tc0 = tensor.cast %extracted_slice_9 : tensor to tensor<*xf64> + + %v55_contract_56_tc1 = tensor.cast %55 : tensor to tensor<*xf64> + + %v54_contract_56_tc2 = tensor.cast %54 : tensor<2x5x5xf64> to tensor<*xf64> + + %v56_tdyn = kernel.launch @cutensornetContraction2_f64(%extracted_slice_9_contract_56_tc0, %v55_contract_56_tc1, %v54_contract_56_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %56 = tensor.cast %v56_tdyn : tensor<*xf64> to tensor<2x5x5xf64> + %57 = polygeist.submapInverse(%53, %56, %c2, %c5, %c5) {map = #map11} : (tensor<200xf64>, tensor<2x5x5xf64>, index, index, index) -> tensor<200xf64> + %58 = polygeist.submap(%8, %c2, %c25) {map = #map12} : (tensor<200xf64>, index, index) -> tensor + %59 = polygeist.submap(%57, %c2, %c25) {map = #map12} : (tensor<200xf64>, index, index) -> tensor + %60 = polygeist.submap(%57, %c2, %c25) {map = #map13} : (tensor<200xf64>, index, index) -> tensor + %61 = polygeist.submap(%57, %c2, %c25) {map = #map14} : (tensor<200xf64>, index, index) -> tensor + %62 = polygeist.submap(%57, %c2, %c25) {map = #map15} : (tensor<200xf64>, index, index) -> tensor + %63 = polygeist.submap(%4, %c2, %c25) {map = #map16} : (tensor, index, index) -> tensor + %64 = polygeist.submap(%3, %c2, %c25) {map = #map16} : (tensor, index, index) -> tensor + %65 = polygeist.submap(%2, %c2, %c25) {map = #map12} : (tensor, index, index) -> tensor + %66 = polygeist.submap(%2, %c2, %c25) {map = #map13} : (tensor, index, index) -> tensor + %67 = polygeist.submap(%2, %c2, %c25) {map = #map14} : (tensor, index, index) -> tensor + %68 = polygeist.submap(%2, %c2, %c25) {map = #map15} : (tensor, index, index) -> tensor + %extracted_slice_10 = tensor.extract_slice %1[0] [%c25] [1] : tensor to tensor + %69 = linalg.generic {doc = "", indexing_maps = [#map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map18, #map17, #map17, #map17], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%65, %66, %67, %68, %59, %60, %61, %62, %extracted_slice_10, %63, %64 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%58 : tensor) { + ^bb0(%in: f64, %in_30: f64, %in_31: f64, %in_32: f64, %in_33: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %out: f64): + %153 = arith.mulf %in, %in_32 : f64 + %154 = arith.mulf %in_30, %in_31 : f64 + %155 = arith.subf %153, %154 : f64 + %156 = arith.divf %in_32, %155 : f64 + %157 = arith.negf %in_30 : f64 + %158 = arith.divf %157, %155 : f64 + %159 = arith.addf %in_33, %in_36 : f64 + %160 = arith.mulf %in_37, %155 : f64 + %161 = arith.mulf %in_38, %156 : f64 + %162 = arith.mulf %161, %159 : f64 + %163 = arith.addf %in_33, %in_33 : f64 + %164 = arith.mulf %156, %163 : f64 + %165 = arith.addf %in_34, %in_35 : f64 + %166 = arith.mulf %158, %165 : f64 + %167 = arith.addf %164, %166 : f64 + %168 = arith.mulf %in_39, %167 : f64 + %169 = arith.addf %162, %168 : f64 + %170 = arith.mulf %160, %169 : f64 + linalg.yield %170 : f64 + } -> tensor + %70 = polygeist.submapInverse(%8, %69, %c2, %c25) {map = #map12} : (tensor<200xf64>, tensor, index, index) -> tensor<200xf64> + %71 = polygeist.submap(%70, %c2, %c25) {map = #map14} : (tensor<200xf64>, index, index) -> tensor + %72 = polygeist.submap(%57, %c2, %c25) {map = #map12} : (tensor<200xf64>, index, index) -> tensor + %73 = polygeist.submap(%57, %c2, %c25) {map = #map13} : (tensor<200xf64>, index, index) -> tensor + %74 = polygeist.submap(%57, %c2, %c25) {map = #map14} : (tensor<200xf64>, index, index) -> tensor + %75 = polygeist.submap(%57, %c2, %c25) {map = #map15} : (tensor<200xf64>, index, index) -> tensor + %76 = polygeist.submap(%4, %c2, %c25) {map = #map16} : (tensor, index, index) -> tensor + %77 = polygeist.submap(%3, %c2, %c25) {map = #map16} : (tensor, index, index) -> tensor + %78 = polygeist.submap(%2, %c2, %c25) {map = #map12} : (tensor, index, index) -> tensor + %79 = polygeist.submap(%2, %c2, %c25) {map = #map13} : (tensor, index, index) -> tensor + %80 = polygeist.submap(%2, %c2, %c25) {map = #map14} : (tensor, index, index) -> tensor + %81 = polygeist.submap(%2, %c2, %c25) {map = #map15} : (tensor, index, index) -> tensor + %extracted_slice_11 = tensor.extract_slice %1[0] [%c25] [1] : tensor to tensor + %82 = linalg.generic {doc = "", indexing_maps = [#map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map18, #map17, #map17, #map17], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%78, %79, %80, %81, %72, %73, %74, %75, %extracted_slice_11, %76, %77 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%71 : tensor) { + ^bb0(%in: f64, %in_30: f64, %in_31: f64, %in_32: f64, %in_33: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %out: f64): + %153 = arith.mulf %in, %in_32 : f64 + %154 = arith.mulf %in_30, %in_31 : f64 + %155 = arith.subf %153, %154 : f64 + %156 = arith.divf %in_32, %155 : f64 + %157 = arith.negf %in_30 : f64 + %158 = arith.divf %157, %155 : f64 + %159 = arith.addf %in_33, %in_36 : f64 + %160 = arith.mulf %in_37, %155 : f64 + %161 = arith.mulf %in_38, %158 : f64 + %162 = arith.mulf %161, %159 : f64 + %163 = arith.addf %in_35, %in_34 : f64 + %164 = arith.mulf %156, %163 : f64 + %165 = arith.addf %in_36, %in_36 : f64 + %166 = arith.mulf %158, %165 : f64 + %167 = arith.addf %164, %166 : f64 + %168 = arith.mulf %in_39, %167 : f64 + %169 = arith.addf %162, %168 : f64 + %170 = arith.mulf %160, %169 : f64 + linalg.yield %170 : f64 + } -> tensor + %83 = polygeist.submapInverse(%70, %82, %c2, %c25) {map = #map14} : (tensor<200xf64>, tensor, index, index) -> tensor<200xf64> + %84 = polygeist.submap(%83, %c2, %c25) {map = #map13} : (tensor<200xf64>, index, index) -> tensor + %85 = polygeist.submap(%57, %c2, %c25) {map = #map12} : (tensor<200xf64>, index, index) -> tensor + %86 = polygeist.submap(%57, %c2, %c25) {map = #map13} : (tensor<200xf64>, index, index) -> tensor + %87 = polygeist.submap(%57, %c2, %c25) {map = #map14} : (tensor<200xf64>, index, index) -> tensor + %88 = polygeist.submap(%57, %c2, %c25) {map = #map15} : (tensor<200xf64>, index, index) -> tensor + %89 = polygeist.submap(%4, %c2, %c25) {map = #map16} : (tensor, index, index) -> tensor + %90 = polygeist.submap(%3, %c2, %c25) {map = #map16} : (tensor, index, index) -> tensor + %91 = polygeist.submap(%2, %c2, %c25) {map = #map12} : (tensor, index, index) -> tensor + %92 = polygeist.submap(%2, %c2, %c25) {map = #map13} : (tensor, index, index) -> tensor + %93 = polygeist.submap(%2, %c2, %c25) {map = #map14} : (tensor, index, index) -> tensor + %94 = polygeist.submap(%2, %c2, %c25) {map = #map15} : (tensor, index, index) -> tensor + %extracted_slice_12 = tensor.extract_slice %1[0] [%c25] [1] : tensor to tensor + %95 = linalg.generic {doc = "", indexing_maps = [#map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map18, #map17, #map17, #map17], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%91, %92, %93, %94, %85, %86, %87, %88, %extracted_slice_12, %89, %90 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%84 : tensor) { + ^bb0(%in: f64, %in_30: f64, %in_31: f64, %in_32: f64, %in_33: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %out: f64): + %153 = arith.mulf %in, %in_32 : f64 + %154 = arith.mulf %in_30, %in_31 : f64 + %155 = arith.subf %153, %154 : f64 + %156 = arith.negf %in_31 : f64 + %157 = arith.divf %156, %155 : f64 + %158 = arith.divf %in, %155 : f64 + %159 = arith.addf %in_33, %in_36 : f64 + %160 = arith.mulf %in_37, %155 : f64 + %161 = arith.mulf %in_38, %157 : f64 + %162 = arith.mulf %161, %159 : f64 + %163 = arith.addf %in_33, %in_33 : f64 + %164 = arith.mulf %157, %163 : f64 + %165 = arith.addf %in_34, %in_35 : f64 + %166 = arith.mulf %158, %165 : f64 + %167 = arith.addf %164, %166 : f64 + %168 = arith.mulf %in_39, %167 : f64 + %169 = arith.addf %162, %168 : f64 + %170 = arith.mulf %160, %169 : f64 + linalg.yield %170 : f64 + } -> tensor + %96 = polygeist.submapInverse(%83, %95, %c2, %c25) {map = #map13} : (tensor<200xf64>, tensor, index, index) -> tensor<200xf64> + %97 = polygeist.submap(%96, %c2, %c25) {map = #map15} : (tensor<200xf64>, index, index) -> tensor + %98 = polygeist.submap(%57, %c2, %c25) {map = #map12} : (tensor<200xf64>, index, index) -> tensor + %99 = polygeist.submap(%57, %c2, %c25) {map = #map13} : (tensor<200xf64>, index, index) -> tensor + %100 = polygeist.submap(%57, %c2, %c25) {map = #map14} : (tensor<200xf64>, index, index) -> tensor + %101 = polygeist.submap(%57, %c2, %c25) {map = #map15} : (tensor<200xf64>, index, index) -> tensor + %102 = polygeist.submap(%4, %c2, %c25) {map = #map16} : (tensor, index, index) -> tensor + %103 = polygeist.submap(%3, %c2, %c25) {map = #map16} : (tensor, index, index) -> tensor + %104 = polygeist.submap(%2, %c2, %c25) {map = #map12} : (tensor, index, index) -> tensor + %105 = polygeist.submap(%2, %c2, %c25) {map = #map13} : (tensor, index, index) -> tensor + %106 = polygeist.submap(%2, %c2, %c25) {map = #map14} : (tensor, index, index) -> tensor + %107 = polygeist.submap(%2, %c2, %c25) {map = #map15} : (tensor, index, index) -> tensor + %extracted_slice_13 = tensor.extract_slice %1[0] [%c25] [1] : tensor to tensor + %108 = linalg.generic {doc = "", indexing_maps = [#map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map18, #map17, #map17, #map17], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%104, %105, %106, %107, %98, %99, %100, %101, %extracted_slice_13, %102, %103 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%97 : tensor) { + ^bb0(%in: f64, %in_30: f64, %in_31: f64, %in_32: f64, %in_33: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %out: f64): + %153 = arith.mulf %in, %in_32 : f64 + %154 = arith.mulf %in_30, %in_31 : f64 + %155 = arith.subf %153, %154 : f64 + %156 = arith.negf %in_31 : f64 + %157 = arith.divf %156, %155 : f64 + %158 = arith.divf %in, %155 : f64 + %159 = arith.addf %in_33, %in_36 : f64 + %160 = arith.mulf %in_37, %155 : f64 + %161 = arith.mulf %in_38, %158 : f64 + %162 = arith.mulf %161, %159 : f64 + %163 = arith.addf %in_35, %in_34 : f64 + %164 = arith.mulf %157, %163 : f64 + %165 = arith.addf %in_36, %in_36 : f64 + %166 = arith.mulf %158, %165 : f64 + %167 = arith.addf %164, %166 : f64 + %168 = arith.mulf %in_39, %167 : f64 + %169 = arith.addf %162, %168 : f64 + %170 = arith.mulf %160, %169 : f64 + linalg.yield %170 : f64 + } -> tensor + %109 = polygeist.submapInverse(%96, %108, %c2, %c25) {map = #map15} : (tensor<200xf64>, tensor, index, index) -> tensor<200xf64> + %110 = tensor.empty() : tensor<2x4x4xf64> + %111 = tensor.empty() : tensor<2x4x4xf64> + %112 = tensor.empty() : tensor<2x5x4xf64> + %113 = tensor.empty() : tensor<2x5x4xf64> + %extracted_slice_14 = tensor.extract_slice %113[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %114 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_14 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_15 = tensor.insert_slice %114 into %113[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor into tensor<2x5x4xf64> + %115 = polygeist.submap(%109, %c2, %c5, %c4, %c5) {map = #map19} : (tensor<200xf64>, index, index, index, index) -> tensor + %116 = polygeist.submap(%6, %c2, %c5, %c4, %c5) {map = #map20} : (tensor, index, index, index, index) -> tensor + %v115_contract_117_tc0 = tensor.cast %115 : tensor to tensor<*xf64> + + %v116_contract_117_tc1 = tensor.cast %116 : tensor to tensor<*xf64> + + %inserted_slice_15_contract_117_tc2 = tensor.cast %inserted_slice_15 : tensor<2x5x4xf64> to tensor<*xf64> + + %v117_tdyn = kernel.launch @cutensornetContraction2_f64(%v115_contract_117_tc0, %v116_contract_117_tc1, %inserted_slice_15_contract_117_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %117 = tensor.cast %v117_tdyn : tensor<*xf64> to tensor<2x5x4xf64> + %extracted_slice_16 = tensor.extract_slice %112[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %118 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_16 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_17 = tensor.insert_slice %118 into %112[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor into tensor<2x5x4xf64> + %119 = polygeist.submap(%109, %c2, %c5, %c4, %c5) {map = #map21} : (tensor<200xf64>, index, index, index, index) -> tensor + %120 = polygeist.submap(%7, %c2, %c5, %c4, %c5) {map = #map20} : (tensor, index, index, index, index) -> tensor + %v119_contract_121_tc0 = tensor.cast %119 : tensor to tensor<*xf64> + + %v120_contract_121_tc1 = tensor.cast %120 : tensor to tensor<*xf64> + + %inserted_slice_17_contract_121_tc2 = tensor.cast %inserted_slice_17 : tensor<2x5x4xf64> to tensor<*xf64> + + %v121_tdyn = kernel.launch @cutensornetContraction2_f64(%v119_contract_121_tc0, %v120_contract_121_tc1, %inserted_slice_17_contract_121_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %121 = tensor.cast %v121_tdyn : tensor<*xf64> to tensor<2x5x4xf64> + %extracted_slice_18 = tensor.extract_slice %111[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : tensor<2x4x4xf64> to tensor + %extracted_slice_19 = tensor.extract_slice %117[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %123 = polygeist.submap(%7, %c2, %c4, %c4, %c5) {map = #map22} : (tensor, index, index, index, index) -> tensor + %extracted_slice_19_contract_124_tc0 = tensor.cast %extracted_slice_19 : tensor to tensor<*xf64> + + %v123_contract_124_tc1 = tensor.cast %123 : tensor to tensor<*xf64> + + %extracted_slice_18_contract_124_tc2 = tensor.cast %extracted_slice_18 : tensor to tensor<*xf64> + + %v124_tdyn = kernel.launch @cutensornetContraction2_f64(%extracted_slice_19_contract_124_tc0, %v123_contract_124_tc1, %extracted_slice_18_contract_124_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %124 = tensor.cast %v124_tdyn : tensor<*xf64> to tensor + %extracted_slice_20 = tensor.extract_slice %110[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : tensor<2x4x4xf64> to tensor + %extracted_slice_21 = tensor.extract_slice %121[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %126 = polygeist.submap(%6, %c2, %c4, %c4, %c5) {map = #map22} : (tensor, index, index, index, index) -> tensor + %extracted_slice_21_contract_127_tc0 = tensor.cast %extracted_slice_21 : tensor to tensor<*xf64> + + %v126_contract_127_tc1 = tensor.cast %126 : tensor to tensor<*xf64> + + %extracted_slice_20_contract_127_tc2 = tensor.cast %extracted_slice_20 : tensor to tensor<*xf64> + + %v127_tdyn = kernel.launch @cutensornetContraction2_f64(%extracted_slice_21_contract_127_tc0, %v126_contract_127_tc1, %extracted_slice_20_contract_127_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %127 = tensor.cast %v127_tdyn : tensor<*xf64> to tensor + %128 = polygeist.submap(%0, %c2, %c4, %c4) {map = #map23} : (tensor, index, index, index) -> tensor + %129 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%124, %127 : tensor, tensor) outs(%128 : tensor) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.addf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor + %130 = polygeist.submapInverse(%0, %129, %c2, %c4, %c4) {map = #map23} : (tensor, tensor, index, index, index) -> tensor + %131 = tensor.empty() : tensor<2x4x4xf64> + %132 = tensor.empty() : tensor<2x4x4xf64> + %133 = tensor.empty() : tensor<2x5x4xf64> + %134 = tensor.empty() : tensor<2x5x4xf64> + %extracted_slice_22 = tensor.extract_slice %134[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %135 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_22 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_23 = tensor.insert_slice %135 into %134[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor into tensor<2x5x4xf64> + %136 = polygeist.submap(%109, %c2, %c5, %c4, %c5) {map = #map24} : (tensor<200xf64>, index, index, index, index) -> tensor + %137 = polygeist.submap(%6, %c2, %c5, %c4, %c5) {map = #map20} : (tensor, index, index, index, index) -> tensor + %v136_contract_138_tc0 = tensor.cast %136 : tensor to tensor<*xf64> + + %v137_contract_138_tc1 = tensor.cast %137 : tensor to tensor<*xf64> + + %inserted_slice_23_contract_138_tc2 = tensor.cast %inserted_slice_23 : tensor<2x5x4xf64> to tensor<*xf64> + + %v138_tdyn = kernel.launch @cutensornetContraction2_f64(%v136_contract_138_tc0, %v137_contract_138_tc1, %inserted_slice_23_contract_138_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %138 = tensor.cast %v138_tdyn : tensor<*xf64> to tensor<2x5x4xf64> + %extracted_slice_24 = tensor.extract_slice %133[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %139 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_24 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_25 = tensor.insert_slice %139 into %133[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor into tensor<2x5x4xf64> + %140 = polygeist.submap(%109, %c2, %c5, %c4, %c5) {map = #map25} : (tensor<200xf64>, index, index, index, index) -> tensor + %141 = polygeist.submap(%7, %c2, %c5, %c4, %c5) {map = #map20} : (tensor, index, index, index, index) -> tensor + %v140_contract_142_tc0 = tensor.cast %140 : tensor to tensor<*xf64> + + %v141_contract_142_tc1 = tensor.cast %141 : tensor to tensor<*xf64> + + %inserted_slice_25_contract_142_tc2 = tensor.cast %inserted_slice_25 : tensor<2x5x4xf64> to tensor<*xf64> + + %v142_tdyn = kernel.launch @cutensornetContraction2_f64(%v140_contract_142_tc0, %v141_contract_142_tc1, %inserted_slice_25_contract_142_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %142 = tensor.cast %v142_tdyn : tensor<*xf64> to tensor<2x5x4xf64> + %extracted_slice_26 = tensor.extract_slice %132[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : tensor<2x4x4xf64> to tensor + %extracted_slice_27 = tensor.extract_slice %138[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %144 = polygeist.submap(%7, %c2, %c4, %c4, %c5) {map = #map22} : (tensor, index, index, index, index) -> tensor + %extracted_slice_27_contract_145_tc0 = tensor.cast %extracted_slice_27 : tensor to tensor<*xf64> + + %v144_contract_145_tc1 = tensor.cast %144 : tensor to tensor<*xf64> + + %extracted_slice_26_contract_145_tc2 = tensor.cast %extracted_slice_26 : tensor to tensor<*xf64> + + %v145_tdyn = kernel.launch @cutensornetContraction2_f64(%extracted_slice_27_contract_145_tc0, %v144_contract_145_tc1, %extracted_slice_26_contract_145_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %145 = tensor.cast %v145_tdyn : tensor<*xf64> to tensor + %extracted_slice_28 = tensor.extract_slice %131[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : tensor<2x4x4xf64> to tensor + %extracted_slice_29 = tensor.extract_slice %142[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : tensor<2x5x4xf64> to tensor + %147 = polygeist.submap(%6, %c2, %c4, %c4, %c5) {map = #map22} : (tensor, index, index, index, index) -> tensor + %extracted_slice_29_contract_148_tc0 = tensor.cast %extracted_slice_29 : tensor to tensor<*xf64> + + %v147_contract_148_tc1 = tensor.cast %147 : tensor to tensor<*xf64> + + %extracted_slice_28_contract_148_tc2 = tensor.cast %extracted_slice_28 : tensor to tensor<*xf64> + + %v148_tdyn = kernel.launch @cutensornetContraction2_f64(%extracted_slice_29_contract_148_tc0, %v147_contract_148_tc1, %extracted_slice_28_contract_148_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %148 = tensor.cast %v148_tdyn : tensor<*xf64> to tensor + %149 = polygeist.submap(%130, %c2, %c4, %c4) {map = #map26} : (tensor, index, index, index) -> tensor + %150 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%145, %148 : tensor, tensor) outs(%149 : tensor) { + ^bb0(%in: f64, %in_30: f64, %out: f64): + %153 = arith.addf %in, %in_30 : f64 + %154 = arith.addf %out, %153 : f64 + linalg.yield %154 : f64 + } -> tensor + %151 = polygeist.submapInverse(%130, %150, %c2, %c4, %c4) {map = #map26} : (tensor, tensor, index, index, index) -> tensor + %152 = bufferization.to_memref %151 : memref + memref.copy %152, %arg7 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_mtop_iso_elasticity_dfem_2d.raised.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_mtop_iso_elasticity_dfem_2d.raised.mlir new file mode 100644 index 000000000000..812075fd77b8 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_mtop_iso_elasticity_dfem_2d.raised.mlir @@ -0,0 +1,422 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map8 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50 + 25)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4 + 32)> +#map10 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50 + 100)> +#map11 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50 + 125)> +#map12 = affine_map<(d0, d1) -> (d1 + d0 * 100)> +#map13 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 25)> +#map14 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 50)> +#map15 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 75)> +#map16 = affine_map<(d0, d1) -> (d1 + d0 * 25)> +#map17 = affine_map<(d0, d1) -> (d0, d1)> +#map18 = affine_map<(d0, d1) -> (d1)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d2)> +#map21 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50 + 25)> +#map22 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d1)> +#map23 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50 + 100)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50 + 125)> +#map26 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4 + 32)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_mtop_iso_elasticity_dfem_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c25 = arith.constant 25 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<200xf64> + %alloca_0 = memref.alloca() : memref<200xf64> + %alloca_1 = memref.alloca() : memref<2x4x5xf64> + %alloca_2 = memref.alloca() : memref<2x4x5xf64> + %subview = memref.subview %alloca_2[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg2, %c2, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_2 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.mulf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %subview_3 = memref.subview %alloca_1[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_3 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg2, %c2, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%2, %3 : memref, memref) outs(%alloca_1 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.mulf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %4 = polygeist.submap(%alloca_0, %c2, %c5, %c5) {map = #map5} : (memref<200xf64>, index, index, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%4 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_4 = memref.subview %alloca_1[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + %5 = polygeist.submap(%arg0, %c2, %c5, %c5, %c4) {map = #map6} : (memref, index, index, index, index) -> memref + %6 = polygeist.submap(%alloca_0, %c2, %c5, %c5) {map = #map5} : (memref<200xf64>, index, index, index) -> memref<2x5x5xf64> + linalg.generic {indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_4, %5 : memref>, memref) outs(%6 : memref<2x5x5xf64>) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.mulf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %7 = polygeist.submap(%alloca_0, %c2, %c5, %c5) {map = #map8} : (memref<200xf64>, index, index, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%7 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_5 = memref.subview %alloca_2[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + %8 = polygeist.submap(%arg1, %c2, %c5, %c5, %c4) {map = #map6} : (memref, index, index, index, index) -> memref + %9 = polygeist.submap(%alloca_0, %c2, %c5, %c5) {map = #map8} : (memref<200xf64>, index, index, index) -> memref<2x5x5xf64> + linalg.generic {indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_5, %8 : memref>, memref) outs(%9 : memref<2x5x5xf64>) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.mulf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %alloca_6 = memref.alloca() : memref<2x4x5xf64> + %alloca_7 = memref.alloca() : memref<2x4x5xf64> + %subview_8 = memref.subview %alloca_7[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_8 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %10 = polygeist.submap(%arg2, %c2, %c4, %c5, %c4) {map = #map9} : (memref, index, index, index, index) -> memref + %11 = polygeist.submap(%arg0, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%10, %11 : memref, memref) outs(%alloca_7 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.mulf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %subview_9 = memref.subview %alloca_6[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_9 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %12 = polygeist.submap(%arg2, %c2, %c4, %c5, %c4) {map = #map9} : (memref, index, index, index, index) -> memref + %13 = polygeist.submap(%arg1, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%12, %13 : memref, memref) outs(%alloca_6 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.mulf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %14 = polygeist.submap(%alloca_0, %c2, %c5, %c5) {map = #map10} : (memref<200xf64>, index, index, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%14 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_10 = memref.subview %alloca_6[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + %15 = polygeist.submap(%arg0, %c2, %c5, %c5, %c4) {map = #map6} : (memref, index, index, index, index) -> memref + %16 = polygeist.submap(%alloca_0, %c2, %c5, %c5) {map = #map10} : (memref<200xf64>, index, index, index) -> memref<2x5x5xf64> + linalg.generic {indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_10, %15 : memref>, memref) outs(%16 : memref<2x5x5xf64>) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.mulf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %17 = polygeist.submap(%alloca_0, %c2, %c5, %c5) {map = #map11} : (memref<200xf64>, index, index, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%17 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_11 = memref.subview %alloca_7[0, 0, 0] [%c2, %c4, %c5] [1, 1, 1] : memref<2x4x5xf64> to memref> + %18 = polygeist.submap(%arg1, %c2, %c5, %c5, %c4) {map = #map6} : (memref, index, index, index, index) -> memref + %19 = polygeist.submap(%alloca_0, %c2, %c5, %c5) {map = #map11} : (memref<200xf64>, index, index, index) -> memref<2x5x5xf64> + linalg.generic {indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_11, %18 : memref>, memref) outs(%19 : memref<2x5x5xf64>) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.mulf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %20 = polygeist.submap(%arg5, %c2, %c25) {map = #map12} : (memref, index, index) -> memref + %21 = polygeist.submap(%arg5, %c2, %c25) {map = #map13} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg5, %c2, %c25) {map = #map14} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg5, %c2, %c25) {map = #map15} : (memref, index, index) -> memref + %24 = polygeist.submap(%alloca_0, %c2, %c25) {map = #map12} : (memref<200xf64>, index, index) -> memref + %25 = polygeist.submap(%alloca_0, %c2, %c25) {map = #map13} : (memref<200xf64>, index, index) -> memref + %26 = polygeist.submap(%alloca_0, %c2, %c25) {map = #map14} : (memref<200xf64>, index, index) -> memref + %27 = polygeist.submap(%alloca_0, %c2, %c25) {map = #map15} : (memref<200xf64>, index, index) -> memref + %subview_12 = memref.subview %arg6[0] [%c25] [1] : memref to memref> + %28 = polygeist.submap(%arg3, %c2, %c25) {map = #map16} : (memref, index, index) -> memref + %29 = polygeist.submap(%arg4, %c2, %c25) {map = #map16} : (memref, index, index) -> memref + %30 = polygeist.submap(%alloca, %c2, %c25) {map = #map12} : (memref<200xf64>, index, index) -> memref + linalg.generic {indexing_maps = [#map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map18, #map17, #map17, #map17], iterator_types = ["parallel", "parallel"]} ins(%20, %21, %22, %23, %24, %25, %26, %27, %subview_12, %28, %29 : memref, memref, memref, memref, memref, memref, memref, memref, memref>, memref, memref) outs(%30 : memref) { + ^bb0(%in: f64, %in_44: f64, %in_45: f64, %in_46: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %out: f64): + %78 = arith.mulf %in, %in_46 : f64 + %79 = arith.mulf %in_44, %in_45 : f64 + %80 = arith.subf %78, %79 : f64 + %81 = arith.divf %in_46, %80 : f64 + %82 = arith.negf %in_44 : f64 + %83 = arith.divf %82, %80 : f64 + %84 = arith.addf %in_47, %in_50 : f64 + %85 = arith.mulf %in_51, %80 : f64 + %86 = arith.mulf %in_52, %81 : f64 + %87 = arith.mulf %86, %84 : f64 + %88 = arith.addf %in_47, %in_47 : f64 + %89 = arith.mulf %81, %88 : f64 + %90 = arith.addf %in_48, %in_49 : f64 + %91 = arith.mulf %83, %90 : f64 + %92 = arith.addf %89, %91 : f64 + %93 = arith.mulf %in_53, %92 : f64 + %94 = arith.addf %87, %93 : f64 + %95 = arith.mulf %85, %94 : f64 + linalg.yield %95 : f64 + } + %31 = polygeist.submap(%arg5, %c2, %c25) {map = #map12} : (memref, index, index) -> memref + %32 = polygeist.submap(%arg5, %c2, %c25) {map = #map13} : (memref, index, index) -> memref + %33 = polygeist.submap(%arg5, %c2, %c25) {map = #map14} : (memref, index, index) -> memref + %34 = polygeist.submap(%arg5, %c2, %c25) {map = #map15} : (memref, index, index) -> memref + %35 = polygeist.submap(%alloca_0, %c2, %c25) {map = #map12} : (memref<200xf64>, index, index) -> memref + %36 = polygeist.submap(%alloca_0, %c2, %c25) {map = #map13} : (memref<200xf64>, index, index) -> memref + %37 = polygeist.submap(%alloca_0, %c2, %c25) {map = #map14} : (memref<200xf64>, index, index) -> memref + %38 = polygeist.submap(%alloca_0, %c2, %c25) {map = #map15} : (memref<200xf64>, index, index) -> memref + %subview_13 = memref.subview %arg6[0] [%c25] [1] : memref to memref> + %39 = polygeist.submap(%arg3, %c2, %c25) {map = #map16} : (memref, index, index) -> memref + %40 = polygeist.submap(%arg4, %c2, %c25) {map = #map16} : (memref, index, index) -> memref + %41 = polygeist.submap(%alloca, %c2, %c25) {map = #map14} : (memref<200xf64>, index, index) -> memref + linalg.generic {indexing_maps = [#map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map18, #map17, #map17, #map17], iterator_types = ["parallel", "parallel"]} ins(%31, %32, %33, %34, %35, %36, %37, %38, %subview_13, %39, %40 : memref, memref, memref, memref, memref, memref, memref, memref, memref>, memref, memref) outs(%41 : memref) { + ^bb0(%in: f64, %in_44: f64, %in_45: f64, %in_46: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %out: f64): + %78 = arith.mulf %in, %in_46 : f64 + %79 = arith.mulf %in_44, %in_45 : f64 + %80 = arith.subf %78, %79 : f64 + %81 = arith.divf %in_46, %80 : f64 + %82 = arith.negf %in_44 : f64 + %83 = arith.divf %82, %80 : f64 + %84 = arith.addf %in_47, %in_50 : f64 + %85 = arith.mulf %in_51, %80 : f64 + %86 = arith.mulf %in_52, %83 : f64 + %87 = arith.mulf %86, %84 : f64 + %88 = arith.addf %in_49, %in_48 : f64 + %89 = arith.mulf %81, %88 : f64 + %90 = arith.addf %in_50, %in_50 : f64 + %91 = arith.mulf %83, %90 : f64 + %92 = arith.addf %89, %91 : f64 + %93 = arith.mulf %in_53, %92 : f64 + %94 = arith.addf %87, %93 : f64 + %95 = arith.mulf %85, %94 : f64 + linalg.yield %95 : f64 + } + %42 = polygeist.submap(%arg5, %c2, %c25) {map = #map12} : (memref, index, index) -> memref + %43 = polygeist.submap(%arg5, %c2, %c25) {map = #map13} : (memref, index, index) -> memref + %44 = polygeist.submap(%arg5, %c2, %c25) {map = #map14} : (memref, index, index) -> memref + %45 = polygeist.submap(%arg5, %c2, %c25) {map = #map15} : (memref, index, index) -> memref + %46 = polygeist.submap(%alloca_0, %c2, %c25) {map = #map12} : (memref<200xf64>, index, index) -> memref + %47 = polygeist.submap(%alloca_0, %c2, %c25) {map = #map13} : (memref<200xf64>, index, index) -> memref + %48 = polygeist.submap(%alloca_0, %c2, %c25) {map = #map14} : (memref<200xf64>, index, index) -> memref + %49 = polygeist.submap(%alloca_0, %c2, %c25) {map = #map15} : (memref<200xf64>, index, index) -> memref + %subview_14 = memref.subview %arg6[0] [%c25] [1] : memref to memref> + %50 = polygeist.submap(%arg3, %c2, %c25) {map = #map16} : (memref, index, index) -> memref + %51 = polygeist.submap(%arg4, %c2, %c25) {map = #map16} : (memref, index, index) -> memref + %52 = polygeist.submap(%alloca, %c2, %c25) {map = #map13} : (memref<200xf64>, index, index) -> memref + linalg.generic {indexing_maps = [#map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map18, #map17, #map17, #map17], iterator_types = ["parallel", "parallel"]} ins(%42, %43, %44, %45, %46, %47, %48, %49, %subview_14, %50, %51 : memref, memref, memref, memref, memref, memref, memref, memref, memref>, memref, memref) outs(%52 : memref) { + ^bb0(%in: f64, %in_44: f64, %in_45: f64, %in_46: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %out: f64): + %78 = arith.mulf %in, %in_46 : f64 + %79 = arith.mulf %in_44, %in_45 : f64 + %80 = arith.subf %78, %79 : f64 + %81 = arith.negf %in_45 : f64 + %82 = arith.divf %81, %80 : f64 + %83 = arith.divf %in, %80 : f64 + %84 = arith.addf %in_47, %in_50 : f64 + %85 = arith.mulf %in_51, %80 : f64 + %86 = arith.mulf %in_52, %82 : f64 + %87 = arith.mulf %86, %84 : f64 + %88 = arith.addf %in_47, %in_47 : f64 + %89 = arith.mulf %82, %88 : f64 + %90 = arith.addf %in_48, %in_49 : f64 + %91 = arith.mulf %83, %90 : f64 + %92 = arith.addf %89, %91 : f64 + %93 = arith.mulf %in_53, %92 : f64 + %94 = arith.addf %87, %93 : f64 + %95 = arith.mulf %85, %94 : f64 + linalg.yield %95 : f64 + } + %53 = polygeist.submap(%arg5, %c2, %c25) {map = #map12} : (memref, index, index) -> memref + %54 = polygeist.submap(%arg5, %c2, %c25) {map = #map13} : (memref, index, index) -> memref + %55 = polygeist.submap(%arg5, %c2, %c25) {map = #map14} : (memref, index, index) -> memref + %56 = polygeist.submap(%arg5, %c2, %c25) {map = #map15} : (memref, index, index) -> memref + %57 = polygeist.submap(%alloca_0, %c2, %c25) {map = #map12} : (memref<200xf64>, index, index) -> memref + %58 = polygeist.submap(%alloca_0, %c2, %c25) {map = #map13} : (memref<200xf64>, index, index) -> memref + %59 = polygeist.submap(%alloca_0, %c2, %c25) {map = #map14} : (memref<200xf64>, index, index) -> memref + %60 = polygeist.submap(%alloca_0, %c2, %c25) {map = #map15} : (memref<200xf64>, index, index) -> memref + %subview_15 = memref.subview %arg6[0] [%c25] [1] : memref to memref> + %61 = polygeist.submap(%arg3, %c2, %c25) {map = #map16} : (memref, index, index) -> memref + %62 = polygeist.submap(%arg4, %c2, %c25) {map = #map16} : (memref, index, index) -> memref + %63 = polygeist.submap(%alloca, %c2, %c25) {map = #map15} : (memref<200xf64>, index, index) -> memref + linalg.generic {indexing_maps = [#map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map18, #map17, #map17, #map17], iterator_types = ["parallel", "parallel"]} ins(%53, %54, %55, %56, %57, %58, %59, %60, %subview_15, %61, %62 : memref, memref, memref, memref, memref, memref, memref, memref, memref>, memref, memref) outs(%63 : memref) { + ^bb0(%in: f64, %in_44: f64, %in_45: f64, %in_46: f64, %in_47: f64, %in_48: f64, %in_49: f64, %in_50: f64, %in_51: f64, %in_52: f64, %in_53: f64, %out: f64): + %78 = arith.mulf %in, %in_46 : f64 + %79 = arith.mulf %in_44, %in_45 : f64 + %80 = arith.subf %78, %79 : f64 + %81 = arith.negf %in_45 : f64 + %82 = arith.divf %81, %80 : f64 + %83 = arith.divf %in, %80 : f64 + %84 = arith.addf %in_47, %in_50 : f64 + %85 = arith.mulf %in_51, %80 : f64 + %86 = arith.mulf %in_52, %83 : f64 + %87 = arith.mulf %86, %84 : f64 + %88 = arith.addf %in_49, %in_48 : f64 + %89 = arith.mulf %82, %88 : f64 + %90 = arith.addf %in_50, %in_50 : f64 + %91 = arith.mulf %83, %90 : f64 + %92 = arith.addf %89, %91 : f64 + %93 = arith.mulf %in_53, %92 : f64 + %94 = arith.addf %87, %93 : f64 + %95 = arith.mulf %85, %94 : f64 + linalg.yield %95 : f64 + } + %alloca_16 = memref.alloca() : memref<2x4x4xf64> + %alloca_17 = memref.alloca() : memref<2x4x4xf64> + %alloca_18 = memref.alloca() : memref<2x5x4xf64> + %alloca_19 = memref.alloca() : memref<2x5x4xf64> + %subview_20 = memref.subview %alloca_19[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_20 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %64 = polygeist.submap(%alloca, %c2, %c5, %c4, %c5) {map = #map19} : (memref<200xf64>, index, index, index, index) -> memref + %65 = polygeist.submap(%arg1, %c2, %c5, %c4, %c5) {map = #map20} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%64, %65 : memref, memref) outs(%alloca_19 : memref<2x5x4xf64>) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.mulf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %subview_21 = memref.subview %alloca_18[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_21 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %66 = polygeist.submap(%alloca, %c2, %c5, %c4, %c5) {map = #map21} : (memref<200xf64>, index, index, index, index) -> memref + %67 = polygeist.submap(%arg0, %c2, %c5, %c4, %c5) {map = #map20} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%66, %67 : memref, memref) outs(%alloca_18 : memref<2x5x4xf64>) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.mulf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %subview_22 = memref.subview %alloca_17[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_22 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_23 = memref.subview %alloca_19[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + %68 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5) {map = #map22} : (memref, index, index, index, index) -> memref + %subview_24 = memref.subview %alloca_17[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_23, %68 : memref>, memref) outs(%subview_24 : memref>) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.mulf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %subview_25 = memref.subview %alloca_16[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_25 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_26 = memref.subview %alloca_18[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + %69 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5) {map = #map22} : (memref, index, index, index, index) -> memref + %subview_27 = memref.subview %alloca_16[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_26, %69 : memref>, memref) outs(%subview_27 : memref>) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.mulf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %subview_28 = memref.subview %alloca_17[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + %subview_29 = memref.subview %alloca_16[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + %70 = polygeist.submap(%arg7, %c2, %c4, %c4) {map = #map23} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview_28, %subview_29 : memref>, memref>) outs(%70 : memref) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.addf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %alloca_30 = memref.alloca() : memref<2x4x4xf64> + %alloca_31 = memref.alloca() : memref<2x4x4xf64> + %alloca_32 = memref.alloca() : memref<2x5x4xf64> + %alloca_33 = memref.alloca() : memref<2x5x4xf64> + %subview_34 = memref.subview %alloca_33[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_34 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %71 = polygeist.submap(%alloca, %c2, %c5, %c4, %c5) {map = #map24} : (memref<200xf64>, index, index, index, index) -> memref + %72 = polygeist.submap(%arg1, %c2, %c5, %c4, %c5) {map = #map20} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%71, %72 : memref, memref) outs(%alloca_33 : memref<2x5x4xf64>) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.mulf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %subview_35 = memref.subview %alloca_32[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_35 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %73 = polygeist.submap(%alloca, %c2, %c5, %c4, %c5) {map = #map25} : (memref<200xf64>, index, index, index, index) -> memref + %74 = polygeist.submap(%arg0, %c2, %c5, %c4, %c5) {map = #map20} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%73, %74 : memref, memref) outs(%alloca_32 : memref<2x5x4xf64>) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.mulf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %subview_36 = memref.subview %alloca_31[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_36 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_37 = memref.subview %alloca_33[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + %75 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5) {map = #map22} : (memref, index, index, index, index) -> memref + %subview_38 = memref.subview %alloca_31[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_37, %75 : memref>, memref) outs(%subview_38 : memref>) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.mulf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %subview_39 = memref.subview %alloca_30[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%subview_39 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_40 = memref.subview %alloca_32[0, 0, 0] [%c2, %c5, %c4] [1, 1, 1] : memref<2x5x4xf64> to memref> + %76 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5) {map = #map22} : (memref, index, index, index, index) -> memref + %subview_41 = memref.subview %alloca_30[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%subview_40, %76 : memref>, memref) outs(%subview_41 : memref>) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.mulf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + %subview_42 = memref.subview %alloca_31[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + %subview_43 = memref.subview %alloca_30[0, 0, 0] [%c2, %c4, %c4] [1, 1, 1] : memref<2x4x4xf64> to memref> + %77 = polygeist.submap(%arg7, %c2, %c4, %c4) {map = #map26} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview_42, %subview_43 : memref>, memref>) outs(%77 : memref) { + ^bb0(%in: f64, %in_44: f64, %out: f64): + %78 = arith.addf %in, %in_44 : f64 + %79 = arith.addf %out, %78 : f64 + linalg.yield %79 : f64 + } + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pa_operators_3d.debufferized.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pa_operators_3d.debufferized.mlir new file mode 100644 index 000000000000..e8ab1cf358d2 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pa_operators_3d.debufferized.mlir @@ -0,0 +1,2789 @@ +#map = affine_map<(d0, d1) -> (d1 * 4 + d0)> +#map1 = affine_map<(d0, d1) -> (d1 + d0 * 5)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 192 + d1 * 16 + d2 * 4)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map14 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 125 + d1 * 25 + d2 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 192 + d1 * 16 + d2 * 4 + 64)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 192 + d1 * 16 + d2 * 4 + 128)> +#map21 = affine_map<(d0, d1, d2) -> (d2 + d0 * 2250 + d1 * 125)> +#map22 = affine_map<(d0, d1, d2) -> (d2 + d0 * 750 + d1 * 125)> +#map23 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map24 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 750)> +#map25 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 125)> +#map26 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 250)> +#map27 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 375)> +#map28 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 500)> +#map29 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 625)> +#map30 = affine_map<(d0, d1, d2) -> (d2 + d0 * 2250 + d1 * 125 + 750)> +#map31 = affine_map<(d0, d1, d2) -> (d2 + d0 * 2250 + d1 * 125 + 1500)> +#map32 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 125)> +#map33 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5)> +#map34 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 125)> +#map35 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 250)> +#map36 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d0 * 375 + d2 * 5)> +#map37 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 25 + d2 + d1 * 125 + d0 * 375 + d3 * 5)> +#map38 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 25 + d0 * 1125 + d3 * 5 + d1 * 125)> +#map39 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d0 * 375 + d2 * 5 + 125)> +#map40 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 25 + d0 * 1125 + d3 * 5 + d1 * 125 + 375)> +#map41 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d0 * 375 + d2 * 5 + 250)> +#map42 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 25 + d0 * 1125 + d3 * 5 + d1 * 125 + 750)> +#map43 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 25 + d0 * 375 + d3 * 5 + d1 * 125)> +#map44 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 * 125 + d4 + d2 * 25 + d0 * 375 + d3 * 5)> +#map45 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 * 125 + d4 + d2 * 25 + d1 * 375 + d0 * 1125 + d3 * 5)> +#map46 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 * 125 + d5 * 375 + d0 * 1125 + d2 * 25 + d4 + d3 * 5)> +#map47 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map48 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4)> +#map49 = affine_map<(d0, d1) -> (d1 + d0 * 375)> +#map50 = affine_map<(d0, d1) -> (d1 + d0 * 125)> +#map51 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 125)> +#map52 = affine_map<(d0, d1) -> (d1 + d0 * 375 + 125)> +#map53 = affine_map<(d0, d1) -> (d1 + d0 * 375 + 250)> +#map54 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d5 * 125 + d0 * 375 + d2 + d4 * 25 + d3 * 5)> +#map55 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d5 * 125 + d4 + d2 * 25 + d1 * 375 + d0 * 1125 + d3 * 5)> +#map56 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map57 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4)> +#map58 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d5 + d1 * 4)> +#map59 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4 * 375 + d3 + d1 * 25 + d0 * 1125 + d2 * 5)> +#map60 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4 * 375 + d0 * 1125 + d3 + d1 * 25 + d2 * 5 + 125)> +#map61 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4 * 375 + d0 * 1125 + d3 + d1 * 25 + d2 * 5 + 250)> +#map62 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d6 + d2 * 4)> +#map63 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d7 + d4 * 64 + d0 * 192 + d5 * 16 + d6 * 4)> +#map64 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d7 + d3 * 4)> +#map65 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map66 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +#map67 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 * 4 + d1)> +#map68 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 * 4 + d2)> +#map69 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 * 4 + d3)> +#map70 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +#map71 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_navier_tgv_pa_operators_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref, %arg11: memref, %arg12: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c125 = arith.constant 125 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = bufferization.to_tensor %arg5 : memref + %6 = bufferization.to_tensor %arg6 : memref + %7 = bufferization.to_tensor %arg7 : memref + %8 = bufferization.to_tensor %arg8 : memref + %9 = bufferization.to_tensor %arg9 : memref + %10 = bufferization.to_tensor %arg10 : memref + %11 = bufferization.to_tensor %arg11 : memref + %12 = bufferization.to_tensor %arg12 : memref + %13 = tensor.empty() : tensor<20xf64> + %14 = polygeist.submap(%0, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %15 = polygeist.submap(%13, %c4, %c5) {map = #map1} : (tensor<20xf64>, index, index) -> tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%14 : tensor) outs(%15 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %17 = polygeist.submapInverse(%13, %16, %c4, %c5) {map = #map1} : (tensor<20xf64>, tensor, index, index) -> tensor<20xf64> + %18 = tensor.empty() : tensor<128xf64> + %19 = tensor.empty() : tensor<128xf64> + %20 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %21 = polygeist.submap(%19, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%20 : tensor) outs(%21 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %23 = polygeist.submapInverse(%19, %22, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %24 = polygeist.submap(%11, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %25 = polygeist.submap(%18, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %26 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%24 : tensor) outs(%25 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %27 = polygeist.submapInverse(%18, %26, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %28 = tensor.empty() : tensor<2x5x4x4xf64> + %29 = tensor.empty() : tensor<2x5x5x4xf64> + %30 = tensor.empty() : tensor<2x5x5x5xf64> + %31 = tensor.empty() : tensor<2x4x5x5xf64> + %32 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice = tensor.extract_slice %32[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %33 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %33 into %32[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %34 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %35 = polygeist.submap(%23, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %36 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%34, %35 : tensor, tensor) outs(%inserted_slice : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_0 = tensor.extract_slice %31[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %37 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_0 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %38 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice_1 = tensor.extract_slice %36[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %39 = linalg.generic {doc = "", indexing_maps = [#map8, #map11, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%38, %extracted_slice_1 : tensor, tensor) outs(%37 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_2 = tensor.extract_slice %30[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %40 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_2 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %41 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %42 = linalg.generic {doc = "", indexing_maps = [#map8, #map13, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%41, %39 : tensor, tensor) outs(%40 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %43 = polygeist.submap(%5, %c2, %c5, %c5, %c5) {map = #map14} : (tensor, index, index, index, index) -> tensor + %44 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%43 : tensor) outs(%42 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.mulf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %extracted_slice_3 = tensor.extract_slice %29[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %45 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_3 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %46 = polygeist.submap(%17, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %47 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%46, %44 : tensor, tensor) outs(%45 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_4 = tensor.extract_slice %28[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %48 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_4 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %49 = polygeist.submap(%17, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %50 = linalg.generic {doc = "", indexing_maps = [#map8, #map11, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%49, %47 : tensor, tensor) outs(%48 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %51 = polygeist.submap(%17, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %52 = polygeist.submap(%27, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor<2x4x4x4xf64> + %53 = linalg.generic {doc = "", indexing_maps = [#map8, #map13, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%51, %50 : tensor, tensor) outs(%52 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x4xf64> + %54 = polygeist.submapInverse(%27, %53, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor<2x4x4x4xf64>, index, index, index, index) -> tensor<128xf64> + %55 = polygeist.submap(%54, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %56 = polygeist.submap(%11, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %57 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%55 : tensor) outs(%56 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %58 = polygeist.submapInverse(%11, %57, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, tensor, index, index, index, index) -> tensor + %59 = tensor.empty() : tensor<128xf64> + %60 = tensor.empty() : tensor<128xf64> + %61 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %62 = polygeist.submap(%60, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%61 : tensor) outs(%62 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %64 = polygeist.submapInverse(%60, %63, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %65 = polygeist.submap(%58, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %66 = polygeist.submap(%59, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %67 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%65 : tensor) outs(%66 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %68 = polygeist.submapInverse(%59, %67, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %69 = tensor.empty() : tensor<2x5x4x4xf64> + %70 = tensor.empty() : tensor<2x5x5x4xf64> + %71 = tensor.empty() : tensor<2x5x5x5xf64> + %72 = tensor.empty() : tensor<2x4x5x5xf64> + %73 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_5 = tensor.extract_slice %73[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %74 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_5 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_6 = tensor.insert_slice %74 into %73[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %75 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %76 = polygeist.submap(%64, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %77 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%75, %76 : tensor, tensor) outs(%inserted_slice_6 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_7 = tensor.extract_slice %72[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %78 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_7 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %79 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice_8 = tensor.extract_slice %77[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %80 = linalg.generic {doc = "", indexing_maps = [#map8, #map11, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%79, %extracted_slice_8 : tensor, tensor) outs(%78 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_9 = tensor.extract_slice %71[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %81 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_9 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %82 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %83 = linalg.generic {doc = "", indexing_maps = [#map8, #map13, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%82, %80 : tensor, tensor) outs(%81 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %84 = polygeist.submap(%5, %c2, %c5, %c5, %c5) {map = #map14} : (tensor, index, index, index, index) -> tensor + %85 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%84 : tensor) outs(%83 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.mulf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %extracted_slice_10 = tensor.extract_slice %70[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %86 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_10 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %87 = polygeist.submap(%17, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %88 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%87, %85 : tensor, tensor) outs(%86 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_11 = tensor.extract_slice %69[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %89 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_11 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %90 = polygeist.submap(%17, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %91 = linalg.generic {doc = "", indexing_maps = [#map8, #map11, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%90, %88 : tensor, tensor) outs(%89 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %92 = polygeist.submap(%17, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %93 = polygeist.submap(%68, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor<2x4x4x4xf64> + %94 = linalg.generic {doc = "", indexing_maps = [#map8, #map13, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%92, %91 : tensor, tensor) outs(%93 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x4xf64> + %95 = polygeist.submapInverse(%68, %94, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor<2x4x4x4xf64>, index, index, index, index) -> tensor<128xf64> + %96 = polygeist.submap(%95, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %97 = polygeist.submap(%58, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %98 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%96 : tensor) outs(%97 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %99 = polygeist.submapInverse(%58, %98, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %100 = tensor.empty() : tensor<128xf64> + %101 = tensor.empty() : tensor<128xf64> + %102 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %103 = polygeist.submap(%101, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %104 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%102 : tensor) outs(%103 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %105 = polygeist.submapInverse(%101, %104, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %106 = polygeist.submap(%99, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %107 = polygeist.submap(%100, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %108 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%106 : tensor) outs(%107 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %109 = polygeist.submapInverse(%100, %108, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %110 = tensor.empty() : tensor<2x5x4x4xf64> + %111 = tensor.empty() : tensor<2x5x5x4xf64> + %112 = tensor.empty() : tensor<2x5x5x5xf64> + %113 = tensor.empty() : tensor<2x4x5x5xf64> + %114 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_12 = tensor.extract_slice %114[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %115 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_12 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_13 = tensor.insert_slice %115 into %114[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %116 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %117 = polygeist.submap(%105, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %118 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%116, %117 : tensor, tensor) outs(%inserted_slice_13 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_14 = tensor.extract_slice %113[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %119 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_14 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %120 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice_15 = tensor.extract_slice %118[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %121 = linalg.generic {doc = "", indexing_maps = [#map8, #map11, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%120, %extracted_slice_15 : tensor, tensor) outs(%119 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_16 = tensor.extract_slice %112[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %122 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_16 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %123 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %124 = linalg.generic {doc = "", indexing_maps = [#map8, #map13, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%123, %121 : tensor, tensor) outs(%122 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %125 = polygeist.submap(%5, %c2, %c5, %c5, %c5) {map = #map14} : (tensor, index, index, index, index) -> tensor + %126 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%125 : tensor) outs(%124 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.mulf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %extracted_slice_17 = tensor.extract_slice %111[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %127 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_17 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %128 = polygeist.submap(%17, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %129 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%128, %126 : tensor, tensor) outs(%127 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_18 = tensor.extract_slice %110[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %130 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_18 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %131 = polygeist.submap(%17, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %132 = linalg.generic {doc = "", indexing_maps = [#map8, #map11, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%131, %129 : tensor, tensor) outs(%130 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %133 = polygeist.submap(%17, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %134 = polygeist.submap(%109, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor<2x4x4x4xf64> + %135 = linalg.generic {doc = "", indexing_maps = [#map8, #map13, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%133, %132 : tensor, tensor) outs(%134 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x4xf64> + %136 = polygeist.submapInverse(%109, %135, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor<2x4x4x4xf64>, index, index, index, index) -> tensor<128xf64> + %137 = polygeist.submap(%136, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %138 = polygeist.submap(%99, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %139 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%137 : tensor) outs(%138 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %140 = polygeist.submapInverse(%99, %139, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, tensor, index, index, index, index) -> tensor + %141 = tensor.empty() : tensor<20xf64> + %142 = tensor.empty() : tensor<20xf64> + %143 = polygeist.submap(%0, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %144 = polygeist.submap(%142, %c4, %c5) {map = #map1} : (tensor<20xf64>, index, index) -> tensor + %145 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%143 : tensor) outs(%144 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %146 = polygeist.submapInverse(%142, %145, %c4, %c5) {map = #map1} : (tensor<20xf64>, tensor, index, index) -> tensor<20xf64> + %147 = polygeist.submap(%1, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %148 = polygeist.submap(%141, %c4, %c5) {map = #map1} : (tensor<20xf64>, index, index) -> tensor + %149 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%147 : tensor) outs(%148 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %150 = polygeist.submapInverse(%141, %149, %c4, %c5) {map = #map1} : (tensor<20xf64>, tensor, index, index) -> tensor<20xf64> + %151 = tensor.empty() : tensor<128xf64> + %152 = tensor.empty() : tensor<128xf64> + %153 = tensor.empty() : tensor<1500xf64> + %154 = polygeist.submap(%6, %c2, %c6, %c125) {map = #map21} : (tensor, index, index, index) -> tensor + %155 = polygeist.submap(%153, %c2, %c6, %c125) {map = #map22} : (tensor<1500xf64>, index, index, index) -> tensor + %156 = linalg.generic {doc = "", indexing_maps = [#map23, #map23], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%154 : tensor) outs(%155 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %157 = polygeist.submapInverse(%153, %156, %c2, %c6, %c125) {map = #map22} : (tensor<1500xf64>, tensor, index, index, index) -> tensor<1500xf64> + %158 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %159 = polygeist.submap(%152, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %160 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%158 : tensor) outs(%159 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %161 = polygeist.submapInverse(%152, %160, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %162 = polygeist.submap(%140, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %163 = polygeist.submap(%151, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %164 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%162 : tensor) outs(%163 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %165 = polygeist.submapInverse(%151, %164, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %166 = tensor.empty() : tensor<2x4x4x4xf64> + %167 = tensor.empty() : tensor<2x4x4x4xf64> + %168 = tensor.empty() : tensor<2x4x4x4xf64> + %169 = tensor.empty() : tensor<2x5x4x4xf64> + %170 = tensor.empty() : tensor<2x5x4x4xf64> + %171 = tensor.empty() : tensor<2x5x4x4xf64> + %172 = tensor.empty() : tensor<2x5x5x4xf64> + %173 = tensor.empty() : tensor<2x5x5x4xf64> + %174 = tensor.empty() : tensor<2x5x5x4xf64> + %175 = tensor.empty() : tensor<2x5x5x5xf64> + %176 = tensor.empty() : tensor<2x5x5x5xf64> + %177 = tensor.empty() : tensor<2x5x5x5xf64> + %178 = tensor.empty() : tensor<2x4x5x5xf64> + %179 = tensor.empty() : tensor<2x4x5x5xf64> + %180 = tensor.empty() : tensor<2x4x5x5xf64> + %181 = tensor.empty() : tensor<2x4x4x5xf64> + %182 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_19 = tensor.extract_slice %182[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %183 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_19 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_20 = tensor.insert_slice %183 into %182[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %184 = polygeist.submap(%161, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %185 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %186 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%184, %185 : tensor, tensor) outs(%inserted_slice_20 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_21 = tensor.extract_slice %181[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %187 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_21 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_22 = tensor.insert_slice %187 into %181[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %188 = polygeist.submap(%161, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %189 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %190 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%188, %189 : tensor, tensor) outs(%inserted_slice_22 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_23 = tensor.extract_slice %180[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %191 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_23 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_24 = tensor.extract_slice %190[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %192 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %193 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_24, %192 : tensor, tensor) outs(%191 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_25 = tensor.extract_slice %179[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %194 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_25 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_26 = tensor.extract_slice %186[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %195 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %196 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_26, %195 : tensor, tensor) outs(%194 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_27 = tensor.extract_slice %178[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %197 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_27 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_28 = tensor.extract_slice %186[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %198 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %199 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_28, %198 : tensor, tensor) outs(%197 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_29 = tensor.extract_slice %177[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %200 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_29 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %201 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %202 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%193, %201 : tensor, tensor) outs(%200 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_30 = tensor.extract_slice %176[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %203 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_30 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %204 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %205 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%196, %204 : tensor, tensor) outs(%203 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_31 = tensor.extract_slice %175[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %206 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_31 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %207 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %208 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%199, %207 : tensor, tensor) outs(%206 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_32 = tensor.extract_slice %174[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %209 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_32 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %210 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map24} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %211 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %212 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %213 = polygeist.submap(%150, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %214 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%210, %202, %211, %205, %212, %208, %213 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%209 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_33 = tensor.extract_slice %173[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %215 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_33 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %216 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %217 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map27} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %218 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %219 = polygeist.submap(%146, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %220 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%216, %202, %217, %205, %218, %208, %219 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%215 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_34 = tensor.extract_slice %172[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %221 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_34 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %222 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %223 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %224 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map29} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %225 = polygeist.submap(%146, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %226 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%222, %202, %223, %205, %224, %208, %225 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%221 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_35 = tensor.extract_slice %171[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %227 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_35 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %228 = polygeist.submap(%146, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %229 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%214, %228 : tensor, tensor) outs(%227 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_36 = tensor.extract_slice %170[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %230 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_36 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %231 = polygeist.submap(%150, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %232 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%220, %231 : tensor, tensor) outs(%230 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_37 = tensor.extract_slice %169[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %233 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_37 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %234 = polygeist.submap(%146, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %235 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%226, %234 : tensor, tensor) outs(%233 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_38 = tensor.extract_slice %168[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %236 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_38 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %237 = polygeist.submap(%146, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %238 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%229, %237 : tensor, tensor) outs(%236 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_39 = tensor.extract_slice %167[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %239 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_39 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %240 = polygeist.submap(%146, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %241 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%232, %240 : tensor, tensor) outs(%239 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_40 = tensor.extract_slice %166[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %242 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_40 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %243 = polygeist.submap(%150, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %244 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%235, %243 : tensor, tensor) outs(%242 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %245 = polygeist.submap(%165, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %246 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%238, %241, %244 : tensor, tensor, tensor) outs(%245 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %out: f64): + %1034 = arith.addf %in, %in_192 : f64 + %1035 = arith.addf %1034, %in_193 : f64 + %1036 = arith.addf %out, %1035 : f64 + linalg.yield %1036 : f64 + } -> tensor + %247 = polygeist.submapInverse(%165, %246, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %248 = polygeist.submap(%247, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %249 = polygeist.submap(%140, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %250 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%248 : tensor) outs(%249 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %251 = polygeist.submapInverse(%140, %250, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, tensor, index, index, index, index) -> tensor + %252 = tensor.empty() : tensor<128xf64> + %253 = tensor.empty() : tensor<128xf64> + %254 = tensor.empty() : tensor<1500xf64> + %255 = polygeist.submap(%6, %c2, %c6, %c125) {map = #map30} : (tensor, index, index, index) -> tensor + %256 = polygeist.submap(%254, %c2, %c6, %c125) {map = #map22} : (tensor<1500xf64>, index, index, index) -> tensor + %257 = linalg.generic {doc = "", indexing_maps = [#map23, #map23], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%255 : tensor) outs(%256 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %258 = polygeist.submapInverse(%254, %257, %c2, %c6, %c125) {map = #map22} : (tensor<1500xf64>, tensor, index, index, index) -> tensor<1500xf64> + %259 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %260 = polygeist.submap(%253, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %261 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%259 : tensor) outs(%260 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %262 = polygeist.submapInverse(%253, %261, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %263 = polygeist.submap(%251, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %264 = polygeist.submap(%252, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %265 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%263 : tensor) outs(%264 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %266 = polygeist.submapInverse(%252, %265, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %267 = tensor.empty() : tensor<2x4x4x4xf64> + %268 = tensor.empty() : tensor<2x4x4x4xf64> + %269 = tensor.empty() : tensor<2x4x4x4xf64> + %270 = tensor.empty() : tensor<2x5x4x4xf64> + %271 = tensor.empty() : tensor<2x5x4x4xf64> + %272 = tensor.empty() : tensor<2x5x4x4xf64> + %273 = tensor.empty() : tensor<2x5x5x4xf64> + %274 = tensor.empty() : tensor<2x5x5x4xf64> + %275 = tensor.empty() : tensor<2x5x5x4xf64> + %276 = tensor.empty() : tensor<2x5x5x5xf64> + %277 = tensor.empty() : tensor<2x5x5x5xf64> + %278 = tensor.empty() : tensor<2x5x5x5xf64> + %279 = tensor.empty() : tensor<2x4x5x5xf64> + %280 = tensor.empty() : tensor<2x4x5x5xf64> + %281 = tensor.empty() : tensor<2x4x5x5xf64> + %282 = tensor.empty() : tensor<2x4x4x5xf64> + %283 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_41 = tensor.extract_slice %283[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %284 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_41 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_42 = tensor.insert_slice %284 into %283[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %285 = polygeist.submap(%262, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %286 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %287 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%285, %286 : tensor, tensor) outs(%inserted_slice_42 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_43 = tensor.extract_slice %282[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %288 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_43 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_44 = tensor.insert_slice %288 into %282[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %289 = polygeist.submap(%262, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %290 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %291 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%289, %290 : tensor, tensor) outs(%inserted_slice_44 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_45 = tensor.extract_slice %281[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %292 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_45 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_46 = tensor.extract_slice %291[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %293 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %294 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_46, %293 : tensor, tensor) outs(%292 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_47 = tensor.extract_slice %280[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %295 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_47 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_48 = tensor.extract_slice %287[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %296 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %297 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_48, %296 : tensor, tensor) outs(%295 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_49 = tensor.extract_slice %279[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %298 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_49 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_50 = tensor.extract_slice %287[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %299 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %300 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_50, %299 : tensor, tensor) outs(%298 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_51 = tensor.extract_slice %278[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %301 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_51 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %302 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %303 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%294, %302 : tensor, tensor) outs(%301 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_52 = tensor.extract_slice %277[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %304 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_52 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %305 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %306 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%297, %305 : tensor, tensor) outs(%304 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_53 = tensor.extract_slice %276[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %307 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_53 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %308 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %309 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%300, %308 : tensor, tensor) outs(%307 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_54 = tensor.extract_slice %275[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %310 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_54 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %311 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map24} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %312 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %313 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %314 = polygeist.submap(%150, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %315 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%311, %303, %312, %306, %313, %309, %314 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%310 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_55 = tensor.extract_slice %274[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %316 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_55 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %317 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %318 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map27} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %319 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %320 = polygeist.submap(%146, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %321 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%317, %303, %318, %306, %319, %309, %320 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%316 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_56 = tensor.extract_slice %273[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %322 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_56 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %323 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %324 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %325 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map29} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %326 = polygeist.submap(%146, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %327 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%323, %303, %324, %306, %325, %309, %326 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%322 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_57 = tensor.extract_slice %272[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %328 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_57 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %329 = polygeist.submap(%146, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %330 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%315, %329 : tensor, tensor) outs(%328 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_58 = tensor.extract_slice %271[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %331 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_58 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %332 = polygeist.submap(%150, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %333 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%321, %332 : tensor, tensor) outs(%331 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_59 = tensor.extract_slice %270[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %334 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_59 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %335 = polygeist.submap(%146, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %336 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%327, %335 : tensor, tensor) outs(%334 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_60 = tensor.extract_slice %269[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %337 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_60 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %338 = polygeist.submap(%146, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %339 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%330, %338 : tensor, tensor) outs(%337 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_61 = tensor.extract_slice %268[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %340 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_61 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %341 = polygeist.submap(%146, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %342 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%333, %341 : tensor, tensor) outs(%340 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_62 = tensor.extract_slice %267[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %343 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_62 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %344 = polygeist.submap(%150, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %345 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%336, %344 : tensor, tensor) outs(%343 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %346 = polygeist.submap(%266, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %347 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%339, %342, %345 : tensor, tensor, tensor) outs(%346 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %out: f64): + %1034 = arith.addf %in, %in_192 : f64 + %1035 = arith.addf %1034, %in_193 : f64 + %1036 = arith.addf %out, %1035 : f64 + linalg.yield %1036 : f64 + } -> tensor + %348 = polygeist.submapInverse(%266, %347, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %349 = polygeist.submap(%348, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %350 = polygeist.submap(%251, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %351 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%349 : tensor) outs(%350 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %352 = polygeist.submapInverse(%251, %351, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %353 = tensor.empty() : tensor<128xf64> + %354 = tensor.empty() : tensor<128xf64> + %355 = tensor.empty() : tensor<1500xf64> + %356 = polygeist.submap(%6, %c2, %c6, %c125) {map = #map31} : (tensor, index, index, index) -> tensor + %357 = polygeist.submap(%355, %c2, %c6, %c125) {map = #map22} : (tensor<1500xf64>, index, index, index) -> tensor + %358 = linalg.generic {doc = "", indexing_maps = [#map23, #map23], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%356 : tensor) outs(%357 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %359 = polygeist.submapInverse(%355, %358, %c2, %c6, %c125) {map = #map22} : (tensor<1500xf64>, tensor, index, index, index) -> tensor<1500xf64> + %360 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %361 = polygeist.submap(%354, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %362 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%360 : tensor) outs(%361 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %363 = polygeist.submapInverse(%354, %362, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %364 = polygeist.submap(%352, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %365 = polygeist.submap(%353, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %366 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%364 : tensor) outs(%365 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %367 = polygeist.submapInverse(%353, %366, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %368 = tensor.empty() : tensor<2x4x4x4xf64> + %369 = tensor.empty() : tensor<2x4x4x4xf64> + %370 = tensor.empty() : tensor<2x4x4x4xf64> + %371 = tensor.empty() : tensor<2x5x4x4xf64> + %372 = tensor.empty() : tensor<2x5x4x4xf64> + %373 = tensor.empty() : tensor<2x5x4x4xf64> + %374 = tensor.empty() : tensor<2x5x5x4xf64> + %375 = tensor.empty() : tensor<2x5x5x4xf64> + %376 = tensor.empty() : tensor<2x5x5x4xf64> + %377 = tensor.empty() : tensor<2x5x5x5xf64> + %378 = tensor.empty() : tensor<2x5x5x5xf64> + %379 = tensor.empty() : tensor<2x5x5x5xf64> + %380 = tensor.empty() : tensor<2x4x5x5xf64> + %381 = tensor.empty() : tensor<2x4x5x5xf64> + %382 = tensor.empty() : tensor<2x4x5x5xf64> + %383 = tensor.empty() : tensor<2x4x4x5xf64> + %384 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_63 = tensor.extract_slice %384[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %385 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_63 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_64 = tensor.insert_slice %385 into %384[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %386 = polygeist.submap(%363, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %387 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %388 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%386, %387 : tensor, tensor) outs(%inserted_slice_64 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_65 = tensor.extract_slice %383[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %389 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_65 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_66 = tensor.insert_slice %389 into %383[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %390 = polygeist.submap(%363, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %391 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %392 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%390, %391 : tensor, tensor) outs(%inserted_slice_66 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_67 = tensor.extract_slice %382[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %393 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_67 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_68 = tensor.extract_slice %392[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %394 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %395 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_68, %394 : tensor, tensor) outs(%393 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_69 = tensor.extract_slice %381[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %396 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_69 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_70 = tensor.extract_slice %388[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %397 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %398 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_70, %397 : tensor, tensor) outs(%396 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_71 = tensor.extract_slice %380[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %399 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_71 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_72 = tensor.extract_slice %388[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %400 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %401 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_72, %400 : tensor, tensor) outs(%399 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_73 = tensor.extract_slice %379[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %402 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_73 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %403 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %404 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%395, %403 : tensor, tensor) outs(%402 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_74 = tensor.extract_slice %378[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %405 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_74 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %406 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %407 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%398, %406 : tensor, tensor) outs(%405 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_75 = tensor.extract_slice %377[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %408 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_75 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %409 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %410 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%401, %409 : tensor, tensor) outs(%408 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_76 = tensor.extract_slice %376[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %411 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_76 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %412 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map24} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %413 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %414 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %415 = polygeist.submap(%150, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %416 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%412, %404, %413, %407, %414, %410, %415 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%411 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_77 = tensor.extract_slice %375[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %417 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_77 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %418 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %419 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map27} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %420 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %421 = polygeist.submap(%146, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %422 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%418, %404, %419, %407, %420, %410, %421 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%417 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_78 = tensor.extract_slice %374[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %423 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_78 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %424 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %425 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %426 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map29} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %427 = polygeist.submap(%146, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %428 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%424, %404, %425, %407, %426, %410, %427 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%423 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_79 = tensor.extract_slice %373[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %429 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_79 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %430 = polygeist.submap(%146, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %431 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%416, %430 : tensor, tensor) outs(%429 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_80 = tensor.extract_slice %372[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %432 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_80 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %433 = polygeist.submap(%150, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %434 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%422, %433 : tensor, tensor) outs(%432 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_81 = tensor.extract_slice %371[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %435 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_81 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %436 = polygeist.submap(%146, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %437 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%428, %436 : tensor, tensor) outs(%435 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_82 = tensor.extract_slice %370[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %438 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_82 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %439 = polygeist.submap(%146, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %440 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%431, %439 : tensor, tensor) outs(%438 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_83 = tensor.extract_slice %369[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %441 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_83 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %442 = polygeist.submap(%146, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %443 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%434, %442 : tensor, tensor) outs(%441 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_84 = tensor.extract_slice %368[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %444 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_84 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %445 = polygeist.submap(%150, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %446 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%437, %445 : tensor, tensor) outs(%444 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %447 = polygeist.submap(%367, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %448 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%440, %443, %446 : tensor, tensor, tensor) outs(%447 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %out: f64): + %1034 = arith.addf %in, %in_192 : f64 + %1035 = arith.addf %1034, %in_193 : f64 + %1036 = arith.addf %out, %1035 : f64 + linalg.yield %1036 : f64 + } -> tensor + %449 = polygeist.submapInverse(%367, %448, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %450 = polygeist.submap(%449, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %451 = polygeist.submap(%352, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %452 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%450 : tensor) outs(%451 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %453 = polygeist.submapInverse(%352, %452, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, tensor, index, index, index, index) -> tensor + %454 = tensor.empty() : tensor<750xf64> + %455 = tensor.empty() : tensor<2250xf64> + %456 = tensor.empty() : tensor<750xf64> + %457 = tensor.empty() : tensor<20xf64> + %458 = polygeist.submap(%0, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %459 = polygeist.submap(%457, %c4, %c5) {map = #map1} : (tensor<20xf64>, index, index) -> tensor + %460 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%458 : tensor) outs(%459 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %461 = polygeist.submapInverse(%457, %460, %c4, %c5) {map = #map1} : (tensor<20xf64>, tensor, index, index) -> tensor<20xf64> + %462 = tensor.empty() : tensor<750xf64> + %463 = tensor.empty() : tensor<250xf64> + %464 = tensor.empty() : tensor<128xf64> + %465 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %466 = polygeist.submap(%464, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %467 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%465 : tensor) outs(%466 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %468 = polygeist.submapInverse(%464, %467, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %469 = tensor.empty() : tensor<2x4x5x5xf64> + %470 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_85 = tensor.extract_slice %470[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %471 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_85 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_86 = tensor.insert_slice %471 into %470[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %472 = polygeist.submap(%468, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %473 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %474 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%472, %473 : tensor, tensor) outs(%inserted_slice_86 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_87 = tensor.extract_slice %469[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %475 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_87 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_88 = tensor.extract_slice %474[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %476 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %477 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_88, %476 : tensor, tensor) outs(%475 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %478 = polygeist.submap(%463, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor + %479 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%478 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %480 = polygeist.submapInverse(%463, %479, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, tensor, index, index, index, index) -> tensor<250xf64> + %481 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %482 = polygeist.submap(%480, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %483 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%477, %481 : tensor, tensor) outs(%482 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x5xf64> + %484 = polygeist.submapInverse(%480, %483, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<250xf64> + %485 = tensor.empty() : tensor<2x4x5x5xf64> + %486 = tensor.empty() : tensor<2x4x5x5xf64> + %487 = tensor.empty() : tensor<2x4x5x5xf64> + %488 = tensor.empty() : tensor<2x4x4x5xf64> + %489 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_89 = tensor.extract_slice %489[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %490 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_89 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_90 = tensor.insert_slice %490 into %489[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %491 = polygeist.submap(%468, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %492 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %493 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%491, %492 : tensor, tensor) outs(%inserted_slice_90 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_91 = tensor.extract_slice %488[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %494 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_91 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_92 = tensor.insert_slice %494 into %488[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %495 = polygeist.submap(%468, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %496 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %497 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%495, %496 : tensor, tensor) outs(%inserted_slice_92 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_93 = tensor.extract_slice %487[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %498 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_93 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_94 = tensor.extract_slice %497[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %499 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %500 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_94, %499 : tensor, tensor) outs(%498 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_95 = tensor.extract_slice %486[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %501 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_95 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_96 = tensor.extract_slice %493[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %502 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %503 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_96, %502 : tensor, tensor) outs(%501 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_97 = tensor.extract_slice %485[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %504 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_97 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_98 = tensor.extract_slice %493[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %505 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %506 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_98, %505 : tensor, tensor) outs(%504 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %507 = polygeist.submap(%462, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, index, index, index, index) -> tensor + %508 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%507 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %509 = polygeist.submapInverse(%462, %508, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %510 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %511 = polygeist.submap(%509, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %512 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%500, %510 : tensor, tensor) outs(%511 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x5xf64> + %513 = polygeist.submapInverse(%509, %512, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %514 = polygeist.submap(%513, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, index, index, index, index) -> tensor + %515 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%514 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %516 = polygeist.submapInverse(%513, %515, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %517 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %518 = polygeist.submap(%516, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %519 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%503, %517 : tensor, tensor) outs(%518 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x5xf64> + %520 = polygeist.submapInverse(%516, %519, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %521 = polygeist.submap(%520, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, index, index, index, index) -> tensor + %522 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%521 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %523 = polygeist.submapInverse(%520, %522, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %524 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %525 = polygeist.submap(%523, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %526 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%506, %524 : tensor, tensor) outs(%525 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x5xf64> + %527 = polygeist.submapInverse(%523, %526, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %528 = polygeist.submap(%484, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor + %529 = polygeist.submap(%456, %c2, %c5, %c5, %c5) {map = #map36} : (tensor<750xf64>, index, index, index, index) -> tensor + %530 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%528 : tensor) outs(%529 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %531 = polygeist.submapInverse(%456, %530, %c2, %c5, %c5, %c5) {map = #map36} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %532 = polygeist.submap(%527, %c2, %c3, %c5, %c5, %c5) {map = #map37} : (tensor<750xf64>, index, index, index, index, index) -> tensor + %533 = polygeist.submap(%455, %c2, %c3, %c5, %c5, %c5) {map = #map38} : (tensor<2250xf64>, index, index, index, index, index) -> tensor + %534 = linalg.generic {doc = "", indexing_maps = [#map8, #map8], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%532 : tensor) outs(%533 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %535 = polygeist.submapInverse(%455, %534, %c2, %c3, %c5, %c5, %c5) {map = #map38} : (tensor<2250xf64>, tensor, index, index, index, index, index) -> tensor<2250xf64> + %536 = tensor.empty() : tensor<750xf64> + %537 = tensor.empty() : tensor<250xf64> + %538 = tensor.empty() : tensor<128xf64> + %539 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %540 = polygeist.submap(%538, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %541 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%539 : tensor) outs(%540 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %542 = polygeist.submapInverse(%538, %541, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %543 = tensor.empty() : tensor<2x4x5x5xf64> + %544 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_99 = tensor.extract_slice %544[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %545 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_99 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_100 = tensor.insert_slice %545 into %544[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %546 = polygeist.submap(%542, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %547 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %548 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%546, %547 : tensor, tensor) outs(%inserted_slice_100 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_101 = tensor.extract_slice %543[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %549 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_101 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_102 = tensor.extract_slice %548[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %550 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %551 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_102, %550 : tensor, tensor) outs(%549 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %552 = polygeist.submap(%537, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor + %553 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%552 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %554 = polygeist.submapInverse(%537, %553, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, tensor, index, index, index, index) -> tensor<250xf64> + %555 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %556 = polygeist.submap(%554, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %557 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%551, %555 : tensor, tensor) outs(%556 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x5xf64> + %558 = polygeist.submapInverse(%554, %557, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<250xf64> + %559 = tensor.empty() : tensor<2x4x5x5xf64> + %560 = tensor.empty() : tensor<2x4x5x5xf64> + %561 = tensor.empty() : tensor<2x4x5x5xf64> + %562 = tensor.empty() : tensor<2x4x4x5xf64> + %563 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_103 = tensor.extract_slice %563[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %564 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_103 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_104 = tensor.insert_slice %564 into %563[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %565 = polygeist.submap(%542, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %566 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %567 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%565, %566 : tensor, tensor) outs(%inserted_slice_104 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_105 = tensor.extract_slice %562[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %568 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_105 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_106 = tensor.insert_slice %568 into %562[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %569 = polygeist.submap(%542, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %570 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %571 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%569, %570 : tensor, tensor) outs(%inserted_slice_106 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_107 = tensor.extract_slice %561[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %572 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_107 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_108 = tensor.extract_slice %571[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %573 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %574 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_108, %573 : tensor, tensor) outs(%572 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_109 = tensor.extract_slice %560[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %575 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_109 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_110 = tensor.extract_slice %567[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %576 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %577 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_110, %576 : tensor, tensor) outs(%575 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_111 = tensor.extract_slice %559[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %578 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_111 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_112 = tensor.extract_slice %567[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %579 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %580 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_112, %579 : tensor, tensor) outs(%578 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %581 = polygeist.submap(%536, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, index, index, index, index) -> tensor + %582 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%581 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %583 = polygeist.submapInverse(%536, %582, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %584 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %585 = polygeist.submap(%583, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %586 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%574, %584 : tensor, tensor) outs(%585 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x5xf64> + %587 = polygeist.submapInverse(%583, %586, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %588 = polygeist.submap(%587, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, index, index, index, index) -> tensor + %589 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%588 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %590 = polygeist.submapInverse(%587, %589, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %591 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %592 = polygeist.submap(%590, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %593 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%577, %591 : tensor, tensor) outs(%592 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x5xf64> + %594 = polygeist.submapInverse(%590, %593, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %595 = polygeist.submap(%594, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, index, index, index, index) -> tensor + %596 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%595 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %597 = polygeist.submapInverse(%594, %596, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %598 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %599 = polygeist.submap(%597, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %600 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%580, %598 : tensor, tensor) outs(%599 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x5xf64> + %601 = polygeist.submapInverse(%597, %600, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %602 = polygeist.submap(%558, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor + %603 = polygeist.submap(%531, %c2, %c5, %c5, %c5) {map = #map39} : (tensor<750xf64>, index, index, index, index) -> tensor + %604 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%602 : tensor) outs(%603 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %605 = polygeist.submapInverse(%531, %604, %c2, %c5, %c5, %c5) {map = #map39} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %606 = polygeist.submap(%601, %c2, %c3, %c5, %c5, %c5) {map = #map37} : (tensor<750xf64>, index, index, index, index, index) -> tensor + %607 = polygeist.submap(%535, %c2, %c3, %c5, %c5, %c5) {map = #map40} : (tensor<2250xf64>, index, index, index, index, index) -> tensor + %608 = linalg.generic {doc = "", indexing_maps = [#map8, #map8], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%606 : tensor) outs(%607 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %609 = polygeist.submapInverse(%535, %608, %c2, %c3, %c5, %c5, %c5) {map = #map40} : (tensor<2250xf64>, tensor, index, index, index, index, index) -> tensor<2250xf64> + %610 = tensor.empty() : tensor<750xf64> + %611 = tensor.empty() : tensor<250xf64> + %612 = tensor.empty() : tensor<128xf64> + %613 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %614 = polygeist.submap(%612, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %615 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%613 : tensor) outs(%614 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %616 = polygeist.submapInverse(%612, %615, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %617 = tensor.empty() : tensor<2x4x5x5xf64> + %618 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_113 = tensor.extract_slice %618[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %619 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_113 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_114 = tensor.insert_slice %619 into %618[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %620 = polygeist.submap(%616, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %621 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %622 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%620, %621 : tensor, tensor) outs(%inserted_slice_114 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_115 = tensor.extract_slice %617[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %623 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_115 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_116 = tensor.extract_slice %622[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %624 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %625 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_116, %624 : tensor, tensor) outs(%623 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %626 = polygeist.submap(%611, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor + %627 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%626 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %628 = polygeist.submapInverse(%611, %627, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, tensor, index, index, index, index) -> tensor<250xf64> + %629 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %630 = polygeist.submap(%628, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %631 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%625, %629 : tensor, tensor) outs(%630 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x5xf64> + %632 = polygeist.submapInverse(%628, %631, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<250xf64> + %633 = tensor.empty() : tensor<2x4x5x5xf64> + %634 = tensor.empty() : tensor<2x4x5x5xf64> + %635 = tensor.empty() : tensor<2x4x5x5xf64> + %636 = tensor.empty() : tensor<2x4x4x5xf64> + %637 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_117 = tensor.extract_slice %637[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %638 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_117 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_118 = tensor.insert_slice %638 into %637[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %639 = polygeist.submap(%616, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %640 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %641 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%639, %640 : tensor, tensor) outs(%inserted_slice_118 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_119 = tensor.extract_slice %636[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %642 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_119 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_120 = tensor.insert_slice %642 into %636[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %643 = polygeist.submap(%616, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %644 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %645 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%643, %644 : tensor, tensor) outs(%inserted_slice_120 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_121 = tensor.extract_slice %635[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %646 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_121 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_122 = tensor.extract_slice %645[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %647 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %648 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_122, %647 : tensor, tensor) outs(%646 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_123 = tensor.extract_slice %634[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %649 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_123 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_124 = tensor.extract_slice %641[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %650 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %651 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_124, %650 : tensor, tensor) outs(%649 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_125 = tensor.extract_slice %633[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %652 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_125 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_126 = tensor.extract_slice %641[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %653 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %654 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_126, %653 : tensor, tensor) outs(%652 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %655 = polygeist.submap(%610, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, index, index, index, index) -> tensor + %656 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%655 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %657 = polygeist.submapInverse(%610, %656, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %658 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %659 = polygeist.submap(%657, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %660 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%648, %658 : tensor, tensor) outs(%659 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x5xf64> + %661 = polygeist.submapInverse(%657, %660, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %662 = polygeist.submap(%661, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, index, index, index, index) -> tensor + %663 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%662 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %664 = polygeist.submapInverse(%661, %663, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %665 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %666 = polygeist.submap(%664, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %667 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%651, %665 : tensor, tensor) outs(%666 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x5xf64> + %668 = polygeist.submapInverse(%664, %667, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %669 = polygeist.submap(%668, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, index, index, index, index) -> tensor + %670 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%669 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %671 = polygeist.submapInverse(%668, %670, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %672 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %673 = polygeist.submap(%671, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %674 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%654, %672 : tensor, tensor) outs(%673 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x5xf64> + %675 = polygeist.submapInverse(%671, %674, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %676 = polygeist.submap(%632, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor + %677 = polygeist.submap(%605, %c2, %c5, %c5, %c5) {map = #map41} : (tensor<750xf64>, index, index, index, index) -> tensor + %678 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%676 : tensor) outs(%677 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %679 = polygeist.submapInverse(%605, %678, %c2, %c5, %c5, %c5) {map = #map41} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %680 = polygeist.submap(%675, %c2, %c3, %c5, %c5, %c5) {map = #map37} : (tensor<750xf64>, index, index, index, index, index) -> tensor + %681 = polygeist.submap(%609, %c2, %c3, %c5, %c5, %c5) {map = #map42} : (tensor<2250xf64>, index, index, index, index, index) -> tensor + %682 = linalg.generic {doc = "", indexing_maps = [#map8, #map8], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%680 : tensor) outs(%681 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %683 = polygeist.submapInverse(%609, %682, %c2, %c3, %c5, %c5, %c5) {map = #map42} : (tensor<2250xf64>, tensor, index, index, index, index, index) -> tensor<2250xf64> + %684 = polygeist.submap(%454, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (tensor<750xf64>, index, index, index, index, index) -> tensor + %685 = linalg.generic {doc = "", indexing_maps = [#map8], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%684 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %686 = polygeist.submapInverse(%454, %685, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (tensor<750xf64>, tensor, index, index, index, index, index) -> tensor<750xf64> + %687 = polygeist.submap(%679, %c2, %c3, %c5, %c5, %c5, %c3, %c3) {map = #map44} : (tensor<750xf64>, index, index, index, index, index, index, index) -> tensor + %688 = polygeist.submap(%683, %c2, %c3, %c5, %c5, %c5, %c3, %c3) {map = #map45} : (tensor<2250xf64>, index, index, index, index, index, index, index) -> tensor + %689 = polygeist.submap(%7, %c2, %c3, %c5, %c5, %c5, %c3, %c3) {map = #map46} : (tensor, index, index, index, index, index, index, index) -> tensor + %690 = polygeist.submap(%686, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (tensor<750xf64>, index, index, index, index, index) -> tensor<2x3x5x5x5xf64> + %691 = linalg.generic {doc = "", indexing_maps = [#map47, #map47, #map47, #map48], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%687, %688, %689 : tensor, tensor, tensor) outs(%690 : tensor<2x3x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %1034, %in_193 : f64 + %1036 = arith.addf %out, %1035 : f64 + linalg.yield %1036 : f64 + } -> tensor<2x3x5x5x5xf64> + %692 = polygeist.submapInverse(%686, %691, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (tensor<750xf64>, tensor<2x3x5x5x5xf64>, index, index, index, index, index) -> tensor<750xf64> + %693 = tensor.empty() : tensor<128xf64> + %694 = tensor.empty() : tensor<250xf64> + %695 = polygeist.submap(%692, %c2, %c125) {map = #map49} : (tensor<750xf64>, index, index) -> tensor + %696 = polygeist.submap(%694, %c2, %c125) {map = #map50} : (tensor<250xf64>, index, index) -> tensor + %697 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%695 : tensor) outs(%696 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %698 = polygeist.submapInverse(%694, %697, %c2, %c125) {map = #map50} : (tensor<250xf64>, tensor, index, index) -> tensor<250xf64> + %699 = polygeist.submap(%453, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %700 = polygeist.submap(%693, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %701 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%699 : tensor) outs(%700 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %702 = polygeist.submapInverse(%693, %701, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %703 = tensor.empty() : tensor<2x4x4x4xf64> + %704 = tensor.empty() : tensor<2x5x4x4xf64> + %705 = tensor.empty() : tensor<2x5x5x4xf64> + %extracted_slice_127 = tensor.extract_slice %705[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %706 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_127 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_128 = tensor.insert_slice %706 into %705[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor into tensor<2x5x5x4xf64> + %707 = polygeist.submap(%698, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (tensor<250xf64>, index, index, index, index, index) -> tensor + %708 = polygeist.submap(%461, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %709 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%707, %708 : tensor, tensor) outs(%inserted_slice_128 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x4xf64> + %extracted_slice_129 = tensor.extract_slice %704[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %710 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_129 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_130 = tensor.extract_slice %709[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %711 = polygeist.submap(%461, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %712 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_130, %711 : tensor, tensor) outs(%710 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_131 = tensor.extract_slice %703[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %713 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_131 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %714 = polygeist.submap(%461, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %715 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%712, %714 : tensor, tensor) outs(%713 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %716 = polygeist.submap(%702, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %717 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%715 : tensor) outs(%716 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.addf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %718 = polygeist.submapInverse(%702, %717, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %719 = polygeist.submap(%718, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %720 = polygeist.submap(%453, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %721 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%719 : tensor) outs(%720 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %722 = polygeist.submapInverse(%453, %721, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, tensor, index, index, index, index) -> tensor + %723 = tensor.empty() : tensor<128xf64> + %724 = tensor.empty() : tensor<250xf64> + %725 = polygeist.submap(%692, %c2, %c125) {map = #map52} : (tensor<750xf64>, index, index) -> tensor + %726 = polygeist.submap(%724, %c2, %c125) {map = #map50} : (tensor<250xf64>, index, index) -> tensor + %727 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%725 : tensor) outs(%726 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %728 = polygeist.submapInverse(%724, %727, %c2, %c125) {map = #map50} : (tensor<250xf64>, tensor, index, index) -> tensor<250xf64> + %729 = polygeist.submap(%722, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %730 = polygeist.submap(%723, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %731 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%729 : tensor) outs(%730 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %732 = polygeist.submapInverse(%723, %731, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %733 = tensor.empty() : tensor<2x4x4x4xf64> + %734 = tensor.empty() : tensor<2x5x4x4xf64> + %735 = tensor.empty() : tensor<2x5x5x4xf64> + %extracted_slice_132 = tensor.extract_slice %735[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %736 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_132 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_133 = tensor.insert_slice %736 into %735[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor into tensor<2x5x5x4xf64> + %737 = polygeist.submap(%728, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (tensor<250xf64>, index, index, index, index, index) -> tensor + %738 = polygeist.submap(%461, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %739 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%737, %738 : tensor, tensor) outs(%inserted_slice_133 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x4xf64> + %extracted_slice_134 = tensor.extract_slice %734[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %740 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_134 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_135 = tensor.extract_slice %739[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %741 = polygeist.submap(%461, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %742 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_135, %741 : tensor, tensor) outs(%740 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_136 = tensor.extract_slice %733[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %743 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_136 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %744 = polygeist.submap(%461, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %745 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%742, %744 : tensor, tensor) outs(%743 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %746 = polygeist.submap(%732, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %747 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%745 : tensor) outs(%746 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.addf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %748 = polygeist.submapInverse(%732, %747, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %749 = polygeist.submap(%748, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %750 = polygeist.submap(%722, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %751 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%749 : tensor) outs(%750 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %752 = polygeist.submapInverse(%722, %751, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %753 = tensor.empty() : tensor<128xf64> + %754 = tensor.empty() : tensor<250xf64> + %755 = polygeist.submap(%692, %c2, %c125) {map = #map53} : (tensor<750xf64>, index, index) -> tensor + %756 = polygeist.submap(%754, %c2, %c125) {map = #map50} : (tensor<250xf64>, index, index) -> tensor + %757 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%755 : tensor) outs(%756 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %758 = polygeist.submapInverse(%754, %757, %c2, %c125) {map = #map50} : (tensor<250xf64>, tensor, index, index) -> tensor<250xf64> + %759 = polygeist.submap(%752, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %760 = polygeist.submap(%753, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %761 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%759 : tensor) outs(%760 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %762 = polygeist.submapInverse(%753, %761, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %763 = tensor.empty() : tensor<2x4x4x4xf64> + %764 = tensor.empty() : tensor<2x5x4x4xf64> + %765 = tensor.empty() : tensor<2x5x5x4xf64> + %extracted_slice_137 = tensor.extract_slice %765[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %766 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_137 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_138 = tensor.insert_slice %766 into %765[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor into tensor<2x5x5x4xf64> + %767 = polygeist.submap(%758, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (tensor<250xf64>, index, index, index, index, index) -> tensor + %768 = polygeist.submap(%461, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %769 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%767, %768 : tensor, tensor) outs(%inserted_slice_138 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x4xf64> + %extracted_slice_139 = tensor.extract_slice %764[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %770 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_139 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_140 = tensor.extract_slice %769[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %771 = polygeist.submap(%461, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %772 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_140, %771 : tensor, tensor) outs(%770 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_141 = tensor.extract_slice %763[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %773 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_141 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %774 = polygeist.submap(%461, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %775 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%772, %774 : tensor, tensor) outs(%773 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %776 = polygeist.submap(%762, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %777 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%775 : tensor) outs(%776 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.addf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %778 = polygeist.submapInverse(%762, %777, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %779 = polygeist.submap(%778, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %780 = polygeist.submap(%752, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %781 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%779 : tensor) outs(%780 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %782 = polygeist.submapInverse(%752, %781, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, tensor, index, index, index, index) -> tensor + %783 = tensor.empty() : tensor<2x4x4x4xf64> + %784 = tensor.empty() : tensor<2x4x4x4xf64> + %785 = tensor.empty() : tensor<2x4x4x4xf64> + %786 = tensor.empty() : tensor<2x5x4x4xf64> + %787 = tensor.empty() : tensor<2x5x4x4xf64> + %788 = tensor.empty() : tensor<2x5x4x4xf64> + %789 = tensor.empty() : tensor<2x5x5x4xf64> + %790 = tensor.empty() : tensor<2x5x5x4xf64> + %791 = tensor.empty() : tensor<2x5x5x4xf64> + %792 = tensor.empty() : tensor<2x5x5x5xf64> + %793 = tensor.empty() : tensor<2x5x5x5xf64> + %794 = tensor.empty() : tensor<2x5x5x5xf64> + %795 = tensor.empty() : tensor<2x4x5x5xf64> + %796 = tensor.empty() : tensor<2x4x5x5xf64> + %797 = tensor.empty() : tensor<2x4x5x5xf64> + %798 = tensor.empty() : tensor<2x4x4x5xf64> + %799 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_142 = tensor.extract_slice %799[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %800 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_142 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_143 = tensor.insert_slice %800 into %799[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %801 = polygeist.submap(%10, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %802 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %803 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%801, %802 : tensor, tensor) outs(%inserted_slice_143 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_144 = tensor.extract_slice %798[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %804 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_144 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_145 = tensor.insert_slice %804 into %798[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %805 = polygeist.submap(%10, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %806 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %807 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%805, %806 : tensor, tensor) outs(%inserted_slice_145 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_146 = tensor.extract_slice %797[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %808 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_146 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_147 = tensor.extract_slice %807[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %809 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %810 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_147, %809 : tensor, tensor) outs(%808 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_148 = tensor.extract_slice %796[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %811 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_148 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_149 = tensor.extract_slice %803[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %812 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %813 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_149, %812 : tensor, tensor) outs(%811 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_150 = tensor.extract_slice %795[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %814 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_150 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_151 = tensor.extract_slice %803[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %815 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %816 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_151, %815 : tensor, tensor) outs(%814 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_152 = tensor.extract_slice %794[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %817 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_152 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %818 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %819 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%810, %818 : tensor, tensor) outs(%817 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_153 = tensor.extract_slice %793[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %820 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_153 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %821 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %822 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%813, %821 : tensor, tensor) outs(%820 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_154 = tensor.extract_slice %792[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %823 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_154 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %824 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %825 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%816, %824 : tensor, tensor) outs(%823 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_155 = tensor.extract_slice %791[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %826 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_155 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %827 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map24} : (tensor, index, index, index, index, index) -> tensor + %828 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (tensor, index, index, index, index, index) -> tensor + %829 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (tensor, index, index, index, index, index) -> tensor + %830 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %831 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%827, %819, %828, %822, %829, %825, %830 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%826 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_156 = tensor.extract_slice %790[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %832 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_156 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %833 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (tensor, index, index, index, index, index) -> tensor + %834 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map27} : (tensor, index, index, index, index, index) -> tensor + %835 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (tensor, index, index, index, index, index) -> tensor + %836 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %837 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%833, %819, %834, %822, %835, %825, %836 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%832 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_157 = tensor.extract_slice %789[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %838 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_157 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %839 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (tensor, index, index, index, index, index) -> tensor + %840 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (tensor, index, index, index, index, index) -> tensor + %841 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map29} : (tensor, index, index, index, index, index) -> tensor + %842 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %843 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%839, %819, %840, %822, %841, %825, %842 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%838 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_158 = tensor.extract_slice %788[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %844 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_158 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %845 = polygeist.submap(%2, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %846 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%831, %845 : tensor, tensor) outs(%844 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_159 = tensor.extract_slice %787[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %847 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_159 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %848 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %849 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%837, %848 : tensor, tensor) outs(%847 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_160 = tensor.extract_slice %786[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %850 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_160 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %851 = polygeist.submap(%2, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %852 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%843, %851 : tensor, tensor) outs(%850 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_161 = tensor.extract_slice %785[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %853 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_161 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %854 = polygeist.submap(%2, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %855 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%846, %854 : tensor, tensor) outs(%853 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_162 = tensor.extract_slice %784[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %856 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_162 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %857 = polygeist.submap(%2, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %858 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%849, %857 : tensor, tensor) outs(%856 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_163 = tensor.extract_slice %783[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %859 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_163 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %860 = polygeist.submap(%3, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %861 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%852, %860 : tensor, tensor) outs(%859 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %862 = polygeist.submap(%12, %c2, %c4, %c4, %c4) {map = #map4} : (tensor, index, index, index, index) -> tensor + %863 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%855, %858, %861 : tensor, tensor, tensor) outs(%862 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %out: f64): + %1034 = arith.addf %in, %in_192 : f64 + %1035 = arith.addf %1034, %in_193 : f64 + %1036 = arith.addf %out, %1035 : f64 + linalg.yield %1036 : f64 + } -> tensor + %864 = polygeist.submapInverse(%12, %863, %c2, %c4, %c4, %c4) {map = #map4} : (tensor, tensor, index, index, index, index) -> tensor + %865 = tensor.empty() : tensor<750xf64> + %866 = tensor.empty() : tensor<750xf64> + %867 = tensor.empty() : tensor<20xf64> + %868 = polygeist.submap(%0, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %869 = polygeist.submap(%867, %c4, %c5) {map = #map1} : (tensor<20xf64>, index, index) -> tensor + %870 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%868 : tensor) outs(%869 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %871 = polygeist.submapInverse(%867, %870, %c4, %c5) {map = #map1} : (tensor<20xf64>, tensor, index, index) -> tensor<20xf64> + %872 = tensor.empty() : tensor<2x4x5x5xf64> + %873 = tensor.empty() : tensor<2x4x5x5xf64> + %874 = tensor.empty() : tensor<2x4x5x5xf64> + %875 = tensor.empty() : tensor<2x4x4x5xf64> + %876 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_164 = tensor.extract_slice %876[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %877 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_164 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_165 = tensor.insert_slice %877 into %876[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %878 = polygeist.submap(%10, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %879 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %880 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%878, %879 : tensor, tensor) outs(%inserted_slice_165 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_166 = tensor.extract_slice %875[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %881 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_166 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_167 = tensor.insert_slice %881 into %875[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %882 = polygeist.submap(%10, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %883 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %884 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%882, %883 : tensor, tensor) outs(%inserted_slice_167 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_168 = tensor.extract_slice %874[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %885 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_168 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_169 = tensor.extract_slice %884[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %886 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %887 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_169, %886 : tensor, tensor) outs(%885 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_170 = tensor.extract_slice %873[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %888 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_170 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_171 = tensor.extract_slice %880[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %889 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %890 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_171, %889 : tensor, tensor) outs(%888 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_172 = tensor.extract_slice %872[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %891 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_172 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_173 = tensor.extract_slice %880[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %892 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %893 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_173, %892 : tensor, tensor) outs(%891 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %894 = polygeist.submap(%866, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, index, index, index, index) -> tensor + %895 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%894 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %896 = polygeist.submapInverse(%866, %895, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %897 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %898 = polygeist.submap(%896, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %899 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%887, %897 : tensor, tensor) outs(%898 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x5xf64> + %900 = polygeist.submapInverse(%896, %899, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %901 = polygeist.submap(%900, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, index, index, index, index) -> tensor + %902 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%901 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %903 = polygeist.submapInverse(%900, %902, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %904 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %905 = polygeist.submap(%903, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %906 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%890, %904 : tensor, tensor) outs(%905 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x5xf64> + %907 = polygeist.submapInverse(%903, %906, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %908 = polygeist.submap(%907, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, index, index, index, index) -> tensor + %909 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%908 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %910 = polygeist.submapInverse(%907, %909, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %911 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %912 = polygeist.submap(%910, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %913 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%893, %911 : tensor, tensor) outs(%912 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x5xf64> + %914 = polygeist.submapInverse(%910, %913, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %915 = polygeist.submap(%865, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (tensor<750xf64>, index, index, index, index, index) -> tensor + %916 = linalg.generic {doc = "", indexing_maps = [#map8], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%915 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %917 = polygeist.submapInverse(%865, %916, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (tensor<750xf64>, tensor, index, index, index, index, index) -> tensor<750xf64> + %918 = polygeist.submap(%914, %c2, %c3, %c5, %c5, %c5, %c3) {map = #map54} : (tensor<750xf64>, index, index, index, index, index, index) -> tensor + %919 = polygeist.submap(%8, %c2, %c3, %c5, %c5, %c5, %c3) {map = #map55} : (tensor, index, index, index, index, index, index) -> tensor + %920 = polygeist.submap(%917, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (tensor<750xf64>, index, index, index, index, index) -> tensor<2x3x5x5x5xf64> + %921 = linalg.generic {doc = "", indexing_maps = [#map56, #map56, #map57], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%918, %919 : tensor, tensor) outs(%920 : tensor<2x3x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x3x5x5x5xf64> + %922 = polygeist.submapInverse(%917, %921, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (tensor<750xf64>, tensor<2x3x5x5x5xf64>, index, index, index, index, index) -> tensor<750xf64> + %923 = tensor.empty() : tensor<128xf64> + %924 = tensor.empty() : tensor<250xf64> + %925 = polygeist.submap(%922, %c2, %c125) {map = #map49} : (tensor<750xf64>, index, index) -> tensor + %926 = polygeist.submap(%924, %c2, %c125) {map = #map50} : (tensor<250xf64>, index, index) -> tensor + %927 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%925 : tensor) outs(%926 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %928 = polygeist.submapInverse(%924, %927, %c2, %c125) {map = #map50} : (tensor<250xf64>, tensor, index, index) -> tensor<250xf64> + %929 = polygeist.submap(%782, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %930 = polygeist.submap(%923, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %931 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%929 : tensor) outs(%930 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %932 = polygeist.submapInverse(%923, %931, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %933 = tensor.empty() : tensor<2x4x4x4xf64> + %934 = tensor.empty() : tensor<2x5x4x4xf64> + %935 = tensor.empty() : tensor<2x5x5x4xf64> + %extracted_slice_174 = tensor.extract_slice %935[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %936 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_174 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_175 = tensor.insert_slice %936 into %935[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor into tensor<2x5x5x4xf64> + %937 = polygeist.submap(%928, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (tensor<250xf64>, index, index, index, index, index) -> tensor + %938 = polygeist.submap(%871, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %939 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%937, %938 : tensor, tensor) outs(%inserted_slice_175 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x4xf64> + %extracted_slice_176 = tensor.extract_slice %934[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %940 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_176 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_177 = tensor.extract_slice %939[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %941 = polygeist.submap(%871, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %942 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_177, %941 : tensor, tensor) outs(%940 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_178 = tensor.extract_slice %933[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %943 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_178 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %944 = polygeist.submap(%871, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %945 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%942, %944 : tensor, tensor) outs(%943 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %946 = polygeist.submap(%932, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %947 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%945 : tensor) outs(%946 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.addf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %948 = polygeist.submapInverse(%932, %947, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %949 = polygeist.submap(%948, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %950 = polygeist.submap(%782, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %951 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%949 : tensor) outs(%950 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %952 = polygeist.submapInverse(%782, %951, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, tensor, index, index, index, index) -> tensor + %953 = tensor.empty() : tensor<128xf64> + %954 = tensor.empty() : tensor<250xf64> + %955 = polygeist.submap(%922, %c2, %c125) {map = #map52} : (tensor<750xf64>, index, index) -> tensor + %956 = polygeist.submap(%954, %c2, %c125) {map = #map50} : (tensor<250xf64>, index, index) -> tensor + %957 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%955 : tensor) outs(%956 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %958 = polygeist.submapInverse(%954, %957, %c2, %c125) {map = #map50} : (tensor<250xf64>, tensor, index, index) -> tensor<250xf64> + %959 = polygeist.submap(%952, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %960 = polygeist.submap(%953, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %961 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%959 : tensor) outs(%960 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %962 = polygeist.submapInverse(%953, %961, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %963 = tensor.empty() : tensor<2x4x4x4xf64> + %964 = tensor.empty() : tensor<2x5x4x4xf64> + %965 = tensor.empty() : tensor<2x5x5x4xf64> + %extracted_slice_179 = tensor.extract_slice %965[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %966 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_179 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_180 = tensor.insert_slice %966 into %965[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor into tensor<2x5x5x4xf64> + %967 = polygeist.submap(%958, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (tensor<250xf64>, index, index, index, index, index) -> tensor + %968 = polygeist.submap(%871, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %969 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%967, %968 : tensor, tensor) outs(%inserted_slice_180 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x4xf64> + %extracted_slice_181 = tensor.extract_slice %964[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %970 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_181 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_182 = tensor.extract_slice %969[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %971 = polygeist.submap(%871, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %972 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_182, %971 : tensor, tensor) outs(%970 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_183 = tensor.extract_slice %963[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %973 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_183 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %974 = polygeist.submap(%871, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %975 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%972, %974 : tensor, tensor) outs(%973 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %976 = polygeist.submap(%962, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %977 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%975 : tensor) outs(%976 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.addf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %978 = polygeist.submapInverse(%962, %977, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %979 = polygeist.submap(%978, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %980 = polygeist.submap(%952, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %981 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%979 : tensor) outs(%980 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %982 = polygeist.submapInverse(%952, %981, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %983 = tensor.empty() : tensor<128xf64> + %984 = tensor.empty() : tensor<250xf64> + %985 = polygeist.submap(%922, %c2, %c125) {map = #map53} : (tensor<750xf64>, index, index) -> tensor + %986 = polygeist.submap(%984, %c2, %c125) {map = #map50} : (tensor<250xf64>, index, index) -> tensor + %987 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%985 : tensor) outs(%986 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %988 = polygeist.submapInverse(%984, %987, %c2, %c125) {map = #map50} : (tensor<250xf64>, tensor, index, index) -> tensor<250xf64> + %989 = polygeist.submap(%982, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %990 = polygeist.submap(%983, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %991 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%989 : tensor) outs(%990 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %992 = polygeist.submapInverse(%983, %991, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %993 = tensor.empty() : tensor<2x4x4x4xf64> + %994 = tensor.empty() : tensor<2x5x4x4xf64> + %995 = tensor.empty() : tensor<2x5x5x4xf64> + %extracted_slice_184 = tensor.extract_slice %995[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %996 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_184 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_185 = tensor.insert_slice %996 into %995[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor into tensor<2x5x5x4xf64> + %997 = polygeist.submap(%988, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (tensor<250xf64>, index, index, index, index, index) -> tensor + %998 = polygeist.submap(%871, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %999 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%997, %998 : tensor, tensor) outs(%inserted_slice_185 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x4xf64> + %extracted_slice_186 = tensor.extract_slice %994[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %1000 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_186 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_187 = tensor.extract_slice %999[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %1001 = polygeist.submap(%871, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %1002 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_187, %1001 : tensor, tensor) outs(%1000 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_188 = tensor.extract_slice %993[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %1003 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_188 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %1004 = polygeist.submap(%871, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %1005 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%1002, %1004 : tensor, tensor) outs(%1003 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %1006 = polygeist.submap(%992, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %1007 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%1005 : tensor) outs(%1006 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.addf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %1008 = polygeist.submapInverse(%992, %1007, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %1009 = polygeist.submap(%1008, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %1010 = polygeist.submap(%982, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %1011 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%1009 : tensor) outs(%1010 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %1012 = polygeist.submapInverse(%982, %1011, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, tensor, index, index, index, index) -> tensor + %1013 = bufferization.to_memref %1012 : memref + memref.copy %1013, %arg11 : memref to memref + %1014 = tensor.empty() : tensor<2x5x5x5xf64> + %extracted_slice_189 = tensor.extract_slice %1014[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %1015 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_189 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_190 = tensor.insert_slice %1015 into %1014[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor into tensor<2x5x5x5xf64> + %1016 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map58} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1017 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map59} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1018 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map60} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1019 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map58} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1020 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map61} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1021 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map62} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1022 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map62} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1023 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map63} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1024 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map64} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1025 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map64} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1026 = linalg.generic {doc = "", indexing_maps = [#map65, #map65, #map65, #map65, #map65, #map65, #map65, #map65, #map65, #map65, #map66], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction", "reduction"], library_call = ""} ins(%1016, %1017, %1018, %1019, %1020, %1021, %1022, %1023, %1024, %1025 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%inserted_slice_190 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %in_198: f64, %in_199: f64, %in_200: f64, %out: f64): + %1034 = arith.mulf %in_198, %in_199 : f64 + %1035 = arith.mulf %1034, %in_196 : f64 + %1036 = arith.mulf %1035, %in : f64 + %1037 = arith.mulf %1036, %in_192 : f64 + %1038 = arith.addf %out, %1037 : f64 + %1039 = arith.mulf %in_198, %in_200 : f64 + %1040 = arith.mulf %1039, %in_197 : f64 + %1041 = arith.mulf %1040, %in : f64 + %1042 = arith.mulf %1041, %in_193 : f64 + %1043 = arith.addf %1038, %1042 : f64 + %1044 = arith.mulf %1039, %in_196 : f64 + %1045 = arith.mulf %1044, %in_194 : f64 + %1046 = arith.mulf %1045, %in_195 : f64 + %1047 = arith.addf %1043, %1046 : f64 + linalg.yield %1047 : f64 + } -> tensor<2x5x5x5xf64> + %1027 = polygeist.submap(%0, %c2, %c4, %c4, %c4, %c5, %c5, %c5) {map = #map67} : (tensor, index, index, index, index, index, index, index) -> tensor + %1028 = polygeist.submap(%0, %c2, %c4, %c4, %c4, %c5, %c5, %c5) {map = #map68} : (tensor, index, index, index, index, index, index, index) -> tensor + %extracted_slice_191 = tensor.extract_slice %1026[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %1029 = polygeist.submap(%0, %c2, %c4, %c4, %c4, %c5, %c5, %c5) {map = #map69} : (tensor, index, index, index, index, index, index, index) -> tensor + %1030 = polygeist.submap(%864, %c2, %c4, %c4, %c4) {map = #map4} : (tensor, index, index, index, index) -> tensor + %1031 = linalg.generic {doc = "", indexing_maps = [#map47, #map47, #map70, #map47, #map71], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%1027, %1028, %extracted_slice_191, %1029 : tensor, tensor, tensor, tensor) outs(%1030 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %out: f64): + %1034 = arith.mulf %in_193, %in_194 : f64 + %1035 = arith.mulf %1034, %in_192 : f64 + %1036 = arith.mulf %1035, %in : f64 + %1037 = arith.addf %out, %1036 : f64 + linalg.yield %1037 : f64 + } -> tensor + %1032 = polygeist.submapInverse(%864, %1031, %c2, %c4, %c4, %c4) {map = #map4} : (tensor, tensor, index, index, index, index) -> tensor + %1033 = bufferization.to_memref %1032 : memref + memref.copy %1033, %arg12 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pa_operators_3d.frontend.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pa_operators_3d.frontend.mlir new file mode 100644 index 000000000000..52249376224b --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pa_operators_3d.frontend.mlir @@ -0,0 +1,6942 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_navier_tgv_pa_operators_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref, %arg11: memref, %arg12: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<20xf64> + affine.for %arg13 = 0 to 4 { + affine.for %arg14 = 0 to 5 { + %0 = affine.load %arg0[%arg13 + %arg14 * 4] : memref + affine.store %0, %alloca[%arg14 + %arg13 * 5] : memref<20xf64> + } + } + %alloca_0 = memref.alloca() : memref<128xf64> + %alloca_1 = memref.alloca() : memref<128xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %arg9[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref + affine.store %0, %alloca_1[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %1 = affine.load %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref + affine.store %1, %alloca_0[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_5 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg17 + %arg16 * 4] : memref + %2 = affine.load %alloca_1[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %2 = affine.load %alloca_6[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %2 = affine.load %alloca_5[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.load %arg5[%arg13 * 125 + %arg16 + %arg14 * 25 + %arg15 * 5] : memref + %1 = affine.load %alloca_4[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + %2 = arith.mulf %1, %0 : f64 + affine.store %2, %alloca_4[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg17 + %arg16 * 5] : memref<20xf64> + %2 = affine.load %alloca_4[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg17 + %arg15 * 5] : memref<20xf64> + %2 = affine.load %alloca_3[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg17 + %arg14 * 5] : memref<20xf64> + %4 = affine.load %alloca_2[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg18, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %alloca_0[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_0[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_0[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + affine.store %0, %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref + } + } + } + } + %alloca_7 = memref.alloca() : memref<128xf64> + %alloca_8 = memref.alloca() : memref<128xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %arg9[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 64] : memref + affine.store %0, %alloca_8[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %1 = affine.load %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 64] : memref + affine.store %1, %alloca_7[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg17 + %arg16 * 4] : memref + %2 = affine.load %alloca_8[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %2 = affine.load %alloca_13[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %2 = affine.load %alloca_12[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.load %arg5[%arg13 * 125 + %arg16 + %arg14 * 25 + %arg15 * 5] : memref + %1 = affine.load %alloca_11[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + %2 = arith.mulf %1, %0 : f64 + affine.store %2, %alloca_11[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg17 + %arg16 * 5] : memref<20xf64> + %2 = affine.load %alloca_11[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg17 + %arg15 * 5] : memref<20xf64> + %2 = affine.load %alloca_10[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg17 + %arg14 * 5] : memref<20xf64> + %4 = affine.load %alloca_9[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg18, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %alloca_7[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_7[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_7[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + affine.store %0, %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 64] : memref + } + } + } + } + %alloca_14 = memref.alloca() : memref<128xf64> + %alloca_15 = memref.alloca() : memref<128xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %arg9[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 128] : memref + affine.store %0, %alloca_15[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %1 = affine.load %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 128] : memref + affine.store %1, %alloca_14[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + %alloca_16 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg17 + %arg16 * 4] : memref + %2 = affine.load %alloca_15[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_20[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %2 = affine.load %alloca_20[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_19[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %2 = affine.load %alloca_19[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_18[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.load %arg5[%arg13 * 125 + %arg16 + %arg14 * 25 + %arg15 * 5] : memref + %1 = affine.load %alloca_18[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + %2 = arith.mulf %1, %0 : f64 + affine.store %2, %alloca_18[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg17 + %arg16 * 5] : memref<20xf64> + %2 = affine.load %alloca_18[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_17[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg17 + %arg15 * 5] : memref<20xf64> + %2 = affine.load %alloca_17[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_16[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg17 + %arg14 * 5] : memref<20xf64> + %4 = affine.load %alloca_16[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg18, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %alloca_14[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_14[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_14[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + affine.store %0, %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 128] : memref + } + } + } + } + %alloca_21 = memref.alloca() : memref<20xf64> + %alloca_22 = memref.alloca() : memref<20xf64> + affine.for %arg13 = 0 to 4 { + affine.for %arg14 = 0 to 5 { + %0 = affine.load %arg0[%arg13 + %arg14 * 4] : memref + affine.store %0, %alloca_22[%arg14 + %arg13 * 5] : memref<20xf64> + %1 = affine.load %arg1[%arg13 + %arg14 * 4] : memref + affine.store %1, %alloca_21[%arg14 + %arg13 * 5] : memref<20xf64> + } + } + %alloca_23 = memref.alloca() : memref<128xf64> + %alloca_24 = memref.alloca() : memref<128xf64> + %alloca_25 = memref.alloca() : memref<1500xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 6 { + affine.for %arg15 = 0 to 125 { + %0 = affine.load %arg6[%arg15 + %arg13 * 2250 + %arg14 * 125] : memref + affine.store %0, %alloca_25[%arg15 + %arg13 * 750 + %arg14 * 125] : memref<1500xf64> + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %arg9[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref + affine.store %0, %alloca_24[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %1 = affine.load %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref + affine.store %1, %alloca_23[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + %alloca_26 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_27 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_28 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_29 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_30 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_31 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_32 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_33 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_34 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_35 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_36 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_37 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_38 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_39 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_40 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_41 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_42 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_24[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_42[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_24[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = affine.load %arg1[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_41[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_41[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_40[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_42[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_39[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_42[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_38[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_40[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_37[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_39[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_36[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_38[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_35[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_25[%arg14 * 25 + %arg17 + %arg15 * 5 + %arg13 * 750] : memref<1500xf64> + %2 = affine.load %alloca_37[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_25[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 125] : memref<1500xf64> + %5 = affine.load %alloca_36[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_25[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 250] : memref<1500xf64> + %9 = affine.load %alloca_35[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca_21[%arg17 + %arg16 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg18, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_34[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_25[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 125] : memref<1500xf64> + %2 = affine.load %alloca_37[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_25[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 375] : memref<1500xf64> + %5 = affine.load %alloca_36[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_25[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 500] : memref<1500xf64> + %9 = affine.load %alloca_35[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca_22[%arg17 + %arg16 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg18, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_33[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_25[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 250] : memref<1500xf64> + %2 = affine.load %alloca_37[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_25[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 500] : memref<1500xf64> + %5 = affine.load %alloca_36[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_25[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 625] : memref<1500xf64> + %9 = affine.load %alloca_35[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca_22[%arg17 + %arg16 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg18, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_32[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_34[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_22[%arg17 + %arg15 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_31[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_21[%arg17 + %arg15 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_30[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_32[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_22[%arg17 + %arg15 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_29[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_31[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_22[%arg17 + %arg14 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_28[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_30[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_22[%arg17 + %arg14 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_27[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_29[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_21[%arg17 + %arg14 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_26[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_28[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_27[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %alloca_26[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_23[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %6 = arith.addf %5, %4 : f64 + affine.store %6, %alloca_23[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_23[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + affine.store %0, %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref + } + } + } + } + %alloca_43 = memref.alloca() : memref<128xf64> + %alloca_44 = memref.alloca() : memref<128xf64> + %alloca_45 = memref.alloca() : memref<1500xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 6 { + affine.for %arg15 = 0 to 125 { + %0 = affine.load %arg6[%arg15 + %arg13 * 2250 + %arg14 * 125 + 750] : memref + affine.store %0, %alloca_45[%arg15 + %arg13 * 750 + %arg14 * 125] : memref<1500xf64> + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %arg9[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 64] : memref + affine.store %0, %alloca_44[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %1 = affine.load %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 64] : memref + affine.store %1, %alloca_43[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + %alloca_46 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_47 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_48 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_49 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_50 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_51 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_52 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_53 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_54 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_55 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_56 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_57 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_58 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_59 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_60 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_61 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_62 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_44[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_62[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_44[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = affine.load %arg1[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_61[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_61[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_60[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_62[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_59[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_62[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_58[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_60[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_57[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_59[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_56[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_58[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_55[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_45[%arg14 * 25 + %arg17 + %arg15 * 5 + %arg13 * 750] : memref<1500xf64> + %2 = affine.load %alloca_57[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_45[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 125] : memref<1500xf64> + %5 = affine.load %alloca_56[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_45[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 250] : memref<1500xf64> + %9 = affine.load %alloca_55[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca_21[%arg17 + %arg16 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg18, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_54[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_45[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 125] : memref<1500xf64> + %2 = affine.load %alloca_57[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_45[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 375] : memref<1500xf64> + %5 = affine.load %alloca_56[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_45[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 500] : memref<1500xf64> + %9 = affine.load %alloca_55[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca_22[%arg17 + %arg16 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg18, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_53[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_45[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 250] : memref<1500xf64> + %2 = affine.load %alloca_57[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_45[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 500] : memref<1500xf64> + %5 = affine.load %alloca_56[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_45[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 625] : memref<1500xf64> + %9 = affine.load %alloca_55[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca_22[%arg17 + %arg16 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg18, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_52[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_54[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_22[%arg17 + %arg15 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_51[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_53[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_21[%arg17 + %arg15 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_50[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_52[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_22[%arg17 + %arg15 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_49[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_51[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_22[%arg17 + %arg14 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_48[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_50[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_22[%arg17 + %arg14 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_47[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_49[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_21[%arg17 + %arg14 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_46[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_48[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_47[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %alloca_46[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_43[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %6 = arith.addf %5, %4 : f64 + affine.store %6, %alloca_43[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_43[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + affine.store %0, %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 64] : memref + } + } + } + } + %alloca_63 = memref.alloca() : memref<128xf64> + %alloca_64 = memref.alloca() : memref<128xf64> + %alloca_65 = memref.alloca() : memref<1500xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 6 { + affine.for %arg15 = 0 to 125 { + %0 = affine.load %arg6[%arg15 + %arg13 * 2250 + %arg14 * 125 + 1500] : memref + affine.store %0, %alloca_65[%arg15 + %arg13 * 750 + %arg14 * 125] : memref<1500xf64> + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %arg9[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 128] : memref + affine.store %0, %alloca_64[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %1 = affine.load %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 128] : memref + affine.store %1, %alloca_63[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + %alloca_66 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_67 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_68 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_69 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_70 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_71 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_72 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_73 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_74 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_75 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_76 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_77 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_78 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_79 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_80 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_81 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_82 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_64[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_82[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_64[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = affine.load %arg1[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_81[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_81[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_80[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_82[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_79[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_82[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_78[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_80[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_77[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_79[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_76[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_78[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_75[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_65[%arg14 * 25 + %arg17 + %arg15 * 5 + %arg13 * 750] : memref<1500xf64> + %2 = affine.load %alloca_77[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_65[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 125] : memref<1500xf64> + %5 = affine.load %alloca_76[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_65[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 250] : memref<1500xf64> + %9 = affine.load %alloca_75[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca_21[%arg17 + %arg16 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg18, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_74[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_65[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 125] : memref<1500xf64> + %2 = affine.load %alloca_77[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_65[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 375] : memref<1500xf64> + %5 = affine.load %alloca_76[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_65[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 500] : memref<1500xf64> + %9 = affine.load %alloca_75[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca_22[%arg17 + %arg16 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg18, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_73[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_65[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 250] : memref<1500xf64> + %2 = affine.load %alloca_77[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_65[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 500] : memref<1500xf64> + %5 = affine.load %alloca_76[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_65[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 625] : memref<1500xf64> + %9 = affine.load %alloca_75[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca_22[%arg17 + %arg16 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg18, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_72[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_74[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_22[%arg17 + %arg15 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_71[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_73[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_21[%arg17 + %arg15 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_70[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_72[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_22[%arg17 + %arg15 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_69[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_71[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_22[%arg17 + %arg14 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_68[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_70[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_22[%arg17 + %arg14 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_67[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_69[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_21[%arg17 + %arg14 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_66[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_68[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_67[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %alloca_66[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_63[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %6 = arith.addf %5, %4 : f64 + affine.store %6, %alloca_63[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_63[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + affine.store %0, %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 128] : memref + } + } + } + } + %alloca_83 = memref.alloca() : memref<750xf64> + %alloca_84 = memref.alloca() : memref<2250xf64> + %alloca_85 = memref.alloca() : memref<750xf64> + %alloca_86 = memref.alloca() : memref<20xf64> + affine.for %arg13 = 0 to 4 { + affine.for %arg14 = 0 to 5 { + %0 = affine.load %arg0[%arg13 + %arg14 * 4] : memref + affine.store %0, %alloca_86[%arg14 + %arg13 * 5] : memref<20xf64> + } + } + %alloca_87 = memref.alloca() : memref<750xf64> + %alloca_88 = memref.alloca() : memref<250xf64> + %alloca_89 = memref.alloca() : memref<128xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %arg9[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref + affine.store %0, %alloca_89[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + %alloca_90 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_91 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_89[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_91[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_91[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_90[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_90[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_88[%arg14 * 25 + %arg16 + %arg15 * 5 + %arg13 * 125] : memref<250xf64> + } + } + } + } + %alloca_92 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_93 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_94 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_95 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_96 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_89[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_96[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_89[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = affine.load %arg1[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_95[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_95[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_94[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_96[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_93[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_96[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_92[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_94[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_87[%arg13 * 375 + %arg14 + %arg16 * 25 + %arg15 * 5] : memref<750xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_93[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_87[%arg13 * 375 + %arg14 + %arg16 * 25 + %arg15 * 5 + 125] : memref<750xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_92[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_87[%arg13 * 375 + %arg14 + %arg16 * 25 + %arg15 * 5 + 250] : memref<750xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.load %alloca_88[%arg14 * 25 + %arg16 + %arg15 * 5 + %arg13 * 125] : memref<250xf64> + affine.store %0, %alloca_85[%arg14 * 25 + %arg16 + %arg13 * 375 + %arg15 * 5] : memref<750xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 3 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + affine.for %arg17 = 0 to 5 { + %0 = affine.load %alloca_87[%arg13 * 375 + %arg14 * 125 + %arg15 + %arg17 * 25 + %arg16 * 5] : memref<750xf64> + affine.store %0, %alloca_84[%arg13 * 1125 + %arg15 * 25 + %arg17 + %arg16 * 5 + %arg14 * 125] : memref<2250xf64> + } + } + } + } + } + %alloca_97 = memref.alloca() : memref<750xf64> + %alloca_98 = memref.alloca() : memref<250xf64> + %alloca_99 = memref.alloca() : memref<128xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %arg9[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 64] : memref + affine.store %0, %alloca_99[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + %alloca_100 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_101 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_99[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_101[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_101[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_100[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_100[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_98[%arg14 * 25 + %arg16 + %arg15 * 5 + %arg13 * 125] : memref<250xf64> + } + } + } + } + %alloca_102 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_103 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_104 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_105 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_106 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_99[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_106[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_99[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = affine.load %arg1[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_105[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_105[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_104[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_106[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_103[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_106[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_102[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_104[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_97[%arg13 * 375 + %arg14 + %arg16 * 25 + %arg15 * 5] : memref<750xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_103[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_97[%arg13 * 375 + %arg14 + %arg16 * 25 + %arg15 * 5 + 125] : memref<750xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_102[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_97[%arg13 * 375 + %arg14 + %arg16 * 25 + %arg15 * 5 + 250] : memref<750xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.load %alloca_98[%arg14 * 25 + %arg16 + %arg15 * 5 + %arg13 * 125] : memref<250xf64> + affine.store %0, %alloca_85[%arg14 * 25 + %arg16 + %arg13 * 375 + %arg15 * 5 + 125] : memref<750xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 3 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + affine.for %arg17 = 0 to 5 { + %0 = affine.load %alloca_97[%arg13 * 375 + %arg14 * 125 + %arg15 + %arg17 * 25 + %arg16 * 5] : memref<750xf64> + affine.store %0, %alloca_84[%arg13 * 1125 + %arg15 * 25 + %arg17 + %arg16 * 5 + %arg14 * 125 + 375] : memref<2250xf64> + } + } + } + } + } + %alloca_107 = memref.alloca() : memref<750xf64> + %alloca_108 = memref.alloca() : memref<250xf64> + %alloca_109 = memref.alloca() : memref<128xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %arg9[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 128] : memref + affine.store %0, %alloca_109[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + %alloca_110 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_111 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_109[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_111[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_111[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_110[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_110[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_108[%arg14 * 25 + %arg16 + %arg15 * 5 + %arg13 * 125] : memref<250xf64> + } + } + } + } + %alloca_112 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_113 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_114 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_115 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_116 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_109[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_116[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_109[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = affine.load %arg1[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_115[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_115[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_114[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_116[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_113[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_116[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_112[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_114[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_107[%arg13 * 375 + %arg14 + %arg16 * 25 + %arg15 * 5] : memref<750xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_113[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_107[%arg13 * 375 + %arg14 + %arg16 * 25 + %arg15 * 5 + 125] : memref<750xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_112[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_107[%arg13 * 375 + %arg14 + %arg16 * 25 + %arg15 * 5 + 250] : memref<750xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.load %alloca_108[%arg14 * 25 + %arg16 + %arg15 * 5 + %arg13 * 125] : memref<250xf64> + affine.store %0, %alloca_85[%arg14 * 25 + %arg16 + %arg13 * 375 + %arg15 * 5 + 250] : memref<750xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 3 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + affine.for %arg17 = 0 to 5 { + %0 = affine.load %alloca_107[%arg13 * 375 + %arg14 * 125 + %arg15 + %arg17 * 25 + %arg16 * 5] : memref<750xf64> + affine.store %0, %alloca_84[%arg13 * 1125 + %arg15 * 25 + %arg17 + %arg16 * 5 + %arg14 * 125 + 750] : memref<2250xf64> + } + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 3 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + affine.for %arg17 = 0 to 5 { + %0 = affine.for %arg18 = 0 to 3 iter_args(%arg19 = %cst) -> (f64) { + %1 = affine.load %alloca_85[%arg15 * 25 + %arg13 * 375 + %arg17 + %arg16 * 5 + %arg18 * 125] : memref<750xf64> + %2 = affine.for %arg20 = 0 to 3 iter_args(%arg21 = %arg19) -> (f64) { + %3 = affine.load %alloca_84[%arg13 * 1125 + %arg14 * 375 + %arg15 * 25 + %arg17 + %arg16 * 5 + %arg20 * 125] : memref<2250xf64> + %4 = arith.mulf %1, %3 : f64 + %5 = affine.load %arg7[%arg13 * 1125 + %arg18 * 375 + %arg15 * 25 + %arg17 + %arg16 * 5 + %arg20 * 125] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %arg21, %6 : f64 + affine.yield %7 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca_83[%arg15 * 25 + %arg13 * 375 + %arg17 + %arg16 * 5 + %arg14 * 125] : memref<750xf64> + } + } + } + } + } + %alloca_117 = memref.alloca() : memref<128xf64> + %alloca_118 = memref.alloca() : memref<250xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 125 { + %0 = affine.load %alloca_83[%arg14 + %arg13 * 375] : memref<750xf64> + affine.store %0, %alloca_118[%arg14 + %arg13 * 125] : memref<250xf64> + } + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref + affine.store %0, %alloca_117[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + %alloca_119 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_120 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_121 = memref.alloca() : memref<2x5x5x4xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_118[%arg14 * 25 + %arg17 + %arg15 * 5 + %arg13 * 125] : memref<250xf64> + %2 = affine.load %alloca_86[%arg17 + %arg16 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_121[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_121[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_86[%arg17 + %arg15 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_120[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_120[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_86[%arg17 + %arg14 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_119[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_119[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_117[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_117[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_117[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + affine.store %0, %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref + } + } + } + } + %alloca_122 = memref.alloca() : memref<128xf64> + %alloca_123 = memref.alloca() : memref<250xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 125 { + %0 = affine.load %alloca_83[%arg14 + %arg13 * 375 + 125] : memref<750xf64> + affine.store %0, %alloca_123[%arg14 + %arg13 * 125] : memref<250xf64> + } + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 64] : memref + affine.store %0, %alloca_122[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + %alloca_124 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_125 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_126 = memref.alloca() : memref<2x5x5x4xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_123[%arg14 * 25 + %arg17 + %arg15 * 5 + %arg13 * 125] : memref<250xf64> + %2 = affine.load %alloca_86[%arg17 + %arg16 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_126[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_126[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_86[%arg17 + %arg15 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_125[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_125[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_86[%arg17 + %arg14 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_124[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_124[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_122[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_122[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_122[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + affine.store %0, %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 64] : memref + } + } + } + } + %alloca_127 = memref.alloca() : memref<128xf64> + %alloca_128 = memref.alloca() : memref<250xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 125 { + %0 = affine.load %alloca_83[%arg14 + %arg13 * 375 + 250] : memref<750xf64> + affine.store %0, %alloca_128[%arg14 + %arg13 * 125] : memref<250xf64> + } + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 128] : memref + affine.store %0, %alloca_127[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + %alloca_129 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_130 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_131 = memref.alloca() : memref<2x5x5x4xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_128[%arg14 * 25 + %arg17 + %arg15 * 5 + %arg13 * 125] : memref<250xf64> + %2 = affine.load %alloca_86[%arg17 + %arg16 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_131[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_131[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_86[%arg17 + %arg15 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_130[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_130[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_86[%arg17 + %arg14 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_129[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_129[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_127[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_127[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_127[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + affine.store %0, %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 128] : memref + } + } + } + } + %alloca_132 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_133 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_134 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_135 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_136 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_137 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_138 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_139 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_140 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_141 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_142 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_143 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_144 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_145 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_146 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_147 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_148 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %arg10[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref + %2 = affine.load %arg0[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_148[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %arg10[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref + %2 = affine.load %arg1[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_147[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_147[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_146[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_148[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_145[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_148[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_144[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_146[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_143[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_145[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_142[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_144[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_141[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg14 * 25 + %arg17 + %arg15 * 5 + %arg13 * 750] : memref + %2 = affine.load %alloca_143[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 125] : memref + %5 = affine.load %alloca_142[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 250] : memref + %9 = affine.load %alloca_141[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg3[%arg17 + %arg16 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg18, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_140[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 125] : memref + %2 = affine.load %alloca_143[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 375] : memref + %5 = affine.load %alloca_142[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 500] : memref + %9 = affine.load %alloca_141[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg17 + %arg16 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg18, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_139[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 250] : memref + %2 = affine.load %alloca_143[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 500] : memref + %5 = affine.load %alloca_142[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg14 * 25 + %arg17 + %arg13 * 750 + %arg15 * 5 + 625] : memref + %9 = affine.load %alloca_141[%arg13, %arg14, %arg15, %arg17] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg17 + %arg16 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg18, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_138[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_140[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg17 + %arg15 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_137[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_139[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg17 + %arg15 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_136[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_138[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg17 + %arg15 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_135[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_137[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg17 + %arg14 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_134[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_136[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg17 + %arg14 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_133[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_135[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg17 + %arg14 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_132[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_134[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_133[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %alloca_132[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg12[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref + %6 = arith.addf %5, %4 : f64 + affine.store %6, %arg12[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref + } + } + } + } + %alloca_149 = memref.alloca() : memref<750xf64> + %alloca_150 = memref.alloca() : memref<750xf64> + %alloca_151 = memref.alloca() : memref<20xf64> + affine.for %arg13 = 0 to 4 { + affine.for %arg14 = 0 to 5 { + %0 = affine.load %arg0[%arg13 + %arg14 * 4] : memref + affine.store %0, %alloca_151[%arg14 + %arg13 * 5] : memref<20xf64> + } + } + %alloca_152 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_153 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_154 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_155 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_156 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %arg10[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref + %2 = affine.load %arg0[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_156[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %arg10[%arg13 * 64 + %arg17 + %arg14 * 16 + %arg15 * 4] : memref + %2 = affine.load %arg1[%arg17 + %arg16 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_155[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_155[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_154[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_156[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_153[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_156[%arg13, %arg14, %arg17, %arg16] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg17 + %arg15 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_152[%arg13, %arg14, %arg15, %arg16] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_154[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_150[%arg13 * 375 + %arg14 + %arg16 * 25 + %arg15 * 5] : memref<750xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_153[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_150[%arg13 * 375 + %arg14 + %arg16 * 25 + %arg15 * 5 + 125] : memref<750xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 4 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_152[%arg13, %arg17, %arg15, %arg16] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg17 + %arg14 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_150[%arg13 * 375 + %arg14 + %arg16 * 25 + %arg15 * 5 + 250] : memref<750xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 3 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + affine.for %arg17 = 0 to 5 { + %0 = affine.for %arg18 = 0 to 3 iter_args(%arg19 = %cst) -> (f64) { + %1 = affine.load %alloca_150[%arg13 * 375 + %arg18 * 125 + %arg15 + %arg17 * 25 + %arg16 * 5] : memref<750xf64> + %2 = affine.load %arg8[%arg13 * 1125 + %arg14 * 375 + %arg15 * 25 + %arg17 + %arg16 * 5 + %arg18 * 125] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg19, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_149[%arg15 * 25 + %arg13 * 375 + %arg17 + %arg16 * 5 + %arg14 * 125] : memref<750xf64> + } + } + } + } + } + %alloca_157 = memref.alloca() : memref<128xf64> + %alloca_158 = memref.alloca() : memref<250xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 125 { + %0 = affine.load %alloca_149[%arg14 + %arg13 * 375] : memref<750xf64> + affine.store %0, %alloca_158[%arg14 + %arg13 * 125] : memref<250xf64> + } + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref + affine.store %0, %alloca_157[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + %alloca_159 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_160 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_161 = memref.alloca() : memref<2x5x5x4xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_158[%arg14 * 25 + %arg17 + %arg15 * 5 + %arg13 * 125] : memref<250xf64> + %2 = affine.load %alloca_151[%arg17 + %arg16 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_161[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_161[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_151[%arg17 + %arg15 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_160[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_160[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_151[%arg17 + %arg14 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_159[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_159[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_157[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_157[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_157[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + affine.store %0, %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref + } + } + } + } + %alloca_162 = memref.alloca() : memref<128xf64> + %alloca_163 = memref.alloca() : memref<250xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 125 { + %0 = affine.load %alloca_149[%arg14 + %arg13 * 375 + 125] : memref<750xf64> + affine.store %0, %alloca_163[%arg14 + %arg13 * 125] : memref<250xf64> + } + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 64] : memref + affine.store %0, %alloca_162[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + %alloca_164 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_165 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_166 = memref.alloca() : memref<2x5x5x4xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_163[%arg14 * 25 + %arg17 + %arg15 * 5 + %arg13 * 125] : memref<250xf64> + %2 = affine.load %alloca_151[%arg17 + %arg16 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_166[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_166[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_151[%arg17 + %arg15 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_165[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_165[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_151[%arg17 + %arg14 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_164[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_164[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_162[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_162[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_162[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + affine.store %0, %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 64] : memref + } + } + } + } + %alloca_167 = memref.alloca() : memref<128xf64> + %alloca_168 = memref.alloca() : memref<250xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 125 { + %0 = affine.load %alloca_149[%arg14 + %arg13 * 375 + 250] : memref<750xf64> + affine.store %0, %alloca_168[%arg14 + %arg13 * 125] : memref<250xf64> + } + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 128] : memref + affine.store %0, %alloca_167[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + %alloca_169 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_170 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_171 = memref.alloca() : memref<2x5x5x4xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_168[%arg14 * 25 + %arg17 + %arg15 * 5 + %arg13 * 125] : memref<250xf64> + %2 = affine.load %alloca_151[%arg17 + %arg16 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_171[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_171[%arg13, %arg14, %arg17, %arg16] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_151[%arg17 + %arg15 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_170[%arg13, %arg14, %arg15, %arg16] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.load %alloca_170[%arg13, %arg17, %arg15, %arg16] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_151[%arg17 + %arg14 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg18, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_169[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_169[%arg13, %arg14, %arg15, %arg16] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_167[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_167[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.load %alloca_167[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref<128xf64> + affine.store %0, %arg11[%arg13 * 192 + %arg16 + %arg14 * 16 + %arg15 * 4 + 128] : memref + } + } + } + } + %alloca_172 = memref.alloca() : memref<2x5x5x5xf64> + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 5 { + affine.for %arg15 = 0 to 5 { + affine.for %arg16 = 0 to 5 { + %0 = affine.for %arg17 = 0 to 3 iter_args(%arg18 = %cst) -> (f64) { + %1 = affine.for %arg19 = 0 to 4 iter_args(%arg20 = %arg18) -> (f64) { + %2 = affine.load %arg0[%arg19 + %arg14 * 4] : memref + %3 = affine.load %arg8[%arg14 * 25 + %arg13 * 1125 + %arg16 + %arg15 * 5 + %arg17 * 375] : memref + %4 = affine.load %arg8[%arg13 * 1125 + %arg17 * 375 + %arg16 + %arg14 * 25 + %arg15 * 5 + 125] : memref + %5 = affine.load %arg1[%arg19 + %arg14 * 4] : memref + %6 = affine.load %arg8[%arg13 * 1125 + %arg17 * 375 + %arg16 + %arg14 * 25 + %arg15 * 5 + 250] : memref + %7 = affine.for %arg21 = 0 to 4 iter_args(%arg22 = %arg20) -> (f64) { + %8 = affine.load %arg0[%arg21 + %arg15 * 4] : memref + %9 = affine.load %arg1[%arg21 + %arg15 * 4] : memref + %10 = affine.for %arg23 = 0 to 4 iter_args(%arg24 = %arg22) -> (f64) { + %11 = affine.load %arg9[%arg13 * 192 + %arg17 * 64 + %arg23 + %arg19 * 16 + %arg21 * 4] : memref + %12 = affine.load %arg1[%arg23 + %arg16 * 4] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.mulf %13, %8 : f64 + %15 = arith.mulf %14, %2 : f64 + %16 = arith.mulf %15, %3 : f64 + %17 = arith.addf %arg24, %16 : f64 + %18 = affine.load %arg0[%arg23 + %arg16 * 4] : memref + %19 = arith.mulf %11, %18 : f64 + %20 = arith.mulf %19, %9 : f64 + %21 = arith.mulf %20, %2 : f64 + %22 = arith.mulf %21, %4 : f64 + %23 = arith.addf %17, %22 : f64 + %24 = arith.mulf %19, %8 : f64 + %25 = arith.mulf %24, %5 : f64 + %26 = arith.mulf %25, %6 : f64 + %27 = arith.addf %23, %26 : f64 + affine.yield %27 : f64 + } + affine.yield %10 : f64 + } + affine.yield %7 : f64 + } + affine.yield %1 : f64 + } + affine.store %0, %alloca_172[%arg13, %arg14, %arg15, %arg16] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg13 = 0 to 2 { + affine.for %arg14 = 0 to 4 { + affine.for %arg15 = 0 to 4 { + affine.for %arg16 = 0 to 4 { + %0 = affine.for %arg17 = 0 to 5 iter_args(%arg18 = %cst) -> (f64) { + %3 = affine.load %arg0[%arg14 + %arg17 * 4] : memref + %4 = affine.for %arg19 = 0 to 5 iter_args(%arg20 = %arg18) -> (f64) { + %5 = affine.load %arg0[%arg15 + %arg19 * 4] : memref + %6 = affine.for %arg21 = 0 to 5 iter_args(%arg22 = %arg20) -> (f64) { + %7 = affine.load %alloca_172[%arg13, %arg17, %arg19, %arg21] : memref<2x5x5x5xf64> + %8 = affine.load %arg0[%arg16 + %arg21 * 4] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg22, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg12[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg12[%arg13 * 64 + %arg16 + %arg14 * 16 + %arg15 * 4] : memref + } + } + } + } + return + } + func.func @mfem_pa_vector_mass_apply_3d_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<20xf64> + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 5 { + %0 = affine.load %arg0[%arg4 + %arg5 * 4] : memref + affine.store %0, %alloca[%arg5 + %arg4 * 5] : memref<20xf64> + } + } + %alloca_0 = memref.alloca() : memref<128xf64> + %alloca_1 = memref.alloca() : memref<128xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.load %arg2[%arg4 * 192 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref + affine.store %0, %alloca_1[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + %1 = affine.load %arg3[%arg4 * 192 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref + affine.store %1, %alloca_0[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + } + } + } + } + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_5 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg8 + %arg7 * 4] : memref + %2 = affine.load %alloca_1[%arg4 * 64 + %arg8 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg4, %arg5, %arg6, %arg7] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg8 + %arg6 * 4] : memref + %2 = affine.load %alloca_6[%arg4, %arg5, %arg8, %arg7] : memref<2x4x4x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg4, %arg5, %arg6, %arg7] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg8 + %arg5 * 4] : memref + %2 = affine.load %alloca_5[%arg4, %arg8, %arg6, %arg7] : memref<2x4x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg4, %arg5, %arg6, %arg7] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.load %arg1[%arg4 * 125 + %arg7 + %arg5 * 25 + %arg6 * 5] : memref + %1 = affine.load %alloca_4[%arg4, %arg5, %arg6, %arg7] : memref<2x5x5x5xf64> + %2 = arith.mulf %1, %0 : f64 + affine.store %2, %alloca_4[%arg4, %arg5, %arg6, %arg7] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg8 + %arg7 * 5] : memref<20xf64> + %2 = affine.load %alloca_4[%arg4, %arg5, %arg6, %arg8] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg4, %arg5, %arg6, %arg7] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg8 + %arg6 * 5] : memref<20xf64> + %2 = affine.load %alloca_3[%arg4, %arg5, %arg8, %arg7] : memref<2x5x5x4xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg4, %arg5, %arg6, %arg7] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg8 + %arg5 * 5] : memref<20xf64> + %4 = affine.load %alloca_2[%arg4, %arg8, %arg6, %arg7] : memref<2x5x4x4xf64> + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg9, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %alloca_0[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_0[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.load %alloca_0[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + affine.store %0, %arg3[%arg4 * 192 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref + } + } + } + } + %alloca_7 = memref.alloca() : memref<128xf64> + %alloca_8 = memref.alloca() : memref<128xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.load %arg2[%arg4 * 192 + %arg7 + %arg5 * 16 + %arg6 * 4 + 64] : memref + affine.store %0, %alloca_8[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + %1 = affine.load %arg3[%arg4 * 192 + %arg7 + %arg5 * 16 + %arg6 * 4 + 64] : memref + affine.store %1, %alloca_7[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + } + } + } + } + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg8 + %arg7 * 4] : memref + %2 = affine.load %alloca_8[%arg4 * 64 + %arg8 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg4, %arg5, %arg6, %arg7] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg8 + %arg6 * 4] : memref + %2 = affine.load %alloca_13[%arg4, %arg5, %arg8, %arg7] : memref<2x4x4x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg4, %arg5, %arg6, %arg7] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg8 + %arg5 * 4] : memref + %2 = affine.load %alloca_12[%arg4, %arg8, %arg6, %arg7] : memref<2x4x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg4, %arg5, %arg6, %arg7] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.load %arg1[%arg4 * 125 + %arg7 + %arg5 * 25 + %arg6 * 5] : memref + %1 = affine.load %alloca_11[%arg4, %arg5, %arg6, %arg7] : memref<2x5x5x5xf64> + %2 = arith.mulf %1, %0 : f64 + affine.store %2, %alloca_11[%arg4, %arg5, %arg6, %arg7] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg8 + %arg7 * 5] : memref<20xf64> + %2 = affine.load %alloca_11[%arg4, %arg5, %arg6, %arg8] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg4, %arg5, %arg6, %arg7] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg8 + %arg6 * 5] : memref<20xf64> + %2 = affine.load %alloca_10[%arg4, %arg5, %arg8, %arg7] : memref<2x5x5x4xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg4, %arg5, %arg6, %arg7] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg8 + %arg5 * 5] : memref<20xf64> + %4 = affine.load %alloca_9[%arg4, %arg8, %arg6, %arg7] : memref<2x5x4x4xf64> + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg9, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %alloca_7[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_7[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.load %alloca_7[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + affine.store %0, %arg3[%arg4 * 192 + %arg7 + %arg5 * 16 + %arg6 * 4 + 64] : memref + } + } + } + } + %alloca_14 = memref.alloca() : memref<128xf64> + %alloca_15 = memref.alloca() : memref<128xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.load %arg2[%arg4 * 192 + %arg7 + %arg5 * 16 + %arg6 * 4 + 128] : memref + affine.store %0, %alloca_15[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + %1 = affine.load %arg3[%arg4 * 192 + %arg7 + %arg5 * 16 + %arg6 * 4 + 128] : memref + affine.store %1, %alloca_14[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + } + } + } + } + %alloca_16 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg8 + %arg7 * 4] : memref + %2 = affine.load %alloca_15[%arg4 * 64 + %arg8 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_20[%arg4, %arg5, %arg6, %arg7] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg8 + %arg6 * 4] : memref + %2 = affine.load %alloca_20[%arg4, %arg5, %arg8, %arg7] : memref<2x4x4x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_19[%arg4, %arg5, %arg6, %arg7] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg8 + %arg5 * 4] : memref + %2 = affine.load %alloca_19[%arg4, %arg8, %arg6, %arg7] : memref<2x4x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_18[%arg4, %arg5, %arg6, %arg7] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.load %arg1[%arg4 * 125 + %arg7 + %arg5 * 25 + %arg6 * 5] : memref + %1 = affine.load %alloca_18[%arg4, %arg5, %arg6, %arg7] : memref<2x5x5x5xf64> + %2 = arith.mulf %1, %0 : f64 + affine.store %2, %alloca_18[%arg4, %arg5, %arg6, %arg7] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg8 + %arg7 * 5] : memref<20xf64> + %2 = affine.load %alloca_18[%arg4, %arg5, %arg6, %arg8] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_17[%arg4, %arg5, %arg6, %arg7] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg8 + %arg6 * 5] : memref<20xf64> + %2 = affine.load %alloca_17[%arg4, %arg5, %arg8, %arg7] : memref<2x5x5x4xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_16[%arg4, %arg5, %arg6, %arg7] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg8 + %arg5 * 5] : memref<20xf64> + %4 = affine.load %alloca_16[%arg4, %arg8, %arg6, %arg7] : memref<2x5x4x4xf64> + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg9, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %alloca_14[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_14[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.load %alloca_14[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref<128xf64> + affine.store %0, %arg3[%arg4 * 192 + %arg7 + %arg5 * 16 + %arg6 * 4 + 128] : memref + } + } + } + } + return + } + func.func @mfem_pa_vector_diffusion_apply_3d_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<20xf64> + %alloca_0 = memref.alloca() : memref<20xf64> + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %0 = affine.load %arg0[%arg5 + %arg6 * 4] : memref + affine.store %0, %alloca_0[%arg6 + %arg5 * 5] : memref<20xf64> + %1 = affine.load %arg1[%arg5 + %arg6 * 4] : memref + affine.store %1, %alloca[%arg6 + %arg5 * 5] : memref<20xf64> + } + } + %alloca_1 = memref.alloca() : memref<128xf64> + %alloca_2 = memref.alloca() : memref<128xf64> + %alloca_3 = memref.alloca() : memref<1500xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 6 { + affine.for %arg7 = 0 to 125 { + %0 = affine.load %arg2[%arg7 + %arg5 * 2250 + %arg6 * 125] : memref + affine.store %0, %alloca_3[%arg7 + %arg5 * 750 + %arg6 * 125] : memref<1500xf64> + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %arg3[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + affine.store %0, %alloca_2[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %1 = affine.load %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + affine.store %1, %alloca_1[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + %alloca_4 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_13 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_14 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_15 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_16 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_17 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_18 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_20 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_20[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = affine.load %arg1[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_19[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_19[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_18[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_20[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_17[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_20[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_16[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_18[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_15[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_17[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_14[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_16[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg6 * 25 + %arg9 + %arg7 * 5 + %arg5 * 750] : memref<1500xf64> + %2 = affine.load %alloca_15[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_3[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 125] : memref<1500xf64> + %5 = affine.load %alloca_14[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_3[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 250] : memref<1500xf64> + %9 = affine.load %alloca_13[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca[%arg9 + %arg8 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg10, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_12[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 125] : memref<1500xf64> + %2 = affine.load %alloca_15[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_3[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 375] : memref<1500xf64> + %5 = affine.load %alloca_14[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_3[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 500] : memref<1500xf64> + %9 = affine.load %alloca_13[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca_0[%arg9 + %arg8 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg10, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_11[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 250] : memref<1500xf64> + %2 = affine.load %alloca_15[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_3[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 500] : memref<1500xf64> + %5 = affine.load %alloca_14[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_3[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 625] : memref<1500xf64> + %9 = affine.load %alloca_13[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca_0[%arg9 + %arg8 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg10, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_10[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_0[%arg9 + %arg7 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %2 = affine.load %alloca[%arg9 + %arg7 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_0[%arg9 + %arg7 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_0[%arg9 + %arg6 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_0[%arg9 + %arg6 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %2 = affine.load %alloca[%arg9 + %arg6 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_6[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_5[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %alloca_4[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_1[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %6 = arith.addf %5, %4 : f64 + affine.store %6, %alloca_1[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_1[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + affine.store %0, %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + } + } + } + } + %alloca_21 = memref.alloca() : memref<128xf64> + %alloca_22 = memref.alloca() : memref<128xf64> + %alloca_23 = memref.alloca() : memref<1500xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 6 { + affine.for %arg7 = 0 to 125 { + %0 = affine.load %arg2[%arg7 + %arg5 * 2250 + %arg6 * 125 + 750] : memref + affine.store %0, %alloca_23[%arg7 + %arg5 * 750 + %arg6 * 125] : memref<1500xf64> + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %arg3[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4 + 64] : memref + affine.store %0, %alloca_22[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %1 = affine.load %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4 + 64] : memref + affine.store %1, %alloca_21[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + %alloca_24 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_25 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_26 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_27 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_28 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_29 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_30 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_31 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_32 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_33 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_34 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_35 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_36 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_37 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_38 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_39 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_40 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_22[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_40[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_22[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = affine.load %arg1[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_39[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_39[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_38[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_40[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_37[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_40[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_36[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_38[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_35[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_37[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_34[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_36[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_33[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_23[%arg6 * 25 + %arg9 + %arg7 * 5 + %arg5 * 750] : memref<1500xf64> + %2 = affine.load %alloca_35[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_23[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 125] : memref<1500xf64> + %5 = affine.load %alloca_34[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_23[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 250] : memref<1500xf64> + %9 = affine.load %alloca_33[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca[%arg9 + %arg8 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg10, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_32[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_23[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 125] : memref<1500xf64> + %2 = affine.load %alloca_35[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_23[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 375] : memref<1500xf64> + %5 = affine.load %alloca_34[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_23[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 500] : memref<1500xf64> + %9 = affine.load %alloca_33[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca_0[%arg9 + %arg8 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg10, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_31[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_23[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 250] : memref<1500xf64> + %2 = affine.load %alloca_35[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_23[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 500] : memref<1500xf64> + %5 = affine.load %alloca_34[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_23[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 625] : memref<1500xf64> + %9 = affine.load %alloca_33[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca_0[%arg9 + %arg8 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg10, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_30[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_32[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_0[%arg9 + %arg7 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_29[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_31[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %2 = affine.load %alloca[%arg9 + %arg7 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_28[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_30[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_0[%arg9 + %arg7 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_27[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_29[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_0[%arg9 + %arg6 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_26[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_28[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_0[%arg9 + %arg6 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_25[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_27[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %2 = affine.load %alloca[%arg9 + %arg6 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_24[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_26[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_25[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %alloca_24[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_21[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %6 = arith.addf %5, %4 : f64 + affine.store %6, %alloca_21[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_21[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + affine.store %0, %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4 + 64] : memref + } + } + } + } + %alloca_41 = memref.alloca() : memref<128xf64> + %alloca_42 = memref.alloca() : memref<128xf64> + %alloca_43 = memref.alloca() : memref<1500xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 6 { + affine.for %arg7 = 0 to 125 { + %0 = affine.load %arg2[%arg7 + %arg5 * 2250 + %arg6 * 125 + 1500] : memref + affine.store %0, %alloca_43[%arg7 + %arg5 * 750 + %arg6 * 125] : memref<1500xf64> + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %arg3[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4 + 128] : memref + affine.store %0, %alloca_42[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %1 = affine.load %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4 + 128] : memref + affine.store %1, %alloca_41[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + %alloca_44 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_45 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_46 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_47 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_48 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_49 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_50 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_51 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_52 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_53 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_54 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_55 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_56 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_57 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_58 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_59 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_60 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_42[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_60[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_42[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = affine.load %arg1[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_59[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_59[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_58[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_60[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_57[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_60[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_56[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_58[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_55[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_57[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_54[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_56[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_53[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_43[%arg6 * 25 + %arg9 + %arg7 * 5 + %arg5 * 750] : memref<1500xf64> + %2 = affine.load %alloca_55[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_43[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 125] : memref<1500xf64> + %5 = affine.load %alloca_54[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_43[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 250] : memref<1500xf64> + %9 = affine.load %alloca_53[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca[%arg9 + %arg8 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg10, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_52[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_43[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 125] : memref<1500xf64> + %2 = affine.load %alloca_55[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_43[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 375] : memref<1500xf64> + %5 = affine.load %alloca_54[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_43[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 500] : memref<1500xf64> + %9 = affine.load %alloca_53[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca_0[%arg9 + %arg8 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg10, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_51[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_43[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 250] : memref<1500xf64> + %2 = affine.load %alloca_55[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_43[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 500] : memref<1500xf64> + %5 = affine.load %alloca_54[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %alloca_43[%arg6 * 25 + %arg9 + %arg5 * 750 + %arg7 * 5 + 625] : memref<1500xf64> + %9 = affine.load %alloca_53[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %alloca_0[%arg9 + %arg8 * 5] : memref<20xf64> + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg10, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_50[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_52[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_0[%arg9 + %arg7 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_49[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_51[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %2 = affine.load %alloca[%arg9 + %arg7 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_48[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_50[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_0[%arg9 + %arg7 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_47[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_49[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_0[%arg9 + %arg6 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_46[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_48[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_0[%arg9 + %arg6 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_45[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_47[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %2 = affine.load %alloca[%arg9 + %arg6 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_44[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_46[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_45[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %alloca_44[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_41[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %6 = arith.addf %5, %4 : f64 + affine.store %6, %alloca_41[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_41[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + affine.store %0, %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4 + 128] : memref + } + } + } + } + return + } + func.func @mfem_pa_vector_convection_nl_apply_3d_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<750xf64> + %alloca_0 = memref.alloca() : memref<2250xf64> + %alloca_1 = memref.alloca() : memref<750xf64> + %alloca_2 = memref.alloca() : memref<20xf64> + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %0 = affine.load %arg0[%arg5 + %arg6 * 4] : memref + affine.store %0, %alloca_2[%arg6 + %arg5 * 5] : memref<20xf64> + } + } + %alloca_3 = memref.alloca() : memref<750xf64> + %alloca_4 = memref.alloca() : memref<250xf64> + %alloca_5 = memref.alloca() : memref<128xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %arg3[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + affine.store %0, %alloca_5[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + %alloca_6 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg6 * 25 + %arg8 + %arg7 * 5 + %arg5 * 125] : memref<250xf64> + } + } + } + } + %alloca_8 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = affine.load %arg1[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg5 * 375 + %arg6 + %arg8 * 25 + %arg7 * 5] : memref<750xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg5 * 375 + %arg6 + %arg8 * 25 + %arg7 * 5 + 125] : memref<750xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg5 * 375 + %arg6 + %arg8 * 25 + %arg7 * 5 + 250] : memref<750xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.load %alloca_4[%arg6 * 25 + %arg8 + %arg7 * 5 + %arg5 * 125] : memref<250xf64> + affine.store %0, %alloca_1[%arg6 * 25 + %arg8 + %arg5 * 375 + %arg7 * 5] : memref<750xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.load %alloca_3[%arg5 * 375 + %arg6 * 125 + %arg7 + %arg9 * 25 + %arg8 * 5] : memref<750xf64> + affine.store %0, %alloca_0[%arg5 * 1125 + %arg7 * 25 + %arg9 + %arg8 * 5 + %arg6 * 125] : memref<2250xf64> + } + } + } + } + } + %alloca_13 = memref.alloca() : memref<750xf64> + %alloca_14 = memref.alloca() : memref<250xf64> + %alloca_15 = memref.alloca() : memref<128xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %arg3[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4 + 64] : memref + affine.store %0, %alloca_15[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + %alloca_16 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_17 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_17[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_17[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_16[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_16[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_14[%arg6 * 25 + %arg8 + %arg7 * 5 + %arg5 * 125] : memref<250xf64> + } + } + } + } + %alloca_18 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_21 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_22 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_22[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = affine.load %arg1[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_21[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_21[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_20[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_22[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_19[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_22[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_18[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_20[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg5 * 375 + %arg6 + %arg8 * 25 + %arg7 * 5] : memref<750xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_19[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg5 * 375 + %arg6 + %arg8 * 25 + %arg7 * 5 + 125] : memref<750xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_18[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg5 * 375 + %arg6 + %arg8 * 25 + %arg7 * 5 + 250] : memref<750xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.load %alloca_14[%arg6 * 25 + %arg8 + %arg7 * 5 + %arg5 * 125] : memref<250xf64> + affine.store %0, %alloca_1[%arg6 * 25 + %arg8 + %arg5 * 375 + %arg7 * 5 + 125] : memref<750xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.load %alloca_13[%arg5 * 375 + %arg6 * 125 + %arg7 + %arg9 * 25 + %arg8 * 5] : memref<750xf64> + affine.store %0, %alloca_0[%arg5 * 1125 + %arg7 * 25 + %arg9 + %arg8 * 5 + %arg6 * 125 + 375] : memref<2250xf64> + } + } + } + } + } + %alloca_23 = memref.alloca() : memref<750xf64> + %alloca_24 = memref.alloca() : memref<250xf64> + %alloca_25 = memref.alloca() : memref<128xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %arg3[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4 + 128] : memref + affine.store %0, %alloca_25[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + %alloca_26 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_27 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_25[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_27[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_27[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_26[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_26[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_24[%arg6 * 25 + %arg8 + %arg7 * 5 + %arg5 * 125] : memref<250xf64> + } + } + } + } + %alloca_28 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_29 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_30 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_31 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_32 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_25[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_32[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_25[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = affine.load %arg1[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_31[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_31[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_30[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_32[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_29[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_32[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_28[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_30[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_23[%arg5 * 375 + %arg6 + %arg8 * 25 + %arg7 * 5] : memref<750xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_29[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_23[%arg5 * 375 + %arg6 + %arg8 * 25 + %arg7 * 5 + 125] : memref<750xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_28[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_23[%arg5 * 375 + %arg6 + %arg8 * 25 + %arg7 * 5 + 250] : memref<750xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.load %alloca_24[%arg6 * 25 + %arg8 + %arg7 * 5 + %arg5 * 125] : memref<250xf64> + affine.store %0, %alloca_1[%arg6 * 25 + %arg8 + %arg5 * 375 + %arg7 * 5 + 250] : memref<750xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.load %alloca_23[%arg5 * 375 + %arg6 * 125 + %arg7 + %arg9 * 25 + %arg8 * 5] : memref<750xf64> + affine.store %0, %alloca_0[%arg5 * 1125 + %arg7 * 25 + %arg9 + %arg8 * 5 + %arg6 * 125 + 750] : memref<2250xf64> + } + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 3 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_1[%arg7 * 25 + %arg5 * 375 + %arg9 + %arg8 * 5 + %arg10 * 125] : memref<750xf64> + %2 = affine.for %arg12 = 0 to 3 iter_args(%arg13 = %arg11) -> (f64) { + %3 = affine.load %alloca_0[%arg5 * 1125 + %arg6 * 375 + %arg7 * 25 + %arg9 + %arg8 * 5 + %arg12 * 125] : memref<2250xf64> + %4 = arith.mulf %1, %3 : f64 + %5 = affine.load %arg2[%arg5 * 1125 + %arg10 * 375 + %arg7 * 25 + %arg9 + %arg8 * 5 + %arg12 * 125] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %arg13, %6 : f64 + affine.yield %7 : f64 + } + affine.yield %2 : f64 + } + affine.store %0, %alloca[%arg7 * 25 + %arg5 * 375 + %arg9 + %arg8 * 5 + %arg6 * 125] : memref<750xf64> + } + } + } + } + } + %alloca_33 = memref.alloca() : memref<128xf64> + %alloca_34 = memref.alloca() : memref<250xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 125 { + %0 = affine.load %alloca[%arg6 + %arg5 * 375] : memref<750xf64> + affine.store %0, %alloca_34[%arg6 + %arg5 * 125] : memref<250xf64> + } + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + affine.store %0, %alloca_33[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + %alloca_35 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_36 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_37 = memref.alloca() : memref<2x5x5x4xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_34[%arg6 * 25 + %arg9 + %arg7 * 5 + %arg5 * 125] : memref<250xf64> + %2 = affine.load %alloca_2[%arg9 + %arg8 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_37[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_37[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_2[%arg9 + %arg7 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_36[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_36[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_2[%arg9 + %arg6 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_35[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_35[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_33[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_33[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_33[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + affine.store %0, %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + } + } + } + } + %alloca_38 = memref.alloca() : memref<128xf64> + %alloca_39 = memref.alloca() : memref<250xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 125 { + %0 = affine.load %alloca[%arg6 + %arg5 * 375 + 125] : memref<750xf64> + affine.store %0, %alloca_39[%arg6 + %arg5 * 125] : memref<250xf64> + } + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4 + 64] : memref + affine.store %0, %alloca_38[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + %alloca_40 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_41 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_42 = memref.alloca() : memref<2x5x5x4xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_39[%arg6 * 25 + %arg9 + %arg7 * 5 + %arg5 * 125] : memref<250xf64> + %2 = affine.load %alloca_2[%arg9 + %arg8 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_42[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_42[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_2[%arg9 + %arg7 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_41[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_41[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_2[%arg9 + %arg6 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_40[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_40[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_38[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_38[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_38[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + affine.store %0, %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4 + 64] : memref + } + } + } + } + %alloca_43 = memref.alloca() : memref<128xf64> + %alloca_44 = memref.alloca() : memref<250xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 125 { + %0 = affine.load %alloca[%arg6 + %arg5 * 375 + 250] : memref<750xf64> + affine.store %0, %alloca_44[%arg6 + %arg5 * 125] : memref<250xf64> + } + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4 + 128] : memref + affine.store %0, %alloca_43[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + %alloca_45 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_46 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_47 = memref.alloca() : memref<2x5x5x4xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_44[%arg6 * 25 + %arg9 + %arg7 * 5 + %arg5 * 125] : memref<250xf64> + %2 = affine.load %alloca_2[%arg9 + %arg8 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_47[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_47[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_2[%arg9 + %arg7 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_46[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_46[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_2[%arg9 + %arg6 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_45[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_45[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_43[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_43[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_43[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + affine.store %0, %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4 + 128] : memref + } + } + } + } + return + } + func.func @mfem_pa_diffusion_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_14 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_15 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg7 * 64 + %arg11 + %arg8 * 16 + %arg9 * 4] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_15[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg7 * 64 + %arg11 + %arg8 * 16 + %arg9 * 4] : memref + %2 = affine.load %arg1[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_14[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg9 * 5 + %arg7 * 750] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 125] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 250] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg3[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_7[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 125] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 375] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 500] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 250] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 500] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 625] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.load %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg6[%arg7 * 64 + %arg10 + %arg8 * 16 + %arg9 * 4] : memref + %6 = arith.addf %5, %4 : f64 + affine.store %6, %arg6[%arg7 * 64 + %arg10 + %arg8 * 16 + %arg9 * 4] : memref + } + } + } + } + return + } + func.func @mfem_pa_discrete_gradient_apply_3d_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<750xf64> + %alloca_0 = memref.alloca() : memref<750xf64> + %alloca_1 = memref.alloca() : memref<20xf64> + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %0 = affine.load %arg0[%arg5 + %arg6 * 4] : memref + affine.store %0, %alloca_1[%arg6 + %arg5 * 5] : memref<20xf64> + } + } + %alloca_2 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_3 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_4 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_5 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_6 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg3[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref + %2 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg3[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref + %2 = affine.load %arg1[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg5 * 375 + %arg6 + %arg8 * 25 + %arg7 * 5] : memref<750xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg5 * 375 + %arg6 + %arg8 * 25 + %arg7 * 5 + 125] : memref<750xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg9 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg5 * 375 + %arg6 + %arg8 * 25 + %arg7 * 5 + 250] : memref<750xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 3 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 3 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_0[%arg5 * 375 + %arg10 * 125 + %arg7 + %arg9 * 25 + %arg8 * 5] : memref<750xf64> + %2 = affine.load %arg2[%arg5 * 1125 + %arg6 * 375 + %arg7 * 25 + %arg9 + %arg8 * 5 + %arg10 * 125] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7 * 25 + %arg5 * 375 + %arg9 + %arg8 * 5 + %arg6 * 125] : memref<750xf64> + } + } + } + } + } + %alloca_7 = memref.alloca() : memref<128xf64> + %alloca_8 = memref.alloca() : memref<250xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 125 { + %0 = affine.load %alloca[%arg6 + %arg5 * 375] : memref<750xf64> + affine.store %0, %alloca_8[%arg6 + %arg5 * 125] : memref<250xf64> + } + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + affine.store %0, %alloca_7[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + %alloca_9 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x4xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg6 * 25 + %arg9 + %arg7 * 5 + %arg5 * 125] : memref<250xf64> + %2 = affine.load %alloca_1[%arg9 + %arg8 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_1[%arg9 + %arg7 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_1[%arg9 + %arg6 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_9[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_7[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_7[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_7[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + affine.store %0, %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + } + } + } + } + %alloca_12 = memref.alloca() : memref<128xf64> + %alloca_13 = memref.alloca() : memref<250xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 125 { + %0 = affine.load %alloca[%arg6 + %arg5 * 375 + 125] : memref<750xf64> + affine.store %0, %alloca_13[%arg6 + %arg5 * 125] : memref<250xf64> + } + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4 + 64] : memref + affine.store %0, %alloca_12[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + %alloca_14 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_15 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_16 = memref.alloca() : memref<2x5x5x4xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg6 * 25 + %arg9 + %arg7 * 5 + %arg5 * 125] : memref<250xf64> + %2 = affine.load %alloca_1[%arg9 + %arg8 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_16[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_16[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_1[%arg9 + %arg7 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_15[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_1[%arg9 + %arg6 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_14[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_14[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_12[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_12[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_12[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + affine.store %0, %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4 + 64] : memref + } + } + } + } + %alloca_17 = memref.alloca() : memref<128xf64> + %alloca_18 = memref.alloca() : memref<250xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 125 { + %0 = affine.load %alloca[%arg6 + %arg5 * 375 + 250] : memref<750xf64> + affine.store %0, %alloca_18[%arg6 + %arg5 * 125] : memref<250xf64> + } + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4 + 128] : memref + affine.store %0, %alloca_17[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + %alloca_19 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_20 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_21 = memref.alloca() : memref<2x5x5x4xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_18[%arg6 * 25 + %arg9 + %arg7 * 5 + %arg5 * 125] : memref<250xf64> + %2 = affine.load %alloca_1[%arg9 + %arg8 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_21[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_21[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %2 = affine.load %alloca_1[%arg9 + %arg7 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_20[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_20[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %2 = affine.load %alloca_1[%arg9 + %arg6 * 5] : memref<20xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_19[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_19[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_17[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + %2 = arith.addf %1, %0 : f64 + affine.store %2, %alloca_17[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca_17[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref<128xf64> + affine.store %0, %arg4[%arg5 * 192 + %arg8 + %arg6 * 16 + %arg7 * 4 + 128] : memref + } + } + } + } + return + } + func.func @mfem_pa_discrete_divergence_apply_3d_direct(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x5x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %arg10) -> (f64) { + %2 = affine.load %arg0[%arg11 + %arg6 * 4] : memref + %3 = affine.load %arg2[%arg6 * 25 + %arg5 * 1125 + %arg8 + %arg7 * 5 + %arg9 * 375] : memref + %4 = affine.load %arg2[%arg5 * 1125 + %arg9 * 375 + %arg8 + %arg6 * 25 + %arg7 * 5 + 125] : memref + %5 = affine.load %arg1[%arg11 + %arg6 * 4] : memref + %6 = affine.load %arg2[%arg5 * 1125 + %arg9 * 375 + %arg8 + %arg6 * 25 + %arg7 * 5 + 250] : memref + %7 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %arg12) -> (f64) { + %8 = affine.load %arg0[%arg13 + %arg7 * 4] : memref + %9 = affine.load %arg1[%arg13 + %arg7 * 4] : memref + %10 = affine.for %arg15 = 0 to 4 iter_args(%arg16 = %arg14) -> (f64) { + %11 = affine.load %arg3[%arg5 * 192 + %arg9 * 64 + %arg15 + %arg11 * 16 + %arg13 * 4] : memref + %12 = affine.load %arg1[%arg15 + %arg8 * 4] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.mulf %13, %8 : f64 + %15 = arith.mulf %14, %2 : f64 + %16 = arith.mulf %15, %3 : f64 + %17 = arith.addf %arg16, %16 : f64 + %18 = affine.load %arg0[%arg15 + %arg8 * 4] : memref + %19 = arith.mulf %11, %18 : f64 + %20 = arith.mulf %19, %9 : f64 + %21 = arith.mulf %20, %2 : f64 + %22 = arith.mulf %21, %4 : f64 + %23 = arith.addf %17, %22 : f64 + %24 = arith.mulf %19, %8 : f64 + %25 = arith.mulf %24, %5 : f64 + %26 = arith.mulf %25, %6 : f64 + %27 = arith.addf %23, %26 : f64 + affine.yield %27 : f64 + } + affine.yield %10 : f64 + } + affine.yield %7 : f64 + } + affine.yield %1 : f64 + } + affine.store %0, %alloca[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %3 = affine.load %arg0[%arg6 + %arg9 * 4] : memref + %4 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %arg10) -> (f64) { + %5 = affine.load %arg0[%arg7 + %arg11 * 4] : memref + %6 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %arg12) -> (f64) { + %7 = affine.load %alloca[%arg5, %arg9, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %arg0[%arg8 + %arg13 * 4] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.mulf %9, %5 : f64 + %11 = arith.mulf %10, %3 : f64 + %12 = arith.addf %arg14, %11 : f64 + affine.yield %12 : f64 + } + affine.yield %6 : f64 + } + affine.yield %4 : f64 + } + %1 = affine.load %arg4[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg4[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + } + } + } + } + return + } + func.func @mfem_interp_grad_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x5x5xf64> + %alloca_0 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_1 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg4 * 64 + %arg8 + %arg5 * 16 + %arg6 * 4] : memref + %2 = affine.load %arg1[%arg8 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg4, %arg5, %arg6, %arg7] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg4 * 64 + %arg8 + %arg5 * 16 + %arg6 * 4] : memref + %2 = affine.load %arg2[%arg8 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg4, %arg5, %arg6, %arg7] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg4, %arg5, %arg8, %arg7] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg8 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg4, %arg5, %arg6, %arg7] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg4, %arg5, %arg8, %arg7] : memref<2x4x4x5xf64> + %2 = affine.load %arg2[%arg8 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg4, %arg5, %arg6, %arg7] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg4, %arg5, %arg8, %arg7] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg8 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg4, %arg5, %arg6, %arg7] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca_1[%arg4, %arg8, %arg6, %arg7] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg8 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %arg3[%arg4 * 375 + %arg5 + %arg7 * 25 + %arg6 * 5] : memref + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca_0[%arg4, %arg8, %arg6, %arg7] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg8 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %arg3[%arg4 * 375 + %arg5 + %arg7 * 25 + %arg6 * 5 + 125] : memref + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg4, %arg8, %arg6, %arg7] : memref<2x4x5x5xf64> + %2 = affine.load %arg2[%arg8 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %arg3[%arg4 * 375 + %arg5 + %arg7 * 25 + %arg6 * 5 + 250] : memref + } + } + } + } + return + } + func.func @mfem_pa_mass_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_2 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %2 = affine.load %arg3[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %2 = affine.load %alloca_3[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %2 = affine.load %alloca_2[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.load %arg2[%arg5 * 125 + %arg8 + %arg6 * 25 + %arg7 * 5] : memref + %1 = affine.load %alloca_1[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + %2 = arith.mulf %1, %0 : f64 + affine.store %2, %alloca_1[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg9 + %arg8 * 5] : memref + %2 = affine.load %alloca_1[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg9 + %arg7 * 5] : memref + %2 = affine.load %alloca_0[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %3 = affine.load %arg1[%arg9 + %arg6 * 5] : memref + %4 = affine.load %alloca[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg10, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg4[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg4[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pa_operators_3d.matched.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pa_operators_3d.matched.mlir new file mode 100644 index 000000000000..e1caec8cfb35 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pa_operators_3d.matched.mlir @@ -0,0 +1,2311 @@ +#map = affine_map<(d0, d1) -> (d1 * 4 + d0)> +#map1 = affine_map<(d0, d1) -> (d1 + d0 * 5)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 192 + d1 * 16 + d2 * 4)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map14 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 125 + d1 * 25 + d2 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 192 + d1 * 16 + d2 * 4 + 64)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 192 + d1 * 16 + d2 * 4 + 128)> +#map21 = affine_map<(d0, d1, d2) -> (d2 + d0 * 2250 + d1 * 125)> +#map22 = affine_map<(d0, d1, d2) -> (d2 + d0 * 750 + d1 * 125)> +#map23 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map24 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 750)> +#map25 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 125)> +#map26 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 250)> +#map27 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 375)> +#map28 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 500)> +#map29 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 625)> +#map30 = affine_map<(d0, d1, d2) -> (d2 + d0 * 2250 + d1 * 125 + 750)> +#map31 = affine_map<(d0, d1, d2) -> (d2 + d0 * 2250 + d1 * 125 + 1500)> +#map32 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 125)> +#map33 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5)> +#map34 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 125)> +#map35 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 250)> +#map36 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d0 * 375 + d2 * 5)> +#map37 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 25 + d2 + d1 * 125 + d0 * 375 + d3 * 5)> +#map38 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 25 + d0 * 1125 + d3 * 5 + d1 * 125)> +#map39 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d0 * 375 + d2 * 5 + 125)> +#map40 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 25 + d0 * 1125 + d3 * 5 + d1 * 125 + 375)> +#map41 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d0 * 375 + d2 * 5 + 250)> +#map42 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 25 + d0 * 1125 + d3 * 5 + d1 * 125 + 750)> +#map43 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 25 + d0 * 375 + d3 * 5 + d1 * 125)> +#map44 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 * 125 + d4 + d2 * 25 + d0 * 375 + d3 * 5)> +#map45 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 * 125 + d4 + d2 * 25 + d1 * 375 + d0 * 1125 + d3 * 5)> +#map46 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 * 125 + d5 * 375 + d0 * 1125 + d2 * 25 + d4 + d3 * 5)> +#map47 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map48 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4)> +#map49 = affine_map<(d0, d1) -> (d1 + d0 * 375)> +#map50 = affine_map<(d0, d1) -> (d1 + d0 * 125)> +#map51 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 125)> +#map52 = affine_map<(d0, d1) -> (d1 + d0 * 375 + 125)> +#map53 = affine_map<(d0, d1) -> (d1 + d0 * 375 + 250)> +#map54 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d5 * 125 + d0 * 375 + d2 + d4 * 25 + d3 * 5)> +#map55 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d5 * 125 + d4 + d2 * 25 + d1 * 375 + d0 * 1125 + d3 * 5)> +#map56 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map57 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4)> +#map58 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d5 + d1 * 4)> +#map59 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4 * 375 + d3 + d1 * 25 + d0 * 1125 + d2 * 5)> +#map60 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4 * 375 + d0 * 1125 + d3 + d1 * 25 + d2 * 5 + 125)> +#map61 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4 * 375 + d0 * 1125 + d3 + d1 * 25 + d2 * 5 + 250)> +#map62 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d6 + d2 * 4)> +#map63 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d7 + d4 * 64 + d0 * 192 + d5 * 16 + d6 * 4)> +#map64 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d7 + d3 * 4)> +#map65 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map66 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +#map67 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 * 4 + d1)> +#map68 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 * 4 + d2)> +#map69 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 * 4 + d3)> +#map70 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +#map71 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_navier_tgv_pa_operators_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref, %arg11: memref, %arg12: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c125 = arith.constant 125 : index + %c3 = arith.constant 3 : index + %c6 = arith.constant 6 : index + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %0 = bufferization.to_tensor %arg0 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = bufferization.to_tensor %arg5 : memref + %6 = bufferization.to_tensor %arg6 : memref + %7 = bufferization.to_tensor %arg7 : memref + %8 = bufferization.to_tensor %arg8 : memref + %9 = bufferization.to_tensor %arg9 : memref + %10 = bufferization.to_tensor %arg10 : memref + %11 = bufferization.to_tensor %arg11 : memref + %12 = bufferization.to_tensor %arg12 : memref + %13 = tensor.empty() : tensor<20xf64> + %14 = polygeist.submap(%0, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %15 = polygeist.submap(%13, %c4, %c5) {map = #map1} : (tensor<20xf64>, index, index) -> tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%14 : tensor) outs(%15 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %17 = polygeist.submapInverse(%13, %16, %c4, %c5) {map = #map1} : (tensor<20xf64>, tensor, index, index) -> tensor<20xf64> + %18 = tensor.empty() : tensor<128xf64> + %19 = tensor.empty() : tensor<128xf64> + %20 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %21 = polygeist.submap(%19, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%20 : tensor) outs(%21 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %23 = polygeist.submapInverse(%19, %22, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %24 = polygeist.submap(%11, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %25 = polygeist.submap(%18, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %26 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%24 : tensor) outs(%25 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %27 = polygeist.submapInverse(%18, %26, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %28 = tensor.empty() : tensor<2x5x4x4xf64> + %29 = tensor.empty() : tensor<2x5x5x4xf64> + %30 = tensor.empty() : tensor<2x5x5x5xf64> + %31 = tensor.empty() : tensor<2x4x5x5xf64> + %32 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice = tensor.extract_slice %32[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %33 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice = tensor.insert_slice %33 into %32[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %34 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %35 = polygeist.submap(%23, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %36 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%34, %35 : tensor, tensor) outs(%inserted_slice : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_0 = tensor.extract_slice %31[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %38 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice_1 = tensor.extract_slice %36[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %39 = kernel.launch @cutensornetContraction2_f64_r5r4r4(%38, %extracted_slice_1, %extracted_slice_0) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_2 = tensor.extract_slice %30[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %41 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %42 = kernel.launch @cutensornetContraction2_f64_r5r4r4(%41, %39, %extracted_slice_2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %43 = polygeist.submap(%5, %c2, %c5, %c5, %c5) {map = #map14} : (tensor, index, index, index, index) -> tensor + %44 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%43 : tensor) outs(%42 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.mulf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %extracted_slice_3 = tensor.extract_slice %29[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %45 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_3 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %46 = polygeist.submap(%17, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %47 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%46, %44 : tensor, tensor) outs(%45 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_4 = tensor.extract_slice %28[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %48 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_4 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %49 = polygeist.submap(%17, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %50 = linalg.generic {doc = "", indexing_maps = [#map8, #map11, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%49, %47 : tensor, tensor) outs(%48 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %51 = polygeist.submap(%17, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %52 = polygeist.submap(%27, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor<2x4x4x4xf64> + %53 = linalg.generic {doc = "", indexing_maps = [#map8, #map13, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%51, %50 : tensor, tensor) outs(%52 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x4xf64> + %54 = polygeist.submapInverse(%27, %53, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor<2x4x4x4xf64>, index, index, index, index) -> tensor<128xf64> + %55 = polygeist.submap(%54, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %56 = polygeist.submap(%11, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %57 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%55 : tensor) outs(%56 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %58 = polygeist.submapInverse(%11, %57, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, tensor, index, index, index, index) -> tensor + %59 = tensor.empty() : tensor<128xf64> + %60 = tensor.empty() : tensor<128xf64> + %61 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %62 = polygeist.submap(%60, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%61 : tensor) outs(%62 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %64 = polygeist.submapInverse(%60, %63, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %65 = polygeist.submap(%58, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %66 = polygeist.submap(%59, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %67 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%65 : tensor) outs(%66 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %68 = polygeist.submapInverse(%59, %67, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %69 = tensor.empty() : tensor<2x5x4x4xf64> + %70 = tensor.empty() : tensor<2x5x5x4xf64> + %71 = tensor.empty() : tensor<2x5x5x5xf64> + %72 = tensor.empty() : tensor<2x4x5x5xf64> + %73 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_5 = tensor.extract_slice %73[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %74 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_5 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_6 = tensor.insert_slice %74 into %73[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %75 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %76 = polygeist.submap(%64, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %77 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%75, %76 : tensor, tensor) outs(%inserted_slice_6 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_7 = tensor.extract_slice %72[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %79 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice_8 = tensor.extract_slice %77[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %80 = kernel.launch @cutensornetContraction2_f64_r5r4r4(%79, %extracted_slice_8, %extracted_slice_7) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_9 = tensor.extract_slice %71[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %82 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %83 = kernel.launch @cutensornetContraction2_f64_r5r4r4(%82, %80, %extracted_slice_9) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %84 = polygeist.submap(%5, %c2, %c5, %c5, %c5) {map = #map14} : (tensor, index, index, index, index) -> tensor + %85 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%84 : tensor) outs(%83 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.mulf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %extracted_slice_10 = tensor.extract_slice %70[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %86 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_10 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %87 = polygeist.submap(%17, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %88 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%87, %85 : tensor, tensor) outs(%86 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_11 = tensor.extract_slice %69[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %89 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_11 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %90 = polygeist.submap(%17, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %91 = linalg.generic {doc = "", indexing_maps = [#map8, #map11, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%90, %88 : tensor, tensor) outs(%89 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %92 = polygeist.submap(%17, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %93 = polygeist.submap(%68, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor<2x4x4x4xf64> + %94 = linalg.generic {doc = "", indexing_maps = [#map8, #map13, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%92, %91 : tensor, tensor) outs(%93 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x4xf64> + %95 = polygeist.submapInverse(%68, %94, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor<2x4x4x4xf64>, index, index, index, index) -> tensor<128xf64> + %96 = polygeist.submap(%95, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %97 = polygeist.submap(%58, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %98 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%96 : tensor) outs(%97 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %99 = polygeist.submapInverse(%58, %98, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %100 = tensor.empty() : tensor<128xf64> + %101 = tensor.empty() : tensor<128xf64> + %102 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %103 = polygeist.submap(%101, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %104 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%102 : tensor) outs(%103 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %105 = polygeist.submapInverse(%101, %104, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %106 = polygeist.submap(%99, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %107 = polygeist.submap(%100, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %108 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%106 : tensor) outs(%107 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %109 = polygeist.submapInverse(%100, %108, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %110 = tensor.empty() : tensor<2x5x4x4xf64> + %111 = tensor.empty() : tensor<2x5x5x4xf64> + %112 = tensor.empty() : tensor<2x5x5x5xf64> + %113 = tensor.empty() : tensor<2x4x5x5xf64> + %114 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_12 = tensor.extract_slice %114[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %115 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_12 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_13 = tensor.insert_slice %115 into %114[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %116 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %117 = polygeist.submap(%105, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %118 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%116, %117 : tensor, tensor) outs(%inserted_slice_13 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_14 = tensor.extract_slice %113[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %120 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %extracted_slice_15 = tensor.extract_slice %118[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %121 = kernel.launch @cutensornetContraction2_f64_r5r4r4(%120, %extracted_slice_15, %extracted_slice_14) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_16 = tensor.extract_slice %112[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %123 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %124 = kernel.launch @cutensornetContraction2_f64_r5r4r4(%123, %121, %extracted_slice_16) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + %125 = polygeist.submap(%5, %c2, %c5, %c5, %c5) {map = #map14} : (tensor, index, index, index, index) -> tensor + %126 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%125 : tensor) outs(%124 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.mulf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %extracted_slice_17 = tensor.extract_slice %111[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %127 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_17 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %128 = polygeist.submap(%17, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %129 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%128, %126 : tensor, tensor) outs(%127 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_18 = tensor.extract_slice %110[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %130 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_18 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %131 = polygeist.submap(%17, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %132 = linalg.generic {doc = "", indexing_maps = [#map8, #map11, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%131, %129 : tensor, tensor) outs(%130 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %133 = polygeist.submap(%17, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %134 = polygeist.submap(%109, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor<2x4x4x4xf64> + %135 = linalg.generic {doc = "", indexing_maps = [#map8, #map13, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%133, %132 : tensor, tensor) outs(%134 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x4xf64> + %136 = polygeist.submapInverse(%109, %135, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor<2x4x4x4xf64>, index, index, index, index) -> tensor<128xf64> + %137 = polygeist.submap(%136, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %138 = polygeist.submap(%99, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %139 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%137 : tensor) outs(%138 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %140 = polygeist.submapInverse(%99, %139, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, tensor, index, index, index, index) -> tensor + %141 = tensor.empty() : tensor<20xf64> + %142 = tensor.empty() : tensor<20xf64> + %143 = polygeist.submap(%0, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %144 = polygeist.submap(%142, %c4, %c5) {map = #map1} : (tensor<20xf64>, index, index) -> tensor + %145 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%143 : tensor) outs(%144 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %146 = polygeist.submapInverse(%142, %145, %c4, %c5) {map = #map1} : (tensor<20xf64>, tensor, index, index) -> tensor<20xf64> + %147 = polygeist.submap(%1, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %148 = polygeist.submap(%141, %c4, %c5) {map = #map1} : (tensor<20xf64>, index, index) -> tensor + %149 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%147 : tensor) outs(%148 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %150 = polygeist.submapInverse(%141, %149, %c4, %c5) {map = #map1} : (tensor<20xf64>, tensor, index, index) -> tensor<20xf64> + %151 = tensor.empty() : tensor<128xf64> + %152 = tensor.empty() : tensor<128xf64> + %153 = tensor.empty() : tensor<1500xf64> + %154 = polygeist.submap(%6, %c2, %c6, %c125) {map = #map21} : (tensor, index, index, index) -> tensor + %155 = polygeist.submap(%153, %c2, %c6, %c125) {map = #map22} : (tensor<1500xf64>, index, index, index) -> tensor + %156 = linalg.generic {doc = "", indexing_maps = [#map23, #map23], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%154 : tensor) outs(%155 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %157 = polygeist.submapInverse(%153, %156, %c2, %c6, %c125) {map = #map22} : (tensor<1500xf64>, tensor, index, index, index) -> tensor<1500xf64> + %158 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %159 = polygeist.submap(%152, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %160 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%158 : tensor) outs(%159 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %161 = polygeist.submapInverse(%152, %160, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %162 = polygeist.submap(%140, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %163 = polygeist.submap(%151, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %164 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%162 : tensor) outs(%163 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %165 = polygeist.submapInverse(%151, %164, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %166 = tensor.empty() : tensor<2x4x4x4xf64> + %167 = tensor.empty() : tensor<2x4x4x4xf64> + %168 = tensor.empty() : tensor<2x4x4x4xf64> + %169 = tensor.empty() : tensor<2x5x4x4xf64> + %170 = tensor.empty() : tensor<2x5x4x4xf64> + %171 = tensor.empty() : tensor<2x5x4x4xf64> + %172 = tensor.empty() : tensor<2x5x5x4xf64> + %173 = tensor.empty() : tensor<2x5x5x4xf64> + %174 = tensor.empty() : tensor<2x5x5x4xf64> + %175 = tensor.empty() : tensor<2x5x5x5xf64> + %176 = tensor.empty() : tensor<2x5x5x5xf64> + %177 = tensor.empty() : tensor<2x5x5x5xf64> + %178 = tensor.empty() : tensor<2x4x5x5xf64> + %179 = tensor.empty() : tensor<2x4x5x5xf64> + %180 = tensor.empty() : tensor<2x4x5x5xf64> + %181 = tensor.empty() : tensor<2x4x4x5xf64> + %182 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_19 = tensor.extract_slice %182[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %183 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_19 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_20 = tensor.insert_slice %183 into %182[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %184 = polygeist.submap(%161, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %185 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %186 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%184, %185 : tensor, tensor) outs(%inserted_slice_20 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_21 = tensor.extract_slice %181[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %187 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_21 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_22 = tensor.insert_slice %187 into %181[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %188 = polygeist.submap(%161, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %189 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %190 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%188, %189 : tensor, tensor) outs(%inserted_slice_22 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_23 = tensor.extract_slice %180[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_24 = tensor.extract_slice %190[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %192 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %193 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_24, %192, %extracted_slice_23) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_25 = tensor.extract_slice %179[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_26 = tensor.extract_slice %186[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %195 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %196 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_26, %195, %extracted_slice_25) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_27 = tensor.extract_slice %178[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_28 = tensor.extract_slice %186[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %198 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %199 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_28, %198, %extracted_slice_27) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_29 = tensor.extract_slice %177[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %201 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %202 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%193, %201, %extracted_slice_29) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_30 = tensor.extract_slice %176[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %204 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %205 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%196, %204, %extracted_slice_30) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_31 = tensor.extract_slice %175[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %207 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %208 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%199, %207, %extracted_slice_31) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_32 = tensor.extract_slice %174[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %209 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_32 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %210 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map24} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %211 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %212 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %213 = polygeist.submap(%150, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %214 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%210, %202, %211, %205, %212, %208, %213 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%209 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_33 = tensor.extract_slice %173[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %215 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_33 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %216 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %217 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map27} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %218 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %219 = polygeist.submap(%146, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %220 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%216, %202, %217, %205, %218, %208, %219 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%215 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_34 = tensor.extract_slice %172[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %221 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_34 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %222 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %223 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %224 = polygeist.submap(%157, %c2, %c5, %c5, %c4, %c5) {map = #map29} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %225 = polygeist.submap(%146, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %226 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%222, %202, %223, %205, %224, %208, %225 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%221 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_35 = tensor.extract_slice %171[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %227 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_35 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %228 = polygeist.submap(%146, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %229 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%214, %228 : tensor, tensor) outs(%227 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_36 = tensor.extract_slice %170[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %230 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_36 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %231 = polygeist.submap(%150, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %232 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%220, %231 : tensor, tensor) outs(%230 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_37 = tensor.extract_slice %169[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %233 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_37 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %234 = polygeist.submap(%146, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %235 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%226, %234 : tensor, tensor) outs(%233 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_38 = tensor.extract_slice %168[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %236 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_38 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %237 = polygeist.submap(%146, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %238 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%229, %237 : tensor, tensor) outs(%236 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_39 = tensor.extract_slice %167[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %239 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_39 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %240 = polygeist.submap(%146, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %241 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%232, %240 : tensor, tensor) outs(%239 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_40 = tensor.extract_slice %166[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %242 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_40 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %243 = polygeist.submap(%150, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %244 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%235, %243 : tensor, tensor) outs(%242 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %245 = polygeist.submap(%165, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %246 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%238, %241, %244 : tensor, tensor, tensor) outs(%245 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %out: f64): + %1034 = arith.addf %in, %in_192 : f64 + %1035 = arith.addf %1034, %in_193 : f64 + %1036 = arith.addf %out, %1035 : f64 + linalg.yield %1036 : f64 + } -> tensor + %247 = polygeist.submapInverse(%165, %246, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %248 = polygeist.submap(%247, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %249 = polygeist.submap(%140, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %250 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%248 : tensor) outs(%249 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %251 = polygeist.submapInverse(%140, %250, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, tensor, index, index, index, index) -> tensor + %252 = tensor.empty() : tensor<128xf64> + %253 = tensor.empty() : tensor<128xf64> + %254 = tensor.empty() : tensor<1500xf64> + %255 = polygeist.submap(%6, %c2, %c6, %c125) {map = #map30} : (tensor, index, index, index) -> tensor + %256 = polygeist.submap(%254, %c2, %c6, %c125) {map = #map22} : (tensor<1500xf64>, index, index, index) -> tensor + %257 = linalg.generic {doc = "", indexing_maps = [#map23, #map23], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%255 : tensor) outs(%256 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %258 = polygeist.submapInverse(%254, %257, %c2, %c6, %c125) {map = #map22} : (tensor<1500xf64>, tensor, index, index, index) -> tensor<1500xf64> + %259 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %260 = polygeist.submap(%253, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %261 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%259 : tensor) outs(%260 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %262 = polygeist.submapInverse(%253, %261, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %263 = polygeist.submap(%251, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %264 = polygeist.submap(%252, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %265 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%263 : tensor) outs(%264 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %266 = polygeist.submapInverse(%252, %265, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %267 = tensor.empty() : tensor<2x4x4x4xf64> + %268 = tensor.empty() : tensor<2x4x4x4xf64> + %269 = tensor.empty() : tensor<2x4x4x4xf64> + %270 = tensor.empty() : tensor<2x5x4x4xf64> + %271 = tensor.empty() : tensor<2x5x4x4xf64> + %272 = tensor.empty() : tensor<2x5x4x4xf64> + %273 = tensor.empty() : tensor<2x5x5x4xf64> + %274 = tensor.empty() : tensor<2x5x5x4xf64> + %275 = tensor.empty() : tensor<2x5x5x4xf64> + %276 = tensor.empty() : tensor<2x5x5x5xf64> + %277 = tensor.empty() : tensor<2x5x5x5xf64> + %278 = tensor.empty() : tensor<2x5x5x5xf64> + %279 = tensor.empty() : tensor<2x4x5x5xf64> + %280 = tensor.empty() : tensor<2x4x5x5xf64> + %281 = tensor.empty() : tensor<2x4x5x5xf64> + %282 = tensor.empty() : tensor<2x4x4x5xf64> + %283 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_41 = tensor.extract_slice %283[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %284 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_41 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_42 = tensor.insert_slice %284 into %283[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %285 = polygeist.submap(%262, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %286 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %287 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%285, %286 : tensor, tensor) outs(%inserted_slice_42 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_43 = tensor.extract_slice %282[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %288 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_43 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_44 = tensor.insert_slice %288 into %282[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %289 = polygeist.submap(%262, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %290 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %291 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%289, %290 : tensor, tensor) outs(%inserted_slice_44 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_45 = tensor.extract_slice %281[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_46 = tensor.extract_slice %291[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %293 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %294 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_46, %293, %extracted_slice_45) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_47 = tensor.extract_slice %280[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_48 = tensor.extract_slice %287[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %296 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %297 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_48, %296, %extracted_slice_47) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_49 = tensor.extract_slice %279[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_50 = tensor.extract_slice %287[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %299 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %300 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_50, %299, %extracted_slice_49) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_51 = tensor.extract_slice %278[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %302 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %303 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%294, %302, %extracted_slice_51) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_52 = tensor.extract_slice %277[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %305 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %306 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%297, %305, %extracted_slice_52) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_53 = tensor.extract_slice %276[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %308 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %309 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%300, %308, %extracted_slice_53) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_54 = tensor.extract_slice %275[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %310 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_54 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %311 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map24} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %312 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %313 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %314 = polygeist.submap(%150, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %315 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%311, %303, %312, %306, %313, %309, %314 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%310 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_55 = tensor.extract_slice %274[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %316 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_55 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %317 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %318 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map27} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %319 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %320 = polygeist.submap(%146, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %321 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%317, %303, %318, %306, %319, %309, %320 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%316 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_56 = tensor.extract_slice %273[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %322 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_56 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %323 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %324 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %325 = polygeist.submap(%258, %c2, %c5, %c5, %c4, %c5) {map = #map29} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %326 = polygeist.submap(%146, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %327 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%323, %303, %324, %306, %325, %309, %326 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%322 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_57 = tensor.extract_slice %272[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %328 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_57 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %329 = polygeist.submap(%146, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %330 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%315, %329 : tensor, tensor) outs(%328 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_58 = tensor.extract_slice %271[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %331 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_58 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %332 = polygeist.submap(%150, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %333 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%321, %332 : tensor, tensor) outs(%331 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_59 = tensor.extract_slice %270[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %334 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_59 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %335 = polygeist.submap(%146, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %336 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%327, %335 : tensor, tensor) outs(%334 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_60 = tensor.extract_slice %269[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %337 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_60 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %338 = polygeist.submap(%146, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %339 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%330, %338 : tensor, tensor) outs(%337 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_61 = tensor.extract_slice %268[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %340 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_61 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %341 = polygeist.submap(%146, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %342 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%333, %341 : tensor, tensor) outs(%340 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_62 = tensor.extract_slice %267[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %343 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_62 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %344 = polygeist.submap(%150, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %345 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%336, %344 : tensor, tensor) outs(%343 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %346 = polygeist.submap(%266, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %347 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%339, %342, %345 : tensor, tensor, tensor) outs(%346 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %out: f64): + %1034 = arith.addf %in, %in_192 : f64 + %1035 = arith.addf %1034, %in_193 : f64 + %1036 = arith.addf %out, %1035 : f64 + linalg.yield %1036 : f64 + } -> tensor + %348 = polygeist.submapInverse(%266, %347, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %349 = polygeist.submap(%348, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %350 = polygeist.submap(%251, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %351 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%349 : tensor) outs(%350 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %352 = polygeist.submapInverse(%251, %351, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %353 = tensor.empty() : tensor<128xf64> + %354 = tensor.empty() : tensor<128xf64> + %355 = tensor.empty() : tensor<1500xf64> + %356 = polygeist.submap(%6, %c2, %c6, %c125) {map = #map31} : (tensor, index, index, index) -> tensor + %357 = polygeist.submap(%355, %c2, %c6, %c125) {map = #map22} : (tensor<1500xf64>, index, index, index) -> tensor + %358 = linalg.generic {doc = "", indexing_maps = [#map23, #map23], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%356 : tensor) outs(%357 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %359 = polygeist.submapInverse(%355, %358, %c2, %c6, %c125) {map = #map22} : (tensor<1500xf64>, tensor, index, index, index) -> tensor<1500xf64> + %360 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %361 = polygeist.submap(%354, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %362 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%360 : tensor) outs(%361 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %363 = polygeist.submapInverse(%354, %362, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %364 = polygeist.submap(%352, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %365 = polygeist.submap(%353, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %366 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%364 : tensor) outs(%365 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %367 = polygeist.submapInverse(%353, %366, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %368 = tensor.empty() : tensor<2x4x4x4xf64> + %369 = tensor.empty() : tensor<2x4x4x4xf64> + %370 = tensor.empty() : tensor<2x4x4x4xf64> + %371 = tensor.empty() : tensor<2x5x4x4xf64> + %372 = tensor.empty() : tensor<2x5x4x4xf64> + %373 = tensor.empty() : tensor<2x5x4x4xf64> + %374 = tensor.empty() : tensor<2x5x5x4xf64> + %375 = tensor.empty() : tensor<2x5x5x4xf64> + %376 = tensor.empty() : tensor<2x5x5x4xf64> + %377 = tensor.empty() : tensor<2x5x5x5xf64> + %378 = tensor.empty() : tensor<2x5x5x5xf64> + %379 = tensor.empty() : tensor<2x5x5x5xf64> + %380 = tensor.empty() : tensor<2x4x5x5xf64> + %381 = tensor.empty() : tensor<2x4x5x5xf64> + %382 = tensor.empty() : tensor<2x4x5x5xf64> + %383 = tensor.empty() : tensor<2x4x4x5xf64> + %384 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_63 = tensor.extract_slice %384[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %385 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_63 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_64 = tensor.insert_slice %385 into %384[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %386 = polygeist.submap(%363, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %387 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %388 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%386, %387 : tensor, tensor) outs(%inserted_slice_64 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_65 = tensor.extract_slice %383[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %389 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_65 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_66 = tensor.insert_slice %389 into %383[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %390 = polygeist.submap(%363, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %391 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %392 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%390, %391 : tensor, tensor) outs(%inserted_slice_66 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_67 = tensor.extract_slice %382[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_68 = tensor.extract_slice %392[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %394 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %395 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_68, %394, %extracted_slice_67) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_69 = tensor.extract_slice %381[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_70 = tensor.extract_slice %388[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %397 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %398 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_70, %397, %extracted_slice_69) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_71 = tensor.extract_slice %380[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_72 = tensor.extract_slice %388[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %400 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %401 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_72, %400, %extracted_slice_71) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_73 = tensor.extract_slice %379[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %403 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %404 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%395, %403, %extracted_slice_73) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_74 = tensor.extract_slice %378[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %406 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %407 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%398, %406, %extracted_slice_74) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_75 = tensor.extract_slice %377[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %409 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %410 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%401, %409, %extracted_slice_75) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_76 = tensor.extract_slice %376[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %411 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_76 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %412 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map24} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %413 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %414 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %415 = polygeist.submap(%150, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %416 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%412, %404, %413, %407, %414, %410, %415 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%411 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_77 = tensor.extract_slice %375[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %417 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_77 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %418 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %419 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map27} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %420 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %421 = polygeist.submap(%146, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %422 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%418, %404, %419, %407, %420, %410, %421 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%417 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_78 = tensor.extract_slice %374[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %423 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_78 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %424 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %425 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %426 = polygeist.submap(%359, %c2, %c5, %c5, %c4, %c5) {map = #map29} : (tensor<1500xf64>, index, index, index, index, index) -> tensor + %427 = polygeist.submap(%146, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %428 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%424, %404, %425, %407, %426, %410, %427 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%423 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_79 = tensor.extract_slice %373[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %429 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_79 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %430 = polygeist.submap(%146, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %431 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%416, %430 : tensor, tensor) outs(%429 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_80 = tensor.extract_slice %372[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %432 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_80 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %433 = polygeist.submap(%150, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %434 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%422, %433 : tensor, tensor) outs(%432 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_81 = tensor.extract_slice %371[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %435 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_81 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %436 = polygeist.submap(%146, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %437 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%428, %436 : tensor, tensor) outs(%435 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_82 = tensor.extract_slice %370[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %438 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_82 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %439 = polygeist.submap(%146, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %440 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%431, %439 : tensor, tensor) outs(%438 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_83 = tensor.extract_slice %369[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %441 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_83 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %442 = polygeist.submap(%146, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %443 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%434, %442 : tensor, tensor) outs(%441 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_84 = tensor.extract_slice %368[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %444 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_84 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %445 = polygeist.submap(%150, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %446 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%437, %445 : tensor, tensor) outs(%444 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %447 = polygeist.submap(%367, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %448 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%440, %443, %446 : tensor, tensor, tensor) outs(%447 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %out: f64): + %1034 = arith.addf %in, %in_192 : f64 + %1035 = arith.addf %1034, %in_193 : f64 + %1036 = arith.addf %out, %1035 : f64 + linalg.yield %1036 : f64 + } -> tensor + %449 = polygeist.submapInverse(%367, %448, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %450 = polygeist.submap(%449, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %451 = polygeist.submap(%352, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %452 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%450 : tensor) outs(%451 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %453 = polygeist.submapInverse(%352, %452, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, tensor, index, index, index, index) -> tensor + %454 = tensor.empty() : tensor<750xf64> + %455 = tensor.empty() : tensor<2250xf64> + %456 = tensor.empty() : tensor<750xf64> + %457 = tensor.empty() : tensor<20xf64> + %458 = polygeist.submap(%0, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %459 = polygeist.submap(%457, %c4, %c5) {map = #map1} : (tensor<20xf64>, index, index) -> tensor + %460 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%458 : tensor) outs(%459 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %461 = polygeist.submapInverse(%457, %460, %c4, %c5) {map = #map1} : (tensor<20xf64>, tensor, index, index) -> tensor<20xf64> + %462 = tensor.empty() : tensor<750xf64> + %463 = tensor.empty() : tensor<250xf64> + %464 = tensor.empty() : tensor<128xf64> + %465 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %466 = polygeist.submap(%464, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %467 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%465 : tensor) outs(%466 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %468 = polygeist.submapInverse(%464, %467, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %469 = tensor.empty() : tensor<2x4x5x5xf64> + %470 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_85 = tensor.extract_slice %470[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %471 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_85 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_86 = tensor.insert_slice %471 into %470[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %472 = polygeist.submap(%468, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %473 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %474 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%472, %473 : tensor, tensor) outs(%inserted_slice_86 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_87 = tensor.extract_slice %469[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_88 = tensor.extract_slice %474[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %476 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %477 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_88, %476, %extracted_slice_87) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %478 = polygeist.submap(%463, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor + %479 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%478 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %480 = polygeist.submapInverse(%463, %479, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, tensor, index, index, index, index) -> tensor<250xf64> + %481 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %482 = polygeist.submap(%480, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %v482_contract_483_tc2 = tensor.cast %482 : tensor<2x5x5x5xf64> to tensor + + %v483_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%477, %481, %v482_contract_483_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %483 = tensor.cast %v483_tdyn : tensor to tensor<2x5x5x5xf64> + %484 = polygeist.submapInverse(%480, %483, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<250xf64> + %485 = tensor.empty() : tensor<2x4x5x5xf64> + %486 = tensor.empty() : tensor<2x4x5x5xf64> + %487 = tensor.empty() : tensor<2x4x5x5xf64> + %488 = tensor.empty() : tensor<2x4x4x5xf64> + %489 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_89 = tensor.extract_slice %489[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %490 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_89 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_90 = tensor.insert_slice %490 into %489[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %491 = polygeist.submap(%468, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %492 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %493 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%491, %492 : tensor, tensor) outs(%inserted_slice_90 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_91 = tensor.extract_slice %488[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %494 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_91 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_92 = tensor.insert_slice %494 into %488[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %495 = polygeist.submap(%468, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %496 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %497 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%495, %496 : tensor, tensor) outs(%inserted_slice_92 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_93 = tensor.extract_slice %487[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_94 = tensor.extract_slice %497[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %499 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %500 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_94, %499, %extracted_slice_93) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_95 = tensor.extract_slice %486[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_96 = tensor.extract_slice %493[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %502 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %503 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_96, %502, %extracted_slice_95) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_97 = tensor.extract_slice %485[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_98 = tensor.extract_slice %493[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %505 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %506 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_98, %505, %extracted_slice_97) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %507 = polygeist.submap(%462, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, index, index, index, index) -> tensor + %508 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%507 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %509 = polygeist.submapInverse(%462, %508, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %510 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %511 = polygeist.submap(%509, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %v511_contract_512_tc2 = tensor.cast %511 : tensor<2x5x5x5xf64> to tensor + + %v512_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%500, %510, %v511_contract_512_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %512 = tensor.cast %v512_tdyn : tensor to tensor<2x5x5x5xf64> + %513 = polygeist.submapInverse(%509, %512, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %514 = polygeist.submap(%513, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, index, index, index, index) -> tensor + %515 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%514 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %516 = polygeist.submapInverse(%513, %515, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %517 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %518 = polygeist.submap(%516, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %v518_contract_519_tc2 = tensor.cast %518 : tensor<2x5x5x5xf64> to tensor + + %v519_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%503, %517, %v518_contract_519_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %519 = tensor.cast %v519_tdyn : tensor to tensor<2x5x5x5xf64> + %520 = polygeist.submapInverse(%516, %519, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %521 = polygeist.submap(%520, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, index, index, index, index) -> tensor + %522 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%521 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %523 = polygeist.submapInverse(%520, %522, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %524 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %525 = polygeist.submap(%523, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %v525_contract_526_tc2 = tensor.cast %525 : tensor<2x5x5x5xf64> to tensor + + %v526_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%506, %524, %v525_contract_526_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %526 = tensor.cast %v526_tdyn : tensor to tensor<2x5x5x5xf64> + %527 = polygeist.submapInverse(%523, %526, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %528 = polygeist.submap(%484, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor + %529 = polygeist.submap(%456, %c2, %c5, %c5, %c5) {map = #map36} : (tensor<750xf64>, index, index, index, index) -> tensor + %530 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%528 : tensor) outs(%529 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %531 = polygeist.submapInverse(%456, %530, %c2, %c5, %c5, %c5) {map = #map36} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %532 = polygeist.submap(%527, %c2, %c3, %c5, %c5, %c5) {map = #map37} : (tensor<750xf64>, index, index, index, index, index) -> tensor + %533 = polygeist.submap(%455, %c2, %c3, %c5, %c5, %c5) {map = #map38} : (tensor<2250xf64>, index, index, index, index, index) -> tensor + %534 = linalg.generic {doc = "", indexing_maps = [#map8, #map8], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%532 : tensor) outs(%533 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %535 = polygeist.submapInverse(%455, %534, %c2, %c3, %c5, %c5, %c5) {map = #map38} : (tensor<2250xf64>, tensor, index, index, index, index, index) -> tensor<2250xf64> + %536 = tensor.empty() : tensor<750xf64> + %537 = tensor.empty() : tensor<250xf64> + %538 = tensor.empty() : tensor<128xf64> + %539 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %540 = polygeist.submap(%538, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %541 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%539 : tensor) outs(%540 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %542 = polygeist.submapInverse(%538, %541, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %543 = tensor.empty() : tensor<2x4x5x5xf64> + %544 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_99 = tensor.extract_slice %544[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %545 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_99 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_100 = tensor.insert_slice %545 into %544[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %546 = polygeist.submap(%542, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %547 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %548 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%546, %547 : tensor, tensor) outs(%inserted_slice_100 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_101 = tensor.extract_slice %543[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_102 = tensor.extract_slice %548[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %550 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %551 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_102, %550, %extracted_slice_101) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %552 = polygeist.submap(%537, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor + %553 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%552 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %554 = polygeist.submapInverse(%537, %553, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, tensor, index, index, index, index) -> tensor<250xf64> + %555 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %556 = polygeist.submap(%554, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %v556_contract_557_tc2 = tensor.cast %556 : tensor<2x5x5x5xf64> to tensor + + %v557_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%551, %555, %v556_contract_557_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %557 = tensor.cast %v557_tdyn : tensor to tensor<2x5x5x5xf64> + %558 = polygeist.submapInverse(%554, %557, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<250xf64> + %559 = tensor.empty() : tensor<2x4x5x5xf64> + %560 = tensor.empty() : tensor<2x4x5x5xf64> + %561 = tensor.empty() : tensor<2x4x5x5xf64> + %562 = tensor.empty() : tensor<2x4x4x5xf64> + %563 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_103 = tensor.extract_slice %563[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %564 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_103 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_104 = tensor.insert_slice %564 into %563[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %565 = polygeist.submap(%542, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %566 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %567 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%565, %566 : tensor, tensor) outs(%inserted_slice_104 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_105 = tensor.extract_slice %562[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %568 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_105 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_106 = tensor.insert_slice %568 into %562[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %569 = polygeist.submap(%542, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %570 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %571 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%569, %570 : tensor, tensor) outs(%inserted_slice_106 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_107 = tensor.extract_slice %561[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_108 = tensor.extract_slice %571[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %573 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %574 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_108, %573, %extracted_slice_107) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_109 = tensor.extract_slice %560[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_110 = tensor.extract_slice %567[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %576 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %577 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_110, %576, %extracted_slice_109) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_111 = tensor.extract_slice %559[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_112 = tensor.extract_slice %567[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %579 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %580 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_112, %579, %extracted_slice_111) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %581 = polygeist.submap(%536, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, index, index, index, index) -> tensor + %582 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%581 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %583 = polygeist.submapInverse(%536, %582, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %584 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %585 = polygeist.submap(%583, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %v585_contract_586_tc2 = tensor.cast %585 : tensor<2x5x5x5xf64> to tensor + + %v586_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%574, %584, %v585_contract_586_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %586 = tensor.cast %v586_tdyn : tensor to tensor<2x5x5x5xf64> + %587 = polygeist.submapInverse(%583, %586, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %588 = polygeist.submap(%587, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, index, index, index, index) -> tensor + %589 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%588 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %590 = polygeist.submapInverse(%587, %589, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %591 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %592 = polygeist.submap(%590, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %v592_contract_593_tc2 = tensor.cast %592 : tensor<2x5x5x5xf64> to tensor + + %v593_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%577, %591, %v592_contract_593_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %593 = tensor.cast %v593_tdyn : tensor to tensor<2x5x5x5xf64> + %594 = polygeist.submapInverse(%590, %593, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %595 = polygeist.submap(%594, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, index, index, index, index) -> tensor + %596 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%595 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %597 = polygeist.submapInverse(%594, %596, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %598 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %599 = polygeist.submap(%597, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %v599_contract_600_tc2 = tensor.cast %599 : tensor<2x5x5x5xf64> to tensor + + %v600_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%580, %598, %v599_contract_600_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %600 = tensor.cast %v600_tdyn : tensor to tensor<2x5x5x5xf64> + %601 = polygeist.submapInverse(%597, %600, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %602 = polygeist.submap(%558, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor + %603 = polygeist.submap(%531, %c2, %c5, %c5, %c5) {map = #map39} : (tensor<750xf64>, index, index, index, index) -> tensor + %604 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%602 : tensor) outs(%603 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %605 = polygeist.submapInverse(%531, %604, %c2, %c5, %c5, %c5) {map = #map39} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %606 = polygeist.submap(%601, %c2, %c3, %c5, %c5, %c5) {map = #map37} : (tensor<750xf64>, index, index, index, index, index) -> tensor + %607 = polygeist.submap(%535, %c2, %c3, %c5, %c5, %c5) {map = #map40} : (tensor<2250xf64>, index, index, index, index, index) -> tensor + %608 = linalg.generic {doc = "", indexing_maps = [#map8, #map8], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%606 : tensor) outs(%607 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %609 = polygeist.submapInverse(%535, %608, %c2, %c3, %c5, %c5, %c5) {map = #map40} : (tensor<2250xf64>, tensor, index, index, index, index, index) -> tensor<2250xf64> + %610 = tensor.empty() : tensor<750xf64> + %611 = tensor.empty() : tensor<250xf64> + %612 = tensor.empty() : tensor<128xf64> + %613 = polygeist.submap(%9, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %614 = polygeist.submap(%612, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %615 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%613 : tensor) outs(%614 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %616 = polygeist.submapInverse(%612, %615, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %617 = tensor.empty() : tensor<2x4x5x5xf64> + %618 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_113 = tensor.extract_slice %618[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %619 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_113 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_114 = tensor.insert_slice %619 into %618[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %620 = polygeist.submap(%616, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %621 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %622 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%620, %621 : tensor, tensor) outs(%inserted_slice_114 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_115 = tensor.extract_slice %617[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_116 = tensor.extract_slice %622[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %624 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %625 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_116, %624, %extracted_slice_115) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %626 = polygeist.submap(%611, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor + %627 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%626 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %628 = polygeist.submapInverse(%611, %627, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, tensor, index, index, index, index) -> tensor<250xf64> + %629 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %630 = polygeist.submap(%628, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %v630_contract_631_tc2 = tensor.cast %630 : tensor<2x5x5x5xf64> to tensor + + %v631_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%625, %629, %v630_contract_631_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %631 = tensor.cast %v631_tdyn : tensor to tensor<2x5x5x5xf64> + %632 = polygeist.submapInverse(%628, %631, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<250xf64> + %633 = tensor.empty() : tensor<2x4x5x5xf64> + %634 = tensor.empty() : tensor<2x4x5x5xf64> + %635 = tensor.empty() : tensor<2x4x5x5xf64> + %636 = tensor.empty() : tensor<2x4x4x5xf64> + %637 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_117 = tensor.extract_slice %637[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %638 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_117 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_118 = tensor.insert_slice %638 into %637[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %639 = polygeist.submap(%616, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %640 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %641 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%639, %640 : tensor, tensor) outs(%inserted_slice_118 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_119 = tensor.extract_slice %636[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %642 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_119 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_120 = tensor.insert_slice %642 into %636[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %643 = polygeist.submap(%616, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor<128xf64>, index, index, index, index, index) -> tensor + %644 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %645 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%643, %644 : tensor, tensor) outs(%inserted_slice_120 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x4x4x5xf64> + %extracted_slice_121 = tensor.extract_slice %635[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_122 = tensor.extract_slice %645[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %647 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %648 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_122, %647, %extracted_slice_121) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_123 = tensor.extract_slice %634[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_124 = tensor.extract_slice %641[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %650 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %651 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_124, %650, %extracted_slice_123) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_125 = tensor.extract_slice %633[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_126 = tensor.extract_slice %641[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %653 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %654 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_126, %653, %extracted_slice_125) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %655 = polygeist.submap(%610, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, index, index, index, index) -> tensor + %656 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%655 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %657 = polygeist.submapInverse(%610, %656, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %658 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %659 = polygeist.submap(%657, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %v659_contract_660_tc2 = tensor.cast %659 : tensor<2x5x5x5xf64> to tensor + + %v660_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%648, %658, %v659_contract_660_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %660 = tensor.cast %v660_tdyn : tensor to tensor<2x5x5x5xf64> + %661 = polygeist.submapInverse(%657, %660, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %662 = polygeist.submap(%661, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, index, index, index, index) -> tensor + %663 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%662 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %664 = polygeist.submapInverse(%661, %663, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %665 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %666 = polygeist.submap(%664, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %v666_contract_667_tc2 = tensor.cast %666 : tensor<2x5x5x5xf64> to tensor + + %v667_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%651, %665, %v666_contract_667_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %667 = tensor.cast %v667_tdyn : tensor to tensor<2x5x5x5xf64> + %668 = polygeist.submapInverse(%664, %667, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %669 = polygeist.submap(%668, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, index, index, index, index) -> tensor + %670 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%669 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %671 = polygeist.submapInverse(%668, %670, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %672 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %673 = polygeist.submap(%671, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %v673_contract_674_tc2 = tensor.cast %673 : tensor<2x5x5x5xf64> to tensor + + %v674_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%654, %672, %v673_contract_674_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %674 = tensor.cast %v674_tdyn : tensor to tensor<2x5x5x5xf64> + %675 = polygeist.submapInverse(%671, %674, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %676 = polygeist.submap(%632, %c2, %c5, %c5, %c5) {map = #map32} : (tensor<250xf64>, index, index, index, index) -> tensor + %677 = polygeist.submap(%605, %c2, %c5, %c5, %c5) {map = #map41} : (tensor<750xf64>, index, index, index, index) -> tensor + %678 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%676 : tensor) outs(%677 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %679 = polygeist.submapInverse(%605, %678, %c2, %c5, %c5, %c5) {map = #map41} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %680 = polygeist.submap(%675, %c2, %c3, %c5, %c5, %c5) {map = #map37} : (tensor<750xf64>, index, index, index, index, index) -> tensor + %681 = polygeist.submap(%609, %c2, %c3, %c5, %c5, %c5) {map = #map42} : (tensor<2250xf64>, index, index, index, index, index) -> tensor + %682 = linalg.generic {doc = "", indexing_maps = [#map8, #map8], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%680 : tensor) outs(%681 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %683 = polygeist.submapInverse(%609, %682, %c2, %c3, %c5, %c5, %c5) {map = #map42} : (tensor<2250xf64>, tensor, index, index, index, index, index) -> tensor<2250xf64> + %684 = polygeist.submap(%454, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (tensor<750xf64>, index, index, index, index, index) -> tensor + %685 = linalg.generic {doc = "", indexing_maps = [#map8], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%684 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %686 = polygeist.submapInverse(%454, %685, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (tensor<750xf64>, tensor, index, index, index, index, index) -> tensor<750xf64> + %687 = polygeist.submap(%679, %c2, %c3, %c5, %c5, %c5, %c3, %c3) {map = #map44} : (tensor<750xf64>, index, index, index, index, index, index, index) -> tensor + %688 = polygeist.submap(%683, %c2, %c3, %c5, %c5, %c5, %c3, %c3) {map = #map45} : (tensor<2250xf64>, index, index, index, index, index, index, index) -> tensor + %689 = polygeist.submap(%7, %c2, %c3, %c5, %c5, %c5, %c3, %c3) {map = #map46} : (tensor, index, index, index, index, index, index, index) -> tensor + %690 = polygeist.submap(%686, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (tensor<750xf64>, index, index, index, index, index) -> tensor<2x3x5x5x5xf64> + %691 = linalg.generic {doc = "", indexing_maps = [#map47, #map47, #map47, #map48], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction"], library_call = ""} ins(%687, %688, %689 : tensor, tensor, tensor) outs(%690 : tensor<2x3x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %1034, %in_193 : f64 + %1036 = arith.addf %out, %1035 : f64 + linalg.yield %1036 : f64 + } -> tensor<2x3x5x5x5xf64> + %692 = polygeist.submapInverse(%686, %691, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (tensor<750xf64>, tensor<2x3x5x5x5xf64>, index, index, index, index, index) -> tensor<750xf64> + %693 = tensor.empty() : tensor<128xf64> + %694 = tensor.empty() : tensor<250xf64> + %695 = polygeist.submap(%692, %c2, %c125) {map = #map49} : (tensor<750xf64>, index, index) -> tensor + %696 = polygeist.submap(%694, %c2, %c125) {map = #map50} : (tensor<250xf64>, index, index) -> tensor + %697 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%695 : tensor) outs(%696 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %698 = polygeist.submapInverse(%694, %697, %c2, %c125) {map = #map50} : (tensor<250xf64>, tensor, index, index) -> tensor<250xf64> + %699 = polygeist.submap(%453, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %700 = polygeist.submap(%693, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %701 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%699 : tensor) outs(%700 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %702 = polygeist.submapInverse(%693, %701, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %703 = tensor.empty() : tensor<2x4x4x4xf64> + %704 = tensor.empty() : tensor<2x5x4x4xf64> + %705 = tensor.empty() : tensor<2x5x5x4xf64> + %extracted_slice_127 = tensor.extract_slice %705[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %706 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_127 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_128 = tensor.insert_slice %706 into %705[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor into tensor<2x5x5x4xf64> + %707 = polygeist.submap(%698, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (tensor<250xf64>, index, index, index, index, index) -> tensor + %708 = polygeist.submap(%461, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %709 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%707, %708 : tensor, tensor) outs(%inserted_slice_128 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x4xf64> + %extracted_slice_129 = tensor.extract_slice %704[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %710 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_129 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_130 = tensor.extract_slice %709[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %711 = polygeist.submap(%461, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %712 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_130, %711 : tensor, tensor) outs(%710 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_131 = tensor.extract_slice %703[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %713 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_131 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %714 = polygeist.submap(%461, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %715 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%712, %714 : tensor, tensor) outs(%713 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %716 = polygeist.submap(%702, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %717 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%715 : tensor) outs(%716 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.addf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %718 = polygeist.submapInverse(%702, %717, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %719 = polygeist.submap(%718, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %720 = polygeist.submap(%453, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %721 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%719 : tensor) outs(%720 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %722 = polygeist.submapInverse(%453, %721, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, tensor, index, index, index, index) -> tensor + %723 = tensor.empty() : tensor<128xf64> + %724 = tensor.empty() : tensor<250xf64> + %725 = polygeist.submap(%692, %c2, %c125) {map = #map52} : (tensor<750xf64>, index, index) -> tensor + %726 = polygeist.submap(%724, %c2, %c125) {map = #map50} : (tensor<250xf64>, index, index) -> tensor + %727 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%725 : tensor) outs(%726 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %728 = polygeist.submapInverse(%724, %727, %c2, %c125) {map = #map50} : (tensor<250xf64>, tensor, index, index) -> tensor<250xf64> + %729 = polygeist.submap(%722, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %730 = polygeist.submap(%723, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %731 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%729 : tensor) outs(%730 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %732 = polygeist.submapInverse(%723, %731, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %733 = tensor.empty() : tensor<2x4x4x4xf64> + %734 = tensor.empty() : tensor<2x5x4x4xf64> + %735 = tensor.empty() : tensor<2x5x5x4xf64> + %extracted_slice_132 = tensor.extract_slice %735[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %736 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_132 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_133 = tensor.insert_slice %736 into %735[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor into tensor<2x5x5x4xf64> + %737 = polygeist.submap(%728, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (tensor<250xf64>, index, index, index, index, index) -> tensor + %738 = polygeist.submap(%461, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %739 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%737, %738 : tensor, tensor) outs(%inserted_slice_133 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x4xf64> + %extracted_slice_134 = tensor.extract_slice %734[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %740 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_134 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_135 = tensor.extract_slice %739[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %741 = polygeist.submap(%461, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %742 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_135, %741 : tensor, tensor) outs(%740 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_136 = tensor.extract_slice %733[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %743 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_136 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %744 = polygeist.submap(%461, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %745 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%742, %744 : tensor, tensor) outs(%743 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %746 = polygeist.submap(%732, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %747 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%745 : tensor) outs(%746 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.addf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %748 = polygeist.submapInverse(%732, %747, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %749 = polygeist.submap(%748, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %750 = polygeist.submap(%722, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %751 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%749 : tensor) outs(%750 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %752 = polygeist.submapInverse(%722, %751, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %753 = tensor.empty() : tensor<128xf64> + %754 = tensor.empty() : tensor<250xf64> + %755 = polygeist.submap(%692, %c2, %c125) {map = #map53} : (tensor<750xf64>, index, index) -> tensor + %756 = polygeist.submap(%754, %c2, %c125) {map = #map50} : (tensor<250xf64>, index, index) -> tensor + %757 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%755 : tensor) outs(%756 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %758 = polygeist.submapInverse(%754, %757, %c2, %c125) {map = #map50} : (tensor<250xf64>, tensor, index, index) -> tensor<250xf64> + %759 = polygeist.submap(%752, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %760 = polygeist.submap(%753, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %761 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%759 : tensor) outs(%760 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %762 = polygeist.submapInverse(%753, %761, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %763 = tensor.empty() : tensor<2x4x4x4xf64> + %764 = tensor.empty() : tensor<2x5x4x4xf64> + %765 = tensor.empty() : tensor<2x5x5x4xf64> + %extracted_slice_137 = tensor.extract_slice %765[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %766 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_137 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_138 = tensor.insert_slice %766 into %765[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor into tensor<2x5x5x4xf64> + %767 = polygeist.submap(%758, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (tensor<250xf64>, index, index, index, index, index) -> tensor + %768 = polygeist.submap(%461, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %769 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%767, %768 : tensor, tensor) outs(%inserted_slice_138 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x4xf64> + %extracted_slice_139 = tensor.extract_slice %764[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %770 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_139 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_140 = tensor.extract_slice %769[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %771 = polygeist.submap(%461, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %772 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_140, %771 : tensor, tensor) outs(%770 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_141 = tensor.extract_slice %763[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %773 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_141 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %774 = polygeist.submap(%461, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %775 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%772, %774 : tensor, tensor) outs(%773 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %776 = polygeist.submap(%762, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %777 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%775 : tensor) outs(%776 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.addf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %778 = polygeist.submapInverse(%762, %777, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %779 = polygeist.submap(%778, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %780 = polygeist.submap(%752, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %781 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%779 : tensor) outs(%780 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %782 = polygeist.submapInverse(%752, %781, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, tensor, index, index, index, index) -> tensor + %783 = tensor.empty() : tensor<2x4x4x4xf64> + %784 = tensor.empty() : tensor<2x4x4x4xf64> + %785 = tensor.empty() : tensor<2x4x4x4xf64> + %786 = tensor.empty() : tensor<2x5x4x4xf64> + %787 = tensor.empty() : tensor<2x5x4x4xf64> + %788 = tensor.empty() : tensor<2x5x4x4xf64> + %789 = tensor.empty() : tensor<2x5x5x4xf64> + %790 = tensor.empty() : tensor<2x5x5x4xf64> + %791 = tensor.empty() : tensor<2x5x5x4xf64> + %792 = tensor.empty() : tensor<2x5x5x5xf64> + %793 = tensor.empty() : tensor<2x5x5x5xf64> + %794 = tensor.empty() : tensor<2x5x5x5xf64> + %795 = tensor.empty() : tensor<2x4x5x5xf64> + %796 = tensor.empty() : tensor<2x4x5x5xf64> + %797 = tensor.empty() : tensor<2x4x5x5xf64> + %798 = tensor.empty() : tensor<2x4x4x5xf64> + %799 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_142 = tensor.extract_slice %799[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %800 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_142 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_143 = tensor.insert_slice %800 into %799[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %801 = polygeist.submap(%10, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %802 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %inserted_slice_143_contract_803_tc2 = tensor.cast %inserted_slice_143 : tensor<2x4x4x5xf64> to tensor + + %v803_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%801, %802, %inserted_slice_143_contract_803_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %803 = tensor.cast %v803_tdyn : tensor to tensor<2x4x4x5xf64> + %extracted_slice_144 = tensor.extract_slice %798[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %804 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_144 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_145 = tensor.insert_slice %804 into %798[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %805 = polygeist.submap(%10, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %806 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %inserted_slice_145_contract_807_tc2 = tensor.cast %inserted_slice_145 : tensor<2x4x4x5xf64> to tensor + + %v807_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%805, %806, %inserted_slice_145_contract_807_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %807 = tensor.cast %v807_tdyn : tensor to tensor<2x4x4x5xf64> + %extracted_slice_146 = tensor.extract_slice %797[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_147 = tensor.extract_slice %807[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %809 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %810 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_147, %809, %extracted_slice_146) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_148 = tensor.extract_slice %796[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_149 = tensor.extract_slice %803[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %812 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %813 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_149, %812, %extracted_slice_148) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_150 = tensor.extract_slice %795[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_151 = tensor.extract_slice %803[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %815 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %816 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_151, %815, %extracted_slice_150) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_152 = tensor.extract_slice %794[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %818 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %819 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%810, %818, %extracted_slice_152) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_153 = tensor.extract_slice %793[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %821 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %822 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%813, %821, %extracted_slice_153) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_154 = tensor.extract_slice %792[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %824 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %825 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%816, %824, %extracted_slice_154) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_155 = tensor.extract_slice %791[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %826 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_155 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %827 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map24} : (tensor, index, index, index, index, index) -> tensor + %828 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (tensor, index, index, index, index, index) -> tensor + %829 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (tensor, index, index, index, index, index) -> tensor + %830 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %831 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%827, %819, %828, %822, %829, %825, %830 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%826 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_156 = tensor.extract_slice %790[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %832 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_156 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %833 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (tensor, index, index, index, index, index) -> tensor + %834 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map27} : (tensor, index, index, index, index, index) -> tensor + %835 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (tensor, index, index, index, index, index) -> tensor + %836 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %837 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%833, %819, %834, %822, %835, %825, %836 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%832 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_157 = tensor.extract_slice %789[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %838 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_157 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %839 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (tensor, index, index, index, index, index) -> tensor + %840 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (tensor, index, index, index, index, index) -> tensor + %841 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map29} : (tensor, index, index, index, index, index) -> tensor + %842 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %843 = linalg.generic {doc = "", indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%839, %819, %840, %822, %841, %825, %842 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%838 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.mulf %in_193, %in_194 : f64 + %1036 = arith.addf %1034, %1035 : f64 + %1037 = arith.mulf %in_195, %in_196 : f64 + %1038 = arith.addf %1036, %1037 : f64 + %1039 = arith.mulf %1038, %in_197 : f64 + %1040 = arith.addf %out, %1039 : f64 + linalg.yield %1040 : f64 + } -> tensor + %extracted_slice_158 = tensor.extract_slice %788[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %845 = polygeist.submap(%2, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %846 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%831, %845, %extracted_slice_158) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_159 = tensor.extract_slice %787[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %848 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %849 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%837, %848, %extracted_slice_159) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_160 = tensor.extract_slice %786[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %851 = polygeist.submap(%2, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %852 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%843, %851, %extracted_slice_160) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_161 = tensor.extract_slice %785[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %854 = polygeist.submap(%2, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %855 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%846, %854, %extracted_slice_161) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_162 = tensor.extract_slice %784[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %857 = polygeist.submap(%2, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %858 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%849, %857, %extracted_slice_162) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_163 = tensor.extract_slice %783[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %860 = polygeist.submap(%3, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %861 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%852, %860, %extracted_slice_163) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + %862 = polygeist.submap(%12, %c2, %c4, %c4, %c4) {map = #map4} : (tensor, index, index, index, index) -> tensor + %863 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%855, %858, %861 : tensor, tensor, tensor) outs(%862 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %out: f64): + %1034 = arith.addf %in, %in_192 : f64 + %1035 = arith.addf %1034, %in_193 : f64 + %1036 = arith.addf %out, %1035 : f64 + linalg.yield %1036 : f64 + } -> tensor + %864 = polygeist.submapInverse(%12, %863, %c2, %c4, %c4, %c4) {map = #map4} : (tensor, tensor, index, index, index, index) -> tensor + %865 = tensor.empty() : tensor<750xf64> + %866 = tensor.empty() : tensor<750xf64> + %867 = tensor.empty() : tensor<20xf64> + %868 = polygeist.submap(%0, %c4, %c5) {map = #map} : (tensor, index, index) -> tensor + %869 = polygeist.submap(%867, %c4, %c5) {map = #map1} : (tensor<20xf64>, index, index) -> tensor + %870 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%868 : tensor) outs(%869 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %871 = polygeist.submapInverse(%867, %870, %c4, %c5) {map = #map1} : (tensor<20xf64>, tensor, index, index) -> tensor<20xf64> + %872 = tensor.empty() : tensor<2x4x5x5xf64> + %873 = tensor.empty() : tensor<2x4x5x5xf64> + %874 = tensor.empty() : tensor<2x4x5x5xf64> + %875 = tensor.empty() : tensor<2x4x4x5xf64> + %876 = tensor.empty() : tensor<2x4x4x5xf64> + %extracted_slice_164 = tensor.extract_slice %876[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %877 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_164 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_165 = tensor.insert_slice %877 into %876[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %878 = polygeist.submap(%10, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %879 = polygeist.submap(%0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %inserted_slice_165_contract_880_tc2 = tensor.cast %inserted_slice_165 : tensor<2x4x4x5xf64> to tensor + + %v880_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%878, %879, %inserted_slice_165_contract_880_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %880 = tensor.cast %v880_tdyn : tensor to tensor<2x4x4x5xf64> + %extracted_slice_166 = tensor.extract_slice %875[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %881 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_166 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_167 = tensor.insert_slice %881 into %875[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor into tensor<2x4x4x5xf64> + %882 = polygeist.submap(%10, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %883 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %inserted_slice_167_contract_884_tc2 = tensor.cast %inserted_slice_167 : tensor<2x4x4x5xf64> to tensor + + %v884_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%882, %883, %inserted_slice_167_contract_884_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %884 = tensor.cast %v884_tdyn : tensor to tensor<2x4x4x5xf64> + %extracted_slice_168 = tensor.extract_slice %874[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_169 = tensor.extract_slice %884[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %886 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %887 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_169, %886, %extracted_slice_168) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_170 = tensor.extract_slice %873[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_171 = tensor.extract_slice %880[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %889 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %890 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_171, %889, %extracted_slice_170) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %extracted_slice_172 = tensor.extract_slice %872[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : tensor<2x4x5x5xf64> to tensor + %extracted_slice_173 = tensor.extract_slice %880[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : tensor<2x4x4x5xf64> to tensor + %892 = polygeist.submap(%0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %893 = kernel.launch @cutensornetContraction2_f64_r4r5r4(%extracted_slice_173, %892, %extracted_slice_172) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + %894 = polygeist.submap(%866, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, index, index, index, index) -> tensor + %895 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%894 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %896 = polygeist.submapInverse(%866, %895, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %897 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %898 = polygeist.submap(%896, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %v898_contract_899_tc2 = tensor.cast %898 : tensor<2x5x5x5xf64> to tensor + + %v899_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%887, %897, %v898_contract_899_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %899 = tensor.cast %v899_tdyn : tensor to tensor<2x5x5x5xf64> + %900 = polygeist.submapInverse(%896, %899, %c2, %c5, %c5, %c5) {map = #map33} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %901 = polygeist.submap(%900, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, index, index, index, index) -> tensor + %902 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%901 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %903 = polygeist.submapInverse(%900, %902, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %904 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %905 = polygeist.submap(%903, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %v905_contract_906_tc2 = tensor.cast %905 : tensor<2x5x5x5xf64> to tensor + + %v906_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%890, %904, %v905_contract_906_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %906 = tensor.cast %v906_tdyn : tensor to tensor<2x5x5x5xf64> + %907 = polygeist.submapInverse(%903, %906, %c2, %c5, %c5, %c5) {map = #map34} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %908 = polygeist.submap(%907, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, index, index, index, index) -> tensor + %909 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%908 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %910 = polygeist.submapInverse(%907, %909, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, tensor, index, index, index, index) -> tensor<750xf64> + %911 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %912 = polygeist.submap(%910, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, index, index, index, index) -> tensor<2x5x5x5xf64> + %v912_contract_913_tc2 = tensor.cast %912 : tensor<2x5x5x5xf64> to tensor + + %v913_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%893, %911, %v912_contract_913_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %913 = tensor.cast %v913_tdyn : tensor to tensor<2x5x5x5xf64> + %914 = polygeist.submapInverse(%910, %913, %c2, %c5, %c5, %c5) {map = #map35} : (tensor<750xf64>, tensor<2x5x5x5xf64>, index, index, index, index) -> tensor<750xf64> + %915 = polygeist.submap(%865, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (tensor<750xf64>, index, index, index, index, index) -> tensor + %916 = linalg.generic {doc = "", indexing_maps = [#map8], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%915 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %917 = polygeist.submapInverse(%865, %916, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (tensor<750xf64>, tensor, index, index, index, index, index) -> tensor<750xf64> + %918 = polygeist.submap(%914, %c2, %c3, %c5, %c5, %c5, %c3) {map = #map54} : (tensor<750xf64>, index, index, index, index, index, index) -> tensor + %919 = polygeist.submap(%8, %c2, %c3, %c5, %c5, %c5, %c3) {map = #map55} : (tensor, index, index, index, index, index, index) -> tensor + %920 = polygeist.submap(%917, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (tensor<750xf64>, index, index, index, index, index) -> tensor<2x3x5x5x5xf64> + %921 = linalg.generic {doc = "", indexing_maps = [#map56, #map56, #map57], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%918, %919 : tensor, tensor) outs(%920 : tensor<2x3x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x3x5x5x5xf64> + %922 = polygeist.submapInverse(%917, %921, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (tensor<750xf64>, tensor<2x3x5x5x5xf64>, index, index, index, index, index) -> tensor<750xf64> + %923 = tensor.empty() : tensor<128xf64> + %924 = tensor.empty() : tensor<250xf64> + %925 = polygeist.submap(%922, %c2, %c125) {map = #map49} : (tensor<750xf64>, index, index) -> tensor + %926 = polygeist.submap(%924, %c2, %c125) {map = #map50} : (tensor<250xf64>, index, index) -> tensor + %927 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%925 : tensor) outs(%926 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %928 = polygeist.submapInverse(%924, %927, %c2, %c125) {map = #map50} : (tensor<250xf64>, tensor, index, index) -> tensor<250xf64> + %929 = polygeist.submap(%782, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %930 = polygeist.submap(%923, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %931 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%929 : tensor) outs(%930 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %932 = polygeist.submapInverse(%923, %931, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %933 = tensor.empty() : tensor<2x4x4x4xf64> + %934 = tensor.empty() : tensor<2x5x4x4xf64> + %935 = tensor.empty() : tensor<2x5x5x4xf64> + %extracted_slice_174 = tensor.extract_slice %935[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %936 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_174 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_175 = tensor.insert_slice %936 into %935[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor into tensor<2x5x5x4xf64> + %937 = polygeist.submap(%928, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (tensor<250xf64>, index, index, index, index, index) -> tensor + %938 = polygeist.submap(%871, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %939 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%937, %938 : tensor, tensor) outs(%inserted_slice_175 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x4xf64> + %extracted_slice_176 = tensor.extract_slice %934[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %940 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_176 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_177 = tensor.extract_slice %939[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %941 = polygeist.submap(%871, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %942 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_177, %941 : tensor, tensor) outs(%940 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_178 = tensor.extract_slice %933[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %943 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_178 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %944 = polygeist.submap(%871, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %945 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%942, %944 : tensor, tensor) outs(%943 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %946 = polygeist.submap(%932, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %947 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%945 : tensor) outs(%946 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.addf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %948 = polygeist.submapInverse(%932, %947, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %949 = polygeist.submap(%948, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %950 = polygeist.submap(%782, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, index, index, index, index) -> tensor + %951 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%949 : tensor) outs(%950 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %952 = polygeist.submapInverse(%782, %951, %c2, %c4, %c4, %c4) {map = #map3} : (tensor, tensor, index, index, index, index) -> tensor + %953 = tensor.empty() : tensor<128xf64> + %954 = tensor.empty() : tensor<250xf64> + %955 = polygeist.submap(%922, %c2, %c125) {map = #map52} : (tensor<750xf64>, index, index) -> tensor + %956 = polygeist.submap(%954, %c2, %c125) {map = #map50} : (tensor<250xf64>, index, index) -> tensor + %957 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%955 : tensor) outs(%956 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %958 = polygeist.submapInverse(%954, %957, %c2, %c125) {map = #map50} : (tensor<250xf64>, tensor, index, index) -> tensor<250xf64> + %959 = polygeist.submap(%952, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %960 = polygeist.submap(%953, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %961 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%959 : tensor) outs(%960 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %962 = polygeist.submapInverse(%953, %961, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %963 = tensor.empty() : tensor<2x4x4x4xf64> + %964 = tensor.empty() : tensor<2x5x4x4xf64> + %965 = tensor.empty() : tensor<2x5x5x4xf64> + %extracted_slice_179 = tensor.extract_slice %965[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %966 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_179 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_180 = tensor.insert_slice %966 into %965[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor into tensor<2x5x5x4xf64> + %967 = polygeist.submap(%958, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (tensor<250xf64>, index, index, index, index, index) -> tensor + %968 = polygeist.submap(%871, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %969 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%967, %968 : tensor, tensor) outs(%inserted_slice_180 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x4xf64> + %extracted_slice_181 = tensor.extract_slice %964[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %970 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_181 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_182 = tensor.extract_slice %969[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %971 = polygeist.submap(%871, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %972 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_182, %971 : tensor, tensor) outs(%970 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_183 = tensor.extract_slice %963[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %973 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_183 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %974 = polygeist.submap(%871, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %975 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%972, %974 : tensor, tensor) outs(%973 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %976 = polygeist.submap(%962, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %977 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%975 : tensor) outs(%976 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.addf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %978 = polygeist.submapInverse(%962, %977, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %979 = polygeist.submap(%978, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %980 = polygeist.submap(%952, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %981 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%979 : tensor) outs(%980 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %982 = polygeist.submapInverse(%952, %981, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %983 = tensor.empty() : tensor<128xf64> + %984 = tensor.empty() : tensor<250xf64> + %985 = polygeist.submap(%922, %c2, %c125) {map = #map53} : (tensor<750xf64>, index, index) -> tensor + %986 = polygeist.submap(%984, %c2, %c125) {map = #map50} : (tensor<250xf64>, index, index) -> tensor + %987 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%985 : tensor) outs(%986 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %988 = polygeist.submapInverse(%984, %987, %c2, %c125) {map = #map50} : (tensor<250xf64>, tensor, index, index) -> tensor<250xf64> + %989 = polygeist.submap(%982, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %990 = polygeist.submap(%983, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %991 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%989 : tensor) outs(%990 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %992 = polygeist.submapInverse(%983, %991, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %993 = tensor.empty() : tensor<2x4x4x4xf64> + %994 = tensor.empty() : tensor<2x5x4x4xf64> + %995 = tensor.empty() : tensor<2x5x5x4xf64> + %extracted_slice_184 = tensor.extract_slice %995[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %996 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_184 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_185 = tensor.insert_slice %996 into %995[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor into tensor<2x5x5x4xf64> + %997 = polygeist.submap(%988, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (tensor<250xf64>, index, index, index, index, index) -> tensor + %998 = polygeist.submap(%871, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %999 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%997, %998 : tensor, tensor) outs(%inserted_slice_185 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor<2x5x5x4xf64> + %extracted_slice_186 = tensor.extract_slice %994[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : tensor<2x5x4x4xf64> to tensor + %1000 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_186 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %extracted_slice_187 = tensor.extract_slice %999[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : tensor<2x5x5x4xf64> to tensor + %1001 = polygeist.submap(%871, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %1002 = linalg.generic {doc = "", indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%extracted_slice_187, %1001 : tensor, tensor) outs(%1000 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %extracted_slice_188 = tensor.extract_slice %993[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : tensor<2x4x4x4xf64> to tensor + %1003 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_188 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %1004 = polygeist.submap(%871, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor<20xf64>, index, index, index, index, index) -> tensor + %1005 = linalg.generic {doc = "", indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%1002, %1004 : tensor, tensor) outs(%1003 : tensor) { + ^bb0(%in: f64, %in_192: f64, %out: f64): + %1034 = arith.mulf %in, %in_192 : f64 + %1035 = arith.addf %out, %1034 : f64 + linalg.yield %1035 : f64 + } -> tensor + %1006 = polygeist.submap(%992, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %1007 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%1005 : tensor) outs(%1006 : tensor) { + ^bb0(%in: f64, %out: f64): + %1034 = arith.addf %out, %in : f64 + linalg.yield %1034 : f64 + } -> tensor + %1008 = polygeist.submapInverse(%992, %1007, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, tensor, index, index, index, index) -> tensor<128xf64> + %1009 = polygeist.submap(%1008, %c2, %c4, %c4, %c4) {map = #map4} : (tensor<128xf64>, index, index, index, index) -> tensor + %1010 = polygeist.submap(%982, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, index, index, index, index) -> tensor + %1011 = linalg.generic {doc = "", indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%1009 : tensor) outs(%1010 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %1012 = polygeist.submapInverse(%982, %1011, %c2, %c4, %c4, %c4) {map = #map20} : (tensor, tensor, index, index, index, index) -> tensor + %1013 = bufferization.to_memref %1012 : memref + memref.copy %1013, %arg11 : memref to memref + %1014 = tensor.empty() : tensor<2x5x5x5xf64> + %extracted_slice_189 = tensor.extract_slice %1014[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %1015 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%extracted_slice_189 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %inserted_slice_190 = tensor.insert_slice %1015 into %1014[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor into tensor<2x5x5x5xf64> + %1016 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map58} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1017 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map59} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1018 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map60} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1019 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map58} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1020 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map61} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1021 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map62} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1022 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map62} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1023 = polygeist.submap(%9, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map63} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1024 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map64} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1025 = polygeist.submap(%0, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map64} : (tensor, index, index, index, index, index, index, index, index) -> tensor + %1026 = linalg.generic {doc = "", indexing_maps = [#map65, #map65, #map65, #map65, #map65, #map65, #map65, #map65, #map65, #map65, #map66], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction", "reduction"], library_call = ""} ins(%1016, %1017, %1018, %1019, %1020, %1021, %1022, %1023, %1024, %1025 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%inserted_slice_190 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %in_195: f64, %in_196: f64, %in_197: f64, %in_198: f64, %in_199: f64, %in_200: f64, %out: f64): + %1034 = arith.mulf %in_198, %in_199 : f64 + %1035 = arith.mulf %1034, %in_196 : f64 + %1036 = arith.mulf %1035, %in : f64 + %1037 = arith.mulf %1036, %in_192 : f64 + %1038 = arith.addf %out, %1037 : f64 + %1039 = arith.mulf %in_198, %in_200 : f64 + %1040 = arith.mulf %1039, %in_197 : f64 + %1041 = arith.mulf %1040, %in : f64 + %1042 = arith.mulf %1041, %in_193 : f64 + %1043 = arith.addf %1038, %1042 : f64 + %1044 = arith.mulf %1039, %in_196 : f64 + %1045 = arith.mulf %1044, %in_194 : f64 + %1046 = arith.mulf %1045, %in_195 : f64 + %1047 = arith.addf %1043, %1046 : f64 + linalg.yield %1047 : f64 + } -> tensor<2x5x5x5xf64> + %1027 = polygeist.submap(%0, %c2, %c4, %c4, %c4, %c5, %c5, %c5) {map = #map67} : (tensor, index, index, index, index, index, index, index) -> tensor + %1028 = polygeist.submap(%0, %c2, %c4, %c4, %c4, %c5, %c5, %c5) {map = #map68} : (tensor, index, index, index, index, index, index, index) -> tensor + %extracted_slice_191 = tensor.extract_slice %1026[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : tensor<2x5x5x5xf64> to tensor + %1029 = polygeist.submap(%0, %c2, %c4, %c4, %c4, %c5, %c5, %c5) {map = #map69} : (tensor, index, index, index, index, index, index, index) -> tensor + %1030 = polygeist.submap(%864, %c2, %c4, %c4, %c4) {map = #map4} : (tensor, index, index, index, index) -> tensor + %1031 = linalg.generic {doc = "", indexing_maps = [#map47, #map47, #map70, #map47, #map71], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"], library_call = ""} ins(%1027, %1028, %extracted_slice_191, %1029 : tensor, tensor, tensor, tensor) outs(%1030 : tensor) { + ^bb0(%in: f64, %in_192: f64, %in_193: f64, %in_194: f64, %out: f64): + %1034 = arith.mulf %in_193, %in_194 : f64 + %1035 = arith.mulf %1034, %in_192 : f64 + %1036 = arith.mulf %1035, %in : f64 + %1037 = arith.addf %out, %1036 : f64 + linalg.yield %1037 : f64 + } -> tensor + %1032 = polygeist.submapInverse(%864, %1031, %c2, %c4, %c4, %c4) {map = #map4} : (tensor, tensor, index, index, index, index) -> tensor + %1033 = bufferization.to_memref %1032 : memref + memref.copy %1033, %arg12 : memref to memref + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pa_operators_3d.raised.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pa_operators_3d.raised.mlir new file mode 100644 index 000000000000..4ba823221a92 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pa_operators_3d.raised.mlir @@ -0,0 +1,2867 @@ +#map = affine_map<(d0, d1) -> (d1 * 4 + d0)> +#map1 = affine_map<(d0, d1) -> (d1 + d0 * 5)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 192 + d1 * 16 + d2 * 4)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map14 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 125 + d1 * 25 + d2 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 192 + d1 * 16 + d2 * 4 + 64)> +#map20 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 192 + d1 * 16 + d2 * 4 + 128)> +#map21 = affine_map<(d0, d1, d2) -> (d2 + d0 * 2250 + d1 * 125)> +#map22 = affine_map<(d0, d1, d2) -> (d2 + d0 * 750 + d1 * 125)> +#map23 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map24 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 750)> +#map25 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 125)> +#map26 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 250)> +#map27 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 375)> +#map28 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 500)> +#map29 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 625)> +#map30 = affine_map<(d0, d1, d2) -> (d2 + d0 * 2250 + d1 * 125 + 750)> +#map31 = affine_map<(d0, d1, d2) -> (d2 + d0 * 2250 + d1 * 125 + 1500)> +#map32 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d2 * 5 + d0 * 125)> +#map33 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5)> +#map34 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 125)> +#map35 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 250)> +#map36 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d0 * 375 + d2 * 5)> +#map37 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 25 + d2 + d1 * 125 + d0 * 375 + d3 * 5)> +#map38 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 25 + d0 * 1125 + d3 * 5 + d1 * 125)> +#map39 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d0 * 375 + d2 * 5 + 125)> +#map40 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 25 + d0 * 1125 + d3 * 5 + d1 * 125 + 375)> +#map41 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 25 + d0 * 375 + d2 * 5 + 250)> +#map42 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 25 + d0 * 1125 + d3 * 5 + d1 * 125 + 750)> +#map43 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 25 + d0 * 375 + d3 * 5 + d1 * 125)> +#map44 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 * 125 + d4 + d2 * 25 + d0 * 375 + d3 * 5)> +#map45 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 * 125 + d4 + d2 * 25 + d1 * 375 + d0 * 1125 + d3 * 5)> +#map46 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 * 125 + d5 * 375 + d0 * 1125 + d2 * 25 + d4 + d3 * 5)> +#map47 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)> +#map48 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4)> +#map49 = affine_map<(d0, d1) -> (d1 + d0 * 375)> +#map50 = affine_map<(d0, d1) -> (d1 + d0 * 125)> +#map51 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 125)> +#map52 = affine_map<(d0, d1) -> (d1 + d0 * 375 + 125)> +#map53 = affine_map<(d0, d1) -> (d1 + d0 * 375 + 250)> +#map54 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d5 * 125 + d0 * 375 + d2 + d4 * 25 + d3 * 5)> +#map55 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d5 * 125 + d4 + d2 * 25 + d1 * 375 + d0 * 1125 + d3 * 5)> +#map56 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4, d5)> +#map57 = affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1, d2, d3, d4)> +#map58 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d5 + d1 * 4)> +#map59 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4 * 375 + d3 + d1 * 25 + d0 * 1125 + d2 * 5)> +#map60 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4 * 375 + d0 * 1125 + d3 + d1 * 25 + d2 * 5 + 125)> +#map61 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d4 * 375 + d0 * 1125 + d3 + d1 * 25 + d2 * 5 + 250)> +#map62 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d6 + d2 * 4)> +#map63 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d7 + d4 * 64 + d0 * 192 + d5 * 16 + d6 * 4)> +#map64 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d7 + d3 * 4)> +#map65 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3, d4, d5, d6, d7)> +#map66 = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0, d1, d2, d3)> +#map67 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4 * 4 + d1)> +#map68 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5 * 4 + d2)> +#map69 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d6 * 4 + d3)> +#map70 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d4, d5, d6)> +#map71 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_navier_tgv_pa_operators_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref, %arg11: memref, %arg12: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %c6 = arith.constant 6 : index + %c3 = arith.constant 3 : index + %c125 = arith.constant 125 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<20xf64> + %0 = polygeist.submap(%arg0, %c4, %c5) {map = #map} : (memref, index, index) -> memref + %1 = polygeist.submap(%alloca, %c4, %c5) {map = #map1} : (memref<20xf64>, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%0 : memref) outs(%1 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_0 = memref.alloca() : memref<128xf64> + %alloca_1 = memref.alloca() : memref<128xf64> + %2 = polygeist.submap(%arg9, %c2, %c4, %c4, %c4) {map = #map3} : (memref, index, index, index, index) -> memref + %3 = polygeist.submap(%alloca_1, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %4 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map3} : (memref, index, index, index, index) -> memref + %5 = polygeist.submap(%alloca_0, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_5 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x4x4x5xf64> + %subview = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + %7 = polygeist.submap(%alloca_1, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%6, %7 : memref, memref) outs(%alloca_6 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_7 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_7 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_8 = memref.subview %alloca_6[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %subview_9 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map11, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%8, %subview_8 : memref, memref>) outs(%subview_9 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_10 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_10 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %9 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_11 = memref.subview %alloca_5[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %subview_12 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map13, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%9, %subview_11 : memref, memref>) outs(%subview_12 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %10 = polygeist.submap(%arg5, %c2, %c5, %c5, %c5) {map = #map14} : (memref, index, index, index, index) -> memref + %subview_13 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%10 : memref) outs(%subview_13 : memref>) { + ^bb0(%in: f64, %out: f64): + %384 = arith.mulf %out, %in : f64 + linalg.yield %384 : f64 + } + %subview_14 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_14 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %11 = polygeist.submap(%alloca, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_15 = memref.subview %alloca_4[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_16 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map16, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%11, %subview_15 : memref, memref>) outs(%subview_16 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_17 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_17 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %12 = polygeist.submap(%alloca, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_18 = memref.subview %alloca_3[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %subview_19 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map11, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%12, %subview_18 : memref, memref>) outs(%subview_19 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %13 = polygeist.submap(%alloca, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_20 = memref.subview %alloca_2[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %14 = polygeist.submap(%alloca_0, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref<2x4x4x4xf64> + linalg.generic {indexing_maps = [#map8, #map13, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%13, %subview_20 : memref, memref>) outs(%14 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %15 = polygeist.submap(%alloca_0, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + %16 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map3} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%15 : memref) outs(%16 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_21 = memref.alloca() : memref<128xf64> + %alloca_22 = memref.alloca() : memref<128xf64> + %17 = polygeist.submap(%arg9, %c2, %c4, %c4, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + %18 = polygeist.submap(%alloca_22, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%17 : memref) outs(%18 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %19 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + %20 = polygeist.submap(%alloca_21, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%19 : memref) outs(%20 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_23 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_24 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_25 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_26 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_27 = memref.alloca() : memref<2x4x4x5xf64> + %subview_28 = memref.subview %alloca_27[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_28 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %21 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + %22 = polygeist.submap(%alloca_22, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%21, %22 : memref, memref) outs(%alloca_27 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_29 = memref.subview %alloca_26[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_29 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %23 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_30 = memref.subview %alloca_27[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %subview_31 = memref.subview %alloca_26[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map11, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%23, %subview_30 : memref, memref>) outs(%subview_31 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_32 = memref.subview %alloca_25[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_32 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %24 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_33 = memref.subview %alloca_26[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %subview_34 = memref.subview %alloca_25[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map13, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%24, %subview_33 : memref, memref>) outs(%subview_34 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %25 = polygeist.submap(%arg5, %c2, %c5, %c5, %c5) {map = #map14} : (memref, index, index, index, index) -> memref + %subview_35 = memref.subview %alloca_25[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%25 : memref) outs(%subview_35 : memref>) { + ^bb0(%in: f64, %out: f64): + %384 = arith.mulf %out, %in : f64 + linalg.yield %384 : f64 + } + %subview_36 = memref.subview %alloca_24[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_36 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %26 = polygeist.submap(%alloca, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_37 = memref.subview %alloca_25[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_38 = memref.subview %alloca_24[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map16, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%26, %subview_37 : memref, memref>) outs(%subview_38 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_39 = memref.subview %alloca_23[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_39 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %27 = polygeist.submap(%alloca, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_40 = memref.subview %alloca_24[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %subview_41 = memref.subview %alloca_23[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map11, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%27, %subview_40 : memref, memref>) outs(%subview_41 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %28 = polygeist.submap(%alloca, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_42 = memref.subview %alloca_23[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %29 = polygeist.submap(%alloca_21, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref<2x4x4x4xf64> + linalg.generic {indexing_maps = [#map8, #map13, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%28, %subview_42 : memref, memref>) outs(%29 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %30 = polygeist.submap(%alloca_21, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + %31 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%30 : memref) outs(%31 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_43 = memref.alloca() : memref<128xf64> + %alloca_44 = memref.alloca() : memref<128xf64> + %32 = polygeist.submap(%arg9, %c2, %c4, %c4, %c4) {map = #map20} : (memref, index, index, index, index) -> memref + %33 = polygeist.submap(%alloca_44, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%32 : memref) outs(%33 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %34 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map20} : (memref, index, index, index, index) -> memref + %35 = polygeist.submap(%alloca_43, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%34 : memref) outs(%35 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_45 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_46 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_47 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_48 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_49 = memref.alloca() : memref<2x4x4x5xf64> + %subview_50 = memref.subview %alloca_49[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_50 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %36 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + %37 = polygeist.submap(%alloca_44, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%36, %37 : memref, memref) outs(%alloca_49 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_51 = memref.subview %alloca_48[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_51 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %38 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_52 = memref.subview %alloca_49[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %subview_53 = memref.subview %alloca_48[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map11, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%38, %subview_52 : memref, memref>) outs(%subview_53 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_54 = memref.subview %alloca_47[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_54 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %39 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_55 = memref.subview %alloca_48[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %subview_56 = memref.subview %alloca_47[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map13, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%39, %subview_55 : memref, memref>) outs(%subview_56 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %40 = polygeist.submap(%arg5, %c2, %c5, %c5, %c5) {map = #map14} : (memref, index, index, index, index) -> memref + %subview_57 = memref.subview %alloca_47[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%40 : memref) outs(%subview_57 : memref>) { + ^bb0(%in: f64, %out: f64): + %384 = arith.mulf %out, %in : f64 + linalg.yield %384 : f64 + } + %subview_58 = memref.subview %alloca_46[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_58 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %41 = polygeist.submap(%alloca, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_59 = memref.subview %alloca_47[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %subview_60 = memref.subview %alloca_46[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map16, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%41, %subview_59 : memref, memref>) outs(%subview_60 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_61 = memref.subview %alloca_45[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_61 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %42 = polygeist.submap(%alloca, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_62 = memref.subview %alloca_46[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %subview_63 = memref.subview %alloca_45[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map11, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%42, %subview_62 : memref, memref>) outs(%subview_63 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %43 = polygeist.submap(%alloca, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_64 = memref.subview %alloca_45[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %44 = polygeist.submap(%alloca_43, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref<2x4x4x4xf64> + linalg.generic {indexing_maps = [#map8, #map13, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%43, %subview_64 : memref, memref>) outs(%44 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %45 = polygeist.submap(%alloca_43, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + %46 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map20} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%45 : memref) outs(%46 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_65 = memref.alloca() : memref<20xf64> + %alloca_66 = memref.alloca() : memref<20xf64> + %47 = polygeist.submap(%arg0, %c4, %c5) {map = #map} : (memref, index, index) -> memref + %48 = polygeist.submap(%alloca_66, %c4, %c5) {map = #map1} : (memref<20xf64>, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%47 : memref) outs(%48 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %49 = polygeist.submap(%arg1, %c4, %c5) {map = #map} : (memref, index, index) -> memref + %50 = polygeist.submap(%alloca_65, %c4, %c5) {map = #map1} : (memref<20xf64>, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%49 : memref) outs(%50 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_67 = memref.alloca() : memref<128xf64> + %alloca_68 = memref.alloca() : memref<128xf64> + %alloca_69 = memref.alloca() : memref<1500xf64> + %51 = polygeist.submap(%arg6, %c2, %c6, %c125) {map = #map21} : (memref, index, index, index) -> memref + %52 = polygeist.submap(%alloca_69, %c2, %c6, %c125) {map = #map22} : (memref<1500xf64>, index, index, index) -> memref + linalg.generic {indexing_maps = [#map23, #map23], iterator_types = ["parallel", "parallel", "parallel"]} ins(%51 : memref) outs(%52 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %53 = polygeist.submap(%arg9, %c2, %c4, %c4, %c4) {map = #map3} : (memref, index, index, index, index) -> memref + %54 = polygeist.submap(%alloca_68, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%53 : memref) outs(%54 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %55 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map3} : (memref, index, index, index, index) -> memref + %56 = polygeist.submap(%alloca_67, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%55 : memref) outs(%56 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_70 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_71 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_72 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_73 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_74 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_75 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_76 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_77 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_78 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_79 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_80 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_81 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_82 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_83 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_84 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_85 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_86 = memref.alloca() : memref<2x4x4x5xf64> + %subview_87 = memref.subview %alloca_86[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_87 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %57 = polygeist.submap(%alloca_68, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + %58 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%57, %58 : memref, memref) outs(%alloca_86 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_88 = memref.subview %alloca_85[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_88 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %59 = polygeist.submap(%alloca_68, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + %60 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%59, %60 : memref, memref) outs(%alloca_85 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_89 = memref.subview %alloca_84[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_89 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_90 = memref.subview %alloca_85[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %61 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_91 = memref.subview %alloca_84[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_90, %61 : memref>, memref) outs(%subview_91 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_92 = memref.subview %alloca_83[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_92 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_93 = memref.subview %alloca_86[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %62 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_94 = memref.subview %alloca_83[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_93, %62 : memref>, memref) outs(%subview_94 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_95 = memref.subview %alloca_82[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_95 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_96 = memref.subview %alloca_86[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %63 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_97 = memref.subview %alloca_82[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_96, %63 : memref>, memref) outs(%subview_97 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_98 = memref.subview %alloca_81[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_98 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_99 = memref.subview %alloca_84[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %64 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_100 = memref.subview %alloca_81[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_99, %64 : memref>, memref) outs(%subview_100 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_101 = memref.subview %alloca_80[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_101 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_102 = memref.subview %alloca_83[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %65 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_103 = memref.subview %alloca_80[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_102, %65 : memref>, memref) outs(%subview_103 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_104 = memref.subview %alloca_79[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_104 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_105 = memref.subview %alloca_82[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %66 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_106 = memref.subview %alloca_79[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_105, %66 : memref>, memref) outs(%subview_106 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_107 = memref.subview %alloca_78[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_107 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %67 = polygeist.submap(%alloca_69, %c2, %c5, %c5, %c4, %c5) {map = #map24} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_108 = memref.subview %alloca_81[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %68 = polygeist.submap(%alloca_69, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_109 = memref.subview %alloca_80[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %69 = polygeist.submap(%alloca_69, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_110 = memref.subview %alloca_79[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %70 = polygeist.submap(%alloca_65, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_111 = memref.subview %alloca_78[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%67, %subview_108, %68, %subview_109, %69, %subview_110, %70 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_111 : memref>) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %in_564: f64, %in_565: f64, %in_566: f64, %in_567: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.mulf %in_563, %in_564 : f64 + %386 = arith.addf %384, %385 : f64 + %387 = arith.mulf %in_565, %in_566 : f64 + %388 = arith.addf %386, %387 : f64 + %389 = arith.mulf %388, %in_567 : f64 + %390 = arith.addf %out, %389 : f64 + linalg.yield %390 : f64 + } + %subview_112 = memref.subview %alloca_77[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_112 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %71 = polygeist.submap(%alloca_69, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_113 = memref.subview %alloca_81[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %72 = polygeist.submap(%alloca_69, %c2, %c5, %c5, %c4, %c5) {map = #map27} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_114 = memref.subview %alloca_80[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %73 = polygeist.submap(%alloca_69, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_115 = memref.subview %alloca_79[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %74 = polygeist.submap(%alloca_66, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_116 = memref.subview %alloca_77[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%71, %subview_113, %72, %subview_114, %73, %subview_115, %74 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_116 : memref>) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %in_564: f64, %in_565: f64, %in_566: f64, %in_567: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.mulf %in_563, %in_564 : f64 + %386 = arith.addf %384, %385 : f64 + %387 = arith.mulf %in_565, %in_566 : f64 + %388 = arith.addf %386, %387 : f64 + %389 = arith.mulf %388, %in_567 : f64 + %390 = arith.addf %out, %389 : f64 + linalg.yield %390 : f64 + } + %subview_117 = memref.subview %alloca_76[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_117 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %75 = polygeist.submap(%alloca_69, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_118 = memref.subview %alloca_81[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %76 = polygeist.submap(%alloca_69, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_119 = memref.subview %alloca_80[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %77 = polygeist.submap(%alloca_69, %c2, %c5, %c5, %c4, %c5) {map = #map29} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_120 = memref.subview %alloca_79[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %78 = polygeist.submap(%alloca_66, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_121 = memref.subview %alloca_76[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%75, %subview_118, %76, %subview_119, %77, %subview_120, %78 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_121 : memref>) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %in_564: f64, %in_565: f64, %in_566: f64, %in_567: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.mulf %in_563, %in_564 : f64 + %386 = arith.addf %384, %385 : f64 + %387 = arith.mulf %in_565, %in_566 : f64 + %388 = arith.addf %386, %387 : f64 + %389 = arith.mulf %388, %in_567 : f64 + %390 = arith.addf %out, %389 : f64 + linalg.yield %390 : f64 + } + %subview_122 = memref.subview %alloca_75[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_122 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_123 = memref.subview %alloca_78[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %79 = polygeist.submap(%alloca_66, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_124 = memref.subview %alloca_75[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_123, %79 : memref>, memref) outs(%subview_124 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_125 = memref.subview %alloca_74[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_125 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_126 = memref.subview %alloca_77[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %80 = polygeist.submap(%alloca_65, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_127 = memref.subview %alloca_74[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_126, %80 : memref>, memref) outs(%subview_127 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_128 = memref.subview %alloca_73[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_128 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_129 = memref.subview %alloca_76[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %81 = polygeist.submap(%alloca_66, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_130 = memref.subview %alloca_73[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_129, %81 : memref>, memref) outs(%subview_130 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_131 = memref.subview %alloca_72[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_131 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_132 = memref.subview %alloca_75[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %82 = polygeist.submap(%alloca_66, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_133 = memref.subview %alloca_72[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_132, %82 : memref>, memref) outs(%subview_133 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_134 = memref.subview %alloca_71[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_134 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_135 = memref.subview %alloca_74[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %83 = polygeist.submap(%alloca_66, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_136 = memref.subview %alloca_71[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_135, %83 : memref>, memref) outs(%subview_136 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_137 = memref.subview %alloca_70[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_137 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_138 = memref.subview %alloca_73[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %84 = polygeist.submap(%alloca_65, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_139 = memref.subview %alloca_70[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_138, %84 : memref>, memref) outs(%subview_139 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_140 = memref.subview %alloca_72[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_141 = memref.subview %alloca_71[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_142 = memref.subview %alloca_70[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %85 = polygeist.submap(%alloca_67, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_140, %subview_141, %subview_142 : memref>, memref>, memref>) outs(%85 : memref) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %out: f64): + %384 = arith.addf %in, %in_562 : f64 + %385 = arith.addf %384, %in_563 : f64 + %386 = arith.addf %out, %385 : f64 + linalg.yield %386 : f64 + } + %86 = polygeist.submap(%alloca_67, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + %87 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map3} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%86 : memref) outs(%87 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_143 = memref.alloca() : memref<128xf64> + %alloca_144 = memref.alloca() : memref<128xf64> + %alloca_145 = memref.alloca() : memref<1500xf64> + %88 = polygeist.submap(%arg6, %c2, %c6, %c125) {map = #map30} : (memref, index, index, index) -> memref + %89 = polygeist.submap(%alloca_145, %c2, %c6, %c125) {map = #map22} : (memref<1500xf64>, index, index, index) -> memref + linalg.generic {indexing_maps = [#map23, #map23], iterator_types = ["parallel", "parallel", "parallel"]} ins(%88 : memref) outs(%89 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %90 = polygeist.submap(%arg9, %c2, %c4, %c4, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + %91 = polygeist.submap(%alloca_144, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%90 : memref) outs(%91 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %92 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + %93 = polygeist.submap(%alloca_143, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%92 : memref) outs(%93 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_146 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_147 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_148 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_149 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_150 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_151 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_152 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_153 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_154 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_155 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_156 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_157 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_158 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_159 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_160 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_161 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_162 = memref.alloca() : memref<2x4x4x5xf64> + %subview_163 = memref.subview %alloca_162[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_163 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %94 = polygeist.submap(%alloca_144, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + %95 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%94, %95 : memref, memref) outs(%alloca_162 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_164 = memref.subview %alloca_161[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_164 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %96 = polygeist.submap(%alloca_144, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + %97 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%96, %97 : memref, memref) outs(%alloca_161 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_165 = memref.subview %alloca_160[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_165 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_166 = memref.subview %alloca_161[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %98 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_167 = memref.subview %alloca_160[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_166, %98 : memref>, memref) outs(%subview_167 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_168 = memref.subview %alloca_159[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_168 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_169 = memref.subview %alloca_162[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %99 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_170 = memref.subview %alloca_159[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_169, %99 : memref>, memref) outs(%subview_170 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_171 = memref.subview %alloca_158[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_171 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_172 = memref.subview %alloca_162[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %100 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_173 = memref.subview %alloca_158[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_172, %100 : memref>, memref) outs(%subview_173 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_174 = memref.subview %alloca_157[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_174 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_175 = memref.subview %alloca_160[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %101 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_176 = memref.subview %alloca_157[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_175, %101 : memref>, memref) outs(%subview_176 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_177 = memref.subview %alloca_156[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_177 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_178 = memref.subview %alloca_159[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %102 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_179 = memref.subview %alloca_156[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_178, %102 : memref>, memref) outs(%subview_179 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_180 = memref.subview %alloca_155[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_180 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_181 = memref.subview %alloca_158[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %103 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_182 = memref.subview %alloca_155[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_181, %103 : memref>, memref) outs(%subview_182 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_183 = memref.subview %alloca_154[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_183 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %104 = polygeist.submap(%alloca_145, %c2, %c5, %c5, %c4, %c5) {map = #map24} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_184 = memref.subview %alloca_157[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %105 = polygeist.submap(%alloca_145, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_185 = memref.subview %alloca_156[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %106 = polygeist.submap(%alloca_145, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_186 = memref.subview %alloca_155[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %107 = polygeist.submap(%alloca_65, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_187 = memref.subview %alloca_154[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%104, %subview_184, %105, %subview_185, %106, %subview_186, %107 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_187 : memref>) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %in_564: f64, %in_565: f64, %in_566: f64, %in_567: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.mulf %in_563, %in_564 : f64 + %386 = arith.addf %384, %385 : f64 + %387 = arith.mulf %in_565, %in_566 : f64 + %388 = arith.addf %386, %387 : f64 + %389 = arith.mulf %388, %in_567 : f64 + %390 = arith.addf %out, %389 : f64 + linalg.yield %390 : f64 + } + %subview_188 = memref.subview %alloca_153[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_188 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %108 = polygeist.submap(%alloca_145, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_189 = memref.subview %alloca_157[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %109 = polygeist.submap(%alloca_145, %c2, %c5, %c5, %c4, %c5) {map = #map27} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_190 = memref.subview %alloca_156[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %110 = polygeist.submap(%alloca_145, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_191 = memref.subview %alloca_155[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %111 = polygeist.submap(%alloca_66, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_192 = memref.subview %alloca_153[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%108, %subview_189, %109, %subview_190, %110, %subview_191, %111 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_192 : memref>) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %in_564: f64, %in_565: f64, %in_566: f64, %in_567: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.mulf %in_563, %in_564 : f64 + %386 = arith.addf %384, %385 : f64 + %387 = arith.mulf %in_565, %in_566 : f64 + %388 = arith.addf %386, %387 : f64 + %389 = arith.mulf %388, %in_567 : f64 + %390 = arith.addf %out, %389 : f64 + linalg.yield %390 : f64 + } + %subview_193 = memref.subview %alloca_152[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_193 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %112 = polygeist.submap(%alloca_145, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_194 = memref.subview %alloca_157[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %113 = polygeist.submap(%alloca_145, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_195 = memref.subview %alloca_156[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %114 = polygeist.submap(%alloca_145, %c2, %c5, %c5, %c4, %c5) {map = #map29} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_196 = memref.subview %alloca_155[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %115 = polygeist.submap(%alloca_66, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_197 = memref.subview %alloca_152[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%112, %subview_194, %113, %subview_195, %114, %subview_196, %115 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_197 : memref>) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %in_564: f64, %in_565: f64, %in_566: f64, %in_567: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.mulf %in_563, %in_564 : f64 + %386 = arith.addf %384, %385 : f64 + %387 = arith.mulf %in_565, %in_566 : f64 + %388 = arith.addf %386, %387 : f64 + %389 = arith.mulf %388, %in_567 : f64 + %390 = arith.addf %out, %389 : f64 + linalg.yield %390 : f64 + } + %subview_198 = memref.subview %alloca_151[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_198 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_199 = memref.subview %alloca_154[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %116 = polygeist.submap(%alloca_66, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_200 = memref.subview %alloca_151[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_199, %116 : memref>, memref) outs(%subview_200 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_201 = memref.subview %alloca_150[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_201 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_202 = memref.subview %alloca_153[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %117 = polygeist.submap(%alloca_65, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_203 = memref.subview %alloca_150[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_202, %117 : memref>, memref) outs(%subview_203 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_204 = memref.subview %alloca_149[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_204 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_205 = memref.subview %alloca_152[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %118 = polygeist.submap(%alloca_66, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_206 = memref.subview %alloca_149[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_205, %118 : memref>, memref) outs(%subview_206 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_207 = memref.subview %alloca_148[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_207 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_208 = memref.subview %alloca_151[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %119 = polygeist.submap(%alloca_66, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_209 = memref.subview %alloca_148[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_208, %119 : memref>, memref) outs(%subview_209 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_210 = memref.subview %alloca_147[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_210 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_211 = memref.subview %alloca_150[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %120 = polygeist.submap(%alloca_66, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_212 = memref.subview %alloca_147[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_211, %120 : memref>, memref) outs(%subview_212 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_213 = memref.subview %alloca_146[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_213 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_214 = memref.subview %alloca_149[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %121 = polygeist.submap(%alloca_65, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_215 = memref.subview %alloca_146[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_214, %121 : memref>, memref) outs(%subview_215 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_216 = memref.subview %alloca_148[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_217 = memref.subview %alloca_147[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_218 = memref.subview %alloca_146[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %122 = polygeist.submap(%alloca_143, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_216, %subview_217, %subview_218 : memref>, memref>, memref>) outs(%122 : memref) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %out: f64): + %384 = arith.addf %in, %in_562 : f64 + %385 = arith.addf %384, %in_563 : f64 + %386 = arith.addf %out, %385 : f64 + linalg.yield %386 : f64 + } + %123 = polygeist.submap(%alloca_143, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + %124 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%123 : memref) outs(%124 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_219 = memref.alloca() : memref<128xf64> + %alloca_220 = memref.alloca() : memref<128xf64> + %alloca_221 = memref.alloca() : memref<1500xf64> + %125 = polygeist.submap(%arg6, %c2, %c6, %c125) {map = #map31} : (memref, index, index, index) -> memref + %126 = polygeist.submap(%alloca_221, %c2, %c6, %c125) {map = #map22} : (memref<1500xf64>, index, index, index) -> memref + linalg.generic {indexing_maps = [#map23, #map23], iterator_types = ["parallel", "parallel", "parallel"]} ins(%125 : memref) outs(%126 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %127 = polygeist.submap(%arg9, %c2, %c4, %c4, %c4) {map = #map20} : (memref, index, index, index, index) -> memref + %128 = polygeist.submap(%alloca_220, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%127 : memref) outs(%128 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %129 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map20} : (memref, index, index, index, index) -> memref + %130 = polygeist.submap(%alloca_219, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%129 : memref) outs(%130 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_222 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_223 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_224 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_225 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_226 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_227 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_228 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_229 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_230 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_231 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_232 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_233 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_234 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_235 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_236 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_237 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_238 = memref.alloca() : memref<2x4x4x5xf64> + %subview_239 = memref.subview %alloca_238[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_239 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %131 = polygeist.submap(%alloca_220, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + %132 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%131, %132 : memref, memref) outs(%alloca_238 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_240 = memref.subview %alloca_237[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_240 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %133 = polygeist.submap(%alloca_220, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + %134 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%133, %134 : memref, memref) outs(%alloca_237 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_241 = memref.subview %alloca_236[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_241 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_242 = memref.subview %alloca_237[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %135 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_243 = memref.subview %alloca_236[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_242, %135 : memref>, memref) outs(%subview_243 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_244 = memref.subview %alloca_235[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_244 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_245 = memref.subview %alloca_238[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %136 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_246 = memref.subview %alloca_235[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_245, %136 : memref>, memref) outs(%subview_246 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_247 = memref.subview %alloca_234[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_247 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_248 = memref.subview %alloca_238[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %137 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_249 = memref.subview %alloca_234[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_248, %137 : memref>, memref) outs(%subview_249 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_250 = memref.subview %alloca_233[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_250 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_251 = memref.subview %alloca_236[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %138 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_252 = memref.subview %alloca_233[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_251, %138 : memref>, memref) outs(%subview_252 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_253 = memref.subview %alloca_232[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_253 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_254 = memref.subview %alloca_235[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %139 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_255 = memref.subview %alloca_232[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_254, %139 : memref>, memref) outs(%subview_255 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_256 = memref.subview %alloca_231[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_256 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_257 = memref.subview %alloca_234[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %140 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_258 = memref.subview %alloca_231[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_257, %140 : memref>, memref) outs(%subview_258 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_259 = memref.subview %alloca_230[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_259 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %141 = polygeist.submap(%alloca_221, %c2, %c5, %c5, %c4, %c5) {map = #map24} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_260 = memref.subview %alloca_233[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %142 = polygeist.submap(%alloca_221, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_261 = memref.subview %alloca_232[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %143 = polygeist.submap(%alloca_221, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_262 = memref.subview %alloca_231[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %144 = polygeist.submap(%alloca_65, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_263 = memref.subview %alloca_230[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%141, %subview_260, %142, %subview_261, %143, %subview_262, %144 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_263 : memref>) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %in_564: f64, %in_565: f64, %in_566: f64, %in_567: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.mulf %in_563, %in_564 : f64 + %386 = arith.addf %384, %385 : f64 + %387 = arith.mulf %in_565, %in_566 : f64 + %388 = arith.addf %386, %387 : f64 + %389 = arith.mulf %388, %in_567 : f64 + %390 = arith.addf %out, %389 : f64 + linalg.yield %390 : f64 + } + %subview_264 = memref.subview %alloca_229[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_264 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %145 = polygeist.submap(%alloca_221, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_265 = memref.subview %alloca_233[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %146 = polygeist.submap(%alloca_221, %c2, %c5, %c5, %c4, %c5) {map = #map27} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_266 = memref.subview %alloca_232[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %147 = polygeist.submap(%alloca_221, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_267 = memref.subview %alloca_231[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %148 = polygeist.submap(%alloca_66, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_268 = memref.subview %alloca_229[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%145, %subview_265, %146, %subview_266, %147, %subview_267, %148 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_268 : memref>) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %in_564: f64, %in_565: f64, %in_566: f64, %in_567: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.mulf %in_563, %in_564 : f64 + %386 = arith.addf %384, %385 : f64 + %387 = arith.mulf %in_565, %in_566 : f64 + %388 = arith.addf %386, %387 : f64 + %389 = arith.mulf %388, %in_567 : f64 + %390 = arith.addf %out, %389 : f64 + linalg.yield %390 : f64 + } + %subview_269 = memref.subview %alloca_228[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_269 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %149 = polygeist.submap(%alloca_221, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_270 = memref.subview %alloca_233[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %150 = polygeist.submap(%alloca_221, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_271 = memref.subview %alloca_232[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %151 = polygeist.submap(%alloca_221, %c2, %c5, %c5, %c4, %c5) {map = #map29} : (memref<1500xf64>, index, index, index, index, index) -> memref + %subview_272 = memref.subview %alloca_231[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %152 = polygeist.submap(%alloca_66, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_273 = memref.subview %alloca_228[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%149, %subview_270, %150, %subview_271, %151, %subview_272, %152 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_273 : memref>) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %in_564: f64, %in_565: f64, %in_566: f64, %in_567: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.mulf %in_563, %in_564 : f64 + %386 = arith.addf %384, %385 : f64 + %387 = arith.mulf %in_565, %in_566 : f64 + %388 = arith.addf %386, %387 : f64 + %389 = arith.mulf %388, %in_567 : f64 + %390 = arith.addf %out, %389 : f64 + linalg.yield %390 : f64 + } + %subview_274 = memref.subview %alloca_227[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_274 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_275 = memref.subview %alloca_230[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %153 = polygeist.submap(%alloca_66, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_276 = memref.subview %alloca_227[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_275, %153 : memref>, memref) outs(%subview_276 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_277 = memref.subview %alloca_226[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_277 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_278 = memref.subview %alloca_229[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %154 = polygeist.submap(%alloca_65, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_279 = memref.subview %alloca_226[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_278, %154 : memref>, memref) outs(%subview_279 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_280 = memref.subview %alloca_225[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_280 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_281 = memref.subview %alloca_228[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %155 = polygeist.submap(%alloca_66, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_282 = memref.subview %alloca_225[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_281, %155 : memref>, memref) outs(%subview_282 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_283 = memref.subview %alloca_224[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_283 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_284 = memref.subview %alloca_227[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %156 = polygeist.submap(%alloca_66, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_285 = memref.subview %alloca_224[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_284, %156 : memref>, memref) outs(%subview_285 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_286 = memref.subview %alloca_223[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_286 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_287 = memref.subview %alloca_226[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %157 = polygeist.submap(%alloca_66, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_288 = memref.subview %alloca_223[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_287, %157 : memref>, memref) outs(%subview_288 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_289 = memref.subview %alloca_222[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_289 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_290 = memref.subview %alloca_225[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %158 = polygeist.submap(%alloca_65, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_291 = memref.subview %alloca_222[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_290, %158 : memref>, memref) outs(%subview_291 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_292 = memref.subview %alloca_224[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_293 = memref.subview %alloca_223[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_294 = memref.subview %alloca_222[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %159 = polygeist.submap(%alloca_219, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_292, %subview_293, %subview_294 : memref>, memref>, memref>) outs(%159 : memref) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %out: f64): + %384 = arith.addf %in, %in_562 : f64 + %385 = arith.addf %384, %in_563 : f64 + %386 = arith.addf %out, %385 : f64 + linalg.yield %386 : f64 + } + %160 = polygeist.submap(%alloca_219, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + %161 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map20} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%160 : memref) outs(%161 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_295 = memref.alloca() : memref<750xf64> + %alloca_296 = memref.alloca() : memref<2250xf64> + %alloca_297 = memref.alloca() : memref<750xf64> + %alloca_298 = memref.alloca() : memref<20xf64> + %162 = polygeist.submap(%arg0, %c4, %c5) {map = #map} : (memref, index, index) -> memref + %163 = polygeist.submap(%alloca_298, %c4, %c5) {map = #map1} : (memref<20xf64>, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%162 : memref) outs(%163 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_299 = memref.alloca() : memref<750xf64> + %alloca_300 = memref.alloca() : memref<250xf64> + %alloca_301 = memref.alloca() : memref<128xf64> + %164 = polygeist.submap(%arg9, %c2, %c4, %c4, %c4) {map = #map3} : (memref, index, index, index, index) -> memref + %165 = polygeist.submap(%alloca_301, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%164 : memref) outs(%165 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_302 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_303 = memref.alloca() : memref<2x4x4x5xf64> + %subview_304 = memref.subview %alloca_303[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_304 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %166 = polygeist.submap(%alloca_301, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + %167 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%166, %167 : memref, memref) outs(%alloca_303 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_305 = memref.subview %alloca_302[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_305 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_306 = memref.subview %alloca_303[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %168 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_307 = memref.subview %alloca_302[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_306, %168 : memref>, memref) outs(%subview_307 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %169 = polygeist.submap(%alloca_300, %c2, %c5, %c5, %c5) {map = #map32} : (memref<250xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%169 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_308 = memref.subview %alloca_302[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %170 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %171 = polygeist.submap(%alloca_300, %c2, %c5, %c5, %c5) {map = #map32} : (memref<250xf64>, index, index, index, index) -> memref<2x5x5x5xf64> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_308, %170 : memref>, memref) outs(%171 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %alloca_309 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_310 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_311 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_312 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_313 = memref.alloca() : memref<2x4x4x5xf64> + %subview_314 = memref.subview %alloca_313[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_314 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %172 = polygeist.submap(%alloca_301, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + %173 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%172, %173 : memref, memref) outs(%alloca_313 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_315 = memref.subview %alloca_312[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_315 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %174 = polygeist.submap(%alloca_301, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + %175 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%174, %175 : memref, memref) outs(%alloca_312 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_316 = memref.subview %alloca_311[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_316 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_317 = memref.subview %alloca_312[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %176 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_318 = memref.subview %alloca_311[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_317, %176 : memref>, memref) outs(%subview_318 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_319 = memref.subview %alloca_310[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_319 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_320 = memref.subview %alloca_313[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %177 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_321 = memref.subview %alloca_310[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_320, %177 : memref>, memref) outs(%subview_321 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_322 = memref.subview %alloca_309[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_322 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_323 = memref.subview %alloca_313[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %178 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_324 = memref.subview %alloca_309[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_323, %178 : memref>, memref) outs(%subview_324 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %179 = polygeist.submap(%alloca_299, %c2, %c5, %c5, %c5) {map = #map33} : (memref<750xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%179 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_325 = memref.subview %alloca_311[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %180 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %181 = polygeist.submap(%alloca_299, %c2, %c5, %c5, %c5) {map = #map33} : (memref<750xf64>, index, index, index, index) -> memref<2x5x5x5xf64> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_325, %180 : memref>, memref) outs(%181 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %182 = polygeist.submap(%alloca_299, %c2, %c5, %c5, %c5) {map = #map34} : (memref<750xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%182 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_326 = memref.subview %alloca_310[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %183 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %184 = polygeist.submap(%alloca_299, %c2, %c5, %c5, %c5) {map = #map34} : (memref<750xf64>, index, index, index, index) -> memref<2x5x5x5xf64> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_326, %183 : memref>, memref) outs(%184 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %185 = polygeist.submap(%alloca_299, %c2, %c5, %c5, %c5) {map = #map35} : (memref<750xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%185 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_327 = memref.subview %alloca_309[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %186 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %187 = polygeist.submap(%alloca_299, %c2, %c5, %c5, %c5) {map = #map35} : (memref<750xf64>, index, index, index, index) -> memref<2x5x5x5xf64> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_327, %186 : memref>, memref) outs(%187 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %188 = polygeist.submap(%alloca_300, %c2, %c5, %c5, %c5) {map = #map32} : (memref<250xf64>, index, index, index, index) -> memref + %189 = polygeist.submap(%alloca_297, %c2, %c5, %c5, %c5) {map = #map36} : (memref<750xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%188 : memref) outs(%189 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %190 = polygeist.submap(%alloca_299, %c2, %c3, %c5, %c5, %c5) {map = #map37} : (memref<750xf64>, index, index, index, index, index) -> memref + %191 = polygeist.submap(%alloca_296, %c2, %c3, %c5, %c5, %c5) {map = #map38} : (memref<2250xf64>, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%190 : memref) outs(%191 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_328 = memref.alloca() : memref<750xf64> + %alloca_329 = memref.alloca() : memref<250xf64> + %alloca_330 = memref.alloca() : memref<128xf64> + %192 = polygeist.submap(%arg9, %c2, %c4, %c4, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + %193 = polygeist.submap(%alloca_330, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%192 : memref) outs(%193 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_331 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_332 = memref.alloca() : memref<2x4x4x5xf64> + %subview_333 = memref.subview %alloca_332[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_333 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %194 = polygeist.submap(%alloca_330, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + %195 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%194, %195 : memref, memref) outs(%alloca_332 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_334 = memref.subview %alloca_331[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_334 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_335 = memref.subview %alloca_332[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %196 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_336 = memref.subview %alloca_331[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_335, %196 : memref>, memref) outs(%subview_336 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %197 = polygeist.submap(%alloca_329, %c2, %c5, %c5, %c5) {map = #map32} : (memref<250xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%197 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_337 = memref.subview %alloca_331[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %198 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %199 = polygeist.submap(%alloca_329, %c2, %c5, %c5, %c5) {map = #map32} : (memref<250xf64>, index, index, index, index) -> memref<2x5x5x5xf64> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_337, %198 : memref>, memref) outs(%199 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %alloca_338 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_339 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_340 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_341 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_342 = memref.alloca() : memref<2x4x4x5xf64> + %subview_343 = memref.subview %alloca_342[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_343 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %200 = polygeist.submap(%alloca_330, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + %201 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%200, %201 : memref, memref) outs(%alloca_342 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_344 = memref.subview %alloca_341[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_344 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %202 = polygeist.submap(%alloca_330, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + %203 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%202, %203 : memref, memref) outs(%alloca_341 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_345 = memref.subview %alloca_340[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_345 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_346 = memref.subview %alloca_341[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %204 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_347 = memref.subview %alloca_340[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_346, %204 : memref>, memref) outs(%subview_347 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_348 = memref.subview %alloca_339[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_348 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_349 = memref.subview %alloca_342[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %205 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_350 = memref.subview %alloca_339[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_349, %205 : memref>, memref) outs(%subview_350 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_351 = memref.subview %alloca_338[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_351 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_352 = memref.subview %alloca_342[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %206 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_353 = memref.subview %alloca_338[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_352, %206 : memref>, memref) outs(%subview_353 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %207 = polygeist.submap(%alloca_328, %c2, %c5, %c5, %c5) {map = #map33} : (memref<750xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%207 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_354 = memref.subview %alloca_340[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %208 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %209 = polygeist.submap(%alloca_328, %c2, %c5, %c5, %c5) {map = #map33} : (memref<750xf64>, index, index, index, index) -> memref<2x5x5x5xf64> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_354, %208 : memref>, memref) outs(%209 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %210 = polygeist.submap(%alloca_328, %c2, %c5, %c5, %c5) {map = #map34} : (memref<750xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%210 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_355 = memref.subview %alloca_339[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %211 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %212 = polygeist.submap(%alloca_328, %c2, %c5, %c5, %c5) {map = #map34} : (memref<750xf64>, index, index, index, index) -> memref<2x5x5x5xf64> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_355, %211 : memref>, memref) outs(%212 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %213 = polygeist.submap(%alloca_328, %c2, %c5, %c5, %c5) {map = #map35} : (memref<750xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%213 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_356 = memref.subview %alloca_338[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %214 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %215 = polygeist.submap(%alloca_328, %c2, %c5, %c5, %c5) {map = #map35} : (memref<750xf64>, index, index, index, index) -> memref<2x5x5x5xf64> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_356, %214 : memref>, memref) outs(%215 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %216 = polygeist.submap(%alloca_329, %c2, %c5, %c5, %c5) {map = #map32} : (memref<250xf64>, index, index, index, index) -> memref + %217 = polygeist.submap(%alloca_297, %c2, %c5, %c5, %c5) {map = #map39} : (memref<750xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%216 : memref) outs(%217 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %218 = polygeist.submap(%alloca_328, %c2, %c3, %c5, %c5, %c5) {map = #map37} : (memref<750xf64>, index, index, index, index, index) -> memref + %219 = polygeist.submap(%alloca_296, %c2, %c3, %c5, %c5, %c5) {map = #map40} : (memref<2250xf64>, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%218 : memref) outs(%219 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_357 = memref.alloca() : memref<750xf64> + %alloca_358 = memref.alloca() : memref<250xf64> + %alloca_359 = memref.alloca() : memref<128xf64> + %220 = polygeist.submap(%arg9, %c2, %c4, %c4, %c4) {map = #map20} : (memref, index, index, index, index) -> memref + %221 = polygeist.submap(%alloca_359, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%220 : memref) outs(%221 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_360 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_361 = memref.alloca() : memref<2x4x4x5xf64> + %subview_362 = memref.subview %alloca_361[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_362 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %222 = polygeist.submap(%alloca_359, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + %223 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%222, %223 : memref, memref) outs(%alloca_361 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_363 = memref.subview %alloca_360[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_363 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_364 = memref.subview %alloca_361[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %224 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_365 = memref.subview %alloca_360[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_364, %224 : memref>, memref) outs(%subview_365 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %225 = polygeist.submap(%alloca_358, %c2, %c5, %c5, %c5) {map = #map32} : (memref<250xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%225 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_366 = memref.subview %alloca_360[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %226 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %227 = polygeist.submap(%alloca_358, %c2, %c5, %c5, %c5) {map = #map32} : (memref<250xf64>, index, index, index, index) -> memref<2x5x5x5xf64> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_366, %226 : memref>, memref) outs(%227 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %alloca_367 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_368 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_369 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_370 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_371 = memref.alloca() : memref<2x4x4x5xf64> + %subview_372 = memref.subview %alloca_371[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_372 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %228 = polygeist.submap(%alloca_359, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + %229 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%228, %229 : memref, memref) outs(%alloca_371 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_373 = memref.subview %alloca_370[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_373 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %230 = polygeist.submap(%alloca_359, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref<128xf64>, index, index, index, index, index) -> memref + %231 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%230, %231 : memref, memref) outs(%alloca_370 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_374 = memref.subview %alloca_369[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_374 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_375 = memref.subview %alloca_370[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %232 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_376 = memref.subview %alloca_369[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_375, %232 : memref>, memref) outs(%subview_376 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_377 = memref.subview %alloca_368[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_377 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_378 = memref.subview %alloca_371[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %233 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_379 = memref.subview %alloca_368[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_378, %233 : memref>, memref) outs(%subview_379 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_380 = memref.subview %alloca_367[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_380 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_381 = memref.subview %alloca_371[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %234 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_382 = memref.subview %alloca_367[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_381, %234 : memref>, memref) outs(%subview_382 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %235 = polygeist.submap(%alloca_357, %c2, %c5, %c5, %c5) {map = #map33} : (memref<750xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%235 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_383 = memref.subview %alloca_369[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %236 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %237 = polygeist.submap(%alloca_357, %c2, %c5, %c5, %c5) {map = #map33} : (memref<750xf64>, index, index, index, index) -> memref<2x5x5x5xf64> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_383, %236 : memref>, memref) outs(%237 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %238 = polygeist.submap(%alloca_357, %c2, %c5, %c5, %c5) {map = #map34} : (memref<750xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%238 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_384 = memref.subview %alloca_368[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %239 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %240 = polygeist.submap(%alloca_357, %c2, %c5, %c5, %c5) {map = #map34} : (memref<750xf64>, index, index, index, index) -> memref<2x5x5x5xf64> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_384, %239 : memref>, memref) outs(%240 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %241 = polygeist.submap(%alloca_357, %c2, %c5, %c5, %c5) {map = #map35} : (memref<750xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%241 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_385 = memref.subview %alloca_367[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %242 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %243 = polygeist.submap(%alloca_357, %c2, %c5, %c5, %c5) {map = #map35} : (memref<750xf64>, index, index, index, index) -> memref<2x5x5x5xf64> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_385, %242 : memref>, memref) outs(%243 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %244 = polygeist.submap(%alloca_358, %c2, %c5, %c5, %c5) {map = #map32} : (memref<250xf64>, index, index, index, index) -> memref + %245 = polygeist.submap(%alloca_297, %c2, %c5, %c5, %c5) {map = #map41} : (memref<750xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%244 : memref) outs(%245 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %246 = polygeist.submap(%alloca_357, %c2, %c3, %c5, %c5, %c5) {map = #map37} : (memref<750xf64>, index, index, index, index, index) -> memref + %247 = polygeist.submap(%alloca_296, %c2, %c3, %c5, %c5, %c5) {map = #map42} : (memref<2250xf64>, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} ins(%246 : memref) outs(%247 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %248 = polygeist.submap(%alloca_295, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (memref<750xf64>, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} outs(%248 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %249 = polygeist.submap(%alloca_297, %c2, %c3, %c5, %c5, %c5, %c3, %c3) {map = #map44} : (memref<750xf64>, index, index, index, index, index, index, index) -> memref + %250 = polygeist.submap(%alloca_296, %c2, %c3, %c5, %c5, %c5, %c3, %c3) {map = #map45} : (memref<2250xf64>, index, index, index, index, index, index, index) -> memref + %251 = polygeist.submap(%arg7, %c2, %c3, %c5, %c5, %c5, %c3, %c3) {map = #map46} : (memref, index, index, index, index, index, index, index) -> memref + %252 = polygeist.submap(%alloca_295, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (memref<750xf64>, index, index, index, index, index) -> memref<2x3x5x5x5xf64> + linalg.generic {indexing_maps = [#map47, #map47, #map47, #map48], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction"]} ins(%249, %250, %251 : memref, memref, memref) outs(%252 : memref<2x3x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.mulf %384, %in_563 : f64 + %386 = arith.addf %out, %385 : f64 + linalg.yield %386 : f64 + } + %alloca_386 = memref.alloca() : memref<128xf64> + %alloca_387 = memref.alloca() : memref<250xf64> + %253 = polygeist.submap(%alloca_295, %c2, %c125) {map = #map49} : (memref<750xf64>, index, index) -> memref + %254 = polygeist.submap(%alloca_387, %c2, %c125) {map = #map50} : (memref<250xf64>, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%253 : memref) outs(%254 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %255 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map3} : (memref, index, index, index, index) -> memref + %256 = polygeist.submap(%alloca_386, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%255 : memref) outs(%256 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_388 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_389 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_390 = memref.alloca() : memref<2x5x5x4xf64> + %subview_391 = memref.subview %alloca_390[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_391 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %257 = polygeist.submap(%alloca_387, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (memref<250xf64>, index, index, index, index, index) -> memref + %258 = polygeist.submap(%alloca_298, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%257, %258 : memref, memref) outs(%alloca_390 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_392 = memref.subview %alloca_389[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_392 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_393 = memref.subview %alloca_390[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %259 = polygeist.submap(%alloca_298, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_394 = memref.subview %alloca_389[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_393, %259 : memref>, memref) outs(%subview_394 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_395 = memref.subview %alloca_388[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_395 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_396 = memref.subview %alloca_389[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %260 = polygeist.submap(%alloca_298, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_397 = memref.subview %alloca_388[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_396, %260 : memref>, memref) outs(%subview_397 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_398 = memref.subview %alloca_388[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %261 = polygeist.submap(%alloca_386, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_398 : memref>) outs(%261 : memref) { + ^bb0(%in: f64, %out: f64): + %384 = arith.addf %out, %in : f64 + linalg.yield %384 : f64 + } + %262 = polygeist.submap(%alloca_386, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + %263 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map3} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%262 : memref) outs(%263 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_399 = memref.alloca() : memref<128xf64> + %alloca_400 = memref.alloca() : memref<250xf64> + %264 = polygeist.submap(%alloca_295, %c2, %c125) {map = #map52} : (memref<750xf64>, index, index) -> memref + %265 = polygeist.submap(%alloca_400, %c2, %c125) {map = #map50} : (memref<250xf64>, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%264 : memref) outs(%265 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %266 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + %267 = polygeist.submap(%alloca_399, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%266 : memref) outs(%267 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_401 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_402 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_403 = memref.alloca() : memref<2x5x5x4xf64> + %subview_404 = memref.subview %alloca_403[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_404 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %268 = polygeist.submap(%alloca_400, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (memref<250xf64>, index, index, index, index, index) -> memref + %269 = polygeist.submap(%alloca_298, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%268, %269 : memref, memref) outs(%alloca_403 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_405 = memref.subview %alloca_402[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_405 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_406 = memref.subview %alloca_403[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %270 = polygeist.submap(%alloca_298, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_407 = memref.subview %alloca_402[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_406, %270 : memref>, memref) outs(%subview_407 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_408 = memref.subview %alloca_401[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_408 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_409 = memref.subview %alloca_402[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %271 = polygeist.submap(%alloca_298, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_410 = memref.subview %alloca_401[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_409, %271 : memref>, memref) outs(%subview_410 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_411 = memref.subview %alloca_401[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %272 = polygeist.submap(%alloca_399, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_411 : memref>) outs(%272 : memref) { + ^bb0(%in: f64, %out: f64): + %384 = arith.addf %out, %in : f64 + linalg.yield %384 : f64 + } + %273 = polygeist.submap(%alloca_399, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + %274 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%273 : memref) outs(%274 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_412 = memref.alloca() : memref<128xf64> + %alloca_413 = memref.alloca() : memref<250xf64> + %275 = polygeist.submap(%alloca_295, %c2, %c125) {map = #map53} : (memref<750xf64>, index, index) -> memref + %276 = polygeist.submap(%alloca_413, %c2, %c125) {map = #map50} : (memref<250xf64>, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%275 : memref) outs(%276 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %277 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map20} : (memref, index, index, index, index) -> memref + %278 = polygeist.submap(%alloca_412, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%277 : memref) outs(%278 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_414 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_415 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_416 = memref.alloca() : memref<2x5x5x4xf64> + %subview_417 = memref.subview %alloca_416[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_417 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %279 = polygeist.submap(%alloca_413, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (memref<250xf64>, index, index, index, index, index) -> memref + %280 = polygeist.submap(%alloca_298, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%279, %280 : memref, memref) outs(%alloca_416 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_418 = memref.subview %alloca_415[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_418 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_419 = memref.subview %alloca_416[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %281 = polygeist.submap(%alloca_298, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_420 = memref.subview %alloca_415[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_419, %281 : memref>, memref) outs(%subview_420 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_421 = memref.subview %alloca_414[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_421 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_422 = memref.subview %alloca_415[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %282 = polygeist.submap(%alloca_298, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_423 = memref.subview %alloca_414[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_422, %282 : memref>, memref) outs(%subview_423 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_424 = memref.subview %alloca_414[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %283 = polygeist.submap(%alloca_412, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_424 : memref>) outs(%283 : memref) { + ^bb0(%in: f64, %out: f64): + %384 = arith.addf %out, %in : f64 + linalg.yield %384 : f64 + } + %284 = polygeist.submap(%alloca_412, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + %285 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map20} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%284 : memref) outs(%285 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_425 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_426 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_427 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_428 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_429 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_430 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_431 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_432 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_433 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_434 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_435 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_436 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_437 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_438 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_439 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_440 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_441 = memref.alloca() : memref<2x4x4x5xf64> + %subview_442 = memref.subview %alloca_441[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_442 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %286 = polygeist.submap(%arg10, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %287 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%286, %287 : memref, memref) outs(%alloca_441 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_443 = memref.subview %alloca_440[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_443 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %288 = polygeist.submap(%arg10, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %289 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%288, %289 : memref, memref) outs(%alloca_440 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_444 = memref.subview %alloca_439[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_444 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_445 = memref.subview %alloca_440[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %290 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_446 = memref.subview %alloca_439[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_445, %290 : memref>, memref) outs(%subview_446 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_447 = memref.subview %alloca_438[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_447 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_448 = memref.subview %alloca_441[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %291 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_449 = memref.subview %alloca_438[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_448, %291 : memref>, memref) outs(%subview_449 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_450 = memref.subview %alloca_437[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_450 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_451 = memref.subview %alloca_441[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %292 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_452 = memref.subview %alloca_437[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_451, %292 : memref>, memref) outs(%subview_452 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_453 = memref.subview %alloca_436[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_453 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_454 = memref.subview %alloca_439[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %293 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_455 = memref.subview %alloca_436[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_454, %293 : memref>, memref) outs(%subview_455 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_456 = memref.subview %alloca_435[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_456 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_457 = memref.subview %alloca_438[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %294 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_458 = memref.subview %alloca_435[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_457, %294 : memref>, memref) outs(%subview_458 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_459 = memref.subview %alloca_434[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_459 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_460 = memref.subview %alloca_437[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %295 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %subview_461 = memref.subview %alloca_434[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_460, %295 : memref>, memref) outs(%subview_461 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_462 = memref.subview %alloca_433[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_462 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %296 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map24} : (memref, index, index, index, index, index) -> memref + %subview_463 = memref.subview %alloca_436[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %297 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (memref, index, index, index, index, index) -> memref + %subview_464 = memref.subview %alloca_435[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %298 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (memref, index, index, index, index, index) -> memref + %subview_465 = memref.subview %alloca_434[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %299 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_466 = memref.subview %alloca_433[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%296, %subview_463, %297, %subview_464, %298, %subview_465, %299 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_466 : memref>) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %in_564: f64, %in_565: f64, %in_566: f64, %in_567: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.mulf %in_563, %in_564 : f64 + %386 = arith.addf %384, %385 : f64 + %387 = arith.mulf %in_565, %in_566 : f64 + %388 = arith.addf %386, %387 : f64 + %389 = arith.mulf %388, %in_567 : f64 + %390 = arith.addf %out, %389 : f64 + linalg.yield %390 : f64 + } + %subview_467 = memref.subview %alloca_432[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_467 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %300 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map25} : (memref, index, index, index, index, index) -> memref + %subview_468 = memref.subview %alloca_436[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %301 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map27} : (memref, index, index, index, index, index) -> memref + %subview_469 = memref.subview %alloca_435[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %302 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (memref, index, index, index, index, index) -> memref + %subview_470 = memref.subview %alloca_434[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %303 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_471 = memref.subview %alloca_432[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%300, %subview_468, %301, %subview_469, %302, %subview_470, %303 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_471 : memref>) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %in_564: f64, %in_565: f64, %in_566: f64, %in_567: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.mulf %in_563, %in_564 : f64 + %386 = arith.addf %384, %385 : f64 + %387 = arith.mulf %in_565, %in_566 : f64 + %388 = arith.addf %386, %387 : f64 + %389 = arith.mulf %388, %in_567 : f64 + %390 = arith.addf %out, %389 : f64 + linalg.yield %390 : f64 + } + %subview_472 = memref.subview %alloca_431[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_472 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %304 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map26} : (memref, index, index, index, index, index) -> memref + %subview_473 = memref.subview %alloca_436[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %305 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map28} : (memref, index, index, index, index, index) -> memref + %subview_474 = memref.subview %alloca_435[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %306 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map29} : (memref, index, index, index, index, index) -> memref + %subview_475 = memref.subview %alloca_434[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %307 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %subview_476 = memref.subview %alloca_431[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map8, #map16, #map8, #map16, #map8, #map16, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%304, %subview_473, %305, %subview_474, %306, %subview_475, %307 : memref, memref>, memref, memref>, memref, memref>, memref) outs(%subview_476 : memref>) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %in_564: f64, %in_565: f64, %in_566: f64, %in_567: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.mulf %in_563, %in_564 : f64 + %386 = arith.addf %384, %385 : f64 + %387 = arith.mulf %in_565, %in_566 : f64 + %388 = arith.addf %386, %387 : f64 + %389 = arith.mulf %388, %in_567 : f64 + %390 = arith.addf %out, %389 : f64 + linalg.yield %390 : f64 + } + %subview_477 = memref.subview %alloca_430[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_477 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_478 = memref.subview %alloca_433[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %308 = polygeist.submap(%arg2, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_479 = memref.subview %alloca_430[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_478, %308 : memref>, memref) outs(%subview_479 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_480 = memref.subview %alloca_429[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_480 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_481 = memref.subview %alloca_432[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %309 = polygeist.submap(%arg3, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_482 = memref.subview %alloca_429[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_481, %309 : memref>, memref) outs(%subview_482 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_483 = memref.subview %alloca_428[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_483 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_484 = memref.subview %alloca_431[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %310 = polygeist.submap(%arg2, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + %subview_485 = memref.subview %alloca_428[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_484, %310 : memref>, memref) outs(%subview_485 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_486 = memref.subview %alloca_427[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_486 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_487 = memref.subview %alloca_430[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %311 = polygeist.submap(%arg2, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %subview_488 = memref.subview %alloca_427[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_487, %311 : memref>, memref) outs(%subview_488 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_489 = memref.subview %alloca_426[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_489 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_490 = memref.subview %alloca_429[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %312 = polygeist.submap(%arg2, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %subview_491 = memref.subview %alloca_426[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_490, %312 : memref>, memref) outs(%subview_491 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_492 = memref.subview %alloca_425[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_492 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_493 = memref.subview %alloca_428[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %313 = polygeist.submap(%arg3, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %subview_494 = memref.subview %alloca_425[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_493, %313 : memref>, memref) outs(%subview_494 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_495 = memref.subview %alloca_427[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_496 = memref.subview %alloca_426[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %subview_497 = memref.subview %alloca_425[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %314 = polygeist.submap(%arg12, %c2, %c4, %c4, %c4) {map = #map4} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_495, %subview_496, %subview_497 : memref>, memref>, memref>) outs(%314 : memref) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %out: f64): + %384 = arith.addf %in, %in_562 : f64 + %385 = arith.addf %384, %in_563 : f64 + %386 = arith.addf %out, %385 : f64 + linalg.yield %386 : f64 + } + %alloca_498 = memref.alloca() : memref<750xf64> + %alloca_499 = memref.alloca() : memref<750xf64> + %alloca_500 = memref.alloca() : memref<20xf64> + %315 = polygeist.submap(%arg0, %c4, %c5) {map = #map} : (memref, index, index) -> memref + %316 = polygeist.submap(%alloca_500, %c4, %c5) {map = #map1} : (memref<20xf64>, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%315 : memref) outs(%316 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_501 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_502 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_503 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_504 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_505 = memref.alloca() : memref<2x4x4x5xf64> + %subview_506 = memref.subview %alloca_505[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_506 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %317 = polygeist.submap(%arg10, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %318 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%317, %318 : memref, memref) outs(%alloca_505 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_507 = memref.subview %alloca_504[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_507 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %319 = polygeist.submap(%arg10, %c2, %c4, %c4, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + %320 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5, %c4) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%319, %320 : memref, memref) outs(%alloca_504 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_508 = memref.subview %alloca_503[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_508 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_509 = memref.subview %alloca_504[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %321 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_510 = memref.subview %alloca_503[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_509, %321 : memref>, memref) outs(%subview_510 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_511 = memref.subview %alloca_502[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_511 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_512 = memref.subview %alloca_505[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %322 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_513 = memref.subview %alloca_502[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_512, %322 : memref>, memref) outs(%subview_513 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_514 = memref.subview %alloca_501[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_514 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_515 = memref.subview %alloca_505[0, 0, 0, 0] [%c2, %c4, %c4, %c5] [1, 1, 1, 1] : memref<2x4x4x5xf64> to memref> + %323 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + %subview_516 = memref.subview %alloca_501[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_515, %323 : memref>, memref) outs(%subview_516 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %324 = polygeist.submap(%alloca_499, %c2, %c5, %c5, %c5) {map = #map33} : (memref<750xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%324 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_517 = memref.subview %alloca_503[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %325 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %326 = polygeist.submap(%alloca_499, %c2, %c5, %c5, %c5) {map = #map33} : (memref<750xf64>, index, index, index, index) -> memref<2x5x5x5xf64> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_517, %325 : memref>, memref) outs(%326 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %327 = polygeist.submap(%alloca_499, %c2, %c5, %c5, %c5) {map = #map34} : (memref<750xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%327 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_518 = memref.subview %alloca_502[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %328 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %329 = polygeist.submap(%alloca_499, %c2, %c5, %c5, %c5) {map = #map34} : (memref<750xf64>, index, index, index, index) -> memref<2x5x5x5xf64> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_518, %328 : memref>, memref) outs(%329 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %330 = polygeist.submap(%alloca_499, %c2, %c5, %c5, %c5) {map = #map35} : (memref<750xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%330 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_519 = memref.subview %alloca_501[0, 0, 0, 0] [%c2, %c4, %c5, %c5] [1, 1, 1, 1] : memref<2x4x5x5xf64> to memref> + %331 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %332 = polygeist.submap(%alloca_499, %c2, %c5, %c5, %c5) {map = #map35} : (memref<750xf64>, index, index, index, index) -> memref<2x5x5x5xf64> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_519, %331 : memref>, memref) outs(%332 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %333 = polygeist.submap(%alloca_498, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (memref<750xf64>, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]} outs(%333 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %334 = polygeist.submap(%alloca_499, %c2, %c3, %c5, %c5, %c5, %c3) {map = #map54} : (memref<750xf64>, index, index, index, index, index, index) -> memref + %335 = polygeist.submap(%arg8, %c2, %c3, %c5, %c5, %c5, %c3) {map = #map55} : (memref, index, index, index, index, index, index) -> memref + %336 = polygeist.submap(%alloca_498, %c2, %c3, %c5, %c5, %c5) {map = #map43} : (memref<750xf64>, index, index, index, index, index) -> memref<2x3x5x5x5xf64> + linalg.generic {indexing_maps = [#map56, #map56, #map57], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%334, %335 : memref, memref) outs(%336 : memref<2x3x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %alloca_520 = memref.alloca() : memref<128xf64> + %alloca_521 = memref.alloca() : memref<250xf64> + %337 = polygeist.submap(%alloca_498, %c2, %c125) {map = #map49} : (memref<750xf64>, index, index) -> memref + %338 = polygeist.submap(%alloca_521, %c2, %c125) {map = #map50} : (memref<250xf64>, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%337 : memref) outs(%338 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %339 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map3} : (memref, index, index, index, index) -> memref + %340 = polygeist.submap(%alloca_520, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%339 : memref) outs(%340 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_522 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_523 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_524 = memref.alloca() : memref<2x5x5x4xf64> + %subview_525 = memref.subview %alloca_524[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_525 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %341 = polygeist.submap(%alloca_521, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (memref<250xf64>, index, index, index, index, index) -> memref + %342 = polygeist.submap(%alloca_500, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%341, %342 : memref, memref) outs(%alloca_524 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_526 = memref.subview %alloca_523[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_526 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_527 = memref.subview %alloca_524[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %343 = polygeist.submap(%alloca_500, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_528 = memref.subview %alloca_523[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_527, %343 : memref>, memref) outs(%subview_528 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_529 = memref.subview %alloca_522[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_529 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_530 = memref.subview %alloca_523[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %344 = polygeist.submap(%alloca_500, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_531 = memref.subview %alloca_522[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_530, %344 : memref>, memref) outs(%subview_531 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_532 = memref.subview %alloca_522[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %345 = polygeist.submap(%alloca_520, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_532 : memref>) outs(%345 : memref) { + ^bb0(%in: f64, %out: f64): + %384 = arith.addf %out, %in : f64 + linalg.yield %384 : f64 + } + %346 = polygeist.submap(%alloca_520, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + %347 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map3} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%346 : memref) outs(%347 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_533 = memref.alloca() : memref<128xf64> + %alloca_534 = memref.alloca() : memref<250xf64> + %348 = polygeist.submap(%alloca_498, %c2, %c125) {map = #map52} : (memref<750xf64>, index, index) -> memref + %349 = polygeist.submap(%alloca_534, %c2, %c125) {map = #map50} : (memref<250xf64>, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%348 : memref) outs(%349 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %350 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + %351 = polygeist.submap(%alloca_533, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%350 : memref) outs(%351 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_535 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_536 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_537 = memref.alloca() : memref<2x5x5x4xf64> + %subview_538 = memref.subview %alloca_537[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_538 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %352 = polygeist.submap(%alloca_534, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (memref<250xf64>, index, index, index, index, index) -> memref + %353 = polygeist.submap(%alloca_500, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%352, %353 : memref, memref) outs(%alloca_537 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_539 = memref.subview %alloca_536[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_539 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_540 = memref.subview %alloca_537[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %354 = polygeist.submap(%alloca_500, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_541 = memref.subview %alloca_536[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_540, %354 : memref>, memref) outs(%subview_541 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_542 = memref.subview %alloca_535[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_542 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_543 = memref.subview %alloca_536[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %355 = polygeist.submap(%alloca_500, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_544 = memref.subview %alloca_535[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_543, %355 : memref>, memref) outs(%subview_544 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_545 = memref.subview %alloca_535[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %356 = polygeist.submap(%alloca_533, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_545 : memref>) outs(%356 : memref) { + ^bb0(%in: f64, %out: f64): + %384 = arith.addf %out, %in : f64 + linalg.yield %384 : f64 + } + %357 = polygeist.submap(%alloca_533, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + %358 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%357 : memref) outs(%358 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_546 = memref.alloca() : memref<128xf64> + %alloca_547 = memref.alloca() : memref<250xf64> + %359 = polygeist.submap(%alloca_498, %c2, %c125) {map = #map53} : (memref<750xf64>, index, index) -> memref + %360 = polygeist.submap(%alloca_547, %c2, %c125) {map = #map50} : (memref<250xf64>, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel", "parallel"]} ins(%359 : memref) outs(%360 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %361 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map20} : (memref, index, index, index, index) -> memref + %362 = polygeist.submap(%alloca_546, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%361 : memref) outs(%362 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_548 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_549 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_550 = memref.alloca() : memref<2x5x5x4xf64> + %subview_551 = memref.subview %alloca_550[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_551 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %363 = polygeist.submap(%alloca_547, %c2, %c5, %c5, %c4, %c5) {map = #map51} : (memref<250xf64>, index, index, index, index, index) -> memref + %364 = polygeist.submap(%alloca_500, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref<20xf64>, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%363, %364 : memref, memref) outs(%alloca_550 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_552 = memref.subview %alloca_549[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_552 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_553 = memref.subview %alloca_550[0, 0, 0, 0] [%c2, %c5, %c5, %c4] [1, 1, 1, 1] : memref<2x5x5x4xf64> to memref> + %365 = polygeist.submap(%alloca_500, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_554 = memref.subview %alloca_549[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map11, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_553, %365 : memref>, memref) outs(%subview_554 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_555 = memref.subview %alloca_548[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_555 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_556 = memref.subview %alloca_549[0, 0, 0, 0] [%c2, %c5, %c4, %c4] [1, 1, 1, 1] : memref<2x5x4x4xf64> to memref> + %366 = polygeist.submap(%alloca_500, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref<20xf64>, index, index, index, index, index) -> memref + %subview_557 = memref.subview %alloca_548[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + linalg.generic {indexing_maps = [#map13, #map8, #map9], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%subview_556, %366 : memref>, memref) outs(%subview_557 : memref>) { + ^bb0(%in: f64, %in_562: f64, %out: f64): + %384 = arith.mulf %in, %in_562 : f64 + %385 = arith.addf %out, %384 : f64 + linalg.yield %385 : f64 + } + %subview_558 = memref.subview %alloca_548[0, 0, 0, 0] [%c2, %c4, %c4, %c4] [1, 1, 1, 1] : memref<2x4x4x4xf64> to memref> + %367 = polygeist.submap(%alloca_546, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%subview_558 : memref>) outs(%367 : memref) { + ^bb0(%in: f64, %out: f64): + %384 = arith.addf %out, %in : f64 + linalg.yield %384 : f64 + } + %368 = polygeist.submap(%alloca_546, %c2, %c4, %c4, %c4) {map = #map4} : (memref<128xf64>, index, index, index, index) -> memref + %369 = polygeist.submap(%arg11, %c2, %c4, %c4, %c4) {map = #map20} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%368 : memref) outs(%369 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %alloca_559 = memref.alloca() : memref<2x5x5x5xf64> + %subview_560 = memref.subview %alloca_559[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%subview_560 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %370 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map58} : (memref, index, index, index, index, index, index, index, index) -> memref + %371 = polygeist.submap(%arg8, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map59} : (memref, index, index, index, index, index, index, index, index) -> memref + %372 = polygeist.submap(%arg8, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map60} : (memref, index, index, index, index, index, index, index, index) -> memref + %373 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map58} : (memref, index, index, index, index, index, index, index, index) -> memref + %374 = polygeist.submap(%arg8, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map61} : (memref, index, index, index, index, index, index, index, index) -> memref + %375 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map62} : (memref, index, index, index, index, index, index, index, index) -> memref + %376 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map62} : (memref, index, index, index, index, index, index, index, index) -> memref + %377 = polygeist.submap(%arg9, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map63} : (memref, index, index, index, index, index, index, index, index) -> memref + %378 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map64} : (memref, index, index, index, index, index, index, index, index) -> memref + %379 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3, %c4, %c4, %c4) {map = #map64} : (memref, index, index, index, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map65, #map65, #map65, #map65, #map65, #map65, #map65, #map65, #map65, #map65, #map66], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction", "reduction"]} ins(%370, %371, %372, %373, %374, %375, %376, %377, %378, %379 : memref, memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%alloca_559 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %in_564: f64, %in_565: f64, %in_566: f64, %in_567: f64, %in_568: f64, %in_569: f64, %in_570: f64, %out: f64): + %384 = arith.mulf %in_568, %in_569 : f64 + %385 = arith.mulf %384, %in_566 : f64 + %386 = arith.mulf %385, %in : f64 + %387 = arith.mulf %386, %in_562 : f64 + %388 = arith.addf %out, %387 : f64 + %389 = arith.mulf %in_568, %in_570 : f64 + %390 = arith.mulf %389, %in_567 : f64 + %391 = arith.mulf %390, %in : f64 + %392 = arith.mulf %391, %in_563 : f64 + %393 = arith.addf %388, %392 : f64 + %394 = arith.mulf %389, %in_566 : f64 + %395 = arith.mulf %394, %in_564 : f64 + %396 = arith.mulf %395, %in_565 : f64 + %397 = arith.addf %393, %396 : f64 + linalg.yield %397 : f64 + } + %380 = polygeist.submap(%arg0, %c2, %c4, %c4, %c4, %c5, %c5, %c5) {map = #map67} : (memref, index, index, index, index, index, index, index) -> memref + %381 = polygeist.submap(%arg0, %c2, %c4, %c4, %c4, %c5, %c5, %c5) {map = #map68} : (memref, index, index, index, index, index, index, index) -> memref + %subview_561 = memref.subview %alloca_559[0, 0, 0, 0] [%c2, %c5, %c5, %c5] [1, 1, 1, 1] : memref<2x5x5x5xf64> to memref> + %382 = polygeist.submap(%arg0, %c2, %c4, %c4, %c4, %c5, %c5, %c5) {map = #map69} : (memref, index, index, index, index, index, index, index) -> memref + %383 = polygeist.submap(%arg12, %c2, %c4, %c4, %c4) {map = #map4} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map47, #map47, #map70, #map47, #map71], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]} ins(%380, %381, %subview_561, %382 : memref, memref, memref>, memref) outs(%383 : memref) { + ^bb0(%in: f64, %in_562: f64, %in_563: f64, %in_564: f64, %out: f64): + %384 = arith.mulf %in_563, %in_564 : f64 + %385 = arith.mulf %384, %in_562 : f64 + %386 = arith.mulf %385, %in : f64 + %387 = arith.addf %out, %386 : f64 + linalg.yield %387 : f64 + } + return + } +} + diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pressure_diffusion_3d.debufferized.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pressure_diffusion_3d.debufferized.mlir new file mode 100644 index 000000000000..4ca8070d09e0 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pressure_diffusion_3d.debufferized.mlir @@ -0,0 +1,277 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 750)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 125)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 250)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 375)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 500)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 625)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_navier_tgv_pressure_diffusion_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x4x4x4xf64> + %8 = tensor.empty() : tensor<2x4x4x4xf64> + %9 = tensor.empty() : tensor<2x4x4x4xf64> + %10 = tensor.empty() : tensor<2x5x4x4xf64> + %11 = tensor.empty() : tensor<2x5x4x4xf64> + %12 = tensor.empty() : tensor<2x5x4x4xf64> + %13 = tensor.empty() : tensor<2x5x5x4xf64> + %14 = tensor.empty() : tensor<2x5x5x4xf64> + %15 = tensor.empty() : tensor<2x5x5x4xf64> + %16 = tensor.empty() : tensor<2x5x5x5xf64> + %17 = tensor.empty() : tensor<2x5x5x5xf64> + %18 = tensor.empty() : tensor<2x5x5x5xf64> + %19 = tensor.empty() : tensor<2x4x5x5xf64> + %20 = tensor.empty() : tensor<2x4x5x5xf64> + %21 = tensor.empty() : tensor<2x4x5x5xf64> + %22 = tensor.empty() : tensor<2x4x4x5xf64> + %23 = tensor.empty() : tensor<2x4x4x5xf64> + %24 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%23 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %25 = polygeist.submap(%6, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %26 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %27 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%26, %25 : tensor, tensor) outs(%24 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x4x5xf64> + %28 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%22 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %29 = polygeist.submap(%5, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %30 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %31 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%30, %29 : tensor, tensor) outs(%28 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x4x5xf64> + %32 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%21 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %33 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %34 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%31, %33 : tensor<2x4x4x5xf64>, tensor) outs(%32 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x5x5xf64> + %35 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%20 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %36 = polygeist.submap(%5, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %37 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%27, %36 : tensor<2x4x4x5xf64>, tensor) outs(%35 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x5x5xf64> + %38 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%19 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %39 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %40 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%27, %39 : tensor<2x4x4x5xf64>, tensor) outs(%38 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x5x5xf64> + %41 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%18 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %42 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %43 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%34, %42 : tensor<2x4x5x5xf64>, tensor) outs(%41 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x5x5x5xf64> + %44 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%17 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %45 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %46 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%37, %45 : tensor<2x4x5x5xf64>, tensor) outs(%44 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x5x5x5xf64> + %47 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%16 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %48 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %49 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%40, %48 : tensor<2x4x5x5xf64>, tensor) outs(%47 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x5x5x5xf64> + %50 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%15 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %51 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %52 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %53 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %54 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%52, %43, %53, %46, %54, %49, %51 : tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor) outs(%50 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.mulf %in_1, %in_2 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_3, %in_4 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_5 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor<2x5x5x4xf64> + %56 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%14 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %57 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %58 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %59 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %60 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %61 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%58, %43, %59, %46, %60, %49, %57 : tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor) outs(%56 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.mulf %in_1, %in_2 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_3, %in_4 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_5 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor<2x5x5x4xf64> + %62 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%13 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %63 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %64 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %65 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %66 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %67 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%64, %43, %65, %46, %66, %49, %63 : tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor) outs(%62 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.mulf %in_1, %in_2 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_3, %in_4 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_5 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor<2x5x5x4xf64> + %68 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %69 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %70 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%55, %69 : tensor<2x5x5x4xf64>, tensor) outs(%68 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x5x4x4xf64> + %71 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %72 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %73 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%61, %72 : tensor<2x5x5x4xf64>, tensor) outs(%71 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x5x4x4xf64> + %74 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %75 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %76 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%67, %75 : tensor<2x5x5x4xf64>, tensor) outs(%74 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x5x4x4xf64> + %77 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %78 = polygeist.submap(%4, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %79 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%70, %78 : tensor<2x5x4x4xf64>, tensor) outs(%77 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x4x4xf64> + %80 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %81 = polygeist.submap(%4, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %82 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%73, %81 : tensor<2x5x4x4xf64>, tensor) outs(%80 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x4x4xf64> + %83 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%7 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %84 = polygeist.submap(%3, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %85 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%76, %84 : tensor<2x5x4x4xf64>, tensor) outs(%83 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x4x4xf64> + %86 = polygeist.submap(%0, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %87 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%79, %82, %85 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%86 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %90 = arith.addf %in, %in_0 : f64 + %91 = arith.addf %90, %in_1 : f64 + %92 = arith.addf %out, %91 : f64 + linalg.yield %92 : f64 + } -> tensor + %88 = polygeist.submapInverse(%0, %87, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %89 = bufferization.to_memref %88 : memref + memref.copy %89, %arg6 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pressure_diffusion_3d.frontend.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pressure_diffusion_3d.frontend.mlir new file mode 100644 index 000000000000..e81f2526c52b --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pressure_diffusion_3d.frontend.mlir @@ -0,0 +1,680 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_navier_tgv_pressure_diffusion_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_14 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_15 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg7 * 64 + %arg11 + %arg8 * 16 + %arg9 * 4] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_15[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg7 * 64 + %arg11 + %arg8 * 16 + %arg9 * 4] : memref + %2 = affine.load %arg1[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_14[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg9 * 5 + %arg7 * 750] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 125] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 250] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg3[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_7[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 125] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 375] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 500] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 250] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 500] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 625] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.load %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg6[%arg7 * 64 + %arg10 + %arg8 * 16 + %arg9 * 4] : memref + %6 = arith.addf %5, %4 : f64 + affine.store %6, %arg6[%arg7 * 64 + %arg10 + %arg8 * 16 + %arg9 * 4] : memref + } + } + } + } + return + } + func.func @mfem_pa_diffusion_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_14 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_15 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg7 * 64 + %arg11 + %arg8 * 16 + %arg9 * 4] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_15[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg7 * 64 + %arg11 + %arg8 * 16 + %arg9 * 4] : memref + %2 = affine.load %arg1[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_14[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg9 * 5 + %arg7 * 750] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 125] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 250] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg3[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_7[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 125] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 375] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 500] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 250] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 500] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 625] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.load %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg6[%arg7 * 64 + %arg10 + %arg8 * 16 + %arg9 * 4] : memref + %6 = arith.addf %5, %4 : f64 + affine.store %6, %arg6[%arg7 * 64 + %arg10 + %arg8 * 16 + %arg9 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pressure_diffusion_3d.matched.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pressure_diffusion_3d.matched.mlir new file mode 100644 index 000000000000..1172dac99181 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pressure_diffusion_3d.matched.mlir @@ -0,0 +1,231 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 750)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 125)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 250)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 375)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 500)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 625)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_navier_tgv_pressure_diffusion_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x4x4x4xf64> + %8 = tensor.empty() : tensor<2x4x4x4xf64> + %9 = tensor.empty() : tensor<2x4x4x4xf64> + %10 = tensor.empty() : tensor<2x5x4x4xf64> + %11 = tensor.empty() : tensor<2x5x4x4xf64> + %12 = tensor.empty() : tensor<2x5x4x4xf64> + %13 = tensor.empty() : tensor<2x5x5x4xf64> + %14 = tensor.empty() : tensor<2x5x5x4xf64> + %15 = tensor.empty() : tensor<2x5x5x4xf64> + %16 = tensor.empty() : tensor<2x5x5x5xf64> + %17 = tensor.empty() : tensor<2x5x5x5xf64> + %18 = tensor.empty() : tensor<2x5x5x5xf64> + %19 = tensor.empty() : tensor<2x4x5x5xf64> + %20 = tensor.empty() : tensor<2x4x5x5xf64> + %21 = tensor.empty() : tensor<2x4x5x5xf64> + %22 = tensor.empty() : tensor<2x4x4x5xf64> + %23 = tensor.empty() : tensor<2x4x4x5xf64> + %25 = polygeist.submap(%6, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %26 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v23_contract_27_tc2 = tensor.cast %23 : tensor<2x4x4x5xf64> to tensor + + %v27_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%26, %25, %v23_contract_27_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %27 = tensor.cast %v27_tdyn : tensor to tensor<2x4x4x5xf64> + %29 = polygeist.submap(%5, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %30 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v22_contract_31_tc2 = tensor.cast %22 : tensor<2x4x4x5xf64> to tensor + + %v31_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%30, %29, %v22_contract_31_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %31 = tensor.cast %v31_tdyn : tensor to tensor<2x4x4x5xf64> + %33 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v31_contract_34_tc0 = tensor.cast %31 : tensor<2x4x4x5xf64> to tensor + + %v21_contract_34_tc2 = tensor.cast %21 : tensor<2x4x5x5xf64> to tensor + + %v34_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v31_contract_34_tc0, %33, %v21_contract_34_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %34 = tensor.cast %v34_tdyn : tensor to tensor<2x4x5x5xf64> + %36 = polygeist.submap(%5, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v27_contract_37_tc0 = tensor.cast %27 : tensor<2x4x4x5xf64> to tensor + + %v20_contract_37_tc2 = tensor.cast %20 : tensor<2x4x5x5xf64> to tensor + + %v37_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v27_contract_37_tc0, %36, %v20_contract_37_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %37 = tensor.cast %v37_tdyn : tensor to tensor<2x4x5x5xf64> + %39 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v27_contract_40_tc0 = tensor.cast %27 : tensor<2x4x4x5xf64> to tensor + + %v19_contract_40_tc2 = tensor.cast %19 : tensor<2x4x5x5xf64> to tensor + + %v40_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v27_contract_40_tc0, %39, %v19_contract_40_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %40 = tensor.cast %v40_tdyn : tensor to tensor<2x4x5x5xf64> + %42 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v34_contract_43_tc0 = tensor.cast %34 : tensor<2x4x5x5xf64> to tensor + + %v18_contract_43_tc2 = tensor.cast %18 : tensor<2x5x5x5xf64> to tensor + + %v43_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v34_contract_43_tc0, %42, %v18_contract_43_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %43 = tensor.cast %v43_tdyn : tensor to tensor<2x5x5x5xf64> + %45 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v37_contract_46_tc0 = tensor.cast %37 : tensor<2x4x5x5xf64> to tensor + + %v17_contract_46_tc2 = tensor.cast %17 : tensor<2x5x5x5xf64> to tensor + + %v46_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v37_contract_46_tc0, %45, %v17_contract_46_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %46 = tensor.cast %v46_tdyn : tensor to tensor<2x5x5x5xf64> + %48 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v40_contract_49_tc0 = tensor.cast %40 : tensor<2x4x5x5xf64> to tensor + + %v16_contract_49_tc2 = tensor.cast %16 : tensor<2x5x5x5xf64> to tensor + + %v49_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v40_contract_49_tc0, %48, %v16_contract_49_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %49 = tensor.cast %v49_tdyn : tensor to tensor<2x5x5x5xf64> + %50 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%15 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %51 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %52 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %53 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %54 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%52, %43, %53, %46, %54, %49, %51 : tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor) outs(%50 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.mulf %in_1, %in_2 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_3, %in_4 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_5 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor<2x5x5x4xf64> + %56 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%14 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %57 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %58 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %59 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %60 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %61 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%58, %43, %59, %46, %60, %49, %57 : tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor) outs(%56 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.mulf %in_1, %in_2 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_3, %in_4 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_5 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor<2x5x5x4xf64> + %62 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%13 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %63 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %64 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %65 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %66 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %67 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%64, %43, %65, %46, %66, %49, %63 : tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor) outs(%62 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.mulf %in_1, %in_2 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_3, %in_4 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_5 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor<2x5x5x4xf64> + %69 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %v55_contract_70_tc0 = tensor.cast %55 : tensor<2x5x5x4xf64> to tensor + + %v12_contract_70_tc2 = tensor.cast %12 : tensor<2x5x4x4xf64> to tensor + + %v70_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v55_contract_70_tc0, %69, %v12_contract_70_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %70 = tensor.cast %v70_tdyn : tensor to tensor<2x5x4x4xf64> + %72 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %v61_contract_73_tc0 = tensor.cast %61 : tensor<2x5x5x4xf64> to tensor + + %v11_contract_73_tc2 = tensor.cast %11 : tensor<2x5x4x4xf64> to tensor + + %v73_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v61_contract_73_tc0, %72, %v11_contract_73_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %73 = tensor.cast %v73_tdyn : tensor to tensor<2x5x4x4xf64> + %75 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %v67_contract_76_tc0 = tensor.cast %67 : tensor<2x5x5x4xf64> to tensor + + %v10_contract_76_tc2 = tensor.cast %10 : tensor<2x5x4x4xf64> to tensor + + %v76_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v67_contract_76_tc0, %75, %v10_contract_76_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %76 = tensor.cast %v76_tdyn : tensor to tensor<2x5x4x4xf64> + %78 = polygeist.submap(%4, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %v70_contract_79_tc0 = tensor.cast %70 : tensor<2x5x4x4xf64> to tensor + + %v9_contract_79_tc2 = tensor.cast %9 : tensor<2x4x4x4xf64> to tensor + + %v79_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v70_contract_79_tc0, %78, %v9_contract_79_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %79 = tensor.cast %v79_tdyn : tensor to tensor<2x4x4x4xf64> + %81 = polygeist.submap(%4, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %v73_contract_82_tc0 = tensor.cast %73 : tensor<2x5x4x4xf64> to tensor + + %v8_contract_82_tc2 = tensor.cast %8 : tensor<2x4x4x4xf64> to tensor + + %v82_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v73_contract_82_tc0, %81, %v8_contract_82_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %82 = tensor.cast %v82_tdyn : tensor to tensor<2x4x4x4xf64> + %84 = polygeist.submap(%3, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %v76_contract_85_tc0 = tensor.cast %76 : tensor<2x5x4x4xf64> to tensor + + %v7_contract_85_tc2 = tensor.cast %7 : tensor<2x4x4x4xf64> to tensor + + %v85_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v76_contract_85_tc0, %84, %v7_contract_85_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %85 = tensor.cast %v85_tdyn : tensor to tensor<2x4x4x4xf64> + %86 = polygeist.submap(%0, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %87 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%79, %82, %85 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%86 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %90 = arith.addf %in, %in_0 : f64 + %91 = arith.addf %90, %in_1 : f64 + %92 = arith.addf %out, %91 : f64 + linalg.yield %92 : f64 + } -> tensor + %88 = polygeist.submapInverse(%0, %87, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %89 = bufferization.to_memref %88 : memref + memref.copy %89, %arg6 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pressure_diffusion_3d.raised.mlir b/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pressure_diffusion_3d.raised.mlir new file mode 100644 index 000000000000..ddcc36bdd300 --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/mfem_app_navier_tgv_pressure_diffusion_3d.raised.mlir @@ -0,0 +1,267 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 750)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 125)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 250)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 375)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 500)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 625)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_app_navier_tgv_pressure_diffusion_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_14 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_15 = memref.alloca() : memref<2x4x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_15 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg5, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_15 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_14 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg5, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%2, %3 : memref, memref) outs(%alloca_14 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_13 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_14, %4 : memref<2x4x4x5xf64>, memref) outs(%alloca_13 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_12 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %5 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_15, %5 : memref<2x4x4x5xf64>, memref) outs(%alloca_12 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_11 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_15, %6 : memref<2x4x4x5xf64>, memref) outs(%alloca_11 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_10 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %7 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_13, %7 : memref<2x4x5x5xf64>, memref) outs(%alloca_10 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_9 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_12, %8 : memref<2x4x5x5xf64>, memref) outs(%alloca_9 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_8 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %9 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_11, %9 : memref<2x4x5x5xf64>, memref) outs(%alloca_8 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_7 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %10 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (memref, index, index, index, index, index) -> memref + %11 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (memref, index, index, index, index, index) -> memref + %12 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (memref, index, index, index, index, index) -> memref + %13 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%10, %alloca_10, %11, %alloca_9, %12, %alloca_8, %13 : memref, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref) outs(%alloca_7 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %in_17: f64, %in_18: f64, %in_19: f64, %in_20: f64, %in_21: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.mulf %in_17, %in_18 : f64 + %31 = arith.addf %29, %30 : f64 + %32 = arith.mulf %in_19, %in_20 : f64 + %33 = arith.addf %31, %32 : f64 + %34 = arith.mulf %33, %in_21 : f64 + %35 = arith.addf %out, %34 : f64 + linalg.yield %35 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_6 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (memref, index, index, index, index, index) -> memref + %15 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %16 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %17 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%14, %alloca_10, %15, %alloca_9, %16, %alloca_8, %17 : memref, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref) outs(%alloca_6 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %in_17: f64, %in_18: f64, %in_19: f64, %in_20: f64, %in_21: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.mulf %in_17, %in_18 : f64 + %31 = arith.addf %29, %30 : f64 + %32 = arith.mulf %in_19, %in_20 : f64 + %33 = arith.addf %31, %32 : f64 + %34 = arith.mulf %33, %in_21 : f64 + %35 = arith.addf %out, %34 : f64 + linalg.yield %35 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_5 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %18 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (memref, index, index, index, index, index) -> memref + %19 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %20 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %21 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%18, %alloca_10, %19, %alloca_9, %20, %alloca_8, %21 : memref, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref) outs(%alloca_5 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %in_17: f64, %in_18: f64, %in_19: f64, %in_20: f64, %in_21: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.mulf %in_17, %in_18 : f64 + %31 = arith.addf %29, %30 : f64 + %32 = arith.mulf %in_19, %in_20 : f64 + %33 = arith.addf %31, %32 : f64 + %34 = arith.mulf %33, %in_21 : f64 + %35 = arith.addf %out, %34 : f64 + linalg.yield %35 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_4 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %22 = polygeist.submap(%arg2, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_7, %22 : memref<2x5x5x4xf64>, memref) outs(%alloca_4 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %23 = polygeist.submap(%arg3, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_6, %23 : memref<2x5x5x4xf64>, memref) outs(%alloca_3 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %24 = polygeist.submap(%arg2, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_5, %24 : memref<2x5x5x4xf64>, memref) outs(%alloca_2 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %25 = polygeist.submap(%arg2, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_4, %25 : memref<2x5x4x4xf64>, memref) outs(%alloca_1 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %26 = polygeist.submap(%arg2, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_3, %26 : memref<2x5x4x4xf64>, memref) outs(%alloca_0 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %27 = polygeist.submap(%arg3, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_2, %27 : memref<2x5x4x4xf64>, memref) outs(%alloca : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + %28 = polygeist.submap(%arg6, %c2, %c4, %c4, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%alloca_1, %alloca_0, %alloca : memref<2x4x4x4xf64>, memref<2x4x4x4xf64>, memref<2x4x4x4xf64>) outs(%28 : memref) { + ^bb0(%in: f64, %in_16: f64, %in_17: f64, %out: f64): + %29 = arith.addf %in, %in_16 : f64 + %30 = arith.addf %29, %in_17 : f64 + %31 = arith.addf %out, %30 : f64 + linalg.yield %31 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/application_extractions/results/summary.csv b/issues/mfem_c_kernels/application_extractions/results/summary.csv new file mode 100644 index 000000000000..5c42e3eb626b --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/results/summary.csv @@ -0,0 +1,12 @@ +application,source,support_source,function,coverage,operator_families,upstream_file,upstream_lines,missing_operator,frontend_ok,raise_ok,debufferize_ok,matcher_ok,linalg_ops,residual_loops,matched_groups,matcher_bodies,launches +mtop_iso_elasticity,mtop_iso_elasticity_dfem_2d.c,,mfem_app_mtop_iso_elasticity_dfem_2d,complete_hot_path,interpolation;elasticity_qpoint;integration,miniapps/mtop/mtop_solvers.cpp,376-410,,true,true,true,true,76,0,16,22,16 +dfem_minimal_surface,dfem_minimal_surface_2d.c,,mfem_app_dfem_minimal_surface_2d,complete_hot_path,interpolation;minimal_surface_qpoint;integration,miniapps/dfem/dfem-minimal-surface.cpp,308-356,,true,true,true,true,36,0,8,10,8 +ex35p,ex35p_pa_operators.c,,mfem_app_ex35p_h1_3d,complete_operator_branch,Diffusion;Mass,examples/ex35p.cpp,369-376,,true,true,true,true,94,0,19,28,19 +ex35p,ex35p_pa_operators.c,missing_stage_kernels.c,mfem_app_ex35p_hcurl_3d,complete_operator_branch,CurlCurl;VectorFEMass_Hcurl,examples/ex35p.cpp,379-382,,true,true,true,true,166,0,29,54,29 +ex35p,ex35p_pa_operators.c,missing_stage_kernels.c,mfem_app_ex35p_hdiv_3d,complete_operator_branch,DivDiv;VectorFEMass_Hdiv,examples/ex35p.cpp,385-388,,true,true,true,true,86,0,12,31,12 +ex9p,ex9p_mass_convection_2d.c,missing_stage_kernels.c,mfem_app_ex9p_mass_convection_2d,complete_element_and_solver_iteration,Mass;Convection;PCG_iteration,examples/ex9p.cpp,388-404;704-709,,true,true,true,true,46,0,10,15,10 +grad_div,grad_div_3d.c,missing_stage_kernels.c,mfem_app_grad_div_3d,complete_operator_branch,DivDiv;VectorFEMass_Hdiv,miniapps/hdiv-linear-solver/grad_div.cpp,203-206,,true,true,true,true,86,0,12,31,12 +abs_l1_jacobi,abs_l1_jacobi_operators.c,,mfem_app_abs_l1_mass_3d,complete_operator_branch,Mass,miniapps/diag-smoothers/abs-l1-jacobi.cpp,279-309,,true,true,true,true,24,0,5,7,5 +abs_l1_jacobi,abs_l1_jacobi_operators.c,,mfem_app_abs_l1_diffusion_3d,complete_operator_branch,Diffusion,miniapps/diag-smoothers/abs-l1-jacobi.cpp,279-309,,true,true,true,true,70,0,14,21,14 +abs_l1_jacobi,abs_l1_jacobi_operators.c,missing_stage_kernels.c,mfem_app_abs_l1_curlcurl_3d,complete_operator_branch,CurlCurl;VectorFEMass_Hcurl,miniapps/diag-smoothers/abs-l1-jacobi.cpp,294-301,,true,true,true,true,166,0,29,54,29 +navier_tgv,navier_tgv_pressure_diffusion_3d.c,missing_stage_kernels.c,mfem_app_navier_tgv_pa_operators_3d,complete_pa_operator_families,VectorMass;VectorDiffusion;VectorConvectionNLF;pressure_Diffusion;discrete_divergence;discrete_gradient,miniapps/fluids/navier/navier_solver.cpp,128-205,,true,true,true,true,720,0,190,349,70 diff --git a/issues/mfem_c_kernels/application_extractions/stage_kernels.h b/issues/mfem_c_kernels/application_extractions/stage_kernels.h new file mode 100644 index 000000000000..36b0ba82a7ce --- /dev/null +++ b/issues/mfem_c_kernels/application_extractions/stage_kernels.h @@ -0,0 +1,114 @@ +#ifndef MFEM_APPLICATION_STAGE_KERNELS_H +#define MFEM_APPLICATION_STAGE_KERNELS_H + +/* Give each included extraction private constant names. The numerical + * functions retain their manifest names and are inlined by cgeist into an + * application entry point selected with --function. */ + +#define D1D MASS_D1D +#define Q1D MASS_Q1D +#define NE MASS_NE +#include "../normalized/mass_stage_sliced.c" +#undef X2 +#undef D2 +#undef X3 +#undef D3 +#undef NE +#undef Q1D +#undef D1D + +#define D1D DIFF_D1D +#define Q1D DIFF_Q1D +#define NE DIFF_NE +#include "../normalized/diffusion_stage_sliced.c" +#undef X2 +#undef X3 +#undef O2 +#undef O3 +#undef NE +#undef Q1D +#undef D1D + +#define D1D CONV_D1D +#define Q1D CONV_Q1D +#define NE CONV_NE +#include "../normalized/convection_stage_sliced.c" +#undef X2 +#undef X3 +#undef O2 +#undef O3 +#undef NE +#undef Q1D +#undef D1D + +#define D1D DERHAM2_D1D +#define Q1D DERHAM2_Q1D +#define EDGE DERHAM2_EDGE +#define NE DERHAM2_NE +#define N2 DERHAM2_N2 +#include "../normalized/de_rham2_stage_sliced.c" +#undef V +#undef O +#undef N2 +#undef NE +#undef EDGE +#undef Q1D +#undef D1D + +#define D1D CURL3_D1D +#define Q1D CURL3_Q1D +#define EDGE CURL3_EDGE +#define NE CURL3_NE +#define N3 CURL3_N3 +#include "../normalized/curlcurl3_stage_sliced.c" +#undef V +#undef OP +#undef N3 +#undef NE +#undef EDGE +#undef Q1D +#undef D1D + +#define D1D DIV3_D1D +#define Q1D DIV3_Q1D +#define EDGE DIV3_EDGE +#define NE DIV3_NE +#define N3 DIV3_N3 +#include "../normalized/divdiv3_stage_sliced.c" +#undef V +#undef O +#undef N3 +#undef NE +#undef EDGE +#undef Q1D +#undef D1D + +#define D1D GRAD_D1D +#define Q1D GRAD_Q1D +#define VDIM GRAD_VDIM +#include "../normalized/gradient_stage_sliced.c" +#undef F2 +#undef F3 +#undef Q2 +#undef Q3 +#undef VDIM +#undef Q1D +#undef D1D + +#define Q1D ELAS_Q1D +#define NE ELAS_NE +#define NQ2 ELAS_NQ2 +#define NQ3 ELAS_NQ3 +#include "../normalized/elasticity_scalarized.c" +#undef J2 +#undef J3 +#undef Q2 +#undef Q3 +#undef NQ3 +#undef NQ2 +#undef NE +#undef Q1D + +#include "missing_stage_kernels.c" + +#endif diff --git a/issues/mfem_c_kernels/applications/.gitignore b/issues/mfem_c_kernels/applications/.gitignore new file mode 100644 index 000000000000..567609b1234a --- /dev/null +++ b/issues/mfem_c_kernels/applications/.gitignore @@ -0,0 +1 @@ +build/ diff --git a/issues/mfem_c_kernels/applications/README.md b/issues/mfem_c_kernels/applications/README.md new file mode 100644 index 000000000000..409247ae27c1 --- /dev/null +++ b/issues/mfem_c_kernels/applications/README.md @@ -0,0 +1,21 @@ +# MFEM application hot-operator ports + +These harnesses connect the extracted MFEM partial-assembly operators to the +serial examples that exercise the same algorithmic families: + +- `ex1_diffusion_3d.c`: Example 1, H1 diffusion. +- `ex3_curlcurl_3d.c`: Example 3, H(curl) curl-curl. +- `ex4_divdiv_3d.c`: Example 4, H(div) div-div. +- `ex9_mass_2d.c` and `ex9_convection_2d.c`: Example 9, DG mass and convection. + +Each harness checks one compiler-raised operator application against the +faithful extracted C implementation, then reports warmed per-application time. +The current extracted functions are specialized to `D1D=4`, `Q1D=5`, and +`NE=2`. Consequently these are hot-operator ports, not yet drop-in replacements +for MFEM's arbitrary element batches. Repeating a two-element function call is +also intentionally not presented as an optimized GPU integration: it measures +the launch/transfer cost of the current ABI as well as the library operation. + +Run `./run_native.sh` for the faithful-versus-stage-sliced CPU check. Current +measurements and the raised-pipeline blockers are recorded in +`RESULTS_2026_07_31.md`. diff --git a/issues/mfem_c_kernels/applications/RESULTS_2026_07_31.md b/issues/mfem_c_kernels/applications/RESULTS_2026_07_31.md new file mode 100644 index 000000000000..f986476e4b37 --- /dev/null +++ b/issues/mfem_c_kernels/applications/RESULTS_2026_07_31.md @@ -0,0 +1,54 @@ +# MFEM application-port results, 2026-07-31 + +## Scope + +The first ports cover the partial-assembly hot operators used by MFEM examples +1, 3, 4, and 9. They retain the extraction specialization `D1D=4`, `Q1D=5`, +and `NE=2`; they are not yet wired into MFEM's arbitrary-size operator API. + +## Whole MFEM baseline smoke tests + +The pinned MFEM library and serial examples built successfully. Runs used the +`cpu` device, partial assembly, no visualization, and one OpenMP thread. + +- `ex1`, H1 diffusion, `inline-hex.mesh`, order 3: completed in 38.56 s. +- `ex3`, H(curl), `inline-hex.mesh`, order 3: exceeded the 60 s smoke-test cap. +- `ex4`, H(div), `inline-hex.mesh`, order 3: completed in 42.30 s. +- `ex9`, DG advection, order 3, two time steps: completed in 0.02 s. + +These wall times include mesh setup, assembly, constraints, and solver work, so +they are not used to claim a kernel speedup. + +## Faithful C versus stage-sliced C + +Each result is 10,000 warmed applications of a two-element operator. The +maximum errors are measured after one application. + +- `ex1` diffusion 3D: 6.344 us -> 4.668 us, 1.359x, error 1.78e-15. +- `ex3` curl-curl 3D: 13.803 us -> 7.945 us, 1.737x, error 3.55e-15. +- `ex4` div-div 3D: 15.643 us -> 4.981 us, 3.141x, error 8.88e-16. +- `ex9` convection 2D: 0.494 us -> 0.329 us, 1.500x, error 2.22e-16. +- `ex9` mass 2D: 0.267 us -> 0.248 us, 1.078x, error 0. + +This establishes that scratch/stage slicing preserves the operator and can +improve ordinary C optimization. It is not a vendor-library or GPU result. + +## Raised/library-backed pipeline status + +The application harness found two integration failures before a valid silicon +performance comparison could be made: + +1. Pointer-only extracted functions did not retain heterogeneous argument + extents in the generated C-to-memref wrapper. Per-function + `polygeist-arg-extents` annotations and wrapper support now fix this. +2. `ex1` diffusion raises and emits 14 cuTensorNet contraction calls, but the + host semantic runtime disagrees with the faithful operator (maximum error + 25.566). This means the multi-stage contraction rewrite is not yet legal as + emitted; its measured time is invalid and must not be reported as speedup. +3. `ex9` mass emits three contraction calls but leaves a tensor-valued + `polygeist.submapInverse` after ABI cleanup, preventing LLVM lowering. + +GPU execution is intentionally gated on resolving these correctness/lowering +failures. The next useful step is stage-by-stage differential testing of the +multi-launch rewrite, followed by batched/persistent device-buffer integration +instead of one host transfer per two-element stage. diff --git a/issues/mfem_c_kernels/applications/bench_common.h b/issues/mfem_c_kernels/applications/bench_common.h new file mode 100644 index 000000000000..4b0ec34e761d --- /dev/null +++ b/issues/mfem_c_kernels/applications/bench_common.h @@ -0,0 +1,76 @@ +#ifndef POLYGEIST_MFEM_BENCH_COMMON_H +#define POLYGEIST_MFEM_BENCH_COMMON_H + +#include +#include +#include +#include +#include + +#ifndef BENCH_ITERS +#define BENCH_ITERS 100 +#endif + +static unsigned bench_state = 0x6d2b79f5u; + +static double bench_value(void) { + bench_state = 1664525u * bench_state + 1013904223u; + return ((double)((bench_state >> 8) & 0xffffu) / 32768.0) - 1.0; +} + +static void bench_fill(double *x, int n) { + for (int i = 0; i < n; ++i) x[i] = bench_value(); +} + +static void bench_transpose(const double *a, double *at, int rows, int cols) { + for (int i = 0; i < rows; ++i) + for (int j = 0; j < cols; ++j) at[j * rows + i] = a[i * cols + j]; +} + +static double bench_now(void) { + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return (double)ts.tv_sec + 1.0e-9 * (double)ts.tv_nsec; +} + +static double bench_max_error(const double *a, const double *b, int n) { + double error = 0.0; + for (int i = 0; i < n; ++i) { + const double d = fabs(a[i] - b[i]); + if (d > error) error = d; + } + return error; +} + +static double bench_checksum(const double *x, int n) { + double sum = 0.0; + for (int i = 0; i < n; ++i) sum += x[i] * (double)(i + 1); + return sum; +} + +#define RUN_AND_REPORT(APP, OP, CALL_REF, CALL_RAISED, YN) \ + do { \ + memset(y_ref, 0, sizeof(y_ref)); \ + memset(y_raised, 0, sizeof(y_raised)); \ + CALL_REF; \ + CALL_RAISED; \ + const double error = bench_max_error(y_ref, y_raised, (YN)); \ + memset(y_ref, 0, sizeof(y_ref)); \ + double begin = bench_now(); \ + for (int iteration = 0; iteration < BENCH_ITERS; ++iteration) CALL_REF; \ + const double reference_seconds = bench_now() - begin; \ + memset(y_raised, 0, sizeof(y_raised)); \ + begin = bench_now(); \ + for (int iteration = 0; iteration < BENCH_ITERS; ++iteration) CALL_RAISED;\ + const double raised_seconds = bench_now() - begin; \ + printf("app=%s operator=%s iterations=%d max_error=%.17g " \ + "reference_us=%.6f raised_us=%.6f speedup=%.6f checksum=%.17g\n", \ + (APP), (OP), BENCH_ITERS, error, \ + 1.0e6 * reference_seconds / BENCH_ITERS, \ + 1.0e6 * raised_seconds / BENCH_ITERS, \ + reference_seconds / raised_seconds, \ + bench_checksum(y_raised, (YN))); \ + return error <= 5.0e-13 ? 0 : 1; \ + } while (0) + +#endif diff --git a/issues/mfem_c_kernels/applications/ex1_diffusion_3d.c b/issues/mfem_c_kernels/applications/ex1_diffusion_3d.c new file mode 100644 index 000000000000..ab31d0b7f3e1 --- /dev/null +++ b/issues/mfem_c_kernels/applications/ex1_diffusion_3d.c @@ -0,0 +1,18 @@ +#include "bench_common.h" +#include "../original/diffusion_apply.c" + +void mfem_pa_diffusion_apply_3d_stage_sliced( + const double *, const double *, const double *, const double *, + const double *, const double *, double *); + +int main(void) { + double b[20], g[20], bt[20], gt[20], op[2 * 6 * 125], x[2 * 64]; + double y_ref[2 * 64], y_raised[2 * 64]; + bench_fill(b, 20); bench_fill(g, 20); + bench_transpose(b, bt, 5, 4); bench_transpose(g, gt, 5, 4); + bench_fill(op, 2 * 6 * 125); bench_fill(x, 2 * 64); + RUN_AND_REPORT("ex1", "diffusion_3d", + mfem_pa_diffusion_apply_3d(b, g, bt, gt, op, x, y_ref), + mfem_pa_diffusion_apply_3d_stage_sliced(b, g, bt, gt, op, x, y_raised), + 2 * 64); +} diff --git a/issues/mfem_c_kernels/applications/ex3_curlcurl_3d.c b/issues/mfem_c_kernels/applications/ex3_curlcurl_3d.c new file mode 100644 index 000000000000..5c94f0af8158 --- /dev/null +++ b/issues/mfem_c_kernels/applications/ex3_curlcurl_3d.c @@ -0,0 +1,21 @@ +#include "bench_common.h" +#include "../original/hcurl3_apply.c" + +void mfem_pa_curlcurl_apply_3d_stage_sliced( + const double *, const double *, const double *, const double *, + const double *, const double *, const double *, const double *, double *); + +int main(void) { + double bo[15], bc[20], bot[15], bct[20], g[20], gt[20]; + double op[2 * 6 * 125], x[2 * 3 * 3 * 4 * 4]; + double y_ref[2 * 3 * 3 * 4 * 4], y_raised[2 * 3 * 3 * 4 * 4]; + bench_fill(bo, 15); bench_fill(bc, 20); bench_fill(g, 20); + bench_transpose(bo, bot, 5, 3); bench_transpose(bc, bct, 5, 4); + bench_transpose(g, gt, 5, 4); + bench_fill(op, 2 * 6 * 125); bench_fill(x, 2 * 3 * 3 * 4 * 4); + RUN_AND_REPORT("ex3", "curlcurl_3d", + mfem_pa_curlcurl_apply_3d(bo, bc, bot, bct, g, gt, op, x, y_ref), + mfem_pa_curlcurl_apply_3d_stage_sliced(bo, bc, bot, bct, g, gt, op, x, + y_raised), + 2 * 3 * 3 * 4 * 4); +} diff --git a/issues/mfem_c_kernels/applications/ex4_divdiv_3d.c b/issues/mfem_c_kernels/applications/ex4_divdiv_3d.c new file mode 100644 index 000000000000..c7751c1f75f4 --- /dev/null +++ b/issues/mfem_c_kernels/applications/ex4_divdiv_3d.c @@ -0,0 +1,19 @@ +#include "bench_common.h" +#include "../original/de_rham_apply.c" + +void mfem_pa_divdiv_apply_3d_stage_sliced( + const double *, const double *, const double *, const double *, + const double *, const double *, double *); + +int main(void) { + double bo[15], bot[15], g[20], gt[20], op[2 * 125]; + double x[2 * 3 * 3 * 3 * 4], y_ref[2 * 3 * 3 * 3 * 4]; + double y_raised[2 * 3 * 3 * 3 * 4]; + bench_fill(bo, 15); bench_fill(g, 20); + bench_transpose(bo, bot, 5, 3); bench_transpose(g, gt, 5, 4); + bench_fill(op, 2 * 125); bench_fill(x, 2 * 3 * 3 * 3 * 4); + RUN_AND_REPORT("ex4", "divdiv_3d", + mfem_pa_divdiv_apply_3d(bo, bot, g, gt, op, x, y_ref), + mfem_pa_divdiv_apply_3d_stage_sliced(bo, bot, g, gt, op, x, y_raised), + 2 * 3 * 3 * 3 * 4); +} diff --git a/issues/mfem_c_kernels/applications/ex9_convection_2d.c b/issues/mfem_c_kernels/applications/ex9_convection_2d.c new file mode 100644 index 000000000000..facf1c7e0a7c --- /dev/null +++ b/issues/mfem_c_kernels/applications/ex9_convection_2d.c @@ -0,0 +1,17 @@ +#include "bench_common.h" +#include "../original/convection_apply.c" + +void mfem_pa_convection_apply_2d_stage_sliced( + const double *, const double *, const double *, const double *, + const double *, double *); + +int main(void) { + double b[20], g[20], bt[20], op[2 * 2 * 25], x[2 * 16]; + double y_ref[2 * 16], y_raised[2 * 16]; + bench_fill(b, 20); bench_fill(g, 20); bench_transpose(b, bt, 5, 4); + bench_fill(op, 2 * 2 * 25); bench_fill(x, 2 * 16); + RUN_AND_REPORT("ex9", "convection_2d", + mfem_pa_convection_apply_2d(b, g, bt, op, x, y_ref), + mfem_pa_convection_apply_2d_stage_sliced(b, g, bt, op, x, y_raised), + 2 * 16); +} diff --git a/issues/mfem_c_kernels/applications/ex9_mass_2d.c b/issues/mfem_c_kernels/applications/ex9_mass_2d.c new file mode 100644 index 000000000000..324077550dd2 --- /dev/null +++ b/issues/mfem_c_kernels/applications/ex9_mass_2d.c @@ -0,0 +1,16 @@ +#include "bench_common.h" +#include "../original/mass_apply.c" + +void mfem_pa_mass_apply_2d_stage_sliced( + const double *, const double *, const double *, const double *, double *); + +int main(void) { + double b[20], bt[20], op[2 * 25], x[2 * 16]; + double y_ref[2 * 16], y_raised[2 * 16]; + bench_fill(b, 20); bench_transpose(b, bt, 5, 4); + bench_fill(op, 2 * 25); bench_fill(x, 2 * 16); + RUN_AND_REPORT("ex9", "mass_2d", + mfem_pa_mass_apply_2d(b, bt, op, x, y_ref), + mfem_pa_mass_apply_2d_stage_sliced(b, bt, op, x, y_raised), + 2 * 16); +} diff --git a/issues/mfem_c_kernels/applications/run_native.sh b/issues/mfem_c_kernels/applications/run_native.sh new file mode 100755 index 000000000000..eedb12ef259f --- /dev/null +++ b/issues/mfem_c_kernels/applications/run_native.sh @@ -0,0 +1,22 @@ +#!/bin/bash +set -euo pipefail + +HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +CORPUS="$(cd "$HERE/.." && pwd)" +OUT="$HERE/build/native" +CC="${CC:-clang}" +ITERS="${BENCH_ITERS:-10000}" +mkdir -p "$OUT" + +build() { + "$CC" -O3 -DBENCH_ITERS="$ITERS" "$CORPUS/normalized/$1" "$HERE/$2" \ + -lm -o "$OUT/$3" +} + +build diffusion_stage_sliced.c ex1_diffusion_3d.c ex1_diffusion_3d +build curlcurl3_stage_sliced.c ex3_curlcurl_3d.c ex3_curlcurl_3d +build divdiv3_stage_sliced.c ex4_divdiv_3d.c ex4_divdiv_3d +build convection_stage_sliced.c ex9_convection_2d.c ex9_convection_2d +build mass_stage_sliced.c ex9_mass_2d.c ex9_mass_2d + +for executable in "$OUT"/*; do "$executable"; done diff --git a/issues/mfem_c_kernels/applications/summary.csv b/issues/mfem_c_kernels/applications/summary.csv new file mode 100644 index 000000000000..3bce3bff069c --- /dev/null +++ b/issues/mfem_c_kernels/applications/summary.csv @@ -0,0 +1,6 @@ +id,application,operator,dimension,kernel_id,harness,normalized,reference_us,sliced_us,speedup,max_error,library_launches,raised_status,blocker +ex1_diffusion_3d,MFEM ex1,H1 diffusion,3,diffusion_apply_3d_stage_sliced,ex1_diffusion_3d.c,../normalized/diffusion_stage_sliced.c,6.344,4.668,1.359,1.78e-15,14,SEMANTIC MISMATCH,"14 cuTensorNet calls emit, but the composed result differs from the faithful operator (max error 25.566)" +ex3_curlcurl_3d,MFEM ex3,H(curl) curl-curl,3,curlcurl_apply_3d_stage_sliced,ex3_curlcurl_3d.c,../normalized/curlcurl3_stage_sliced.c,13.803,7.945,1.737,3.55e-15,29,NOT E2E TESTED,"Stage matches exist; complete library-backed host correctness is pending" +ex4_divdiv_3d,MFEM ex4,H(div) div-div,3,divdiv_apply_3d_stage_sliced,ex4_divdiv_3d.c,../normalized/divdiv3_stage_sliced.c,15.643,4.981,3.141,8.88e-16,12,NOT E2E TESTED,"Stage matches exist; complete library-backed host correctness is pending" +ex9_convection_2d,MFEM ex9,DG convection,2,convection_apply_2d_stage_sliced,ex9_convection_2d.c,../normalized/convection_stage_sliced.c,0.494,0.329,1.500,2.22e-16,6,NOT E2E TESTED,"Stage matches exist; complete library-backed host correctness is pending" +ex9_mass_2d,MFEM ex9,DG mass,2,mass_apply_2d_stage_sliced,ex9_mass_2d.c,../normalized/mass_stage_sliced.c,0.267,0.248,1.078,0,3,LOWERING BLOCKED,"tensor-valued polygeist.submapInverse remains after ABI cleanup" diff --git a/issues/mfem_c_kernels/benchmarks/cutensornet_device_abi_smoke.c b/issues/mfem_c_kernels/benchmarks/cutensornet_device_abi_smoke.c new file mode 100644 index 000000000000..0b7e24660740 --- /dev/null +++ b/issues/mfem_c_kernels/benchmarks/cutensornet_device_abi_smoke.c @@ -0,0 +1,83 @@ +#include "polygeist_cublas_rt.h" + +#include +#include +#include +#include +#include + +enum { MAX_RANK = 64, FIELDS_PER_TENSOR = 3 * MAX_RANK, + METADATA_SIZE = 3 + 3 * FIELDS_PER_TENSOR }; + +static void set_tensor_metadata(int64_t metadata[METADATA_SIZE], int tensor, + int rank, const int64_t *extents, + const int64_t *strides, + const int64_t *modes) { + metadata[tensor] = rank; + const int base = 3 + tensor * FIELDS_PER_TENSOR; + for (int dim = 0; dim < rank; ++dim) { + metadata[base + dim] = extents[dim]; + metadata[base + MAX_RANK + dim] = strides[dim]; + metadata[base + 2 * MAX_RANK + dim] = modes[dim]; + } +} + +static int check_cuda(cudaError_t status, const char *operation) { + if (status == cudaSuccess) return 1; + fprintf(stderr, "%s failed: %s\n", operation, cudaGetErrorString(status)); + return 0; +} + +int main(void) { + const double host_a[6] = {1, 2, 3, 4, 5, 6}; + const double host_b[6] = {7, 8, 9, 10, 11, 12}; + const double expected[4] = {58, 64, 139, 154}; + double host_c[4] = {0, 0, 0, 0}; + double *device_a = NULL, *device_b = NULL, *device_c = NULL; + int64_t metadata[METADATA_SIZE]; + memset(metadata, 0, sizeof(metadata)); + + const int64_t a_extents[2] = {2, 3}; + const int64_t a_strides[2] = {3, 1}; + const int64_t a_modes[2] = {0, 2}; + const int64_t b_extents[2] = {3, 2}; + const int64_t b_strides[2] = {2, 1}; + const int64_t b_modes[2] = {2, 1}; + const int64_t c_extents[2] = {2, 2}; + const int64_t c_strides[2] = {2, 1}; + const int64_t c_modes[2] = {0, 1}; + set_tensor_metadata(metadata, 0, 2, a_extents, a_strides, a_modes); + set_tensor_metadata(metadata, 1, 2, b_extents, b_strides, b_modes); + set_tensor_metadata(metadata, 2, 2, c_extents, c_strides, c_modes); + + if (!check_cuda(cudaMalloc((void **)&device_a, sizeof(host_a)), "cudaMalloc A") || + !check_cuda(cudaMalloc((void **)&device_b, sizeof(host_b)), "cudaMalloc B") || + !check_cuda(cudaMalloc((void **)&device_c, sizeof(host_c)), "cudaMalloc C") || + !check_cuda(cudaMemcpy(device_a, host_a, sizeof(host_a), + cudaMemcpyHostToDevice), "copy A") || + !check_cuda(cudaMemcpy(device_b, host_b, sizeof(host_b), + cudaMemcpyHostToDevice), "copy B")) + return 2; + + polygeist_cutensornet_contraction2_f64_device( + device_a, device_b, device_c, metadata); + polygeist_cutensornet_contraction2_f64_device( + device_a, device_b, device_c, metadata); + if (!check_cuda(cudaMemcpy(host_c, device_c, sizeof(host_c), + cudaMemcpyDeviceToHost), "copy C")) + return 2; + + double max_error = 0.0; + for (int i = 0; i < 4; ++i) + max_error = fmax(max_error, fabs(host_c[i] - expected[i])); + printf("cutensornet_device_abi correctness=%s max_error=%.3e " + "result=[%.1f,%.1f,%.1f,%.1f]\n", + max_error < 1.0e-12 ? "PASS" : "FAIL", max_error, + host_c[0], host_c[1], host_c[2], host_c[3]); + + cudaFree(device_a); + cudaFree(device_b); + cudaFree(device_c); + polygeist_cublas_destroy(); + return max_error < 1.0e-12 ? 0 : 1; +} diff --git a/issues/mfem_c_kernels/benchmarks/mfem_native_cuda_dfem_bench.cpp b/issues/mfem_c_kernels/benchmarks/mfem_native_cuda_dfem_bench.cpp new file mode 100644 index 000000000000..903c7cfa5d44 --- /dev/null +++ b/issues/mfem_c_kernels/benchmarks/mfem_native_cuda_dfem_bench.cpp @@ -0,0 +1,179 @@ +#include + +#include +#include +#include +#include + +#include "mfem.hpp" +#include "fem/dfem/integrate.hpp" +#include "fem/dfem/interpolate.hpp" + +#ifndef MFEM_BENCH_NE +#define MFEM_BENCH_NE 1024 +#endif +#ifndef BENCH_ITERS +#define BENCH_ITERS 20 +#endif + +using mfem::Vector; +using mfem::DeviceTensor; +using mfem::real_t; +using namespace mfem::future; + +#if defined(BENCH_INTERP_VALUE_2D) +#define BENCH_NAME "interp_value_2d" +#define DIMENSION 2 +#define IS_INTERPOLATION 1 +#define IS_GRADIENT 0 +#elif defined(BENCH_INTERP_VALUE_3D) +#define BENCH_NAME "interp_value_3d" +#define DIMENSION 3 +#define IS_INTERPOLATION 1 +#define IS_GRADIENT 0 +#elif defined(BENCH_INTEGRATE_VALUE_2D) +#define BENCH_NAME "integrate_value_2d" +#define DIMENSION 2 +#define IS_INTERPOLATION 0 +#define IS_GRADIENT 0 +#elif defined(BENCH_INTEGRATE_VALUE_3D) +#define BENCH_NAME "integrate_value_3d" +#define DIMENSION 3 +#define IS_INTERPOLATION 0 +#define IS_GRADIENT 0 +#elif defined(BENCH_INTERP_GRAD_2D) +#define BENCH_NAME "interp_grad_2d" +#define DIMENSION 2 +#define IS_INTERPOLATION 1 +#define IS_GRADIENT 1 +#elif defined(BENCH_INTERP_GRAD_3D) +#define BENCH_NAME "interp_grad_3d" +#define DIMENSION 3 +#define IS_INTERPOLATION 1 +#define IS_GRADIENT 1 +#elif defined(BENCH_INTEGRATE_GRAD_2D) +#define BENCH_NAME "integrate_grad_2d" +#define DIMENSION 2 +#define IS_INTERPOLATION 0 +#define IS_GRADIENT 1 +#elif defined(BENCH_INTEGRATE_GRAD_3D) +#define BENCH_NAME "integrate_grad_3d" +#define DIMENSION 3 +#define IS_INTERPOLATION 0 +#define IS_GRADIENT 1 +#else +#error "Select one BENCH_{INTERP,INTEGRATE}_{VALUE,GRAD}_{2D,3D} kernel" +#endif + +static constexpr int D1D = 4; +static constexpr int Q1D = 5; +static constexpr int DOFS = DIMENSION == 2 ? D1D * D1D : D1D * D1D * D1D; +static constexpr int QPTS = DIMENSION == 2 ? Q1D * Q1D : Q1D * Q1D * Q1D; +static constexpr int TERMS = IS_GRADIENT ? DIMENSION : 1; +static constexpr int INPUT_SIZE = + IS_INTERPOLATION ? DOFS * MFEM_BENCH_NE + : TERMS * QPTS * MFEM_BENCH_NE; +static constexpr int OUTPUT_SIZE = + IS_INTERPOLATION ? TERMS * QPTS * MFEM_BENCH_NE + : DOFS * MFEM_BENCH_NE; +static constexpr int SCRATCH_SLICE = 100; +static constexpr int SCRATCH_SIZE = 6 * SCRATCH_SLICE; + +static double value(int i, int salt) { + return (double)(((i * 17 + salt * 13 + 5) % 101) - 50) / 257.0; +} + +template +static void launch(const Vector &basis, const Vector &gradient, + const Vector &input, Vector &output, + FieldOperatorType field_operator) { + const real_t *B = basis.Read(); + const real_t *G = gradient.Read(); + const real_t *X = input.Read(); + real_t *Y = output.ReadWrite(); + const DofToQuadMap dtq{ + DeviceTensor<3, const real_t>(B, Q1D, 1, D1D), + DeviceTensor<3, const real_t>(G, Q1D, 1, D1D), -1}; + const DeviceTensor<1, const real_t> weights(nullptr, 0); + const std::array scratch_sizes = { + SCRATCH_SLICE, SCRATCH_SLICE, SCRATCH_SLICE, + SCRATCH_SLICE, SCRATCH_SLICE, SCRATCH_SLICE}; + ThreadBlocks blocks{Q1D, Q1D, DIMENSION == 3 ? Q1D : 1}; + + mfem::future::forall( + [=] MFEM_HOST_DEVICE(int e, void *shared_memory) mutable { + auto scratch = load_scratch_mem( + shared_memory, 0, scratch_sizes); +#if IS_INTERPOLATION + DeviceTensor<1> field_e(const_cast(X) + e * DOFS, DOFS); + DeviceTensor<2> field_qp(Y + e * TERMS * QPTS, TERMS, QPTS); +#if DIMENSION == 2 + map_field_to_quadrature_data_tensor_product_2d( + field_qp, dtq, field_e, field_operator, weights, scratch); +#else + map_field_to_quadrature_data_tensor_product_3d( + field_qp, dtq, field_e, field_operator, weights, scratch); +#endif +#else + DeviceTensor<3> field_qp( + const_cast(X) + e * TERMS * QPTS, 1, TERMS, QPTS); + DeviceTensor<2> field_e(Y + e * DOFS, DOFS, 1); +#if DIMENSION == 2 + map_quadrature_data_to_fields_tensor_impl_2d( + field_e, field_qp, field_operator, dtq, scratch); +#else + map_quadrature_data_to_fields_tensor_impl_3d( + field_e, field_qp, field_operator, dtq, scratch); +#endif +#endif + }, + MFEM_BENCH_NE, blocks, SCRATCH_SIZE); +} + +int main() { + mfem::Device device("cuda"); + Vector basis(20), gradient(20), input(INPUT_SIZE), output(OUTPUT_SIZE); + for (int i = 0; i < 20; ++i) { + basis[i] = value(0, 0); + gradient[i] = value(0, 1); + } + for (int i = 0; i < INPUT_SIZE; ++i) input[i] = value(i, 7); + output = 0.0; + +#if IS_GRADIENT + Gradient<> field_operator; +#else + Value<> field_operator; +#endif + field_operator.vdim = 1; + field_operator.dim = DIMENSION; + field_operator.size_on_qp = TERMS; + + launch(basis, gradient, input, output, field_operator); + cudaDeviceSynchronize(); + const real_t *host_output = output.HostRead(); + double checksum = 0.0; + double max_abs = 0.0; + for (int i = 0; i < OUTPUT_SIZE; ++i) { + checksum += host_output[i]; + max_abs = fmax(max_abs, fabs(host_output[i])); + } + + output = 0.0; + launch(basis, gradient, input, output, field_operator); + cudaDeviceSynchronize(); + output = 0.0; + const auto start = std::chrono::steady_clock::now(); + for (int i = 0; i < BENCH_ITERS; ++i) { + launch(basis, gradient, input, output, field_operator); + } + const auto stop = std::chrono::steady_clock::now(); + const double runtime_us = + std::chrono::duration(stop - start).count() / + BENCH_ITERS; + std::printf("implementation=mfem_native_cuda kernel=%s ne=%d iterations=%d " + "runtime_us=%.6f checksum=%.17g max_abs=%.17g\n", + BENCH_NAME, MFEM_BENCH_NE, BENCH_ITERS, runtime_us, + checksum, max_abs); + return cudaGetLastError() == cudaSuccess ? 0 : 1; +} diff --git a/issues/mfem_c_kernels/benchmarks/mfem_native_cuda_pa_bench.cpp b/issues/mfem_c_kernels/benchmarks/mfem_native_cuda_pa_bench.cpp new file mode 100644 index 000000000000..a6713ae106cc --- /dev/null +++ b/issues/mfem_c_kernels/benchmarks/mfem_native_cuda_pa_bench.cpp @@ -0,0 +1,254 @@ +#include + +#include +#include +#include + +#include "mfem.hpp" + +// MFEM's implementation headers reuse some internal aliases, just as normal +// MFEM translation units do. Include only the selected kernel family. +#if defined(BENCH_MASS_2D) || defined(BENCH_MASS_3D) +#include "fem/integ/bilininteg_mass_kernels.hpp" +#elif defined(BENCH_DIFFUSION_2D) || defined(BENCH_DIFFUSION_3D) +#include "fem/integ/bilininteg_diffusion_kernels.hpp" +#elif defined(BENCH_CONVECTION_2D) || defined(BENCH_CONVECTION_3D) +#include "fem/integ/bilininteg_convection_kernels.hpp" +#elif defined(BENCH_CURLCURL_2D) || defined(BENCH_CURLCURL_3D) || \ + defined(BENCH_HCURL_MASS_3D) +#include "fem/integ/bilininteg_hcurl_kernels.hpp" +#elif defined(BENCH_DIVDIV_2D) || defined(BENCH_DIVDIV_3D) || \ + defined(BENCH_HDIV_MASS_3D) +#include "fem/integ/bilininteg_hdiv_kernels.hpp" +#else +#error "Select one BENCH_* kernel family" +#endif + +#ifndef MFEM_BENCH_NE +#define MFEM_BENCH_NE 1024 +#endif +#ifndef BENCH_ITERS +#define BENCH_ITERS 20 +#endif + +using mfem::Array; +using mfem::Vector; +using mfem::real_t; + +#if defined(BENCH_MASS_2D) +#define BENCH_NAME "mass_apply_2d" +#define OP_SIZE (25 * MFEM_BENCH_NE) +#define X_SIZE (16 * MFEM_BENCH_NE) +#define Y_SIZE X_SIZE +static void launch(const Array &a0, const Array &a1, + const Array &, const Array &, + const Array &, const Array &, + const Vector &op, const Vector &x, Vector &y) { + mfem::internal::SmemPAMassApply2D<4, 5>(MFEM_BENCH_NE, a0, a1, op, x, y); +} +#elif defined(BENCH_MASS_3D) +#define BENCH_NAME "mass_apply_3d" +#define OP_SIZE (125 * MFEM_BENCH_NE) +#define X_SIZE (64 * MFEM_BENCH_NE) +#define Y_SIZE X_SIZE +static void launch(const Array &a0, const Array &a1, + const Array &, const Array &, + const Array &, const Array &, + const Vector &op, const Vector &x, Vector &y) { + mfem::internal::SmemPAMassApply3D<4, 5>(MFEM_BENCH_NE, a0, a1, op, x, y); +} +#elif defined(BENCH_DIFFUSION_2D) +#define BENCH_NAME "diffusion_apply_2d" +#define OP_SIZE (75 * MFEM_BENCH_NE) +#define X_SIZE (16 * MFEM_BENCH_NE) +#define Y_SIZE X_SIZE +static void launch(const Array &a0, const Array &a1, + const Array &a2, const Array &a3, + const Array &, const Array &, + const Vector &op, const Vector &x, Vector &y) { + mfem::internal::SmemPADiffusionApply2D<4, 5>( + MFEM_BENCH_NE, true, a0, a1, a2, a3, op, x, y); +} +#elif defined(BENCH_DIFFUSION_3D) +#define BENCH_NAME "diffusion_apply_3d" +#define OP_SIZE (750 * MFEM_BENCH_NE) +#define X_SIZE (64 * MFEM_BENCH_NE) +#define Y_SIZE X_SIZE +static void launch(const Array &a0, const Array &a1, + const Array &a2, const Array &a3, + const Array &, const Array &, + const Vector &op, const Vector &x, Vector &y) { + mfem::internal::SmemPADiffusionApply3D<4, 5>( + MFEM_BENCH_NE, true, a0, a1, a2, a3, op, x, y); +} +#elif defined(BENCH_CONVECTION_2D) +#define BENCH_NAME "convection_apply_2d" +#define OP_SIZE (50 * MFEM_BENCH_NE) +#define X_SIZE (16 * MFEM_BENCH_NE) +#define Y_SIZE X_SIZE +static void launch(const Array &a0, const Array &a1, + const Array &a2, const Array &a3, + const Array &, const Array &, + const Vector &op, const Vector &x, Vector &y) { + mfem::SmemPAConvectionApply2D<4, 5, mfem::convection::NBZ(4)>( + MFEM_BENCH_NE, a0, a1, a2, a3, op, x, y); +} +#elif defined(BENCH_CONVECTION_3D) +#define BENCH_NAME "convection_apply_3d" +#define OP_SIZE (375 * MFEM_BENCH_NE) +#define X_SIZE (64 * MFEM_BENCH_NE) +#define Y_SIZE X_SIZE +static void launch(const Array &a0, const Array &a1, + const Array &a2, const Array &a3, + const Array &, const Array &, + const Vector &op, const Vector &x, Vector &y) { + mfem::SmemPAConvectionApply3D<4, 5>(MFEM_BENCH_NE, a0, a1, a2, a3, + op, x, y); +} +#elif defined(BENCH_CURLCURL_2D) +#define BENCH_NAME "curlcurl_apply_2d" +#define OP_SIZE (25 * MFEM_BENCH_NE) +#define X_SIZE (24 * MFEM_BENCH_NE) +#define Y_SIZE X_SIZE +static void launch(const Array &a0, const Array &a1, + const Array &a2, const Array &a3, + const Array &a4, const Array &a5, + const Vector &op, const Vector &x, Vector &y) { + mfem::internal::PACurlCurlApply2D(4, 5, true, MFEM_BENCH_NE, a0, a2, + a1, a3, a4, a5, op, x, y); +} +#elif defined(BENCH_CURLCURL_3D) +#define BENCH_NAME "curlcurl_apply_3d" +#define OP_SIZE (750 * MFEM_BENCH_NE) +#define X_SIZE (144 * MFEM_BENCH_NE) +#define Y_SIZE X_SIZE +static void launch(const Array &a0, const Array &a1, + const Array &a2, const Array &a3, + const Array &a4, const Array &a5, + const Vector &op, const Vector &x, Vector &y) { + mfem::internal::SmemPACurlCurlApply3D<4, 5>( + 4, 5, true, MFEM_BENCH_NE, a0, a2, a1, a3, a4, a5, op, x, y); +} +#elif defined(BENCH_HCURL_MASS_3D) +#define BENCH_NAME "hcurl_mass_apply_3d" +#define OP_SIZE (750 * MFEM_BENCH_NE) +#define X_SIZE (144 * MFEM_BENCH_NE) +#define Y_SIZE X_SIZE +static void launch(const Array &a0, const Array &a1, + const Array &a2, const Array &a3, + const Array &, const Array &, + const Vector &op, const Vector &x, Vector &y) { + mfem::internal::SmemPAHcurlMassApply3D<4, 5>( + 4, 5, MFEM_BENCH_NE, true, a0, a2, a1, a3, op, x, y); +} +#elif defined(BENCH_DIVDIV_2D) +#define BENCH_NAME "divdiv_apply_2d" +#define OP_SIZE (25 * MFEM_BENCH_NE) +#define X_SIZE (24 * MFEM_BENCH_NE) +#define Y_SIZE X_SIZE +static void launch(const Array &a0, const Array &a1, + const Array &a2, const Array &a3, + const Array &, const Array &, + const Vector &op, const Vector &x, Vector &y) { + mfem::internal::PADivDivApply2D(4, 5, MFEM_BENCH_NE, a0, a2, a1, a3, + op, x, y); +} +#elif defined(BENCH_DIVDIV_3D) +#define BENCH_NAME "divdiv_apply_3d" +#define OP_SIZE (125 * MFEM_BENCH_NE) +#define X_SIZE (108 * MFEM_BENCH_NE) +#define Y_SIZE X_SIZE +static void launch(const Array &a0, const Array &a1, + const Array &a2, const Array &a3, + const Array &, const Array &, + const Vector &op, const Vector &x, Vector &y) { + mfem::internal::PADivDivApply3D(4, 5, MFEM_BENCH_NE, a0, a2, a1, a3, + op, x, y); +} +#elif defined(BENCH_HDIV_MASS_3D) +#define BENCH_NAME "hdiv_mass_apply_3d" +#define OP_SIZE (750 * MFEM_BENCH_NE) +#define X_SIZE (108 * MFEM_BENCH_NE) +#define Y_SIZE X_SIZE +static void launch(const Array &a0, const Array &a1, + const Array &a2, const Array &a3, + const Array &, const Array &, + const Vector &op, const Vector &x, Vector &y) { + mfem::internal::SmemPAHdivMassApply3D<4, 5>( + MFEM_BENCH_NE, true, a0, a2, a1, a3, op, x, y); +} +#else +#error "Select one BENCH_* operator" +#endif + +static double value(int i, int salt) { + return (double)(((i * 17 + salt * 13 + 5) % 101) - 50) / 257.0; +} + +static void transpose(Array &dst, const Array &src, + int rows, int cols) { + for (int row = 0; row < rows; ++row) + for (int col = 0; col < cols; ++col) + dst[col * rows + row] = src[row * cols + col]; +} + +int main() { + mfem::Device device("cuda"); + Array a0(20), a1(20), a2(20), a3(20), a4(20), a5(20); + Array *arrays[] = {&a0, &a1, &a2, &a3, &a4, &a5}; + for (int a = 0; a < 6; ++a) + for (int i = 0; i < arrays[a]->Size(); ++i) + // The extracted C stores basis matrices row-major while MFEM's + // DeviceMatrix view is column-major. A per-matrix constant keeps the + // same logical test input in both representations without conflating + // layout conversion with operator correctness. + (*arrays[a])[i] = value(0, a); +#if defined(BENCH_CURLCURL_2D) || defined(BENCH_CURLCURL_3D) || \ + defined(BENCH_HCURL_MASS_3D) + transpose(a1, a0, 5, 3); // Bot = transpose(Bo) + transpose(a3, a2, 5, 4); // Bct = transpose(Bc) + transpose(a5, a4, 5, 4); // Gct = transpose(Gc) +#elif defined(BENCH_DIVDIV_2D) || defined(BENCH_DIVDIV_3D) || \ + defined(BENCH_HDIV_MASS_3D) + transpose(a1, a0, 5, 3); // Bot = transpose(Bo) + transpose(a3, a2, 5, 4); // Gct = transpose(Gc) +#elif defined(BENCH_MASS_2D) || defined(BENCH_MASS_3D) + transpose(a1, a0, 5, 4); // Bt = transpose(B) +#else + transpose(a2, a0, 5, 4); // Bt = transpose(B) + transpose(a3, a1, 5, 4); // Gt = transpose(G) +#endif + + Vector op(OP_SIZE), x(X_SIZE), y(Y_SIZE); + for (int i = 0; i < op.Size(); ++i) op[i] = value(i, 6); + for (int i = 0; i < x.Size(); ++i) x[i] = value(i, 7); + y = 0.0; + + launch(a0, a1, a2, a3, a4, a5, op, x, y); + cudaDeviceSynchronize(); + const real_t *host_y = y.HostRead(); + double checksum = 0.0; + double max_abs = 0.0; + for (int i = 0; i < y.Size(); ++i) { + checksum += host_y[i]; + max_abs = fmax(max_abs, fabs(host_y[i])); + } + + y = 0.0; + launch(a0, a1, a2, a3, a4, a5, op, x, y); + cudaDeviceSynchronize(); + y = 0.0; + const auto start = std::chrono::steady_clock::now(); + for (int i = 0; i < BENCH_ITERS; ++i) { + launch(a0, a1, a2, a3, a4, a5, op, x, y); + cudaDeviceSynchronize(); + } + const auto stop = std::chrono::steady_clock::now(); + const double us = + std::chrono::duration(stop - start).count() / + BENCH_ITERS; + std::printf("implementation=mfem_native_cuda kernel=%s ne=%d iterations=%d " + "runtime_us=%.6f checksum=%.17g max_abs=%.17g\n", + BENCH_NAME, MFEM_BENCH_NE, BENCH_ITERS, us, checksum, max_abs); + return cudaGetLastError() == cudaSuccess ? 0 : 1; +} diff --git a/issues/mfem_c_kernels/benchmarks/mfem_raised_pa_bench.c b/issues/mfem_c_kernels/benchmarks/mfem_raised_pa_bench.c new file mode 100644 index 000000000000..152733a1ef87 --- /dev/null +++ b/issues/mfem_c_kernels/benchmarks/mfem_raised_pa_bench.c @@ -0,0 +1,227 @@ +#include +#include +#include +#include + +#ifndef MFEM_BENCH_NE +#define MFEM_BENCH_NE 1024 +#endif +#ifndef BENCH_ITERS +#define BENCH_ITERS 20 +#endif + +#define MAX_OP (750 * MFEM_BENCH_NE) +#define MAX_X (375 * MFEM_BENCH_NE) + +static double a[6][20]; +static double op[MAX_OP]; +static double x[MAX_X]; +static double y[MAX_X]; + +static double value(int i, int salt) { + return (double)(((i * 17 + salt * 13 + 5) % 101) - 50) / 257.0; +} + +static void transpose(double *dst, const double *src, int rows, int cols) { + for (int row = 0; row < rows; ++row) + for (int col = 0; col < cols; ++col) + dst[col * rows + row] = src[row * cols + col]; +} + +static double seconds(void) { + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return (double)ts.tv_sec + 1.0e-9 * (double)ts.tv_nsec; +} + +#if defined(BENCH_MASS_2D) +#define BENCH_NAME "mass_apply_2d" +#define FUNCTION mfem_pa_mass_apply_2d_stage_sliced +#define OP_SIZE (25 * MFEM_BENCH_NE) +#define X_SIZE (16 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, const double *, + const double *, double *); +static void run(void) { FUNCTION(a[0], a[1], op, x, y); } +#elif defined(BENCH_MASS_3D) +#define BENCH_NAME "mass_apply_3d" +#define FUNCTION mfem_pa_mass_apply_3d_stage_sliced +#define OP_SIZE (125 * MFEM_BENCH_NE) +#define X_SIZE (64 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, const double *, + const double *, double *); +static void run(void) { FUNCTION(a[0], a[1], op, x, y); } +#elif defined(BENCH_DIFFUSION_2D) +#define BENCH_NAME "diffusion_apply_2d" +#define FUNCTION mfem_pa_diffusion_apply_2d_stage_sliced +#define OP_SIZE (75 * MFEM_BENCH_NE) +#define X_SIZE (16 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, const double *, + const double *, const double *, const double *, double *); +static void run(void) { FUNCTION(a[0], a[1], a[2], a[3], op, x, y); } +#elif defined(BENCH_DIFFUSION_3D) +#define BENCH_NAME "diffusion_apply_3d" +#define FUNCTION mfem_pa_diffusion_apply_3d_stage_sliced +#define OP_SIZE (750 * MFEM_BENCH_NE) +#define X_SIZE (64 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, const double *, + const double *, const double *, const double *, double *); +static void run(void) { FUNCTION(a[0], a[1], a[2], a[3], op, x, y); } +#elif defined(BENCH_CONVECTION_2D) +#define BENCH_NAME "convection_apply_2d" +#define FUNCTION mfem_pa_convection_apply_2d_stage_sliced +#define OP_SIZE (50 * MFEM_BENCH_NE) +#define X_SIZE (16 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, const double *, + const double *, const double *, double *); +static void run(void) { FUNCTION(a[0], a[1], a[2], op, x, y); } +#elif defined(BENCH_CONVECTION_3D) +#define BENCH_NAME "convection_apply_3d" +#define FUNCTION mfem_pa_convection_apply_3d_stage_sliced +#define OP_SIZE (375 * MFEM_BENCH_NE) +#define X_SIZE (64 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, const double *, + const double *, const double *, double *); +static void run(void) { FUNCTION(a[0], a[1], a[2], op, x, y); } +#elif defined(BENCH_CURLCURL_2D) +#define BENCH_NAME "curlcurl_apply_2d" +#define FUNCTION mfem_pa_curlcurl_apply_2d_stage_sliced +#define OP_SIZE (25 * MFEM_BENCH_NE) +#define X_SIZE (24 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, const double *, + const double *, const double *, const double *, double *); +static void run(void) { FUNCTION(a[0], a[1], a[4], a[5], op, x, y); } +#elif defined(BENCH_CURLCURL_3D) +#define BENCH_NAME "curlcurl_apply_3d" +#define FUNCTION mfem_pa_curlcurl_apply_3d_stage_sliced +#define OP_SIZE (750 * MFEM_BENCH_NE) +#define X_SIZE (144 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, const double *, + const double *, const double *, const double *, + const double *, const double *, double *); +static void run(void) { + FUNCTION(a[0], a[2], a[1], a[3], a[4], a[5], op, x, y); +} +#elif defined(BENCH_DIVDIV_2D) +#define BENCH_NAME "divdiv_apply_2d" +#define FUNCTION mfem_pa_divdiv_apply_2d_stage_sliced +#define OP_SIZE (25 * MFEM_BENCH_NE) +#define X_SIZE (24 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, const double *, + const double *, const double *, const double *, double *); +static void run(void) { FUNCTION(a[0], a[1], a[2], a[3], op, x, y); } +#elif defined(BENCH_DIVDIV_3D) +#define BENCH_NAME "divdiv_apply_3d" +#define FUNCTION mfem_pa_divdiv_apply_3d_stage_sliced +#define OP_SIZE (125 * MFEM_BENCH_NE) +#define X_SIZE (108 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, const double *, + const double *, const double *, const double *, double *); +static void run(void) { FUNCTION(a[0], a[1], a[2], a[3], op, x, y); } +#elif defined(BENCH_INTERP_VALUE_2D) +#define BENCH_NAME "interp_value_2d" +#define FUNCTION mfem_interp_value_2d_scratch_sliced +#define INPUT_SIZE (16 * MFEM_BENCH_NE) +#define OUTPUT_SIZE (25 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, double *); +static void run(void) { FUNCTION(x, a[0], y); } +#elif defined(BENCH_INTERP_VALUE_3D) +#define BENCH_NAME "interp_value_3d" +#define FUNCTION mfem_interp_value_3d_scratch_sliced +#define INPUT_SIZE (64 * MFEM_BENCH_NE) +#define OUTPUT_SIZE (125 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, double *); +static void run(void) { FUNCTION(x, a[0], y); } +#elif defined(BENCH_INTEGRATE_VALUE_2D) +#define BENCH_NAME "integrate_value_2d" +#define FUNCTION mfem_integrate_value_2d_scratch_sliced +#define INPUT_SIZE (25 * MFEM_BENCH_NE) +#define OUTPUT_SIZE (16 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, double *); +static void run(void) { FUNCTION(x, a[0], y); } +#elif defined(BENCH_INTEGRATE_VALUE_3D) +#define BENCH_NAME "integrate_value_3d" +#define FUNCTION mfem_integrate_value_3d_scratch_sliced +#define INPUT_SIZE (125 * MFEM_BENCH_NE) +#define OUTPUT_SIZE (64 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, double *); +static void run(void) { FUNCTION(x, a[0], y); } +#elif defined(BENCH_INTERP_GRAD_2D) +#define BENCH_NAME "interp_grad_2d" +#define FUNCTION mfem_interp_grad_2d_stage_sliced +#define INPUT_SIZE (16 * MFEM_BENCH_NE) +#define OUTPUT_SIZE (50 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, const double *, double *); +static void run(void) { FUNCTION(x, a[0], a[1], y); } +#elif defined(BENCH_INTERP_GRAD_3D) +#define BENCH_NAME "interp_grad_3d" +#define FUNCTION mfem_interp_grad_3d_stage_sliced +#define INPUT_SIZE (64 * MFEM_BENCH_NE) +#define OUTPUT_SIZE (375 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, const double *, double *); +static void run(void) { FUNCTION(x, a[0], a[1], y); } +#elif defined(BENCH_INTEGRATE_GRAD_2D) +#define BENCH_NAME "integrate_grad_2d" +#define FUNCTION mfem_integrate_grad_2d_stage_sliced +#define INPUT_SIZE (50 * MFEM_BENCH_NE) +#define OUTPUT_SIZE (16 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, const double *, double *); +static void run(void) { FUNCTION(x, a[0], a[1], y); } +#elif defined(BENCH_INTEGRATE_GRAD_3D) +#define BENCH_NAME "integrate_grad_3d" +#define FUNCTION mfem_integrate_grad_3d_stage_sliced +#define INPUT_SIZE (375 * MFEM_BENCH_NE) +#define OUTPUT_SIZE (64 * MFEM_BENCH_NE) +extern void FUNCTION(const double *, const double *, const double *, double *); +static void run(void) { FUNCTION(x, a[0], a[1], y); } +#else +#error "Select one BENCH_* operator" +#endif + +#ifndef INPUT_SIZE +#define INPUT_SIZE X_SIZE +#endif +#ifndef OUTPUT_SIZE +#define OUTPUT_SIZE X_SIZE +#endif +#ifndef OP_SIZE +#define OP_SIZE 0 +#endif + +int main(void) { + for (int j = 0; j < 6; ++j) + for (int i = 0; i < 20; ++i) a[j][i] = value(0, j); +#if defined(BENCH_CURLCURL_2D) || defined(BENCH_CURLCURL_3D) + transpose(a[1], a[0], 5, 3); + transpose(a[3], a[2], 5, 4); + transpose(a[5], a[4], 5, 4); +#elif defined(BENCH_DIVDIV_2D) || defined(BENCH_DIVDIV_3D) + transpose(a[1], a[0], 5, 3); + transpose(a[3], a[2], 5, 4); +#elif defined(BENCH_MASS_2D) || defined(BENCH_MASS_3D) + transpose(a[1], a[0], 5, 4); +#else + transpose(a[2], a[0], 5, 4); + transpose(a[3], a[1], 5, 4); +#endif + for (int i = 0; i < OP_SIZE; ++i) op[i] = value(i, 6); + for (int i = 0; i < INPUT_SIZE; ++i) x[i] = value(i, 7); + + memset(y, 0, OUTPUT_SIZE * sizeof(double)); + run(); + double checksum = 0.0, max_abs = 0.0; + for (int i = 0; i < OUTPUT_SIZE; ++i) { + checksum += y[i]; + max_abs = fmax(max_abs, fabs(y[i])); + } + + memset(y, 0, OUTPUT_SIZE * sizeof(double)); + run(); + memset(y, 0, OUTPUT_SIZE * sizeof(double)); + const double start = seconds(); + for (int i = 0; i < BENCH_ITERS; ++i) run(); + const double runtime_us = (seconds() - start) * 1.0e6 / BENCH_ITERS; + printf("implementation=polygeist_raised kernel=%s ne=%d iterations=%d " + "runtime_us=%.6f checksum=%.17g max_abs=%.17g\n", + BENCH_NAME, MFEM_BENCH_NE, BENCH_ITERS, runtime_us, checksum, max_abs); + return isfinite(checksum) ? 0 : 1; +} diff --git a/issues/mfem_c_kernels/manifest.csv b/issues/mfem_c_kernels/manifest.csv new file mode 100644 index 000000000000..df9638987293 --- /dev/null +++ b/issues/mfem_c_kernels/manifest.csv @@ -0,0 +1,41 @@ +id,family,dimension,operation,variant,source,function,upstream_file,upstream_symbol +interp_value_2d,sum_factorization,2,interpolate_value,original,original/sum_factorization.c,mfem_interp_value_2d,fem/dfem/interpolate.hpp,map_field_to_quadrature_data_tensor_product_2d +interp_grad_2d,sum_factorization,2,interpolate_gradient,original,original/sum_factorization.c,mfem_interp_grad_2d,fem/dfem/interpolate.hpp,map_field_to_quadrature_data_tensor_product_2d +interp_value_3d,sum_factorization,3,interpolate_value,original,original/sum_factorization.c,mfem_interp_value_3d,fem/dfem/interpolate.hpp,map_field_to_quadrature_data_tensor_product_3d +interp_grad_3d,sum_factorization,3,interpolate_gradient,original,original/sum_factorization.c,mfem_interp_grad_3d,fem/dfem/interpolate.hpp,map_field_to_quadrature_data_tensor_product_3d +integrate_value_2d,sum_factorization,2,integrate_value,original,original/sum_factorization.c,mfem_integrate_value_2d,fem/dfem/integrate.hpp,map_quadrature_data_to_fields_tensor_impl_2d +integrate_grad_2d,sum_factorization,2,integrate_gradient,original,original/sum_factorization.c,mfem_integrate_grad_2d,fem/dfem/integrate.hpp,map_quadrature_data_to_fields_tensor_impl_2d +integrate_value_3d,sum_factorization,3,integrate_value,original,original/sum_factorization.c,mfem_integrate_value_3d,fem/dfem/integrate.hpp,map_quadrature_data_to_fields_tensor_impl_3d +integrate_grad_3d,sum_factorization,3,integrate_gradient,original,original/sum_factorization.c,mfem_integrate_grad_3d,fem/dfem/integrate.hpp,map_quadrature_data_to_fields_tensor_impl_3d +mass_apply_2d,partial_assembly,2,mass_apply,original,original/mass_apply.c,mfem_pa_mass_apply_2d,fem/integ/bilininteg_mass_kernels.hpp,PAMassApply2D_Element +mass_apply_3d,partial_assembly,3,mass_apply,original,original/mass_apply.c,mfem_pa_mass_apply_3d,fem/integ/bilininteg_mass_kernels.hpp,PAMassApply3D_Element +diffusion_apply_2d,partial_assembly,2,diffusion_apply_symmetric,original,original/diffusion_apply.c,mfem_pa_diffusion_apply_2d,fem/integ/bilininteg_diffusion_kernels.hpp,PADiffusionApply2D +diffusion_apply_3d,partial_assembly,3,diffusion_apply_symmetric,original,original/diffusion_apply.c,mfem_pa_diffusion_apply_3d,fem/integ/bilininteg_diffusion_kernels.hpp,PADiffusionApply3D +convection_apply_2d,partial_assembly,2,convection_apply,original,original/convection_apply.c,mfem_pa_convection_apply_2d,fem/integ/bilininteg_convection_kernels.hpp,PAConvectionApply2D +convection_apply_3d,partial_assembly,3,convection_apply,original,original/convection_apply.c,mfem_pa_convection_apply_3d,fem/integ/bilininteg_convection_kernels.hpp,PAConvectionApply3D +elasticity_qpoint_2d,quadrature_function,2,isotropic_linear_elasticity,original,original/elasticity_qpoint.c,mfem_elasticity_qpoint_2d,fem/integ/bilininteg_elasticity_kernels.hpp,ElasticityAddMultPA_<2> +elasticity_qpoint_3d,quadrature_function,3,isotropic_linear_elasticity,original,original/elasticity_qpoint.c,mfem_elasticity_qpoint_3d,fem/integ/bilininteg_elasticity_kernels.hpp,ElasticityAddMultPA_<3> +curlcurl_apply_2d,de_rham,2,curl_curl_apply,original,original/de_rham_apply.c,mfem_pa_curlcurl_apply_2d,fem/integ/bilininteg_hcurl_kernels.cpp,PACurlCurlApply2D +divdiv_apply_2d,de_rham,2,div_div_apply,original,original/de_rham_apply.c,mfem_pa_divdiv_apply_2d,fem/integ/bilininteg_hdiv_kernels.cpp,PADivDivApply2D +divdiv_apply_3d,de_rham,3,div_div_apply,original,original/de_rham_apply.c,mfem_pa_divdiv_apply_3d,fem/integ/bilininteg_hdiv_kernels.cpp,PADivDivApply3D +curlcurl_apply_3d,de_rham,3,curl_curl_apply_symmetric,original,original/hcurl3_apply.c,mfem_pa_curlcurl_apply_3d,fem/integ/bilininteg_hcurl_kernels.hpp,PACurlCurlApply3D +interp_value_2d_scratch_sliced,sum_factorization,2,interpolate_value,normalized,normalized/value_scratch_sliced.c,mfem_interp_value_2d_scratch_sliced,fem/dfem/interpolate.hpp,map_field_to_quadrature_data_tensor_product_2d +interp_value_3d_scratch_sliced,sum_factorization,3,interpolate_value,normalized,normalized/value_scratch_sliced.c,mfem_interp_value_3d_scratch_sliced,fem/dfem/interpolate.hpp,map_field_to_quadrature_data_tensor_product_3d +integrate_value_2d_scratch_sliced,sum_factorization,2,integrate_value,normalized,normalized/value_scratch_sliced.c,mfem_integrate_value_2d_scratch_sliced,fem/dfem/integrate.hpp,map_quadrature_data_to_fields_tensor_impl_2d +integrate_value_3d_scratch_sliced,sum_factorization,3,integrate_value,normalized,normalized/value_scratch_sliced.c,mfem_integrate_value_3d_scratch_sliced,fem/dfem/integrate.hpp,map_quadrature_data_to_fields_tensor_impl_3d +mass_apply_2d_stage_sliced,partial_assembly,2,mass_apply,normalized,normalized/mass_stage_sliced.c,mfem_pa_mass_apply_2d_stage_sliced,fem/integ/bilininteg_mass_kernels.hpp,PAMassApply2D_Element +mass_apply_3d_stage_sliced,partial_assembly,3,mass_apply,normalized,normalized/mass_stage_sliced.c,mfem_pa_mass_apply_3d_stage_sliced,fem/integ/bilininteg_mass_kernels.hpp,PAMassApply3D_Element +interp_grad_2d_stage_sliced,sum_factorization,2,interpolate_gradient,normalized,normalized/gradient_stage_sliced.c,mfem_interp_grad_2d_stage_sliced,fem/dfem/interpolate.hpp,map_field_to_quadrature_data_tensor_product_2d +interp_grad_3d_stage_sliced,sum_factorization,3,interpolate_gradient,normalized,normalized/gradient_stage_sliced.c,mfem_interp_grad_3d_stage_sliced,fem/dfem/interpolate.hpp,map_field_to_quadrature_data_tensor_product_3d +integrate_grad_2d_stage_sliced,sum_factorization,2,integrate_gradient,normalized,normalized/gradient_stage_sliced.c,mfem_integrate_grad_2d_stage_sliced,fem/dfem/integrate.hpp,map_quadrature_data_to_fields_tensor_impl_2d +integrate_grad_3d_stage_sliced,sum_factorization,3,integrate_gradient,normalized,normalized/gradient_stage_sliced.c,mfem_integrate_grad_3d_stage_sliced,fem/dfem/integrate.hpp,map_quadrature_data_to_fields_tensor_impl_3d +diffusion_apply_2d_stage_sliced,partial_assembly,2,diffusion_apply_symmetric,normalized,normalized/diffusion_stage_sliced.c,mfem_pa_diffusion_apply_2d_stage_sliced,fem/integ/bilininteg_diffusion_kernels.hpp,PADiffusionApply2D +diffusion_apply_3d_stage_sliced,partial_assembly,3,diffusion_apply_symmetric,normalized,normalized/diffusion_stage_sliced.c,mfem_pa_diffusion_apply_3d_stage_sliced,fem/integ/bilininteg_diffusion_kernels.hpp,PADiffusionApply3D +convection_apply_2d_stage_sliced,partial_assembly,2,convection_apply,normalized,normalized/convection_stage_sliced.c,mfem_pa_convection_apply_2d_stage_sliced,fem/integ/bilininteg_convection_kernels.hpp,PAConvectionApply2D +convection_apply_3d_stage_sliced,partial_assembly,3,convection_apply,normalized,normalized/convection_stage_sliced.c,mfem_pa_convection_apply_3d_stage_sliced,fem/integ/bilininteg_convection_kernels.hpp,PAConvectionApply3D +elasticity_qpoint_2d_scalarized,quadrature_function,2,isotropic_linear_elasticity,normalized,normalized/elasticity_scalarized.c,mfem_elasticity_qpoint_2d_scalarized,fem/integ/bilininteg_elasticity_kernels.hpp,ElasticityAddMultPA_<2> +elasticity_qpoint_3d_scalarized,quadrature_function,3,isotropic_linear_elasticity,normalized,normalized/elasticity_scalarized.c,mfem_elasticity_qpoint_3d_scalarized,fem/integ/bilininteg_elasticity_kernels.hpp,ElasticityAddMultPA_<3> +curlcurl_apply_2d_stage_sliced,de_rham,2,curl_curl_apply,normalized,normalized/de_rham2_stage_sliced.c,mfem_pa_curlcurl_apply_2d_stage_sliced,fem/integ/bilininteg_hcurl_kernels.cpp,PACurlCurlApply2D +divdiv_apply_2d_stage_sliced,de_rham,2,div_div_apply,normalized,normalized/de_rham2_stage_sliced.c,mfem_pa_divdiv_apply_2d_stage_sliced,fem/integ/bilininteg_hdiv_kernels.cpp,PADivDivApply2D +divdiv_apply_3d_stage_sliced,de_rham,3,div_div_apply,normalized,normalized/divdiv3_stage_sliced.c,mfem_pa_divdiv_apply_3d_stage_sliced,fem/integ/bilininteg_hdiv_kernels.cpp,PADivDivApply3D +curlcurl_apply_3d_stage_sliced,de_rham,3,curl_curl_apply_symmetric,normalized,normalized/curlcurl3_stage_sliced.c,mfem_pa_curlcurl_apply_3d_stage_sliced,fem/integ/bilininteg_hcurl_kernels.hpp,PACurlCurlApply3D diff --git a/issues/mfem_c_kernels/match_results/SUMMARY.md b/issues/mfem_c_kernels/match_results/SUMMARY.md new file mode 100644 index 000000000000..3c1818319d8f --- /dev/null +++ b/issues/mfem_c_kernels/match_results/SUMMARY.md @@ -0,0 +1,44 @@ +# MFEM normalized-kernel library matching + +- kernels: 20 +- matcher successes: 20 +- kernels with at least one match: 18 +- matched stage groups: 134 +- emitted kernel.launch operations: 134 + +Matches are stage-level unless a report explicitly names a whole composition. + + +## FP64 contraction lowering + +- 128 matches are ABI-legal two-input FP64 contractions: + - 64 rank `4 x 5 -> 4` + - 4 rank `5 x 4 -> 4` + - 20 rank `5 x 5 -> 4` +- 40 iterator/rank-generic launches, comprising all 36 2D contraction stages + plus 4 3D stages whose physical output views compact a broadcast mode +- All 128 lower to `polygeist_cutensornet_contraction2_f64`, with the original + affine indexing maps and physical `polygeist.submap` strides encoded as + extent/stride/mode metadata. +- A reduction dimension may occur in the logical output map only when its + physical `polygeist.submap` stride is proven zero; ABI lowering then omits + that broadcast mode from the output descriptor. +- The remaining 6 emitted launches are older structural matches (5 + `cublasDaxpby`, 1 `cudnnAddTensor_batched`) and are not included in the + cuTensorNet lowering count. + +Host compilation, focused pass tests, and the CPU reference contraction test +pass. + +## Silicon validation + +On 2026-07-24, all three compiler-generated FP64 variants ran through +cuTensorNet on an aarch64 Tegra target: + +- `r4 x r5 -> r4`: `max_error=0` +- `r5 x r4 -> r4`: `max_error=0` +- `r5 x r5 -> r4` with compacted broadcast modes: `max_error=0` + +The first call paid cuTensorNet/CUDA initialization and planning cost. The +subsequent two small contractions took about `0.085-0.088 ms` of device time. +See `../silicon_results/2026-07-24_cutensornet_variants.log`. diff --git a/issues/mfem_c_kernels/match_results/convection_apply_2d_stage_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/convection_apply_2d_stage_sliced/debufferized.mlir new file mode 100644 index 000000000000..f668cd204d30 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/convection_apply_2d_stage_sliced/debufferized.mlir @@ -0,0 +1,116 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 50 + d1 * 5)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 50 + d1 * 5 + 25)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map12 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_convection_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = bufferization.to_tensor %arg0 : memref + %6 = tensor.empty() : tensor<2x4x4xf64> + %7 = tensor.empty() : tensor<2x5x4xf64> + %8 = tensor.empty() : tensor<2x5x5xf64> + %9 = tensor.empty() : tensor<2x5x5xf64> + %10 = tensor.empty() : tensor<2x4x5xf64> + %11 = tensor.empty() : tensor<2x4x5xf64> + %12 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5xf64> + %13 = polygeist.submap(%5, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %14 = polygeist.submap(%1, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%14, %13 : tensor, tensor) outs(%12 : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %38 = arith.mulf %in, %in_0 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } -> tensor<2x4x5xf64> + %16 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5xf64> + %17 = polygeist.submap(%4, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %18 = polygeist.submap(%1, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%18, %17 : tensor, tensor) outs(%16 : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %38 = arith.mulf %in, %in_0 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } -> tensor<2x4x5xf64> + %20 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5xf64> + %21 = polygeist.submap(%5, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%19, %21 : tensor<2x4x5xf64>, tensor) outs(%20 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %38 = arith.mulf %in, %in_0 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } -> tensor<2x5x5xf64> + %23 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5xf64> + %24 = polygeist.submap(%4, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%15, %24 : tensor<2x4x5xf64>, tensor) outs(%23 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %38 = arith.mulf %in, %in_0 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } -> tensor<2x5x5xf64> + %26 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%7 : tensor<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4xf64> + %27 = polygeist.submap(%3, %c2, %c5, %c4, %c5) {map = #map7} : (tensor, index, index, index, index) -> tensor + %28 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map8} : (tensor, index, index, index, index) -> tensor + %29 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index) -> tensor + %30 = linalg.generic {doc = "", indexing_maps = [#map3, #map10, #map3, #map10, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%28, %22, %29, %25, %27 : tensor, tensor<2x5x5xf64>, tensor, tensor<2x5x5xf64>, tensor) outs(%26 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %38 = arith.mulf %in, %in_0 : f64 + %39 = arith.mulf %in_1, %in_2 : f64 + %40 = arith.addf %38, %39 : f64 + %41 = arith.mulf %40, %in_3 : f64 + %42 = arith.addf %out, %41 : f64 + linalg.yield %42 : f64 + } -> tensor<2x5x4xf64> + %31 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%6 : tensor<2x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4xf64> + %32 = polygeist.submap(%3, %c2, %c4, %c4, %c5) {map = #map11} : (tensor, index, index, index, index) -> tensor + %33 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%30, %32 : tensor<2x5x4xf64>, tensor) outs(%31 : tensor<2x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %38 = arith.mulf %in, %in_0 : f64 + %39 = arith.addf %out, %38 : f64 + linalg.yield %39 : f64 + } -> tensor<2x4x4xf64> + %34 = polygeist.submap(%0, %c2, %c4, %c4) {map = #map12} : (tensor, index, index, index) -> tensor + %35 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%33 : tensor<2x4x4xf64>) outs(%34 : tensor) { + ^bb0(%in: f64, %out: f64): + %38 = arith.addf %out, %in : f64 + linalg.yield %38 : f64 + } -> tensor + %36 = polygeist.submapInverse(%0, %35, %c2, %c4, %c4) {map = #map12} : (tensor, tensor, index, index, index) -> tensor + %37 = bufferization.to_memref %36 : memref + memref.copy %37, %arg5 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/convection_apply_2d_stage_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/convection_apply_2d_stage_sliced/match_report.txt new file mode 100644 index 000000000000..743a82cc9c42 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/convection_apply_2d_stage_sliced/match_report.txt @@ -0,0 +1,10 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/convection_apply_2d_stage_sliced/debufferized.mlir == + match body#[0, 1] cutensornetContraction2_f64 + match body#[2, 3] cutensornetContraction2_f64 + match body#[4, 5] cutensornetContraction2_f64 + match body#[6, 7] cutensornetContraction2_f64 + no_match body#8 ? + no_match body#9 ? + match body#[10, 11] cutensornetContraction2_f64 + match body#[12] cublasDaxpby + total: 6 matched / 8 bodies diff --git a/issues/mfem_c_kernels/match_results/convection_apply_2d_stage_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/convection_apply_2d_stage_sliced/matched.mlir new file mode 100644 index 000000000000..00f12c832ae6 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/convection_apply_2d_stage_sliced/matched.mlir @@ -0,0 +1,109 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 50 + d1 * 5)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 50 + d1 * 5 + 25)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map12 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_convection_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = bufferization.to_tensor %arg0 : memref + %6 = tensor.empty() : tensor<2x4x4xf64> + %7 = tensor.empty() : tensor<2x5x4xf64> + %8 = tensor.empty() : tensor<2x5x5xf64> + %9 = tensor.empty() : tensor<2x5x5xf64> + %10 = tensor.empty() : tensor<2x4x5xf64> + %11 = tensor.empty() : tensor<2x4x5xf64> + %13 = polygeist.submap(%5, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %14 = polygeist.submap(%1, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v14_contract_15_tc0 = tensor.cast %14 : tensor to tensor<*xf64> + + %v13_contract_15_tc1 = tensor.cast %13 : tensor to tensor<*xf64> + + %v11_contract_15_tc2 = tensor.cast %11 : tensor<2x4x5xf64> to tensor<*xf64> + + %v15_tdyn = kernel.launch @cutensornetContraction2_f64(%v14_contract_15_tc0, %v13_contract_15_tc1, %v11_contract_15_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %15 = tensor.cast %v15_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %17 = polygeist.submap(%4, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %18 = polygeist.submap(%1, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v18_contract_19_tc0 = tensor.cast %18 : tensor to tensor<*xf64> + + %v17_contract_19_tc1 = tensor.cast %17 : tensor to tensor<*xf64> + + %v10_contract_19_tc2 = tensor.cast %10 : tensor<2x4x5xf64> to tensor<*xf64> + + %v19_tdyn = kernel.launch @cutensornetContraction2_f64(%v18_contract_19_tc0, %v17_contract_19_tc1, %v10_contract_19_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %19 = tensor.cast %v19_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %21 = polygeist.submap(%5, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %v19_contract_22_tc0 = tensor.cast %19 : tensor<2x4x5xf64> to tensor<*xf64> + + %v21_contract_22_tc1 = tensor.cast %21 : tensor to tensor<*xf64> + + %v9_contract_22_tc2 = tensor.cast %9 : tensor<2x5x5xf64> to tensor<*xf64> + + %v22_tdyn = kernel.launch @cutensornetContraction2_f64(%v19_contract_22_tc0, %v21_contract_22_tc1, %v9_contract_22_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %22 = tensor.cast %v22_tdyn : tensor<*xf64> to tensor<2x5x5xf64> + %24 = polygeist.submap(%4, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %v15_contract_25_tc0 = tensor.cast %15 : tensor<2x4x5xf64> to tensor<*xf64> + + %v24_contract_25_tc1 = tensor.cast %24 : tensor to tensor<*xf64> + + %v8_contract_25_tc2 = tensor.cast %8 : tensor<2x5x5xf64> to tensor<*xf64> + + %v25_tdyn = kernel.launch @cutensornetContraction2_f64(%v15_contract_25_tc0, %v24_contract_25_tc1, %v8_contract_25_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %25 = tensor.cast %v25_tdyn : tensor<*xf64> to tensor<2x5x5xf64> + %26 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%7 : tensor<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4xf64> + %27 = polygeist.submap(%3, %c2, %c5, %c4, %c5) {map = #map7} : (tensor, index, index, index, index) -> tensor + %28 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map8} : (tensor, index, index, index, index) -> tensor + %29 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index) -> tensor + %30 = linalg.generic {doc = "", indexing_maps = [#map3, #map10, #map3, #map10, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%28, %22, %29, %25, %27 : tensor, tensor<2x5x5xf64>, tensor, tensor<2x5x5xf64>, tensor) outs(%26 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %38 = arith.mulf %in, %in_0 : f64 + %39 = arith.mulf %in_1, %in_2 : f64 + %40 = arith.addf %38, %39 : f64 + %41 = arith.mulf %40, %in_3 : f64 + %42 = arith.addf %out, %41 : f64 + linalg.yield %42 : f64 + } -> tensor<2x5x4xf64> + %32 = polygeist.submap(%3, %c2, %c4, %c4, %c5) {map = #map11} : (tensor, index, index, index, index) -> tensor + %v30_contract_33_tc0 = tensor.cast %30 : tensor<2x5x4xf64> to tensor<*xf64> + + %v32_contract_33_tc1 = tensor.cast %32 : tensor to tensor<*xf64> + + %v6_contract_33_tc2 = tensor.cast %6 : tensor<2x4x4xf64> to tensor<*xf64> + + %v33_tdyn = kernel.launch @cutensornetContraction2_f64(%v30_contract_33_tc0, %v32_contract_33_tc1, %v6_contract_33_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %33 = tensor.cast %v33_tdyn : tensor<*xf64> to tensor<2x4x4xf64> + %34 = polygeist.submap(%0, %c2, %c4, %c4) {map = #map12} : (tensor, index, index, index) -> tensor + %v33_tc0 = tensor.cast %33 : tensor<2x4x4xf64> to tensor + + %35 = kernel.launch @cublasDaxpby(%v33_tc0, %34) : (tensor, tensor) -> tensor + %36 = polygeist.submapInverse(%0, %35, %c2, %c4, %c4) {map = #map12} : (tensor, tensor, index, index, index) -> tensor + %37 = bufferization.to_memref %36 : memref + memref.copy %37, %arg5 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/convection_apply_3d_stage_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/convection_apply_3d_stage_sliced/debufferized.mlir new file mode 100644 index 000000000000..3584ad71004d --- /dev/null +++ b/issues/mfem_c_kernels/match_results/convection_apply_3d_stage_sliced/debufferized.mlir @@ -0,0 +1,183 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 375 + d1 * 25 + d2 * 5)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 375 + d1 * 25 + d2 * 5 + 125)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 375 + d1 * 25 + d2 * 5 + 250)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map16 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_convection_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = bufferization.to_tensor %arg0 : memref + %6 = tensor.empty() : tensor<2x4x4x4xf64> + %7 = tensor.empty() : tensor<2x5x4x4xf64> + %8 = tensor.empty() : tensor<2x5x5x4xf64> + %9 = tensor.empty() : tensor<2x5x5x5xf64> + %10 = tensor.empty() : tensor<2x5x5x5xf64> + %11 = tensor.empty() : tensor<2x5x5x5xf64> + %12 = tensor.empty() : tensor<2x4x5x5xf64> + %13 = tensor.empty() : tensor<2x4x5x5xf64> + %14 = tensor.empty() : tensor<2x4x5x5xf64> + %15 = tensor.empty() : tensor<2x4x4x5xf64> + %16 = tensor.empty() : tensor<2x4x4x5xf64> + %17 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%16 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %18 = polygeist.submap(%5, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %19 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %20 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%19, %18 : tensor, tensor) outs(%17 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %59 = arith.mulf %in, %in_0 : f64 + %60 = arith.addf %out, %59 : f64 + linalg.yield %60 : f64 + } -> tensor<2x4x4x5xf64> + %21 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%15 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %22 = polygeist.submap(%4, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %23 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %24 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%23, %22 : tensor, tensor) outs(%21 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %59 = arith.mulf %in, %in_0 : f64 + %60 = arith.addf %out, %59 : f64 + linalg.yield %60 : f64 + } -> tensor<2x4x4x5xf64> + %25 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%14 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %26 = polygeist.submap(%5, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %27 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%24, %26 : tensor<2x4x4x5xf64>, tensor) outs(%25 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %59 = arith.mulf %in, %in_0 : f64 + %60 = arith.addf %out, %59 : f64 + linalg.yield %60 : f64 + } -> tensor<2x4x5x5xf64> + %28 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%13 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %29 = polygeist.submap(%4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %30 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%20, %29 : tensor<2x4x4x5xf64>, tensor) outs(%28 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %59 = arith.mulf %in, %in_0 : f64 + %60 = arith.addf %out, %59 : f64 + linalg.yield %60 : f64 + } -> tensor<2x4x5x5xf64> + %31 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %32 = polygeist.submap(%5, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %33 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%20, %32 : tensor<2x4x4x5xf64>, tensor) outs(%31 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %59 = arith.mulf %in, %in_0 : f64 + %60 = arith.addf %out, %59 : f64 + linalg.yield %60 : f64 + } -> tensor<2x4x5x5xf64> + %34 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %35 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %36 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%27, %35 : tensor<2x4x5x5xf64>, tensor) outs(%34 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %59 = arith.mulf %in, %in_0 : f64 + %60 = arith.addf %out, %59 : f64 + linalg.yield %60 : f64 + } -> tensor<2x5x5x5xf64> + %37 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %38 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %39 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%30, %38 : tensor<2x4x5x5xf64>, tensor) outs(%37 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %59 = arith.mulf %in, %in_0 : f64 + %60 = arith.addf %out, %59 : f64 + linalg.yield %60 : f64 + } -> tensor<2x5x5x5xf64> + %40 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %41 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %42 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%33, %41 : tensor<2x4x5x5xf64>, tensor) outs(%40 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %59 = arith.mulf %in, %in_0 : f64 + %60 = arith.addf %out, %59 : f64 + linalg.yield %60 : f64 + } -> tensor<2x5x5x5xf64> + %43 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %44 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %45 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %46 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %47 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %48 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%45, %36, %46, %39, %47, %42, %44 : tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor) outs(%43 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %out: f64): + %59 = arith.mulf %in, %in_0 : f64 + %60 = arith.mulf %in_1, %in_2 : f64 + %61 = arith.addf %59, %60 : f64 + %62 = arith.mulf %in_3, %in_4 : f64 + %63 = arith.addf %61, %62 : f64 + %64 = arith.mulf %63, %in_5 : f64 + %65 = arith.addf %out, %64 : f64 + linalg.yield %65 : f64 + } -> tensor<2x5x5x4xf64> + %49 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%7 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %50 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %51 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%48, %50 : tensor<2x5x5x4xf64>, tensor) outs(%49 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %59 = arith.mulf %in, %in_0 : f64 + %60 = arith.addf %out, %59 : f64 + linalg.yield %60 : f64 + } -> tensor<2x5x4x4xf64> + %52 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%6 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %53 = polygeist.submap(%3, %c2, %c4, %c4, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %54 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%51, %53 : tensor<2x5x4x4xf64>, tensor) outs(%52 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %59 = arith.mulf %in, %in_0 : f64 + %60 = arith.addf %out, %59 : f64 + linalg.yield %60 : f64 + } -> tensor<2x4x4x4xf64> + %55 = polygeist.submap(%0, %c2, %c4, %c4, %c4) {map = #map16} : (tensor, index, index, index, index) -> tensor + %56 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%54 : tensor<2x4x4x4xf64>) outs(%55 : tensor) { + ^bb0(%in: f64, %out: f64): + %59 = arith.addf %out, %in : f64 + linalg.yield %59 : f64 + } -> tensor + %57 = polygeist.submapInverse(%0, %56, %c2, %c4, %c4, %c4) {map = #map16} : (tensor, tensor, index, index, index, index) -> tensor + %58 = bufferization.to_memref %57 : memref + memref.copy %58, %arg5 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/convection_apply_3d_stage_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/convection_apply_3d_stage_sliced/match_report.txt new file mode 100644 index 000000000000..79e04ee17b31 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/convection_apply_3d_stage_sliced/match_report.txt @@ -0,0 +1,15 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/convection_apply_3d_stage_sliced/debufferized.mlir == + match body#[0, 1] cublasGemmFor1x1Conv + match body#[2, 3] cublasGemmFor1x1Conv + match body#[4, 5] cublasGemmFor1x1Conv + match body#[6, 7] cublasGemmFor1x1Conv + match body#[8, 9] cublasGemmFor1x1Conv + match body#[10, 11] cublasGemmFor1x1Conv + match body#[12, 13] cublasGemmFor1x1Conv + match body#[14, 15] cublasGemmFor1x1Conv + no_match body#16 ? + no_match body#17 ? + match body#[18, 19] cublasGemmFor1x1Conv + match body#[20, 21] cublasGemmFor1x1Conv + match body#[22] cudnnAddTensor_batched + total: 11 matched / 13 bodies diff --git a/issues/mfem_c_kernels/match_results/convection_apply_3d_stage_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/convection_apply_3d_stage_sliced/matched.mlir new file mode 100644 index 000000000000..d0a71514af45 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/convection_apply_3d_stage_sliced/matched.mlir @@ -0,0 +1,147 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 375 + d1 * 25 + d2 * 5)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 375 + d1 * 25 + d2 * 5 + 125)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 375 + d1 * 25 + d2 * 5 + 250)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map16 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_convection_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = bufferization.to_tensor %arg0 : memref + %6 = tensor.empty() : tensor<2x4x4x4xf64> + %7 = tensor.empty() : tensor<2x5x4x4xf64> + %8 = tensor.empty() : tensor<2x5x5x4xf64> + %9 = tensor.empty() : tensor<2x5x5x5xf64> + %10 = tensor.empty() : tensor<2x5x5x5xf64> + %11 = tensor.empty() : tensor<2x5x5x5xf64> + %12 = tensor.empty() : tensor<2x4x5x5xf64> + %13 = tensor.empty() : tensor<2x4x5x5xf64> + %14 = tensor.empty() : tensor<2x4x5x5xf64> + %15 = tensor.empty() : tensor<2x4x4x5xf64> + %16 = tensor.empty() : tensor<2x4x4x5xf64> + %18 = polygeist.submap(%5, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %19 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v16_contract_20_tc2 = tensor.cast %16 : tensor<2x4x4x5xf64> to tensor + + %v20_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%19, %18, %v16_contract_20_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %20 = tensor.cast %v20_tdyn : tensor to tensor<2x4x4x5xf64> + %22 = polygeist.submap(%4, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %23 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v15_contract_24_tc2 = tensor.cast %15 : tensor<2x4x4x5xf64> to tensor + + %v24_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%23, %22, %v15_contract_24_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %24 = tensor.cast %v24_tdyn : tensor to tensor<2x4x4x5xf64> + %26 = polygeist.submap(%5, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v24_contract_27_tc0 = tensor.cast %24 : tensor<2x4x4x5xf64> to tensor + + %v14_contract_27_tc2 = tensor.cast %14 : tensor<2x4x5x5xf64> to tensor + + %v27_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v24_contract_27_tc0, %26, %v14_contract_27_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %27 = tensor.cast %v27_tdyn : tensor to tensor<2x4x5x5xf64> + %29 = polygeist.submap(%4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v20_contract_30_tc0 = tensor.cast %20 : tensor<2x4x4x5xf64> to tensor + + %v13_contract_30_tc2 = tensor.cast %13 : tensor<2x4x5x5xf64> to tensor + + %v30_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v20_contract_30_tc0, %29, %v13_contract_30_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %30 = tensor.cast %v30_tdyn : tensor to tensor<2x4x5x5xf64> + %32 = polygeist.submap(%5, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v20_contract_33_tc0 = tensor.cast %20 : tensor<2x4x4x5xf64> to tensor + + %v12_contract_33_tc2 = tensor.cast %12 : tensor<2x4x5x5xf64> to tensor + + %v33_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v20_contract_33_tc0, %32, %v12_contract_33_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %33 = tensor.cast %v33_tdyn : tensor to tensor<2x4x5x5xf64> + %35 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v27_contract_36_tc0 = tensor.cast %27 : tensor<2x4x5x5xf64> to tensor + + %v11_contract_36_tc2 = tensor.cast %11 : tensor<2x5x5x5xf64> to tensor + + %v36_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v27_contract_36_tc0, %35, %v11_contract_36_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %36 = tensor.cast %v36_tdyn : tensor to tensor<2x5x5x5xf64> + %38 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v30_contract_39_tc0 = tensor.cast %30 : tensor<2x4x5x5xf64> to tensor + + %v10_contract_39_tc2 = tensor.cast %10 : tensor<2x5x5x5xf64> to tensor + + %v39_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v30_contract_39_tc0, %38, %v10_contract_39_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %39 = tensor.cast %v39_tdyn : tensor to tensor<2x5x5x5xf64> + %41 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v33_contract_42_tc0 = tensor.cast %33 : tensor<2x4x5x5xf64> to tensor + + %v9_contract_42_tc2 = tensor.cast %9 : tensor<2x5x5x5xf64> to tensor + + %v42_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v33_contract_42_tc0, %41, %v9_contract_42_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %42 = tensor.cast %v42_tdyn : tensor to tensor<2x5x5x5xf64> + %43 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %44 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %45 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %46 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %47 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %48 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%45, %36, %46, %39, %47, %42, %44 : tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor) outs(%43 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %out: f64): + %59 = arith.mulf %in, %in_0 : f64 + %60 = arith.mulf %in_1, %in_2 : f64 + %61 = arith.addf %59, %60 : f64 + %62 = arith.mulf %in_3, %in_4 : f64 + %63 = arith.addf %61, %62 : f64 + %64 = arith.mulf %63, %in_5 : f64 + %65 = arith.addf %out, %64 : f64 + linalg.yield %65 : f64 + } -> tensor<2x5x5x4xf64> + %50 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %v48_contract_51_tc0 = tensor.cast %48 : tensor<2x5x5x4xf64> to tensor + + %v7_contract_51_tc2 = tensor.cast %7 : tensor<2x5x4x4xf64> to tensor + + %v51_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v48_contract_51_tc0, %50, %v7_contract_51_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %51 = tensor.cast %v51_tdyn : tensor to tensor<2x5x4x4xf64> + %53 = polygeist.submap(%3, %c2, %c4, %c4, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %v51_contract_54_tc0 = tensor.cast %51 : tensor<2x5x4x4xf64> to tensor + + %v6_contract_54_tc2 = tensor.cast %6 : tensor<2x4x4x4xf64> to tensor + + %v54_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v51_contract_54_tc0, %53, %v6_contract_54_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %54 = tensor.cast %v54_tdyn : tensor to tensor<2x4x4x4xf64> + %55 = polygeist.submap(%0, %c2, %c4, %c4, %c4) {map = #map16} : (tensor, index, index, index, index) -> tensor + %v54_tc0 = tensor.cast %54 : tensor<2x4x4x4xf64> to tensor + + %56 = kernel.launch @cudnnAddTensor_batched(%v54_tc0, %55) : (tensor, tensor) -> tensor + %57 = polygeist.submapInverse(%0, %56, %c2, %c4, %c4, %c4) {map = #map16} : (tensor, tensor, index, index, index, index) -> tensor + %58 = bufferization.to_memref %57 : memref + memref.copy %58, %arg5 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/curlcurl_apply_2d_stage_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/curlcurl_apply_2d_stage_sliced/debufferized.mlir new file mode 100644 index 000000000000..803495b30248 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/curlcurl_apply_2d_stage_sliced/debufferized.mlir @@ -0,0 +1,153 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 3 + d0 * 24)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4 + d0 * 24 + 12)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 3)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 25 + d1 * 5)> +#map12 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map13 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map14 = affine_map<(d0, d1, d2) -> (d2 + d1 * 3 + d0 * 24)> +#map15 = affine_map<(d0, d1, d2) -> (d2 + d1 * 4 + d0 * 24 + 12)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_curlcurl_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x3x4xf64> + %8 = tensor.empty() : tensor<2x4x3xf64> + %9 = tensor.empty() : tensor<2x5x4xf64> + %10 = tensor.empty() : tensor<2x5x3xf64> + %11 = tensor.empty() : tensor<2x5x5xf64> + %12 = tensor.empty() : tensor<2x5x5xf64> + %13 = tensor.empty() : tensor<2x3x5xf64> + %14 = tensor.empty() : tensor<2x4x5xf64> + %15 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%14 : tensor<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5xf64> + %16 = polygeist.submap(%6, %c2, %c4, %c5, %c3) {map = #map1} : (tensor, index, index, index, index) -> tensor + %17 = polygeist.submap(%1, %c2, %c4, %c5, %c3) {map = #map2} : (tensor, index, index, index, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%17, %16 : tensor, tensor) outs(%15 : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %50 = arith.mulf %in, %in_0 : f64 + %51 = arith.addf %out, %50 : f64 + linalg.yield %51 : f64 + } -> tensor<2x4x5xf64> + %19 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5xf64> + %20 = polygeist.submap(%4, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %21 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%18, %20 : tensor<2x4x5xf64>, tensor) outs(%19 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %50 = arith.mulf %in, %in_0 : f64 + %51 = arith.addf %out, %50 : f64 + linalg.yield %51 : f64 + } -> tensor<2x5x5xf64> + %22 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%13 : tensor<2x3x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x3x5xf64> + %23 = polygeist.submap(%4, %c2, %c3, %c5, %c4) {map = #map7} : (tensor, index, index, index, index) -> tensor + %24 = polygeist.submap(%1, %c2, %c3, %c5, %c4) {map = #map8} : (tensor, index, index, index, index) -> tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%24, %23 : tensor, tensor) outs(%22 : tensor<2x3x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %50 = arith.mulf %in, %in_0 : f64 + %51 = arith.addf %out, %50 : f64 + linalg.yield %51 : f64 + } -> tensor<2x3x5xf64> + %26 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5xf64> + %27 = polygeist.submap(%6, %c2, %c5, %c5, %c3) {map = #map9} : (tensor, index, index, index, index) -> tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%25, %27 : tensor<2x3x5xf64>, tensor) outs(%26 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %50 = arith.mulf %in, %in_0 : f64 + %51 = arith.addf %out, %50 : f64 + linalg.yield %51 : f64 + } -> tensor<2x5x5xf64> + %29 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x5x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x3xf64> + %30 = polygeist.submap(%5, %c2, %c5, %c3, %c5) {map = #map10} : (tensor, index, index, index, index) -> tensor + %31 = polygeist.submap(%2, %c2, %c5, %c3, %c5) {map = #map11} : (tensor, index, index, index, index) -> tensor + %32 = linalg.generic {doc = "", indexing_maps = [#map3, #map12, #map12, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%31, %28, %21, %30 : tensor, tensor<2x5x5xf64>, tensor<2x5x5xf64>, tensor) outs(%29 : tensor<2x5x3xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %50 = arith.subf %in_0, %in_1 : f64 + %51 = arith.mulf %in, %50 : f64 + %52 = arith.mulf %51, %in_2 : f64 + %53 = arith.addf %out, %52 : f64 + linalg.yield %53 : f64 + } -> tensor<2x5x3xf64> + %33 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor<2x4x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x3xf64> + %34 = polygeist.submap(%3, %c2, %c4, %c3, %c5) {map = #map13} : (tensor, index, index, index, index) -> tensor + %35 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%32, %34 : tensor<2x5x3xf64>, tensor) outs(%33 : tensor<2x4x3xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %50 = arith.mulf %in, %in_0 : f64 + %51 = arith.subf %out, %50 : f64 + linalg.yield %51 : f64 + } -> tensor<2x4x3xf64> + %36 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4xf64> + %37 = polygeist.submap(%3, %c2, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index) -> tensor + %38 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index) -> tensor + %39 = linalg.generic {doc = "", indexing_maps = [#map3, #map12, #map12, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%38, %28, %21, %37 : tensor, tensor<2x5x5xf64>, tensor<2x5x5xf64>, tensor) outs(%36 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %50 = arith.subf %in_0, %in_1 : f64 + %51 = arith.mulf %in, %50 : f64 + %52 = arith.mulf %51, %in_2 : f64 + %53 = arith.addf %out, %52 : f64 + linalg.yield %53 : f64 + } -> tensor<2x5x4xf64> + %40 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%7 : tensor<2x3x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x3x4xf64> + %41 = polygeist.submap(%5, %c2, %c3, %c4, %c5) {map = #map13} : (tensor, index, index, index, index) -> tensor + %42 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%39, %41 : tensor<2x5x4xf64>, tensor) outs(%40 : tensor<2x3x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %50 = arith.mulf %in, %in_0 : f64 + %51 = arith.addf %out, %50 : f64 + linalg.yield %51 : f64 + } -> tensor<2x3x4xf64> + %43 = polygeist.submap(%0, %c2, %c4, %c3) {map = #map14} : (tensor, index, index, index) -> tensor + %44 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%35 : tensor<2x4x3xf64>) outs(%43 : tensor) { + ^bb0(%in: f64, %out: f64): + %50 = arith.addf %out, %in : f64 + linalg.yield %50 : f64 + } -> tensor + %45 = polygeist.submapInverse(%0, %44, %c2, %c4, %c3) {map = #map14} : (tensor, tensor, index, index, index) -> tensor + %46 = polygeist.submap(%45, %c2, %c3, %c4) {map = #map15} : (tensor, index, index, index) -> tensor + %47 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%42 : tensor<2x3x4xf64>) outs(%46 : tensor) { + ^bb0(%in: f64, %out: f64): + %50 = arith.addf %out, %in : f64 + linalg.yield %50 : f64 + } -> tensor + %48 = polygeist.submapInverse(%45, %47, %c2, %c3, %c4) {map = #map15} : (tensor, tensor, index, index, index) -> tensor + %49 = bufferization.to_memref %48 : memref + memref.copy %49, %arg6 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/curlcurl_apply_2d_stage_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/curlcurl_apply_2d_stage_sliced/match_report.txt new file mode 100644 index 000000000000..7eeeb7160d34 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/curlcurl_apply_2d_stage_sliced/match_report.txt @@ -0,0 +1,15 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/curlcurl_apply_2d_stage_sliced/debufferized.mlir == + match body#[0, 1] cutensornetContraction2_f64 + match body#[2, 3] cutensornetContraction2_f64 + match body#[4, 5] cutensornetContraction2_f64 + match body#[6, 7] cutensornetContraction2_f64 + no_match body#8 ? + no_match body#9 ? + no_match body#10 ? + no_match body#11 ? + no_match body#12 ? + no_match body#13 ? + match body#[14, 15] cutensornetContraction2_f64 + match body#[16] cublasDaxpby + match body#[17] cublasDaxpby + total: 7 matched / 13 bodies diff --git a/issues/mfem_c_kernels/match_results/curlcurl_apply_2d_stage_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/curlcurl_apply_2d_stage_sliced/matched.mlir new file mode 100644 index 000000000000..3948eb1dc69c --- /dev/null +++ b/issues/mfem_c_kernels/match_results/curlcurl_apply_2d_stage_sliced/matched.mlir @@ -0,0 +1,144 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 3)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 3 + d0 * 24)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4 + d0 * 24 + 12)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 3)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 25 + d1 * 5)> +#map12 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map13 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map14 = affine_map<(d0, d1, d2) -> (d2 + d1 * 3 + d0 * 24)> +#map15 = affine_map<(d0, d1, d2) -> (d2 + d1 * 4 + d0 * 24 + 12)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_curlcurl_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x3x4xf64> + %8 = tensor.empty() : tensor<2x4x3xf64> + %9 = tensor.empty() : tensor<2x5x4xf64> + %10 = tensor.empty() : tensor<2x5x3xf64> + %11 = tensor.empty() : tensor<2x5x5xf64> + %12 = tensor.empty() : tensor<2x5x5xf64> + %13 = tensor.empty() : tensor<2x3x5xf64> + %14 = tensor.empty() : tensor<2x4x5xf64> + %16 = polygeist.submap(%6, %c2, %c4, %c5, %c3) {map = #map1} : (tensor, index, index, index, index) -> tensor + %17 = polygeist.submap(%1, %c2, %c4, %c5, %c3) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v17_contract_18_tc0 = tensor.cast %17 : tensor to tensor<*xf64> + + %v16_contract_18_tc1 = tensor.cast %16 : tensor to tensor<*xf64> + + %v14_contract_18_tc2 = tensor.cast %14 : tensor<2x4x5xf64> to tensor<*xf64> + + %v18_tdyn = kernel.launch @cutensornetContraction2_f64(%v17_contract_18_tc0, %v16_contract_18_tc1, %v14_contract_18_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %18 = tensor.cast %v18_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %20 = polygeist.submap(%4, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %v18_contract_21_tc0 = tensor.cast %18 : tensor<2x4x5xf64> to tensor<*xf64> + + %v20_contract_21_tc1 = tensor.cast %20 : tensor to tensor<*xf64> + + %v12_contract_21_tc2 = tensor.cast %12 : tensor<2x5x5xf64> to tensor<*xf64> + + %v21_tdyn = kernel.launch @cutensornetContraction2_f64(%v18_contract_21_tc0, %v20_contract_21_tc1, %v12_contract_21_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %21 = tensor.cast %v21_tdyn : tensor<*xf64> to tensor<2x5x5xf64> + %23 = polygeist.submap(%4, %c2, %c3, %c5, %c4) {map = #map7} : (tensor, index, index, index, index) -> tensor + %24 = polygeist.submap(%1, %c2, %c3, %c5, %c4) {map = #map8} : (tensor, index, index, index, index) -> tensor + %v24_contract_25_tc0 = tensor.cast %24 : tensor to tensor<*xf64> + + %v23_contract_25_tc1 = tensor.cast %23 : tensor to tensor<*xf64> + + %v13_contract_25_tc2 = tensor.cast %13 : tensor<2x3x5xf64> to tensor<*xf64> + + %v25_tdyn = kernel.launch @cutensornetContraction2_f64(%v24_contract_25_tc0, %v23_contract_25_tc1, %v13_contract_25_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %25 = tensor.cast %v25_tdyn : tensor<*xf64> to tensor<2x3x5xf64> + %27 = polygeist.submap(%6, %c2, %c5, %c5, %c3) {map = #map9} : (tensor, index, index, index, index) -> tensor + %v25_contract_28_tc0 = tensor.cast %25 : tensor<2x3x5xf64> to tensor<*xf64> + + %v27_contract_28_tc1 = tensor.cast %27 : tensor to tensor<*xf64> + + %v11_contract_28_tc2 = tensor.cast %11 : tensor<2x5x5xf64> to tensor<*xf64> + + %v28_tdyn = kernel.launch @cutensornetContraction2_f64(%v25_contract_28_tc0, %v27_contract_28_tc1, %v11_contract_28_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %28 = tensor.cast %v28_tdyn : tensor<*xf64> to tensor<2x5x5xf64> + %29 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x5x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x3xf64> + %30 = polygeist.submap(%5, %c2, %c5, %c3, %c5) {map = #map10} : (tensor, index, index, index, index) -> tensor + %31 = polygeist.submap(%2, %c2, %c5, %c3, %c5) {map = #map11} : (tensor, index, index, index, index) -> tensor + %32 = linalg.generic {doc = "", indexing_maps = [#map3, #map12, #map12, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%31, %28, %21, %30 : tensor, tensor<2x5x5xf64>, tensor<2x5x5xf64>, tensor) outs(%29 : tensor<2x5x3xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %50 = arith.subf %in_0, %in_1 : f64 + %51 = arith.mulf %in, %50 : f64 + %52 = arith.mulf %51, %in_2 : f64 + %53 = arith.addf %out, %52 : f64 + linalg.yield %53 : f64 + } -> tensor<2x5x3xf64> + %33 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor<2x4x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x3xf64> + %34 = polygeist.submap(%3, %c2, %c4, %c3, %c5) {map = #map13} : (tensor, index, index, index, index) -> tensor + %35 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%32, %34 : tensor<2x5x3xf64>, tensor) outs(%33 : tensor<2x4x3xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %50 = arith.mulf %in, %in_0 : f64 + %51 = arith.subf %out, %50 : f64 + linalg.yield %51 : f64 + } -> tensor<2x4x3xf64> + %36 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4xf64> + %37 = polygeist.submap(%3, %c2, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index) -> tensor + %38 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index) -> tensor + %39 = linalg.generic {doc = "", indexing_maps = [#map3, #map12, #map12, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%38, %28, %21, %37 : tensor, tensor<2x5x5xf64>, tensor<2x5x5xf64>, tensor) outs(%36 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %50 = arith.subf %in_0, %in_1 : f64 + %51 = arith.mulf %in, %50 : f64 + %52 = arith.mulf %51, %in_2 : f64 + %53 = arith.addf %out, %52 : f64 + linalg.yield %53 : f64 + } -> tensor<2x5x4xf64> + %41 = polygeist.submap(%5, %c2, %c3, %c4, %c5) {map = #map13} : (tensor, index, index, index, index) -> tensor + %v39_contract_42_tc0 = tensor.cast %39 : tensor<2x5x4xf64> to tensor<*xf64> + + %v41_contract_42_tc1 = tensor.cast %41 : tensor to tensor<*xf64> + + %v7_contract_42_tc2 = tensor.cast %7 : tensor<2x3x4xf64> to tensor<*xf64> + + %v42_tdyn = kernel.launch @cutensornetContraction2_f64(%v39_contract_42_tc0, %v41_contract_42_tc1, %v7_contract_42_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %42 = tensor.cast %v42_tdyn : tensor<*xf64> to tensor<2x3x4xf64> + %43 = polygeist.submap(%0, %c2, %c4, %c3) {map = #map14} : (tensor, index, index, index) -> tensor + %v35_tc0 = tensor.cast %35 : tensor<2x4x3xf64> to tensor + + %44 = kernel.launch @cublasDaxpby(%v35_tc0, %43) : (tensor, tensor) -> tensor + %45 = polygeist.submapInverse(%0, %44, %c2, %c4, %c3) {map = #map14} : (tensor, tensor, index, index, index) -> tensor + %46 = polygeist.submap(%45, %c2, %c3, %c4) {map = #map15} : (tensor, index, index, index) -> tensor + %v42_tc0 = tensor.cast %42 : tensor<2x3x4xf64> to tensor + + %47 = kernel.launch @cublasDaxpby(%v42_tc0, %46) : (tensor, tensor) -> tensor + %48 = polygeist.submapInverse(%45, %47, %c2, %c3, %c4) {map = #map15} : (tensor, tensor, index, index, index) -> tensor + %49 = bufferization.to_memref %48 : memref + memref.copy %49, %arg6 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/curlcurl_apply_3d_stage_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/curlcurl_apply_3d_stage_sliced/debufferized.mlir new file mode 100644 index 000000000000..39e429c48335 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/curlcurl_apply_3d_stage_sliced/debufferized.mlir @@ -0,0 +1,563 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 144)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 125)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 375)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 500)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 250)> +#map22 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 625)> +#map23 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 144)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map26 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_curlcurl_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg8 : memref + %1 = bufferization.to_tensor %arg7 : memref + %2 = bufferization.to_tensor %arg6 : memref + %3 = bufferization.to_tensor %arg5 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = bufferization.to_tensor %arg3 : memref + %6 = bufferization.to_tensor %arg2 : memref + %7 = bufferization.to_tensor %arg1 : memref + %8 = bufferization.to_tensor %arg0 : memref + %9 = tensor.empty() : tensor<2x4x4x4xf64> + %10 = tensor.empty() : tensor<2x4x4x4xf64> + %11 = tensor.empty() : tensor<2x4x4x4xf64> + %12 = tensor.empty() : tensor<2x4x4x4xf64> + %13 = tensor.empty() : tensor<2x4x4x4xf64> + %14 = tensor.empty() : tensor<2x4x4x4xf64> + %15 = tensor.empty() : tensor<2x5x4x4xf64> + %16 = tensor.empty() : tensor<2x5x4x4xf64> + %17 = tensor.empty() : tensor<2x5x4x4xf64> + %18 = tensor.empty() : tensor<2x5x4x4xf64> + %19 = tensor.empty() : tensor<2x5x4x4xf64> + %20 = tensor.empty() : tensor<2x5x4x4xf64> + %21 = tensor.empty() : tensor<2x5x5x4xf64> + %22 = tensor.empty() : tensor<2x5x5x4xf64> + %23 = tensor.empty() : tensor<2x5x5x4xf64> + %24 = tensor.empty() : tensor<2x5x5x4xf64> + %25 = tensor.empty() : tensor<2x5x5x4xf64> + %26 = tensor.empty() : tensor<2x5x5x4xf64> + %27 = tensor.empty() : tensor<2x5x5x5xf64> + %28 = tensor.empty() : tensor<2x5x5x5xf64> + %29 = tensor.empty() : tensor<2x5x5x5xf64> + %30 = tensor.empty() : tensor<2x5x5x5xf64> + %31 = tensor.empty() : tensor<2x5x5x5xf64> + %32 = tensor.empty() : tensor<2x5x5x5xf64> + %33 = tensor.empty() : tensor<2x4x5x5xf64> + %34 = tensor.empty() : tensor<2x4x5x5xf64> + %35 = tensor.empty() : tensor<2x4x5x5xf64> + %36 = tensor.empty() : tensor<2x4x5x5xf64> + %37 = tensor.empty() : tensor<2x4x5x5xf64> + %38 = tensor.empty() : tensor<2x4x5x5xf64> + %39 = tensor.empty() : tensor<2x4x4x5xf64> + %40 = tensor.empty() : tensor<2x4x4x5xf64> + %41 = tensor.empty() : tensor<2x4x4x5xf64> + %42 = tensor.empty() : tensor<2x4x4x5xf64> + %43 = tensor.empty() : tensor<2x4x4x5xf64> + %44 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%43 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %45 = polygeist.submap(%8, %c2, %c4, %c4, %c5, %c3) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %46 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c3) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %47 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%46, %45 : tensor, tensor) outs(%44 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x5xf64> + %48 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%38 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %49 = polygeist.submap(%4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %50 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%47, %49 : tensor<2x4x4x5xf64>, tensor) outs(%48 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %51 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%37 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %52 = polygeist.submap(%7, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %53 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%47, %52 : tensor<2x4x4x5xf64>, tensor) outs(%51 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %54 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%32 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %55 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %56 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%50, %55 : tensor<2x4x5x5xf64>, tensor) outs(%54 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %57 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%31 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %58 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %59 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%53, %58 : tensor<2x4x5x5xf64>, tensor) outs(%57 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %60 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%42 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %61 = polygeist.submap(%4, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %62 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%62, %61 : tensor, tensor) outs(%60 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x5xf64> + %64 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%41 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %65 = polygeist.submap(%7, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %66 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %67 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%66, %65 : tensor, tensor) outs(%64 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x5xf64> + %68 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%36 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %69 = polygeist.submap(%8, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %70 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%63, %69 : tensor<2x4x4x5xf64>, tensor) outs(%68 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %71 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%35 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %72 = polygeist.submap(%8, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %73 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%67, %72 : tensor<2x4x4x5xf64>, tensor) outs(%71 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %74 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%30 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %75 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %76 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%70, %75 : tensor<2x4x5x5xf64>, tensor) outs(%74 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %77 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%29 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %78 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %79 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%73, %78 : tensor<2x4x5x5xf64>, tensor) outs(%77 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %80 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%40 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %81 = polygeist.submap(%4, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %82 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %83 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%82, %81 : tensor, tensor) outs(%80 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x5xf64> + %84 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%39 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %85 = polygeist.submap(%7, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %86 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %87 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%86, %85 : tensor, tensor) outs(%84 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x5xf64> + %88 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%34 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %89 = polygeist.submap(%7, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %90 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%83, %89 : tensor<2x4x4x5xf64>, tensor) outs(%88 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %91 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%33 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %92 = polygeist.submap(%4, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %93 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%87, %92 : tensor<2x4x4x5xf64>, tensor) outs(%91 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x5x5xf64> + %94 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%28 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %95 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %96 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%90, %95 : tensor<2x4x5x5xf64>, tensor) outs(%94 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %97 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%27 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %98 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %99 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%93, %98 : tensor<2x4x5x5xf64>, tensor) outs(%97 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x5x5xf64> + %100 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%26 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %101 = polygeist.submap(%6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %102 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %103 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %104 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %105 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%102, %99, %79, %103, %59, %96, %104, %76, %56, %101 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%100 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %106 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%20 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %107 = polygeist.submap(%5, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %108 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%105, %107 : tensor<2x5x5x4xf64>, tensor) outs(%106 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %109 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%14 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %110 = polygeist.submap(%3, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %111 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%108, %110 : tensor<2x5x4x4xf64>, tensor) outs(%109 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %112 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%25 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %113 = polygeist.submap(%6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %114 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %115 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %116 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %117 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%114, %99, %79, %115, %59, %96, %116, %76, %56, %113 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%112 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %118 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%19 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %119 = polygeist.submap(%3, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %120 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%117, %119 : tensor<2x5x5x4xf64>, tensor) outs(%118 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %121 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%13 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %122 = polygeist.submap(%5, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %123 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%120, %122 : tensor<2x5x4x4xf64>, tensor) outs(%121 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %124 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%24 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %125 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %126 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %127 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %128 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %129 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%126, %99, %79, %127, %59, %96, %128, %76, %56, %125 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%124 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %130 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%18 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %131 = polygeist.submap(%6, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %132 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%129, %131 : tensor<2x5x5x4xf64>, tensor) outs(%130 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %133 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %134 = polygeist.submap(%5, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %135 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%132, %134 : tensor<2x5x4x4xf64>, tensor) outs(%133 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %136 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%23 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %137 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %138 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %139 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %140 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %141 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%138, %99, %79, %139, %59, %96, %140, %76, %56, %137 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%136 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %142 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%17 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %143 = polygeist.submap(%6, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %144 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%141, %143 : tensor<2x5x5x4xf64>, tensor) outs(%142 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %145 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %146 = polygeist.submap(%3, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %147 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%144, %146 : tensor<2x5x4x4xf64>, tensor) outs(%145 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %148 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%22 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %149 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %150 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %151 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %152 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %153 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%150, %99, %79, %151, %59, %96, %152, %76, %56, %149 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%148 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %154 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%16 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %155 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %156 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%153, %155 : tensor<2x5x5x4xf64>, tensor) outs(%154 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %157 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %158 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %159 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%156, %158 : tensor<2x5x4x4xf64>, tensor) outs(%157 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %160 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%21 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %161 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %162 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %163 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %164 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %165 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%162, %99, %79, %163, %59, %96, %164, %76, %56, %161 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%160 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %166 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%15 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %167 = polygeist.submap(%5, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %168 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%165, %167 : tensor<2x5x5x4xf64>, tensor) outs(%166 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x5x4x4xf64> + %169 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %170 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %171 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%168, %170 : tensor<2x5x4x4xf64>, tensor) outs(%169 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.mulf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor<2x4x4x4xf64> + %172 = polygeist.submap(%0, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, index, index, index, index) -> tensor + %173 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%111, %123 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%172 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %174 = polygeist.submapInverse(%0, %173, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, tensor, index, index, index, index) -> tensor + %175 = polygeist.submap(%174, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, index, index, index, index) -> tensor + %176 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%135, %147 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%175 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %177 = polygeist.submapInverse(%174, %176, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, tensor, index, index, index, index) -> tensor + %178 = polygeist.submap(%177, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, index, index, index, index) -> tensor + %179 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%159, %171 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%178 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %180 = polygeist.submapInverse(%177, %179, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, tensor, index, index, index, index) -> tensor + %181 = bufferization.to_memref %180 : memref + memref.copy %181, %arg8 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/curlcurl_apply_3d_stage_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/curlcurl_apply_3d_stage_sliced/match_report.txt new file mode 100644 index 000000000000..45c758ebae87 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/curlcurl_apply_3d_stage_sliced/match_report.txt @@ -0,0 +1,46 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/curlcurl_apply_3d_stage_sliced/debufferized.mlir == + match body#[0, 1] cublasGemmFor1x1Conv + match body#[2, 3] cublasGemmFor1x1Conv + match body#[4, 5] cublasGemmFor1x1Conv + match body#[6, 7] cublasGemmFor1x1Conv + match body#[8, 9] cublasGemmFor1x1Conv + match body#[10, 11] cublasGemmFor1x1Conv + match body#[12, 13] cublasGemmFor1x1Conv + match body#[14, 15] cublasGemmFor1x1Conv + match body#[16, 17] cublasGemmFor1x1Conv + match body#[18, 19] cublasGemmFor1x1Conv + match body#[20, 21] cublasGemmFor1x1Conv + match body#[22, 23] cublasGemmFor1x1Conv + match body#[24, 25] cublasGemmFor1x1Conv + match body#[26, 27] cublasGemmFor1x1Conv + match body#[28, 29] cublasGemmFor1x1Conv + match body#[30, 31] cublasGemmFor1x1Conv + match body#[32, 33] cublasGemmFor1x1Conv + no_match body#34 ? + no_match body#35 ? + match body#[36, 37] cublasGemmFor1x1Conv + match body#[38, 39] cublasGemmFor1x1Conv + no_match body#40 ? + no_match body#41 ? + match body#[42, 43] cublasGemmFor1x1Conv + match body#[44, 45] cublasGemmFor1x1Conv + no_match body#46 ? + no_match body#47 ? + match body#[48, 49] cublasGemmFor1x1Conv + match body#[50, 51] cublasGemmFor1x1Conv + no_match body#52 ? + no_match body#53 ? + match body#[54, 55] cublasGemmFor1x1Conv + match body#[56, 57] cublasGemmFor1x1Conv + no_match body#58 ? + no_match body#59 ? + match body#[60, 61] cublasGemmFor1x1Conv + match body#[62, 63] cublasGemmFor1x1Conv + no_match body#64 ? + no_match body#65 ? + match body#[66, 67] cublasGemmFor1x1Conv + match body#[68, 69] cublasGemmFor1x1Conv + no_match body#70 ? + no_match body#71 ? + no_match body#72 ? + total: 29 matched / 44 bodies diff --git a/issues/mfem_c_kernels/match_results/curlcurl_apply_3d_stage_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/curlcurl_apply_3d_stage_sliced/matched.mlir new file mode 100644 index 000000000000..3bf2a949a74e --- /dev/null +++ b/issues/mfem_c_kernels/match_results/curlcurl_apply_3d_stage_sliced/matched.mlir @@ -0,0 +1,466 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 144)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 125)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 375)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 500)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 250)> +#map22 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 625)> +#map23 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 144)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map26 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_curlcurl_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg8 : memref + %1 = bufferization.to_tensor %arg7 : memref + %2 = bufferization.to_tensor %arg6 : memref + %3 = bufferization.to_tensor %arg5 : memref + %4 = bufferization.to_tensor %arg4 : memref + %5 = bufferization.to_tensor %arg3 : memref + %6 = bufferization.to_tensor %arg2 : memref + %7 = bufferization.to_tensor %arg1 : memref + %8 = bufferization.to_tensor %arg0 : memref + %9 = tensor.empty() : tensor<2x4x4x4xf64> + %10 = tensor.empty() : tensor<2x4x4x4xf64> + %11 = tensor.empty() : tensor<2x4x4x4xf64> + %12 = tensor.empty() : tensor<2x4x4x4xf64> + %13 = tensor.empty() : tensor<2x4x4x4xf64> + %14 = tensor.empty() : tensor<2x4x4x4xf64> + %15 = tensor.empty() : tensor<2x5x4x4xf64> + %16 = tensor.empty() : tensor<2x5x4x4xf64> + %17 = tensor.empty() : tensor<2x5x4x4xf64> + %18 = tensor.empty() : tensor<2x5x4x4xf64> + %19 = tensor.empty() : tensor<2x5x4x4xf64> + %20 = tensor.empty() : tensor<2x5x4x4xf64> + %21 = tensor.empty() : tensor<2x5x5x4xf64> + %22 = tensor.empty() : tensor<2x5x5x4xf64> + %23 = tensor.empty() : tensor<2x5x5x4xf64> + %24 = tensor.empty() : tensor<2x5x5x4xf64> + %25 = tensor.empty() : tensor<2x5x5x4xf64> + %26 = tensor.empty() : tensor<2x5x5x4xf64> + %27 = tensor.empty() : tensor<2x5x5x5xf64> + %28 = tensor.empty() : tensor<2x5x5x5xf64> + %29 = tensor.empty() : tensor<2x5x5x5xf64> + %30 = tensor.empty() : tensor<2x5x5x5xf64> + %31 = tensor.empty() : tensor<2x5x5x5xf64> + %32 = tensor.empty() : tensor<2x5x5x5xf64> + %33 = tensor.empty() : tensor<2x4x5x5xf64> + %34 = tensor.empty() : tensor<2x4x5x5xf64> + %35 = tensor.empty() : tensor<2x4x5x5xf64> + %36 = tensor.empty() : tensor<2x4x5x5xf64> + %37 = tensor.empty() : tensor<2x4x5x5xf64> + %38 = tensor.empty() : tensor<2x4x5x5xf64> + %39 = tensor.empty() : tensor<2x4x4x5xf64> + %40 = tensor.empty() : tensor<2x4x4x5xf64> + %41 = tensor.empty() : tensor<2x4x4x5xf64> + %42 = tensor.empty() : tensor<2x4x4x5xf64> + %43 = tensor.empty() : tensor<2x4x4x5xf64> + %45 = polygeist.submap(%8, %c2, %c4, %c4, %c5, %c3) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %46 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c3) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v43_contract_47_tc2 = tensor.cast %43 : tensor<2x4x4x5xf64> to tensor + + %v47_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%46, %45, %v43_contract_47_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %47 = tensor.cast %v47_tdyn : tensor to tensor<2x4x4x5xf64> + %49 = polygeist.submap(%4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v47_contract_50_tc0 = tensor.cast %47 : tensor<2x4x4x5xf64> to tensor + + %v38_contract_50_tc2 = tensor.cast %38 : tensor<2x4x5x5xf64> to tensor + + %v50_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v47_contract_50_tc0, %49, %v38_contract_50_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %50 = tensor.cast %v50_tdyn : tensor to tensor<2x4x5x5xf64> + %52 = polygeist.submap(%7, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v47_contract_53_tc0 = tensor.cast %47 : tensor<2x4x4x5xf64> to tensor + + %v37_contract_53_tc2 = tensor.cast %37 : tensor<2x4x5x5xf64> to tensor + + %v53_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v47_contract_53_tc0, %52, %v37_contract_53_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %53 = tensor.cast %v53_tdyn : tensor to tensor<2x4x5x5xf64> + %55 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v50_contract_56_tc0 = tensor.cast %50 : tensor<2x4x5x5xf64> to tensor + + %v32_contract_56_tc2 = tensor.cast %32 : tensor<2x5x5x5xf64> to tensor + + %v56_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v50_contract_56_tc0, %55, %v32_contract_56_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %56 = tensor.cast %v56_tdyn : tensor to tensor<2x5x5x5xf64> + %58 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v53_contract_59_tc0 = tensor.cast %53 : tensor<2x4x5x5xf64> to tensor + + %v31_contract_59_tc2 = tensor.cast %31 : tensor<2x5x5x5xf64> to tensor + + %v59_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v53_contract_59_tc0, %58, %v31_contract_59_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %59 = tensor.cast %v59_tdyn : tensor to tensor<2x5x5x5xf64> + %61 = polygeist.submap(%4, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %62 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %v42_contract_63_tc2 = tensor.cast %42 : tensor<2x4x4x5xf64> to tensor + + %v63_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%62, %61, %v42_contract_63_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %63 = tensor.cast %v63_tdyn : tensor to tensor<2x4x4x5xf64> + %65 = polygeist.submap(%7, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %66 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %v41_contract_67_tc2 = tensor.cast %41 : tensor<2x4x4x5xf64> to tensor + + %v67_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%66, %65, %v41_contract_67_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %67 = tensor.cast %v67_tdyn : tensor to tensor<2x4x4x5xf64> + %69 = polygeist.submap(%8, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %v63_contract_70_tc0 = tensor.cast %63 : tensor<2x4x4x5xf64> to tensor + + %v36_contract_70_tc2 = tensor.cast %36 : tensor<2x4x5x5xf64> to tensor + + %v70_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v63_contract_70_tc0, %69, %v36_contract_70_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %70 = tensor.cast %v70_tdyn : tensor to tensor<2x4x5x5xf64> + %72 = polygeist.submap(%8, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %v67_contract_73_tc0 = tensor.cast %67 : tensor<2x4x4x5xf64> to tensor + + %v35_contract_73_tc2 = tensor.cast %35 : tensor<2x4x5x5xf64> to tensor + + %v73_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v67_contract_73_tc0, %72, %v35_contract_73_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %73 = tensor.cast %v73_tdyn : tensor to tensor<2x4x5x5xf64> + %75 = polygeist.submap(%7, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v70_contract_76_tc0 = tensor.cast %70 : tensor<2x4x5x5xf64> to tensor + + %v30_contract_76_tc2 = tensor.cast %30 : tensor<2x5x5x5xf64> to tensor + + %v76_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v70_contract_76_tc0, %75, %v30_contract_76_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %76 = tensor.cast %v76_tdyn : tensor to tensor<2x5x5x5xf64> + %78 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v73_contract_79_tc0 = tensor.cast %73 : tensor<2x4x5x5xf64> to tensor + + %v29_contract_79_tc2 = tensor.cast %29 : tensor<2x5x5x5xf64> to tensor + + %v79_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v73_contract_79_tc0, %78, %v29_contract_79_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %79 = tensor.cast %v79_tdyn : tensor to tensor<2x5x5x5xf64> + %81 = polygeist.submap(%4, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %82 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %v40_contract_83_tc2 = tensor.cast %40 : tensor<2x4x4x5xf64> to tensor + + %v83_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%82, %81, %v40_contract_83_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %83 = tensor.cast %v83_tdyn : tensor to tensor<2x4x4x5xf64> + %85 = polygeist.submap(%7, %c2, %c3, %c4, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %86 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %v39_contract_87_tc2 = tensor.cast %39 : tensor<2x4x4x5xf64> to tensor + + %v87_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%86, %85, %v39_contract_87_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %87 = tensor.cast %v87_tdyn : tensor to tensor<2x4x4x5xf64> + %89 = polygeist.submap(%7, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v83_contract_90_tc0 = tensor.cast %83 : tensor<2x4x4x5xf64> to tensor + + %v34_contract_90_tc2 = tensor.cast %34 : tensor<2x4x5x5xf64> to tensor + + %v90_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v83_contract_90_tc0, %89, %v34_contract_90_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %90 = tensor.cast %v90_tdyn : tensor to tensor<2x4x5x5xf64> + %92 = polygeist.submap(%4, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v87_contract_93_tc0 = tensor.cast %87 : tensor<2x4x4x5xf64> to tensor + + %v33_contract_93_tc2 = tensor.cast %33 : tensor<2x4x5x5xf64> to tensor + + %v93_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v87_contract_93_tc0, %92, %v33_contract_93_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %93 = tensor.cast %v93_tdyn : tensor to tensor<2x4x5x5xf64> + %95 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %v90_contract_96_tc0 = tensor.cast %90 : tensor<2x4x5x5xf64> to tensor + + %v28_contract_96_tc2 = tensor.cast %28 : tensor<2x5x5x5xf64> to tensor + + %v96_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v90_contract_96_tc0, %95, %v28_contract_96_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %96 = tensor.cast %v96_tdyn : tensor to tensor<2x5x5x5xf64> + %98 = polygeist.submap(%8, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %v93_contract_99_tc0 = tensor.cast %93 : tensor<2x4x5x5xf64> to tensor + + %v27_contract_99_tc2 = tensor.cast %27 : tensor<2x5x5x5xf64> to tensor + + %v99_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v93_contract_99_tc0, %98, %v27_contract_99_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %99 = tensor.cast %v99_tdyn : tensor to tensor<2x5x5x5xf64> + %100 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%26 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %101 = polygeist.submap(%6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %102 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %103 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %104 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %105 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%102, %99, %79, %103, %59, %96, %104, %76, %56, %101 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%100 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %107 = polygeist.submap(%5, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v105_contract_108_tc0 = tensor.cast %105 : tensor<2x5x5x4xf64> to tensor + + %v20_contract_108_tc2 = tensor.cast %20 : tensor<2x5x4x4xf64> to tensor + + %v108_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v105_contract_108_tc0, %107, %v20_contract_108_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %108 = tensor.cast %v108_tdyn : tensor to tensor<2x5x4x4xf64> + %110 = polygeist.submap(%3, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v108_contract_111_tc0 = tensor.cast %108 : tensor<2x5x4x4xf64> to tensor + + %v14_contract_111_tc2 = tensor.cast %14 : tensor<2x4x4x4xf64> to tensor + + %v111_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v108_contract_111_tc0, %110, %v14_contract_111_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %111 = tensor.cast %v111_tdyn : tensor to tensor<2x4x4x4xf64> + %112 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%25 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %113 = polygeist.submap(%6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %114 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %115 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %116 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %117 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%114, %99, %79, %115, %59, %96, %116, %76, %56, %113 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%112 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %119 = polygeist.submap(%3, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v117_contract_120_tc0 = tensor.cast %117 : tensor<2x5x5x4xf64> to tensor + + %v19_contract_120_tc2 = tensor.cast %19 : tensor<2x5x4x4xf64> to tensor + + %v120_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v117_contract_120_tc0, %119, %v19_contract_120_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %120 = tensor.cast %v120_tdyn : tensor to tensor<2x5x4x4xf64> + %122 = polygeist.submap(%5, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v120_contract_123_tc0 = tensor.cast %120 : tensor<2x5x4x4xf64> to tensor + + %v13_contract_123_tc2 = tensor.cast %13 : tensor<2x4x4x4xf64> to tensor + + %v123_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v120_contract_123_tc0, %122, %v13_contract_123_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %123 = tensor.cast %v123_tdyn : tensor to tensor<2x4x4x4xf64> + %124 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%24 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %125 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %126 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %127 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %128 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map22} : (tensor, index, index, index, index, index) -> tensor + %129 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%126, %99, %79, %127, %59, %96, %128, %76, %56, %125 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%124 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %131 = polygeist.submap(%6, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v129_contract_132_tc0 = tensor.cast %129 : tensor<2x5x5x4xf64> to tensor + + %v18_contract_132_tc2 = tensor.cast %18 : tensor<2x5x4x4xf64> to tensor + + %v132_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v129_contract_132_tc0, %131, %v18_contract_132_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %132 = tensor.cast %v132_tdyn : tensor to tensor<2x5x4x4xf64> + %134 = polygeist.submap(%5, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v132_contract_135_tc0 = tensor.cast %132 : tensor<2x5x4x4xf64> to tensor + + %v12_contract_135_tc2 = tensor.cast %12 : tensor<2x4x4x4xf64> to tensor + + %v135_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v132_contract_135_tc0, %134, %v12_contract_135_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %135 = tensor.cast %v135_tdyn : tensor to tensor<2x4x4x4xf64> + %136 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%23 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %137 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %138 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %139 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %140 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %141 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%138, %99, %79, %139, %59, %96, %140, %76, %56, %137 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%136 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %143 = polygeist.submap(%6, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v141_contract_144_tc0 = tensor.cast %141 : tensor<2x5x5x4xf64> to tensor + + %v17_contract_144_tc2 = tensor.cast %17 : tensor<2x5x4x4xf64> to tensor + + %v144_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v141_contract_144_tc0, %143, %v17_contract_144_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %144 = tensor.cast %v144_tdyn : tensor to tensor<2x5x4x4xf64> + %146 = polygeist.submap(%3, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v144_contract_147_tc0 = tensor.cast %144 : tensor<2x5x4x4xf64> to tensor + + %v11_contract_147_tc2 = tensor.cast %11 : tensor<2x4x4x4xf64> to tensor + + %v147_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v144_contract_147_tc0, %146, %v11_contract_147_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %147 = tensor.cast %v147_tdyn : tensor to tensor<2x4x4x4xf64> + %148 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%22 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %149 = polygeist.submap(%5, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %150 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (tensor, index, index, index, index, index) -> tensor + %151 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %152 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %153 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%150, %99, %79, %151, %59, %96, %152, %76, %56, %149 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%148 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %155 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v153_contract_156_tc0 = tensor.cast %153 : tensor<2x5x5x4xf64> to tensor + + %v16_contract_156_tc2 = tensor.cast %16 : tensor<2x5x4x4xf64> to tensor + + %v156_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v153_contract_156_tc0, %155, %v16_contract_156_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %156 = tensor.cast %v156_tdyn : tensor to tensor<2x5x4x4xf64> + %158 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v156_contract_159_tc0 = tensor.cast %156 : tensor<2x5x4x4xf64> to tensor + + %v10_contract_159_tc2 = tensor.cast %10 : tensor<2x4x4x4xf64> to tensor + + %v159_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v156_contract_159_tc0, %158, %v10_contract_159_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %159 = tensor.cast %v159_tdyn : tensor to tensor<2x4x4x4xf64> + %160 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%21 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %161 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %162 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %163 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %164 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %165 = linalg.generic {doc = "", indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%162, %99, %79, %163, %59, %96, %164, %76, %56, %161 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%160 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %182 = arith.subf %in_0, %in_1 : f64 + %183 = arith.mulf %in, %182 : f64 + %184 = arith.subf %in_3, %in_4 : f64 + %185 = arith.mulf %in_2, %184 : f64 + %186 = arith.addf %183, %185 : f64 + %187 = arith.subf %in_6, %in_7 : f64 + %188 = arith.mulf %in_5, %187 : f64 + %189 = arith.addf %186, %188 : f64 + %190 = arith.mulf %189, %in_8 : f64 + %191 = arith.addf %out, %190 : f64 + linalg.yield %191 : f64 + } -> tensor<2x5x5x4xf64> + %167 = polygeist.submap(%5, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %v165_contract_168_tc0 = tensor.cast %165 : tensor<2x5x5x4xf64> to tensor + + %v15_contract_168_tc2 = tensor.cast %15 : tensor<2x5x4x4xf64> to tensor + + %v168_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v165_contract_168_tc0, %167, %v15_contract_168_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %168 = tensor.cast %v168_tdyn : tensor to tensor<2x5x4x4xf64> + %170 = polygeist.submap(%6, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %v168_contract_171_tc0 = tensor.cast %168 : tensor<2x5x4x4xf64> to tensor + + %v9_contract_171_tc2 = tensor.cast %9 : tensor<2x4x4x4xf64> to tensor + + %v171_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v168_contract_171_tc0, %170, %v9_contract_171_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %171 = tensor.cast %v171_tdyn : tensor to tensor<2x4x4x4xf64> + %172 = polygeist.submap(%0, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, index, index, index, index) -> tensor + %173 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%111, %123 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%172 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %174 = polygeist.submapInverse(%0, %173, %c2, %c4, %c4, %c3) {map = #map24} : (tensor, tensor, index, index, index, index) -> tensor + %175 = polygeist.submap(%174, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, index, index, index, index) -> tensor + %176 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%135, %147 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%175 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %177 = polygeist.submapInverse(%174, %176, %c2, %c4, %c3, %c4) {map = #map25} : (tensor, tensor, index, index, index, index) -> tensor + %178 = polygeist.submap(%177, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, index, index, index, index) -> tensor + %179 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%159, %171 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%178 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %182 = arith.subf %in, %in_0 : f64 + %183 = arith.addf %out, %182 : f64 + linalg.yield %183 : f64 + } -> tensor + %180 = polygeist.submapInverse(%177, %179, %c2, %c3, %c4, %c4) {map = #map26} : (tensor, tensor, index, index, index, index) -> tensor + %181 = bufferization.to_memref %180 : memref + memref.copy %181, %arg8 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/diffusion_apply_2d_stage_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/diffusion_apply_2d_stage_sliced/debufferized.mlir new file mode 100644 index 000000000000..c9fce83a1f36 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/diffusion_apply_2d_stage_sliced/debufferized.mlir @@ -0,0 +1,148 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5 + d0 * 75)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 75 + d1 * 5 + 25)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 75 + d1 * 5 + 50)> +#map12 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map13 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_diffusion_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x4x4xf64> + %8 = tensor.empty() : tensor<2x4x4xf64> + %9 = tensor.empty() : tensor<2x5x4xf64> + %10 = tensor.empty() : tensor<2x5x4xf64> + %11 = tensor.empty() : tensor<2x5x5xf64> + %12 = tensor.empty() : tensor<2x5x5xf64> + %13 = tensor.empty() : tensor<2x4x5xf64> + %14 = tensor.empty() : tensor<2x4x5xf64> + %15 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%14 : tensor<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5xf64> + %16 = polygeist.submap(%6, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %17 = polygeist.submap(%1, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%17, %16 : tensor, tensor) outs(%15 : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %49 = arith.mulf %in, %in_0 : f64 + %50 = arith.addf %out, %49 : f64 + linalg.yield %50 : f64 + } -> tensor<2x4x5xf64> + %19 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%13 : tensor<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5xf64> + %20 = polygeist.submap(%5, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %21 = polygeist.submap(%1, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%21, %20 : tensor, tensor) outs(%19 : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %49 = arith.mulf %in, %in_0 : f64 + %50 = arith.addf %out, %49 : f64 + linalg.yield %50 : f64 + } -> tensor<2x4x5xf64> + %23 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5xf64> + %24 = polygeist.submap(%6, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%22, %24 : tensor<2x4x5xf64>, tensor) outs(%23 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %49 = arith.mulf %in, %in_0 : f64 + %50 = arith.addf %out, %49 : f64 + linalg.yield %50 : f64 + } -> tensor<2x5x5xf64> + %26 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5xf64> + %27 = polygeist.submap(%5, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%18, %27 : tensor<2x4x5xf64>, tensor) outs(%26 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %49 = arith.mulf %in, %in_0 : f64 + %50 = arith.addf %out, %49 : f64 + linalg.yield %50 : f64 + } -> tensor<2x5x5xf64> + %29 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4xf64> + %30 = polygeist.submap(%3, %c2, %c5, %c4, %c5) {map = #map7} : (tensor, index, index, index, index) -> tensor + %31 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map8} : (tensor, index, index, index, index) -> tensor + %32 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index) -> tensor + %33 = linalg.generic {doc = "", indexing_maps = [#map3, #map10, #map3, #map10, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%31, %25, %32, %28, %30 : tensor, tensor<2x5x5xf64>, tensor, tensor<2x5x5xf64>, tensor) outs(%29 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %49 = arith.mulf %in, %in_0 : f64 + %50 = arith.mulf %in_1, %in_2 : f64 + %51 = arith.addf %49, %50 : f64 + %52 = arith.mulf %51, %in_3 : f64 + %53 = arith.addf %out, %52 : f64 + linalg.yield %53 : f64 + } -> tensor<2x5x4xf64> + %34 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4xf64> + %35 = polygeist.submap(%4, %c2, %c5, %c4, %c5) {map = #map7} : (tensor, index, index, index, index) -> tensor + %36 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index) -> tensor + %37 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index) -> tensor + %38 = linalg.generic {doc = "", indexing_maps = [#map3, #map10, #map3, #map10, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%36, %25, %37, %28, %35 : tensor, tensor<2x5x5xf64>, tensor, tensor<2x5x5xf64>, tensor) outs(%34 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %49 = arith.mulf %in, %in_0 : f64 + %50 = arith.mulf %in_1, %in_2 : f64 + %51 = arith.addf %49, %50 : f64 + %52 = arith.mulf %51, %in_3 : f64 + %53 = arith.addf %out, %52 : f64 + linalg.yield %53 : f64 + } -> tensor<2x5x4xf64> + %39 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor<2x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4xf64> + %40 = polygeist.submap(%4, %c2, %c4, %c4, %c5) {map = #map12} : (tensor, index, index, index, index) -> tensor + %41 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%33, %40 : tensor<2x5x4xf64>, tensor) outs(%39 : tensor<2x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %49 = arith.mulf %in, %in_0 : f64 + %50 = arith.addf %out, %49 : f64 + linalg.yield %50 : f64 + } -> tensor<2x4x4xf64> + %42 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%7 : tensor<2x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4xf64> + %43 = polygeist.submap(%3, %c2, %c4, %c4, %c5) {map = #map12} : (tensor, index, index, index, index) -> tensor + %44 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%38, %43 : tensor<2x5x4xf64>, tensor) outs(%42 : tensor<2x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %49 = arith.mulf %in, %in_0 : f64 + %50 = arith.addf %out, %49 : f64 + linalg.yield %50 : f64 + } -> tensor<2x4x4xf64> + %45 = polygeist.submap(%0, %c2, %c4, %c4) {map = #map13} : (tensor, index, index, index) -> tensor + %46 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%41, %44 : tensor<2x4x4xf64>, tensor<2x4x4xf64>) outs(%45 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %49 = arith.addf %in, %in_0 : f64 + %50 = arith.addf %out, %49 : f64 + linalg.yield %50 : f64 + } -> tensor + %47 = polygeist.submapInverse(%0, %46, %c2, %c4, %c4) {map = #map13} : (tensor, tensor, index, index, index) -> tensor + %48 = bufferization.to_memref %47 : memref + memref.copy %48, %arg6 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/diffusion_apply_2d_stage_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/diffusion_apply_2d_stage_sliced/match_report.txt new file mode 100644 index 000000000000..59f006360c37 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/diffusion_apply_2d_stage_sliced/match_report.txt @@ -0,0 +1,13 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/diffusion_apply_2d_stage_sliced/debufferized.mlir == + match body#[0, 1] cutensornetContraction2_f64 + match body#[2, 3] cutensornetContraction2_f64 + match body#[4, 5] cutensornetContraction2_f64 + match body#[6, 7] cutensornetContraction2_f64 + no_match body#8 ? + no_match body#9 ? + no_match body#10 ? + no_match body#11 ? + match body#[12, 13] cutensornetContraction2_f64 + match body#[14, 15] cutensornetContraction2_f64 + no_match body#16 ? + total: 6 matched / 11 bodies diff --git a/issues/mfem_c_kernels/match_results/diffusion_apply_2d_stage_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/diffusion_apply_2d_stage_sliced/matched.mlir new file mode 100644 index 000000000000..5eee3816c0be --- /dev/null +++ b/issues/mfem_c_kernels/match_results/diffusion_apply_2d_stage_sliced/matched.mlir @@ -0,0 +1,142 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5 + d0 * 75)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 75 + d1 * 5 + 25)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 75 + d1 * 5 + 50)> +#map12 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map13 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_diffusion_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x4x4xf64> + %8 = tensor.empty() : tensor<2x4x4xf64> + %9 = tensor.empty() : tensor<2x5x4xf64> + %10 = tensor.empty() : tensor<2x5x4xf64> + %11 = tensor.empty() : tensor<2x5x5xf64> + %12 = tensor.empty() : tensor<2x5x5xf64> + %13 = tensor.empty() : tensor<2x4x5xf64> + %14 = tensor.empty() : tensor<2x4x5xf64> + %16 = polygeist.submap(%6, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %17 = polygeist.submap(%1, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v17_contract_18_tc0 = tensor.cast %17 : tensor to tensor<*xf64> + + %v16_contract_18_tc1 = tensor.cast %16 : tensor to tensor<*xf64> + + %v14_contract_18_tc2 = tensor.cast %14 : tensor<2x4x5xf64> to tensor<*xf64> + + %v18_tdyn = kernel.launch @cutensornetContraction2_f64(%v17_contract_18_tc0, %v16_contract_18_tc1, %v14_contract_18_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %18 = tensor.cast %v18_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %20 = polygeist.submap(%5, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %21 = polygeist.submap(%1, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v21_contract_22_tc0 = tensor.cast %21 : tensor to tensor<*xf64> + + %v20_contract_22_tc1 = tensor.cast %20 : tensor to tensor<*xf64> + + %v13_contract_22_tc2 = tensor.cast %13 : tensor<2x4x5xf64> to tensor<*xf64> + + %v22_tdyn = kernel.launch @cutensornetContraction2_f64(%v21_contract_22_tc0, %v20_contract_22_tc1, %v13_contract_22_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %22 = tensor.cast %v22_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %24 = polygeist.submap(%6, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %v22_contract_25_tc0 = tensor.cast %22 : tensor<2x4x5xf64> to tensor<*xf64> + + %v24_contract_25_tc1 = tensor.cast %24 : tensor to tensor<*xf64> + + %v12_contract_25_tc2 = tensor.cast %12 : tensor<2x5x5xf64> to tensor<*xf64> + + %v25_tdyn = kernel.launch @cutensornetContraction2_f64(%v22_contract_25_tc0, %v24_contract_25_tc1, %v12_contract_25_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %25 = tensor.cast %v25_tdyn : tensor<*xf64> to tensor<2x5x5xf64> + %27 = polygeist.submap(%5, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %v18_contract_28_tc0 = tensor.cast %18 : tensor<2x4x5xf64> to tensor<*xf64> + + %v27_contract_28_tc1 = tensor.cast %27 : tensor to tensor<*xf64> + + %v11_contract_28_tc2 = tensor.cast %11 : tensor<2x5x5xf64> to tensor<*xf64> + + %v28_tdyn = kernel.launch @cutensornetContraction2_f64(%v18_contract_28_tc0, %v27_contract_28_tc1, %v11_contract_28_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %28 = tensor.cast %v28_tdyn : tensor<*xf64> to tensor<2x5x5xf64> + %29 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4xf64> + %30 = polygeist.submap(%3, %c2, %c5, %c4, %c5) {map = #map7} : (tensor, index, index, index, index) -> tensor + %31 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map8} : (tensor, index, index, index, index) -> tensor + %32 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index) -> tensor + %33 = linalg.generic {doc = "", indexing_maps = [#map3, #map10, #map3, #map10, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%31, %25, %32, %28, %30 : tensor, tensor<2x5x5xf64>, tensor, tensor<2x5x5xf64>, tensor) outs(%29 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %49 = arith.mulf %in, %in_0 : f64 + %50 = arith.mulf %in_1, %in_2 : f64 + %51 = arith.addf %49, %50 : f64 + %52 = arith.mulf %51, %in_3 : f64 + %53 = arith.addf %out, %52 : f64 + linalg.yield %53 : f64 + } -> tensor<2x5x4xf64> + %34 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4xf64> + %35 = polygeist.submap(%4, %c2, %c5, %c4, %c5) {map = #map7} : (tensor, index, index, index, index) -> tensor + %36 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index) -> tensor + %37 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index) -> tensor + %38 = linalg.generic {doc = "", indexing_maps = [#map3, #map10, #map3, #map10, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%36, %25, %37, %28, %35 : tensor, tensor<2x5x5xf64>, tensor, tensor<2x5x5xf64>, tensor) outs(%34 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %49 = arith.mulf %in, %in_0 : f64 + %50 = arith.mulf %in_1, %in_2 : f64 + %51 = arith.addf %49, %50 : f64 + %52 = arith.mulf %51, %in_3 : f64 + %53 = arith.addf %out, %52 : f64 + linalg.yield %53 : f64 + } -> tensor<2x5x4xf64> + %40 = polygeist.submap(%4, %c2, %c4, %c4, %c5) {map = #map12} : (tensor, index, index, index, index) -> tensor + %v33_contract_41_tc0 = tensor.cast %33 : tensor<2x5x4xf64> to tensor<*xf64> + + %v40_contract_41_tc1 = tensor.cast %40 : tensor to tensor<*xf64> + + %v8_contract_41_tc2 = tensor.cast %8 : tensor<2x4x4xf64> to tensor<*xf64> + + %v41_tdyn = kernel.launch @cutensornetContraction2_f64(%v33_contract_41_tc0, %v40_contract_41_tc1, %v8_contract_41_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %41 = tensor.cast %v41_tdyn : tensor<*xf64> to tensor<2x4x4xf64> + %43 = polygeist.submap(%3, %c2, %c4, %c4, %c5) {map = #map12} : (tensor, index, index, index, index) -> tensor + %v38_contract_44_tc0 = tensor.cast %38 : tensor<2x5x4xf64> to tensor<*xf64> + + %v43_contract_44_tc1 = tensor.cast %43 : tensor to tensor<*xf64> + + %v7_contract_44_tc2 = tensor.cast %7 : tensor<2x4x4xf64> to tensor<*xf64> + + %v44_tdyn = kernel.launch @cutensornetContraction2_f64(%v38_contract_44_tc0, %v43_contract_44_tc1, %v7_contract_44_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %44 = tensor.cast %v44_tdyn : tensor<*xf64> to tensor<2x4x4xf64> + %45 = polygeist.submap(%0, %c2, %c4, %c4) {map = #map13} : (tensor, index, index, index) -> tensor + %46 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%41, %44 : tensor<2x4x4xf64>, tensor<2x4x4xf64>) outs(%45 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %49 = arith.addf %in, %in_0 : f64 + %50 = arith.addf %out, %49 : f64 + linalg.yield %50 : f64 + } -> tensor + %47 = polygeist.submapInverse(%0, %46, %c2, %c4, %c4) {map = #map13} : (tensor, tensor, index, index, index) -> tensor + %48 = bufferization.to_memref %47 : memref + memref.copy %48, %arg6 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/diffusion_apply_3d_stage_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/diffusion_apply_3d_stage_sliced/debufferized.mlir new file mode 100644 index 000000000000..97e91175e605 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/diffusion_apply_3d_stage_sliced/debufferized.mlir @@ -0,0 +1,277 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 750)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 125)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 250)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 375)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 500)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 625)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_diffusion_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x4x4x4xf64> + %8 = tensor.empty() : tensor<2x4x4x4xf64> + %9 = tensor.empty() : tensor<2x4x4x4xf64> + %10 = tensor.empty() : tensor<2x5x4x4xf64> + %11 = tensor.empty() : tensor<2x5x4x4xf64> + %12 = tensor.empty() : tensor<2x5x4x4xf64> + %13 = tensor.empty() : tensor<2x5x5x4xf64> + %14 = tensor.empty() : tensor<2x5x5x4xf64> + %15 = tensor.empty() : tensor<2x5x5x4xf64> + %16 = tensor.empty() : tensor<2x5x5x5xf64> + %17 = tensor.empty() : tensor<2x5x5x5xf64> + %18 = tensor.empty() : tensor<2x5x5x5xf64> + %19 = tensor.empty() : tensor<2x4x5x5xf64> + %20 = tensor.empty() : tensor<2x4x5x5xf64> + %21 = tensor.empty() : tensor<2x4x5x5xf64> + %22 = tensor.empty() : tensor<2x4x4x5xf64> + %23 = tensor.empty() : tensor<2x4x4x5xf64> + %24 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%23 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %25 = polygeist.submap(%6, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %26 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %27 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%26, %25 : tensor, tensor) outs(%24 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x4x5xf64> + %28 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%22 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %29 = polygeist.submap(%5, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %30 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %31 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%30, %29 : tensor, tensor) outs(%28 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x4x5xf64> + %32 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%21 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %33 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %34 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%31, %33 : tensor<2x4x4x5xf64>, tensor) outs(%32 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x5x5xf64> + %35 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%20 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %36 = polygeist.submap(%5, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %37 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%27, %36 : tensor<2x4x4x5xf64>, tensor) outs(%35 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x5x5xf64> + %38 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%19 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %39 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %40 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%27, %39 : tensor<2x4x4x5xf64>, tensor) outs(%38 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x5x5xf64> + %41 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%18 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %42 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %43 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%34, %42 : tensor<2x4x5x5xf64>, tensor) outs(%41 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x5x5x5xf64> + %44 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%17 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %45 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %46 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%37, %45 : tensor<2x4x5x5xf64>, tensor) outs(%44 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x5x5x5xf64> + %47 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%16 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %48 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %49 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%40, %48 : tensor<2x4x5x5xf64>, tensor) outs(%47 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x5x5x5xf64> + %50 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%15 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %51 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %52 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %53 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %54 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%52, %43, %53, %46, %54, %49, %51 : tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor) outs(%50 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.mulf %in_1, %in_2 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_3, %in_4 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_5 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor<2x5x5x4xf64> + %56 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%14 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %57 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %58 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %59 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %60 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %61 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%58, %43, %59, %46, %60, %49, %57 : tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor) outs(%56 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.mulf %in_1, %in_2 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_3, %in_4 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_5 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor<2x5x5x4xf64> + %62 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%13 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %63 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %64 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %65 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %66 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %67 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%64, %43, %65, %46, %66, %49, %63 : tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor) outs(%62 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.mulf %in_1, %in_2 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_3, %in_4 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_5 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor<2x5x5x4xf64> + %68 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %69 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %70 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%55, %69 : tensor<2x5x5x4xf64>, tensor) outs(%68 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x5x4x4xf64> + %71 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %72 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %73 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%61, %72 : tensor<2x5x5x4xf64>, tensor) outs(%71 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x5x4x4xf64> + %74 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %75 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %76 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%67, %75 : tensor<2x5x5x4xf64>, tensor) outs(%74 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x5x4x4xf64> + %77 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %78 = polygeist.submap(%4, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %79 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%70, %78 : tensor<2x5x4x4xf64>, tensor) outs(%77 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x4x4xf64> + %80 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %81 = polygeist.submap(%4, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %82 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%73, %81 : tensor<2x5x4x4xf64>, tensor) outs(%80 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x4x4xf64> + %83 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%7 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %84 = polygeist.submap(%3, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %85 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%76, %84 : tensor<2x5x4x4xf64>, tensor) outs(%83 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.addf %out, %90 : f64 + linalg.yield %91 : f64 + } -> tensor<2x4x4x4xf64> + %86 = polygeist.submap(%0, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %87 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%79, %82, %85 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%86 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %90 = arith.addf %in, %in_0 : f64 + %91 = arith.addf %90, %in_1 : f64 + %92 = arith.addf %out, %91 : f64 + linalg.yield %92 : f64 + } -> tensor + %88 = polygeist.submapInverse(%0, %87, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %89 = bufferization.to_memref %88 : memref + memref.copy %89, %arg6 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/diffusion_apply_3d_stage_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/diffusion_apply_3d_stage_sliced/match_report.txt new file mode 100644 index 000000000000..168152550fda --- /dev/null +++ b/issues/mfem_c_kernels/match_results/diffusion_apply_3d_stage_sliced/match_report.txt @@ -0,0 +1,23 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/diffusion_apply_3d_stage_sliced/debufferized.mlir == + match body#[0, 1] cublasGemmFor1x1Conv + match body#[2, 3] cublasGemmFor1x1Conv + match body#[4, 5] cublasGemmFor1x1Conv + match body#[6, 7] cublasGemmFor1x1Conv + match body#[8, 9] cublasGemmFor1x1Conv + match body#[10, 11] cublasGemmFor1x1Conv + match body#[12, 13] cublasGemmFor1x1Conv + match body#[14, 15] cublasGemmFor1x1Conv + no_match body#16 ? + no_match body#17 ? + no_match body#18 ? + no_match body#19 ? + no_match body#20 ? + no_match body#21 ? + match body#[22, 23] cublasGemmFor1x1Conv + match body#[24, 25] cublasGemmFor1x1Conv + match body#[26, 27] cublasGemmFor1x1Conv + match body#[28, 29] cublasGemmFor1x1Conv + match body#[30, 31] cublasGemmFor1x1Conv + match body#[32, 33] cublasGemmFor1x1Conv + no_match body#34 ? + total: 14 matched / 21 bodies diff --git a/issues/mfem_c_kernels/match_results/diffusion_apply_3d_stage_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/diffusion_apply_3d_stage_sliced/matched.mlir new file mode 100644 index 000000000000..cb81322338f8 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/diffusion_apply_3d_stage_sliced/matched.mlir @@ -0,0 +1,231 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 750)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 125)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 250)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 375)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 500)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 625)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_diffusion_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x4x4x4xf64> + %8 = tensor.empty() : tensor<2x4x4x4xf64> + %9 = tensor.empty() : tensor<2x4x4x4xf64> + %10 = tensor.empty() : tensor<2x5x4x4xf64> + %11 = tensor.empty() : tensor<2x5x4x4xf64> + %12 = tensor.empty() : tensor<2x5x4x4xf64> + %13 = tensor.empty() : tensor<2x5x5x4xf64> + %14 = tensor.empty() : tensor<2x5x5x4xf64> + %15 = tensor.empty() : tensor<2x5x5x4xf64> + %16 = tensor.empty() : tensor<2x5x5x5xf64> + %17 = tensor.empty() : tensor<2x5x5x5xf64> + %18 = tensor.empty() : tensor<2x5x5x5xf64> + %19 = tensor.empty() : tensor<2x4x5x5xf64> + %20 = tensor.empty() : tensor<2x4x5x5xf64> + %21 = tensor.empty() : tensor<2x4x5x5xf64> + %22 = tensor.empty() : tensor<2x4x4x5xf64> + %23 = tensor.empty() : tensor<2x4x4x5xf64> + %25 = polygeist.submap(%6, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %26 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v23_contract_27_tc2 = tensor.cast %23 : tensor<2x4x4x5xf64> to tensor + + %v27_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%26, %25, %v23_contract_27_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %27 = tensor.cast %v27_tdyn : tensor to tensor<2x4x4x5xf64> + %29 = polygeist.submap(%5, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %30 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v22_contract_31_tc2 = tensor.cast %22 : tensor<2x4x4x5xf64> to tensor + + %v31_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%30, %29, %v22_contract_31_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %31 = tensor.cast %v31_tdyn : tensor to tensor<2x4x4x5xf64> + %33 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v31_contract_34_tc0 = tensor.cast %31 : tensor<2x4x4x5xf64> to tensor + + %v21_contract_34_tc2 = tensor.cast %21 : tensor<2x4x5x5xf64> to tensor + + %v34_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v31_contract_34_tc0, %33, %v21_contract_34_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %34 = tensor.cast %v34_tdyn : tensor to tensor<2x4x5x5xf64> + %36 = polygeist.submap(%5, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v27_contract_37_tc0 = tensor.cast %27 : tensor<2x4x4x5xf64> to tensor + + %v20_contract_37_tc2 = tensor.cast %20 : tensor<2x4x5x5xf64> to tensor + + %v37_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v27_contract_37_tc0, %36, %v20_contract_37_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %37 = tensor.cast %v37_tdyn : tensor to tensor<2x4x5x5xf64> + %39 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v27_contract_40_tc0 = tensor.cast %27 : tensor<2x4x4x5xf64> to tensor + + %v19_contract_40_tc2 = tensor.cast %19 : tensor<2x4x5x5xf64> to tensor + + %v40_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v27_contract_40_tc0, %39, %v19_contract_40_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %40 = tensor.cast %v40_tdyn : tensor to tensor<2x4x5x5xf64> + %42 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v34_contract_43_tc0 = tensor.cast %34 : tensor<2x4x5x5xf64> to tensor + + %v18_contract_43_tc2 = tensor.cast %18 : tensor<2x5x5x5xf64> to tensor + + %v43_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v34_contract_43_tc0, %42, %v18_contract_43_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %43 = tensor.cast %v43_tdyn : tensor to tensor<2x5x5x5xf64> + %45 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v37_contract_46_tc0 = tensor.cast %37 : tensor<2x4x5x5xf64> to tensor + + %v17_contract_46_tc2 = tensor.cast %17 : tensor<2x5x5x5xf64> to tensor + + %v46_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v37_contract_46_tc0, %45, %v17_contract_46_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %46 = tensor.cast %v46_tdyn : tensor to tensor<2x5x5x5xf64> + %48 = polygeist.submap(%5, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v40_contract_49_tc0 = tensor.cast %40 : tensor<2x4x5x5xf64> to tensor + + %v16_contract_49_tc2 = tensor.cast %16 : tensor<2x5x5x5xf64> to tensor + + %v49_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v40_contract_49_tc0, %48, %v16_contract_49_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %49 = tensor.cast %v49_tdyn : tensor to tensor<2x5x5x5xf64> + %50 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%15 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %51 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %52 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %53 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %54 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%52, %43, %53, %46, %54, %49, %51 : tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor) outs(%50 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.mulf %in_1, %in_2 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_3, %in_4 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_5 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor<2x5x5x4xf64> + %56 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%14 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %57 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %58 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %59 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %60 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %61 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%58, %43, %59, %46, %60, %49, %57 : tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor) outs(%56 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.mulf %in_1, %in_2 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_3, %in_4 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_5 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor<2x5x5x4xf64> + %62 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%13 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %63 = polygeist.submap(%4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %64 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %65 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %66 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (tensor, index, index, index, index, index) -> tensor + %67 = linalg.generic {doc = "", indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%64, %43, %65, %46, %66, %49, %63 : tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor, tensor<2x5x5x5xf64>, tensor) outs(%62 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %out: f64): + %90 = arith.mulf %in, %in_0 : f64 + %91 = arith.mulf %in_1, %in_2 : f64 + %92 = arith.addf %90, %91 : f64 + %93 = arith.mulf %in_3, %in_4 : f64 + %94 = arith.addf %92, %93 : f64 + %95 = arith.mulf %94, %in_5 : f64 + %96 = arith.addf %out, %95 : f64 + linalg.yield %96 : f64 + } -> tensor<2x5x5x4xf64> + %69 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %v55_contract_70_tc0 = tensor.cast %55 : tensor<2x5x5x4xf64> to tensor + + %v12_contract_70_tc2 = tensor.cast %12 : tensor<2x5x4x4xf64> to tensor + + %v70_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v55_contract_70_tc0, %69, %v12_contract_70_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %70 = tensor.cast %v70_tdyn : tensor to tensor<2x5x4x4xf64> + %72 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %v61_contract_73_tc0 = tensor.cast %61 : tensor<2x5x5x4xf64> to tensor + + %v11_contract_73_tc2 = tensor.cast %11 : tensor<2x5x4x4xf64> to tensor + + %v73_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v61_contract_73_tc0, %72, %v11_contract_73_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %73 = tensor.cast %v73_tdyn : tensor to tensor<2x5x4x4xf64> + %75 = polygeist.submap(%4, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %v67_contract_76_tc0 = tensor.cast %67 : tensor<2x5x5x4xf64> to tensor + + %v10_contract_76_tc2 = tensor.cast %10 : tensor<2x5x4x4xf64> to tensor + + %v76_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v67_contract_76_tc0, %75, %v10_contract_76_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %76 = tensor.cast %v76_tdyn : tensor to tensor<2x5x4x4xf64> + %78 = polygeist.submap(%4, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %v70_contract_79_tc0 = tensor.cast %70 : tensor<2x5x4x4xf64> to tensor + + %v9_contract_79_tc2 = tensor.cast %9 : tensor<2x4x4x4xf64> to tensor + + %v79_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v70_contract_79_tc0, %78, %v9_contract_79_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %79 = tensor.cast %v79_tdyn : tensor to tensor<2x4x4x4xf64> + %81 = polygeist.submap(%4, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %v73_contract_82_tc0 = tensor.cast %73 : tensor<2x5x4x4xf64> to tensor + + %v8_contract_82_tc2 = tensor.cast %8 : tensor<2x4x4x4xf64> to tensor + + %v82_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v73_contract_82_tc0, %81, %v8_contract_82_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %82 = tensor.cast %v82_tdyn : tensor to tensor<2x4x4x4xf64> + %84 = polygeist.submap(%3, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %v76_contract_85_tc0 = tensor.cast %76 : tensor<2x5x4x4xf64> to tensor + + %v7_contract_85_tc2 = tensor.cast %7 : tensor<2x4x4x4xf64> to tensor + + %v85_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v76_contract_85_tc0, %84, %v7_contract_85_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %85 = tensor.cast %v85_tdyn : tensor to tensor<2x4x4x4xf64> + %86 = polygeist.submap(%0, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, index, index, index, index) -> tensor + %87 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%79, %82, %85 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%86 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %90 = arith.addf %in, %in_0 : f64 + %91 = arith.addf %90, %in_1 : f64 + %92 = arith.addf %out, %91 : f64 + linalg.yield %92 : f64 + } -> tensor + %88 = polygeist.submapInverse(%0, %87, %c2, %c4, %c4, %c4) {map = #map19} : (tensor, tensor, index, index, index, index) -> tensor + %89 = bufferization.to_memref %88 : memref + memref.copy %89, %arg6 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/divdiv_apply_2d_stage_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/divdiv_apply_2d_stage_sliced/debufferized.mlir new file mode 100644 index 000000000000..ce012140ace0 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/divdiv_apply_2d_stage_sliced/debufferized.mlir @@ -0,0 +1,153 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4 + d0 * 24)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 3)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 3)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 3 + d0 * 24 + 12)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 25 + d1 * 5)> +#map12 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map13 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map14 = affine_map<(d0, d1, d2) -> (d2 + d1 * 4 + d0 * 24)> +#map15 = affine_map<(d0, d1, d2) -> (d2 + d1 * 3 + d0 * 24 + 12)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_divdiv_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x4x3xf64> + %8 = tensor.empty() : tensor<2x3x4xf64> + %9 = tensor.empty() : tensor<2x5x3xf64> + %10 = tensor.empty() : tensor<2x5x4xf64> + %11 = tensor.empty() : tensor<2x5x5xf64> + %12 = tensor.empty() : tensor<2x5x5xf64> + %13 = tensor.empty() : tensor<2x4x5xf64> + %14 = tensor.empty() : tensor<2x3x5xf64> + %15 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%14 : tensor<2x3x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x3x5xf64> + %16 = polygeist.submap(%4, %c2, %c3, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %17 = polygeist.submap(%1, %c2, %c3, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%17, %16 : tensor, tensor) outs(%15 : tensor<2x3x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %50 = arith.mulf %in, %in_0 : f64 + %51 = arith.addf %out, %50 : f64 + linalg.yield %51 : f64 + } -> tensor<2x3x5xf64> + %19 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5xf64> + %20 = polygeist.submap(%6, %c2, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index) -> tensor + %21 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%18, %20 : tensor<2x3x5xf64>, tensor) outs(%19 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %50 = arith.mulf %in, %in_0 : f64 + %51 = arith.addf %out, %50 : f64 + linalg.yield %51 : f64 + } -> tensor<2x5x5xf64> + %22 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%13 : tensor<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5xf64> + %23 = polygeist.submap(%6, %c2, %c4, %c5, %c3) {map = #map7} : (tensor, index, index, index, index) -> tensor + %24 = polygeist.submap(%1, %c2, %c4, %c5, %c3) {map = #map8} : (tensor, index, index, index, index) -> tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%24, %23 : tensor, tensor) outs(%22 : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %50 = arith.mulf %in, %in_0 : f64 + %51 = arith.addf %out, %50 : f64 + linalg.yield %51 : f64 + } -> tensor<2x4x5xf64> + %26 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5xf64> + %27 = polygeist.submap(%4, %c2, %c5, %c5, %c4) {map = #map9} : (tensor, index, index, index, index) -> tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%25, %27 : tensor<2x4x5xf64>, tensor) outs(%26 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %50 = arith.mulf %in, %in_0 : f64 + %51 = arith.addf %out, %50 : f64 + linalg.yield %51 : f64 + } -> tensor<2x5x5xf64> + %29 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4xf64> + %30 = polygeist.submap(%3, %c2, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index) -> tensor + %31 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index) -> tensor + %32 = linalg.generic {doc = "", indexing_maps = [#map3, #map12, #map12, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%31, %21, %28, %30 : tensor, tensor<2x5x5xf64>, tensor<2x5x5xf64>, tensor) outs(%29 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %50 = arith.addf %in_0, %in_1 : f64 + %51 = arith.mulf %in, %50 : f64 + %52 = arith.mulf %51, %in_2 : f64 + %53 = arith.addf %out, %52 : f64 + linalg.yield %53 : f64 + } -> tensor<2x5x4xf64> + %33 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor<2x3x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x3x4xf64> + %34 = polygeist.submap(%5, %c2, %c3, %c4, %c5) {map = #map13} : (tensor, index, index, index, index) -> tensor + %35 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%32, %34 : tensor<2x5x4xf64>, tensor) outs(%33 : tensor<2x3x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %50 = arith.mulf %in, %in_0 : f64 + %51 = arith.addf %out, %50 : f64 + linalg.yield %51 : f64 + } -> tensor<2x3x4xf64> + %36 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x5x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x3xf64> + %37 = polygeist.submap(%5, %c2, %c5, %c3, %c5) {map = #map10} : (tensor, index, index, index, index) -> tensor + %38 = polygeist.submap(%2, %c2, %c5, %c3, %c5) {map = #map11} : (tensor, index, index, index, index) -> tensor + %39 = linalg.generic {doc = "", indexing_maps = [#map3, #map12, #map12, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%38, %21, %28, %37 : tensor, tensor<2x5x5xf64>, tensor<2x5x5xf64>, tensor) outs(%36 : tensor<2x5x3xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %50 = arith.addf %in_0, %in_1 : f64 + %51 = arith.mulf %in, %50 : f64 + %52 = arith.mulf %51, %in_2 : f64 + %53 = arith.addf %out, %52 : f64 + linalg.yield %53 : f64 + } -> tensor<2x5x3xf64> + %40 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%7 : tensor<2x4x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x3xf64> + %41 = polygeist.submap(%3, %c2, %c4, %c3, %c5) {map = #map13} : (tensor, index, index, index, index) -> tensor + %42 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%39, %41 : tensor<2x5x3xf64>, tensor) outs(%40 : tensor<2x4x3xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %50 = arith.mulf %in, %in_0 : f64 + %51 = arith.addf %out, %50 : f64 + linalg.yield %51 : f64 + } -> tensor<2x4x3xf64> + %43 = polygeist.submap(%0, %c2, %c3, %c4) {map = #map14} : (tensor, index, index, index) -> tensor + %44 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%35 : tensor<2x3x4xf64>) outs(%43 : tensor) { + ^bb0(%in: f64, %out: f64): + %50 = arith.addf %out, %in : f64 + linalg.yield %50 : f64 + } -> tensor + %45 = polygeist.submapInverse(%0, %44, %c2, %c3, %c4) {map = #map14} : (tensor, tensor, index, index, index) -> tensor + %46 = polygeist.submap(%45, %c2, %c4, %c3) {map = #map15} : (tensor, index, index, index) -> tensor + %47 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%42 : tensor<2x4x3xf64>) outs(%46 : tensor) { + ^bb0(%in: f64, %out: f64): + %50 = arith.addf %out, %in : f64 + linalg.yield %50 : f64 + } -> tensor + %48 = polygeist.submapInverse(%45, %47, %c2, %c4, %c3) {map = #map15} : (tensor, tensor, index, index, index) -> tensor + %49 = bufferization.to_memref %48 : memref + memref.copy %49, %arg6 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/divdiv_apply_2d_stage_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/divdiv_apply_2d_stage_sliced/match_report.txt new file mode 100644 index 000000000000..baa9042ad417 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/divdiv_apply_2d_stage_sliced/match_report.txt @@ -0,0 +1,14 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/divdiv_apply_2d_stage_sliced/debufferized.mlir == + match body#[0, 1] cutensornetContraction2_f64 + match body#[2, 3] cutensornetContraction2_f64 + match body#[4, 5] cutensornetContraction2_f64 + match body#[6, 7] cutensornetContraction2_f64 + no_match body#8 ? + no_match body#9 ? + match body#[10, 11] cutensornetContraction2_f64 + no_match body#12 ? + no_match body#13 ? + match body#[14, 15] cutensornetContraction2_f64 + match body#[16] cublasDaxpby + match body#[17] cublasDaxpby + total: 8 matched / 12 bodies diff --git a/issues/mfem_c_kernels/match_results/divdiv_apply_2d_stage_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/divdiv_apply_2d_stage_sliced/matched.mlir new file mode 100644 index 000000000000..0004fc3e563c --- /dev/null +++ b/issues/mfem_c_kernels/match_results/divdiv_apply_2d_stage_sliced/matched.mlir @@ -0,0 +1,143 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4 + d0 * 24)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 3)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 3)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 3 + d0 * 24 + 12)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 25 + d1 * 5)> +#map12 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map13 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map14 = affine_map<(d0, d1, d2) -> (d2 + d1 * 4 + d0 * 24)> +#map15 = affine_map<(d0, d1, d2) -> (d2 + d1 * 3 + d0 * 24 + 12)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_divdiv_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x4x3xf64> + %8 = tensor.empty() : tensor<2x3x4xf64> + %9 = tensor.empty() : tensor<2x5x3xf64> + %10 = tensor.empty() : tensor<2x5x4xf64> + %11 = tensor.empty() : tensor<2x5x5xf64> + %12 = tensor.empty() : tensor<2x5x5xf64> + %13 = tensor.empty() : tensor<2x4x5xf64> + %14 = tensor.empty() : tensor<2x3x5xf64> + %16 = polygeist.submap(%4, %c2, %c3, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %17 = polygeist.submap(%1, %c2, %c3, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v17_contract_18_tc0 = tensor.cast %17 : tensor to tensor<*xf64> + + %v16_contract_18_tc1 = tensor.cast %16 : tensor to tensor<*xf64> + + %v14_contract_18_tc2 = tensor.cast %14 : tensor<2x3x5xf64> to tensor<*xf64> + + %v18_tdyn = kernel.launch @cutensornetContraction2_f64(%v17_contract_18_tc0, %v16_contract_18_tc1, %v14_contract_18_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %18 = tensor.cast %v18_tdyn : tensor<*xf64> to tensor<2x3x5xf64> + %20 = polygeist.submap(%6, %c2, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index) -> tensor + %v18_contract_21_tc0 = tensor.cast %18 : tensor<2x3x5xf64> to tensor<*xf64> + + %v20_contract_21_tc1 = tensor.cast %20 : tensor to tensor<*xf64> + + %v12_contract_21_tc2 = tensor.cast %12 : tensor<2x5x5xf64> to tensor<*xf64> + + %v21_tdyn = kernel.launch @cutensornetContraction2_f64(%v18_contract_21_tc0, %v20_contract_21_tc1, %v12_contract_21_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %21 = tensor.cast %v21_tdyn : tensor<*xf64> to tensor<2x5x5xf64> + %23 = polygeist.submap(%6, %c2, %c4, %c5, %c3) {map = #map7} : (tensor, index, index, index, index) -> tensor + %24 = polygeist.submap(%1, %c2, %c4, %c5, %c3) {map = #map8} : (tensor, index, index, index, index) -> tensor + %v24_contract_25_tc0 = tensor.cast %24 : tensor to tensor<*xf64> + + %v23_contract_25_tc1 = tensor.cast %23 : tensor to tensor<*xf64> + + %v13_contract_25_tc2 = tensor.cast %13 : tensor<2x4x5xf64> to tensor<*xf64> + + %v25_tdyn = kernel.launch @cutensornetContraction2_f64(%v24_contract_25_tc0, %v23_contract_25_tc1, %v13_contract_25_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %25 = tensor.cast %v25_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %27 = polygeist.submap(%4, %c2, %c5, %c5, %c4) {map = #map9} : (tensor, index, index, index, index) -> tensor + %v25_contract_28_tc0 = tensor.cast %25 : tensor<2x4x5xf64> to tensor<*xf64> + + %v27_contract_28_tc1 = tensor.cast %27 : tensor to tensor<*xf64> + + %v11_contract_28_tc2 = tensor.cast %11 : tensor<2x5x5xf64> to tensor<*xf64> + + %v28_tdyn = kernel.launch @cutensornetContraction2_f64(%v25_contract_28_tc0, %v27_contract_28_tc1, %v11_contract_28_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %28 = tensor.cast %v28_tdyn : tensor<*xf64> to tensor<2x5x5xf64> + %29 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4xf64> + %30 = polygeist.submap(%3, %c2, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index) -> tensor + %31 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map11} : (tensor, index, index, index, index) -> tensor + %32 = linalg.generic {doc = "", indexing_maps = [#map3, #map12, #map12, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%31, %21, %28, %30 : tensor, tensor<2x5x5xf64>, tensor<2x5x5xf64>, tensor) outs(%29 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %50 = arith.addf %in_0, %in_1 : f64 + %51 = arith.mulf %in, %50 : f64 + %52 = arith.mulf %51, %in_2 : f64 + %53 = arith.addf %out, %52 : f64 + linalg.yield %53 : f64 + } -> tensor<2x5x4xf64> + %34 = polygeist.submap(%5, %c2, %c3, %c4, %c5) {map = #map13} : (tensor, index, index, index, index) -> tensor + %v32_contract_35_tc0 = tensor.cast %32 : tensor<2x5x4xf64> to tensor<*xf64> + + %v34_contract_35_tc1 = tensor.cast %34 : tensor to tensor<*xf64> + + %v8_contract_35_tc2 = tensor.cast %8 : tensor<2x3x4xf64> to tensor<*xf64> + + %v35_tdyn = kernel.launch @cutensornetContraction2_f64(%v32_contract_35_tc0, %v34_contract_35_tc1, %v8_contract_35_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %35 = tensor.cast %v35_tdyn : tensor<*xf64> to tensor<2x3x4xf64> + %36 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x5x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x3xf64> + %37 = polygeist.submap(%5, %c2, %c5, %c3, %c5) {map = #map10} : (tensor, index, index, index, index) -> tensor + %38 = polygeist.submap(%2, %c2, %c5, %c3, %c5) {map = #map11} : (tensor, index, index, index, index) -> tensor + %39 = linalg.generic {doc = "", indexing_maps = [#map3, #map12, #map12, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%38, %21, %28, %37 : tensor, tensor<2x5x5xf64>, tensor<2x5x5xf64>, tensor) outs(%36 : tensor<2x5x3xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %50 = arith.addf %in_0, %in_1 : f64 + %51 = arith.mulf %in, %50 : f64 + %52 = arith.mulf %51, %in_2 : f64 + %53 = arith.addf %out, %52 : f64 + linalg.yield %53 : f64 + } -> tensor<2x5x3xf64> + %41 = polygeist.submap(%3, %c2, %c4, %c3, %c5) {map = #map13} : (tensor, index, index, index, index) -> tensor + %v39_contract_42_tc0 = tensor.cast %39 : tensor<2x5x3xf64> to tensor<*xf64> + + %v41_contract_42_tc1 = tensor.cast %41 : tensor to tensor<*xf64> + + %v7_contract_42_tc2 = tensor.cast %7 : tensor<2x4x3xf64> to tensor<*xf64> + + %v42_tdyn = kernel.launch @cutensornetContraction2_f64(%v39_contract_42_tc0, %v41_contract_42_tc1, %v7_contract_42_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %42 = tensor.cast %v42_tdyn : tensor<*xf64> to tensor<2x4x3xf64> + %43 = polygeist.submap(%0, %c2, %c3, %c4) {map = #map14} : (tensor, index, index, index) -> tensor + %v35_tc0 = tensor.cast %35 : tensor<2x3x4xf64> to tensor + + %44 = kernel.launch @cublasDaxpby(%v35_tc0, %43) : (tensor, tensor) -> tensor + %45 = polygeist.submapInverse(%0, %44, %c2, %c3, %c4) {map = #map14} : (tensor, tensor, index, index, index) -> tensor + %46 = polygeist.submap(%45, %c2, %c4, %c3) {map = #map15} : (tensor, index, index, index) -> tensor + %v42_tc0 = tensor.cast %42 : tensor<2x4x3xf64> to tensor + + %47 = kernel.launch @cublasDaxpby(%v42_tc0, %46) : (tensor, tensor) -> tensor + %48 = polygeist.submapInverse(%45, %47, %c2, %c4, %c3) {map = #map15} : (tensor, tensor, index, index, index) -> tensor + %49 = bufferization.to_memref %48 : memref + memref.copy %49, %arg6 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/divdiv_apply_3d_stage_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/divdiv_apply_3d_stage_sliced/debufferized.mlir new file mode 100644 index 000000000000..4ca2cc60cd8b --- /dev/null +++ b/issues/mfem_c_kernels/match_results/divdiv_apply_3d_stage_sliced/debufferized.mlir @@ -0,0 +1,263 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 108)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 125 + d1 * 25 + d2 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 4 + d0 * 108)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_divdiv_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x5x4x4xf64> + %8 = tensor.empty() : tensor<2x5x4x4xf64> + %9 = tensor.empty() : tensor<2x5x4x4xf64> + %10 = tensor.empty() : tensor<2x5x5x4xf64> + %11 = tensor.empty() : tensor<2x5x5x4xf64> + %12 = tensor.empty() : tensor<2x5x5x4xf64> + %13 = tensor.empty() : tensor<2x5x5x5xf64> + %14 = tensor.empty() : tensor<2x5x5x5xf64> + %15 = tensor.empty() : tensor<2x5x5x5xf64> + %16 = tensor.empty() : tensor<2x4x5x5xf64> + %17 = tensor.empty() : tensor<2x4x5x5xf64> + %18 = tensor.empty() : tensor<2x4x5x5xf64> + %19 = tensor.empty() : tensor<2x4x4x5xf64> + %20 = tensor.empty() : tensor<2x4x4x5xf64> + %21 = tensor.empty() : tensor<2x4x4x5xf64> + %22 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%21 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %23 = polygeist.submap(%4, %c2, %c3, %c3, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %24 = polygeist.submap(%1, %c2, %c3, %c3, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%24, %23 : tensor, tensor) outs(%22 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x4x5xf64> + %26 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%18 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %27 = polygeist.submap(%6, %c2, %c3, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%25, %27 : tensor<2x4x4x5xf64>, tensor) outs(%26 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x5x5xf64> + %29 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%15 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %30 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %31 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%28, %30 : tensor<2x4x5x5xf64>, tensor) outs(%29 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x5x5xf64> + %32 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%20 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %33 = polygeist.submap(%6, %c2, %c3, %c4, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %34 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c3) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %35 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%34, %33 : tensor, tensor) outs(%32 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x4x5xf64> + %36 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%17 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %37 = polygeist.submap(%4, %c2, %c3, %c5, %c5, %c4) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %38 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%35, %37 : tensor<2x4x4x5xf64>, tensor) outs(%36 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x5x5xf64> + %39 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%14 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %40 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %41 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%38, %40 : tensor<2x4x5x5xf64>, tensor) outs(%39 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x5x5xf64> + %42 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%19 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %43 = polygeist.submap(%6, %c2, %c4, %c3, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %44 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c3) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %45 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%44, %43 : tensor, tensor) outs(%42 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x4x5xf64> + %46 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%16 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %47 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %48 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%45, %47 : tensor<2x4x4x5xf64>, tensor) outs(%46 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x4x5x5xf64> + %49 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%13 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %50 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %51 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%48, %50 : tensor<2x4x5x5xf64>, tensor) outs(%49 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x5x5xf64> + %52 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %53 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %54 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%54, %31, %41, %51, %53 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%52 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %56 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %57 = polygeist.submap(%5, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %58 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %59 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%58, %31, %41, %51, %57 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%56 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %60 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %61 = polygeist.submap(%5, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %62 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%62, %31, %41, %51, %61 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%60 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %64 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %65 = polygeist.submap(%5, %c2, %c5, %c3, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %66 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%55, %65 : tensor<2x5x5x4xf64>, tensor) outs(%64 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x4x4xf64> + %67 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %68 = polygeist.submap(%3, %c2, %c5, %c4, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %69 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%59, %68 : tensor<2x5x5x4xf64>, tensor) outs(%67 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x4x4xf64> + %70 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%7 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %71 = polygeist.submap(%5, %c2, %c5, %c3, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %72 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%63, %71 : tensor<2x5x5x4xf64>, tensor) outs(%70 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor<2x5x4x4xf64> + %73 = polygeist.submap(%5, %c2, %c3, %c3, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %74 = polygeist.submap(%0, %c2, %c3, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %75 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%66, %73 : tensor<2x5x4x4xf64>, tensor) outs(%74 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %76 = polygeist.submapInverse(%0, %75, %c2, %c3, %c3, %c4, %c5) {map = #map19} : (tensor, tensor, index, index, index, index, index) -> tensor + %77 = polygeist.submap(%5, %c2, %c3, %c4, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %78 = polygeist.submap(%76, %c2, %c3, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %79 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%69, %77 : tensor<2x5x4x4xf64>, tensor) outs(%78 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %80 = polygeist.submapInverse(%76, %79, %c2, %c3, %c4, %c3, %c5) {map = #map20} : (tensor, tensor, index, index, index, index, index) -> tensor + %81 = polygeist.submap(%3, %c2, %c4, %c3, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %82 = polygeist.submap(%80, %c2, %c4, %c3, %c3, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %83 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%72, %81 : tensor<2x5x4x4xf64>, tensor) outs(%82 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %84 = polygeist.submapInverse(%80, %83, %c2, %c4, %c3, %c3, %c5) {map = #map21} : (tensor, tensor, index, index, index, index, index) -> tensor + %85 = bufferization.to_memref %84 : memref + memref.copy %85, %arg6 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/divdiv_apply_3d_stage_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/divdiv_apply_3d_stage_sliced/match_report.txt new file mode 100644 index 000000000000..247e31ac6629 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/divdiv_apply_3d_stage_sliced/match_report.txt @@ -0,0 +1,23 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/divdiv_apply_3d_stage_sliced/debufferized.mlir == + match body#[0, 1] cublasGemmFor1x1Conv + match body#[2, 3] cublasGemmFor1x1Conv + match body#[4, 5] cublasGemmFor1x1Conv + match body#[6, 7] cublasGemmFor1x1Conv + match body#[8, 9] cublasGemmFor1x1Conv + match body#[10, 11] cublasGemmFor1x1Conv + match body#[12, 13] cublasGemmFor1x1Conv + match body#[14, 15] cublasGemmFor1x1Conv + match body#[16, 17] cublasGemmFor1x1Conv + no_match body#18 ? + no_match body#19 ? + no_match body#20 ? + no_match body#21 ? + no_match body#22 ? + no_match body#23 ? + match body#[24, 25] cublasGemmFor1x1Conv + match body#[26, 27] cublasGemmFor1x1Conv + match body#[28, 29] cublasGemmFor1x1Conv + no_match body#30 ? + no_match body#31 ? + no_match body#32 ? + total: 12 matched / 21 bodies diff --git a/issues/mfem_c_kernels/match_results/divdiv_apply_3d_stage_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/divdiv_apply_3d_stage_sliced/matched.mlir new file mode 100644 index 000000000000..28f89406c9de --- /dev/null +++ b/issues/mfem_c_kernels/match_results/divdiv_apply_3d_stage_sliced/matched.mlir @@ -0,0 +1,221 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 108)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 125 + d1 * 25 + d2 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 4 + d0 * 108)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_divdiv_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = bufferization.to_tensor %arg1 : memref + %6 = bufferization.to_tensor %arg0 : memref + %7 = tensor.empty() : tensor<2x5x4x4xf64> + %8 = tensor.empty() : tensor<2x5x4x4xf64> + %9 = tensor.empty() : tensor<2x5x4x4xf64> + %10 = tensor.empty() : tensor<2x5x5x4xf64> + %11 = tensor.empty() : tensor<2x5x5x4xf64> + %12 = tensor.empty() : tensor<2x5x5x4xf64> + %13 = tensor.empty() : tensor<2x5x5x5xf64> + %14 = tensor.empty() : tensor<2x5x5x5xf64> + %15 = tensor.empty() : tensor<2x5x5x5xf64> + %16 = tensor.empty() : tensor<2x4x5x5xf64> + %17 = tensor.empty() : tensor<2x4x5x5xf64> + %18 = tensor.empty() : tensor<2x4x5x5xf64> + %19 = tensor.empty() : tensor<2x4x4x5xf64> + %20 = tensor.empty() : tensor<2x4x4x5xf64> + %21 = tensor.empty() : tensor<2x4x4x5xf64> + %23 = polygeist.submap(%4, %c2, %c3, %c3, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %24 = polygeist.submap(%1, %c2, %c3, %c3, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v21_contract_25_tc2 = tensor.cast %21 : tensor<2x4x4x5xf64> to tensor + + %v25_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%24, %23, %v21_contract_25_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %25 = tensor.cast %v25_tdyn : tensor to tensor<2x4x4x5xf64> + %27 = polygeist.submap(%6, %c2, %c3, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v25_contract_28_tc0 = tensor.cast %25 : tensor<2x4x4x5xf64> to tensor + + %v18_contract_28_tc2 = tensor.cast %18 : tensor<2x4x5x5xf64> to tensor + + %v28_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v25_contract_28_tc0, %27, %v18_contract_28_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %28 = tensor.cast %v28_tdyn : tensor to tensor<2x4x5x5xf64> + %30 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v28_contract_31_tc0 = tensor.cast %28 : tensor<2x4x5x5xf64> to tensor + + %v15_contract_31_tc2 = tensor.cast %15 : tensor<2x5x5x5xf64> to tensor + + %v31_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v28_contract_31_tc0, %30, %v15_contract_31_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %31 = tensor.cast %v31_tdyn : tensor to tensor<2x5x5x5xf64> + %33 = polygeist.submap(%6, %c2, %c3, %c4, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %34 = polygeist.submap(%1, %c2, %c3, %c4, %c5, %c3) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %v20_contract_35_tc2 = tensor.cast %20 : tensor<2x4x4x5xf64> to tensor + + %v35_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%34, %33, %v20_contract_35_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %35 = tensor.cast %v35_tdyn : tensor to tensor<2x4x4x5xf64> + %37 = polygeist.submap(%4, %c2, %c3, %c5, %c5, %c4) {map = #map11} : (tensor, index, index, index, index, index) -> tensor + %v35_contract_38_tc0 = tensor.cast %35 : tensor<2x4x4x5xf64> to tensor + + %v17_contract_38_tc2 = tensor.cast %17 : tensor<2x4x5x5xf64> to tensor + + %v38_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v35_contract_38_tc0, %37, %v17_contract_38_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %38 = tensor.cast %v38_tdyn : tensor to tensor<2x4x5x5xf64> + %40 = polygeist.submap(%6, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v38_contract_41_tc0 = tensor.cast %38 : tensor<2x4x5x5xf64> to tensor + + %v14_contract_41_tc2 = tensor.cast %14 : tensor<2x5x5x5xf64> to tensor + + %v41_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v38_contract_41_tc0, %40, %v14_contract_41_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %41 = tensor.cast %v41_tdyn : tensor to tensor<2x5x5x5xf64> + %43 = polygeist.submap(%6, %c2, %c4, %c3, %c5, %c3) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %44 = polygeist.submap(%1, %c2, %c4, %c3, %c5, %c3) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %v19_contract_45_tc2 = tensor.cast %19 : tensor<2x4x4x5xf64> to tensor + + %v45_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%44, %43, %v19_contract_45_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %45 = tensor.cast %v45_tdyn : tensor to tensor<2x4x4x5xf64> + %47 = polygeist.submap(%6, %c2, %c4, %c5, %c5, %c3) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v45_contract_48_tc0 = tensor.cast %45 : tensor<2x4x4x5xf64> to tensor + + %v16_contract_48_tc2 = tensor.cast %16 : tensor<2x4x5x5xf64> to tensor + + %v48_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v45_contract_48_tc0, %47, %v16_contract_48_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %48 = tensor.cast %v48_tdyn : tensor to tensor<2x4x5x5xf64> + %50 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %v48_contract_51_tc0 = tensor.cast %48 : tensor<2x4x5x5xf64> to tensor + + %v13_contract_51_tc2 = tensor.cast %13 : tensor<2x5x5x5xf64> to tensor + + %v51_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v48_contract_51_tc0, %50, %v13_contract_51_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %51 = tensor.cast %v51_tdyn : tensor to tensor<2x5x5x5xf64> + %52 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %53 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %54 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %55 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%54, %31, %41, %51, %53 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%52 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %56 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %57 = polygeist.submap(%5, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %58 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %59 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%58, %31, %41, %51, %57 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%56 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %60 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %61 = polygeist.submap(%5, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %62 = polygeist.submap(%2, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (tensor, index, index, index, index, index) -> tensor + %63 = linalg.generic {doc = "", indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%62, %31, %41, %51, %61 : tensor, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor<2x5x5x5xf64>, tensor) outs(%60 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %86 = arith.addf %in_0, %in_1 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %in, %87 : f64 + %89 = arith.mulf %88, %in_3 : f64 + %90 = arith.addf %out, %89 : f64 + linalg.yield %90 : f64 + } -> tensor<2x5x5x4xf64> + %65 = polygeist.submap(%5, %c2, %c5, %c3, %c4, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %v55_contract_66_tc0 = tensor.cast %55 : tensor<2x5x5x4xf64> to tensor + + %v9_contract_66_tc2 = tensor.cast %9 : tensor<2x5x4x4xf64> to tensor + + %v66_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v55_contract_66_tc0, %65, %v9_contract_66_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %66 = tensor.cast %v66_tdyn : tensor to tensor<2x5x4x4xf64> + %68 = polygeist.submap(%3, %c2, %c5, %c4, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %v59_contract_69_tc0 = tensor.cast %59 : tensor<2x5x5x4xf64> to tensor + + %v8_contract_69_tc2 = tensor.cast %8 : tensor<2x5x4x4xf64> to tensor + + %v69_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v59_contract_69_tc0, %68, %v8_contract_69_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %69 = tensor.cast %v69_tdyn : tensor to tensor<2x5x4x4xf64> + %71 = polygeist.submap(%5, %c2, %c5, %c3, %c3, %c5) {map = #map17} : (tensor, index, index, index, index, index) -> tensor + %v63_contract_72_tc0 = tensor.cast %63 : tensor<2x5x5x4xf64> to tensor + + %v7_contract_72_tc2 = tensor.cast %7 : tensor<2x5x4x4xf64> to tensor + + %v72_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v63_contract_72_tc0, %71, %v7_contract_72_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %72 = tensor.cast %v72_tdyn : tensor to tensor<2x5x4x4xf64> + %73 = polygeist.submap(%5, %c2, %c3, %c3, %c4, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %74 = polygeist.submap(%0, %c2, %c3, %c3, %c4, %c5) {map = #map19} : (tensor, index, index, index, index, index) -> tensor + %75 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%66, %73 : tensor<2x5x4x4xf64>, tensor) outs(%74 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %76 = polygeist.submapInverse(%0, %75, %c2, %c3, %c3, %c4, %c5) {map = #map19} : (tensor, tensor, index, index, index, index, index) -> tensor + %77 = polygeist.submap(%5, %c2, %c3, %c4, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %78 = polygeist.submap(%76, %c2, %c3, %c4, %c3, %c5) {map = #map20} : (tensor, index, index, index, index, index) -> tensor + %79 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%69, %77 : tensor<2x5x4x4xf64>, tensor) outs(%78 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %80 = polygeist.submapInverse(%76, %79, %c2, %c3, %c4, %c3, %c5) {map = #map20} : (tensor, tensor, index, index, index, index, index) -> tensor + %81 = polygeist.submap(%3, %c2, %c4, %c3, %c3, %c5) {map = #map18} : (tensor, index, index, index, index, index) -> tensor + %82 = polygeist.submap(%80, %c2, %c4, %c3, %c3, %c5) {map = #map21} : (tensor, index, index, index, index, index) -> tensor + %83 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%72, %81 : tensor<2x5x4x4xf64>, tensor) outs(%82 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %86 = arith.mulf %in, %in_0 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } -> tensor + %84 = polygeist.submapInverse(%80, %83, %c2, %c4, %c3, %c3, %c5) {map = #map21} : (tensor, tensor, index, index, index, index, index) -> tensor + %85 = bufferization.to_memref %84 : memref + memref.copy %85, %arg6 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/elasticity_qpoint_2d_scalarized/debufferized.mlir b/issues/mfem_c_kernels/match_results/elasticity_qpoint_2d_scalarized/debufferized.mlir new file mode 100644 index 000000000000..11fde53bb1ce --- /dev/null +++ b/issues/mfem_c_kernels/match_results/elasticity_qpoint_2d_scalarized/debufferized.mlir @@ -0,0 +1,158 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 25)> +#map1 = affine_map<(d0, d1) -> (d1 + d0 * 100)> +#map2 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 25)> +#map3 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 50)> +#map4 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 75)> +#map5 = affine_map<(d0, d1) -> (d0, d1)> +#map6 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_elasticity_qpoint_2d_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c25 = arith.constant 25 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = bufferization.to_tensor %arg0 : memref + %6 = polygeist.submap(%5, %c2, %c25) {map = #map} : (tensor, index, index) -> tensor + %7 = polygeist.submap(%4, %c2, %c25) {map = #map} : (tensor, index, index) -> tensor + %8 = polygeist.submap(%3, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %9 = polygeist.submap(%3, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %10 = polygeist.submap(%3, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %11 = polygeist.submap(%3, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %12 = polygeist.submap(%1, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %13 = polygeist.submap(%1, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %14 = polygeist.submap(%1, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %15 = polygeist.submap(%1, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %16 = polygeist.submap(%0, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %17 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5, #map5, #map5, #map5, #map5, #map6, #map5, #map5, #map5], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%8, %9, %10, %11, %12, %13, %14, %15, %2, %6, %7 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%16 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %out: f64): + %59 = arith.mulf %in, %in_2 : f64 + %60 = arith.mulf %in_0, %in_1 : f64 + %61 = arith.subf %59, %60 : f64 + %62 = arith.divf %in_2, %61 : f64 + %63 = arith.negf %in_0 : f64 + %64 = arith.divf %63, %61 : f64 + %65 = arith.addf %in_3, %in_6 : f64 + %66 = arith.mulf %in_7, %61 : f64 + %67 = arith.mulf %in_8, %62 : f64 + %68 = arith.mulf %67, %65 : f64 + %69 = arith.addf %in_3, %in_3 : f64 + %70 = arith.mulf %62, %69 : f64 + %71 = arith.addf %in_4, %in_5 : f64 + %72 = arith.mulf %64, %71 : f64 + %73 = arith.addf %70, %72 : f64 + %74 = arith.mulf %in_9, %73 : f64 + %75 = arith.addf %68, %74 : f64 + %76 = arith.mulf %66, %75 : f64 + linalg.yield %76 : f64 + } -> tensor + %18 = polygeist.submapInverse(%0, %17, %c2, %c25) {map = #map1} : (tensor, tensor, index, index) -> tensor + %19 = polygeist.submap(%5, %c2, %c25) {map = #map} : (tensor, index, index) -> tensor + %20 = polygeist.submap(%4, %c2, %c25) {map = #map} : (tensor, index, index) -> tensor + %21 = polygeist.submap(%3, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %22 = polygeist.submap(%3, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %23 = polygeist.submap(%3, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %24 = polygeist.submap(%3, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %25 = polygeist.submap(%1, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %26 = polygeist.submap(%1, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %27 = polygeist.submap(%1, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %28 = polygeist.submap(%1, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %29 = polygeist.submap(%18, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %30 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5, #map5, #map5, #map5, #map5, #map6, #map5, #map5, #map5], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%21, %22, %23, %24, %25, %26, %27, %28, %2, %19, %20 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%29 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %out: f64): + %59 = arith.mulf %in, %in_2 : f64 + %60 = arith.mulf %in_0, %in_1 : f64 + %61 = arith.subf %59, %60 : f64 + %62 = arith.divf %in_2, %61 : f64 + %63 = arith.negf %in_0 : f64 + %64 = arith.divf %63, %61 : f64 + %65 = arith.addf %in_3, %in_6 : f64 + %66 = arith.mulf %in_7, %61 : f64 + %67 = arith.mulf %in_8, %64 : f64 + %68 = arith.mulf %67, %65 : f64 + %69 = arith.addf %in_5, %in_4 : f64 + %70 = arith.mulf %62, %69 : f64 + %71 = arith.addf %in_6, %in_6 : f64 + %72 = arith.mulf %64, %71 : f64 + %73 = arith.addf %70, %72 : f64 + %74 = arith.mulf %in_9, %73 : f64 + %75 = arith.addf %68, %74 : f64 + %76 = arith.mulf %66, %75 : f64 + linalg.yield %76 : f64 + } -> tensor + %31 = polygeist.submapInverse(%18, %30, %c2, %c25) {map = #map3} : (tensor, tensor, index, index) -> tensor + %32 = polygeist.submap(%5, %c2, %c25) {map = #map} : (tensor, index, index) -> tensor + %33 = polygeist.submap(%4, %c2, %c25) {map = #map} : (tensor, index, index) -> tensor + %34 = polygeist.submap(%3, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %35 = polygeist.submap(%3, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %36 = polygeist.submap(%3, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %37 = polygeist.submap(%3, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %38 = polygeist.submap(%1, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %39 = polygeist.submap(%1, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %40 = polygeist.submap(%1, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %41 = polygeist.submap(%1, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %42 = polygeist.submap(%31, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %43 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5, #map5, #map5, #map5, #map5, #map6, #map5, #map5, #map5], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%34, %35, %36, %37, %38, %39, %40, %41, %2, %32, %33 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%42 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %out: f64): + %59 = arith.mulf %in, %in_2 : f64 + %60 = arith.mulf %in_0, %in_1 : f64 + %61 = arith.subf %59, %60 : f64 + %62 = arith.negf %in_1 : f64 + %63 = arith.divf %62, %61 : f64 + %64 = arith.divf %in, %61 : f64 + %65 = arith.addf %in_3, %in_6 : f64 + %66 = arith.mulf %in_7, %61 : f64 + %67 = arith.mulf %in_8, %63 : f64 + %68 = arith.mulf %67, %65 : f64 + %69 = arith.addf %in_3, %in_3 : f64 + %70 = arith.mulf %63, %69 : f64 + %71 = arith.addf %in_4, %in_5 : f64 + %72 = arith.mulf %64, %71 : f64 + %73 = arith.addf %70, %72 : f64 + %74 = arith.mulf %in_9, %73 : f64 + %75 = arith.addf %68, %74 : f64 + %76 = arith.mulf %66, %75 : f64 + linalg.yield %76 : f64 + } -> tensor + %44 = polygeist.submapInverse(%31, %43, %c2, %c25) {map = #map2} : (tensor, tensor, index, index) -> tensor + %45 = polygeist.submap(%5, %c2, %c25) {map = #map} : (tensor, index, index) -> tensor + %46 = polygeist.submap(%4, %c2, %c25) {map = #map} : (tensor, index, index) -> tensor + %47 = polygeist.submap(%3, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %48 = polygeist.submap(%3, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %49 = polygeist.submap(%3, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %50 = polygeist.submap(%3, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %51 = polygeist.submap(%1, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %52 = polygeist.submap(%1, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %53 = polygeist.submap(%1, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %54 = polygeist.submap(%1, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %55 = polygeist.submap(%44, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %56 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5, #map5, #map5, #map5, #map5, #map6, #map5, #map5, #map5], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%47, %48, %49, %50, %51, %52, %53, %54, %2, %45, %46 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%55 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %out: f64): + %59 = arith.mulf %in, %in_2 : f64 + %60 = arith.mulf %in_0, %in_1 : f64 + %61 = arith.subf %59, %60 : f64 + %62 = arith.negf %in_1 : f64 + %63 = arith.divf %62, %61 : f64 + %64 = arith.divf %in, %61 : f64 + %65 = arith.addf %in_3, %in_6 : f64 + %66 = arith.mulf %in_7, %61 : f64 + %67 = arith.mulf %in_8, %64 : f64 + %68 = arith.mulf %67, %65 : f64 + %69 = arith.addf %in_5, %in_4 : f64 + %70 = arith.mulf %63, %69 : f64 + %71 = arith.addf %in_6, %in_6 : f64 + %72 = arith.mulf %64, %71 : f64 + %73 = arith.addf %70, %72 : f64 + %74 = arith.mulf %in_9, %73 : f64 + %75 = arith.addf %68, %74 : f64 + %76 = arith.mulf %66, %75 : f64 + linalg.yield %76 : f64 + } -> tensor + %57 = polygeist.submapInverse(%44, %56, %c2, %c25) {map = #map4} : (tensor, tensor, index, index) -> tensor + %58 = bufferization.to_memref %57 : memref + memref.copy %58, %arg5 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/elasticity_qpoint_2d_scalarized/match_report.txt b/issues/mfem_c_kernels/match_results/elasticity_qpoint_2d_scalarized/match_report.txt new file mode 100644 index 000000000000..382c375615fc --- /dev/null +++ b/issues/mfem_c_kernels/match_results/elasticity_qpoint_2d_scalarized/match_report.txt @@ -0,0 +1,6 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/elasticity_qpoint_2d_scalarized/debufferized.mlir == + no_match body#0 ? + no_match body#1 ? + no_match body#2 ? + no_match body#3 ? + total: 0 matched / 4 bodies diff --git a/issues/mfem_c_kernels/match_results/elasticity_qpoint_2d_scalarized/matched.mlir b/issues/mfem_c_kernels/match_results/elasticity_qpoint_2d_scalarized/matched.mlir new file mode 100644 index 000000000000..11fde53bb1ce --- /dev/null +++ b/issues/mfem_c_kernels/match_results/elasticity_qpoint_2d_scalarized/matched.mlir @@ -0,0 +1,158 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 25)> +#map1 = affine_map<(d0, d1) -> (d1 + d0 * 100)> +#map2 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 25)> +#map3 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 50)> +#map4 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 75)> +#map5 = affine_map<(d0, d1) -> (d0, d1)> +#map6 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_elasticity_qpoint_2d_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c25 = arith.constant 25 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = bufferization.to_tensor %arg0 : memref + %6 = polygeist.submap(%5, %c2, %c25) {map = #map} : (tensor, index, index) -> tensor + %7 = polygeist.submap(%4, %c2, %c25) {map = #map} : (tensor, index, index) -> tensor + %8 = polygeist.submap(%3, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %9 = polygeist.submap(%3, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %10 = polygeist.submap(%3, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %11 = polygeist.submap(%3, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %12 = polygeist.submap(%1, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %13 = polygeist.submap(%1, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %14 = polygeist.submap(%1, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %15 = polygeist.submap(%1, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %16 = polygeist.submap(%0, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %17 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5, #map5, #map5, #map5, #map5, #map6, #map5, #map5, #map5], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%8, %9, %10, %11, %12, %13, %14, %15, %2, %6, %7 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%16 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %out: f64): + %59 = arith.mulf %in, %in_2 : f64 + %60 = arith.mulf %in_0, %in_1 : f64 + %61 = arith.subf %59, %60 : f64 + %62 = arith.divf %in_2, %61 : f64 + %63 = arith.negf %in_0 : f64 + %64 = arith.divf %63, %61 : f64 + %65 = arith.addf %in_3, %in_6 : f64 + %66 = arith.mulf %in_7, %61 : f64 + %67 = arith.mulf %in_8, %62 : f64 + %68 = arith.mulf %67, %65 : f64 + %69 = arith.addf %in_3, %in_3 : f64 + %70 = arith.mulf %62, %69 : f64 + %71 = arith.addf %in_4, %in_5 : f64 + %72 = arith.mulf %64, %71 : f64 + %73 = arith.addf %70, %72 : f64 + %74 = arith.mulf %in_9, %73 : f64 + %75 = arith.addf %68, %74 : f64 + %76 = arith.mulf %66, %75 : f64 + linalg.yield %76 : f64 + } -> tensor + %18 = polygeist.submapInverse(%0, %17, %c2, %c25) {map = #map1} : (tensor, tensor, index, index) -> tensor + %19 = polygeist.submap(%5, %c2, %c25) {map = #map} : (tensor, index, index) -> tensor + %20 = polygeist.submap(%4, %c2, %c25) {map = #map} : (tensor, index, index) -> tensor + %21 = polygeist.submap(%3, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %22 = polygeist.submap(%3, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %23 = polygeist.submap(%3, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %24 = polygeist.submap(%3, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %25 = polygeist.submap(%1, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %26 = polygeist.submap(%1, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %27 = polygeist.submap(%1, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %28 = polygeist.submap(%1, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %29 = polygeist.submap(%18, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %30 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5, #map5, #map5, #map5, #map5, #map6, #map5, #map5, #map5], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%21, %22, %23, %24, %25, %26, %27, %28, %2, %19, %20 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%29 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %out: f64): + %59 = arith.mulf %in, %in_2 : f64 + %60 = arith.mulf %in_0, %in_1 : f64 + %61 = arith.subf %59, %60 : f64 + %62 = arith.divf %in_2, %61 : f64 + %63 = arith.negf %in_0 : f64 + %64 = arith.divf %63, %61 : f64 + %65 = arith.addf %in_3, %in_6 : f64 + %66 = arith.mulf %in_7, %61 : f64 + %67 = arith.mulf %in_8, %64 : f64 + %68 = arith.mulf %67, %65 : f64 + %69 = arith.addf %in_5, %in_4 : f64 + %70 = arith.mulf %62, %69 : f64 + %71 = arith.addf %in_6, %in_6 : f64 + %72 = arith.mulf %64, %71 : f64 + %73 = arith.addf %70, %72 : f64 + %74 = arith.mulf %in_9, %73 : f64 + %75 = arith.addf %68, %74 : f64 + %76 = arith.mulf %66, %75 : f64 + linalg.yield %76 : f64 + } -> tensor + %31 = polygeist.submapInverse(%18, %30, %c2, %c25) {map = #map3} : (tensor, tensor, index, index) -> tensor + %32 = polygeist.submap(%5, %c2, %c25) {map = #map} : (tensor, index, index) -> tensor + %33 = polygeist.submap(%4, %c2, %c25) {map = #map} : (tensor, index, index) -> tensor + %34 = polygeist.submap(%3, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %35 = polygeist.submap(%3, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %36 = polygeist.submap(%3, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %37 = polygeist.submap(%3, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %38 = polygeist.submap(%1, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %39 = polygeist.submap(%1, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %40 = polygeist.submap(%1, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %41 = polygeist.submap(%1, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %42 = polygeist.submap(%31, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %43 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5, #map5, #map5, #map5, #map5, #map6, #map5, #map5, #map5], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%34, %35, %36, %37, %38, %39, %40, %41, %2, %32, %33 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%42 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %out: f64): + %59 = arith.mulf %in, %in_2 : f64 + %60 = arith.mulf %in_0, %in_1 : f64 + %61 = arith.subf %59, %60 : f64 + %62 = arith.negf %in_1 : f64 + %63 = arith.divf %62, %61 : f64 + %64 = arith.divf %in, %61 : f64 + %65 = arith.addf %in_3, %in_6 : f64 + %66 = arith.mulf %in_7, %61 : f64 + %67 = arith.mulf %in_8, %63 : f64 + %68 = arith.mulf %67, %65 : f64 + %69 = arith.addf %in_3, %in_3 : f64 + %70 = arith.mulf %63, %69 : f64 + %71 = arith.addf %in_4, %in_5 : f64 + %72 = arith.mulf %64, %71 : f64 + %73 = arith.addf %70, %72 : f64 + %74 = arith.mulf %in_9, %73 : f64 + %75 = arith.addf %68, %74 : f64 + %76 = arith.mulf %66, %75 : f64 + linalg.yield %76 : f64 + } -> tensor + %44 = polygeist.submapInverse(%31, %43, %c2, %c25) {map = #map2} : (tensor, tensor, index, index) -> tensor + %45 = polygeist.submap(%5, %c2, %c25) {map = #map} : (tensor, index, index) -> tensor + %46 = polygeist.submap(%4, %c2, %c25) {map = #map} : (tensor, index, index) -> tensor + %47 = polygeist.submap(%3, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %48 = polygeist.submap(%3, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %49 = polygeist.submap(%3, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %50 = polygeist.submap(%3, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %51 = polygeist.submap(%1, %c2, %c25) {map = #map1} : (tensor, index, index) -> tensor + %52 = polygeist.submap(%1, %c2, %c25) {map = #map2} : (tensor, index, index) -> tensor + %53 = polygeist.submap(%1, %c2, %c25) {map = #map3} : (tensor, index, index) -> tensor + %54 = polygeist.submap(%1, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %55 = polygeist.submap(%44, %c2, %c25) {map = #map4} : (tensor, index, index) -> tensor + %56 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5, #map5, #map5, #map5, #map5, #map6, #map5, #map5, #map5], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%47, %48, %49, %50, %51, %52, %53, %54, %2, %45, %46 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%55 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %out: f64): + %59 = arith.mulf %in, %in_2 : f64 + %60 = arith.mulf %in_0, %in_1 : f64 + %61 = arith.subf %59, %60 : f64 + %62 = arith.negf %in_1 : f64 + %63 = arith.divf %62, %61 : f64 + %64 = arith.divf %in, %61 : f64 + %65 = arith.addf %in_3, %in_6 : f64 + %66 = arith.mulf %in_7, %61 : f64 + %67 = arith.mulf %in_8, %64 : f64 + %68 = arith.mulf %67, %65 : f64 + %69 = arith.addf %in_5, %in_4 : f64 + %70 = arith.mulf %63, %69 : f64 + %71 = arith.addf %in_6, %in_6 : f64 + %72 = arith.mulf %64, %71 : f64 + %73 = arith.addf %70, %72 : f64 + %74 = arith.mulf %in_9, %73 : f64 + %75 = arith.addf %68, %74 : f64 + %76 = arith.mulf %66, %75 : f64 + linalg.yield %76 : f64 + } -> tensor + %57 = polygeist.submapInverse(%44, %56, %c2, %c25) {map = #map4} : (tensor, tensor, index, index) -> tensor + %58 = bufferization.to_memref %57 : memref + memref.copy %58, %arg5 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/elasticity_qpoint_3d_scalarized/debufferized.mlir b/issues/mfem_c_kernels/match_results/elasticity_qpoint_3d_scalarized/debufferized.mlir new file mode 100644 index 000000000000..360afc8329b7 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/elasticity_qpoint_3d_scalarized/debufferized.mlir @@ -0,0 +1,597 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 125)> +#map1 = affine_map<(d0, d1) -> (d1 + d0 * 1125)> +#map2 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 125)> +#map3 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 250)> +#map4 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 375)> +#map5 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 500)> +#map6 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 625)> +#map7 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 750)> +#map8 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 875)> +#map9 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 1000)> +#map10 = affine_map<(d0, d1) -> (d0, d1)> +#map11 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_elasticity_qpoint_3d_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c125 = arith.constant 125 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = bufferization.to_tensor %arg0 : memref + %6 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %7 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %8 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %9 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %10 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %11 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %12 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %13 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %14 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %15 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %16 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %17 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %18 = polygeist.submap(%1, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %19 = polygeist.submap(%1, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %20 = polygeist.submap(%1, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %21 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %22 = polygeist.submap(%1, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %23 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %24 = polygeist.submap(%0, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%8, %9, %10, %11, %12, %13, %14, %15, %16, %17, %18, %19, %20, %21, %22, %23, %2, %6, %7 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%24 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.divf %198, %209 : f64 + %211 = arith.mulf %in_1, %in_6 : f64 + %212 = arith.mulf %in_0, %in_7 : f64 + %213 = arith.subf %211, %212 : f64 + %214 = arith.divf %213, %209 : f64 + %215 = arith.mulf %in_0, %in_4 : f64 + %216 = arith.mulf %in_1, %in_3 : f64 + %217 = arith.subf %215, %216 : f64 + %218 = arith.divf %217, %209 : f64 + %219 = arith.addf %in_8, %in_12 : f64 + %220 = arith.addf %219, %in_14 : f64 + %221 = arith.mulf %in_15, %209 : f64 + %222 = arith.mulf %in_16, %210 : f64 + %223 = arith.mulf %222, %220 : f64 + %224 = arith.addf %in_8, %in_8 : f64 + %225 = arith.mulf %210, %224 : f64 + %226 = arith.addf %in_9, %in_11 : f64 + %227 = arith.mulf %214, %226 : f64 + %228 = arith.addf %225, %227 : f64 + %229 = arith.addf %in_10, %in_13 : f64 + %230 = arith.mulf %218, %229 : f64 + %231 = arith.addf %228, %230 : f64 + %232 = arith.mulf %in_17, %231 : f64 + %233 = arith.addf %223, %232 : f64 + %234 = arith.mulf %221, %233 : f64 + linalg.yield %234 : f64 + } -> tensor + %26 = polygeist.submapInverse(%0, %25, %c2, %c125) {map = #map1} : (tensor, tensor, index, index) -> tensor + %27 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %28 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %29 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %30 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %31 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %32 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %33 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %34 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %35 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %36 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %37 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %38 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %39 = polygeist.submap(%1, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %40 = polygeist.submap(%1, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %41 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %42 = polygeist.submap(%1, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %43 = polygeist.submap(%1, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %44 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %45 = polygeist.submap(%26, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %46 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%29, %30, %31, %32, %33, %34, %35, %36, %37, %38, %39, %40, %41, %42, %43, %44, %2, %27, %28 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%45 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.divf %198, %209 : f64 + %211 = arith.mulf %in_1, %in_6 : f64 + %212 = arith.mulf %in_0, %in_7 : f64 + %213 = arith.subf %211, %212 : f64 + %214 = arith.divf %213, %209 : f64 + %215 = arith.mulf %in_0, %in_4 : f64 + %216 = arith.mulf %in_1, %in_3 : f64 + %217 = arith.subf %215, %216 : f64 + %218 = arith.divf %217, %209 : f64 + %219 = arith.addf %in_8, %in_11 : f64 + %220 = arith.addf %219, %in_14 : f64 + %221 = arith.mulf %in_15, %209 : f64 + %222 = arith.mulf %in_16, %214 : f64 + %223 = arith.mulf %222, %220 : f64 + %224 = arith.addf %in_10, %in_9 : f64 + %225 = arith.mulf %210, %224 : f64 + %226 = arith.addf %in_11, %in_11 : f64 + %227 = arith.mulf %214, %226 : f64 + %228 = arith.addf %225, %227 : f64 + %229 = arith.addf %in_12, %in_13 : f64 + %230 = arith.mulf %218, %229 : f64 + %231 = arith.addf %228, %230 : f64 + %232 = arith.mulf %in_17, %231 : f64 + %233 = arith.addf %223, %232 : f64 + %234 = arith.mulf %221, %233 : f64 + linalg.yield %234 : f64 + } -> tensor + %47 = polygeist.submapInverse(%26, %46, %c2, %c125) {map = #map4} : (tensor, tensor, index, index) -> tensor + %48 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %49 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %50 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %51 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %52 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %53 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %54 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %55 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %56 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %57 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %58 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %59 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %60 = polygeist.submap(%1, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %61 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %62 = polygeist.submap(%1, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %63 = polygeist.submap(%1, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %64 = polygeist.submap(%1, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %65 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %66 = polygeist.submap(%47, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %67 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%50, %51, %52, %53, %54, %55, %56, %57, %58, %59, %60, %61, %62, %63, %64, %65, %2, %48, %49 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%66 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.divf %198, %209 : f64 + %211 = arith.mulf %in_1, %in_6 : f64 + %212 = arith.mulf %in_0, %in_7 : f64 + %213 = arith.subf %211, %212 : f64 + %214 = arith.divf %213, %209 : f64 + %215 = arith.mulf %in_0, %in_4 : f64 + %216 = arith.mulf %in_1, %in_3 : f64 + %217 = arith.subf %215, %216 : f64 + %218 = arith.divf %217, %209 : f64 + %219 = arith.addf %in_8, %in_10 : f64 + %220 = arith.addf %219, %in_14 : f64 + %221 = arith.mulf %in_15, %209 : f64 + %222 = arith.mulf %in_16, %218 : f64 + %223 = arith.mulf %222, %220 : f64 + %224 = arith.addf %in_12, %in_9 : f64 + %225 = arith.mulf %210, %224 : f64 + %226 = arith.addf %in_13, %in_11 : f64 + %227 = arith.mulf %214, %226 : f64 + %228 = arith.addf %225, %227 : f64 + %229 = arith.addf %in_14, %in_14 : f64 + %230 = arith.mulf %218, %229 : f64 + %231 = arith.addf %228, %230 : f64 + %232 = arith.mulf %in_17, %231 : f64 + %233 = arith.addf %223, %232 : f64 + %234 = arith.mulf %221, %233 : f64 + linalg.yield %234 : f64 + } -> tensor + %68 = polygeist.submapInverse(%47, %67, %c2, %c125) {map = #map7} : (tensor, tensor, index, index) -> tensor + %69 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %70 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %71 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %72 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %73 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %74 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %75 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %76 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %77 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %78 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %79 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %80 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %81 = polygeist.submap(%1, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %82 = polygeist.submap(%1, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %83 = polygeist.submap(%1, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %84 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %85 = polygeist.submap(%1, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %86 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %87 = polygeist.submap(%68, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %88 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%71, %72, %73, %74, %75, %76, %77, %78, %79, %80, %81, %82, %83, %84, %85, %86, %2, %69, %70 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%87 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.subf %201, %200 : f64 + %211 = arith.divf %210, %209 : f64 + %212 = arith.mulf %in, %in_7 : f64 + %213 = arith.mulf %in_1, %in_5 : f64 + %214 = arith.subf %212, %213 : f64 + %215 = arith.divf %214, %209 : f64 + %216 = arith.mulf %in_1, %in_2 : f64 + %217 = arith.mulf %in, %in_4 : f64 + %218 = arith.subf %216, %217 : f64 + %219 = arith.divf %218, %209 : f64 + %220 = arith.addf %in_8, %in_12 : f64 + %221 = arith.addf %220, %in_14 : f64 + %222 = arith.mulf %in_15, %209 : f64 + %223 = arith.mulf %in_16, %211 : f64 + %224 = arith.mulf %223, %221 : f64 + %225 = arith.addf %in_8, %in_8 : f64 + %226 = arith.mulf %211, %225 : f64 + %227 = arith.addf %in_9, %in_11 : f64 + %228 = arith.mulf %215, %227 : f64 + %229 = arith.addf %226, %228 : f64 + %230 = arith.addf %in_10, %in_13 : f64 + %231 = arith.mulf %219, %230 : f64 + %232 = arith.addf %229, %231 : f64 + %233 = arith.mulf %in_17, %232 : f64 + %234 = arith.addf %224, %233 : f64 + %235 = arith.mulf %222, %234 : f64 + linalg.yield %235 : f64 + } -> tensor + %89 = polygeist.submapInverse(%68, %88, %c2, %c125) {map = #map2} : (tensor, tensor, index, index) -> tensor + %90 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %91 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %92 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %93 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %94 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %95 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %96 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %97 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %98 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %99 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %100 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %101 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %102 = polygeist.submap(%1, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %103 = polygeist.submap(%1, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %104 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %105 = polygeist.submap(%1, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %106 = polygeist.submap(%1, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %107 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %108 = polygeist.submap(%89, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %109 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%92, %93, %94, %95, %96, %97, %98, %99, %100, %101, %102, %103, %104, %105, %106, %107, %2, %90, %91 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%108 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.subf %201, %200 : f64 + %211 = arith.divf %210, %209 : f64 + %212 = arith.mulf %in, %in_7 : f64 + %213 = arith.mulf %in_1, %in_5 : f64 + %214 = arith.subf %212, %213 : f64 + %215 = arith.divf %214, %209 : f64 + %216 = arith.mulf %in_1, %in_2 : f64 + %217 = arith.mulf %in, %in_4 : f64 + %218 = arith.subf %216, %217 : f64 + %219 = arith.divf %218, %209 : f64 + %220 = arith.addf %in_8, %in_11 : f64 + %221 = arith.addf %220, %in_14 : f64 + %222 = arith.mulf %in_15, %209 : f64 + %223 = arith.mulf %in_16, %215 : f64 + %224 = arith.mulf %223, %221 : f64 + %225 = arith.addf %in_10, %in_9 : f64 + %226 = arith.mulf %211, %225 : f64 + %227 = arith.addf %in_11, %in_11 : f64 + %228 = arith.mulf %215, %227 : f64 + %229 = arith.addf %226, %228 : f64 + %230 = arith.addf %in_12, %in_13 : f64 + %231 = arith.mulf %219, %230 : f64 + %232 = arith.addf %229, %231 : f64 + %233 = arith.mulf %in_17, %232 : f64 + %234 = arith.addf %224, %233 : f64 + %235 = arith.mulf %222, %234 : f64 + linalg.yield %235 : f64 + } -> tensor + %110 = polygeist.submapInverse(%89, %109, %c2, %c125) {map = #map5} : (tensor, tensor, index, index) -> tensor + %111 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %112 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %113 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %114 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %115 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %116 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %117 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %118 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %119 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %120 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %121 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %122 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %123 = polygeist.submap(%1, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %124 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %125 = polygeist.submap(%1, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %126 = polygeist.submap(%1, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %127 = polygeist.submap(%1, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %128 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %129 = polygeist.submap(%110, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %130 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%113, %114, %115, %116, %117, %118, %119, %120, %121, %122, %123, %124, %125, %126, %127, %128, %2, %111, %112 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%129 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.subf %201, %200 : f64 + %211 = arith.divf %210, %209 : f64 + %212 = arith.mulf %in, %in_7 : f64 + %213 = arith.mulf %in_1, %in_5 : f64 + %214 = arith.subf %212, %213 : f64 + %215 = arith.divf %214, %209 : f64 + %216 = arith.mulf %in_1, %in_2 : f64 + %217 = arith.mulf %in, %in_4 : f64 + %218 = arith.subf %216, %217 : f64 + %219 = arith.divf %218, %209 : f64 + %220 = arith.addf %in_8, %in_10 : f64 + %221 = arith.addf %220, %in_14 : f64 + %222 = arith.mulf %in_15, %209 : f64 + %223 = arith.mulf %in_16, %219 : f64 + %224 = arith.mulf %223, %221 : f64 + %225 = arith.addf %in_12, %in_9 : f64 + %226 = arith.mulf %211, %225 : f64 + %227 = arith.addf %in_13, %in_11 : f64 + %228 = arith.mulf %215, %227 : f64 + %229 = arith.addf %226, %228 : f64 + %230 = arith.addf %in_14, %in_14 : f64 + %231 = arith.mulf %219, %230 : f64 + %232 = arith.addf %229, %231 : f64 + %233 = arith.mulf %in_17, %232 : f64 + %234 = arith.addf %224, %233 : f64 + %235 = arith.mulf %222, %234 : f64 + linalg.yield %235 : f64 + } -> tensor + %131 = polygeist.submapInverse(%110, %130, %c2, %c125) {map = #map8} : (tensor, tensor, index, index) -> tensor + %132 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %133 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %134 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %135 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %136 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %137 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %138 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %139 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %140 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %141 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %142 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %143 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %144 = polygeist.submap(%1, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %145 = polygeist.submap(%1, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %146 = polygeist.submap(%1, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %147 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %148 = polygeist.submap(%1, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %149 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %150 = polygeist.submap(%131, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %151 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%134, %135, %136, %137, %138, %139, %140, %141, %142, %143, %144, %145, %146, %147, %148, %149, %2, %132, %133 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%150 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.divf %207, %209 : f64 + %211 = arith.mulf %in_0, %in_5 : f64 + %212 = arith.mulf %in, %in_6 : f64 + %213 = arith.subf %211, %212 : f64 + %214 = arith.divf %213, %209 : f64 + %215 = arith.mulf %in, %in_3 : f64 + %216 = arith.mulf %in_0, %in_2 : f64 + %217 = arith.subf %215, %216 : f64 + %218 = arith.divf %217, %209 : f64 + %219 = arith.addf %in_8, %in_12 : f64 + %220 = arith.addf %219, %in_14 : f64 + %221 = arith.mulf %in_15, %209 : f64 + %222 = arith.mulf %in_16, %210 : f64 + %223 = arith.mulf %222, %220 : f64 + %224 = arith.addf %in_8, %in_8 : f64 + %225 = arith.mulf %210, %224 : f64 + %226 = arith.addf %in_9, %in_11 : f64 + %227 = arith.mulf %214, %226 : f64 + %228 = arith.addf %225, %227 : f64 + %229 = arith.addf %in_10, %in_13 : f64 + %230 = arith.mulf %218, %229 : f64 + %231 = arith.addf %228, %230 : f64 + %232 = arith.mulf %in_17, %231 : f64 + %233 = arith.addf %223, %232 : f64 + %234 = arith.mulf %221, %233 : f64 + linalg.yield %234 : f64 + } -> tensor + %152 = polygeist.submapInverse(%131, %151, %c2, %c125) {map = #map3} : (tensor, tensor, index, index) -> tensor + %153 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %154 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %155 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %156 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %157 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %158 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %159 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %160 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %161 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %162 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %163 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %164 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %165 = polygeist.submap(%1, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %166 = polygeist.submap(%1, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %167 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %168 = polygeist.submap(%1, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %169 = polygeist.submap(%1, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %170 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %171 = polygeist.submap(%152, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %172 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%155, %156, %157, %158, %159, %160, %161, %162, %163, %164, %165, %166, %167, %168, %169, %170, %2, %153, %154 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%171 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.divf %207, %209 : f64 + %211 = arith.mulf %in_0, %in_5 : f64 + %212 = arith.mulf %in, %in_6 : f64 + %213 = arith.subf %211, %212 : f64 + %214 = arith.divf %213, %209 : f64 + %215 = arith.mulf %in, %in_3 : f64 + %216 = arith.mulf %in_0, %in_2 : f64 + %217 = arith.subf %215, %216 : f64 + %218 = arith.divf %217, %209 : f64 + %219 = arith.addf %in_8, %in_11 : f64 + %220 = arith.addf %219, %in_14 : f64 + %221 = arith.mulf %in_15, %209 : f64 + %222 = arith.mulf %in_16, %214 : f64 + %223 = arith.mulf %222, %220 : f64 + %224 = arith.addf %in_10, %in_9 : f64 + %225 = arith.mulf %210, %224 : f64 + %226 = arith.addf %in_11, %in_11 : f64 + %227 = arith.mulf %214, %226 : f64 + %228 = arith.addf %225, %227 : f64 + %229 = arith.addf %in_12, %in_13 : f64 + %230 = arith.mulf %218, %229 : f64 + %231 = arith.addf %228, %230 : f64 + %232 = arith.mulf %in_17, %231 : f64 + %233 = arith.addf %223, %232 : f64 + %234 = arith.mulf %221, %233 : f64 + linalg.yield %234 : f64 + } -> tensor + %173 = polygeist.submapInverse(%152, %172, %c2, %c125) {map = #map6} : (tensor, tensor, index, index) -> tensor + %174 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %175 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %176 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %177 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %178 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %179 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %180 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %181 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %182 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %183 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %184 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %185 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %186 = polygeist.submap(%1, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %187 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %188 = polygeist.submap(%1, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %189 = polygeist.submap(%1, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %190 = polygeist.submap(%1, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %191 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %192 = polygeist.submap(%173, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %193 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%176, %177, %178, %179, %180, %181, %182, %183, %184, %185, %186, %187, %188, %189, %190, %191, %2, %174, %175 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%192 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.divf %207, %209 : f64 + %211 = arith.mulf %in_0, %in_5 : f64 + %212 = arith.mulf %in, %in_6 : f64 + %213 = arith.subf %211, %212 : f64 + %214 = arith.divf %213, %209 : f64 + %215 = arith.mulf %in, %in_3 : f64 + %216 = arith.mulf %in_0, %in_2 : f64 + %217 = arith.subf %215, %216 : f64 + %218 = arith.divf %217, %209 : f64 + %219 = arith.addf %in_8, %in_10 : f64 + %220 = arith.addf %219, %in_14 : f64 + %221 = arith.mulf %in_15, %209 : f64 + %222 = arith.mulf %in_16, %218 : f64 + %223 = arith.mulf %222, %220 : f64 + %224 = arith.addf %in_12, %in_9 : f64 + %225 = arith.mulf %210, %224 : f64 + %226 = arith.addf %in_13, %in_11 : f64 + %227 = arith.mulf %214, %226 : f64 + %228 = arith.addf %225, %227 : f64 + %229 = arith.addf %in_14, %in_14 : f64 + %230 = arith.mulf %218, %229 : f64 + %231 = arith.addf %228, %230 : f64 + %232 = arith.mulf %in_17, %231 : f64 + %233 = arith.addf %223, %232 : f64 + %234 = arith.mulf %221, %233 : f64 + linalg.yield %234 : f64 + } -> tensor + %194 = polygeist.submapInverse(%173, %193, %c2, %c125) {map = #map9} : (tensor, tensor, index, index) -> tensor + %195 = bufferization.to_memref %194 : memref + memref.copy %195, %arg5 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/elasticity_qpoint_3d_scalarized/match_report.txt b/issues/mfem_c_kernels/match_results/elasticity_qpoint_3d_scalarized/match_report.txt new file mode 100644 index 000000000000..a6420d0d9b25 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/elasticity_qpoint_3d_scalarized/match_report.txt @@ -0,0 +1,11 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/elasticity_qpoint_3d_scalarized/debufferized.mlir == + no_match body#0 ? + no_match body#1 ? + no_match body#2 ? + no_match body#3 ? + no_match body#4 ? + no_match body#5 ? + no_match body#6 ? + no_match body#7 ? + no_match body#8 ? + total: 0 matched / 9 bodies diff --git a/issues/mfem_c_kernels/match_results/elasticity_qpoint_3d_scalarized/matched.mlir b/issues/mfem_c_kernels/match_results/elasticity_qpoint_3d_scalarized/matched.mlir new file mode 100644 index 000000000000..360afc8329b7 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/elasticity_qpoint_3d_scalarized/matched.mlir @@ -0,0 +1,597 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 125)> +#map1 = affine_map<(d0, d1) -> (d1 + d0 * 1125)> +#map2 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 125)> +#map3 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 250)> +#map4 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 375)> +#map5 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 500)> +#map6 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 625)> +#map7 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 750)> +#map8 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 875)> +#map9 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 1000)> +#map10 = affine_map<(d0, d1) -> (d0, d1)> +#map11 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_elasticity_qpoint_3d_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c125 = arith.constant 125 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = bufferization.to_tensor %arg0 : memref + %6 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %7 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %8 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %9 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %10 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %11 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %12 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %13 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %14 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %15 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %16 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %17 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %18 = polygeist.submap(%1, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %19 = polygeist.submap(%1, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %20 = polygeist.submap(%1, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %21 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %22 = polygeist.submap(%1, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %23 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %24 = polygeist.submap(%0, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%8, %9, %10, %11, %12, %13, %14, %15, %16, %17, %18, %19, %20, %21, %22, %23, %2, %6, %7 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%24 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.divf %198, %209 : f64 + %211 = arith.mulf %in_1, %in_6 : f64 + %212 = arith.mulf %in_0, %in_7 : f64 + %213 = arith.subf %211, %212 : f64 + %214 = arith.divf %213, %209 : f64 + %215 = arith.mulf %in_0, %in_4 : f64 + %216 = arith.mulf %in_1, %in_3 : f64 + %217 = arith.subf %215, %216 : f64 + %218 = arith.divf %217, %209 : f64 + %219 = arith.addf %in_8, %in_12 : f64 + %220 = arith.addf %219, %in_14 : f64 + %221 = arith.mulf %in_15, %209 : f64 + %222 = arith.mulf %in_16, %210 : f64 + %223 = arith.mulf %222, %220 : f64 + %224 = arith.addf %in_8, %in_8 : f64 + %225 = arith.mulf %210, %224 : f64 + %226 = arith.addf %in_9, %in_11 : f64 + %227 = arith.mulf %214, %226 : f64 + %228 = arith.addf %225, %227 : f64 + %229 = arith.addf %in_10, %in_13 : f64 + %230 = arith.mulf %218, %229 : f64 + %231 = arith.addf %228, %230 : f64 + %232 = arith.mulf %in_17, %231 : f64 + %233 = arith.addf %223, %232 : f64 + %234 = arith.mulf %221, %233 : f64 + linalg.yield %234 : f64 + } -> tensor + %26 = polygeist.submapInverse(%0, %25, %c2, %c125) {map = #map1} : (tensor, tensor, index, index) -> tensor + %27 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %28 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %29 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %30 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %31 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %32 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %33 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %34 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %35 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %36 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %37 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %38 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %39 = polygeist.submap(%1, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %40 = polygeist.submap(%1, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %41 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %42 = polygeist.submap(%1, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %43 = polygeist.submap(%1, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %44 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %45 = polygeist.submap(%26, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %46 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%29, %30, %31, %32, %33, %34, %35, %36, %37, %38, %39, %40, %41, %42, %43, %44, %2, %27, %28 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%45 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.divf %198, %209 : f64 + %211 = arith.mulf %in_1, %in_6 : f64 + %212 = arith.mulf %in_0, %in_7 : f64 + %213 = arith.subf %211, %212 : f64 + %214 = arith.divf %213, %209 : f64 + %215 = arith.mulf %in_0, %in_4 : f64 + %216 = arith.mulf %in_1, %in_3 : f64 + %217 = arith.subf %215, %216 : f64 + %218 = arith.divf %217, %209 : f64 + %219 = arith.addf %in_8, %in_11 : f64 + %220 = arith.addf %219, %in_14 : f64 + %221 = arith.mulf %in_15, %209 : f64 + %222 = arith.mulf %in_16, %214 : f64 + %223 = arith.mulf %222, %220 : f64 + %224 = arith.addf %in_10, %in_9 : f64 + %225 = arith.mulf %210, %224 : f64 + %226 = arith.addf %in_11, %in_11 : f64 + %227 = arith.mulf %214, %226 : f64 + %228 = arith.addf %225, %227 : f64 + %229 = arith.addf %in_12, %in_13 : f64 + %230 = arith.mulf %218, %229 : f64 + %231 = arith.addf %228, %230 : f64 + %232 = arith.mulf %in_17, %231 : f64 + %233 = arith.addf %223, %232 : f64 + %234 = arith.mulf %221, %233 : f64 + linalg.yield %234 : f64 + } -> tensor + %47 = polygeist.submapInverse(%26, %46, %c2, %c125) {map = #map4} : (tensor, tensor, index, index) -> tensor + %48 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %49 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %50 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %51 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %52 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %53 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %54 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %55 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %56 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %57 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %58 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %59 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %60 = polygeist.submap(%1, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %61 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %62 = polygeist.submap(%1, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %63 = polygeist.submap(%1, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %64 = polygeist.submap(%1, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %65 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %66 = polygeist.submap(%47, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %67 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%50, %51, %52, %53, %54, %55, %56, %57, %58, %59, %60, %61, %62, %63, %64, %65, %2, %48, %49 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%66 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.divf %198, %209 : f64 + %211 = arith.mulf %in_1, %in_6 : f64 + %212 = arith.mulf %in_0, %in_7 : f64 + %213 = arith.subf %211, %212 : f64 + %214 = arith.divf %213, %209 : f64 + %215 = arith.mulf %in_0, %in_4 : f64 + %216 = arith.mulf %in_1, %in_3 : f64 + %217 = arith.subf %215, %216 : f64 + %218 = arith.divf %217, %209 : f64 + %219 = arith.addf %in_8, %in_10 : f64 + %220 = arith.addf %219, %in_14 : f64 + %221 = arith.mulf %in_15, %209 : f64 + %222 = arith.mulf %in_16, %218 : f64 + %223 = arith.mulf %222, %220 : f64 + %224 = arith.addf %in_12, %in_9 : f64 + %225 = arith.mulf %210, %224 : f64 + %226 = arith.addf %in_13, %in_11 : f64 + %227 = arith.mulf %214, %226 : f64 + %228 = arith.addf %225, %227 : f64 + %229 = arith.addf %in_14, %in_14 : f64 + %230 = arith.mulf %218, %229 : f64 + %231 = arith.addf %228, %230 : f64 + %232 = arith.mulf %in_17, %231 : f64 + %233 = arith.addf %223, %232 : f64 + %234 = arith.mulf %221, %233 : f64 + linalg.yield %234 : f64 + } -> tensor + %68 = polygeist.submapInverse(%47, %67, %c2, %c125) {map = #map7} : (tensor, tensor, index, index) -> tensor + %69 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %70 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %71 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %72 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %73 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %74 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %75 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %76 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %77 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %78 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %79 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %80 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %81 = polygeist.submap(%1, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %82 = polygeist.submap(%1, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %83 = polygeist.submap(%1, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %84 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %85 = polygeist.submap(%1, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %86 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %87 = polygeist.submap(%68, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %88 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%71, %72, %73, %74, %75, %76, %77, %78, %79, %80, %81, %82, %83, %84, %85, %86, %2, %69, %70 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%87 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.subf %201, %200 : f64 + %211 = arith.divf %210, %209 : f64 + %212 = arith.mulf %in, %in_7 : f64 + %213 = arith.mulf %in_1, %in_5 : f64 + %214 = arith.subf %212, %213 : f64 + %215 = arith.divf %214, %209 : f64 + %216 = arith.mulf %in_1, %in_2 : f64 + %217 = arith.mulf %in, %in_4 : f64 + %218 = arith.subf %216, %217 : f64 + %219 = arith.divf %218, %209 : f64 + %220 = arith.addf %in_8, %in_12 : f64 + %221 = arith.addf %220, %in_14 : f64 + %222 = arith.mulf %in_15, %209 : f64 + %223 = arith.mulf %in_16, %211 : f64 + %224 = arith.mulf %223, %221 : f64 + %225 = arith.addf %in_8, %in_8 : f64 + %226 = arith.mulf %211, %225 : f64 + %227 = arith.addf %in_9, %in_11 : f64 + %228 = arith.mulf %215, %227 : f64 + %229 = arith.addf %226, %228 : f64 + %230 = arith.addf %in_10, %in_13 : f64 + %231 = arith.mulf %219, %230 : f64 + %232 = arith.addf %229, %231 : f64 + %233 = arith.mulf %in_17, %232 : f64 + %234 = arith.addf %224, %233 : f64 + %235 = arith.mulf %222, %234 : f64 + linalg.yield %235 : f64 + } -> tensor + %89 = polygeist.submapInverse(%68, %88, %c2, %c125) {map = #map2} : (tensor, tensor, index, index) -> tensor + %90 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %91 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %92 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %93 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %94 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %95 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %96 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %97 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %98 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %99 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %100 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %101 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %102 = polygeist.submap(%1, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %103 = polygeist.submap(%1, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %104 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %105 = polygeist.submap(%1, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %106 = polygeist.submap(%1, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %107 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %108 = polygeist.submap(%89, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %109 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%92, %93, %94, %95, %96, %97, %98, %99, %100, %101, %102, %103, %104, %105, %106, %107, %2, %90, %91 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%108 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.subf %201, %200 : f64 + %211 = arith.divf %210, %209 : f64 + %212 = arith.mulf %in, %in_7 : f64 + %213 = arith.mulf %in_1, %in_5 : f64 + %214 = arith.subf %212, %213 : f64 + %215 = arith.divf %214, %209 : f64 + %216 = arith.mulf %in_1, %in_2 : f64 + %217 = arith.mulf %in, %in_4 : f64 + %218 = arith.subf %216, %217 : f64 + %219 = arith.divf %218, %209 : f64 + %220 = arith.addf %in_8, %in_11 : f64 + %221 = arith.addf %220, %in_14 : f64 + %222 = arith.mulf %in_15, %209 : f64 + %223 = arith.mulf %in_16, %215 : f64 + %224 = arith.mulf %223, %221 : f64 + %225 = arith.addf %in_10, %in_9 : f64 + %226 = arith.mulf %211, %225 : f64 + %227 = arith.addf %in_11, %in_11 : f64 + %228 = arith.mulf %215, %227 : f64 + %229 = arith.addf %226, %228 : f64 + %230 = arith.addf %in_12, %in_13 : f64 + %231 = arith.mulf %219, %230 : f64 + %232 = arith.addf %229, %231 : f64 + %233 = arith.mulf %in_17, %232 : f64 + %234 = arith.addf %224, %233 : f64 + %235 = arith.mulf %222, %234 : f64 + linalg.yield %235 : f64 + } -> tensor + %110 = polygeist.submapInverse(%89, %109, %c2, %c125) {map = #map5} : (tensor, tensor, index, index) -> tensor + %111 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %112 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %113 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %114 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %115 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %116 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %117 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %118 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %119 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %120 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %121 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %122 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %123 = polygeist.submap(%1, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %124 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %125 = polygeist.submap(%1, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %126 = polygeist.submap(%1, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %127 = polygeist.submap(%1, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %128 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %129 = polygeist.submap(%110, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %130 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%113, %114, %115, %116, %117, %118, %119, %120, %121, %122, %123, %124, %125, %126, %127, %128, %2, %111, %112 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%129 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.subf %201, %200 : f64 + %211 = arith.divf %210, %209 : f64 + %212 = arith.mulf %in, %in_7 : f64 + %213 = arith.mulf %in_1, %in_5 : f64 + %214 = arith.subf %212, %213 : f64 + %215 = arith.divf %214, %209 : f64 + %216 = arith.mulf %in_1, %in_2 : f64 + %217 = arith.mulf %in, %in_4 : f64 + %218 = arith.subf %216, %217 : f64 + %219 = arith.divf %218, %209 : f64 + %220 = arith.addf %in_8, %in_10 : f64 + %221 = arith.addf %220, %in_14 : f64 + %222 = arith.mulf %in_15, %209 : f64 + %223 = arith.mulf %in_16, %219 : f64 + %224 = arith.mulf %223, %221 : f64 + %225 = arith.addf %in_12, %in_9 : f64 + %226 = arith.mulf %211, %225 : f64 + %227 = arith.addf %in_13, %in_11 : f64 + %228 = arith.mulf %215, %227 : f64 + %229 = arith.addf %226, %228 : f64 + %230 = arith.addf %in_14, %in_14 : f64 + %231 = arith.mulf %219, %230 : f64 + %232 = arith.addf %229, %231 : f64 + %233 = arith.mulf %in_17, %232 : f64 + %234 = arith.addf %224, %233 : f64 + %235 = arith.mulf %222, %234 : f64 + linalg.yield %235 : f64 + } -> tensor + %131 = polygeist.submapInverse(%110, %130, %c2, %c125) {map = #map8} : (tensor, tensor, index, index) -> tensor + %132 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %133 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %134 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %135 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %136 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %137 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %138 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %139 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %140 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %141 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %142 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %143 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %144 = polygeist.submap(%1, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %145 = polygeist.submap(%1, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %146 = polygeist.submap(%1, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %147 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %148 = polygeist.submap(%1, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %149 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %150 = polygeist.submap(%131, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %151 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%134, %135, %136, %137, %138, %139, %140, %141, %142, %143, %144, %145, %146, %147, %148, %149, %2, %132, %133 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%150 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.divf %207, %209 : f64 + %211 = arith.mulf %in_0, %in_5 : f64 + %212 = arith.mulf %in, %in_6 : f64 + %213 = arith.subf %211, %212 : f64 + %214 = arith.divf %213, %209 : f64 + %215 = arith.mulf %in, %in_3 : f64 + %216 = arith.mulf %in_0, %in_2 : f64 + %217 = arith.subf %215, %216 : f64 + %218 = arith.divf %217, %209 : f64 + %219 = arith.addf %in_8, %in_12 : f64 + %220 = arith.addf %219, %in_14 : f64 + %221 = arith.mulf %in_15, %209 : f64 + %222 = arith.mulf %in_16, %210 : f64 + %223 = arith.mulf %222, %220 : f64 + %224 = arith.addf %in_8, %in_8 : f64 + %225 = arith.mulf %210, %224 : f64 + %226 = arith.addf %in_9, %in_11 : f64 + %227 = arith.mulf %214, %226 : f64 + %228 = arith.addf %225, %227 : f64 + %229 = arith.addf %in_10, %in_13 : f64 + %230 = arith.mulf %218, %229 : f64 + %231 = arith.addf %228, %230 : f64 + %232 = arith.mulf %in_17, %231 : f64 + %233 = arith.addf %223, %232 : f64 + %234 = arith.mulf %221, %233 : f64 + linalg.yield %234 : f64 + } -> tensor + %152 = polygeist.submapInverse(%131, %151, %c2, %c125) {map = #map3} : (tensor, tensor, index, index) -> tensor + %153 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %154 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %155 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %156 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %157 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %158 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %159 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %160 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %161 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %162 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %163 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %164 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %165 = polygeist.submap(%1, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %166 = polygeist.submap(%1, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %167 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %168 = polygeist.submap(%1, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %169 = polygeist.submap(%1, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %170 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %171 = polygeist.submap(%152, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %172 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%155, %156, %157, %158, %159, %160, %161, %162, %163, %164, %165, %166, %167, %168, %169, %170, %2, %153, %154 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%171 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.divf %207, %209 : f64 + %211 = arith.mulf %in_0, %in_5 : f64 + %212 = arith.mulf %in, %in_6 : f64 + %213 = arith.subf %211, %212 : f64 + %214 = arith.divf %213, %209 : f64 + %215 = arith.mulf %in, %in_3 : f64 + %216 = arith.mulf %in_0, %in_2 : f64 + %217 = arith.subf %215, %216 : f64 + %218 = arith.divf %217, %209 : f64 + %219 = arith.addf %in_8, %in_11 : f64 + %220 = arith.addf %219, %in_14 : f64 + %221 = arith.mulf %in_15, %209 : f64 + %222 = arith.mulf %in_16, %214 : f64 + %223 = arith.mulf %222, %220 : f64 + %224 = arith.addf %in_10, %in_9 : f64 + %225 = arith.mulf %210, %224 : f64 + %226 = arith.addf %in_11, %in_11 : f64 + %227 = arith.mulf %214, %226 : f64 + %228 = arith.addf %225, %227 : f64 + %229 = arith.addf %in_12, %in_13 : f64 + %230 = arith.mulf %218, %229 : f64 + %231 = arith.addf %228, %230 : f64 + %232 = arith.mulf %in_17, %231 : f64 + %233 = arith.addf %223, %232 : f64 + %234 = arith.mulf %221, %233 : f64 + linalg.yield %234 : f64 + } -> tensor + %173 = polygeist.submapInverse(%152, %172, %c2, %c125) {map = #map6} : (tensor, tensor, index, index) -> tensor + %174 = polygeist.submap(%5, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %175 = polygeist.submap(%4, %c2, %c125) {map = #map} : (tensor, index, index) -> tensor + %176 = polygeist.submap(%3, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %177 = polygeist.submap(%3, %c2, %c125) {map = #map2} : (tensor, index, index) -> tensor + %178 = polygeist.submap(%3, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %179 = polygeist.submap(%3, %c2, %c125) {map = #map4} : (tensor, index, index) -> tensor + %180 = polygeist.submap(%3, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %181 = polygeist.submap(%3, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %182 = polygeist.submap(%3, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %183 = polygeist.submap(%3, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %184 = polygeist.submap(%3, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %185 = polygeist.submap(%1, %c2, %c125) {map = #map1} : (tensor, index, index) -> tensor + %186 = polygeist.submap(%1, %c2, %c125) {map = #map3} : (tensor, index, index) -> tensor + %187 = polygeist.submap(%1, %c2, %c125) {map = #map5} : (tensor, index, index) -> tensor + %188 = polygeist.submap(%1, %c2, %c125) {map = #map6} : (tensor, index, index) -> tensor + %189 = polygeist.submap(%1, %c2, %c125) {map = #map7} : (tensor, index, index) -> tensor + %190 = polygeist.submap(%1, %c2, %c125) {map = #map8} : (tensor, index, index) -> tensor + %191 = polygeist.submap(%1, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %192 = polygeist.submap(%173, %c2, %c125) {map = #map9} : (tensor, index, index) -> tensor + %193 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%176, %177, %178, %179, %180, %181, %182, %183, %184, %185, %186, %187, %188, %189, %190, %191, %2, %174, %175 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%192 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %196 = arith.mulf %in_3, %in_7 : f64 + %197 = arith.mulf %in_4, %in_6 : f64 + %198 = arith.subf %196, %197 : f64 + %199 = arith.mulf %in, %198 : f64 + %200 = arith.mulf %in_2, %in_7 : f64 + %201 = arith.mulf %in_4, %in_5 : f64 + %202 = arith.subf %200, %201 : f64 + %203 = arith.mulf %in_0, %202 : f64 + %204 = arith.subf %199, %203 : f64 + %205 = arith.mulf %in_2, %in_6 : f64 + %206 = arith.mulf %in_3, %in_5 : f64 + %207 = arith.subf %205, %206 : f64 + %208 = arith.mulf %in_1, %207 : f64 + %209 = arith.addf %204, %208 : f64 + %210 = arith.divf %207, %209 : f64 + %211 = arith.mulf %in_0, %in_5 : f64 + %212 = arith.mulf %in, %in_6 : f64 + %213 = arith.subf %211, %212 : f64 + %214 = arith.divf %213, %209 : f64 + %215 = arith.mulf %in, %in_3 : f64 + %216 = arith.mulf %in_0, %in_2 : f64 + %217 = arith.subf %215, %216 : f64 + %218 = arith.divf %217, %209 : f64 + %219 = arith.addf %in_8, %in_10 : f64 + %220 = arith.addf %219, %in_14 : f64 + %221 = arith.mulf %in_15, %209 : f64 + %222 = arith.mulf %in_16, %218 : f64 + %223 = arith.mulf %222, %220 : f64 + %224 = arith.addf %in_12, %in_9 : f64 + %225 = arith.mulf %210, %224 : f64 + %226 = arith.addf %in_13, %in_11 : f64 + %227 = arith.mulf %214, %226 : f64 + %228 = arith.addf %225, %227 : f64 + %229 = arith.addf %in_14, %in_14 : f64 + %230 = arith.mulf %218, %229 : f64 + %231 = arith.addf %228, %230 : f64 + %232 = arith.mulf %in_17, %231 : f64 + %233 = arith.addf %223, %232 : f64 + %234 = arith.mulf %221, %233 : f64 + linalg.yield %234 : f64 + } -> tensor + %194 = polygeist.submapInverse(%173, %193, %c2, %c125) {map = #map9} : (tensor, tensor, index, index) -> tensor + %195 = bufferization.to_memref %194 : memref + memref.copy %195, %arg5 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/integrate_grad_2d_stage_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/integrate_grad_2d_stage_sliced/debufferized.mlir new file mode 100644 index 000000000000..ea9dd205a18e --- /dev/null +++ b/issues/mfem_c_kernels/match_results/integrate_grad_2d_stage_sliced/debufferized.mlir @@ -0,0 +1,82 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50 + 25)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d1)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map8 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_grad_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = tensor.empty() : tensor<2x4x4xf64> + %5 = tensor.empty() : tensor<2x4x4xf64> + %6 = tensor.empty() : tensor<2x5x4xf64> + %7 = tensor.empty() : tensor<2x5x4xf64> + %8 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%7 : tensor<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4xf64> + %9 = polygeist.submap(%3, %c2, %c5, %c4, %c5) {map = #map1} : (tensor, index, index, index, index) -> tensor + %10 = polygeist.submap(%1, %c2, %c5, %c4, %c5) {map = #map2} : (tensor, index, index, index, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%9, %10 : tensor, tensor) outs(%8 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %26 = arith.mulf %in, %in_0 : f64 + %27 = arith.addf %out, %26 : f64 + linalg.yield %27 : f64 + } -> tensor<2x5x4xf64> + %12 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%6 : tensor<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4xf64> + %13 = polygeist.submap(%3, %c2, %c5, %c4, %c5) {map = #map5} : (tensor, index, index, index, index) -> tensor + %14 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map2} : (tensor, index, index, index, index) -> tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%13, %14 : tensor, tensor) outs(%12 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %26 = arith.mulf %in, %in_0 : f64 + %27 = arith.addf %out, %26 : f64 + linalg.yield %27 : f64 + } -> tensor<2x5x4xf64> + %16 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%5 : tensor<2x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4xf64> + %17 = polygeist.submap(%2, %c2, %c4, %c4, %c5) {map = #map6} : (tensor, index, index, index, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%11, %17 : tensor<2x5x4xf64>, tensor) outs(%16 : tensor<2x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %26 = arith.mulf %in, %in_0 : f64 + %27 = arith.addf %out, %26 : f64 + linalg.yield %27 : f64 + } -> tensor<2x4x4xf64> + %19 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%4 : tensor<2x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4xf64> + %20 = polygeist.submap(%1, %c2, %c4, %c4, %c5) {map = #map6} : (tensor, index, index, index, index) -> tensor + %21 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%15, %20 : tensor<2x5x4xf64>, tensor) outs(%19 : tensor<2x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %26 = arith.mulf %in, %in_0 : f64 + %27 = arith.addf %out, %26 : f64 + linalg.yield %27 : f64 + } -> tensor<2x4x4xf64> + %22 = polygeist.submap(%0, %c2, %c4, %c4) {map = #map8} : (tensor, index, index, index) -> tensor + %23 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%18, %21 : tensor<2x4x4xf64>, tensor<2x4x4xf64>) outs(%22 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %26 = arith.addf %in, %in_0 : f64 + %27 = arith.addf %out, %26 : f64 + linalg.yield %27 : f64 + } -> tensor + %24 = polygeist.submapInverse(%0, %23, %c2, %c4, %c4) {map = #map8} : (tensor, tensor, index, index, index) -> tensor + %25 = bufferization.to_memref %24 : memref + memref.copy %25, %arg3 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/integrate_grad_2d_stage_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/integrate_grad_2d_stage_sliced/match_report.txt new file mode 100644 index 000000000000..10fd93f67055 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/integrate_grad_2d_stage_sliced/match_report.txt @@ -0,0 +1,7 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/integrate_grad_2d_stage_sliced/debufferized.mlir == + match body#[0, 1] cutensornetContraction2_f64 + match body#[2, 3] cutensornetContraction2_f64 + match body#[4, 5] cutensornetContraction2_f64 + match body#[6, 7] cutensornetContraction2_f64 + no_match body#8 ? + total: 4 matched / 5 bodies diff --git a/issues/mfem_c_kernels/match_results/integrate_grad_2d_stage_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/integrate_grad_2d_stage_sliced/matched.mlir new file mode 100644 index 000000000000..7eeb2cbb2827 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/integrate_grad_2d_stage_sliced/matched.mlir @@ -0,0 +1,78 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50 + 25)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d1)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map8 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_grad_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = tensor.empty() : tensor<2x4x4xf64> + %5 = tensor.empty() : tensor<2x4x4xf64> + %6 = tensor.empty() : tensor<2x5x4xf64> + %7 = tensor.empty() : tensor<2x5x4xf64> + %9 = polygeist.submap(%3, %c2, %c5, %c4, %c5) {map = #map1} : (tensor, index, index, index, index) -> tensor + %10 = polygeist.submap(%1, %c2, %c5, %c4, %c5) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v9_contract_11_tc0 = tensor.cast %9 : tensor to tensor<*xf64> + + %v10_contract_11_tc1 = tensor.cast %10 : tensor to tensor<*xf64> + + %v7_contract_11_tc2 = tensor.cast %7 : tensor<2x5x4xf64> to tensor<*xf64> + + %v11_tdyn = kernel.launch @cutensornetContraction2_f64(%v9_contract_11_tc0, %v10_contract_11_tc1, %v7_contract_11_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %11 = tensor.cast %v11_tdyn : tensor<*xf64> to tensor<2x5x4xf64> + %13 = polygeist.submap(%3, %c2, %c5, %c4, %c5) {map = #map5} : (tensor, index, index, index, index) -> tensor + %14 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v13_contract_15_tc0 = tensor.cast %13 : tensor to tensor<*xf64> + + %v14_contract_15_tc1 = tensor.cast %14 : tensor to tensor<*xf64> + + %v6_contract_15_tc2 = tensor.cast %6 : tensor<2x5x4xf64> to tensor<*xf64> + + %v15_tdyn = kernel.launch @cutensornetContraction2_f64(%v13_contract_15_tc0, %v14_contract_15_tc1, %v6_contract_15_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %15 = tensor.cast %v15_tdyn : tensor<*xf64> to tensor<2x5x4xf64> + %17 = polygeist.submap(%2, %c2, %c4, %c4, %c5) {map = #map6} : (tensor, index, index, index, index) -> tensor + %v11_contract_18_tc0 = tensor.cast %11 : tensor<2x5x4xf64> to tensor<*xf64> + + %v17_contract_18_tc1 = tensor.cast %17 : tensor to tensor<*xf64> + + %v5_contract_18_tc2 = tensor.cast %5 : tensor<2x4x4xf64> to tensor<*xf64> + + %v18_tdyn = kernel.launch @cutensornetContraction2_f64(%v11_contract_18_tc0, %v17_contract_18_tc1, %v5_contract_18_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %18 = tensor.cast %v18_tdyn : tensor<*xf64> to tensor<2x4x4xf64> + %20 = polygeist.submap(%1, %c2, %c4, %c4, %c5) {map = #map6} : (tensor, index, index, index, index) -> tensor + %v15_contract_21_tc0 = tensor.cast %15 : tensor<2x5x4xf64> to tensor<*xf64> + + %v20_contract_21_tc1 = tensor.cast %20 : tensor to tensor<*xf64> + + %v4_contract_21_tc2 = tensor.cast %4 : tensor<2x4x4xf64> to tensor<*xf64> + + %v21_tdyn = kernel.launch @cutensornetContraction2_f64(%v15_contract_21_tc0, %v20_contract_21_tc1, %v4_contract_21_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %21 = tensor.cast %v21_tdyn : tensor<*xf64> to tensor<2x4x4xf64> + %22 = polygeist.submap(%0, %c2, %c4, %c4) {map = #map8} : (tensor, index, index, index) -> tensor + %23 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%18, %21 : tensor<2x4x4xf64>, tensor<2x4x4xf64>) outs(%22 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %26 = arith.addf %in, %in_0 : f64 + %27 = arith.addf %out, %26 : f64 + linalg.yield %27 : f64 + } -> tensor + %24 = polygeist.submapInverse(%0, %23, %c2, %c4, %c4) {map = #map8} : (tensor, tensor, index, index, index) -> tensor + %25 = bufferization.to_memref %24 : memref + memref.copy %25, %arg3 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/integrate_grad_3d_stage_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/integrate_grad_3d_stage_sliced/debufferized.mlir new file mode 100644 index 000000000000..761c2c1a296b --- /dev/null +++ b/issues/mfem_c_kernels/match_results/integrate_grad_3d_stage_sliced/debufferized.mlir @@ -0,0 +1,147 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 25 + d1 + d0 * 375 + d2 * 5)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 4 + d3)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 25 + d1 + d0 * 375 + d2 * 5 + 125)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 25 + d1 + d0 * 375 + d2 * 5 + 250)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 4 + d2)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 4 + d1)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_grad_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = tensor.empty() : tensor<2x4x4x4xf64> + %5 = tensor.empty() : tensor<2x4x4x4xf64> + %6 = tensor.empty() : tensor<2x4x4x4xf64> + %7 = tensor.empty() : tensor<2x5x4x4xf64> + %8 = tensor.empty() : tensor<2x5x4x4xf64> + %9 = tensor.empty() : tensor<2x5x4x4xf64> + %10 = tensor.empty() : tensor<2x5x5x4xf64> + %11 = tensor.empty() : tensor<2x5x5x4xf64> + %12 = tensor.empty() : tensor<2x5x5x4xf64> + %13 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %14 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %15 = polygeist.submap(%1, %c2, %c5, %c5, %c4, %c5) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%14, %15 : tensor, tensor) outs(%13 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %47 = arith.mulf %in, %in_0 : f64 + %48 = arith.addf %out, %47 : f64 + linalg.yield %48 : f64 + } -> tensor<2x5x5x4xf64> + %17 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%11 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %18 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %19 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %20 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%18, %19 : tensor, tensor) outs(%17 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %47 = arith.mulf %in, %in_0 : f64 + %48 = arith.addf %out, %47 : f64 + linalg.yield %48 : f64 + } -> tensor<2x5x5x4xf64> + %21 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%10 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %22 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %23 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %24 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%22, %23 : tensor, tensor) outs(%21 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %47 = arith.mulf %in, %in_0 : f64 + %48 = arith.addf %out, %47 : f64 + linalg.yield %48 : f64 + } -> tensor<2x5x5x4xf64> + %25 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %26 = polygeist.submap(%2, %c2, %c5, %c4, %c4, %c5) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %27 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%16, %26 : tensor<2x5x5x4xf64>, tensor) outs(%25 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %47 = arith.mulf %in, %in_0 : f64 + %48 = arith.addf %out, %47 : f64 + linalg.yield %48 : f64 + } -> tensor<2x5x4x4xf64> + %28 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %29 = polygeist.submap(%1, %c2, %c5, %c4, %c4, %c5) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %30 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%20, %29 : tensor<2x5x5x4xf64>, tensor) outs(%28 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %47 = arith.mulf %in, %in_0 : f64 + %48 = arith.addf %out, %47 : f64 + linalg.yield %48 : f64 + } -> tensor<2x5x4x4xf64> + %31 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%7 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %32 = polygeist.submap(%2, %c2, %c5, %c4, %c4, %c5) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %33 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%24, %32 : tensor<2x5x5x4xf64>, tensor) outs(%31 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %47 = arith.mulf %in, %in_0 : f64 + %48 = arith.addf %out, %47 : f64 + linalg.yield %48 : f64 + } -> tensor<2x5x4x4xf64> + %34 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%6 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %35 = polygeist.submap(%2, %c2, %c4, %c4, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %36 = linalg.generic {doc = "", indexing_maps = [#map10, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%27, %35 : tensor<2x5x4x4xf64>, tensor) outs(%34 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %47 = arith.mulf %in, %in_0 : f64 + %48 = arith.addf %out, %47 : f64 + linalg.yield %48 : f64 + } -> tensor<2x4x4x4xf64> + %37 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%5 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %38 = polygeist.submap(%2, %c2, %c4, %c4, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %39 = linalg.generic {doc = "", indexing_maps = [#map10, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%30, %38 : tensor<2x5x4x4xf64>, tensor) outs(%37 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %47 = arith.mulf %in, %in_0 : f64 + %48 = arith.addf %out, %47 : f64 + linalg.yield %48 : f64 + } -> tensor<2x4x4x4xf64> + %40 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%4 : tensor<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x4xf64> + %41 = polygeist.submap(%1, %c2, %c4, %c4, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %42 = linalg.generic {doc = "", indexing_maps = [#map10, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%33, %41 : tensor<2x5x4x4xf64>, tensor) outs(%40 : tensor<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %47 = arith.mulf %in, %in_0 : f64 + %48 = arith.addf %out, %47 : f64 + linalg.yield %48 : f64 + } -> tensor<2x4x4x4xf64> + %43 = polygeist.submap(%0, %c2, %c4, %c4, %c4) {map = #map11} : (tensor, index, index, index, index) -> tensor + %44 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%36, %39, %42 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%43 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %47 = arith.addf %in, %in_0 : f64 + %48 = arith.addf %47, %in_1 : f64 + %49 = arith.addf %out, %48 : f64 + linalg.yield %49 : f64 + } -> tensor + %45 = polygeist.submapInverse(%0, %44, %c2, %c4, %c4, %c4) {map = #map11} : (tensor, tensor, index, index, index, index) -> tensor + %46 = bufferization.to_memref %45 : memref + memref.copy %46, %arg3 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/integrate_grad_3d_stage_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/integrate_grad_3d_stage_sliced/match_report.txt new file mode 100644 index 000000000000..b4c34c0c4353 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/integrate_grad_3d_stage_sliced/match_report.txt @@ -0,0 +1,12 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/integrate_grad_3d_stage_sliced/debufferized.mlir == + match body#[0, 1] cublasGemmFor1x1Conv + match body#[2, 3] cublasGemmFor1x1Conv + match body#[4, 5] cublasGemmFor1x1Conv + match body#[6, 7] cublasGemmFor1x1Conv + match body#[8, 9] cublasGemmFor1x1Conv + match body#[10, 11] cublasGemmFor1x1Conv + match body#[12, 13] cublasGemmFor1x1Conv + match body#[14, 15] cublasGemmFor1x1Conv + match body#[16, 17] cublasGemmFor1x1Conv + no_match body#18 ? + total: 9 matched / 10 bodies diff --git a/issues/mfem_c_kernels/match_results/integrate_grad_3d_stage_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/integrate_grad_3d_stage_sliced/matched.mlir new file mode 100644 index 000000000000..138b161992bd --- /dev/null +++ b/issues/mfem_c_kernels/match_results/integrate_grad_3d_stage_sliced/matched.mlir @@ -0,0 +1,114 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 25 + d1 + d0 * 375 + d2 * 5)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 4 + d3)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 25 + d1 + d0 * 375 + d2 * 5 + 125)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 25 + d1 + d0 * 375 + d2 * 5 + 250)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 4 + d2)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 4 + d1)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_grad_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = tensor.empty() : tensor<2x4x4x4xf64> + %5 = tensor.empty() : tensor<2x4x4x4xf64> + %6 = tensor.empty() : tensor<2x4x4x4xf64> + %7 = tensor.empty() : tensor<2x5x4x4xf64> + %8 = tensor.empty() : tensor<2x5x4x4xf64> + %9 = tensor.empty() : tensor<2x5x4x4xf64> + %10 = tensor.empty() : tensor<2x5x5x4xf64> + %11 = tensor.empty() : tensor<2x5x5x4xf64> + %12 = tensor.empty() : tensor<2x5x5x4xf64> + %14 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %15 = polygeist.submap(%1, %c2, %c5, %c5, %c4, %c5) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v12_contract_16_tc2 = tensor.cast %12 : tensor<2x5x5x4xf64> to tensor + + %v16_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%14, %15, %v12_contract_16_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %16 = tensor.cast %v16_tdyn : tensor to tensor<2x5x5x4xf64> + %18 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %19 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v11_contract_20_tc2 = tensor.cast %11 : tensor<2x5x5x4xf64> to tensor + + %v20_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%18, %19, %v11_contract_20_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %20 = tensor.cast %v20_tdyn : tensor to tensor<2x5x5x4xf64> + %22 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map6} : (tensor, index, index, index, index, index) -> tensor + %23 = polygeist.submap(%2, %c2, %c5, %c5, %c4, %c5) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v10_contract_24_tc2 = tensor.cast %10 : tensor<2x5x5x4xf64> to tensor + + %v24_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%22, %23, %v10_contract_24_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %24 = tensor.cast %v24_tdyn : tensor to tensor<2x5x5x4xf64> + %26 = polygeist.submap(%2, %c2, %c5, %c4, %c4, %c5) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v16_contract_27_tc0 = tensor.cast %16 : tensor<2x5x5x4xf64> to tensor + + %v9_contract_27_tc2 = tensor.cast %9 : tensor<2x5x4x4xf64> to tensor + + %v27_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v16_contract_27_tc0, %26, %v9_contract_27_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %27 = tensor.cast %v27_tdyn : tensor to tensor<2x5x4x4xf64> + %29 = polygeist.submap(%1, %c2, %c5, %c4, %c4, %c5) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v20_contract_30_tc0 = tensor.cast %20 : tensor<2x5x5x4xf64> to tensor + + %v8_contract_30_tc2 = tensor.cast %8 : tensor<2x5x4x4xf64> to tensor + + %v30_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v20_contract_30_tc0, %29, %v8_contract_30_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %30 = tensor.cast %v30_tdyn : tensor to tensor<2x5x4x4xf64> + %32 = polygeist.submap(%2, %c2, %c5, %c4, %c4, %c5) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v24_contract_33_tc0 = tensor.cast %24 : tensor<2x5x5x4xf64> to tensor + + %v7_contract_33_tc2 = tensor.cast %7 : tensor<2x5x4x4xf64> to tensor + + %v33_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v24_contract_33_tc0, %32, %v7_contract_33_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %33 = tensor.cast %v33_tdyn : tensor to tensor<2x5x4x4xf64> + %35 = polygeist.submap(%2, %c2, %c4, %c4, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %v27_contract_36_tc0 = tensor.cast %27 : tensor<2x5x4x4xf64> to tensor + + %v6_contract_36_tc2 = tensor.cast %6 : tensor<2x4x4x4xf64> to tensor + + %v36_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v27_contract_36_tc0, %35, %v6_contract_36_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %36 = tensor.cast %v36_tdyn : tensor to tensor<2x4x4x4xf64> + %38 = polygeist.submap(%2, %c2, %c4, %c4, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %v30_contract_39_tc0 = tensor.cast %30 : tensor<2x5x4x4xf64> to tensor + + %v5_contract_39_tc2 = tensor.cast %5 : tensor<2x4x4x4xf64> to tensor + + %v39_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v30_contract_39_tc0, %38, %v5_contract_39_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %39 = tensor.cast %v39_tdyn : tensor to tensor<2x4x4x4xf64> + %41 = polygeist.submap(%1, %c2, %c4, %c4, %c4, %c5) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %v33_contract_42_tc0 = tensor.cast %33 : tensor<2x5x4x4xf64> to tensor + + %v4_contract_42_tc2 = tensor.cast %4 : tensor<2x4x4x4xf64> to tensor + + %v42_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v33_contract_42_tc0, %41, %v4_contract_42_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %42 = tensor.cast %v42_tdyn : tensor to tensor<2x4x4x4xf64> + %43 = polygeist.submap(%0, %c2, %c4, %c4, %c4) {map = #map11} : (tensor, index, index, index, index) -> tensor + %44 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%36, %39, %42 : tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>, tensor<2x4x4x4xf64>) outs(%43 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %47 = arith.addf %in, %in_0 : f64 + %48 = arith.addf %47, %in_1 : f64 + %49 = arith.addf %out, %48 : f64 + linalg.yield %49 : f64 + } -> tensor + %45 = polygeist.submapInverse(%0, %44, %c2, %c4, %c4, %c4) {map = #map11} : (tensor, tensor, index, index, index, index) -> tensor + %46 = bufferization.to_memref %45 : memref + memref.copy %46, %arg3 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/integrate_value_2d_scratch_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/integrate_value_2d_scratch_sliced/debufferized.mlir new file mode 100644 index 000000000000..2f37cfd08964 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/integrate_value_2d_scratch_sliced/debufferized.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 25)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d1)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 16 + d1 * 4)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_value_2d_scratch_sliced(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<2x5x4xf64> + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%3 : tensor<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4xf64> + %5 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map1} : (tensor, index, index, index, index) -> tensor + %6 = polygeist.submap(%1, %c2, %c5, %c4, %c5) {map = #map2} : (tensor, index, index, index, index) -> tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%5, %6 : tensor, tensor) outs(%4 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %13 = arith.mulf %in, %in_0 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } -> tensor<2x5x4xf64> + %8 = polygeist.submap(%1, %c2, %c4, %c4, %c5) {map = #map5} : (tensor, index, index, index, index) -> tensor + %9 = polygeist.submap(%0, %c2, %c4, %c4, %c5) {map = #map6} : (tensor, index, index, index, index) -> tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%7, %8 : tensor<2x5x4xf64>, tensor) outs(%9 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %13 = arith.mulf %in, %in_0 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } -> tensor + %11 = polygeist.submapInverse(%0, %10, %c2, %c4, %c4, %c5) {map = #map6} : (tensor, tensor, index, index, index, index) -> tensor + %12 = bufferization.to_memref %11 : memref + memref.copy %12, %arg2 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/integrate_value_2d_scratch_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/integrate_value_2d_scratch_sliced/match_report.txt new file mode 100644 index 000000000000..6209d1339990 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/integrate_value_2d_scratch_sliced/match_report.txt @@ -0,0 +1,4 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/integrate_value_2d_scratch_sliced/debufferized.mlir == + match body#[0, 1] cutensornetContraction2_f64 + no_match body#2 ? + total: 1 matched / 2 bodies diff --git a/issues/mfem_c_kernels/match_results/integrate_value_2d_scratch_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/integrate_value_2d_scratch_sliced/matched.mlir new file mode 100644 index 000000000000..070fe4b46310 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/integrate_value_2d_scratch_sliced/matched.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 25)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d1)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 16 + d1 * 4)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_value_2d_scratch_sliced(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<2x5x4xf64> + %5 = polygeist.submap(%2, %c2, %c5, %c4, %c5) {map = #map1} : (tensor, index, index, index, index) -> tensor + %6 = polygeist.submap(%1, %c2, %c5, %c4, %c5) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v5_contract_7_tc0 = tensor.cast %5 : tensor to tensor<*xf64> + + %v6_contract_7_tc1 = tensor.cast %6 : tensor to tensor<*xf64> + + %v3_contract_7_tc2 = tensor.cast %3 : tensor<2x5x4xf64> to tensor<*xf64> + + %v7_tdyn = kernel.launch @cutensornetContraction2_f64(%v5_contract_7_tc0, %v6_contract_7_tc1, %v3_contract_7_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %7 = tensor.cast %v7_tdyn : tensor<*xf64> to tensor<2x5x4xf64> + %8 = polygeist.submap(%1, %c2, %c4, %c4, %c5) {map = #map5} : (tensor, index, index, index, index) -> tensor + %9 = polygeist.submap(%0, %c2, %c4, %c4, %c5) {map = #map6} : (tensor, index, index, index, index) -> tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%7, %8 : tensor<2x5x4xf64>, tensor) outs(%9 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %13 = arith.mulf %in, %in_0 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } -> tensor + %11 = polygeist.submapInverse(%0, %10, %c2, %c4, %c4, %c5) {map = #map6} : (tensor, tensor, index, index, index, index) -> tensor + %12 = bufferization.to_memref %11 : memref + memref.copy %12, %arg2 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/integrate_value_3d_scratch_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/integrate_value_3d_scratch_sliced/debufferized.mlir new file mode 100644 index 000000000000..713317cddb5f --- /dev/null +++ b/issues/mfem_c_kernels/match_results/integrate_value_3d_scratch_sliced/debufferized.mlir @@ -0,0 +1,57 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d3, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 25 + d3 + d0 * 125 + d1 * 5)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 4 + d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 4 + d1)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4, d2)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_value_3d_scratch_sliced(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<2x5x4x4xf64> + %4 = tensor.empty() : tensor<2x5x5x4xf64> + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%4 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %6 = polygeist.submap(%2, %c2, %c5, %c4, %c5, %c5) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %7 = polygeist.submap(%1, %c2, %c5, %c4, %c5, %c5) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%6, %7 : tensor, tensor) outs(%5 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %17 = arith.mulf %in, %in_0 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } -> tensor<2x5x5x4xf64> + %9 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%3 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %10 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c5) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%8, %10 : tensor<2x5x5x4xf64>, tensor) outs(%9 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %17 = arith.mulf %in, %in_0 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } -> tensor<2x5x4x4xf64> + %12 = polygeist.submap(%1, %c2, %c4, %c4, %c4, %c5) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %13 = polygeist.submap(%0, %c2, %c4, %c4, %c4, %c5) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %14 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%11, %12 : tensor<2x5x4x4xf64>, tensor) outs(%13 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %17 = arith.mulf %in, %in_0 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } -> tensor + %15 = polygeist.submapInverse(%0, %14, %c2, %c4, %c4, %c4, %c5) {map = #map7} : (tensor, tensor, index, index, index, index, index) -> tensor + %16 = bufferization.to_memref %15 : memref + memref.copy %16, %arg2 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/integrate_value_3d_scratch_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/integrate_value_3d_scratch_sliced/match_report.txt new file mode 100644 index 000000000000..dd27bc91a1e2 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/integrate_value_3d_scratch_sliced/match_report.txt @@ -0,0 +1,5 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/integrate_value_3d_scratch_sliced/debufferized.mlir == + match body#[0, 1] cublasGemmFor1x1Conv + match body#[2, 3] cublasGemmFor1x1Conv + no_match body#4 ? + total: 2 matched / 3 bodies diff --git a/issues/mfem_c_kernels/match_results/integrate_value_3d_scratch_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/integrate_value_3d_scratch_sliced/matched.mlir new file mode 100644 index 000000000000..43db4d86f439 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/integrate_value_3d_scratch_sliced/matched.mlir @@ -0,0 +1,49 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d3, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 25 + d3 + d0 * 125 + d1 * 5)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 4 + d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 4 + d1)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4, d2)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_value_3d_scratch_sliced(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<2x5x4x4xf64> + %4 = tensor.empty() : tensor<2x5x5x4xf64> + %6 = polygeist.submap(%2, %c2, %c5, %c4, %c5, %c5) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %7 = polygeist.submap(%1, %c2, %c5, %c4, %c5, %c5) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v4_contract_8_tc2 = tensor.cast %4 : tensor<2x5x5x4xf64> to tensor + + %v8_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%6, %7, %v4_contract_8_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)>]} : (tensor, tensor, tensor) -> tensor + + %8 = tensor.cast %v8_tdyn : tensor to tensor<2x5x5x4xf64> + %10 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c5) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v8_contract_11_tc0 = tensor.cast %8 : tensor<2x5x5x4xf64> to tensor + + %v3_contract_11_tc2 = tensor.cast %3 : tensor<2x5x4x4xf64> to tensor + + %v11_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v8_contract_11_tc0, %10, %v3_contract_11_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d2, d1, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %11 = tensor.cast %v11_tdyn : tensor to tensor<2x5x4x4xf64> + %12 = polygeist.submap(%1, %c2, %c4, %c4, %c4, %c5) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %13 = polygeist.submap(%0, %c2, %c4, %c4, %c4, %c5) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %14 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%11, %12 : tensor<2x5x4x4xf64>, tensor) outs(%13 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %17 = arith.mulf %in, %in_0 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } -> tensor + %15 = polygeist.submapInverse(%0, %14, %c2, %c4, %c4, %c4, %c5) {map = #map7} : (tensor, tensor, index, index, index, index, index) -> tensor + %16 = bufferization.to_memref %15 : memref + memref.copy %16, %arg2 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/interp_grad_2d_stage_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/interp_grad_2d_stage_sliced/debufferized.mlir new file mode 100644 index 000000000000..2f8e6778452f --- /dev/null +++ b/issues/mfem_c_kernels/match_results/interp_grad_2d_stage_sliced/debufferized.mlir @@ -0,0 +1,82 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d2 * 5 + d1 + d0 * 50)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map9 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50 + 25)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d2 * 5 + d1 + d0 * 50 + 25)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_grad_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = tensor.empty() : tensor<2x4x5xf64> + %5 = tensor.empty() : tensor<2x4x5xf64> + %6 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%5 : tensor<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5xf64> + %7 = polygeist.submap(%3, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %8 = polygeist.submap(%2, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%7, %8 : tensor, tensor) outs(%6 : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %29 = arith.mulf %in, %in_0 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } -> tensor<2x4x5xf64> + %10 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%4 : tensor<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5xf64> + %11 = polygeist.submap(%3, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %12 = polygeist.submap(%1, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%11, %12 : tensor, tensor) outs(%10 : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %29 = arith.mulf %in, %in_0 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } -> tensor<2x4x5xf64> + %14 = polygeist.submap(%0, %c2, %c5, %c5) {map = #map5} : (tensor, index, index, index) -> tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%14 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %16 = polygeist.submapInverse(%0, %15, %c2, %c5, %c5) {map = #map5} : (tensor, tensor, index, index, index) -> tensor + %17 = polygeist.submap(%2, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %18 = polygeist.submap(%16, %c2, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%13, %17 : tensor<2x4x5xf64>, tensor) outs(%18 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %29 = arith.mulf %in, %in_0 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } -> tensor + %20 = polygeist.submapInverse(%16, %19, %c2, %c5, %c5, %c4) {map = #map7} : (tensor, tensor, index, index, index, index) -> tensor + %21 = polygeist.submap(%20, %c2, %c5, %c5) {map = #map9} : (tensor, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%21 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %23 = polygeist.submapInverse(%20, %22, %c2, %c5, %c5) {map = #map9} : (tensor, tensor, index, index, index) -> tensor + %24 = polygeist.submap(%1, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %25 = polygeist.submap(%23, %c2, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index) -> tensor + %26 = linalg.generic {doc = "", indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%9, %24 : tensor<2x4x5xf64>, tensor) outs(%25 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %29 = arith.mulf %in, %in_0 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } -> tensor + %27 = polygeist.submapInverse(%23, %26, %c2, %c5, %c5, %c4) {map = #map10} : (tensor, tensor, index, index, index, index) -> tensor + %28 = bufferization.to_memref %27 : memref + memref.copy %28, %arg3 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/interp_grad_2d_stage_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/interp_grad_2d_stage_sliced/match_report.txt new file mode 100644 index 000000000000..91bafbc6d552 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/interp_grad_2d_stage_sliced/match_report.txt @@ -0,0 +1,6 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/interp_grad_2d_stage_sliced/debufferized.mlir == + match body#[0, 1] cutensornetContraction2_f64 + match body#[2, 3] cutensornetContraction2_f64 + match body#[4, 5] cutensornetContraction2_f64 + match body#[6, 7] cutensornetContraction2_f64 + total: 4 matched / 4 bodies diff --git a/issues/mfem_c_kernels/match_results/interp_grad_2d_stage_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/interp_grad_2d_stage_sliced/matched.mlir new file mode 100644 index 000000000000..039ba67986e5 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/interp_grad_2d_stage_sliced/matched.mlir @@ -0,0 +1,86 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d2 * 5 + d1 + d0 * 50)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map9 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50 + 25)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d2 * 5 + d1 + d0 * 50 + 25)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_grad_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = tensor.empty() : tensor<2x4x5xf64> + %5 = tensor.empty() : tensor<2x4x5xf64> + %7 = polygeist.submap(%3, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %8 = polygeist.submap(%2, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v7_contract_9_tc0 = tensor.cast %7 : tensor to tensor<*xf64> + + %v8_contract_9_tc1 = tensor.cast %8 : tensor to tensor<*xf64> + + %v5_contract_9_tc2 = tensor.cast %5 : tensor<2x4x5xf64> to tensor<*xf64> + + %v9_tdyn = kernel.launch @cutensornetContraction2_f64(%v7_contract_9_tc0, %v8_contract_9_tc1, %v5_contract_9_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %9 = tensor.cast %v9_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %11 = polygeist.submap(%3, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %12 = polygeist.submap(%1, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v11_contract_13_tc0 = tensor.cast %11 : tensor to tensor<*xf64> + + %v12_contract_13_tc1 = tensor.cast %12 : tensor to tensor<*xf64> + + %v4_contract_13_tc2 = tensor.cast %4 : tensor<2x4x5xf64> to tensor<*xf64> + + %v13_tdyn = kernel.launch @cutensornetContraction2_f64(%v11_contract_13_tc0, %v12_contract_13_tc1, %v4_contract_13_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %13 = tensor.cast %v13_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %14 = polygeist.submap(%0, %c2, %c5, %c5) {map = #map5} : (tensor, index, index, index) -> tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%14 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %16 = polygeist.submapInverse(%0, %15, %c2, %c5, %c5) {map = #map5} : (tensor, tensor, index, index, index) -> tensor + %17 = polygeist.submap(%2, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %18 = polygeist.submap(%16, %c2, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index) -> tensor + %v13_contract_19_tc0 = tensor.cast %13 : tensor<2x4x5xf64> to tensor<*xf64> + + %v17_contract_19_tc1 = tensor.cast %17 : tensor to tensor<*xf64> + + %v18_contract_19_tc2 = tensor.cast %18 : tensor to tensor<*xf64> + + %v19_tdyn = kernel.launch @cutensornetContraction2_f64(%v13_contract_19_tc0, %v17_contract_19_tc1, %v18_contract_19_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %19 = tensor.cast %v19_tdyn : tensor<*xf64> to tensor + %20 = polygeist.submapInverse(%16, %19, %c2, %c5, %c5, %c4) {map = #map7} : (tensor, tensor, index, index, index, index) -> tensor + %21 = polygeist.submap(%20, %c2, %c5, %c5) {map = #map9} : (tensor, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%21 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %23 = polygeist.submapInverse(%20, %22, %c2, %c5, %c5) {map = #map9} : (tensor, tensor, index, index, index) -> tensor + %24 = polygeist.submap(%1, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %25 = polygeist.submap(%23, %c2, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index) -> tensor + %v9_contract_26_tc0 = tensor.cast %9 : tensor<2x4x5xf64> to tensor<*xf64> + + %v24_contract_26_tc1 = tensor.cast %24 : tensor to tensor<*xf64> + + %v25_contract_26_tc2 = tensor.cast %25 : tensor to tensor<*xf64> + + %v26_tdyn = kernel.launch @cutensornetContraction2_f64(%v9_contract_26_tc0, %v24_contract_26_tc1, %v25_contract_26_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %26 = tensor.cast %v26_tdyn : tensor<*xf64> to tensor + %27 = polygeist.submapInverse(%23, %26, %c2, %c5, %c5, %c4) {map = #map10} : (tensor, tensor, index, index, index, index) -> tensor + %28 = bufferization.to_memref %27 : memref + memref.copy %28, %arg3 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/interp_grad_3d_stage_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/interp_grad_3d_stage_sliced/debufferized.mlir new file mode 100644 index 000000000000..9015d30fbe31 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/interp_grad_3d_stage_sliced/debufferized.mlir @@ -0,0 +1,137 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 125)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 125)> +#map13 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 250)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 250)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_grad_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = tensor.empty() : tensor<2x4x5x5xf64> + %5 = tensor.empty() : tensor<2x4x5x5xf64> + %6 = tensor.empty() : tensor<2x4x5x5xf64> + %7 = tensor.empty() : tensor<2x4x4x5xf64> + %8 = tensor.empty() : tensor<2x4x4x5xf64> + %9 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %10 = polygeist.submap(%3, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %11 = polygeist.submap(%2, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %12 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%10, %11 : tensor, tensor) outs(%9 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %48 = arith.mulf %in, %in_0 : f64 + %49 = arith.addf %out, %48 : f64 + linalg.yield %49 : f64 + } -> tensor<2x4x4x5xf64> + %13 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%7 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %14 = polygeist.submap(%3, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %15 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%14, %15 : tensor, tensor) outs(%13 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %48 = arith.mulf %in, %in_0 : f64 + %49 = arith.addf %out, %48 : f64 + linalg.yield %49 : f64 + } -> tensor<2x4x4x5xf64> + %17 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%6 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %18 = polygeist.submap(%2, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%16, %18 : tensor<2x4x4x5xf64>, tensor) outs(%17 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %48 = arith.mulf %in, %in_0 : f64 + %49 = arith.addf %out, %48 : f64 + linalg.yield %49 : f64 + } -> tensor<2x4x5x5xf64> + %20 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%5 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %21 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%12, %21 : tensor<2x4x4x5xf64>, tensor) outs(%20 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %48 = arith.mulf %in, %in_0 : f64 + %49 = arith.addf %out, %48 : f64 + linalg.yield %49 : f64 + } -> tensor<2x4x5x5xf64> + %23 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%4 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %24 = polygeist.submap(%2, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%12, %24 : tensor<2x4x4x5xf64>, tensor) outs(%23 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %48 = arith.mulf %in, %in_0 : f64 + %49 = arith.addf %out, %48 : f64 + linalg.yield %49 : f64 + } -> tensor<2x4x5x5xf64> + %26 = polygeist.submap(%0, %c2, %c5, %c5, %c5) {map = #map7} : (tensor, index, index, index, index) -> tensor + %27 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%26 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %28 = polygeist.submapInverse(%0, %27, %c2, %c5, %c5, %c5) {map = #map7} : (tensor, tensor, index, index, index, index) -> tensor + %29 = polygeist.submap(%2, %c2, %c5, %c5, %c5, %c4) {map = #map8} : (tensor, index, index, index, index, index) -> tensor + %30 = polygeist.submap(%28, %c2, %c5, %c5, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %31 = linalg.generic {doc = "", indexing_maps = [#map10, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%19, %29 : tensor<2x4x5x5xf64>, tensor) outs(%30 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %48 = arith.mulf %in, %in_0 : f64 + %49 = arith.addf %out, %48 : f64 + linalg.yield %49 : f64 + } -> tensor + %32 = polygeist.submapInverse(%28, %31, %c2, %c5, %c5, %c5, %c4) {map = #map9} : (tensor, tensor, index, index, index, index, index) -> tensor + %33 = polygeist.submap(%32, %c2, %c5, %c5, %c5) {map = #map11} : (tensor, index, index, index, index) -> tensor + %34 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%33 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %35 = polygeist.submapInverse(%32, %34, %c2, %c5, %c5, %c5) {map = #map11} : (tensor, tensor, index, index, index, index) -> tensor + %36 = polygeist.submap(%2, %c2, %c5, %c5, %c5, %c4) {map = #map8} : (tensor, index, index, index, index, index) -> tensor + %37 = polygeist.submap(%35, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %38 = linalg.generic {doc = "", indexing_maps = [#map10, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%22, %36 : tensor<2x4x5x5xf64>, tensor) outs(%37 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %48 = arith.mulf %in, %in_0 : f64 + %49 = arith.addf %out, %48 : f64 + linalg.yield %49 : f64 + } -> tensor + %39 = polygeist.submapInverse(%35, %38, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, tensor, index, index, index, index, index) -> tensor + %40 = polygeist.submap(%39, %c2, %c5, %c5, %c5) {map = #map13} : (tensor, index, index, index, index) -> tensor + %41 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%40 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %42 = polygeist.submapInverse(%39, %41, %c2, %c5, %c5, %c5) {map = #map13} : (tensor, tensor, index, index, index, index) -> tensor + %43 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map8} : (tensor, index, index, index, index, index) -> tensor + %44 = polygeist.submap(%42, %c2, %c5, %c5, %c5, %c4) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %45 = linalg.generic {doc = "", indexing_maps = [#map10, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%25, %43 : tensor<2x4x5x5xf64>, tensor) outs(%44 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %48 = arith.mulf %in, %in_0 : f64 + %49 = arith.addf %out, %48 : f64 + linalg.yield %49 : f64 + } -> tensor + %46 = polygeist.submapInverse(%42, %45, %c2, %c5, %c5, %c5, %c4) {map = #map14} : (tensor, tensor, index, index, index, index, index) -> tensor + %47 = bufferization.to_memref %46 : memref + memref.copy %47, %arg3 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/interp_grad_3d_stage_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/interp_grad_3d_stage_sliced/match_report.txt new file mode 100644 index 000000000000..c9ff36ff0b93 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/interp_grad_3d_stage_sliced/match_report.txt @@ -0,0 +1,10 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/interp_grad_3d_stage_sliced/debufferized.mlir == + match body#[0, 1] cublasGemmFor1x1Conv + match body#[2, 3] cublasGemmFor1x1Conv + match body#[4, 5] cublasGemmFor1x1Conv + match body#[6, 7] cublasGemmFor1x1Conv + match body#[8, 9] cublasGemmFor1x1Conv + match body#[10, 11] cublasGemmFor1x1Conv + match body#[12, 13] cublasGemmFor1x1Conv + match body#[14, 15] cublasGemmFor1x1Conv + total: 8 matched / 8 bodies diff --git a/issues/mfem_c_kernels/match_results/interp_grad_3d_stage_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/interp_grad_3d_stage_sliced/matched.mlir new file mode 100644 index 000000000000..257d930a8504 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/interp_grad_3d_stage_sliced/matched.mlir @@ -0,0 +1,127 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 125)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 125)> +#map13 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 250)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 250)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_grad_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = bufferization.to_tensor %arg0 : memref + %4 = tensor.empty() : tensor<2x4x5x5xf64> + %5 = tensor.empty() : tensor<2x4x5x5xf64> + %6 = tensor.empty() : tensor<2x4x5x5xf64> + %7 = tensor.empty() : tensor<2x4x4x5xf64> + %8 = tensor.empty() : tensor<2x4x4x5xf64> + %10 = polygeist.submap(%3, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %11 = polygeist.submap(%2, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v8_contract_12_tc2 = tensor.cast %8 : tensor<2x4x4x5xf64> to tensor + + %v12_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%10, %11, %v8_contract_12_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %12 = tensor.cast %v12_tdyn : tensor to tensor<2x4x4x5xf64> + %14 = polygeist.submap(%3, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %15 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v7_contract_16_tc2 = tensor.cast %7 : tensor<2x4x4x5xf64> to tensor + + %v16_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%14, %15, %v7_contract_16_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %16 = tensor.cast %v16_tdyn : tensor to tensor<2x4x4x5xf64> + %18 = polygeist.submap(%2, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v16_contract_19_tc0 = tensor.cast %16 : tensor<2x4x4x5xf64> to tensor + + %v6_contract_19_tc2 = tensor.cast %6 : tensor<2x4x5x5xf64> to tensor + + %v19_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v16_contract_19_tc0, %18, %v6_contract_19_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %19 = tensor.cast %v19_tdyn : tensor to tensor<2x4x5x5xf64> + %21 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v12_contract_22_tc0 = tensor.cast %12 : tensor<2x4x4x5xf64> to tensor + + %v5_contract_22_tc2 = tensor.cast %5 : tensor<2x4x5x5xf64> to tensor + + %v22_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v12_contract_22_tc0, %21, %v5_contract_22_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %22 = tensor.cast %v22_tdyn : tensor to tensor<2x4x5x5xf64> + %24 = polygeist.submap(%2, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v12_contract_25_tc0 = tensor.cast %12 : tensor<2x4x4x5xf64> to tensor + + %v4_contract_25_tc2 = tensor.cast %4 : tensor<2x4x5x5xf64> to tensor + + %v25_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v12_contract_25_tc0, %24, %v4_contract_25_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %25 = tensor.cast %v25_tdyn : tensor to tensor<2x4x5x5xf64> + %26 = polygeist.submap(%0, %c2, %c5, %c5, %c5) {map = #map7} : (tensor, index, index, index, index) -> tensor + %27 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%26 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %28 = polygeist.submapInverse(%0, %27, %c2, %c5, %c5, %c5) {map = #map7} : (tensor, tensor, index, index, index, index) -> tensor + %29 = polygeist.submap(%2, %c2, %c5, %c5, %c5, %c4) {map = #map8} : (tensor, index, index, index, index, index) -> tensor + %30 = polygeist.submap(%28, %c2, %c5, %c5, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %v19_contract_31_tc0 = tensor.cast %19 : tensor<2x4x5x5xf64> to tensor<*xf64> + + %v29_contract_31_tc1 = tensor.cast %29 : tensor to tensor<*xf64> + + %v30_contract_31_tc2 = tensor.cast %30 : tensor to tensor<*xf64> + + %v31_tdyn = kernel.launch @cutensornetContraction2_f64(%v19_contract_31_tc0, %v29_contract_31_tc1, %v30_contract_31_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %31 = tensor.cast %v31_tdyn : tensor<*xf64> to tensor + %32 = polygeist.submapInverse(%28, %31, %c2, %c5, %c5, %c5, %c4) {map = #map9} : (tensor, tensor, index, index, index, index, index) -> tensor + %33 = polygeist.submap(%32, %c2, %c5, %c5, %c5) {map = #map11} : (tensor, index, index, index, index) -> tensor + %34 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%33 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %35 = polygeist.submapInverse(%32, %34, %c2, %c5, %c5, %c5) {map = #map11} : (tensor, tensor, index, index, index, index) -> tensor + %36 = polygeist.submap(%2, %c2, %c5, %c5, %c5, %c4) {map = #map8} : (tensor, index, index, index, index, index) -> tensor + %37 = polygeist.submap(%35, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %v22_contract_38_tc0 = tensor.cast %22 : tensor<2x4x5x5xf64> to tensor<*xf64> + + %v36_contract_38_tc1 = tensor.cast %36 : tensor to tensor<*xf64> + + %v37_contract_38_tc2 = tensor.cast %37 : tensor to tensor<*xf64> + + %v38_tdyn = kernel.launch @cutensornetContraction2_f64(%v22_contract_38_tc0, %v36_contract_38_tc1, %v37_contract_38_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %38 = tensor.cast %v38_tdyn : tensor<*xf64> to tensor + %39 = polygeist.submapInverse(%35, %38, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (tensor, tensor, index, index, index, index, index) -> tensor + %40 = polygeist.submap(%39, %c2, %c5, %c5, %c5) {map = #map13} : (tensor, index, index, index, index) -> tensor + %41 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%40 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %42 = polygeist.submapInverse(%39, %41, %c2, %c5, %c5, %c5) {map = #map13} : (tensor, tensor, index, index, index, index) -> tensor + %43 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map8} : (tensor, index, index, index, index, index) -> tensor + %44 = polygeist.submap(%42, %c2, %c5, %c5, %c5, %c4) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %v25_contract_45_tc0 = tensor.cast %25 : tensor<2x4x5x5xf64> to tensor<*xf64> + + %v43_contract_45_tc1 = tensor.cast %43 : tensor to tensor<*xf64> + + %v44_contract_45_tc2 = tensor.cast %44 : tensor to tensor<*xf64> + + %v45_tdyn = kernel.launch @cutensornetContraction2_f64(%v25_contract_45_tc0, %v43_contract_45_tc1, %v44_contract_45_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %45 = tensor.cast %v45_tdyn : tensor<*xf64> to tensor + %46 = polygeist.submapInverse(%42, %45, %c2, %c5, %c5, %c5, %c4) {map = #map14} : (tensor, tensor, index, index, index, index, index) -> tensor + %47 = bufferization.to_memref %46 : memref + memref.copy %47, %arg3 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/interp_value_2d_scratch_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/interp_value_2d_scratch_sliced/debufferized.mlir new file mode 100644 index 000000000000..1bd1651593ce --- /dev/null +++ b/issues/mfem_c_kernels/match_results/interp_value_2d_scratch_sliced/debufferized.mlir @@ -0,0 +1,50 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2) -> (d2 + d0 * 25 + d1 * 5)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 25 + d1 * 5)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_value_2d_scratch_sliced(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<2x4x5xf64> + %4 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%3 : tensor<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5xf64> + %5 = polygeist.submap(%2, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %6 = polygeist.submap(%1, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%6, %5 : tensor, tensor) outs(%4 : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %16 = arith.mulf %in, %in_0 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } -> tensor<2x4x5xf64> + %8 = polygeist.submap(%0, %c2, %c5, %c5) {map = #map5} : (tensor, index, index, index) -> tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %10 = polygeist.submapInverse(%0, %9, %c2, %c5, %c5) {map = #map5} : (tensor, tensor, index, index, index) -> tensor + %11 = polygeist.submap(%1, %c2, %c5, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %12 = polygeist.submap(%10, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map7, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%7, %11 : tensor<2x4x5xf64>, tensor) outs(%12 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %16 = arith.mulf %in, %in_0 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } -> tensor + %14 = polygeist.submapInverse(%10, %13, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, tensor, index, index, index, index) -> tensor + %15 = bufferization.to_memref %14 : memref + memref.copy %15, %arg2 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/interp_value_2d_scratch_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/interp_value_2d_scratch_sliced/match_report.txt new file mode 100644 index 000000000000..8c6675c1e64f --- /dev/null +++ b/issues/mfem_c_kernels/match_results/interp_value_2d_scratch_sliced/match_report.txt @@ -0,0 +1,4 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/interp_value_2d_scratch_sliced/debufferized.mlir == + match body#[0, 1] cutensornetContraction2_f64 + match body#[2, 3] cutensornetContraction2_f64 + total: 2 matched / 2 bodies diff --git a/issues/mfem_c_kernels/match_results/interp_value_2d_scratch_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/interp_value_2d_scratch_sliced/matched.mlir new file mode 100644 index 000000000000..137b93c76924 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/interp_value_2d_scratch_sliced/matched.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2) -> (d2 + d0 * 25 + d1 * 5)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 25 + d1 * 5)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_value_2d_scratch_sliced(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<2x4x5xf64> + %5 = polygeist.submap(%2, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %6 = polygeist.submap(%1, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v6_contract_7_tc0 = tensor.cast %6 : tensor to tensor<*xf64> + + %v5_contract_7_tc1 = tensor.cast %5 : tensor to tensor<*xf64> + + %v3_contract_7_tc2 = tensor.cast %3 : tensor<2x4x5xf64> to tensor<*xf64> + + %v7_tdyn = kernel.launch @cutensornetContraction2_f64(%v6_contract_7_tc0, %v5_contract_7_tc1, %v3_contract_7_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %7 = tensor.cast %v7_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %8 = polygeist.submap(%0, %c2, %c5, %c5) {map = #map5} : (tensor, index, index, index) -> tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %10 = polygeist.submapInverse(%0, %9, %c2, %c5, %c5) {map = #map5} : (tensor, tensor, index, index, index) -> tensor + %11 = polygeist.submap(%1, %c2, %c5, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %12 = polygeist.submap(%10, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, index, index, index, index) -> tensor + %v7_contract_13_tc0 = tensor.cast %7 : tensor<2x4x5xf64> to tensor<*xf64> + + %v11_contract_13_tc1 = tensor.cast %11 : tensor to tensor<*xf64> + + %v12_contract_13_tc2 = tensor.cast %12 : tensor to tensor<*xf64> + + %v13_tdyn = kernel.launch @cutensornetContraction2_f64(%v7_contract_13_tc0, %v11_contract_13_tc1, %v12_contract_13_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %13 = tensor.cast %v13_tdyn : tensor<*xf64> to tensor + %14 = polygeist.submapInverse(%10, %13, %c2, %c5, %c5, %c4) {map = #map6} : (tensor, tensor, index, index, index, index) -> tensor + %15 = bufferization.to_memref %14 : memref + memref.copy %15, %arg2 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/interp_value_3d_scratch_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/interp_value_3d_scratch_sliced/debufferized.mlir new file mode 100644 index 000000000000..5f28aacfeb11 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/interp_value_3d_scratch_sliced/debufferized.mlir @@ -0,0 +1,66 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3, d2)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 125 + d2 * 5)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d3 * 25 + d1 + d0 * 125 + d2 * 5)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_value_3d_scratch_sliced(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<2x4x5x5xf64> + %4 = tensor.empty() : tensor<2x4x4x5xf64> + %5 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%4 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %6 = polygeist.submap(%2, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %7 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%7, %6 : tensor, tensor) outs(%5 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %20 = arith.mulf %in, %in_0 : f64 + %21 = arith.addf %out, %20 : f64 + linalg.yield %21 : f64 + } -> tensor<2x4x4x5xf64> + %9 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%3 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %10 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map6, #map3, #map7], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%8, %10 : tensor<2x4x4x5xf64>, tensor) outs(%9 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %20 = arith.mulf %in, %in_0 : f64 + %21 = arith.addf %out, %20 : f64 + linalg.yield %21 : f64 + } -> tensor<2x4x5x5xf64> + %12 = polygeist.submap(%0, %c2, %c5, %c5, %c5) {map = #map8} : (tensor, index, index, index, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %14 = polygeist.submapInverse(%0, %13, %c2, %c5, %c5, %c5) {map = #map8} : (tensor, tensor, index, index, index, index) -> tensor + %15 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %16 = polygeist.submap(%14, %c2, %c5, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %17 = linalg.generic {doc = "", indexing_maps = [#map11, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%11, %15 : tensor<2x4x5x5xf64>, tensor) outs(%16 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %20 = arith.mulf %in, %in_0 : f64 + %21 = arith.addf %out, %20 : f64 + linalg.yield %21 : f64 + } -> tensor + %18 = polygeist.submapInverse(%14, %17, %c2, %c5, %c5, %c5, %c4) {map = #map10} : (tensor, tensor, index, index, index, index, index) -> tensor + %19 = bufferization.to_memref %18 : memref + memref.copy %19, %arg2 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/interp_value_3d_scratch_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/interp_value_3d_scratch_sliced/match_report.txt new file mode 100644 index 000000000000..ec030dc4811b --- /dev/null +++ b/issues/mfem_c_kernels/match_results/interp_value_3d_scratch_sliced/match_report.txt @@ -0,0 +1,5 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/interp_value_3d_scratch_sliced/debufferized.mlir == + match body#[0, 1] cublasGemmFor1x1Conv + match body#[2, 3] cublasGemmFor1x1Conv + match body#[4, 5] cublasGemmFor1x1Conv + total: 3 matched / 3 bodies diff --git a/issues/mfem_c_kernels/match_results/interp_value_3d_scratch_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/interp_value_3d_scratch_sliced/matched.mlir new file mode 100644 index 000000000000..2acd6da74d23 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/interp_value_3d_scratch_sliced/matched.mlir @@ -0,0 +1,61 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3, d2)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 125 + d2 * 5)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d3 * 25 + d1 + d0 * 125 + d2 * 5)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_value_3d_scratch_sliced(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = bufferization.to_tensor %arg0 : memref + %3 = tensor.empty() : tensor<2x4x5x5xf64> + %4 = tensor.empty() : tensor<2x4x4x5xf64> + %6 = polygeist.submap(%2, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %7 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v4_contract_8_tc2 = tensor.cast %4 : tensor<2x4x4x5xf64> to tensor + + %v8_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%7, %6, %v4_contract_8_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %8 = tensor.cast %v8_tdyn : tensor to tensor<2x4x4x5xf64> + %10 = polygeist.submap(%1, %c2, %c4, %c5, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v8_contract_11_tc0 = tensor.cast %8 : tensor<2x4x4x5xf64> to tensor + + %v3_contract_11_tc2 = tensor.cast %3 : tensor<2x4x5x5xf64> to tensor + + %v11_tdyn = kernel.launch @cutensornetContraction2_f64_r4r5r4(%v8_contract_11_tc0, %10, %v3_contract_11_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} : (tensor, tensor, tensor) -> tensor + + %11 = tensor.cast %v11_tdyn : tensor to tensor<2x4x5x5xf64> + %12 = polygeist.submap(%0, %c2, %c5, %c5, %c5) {map = #map8} : (tensor, index, index, index, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%12 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %14 = polygeist.submapInverse(%0, %13, %c2, %c5, %c5, %c5) {map = #map8} : (tensor, tensor, index, index, index, index) -> tensor + %15 = polygeist.submap(%1, %c2, %c5, %c5, %c5, %c4) {map = #map9} : (tensor, index, index, index, index, index) -> tensor + %16 = polygeist.submap(%14, %c2, %c5, %c5, %c5, %c4) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %v11_contract_17_tc0 = tensor.cast %11 : tensor<2x4x5x5xf64> to tensor<*xf64> + + %v15_contract_17_tc1 = tensor.cast %15 : tensor to tensor<*xf64> + + %v16_contract_17_tc2 = tensor.cast %16 : tensor to tensor<*xf64> + + %v17_tdyn = kernel.launch @cutensornetContraction2_f64(%v11_contract_17_tc0, %v15_contract_17_tc1, %v16_contract_17_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d1, d2)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2, d4)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %17 = tensor.cast %v17_tdyn : tensor<*xf64> to tensor + %18 = polygeist.submapInverse(%14, %17, %c2, %c5, %c5, %c5, %c4) {map = #map10} : (tensor, tensor, index, index, index, index, index) -> tensor + %19 = bufferization.to_memref %18 : memref + memref.copy %19, %arg2 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/mass_apply_2d_stage_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/mass_apply_2d_stage_sliced/debufferized.mlir new file mode 100644 index 000000000000..2fdf9894453c --- /dev/null +++ b/issues/mfem_c_kernels/match_results/mass_apply_2d_stage_sliced/debufferized.mlir @@ -0,0 +1,80 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2) -> (d2 + d0 * 25 + d1 * 5)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 16 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_mass_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = tensor.empty() : tensor<2x5x4xf64> + %6 = tensor.empty() : tensor<2x5x5xf64> + %7 = tensor.empty() : tensor<2x4x5xf64> + %8 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%7 : tensor<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5xf64> + %9 = polygeist.submap(%4, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %10 = polygeist.submap(%1, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%9, %10 : tensor, tensor) outs(%8 : tensor<2x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %25 = arith.mulf %in, %in_0 : f64 + %26 = arith.addf %out, %25 : f64 + linalg.yield %26 : f64 + } -> tensor<2x4x5xf64> + %12 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%6 : tensor<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5xf64> + %13 = polygeist.submap(%4, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %14 = linalg.generic {doc = "", indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%13, %11 : tensor, tensor<2x4x5xf64>) outs(%12 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %25 = arith.mulf %in, %in_0 : f64 + %26 = arith.addf %out, %25 : f64 + linalg.yield %26 : f64 + } -> tensor<2x5x5xf64> + %15 = polygeist.submap(%2, %c2, %c5, %c5) {map = #map7} : (tensor, index, index, index) -> tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%15 : tensor) outs(%14 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %out: f64): + %25 = arith.mulf %out, %in : f64 + linalg.yield %25 : f64 + } -> tensor<2x5x5xf64> + %17 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} outs(%5 : tensor<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4xf64> + %18 = polygeist.submap(%3, %c2, %c5, %c4, %c5) {map = #map8} : (tensor, index, index, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map3, #map9, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%18, %16 : tensor, tensor<2x5x5xf64>) outs(%17 : tensor<2x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %25 = arith.mulf %in, %in_0 : f64 + %26 = arith.addf %out, %25 : f64 + linalg.yield %26 : f64 + } -> tensor<2x5x4xf64> + %20 = polygeist.submap(%3, %c2, %c4, %c4, %c5) {map = #map10} : (tensor, index, index, index, index) -> tensor + %21 = polygeist.submap(%0, %c2, %c4, %c4, %c5) {map = #map11} : (tensor, index, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map3, #map6, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%20, %19 : tensor, tensor<2x5x4xf64>) outs(%21 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %25 = arith.mulf %in, %in_0 : f64 + %26 = arith.addf %out, %25 : f64 + linalg.yield %26 : f64 + } -> tensor + %23 = polygeist.submapInverse(%0, %22, %c2, %c4, %c4, %c5) {map = #map11} : (tensor, tensor, index, index, index, index) -> tensor + %24 = bufferization.to_memref %23 : memref + memref.copy %24, %arg4 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/mass_apply_2d_stage_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/mass_apply_2d_stage_sliced/match_report.txt new file mode 100644 index 000000000000..b9d371ff3553 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/mass_apply_2d_stage_sliced/match_report.txt @@ -0,0 +1,7 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/mass_apply_2d_stage_sliced/debufferized.mlir == + match body#[0, 1] cutensornetContraction2_f64 + match body#[2, 3] cutensornetContraction2_f64 + no_match body#4 ? + match body#[5, 6] cutensornetContraction2_f64 + no_match body#7 ? + total: 3 matched / 5 bodies diff --git a/issues/mfem_c_kernels/match_results/mass_apply_2d_stage_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/mass_apply_2d_stage_sliced/matched.mlir new file mode 100644 index 000000000000..aeba393e20be --- /dev/null +++ b/issues/mfem_c_kernels/match_results/mass_apply_2d_stage_sliced/matched.mlir @@ -0,0 +1,77 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2) -> (d2 + d0 * 25 + d1 * 5)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 16 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_mass_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = tensor.empty() : tensor<2x5x4xf64> + %6 = tensor.empty() : tensor<2x5x5xf64> + %7 = tensor.empty() : tensor<2x4x5xf64> + %9 = polygeist.submap(%4, %c2, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %10 = polygeist.submap(%1, %c2, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index) -> tensor + %v9_contract_11_tc0 = tensor.cast %9 : tensor to tensor<*xf64> + + %v10_contract_11_tc1 = tensor.cast %10 : tensor to tensor<*xf64> + + %v7_contract_11_tc2 = tensor.cast %7 : tensor<2x4x5xf64> to tensor<*xf64> + + %v11_tdyn = kernel.launch @cutensornetContraction2_f64(%v9_contract_11_tc0, %v10_contract_11_tc1, %v7_contract_11_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %11 = tensor.cast %v11_tdyn : tensor<*xf64> to tensor<2x4x5xf64> + %13 = polygeist.submap(%4, %c2, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index) -> tensor + %v13_contract_14_tc0 = tensor.cast %13 : tensor to tensor<*xf64> + + %v11_contract_14_tc1 = tensor.cast %11 : tensor<2x4x5xf64> to tensor<*xf64> + + %v6_contract_14_tc2 = tensor.cast %6 : tensor<2x5x5xf64> to tensor<*xf64> + + %v14_tdyn = kernel.launch @cutensornetContraction2_f64(%v13_contract_14_tc0, %v11_contract_14_tc1, %v6_contract_14_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %14 = tensor.cast %v14_tdyn : tensor<*xf64> to tensor<2x5x5xf64> + %15 = polygeist.submap(%2, %c2, %c5, %c5) {map = #map7} : (tensor, index, index, index) -> tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%15 : tensor) outs(%14 : tensor<2x5x5xf64>) { + ^bb0(%in: f64, %out: f64): + %25 = arith.mulf %out, %in : f64 + linalg.yield %25 : f64 + } -> tensor<2x5x5xf64> + %18 = polygeist.submap(%3, %c2, %c5, %c4, %c5) {map = #map8} : (tensor, index, index, index, index) -> tensor + %v18_contract_19_tc0 = tensor.cast %18 : tensor to tensor<*xf64> + + %v16_contract_19_tc1 = tensor.cast %16 : tensor<2x5x5xf64> to tensor<*xf64> + + %v5_contract_19_tc2 = tensor.cast %5 : tensor<2x5x4xf64> to tensor<*xf64> + + %v19_tdyn = kernel.launch @cutensornetContraction2_f64(%v18_contract_19_tc0, %v16_contract_19_tc1, %v5_contract_19_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)>, affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]} : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> + + %19 = tensor.cast %v19_tdyn : tensor<*xf64> to tensor<2x5x4xf64> + %20 = polygeist.submap(%3, %c2, %c4, %c4, %c5) {map = #map10} : (tensor, index, index, index, index) -> tensor + %21 = polygeist.submap(%0, %c2, %c4, %c4, %c5) {map = #map11} : (tensor, index, index, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map3, #map6, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%20, %19 : tensor, tensor<2x5x4xf64>) outs(%21 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %25 = arith.mulf %in, %in_0 : f64 + %26 = arith.addf %out, %25 : f64 + linalg.yield %26 : f64 + } -> tensor + %23 = polygeist.submapInverse(%0, %22, %c2, %c4, %c4, %c5) {map = #map11} : (tensor, tensor, index, index, index, index) -> tensor + %24 = bufferization.to_memref %23 : memref + memref.copy %24, %arg4 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/mass_apply_3d_stage_sliced/debufferized.mlir b/issues/mfem_c_kernels/match_results/mass_apply_3d_stage_sliced/debufferized.mlir new file mode 100644 index 000000000000..4d5ebd14e5a8 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/mass_apply_3d_stage_sliced/debufferized.mlir @@ -0,0 +1,107 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 125 + d1 * 25 + d2 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_mass_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = tensor.empty() : tensor<2x5x4x4xf64> + %6 = tensor.empty() : tensor<2x5x5x4xf64> + %7 = tensor.empty() : tensor<2x5x5x5xf64> + %8 = tensor.empty() : tensor<2x4x5x5xf64> + %9 = tensor.empty() : tensor<2x4x4x5xf64> + %10 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%9 : tensor<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x4x5xf64> + %11 = polygeist.submap(%4, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %12 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%11, %12 : tensor, tensor) outs(%10 : tensor<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %33 = arith.mulf %in, %in_0 : f64 + %34 = arith.addf %out, %33 : f64 + linalg.yield %34 : f64 + } -> tensor<2x4x4x5xf64> + %14 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%8 : tensor<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x4x5x5xf64> + %15 = polygeist.submap(%4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%15, %13 : tensor, tensor<2x4x4x5xf64>) outs(%14 : tensor<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %33 = arith.mulf %in, %in_0 : f64 + %34 = arith.addf %out, %33 : f64 + linalg.yield %34 : f64 + } -> tensor<2x4x5x5xf64> + %17 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%7 : tensor<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x5xf64> + %18 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map3, #map8, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%18, %16 : tensor, tensor<2x4x5x5xf64>) outs(%17 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %33 = arith.mulf %in, %in_0 : f64 + %34 = arith.addf %out, %33 : f64 + linalg.yield %34 : f64 + } -> tensor<2x5x5x5xf64> + %20 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map9} : (tensor, index, index, index, index) -> tensor + %21 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%20 : tensor) outs(%19 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %out: f64): + %33 = arith.mulf %out, %in : f64 + linalg.yield %33 : f64 + } -> tensor<2x5x5x5xf64> + %22 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%6 : tensor<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x5x4xf64> + %23 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %24 = linalg.generic {doc = "", indexing_maps = [#map3, #map11, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%23, %21 : tensor, tensor<2x5x5x5xf64>) outs(%22 : tensor<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %33 = arith.mulf %in, %in_0 : f64 + %34 = arith.addf %out, %33 : f64 + linalg.yield %34 : f64 + } -> tensor<2x5x5x4xf64> + %25 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} outs(%5 : tensor<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor<2x5x4x4xf64> + %26 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %27 = linalg.generic {doc = "", indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%26, %24 : tensor, tensor<2x5x5x4xf64>) outs(%25 : tensor<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %33 = arith.mulf %in, %in_0 : f64 + %34 = arith.addf %out, %33 : f64 + linalg.yield %34 : f64 + } -> tensor<2x5x4x4xf64> + %28 = polygeist.submap(%3, %c2, %c4, %c4, %c4, %c5) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %29 = polygeist.submap(%0, %c2, %c4, %c4, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %30 = linalg.generic {doc = "", indexing_maps = [#map3, #map8, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%28, %27 : tensor, tensor<2x5x4x4xf64>) outs(%29 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %33 = arith.mulf %in, %in_0 : f64 + %34 = arith.addf %out, %33 : f64 + linalg.yield %34 : f64 + } -> tensor + %31 = polygeist.submapInverse(%0, %30, %c2, %c4, %c4, %c4, %c5) {map = #map14} : (tensor, tensor, index, index, index, index, index) -> tensor + %32 = bufferization.to_memref %31 : memref + memref.copy %32, %arg4 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/mass_apply_3d_stage_sliced/match_report.txt b/issues/mfem_c_kernels/match_results/mass_apply_3d_stage_sliced/match_report.txt new file mode 100644 index 000000000000..cf4a2e12f666 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/mass_apply_3d_stage_sliced/match_report.txt @@ -0,0 +1,9 @@ +== match report for /home/arjaiswal/Polygeist/issues/mfem_c_kernels/match_results/mass_apply_3d_stage_sliced/debufferized.mlir == + match body#[0, 1] cublasGemmFor1x1Conv + match body#[2, 3] cublasGemmFor1x1Conv + match body#[4, 5] cublasGemmFor1x1Conv + no_match body#6 ? + match body#[7, 8] cublasGemmFor1x1Conv + match body#[9, 10] cublasGemmFor1x1Conv + no_match body#11 ? + total: 5 matched / 7 bodies diff --git a/issues/mfem_c_kernels/match_results/mass_apply_3d_stage_sliced/matched.mlir b/issues/mfem_c_kernels/match_results/mass_apply_3d_stage_sliced/matched.mlir new file mode 100644 index 000000000000..7f8162d04ea0 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/mass_apply_3d_stage_sliced/matched.mlir @@ -0,0 +1,90 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 125 + d1 * 25 + d2 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_mass_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %c2 = arith.constant 2 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = bufferization.to_tensor %arg0 : memref + %5 = tensor.empty() : tensor<2x5x4x4xf64> + %6 = tensor.empty() : tensor<2x5x5x4xf64> + %7 = tensor.empty() : tensor<2x5x5x5xf64> + %8 = tensor.empty() : tensor<2x4x5x5xf64> + %9 = tensor.empty() : tensor<2x4x4x5xf64> + %11 = polygeist.submap(%4, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (tensor, index, index, index, index, index) -> tensor + %12 = polygeist.submap(%1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (tensor, index, index, index, index, index) -> tensor + %v9_contract_13_tc2 = tensor.cast %9 : tensor<2x4x4x5xf64> to tensor + + %v13_tdyn = kernel.launch @cutensornetContraction2_f64_r5r5r4(%11, %12, %v9_contract_13_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %13 = tensor.cast %v13_tdyn : tensor to tensor<2x4x4x5xf64> + %15 = polygeist.submap(%4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (tensor, index, index, index, index, index) -> tensor + %v13_contract_16_tc1 = tensor.cast %13 : tensor<2x4x4x5xf64> to tensor + + %v8_contract_16_tc2 = tensor.cast %8 : tensor<2x4x5x5xf64> to tensor + + %v16_tdyn = kernel.launch @cutensornetContraction2_f64_r5r4r4(%15, %v13_contract_16_tc1, %v8_contract_16_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %16 = tensor.cast %v16_tdyn : tensor to tensor<2x4x5x5xf64> + %18 = polygeist.submap(%4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (tensor, index, index, index, index, index) -> tensor + %v16_contract_19_tc1 = tensor.cast %16 : tensor<2x4x5x5xf64> to tensor + + %v7_contract_19_tc2 = tensor.cast %7 : tensor<2x5x5x5xf64> to tensor + + %v19_tdyn = kernel.launch @cutensornetContraction2_f64_r5r4r4(%18, %v16_contract_19_tc1, %v7_contract_19_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %19 = tensor.cast %v19_tdyn : tensor to tensor<2x5x5x5xf64> + %20 = polygeist.submap(%2, %c2, %c5, %c5, %c5) {map = #map9} : (tensor, index, index, index, index) -> tensor + %21 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"], library_call = ""} ins(%20 : tensor) outs(%19 : tensor<2x5x5x5xf64>) { + ^bb0(%in: f64, %out: f64): + %33 = arith.mulf %out, %in : f64 + linalg.yield %33 : f64 + } -> tensor<2x5x5x5xf64> + %23 = polygeist.submap(%3, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (tensor, index, index, index, index, index) -> tensor + %v21_contract_24_tc1 = tensor.cast %21 : tensor<2x5x5x5xf64> to tensor + + %v6_contract_24_tc2 = tensor.cast %6 : tensor<2x5x5x4xf64> to tensor + + %v24_tdyn = kernel.launch @cutensornetContraction2_f64_r5r4r4(%23, %v21_contract_24_tc1, %v6_contract_24_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %24 = tensor.cast %v24_tdyn : tensor to tensor<2x5x5x4xf64> + %26 = polygeist.submap(%3, %c2, %c5, %c4, %c4, %c5) {map = #map12} : (tensor, index, index, index, index, index) -> tensor + %v24_contract_27_tc1 = tensor.cast %24 : tensor<2x5x5x4xf64> to tensor + + %v5_contract_27_tc2 = tensor.cast %5 : tensor<2x5x4x4xf64> to tensor + + %v27_tdyn = kernel.launch @cutensornetContraction2_f64_r5r4r4(%26, %v24_contract_27_tc1, %v5_contract_27_tc2) {contraction_maps = [affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)>, affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} : (tensor, tensor, tensor) -> tensor + + %27 = tensor.cast %v27_tdyn : tensor to tensor<2x5x4x4xf64> + %28 = polygeist.submap(%3, %c2, %c4, %c4, %c4, %c5) {map = #map13} : (tensor, index, index, index, index, index) -> tensor + %29 = polygeist.submap(%0, %c2, %c4, %c4, %c4, %c5) {map = #map14} : (tensor, index, index, index, index, index) -> tensor + %30 = linalg.generic {doc = "", indexing_maps = [#map3, #map8, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"], library_call = ""} ins(%28, %27 : tensor, tensor<2x5x4x4xf64>) outs(%29 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %33 = arith.mulf %in, %in_0 : f64 + %34 = arith.addf %out, %33 : f64 + linalg.yield %34 : f64 + } -> tensor + %31 = polygeist.submapInverse(%0, %30, %c2, %c4, %c4, %c4, %c5) {map = #map14} : (tensor, tensor, index, index, index, index, index) -> tensor + %32 = bufferization.to_memref %31 : memref + memref.copy %32, %arg4 : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/match_results/summary.csv b/issues/mfem_c_kernels/match_results/summary.csv new file mode 100644 index 000000000000..2eb04216a595 --- /dev/null +++ b/issues/mfem_c_kernels/match_results/summary.csv @@ -0,0 +1,21 @@ +id,function,family,dimension,debufferize_ok,matcher_ok,linalg_ops,matcher_bodies,matched_groups,matched_symbols,kernel_launches,launch_symbols,error +convection_apply_2d_stage_sliced,mfem_pa_convection_apply_2d_stage_sliced,partial_assembly,2,True,True,26,8,6,"cublasDaxpby,cutensornetContraction2_f64",6,"cublasDaxpby,cutensornetContraction2_f64", +convection_apply_3d_stage_sliced,mfem_pa_convection_apply_3d_stage_sliced,partial_assembly,3,True,True,46,13,11,"cublasGemmFor1x1Conv,cudnnAddTensor_batched",11,"cudnnAddTensor_batched,cutensornetContraction2_f64_r4r5r4,cutensornetContraction2_f64_r5r5r4", +curlcurl_apply_2d_stage_sliced,mfem_pa_curlcurl_apply_2d_stage_sliced,de_rham,2,True,True,36,13,7,"cublasDaxpby,cutensornetContraction2_f64",7,"cublasDaxpby,cutensornetContraction2_f64", +curlcurl_apply_3d_stage_sliced,mfem_pa_curlcurl_apply_3d_stage_sliced,de_rham,3,True,True,146,44,29,cublasGemmFor1x1Conv,29,"cutensornetContraction2_f64_r4r5r4,cutensornetContraction2_f64_r5r5r4", +diffusion_apply_2d_stage_sliced,mfem_pa_diffusion_apply_2d_stage_sliced,partial_assembly,2,True,True,34,11,6,cutensornetContraction2_f64,6,cutensornetContraction2_f64, +diffusion_apply_3d_stage_sliced,mfem_pa_diffusion_apply_3d_stage_sliced,partial_assembly,3,True,True,70,21,14,cublasGemmFor1x1Conv,14,"cutensornetContraction2_f64_r4r5r4,cutensornetContraction2_f64_r5r5r4", +divdiv_apply_2d_stage_sliced,mfem_pa_divdiv_apply_2d_stage_sliced,de_rham,2,True,True,36,12,8,"cublasDaxpby,cutensornetContraction2_f64",8,"cublasDaxpby,cutensornetContraction2_f64", +divdiv_apply_3d_stage_sliced,mfem_pa_divdiv_apply_3d_stage_sliced,de_rham,3,True,True,66,21,12,cublasGemmFor1x1Conv,12,"cutensornetContraction2_f64_r4r5r4,cutensornetContraction2_f64_r5r5r4", +elasticity_qpoint_2d_scalarized,mfem_elasticity_qpoint_2d_scalarized,quadrature_function,2,True,True,8,4,0,,0,, +elasticity_qpoint_3d_scalarized,mfem_elasticity_qpoint_3d_scalarized,quadrature_function,3,True,True,18,9,0,,0,, +integrate_grad_2d_stage_sliced,mfem_integrate_grad_2d_stage_sliced,sum_factorization,2,True,True,18,5,4,cutensornetContraction2_f64,4,cutensornetContraction2_f64, +integrate_grad_3d_stage_sliced,mfem_integrate_grad_3d_stage_sliced,sum_factorization,3,True,True,38,10,9,cublasGemmFor1x1Conv,9,"cutensornetContraction2_f64_r4r5r4,cutensornetContraction2_f64_r5r5r4", +integrate_value_2d_scratch_sliced,mfem_integrate_value_2d_scratch_sliced,sum_factorization,2,True,True,6,2,1,cutensornetContraction2_f64,1,cutensornetContraction2_f64, +integrate_value_3d_scratch_sliced,mfem_integrate_value_3d_scratch_sliced,sum_factorization,3,True,True,10,3,2,cublasGemmFor1x1Conv,2,"cutensornetContraction2_f64_r4r5r4,cutensornetContraction2_f64_r5r5r4", +interp_grad_2d_stage_sliced,mfem_interp_grad_2d_stage_sliced,sum_factorization,2,True,True,16,4,4,cutensornetContraction2_f64,4,cutensornetContraction2_f64, +interp_grad_3d_stage_sliced,mfem_interp_grad_3d_stage_sliced,sum_factorization,3,True,True,32,8,8,cublasGemmFor1x1Conv,8,"cutensornetContraction2_f64,cutensornetContraction2_f64_r4r5r4,cutensornetContraction2_f64_r5r5r4", +interp_value_2d_scratch_sliced,mfem_interp_value_2d_scratch_sliced,sum_factorization,2,True,True,8,2,2,cutensornetContraction2_f64,2,cutensornetContraction2_f64, +interp_value_3d_scratch_sliced,mfem_interp_value_3d_scratch_sliced,sum_factorization,3,True,True,12,3,3,cublasGemmFor1x1Conv,3,"cutensornetContraction2_f64,cutensornetContraction2_f64_r4r5r4,cutensornetContraction2_f64_r5r5r4", +mass_apply_2d_stage_sliced,mfem_pa_mass_apply_2d_stage_sliced,partial_assembly,2,True,True,16,5,3,cutensornetContraction2_f64,3,cutensornetContraction2_f64, +mass_apply_3d_stage_sliced,mfem_pa_mass_apply_3d_stage_sliced,partial_assembly,3,True,True,24,7,5,cublasGemmFor1x1Conv,5,"cutensornetContraction2_f64_r5r4r4,cutensornetContraction2_f64_r5r5r4", diff --git a/issues/mfem_c_kernels/mfem_cutensornet_r4r5r4_silicon.mlir b/issues/mfem_c_kernels/mfem_cutensornet_r4r5r4_silicon.mlir new file mode 100644 index 000000000000..15400244deae --- /dev/null +++ b/issues/mfem_c_kernels/mfem_cutensornet_r4r5r4_silicon.mlir @@ -0,0 +1,150 @@ +#a_flat = affine_map<(d0, d1, d2, d3) -> + (d0 * 24 + d1 * 8 + d2 * 2 + d3)> +#b_flat = affine_map<(d0, d1, d2, d3, d4) -> + (d0 * 48 + d1 * 24 + d2 * 12 + d3 * 4 + d4)> +#c_flat = affine_map<(d0, d1, d2, d3) -> + (d0 * 12 + d1 * 4 + d2 * 2 + d3)> +#a5_flat = affine_map<(d0, d1, d2, d3, d4) -> + (d0 * 96 + d1 * 32 + d2 * 16 + d3 * 8 + d4)> +#b4_flat = affine_map<(d0, d1, d2, d3) -> + (d0 * 24 + d1 * 8 + d2 * 2 + d3)> +#a5_broadcast_flat = affine_map<(d0, d1, d2, d3, d4) -> + (d0 * 24 + d1 * 8 + d3 * 4 + d4)> +#b5_broadcast_flat = affine_map<(d0, d1, d2, d3, d4) -> + (d2 * 8 + d3 * 4 + d4)> + +module { + kernel.defn @cutensornetContraction2_f64_r4r5r4( + %a: tensor, + %b: tensor, + %c: tensor) -> tensor { + kernel.yield %c : tensor + } + + kernel.defn @cutensornetContraction2_f64_r5r4r4( + %a: tensor, + %b: tensor, + %c: tensor) -> tensor { + kernel.yield %c : tensor + } + + kernel.defn @cutensornetContraction2_f64_r5r5r4( + %a: tensor, + %b: tensor, + %c: tensor) -> tensor { + kernel.yield %c : tensor + } + + func.func @mfem_cutensornet_r4r5r4( + %a_memref: memref, %b_memref: memref, + %c_memref: memref) { + %n0 = arith.constant 2 : index + %n1 = arith.constant 3 : index + %n2 = arith.constant 2 : index + %n3 = arith.constant 2 : index + %nk = arith.constant 4 : index + %a = bufferization.to_tensor %a_memref : memref + %b = bufferization.to_tensor %b_memref : memref + %c = bufferization.to_tensor %c_memref : memref + %av = polygeist.submap(%a, %n0, %n1, %nk, %n2) {map = #a_flat} + : (tensor, index, index, index, index) + -> tensor + %bv = polygeist.submap(%b, %n0, %n3, %n2, %n1, %nk) {map = #b_flat} + : (tensor, index, index, index, index, index) + -> tensor + %cv = polygeist.submap(%c, %n0, %n1, %n3, %n2) {map = #c_flat} + : (tensor, index, index, index, index) + -> tensor + %result = kernel.launch @cutensornetContraction2_f64_r4r5r4( + %av, %bv, %cv) {contraction_maps = [ + affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)>, + affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d2, d1, d4)>, + affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)>]} + : (tensor, tensor, + tensor) -> tensor + %updated = polygeist.submapInverse( + %c, %result, %n0, %n1, %n3, %n2) {map = #c_flat} + : (tensor, tensor, index, index, index, index) + -> tensor + %updated_memref = bufferization.to_memref %updated : memref + memref.copy %updated_memref, %c_memref + : memref to memref + return + } + + func.func @mfem_cutensornet_r5r4r4( + %a_memref: memref, %b_memref: memref, + %c_memref: memref) { + %n0 = arith.constant 2 : index + %n1 = arith.constant 3 : index + %n2 = arith.constant 2 : index + %n3 = arith.constant 2 : index + %nk = arith.constant 4 : index + %a = bufferization.to_tensor %a_memref : memref + %b = bufferization.to_tensor %b_memref : memref + %c = bufferization.to_tensor %c_memref : memref + %av = polygeist.submap(%a, %n0, %n1, %n2, %n3, %nk) {map = #a5_flat} + : (tensor, index, index, index, index, index) + -> tensor + %bv = polygeist.submap(%b, %n0, %n1, %nk, %n3) {map = #b4_flat} + : (tensor, index, index, index, index) + -> tensor + %cv = polygeist.submap(%c, %n0, %n1, %n2, %n3) {map = #c_flat} + : (tensor, index, index, index, index) + -> tensor + %result = kernel.launch @cutensornetContraction2_f64_r5r4r4( + %av, %bv, %cv) {contraction_maps = [ + affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, + affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)>, + affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} + : (tensor, tensor, + tensor) -> tensor + %updated = polygeist.submapInverse( + %c, %result, %n0, %n1, %n2, %n3) {map = #c_flat} + : (tensor, tensor, index, index, index, index) + -> tensor + %updated_memref = bufferization.to_memref %updated : memref + memref.copy %updated_memref, %c_memref + : memref to memref + return + } + + func.func @mfem_cutensornet_r5r5r4_broadcast( + %a_memref: memref, %b_memref: memref, + %c_memref: memref) { + %n0 = arith.constant 2 : index + %n1 = arith.constant 3 : index + %n2 = arith.constant 2 : index + %n3 = arith.constant 2 : index + %nk = arith.constant 4 : index + %a = bufferization.to_tensor %a_memref : memref + %b = bufferization.to_tensor %b_memref : memref + %c = bufferization.to_tensor %c_memref : memref + %av = polygeist.submap(%a, %n0, %n1, %n2, %n3, %nk) + {map = #a5_broadcast_flat} + : (tensor, index, index, index, index, index) + -> tensor + %bv = polygeist.submap(%b, %n0, %n1, %n2, %n3, %nk) + {map = #b5_broadcast_flat} + : (tensor, index, index, index, index, index) + -> tensor + %cv = polygeist.submap(%c, %n0, %n1, %n2, %n3) {map = #c_flat} + : (tensor, index, index, index, index) + -> tensor + %result = kernel.launch @cutensornetContraction2_f64_r5r5r4( + %av, %bv, %cv) {contraction_maps = [ + affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, + affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>, + affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]} + : (tensor, tensor, + tensor) -> tensor + %updated = polygeist.submapInverse( + %c, %result, %n0, %n1, %n2, %n3) {map = #c_flat} + : (tensor, tensor, index, index, index, index) + -> tensor + %updated_memref = bufferization.to_memref %updated : memref + memref.copy %updated_memref, %c_memref + : memref to memref + return + } +} diff --git a/issues/mfem_c_kernels/mfem_cutensornet_r4r5r4_silicon_harness.c b/issues/mfem_c_kernels/mfem_cutensornet_r4r5r4_silicon_harness.c new file mode 100644 index 000000000000..06a8c4b1ac14 --- /dev/null +++ b/issues/mfem_c_kernels/mfem_cutensornet_r4r5r4_silicon_harness.c @@ -0,0 +1,118 @@ +#include +#include +#include + +extern void mfem_cutensornet_r4r5r4( + double *, double *, int64_t, int64_t, int64_t, + double *, double *, int64_t, int64_t, int64_t, + double *, double *, int64_t, int64_t, int64_t); +extern void mfem_cutensornet_r5r4r4( + double *, double *, int64_t, int64_t, int64_t, + double *, double *, int64_t, int64_t, int64_t, + double *, double *, int64_t, int64_t, int64_t); +extern void mfem_cutensornet_r5r5r4_broadcast( + double *, double *, int64_t, int64_t, int64_t, + double *, double *, int64_t, int64_t, int64_t, + double *, double *, int64_t, int64_t, int64_t); + +int main(void) { + double a[48], b[96], c[24]; + for (int64_t i = 0; i < 48; ++i) + a[i] = (double)((i * 7 + 3) % 29 - 14) / 11.0; + for (int64_t i = 0; i < 96; ++i) + b[i] = (double)((i * 5 + 1) % 23 - 11) / 13.0; + for (int64_t i = 0; i < 24; ++i) + c[i] = -777.0; + + mfem_cutensornet_r4r5r4( + a, a, 0, 48, 1, b, b, 0, 96, 1, c, c, 0, 24, 1); + + double max_error = 0.0; + for (int64_t d0 = 0; d0 < 2; ++d0) + for (int64_t d1 = 0; d1 < 3; ++d1) + for (int64_t d3 = 0; d3 < 2; ++d3) + for (int64_t d2 = 0; d2 < 2; ++d2) { + double expected = 0.0; + for (int64_t d4 = 0; d4 < 4; ++d4) { + int64_t a_offset = d0 * 24 + d1 * 8 + d4 * 2 + d2; + int64_t b_offset = + d0 * 48 + d3 * 24 + d2 * 12 + d1 * 4 + d4; + expected += a[a_offset] * b[b_offset]; + } + int64_t c_offset = d0 * 12 + d1 * 4 + d3 * 2 + d2; + double error = fabs(c[c_offset] - expected); + if (error > max_error) + max_error = error; + } + printf("compiler_generated_r4r5r4 max_error=%.17g %s\n", max_error, + max_error <= 1.0e-11 ? "PASS" : "FAIL"); + int failures = max_error > 1.0e-11; + + { + double a5[188], b4[48], c4[24]; + for (int64_t i = 0; i < 188; ++i) + a5[i] = (double)((i * 7 + 3) % 29 - 14) / 11.0; + for (int64_t i = 0; i < 48; ++i) + b4[i] = (double)((i * 5 + 1) % 23 - 11) / 13.0; + for (int64_t i = 0; i < 24; ++i) + c4[i] = -777.0; + mfem_cutensornet_r5r4r4( + a5, a5, 0, 188, 1, b4, b4, 0, 48, 1, + c4, c4, 0, 24, 1); + max_error = 0.0; + for (int64_t d0 = 0; d0 < 2; ++d0) + for (int64_t d1 = 0; d1 < 3; ++d1) + for (int64_t d2 = 0; d2 < 2; ++d2) + for (int64_t d3 = 0; d3 < 2; ++d3) { + double expected = 0.0; + for (int64_t d4 = 0; d4 < 4; ++d4) { + int64_t a_offset = + d0 * 96 + d1 * 32 + d2 * 16 + d3 * 8 + d4; + int64_t b_offset = d0 * 24 + d1 * 8 + d4 * 2 + d3; + expected += a5[a_offset] * b4[b_offset]; + } + int64_t c_offset = d0 * 12 + d1 * 4 + d2 * 2 + d3; + double error = fabs(c4[c_offset] - expected); + if (error > max_error) + max_error = error; + } + printf("compiler_generated_r5r4r4 max_error=%.17g %s\n", max_error, + max_error <= 1.0e-11 ? "PASS" : "FAIL"); + failures += max_error > 1.0e-11; + } + + { + double a5[48], b5[16], c4[24]; + for (int64_t i = 0; i < 48; ++i) + a5[i] = (double)((i * 7 + 3) % 29 - 14) / 11.0; + for (int64_t i = 0; i < 16; ++i) + b5[i] = (double)((i * 5 + 1) % 23 - 11) / 13.0; + for (int64_t i = 0; i < 24; ++i) + c4[i] = -777.0; + mfem_cutensornet_r5r5r4_broadcast( + a5, a5, 0, 48, 1, b5, b5, 0, 16, 1, + c4, c4, 0, 24, 1); + max_error = 0.0; + for (int64_t d0 = 0; d0 < 2; ++d0) + for (int64_t d1 = 0; d1 < 3; ++d1) + for (int64_t d2 = 0; d2 < 2; ++d2) + for (int64_t d3 = 0; d3 < 2; ++d3) { + double expected = 0.0; + for (int64_t d4 = 0; d4 < 4; ++d4) { + int64_t a_offset = d0 * 24 + d1 * 8 + d3 * 4 + d4; + int64_t b_offset = d2 * 8 + d3 * 4 + d4; + expected += a5[a_offset] * b5[b_offset]; + } + int64_t c_offset = d0 * 12 + d1 * 4 + d2 * 2 + d3; + double error = fabs(c4[c_offset] - expected); + if (error > max_error) + max_error = error; + } + printf("compiler_generated_r5r5r4_broadcast max_error=%.17g %s\n", + max_error, max_error <= 1.0e-11 ? "PASS" : "FAIL"); + failures += max_error > 1.0e-11; + } + + printf("compiler_generated_variants failures=%d\n", failures); + return failures != 0; +} diff --git a/issues/mfem_c_kernels/mfem_cutensornet_variants_harness.c b/issues/mfem_c_kernels/mfem_cutensornet_variants_harness.c new file mode 100644 index 000000000000..ddff71da5ce3 --- /dev/null +++ b/issues/mfem_c_kernels/mfem_cutensornet_variants_harness.c @@ -0,0 +1,212 @@ +#include "polygeist_cublas_rt.h" + +#include +#include +#include +#include + +enum { + MAX_RANK = 64, + TENSOR_FIELDS = 3 * MAX_RANK, + METADATA_SIZE = 3 + 3 * TENSOR_FIELDS, + MAX_ELEMENTS = 4096 +}; + +static void set_tensor(int64_t metadata[METADATA_SIZE], int tensor, + int64_t rank, const int64_t *extents, + const int64_t *strides, const int64_t *modes) { + metadata[tensor] = rank; + int64_t base = 3 + tensor * TENSOR_FIELDS; + for (int64_t dim = 0; dim < MAX_RANK; ++dim) { + metadata[base + dim] = dim < rank ? extents[dim] : 1; + metadata[base + MAX_RANK + dim] = dim < rank ? strides[dim] : 0; + metadata[base + 2 * MAX_RANK + dim] = + dim < rank ? modes[dim] : -1; + } +} + +static int64_t tensor_span(const int64_t metadata[METADATA_SIZE], int tensor) { + int64_t rank = metadata[tensor]; + int64_t base = 3 + tensor * TENSOR_FIELDS; + int64_t span = 1; + for (int64_t dim = 0; dim < rank; ++dim) + span += (metadata[base + dim] - 1) * + metadata[base + MAX_RANK + dim]; + return span; +} + +static void reference_contraction( + const double *a, const double *b, double *c, + const int64_t metadata[METADATA_SIZE]) { + int64_t mode_extents[MAX_RANK]; + int present[3][MAX_RANK] = {{0}}; + for (int mode = 0; mode < MAX_RANK; ++mode) + mode_extents[mode] = 1; + for (int tensor = 0; tensor < 3; ++tensor) { + int64_t rank = metadata[tensor]; + int64_t base = 3 + tensor * TENSOR_FIELDS; + for (int64_t dim = 0; dim < rank; ++dim) { + int64_t mode = metadata[base + 2 * MAX_RANK + dim]; + mode_extents[mode] = metadata[base + dim]; + present[tensor][mode] = 1; + } + } + + int64_t total = 1; + for (int mode = 0; mode < MAX_RANK; ++mode) + total *= mode_extents[mode]; + for (int64_t linear = 0; linear < total; ++linear) { + int64_t coordinates[MAX_RANK]; + int64_t remaining = linear; + for (int mode = MAX_RANK - 1; mode >= 0; --mode) { + coordinates[mode] = remaining % mode_extents[mode]; + remaining /= mode_extents[mode]; + } + + int64_t offsets[3] = {0, 0, 0}; + for (int tensor = 0; tensor < 3; ++tensor) { + int64_t rank = metadata[tensor]; + int64_t base = 3 + tensor * TENSOR_FIELDS; + for (int64_t dim = 0; dim < rank; ++dim) + offsets[tensor] += + coordinates[metadata[base + 2 * MAX_RANK + dim]] * + metadata[base + MAX_RANK + dim]; + } + + int first_reduction_point = 1; + for (int mode = 0; mode < MAX_RANK; ++mode) + if (!present[2][mode] && (present[0][mode] || present[1][mode]) && + coordinates[mode] != 0) + first_reduction_point = 0; + if (first_reduction_point) + c[offsets[2]] = 0.0; + c[offsets[2]] += a[offsets[0]] * b[offsets[1]]; + } +} + +static int run_case(const char *name, + const int64_t metadata[METADATA_SIZE]) { + static double a[MAX_ELEMENTS], b[MAX_ELEMENTS]; + static double expected[MAX_ELEMENTS], actual[MAX_ELEMENTS]; + int64_t spans[3] = { + tensor_span(metadata, 0), + tensor_span(metadata, 1), + tensor_span(metadata, 2), + }; + if (spans[0] > MAX_ELEMENTS || spans[1] > MAX_ELEMENTS || + spans[2] > MAX_ELEMENTS) + return 1; + + for (int64_t i = 0; i < spans[0]; ++i) + a[i] = (double)((i * 7 + 3) % 29 - 14) / 11.0; + for (int64_t i = 0; i < spans[1]; ++i) + b[i] = (double)((i * 5 + 1) % 23 - 11) / 13.0; + for (int64_t i = 0; i < spans[2]; ++i) + expected[i] = actual[i] = -777.0; + + reference_contraction(a, b, expected, metadata); + polygeist_cutensornet_contraction2_f64(a, b, actual, metadata); + + double max_error = 0.0; + for (int64_t i = 0; i < spans[2]; ++i) { + double error = fabs(actual[i] - expected[i]); + if (error > max_error) + max_error = error; + } + printf("%s span=(%ld,%ld,%ld) max_error=%.17g %s\n", name, + (long)spans[0], (long)spans[1], (long)spans[2], max_error, + max_error <= 1.0e-11 ? "PASS" : "FAIL"); + return max_error > 1.0e-11; +} + +int main(void) { + int failures = 0; + + { + int64_t metadata[METADATA_SIZE] = {0}; + const int64_t ae[] = {2, 3, 4, 2}; + const int64_t as[] = {24, 8, 2, 1}; + const int64_t am[] = {0, 1, 4, 2}; + const int64_t be[] = {2, 2, 2, 3, 4}; + const int64_t bs[] = {48, 24, 12, 4, 1}; + const int64_t bm[] = {0, 3, 2, 1, 4}; + const int64_t ce[] = {2, 3, 2, 2}; + const int64_t cs[] = {12, 4, 2, 1}; + const int64_t cm[] = {0, 1, 3, 2}; + set_tensor(metadata, 0, 4, ae, as, am); + set_tensor(metadata, 1, 5, be, bs, bm); + set_tensor(metadata, 2, 4, ce, cs, cm); + failures += run_case("r4r5r4", metadata); + } + + { + int64_t metadata[METADATA_SIZE] = {0}; + const int64_t ae[] = {2, 3, 2, 2, 4}; + const int64_t as[] = {96, 32, 16, 8, 1}; + const int64_t am[] = {0, 1, 2, 3, 4}; + const int64_t be[] = {2, 3, 4, 2}; + const int64_t bs[] = {24, 8, 2, 1}; + const int64_t bm[] = {0, 1, 4, 3}; + const int64_t ce[] = {2, 3, 2, 2}; + const int64_t cs[] = {12, 4, 2, 1}; + const int64_t cm[] = {0, 1, 2, 3}; + set_tensor(metadata, 0, 5, ae, as, am); + set_tensor(metadata, 1, 4, be, bs, bm); + set_tensor(metadata, 2, 4, ce, cs, cm); + failures += run_case("r5r4r4", metadata); + } + + { + int64_t metadata[METADATA_SIZE] = {0}; + const int64_t ae[] = {2, 3, 2, 4}; + const int64_t as[] = {24, 8, 4, 1}; + const int64_t am[] = {0, 1, 3, 4}; + const int64_t be[] = {2, 2, 4}; + const int64_t bs[] = {8, 4, 1}; + const int64_t bm[] = {2, 3, 4}; + const int64_t ce[] = {2, 3, 2, 2}; + const int64_t cs[] = {12, 4, 2, 1}; + const int64_t cm[] = {0, 1, 2, 3}; + set_tensor(metadata, 0, 4, ae, as, am); + set_tensor(metadata, 1, 3, be, bs, bm); + set_tensor(metadata, 2, 4, ce, cs, cm); + failures += run_case("r5r5r4_broadcast_compacted", metadata); + } + + { + int64_t metadata[METADATA_SIZE] = {0}; + const int64_t ae[] = {2, 3, 5, 4}; + const int64_t as[] = {60, 20, 4, 1}; + const int64_t am[] = {0, 1, 2, 3}; + const int64_t be[] = {2, 3, 5, 4}; + const int64_t bs[] = {60, 20, 4, 1}; + const int64_t bm[] = {0, 1, 2, 3}; + const int64_t ce[] = {2, 3, 5}; + const int64_t cs[] = {15, 5, 1}; + const int64_t cm[] = {0, 1, 2}; + set_tensor(metadata, 0, 4, ae, as, am); + set_tensor(metadata, 1, 4, be, bs, bm); + set_tensor(metadata, 2, 3, ce, cs, cm); + failures += run_case("r4r4r3_2d", metadata); + } + + { + int64_t metadata[METADATA_SIZE] = {0}; + const int64_t ae[] = {2, 4, 3}; + const int64_t as[] = {12, 3, 1}; + const int64_t am[] = {0, 3, 1}; + const int64_t be[] = {2, 3, 5, 4}; + const int64_t bs[] = {60, 20, 4, 1}; + const int64_t bm[] = {0, 1, 2, 3}; + const int64_t ce[] = {2, 3, 5}; + const int64_t cs[] = {15, 5, 1}; + const int64_t cm[] = {0, 1, 2}; + set_tensor(metadata, 0, 3, ae, as, am); + set_tensor(metadata, 1, 4, be, bs, bm); + set_tensor(metadata, 2, 3, ce, cs, cm); + failures += run_case("r3r4r3_2d_broadcast_compacted", metadata); + } + + printf("mfem_cutensornet_variants failures=%d\n", failures); + return failures != 0; +} diff --git a/issues/mfem_c_kernels/normalized/convection_stage_sliced.c b/issues/mfem_c_kernels/normalized/convection_stage_sliced.c new file mode 100644 index 000000000000..0f489a72c2dc --- /dev/null +++ b/issues/mfem_c_kernels/normalized/convection_stage_sliced.c @@ -0,0 +1,47 @@ +/* PA convection with disjoint element/channel/stage scratch. */ +#ifndef MFEM_BENCH_NE +#define MFEM_BENCH_NE 2 +#endif +enum { D1D=4,Q1D=5,NE=MFEM_BENCH_NE }; +#define X2(x,y,e) ((x)+D1D*((y)+D1D*(e))) +#define X3(x,y,z,e) ((x)+D1D*((y)+D1D*((z)+D1D*(e)))) +#define O2(x,y,c,e) ((x)+Q1D*((y)+Q1D*((c)+2*(e)))) +#define O3(x,y,z,c,e) ((x)+Q1D*((y)+Q1D*((z)+Q1D*((c)+3*(e))))) + +// polygeist-arg-extents mfem_pa_convection_apply_2d_stage_sliced: B=20, G=20, Bt=20, op=50*MFEM_BENCH_NE, X=16*MFEM_BENCH_NE, Y=16*MFEM_BENCH_NE +void mfem_pa_convection_apply_2d_stage_sliced(const double *B,const double *G, + const double *Bt,const double *op,const double *X,double *Y) { + double bx[NE][D1D][Q1D],gx[NE][D1D][Q1D],g0[NE][Q1D][Q1D],g1[NE][Q1D][Q1D]; + double h[NE][Q1D][Q1D],tx[NE][Q1D][D1D],u[NE][D1D][D1D]; + for(int e=0;e : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_convection_apply_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4x5xf64> + %alloca_0 = memref.alloca() : memref<5x5xf64> + %alloca_1 = memref.alloca() : memref<5x5xf64> + %alloca_2 = memref.alloca() : memref<5x5xf64> + %alloca_3 = memref.alloca() : memref<4x5xf64> + %alloca_4 = memref.alloca() : memref<4x5xf64> + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + affine.store %cst, %alloca_3[%arg7, %arg8] : memref<4x5xf64> + affine.store %cst, %alloca_4[%arg7, %arg8] : memref<4x5xf64> + %0:2 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst, %arg11 = %cst) -> (f64, f64) { + %1 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %2 = affine.load %arg4[%arg9 + %arg6 * 16 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.store %4, %alloca_4[%arg7, %arg8] : memref<4x5xf64> + %5 = affine.load %arg1[%arg9 + %arg8 * 4] : memref + %6 = arith.mulf %5, %2 : f64 + %7 = arith.addf %arg10, %6 : f64 + affine.store %7, %alloca_3[%arg7, %arg8] : memref<4x5xf64> + affine.yield %7, %4 : f64, f64 + } + } + } + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.store %cst, %alloca_1[%arg8, %arg7] : memref<5x5xf64> + affine.store %cst, %alloca_2[%arg8, %arg7] : memref<5x5xf64> + %0:2 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst, %arg11 = %cst) -> (f64, f64) { + %8 = affine.load %arg1[%arg9 + %arg8 * 4] : memref + %9 = affine.load %alloca_4[%arg9, %arg7] : memref<4x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %arg11, %10 : f64 + affine.store %11, %alloca_2[%arg8, %arg7] : memref<5x5xf64> + %12 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %13 = affine.load %alloca_3[%arg9, %arg7] : memref<4x5xf64> + %14 = arith.mulf %12, %13 : f64 + %15 = arith.addf %arg10, %14 : f64 + affine.store %15, %alloca_1[%arg8, %arg7] : memref<5x5xf64> + affine.yield %15, %11 : f64, f64 + } + %1 = affine.load %arg3[%arg7 + %arg6 * 50 + %arg8 * 5] : memref + %2 = affine.load %alloca_1[%arg8, %arg7] : memref<5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg3[%arg7 + %arg6 * 50 + %arg8 * 5 + 25] : memref + %5 = affine.load %alloca_2[%arg8, %arg7] : memref<5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + affine.store %7, %alloca_0[%arg8, %arg7] : memref<5x5xf64> + } + } + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + affine.store %cst, %alloca[%arg8, %arg7] : memref<4x5xf64> + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg2[%arg9 + %arg8 * 5] : memref + %2 = affine.load %alloca_0[%arg9, %arg7] : memref<5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.store %4, %alloca[%arg8, %arg7] : memref<4x5xf64> + affine.yield %4 : f64 + } + } + } + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + %0 = affine.load %arg2[%arg9 + %arg7 * 5] : memref + %1 = affine.load %alloca[%arg8, %arg9] : memref<4x5xf64> + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %arg5[%arg7 + %arg6 * 16 + %arg8 * 4] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg5[%arg7 + %arg6 * 16 + %arg8 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/convection_apply_2d__original.raised.mlir b/issues/mfem_c_kernels/results/convection_apply_2d__original.raised.mlir new file mode 100644 index 000000000000..0badcaa350c0 --- /dev/null +++ b/issues/mfem_c_kernels/results/convection_apply_2d__original.raised.mlir @@ -0,0 +1,109 @@ +#map = affine_map<(d0)[s0] -> (d0 + s0 * 4)> +#map1 = affine_map<(d0)[s0, s1] -> (d0 + s0 * 16 + s1 * 4)> +#map2 = affine_map<(d0) -> (d0)> +#map3 = affine_map<(d0) -> ()> +#map4 = affine_map<(d0)[s0] -> (d0 + s0 * 5)> +#map5 = affine_map<(d0, d1, d2) -> (d2 + d0 * 5)> +#map6 = affine_map<(d0, d1, d2)[s0] -> (d1 * 4 + d0 + s0 * 16)> +#map7 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map8 = affine_map<(d0, d1, d2) -> (d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_convection_apply_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4x5xf64> + %alloca_0 = memref.alloca() : memref<5x5xf64> + %alloca_1 = memref.alloca() : memref<5x5xf64> + %alloca_2 = memref.alloca() : memref<5x5xf64> + %alloca_3 = memref.alloca() : memref<4x5xf64> + %alloca_4 = memref.alloca() : memref<4x5xf64> + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + affine.store %cst, %alloca_3[%arg7, %arg8] : memref<4x5xf64> + affine.store %cst, %alloca_4[%arg7, %arg8] : memref<4x5xf64> + %alloca_5 = memref.alloca() : memref + affine.store %cst, %alloca_5[] : memref + %alloca_6 = memref.alloca() : memref + affine.store %cst, %alloca_6[] : memref + %2 = polygeist.submap(%arg0, %arg8, %c4) {map = #map} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg4, %arg6, %arg7, %c4) {map = #map1} : (memref, index, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg8, %c4) {map = #map} : (memref, index, index) -> memref + %subview = memref.subview %alloca_4[%arg7, %arg8] [1, 1] [1, 1] : memref<4x5xf64> to memref> + %subview_7 = memref.subview %alloca_3[%arg7, %arg8] [1, 1] [1, 1] : memref<4x5xf64> to memref> + %subview_8 = memref.subview %alloca_5[] [] [] : memref to memref> + %subview_9 = memref.subview %alloca_6[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map2, #map3, #map3, #map3, #map3], iterator_types = ["reduction"]} ins(%2, %3, %4 : memref, memref, memref) outs(%subview, %subview_7, %subview_8, %subview_9 : memref>, memref>, memref>, memref>) { + ^bb0(%in: f64, %in_10: f64, %in_11: f64, %out: f64, %out_12: f64, %out_13: f64, %out_14: f64): + %5 = arith.mulf %in, %in_10 : f64 + %6 = arith.addf %out_14, %5 : f64 + %7 = arith.mulf %in_11, %in_10 : f64 + %8 = arith.addf %out_13, %7 : f64 + linalg.yield %6, %8, %8, %6 : f64, f64, f64, f64 + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.store %cst, %alloca_1[%arg8, %arg7] : memref<5x5xf64> + affine.store %cst, %alloca_2[%arg8, %arg7] : memref<5x5xf64> + %alloca_5 = memref.alloca() : memref + affine.store %cst, %alloca_5[] : memref + %alloca_6 = memref.alloca() : memref + affine.store %cst, %alloca_6[] : memref + %2 = polygeist.submap(%arg1, %arg8, %c4) {map = #map} : (memref, index, index) -> memref + %subview = memref.subview %alloca_4[0, %arg7] [%c4, 1] [1, 1] : memref<4x5xf64> to memref> + %3 = polygeist.submap(%arg0, %arg8, %c4) {map = #map} : (memref, index, index) -> memref + %subview_7 = memref.subview %alloca_3[0, %arg7] [%c4, 1] [1, 1] : memref<4x5xf64> to memref> + %subview_8 = memref.subview %alloca_2[%arg8, %arg7] [1, 1] [1, 1] : memref<5x5xf64> to memref> + %subview_9 = memref.subview %alloca_1[%arg8, %arg7] [1, 1] [1, 1] : memref<5x5xf64> to memref> + %subview_10 = memref.subview %alloca_5[] [] [] : memref to memref> + %subview_11 = memref.subview %alloca_6[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map2, #map2, #map3, #map3, #map3, #map3], iterator_types = ["reduction"]} ins(%2, %subview, %3, %subview_7 : memref, memref>, memref, memref>) outs(%subview_8, %subview_9, %subview_10, %subview_11 : memref>, memref>, memref>, memref>) { + ^bb0(%in: f64, %in_12: f64, %in_13: f64, %in_14: f64, %out: f64, %out_15: f64, %out_16: f64, %out_17: f64): + %11 = arith.mulf %in, %in_12 : f64 + %12 = arith.addf %out_17, %11 : f64 + %13 = arith.mulf %in_13, %in_14 : f64 + %14 = arith.addf %out_16, %13 : f64 + linalg.yield %12, %14, %14, %12 : f64, f64, f64, f64 + } + %4 = affine.load %arg3[%arg7 + %arg6 * 50 + %arg8 * 5] : memref + %5 = affine.load %alloca_1[%arg8, %arg7] : memref<5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg3[%arg7 + %arg6 * 50 + %arg8 * 5 + 25] : memref + %8 = affine.load %alloca_2[%arg8, %arg7] : memref<5x5xf64> + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %6, %9 : f64 + affine.store %10, %alloca_0[%arg8, %arg7] : memref<5x5xf64> + } {polygeist.was_parallel} + } {polygeist.was_parallel} + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + affine.store %cst, %alloca[%arg8, %arg7] : memref<4x5xf64> + %alloca_5 = memref.alloca() : memref + affine.store %cst, %alloca_5[] : memref + %2 = polygeist.submap(%arg2, %arg8, %c5) {map = #map4} : (memref, index, index) -> memref + %subview = memref.subview %alloca_0[0, %arg7] [%c5, 1] [1, 1] : memref<5x5xf64> to memref> + %subview_6 = memref.subview %alloca[%arg8, %arg7] [1, 1] [1, 1] : memref<4x5xf64> to memref> + %subview_7 = memref.subview %alloca_5[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map3, #map3], iterator_types = ["reduction"]} ins(%2, %subview : memref, memref>) outs(%subview_6, %subview_7 : memref>, memref>) { + ^bb0(%in: f64, %in_8: f64, %out: f64, %out_9: f64): + %3 = arith.mulf %in, %in_8 : f64 + %4 = arith.addf %out_9, %3 : f64 + linalg.yield %4, %4 : f64, f64 + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + %0 = polygeist.submap(%arg2, %c4, %c4, %c5) {map = #map5} : (memref, index, index, index) -> memref + %1 = polygeist.submap(%arg5, %arg6, %c4, %c4, %c5) {map = #map6} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map7, #map8, #map7], iterator_types = ["parallel", "parallel", "reduction"]} ins(%0, %alloca : memref, memref<4x5xf64>) outs(%1 : memref) { + ^bb0(%in: f64, %in_5: f64, %out: f64): + %2 = arith.mulf %in, %in_5 : f64 + %3 = arith.addf %out, %2 : f64 + linalg.yield %3 : f64 + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/convection_apply_2d_stage_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/convection_apply_2d_stage_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..d1a8b49548a2 --- /dev/null +++ b/issues/mfem_c_kernels/results/convection_apply_2d_stage_sliced__normalized.frontend.mlir @@ -0,0 +1,112 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_convection_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x5xf64> + %alloca_2 = memref.alloca() : memref<2x5x5xf64> + %alloca_3 = memref.alloca() : memref<2x4x5xf64> + %alloca_4 = memref.alloca() : memref<2x4x5xf64> + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg9 + %arg6 * 16 + %arg7 * 4] : memref + %2 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg6, %arg7, %arg8] : memref<2x4x5xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg9 + %arg6 * 16 + %arg7 * 4] : memref + %2 = affine.load %arg1[%arg9 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg6, %arg7, %arg8] : memref<2x4x5xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg6, %arg9, %arg8] : memref<2x4x5xf64> + %2 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg6, %arg7, %arg8] : memref<2x5x5xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg6, %arg9, %arg8] : memref<2x4x5xf64> + %2 = affine.load %arg1[%arg9 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg6, %arg7, %arg8] : memref<2x5x5xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg3[%arg9 + %arg6 * 50 + %arg7 * 5] : memref + %2 = affine.load %alloca_2[%arg6, %arg7, %arg9] : memref<2x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg3[%arg9 + %arg6 * 50 + %arg7 * 5 + 25] : memref + %5 = affine.load %alloca_1[%arg6, %arg7, %arg9] : memref<2x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg2[%arg9 + %arg8 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg10, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_0[%arg6, %arg7, %arg8] : memref<2x5x4xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %alloca_0[%arg6, %arg9, %arg8] : memref<2x5x4xf64> + %2 = affine.load %arg2[%arg9 + %arg7 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg6, %arg7, %arg8] : memref<2x4x4xf64> + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %alloca[%arg6, %arg7, %arg8] : memref<2x4x4xf64> + %1 = affine.load %arg5[%arg8 + %arg6 * 16 + %arg7 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg5[%arg8 + %arg6 * 16 + %arg7 * 4] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/convection_apply_2d_stage_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/convection_apply_2d_stage_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..1d3b62df9adf --- /dev/null +++ b/issues/mfem_c_kernels/results/convection_apply_2d_stage_sliced__normalized.raised.mlir @@ -0,0 +1,107 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 50 + d1 * 5)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 50 + d1 * 5 + 25)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map12 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_convection_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x5xf64> + %alloca_2 = memref.alloca() : memref<2x5x5xf64> + %alloca_3 = memref.alloca() : memref<2x4x5xf64> + %alloca_4 = memref.alloca() : memref<2x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_4 : memref<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg4, %c2, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_4 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_5: f64, %out: f64): + %11 = arith.mulf %in, %in_5 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg4, %c2, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%2, %3 : memref, memref) outs(%alloca_3 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_5: f64, %out: f64): + %11 = arith.mulf %in, %in_5 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg0, %c2, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_3, %4 : memref<2x4x5xf64>, memref) outs(%alloca_2 : memref<2x5x5xf64>) { + ^bb0(%in: f64, %in_5: f64, %out: f64): + %11 = arith.mulf %in, %in_5 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %5 = polygeist.submap(%arg1, %c2, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_4, %5 : memref<2x4x5xf64>, memref) outs(%alloca_1 : memref<2x5x5xf64>) { + ^bb0(%in: f64, %in_5: f64, %out: f64): + %11 = arith.mulf %in, %in_5 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg3, %c2, %c5, %c4, %c5) {map = #map7} : (memref, index, index, index, index) -> memref + %7 = polygeist.submap(%arg3, %c2, %c5, %c4, %c5) {map = #map8} : (memref, index, index, index, index) -> memref + %8 = polygeist.submap(%arg2, %c2, %c5, %c4, %c5) {map = #map9} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map10, #map3, #map10, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%6, %alloca_2, %7, %alloca_1, %8 : memref, memref<2x5x5xf64>, memref, memref<2x5x5xf64>, memref) outs(%alloca_0 : memref<2x5x4xf64>) { + ^bb0(%in: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %11 = arith.mulf %in, %in_5 : f64 + %12 = arith.mulf %in_6, %in_7 : f64 + %13 = arith.addf %11, %12 : f64 + %14 = arith.mulf %13, %in_8 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca : memref<2x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %9 = polygeist.submap(%arg2, %c2, %c4, %c4, %c5) {map = #map11} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_0, %9 : memref<2x5x4xf64>, memref) outs(%alloca : memref<2x4x4xf64>) { + ^bb0(%in: f64, %in_5: f64, %out: f64): + %11 = arith.mulf %in, %in_5 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + %10 = polygeist.submap(%arg5, %c2, %c4, %c4) {map = #map12} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%alloca : memref<2x4x4xf64>) outs(%10 : memref) { + ^bb0(%in: f64, %out: f64): + %11 = arith.addf %out, %in : f64 + linalg.yield %11 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/convection_apply_3d__original.frontend.mlir b/issues/mfem_c_kernels/results/convection_apply_3d__original.frontend.mlir new file mode 100644 index 000000000000..48db72f047c9 --- /dev/null +++ b/issues/mfem_c_kernels/results/convection_apply_3d__original.frontend.mlir @@ -0,0 +1,148 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_convection_apply_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4x4x5xf64> + %alloca_0 = memref.alloca() : memref<4x5x5xf64> + %alloca_1 = memref.alloca() : memref<5x5x5xf64> + %alloca_2 = memref.alloca() : memref<5x5x5xf64> + %alloca_3 = memref.alloca() : memref<5x5x5xf64> + %alloca_4 = memref.alloca() : memref<5x5x5xf64> + %alloca_5 = memref.alloca() : memref<4x5x5xf64> + %alloca_6 = memref.alloca() : memref<4x5x5xf64> + %alloca_7 = memref.alloca() : memref<4x5x5xf64> + %alloca_8 = memref.alloca() : memref<4x4x5xf64> + %alloca_9 = memref.alloca() : memref<4x4x5xf64> + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.store %cst, %alloca_8[%arg7, %arg8, %arg9] : memref<4x4x5xf64> + affine.store %cst, %alloca_9[%arg7, %arg8, %arg9] : memref<4x4x5xf64> + %0:2 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst, %arg12 = %cst) -> (f64, f64) { + %1 = affine.load %arg0[%arg10 + %arg9 * 4] : memref + %2 = affine.load %arg4[%arg6 * 64 + %arg10 + %arg7 * 16 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.store %4, %alloca_9[%arg7, %arg8, %arg9] : memref<4x4x5xf64> + %5 = affine.load %arg1[%arg10 + %arg9 * 4] : memref + %6 = arith.mulf %5, %2 : f64 + %7 = arith.addf %arg11, %6 : f64 + affine.store %7, %alloca_8[%arg7, %arg8, %arg9] : memref<4x4x5xf64> + affine.yield %7, %4 : f64, f64 + } + } + } + } + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.store %cst, %alloca_5[%arg7, %arg9, %arg8] : memref<4x5x5xf64> + affine.store %cst, %alloca_6[%arg7, %arg9, %arg8] : memref<4x5x5xf64> + affine.store %cst, %alloca_7[%arg7, %arg9, %arg8] : memref<4x5x5xf64> + %0:3 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst, %arg12 = %cst, %arg13 = %cst) -> (f64, f64, f64) { + %1 = affine.load %arg0[%arg10 + %arg9 * 4] : memref + %2 = affine.load %alloca_9[%arg7, %arg10, %arg8] : memref<4x4x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg13, %3 : f64 + affine.store %4, %alloca_7[%arg7, %arg9, %arg8] : memref<4x5x5xf64> + %5 = affine.load %arg1[%arg10 + %arg9 * 4] : memref + %6 = arith.mulf %5, %2 : f64 + %7 = arith.addf %arg12, %6 : f64 + affine.store %7, %alloca_6[%arg7, %arg9, %arg8] : memref<4x5x5xf64> + %8 = affine.load %arg0[%arg10 + %arg9 * 4] : memref + %9 = affine.load %alloca_8[%arg7, %arg10, %arg8] : memref<4x4x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %arg11, %10 : f64 + affine.store %11, %alloca_5[%arg7, %arg9, %arg8] : memref<4x5x5xf64> + affine.yield %11, %7, %4 : f64, f64, f64 + } + } + } + } + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.store %cst, %alloca_2[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + affine.store %cst, %alloca_3[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + affine.store %cst, %alloca_4[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + %0:3 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst, %arg12 = %cst, %arg13 = %cst) -> (f64, f64, f64) { + %12 = affine.load %arg1[%arg10 + %arg9 * 4] : memref + %13 = affine.load %alloca_7[%arg10, %arg8, %arg7] : memref<4x5x5xf64> + %14 = arith.mulf %12, %13 : f64 + %15 = arith.addf %arg13, %14 : f64 + affine.store %15, %alloca_4[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + %16 = affine.load %arg0[%arg10 + %arg9 * 4] : memref + %17 = affine.load %alloca_6[%arg10, %arg8, %arg7] : memref<4x5x5xf64> + %18 = arith.mulf %16, %17 : f64 + %19 = arith.addf %arg12, %18 : f64 + affine.store %19, %alloca_3[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + %20 = affine.load %arg0[%arg10 + %arg9 * 4] : memref + %21 = affine.load %alloca_5[%arg10, %arg8, %arg7] : memref<4x5x5xf64> + %22 = arith.mulf %20, %21 : f64 + %23 = arith.addf %arg11, %22 : f64 + affine.store %23, %alloca_2[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + affine.yield %23, %19, %15 : f64, f64, f64 + } + %1 = affine.load %arg3[%arg6 * 375 + %arg7 + %arg9 * 25 + %arg8 * 5] : memref + %2 = affine.load %alloca_2[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg3[%arg6 * 375 + %arg7 + %arg9 * 25 + %arg8 * 5 + 125] : memref + %5 = affine.load %alloca_3[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg3[%arg6 * 375 + %arg7 + %arg9 * 25 + %arg8 * 5 + 250] : memref + %9 = affine.load %alloca_4[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + affine.store %11, %alloca_1[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + } + } + } + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.store %cst, %alloca_0[%arg9, %arg8, %arg7] : memref<4x5x5xf64> + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg2[%arg10 + %arg9 * 5] : memref + %2 = affine.load %alloca_1[%arg10, %arg8, %arg7] : memref<5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.store %4, %alloca_0[%arg9, %arg8, %arg7] : memref<4x5x5xf64> + affine.yield %4 : f64 + } + } + } + } + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.store %cst, %alloca[%arg7, %arg9, %arg8] : memref<4x4x5xf64> + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg2[%arg10 + %arg9 * 5] : memref + %2 = affine.load %alloca_0[%arg7, %arg10, %arg8] : memref<4x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.store %4, %alloca[%arg7, %arg9, %arg8] : memref<4x4x5xf64> + affine.yield %4 : f64 + } + } + } + } + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.load %arg2[%arg10 + %arg9 * 5] : memref + %1 = affine.load %alloca[%arg7, %arg8, %arg10] : memref<4x4x5xf64> + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %arg5[%arg6 * 64 + %arg9 + %arg7 * 16 + %arg8 * 4] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg5[%arg6 * 64 + %arg9 + %arg7 * 16 + %arg8 * 4] : memref + } + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/convection_apply_3d__original.raised.mlir b/issues/mfem_c_kernels/results/convection_apply_3d__original.raised.mlir new file mode 100644 index 000000000000..9a67755d4176 --- /dev/null +++ b/issues/mfem_c_kernels/results/convection_apply_3d__original.raised.mlir @@ -0,0 +1,188 @@ +#map = affine_map<(d0)[s0] -> (d0 + s0 * 4)> +#map1 = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 64 + s1 * 16 + s2 * 4)> +#map2 = affine_map<(d0) -> (d0)> +#map3 = affine_map<(d0) -> ()> +#map4 = affine_map<(d0)[s0] -> (d0 + s0 * 5)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map6 = affine_map<(d0, d1, d2, d3)[s0] -> (d2 + s0 * 64 + d0 * 16 + d1 * 4)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_convection_apply_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4x4x5xf64> + %alloca_0 = memref.alloca() : memref<4x5x5xf64> + %alloca_1 = memref.alloca() : memref<5x5x5xf64> + %alloca_2 = memref.alloca() : memref<5x5x5xf64> + %alloca_3 = memref.alloca() : memref<5x5x5xf64> + %alloca_4 = memref.alloca() : memref<5x5x5xf64> + %alloca_5 = memref.alloca() : memref<4x5x5xf64> + %alloca_6 = memref.alloca() : memref<4x5x5xf64> + %alloca_7 = memref.alloca() : memref<4x5x5xf64> + %alloca_8 = memref.alloca() : memref<4x4x5xf64> + %alloca_9 = memref.alloca() : memref<4x4x5xf64> + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.store %cst, %alloca_8[%arg7, %arg8, %arg9] : memref<4x4x5xf64> + affine.store %cst, %alloca_9[%arg7, %arg8, %arg9] : memref<4x4x5xf64> + %alloca_10 = memref.alloca() : memref + affine.store %cst, %alloca_10[] : memref + %alloca_11 = memref.alloca() : memref + affine.store %cst, %alloca_11[] : memref + %2 = polygeist.submap(%arg0, %arg9, %c4) {map = #map} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg4, %arg6, %arg7, %arg8, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg9, %c4) {map = #map} : (memref, index, index) -> memref + %subview = memref.subview %alloca_9[%arg7, %arg8, %arg9] [1, 1, 1] [1, 1, 1] : memref<4x4x5xf64> to memref> + %subview_12 = memref.subview %alloca_8[%arg7, %arg8, %arg9] [1, 1, 1] [1, 1, 1] : memref<4x4x5xf64> to memref> + %subview_13 = memref.subview %alloca_10[] [] [] : memref to memref> + %subview_14 = memref.subview %alloca_11[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map2, #map3, #map3, #map3, #map3], iterator_types = ["reduction"]} ins(%2, %3, %4 : memref, memref, memref) outs(%subview, %subview_12, %subview_13, %subview_14 : memref>, memref>, memref>, memref>) { + ^bb0(%in: f64, %in_15: f64, %in_16: f64, %out: f64, %out_17: f64, %out_18: f64, %out_19: f64): + %5 = arith.mulf %in, %in_15 : f64 + %6 = arith.addf %out_19, %5 : f64 + %7 = arith.mulf %in_16, %in_15 : f64 + %8 = arith.addf %out_18, %7 : f64 + linalg.yield %6, %8, %8, %6 : f64, f64, f64, f64 + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.store %cst, %alloca_5[%arg7, %arg9, %arg8] : memref<4x5x5xf64> + affine.store %cst, %alloca_6[%arg7, %arg9, %arg8] : memref<4x5x5xf64> + affine.store %cst, %alloca_7[%arg7, %arg9, %arg8] : memref<4x5x5xf64> + %alloca_10 = memref.alloca() : memref + affine.store %cst, %alloca_10[] : memref + %alloca_11 = memref.alloca() : memref + affine.store %cst, %alloca_11[] : memref + %alloca_12 = memref.alloca() : memref + affine.store %cst, %alloca_12[] : memref + %2 = polygeist.submap(%arg0, %arg9, %c4) {map = #map} : (memref, index, index) -> memref + %subview = memref.subview %alloca_9[%arg7, 0, %arg8] [1, %c4, 1] [1, 1, 1] : memref<4x4x5xf64> to memref> + %3 = polygeist.submap(%arg1, %arg9, %c4) {map = #map} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg0, %arg9, %c4) {map = #map} : (memref, index, index) -> memref + %subview_13 = memref.subview %alloca_8[%arg7, 0, %arg8] [1, %c4, 1] [1, 1, 1] : memref<4x4x5xf64> to memref> + %subview_14 = memref.subview %alloca_7[%arg7, %arg9, %arg8] [1, 1, 1] [1, 1, 1] : memref<4x5x5xf64> to memref> + %subview_15 = memref.subview %alloca_6[%arg7, %arg9, %arg8] [1, 1, 1] [1, 1, 1] : memref<4x5x5xf64> to memref> + %subview_16 = memref.subview %alloca_5[%arg7, %arg9, %arg8] [1, 1, 1] [1, 1, 1] : memref<4x5x5xf64> to memref> + %subview_17 = memref.subview %alloca_10[] [] [] : memref to memref> + %subview_18 = memref.subview %alloca_11[] [] [] : memref to memref> + %subview_19 = memref.subview %alloca_12[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map2, #map2, #map2, #map3, #map3, #map3, #map3, #map3, #map3], iterator_types = ["reduction"]} ins(%2, %subview, %3, %4, %subview_13 : memref, memref>, memref, memref, memref>) outs(%subview_14, %subview_15, %subview_16, %subview_17, %subview_18, %subview_19 : memref>, memref>, memref>, memref>, memref>, memref>) { + ^bb0(%in: f64, %in_20: f64, %in_21: f64, %in_22: f64, %in_23: f64, %out: f64, %out_24: f64, %out_25: f64, %out_26: f64, %out_27: f64, %out_28: f64): + %5 = arith.mulf %in, %in_20 : f64 + %6 = arith.addf %out_28, %5 : f64 + %7 = arith.mulf %in_21, %in_20 : f64 + %8 = arith.addf %out_27, %7 : f64 + %9 = arith.mulf %in_22, %in_23 : f64 + %10 = arith.addf %out_26, %9 : f64 + linalg.yield %6, %8, %10, %10, %8, %6 : f64, f64, f64, f64, f64, f64 + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.store %cst, %alloca_2[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + affine.store %cst, %alloca_3[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + affine.store %cst, %alloca_4[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + %alloca_10 = memref.alloca() : memref + affine.store %cst, %alloca_10[] : memref + %alloca_11 = memref.alloca() : memref + affine.store %cst, %alloca_11[] : memref + %alloca_12 = memref.alloca() : memref + affine.store %cst, %alloca_12[] : memref + %2 = polygeist.submap(%arg1, %arg9, %c4) {map = #map} : (memref, index, index) -> memref + %subview = memref.subview %alloca_7[0, %arg8, %arg7] [%c4, 1, 1] [1, 1, 1] : memref<4x5x5xf64> to memref> + %3 = polygeist.submap(%arg0, %arg9, %c4) {map = #map} : (memref, index, index) -> memref + %subview_13 = memref.subview %alloca_6[0, %arg8, %arg7] [%c4, 1, 1] [1, 1, 1] : memref<4x5x5xf64> to memref> + %4 = polygeist.submap(%arg0, %arg9, %c4) {map = #map} : (memref, index, index) -> memref + %subview_14 = memref.subview %alloca_5[0, %arg8, %arg7] [%c4, 1, 1] [1, 1, 1] : memref<4x5x5xf64> to memref> + %subview_15 = memref.subview %alloca_4[%arg9, %arg8, %arg7] [1, 1, 1] [1, 1, 1] : memref<5x5x5xf64> to memref> + %subview_16 = memref.subview %alloca_3[%arg9, %arg8, %arg7] [1, 1, 1] [1, 1, 1] : memref<5x5x5xf64> to memref> + %subview_17 = memref.subview %alloca_2[%arg9, %arg8, %arg7] [1, 1, 1] [1, 1, 1] : memref<5x5x5xf64> to memref> + %subview_18 = memref.subview %alloca_10[] [] [] : memref to memref> + %subview_19 = memref.subview %alloca_11[] [] [] : memref to memref> + %subview_20 = memref.subview %alloca_12[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map2, #map2, #map2, #map2, #map3, #map3, #map3, #map3, #map3, #map3], iterator_types = ["reduction"]} ins(%2, %subview, %3, %subview_13, %4, %subview_14 : memref, memref>, memref, memref>, memref, memref>) outs(%subview_15, %subview_16, %subview_17, %subview_18, %subview_19, %subview_20 : memref>, memref>, memref>, memref>, memref>, memref>) { + ^bb0(%in: f64, %in_21: f64, %in_22: f64, %in_23: f64, %in_24: f64, %in_25: f64, %out: f64, %out_26: f64, %out_27: f64, %out_28: f64, %out_29: f64, %out_30: f64): + %16 = arith.mulf %in, %in_21 : f64 + %17 = arith.addf %out_30, %16 : f64 + %18 = arith.mulf %in_22, %in_23 : f64 + %19 = arith.addf %out_29, %18 : f64 + %20 = arith.mulf %in_24, %in_25 : f64 + %21 = arith.addf %out_28, %20 : f64 + linalg.yield %17, %19, %21, %21, %19, %17 : f64, f64, f64, f64, f64, f64 + } + %5 = affine.load %arg3[%arg6 * 375 + %arg7 + %arg9 * 25 + %arg8 * 5] : memref + %6 = affine.load %alloca_2[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg3[%arg6 * 375 + %arg7 + %arg9 * 25 + %arg8 * 5 + 125] : memref + %9 = affine.load %alloca_3[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg3[%arg6 * 375 + %arg7 + %arg9 * 25 + %arg8 * 5 + 250] : memref + %13 = affine.load %alloca_4[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + %14 = arith.mulf %12, %13 : f64 + %15 = arith.addf %11, %14 : f64 + affine.store %15, %alloca_1[%arg9, %arg8, %arg7] : memref<5x5x5xf64> + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.store %cst, %alloca_0[%arg9, %arg8, %arg7] : memref<4x5x5xf64> + %alloca_10 = memref.alloca() : memref + affine.store %cst, %alloca_10[] : memref + %2 = polygeist.submap(%arg2, %arg9, %c5) {map = #map4} : (memref, index, index) -> memref + %subview = memref.subview %alloca_1[0, %arg8, %arg7] [%c5, 1, 1] [1, 1, 1] : memref<5x5x5xf64> to memref> + %subview_11 = memref.subview %alloca_0[%arg9, %arg8, %arg7] [1, 1, 1] [1, 1, 1] : memref<4x5x5xf64> to memref> + %subview_12 = memref.subview %alloca_10[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map3, #map3], iterator_types = ["reduction"]} ins(%2, %subview : memref, memref>) outs(%subview_11, %subview_12 : memref>, memref>) { + ^bb0(%in: f64, %in_13: f64, %out: f64, %out_14: f64): + %3 = arith.mulf %in, %in_13 : f64 + %4 = arith.addf %out_14, %3 : f64 + linalg.yield %4, %4 : f64, f64 + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.store %cst, %alloca[%arg7, %arg9, %arg8] : memref<4x4x5xf64> + %alloca_10 = memref.alloca() : memref + affine.store %cst, %alloca_10[] : memref + %2 = polygeist.submap(%arg2, %arg9, %c5) {map = #map4} : (memref, index, index) -> memref + %subview = memref.subview %alloca_0[%arg7, 0, %arg8] [1, %c5, 1] [1, 1, 1] : memref<4x5x5xf64> to memref> + %subview_11 = memref.subview %alloca[%arg7, %arg9, %arg8] [1, 1, 1] [1, 1, 1] : memref<4x4x5xf64> to memref> + %subview_12 = memref.subview %alloca_10[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map3, #map3], iterator_types = ["reduction"]} ins(%2, %subview : memref, memref>) outs(%subview_11, %subview_12 : memref>, memref>) { + ^bb0(%in: f64, %in_13: f64, %out: f64, %out_14: f64): + %3 = arith.mulf %in, %in_13 : f64 + %4 = arith.addf %out_14, %3 : f64 + linalg.yield %4, %4 : f64, f64 + } + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + %0 = polygeist.submap(%arg2, %c4, %c4, %c4, %c5) {map = #map5} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg5, %arg6, %c4, %c4, %c4, %c5) {map = #map6} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map7, #map8, #map7], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%0, %alloca : memref, memref<4x4x5xf64>) outs(%1 : memref) { + ^bb0(%in: f64, %in_10: f64, %out: f64): + %2 = arith.mulf %in, %in_10 : f64 + %3 = arith.addf %out, %2 : f64 + linalg.yield %3 : f64 + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/convection_apply_3d_stage_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/convection_apply_3d_stage_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..af0b388234f5 --- /dev/null +++ b/issues/mfem_c_kernels/results/convection_apply_3d_stage_sliced__normalized.frontend.mlir @@ -0,0 +1,215 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_convection_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_5 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_8 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg6 * 64 + %arg10 + %arg7 * 16 + %arg8 * 4] : memref + %2 = affine.load %arg0[%arg10 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg6, %arg7, %arg8, %arg9] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg6 * 64 + %arg10 + %arg7 * 16 + %arg8 * 4] : memref + %2 = affine.load %arg1[%arg10 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg6, %arg7, %arg8, %arg9] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg6, %arg7, %arg10, %arg9] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg10 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg6, %arg7, %arg8, %arg9] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg6, %arg7, %arg10, %arg9] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg10 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg6, %arg7, %arg8, %arg9] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg6, %arg7, %arg10, %arg9] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg10 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg6, %arg7, %arg8, %arg9] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg6, %arg10, %arg8, %arg9] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg10 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg6, %arg7, %arg8, %arg9] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg6, %arg10, %arg8, %arg9] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg10 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg6, %arg7, %arg8, %arg9] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg6, %arg10, %arg8, %arg9] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg10 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg6, %arg7, %arg8, %arg9] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg3[%arg6 * 375 + %arg10 + %arg7 * 25 + %arg8 * 5] : memref + %2 = affine.load %alloca_4[%arg6, %arg7, %arg8, %arg10] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg3[%arg6 * 375 + %arg10 + %arg7 * 25 + %arg8 * 5 + 125] : memref + %5 = affine.load %alloca_3[%arg6, %arg7, %arg8, %arg10] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg3[%arg6 * 375 + %arg10 + %arg7 * 25 + %arg8 * 5 + 250] : memref + %9 = affine.load %alloca_2[%arg6, %arg7, %arg8, %arg10] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg10 + %arg9 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg11, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_1[%arg6, %arg7, %arg8, %arg9] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_1[%arg6, %arg7, %arg10, %arg9] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg10 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg6, %arg7, %arg8, %arg9] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_0[%arg6, %arg10, %arg8, %arg9] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg10 + %arg7 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg6, %arg7, %arg8, %arg9] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + %0 = affine.load %alloca[%arg6, %arg7, %arg8, %arg9] : memref<2x4x4x4xf64> + %1 = affine.load %arg5[%arg6 * 64 + %arg9 + %arg7 * 16 + %arg8 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg5[%arg6 * 64 + %arg9 + %arg7 * 16 + %arg8 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/convection_apply_3d_stage_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/convection_apply_3d_stage_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..63177a493d6f --- /dev/null +++ b/issues/mfem_c_kernels/results/convection_apply_3d_stage_sliced__normalized.raised.mlir @@ -0,0 +1,174 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 375 + d1 * 25 + d2 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 375 + d1 * 25 + d2 * 5 + 125)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 375 + d1 * 25 + d2 * 5 + 250)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map16 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_convection_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_5 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_8 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_9 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg4, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_9 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_10: f64, %out: f64): + %17 = arith.mulf %in, %in_10 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_8 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg4, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%2, %3 : memref, memref) outs(%alloca_8 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_10: f64, %out: f64): + %17 = arith.mulf %in, %in_10 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_7 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_8, %4 : memref<2x4x4x5xf64>, memref) outs(%alloca_7 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_10: f64, %out: f64): + %17 = arith.mulf %in, %in_10 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_6 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %5 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_9, %5 : memref<2x4x4x5xf64>, memref) outs(%alloca_6 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_10: f64, %out: f64): + %17 = arith.mulf %in, %in_10 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_5 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_9, %6 : memref<2x4x4x5xf64>, memref) outs(%alloca_5 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_10: f64, %out: f64): + %17 = arith.mulf %in, %in_10 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_4 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %7 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_7, %7 : memref<2x4x5x5xf64>, memref) outs(%alloca_4 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_10: f64, %out: f64): + %17 = arith.mulf %in, %in_10 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_6, %8 : memref<2x4x5x5xf64>, memref) outs(%alloca_3 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_10: f64, %out: f64): + %17 = arith.mulf %in, %in_10 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %9 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_5, %9 : memref<2x4x5x5xf64>, memref) outs(%alloca_2 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_10: f64, %out: f64): + %17 = arith.mulf %in, %in_10 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %10 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (memref, index, index, index, index, index) -> memref + %11 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (memref, index, index, index, index, index) -> memref + %12 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (memref, index, index, index, index, index) -> memref + %13 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%10, %alloca_4, %11, %alloca_3, %12, %alloca_2, %13 : memref, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref) outs(%alloca_1 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %out: f64): + %17 = arith.mulf %in, %in_10 : f64 + %18 = arith.mulf %in_11, %in_12 : f64 + %19 = arith.addf %17, %18 : f64 + %20 = arith.mulf %in_13, %in_14 : f64 + %21 = arith.addf %19, %20 : f64 + %22 = arith.mulf %21, %in_15 : f64 + %23 = arith.addf %out, %22 : f64 + linalg.yield %23 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg2, %c2, %c5, %c4, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_1, %14 : memref<2x5x5x4xf64>, memref) outs(%alloca_0 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_10: f64, %out: f64): + %17 = arith.mulf %in, %in_10 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %15 = polygeist.submap(%arg2, %c2, %c4, %c4, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_0, %15 : memref<2x5x4x4xf64>, memref) outs(%alloca : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_10: f64, %out: f64): + %17 = arith.mulf %in, %in_10 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } + %16 = polygeist.submap(%arg5, %c2, %c4, %c4, %c4) {map = #map16} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%alloca : memref<2x4x4x4xf64>) outs(%16 : memref) { + ^bb0(%in: f64, %out: f64): + %17 = arith.addf %out, %in : f64 + linalg.yield %17 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/curlcurl_apply_2d__original.frontend.mlir b/issues/mfem_c_kernels/results/curlcurl_apply_2d__original.frontend.mlir new file mode 100644 index 000000000000..6b1427618c78 --- /dev/null +++ b/issues/mfem_c_kernels/results/curlcurl_apply_2d__original.frontend.mlir @@ -0,0 +1,178 @@ +#set = affine_set<(d0) : (d0 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_curlcurl_apply_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c24_i32 = arith.constant 24 : i32 + %c4_i32 = arith.constant 4 : i32 + %c3_i32 = arith.constant 3 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f64 + %c5_i32 = arith.constant 5 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<4xf64> + %alloca_0 = memref.alloca() : memref<5xf64> + %alloca_1 = memref.alloca() : memref<5x5xf64> + affine.for %arg7 = 0 to 2 { + %0 = arith.index_cast %arg7 : index to i32 + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.store %cst, %alloca_1[%arg8, %arg9] : memref<5x5xf64> + } + } + %1 = arith.muli %0, %c24_i32 : i32 + %2 = affine.for %arg8 = 0 to 2 iter_args(%arg9 = %c0_i32) -> (i32) { + %3 = arith.index_cast %arg8 : index to i32 + %4 = arith.cmpi eq, %3, %c1_i32 : i32 + %5 = arith.select %4, %c3_i32, %c4_i32 : i32 + %6 = arith.cmpi eq, %3, %c0_i32 : i32 + %7 = arith.select %6, %c3_i32, %c4_i32 : i32 + %8 = arith.index_cast %5 : i32 to index + %9 = arith.index_cast %7 : i32 to index + scf.for %arg10 = %c0 to %8 step %c1 { + %12 = arith.index_cast %arg10 : index to i32 + affine.for %arg11 = 0 to 5 { + affine.store %cst, %alloca_0[%arg11] : memref<5xf64> + } + %13 = arith.muli %12, %7 : i32 + scf.for %arg11 = %c0 to %9 step %c1 { + %14 = arith.index_cast %arg11 : index to i32 + %15 = arith.addi %14, %13 : i32 + %16 = arith.addi %15, %arg9 : i32 + %17 = arith.addi %16, %1 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = memref.load %arg5[%18] : memref + affine.for %arg12 = 0 to 5 { + %20 = arith.index_cast %arg12 : index to i32 + %21 = affine.if #set(%arg8) -> f64 { + %25 = arith.muli %20, %c3_i32 : i32 + %26 = arith.addi %25, %14 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = memref.load %arg0[%27] : memref + affine.yield %28 : f64 + } else { + %25 = arith.muli %20, %c4_i32 : i32 + %26 = arith.addi %25, %14 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = memref.load %arg2[%27] : memref + affine.yield %28 : f64 + } + %22 = arith.mulf %19, %21 : f64 + %23 = affine.load %alloca_0[%arg12] : memref<5xf64> + %24 = arith.addf %23, %22 : f64 + affine.store %24, %alloca_0[%arg12] : memref<5xf64> + } + } + affine.for %arg11 = 0 to 5 { + %14 = arith.index_cast %arg11 : index to i32 + %15 = affine.if #set(%arg8) -> f64 { + %16 = arith.muli %14, %c4_i32 : i32 + %17 = arith.addi %16, %12 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = memref.load %arg2[%18] : memref + %20 = arith.negf %19 : f64 + affine.yield %20 : f64 + } else { + %16 = arith.muli %14, %c3_i32 : i32 + %17 = arith.addi %16, %12 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = memref.load %arg0[%18] : memref + affine.yield %19 : f64 + } + affine.for %arg12 = 0 to 5 { + %16 = affine.load %alloca_0[%arg12] : memref<5xf64> + %17 = arith.mulf %16, %15 : f64 + %18 = affine.load %alloca_1[%arg11, %arg12] : memref<5x5xf64> + %19 = arith.addf %18, %17 : f64 + affine.store %19, %alloca_1[%arg11, %arg12] : memref<5x5xf64> + } + } + } + %10 = arith.muli %7, %5 : i32 + %11 = arith.addi %arg9, %10 : i32 + affine.yield %11 : i32 + } + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %3 = affine.load %arg4[%arg9 + %arg7 * 25 + %arg8 * 5] : memref + %4 = affine.load %alloca_1[%arg8, %arg9] : memref<5x5xf64> + %5 = arith.mulf %4, %3 : f64 + affine.store %5, %alloca_1[%arg8, %arg9] : memref<5x5xf64> + } + } + affine.for %arg8 = 0 to 5 { + %3 = arith.index_cast %arg8 : index to i32 + %4 = affine.for %arg9 = 0 to 2 iter_args(%arg10 = %c0_i32) -> (i32) { + %5 = arith.index_cast %arg9 : index to i32 + %6 = arith.cmpi eq, %5, %c1_i32 : i32 + %7 = arith.select %6, %c3_i32, %c4_i32 : i32 + %8 = arith.cmpi eq, %5, %c0_i32 : i32 + %9 = arith.select %8, %c3_i32, %c4_i32 : i32 + %10 = arith.index_cast %9 : i32 to index + scf.for %arg11 = %c0 to %10 step %c1 { + memref.store %cst, %alloca[%arg11] : memref<4xf64> + } + affine.for %arg11 = 0 to 5 { + %14 = arith.index_cast %arg11 : index to i32 + %15 = affine.load %alloca_1[%arg8, %arg11] : memref<5x5xf64> + scf.for %arg12 = %c0 to %10 step %c1 { + %16 = arith.index_cast %arg12 : index to i32 + %17 = affine.if #set(%arg9) -> f64 { + %21 = arith.muli %16, %c5_i32 : i32 + %22 = arith.addi %21, %14 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = memref.load %arg1[%23] : memref + affine.yield %24 : f64 + } else { + %21 = arith.muli %16, %c5_i32 : i32 + %22 = arith.addi %21, %14 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = memref.load %arg3[%23] : memref + affine.yield %24 : f64 + } + %18 = arith.mulf %15, %17 : f64 + %19 = memref.load %alloca[%arg12] : memref<4xf64> + %20 = arith.addf %19, %18 : f64 + memref.store %20, %alloca[%arg12] : memref<4xf64> + } + } + %11 = arith.index_cast %7 : i32 to index + scf.for %arg11 = %c0 to %11 step %c1 { + %14 = arith.index_cast %arg11 : index to i32 + %15 = affine.if #set(%arg9) -> f64 { + %17 = arith.muli %14, %c5_i32 : i32 + %18 = arith.addi %17, %3 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg3[%19] : memref + %21 = arith.negf %20 : f64 + affine.yield %21 : f64 + } else { + %17 = arith.muli %14, %c5_i32 : i32 + %18 = arith.addi %17, %3 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg1[%19] : memref + affine.yield %20 : f64 + } + %16 = arith.muli %14, %9 : i32 + scf.for %arg12 = %c0 to %10 step %c1 { + %17 = arith.index_cast %arg12 : index to i32 + %18 = arith.addi %17, %16 : i32 + %19 = arith.addi %18, %arg10 : i32 + %20 = arith.addi %19, %1 : i32 + %21 = arith.index_cast %20 : i32 to index + %22 = memref.load %alloca[%arg12] : memref<4xf64> + %23 = arith.mulf %22, %15 : f64 + %24 = memref.load %arg6[%21] : memref + %25 = arith.addf %24, %23 : f64 + memref.store %25, %arg6[%21] : memref + } + } + %12 = arith.muli %9, %7 : i32 + %13 = arith.addi %arg10, %12 : i32 + affine.yield %13 : i32 + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/curlcurl_apply_2d__original.raised.mlir b/issues/mfem_c_kernels/results/curlcurl_apply_2d__original.raised.mlir new file mode 100644 index 000000000000..3c59e8331cf5 --- /dev/null +++ b/issues/mfem_c_kernels/results/curlcurl_apply_2d__original.raised.mlir @@ -0,0 +1,175 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 25 + d0 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_curlcurl_apply_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c24_i32 = arith.constant 24 : i32 + %c4_i32 = arith.constant 4 : i32 + %c3_i32 = arith.constant 3 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f64 + %c5_i32 = arith.constant 5 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<4xf64> + %alloca_0 = memref.alloca() : memref<5xf64> + %alloca_1 = memref.alloca() : memref<5x5xf64> + affine.for %arg7 = 0 to 2 { + %0 = arith.index_cast %arg7 : index to i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%alloca_1 : memref<5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %1 = arith.muli %0, %c24_i32 : i32 + %alloca_2 = memref.alloca() : memref + affine.store %c0_i32, %alloca_2[] : memref + affine.for %arg8 = 0 to 2 { + %3 = affine.load %alloca_2[] : memref + %4 = arith.index_cast %arg8 : index to i32 + %5 = arith.cmpi eq, %4, %c1_i32 : i32 + %6 = arith.select %5, %c3_i32, %c4_i32 : i32 + %7 = arith.cmpi eq, %4, %c0_i32 : i32 + %8 = arith.select %7, %c3_i32, %c4_i32 : i32 + %9 = arith.index_cast %6 : i32 to index + %10 = arith.index_cast %8 : i32 to index + scf.for %arg9 = %c0 to %9 step %c1 { + %13 = arith.index_cast %arg9 : index to i32 + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel"]} outs(%alloca_0 : memref<5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = arith.muli %13, %8 : i32 + scf.for %arg10 = %c0 to %10 step %c1 { + %15 = arith.index_cast %arg10 : index to i32 + %16 = arith.addi %15, %14 : i32 + %17 = arith.addi %16, %3 : i32 + %18 = arith.addi %17, %1 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg5[%19] : memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel"]} outs(%alloca_0 : memref<5xf64>) { + ^bb0(%out: f64): + %21 = linalg.index 0 : index + %22 = arith.index_cast %21 : index to i32 + %23 = arith.cmpi eq, %arg8, %c0 : index + %24 = arith.muli %22, %c3_i32 : i32 + %25 = arith.addi %24, %15 : i32 + %26 = arith.index_cast %25 : i32 to index + %27 = memref.load %arg0[%26] : memref + %28 = arith.muli %22, %c4_i32 : i32 + %29 = arith.addi %28, %15 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = memref.load %arg2[%30] : memref + %32 = arith.select %23, %27, %31 : f64 + %33 = arith.mulf %20, %32 : f64 + %34 = arith.addf %out, %33 : f64 + linalg.yield %34 : f64 + } + } + affine.for %arg10 = 0 to 5 { + %15 = arith.index_cast %arg10 : index to i32 + %16 = arith.cmpi eq, %arg8, %c0 : index + %17 = arith.muli %15, %c4_i32 : i32 + %18 = arith.addi %17, %13 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg2[%19] : memref + %21 = arith.negf %20 : f64 + %22 = arith.muli %15, %c3_i32 : i32 + %23 = arith.addi %22, %13 : i32 + %24 = arith.index_cast %23 : i32 to index + %25 = memref.load %arg0[%24] : memref + %26 = arith.select %16, %21, %25 : f64 + %subview = memref.subview %alloca_0[0] [%c5] [1] : memref<5xf64> to memref> + %subview_3 = memref.subview %alloca_1[%arg10, 0] [1, %c5] [1, 1] : memref<5x5xf64> to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f64, %out: f64): + %27 = arith.mulf %in, %26 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + } + } + %11 = arith.muli %8, %6 : i32 + %12 = arith.addi %3, %11 : i32 + affine.store %12, %alloca_2[] : memref + } + %2 = polygeist.submap(%arg4, %arg7, %c5, %c5) {map = #map2} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%2 : memref) outs(%alloca_1 : memref<5x5xf64>) { + ^bb0(%in: f64, %out: f64): + %3 = arith.mulf %out, %in : f64 + linalg.yield %3 : f64 + } + affine.for %arg8 = 0 to 5 { + %3 = arith.index_cast %arg8 : index to i32 + %alloca_3 = memref.alloca() : memref + affine.store %c0_i32, %alloca_3[] : memref + affine.for %arg9 = 0 to 2 { + %4 = affine.load %alloca_3[] : memref + %5 = arith.index_cast %arg9 : index to i32 + %6 = arith.cmpi eq, %5, %c1_i32 : i32 + %7 = arith.select %6, %c3_i32, %c4_i32 : i32 + %8 = arith.cmpi eq, %5, %c0_i32 : i32 + %9 = arith.select %8, %c3_i32, %c4_i32 : i32 + %10 = arith.index_cast %9 : i32 to index + scf.for %arg10 = %c0 to %10 step %c1 { + memref.store %cst, %alloca[%arg10] : memref<4xf64> + } + affine.for %arg10 = 0 to 5 { + %14 = arith.index_cast %arg10 : index to i32 + %15 = affine.load %alloca_1[%arg8, %arg10] : memref<5x5xf64> + scf.for %arg11 = %c0 to %10 step %c1 { + %16 = arith.index_cast %arg11 : index to i32 + %17 = arith.cmpi eq, %arg9, %c0 : index + %18 = arith.muli %16, %c5_i32 : i32 + %19 = arith.addi %18, %14 : i32 + %20 = arith.index_cast %19 : i32 to index + %21 = memref.load %arg1[%20] : memref + %22 = arith.muli %16, %c5_i32 : i32 + %23 = arith.addi %22, %14 : i32 + %24 = arith.index_cast %23 : i32 to index + %25 = memref.load %arg3[%24] : memref + %26 = arith.select %17, %21, %25 : f64 + %27 = arith.mulf %15, %26 : f64 + %28 = memref.load %alloca[%arg11] : memref<4xf64> + %29 = arith.addf %28, %27 : f64 + memref.store %29, %alloca[%arg11] : memref<4xf64> + } + } + %11 = arith.index_cast %7 : i32 to index + scf.for %arg10 = %c0 to %11 step %c1 { + %14 = arith.index_cast %arg10 : index to i32 + %15 = arith.cmpi eq, %arg9, %c0 : index + %16 = arith.muli %14, %c5_i32 : i32 + %17 = arith.addi %16, %3 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = memref.load %arg3[%18] : memref + %20 = arith.negf %19 : f64 + %21 = arith.muli %14, %c5_i32 : i32 + %22 = arith.addi %21, %3 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = memref.load %arg1[%23] : memref + %25 = arith.select %15, %20, %24 : f64 + %26 = arith.muli %14, %9 : i32 + scf.for %arg11 = %c0 to %10 step %c1 { + %27 = arith.index_cast %arg11 : index to i32 + %28 = arith.addi %27, %26 : i32 + %29 = arith.addi %28, %4 : i32 + %30 = arith.addi %29, %1 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %alloca[%arg11] : memref<4xf64> + %33 = arith.mulf %32, %25 : f64 + %34 = memref.load %arg6[%31] : memref + %35 = arith.addf %34, %33 : f64 + memref.store %35, %arg6[%31] : memref + } + } + %12 = arith.muli %9, %7 : i32 + %13 = arith.addi %4, %12 : i32 + affine.store %13, %alloca_3[] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/curlcurl_apply_2d_stage_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/curlcurl_apply_2d_stage_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..9443df6bf5a8 --- /dev/null +++ b/issues/mfem_c_kernels/results/curlcurl_apply_2d_stage_sliced__normalized.frontend.mlir @@ -0,0 +1,154 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_curlcurl_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x3x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x3xf64> + %alloca_1 = memref.alloca() : memref<2x5x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x3xf64> + %alloca_3 = memref.alloca() : memref<2x5x5xf64> + %alloca_4 = memref.alloca() : memref<2x5x5xf64> + %alloca_5 = memref.alloca() : memref<2x3x5xf64> + %alloca_6 = memref.alloca() : memref<2x4x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 3 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg10 + %arg8 * 3 + %arg7 * 24] : memref + %2 = affine.load %arg0[%arg10 + %arg9 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9] : memref<2x4x5xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg7, %arg10, %arg9] : memref<2x4x5xf64> + %2 = affine.load %arg2[%arg10 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9] : memref<2x5x5xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg10 + %arg8 * 4 + %arg7 * 24 + 12] : memref + %2 = affine.load %arg2[%arg10 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9] : memref<2x3x5xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 3 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg7, %arg10, %arg9] : memref<2x3x5xf64> + %2 = affine.load %arg0[%arg10 + %arg8 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9] : memref<2x5x5xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 3 { + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg10 + %arg7 * 25 + %arg8 * 5] : memref + %2 = affine.load %alloca_3[%arg7, %arg8, %arg10] : memref<2x5x5xf64> + %3 = affine.load %alloca_4[%arg7, %arg8, %arg10] : memref<2x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg1[%arg10 + %arg9 * 5] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.addf %arg11, %7 : f64 + affine.yield %8 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9] : memref<2x5x3xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg10, %arg9] : memref<2x5x3xf64> + %2 = affine.load %arg3[%arg10 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.subf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9] : memref<2x4x3xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg10 + %arg7 * 25 + %arg8 * 5] : memref + %2 = affine.load %alloca_3[%arg7, %arg8, %arg10] : memref<2x5x5xf64> + %3 = affine.load %alloca_4[%arg7, %arg8, %arg10] : memref<2x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg3[%arg10 + %arg9 * 5] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.addf %arg11, %7 : f64 + affine.yield %8 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9] : memref<2x5x4xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_1[%arg7, %arg10, %arg9] : memref<2x5x4xf64> + %2 = affine.load %arg1[%arg10 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9] : memref<2x3x4xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + %0 = affine.load %alloca_0[%arg7, %arg8, %arg9] : memref<2x4x3xf64> + %1 = affine.load %arg6[%arg9 + %arg8 * 3 + %arg7 * 24] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg9 + %arg8 * 3 + %arg7 * 24] : memref + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + %0 = affine.load %alloca[%arg7, %arg8, %arg9] : memref<2x3x4xf64> + %1 = affine.load %arg6[%arg9 + %arg8 * 4 + %arg7 * 24 + 12] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg9 + %arg8 * 4 + %arg7 * 24 + 12] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/curlcurl_apply_2d_stage_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/curlcurl_apply_2d_stage_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..64c787111f07 --- /dev/null +++ b/issues/mfem_c_kernels/results/curlcurl_apply_2d_stage_sliced__normalized.raised.mlir @@ -0,0 +1,142 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 3 + d0 * 24)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 3)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4 + d0 * 24 + 12)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 3)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 25 + d1 * 5)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map12 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map13 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map14 = affine_map<(d0, d1, d2) -> (d2 + d1 * 3 + d0 * 24)> +#map15 = affine_map<(d0, d1, d2) -> (d2 + d1 * 4 + d0 * 24 + 12)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_curlcurl_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x3x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x3xf64> + %alloca_1 = memref.alloca() : memref<2x5x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x3xf64> + %alloca_3 = memref.alloca() : memref<2x5x5xf64> + %alloca_4 = memref.alloca() : memref<2x5x5xf64> + %alloca_5 = memref.alloca() : memref<2x3x5xf64> + %alloca_6 = memref.alloca() : memref<2x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_6 : memref<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg5, %c2, %c4, %c5, %c3) {map = #map1} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c5, %c3) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_6 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %14 = arith.mulf %in, %in_7 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_4 : memref<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_6, %2 : memref<2x4x5xf64>, memref) outs(%alloca_4 : memref<2x5x5xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %14 = arith.mulf %in, %in_7 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_5 : memref<2x3x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %3 = polygeist.submap(%arg5, %c2, %c3, %c5, %c4) {map = #map7} : (memref, index, index, index, index) -> memref + %4 = polygeist.submap(%arg2, %c2, %c3, %c5, %c4) {map = #map8} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%3, %4 : memref, memref) outs(%alloca_5 : memref<2x3x5xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %14 = arith.mulf %in, %in_7 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %5 = polygeist.submap(%arg0, %c2, %c5, %c5, %c3) {map = #map9} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_5, %5 : memref<2x3x5xf64>, memref) outs(%alloca_3 : memref<2x5x5xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %14 = arith.mulf %in, %in_7 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x5x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg4, %c2, %c5, %c3, %c5) {map = #map10} : (memref, index, index, index, index) -> memref + %7 = polygeist.submap(%arg1, %c2, %c5, %c3, %c5) {map = #map11} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map12, #map12, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%6, %alloca_3, %alloca_4, %7 : memref, memref<2x5x5xf64>, memref<2x5x5xf64>, memref) outs(%alloca_2 : memref<2x5x3xf64>) { + ^bb0(%in: f64, %in_7: f64, %in_8: f64, %in_9: f64, %out: f64): + %14 = arith.subf %in_7, %in_8 : f64 + %15 = arith.mulf %in, %14 : f64 + %16 = arith.mulf %15, %in_9 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x4x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg3, %c2, %c4, %c3, %c5) {map = #map13} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_2, %8 : memref<2x5x3xf64>, memref) outs(%alloca_0 : memref<2x4x3xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %14 = arith.mulf %in, %in_7 : f64 + %15 = arith.subf %out, %14 : f64 + linalg.yield %15 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %9 = polygeist.submap(%arg4, %c2, %c5, %c4, %c5) {map = #map10} : (memref, index, index, index, index) -> memref + %10 = polygeist.submap(%arg3, %c2, %c5, %c4, %c5) {map = #map11} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map12, #map12, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%9, %alloca_3, %alloca_4, %10 : memref, memref<2x5x5xf64>, memref<2x5x5xf64>, memref) outs(%alloca_1 : memref<2x5x4xf64>) { + ^bb0(%in: f64, %in_7: f64, %in_8: f64, %in_9: f64, %out: f64): + %14 = arith.subf %in_7, %in_8 : f64 + %15 = arith.mulf %in, %14 : f64 + %16 = arith.mulf %15, %in_9 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca : memref<2x3x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %11 = polygeist.submap(%arg1, %c2, %c3, %c4, %c5) {map = #map13} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_1, %11 : memref<2x5x4xf64>, memref) outs(%alloca : memref<2x3x4xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %14 = arith.mulf %in, %in_7 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 + } + %12 = polygeist.submap(%arg6, %c2, %c4, %c3) {map = #map14} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%alloca_0 : memref<2x4x3xf64>) outs(%12 : memref) { + ^bb0(%in: f64, %out: f64): + %14 = arith.addf %out, %in : f64 + linalg.yield %14 : f64 + } + %13 = polygeist.submap(%arg6, %c2, %c3, %c4) {map = #map15} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%alloca : memref<2x3x4xf64>) outs(%13 : memref) { + ^bb0(%in: f64, %out: f64): + %14 = arith.addf %out, %in : f64 + linalg.yield %14 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/curlcurl_apply_3d__original.frontend.mlir b/issues/mfem_c_kernels/results/curlcurl_apply_3d__original.frontend.mlir new file mode 100644 index 000000000000..13d22f68c811 --- /dev/null +++ b/issues/mfem_c_kernels/results/curlcurl_apply_3d__original.frontend.mlir @@ -0,0 +1,421 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_curlcurl_apply_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<3x2xf64> + %alloca_0 = memref.alloca() : memref<3x4xf64> + %alloca_1 = memref.alloca() : memref<3x4xf64> + %alloca_2 = memref.alloca() : memref<3x2xf64> + %alloca_3 = memref.alloca() : memref<3x4xf64> + %alloca_4 = memref.alloca() : memref<3x4xf64> + %alloca_5 = memref.alloca() : memref<3x2xf64> + %alloca_6 = memref.alloca() : memref<4x3xf64> + %alloca_7 = memref.alloca() : memref<4x3xf64> + %alloca_8 = memref.alloca() : memref<5xf64> + %alloca_9 = memref.alloca() : memref<5x5x2xf64> + %alloca_10 = memref.alloca() : memref<5xf64> + %alloca_11 = memref.alloca() : memref<5x5x2xf64> + %alloca_12 = memref.alloca() : memref<5xf64> + %alloca_13 = memref.alloca() : memref<5x5x2xf64> + %alloca_14 = memref.alloca() : memref<5x5x5x3xf64> + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 3 { + affine.store %cst, %alloca_14[%arg10, %arg11, %arg12, %arg13] : memref<5x5x5x3xf64> + } + } + } + } + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.store %cst, %alloca_13[%arg11, %arg12, 1] : memref<5x5x2xf64> + affine.store %cst, %alloca_13[%arg11, %arg12, 0] : memref<5x5x2xf64> + } + } + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + affine.store %cst, %alloca_12[%arg12] : memref<5xf64> + } + affine.for %arg12 = 0 to 3 { + %0 = affine.load %arg7[%arg10 * 12 + %arg12 + %arg11 * 3 + %arg9 * 144] : memref + affine.for %arg13 = 0 to 5 { + %1 = affine.load %arg0[%arg12 + %arg13 * 3] : memref + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %alloca_12[%arg13] : memref<5xf64> + %4 = arith.addf %3, %2 : f64 + affine.store %4, %alloca_12[%arg13] : memref<5xf64> + } + } + affine.for %arg12 = 0 to 5 { + %0 = affine.load %arg4[%arg11 + %arg12 * 4] : memref + %1 = affine.load %arg1[%arg11 + %arg12 * 4] : memref + affine.for %arg13 = 0 to 5 { + %2 = affine.load %alloca_12[%arg13] : memref<5xf64> + %3 = arith.mulf %2, %0 : f64 + %4 = affine.load %alloca_13[%arg12, %arg13, 0] : memref<5x5x2xf64> + %5 = arith.addf %4, %3 : f64 + affine.store %5, %alloca_13[%arg12, %arg13, 0] : memref<5x5x2xf64> + %6 = arith.mulf %2, %1 : f64 + %7 = affine.load %alloca_13[%arg12, %arg13, 1] : memref<5x5x2xf64> + %8 = arith.addf %7, %6 : f64 + affine.store %8, %alloca_13[%arg12, %arg13, 1] : memref<5x5x2xf64> + } + } + } + affine.for %arg11 = 0 to 5 { + %0 = affine.load %arg4[%arg10 + %arg11 * 4] : memref + %1 = affine.load %arg1[%arg10 + %arg11 * 4] : memref + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %2 = affine.load %alloca_13[%arg12, %arg13, 1] : memref<5x5x2xf64> + %3 = arith.mulf %2, %0 : f64 + %4 = affine.load %alloca_14[%arg11, %arg12, %arg13, 1] : memref<5x5x5x3xf64> + %5 = arith.addf %4, %3 : f64 + affine.store %5, %alloca_14[%arg11, %arg12, %arg13, 1] : memref<5x5x5x3xf64> + %6 = affine.load %alloca_13[%arg12, %arg13, 0] : memref<5x5x2xf64> + %7 = arith.mulf %6, %1 : f64 + %8 = affine.load %alloca_14[%arg11, %arg12, %arg13, 2] : memref<5x5x5x3xf64> + %9 = arith.subf %8, %7 : f64 + affine.store %9, %alloca_14[%arg11, %arg12, %arg13, 2] : memref<5x5x5x3xf64> + } + } + } + } + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.store %cst, %alloca_11[%arg11, %arg12, 1] : memref<5x5x2xf64> + affine.store %cst, %alloca_11[%arg11, %arg12, 0] : memref<5x5x2xf64> + } + } + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + affine.store %cst, %alloca_10[%arg12] : memref<5xf64> + } + affine.for %arg12 = 0 to 3 { + %0 = affine.load %arg7[%arg10 * 12 + %arg11 + %arg12 * 4 + %arg9 * 144 + 48] : memref + affine.for %arg13 = 0 to 5 { + %1 = affine.load %arg0[%arg12 + %arg13 * 3] : memref + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %alloca_10[%arg13] : memref<5xf64> + %4 = arith.addf %3, %2 : f64 + affine.store %4, %alloca_10[%arg13] : memref<5xf64> + } + } + affine.for %arg12 = 0 to 5 { + %0 = affine.load %arg4[%arg11 + %arg12 * 4] : memref + %1 = affine.load %arg1[%arg11 + %arg12 * 4] : memref + affine.for %arg13 = 0 to 5 { + %2 = affine.load %alloca_10[%arg13] : memref<5xf64> + %3 = arith.mulf %0, %2 : f64 + %4 = affine.load %alloca_11[%arg13, %arg12, 0] : memref<5x5x2xf64> + %5 = arith.addf %4, %3 : f64 + affine.store %5, %alloca_11[%arg13, %arg12, 0] : memref<5x5x2xf64> + %6 = arith.mulf %1, %2 : f64 + %7 = affine.load %alloca_11[%arg13, %arg12, 1] : memref<5x5x2xf64> + %8 = arith.addf %7, %6 : f64 + affine.store %8, %alloca_11[%arg13, %arg12, 1] : memref<5x5x2xf64> + } + } + } + affine.for %arg11 = 0 to 5 { + %0 = affine.load %arg4[%arg10 + %arg11 * 4] : memref + %1 = affine.load %arg1[%arg10 + %arg11 * 4] : memref + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %2 = affine.load %alloca_11[%arg12, %arg13, 1] : memref<5x5x2xf64> + %3 = arith.mulf %2, %0 : f64 + %4 = affine.load %alloca_14[%arg11, %arg12, %arg13, 0] : memref<5x5x5x3xf64> + %5 = arith.subf %4, %3 : f64 + affine.store %5, %alloca_14[%arg11, %arg12, %arg13, 0] : memref<5x5x5x3xf64> + %6 = affine.load %alloca_11[%arg12, %arg13, 0] : memref<5x5x2xf64> + %7 = arith.mulf %6, %1 : f64 + %8 = affine.load %alloca_14[%arg11, %arg12, %arg13, 2] : memref<5x5x5x3xf64> + %9 = arith.addf %8, %7 : f64 + affine.store %9, %alloca_14[%arg11, %arg12, %arg13, 2] : memref<5x5x5x3xf64> + } + } + } + } + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.store %cst, %alloca_9[%arg11, %arg12, 1] : memref<5x5x2xf64> + affine.store %cst, %alloca_9[%arg11, %arg12, 0] : memref<5x5x2xf64> + } + } + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + affine.store %cst, %alloca_8[%arg12] : memref<5xf64> + } + affine.for %arg12 = 0 to 3 { + %0 = affine.load %arg7[%arg12 * 16 + %arg10 + %arg11 * 4 + %arg9 * 144 + 96] : memref + affine.for %arg13 = 0 to 5 { + %1 = affine.load %arg0[%arg12 + %arg13 * 3] : memref + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %alloca_8[%arg13] : memref<5xf64> + %4 = arith.addf %3, %2 : f64 + affine.store %4, %alloca_8[%arg13] : memref<5xf64> + } + } + affine.for %arg12 = 0 to 5 { + %0 = affine.load %arg1[%arg11 + %arg12 * 4] : memref + %1 = affine.load %arg4[%arg11 + %arg12 * 4] : memref + affine.for %arg13 = 0 to 5 { + %2 = affine.load %alloca_8[%arg13] : memref<5xf64> + %3 = arith.mulf %2, %0 : f64 + %4 = affine.load %alloca_9[%arg13, %arg12, 0] : memref<5x5x2xf64> + %5 = arith.addf %4, %3 : f64 + affine.store %5, %alloca_9[%arg13, %arg12, 0] : memref<5x5x2xf64> + %6 = arith.mulf %2, %1 : f64 + %7 = affine.load %alloca_9[%arg13, %arg12, 1] : memref<5x5x2xf64> + %8 = arith.addf %7, %6 : f64 + affine.store %8, %alloca_9[%arg13, %arg12, 1] : memref<5x5x2xf64> + } + } + } + affine.for %arg11 = 0 to 5 { + %0 = affine.load %arg1[%arg10 + %arg11 * 4] : memref + %1 = affine.load %arg4[%arg10 + %arg11 * 4] : memref + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %2 = affine.load %alloca_9[%arg13, %arg12, 1] : memref<5x5x2xf64> + %3 = arith.mulf %2, %0 : f64 + %4 = affine.load %alloca_14[%arg13, %arg12, %arg11, 0] : memref<5x5x5x3xf64> + %5 = arith.addf %4, %3 : f64 + affine.store %5, %alloca_14[%arg13, %arg12, %arg11, 0] : memref<5x5x5x3xf64> + %6 = affine.load %alloca_9[%arg13, %arg12, 0] : memref<5x5x2xf64> + %7 = arith.mulf %6, %1 : f64 + %8 = affine.load %alloca_14[%arg13, %arg12, %arg11, 1] : memref<5x5x5x3xf64> + %9 = arith.subf %8, %7 : f64 + affine.store %9, %alloca_14[%arg13, %arg12, %arg11, 1] : memref<5x5x5x3xf64> + } + } + } + } + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.load %alloca_14[%arg10, %arg11, %arg12, 0] : memref<5x5x5x3xf64> + %1 = affine.load %alloca_14[%arg10, %arg11, %arg12, 1] : memref<5x5x5x3xf64> + %2 = affine.load %alloca_14[%arg10, %arg11, %arg12, 2] : memref<5x5x5x3xf64> + %3 = affine.load %arg6[%arg9 * 750 + %arg12 + %arg10 * 25 + %arg11 * 5] : memref + %4 = affine.load %arg6[%arg9 * 750 + %arg12 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %5 = affine.load %arg6[%arg9 * 750 + %arg12 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %6 = affine.load %arg6[%arg9 * 750 + %arg12 + %arg10 * 25 + %arg11 * 5 + 375] : memref + %7 = affine.load %arg6[%arg9 * 750 + %arg12 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %8 = affine.load %arg6[%arg9 * 750 + %arg12 + %arg10 * 25 + %arg11 * 5 + 625] : memref + %9 = arith.mulf %3, %0 : f64 + %10 = arith.mulf %4, %1 : f64 + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %5, %2 : f64 + %13 = arith.addf %11, %12 : f64 + affine.store %13, %alloca_14[%arg10, %arg11, %arg12, 0] : memref<5x5x5x3xf64> + %14 = arith.mulf %4, %0 : f64 + %15 = arith.mulf %6, %1 : f64 + %16 = arith.addf %14, %15 : f64 + %17 = arith.mulf %7, %2 : f64 + %18 = arith.addf %16, %17 : f64 + affine.store %18, %alloca_14[%arg10, %arg11, %arg12, 1] : memref<5x5x5x3xf64> + %19 = arith.mulf %5, %0 : f64 + %20 = arith.mulf %7, %1 : f64 + %21 = arith.addf %19, %20 : f64 + %22 = arith.mulf %8, %2 : f64 + %23 = arith.addf %21, %22 : f64 + affine.store %23, %alloca_14[%arg10, %arg11, %arg12, 2] : memref<5x5x5x3xf64> + } + } + } + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.store %cst, %alloca_6[%arg11, %arg12] : memref<4x3xf64> + affine.store %cst, %alloca_7[%arg11, %arg12] : memref<4x3xf64> + } + } + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + affine.store %cst, %alloca_5[%arg12, 1] : memref<3x2xf64> + affine.store %cst, %alloca_5[%arg12, 0] : memref<3x2xf64> + } + affine.for %arg12 = 0 to 5 { + %0 = affine.load %alloca_14[%arg10, %arg11, %arg12, 1] : memref<5x5x5x3xf64> + %1 = affine.load %alloca_14[%arg10, %arg11, %arg12, 2] : memref<5x5x5x3xf64> + affine.for %arg13 = 0 to 3 { + %2 = affine.load %arg2[%arg12 + %arg13 * 5] : memref + %3 = arith.mulf %2, %0 : f64 + %4 = affine.load %alloca_5[%arg13, 0] : memref<3x2xf64> + %5 = arith.addf %4, %3 : f64 + affine.store %5, %alloca_5[%arg13, 0] : memref<3x2xf64> + %6 = affine.load %arg2[%arg12 + %arg13 * 5] : memref + %7 = arith.mulf %6, %1 : f64 + %8 = affine.load %alloca_5[%arg13, 1] : memref<3x2xf64> + %9 = arith.addf %8, %7 : f64 + affine.store %9, %alloca_5[%arg13, 1] : memref<3x2xf64> + } + } + affine.for %arg12 = 0 to 4 { + %0 = affine.load %arg3[%arg11 + %arg12 * 5] : memref + %1 = affine.load %arg5[%arg11 + %arg12 * 5] : memref + affine.for %arg13 = 0 to 3 { + %2 = affine.load %alloca_5[%arg13, 0] : memref<3x2xf64> + %3 = arith.mulf %2, %0 : f64 + %4 = affine.load %alloca_6[%arg12, %arg13] : memref<4x3xf64> + %5 = arith.addf %4, %3 : f64 + affine.store %5, %alloca_6[%arg12, %arg13] : memref<4x3xf64> + %6 = affine.load %alloca_5[%arg13, 1] : memref<3x2xf64> + %7 = arith.mulf %6, %1 : f64 + %8 = affine.load %alloca_7[%arg12, %arg13] : memref<4x3xf64> + %9 = arith.addf %8, %7 : f64 + affine.store %9, %alloca_7[%arg12, %arg13] : memref<4x3xf64> + } + } + } + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.load %alloca_6[%arg12, %arg13] : memref<4x3xf64> + %1 = affine.load %arg5[%arg10 + %arg11 * 5] : memref + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %alloca_7[%arg12, %arg13] : memref<4x3xf64> + %4 = affine.load %arg3[%arg10 + %arg11 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.subf %2, %5 : f64 + %7 = affine.load %arg8[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg9 * 144] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg8[%arg11 * 12 + %arg13 + %arg12 * 3 + %arg9 * 144] : memref + } + } + } + } + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.store %cst, %alloca_3[%arg11, %arg12] : memref<3x4xf64> + affine.store %cst, %alloca_4[%arg11, %arg12] : memref<3x4xf64> + } + } + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + affine.store %cst, %alloca_2[%arg12, 1] : memref<3x2xf64> + affine.store %cst, %alloca_2[%arg12, 0] : memref<3x2xf64> + } + affine.for %arg12 = 0 to 5 { + %0 = affine.load %alloca_14[%arg10, %arg12, %arg11, 2] : memref<5x5x5x3xf64> + %1 = affine.load %alloca_14[%arg10, %arg12, %arg11, 0] : memref<5x5x5x3xf64> + affine.for %arg13 = 0 to 3 { + %2 = affine.load %arg2[%arg12 + %arg13 * 5] : memref + %3 = arith.mulf %2, %0 : f64 + %4 = affine.load %alloca_2[%arg13, 0] : memref<3x2xf64> + %5 = arith.addf %4, %3 : f64 + affine.store %5, %alloca_2[%arg13, 0] : memref<3x2xf64> + %6 = affine.load %arg2[%arg12 + %arg13 * 5] : memref + %7 = arith.mulf %6, %1 : f64 + %8 = affine.load %alloca_2[%arg13, 1] : memref<3x2xf64> + %9 = arith.addf %8, %7 : f64 + affine.store %9, %alloca_2[%arg13, 1] : memref<3x2xf64> + } + } + affine.for %arg12 = 0 to 4 { + %0 = affine.load %arg5[%arg11 + %arg12 * 5] : memref + %1 = affine.load %arg3[%arg11 + %arg12 * 5] : memref + affine.for %arg13 = 0 to 3 { + %2 = affine.load %alloca_2[%arg13, 0] : memref<3x2xf64> + %3 = arith.mulf %2, %0 : f64 + %4 = affine.load %alloca_4[%arg13, %arg12] : memref<3x4xf64> + %5 = arith.addf %4, %3 : f64 + affine.store %5, %alloca_4[%arg13, %arg12] : memref<3x4xf64> + %6 = affine.load %alloca_2[%arg13, 1] : memref<3x2xf64> + %7 = arith.mulf %6, %1 : f64 + %8 = affine.load %alloca_3[%arg13, %arg12] : memref<3x4xf64> + %9 = arith.addf %8, %7 : f64 + affine.store %9, %alloca_3[%arg13, %arg12] : memref<3x4xf64> + } + } + } + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + affine.for %arg13 = 0 to 4 { + %0 = affine.load %alloca_3[%arg12, %arg13] : memref<3x4xf64> + %1 = arith.negf %0 : f64 + %2 = affine.load %arg5[%arg10 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %alloca_4[%arg12, %arg13] : memref<3x4xf64> + %5 = affine.load %arg3[%arg10 + %arg11 * 5] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg8[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg9 * 144 + 48] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg8[%arg11 * 12 + %arg13 + %arg12 * 4 + %arg9 * 144 + 48] : memref + } + } + } + } + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + affine.store %cst, %alloca_0[%arg11, %arg12] : memref<3x4xf64> + affine.store %cst, %alloca_1[%arg11, %arg12] : memref<3x4xf64> + } + } + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + affine.store %cst, %alloca[%arg12, 1] : memref<3x2xf64> + affine.store %cst, %alloca[%arg12, 0] : memref<3x2xf64> + } + affine.for %arg12 = 0 to 5 { + %0 = affine.load %alloca_14[%arg12, %arg11, %arg10, 0] : memref<5x5x5x3xf64> + %1 = affine.load %alloca_14[%arg12, %arg11, %arg10, 1] : memref<5x5x5x3xf64> + affine.for %arg13 = 0 to 3 { + %2 = affine.load %arg2[%arg12 + %arg13 * 5] : memref + %3 = arith.mulf %2, %0 : f64 + %4 = affine.load %alloca[%arg13, 0] : memref<3x2xf64> + %5 = arith.addf %4, %3 : f64 + affine.store %5, %alloca[%arg13, 0] : memref<3x2xf64> + %6 = affine.load %arg2[%arg12 + %arg13 * 5] : memref + %7 = arith.mulf %6, %1 : f64 + %8 = affine.load %alloca[%arg13, 1] : memref<3x2xf64> + %9 = arith.addf %8, %7 : f64 + affine.store %9, %alloca[%arg13, 1] : memref<3x2xf64> + } + } + affine.for %arg12 = 0 to 4 { + %0 = affine.load %arg3[%arg11 + %arg12 * 5] : memref + %1 = affine.load %arg5[%arg11 + %arg12 * 5] : memref + affine.for %arg13 = 0 to 3 { + %2 = affine.load %alloca[%arg13, 1] : memref<3x2xf64> + %3 = arith.mulf %0, %2 : f64 + %4 = affine.load %alloca_1[%arg13, %arg12] : memref<3x4xf64> + %5 = arith.addf %4, %3 : f64 + affine.store %5, %alloca_1[%arg13, %arg12] : memref<3x4xf64> + %6 = affine.load %alloca[%arg13, 0] : memref<3x2xf64> + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %alloca_0[%arg13, %arg12] : memref<3x4xf64> + %9 = arith.addf %8, %7 : f64 + affine.store %9, %alloca_0[%arg13, %arg12] : memref<3x4xf64> + } + } + } + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + affine.for %arg13 = 0 to 3 { + %0 = affine.load %alloca_0[%arg13, %arg12] : memref<3x4xf64> + %1 = affine.load %arg3[%arg10 + %arg11 * 5] : memref + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %alloca_1[%arg13, %arg12] : memref<3x4xf64> + %4 = affine.load %arg5[%arg10 + %arg11 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.subf %2, %5 : f64 + %7 = affine.load %arg8[%arg13 * 16 + %arg11 + %arg12 * 4 + %arg9 * 144 + 96] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg8[%arg13 * 16 + %arg11 + %arg12 * 4 + %arg9 * 144 + 96] : memref + } + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/curlcurl_apply_3d__original.raised.mlir b/issues/mfem_c_kernels/results/curlcurl_apply_3d__original.raised.mlir new file mode 100644 index 000000000000..ed4fc2a48811 --- /dev/null +++ b/issues/mfem_c_kernels/results/curlcurl_apply_3d__original.raised.mlir @@ -0,0 +1,487 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d1 * 3 + d0)> +#map4 = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 12 + s1 * 3 + s2 * 144)> +#map5 = affine_map<(d0, d1) -> (d0)> +#map6 = affine_map<(d0, d1) -> (d1)> +#map7 = affine_map<(d0)[s0] -> (d0 * 4 + s0)> +#map8 = affine_map<(d0)[s0, s1, s2] -> (d0 * 4 + s0 * 12 + s1 + s2 * 144 + 48)> +#map9 = affine_map<(d0, d1) -> (d1, d0)> +#map10 = affine_map<(d0)[s0, s1, s2] -> (d0 * 16 + s0 + s1 * 4 + s2 * 144 + 96)> +#map11 = affine_map<(d0, d1, d2)[s0] -> (d2 + s0 * 750 + d0 * 25 + d1 * 5)> +#map12 = affine_map<(d0, d1, d2)[s0] -> (d2 + s0 * 750 + d0 * 25 + d1 * 5 + 125)> +#map13 = affine_map<(d0, d1, d2)[s0] -> (d2 + s0 * 750 + d0 * 25 + d1 * 5 + 250)> +#map14 = affine_map<(d0, d1, d2)[s0] -> (d2 + s0 * 750 + d0 * 25 + d1 * 5 + 375)> +#map15 = affine_map<(d0, d1, d2)[s0] -> (d2 + s0 * 750 + d0 * 25 + d1 * 5 + 500)> +#map16 = affine_map<(d0, d1, d2)[s0] -> (d2 + s0 * 750 + d0 * 25 + d1 * 5 + 625)> +#map17 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map18 = affine_map<(d0)[s0] -> (d0 * 5 + s0)> +#map19 = affine_map<(d0, d1, d2)[s0] -> (d0 * 5 + s0)> +#map20 = affine_map<(d0, d1, d2)[s0] -> (d2 + d0 * 12 + d1 * 3 + s0 * 144)> +#map21 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map22 = affine_map<(d0, d1, d2)[s0] -> (d2 + d0 * 12 + d1 * 4 + s0 * 144 + 48)> +#map23 = affine_map<(d0, d1, d2)[s0] -> (d2 * 16 + d0 + d1 * 4 + s0 * 144 + 96)> +#map24 = affine_map<(d0, d1, d2) -> (d2, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_curlcurl_apply_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<3x2xf64> + %alloca_0 = memref.alloca() : memref<3x4xf64> + %alloca_1 = memref.alloca() : memref<3x4xf64> + %alloca_2 = memref.alloca() : memref<3x2xf64> + %alloca_3 = memref.alloca() : memref<3x4xf64> + %alloca_4 = memref.alloca() : memref<3x4xf64> + %alloca_5 = memref.alloca() : memref<3x2xf64> + %alloca_6 = memref.alloca() : memref<4x3xf64> + %alloca_7 = memref.alloca() : memref<4x3xf64> + %alloca_8 = memref.alloca() : memref<5xf64> + %alloca_9 = memref.alloca() : memref<5x5x2xf64> + %alloca_10 = memref.alloca() : memref<5xf64> + %alloca_11 = memref.alloca() : memref<5x5x2xf64> + %alloca_12 = memref.alloca() : memref<5xf64> + %alloca_13 = memref.alloca() : memref<5x5x2xf64> + %alloca_14 = memref.alloca() : memref<5x5x5x3xf64> + affine.for %arg9 = 0 to 2 { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_14 : memref<5x5x5x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg10 = 0 to 4 { + %subview_17 = memref.subview %alloca_13[0, 0, 1] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%subview_17 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_18 = memref.subview %alloca_13[0, 0, 0] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%subview_18 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg11 = 0 to 4 { + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel"]} outs(%alloca_12 : memref<5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg0, %c3, %c5) {map = #map3} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg7, %arg10, %arg11, %arg9, %c3) {map = #map4} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map1, #map6], iterator_types = ["reduction", "parallel"]} ins(%7, %6 : memref, memref) outs(%alloca_12 : memref<5xf64>) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %10 = arith.mulf %in, %in_24 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + %subview_19 = memref.subview %alloca_12[0] [%c5] [1] : memref<5xf64> to memref> + %subview_20 = memref.subview %alloca_13[0, 0, 0] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + %subview_21 = memref.subview %alloca_13[0, 0, 1] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + %8 = polygeist.submap(%arg4, %arg11, %c5) {map = #map7} : (memref, index, index) -> memref + %subview_22 = memref.subview %8[0] [%c5] [1] : memref to memref> + %9 = polygeist.submap(%arg1, %arg11, %c5) {map = #map7} : (memref, index, index) -> memref + %subview_23 = memref.subview %9[0] [%c5] [1] : memref to memref> + linalg.generic {indexing_maps = [#map5, #map5, #map6, #map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview_22, %subview_23, %subview_19 : memref>, memref>, memref>) outs(%subview_20, %subview_21 : memref>, memref>) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %out: f64, %out_26: f64): + %10 = arith.mulf %in_25, %in : f64 + %11 = arith.addf %out, %10 : f64 + %12 = arith.mulf %in_25, %in_24 : f64 + %13 = arith.addf %out_26, %12 : f64 + linalg.yield %11, %13 : f64, f64 + } + } + affine.for %arg11 = 0 to 5 { + %6 = affine.load %arg4[%arg10 + %arg11 * 4] : memref + %7 = affine.load %arg1[%arg10 + %arg11 * 4] : memref + %subview_19 = memref.subview %alloca_13[0, 0, 1] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + %subview_20 = memref.subview %alloca_14[%arg11, 0, 0, 1] [1, %c5, %c5, 1] [1, 1, 1, 1] : memref<5x5x5x3xf64> to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview_19 : memref>) outs(%subview_20 : memref>) { + ^bb0(%in: f64, %out: f64): + %8 = arith.mulf %in, %6 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + %subview_21 = memref.subview %alloca_13[0, 0, 0] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + %subview_22 = memref.subview %alloca_14[%arg11, 0, 0, 2] [1, %c5, %c5, 1] [1, 1, 1, 1] : memref<5x5x5x3xf64> to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview_21 : memref>) outs(%subview_22 : memref>) { + ^bb0(%in: f64, %out: f64): + %8 = arith.mulf %in, %7 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + } {polygeist.was_parallel} + } + affine.for %arg10 = 0 to 4 { + %subview_17 = memref.subview %alloca_11[0, 0, 1] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%subview_17 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_18 = memref.subview %alloca_11[0, 0, 0] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%subview_18 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg11 = 0 to 4 { + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel"]} outs(%alloca_10 : memref<5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg0, %c3, %c5) {map = #map3} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg7, %arg10, %arg11, %arg9, %c3) {map = #map8} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map1, #map6], iterator_types = ["reduction", "parallel"]} ins(%7, %6 : memref, memref) outs(%alloca_10 : memref<5xf64>) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %10 = arith.mulf %in, %in_24 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + %subview_19 = memref.subview %alloca_10[0] [%c5] [1] : memref<5xf64> to memref> + %subview_20 = memref.subview %alloca_11[0, 0, 0] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + %subview_21 = memref.subview %alloca_11[0, 0, 1] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + %8 = polygeist.submap(%arg4, %arg11, %c5) {map = #map7} : (memref, index, index) -> memref + %subview_22 = memref.subview %8[0] [%c5] [1] : memref to memref> + %9 = polygeist.submap(%arg1, %arg11, %c5) {map = #map7} : (memref, index, index) -> memref + %subview_23 = memref.subview %9[0] [%c5] [1] : memref to memref> + linalg.generic {indexing_maps = [#map5, #map5, #map6, #map9, #map9], iterator_types = ["parallel", "parallel"]} ins(%subview_22, %subview_23, %subview_19 : memref>, memref>, memref>) outs(%subview_20, %subview_21 : memref>, memref>) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %out: f64, %out_26: f64): + %10 = arith.mulf %in, %in_25 : f64 + %11 = arith.addf %out, %10 : f64 + %12 = arith.mulf %in_24, %in_25 : f64 + %13 = arith.addf %out_26, %12 : f64 + linalg.yield %11, %13 : f64, f64 + } + } + affine.for %arg11 = 0 to 5 { + %6 = affine.load %arg4[%arg10 + %arg11 * 4] : memref + %7 = affine.load %arg1[%arg10 + %arg11 * 4] : memref + %subview_19 = memref.subview %alloca_11[0, 0, 1] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + %subview_20 = memref.subview %alloca_14[%arg11, 0, 0, 0] [1, %c5, %c5, 1] [1, 1, 1, 1] : memref<5x5x5x3xf64> to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview_19 : memref>) outs(%subview_20 : memref>) { + ^bb0(%in: f64, %out: f64): + %8 = arith.mulf %in, %6 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + %subview_21 = memref.subview %alloca_11[0, 0, 0] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + %subview_22 = memref.subview %alloca_14[%arg11, 0, 0, 2] [1, %c5, %c5, 1] [1, 1, 1, 1] : memref<5x5x5x3xf64> to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview_21 : memref>) outs(%subview_22 : memref>) { + ^bb0(%in: f64, %out: f64): + %8 = arith.mulf %in, %7 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } {polygeist.was_parallel} + } + affine.for %arg10 = 0 to 4 { + %subview_17 = memref.subview %alloca_9[0, 0, 1] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%subview_17 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_18 = memref.subview %alloca_9[0, 0, 0] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%subview_18 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg11 = 0 to 4 { + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel"]} outs(%alloca_8 : memref<5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg0, %c3, %c5) {map = #map3} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg7, %arg10, %arg11, %arg9, %c3) {map = #map10} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map1, #map6], iterator_types = ["reduction", "parallel"]} ins(%7, %6 : memref, memref) outs(%alloca_8 : memref<5xf64>) { + ^bb0(%in: f64, %in_24: f64, %out: f64): + %10 = arith.mulf %in, %in_24 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + %subview_19 = memref.subview %alloca_8[0] [%c5] [1] : memref<5xf64> to memref> + %subview_20 = memref.subview %alloca_9[0, 0, 0] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + %subview_21 = memref.subview %alloca_9[0, 0, 1] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + %8 = polygeist.submap(%arg1, %arg11, %c5) {map = #map7} : (memref, index, index) -> memref + %subview_22 = memref.subview %8[0] [%c5] [1] : memref to memref> + %9 = polygeist.submap(%arg4, %arg11, %c5) {map = #map7} : (memref, index, index) -> memref + %subview_23 = memref.subview %9[0] [%c5] [1] : memref to memref> + linalg.generic {indexing_maps = [#map5, #map5, #map6, #map9, #map9], iterator_types = ["parallel", "parallel"]} ins(%subview_22, %subview_23, %subview_19 : memref>, memref>, memref>) outs(%subview_20, %subview_21 : memref>, memref>) { + ^bb0(%in: f64, %in_24: f64, %in_25: f64, %out: f64, %out_26: f64): + %10 = arith.mulf %in_25, %in : f64 + %11 = arith.addf %out, %10 : f64 + %12 = arith.mulf %in_25, %in_24 : f64 + %13 = arith.addf %out_26, %12 : f64 + linalg.yield %11, %13 : f64, f64 + } + } + affine.for %arg11 = 0 to 5 { + %6 = affine.load %arg1[%arg10 + %arg11 * 4] : memref + %7 = affine.load %arg4[%arg10 + %arg11 * 4] : memref + %subview_19 = memref.subview %alloca_9[0, 0, 1] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + %subview_20 = memref.subview %alloca_14[0, 0, %arg11, 0] [%c5, %c5, 1, 1] [1, 1, 1, 1] : memref<5x5x5x3xf64> to memref> + linalg.generic {indexing_maps = [#map9, #map9], iterator_types = ["parallel", "parallel"]} ins(%subview_19 : memref>) outs(%subview_20 : memref>) { + ^bb0(%in: f64, %out: f64): + %8 = arith.mulf %in, %6 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + %subview_21 = memref.subview %alloca_9[0, 0, 0] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + %subview_22 = memref.subview %alloca_14[0, 0, %arg11, 1] [%c5, %c5, 1, 1] [1, 1, 1, 1] : memref<5x5x5x3xf64> to memref> + linalg.generic {indexing_maps = [#map9, #map9], iterator_types = ["parallel", "parallel"]} ins(%subview_21 : memref>) outs(%subview_22 : memref>) { + ^bb0(%in: f64, %out: f64): + %8 = arith.mulf %in, %7 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + } {polygeist.was_parallel} + } + %0 = polygeist.submap(%arg6, %arg9, %c5, %c5, %c5) {map = #map11} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg6, %arg9, %c5, %c5, %c5) {map = #map12} : (memref, index, index, index, index) -> memref + %2 = polygeist.submap(%arg6, %arg9, %c5, %c5, %c5) {map = #map13} : (memref, index, index, index, index) -> memref + %3 = polygeist.submap(%arg6, %arg9, %c5, %c5, %c5) {map = #map14} : (memref, index, index, index, index) -> memref + %4 = polygeist.submap(%arg6, %arg9, %c5, %c5, %c5) {map = #map15} : (memref, index, index, index, index) -> memref + %5 = polygeist.submap(%arg6, %arg9, %c5, %c5, %c5) {map = #map16} : (memref, index, index, index, index) -> memref + %subview = memref.subview %alloca_14[0, 0, 0, 0] [%c5, %c5, %c5, 1] [1, 1, 1, 1] : memref<5x5x5x3xf64> to memref> + %subview_15 = memref.subview %alloca_14[0, 0, 0, 1] [%c5, %c5, %c5, 1] [1, 1, 1, 1] : memref<5x5x5x3xf64> to memref> + %subview_16 = memref.subview %alloca_14[0, 0, 0, 2] [%c5, %c5, %c5, 1] [1, 1, 1, 1] : memref<5x5x5x3xf64> to memref> + linalg.generic {indexing_maps = [#map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17, #map17], iterator_types = ["parallel", "parallel", "parallel"]} ins(%0, %1, %2, %3, %4, %5 : memref, memref, memref, memref, memref, memref) outs(%subview, %subview_15, %subview_16 : memref>, memref>, memref>) { + ^bb0(%in: f64, %in_17: f64, %in_18: f64, %in_19: f64, %in_20: f64, %in_21: f64, %out: f64, %out_22: f64, %out_23: f64): + %6 = arith.mulf %in, %out : f64 + %7 = arith.mulf %in_17, %out_22 : f64 + %8 = arith.addf %6, %7 : f64 + %9 = arith.mulf %in_18, %out_23 : f64 + %10 = arith.addf %8, %9 : f64 + %11 = arith.mulf %in_17, %out : f64 + %12 = arith.mulf %in_19, %out_22 : f64 + %13 = arith.addf %11, %12 : f64 + %14 = arith.mulf %in_20, %out_23 : f64 + %15 = arith.addf %13, %14 : f64 + %16 = arith.mulf %in_18, %out : f64 + %17 = arith.mulf %in_20, %out_22 : f64 + %18 = arith.addf %16, %17 : f64 + %19 = arith.mulf %in_21, %out_23 : f64 + %20 = arith.addf %18, %19 : f64 + linalg.yield %10, %15, %20 : f64, f64, f64 + } + affine.for %arg10 = 0 to 5 { + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%alloca_6 : memref<4x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%alloca_7 : memref<4x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg11 = 0 to 5 { + %subview_17 = memref.subview %alloca_5[0, 1] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel"]} outs(%subview_17 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_18 = memref.subview %alloca_5[0, 0] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel"]} outs(%subview_18 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg12 = 0 to 5 { + %9 = affine.load %alloca_14[%arg10, %arg11, %arg12, 1] : memref<5x5x5x3xf64> + %10 = affine.load %alloca_14[%arg10, %arg11, %arg12, 2] : memref<5x5x5x3xf64> + %11 = polygeist.submap(%arg2, %arg12, %c3) {map = #map18} : (memref, index, index) -> memref + %subview_19 = memref.subview %alloca_5[0, 0] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%11 : memref) outs(%subview_19 : memref>) { + ^bb0(%in: f64, %out: f64): + %13 = arith.mulf %in, %9 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } + %12 = polygeist.submap(%arg2, %arg12, %c3) {map = #map18} : (memref, index, index) -> memref + %subview_20 = memref.subview %alloca_5[0, 1] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%12 : memref) outs(%subview_20 : memref>) { + ^bb0(%in: f64, %out: f64): + %13 = arith.mulf %in, %10 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } + } + affine.for %arg12 = 0 to 4 { + %9 = affine.load %arg3[%arg11 + %arg12 * 5] : memref + %10 = affine.load %arg5[%arg11 + %arg12 * 5] : memref + %subview_19 = memref.subview %alloca_5[0, 0] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + %subview_20 = memref.subview %alloca_6[%arg12, 0] [1, %c3] [1, 1] : memref<4x3xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%subview_19 : memref>) outs(%subview_20 : memref>) { + ^bb0(%in: f64, %out: f64): + %11 = arith.mulf %in, %9 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + %subview_21 = memref.subview %alloca_5[0, 1] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + %subview_22 = memref.subview %alloca_7[%arg12, 0] [1, %c3] [1, 1] : memref<4x3xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%subview_21 : memref>) outs(%subview_22 : memref>) { + ^bb0(%in: f64, %out: f64): + %11 = arith.mulf %in, %10 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + } {polygeist.was_parallel} + } + %6 = polygeist.submap(%arg5, %arg10, %c4, %c4, %c3) {map = #map19} : (memref, index, index, index, index) -> memref + %7 = polygeist.submap(%arg3, %arg10, %c4, %c4, %c3) {map = #map19} : (memref, index, index, index, index) -> memref + %8 = polygeist.submap(%arg8, %arg9, %c4, %c4, %c3) {map = #map20} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map21, #map17, #map21, #map17, #map17], iterator_types = ["parallel", "parallel", "parallel"]} ins(%alloca_6, %6, %alloca_7, %7 : memref<4x3xf64>, memref, memref<4x3xf64>, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_17: f64, %in_18: f64, %in_19: f64, %out: f64): + %9 = arith.mulf %in, %in_17 : f64 + %10 = arith.mulf %in_18, %in_19 : f64 + %11 = arith.subf %9, %10 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + } + affine.for %arg10 = 0 to 5 { + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%alloca_3 : memref<3x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%alloca_4 : memref<3x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg11 = 0 to 5 { + %subview_17 = memref.subview %alloca_2[0, 1] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel"]} outs(%subview_17 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_18 = memref.subview %alloca_2[0, 0] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel"]} outs(%subview_18 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg12 = 0 to 5 { + %9 = affine.load %alloca_14[%arg10, %arg12, %arg11, 2] : memref<5x5x5x3xf64> + %10 = affine.load %alloca_14[%arg10, %arg12, %arg11, 0] : memref<5x5x5x3xf64> + %11 = polygeist.submap(%arg2, %arg12, %c3) {map = #map18} : (memref, index, index) -> memref + %subview_19 = memref.subview %alloca_2[0, 0] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%11 : memref) outs(%subview_19 : memref>) { + ^bb0(%in: f64, %out: f64): + %13 = arith.mulf %in, %9 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } + %12 = polygeist.submap(%arg2, %arg12, %c3) {map = #map18} : (memref, index, index) -> memref + %subview_20 = memref.subview %alloca_2[0, 1] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%12 : memref) outs(%subview_20 : memref>) { + ^bb0(%in: f64, %out: f64): + %13 = arith.mulf %in, %10 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } + } + affine.for %arg12 = 0 to 4 { + %9 = affine.load %arg5[%arg11 + %arg12 * 5] : memref + %10 = affine.load %arg3[%arg11 + %arg12 * 5] : memref + %subview_19 = memref.subview %alloca_2[0, 0] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + %subview_20 = memref.subview %alloca_4[0, %arg12] [%c3, 1] [1, 1] : memref<3x4xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%subview_19 : memref>) outs(%subview_20 : memref>) { + ^bb0(%in: f64, %out: f64): + %11 = arith.mulf %in, %9 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + %subview_21 = memref.subview %alloca_2[0, 1] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + %subview_22 = memref.subview %alloca_3[0, %arg12] [%c3, 1] [1, 1] : memref<3x4xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%subview_21 : memref>) outs(%subview_22 : memref>) { + ^bb0(%in: f64, %out: f64): + %11 = arith.mulf %in, %10 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + } {polygeist.was_parallel} + } + %6 = polygeist.submap(%arg5, %arg10, %c4, %c3, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + %7 = polygeist.submap(%arg3, %arg10, %c4, %c3, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + %8 = polygeist.submap(%arg8, %arg9, %c4, %c3, %c4) {map = #map22} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map21, #map17, #map21, #map17, #map17], iterator_types = ["parallel", "parallel", "parallel"]} ins(%alloca_3, %6, %alloca_4, %7 : memref<3x4xf64>, memref, memref<3x4xf64>, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_17: f64, %in_18: f64, %in_19: f64, %out: f64): + %9 = arith.negf %in : f64 + %10 = arith.mulf %9, %in_17 : f64 + %11 = arith.mulf %in_18, %in_19 : f64 + %12 = arith.addf %10, %11 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 + } + } + affine.for %arg10 = 0 to 5 { + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%alloca_0 : memref<3x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%alloca_1 : memref<3x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg11 = 0 to 5 { + %subview_17 = memref.subview %alloca[0, 1] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel"]} outs(%subview_17 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_18 = memref.subview %alloca[0, 0] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel"]} outs(%subview_18 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg12 = 0 to 5 { + %9 = affine.load %alloca_14[%arg12, %arg11, %arg10, 0] : memref<5x5x5x3xf64> + %10 = affine.load %alloca_14[%arg12, %arg11, %arg10, 1] : memref<5x5x5x3xf64> + %11 = polygeist.submap(%arg2, %arg12, %c3) {map = #map18} : (memref, index, index) -> memref + %subview_19 = memref.subview %alloca[0, 0] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%11 : memref) outs(%subview_19 : memref>) { + ^bb0(%in: f64, %out: f64): + %13 = arith.mulf %in, %9 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } + %12 = polygeist.submap(%arg2, %arg12, %c3) {map = #map18} : (memref, index, index) -> memref + %subview_20 = memref.subview %alloca[0, 1] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%12 : memref) outs(%subview_20 : memref>) { + ^bb0(%in: f64, %out: f64): + %13 = arith.mulf %in, %10 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } + } + affine.for %arg12 = 0 to 4 { + %9 = affine.load %arg3[%arg11 + %arg12 * 5] : memref + %10 = affine.load %arg5[%arg11 + %arg12 * 5] : memref + %subview_19 = memref.subview %alloca[0, 1] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + %subview_20 = memref.subview %alloca_1[0, %arg12] [%c3, 1] [1, 1] : memref<3x4xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%subview_19 : memref>) outs(%subview_20 : memref>) { + ^bb0(%in: f64, %out: f64): + %11 = arith.mulf %9, %in : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + %subview_21 = memref.subview %alloca[0, 0] [%c3, 1] [1, 1] : memref<3x2xf64> to memref> + %subview_22 = memref.subview %alloca_0[0, %arg12] [%c3, 1] [1, 1] : memref<3x4xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%subview_21 : memref>) outs(%subview_22 : memref>) { + ^bb0(%in: f64, %out: f64): + %11 = arith.mulf %10, %in : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + } {polygeist.was_parallel} + } + %6 = polygeist.submap(%arg3, %arg10, %c4, %c4, %c3) {map = #map19} : (memref, index, index, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg10, %c4, %c4, %c3) {map = #map19} : (memref, index, index, index, index) -> memref + %8 = polygeist.submap(%arg8, %arg9, %c4, %c4, %c3) {map = #map23} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map24, #map17, #map24, #map17, #map17], iterator_types = ["parallel", "parallel", "parallel"]} ins(%alloca_0, %6, %alloca_1, %7 : memref<3x4xf64>, memref, memref<3x4xf64>, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_17: f64, %in_18: f64, %in_19: f64, %out: f64): + %9 = arith.mulf %in, %in_17 : f64 + %10 = arith.mulf %in_18, %in_19 : f64 + %11 = arith.subf %9, %10 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/curlcurl_apply_3d_stage_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/curlcurl_apply_3d_stage_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..f55e4e80df6a --- /dev/null +++ b/issues/mfem_c_kernels/results/curlcurl_apply_3d_stage_sliced__normalized.frontend.mlir @@ -0,0 +1,739 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_curlcurl_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_13 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_14 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_15 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_16 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_21 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_22 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_23 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_24 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_25 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_26 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_27 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_28 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_29 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_30 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_31 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_32 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_33 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 3 + %arg9 * 144] : memref + %2 = affine.load %arg0[%arg13 + %arg12 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_33[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_28[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_33[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_27[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_28[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_22[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_27[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_21[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %2 = affine.load %arg4[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_32[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 12 + %arg13 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %2 = affine.load %arg1[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_31[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_32[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg13 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_26[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_31[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg13 + %arg11 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_25[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_26[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_20[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_25[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg4[%arg13 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_19[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 16 + %arg13 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %2 = affine.load %arg4[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_30[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg7[%arg10 * 16 + %arg13 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %2 = affine.load %arg1[%arg13 + %arg12 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_29[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_30[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_24[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 4 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_29[%arg9, %arg10, %arg13, %arg12] : memref<2x4x4x5xf64> + %2 = affine.load %arg4[%arg13 + %arg11 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_23[%arg9, %arg10, %arg11, %arg12] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_24[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg13 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_18[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + %0 = affine.for %arg13 = 0 to 3 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_23[%arg9, %arg13, %arg11, %arg12] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg13 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_17[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_16[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_16[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg2[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_15[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 625] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_14[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_13[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg5[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 250] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg3[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_12[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg5[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 125] : memref + %2 = affine.load %alloca_17[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_19[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %4 = arith.subf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 375] : memref + %7 = affine.load %alloca_21[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %8 = affine.load %alloca_18[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %9 = arith.subf %7, %8 : f64 + %10 = arith.mulf %6, %9 : f64 + %11 = arith.addf %5, %10 : f64 + %12 = affine.load %arg6[%arg9 * 750 + %arg13 + %arg10 * 25 + %arg11 * 5 + 500] : memref + %13 = affine.load %alloca_20[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %14 = affine.load %alloca_22[%arg9, %arg10, %arg11, %arg13] : memref<2x5x5x5xf64> + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %12, %15 : f64 + %17 = arith.addf %11, %16 : f64 + %18 = affine.load %arg5[%arg13 + %arg12 * 5] : memref + %19 = arith.mulf %17, %18 : f64 + %20 = arith.addf %arg14, %19 : f64 + affine.yield %20 : f64 + } + affine.store %0, %alloca_11[%arg9, %arg10, %arg11, %arg12] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg9, %arg10, %arg13, %arg12] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg13 + %arg11 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg9, %arg10, %arg11, %arg12] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.for %arg13 = 0 to 5 iter_args(%arg14 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg9, %arg13, %arg11, %arg12] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg13 + %arg10 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg14, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 3 { + %0 = affine.load %alloca_4[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_3[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 12 + %arg12 + %arg11 * 3 + %arg9 * 144] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 12 + %arg12 + %arg11 * 3 + %arg9 * 144] : memref + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.for %arg12 = 0 to 4 { + %0 = affine.load %alloca_2[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_1[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 12 + %arg12 + %arg11 * 4 + %arg9 * 144 + 48] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 12 + %arg12 + %arg11 * 4 + %arg9 * 144 + 48] : memref + } + } + } + } + affine.for %arg9 = 0 to 2 { + affine.for %arg10 = 0 to 3 { + affine.for %arg11 = 0 to 4 { + affine.for %arg12 = 0 to 4 { + %0 = affine.load %alloca_0[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %1 = affine.load %alloca[%arg9, %arg10, %arg11, %arg12] : memref<2x4x4x4xf64> + %2 = arith.subf %0, %1 : f64 + %3 = affine.load %arg8[%arg10 * 16 + %arg12 + %arg11 * 4 + %arg9 * 144 + 96] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg8[%arg10 * 16 + %arg12 + %arg11 * 4 + %arg9 * 144 + 96] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/curlcurl_apply_3d_stage_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/curlcurl_apply_3d_stage_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..8caf5bd89544 --- /dev/null +++ b/issues/mfem_c_kernels/results/curlcurl_apply_3d_stage_sliced__normalized.raised.mlir @@ -0,0 +1,549 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 144)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 125)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 375)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 500)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 250)> +#map22 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5 + 625)> +#map23 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 750 + d1 * 25 + d2 * 5)> +#map24 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 3 + d0 * 144)> +#map25 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 12 + d2 * 4 + d0 * 144 + 48)> +#map26 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 16 + d2 * 4 + d0 * 144 + 96)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_curlcurl_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %c3 = arith.constant 3 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_9 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_10 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_11 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_12 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_13 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_14 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_15 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_16 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_17 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_18 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_19 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_20 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_21 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_22 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_23 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_24 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_25 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_26 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_27 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_28 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_29 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_30 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_31 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_32 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_33 = memref.alloca() : memref<2x4x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_33 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg7, %c2, %c4, %c4, %c5, %c3) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c3) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_33 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_28 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg4, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_33, %2 : memref<2x4x4x5xf64>, memref) outs(%alloca_28 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_27 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %3 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_33, %3 : memref<2x4x4x5xf64>, memref) outs(%alloca_27 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_22 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_28, %4 : memref<2x4x5x5xf64>, memref) outs(%alloca_22 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_21 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %5 = polygeist.submap(%arg4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_27, %5 : memref<2x4x5x5xf64>, memref) outs(%alloca_21 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_32 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg7, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (memref, index, index, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%6, %7 : memref, memref) outs(%alloca_32 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_31 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg7, %c2, %c4, %c3, %c5, %c4) {map = #map9} : (memref, index, index, index, index, index) -> memref + %9 = polygeist.submap(%arg1, %c2, %c4, %c3, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%8, %9 : memref, memref) outs(%alloca_31 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_26 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %10 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_32, %10 : memref<2x4x4x5xf64>, memref) outs(%alloca_26 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_25 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %11 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c3) {map = #map11} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_31, %11 : memref<2x4x4x5xf64>, memref) outs(%alloca_25 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_20 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %12 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_26, %12 : memref<2x4x5x5xf64>, memref) outs(%alloca_20 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_19 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %13 = polygeist.submap(%arg4, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_25, %13 : memref<2x4x5x5xf64>, memref) outs(%alloca_19 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_30 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg7, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %15 = polygeist.submap(%arg4, %c2, %c3, %c4, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%14, %15 : memref, memref) outs(%alloca_30 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_29 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %16 = polygeist.submap(%arg7, %c2, %c3, %c4, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + %17 = polygeist.submap(%arg1, %c2, %c3, %c4, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%16, %17 : memref, memref) outs(%alloca_29 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_24 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %18 = polygeist.submap(%arg1, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_30, %18 : memref<2x4x4x5xf64>, memref) outs(%alloca_24 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_23 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %19 = polygeist.submap(%arg4, %c2, %c3, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_29, %19 : memref<2x4x4x5xf64>, memref) outs(%alloca_23 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_18 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %20 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_24, %20 : memref<2x4x5x5xf64>, memref) outs(%alloca_18 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_17 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %21 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map13} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_23, %21 : memref<2x4x5x5xf64>, memref) outs(%alloca_17 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_16 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %22 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %23 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %24 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %25 = polygeist.submap(%arg2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%22, %alloca_17, %alloca_19, %23, %alloca_21, %alloca_18, %24, %alloca_20, %alloca_22, %25 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_16 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_10 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %26 = polygeist.submap(%arg3, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_16, %26 : memref<2x5x5x4xf64>, memref) outs(%alloca_10 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_4 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %27 = polygeist.submap(%arg5, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_10, %27 : memref<2x5x4x4xf64>, memref) outs(%alloca_4 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_15 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %28 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %29 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %30 = polygeist.submap(%arg6, %c2, %c5, %c5, %c3, %c5) {map = #map22} : (memref, index, index, index, index, index) -> memref + %31 = polygeist.submap(%arg2, %c2, %c5, %c5, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%28, %alloca_17, %alloca_19, %29, %alloca_21, %alloca_18, %30, %alloca_20, %alloca_22, %31 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_15 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_9 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %32 = polygeist.submap(%arg5, %c2, %c5, %c4, %c3, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_15, %32 : memref<2x5x5x4xf64>, memref) outs(%alloca_9 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %33 = polygeist.submap(%arg3, %c2, %c4, %c4, %c3, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_9, %33 : memref<2x5x4x4xf64>, memref) outs(%alloca_3 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_14 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %34 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %35 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %36 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map22} : (memref, index, index, index, index, index) -> memref + %37 = polygeist.submap(%arg5, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%34, %alloca_17, %alloca_19, %35, %alloca_21, %alloca_18, %36, %alloca_20, %alloca_22, %37 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_14 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_8 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %38 = polygeist.submap(%arg2, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_14, %38 : memref<2x5x5x4xf64>, memref) outs(%alloca_8 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %39 = polygeist.submap(%arg3, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_8, %39 : memref<2x5x4x4xf64>, memref) outs(%alloca_2 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_13 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %40 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (memref, index, index, index, index, index) -> memref + %41 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %42 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %43 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%40, %alloca_17, %alloca_19, %41, %alloca_21, %alloca_18, %42, %alloca_20, %alloca_22, %43 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_13 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_7 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %44 = polygeist.submap(%arg2, %c2, %c5, %c3, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_13, %44 : memref<2x5x5x4xf64>, memref) outs(%alloca_7 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %45 = polygeist.submap(%arg5, %c2, %c4, %c3, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_7, %45 : memref<2x5x4x4xf64>, memref) outs(%alloca_1 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_12 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %46 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map23} : (memref, index, index, index, index, index) -> memref + %47 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %48 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + %49 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%46, %alloca_17, %alloca_19, %47, %alloca_21, %alloca_18, %48, %alloca_20, %alloca_22, %49 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_12 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_6 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %50 = polygeist.submap(%arg5, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_12, %50 : memref<2x5x5x4xf64>, memref) outs(%alloca_6 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %51 = polygeist.submap(%arg2, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_6, %51 : memref<2x5x4x4xf64>, memref) outs(%alloca_0 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_11 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %52 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %53 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %54 = polygeist.submap(%arg6, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %55 = polygeist.submap(%arg5, %c2, %c5, %c5, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map18, #map18, #map3, #map18, #map18, #map3, #map18, #map18, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%52, %alloca_17, %alloca_19, %53, %alloca_21, %alloca_18, %54, %alloca_20, %alloca_22, %55 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_11 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %in_35: f64, %in_36: f64, %in_37: f64, %in_38: f64, %in_39: f64, %in_40: f64, %in_41: f64, %in_42: f64, %out: f64): + %61 = arith.subf %in_34, %in_35 : f64 + %62 = arith.mulf %in, %61 : f64 + %63 = arith.subf %in_37, %in_38 : f64 + %64 = arith.mulf %in_36, %63 : f64 + %65 = arith.addf %62, %64 : f64 + %66 = arith.subf %in_40, %in_41 : f64 + %67 = arith.mulf %in_39, %66 : f64 + %68 = arith.addf %65, %67 : f64 + %69 = arith.mulf %68, %in_42 : f64 + %70 = arith.addf %out, %69 : f64 + linalg.yield %70 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_5 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %56 = polygeist.submap(%arg3, %c2, %c5, %c4, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_11, %56 : memref<2x5x5x4xf64>, memref) outs(%alloca_5 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %57 = polygeist.submap(%arg2, %c2, %c3, %c4, %c4, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_5, %57 : memref<2x5x4x4xf64>, memref) outs(%alloca : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.mulf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + %58 = polygeist.submap(%arg8, %c2, %c4, %c4, %c3) {map = #map24} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%alloca_4, %alloca_3 : memref<2x4x4x4xf64>, memref<2x4x4x4xf64>) outs(%58 : memref) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.subf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + %59 = polygeist.submap(%arg8, %c2, %c4, %c3, %c4) {map = #map25} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%alloca_2, %alloca_1 : memref<2x4x4x4xf64>, memref<2x4x4x4xf64>) outs(%59 : memref) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.subf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + %60 = polygeist.submap(%arg8, %c2, %c3, %c4, %c4) {map = #map26} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%alloca_0, %alloca : memref<2x4x4x4xf64>, memref<2x4x4x4xf64>) outs(%60 : memref) { + ^bb0(%in: f64, %in_34: f64, %out: f64): + %61 = arith.subf %in, %in_34 : f64 + %62 = arith.addf %out, %61 : f64 + linalg.yield %62 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/diffusion_apply_2d__original.frontend.mlir b/issues/mfem_c_kernels/results/diffusion_apply_2d__original.frontend.mlir new file mode 100644 index 000000000000..dfc7d0ff5cf9 --- /dev/null +++ b/issues/mfem_c_kernels/results/diffusion_apply_2d__original.frontend.mlir @@ -0,0 +1,107 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_diffusion_apply_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4x2xf64> + %alloca_0 = memref.alloca() : memref<5x2xf64> + %alloca_1 = memref.alloca() : memref<5x5x2xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.store %cst, %alloca_1[%arg8, %arg9, 1] : memref<5x5x2xf64> + affine.store %cst, %alloca_1[%arg8, %arg9, 0] : memref<5x5x2xf64> + } + } + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.store %cst, %alloca_0[%arg9, 1] : memref<5x2xf64> + affine.store %cst, %alloca_0[%arg9, 0] : memref<5x2xf64> + } + affine.for %arg9 = 0 to 4 { + %0 = affine.load %arg5[%arg9 + %arg7 * 16 + %arg8 * 4] : memref + affine.for %arg10 = 0 to 5 { + %1 = affine.load %arg0[%arg9 + %arg10 * 4] : memref + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %alloca_0[%arg10, 0] : memref<5x2xf64> + %4 = arith.addf %3, %2 : f64 + affine.store %4, %alloca_0[%arg10, 0] : memref<5x2xf64> + %5 = affine.load %arg1[%arg9 + %arg10 * 4] : memref + %6 = arith.mulf %0, %5 : f64 + %7 = affine.load %alloca_0[%arg10, 1] : memref<5x2xf64> + %8 = arith.addf %7, %6 : f64 + affine.store %8, %alloca_0[%arg10, 1] : memref<5x2xf64> + } + } + affine.for %arg9 = 0 to 5 { + %0 = affine.load %arg0[%arg8 + %arg9 * 4] : memref + %1 = affine.load %arg1[%arg8 + %arg9 * 4] : memref + affine.for %arg10 = 0 to 5 { + %2 = affine.load %alloca_0[%arg10, 1] : memref<5x2xf64> + %3 = arith.mulf %2, %0 : f64 + %4 = affine.load %alloca_1[%arg9, %arg10, 0] : memref<5x5x2xf64> + %5 = arith.addf %4, %3 : f64 + affine.store %5, %alloca_1[%arg9, %arg10, 0] : memref<5x5x2xf64> + %6 = affine.load %alloca_0[%arg10, 0] : memref<5x2xf64> + %7 = arith.mulf %6, %1 : f64 + %8 = affine.load %alloca_1[%arg9, %arg10, 1] : memref<5x5x2xf64> + %9 = arith.addf %8, %7 : f64 + affine.store %9, %alloca_1[%arg9, %arg10, 1] : memref<5x5x2xf64> + } + } + } + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.load %alloca_1[%arg8, %arg9, 0] : memref<5x5x2xf64> + %1 = affine.load %alloca_1[%arg8, %arg9, 1] : memref<5x5x2xf64> + %2 = affine.load %arg4[%arg9 + %arg8 * 5 + %arg7 * 75] : memref + %3 = affine.load %arg4[%arg9 + %arg7 * 75 + %arg8 * 5 + 25] : memref + %4 = affine.load %arg4[%arg9 + %arg7 * 75 + %arg8 * 5 + 50] : memref + %5 = arith.mulf %2, %0 : f64 + %6 = arith.mulf %3, %1 : f64 + %7 = arith.addf %5, %6 : f64 + affine.store %7, %alloca_1[%arg8, %arg9, 0] : memref<5x5x2xf64> + %8 = arith.mulf %3, %0 : f64 + %9 = arith.mulf %4, %1 : f64 + %10 = arith.addf %8, %9 : f64 + affine.store %10, %alloca_1[%arg8, %arg9, 1] : memref<5x5x2xf64> + } + } + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.store %cst, %alloca[%arg9, 1] : memref<4x2xf64> + affine.store %cst, %alloca[%arg9, 0] : memref<4x2xf64> + } + affine.for %arg9 = 0 to 5 { + %0 = affine.load %alloca_1[%arg8, %arg9, 0] : memref<5x5x2xf64> + %1 = affine.load %alloca_1[%arg8, %arg9, 1] : memref<5x5x2xf64> + affine.for %arg10 = 0 to 4 { + %2 = affine.load %arg3[%arg9 + %arg10 * 5] : memref + %3 = arith.mulf %0, %2 : f64 + %4 = affine.load %alloca[%arg10, 0] : memref<4x2xf64> + %5 = arith.addf %4, %3 : f64 + affine.store %5, %alloca[%arg10, 0] : memref<4x2xf64> + %6 = affine.load %arg2[%arg9 + %arg10 * 5] : memref + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %alloca[%arg10, 1] : memref<4x2xf64> + %9 = arith.addf %8, %7 : f64 + affine.store %9, %alloca[%arg10, 1] : memref<4x2xf64> + } + } + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.load %alloca[%arg10, 0] : memref<4x2xf64> + %1 = affine.load %arg2[%arg8 + %arg9 * 5] : memref + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %alloca[%arg10, 1] : memref<4x2xf64> + %4 = affine.load %arg3[%arg8 + %arg9 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %2, %5 : f64 + %7 = affine.load %arg6[%arg10 + %arg7 * 16 + %arg9 * 4] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg6[%arg10 + %arg7 * 16 + %arg9 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/diffusion_apply_2d__original.raised.mlir b/issues/mfem_c_kernels/results/diffusion_apply_2d__original.raised.mlir new file mode 100644 index 000000000000..aaefbec19522 --- /dev/null +++ b/issues/mfem_c_kernels/results/diffusion_apply_2d__original.raised.mlir @@ -0,0 +1,144 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0)[s0] -> (d0 * 4 + s0)> +#map3 = affine_map<(d0, d1)[s0] -> (d1 + d0 * 5 + s0 * 75)> +#map4 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 75 + d0 * 5 + 25)> +#map5 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 75 + d0 * 5 + 50)> +#map6 = affine_map<(d0)[s0] -> (d0 * 5 + s0)> +#map7 = affine_map<(d0, d1)[s0] -> (d0 * 5 + s0)> +#map8 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 16 + d0 * 4)> +#map9 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_diffusion_apply_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4x2xf64> + %alloca_0 = memref.alloca() : memref<5x2xf64> + %alloca_1 = memref.alloca() : memref<5x5x2xf64> + affine.for %arg7 = 0 to 2 { + %subview = memref.subview %alloca_1[0, 0, 1] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_2 = memref.subview %alloca_1[0, 0, 0] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%subview_2 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg8 = 0 to 4 { + %subview_5 = memref.subview %alloca_0[0, 1] [%c5, 1] [1, 1] : memref<5x2xf64> to memref> + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel"]} outs(%subview_5 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_6 = memref.subview %alloca_0[0, 0] [%c5, 1] [1, 1] : memref<5x2xf64> to memref> + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel"]} outs(%subview_6 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg9 = 0 to 4 { + %3 = affine.load %arg5[%arg9 + %arg7 * 16 + %arg8 * 4] : memref + %4 = polygeist.submap(%arg0, %arg9, %c5) {map = #map2} : (memref, index, index) -> memref + %subview_7 = memref.subview %alloca_0[0, 0] [%c5, 1] [1, 1] : memref<5x2xf64> to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%4 : memref) outs(%subview_7 : memref>) { + ^bb0(%in: f64, %out: f64): + %6 = arith.mulf %3, %in : f64 + %7 = arith.addf %out, %6 : f64 + linalg.yield %7 : f64 + } + %5 = polygeist.submap(%arg1, %arg9, %c5) {map = #map2} : (memref, index, index) -> memref + %subview_8 = memref.subview %alloca_0[0, 1] [%c5, 1] [1, 1] : memref<5x2xf64> to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%5 : memref) outs(%subview_8 : memref>) { + ^bb0(%in: f64, %out: f64): + %6 = arith.mulf %3, %in : f64 + %7 = arith.addf %out, %6 : f64 + linalg.yield %7 : f64 + } + } + affine.for %arg9 = 0 to 5 { + %3 = affine.load %arg0[%arg8 + %arg9 * 4] : memref + %4 = affine.load %arg1[%arg8 + %arg9 * 4] : memref + %subview_7 = memref.subview %alloca_0[0, 1] [%c5, 1] [1, 1] : memref<5x2xf64> to memref> + %subview_8 = memref.subview %alloca_1[%arg9, 0, 0] [1, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%subview_7 : memref>) outs(%subview_8 : memref>) { + ^bb0(%in: f64, %out: f64): + %5 = arith.mulf %in, %3 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } + %subview_9 = memref.subview %alloca_0[0, 0] [%c5, 1] [1, 1] : memref<5x2xf64> to memref> + %subview_10 = memref.subview %alloca_1[%arg9, 0, 1] [1, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%subview_9 : memref>) outs(%subview_10 : memref>) { + ^bb0(%in: f64, %out: f64): + %5 = arith.mulf %in, %4 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } + } {polygeist.was_parallel} + } + %0 = polygeist.submap(%arg4, %arg7, %c5, %c5) {map = #map3} : (memref, index, index, index) -> memref + %1 = polygeist.submap(%arg4, %arg7, %c5, %c5) {map = #map4} : (memref, index, index, index) -> memref + %2 = polygeist.submap(%arg4, %arg7, %c5, %c5) {map = #map5} : (memref, index, index, index) -> memref + %subview_3 = memref.subview %alloca_1[0, 0, 0] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + %subview_4 = memref.subview %alloca_1[0, 0, 1] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x2xf64> to memref> + linalg.generic {indexing_maps = [#map, #map, #map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%0, %1, %2 : memref, memref, memref) outs(%subview_3, %subview_4 : memref>, memref>) { + ^bb0(%in: f64, %in_5: f64, %in_6: f64, %out: f64, %out_7: f64): + %3 = arith.mulf %in, %out : f64 + %4 = arith.mulf %in_5, %out_7 : f64 + %5 = arith.addf %3, %4 : f64 + %6 = arith.mulf %in_5, %out : f64 + %7 = arith.mulf %in_6, %out_7 : f64 + %8 = arith.addf %6, %7 : f64 + linalg.yield %5, %8 : f64, f64 + } + affine.for %arg8 = 0 to 5 { + %subview_5 = memref.subview %alloca[0, 1] [%c4, 1] [1, 1] : memref<4x2xf64> to memref> + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel"]} outs(%subview_5 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_6 = memref.subview %alloca[0, 0] [%c4, 1] [1, 1] : memref<4x2xf64> to memref> + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel"]} outs(%subview_6 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg9 = 0 to 5 { + %6 = affine.load %alloca_1[%arg8, %arg9, 0] : memref<5x5x2xf64> + %7 = affine.load %alloca_1[%arg8, %arg9, 1] : memref<5x5x2xf64> + %8 = polygeist.submap(%arg3, %arg9, %c4) {map = #map6} : (memref, index, index) -> memref + %subview_9 = memref.subview %alloca[0, 0] [%c4, 1] [1, 1] : memref<4x2xf64> to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%8 : memref) outs(%subview_9 : memref>) { + ^bb0(%in: f64, %out: f64): + %10 = arith.mulf %6, %in : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + %9 = polygeist.submap(%arg2, %arg9, %c4) {map = #map6} : (memref, index, index) -> memref + %subview_10 = memref.subview %alloca[0, 1] [%c4, 1] [1, 1] : memref<4x2xf64> to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%9 : memref) outs(%subview_10 : memref>) { + ^bb0(%in: f64, %out: f64): + %10 = arith.mulf %7, %in : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + } + %subview_7 = memref.subview %alloca[0, 0] [%c4, 1] [1, 1] : memref<4x2xf64> to memref> + %3 = polygeist.submap(%arg2, %arg8, %c4, %c4) {map = #map7} : (memref, index, index, index) -> memref + %subview_8 = memref.subview %alloca[0, 1] [%c4, 1] [1, 1] : memref<4x2xf64> to memref> + %4 = polygeist.submap(%arg3, %arg8, %c4, %c4) {map = #map7} : (memref, index, index, index) -> memref + %5 = polygeist.submap(%arg6, %arg7, %c4, %c4) {map = #map8} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map9, #map, #map9, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%subview_7, %3, %subview_8, %4 : memref>, memref, memref>, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_9: f64, %in_10: f64, %in_11: f64, %out: f64): + %6 = arith.mulf %in, %in_9 : f64 + %7 = arith.mulf %in_10, %in_11 : f64 + %8 = arith.addf %6, %7 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/diffusion_apply_2d_stage_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/diffusion_apply_2d_stage_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..4e9992498120 --- /dev/null +++ b/issues/mfem_c_kernels/results/diffusion_apply_2d_stage_sliced__normalized.frontend.mlir @@ -0,0 +1,150 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_diffusion_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5xf64> + %alloca_4 = memref.alloca() : memref<2x5x5xf64> + %alloca_5 = memref.alloca() : memref<2x4x5xf64> + %alloca_6 = memref.alloca() : memref<2x4x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg10 + %arg7 * 16 + %arg8 * 4] : memref + %2 = affine.load %arg0[%arg10 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9] : memref<2x4x5xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg10 + %arg7 * 16 + %arg8 * 4] : memref + %2 = affine.load %arg1[%arg10 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9] : memref<2x4x5xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg7, %arg10, %arg9] : memref<2x4x5xf64> + %2 = affine.load %arg0[%arg10 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9] : memref<2x5x5xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg7, %arg10, %arg9] : memref<2x4x5xf64> + %2 = affine.load %arg1[%arg10 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9] : memref<2x5x5xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg10 + %arg8 * 5 + %arg7 * 75] : memref + %2 = affine.load %alloca_4[%arg7, %arg8, %arg10] : memref<2x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg10 + %arg7 * 75 + %arg8 * 5 + 25] : memref + %5 = affine.load %alloca_3[%arg7, %arg8, %arg10] : memref<2x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg3[%arg10 + %arg9 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg11, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9] : memref<2x5x4xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg10 + %arg7 * 75 + %arg8 * 5 + 25] : memref + %2 = affine.load %alloca_4[%arg7, %arg8, %arg10] : memref<2x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg10 + %arg7 * 75 + %arg8 * 5 + 50] : memref + %5 = affine.load %alloca_3[%arg7, %arg8, %arg10] : memref<2x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg2[%arg10 + %arg9 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg11, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9] : memref<2x5x4xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg10, %arg9] : memref<2x5x4xf64> + %2 = affine.load %arg2[%arg10 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9] : memref<2x4x4xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_1[%arg7, %arg10, %arg9] : memref<2x5x4xf64> + %2 = affine.load %arg3[%arg10 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9] : memref<2x4x4xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + %0 = affine.load %alloca_0[%arg7, %arg8, %arg9] : memref<2x4x4xf64> + %1 = affine.load %alloca[%arg7, %arg8, %arg9] : memref<2x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %arg6[%arg9 + %arg7 * 16 + %arg8 * 4] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg6[%arg9 + %arg7 * 16 + %arg8 * 4] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/diffusion_apply_2d_stage_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/diffusion_apply_2d_stage_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..303648b645bc --- /dev/null +++ b/issues/mfem_c_kernels/results/diffusion_apply_2d_stage_sliced__normalized.raised.mlir @@ -0,0 +1,138 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5 + d0 * 75)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 75 + d1 * 5 + 25)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 75 + d1 * 5 + 50)> +#map12 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map13 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_diffusion_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5xf64> + %alloca_4 = memref.alloca() : memref<2x5x5xf64> + %alloca_5 = memref.alloca() : memref<2x4x5xf64> + %alloca_6 = memref.alloca() : memref<2x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_6 : memref<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg5, %c2, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_6 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %15 = arith.mulf %in, %in_7 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_5 : memref<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg5, %c2, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%2, %3 : memref, memref) outs(%alloca_5 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %15 = arith.mulf %in, %in_7 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_4 : memref<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg0, %c2, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_5, %4 : memref<2x4x5xf64>, memref) outs(%alloca_4 : memref<2x5x5xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %15 = arith.mulf %in, %in_7 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %5 = polygeist.submap(%arg1, %c2, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_6, %5 : memref<2x4x5xf64>, memref) outs(%alloca_3 : memref<2x5x5xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %15 = arith.mulf %in, %in_7 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg4, %c2, %c5, %c4, %c5) {map = #map7} : (memref, index, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %c2, %c5, %c4, %c5) {map = #map8} : (memref, index, index, index, index) -> memref + %8 = polygeist.submap(%arg3, %c2, %c5, %c4, %c5) {map = #map9} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map10, #map3, #map10, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%6, %alloca_4, %7, %alloca_3, %8 : memref, memref<2x5x5xf64>, memref, memref<2x5x5xf64>, memref) outs(%alloca_2 : memref<2x5x4xf64>) { + ^bb0(%in: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %out: f64): + %15 = arith.mulf %in, %in_7 : f64 + %16 = arith.mulf %in_8, %in_9 : f64 + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %in_10 : f64 + %19 = arith.addf %out, %18 : f64 + linalg.yield %19 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %9 = polygeist.submap(%arg4, %c2, %c5, %c4, %c5) {map = #map8} : (memref, index, index, index, index) -> memref + %10 = polygeist.submap(%arg4, %c2, %c5, %c4, %c5) {map = #map11} : (memref, index, index, index, index) -> memref + %11 = polygeist.submap(%arg2, %c2, %c5, %c4, %c5) {map = #map9} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map10, #map3, #map10, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%9, %alloca_4, %10, %alloca_3, %11 : memref, memref<2x5x5xf64>, memref, memref<2x5x5xf64>, memref) outs(%alloca_1 : memref<2x5x4xf64>) { + ^bb0(%in: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %out: f64): + %15 = arith.mulf %in, %in_7 : f64 + %16 = arith.mulf %in_8, %in_9 : f64 + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %in_10 : f64 + %19 = arith.addf %out, %18 : f64 + linalg.yield %19 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %12 = polygeist.submap(%arg2, %c2, %c4, %c4, %c5) {map = #map12} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_2, %12 : memref<2x5x4xf64>, memref) outs(%alloca_0 : memref<2x4x4xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %15 = arith.mulf %in, %in_7 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca : memref<2x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %13 = polygeist.submap(%arg3, %c2, %c4, %c4, %c5) {map = #map12} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_1, %13 : memref<2x5x4xf64>, memref) outs(%alloca : memref<2x4x4xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %15 = arith.mulf %in, %in_7 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 + } + %14 = polygeist.submap(%arg6, %c2, %c4, %c4) {map = #map13} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%alloca_0, %alloca : memref<2x4x4xf64>, memref<2x4x4xf64>) outs(%14 : memref) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %15 = arith.addf %in, %in_7 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/diffusion_apply_3d__original.frontend.mlir b/issues/mfem_c_kernels/results/diffusion_apply_3d__original.frontend.mlir new file mode 100644 index 000000000000..e8962e5b1bbe --- /dev/null +++ b/issues/mfem_c_kernels/results/diffusion_apply_3d__original.frontend.mlir @@ -0,0 +1,205 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_diffusion_apply_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4x3xf64> + %alloca_0 = memref.alloca() : memref<4x4x3xf64> + %alloca_1 = memref.alloca() : memref<5x2xf64> + %alloca_2 = memref.alloca() : memref<5x5x3xf64> + %alloca_3 = memref.alloca() : memref<5x5x5x3xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.store %cst, %alloca_3[%arg8, %arg9, %arg10, %arg11] : memref<5x5x5x3xf64> + } + } + } + } + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 3 { + affine.store %cst, %alloca_2[%arg9, %arg10, %arg11] : memref<5x5x3xf64> + } + } + } + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + affine.store %cst, %alloca_1[%arg10, 1] : memref<5x2xf64> + affine.store %cst, %alloca_1[%arg10, 0] : memref<5x2xf64> + } + affine.for %arg10 = 0 to 4 { + %0 = affine.load %arg5[%arg7 * 64 + %arg10 + %arg8 * 16 + %arg9 * 4] : memref + affine.for %arg11 = 0 to 5 { + %1 = affine.load %arg0[%arg10 + %arg11 * 4] : memref + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %alloca_1[%arg11, 0] : memref<5x2xf64> + %4 = arith.addf %3, %2 : f64 + affine.store %4, %alloca_1[%arg11, 0] : memref<5x2xf64> + %5 = affine.load %arg1[%arg10 + %arg11 * 4] : memref + %6 = arith.mulf %0, %5 : f64 + %7 = affine.load %alloca_1[%arg11, 1] : memref<5x2xf64> + %8 = arith.addf %7, %6 : f64 + affine.store %8, %alloca_1[%arg11, 1] : memref<5x2xf64> + } + } + affine.for %arg10 = 0 to 5 { + %0 = affine.load %arg0[%arg9 + %arg10 * 4] : memref + %1 = affine.load %arg1[%arg9 + %arg10 * 4] : memref + affine.for %arg11 = 0 to 5 { + %2 = affine.load %alloca_1[%arg11, 1] : memref<5x2xf64> + %3 = arith.mulf %2, %0 : f64 + %4 = affine.load %alloca_2[%arg10, %arg11, 0] : memref<5x5x3xf64> + %5 = arith.addf %4, %3 : f64 + affine.store %5, %alloca_2[%arg10, %arg11, 0] : memref<5x5x3xf64> + %6 = affine.load %alloca_1[%arg11, 0] : memref<5x2xf64> + %7 = arith.mulf %6, %1 : f64 + %8 = affine.load %alloca_2[%arg10, %arg11, 1] : memref<5x5x3xf64> + %9 = arith.addf %8, %7 : f64 + affine.store %9, %alloca_2[%arg10, %arg11, 1] : memref<5x5x3xf64> + %10 = arith.mulf %6, %0 : f64 + %11 = affine.load %alloca_2[%arg10, %arg11, 2] : memref<5x5x3xf64> + %12 = arith.addf %11, %10 : f64 + affine.store %12, %alloca_2[%arg10, %arg11, 2] : memref<5x5x3xf64> + } + } + } + affine.for %arg9 = 0 to 5 { + %0 = affine.load %arg0[%arg8 + %arg9 * 4] : memref + %1 = affine.load %arg1[%arg8 + %arg9 * 4] : memref + affine.for %arg10 = 0 to 5 { + affine.for %arg11 = 0 to 5 { + %2 = affine.load %alloca_2[%arg10, %arg11, 0] : memref<5x5x3xf64> + %3 = arith.mulf %2, %0 : f64 + %4 = affine.load %alloca_3[%arg9, %arg10, %arg11, 0] : memref<5x5x5x3xf64> + %5 = arith.addf %4, %3 : f64 + affine.store %5, %alloca_3[%arg9, %arg10, %arg11, 0] : memref<5x5x5x3xf64> + %6 = affine.load %alloca_2[%arg10, %arg11, 1] : memref<5x5x3xf64> + %7 = arith.mulf %6, %0 : f64 + %8 = affine.load %alloca_3[%arg9, %arg10, %arg11, 1] : memref<5x5x5x3xf64> + %9 = arith.addf %8, %7 : f64 + affine.store %9, %alloca_3[%arg9, %arg10, %arg11, 1] : memref<5x5x5x3xf64> + %10 = affine.load %alloca_2[%arg10, %arg11, 2] : memref<5x5x3xf64> + %11 = arith.mulf %10, %1 : f64 + %12 = affine.load %alloca_3[%arg9, %arg10, %arg11, 2] : memref<5x5x5x3xf64> + %13 = arith.addf %12, %11 : f64 + affine.store %13, %alloca_3[%arg9, %arg10, %arg11, 2] : memref<5x5x5x3xf64> + } + } + } + } + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.load %alloca_3[%arg8, %arg9, %arg10, 0] : memref<5x5x5x3xf64> + %1 = affine.load %alloca_3[%arg8, %arg9, %arg10, 1] : memref<5x5x5x3xf64> + %2 = affine.load %alloca_3[%arg8, %arg9, %arg10, 2] : memref<5x5x5x3xf64> + %3 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg9 * 5 + %arg7 * 750] : memref + %4 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg7 * 750 + %arg9 * 5 + 125] : memref + %5 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg7 * 750 + %arg9 * 5 + 250] : memref + %6 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg7 * 750 + %arg9 * 5 + 375] : memref + %7 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg7 * 750 + %arg9 * 5 + 500] : memref + %8 = affine.load %arg4[%arg8 * 25 + %arg10 + %arg7 * 750 + %arg9 * 5 + 625] : memref + %9 = arith.mulf %3, %0 : f64 + %10 = arith.mulf %4, %1 : f64 + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %5, %2 : f64 + %13 = arith.addf %11, %12 : f64 + affine.store %13, %alloca_3[%arg8, %arg9, %arg10, 0] : memref<5x5x5x3xf64> + %14 = arith.mulf %4, %0 : f64 + %15 = arith.mulf %6, %1 : f64 + %16 = arith.addf %14, %15 : f64 + %17 = arith.mulf %7, %2 : f64 + %18 = arith.addf %16, %17 : f64 + affine.store %18, %alloca_3[%arg8, %arg9, %arg10, 1] : memref<5x5x5x3xf64> + %19 = arith.mulf %5, %0 : f64 + %20 = arith.mulf %7, %1 : f64 + %21 = arith.addf %19, %20 : f64 + %22 = arith.mulf %8, %2 : f64 + %23 = arith.addf %21, %22 : f64 + affine.store %23, %alloca_3[%arg8, %arg9, %arg10, 2] : memref<5x5x5x3xf64> + } + } + } + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.store %cst, %alloca_0[%arg9, %arg10, %arg11] : memref<4x4x3xf64> + } + } + } + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 3 { + affine.store %cst, %alloca[%arg10, %arg11] : memref<4x3xf64> + } + } + affine.for %arg10 = 0 to 5 { + %0 = affine.load %alloca_3[%arg8, %arg9, %arg10, 0] : memref<5x5x5x3xf64> + %1 = affine.load %alloca_3[%arg8, %arg9, %arg10, 1] : memref<5x5x5x3xf64> + %2 = affine.load %alloca_3[%arg8, %arg9, %arg10, 2] : memref<5x5x5x3xf64> + affine.for %arg11 = 0 to 4 { + %3 = affine.load %arg3[%arg10 + %arg11 * 5] : memref + %4 = arith.mulf %0, %3 : f64 + %5 = affine.load %alloca[%arg11, 0] : memref<4x3xf64> + %6 = arith.addf %5, %4 : f64 + affine.store %6, %alloca[%arg11, 0] : memref<4x3xf64> + %7 = affine.load %arg2[%arg10 + %arg11 * 5] : memref + %8 = arith.mulf %1, %7 : f64 + %9 = affine.load %alloca[%arg11, 1] : memref<4x3xf64> + %10 = arith.addf %9, %8 : f64 + affine.store %10, %alloca[%arg11, 1] : memref<4x3xf64> + %11 = affine.load %arg2[%arg10 + %arg11 * 5] : memref + %12 = arith.mulf %2, %11 : f64 + %13 = affine.load %alloca[%arg11, 2] : memref<4x3xf64> + %14 = arith.addf %13, %12 : f64 + affine.store %14, %alloca[%arg11, 2] : memref<4x3xf64> + } + } + affine.for %arg10 = 0 to 4 { + %0 = affine.load %arg2[%arg9 + %arg10 * 5] : memref + %1 = affine.load %arg3[%arg9 + %arg10 * 5] : memref + affine.for %arg11 = 0 to 4 { + %2 = affine.load %alloca[%arg11, 0] : memref<4x3xf64> + %3 = arith.mulf %2, %0 : f64 + %4 = affine.load %alloca_0[%arg10, %arg11, 0] : memref<4x4x3xf64> + %5 = arith.addf %4, %3 : f64 + affine.store %5, %alloca_0[%arg10, %arg11, 0] : memref<4x4x3xf64> + %6 = affine.load %alloca[%arg11, 1] : memref<4x3xf64> + %7 = arith.mulf %6, %1 : f64 + %8 = affine.load %alloca_0[%arg10, %arg11, 1] : memref<4x4x3xf64> + %9 = arith.addf %8, %7 : f64 + affine.store %9, %alloca_0[%arg10, %arg11, 1] : memref<4x4x3xf64> + %10 = affine.load %alloca[%arg11, 2] : memref<4x3xf64> + %11 = arith.mulf %10, %0 : f64 + %12 = affine.load %alloca_0[%arg10, %arg11, 2] : memref<4x4x3xf64> + %13 = arith.addf %12, %11 : f64 + affine.store %13, %alloca_0[%arg10, %arg11, 2] : memref<4x4x3xf64> + } + } + } + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + affine.for %arg11 = 0 to 4 { + %0 = affine.load %alloca_0[%arg10, %arg11, 0] : memref<4x4x3xf64> + %1 = affine.load %alloca_0[%arg10, %arg11, 1] : memref<4x4x3xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %arg2[%arg8 + %arg9 * 5] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = affine.load %alloca_0[%arg10, %arg11, 2] : memref<4x4x3xf64> + %6 = affine.load %arg3[%arg8 + %arg9 * 5] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.addf %4, %7 : f64 + %9 = affine.load %arg6[%arg7 * 64 + %arg11 + %arg9 * 16 + %arg10 * 4] : memref + %10 = arith.addf %9, %8 : f64 + affine.store %10, %arg6[%arg7 * 64 + %arg11 + %arg9 * 16 + %arg10 * 4] : memref + } + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/diffusion_apply_3d__original.raised.mlir b/issues/mfem_c_kernels/results/diffusion_apply_3d__original.raised.mlir new file mode 100644 index 000000000000..a72a6c124237 --- /dev/null +++ b/issues/mfem_c_kernels/results/diffusion_apply_3d__original.raised.mlir @@ -0,0 +1,232 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map2 = affine_map<(d0) -> (d0)> +#map3 = affine_map<(d0)[s0] -> (d0 * 4 + s0)> +#map4 = affine_map<(d0, d1) -> (d0)> +#map5 = affine_map<(d0, d1) -> (d1)> +#map6 = affine_map<(d0, d1) -> (d0, d1)> +#map7 = affine_map<(d0, d1, d2)[s0] -> (d2 + d0 * 25 + d1 * 5 + s0 * 750)> +#map8 = affine_map<(d0, d1, d2)[s0] -> (d2 + d0 * 25 + s0 * 750 + d1 * 5 + 125)> +#map9 = affine_map<(d0, d1, d2)[s0] -> (d2 + d0 * 25 + s0 * 750 + d1 * 5 + 250)> +#map10 = affine_map<(d0, d1, d2)[s0] -> (d2 + d0 * 25 + s0 * 750 + d1 * 5 + 375)> +#map11 = affine_map<(d0, d1, d2)[s0] -> (d2 + d0 * 25 + s0 * 750 + d1 * 5 + 500)> +#map12 = affine_map<(d0, d1, d2)[s0] -> (d2 + d0 * 25 + s0 * 750 + d1 * 5 + 625)> +#map13 = affine_map<(d0)[s0] -> (d0 * 5 + s0)> +#map14 = affine_map<(d0, d1, d2)[s0] -> (d0 * 5 + s0)> +#map15 = affine_map<(d0, d1, d2)[s0] -> (d2 + s0 * 64 + d0 * 16 + d1 * 4)> +#map16 = affine_map<(d0, d1, d2) -> (d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_diffusion_apply_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4x3xf64> + %alloca_0 = memref.alloca() : memref<4x4x3xf64> + %alloca_1 = memref.alloca() : memref<5x2xf64> + %alloca_2 = memref.alloca() : memref<5x5x3xf64> + %alloca_3 = memref.alloca() : memref<5x5x5x3xf64> + affine.for %arg7 = 0 to 2 { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<5x5x5x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg8 = 0 to 4 { + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<5x5x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg9 = 0 to 4 { + %subview_6 = memref.subview %alloca_1[0, 1] [%c5, 1] [1, 1] : memref<5x2xf64> to memref> + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel"]} outs(%subview_6 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %subview_7 = memref.subview %alloca_1[0, 0] [%c5, 1] [1, 1] : memref<5x2xf64> to memref> + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel"]} outs(%subview_7 : memref>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg10 = 0 to 4 { + %8 = affine.load %arg5[%arg7 * 64 + %arg10 + %arg8 * 16 + %arg9 * 4] : memref + %9 = polygeist.submap(%arg0, %arg10, %c5) {map = #map3} : (memref, index, index) -> memref + %subview_15 = memref.subview %alloca_1[0, 0] [%c5, 1] [1, 1] : memref<5x2xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%9 : memref) outs(%subview_15 : memref>) { + ^bb0(%in: f64, %out: f64): + %11 = arith.mulf %8, %in : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + %10 = polygeist.submap(%arg1, %arg10, %c5) {map = #map3} : (memref, index, index) -> memref + %subview_16 = memref.subview %alloca_1[0, 1] [%c5, 1] [1, 1] : memref<5x2xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%10 : memref) outs(%subview_16 : memref>) { + ^bb0(%in: f64, %out: f64): + %11 = arith.mulf %8, %in : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + } + %subview_8 = memref.subview %alloca_1[0, 1] [%c5, 1] [1, 1] : memref<5x2xf64> to memref> + %subview_9 = memref.subview %alloca_1[0, 0] [%c5, 1] [1, 1] : memref<5x2xf64> to memref> + %subview_10 = memref.subview %alloca_2[0, 0, 0] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x3xf64> to memref> + %subview_11 = memref.subview %alloca_2[0, 0, 1] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x3xf64> to memref> + %subview_12 = memref.subview %alloca_2[0, 0, 2] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x3xf64> to memref> + %6 = polygeist.submap(%arg0, %arg9, %c5) {map = #map3} : (memref, index, index) -> memref + %subview_13 = memref.subview %6[0] [%c5] [1] : memref to memref> + %7 = polygeist.submap(%arg1, %arg9, %c5) {map = #map3} : (memref, index, index) -> memref + %subview_14 = memref.subview %7[0] [%c5] [1] : memref to memref> + linalg.generic {indexing_maps = [#map4, #map4, #map5, #map5, #map6, #map6, #map6], iterator_types = ["parallel", "parallel"]} ins(%subview_13, %subview_14, %subview_8, %subview_9 : memref>, memref>, memref>, memref>) outs(%subview_10, %subview_11, %subview_12 : memref>, memref>, memref>) { + ^bb0(%in: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64, %out_18: f64, %out_19: f64): + %8 = arith.mulf %in_16, %in : f64 + %9 = arith.addf %out, %8 : f64 + %10 = arith.mulf %in_17, %in_15 : f64 + %11 = arith.addf %out_18, %10 : f64 + %12 = arith.mulf %in_17, %in : f64 + %13 = arith.addf %out_19, %12 : f64 + linalg.yield %9, %11, %13 : f64, f64, f64 + } + } + affine.for %arg9 = 0 to 5 { + %6 = affine.load %arg0[%arg8 + %arg9 * 4] : memref + %7 = affine.load %arg1[%arg8 + %arg9 * 4] : memref + %subview_6 = memref.subview %alloca_2[0, 0, 0] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x3xf64> to memref> + %subview_7 = memref.subview %alloca_3[%arg9, 0, 0, 0] [1, %c5, %c5, 1] [1, 1, 1, 1] : memref<5x5x5x3xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map6], iterator_types = ["parallel", "parallel"]} ins(%subview_6 : memref>) outs(%subview_7 : memref>) { + ^bb0(%in: f64, %out: f64): + %8 = arith.mulf %in, %6 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + %subview_8 = memref.subview %alloca_2[0, 0, 1] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x3xf64> to memref> + %subview_9 = memref.subview %alloca_3[%arg9, 0, 0, 1] [1, %c5, %c5, 1] [1, 1, 1, 1] : memref<5x5x5x3xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map6], iterator_types = ["parallel", "parallel"]} ins(%subview_8 : memref>) outs(%subview_9 : memref>) { + ^bb0(%in: f64, %out: f64): + %8 = arith.mulf %in, %6 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + %subview_10 = memref.subview %alloca_2[0, 0, 2] [%c5, %c5, 1] [1, 1, 1] : memref<5x5x3xf64> to memref> + %subview_11 = memref.subview %alloca_3[%arg9, 0, 0, 2] [1, %c5, %c5, 1] [1, 1, 1, 1] : memref<5x5x5x3xf64> to memref> + linalg.generic {indexing_maps = [#map6, #map6], iterator_types = ["parallel", "parallel"]} ins(%subview_10 : memref>) outs(%subview_11 : memref>) { + ^bb0(%in: f64, %out: f64): + %8 = arith.mulf %in, %7 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } {polygeist.was_parallel} + } + %0 = polygeist.submap(%arg4, %arg7, %c5, %c5, %c5) {map = #map7} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg4, %arg7, %c5, %c5, %c5) {map = #map8} : (memref, index, index, index, index) -> memref + %2 = polygeist.submap(%arg4, %arg7, %c5, %c5, %c5) {map = #map9} : (memref, index, index, index, index) -> memref + %3 = polygeist.submap(%arg4, %arg7, %c5, %c5, %c5) {map = #map10} : (memref, index, index, index, index) -> memref + %4 = polygeist.submap(%arg4, %arg7, %c5, %c5, %c5) {map = #map11} : (memref, index, index, index, index) -> memref + %5 = polygeist.submap(%arg4, %arg7, %c5, %c5, %c5) {map = #map12} : (memref, index, index, index, index) -> memref + %subview = memref.subview %alloca_3[0, 0, 0, 0] [%c5, %c5, %c5, 1] [1, 1, 1, 1] : memref<5x5x5x3xf64> to memref> + %subview_4 = memref.subview %alloca_3[0, 0, 0, 1] [%c5, %c5, %c5, 1] [1, 1, 1, 1] : memref<5x5x5x3xf64> to memref> + %subview_5 = memref.subview %alloca_3[0, 0, 0, 2] [%c5, %c5, %c5, 1] [1, 1, 1, 1] : memref<5x5x5x3xf64> to memref> + linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1, #map1, #map1, #map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%0, %1, %2, %3, %4, %5 : memref, memref, memref, memref, memref, memref) outs(%subview, %subview_4, %subview_5 : memref>, memref>, memref>) { + ^bb0(%in: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %out: f64, %out_11: f64, %out_12: f64): + %6 = arith.mulf %in, %out : f64 + %7 = arith.mulf %in_6, %out_11 : f64 + %8 = arith.addf %6, %7 : f64 + %9 = arith.mulf %in_7, %out_12 : f64 + %10 = arith.addf %8, %9 : f64 + %11 = arith.mulf %in_6, %out : f64 + %12 = arith.mulf %in_8, %out_11 : f64 + %13 = arith.addf %11, %12 : f64 + %14 = arith.mulf %in_9, %out_12 : f64 + %15 = arith.addf %13, %14 : f64 + %16 = arith.mulf %in_7, %out : f64 + %17 = arith.mulf %in_9, %out_11 : f64 + %18 = arith.addf %16, %17 : f64 + %19 = arith.mulf %in_10, %out_12 : f64 + %20 = arith.addf %18, %19 : f64 + linalg.yield %10, %15, %20 : f64, f64, f64 + } + affine.for %arg8 = 0 to 5 { + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<4x4x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg9 = 0 to 5 { + linalg.generic {indexing_maps = [#map6], iterator_types = ["parallel", "parallel"]} outs(%alloca : memref<4x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg10 = 0 to 5 { + %9 = affine.load %alloca_3[%arg8, %arg9, %arg10, 0] : memref<5x5x5x3xf64> + %10 = affine.load %alloca_3[%arg8, %arg9, %arg10, 1] : memref<5x5x5x3xf64> + %11 = affine.load %alloca_3[%arg8, %arg9, %arg10, 2] : memref<5x5x5x3xf64> + %12 = polygeist.submap(%arg3, %arg10, %c4) {map = #map13} : (memref, index, index) -> memref + %subview_9 = memref.subview %alloca[0, 0] [%c4, 1] [1, 1] : memref<4x3xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%12 : memref) outs(%subview_9 : memref>) { + ^bb0(%in: f64, %out: f64): + %15 = arith.mulf %9, %in : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 + } + %13 = polygeist.submap(%arg2, %arg10, %c4) {map = #map13} : (memref, index, index) -> memref + %subview_10 = memref.subview %alloca[0, 1] [%c4, 1] [1, 1] : memref<4x3xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%13 : memref) outs(%subview_10 : memref>) { + ^bb0(%in: f64, %out: f64): + %15 = arith.mulf %10, %in : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 + } + %14 = polygeist.submap(%arg2, %arg10, %c4) {map = #map13} : (memref, index, index) -> memref + %subview_11 = memref.subview %alloca[0, 2] [%c4, 1] [1, 1] : memref<4x3xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%14 : memref) outs(%subview_11 : memref>) { + ^bb0(%in: f64, %out: f64): + %15 = arith.mulf %11, %in : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 + } + } + affine.for %arg10 = 0 to 4 { + %9 = affine.load %arg2[%arg9 + %arg10 * 5] : memref + %10 = affine.load %arg3[%arg9 + %arg10 * 5] : memref + %subview_9 = memref.subview %alloca[0, 0] [%c4, 1] [1, 1] : memref<4x3xf64> to memref> + %subview_10 = memref.subview %alloca_0[%arg10, 0, 0] [1, %c4, 1] [1, 1, 1] : memref<4x4x3xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%subview_9 : memref>) outs(%subview_10 : memref>) { + ^bb0(%in: f64, %out: f64): + %11 = arith.mulf %in, %9 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + %subview_11 = memref.subview %alloca[0, 1] [%c4, 1] [1, 1] : memref<4x3xf64> to memref> + %subview_12 = memref.subview %alloca_0[%arg10, 0, 1] [1, %c4, 1] [1, 1, 1] : memref<4x4x3xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%subview_11 : memref>) outs(%subview_12 : memref>) { + ^bb0(%in: f64, %out: f64): + %11 = arith.mulf %in, %10 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + %subview_13 = memref.subview %alloca[0, 2] [%c4, 1] [1, 1] : memref<4x3xf64> to memref> + %subview_14 = memref.subview %alloca_0[%arg10, 0, 2] [1, %c4, 1] [1, 1, 1] : memref<4x4x3xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%subview_13 : memref>) outs(%subview_14 : memref>) { + ^bb0(%in: f64, %out: f64): + %11 = arith.mulf %in, %9 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } + } {polygeist.was_parallel} + } + %subview_6 = memref.subview %alloca_0[0, 0, 0] [%c4, %c4, 1] [1, 1, 1] : memref<4x4x3xf64> to memref> + %subview_7 = memref.subview %alloca_0[0, 0, 1] [%c4, %c4, 1] [1, 1, 1] : memref<4x4x3xf64> to memref> + %6 = polygeist.submap(%arg2, %arg8, %c4, %c4, %c4) {map = #map14} : (memref, index, index, index, index) -> memref + %subview_8 = memref.subview %alloca_0[0, 0, 2] [%c4, %c4, 1] [1, 1, 1] : memref<4x4x3xf64> to memref> + %7 = polygeist.submap(%arg3, %arg8, %c4, %c4, %c4) {map = #map14} : (memref, index, index, index, index) -> memref + %8 = polygeist.submap(%arg6, %arg7, %c4, %c4, %c4) {map = #map15} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map16, #map16, #map1, #map16, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%subview_6, %subview_7, %6, %subview_8, %7 : memref>, memref>, memref, memref>, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %out: f64): + %9 = arith.addf %in, %in_9 : f64 + %10 = arith.mulf %9, %in_10 : f64 + %11 = arith.mulf %in_11, %in_12 : f64 + %12 = arith.addf %10, %11 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/diffusion_apply_3d_stage_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/diffusion_apply_3d_stage_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..c701d4eca4b5 --- /dev/null +++ b/issues/mfem_c_kernels/results/diffusion_apply_3d_stage_sliced__normalized.frontend.mlir @@ -0,0 +1,341 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_diffusion_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_14 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_15 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg7 * 64 + %arg11 + %arg8 * 16 + %arg9 * 4] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_15[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg7 * 64 + %arg11 + %arg8 * 16 + %arg9 * 4] : memref + %2 = affine.load %arg1[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_14[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_14[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_15[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg9 * 5 + %arg7 * 750] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 125] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 250] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg3[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_7[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 125] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 375] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 500] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 250] : memref + %2 = affine.load %alloca_10[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 500] : memref + %5 = affine.load %alloca_9[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + %8 = affine.load %arg4[%arg8 * 25 + %arg11 + %arg7 * 750 + %arg9 * 5 + 625] : memref + %9 = affine.load %alloca_8[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + %12 = affine.load %arg2[%arg11 + %arg10 * 5] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = arith.addf %arg12, %13 : f64 + affine.yield %14 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %2 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 4 { + %0 = affine.load %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x4xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg6[%arg7 * 64 + %arg10 + %arg8 * 16 + %arg9 * 4] : memref + %6 = arith.addf %5, %4 : f64 + affine.store %6, %arg6[%arg7 * 64 + %arg10 + %arg8 * 16 + %arg9 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/diffusion_apply_3d_stage_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/diffusion_apply_3d_stage_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..5c5a2b8b54e8 --- /dev/null +++ b/issues/mfem_c_kernels/results/diffusion_apply_3d_stage_sliced__normalized.raised.mlir @@ -0,0 +1,267 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d2 * 5 + d0 * 750)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 125)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 250)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 375)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 500)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 25 + d0 * 750 + d2 * 5 + 625)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_diffusion_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_8 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_14 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_15 = memref.alloca() : memref<2x4x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_15 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg5, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_15 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_14 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg5, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%2, %3 : memref, memref) outs(%alloca_14 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_13 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_14, %4 : memref<2x4x4x5xf64>, memref) outs(%alloca_13 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_12 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %5 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_15, %5 : memref<2x4x4x5xf64>, memref) outs(%alloca_12 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_11 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_15, %6 : memref<2x4x4x5xf64>, memref) outs(%alloca_11 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_10 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %7 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_13, %7 : memref<2x4x5x5xf64>, memref) outs(%alloca_10 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_9 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_12, %8 : memref<2x4x5x5xf64>, memref) outs(%alloca_9 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_8 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %9 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_11, %9 : memref<2x4x5x5xf64>, memref) outs(%alloca_8 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_7 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %10 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map9} : (memref, index, index, index, index, index) -> memref + %11 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (memref, index, index, index, index, index) -> memref + %12 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (memref, index, index, index, index, index) -> memref + %13 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%10, %alloca_10, %11, %alloca_9, %12, %alloca_8, %13 : memref, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref) outs(%alloca_7 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %in_17: f64, %in_18: f64, %in_19: f64, %in_20: f64, %in_21: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.mulf %in_17, %in_18 : f64 + %31 = arith.addf %29, %30 : f64 + %32 = arith.mulf %in_19, %in_20 : f64 + %33 = arith.addf %31, %32 : f64 + %34 = arith.mulf %33, %in_21 : f64 + %35 = arith.addf %out, %34 : f64 + linalg.yield %35 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_6 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (memref, index, index, index, index, index) -> memref + %15 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %16 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %17 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%14, %alloca_10, %15, %alloca_9, %16, %alloca_8, %17 : memref, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref) outs(%alloca_6 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %in_17: f64, %in_18: f64, %in_19: f64, %in_20: f64, %in_21: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.mulf %in_17, %in_18 : f64 + %31 = arith.addf %29, %30 : f64 + %32 = arith.mulf %in_19, %in_20 : f64 + %33 = arith.addf %31, %32 : f64 + %34 = arith.mulf %33, %in_21 : f64 + %35 = arith.addf %out, %34 : f64 + linalg.yield %35 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_5 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %18 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map11} : (memref, index, index, index, index, index) -> memref + %19 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + %20 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map16} : (memref, index, index, index, index, index) -> memref + %21 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4, %c5) {map = #map12} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map13, #map3, #map13, #map3, #map13, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%18, %alloca_10, %19, %alloca_9, %20, %alloca_8, %21 : memref, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref, memref<2x5x5x5xf64>, memref) outs(%alloca_5 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %in_17: f64, %in_18: f64, %in_19: f64, %in_20: f64, %in_21: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.mulf %in_17, %in_18 : f64 + %31 = arith.addf %29, %30 : f64 + %32 = arith.mulf %in_19, %in_20 : f64 + %33 = arith.addf %31, %32 : f64 + %34 = arith.mulf %33, %in_21 : f64 + %35 = arith.addf %out, %34 : f64 + linalg.yield %35 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_4 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %22 = polygeist.submap(%arg2, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_7, %22 : memref<2x5x5x4xf64>, memref) outs(%alloca_4 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %23 = polygeist.submap(%arg3, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_6, %23 : memref<2x5x5x4xf64>, memref) outs(%alloca_3 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %24 = polygeist.submap(%arg2, %c2, %c5, %c4, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_5, %24 : memref<2x5x5x4xf64>, memref) outs(%alloca_2 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %25 = polygeist.submap(%arg2, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_4, %25 : memref<2x5x4x4xf64>, memref) outs(%alloca_1 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %26 = polygeist.submap(%arg2, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_3, %26 : memref<2x5x4x4xf64>, memref) outs(%alloca_0 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %27 = polygeist.submap(%arg3, %c2, %c4, %c4, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_2, %27 : memref<2x5x4x4xf64>, memref) outs(%alloca : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_16: f64, %out: f64): + %29 = arith.mulf %in, %in_16 : f64 + %30 = arith.addf %out, %29 : f64 + linalg.yield %30 : f64 + } + %28 = polygeist.submap(%arg6, %c2, %c4, %c4, %c4) {map = #map19} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%alloca_1, %alloca_0, %alloca : memref<2x4x4x4xf64>, memref<2x4x4x4xf64>, memref<2x4x4x4xf64>) outs(%28 : memref) { + ^bb0(%in: f64, %in_16: f64, %in_17: f64, %out: f64): + %29 = arith.addf %in, %in_16 : f64 + %30 = arith.addf %29, %in_17 : f64 + %31 = arith.addf %out, %30 : f64 + linalg.yield %31 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/divdiv_apply_2d__original.frontend.mlir b/issues/mfem_c_kernels/results/divdiv_apply_2d__original.frontend.mlir new file mode 100644 index 000000000000..fe5d796f9a88 --- /dev/null +++ b/issues/mfem_c_kernels/results/divdiv_apply_2d__original.frontend.mlir @@ -0,0 +1,176 @@ +#set = affine_set<(d0) : (d0 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_divdiv_apply_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c24_i32 = arith.constant 24 : i32 + %c4_i32 = arith.constant 4 : i32 + %c3_i32 = arith.constant 3 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f64 + %c5_i32 = arith.constant 5 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<4xf64> + %alloca_0 = memref.alloca() : memref<5xf64> + %alloca_1 = memref.alloca() : memref<5x5xf64> + affine.for %arg7 = 0 to 2 { + %0 = arith.index_cast %arg7 : index to i32 + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.store %cst, %alloca_1[%arg8, %arg9] : memref<5x5xf64> + } + } + %1 = arith.muli %0, %c24_i32 : i32 + %2 = affine.for %arg8 = 0 to 2 iter_args(%arg9 = %c0_i32) -> (i32) { + %3 = arith.index_cast %arg8 : index to i32 + %4 = arith.cmpi eq, %3, %c1_i32 : i32 + %5 = arith.select %4, %c3_i32, %c4_i32 : i32 + %6 = arith.cmpi eq, %3, %c0_i32 : i32 + %7 = arith.select %6, %c3_i32, %c4_i32 : i32 + %8 = arith.index_cast %7 : i32 to index + %9 = arith.index_cast %5 : i32 to index + scf.for %arg10 = %c0 to %8 step %c1 { + %12 = arith.index_cast %arg10 : index to i32 + affine.for %arg11 = 0 to 5 { + affine.store %cst, %alloca_0[%arg11] : memref<5xf64> + } + %13 = arith.muli %12, %5 : i32 + scf.for %arg11 = %c0 to %9 step %c1 { + %14 = arith.index_cast %arg11 : index to i32 + %15 = arith.addi %14, %13 : i32 + %16 = arith.addi %15, %arg9 : i32 + %17 = arith.addi %16, %1 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = memref.load %arg5[%18] : memref + affine.for %arg12 = 0 to 5 { + %20 = arith.index_cast %arg12 : index to i32 + %21 = affine.if #set(%arg8) -> f64 { + %25 = arith.muli %20, %c4_i32 : i32 + %26 = arith.addi %25, %14 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = memref.load %arg2[%27] : memref + affine.yield %28 : f64 + } else { + %25 = arith.muli %20, %c3_i32 : i32 + %26 = arith.addi %25, %14 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = memref.load %arg0[%27] : memref + affine.yield %28 : f64 + } + %22 = arith.mulf %19, %21 : f64 + %23 = affine.load %alloca_0[%arg12] : memref<5xf64> + %24 = arith.addf %23, %22 : f64 + affine.store %24, %alloca_0[%arg12] : memref<5xf64> + } + } + affine.for %arg11 = 0 to 5 { + %14 = arith.index_cast %arg11 : index to i32 + %15 = affine.if #set(%arg8) -> f64 { + %16 = arith.muli %14, %c3_i32 : i32 + %17 = arith.addi %16, %12 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = memref.load %arg0[%18] : memref + affine.yield %19 : f64 + } else { + %16 = arith.muli %14, %c4_i32 : i32 + %17 = arith.addi %16, %12 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = memref.load %arg2[%18] : memref + affine.yield %19 : f64 + } + affine.for %arg12 = 0 to 5 { + %16 = affine.load %alloca_0[%arg12] : memref<5xf64> + %17 = arith.mulf %16, %15 : f64 + %18 = affine.load %alloca_1[%arg11, %arg12] : memref<5x5xf64> + %19 = arith.addf %18, %17 : f64 + affine.store %19, %alloca_1[%arg11, %arg12] : memref<5x5xf64> + } + } + } + %10 = arith.muli %5, %7 : i32 + %11 = arith.addi %arg9, %10 : i32 + affine.yield %11 : i32 + } + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %3 = affine.load %arg4[%arg9 + %arg7 * 25 + %arg8 * 5] : memref + %4 = affine.load %alloca_1[%arg8, %arg9] : memref<5x5xf64> + %5 = arith.mulf %4, %3 : f64 + affine.store %5, %alloca_1[%arg8, %arg9] : memref<5x5xf64> + } + } + affine.for %arg8 = 0 to 5 { + %3 = arith.index_cast %arg8 : index to i32 + %4 = affine.for %arg9 = 0 to 2 iter_args(%arg10 = %c0_i32) -> (i32) { + %5 = arith.index_cast %arg9 : index to i32 + %6 = arith.cmpi eq, %5, %c1_i32 : i32 + %7 = arith.select %6, %c3_i32, %c4_i32 : i32 + %8 = arith.cmpi eq, %5, %c0_i32 : i32 + %9 = arith.select %8, %c3_i32, %c4_i32 : i32 + %10 = arith.index_cast %7 : i32 to index + scf.for %arg11 = %c0 to %10 step %c1 { + memref.store %cst, %alloca[%arg11] : memref<4xf64> + } + affine.for %arg11 = 0 to 5 { + %14 = arith.index_cast %arg11 : index to i32 + %15 = affine.load %alloca_1[%arg8, %arg11] : memref<5x5xf64> + scf.for %arg12 = %c0 to %10 step %c1 { + %16 = arith.index_cast %arg12 : index to i32 + %17 = affine.if #set(%arg9) -> f64 { + %21 = arith.muli %16, %c5_i32 : i32 + %22 = arith.addi %21, %14 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = memref.load %arg3[%23] : memref + affine.yield %24 : f64 + } else { + %21 = arith.muli %16, %c5_i32 : i32 + %22 = arith.addi %21, %14 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = memref.load %arg1[%23] : memref + affine.yield %24 : f64 + } + %18 = arith.mulf %15, %17 : f64 + %19 = memref.load %alloca[%arg12] : memref<4xf64> + %20 = arith.addf %19, %18 : f64 + memref.store %20, %alloca[%arg12] : memref<4xf64> + } + } + %11 = arith.index_cast %9 : i32 to index + scf.for %arg11 = %c0 to %11 step %c1 { + %14 = arith.index_cast %arg11 : index to i32 + %15 = affine.if #set(%arg9) -> f64 { + %17 = arith.muli %14, %c5_i32 : i32 + %18 = arith.addi %17, %3 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg1[%19] : memref + affine.yield %20 : f64 + } else { + %17 = arith.muli %14, %c5_i32 : i32 + %18 = arith.addi %17, %3 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg3[%19] : memref + affine.yield %20 : f64 + } + %16 = arith.muli %14, %7 : i32 + scf.for %arg12 = %c0 to %10 step %c1 { + %17 = arith.index_cast %arg12 : index to i32 + %18 = arith.addi %17, %16 : i32 + %19 = arith.addi %18, %arg10 : i32 + %20 = arith.addi %19, %1 : i32 + %21 = arith.index_cast %20 : i32 to index + %22 = memref.load %alloca[%arg12] : memref<4xf64> + %23 = arith.mulf %22, %15 : f64 + %24 = memref.load %arg6[%21] : memref + %25 = arith.addf %24, %23 : f64 + memref.store %25, %arg6[%21] : memref + } + } + %12 = arith.muli %7, %9 : i32 + %13 = arith.addi %arg10, %12 : i32 + affine.yield %13 : i32 + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/divdiv_apply_2d__original.raised.mlir b/issues/mfem_c_kernels/results/divdiv_apply_2d__original.raised.mlir new file mode 100644 index 000000000000..14042b869710 --- /dev/null +++ b/issues/mfem_c_kernels/results/divdiv_apply_2d__original.raised.mlir @@ -0,0 +1,173 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 25 + d0 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_divdiv_apply_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c24_i32 = arith.constant 24 : i32 + %c4_i32 = arith.constant 4 : i32 + %c3_i32 = arith.constant 3 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f64 + %c5_i32 = arith.constant 5 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<4xf64> + %alloca_0 = memref.alloca() : memref<5xf64> + %alloca_1 = memref.alloca() : memref<5x5xf64> + affine.for %arg7 = 0 to 2 { + %0 = arith.index_cast %arg7 : index to i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%alloca_1 : memref<5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %1 = arith.muli %0, %c24_i32 : i32 + %alloca_2 = memref.alloca() : memref + affine.store %c0_i32, %alloca_2[] : memref + affine.for %arg8 = 0 to 2 { + %3 = affine.load %alloca_2[] : memref + %4 = arith.index_cast %arg8 : index to i32 + %5 = arith.cmpi eq, %4, %c1_i32 : i32 + %6 = arith.select %5, %c3_i32, %c4_i32 : i32 + %7 = arith.cmpi eq, %4, %c0_i32 : i32 + %8 = arith.select %7, %c3_i32, %c4_i32 : i32 + %9 = arith.index_cast %8 : i32 to index + %10 = arith.index_cast %6 : i32 to index + scf.for %arg9 = %c0 to %9 step %c1 { + %13 = arith.index_cast %arg9 : index to i32 + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel"]} outs(%alloca_0 : memref<5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = arith.muli %13, %6 : i32 + scf.for %arg10 = %c0 to %10 step %c1 { + %15 = arith.index_cast %arg10 : index to i32 + %16 = arith.addi %15, %14 : i32 + %17 = arith.addi %16, %3 : i32 + %18 = arith.addi %17, %1 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg5[%19] : memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel"]} outs(%alloca_0 : memref<5xf64>) { + ^bb0(%out: f64): + %21 = linalg.index 0 : index + %22 = arith.index_cast %21 : index to i32 + %23 = arith.cmpi eq, %arg8, %c0 : index + %24 = arith.muli %22, %c4_i32 : i32 + %25 = arith.addi %24, %15 : i32 + %26 = arith.index_cast %25 : i32 to index + %27 = memref.load %arg2[%26] : memref + %28 = arith.muli %22, %c3_i32 : i32 + %29 = arith.addi %28, %15 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = memref.load %arg0[%30] : memref + %32 = arith.select %23, %27, %31 : f64 + %33 = arith.mulf %20, %32 : f64 + %34 = arith.addf %out, %33 : f64 + linalg.yield %34 : f64 + } + } + affine.for %arg10 = 0 to 5 { + %15 = arith.index_cast %arg10 : index to i32 + %16 = arith.cmpi eq, %arg8, %c0 : index + %17 = arith.muli %15, %c3_i32 : i32 + %18 = arith.addi %17, %13 : i32 + %19 = arith.index_cast %18 : i32 to index + %20 = memref.load %arg0[%19] : memref + %21 = arith.muli %15, %c4_i32 : i32 + %22 = arith.addi %21, %13 : i32 + %23 = arith.index_cast %22 : i32 to index + %24 = memref.load %arg2[%23] : memref + %25 = arith.select %16, %20, %24 : f64 + %subview = memref.subview %alloca_0[0] [%c5] [1] : memref<5xf64> to memref> + %subview_3 = memref.subview %alloca_1[%arg10, 0] [1, %c5] [1, 1] : memref<5x5xf64> to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_3 : memref>) { + ^bb0(%in: f64, %out: f64): + %26 = arith.mulf %in, %25 : f64 + %27 = arith.addf %out, %26 : f64 + linalg.yield %27 : f64 + } + } + } + %11 = arith.muli %6, %8 : i32 + %12 = arith.addi %3, %11 : i32 + affine.store %12, %alloca_2[] : memref + } + %2 = polygeist.submap(%arg4, %arg7, %c5, %c5) {map = #map2} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%2 : memref) outs(%alloca_1 : memref<5x5xf64>) { + ^bb0(%in: f64, %out: f64): + %3 = arith.mulf %out, %in : f64 + linalg.yield %3 : f64 + } + affine.for %arg8 = 0 to 5 { + %3 = arith.index_cast %arg8 : index to i32 + %alloca_3 = memref.alloca() : memref + affine.store %c0_i32, %alloca_3[] : memref + affine.for %arg9 = 0 to 2 { + %4 = affine.load %alloca_3[] : memref + %5 = arith.index_cast %arg9 : index to i32 + %6 = arith.cmpi eq, %5, %c1_i32 : i32 + %7 = arith.select %6, %c3_i32, %c4_i32 : i32 + %8 = arith.cmpi eq, %5, %c0_i32 : i32 + %9 = arith.select %8, %c3_i32, %c4_i32 : i32 + %10 = arith.index_cast %7 : i32 to index + scf.for %arg10 = %c0 to %10 step %c1 { + memref.store %cst, %alloca[%arg10] : memref<4xf64> + } + affine.for %arg10 = 0 to 5 { + %14 = arith.index_cast %arg10 : index to i32 + %15 = affine.load %alloca_1[%arg8, %arg10] : memref<5x5xf64> + scf.for %arg11 = %c0 to %10 step %c1 { + %16 = arith.index_cast %arg11 : index to i32 + %17 = arith.cmpi eq, %arg9, %c0 : index + %18 = arith.muli %16, %c5_i32 : i32 + %19 = arith.addi %18, %14 : i32 + %20 = arith.index_cast %19 : i32 to index + %21 = memref.load %arg3[%20] : memref + %22 = arith.muli %16, %c5_i32 : i32 + %23 = arith.addi %22, %14 : i32 + %24 = arith.index_cast %23 : i32 to index + %25 = memref.load %arg1[%24] : memref + %26 = arith.select %17, %21, %25 : f64 + %27 = arith.mulf %15, %26 : f64 + %28 = memref.load %alloca[%arg11] : memref<4xf64> + %29 = arith.addf %28, %27 : f64 + memref.store %29, %alloca[%arg11] : memref<4xf64> + } + } + %11 = arith.index_cast %9 : i32 to index + scf.for %arg10 = %c0 to %11 step %c1 { + %14 = arith.index_cast %arg10 : index to i32 + %15 = arith.cmpi eq, %arg9, %c0 : index + %16 = arith.muli %14, %c5_i32 : i32 + %17 = arith.addi %16, %3 : i32 + %18 = arith.index_cast %17 : i32 to index + %19 = memref.load %arg1[%18] : memref + %20 = arith.muli %14, %c5_i32 : i32 + %21 = arith.addi %20, %3 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = memref.load %arg3[%22] : memref + %24 = arith.select %15, %19, %23 : f64 + %25 = arith.muli %14, %7 : i32 + scf.for %arg11 = %c0 to %10 step %c1 { + %26 = arith.index_cast %arg11 : index to i32 + %27 = arith.addi %26, %25 : i32 + %28 = arith.addi %27, %4 : i32 + %29 = arith.addi %28, %1 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = memref.load %alloca[%arg11] : memref<4xf64> + %32 = arith.mulf %31, %24 : f64 + %33 = memref.load %arg6[%30] : memref + %34 = arith.addf %33, %32 : f64 + memref.store %34, %arg6[%30] : memref + } + } + %12 = arith.muli %7, %9 : i32 + %13 = arith.addi %4, %12 : i32 + affine.store %13, %alloca_3[] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/divdiv_apply_2d_stage_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/divdiv_apply_2d_stage_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..3fe578ca0007 --- /dev/null +++ b/issues/mfem_c_kernels/results/divdiv_apply_2d_stage_sliced__normalized.frontend.mlir @@ -0,0 +1,154 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_divdiv_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x3xf64> + %alloca_0 = memref.alloca() : memref<2x3x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x3xf64> + %alloca_2 = memref.alloca() : memref<2x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5xf64> + %alloca_4 = memref.alloca() : memref<2x5x5xf64> + %alloca_5 = memref.alloca() : memref<2x4x5xf64> + %alloca_6 = memref.alloca() : memref<2x3x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg10 + %arg8 * 4 + %arg7 * 24] : memref + %2 = affine.load %arg2[%arg10 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9] : memref<2x3x5xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 3 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg7, %arg10, %arg9] : memref<2x3x5xf64> + %2 = affine.load %arg0[%arg10 + %arg8 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9] : memref<2x5x5xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 3 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg10 + %arg8 * 3 + %arg7 * 24 + 12] : memref + %2 = affine.load %arg0[%arg10 + %arg9 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9] : memref<2x4x5xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %0 = affine.for %arg10 = 0 to 4 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg7, %arg10, %arg9] : memref<2x4x5xf64> + %2 = affine.load %arg2[%arg10 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9] : memref<2x5x5xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg10 + %arg7 * 25 + %arg8 * 5] : memref + %2 = affine.load %alloca_4[%arg7, %arg8, %arg10] : memref<2x5x5xf64> + %3 = affine.load %alloca_3[%arg7, %arg8, %arg10] : memref<2x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg3[%arg10 + %arg9 * 5] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.addf %arg11, %7 : f64 + affine.yield %8 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9] : memref<2x5x4xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg10, %arg9] : memref<2x5x4xf64> + %2 = affine.load %arg1[%arg10 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9] : memref<2x3x4xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 3 { + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg10 + %arg7 * 25 + %arg8 * 5] : memref + %2 = affine.load %alloca_4[%arg7, %arg8, %arg10] : memref<2x5x5xf64> + %3 = affine.load %alloca_3[%arg7, %arg8, %arg10] : memref<2x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = arith.mulf %1, %4 : f64 + %6 = affine.load %arg1[%arg10 + %arg9 * 5] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.addf %arg11, %7 : f64 + affine.yield %8 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9] : memref<2x5x3xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + %0 = affine.for %arg10 = 0 to 5 iter_args(%arg11 = %cst) -> (f64) { + %1 = affine.load %alloca_1[%arg7, %arg10, %arg9] : memref<2x5x3xf64> + %2 = affine.load %arg3[%arg10 + %arg8 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9] : memref<2x4x3xf64> + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + %0 = affine.load %alloca_0[%arg7, %arg8, %arg9] : memref<2x3x4xf64> + %1 = affine.load %arg6[%arg9 + %arg8 * 4 + %arg7 * 24] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg9 + %arg8 * 4 + %arg7 * 24] : memref + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + %0 = affine.load %alloca[%arg7, %arg8, %arg9] : memref<2x4x3xf64> + %1 = affine.load %arg6[%arg9 + %arg8 * 3 + %arg7 * 24 + 12] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg9 + %arg8 * 3 + %arg7 * 24 + 12] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/divdiv_apply_2d_stage_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/divdiv_apply_2d_stage_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..fbb091fbd0e0 --- /dev/null +++ b/issues/mfem_c_kernels/results/divdiv_apply_2d_stage_sliced__normalized.raised.mlir @@ -0,0 +1,142 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4 + d0 * 24)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 3)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 3 + d0 * 24 + 12)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 3)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 25 + d1 * 5)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map12 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map13 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map14 = affine_map<(d0, d1, d2) -> (d2 + d1 * 4 + d0 * 24)> +#map15 = affine_map<(d0, d1, d2) -> (d2 + d1 * 3 + d0 * 24 + 12)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_divdiv_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x3xf64> + %alloca_0 = memref.alloca() : memref<2x3x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x3xf64> + %alloca_2 = memref.alloca() : memref<2x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5xf64> + %alloca_4 = memref.alloca() : memref<2x5x5xf64> + %alloca_5 = memref.alloca() : memref<2x4x5xf64> + %alloca_6 = memref.alloca() : memref<2x3x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_6 : memref<2x3x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg5, %c2, %c3, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg2, %c2, %c3, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_6 : memref<2x3x5xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %14 = arith.mulf %in, %in_7 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_4 : memref<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg0, %c2, %c5, %c5, %c3) {map = #map5} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_6, %2 : memref<2x3x5xf64>, memref) outs(%alloca_4 : memref<2x5x5xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %14 = arith.mulf %in, %in_7 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_5 : memref<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %3 = polygeist.submap(%arg5, %c2, %c4, %c5, %c3) {map = #map7} : (memref, index, index, index, index) -> memref + %4 = polygeist.submap(%arg0, %c2, %c4, %c5, %c3) {map = #map8} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%3, %4 : memref, memref) outs(%alloca_5 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %14 = arith.mulf %in, %in_7 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %5 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4) {map = #map9} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_5, %5 : memref<2x4x5xf64>, memref) outs(%alloca_3 : memref<2x5x5xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %14 = arith.mulf %in, %in_7 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg4, %c2, %c5, %c4, %c5) {map = #map10} : (memref, index, index, index, index) -> memref + %7 = polygeist.submap(%arg3, %c2, %c5, %c4, %c5) {map = #map11} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map12, #map12, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%6, %alloca_4, %alloca_3, %7 : memref, memref<2x5x5xf64>, memref<2x5x5xf64>, memref) outs(%alloca_2 : memref<2x5x4xf64>) { + ^bb0(%in: f64, %in_7: f64, %in_8: f64, %in_9: f64, %out: f64): + %14 = arith.addf %in_7, %in_8 : f64 + %15 = arith.mulf %in, %14 : f64 + %16 = arith.mulf %15, %in_9 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x3x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg1, %c2, %c3, %c4, %c5) {map = #map13} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_2, %8 : memref<2x5x4xf64>, memref) outs(%alloca_0 : memref<2x3x4xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %14 = arith.mulf %in, %in_7 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x5x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %9 = polygeist.submap(%arg4, %c2, %c5, %c3, %c5) {map = #map10} : (memref, index, index, index, index) -> memref + %10 = polygeist.submap(%arg1, %c2, %c5, %c3, %c5) {map = #map11} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map12, #map12, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%9, %alloca_4, %alloca_3, %10 : memref, memref<2x5x5xf64>, memref<2x5x5xf64>, memref) outs(%alloca_1 : memref<2x5x3xf64>) { + ^bb0(%in: f64, %in_7: f64, %in_8: f64, %in_9: f64, %out: f64): + %14 = arith.addf %in_7, %in_8 : f64 + %15 = arith.mulf %in, %14 : f64 + %16 = arith.mulf %15, %in_9 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca : memref<2x4x3xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %11 = polygeist.submap(%arg3, %c2, %c4, %c3, %c5) {map = #map13} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_1, %11 : memref<2x5x3xf64>, memref) outs(%alloca : memref<2x4x3xf64>) { + ^bb0(%in: f64, %in_7: f64, %out: f64): + %14 = arith.mulf %in, %in_7 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 + } + %12 = polygeist.submap(%arg6, %c2, %c3, %c4) {map = #map14} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%alloca_0 : memref<2x3x4xf64>) outs(%12 : memref) { + ^bb0(%in: f64, %out: f64): + %14 = arith.addf %out, %in : f64 + linalg.yield %14 : f64 + } + %13 = polygeist.submap(%arg6, %c2, %c4, %c3) {map = #map15} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%alloca : memref<2x4x3xf64>) outs(%13 : memref) { + ^bb0(%in: f64, %out: f64): + %14 = arith.addf %out, %in : f64 + linalg.yield %14 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/divdiv_apply_3d__original.frontend.mlir b/issues/mfem_c_kernels/results/divdiv_apply_3d__original.frontend.mlir new file mode 100644 index 000000000000..46b5aa492444 --- /dev/null +++ b/issues/mfem_c_kernels/results/divdiv_apply_3d__original.frontend.mlir @@ -0,0 +1,264 @@ +#set = affine_set<(d0) : (d0 == 0)> +#set1 = affine_set<(d0) : (d0 - 1 == 0)> +#set2 = affine_set<(d0) : (d0 - 2 == 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_divdiv_apply_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c108_i32 = arith.constant 108 : i32 + %c4_i32 = arith.constant 4 : i32 + %c3_i32 = arith.constant 3 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f64 + %c5_i32 = arith.constant 5 : i32 + %c2_i32 = arith.constant 2 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<4xf64> + %alloca_0 = memref.alloca() : memref<4x4xf64> + %alloca_1 = memref.alloca() : memref<5xf64> + %alloca_2 = memref.alloca() : memref<5x5xf64> + %alloca_3 = memref.alloca() : memref<5x5x5xf64> + affine.for %arg7 = 0 to 2 { + %0 = arith.index_cast %arg7 : index to i32 + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + affine.store %cst, %alloca_3[%arg8, %arg9, %arg10] : memref<5x5x5xf64> + } + } + } + %1 = arith.muli %0, %c108_i32 : i32 + %2 = affine.for %arg8 = 0 to 3 iter_args(%arg9 = %c0_i32) -> (i32) { + %3 = arith.index_cast %arg8 : index to i32 + %4 = arith.cmpi eq, %3, %c2_i32 : i32 + %5 = arith.select %4, %c4_i32, %c3_i32 : i32 + %6 = arith.cmpi eq, %3, %c1_i32 : i32 + %7 = arith.select %6, %c4_i32, %c3_i32 : i32 + %8 = arith.cmpi eq, %3, %c0_i32 : i32 + %9 = arith.select %8, %c4_i32, %c3_i32 : i32 + %10 = arith.index_cast %5 : i32 to index + %11 = arith.index_cast %7 : i32 to index + %12 = arith.index_cast %9 : i32 to index + scf.for %arg10 = %c0 to %10 step %c1 { + %16 = arith.index_cast %arg10 : index to i32 + affine.for %arg11 = 0 to 5 { + affine.for %arg12 = 0 to 5 { + affine.store %cst, %alloca_2[%arg11, %arg12] : memref<5x5xf64> + } + } + %17 = arith.muli %16, %7 : i32 + scf.for %arg11 = %c0 to %11 step %c1 { + %18 = arith.index_cast %arg11 : index to i32 + affine.for %arg12 = 0 to 5 { + affine.store %cst, %alloca_1[%arg12] : memref<5xf64> + } + %19 = arith.addi %18, %17 : i32 + %20 = arith.muli %19, %9 : i32 + scf.for %arg12 = %c0 to %12 step %c1 { + %21 = arith.index_cast %arg12 : index to i32 + %22 = arith.addi %21, %20 : i32 + %23 = arith.addi %22, %arg9 : i32 + %24 = arith.addi %23, %1 : i32 + %25 = arith.index_cast %24 : i32 to index + %26 = memref.load %arg5[%25] : memref + affine.for %arg13 = 0 to 5 { + %27 = arith.index_cast %arg13 : index to i32 + %28 = affine.if #set(%arg8) -> f64 { + %32 = arith.muli %27, %c4_i32 : i32 + %33 = arith.addi %32, %21 : i32 + %34 = arith.index_cast %33 : i32 to index + %35 = memref.load %arg2[%34] : memref + affine.yield %35 : f64 + } else { + %32 = arith.muli %27, %c3_i32 : i32 + %33 = arith.addi %32, %21 : i32 + %34 = arith.index_cast %33 : i32 to index + %35 = memref.load %arg0[%34] : memref + affine.yield %35 : f64 + } + %29 = arith.mulf %26, %28 : f64 + %30 = affine.load %alloca_1[%arg13] : memref<5xf64> + %31 = arith.addf %30, %29 : f64 + affine.store %31, %alloca_1[%arg13] : memref<5xf64> + } + } + affine.for %arg12 = 0 to 5 { + %21 = arith.index_cast %arg12 : index to i32 + %22 = affine.if #set1(%arg8) -> f64 { + %23 = arith.muli %21, %c4_i32 : i32 + %24 = arith.addi %23, %18 : i32 + %25 = arith.index_cast %24 : i32 to index + %26 = memref.load %arg2[%25] : memref + affine.yield %26 : f64 + } else { + %23 = arith.muli %21, %c3_i32 : i32 + %24 = arith.addi %23, %18 : i32 + %25 = arith.index_cast %24 : i32 to index + %26 = memref.load %arg0[%25] : memref + affine.yield %26 : f64 + } + affine.for %arg13 = 0 to 5 { + %23 = affine.load %alloca_1[%arg13] : memref<5xf64> + %24 = arith.mulf %23, %22 : f64 + %25 = affine.load %alloca_2[%arg12, %arg13] : memref<5x5xf64> + %26 = arith.addf %25, %24 : f64 + affine.store %26, %alloca_2[%arg12, %arg13] : memref<5x5xf64> + } + } + } + affine.for %arg11 = 0 to 5 { + %18 = arith.index_cast %arg11 : index to i32 + %19 = arith.muli %18, %c4_i32 : i32 + %20 = arith.addi %19, %16 : i32 + %21 = arith.index_cast %20 : i32 to index + %22 = arith.muli %18, %c3_i32 : i32 + %23 = arith.addi %22, %16 : i32 + %24 = arith.index_cast %23 : i32 to index + %25 = affine.if #set2(%arg8) -> f64 { + %26 = memref.load %arg2[%21] : memref + affine.yield %26 : f64 + } else { + %26 = memref.load %arg0[%24] : memref + affine.yield %26 : f64 + } + affine.for %arg12 = 0 to 5 { + affine.for %arg13 = 0 to 5 { + %26 = affine.load %alloca_2[%arg12, %arg13] : memref<5x5xf64> + %27 = arith.mulf %26, %25 : f64 + %28 = affine.load %alloca_3[%arg11, %arg12, %arg13] : memref<5x5x5xf64> + %29 = arith.addf %28, %27 : f64 + affine.store %29, %alloca_3[%arg11, %arg12, %arg13] : memref<5x5x5xf64> + } + } + } + } + %13 = arith.muli %9, %7 : i32 + %14 = arith.muli %13, %5 : i32 + %15 = arith.addi %arg9, %14 : i32 + affine.yield %15 : i32 + } + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %3 = affine.load %arg4[%arg7 * 125 + %arg10 + %arg8 * 25 + %arg9 * 5] : memref + %4 = affine.load %alloca_3[%arg8, %arg9, %arg10] : memref<5x5x5xf64> + %5 = arith.mulf %4, %3 : f64 + affine.store %5, %alloca_3[%arg8, %arg9, %arg10] : memref<5x5x5xf64> + } + } + } + affine.for %arg8 = 0 to 5 { + %3 = arith.index_cast %arg8 : index to i32 + %4 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %c0_i32) -> (i32) { + %5 = arith.index_cast %arg9 : index to i32 + %6 = arith.cmpi eq, %5, %c2_i32 : i32 + %7 = arith.select %6, %c4_i32, %c3_i32 : i32 + %8 = arith.cmpi eq, %5, %c1_i32 : i32 + %9 = arith.select %8, %c4_i32, %c3_i32 : i32 + %10 = arith.cmpi eq, %5, %c0_i32 : i32 + %11 = arith.select %10, %c4_i32, %c3_i32 : i32 + %12 = arith.index_cast %9 : i32 to index + %13 = arith.index_cast %11 : i32 to index + scf.for %arg11 = %c0 to %12 step %c1 { + scf.for %arg12 = %c0 to %13 step %c1 { + memref.store %cst, %alloca_0[%arg11, %arg12] : memref<4x4xf64> + } + } + %14 = arith.cmpi sgt, %13, %c0 : index + affine.for %arg11 = 0 to 5 { + %19 = arith.index_cast %arg11 : index to i32 + scf.for %arg12 = %c0 to %13 step %c1 { + memref.store %cst, %alloca[%arg12] : memref<4xf64> + } + affine.for %arg12 = 0 to 5 { + %20 = arith.index_cast %arg12 : index to i32 + %21 = affine.load %alloca_3[%arg8, %arg11, %arg12] : memref<5x5x5xf64> + scf.for %arg13 = %c0 to %13 step %c1 { + %22 = arith.index_cast %arg13 : index to i32 + %23 = affine.if #set(%arg9) -> f64 { + %27 = arith.muli %22, %c5_i32 : i32 + %28 = arith.addi %27, %20 : i32 + %29 = arith.index_cast %28 : i32 to index + %30 = memref.load %arg3[%29] : memref + affine.yield %30 : f64 + } else { + %27 = arith.muli %22, %c5_i32 : i32 + %28 = arith.addi %27, %20 : i32 + %29 = arith.index_cast %28 : i32 to index + %30 = memref.load %arg1[%29] : memref + affine.yield %30 : f64 + } + %24 = arith.mulf %21, %23 : f64 + %25 = memref.load %alloca[%arg13] : memref<4xf64> + %26 = arith.addf %25, %24 : f64 + memref.store %26, %alloca[%arg13] : memref<4xf64> + } + } + scf.for %arg12 = %c0 to %12 step %c1 { + scf.if %14 { + %20 = arith.index_cast %arg12 : index to i32 + %21 = affine.if #set1(%arg9) -> f64 { + %22 = arith.muli %20, %c5_i32 : i32 + %23 = arith.addi %22, %19 : i32 + %24 = arith.index_cast %23 : i32 to index + %25 = memref.load %arg3[%24] : memref + affine.yield %25 : f64 + } else { + %22 = arith.muli %20, %c5_i32 : i32 + %23 = arith.addi %22, %19 : i32 + %24 = arith.index_cast %23 : i32 to index + %25 = memref.load %arg1[%24] : memref + affine.yield %25 : f64 + } + scf.for %arg13 = %c0 to %13 step %c1 { + %22 = memref.load %alloca[%arg13] : memref<4xf64> + %23 = arith.mulf %22, %21 : f64 + %24 = memref.load %alloca_0[%arg12, %arg13] : memref<4x4xf64> + %25 = arith.addf %24, %23 : f64 + memref.store %25, %alloca_0[%arg12, %arg13] : memref<4x4xf64> + } + } + } + } + %15 = arith.index_cast %7 : i32 to index + scf.for %arg11 = %c0 to %15 step %c1 { + %19 = arith.index_cast %arg11 : index to i32 + %20 = arith.muli %19, %9 : i32 + %21 = arith.muli %19, %c5_i32 : i32 + %22 = arith.addi %21, %3 : i32 + %23 = arith.index_cast %22 : i32 to index + scf.for %arg12 = %c0 to %12 step %c1 { + %24 = arith.index_cast %arg12 : index to i32 + %25 = arith.addi %24, %20 : i32 + %26 = arith.muli %25, %11 : i32 + scf.for %arg13 = %c0 to %13 step %c1 { + %27 = arith.index_cast %arg13 : index to i32 + %28 = arith.addi %27, %26 : i32 + %29 = arith.addi %28, %arg10 : i32 + %30 = arith.addi %29, %1 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %alloca_0[%arg12, %arg13] : memref<4x4xf64> + %33 = affine.if #set2(%arg9) -> f64 { + %37 = memref.load %arg3[%23] : memref + affine.yield %37 : f64 + } else { + %37 = memref.load %arg1[%23] : memref + affine.yield %37 : f64 + } + %34 = arith.mulf %32, %33 : f64 + %35 = memref.load %arg6[%31] : memref + %36 = arith.addf %35, %34 : f64 + memref.store %36, %arg6[%31] : memref + } + } + } + %16 = arith.muli %11, %9 : i32 + %17 = arith.muli %16, %7 : i32 + %18 = arith.addi %arg10, %17 : i32 + affine.yield %18 : i32 + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/divdiv_apply_3d__original.raised.mlir b/issues/mfem_c_kernels/results/divdiv_apply_3d__original.raised.mlir new file mode 100644 index 000000000000..551c834f1ef5 --- /dev/null +++ b/issues/mfem_c_kernels/results/divdiv_apply_3d__original.raised.mlir @@ -0,0 +1,254 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0) -> (d0)> +#map3 = affine_map<(d0) -> (d0 - 1)> +#map4 = affine_map<(d0) -> (d0 - 2)> +#map5 = affine_map<(d0, d1, d2)[s0] -> (d2 + s0 * 125 + d0 * 25 + d1 * 5)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_divdiv_apply_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %c0 = arith.constant 0 : index + %c1 = arith.constant 1 : index + %c108_i32 = arith.constant 108 : i32 + %c4_i32 = arith.constant 4 : i32 + %c3_i32 = arith.constant 3 : i32 + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f64 + %c5_i32 = arith.constant 5 : i32 + %c2_i32 = arith.constant 2 : i32 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<4xf64> + %alloca_0 = memref.alloca() : memref<4x4xf64> + %alloca_1 = memref.alloca() : memref<5xf64> + %alloca_2 = memref.alloca() : memref<5x5xf64> + %alloca_3 = memref.alloca() : memref<5x5x5xf64> + affine.for %arg7 = 0 to 2 { + %0 = arith.index_cast %arg7 : index to i32 + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %1 = arith.muli %0, %c108_i32 : i32 + %alloca_4 = memref.alloca() : memref + affine.store %c0_i32, %alloca_4[] : memref + affine.for %arg8 = 0 to 3 { + %3 = affine.load %alloca_4[] : memref + %4 = arith.index_cast %arg8 : index to i32 + %5 = arith.cmpi eq, %4, %c2_i32 : i32 + %6 = arith.select %5, %c4_i32, %c3_i32 : i32 + %7 = arith.cmpi eq, %4, %c1_i32 : i32 + %8 = arith.select %7, %c4_i32, %c3_i32 : i32 + %9 = arith.cmpi eq, %4, %c0_i32 : i32 + %10 = arith.select %9, %c4_i32, %c3_i32 : i32 + %11 = arith.index_cast %6 : i32 to index + %12 = arith.index_cast %8 : i32 to index + %13 = arith.index_cast %10 : i32 to index + scf.for %arg9 = %c0 to %11 step %c1 { + %17 = arith.index_cast %arg9 : index to i32 + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%alloca_2 : memref<5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %18 = arith.muli %17, %8 : i32 + scf.for %arg10 = %c0 to %12 step %c1 { + %19 = arith.index_cast %arg10 : index to i32 + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel"]} outs(%alloca_1 : memref<5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %20 = arith.addi %19, %18 : i32 + %21 = arith.muli %20, %10 : i32 + scf.for %arg11 = %c0 to %13 step %c1 { + %22 = arith.index_cast %arg11 : index to i32 + %23 = arith.addi %22, %21 : i32 + %24 = arith.addi %23, %3 : i32 + %25 = arith.addi %24, %1 : i32 + %26 = arith.index_cast %25 : i32 to index + %27 = memref.load %arg5[%26] : memref + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel"]} outs(%alloca_1 : memref<5xf64>) { + ^bb0(%out: f64): + %28 = linalg.index 0 : index + %29 = arith.index_cast %28 : index to i32 + %30 = arith.cmpi eq, %arg8, %c0 : index + %31 = arith.muli %29, %c4_i32 : i32 + %32 = arith.addi %31, %22 : i32 + %33 = arith.index_cast %32 : i32 to index + %34 = memref.load %arg2[%33] : memref + %35 = arith.muli %29, %c3_i32 : i32 + %36 = arith.addi %35, %22 : i32 + %37 = arith.index_cast %36 : i32 to index + %38 = memref.load %arg0[%37] : memref + %39 = arith.select %30, %34, %38 : f64 + %40 = arith.mulf %27, %39 : f64 + %41 = arith.addf %out, %40 : f64 + linalg.yield %41 : f64 + } + } + affine.for %arg11 = 0 to 5 { + %22 = arith.index_cast %arg11 : index to i32 + %23 = affine.apply #map3(%arg8) + %24 = arith.cmpi eq, %23, %c0 : index + %25 = arith.muli %22, %c4_i32 : i32 + %26 = arith.addi %25, %19 : i32 + %27 = arith.index_cast %26 : i32 to index + %28 = memref.load %arg2[%27] : memref + %29 = arith.muli %22, %c3_i32 : i32 + %30 = arith.addi %29, %19 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %arg0[%31] : memref + %33 = arith.select %24, %28, %32 : f64 + %subview = memref.subview %alloca_1[0] [%c5] [1] : memref<5xf64> to memref> + %subview_5 = memref.subview %alloca_2[%arg11, 0] [1, %c5] [1, 1] : memref<5x5xf64> to memref> + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%subview : memref>) outs(%subview_5 : memref>) { + ^bb0(%in: f64, %out: f64): + %34 = arith.mulf %in, %33 : f64 + %35 = arith.addf %out, %34 : f64 + linalg.yield %35 : f64 + } + } + } + affine.for %arg10 = 0 to 5 { + %19 = arith.index_cast %arg10 : index to i32 + %20 = arith.muli %19, %c4_i32 : i32 + %21 = arith.addi %20, %17 : i32 + %22 = arith.index_cast %21 : i32 to index + %23 = arith.muli %19, %c3_i32 : i32 + %24 = arith.addi %23, %17 : i32 + %25 = arith.index_cast %24 : i32 to index + %26 = affine.apply #map4(%arg8) + %27 = arith.cmpi eq, %26, %c0 : index + %28 = memref.load %arg2[%22] : memref + %29 = memref.load %arg0[%25] : memref + %30 = arith.select %27, %28, %29 : f64 + %subview = memref.subview %alloca_2[0, 0] [%c5, %c5] [1, 1] : memref<5x5xf64> to memref> + %subview_5 = memref.subview %alloca_3[%arg10, 0, 0] [1, %c5, %c5] [1, 1, 1] : memref<5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%subview : memref>) outs(%subview_5 : memref>) { + ^bb0(%in: f64, %out: f64): + %31 = arith.mulf %in, %30 : f64 + %32 = arith.addf %out, %31 : f64 + linalg.yield %32 : f64 + } + } + } + %14 = arith.muli %10, %8 : i32 + %15 = arith.muli %14, %6 : i32 + %16 = arith.addi %3, %15 : i32 + affine.store %16, %alloca_4[] : memref + } + %2 = polygeist.submap(%arg4, %arg7, %c5, %c5, %c5) {map = #map5} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2 : memref) outs(%alloca_3 : memref<5x5x5xf64>) { + ^bb0(%in: f64, %out: f64): + %3 = arith.mulf %out, %in : f64 + linalg.yield %3 : f64 + } + affine.for %arg8 = 0 to 5 { + %3 = arith.index_cast %arg8 : index to i32 + %alloca_5 = memref.alloca() : memref + affine.store %c0_i32, %alloca_5[] : memref + affine.for %arg9 = 0 to 3 { + %4 = affine.load %alloca_5[] : memref + %5 = arith.index_cast %arg9 : index to i32 + %6 = arith.cmpi eq, %5, %c2_i32 : i32 + %7 = arith.select %6, %c4_i32, %c3_i32 : i32 + %8 = arith.cmpi eq, %5, %c1_i32 : i32 + %9 = arith.select %8, %c4_i32, %c3_i32 : i32 + %10 = arith.cmpi eq, %5, %c0_i32 : i32 + %11 = arith.select %10, %c4_i32, %c3_i32 : i32 + %12 = arith.index_cast %9 : i32 to index + %13 = arith.index_cast %11 : i32 to index + scf.for %arg10 = %c0 to %12 step %c1 { + scf.for %arg11 = %c0 to %13 step %c1 { + memref.store %cst, %alloca_0[%arg10, %arg11] : memref<4x4xf64> + } + } + %14 = arith.cmpi sgt, %13, %c0 : index + affine.for %arg10 = 0 to 5 { + %19 = arith.index_cast %arg10 : index to i32 + scf.for %arg11 = %c0 to %13 step %c1 { + memref.store %cst, %alloca[%arg11] : memref<4xf64> + } + affine.for %arg11 = 0 to 5 { + %20 = arith.index_cast %arg11 : index to i32 + %21 = affine.load %alloca_3[%arg8, %arg10, %arg11] : memref<5x5x5xf64> + scf.for %arg12 = %c0 to %13 step %c1 { + %22 = arith.index_cast %arg12 : index to i32 + %23 = arith.cmpi eq, %arg9, %c0 : index + %24 = arith.muli %22, %c5_i32 : i32 + %25 = arith.addi %24, %20 : i32 + %26 = arith.index_cast %25 : i32 to index + %27 = memref.load %arg3[%26] : memref + %28 = arith.muli %22, %c5_i32 : i32 + %29 = arith.addi %28, %20 : i32 + %30 = arith.index_cast %29 : i32 to index + %31 = memref.load %arg1[%30] : memref + %32 = arith.select %23, %27, %31 : f64 + %33 = arith.mulf %21, %32 : f64 + %34 = memref.load %alloca[%arg12] : memref<4xf64> + %35 = arith.addf %34, %33 : f64 + memref.store %35, %alloca[%arg12] : memref<4xf64> + } + } + scf.for %arg11 = %c0 to %12 step %c1 { + scf.if %14 { + %20 = arith.index_cast %arg11 : index to i32 + %21 = affine.apply #map3(%arg9) + %22 = arith.cmpi eq, %21, %c0 : index + %23 = arith.muli %20, %c5_i32 : i32 + %24 = arith.addi %23, %19 : i32 + %25 = arith.index_cast %24 : i32 to index + %26 = memref.load %arg3[%25] : memref + %27 = arith.muli %20, %c5_i32 : i32 + %28 = arith.addi %27, %19 : i32 + %29 = arith.index_cast %28 : i32 to index + %30 = memref.load %arg1[%29] : memref + %31 = arith.select %22, %26, %30 : f64 + scf.for %arg12 = %c0 to %13 step %c1 { + %32 = memref.load %alloca[%arg12] : memref<4xf64> + %33 = arith.mulf %32, %31 : f64 + %34 = memref.load %alloca_0[%arg11, %arg12] : memref<4x4xf64> + %35 = arith.addf %34, %33 : f64 + memref.store %35, %alloca_0[%arg11, %arg12] : memref<4x4xf64> + } + } + } + } + %15 = arith.index_cast %7 : i32 to index + scf.for %arg10 = %c0 to %15 step %c1 { + %19 = arith.index_cast %arg10 : index to i32 + %20 = arith.muli %19, %9 : i32 + %21 = arith.muli %19, %c5_i32 : i32 + %22 = arith.addi %21, %3 : i32 + %23 = arith.index_cast %22 : i32 to index + scf.for %arg11 = %c0 to %12 step %c1 { + %24 = arith.index_cast %arg11 : index to i32 + %25 = arith.addi %24, %20 : i32 + %26 = arith.muli %25, %11 : i32 + scf.for %arg12 = %c0 to %13 step %c1 { + %27 = arith.index_cast %arg12 : index to i32 + %28 = arith.addi %27, %26 : i32 + %29 = arith.addi %28, %4 : i32 + %30 = arith.addi %29, %1 : i32 + %31 = arith.index_cast %30 : i32 to index + %32 = memref.load %alloca_0[%arg11, %arg12] : memref<4x4xf64> + %33 = affine.apply #map4(%arg9) + %34 = arith.cmpi eq, %33, %c0 : index + %35 = memref.load %arg3[%23] : memref + %36 = memref.load %arg1[%23] : memref + %37 = arith.select %34, %35, %36 : f64 + %38 = arith.mulf %32, %37 : f64 + %39 = memref.load %arg6[%31] : memref + %40 = arith.addf %39, %38 : f64 + memref.store %40, %arg6[%31] : memref + } + } + } + %16 = arith.muli %11, %9 : i32 + %17 = arith.muli %16, %7 : i32 + %18 = arith.addi %4, %17 : i32 + affine.store %18, %alloca_5[] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/divdiv_apply_3d_stage_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/divdiv_apply_3d_stage_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..8531eb6b9ce7 --- /dev/null +++ b/issues/mfem_c_kernels/results/divdiv_apply_3d_stage_sliced__normalized.frontend.mlir @@ -0,0 +1,333 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_divdiv_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_8 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 12 + %arg11 + %arg9 * 4 + %arg7 * 108] : memref + %2 = affine.load %arg2[%arg11 + %arg10 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_13[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_13[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_10[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_10[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 12 + %arg11 + %arg9 * 3 + %arg7 * 108 + 36] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_12[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_12[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg2[%arg11 + %arg9 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_9[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_9[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg0[%arg11 + %arg8 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg5[%arg8 * 9 + %arg11 + %arg9 * 3 + %arg7 * 108 + 72] : memref + %2 = affine.load %arg0[%arg11 + %arg10 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_11[%arg7, %arg8, %arg9, %arg10] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_11[%arg7, %arg8, %arg11, %arg10] : memref<2x4x4x5xf64> + %2 = affine.load %arg0[%arg11 + %arg9 * 3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_8[%arg7, %arg8, %arg9, %arg10] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 5 { + %0 = affine.for %arg11 = 0 to 4 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_8[%arg7, %arg11, %arg9, %arg10] : memref<2x4x5x5xf64> + %2 = affine.load %arg2[%arg11 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg3[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_4[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg1[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_3[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %arg4[%arg7 * 125 + %arg11 + %arg8 * 25 + %arg9 * 5] : memref + %2 = affine.load %alloca_7[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %3 = affine.load %alloca_6[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %alloca_5[%arg7, %arg8, %arg9, %arg11] : memref<2x5x5x5xf64> + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %1, %6 : f64 + %8 = affine.load %arg1[%arg11 + %arg10 * 5] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %arg12, %9 : f64 + affine.yield %10 : f64 + } + affine.store %0, %alloca_2[%arg7, %arg8, %arg9, %arg10] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg3[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg7, %arg8, %arg11, %arg10] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg11 + %arg9 * 5] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg12, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg7, %arg8, %arg9, %arg10] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 4 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca_1[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg1[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 4 + %arg7 * 108] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 3 { + affine.for %arg9 = 0 to 4 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca_0[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg1[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 12 + %arg10 + %arg9 * 3 + %arg7 * 108 + 36] : memref + } + } + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 3 { + affine.for %arg10 = 0 to 3 { + %0 = affine.for %arg11 = 0 to 5 iter_args(%arg12 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg7, %arg11, %arg9, %arg10] : memref<2x5x4x4xf64> + %4 = affine.load %arg3[%arg11 + %arg8 * 5] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg12, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg6[%arg8 * 9 + %arg10 + %arg9 * 3 + %arg7 * 108 + 72] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/divdiv_apply_3d_stage_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/divdiv_apply_3d_stage_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..6ab20b1d19fc --- /dev/null +++ b/issues/mfem_c_kernels/results/divdiv_apply_3d_stage_sliced__normalized.raised.mlir @@ -0,0 +1,251 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 4 + d0 * 108)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 3)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 3)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 3)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 125 + d1 * 25 + d2 * 5)> +#map15 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map16 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map17 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map18 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map19 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 4 + d0 * 108)> +#map20 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 12 + d2 * 3 + d0 * 108 + 36)> +#map21 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d1 * 9 + d2 * 3 + d0 * 108 + 72)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_divdiv_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c3 = arith.constant 3 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_8 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_9 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_10 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_11 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_12 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_13 = memref.alloca() : memref<2x4x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_13 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg5, %c2, %c3, %c3, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg2, %c2, %c3, %c3, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_13 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_10 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg0, %c2, %c3, %c5, %c5, %c3) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_13, %2 : memref<2x4x4x5xf64>, memref) outs(%alloca_10 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_7 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %3 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_10, %3 : memref<2x4x5x5xf64>, memref) outs(%alloca_7 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_12 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg5, %c2, %c3, %c4, %c5, %c3) {map = #map9} : (memref, index, index, index, index, index) -> memref + %5 = polygeist.submap(%arg0, %c2, %c3, %c4, %c5, %c3) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%4, %5 : memref, memref) outs(%alloca_12 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_9 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg2, %c2, %c3, %c5, %c5, %c4) {map = #map11} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_12, %6 : memref<2x4x4x5xf64>, memref) outs(%alloca_9 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_6 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %7 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c3) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_9, %7 : memref<2x4x5x5xf64>, memref) outs(%alloca_6 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_11 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg5, %c2, %c4, %c3, %c5, %c3) {map = #map12} : (memref, index, index, index, index, index) -> memref + %9 = polygeist.submap(%arg0, %c2, %c4, %c3, %c5, %c3) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%8, %9 : memref, memref) outs(%alloca_11 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_8 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %10 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c3) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_11, %10 : memref<2x4x4x5xf64>, memref) outs(%alloca_8 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_5 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %11 = polygeist.submap(%arg2, %c2, %c5, %c5, %c5, %c4) {map = #map13} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_8, %11 : memref<2x4x5x5xf64>, memref) outs(%alloca_5 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_4 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %12 = polygeist.submap(%arg4, %c2, %c5, %c5, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %13 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%12, %alloca_7, %alloca_6, %alloca_5, %13 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_4 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %27 = arith.addf %in_14, %in_15 : f64 + %28 = arith.addf %27, %in_16 : f64 + %29 = arith.mulf %in, %28 : f64 + %30 = arith.mulf %29, %in_17 : f64 + %31 = arith.addf %out, %30 : f64 + linalg.yield %31 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg4, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %15 = polygeist.submap(%arg1, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%14, %alloca_7, %alloca_6, %alloca_5, %15 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_3 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %27 = arith.addf %in_14, %in_15 : f64 + %28 = arith.addf %27, %in_16 : f64 + %29 = arith.mulf %in, %28 : f64 + %30 = arith.mulf %29, %in_17 : f64 + %31 = arith.addf %out, %30 : f64 + linalg.yield %31 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %16 = polygeist.submap(%arg4, %c2, %c5, %c5, %c3, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + %17 = polygeist.submap(%arg1, %c2, %c5, %c5, %c3, %c5) {map = #map15} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map16, #map16, #map16, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%16, %alloca_7, %alloca_6, %alloca_5, %17 : memref, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref<2x5x5x5xf64>, memref) outs(%alloca_2 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %27 = arith.addf %in_14, %in_15 : f64 + %28 = arith.addf %27, %in_16 : f64 + %29 = arith.mulf %in, %28 : f64 + %30 = arith.mulf %29, %in_17 : f64 + %31 = arith.addf %out, %30 : f64 + linalg.yield %31 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %18 = polygeist.submap(%arg1, %c2, %c5, %c3, %c4, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_4, %18 : memref<2x5x5x4xf64>, memref) outs(%alloca_1 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %19 = polygeist.submap(%arg3, %c2, %c5, %c4, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_3, %19 : memref<2x5x5x4xf64>, memref) outs(%alloca_0 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %20 = polygeist.submap(%arg1, %c2, %c5, %c3, %c3, %c5) {map = #map17} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_2, %20 : memref<2x5x5x4xf64>, memref) outs(%alloca : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + %21 = polygeist.submap(%arg1, %c2, %c3, %c3, %c4, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %22 = polygeist.submap(%arg6, %c2, %c3, %c3, %c4, %c5) {map = #map19} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_1, %21 : memref<2x5x4x4xf64>, memref) outs(%22 : memref) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + %23 = polygeist.submap(%arg1, %c2, %c3, %c4, %c3, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %24 = polygeist.submap(%arg6, %c2, %c3, %c4, %c3, %c5) {map = #map20} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_0, %23 : memref<2x5x4x4xf64>, memref) outs(%24 : memref) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + %25 = polygeist.submap(%arg3, %c2, %c4, %c3, %c3, %c5) {map = #map18} : (memref, index, index, index, index, index) -> memref + %26 = polygeist.submap(%arg6, %c2, %c4, %c3, %c3, %c5) {map = #map21} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca, %25 : memref<2x5x4x4xf64>, memref) outs(%26 : memref) { + ^bb0(%in: f64, %in_14: f64, %out: f64): + %27 = arith.mulf %in, %in_14 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/elasticity_qpoint_2d__original.frontend.mlir b/issues/mfem_c_kernels/results/elasticity_qpoint_2d__original.frontend.mlir new file mode 100644 index 000000000000..0e882aeeb5bb --- /dev/null +++ b/issues/mfem_c_kernels/results/elasticity_qpoint_2d__original.frontend.mlir @@ -0,0 +1,80 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_elasticity_qpoint_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f64 + %cst_0 = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x2xf64> + %alloca_1 = memref.alloca() : memref<2x2xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 25 { + %0 = affine.load %arg2[%arg6 + %arg5 * 100] : memref + %1 = affine.load %arg2[%arg6 + %arg5 * 100 + 25] : memref + %2 = affine.load %arg2[%arg6 + %arg5 * 100 + 50] : memref + %3 = affine.load %arg2[%arg6 + %arg5 * 100 + 75] : memref + %4 = arith.mulf %0, %3 : f64 + %5 = arith.mulf %1, %2 : f64 + %6 = arith.subf %4, %5 : f64 + %7 = arith.divf %3, %6 : f64 + affine.store %7, %alloca_1[0, 0] : memref<2x2xf64> + %8 = arith.negf %1 : f64 + %9 = arith.divf %8, %6 : f64 + affine.store %9, %alloca_1[0, 1] : memref<2x2xf64> + %10 = arith.negf %2 : f64 + %11 = arith.divf %10, %6 : f64 + affine.store %11, %alloca_1[1, 0] : memref<2x2xf64> + %12 = arith.divf %0, %6 : f64 + affine.store %12, %alloca_1[1, 1] : memref<2x2xf64> + %13 = affine.load %arg4[%arg6 + %arg5 * 100] : memref + %14 = affine.load %arg4[%arg6 + %arg5 * 100 + 75] : memref + %15 = arith.addf %13, %14 : f64 + %16 = affine.load %arg3[%arg6] : memref + %17 = arith.mulf %16, %6 : f64 + %18 = affine.load %arg0[%arg6 + %arg5 * 25] : memref + %19 = affine.load %arg1[%arg6 + %arg5 * 25] : memref + %20 = arith.mulf %19, %cst : f64 + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 2 { + %21 = arith.index_cast %arg8 : index to i32 + %22 = affine.for %arg9 = 0 to 2 iter_args(%arg10 = %cst_0) -> (f64) { + %29 = arith.index_cast %arg9 : index to i32 + %30 = arith.cmpi eq, %29, %21 : i32 + %31 = arith.extui %30 : i1 to i32 + %32 = arith.sitofp %31 : i32 to f64 + %33 = affine.load %alloca_1[%arg7, %arg9] : memref<2x2xf64> + %34 = affine.for %arg11 = 0 to 2 iter_args(%arg12 = %arg10) -> (f64) { + %35 = arith.index_cast %arg11 : index to i32 + %36 = affine.load %alloca_1[%arg7, %arg11] : memref<2x2xf64> + %37 = arith.mulf %32, %36 : f64 + %38 = arith.cmpi eq, %35, %21 : i32 + %39 = arith.extui %38 : i1 to i32 + %40 = arith.sitofp %39 : i32 to f64 + %41 = arith.mulf %40, %33 : f64 + %42 = arith.addf %37, %41 : f64 + %43 = affine.load %arg4[%arg5 * 100 + %arg6 + %arg9 * 50 + %arg11 * 25] : memref + %44 = affine.load %arg4[%arg5 * 100 + %arg6 + %arg11 * 50 + %arg9 * 25] : memref + %45 = arith.addf %43, %44 : f64 + %46 = arith.mulf %42, %45 : f64 + %47 = arith.addf %arg12, %46 : f64 + affine.yield %47 : f64 + } + affine.yield %34 : f64 + } + %23 = affine.load %alloca_1[%arg7, %arg8] : memref<2x2xf64> + %24 = arith.mulf %18, %23 : f64 + %25 = arith.mulf %24, %15 : f64 + %26 = arith.mulf %20, %22 : f64 + %27 = arith.addf %25, %26 : f64 + %28 = arith.mulf %17, %27 : f64 + affine.store %28, %alloca[%arg7, %arg8] : memref<2x2xf64> + } + } + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 2 { + %21 = affine.load %alloca[%arg7, %arg8] : memref<2x2xf64> + affine.store %21, %arg4[%arg5 * 100 + %arg6 + %arg8 * 50 + %arg7 * 25] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/elasticity_qpoint_2d__original.raised.mlir b/issues/mfem_c_kernels/results/elasticity_qpoint_2d__original.raised.mlir new file mode 100644 index 000000000000..761c633be3e2 --- /dev/null +++ b/issues/mfem_c_kernels/results/elasticity_qpoint_2d__original.raised.mlir @@ -0,0 +1,92 @@ +#map = affine_map<(d0, d1)[s0, s1] -> (d1 * 25 + d0 * 50 + s0 * 100 + s1)> +#map1 = affine_map<(d0, d1)[s0, s1] -> (d1 * 50 + s0 * 100 + s1 + d0 * 25)> +#map2 = affine_map<(d0, d1) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d1)> +#map4 = affine_map<(d0, d1) -> (d0, d1)> +#map5 = affine_map<(d0, d1) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_elasticity_qpoint_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %cst = arith.constant 5.000000e-01 : f64 + %cst_0 = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x2xf64> + %alloca_1 = memref.alloca() : memref<2x2xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 25 { + %0 = affine.load %arg2[%arg6 + %arg5 * 100] : memref + %1 = affine.load %arg2[%arg6 + %arg5 * 100 + 25] : memref + %2 = affine.load %arg2[%arg6 + %arg5 * 100 + 50] : memref + %3 = affine.load %arg2[%arg6 + %arg5 * 100 + 75] : memref + %4 = arith.mulf %0, %3 : f64 + %5 = arith.mulf %1, %2 : f64 + %6 = arith.subf %4, %5 : f64 + %7 = arith.divf %3, %6 : f64 + affine.store %7, %alloca_1[0, 0] : memref<2x2xf64> + %8 = arith.negf %1 : f64 + %9 = arith.divf %8, %6 : f64 + affine.store %9, %alloca_1[0, 1] : memref<2x2xf64> + %10 = arith.negf %2 : f64 + %11 = arith.divf %10, %6 : f64 + affine.store %11, %alloca_1[1, 0] : memref<2x2xf64> + %12 = arith.divf %0, %6 : f64 + affine.store %12, %alloca_1[1, 1] : memref<2x2xf64> + %13 = affine.load %arg4[%arg6 + %arg5 * 100] : memref + %14 = affine.load %arg4[%arg6 + %arg5 * 100 + 75] : memref + %15 = arith.addf %13, %14 : f64 + %16 = affine.load %arg3[%arg6] : memref + %17 = arith.mulf %16, %6 : f64 + %18 = affine.load %arg0[%arg6 + %arg5 * 25] : memref + %19 = affine.load %arg1[%arg6 + %arg5 * 25] : memref + %20 = arith.mulf %19, %cst : f64 + affine.for %arg7 = 0 to 2 { + affine.for %arg8 = 0 to 2 { + %22 = arith.index_cast %arg8 : index to i32 + %alloca_2 = memref.alloca() : memref + affine.store %cst_0, %alloca_2[] : memref + %subview = memref.subview %alloca_1[%arg7, 0] [1, %c2] [1, 1] : memref<2x2xf64> to memref> + %23 = polygeist.submap(%arg4, %arg5, %arg6, %c2, %c2) {map = #map} : (memref, index, index, index, index) -> memref + %24 = polygeist.submap(%arg4, %arg5, %arg6, %c2, %c2) {map = #map1} : (memref, index, index, index, index) -> memref + %subview_3 = memref.subview %alloca_2[] [] [] : memref to memref> + %subview_4 = memref.subview %alloca_1[%arg7, 0] [1, %c2] [1, 1] : memref<2x2xf64> to memref> + %cast = memref.cast %subview_4 : memref> to memref + %subview_5 = memref.subview %cast[0] [%c2] [1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3, #map4, #map4, #map5], iterator_types = ["reduction", "reduction"]} ins(%subview_5, %subview, %23, %24 : memref>, memref>, memref, memref) outs(%subview_3 : memref>) { + ^bb0(%in: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %32 = linalg.index 0 : index + %33 = arith.index_cast %32 : index to i32 + %34 = arith.cmpi eq, %33, %22 : i32 + %35 = arith.extui %34 : i1 to i32 + %36 = arith.sitofp %35 : i32 to f64 + %37 = linalg.index 1 : index + %38 = arith.index_cast %37 : index to i32 + %39 = arith.mulf %36, %in_6 : f64 + %40 = arith.cmpi eq, %38, %22 : i32 + %41 = arith.extui %40 : i1 to i32 + %42 = arith.sitofp %41 : i32 to f64 + %43 = arith.mulf %42, %in : f64 + %44 = arith.addf %39, %43 : f64 + %45 = arith.addf %in_7, %in_8 : f64 + %46 = arith.mulf %44, %45 : f64 + %47 = arith.addf %out, %46 : f64 + linalg.yield %47 : f64 + } + %25 = affine.load %alloca_2[] : memref + %26 = affine.load %alloca_1[%arg7, %arg8] : memref<2x2xf64> + %27 = arith.mulf %18, %26 : f64 + %28 = arith.mulf %27, %15 : f64 + %29 = arith.mulf %20, %25 : f64 + %30 = arith.addf %28, %29 : f64 + %31 = arith.mulf %17, %30 : f64 + affine.store %31, %alloca[%arg7, %arg8] : memref<2x2xf64> + } {polygeist.was_parallel} + } {polygeist.was_parallel} + %21 = polygeist.submap(%arg4, %arg5, %arg6, %c2, %c2) {map = #map1} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%alloca : memref<2x2xf64>) outs(%21 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/elasticity_qpoint_2d_scalarized__normalized.frontend.mlir b/issues/mfem_c_kernels/results/elasticity_qpoint_2d_scalarized__normalized.frontend.mlir new file mode 100644 index 000000000000..c212506a1465 --- /dev/null +++ b/issues/mfem_c_kernels/results/elasticity_qpoint_2d_scalarized__normalized.frontend.mlir @@ -0,0 +1,141 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_elasticity_qpoint_2d_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 25 { + %0 = affine.load %arg2[%arg7 + %arg6 * 100] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 100 + 25] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 100 + 50] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 100 + 75] : memref + %4 = arith.mulf %0, %3 : f64 + %5 = arith.mulf %1, %2 : f64 + %6 = arith.subf %4, %5 : f64 + %7 = arith.divf %3, %6 : f64 + %8 = arith.negf %1 : f64 + %9 = arith.divf %8, %6 : f64 + %10 = affine.load %arg4[%arg7 + %arg6 * 100] : memref + %11 = affine.load %arg4[%arg7 + %arg6 * 100 + 25] : memref + %12 = affine.load %arg4[%arg7 + %arg6 * 100 + 50] : memref + %13 = affine.load %arg4[%arg7 + %arg6 * 100 + 75] : memref + %14 = arith.addf %10, %13 : f64 + %15 = affine.load %arg3[%arg7] : memref + %16 = arith.mulf %15, %6 : f64 + %17 = affine.load %arg0[%arg7 + %arg6 * 25] : memref + %18 = affine.load %arg1[%arg7 + %arg6 * 25] : memref + %19 = arith.mulf %17, %7 : f64 + %20 = arith.mulf %19, %14 : f64 + %21 = arith.addf %10, %10 : f64 + %22 = arith.mulf %7, %21 : f64 + %23 = arith.addf %11, %12 : f64 + %24 = arith.mulf %9, %23 : f64 + %25 = arith.addf %22, %24 : f64 + %26 = arith.mulf %18, %25 : f64 + %27 = arith.addf %20, %26 : f64 + %28 = arith.mulf %16, %27 : f64 + affine.store %28, %arg5[%arg7 + %arg6 * 100] : memref + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 25 { + %0 = affine.load %arg2[%arg7 + %arg6 * 100] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 100 + 25] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 100 + 50] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 100 + 75] : memref + %4 = arith.mulf %0, %3 : f64 + %5 = arith.mulf %1, %2 : f64 + %6 = arith.subf %4, %5 : f64 + %7 = arith.divf %3, %6 : f64 + %8 = arith.negf %1 : f64 + %9 = arith.divf %8, %6 : f64 + %10 = affine.load %arg4[%arg7 + %arg6 * 100] : memref + %11 = affine.load %arg4[%arg7 + %arg6 * 100 + 25] : memref + %12 = affine.load %arg4[%arg7 + %arg6 * 100 + 50] : memref + %13 = affine.load %arg4[%arg7 + %arg6 * 100 + 75] : memref + %14 = arith.addf %10, %13 : f64 + %15 = affine.load %arg3[%arg7] : memref + %16 = arith.mulf %15, %6 : f64 + %17 = affine.load %arg0[%arg7 + %arg6 * 25] : memref + %18 = affine.load %arg1[%arg7 + %arg6 * 25] : memref + %19 = arith.mulf %17, %9 : f64 + %20 = arith.mulf %19, %14 : f64 + %21 = arith.addf %12, %11 : f64 + %22 = arith.mulf %7, %21 : f64 + %23 = arith.addf %13, %13 : f64 + %24 = arith.mulf %9, %23 : f64 + %25 = arith.addf %22, %24 : f64 + %26 = arith.mulf %18, %25 : f64 + %27 = arith.addf %20, %26 : f64 + %28 = arith.mulf %16, %27 : f64 + affine.store %28, %arg5[%arg7 + %arg6 * 100 + 50] : memref + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 25 { + %0 = affine.load %arg2[%arg7 + %arg6 * 100] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 100 + 25] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 100 + 50] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 100 + 75] : memref + %4 = arith.mulf %0, %3 : f64 + %5 = arith.mulf %1, %2 : f64 + %6 = arith.subf %4, %5 : f64 + %7 = arith.negf %2 : f64 + %8 = arith.divf %7, %6 : f64 + %9 = arith.divf %0, %6 : f64 + %10 = affine.load %arg4[%arg7 + %arg6 * 100] : memref + %11 = affine.load %arg4[%arg7 + %arg6 * 100 + 25] : memref + %12 = affine.load %arg4[%arg7 + %arg6 * 100 + 50] : memref + %13 = affine.load %arg4[%arg7 + %arg6 * 100 + 75] : memref + %14 = arith.addf %10, %13 : f64 + %15 = affine.load %arg3[%arg7] : memref + %16 = arith.mulf %15, %6 : f64 + %17 = affine.load %arg0[%arg7 + %arg6 * 25] : memref + %18 = affine.load %arg1[%arg7 + %arg6 * 25] : memref + %19 = arith.mulf %17, %8 : f64 + %20 = arith.mulf %19, %14 : f64 + %21 = arith.addf %10, %10 : f64 + %22 = arith.mulf %8, %21 : f64 + %23 = arith.addf %11, %12 : f64 + %24 = arith.mulf %9, %23 : f64 + %25 = arith.addf %22, %24 : f64 + %26 = arith.mulf %18, %25 : f64 + %27 = arith.addf %20, %26 : f64 + %28 = arith.mulf %16, %27 : f64 + affine.store %28, %arg5[%arg7 + %arg6 * 100 + 25] : memref + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 25 { + %0 = affine.load %arg2[%arg7 + %arg6 * 100] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 100 + 25] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 100 + 50] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 100 + 75] : memref + %4 = arith.mulf %0, %3 : f64 + %5 = arith.mulf %1, %2 : f64 + %6 = arith.subf %4, %5 : f64 + %7 = arith.negf %2 : f64 + %8 = arith.divf %7, %6 : f64 + %9 = arith.divf %0, %6 : f64 + %10 = affine.load %arg4[%arg7 + %arg6 * 100] : memref + %11 = affine.load %arg4[%arg7 + %arg6 * 100 + 25] : memref + %12 = affine.load %arg4[%arg7 + %arg6 * 100 + 50] : memref + %13 = affine.load %arg4[%arg7 + %arg6 * 100 + 75] : memref + %14 = arith.addf %10, %13 : f64 + %15 = affine.load %arg3[%arg7] : memref + %16 = arith.mulf %15, %6 : f64 + %17 = affine.load %arg0[%arg7 + %arg6 * 25] : memref + %18 = affine.load %arg1[%arg7 + %arg6 * 25] : memref + %19 = arith.mulf %17, %9 : f64 + %20 = arith.mulf %19, %14 : f64 + %21 = arith.addf %12, %11 : f64 + %22 = arith.mulf %8, %21 : f64 + %23 = arith.addf %13, %13 : f64 + %24 = arith.mulf %9, %23 : f64 + %25 = arith.addf %22, %24 : f64 + %26 = arith.mulf %18, %25 : f64 + %27 = arith.addf %20, %26 : f64 + %28 = arith.mulf %16, %27 : f64 + affine.store %28, %arg5[%arg7 + %arg6 * 100 + 75] : memref + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/elasticity_qpoint_2d_scalarized__normalized.raised.mlir b/issues/mfem_c_kernels/results/elasticity_qpoint_2d_scalarized__normalized.raised.mlir new file mode 100644 index 000000000000..d196af635658 --- /dev/null +++ b/issues/mfem_c_kernels/results/elasticity_qpoint_2d_scalarized__normalized.raised.mlir @@ -0,0 +1,146 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 100)> +#map1 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 25)> +#map2 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 50)> +#map3 = affine_map<(d0, d1) -> (d1 + d0 * 100 + 75)> +#map4 = affine_map<(d0, d1) -> (d1 + d0 * 25)> +#map5 = affine_map<(d0, d1) -> (d0, d1)> +#map6 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_elasticity_qpoint_2d_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c25 = arith.constant 25 : index + %0 = polygeist.submap(%arg2, %c2, %c25) {map = #map} : (memref, index, index) -> memref + %1 = polygeist.submap(%arg2, %c2, %c25) {map = #map1} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg2, %c2, %c25) {map = #map2} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg2, %c2, %c25) {map = #map3} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %c2, %c25) {map = #map} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg4, %c2, %c25) {map = #map1} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg4, %c2, %c25) {map = #map2} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg4, %c2, %c25) {map = #map3} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg0, %c2, %c25) {map = #map4} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg1, %c2, %c25) {map = #map4} : (memref, index, index) -> memref + %10 = polygeist.submap(%arg5, %c2, %c25) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5, #map5, #map5, #map5, #map5, #map5, #map6, #map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%0, %1, %2, %3, %4, %5, %6, %7, %arg3, %8, %9 : memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%10 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %out: f64): + %44 = arith.mulf %in, %in_2 : f64 + %45 = arith.mulf %in_0, %in_1 : f64 + %46 = arith.subf %44, %45 : f64 + %47 = arith.divf %in_2, %46 : f64 + %48 = arith.negf %in_0 : f64 + %49 = arith.divf %48, %46 : f64 + %50 = arith.addf %in_3, %in_6 : f64 + %51 = arith.mulf %in_7, %46 : f64 + %52 = arith.mulf %in_8, %47 : f64 + %53 = arith.mulf %52, %50 : f64 + %54 = arith.addf %in_3, %in_3 : f64 + %55 = arith.mulf %47, %54 : f64 + %56 = arith.addf %in_4, %in_5 : f64 + %57 = arith.mulf %49, %56 : f64 + %58 = arith.addf %55, %57 : f64 + %59 = arith.mulf %in_9, %58 : f64 + %60 = arith.addf %53, %59 : f64 + %61 = arith.mulf %51, %60 : f64 + linalg.yield %61 : f64 + } + %11 = polygeist.submap(%arg2, %c2, %c25) {map = #map} : (memref, index, index) -> memref + %12 = polygeist.submap(%arg2, %c2, %c25) {map = #map1} : (memref, index, index) -> memref + %13 = polygeist.submap(%arg2, %c2, %c25) {map = #map2} : (memref, index, index) -> memref + %14 = polygeist.submap(%arg2, %c2, %c25) {map = #map3} : (memref, index, index) -> memref + %15 = polygeist.submap(%arg4, %c2, %c25) {map = #map} : (memref, index, index) -> memref + %16 = polygeist.submap(%arg4, %c2, %c25) {map = #map1} : (memref, index, index) -> memref + %17 = polygeist.submap(%arg4, %c2, %c25) {map = #map2} : (memref, index, index) -> memref + %18 = polygeist.submap(%arg4, %c2, %c25) {map = #map3} : (memref, index, index) -> memref + %19 = polygeist.submap(%arg0, %c2, %c25) {map = #map4} : (memref, index, index) -> memref + %20 = polygeist.submap(%arg1, %c2, %c25) {map = #map4} : (memref, index, index) -> memref + %21 = polygeist.submap(%arg5, %c2, %c25) {map = #map2} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5, #map5, #map5, #map5, #map5, #map5, #map6, #map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%11, %12, %13, %14, %15, %16, %17, %18, %arg3, %19, %20 : memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %out: f64): + %44 = arith.mulf %in, %in_2 : f64 + %45 = arith.mulf %in_0, %in_1 : f64 + %46 = arith.subf %44, %45 : f64 + %47 = arith.divf %in_2, %46 : f64 + %48 = arith.negf %in_0 : f64 + %49 = arith.divf %48, %46 : f64 + %50 = arith.addf %in_3, %in_6 : f64 + %51 = arith.mulf %in_7, %46 : f64 + %52 = arith.mulf %in_8, %49 : f64 + %53 = arith.mulf %52, %50 : f64 + %54 = arith.addf %in_5, %in_4 : f64 + %55 = arith.mulf %47, %54 : f64 + %56 = arith.addf %in_6, %in_6 : f64 + %57 = arith.mulf %49, %56 : f64 + %58 = arith.addf %55, %57 : f64 + %59 = arith.mulf %in_9, %58 : f64 + %60 = arith.addf %53, %59 : f64 + %61 = arith.mulf %51, %60 : f64 + linalg.yield %61 : f64 + } + %22 = polygeist.submap(%arg2, %c2, %c25) {map = #map} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg2, %c2, %c25) {map = #map1} : (memref, index, index) -> memref + %24 = polygeist.submap(%arg2, %c2, %c25) {map = #map2} : (memref, index, index) -> memref + %25 = polygeist.submap(%arg2, %c2, %c25) {map = #map3} : (memref, index, index) -> memref + %26 = polygeist.submap(%arg4, %c2, %c25) {map = #map} : (memref, index, index) -> memref + %27 = polygeist.submap(%arg4, %c2, %c25) {map = #map1} : (memref, index, index) -> memref + %28 = polygeist.submap(%arg4, %c2, %c25) {map = #map2} : (memref, index, index) -> memref + %29 = polygeist.submap(%arg4, %c2, %c25) {map = #map3} : (memref, index, index) -> memref + %30 = polygeist.submap(%arg0, %c2, %c25) {map = #map4} : (memref, index, index) -> memref + %31 = polygeist.submap(%arg1, %c2, %c25) {map = #map4} : (memref, index, index) -> memref + %32 = polygeist.submap(%arg5, %c2, %c25) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5, #map5, #map5, #map5, #map5, #map5, #map6, #map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%22, %23, %24, %25, %26, %27, %28, %29, %arg3, %30, %31 : memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%32 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %out: f64): + %44 = arith.mulf %in, %in_2 : f64 + %45 = arith.mulf %in_0, %in_1 : f64 + %46 = arith.subf %44, %45 : f64 + %47 = arith.negf %in_1 : f64 + %48 = arith.divf %47, %46 : f64 + %49 = arith.divf %in, %46 : f64 + %50 = arith.addf %in_3, %in_6 : f64 + %51 = arith.mulf %in_7, %46 : f64 + %52 = arith.mulf %in_8, %48 : f64 + %53 = arith.mulf %52, %50 : f64 + %54 = arith.addf %in_3, %in_3 : f64 + %55 = arith.mulf %48, %54 : f64 + %56 = arith.addf %in_4, %in_5 : f64 + %57 = arith.mulf %49, %56 : f64 + %58 = arith.addf %55, %57 : f64 + %59 = arith.mulf %in_9, %58 : f64 + %60 = arith.addf %53, %59 : f64 + %61 = arith.mulf %51, %60 : f64 + linalg.yield %61 : f64 + } + %33 = polygeist.submap(%arg2, %c2, %c25) {map = #map} : (memref, index, index) -> memref + %34 = polygeist.submap(%arg2, %c2, %c25) {map = #map1} : (memref, index, index) -> memref + %35 = polygeist.submap(%arg2, %c2, %c25) {map = #map2} : (memref, index, index) -> memref + %36 = polygeist.submap(%arg2, %c2, %c25) {map = #map3} : (memref, index, index) -> memref + %37 = polygeist.submap(%arg4, %c2, %c25) {map = #map} : (memref, index, index) -> memref + %38 = polygeist.submap(%arg4, %c2, %c25) {map = #map1} : (memref, index, index) -> memref + %39 = polygeist.submap(%arg4, %c2, %c25) {map = #map2} : (memref, index, index) -> memref + %40 = polygeist.submap(%arg4, %c2, %c25) {map = #map3} : (memref, index, index) -> memref + %41 = polygeist.submap(%arg0, %c2, %c25) {map = #map4} : (memref, index, index) -> memref + %42 = polygeist.submap(%arg1, %c2, %c25) {map = #map4} : (memref, index, index) -> memref + %43 = polygeist.submap(%arg5, %c2, %c25) {map = #map3} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5, #map5, #map5, #map5, #map5, #map5, #map6, #map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%33, %34, %35, %36, %37, %38, %39, %40, %arg3, %41, %42 : memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%43 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %out: f64): + %44 = arith.mulf %in, %in_2 : f64 + %45 = arith.mulf %in_0, %in_1 : f64 + %46 = arith.subf %44, %45 : f64 + %47 = arith.negf %in_1 : f64 + %48 = arith.divf %47, %46 : f64 + %49 = arith.divf %in, %46 : f64 + %50 = arith.addf %in_3, %in_6 : f64 + %51 = arith.mulf %in_7, %46 : f64 + %52 = arith.mulf %in_8, %49 : f64 + %53 = arith.mulf %52, %50 : f64 + %54 = arith.addf %in_5, %in_4 : f64 + %55 = arith.mulf %48, %54 : f64 + %56 = arith.addf %in_6, %in_6 : f64 + %57 = arith.mulf %49, %56 : f64 + %58 = arith.addf %55, %57 : f64 + %59 = arith.mulf %in_9, %58 : f64 + %60 = arith.addf %53, %59 : f64 + %61 = arith.mulf %51, %60 : f64 + linalg.yield %61 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/elasticity_qpoint_3d__original.frontend.mlir b/issues/mfem_c_kernels/results/elasticity_qpoint_3d__original.frontend.mlir new file mode 100644 index 000000000000..0300947f9215 --- /dev/null +++ b/issues/mfem_c_kernels/results/elasticity_qpoint_3d__original.frontend.mlir @@ -0,0 +1,125 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_elasticity_qpoint_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f64 + %cst_0 = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<3x3xf64> + %alloca_1 = memref.alloca() : memref<3x3xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 125 { + %0 = affine.load %arg2[%arg6 + %arg5 * 1125] : memref + %1 = affine.load %arg2[%arg6 + %arg5 * 1125 + 125] : memref + %2 = affine.load %arg2[%arg6 + %arg5 * 1125 + 250] : memref + %3 = affine.load %arg2[%arg6 + %arg5 * 1125 + 375] : memref + %4 = affine.load %arg2[%arg6 + %arg5 * 1125 + 500] : memref + %5 = affine.load %arg2[%arg6 + %arg5 * 1125 + 625] : memref + %6 = affine.load %arg2[%arg6 + %arg5 * 1125 + 750] : memref + %7 = affine.load %arg2[%arg6 + %arg5 * 1125 + 875] : memref + %8 = affine.load %arg2[%arg6 + %arg5 * 1125 + 1000] : memref + %9 = arith.mulf %4, %8 : f64 + %10 = arith.mulf %5, %7 : f64 + %11 = arith.subf %9, %10 : f64 + %12 = arith.mulf %0, %11 : f64 + %13 = arith.mulf %3, %8 : f64 + %14 = arith.mulf %5, %6 : f64 + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %1, %15 : f64 + %17 = arith.subf %12, %16 : f64 + %18 = arith.mulf %3, %7 : f64 + %19 = arith.mulf %4, %6 : f64 + %20 = arith.subf %18, %19 : f64 + %21 = arith.mulf %2, %20 : f64 + %22 = arith.addf %17, %21 : f64 + %23 = arith.divf %11, %22 : f64 + affine.store %23, %alloca_1[0, 0] : memref<3x3xf64> + %24 = arith.mulf %2, %7 : f64 + %25 = arith.mulf %1, %8 : f64 + %26 = arith.subf %24, %25 : f64 + %27 = arith.divf %26, %22 : f64 + affine.store %27, %alloca_1[0, 1] : memref<3x3xf64> + %28 = arith.mulf %1, %5 : f64 + %29 = arith.mulf %2, %4 : f64 + %30 = arith.subf %28, %29 : f64 + %31 = arith.divf %30, %22 : f64 + affine.store %31, %alloca_1[0, 2] : memref<3x3xf64> + %32 = arith.subf %14, %13 : f64 + %33 = arith.divf %32, %22 : f64 + affine.store %33, %alloca_1[1, 0] : memref<3x3xf64> + %34 = arith.mulf %0, %8 : f64 + %35 = arith.mulf %2, %6 : f64 + %36 = arith.subf %34, %35 : f64 + %37 = arith.divf %36, %22 : f64 + affine.store %37, %alloca_1[1, 1] : memref<3x3xf64> + %38 = arith.mulf %2, %3 : f64 + %39 = arith.mulf %0, %5 : f64 + %40 = arith.subf %38, %39 : f64 + %41 = arith.divf %40, %22 : f64 + affine.store %41, %alloca_1[1, 2] : memref<3x3xf64> + %42 = arith.divf %20, %22 : f64 + affine.store %42, %alloca_1[2, 0] : memref<3x3xf64> + %43 = arith.mulf %1, %6 : f64 + %44 = arith.mulf %0, %7 : f64 + %45 = arith.subf %43, %44 : f64 + %46 = arith.divf %45, %22 : f64 + affine.store %46, %alloca_1[2, 1] : memref<3x3xf64> + %47 = arith.mulf %0, %4 : f64 + %48 = arith.mulf %1, %3 : f64 + %49 = arith.subf %47, %48 : f64 + %50 = arith.divf %49, %22 : f64 + affine.store %50, %alloca_1[2, 2] : memref<3x3xf64> + %51 = affine.load %arg4[%arg6 + %arg5 * 1125] : memref + %52 = affine.load %arg4[%arg6 + %arg5 * 1125 + 500] : memref + %53 = arith.addf %51, %52 : f64 + %54 = affine.load %arg4[%arg6 + %arg5 * 1125 + 1000] : memref + %55 = arith.addf %53, %54 : f64 + %56 = affine.load %arg3[%arg6] : memref + %57 = arith.mulf %56, %22 : f64 + %58 = affine.load %arg0[%arg6 + %arg5 * 125] : memref + %59 = affine.load %arg1[%arg6 + %arg5 * 125] : memref + %60 = arith.mulf %59, %cst : f64 + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + %61 = arith.index_cast %arg8 : index to i32 + %62 = affine.for %arg9 = 0 to 3 iter_args(%arg10 = %cst_0) -> (f64) { + %69 = arith.index_cast %arg9 : index to i32 + %70 = arith.cmpi eq, %69, %61 : i32 + %71 = arith.extui %70 : i1 to i32 + %72 = arith.sitofp %71 : i32 to f64 + %73 = affine.load %alloca_1[%arg7, %arg9] : memref<3x3xf64> + %74 = affine.for %arg11 = 0 to 3 iter_args(%arg12 = %arg10) -> (f64) { + %75 = arith.index_cast %arg11 : index to i32 + %76 = affine.load %alloca_1[%arg7, %arg11] : memref<3x3xf64> + %77 = arith.mulf %72, %76 : f64 + %78 = arith.cmpi eq, %75, %61 : i32 + %79 = arith.extui %78 : i1 to i32 + %80 = arith.sitofp %79 : i32 to f64 + %81 = arith.mulf %80, %73 : f64 + %82 = arith.addf %77, %81 : f64 + %83 = affine.load %arg4[%arg5 * 1125 + %arg6 + %arg9 * 375 + %arg11 * 125] : memref + %84 = affine.load %arg4[%arg5 * 1125 + %arg6 + %arg11 * 375 + %arg9 * 125] : memref + %85 = arith.addf %83, %84 : f64 + %86 = arith.mulf %82, %85 : f64 + %87 = arith.addf %arg12, %86 : f64 + affine.yield %87 : f64 + } + affine.yield %74 : f64 + } + %63 = affine.load %alloca_1[%arg7, %arg8] : memref<3x3xf64> + %64 = arith.mulf %58, %63 : f64 + %65 = arith.mulf %64, %55 : f64 + %66 = arith.mulf %60, %62 : f64 + %67 = arith.addf %65, %66 : f64 + %68 = arith.mulf %57, %67 : f64 + affine.store %68, %alloca[%arg7, %arg8] : memref<3x3xf64> + } + } + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + %61 = affine.load %alloca[%arg7, %arg8] : memref<3x3xf64> + affine.store %61, %arg4[%arg5 * 1125 + %arg6 + %arg8 * 375 + %arg7 * 125] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/elasticity_qpoint_3d__original.raised.mlir b/issues/mfem_c_kernels/results/elasticity_qpoint_3d__original.raised.mlir new file mode 100644 index 000000000000..2e40001b45f6 --- /dev/null +++ b/issues/mfem_c_kernels/results/elasticity_qpoint_3d__original.raised.mlir @@ -0,0 +1,137 @@ +#map = affine_map<(d0, d1)[s0, s1] -> (d1 * 125 + d0 * 375 + s0 * 1125 + s1)> +#map1 = affine_map<(d0, d1)[s0, s1] -> (d1 * 375 + s0 * 1125 + s1 + d0 * 125)> +#map2 = affine_map<(d0, d1) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d1)> +#map4 = affine_map<(d0, d1) -> (d0, d1)> +#map5 = affine_map<(d0, d1) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_elasticity_qpoint_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3 = arith.constant 3 : index + %cst = arith.constant 5.000000e-01 : f64 + %cst_0 = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<3x3xf64> + %alloca_1 = memref.alloca() : memref<3x3xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 125 { + %0 = affine.load %arg2[%arg6 + %arg5 * 1125] : memref + %1 = affine.load %arg2[%arg6 + %arg5 * 1125 + 125] : memref + %2 = affine.load %arg2[%arg6 + %arg5 * 1125 + 250] : memref + %3 = affine.load %arg2[%arg6 + %arg5 * 1125 + 375] : memref + %4 = affine.load %arg2[%arg6 + %arg5 * 1125 + 500] : memref + %5 = affine.load %arg2[%arg6 + %arg5 * 1125 + 625] : memref + %6 = affine.load %arg2[%arg6 + %arg5 * 1125 + 750] : memref + %7 = affine.load %arg2[%arg6 + %arg5 * 1125 + 875] : memref + %8 = affine.load %arg2[%arg6 + %arg5 * 1125 + 1000] : memref + %9 = arith.mulf %4, %8 : f64 + %10 = arith.mulf %5, %7 : f64 + %11 = arith.subf %9, %10 : f64 + %12 = arith.mulf %0, %11 : f64 + %13 = arith.mulf %3, %8 : f64 + %14 = arith.mulf %5, %6 : f64 + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %1, %15 : f64 + %17 = arith.subf %12, %16 : f64 + %18 = arith.mulf %3, %7 : f64 + %19 = arith.mulf %4, %6 : f64 + %20 = arith.subf %18, %19 : f64 + %21 = arith.mulf %2, %20 : f64 + %22 = arith.addf %17, %21 : f64 + %23 = arith.divf %11, %22 : f64 + affine.store %23, %alloca_1[0, 0] : memref<3x3xf64> + %24 = arith.mulf %2, %7 : f64 + %25 = arith.mulf %1, %8 : f64 + %26 = arith.subf %24, %25 : f64 + %27 = arith.divf %26, %22 : f64 + affine.store %27, %alloca_1[0, 1] : memref<3x3xf64> + %28 = arith.mulf %1, %5 : f64 + %29 = arith.mulf %2, %4 : f64 + %30 = arith.subf %28, %29 : f64 + %31 = arith.divf %30, %22 : f64 + affine.store %31, %alloca_1[0, 2] : memref<3x3xf64> + %32 = arith.subf %14, %13 : f64 + %33 = arith.divf %32, %22 : f64 + affine.store %33, %alloca_1[1, 0] : memref<3x3xf64> + %34 = arith.mulf %0, %8 : f64 + %35 = arith.mulf %2, %6 : f64 + %36 = arith.subf %34, %35 : f64 + %37 = arith.divf %36, %22 : f64 + affine.store %37, %alloca_1[1, 1] : memref<3x3xf64> + %38 = arith.mulf %2, %3 : f64 + %39 = arith.mulf %0, %5 : f64 + %40 = arith.subf %38, %39 : f64 + %41 = arith.divf %40, %22 : f64 + affine.store %41, %alloca_1[1, 2] : memref<3x3xf64> + %42 = arith.divf %20, %22 : f64 + affine.store %42, %alloca_1[2, 0] : memref<3x3xf64> + %43 = arith.mulf %1, %6 : f64 + %44 = arith.mulf %0, %7 : f64 + %45 = arith.subf %43, %44 : f64 + %46 = arith.divf %45, %22 : f64 + affine.store %46, %alloca_1[2, 1] : memref<3x3xf64> + %47 = arith.mulf %0, %4 : f64 + %48 = arith.mulf %1, %3 : f64 + %49 = arith.subf %47, %48 : f64 + %50 = arith.divf %49, %22 : f64 + affine.store %50, %alloca_1[2, 2] : memref<3x3xf64> + %51 = affine.load %arg4[%arg6 + %arg5 * 1125] : memref + %52 = affine.load %arg4[%arg6 + %arg5 * 1125 + 500] : memref + %53 = arith.addf %51, %52 : f64 + %54 = affine.load %arg4[%arg6 + %arg5 * 1125 + 1000] : memref + %55 = arith.addf %53, %54 : f64 + %56 = affine.load %arg3[%arg6] : memref + %57 = arith.mulf %56, %22 : f64 + %58 = affine.load %arg0[%arg6 + %arg5 * 125] : memref + %59 = affine.load %arg1[%arg6 + %arg5 * 125] : memref + %60 = arith.mulf %59, %cst : f64 + affine.for %arg7 = 0 to 3 { + affine.for %arg8 = 0 to 3 { + %62 = arith.index_cast %arg8 : index to i32 + %alloca_2 = memref.alloca() : memref + affine.store %cst_0, %alloca_2[] : memref + %subview = memref.subview %alloca_1[%arg7, 0] [1, %c3] [1, 1] : memref<3x3xf64> to memref> + %63 = polygeist.submap(%arg4, %arg5, %arg6, %c3, %c3) {map = #map} : (memref, index, index, index, index) -> memref + %64 = polygeist.submap(%arg4, %arg5, %arg6, %c3, %c3) {map = #map1} : (memref, index, index, index, index) -> memref + %subview_3 = memref.subview %alloca_2[] [] [] : memref to memref> + %subview_4 = memref.subview %alloca_1[%arg7, 0] [1, %c3] [1, 1] : memref<3x3xf64> to memref> + %cast = memref.cast %subview_4 : memref> to memref + %subview_5 = memref.subview %cast[0] [%c3] [1] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map3, #map4, #map4, #map5], iterator_types = ["reduction", "reduction"]} ins(%subview_5, %subview, %63, %64 : memref>, memref>, memref, memref) outs(%subview_3 : memref>) { + ^bb0(%in: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64): + %72 = linalg.index 0 : index + %73 = arith.index_cast %72 : index to i32 + %74 = arith.cmpi eq, %73, %62 : i32 + %75 = arith.extui %74 : i1 to i32 + %76 = arith.sitofp %75 : i32 to f64 + %77 = linalg.index 1 : index + %78 = arith.index_cast %77 : index to i32 + %79 = arith.mulf %76, %in_6 : f64 + %80 = arith.cmpi eq, %78, %62 : i32 + %81 = arith.extui %80 : i1 to i32 + %82 = arith.sitofp %81 : i32 to f64 + %83 = arith.mulf %82, %in : f64 + %84 = arith.addf %79, %83 : f64 + %85 = arith.addf %in_7, %in_8 : f64 + %86 = arith.mulf %84, %85 : f64 + %87 = arith.addf %out, %86 : f64 + linalg.yield %87 : f64 + } + %65 = affine.load %alloca_2[] : memref + %66 = affine.load %alloca_1[%arg7, %arg8] : memref<3x3xf64> + %67 = arith.mulf %58, %66 : f64 + %68 = arith.mulf %67, %55 : f64 + %69 = arith.mulf %60, %65 : f64 + %70 = arith.addf %68, %69 : f64 + %71 = arith.mulf %57, %70 : f64 + affine.store %71, %alloca[%arg7, %arg8] : memref<3x3xf64> + } {polygeist.was_parallel} + } {polygeist.was_parallel} + %61 = polygeist.submap(%arg4, %arg5, %arg6, %c3, %c3) {map = #map1} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%alloca : memref<3x3xf64>) outs(%61 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/elasticity_qpoint_3d_scalarized__normalized.frontend.mlir b/issues/mfem_c_kernels/results/elasticity_qpoint_3d_scalarized__normalized.frontend.mlir new file mode 100644 index 000000000000..a455edeb9666 --- /dev/null +++ b/issues/mfem_c_kernels/results/elasticity_qpoint_3d_scalarized__normalized.frontend.mlir @@ -0,0 +1,575 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_elasticity_qpoint_3d_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 125 { + %0 = affine.load %arg2[%arg7 + %arg6 * 1125] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 1125 + 125] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 1125 + 250] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 1125 + 375] : memref + %4 = affine.load %arg2[%arg7 + %arg6 * 1125 + 500] : memref + %5 = affine.load %arg2[%arg7 + %arg6 * 1125 + 625] : memref + %6 = affine.load %arg2[%arg7 + %arg6 * 1125 + 750] : memref + %7 = affine.load %arg2[%arg7 + %arg6 * 1125 + 875] : memref + %8 = affine.load %arg2[%arg7 + %arg6 * 1125 + 1000] : memref + %9 = arith.mulf %4, %8 : f64 + %10 = arith.mulf %5, %7 : f64 + %11 = arith.subf %9, %10 : f64 + %12 = arith.mulf %0, %11 : f64 + %13 = arith.mulf %3, %8 : f64 + %14 = arith.mulf %5, %6 : f64 + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %1, %15 : f64 + %17 = arith.subf %12, %16 : f64 + %18 = arith.mulf %3, %7 : f64 + %19 = arith.mulf %4, %6 : f64 + %20 = arith.subf %18, %19 : f64 + %21 = arith.mulf %2, %20 : f64 + %22 = arith.addf %17, %21 : f64 + %23 = arith.divf %11, %22 : f64 + %24 = arith.mulf %2, %7 : f64 + %25 = arith.mulf %1, %8 : f64 + %26 = arith.subf %24, %25 : f64 + %27 = arith.divf %26, %22 : f64 + %28 = arith.mulf %1, %5 : f64 + %29 = arith.mulf %2, %4 : f64 + %30 = arith.subf %28, %29 : f64 + %31 = arith.divf %30, %22 : f64 + %32 = affine.load %arg4[%arg7 + %arg6 * 1125] : memref + %33 = affine.load %arg4[%arg7 + %arg6 * 1125 + 125] : memref + %34 = affine.load %arg4[%arg7 + %arg6 * 1125 + 250] : memref + %35 = affine.load %arg4[%arg7 + %arg6 * 1125 + 375] : memref + %36 = affine.load %arg4[%arg7 + %arg6 * 1125 + 500] : memref + %37 = affine.load %arg4[%arg7 + %arg6 * 1125 + 750] : memref + %38 = affine.load %arg4[%arg7 + %arg6 * 1125 + 1000] : memref + %39 = arith.addf %32, %36 : f64 + %40 = arith.addf %39, %38 : f64 + %41 = affine.load %arg3[%arg7] : memref + %42 = arith.mulf %41, %22 : f64 + %43 = affine.load %arg0[%arg7 + %arg6 * 125] : memref + %44 = affine.load %arg1[%arg7 + %arg6 * 125] : memref + %45 = arith.mulf %43, %23 : f64 + %46 = arith.mulf %45, %40 : f64 + %47 = arith.addf %32, %32 : f64 + %48 = arith.mulf %23, %47 : f64 + %49 = arith.addf %33, %35 : f64 + %50 = arith.mulf %27, %49 : f64 + %51 = arith.addf %48, %50 : f64 + %52 = arith.addf %34, %37 : f64 + %53 = arith.mulf %31, %52 : f64 + %54 = arith.addf %51, %53 : f64 + %55 = arith.mulf %44, %54 : f64 + %56 = arith.addf %46, %55 : f64 + %57 = arith.mulf %42, %56 : f64 + affine.store %57, %arg5[%arg7 + %arg6 * 1125] : memref + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 125 { + %0 = affine.load %arg2[%arg7 + %arg6 * 1125] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 1125 + 125] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 1125 + 250] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 1125 + 375] : memref + %4 = affine.load %arg2[%arg7 + %arg6 * 1125 + 500] : memref + %5 = affine.load %arg2[%arg7 + %arg6 * 1125 + 625] : memref + %6 = affine.load %arg2[%arg7 + %arg6 * 1125 + 750] : memref + %7 = affine.load %arg2[%arg7 + %arg6 * 1125 + 875] : memref + %8 = affine.load %arg2[%arg7 + %arg6 * 1125 + 1000] : memref + %9 = arith.mulf %4, %8 : f64 + %10 = arith.mulf %5, %7 : f64 + %11 = arith.subf %9, %10 : f64 + %12 = arith.mulf %0, %11 : f64 + %13 = arith.mulf %3, %8 : f64 + %14 = arith.mulf %5, %6 : f64 + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %1, %15 : f64 + %17 = arith.subf %12, %16 : f64 + %18 = arith.mulf %3, %7 : f64 + %19 = arith.mulf %4, %6 : f64 + %20 = arith.subf %18, %19 : f64 + %21 = arith.mulf %2, %20 : f64 + %22 = arith.addf %17, %21 : f64 + %23 = arith.divf %11, %22 : f64 + %24 = arith.mulf %2, %7 : f64 + %25 = arith.mulf %1, %8 : f64 + %26 = arith.subf %24, %25 : f64 + %27 = arith.divf %26, %22 : f64 + %28 = arith.mulf %1, %5 : f64 + %29 = arith.mulf %2, %4 : f64 + %30 = arith.subf %28, %29 : f64 + %31 = arith.divf %30, %22 : f64 + %32 = affine.load %arg4[%arg7 + %arg6 * 1125] : memref + %33 = affine.load %arg4[%arg7 + %arg6 * 1125 + 125] : memref + %34 = affine.load %arg4[%arg7 + %arg6 * 1125 + 375] : memref + %35 = affine.load %arg4[%arg7 + %arg6 * 1125 + 500] : memref + %36 = affine.load %arg4[%arg7 + %arg6 * 1125 + 625] : memref + %37 = affine.load %arg4[%arg7 + %arg6 * 1125 + 875] : memref + %38 = affine.load %arg4[%arg7 + %arg6 * 1125 + 1000] : memref + %39 = arith.addf %32, %35 : f64 + %40 = arith.addf %39, %38 : f64 + %41 = affine.load %arg3[%arg7] : memref + %42 = arith.mulf %41, %22 : f64 + %43 = affine.load %arg0[%arg7 + %arg6 * 125] : memref + %44 = affine.load %arg1[%arg7 + %arg6 * 125] : memref + %45 = arith.mulf %43, %27 : f64 + %46 = arith.mulf %45, %40 : f64 + %47 = arith.addf %34, %33 : f64 + %48 = arith.mulf %23, %47 : f64 + %49 = arith.addf %35, %35 : f64 + %50 = arith.mulf %27, %49 : f64 + %51 = arith.addf %48, %50 : f64 + %52 = arith.addf %36, %37 : f64 + %53 = arith.mulf %31, %52 : f64 + %54 = arith.addf %51, %53 : f64 + %55 = arith.mulf %44, %54 : f64 + %56 = arith.addf %46, %55 : f64 + %57 = arith.mulf %42, %56 : f64 + affine.store %57, %arg5[%arg7 + %arg6 * 1125 + 375] : memref + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 125 { + %0 = affine.load %arg2[%arg7 + %arg6 * 1125] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 1125 + 125] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 1125 + 250] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 1125 + 375] : memref + %4 = affine.load %arg2[%arg7 + %arg6 * 1125 + 500] : memref + %5 = affine.load %arg2[%arg7 + %arg6 * 1125 + 625] : memref + %6 = affine.load %arg2[%arg7 + %arg6 * 1125 + 750] : memref + %7 = affine.load %arg2[%arg7 + %arg6 * 1125 + 875] : memref + %8 = affine.load %arg2[%arg7 + %arg6 * 1125 + 1000] : memref + %9 = arith.mulf %4, %8 : f64 + %10 = arith.mulf %5, %7 : f64 + %11 = arith.subf %9, %10 : f64 + %12 = arith.mulf %0, %11 : f64 + %13 = arith.mulf %3, %8 : f64 + %14 = arith.mulf %5, %6 : f64 + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %1, %15 : f64 + %17 = arith.subf %12, %16 : f64 + %18 = arith.mulf %3, %7 : f64 + %19 = arith.mulf %4, %6 : f64 + %20 = arith.subf %18, %19 : f64 + %21 = arith.mulf %2, %20 : f64 + %22 = arith.addf %17, %21 : f64 + %23 = arith.divf %11, %22 : f64 + %24 = arith.mulf %2, %7 : f64 + %25 = arith.mulf %1, %8 : f64 + %26 = arith.subf %24, %25 : f64 + %27 = arith.divf %26, %22 : f64 + %28 = arith.mulf %1, %5 : f64 + %29 = arith.mulf %2, %4 : f64 + %30 = arith.subf %28, %29 : f64 + %31 = arith.divf %30, %22 : f64 + %32 = affine.load %arg4[%arg7 + %arg6 * 1125] : memref + %33 = affine.load %arg4[%arg7 + %arg6 * 1125 + 250] : memref + %34 = affine.load %arg4[%arg7 + %arg6 * 1125 + 500] : memref + %35 = affine.load %arg4[%arg7 + %arg6 * 1125 + 625] : memref + %36 = affine.load %arg4[%arg7 + %arg6 * 1125 + 750] : memref + %37 = affine.load %arg4[%arg7 + %arg6 * 1125 + 875] : memref + %38 = affine.load %arg4[%arg7 + %arg6 * 1125 + 1000] : memref + %39 = arith.addf %32, %34 : f64 + %40 = arith.addf %39, %38 : f64 + %41 = affine.load %arg3[%arg7] : memref + %42 = arith.mulf %41, %22 : f64 + %43 = affine.load %arg0[%arg7 + %arg6 * 125] : memref + %44 = affine.load %arg1[%arg7 + %arg6 * 125] : memref + %45 = arith.mulf %43, %31 : f64 + %46 = arith.mulf %45, %40 : f64 + %47 = arith.addf %36, %33 : f64 + %48 = arith.mulf %23, %47 : f64 + %49 = arith.addf %37, %35 : f64 + %50 = arith.mulf %27, %49 : f64 + %51 = arith.addf %48, %50 : f64 + %52 = arith.addf %38, %38 : f64 + %53 = arith.mulf %31, %52 : f64 + %54 = arith.addf %51, %53 : f64 + %55 = arith.mulf %44, %54 : f64 + %56 = arith.addf %46, %55 : f64 + %57 = arith.mulf %42, %56 : f64 + affine.store %57, %arg5[%arg7 + %arg6 * 1125 + 750] : memref + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 125 { + %0 = affine.load %arg2[%arg7 + %arg6 * 1125] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 1125 + 125] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 1125 + 250] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 1125 + 375] : memref + %4 = affine.load %arg2[%arg7 + %arg6 * 1125 + 500] : memref + %5 = affine.load %arg2[%arg7 + %arg6 * 1125 + 625] : memref + %6 = affine.load %arg2[%arg7 + %arg6 * 1125 + 750] : memref + %7 = affine.load %arg2[%arg7 + %arg6 * 1125 + 875] : memref + %8 = affine.load %arg2[%arg7 + %arg6 * 1125 + 1000] : memref + %9 = arith.mulf %4, %8 : f64 + %10 = arith.mulf %5, %7 : f64 + %11 = arith.subf %9, %10 : f64 + %12 = arith.mulf %0, %11 : f64 + %13 = arith.mulf %3, %8 : f64 + %14 = arith.mulf %5, %6 : f64 + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %1, %15 : f64 + %17 = arith.subf %12, %16 : f64 + %18 = arith.mulf %3, %7 : f64 + %19 = arith.mulf %4, %6 : f64 + %20 = arith.subf %18, %19 : f64 + %21 = arith.mulf %2, %20 : f64 + %22 = arith.addf %17, %21 : f64 + %23 = arith.subf %14, %13 : f64 + %24 = arith.divf %23, %22 : f64 + %25 = arith.mulf %0, %8 : f64 + %26 = arith.mulf %2, %6 : f64 + %27 = arith.subf %25, %26 : f64 + %28 = arith.divf %27, %22 : f64 + %29 = arith.mulf %2, %3 : f64 + %30 = arith.mulf %0, %5 : f64 + %31 = arith.subf %29, %30 : f64 + %32 = arith.divf %31, %22 : f64 + %33 = affine.load %arg4[%arg7 + %arg6 * 1125] : memref + %34 = affine.load %arg4[%arg7 + %arg6 * 1125 + 125] : memref + %35 = affine.load %arg4[%arg7 + %arg6 * 1125 + 250] : memref + %36 = affine.load %arg4[%arg7 + %arg6 * 1125 + 375] : memref + %37 = affine.load %arg4[%arg7 + %arg6 * 1125 + 500] : memref + %38 = affine.load %arg4[%arg7 + %arg6 * 1125 + 750] : memref + %39 = affine.load %arg4[%arg7 + %arg6 * 1125 + 1000] : memref + %40 = arith.addf %33, %37 : f64 + %41 = arith.addf %40, %39 : f64 + %42 = affine.load %arg3[%arg7] : memref + %43 = arith.mulf %42, %22 : f64 + %44 = affine.load %arg0[%arg7 + %arg6 * 125] : memref + %45 = affine.load %arg1[%arg7 + %arg6 * 125] : memref + %46 = arith.mulf %44, %24 : f64 + %47 = arith.mulf %46, %41 : f64 + %48 = arith.addf %33, %33 : f64 + %49 = arith.mulf %24, %48 : f64 + %50 = arith.addf %34, %36 : f64 + %51 = arith.mulf %28, %50 : f64 + %52 = arith.addf %49, %51 : f64 + %53 = arith.addf %35, %38 : f64 + %54 = arith.mulf %32, %53 : f64 + %55 = arith.addf %52, %54 : f64 + %56 = arith.mulf %45, %55 : f64 + %57 = arith.addf %47, %56 : f64 + %58 = arith.mulf %43, %57 : f64 + affine.store %58, %arg5[%arg7 + %arg6 * 1125 + 125] : memref + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 125 { + %0 = affine.load %arg2[%arg7 + %arg6 * 1125] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 1125 + 125] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 1125 + 250] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 1125 + 375] : memref + %4 = affine.load %arg2[%arg7 + %arg6 * 1125 + 500] : memref + %5 = affine.load %arg2[%arg7 + %arg6 * 1125 + 625] : memref + %6 = affine.load %arg2[%arg7 + %arg6 * 1125 + 750] : memref + %7 = affine.load %arg2[%arg7 + %arg6 * 1125 + 875] : memref + %8 = affine.load %arg2[%arg7 + %arg6 * 1125 + 1000] : memref + %9 = arith.mulf %4, %8 : f64 + %10 = arith.mulf %5, %7 : f64 + %11 = arith.subf %9, %10 : f64 + %12 = arith.mulf %0, %11 : f64 + %13 = arith.mulf %3, %8 : f64 + %14 = arith.mulf %5, %6 : f64 + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %1, %15 : f64 + %17 = arith.subf %12, %16 : f64 + %18 = arith.mulf %3, %7 : f64 + %19 = arith.mulf %4, %6 : f64 + %20 = arith.subf %18, %19 : f64 + %21 = arith.mulf %2, %20 : f64 + %22 = arith.addf %17, %21 : f64 + %23 = arith.subf %14, %13 : f64 + %24 = arith.divf %23, %22 : f64 + %25 = arith.mulf %0, %8 : f64 + %26 = arith.mulf %2, %6 : f64 + %27 = arith.subf %25, %26 : f64 + %28 = arith.divf %27, %22 : f64 + %29 = arith.mulf %2, %3 : f64 + %30 = arith.mulf %0, %5 : f64 + %31 = arith.subf %29, %30 : f64 + %32 = arith.divf %31, %22 : f64 + %33 = affine.load %arg4[%arg7 + %arg6 * 1125] : memref + %34 = affine.load %arg4[%arg7 + %arg6 * 1125 + 125] : memref + %35 = affine.load %arg4[%arg7 + %arg6 * 1125 + 375] : memref + %36 = affine.load %arg4[%arg7 + %arg6 * 1125 + 500] : memref + %37 = affine.load %arg4[%arg7 + %arg6 * 1125 + 625] : memref + %38 = affine.load %arg4[%arg7 + %arg6 * 1125 + 875] : memref + %39 = affine.load %arg4[%arg7 + %arg6 * 1125 + 1000] : memref + %40 = arith.addf %33, %36 : f64 + %41 = arith.addf %40, %39 : f64 + %42 = affine.load %arg3[%arg7] : memref + %43 = arith.mulf %42, %22 : f64 + %44 = affine.load %arg0[%arg7 + %arg6 * 125] : memref + %45 = affine.load %arg1[%arg7 + %arg6 * 125] : memref + %46 = arith.mulf %44, %28 : f64 + %47 = arith.mulf %46, %41 : f64 + %48 = arith.addf %35, %34 : f64 + %49 = arith.mulf %24, %48 : f64 + %50 = arith.addf %36, %36 : f64 + %51 = arith.mulf %28, %50 : f64 + %52 = arith.addf %49, %51 : f64 + %53 = arith.addf %37, %38 : f64 + %54 = arith.mulf %32, %53 : f64 + %55 = arith.addf %52, %54 : f64 + %56 = arith.mulf %45, %55 : f64 + %57 = arith.addf %47, %56 : f64 + %58 = arith.mulf %43, %57 : f64 + affine.store %58, %arg5[%arg7 + %arg6 * 1125 + 500] : memref + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 125 { + %0 = affine.load %arg2[%arg7 + %arg6 * 1125] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 1125 + 125] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 1125 + 250] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 1125 + 375] : memref + %4 = affine.load %arg2[%arg7 + %arg6 * 1125 + 500] : memref + %5 = affine.load %arg2[%arg7 + %arg6 * 1125 + 625] : memref + %6 = affine.load %arg2[%arg7 + %arg6 * 1125 + 750] : memref + %7 = affine.load %arg2[%arg7 + %arg6 * 1125 + 875] : memref + %8 = affine.load %arg2[%arg7 + %arg6 * 1125 + 1000] : memref + %9 = arith.mulf %4, %8 : f64 + %10 = arith.mulf %5, %7 : f64 + %11 = arith.subf %9, %10 : f64 + %12 = arith.mulf %0, %11 : f64 + %13 = arith.mulf %3, %8 : f64 + %14 = arith.mulf %5, %6 : f64 + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %1, %15 : f64 + %17 = arith.subf %12, %16 : f64 + %18 = arith.mulf %3, %7 : f64 + %19 = arith.mulf %4, %6 : f64 + %20 = arith.subf %18, %19 : f64 + %21 = arith.mulf %2, %20 : f64 + %22 = arith.addf %17, %21 : f64 + %23 = arith.subf %14, %13 : f64 + %24 = arith.divf %23, %22 : f64 + %25 = arith.mulf %0, %8 : f64 + %26 = arith.mulf %2, %6 : f64 + %27 = arith.subf %25, %26 : f64 + %28 = arith.divf %27, %22 : f64 + %29 = arith.mulf %2, %3 : f64 + %30 = arith.mulf %0, %5 : f64 + %31 = arith.subf %29, %30 : f64 + %32 = arith.divf %31, %22 : f64 + %33 = affine.load %arg4[%arg7 + %arg6 * 1125] : memref + %34 = affine.load %arg4[%arg7 + %arg6 * 1125 + 250] : memref + %35 = affine.load %arg4[%arg7 + %arg6 * 1125 + 500] : memref + %36 = affine.load %arg4[%arg7 + %arg6 * 1125 + 625] : memref + %37 = affine.load %arg4[%arg7 + %arg6 * 1125 + 750] : memref + %38 = affine.load %arg4[%arg7 + %arg6 * 1125 + 875] : memref + %39 = affine.load %arg4[%arg7 + %arg6 * 1125 + 1000] : memref + %40 = arith.addf %33, %35 : f64 + %41 = arith.addf %40, %39 : f64 + %42 = affine.load %arg3[%arg7] : memref + %43 = arith.mulf %42, %22 : f64 + %44 = affine.load %arg0[%arg7 + %arg6 * 125] : memref + %45 = affine.load %arg1[%arg7 + %arg6 * 125] : memref + %46 = arith.mulf %44, %32 : f64 + %47 = arith.mulf %46, %41 : f64 + %48 = arith.addf %37, %34 : f64 + %49 = arith.mulf %24, %48 : f64 + %50 = arith.addf %38, %36 : f64 + %51 = arith.mulf %28, %50 : f64 + %52 = arith.addf %49, %51 : f64 + %53 = arith.addf %39, %39 : f64 + %54 = arith.mulf %32, %53 : f64 + %55 = arith.addf %52, %54 : f64 + %56 = arith.mulf %45, %55 : f64 + %57 = arith.addf %47, %56 : f64 + %58 = arith.mulf %43, %57 : f64 + affine.store %58, %arg5[%arg7 + %arg6 * 1125 + 875] : memref + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 125 { + %0 = affine.load %arg2[%arg7 + %arg6 * 1125] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 1125 + 125] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 1125 + 250] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 1125 + 375] : memref + %4 = affine.load %arg2[%arg7 + %arg6 * 1125 + 500] : memref + %5 = affine.load %arg2[%arg7 + %arg6 * 1125 + 625] : memref + %6 = affine.load %arg2[%arg7 + %arg6 * 1125 + 750] : memref + %7 = affine.load %arg2[%arg7 + %arg6 * 1125 + 875] : memref + %8 = affine.load %arg2[%arg7 + %arg6 * 1125 + 1000] : memref + %9 = arith.mulf %4, %8 : f64 + %10 = arith.mulf %5, %7 : f64 + %11 = arith.subf %9, %10 : f64 + %12 = arith.mulf %0, %11 : f64 + %13 = arith.mulf %3, %8 : f64 + %14 = arith.mulf %5, %6 : f64 + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %1, %15 : f64 + %17 = arith.subf %12, %16 : f64 + %18 = arith.mulf %3, %7 : f64 + %19 = arith.mulf %4, %6 : f64 + %20 = arith.subf %18, %19 : f64 + %21 = arith.mulf %2, %20 : f64 + %22 = arith.addf %17, %21 : f64 + %23 = arith.divf %20, %22 : f64 + %24 = arith.mulf %1, %6 : f64 + %25 = arith.mulf %0, %7 : f64 + %26 = arith.subf %24, %25 : f64 + %27 = arith.divf %26, %22 : f64 + %28 = arith.mulf %0, %4 : f64 + %29 = arith.mulf %1, %3 : f64 + %30 = arith.subf %28, %29 : f64 + %31 = arith.divf %30, %22 : f64 + %32 = affine.load %arg4[%arg7 + %arg6 * 1125] : memref + %33 = affine.load %arg4[%arg7 + %arg6 * 1125 + 125] : memref + %34 = affine.load %arg4[%arg7 + %arg6 * 1125 + 250] : memref + %35 = affine.load %arg4[%arg7 + %arg6 * 1125 + 375] : memref + %36 = affine.load %arg4[%arg7 + %arg6 * 1125 + 500] : memref + %37 = affine.load %arg4[%arg7 + %arg6 * 1125 + 750] : memref + %38 = affine.load %arg4[%arg7 + %arg6 * 1125 + 1000] : memref + %39 = arith.addf %32, %36 : f64 + %40 = arith.addf %39, %38 : f64 + %41 = affine.load %arg3[%arg7] : memref + %42 = arith.mulf %41, %22 : f64 + %43 = affine.load %arg0[%arg7 + %arg6 * 125] : memref + %44 = affine.load %arg1[%arg7 + %arg6 * 125] : memref + %45 = arith.mulf %43, %23 : f64 + %46 = arith.mulf %45, %40 : f64 + %47 = arith.addf %32, %32 : f64 + %48 = arith.mulf %23, %47 : f64 + %49 = arith.addf %33, %35 : f64 + %50 = arith.mulf %27, %49 : f64 + %51 = arith.addf %48, %50 : f64 + %52 = arith.addf %34, %37 : f64 + %53 = arith.mulf %31, %52 : f64 + %54 = arith.addf %51, %53 : f64 + %55 = arith.mulf %44, %54 : f64 + %56 = arith.addf %46, %55 : f64 + %57 = arith.mulf %42, %56 : f64 + affine.store %57, %arg5[%arg7 + %arg6 * 1125 + 250] : memref + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 125 { + %0 = affine.load %arg2[%arg7 + %arg6 * 1125] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 1125 + 125] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 1125 + 250] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 1125 + 375] : memref + %4 = affine.load %arg2[%arg7 + %arg6 * 1125 + 500] : memref + %5 = affine.load %arg2[%arg7 + %arg6 * 1125 + 625] : memref + %6 = affine.load %arg2[%arg7 + %arg6 * 1125 + 750] : memref + %7 = affine.load %arg2[%arg7 + %arg6 * 1125 + 875] : memref + %8 = affine.load %arg2[%arg7 + %arg6 * 1125 + 1000] : memref + %9 = arith.mulf %4, %8 : f64 + %10 = arith.mulf %5, %7 : f64 + %11 = arith.subf %9, %10 : f64 + %12 = arith.mulf %0, %11 : f64 + %13 = arith.mulf %3, %8 : f64 + %14 = arith.mulf %5, %6 : f64 + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %1, %15 : f64 + %17 = arith.subf %12, %16 : f64 + %18 = arith.mulf %3, %7 : f64 + %19 = arith.mulf %4, %6 : f64 + %20 = arith.subf %18, %19 : f64 + %21 = arith.mulf %2, %20 : f64 + %22 = arith.addf %17, %21 : f64 + %23 = arith.divf %20, %22 : f64 + %24 = arith.mulf %1, %6 : f64 + %25 = arith.mulf %0, %7 : f64 + %26 = arith.subf %24, %25 : f64 + %27 = arith.divf %26, %22 : f64 + %28 = arith.mulf %0, %4 : f64 + %29 = arith.mulf %1, %3 : f64 + %30 = arith.subf %28, %29 : f64 + %31 = arith.divf %30, %22 : f64 + %32 = affine.load %arg4[%arg7 + %arg6 * 1125] : memref + %33 = affine.load %arg4[%arg7 + %arg6 * 1125 + 125] : memref + %34 = affine.load %arg4[%arg7 + %arg6 * 1125 + 375] : memref + %35 = affine.load %arg4[%arg7 + %arg6 * 1125 + 500] : memref + %36 = affine.load %arg4[%arg7 + %arg6 * 1125 + 625] : memref + %37 = affine.load %arg4[%arg7 + %arg6 * 1125 + 875] : memref + %38 = affine.load %arg4[%arg7 + %arg6 * 1125 + 1000] : memref + %39 = arith.addf %32, %35 : f64 + %40 = arith.addf %39, %38 : f64 + %41 = affine.load %arg3[%arg7] : memref + %42 = arith.mulf %41, %22 : f64 + %43 = affine.load %arg0[%arg7 + %arg6 * 125] : memref + %44 = affine.load %arg1[%arg7 + %arg6 * 125] : memref + %45 = arith.mulf %43, %27 : f64 + %46 = arith.mulf %45, %40 : f64 + %47 = arith.addf %34, %33 : f64 + %48 = arith.mulf %23, %47 : f64 + %49 = arith.addf %35, %35 : f64 + %50 = arith.mulf %27, %49 : f64 + %51 = arith.addf %48, %50 : f64 + %52 = arith.addf %36, %37 : f64 + %53 = arith.mulf %31, %52 : f64 + %54 = arith.addf %51, %53 : f64 + %55 = arith.mulf %44, %54 : f64 + %56 = arith.addf %46, %55 : f64 + %57 = arith.mulf %42, %56 : f64 + affine.store %57, %arg5[%arg7 + %arg6 * 1125 + 625] : memref + } + } + affine.for %arg6 = 0 to 2 { + affine.for %arg7 = 0 to 125 { + %0 = affine.load %arg2[%arg7 + %arg6 * 1125] : memref + %1 = affine.load %arg2[%arg7 + %arg6 * 1125 + 125] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 1125 + 250] : memref + %3 = affine.load %arg2[%arg7 + %arg6 * 1125 + 375] : memref + %4 = affine.load %arg2[%arg7 + %arg6 * 1125 + 500] : memref + %5 = affine.load %arg2[%arg7 + %arg6 * 1125 + 625] : memref + %6 = affine.load %arg2[%arg7 + %arg6 * 1125 + 750] : memref + %7 = affine.load %arg2[%arg7 + %arg6 * 1125 + 875] : memref + %8 = affine.load %arg2[%arg7 + %arg6 * 1125 + 1000] : memref + %9 = arith.mulf %4, %8 : f64 + %10 = arith.mulf %5, %7 : f64 + %11 = arith.subf %9, %10 : f64 + %12 = arith.mulf %0, %11 : f64 + %13 = arith.mulf %3, %8 : f64 + %14 = arith.mulf %5, %6 : f64 + %15 = arith.subf %13, %14 : f64 + %16 = arith.mulf %1, %15 : f64 + %17 = arith.subf %12, %16 : f64 + %18 = arith.mulf %3, %7 : f64 + %19 = arith.mulf %4, %6 : f64 + %20 = arith.subf %18, %19 : f64 + %21 = arith.mulf %2, %20 : f64 + %22 = arith.addf %17, %21 : f64 + %23 = arith.divf %20, %22 : f64 + %24 = arith.mulf %1, %6 : f64 + %25 = arith.mulf %0, %7 : f64 + %26 = arith.subf %24, %25 : f64 + %27 = arith.divf %26, %22 : f64 + %28 = arith.mulf %0, %4 : f64 + %29 = arith.mulf %1, %3 : f64 + %30 = arith.subf %28, %29 : f64 + %31 = arith.divf %30, %22 : f64 + %32 = affine.load %arg4[%arg7 + %arg6 * 1125] : memref + %33 = affine.load %arg4[%arg7 + %arg6 * 1125 + 250] : memref + %34 = affine.load %arg4[%arg7 + %arg6 * 1125 + 500] : memref + %35 = affine.load %arg4[%arg7 + %arg6 * 1125 + 625] : memref + %36 = affine.load %arg4[%arg7 + %arg6 * 1125 + 750] : memref + %37 = affine.load %arg4[%arg7 + %arg6 * 1125 + 875] : memref + %38 = affine.load %arg4[%arg7 + %arg6 * 1125 + 1000] : memref + %39 = arith.addf %32, %34 : f64 + %40 = arith.addf %39, %38 : f64 + %41 = affine.load %arg3[%arg7] : memref + %42 = arith.mulf %41, %22 : f64 + %43 = affine.load %arg0[%arg7 + %arg6 * 125] : memref + %44 = affine.load %arg1[%arg7 + %arg6 * 125] : memref + %45 = arith.mulf %43, %31 : f64 + %46 = arith.mulf %45, %40 : f64 + %47 = arith.addf %36, %33 : f64 + %48 = arith.mulf %23, %47 : f64 + %49 = arith.addf %37, %35 : f64 + %50 = arith.mulf %27, %49 : f64 + %51 = arith.addf %48, %50 : f64 + %52 = arith.addf %38, %38 : f64 + %53 = arith.mulf %31, %52 : f64 + %54 = arith.addf %51, %53 : f64 + %55 = arith.mulf %44, %54 : f64 + %56 = arith.addf %46, %55 : f64 + %57 = arith.mulf %42, %56 : f64 + affine.store %57, %arg5[%arg7 + %arg6 * 1125 + 1000] : memref + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/elasticity_qpoint_3d_scalarized__normalized.raised.mlir b/issues/mfem_c_kernels/results/elasticity_qpoint_3d_scalarized__normalized.raised.mlir new file mode 100644 index 000000000000..587a8b326b7d --- /dev/null +++ b/issues/mfem_c_kernels/results/elasticity_qpoint_3d_scalarized__normalized.raised.mlir @@ -0,0 +1,580 @@ +#map = affine_map<(d0, d1) -> (d1 + d0 * 1125)> +#map1 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 125)> +#map2 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 250)> +#map3 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 375)> +#map4 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 500)> +#map5 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 625)> +#map6 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 750)> +#map7 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 875)> +#map8 = affine_map<(d0, d1) -> (d1 + d0 * 1125 + 1000)> +#map9 = affine_map<(d0, d1) -> (d1 + d0 * 125)> +#map10 = affine_map<(d0, d1) -> (d0, d1)> +#map11 = affine_map<(d0, d1) -> (d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_elasticity_qpoint_3d_scalarized(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c125 = arith.constant 125 : index + %0 = polygeist.submap(%arg2, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %1 = polygeist.submap(%arg2, %c2, %c125) {map = #map1} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg2, %c2, %c125) {map = #map2} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg2, %c2, %c125) {map = #map3} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg2, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg2, %c2, %c125) {map = #map5} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg2, %c2, %c125) {map = #map6} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg2, %c2, %c125) {map = #map7} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg2, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg4, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %10 = polygeist.submap(%arg4, %c2, %c125) {map = #map1} : (memref, index, index) -> memref + %11 = polygeist.submap(%arg4, %c2, %c125) {map = #map2} : (memref, index, index) -> memref + %12 = polygeist.submap(%arg4, %c2, %c125) {map = #map3} : (memref, index, index) -> memref + %13 = polygeist.submap(%arg4, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %14 = polygeist.submap(%arg4, %c2, %c125) {map = #map6} : (memref, index, index) -> memref + %15 = polygeist.submap(%arg4, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %16 = polygeist.submap(%arg0, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %17 = polygeist.submap(%arg1, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %18 = polygeist.submap(%arg5, %c2, %c125) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"]} ins(%0, %1, %2, %3, %4, %5, %6, %7, %8, %9, %10, %11, %12, %13, %14, %15, %arg3, %16, %17 : memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%18 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %171 = arith.mulf %in_3, %in_7 : f64 + %172 = arith.mulf %in_4, %in_6 : f64 + %173 = arith.subf %171, %172 : f64 + %174 = arith.mulf %in, %173 : f64 + %175 = arith.mulf %in_2, %in_7 : f64 + %176 = arith.mulf %in_4, %in_5 : f64 + %177 = arith.subf %175, %176 : f64 + %178 = arith.mulf %in_0, %177 : f64 + %179 = arith.subf %174, %178 : f64 + %180 = arith.mulf %in_2, %in_6 : f64 + %181 = arith.mulf %in_3, %in_5 : f64 + %182 = arith.subf %180, %181 : f64 + %183 = arith.mulf %in_1, %182 : f64 + %184 = arith.addf %179, %183 : f64 + %185 = arith.divf %173, %184 : f64 + %186 = arith.mulf %in_1, %in_6 : f64 + %187 = arith.mulf %in_0, %in_7 : f64 + %188 = arith.subf %186, %187 : f64 + %189 = arith.divf %188, %184 : f64 + %190 = arith.mulf %in_0, %in_4 : f64 + %191 = arith.mulf %in_1, %in_3 : f64 + %192 = arith.subf %190, %191 : f64 + %193 = arith.divf %192, %184 : f64 + %194 = arith.addf %in_8, %in_12 : f64 + %195 = arith.addf %194, %in_14 : f64 + %196 = arith.mulf %in_15, %184 : f64 + %197 = arith.mulf %in_16, %185 : f64 + %198 = arith.mulf %197, %195 : f64 + %199 = arith.addf %in_8, %in_8 : f64 + %200 = arith.mulf %185, %199 : f64 + %201 = arith.addf %in_9, %in_11 : f64 + %202 = arith.mulf %189, %201 : f64 + %203 = arith.addf %200, %202 : f64 + %204 = arith.addf %in_10, %in_13 : f64 + %205 = arith.mulf %193, %204 : f64 + %206 = arith.addf %203, %205 : f64 + %207 = arith.mulf %in_17, %206 : f64 + %208 = arith.addf %198, %207 : f64 + %209 = arith.mulf %196, %208 : f64 + linalg.yield %209 : f64 + } + %19 = polygeist.submap(%arg2, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %20 = polygeist.submap(%arg2, %c2, %c125) {map = #map1} : (memref, index, index) -> memref + %21 = polygeist.submap(%arg2, %c2, %c125) {map = #map2} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg2, %c2, %c125) {map = #map3} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg2, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %24 = polygeist.submap(%arg2, %c2, %c125) {map = #map5} : (memref, index, index) -> memref + %25 = polygeist.submap(%arg2, %c2, %c125) {map = #map6} : (memref, index, index) -> memref + %26 = polygeist.submap(%arg2, %c2, %c125) {map = #map7} : (memref, index, index) -> memref + %27 = polygeist.submap(%arg2, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %28 = polygeist.submap(%arg4, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %29 = polygeist.submap(%arg4, %c2, %c125) {map = #map1} : (memref, index, index) -> memref + %30 = polygeist.submap(%arg4, %c2, %c125) {map = #map3} : (memref, index, index) -> memref + %31 = polygeist.submap(%arg4, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %32 = polygeist.submap(%arg4, %c2, %c125) {map = #map5} : (memref, index, index) -> memref + %33 = polygeist.submap(%arg4, %c2, %c125) {map = #map7} : (memref, index, index) -> memref + %34 = polygeist.submap(%arg4, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %35 = polygeist.submap(%arg0, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %36 = polygeist.submap(%arg1, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %37 = polygeist.submap(%arg5, %c2, %c125) {map = #map3} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"]} ins(%19, %20, %21, %22, %23, %24, %25, %26, %27, %28, %29, %30, %31, %32, %33, %34, %arg3, %35, %36 : memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%37 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %171 = arith.mulf %in_3, %in_7 : f64 + %172 = arith.mulf %in_4, %in_6 : f64 + %173 = arith.subf %171, %172 : f64 + %174 = arith.mulf %in, %173 : f64 + %175 = arith.mulf %in_2, %in_7 : f64 + %176 = arith.mulf %in_4, %in_5 : f64 + %177 = arith.subf %175, %176 : f64 + %178 = arith.mulf %in_0, %177 : f64 + %179 = arith.subf %174, %178 : f64 + %180 = arith.mulf %in_2, %in_6 : f64 + %181 = arith.mulf %in_3, %in_5 : f64 + %182 = arith.subf %180, %181 : f64 + %183 = arith.mulf %in_1, %182 : f64 + %184 = arith.addf %179, %183 : f64 + %185 = arith.divf %173, %184 : f64 + %186 = arith.mulf %in_1, %in_6 : f64 + %187 = arith.mulf %in_0, %in_7 : f64 + %188 = arith.subf %186, %187 : f64 + %189 = arith.divf %188, %184 : f64 + %190 = arith.mulf %in_0, %in_4 : f64 + %191 = arith.mulf %in_1, %in_3 : f64 + %192 = arith.subf %190, %191 : f64 + %193 = arith.divf %192, %184 : f64 + %194 = arith.addf %in_8, %in_11 : f64 + %195 = arith.addf %194, %in_14 : f64 + %196 = arith.mulf %in_15, %184 : f64 + %197 = arith.mulf %in_16, %189 : f64 + %198 = arith.mulf %197, %195 : f64 + %199 = arith.addf %in_10, %in_9 : f64 + %200 = arith.mulf %185, %199 : f64 + %201 = arith.addf %in_11, %in_11 : f64 + %202 = arith.mulf %189, %201 : f64 + %203 = arith.addf %200, %202 : f64 + %204 = arith.addf %in_12, %in_13 : f64 + %205 = arith.mulf %193, %204 : f64 + %206 = arith.addf %203, %205 : f64 + %207 = arith.mulf %in_17, %206 : f64 + %208 = arith.addf %198, %207 : f64 + %209 = arith.mulf %196, %208 : f64 + linalg.yield %209 : f64 + } + %38 = polygeist.submap(%arg2, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %39 = polygeist.submap(%arg2, %c2, %c125) {map = #map1} : (memref, index, index) -> memref + %40 = polygeist.submap(%arg2, %c2, %c125) {map = #map2} : (memref, index, index) -> memref + %41 = polygeist.submap(%arg2, %c2, %c125) {map = #map3} : (memref, index, index) -> memref + %42 = polygeist.submap(%arg2, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %43 = polygeist.submap(%arg2, %c2, %c125) {map = #map5} : (memref, index, index) -> memref + %44 = polygeist.submap(%arg2, %c2, %c125) {map = #map6} : (memref, index, index) -> memref + %45 = polygeist.submap(%arg2, %c2, %c125) {map = #map7} : (memref, index, index) -> memref + %46 = polygeist.submap(%arg2, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %47 = polygeist.submap(%arg4, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %48 = polygeist.submap(%arg4, %c2, %c125) {map = #map2} : (memref, index, index) -> memref + %49 = polygeist.submap(%arg4, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %50 = polygeist.submap(%arg4, %c2, %c125) {map = #map5} : (memref, index, index) -> memref + %51 = polygeist.submap(%arg4, %c2, %c125) {map = #map6} : (memref, index, index) -> memref + %52 = polygeist.submap(%arg4, %c2, %c125) {map = #map7} : (memref, index, index) -> memref + %53 = polygeist.submap(%arg4, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %54 = polygeist.submap(%arg0, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %55 = polygeist.submap(%arg1, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %56 = polygeist.submap(%arg5, %c2, %c125) {map = #map6} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"]} ins(%38, %39, %40, %41, %42, %43, %44, %45, %46, %47, %48, %49, %50, %51, %52, %53, %arg3, %54, %55 : memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%56 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %171 = arith.mulf %in_3, %in_7 : f64 + %172 = arith.mulf %in_4, %in_6 : f64 + %173 = arith.subf %171, %172 : f64 + %174 = arith.mulf %in, %173 : f64 + %175 = arith.mulf %in_2, %in_7 : f64 + %176 = arith.mulf %in_4, %in_5 : f64 + %177 = arith.subf %175, %176 : f64 + %178 = arith.mulf %in_0, %177 : f64 + %179 = arith.subf %174, %178 : f64 + %180 = arith.mulf %in_2, %in_6 : f64 + %181 = arith.mulf %in_3, %in_5 : f64 + %182 = arith.subf %180, %181 : f64 + %183 = arith.mulf %in_1, %182 : f64 + %184 = arith.addf %179, %183 : f64 + %185 = arith.divf %173, %184 : f64 + %186 = arith.mulf %in_1, %in_6 : f64 + %187 = arith.mulf %in_0, %in_7 : f64 + %188 = arith.subf %186, %187 : f64 + %189 = arith.divf %188, %184 : f64 + %190 = arith.mulf %in_0, %in_4 : f64 + %191 = arith.mulf %in_1, %in_3 : f64 + %192 = arith.subf %190, %191 : f64 + %193 = arith.divf %192, %184 : f64 + %194 = arith.addf %in_8, %in_10 : f64 + %195 = arith.addf %194, %in_14 : f64 + %196 = arith.mulf %in_15, %184 : f64 + %197 = arith.mulf %in_16, %193 : f64 + %198 = arith.mulf %197, %195 : f64 + %199 = arith.addf %in_12, %in_9 : f64 + %200 = arith.mulf %185, %199 : f64 + %201 = arith.addf %in_13, %in_11 : f64 + %202 = arith.mulf %189, %201 : f64 + %203 = arith.addf %200, %202 : f64 + %204 = arith.addf %in_14, %in_14 : f64 + %205 = arith.mulf %193, %204 : f64 + %206 = arith.addf %203, %205 : f64 + %207 = arith.mulf %in_17, %206 : f64 + %208 = arith.addf %198, %207 : f64 + %209 = arith.mulf %196, %208 : f64 + linalg.yield %209 : f64 + } + %57 = polygeist.submap(%arg2, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %58 = polygeist.submap(%arg2, %c2, %c125) {map = #map1} : (memref, index, index) -> memref + %59 = polygeist.submap(%arg2, %c2, %c125) {map = #map2} : (memref, index, index) -> memref + %60 = polygeist.submap(%arg2, %c2, %c125) {map = #map3} : (memref, index, index) -> memref + %61 = polygeist.submap(%arg2, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %62 = polygeist.submap(%arg2, %c2, %c125) {map = #map5} : (memref, index, index) -> memref + %63 = polygeist.submap(%arg2, %c2, %c125) {map = #map6} : (memref, index, index) -> memref + %64 = polygeist.submap(%arg2, %c2, %c125) {map = #map7} : (memref, index, index) -> memref + %65 = polygeist.submap(%arg2, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %66 = polygeist.submap(%arg4, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %67 = polygeist.submap(%arg4, %c2, %c125) {map = #map1} : (memref, index, index) -> memref + %68 = polygeist.submap(%arg4, %c2, %c125) {map = #map2} : (memref, index, index) -> memref + %69 = polygeist.submap(%arg4, %c2, %c125) {map = #map3} : (memref, index, index) -> memref + %70 = polygeist.submap(%arg4, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %71 = polygeist.submap(%arg4, %c2, %c125) {map = #map6} : (memref, index, index) -> memref + %72 = polygeist.submap(%arg4, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %73 = polygeist.submap(%arg0, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %74 = polygeist.submap(%arg1, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %75 = polygeist.submap(%arg5, %c2, %c125) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"]} ins(%57, %58, %59, %60, %61, %62, %63, %64, %65, %66, %67, %68, %69, %70, %71, %72, %arg3, %73, %74 : memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%75 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %171 = arith.mulf %in_3, %in_7 : f64 + %172 = arith.mulf %in_4, %in_6 : f64 + %173 = arith.subf %171, %172 : f64 + %174 = arith.mulf %in, %173 : f64 + %175 = arith.mulf %in_2, %in_7 : f64 + %176 = arith.mulf %in_4, %in_5 : f64 + %177 = arith.subf %175, %176 : f64 + %178 = arith.mulf %in_0, %177 : f64 + %179 = arith.subf %174, %178 : f64 + %180 = arith.mulf %in_2, %in_6 : f64 + %181 = arith.mulf %in_3, %in_5 : f64 + %182 = arith.subf %180, %181 : f64 + %183 = arith.mulf %in_1, %182 : f64 + %184 = arith.addf %179, %183 : f64 + %185 = arith.subf %176, %175 : f64 + %186 = arith.divf %185, %184 : f64 + %187 = arith.mulf %in, %in_7 : f64 + %188 = arith.mulf %in_1, %in_5 : f64 + %189 = arith.subf %187, %188 : f64 + %190 = arith.divf %189, %184 : f64 + %191 = arith.mulf %in_1, %in_2 : f64 + %192 = arith.mulf %in, %in_4 : f64 + %193 = arith.subf %191, %192 : f64 + %194 = arith.divf %193, %184 : f64 + %195 = arith.addf %in_8, %in_12 : f64 + %196 = arith.addf %195, %in_14 : f64 + %197 = arith.mulf %in_15, %184 : f64 + %198 = arith.mulf %in_16, %186 : f64 + %199 = arith.mulf %198, %196 : f64 + %200 = arith.addf %in_8, %in_8 : f64 + %201 = arith.mulf %186, %200 : f64 + %202 = arith.addf %in_9, %in_11 : f64 + %203 = arith.mulf %190, %202 : f64 + %204 = arith.addf %201, %203 : f64 + %205 = arith.addf %in_10, %in_13 : f64 + %206 = arith.mulf %194, %205 : f64 + %207 = arith.addf %204, %206 : f64 + %208 = arith.mulf %in_17, %207 : f64 + %209 = arith.addf %199, %208 : f64 + %210 = arith.mulf %197, %209 : f64 + linalg.yield %210 : f64 + } + %76 = polygeist.submap(%arg2, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %77 = polygeist.submap(%arg2, %c2, %c125) {map = #map1} : (memref, index, index) -> memref + %78 = polygeist.submap(%arg2, %c2, %c125) {map = #map2} : (memref, index, index) -> memref + %79 = polygeist.submap(%arg2, %c2, %c125) {map = #map3} : (memref, index, index) -> memref + %80 = polygeist.submap(%arg2, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %81 = polygeist.submap(%arg2, %c2, %c125) {map = #map5} : (memref, index, index) -> memref + %82 = polygeist.submap(%arg2, %c2, %c125) {map = #map6} : (memref, index, index) -> memref + %83 = polygeist.submap(%arg2, %c2, %c125) {map = #map7} : (memref, index, index) -> memref + %84 = polygeist.submap(%arg2, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %85 = polygeist.submap(%arg4, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %86 = polygeist.submap(%arg4, %c2, %c125) {map = #map1} : (memref, index, index) -> memref + %87 = polygeist.submap(%arg4, %c2, %c125) {map = #map3} : (memref, index, index) -> memref + %88 = polygeist.submap(%arg4, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %89 = polygeist.submap(%arg4, %c2, %c125) {map = #map5} : (memref, index, index) -> memref + %90 = polygeist.submap(%arg4, %c2, %c125) {map = #map7} : (memref, index, index) -> memref + %91 = polygeist.submap(%arg4, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %92 = polygeist.submap(%arg0, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %93 = polygeist.submap(%arg1, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %94 = polygeist.submap(%arg5, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"]} ins(%76, %77, %78, %79, %80, %81, %82, %83, %84, %85, %86, %87, %88, %89, %90, %91, %arg3, %92, %93 : memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%94 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %171 = arith.mulf %in_3, %in_7 : f64 + %172 = arith.mulf %in_4, %in_6 : f64 + %173 = arith.subf %171, %172 : f64 + %174 = arith.mulf %in, %173 : f64 + %175 = arith.mulf %in_2, %in_7 : f64 + %176 = arith.mulf %in_4, %in_5 : f64 + %177 = arith.subf %175, %176 : f64 + %178 = arith.mulf %in_0, %177 : f64 + %179 = arith.subf %174, %178 : f64 + %180 = arith.mulf %in_2, %in_6 : f64 + %181 = arith.mulf %in_3, %in_5 : f64 + %182 = arith.subf %180, %181 : f64 + %183 = arith.mulf %in_1, %182 : f64 + %184 = arith.addf %179, %183 : f64 + %185 = arith.subf %176, %175 : f64 + %186 = arith.divf %185, %184 : f64 + %187 = arith.mulf %in, %in_7 : f64 + %188 = arith.mulf %in_1, %in_5 : f64 + %189 = arith.subf %187, %188 : f64 + %190 = arith.divf %189, %184 : f64 + %191 = arith.mulf %in_1, %in_2 : f64 + %192 = arith.mulf %in, %in_4 : f64 + %193 = arith.subf %191, %192 : f64 + %194 = arith.divf %193, %184 : f64 + %195 = arith.addf %in_8, %in_11 : f64 + %196 = arith.addf %195, %in_14 : f64 + %197 = arith.mulf %in_15, %184 : f64 + %198 = arith.mulf %in_16, %190 : f64 + %199 = arith.mulf %198, %196 : f64 + %200 = arith.addf %in_10, %in_9 : f64 + %201 = arith.mulf %186, %200 : f64 + %202 = arith.addf %in_11, %in_11 : f64 + %203 = arith.mulf %190, %202 : f64 + %204 = arith.addf %201, %203 : f64 + %205 = arith.addf %in_12, %in_13 : f64 + %206 = arith.mulf %194, %205 : f64 + %207 = arith.addf %204, %206 : f64 + %208 = arith.mulf %in_17, %207 : f64 + %209 = arith.addf %199, %208 : f64 + %210 = arith.mulf %197, %209 : f64 + linalg.yield %210 : f64 + } + %95 = polygeist.submap(%arg2, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %96 = polygeist.submap(%arg2, %c2, %c125) {map = #map1} : (memref, index, index) -> memref + %97 = polygeist.submap(%arg2, %c2, %c125) {map = #map2} : (memref, index, index) -> memref + %98 = polygeist.submap(%arg2, %c2, %c125) {map = #map3} : (memref, index, index) -> memref + %99 = polygeist.submap(%arg2, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %100 = polygeist.submap(%arg2, %c2, %c125) {map = #map5} : (memref, index, index) -> memref + %101 = polygeist.submap(%arg2, %c2, %c125) {map = #map6} : (memref, index, index) -> memref + %102 = polygeist.submap(%arg2, %c2, %c125) {map = #map7} : (memref, index, index) -> memref + %103 = polygeist.submap(%arg2, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %104 = polygeist.submap(%arg4, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %105 = polygeist.submap(%arg4, %c2, %c125) {map = #map2} : (memref, index, index) -> memref + %106 = polygeist.submap(%arg4, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %107 = polygeist.submap(%arg4, %c2, %c125) {map = #map5} : (memref, index, index) -> memref + %108 = polygeist.submap(%arg4, %c2, %c125) {map = #map6} : (memref, index, index) -> memref + %109 = polygeist.submap(%arg4, %c2, %c125) {map = #map7} : (memref, index, index) -> memref + %110 = polygeist.submap(%arg4, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %111 = polygeist.submap(%arg0, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %112 = polygeist.submap(%arg1, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %113 = polygeist.submap(%arg5, %c2, %c125) {map = #map7} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"]} ins(%95, %96, %97, %98, %99, %100, %101, %102, %103, %104, %105, %106, %107, %108, %109, %110, %arg3, %111, %112 : memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%113 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %171 = arith.mulf %in_3, %in_7 : f64 + %172 = arith.mulf %in_4, %in_6 : f64 + %173 = arith.subf %171, %172 : f64 + %174 = arith.mulf %in, %173 : f64 + %175 = arith.mulf %in_2, %in_7 : f64 + %176 = arith.mulf %in_4, %in_5 : f64 + %177 = arith.subf %175, %176 : f64 + %178 = arith.mulf %in_0, %177 : f64 + %179 = arith.subf %174, %178 : f64 + %180 = arith.mulf %in_2, %in_6 : f64 + %181 = arith.mulf %in_3, %in_5 : f64 + %182 = arith.subf %180, %181 : f64 + %183 = arith.mulf %in_1, %182 : f64 + %184 = arith.addf %179, %183 : f64 + %185 = arith.subf %176, %175 : f64 + %186 = arith.divf %185, %184 : f64 + %187 = arith.mulf %in, %in_7 : f64 + %188 = arith.mulf %in_1, %in_5 : f64 + %189 = arith.subf %187, %188 : f64 + %190 = arith.divf %189, %184 : f64 + %191 = arith.mulf %in_1, %in_2 : f64 + %192 = arith.mulf %in, %in_4 : f64 + %193 = arith.subf %191, %192 : f64 + %194 = arith.divf %193, %184 : f64 + %195 = arith.addf %in_8, %in_10 : f64 + %196 = arith.addf %195, %in_14 : f64 + %197 = arith.mulf %in_15, %184 : f64 + %198 = arith.mulf %in_16, %194 : f64 + %199 = arith.mulf %198, %196 : f64 + %200 = arith.addf %in_12, %in_9 : f64 + %201 = arith.mulf %186, %200 : f64 + %202 = arith.addf %in_13, %in_11 : f64 + %203 = arith.mulf %190, %202 : f64 + %204 = arith.addf %201, %203 : f64 + %205 = arith.addf %in_14, %in_14 : f64 + %206 = arith.mulf %194, %205 : f64 + %207 = arith.addf %204, %206 : f64 + %208 = arith.mulf %in_17, %207 : f64 + %209 = arith.addf %199, %208 : f64 + %210 = arith.mulf %197, %209 : f64 + linalg.yield %210 : f64 + } + %114 = polygeist.submap(%arg2, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %115 = polygeist.submap(%arg2, %c2, %c125) {map = #map1} : (memref, index, index) -> memref + %116 = polygeist.submap(%arg2, %c2, %c125) {map = #map2} : (memref, index, index) -> memref + %117 = polygeist.submap(%arg2, %c2, %c125) {map = #map3} : (memref, index, index) -> memref + %118 = polygeist.submap(%arg2, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %119 = polygeist.submap(%arg2, %c2, %c125) {map = #map5} : (memref, index, index) -> memref + %120 = polygeist.submap(%arg2, %c2, %c125) {map = #map6} : (memref, index, index) -> memref + %121 = polygeist.submap(%arg2, %c2, %c125) {map = #map7} : (memref, index, index) -> memref + %122 = polygeist.submap(%arg2, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %123 = polygeist.submap(%arg4, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %124 = polygeist.submap(%arg4, %c2, %c125) {map = #map1} : (memref, index, index) -> memref + %125 = polygeist.submap(%arg4, %c2, %c125) {map = #map2} : (memref, index, index) -> memref + %126 = polygeist.submap(%arg4, %c2, %c125) {map = #map3} : (memref, index, index) -> memref + %127 = polygeist.submap(%arg4, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %128 = polygeist.submap(%arg4, %c2, %c125) {map = #map6} : (memref, index, index) -> memref + %129 = polygeist.submap(%arg4, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %130 = polygeist.submap(%arg0, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %131 = polygeist.submap(%arg1, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %132 = polygeist.submap(%arg5, %c2, %c125) {map = #map2} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"]} ins(%114, %115, %116, %117, %118, %119, %120, %121, %122, %123, %124, %125, %126, %127, %128, %129, %arg3, %130, %131 : memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%132 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %171 = arith.mulf %in_3, %in_7 : f64 + %172 = arith.mulf %in_4, %in_6 : f64 + %173 = arith.subf %171, %172 : f64 + %174 = arith.mulf %in, %173 : f64 + %175 = arith.mulf %in_2, %in_7 : f64 + %176 = arith.mulf %in_4, %in_5 : f64 + %177 = arith.subf %175, %176 : f64 + %178 = arith.mulf %in_0, %177 : f64 + %179 = arith.subf %174, %178 : f64 + %180 = arith.mulf %in_2, %in_6 : f64 + %181 = arith.mulf %in_3, %in_5 : f64 + %182 = arith.subf %180, %181 : f64 + %183 = arith.mulf %in_1, %182 : f64 + %184 = arith.addf %179, %183 : f64 + %185 = arith.divf %182, %184 : f64 + %186 = arith.mulf %in_0, %in_5 : f64 + %187 = arith.mulf %in, %in_6 : f64 + %188 = arith.subf %186, %187 : f64 + %189 = arith.divf %188, %184 : f64 + %190 = arith.mulf %in, %in_3 : f64 + %191 = arith.mulf %in_0, %in_2 : f64 + %192 = arith.subf %190, %191 : f64 + %193 = arith.divf %192, %184 : f64 + %194 = arith.addf %in_8, %in_12 : f64 + %195 = arith.addf %194, %in_14 : f64 + %196 = arith.mulf %in_15, %184 : f64 + %197 = arith.mulf %in_16, %185 : f64 + %198 = arith.mulf %197, %195 : f64 + %199 = arith.addf %in_8, %in_8 : f64 + %200 = arith.mulf %185, %199 : f64 + %201 = arith.addf %in_9, %in_11 : f64 + %202 = arith.mulf %189, %201 : f64 + %203 = arith.addf %200, %202 : f64 + %204 = arith.addf %in_10, %in_13 : f64 + %205 = arith.mulf %193, %204 : f64 + %206 = arith.addf %203, %205 : f64 + %207 = arith.mulf %in_17, %206 : f64 + %208 = arith.addf %198, %207 : f64 + %209 = arith.mulf %196, %208 : f64 + linalg.yield %209 : f64 + } + %133 = polygeist.submap(%arg2, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %134 = polygeist.submap(%arg2, %c2, %c125) {map = #map1} : (memref, index, index) -> memref + %135 = polygeist.submap(%arg2, %c2, %c125) {map = #map2} : (memref, index, index) -> memref + %136 = polygeist.submap(%arg2, %c2, %c125) {map = #map3} : (memref, index, index) -> memref + %137 = polygeist.submap(%arg2, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %138 = polygeist.submap(%arg2, %c2, %c125) {map = #map5} : (memref, index, index) -> memref + %139 = polygeist.submap(%arg2, %c2, %c125) {map = #map6} : (memref, index, index) -> memref + %140 = polygeist.submap(%arg2, %c2, %c125) {map = #map7} : (memref, index, index) -> memref + %141 = polygeist.submap(%arg2, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %142 = polygeist.submap(%arg4, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %143 = polygeist.submap(%arg4, %c2, %c125) {map = #map1} : (memref, index, index) -> memref + %144 = polygeist.submap(%arg4, %c2, %c125) {map = #map3} : (memref, index, index) -> memref + %145 = polygeist.submap(%arg4, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %146 = polygeist.submap(%arg4, %c2, %c125) {map = #map5} : (memref, index, index) -> memref + %147 = polygeist.submap(%arg4, %c2, %c125) {map = #map7} : (memref, index, index) -> memref + %148 = polygeist.submap(%arg4, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %149 = polygeist.submap(%arg0, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %150 = polygeist.submap(%arg1, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %151 = polygeist.submap(%arg5, %c2, %c125) {map = #map5} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"]} ins(%133, %134, %135, %136, %137, %138, %139, %140, %141, %142, %143, %144, %145, %146, %147, %148, %arg3, %149, %150 : memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%151 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %171 = arith.mulf %in_3, %in_7 : f64 + %172 = arith.mulf %in_4, %in_6 : f64 + %173 = arith.subf %171, %172 : f64 + %174 = arith.mulf %in, %173 : f64 + %175 = arith.mulf %in_2, %in_7 : f64 + %176 = arith.mulf %in_4, %in_5 : f64 + %177 = arith.subf %175, %176 : f64 + %178 = arith.mulf %in_0, %177 : f64 + %179 = arith.subf %174, %178 : f64 + %180 = arith.mulf %in_2, %in_6 : f64 + %181 = arith.mulf %in_3, %in_5 : f64 + %182 = arith.subf %180, %181 : f64 + %183 = arith.mulf %in_1, %182 : f64 + %184 = arith.addf %179, %183 : f64 + %185 = arith.divf %182, %184 : f64 + %186 = arith.mulf %in_0, %in_5 : f64 + %187 = arith.mulf %in, %in_6 : f64 + %188 = arith.subf %186, %187 : f64 + %189 = arith.divf %188, %184 : f64 + %190 = arith.mulf %in, %in_3 : f64 + %191 = arith.mulf %in_0, %in_2 : f64 + %192 = arith.subf %190, %191 : f64 + %193 = arith.divf %192, %184 : f64 + %194 = arith.addf %in_8, %in_11 : f64 + %195 = arith.addf %194, %in_14 : f64 + %196 = arith.mulf %in_15, %184 : f64 + %197 = arith.mulf %in_16, %189 : f64 + %198 = arith.mulf %197, %195 : f64 + %199 = arith.addf %in_10, %in_9 : f64 + %200 = arith.mulf %185, %199 : f64 + %201 = arith.addf %in_11, %in_11 : f64 + %202 = arith.mulf %189, %201 : f64 + %203 = arith.addf %200, %202 : f64 + %204 = arith.addf %in_12, %in_13 : f64 + %205 = arith.mulf %193, %204 : f64 + %206 = arith.addf %203, %205 : f64 + %207 = arith.mulf %in_17, %206 : f64 + %208 = arith.addf %198, %207 : f64 + %209 = arith.mulf %196, %208 : f64 + linalg.yield %209 : f64 + } + %152 = polygeist.submap(%arg2, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %153 = polygeist.submap(%arg2, %c2, %c125) {map = #map1} : (memref, index, index) -> memref + %154 = polygeist.submap(%arg2, %c2, %c125) {map = #map2} : (memref, index, index) -> memref + %155 = polygeist.submap(%arg2, %c2, %c125) {map = #map3} : (memref, index, index) -> memref + %156 = polygeist.submap(%arg2, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %157 = polygeist.submap(%arg2, %c2, %c125) {map = #map5} : (memref, index, index) -> memref + %158 = polygeist.submap(%arg2, %c2, %c125) {map = #map6} : (memref, index, index) -> memref + %159 = polygeist.submap(%arg2, %c2, %c125) {map = #map7} : (memref, index, index) -> memref + %160 = polygeist.submap(%arg2, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %161 = polygeist.submap(%arg4, %c2, %c125) {map = #map} : (memref, index, index) -> memref + %162 = polygeist.submap(%arg4, %c2, %c125) {map = #map2} : (memref, index, index) -> memref + %163 = polygeist.submap(%arg4, %c2, %c125) {map = #map4} : (memref, index, index) -> memref + %164 = polygeist.submap(%arg4, %c2, %c125) {map = #map5} : (memref, index, index) -> memref + %165 = polygeist.submap(%arg4, %c2, %c125) {map = #map6} : (memref, index, index) -> memref + %166 = polygeist.submap(%arg4, %c2, %c125) {map = #map7} : (memref, index, index) -> memref + %167 = polygeist.submap(%arg4, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + %168 = polygeist.submap(%arg0, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %169 = polygeist.submap(%arg1, %c2, %c125) {map = #map9} : (memref, index, index) -> memref + %170 = polygeist.submap(%arg5, %c2, %c125) {map = #map8} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map11, #map10, #map10, #map10], iterator_types = ["parallel", "parallel"]} ins(%152, %153, %154, %155, %156, %157, %158, %159, %160, %161, %162, %163, %164, %165, %166, %167, %arg3, %168, %169 : memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref, memref) outs(%170 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %in_7: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %in_17: f64, %out: f64): + %171 = arith.mulf %in_3, %in_7 : f64 + %172 = arith.mulf %in_4, %in_6 : f64 + %173 = arith.subf %171, %172 : f64 + %174 = arith.mulf %in, %173 : f64 + %175 = arith.mulf %in_2, %in_7 : f64 + %176 = arith.mulf %in_4, %in_5 : f64 + %177 = arith.subf %175, %176 : f64 + %178 = arith.mulf %in_0, %177 : f64 + %179 = arith.subf %174, %178 : f64 + %180 = arith.mulf %in_2, %in_6 : f64 + %181 = arith.mulf %in_3, %in_5 : f64 + %182 = arith.subf %180, %181 : f64 + %183 = arith.mulf %in_1, %182 : f64 + %184 = arith.addf %179, %183 : f64 + %185 = arith.divf %182, %184 : f64 + %186 = arith.mulf %in_0, %in_5 : f64 + %187 = arith.mulf %in, %in_6 : f64 + %188 = arith.subf %186, %187 : f64 + %189 = arith.divf %188, %184 : f64 + %190 = arith.mulf %in, %in_3 : f64 + %191 = arith.mulf %in_0, %in_2 : f64 + %192 = arith.subf %190, %191 : f64 + %193 = arith.divf %192, %184 : f64 + %194 = arith.addf %in_8, %in_10 : f64 + %195 = arith.addf %194, %in_14 : f64 + %196 = arith.mulf %in_15, %184 : f64 + %197 = arith.mulf %in_16, %193 : f64 + %198 = arith.mulf %197, %195 : f64 + %199 = arith.addf %in_12, %in_9 : f64 + %200 = arith.mulf %185, %199 : f64 + %201 = arith.addf %in_13, %in_11 : f64 + %202 = arith.mulf %189, %201 : f64 + %203 = arith.addf %200, %202 : f64 + %204 = arith.addf %in_14, %in_14 : f64 + %205 = arith.mulf %193, %204 : f64 + %206 = arith.addf %203, %205 : f64 + %207 = arith.mulf %in_17, %206 : f64 + %208 = arith.addf %198, %207 : f64 + %209 = arith.mulf %196, %208 : f64 + linalg.yield %209 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/integrate_grad_2d__original.frontend.mlir b/issues/mfem_c_kernels/results/integrate_grad_2d__original.frontend.mlir new file mode 100644 index 000000000000..44de2f031c28 --- /dev/null +++ b/issues/mfem_c_kernels/results/integrate_grad_2d__original.frontend.mlir @@ -0,0 +1,46 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_grad_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<5x4xf64> + %alloca_0 = memref.alloca() : memref<5x4xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 4 { + %0:2 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst, %arg9 = %cst) -> (f64, f64) { + %1 = affine.load %arg0[%arg5 + %arg4 * 50 + %arg7 * 5] : memref + %2 = affine.load %arg2[%arg6 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + %5 = affine.load %arg0[%arg5 + %arg4 * 50 + %arg7 * 5 + 25] : memref + %6 = affine.load %arg1[%arg6 + %arg7 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.addf %arg8, %7 : f64 + affine.yield %8, %4 : f64, f64 + } + affine.store %0#1, %alloca_0[%arg5, %arg6] : memref<5x4xf64> + affine.store %0#0, %alloca[%arg5, %arg6] : memref<5x4xf64> + } + } + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + %0:2 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst, %arg9 = %cst) -> (f64, f64) { + %4 = affine.load %alloca_0[%arg7, %arg6] : memref<5x4xf64> + %5 = affine.load %arg1[%arg5 + %arg7 * 4] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %arg9, %6 : f64 + %8 = affine.load %alloca[%arg7, %arg6] : memref<5x4xf64> + %9 = affine.load %arg2[%arg5 + %arg7 * 4] : memref + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %arg8, %10 : f64 + affine.yield %11, %7 : f64, f64 + } + %1 = arith.addf %0#1, %0#0 : f64 + %2 = affine.load %arg3[%arg6 + %arg4 * 16 + %arg5 * 4] : memref + %3 = arith.addf %2, %1 : f64 + affine.store %3, %arg3[%arg6 + %arg4 * 16 + %arg5 * 4] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/integrate_grad_2d__original.raised.mlir b/issues/mfem_c_kernels/results/integrate_grad_2d__original.raised.mlir new file mode 100644 index 000000000000..97850d6b30a2 --- /dev/null +++ b/issues/mfem_c_kernels/results/integrate_grad_2d__original.raised.mlir @@ -0,0 +1,68 @@ +#map = affine_map<(d0)[s0, s1] -> (d0 * 5 + s0 + s1 * 50)> +#map1 = affine_map<(d0)[s0] -> (d0 * 4 + s0)> +#map2 = affine_map<(d0)[s0, s1] -> (d0 * 5 + s0 + s1 * 50 + 25)> +#map3 = affine_map<(d0) -> (d0)> +#map4 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_grad_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<5x4xf64> + %alloca_0 = memref.alloca() : memref<5x4xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 4 { + %alloca_1 = memref.alloca() : memref + affine.store %cst, %alloca_1[] : memref + %alloca_2 = memref.alloca() : memref + affine.store %cst, %alloca_2[] : memref + %0 = polygeist.submap(%arg0, %arg5, %arg4, %c5) {map = #map} : (memref, index, index, index) -> memref + %1 = polygeist.submap(%arg2, %arg6, %c5) {map = #map1} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg0, %arg5, %arg4, %c5) {map = #map2} : (memref, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg6, %c5) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map3, #map3, #map4, #map4], iterator_types = ["reduction"]} ins(%0, %1, %2, %3 : memref, memref, memref, memref) outs(%alloca_1, %alloca_2 : memref, memref) { + ^bb0(%in: f64, %in_3: f64, %in_4: f64, %in_5: f64, %out: f64, %out_6: f64): + %6 = arith.mulf %in, %in_3 : f64 + %7 = arith.addf %out_6, %6 : f64 + %8 = arith.mulf %in_4, %in_5 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9, %7 : f64, f64 + } + %4 = affine.load %alloca_1[] : memref + %5 = affine.load %alloca_2[] : memref + affine.store %5, %alloca_0[%arg5, %arg6] : memref<5x4xf64> + affine.store %4, %alloca[%arg5, %arg6] : memref<5x4xf64> + } {polygeist.was_parallel} + } {polygeist.was_parallel} + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + %alloca_1 = memref.alloca() : memref + affine.store %cst, %alloca_1[] : memref + %alloca_2 = memref.alloca() : memref + affine.store %cst, %alloca_2[] : memref + %subview = memref.subview %alloca_0[0, %arg6] [%c5, 1] [1, 1] : memref<5x4xf64> to memref> + %0 = polygeist.submap(%arg1, %arg5, %c5) {map = #map1} : (memref, index, index) -> memref + %subview_3 = memref.subview %alloca[0, %arg6] [%c5, 1] [1, 1] : memref<5x4xf64> to memref> + %1 = polygeist.submap(%arg2, %arg5, %c5) {map = #map1} : (memref, index, index) -> memref + %subview_4 = memref.subview %alloca_1[] [] [] : memref to memref> + %subview_5 = memref.subview %alloca_2[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map3, #map3, #map3, #map3, #map4, #map4], iterator_types = ["reduction"]} ins(%subview, %0, %subview_3, %1 : memref>, memref, memref>, memref) outs(%subview_4, %subview_5 : memref>, memref>) { + ^bb0(%in: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64, %out_9: f64): + %7 = arith.mulf %in, %in_6 : f64 + %8 = arith.addf %out_9, %7 : f64 + %9 = arith.mulf %in_7, %in_8 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10, %8 : f64, f64 + } + %2 = affine.load %alloca_1[] : memref + %3 = affine.load %alloca_2[] : memref + %4 = arith.addf %3, %2 : f64 + %5 = affine.load %arg3[%arg6 + %arg4 * 16 + %arg5 * 4] : memref + %6 = arith.addf %5, %4 : f64 + affine.store %6, %arg3[%arg6 + %arg4 * 16 + %arg5 * 4] : memref + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } + return + } +} diff --git a/issues/mfem_c_kernels/results/integrate_grad_2d_stage_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/integrate_grad_2d_stage_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..6eeeaa21f90b --- /dev/null +++ b/issues/mfem_c_kernels/results/integrate_grad_2d_stage_sliced__normalized.frontend.mlir @@ -0,0 +1,78 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_grad_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 4 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg5 + %arg4 * 50 + %arg7 * 5] : memref + %2 = affine.load %arg2[%arg6 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg4, %arg5, %arg6] : memref<2x5x4xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 4 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg5 + %arg4 * 50 + %arg7 * 5 + 25] : memref + %2 = affine.load %arg1[%arg6 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg4, %arg5, %arg6] : memref<2x5x4xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg4, %arg7, %arg6] : memref<2x5x4xf64> + %2 = affine.load %arg1[%arg5 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg4, %arg5, %arg6] : memref<2x4x4xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca_1[%arg4, %arg7, %arg6] : memref<2x5x4xf64> + %2 = affine.load %arg2[%arg5 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg4, %arg5, %arg6] : memref<2x4x4xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + %0 = affine.load %alloca_0[%arg4, %arg5, %arg6] : memref<2x4x4xf64> + %1 = affine.load %alloca[%arg4, %arg5, %arg6] : memref<2x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %arg3[%arg6 + %arg4 * 16 + %arg5 * 4] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg3[%arg6 + %arg4 * 16 + %arg5 * 4] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/integrate_grad_2d_stage_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/integrate_grad_2d_stage_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..ede1f9fc3705 --- /dev/null +++ b/issues/mfem_c_kernels/results/integrate_grad_2d_stage_sliced__normalized.raised.mlir @@ -0,0 +1,75 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 50 + 25)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d1)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map8 = affine_map<(d0, d1, d2) -> (d2 + d0 * 16 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_grad_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg0, %c2, %c5, %c4, %c5) {map = #map1} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg2, %c2, %c5, %c4, %c5) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_2 : memref<2x5x4xf64>) { + ^bb0(%in: f64, %in_3: f64, %out: f64): + %7 = arith.mulf %in, %in_3 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg0, %c2, %c5, %c4, %c5) {map = #map5} : (memref, index, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %c2, %c5, %c4, %c5) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%2, %3 : memref, memref) outs(%alloca_1 : memref<2x5x4xf64>) { + ^bb0(%in: f64, %in_3: f64, %out: f64): + %7 = arith.mulf %in, %in_3 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5) {map = #map6} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_2, %4 : memref<2x5x4xf64>, memref) outs(%alloca_0 : memref<2x4x4xf64>) { + ^bb0(%in: f64, %in_3: f64, %out: f64): + %7 = arith.mulf %in, %in_3 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca : memref<2x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %5 = polygeist.submap(%arg2, %c2, %c4, %c4, %c5) {map = #map6} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map7, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_1, %5 : memref<2x5x4xf64>, memref) outs(%alloca : memref<2x4x4xf64>) { + ^bb0(%in: f64, %in_3: f64, %out: f64): + %7 = arith.mulf %in, %in_3 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } + %6 = polygeist.submap(%arg3, %c2, %c4, %c4) {map = #map8} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%alloca_0, %alloca : memref<2x4x4xf64>, memref<2x4x4xf64>) outs(%6 : memref) { + ^bb0(%in: f64, %in_3: f64, %out: f64): + %7 = arith.addf %in, %in_3 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/integrate_grad_3d__original.frontend.mlir b/issues/mfem_c_kernels/results/integrate_grad_3d__original.frontend.mlir new file mode 100644 index 000000000000..b03e63861e36 --- /dev/null +++ b/issues/mfem_c_kernels/results/integrate_grad_3d__original.frontend.mlir @@ -0,0 +1,85 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_grad_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<5x4x4xf64> + %alloca_0 = memref.alloca() : memref<5x4x4xf64> + %alloca_1 = memref.alloca() : memref<5x4x4xf64> + %alloca_2 = memref.alloca() : memref<5x5x4xf64> + %alloca_3 = memref.alloca() : memref<5x5x4xf64> + %alloca_4 = memref.alloca() : memref<5x5x4xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + %0:3 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst, %arg10 = %cst, %arg11 = %cst) -> (f64, f64, f64) { + %1 = affine.load %arg0[%arg4 * 375 + %arg5 + %arg8 * 25 + %arg6 * 5] : memref + %2 = affine.load %arg2[%arg7 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + %5 = affine.load %arg0[%arg4 * 375 + %arg5 + %arg8 * 25 + %arg6 * 5 + 125] : memref + %6 = affine.load %arg1[%arg7 + %arg8 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.addf %arg10, %7 : f64 + %9 = affine.load %arg0[%arg4 * 375 + %arg5 + %arg8 * 25 + %arg6 * 5 + 250] : memref + %10 = arith.mulf %9, %6 : f64 + %11 = arith.addf %arg9, %10 : f64 + affine.yield %11, %8, %4 : f64, f64, f64 + } + affine.store %0#2, %alloca_4[%arg5, %arg6, %arg7] : memref<5x5x4xf64> + affine.store %0#1, %alloca_3[%arg5, %arg6, %arg7] : memref<5x5x4xf64> + affine.store %0#0, %alloca_2[%arg5, %arg6, %arg7] : memref<5x5x4xf64> + } + } + } + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0:3 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst, %arg10 = %cst, %arg11 = %cst) -> (f64, f64, f64) { + %1 = affine.load %alloca_4[%arg5, %arg8, %arg7] : memref<5x5x4xf64> + %2 = affine.load %arg1[%arg6 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + %5 = affine.load %alloca_3[%arg5, %arg8, %arg7] : memref<5x5x4xf64> + %6 = affine.load %arg2[%arg6 + %arg8 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.addf %arg10, %7 : f64 + %9 = affine.load %alloca_2[%arg5, %arg8, %arg7] : memref<5x5x4xf64> + %10 = arith.mulf %9, %2 : f64 + %11 = arith.addf %arg9, %10 : f64 + affine.yield %11, %8, %4 : f64, f64, f64 + } + affine.store %0#2, %alloca_1[%arg5, %arg6, %arg7] : memref<5x4x4xf64> + affine.store %0#1, %alloca_0[%arg5, %arg6, %arg7] : memref<5x4x4xf64> + affine.store %0#0, %alloca[%arg5, %arg6, %arg7] : memref<5x4x4xf64> + } + } + } + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0:3 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst, %arg10 = %cst, %arg11 = %cst) -> (f64, f64, f64) { + %5 = affine.load %alloca_1[%arg8, %arg6, %arg7] : memref<5x4x4xf64> + %6 = affine.load %arg1[%arg5 + %arg8 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.addf %arg11, %7 : f64 + %9 = affine.load %alloca_0[%arg8, %arg6, %arg7] : memref<5x4x4xf64> + %10 = arith.mulf %9, %6 : f64 + %11 = arith.addf %arg10, %10 : f64 + %12 = affine.load %alloca[%arg8, %arg6, %arg7] : memref<5x4x4xf64> + %13 = affine.load %arg2[%arg5 + %arg8 * 4] : memref + %14 = arith.mulf %12, %13 : f64 + %15 = arith.addf %arg9, %14 : f64 + affine.yield %15, %11, %8 : f64, f64, f64 + } + %1 = arith.addf %0#2, %0#1 : f64 + %2 = arith.addf %1, %0#0 : f64 + %3 = affine.load %arg3[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg3[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/integrate_grad_3d__original.raised.mlir b/issues/mfem_c_kernels/results/integrate_grad_3d__original.raised.mlir new file mode 100644 index 000000000000..79a6708162f0 --- /dev/null +++ b/issues/mfem_c_kernels/results/integrate_grad_3d__original.raised.mlir @@ -0,0 +1,128 @@ +#map = affine_map<(d0)[s0, s1, s2] -> (d0 * 25 + s0 * 375 + s1 + s2 * 5)> +#map1 = affine_map<(d0)[s0] -> (d0 * 4 + s0)> +#map2 = affine_map<(d0)[s0, s1, s2] -> (d0 * 25 + s0 * 375 + s1 + s2 * 5 + 125)> +#map3 = affine_map<(d0)[s0, s1, s2] -> (d0 * 25 + s0 * 375 + s1 + s2 * 5 + 250)> +#map4 = affine_map<(d0) -> (d0)> +#map5 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_grad_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<5x4x4xf64> + %alloca_0 = memref.alloca() : memref<5x4x4xf64> + %alloca_1 = memref.alloca() : memref<5x4x4xf64> + %alloca_2 = memref.alloca() : memref<5x5x4xf64> + %alloca_3 = memref.alloca() : memref<5x5x4xf64> + %alloca_4 = memref.alloca() : memref<5x5x4xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + %alloca_5 = memref.alloca() : memref + affine.store %cst, %alloca_5[] : memref + %alloca_6 = memref.alloca() : memref + affine.store %cst, %alloca_6[] : memref + %alloca_7 = memref.alloca() : memref + affine.store %cst, %alloca_7[] : memref + %0 = polygeist.submap(%arg0, %arg4, %arg5, %arg6, %c5) {map = #map} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg2, %arg7, %c5) {map = #map1} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg0, %arg4, %arg5, %arg6, %c5) {map = #map2} : (memref, index, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg7, %c5) {map = #map1} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg0, %arg4, %arg5, %arg6, %c5) {map = #map3} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4, #map4, #map5, #map5, #map5], iterator_types = ["reduction"]} ins(%0, %1, %2, %3, %4 : memref, memref, memref, memref, memref) outs(%alloca_5, %alloca_6, %alloca_7 : memref, memref, memref) { + ^bb0(%in: f64, %in_8: f64, %in_9: f64, %in_10: f64, %in_11: f64, %out: f64, %out_12: f64, %out_13: f64): + %8 = arith.mulf %in, %in_8 : f64 + %9 = arith.addf %out_13, %8 : f64 + %10 = arith.mulf %in_9, %in_10 : f64 + %11 = arith.addf %out_12, %10 : f64 + %12 = arith.mulf %in_11, %in_10 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13, %11, %9 : f64, f64, f64 + } + %5 = affine.load %alloca_5[] : memref + %6 = affine.load %alloca_6[] : memref + %7 = affine.load %alloca_7[] : memref + affine.store %7, %alloca_4[%arg5, %arg6, %arg7] : memref<5x5x4xf64> + affine.store %6, %alloca_3[%arg5, %arg6, %arg7] : memref<5x5x4xf64> + affine.store %5, %alloca_2[%arg5, %arg6, %arg7] : memref<5x5x4xf64> + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %alloca_5 = memref.alloca() : memref + affine.store %cst, %alloca_5[] : memref + %alloca_6 = memref.alloca() : memref + affine.store %cst, %alloca_6[] : memref + %alloca_7 = memref.alloca() : memref + affine.store %cst, %alloca_7[] : memref + %subview = memref.subview %alloca_4[%arg5, 0, %arg7] [1, %c5, 1] [1, 1, 1] : memref<5x5x4xf64> to memref> + %0 = polygeist.submap(%arg1, %arg6, %c5) {map = #map1} : (memref, index, index) -> memref + %subview_8 = memref.subview %alloca_3[%arg5, 0, %arg7] [1, %c5, 1] [1, 1, 1] : memref<5x5x4xf64> to memref> + %1 = polygeist.submap(%arg2, %arg6, %c5) {map = #map1} : (memref, index, index) -> memref + %subview_9 = memref.subview %alloca_2[%arg5, 0, %arg7] [1, %c5, 1] [1, 1, 1] : memref<5x5x4xf64> to memref> + %subview_10 = memref.subview %alloca_5[] [] [] : memref to memref> + %subview_11 = memref.subview %alloca_6[] [] [] : memref to memref> + %subview_12 = memref.subview %alloca_7[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4, #map4, #map5, #map5, #map5], iterator_types = ["reduction"]} ins(%subview, %0, %subview_8, %1, %subview_9 : memref>, memref, memref>, memref, memref>) outs(%subview_10, %subview_11, %subview_12 : memref>, memref>, memref>) { + ^bb0(%in: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %out: f64, %out_17: f64, %out_18: f64): + %5 = arith.mulf %in, %in_13 : f64 + %6 = arith.addf %out_18, %5 : f64 + %7 = arith.mulf %in_14, %in_15 : f64 + %8 = arith.addf %out_17, %7 : f64 + %9 = arith.mulf %in_16, %in_13 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10, %8, %6 : f64, f64, f64 + } + %2 = affine.load %alloca_5[] : memref + %3 = affine.load %alloca_6[] : memref + %4 = affine.load %alloca_7[] : memref + affine.store %4, %alloca_1[%arg5, %arg6, %arg7] : memref<5x4x4xf64> + affine.store %3, %alloca_0[%arg5, %arg6, %arg7] : memref<5x4x4xf64> + affine.store %2, %alloca[%arg5, %arg6, %arg7] : memref<5x4x4xf64> + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %alloca_5 = memref.alloca() : memref + affine.store %cst, %alloca_5[] : memref + %alloca_6 = memref.alloca() : memref + affine.store %cst, %alloca_6[] : memref + %alloca_7 = memref.alloca() : memref + affine.store %cst, %alloca_7[] : memref + %subview = memref.subview %alloca_1[0, %arg6, %arg7] [%c5, 1, 1] [1, 1, 1] : memref<5x4x4xf64> to memref> + %0 = polygeist.submap(%arg1, %arg5, %c5) {map = #map1} : (memref, index, index) -> memref + %subview_8 = memref.subview %alloca_0[0, %arg6, %arg7] [%c5, 1, 1] [1, 1, 1] : memref<5x4x4xf64> to memref> + %subview_9 = memref.subview %alloca[0, %arg6, %arg7] [%c5, 1, 1] [1, 1, 1] : memref<5x4x4xf64> to memref> + %1 = polygeist.submap(%arg2, %arg5, %c5) {map = #map1} : (memref, index, index) -> memref + %subview_10 = memref.subview %alloca_5[] [] [] : memref to memref> + %subview_11 = memref.subview %alloca_6[] [] [] : memref to memref> + %subview_12 = memref.subview %alloca_7[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4, #map4, #map5, #map5, #map5], iterator_types = ["reduction"]} ins(%subview, %0, %subview_8, %subview_9, %1 : memref>, memref, memref>, memref>, memref) outs(%subview_10, %subview_11, %subview_12 : memref>, memref>, memref>) { + ^bb0(%in: f64, %in_13: f64, %in_14: f64, %in_15: f64, %in_16: f64, %out: f64, %out_17: f64, %out_18: f64): + %9 = arith.mulf %in, %in_13 : f64 + %10 = arith.addf %out_18, %9 : f64 + %11 = arith.mulf %in_14, %in_13 : f64 + %12 = arith.addf %out_17, %11 : f64 + %13 = arith.mulf %in_15, %in_16 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14, %12, %10 : f64, f64, f64 + } + %2 = affine.load %alloca_5[] : memref + %3 = affine.load %alloca_6[] : memref + %4 = affine.load %alloca_7[] : memref + %5 = arith.addf %4, %3 : f64 + %6 = arith.addf %5, %2 : f64 + %7 = affine.load %arg3[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg3[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } + return + } +} diff --git a/issues/mfem_c_kernels/results/integrate_grad_3d_stage_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/integrate_grad_3d_stage_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..427205674b46 --- /dev/null +++ b/issues/mfem_c_kernels/results/integrate_grad_3d_stage_sliced__normalized.frontend.mlir @@ -0,0 +1,175 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_grad_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x4xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg4 * 375 + %arg5 + %arg8 * 25 + %arg6 * 5] : memref + %2 = affine.load %arg2[%arg7 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_7[%arg4, %arg5, %arg6, %arg7] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg4 * 375 + %arg5 + %arg8 * 25 + %arg6 * 5 + 125] : memref + %2 = affine.load %arg1[%arg7 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_6[%arg4, %arg5, %arg6, %arg7] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg4 * 375 + %arg5 + %arg8 * 25 + %arg6 * 5 + 250] : memref + %2 = affine.load %arg1[%arg7 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_5[%arg4, %arg5, %arg6, %arg7] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca_7[%arg4, %arg5, %arg8, %arg7] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg6 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_4[%arg4, %arg5, %arg6, %arg7] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca_6[%arg4, %arg5, %arg8, %arg7] : memref<2x5x5x4xf64> + %2 = affine.load %arg2[%arg6 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg4, %arg5, %arg6, %arg7] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca_5[%arg4, %arg5, %arg8, %arg7] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg6 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg4, %arg5, %arg6, %arg7] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca_4[%arg4, %arg8, %arg6, %arg7] : memref<2x5x4x4xf64> + %2 = affine.load %arg1[%arg5 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg4, %arg5, %arg6, %arg7] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg4, %arg8, %arg6, %arg7] : memref<2x5x4x4xf64> + %2 = affine.load %arg1[%arg5 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg4, %arg5, %arg6, %arg7] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg4, %arg8, %arg6, %arg7] : memref<2x5x4x4xf64> + %2 = affine.load %arg2[%arg5 + %arg8 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg4, %arg5, %arg6, %arg7] : memref<2x4x4x4xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.load %alloca_1[%arg4, %arg5, %arg6, %arg7] : memref<2x4x4x4xf64> + %1 = affine.load %alloca_0[%arg4, %arg5, %arg6, %arg7] : memref<2x4x4x4xf64> + %2 = arith.addf %0, %1 : f64 + %3 = affine.load %alloca[%arg4, %arg5, %arg6, %arg7] : memref<2x4x4x4xf64> + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg3[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref + %6 = arith.addf %5, %4 : f64 + affine.store %6, %arg3[%arg4 * 64 + %arg7 + %arg5 * 16 + %arg6 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/integrate_grad_3d_stage_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/integrate_grad_3d_stage_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..d900169866ca --- /dev/null +++ b/issues/mfem_c_kernels/results/integrate_grad_3d_stage_sliced__normalized.raised.mlir @@ -0,0 +1,140 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 25 + d1 + d0 * 375 + d2 * 5)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 4 + d3)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 25 + d1 + d0 * 375 + d2 * 5 + 125)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 25 + d1 + d0 * 375 + d2 * 5 + 250)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 4 + d2)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 4 + d1)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_grad_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_1 = memref.alloca() : memref<2x4x4x4xf64> + %alloca_2 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_3 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_4 = memref.alloca() : memref<2x5x4x4xf64> + %alloca_5 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_6 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_7 = memref.alloca() : memref<2x5x5x4xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_7 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg0, %c2, %c5, %c5, %c4, %c5) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4, %c5) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_7 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_8: f64, %out: f64): + %13 = arith.mulf %in, %in_8 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_6 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg0, %c2, %c5, %c5, %c4, %c5) {map = #map5} : (memref, index, index, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %c2, %c5, %c5, %c4, %c5) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%2, %3 : memref, memref) outs(%alloca_6 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_8: f64, %out: f64): + %13 = arith.mulf %in, %in_8 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_5 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg0, %c2, %c5, %c5, %c4, %c5) {map = #map6} : (memref, index, index, index, index, index) -> memref + %5 = polygeist.submap(%arg1, %c2, %c5, %c5, %c4, %c5) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%4, %5 : memref, memref) outs(%alloca_5 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_8: f64, %out: f64): + %13 = arith.mulf %in, %in_8 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_4 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg1, %c2, %c5, %c4, %c4, %c5) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_7, %6 : memref<2x5x5x4xf64>, memref) outs(%alloca_4 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_8: f64, %out: f64): + %13 = arith.mulf %in, %in_8 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %7 = polygeist.submap(%arg2, %c2, %c5, %c4, %c4, %c5) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_6, %7 : memref<2x5x5x4xf64>, memref) outs(%alloca_3 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_8: f64, %out: f64): + %13 = arith.mulf %in, %in_8 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg1, %c2, %c5, %c4, %c4, %c5) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_5, %8 : memref<2x5x5x4xf64>, memref) outs(%alloca_2 : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_8: f64, %out: f64): + %13 = arith.mulf %in, %in_8 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %9 = polygeist.submap(%arg1, %c2, %c4, %c4, %c4, %c5) {map = #map9} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_4, %9 : memref<2x5x4x4xf64>, memref) outs(%alloca_1 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_8: f64, %out: f64): + %13 = arith.mulf %in, %in_8 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %10 = polygeist.submap(%arg1, %c2, %c4, %c4, %c4, %c5) {map = #map9} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_3, %10 : memref<2x5x4x4xf64>, memref) outs(%alloca_0 : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_8: f64, %out: f64): + %13 = arith.mulf %in, %in_8 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca : memref<2x4x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %11 = polygeist.submap(%arg2, %c2, %c4, %c4, %c4, %c5) {map = #map9} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_2, %11 : memref<2x5x4x4xf64>, memref) outs(%alloca : memref<2x4x4x4xf64>) { + ^bb0(%in: f64, %in_8: f64, %out: f64): + %13 = arith.mulf %in, %in_8 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } + %12 = polygeist.submap(%arg3, %c2, %c4, %c4, %c4) {map = #map11} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%alloca_1, %alloca_0, %alloca : memref<2x4x4x4xf64>, memref<2x4x4x4xf64>, memref<2x4x4x4xf64>) outs(%12 : memref) { + ^bb0(%in: f64, %in_8: f64, %in_9: f64, %out: f64): + %13 = arith.addf %in, %in_8 : f64 + %14 = arith.addf %13, %in_9 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/integrate_value_2d__original.frontend.mlir b/issues/mfem_c_kernels/results/integrate_value_2d__original.frontend.mlir new file mode 100644 index 000000000000..4d02c58d8bc7 --- /dev/null +++ b/issues/mfem_c_kernels/results/integrate_value_2d__original.frontend.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_value_2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<5x4xf64> + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 4 { + %0 = affine.for %arg6 = 0 to 5 iter_args(%arg7 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg4 + %arg3 * 25 + %arg6 * 5] : memref + %2 = affine.load %arg1[%arg5 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg7, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg4, %arg5] : memref<5x4xf64> + } + } + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + %0 = affine.for %arg6 = 0 to 5 iter_args(%arg7 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg6, %arg5] : memref<5x4xf64> + %4 = affine.load %arg1[%arg4 + %arg6 * 4] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg7, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg2[%arg5 + %arg3 * 16 + %arg4 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg2[%arg5 + %arg3 * 16 + %arg4 * 4] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/integrate_value_2d__original.raised.mlir b/issues/mfem_c_kernels/results/integrate_value_2d__original.raised.mlir new file mode 100644 index 000000000000..808f1a22ccda --- /dev/null +++ b/issues/mfem_c_kernels/results/integrate_value_2d__original.raised.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2)[s0] -> (d2 * 5 + d0 + s0 * 25)> +#map2 = affine_map<(d0, d1, d2) -> (d2 * 4 + d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map4 = affine_map<(d0, d1, d2) -> (d0, d1)> +#map5 = affine_map<(d0, d1, d2) -> (d2 * 4 + d0)> +#map6 = affine_map<(d0, d1, d2)[s0] -> (d1 + s0 * 16 + d0 * 4)> +#map7 = affine_map<(d0, d1, d2) -> (d2, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_value_2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<5x4xf64> + affine.for %arg3 = 0 to 2 { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%alloca : memref<5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg0, %arg3, %c5, %c4, %c5) {map = #map1} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %c5, %c4, %c5) {map = #map2} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca : memref<5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.addf %out, %4 : f64 + linalg.yield %5 : f64 + } + %2 = polygeist.submap(%arg1, %c4, %c4, %c5) {map = #map5} : (memref, index, index, index) -> memref + %3 = polygeist.submap(%arg2, %arg3, %c4, %c4, %c5) {map = #map6} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map7, #map3, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%alloca, %2 : memref<5x4xf64>, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.addf %out, %4 : f64 + linalg.yield %5 : f64 + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/integrate_value_2d_scratch_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/integrate_value_2d_scratch_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..0e86af5c4b99 --- /dev/null +++ b/issues/mfem_c_kernels/results/integrate_value_2d_scratch_sliced__normalized.frontend.mlir @@ -0,0 +1,37 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_value_2d_scratch_sliced(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4xf64> + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 4 { + %0 = affine.for %arg6 = 0 to 5 iter_args(%arg7 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg4 + %arg3 * 25 + %arg6 * 5] : memref + %2 = affine.load %arg1[%arg5 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg7, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg3, %arg4, %arg5] : memref<2x5x4xf64> + } + } + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + %0 = affine.for %arg6 = 0 to 5 iter_args(%arg7 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg3, %arg6, %arg5] : memref<2x5x4xf64> + %4 = affine.load %arg1[%arg4 + %arg6 * 4] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg7, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg2[%arg5 + %arg3 * 16 + %arg4 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg2[%arg5 + %arg3 * 16 + %arg4 * 4] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/integrate_value_2d_scratch_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/integrate_value_2d_scratch_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..b7e3ab5e9868 --- /dev/null +++ b/issues/mfem_c_kernels/results/integrate_value_2d_scratch_sliced__normalized.raised.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 * 5 + d1 + d0 * 25)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d2)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d1)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 16 + d1 * 4)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_value_2d_scratch_sliced(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca : memref<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg0, %c2, %c5, %c4, %c5) {map = #map1} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %c2, %c5, %c4, %c5) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca : memref<2x5x4xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.addf %out, %4 : f64 + linalg.yield %5 : f64 + } + %2 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5) {map = #map5} : (memref, index, index, index, index) -> memref + %3 = polygeist.submap(%arg2, %c2, %c4, %c4, %c5) {map = #map6} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map7, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca, %2 : memref<2x5x4xf64>, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.addf %out, %4 : f64 + linalg.yield %5 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/integrate_value_3d__original.frontend.mlir b/issues/mfem_c_kernels/results/integrate_value_3d__original.frontend.mlir new file mode 100644 index 000000000000..3b4ee1cae469 --- /dev/null +++ b/issues/mfem_c_kernels/results/integrate_value_3d__original.frontend.mlir @@ -0,0 +1,54 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_value_3d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<5x4x4xf64> + %alloca_0 = memref.alloca() : memref<5x5x4xf64> + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg3 * 125 + %arg6 + %arg7 * 25 + %arg4 * 5] : memref + %2 = affine.load %arg1[%arg5 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg6, %arg4, %arg5] : memref<5x5x4xf64> + } + } + } + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca_0[%arg6, %arg7, %arg5] : memref<5x5x4xf64> + %2 = affine.load %arg1[%arg4 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg6, %arg4, %arg5] : memref<5x4x4xf64> + } + } + } + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg7, %arg5, %arg6] : memref<5x4x4xf64> + %4 = affine.load %arg1[%arg4 + %arg7 * 4] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg8, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg2[%arg3 * 64 + %arg6 + %arg4 * 16 + %arg5 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg2[%arg3 * 64 + %arg6 + %arg4 * 16 + %arg5 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/integrate_value_3d__original.raised.mlir b/issues/mfem_c_kernels/results/integrate_value_3d__original.raised.mlir new file mode 100644 index 000000000000..8f9f4e8b3285 --- /dev/null +++ b/issues/mfem_c_kernels/results/integrate_value_3d__original.raised.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0, d1, d2) -> (d2, d0, d1)> +#map1 = affine_map<(d0, d1, d2, d3)[s0] -> (d3 * 25 + d2 + s0 * 125 + d0 * 5)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d1)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d2, d0, d1)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 * 4 + d0)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d2, d3, d1)> +#map7 = affine_map<(d0, d1, d2, d3)[s0] -> (d2 + s0 * 64 + d0 * 16 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_value_3d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<5x4x4xf64> + %alloca_0 = memref.alloca() : memref<5x5x4xf64> + affine.for %arg3 = 0 to 2 { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg0, %arg3, %c5, %c4, %c5, %c5) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %c5, %c4, %c5, %c5) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_0 : memref<5x5x4xf64>) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %5 = arith.mulf %in, %in_1 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca : memref<5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg1, %c4, %c4, %c5, %c5) {map = #map5} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_0, %2 : memref<5x5x4xf64>, memref) outs(%alloca : memref<5x4x4xf64>) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %5 = arith.mulf %in, %in_1 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } + %3 = polygeist.submap(%arg1, %c4, %c4, %c4, %c5) {map = #map5} : (memref, index, index, index, index) -> memref + %4 = polygeist.submap(%arg2, %arg3, %c4, %c4, %c4, %c5) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca, %3 : memref<5x4x4xf64>, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %5 = arith.mulf %in, %in_1 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/integrate_value_3d_scratch_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/integrate_value_3d_scratch_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..c5fa5b75fc6c --- /dev/null +++ b/issues/mfem_c_kernels/results/integrate_value_3d_scratch_sliced__normalized.frontend.mlir @@ -0,0 +1,58 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_value_3d_scratch_sliced(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x5x4xf64> + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg3 * 125 + %arg6 + %arg7 * 25 + %arg4 * 5] : memref + %2 = affine.load %arg1[%arg5 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg3, %arg6, %arg4, %arg5] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca_0[%arg3, %arg6, %arg7, %arg5] : memref<2x5x5x4xf64> + %2 = affine.load %arg1[%arg4 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg3, %arg6, %arg4, %arg5] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + %0 = affine.for %arg7 = 0 to 5 iter_args(%arg8 = %cst) -> (f64) { + %3 = affine.load %alloca[%arg3, %arg7, %arg5, %arg6] : memref<2x5x4x4xf64> + %4 = affine.load %arg1[%arg4 + %arg7 * 4] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg8, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg2[%arg3 * 64 + %arg6 + %arg4 * 16 + %arg5 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg2[%arg3 * 64 + %arg6 + %arg4 * 16 + %arg5 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/integrate_value_3d_scratch_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/integrate_value_3d_scratch_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..2c97280871b8 --- /dev/null +++ b/issues/mfem_c_kernels/results/integrate_value_3d_scratch_sliced__normalized.raised.mlir @@ -0,0 +1,51 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d3, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 25 + d3 + d0 * 125 + d1 * 5)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 4 + d2)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 * 4 + d1)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d3, d4, d2)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_integrate_value_3d_scratch_sliced(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c4 = arith.constant 4 : index + %c5 = arith.constant 5 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x5x4xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg0, %c2, %c5, %c4, %c5, %c5) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %c2, %c5, %c4, %c5, %c5) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_0 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %5 = arith.mulf %in, %in_1 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5, %c5) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_0, %2 : memref<2x5x5x4xf64>, memref) outs(%alloca : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %5 = arith.mulf %in, %in_1 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } + %3 = polygeist.submap(%arg1, %c2, %c4, %c4, %c4, %c5) {map = #map5} : (memref, index, index, index, index, index) -> memref + %4 = polygeist.submap(%arg2, %c2, %c4, %c4, %c4, %c5) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca, %3 : memref<2x5x4x4xf64>, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %5 = arith.mulf %in, %in_1 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/interp_grad_2d__original.frontend.mlir b/issues/mfem_c_kernels/results/interp_grad_2d__original.frontend.mlir new file mode 100644 index 000000000000..218114ec6aa6 --- /dev/null +++ b/issues/mfem_c_kernels/results/interp_grad_2d__original.frontend.mlir @@ -0,0 +1,43 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_grad_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4x5xf64> + %alloca_0 = memref.alloca() : memref<4x5xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %0:2 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst, %arg9 = %cst) -> (f64, f64) { + %1 = affine.load %arg0[%arg7 + %arg4 * 16 + %arg5 * 4] : memref + %2 = affine.load %arg1[%arg7 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + %5 = affine.load %arg2[%arg7 + %arg6 * 4] : memref + %6 = arith.mulf %1, %5 : f64 + %7 = arith.addf %arg8, %6 : f64 + affine.yield %7, %4 : f64, f64 + } + affine.store %0#1, %alloca_0[%arg5, %arg6] : memref<4x5xf64> + affine.store %0#0, %alloca[%arg5, %arg6] : memref<4x5xf64> + } + } + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + %0:2 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst, %arg9 = %cst) -> (f64, f64) { + %1 = affine.load %alloca[%arg7, %arg6] : memref<4x5xf64> + %2 = affine.load %arg1[%arg7 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + %5 = affine.load %alloca_0[%arg7, %arg6] : memref<4x5xf64> + %6 = affine.load %arg2[%arg7 + %arg5 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.addf %arg8, %7 : f64 + affine.yield %8, %4 : f64, f64 + } + affine.store %0#1, %arg3[%arg5 + %arg4 * 50 + %arg6 * 5] : memref + affine.store %0#0, %arg3[%arg5 + %arg4 * 50 + %arg6 * 5 + 25] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/interp_grad_2d__original.raised.mlir b/issues/mfem_c_kernels/results/interp_grad_2d__original.raised.mlir new file mode 100644 index 000000000000..f710d5f0acc5 --- /dev/null +++ b/issues/mfem_c_kernels/results/interp_grad_2d__original.raised.mlir @@ -0,0 +1,64 @@ +#map = affine_map<(d0)[s0, s1] -> (d0 + s0 * 16 + s1 * 4)> +#map1 = affine_map<(d0)[s0] -> (d0 + s0 * 4)> +#map2 = affine_map<(d0) -> (d0)> +#map3 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_grad_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4x5xf64> + %alloca_0 = memref.alloca() : memref<4x5xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %alloca_1 = memref.alloca() : memref + affine.store %cst, %alloca_1[] : memref + %alloca_2 = memref.alloca() : memref + affine.store %cst, %alloca_2[] : memref + %0 = polygeist.submap(%arg0, %arg4, %arg5, %c4) {map = #map} : (memref, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %arg6, %c4) {map = #map1} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg2, %arg6, %c4) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2, #map2, #map3, #map3], iterator_types = ["reduction"]} ins(%0, %1, %2 : memref, memref, memref) outs(%alloca_1, %alloca_2 : memref, memref) { + ^bb0(%in: f64, %in_3: f64, %in_4: f64, %out: f64, %out_5: f64): + %5 = arith.mulf %in, %in_3 : f64 + %6 = arith.addf %out_5, %5 : f64 + %7 = arith.mulf %in, %in_4 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8, %6 : f64, f64 + } + %3 = affine.load %alloca_1[] : memref + %4 = affine.load %alloca_2[] : memref + affine.store %4, %alloca_0[%arg5, %arg6] : memref<4x5xf64> + affine.store %3, %alloca[%arg5, %arg6] : memref<4x5xf64> + } {polygeist.was_parallel} + } {polygeist.was_parallel} + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + %alloca_1 = memref.alloca() : memref + affine.store %cst, %alloca_1[] : memref + %alloca_2 = memref.alloca() : memref + affine.store %cst, %alloca_2[] : memref + %subview = memref.subview %alloca[0, %arg6] [%c4, 1] [1, 1] : memref<4x5xf64> to memref> + %0 = polygeist.submap(%arg1, %arg5, %c4) {map = #map1} : (memref, index, index) -> memref + %subview_3 = memref.subview %alloca_0[0, %arg6] [%c4, 1] [1, 1] : memref<4x5xf64> to memref> + %1 = polygeist.submap(%arg2, %arg5, %c4) {map = #map1} : (memref, index, index) -> memref + %subview_4 = memref.subview %alloca_1[] [] [] : memref to memref> + %subview_5 = memref.subview %alloca_2[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map2, #map2, #map3, #map3], iterator_types = ["reduction"]} ins(%subview, %0, %subview_3, %1 : memref>, memref, memref>, memref) outs(%subview_4, %subview_5 : memref>, memref>) { + ^bb0(%in: f64, %in_6: f64, %in_7: f64, %in_8: f64, %out: f64, %out_9: f64): + %4 = arith.mulf %in, %in_6 : f64 + %5 = arith.addf %out_9, %4 : f64 + %6 = arith.mulf %in_7, %in_8 : f64 + %7 = arith.addf %out, %6 : f64 + linalg.yield %7, %5 : f64, f64 + } + %2 = affine.load %alloca_1[] : memref + %3 = affine.load %alloca_2[] : memref + affine.store %3, %arg3[%arg5 + %arg4 * 50 + %arg6 * 5] : memref + affine.store %2, %arg3[%arg5 + %arg4 * 50 + %arg6 * 5 + 25] : memref + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } + return + } +} diff --git a/issues/mfem_c_kernels/results/interp_grad_2d_stage_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/interp_grad_2d_stage_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..2109cad00094 --- /dev/null +++ b/issues/mfem_c_kernels/results/interp_grad_2d_stage_sliced__normalized.frontend.mlir @@ -0,0 +1,64 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_grad_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x5xf64> + %alloca_0 = memref.alloca() : memref<2x4x5xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg7 + %arg4 * 16 + %arg5 * 4] : memref + %2 = affine.load %arg1[%arg7 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg4, %arg5, %arg6] : memref<2x4x5xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg7 + %arg4 * 16 + %arg5 * 4] : memref + %2 = affine.load %arg2[%arg7 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg4, %arg5, %arg6] : memref<2x4x5xf64> + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg4, %arg7, %arg6] : memref<2x4x5xf64> + %2 = affine.load %arg1[%arg7 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %arg3[%arg5 + %arg4 * 50 + %arg6 * 5] : memref + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca_0[%arg4, %arg7, %arg6] : memref<2x4x5xf64> + %2 = affine.load %arg2[%arg7 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %arg3[%arg5 + %arg4 * 50 + %arg6 * 5 + 25] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/interp_grad_2d_stage_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/interp_grad_2d_stage_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..13ca80314eaa --- /dev/null +++ b/issues/mfem_c_kernels/results/interp_grad_2d_stage_sliced__normalized.raised.mlir @@ -0,0 +1,72 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d2 * 5 + d1 + d0 * 50)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map9 = affine_map<(d0, d1, d2) -> (d2 * 5 + d1 + d0 * 50 + 25)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d2 * 5 + d1 + d0 * 50 + 25)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_grad_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x5xf64> + %alloca_0 = memref.alloca() : memref<2x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg0, %c2, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_0 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %10 = arith.mulf %in, %in_1 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca : memref<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg0, %c2, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %3 = polygeist.submap(%arg2, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%2, %3 : memref, memref) outs(%alloca : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %10 = arith.mulf %in, %in_1 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + %4 = polygeist.submap(%arg3, %c2, %c5, %c5) {map = #map5} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%4 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %5 = polygeist.submap(%arg1, %c2, %c5, %c5, %c4) {map = #map6} : (memref, index, index, index, index) -> memref + %6 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca, %5 : memref<2x4x5xf64>, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %10 = arith.mulf %in, %in_1 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + %7 = polygeist.submap(%arg3, %c2, %c5, %c5) {map = #map9} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%7 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4) {map = #map6} : (memref, index, index, index, index) -> memref + %9 = polygeist.submap(%arg3, %c2, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_0, %8 : memref<2x4x5xf64>, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %10 = arith.mulf %in, %in_1 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/interp_grad_3d__original.frontend.mlir b/issues/mfem_c_kernels/results/interp_grad_3d__original.frontend.mlir new file mode 100644 index 000000000000..124bf228b15f --- /dev/null +++ b/issues/mfem_c_kernels/results/interp_grad_3d__original.frontend.mlir @@ -0,0 +1,76 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_grad_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4x5x5xf64> + %alloca_0 = memref.alloca() : memref<4x5x5xf64> + %alloca_1 = memref.alloca() : memref<4x5x5xf64> + %alloca_2 = memref.alloca() : memref<4x4x5xf64> + %alloca_3 = memref.alloca() : memref<4x4x5xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + %0:2 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst, %arg10 = %cst) -> (f64, f64) { + %1 = affine.load %arg0[%arg4 * 64 + %arg8 + %arg5 * 16 + %arg6 * 4] : memref + %2 = affine.load %arg1[%arg8 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + %5 = affine.load %arg2[%arg8 + %arg7 * 4] : memref + %6 = arith.mulf %1, %5 : f64 + %7 = arith.addf %arg9, %6 : f64 + affine.yield %7, %4 : f64, f64 + } + affine.store %0#1, %alloca_3[%arg5, %arg6, %arg7] : memref<4x4x5xf64> + affine.store %0#0, %alloca_2[%arg5, %arg6, %arg7] : memref<4x4x5xf64> + } + } + } + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0:3 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst, %arg10 = %cst, %arg11 = %cst) -> (f64, f64, f64) { + %1 = affine.load %alloca_2[%arg5, %arg8, %arg7] : memref<4x4x5xf64> + %2 = affine.load %arg1[%arg8 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + %5 = affine.load %alloca_3[%arg5, %arg8, %arg7] : memref<4x4x5xf64> + %6 = affine.load %arg2[%arg8 + %arg6 * 4] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.addf %arg10, %7 : f64 + %9 = arith.mulf %5, %2 : f64 + %10 = arith.addf %arg9, %9 : f64 + affine.yield %10, %8, %4 : f64, f64, f64 + } + affine.store %0#2, %alloca_1[%arg5, %arg6, %arg7] : memref<4x5x5xf64> + affine.store %0#1, %alloca_0[%arg5, %arg6, %arg7] : memref<4x5x5xf64> + affine.store %0#0, %alloca[%arg5, %arg6, %arg7] : memref<4x5x5xf64> + } + } + } + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0:3 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst, %arg10 = %cst, %arg11 = %cst) -> (f64, f64, f64) { + %1 = affine.load %alloca_1[%arg8, %arg6, %arg7] : memref<4x5x5xf64> + %2 = affine.load %arg1[%arg8 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg11, %3 : f64 + %5 = affine.load %alloca_0[%arg8, %arg6, %arg7] : memref<4x5x5xf64> + %6 = arith.mulf %5, %2 : f64 + %7 = arith.addf %arg10, %6 : f64 + %8 = affine.load %alloca[%arg8, %arg6, %arg7] : memref<4x5x5xf64> + %9 = affine.load %arg2[%arg8 + %arg5 * 4] : memref + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %arg9, %10 : f64 + affine.yield %11, %7, %4 : f64, f64, f64 + } + affine.store %0#2, %arg3[%arg4 * 375 + %arg5 + %arg7 * 25 + %arg6 * 5] : memref + affine.store %0#1, %arg3[%arg4 * 375 + %arg5 + %arg7 * 25 + %arg6 * 5 + 125] : memref + affine.store %0#0, %arg3[%arg4 * 375 + %arg5 + %arg7 * 25 + %arg6 * 5 + 250] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/interp_grad_3d__original.raised.mlir b/issues/mfem_c_kernels/results/interp_grad_3d__original.raised.mlir new file mode 100644 index 000000000000..6d86eafa2516 --- /dev/null +++ b/issues/mfem_c_kernels/results/interp_grad_3d__original.raised.mlir @@ -0,0 +1,114 @@ +#map = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 64 + s1 * 16 + s2 * 4)> +#map1 = affine_map<(d0)[s0] -> (d0 + s0 * 4)> +#map2 = affine_map<(d0) -> (d0)> +#map3 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_grad_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4x5x5xf64> + %alloca_0 = memref.alloca() : memref<4x5x5xf64> + %alloca_1 = memref.alloca() : memref<4x5x5xf64> + %alloca_2 = memref.alloca() : memref<4x4x5xf64> + %alloca_3 = memref.alloca() : memref<4x4x5xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + %alloca_4 = memref.alloca() : memref + affine.store %cst, %alloca_4[] : memref + %alloca_5 = memref.alloca() : memref + affine.store %cst, %alloca_5[] : memref + %0 = polygeist.submap(%arg0, %arg4, %arg5, %arg6, %c4) {map = #map} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %arg7, %c4) {map = #map1} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg2, %arg7, %c4) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2, #map2, #map3, #map3], iterator_types = ["reduction"]} ins(%0, %1, %2 : memref, memref, memref) outs(%alloca_4, %alloca_5 : memref, memref) { + ^bb0(%in: f64, %in_6: f64, %in_7: f64, %out: f64, %out_8: f64): + %5 = arith.mulf %in, %in_6 : f64 + %6 = arith.addf %out_8, %5 : f64 + %7 = arith.mulf %in, %in_7 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8, %6 : f64, f64 + } + %3 = affine.load %alloca_4[] : memref + %4 = affine.load %alloca_5[] : memref + affine.store %4, %alloca_3[%arg5, %arg6, %arg7] : memref<4x4x5xf64> + affine.store %3, %alloca_2[%arg5, %arg6, %arg7] : memref<4x4x5xf64> + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %alloca_4 = memref.alloca() : memref + affine.store %cst, %alloca_4[] : memref + %alloca_5 = memref.alloca() : memref + affine.store %cst, %alloca_5[] : memref + %alloca_6 = memref.alloca() : memref + affine.store %cst, %alloca_6[] : memref + %subview = memref.subview %alloca_2[%arg5, 0, %arg7] [1, %c4, 1] [1, 1, 1] : memref<4x4x5xf64> to memref> + %0 = polygeist.submap(%arg1, %arg6, %c4) {map = #map1} : (memref, index, index) -> memref + %subview_7 = memref.subview %alloca_3[%arg5, 0, %arg7] [1, %c4, 1] [1, 1, 1] : memref<4x4x5xf64> to memref> + %1 = polygeist.submap(%arg2, %arg6, %c4) {map = #map1} : (memref, index, index) -> memref + %subview_8 = memref.subview %alloca_4[] [] [] : memref to memref> + %subview_9 = memref.subview %alloca_5[] [] [] : memref to memref> + %subview_10 = memref.subview %alloca_6[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map2, #map2, #map3, #map3, #map3], iterator_types = ["reduction"]} ins(%subview, %0, %subview_7, %1 : memref>, memref, memref>, memref) outs(%subview_8, %subview_9, %subview_10 : memref>, memref>, memref>) { + ^bb0(%in: f64, %in_11: f64, %in_12: f64, %in_13: f64, %out: f64, %out_14: f64, %out_15: f64): + %5 = arith.mulf %in, %in_11 : f64 + %6 = arith.addf %out_15, %5 : f64 + %7 = arith.mulf %in_12, %in_13 : f64 + %8 = arith.addf %out_14, %7 : f64 + %9 = arith.mulf %in_12, %in_11 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10, %8, %6 : f64, f64, f64 + } + %2 = affine.load %alloca_4[] : memref + %3 = affine.load %alloca_5[] : memref + %4 = affine.load %alloca_6[] : memref + affine.store %4, %alloca_1[%arg5, %arg6, %arg7] : memref<4x5x5xf64> + affine.store %3, %alloca_0[%arg5, %arg6, %arg7] : memref<4x5x5xf64> + affine.store %2, %alloca[%arg5, %arg6, %arg7] : memref<4x5x5xf64> + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %alloca_4 = memref.alloca() : memref + affine.store %cst, %alloca_4[] : memref + %alloca_5 = memref.alloca() : memref + affine.store %cst, %alloca_5[] : memref + %alloca_6 = memref.alloca() : memref + affine.store %cst, %alloca_6[] : memref + %subview = memref.subview %alloca_1[0, %arg6, %arg7] [%c4, 1, 1] [1, 1, 1] : memref<4x5x5xf64> to memref> + %0 = polygeist.submap(%arg1, %arg5, %c4) {map = #map1} : (memref, index, index) -> memref + %subview_7 = memref.subview %alloca_0[0, %arg6, %arg7] [%c4, 1, 1] [1, 1, 1] : memref<4x5x5xf64> to memref> + %subview_8 = memref.subview %alloca[0, %arg6, %arg7] [%c4, 1, 1] [1, 1, 1] : memref<4x5x5xf64> to memref> + %1 = polygeist.submap(%arg2, %arg5, %c4) {map = #map1} : (memref, index, index) -> memref + %subview_9 = memref.subview %alloca_4[] [] [] : memref to memref> + %subview_10 = memref.subview %alloca_5[] [] [] : memref to memref> + %subview_11 = memref.subview %alloca_6[] [] [] : memref to memref> + linalg.generic {indexing_maps = [#map2, #map2, #map2, #map2, #map2, #map3, #map3, #map3], iterator_types = ["reduction"]} ins(%subview, %0, %subview_7, %subview_8, %1 : memref>, memref, memref>, memref>, memref) outs(%subview_9, %subview_10, %subview_11 : memref>, memref>, memref>) { + ^bb0(%in: f64, %in_12: f64, %in_13: f64, %in_14: f64, %in_15: f64, %out: f64, %out_16: f64, %out_17: f64): + %5 = arith.mulf %in, %in_12 : f64 + %6 = arith.addf %out_17, %5 : f64 + %7 = arith.mulf %in_13, %in_12 : f64 + %8 = arith.addf %out_16, %7 : f64 + %9 = arith.mulf %in_14, %in_15 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10, %8, %6 : f64, f64, f64 + } + %2 = affine.load %alloca_4[] : memref + %3 = affine.load %alloca_5[] : memref + %4 = affine.load %alloca_6[] : memref + affine.store %4, %arg3[%arg4 * 375 + %arg5 + %arg7 * 25 + %arg6 * 5] : memref + affine.store %3, %arg3[%arg4 * 375 + %arg5 + %arg7 * 25 + %arg6 * 5 + 125] : memref + affine.store %2, %arg3[%arg4 * 375 + %arg5 + %arg7 * 25 + %arg6 * 5 + 250] : memref + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } {polygeist.was_parallel} + } + return + } +} diff --git a/issues/mfem_c_kernels/results/interp_grad_3d_stage_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/interp_grad_3d_stage_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..0364d02f71a0 --- /dev/null +++ b/issues/mfem_c_kernels/results/interp_grad_3d_stage_sliced__normalized.frontend.mlir @@ -0,0 +1,139 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_grad_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x5x5xf64> + %alloca_0 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_1 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg4 * 64 + %arg8 + %arg5 * 16 + %arg6 * 4] : memref + %2 = affine.load %arg1[%arg8 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg4, %arg5, %arg6, %arg7] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg4 * 64 + %arg8 + %arg5 * 16 + %arg6 * 4] : memref + %2 = affine.load %arg2[%arg8 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg4, %arg5, %arg6, %arg7] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca_2[%arg4, %arg5, %arg8, %arg7] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg8 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg4, %arg5, %arg6, %arg7] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg4, %arg5, %arg8, %arg7] : memref<2x4x4x5xf64> + %2 = affine.load %arg2[%arg8 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg4, %arg5, %arg6, %arg7] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca_3[%arg4, %arg5, %arg8, %arg7] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg8 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg4, %arg5, %arg6, %arg7] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca_1[%arg4, %arg8, %arg6, %arg7] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg8 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %arg3[%arg4 * 375 + %arg5 + %arg7 * 25 + %arg6 * 5] : memref + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca_0[%arg4, %arg8, %arg6, %arg7] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg8 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %arg3[%arg4 * 375 + %arg5 + %arg7 * 25 + %arg6 * 5 + 125] : memref + } + } + } + } + affine.for %arg4 = 0 to 2 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg4, %arg8, %arg6, %arg7] : memref<2x4x5x5xf64> + %2 = affine.load %arg2[%arg8 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %arg3[%arg4 * 375 + %arg5 + %arg7 * 25 + %arg6 * 5 + 250] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/interp_grad_3d_stage_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/interp_grad_3d_stage_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..6aa8632bc3fb --- /dev/null +++ b/issues/mfem_c_kernels/results/interp_grad_3d_stage_sliced__normalized.raised.mlir @@ -0,0 +1,125 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 125)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 125)> +#map13 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 250)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d3 * 25 + d1 + d0 * 375 + d2 * 5 + 250)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_grad_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x5x5xf64> + %alloca_0 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_1 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_2 = memref.alloca() : memref<2x4x4x5xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_3 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %16 = arith.mulf %in, %in_4 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %3 = polygeist.submap(%arg2, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%2, %3 : memref, memref) outs(%alloca_2 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %16 = arith.mulf %in, %in_4 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_2, %4 : memref<2x4x4x5xf64>, memref) outs(%alloca_1 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %16 = arith.mulf %in, %in_4 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %5 = polygeist.submap(%arg2, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_3, %5 : memref<2x4x4x5xf64>, memref) outs(%alloca_0 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %16 = arith.mulf %in, %in_4 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_3, %6 : memref<2x4x4x5xf64>, memref) outs(%alloca : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %16 = arith.mulf %in, %in_4 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } + %7 = polygeist.submap(%arg3, %c2, %c5, %c5, %c5) {map = #map7} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%7 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %8 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map8} : (memref, index, index, index, index, index) -> memref + %9 = polygeist.submap(%arg3, %c2, %c5, %c5, %c5, %c4) {map = #map9} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_1, %8 : memref<2x4x5x5xf64>, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %16 = arith.mulf %in, %in_4 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } + %10 = polygeist.submap(%arg3, %c2, %c5, %c5, %c5) {map = #map11} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%10 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %11 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map8} : (memref, index, index, index, index, index) -> memref + %12 = polygeist.submap(%arg3, %c2, %c5, %c5, %c5, %c4) {map = #map12} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_0, %11 : memref<2x4x5x5xf64>, memref) outs(%12 : memref) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %16 = arith.mulf %in, %in_4 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } + %13 = polygeist.submap(%arg3, %c2, %c5, %c5, %c5) {map = #map13} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%13 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg2, %c2, %c5, %c5, %c5, %c4) {map = #map8} : (memref, index, index, index, index, index) -> memref + %15 = polygeist.submap(%arg3, %c2, %c5, %c5, %c5, %c4) {map = #map14} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca, %14 : memref<2x4x5x5xf64>, memref) outs(%15 : memref) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %16 = arith.mulf %in, %in_4 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/interp_value_2d__original.frontend.mlir b/issues/mfem_c_kernels/results/interp_value_2d__original.frontend.mlir new file mode 100644 index 000000000000..ea5391b1edb5 --- /dev/null +++ b/issues/mfem_c_kernels/results/interp_value_2d__original.frontend.mlir @@ -0,0 +1,33 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_value_2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4x5xf64> + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 5 { + %0 = affine.for %arg6 = 0 to 4 iter_args(%arg7 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg6 + %arg5 * 4] : memref + %2 = affine.load %arg0[%arg6 + %arg3 * 16 + %arg4 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg7, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg4, %arg5] : memref<4x5xf64> + } + } + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 5 { + %0 = affine.for %arg6 = 0 to 4 iter_args(%arg7 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg6, %arg4] : memref<4x5xf64> + %2 = affine.load %arg1[%arg6 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg7, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %arg2[%arg5 + %arg3 * 25 + %arg4 * 5] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/interp_value_2d__original.raised.mlir b/issues/mfem_c_kernels/results/interp_value_2d__original.raised.mlir new file mode 100644 index 000000000000..d6142a6cd4e9 --- /dev/null +++ b/issues/mfem_c_kernels/results/interp_value_2d__original.raised.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0, d1, d2) -> (d2 + d1 * 4)> +#map2 = affine_map<(d0, d1, d2)[s0] -> (d2 + s0 * 16 + d0 * 4)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map4 = affine_map<(d0, d1, d2) -> (d0, d1)> +#map5 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 25 + d0 * 5)> +#map6 = affine_map<(d0, d1, d2)[s0] -> (d1 + s0 * 25 + d0 * 5)> +#map7 = affine_map<(d0, d1, d2) -> (d2, d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_value_2d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4x5xf64> + affine.for %arg3 = 0 to 2 { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%alloca : memref<4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg1, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %arg3, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca : memref<4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } + %2 = polygeist.submap(%arg2, %arg3, %c5, %c5) {map = #map5} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%2 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %3 = polygeist.submap(%arg1, %c5, %c5, %c4) {map = #map1} : (memref, index, index, index) -> memref + %4 = polygeist.submap(%arg2, %arg3, %c5, %c5, %c4) {map = #map6} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map7, #map3, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%alloca, %3 : memref<4x5xf64>, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/interp_value_2d_scratch_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/interp_value_2d_scratch_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..3cf06c0dfe7d --- /dev/null +++ b/issues/mfem_c_kernels/results/interp_value_2d_scratch_sliced__normalized.frontend.mlir @@ -0,0 +1,35 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_value_2d_scratch_sliced(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x5xf64> + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 5 { + %0 = affine.for %arg6 = 0 to 4 iter_args(%arg7 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg6 + %arg5 * 4] : memref + %2 = affine.load %arg0[%arg6 + %arg3 * 16 + %arg4 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg7, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg3, %arg4, %arg5] : memref<2x4x5xf64> + } + } + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 5 { + %0 = affine.for %arg6 = 0 to 4 iter_args(%arg7 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg3, %arg6, %arg4] : memref<2x4x5xf64> + %2 = affine.load %arg1[%arg6 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg7, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %arg2[%arg5 + %arg3 * 25 + %arg4 * 5] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/interp_value_2d_scratch_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/interp_value_2d_scratch_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..b96e03bc77b7 --- /dev/null +++ b/issues/mfem_c_kernels/results/interp_value_2d_scratch_sliced__normalized.raised.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2) -> (d2 + d0 * 25 + d1 * 5)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 25 + d1 * 5)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_value_2d_scratch_sliced(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca : memref<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg1, %c2, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } + %2 = polygeist.submap(%arg2, %c2, %c5, %c5) {map = #map5} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%2 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %3 = polygeist.submap(%arg1, %c2, %c5, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %4 = polygeist.submap(%arg2, %c2, %c5, %c5, %c4) {map = #map6} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map7, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca, %3 : memref<2x4x5xf64>, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/interp_value_3d__original.frontend.mlir b/issues/mfem_c_kernels/results/interp_value_3d__original.frontend.mlir new file mode 100644 index 000000000000..ca1d264df605 --- /dev/null +++ b/issues/mfem_c_kernels/results/interp_value_3d__original.frontend.mlir @@ -0,0 +1,52 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_value_3d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4x5x5xf64> + %alloca_0 = memref.alloca() : memref<4x4x5xf64> + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg7 + %arg6 * 4] : memref + %2 = affine.load %arg0[%arg3 * 64 + %arg7 + %arg4 * 16 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg4, %arg5, %arg6] : memref<4x4x5xf64> + } + } + } + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca_0[%arg4, %arg7, %arg5] : memref<4x4x5xf64> + %2 = affine.load %arg1[%arg7 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg4, %arg6, %arg5] : memref<4x5x5xf64> + } + } + } + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg7, %arg5, %arg6] : memref<4x5x5xf64> + %2 = affine.load %arg1[%arg7 + %arg4 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %arg2[%arg3 * 125 + %arg4 + %arg6 * 25 + %arg5 * 5] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/interp_value_3d__original.raised.mlir b/issues/mfem_c_kernels/results/interp_value_3d__original.raised.mlir new file mode 100644 index 000000000000..03e0ea59d93b --- /dev/null +++ b/issues/mfem_c_kernels/results/interp_value_3d__original.raised.mlir @@ -0,0 +1,60 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3)[s0] -> (d3 + s0 * 64 + d0 * 16 + d1 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2) -> (d0, d2, d1)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d1)> +#map7 = affine_map<(d0, d1, d2, d3) -> (d0, d2, d1)> +#map8 = affine_map<(d0, d1, d2)[s0] -> (d2 * 25 + d0 + s0 * 125 + d1 * 5)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 4)> +#map10 = affine_map<(d0, d1, d2, d3)[s0] -> (d2 * 25 + d0 + s0 * 125 + d1 * 5)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d3, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_value_3d(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4x5x5xf64> + %alloca_0 = memref.alloca() : memref<4x4x5xf64> + affine.for %arg3 = 0 to 2 { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg1, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %arg3, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_0 : memref<4x4x5xf64>) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %6 = arith.mulf %in, %in_1 : f64 + %7 = arith.addf %out, %6 : f64 + linalg.yield %7 : f64 + } + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca : memref<4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg1, %c4, %c5, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map7], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca_0, %2 : memref<4x4x5xf64>, memref) outs(%alloca : memref<4x5x5xf64>) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %6 = arith.mulf %in, %in_1 : f64 + %7 = arith.addf %out, %6 : f64 + linalg.yield %7 : f64 + } + %3 = polygeist.submap(%arg2, %arg3, %c5, %c5, %c5) {map = #map8} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg1, %c5, %c5, %c5, %c4) {map = #map9} : (memref, index, index, index, index) -> memref + %5 = polygeist.submap(%arg2, %arg3, %c5, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map11, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%alloca, %4 : memref<4x5x5xf64>, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %6 = arith.mulf %in, %in_1 : f64 + %7 = arith.addf %out, %6 : f64 + linalg.yield %7 : f64 + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/interp_value_3d_scratch_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/interp_value_3d_scratch_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..8373527f626a --- /dev/null +++ b/issues/mfem_c_kernels/results/interp_value_3d_scratch_sliced__normalized.frontend.mlir @@ -0,0 +1,56 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_value_3d_scratch_sliced(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x5x5xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 4 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg7 + %arg6 * 4] : memref + %2 = affine.load %arg0[%arg3 * 64 + %arg7 + %arg4 * 16 + %arg5 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg3, %arg4, %arg5, %arg6] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 4 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca_0[%arg3, %arg4, %arg7, %arg5] : memref<2x4x4x5xf64> + %2 = affine.load %arg1[%arg7 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg3, %arg4, %arg6, %arg5] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg3 = 0 to 2 { + affine.for %arg4 = 0 to 5 { + affine.for %arg5 = 0 to 5 { + affine.for %arg6 = 0 to 5 { + %0 = affine.for %arg7 = 0 to 4 iter_args(%arg8 = %cst) -> (f64) { + %1 = affine.load %alloca[%arg3, %arg7, %arg5, %arg6] : memref<2x4x5x5xf64> + %2 = affine.load %arg1[%arg7 + %arg4 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg8, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %arg2[%arg3 * 125 + %arg4 + %arg6 * 25 + %arg5 * 5] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/interp_value_3d_scratch_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/interp_value_3d_scratch_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..69c5602f8ea5 --- /dev/null +++ b/issues/mfem_c_kernels/results/interp_value_3d_scratch_sliced__normalized.raised.mlir @@ -0,0 +1,59 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3, d2)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d2)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d3, d2)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 * 25 + d1 + d0 * 125 + d2 * 5)> +#map9 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d3 * 25 + d1 + d0 * 125 + d2 * 5)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_interp_value_3d_scratch_sliced(%arg0: memref, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x4x5x5xf64> + %alloca_0 = memref.alloca() : memref<2x4x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_0 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %6 = arith.mulf %in, %in_1 : f64 + %7 = arith.addf %out, %6 : f64 + linalg.yield %7 : f64 + } + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg1, %c2, %c4, %c5, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map3, #map7], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca_0, %2 : memref<2x4x4x5xf64>, memref) outs(%alloca : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %6 = arith.mulf %in, %in_1 : f64 + %7 = arith.addf %out, %6 : f64 + linalg.yield %7 : f64 + } + %3 = polygeist.submap(%arg2, %c2, %c5, %c5, %c5) {map = #map8} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg1, %c2, %c5, %c5, %c5, %c4) {map = #map9} : (memref, index, index, index, index, index) -> memref + %5 = polygeist.submap(%arg2, %c2, %c5, %c5, %c5, %c4) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map11, #map3, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%alloca, %4 : memref<2x4x5x5xf64>, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %6 = arith.mulf %in, %in_1 : f64 + %7 = arith.addf %out, %6 : f64 + linalg.yield %7 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/mass_apply_2d__original.frontend.mlir b/issues/mfem_c_kernels/results/mass_apply_2d__original.frontend.mlir new file mode 100644 index 000000000000..2a977a15fbdb --- /dev/null +++ b/issues/mfem_c_kernels/results/mass_apply_2d__original.frontend.mlir @@ -0,0 +1,74 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_mass_apply_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4xf64> + %alloca_0 = memref.alloca() : memref<5xf64> + %alloca_1 = memref.alloca() : memref<5x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.store %cst, %alloca_1[%arg6, %arg7] : memref<5x5xf64> + } + } + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.store %cst, %alloca_0[%arg7] : memref<5xf64> + } + affine.for %arg7 = 0 to 4 { + %0 = affine.load %arg3[%arg7 + %arg5 * 16 + %arg6 * 4] : memref + affine.for %arg8 = 0 to 5 { + %1 = affine.load %arg0[%arg7 + %arg8 * 4] : memref + %2 = arith.mulf %1, %0 : f64 + %3 = affine.load %alloca_0[%arg8] : memref<5xf64> + %4 = arith.addf %3, %2 : f64 + affine.store %4, %alloca_0[%arg8] : memref<5xf64> + } + } + affine.for %arg7 = 0 to 5 { + %0 = affine.load %arg0[%arg6 + %arg7 * 4] : memref + affine.for %arg8 = 0 to 5 { + %1 = affine.load %alloca_0[%arg8] : memref<5xf64> + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %alloca_1[%arg7, %arg8] : memref<5x5xf64> + %4 = arith.addf %3, %2 : f64 + affine.store %4, %alloca_1[%arg7, %arg8] : memref<5x5xf64> + } + } + } + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.load %arg2[%arg7 + %arg5 * 25 + %arg6 * 5] : memref + %1 = affine.load %alloca_1[%arg6, %arg7] : memref<5x5xf64> + %2 = arith.mulf %1, %0 : f64 + affine.store %2, %alloca_1[%arg6, %arg7] : memref<5x5xf64> + } + } + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.store %cst, %alloca[%arg7] : memref<4xf64> + } + affine.for %arg7 = 0 to 5 { + %0 = affine.load %alloca_1[%arg6, %arg7] : memref<5x5xf64> + affine.for %arg8 = 0 to 4 { + %1 = affine.load %arg1[%arg7 + %arg8 * 5] : memref + %2 = arith.mulf %1, %0 : f64 + %3 = affine.load %alloca[%arg8] : memref<4xf64> + %4 = arith.addf %3, %2 : f64 + affine.store %4, %alloca[%arg8] : memref<4xf64> + } + } + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.load %arg1[%arg6 + %arg7 * 5] : memref + %1 = affine.load %alloca[%arg8] : memref<4xf64> + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %arg4[%arg8 + %arg5 * 16 + %arg7 * 4] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg4[%arg8 + %arg5 * 16 + %arg7 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/mass_apply_2d__original.raised.mlir b/issues/mfem_c_kernels/results/mass_apply_2d__original.raised.mlir new file mode 100644 index 000000000000..8ec297fbc446 --- /dev/null +++ b/issues/mfem_c_kernels/results/mass_apply_2d__original.raised.mlir @@ -0,0 +1,77 @@ +#map = affine_map<(d0, d1) -> (d0, d1)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1 * 4 + d0)> +#map3 = affine_map<(d0)[s0, s1] -> (d0 + s0 * 16 + s1 * 4)> +#map4 = affine_map<(d0, d1) -> (d0)> +#map5 = affine_map<(d0, d1) -> (d1)> +#map6 = affine_map<(d0)[s0] -> (d0 * 4 + s0)> +#map7 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 25 + d0 * 5)> +#map8 = affine_map<(d0, d1) -> (d1 * 5 + d0)> +#map9 = affine_map<(d0, d1)[s0] -> (d0 * 5 + s0)> +#map10 = affine_map<(d0, d1)[s0] -> (d1 + s0 * 16 + d0 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_mass_apply_2d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4xf64> + %alloca_0 = memref.alloca() : memref<5xf64> + %alloca_1 = memref.alloca() : memref<5x5xf64> + affine.for %arg5 = 0 to 2 { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel"]} outs(%alloca_1 : memref<5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg6 = 0 to 4 { + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel"]} outs(%alloca_0 : memref<5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %1 = polygeist.submap(%arg0, %c4, %c5) {map = #map2} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg3, %arg5, %arg6, %c4) {map = #map3} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map4, #map, #map5], iterator_types = ["reduction", "parallel"]} ins(%2, %1 : memref, memref) outs(%alloca_0 : memref<5xf64>) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %4 = arith.mulf %in_2, %in : f64 + %5 = arith.addf %out, %4 : f64 + linalg.yield %5 : f64 + } + %3 = polygeist.submap(%arg0, %arg6, %c5) {map = #map6} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map4, #map5, #map], iterator_types = ["parallel", "parallel"]} ins(%3, %alloca_0 : memref, memref<5xf64>) outs(%alloca_1 : memref<5x5xf64>) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %4 = arith.mulf %in, %in_2 : f64 + %5 = arith.addf %out, %4 : f64 + linalg.yield %5 : f64 + } + } + %0 = polygeist.submap(%arg2, %arg5, %c5, %c5) {map = #map7} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%0 : memref) outs(%alloca_1 : memref<5x5xf64>) { + ^bb0(%in: f64, %out: f64): + %1 = arith.mulf %out, %in : f64 + linalg.yield %1 : f64 + } + affine.for %arg6 = 0 to 5 { + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel"]} outs(%alloca : memref<4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %1 = polygeist.submap(%arg1, %c5, %c4) {map = #map8} : (memref, index, index) -> memref + %subview = memref.subview %alloca_1[%arg6, 0] [1, %c5] [1, 1] : memref<5x5xf64> to memref> + linalg.generic {indexing_maps = [#map4, #map, #map5], iterator_types = ["reduction", "parallel"]} ins(%subview, %1 : memref>, memref) outs(%alloca : memref<4xf64>) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %4 = arith.mulf %in_2, %in : f64 + %5 = arith.addf %out, %4 : f64 + linalg.yield %5 : f64 + } + %2 = polygeist.submap(%arg1, %arg6, %c4, %c4) {map = #map9} : (memref, index, index, index) -> memref + %3 = polygeist.submap(%arg4, %arg5, %c4, %c4) {map = #map10} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map5, #map], iterator_types = ["parallel", "parallel"]} ins(%2, %alloca : memref, memref<4xf64>) outs(%3 : memref) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %4 = arith.mulf %in, %in_2 : f64 + %5 = arith.addf %out, %4 : f64 + linalg.yield %5 : f64 + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/mass_apply_2d_stage_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/mass_apply_2d_stage_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..1083d538cdc3 --- /dev/null +++ b/issues/mfem_c_kernels/results/mass_apply_2d_stage_sliced__normalized.frontend.mlir @@ -0,0 +1,77 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_mass_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x5xf64> + %alloca_1 = memref.alloca() : memref<2x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg8 + %arg7 * 4] : memref + %2 = affine.load %arg3[%arg8 + %arg5 * 16 + %arg6 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg5, %arg6, %arg7] : memref<2x4x5xf64> + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.for %arg8 = 0 to 4 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg8 + %arg6 * 4] : memref + %2 = affine.load %alloca_1[%arg5, %arg8, %arg7] : memref<2x4x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg5, %arg6, %arg7] : memref<2x5x5xf64> + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + %0 = affine.load %arg2[%arg7 + %arg5 * 25 + %arg6 * 5] : memref + %1 = affine.load %alloca_0[%arg5, %arg6, %arg7] : memref<2x5x5xf64> + %2 = arith.mulf %1, %0 : f64 + affine.store %2, %alloca_0[%arg5, %arg6, %arg7] : memref<2x5x5xf64> + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg8 + %arg7 * 5] : memref + %2 = affine.load %alloca_0[%arg5, %arg6, %arg8] : memref<2x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg9, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg5, %arg6, %arg7] : memref<2x5x4xf64> + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + %0 = affine.for %arg8 = 0 to 5 iter_args(%arg9 = %cst) -> (f64) { + %3 = affine.load %arg1[%arg8 + %arg6 * 5] : memref + %4 = affine.load %alloca[%arg5, %arg8, %arg7] : memref<2x5x4xf64> + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg9, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg4[%arg7 + %arg5 * 16 + %arg6 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg4[%arg7 + %arg5 * 16 + %arg6 * 4] : memref + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/mass_apply_2d_stage_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/mass_apply_2d_stage_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..c282125b69a4 --- /dev/null +++ b/issues/mfem_c_kernels/results/mass_apply_2d_stage_sliced__normalized.raised.mlir @@ -0,0 +1,72 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 4)> +#map2 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 16 + d1 * 4)> +#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> +#map5 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 4)> +#map6 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d2)> +#map7 = affine_map<(d0, d1, d2) -> (d2 + d0 * 25 + d1 * 5)> +#map8 = affine_map<(d0, d1, d2, d3) -> (d3 + d2 * 5)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> +#map10 = affine_map<(d0, d1, d2, d3) -> (d3 + d1 * 5)> +#map11 = affine_map<(d0, d1, d2, d3) -> (d2 + d0 * 16 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_mass_apply_2d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x5xf64> + %alloca_1 = memref.alloca() : memref<2x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg0, %c2, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index) -> memref + %1 = polygeist.submap(%arg3, %c2, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_1 : memref<2x4x5xf64>) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %7 = arith.mulf %in, %in_2 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg0, %c2, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%2, %alloca_1 : memref, memref<2x4x5xf64>) outs(%alloca_0 : memref<2x5x5xf64>) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %7 = arith.mulf %in, %in_2 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } + %3 = polygeist.submap(%arg2, %c2, %c5, %c5) {map = #map7} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3 : memref) outs(%alloca_0 : memref<2x5x5xf64>) { + ^bb0(%in: f64, %out: f64): + %7 = arith.mulf %out, %in : f64 + linalg.yield %7 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca : memref<2x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg1, %c2, %c5, %c4, %c5) {map = #map8} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map9, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%4, %alloca_0 : memref, memref<2x5x5xf64>) outs(%alloca : memref<2x5x4xf64>) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %7 = arith.mulf %in, %in_2 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } + %5 = polygeist.submap(%arg1, %c2, %c4, %c4, %c5) {map = #map10} : (memref, index, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %c2, %c4, %c4, %c5) {map = #map11} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map6, #map3], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%5, %alloca : memref, memref<2x5x4xf64>) outs(%6 : memref) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %7 = arith.mulf %in, %in_2 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/mass_apply_3d__original.frontend.mlir b/issues/mfem_c_kernels/results/mass_apply_3d__original.frontend.mlir new file mode 100644 index 000000000000..a7f804ee5d8d --- /dev/null +++ b/issues/mfem_c_kernels/results/mass_apply_3d__original.frontend.mlir @@ -0,0 +1,118 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_mass_apply_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4xf64> + %alloca_0 = memref.alloca() : memref<4x4xf64> + %alloca_1 = memref.alloca() : memref<5xf64> + %alloca_2 = memref.alloca() : memref<5x5xf64> + %alloca_3 = memref.alloca() : memref<5x5x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.store %cst, %alloca_3[%arg6, %arg7, %arg8] : memref<5x5x5xf64> + } + } + } + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + affine.store %cst, %alloca_2[%arg7, %arg8] : memref<5x5xf64> + } + } + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + affine.store %cst, %alloca_1[%arg8] : memref<5xf64> + } + affine.for %arg8 = 0 to 4 { + %0 = affine.load %arg3[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + affine.for %arg9 = 0 to 5 { + %1 = affine.load %arg0[%arg8 + %arg9 * 4] : memref + %2 = arith.mulf %1, %0 : f64 + %3 = affine.load %alloca_1[%arg9] : memref<5xf64> + %4 = arith.addf %3, %2 : f64 + affine.store %4, %alloca_1[%arg9] : memref<5xf64> + } + } + affine.for %arg8 = 0 to 5 { + %0 = affine.load %arg0[%arg7 + %arg8 * 4] : memref + affine.for %arg9 = 0 to 5 { + %1 = affine.load %alloca_1[%arg9] : memref<5xf64> + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %alloca_2[%arg8, %arg9] : memref<5x5xf64> + %4 = arith.addf %3, %2 : f64 + affine.store %4, %alloca_2[%arg8, %arg9] : memref<5x5xf64> + } + } + } + affine.for %arg7 = 0 to 5 { + %0 = affine.load %arg0[%arg6 + %arg7 * 4] : memref + affine.for %arg8 = 0 to 5 { + affine.for %arg9 = 0 to 5 { + %1 = affine.load %alloca_2[%arg8, %arg9] : memref<5x5xf64> + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %alloca_3[%arg7, %arg8, %arg9] : memref<5x5x5xf64> + %4 = arith.addf %3, %2 : f64 + affine.store %4, %alloca_3[%arg7, %arg8, %arg9] : memref<5x5x5xf64> + } + } + } + } + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.load %arg2[%arg5 * 125 + %arg8 + %arg6 * 25 + %arg7 * 5] : memref + %1 = affine.load %alloca_3[%arg6, %arg7, %arg8] : memref<5x5x5xf64> + %2 = arith.mulf %1, %0 : f64 + affine.store %2, %alloca_3[%arg6, %arg7, %arg8] : memref<5x5x5xf64> + } + } + } + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + affine.store %cst, %alloca_0[%arg7, %arg8] : memref<4x4xf64> + } + } + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + affine.store %cst, %alloca[%arg8] : memref<4xf64> + } + affine.for %arg8 = 0 to 5 { + %0 = affine.load %alloca_3[%arg6, %arg7, %arg8] : memref<5x5x5xf64> + affine.for %arg9 = 0 to 4 { + %1 = affine.load %arg1[%arg8 + %arg9 * 5] : memref + %2 = arith.mulf %1, %0 : f64 + %3 = affine.load %alloca[%arg9] : memref<4xf64> + %4 = arith.addf %3, %2 : f64 + affine.store %4, %alloca[%arg9] : memref<4xf64> + } + } + affine.for %arg8 = 0 to 4 { + %0 = affine.load %arg1[%arg7 + %arg8 * 5] : memref + affine.for %arg9 = 0 to 4 { + %1 = affine.load %alloca[%arg9] : memref<4xf64> + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %alloca_0[%arg8, %arg9] : memref<4x4xf64> + %4 = arith.addf %3, %2 : f64 + affine.store %4, %alloca_0[%arg8, %arg9] : memref<4x4xf64> + } + } + } + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + affine.for %arg9 = 0 to 4 { + %0 = affine.load %arg1[%arg6 + %arg7 * 5] : memref + %1 = affine.load %alloca_0[%arg8, %arg9] : memref<4x4xf64> + %2 = arith.mulf %0, %1 : f64 + %3 = affine.load %arg4[%arg5 * 64 + %arg9 + %arg7 * 16 + %arg8 * 4] : memref + %4 = arith.addf %3, %2 : f64 + affine.store %4, %arg4[%arg5 * 64 + %arg9 + %arg7 * 16 + %arg8 * 4] : memref + } + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/mass_apply_3d__original.raised.mlir b/issues/mfem_c_kernels/results/mass_apply_3d__original.raised.mlir new file mode 100644 index 000000000000..862b0a56876f --- /dev/null +++ b/issues/mfem_c_kernels/results/mass_apply_3d__original.raised.mlir @@ -0,0 +1,109 @@ +#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d1 * 4 + d0)> +#map4 = affine_map<(d0)[s0, s1, s2] -> (d0 + s0 * 64 + s1 * 16 + s2 * 4)> +#map5 = affine_map<(d0, d1) -> (d0)> +#map6 = affine_map<(d0, d1) -> (d1)> +#map7 = affine_map<(d0)[s0] -> (d0 * 4 + s0)> +#map8 = affine_map<(d0, d1, d2) -> (d0)> +#map9 = affine_map<(d0, d1, d2) -> (d1, d2)> +#map10 = affine_map<(d0, d1, d2)[s0] -> (d2 + s0 * 125 + d0 * 25 + d1 * 5)> +#map11 = affine_map<(d0, d1) -> (d1 * 5 + d0)> +#map12 = affine_map<(d0)[s0] -> (d0 * 5 + s0)> +#map13 = affine_map<(d0, d1, d2)[s0] -> (d0 * 5 + s0)> +#map14 = affine_map<(d0, d1, d2)[s0] -> (d2 + s0 * 64 + d0 * 16 + d1 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_mass_apply_3d(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<4xf64> + %alloca_0 = memref.alloca() : memref<4x4xf64> + %alloca_1 = memref.alloca() : memref<5xf64> + %alloca_2 = memref.alloca() : memref<5x5xf64> + %alloca_3 = memref.alloca() : memref<5x5x5xf64> + affine.for %arg5 = 0 to 2 { + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg6 = 0 to 4 { + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%alloca_2 : memref<5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg7 = 0 to 4 { + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel"]} outs(%alloca_1 : memref<5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg0, %c4, %c5) {map = #map3} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg3, %arg5, %arg6, %arg7, %c4) {map = #map4} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map1, #map6], iterator_types = ["reduction", "parallel"]} ins(%3, %2 : memref, memref) outs(%alloca_1 : memref<5xf64>) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %5 = arith.mulf %in_4, %in : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } + %4 = polygeist.submap(%arg0, %arg7, %c5) {map = #map7} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map6, #map1], iterator_types = ["parallel", "parallel"]} ins(%4, %alloca_1 : memref, memref<5xf64>) outs(%alloca_2 : memref<5x5xf64>) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %5 = arith.mulf %in, %in_4 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } + } + %1 = polygeist.submap(%arg0, %arg6, %c5) {map = #map7} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map9, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1, %alloca_2 : memref, memref<5x5xf64>) outs(%alloca_3 : memref<5x5x5xf64>) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %2 = arith.mulf %in, %in_4 : f64 + %3 = arith.addf %out, %2 : f64 + linalg.yield %3 : f64 + } + } + %0 = polygeist.submap(%arg2, %arg5, %c5, %c5, %c5) {map = #map10} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%0 : memref) outs(%alloca_3 : memref<5x5x5xf64>) { + ^bb0(%in: f64, %out: f64): + %1 = arith.mulf %out, %in : f64 + linalg.yield %1 : f64 + } + affine.for %arg6 = 0 to 5 { + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%alloca_0 : memref<4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + affine.for %arg7 = 0 to 5 { + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel"]} outs(%alloca : memref<4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %3 = polygeist.submap(%arg1, %c5, %c4) {map = #map11} : (memref, index, index) -> memref + %subview = memref.subview %alloca_3[%arg6, %arg7, 0] [1, 1, %c5] [1, 1, 1] : memref<5x5x5xf64> to memref> + linalg.generic {indexing_maps = [#map5, #map1, #map6], iterator_types = ["reduction", "parallel"]} ins(%subview, %3 : memref>, memref) outs(%alloca : memref<4xf64>) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %5 = arith.mulf %in_4, %in : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } + %4 = polygeist.submap(%arg1, %arg7, %c4) {map = #map12} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map6, #map1], iterator_types = ["parallel", "parallel"]} ins(%4, %alloca : memref, memref<4xf64>) outs(%alloca_0 : memref<4x4xf64>) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %5 = arith.mulf %in, %in_4 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } + } + %1 = polygeist.submap(%arg1, %arg6, %c4, %c4, %c4) {map = #map13} : (memref, index, index, index, index) -> memref + %2 = polygeist.submap(%arg4, %arg5, %c4, %c4, %c4) {map = #map14} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map9, #map], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1, %alloca_0 : memref, memref<4x4xf64>) outs(%2 : memref) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %3 = arith.mulf %in, %in_4 : f64 + %4 = arith.addf %out, %3 : f64 + linalg.yield %4 : f64 + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/mass_apply_3d_stage_sliced__normalized.frontend.mlir b/issues/mfem_c_kernels/results/mass_apply_3d_stage_sliced__normalized.frontend.mlir new file mode 100644 index 000000000000..50c745c6a815 --- /dev/null +++ b/issues/mfem_c_kernels/results/mass_apply_3d_stage_sliced__normalized.frontend.mlir @@ -0,0 +1,121 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_mass_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_2 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x5xf64> + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg9 + %arg8 * 4] : memref + %2 = affine.load %arg3[%arg5 * 64 + %arg9 + %arg6 * 16 + %arg7 * 4] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_3[%arg5, %arg6, %arg7, %arg8] : memref<2x4x4x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg9 + %arg7 * 4] : memref + %2 = affine.load %alloca_3[%arg5, %arg6, %arg9, %arg8] : memref<2x4x4x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_2[%arg5, %arg6, %arg7, %arg8] : memref<2x4x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.for %arg9 = 0 to 4 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg0[%arg9 + %arg6 * 4] : memref + %2 = affine.load %alloca_2[%arg5, %arg9, %arg7, %arg8] : memref<2x4x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_1[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 5 { + %0 = affine.load %arg2[%arg5 * 125 + %arg8 + %arg6 * 25 + %arg7 * 5] : memref + %1 = affine.load %alloca_1[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + %2 = arith.mulf %1, %0 : f64 + affine.store %2, %alloca_1[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x5xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 5 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg9 + %arg8 * 5] : memref + %2 = affine.load %alloca_1[%arg5, %arg6, %arg7, %arg9] : memref<2x5x5x5xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca_0[%arg5, %arg6, %arg7, %arg8] : memref<2x5x5x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 5 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %1 = affine.load %arg1[%arg9 + %arg7 * 5] : memref + %2 = affine.load %alloca_0[%arg5, %arg6, %arg9, %arg8] : memref<2x5x5x4xf64> + %3 = arith.mulf %1, %2 : f64 + %4 = arith.addf %arg10, %3 : f64 + affine.yield %4 : f64 + } + affine.store %0, %alloca[%arg5, %arg6, %arg7, %arg8] : memref<2x5x4x4xf64> + } + } + } + } + affine.for %arg5 = 0 to 2 { + affine.for %arg6 = 0 to 4 { + affine.for %arg7 = 0 to 4 { + affine.for %arg8 = 0 to 4 { + %0 = affine.for %arg9 = 0 to 5 iter_args(%arg10 = %cst) -> (f64) { + %3 = affine.load %arg1[%arg9 + %arg6 * 5] : memref + %4 = affine.load %alloca[%arg5, %arg9, %arg7, %arg8] : memref<2x5x4x4xf64> + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %arg10, %5 : f64 + affine.yield %6 : f64 + } + %1 = affine.load %arg4[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + %2 = arith.addf %1, %0 : f64 + affine.store %2, %arg4[%arg5 * 64 + %arg8 + %arg6 * 16 + %arg7 * 4] : memref + } + } + } + } + return + } +} diff --git a/issues/mfem_c_kernels/results/mass_apply_3d_stage_sliced__normalized.raised.mlir b/issues/mfem_c_kernels/results/mass_apply_3d_stage_sliced__normalized.raised.mlir new file mode 100644 index 000000000000..e0a2716fce2f --- /dev/null +++ b/issues/mfem_c_kernels/results/mass_apply_3d_stage_sliced__normalized.raised.mlir @@ -0,0 +1,99 @@ +#map = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> +#map1 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 4)> +#map2 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d0 * 64 + d1 * 16 + d2 * 4)> +#map3 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)> +#map4 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)> +#map5 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 4)> +#map6 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d4, d3)> +#map7 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 4)> +#map8 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d4, d2, d3)> +#map9 = affine_map<(d0, d1, d2, d3) -> (d3 + d0 * 125 + d1 * 25 + d2 * 5)> +#map10 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d3 * 5)> +#map11 = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d4)> +#map12 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d2 * 5)> +#map13 = affine_map<(d0, d1, d2, d3, d4) -> (d4 + d1 * 5)> +#map14 = affine_map<(d0, d1, d2, d3, d4) -> (d3 + d0 * 64 + d1 * 16 + d2 * 4)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mfem_pa_mass_apply_3d_stage_sliced(%arg0: memref, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c2 = arith.constant 2 : index + %c5 = arith.constant 5 : index + %c4 = arith.constant 4 : index + %cst = arith.constant 0.000000e+00 : f64 + %alloca = memref.alloca() : memref<2x5x4x4xf64> + %alloca_0 = memref.alloca() : memref<2x5x5x4xf64> + %alloca_1 = memref.alloca() : memref<2x5x5x5xf64> + %alloca_2 = memref.alloca() : memref<2x4x5x5xf64> + %alloca_3 = memref.alloca() : memref<2x4x4x5xf64> + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_3 : memref<2x4x4x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %0 = polygeist.submap(%arg0, %c2, %c4, %c4, %c5, %c4) {map = #map1} : (memref, index, index, index, index, index) -> memref + %1 = polygeist.submap(%arg3, %c2, %c4, %c4, %c5, %c4) {map = #map2} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%0, %1 : memref, memref) outs(%alloca_3 : memref<2x4x4x5xf64>) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %9 = arith.mulf %in, %in_4 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_2 : memref<2x4x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg0, %c2, %c4, %c5, %c5, %c4) {map = #map5} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%2, %alloca_3 : memref, memref<2x4x4x5xf64>) outs(%alloca_2 : memref<2x4x5x5xf64>) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %9 = arith.mulf %in, %in_4 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_1 : memref<2x5x5x5xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %3 = polygeist.submap(%arg0, %c2, %c5, %c5, %c5, %c4) {map = #map7} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map8, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%3, %alloca_2 : memref, memref<2x4x5x5xf64>) outs(%alloca_1 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %9 = arith.mulf %in, %in_4 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %4 = polygeist.submap(%arg2, %c2, %c5, %c5, %c5) {map = #map9} : (memref, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%4 : memref) outs(%alloca_1 : memref<2x5x5x5xf64>) { + ^bb0(%in: f64, %out: f64): + %9 = arith.mulf %out, %in : f64 + linalg.yield %9 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca_0 : memref<2x5x5x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %5 = polygeist.submap(%arg1, %c2, %c5, %c5, %c4, %c5) {map = #map10} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map11, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%5, %alloca_1 : memref, memref<2x5x5x5xf64>) outs(%alloca_0 : memref<2x5x5x4xf64>) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %9 = arith.mulf %in, %in_4 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%alloca : memref<2x5x4x4xf64>) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg1, %c2, %c5, %c4, %c4, %c5) {map = #map12} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map6, #map4], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%6, %alloca_0 : memref, memref<2x5x5x4xf64>) outs(%alloca : memref<2x5x4x4xf64>) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %9 = arith.mulf %in, %in_4 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %7 = polygeist.submap(%arg1, %c2, %c4, %c4, %c4, %c5) {map = #map13} : (memref, index, index, index, index, index) -> memref + %8 = polygeist.submap(%arg4, %c2, %c4, %c4, %c4, %c5) {map = #map14} : (memref, index, index, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map8, #map3], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction"]} ins(%7, %alloca : memref, memref<2x5x4x4xf64>) outs(%8 : memref) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %9 = arith.mulf %in, %in_4 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + return + } +} diff --git a/issues/mfem_c_kernels/results/summary.csv b/issues/mfem_c_kernels/results/summary.csv new file mode 100644 index 000000000000..b3ed0aa3e14a --- /dev/null +++ b/issues/mfem_c_kernels/results/summary.csv @@ -0,0 +1,41 @@ +id,family,dimension,operation,variant,source,function,upstream_file,upstream_symbol,frontend_ok,raise_ok,linalg_ops,residual_loops,fully_raised +interp_value_2d,sum_factorization,2,interpolate_value,original,original/sum_factorization.c,mfem_interp_value_2d,fem/dfem/interpolate.hpp,map_field_to_quadrature_data_tensor_product_2d,true,true,8,1,false +interp_grad_2d,sum_factorization,2,interpolate_gradient,original,original/sum_factorization.c,mfem_interp_grad_2d,fem/dfem/interpolate.hpp,map_field_to_quadrature_data_tensor_product_2d,true,true,4,5,false +interp_value_3d,sum_factorization,3,interpolate_value,original,original/sum_factorization.c,mfem_interp_value_3d,fem/dfem/interpolate.hpp,map_field_to_quadrature_data_tensor_product_3d,true,true,12,1,false +interp_grad_3d,sum_factorization,3,interpolate_gradient,original,original/sum_factorization.c,mfem_interp_grad_3d,fem/dfem/interpolate.hpp,map_field_to_quadrature_data_tensor_product_3d,true,true,6,10,false +integrate_value_2d,sum_factorization,2,integrate_value,original,original/sum_factorization.c,mfem_integrate_value_2d,fem/dfem/integrate.hpp,map_quadrature_data_to_fields_tensor_impl_2d,true,true,6,1,false +integrate_grad_2d,sum_factorization,2,integrate_gradient,original,original/sum_factorization.c,mfem_integrate_grad_2d,fem/dfem/integrate.hpp,map_quadrature_data_to_fields_tensor_impl_2d,true,true,4,5,false +integrate_value_3d,sum_factorization,3,integrate_value,original,original/sum_factorization.c,mfem_integrate_value_3d,fem/dfem/integrate.hpp,map_quadrature_data_to_fields_tensor_impl_3d,true,true,10,1,false +integrate_grad_3d,sum_factorization,3,integrate_gradient,original,original/sum_factorization.c,mfem_integrate_grad_3d,fem/dfem/integrate.hpp,map_quadrature_data_to_fields_tensor_impl_3d,true,true,6,10,false +mass_apply_2d,partial_assembly,2,mass_apply,original,original/mass_apply.c,mfem_pa_mass_apply_2d,fem/integ/bilininteg_mass_kernels.hpp,PAMassApply2D_Element,true,true,16,3,false +mass_apply_3d,partial_assembly,3,mass_apply,original,original/mass_apply.c,mfem_pa_mass_apply_3d,fem/integ/bilininteg_mass_kernels.hpp,PAMassApply3D_Element,true,true,24,5,false +diffusion_apply_2d,partial_assembly,2,diffusion_apply_symmetric,original,original/diffusion_apply.c,mfem_pa_diffusion_apply_2d,fem/integ/bilininteg_diffusion_kernels.hpp,PADiffusionApply2D,true,true,28,6,false +diffusion_apply_3d,partial_assembly,3,diffusion_apply_symmetric,original,original/diffusion_apply.c,mfem_pa_diffusion_apply_3d,fem/integ/bilininteg_diffusion_kernels.hpp,PADiffusionApply3D,true,true,40,9,false +convection_apply_2d,partial_assembly,2,convection_apply,original,original/convection_apply.c,mfem_pa_convection_apply_2d,fem/integ/bilininteg_convection_kernels.hpp,PAConvectionApply2D,true,true,8,7,false +convection_apply_3d,partial_assembly,3,convection_apply,original,original/convection_apply.c,mfem_pa_convection_apply_3d,fem/integ/bilininteg_convection_kernels.hpp,PAConvectionApply3D,true,true,12,16,false +elasticity_qpoint_2d,quadrature_function,2,isotropic_linear_elasticity,original,original/elasticity_qpoint.c,mfem_elasticity_qpoint_2d,fem/integ/bilininteg_elasticity_kernels.hpp,ElasticityAddMultPA_<2>,true,true,6,4,false +elasticity_qpoint_3d,quadrature_function,3,isotropic_linear_elasticity,original,original/elasticity_qpoint.c,mfem_elasticity_qpoint_3d,fem/integ/bilininteg_elasticity_kernels.hpp,ElasticityAddMultPA_<3>,true,true,6,4,false +curlcurl_apply_2d,de_rham,2,curl_curl_apply,original,original/de_rham_apply.c,mfem_pa_curlcurl_apply_2d,fem/integ/bilininteg_hcurl_kernels.cpp,PACurlCurlApply2D,true,true,11,12,false +divdiv_apply_2d,de_rham,2,div_div_apply,original,original/de_rham_apply.c,mfem_pa_divdiv_apply_2d,fem/integ/bilininteg_hdiv_kernels.cpp,PADivDivApply2D,true,true,11,12,false +divdiv_apply_3d,de_rham,3,div_div_apply,original,original/de_rham_apply.c,mfem_pa_divdiv_apply_3d,fem/integ/bilininteg_hdiv_kernels.cpp,PADivDivApply3D,true,true,15,20,false +curlcurl_apply_3d,de_rham,3,curl_curl_apply_symmetric,original,original/hcurl3_apply.c,mfem_pa_curlcurl_apply_3d,fem/integ/bilininteg_hcurl_kernels.hpp,PACurlCurlApply3D,true,true,100,22,false +interp_value_2d_scratch_sliced,sum_factorization,2,interpolate_value,normalized,normalized/value_scratch_sliced.c,mfem_interp_value_2d_scratch_sliced,fem/dfem/interpolate.hpp,map_field_to_quadrature_data_tensor_product_2d,true,true,8,0,true +interp_value_3d_scratch_sliced,sum_factorization,3,interpolate_value,normalized,normalized/value_scratch_sliced.c,mfem_interp_value_3d_scratch_sliced,fem/dfem/interpolate.hpp,map_field_to_quadrature_data_tensor_product_3d,true,true,12,0,true +integrate_value_2d_scratch_sliced,sum_factorization,2,integrate_value,normalized,normalized/value_scratch_sliced.c,mfem_integrate_value_2d_scratch_sliced,fem/dfem/integrate.hpp,map_quadrature_data_to_fields_tensor_impl_2d,true,true,6,0,true +integrate_value_3d_scratch_sliced,sum_factorization,3,integrate_value,normalized,normalized/value_scratch_sliced.c,mfem_integrate_value_3d_scratch_sliced,fem/dfem/integrate.hpp,map_quadrature_data_to_fields_tensor_impl_3d,true,true,10,0,true +mass_apply_2d_stage_sliced,partial_assembly,2,mass_apply,normalized,normalized/mass_stage_sliced.c,mfem_pa_mass_apply_2d_stage_sliced,fem/integ/bilininteg_mass_kernels.hpp,PAMassApply2D_Element,true,true,16,0,true +mass_apply_3d_stage_sliced,partial_assembly,3,mass_apply,normalized,normalized/mass_stage_sliced.c,mfem_pa_mass_apply_3d_stage_sliced,fem/integ/bilininteg_mass_kernels.hpp,PAMassApply3D_Element,true,true,24,0,true +interp_grad_2d_stage_sliced,sum_factorization,2,interpolate_gradient,normalized,normalized/gradient_stage_sliced.c,mfem_interp_grad_2d_stage_sliced,fem/dfem/interpolate.hpp,map_field_to_quadrature_data_tensor_product_2d,true,true,16,0,true +interp_grad_3d_stage_sliced,sum_factorization,3,interpolate_gradient,normalized,normalized/gradient_stage_sliced.c,mfem_interp_grad_3d_stage_sliced,fem/dfem/interpolate.hpp,map_field_to_quadrature_data_tensor_product_3d,true,true,32,0,true +integrate_grad_2d_stage_sliced,sum_factorization,2,integrate_gradient,normalized,normalized/gradient_stage_sliced.c,mfem_integrate_grad_2d_stage_sliced,fem/dfem/integrate.hpp,map_quadrature_data_to_fields_tensor_impl_2d,true,true,18,0,true +integrate_grad_3d_stage_sliced,sum_factorization,3,integrate_gradient,normalized,normalized/gradient_stage_sliced.c,mfem_integrate_grad_3d_stage_sliced,fem/dfem/integrate.hpp,map_quadrature_data_to_fields_tensor_impl_3d,true,true,38,0,true +diffusion_apply_2d_stage_sliced,partial_assembly,2,diffusion_apply_symmetric,normalized,normalized/diffusion_stage_sliced.c,mfem_pa_diffusion_apply_2d_stage_sliced,fem/integ/bilininteg_diffusion_kernels.hpp,PADiffusionApply2D,true,true,34,0,true +diffusion_apply_3d_stage_sliced,partial_assembly,3,diffusion_apply_symmetric,normalized,normalized/diffusion_stage_sliced.c,mfem_pa_diffusion_apply_3d_stage_sliced,fem/integ/bilininteg_diffusion_kernels.hpp,PADiffusionApply3D,true,true,70,0,true +convection_apply_2d_stage_sliced,partial_assembly,2,convection_apply,normalized,normalized/convection_stage_sliced.c,mfem_pa_convection_apply_2d_stage_sliced,fem/integ/bilininteg_convection_kernels.hpp,PAConvectionApply2D,true,true,26,0,true +convection_apply_3d_stage_sliced,partial_assembly,3,convection_apply,normalized,normalized/convection_stage_sliced.c,mfem_pa_convection_apply_3d_stage_sliced,fem/integ/bilininteg_convection_kernels.hpp,PAConvectionApply3D,true,true,46,0,true +elasticity_qpoint_2d_scalarized,quadrature_function,2,isotropic_linear_elasticity,normalized,normalized/elasticity_scalarized.c,mfem_elasticity_qpoint_2d_scalarized,fem/integ/bilininteg_elasticity_kernels.hpp,ElasticityAddMultPA_<2>,true,true,8,0,true +elasticity_qpoint_3d_scalarized,quadrature_function,3,isotropic_linear_elasticity,normalized,normalized/elasticity_scalarized.c,mfem_elasticity_qpoint_3d_scalarized,fem/integ/bilininteg_elasticity_kernels.hpp,ElasticityAddMultPA_<3>,true,true,18,0,true +curlcurl_apply_2d_stage_sliced,de_rham,2,curl_curl_apply,normalized,normalized/de_rham2_stage_sliced.c,mfem_pa_curlcurl_apply_2d_stage_sliced,fem/integ/bilininteg_hcurl_kernels.cpp,PACurlCurlApply2D,true,true,36,0,true +divdiv_apply_2d_stage_sliced,de_rham,2,div_div_apply,normalized,normalized/de_rham2_stage_sliced.c,mfem_pa_divdiv_apply_2d_stage_sliced,fem/integ/bilininteg_hdiv_kernels.cpp,PADivDivApply2D,true,true,36,0,true +divdiv_apply_3d_stage_sliced,de_rham,3,div_div_apply,normalized,normalized/divdiv3_stage_sliced.c,mfem_pa_divdiv_apply_3d_stage_sliced,fem/integ/bilininteg_hdiv_kernels.cpp,PADivDivApply3D,true,true,66,0,true +curlcurl_apply_3d_stage_sliced,de_rham,3,curl_curl_apply_symmetric,normalized,normalized/curlcurl3_stage_sliced.c,mfem_pa_curlcurl_apply_3d_stage_sliced,fem/integ/bilininteg_hcurl_kernels.hpp,PACurlCurlApply3D,true,true,146,0,true diff --git a/issues/mfem_c_kernels/silicon_results/2026-07-24_cutensornet_variants.log b/issues/mfem_c_kernels/silicon_results/2026-07-24_cutensornet_variants.log new file mode 100644 index 000000000000..c9a8701933ff --- /dev/null +++ b/issues/mfem_c_kernels/silicon_results/2026-07-24_cutensornet_variants.log @@ -0,0 +1,30 @@ +Date: 2026-07-24 +Target: ubuntu@enmity +Target kernel: Linux 6.8.12-1017-tegra aarch64 +Backend: cuTensorNet 2.13.0, cuTENSOR 2, CUDA 12 +Datatype: f64 + +The system-wide /lib/aarch64-linux-gnu/libcuda.so.1 was incompatible with +the running Tegra kernel. The test used a staging-directory symlink to the +board's Tegra-specific /usr/lib/aarch64-linux-gnu/nvidia/libcuda.so.1.1. +No system files were changed. + +Compiler-generated end-to-end run: + +POLYGEIST_RT_TIMING op=cutensornetContraction2_f64 m=2 n=3 k=4 host_ms=575.260447 device_ms=0.821856 +POLYGEIST_RT_TIMING op=cutensornetContraction2_f64 m=2 n=3 k=4 host_ms=2.297184 device_ms=0.087520 +POLYGEIST_RT_TIMING op=cutensornetContraction2_f64 m=2 n=3 k=4 host_ms=1.935484 device_ms=0.084512 +compiler_generated_r4r5r4 max_error=0 PASS +compiler_generated_r5r4r4 max_error=0 PASS +compiler_generated_r5r5r4_broadcast max_error=0 PASS +compiler_generated_variants failures=0 + +Five-process runtime repetition: + +RUN=1 device_ms=(0.776544,0.088384,0.088928) failures=0 +RUN=2 device_ms=(0.902208,0.118144,0.118912) failures=0 +RUN=3 device_ms=(0.886528,0.106240,0.103904) failures=0 +RUN=4 device_ms=(0.898560,0.113984,0.108832) failures=0 +RUN=5 device_ms=(0.884128,0.104352,0.104352) failures=0 + +Every run reported max_error=0 for all three variants. diff --git a/issues/mfem_c_kernels/silicon_results/2026-08-07_native_cuda_applications.md b/issues/mfem_c_kernels/silicon_results/2026-08-07_native_cuda_applications.md new file mode 100644 index 000000000000..5195b4a2a499 --- /dev/null +++ b/issues/mfem_c_kernels/silicon_results/2026-08-07_native_cuda_applications.md @@ -0,0 +1,92 @@ +# Native MFEM CUDA application validation (Jetson Orin) + +Date: 2026-08-07 + +## Scope + +This validates that the upstream MFEM applications containing the operator +families covered by our extracted/raised application kernels can execute their +native GPU paths. It is an application-level CUDA execution check, not yet a +timed raised-vs-native comparison. + +MFEM revision: `951cf8886b9c0c33fb36a2f0ede268c8d6a0d8b5` + +Hardware/configuration: + +- NVIDIA Jetson Orin, MAXN mode +- CUDA 12.6, target `sm_87` +- MFEM `Release`, double precision, `MFEM_USE_CUDA=YES`, `MFEM_USE_MPI=YES` +- One MPI rank; GPU-aware MPI disabled + +## Results + +All genuine CUDA-capable covered applications executed successfully. + +1. `mtop_test_iso_elasticity` -- PASS + - Covered path: DFEM interpolation -> elasticity quadrature function -> integration + - Parameters: `-d cuda -quad -dfem -prl 0 -no-vis -no-pv` + - Size: 576 elements, 5,040 unknowns + - Linear solve converged in 56 iterations. + +2. `dfem-minimal-surface` -- PASS + - Covered path: DFEM interpolation -> nonlinear quadrature function -> integration + - Parameters: `-d cuda -o 3 -r 1 -der 1 -no-vis` + - Newton solve reached relative residual `8.18e-11`. + +3. `ex35p`, H1 -- PASS after using a non-degenerate mesh size + - Covered path: PA diffusion and mass + - Parameters: `-d cuda -pa -hex -p 0 -o 2 -rs 1 -rp 1 -no-vis` + - Size: linear system 8,802; LOBPCG converged in 18 iterations. + - The earlier `-rs 0 -rp 0` smoke case was too small for the requested + five-mode eigensolve and reported MFEM's `GEVP solver failure`. + +4. `ex35p`, H(curl) -- PASS + - Covered path: PA curl-curl and vector mass + - Parameters: `-d cuda -pa -hex -p 1 -o 2 -rs 0 -rp 0 -no-vis` + - LOBPCG converged in 2 iterations. + +5. `ex35p`, H(div) -- PASS + - Covered path: PA div-div and vector mass + - Parameters: `-d cuda -pa -hex -p 2 -o 2 -rs 0 -rp 0 -no-vis` + - LOBPCG completed in 26 iterations. + +6. `ex9p` -- PASS + - Covered path: PA mass and DG convection during time stepping + - Parameters: `-d cuda -pa -rs 0 -rp 0 -o 3 -tf 0.02 -dt 0.01 -no-vis -no-visit -no-paraview` + - Completed two time steps. + +7. `grad_div` -- PASS + - Covered path: PA div-div + - Parameters: `-d cuda -lor -rs 0 -rp 0 -o 2` + - LOR-AMS converged in 20 iterations; reported L2 error `1.1688e-01`. + +8. `abs-l1-jacobi`, mass -- PASS + - Covered path: PA mass + - Parameters: `-d cuda -a 3 -i 0 -o 3 -rs 1 -rp 0 -ni 30 -no-vis` + - Converged in 10 iterations; L2 error `8.73866e-04`. + +9. `abs-l1-jacobi`, diffusion -- PASS + - Covered path: PA diffusion + - Parameters: `-d cuda -a 3 -i 1 -o 3 -rs 1 -rp 0 -ni 30 -no-vis` + - Converged in 10 iterations; L2 error `1.15796e-03`. + +10. `abs-l1-jacobi`, curl-curl -- PASS + - Covered path: PA curl-curl and vector mass + - Parameters: `-d cuda -a 3 -i 2 -o 3 -rs 1 -rp 0 -ni 300 -no-vis` + - Converged in 95 iterations; L2 error `2.40579e-03`. + +## Candidate that is not a native CUDA application + +`navier_tgv` was built but excluded from the CUDA run set. At this MFEM +revision it uses PA operators but does not construct an MFEM `Device` or expose +a `-d/--device` option, so the application executes on CPU as written. Adding +a device option would be an upstream-source modification, not validation of an +existing CUDA application variant. + +## Important interpretation + +`Device configuration: cuda,cpu` was printed by every passing CUDA run. These +results prove that the native MFEM application and its covered operator path can +execute with MFEM's CUDA backend. They do not prove numerical equivalence to +our extracted raised program; that requires a paired harness with identical +inputs, outputs, problem size, and an in-process warm timing loop. diff --git a/issues/mfem_c_kernels/silicon_results/RAISED_VS_MFEM_NATIVE_ANALYSIS.md b/issues/mfem_c_kernels/silicon_results/RAISED_VS_MFEM_NATIVE_ANALYSIS.md new file mode 100644 index 000000000000..46cff9f98e70 --- /dev/null +++ b/issues/mfem_c_kernels/silicon_results/RAISED_VS_MFEM_NATIVE_ANALYSIS.md @@ -0,0 +1,334 @@ +# Raised Polygeist vs. native MFEM CUDA: runtime analysis + +## Benchmark configuration + +- Hardware: NVIDIA Jetson Orin (`sm_87`) +- Power mode: MAXN +- CUDA: 12.6 +- Data type: `f64` +- Elements: `NE=1024` +- Basis dimensions: `D1D=4`, `Q1D=5` +- Timing: 20 warm iterations per process; reported raised value is the median + of process runs 2--4, excluding the first cold CUDA process +- Correctness: all 18 matcher-covered normalized kernels passed checksum and + maximum-output comparison within floating-point roundoff: ten PA operators + and eight DFEM interpolation/integration maps + +The full measurements are stored in +[`native_vs_raised_large_ne.csv`](native_vs_raised_large_ne.csv). + +## Meaning of the measurements + +`raised_runtime_us` measures the extracted C kernel after the Polygeist +raising, matching, ABI generation, and CUDA-library lowering pipeline. The +runtime now caches prepared cuTensorNet networks, optimizer state, workspace +descriptors, and scratch allocations by contraction signature. The value still +includes the current compatibility host-pointer ABI, synchronization at host +boundaries, correctness-first tensor snapshots, and unmatched operations that +lower to host loops. + +`raised_runtime_us_before_plan_cache` preserves the earlier measurement, and +`plan_cache_speedup` reports the improvement from the new runtime/compiler +path. The gain is between `1.30x` and `3.23x` across the ten operators. + +`mfem_native_runtime_us` measures MFEM's existing specialized CUDA +implementation with its input and output tensors resident on the GPU. For the +eight DFEM rows, the benchmark wrapper dispatches MFEM's own inline +tensor-product device routine with one CUDA thread block per element. Each +iteration is synchronized before timing is recorded. + +The eight newly covered DFEM maps range from `21.341x` to `200.504x` slower +than native MFEM CUDA. Their individual numbers and the original ten PA +comparisons are stored together in the CSV above. + +`raised_over_native` is: + +```text +raised_runtime_us / mfem_native_runtime_us +``` + +Therefore, a value of `58.3` means that the current raised execution is 58.3 +times slower than the native MFEM CUDA implementation. A value below one +would mean that the raised implementation is faster. + +## Representative result: PA Mass 2D + +For `mfem_pa_mass_apply_2d_stage_sliced`: + +```text +Raised before: 7.67 ms +Raised with cache: 2.38 ms +MFEM native CUDA: 40.8 us +Cache improvement: 3.23x +Raised/native: 58.3x +``` + +Both implementations produced the same checksum and maximum absolute output +value within floating-point roundoff. + +## What the raised implementation deploys + +The original Mass 2D computation has five stages: + +1. Interpolate in the x direction. +2. Interpolate in the y direction. +3. Multiply by the quadrature coefficient `D`. +4. Integrate in the x direction. +5. Integrate in the y direction and accumulate into `Y`. + +The current matcher converts three of those stages into independent +`@cutensornetContraction2_f64` launches. The pointwise multiplication and +final reduction remain `linalg.generic` operations and are ultimately +compiled as AArch64 host loops. + +A simplified view of the deployed execution remains: + +```text +cuTensorNet contraction 1: interpolate X in x +synchronize + +cuTensorNet contraction 2: interpolate in y +synchronize + +host loop: multiply the quadrature tensor by D + +cuTensorNet contraction 3: integrate in x +synchronize + +host loop: final integration and accumulation into Y +``` + +The stored matcher result is +[`match_results/mass_apply_2d_stage_sliced/matched.mlir`](../match_results/mass_apply_2d_stage_sliced/matched.mlir). + +### Work performed by cuTensorNet contractions + +The first call for a new contraction signature performs the expensive setup: + +```c +reuse_or_create_global_cutensornet_handle(); +cutensornetCreateNetwork(handle, &network); +cutensornetNetworkAppendTensor(...); +cutensornetNetworkAppendTensor(...); +cutensornetNetworkSetOutputTensor(...); + +cutensornetCreateContractionOptimizerConfig(...); +cutensornetCreateContractionOptimizerInfo(...); +cutensornetContractionOptimize(...); + +cutensornetCreateWorkspaceDescriptor(...); +cutensornetWorkspaceComputeContractionSizes(...); +cudaMalloc(scratch); +cutensornetNetworkPrepareContraction(...); + +cache[signature] = {network, optimizer, workspace, scratch}; +``` + +Every later call with the same device, ranks, extents, strides, and modes does +only: + +```c +entry = cache_lookup(signature); +register_or_find_mapped_host_buffers(A, B, C); +cutensornetNetworkSetInputTensorMemory(...); // rebind A and B +cutensornetNetworkSetOutputTensorMemory(...); // rebind C +cutensornetNetworkContract(...); +sync_only_at_the_end_of_the_safe_GPU_region(); +``` + +The cache has 64 LRU entries and is enabled by default. It can be disabled +with `POLYGEIST_CUTENSORNET_PLAN_CACHE=0`; cache statistics are printed when +`POLYGEIST_RT_CACHE_STATS=1`. + +The implementation is in +[`runtime/polygeist_cublas_rt_cuda.c`](../../../runtime/polygeist_cublas_rt_cuda.c), +in `polygeist_cutensornet_contraction2_f64`. + +### Historical setup time versus GPU time + +Runtime instrumentation for a warmed Mass 2D iteration reported representative +values of: + +```text +Contraction 1: host 2.07 ms, GPU 0.030 ms +Contraction 2: host 2.13 ms, GPU 0.032 ms +Contraction 3: host 2.16 ms, GPU 0.036 ms +``` + +The three contractions perform approximately `0.10 ms` of actual GPU work, +but spend approximately `6.3 ms` in their host-side call paths. The rest of +the approximately `7.5-7.7 ms` execution time comes from synchronization, +intermediate tensor handling, and the two residual host stages. + +Thus, cuTensorNet's mathematical contraction was not intrinsically taking +multiple milliseconds. The new cache removes repeated reconstruction, +optimization, preparation, and destruction. For example, a Mass 2D process +reports `3` misses followed by `63` hits. The remaining `2.38 ms` is dominated +by host/device boundaries, output snapshots, synchronization, separate +launches, and residual host stages. + +### Host-memory behavior + +The current Jetson runtime normally uses `cudaHostRegister` and +`cudaHostGetDevicePointer` to expose host buffers as mapped memory. It caches +registrations for reuse. Consequently, repeated bulk `cudaMemcpy` transfers +are not the main cause of this result. + +The remaining memory-related costs are mapped-host access, registration on +first use or cache replacement, temporary allocation, and the CPU/GPU +boundaries caused by residual host stages. + +## What native MFEM deploys + +For Mass 2D, MFEM invokes one specialized launcher resembling: + +```c++ +mfem::forall_2D_batch(NE, Q1D, Q1D, NBZ, + [=] MFEM_HOST_DEVICE (int e) { + internal::SmemPAMassApply2D_Element<4, 5, NBZ>( + e, NE, B, D, X, Y); + }); +``` + +Inside that one device kernel, MFEM performs all five stages: + +```c++ +MFEM_SHARED real_t B_and_Bt[...]; +MFEM_SHARED real_t scratch0[...]; +MFEM_SHARED real_t scratch1[...]; + +load B and X into shared memory; + +DQ = B * X; // interpolation in x +QQ = B * DQ; // interpolation in y +QQ *= coefficient_D; // quadrature pointwise stage +QD = transpose(B) * QQ; // integration in x +Y += transpose(B) * QD; // integration in y +``` + +The relevant MFEM implementation is in: + +- [`SmemPAMassApply2D`](../../../third_party/mfem/fem/integ/bilininteg_mass_kernels.hpp) +- `SmemPAMassApply2D_Element` in the same file + +MFEM therefore benefits from: + +- One CUDA kernel launch instead of three library calls and two host stages. +- No runtime contraction-network optimizer. +- No per-stage plan creation or destruction. +- GPU-resident input and output tensors. +- Intermediate values retained in registers and shared memory. +- Compile-time specialization for `D1D=4` and `Q1D=5`. +- Loop unrolling and a launch configuration tailored to the finite-element + operator. +- No global-memory materialization between the five mathematical stages. + +## Execution structure comparison + +```text +Raised Polygeist (current cached compatibility ABI) +--------------------------------------------------- +cached plan lookup + pointer rebind + -> GPU contraction + -> synchronize + -> host-visible output snapshot +cached plan lookup + pointer rebind + -> GPU contraction + -> synchronize + -> host-visible output snapshot +host pointwise loop +cached plan lookup + pointer rebind + -> GPU contraction + -> synchronize + -> host-visible output snapshot +host reduction/accumulation loop + +MFEM native CUDA +---------------- +one specialized CUDA launch + -> interpolation + -> coefficient application + -> integration + -> output accumulation +``` + +## Main causes of the slowdown + +In descending order of importance for the current measurements: + +1. **Loss of fusion.** One finite-element operator becomes multiple library + launches plus residual host loops. +2. **CPU/GPU boundaries.** Unmatched pointwise and reduction stages execute on + the host between GPU contractions. +3. **Correctness-first host snapshots and synchronization.** The current + opaque pointer call does not model its tensor write for bufferization, so + each output is copied to a fresh host-visible tensor. These host operations + correctly terminate an asynchronous GPU region. +4. **Materialized intermediate tensors.** Values that MFEM keeps in shared + memory become standalone tensors visible across calls. +5. **A general-purpose library is being used for very small fixed + contractions.** MFEM's specialized `4x5` tensor-product kernel has much + less machinery and exposes more compile-time optimization opportunities. + +Repeated per-signature cuTensorNet planning was previously the largest fixed +overhead. It is now removed on cache hits, but the structural costs above +remain. + +Both implementations use `f64`, so the Jetson's relatively limited FP64 +throughput is not the primary explanation for the ratio. The large difference +comes from execution structure and runtime overhead. + +## Improvements needed + +### Implemented: cache and reuse library state + +- One cuTensorNet handle is reused. +- Network descriptors and optimized plans are cached by contraction signature. +- Prepared workspaces and scratch allocations remain live in the cache. +- Input/output pointers are rebound on each cache hit. +- Cache entries are destroyed at explicit runtime teardown or process exit. + +This produced `1.30x`--`3.23x` end-to-end speedups, but does not eliminate +multiple launches or global intermediates. + +### Implemented foundation: safe pipeline scopes and device-pointer ABI + +- `WrapKernelLaunchPipeline` now forms maximal block-local GPU-only regions. + It defers synchronization across library calls and metadata/view operations, + but ends the region before any host tensor computation. +- `polygeist_cutensornet_contraction2_f64_device` accepts CUDA device pointers + directly and skips host registration/mapping. +- `--lower-kernel-launch-to-cublas=device-resident-cutensornet=true`, exposed + by `POLYGEIST_DEVICE_RESIDENT_ABI=1` in the build script, selects this ABI. +- The compiler rejects this mode if residual `linalg`, loops, host memref + accesses/copies, tensor element accesses, or non-device-produced operands + remain. It therefore fails closed instead of treating a host pointer as a + device pointer. + +The device runtime ABI passed a Jetson smoke test: a device-resident `2x3` by +`3x2` contraction produced `[58, 64, 139, 154]` exactly, with one cache miss +and one hit. Current MFEM stage pipelines intentionally fail the legality gate +because their residual pointwise/reduction stages and snapshot copies still +execute on the host. Making the whole raised graph device-resident requires +lowering those residual stages to GPU library operations and replacing opaque +call snapshots with a bufferizable library-call representation. + +### Performance target: fuse the recognized stage graph + +The long-term transformation should be: + +```text +recognized interpolation + -> recognized quadrature operation + -> recognized integration + -> one fused GPU implementation +``` + +The raising and matching work already recovers the stage semantics. The +remaining compiler work is to preserve the complete dependency graph, select +fusion boundaries, and lower the graph to one optimized implementation rather +than independently lowering each `linalg.generic` operation. + +Plan caching has made the present approach substantially less slow. Matching +native MFEM performance, however, still requires fusion and GPU-resident +intermediates. diff --git a/issues/mfem_c_kernels/silicon_results/application_native_vs_raised_large_ne.csv b/issues/mfem_c_kernels/silicon_results/application_native_vs_raised_large_ne.csv new file mode 100644 index 000000000000..2f1749e6760f --- /dev/null +++ b/issues/mfem_c_kernels/silicon_results/application_native_vs_raised_large_ne.csv @@ -0,0 +1,12 @@ +function,ne,d1d,q1d,raised_iterations,native_iterations,correctness,raised_runtime_us,mfem_native_runtime_us,raised_over_native,native_components,comparison_quality,comparison_scope,hardware,measurement_statistic +mfem_app_mtop_iso_elasticity_dfem_2d,1024,4,5,5,,PASS,22691.769619,,,interpolation+elasticity_qpoint+integration,UNAVAILABLE,no equivalent public MFEM CUDA PA microkernel entry point,Jetson_Orin_sm87_MAXN_CUDA12.6,median_of_process_runs_2_to_4 +mfem_app_dfem_minimal_surface_2d,1024,4,5,5,,FAIL,,,,interpolation+minimal_surface_qpoint+integration,CORRECTNESS_FAIL,raised timing withheld because max_abs=max_rel=0.20337545654012545,Jetson_Orin_sm87_MAXN_CUDA12.6,repeated_process_runs_1_to_4 +mfem_app_ex35p_h1_3d,1024,4,5,5,20,PASS,63628.940796,440.792000,144.351,diffusion_apply_3d+mass_apply_3d,COMPONENT_SUM,sum of separately measured resident MFEM CUDA PA kernel medians,Jetson_Orin_sm87_MAXN_CUDA12.6,median_of_process_runs_2_to_4 +mfem_app_ex35p_hcurl_3d,1024,4,5,5,20,PASS,300323.993620,25960.494400,11.569,curlcurl_apply_3d+hcurl_mass_apply_3d,COMPONENT_SUM,sum of separately measured resident MFEM CUDA PA kernel medians,Jetson_Orin_sm87_MAXN_CUDA12.6,median_of_process_runs_2_to_4 +mfem_app_ex35p_hdiv_3d,1024,4,5,5,20,PASS,190912.665566,1375.137600,138.832,divdiv_apply_3d+hdiv_mass_apply_3d,COMPONENT_SUM,sum of separately measured resident MFEM CUDA PA kernel medians,Jetson_Orin_sm87_MAXN_CUDA12.6,median_of_process_runs_2_to_4 +mfem_app_ex9p_mass_convection_2d,1024,4,5,5,20,PASS,10927.411215,86.486400,126.348,mass_apply_2d+convection_apply_2d,PARTIAL_COMPONENT_SUM,native baseline covers PA operators only while raised timing also includes one PCG algebra iteration,Jetson_Orin_sm87_MAXN_CUDA12.6,median_of_process_runs_2_to_4 +mfem_app_grad_div_3d,1024,4,5,5,20,PASS,191170.483176,1375.137600,139.019,divdiv_apply_3d+hdiv_mass_apply_3d,COMPONENT_SUM,sum of separately measured resident MFEM CUDA PA kernel medians,Jetson_Orin_sm87_MAXN_CUDA12.6,median_of_process_runs_2_to_4 +mfem_app_abs_l1_mass_3d,1024,4,5,5,20,PASS,14519.686392,136.692800,106.221,mass_apply_3d,EXACT_OPERATOR,same PA operator family and tensor extents; native value is the resident MFEM CUDA kernel median,Jetson_Orin_sm87_MAXN_CUDA12.6,median_of_process_runs_2_to_4 +mfem_app_abs_l1_diffusion_3d,1024,4,5,5,20,PASS,51795.756817,304.099200,170.325,diffusion_apply_3d,EXACT_OPERATOR,same PA operator family and tensor extents; native value is the resident MFEM CUDA kernel median,Jetson_Orin_sm87_MAXN_CUDA12.6,median_of_process_runs_2_to_4 +mfem_app_abs_l1_curlcurl_3d,1024,4,5,5,20,PASS,300721.100811,25960.494400,11.584,curlcurl_apply_3d+hcurl_mass_apply_3d,COMPONENT_SUM,sum of separately measured resident MFEM CUDA PA kernel medians,Jetson_Orin_sm87_MAXN_CUDA12.6,median_of_process_runs_2_to_4 +mfem_app_navier_tgv_pa_operators_3d,1024,4,5,5,,PASS,919070.540834,,,vector_mass+vector_diffusion+nonlinear_convection+pressure_diffusion+divergence+gradient,UNAVAILABLE,upstream navier_tgv has no MFEM Device or CUDA command-line path at this revision,Jetson_Orin_sm87_MAXN_CUDA12.6,median_of_process_runs_2_to_4 diff --git a/issues/mfem_c_kernels/silicon_results/native_additional_operator_baselines_large_ne.csv b/issues/mfem_c_kernels/silicon_results/native_additional_operator_baselines_large_ne.csv new file mode 100644 index 000000000000..8a020cb3e8a9 --- /dev/null +++ b/issues/mfem_c_kernels/silicon_results/native_additional_operator_baselines_large_ne.csv @@ -0,0 +1,3 @@ +kernel,ne,d1d,q1d,iterations,runtime_us,hardware,measurement_statistic +hcurl_mass_apply_3d,1024,4,5,20,9002.161600,Jetson_Orin_sm87_MAXN_CUDA12.6,median_of_process_runs_2_to_4 +hdiv_mass_apply_3d,1024,4,5,20,396.065600,Jetson_Orin_sm87_MAXN_CUDA12.6,median_of_process_runs_2_to_4 diff --git a/issues/mfem_c_kernels/silicon_results/native_vs_raised_large_ne.csv b/issues/mfem_c_kernels/silicon_results/native_vs_raised_large_ne.csv new file mode 100644 index 000000000000..a8cb2975dc9a --- /dev/null +++ b/issues/mfem_c_kernels/silicon_results/native_vs_raised_large_ne.csv @@ -0,0 +1,19 @@ +id,function,ne,d1d,q1d,iterations,correctness,raised_runtime_us,mfem_native_runtime_us,raised_over_native,raised_checksum,mfem_native_checksum,timing_scope,hardware,raised_runtime_us_before_plan_cache,plan_cache_speedup,measurement_statistic +mass_apply_2d_stage_sliced,mfem_pa_mass_apply_2d_stage_sliced,1024,4,5,20,PASS,2379.638399,40.824000,58.290,-0.019158815000406532,-0.019158815000406504,cached_host_abi_vs_resident_native_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,7673.332805,3.225,median_of_process_runs_2_to_4 +mass_apply_3d_stage_sliced,mfem_pa_mass_apply_3d_stage_sliced,1024,4,5,20,PASS,11055.884801,136.692800,80.881,-0.0012516174568922064,-0.0012516174568921769,cached_host_abi_vs_resident_native_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,17126.136005,1.549,median_of_process_runs_2_to_4 +diffusion_apply_2d_stage_sliced,mfem_pa_diffusion_apply_2d_stage_sliced,1024,4,5,20,PASS,6943.662395,55.736000,124.581,0.016461057368181917,0.016461057368181962,cached_host_abi_vs_resident_native_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,14322.166401,2.063,median_of_process_runs_2_to_4 +diffusion_apply_3d_stage_sliced,mfem_pa_diffusion_apply_3d_stage_sliced,1024,4,5,20,PASS,45682.379208,304.099200,150.222,-0.0003863925191181366,-0.00038639251911810901,cached_host_abi_vs_resident_native_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,64619.326394,1.415,median_of_process_runs_2_to_4 +convection_apply_2d_stage_sliced,mfem_pa_convection_apply_2d_stage_sliced,1024,4,5,20,PASS,4395.380802,45.662400,96.258,0.02958561406125481,0.029585614061254803,cached_host_abi_vs_resident_native_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,11440.915207,2.603,median_of_process_runs_2_to_4 +convection_apply_3d_stage_sliced,mfem_pa_convection_apply_3d_stage_sliced,1024,4,5,20,PASS,27177.638409,184.304000,147.461,0.0016542800400618459,0.0016542800400617536,cached_host_abi_vs_resident_native_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,38552.363205,1.419,median_of_process_runs_2_to_4 +curlcurl_apply_2d_stage_sliced,mfem_pa_curlcurl_apply_2d_stage_sliced,1024,4,5,20,PASS,5008.371209,142.134400,35.237,-1.3713463416047122e-18,2.6342724659608741e-19,cached_host_abi_vs_resident_native_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,12027.055991,2.401,median_of_process_runs_2_to_4 +curlcurl_apply_3d_stage_sliced,mfem_pa_curlcurl_apply_3d_stage_sliced,1024,4,5,20,PASS,94683.788798,16958.332800,5.583,2.1457263612972551e-18,3.8364239763515398e-18,cached_host_abi_vs_resident_native_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,123443.895997,1.304,median_of_process_runs_2_to_4 +divdiv_apply_2d_stage_sliced,mfem_pa_divdiv_apply_2d_stage_sliced,1024,4,5,20,PASS,5469.668796,141.667200,38.609,0.031956259236681085,0.031956259236681113,cached_host_abi_vs_resident_native_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,13522.481604,2.472,median_of_process_runs_2_to_4 +divdiv_apply_3d_stage_sliced,mfem_pa_divdiv_apply_3d_stage_sliced,1024,4,5,20,PASS,33034.998400,979.072000,33.741,0.00023148998240787787,0.00023148998240787706,cached_host_abi_vs_resident_native_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,46395.318408,1.404,median_of_process_runs_2_to_4 +interp_value_2d_scratch_sliced,mfem_interp_value_2d_scratch_sliced,1024,4,5,20,PASS,674.902403,31.624000,21.341,0.27139825974030091,0.27139825974030091,cached_host_abi_vs_resident_native_dfem_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,,,median_of_process_runs_2_to_4 +interp_value_3d_scratch_sliced,mfem_interp_value_3d_scratch_sliced,1024,4,5,20,PASS,5984.705605,62.710400,95.434,0.15927400328969707,0.15927400328969707,cached_host_abi_vs_resident_native_dfem_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,,,median_of_process_runs_2_to_4 +integrate_value_2d_scratch_sliced,mfem_integrate_value_2d_scratch_sliced,1024,4,5,20,PASS,927.177607,34.769600,26.666,0.068714460488089518,0.068714460488090462,cached_host_abi_vs_resident_native_dfem_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,,,median_of_process_runs_2_to_4 +integrate_value_3d_scratch_sliced,mfem_integrate_value_3d_scratch_sliced,1024,4,5,20,PASS,5101.929605,75.390400,67.673,-0.12165400592248544,-0.12165400592248397,cached_host_abi_vs_resident_native_dfem_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,,,median_of_process_runs_2_to_4 +interp_grad_2d_stage_sliced,mfem_interp_grad_2d_stage_sliced,1024,4,5,20,PASS,1885.049592,37.504000,50.263,0.38598863607511064,0.38598863607511519,cached_host_abi_vs_resident_native_dfem_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,,,median_of_process_runs_2_to_4 +interp_grad_3d_stage_sliced,mfem_interp_grad_3d_stage_sliced,1024,4,5,20,PASS,25410.763198,126.734400,200.504,0.33978454035133859,0.3397845403513437,cached_host_abi_vs_resident_native_dfem_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,,,median_of_process_runs_2_to_4 +integrate_grad_2d_stage_sliced,mfem_integrate_grad_2d_stage_sliced,1024,4,5,20,PASS,2673.907205,43.307200,61.743,-0.065151488462781029,-0.065151488462779183,cached_host_abi_vs_resident_native_dfem_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,,,median_of_process_runs_2_to_4 +integrate_grad_3d_stage_sliced,mfem_integrate_grad_3d_stage_sliced,1024,4,5,20,PASS,15839.600004,171.872000,92.159,0.038976814595959426,0.038976814595929117,cached_host_abi_vs_resident_native_dfem_launch,Jetson_Orin_sm87_MAXN_CUDA12.6,,,median_of_process_runs_2_to_4 diff --git a/issues/no_canonicalize.mlir b/issues/no_canonicalize.mlir new file mode 100644 index 000000000000..2e2c17bb4295 --- /dev/null +++ b/issues/no_canonicalize.mlir @@ -0,0 +1,29 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.000000e-01 : f64 + %c0_i32 = arith.constant 0 : i32 + %alloca = memref.alloca() : memref<1300x1300xf32> + %alloca_0 = memref.alloca() : memref<1300x1300xf32> + affine.for %arg0 = 0 to 500 { + affine.for %arg1 = 1 to 1299 { + affine.for %arg2 = 1 to 1299 { + %0 = affine.load %alloca_0[%arg1, %arg2] : memref<1300x1300xf32> + %1 = affine.load %alloca_0[%arg1, %arg2 - 1] : memref<1300x1300xf32> + %2 = arith.addf %0, %1 : f32 + %3 = affine.load %alloca_0[%arg1, %arg2 + 1] : memref<1300x1300xf32> + %4 = arith.addf %2, %3 : f32 + %5 = affine.load %alloca_0[%arg1 + 1, %arg2] : memref<1300x1300xf32> + %6 = arith.addf %4, %5 : f32 + %7 = affine.load %alloca_0[%arg1 - 1, %arg2] : memref<1300x1300xf32> + %8 = arith.addf %6, %7 : f32 + %9 = arith.extf %8 : f32 to f64 + %10 = arith.mulf %9, %cst : f64 + %11 = arith.truncf %10 : f64 to f32 + affine.store %11, %alloca[%arg1, %arg2] : memref<1300x1300xf32> + } + } + } + return %c0_i32 : i32 + } +} diff --git a/issues/nullptr_type_min.cpp b/issues/nullptr_type_min.cpp new file mode 100644 index 000000000000..6ca3ad33999b --- /dev/null +++ b/issues/nullptr_type_min.cpp @@ -0,0 +1,5 @@ +void nullptr_type_min_sink(decltype(nullptr)); + +void nullptr_type_min() { + nullptr_type_min_sink(nullptr); +} diff --git a/issues/preferred_alignof_min.cpp b/issues/preferred_alignof_min.cpp new file mode 100644 index 000000000000..b4f91ef89f9b --- /dev/null +++ b/issues/preferred_alignof_min.cpp @@ -0,0 +1,2 @@ +unsigned long preferred_alignof_char() { return __alignof__(char); } + diff --git a/issues/proxy_app_raise_probes/include/bml.h b/issues/proxy_app_raise_probes/include/bml.h new file mode 100644 index 000000000000..ba6b8a26e29f --- /dev/null +++ b/issues/proxy_app_raise_probes/include/bml.h @@ -0,0 +1,24 @@ +#ifndef PROXY_APP_RAISE_PROBE_BML_H +#define PROXY_APP_RAISE_PROBE_BML_H + +typedef double real_t; +typedef struct bml_matrix_t bml_matrix_t; + +real_t *bml_gershgorin(bml_matrix_t *matrix); +void bml_scale_add_identity(bml_matrix_t *matrix, real_t alpha, real_t beta, + real_t threshold); +void bml_free_memory(void *ptr); +void bml_copy(const bml_matrix_t *from, bml_matrix_t *to); +bml_matrix_t *bml_copy_new(const bml_matrix_t *matrix); +real_t bml_trace(const bml_matrix_t *matrix); +real_t *bml_multiply_x2(const bml_matrix_t *matrix, bml_matrix_t *x2, + real_t threshold); +void bml_add(bml_matrix_t *x, bml_matrix_t *y, real_t alpha, real_t beta, + real_t threshold); +int bml_printRank(void); +int bml_getNRanks(void); +int bml_get_bandwidth(const bml_matrix_t *matrix); +void bml_scale_inplace(const real_t *scale, bml_matrix_t *matrix); +void bml_deallocate(bml_matrix_t **matrix); + +#endif diff --git a/issues/proxy_app_raise_probes/include/mpi.h b/issues/proxy_app_raise_probes/include/mpi.h new file mode 100644 index 000000000000..967ce651548c --- /dev/null +++ b/issues/proxy_app_raise_probes/include/mpi.h @@ -0,0 +1,43 @@ +#ifndef PROXY_APP_RAISE_PROBE_MPI_H +#define PROXY_APP_RAISE_PROBE_MPI_H + +typedef int MPI_Comm; +typedef int MPI_Datatype; +typedef int MPI_Request; +typedef int MPI_Status; + +#define MPI_COMM_WORLD 0 +#define MPI_ORDER_C 0 +#define MPI_DOUBLE_COMPLEX 0 +#define MPI_REQUEST_NULL 0 +#define MPI_STATUS_IGNORE ((MPI_Status *)0) + +int MPI_Cart_sub(MPI_Comm comm, const int remaining_dims[], MPI_Comm *newcomm); +int MPI_Dims_create(int nnodes, int ndims, int dims[]); +int MPI_Cart_create(MPI_Comm comm_old, int ndims, const int dims[], + const int periods[], int reorder, MPI_Comm *comm_cart); +int MPI_Cart_get(MPI_Comm comm, int maxdims, int dims[], int periods[], + int coords[]); +int MPI_Comm_rank(MPI_Comm comm, int *rank); +int MPI_Comm_size(MPI_Comm comm, int *size); +int MPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int coords[]); +int MPI_Cart_rank(MPI_Comm comm, int coords[], int *rank); +int MPI_Barrier(MPI_Comm comm); +int MPI_Type_create_subarray(int ndims, const int sizes[], const int subsizes[], + const int starts[], int order, MPI_Datatype oldtype, + MPI_Datatype *newtype); +int MPI_Type_contiguous(int count, MPI_Datatype oldtype, MPI_Datatype *newtype); +int MPI_Type_commit(MPI_Datatype *datatype); +int MPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype, + int dest, int sendtag, void *recvbuf, int recvcount, + MPI_Datatype recvtype, int source, int recvtag, + MPI_Comm comm, MPI_Status *status); +int MPI_Type_free(MPI_Datatype *datatype); +int MPI_Comm_free(MPI_Comm *comm); +int MPI_Isend(const void *buf, int count, MPI_Datatype datatype, + int dest, int tag, MPI_Comm comm, MPI_Request *request); +int MPI_Irecv(void *buf, int count, MPI_Datatype datatype, + int source, int tag, MPI_Comm comm, MPI_Request *request); +int MPI_Wait(MPI_Request *request, MPI_Status *status); + +#endif diff --git a/issues/proxy_app_raise_probes/include/swfft_probe_disable_debug.h b/issues/proxy_app_raise_probes/include/swfft_probe_disable_debug.h new file mode 100644 index 000000000000..6620fceeea28 --- /dev/null +++ b/issues/proxy_app_raise_probes/include/swfft_probe_disable_debug.h @@ -0,0 +1,10 @@ +#ifndef POLYGEIST_SWFFT_PROBE_DISABLE_DEBUG_H +#define POLYGEIST_SWFFT_PROBE_DISABLE_DEBUG_H + +#include +#include + +#define fprintf(...) (0) +#define abort(...) ((void)0) + +#endif diff --git a/issues/proxy_app_raise_probes/run_proxy_app_raise_probes.sh b/issues/proxy_app_raise_probes/run_proxy_app_raise_probes.sh new file mode 100644 index 000000000000..570c865634ef --- /dev/null +++ b/issues/proxy_app_raise_probes/run_proxy_app_raise_probes.sh @@ -0,0 +1,172 @@ +#!/bin/bash +# First-pass cgeist/linalg probes for selected C ECP proxy apps. +set +e + +REPO_ROOT=${REPO_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)} +OUT=${POLYGEIST_PROXY_APP_OUT:-/tmp/proxy_app_raise_mlir} +CGEIST_BIN=${CGEIST_BIN:-$REPO_ROOT/build/bin/cgeist} +POLYGEIST_OPT_BIN=${POLYGEIST_OPT_BIN:-$REPO_ROOT/build/bin/polygeist-opt} +PROBE_INCLUDE=$REPO_ROOT/issues/proxy_app_raise_probes/include + +if [ -n "${POLYGEIST_CLANG_RESOURCE_DIR:-}" ]; then + RESOURCE_DIR=$POLYGEIST_CLANG_RESOURCE_DIR +elif [ -d "$REPO_ROOT/llvm-project/build/lib/clang/18" ]; then + RESOURCE_DIR=$REPO_ROOT/llvm-project/build/lib/clang/18 +else + RESOURCE_DIR=/usr/lib/clang/14 +fi + +mkdir -p "$OUT" +rm -f "$OUT"/* + +count_pattern() { + local pattern=$1 + local file=$2 + if [ ! -s "$file" ]; then + echo 0 + return + fi + grep -Ec "$pattern" "$file" 2>/dev/null +} + +pick_artifact() { + local tag=$1 + if [ -s "$OUT/${tag}_debuf_mr.mlir" ] && + grep -q "linalg.generic" "$OUT/${tag}_debuf_mr.mlir"; then + echo "$OUT/${tag}_debuf_mr.mlir" + elif [ -s "$OUT/${tag}_debuf.mlir" ] && + grep -q "linalg.generic" "$OUT/${tag}_debuf.mlir"; then + echo "$OUT/${tag}_debuf.mlir" + elif [ -s "$OUT/${tag}_linalg.mlir" ]; then + echo "$OUT/${tag}_linalg.mlir" + else + echo "$OUT/${tag}.mlir" + fi +} + +summarize_one() { + local tag=$1 + local status artifact lg tensor memref loops ifs + + if [ ! -s "$OUT/${tag}.mlir" ]; then + printf "%-32s %-18s %7s %7s %7s %7s %7s %s\n" \ + "$tag" "cgeist-fail" "-" "-" "-" "-" "-" "$OUT/${tag}.cgeist.err" + return + fi + if [ ! -s "$OUT/${tag}_linalg.mlir" ]; then + printf "%-32s %-18s %7s %7s %7s %7s %7s %s\n" \ + "$tag" "raise-fail" "-" "-" "-" "-" "-" "$OUT/${tag}.raise.err" + return + fi + + artifact=$(pick_artifact "$tag") + lg=$(count_pattern "linalg\\.generic" "$artifact") + tensor=$(count_pattern "tensor<" "$artifact") + memref=$(count_pattern "memref<" "$artifact") + loops=$(count_pattern "affine\\.for|scf\\.for|affine\\.parallel|scf\\.parallel" "$artifact") + ifs=$(count_pattern "affine\\.if|scf\\.if" "$artifact") + + if [ "$lg" -gt 0 ] && [ "$tensor" -gt 0 ]; then + status="tensor-linalg" + elif [ "$lg" -gt 0 ]; then + status="memref-linalg" + else + status="no-linalg" + fi + if [ "$loops" -gt 0 ]; then + status="${status}+loops" + fi + if [ "$ifs" -gt 0 ]; then + status="${status}+if" + fi + + printf "%-32s %-18s %7s %7s %7s %7s %7s %s\n" \ + "$tag" "$status" "$lg" "$tensor" "$memref" "$loops" "$ifs" "$artifact" +} + +run_probe() { + local tag=$1 + local src=$2 + local cgeist_fn=$3 + local select_fn=$4 + shift 4 + + echo "[$tag] cgeist $cgeist_fn" + timeout 90 "$CGEIST_BIN" "$REPO_ROOT/$src" --function="$cgeist_fn" \ + --resource-dir="$RESOURCE_DIR" --raise-scf-to-affine -fPIC -std=gnu11 -S \ + "$@" -o "$OUT/${tag}.mlir" 2>"$OUT/${tag}.cgeist.err" + if [ ! -s "$OUT/${tag}.mlir" ]; then + echo " cgeist FAILED" + rm -f "$OUT/${tag}.mlir" + summarize_one "$tag" >> "$SUMMARY" + return + fi + + local select_args=() + if [ "$select_fn" != "-" ]; then + select_args=(--select-func=func-name="$select_fn") + fi + + echo "[$tag] raise" + timeout 90 "$POLYGEIST_OPT_BIN" \ + "${select_args[@]}" \ + --remove-iter-args --affine-parallelize \ + --raise-affine-to-linalg-pipeline --lower-polygeist-submap \ + "$OUT/${tag}.mlir" -o "$OUT/${tag}_linalg.mlir" \ + 2>"$OUT/${tag}.raise.err" + if [ ! -s "$OUT/${tag}_linalg.mlir" ]; then + echo " raise FAILED" + rm -f "$OUT/${tag}_linalg.mlir" + summarize_one "$tag" >> "$SUMMARY" + return + fi + + echo "[$tag] debuf v2" + timeout 90 "$POLYGEIST_OPT_BIN" --linalg-debufferize \ + "$OUT/${tag}_linalg.mlir" -o "$OUT/${tag}_debuf.mlir" \ + 2>"$OUT/${tag}.debuf.err" + if [ ! -s "$OUT/${tag}_debuf.mlir" ]; then + rm -f "$OUT/${tag}_debuf.mlir" + fi + + echo "[$tag] debuf multi-root" + timeout 90 "$POLYGEIST_OPT_BIN" --linalg-debufferize=use-multi-root=true \ + "$OUT/${tag}_linalg.mlir" -o "$OUT/${tag}_debuf_mr.mlir" \ + 2>"$OUT/${tag}.debuf_mr.err" + if [ ! -s "$OUT/${tag}_debuf_mr.mlir" ]; then + rm -f "$OUT/${tag}_debuf_mr.mlir" + fi + + summarize_one "$tag" >> "$SUMMARY" +} + +SUMMARY=$OUT/summary.txt +printf "%-32s %-18s %7s %7s %7s %7s %7s %s\n" \ + "probe" "status" "linalg" "tensor" "memref" "loops" "ifs" "artifact" > "$SUMMARY" + +run_probe "swfft_distribution_2_to_3" \ + "third_party/SWFFT/distribution.c" "distribution_2_to_3" "-" \ + -I"$PROBE_INCLUDE" -I"$REPO_ROOT/third_party/SWFFT" \ + -DNDEBUG -include "$PROBE_INCLUDE/swfft_probe_disable_debug.h" + +run_probe "miniamr_stencil_calc" \ + "third_party/miniAMR/ref/stencil.c" "stencil_calc" "-" \ + -I"$PROBE_INCLUDE" -I"$REPO_ROOT/third_party/miniAMR/ref" + +run_probe "hypar_linear_adr_advection" \ + "third_party/hypar/src/PhysicalModels/LinearADR/LinearADRAdvection.c" \ + "LinearADRAdvection" "LinearADRAdvection" \ + -I"$PROBE_INCLUDE" -I"$REPO_ROOT/third_party/hypar/include" + +run_probe "hpgmg_7pt_apply_op" \ + "third_party/hpgmg/finite-volume/source/operators.7pt.c" "*" "-" \ + -I"$PROBE_INCLUDE" -I"$REPO_ROOT/third_party/hpgmg/finite-volume/source" \ + -DUSE_JACOBI + +run_probe "exasp2_sp2_loop" \ + "third_party/ExaSP2/src/sp2Basic.c" "sp2Loop" "-" \ + -I"$PROBE_INCLUDE" -I"$REPO_ROOT/third_party/ExaSP2/src" \ + -DSP2_BASIC -DNTIMING -DNCOUNTING + +echo "Done. Output in $OUT" +cat "$SUMMARY" diff --git a/issues/proxy_kernel_extractions/README.md b/issues/proxy_kernel_extractions/README.md new file mode 100644 index 000000000000..ae08d159219e --- /dev/null +++ b/issues/proxy_kernel_extractions/README.md @@ -0,0 +1,29 @@ +# Proxy Kernel Extractions + +This directory contains standalone, minimized C kernels extracted from the five +C proxy apps selected for the CGO paper experiments: + +- `miniAMR`: stencil, material update, and halo pack/unpack kernels. +- `HPGMG`: stencil operators, residual/smoother kernels, BLAS1 kernels, + restriction/interpolation, flux kernels, and solver update kernels. +- `HyPar`: finite differences, reconstruction/WENO, limiters, LinearADR, + Burgers, and Euler flux/upwind kernels. +- `SWFFT`: redistribution, slab copy, and transpose/data-layout kernels. +- `ExaSP2`: dense matrix normalization, square/GEMM-like SP2 kernels, trace, + AXPBY, SpMV, and CG update kernels. + +The extraction intentionally removes MPI, BML, and solver-specific structs so +the run answers a narrower question: whether the computational loop/dataflow +shape can be raised by the Polygeist affine-to-Linalg pipeline. + +Run: + +```sh +issues/proxy_kernel_extractions/run_proxy_kernel_extractions.sh +``` + +By default the generated MLIR and summary go to: + +```sh +/tmp/proxy_kernel_extractions_mlir +``` diff --git a/issues/proxy_kernel_extractions/RESULTS.md b/issues/proxy_kernel_extractions/RESULTS.md new file mode 100644 index 000000000000..39aedbe370f0 --- /dev/null +++ b/issues/proxy_kernel_extractions/RESULTS.md @@ -0,0 +1,71 @@ +# Latest Proxy Kernel Extraction Results + +Run command: + +```sh +issues/proxy_kernel_extractions/run_proxy_kernel_extractions.sh +``` + +Latest output directory: + +```sh +/tmp/proxy_kernel_extractions_mlir +``` + +## Summary + +- Total standalone probes: 85 +- `cgeist` failures: 0 +- Tensor-form Linalg: 82 +- Loop-free memref-form Linalg: 2 +- Memref-form Linalg with residual loops: 1 +- No Linalg, but raise completed: 0 +- Raise failure: 0 +- Kernels with residual loops: 1 +- Kernels with residual ifs: 0 + +Project breakdown: + +- `miniAMR`: 13 total, 12 tensor-Linalg, 1 memref-Linalg with residual loops, 0 no-Linalg, 0 raise failures. +- `HPGMG`: 29 total, 27 tensor-Linalg, 2 loop-free memref-Linalg, 0 no-Linalg, 0 raise failures. +- `HyPar`: 28 total, 28 tensor-Linalg, 0 no-Linalg, 0 raise failures. +- `SWFFT`: 6 total, 6 tensor-Linalg, 0 no-Linalg, 0 raise failures. +- `ExaSP2`: 9 total, 9 tensor-Linalg, 0 no-Linalg, 0 raise failures. + +## Useful Successes + +- `miniAMR` isolated stencils, material updates, and halo pack/unpack mostly + raise cleanly to tensor Linalg. The only partial result is + `miniamr_stencil_calc_27`, which raises to memref Linalg but leaves the + explicit 3x3x3 accumulation loops. +- `HPGMG` 7-point/27-point apply, residual, Jacobi and red-black smoothers, + BLAS1 kernels, reductions, restriction, interpolation, FV flux extracts, and + CG/BiCGSTAB multi-vector updates raise. +- `HyPar` first/second/fourth finite differences, central/upwind + reconstruction, WENO reconstruction and weights, limiters, LinearADR pointwise + kernels, Burgers kernels, Euler fluxes, and LLF upwind fluxes raise. +- `SWFFT` local redistribution pack/unpack, slab copy, and transpose kernels + raise cleanly. This separates local layout movement from the full MPI-heavy + SWFFT application. +- `ExaSP2` dense normalization, dense square, SP2 update/select, trace, AXPBY, + SpMV, and CG-step extracts raise to tensor Linalg. + +## Current Partial Cases + +- `miniamr_stencil_calc_27`: raises to memref Linalg but leaves the explicit + small 3x3x3 accumulation loops. This is now the only residual-loop case. +- `hpgmg_interpolation_p1`: raises to loop-free memref Linalg. It uses + parity-dependent coarse-grid indexing and dynamic `memref.load` operations + inside the Linalg payload, so the current debufferizer does not convert it to + tensor form. +- `hpgmg_interpolation_p2`: raises to loop-free memref Linalg for the same + hybrid-payload reason. + +## Interpretation + +The isolated results are strong for the paper narrative: once the application +ABI, MPI, BML, and solver structs are removed, most regular compute and layout +kernels from these proxy apps raise to Linalg. The remaining cases point to +specific next compiler/matcher work: tensorizing hybrid Linalg bodies that keep +dynamic memref payload loads, and composing nested fixed-size stencil reductions +such as the explicit 27-point accumulation in `miniamr_stencil_calc_27`. diff --git a/issues/proxy_kernel_extractions/proxy_kernel_extractions.c b/issues/proxy_kernel_extractions/proxy_kernel_extractions.c new file mode 100644 index 000000000000..f8375f353087 --- /dev/null +++ b/issues/proxy_kernel_extractions/proxy_kernel_extractions.c @@ -0,0 +1,925 @@ +// Standalone kernelized extracts from the C proxy apps we are evaluating. +// The goal is to preserve loop/dataflow shapes while removing app ABI, +// MPI, BML, and solver-struct setup. + +#include + +#define PK_ABS(x) ((x) < 0.0 ? -(x) : (x)) +#define PK_MAX(a, b) ((a) > (b) ? (a) : (b)) +#define PK_MIN(a, b) ((a) < (b) ? (a) : (b)) + +#define MX 12 +#define MY 10 +#define MZ 8 +#define MMAT 4 + +void miniamr_stencil_calc_7(double out[MX][MY][MZ], + const double in[MX + 2][MY + 2][MZ + 2]) { + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + out[i][j][k] = (in[i][j + 1][k + 1] + in[i + 1][j][k + 1] + + in[i + 1][j + 1][k] + in[i + 1][j + 1][k + 1] + + in[i + 1][j + 1][k + 2] + in[i + 1][j + 2][k + 1] + + in[i + 2][j + 1][k + 1]) / + 7.0; +} + +void miniamr_stencil_calc_27(double out[MX][MY][MZ], + const double in[MX + 2][MY + 2][MZ + 2]) { + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double sum = 0.0; + for (int di = 0; di < 3; di++) + for (int dj = 0; dj < 3; dj++) + for (int dk = 0; dk < 3; dk++) + sum += in[i + di][j + dj][k + dk]; + out[i][j][k] = sum / 27.0; + } +} + +void miniamr_stencil_0_coupled_sum(double out[MX][MY][MZ], + const double material[MMAT][MX][MY][MZ], + const double base[MX][MY][MZ]) { + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double acc = out[i][j][k]; + for (int v = 0; v < MMAT; v++) + acc += material[v][i][j][k] * base[i][j][k]; + out[i][j][k] = acc; + } +} + +void miniamr_stencil_0_pointwise_update(double out[MX][MY][MZ], + const double a[MX][MY][MZ], + const double b[MX][MY][MZ], + double a1) { + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + out[i][j][k] += out[i][j][k] * + (a[i][j][k] + b[i][j][k] - a1 * out[i][j][k]); +} + +void miniamr_stencil_x_directional(double out[MX][MY][MZ], + const double in[MX + 2][MY][MZ], + double a0, double a1) { + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double left = in[i][j][k]; + double center = in[i + 1][j][k]; + double right = in[i + 2][j][k]; + out[i][j][k] = center + a0 * (left - 2.0 * center + right) + + a1 * (right - left); + } +} + +void miniamr_stencil_y_directional(double out[MX][MY][MZ], + const double in[MX][MY + 2][MZ], + double a0, double a1) { + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double left = in[i][j][k]; + double center = in[i][j + 1][k]; + double right = in[i][j + 2][k]; + out[i][j][k] = center + a0 * (left - 2.0 * center + right) + + a1 * (right - left); + } +} + +void miniamr_stencil_z_directional(double out[MX][MY][MZ], + const double in[MX][MY][MZ + 2], + double a0, double a1) { + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double left = in[i][j][k]; + double center = in[i][j][k + 1]; + double right = in[i][j][k + 2]; + out[i][j][k] = center + a0 * (left - 2.0 * center + right) + + a1 * (right - left); + } +} + +void miniamr_stencil_7_weighted(double out[MX][MY][MZ], + const double in[MX + 2][MY + 2][MZ + 2], + const double coeff[MX][MY][MZ]) { + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double center = in[i + 1][j + 1][k + 1]; + double lap = in[i][j + 1][k + 1] + in[i + 2][j + 1][k + 1] + + in[i + 1][j][k + 1] + in[i + 1][j + 2][k + 1] + + in[i + 1][j + 1][k] + in[i + 1][j + 1][k + 2] - + 6.0 * center; + out[i][j][k] = center + coeff[i][j][k] * lap; + } +} + +void miniamr_stencil_27_weighted(double out[MX][MY][MZ], + const double in[MX + 2][MY + 2][MZ + 2], + const double coeff[3][3][3]) { + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double sum = 0.0; + for (int di = 0; di < 3; di++) + for (int dj = 0; dj < 3; dj++) + for (int dk = 0; dk < 3; dk++) + sum += coeff[di][dj][dk] * in[i + di][j + dj][k + dk]; + out[i][j][k] = sum; + } +} + +void miniamr_pack_face_x(double buf[MY][MZ], + const double grid[MX + 2][MY + 2][MZ + 2]) { + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + buf[j][k] = grid[1][j + 1][k + 1]; +} + +void miniamr_unpack_face_x(double grid[MX + 2][MY + 2][MZ + 2], + const double buf[MY][MZ]) { + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + grid[0][j + 1][k + 1] = buf[j][k]; +} + +void miniamr_pack_block(double buf[MX * MY * MZ], + const double grid[MX][MY][MZ]) { + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + buf[(i * MY + j) * MZ + k] = grid[i][j][k]; +} + +void miniamr_unpack_block(double grid[MX][MY][MZ], + const double buf[MX * MY * MZ]) { + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + grid[i][j][k] = buf[(i * MY + j) * MZ + k]; +} + +#define HX 12 +#define HY 10 +#define HZ 8 +#define HV 960 + +void hpgmg_apply_op_7pt(double Ax[HX][HY][HZ], + const double x[HX + 2][HY + 2][HZ + 2], double a, + double b) { + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) { + double center = x[i + 1][j + 1][k + 1]; + double lap = 6.0 * center - x[i][j + 1][k + 1] - + x[i + 2][j + 1][k + 1] - x[i + 1][j][k + 1] - + x[i + 1][j + 2][k + 1] - x[i + 1][j + 1][k] - + x[i + 1][j + 1][k + 2]; + Ax[i][j][k] = a * center + b * lap; + } +} + +void hpgmg_apply_op_27pt(double Ax[HX][HY][HZ], + const double x[HX + 2][HY + 2][HZ + 2], + const double coeff[3][3][3], double a) { + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) { + double sum = a * x[i + 1][j + 1][k + 1]; + for (int di = 0; di < 3; di++) + for (int dj = 0; dj < 3; dj++) + for (int dk = 0; dk < 3; dk++) + sum += coeff[di][dj][dk] * x[i + di][j + dj][k + dk]; + Ax[i][j][k] = sum; + } +} + +void hpgmg_residual_7pt(double res[HX][HY][HZ], + const double rhs[HX][HY][HZ], + const double x[HX + 2][HY + 2][HZ + 2], double a, + double b) { + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) { + double center = x[i + 1][j + 1][k + 1]; + double lap = 6.0 * center - x[i][j + 1][k + 1] - + x[i + 2][j + 1][k + 1] - x[i + 1][j][k + 1] - + x[i + 1][j + 2][k + 1] - x[i + 1][j + 1][k] - + x[i + 1][j + 1][k + 2]; + res[i][j][k] = rhs[i][j][k] - (a * center + b * lap); + } +} + +void hpgmg_jacobi_smooth_7pt(double next[HX][HY][HZ], + const double cur[HX + 2][HY + 2][HZ + 2], + const double rhs[HX][HY][HZ], + const double dinv[HX][HY][HZ], double a, + double b, double weight) { + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) { + double center = cur[i + 1][j + 1][k + 1]; + double lap = 6.0 * center - cur[i][j + 1][k + 1] - + cur[i + 2][j + 1][k + 1] - cur[i + 1][j][k + 1] - + cur[i + 1][j + 2][k + 1] - cur[i + 1][j + 1][k] - + cur[i + 1][j + 1][k + 2]; + double ax = a * center + b * lap; + next[i][j][k] = center + weight * dinv[i][j][k] * (rhs[i][j][k] - ax); + } +} + +void hpgmg_gsrb_smooth_7pt(double x[HX + 2][HY + 2][HZ + 2], + const double rhs[HX][HY][HZ], + const double dinv[HX][HY][HZ], int color, + double a, double b) { + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) + if (((i + j + k) & 1) == color) { + double center = x[i + 1][j + 1][k + 1]; + double lap = 6.0 * center - x[i][j + 1][k + 1] - + x[i + 2][j + 1][k + 1] - x[i + 1][j][k + 1] - + x[i + 1][j + 2][k + 1] - x[i + 1][j + 1][k] - + x[i + 1][j + 1][k + 2]; + double ax = a * center + b * lap; + x[i + 1][j + 1][k + 1] = + center + dinv[i][j][k] * (rhs[i][j][k] - ax); + } +} + +void hpgmg_zero_vector(double a[HV]) { + for (int i = 0; i < HV; i++) + a[i] = 0.0; +} + +void hpgmg_init_vector(double a[HV], double scalar) { + for (int i = 0; i < HV; i++) + a[i] = scalar; +} + +void hpgmg_add_vectors(double c[HV], const double a[HV], const double b[HV], + double scale_a, double scale_b) { + for (int i = 0; i < HV; i++) + c[i] = scale_a * a[i] + scale_b * b[i]; +} + +void hpgmg_mul_vectors(double c[HV], const double a[HV], const double b[HV], + double scale) { + for (int i = 0; i < HV; i++) + c[i] = scale * a[i] * b[i]; +} + +void hpgmg_invert_vector(double c[HV], const double a[HV], double scale) { + for (int i = 0; i < HV; i++) + c[i] = scale / a[i]; +} + +void hpgmg_scale_vector(double c[HV], const double a[HV], double scale) { + for (int i = 0; i < HV; i++) + c[i] = scale * a[i]; +} + +void hpgmg_shift_vector(double c[HV], const double a[HV], double shift) { + for (int i = 0; i < HV; i++) + c[i] = a[i] + shift; +} + +double hpgmg_dot(const double a[HV], const double b[HV]) { + double sum = 0.0; + for (int i = 0; i < HV; i++) + sum += a[i] * b[i]; + return sum; +} + +double hpgmg_norm(const double a[HV]) { + double n = 0.0; + for (int i = 0; i < HV; i++) { + double v = PK_ABS(a[i]); + if (v > n) + n = v; + } + return n; +} + +double hpgmg_mean(const double a[HV]) { + double sum = 0.0; + for (int i = 0; i < HV; i++) + sum += a[i]; + return sum / (double)HV; +} + +double hpgmg_error_l2(const double a[HV], const double b[HV], double h3) { + double sum = 0.0; + for (int i = 0; i < HV; i++) { + double d = a[i] - b[i]; + sum += d * d * h3; + } + return sum; +} + +void hpgmg_color_vector(double grid[HX][HY][HZ], int colors, int ci, int cj, + int ck) { + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) { + double si = (((i + ci) % colors) == 0) ? 1.0 : 0.0; + double sj = (((j + cj) % colors) == 0) ? 1.0 : 0.0; + double sk = (((k + ck) % colors) == 0) ? 1.0 : 0.0; + grid[i][j][k] = si * sj * sk; + } +} + +void hpgmg_random_vector(double grid[HX][HY][HZ]) { + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) + grid[i][j][k] = -1.0 + 2.0 * (double)((i ^ j ^ k ^ 1) & 1); +} + +void hpgmg_restriction_cell(double coarse[HX][HY][HZ], + const double fine[2 * HX][2 * HY][2 * HZ]) { + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) { + int ii = 2 * i, jj = 2 * j, kk = 2 * k; + coarse[i][j][k] = + (fine[ii][jj][kk] + fine[ii + 1][jj][kk] + + fine[ii][jj + 1][kk] + fine[ii + 1][jj + 1][kk] + + fine[ii][jj][kk + 1] + fine[ii + 1][jj][kk + 1] + + fine[ii][jj + 1][kk + 1] + fine[ii + 1][jj + 1][kk + 1]) * + 0.125; + } +} + +void hpgmg_restriction_face_i(double coarse[HX][HY][HZ], + const double fine[2 * HX][2 * HY][2 * HZ]) { + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) { + int ii = 2 * i, jj = 2 * j, kk = 2 * k; + coarse[i][j][k] = (fine[ii][jj][kk] + fine[ii][jj + 1][kk] + + fine[ii][jj][kk + 1] + + fine[ii][jj + 1][kk + 1]) * + 0.25; + } +} + +void hpgmg_restriction_face_j(double coarse[HX][HY][HZ], + const double fine[2 * HX][2 * HY][2 * HZ]) { + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) { + int ii = 2 * i, jj = 2 * j, kk = 2 * k; + coarse[i][j][k] = (fine[ii][jj][kk] + fine[ii + 1][jj][kk] + + fine[ii][jj][kk + 1] + + fine[ii + 1][jj][kk + 1]) * + 0.25; + } +} + +void hpgmg_restriction_face_k(double coarse[HX][HY][HZ], + const double fine[2 * HX][2 * HY][2 * HZ]) { + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) { + int ii = 2 * i, jj = 2 * j, kk = 2 * k; + coarse[i][j][k] = (fine[ii][jj][kk] + fine[ii + 1][jj][kk] + + fine[ii][jj + 1][kk] + + fine[ii + 1][jj + 1][kk]) * + 0.25; + } +} + +void hpgmg_interpolation_p0(double fine[2 * HX][2 * HY][2 * HZ], + const double coarse[HX][HY][HZ]) { + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) + for (int di = 0; di < 2; di++) + for (int dj = 0; dj < 2; dj++) + for (int dk = 0; dk < 2; dk++) + fine[2 * i + di][2 * j + dj][2 * k + dk] = coarse[i][j][k]; +} + +void hpgmg_interpolation_p1(double fine[2 * HX][2 * HY][2 * HZ], + const double coarse[HX + 2][HY + 2][HZ + 2], + double prescale) { + for (int i = 0; i < 2 * HX; i++) + for (int j = 0; j < 2 * HY; j++) + for (int k = 0; k < 2 * HZ; k++) { + int ci = i >> 1, cj = j >> 1, ck = k >> 1; + int di = (i & 1) ? 1 : -1; + int dj = (j & 1) ? 1 : -1; + int dk = (k & 1) ? 1 : -1; + fine[i][j][k] = + prescale * fine[i][j][k] + + 0.421875 * coarse[ci + 1][cj + 1][ck + 1] + + 0.140625 * coarse[ci + 1 + di][cj + 1][ck + 1] + + 0.140625 * coarse[ci + 1][cj + 1 + dj][ck + 1] + + 0.140625 * coarse[ci + 1][cj + 1][ck + 1 + dk] + + 0.046875 * coarse[ci + 1 + di][cj + 1 + dj][ck + 1] + + 0.046875 * coarse[ci + 1 + di][cj + 1][ck + 1 + dk] + + 0.046875 * coarse[ci + 1][cj + 1 + dj][ck + 1 + dk] + + 0.015625 * coarse[ci + 1 + di][cj + 1 + dj][ck + 1 + dk]; + } +} + +void hpgmg_interpolation_p2(double fine[2 * HX][2 * HY][2 * HZ], + const double coarse[HX + 2][HY + 2][HZ + 2]) { + for (int i = 0; i < 2 * HX; i++) + for (int j = 0; j < 2 * HY; j++) + for (int k = 0; k < 2 * HZ; k++) { + int ci = i >> 1, cj = j >> 1, ck = k >> 1; + fine[i][j][k] = 0.5 * coarse[ci + 1][cj + 1][ck + 1] + + 0.08333333333333333 * + (coarse[ci][cj + 1][ck + 1] + + coarse[ci + 2][cj + 1][ck + 1] + + coarse[ci + 1][cj][ck + 1] + + coarse[ci + 1][cj + 2][ck + 1] + + coarse[ci + 1][cj + 1][ck] + + coarse[ci + 1][cj + 1][ck + 2]); + } +} + +void hpgmg_fv2_flux(double flux[HX][HY][HZ], + const double a[HX + 2][HY + 2][HZ + 2]) { + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) + flux[i][j][k] = a[i + 2][j + 1][k + 1] - a[i + 1][j + 1][k + 1]; +} + +void hpgmg_fv4_flux(double flux[HX][HY][HZ], + const double a[HX + 4][HY + 4][HZ + 4]) { + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) + flux[i][j][k] = + (-a[i][j + 2][k + 2] + 7.0 * a[i + 1][j + 2][k + 2] - + 7.0 * a[i + 2][j + 2][k + 2] + a[i + 3][j + 2][k + 2]) / + 12.0; +} + +void hpgmg_cg_update(double x[HV], double r[HV], double p[HV], + const double Ap[HV], double alpha, double beta) { + for (int i = 0; i < HV; i++) { + x[i] += alpha * p[i]; + r[i] -= alpha * Ap[i]; + p[i] = r[i] + beta * p[i]; + } +} + +void hpgmg_bicgstab_update(double x[HV], double r[HV], const double p[HV], + const double v[HV], double alpha, double omega) { + for (int i = 0; i < HV; i++) { + double s = r[i] - alpha * v[i]; + x[i] += alpha * p[i] + omega * s; + r[i] = s - omega * v[i]; + } +} + +#define HL 32 +#define HNV 4 + +void hypar_first_derivative_first_order(double df[HL][HNV], + const double f[HL + 1][HNV]) { + for (int i = 0; i < HL; i++) + for (int v = 0; v < HNV; v++) + df[i][v] = f[i + 1][v] - f[i][v]; +} + +void hypar_first_derivative_second_order(double df[HL][HNV], + const double f[HL + 2][HNV]) { + for (int i = 0; i < HL; i++) + for (int v = 0; v < HNV; v++) + df[i][v] = 0.5 * (f[i + 2][v] - f[i][v]); +} + +void hypar_first_derivative_fourth_order(double df[HL][HNV], + const double f[HL + 4][HNV]) { + for (int i = 0; i < HL; i++) + for (int v = 0; v < HNV; v++) + df[i][v] = (f[i][v] - 8.0 * f[i + 1][v] + 8.0 * f[i + 3][v] - + f[i + 4][v]) / + 12.0; +} + +void hypar_interp_first_order_upwind(double fI[HL + 1][HNV], + const double fC[HL + 2][HNV], int upw) { + for (int i = 0; i < HL + 1; i++) + for (int v = 0; v < HNV; v++) + fI[i][v] = upw > 0 ? fC[i][v] : fC[i + 1][v]; +} + +void hypar_interp_second_order_central(double fI[HL + 1][HNV], + const double fC[HL + 2][HNV]) { + for (int i = 0; i < HL + 1; i++) + for (int v = 0; v < HNV; v++) + fI[i][v] = 0.5 * (fC[i][v] + fC[i + 1][v]); +} + +void hypar_interp_second_order_muscl(double fI[HL + 1][HNV], + const double fC[HL + 3][HNV]) { + for (int i = 0; i < HL + 1; i++) + for (int v = 0; v < HNV; v++) { + double dl = fC[i + 1][v] - fC[i][v]; + double dr = fC[i + 2][v] - fC[i + 1][v]; + double slope = (dl * dr <= 0.0) ? 0.0 + : ((PK_ABS(dl) < PK_ABS(dr)) ? dl : dr); + fI[i][v] = fC[i + 1][v] - 0.5 * slope; + } +} + +void hypar_interp_fourth_order_central(double fI[HL + 1][HNV], + const double fC[HL + 4][HNV]) { + for (int i = 0; i < HL + 1; i++) + for (int v = 0; v < HNV; v++) + fI[i][v] = (-fC[i][v] + 7.0 * fC[i + 1][v] + + 7.0 * fC[i + 2][v] - fC[i + 3][v]) / + 12.0; +} + +void hypar_interp_fifth_order_weno(double fI[HL + 1][HNV], + const double fC[HL + 5][HNV], + const double w1[HL + 1][HNV], + const double w2[HL + 1][HNV], + const double w3[HL + 1][HNV]) { + for (int i = 0; i < HL + 1; i++) + for (int v = 0; v < HNV; v++) { + double f1 = (2.0 * fC[i][v] - 7.0 * fC[i + 1][v] + + 11.0 * fC[i + 2][v]) / + 6.0; + double f2 = (-fC[i + 1][v] + 5.0 * fC[i + 2][v] + + 2.0 * fC[i + 3][v]) / + 6.0; + double f3 = (2.0 * fC[i + 2][v] + 5.0 * fC[i + 3][v] - + fC[i + 4][v]) / + 6.0; + fI[i][v] = w1[i][v] * f1 + w2[i][v] * f2 + w3[i][v] * f3; + } +} + +void hypar_weno_weights_js(double w1[HL + 1][HNV], double w2[HL + 1][HNV], + double w3[HL + 1][HNV], + const double fC[HL + 5][HNV], double eps) { + for (int i = 0; i < HL + 1; i++) + for (int v = 0; v < HNV; v++) { + double fm2 = fC[i][v], fm1 = fC[i + 1][v], f0 = fC[i + 2][v]; + double fp1 = fC[i + 3][v], fp2 = fC[i + 4][v]; + double b1 = (13.0 / 12.0) * (fm2 - 2.0 * fm1 + f0) * + (fm2 - 2.0 * fm1 + f0) + + 0.25 * (fm2 - 4.0 * fm1 + 3.0 * f0) * + (fm2 - 4.0 * fm1 + 3.0 * f0); + double b2 = (13.0 / 12.0) * (fm1 - 2.0 * f0 + fp1) * + (fm1 - 2.0 * f0 + fp1) + + 0.25 * (fm1 - fp1) * (fm1 - fp1); + double b3 = (13.0 / 12.0) * (f0 - 2.0 * fp1 + fp2) * + (f0 - 2.0 * fp1 + fp2) + + 0.25 * (3.0 * f0 - 4.0 * fp1 + fp2) * + (3.0 * f0 - 4.0 * fp1 + fp2); + double a1 = 0.1 / ((b1 + eps) * (b1 + eps)); + double a2 = 0.6 / ((b2 + eps) * (b2 + eps)); + double a3 = 0.3 / ((b3 + eps) * (b3 + eps)); + double sum = a1 + a2 + a3; + w1[i][v] = a1 / sum; + w2[i][v] = a2 / sum; + w3[i][v] = a3 / sum; + } +} + +void hypar_limiter_minmod(double out[HL][HNV], const double a[HL][HNV], + const double b[HL][HNV]) { + for (int i = 0; i < HL; i++) + for (int v = 0; v < HNV; v++) + out[i][v] = (a[i][v] * b[i][v] <= 0.0) + ? 0.0 + : ((PK_ABS(a[i][v]) < PK_ABS(b[i][v])) ? a[i][v] + : b[i][v]); +} + +void hypar_limiter_superbee(double out[HL][HNV], const double a[HL][HNV], + const double b[HL][HNV]) { + for (int i = 0; i < HL; i++) + for (int v = 0; v < HNV; v++) { + double s1 = PK_MIN(2.0 * PK_ABS(a[i][v]), PK_ABS(b[i][v])); + double s2 = PK_MIN(PK_ABS(a[i][v]), 2.0 * PK_ABS(b[i][v])); + double mag = PK_MAX(s1, s2); + out[i][v] = (a[i][v] * b[i][v] <= 0.0) ? 0.0 + : (a[i][v] < 0.0 ? -mag : mag); + } +} + +void hypar_limiter_generalized_minmod(double out[HL][HNV], + const double a[HL][HNV], + const double b[HL][HNV], double theta) { + for (int i = 0; i < HL; i++) + for (int v = 0; v < HNV; v++) { + double aa = theta * a[i][v]; + double bb = 0.5 * (a[i][v] + b[i][v]); + double cc = theta * b[i][v]; + double same = (aa * bb > 0.0 && bb * cc > 0.0) ? 1.0 : 0.0; + double mag = PK_MIN(PK_ABS(aa), PK_MIN(PK_ABS(bb), PK_ABS(cc))); + out[i][v] = same == 0.0 ? 0.0 : (aa < 0.0 ? -mag : mag); + } +} + +void hypar_limiter_vanleer(double out[HL][HNV], const double a[HL][HNV], + const double b[HL][HNV]) { + for (int i = 0; i < HL; i++) + for (int v = 0; v < HNV; v++) + out[i][v] = (a[i][v] * b[i][v] <= 0.0) + ? 0.0 + : (2.0 * a[i][v] * b[i][v]) / (a[i][v] + b[i][v]); +} + +void hypar_linear_adr_advection_const(double f[HL][HNV], + const double u[HL][HNV], + const double a[HNV]) { + for (int i = 0; i < HL; i++) + for (int v = 0; v < HNV; v++) + f[i][v] = a[v] * u[i][v]; +} + +void hypar_linear_adr_advection_var(double f[HL][HNV], + const double u[HL][HNV], + const double a[HL][HNV]) { + for (int i = 0; i < HL; i++) + for (int v = 0; v < HNV; v++) + f[i][v] = a[i][v] * u[i][v]; +} + +void hypar_linear_adr_diffusion_g(double f[HL][HNV], const double u[HL][HNV], + const double d[HNV]) { + for (int i = 0; i < HL; i++) + for (int v = 0; v < HNV; v++) + f[i][v] = d[v] * u[i][v]; +} + +void hypar_linear_adr_diffusion_h(double f[HL][HNV], const double u[HL][HNV], + const double d[HNV], int same_dir) { + for (int i = 0; i < HL; i++) + for (int v = 0; v < HNV; v++) + f[i][v] = same_dir ? d[v] * u[i][v] : 0.0; +} + +void hypar_linear_adr_upwind_const(double fI[HL + 1][HNV], + const double fL[HL + 1][HNV], + const double fR[HL + 1][HNV], + const double a[HNV]) { + for (int i = 0; i < HL + 1; i++) + for (int v = 0; v < HNV; v++) + fI[i][v] = a[v] > 0.0 ? fL[i][v] : fR[i][v]; +} + +void hypar_linear_adr_upwind_var(double fI[HL + 1][HNV], + const double fL[HL + 1][HNV], + const double fR[HL + 1][HNV], + const double uL[HL + 1][HNV], + const double uR[HL + 1][HNV], + const double eigL[HL + 1][HNV], + const double eigR[HL + 1][HNV]) { + for (int i = 0; i < HL + 1; i++) + for (int v = 0; v < HNV; v++) { + if (eigL[i][v] > 0.0 && eigR[i][v] > 0.0) { + fI[i][v] = fL[i][v]; + } else if (eigL[i][v] < 0.0 && eigR[i][v] < 0.0) { + fI[i][v] = fR[i][v]; + } else { + double alpha = PK_MAX(PK_ABS(eigL[i][v]), PK_ABS(eigR[i][v])); + fI[i][v] = + 0.5 * (fL[i][v] + fR[i][v] - alpha * (uR[i][v] - uL[i][v])); + } + } +} + +void hypar_linear_adr_centered_flux(double fI[HL + 1][HNV], + const double fL[HL + 1][HNV], + const double fR[HL + 1][HNV]) { + for (int i = 0; i < HL + 1; i++) + for (int v = 0; v < HNV; v++) + fI[i][v] = 0.5 * (fL[i][v] + fR[i][v]); +} + +void hypar_linear_adr_reaction(double r[HL][HNV], const double u[HL][HNV], + const double source[HL][HNV], double lambda) { + for (int i = 0; i < HL; i++) + for (int v = 0; v < HNV; v++) + r[i][v] = source[i][v] - lambda * u[i][v]; +} + +void hypar_burgers_advection(double f[HL], const double u[HL]) { + for (int i = 0; i < HL; i++) + f[i] = 0.5 * u[i] * u[i]; +} + +void hypar_burgers_upwind(double fI[HL + 1], const double fL[HL + 1], + const double fR[HL + 1], const double uL[HL + 1], + const double uR[HL + 1]) { + for (int i = 0; i < HL + 1; i++) { + double alpha = PK_MAX(PK_ABS(uL[i]), PK_ABS(uR[i])); + fI[i] = 0.5 * (fL[i] + fR[i] - alpha * (uR[i] - uL[i])); + } +} + +void hypar_euler1d_flux(double f[HL][3], const double u[HL][3], + double gamma) { + for (int i = 0; i < HL; i++) { + double rho = u[i][0]; + double mom = u[i][1]; + double eng = u[i][2]; + double vel = mom / rho; + double p = (gamma - 1.0) * (eng - 0.5 * rho * vel * vel); + f[i][0] = mom; + f[i][1] = mom * vel + p; + f[i][2] = (eng + p) * vel; + } +} + +void hypar_euler1d_llf(double fI[HL + 1][3], const double fL[HL + 1][3], + const double fR[HL + 1][3], + const double uL[HL + 1][3], + const double uR[HL + 1][3], double alpha) { + for (int i = 0; i < HL + 1; i++) + for (int v = 0; v < 3; v++) + fI[i][v] = 0.5 * (fL[i][v] + fR[i][v] - alpha * (uR[i][v] - uL[i][v])); +} + +void hypar_euler2d_flux_x(double f[HL][4], const double u[HL][4], + double gamma) { + for (int i = 0; i < HL; i++) { + double rho = u[i][0]; + double mx = u[i][1]; + double my = u[i][2]; + double eng = u[i][3]; + double vx = mx / rho; + double vy = my / rho; + double p = (gamma - 1.0) * (eng - 0.5 * rho * (vx * vx + vy * vy)); + f[i][0] = mx; + f[i][1] = mx * vx + p; + f[i][2] = my * vx; + f[i][3] = (eng + p) * vx; + } +} + +void hypar_euler2d_flux_y(double f[HL][4], const double u[HL][4], + double gamma) { + for (int i = 0; i < HL; i++) { + double rho = u[i][0]; + double mx = u[i][1]; + double my = u[i][2]; + double eng = u[i][3]; + double vx = mx / rho; + double vy = my / rho; + double p = (gamma - 1.0) * (eng - 0.5 * rho * (vx * vx + vy * vy)); + f[i][0] = my; + f[i][1] = mx * vy; + f[i][2] = my * vy + p; + f[i][3] = (eng + p) * vy; + } +} + +void hypar_euler2d_llf(double fI[HL + 1][4], const double fL[HL + 1][4], + const double fR[HL + 1][4], + const double uL[HL + 1][4], + const double uR[HL + 1][4], double alpha) { + for (int i = 0; i < HL + 1; i++) + for (int v = 0; v < 4; v++) + fI[i][v] = 0.5 * (fL[i][v] + fR[i][v] - alpha * (uR[i][v] - uL[i][v])); +} + +#define SX 8 +#define SY 8 +#define SZ 8 + +void swfft_redistribute_2_to_3_pack(double chunk[SX][SY][SZ], + const double pencil[SX * SY * SZ]) { + for (int x = 0; x < SX; x++) + for (int y = 0; y < SY; y++) + for (int z = 0; z < SZ; z++) + chunk[x][y][z] = pencil[(x * SY + y) * SZ + z]; +} + +void swfft_redistribute_3_to_2_unpack(double pencil[SX * SY * SZ], + const double chunk[SX][SY][SZ]) { + for (int x = 0; x < SX; x++) + for (int y = 0; y < SY; y++) + for (int z = 0; z < SZ; z++) + pencil[(x * SY + y) * SZ + z] = chunk[x][y][z]; +} + +void swfft_slab_pack(double slab[SX][SY], const double cube[SX][SY][SZ], + int z) { + for (int x = 0; x < SX; x++) + for (int y = 0; y < SY; y++) + slab[x][y] = cube[x][y][z]; +} + +void swfft_slab_unpack(double cube[SX][SY][SZ], const double slab[SX][SY], + int z) { + for (int x = 0; x < SX; x++) + for (int y = 0; y < SY; y++) + cube[x][y][z] = slab[x][y]; +} + +void swfft_transpose_xy(double out[SY][SX][SZ], + const double in[SX][SY][SZ]) { + for (int x = 0; x < SX; x++) + for (int y = 0; y < SY; y++) + for (int z = 0; z < SZ; z++) + out[y][x][z] = in[x][y][z]; +} + +void swfft_transpose_yz(double out[SX][SZ][SY], + const double in[SX][SY][SZ]) { + for (int x = 0; x < SX; x++) + for (int y = 0; y < SY; y++) + for (int z = 0; z < SZ; z++) + out[x][z][y] = in[x][y][z]; +} + +#define EN 16 + +void exasp2_normalize_dense(double rho[EN][EN], const double h[EN][EN], + double emax, double emin) { + double range = emax - emin; + for (int i = 0; i < EN; i++) + for (int j = 0; j < EN; j++) { + double val = -h[i][j] / range; + if (i == j) + val += emax / range; + rho[i][j] = val; + } +} + +void exasp2_normalize_dense_split(double rho[EN][EN], const double h[EN][EN], + double emax, double emin) { + double range = emax - emin; + for (int i = 0; i < EN; i++) + for (int j = 0; j < EN; j++) + rho[i][j] = -h[i][j] / range; + + for (int i = 0; i < EN; i++) + rho[i][i] += emax / range; +} + +void exasp2_dense_square(double x2[EN][EN], const double x[EN][EN]) { + for (int i = 0; i < EN; i++) + for (int j = 0; j < EN; j++) { + double sum = 0.0; + for (int k = 0; k < EN; k++) + sum += x[i][k] * x[k][j]; + x2[i][j] = sum; + } +} + +void exasp2_sp2_update_2x_minus_x2(double x[EN][EN], + const double x2[EN][EN]) { + for (int i = 0; i < EN; i++) + for (int j = 0; j < EN; j++) + x[i][j] = 2.0 * x[i][j] - x2[i][j]; +} + +void exasp2_sp2_select_square(double x[EN][EN], const double x2[EN][EN], + int take_square) { + for (int i = 0; i < EN; i++) + for (int j = 0; j < EN; j++) + x[i][j] = take_square ? x2[i][j] : 2.0 * x[i][j] - x2[i][j]; +} + +double exasp2_trace(const double x[EN][EN]) { + double tr = 0.0; + for (int i = 0; i < EN; i++) + tr += x[i][i]; + return tr; +} + +void exasp2_axpby(double c[HV], const double a[HV], const double b[HV], + double alpha, double beta) { + for (int i = 0; i < HV; i++) + c[i] = alpha * a[i] + beta * b[i]; +} + +void exasp2_spmv(double y[EN], const double a[EN][EN], const double x[EN]) { + for (int i = 0; i < EN; i++) { + double sum = 0.0; + for (int j = 0; j < EN; j++) + sum += a[i][j] * x[j]; + y[i] = sum; + } +} + +void exasp2_conjugate_gradient_step(double x[EN], double r[EN], double p[EN], + const double Ap[EN], double alpha, + double beta) { + for (int i = 0; i < EN; i++) { + x[i] += alpha * p[i]; + r[i] -= alpha * Ap[i]; + p[i] = r[i] + beta * p[i]; + } +} diff --git a/issues/proxy_kernel_extractions/run_proxy_kernel_extractions.sh b/issues/proxy_kernel_extractions/run_proxy_kernel_extractions.sh new file mode 100755 index 000000000000..04ef31abb8c6 --- /dev/null +++ b/issues/proxy_kernel_extractions/run_proxy_kernel_extractions.sh @@ -0,0 +1,231 @@ +#!/bin/bash +# Run the standalone proxy-kernel extraction suite through cgeist and the +# affine-to-linalg pipeline. +set +e + +REPO_ROOT=${REPO_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)} +OUT=${POLYGEIST_PROXY_KERNEL_OUT:-/tmp/proxy_kernel_extractions_mlir} +CGEIST_BIN=${CGEIST_BIN:-$REPO_ROOT/build/bin/cgeist} +POLYGEIST_OPT_BIN=${POLYGEIST_OPT_BIN:-$REPO_ROOT/build/bin/polygeist-opt} +SRC=$REPO_ROOT/issues/proxy_kernel_extractions/proxy_kernel_extractions.c + +if [ -n "${POLYGEIST_CLANG_RESOURCE_DIR:-}" ]; then + RESOURCE_DIR=$POLYGEIST_CLANG_RESOURCE_DIR +elif [ -d "$REPO_ROOT/llvm-project/build/lib/clang/18" ]; then + RESOURCE_DIR=$REPO_ROOT/llvm-project/build/lib/clang/18 +else + RESOURCE_DIR=/usr/lib/clang/14 +fi + +mkdir -p "$OUT" +rm -f "$OUT"/* + +count_pattern() { + local pattern=$1 + local file=$2 + if [ ! -s "$file" ]; then + echo 0 + return + fi + grep -Ec "$pattern" "$file" 2>/dev/null +} + +pick_artifact() { + local tag=$1 + if [ -s "$OUT/${tag}_debuf_mr.mlir" ] && + grep -q "linalg.generic" "$OUT/${tag}_debuf_mr.mlir"; then + echo "$OUT/${tag}_debuf_mr.mlir" + elif [ -s "$OUT/${tag}_debuf.mlir" ] && + grep -q "linalg.generic" "$OUT/${tag}_debuf.mlir"; then + echo "$OUT/${tag}_debuf.mlir" + elif [ -s "$OUT/${tag}_linalg.mlir" ]; then + echo "$OUT/${tag}_linalg.mlir" + else + echo "$OUT/${tag}.mlir" + fi +} + +summarize_one() { + local tag=$1 + local status artifact lg tensor memref loops ifs + + if [ ! -s "$OUT/${tag}.mlir" ]; then + printf "%-42s %-20s %7s %7s %7s %7s %7s %s\n" \ + "$tag" "cgeist-fail" "-" "-" "-" "-" "-" "$OUT/${tag}.cgeist.err" + return + fi + if [ ! -s "$OUT/${tag}_linalg.mlir" ]; then + printf "%-42s %-20s %7s %7s %7s %7s %7s %s\n" \ + "$tag" "raise-fail" "-" "-" "-" "-" "-" "$OUT/${tag}.raise.err" + return + fi + + artifact=$(pick_artifact "$tag") + lg=$(count_pattern "linalg\\.generic" "$artifact") + tensor=$(count_pattern "tensor<" "$artifact") + memref=$(count_pattern "memref<" "$artifact") + loops=$(count_pattern "affine\\.for|scf\\.for|affine\\.parallel|scf\\.parallel" "$artifact") + ifs=$(count_pattern "affine\\.if|scf\\.if" "$artifact") + + if [ "$lg" -gt 0 ] && [ "$tensor" -gt 0 ]; then + status="tensor-linalg" + elif [ "$lg" -gt 0 ]; then + status="memref-linalg" + else + status="no-linalg" + fi + if [ "$loops" -gt 0 ]; then + status="${status}+loops" + fi + if [ "$ifs" -gt 0 ]; then + status="${status}+if" + fi + + printf "%-42s %-20s %7s %7s %7s %7s %7s %s\n" \ + "$tag" "$status" "$lg" "$tensor" "$memref" "$loops" "$ifs" "$artifact" +} + +run_probe() { + local fn=$1 + echo "[$fn] cgeist" + timeout 90 "$CGEIST_BIN" "$SRC" --function="$fn" \ + --resource-dir="$RESOURCE_DIR" --raise-scf-to-affine -fPIC -std=gnu11 -S \ + -o "$OUT/${fn}.mlir" 2>"$OUT/${fn}.cgeist.err" + if [ ! -s "$OUT/${fn}.mlir" ]; then + echo " cgeist FAILED" + rm -f "$OUT/${fn}.mlir" + summarize_one "$fn" >> "$SUMMARY" + return + fi + + echo "[$fn] raise" + timeout 90 "$POLYGEIST_OPT_BIN" \ + --select-func=func-name="$fn" \ + --remove-iter-args --affine-parallelize \ + --raise-affine-to-linalg-pipeline --lower-polygeist-submap \ + "$OUT/${fn}.mlir" -o "$OUT/${fn}_linalg.mlir" \ + 2>"$OUT/${fn}.raise.err" + if [ ! -s "$OUT/${fn}_linalg.mlir" ]; then + echo " raise FAILED" + rm -f "$OUT/${fn}_linalg.mlir" + summarize_one "$fn" >> "$SUMMARY" + return + fi + + echo "[$fn] debuf v2" + timeout 90 "$POLYGEIST_OPT_BIN" --linalg-debufferize \ + "$OUT/${fn}_linalg.mlir" -o "$OUT/${fn}_debuf.mlir" \ + 2>"$OUT/${fn}.debuf.err" + if [ ! -s "$OUT/${fn}_debuf.mlir" ]; then + rm -f "$OUT/${fn}_debuf.mlir" + fi + + echo "[$fn] debuf multi-root" + timeout 90 "$POLYGEIST_OPT_BIN" --linalg-debufferize=use-multi-root=true \ + "$OUT/${fn}_linalg.mlir" -o "$OUT/${fn}_debuf_mr.mlir" \ + 2>"$OUT/${fn}.debuf_mr.err" + if [ ! -s "$OUT/${fn}_debuf_mr.mlir" ]; then + rm -f "$OUT/${fn}_debuf_mr.mlir" + fi + + summarize_one "$fn" >> "$SUMMARY" +} + +PROBES=( + miniamr_stencil_calc_7 + miniamr_stencil_calc_27 + miniamr_stencil_0_coupled_sum + miniamr_stencil_0_pointwise_update + miniamr_stencil_x_directional + miniamr_stencil_y_directional + miniamr_stencil_z_directional + miniamr_stencil_7_weighted + miniamr_stencil_27_weighted + miniamr_pack_face_x + miniamr_unpack_face_x + miniamr_pack_block + miniamr_unpack_block + hpgmg_apply_op_7pt + hpgmg_apply_op_27pt + hpgmg_residual_7pt + hpgmg_jacobi_smooth_7pt + hpgmg_gsrb_smooth_7pt + hpgmg_zero_vector + hpgmg_init_vector + hpgmg_add_vectors + hpgmg_mul_vectors + hpgmg_invert_vector + hpgmg_scale_vector + hpgmg_shift_vector + hpgmg_dot + hpgmg_norm + hpgmg_mean + hpgmg_error_l2 + hpgmg_color_vector + hpgmg_random_vector + hpgmg_restriction_cell + hpgmg_restriction_face_i + hpgmg_restriction_face_j + hpgmg_restriction_face_k + hpgmg_interpolation_p0 + hpgmg_interpolation_p1 + hpgmg_interpolation_p2 + hpgmg_fv2_flux + hpgmg_fv4_flux + hpgmg_cg_update + hpgmg_bicgstab_update + hypar_first_derivative_first_order + hypar_first_derivative_second_order + hypar_first_derivative_fourth_order + hypar_interp_first_order_upwind + hypar_interp_second_order_central + hypar_interp_second_order_muscl + hypar_interp_fourth_order_central + hypar_interp_fifth_order_weno + hypar_weno_weights_js + hypar_limiter_minmod + hypar_limiter_superbee + hypar_limiter_generalized_minmod + hypar_limiter_vanleer + hypar_linear_adr_advection_const + hypar_linear_adr_advection_var + hypar_linear_adr_diffusion_g + hypar_linear_adr_diffusion_h + hypar_linear_adr_upwind_const + hypar_linear_adr_upwind_var + hypar_linear_adr_centered_flux + hypar_linear_adr_reaction + hypar_burgers_advection + hypar_burgers_upwind + hypar_euler1d_flux + hypar_euler1d_llf + hypar_euler2d_flux_x + hypar_euler2d_flux_y + hypar_euler2d_llf + swfft_redistribute_2_to_3_pack + swfft_redistribute_3_to_2_unpack + swfft_slab_pack + swfft_slab_unpack + swfft_transpose_xy + swfft_transpose_yz + exasp2_normalize_dense + exasp2_normalize_dense_split + exasp2_dense_square + exasp2_sp2_update_2x_minus_x2 + exasp2_sp2_select_square + exasp2_trace + exasp2_axpby + exasp2_spmv + exasp2_conjugate_gradient_step +) + +SUMMARY=$OUT/summary.txt +printf "%-42s %-20s %7s %7s %7s %7s %7s %s\n" \ + "kernel" "status" "linalg" "tensor" "memref" "loops" "ifs" "artifact" > "$SUMMARY" + +for fn in "${PROBES[@]}"; do + run_probe "$fn" +done + +echo "Done. Output in $OUT" +cat "$SUMMARY" diff --git a/issues/proxy_kernel_pipelines/exasp2_pipeline_easy.c b/issues/proxy_kernel_pipelines/exasp2_pipeline_easy.c new file mode 100644 index 000000000000..00741249937a --- /dev/null +++ b/issues/proxy_kernel_pipelines/exasp2_pipeline_easy.c @@ -0,0 +1,68 @@ +// ExaSP2-style dense/SP2/CG fixture designed to raise cleanly. +// +// This keeps dense normalization, square, SP2 update/selection, diagonal trace +// extraction, SpMV, AXPBY, and CG-step shapes while avoiding +// BML/MPI/container-level code. + +#ifndef EN +#define EN 16 +#endif + +void exasp2_pipeline_easy(double rho[EN][EN], const double h[EN][EN], + double x[EN][EN], double x2[EN][EN], + const double a[EN][EN], const double v[EN], + double y[EN], double cg_x[EN], double cg_r[EN], + double cg_p[EN], const double cg_Ap[EN], + double axpby_out[EN], const double axpby_a[EN], + const double axpby_b[EN], double trace_diag[EN], + double emax, double emin, double alpha, + double beta, int take_square) { + double range = emax - emin; + + // Normalize dense Hamiltonian into SP2 domain. + for (int i = 0; i < EN; i++) + for (int j = 0; j < EN; j++) + rho[i][j] = -h[i][j] / range; + + for (int i = 0; i < EN; i++) + rho[i][i] += emax / range; + + // Dense square. + for (int i = 0; i < EN; i++) + for (int j = 0; j < EN; j++) { + double sum = 0.0; + for (int k = 0; k < EN; k++) + sum += rho[i][k] * rho[k][j]; + x2[i][j] = sum; + } + + // SP2 selection/update. + for (int i = 0; i < EN; i++) + for (int j = 0; j < EN; j++) + x[i][j] = take_square ? x2[i][j] : 2.0 * rho[i][j] - x2[i][j]; + + // Trace diagonal extraction. The scalar trace reduction is intentionally + // left out because one-element scalar reductions currently need a lowering + // fix before they are safe to use in composed pipeline fixtures. + for (int i = 0; i < EN; i++) + trace_diag[i] = x[i][i]; + + // SpMV. + for (int i = 0; i < EN; i++) { + double sum = 0.0; + for (int j = 0; j < EN; j++) + sum += a[i][j] * v[j]; + y[i] = sum; + } + + // AXPBY. + for (int i = 0; i < EN; i++) + axpby_out[i] = alpha * axpby_a[i] + beta * axpby_b[i]; + + // CG step. + for (int i = 0; i < EN; i++) { + cg_x[i] += alpha * cg_p[i]; + cg_r[i] -= alpha * cg_Ap[i]; + cg_p[i] = cg_r[i] + beta * cg_p[i]; + } +} diff --git a/issues/proxy_kernel_pipelines/hpgmg_pipeline_easy.c b/issues/proxy_kernel_pipelines/hpgmg_pipeline_easy.c new file mode 100644 index 000000000000..8e91e8de30d6 --- /dev/null +++ b/issues/proxy_kernel_pipelines/hpgmg_pipeline_easy.c @@ -0,0 +1,93 @@ +// HPGMG-style mini V-cycle fixture designed to raise cleanly. +// +// This keeps representative stencil, transfer, and BLAS1 loop families while +// avoiding solver structs, MPI state, dynamically dispatched operators, and +// pointer-rich grid metadata. + +#ifndef HX +#define HX 12 +#endif +#ifndef HY +#define HY 10 +#endif +#ifndef HZ +#define HZ 8 +#endif +#ifndef HV +#define HV (HX * HY * HZ) +#endif + +void hpgmg_pipeline_easy(double x[HX + 2][HY + 2][HZ + 2], + const double rhs[HX][HY][HZ], + const double dinv[HX][HY][HZ], + const double fine[2 * HX][2 * HY][2 * HZ], + double Ax[HX][HY][HZ], double res[HX][HY][HZ], + double next[HX][HY][HZ], + double coarse[HX][HY][HZ], + double prolong[2 * HX][2 * HY][2 * HZ], + double vx[HV], double vr[HV], double vp[HV], + const double vAp[HV], double a, double b, + double weight, double alpha, double beta) { + // Apply 7-point operator. + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) { + double center = x[i + 1][j + 1][k + 1]; + double lap = 6.0 * center - x[i][j + 1][k + 1] - + x[i + 2][j + 1][k + 1] - x[i + 1][j][k + 1] - + x[i + 1][j + 2][k + 1] - x[i + 1][j + 1][k] - + x[i + 1][j + 1][k + 2]; + Ax[i][j][k] = a * center + b * lap; + } + + // Residual. + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) { + double center = x[i + 1][j + 1][k + 1]; + double lap = 6.0 * center - x[i][j + 1][k + 1] - + x[i + 2][j + 1][k + 1] - x[i + 1][j][k + 1] - + x[i + 1][j + 2][k + 1] - x[i + 1][j + 1][k] - + x[i + 1][j + 1][k + 2]; + res[i][j][k] = rhs[i][j][k] - (a * center + b * lap); + } + + // Weighted Jacobi smoother. + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) { + double center = x[i + 1][j + 1][k + 1]; + double lap = 6.0 * center - x[i][j + 1][k + 1] - + x[i + 2][j + 1][k + 1] - x[i + 1][j][k + 1] - + x[i + 1][j + 2][k + 1] - x[i + 1][j + 1][k] - + x[i + 1][j + 1][k + 2]; + double ax = a * center + b * lap; + next[i][j][k] = center + weight * dinv[i][j][k] * (rhs[i][j][k] - ax); + } + + // Cell-centered restriction. + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) { + int ii = 2 * i, jj = 2 * j, kk = 2 * k; + coarse[i][j][k] = + (fine[ii][jj][kk] + fine[ii + 1][jj][kk] + + fine[ii][jj + 1][kk] + fine[ii + 1][jj + 1][kk] + + fine[ii][jj][kk + 1] + fine[ii + 1][jj][kk + 1] + + fine[ii][jj + 1][kk + 1] + fine[ii + 1][jj + 1][kk + 1]) * + 0.125; + } + + // Simple injection/prolongation. + for (int i = 0; i < HX; i++) + for (int j = 0; j < HY; j++) + for (int k = 0; k < HZ; k++) + prolong[2 * i][2 * j][2 * k] = coarse[i][j][k]; + + // BLAS1-style CG update. + for (int i = 0; i < HV; i++) { + vx[i] += alpha * vp[i]; + vr[i] -= alpha * vAp[i]; + vp[i] = vr[i] + beta * vp[i]; + } +} diff --git a/issues/proxy_kernel_pipelines/hypar_pipeline_easy.c b/issues/proxy_kernel_pipelines/hypar_pipeline_easy.c new file mode 100644 index 000000000000..68bd7147efb6 --- /dev/null +++ b/issues/proxy_kernel_pipelines/hypar_pipeline_easy.c @@ -0,0 +1,112 @@ +// HyPar-style reconstruction/flux/update fixture designed to raise cleanly. +// +// This keeps finite-difference, WENO, limiter, upwind/centered flux, and +// timestep-update shapes while avoiding macro-generated multidimensional +// iterator state and solver structs. + +#ifndef HL +#define HL 32 +#endif +#ifndef HNV +#define HNV 4 +#endif + +#define PK_ABS(x) ((x) < 0.0 ? -(x) : (x)) +#define PK_MAX(a, b) ((a) > (b) ? (a) : (b)) +#define PK_MIN(a, b) ((a) < (b) ? (a) : (b)) + +void hypar_pipeline_easy(const double fC[HL + 5][HNV], + const double u[HL][HNV], + const double source[HL][HNV], + const double eigL[HL + 1][HNV], + const double eigR[HL + 1][HNV], + const double uL[HL + 1][HNV], + const double uR[HL + 1][HNV], + double df[HL][HNV], double w1[HL + 1][HNV], + double w2[HL + 1][HNV], double w3[HL + 1][HNV], + double fL[HL + 1][HNV], + double fR[HL + 1][HNV], + double limited[HL][HNV], + double flux[HL + 1][HNV], + double reaction[HL][HNV], + double u_next[HL][HNV], double eps, double lambda, + double dt) { + // Fourth-order derivative. + for (int i = 0; i < HL; i++) + for (int v = 0; v < HNV; v++) + df[i][v] = (fC[i][v] - 8.0 * fC[i + 1][v] + + 8.0 * fC[i + 3][v] - fC[i + 4][v]) / + 12.0; + + // Jiang-Shu WENO weights. + for (int i = 0; i < HL + 1; i++) + for (int v = 0; v < HNV; v++) { + double fm2 = fC[i][v], fm1 = fC[i + 1][v], f0 = fC[i + 2][v]; + double fp1 = fC[i + 3][v], fp2 = fC[i + 4][v]; + double b1 = (13.0 / 12.0) * (fm2 - 2.0 * fm1 + f0) * + (fm2 - 2.0 * fm1 + f0) + + 0.25 * (fm2 - 4.0 * fm1 + 3.0 * f0) * + (fm2 - 4.0 * fm1 + 3.0 * f0); + double b2 = (13.0 / 12.0) * (fm1 - 2.0 * f0 + fp1) * + (fm1 - 2.0 * f0 + fp1) + + 0.25 * (fm1 - fp1) * (fm1 - fp1); + double b3 = (13.0 / 12.0) * (f0 - 2.0 * fp1 + fp2) * + (f0 - 2.0 * fp1 + fp2) + + 0.25 * (3.0 * f0 - 4.0 * fp1 + fp2) * + (3.0 * f0 - 4.0 * fp1 + fp2); + double a1 = 0.1 / ((b1 + eps) * (b1 + eps)); + double a2 = 0.6 / ((b2 + eps) * (b2 + eps)); + double a3 = 0.3 / ((b3 + eps) * (b3 + eps)); + double sum = a1 + a2 + a3; + w1[i][v] = a1 / sum; + w2[i][v] = a2 / sum; + w3[i][v] = a3 / sum; + } + + // Fifth-order WENO left/right interface reconstructions. + for (int i = 0; i < HL + 1; i++) + for (int v = 0; v < HNV; v++) { + double q1 = (2.0 * fC[i][v] - 7.0 * fC[i + 1][v] + + 11.0 * fC[i + 2][v]) / + 6.0; + double q2 = (-fC[i + 1][v] + 5.0 * fC[i + 2][v] + + 2.0 * fC[i + 3][v]) / + 6.0; + double q3 = (2.0 * fC[i + 2][v] + 5.0 * fC[i + 3][v] - + fC[i + 4][v]) / + 6.0; + fL[i][v] = w1[i][v] * q1 + w2[i][v] * q2 + w3[i][v] * q3; + fR[i][v] = 0.5 * (fC[i + 2][v] + fC[i + 1][v]); + } + + // Minmod limiter. + for (int i = 0; i < HL; i++) + for (int v = 0; v < HNV; v++) { + double a = fC[i + 2][v] - fC[i + 1][v]; + double b = fC[i + 3][v] - fC[i + 2][v]; + limited[i][v] = + (a * b <= 0.0) ? 0.0 : ((PK_ABS(a) < PK_ABS(b)) ? a : b); + } + + // Local Lax-Friedrichs/upwind flux. + for (int i = 0; i < HL + 1; i++) + for (int v = 0; v < HNV; v++) { + if (eigL[i][v] > 0.0 && eigR[i][v] > 0.0) { + flux[i][v] = fL[i][v]; + } else if (eigL[i][v] < 0.0 && eigR[i][v] < 0.0) { + flux[i][v] = fR[i][v]; + } else { + double alpha = PK_MAX(PK_ABS(eigL[i][v]), PK_ABS(eigR[i][v])); + flux[i][v] = + 0.5 * (fL[i][v] + fR[i][v] - alpha * (uR[i][v] - uL[i][v])); + } + } + + // Reaction and conservative update. + for (int i = 0; i < HL; i++) + for (int v = 0; v < HNV; v++) { + reaction[i][v] = source[i][v] - lambda * u[i][v]; + u_next[i][v] = + u[i][v] - dt * (flux[i + 1][v] - flux[i][v]) + dt * reaction[i][v]; + } +} diff --git a/issues/proxy_kernel_pipelines/miniamr_pipeline.c b/issues/proxy_kernel_pipelines/miniamr_pipeline.c new file mode 100644 index 000000000000..9d0f7fe67c3a --- /dev/null +++ b/issues/proxy_kernel_pipelines/miniamr_pipeline.c @@ -0,0 +1,141 @@ +// miniAMR pipeline-shaped fixture built from the standalone extracted kernel +// bodies. This intentionally keeps app/MPI/block metadata out of the way while +// preserving the stencil, material update, and pack/unpack loop shapes. + +#define MX 12 +#define MY 10 +#define MZ 8 +#define MMAT 4 + +void miniamr_pipeline(double grid[MX + 2][MY + 2][MZ + 2], + double state[MX][MY][MZ], + double tmp[MX][MY][MZ], + double tmp2[MX][MY][MZ], + const double material[MMAT][MX][MY][MZ], + const double coeff[MX][MY][MZ], + const double coeff27[3][3][3], + const double x_in[MX + 2][MY][MZ], + const double y_in[MX][MY + 2][MZ], + const double z_in[MX][MY][MZ + 2], + double face_buf[MY][MZ], + double block_buf[MX * MY * MZ], + double a0, double a1, double a2) { + // Halo face pack/unpack. + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + face_buf[j][k] = grid[1][j + 1][k + 1]; + + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + grid[0][j + 1][k + 1] = face_buf[j][k]; + + // Block pack/unpack. + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + block_buf[(i * MY + j) * MZ + k] = state[i][j][k]; + + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + tmp[i][j][k] = block_buf[(i * MY + j) * MZ + k]; + + // 7-point average stencil. + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + state[i][j][k] = (grid[i][j + 1][k + 1] + + grid[i + 1][j][k + 1] + + grid[i + 1][j + 1][k] + + grid[i + 1][j + 1][k + 1] + + grid[i + 1][j + 1][k + 2] + + grid[i + 1][j + 2][k + 1] + + grid[i + 2][j + 1][k + 1]) / + 7.0; + + // 27-point average stencil. + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double sum = 0.0; + for (int di = 0; di < 3; di++) + for (int dj = 0; dj < 3; dj++) + for (int dk = 0; dk < 3; dk++) + sum += grid[i + di][j + dj][k + dk]; + tmp[i][j][k] = sum / 27.0; + } + + // Material coupled sum and pointwise update. + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double acc = tmp[i][j][k]; + for (int v = 0; v < MMAT; v++) + acc += material[v][i][j][k] * state[i][j][k]; + tmp[i][j][k] = acc; + } + + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + tmp[i][j][k] += tmp[i][j][k] * + (state[i][j][k] + tmp2[i][j][k] - + a2 * tmp[i][j][k]); + + // Directional stencils. + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double left = x_in[i][j][k]; + double center = x_in[i + 1][j][k]; + double right = x_in[i + 2][j][k]; + state[i][j][k] = center + a0 * (left - 2.0 * center + right) + + a1 * (right - left); + } + + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double left = y_in[i][j][k]; + double center = y_in[i][j + 1][k]; + double right = y_in[i][j + 2][k]; + tmp[i][j][k] = center + a0 * (left - 2.0 * center + right) + + a1 * (right - left); + } + + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double left = z_in[i][j][k]; + double center = z_in[i][j][k + 1]; + double right = z_in[i][j][k + 2]; + tmp2[i][j][k] = center + a0 * (left - 2.0 * center + right) + + a1 * (right - left); + } + + // Weighted 7-point and 27-point stencils. + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double center = grid[i + 1][j + 1][k + 1]; + double lap = grid[i][j + 1][k + 1] + + grid[i + 2][j + 1][k + 1] + + grid[i + 1][j][k + 1] + + grid[i + 1][j + 2][k + 1] + + grid[i + 1][j + 1][k] + + grid[i + 1][j + 1][k + 2] - + 6.0 * center; + state[i][j][k] = center + coeff[i][j][k] * lap; + } + + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double sum = 0.0; + for (int di = 0; di < 3; di++) + for (int dj = 0; dj < 3; dj++) + for (int dk = 0; dk < 3; dk++) + sum += coeff27[di][dj][dk] * grid[i + di][j + dj][k + dk]; + tmp[i][j][k] = sum; + } +} diff --git a/issues/proxy_kernel_pipelines/miniamr_pipeline_easy.c b/issues/proxy_kernel_pipelines/miniamr_pipeline_easy.c new file mode 100644 index 000000000000..0c8712ddec76 --- /dev/null +++ b/issues/proxy_kernel_pipelines/miniamr_pipeline_easy.c @@ -0,0 +1,137 @@ +// miniAMR-style pipeline fixture designed to raise cleanly. +// +// This is intentionally not the full miniAMR app. It keeps the pipeline +// sequence we care about for the paper story, but uses direct array operands +// and Linalg-friendly kernel shapes: +// - no block/AMR metadata +// - no double **** pointer chasing +// - no local scalar alloca accumulator for the unweighted 27-point average + +#ifndef MX +#define MX 12 +#endif +#ifndef MY +#define MY 10 +#endif +#ifndef MZ +#define MZ 8 +#endif + +void miniamr_pipeline_easy(double grid[MX + 2][MY + 2][MZ + 2], + const double x_in[MX + 2][MY][MZ], + const double y_in[MX][MY + 2][MZ], + const double z_in[MX][MY][MZ + 2], + const double coeff[MX][MY][MZ], + const double coeff27[3][3][3], + double face_buf[MY][MZ], + double block_buf[MX * MY * MZ], + double avg7[MX][MY][MZ], + double dir_x[MX][MY][MZ], + double dir_y[MX][MY][MZ], + double dir_z[MX][MY][MZ], + double weighted7[MX][MY][MZ], + double weighted27[MX][MY][MZ], + double final_out[MX][MY][MZ], + double a0, double a1) { + // Halo face pack/unpack. + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + face_buf[j][k] = grid[1][j + 1][k + 1]; + + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + grid[0][j + 1][k + 1] = face_buf[j][k]; + + // Block pack/unpack. + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + block_buf[(i * MY + j) * MZ + k] = avg7[i][j][k]; + + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + final_out[i][j][k] = block_buf[(i * MY + j) * MZ + k]; + + // 7-point average stencil. + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + avg7[i][j][k] = (grid[i][j + 1][k + 1] + + grid[i + 1][j][k + 1] + + grid[i + 1][j + 1][k] + + grid[i + 1][j + 1][k + 1] + + grid[i + 1][j + 1][k + 2] + + grid[i + 1][j + 2][k + 1] + + grid[i + 2][j + 1][k + 1]) / + 7.0; + + // Directional stencils. + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double left = x_in[i][j][k]; + double center = x_in[i + 1][j][k]; + double right = x_in[i + 2][j][k]; + dir_x[i][j][k] = center + a0 * (left - 2.0 * center + right) + + a1 * (right - left); + } + + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double left = y_in[i][j][k]; + double center = y_in[i][j + 1][k]; + double right = y_in[i][j + 2][k]; + dir_y[i][j][k] = center + a0 * (left - 2.0 * center + right) + + a1 * (right - left); + } + + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double left = z_in[i][j][k]; + double center = z_in[i][j][k + 1]; + double right = z_in[i][j][k + 2]; + dir_z[i][j][k] = center + a0 * (left - 2.0 * center + right) + + a1 * (right - left); + } + + // Weighted 7-point stencil. + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double center = grid[i + 1][j + 1][k + 1]; + double lap = grid[i][j + 1][k + 1] + + grid[i + 2][j + 1][k + 1] + + grid[i + 1][j][k + 1] + + grid[i + 1][j + 2][k + 1] + + grid[i + 1][j + 1][k] + + grid[i + 1][j + 1][k + 2] - + 6.0 * center; + weighted7[i][j][k] = center + coeff[i][j][k] * lap; + } + + // Weighted 27-point stencil. This raises better than the unweighted + // local-scalar-accumulator average because the coefficient tensor exposes + // the inner 3x3x3 loop as a clean Linalg contraction. + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) { + double sum = 0.0; + for (int di = 0; di < 3; di++) + for (int dj = 0; dj < 3; dj++) + for (int dk = 0; dk < 3; dk++) + sum += coeff27[di][dj][dk] * grid[i + di][j + dj][k + dk]; + weighted27[i][j][k] = sum; + } + + // Final pointwise combine so the fixture is a true pipeline, not just a + // bag of independent kernels. + for (int i = 0; i < MX; i++) + for (int j = 0; j < MY; j++) + for (int k = 0; k < MZ; k++) + final_out[i][j][k] = avg7[i][j][k] + dir_x[i][j][k] + + dir_y[i][j][k] + dir_z[i][j][k] + + weighted7[i][j][k] + weighted27[i][j][k]; +} diff --git a/issues/proxy_kernel_pipelines/proxy_pipeline_silicon_large.c b/issues/proxy_kernel_pipelines/proxy_pipeline_silicon_large.c new file mode 100644 index 000000000000..84d4656b086d --- /dev/null +++ b/issues/proxy_kernel_pipelines/proxy_pipeline_silicon_large.c @@ -0,0 +1,300 @@ +#define _POSIX_C_SOURCE 199309L + +#include +#include +#include + +#ifndef MX +#define MX 64 +#endif +#ifndef MY +#define MY 64 +#endif +#ifndef MZ +#define MZ 64 +#endif + +#ifndef HX +#define HX 64 +#endif +#ifndef HY +#define HY 64 +#endif +#ifndef HZ +#define HZ 64 +#endif +#ifndef HV +#define HV (HX * HY * HZ) +#endif + +#ifndef HL +#define HL 16384 +#endif +#ifndef HNV +#define HNV 5 +#endif + +#ifndef SX +#define SX 64 +#endif +#ifndef SY +#define SY 64 +#endif +#ifndef SZ +#define SZ 64 +#endif + +#ifndef EN +#define EN 512 +#endif + +#include "miniamr_pipeline_easy.c" +#include "hpgmg_pipeline_easy.c" +#include "hypar_pipeline_easy.c" +#include "swfft_pipeline_easy.c" +#include "exasp2_pipeline_easy.c" + +static double now_ms(void) { + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return (double)ts.tv_sec * 1000.0 + (double)ts.tv_nsec / 1000000.0; +} + +static int iterations(void) { + const char *env = getenv("PROXY_PIPELINE_ITERS"); + if (!env || !env[0]) + return 3; + int iters = atoi(env); + return iters > 0 ? iters : 3; +} + +static double seed_value(int a, int b, int c, int salt) { + int v = (a * 17 + b * 13 + c * 7 + salt * 19 + 11) % 101; + return ((double)v - 50.0) * 0.01; +} + +static double checksum_1d(const double *data, int n) { + double sum = 0.0; + for (int i = 0; i < n; ++i) + sum += data[i] * (1.0 + 0.0001 * (double)(i % 17)); + return sum; +} + +static double miniamr_large(int iters, double *avg_ms) { + static double grid[MX + 2][MY + 2][MZ + 2]; + static double x_in[MX + 2][MY][MZ]; + static double y_in[MX][MY + 2][MZ]; + static double z_in[MX][MY][MZ + 2]; + static double coeff[MX][MY][MZ]; + static double coeff27[3][3][3]; + static double face_buf[MY][MZ]; + static double block_buf[MX * MY * MZ]; + static double avg7[MX][MY][MZ]; + static double dir_x[MX][MY][MZ]; + static double dir_y[MX][MY][MZ]; + static double dir_z[MX][MY][MZ]; + static double weighted7[MX][MY][MZ]; + static double weighted27[MX][MY][MZ]; + static double final_out[MX][MY][MZ]; + + for (int i = 0; i < MX + 2; ++i) + for (int j = 0; j < MY + 2; ++j) + for (int k = 0; k < MZ + 2; ++k) + grid[i][j][k] = seed_value(i, j, k, 1); + for (int i = 0; i < MX + 2; ++i) + for (int j = 0; j < MY; ++j) + for (int k = 0; k < MZ; ++k) + x_in[i][j][k] = seed_value(i, j, k, 2); + for (int i = 0; i < MX; ++i) + for (int j = 0; j < MY + 2; ++j) + for (int k = 0; k < MZ; ++k) + y_in[i][j][k] = seed_value(i, j, k, 3); + for (int i = 0; i < MX; ++i) + for (int j = 0; j < MY; ++j) + for (int k = 0; k < MZ + 2; ++k) + z_in[i][j][k] = seed_value(i, j, k, 4); + for (int i = 0; i < MX; ++i) + for (int j = 0; j < MY; ++j) + for (int k = 0; k < MZ; ++k) { + coeff[i][j][k] = 0.05 + seed_value(i, j, k, 5); + avg7[i][j][k] = seed_value(i, j, k, 6); + } + for (int i = 0; i < 3; ++i) + for (int j = 0; j < 3; ++j) + for (int k = 0; k < 3; ++k) + coeff27[i][j][k] = 0.001 * (double)(1 + i + 2 * j + 3 * k); + + miniamr_pipeline_easy(grid, x_in, y_in, z_in, coeff, coeff27, face_buf, + block_buf, avg7, dir_x, dir_y, dir_z, weighted7, + weighted27, final_out, 0.125, 0.03125); + double start = now_ms(); + for (int it = 0; it < iters; ++it) + miniamr_pipeline_easy(grid, x_in, y_in, z_in, coeff, coeff27, face_buf, + block_buf, avg7, dir_x, dir_y, dir_z, weighted7, + weighted27, final_out, 0.125, 0.03125); + *avg_ms = (now_ms() - start) / (double)iters; + return checksum_1d(&final_out[0][0][0], MX * MY * MZ); +} + +static double hpgmg_large(int iters, double *avg_ms) { + static double x[HX + 2][HY + 2][HZ + 2]; + static double rhs[HX][HY][HZ]; + static double dinv[HX][HY][HZ]; + static double fine[2 * HX][2 * HY][2 * HZ]; + static double Ax[HX][HY][HZ]; + static double res[HX][HY][HZ]; + static double next[HX][HY][HZ]; + static double coarse[HX][HY][HZ]; + static double prolong[2 * HX][2 * HY][2 * HZ]; + static double vx[HV], vr[HV], vp[HV], vAp[HV]; + + for (int i = 0; i < HX + 2; ++i) + for (int j = 0; j < HY + 2; ++j) + for (int k = 0; k < HZ + 2; ++k) + x[i][j][k] = seed_value(i, j, k, 10); + for (int i = 0; i < HX; ++i) + for (int j = 0; j < HY; ++j) + for (int k = 0; k < HZ; ++k) { + rhs[i][j][k] = seed_value(i, j, k, 11); + dinv[i][j][k] = 0.5 + 0.01 * (double)((i + j + k) % 9); + } + for (int i = 0; i < 2 * HX; ++i) + for (int j = 0; j < 2 * HY; ++j) + for (int k = 0; k < 2 * HZ; ++k) + fine[i][j][k] = seed_value(i, j, k, 12); + for (int i = 0; i < HV; ++i) { + vx[i] = seed_value(i, 0, 0, 13); + vr[i] = seed_value(i, 0, 0, 14); + vp[i] = seed_value(i, 0, 0, 15); + vAp[i] = seed_value(i, 0, 0, 16); + } + + hpgmg_pipeline_easy(x, rhs, dinv, fine, Ax, res, next, coarse, prolong, vx, + vr, vp, vAp, 0.7, 0.2, 0.8, 0.05, 0.25); + double start = now_ms(); + for (int it = 0; it < iters; ++it) + hpgmg_pipeline_easy(x, rhs, dinv, fine, Ax, res, next, coarse, prolong, vx, + vr, vp, vAp, 0.7, 0.2, 0.8, 0.05, 0.25); + *avg_ms = (now_ms() - start) / (double)iters; + return checksum_1d(&next[0][0][0], HX * HY * HZ) + + checksum_1d(vx, HV) + checksum_1d(vr, HV) + checksum_1d(vp, HV); +} + +static double hypar_large(int iters, double *avg_ms) { + static double fC[HL + 5][HNV]; + static double u[HL][HNV], source[HL][HNV]; + static double eigL[HL + 1][HNV], eigR[HL + 1][HNV]; + static double uL[HL + 1][HNV], uR[HL + 1][HNV]; + static double df[HL][HNV], w1[HL + 1][HNV], w2[HL + 1][HNV]; + static double w3[HL + 1][HNV], fL[HL + 1][HNV], fR[HL + 1][HNV]; + static double limited[HL][HNV], flux[HL + 1][HNV]; + static double reaction[HL][HNV], u_next[HL][HNV]; + + for (int i = 0; i < HL + 5; ++i) + for (int v = 0; v < HNV; ++v) + fC[i][v] = seed_value(i, v, 0, 20); + for (int i = 0; i < HL; ++i) + for (int v = 0; v < HNV; ++v) { + u[i][v] = seed_value(i, v, 0, 21); + source[i][v] = seed_value(i, v, 0, 22); + } + for (int i = 0; i < HL + 1; ++i) + for (int v = 0; v < HNV; ++v) { + eigL[i][v] = seed_value(i, v, 0, 23); + eigR[i][v] = seed_value(i, v, 0, 24); + uL[i][v] = seed_value(i, v, 0, 25); + uR[i][v] = seed_value(i, v, 0, 26); + } + + hypar_pipeline_easy(fC, u, source, eigL, eigR, uL, uR, df, w1, w2, w3, fL, + fR, limited, flux, reaction, u_next, 1.0e-3, 0.2, 0.01); + double start = now_ms(); + for (int it = 0; it < iters; ++it) + hypar_pipeline_easy(fC, u, source, eigL, eigR, uL, uR, df, w1, w2, w3, fL, + fR, limited, flux, reaction, u_next, 1.0e-3, 0.2, + 0.01); + *avg_ms = (now_ms() - start) / (double)iters; + return checksum_1d(&df[0][0], HL * HNV) + + checksum_1d(&limited[0][0], HL * HNV) + + checksum_1d(&u_next[0][0], HL * HNV); +} + +static double swfft_large(int iters, double *avg_ms) { + static double pencil_in[SX * SY * SZ]; + static double cube_in[SX][SY][SZ]; + static double chunk[SX][SY][SZ], slab[SX][SY], cube_work[SX][SY][SZ]; + static double xy[SY][SX][SZ], yz[SX][SZ][SY], pencil_out[SX * SY * SZ]; + + for (int i = 0; i < SX * SY * SZ; ++i) + pencil_in[i] = seed_value(i, 0, 0, 30); + for (int x = 0; x < SX; ++x) + for (int y = 0; y < SY; ++y) + for (int z = 0; z < SZ; ++z) + cube_in[x][y][z] = seed_value(x, y, z, 31); + + swfft_pipeline_easy(pencil_in, cube_in, chunk, slab, cube_work, xy, yz, + pencil_out); + double start = now_ms(); + for (int it = 0; it < iters; ++it) + swfft_pipeline_easy(pencil_in, cube_in, chunk, slab, cube_work, xy, yz, + pencil_out); + *avg_ms = (now_ms() - start) / (double)iters; + return checksum_1d(pencil_out, SX * SY * SZ) + + checksum_1d(&xy[0][0][0], SX * SY * SZ) + + checksum_1d(&yz[0][0][0], SX * SY * SZ); +} + +static double exasp2_large(int iters, double *avg_ms) { + static double rho[EN][EN], h[EN][EN], x[EN][EN], x2[EN][EN], a[EN][EN]; + static double v[EN], y[EN], cg_x[EN], cg_r[EN], cg_p[EN], cg_Ap[EN]; + static double axpby_out[EN], axpby_a[EN], axpby_b[EN], trace_diag[EN]; + + for (int i = 0; i < EN; ++i) { + v[i] = seed_value(i, 0, 0, 40); + cg_x[i] = seed_value(i, 0, 0, 41); + cg_r[i] = seed_value(i, 0, 0, 42); + cg_p[i] = seed_value(i, 0, 0, 43); + cg_Ap[i] = seed_value(i, 0, 0, 44); + axpby_a[i] = seed_value(i, 0, 0, 45); + axpby_b[i] = seed_value(i, 0, 0, 46); + for (int j = 0; j < EN; ++j) { + h[i][j] = seed_value(i, j, 0, 47); + a[i][j] = seed_value(i, j, 0, 48); + rho[i][j] = 0.0; + x[i][j] = seed_value(i, j, 0, 49); + } + } + + exasp2_pipeline_easy(rho, h, x, x2, a, v, y, cg_x, cg_r, cg_p, cg_Ap, + axpby_out, axpby_a, axpby_b, trace_diag, 2.0, -1.0, + 0.07, 0.3, 1); + double start = now_ms(); + for (int it = 0; it < iters; ++it) + exasp2_pipeline_easy(rho, h, x, x2, a, v, y, cg_x, cg_r, cg_p, cg_Ap, + axpby_out, axpby_a, axpby_b, trace_diag, 2.0, -1.0, + 0.07, 0.3, 1); + *avg_ms = (now_ms() - start) / (double)iters; + return checksum_1d(&x[0][0], EN * EN) + checksum_1d(y, EN) + + checksum_1d(cg_x, EN) + checksum_1d(trace_diag, EN); +} + +int main(void) { + int iters = iterations(); + double t0 = 0.0, t1 = 0.0, t2 = 0.0, t3 = 0.0, t4 = 0.0; + double c0 = miniamr_large(iters, &t0); + double c1 = hpgmg_large(iters, &t1); + double c2 = hypar_large(iters, &t2); + double c3 = swfft_large(iters, &t3); + double c4 = exasp2_large(iters, &t4); + + printf("sizes miniamr=%dx%dx%d hpgmg=%dx%dx%d hypar=%dx%d swfft=%dx%dx%d exasp2=%d iters=%d\n", + MX, MY, MZ, HX, HY, HZ, HL, HNV, SX, SY, SZ, EN, iters); + printf("miniamr %.12f avg_ms %.6f\n", c0, t0); + printf("hpgmg %.12f avg_ms %.6f\n", c1, t1); + printf("hypar %.12f avg_ms %.6f\n", c2, t2); + printf("swfft %.12f avg_ms %.6f\n", c3, t3); + printf("exasp2 %.12f avg_ms %.6f\n", c4, t4); + printf("total %.12f avg_ms %.6f\n", c0 + c1 + c2 + c3 + c4, + t0 + t1 + t2 + t3 + t4); + return 0; +} diff --git a/issues/proxy_kernel_pipelines/proxy_pipeline_silicon_smoke.c b/issues/proxy_kernel_pipelines/proxy_pipeline_silicon_smoke.c new file mode 100644 index 000000000000..24ac2d348b0b --- /dev/null +++ b/issues/proxy_kernel_pipelines/proxy_pipeline_silicon_smoke.c @@ -0,0 +1,204 @@ +#include + +#include "miniamr_pipeline_easy.c" +#include "hpgmg_pipeline_easy.c" +#include "hypar_pipeline_easy.c" +#include "swfft_pipeline_easy.c" +#include "exasp2_pipeline_easy.c" + +static double seed_value(int a, int b, int c, int salt) { + int v = (a * 17 + b * 13 + c * 7 + salt * 19 + 11) % 101; + return ((double)v - 50.0) * 0.01; +} + +static double checksum_1d(const double *data, int n) { + double sum = 0.0; + for (int i = 0; i < n; ++i) + sum += data[i] * (1.0 + 0.0001 * (double)(i % 17)); + return sum; +} + +static double miniamr_smoke(void) { + static double grid[MX + 2][MY + 2][MZ + 2]; + static double x_in[MX + 2][MY][MZ]; + static double y_in[MX][MY + 2][MZ]; + static double z_in[MX][MY][MZ + 2]; + static double coeff[MX][MY][MZ]; + static double coeff27[3][3][3]; + static double face_buf[MY][MZ]; + static double block_buf[MX * MY * MZ]; + static double avg7[MX][MY][MZ]; + static double dir_x[MX][MY][MZ]; + static double dir_y[MX][MY][MZ]; + static double dir_z[MX][MY][MZ]; + static double weighted7[MX][MY][MZ]; + static double weighted27[MX][MY][MZ]; + static double final_out[MX][MY][MZ]; + + for (int i = 0; i < MX + 2; ++i) + for (int j = 0; j < MY + 2; ++j) + for (int k = 0; k < MZ + 2; ++k) + grid[i][j][k] = seed_value(i, j, k, 1); + for (int i = 0; i < MX + 2; ++i) + for (int j = 0; j < MY; ++j) + for (int k = 0; k < MZ; ++k) + x_in[i][j][k] = seed_value(i, j, k, 2); + for (int i = 0; i < MX; ++i) + for (int j = 0; j < MY + 2; ++j) + for (int k = 0; k < MZ; ++k) + y_in[i][j][k] = seed_value(i, j, k, 3); + for (int i = 0; i < MX; ++i) + for (int j = 0; j < MY; ++j) + for (int k = 0; k < MZ + 2; ++k) + z_in[i][j][k] = seed_value(i, j, k, 4); + for (int i = 0; i < MX; ++i) + for (int j = 0; j < MY; ++j) + for (int k = 0; k < MZ; ++k) { + coeff[i][j][k] = 0.05 + seed_value(i, j, k, 5); + avg7[i][j][k] = seed_value(i, j, k, 6); + } + for (int i = 0; i < 3; ++i) + for (int j = 0; j < 3; ++j) + for (int k = 0; k < 3; ++k) + coeff27[i][j][k] = 0.001 * (double)(1 + i + 2 * j + 3 * k); + + miniamr_pipeline_easy(grid, x_in, y_in, z_in, coeff, coeff27, face_buf, + block_buf, avg7, dir_x, dir_y, dir_z, weighted7, + weighted27, final_out, 0.125, 0.03125); + return checksum_1d(&final_out[0][0][0], MX * MY * MZ); +} + +static double hpgmg_smoke(void) { + static double x[HX + 2][HY + 2][HZ + 2]; + static double rhs[HX][HY][HZ]; + static double dinv[HX][HY][HZ]; + static double fine[2 * HX][2 * HY][2 * HZ]; + static double Ax[HX][HY][HZ]; + static double res[HX][HY][HZ]; + static double next[HX][HY][HZ]; + static double coarse[HX][HY][HZ]; + static double prolong[2 * HX][2 * HY][2 * HZ]; + static double vx[HV], vr[HV], vp[HV], vAp[HV]; + + for (int i = 0; i < HX + 2; ++i) + for (int j = 0; j < HY + 2; ++j) + for (int k = 0; k < HZ + 2; ++k) + x[i][j][k] = seed_value(i, j, k, 10); + for (int i = 0; i < HX; ++i) + for (int j = 0; j < HY; ++j) + for (int k = 0; k < HZ; ++k) { + rhs[i][j][k] = seed_value(i, j, k, 11); + dinv[i][j][k] = 0.5 + 0.01 * (double)((i + j + k) % 9); + } + for (int i = 0; i < 2 * HX; ++i) + for (int j = 0; j < 2 * HY; ++j) + for (int k = 0; k < 2 * HZ; ++k) + fine[i][j][k] = seed_value(i, j, k, 12); + for (int i = 0; i < HV; ++i) { + vx[i] = seed_value(i, 0, 0, 13); + vr[i] = seed_value(i, 0, 0, 14); + vp[i] = seed_value(i, 0, 0, 15); + vAp[i] = seed_value(i, 0, 0, 16); + } + + hpgmg_pipeline_easy(x, rhs, dinv, fine, Ax, res, next, coarse, prolong, vx, + vr, vp, vAp, 0.7, 0.2, 0.8, 0.05, 0.25); + return checksum_1d(&next[0][0][0], HX * HY * HZ) + + checksum_1d(vx, HV) + checksum_1d(vr, HV) + checksum_1d(vp, HV); +} + +static double hypar_smoke(void) { + static double fC[HL + 5][HNV]; + static double u[HL][HNV], source[HL][HNV]; + static double eigL[HL + 1][HNV], eigR[HL + 1][HNV]; + static double uL[HL + 1][HNV], uR[HL + 1][HNV]; + static double df[HL][HNV], w1[HL + 1][HNV], w2[HL + 1][HNV]; + static double w3[HL + 1][HNV], fL[HL + 1][HNV], fR[HL + 1][HNV]; + static double limited[HL][HNV], flux[HL + 1][HNV]; + static double reaction[HL][HNV], u_next[HL][HNV]; + + for (int i = 0; i < HL + 5; ++i) + for (int v = 0; v < HNV; ++v) + fC[i][v] = seed_value(i, v, 0, 20); + for (int i = 0; i < HL; ++i) + for (int v = 0; v < HNV; ++v) { + u[i][v] = seed_value(i, v, 0, 21); + source[i][v] = seed_value(i, v, 0, 22); + } + for (int i = 0; i < HL + 1; ++i) + for (int v = 0; v < HNV; ++v) { + eigL[i][v] = seed_value(i, v, 0, 23); + eigR[i][v] = seed_value(i, v, 0, 24); + uL[i][v] = seed_value(i, v, 0, 25); + uR[i][v] = seed_value(i, v, 0, 26); + } + + hypar_pipeline_easy(fC, u, source, eigL, eigR, uL, uR, df, w1, w2, w3, fL, + fR, limited, flux, reaction, u_next, 1.0e-3, 0.2, 0.01); + return checksum_1d(&df[0][0], HL * HNV) + + checksum_1d(&limited[0][0], HL * HNV) + + checksum_1d(&u_next[0][0], HL * HNV); +} + +static double swfft_smoke(void) { + static double pencil_in[SX * SY * SZ]; + static double cube_in[SX][SY][SZ]; + static double chunk[SX][SY][SZ], slab[SX][SY], cube_work[SX][SY][SZ]; + static double xy[SY][SX][SZ], yz[SX][SZ][SY], pencil_out[SX * SY * SZ]; + + for (int i = 0; i < SX * SY * SZ; ++i) + pencil_in[i] = seed_value(i, 0, 0, 30); + for (int x = 0; x < SX; ++x) + for (int y = 0; y < SY; ++y) + for (int z = 0; z < SZ; ++z) + cube_in[x][y][z] = seed_value(x, y, z, 31); + + swfft_pipeline_easy(pencil_in, cube_in, chunk, slab, cube_work, xy, yz, + pencil_out); + return checksum_1d(pencil_out, SX * SY * SZ) + + checksum_1d(&xy[0][0][0], SX * SY * SZ) + + checksum_1d(&yz[0][0][0], SX * SY * SZ); +} + +static double exasp2_smoke(void) { + static double rho[EN][EN], h[EN][EN], x[EN][EN], x2[EN][EN], a[EN][EN]; + static double v[EN], y[EN], cg_x[EN], cg_r[EN], cg_p[EN], cg_Ap[EN]; + static double axpby_out[EN], axpby_a[EN], axpby_b[EN], trace_diag[EN]; + + for (int i = 0; i < EN; ++i) { + v[i] = seed_value(i, 0, 0, 40); + cg_x[i] = seed_value(i, 0, 0, 41); + cg_r[i] = seed_value(i, 0, 0, 42); + cg_p[i] = seed_value(i, 0, 0, 43); + cg_Ap[i] = seed_value(i, 0, 0, 44); + axpby_a[i] = seed_value(i, 0, 0, 45); + axpby_b[i] = seed_value(i, 0, 0, 46); + for (int j = 0; j < EN; ++j) { + h[i][j] = seed_value(i, j, 0, 47); + a[i][j] = seed_value(i, j, 0, 48); + rho[i][j] = 0.0; + x[i][j] = seed_value(i, j, 0, 49); + } + } + + exasp2_pipeline_easy(rho, h, x, x2, a, v, y, cg_x, cg_r, cg_p, cg_Ap, + axpby_out, axpby_a, axpby_b, trace_diag, 2.0, -1.0, + 0.07, 0.3, 1); + return checksum_1d(&x[0][0], EN * EN) + checksum_1d(y, EN) + + checksum_1d(cg_x, EN) + checksum_1d(trace_diag, EN); +} + +int main(void) { + double c0 = miniamr_smoke(); + double c1 = hpgmg_smoke(); + double c2 = hypar_smoke(); + double c3 = swfft_smoke(); + double c4 = exasp2_smoke(); + printf("miniamr %.12f\n", c0); + printf("hpgmg %.12f\n", c1); + printf("hypar %.12f\n", c2); + printf("swfft %.12f\n", c3); + printf("exasp2 %.12f\n", c4); + printf("total %.12f\n", c0 + c1 + c2 + c3 + c4); + return 0; +} diff --git a/issues/proxy_kernel_pipelines/swfft_pipeline_easy.c b/issues/proxy_kernel_pipelines/swfft_pipeline_easy.c new file mode 100644 index 000000000000..9d1568a73a4a --- /dev/null +++ b/issues/proxy_kernel_pipelines/swfft_pipeline_easy.c @@ -0,0 +1,53 @@ +// SWFFT-style local redistribution and transpose fixture designed to raise +// cleanly. It models local pack/unpack and slab/transpose movement without MPI. + +#ifndef SX +#define SX 8 +#endif +#ifndef SY +#define SY 8 +#endif +#ifndef SZ +#define SZ 8 +#endif + +void swfft_pipeline_easy(const double pencil_in[SX * SY * SZ], + const double cube_in[SX][SY][SZ], + double chunk[SX][SY][SZ], + double slab[SX][SY], + double cube_work[SX][SY][SZ], + double xy[SY][SX][SZ], + double yz[SX][SZ][SY], + double pencil_out[SX * SY * SZ]) { + // Redistribute 2D pencil to 3D chunk. + for (int x = 0; x < SX; x++) + for (int y = 0; y < SY; y++) + for (int z = 0; z < SZ; z++) + chunk[x][y][z] = pencil_in[(x * SY + y) * SZ + z]; + + // Copy one local slab at a fixed z-plane. + for (int x = 0; x < SX; x++) + for (int y = 0; y < SY; y++) + slab[x][y] = chunk[x][y][3]; + + for (int x = 0; x < SX; x++) + for (int y = 0; y < SY; y++) + cube_work[x][y][3] = slab[x][y]; + + // Local transposes. + for (int x = 0; x < SX; x++) + for (int y = 0; y < SY; y++) + for (int z = 0; z < SZ; z++) + xy[y][x][z] = cube_in[x][y][z]; + + for (int x = 0; x < SX; x++) + for (int y = 0; y < SY; y++) + for (int z = 0; z < SZ; z++) + yz[x][z][y] = cube_in[x][y][z]; + + // Redistribute 3D chunk back to 2D pencil. + for (int x = 0; x < SX; x++) + for (int y = 0; y < SY; y++) + for (int z = 0; z < SZ; z++) + pencil_out[(x * SY + y) * SZ + z] = chunk[x][y][z]; +} diff --git a/issues/ptr_ge_if_min.c b/issues/ptr_ge_if_min.c new file mode 100644 index 000000000000..5e5555d06f00 --- /dev/null +++ b/issues/ptr_ge_if_min.c @@ -0,0 +1,8 @@ +void ptr_ge_if_min(float *buffer, int n) { + float *buf2 = buffer; + float *d = &buf2[n - 2]; + if (d >= buf2) { + d[0] = 0.0f; + } +} + diff --git a/issues/ptr_ge_min.c b/issues/ptr_ge_min.c new file mode 100644 index 000000000000..f0cbf2aac715 --- /dev/null +++ b/issues/ptr_ge_min.c @@ -0,0 +1,8 @@ +void ptr_ge_min(float *buffer, int n) { + float *buf2 = buffer; + float *d = &buf2[n - 2]; + while (d >= buf2) { + d[0] = 0.0f; + d -= 2; + } +} diff --git a/issues/ptr_subassign_min.c b/issues/ptr_subassign_min.c new file mode 100644 index 000000000000..6edc38d7218f --- /dev/null +++ b/issues/ptr_subassign_min.c @@ -0,0 +1,6 @@ +void ptr_subassign_min(float *buffer, int n) { + float *buf2 = buffer; + float *d = &buf2[n - 2]; + d -= 2; + d[0] = 0.0f; +} diff --git a/issues/recursive_function_pointer_record_min.c b/issues/recursive_function_pointer_record_min.c new file mode 100644 index 000000000000..a8d9c7f5bd49 --- /dev/null +++ b/issues/recursive_function_pointer_record_min.c @@ -0,0 +1,15 @@ +struct recursive_function_pointer_record_min; + +typedef void (*recursive_function_pointer_record_min_callback)( + struct recursive_function_pointer_record_min *); + +struct recursive_function_pointer_record_min { + recursive_function_pointer_record_min_callback callback; +}; + +void recursive_function_pointer_record_min_call( + struct recursive_function_pointer_record_min *value) { + if (value->callback) { + value->callback(value); + } +} diff --git a/issues/stb_vorbis_packet_present_probe.c b/issues/stb_vorbis_packet_present_probe.c new file mode 100644 index 000000000000..5fb481898d4c --- /dev/null +++ b/issues/stb_vorbis_packet_present_probe.c @@ -0,0 +1,343 @@ +#include +#include + +typedef uint8_t uint8; + +#define TRUE 1 +#define PAGEFLAG_continued_packet 1 + +enum { + VORBIS_need_more_data = 1, + VORBIS_invalid_stream = 2, +}; + +static const uint8 ogg_page_header[4] = { 'O', 'g', 'g', 'S' }; + +struct stb_vorbis_probe { + int next_seg; + int segment_count; + int previous_length; + uint8 segments[255]; + uint8 * stream; + uint8 * stream_end; +}; + +static int error_probe(struct stb_vorbis_probe * f, int e) { + (void)f; + return -e; +} + +int isolate_packet_present_first_segment(struct stb_vorbis_probe * f) { + int s = f->next_seg, first = TRUE; + uint8 * p = f->stream; + + if (s != -1) { + for (; s < f->segment_count; ++s) { + p += f->segments[s]; + if (f->segments[s] < 255) { + break; + } + } + if (s == f->segment_count) { + s = -1; + } + if (p > f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + first = 0; + } + + return s + first; +} + +int isolate_packet_present_cross_page(struct stb_vorbis_probe * f) { + int s = -1, first = TRUE; + uint8 * p = f->stream; + + for (; s == -1;) { + uint8 * q; + int n; + + if (p + 26 >= f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + if (memcmp(p, ogg_page_header, 4)) { + return error_probe(f, VORBIS_invalid_stream); + } + if (p[4] != 0) { + return error_probe(f, VORBIS_invalid_stream); + } + if (first) { + if (f->previous_length) { + if ((p[5] & PAGEFLAG_continued_packet)) { + return error_probe(f, VORBIS_invalid_stream); + } + } + } else { + if (!(p[5] & PAGEFLAG_continued_packet)) { + return error_probe(f, VORBIS_invalid_stream); + } + } + n = p[26]; + q = p + 27; + p = q + n; + if (p > f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + for (s = 0; s < n; ++s) { + p += q[s]; + if (q[s] < 255) { + break; + } + } + if (s == n) { + s = -1; + } + if (p > f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + first = 0; + } + + return TRUE; +} + +int isolate_packet_present_cross_page_core(struct stb_vorbis_probe * f) { + int s = -1; + uint8 * p = f->stream; + + for (; s == -1;) { + uint8 * q; + int n; + + if (p + 26 >= f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + n = p[26]; + q = p + 27; + p = q + n; + if (p > f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + for (s = 0; s < n; ++s) { + p += q[s]; + if (q[s] < 255) { + break; + } + } + if (s == n) { + s = -1; + } + if (p > f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + } + + return TRUE; +} + +int isolate_packet_present_cross_page_no_memcmp(struct stb_vorbis_probe * f) { + int s = -1, first = TRUE; + uint8 * p = f->stream; + + for (; s == -1;) { + uint8 * q; + int n; + + if (p + 26 >= f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + if (p[0] != 'O' || p[1] != 'g' || p[2] != 'g' || p[3] != 'S') { + return error_probe(f, VORBIS_invalid_stream); + } + if (p[4] != 0) { + return error_probe(f, VORBIS_invalid_stream); + } + if (first) { + if (f->previous_length) { + if ((p[5] & PAGEFLAG_continued_packet)) { + return error_probe(f, VORBIS_invalid_stream); + } + } + } else { + if (!(p[5] & PAGEFLAG_continued_packet)) { + return error_probe(f, VORBIS_invalid_stream); + } + } + n = p[26]; + q = p + 27; + p = q + n; + if (p > f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + for (s = 0; s < n; ++s) { + p += q[s]; + if (q[s] < 255) { + break; + } + } + if (s == n) { + s = -1; + } + if (p > f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + first = 0; + } + + return TRUE; +} + +int isolate_packet_present_cross_page_flags_only(struct stb_vorbis_probe * f) { + int s = -1, first = TRUE; + uint8 * p = f->stream; + + for (; s == -1;) { + uint8 * q; + int n; + + if (p + 26 >= f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + if (first) { + if (f->previous_length) { + if ((p[5] & PAGEFLAG_continued_packet)) { + return error_probe(f, VORBIS_invalid_stream); + } + } + } else { + if (!(p[5] & PAGEFLAG_continued_packet)) { + return error_probe(f, VORBIS_invalid_stream); + } + } + n = p[26]; + q = p + 27; + p = q + n; + if (p > f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + for (s = 0; s < n; ++s) { + p += q[s]; + if (q[s] < 255) { + break; + } + } + if (s == n) { + s = -1; + } + if (p > f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + first = 0; + } + + return TRUE; +} + +int isolate_packet_present_cross_page_no_flags(struct stb_vorbis_probe * f) { + int s = -1; + uint8 * p = f->stream; + + for (; s == -1;) { + uint8 * q; + int n; + + if (p + 26 >= f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + if (memcmp(p, ogg_page_header, 4)) { + return error_probe(f, VORBIS_invalid_stream); + } + if (p[4] != 0) { + return error_probe(f, VORBIS_invalid_stream); + } + n = p[26]; + q = p + 27; + p = q + n; + if (p > f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + for (s = 0; s < n; ++s) { + p += q[s]; + if (q[s] < 255) { + break; + } + } + if (s == n) { + s = -1; + } + if (p > f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + } + + return TRUE; +} + +int isolate_packet_present_full(struct stb_vorbis_probe * f) { + int s = f->next_seg, first = TRUE; + uint8 * p = f->stream; + + if (s != -1) { + for (; s < f->segment_count; ++s) { + p += f->segments[s]; + if (f->segments[s] < 255) { + break; + } + } + if (s == f->segment_count) { + s = -1; + } + if (p > f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + first = 0; + } + + for (; s == -1;) { + uint8 * q; + int n; + + if (p + 26 >= f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + if (memcmp(p, ogg_page_header, 4)) { + return error_probe(f, VORBIS_invalid_stream); + } + if (p[4] != 0) { + return error_probe(f, VORBIS_invalid_stream); + } + if (first) { + if (f->previous_length) { + if ((p[5] & PAGEFLAG_continued_packet)) { + return error_probe(f, VORBIS_invalid_stream); + } + } + } else { + if (!(p[5] & PAGEFLAG_continued_packet)) { + return error_probe(f, VORBIS_invalid_stream); + } + } + n = p[26]; + q = p + 27; + p = q + n; + if (p > f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + for (s = 0; s < n; ++s) { + p += q[s]; + if (q[s] < 255) { + break; + } + } + if (s == n) { + s = -1; + } + if (p > f->stream_end) { + return error_probe(f, VORBIS_need_more_data); + } + first = 0; + } + + return TRUE; +} diff --git a/issues/stb_vorbis_sentinel_loop_probe.c b/issues/stb_vorbis_sentinel_loop_probe.c new file mode 100644 index 000000000000..8246ca83e39d --- /dev/null +++ b/issues/stb_vorbis_sentinel_loop_probe.c @@ -0,0 +1,64 @@ +#include + +typedef uint8_t uint8; + +int isolate_sentinel_scalar_loop(int n, const uint8 * q) { + int s = -1; + int total = 0; + + for (; s == -1;) { + for (s = 0; s < n; ++s) { + total += q[s]; + if (q[s] < 255) { + break; + } + } + if (s == n) { + s = -1; + } + } + + return total + s; +} + +int isolate_sentinel_pointer_loop(uint8 * p, const uint8 * q, int n) { + int s = -1; + + for (; s == -1;) { + for (s = 0; s < n; ++s) { + p += q[s]; + if (q[s] < 255) { + break; + } + } + if (s == n) { + s = -1; + } + } + + return (int)(p - q) + s; +} + +int isolate_sentinel_pointer_checked_loop(uint8 * p, uint8 * end, const uint8 * q, int n) { + int s = -1; + + for (; s == -1;) { + if (p + 26 >= end) { + return -1; + } + for (s = 0; s < n; ++s) { + p += q[s]; + if (q[s] < 255) { + break; + } + } + if (s == n) { + s = -1; + } + if (p > end) { + return -2; + } + } + + return (int)(p - q) + s; +} diff --git a/issues/std_mutex_global_min.cpp b/issues/std_mutex_global_min.cpp new file mode 100644 index 000000000000..6fbcb6c82304 --- /dev/null +++ b/issues/std_mutex_global_min.cpp @@ -0,0 +1,8 @@ +#include + +std::mutex global_mutex; + +void std_mutex_global_lock_min() { global_mutex.lock(); } + +void std_mutex_global_unlock_min() { global_mutex.unlock(); } + diff --git a/issues/std_to_string_return_min.cpp b/issues/std_to_string_return_min.cpp new file mode 100644 index 000000000000..443d17c8e3eb --- /dev/null +++ b/issues/std_to_string_return_min.cpp @@ -0,0 +1,6 @@ +#include + +std::string std_to_string_return_min(float value) { + return std::to_string(value); +} + diff --git a/issues/std_vector_string_global_min.cpp b/issues/std_vector_string_global_min.cpp new file mode 100644 index 000000000000..17dddc15d270 --- /dev/null +++ b/issues/std_vector_string_global_min.cpp @@ -0,0 +1,9 @@ +#include +#include + +static std::vector styles = {"low", "mid", "high"}; + +const char *std_vector_string_global_min(int index) { + return styles[index].c_str(); +} + diff --git a/issues/string_conditional_value_min.cpp b/issues/string_conditional_value_min.cpp new file mode 100644 index 000000000000..ebe552a67546 --- /dev/null +++ b/issues/string_conditional_value_min.cpp @@ -0,0 +1,8 @@ +#include + +std::string string_conditional_value_min(bool choose_first, + const std::string &first, + const std::string &second) { + return choose_first ? first : second; +} + diff --git a/issues/tensor_product_3d_cutensornet_harness.c b/issues/tensor_product_3d_cutensornet_harness.c new file mode 100644 index 000000000000..3fea83719987 --- /dev/null +++ b/issues/tensor_product_3d_cutensornet_harness.c @@ -0,0 +1,41 @@ +#include +#include +#include + +#define KP 4 +#define KQ 5 + +// Bare-pointer memref ABI for three memref arguments. +extern void tensor_product_3d( + float *, float *, int64_t, int64_t, int64_t, + float *, float *, int64_t, int64_t, int64_t, + float *, float *, int64_t, int64_t, int64_t); + +int main(void) { + float psi[KQ * KP], u[KP * KP * KP], out[KQ * KQ * KQ]; + for (int i = 0; i < KQ * KP; ++i) + psi[i] = (float)(i - 7) / 13.0f; + for (int i = 0; i < KP * KP * KP; ++i) + u[i] = (float)(i % 11 - 5) / 9.0f; + + tensor_product_3d( + psi, psi, 0, KQ * KP, 1, + u, u, 0, KP * KP * KP, 1, + out, out, 0, KQ * KQ * KQ, 1); + + float maxErr = 0.0f; + for (int a = 0; a < KQ; ++a) + for (int b = 0; b < KQ; ++b) + for (int c = 0; c < KQ; ++c) { + float ref = 0.0f; + for (int i = 0; i < KP; ++i) + for (int j = 0; j < KP; ++j) + for (int k = 0; k < KP; ++k) + ref += psi[a * KP + i] * psi[b * KP + j] * + psi[c * KP + k] * u[(i * KP + j) * KP + k]; + float err = fabsf(out[(a * KQ + b) * KQ + c] - ref); + if (err > maxErr) maxErr = err; + } + printf("cutensornet tensor product max_err=%g\n", maxErr); + return maxErr <= 2.0e-5f ? 0 : 1; +} diff --git a/issues/tensor_product_3d_f64.c b/issues/tensor_product_3d_f64.c new file mode 100644 index 000000000000..6acdbb76af37 --- /dev/null +++ b/issues/tensor_product_3d_f64.c @@ -0,0 +1,31 @@ +/* Float64 separable 3D tensor product. + * + * out[qi,qj,qk] = sum(i,j,k) + * psi[qi,i] * psi[qj,j] * psi[qk,k] * u[i,j,k] + * + * This intentionally uses the source-level scalar accumulator form that + * exercises nested affine iter_args and remove-iter-args. + */ +#define KP 4 +#define KQ 5 + +void tensor_product_3d_f64(const double psi[KQ * KP], + const double u[KP * KP * KP], + double out[KQ * KQ * KQ]) { + for (long qi = 0; qi < KQ; ++qi) { + for (long qj = 0; qj < KQ; ++qj) { + for (long qk = 0; qk < KQ; ++qk) { + double acc = 0.0; + for (long i = 0; i < KP; ++i) { + for (long j = 0; j < KP; ++j) { + for (long k = 0; k < KP; ++k) { + acc += psi[qi * KP + i] * psi[qj * KP + j] * + psi[qk * KP + k] * u[(i * KP + j) * KP + k]; + } + } + } + out[(qi * KQ + qj) * KQ + qk] = acc; + } + } + } +} diff --git a/issues/tensor_product_3d_f64_e2e_harness.c b/issues/tensor_product_3d_f64_e2e_harness.c new file mode 100644 index 000000000000..0075b05e8fce --- /dev/null +++ b/issues/tensor_product_3d_f64_e2e_harness.c @@ -0,0 +1,35 @@ +#include +#include +#include + +#define KP 4 +#define KQ 5 + +extern void tensor_product_3d_f64( + const double psi[KQ * KP], const double u[KP * KP * KP], + double out[KQ * KQ * KQ]); + +int main(void) { + double psi[KQ * KP], u[KP * KP * KP], out[KQ * KQ * KQ]; + for (int i = 0; i < KQ * KP; ++i) psi[i] = (double)(i - 7) / 13.0; + for (int i = 0; i < KP * KP * KP; ++i) + u[i] = (double)(i % 11 - 5) / 9.0; + + tensor_product_3d_f64(psi, u, out); + + double maxError = 0.0; + for (int a = 0; a < KQ; ++a) + for (int b = 0; b < KQ; ++b) + for (int c = 0; c < KQ; ++c) { + double reference = 0.0; + for (int i = 0; i < KP; ++i) + for (int j = 0; j < KP; ++j) + for (int k = 0; k < KP; ++k) + reference += psi[a * KP + i] * psi[b * KP + j] * + psi[c * KP + k] * u[(i * KP + j) * KP + k]; + double error = fabs(out[(a * KQ + b) * KQ + c] - reference); + if (error > maxError) maxError = error; + } + printf("cutensornet f64 e2e max_err=%.17g\n", maxError); + return maxError <= 1.0e-12 ? 0 : 1; +} diff --git a/issues/tensor_product_3d_f64_harness.c b/issues/tensor_product_3d_f64_harness.c new file mode 100644 index 000000000000..4773ac21983f --- /dev/null +++ b/issues/tensor_product_3d_f64_harness.c @@ -0,0 +1,34 @@ +#include +#include +#include + +#define KP 4 +#define KQ 5 + +void polygeist_cutensornet_tensor_product_3d_f64( + int32_t kq, int32_t kp, const double *psi, const double *u, double *out); + +int main(void) { + double psi[KQ * KP], u[KP * KP * KP], out[KQ * KQ * KQ]; + for (int i = 0; i < KQ * KP; ++i) psi[i] = (double)(i - 7) / 13.0; + for (int i = 0; i < KP * KP * KP; ++i) + u[i] = (double)(i % 11 - 5) / 9.0; + + polygeist_cutensornet_tensor_product_3d_f64(KQ, KP, psi, u, out); + + double maxError = 0.0; + for (int a = 0; a < KQ; ++a) + for (int b = 0; b < KQ; ++b) + for (int c = 0; c < KQ; ++c) { + double reference = 0.0; + for (int i = 0; i < KP; ++i) + for (int j = 0; j < KP; ++j) + for (int k = 0; k < KP; ++k) + reference += psi[a * KP + i] * psi[b * KP + j] * + psi[c * KP + k] * u[(i * KP + j) * KP + k]; + double error = fabs(out[(a * KQ + b) * KQ + c] - reference); + if (error > maxError) maxError = error; + } + printf("cutensornet f64 tensor product max_err=%.17g\n", maxError); + return maxError <= 1.0e-12 ? 0 : 1; +} diff --git a/issues/tensor_product_3d_hoisted_alloca.mlir b/issues/tensor_product_3d_hoisted_alloca.mlir new file mode 100644 index 000000000000..817ecfaa9cb8 --- /dev/null +++ b/issues/tensor_product_3d_hoisted_alloca.mlir @@ -0,0 +1,41 @@ +module { + func.func @tensor_product_3d_hoisted_alloca(%psi: memref, + %u: memref, + %out: memref) { + %cst = arith.constant 0.000000e+00 : f32 + affine.for %qi = 0 to 5 { + affine.for %qj = 0 to 5 { + affine.for %qk = 0 to 5 { + affine.store %cst, %out[%qk + %qi * 25 + %qj * 5] : memref + %slot_j = memref.alloca() : memref + %slot_k = memref.alloca() : memref + affine.for %i = 0 to 4 { + %out_old = affine.load %out[%qk + %qi * 25 + %qj * 5] : memref + %psi_i = affine.load %psi[%i + %qi * 4] : memref + affine.store %out_old, %slot_j[] : memref + affine.for %j = 0 to 4 { + %acc_j = affine.load %slot_j[] : memref + %psi_j = affine.load %psi[%j + %qj * 4] : memref + %partial_ij = arith.mulf %psi_i, %psi_j : f32 + affine.store %acc_j, %slot_k[] : memref + affine.for %k = 0 to 4 { + %acc_k = affine.load %slot_k[] : memref + %psi_k = affine.load %psi[%k + %qk * 4] : memref + %u_ijk = affine.load %u[%k + %i * 16 + %j * 4] : memref + %term0 = arith.mulf %partial_ij, %psi_k : f32 + %term1 = arith.mulf %term0, %u_ijk : f32 + %next = arith.addf %acc_k, %term1 : f32 + affine.store %next, %slot_k[] : memref + } + %after_k = affine.load %slot_k[] : memref + affine.store %after_k, %slot_j[] : memref + } + %after_j = affine.load %slot_j[] : memref + affine.store %after_j, %out[%qk + %qi * 25 + %qj * 5] : memref + } + } + } + } + return + } +} diff --git a/issues/user_variadic_duplicate_symbol_min.c b/issues/user_variadic_duplicate_symbol_min.c new file mode 100644 index 000000000000..4f792d6e0ea7 --- /dev/null +++ b/issues/user_variadic_duplicate_symbol_min.c @@ -0,0 +1,6 @@ +void user_variadic_duplicate_symbol_min_sink(const char *fmt, ...) { +} + +void user_variadic_duplicate_symbol_min(int x) { + user_variadic_duplicate_symbol_min_sink("%d", x); +} diff --git a/issues/whisper_inverse_mdct_min.c b/issues/whisper_inverse_mdct_min.c new file mode 100644 index 000000000000..e6c5d8ce8edc --- /dev/null +++ b/issues/whisper_inverse_mdct_min.c @@ -0,0 +1,20 @@ +typedef struct { + char *alloc_buffer; +} stb_vorbis_alloc; + +typedef struct { + stb_vorbis_alloc alloc; + int temp_offset; +} vorb; + +void *setup_temp_malloc(vorb *f, int sz); + +void inverse_mdct_min(float *buffer, int n, vorb *f, int blocktype) { + int n2 = n >> 1; + float *buf2 = (float *)(f->alloc.alloc_buffer + ? setup_temp_malloc(f, n2 * sizeof(*buf2)) + : __builtin_alloca(n2 * sizeof(*buf2))); + (void)buffer; + (void)blocktype; + (void)buf2; +} diff --git a/issues/whisper_inverse_mdct_ptrloop.c b/issues/whisper_inverse_mdct_ptrloop.c new file mode 100644 index 000000000000..b237f48bb088 --- /dev/null +++ b/issues/whisper_inverse_mdct_ptrloop.c @@ -0,0 +1,24 @@ +typedef struct { + char *alloc_buffer; +} stb_vorbis_alloc; + +typedef struct { + stb_vorbis_alloc alloc; + int temp_offset; +} vorb; + +void *setup_temp_malloc(vorb *f, int sz); + +void inverse_mdct_ptrloop(float *buffer, int n, vorb *f, int blocktype) { + int n2 = n >> 1; + float *buf2 = (float *)(f->alloc.alloc_buffer + ? setup_temp_malloc(f, n2 * sizeof(*buf2)) + : __builtin_alloca(n2 * sizeof(*buf2))); + float *d = &buf2[n2 - 2]; + (void)buffer; + (void)blocktype; + while (d >= buf2) { + d[0] = 0.0f; + d -= 2; + } +} diff --git a/issues/whisper_ops_perf_harness.c b/issues/whisper_ops_perf_harness.c new file mode 100644 index 000000000000..7988fadc0144 --- /dev/null +++ b/issues/whisper_ops_perf_harness.c @@ -0,0 +1,108 @@ +#include +#include +#include +#include + +#ifndef N +#define N 128 +#endif + +#ifndef CONV_IN +#define CONV_IN 160 +#endif + +#ifndef CONV_K +#define CONV_K 3 +#endif + +#ifndef REPEAT +#define REPEAT 50 +#endif + +#ifndef WARMUP +#define WARMUP 10 +#endif + +#define CONV_OUT (CONV_IN - CONV_K + 1) + +void kernel_whisper_vec_dot(float out[1], float x[N], float y[N]); +float kernel_whisper_vec_softmax(float out[N], float x[N], float max_val); +void kernel_whisper_softmax_full(float out[N], float x[N]); +void kernel_whisper_rms_norm(float out[N], float x[N], float eps); +void kernel_whisper_gelu(float out[N], float x[N]); +void kernel_whisper_conv1d(int n, int k, float *out, const float *x, + const float *filter); + +static double now_ms(void) { + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return (double)ts.tv_sec * 1000.0 + (double)ts.tv_nsec / 1.0e6; +} + +static void init_vec(float *x, int n, int seed) { + for (int i = 0; i < n; ++i) { + float a = (float)(((i + seed) * 17) % 97) * 0.03125f; + float b = (float)(((i + seed) * 7) % 19) * 0.015625f; + x[i] = a - b - 1.5f; + } +} + +static double checksum(const float *x, int n) { + double s = 0.0; + for (int i = 0; i < n; ++i) + s += (double)x[i]; + return s; +} + +int main(void) { + static float x[N > CONV_IN ? N : CONV_IN]; + static float y[N > CONV_IN ? N : CONV_IN]; + static float out[N > CONV_OUT ? N : CONV_OUT]; + static float filter[CONV_K]; + float scalar = 0.0f; + float ret = 0.0f; + + init_vec(x, N > CONV_IN ? N : CONV_IN, 1); + init_vec(y, N > CONV_IN ? N : CONV_IN, 11); + init_vec(filter, CONV_K, 23); + + for (int iter = 0; iter < WARMUP + REPEAT; ++iter) { + double t0 = now_ms(); +#if BENCH_KIND == 1 + kernel_whisper_vec_dot(&scalar, x, y); +#elif BENCH_KIND == 2 + ret = kernel_whisper_vec_softmax(out, x, 1.0f); +#elif BENCH_KIND == 3 + kernel_whisper_softmax_full(out, x); +#elif BENCH_KIND == 4 + kernel_whisper_rms_norm(out, x, 1.0e-5f); +#elif BENCH_KIND == 5 + kernel_whisper_gelu(out, x); +#elif BENCH_KIND == 6 + kernel_whisper_conv1d(CONV_IN, CONV_K, out, x, filter); +#else +#error "Define BENCH_KIND as 1..6" +#endif + double t1 = now_ms(); + if (iter >= WARMUP) { + printf("WHISPER_TIMING\tkind=%d\titer=%d\thost_ms=%.6f\n", + BENCH_KIND, iter - WARMUP, t1 - t0); + } + } + +#if BENCH_KIND == 1 + printf("WHISPER_OUTPUT\tkind=%d\tscalar=%.9f\n", BENCH_KIND, (double)scalar); +#elif BENCH_KIND == 2 + printf("WHISPER_OUTPUT\tkind=%d\tchecksum=%.9f\tret=%.9f\tfirst=%.9f\tlast=%.9f\n", + BENCH_KIND, checksum(out, N), (double)ret, (double)out[0], + (double)out[N - 1]); +#elif BENCH_KIND == 6 + printf("WHISPER_OUTPUT\tkind=%d\tchecksum=%.9f\tfirst=%.9f\tlast=%.9f\n", + BENCH_KIND, checksum(out, CONV_OUT), (double)out[0], + (double)out[CONV_OUT - 1]); +#else + printf("WHISPER_OUTPUT\tkind=%d\tchecksum=%.9f\tfirst=%.9f\tlast=%.9f\n", + BENCH_KIND, checksum(out, N), (double)out[0], (double)out[N - 1]); +#endif + return 0; +} diff --git a/issues/whisper_softmax_perf_harness.c b/issues/whisper_softmax_perf_harness.c new file mode 100644 index 000000000000..0ae1483a3438 --- /dev/null +++ b/issues/whisper_softmax_perf_harness.c @@ -0,0 +1,59 @@ +#include +#include +#include +#include + +#ifndef N +#define N 128 +#endif + +#ifndef REPEAT +#define REPEAT 50 +#endif + +#ifndef WARMUP +#define WARMUP 10 +#endif + +void kernel_whisper_softmax_full(float out[N], float x[N]); + +static double now_ms(void) { + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return (double)ts.tv_sec * 1000.0 + (double)ts.tv_nsec / 1.0e6; +} + +static void init_input(float x[N]) { + for (int i = 0; i < N; ++i) { + float a = (float)((i * 17) % 97) * 0.03125f; + float b = (float)((i * 7) % 19) * 0.015625f; + x[i] = a - b - 1.5f; + } +} + +static double checksum(const float out[N]) { + double s = 0.0; + for (int i = 0; i < N; ++i) + s += (double)out[i]; + return s; +} + +int main(void) { + static float x[N]; + static float out[N]; + init_input(x); + + for (int iter = 0; iter < WARMUP + REPEAT; ++iter) { + double t0 = now_ms(); + kernel_whisper_softmax_full(out, x); + double t1 = now_ms(); + if (iter >= WARMUP) { + printf("WHISPER_TIMING\tbench=softmax_full\tN=%d\titer=%d\thost_ms=%.6f\n", + N, iter - WARMUP, t1 - t0); + } + } + + printf("WHISPER_OUTPUT\tbench=softmax_full\tN=%d\tchecksum=%.9f\tfirst=%.9f\tlast=%.9f\n", + N, checksum(out), (double)out[0], (double)out[N - 1]); + return 0; +} diff --git a/lib/polygeist/CMakeLists.txt b/lib/polygeist/CMakeLists.txt index 88aea0de4dd5..b2a410a77872 100644 --- a/lib/polygeist/CMakeLists.txt +++ b/lib/polygeist/CMakeLists.txt @@ -19,3 +19,4 @@ MLIRSCFTransforms ) add_subdirectory(Passes) add_subdirectory(ExecutionEngine) +add_subdirectory(Kernel) diff --git a/lib/polygeist/Kernel/CMakeLists.txt b/lib/polygeist/Kernel/CMakeLists.txt new file mode 100644 index 000000000000..371724504a5e --- /dev/null +++ b/lib/polygeist/Kernel/CMakeLists.txt @@ -0,0 +1,19 @@ +add_mlir_dialect_library(MLIRPolygeistKernel + KernelDialect.cpp + KernelOps.cpp + + ADDITIONAL_HEADER_DIRS + ${PROJECT_SOURCE_DIR}/include/polygeist/Kernel + + DEPENDS + MLIRKernelOpsIncGen + + LINK_LIBS PUBLIC + MLIRIR + MLIRMemRefDialect + MLIRArithDialect + MLIRFuncDialect + MLIRControlFlowInterfaces + MLIRSideEffectInterfaces + MLIRSupport +) \ No newline at end of file diff --git a/lib/polygeist/Kernel/KernelDialect.cpp b/lib/polygeist/Kernel/KernelDialect.cpp new file mode 100644 index 000000000000..0e239ff2565c --- /dev/null +++ b/lib/polygeist/Kernel/KernelDialect.cpp @@ -0,0 +1,33 @@ +//===- KernelDialect.cpp - Kernel dialect implementation --------*- C++ -*-===// +// +// This file is licensed under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "polygeist/Kernel/KernelDialect.h" +#include "polygeist/Kernel/KernelOps.h" + +#include "mlir/IR/Builders.h" +#include "mlir/IR/DialectImplementation.h" +#include "mlir/IR/OpImplementation.h" +#include "mlir/Transforms/InliningUtils.h" +#include "mlir/Dialect/MemRef/IR/MemRef.h" + +using namespace mlir; +using namespace mlir::polygeist; +using namespace mlir::polygeist::kernel; + +#include "polygeist/Kernel/KernelOpsDialect.cpp.inc" + +//===----------------------------------------------------------------------===// +// Kernel dialect initialization +//===----------------------------------------------------------------------===// + +void KernelDialect::initialize() { + addOperations< +#define GET_OP_LIST +#include "polygeist/Kernel/KernelOps.cpp.inc" + >(); +} \ No newline at end of file diff --git a/lib/polygeist/Kernel/KernelOps.cpp b/lib/polygeist/Kernel/KernelOps.cpp new file mode 100644 index 000000000000..8ad84f79e6ea --- /dev/null +++ b/lib/polygeist/Kernel/KernelOps.cpp @@ -0,0 +1,150 @@ +//===- KernelOps.cpp - Kernel dialect operations ----------------*- C++ -*-===// +// +// This file is licensed under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "polygeist/Kernel/KernelOps.h" +#include "polygeist/Kernel/KernelDialect.h" + +#include "mlir/Dialect/Arith/IR/Arith.h" +#include "mlir/Dialect/Func/IR/FuncOps.h" +#include "mlir/Dialect/MemRef/IR/MemRef.h" +#include "mlir/IR/Builders.h" +#include "mlir/IR/BuiltinTypes.h" +#include "mlir/IR/Matchers.h" +#include "mlir/IR/OpImplementation.h" +#include "mlir/IR/PatternMatch.h" +#include "mlir/Interfaces/FunctionImplementation.h" +#include "llvm/ADT/TypeSwitch.h" + +using namespace mlir; +using namespace mlir::polygeist; +using namespace mlir::polygeist::kernel; + +//===----------------------------------------------------------------------===// +// DefnOp +//===----------------------------------------------------------------------===// + +LogicalResult DefnOp::verify() { + // Check that the body region has exactly one block + if (!getBody().hasOneBlock()) + return emitOpError("body region must have exactly one block"); + + // The block can have any number of arguments + // No special verification needed for block arguments + + return success(); +} + +ParseResult DefnOp::parse(OpAsmParser &parser, OperationState &result) { + auto buildFuncType = [](Builder &builder, ArrayRef argTypes, + ArrayRef results, + function_interface_impl::VariadicFlag, + std::string &) { + return builder.getFunctionType(argTypes, results); + }; + + return function_interface_impl::parseFunctionOp( + parser, result, /*allowVariadic=*/false, + getFunctionTypeAttrName(result.name), buildFuncType, + getArgAttrsAttrName(result.name), getResAttrsAttrName(result.name)); +} + +void DefnOp::print(OpAsmPrinter &p) { + function_interface_impl::printFunctionOp( + p, *this, /*isVariadic=*/false, getFunctionTypeAttrName(), + getArgAttrsAttrName(), getResAttrsAttrName()); +} + +//===----------------------------------------------------------------------===// +// YieldOp +//===----------------------------------------------------------------------===// + +LogicalResult YieldOp::verify() { + auto defnOp = cast((*this)->getParentOp()); + + // The operand number and types must match the kernel signature. + const auto &results = defnOp.getFunctionType().getResults(); + if (getNumOperands() != results.size()) + return emitOpError("has ") + << getNumOperands() << " operands, but enclosing kernel (@" + << defnOp.getName() << ") returns " << results.size(); + + for (unsigned i = 0, e = results.size(); i != e; ++i) + if (getOperand(i).getType() != results[i]) + return emitError() << "type of yield operand " << i << " (" + << getOperand(i).getType() + << ") doesn't match kernel result type (" + << results[i] << ")" + << " in kernel @" << defnOp.getName(); + + return success(); +} + +//===----------------------------------------------------------------------===// +// LaunchOp +//===----------------------------------------------------------------------===// + +FunctionType LaunchOp::getKernelType() { + // Get the kernel symbol reference + auto kernelAttr = (*this)->getAttrOfType("kernel"); + if (!kernelAttr) + return nullptr; + + // Look up the kernel DefnOp in the symbol table + auto *symbolTableOp = (*this)->getParentWithTrait(); + if (!symbolTableOp) + return nullptr; + + auto kernelOp = dyn_cast_or_null( + SymbolTable::lookupSymbolIn(symbolTableOp, kernelAttr)); + if (!kernelOp) + return nullptr; + + return kernelOp.getFunctionType(); +} + +LogicalResult LaunchOp::verifySymbolUses(SymbolTableCollection &symbolTable) { + // Check that the kernel attribute was specified. + auto kernelAttr = (*this)->getAttrOfType("kernel"); + if (!kernelAttr) + return emitOpError("requires a 'kernel' symbol reference attribute"); + + // Check that the kernel symbol exists and is a DefnOp. + auto kernelOp = symbolTable.lookupNearestSymbolFrom(*this, kernelAttr); + if (!kernelOp) + return emitOpError() << "'" << kernelAttr.getValue() + << "' does not reference a valid kernel"; + + // Verify that the operand and result types match the kernel signature. + auto kernelType = kernelOp.getFunctionType(); + if (kernelType.getNumInputs() != getNumOperands()) + return emitOpError("incorrect number of operands for kernel"); + + for (unsigned i = 0, e = kernelType.getNumInputs(); i != e; ++i) + if (getOperand(i).getType() != kernelType.getInput(i)) + return emitOpError("operand type mismatch: expected operand type ") + << kernelType.getInput(i) << ", but provided " + << getOperand(i).getType() << " for operand number " << i; + + if (kernelType.getNumResults() != getNumResults()) + return emitOpError("incorrect number of results for kernel"); + + for (unsigned i = 0, e = kernelType.getNumResults(); i != e; ++i) + if (getResult(i).getType() != kernelType.getResult(i)) + return emitOpError("result type mismatch: expected result type ") + << kernelType.getResult(i) << ", but provided " + << getResult(i).getType() << " for result number " << i; + + return success(); +} + +//===----------------------------------------------------------------------===// +// TableGen'd op definitions +//===----------------------------------------------------------------------===// + +#define GET_OP_CLASSES +#include "polygeist/Kernel/KernelOps.cpp.inc" \ No newline at end of file diff --git a/lib/polygeist/Ops.cpp b/lib/polygeist/Ops.cpp index d9a60fbcce45..ce7f0485a230 100644 --- a/lib/polygeist/Ops.cpp +++ b/lib/polygeist/Ops.cpp @@ -22,9 +22,11 @@ #include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Arith/Utils/Utils.h" #include "mlir/Dialect/Func/IR/FuncOps.h" +#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/OpenMP/OpenMPDialect.h" #include "mlir/Dialect/SCF/IR/SCF.h" +#include "mlir/IR/AffineMap.h" #include "mlir/IR/Dominance.h" #include "mlir/IR/IRMapping.h" #include "mlir/IR/IntegerSet.h" @@ -39,7 +41,6 @@ using namespace mlir; using namespace polygeist; using namespace mlir::arith; - llvm::cl::opt BarrierOpt("barrier-opt", llvm::cl::init(true), llvm::cl::desc("Optimize barriers")); @@ -673,6 +674,8 @@ bool isCaptured(Value v, Operation *potentialUser = nullptr, for (auto u : v.getUsers()) { if (seenuse && u == potentialUser) *seenuse = true; + if (isa(u)) + continue; if (isa(u)) continue; @@ -815,25 +818,43 @@ bool mayAlias(Value v, Value v2) { isAlloca[1] = isStackAlloca(v2); isGlobal[1] = v2.getDefiningOp() || - v2.getDefiningOp(); + v2.getDefiningOp(); // Non-equivalent allocas/global's cannot conflict with each other if ((isAlloca[0] || isGlobal[0]) && (isAlloca[1] || isGlobal[1])) return false; - bool isArg[2]; - isArg[0] = v.isa() && - isa( - v.cast().getOwner()->getParentOp()); + bool isArg[2] = {false, false}; + bool isNoAliasArg[2] = {false, false}; + + if (auto ba = dyn_cast(v)) { + if (auto fn = dyn_cast(ba.getOwner()->getParentOp())) { + isArg[0] = true; + if (fn.getArgAttr(ba.getArgNumber(), LLVM::LLVMDialect::getNoAliasAttrName())) { + isNoAliasArg[0] = true; + } + } + } - isArg[1] = v.isa() && - isa( - v.cast().getOwner()->getParentOp()); + if (auto ba = dyn_cast(v2)) { + if (auto fn = dyn_cast(ba.getOwner()->getParentOp())) { + isArg[1] = true; + if (fn.getArgAttr(ba.getArgNumber(), LLVM::LLVMDialect::getNoAliasAttrName())) { + isNoAliasArg[1] = true; + } + } + } // Stack allocations cannot have been passed as an argument. if ((isAlloca[0] && isArg[1]) || (isAlloca[1] && isArg[0])) return false; + if ((isArg[0] && isNoAliasArg[1]) || (isArg[1] && isNoAliasArg[0])) + return false; + + if ((isGlobal[0] && isNoAliasArg[1]) || (isGlobal[1] && isNoAliasArg[0])) + return false; + // Non captured base allocas cannot conflict with another base value. if (isAlloca[0] && !isCaptured(v)) return false; @@ -4487,7 +4508,6 @@ struct MergeNestedAffineParallelIf return success(); } }; - struct MergeParallelInductions : public OpRewritePattern { using OpRewritePattern::OpRewritePattern; @@ -4497,7 +4517,7 @@ struct MergeParallelInductions // Reductions are not supported yet. if (!op.getReductions().empty()) return failure(); - + auto getIndUsage = [&op](AffineExpr cst, ValueRange operands, std::map &indUsage, bool &legal) -> AffineExpr { @@ -5733,6 +5753,629 @@ struct MulDivMul : public OpRewritePattern { } }; +struct SubMapOpCanonicalize : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + LogicalResult matchAndRewrite(SubmapOp op, + PatternRewriter &rewriter) const override { + /// if submap %x is identity map and has the same size as the static size of + /// %x + ///. replace submap with memref.cast of memref<4x5xf32> to memref + /// %x = ... : memref<4x5xf32> + // %y = polygeist.submap %x(#identity_map, %constant_4, %constant_5) : + // memref<4x5xf32> -> memref + // + //. becomes + // + /// %x = ... : memref<4x5xf32> + // %y = memref.cast %x : memref<4x5xf32> -> memref + // + auto source_memref = op.getBase(); + bool isIdentity = op.getMap().isIdentity(); + bool isInputSameDim = llvm::all_of( + llvm::zip_equal(op.getSizes(), + cast(source_memref.getType()).getShape()), + [&](auto pair) { + if (std::get<1>(pair) == -1) + return false; + APInt matched; + if (matchPattern(std::get<0>(pair), m_ConstantInt(&matched))) { + return std::get<1>(pair) == matched; + } + return false; + }); + if (isIdentity && isInputSameDim) { + rewriter.replaceOpWithNewOp(op, op.getType(), + op.getBase()); + return success(); + } + if (auto sapOp = source_memref.getDefiningOp()) { + auto load_map = op.getMap(); + auto submap_map = sapOp.getMap(); + auto new_map = submap_map.compose(load_map); + SmallVector operands; + operands.append(op.getSymbols().begin(), op.getSymbols().end()); + operands.append(op.getSymbols().begin(), op.getSymbols().end()); + operands.append(op.getSizes().begin(), op.getSizes().end()); + rewriter.replaceOpWithNewOp( + op, op.getType(), sapOp.getBase(), operands, new_map); + return success(); + } + return failure(); + } +}; + +struct StrideAndBound { + int64_t stride; + int64_t lowerBound; + unsigned dimOrSymbol; // Which dimension/symbol this applies to + bool isDimension; // true if dimension, false if symbol + + StrideAndBound(int64_t s, int64_t lb, unsigned idx, bool isDim) + : stride(s), lowerBound(lb), dimOrSymbol(idx), isDimension(isDim) {} +}; + +struct ExpressionAnalysis { + SmallVector coefficients; // Coefficients for dims/symbols + int64_t constantTerm = 0; // Pure constant term + + void addDimCoeff(unsigned dim, int64_t coeff) { + coefficients.emplace_back(coeff, 0, dim, true); + } + + void addSymCoeff(unsigned sym, int64_t coeff) { + coefficients.emplace_back(coeff, 0, sym, false); + } +}; + +// Recursively analyze an affine expression to extract coefficients and constants +static ExpressionAnalysis analyzeAffineExpression(AffineExpr expr) { + ExpressionAnalysis result; + + if (auto constExpr = expr.dyn_cast()) { + // Pure constant + result.constantTerm = constExpr.getValue(); + + } else if (auto dimExpr = expr.dyn_cast()) { + // Single dimension with coefficient 1 + result.addDimCoeff(dimExpr.getPosition(), 1); + + } else if (auto symExpr = expr.dyn_cast()) { + // Single symbol with coefficient 1 + result.addSymCoeff(symExpr.getPosition(), 1); + + } else if (auto binaryExpr = expr.dyn_cast()) { + auto lhs = binaryExpr.getLHS(); + auto rhs = binaryExpr.getRHS(); + + if (binaryExpr.getKind() == AffineExprKind::Add) { + // Addition: combine results from both sides + auto lhsAnalysis = analyzeAffineExpression(lhs); + auto rhsAnalysis = analyzeAffineExpression(rhs); + + result.coefficients.append(lhsAnalysis.coefficients); + result.coefficients.append(rhsAnalysis.coefficients); + result.constantTerm = lhsAnalysis.constantTerm + rhsAnalysis.constantTerm; + + } else if (binaryExpr.getKind() == AffineExprKind::Mul) { + // Multiplication: one side should be constant, other should be dim/symbol + auto lhsConst = lhs.dyn_cast(); + auto rhsConst = rhs.dyn_cast(); + + if (lhsConst && !rhsConst) { + // Constant * expr + auto rhsAnalysis = analyzeAffineExpression(rhs); + for (auto &coeff : rhsAnalysis.coefficients) { + coeff.stride *= lhsConst.getValue(); + } + result.coefficients = std::move(rhsAnalysis.coefficients); + result.constantTerm = rhsAnalysis.constantTerm * lhsConst.getValue(); + + } else if (rhsConst && !lhsConst) { + // expr * Constant + auto lhsAnalysis = analyzeAffineExpression(lhs); + for (auto &coeff : lhsAnalysis.coefficients) { + coeff.stride *= rhsConst.getValue(); + } + result.coefficients = std::move(lhsAnalysis.coefficients); + result.constantTerm = lhsAnalysis.constantTerm * rhsConst.getValue(); + + } else if (lhsConst && rhsConst) { + // Constant * Constant + result.constantTerm = lhsConst.getValue() * rhsConst.getValue(); + } + // Note: expr * expr is not affine, so we don't handle it + + } else if (binaryExpr.getKind() == AffineExprKind::Mod) { + // Modulo: more complex, for now just mark as having the base expression + auto lhsAnalysis = analyzeAffineExpression(lhs); + result.coefficients = std::move(lhsAnalysis.coefficients); + result.constantTerm = lhsAnalysis.constantTerm; + + } else if (binaryExpr.getKind() == AffineExprKind::FloorDiv || + binaryExpr.getKind() == AffineExprKind::CeilDiv) { + // Division: handle simple cases where RHS is constant + if (auto rhsConst = rhs.dyn_cast()) { + auto lhsAnalysis = analyzeAffineExpression(lhs); + for (auto &coeff : lhsAnalysis.coefficients) { + coeff.stride = coeff.stride / rhsConst.getValue(); + } + result.coefficients = std::move(lhsAnalysis.coefficients); + result.constantTerm = lhsAnalysis.constantTerm / rhsConst.getValue(); + } + } + } + + return result; +} + +struct MapAnalysis { + SmallVector outputAnalyses; + + // Get all unique strides from all outputs + SmallVector getAllStrides() const { + SmallVector strides; + llvm::DenseSet seen; + + for (const auto &analysis : outputAnalyses) { + for (const auto &coeff : analysis.coefficients) { + // TODO: Need to add a check that if more than one coeffs in an outputAnalysis + // then we need to return failure. + strides.push_back(coeff.stride); + } + } + return strides; + } + + // Get all lower bounds (constant terms) from all outputs + SmallVector getAllLowerBounds() const { + SmallVector bounds; + for (const auto &analysis : outputAnalyses) { + bounds.push_back(analysis.constantTerm); + } + return bounds; + } +}; + +// Main function to analyze an affine map +static MapAnalysis analyzeAffineMap(AffineMap map) { + MapAnalysis result; + + for (auto expr : map.getResults()) { + result.outputAnalyses.push_back(analyzeAffineExpression(expr)); + } + + return result; +} + +// Extract both strides and bounds +std::pair, SmallVector> +extractStridesAndBounds(AffineMap map) { + auto analysis = analyzeAffineMap(map); + return {analysis.getAllStrides(), analysis.getAllLowerBounds()}; +} + +// Helper function to check if an expression is a simple offset + stride pattern +static bool isSimpleOffsetStride(AffineExpr expr) { + // Check if expression is of the form: d0 + constant, d0 * constant + constant, etc. + if (auto dimExpr = expr.dyn_cast()) { + return true; // Simple dimension access + } + + if (auto constExpr = expr.dyn_cast()) { + return true; // Constant offset + } + + if (auto binaryExpr = expr.dyn_cast()) { + auto kind = binaryExpr.getKind(); + + // Allow simple addition and multiplication patterns + if (kind == AffineExprKind::Add || kind == AffineExprKind::Mul) { + return isSimpleOffsetStride(binaryExpr.getLHS()) && + isSimpleOffsetStride(binaryExpr.getRHS()); + } + + // Allow simple division by constants (for stride calculation) + if (kind == AffineExprKind::FloorDiv || kind == AffineExprKind::CeilDiv) { + if (auto rhsConst = binaryExpr.getRHS().dyn_cast()) { + return rhsConst.getValue() > 0 && isSimpleOffsetStride(binaryExpr.getLHS()); + } + } + } + + return false; +} + +// Main function to check if SubmapOp can be converted to SubViewOp +static bool canConvertSubmapToSubView(polygeist::SubmapOp submapOp) { + auto map = submapOp.getMap(); + auto sizes = submapOp.getSizes(); + auto symbols = submapOp.getSymbols(); + auto source_memref = submapOp.getBase(); + + // 0. Only convert if map has symbols + if (submapOp.getMap().getNumSymbols() == 0) { + return false; + } + + // 1. Identity maps are always valid + if (map.isIdentity()) { + return true; + } + + // 2. Check if we can extract meaningful strides and bounds + auto [strides, lowerBounds] = extractStridesAndBounds(map); + if (strides.empty() || lowerBounds.empty()) { + return false; + } + + // 3. Ensure the number of results matches expected dimensions + if (map.getNumResults() != sizes.size()) { + return false; + } + + // 4. Check each expression in the map for complexity + for (auto expr : map.getResults()) { + if (!isSimpleOffsetStride(expr)) { + return false; + } + } + + // 5. Check for unsupported complex transformations + for (auto expr : map.getResults()) { + // Reject expressions that involve multiple dimensions in complex ways + if (auto binaryExpr = expr.dyn_cast()) { + // For now, reject modulo operations as they're hard to represent in SubView + if (binaryExpr.getKind() == AffineExprKind::Mod) { + return false; + } + + // Reject complex multi-dimensional expressions + if (binaryExpr.getKind() == AffineExprKind::Mul) { + auto lhs = binaryExpr.getLHS(); + auto rhs = binaryExpr.getRHS(); + + // Both sides are dimensions = complex interaction + if (lhs.isa() && rhs.isa()) { + return false; + } + + // Multiplication by symbols might be too complex for simple SubView + if (lhs.isa() || rhs.isa()) { + // Allow simple symbol multiplication, but check it's not too complex + if (!lhs.isa() && !rhs.isa()) { + return false; + } + } + } + } + } + + // 6. Check for rank-changing transformations that SubView can't handle + auto sourceType = source_memref.getType().cast(); + auto resultType = submapOp.getType().cast(); + + // SubView can do rank-reduction, but not rank-expansion + if (resultType.getRank() > sourceType.getRank()) { + return false; + } + + return true; +} + +// Convenience function to check and extract conversion info +struct SubmapToSubViewConversionInfo { + bool isValid; + SmallVector strides; + SmallVector offsets; + SmallVector sizes; + SmallVector dynamicOffsets; // For symbol-based offsets + + SubmapToSubViewConversionInfo() : isValid(false) {} +}; + +static SubmapToSubViewConversionInfo +analyzeSubmapToSubViewConversion(polygeist::SubmapOp submapOp) { + SubmapToSubViewConversionInfo info; + + if (!canConvertSubmapToSubView(submapOp)) { + return info; // isValid = false + } + + auto map = submapOp.getMap(); + auto [strides, lowerBounds] = extractStridesAndBounds(map); + + info.isValid = true; + info.strides = strides; + info.offsets = lowerBounds; + info.sizes.append(submapOp.getSizes().begin(), submapOp.getSizes().end()); + + return info; +} + + +struct SubmapToSubviewOp : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + LogicalResult matchAndRewrite(polygeist::SubmapOp submapOp, + PatternRewriter &rewriter) const override { + auto conversionInfo = analyzeSubmapToSubViewConversion(submapOp); + if (!conversionInfo.isValid) + return failure(); + + SmallVector offsetValues, sizeValues, strideValues; + for (int64_t offset : conversionInfo.offsets) { + offsetValues.push_back(rewriter.getI64IntegerAttr(offset)); + } + for (int64_t stride : conversionInfo.strides) { + strideValues.push_back(rewriter.getI64IntegerAttr(stride)); + } + for (Value size : conversionInfo.sizes) { + sizeValues.push_back(size); + } + rewriter.replaceOpWithNewOp(submapOp, submapOp.getBase(), offsetValues, sizeValues, strideValues); + return success(); + } +}; + +// Enhanced analysis structure to handle symbols and transposes +struct EnhancedSubmapAnalysis { + bool isValid = false; + bool needsTranspose = false; + SmallVector permutation; // For transpose: [1,0] means swap dims + SmallVector offsets; // Mix of constants and symbol values + SmallVector strides; // Mix of constants and symbol values + SmallVector sizes; // From submapOp.getSizes() +}; + +// Helper to analyze affine expressions with symbol support +static bool analyzeExpressionWithSymbols(AffineExpr expr, unsigned expectedDim, + ValueRange symbolValues, + OpFoldResult &offset, OpFoldResult &stride, + unsigned &actualDim, OpBuilder &builder) { + offset = builder.getI64IntegerAttr(0); // Default offset = 0 + stride = builder.getI64IntegerAttr(1); // Default stride = 1 + actualDim = expectedDim; + + // Case 1: Simple dimension access: d0, d1, etc. + if (auto dimExpr = expr.dyn_cast()) { + actualDim = dimExpr.getPosition(); + return true; + } + + // Case 2: Constant (pure offset) + if (auto constExpr = expr.dyn_cast()) { + offset = builder.getI64IntegerAttr(constExpr.getValue()); + actualDim = 0; // Degenerate case + return true; + } + + // Case 3: Symbol (pure offset from symbol) + if (auto symbolExpr = expr.dyn_cast()) { + if (symbolExpr.getPosition() < symbolValues.size()) { + offset = symbolValues[symbolExpr.getPosition()]; + actualDim = 0; // Degenerate case + return true; + } + return false; + } + + // Case 4: Binary operations + if (auto binaryExpr = expr.dyn_cast()) { + auto lhs = binaryExpr.getLHS(); + auto rhs = binaryExpr.getRHS(); + + if (binaryExpr.getKind() == AffineExprKind::Add) { + // d0 + constant, d0 + symbol, constant + symbol, etc. + if (auto dimExpr = lhs.dyn_cast()) { + actualDim = dimExpr.getPosition(); + if (auto constExpr = rhs.dyn_cast()) { + offset = builder.getI64IntegerAttr(constExpr.getValue()); + return true; + } + if (auto symbolExpr = rhs.dyn_cast()) { + if (symbolExpr.getPosition() < symbolValues.size()) { + offset = symbolValues[symbolExpr.getPosition()]; + return true; + } + } + } + // Try reverse: constant + d0, symbol + d0 + if (auto dimExpr = rhs.dyn_cast()) { + actualDim = dimExpr.getPosition(); + if (auto constExpr = lhs.dyn_cast()) { + offset = builder.getI64IntegerAttr(constExpr.getValue()); + return true; + } + if (auto symbolExpr = lhs.dyn_cast()) { + if (symbolExpr.getPosition() < symbolValues.size()) { + offset = symbolValues[symbolExpr.getPosition()]; + return true; + } + } + } + } + + if (binaryExpr.getKind() == AffineExprKind::Mul) { + // d0 * constant, d0 * symbol + if (auto dimExpr = lhs.dyn_cast()) { + actualDim = dimExpr.getPosition(); + if (auto constExpr = rhs.dyn_cast()) { + stride = builder.getI64IntegerAttr(constExpr.getValue()); + return true; + } + if (auto symbolExpr = rhs.dyn_cast()) { + if (symbolExpr.getPosition() < symbolValues.size()) { + stride = symbolValues[symbolExpr.getPosition()]; + return true; + } + } + } + // Try reverse: constant * d0, symbol * d0 + if (auto dimExpr = rhs.dyn_cast()) { + actualDim = dimExpr.getPosition(); + if (auto constExpr = lhs.dyn_cast()) { + stride = builder.getI64IntegerAttr(constExpr.getValue()); + return true; + } + if (auto symbolExpr = lhs.dyn_cast()) { + if (symbolExpr.getPosition() < symbolValues.size()) { + stride = symbolValues[symbolExpr.getPosition()]; + return true; + } + } + } + } + } + + return false; +} + +// Enhanced analysis function +static EnhancedSubmapAnalysis analyzeEnhancedSubmap(polygeist::SubmapOp submapOp, + OpBuilder &builder) { + EnhancedSubmapAnalysis analysis; + auto map = submapOp.getMap(); + auto symbolValues = submapOp.getSymbols(); + auto sizes = submapOp.getSizes(); + auto sourceType = submapOp.getViewSource().getType().cast(); + int64_t sourceRank = sourceType.getRank(); + + // Only handle maps with reasonable complexity + if (map.getNumResults() == 0 || map.getNumResults() > 4) { + return analysis; + } + + // Initialize arrays with default values for all dimensions of source memref + SmallVector offsets(sourceRank, builder.getI64IntegerAttr(0)); + SmallVector strides(sourceRank, builder.getI64IntegerAttr(1)); + SmallVector resultSizes; + SmallVector actualDims; + + // Build default sizes from source memref shape + for (int64_t i = 0; i < sourceRank; ++i) { + int64_t dimSize = sourceType.getDimSize(i); + if (dimSize == ShapedType::kDynamic) { + // For dynamic dimensions, we need to use the actual size + Value dimSizeValue = builder.create( + submapOp.getLoc(), submapOp.getViewSource(), i); + resultSizes.push_back(dimSizeValue); + } else { + resultSizes.push_back(builder.getI64IntegerAttr(dimSize)); + } + } + + // Analyze each result expression and update corresponding dimension + for (unsigned i = 0; i < map.getNumResults(); ++i) { + auto expr = map.getResult(i); + OpFoldResult offset, stride; + unsigned actualDim; + + if (!analyzeExpressionWithSymbols(expr, i, symbolValues, offset, stride, + actualDim, builder)) { + return analysis; // Failed to analyze + } + + // Make sure actualDim is within bounds + if (actualDim >= sourceRank) { + return analysis; // Invalid dimension + } + + // Update the arrays for this dimension + offsets[actualDim] = offset; + strides[actualDim] = stride; + actualDims.push_back(actualDim); + } + + analysis.isValid = true; + analysis.offsets = std::move(offsets); + analysis.strides = std::move(strides); + + // Copy sizes - use provided sizes if available, otherwise use computed ones + if (sizes.size() == map.getNumResults()) { + for (auto size : sizes) { + analysis.sizes.push_back(size); + } + } else { + // Use default sizes for all dimensions + analysis.sizes = std::move(resultSizes); + } + + return analysis; +} + +// Enhanced pattern implementation +struct EnhancedSubmapToSubviewOp : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(polygeist::SubmapOp submapOp, + PatternRewriter &rewriter) const override { + auto analysis = analyzeEnhancedSubmap(submapOp, rewriter); + if (!analysis.isValid) { + return failure(); + } + + Value currentMemref = submapOp.getViewSource(); + Location loc = submapOp.getLoc(); + + // Step 1: Apply subview if we have non-trivial offsets/strides + bool hasNonTrivialSubview = false; + for (auto offset : analysis.offsets) { + if (auto attr = offset.dyn_cast()) { + if (auto intAttr = attr.dyn_cast()) { + if (intAttr.getInt() != 0) { + hasNonTrivialSubview = true; + break; + } + } + } else { + hasNonTrivialSubview = true; // Non-constant offset + break; + } + } + + for (auto stride : analysis.strides) { + if (auto attr = stride.dyn_cast()) { + if (auto intAttr = attr.dyn_cast()) { + if (intAttr.getInt() != 1) { + hasNonTrivialSubview = true; + break; + } + } + } else { + hasNonTrivialSubview = true; // Non-constant stride + break; + } + } + + if (hasNonTrivialSubview) { + // Create subview operation + auto subviewOp = rewriter.create( + loc, currentMemref, analysis.offsets, analysis.sizes, analysis.strides); + currentMemref = subviewOp.getResult(); + } + + // Step 2: Apply transpose if needed + if (analysis.needsTranspose) { + // Create transpose using linalg.transpose or memref.transpose + // For now, let's use a simple approach with linalg + SmallVector permutation = analysis.permutation; + + // Create transpose using linalg.transpose (if available) + // This is a simplified version - you might need to adjust based on available ops + auto transposeType = MemRefType::get( + submapOp.getType().cast().getShape(), + submapOp.getType().cast().getElementType()); + + // For simplicity, let's create an identity operation for now + // In practice, you'd want to create the actual transpose operation + currentMemref = currentMemref; // TODO: Implement actual transpose + } + + // Replace the original submap + rewriter.replaceOp(submapOp, currentMemref); + return success(); + } +}; + static llvm::cl::opt BufferElim("enable-buffer-elim", llvm::cl::init(true), llvm::cl::desc("Enable buffer elimination")); @@ -5764,7 +6407,6 @@ void TypeAlignOp::getCanonicalizationPatterns(RewritePatternSet &results, SimplifyDeadAllocV2, SimplifyDeadAllocV2, MulDivMul, MergeParallelInductions, - // RankReduction, AggressiveAllocaScopeInliner, InductiveVarRemoval>(context); } @@ -5880,3 +6522,202 @@ LogicalResult GetFuncOp::verifySymbolUses(SymbolTableCollection &symbolTable) { return success(); } + +class LoadSubMap final : public OpRewritePattern { +public: + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(affine::AffineLoadOp op, + PatternRewriter &rewriter) const override { + auto subMapOp = op.getMemRef().getDefiningOp(); + if (!subMapOp) + return failure(); + + auto submap_map = subMapOp.getMap(); + auto submap_operands = subMapOp.getSymbols(); + auto source_memref = subMapOp.getBase(); + + auto load_map = op.getAffineMap(); + auto load_operands = op.getMapOperands(); + + auto new_map = submap_map.compose(load_map); + + SmallVector operands; + operands.append(load_operands.begin(), + load_operands.begin() + load_map.getNumDims()); + operands.append(submap_operands.begin(), submap_operands.end()); + operands.append(load_operands.begin() + load_map.getNumDims(), + load_operands.end()); + + rewriter.replaceOpWithNewOp(op, source_memref, + new_map, operands); + return success(); + } +}; + +class StoreSubMap final : public OpRewritePattern { +public: + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(affine::AffineStoreOp op, + PatternRewriter &rewriter) const override { + auto subMapOp = op.getMemRef().getDefiningOp(); + if (!subMapOp) + return failure(); + + auto submap_map = subMapOp.getMap(); + auto submap_operands = subMapOp.getSymbols(); + auto source_memref = subMapOp.getBase(); + + auto load_map = op.getAffineMap(); + auto load_operands = op.getMapOperands(); + + auto new_map = submap_map.compose(load_map); + + SmallVector operands; + operands.append(load_operands.begin(), + load_operands.begin() + load_map.getNumDims()); + operands.append(submap_operands.begin(), submap_operands.end()); + operands.append(load_operands.begin() + load_map.getNumDims(), + load_operands.end()); + + rewriter.replaceOpWithNewOp( + op, op.getValue(), source_memref, new_map, operands); + return success(); + } +}; + +OpFoldResult mlir::polygeist::SubmapOp::fold( + mlir::polygeist::SubmapOp::FoldAdaptor adaptor) { + // TODO if submap is identity return nothing + // if submap of submap return new submap + return nullptr; +} + +class DimSubMap final : public OpRewritePattern { +public: + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(memref::DimOp op, + PatternRewriter &rewriter) const override { + auto subMapOp = op.getSource().getDefiningOp(); + if (!subMapOp) + return failure(); + + auto idx = op.getIndex().getDefiningOp(); + if (!idx) + return failure(); + + rewriter.replaceOp(op, subMapOp.getSizes()[idx.value()]); + + return success(); + } +}; + +//===----------------------------------------------------------------------===// +// LinalgGenericEliminateSubmaps Pattern +//===----------------------------------------------------------------------===// + +struct LinalgGenericEliminateSubmaps : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(linalg::GenericOp genericOp, PatternRewriter &rewriter) const override { + bool hasSubmaps = false; + SmallVector newInputs; + SmallVector newOutputs; + SmallVector newIndexingMaps; + + // Get the indexing maps as AffineMap array + auto indexingMaps = genericOp.getIndexingMapsArray(); + + // Check inputs for submaps + for (auto [input, map] : llvm::zip(genericOp.getInputs(), indexingMaps)) { + if (auto submapOp = input.getDefiningOp()) { + // Skip submaps with symbols for now to avoid invalid map composition + if (submapOp.getMap().getNumSymbols() > 0) { + newInputs.push_back(input); + newIndexingMaps.push_back(map); + continue; + } + + hasSubmaps = true; + newInputs.push_back(submapOp.getViewSource()); + // Compose: submap_map.compose(linalg_map) → f(g(x)) + AffineMap composedMap = submapOp.getMap().compose(map); + newIndexingMaps.push_back(composedMap); + } else { + newInputs.push_back(input); + newIndexingMaps.push_back(map); + } + } + + // Check outputs for submaps + auto outputMaps = ArrayRef(indexingMaps).drop_front(genericOp.getInputs().size()); + for (auto [output, map] : llvm::zip(genericOp.getOutputs(), outputMaps)) { + if (auto submapOp = output.getDefiningOp()) { + // Skip submaps with symbols for now to avoid invalid map composition + if (submapOp.getMap().getNumSymbols() > 0) { + newOutputs.push_back(output); + newIndexingMaps.push_back(map); + continue; + } + + hasSubmaps = true; + newOutputs.push_back(submapOp.getViewSource()); + // Compose: submap_map.compose(linalg_map) → f(g(x)) + AffineMap composedMap = submapOp.getMap().compose(map); + newIndexingMaps.push_back(composedMap); + } else { + newOutputs.push_back(output); + newIndexingMaps.push_back(map); + } + } + + if (!hasSubmaps) { + return failure(); + } + + // Create new linalg.generic with composed maps + auto newGenericOp = rewriter.create( + genericOp.getLoc(), + genericOp.getResultTypes(), + newInputs, + newOutputs, + newIndexingMaps, + genericOp.getIteratorTypesArray(), + /*bodyBuild=*/nullptr); + + // Clone the region + IRMapping mapping; + genericOp.getRegion().cloneInto(&newGenericOp.getRegion(), mapping); + + rewriter.replaceOp(genericOp, newGenericOp.getResults()); + return success(); + } +}; + +void polygeist::SubmapOp::getCanonicalizationPatterns( + RewritePatternSet &results, MLIRContext *context) { + // results.insert(context); + results.insert(context); + // results.insert(context); +} + +//===----------------------------------------------------------------------===// +// SubmapInverseOp +//===----------------------------------------------------------------------===// + +OpFoldResult mlir::polygeist::SubmapInverseOp::fold( + mlir::polygeist::SubmapInverseOp::FoldAdaptor adaptor) { + // TODO: Add folding logic for SubmapInverseOp + // For now, just return nullptr (no folding) + return nullptr; +} + +void polygeist::SubmapInverseOp::getCanonicalizationPatterns( + RewritePatternSet &results, MLIRContext *context) { + // TODO: Add canonicalization patterns for SubmapInverseOp + // For now, leave empty +} diff --git a/lib/polygeist/Passes/CMakeLists.txt b/lib/polygeist/Passes/CMakeLists.txt index d6947a1931c5..86d644770cc2 100644 --- a/lib/polygeist/Passes/CMakeLists.txt +++ b/lib/polygeist/Passes/CMakeLists.txt @@ -1,5 +1,6 @@ add_mlir_dialect_library(MLIRPolygeistTransforms ConvertToOpaquePtr.cpp + SelectFunc.cpp AffineCFG.cpp AffineReduction.cpp CanonicalizeFor.cpp @@ -11,7 +12,17 @@ add_mlir_dialect_library(MLIRPolygeistTransforms OpenMPOpt.cpp BarrierRemovalContinuation.cpp RaiseToAffine.cpp + RemoveIterArgs.cpp + FoldSCFIf.cpp RaiseToLinalg.cpp + LinalgDebufferize.cpp + LowerPolygeistSubmap.cpp + LowerKernelLaunch.cpp + WrapKernelLaunchPipeline.cpp + LowerKernelLaunchToCuBLAS.cpp + LowerKernelLaunchToPVA.cpp + KernelLaunchLoweringUtils.cpp + LinalgToKernel.cpp ParallelLower.cpp TrivialUse.cpp ConvertPolygeistToLLVM.cpp @@ -43,15 +54,18 @@ add_mlir_dialect_library(MLIRPolygeistTransforms MLIRGPUToNVVMTransforms MLIRIR MLIRLLVMDialect + MLIRLinalgDialect MLIRMathDialect MLIRMathToLLVM MLIRMemRefDialect MLIRNVVMDialect MLIRPass MLIRPolygeist + MLIRPolygeistKernel MLIRSideEffectInterfaces MLIRSCFToControlFlow MLIRTargetLLVMIRImport + MLIRTensorDialect MLIRTransformUtils MLIRGPUToROCDLTransforms MLIRControlFlowToLLVM diff --git a/lib/polygeist/Passes/FoldSCFIf.cpp b/lib/polygeist/Passes/FoldSCFIf.cpp new file mode 100644 index 000000000000..45ebb7c50a39 --- /dev/null +++ b/lib/polygeist/Passes/FoldSCFIf.cpp @@ -0,0 +1,779 @@ +//===- FoldSCFIf.cpp - Fold scf.if into select -----------------*- C++ -*-===// + +#include "PassDetails.h" + +#include "mlir/Dialect/Affine/IR/AffineOps.h" +#include "mlir/Dialect/Affine/Passes.h" +#include "mlir/Dialect/Arith/IR/Arith.h" +#include "mlir/Dialect/Func/IR/FuncOps.h" +#include "mlir/Dialect/MemRef/IR/MemRef.h" +#include "mlir/Dialect/SCF/IR/SCF.h" +#include "mlir/IR/Builders.h" +#include "mlir/IR/IntegerSet.h" +#include "mlir/IR/IRMapping.h" +#include "mlir/Interfaces/SideEffectInterfaces.h" +#include "mlir/Pass/PassManager.h" +#include "polygeist/Passes/Passes.h" +#include "llvm/ADT/MapVector.h" +#include "llvm/ADT/SetVector.h" +#include "llvm/Support/Debug.h" + +using namespace mlir; +using namespace mlir::polygeist; + +#define DEBUG_TYPE "fold-scf-if" + +static bool hasSingleStore(Block *block) { + llvm::SetVector memrefs; + + for (Operation &op : block->getOperations()) { + if (!isa(op)) + continue; + + Value memref = op.getOperand(1); + if (memrefs.count(memref)) + return false; + + // Store indices must be defined above the current block so that a lifted + // store can be emitted after the if. + if (auto storeOp = dyn_cast(op)) { + if (llvm::any_of(storeOp.getMapOperands(), [&](Value operand) { + return operand.getParentBlock() == block; + })) + return false; + } else if (auto storeOp = dyn_cast(op)) { + if (llvm::any_of(storeOp.getIndices(), [&](Value operand) { + return operand.getParentBlock() == block; + })) + return false; + } + + memrefs.insert(memref); + } + + return true; +} + +static bool canLiftStores(Block *block) { + bool seenStore = false; + for (Operation &op : block->getOperations()) { + if (isa(op)) + continue; + if (isa(op)) { + seenStore = true; + continue; + } + if (seenStore && !isMemoryEffectFree(&op)) + return false; + } + return true; +} + +namespace { +struct MemRefStoreInfo { + unsigned index = 0; + Type type; + Operation *source = nullptr; + SmallVector operands; + AffineMap affineMap; + bool isAffineStore = false; +}; +} // namespace + +static bool getMemRefLoadInfo(Value value, MemRefStoreInfo &info) { + Operation *op = value.getDefiningOp(); + if (!op) + return false; + + info = MemRefStoreInfo(); + info.type = value.getType(); + info.source = op; + + if (auto loadOp = dyn_cast(op)) { + info.operands.assign(loadOp.getIndices().begin(), + loadOp.getIndices().end()); + info.isAffineStore = false; + return true; + } + + if (auto loadOp = dyn_cast(op)) { + info.operands.assign(loadOp.getMapOperands().begin(), + loadOp.getMapOperands().end()); + info.affineMap = loadOp.getAffineMap(); + info.isAffineStore = true; + return true; + } + + return false; +} + +static bool getSingleStoreInfo(Operation &op, MemRefStoreInfo &info) { + info = MemRefStoreInfo(); + info.source = &op; + + if (auto storeOp = dyn_cast(op)) { + info.type = storeOp.getValueToStore().getType(); + info.operands.assign(storeOp.getIndices().begin(), + storeOp.getIndices().end()); + info.isAffineStore = false; + return true; + } + + if (auto storeOp = dyn_cast(op)) { + info.type = storeOp.getValueToStore().getType(); + info.operands.assign(storeOp.getMapOperands().begin(), + storeOp.getMapOperands().end()); + info.affineMap = storeOp.getAffineMap(); + info.isAffineStore = true; + return true; + } + + return false; +} + +static void getMemRefStoreInfo(Block *block, + llvm::MapVector &info) { + unsigned ord = 0; + for (Operation &op : block->getOperations()) { + if (!isa(op)) + continue; + + MemRefStoreInfo storeInfo; + storeInfo.index = ord++; + storeInfo.type = op.getOperand(0).getType(); + storeInfo.source = &op; + + if (auto storeOp = dyn_cast(op)) + storeInfo.operands = storeOp.getIndices(); + else if (auto storeOp = dyn_cast(op)) { + storeInfo.operands = storeOp.getMapOperands(); + storeInfo.affineMap = storeOp.getAffineMap(); + storeInfo.isAffineStore = true; + } + + info[op.getOperand(1)] = storeInfo; + } +} + +static bool sameStoreAddress(const MemRefStoreInfo &a, + const MemRefStoreInfo &b) { + if (a.isAffineStore != b.isAffineStore) + return false; + if (a.operands != b.operands) + return false; + if (a.isAffineStore && a.affineMap != b.affineMap) + return false; + return true; +} + +static bool hasMatchingStores(ArrayRef blocks) { + if (blocks.empty()) + return true; + + llvm::MapVector expected; + getMemRefStoreInfo(blocks.front(), expected); + + for (Block *block : blocks.drop_front()) { + llvm::MapVector actual; + getMemRefStoreInfo(block, actual); + + if (expected.size() != actual.size()) + return false; + + for (auto &entry : expected) { + auto actualIt = actual.find(entry.first); + if (actualIt == actual.end()) + return false; + if (!sameStoreAddress(entry.second, actualIt->second)) + return false; + } + } + + return true; +} + +static Value getMemrefFromStore(Operation *op) { + if (auto storeOp = dyn_cast(op)) + return storeOp.getMemref(); + if (auto storeOp = dyn_cast(op)) + return storeOp.getMemref(); + return Value(); +} + +static Value getMemrefFromLoad(Operation *op) { + if (auto loadOp = dyn_cast(op)) + return loadOp.getMemref(); + if (auto loadOp = dyn_cast(op)) + return loadOp.getMemref(); + return Value(); +} + +static bool sameLoadStoreAddress(const MemRefStoreInfo &load, + const MemRefStoreInfo &store) { + if (load.isAffineStore != store.isAffineStore) + return false; + if (getMemrefFromLoad(load.source) != getMemrefFromStore(store.source)) + return false; + if (load.operands != store.operands) + return false; + if (load.isAffineStore && load.affineMap != store.affineMap) + return false; + return true; +} + +static bool sameLoadAddress(const MemRefStoreInfo &a, + const MemRefStoreInfo &b) { + if (a.isAffineStore != b.isAffineStore) + return false; + if (getMemrefFromLoad(a.source) != getMemrefFromLoad(b.source)) + return false; + if (a.operands != b.operands) + return false; + if (a.isAffineStore && a.affineMap != b.affineMap) + return false; + return true; +} + +static Value getStoredValue(Operation *op) { + if (auto storeOp = dyn_cast(op)) + return storeOp.getValueToStore(); + if (auto storeOp = dyn_cast(op)) + return storeOp.getValueToStore(); + return Value(); +} + +static bool isLoadLike(Operation &op) { + return isa(op); +} + +static bool canSpeculateForSelect(Block *block) { + for (Operation &op : block->getOperations()) { + if (isa(op)) + continue; + if (isLoadLike(op)) + continue; + if (op.getNumRegions() != 0 || !isMemoryEffectFree(&op)) + return false; + } + return true; +} + +static Value materializeIntegerSetCondition(Location loc, IntegerSet set, + ValueRange operands, OpBuilder &b) { + Value active; + Value zero = b.create(loc, 0); + + for (auto constraint : llvm::enumerate(set.getConstraints())) { + AffineMap constraintMap = + AffineMap::get(set.getNumDims(), set.getNumSymbols(), + constraint.value(), b.getContext()); + Value applied = + b.create(loc, constraintMap, operands); + auto predicate = set.isEq(constraint.index()) + ? arith::CmpIPredicate::eq + : arith::CmpIPredicate::sge; + Value ok = b.create(loc, predicate, applied, zero); + active = active ? b.create(loc, active, ok).getResult() + : ok; + } + + if (!active) + active = b.create(loc, true, 1); + return active; +} + +static bool hasUnsafeInterveningEffect(Operation *begin, Operation *end) { + for (Operation *op = begin->getNextNode(); op && op != end; + op = op->getNextNode()) { + if (isLoadLike(*op) || isMemoryEffectFree(op)) + continue; + return true; + } + return false; +} + +static bool valueMatchesCandidate(Value value, Value candidate) { + if (value == candidate) + return true; + + MemRefStoreInfo valueLoad, candidateLoad; + if (!getMemRefLoadInfo(value, valueLoad) || + !getMemRefLoadInfo(candidate, candidateLoad)) + return false; + return sameLoadAddress(valueLoad, candidateLoad); +} + +static bool getCompareOperands(Value condition, Value &lhs, Value &rhs) { + Operation *condOp = condition.getDefiningOp(); + if (!condOp || !isa(condOp) || + condOp->getNumOperands() != 2) + return false; + lhs = condOp->getOperand(0); + rhs = condOp->getOperand(1); + return true; +} + +static LogicalResult foldGuardedStoreUpdate(scf::IfOp ifOp, OpBuilder &b) { + if (ifOp.elseBlock() || ifOp.getNumResults() != 0) + return failure(); + + Operation *store = nullptr; + for (Operation &op : ifOp.thenBlock()->without_terminator()) { + if (isa(op)) { + if (store) + return failure(); + store = &op; + continue; + } + if (!isLoadLike(op)) + return failure(); + } + if (!store) + return failure(); + + MemRefStoreInfo storeInfo; + if (!getSingleStoreInfo(*store, storeInfo)) + return failure(); + + for (Value operand : storeInfo.operands) + if (operand.getParentBlock() == ifOp.thenBlock()) + return failure(); + + Value cmpLhs, cmpRhs; + if (!getCompareOperands(ifOp.getCondition(), cmpLhs, cmpRhs)) + return failure(); + + Value stored = getStoredValue(store); + Value candidate; + Value oldValue; + if (valueMatchesCandidate(stored, cmpLhs)) { + candidate = cmpLhs; + oldValue = cmpRhs; + } else if (valueMatchesCandidate(stored, cmpRhs)) { + candidate = cmpRhs; + oldValue = cmpLhs; + } else { + return failure(); + } + + MemRefStoreInfo oldLoad; + if (!getMemRefLoadInfo(oldValue, oldLoad) || + !sameLoadStoreAddress(oldLoad, storeInfo)) + return failure(); + + if (oldLoad.source->getBlock() != ifOp->getBlock() || + hasUnsafeInterveningEffect(oldLoad.source, ifOp)) + return failure(); + + OpBuilder::InsertionGuard guard(b); + Location loc = ifOp.getLoc(); + b.setInsertionPointAfter(ifOp); + Value selected = + b.create(loc, ifOp.getCondition(), candidate, oldValue); + + if (auto storeOp = dyn_cast(store)) { + b.create(loc, selected, storeOp.getMemref(), + storeOp.getIndices()); + } else { + auto affineStoreOp = cast(store); + b.create(loc, selected, affineStoreOp.getMemref(), + affineStoreOp.getAffineMap(), + affineStoreOp.getMapOperands()); + } + + ifOp.erase(); + return success(); +} + +static bool foldSingleStoreIfToSelect(scf::IfOp ifOp, OpBuilder &b) { + if (ifOp.elseBlock() || ifOp.getNumResults() != 0) + return false; + + Operation *store = nullptr; + for (Operation &op : ifOp.thenBlock()->without_terminator()) { + if (isa(op)) { + if (store) + return false; + store = &op; + continue; + } + if (!isLoadLike(op) && + (op.getNumRegions() != 0 || !isMemoryEffectFree(&op))) + return false; + } + if (!store) + return false; + + MemRefStoreInfo storeInfo; + if (!getSingleStoreInfo(*store, storeInfo)) + return false; + + for (Value operand : storeInfo.operands) + if (operand.getParentBlock() == ifOp.thenBlock()) + return false; + + OpBuilder::InsertionGuard guard(b); + Location loc = ifOp.getLoc(); + b.setInsertionPointAfter(ifOp); + + IRMapping vmap; + Value candidate; + for (Operation &op : ifOp.thenBlock()->getOperations()) { + if (isa(op)) + continue; + if (&op == store) { + candidate = vmap.lookupOrDefault(getStoredValue(store)); + continue; + } + b.clone(op, vmap); + } + if (!candidate) + return false; + + Value oldValue; + if (auto storeOp = dyn_cast(store)) { + oldValue = b.create(loc, storeOp.getMemref(), + storeOp.getIndices()); + Value selected = + b.create(loc, ifOp.getCondition(), candidate, oldValue); + b.create(loc, selected, storeOp.getMemref(), + storeOp.getIndices()); + } else { + auto affineStoreOp = cast(store); + oldValue = b.create( + loc, affineStoreOp.getMemref(), affineStoreOp.getAffineMap(), + affineStoreOp.getMapOperands()); + Value selected = + b.create(loc, ifOp.getCondition(), candidate, oldValue); + b.create(loc, selected, affineStoreOp.getMemref(), + affineStoreOp.getAffineMap(), + affineStoreOp.getMapOperands()); + } + + ifOp.erase(); + return true; +} + +static LogicalResult liftStoreOps(scf::IfOp ifOp, OpBuilder &b) { + Location loc = ifOp.getLoc(); + + if (!hasMatchingStores({ifOp.thenBlock(), ifOp.elseBlock()})) + return failure(); + + llvm::MapVector storeInfo; + getMemRefStoreInfo(ifOp.thenBlock(), storeInfo); + + if (storeInfo.empty()) + return failure(); + + SmallVector storeTypes(storeInfo.size()); + for (auto &info : storeInfo) + storeTypes[info.second.index] = info.second.type; + + OpBuilder::InsertionGuard guard(b); + b.setInsertionPointAfter(ifOp); + + SmallVector resultTypes(ifOp.getResultTypes()); + resultTypes.append(storeTypes); + + scf::IfOp newIfOp = b.create(loc, resultTypes, ifOp.getCondition(), + /*withElseRegion=*/true); + + auto cloneBlock = [&](Block *target, Block *source) { + IRMapping vmap; + + scf::YieldOp yieldOp = cast(source->getTerminator()); + unsigned numExistingResults = yieldOp.getNumOperands(); + SmallVector results(numExistingResults + storeInfo.size()); + + OpBuilder::InsertionGuard guard(b); + b.setInsertionPointToStart(target); + + for (Operation &op : source->getOperations()) { + if (isa(op)) { + Value memref = op.getOperand(1); + Value toStore = op.getOperand(0); + results[storeInfo[memref].index + numExistingResults] = + vmap.lookupOrDefault(toStore); + } else if (!isa(op)) { + b.clone(op, vmap); + } + } + + for (auto operand : llvm::enumerate(yieldOp.getOperands())) + results[operand.index()] = vmap.lookupOrDefault(operand.value()); + + b.create(loc, results); + }; + + cloneBlock(newIfOp.thenBlock(), ifOp.thenBlock()); + cloneBlock(newIfOp.elseBlock(), ifOp.elseBlock()); + + b.setInsertionPointAfter(newIfOp); + + for (auto &p : storeInfo) { + Value memref; + MemRefStoreInfo info; + std::tie(memref, info) = p; + + Value result = newIfOp.getResult(ifOp.getNumResults() + info.index); + if (auto storeOp = dyn_cast(info.source)) { + b.create(loc, result, memref, + storeOp.getAffineMap(), info.operands); + } else if (isa(info.source)) { + b.create(loc, result, memref, info.operands); + } + } + + for (auto result : llvm::enumerate(ifOp.getResults())) + result.value().replaceAllUsesWith(newIfOp.getResult(result.index())); + + ifOp.erase(); + return success(); +} + +static bool processLiftStoreOps(func::FuncOp f, OpBuilder &b) { + bool changed = false; + + f.walk([&](scf::IfOp ifOp) { + if (changed) + return; + + if (!ifOp.elseBlock() || !hasSingleStore(ifOp.thenBlock()) || + !hasSingleStore(ifOp.elseBlock()) || + !canLiftStores(ifOp.thenBlock()) || !canLiftStores(ifOp.elseBlock())) + return; + + if (failed(liftStoreOps(ifOp, b))) + return; + + changed = true; + }); + + return changed; +} + +static bool foldScalarSCFIf(scf::IfOp ifOp, OpBuilder &b) { + if (ifOp.getNumResults() == 0 || !ifOp.elseBlock()) + return false; + if (!canSpeculateForSelect(ifOp.thenBlock()) || + !canSpeculateForSelect(ifOp.elseBlock())) + return false; + + Location loc = ifOp.getLoc(); + OpBuilder::InsertionGuard guard(b); + b.setInsertionPointAfter(ifOp); + + SmallVector thenResults, elseResults; + + auto cloneAfter = [&](Block *block, SmallVectorImpl &results) { + IRMapping vmap; + for (Operation &op : block->getOperations()) { + if (auto yieldOp = dyn_cast(op)) { + for (Value result : yieldOp.getOperands()) + results.push_back(vmap.lookupOrDefault(result)); + } else { + b.clone(op, vmap); + } + } + }; + + cloneAfter(ifOp.thenBlock(), thenResults); + cloneAfter(ifOp.elseBlock(), elseResults); + + if (thenResults.size() != ifOp.getNumResults() || + elseResults.size() != ifOp.getNumResults()) + return false; + + for (auto ifResult : llvm::enumerate(ifOp.getResults())) { + Value newResult = b.create( + loc, ifOp.getCondition(), thenResults[ifResult.index()], + elseResults[ifResult.index()]); + ifResult.value().replaceAllUsesWith(newResult); + } + + ifOp.erase(); + return true; +} + +static bool foldScalarAffineIf(affine::AffineIfOp ifOp, OpBuilder &b) { + if (ifOp.getNumResults() == 0 || !ifOp.hasElse()) + return false; + if (!canSpeculateForSelect(ifOp.getThenBlock()) || + !canSpeculateForSelect(ifOp.getElseBlock())) + return false; + + Location loc = ifOp.getLoc(); + OpBuilder::InsertionGuard guard(b); + b.setInsertionPointAfter(ifOp); + + Value condition = materializeIntegerSetCondition( + loc, ifOp.getIntegerSet(), ifOp.getOperands(), b); + + SmallVector thenResults, elseResults; + + auto cloneAfter = [&](Block *block, SmallVectorImpl &results) { + IRMapping vmap; + for (Operation &op : block->getOperations()) { + if (auto yieldOp = dyn_cast(op)) { + for (Value result : yieldOp.getOperands()) + results.push_back(vmap.lookupOrDefault(result)); + } else { + b.clone(op, vmap); + } + } + }; + + cloneAfter(ifOp.getThenBlock(), thenResults); + cloneAfter(ifOp.getElseBlock(), elseResults); + + if (thenResults.size() != ifOp.getNumResults() || + elseResults.size() != ifOp.getNumResults()) + return false; + + for (auto ifResult : llvm::enumerate(ifOp.getResults())) { + Value newResult = b.create( + loc, condition, thenResults[ifResult.index()], + elseResults[ifResult.index()]); + ifResult.value().replaceAllUsesWith(newResult); + } + + ifOp.erase(); + return true; +} + +static bool foldSCFIf(scf::IfOp ifOp, OpBuilder &b) { + Location loc = ifOp.getLoc(); + + LLVM_DEBUG(llvm::dbgs() << "Working on scf.if:\n" << ifOp << "\n"); + + // Fold scalar store-update idioms such as softmax/reduce-max: + // if (%candidate > %old) store %candidate, %slot + // into: + // %selected = arith.select %cond, %candidate, %old + // store %selected, %slot + // This is intentionally narrower than generic store speculation: the + // implicit else must be the previously loaded value from the same address. + if (succeeded(foldGuardedStoreUpdate(ifOp, b))) + return true; + + if (foldSingleStoreIfToSelect(ifOp, b)) + return true; + + if (foldScalarSCFIf(ifOp, b)) + return true; + + if (!hasSingleStore(ifOp.thenBlock()) || + (ifOp.elseBlock() && !hasSingleStore(ifOp.elseBlock()))) + return false; + + // Replacing control flow with select speculates both sides. Keep this path + // narrow by refusing stores, calls, and nested regions. + if (!canSpeculateForSelect(ifOp.thenBlock()) || + (ifOp.elseBlock() && !canSpeculateForSelect(ifOp.elseBlock()))) + return false; + + if (ifOp.getNumResults() == 0) + return false; + + OpBuilder::InsertionGuard guard(b); + b.setInsertionPointAfter(ifOp); + + SmallVector thenResults, elseResults; + + auto cloneAfter = [&](Block *block, SmallVectorImpl &results) { + IRMapping vmap; + for (Operation &op : block->getOperations()) { + if (auto yieldOp = dyn_cast(op)) { + for (Value result : yieldOp.getOperands()) + results.push_back(vmap.lookupOrDefault(result)); + } else { + b.clone(op, vmap); + } + } + }; + + cloneAfter(ifOp.thenBlock(), thenResults); + + if (ifOp.elseBlock()) { + cloneAfter(ifOp.elseBlock(), elseResults); + + for (auto ifResult : llvm::enumerate(ifOp.getResults())) { + Value newResult = b.create( + loc, ifOp.getCondition(), thenResults[ifResult.index()], + elseResults[ifResult.index()]); + ifResult.value().replaceAllUsesWith(newResult); + } + } + + ifOp.erase(); + return true; +} + +static bool processFold(func::FuncOp f, OpBuilder &b) { + bool changed = false; + + f.walk([&](scf::IfOp ifOp) { + if (changed) + return; + + changed = foldSCFIf(ifOp, b); + }); + + return changed; +} + +static bool processAffineFold(func::FuncOp f, OpBuilder &b) { + bool changed = false; + + f.walk([&](affine::AffineIfOp ifOp) { + if (changed) + return; + + changed = foldScalarAffineIf(ifOp, b); + }); + + return changed; +} + +namespace { +struct FoldSCFIf : public FoldSCFIfBase { + void runOnOperation() override { + Operation *op = getOperation(); + SmallVector funcs; + + if (auto func = dyn_cast(op)) + funcs.push_back(func); + else + op->walk([&](func::FuncOp func) { funcs.push_back(func); }); + + for (func::FuncOp func : funcs) { + if (func->hasAttr("scop.ignored")) + continue; + + OpBuilder builder(func.getContext()); + + while (processLiftStoreOps(func, builder)) + ; + + OpPassManager pm(func.getOperationName()); + pm.addPass(affine::createAffineScalarReplacementPass()); + if (failed(runPipeline(pm, func))) + return signalPassFailure(); + + while (processFold(func, builder)) + ; + while (processAffineFold(func, builder)) + ; + } + } +}; +} // namespace + +namespace mlir { +namespace polygeist { +std::unique_ptr createFoldSCFIfPass() { + return std::make_unique(); +} +} // namespace polygeist +} // namespace mlir diff --git a/lib/polygeist/Passes/KernelLaunchLoweringUtils.cpp b/lib/polygeist/Passes/KernelLaunchLoweringUtils.cpp new file mode 100644 index 000000000000..9252b207e470 --- /dev/null +++ b/lib/polygeist/Passes/KernelLaunchLoweringUtils.cpp @@ -0,0 +1,280 @@ +//===- KernelLaunchLoweringUtils.cpp - shared kernel.launch helpers ------===// + +#include "KernelLaunchLoweringUtils.h" + +#include "mlir/Dialect/Arith/IR/Arith.h" +#include "mlir/Dialect/LLVMIR/LLVMDialect.h" +#include "mlir/Dialect/MemRef/IR/MemRef.h" +#include "polygeist/Kernel/KernelOps.h" + +using namespace mlir; +using namespace mlir::polygeist; +using namespace mlir::polygeist::kernel; + +namespace mlir { +namespace polygeist { + +func::FuncOp ensureShimDecl(ModuleOp module, StringRef shimSym, + TypeRange argTypes, OpBuilder &builder) { + if (auto existing = module.lookupSymbol(shimSym)) + return existing; + OpBuilder::InsertionGuard g(builder); + builder.setInsertionPointToEnd(module.getBody()); + auto fnType = builder.getFunctionType(argTypes, /*results=*/{}); + auto fn = builder.create(module.getLoc(), shimSym, fnType); + fn.setPrivate(); + return fn; +} + +Value memrefBasePtr(OpBuilder &b, Location loc, Value m) { + auto mrTy = cast(m.getType()); + auto eltTy = mrTy.getElementType(); + Value alignedIdx = b.create(loc, m); + Value alignedI64 = b.create(loc, b.getI64Type(), alignedIdx); + auto md = b.create(loc, m); + Value offsetIdx = md.getOffset(); + Value offsetI64 = b.create(loc, b.getI64Type(), offsetIdx); + unsigned bits = eltTy.getIntOrFloatBitWidth(); + Value eltBytes = b.create( + loc, b.getI64Type(), b.getI64IntegerAttr(bits / 8)); + Value byteOff = b.create(loc, offsetI64, eltBytes); + Value byteAddr = b.create(loc, alignedI64, byteOff); + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + return b.create(loc, ptrTy, byteAddr); +} + +static LogicalResult lowerCudnnConv2DNtap(LaunchOp launch, ModuleOp module, + StringRef shimSymbol, + unsigned filterWidth, + bool allowLegacy9tap) { + unsigned taps = filterWidth * filterWidth; + unsigned weightedOperands = taps + 1 + taps; + unsigned n = launch.getNumOperands(); + if (n != weightedOperands && !(allowLegacy9tap && n == 10)) + return launch.emitError("cudnnConvolution2D_") + << taps << "tap: expected " << weightedOperands << " operands " + << "(" << taps << " input subviews + 1 output + " << taps + << " weights)" + << (allowLegacy9tap ? " or legacy 10 operands; got " : "; got ") + << n; + if (launch.getNumResults() != 0) + return launch.emitError("cudnnConvolution2D_") + << taps << "tap: expected memref-form (void) launch; got " + << launch.getNumResults() << " result(s)"; + + auto firstMr = dyn_cast(launch.getOperand(0).getType()); + if (!firstMr || firstMr.getRank() != 2) + return launch.emitError("cudnnConvolution2D_") + << taps << "tap: operand 0 must be a 2D memref"; + Type elemTy = firstMr.getElementType(); + bool isSupportedInt = false; + if (auto intTy = dyn_cast(elemTy)) { + unsigned w = intTy.getWidth(); + isSupportedInt = (w == 32 || w == 16 || w == 8); + } + if (!(elemTy.isF64() || elemTy.isF32() || elemTy.isF16() || + elemTy.isBF16() || isSupportedInt)) + return launch.emitError("cudnnConvolution2D_") + << taps + << "tap: element type must be f64/f32/f16/bf16/i32/i16/i8 (got " + << elemTy << ")"; + for (unsigned i = 0; i < taps + 1; ++i) { + auto mr = dyn_cast(launch.getOperand(i).getType()); + if (!mr || mr.getRank() != 2 || mr.getElementType() != elemTy) + return launch.emitError("cudnnConvolution2D_") + << taps << "tap: input/output memref operands must be 2D " + << "memrefs with matching element type"; + } + if (n == weightedOperands) { + for (unsigned i = taps + 1; i < weightedOperands; ++i) { + if (launch.getOperand(i).getType() != elemTy) + return launch.emitError("cudnnConvolution2D_") + << taps << "tap: weight operands must match memref elem type"; + } + } + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value A_subview = launch.getOperand(0); + Value B_subview = launch.getOperand(taps); + + Value A_ptr = memrefBasePtr(b, loc, A_subview); + Value B_ptr = memrefBasePtr(b, loc, B_subview); + + Value c0 = b.create(loc, 0); + Value c1 = b.create(loc, 1); + Value border_i32 = b.create( + loc, b.getI32Type(), b.getI32IntegerAttr(filterWidth - 1)); + Value h_idx = b.create(loc, B_subview, c0); + Value w_idx = b.create(loc, B_subview, c1); + Value h_i32 = b.create(loc, b.getI32Type(), h_idx); + Value w_i32 = b.create(loc, b.getI32Type(), w_idx); + Value M = b.create(loc, h_i32, border_i32); + Value N = b.create(loc, w_i32, border_i32); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + if (n == weightedOperands) { + SmallVector argTypes = {b.getI32Type(), b.getI32Type()}; + for (unsigned i = 0; i < taps; ++i) argTypes.push_back(elemTy); + argTypes.push_back(ptrTy); + argTypes.push_back(ptrTy); + func::FuncOp shim = ensureShimDecl(module, shimSymbol, argTypes, b); + SmallVector callOperands = {M, N}; + for (unsigned i = taps + 1; i < weightedOperands; ++i) + callOperands.push_back(launch.getOperand(i)); + callOperands.push_back(A_ptr); + callOperands.push_back(B_ptr); + b.create(loc, shim, callOperands); + } else { + if (!elemTy.isF64()) + return launch.emitError( + "cudnnConvolution2D_9tap: legacy 10-arg form requires f64 elements; " + "got ") + << elemTy; + SmallVector argTypes = {b.getI32Type(), b.getI32Type(), + ptrTy, ptrTy}; + func::FuncOp shim = ensureShimDecl( + module, "polygeist_cudnn_conv2d_polybench9tap", argTypes, b); + b.create(loc, shim, ValueRange{M, N, A_ptr, B_ptr}); + } + + launch.erase(); + return success(); +} + +LogicalResult lowerCudnnConv2D9tap(LaunchOp launch, ModuleOp module, + StringRef shimSymbol) { + return lowerCudnnConv2DNtap(launch, module, shimSymbol, + /*filterWidth=*/3, /*allowLegacy9tap=*/true); +} + +LogicalResult lowerCudnnConv2D25tap(LaunchOp launch, ModuleOp module, + StringRef shimSymbol) { + return lowerCudnnConv2DNtap(launch, module, shimSymbol, + /*filterWidth=*/5, /*allowLegacy9tap=*/false); +} + +LogicalResult lowerCudnnConv2DNtapPacked(LaunchOp launch, ModuleOp module, + StringRef shimSymbol) { + if (launch.getNumOperands() != 4) + return launch.emitError("cudnnConvolution2D_ntap: expected 4 operands " + "(input subview, output subview, weights, K); got ") + << launch.getNumOperands(); + if (launch.getNumResults() != 0) + return launch.emitError("cudnnConvolution2D_ntap: expected memref-form " + "(void) launch; got ") + << launch.getNumResults() << " result(s)"; + + Value A_subview = launch.getOperand(0); + Value B_subview = launch.getOperand(1); + Value W_memref = launch.getOperand(2); + Value K = launch.getOperand(3); + + auto aTy = dyn_cast(A_subview.getType()); + auto bTy = dyn_cast(B_subview.getType()); + auto wTy = dyn_cast(W_memref.getType()); + if (!aTy || aTy.getRank() != 2 || !bTy || bTy.getRank() != 2) + return launch.emitError( + "cudnnConvolution2D_ntap: input/output must be 2D memrefs"); + if (!wTy || wTy.getRank() != 1) + return launch.emitError( + "cudnnConvolution2D_ntap: weights must be a 1D memref"); + Type elemTy = aTy.getElementType(); + if (bTy.getElementType() != elemTy || wTy.getElementType() != elemTy) + return launch.emitError( + "cudnnConvolution2D_ntap: input/output/weights dtypes must match"); + if (!(elemTy.isF64() || elemTy.isF32())) + return launch.emitError( + "cudnnConvolution2D_ntap: only f64/f32 packed weights are supported"); + if (!K.getType().isInteger(32)) + return launch.emitError("cudnnConvolution2D_ntap: K must be i32"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value A_ptr = memrefBasePtr(b, loc, A_subview); + Value B_ptr = memrefBasePtr(b, loc, B_subview); + Value W_ptr = memrefBasePtr(b, loc, W_memref); + + Value c0 = b.create(loc, 0); + Value c1 = b.create(loc, 1); + Value oneI32 = b.create( + loc, b.getI32Type(), b.getI32IntegerAttr(1)); + Value border = b.create(loc, K, oneI32); + Value h_idx = b.create(loc, B_subview, c0); + Value w_idx = b.create(loc, B_subview, c1); + Value h_i32 = b.create(loc, b.getI32Type(), h_idx); + Value w_i32 = b.create(loc, b.getI32Type(), w_idx); + Value M = b.create(loc, h_i32, border); + Value N = b.create(loc, w_i32, border); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), b.getI32Type(), + b.getI32Type(), ptrTy, ptrTy, ptrTy}; + func::FuncOp shim = ensureShimDecl(module, shimSymbol, argTypes, b); + b.create(loc, shim, ValueRange{M, N, K, W_ptr, A_ptr, B_ptr}); + + launch.erase(); + return success(); +} + +LogicalResult lowerImageFilter2Operand(kernel::LaunchOp launch, + ModuleOp module, + StringRef shimSymbol) { + unsigned n = launch.getNumOperands(); + if (n != 2) + return launch.emitError( + "image-filter-2op lowering: expected 2 operands " + "(input subview + output subview); got ") + << n; + if (launch.getNumResults() != 0) + return launch.emitError( + "image-filter-2op lowering: expected memref-form (void) " + "launch; got ") + << launch.getNumResults() << " result(s)"; + + auto inMr = dyn_cast(launch.getOperand(0).getType()); + auto outMr = dyn_cast(launch.getOperand(1).getType()); + if (!inMr || inMr.getRank() != 2 || !outMr || outMr.getRank() != 2) + return launch.emitError( + "image-filter-2op lowering: both operands must be 2D memrefs"); + Type elemTy = inMr.getElementType(); + if (outMr.getElementType() != elemTy) + return launch.emitError( + "image-filter-2op lowering: input/output dtypes must match"); + auto intTy = dyn_cast(elemTy); + if (!intTy || !(intTy.getWidth() == 8 || intTy.getWidth() == 16)) + return launch.emitError( + "image-filter-2op lowering: only i8 / i16 supported by PVA"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value A_subview = launch.getOperand(0); + Value B_subview = launch.getOperand(1); + + Value A_ptr = memrefBasePtr(b, loc, A_subview); + Value B_ptr = memrefBasePtr(b, loc, B_subview); + + // Same dim-recovery convention as the 9-tap conv lowering: the output + // subview describes the (M-2)×(N-2) interior, so M/N = dim + 2. + Value c0 = b.create(loc, 0); + Value c1 = b.create(loc, 1); + Value c2_i32 = b.create(loc, b.getI32Type(), + b.getI32IntegerAttr(2)); + Value h_idx = b.create(loc, B_subview, c0); + Value w_idx = b.create(loc, B_subview, c1); + Value h_i32 = b.create(loc, b.getI32Type(), h_idx); + Value w_i32 = b.create(loc, b.getI32Type(), w_idx); + Value M = b.create(loc, h_i32, c2_i32); + Value N = b.create(loc, w_i32, c2_i32); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), b.getI32Type(), + ptrTy, ptrTy}; + func::FuncOp shim = ensureShimDecl(module, shimSymbol, argTypes, b); + b.create(loc, shim, ValueRange{M, N, A_ptr, B_ptr}); + launch.erase(); + return success(); +} + +} // namespace polygeist +} // namespace mlir diff --git a/lib/polygeist/Passes/KernelLaunchLoweringUtils.h b/lib/polygeist/Passes/KernelLaunchLoweringUtils.h new file mode 100644 index 000000000000..95d52b3531fe --- /dev/null +++ b/lib/polygeist/Passes/KernelLaunchLoweringUtils.h @@ -0,0 +1,66 @@ +//===- KernelLaunchLoweringUtils.h - shared kernel.launch helpers --*- C++ -*-===// +// +// Helpers shared by the kernel.launch → runtime-shim ABI lowering passes: +// - LowerKernelLaunchToCuBLAS (most matched library ops) +// - LowerKernelLaunchToPVA (int8/int16 conv2d → PVA Solutions) +// +// All three helpers are backend-agnostic — they take the target shim symbol +// (and arg types) as arguments. Per-backend passes own the libSym → shim +// symbol mapping and the top-level dispatch. +// +//===----------------------------------------------------------------------===// + +#ifndef DIALECT_POLYGEIST_TRANSFORMS_KERNEL_LAUNCH_LOWERING_UTILS_H +#define DIALECT_POLYGEIST_TRANSFORMS_KERNEL_LAUNCH_LOWERING_UTILS_H + +#include "mlir/Dialect/Func/IR/FuncOps.h" +#include "mlir/IR/Builders.h" +#include "mlir/IR/BuiltinOps.h" +#include "mlir/Support/LogicalResult.h" +#include "polygeist/Kernel/KernelOps.h" + +namespace mlir { +namespace polygeist { + +// Get-or-create a `func.func private @()` declaration at +// module scope. Idempotent. +func::FuncOp ensureShimDecl(ModuleOp module, StringRef shimSym, + TypeRange argTypes, OpBuilder &builder); + +// Extract a raw `!llvm.ptr` to the FIRST DATA ELEMENT of a memref: +// aligned_ptr (as index) + offset*sizeof(elt) → !llvm.ptr. +Value memrefBasePtr(OpBuilder &b, Location loc, Value m); + +// Lower a kernel.launch carrying the matcher's 9-tap conv shape to a +// func.call against the supplied shim symbol. Backend-agnostic: the caller +// picks `shimSymbol` based on element type / target accelerator. Handles +// both the new 19-operand form (M, N + 9 input subviews + 1 output + 9 +// weights) and the legacy 10-operand f64 form (hardcoded polybench +// weights inside the shim). +LogicalResult lowerCudnnConv2D9tap(kernel::LaunchOp launch, ModuleOp module, + StringRef shimSymbol); + +// Same convention as lowerCudnnConv2D9tap, but for 5x5 / 25-tap stencils. +// The launch has 25 input subviews, one output subview, then 25 scalar weights. +LogicalResult lowerCudnnConv2D25tap(kernel::LaunchOp launch, ModuleOp module, + StringRef shimSymbol); + +// Lower a generalized packed-weight KxK conv2d stencil launch: +// (top-left input subview, output interior subview, weights memref, K) +// to a runtime shim `(M, N, K, weights*, input*, output*)`. +LogicalResult lowerCudnnConv2DNtapPacked(kernel::LaunchOp launch, + ModuleOp module, + StringRef shimSymbol); + +// Lower a kernel.launch carrying a "uniform-weight K×K image filter" shape +// (1 input subview + 1 output subview, no scalar weights) to a func.call +// whose signature is `(M, N, A_ptr, B_ptr)`. Used by the PVA pass for +// pvaBoxFilter-style ops where the kernel coefficients are implicit. +LogicalResult lowerImageFilter2Operand(kernel::LaunchOp launch, + ModuleOp module, + StringRef shimSymbol); + +} // namespace polygeist +} // namespace mlir + +#endif // DIALECT_POLYGEIST_TRANSFORMS_KERNEL_LAUNCH_LOWERING_UTILS_H diff --git a/lib/polygeist/Passes/LinalgDebufferize.cpp b/lib/polygeist/Passes/LinalgDebufferize.cpp new file mode 100644 index 000000000000..cf29e3a18ef7 --- /dev/null +++ b/lib/polygeist/Passes/LinalgDebufferize.cpp @@ -0,0 +1,3003 @@ +#include "PassDetails.h" + +#include "mlir/Dialect/Affine/IR/AffineOps.h" +#include "mlir/Dialect/Arith/IR/Arith.h" +#include "mlir/Dialect/Bufferization/IR/Bufferization.h" +#include "mlir/Dialect/Func/IR/FuncOps.h" +#include "mlir/Dialect/LLVMIR/LLVMDialect.h" +#include "mlir/Dialect/Linalg/IR/Linalg.h" +#include "mlir/Dialect/MemRef/IR/MemRef.h" +#include "mlir/Dialect/SCF/IR/SCF.h" +#include "mlir/Dialect/SCF/Transforms/Passes.h" +#include "mlir/Dialect/Tensor/IR/Tensor.h" +#include "mlir/IR/AffineExpr.h" +#include "mlir/IR/Dominance.h" +#include "mlir/IR/IRMapping.h" +#include "mlir/IR/Operation.h" +#include "mlir/Transforms/DialectConversion.h" +#include "mlir/Transforms/GreedyPatternRewriteDriver.h" +#include "polygeist/Ops.h" +#include "polygeist/Passes/Passes.h" +#include "llvm/Support/Debug.h" + +#define DEBUG_TYPE "linalg-debufferize" + +using namespace mlir; +using namespace mlir::arith; +using namespace polygeist; +using namespace affine; +using namespace linalg; +using namespace tensor; +using namespace bufferization; + +using opTuple = std::tuple; //First: result, Second: prev_tensor ? + +bool isCaptured(Value v, Operation *potentialUser = nullptr, + bool *seenuse = nullptr); + +//===----------------------------------------------------------------------===// +// Region Context Tracking for Correct SSA Threading +//===----------------------------------------------------------------------===// + +/// Tracks tensor state per region in a tree structure +/// This prevents sibling if regions from polluting each other's tensor state +struct RegionTensorState { + Value tensor; + bool valid = false; +}; + +/// Tracks pending yield updates for scf.if operations +struct PendingIfInfo { + scf::IfOp ifOp; + Value entryTensor; // Tensor value before entering the if + Value thenResult; // Final tensor value from THEN branch (or entryTensor if no users) + Value elseResult; // Final tensor value from ELSE branch (or entryTensor if no users) + bool thenProcessed = false; + bool elseProcessed = false; +}; + +/// Check if an operation is inside a specific region (directly or nested) +bool isInRegion(Operation* op, Region* region) { + return region->isAncestor(op->getParentRegion()); +} + +/// Check if an operation is inside the THEN branch of an scf.if +bool isInIfThenBranch(Operation* op, scf::IfOp ifOp) { + bool result = ifOp.getThenRegion().isAncestor(op->getParentRegion()); + LLVM_DEBUG(llvm::dbgs() << " isInIfThenBranch(" << op->getName() << " at " << op->getLoc() + << ", if at " << ifOp.getLoc() << ") = " << result << "\n"); + return result; +} + +/// Check if an operation is inside the ELSE branch of an scf.if +bool isInIfElseBranch(Operation* op, scf::IfOp ifOp) { + bool result = ifOp.getElseRegion().isAncestor(op->getParentRegion()); + LLVM_DEBUG(llvm::dbgs() << " isInIfElseBranch(" << op->getName() << " at " << op->getLoc() + << ", if at " << ifOp.getLoc() << ") = " << result << "\n"); + return result; +} + +/// Find the innermost scf.if that contains this operation +scf::IfOp findContainingIf(Operation* op) { + Operation* parent = op->getParentOp(); + while (parent) { + if (auto ifOp = dyn_cast(parent)) + return ifOp; + parent = parent->getParentOp(); + } + return nullptr; +} + +/// Get all scf.if ops between an operation and a root region (innermost first) +SmallVector getContainingIfs(Operation* op, Region* rootRegion) { + SmallVector result; + Region* current = op->getParentRegion(); + while (current && current != rootRegion) { + if (auto ifOp = dyn_cast(current->getParentOp())) { + result.push_back(ifOp); + } + current = current->getParentOp()->getParentRegion(); + } + return result; +} + +/// Get the current tensor for a region by tracing up the tree until we find a valid entry +/// This ensures sibling regions don't pollute each other - each inherits from parent only +Value getCurrentTensorForRegion(Region* region, + llvm::DenseMap& regionTensorTree, + Value fallbackTensor) { + Region* current = region; + while (current) { + auto it = regionTensorTree.find(current); + if (it != regionTensorTree.end() && it->second.valid) { + LLVM_DEBUG(llvm::dbgs() << " getCurrentTensorForRegion: found valid tensor in region\n"); + return it->second.tensor; + } + // Go to parent region + Operation* parentOp = current->getParentOp(); + if (!parentOp) break; + current = parentOp->getParentRegion(); + } + LLVM_DEBUG(llvm::dbgs() << " getCurrentTensorForRegion: using fallback tensor\n"); + return fallbackTensor; +} + +/// Set the tensor state for a region +void setRegionTensor(Region* region, Value tensor, + llvm::DenseMap& regionTensorTree) { + regionTensorTree[region] = RegionTensorState{tensor, true}; + LLVM_DEBUG(llvm::dbgs() << " setRegionTensor: set tensor for region\n"); +} + +/// Record the current tensor value for all containing if branches +/// This should be called after any tensor modification (store, linalg.generic, etc.) +void recordBranchResult(Operation* user, Value newTensor, + llvm::DenseMap& pendingIfs, + Region* rootRegion) { + LLVM_DEBUG(llvm::dbgs() << " recordBranchResult called for user: " << user->getName() << " at " << user->getLoc() << "\n"); + LLVM_DEBUG(llvm::dbgs() << " newTensor: " << newTensor << "\n"); + + // For each containing if, record the tensor in the appropriate branch + auto containingIfs = getContainingIfs(user, rootRegion); + LLVM_DEBUG(llvm::dbgs() << " Found " << containingIfs.size() << " containing ifs\n"); + + for (scf::IfOp ifOp : containingIfs) { + auto it = pendingIfs.find(ifOp); + if (it != pendingIfs.end()) { + PendingIfInfo& info = it->second; + if (isInIfThenBranch(user, ifOp)) { + LLVM_DEBUG(llvm::dbgs() << " Recording THEN result for if at " << ifOp.getLoc() << "\n"); + info.thenResult = newTensor; + info.thenProcessed = true; + LLVM_DEBUG(llvm::dbgs() << " Set thenResult, thenProcessed=true\n"); + } else if (isInIfElseBranch(user, ifOp)) { + LLVM_DEBUG(llvm::dbgs() << " Recording ELSE result for if at " << ifOp.getLoc() << "\n"); + info.elseResult = newTensor; + info.elseProcessed = true; + LLVM_DEBUG(llvm::dbgs() << " Set elseResult, elseProcessed=true\n"); + } else { + LLVM_DEBUG(llvm::dbgs() << " WARNING: User not in THEN or ELSE branch of if at " << ifOp.getLoc() << "!\n"); + } + } else { + LLVM_DEBUG(llvm::dbgs() << " No pending info for if at " << ifOp.getLoc() << " (skipping)\n"); + } + } +} + +//===----------------------------------------------------------------------===// +// Subview Chain Tracing and Affine Map Composition +//===----------------------------------------------------------------------===// + +/// Structure to hold information about a chain of submaps from a leaf memref +/// back to the root memref (alloca/alloc/function arg) +struct SubmapChainInfo { + Value rootMemref; // The root alloca/alloc/arg + SmallVector submaps; // Chain of polygeist.submap ops (root to leaf) + + bool isEmpty() const { return submaps.empty(); } +}; + +/// Trace from a memref value back through submap operations to find the root +/// Returns the chain info with all operations collected +SubmapChainInfo traceSubmapChainToRoot(Value memref) { + SubmapChainInfo info; + Value current = memref; + + // Walk up the def-use chain through submaps + while (auto submapOp = current.getDefiningOp()) { + info.submaps.push_back(submapOp); + current = submapOp.getViewSource(); + } + + info.rootMemref = current; + + // Reverse so ops are in root-to-leaf order + std::reverse(info.submaps.begin(), info.submaps.end()); + + return info; +} + +/// Get the tensor type for a submap chain's result +RankedTensorType getSubmapChainTensorType(const SubmapChainInfo &chain) { + if (chain.isEmpty()) { + auto memrefType = chain.rootMemref.getType().cast(); + return RankedTensorType::get(memrefType.getShape(), + memrefType.getElementType()); + } + + // Get type from the last submap + auto leafSubmap = chain.submaps.back(); + auto resultType = leafSubmap.getType().cast(); + return RankedTensorType::get(resultType.getShape(), + resultType.getElementType()); +} + +bool isAncestor(Operation *potentialAncestor, Operation *op) { + Operation *current = op->getParentOp(); + while (current != nullptr) { + if (current == potentialAncestor) + return true; + current = current->getParentOp(); + } + return false; +} + +//Checks if a comes before b +bool comesBefore(Operation *a, Operation *b) { + if (a == b) return false; + + if (isAncestor(a, b)) return true; + if (isAncestor(b, a)) return false; + + Operation *aParent = a->getParentOp(); + Operation *bParent = b->getParentOp(); + // Walk up b's hierarchy until we reach a's level + Operation *bAncestor = b; + //We traverse B's ancestors here + while (Operation *parent = bAncestor->getParentOp()) { + if (parent == aParent) { + // Compare positions within aParent's regions/blocks + Region *aRegion = a->getParentRegion(); + Region *bRegion = bAncestor->getParentRegion(); + + if (aRegion == bRegion) { + // Same region: compare block order + Block *aBlock = a->getBlock(); + Block *bBlock = bAncestor->getBlock(); + if (aBlock != bBlock) { + auto get_block_pos = [](Region *region, Block *block) { + auto &blocks = region->getBlocks(); + auto it = llvm::find_if(blocks, [block](Block &b) { + return &b == block; // Address comparison + }); + assert(it != blocks.end() && "Block not found in region"); + return std::distance(blocks.begin(), it); + }; + return get_block_pos(aRegion, aBlock) < + get_block_pos(bRegion, bBlock); + }; + // Same block: compare operation order + return a->isBeforeInBlock(bAncestor); + } + + // Different regions: compare region order + auto compareRegions = [parent](Region *x, Region *y) { + auto get_region_position = [](Operation *parent, Region *target) { + auto regions = parent->getRegions(); // Get reference to region list + auto begin = regions.begin(); + auto it = llvm::find_if(regions, [&](Region &r) { + return &r == target; + }); + return std::distance(begin, it); + }; + return get_region_position(parent, x) < + get_region_position(parent, y); + }; + return compareRegions(aRegion, bRegion); + } + bAncestor = parent; + } + + Operation *aAncestor = a; + //We traverse A's ancestors here + while (Operation *parent = aAncestor->getParentOp()) { + if (parent == bParent) { + // Compare positions within aParent's regions/blocks + Region *bRegion = b->getParentRegion(); + Region *aRegion = aAncestor->getParentRegion(); + + if (aRegion == bRegion) { + // Same region: compare block order + Block *bBlock = b->getBlock(); + Block *aBlock = aAncestor->getBlock(); + if (aBlock != bBlock) { + auto get_block_pos = [](Region *region, Block *block) { + auto &blocks = region->getBlocks(); + auto it = llvm::find_if(blocks, [block](Block &b) { + return &b == block; // Address comparison + }); + assert(it != blocks.end() && "Block not found in region"); + return std::distance(blocks.begin(), it); + }; + return !(get_block_pos(bRegion, bBlock) < + get_block_pos(aRegion, aBlock)); + }; + // Same block: compare operation order + return !b->isBeforeInBlock(aAncestor); + } + + // Different regions: compare region order + auto compareRegions = [parent](Region *x, Region *y) { + auto get_region_position = [](Operation *parent, Region *target) { + auto regions = parent->getRegions(); // Get reference to region list + auto begin = regions.begin(); + auto it = llvm::find_if(regions, [&](Region &r) { + return &r == target; + }); + return std::distance(begin, it); + }; + return get_region_position(parent, x) < + get_region_position(parent, y); + }; + return !compareRegions(bRegion, aRegion); + } + aAncestor = parent; + } + + //llvm_unreachable("Operations do not share a common ancestor"); + //// Recursive case: compare parent operations + return comesBefore(aParent, bParent); +} + +std::vector getSortedUsers(Value val) { + std::vector users; + for (Operation *user : val.getUsers()) { + //This logic is to prevent duplication of users + auto it = std::find_if(users.begin(), users.end(), + [user](const Operation* op) { + return op == user; + }); + if(it == users.end()) + users.push_back(user); + } + + std::sort(users.begin(), users.end(), [](Operation *a, Operation *b) { + return comesBefore(a,b); + }); + + return users; +} + +// std::vector getSortedUsers(Operation *op) { +// // Find the parent function +// auto funcOp = op->getParentOfType(); +// if (!funcOp) +// return {}; + +// // Map to store order of operations +// llvm::DenseMap opOrder; +// size_t order = 0; + +// funcOp.walk([&](Operation *curOp) { opOrder[curOp] = order++; }); + +// std::vector sortedUsers(op->getUsers().begin(), +// op->getUsers().end()); + +// std::sort( +// sortedUsers.begin(), sortedUsers.end(), +// [&](Operation *a, Operation *b) { return opOrder[a] < opOrder[b]; }); + +// return sortedUsers; +// } + +Region* findCommonAncestorRegion(Operation* a, Operation* b) { + DenseMap regionCounts; + + // Walk up from operation A + Operation* currentOp = a; + while (Region* region = currentOp->getParentRegion()) { + regionCounts[region]++; + currentOp = region->getParentOp(); + } + + // Walk up from operation B to find common region + currentOp = b; + while (Region* region = currentOp->getParentRegion()) { + if (regionCounts.count(region)) + return region; + currentOp = region->getParentOp(); + } + return nullptr; +} + + +struct debufferizationAllocaRemoval : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(memref::AllocaOp allocaOp, + PatternRewriter &rewriter) const final { + Value allocaResult = allocaOp.getResult(); + bool userToTensorOp = false; + bool userCopyOp = false; + bool userOtherOp = false; + memref::CopyOp copyOp; + bufferization::ToTensorOp toTensorOp; + for (Operation *user : allocaResult.getUsers()) { + if (isa(user)) { + userToTensorOp = true; + toTensorOp = cast(user); + } + else if (isa(user)) { + userCopyOp = true; + copyOp = cast(user); + } + else + userOtherOp = true; + } + + if(!(!userOtherOp&&userCopyOp&&userToTensorOp)) + return failure(); + + auto emptyTensor = + rewriter.create(allocaOp.getLoc(),allocaOp.getType().getShape(), + allocaOp.getType().getElementType(), allocaOp.getDynamicSizes()); + + rewriter.replaceAllUsesWith(toTensorOp.getResult(), emptyTensor.getResult()); + + rewriter.eraseOp(copyOp); + rewriter.eraseOp(toTensorOp); + return success(); + } +}; + +void findUsersInRegion( + mlir::Value value, + mlir::Region& region, + llvm::SmallVectorImpl& users +) { + for (mlir::Block& block : region) { + for (mlir::Operation& op : block) { + for (mlir::Value operand : op.getOperands()) { + if (operand == value) { + users.push_back(&op); + break; // No need to check other operands for this op + } + } + + // Recursively check all sub-regions of this operation + for (mlir::Region& subRegion : op.getRegions()) { + findUsersInRegion(value, subRegion, users); + } + } + } +} + +/// Updated propagateValueThroughRegion that correctly handles both THEN and ELSE branches +/// +/// Key insight: When we call this function, currentValue is the tensor value computed +/// in some branch. We need to determine which branch it came from and yield correctly: +/// - If currentValue is in THEN branch: THEN yields currentValue, ELSE yields initTensor +/// - If currentValue is in ELSE branch: THEN yields initTensor, ELSE yields currentValue +void propagateValueThroughRegion(Value ¤tValue, SmallVector regions, + std::vector expandedUserList, + llvm::DenseMap opResultMap, + PatternRewriter &rewriter, + llvm::DenseMap &pendingIfs) { + LLVM_DEBUG(llvm::dbgs() << " propagateValueThroughRegion: Processing " << regions.size() << " regions\n"); + LLVM_DEBUG(llvm::dbgs() << " Current pendingIfs state (" << pendingIfs.size() << " entries):\n"); + // Note: We only print locations and processed flags, not the actual Values, + // because some Values might point to erased operations and crash when printed + LLVM_DEBUG({ + for (auto& [ifOp, info] : pendingIfs) { + llvm::dbgs() << " If at " << ifOp.getLoc() << ": "; + llvm::dbgs() << "thenProcessed=" << info.thenProcessed << ", "; + llvm::dbgs() << "elseProcessed=" << info.elseProcessed << "\n"; + } + }); + + for (Region* region : regions) { + LLVM_DEBUG(llvm::dbgs() << " Processing region in: " << region->getParentOp()->getName() << " at " << region->getParentOp()->getLoc() << "\n"); + Block& block = region->front(); + (void)block; // Silence unused warning + Operation *parentOp = region->getParentOp(); + + //Find init Tensor for the given for loop, i.e first match to expanded user list + mlir::Value initTensor; + int insertIdx = 0; + bool insertIdxFound = false; + for(auto user: expandedUserList) { + mlir::Region *opRegion = user->getParentRegion(); + if(region->isAncestor(opRegion)) { + insertIdxFound = true; + //Maintain a map data structure for tracking every user and if they have been processed then the corresponding result + auto it = opResultMap.find(user); + if(it == opResultMap.end()) + continue; + auto keys_value = it->second; + // op_result (std::get<0>) not used currently, only initTensor needed + initTensor = std::get<1>(keys_value); + break; + } + if(!insertIdxFound) + insertIdx++; + } + + if( auto prevIf = dyn_cast_or_null(parentOp)) { + LLVM_DEBUG(llvm::dbgs() << " Processing scf.if at " << prevIf.getLoc() << "\n"); + + // Check if we have pending info for this if (from branch processing) + auto pendingIt = pendingIfs.find(prevIf); + + Value thenValue, elseValue; + Value entryTensor = initTensor ? initTensor : currentValue; + + if (pendingIt != pendingIfs.end()) { + // We have recorded branch results - use them directly + PendingIfInfo& info = pendingIt->second; + entryTensor = info.entryTensor; + + LLVM_DEBUG(llvm::dbgs() << " PendingIfInfo state: thenProcessed=" << info.thenProcessed + << ", elseProcessed=" << info.elseProcessed << "\n"); + + // Use recorded values: if a branch was processed, use its result; otherwise use entry tensor + thenValue = info.thenProcessed ? info.thenResult : entryTensor; + elseValue = info.elseProcessed ? info.elseResult : entryTensor; + + LLVM_DEBUG(llvm::dbgs() << " Using recorded values for THEN and ELSE branches\n"); + } else { + // First time seeing this if - no users processed yet, use entry tensor for both + thenValue = entryTensor; + elseValue = entryTensor; + + // Record for future reference + PendingIfInfo info; + info.ifOp = prevIf; + info.entryTensor = entryTensor; + info.thenResult = entryTensor; + info.elseResult = entryTensor; + info.thenProcessed = false; + info.elseProcessed = false; + pendingIfs[prevIf] = info; + + LLVM_DEBUG(llvm::dbgs() << " First time seeing if, using entry tensor for both branches\n"); + } + + initTensor = entryTensor; + + LLVM_DEBUG(llvm::dbgs() << " Building new if with yields for THEN and ELSE branches\n"); + + auto prevResults = prevIf.getResults(); + SmallVector newResultTypes; + for (auto res : prevResults) + newResultTypes.push_back(res.getType()); + newResultTypes.push_back(currentValue.getType()); + + // Build yield values with correct values for each branch + auto thenYieldArgs = prevIf.thenYield().getOperands(); + SmallVector thenYieldValues; + for (const auto &it :thenYieldArgs) { + thenYieldValues.push_back(it); + } + thenYieldValues.push_back(thenValue); + + // Save whether prevIf has else BEFORE takeBody moves it + bool hadElse = !prevIf.getElseRegion().empty(); + + SmallVector elseYieldValues; + if(hadElse){ + auto elseYieldArgs = prevIf.elseYield().getOperands(); + for (const auto &it :elseYieldArgs) { + elseYieldValues.push_back(it); + } + } + elseYieldValues.push_back(elseValue); + + //Create new Ifop + rewriter.setInsertionPoint(prevIf); + auto newIf = rewriter.create(prevIf.getLoc(), + newResultTypes, // Combined types + prevIf.getCondition(), // New condition value + true + ); + if (newIf.thenBlock()) + rewriter.eraseBlock(newIf.thenBlock()); + + newIf.getThenRegion().takeBody(prevIf.getThenRegion()); + if(hadElse) + newIf.getElseRegion().takeBody(prevIf.getElseRegion()); + + + //Update yield ops + rewriter.setInsertionPointToEnd(newIf.thenBlock()); + rewriter.replaceOpWithNewOp(newIf.thenYield(), thenYieldValues); + if(hadElse) { + rewriter.setInsertionPointToEnd(newIf.elseBlock()); + rewriter.replaceOpWithNewOp(newIf.elseYield(), elseYieldValues); + } else { + rewriter.setInsertionPointToEnd(newIf.elseBlock()); + rewriter.create(newIf.getLoc(), elseYieldValues); + } + + // Replace uses of old if results with new ones and erase old if + for (auto [oldResult, newResult] : llvm::zip(prevIf.getResults(), newIf.getResults().drop_back())) { + oldResult.replaceAllUsesWith(newResult); + } + rewriter.eraseOp(prevIf); + + // Update pending info to reference new if + if (pendingIt != pendingIfs.end()) { + pendingIfs.erase(pendingIt); + } + pendingIfs[newIf] = PendingIfInfo{newIf, initTensor, thenValue, elseValue, true, true}; + + opResultMap[newIf] = std::make_tuple(newIf->getResult(newIf->getNumResults() - 1), initTensor); + currentValue = newIf->getResult(newIf->getNumResults() - 1); + + LLVM_DEBUG(llvm::dbgs() << " Created new if at " << newIf->getLoc() << " with " << newIf->getNumResults() << " results\n"); + + // FIX: Update outer ifs to use this if's result instead of raw inner tensor values + // This is critical for nested ifs - outer ifs should yield the inner if's RESULT, + // not values defined inside the inner if (which wouldn't dominate the yield) + for (auto& [outerIfOp, outerInfo] : pendingIfs) { + if (outerIfOp == newIf) continue; // Skip self + + // Check if newIf is nested inside outerIfOp + if (outerIfOp.getThenRegion().isAncestor(newIf->getParentRegion())) { + // newIf is in outer's THEN branch - outer should yield newIf's result + LLVM_DEBUG(llvm::dbgs() << " Updating outer if at " << outerIfOp.getLoc() << " THEN result\n"); + outerInfo.thenResult = currentValue; + outerInfo.thenProcessed = true; + } else if (outerIfOp.getElseRegion().isAncestor(newIf->getParentRegion())) { + // newIf is in outer's ELSE branch - outer should yield newIf's result + LLVM_DEBUG(llvm::dbgs() << " Updating outer if at " << outerIfOp.getLoc() << " ELSE result\n"); + outerInfo.elseResult = currentValue; + outerInfo.elseProcessed = true; + } + } + + } + else if (auto prevFor = dyn_cast_or_null(parentOp)) { + + //After first match, now find all the users of the init Tensor in a region. + llvm::SmallVector initOpUsers; + findUsersInRegion(initTensor, *region, initOpUsers); + + SmallVector newInitOperands = prevFor.getInitArgs(); + newInitOperands.push_back(initTensor); //Needs to be the earliest use inside the region. + //TODO: Does this require fix in if as well? + + SmallVector newResultTypes(prevFor.getResultTypes().begin(), prevFor.getResultTypes().end()); + newResultTypes.push_back(currentValue.getType()); + + rewriter.setInsertionPoint(prevFor); + scf::ForOp newLoop = rewriter.create( + prevFor.getLoc(), + prevFor.getLowerBound(), + prevFor.getUpperBound(), + prevFor.getStep(), + newInitOperands + ); + newLoop->setAttrs(prevFor.getOperation()->getAttrs()); + + // Create block with induction variable + original args + new arg + SmallVector blockArgTypes; + blockArgTypes.push_back(newLoop.getInductionVar().getType()); // IV + llvm::append_range(blockArgTypes, newLoop.getResultTypes()); // Original args + + // Transfer operations from original block to new block + Block *newBlock = &newLoop.getRegion().front(); + Block *originalBlock = &prevFor.getRegion().front(); + newBlock->getOperations().splice( + newBlock->end(), + originalBlock->getOperations() + ); + + // Replace uses of original block arguments with new ones + for (unsigned i = 0; i < originalBlock->getNumArguments()-1; ++i) { + originalBlock->getArgument(i + 1) // +1 for IV + .replaceAllUsesWith(newBlock->getArgument(i + 1)); + } + + auto yieldOp = cast(newBlock->getTerminator()); + SmallVector newYieldValues = yieldOp.getOperands(); + // Add new iteration arg from block arguments + newYieldValues.push_back(currentValue); + + rewriter.setInsertionPoint(yieldOp); + rewriter.replaceOpWithNewOp(yieldOp, newYieldValues); + + //Update users of initOp to use iterArgs + for(auto initOpUser: initOpUsers) { + // Iterate over all operands (both inputs and outputs) + for (const auto &en : llvm::enumerate(initOpUser->getOperands())) { + if (en.value() == initTensor) { + OpOperand &operand = initOpUser->getOpOperand(en.index()); + Value newValue = newLoop.getRegionIterArg(newLoop.getRegion().front().getNumArguments()-2); //-1 for IV + operand.set(newValue); + } + } + } + + //Update users of prev For loops results + for (auto [oldResult, newResult] : llvm::zip(prevFor.getResults(), newLoop.getResults().drop_back())) { + oldResult.replaceAllUsesWith(newResult); + } + rewriter.eraseOp(prevFor); + currentValue = newLoop.getResults().back(); + + //Store this in the user list for this region, need to create a data structure for users + opResultMap[newLoop] = std::make_tuple(currentValue, initTensor); + //Update the user list with the for Loop + expandedUserList.insert(expandedUserList.begin() + insertIdx, newLoop); + } + } +} + +bool isDirectUser(Operation *consumer, Operation *producer) { + for (Value operand : consumer->getOperands()) { + if (operand.getDefiningOp() == producer) + return true; + } + return false; +} + +/// Check if all users of a memref are supported for debufferization +bool areAllUsersSupportedForDebufferization(Value memVal) { + for (Operation *user : memVal.getUsers()) { + if (isa(user)) { + continue; + } + // Check if it's a subview that we should also trace + if (auto subviewOp = dyn_cast(user)) { + // Recursively check subview users + if (!areAllUsersSupportedForDebufferization(subviewOp.getResult())) { + return false; + } + continue; + } + LLVM_DEBUG(llvm::dbgs() << " Unsupported user: " << user->getName() << " at " << user->getLoc() << "\n"); + return false; + } + return true; +} + +/// Collect all memory operations (load/store/linalg.generic) on a memref +/// including those that access through subviews +/// Recursively collect all memory operations (load/store/linalg) that use a memref, +/// including through submap chains +void collectMemoryOpsRecursively(Value memVal, + SmallVectorImpl &memOps, + llvm::SmallPtrSetImpl &visited) { + for (Operation *user : memVal.getUsers()) { + // Skip if already visited + if (visited.count(user)) + continue; + visited.insert(user); + + if (isa(user)) { + memOps.push_back(user); + } else if (auto submapOp = dyn_cast(user)) { + // Recursively collect ops on the submap result + collectMemoryOpsRecursively(submapOp.getResult(), memOps, visited); + } + } +} + +/// Get all operations that access a memref (directly or through subview/submap) +std::vector getAllMemoryUsers(Value memVal) { + SmallVector memOps; + llvm::SmallPtrSet visited; + collectMemoryOpsRecursively(memVal, memOps, visited); + + // Sort by execution order + std::sort(memOps.begin(), memOps.end(), [](Operation *a, Operation *b) { + return comesBefore(a, b); + }); + + return std::vector(memOps.begin(), memOps.end()); +} + +//===----------------------------------------------------------------------===// +// Main Debufferization Pattern +//===----------------------------------------------------------------------===// + +// Algorithm Overview: +// 1. For a given root memref (alloca/alloc/func arg), create initial tensor +// 2. Maintain CurrentSlices map: root memref -> current tensor state +// 3. For each memory operation in sorted order: +// - SubViewOp: NOOP (trace chain at load/store time) +// - LoadOp: trace to root, compose indices, use submap to gather, extract +// - StoreOp: trace to root, compose indices, insert, submapInverse +// - LinalgGenericOp: submap for inputs, submapInverse for outputs +// 4. At the end, write back final tensor to original memref + +struct LinalgDebufferization : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(func::FuncOp funcOp, + PatternRewriter &rewriter) const final { + + LLVM_DEBUG(llvm::dbgs() << "\n=== LinalgDebufferization::matchAndRewrite ===\n"); + LLVM_DEBUG(llvm::dbgs() << "Processing function: " << funcOp.getName() << "\n"); + + LogicalResult passResult = failure(); + + // The main handler for each root memref + auto handleMemref = [&](Value memVal) -> LogicalResult { + LLVM_DEBUG(llvm::dbgs() << "\n--- handleMemref ---\n"); + LLVM_DEBUG(llvm::dbgs() << "Processing memref value: " << memVal << "\n"); + + if (!memVal.getType().isa()) { + LLVM_DEBUG(llvm::dbgs() << "REJECTED: Not a MemRefType\n"); + return failure(); + } + + MemRefType memrefType; + if (auto blockArg = memVal.dyn_cast()) { + LLVM_DEBUG(llvm::dbgs() << " Getting MemRefType from BlockArgument\n"); + memrefType = blockArg.getType().dyn_cast(); + } else if (auto allocaOp = memVal.getDefiningOp()) { + LLVM_DEBUG(llvm::dbgs() << " Getting MemRefType from AllocaOp\n"); + memrefType = allocaOp.getType(); + } else if (auto allocOp = memVal.getDefiningOp()) { + LLVM_DEBUG(llvm::dbgs() << " Getting MemRefType from AllocOp\n"); + memrefType = allocOp.getType(); + } else { + LLVM_DEBUG(llvm::dbgs() << "REJECTED: Cannot determine MemRefType\n"); + return failure(); + } + + LLVM_DEBUG(llvm::dbgs() << " MemRefType: " << memrefType << "\n"); + + // Get all memory users (including those through subview/submap chains) + auto sortedUsers = getAllMemoryUsers(memVal); + + LLVM_DEBUG(llvm::dbgs() << " Found " << sortedUsers.size() << " memory users (including through submap/subview)\n"); + for (size_t i = 0; i < sortedUsers.size(); i++) { + LLVM_DEBUG(llvm::dbgs() << " User " << i << ": " << *sortedUsers[i] << "\n"); + } + + // If no memory users found, nothing to debufferize + if (sortedUsers.empty()) { + LLVM_DEBUG(llvm::dbgs() << "REJECTED: No memory users found\n"); + return failure(); + } + + // Initialize: Create tensor from memref + rewriter.setInsertionPointAfterValue(memVal); + auto tensorType = RankedTensorType::get( + memrefType.getShape(), memrefType.getElementType()); + + LLVM_DEBUG(llvm::dbgs() << " Creating bufferization.to_tensor\n"); + auto toTensorOp = rewriter.create( + memVal.getLoc(), tensorType, memVal); + + // CurrentSlices: Map from root memref to current tensor state + // For now we only track one root memref at a time + llvm::DenseMap CurrentSlices; + CurrentSlices[memVal] = toTensorOp.getResult(); + + LLVM_DEBUG(llvm::dbgs() << " ToTensorOp created: " << toTensorOp << "\n"); + LLVM_DEBUG(llvm::dbgs() << " CurrentSlices[" << memVal << "] = " << CurrentSlices[memVal] << "\n"); + + // For region propagation (existing logic) + llvm::DenseMap opResultMap; + llvm::DenseMap pendingIfs; // Track pending if yields + std::vector expandedUserList(sortedUsers); + Value currentTensor = CurrentSlices[memVal]; + + int userIdx = 0; + LLVM_DEBUG(llvm::dbgs() << "\n Processing " << sortedUsers.size() << " users:\n"); + + // Tree-based tensor tracking: each region has its own tensor state + // This prevents sibling regions from polluting each other + llvm::DenseMap regionTensorTree; + + // Initialize the function body region with the initial tensor + regionTensorTree[&funcOp.getBody()] = RegionTensorState{currentTensor, true}; + + Region* lastUserRegion = nullptr; + Operation* lastUser = nullptr; + + for (auto user : sortedUsers) { + LLVM_DEBUG(llvm::dbgs() << "\n [User " << userIdx << "] Processing: " << user->getName() << " at " << user->getLoc() << "\n"); + + // Check if we're entering a new region + Region* userRegion = user->getParentRegion(); + if (lastUserRegion != userRegion) { + LLVM_DEBUG(llvm::dbgs() << " Region changed! Using tree-based tensor lookup...\n"); + + // STEP 1: Detect ifs we're EXITING (to update parent regions) + if (lastUser) { + auto oldContainingIfs = getContainingIfs(lastUser, &funcOp.getBody()); + auto newContainingIfs = getContainingIfs(user, &funcOp.getBody()); + + // Convert new containing ifs to a set for fast lookup + llvm::DenseSet newIfsSet; + for (auto ifOp : newContainingIfs) { + newIfsSet.insert(ifOp); + } + + // Check which ifs we're leaving (in old but not in new) + // Process innermost first (oldContainingIfs is already innermost-first) + for (auto oldIf : oldContainingIfs) { + if (!newIfsSet.contains(oldIf)) { + // We're exiting this if! Update its parent region + LLVM_DEBUG(llvm::dbgs() << " Exiting if at " << oldIf.getLoc() << "\n"); + + // Get the branch we were in + Region* oldThenRegion = &oldIf.getThenRegion(); + Region* oldElseRegion = &oldIf.getElseRegion(); + + // Get the tensor value from the branch we're leaving + auto thenIt = regionTensorTree.find(oldThenRegion); + auto elseIt = regionTensorTree.find(oldElseRegion); + + if (thenIt != regionTensorTree.end() && thenIt->second.valid) { + // We were in THEN branch - update pendingIfs + auto pendingIt = pendingIfs.find(oldIf); + if (pendingIt != pendingIfs.end()) { + pendingIt->second.thenResult = thenIt->second.tensor; + pendingIt->second.thenProcessed = true; + LLVM_DEBUG(llvm::dbgs() << " Updated THEN result on exit\n"); + } + } else if (elseIt != regionTensorTree.end() && elseIt->second.valid) { + // We were in ELSE branch - update pendingIfs + auto pendingIt = pendingIfs.find(oldIf); + if (pendingIt != pendingIfs.end()) { + pendingIt->second.elseResult = elseIt->second.tensor; + pendingIt->second.elseProcessed = true; + LLVM_DEBUG(llvm::dbgs() << " Updated ELSE result on exit\n"); + } + } + + // MERGE PHASE 2 INTO PHASE 1: If exiting a function-body-level if, + // rebuild it immediately so sibling ifs get the correct entry tensor + Region* parentRegion = oldIf->getParentRegion(); + if (parentRegion == &funcOp.getBody()) { + LLVM_DEBUG(llvm::dbgs() << " Function-body if - rebuilding immediately\n"); + + auto pendingIt = pendingIfs.find(oldIf); + if (pendingIt != pendingIfs.end()) { + // Build regions list containing just the parent region + SmallVector exitRegions; + exitRegions.push_back(parentRegion); + + // Get entry tensor for this if + Value entryTensor = pendingIt->second.entryTensor; + + // Rebuild the if with yields + propagateValueThroughRegion(entryTensor, exitRegions, expandedUserList, opResultMap, rewriter, pendingIfs); + + // Find the rebuilt if and update currentTensor + for (auto& op : funcOp.getBody().front()) { + if (auto newIf = dyn_cast(&op)) { + if (newIf.getNumResults() > 0 && newIf.getLoc() == oldIf.getLoc()) { + currentTensor = newIf.getResult(newIf.getNumResults() - 1); + regionTensorTree[parentRegion] = RegionTensorState{currentTensor, true}; + LLVM_DEBUG(llvm::dbgs() << " Updated currentTensor from rebuilt if result\n"); + break; + } + } + } + } + } else { + // For nested ifs, just update the parent region tensor + auto pendingIt = pendingIfs.find(oldIf); + if (pendingIt != pendingIfs.end()) { + if (thenIt != regionTensorTree.end() && thenIt->second.valid) { + regionTensorTree[parentRegion] = RegionTensorState{thenIt->second.tensor, true}; + } else if (elseIt != regionTensorTree.end() && elseIt->second.valid) { + regionTensorTree[parentRegion] = RegionTensorState{elseIt->second.tensor, true}; + } + LLVM_DEBUG(llvm::dbgs() << " Updated parent region tensor on exit\n"); + } + } + } + } + } + + // STEP 2: Get the correct tensor for the new region from the tree + // This traces up to the parent region, avoiding sibling pollution + Region* parentRegion = userRegion; + // Find the parent region that has a valid tensor (go up the tree) + currentTensor = getCurrentTensorForRegion(parentRegion, regionTensorTree, CurrentSlices[memVal]); + LLVM_DEBUG(llvm::dbgs() << " Got tensor from tree for current region: " << currentTensor << "\n"); + + // STEP 3: Set up entry tensor for any new ifs we're entering + auto containingIfs = getContainingIfs(user, &funcOp.getBody()); + + // Process outermost first + for (auto it = containingIfs.rbegin(); it != containingIfs.rend(); ++it) { + scf::IfOp ifOp = *it; + Region* thenRegion = &ifOp.getThenRegion(); + Region* elseRegion = &ifOp.getElseRegion(); + + // Check if we're entering this if's THEN branch for the first time + if (thenRegion->isAncestor(userRegion)) { + auto thenIt = regionTensorTree.find(thenRegion); + if (thenIt == regionTensorTree.end() || !thenIt->second.valid) { + // First time entering THEN - get tensor from PARENT region (not currentTensor!) + Region* ifParentRegion = ifOp->getParentRegion(); + Value entryTensor = getCurrentTensorForRegion(ifParentRegion, regionTensorTree, CurrentSlices[memVal]); + + regionTensorTree[thenRegion] = RegionTensorState{entryTensor, true}; + currentTensor = entryTensor; + + // Set up PendingIfInfo if not exists + if (pendingIfs.find(ifOp) == pendingIfs.end()) { + PendingIfInfo info; + info.ifOp = ifOp; + info.entryTensor = entryTensor; + info.thenResult = entryTensor; + info.elseResult = entryTensor; + pendingIfs[ifOp] = info; + LLVM_DEBUG(llvm::dbgs() << " Created PendingIfInfo for if at " << ifOp.getLoc() << " with entry: " << entryTensor << "\n"); + } + LLVM_DEBUG(llvm::dbgs() << " Entering THEN branch of if at " << ifOp.getLoc() << " with tensor: " << entryTensor << "\n"); + } + } + // Check if we're entering this if's ELSE branch for the first time + else if (elseRegion->isAncestor(userRegion)) { + auto elseIt = regionTensorTree.find(elseRegion); + if (elseIt == regionTensorTree.end() || !elseIt->second.valid) { + // First time entering ELSE - get tensor from PARENT region + Region* ifParentRegion = ifOp->getParentRegion(); + Value entryTensor = getCurrentTensorForRegion(ifParentRegion, regionTensorTree, CurrentSlices[memVal]); + + regionTensorTree[elseRegion] = RegionTensorState{entryTensor, true}; + currentTensor = entryTensor; + + // Set up PendingIfInfo if not exists + if (pendingIfs.find(ifOp) == pendingIfs.end()) { + PendingIfInfo info; + info.ifOp = ifOp; + info.entryTensor = entryTensor; + info.thenResult = entryTensor; + info.elseResult = entryTensor; + pendingIfs[ifOp] = info; + LLVM_DEBUG(llvm::dbgs() << " Created PendingIfInfo for if at " << ifOp.getLoc() << " with entry: " << entryTensor << "\n"); + } + LLVM_DEBUG(llvm::dbgs() << " Entering ELSE branch of if at " << ifOp.getLoc() << " with tensor: " << entryTensor << "\n"); + } + } + } + + lastUserRegion = userRegion; + LLVM_DEBUG(llvm::dbgs() << " After region transition, currentTensor: " << currentTensor << "\n"); + } + + lastUser = user; + + //=== SubmapOp: NOOP === + if (auto submapOp = dyn_cast(user)) { + LLVM_DEBUG(llvm::dbgs() << " Detected polygeist.submap - NOOP\n"); + LLVM_DEBUG(llvm::dbgs() << " (Will use submap/submapInverse when we hit linalg.generic)\n"); + userIdx++; + continue; + } + + //=== LoadOp: direct extract from root tensor === + else if (auto loadOp = dyn_cast(user)) { + LLVM_DEBUG(llvm::dbgs() << " Detected memref.load\n"); + + Value loadMemref = loadOp.getMemRef(); + + // Only handle direct loads from the root memref + Value rootTensor = CurrentSlices[loadMemref]; + if (!rootTensor) { + LLVM_DEBUG(llvm::dbgs() << " ERROR: No tensor for memref\n"); + userIdx++; + continue; + } + + rewriter.setInsertionPoint(loadOp); + + // Create tensor.extract with the load indices + auto extractOp = rewriter.create( + loadOp.getLoc(), rootTensor, loadOp.getIndices()); + + LLVM_DEBUG(llvm::dbgs() << " Created tensor.extract: " << extractOp << "\n"); + + // Replace load result with extract result + loadOp.getResult().replaceAllUsesWith(extractOp.getResult()); + rewriter.eraseOp(loadOp); + + LLVM_DEBUG(llvm::dbgs() << " Erased original load, load->extract complete\n"); + } + + //=== StoreOp: direct insert into root tensor === + else if (auto storeOp = dyn_cast(user)) { + LLVM_DEBUG(llvm::dbgs() << " Detected memref.store\n"); + + Value storeMemref = storeOp.getMemRef(); + Value valueToStore = storeOp.getValueToStore(); + + // Only handle direct stores to the root memref + Value rootTensor = CurrentSlices[storeMemref]; + if (!rootTensor) { + LLVM_DEBUG(llvm::dbgs() << " ERROR: No tensor for memref\n"); + userIdx++; + continue; + } + + rewriter.setInsertionPoint(storeOp); + + // Create tensor.insert to produce new tensor + auto insertOp = rewriter.create( + storeOp.getLoc(), valueToStore, rootTensor, storeOp.getIndices()); + + LLVM_DEBUG(llvm::dbgs() << " Created tensor.insert: " << insertOp << "\n"); + + // Update CurrentSlices - this is the key for SSA semantics! + CurrentSlices[storeMemref] = insertOp.getResult(); + currentTensor = insertOp.getResult(); + + // Update the region tensor tree for correct scoping + regionTensorTree[user->getParentRegion()] = RegionTensorState{currentTensor, true}; + + LLVM_DEBUG(llvm::dbgs() << " Updated CurrentSlices[root] = " << insertOp.getResult() << "\n"); + + // Record this tensor for containing if branches + recordBranchResult(user, currentTensor, pendingIfs, &funcOp.getBody()); + + rewriter.eraseOp(storeOp); + + LLVM_DEBUG(llvm::dbgs() << " Erased original store, store->insert complete\n"); + } + + //=== AffineLoadOp: apply affine map, then extract === + else if (auto affineLoadOp = dyn_cast(user)) { + LLVM_DEBUG(llvm::dbgs() << " Detected affine.load\n"); + + Value loadMemref = affineLoadOp.getMemRef(); + + // Only handle direct loads from the root memref + Value rootTensor = CurrentSlices[loadMemref]; + if (!rootTensor) { + LLVM_DEBUG(llvm::dbgs() << " ERROR: No tensor for memref\n"); + userIdx++; + continue; + } + + rewriter.setInsertionPoint(affineLoadOp); + AffineMap map = affineLoadOp.getAffineMap(); + SmallVector mapOperands(affineLoadOp.getMapOperands()); + + // Apply affine map to get actual indices + SmallVector affineIndices; + for (unsigned i = 0; i < map.getNumResults(); ++i) { + auto applyOp = rewriter.create( + affineLoadOp.getLoc(), map.getSubMap({i}), mapOperands); + affineIndices.push_back(applyOp.getResult()); + } + + // Create tensor.extract + auto extractOp = rewriter.create( + affineLoadOp.getLoc(), rootTensor, affineIndices); + + affineLoadOp.getResult().replaceAllUsesWith(extractOp.getResult()); + rewriter.eraseOp(affineLoadOp); + + LLVM_DEBUG(llvm::dbgs() << " affine.load -> tensor.extract complete\n"); + } + + //=== AffineStoreOp: apply affine map, then insert === + else if (auto affineStoreOp = dyn_cast(user)) { + LLVM_DEBUG(llvm::dbgs() << " Detected affine.store\n"); + + Value storeMemref = affineStoreOp.getMemRef(); + Value valueToStore = affineStoreOp.getValueToStore(); + + // Only handle direct stores to the root memref + Value rootTensor = CurrentSlices[storeMemref]; + if (!rootTensor) { + LLVM_DEBUG(llvm::dbgs() << " ERROR: No tensor for memref\n"); + userIdx++; + continue; + } + + // Apply affine map to get actual indices + rewriter.setInsertionPoint(affineStoreOp); + AffineMap map = affineStoreOp.getAffineMap(); + SmallVector mapOperands(affineStoreOp.getMapOperands()); + + SmallVector affineIndices; + for (unsigned i = 0; i < map.getNumResults(); ++i) { + auto applyOp = rewriter.create( + affineStoreOp.getLoc(), map.getSubMap({i}), mapOperands); + affineIndices.push_back(applyOp.getResult()); + } + + // Create tensor.insert + auto insertOp = rewriter.create( + affineStoreOp.getLoc(), valueToStore, rootTensor, affineIndices); + + // Update CurrentSlices + CurrentSlices[storeMemref] = insertOp.getResult(); + currentTensor = insertOp.getResult(); + + // Update the region tensor tree for correct scoping + regionTensorTree[user->getParentRegion()] = RegionTensorState{currentTensor, true}; + + // Record this tensor for containing if branches + recordBranchResult(user, currentTensor, pendingIfs, &funcOp.getBody()); + + rewriter.eraseOp(affineStoreOp); + + LLVM_DEBUG(llvm::dbgs() << " affine.store -> tensor.insert complete\n"); + } + + //=== LinalgGenericOp: submap for inputs, submapInverse for outputs === + else if (auto genericOp = dyn_cast(user)) { + LLVM_DEBUG(llvm::dbgs() << " Detected linalg.generic\n"); + + // Handle region propagation for SSA value availability + auto commonRegion = findCommonAncestorRegion(currentTensor.getDefiningOp(), user); + if (!commonRegion) { + LLVM_DEBUG(llvm::dbgs() << " ERROR: No common region found\n"); + return failure(); + } + + SmallVector regions; + for (Region* r = currentTensor.getParentRegion(); r != commonRegion; + r = r->getParentOp()->getParentRegion()) { + regions.push_back(r); + } + + if (!regions.empty()) { + propagateValueThroughRegion(currentTensor, regions, expandedUserList, opResultMap, rewriter, pendingIfs); + } + + SmallVector newInputs; + SmallVector newOutputs; + SmallVector resultTypes; + + // Set insertion point BEFORE the generic to create submap ops for inputs/outputs + rewriter.setInsertionPoint(genericOp); + + // Process inputs + for (auto input : genericOp.getInputs()) { + if (input == memVal) { + // Direct use of root memref + newInputs.push_back(currentTensor); + } else if (auto inputMemref = input.getType().dyn_cast()) { + // Check if this input traces back to our root through submap chain + SubmapChainInfo chain = traceSubmapChainToRoot(input); + if (chain.rootMemref == memVal && !chain.isEmpty()) { + // Input is through a submap chain - use submap + Location loc = genericOp.getLoc(); + auto lastSubmap = chain.submaps.back(); + AffineMap map = lastSubmap.getMap(); + SmallVector submapOperands(lastSubmap.getIndicesAndSizes()); + + RankedTensorType sliceTensorType = getSubmapChainTensorType(chain); + + auto submapOp = rewriter.create( + loc, sliceTensorType, currentTensor, submapOperands, map); + + newInputs.push_back(submapOp.getResult()); + LLVM_DEBUG(llvm::dbgs() << " Created submap for input: " << submapOp << "\n"); + } else { + newInputs.push_back(input); + } + } else { + newInputs.push_back(input); + } + } + + // Process outputs + int newCurrentTensorIndex = -1; + int index = 0; + SmallVector outputChains; + + for (auto output : genericOp.getOutputs()) { + if (output == memVal) { + // Direct use of root memref + newOutputs.push_back(currentTensor); + resultTypes.push_back(currentTensor.getType()); + newCurrentTensorIndex = index; + outputChains.push_back(SubmapChainInfo{memVal, {}}); + } else if (auto outputMemref = output.getType().dyn_cast()) { + // Check if this output traces back to our root through submap chain + SubmapChainInfo chain = traceSubmapChainToRoot(output); + if (chain.rootMemref == memVal && !chain.isEmpty()) { + // Output is through a submap chain - need submap for init value + Location loc = genericOp.getLoc(); + auto lastSubmap = chain.submaps.back(); + AffineMap map = lastSubmap.getMap(); + SmallVector submapOperands(lastSubmap.getIndicesAndSizes()); + + RankedTensorType sliceTensorType = getSubmapChainTensorType(chain); + + auto submapOp = rewriter.create( + loc, sliceTensorType, currentTensor, submapOperands, map); + + newOutputs.push_back(submapOp.getResult()); + resultTypes.push_back(sliceTensorType); + newCurrentTensorIndex = index; + outputChains.push_back(chain); + LLVM_DEBUG(llvm::dbgs() << " Created submap for output: " << submapOp << "\n"); + } else { + newOutputs.push_back(output); + resultTypes.push_back(output.getType()); + outputChains.push_back(SubmapChainInfo{}); + } + } else { + newOutputs.push_back(output); + resultTypes.push_back(output.getType()); + outputChains.push_back(SubmapChainInfo{}); + } + index++; + } + + // Set insertion point AFTER the generic for new linalg.generic and submapInverse + rewriter.setInsertionPointAfter(genericOp); + StringAttr empty = StringAttr::get(genericOp.getContext()); + auto newGenericOp = rewriter.create( + genericOp.getLoc(), ArrayRef(resultTypes), newInputs, newOutputs, + genericOp.getIndexingMaps(), genericOp.getIteratorTypes(), empty, empty); + + rewriter.cloneRegionBefore(genericOp.getRegion(), + newGenericOp.getRegion(), + newGenericOp.getRegion().end()); + + // Handle outputs that need submapInverse + Value finalTensor = currentTensor; + for (unsigned i = 0; i < outputChains.size(); ++i) { + const auto &chain = outputChains[i]; + if (chain.rootMemref && !chain.isEmpty()) { + // Need to scatter this result back using submapInverse + Location loc = genericOp.getLoc(); + auto lastSubmap = chain.submaps.back(); + AffineMap map = lastSubmap.getMap(); + SmallVector submapOperands(lastSubmap.getIndicesAndSizes()); + + auto inverseOp = rewriter.create( + loc, finalTensor.getType(), finalTensor, + newGenericOp.getResult(i), submapOperands, map); + + finalTensor = inverseOp.getResult(); + LLVM_DEBUG(llvm::dbgs() << " Created submapInverse: " << inverseOp << "\n"); + } else if (chain.rootMemref == memVal) { + // Direct output to root - use result directly + finalTensor = newGenericOp.getResult(i); + } + } + + // Replace all uses of original generic op + for (unsigned i = 0; i < genericOp->getNumResults(); ++i) { + genericOp->getResult(i).replaceAllUsesWith(newGenericOp->getResult(i)); + } + + // Update CurrentSlices + if (newCurrentTensorIndex != -1) { + CurrentSlices[memVal] = finalTensor; + currentTensor = finalTensor; + opResultMap[newGenericOp] = std::make_tuple(finalTensor, currentTensor); + + // Update the region tensor tree for correct scoping + regionTensorTree[user->getParentRegion()] = RegionTensorState{currentTensor, true}; + + // Record this tensor for containing if branches + recordBranchResult(user, currentTensor, pendingIfs, &funcOp.getBody()); + } + + rewriter.eraseOp(genericOp); + + // Update expandedUserList: replace old generic with new one + if (userIdx < expandedUserList.size()) { + expandedUserList[userIdx] = newGenericOp; + } + + LLVM_DEBUG(llvm::dbgs() << " linalg.generic transformation complete\n"); + } + else { + LLVM_DEBUG(llvm::dbgs() << " Unknown user type (skipping): " << user->getName() << "\n"); + } + userIdx++; + } + + // Final propagation for yields + LLVM_DEBUG(llvm::dbgs() << "\n Finalizing: Adding yields for last use\n"); + auto commonRegion = findCommonAncestorRegion(currentTensor.getDefiningOp(), toTensorOp); + if (!commonRegion) { + LLVM_DEBUG(llvm::dbgs() << " ERROR: No common region for final propagation\n"); + return failure(); + } + + SmallVector regions; + for (Region* r = currentTensor.getParentRegion(); r != commonRegion; + r = r->getParentOp()->getParentRegion()) { + regions.push_back(r); + } + + LLVM_DEBUG(llvm::dbgs() << " Final propagation through " << regions.size() << " regions\n"); + propagateValueThroughRegion(currentTensor, regions, expandedUserList, opResultMap, rewriter, pendingIfs); + + // Only insert to_memref and copy if tensor was actually transformed + if (currentTensor != toTensorOp.getResult()) { + LLVM_DEBUG(llvm::dbgs() << " Tensor was transformed, creating to_memref and copy\n"); + rewriter.setInsertionPointAfter(currentTensor.getDefiningOp()); + auto toMemrefOp = rewriter.create( + memVal.getLoc(), memrefType, currentTensor); + LLVM_DEBUG(llvm::dbgs() << " Created to_memref: " << toMemrefOp << "\n"); + auto copyOp = rewriter.create(memVal.getLoc(), toMemrefOp, memVal); + LLVM_DEBUG(llvm::dbgs() << " Created copy: " << copyOp << "\n"); + } else { + LLVM_DEBUG(llvm::dbgs() << " Tensor was NOT transformed\n"); + } + + LLVM_DEBUG(llvm::dbgs() << "handleMemref SUCCESS\n"); + LLVM_DEBUG(llvm::dbgs() << "=== IR after handleMemref ===\n"); + LLVM_DEBUG(funcOp.print(llvm::dbgs())); + LLVM_DEBUG(llvm::dbgs() << "\n=== END IR after handleMemref ===\n\n"); + return success(); + }; + + + bool anySuccess = false; + //Fix instead of walk, just get the list of allocaOp users, so that you can easily delete ops inside + SmallVector listOfAllocaOps; + SmallVector listOfAllocOps; + + funcOp.walk([&](memref::AllocaOp alloca) { + listOfAllocaOps.push_back(alloca); + }); + //TODO: Adding allocOp for now, without alias check + funcOp.walk([&](memref::AllocOp alloc) { + listOfAllocOps.push_back(alloc); + }); + + LLVM_DEBUG(llvm::dbgs() << "\nProcessing " << listOfAllocaOps.size() << " AllocaOps\n"); + for (auto alloca : listOfAllocaOps) { + LLVM_DEBUG(llvm::dbgs() << "Processing AllocaOp: " << alloca << "\n"); + anySuccess |= succeeded(handleMemref(alloca)); + } + + LLVM_DEBUG(llvm::dbgs() << "\nProcessing " << listOfAllocOps.size() << " AllocOps\n"); + for (auto alloc : listOfAllocOps) { + LLVM_DEBUG(llvm::dbgs() << "Processing AllocOp: " << alloc << "\n"); + anySuccess |= succeeded(handleMemref(alloc)); + } + + LLVM_DEBUG(llvm::dbgs() << "\nProcessing " << funcOp.getNumArguments() << " function arguments\n"); + for(auto arg: funcOp.getArguments()){ + LLVM_DEBUG(llvm::dbgs() << "Processing argument: " << arg << "\n"); + anySuccess |= succeeded(handleMemref(arg)); + } + + passResult = anySuccess ? success() : failure(); + LLVM_DEBUG(llvm::dbgs() << "\n=== LinalgDebufferization " << (anySuccess ? "SUCCESS" : "FAILURE") << " ===\n\n"); + //for (Operation *op : opsToDelete) { + // op->erase(); + //} + //opsToDelete.clear(); + + return passResult; + } +}; + +//===----------------------------------------------------------------------===// +// V2: Region-recursive debufferization +//===----------------------------------------------------------------------===// +// +// Design (see notes/polygeist_raise_to_linalg/linalg_debufferize_stress_survey.md): +// Per-root walk over the IR. A single SSA `currentTensor` flows through the +// recursion. Region-bearing ops (scf.for so far) are rebuilt with extra +// iter_args / yields when their body modifies the root, and the walk recurses +// inside. No flat user list; no per-region tensor tree; no pendingIfs. +// +// Stage 1: linear function-body scope. +// Stage 2: + scf.for (this commit). +// Future: scf.if, scf.while, affine.for, full submap-inverse chain. + +namespace v2 { + +// Does `v` transitively come from `root` via a chain of supported memref view +// ops? The rewriter below can route both polygeist.submap and memref.subview +// to tensor-side slice ops, so the feasibility and touch checks must accept the +// same view forms. Otherwise an earlier root can partially tensorize a +// multi-root linalg.generic while the output root is skipped. +static bool tracesToRoot(Value v, Value root) { + while (true) { + if (v == root) return true; + if (auto sm = v.getDefiningOp()) { + v = sm.getViewSource(); + continue; + } + if (auto sv = v.getDefiningOp()) { + v = sv.getSource(); + continue; + } + return false; + } +} + +// True if `op`'s ancestor chain up to a func::FuncOp consists only of +// region-bearing ops we know how to rebuild. +// Stage 5: scf.for + scf.if + affine.for + scf.while. +static bool ancestorsAreHandled(Operation *op) { + Operation *parent = op->getParentOp(); + while (parent && !isa(parent)) { + if (!isa(parent)) + return false; + parent = parent->getParentOp(); + } + return true; +} + +// Precondition: can we safely debufferize `root` end-to-end? +// All transitive memory users (through supported memref view ops) must be +// load/store/linalg.generic, each under only handled region-bearing +// ancestors. There must also be at least one such memory op (otherwise +// there's no work to do and re-firing the pattern would loop forever). +static bool canHandle(Value root) { + SmallPtrSet visited; + SmallVector worklist; + worklist.push_back(root); + bool hasMemoryOp = false; + while (!worklist.empty()) { + Value v = worklist.pop_back_val(); + for (Operation *user : v.getUsers()) { + if (!visited.insert(user).second) continue; + if (isa(user)) + continue; + if (isa(user)) { + if (!ancestorsAreHandled(user)) return false; + hasMemoryOp = true; + continue; + } + if (auto submap = dyn_cast(user)) { + worklist.push_back(submap.getResult()); + continue; + } + if (auto subview = dyn_cast(user)) { + worklist.push_back(subview.getResult()); + continue; + } + return false; + } + } + return hasMemoryOp; +} + +// SubviewChainInfo + tracer — used by regionWritesRoot below; the +// builder/inverse helpers are defined later (they need WalkCtx). +struct SubviewChainInfo { + Value rootMemref; + SmallVector subviews; + bool isEmpty() const { return subviews.empty(); } +}; + +static SubviewChainInfo traceSubviewChainToRoot(Value memref) { + SubviewChainInfo info; + Value current = memref; + while (auto sv = current.getDefiningOp()) { + info.subviews.push_back(sv); + current = sv.getSource(); + } + info.rootMemref = current; + std::reverse(info.subviews.begin(), info.subviews.end()); + return info; +} + +// Does anything inside `r` *write* to `root` (via store/affine.store/ +// linalg.generic with root in outs, including through supported views) — AND, +// for linalg.generic, can we +// fully rewrite that op (all its memref operands trace to `root`)? +// This second condition prevents handleScfFor/handleAffineFor from +// speculatively rebuilding the loop with a tensor iter_arg in cases +// where the body's writes can't actually be rewritten — which would +// produce a dangling iter_arg and re-trigger the pattern indefinitely. +static bool regionWritesRoot(Region &r, Value root) { + bool writes = false; + r.walk([&](Operation *op) { + if (writes) return WalkResult::interrupt(); + if (auto store = dyn_cast(op)) { + if (tracesToRoot(store.getMemRef(), root)) writes = true; + } else if (auto astore = dyn_cast(op)) { + if (tracesToRoot(astore.getMemRef(), root)) writes = true; + } else if (auto generic = dyn_cast(op)) { + for (Value o : generic.getOutputs()) + if (o.getType().isa() && tracesToRoot(o, root)) { + writes = true; + break; + } + } + return writes ? WalkResult::interrupt() : WalkResult::advance(); + }); + return writes; +} + +// Rebuild a submap chain on the tensor side, starting from `baseTensor`. +static Value buildTensorSubmapChain(Value baseTensor, + const SubmapChainInfo &chain, + PatternRewriter &rewriter) { + Value t = baseTensor; + for (auto submap : chain.submaps) { + auto resMemref = submap.getResult().getType().cast(); + auto resTensor = RankedTensorType::get(resMemref.getShape(), + resMemref.getElementType()); + auto newSubmap = rewriter.create( + submap.getLoc(), resTensor, t, + SmallVector(submap.getIndicesAndSizes()), + submap.getMap()); + t = newSubmap.getResult(); + } + return t; +} + +// Scatter `sliceTensor` (at the leaf-view shape) all the way back into +// `baseTensor` (the root). For a chain [sm0, sm1, sm2]: +// base[i] tensors: bases[0]=baseTensor (root) +// bases[1]=submap(bases[0], sm0) +// bases[2]=submap(bases[1], sm1) +// -- (the leaf view at depth 3 is sliceTensor's shape; +// we don't need a bases[3]) +// Then unwind innermost-first: +// bases[2]' = submapInverse(bases[2], sliceTensor, sm2.ops, sm2.map) +// bases[1]' = submapInverse(bases[1], bases[2]', sm1.ops, sm1.map) +// bases[0]' = submapInverse(bases[0], bases[1]', sm0.ops, sm0.map) +// Return bases[0]'. +static Value applySubmapInverseChain(Value baseTensor, Value sliceTensor, + const SubmapChainInfo &chain, + Location loc, + PatternRewriter &rewriter) { + if (chain.isEmpty()) return sliceTensor; + + // Build intermediate bases by applying chain forward, skipping the leaf + // (whose "base output" is sliceTensor's domain). + SmallVector bases; + bases.push_back(baseTensor); + for (size_t i = 0; i + 1 < chain.submaps.size(); ++i) { + auto sm = chain.submaps[i]; + auto resMemref = sm.getResult().getType().cast(); + auto resTensor = RankedTensorType::get(resMemref.getShape(), + resMemref.getElementType()); + auto fwd = rewriter.create( + sm.getLoc(), resTensor, bases.back(), + SmallVector(sm.getIndicesAndSizes()), sm.getMap()); + bases.push_back(fwd.getResult()); + } + + // Unwind: leaf first. + Value current = sliceTensor; + for (int i = static_cast(chain.submaps.size()) - 1; i >= 0; --i) { + auto sm = chain.submaps[i]; + Value base = bases[i]; + auto inv = rewriter.create( + sm.getLoc(), base.getType(), base, current, + SmallVector(sm.getIndicesAndSizes()), sm.getMap()); + current = inv.getResult(); + } + return current; +} + +// ========================================================================= +// Subview chain support (mirrors the submap chain helpers above). +// +// A `memref.subview` is a "view" op like polygeist.submap but expressed in +// terms of static/dynamic offsets, sizes, and strides. For debufferize we +// treat it as another link in the view chain — the tensor-side equivalent +// is `tensor.extract_slice` (forward) and `tensor.insert_slice` (inverse). +// `SubviewChainInfo` + `traceSubviewChainToRoot` are defined earlier in +// this namespace (regionWritesRoot needs them); the builder/inverse +// helpers below complete the set. +// ========================================================================= + +// Re-emit a subview chain on the tensor side as a sequence of +// tensor.extract_slice ops. Each slice carries the same offsets/sizes/ +// strides as the corresponding memref.subview, and its result type is +// derived from the subview's result memref type (preserving rank-reduction +// if the subview was rank-reducing). +static Value buildTensorSubviewChain(Value baseTensor, + const SubviewChainInfo &chain, + PatternRewriter &rewriter) { + Value t = baseTensor; + for (memref::SubViewOp sv : chain.subviews) { + auto resMemref = sv.getResult().getType().cast(); + auto resTensor = RankedTensorType::get(resMemref.getShape(), + resMemref.getElementType()); + auto extracted = rewriter.create( + sv.getLoc(), resTensor, t, + sv.getMixedOffsets(), sv.getMixedSizes(), sv.getMixedStrides()); + t = extracted.getResult(); + } + return t; +} + +// Scatter `sliceTensor` back through a subview chain via tensor.insert_slice +// ops, mirroring `applySubmapInverseChain` for submaps. +static Value applySubviewInverseChain(Value baseTensor, Value sliceTensor, + const SubviewChainInfo &chain, + Location loc, + PatternRewriter &rewriter) { + if (chain.isEmpty()) return sliceTensor; + // Build intermediate tensor bases via forward extract_slice up to depth N-1. + SmallVector bases; + bases.push_back(baseTensor); + for (size_t i = 0; i + 1 < chain.subviews.size(); ++i) { + memref::SubViewOp sv = chain.subviews[i]; + auto resMemref = sv.getResult().getType().cast(); + auto resTensor = RankedTensorType::get(resMemref.getShape(), + resMemref.getElementType()); + auto fwd = rewriter.create( + sv.getLoc(), resTensor, bases.back(), + sv.getMixedOffsets(), sv.getMixedSizes(), sv.getMixedStrides()); + bases.push_back(fwd.getResult()); + } + // Unwind leaf-first via insert_slice. + Value current = sliceTensor; + for (int i = static_cast(chain.subviews.size()) - 1; i >= 0; --i) { + memref::SubViewOp sv = chain.subviews[i]; + Value base = bases[i]; + auto inserted = rewriter.create( + loc, current, base, + sv.getMixedOffsets(), sv.getMixedSizes(), sv.getMixedStrides()); + current = inserted.getResult(); + } + return current; +} + +// Forward declarations +struct WalkCtx; +static void walkBlock(WalkCtx &ctx, Block &block); +static void handleScfFor(WalkCtx &ctx, scf::ForOp forOp); +static void handleScfIf(WalkCtx &ctx, scf::IfOp ifOp); +static void handleAffineFor(WalkCtx &ctx, affine::AffineForOp forOp); +static void handleScfWhile(WalkCtx &ctx, scf::WhileOp whileOp); +static void rewriteLinalgGenericForRoot(WalkCtx &ctx, linalg::GenericOp generic); + +// Per-root walk context. `didRewrite` flips true as soon as we mutate the IR +// (rewriting a load, store, or generic). It distinguishes the "we did +// something" case from the "current tensor reverted to entry" case, which +// matters for multi-root linalg.generics where we rewrite inputs but the +// output tensor flow stays unchanged. +struct WalkCtx { + Value root; + Value currentTensor; + PatternRewriter *rewriter; + bool didRewrite = false; +}; + +// A local allocation may be created inside a region that contains all of its +// uses (for example, one scalar reduction accumulator per outer-loop +// iteration). Its tensor state must not be added as an iter_arg to that +// enclosing operation: the initial tensor is itself defined in the region and +// therefore cannot dominate the operation. Such state is private to the +// region and can be rewritten in place, then discarded on exit. +static bool rootIsDefinedInside(Value root, Region ®ion) { + Operation *def = root.getDefiningOp(); + Operation *owner = region.getParentOp(); + return def && owner && (owner == def || owner->isProperAncestor(def)); +} + +// Holds whichever kind of view chain routed an operand back to the root +// memref. Exactly one of `submap` or `subview` is non-empty; both empty +// means the operand IS the root directly (no view at all). +struct RoutedChain { + SubmapChainInfo submap; + SubviewChainInfo subview; + bool isEmpty() const { return submap.isEmpty() && subview.isEmpty(); } + bool isSubmap() const { return !submap.isEmpty(); } + bool isSubview() const { return !subview.isEmpty(); } +}; + +static void rewriteLinalgGenericForRoot(WalkCtx &ctx, linalg::GenericOp generic) { + Value root = ctx.root; + PatternRewriter &rewriter = *ctx.rewriter; + rewriter.setInsertionPoint(generic); + SmallVector newInputs, newOutputs; + SmallVector resultTypes; + int outRootResultIdx = -1; + SmallVector newResultForOutput; + RoutedChain outRootChain; + + auto routeOperand = [&](Value v) -> std::pair> { + if (v == root) + return {ctx.currentTensor, RoutedChain{SubmapChainInfo{root, {}}, {}}}; + if (!v.getType().isa()) return {v, std::nullopt}; + + // Try submap chain first (legacy raise path). + SubmapChainInfo subChain = traceSubmapChainToRoot(v); + if (subChain.rootMemref == root) { + if (subChain.isEmpty()) + return {ctx.currentTensor, RoutedChain{subChain, {}}}; + return {buildTensorSubmapChain(ctx.currentTensor, subChain, rewriter), + RoutedChain{subChain, {}}}; + } + // Then memref.subview chain (stencils / trmm / symm / doitgen path). + SubviewChainInfo svChain = traceSubviewChainToRoot(v); + if (svChain.rootMemref == root) { + if (svChain.isEmpty()) + return {ctx.currentTensor, RoutedChain{SubmapChainInfo{root, {}}, {}}}; + return {buildTensorSubviewChain(ctx.currentTensor, svChain, rewriter), + RoutedChain{{}, svChain}}; + } + return {v, std::nullopt}; + }; + + for (Value in : generic.getInputs()) { + auto [nv, _] = routeOperand(in); + newInputs.push_back(nv); + } + int idx = 0; + for (Value out : generic.getOutputs()) { + auto [nv, chainOpt] = routeOperand(out); + newOutputs.push_back(nv); + // Linalg permits mixed tensor/memref outputs, but only tensor outputs + // produce SSA results. During per-root conversion another root may still + // be a memref, so never put its memref type in the result type list. + int resultIdx = -1; + if (nv.getType().isa()) { + resultIdx = resultTypes.size(); + resultTypes.push_back(nv.getType()); + } + newResultForOutput.push_back(resultIdx); + if (chainOpt.has_value()) { + outRootResultIdx = resultIdx; + outRootChain = *chainOpt; + } + ++idx; + } + + rewriter.setInsertionPointAfter(generic); + StringAttr empty = StringAttr::get(generic.getContext()); + auto newGeneric = rewriter.create( + generic.getLoc(), ArrayRef(resultTypes), newInputs, newOutputs, + generic.getIndexingMaps(), generic.getIteratorTypes(), empty, empty); + rewriter.cloneRegionBefore(generic.getRegion(), newGeneric.getRegion(), + newGeneric.getRegion().end()); + + if (outRootResultIdx >= 0) { + Value resultSlice = newGeneric.getResult(outRootResultIdx); + if (outRootChain.isEmpty()) { + ctx.currentTensor = resultSlice; + } else if (outRootChain.isSubmap()) { + ctx.currentTensor = applySubmapInverseChain( + ctx.currentTensor, resultSlice, outRootChain.submap, + generic.getLoc(), rewriter); + } else { + ctx.currentTensor = applySubviewInverseChain( + ctx.currentTensor, resultSlice, outRootChain.subview, + generic.getLoc(), rewriter); + } + } + + // Existing results correspond to the old tensor outputs in output order. + // A newly tensorized output can appear before them, so a plain positional + // zip would rewire an old result to the wrong output. + unsigned oldResultIdx = 0; + for (auto [outIdx, oldOut] : llvm::enumerate(generic.getOutputs())) { + if (!oldOut.getType().isa()) + continue; + int newIdx = newResultForOutput[outIdx]; + assert(newIdx >= 0 && "an existing tensor output must remain a tensor"); + generic.getResult(oldResultIdx++).replaceAllUsesWith( + newGeneric.getResult(newIdx)); + } + rewriter.eraseOp(generic); +} + +static void handleScfFor(WalkCtx &ctx, scf::ForOp forOp) { + PatternRewriter &rewriter = *ctx.rewriter; + + if (rootIsDefinedInside(ctx.root, forOp.getRegion())) { + Value saved = ctx.currentTensor; + walkBlock(ctx, forOp.getRegion().front()); + ctx.currentTensor = saved; + return; + } + + // Body only READS root → walk inline; currentTensor unchanged outside. + // We still recurse to rewrite reads/sub-ops; the outer-scope tensor + // dominates the body and is the right SSA value for them. + if (!regionWritesRoot(forOp.getRegion(), ctx.root)) { + Value saved = ctx.currentTensor; + walkBlock(ctx, forOp.getRegion().front()); + ctx.currentTensor = saved; + return; + } + + // Body WRITES root → rebuild scf.for with one extra iter_arg carrying + // the tensor for this root. + rewriter.setInsertionPoint(forOp); + SmallVector newInits(forOp.getInitArgs()); + newInits.push_back(ctx.currentTensor); + + auto newFor = rewriter.create( + forOp.getLoc(), forOp.getLowerBound(), forOp.getUpperBound(), + forOp.getStep(), newInits); + + Block *oldBody = forOp.getBody(); + Block *newBody = newFor.getBody(); + + // The newly-built scf.for body has a default terminator that the builder + // inserted. Remove it so mergeBlocks can append the old body cleanly. + if (!newBody->empty()) { + Operation *term = newBody->getTerminator(); + rewriter.eraseOp(term); + } + // Map oldBody's [IV, iter_args...] block-args onto newBody's first N+1 + // arguments (everything except the trailing new tensor iter_arg). + rewriter.mergeBlocks(oldBody, newBody, newBody->getArguments().drop_back()); + + // Now walk the new body with currentTensor = the appended tensor iter_arg. + Value entryTensor = newBody->getArguments().back(); + ctx.currentTensor = entryTensor; + walkBlock(ctx, *newBody); + + // Append the inner-final tensor to the yield's operand list. + auto yield = cast(newBody->getTerminator()); + SmallVector newYields(yield.getOperands()); + newYields.push_back(ctx.currentTensor); + rewriter.setInsertionPoint(yield); + rewriter.replaceOpWithNewOp(yield, newYields); + + // Rewire users of the old for's results to the new for's matching results. + for (auto [oldR, newR] : + llvm::zip(forOp.getResults(), newFor.getResults().drop_back())) + oldR.replaceAllUsesWith(newR); + rewriter.eraseOp(forOp); + + // The outer continuation should now see the new for's last result. + ctx.currentTensor = newFor.getResults().back(); + ctx.didRewrite = true; +} + +static void handleScfIf(WalkCtx &ctx, scf::IfOp ifOp) { + PatternRewriter &rewriter = *ctx.rewriter; + + bool rootInThen = rootIsDefinedInside(ctx.root, ifOp.getThenRegion()); + bool rootInElse = !ifOp.getElseRegion().empty() && + rootIsDefinedInside(ctx.root, ifOp.getElseRegion()); + if (rootInThen || rootInElse) { + Value saved = ctx.currentTensor; + if (rootInThen) + walkBlock(ctx, ifOp.getThenRegion().front()); + ctx.currentTensor = saved; + if (rootInElse) + walkBlock(ctx, ifOp.getElseRegion().front()); + ctx.currentTensor = saved; + return; + } + + bool thenWrites = regionWritesRoot(ifOp.getThenRegion(), ctx.root); + bool elseWrites = !ifOp.getElseRegion().empty() && + regionWritesRoot(ifOp.getElseRegion(), ctx.root); + + // Neither branch writes → walk inline for reads only; currentTensor + // unchanged because the outer-scope tensor dominates both branch bodies. + if (!thenWrites && !elseWrites) { + Value saved = ctx.currentTensor; + if (!ifOp.getThenRegion().empty()) + walkBlock(ctx, ifOp.getThenRegion().front()); + ctx.currentTensor = saved; + if (!ifOp.getElseRegion().empty()) + walkBlock(ctx, ifOp.getElseRegion().front()); + ctx.currentTensor = saved; + return; + } + + // Rebuild scf.if with one extra tensor result for the root. + Value entryTensor = ctx.currentTensor; + SmallVector newResultTypes(ifOp.getResultTypes().begin(), + ifOp.getResultTypes().end()); + newResultTypes.push_back(entryTensor.getType()); + + rewriter.setInsertionPoint(ifOp); + auto newIf = rewriter.create( + ifOp.getLoc(), newResultTypes, ifOp.getCondition(), + /*withElseRegion=*/true); + + // THEN branch: splice old's contents into new's then block, then walk. + Block *oldThen = &ifOp.getThenRegion().front(); + Block *newThen = &newIf.getThenRegion().front(); + if (!newThen->empty()) rewriter.eraseOp(newThen->getTerminator()); + rewriter.mergeBlocks(oldThen, newThen, /*argValues=*/{}); + + ctx.currentTensor = entryTensor; + walkBlock(ctx, *newThen); + Value thenFinal = ctx.currentTensor; + + { + auto thenYield = cast(newThen->getTerminator()); + SmallVector thenYields(thenYield.getOperands()); + thenYields.push_back(thenFinal); + rewriter.setInsertionPoint(thenYield); + rewriter.replaceOpWithNewOp(thenYield, thenYields); + } + + // ELSE branch: either splice old's contents or synthesize "yield entry". + Block *newElse = &newIf.getElseRegion().front(); + if (!ifOp.getElseRegion().empty()) { + Block *oldElse = &ifOp.getElseRegion().front(); + if (!newElse->empty()) rewriter.eraseOp(newElse->getTerminator()); + rewriter.mergeBlocks(oldElse, newElse, /*argValues=*/{}); + + ctx.currentTensor = entryTensor; + walkBlock(ctx, *newElse); + Value elseFinal = ctx.currentTensor; + + auto elseYield = cast(newElse->getTerminator()); + SmallVector elseYields(elseYield.getOperands()); + elseYields.push_back(elseFinal); + rewriter.setInsertionPoint(elseYield); + rewriter.replaceOpWithNewOp(elseYield, elseYields); + } else { + // Original had no else. Synthesize: yield the entry tensor unchanged. + // newElse is non-empty: it contains a default empty yield op the + // builder inserted. Replace it with one that yields entryTensor. + SmallVector elseYields{entryTensor}; + if (!newElse->empty()) { + auto elseYield = cast(newElse->getTerminator()); + rewriter.setInsertionPoint(elseYield); + rewriter.replaceOpWithNewOp(elseYield, elseYields); + } else { + rewriter.setInsertionPointToEnd(newElse); + rewriter.create(ifOp.getLoc(), elseYields); + } + } + + // Rewire old if's pre-existing results to the new if's matching ones. + for (auto [oldR, newR] : + llvm::zip(ifOp.getResults(), newIf.getResults().drop_back())) + oldR.replaceAllUsesWith(newR); + rewriter.eraseOp(ifOp); + + ctx.currentTensor = newIf.getResults().back(); + ctx.didRewrite = true; +} + +static void handleAffineFor(WalkCtx &ctx, affine::AffineForOp forOp) { + PatternRewriter &rewriter = *ctx.rewriter; + + if (rootIsDefinedInside(ctx.root, forOp.getRegion())) { + Value saved = ctx.currentTensor; + walkBlock(ctx, forOp.getRegion().front()); + ctx.currentTensor = saved; + return; + } + + if (!regionWritesRoot(forOp.getRegion(), ctx.root)) { + Value saved = ctx.currentTensor; + walkBlock(ctx, forOp.getRegion().front()); + ctx.currentTensor = saved; + return; + } + + rewriter.setInsertionPoint(forOp); + SmallVector newInits(forOp.getInits()); + newInits.push_back(ctx.currentTensor); + + auto newFor = rewriter.create( + forOp.getLoc(), forOp.getLowerBoundOperands(), forOp.getLowerBoundMap(), + forOp.getUpperBoundOperands(), forOp.getUpperBoundMap(), + forOp.getStep(), newInits); + + Block *oldBody = forOp.getBody(); + Block *newBody = newFor.getBody(); + + if (!newBody->empty()) { + Operation *term = newBody->getTerminator(); + rewriter.eraseOp(term); + } + rewriter.mergeBlocks(oldBody, newBody, newBody->getArguments().drop_back()); + + Value entryTensor = newBody->getArguments().back(); + ctx.currentTensor = entryTensor; + walkBlock(ctx, *newBody); + + auto yield = cast(newBody->getTerminator()); + SmallVector newYields(yield.getOperands()); + newYields.push_back(ctx.currentTensor); + rewriter.setInsertionPoint(yield); + rewriter.replaceOpWithNewOp(yield, newYields); + + for (auto [oldR, newR] : + llvm::zip(forOp.getResults(), newFor.getResults().drop_back())) + oldR.replaceAllUsesWith(newR); + rewriter.eraseOp(forOp); + + ctx.currentTensor = newFor.getResults().back(); + ctx.didRewrite = true; +} + +static void handleScfWhile(WalkCtx &ctx, scf::WhileOp whileOp) { + PatternRewriter &rewriter = *ctx.rewriter; + + bool rootInBefore = rootIsDefinedInside(ctx.root, whileOp.getBefore()); + bool rootInAfter = rootIsDefinedInside(ctx.root, whileOp.getAfter()); + if (rootInBefore || rootInAfter) { + Value saved = ctx.currentTensor; + if (rootInBefore) + walkBlock(ctx, whileOp.getBefore().front()); + ctx.currentTensor = saved; + if (rootInAfter) + walkBlock(ctx, whileOp.getAfter().front()); + ctx.currentTensor = saved; + return; + } + + bool beforeWrites = regionWritesRoot(whileOp.getBefore(), ctx.root); + bool afterWrites = regionWritesRoot(whileOp.getAfter(), ctx.root); + + // Neither region writes → walk inline (just for reads). + if (!beforeWrites && !afterWrites) { + Value saved = ctx.currentTensor; + if (!whileOp.getBefore().empty()) + walkBlock(ctx, whileOp.getBefore().front()); + ctx.currentTensor = saved; + if (!whileOp.getAfter().empty()) + walkBlock(ctx, whileOp.getAfter().front()); + ctx.currentTensor = saved; + return; + } + + // Rebuild scf.while with one extra tensor iter_arg threaded through both + // regions: + // - extra `before` block arg (init = currentTensor) + // - extra scf.condition operand (latest tensor in before) + // - extra `after` block arg (carried from condition) + // - extra scf.yield operand (latest tensor in after — feeds next iter) + // - extra scf.while result (final tensor after loop exits) + Value entryTensor = ctx.currentTensor; + Type tensorType = entryTensor.getType(); + + SmallVector newOperands(whileOp.getOperands()); + newOperands.push_back(entryTensor); + + SmallVector newResultTypes(whileOp.getResultTypes().begin(), + whileOp.getResultTypes().end()); + newResultTypes.push_back(tensorType); + + rewriter.setInsertionPoint(whileOp); + auto newWhile = + rewriter.create(whileOp.getLoc(), newResultTypes, + newOperands); + + // Build the before block manually (with the extra tensor arg appended). + SmallVector beforeArgTypes( + whileOp.getBefore().front().getArgumentTypes()); + beforeArgTypes.push_back(tensorType); + SmallVector beforeArgLocs(beforeArgTypes.size(), whileOp.getLoc()); + Block *newBefore = + rewriter.createBlock(&newWhile.getBefore(), {}, beforeArgTypes, + beforeArgLocs); + + Block *oldBefore = &whileOp.getBefore().front(); + rewriter.mergeBlocks(oldBefore, newBefore, newBefore->getArguments().drop_back()); + + ctx.currentTensor = newBefore->getArguments().back(); + walkBlock(ctx, *newBefore); + Value beforeFinal = ctx.currentTensor; + + // Replace scf.condition with one that carries the tensor too. + auto cond = cast(newBefore->getTerminator()); + SmallVector newCondArgs(cond.getArgs()); + newCondArgs.push_back(beforeFinal); + rewriter.setInsertionPoint(cond); + rewriter.replaceOpWithNewOp(cond, cond.getCondition(), + newCondArgs); + + // Build the after block manually too. + SmallVector afterArgTypes( + whileOp.getAfter().front().getArgumentTypes()); + afterArgTypes.push_back(tensorType); + SmallVector afterArgLocs(afterArgTypes.size(), whileOp.getLoc()); + Block *newAfter = + rewriter.createBlock(&newWhile.getAfter(), {}, afterArgTypes, + afterArgLocs); + + Block *oldAfter = &whileOp.getAfter().front(); + rewriter.mergeBlocks(oldAfter, newAfter, newAfter->getArguments().drop_back()); + + ctx.currentTensor = newAfter->getArguments().back(); + walkBlock(ctx, *newAfter); + Value afterFinal = ctx.currentTensor; + + // Replace scf.yield with one that yields the tensor too. + auto yield = cast(newAfter->getTerminator()); + SmallVector newYields(yield.getOperands()); + newYields.push_back(afterFinal); + rewriter.setInsertionPoint(yield); + rewriter.replaceOpWithNewOp(yield, newYields); + + for (auto [oldR, newR] : + llvm::zip(whileOp.getResults(), newWhile.getResults().drop_back())) + oldR.replaceAllUsesWith(newR); + rewriter.eraseOp(whileOp); + + ctx.currentTensor = newWhile.getResults().back(); + ctx.didRewrite = true; +} + +static void walkBlock(WalkCtx &ctx, Block &block) { + for (auto it = block.begin(), end = block.end(); it != end;) { + Operation &op = *it++; + + if (auto load = dyn_cast(&op)) { + if (load.getMemRef() == ctx.root) { + ctx.rewriter->setInsertionPoint(load); + auto extract = ctx.rewriter->create( + load.getLoc(), ctx.currentTensor, load.getIndices()); + load.getResult().replaceAllUsesWith(extract.getResult()); + ctx.rewriter->eraseOp(load); + ctx.didRewrite = true; + } + } else if (auto store = dyn_cast(&op)) { + if (store.getMemRef() == ctx.root) { + ctx.rewriter->setInsertionPoint(store); + auto insert = ctx.rewriter->create( + store.getLoc(), store.getValueToStore(), ctx.currentTensor, + store.getIndices()); + ctx.currentTensor = insert.getResult(); + ctx.rewriter->eraseOp(store); + ctx.didRewrite = true; + } + } else if (auto aload = dyn_cast(&op)) { + if (aload.getMemRef() == ctx.root) { + ctx.rewriter->setInsertionPoint(aload); + AffineMap map = aload.getAffineMap(); + SmallVector mapOperands(aload.getMapOperands()); + SmallVector idx; + for (unsigned i = 0; i < map.getNumResults(); ++i) { + auto apply = ctx.rewriter->create( + aload.getLoc(), map.getSubMap({i}), mapOperands); + idx.push_back(apply.getResult()); + } + auto extract = ctx.rewriter->create( + aload.getLoc(), ctx.currentTensor, idx); + aload.getResult().replaceAllUsesWith(extract.getResult()); + ctx.rewriter->eraseOp(aload); + ctx.didRewrite = true; + } + } else if (auto astore = dyn_cast(&op)) { + if (astore.getMemRef() == ctx.root) { + ctx.rewriter->setInsertionPoint(astore); + AffineMap map = astore.getAffineMap(); + SmallVector mapOperands(astore.getMapOperands()); + SmallVector idx; + for (unsigned i = 0; i < map.getNumResults(); ++i) { + auto apply = ctx.rewriter->create( + astore.getLoc(), map.getSubMap({i}), mapOperands); + idx.push_back(apply.getResult()); + } + auto insert = ctx.rewriter->create( + astore.getLoc(), astore.getValueToStore(), ctx.currentTensor, idx); + ctx.currentTensor = insert.getResult(); + ctx.rewriter->eraseOp(astore); + ctx.didRewrite = true; + } + } else if (auto generic = dyn_cast(&op)) { + // Rewrite only if this generic touches our root via in/out operands. + bool touches = false; + bool writesRoot = false; + bool hasTensorOutput = false; + for (Value v : generic.getInputs()) { + if (v.getType().isa() && tracesToRoot(v, ctx.root)) { + touches = true; + break; + } + } + for (Value v : generic.getOutputs()) { + hasTensorOutput |= v.getType().isa(); + if (v.getType().isa() && tracesToRoot(v, ctx.root)) { + touches = true; + writesRoot = true; + } + } + // Do not tensorize only an input while every destination is still a + // memref. That transient mixed form is rejected by this Linalg + // version's destination-style verifier. Convert an output root first; + // the greedy function pattern will revisit the generic and convert the + // remaining input roots once it has a tensor destination. + if (touches && (writesRoot || hasTensorOutput)) { + rewriteLinalgGenericForRoot(ctx, generic); + ctx.didRewrite = true; + } + } else if (isa(&op)) { + // NOOP — re-emitted at linalg.generic time. + } else if (isa(&op)) { + // NOOP — re-emitted as tensor.extract_slice at linalg.generic time. + } else if (auto forOp = dyn_cast(&op)) { + handleScfFor(ctx, forOp); + } else if (auto ifOp = dyn_cast(&op)) { + handleScfIf(ctx, ifOp); + } else if (auto affFor = dyn_cast(&op)) { + handleAffineFor(ctx, affFor); + } else if (auto whileOp = dyn_cast(&op)) { + handleScfWhile(ctx, whileOp); + } + // Anything else: leave alone. canHandle has ensured no unsupported + // op touches our root. + } +} + +static LogicalResult handleRoot(Value root, Block *body, + PatternRewriter &rewriter) { + auto memrefType = root.getType().dyn_cast(); + if (!memrefType) return failure(); + if (!canHandle(root)) return failure(); + + rewriter.setInsertionPointAfterValue(root); + auto tensorType = RankedTensorType::get(memrefType.getShape(), + memrefType.getElementType()); + auto initT = rewriter.create( + root.getLoc(), tensorType, root); + Value initTensor = initT.getResult(); + + WalkCtx ctx{root, initTensor, &rewriter}; + walkBlock(ctx, *body); + + if (!ctx.didRewrite) { + // Nothing actually changed. Undo the speculative to_tensor — but only + // if it has no uses (e.g. an input-only rewrite of a generic would + // have wired tensor submaps to it, in which case didRewrite is true). + if (initT.getResult().use_empty()) rewriter.eraseOp(initT); + return failure(); + } + + // Write back if the current tensor diverged from the entry tensor. + // If only reads (loads) or input-only generic rewrites happened, the + // outer memref hasn't been logically modified — no copy needed. + if (ctx.currentTensor != initTensor) { + rewriter.setInsertionPointAfterValue(ctx.currentTensor); + auto toMemref = rewriter.create( + root.getLoc(), memrefType, ctx.currentTensor); + rewriter.create(root.getLoc(), toMemref, root); + } + return success(); +} + +} // namespace v2 + +// ========================================================================= +// Multi-root debufferize (experimental). +// +// Unlike v2 which processes one memref root at a time, this walker tracks +// the current tensor state for ALL memref roots of a function simultaneously. +// That handles cases where one linalg.generic op reads from root A and +// writes to root B (PolyBench stencils' double-buffer pattern, trmm's +// "read from A, write to B" pattern, etc.), which the single-root path +// can't lift because the in-progress IR would have mixed tensor+memref +// operand types and the verifier rejects them mid-rewrite. +// +// Key design: +// * MultiRootCtx::rootToTensor maps each tracked memref root → its +// current tensor SSA value (the "live" version after previous reads +// and writes have been applied). +// * Loops thread *all* written roots through iter_args. The set of +// written roots is computed up front by scanning the body. +// * Every memref-typed operand to a linalg.generic / load / store must +// trace (through polygeist.submap / memref.subview) to one of the +// tracked roots; otherwise we refuse to handle the function. +// ========================================================================= +namespace multiroot { + +// SubmapChainInfo and traceSubmapChainToRoot are at global scope (early in +// the file). The rest live in namespace v2. +using v2::buildTensorSubmapChain; +using v2::applySubmapInverseChain; +using v2::SubviewChainInfo; +using v2::traceSubviewChainToRoot; +using v2::buildTensorSubviewChain; +using v2::applySubviewInverseChain; + +struct MultiRootCtx { + // Per-root current tensor state. + DenseMap rootToTensor; + // Initial to_tensor SSA per root (for "did anything change" comparisons). + DenseMap rootInitial; + PatternRewriter *rewriter; + bool didRewrite = false; +}; + +// Walk back through submap / subview ops to find the underlying root memref. +// Returns the original value if no view ops are encountered. +static Value findRoot(Value v) { + Value cur = v; + while (true) { + if (auto sm = cur.getDefiningOp()) { + cur = sm.getViewSource(); + continue; + } + if (auto sv = cur.getDefiningOp()) { + cur = sv.getSource(); + continue; + } + return cur; + } +} + +// Forward declarations for the mutual recursion through loop/if handlers. +struct MultiRootCtx; +static void walkBlock(MultiRootCtx &ctx, Block &block); +static void rewriteLinalgGeneric(MultiRootCtx &ctx, linalg::GenericOp generic); +static void handleScfFor(MultiRootCtx &ctx, scf::ForOp forOp); +static void handleAffineFor(MultiRootCtx &ctx, affine::AffineForOp forOp); + +// Compute the set of tracked roots that any op inside `region` writes to. +// "Writes" = a store, affine.store, or linalg.generic with that root in outs. +static SetVector +collectWrittenRoots(Region ®ion, + const DenseMap &rootToTensor) { + SetVector written; + auto pickRoot = [&](Value v) { + if (!v.getType().isa()) return; + Value r = findRoot(v); + if (rootToTensor.contains(r)) written.insert(r); + }; + region.walk([&](Operation *op) { + if (auto store = dyn_cast(op)) + pickRoot(store.getMemRef()); + else if (auto astore = dyn_cast(op)) + pickRoot(astore.getMemRef()); + else if (auto generic = dyn_cast(op)) + for (Value o : generic.getOutputs()) pickRoot(o); + }); + return written; +} + +// Build a tensor "view" of `v` for use as an operand to the new +// linalg.generic. If v traces to a tracked root, follow its submap / +// subview chain on the current tensor side. If v itself IS a root, just +// return its current tensor. Returns std::nullopt if v doesn't trace to +// any tracked root. +static std::optional>> +routeOperand(MultiRootCtx &ctx, Value v) { + if (!v.getType().isa()) return std::nullopt; + Value root = findRoot(v); + auto it = ctx.rootToTensor.find(root); + if (it == ctx.rootToTensor.end()) return std::nullopt; + Value cur = it->second; + // Direct root reference: return current tensor. + if (v == root) return std::make_pair(cur, std::monostate{}); + // Submap chain? + SubmapChainInfo sm = traceSubmapChainToRoot(v); + if (!sm.isEmpty() && sm.rootMemref == root) { + Value chained = buildTensorSubmapChain(cur, sm, *ctx.rewriter); + return std::make_pair(chained, std::variant{sm}); + } + // Subview chain? + SubviewChainInfo sv = traceSubviewChainToRoot(v); + if (!sv.isEmpty() && sv.rootMemref == root) { + Value chained = buildTensorSubviewChain(cur, sv, *ctx.rewriter); + return std::make_pair(chained, std::variant{sv}); + } + return std::nullopt; +} + +static void rewriteLinalgGeneric(MultiRootCtx &ctx, + linalg::GenericOp generic) { + PatternRewriter &rewriter = *ctx.rewriter; + rewriter.setInsertionPoint(generic); + + SmallVector newInputs, newOutputs; + SmallVector resultTypes; + // Track each output's routing so we can write back into rootToTensor. + struct OutInfo { + Value root; + std::variant chain; + }; + SmallVector outRouting; + + for (Value in : generic.getInputs()) { + auto r = routeOperand(ctx, in); + if (!r.has_value()) { + // Operand doesn't trace to a tracked root — abort: would emit + // a mixed tensor/memref op. + return; + } + newInputs.push_back(r->first); + } + for (Value out : generic.getOutputs()) { + auto r = routeOperand(ctx, out); + if (!r.has_value()) return; + newOutputs.push_back(r->first); + resultTypes.push_back(r->first.getType()); + outRouting.push_back({findRoot(out), r->second}); + } + + rewriter.setInsertionPointAfter(generic); + StringAttr empty = StringAttr::get(generic.getContext()); + auto newGeneric = rewriter.create( + generic.getLoc(), ArrayRef(resultTypes), newInputs, newOutputs, + generic.getIndexingMaps(), generic.getIteratorTypes(), empty, empty); + rewriter.cloneRegionBefore(generic.getRegion(), newGeneric.getRegion(), + newGeneric.getRegion().end()); + + // For each output: apply inverse chain into the root's current tensor. + for (auto [idx, info] : llvm::enumerate(outRouting)) { + Value resultSlice = newGeneric.getResult(idx); + Value base = ctx.rootToTensor[info.root]; + Value updated; + if (std::holds_alternative(info.chain)) { + // Direct root write — no chain, the result IS the new tensor state. + updated = resultSlice; + } else if (auto *sm = std::get_if(&info.chain)) { + updated = applySubmapInverseChain(base, resultSlice, *sm, + generic.getLoc(), rewriter); + } else { + auto *sv = std::get_if(&info.chain); + updated = applySubviewInverseChain(base, resultSlice, *sv, + generic.getLoc(), rewriter); + } + ctx.rootToTensor[info.root] = updated; + } + + for (auto [oldR, newR] : + llvm::zip(generic.getResults(), newGeneric.getResults())) + oldR.replaceAllUsesWith(newR); + rewriter.eraseOp(generic); + ctx.didRewrite = true; +} + +static void handleScfFor(MultiRootCtx &ctx, scf::ForOp forOp) { + PatternRewriter &rewriter = *ctx.rewriter; + // Which roots does the body write? + SetVector written = collectWrittenRoots(forOp.getRegion(), + ctx.rootToTensor); + if (written.empty()) { + // Read-only: walk inline without rebuilding the loop. + auto saved = ctx.rootToTensor; + walkBlock(ctx, forOp.getRegion().front()); + ctx.rootToTensor = saved; + return; + } + + rewriter.setInsertionPoint(forOp); + SmallVector newInits(forOp.getInitArgs()); + SmallVector writtenRootsList(written.begin(), written.end()); + for (Value r : writtenRootsList) newInits.push_back(ctx.rootToTensor[r]); + + auto newFor = rewriter.create( + forOp.getLoc(), forOp.getLowerBound(), forOp.getUpperBound(), + forOp.getStep(), newInits); + newFor->setAttrs(forOp.getOperation()->getAttrs()); + + Block *oldBody = forOp.getBody(); + Block *newBody = newFor.getBody(); + if (!newBody->empty()) rewriter.eraseOp(newBody->getTerminator()); + rewriter.mergeBlocks(oldBody, newBody, + newBody->getArguments().drop_back(written.size())); + + // Inside the new loop body, the tracked roots that are written get their + // new iter_args as their currentTensor. + auto saved = ctx.rootToTensor; + unsigned argOff = newBody->getNumArguments() - written.size(); + for (auto [i, r] : llvm::enumerate(writtenRootsList)) + ctx.rootToTensor[r] = newBody->getArgument(argOff + i); + walkBlock(ctx, *newBody); + + auto yield = cast(newBody->getTerminator()); + SmallVector newYields(yield.getOperands()); + for (Value r : writtenRootsList) newYields.push_back(ctx.rootToTensor[r]); + rewriter.setInsertionPoint(yield); + rewriter.replaceOpWithNewOp(yield, newYields); + + for (auto [oldR, newR] : llvm::zip(forOp.getResults(), + newFor.getResults().drop_back(written.size()))) + oldR.replaceAllUsesWith(newR); + rewriter.eraseOp(forOp); + + // After the loop, the root's tensor state is the corresponding result. + ctx.rootToTensor = saved; + unsigned resOff = newFor.getNumResults() - written.size(); + for (auto [i, r] : llvm::enumerate(writtenRootsList)) + ctx.rootToTensor[r] = newFor.getResult(resOff + i); + ctx.didRewrite = true; +} + +static void handleAffineFor(MultiRootCtx &ctx, affine::AffineForOp forOp) { + PatternRewriter &rewriter = *ctx.rewriter; + SetVector written = collectWrittenRoots(forOp.getRegion(), + ctx.rootToTensor); + if (written.empty()) { + auto saved = ctx.rootToTensor; + walkBlock(ctx, forOp.getRegion().front()); + ctx.rootToTensor = saved; + return; + } + + rewriter.setInsertionPoint(forOp); + SmallVector newInits(forOp.getInits()); + SmallVector writtenRootsList(written.begin(), written.end()); + for (Value r : writtenRootsList) newInits.push_back(ctx.rootToTensor[r]); + + auto newFor = rewriter.create( + forOp.getLoc(), forOp.getLowerBoundOperands(), forOp.getLowerBoundMap(), + forOp.getUpperBoundOperands(), forOp.getUpperBoundMap(), + forOp.getStep(), newInits); + + Block *oldBody = forOp.getBody(); + Block *newBody = newFor.getBody(); + if (!newBody->empty()) rewriter.eraseOp(newBody->getTerminator()); + rewriter.mergeBlocks(oldBody, newBody, + newBody->getArguments().drop_back(written.size())); + + auto saved = ctx.rootToTensor; + unsigned argOff = newBody->getNumArguments() - written.size(); + for (auto [i, r] : llvm::enumerate(writtenRootsList)) + ctx.rootToTensor[r] = newBody->getArgument(argOff + i); + walkBlock(ctx, *newBody); + + auto yield = cast(newBody->getTerminator()); + SmallVector newYields(yield.getOperands()); + for (Value r : writtenRootsList) newYields.push_back(ctx.rootToTensor[r]); + rewriter.setInsertionPoint(yield); + rewriter.replaceOpWithNewOp(yield, newYields); + + for (auto [oldR, newR] : llvm::zip(forOp.getResults(), + newFor.getResults().drop_back(written.size()))) + oldR.replaceAllUsesWith(newR); + rewriter.eraseOp(forOp); + + ctx.rootToTensor = saved; + unsigned resOff = newFor.getNumResults() - written.size(); + for (auto [i, r] : llvm::enumerate(writtenRootsList)) + ctx.rootToTensor[r] = newFor.getResult(resOff + i); + ctx.didRewrite = true; +} + +static void walkBlock(MultiRootCtx &ctx, Block &block) { + for (auto it = block.begin(), end = block.end(); it != end;) { + Operation &op = *it++; + if (auto load = dyn_cast(&op)) { + Value root = findRoot(load.getMemRef()); + auto rit = ctx.rootToTensor.find(root); + if (rit == ctx.rootToTensor.end()) continue; + // For simplicity only handle direct loads of a tracked root. + if (load.getMemRef() != root) continue; + ctx.rewriter->setInsertionPoint(load); + auto extract = ctx.rewriter->create( + load.getLoc(), rit->second, load.getIndices()); + load.getResult().replaceAllUsesWith(extract.getResult()); + ctx.rewriter->eraseOp(load); + ctx.didRewrite = true; + } else if (auto store = dyn_cast(&op)) { + Value root = findRoot(store.getMemRef()); + auto rit = ctx.rootToTensor.find(root); + if (rit == ctx.rootToTensor.end()) continue; + if (store.getMemRef() != root) continue; + ctx.rewriter->setInsertionPoint(store); + auto insert = ctx.rewriter->create( + store.getLoc(), store.getValueToStore(), rit->second, + store.getIndices()); + ctx.rootToTensor[root] = insert.getResult(); + ctx.rewriter->eraseOp(store); + ctx.didRewrite = true; + } else if (auto aload = dyn_cast(&op)) { + Value root = findRoot(aload.getMemRef()); + auto rit = ctx.rootToTensor.find(root); + if (rit == ctx.rootToTensor.end()) continue; + if (aload.getMemRef() != root) continue; + ctx.rewriter->setInsertionPoint(aload); + AffineMap map = aload.getAffineMap(); + SmallVector mapOperands(aload.getMapOperands()); + SmallVector idx; + for (unsigned i = 0; i < map.getNumResults(); ++i) { + auto apply = ctx.rewriter->create( + aload.getLoc(), map.getSubMap({i}), mapOperands); + idx.push_back(apply.getResult()); + } + auto extract = ctx.rewriter->create( + aload.getLoc(), rit->second, idx); + aload.getResult().replaceAllUsesWith(extract.getResult()); + ctx.rewriter->eraseOp(aload); + ctx.didRewrite = true; + } else if (auto astore = dyn_cast(&op)) { + Value root = findRoot(astore.getMemRef()); + auto rit = ctx.rootToTensor.find(root); + if (rit == ctx.rootToTensor.end()) continue; + if (astore.getMemRef() != root) continue; + ctx.rewriter->setInsertionPoint(astore); + AffineMap map = astore.getAffineMap(); + SmallVector mapOperands(astore.getMapOperands()); + SmallVector idx; + for (unsigned i = 0; i < map.getNumResults(); ++i) { + auto apply = ctx.rewriter->create( + astore.getLoc(), map.getSubMap({i}), mapOperands); + idx.push_back(apply.getResult()); + } + auto insert = ctx.rewriter->create( + astore.getLoc(), astore.getValueToStore(), rit->second, idx); + ctx.rootToTensor[root] = insert.getResult(); + ctx.rewriter->eraseOp(astore); + ctx.didRewrite = true; + } else if (auto generic = dyn_cast(&op)) { + // Check that every memref-typed operand traces to a tracked root. + bool allTracked = true; + bool touchesAny = false; + for (Value v : generic->getOperands()) { + if (!v.getType().isa()) continue; + Value r = findRoot(v); + if (ctx.rootToTensor.contains(r)) { touchesAny = true; continue; } + allTracked = false; break; + } + if (allTracked && touchesAny) { + rewriteLinalgGeneric(ctx, generic); + } + } else if (isa(&op)) { + // NOOP — re-emitted on the tensor side at linalg.generic time. + } else if (auto forOp = dyn_cast(&op)) { + handleScfFor(ctx, forOp); + } else if (auto affFor = dyn_cast(&op)) { + handleAffineFor(ctx, affFor); + } + // Other ops (arith, math, return, etc.): leave alone. + } +} + +// Returns true if `op` is *under* an op whose region we don't recurse into +// (affine.if, scf.if, scf.while, etc.). Used to refuse functions whose +// memref work lives inside un-traversed regions — otherwise we'd loop +// forever wrapping the outer loop in fresh iter_args without ever +// converting the inner ops. +static bool isUnderUnhandledRegion(Operation *op) { + Operation *parent = op->getParentOp(); + while (parent && !isa(parent)) { + if (!isa(parent)) + return true; + parent = parent->getParentOp(); + } + return false; +} + +// Check that all memref-using ops in funcOp can be handled by the +// multi-root walker, AND that there's at least one MEMREF-FORM op that +// references a tracked root (load/store/affine.load/affine.store with +// memref operand, OR linalg.generic with at least one memref operand). +// The "has memref work to do" requirement prevents the pattern driver +// from re-firing endlessly on already-converted IR. We also refuse if +// any memref op on a tracked root lives under an unhandled region (if, +// while, etc.) — see isUnderUnhandledRegion. +static bool canHandle(func::FuncOp funcOp, + const DenseMap &rootToTensor) { + bool ok = true; + bool hasMemrefWork = false; + funcOp.walk([&](Operation *op) { + if (!ok) return WalkResult::interrupt(); + if (isa(op)) + return WalkResult::advance(); + auto checkValTracked = [&](Value v) { + if (!v.getType().isa()) return true; + Value r = findRoot(v); + return rootToTensor.contains(r); + }; + auto valTouchesTrackedMemref = [&](Value v) { + if (!v.getType().isa()) return false; + Value r = findRoot(v); + return rootToTensor.contains(r); + }; + if (auto load = dyn_cast(op)) { + if (!checkValTracked(load.getMemRef())) { ok = false; return WalkResult::interrupt(); } + if (valTouchesTrackedMemref(load.getMemRef())) { + if (isUnderUnhandledRegion(op)) { ok = false; return WalkResult::interrupt(); } + hasMemrefWork = true; + } + return WalkResult::advance(); + } + if (auto store = dyn_cast(op)) { + if (!checkValTracked(store.getMemRef())) { ok = false; return WalkResult::interrupt(); } + if (valTouchesTrackedMemref(store.getMemRef())) { + if (isUnderUnhandledRegion(op)) { ok = false; return WalkResult::interrupt(); } + hasMemrefWork = true; + } + return WalkResult::advance(); + } + if (auto aload = dyn_cast(op)) { + if (!checkValTracked(aload.getMemRef())) { ok = false; return WalkResult::interrupt(); } + if (valTouchesTrackedMemref(aload.getMemRef())) { + if (isUnderUnhandledRegion(op)) { ok = false; return WalkResult::interrupt(); } + hasMemrefWork = true; + } + return WalkResult::advance(); + } + if (auto astore = dyn_cast(op)) { + if (!checkValTracked(astore.getMemRef())) { ok = false; return WalkResult::interrupt(); } + if (valTouchesTrackedMemref(astore.getMemRef())) { + if (isUnderUnhandledRegion(op)) { ok = false; return WalkResult::interrupt(); } + hasMemrefWork = true; + } + return WalkResult::advance(); + } + if (auto generic = dyn_cast(op)) { + bool hasMemref = false; + for (Value v : generic->getOperands()) { + if (!checkValTracked(v)) { ok = false; return WalkResult::interrupt(); } + if (v.getType().isa()) hasMemref = true; + } + if (hasMemref) { + if (isUnderUnhandledRegion(op)) { ok = false; return WalkResult::interrupt(); } + hasMemrefWork = true; + } + return WalkResult::advance(); + } + // Any other op: as long as it doesn't have memref operands tied to + // a tracked root, it's fine. + for (Value v : op->getOperands()) { + if (v.getType().isa()) { + Value r = findRoot(v); + if (rootToTensor.contains(r)) { ok = false; return WalkResult::interrupt(); } + } + } + return WalkResult::advance(); + }); + return ok && hasMemrefWork; +} + +static LogicalResult handleAllRoots(func::FuncOp funcOp, + PatternRewriter &rewriter) { + // Collect all roots: function-arg memrefs + local allocs. + SmallVector roots; + for (auto arg : funcOp.getArguments()) + if (arg.getType().isa()) roots.push_back(arg); + funcOp.walk([&](memref::AllocaOp op) { roots.push_back(op.getResult()); }); + funcOp.walk([&](memref::AllocOp op) { roots.push_back(op.getResult()); }); + if (roots.empty()) return failure(); + + // The multi-root loop handlers thread every tracked root written in a loop + // as an iter_arg. A root allocated inside that loop cannot be one of those + // operands because its definition does not dominate the loop. Leave such + // functions to the region-recursive walker, which deliberately treats + // loop-local allocations as private state. + Block *entry = &funcOp.getBody().front(); + for (Value root : roots) { + if (Operation *def = root.getDefiningOp()) + if (def->getBlock() != entry) + return failure(); + } + + // Feasibility check WITHOUT touching the IR. Build a "would-be" root + // set so canHandle can answer questions about it, but don't insert any + // ops yet. This prevents the create-then-erase ping-pong that re-fires + // the pattern driver indefinitely when nothing's actually convertible. + DenseMap rootSet; + for (Value r : roots) rootSet[r] = r; // placeholder values + if (!canHandle(funcOp, rootSet)) return failure(); + + // Now we know we have memref work to do. Create the to_tensor ops. + rewriter.setInsertionPointToStart(&funcOp.getBody().front()); + MultiRootCtx ctx; + ctx.rewriter = &rewriter; + SmallVector initial; + for (Value root : roots) { + if (auto alloc = root.getDefiningOp()) + rewriter.setInsertionPointAfter(alloc); + auto memrefType = root.getType().cast(); + auto tensorType = RankedTensorType::get(memrefType.getShape(), + memrefType.getElementType()); + auto t = rewriter.create( + root.getLoc(), tensorType, root); + ctx.rootToTensor[root] = t.getResult(); + ctx.rootInitial[root] = t.getResult(); + initial.push_back(t); + } + + walkBlock(ctx, funcOp.getBody().front()); + + if (!ctx.didRewrite) { + for (auto t : initial) + if (t.getResult().use_empty()) rewriter.eraseOp(t); + return failure(); + } + + // Write back any roots whose tensor state diverged from the initial. + for (auto [root, curT] : ctx.rootToTensor) { + if (curT == ctx.rootInitial[root]) continue; + rewriter.setInsertionPointAfterValue(curT); + auto memrefType = root.getType().cast(); + auto toMr = rewriter.create( + root.getLoc(), memrefType, curT); + rewriter.create(root.getLoc(), toMr, root); + } + return success(); +} + +// A generic that connects independently rooted buffers must be tensorized as +// one transaction. Processing one root at a time can legally rewrite the +// consumer before the producer root, then erase the producer computation as +// dead buffer work. Count all memref operands, not just outputs: the common +// producer-temp-consumer chain has one output root per generic but still +// carries data across roots. +static bool hasCrossRootGeneric(func::FuncOp funcOp) { + bool found = false; + funcOp.walk([&](linalg::GenericOp generic) { + SetVector roots; + for (Value operand : generic->getOperands()) + if (operand.getType().isa()) + roots.insert(findRoot(operand)); + if (roots.size() > 1) { + found = true; + return WalkResult::interrupt(); + } + return WalkResult::advance(); + }); + return found; +} + +} // namespace multiroot + +struct LinalgDebufferizationMultiRoot + : public OpRewritePattern { + LinalgDebufferizationMultiRoot(MLIRContext *context, + PatternBenefit benefit = 1, + bool onlyWhenRequired = false) + : OpRewritePattern(context, benefit), + onlyWhenRequired(onlyWhenRequired) {} + LogicalResult matchAndRewrite(func::FuncOp funcOp, + PatternRewriter &rewriter) const final { + if (funcOp.isExternal() || funcOp.empty()) return failure(); + if (!llvm::hasSingleElement(funcOp.getBody())) return failure(); + if (onlyWhenRequired && + !multiroot::hasCrossRootGeneric(funcOp)) + return failure(); + return multiroot::handleAllRoots(funcOp, rewriter); + } + +private: + bool onlyWhenRequired; +}; + +struct LinalgDebufferizationRecursive : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(func::FuncOp funcOp, + PatternRewriter &rewriter) const final { + if (funcOp.isExternal() || funcOp.empty()) return failure(); + // Multi-block CFG isn't supported yet; future stages will follow cf.br. + if (!llvm::hasSingleElement(funcOp.getBody())) return failure(); + Block *body = &funcOp.getBody().front(); + bool anyChanged = false; + + SmallVector roots; + funcOp.walk([&](memref::AllocaOp op) { roots.push_back(op.getResult()); }); + funcOp.walk([&](memref::AllocOp op) { roots.push_back(op.getResult()); }); + for (auto arg : funcOp.getArguments()) + if (arg.getType().isa()) roots.push_back(arg); + + for (Value root : roots) { + if (succeeded(v2::handleRoot(root, body, rewriter))) + anyChanged = true; + } + return anyChanged ? success() : failure(); + } +}; + +namespace { +struct LinalgDebufferize : public LinalgDebufferizeBase { + void runOnOperation() override; +}; +} // namespace + +void LinalgDebufferize::runOnOperation() { + auto module = getOperation()->getParentOfType(); + RewritePatternSet patterns(&getContext()); + if (useMultiRoot) { + patterns.insert(&getContext()); + } else if (useRecursive) { + // Cross-root linalg dataflow must be converted atomically. Prefer the + // joint walker when it can handle the whole function; its feasibility + // check fails without mutation and lets the recursive implementation + // cover richer control flow and loop-local scratch as a safe fallback. + patterns.insert( + &getContext(), /*benefit=*/2, /*onlyWhenRequired=*/true); + patterns.insert(&getContext(), + /*benefit=*/1); + } else { + patterns.insert(&getContext()); + } + patterns.insert(&getContext()); + GreedyRewriteConfig config; + (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns), + config); +} + +namespace mlir { +namespace polygeist { +std::unique_ptr createLinalgDebufferizePass() { + return std::make_unique(); +} +} // namespace polygeist +} // namespace mlir diff --git a/lib/polygeist/Passes/LinalgToKernel.cpp b/lib/polygeist/Passes/LinalgToKernel.cpp new file mode 100644 index 000000000000..3563c0ae4731 --- /dev/null +++ b/lib/polygeist/Passes/LinalgToKernel.cpp @@ -0,0 +1,765 @@ +//===- LinalgToKernel.cpp - Pattern to match linalg.generic with kernel.defn ------===// +// +// This file implements a pattern to rewrite linalg.generic operations to kernel +// operations by matching against patterns defined in kernel.defn_collection. +// +//===----------------------------------------------------------------------===// + +#include "PassDetails.h" + +#include "mlir/Dialect/Bufferization/IR/Bufferization.h" +#include "mlir/Dialect/Linalg/IR/Linalg.h" +#include "mlir/Dialect/Tensor/IR/Tensor.h" +#include "mlir/IR/PatternMatch.h" +#include "mlir/Transforms/GreedyPatternRewriteDriver.h" +#include "mlir/Parser/Parser.h" +#include "mlir/Support/FileUtilities.h" +#include "llvm/ADT/TypeSwitch.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/DenseSet.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/Support/SourceMgr.h" +#include "llvm/Support/ToolOutputFile.h" +#include "llvm/Support/Debug.h" +#include "polygeist/Kernel/KernelDialect.h" +#include "polygeist/Kernel/KernelOps.h" +#include "polygeist/Passes/Passes.h" + +#include +#include +#include + +#define DEBUG_TYPE "linalg-to-kernel" + +using namespace mlir; +using namespace mlir::linalg; +using namespace mlir::polygeist; +using namespace mlir::polygeist::kernel; + +namespace { + +// Structure to represent an operation node in the dependency graph +struct OpNode { + Operation *op; + StringRef opName; + SmallVector operandTypes; + SmallVector resultTypes; + SmallVector dependencies; // Operations this depends on + SmallVector dependents; // Operations that depend on this + + OpNode(Operation *operation) : op(operation) { + if (operation) { + // Regular operation node + opName = operation->getName().getStringRef(); + for (Value operand : operation->getOperands()) { + operandTypes.push_back(operand.getType()); + } + for (Value result : operation->getResults()) { + resultTypes.push_back(result.getType()); + } + } else { + // Special node for block arguments - will be set later + opName = "block_arg"; + } + } + + // Check if two nodes are structurally equivalent (same operation type and types) + bool isEquivalentTo(const OpNode &other) const { + return opName == other.opName && + operandTypes == other.operandTypes && + resultTypes == other.resultTypes; + } +}; + +// Structure to represent a dependency graph for a region +struct DependencyGraph { + SmallVector> nodes; + DenseMap opToNode; + SmallVector blockArgNodes; // Special nodes for block arguments + + void buildFromRegion(Region ®ion) { + // Process each block in the region + for (Block &block : region.getBlocks()) { + + // Create pseudo-nodes for block arguments + for (BlockArgument arg : block.getArguments()) { + // Block arguments are represented as special nodes + auto argNode = std::make_unique(nullptr); + argNode->resultTypes.push_back(arg.getType()); + blockArgNodes.push_back(argNode.get()); + + // Map the block argument value to this node for dependency tracking + // We'll use a separate map for this + nodes.push_back(std::move(argNode)); + } + + // Create nodes for each operation + for (Operation &op : block.getOperations()) { + auto node = std::make_unique(&op); + OpNode *nodePtr = node.get(); + opToNode[&op] = nodePtr; + nodes.push_back(std::move(node)); + } + + // Build dependency edges + for (Operation &op : block.getOperations()) { + OpNode *currentNode = opToNode[&op]; + + // For each operand, find what it depends on + for (Value operand : op.getOperands()) { + if (auto blockArg = dyn_cast(operand)) { + // Depends on a block argument + size_t argIndex = blockArg.getArgNumber(); + if (argIndex < blockArgNodes.size()) { + OpNode *argNode = blockArgNodes[argIndex]; + currentNode->dependencies.push_back(argNode); + argNode->dependents.push_back(currentNode); + } + } else if (Operation *definingOp = operand.getDefiningOp()) { + // Depends on another operation + if (opToNode.count(definingOp)) { + OpNode *depNode = opToNode[definingOp]; + currentNode->dependencies.push_back(depNode); + depNode->dependents.push_back(currentNode); + } + } + } + } + } + } + + // Get nodes in topological order (dependencies first) + SmallVector getTopologicalOrder() const { + SmallVector result; + DenseSet visited; + + std::function dfs = [&](OpNode* node) { + if (visited.contains(node)) return; + visited.insert(node); + + // Visit all dependencies first + for (OpNode* dep : node->dependencies) { + dfs(dep); + } + + result.push_back(node); + }; + + // Start DFS from all nodes + for (const auto &node : nodes) { + dfs(node.get()); + } + + return result; + } +}; + +// Enhanced region equivalence check using dependency graphs +bool areRegionsEquivalent(Region &first, Region &second, DenseMap &nodeMapping, + DenseMap &operationMapping) { + // Clear the output mappings + nodeMapping.clear(); + operationMapping.clear(); + + // Fast early checks before expensive graph construction + + // Check number of blocks + if (first.getBlocks().size() != second.getBlocks().size()) { + return false; + } + + // Check each block's basic properties + for (auto blockPair : llvm::zip(first.getBlocks(), second.getBlocks())) { + Block &firstBlock = std::get<0>(blockPair); + Block &secondBlock = std::get<1>(blockPair); + + // Check number of arguments + if (firstBlock.getNumArguments() != secondBlock.getNumArguments()) { + return false; + } + + // Check argument types + for (auto argPair : llvm::zip(firstBlock.getArguments(), secondBlock.getArguments())) { + if (std::get<0>(argPair).getType() != std::get<1>(argPair).getType()) { + return false; + } + } + + // Check number of operations + if (firstBlock.getOperations().size() != secondBlock.getOperations().size()) { + return false; + } + } + + // If basic checks pass, proceed with detailed graph-based analysis + // Build dependency graphs for both regions + DependencyGraph firstGraph, secondGraph; + firstGraph.buildFromRegion(first); + secondGraph.buildFromRegion(second); + + // Quick structural checks + if (firstGraph.nodes.size() != secondGraph.nodes.size()) { + return false; + } + + if (firstGraph.blockArgNodes.size() != secondGraph.blockArgNodes.size()) { + return false; + } + + // Get topological orderings + auto firstOrder = firstGraph.getTopologicalOrder(); + auto secondOrder = secondGraph.getTopologicalOrder(); + + if (firstOrder.size() != secondOrder.size()) { + return false; + } + + // Compare nodes in topological order and build mapping + for (size_t i = 0; i < firstOrder.size(); ++i) { + OpNode *firstNode = firstOrder[i]; + OpNode *secondNode = secondOrder[i]; + + // Check if the nodes are structurally equivalent + if (!firstNode->isEquivalentTo(*secondNode)) { + return false; + } + + // Check if dependency structure matches + if (firstNode->dependencies.size() != secondNode->dependencies.size()) { + return false; + } + + // Verify that dependencies map correctly + for (size_t j = 0; j < firstNode->dependencies.size(); ++j) { + OpNode *firstDep = firstNode->dependencies[j]; + OpNode *secondDep = secondNode->dependencies[j]; + + // Check if we've established a mapping for these dependencies + auto it = nodeMapping.find(firstDep); + if (it != nodeMapping.end()) { + if (it->second != secondDep) { + return false; // Inconsistent mapping + } + } else { + nodeMapping[firstDep] = secondDep; + } + } + + // Establish mapping for current nodes + nodeMapping[firstNode] = secondNode; + + // Build the operation mapping directly from OpNode data while still valid + if (firstNode->op && secondNode->op) { + operationMapping[firstNode->op] = secondNode->op; + } + } + + return true; +} + +// Helper to check if indexing maps are equivalent +bool areIndexingMapsEquivalent(ArrayAttr firstMaps, ArrayAttr secondMaps) { + if (firstMaps.size() != secondMaps.size()) + return false; + + for (auto mapPair : llvm::zip(firstMaps, secondMaps)) { + auto firstMap = std::get<0>(mapPair).cast().getValue(); + auto secondMap = std::get<1>(mapPair).cast().getValue(); + + if (firstMap != secondMap) + return false; + } + + return true; +} + +// Helper to check if iterator types are equivalent +bool areIteratorTypesEquivalent(ArrayAttr firstTypes, ArrayAttr secondTypes) { + if (firstTypes.size() != secondTypes.size()) + return false; + + for (auto typePair : llvm::zip(firstTypes, secondTypes)) { + auto firstType = std::get<0>(typePair).cast().getValue(); + auto secondType = std::get<1>(typePair).cast().getValue(); + + if (firstType != secondType) + return false; + } + + return true; +} + +// Helper function to find the corresponding value in actual IR for a kernel block argument +Value findCorrespondingValue(BlockArgument kernelArg, + const DenseMap &operationMapping, + GenericOp genericOp) { + + LLVM_DEBUG(llvm::dbgs() << "Finding corresponding value for kernel arg #" << kernelArg.getArgNumber() + << " with type " << kernelArg.getType() << "\n"); + + // First, check if this kernel argument is used as an operand to the linalg.generic itself + // This handles tensor arguments that become ins/outs operands + for (Operation *kernelUser : kernelArg.getUsers()) { + LLVM_DEBUG(llvm::dbgs() << "Kernel arg used by: " << *kernelUser << "\n"); + + // Check if the user is a linalg.generic operation + if (auto kernelGeneric = dyn_cast(kernelUser)) { + LLVM_DEBUG(llvm::dbgs() << "Kernel arg is used by linalg.generic as operand\n"); + + // Find which operand position kernelArg occupies in the kernel's linalg.generic + size_t operandIndex = 0; + for (Value operand : kernelGeneric->getOperands()) { + if (operand == kernelArg) { + LLVM_DEBUG(llvm::dbgs() << "Kernel arg is at operand index " << operandIndex + << " of kernel linalg.generic\n"); + + // The corresponding operand in the actual linalg.generic should be at the same position + if (operandIndex < genericOp->getNumOperands()) { + Value actualOperand = genericOp->getOperand(operandIndex); + LLVM_DEBUG(llvm::dbgs() << "Found corresponding actual operand: " << actualOperand << "\n"); + return actualOperand; + } else { + LLVM_DEBUG(llvm::dbgs() << "ERROR - operand index out of bounds in actual generic\n"); + } + break; + } + operandIndex++; + } + + // If we found a linalg.generic usage, we're done with this user + break; + } + } + + // If we reach here, this might be a scalar argument used inside the region + // For scalar arguments like %arg3, %arg4, use operation mapping to trace usage + LLVM_DEBUG(llvm::dbgs() << "Checking if kernel arg is a scalar used inside region\n"); + + for (Operation *kernelUser : kernelArg.getUsers()) { + // Skip if this is the linalg.generic itself (already handled above) + if (isa(kernelUser)) continue; + + LLVM_DEBUG(llvm::dbgs() << "Kernel arg used by operation: " << *kernelUser << "\n"); + + // Find the corresponding operation in actual IR using the fixed mapping + // Note: operationMapping is actualOp -> kernelOp, so we need to reverse-search + auto it = std::find_if(operationMapping.begin(), operationMapping.end(), + [kernelUser](const auto& pair) { + return pair.second == kernelUser; + }); + if (it != operationMapping.end()) { + Operation *actualUser = it->first; // The actual IR operation + LLVM_DEBUG(llvm::dbgs() << "Found corresponding actual operation: " << *actualUser << "\n"); + + // Find which operand position kernelArg occupies in kernelUser + size_t operandIndex = 0; + for (Value operand : kernelUser->getOperands()) { + if (operand == kernelArg) { + LLVM_DEBUG(llvm::dbgs() << "Kernel arg is at operand index " << operandIndex << "\n"); + + // Get the corresponding operand from actual IR + if (operandIndex < actualUser->getNumOperands()) { + Value actualOperand = actualUser->getOperand(operandIndex); + LLVM_DEBUG(llvm::dbgs() << "Found corresponding actual operand: " << actualOperand << "\n"); + return actualOperand; + } else { + LLVM_DEBUG(llvm::dbgs() << "ERROR - operand index out of bounds\n"); + } + break; + } + operandIndex++; + } + } else { + LLVM_DEBUG(llvm::dbgs() << "Could not find corresponding operation in operationMapping\n"); + } + } + + // Fallback: if operation mapping fails, try type matching as last resort + LLVM_DEBUG(llvm::dbgs() << "Fallback to type matching for function arguments\n"); + + auto func = genericOp->getParentOfType(); + if (func) { + LLVM_DEBUG(llvm::dbgs() << "Found parent function with " << func.getNumArguments() << " arguments\n"); + + // Look for function arguments with matching type + for (auto funcArg : func.getArguments()) { + if (funcArg.getType() == kernelArg.getType()) { + LLVM_DEBUG(llvm::dbgs() << "Found function argument with matching type: " << funcArg << "\n"); + // TODO: This is still not ideal - should be improved with better analysis + return funcArg; + } + } + } + + LLVM_DEBUG(llvm::dbgs() << "ERROR - Could not find corresponding value for kernel arg\n"); + return nullptr; +} + +// Structure to hold the result of matching a generic operation with a kernel definition +struct KernelMatchResult { + StringRef kernelName; + DenseMap operationMapping; // actual op -> kernel op + kernel::DefnOp matchedDefnOp; +}; + +// Check if a linalg.generic operation matches a kernel.defn in a collection +FailureOr matchGenericWithDefn( + GenericOp genericOp, + kernel::DefnCollectionOp collectionOp) { + + // Get attributes from the generic operation + ArrayAttr indexingMaps = genericOp.getIndexingMapsAttr(); + ArrayAttr iteratorTypes = genericOp.getIteratorTypesAttr(); + unsigned numInputs = genericOp.getNumDpsInputs(); + unsigned numOutputs = genericOp.getNumDpsInits(); + + // Variables to capture the match result + StringRef matchedOpName; + DenseMap matchedOperationMapping; + kernel::DefnOp matchedDefnOp; + + SmallVector defnOps; + + //llvm::errs() << "DEBUG: kernel.defn_collection contents:\n"; + //llvm::errs() << collectionOp; + //llvm::errs() << collectionOp.getOperation(); + //llvm::errs() << "\n"; + collectionOp.walk([&](kernel::DefnOp defnOp) { + defnOps.push_back(defnOp); + }); + + bool foundMatch = false; + + // Walk through each defn in the collection + for (auto defnOp : defnOps) { + + StringRef opName = defnOp.getSymName(); + LLVM_DEBUG(llvm::dbgs() << "Checking kernel defn: " << opName << "\n"); + + // Check for linalg.generic in the defn's body + GenericOp candidateOp; + + defnOp.walk([&](GenericOp genericOp) { + candidateOp = genericOp; //TODO: Add checks to make sure there is only single linalg.generic in the defn + }); + + if(!candidateOp) { + LLVM_DEBUG(llvm::dbgs() << "No linalg.generic found in defn " << opName << "\n"); + continue; + } + + LLVM_DEBUG(llvm::dbgs() << "Found linalg.generic in defn " << opName << "\n"); + LLVM_DEBUG(llvm::dbgs() << "Candidate numInputs=" << candidateOp.getNumDpsInputs() + << ", target numInputs=" << numInputs << "\n"); + LLVM_DEBUG(llvm::dbgs() << "Candidate numOutputs=" << candidateOp.getNumDpsInits() + << ", target numOutputs=" << numOutputs << "\n"); + + // Check if this linalg.generic matches our target + DenseMap nodeMapping; + DenseMap operationMapping; // Added for findCorrespondingValue + if (candidateOp.getNumDpsInputs() == numInputs && + candidateOp.getNumDpsInits() == numOutputs && + areIndexingMapsEquivalent(candidateOp.getIndexingMapsAttr(), indexingMaps) && + areIteratorTypesEquivalent(candidateOp.getIteratorTypesAttr(), iteratorTypes) && + areRegionsEquivalent(genericOp.getRegion(), candidateOp.getRegion(), nodeMapping, operationMapping)) { + LLVM_DEBUG(llvm::dbgs() << "MATCH FOUND for defn " << opName << "\n"); + foundMatch = true; + matchedOpName = opName; + matchedOperationMapping = operationMapping; // Store the operation mapping + matchedDefnOp = defnOp; // Store the matched defnOp + } else { + LLVM_DEBUG(llvm::dbgs() << "No match for defn " << opName << "\n"); + LLVM_DEBUG(llvm::dbgs() << "Input/output check: " + << (candidateOp.getNumDpsInputs() == numInputs) << "\n"); + LLVM_DEBUG(llvm::dbgs() << "Maps check: " + << areIndexingMapsEquivalent(candidateOp.getIndexingMapsAttr(), indexingMaps) << "\n"); + LLVM_DEBUG(llvm::dbgs() << "Iterator types check: " + << areIteratorTypesEquivalent(candidateOp.getIteratorTypesAttr(), iteratorTypes) << "\n"); + LLVM_DEBUG(llvm::dbgs() << "Regions check: " + << areRegionsEquivalent(genericOp.getRegion(), candidateOp.getRegion(), nodeMapping, operationMapping) << "\n"); + } + + if (foundMatch) { + return KernelMatchResult{matchedOpName, matchedOperationMapping, matchedDefnOp}; + } + } + + return failure(); +} + +// Rewrite pattern to convert linalg.generic to kernel ops +class LinalgGenericToKernelPattern : public OpRewritePattern { +public: + LinalgGenericToKernelPattern(MLIRContext *context, + kernel::DefnCollectionOp collectionOp) + : OpRewritePattern(context), collectionOp(collectionOp) {} + + LogicalResult matchAndRewrite(GenericOp genericOp, + PatternRewriter &rewriter) const override { + + LLVM_DEBUG(llvm::dbgs() << "matchAndRewrite called for genericOp:\n"); + LLVM_DEBUG(llvm::dbgs() << genericOp << "\n"); + + auto module = genericOp->getParentOfType(); + //Check if the parent of the generic op is a kernel.defn + if (auto parentOp = genericOp->getParentOp()) { + if (isa(parentOp)) { + LLVM_DEBUG(llvm::dbgs() << "Skipping genericOp inside kernel.defn\n"); + return failure(); + } + } + + // Try to match with a defn in the collection + auto matchResult = matchGenericWithDefn(genericOp, collectionOp); + if (failed(matchResult)) { + LLVM_DEBUG(llvm::dbgs() << "No match found in collection\n"); + return failure(); + } + + StringRef opName = matchResult->kernelName; + LLVM_DEBUG(llvm::dbgs() << "Match found with kernel: " << opName << "\n"); + + // Find the matched kernel.defn operation + kernel::DefnOp matchedDefnOp = matchResult->matchedDefnOp; + + if (!matchedDefnOp) { + return failure(); + } + + // Check if the kernel.defn already exists in the target module + kernel::DefnOp existingDefn; + module.walk([&](kernel::DefnOp defnOp) { + if (defnOp.getSymName() == opName) { + // Check if this defn is inside a defn_collection (template) or at module level (callable) + if (!defnOp->getParentOfType()) { + existingDefn = defnOp; + return WalkResult::interrupt(); + } + } + return WalkResult::advance(); + }); + + // If the kernel.defn doesn't exist in the module, copy it + if (!existingDefn) { + // Clone the matched kernel.defn operation + rewriter.setInsertionPointToStart(module.getBody()); + auto clonedDefn = rewriter.clone(*matchedDefnOp.getOperation()); + (void)clonedDefn; // Suppress unused variable warning + } + + // Create kernel.launch operation to replace the genericOp + Location loc = genericOp.getLoc(); + + // Set insertion point to the genericOp location + rewriter.setInsertionPoint(genericOp); + + // Get the kernel function signature to map all arguments + Block &kernelBlock = matchedDefnOp.getRegion().front(); + auto kernelArgs = kernelBlock.getArguments(); + + // Use the operationMapping from the match result (no need to call areRegionsEquivalent again) + const DenseMap &operationMapping = matchResult->operationMapping; + + // Use unified approach: map ALL kernel arguments to their corresponding actual values + SmallVector operands; + LLVM_DEBUG(llvm::dbgs() << "Starting to map " << kernelArgs.size() << " kernel arguments\n"); + + for (BlockArgument kernelArg : kernelArgs) { + Value actualValue = findCorrespondingValue(kernelArg, operationMapping, genericOp); + if (!actualValue) { + LLVM_DEBUG(llvm::dbgs() << "Failed to find corresponding value for kernel arg #" + << kernelArg.getArgNumber() << " - returning failure\n"); + return failure(); // Could not find corresponding value + } + operands.push_back(actualValue); + } + + LLVM_DEBUG(llvm::dbgs() << "Successfully mapped all kernel arguments, creating kernel.launch\n"); + + // Get kernel function signature types for casting + auto kernelFuncType = matchedDefnOp.getFunctionType(); + auto kernelInputTypes = kernelFuncType.getInputs(); + auto kernelResultTypes = kernelFuncType.getResults(); + + // Cast operands to match kernel signature types if needed + SmallVector castedOperands; + for (size_t i = 0; i < operands.size(); ++i) { + Value operand = operands[i]; + Type expectedType = (i < kernelInputTypes.size()) ? kernelInputTypes[i] : operand.getType(); + + if (operand.getType() != expectedType) { + // Insert tensor.cast for type conversion + if (isa(operand.getType()) && isa(expectedType)) { + LLVM_DEBUG(llvm::dbgs() << "Casting operand " << i << " from " << operand.getType() + << " to " << expectedType << "\n"); + auto castOp = rewriter.create(loc, expectedType, operand); + castedOperands.push_back(castOp.getResult()); + } else { + // For non-tensor types, use the operand as-is + castedOperands.push_back(operand); + } + } else { + castedOperands.push_back(operand); + } + } + + // Get result types from the generic operation + TypeRange originalResultTypes = genericOp.getResultTypes(); + + // Create the kernel.launch operation with casted operands and kernel result types + auto launchOp = rewriter.create( + loc, + kernelResultTypes, // Use kernel result types for the launch op + opName, + castedOperands // Use casted operands + ); + + // Cast results back to original types if needed + SmallVector finalResults; + for (size_t i = 0; i < launchOp.getResults().size(); ++i) { + Value result = launchOp.getResult(i); + Type originalType = (i < originalResultTypes.size()) ? originalResultTypes[i] : result.getType(); + + if (result.getType() != originalType) { + // Insert tensor.cast to convert back to original type + if (isa(result.getType()) && isa(originalType)) { + LLVM_DEBUG(llvm::dbgs() << "Casting result " << i << " from " << result.getType() + << " to " << originalType << "\n"); + auto castOp = rewriter.create(loc, originalType, result); + finalResults.push_back(castOp.getResult()); + } else { + finalResults.push_back(result); + } + } else { + finalResults.push_back(result); + } + } + + // Replace the generic operation with the final results + rewriter.replaceOp(genericOp, finalResults); + + return success(); + } + +private: + kernel::DefnCollectionOp collectionOp; +}; + +// Pass to apply the rewrite pattern +struct LinalgToKernelPass : public LinalgToKernelBase { + using LinalgToKernelBase::LinalgToKernelBase; + + // Constructor that allows setting the kernel library path + LinalgToKernelPass() = default; + LinalgToKernelPass(const std::string& libraryPath) : externalLibraryPath(libraryPath) {} + + void runOnOperation() override { + ModuleOp module = getOperation(); + + kernel::DefnCollectionOp collectionOp = nullptr; + OwningOpRef externalModule; + // Determine which path to use for kernel library + std::string effectiveLibraryPath = externalLibraryPath; + // If no external path was provided via constructor, try the command line option + if (effectiveLibraryPath.empty()) { + effectiveLibraryPath = std::string(kernelLibraryPath); + } + + //// Debug output + //llvm::errs() << "DEBUG: externalLibraryPath = '" << externalLibraryPath << "'\n"; + //llvm::errs() << "DEBUG: kernelLibraryPath = '" << std::string(kernelLibraryPath) << "'\n"; + //llvm::errs() << "DEBUG: effectiveLibraryPath = '" << effectiveLibraryPath << "'\n"; + + // Check if we should load kernel definitions from an external file + if (!effectiveLibraryPath.empty()) { + //llvm::errs() << "DEBUG: Loading kernel definitions from external file: " << effectiveLibraryPath << "\n"; + // Load kernel definitions from external file + std::string errorMessage; + auto memoryBuffer = mlir::openInputFile(effectiveLibraryPath, &errorMessage); + if (!memoryBuffer) { + module.emitError("Failed to open kernel library file: ") << effectiveLibraryPath + << " - " << errorMessage; + return signalPassFailure(); + } + + // Parse the external file + llvm::SourceMgr sourceMgr; + sourceMgr.AddNewSourceBuffer(std::move(memoryBuffer), llvm::SMLoc()); + + externalModule = mlir::parseSourceFile(sourceMgr, &getContext()); + if (!externalModule) { + module.emitError("Failed to parse kernel library file: ") << effectiveLibraryPath; + return signalPassFailure(); + } + + // Debug: Print the loaded external module + //llvm::errs() << "DEBUG: Successfully loaded external module:\n"; + //externalModule->print(llvm::errs()); + //llvm::errs() << "\n"; + + // Find the kernel.defn_collection in the external module + externalModule->walk([&](kernel::DefnCollectionOp op) { + collectionOp = op; + LLVM_DEBUG(llvm::dbgs() << "Found kernel.defn_collection in external module\n"); + return WalkResult::interrupt(); + }); + + if (!collectionOp) { + module.emitError("No kernel.defn_collection found in external kernel library: ") + << effectiveLibraryPath; + return signalPassFailure(); + } + + // Debug: Print the found collection + //llvm::errs() << "DEBUG: kernel.defn_collection contents:\n"; + //llvm::errs() << collectionOp; + //llvm::errs() << collectionOp.getOperation(); + //llvm::errs() << "\n"; + } else { + // Find the kernel.defn_collection in the current module (original behavior) + module.walk([&](kernel::DefnCollectionOp op) { + collectionOp = op; + return WalkResult::interrupt(); + }); + + if (!collectionOp) { + module.emitError("No kernel.defn_collection found in module. " + "Either include one in the input module or specify " + "--kernel-library-path to load from external file."); + return signalPassFailure(); + } + } + + // Apply the rewrite pattern + RewritePatternSet patterns(&getContext()); + patterns.add(&getContext(), collectionOp); + + //llvm::errs() << "DEBUG: kernel.defn_collection contents:\n"; + //llvm::errs() << collectionOp.getOperation(); + //llvm::errs() << "\n"; + //llvm::errs() << collectionOp; + //llvm::errs() << "\n"; + + if (failed(applyPatternsAndFoldGreedily(module, std::move(patterns)))) + return signalPassFailure(); + } + +private: + std::string externalLibraryPath; +}; + +} // namespace + +namespace mlir::polygeist { + +// Create a pass to convert linalg.generic to kernel +std::unique_ptr createLinalgToKernelPass() { + return std::make_unique(); +} + +// Create a pass to convert linalg.generic to kernel with kernel library path +std::unique_ptr createLinalgToKernelPass(const std::string& kernelLibraryPath) { + return std::make_unique(kernelLibraryPath); +} + +} // namespace mlir::polygeist \ No newline at end of file diff --git a/lib/polygeist/Passes/LowerKernelLaunch.cpp b/lib/polygeist/Passes/LowerKernelLaunch.cpp new file mode 100644 index 000000000000..09dba143b535 --- /dev/null +++ b/lib/polygeist/Passes/LowerKernelLaunch.cpp @@ -0,0 +1,187 @@ +//===- LowerKernelLaunch.cpp - inline kernel.defn bodies into launches ----===// +// +// Phase-2 lowering for the kernel-matcher pipeline. For each `kernel.launch +// @(operands)` op, finds `kernel.defn @` (in the same module or +// in a separately-loaded library file via the `kernel-library-path` option), +// clones the defn body into the launch's parent block, maps defn block args +// to launch operands, and replaces the launch's result SSA with the value +// yielded by `kernel.yield`. The kernel.launch is then erased. +// +// Phase-1 of the pipeline (kernel_match_rewrite.py --with-roundtrip-markers +// + kernel_launch_lower.py) stashes the matcher's pre-match linalg verbatim +// and restores it; that validates plumbing but not matcher labels because +// the round-trip is a no-op by construction. Phase-2 (this pass) substitutes +// a *canonical* linalg implementation from the library so that a +// wrongly-labeled kernel.launch produces different numerics from the user's +// original code and fails the e2e diff against clang. +// +//===----------------------------------------------------------------------===// + +#include "PassDetails.h" + +#include "mlir/Dialect/Arith/IR/Arith.h" +#include "mlir/Dialect/Func/IR/FuncOps.h" +#include "mlir/Dialect/Linalg/IR/Linalg.h" +#include "mlir/Dialect/Math/IR/Math.h" +#include "mlir/Dialect/Tensor/IR/Tensor.h" +#include "mlir/IR/Builders.h" +#include "mlir/IR/BuiltinOps.h" +#include "mlir/IR/IRMapping.h" +#include "mlir/IR/SymbolTable.h" +#include "mlir/Parser/Parser.h" +#include "mlir/Pass/Pass.h" +#include "mlir/Support/FileUtilities.h" +#include "polygeist/Kernel/KernelDialect.h" +#include "polygeist/Kernel/KernelOps.h" +#include "polygeist/Passes/Passes.h" +#include "llvm/Support/Debug.h" +#include "llvm/Support/SourceMgr.h" + +#define DEBUG_TYPE "lower-kernel-launch" + +using namespace mlir; +using namespace mlir::polygeist; +using namespace mlir::polygeist::kernel; + +namespace { + +// Returns the DefnOp inside `module` (or `library`) named `name`, or nullptr. +static DefnOp findDefn(ModuleOp module, ModuleOp library, StringRef name) { + if (auto d = module.lookupSymbol(name)) + return d; + if (library) + return library.lookupSymbol(name); + return nullptr; +} + +// Inline the body of `defn` in place of `launch`. The defn's block arguments +// are mapped to the launch's operands; the defn's terminating kernel.yield +// values are substituted for the launch's results. +// +// Returns success iff the substitution completed and the launch was erased. +static LogicalResult inlineDefnIntoLaunch(LaunchOp launch, DefnOp defn) { + if (defn.isDeclaration()) + return launch.emitError("kernel.defn '") << defn.getSymName() << "' is a declaration (empty body); cannot inline"; + + Block &defnBlock = defn.getBody().front(); + if (defnBlock.getNumArguments() != launch.getOperands().size()) + return launch.emitError("kernel.launch operand count (") + << launch.getOperands().size() + << ") does not match kernel.defn '" << defn.getSymName() + << "' parameter count (" << defnBlock.getNumArguments() << ")"; + + IRMapping mapping; + for (auto [blockArg, operand] : + llvm::zip(defnBlock.getArguments(), launch.getOperands())) { + if (blockArg.getType() != operand.getType()) + return launch.emitError("operand type mismatch: kernel.defn '") + << defn.getSymName() << "' expects " << blockArg.getType() + << " for parameter, got " << operand.getType(); + mapping.map(blockArg, operand); + } + + // Clone every op except the terminator into the launch's parent block, + // immediately before the launch. + OpBuilder builder(launch); + YieldOp yield; + for (Operation &op : defnBlock.without_terminator()) { + builder.clone(op, mapping); + } + // Find the terminator (kernel.yield) and resolve the launch's results. + yield = cast(defnBlock.getTerminator()); + if (yield.getNumOperands() != launch.getNumResults()) + return launch.emitError("kernel.yield arity (") + << yield.getNumOperands() << ") does not match kernel.launch result arity (" + << launch.getNumResults() << ")"; + + SmallVector remappedResults; + for (Value y : yield.getOperands()) { + Value mapped = mapping.lookupOrNull(y); + if (!mapped) + return launch.emitError("kernel.yield references value not produced by inlined body"); + remappedResults.push_back(mapped); + } + launch.replaceAllUsesWith(remappedResults); + launch.erase(); + return success(); +} + +struct LowerKernelLaunchPass + : public mlir::polygeist::LowerKernelLaunchBase { + + // Helper: parse the kernel library file (if a path was given). Returns + // an OwningOpRef that must outlive any DefnOp lookups against the library. + OwningOpRef loadLibrary(MLIRContext *ctx) { + if (kernelLibraryPath.empty()) + return OwningOpRef(); + std::string err; + auto fileOrErr = openInputFile(kernelLibraryPath, &err); + if (!fileOrErr) { + getOperation().emitError( + "lower-kernel-launch: cannot open kernel-library-path '") + << kernelLibraryPath << "': " << err; + return OwningOpRef(); + } + llvm::SourceMgr sourceMgr; + sourceMgr.AddNewSourceBuffer(std::move(fileOrErr), llvm::SMLoc()); + auto parsed = parseSourceFile(sourceMgr, ctx); + if (!parsed) { + getOperation().emitError( + "lower-kernel-launch: failed to parse kernel library at '") + << kernelLibraryPath << "'"; + } + return parsed; + } + + void runOnOperation() override { + ModuleOp module = getOperation(); + OwningOpRef libraryHolder = loadLibrary(module.getContext()); + ModuleOp library = libraryHolder ? libraryHolder.get() : ModuleOp(); + + // Collect the launches up front; we'll erase them as we go. + SmallVector launches; + module.walk([&](LaunchOp op) { launches.push_back(op); }); + + for (LaunchOp launch : launches) { + auto sym = launch->getAttrOfType("kernel"); + if (!sym) { + launch.emitError("kernel.launch missing 'kernel' symbol ref"); + signalPassFailure(); + return; + } + DefnOp defn = findDefn(module, library, sym.getLeafReference().getValue()); + if (!defn) { + launch.emitError("lower-kernel-launch: no kernel.defn @") + << sym.getLeafReference().getValue() + << " found in input module or library"; + signalPassFailure(); + return; + } + if (failed(inlineDefnIntoLaunch(launch, defn))) { + signalPassFailure(); + return; + } + } + + // After inlining, any kernel.defn ops in the *input* module that have no + // remaining uses are dead — they were just symbol carriers. Don't touch + // the library module (it's separately owned). + SmallVector deadDefns; + module.walk([&](DefnOp d) { + if (SymbolTable::symbolKnownUseEmpty(d, module)) + deadDefns.push_back(d); + }); + for (DefnOp d : deadDefns) + d.erase(); + } +}; + +} // anonymous namespace + +namespace mlir { +namespace polygeist { +std::unique_ptr createLowerKernelLaunchPass() { + return std::make_unique(); +} +} // namespace polygeist +} // namespace mlir diff --git a/lib/polygeist/Passes/LowerKernelLaunchToCuBLAS.cpp b/lib/polygeist/Passes/LowerKernelLaunchToCuBLAS.cpp new file mode 100644 index 000000000000..d79d55e89c11 --- /dev/null +++ b/lib/polygeist/Passes/LowerKernelLaunchToCuBLAS.cpp @@ -0,0 +1,4167 @@ +//===- LowerKernelLaunchToCuBLAS.cpp - kernel.launch → cuBLAS ABI -------===// +// +// Phase-2 *ABI* lowering. Distinct from the canonical-defn lowering in +// `LowerKernelLaunch.cpp` (which inlines a reference linalg.generic body): +// this pass replaces each recognised `kernel.launch @(...)` with a +// `func.call` to the matching runtime shim ABI function declared in +// `runtime/polygeist_cublas_rt.h`. Link the shim object file (CPU stub +// for validation, cuBLAS-backed for hardware) to produce an executable. +// +// SUPPORTED LIBRARY SYMBOLS (extend by adding to `kLowerings`): +// @cublasDgemm → polygeist_cublas_dgemm(M, N, K, alpha, A, lda, B, ldb, +// beta, C, ldc) +// +// EXPECTED INPUT IR: +// `kernel.launch` ops live in TENSOR form (the matcher emits them in +// tensor form by default). For each launch we synthesise: +// - `bufferization.to_memref` for each tensor operand +// - dim queries (static when possible, `memref.dim` when dynamic) +// - the `func.call` to the shim ABI function +// - `bufferization.to_tensor restrict writable` to recover the result +// The forward declaration of each shim function is added to the module +// if not already present. +// +// OUT-OF-SCOPE (follow-up work): +// * Device-residency hoisting (eliminate H↔D copies between consecutive +// launches). The current per-call copies in the CUDA backend dominate +// for small matrices. +// * Non-f64 element types. +// * Other library symbols (axpy, axpby, gemv, scal, …). +// +//===----------------------------------------------------------------------===// + +#include "PassDetails.h" + +#include "KernelLaunchLoweringUtils.h" + +#include "mlir/Dialect/Arith/IR/Arith.h" +#include "mlir/Dialect/Bufferization/IR/Bufferization.h" +#include "mlir/Dialect/Func/IR/FuncOps.h" +#include "mlir/Dialect/LLVMIR/LLVMDialect.h" +#include "mlir/Dialect/MemRef/IR/MemRef.h" +#include "mlir/Dialect/Tensor/IR/Tensor.h" +#include "mlir/IR/Builders.h" +#include "mlir/IR/BuiltinOps.h" +#include "mlir/IR/SymbolTable.h" +#include "mlir/Pass/Pass.h" +#include "polygeist/Kernel/KernelDialect.h" +#include "polygeist/Kernel/KernelOps.h" +#include "polygeist/Passes/Passes.h" +#include "polygeist/Ops.h" +#include "llvm/ADT/SmallSet.h" +#include "llvm/Support/Debug.h" + +#include + +#define DEBUG_TYPE "lower-kernel-launch-to-cublas" + +using namespace mlir; +using namespace mlir::polygeist; +using namespace mlir::polygeist::kernel; + +namespace { + +// Symbol of the runtime ABI function for each supported library op. Add +// more entries here as the matcher's library grows. +struct ShimDecl { + StringRef shimSymbol; // e.g. "polygeist_cublas_dgemm" + // Arg types for the func.func private declaration. Filled lazily based + // on the launch's MLIR types so element types flow through. +}; + +static StringRef shimSymbolFor(StringRef libSym) { + if (libSym == "cublasDgemm") return "polygeist_cublas_dgemm"; + if (libSym == "cublasDgemm_simple") return "polygeist_cublas_dgemm"; + if (libSym == "cublasDgemm_alpha_only") return "polygeist_cublas_dgemm"; + if (libSym == "cublasSgemm_broadcast3d_simple") + return "polygeist_cublas_sgemm"; + if (libSym == "cublasSgemm_broadcast3d_memref") + return "polygeist_cublas_sgemm"; + if (libSym == "cublasSgemm_strided_batched_broadcast_rhs") + return "polygeist_cublas_sgemm_strided_batched_broadcast_rhs"; + if (libSym == "cublasDgeam_scale2D") return "polygeist_cublas_dscal_2d"; + if (libSym == "memset_zero_2D") return "polygeist_cublas_memset_zero_2d"; + if (libSym == "memset_zero_2D_f32") + return "polygeist_cublas_memset_zero_2d_f32"; + if (libSym == "memset_zero_1D") return "polygeist_cublas_memset_zero_1d"; + if (libSym == "memset_zero_1D_f32") + return "polygeist_cublas_memset_zero_1d_f32"; + if (libSym == "cublasDgemv") return "polygeist_cublas_dgemv"; + if (libSym == "cublasDgemv_T") return "polygeist_cublas_dgemv_T"; + if (libSym == "cublasSgemv") return "polygeist_cublas_sgemv"; + if (libSym == "cublasSgemv_T") return "polygeist_cublas_sgemv_T"; + if (libSym == "cublasDgemv_alpha") return "polygeist_cublas_dgemv_alpha"; + if (libSym == "cublasDaxpby") return "polygeist_cublas_daxpby"; + if (libSym == "cublasDaxpy_unit") return "polygeist_cublas_daxpy_unit"; + if (libSym == "cublasDger_rank2") return "polygeist_cublas_dger_rank2"; + if (libSym == "cublasDgemm_outer_product") + return "polygeist_cublas_dgemm_outer_product"; + if (libSym == "cudnnConvolution2D_9tap") + return "polygeist_cudnn_conv2d_polybench9tap"; + if (libSym == "cudnnConvolution2D_9tap_f32") + return "polygeist_cudnn_conv2d_3x3_f32"; + if (libSym == "cudnnConvolution2D_9tap_f16") + return "polygeist_cudnn_conv2d_3x3_f16"; + if (libSym == "cudnnConvolution2D_9tap_bf16") + return "polygeist_cudnn_conv2d_3x3_bf16"; + if (libSym == "cudnnConvolution2D_9tap_i32") + return "polygeist_cudnn_conv2d_3x3_i32"; + if (libSym == "cudnnConvolution2D_25tap") + return "polygeist_cudnn_conv2d_5x5_f64"; + if (libSym == "cudnnConvolution2D_25tap_f32") + return "polygeist_cudnn_conv2d_5x5_f32"; + if (libSym == "cudnnConvolution2D_ntap") + return "polygeist_cudnn_conv2d_ntap_f64"; + if (libSym == "cudnnConvolution2D_ntap_f32") + return "polygeist_cudnn_conv2d_ntap_f32"; + if (libSym == "cudnnConvolution2D_ntap_tensor") + return "polygeist_cudnn_conv2d_ntap_f64"; + if (libSym == "cudnnConvolution2D_ntap_f32_tensor") + return "polygeist_cudnn_conv2d_ntap_f32"; + if (libSym == "cudnnConvolution3D_ntap_tensor") + return "polygeist_cudnn_conv3d_ntap_f64"; + if (libSym == "cudnnConvolution3D_ntap_f32_tensor") + return "polygeist_cudnn_conv3d_ntap_f32"; + if (libSym == "cudnnConvolution3D_f32" || + libSym == "cudnnConvolution3D_f32_bias") + return "polygeist_cudnn_conv3d_channels_f32"; + if (libSym == "customStencil3D7pt_f64_tensor" || + libSym == "customStencil3D7ptCoeff_f64_tensor" || + libSym == "customStencil3D7ptExtra_f64_tensor") + return "polygeist_custom_stencil3d_7pt_flat_f64"; + if (libSym == "cufftZ2Z_1D_tensor") + return "polygeist_cufft_z2z_1d"; + if (libSym == "cufftC2C_1D_tensor") + return "polygeist_cufft_c2c_1d"; + if (libSym == "cutensornetTensorProduct3D_f32_tensor") + return "polygeist_cutensornet_tensor_product_3d_f32"; + if (libSym == "cutensornetTensorProduct3D_f64_tensor") + return "polygeist_cutensornet_tensor_product_3d_f64"; + if (libSym == "cutensornetContraction2_f64" || + libSym == "cutensornetContraction2_f64_r4r5r4" || + libSym == "cutensornetContraction2_f64_r5r4r4" || + libSym == "cutensornetContraction2_f64_r5r5r4") + return "polygeist_cutensornet_contraction2_f64"; + // NOTE: cudnnConvolution2D_9tap_i{8,16} are intentionally absent — those + // launches route to PVA Solutions' libpva_operator and are lowered by + // a separate pass (see LowerKernelLaunchToPVA.cpp). cuDNN itself has + // no working standalone INT8/INT16 forward-conv kernel on Orin. + // Extracted-darknet batched CNN-block primitives. All four take their + // 4D tensors through `polygeist.submap` views (the implicit im2col for + // conv, the broadcast onto the 4D iteration domain for batchnorm, etc.) + // — the lowering walks each submap operand back to the underlying base + // memref before extracting the data pointer. + if (libSym == "cudnnConvolutionFwd_batched") + return "polygeist_cudnn_conv2d_batched"; + if (libSym == "cudnnConvolutionFwd_im2col_gemm") + return "polygeist_cudnn_conv2d_im2col_gemm_f32"; + if (libSym == "cudnnMaxPoolFwd_batched") + return "polygeist_cudnn_maxpool_batched"; + if (libSym == "cudnnBatchNormalizationForwardInference") + return "polygeist_cudnn_batchnorm_inference"; + if (libSym == "cudnnAddTensor_batched") + return "polygeist_cudnn_add_tensor_batched"; + if (libSym == "cudnnConvBnReluFwdFused") + return "polygeist_cudnn_conv_bn_relu_fused"; + if (libSym == "cudnnConvBiasReluAddFwdFused") + return "polygeist_cudnn_conv_bias_relu_add_fused"; + if (libSym == "rmsnorm_f32") + return "polygeist_rmsnorm_f32"; + if (libSym == "rmsnorm_f32_tensor") + return "polygeist_rmsnorm_f32"; + if (libSym == "rmsnorm_unweighted_f32_tensor") + return "polygeist_rmsnorm_unweighted_f32"; + if (libSym == "gelu_tanh_f32_tensor") + return "polygeist_cuda_gelu_tanh_f32"; + if (libSym == "whisperExpShiftSum_f32_tensor") + return "polygeist_whisper_exp_shift_sum_f32"; + if (libSym == "cublasSdot") + return "polygeist_cublas_dot_f32"; + if (libSym == "cublasDdot") + return "polygeist_cublas_dot_f64"; + if (libSym == "cudnnSoftmaxForward") + return "polygeist_cudnn_softmax_forward_f32"; + if (libSym == "cudnnSoftmaxForward_tensor") + return "polygeist_cudnn_softmax_forward_f32"; + if (libSym == "cudnnSoftmaxForwardOut_tensor") + return "polygeist_cudnn_softmax_forward_out_f32"; + if (libSym == "cudaCopy1D_f32_tensor" || + libSym == "cudaCopy2D_f32_tensor" || + libSym == "cudaCopy3D_f32_tensor" || + libSym == "cudaCopy6D_f32_tensor") + return "polygeist_cuda_copy_f32"; + if (libSym == "cudaAdd_f32_tensor") + return "polygeist_cuda_add_f32"; + if (libSym == "cudaMaskSelect_f32_tensor") + return "polygeist_cuda_mask_select_f32"; + if (libSym == "cudaSwiGLU_f32_tensor") + return "polygeist_cuda_swiglu_f32"; + if (libSym == "cudaRopeMulMulSub_f32_tensor" || + libSym == "cudaRopeMulMulAdd_f32_tensor") + return "polygeist_cuda_rope_mulmul_f32"; + if (libSym == "cublasLtMatmulBiasReluFused") + return "polygeist_cublaslt_matmul_bias_relu"; + if (libSym == "cublasDsyrk_alias") + return "polygeist_cublas_dsyrk"; + if (libSym == "cublasGemmFor1x1Conv") + return "polygeist_cublas_sgemm_1x1conv"; + return StringRef(); +} + +// `ensureShimDecl` and `memrefBasePtr` are shared with the PVA lowering +// pass; their definitions live in KernelLaunchLoweringUtils.cpp. +using mlir::polygeist::ensureShimDecl; +using mlir::polygeist::memrefBasePtr; + +// Return an SSA value for the `axis` dimension of memref `m`, as `i32`. +// We use i32 because the shim functions accept int32_t for M/N/K/lda/... +// Static dims emit `arith.constant`; dynamic dims emit `memref.dim`. +static Value memrefDimAsI32(OpBuilder &b, Location loc, Value m, int64_t axis) { + auto mrType = cast(m.getType()); + if (!mrType.isDynamicDim(axis)) { + int64_t v = mrType.getDimSize(axis); + return b.create(loc, b.getI32Type(), + b.getI32IntegerAttr((int32_t)v)); + } + Value idx = b.create(loc, axis); + Value dimIdx = b.create(loc, m, idx); + return b.create(loc, b.getI32Type(), dimIdx); +} + +static Value memrefNumElementsAsI32(OpBuilder &b, Location loc, Value m) { + auto mrType = cast(m.getType()); + Value total = b.create(loc, b.getI32Type(), + b.getI32IntegerAttr(1)); + for (int64_t axis = 0; axis < mrType.getRank(); ++axis) + total = b.create(loc, total, + memrefDimAsI32(b, loc, m, axis)); + return total; +} + +static Value valueAsI32(OpBuilder &b, Location loc, Value v); + +static Value integerLikeAsI64(OpBuilder &b, Location loc, Value v) { + if (v.getType().isIndex()) { + if (auto cast = v.getDefiningOp()) { + Value src = cast.getIn(); + if (isa(src.getType())) + return integerLikeAsI64(b, loc, src); + } + return b.create(loc, b.getI64Type(), v); + } + if (v.getType().isInteger(64)) + return v; + if (auto intTy = dyn_cast(v.getType())) { + if (intTy.getWidth() > 64) + return b.create(loc, b.getI64Type(), v); + return b.create(loc, b.getI64Type(), v); + } + return v; +} + +static Value opFoldResultAsI64(OpBuilder &b, Location loc, OpFoldResult ofr) { + if (auto attr = ofr.dyn_cast()) { + int64_t v = cast(attr).getInt(); + return b.create(loc, b.getI64Type(), + b.getI64IntegerAttr(v)); + } + return integerLikeAsI64(b, loc, cast(ofr)); +} + +static Value opFoldResultAsI32(OpBuilder &b, Location loc, OpFoldResult ofr) { + if (auto attr = ofr.dyn_cast()) { + int64_t v = cast(attr).getInt(); + return b.create(loc, b.getI32Type(), + b.getI32IntegerAttr((int32_t)v)); + } + return valueAsI32(b, loc, cast(ofr)); +} + +static Value valueAsI32(OpBuilder &b, Location loc, Value v) { + if (v.getType().isIndex()) + return b.create(loc, b.getI32Type(), v); + if (v.getType().isInteger(32)) + return v; + if (auto intTy = dyn_cast(v.getType())) { + if (intTy.getWidth() > 32) + return b.create(loc, b.getI32Type(), v); + return b.create(loc, b.getI32Type(), v); + } + return v; +} + +// Recover the backing memref whenever a tensor is only an ABI/view wrapper. +// Library calls are opaque to one-shot-bufferize: blindly emitting +// bufferization.to_memref here can allocate and copy an entire operand before +// the call. It also makes an otherwise valid cudaMalloc-backed C ABI unsafe, +// because that compiler-generated copy executes on the host. Keep direct +// to_tensor values and extract_slice views as aliases of their source memrefs; +// materialize only genuine tensor SSA values with no recoverable provenance. +static Value tensorToMemref(OpBuilder &b, Location loc, Value t) { + Value stripped = t; + for (int hops = 0; hops < 8; ++hops) { + if (auto cast = stripped.getDefiningOp()) { + stripped = cast.getSource(); + continue; + } + break; + } + if (auto toTensor = stripped.getDefiningOp()) + return toTensor.getMemref(); + if (auto slice = stripped.getDefiningOp()) { + Value source = slice.getSource(); + for (int hops = 0; hops < 8; ++hops) { + if (auto cast = source.getDefiningOp()) { + source = cast.getSource(); + continue; + } + break; + } + if (auto toTensor = + source.getDefiningOp()) { + auto srcType = cast(toTensor.getMemref().getType()); + auto resultType = cast( + memref::SubViewOp::inferRankReducedResultType( + slice.getType().getShape(), srcType, slice.getMixedOffsets(), + slice.getMixedSizes(), slice.getMixedStrides())); + return b.create( + loc, resultType, toTensor.getMemref(), slice.getMixedOffsets(), + slice.getMixedSizes(), slice.getMixedStrides()); + } + } + auto tt = cast(t.getType()); + auto memrefType = MemRefType::get(tt.getShape(), tt.getElementType()); + return b.create(loc, memrefType, t); +} + +static Value valueToMemref(OpBuilder &b, Location loc, Value v) { + if (isa(v.getType())) + return v; + return tensorToMemref(b, loc, v); +} + +// Snapshot a memref that has just been mutated through an opaque LLVM pointer. +// The pointer passed to an external runtime call hides the mutation from +// one-shot-bufferize. Without an explicit memory operation, bufferization may +// legally reuse the same allocation for a later tensor.empty even while the +// launch result is live. A copy into a fresh memref makes the produced SSA +// value and its lifetime visible to buffer alias analysis. +static Value snapshotOpaqueCallResult(OpBuilder &b, Location loc, Value source) { + auto type = cast(source.getType()); + SmallVector dynamicSizes; + for (int64_t dim = 0; dim < type.getRank(); ++dim) { + if (!type.isDynamicDim(dim)) + continue; + Value axis = b.create(loc, dim); + dynamicSizes.push_back(b.create(loc, source, axis)); + } + Value snapshot = b.create(loc, type, dynamicSizes); + b.create(loc, source, snapshot); + return snapshot; +} + +static ShapedType getRankedShapedType(Value v) { + if (auto t = dyn_cast(v.getType())) + return t; + if (auto m = dyn_cast(v.getType())) + return m; + return ShapedType(); +} + +static Value stripTensorCasts(Value v) { + for (int hops = 0; hops < 8; ++hops) { + if (auto cast = v.getDefiningOp()) { + v = cast.getSource(); + continue; + } + break; + } + return v; +} + +static bufferization::ToTensorOp sourceToTensorOp(Value tensorValue) { + Value v = stripTensorCasts(tensorValue); + if (auto toTensor = v.getDefiningOp()) + return toTensor; + return nullptr; +} + +// Follow destination-style tensor updates to the ABI buffer they logically +// update. This is intentionally output-only: following tensor.insert for a +// read operand would discard the inserted value. Reduction matchers commonly +// initialize an output element with tensor.insert and then pass a rank-reduced +// extract_slice of that value to a library call which overwrites it. +static bufferization::ToTensorOp destinationToTensorOp(Value tensorValue) { + Value v = stripTensorCasts(tensorValue); + for (int hops = 0; hops < 8; ++hops) { + if (auto toTensor = v.getDefiningOp()) + return toTensor; + if (auto insert = v.getDefiningOp()) { + v = stripTensorCasts(insert.getDest()); + continue; + } + if (auto insertSlice = v.getDefiningOp()) { + v = stripTensorCasts(insertSlice.getDest()); + continue; + } + break; + } + return nullptr; +} + +static Value sliceSourceMemref(Value tensorValue) { + Value v = stripTensorCasts(tensorValue); + auto slice = v.getDefiningOp(); + if (!slice) return Value(); + auto toTensor = sourceToTensorOp(slice.getSource()); + if (!toTensor) return Value(); + return toTensor.getMemref(); +} + +static Value valueToMemrefPreservingSlice(OpBuilder &b, Location loc, Value v); +static Value memrefToTensor(OpBuilder &b, Location loc, Value m, + Type tensorType); + +static Value pointerForTensorOrMemref(OpBuilder &b, Location loc, Value v) { + Value stripped = stripTensorCasts(v); + if (auto toTensor = sourceToTensorOp(stripped)) + return memrefBasePtr(b, loc, toTensor.getMemref()); + if (auto slice = stripped.getDefiningOp()) { + if (auto toTensor = sourceToTensorOp(slice.getSource())) { + Value base = toTensor.getMemref(); + auto baseTy = cast(base.getType()); + Value alignedIdx = + b.create(loc, base); + Value alignedI64 = b.create( + loc, b.getI64Type(), alignedIdx); + auto md = b.create(loc, base); + Value linear = integerLikeAsI64(b, loc, md.getOffset()); + auto offsets = slice.getMixedOffsets(); + for (int64_t i = 0, e = offsets.size(); i < e; ++i) { + Value off = opFoldResultAsI64(b, loc, offsets[i]); + Value stride = integerLikeAsI64(b, loc, md.getStrides()[i]); + Value scaled = b.create(loc, off, stride); + linear = b.create(loc, linear, scaled); + } + unsigned bits = baseTy.getElementType().getIntOrFloatBitWidth(); + Value eltBytes = b.create( + loc, b.getI64Type(), b.getI64IntegerAttr(bits / 8)); + Value byteOff = b.create(loc, linear, eltBytes); + Value byteAddr = b.create(loc, alignedI64, byteOff); + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + return b.create(loc, ptrTy, byteAddr); + } + } + + Value mr = valueToMemrefPreservingSlice(b, loc, v); + return memrefBasePtr(b, loc, mr); +} + +static Value numElementsForTensorOrMemref(OpBuilder &b, Location loc, Value v) { + Value stripped = stripTensorCasts(v); + if (auto slice = stripped.getDefiningOp()) { + Value total = b.create(loc, b.getI32Type(), + b.getI32IntegerAttr(1)); + for (OpFoldResult size : slice.getMixedSizes()) + total = b.create(loc, total, + opFoldResultAsI32(b, loc, size)); + return total; + } + Value mr = valueToMemrefPreservingSlice(b, loc, v); + return memrefNumElementsAsI32(b, loc, mr); +} + +static Value dimForTensorOrMemrefAsI32(OpBuilder &b, Location loc, Value v, + int64_t axis) { + Value stripped = stripTensorCasts(v); + if (auto toTensor = sourceToTensorOp(stripped)) + return memrefDimAsI32(b, loc, toTensor.getMemref(), axis); + if (auto slice = stripped.getDefiningOp()) { + if ((int64_t)slice.getType().getRank() == (int64_t)slice.getMixedSizes().size()) + return opFoldResultAsI32(b, loc, slice.getMixedSizes()[axis]); + } + Value mr = valueToMemrefPreservingSlice(b, loc, v); + return memrefDimAsI32(b, loc, mr, axis); +} + +// Bufferize a tensor value, preserving extract_slice views as memref.subview. +// This avoids handing dynamic tensor.extract_slice / tensor.insert_slice to +// one-shot-bufferize after the launch has already been lowered to a call. +static Value valueToMemrefPreservingSlice(OpBuilder &b, Location loc, Value v) { + Value stripped = stripTensorCasts(v); + if (auto toTensor = sourceToTensorOp(stripped)) + return toTensor.getMemref(); + if (auto slice = stripped.getDefiningOp()) { + if (auto toTensor = sourceToTensorOp(slice.getSource())) { + auto srcType = cast(toTensor.getMemref().getType()); + auto resultType = cast( + memref::SubViewOp::inferRankReducedResultType( + slice.getType().getShape(), srcType, slice.getMixedOffsets(), + slice.getMixedSizes(), slice.getMixedStrides())); + return b.create( + loc, resultType, toTensor.getMemref(), slice.getMixedOffsets(), + slice.getMixedSizes(), slice.getMixedStrides()); + } + } + if (isa(v.getType())) + return v; + return tensorToMemref(b, loc, v); +} + +static Value valueToOutputMemrefPreservingSlice(OpBuilder &b, Location loc, + Value v) { + Value stripped = stripTensorCasts(v); + if (auto slice = stripped.getDefiningOp()) { + if (auto toTensor = destinationToTensorOp(slice.getSource())) { + auto srcType = cast(toTensor.getMemref().getType()); + auto resultType = cast( + memref::SubViewOp::inferRankReducedResultType( + slice.getType().getShape(), srcType, slice.getMixedOffsets(), + slice.getMixedSizes(), slice.getMixedStrides())); + return b.create( + loc, resultType, toTensor.getMemref(), slice.getMixedOffsets(), + slice.getMixedSizes(), slice.getMixedStrides()); + } + } + return valueToMemrefPreservingSlice(b, loc, v); +} + +static Value tensorForOutputSliceSource(OpBuilder &b, Location loc, Value v) { + Value stripped = stripTensorCasts(v); + auto slice = stripped.getDefiningOp(); + if (!slice) + return Value(); + auto toTensor = destinationToTensorOp(slice.getSource()); + if (!toTensor) + return Value(); + auto sourceType = dyn_cast(slice.getSource().getType()); + if (!sourceType) + return Value(); + return memrefToTensor(b, loc, toTensor.getMemref(), sourceType); +} + +// Inverse of the above — wrap a memref back into a tensor for downstream +// SSA uses. The `restrict` + `writable` attributes promise this is the +// only alias of the memref, which is true for fresh launch results. +static Value memrefToTensor(OpBuilder &b, Location loc, Value m, Type tensorType) { + auto t = b.create( + loc, tensorType, m, /*restrict=*/true, /*writable=*/true); + return t.getResult(); +} + +static Value tensorForSliceSource(OpBuilder &b, Location loc, Value tensorValue) { + Value v = stripTensorCasts(tensorValue); + auto slice = v.getDefiningOp(); + if (!slice) return Value(); + Value src = stripTensorCasts(slice.getSource()); + auto srcTy = dyn_cast(src.getType()); + Value srcMr = sliceSourceMemref(v); + if (!srcTy || !srcMr) return Value(); + return memrefToTensor(b, loc, srcMr, srcTy); +} + +static void rewireTensorSliceLaunchResult(LaunchOp launch, + Value updatedViewTensor, + Value updatedBaseTensor) { + if (launch.getNumResults() == 0) return; + Value res = launch.getResult(0); + SmallVector inserts; + SmallVector resultCasts; + if (updatedBaseTensor) { + // Dynamic library signatures commonly expose an unranked launch result, + // so the destination-style write-back is reached through one or more + // tensor.cast operations. Treat those casts as transparent when finding + // the terminal insert_slice; otherwise one-shot bufferization later + // materializes a full output snapshot and copy even though the runtime + // already wrote the destination allocation in place. + SmallVector worklist{res}; + llvm::SmallPtrSet seenCasts; + for (size_t i = 0; i < worklist.size(); ++i) { + Value candidate = worklist[i]; + for (Operation *user : candidate.getUsers()) { + if (auto insert = dyn_cast(user)) { + if (insert.getSource() == candidate) + inserts.push_back(insert); + continue; + } + if (auto cast = dyn_cast(user)) { + if (cast.getSource() == candidate && seenCasts.insert(cast).second) { + resultCasts.push_back(cast); + worklist.push_back(cast.getResult()); + } + } + } + } + } + for (auto insert : inserts) { + insert.getResult().replaceAllUsesWith(updatedBaseTensor); + insert.erase(); + } + for (tensor::CastOp cast : llvm::reverse(resultCasts)) + if (cast.getResult().use_empty()) + cast.erase(); + if (!res.use_empty() && updatedViewTensor) + res.replaceAllUsesWith(updatedViewTensor); +} + +// Walk a SSA value back through `polygeist.submap` / `polygeist.submapInverse` +// to its underlying base tensor. The matcher's launches feed operands +// through view chains (the 7D strided-window for conv im2col, the 4D +// broadcast of a 1D per-channel vector for batchnorm, etc.). Earlier +// matched launches in the same function can ALSO have introduced a +// submapInverse via their own in-place semantics — composing two +// launches whose outputs alias makes the chain ≥ 2 levels deep. +// +// Rules: +// • polygeist.submap → walk to its `base` +// • polygeist.submapInverse → walk to its FIRST operand (the base +// tensor it scatters back into; conceptually, after the inverse +// scatter, the underlying base IS the up-to-date tensor). +// Returns `v` unchanged if neither defining op applies, including when +// `v` is a function argument or a bufferization.to_tensor. +static Value resolveSubmapBase(Value v) { + for (int hops = 0; hops < 16; ++hops) { + if (auto submap = v.getDefiningOp()) { + v = submap.getBase(); + continue; + } + if (auto inv = v.getDefiningOp()) { + // First operand is the underlying base; SubmapInverseOp doesn't + // expose a getBase() accessor, so use getOperand(0). + v = inv.getOperand(0); + continue; + } + break; + } + return v; +} + +// After lowering an in-place launch (the runtime shim mutates the output +// memref directly), we need to wire downstream consumers to the new +// "updated base tensor" SSA. There are two patterns: +// +// (a) Output operand was a polygeist.submap view of the underlying 4D +// base. The launch's result has the *view* type and is consumed by +// polygeist.submapInverse(base, result, ...) which scatters back +// to a 4D tensor. We replace the submapInverse's result with the +// updated 4D base tensor and erase the inverse. +// +// (b) Output operand was already the 4D base tensor (no submap on the +// output). The launch's result has the 4D base type, consumed +// directly by bufferization.to_memref / etc. We replace +// launch.getResult(0) uses with the updated base tensor. +// +// The caller's `updatedBaseTensor` is a `bufferization.to_tensor` of the +// freshly-bufferised output memref — same 4D type as the base. +static void rewireLaunchResult(LaunchOp launch, Value updatedBaseTensor) { + if (launch.getNumResults() == 0) return; + Value res = launch.getResult(0); + + // Case (a): submapInverse consumer — replace its result instead, so + // we collapse both the inverse and the launch out of the IR. + SmallVector inverses; + for (Operation *user : res.getUsers()) { + if (auto inv = dyn_cast(user)) + inverses.push_back(inv); + } + for (auto inv : inverses) { + inv.getResult().replaceAllUsesWith(updatedBaseTensor); + inv.erase(); + } + + // Case (b): any remaining consumers of the launch result expect the + // launch's result type. If the launch result is the same type as the + // base tensor (output wasn't a submap), this `replaceAllUsesWith` is + // type-safe and wires to_memref / memref.copy / etc. to the + // bufferized base. If the launch result is a *view* type and there + // are still consumers other than the inverses we just erased, the + // caller's invariants are violated — fail loudly so we notice. + if (!res.use_empty()) { + if (res.getType() != updatedBaseTensor.getType()) { + launch.emitWarning( + "lowering: launch result has view type with non-submapInverse " + "consumer; downstream verifier may complain about the type " + "of the in-place updated tensor"); + } + res.replaceAllUsesWith(updatedBaseTensor); + } +} + +// Variant of rewireLaunchResult for an in-place launch whose destination is a +// polygeist.submap. The runtime mutates (and the caller snapshots) the base +// allocation, but ordinary SSA consumers of the launch result still expect +// the shaped view type. Recreate that same view over the updated base while +// continuing to bypass submapInverse consumers with the full updated base. +static LogicalResult rewireSubmapLaunchResult(LaunchOp launch, + Value updatedViewTensor, + Value updatedBaseTensor) { + if (launch.getNumResults() == 0) + return success(); + Value res = launch.getResult(0); + + SmallVector inverses; + for (Operation *user : res.getUsers()) + if (auto inverse = dyn_cast(user)) + inverses.push_back(inverse); + for (polygeist::SubmapInverseOp inverse : inverses) { + inverse.getResult().replaceAllUsesWith(updatedBaseTensor); + inverse.erase(); + } + + if (!res.use_empty()) { + if (!updatedViewTensor || res.getType() != updatedViewTensor.getType()) + return launch.emitError( + "lowering: cannot reconnect a submap launch result to its updated " + "view type"); + res.replaceAllUsesWith(updatedViewTensor); + } + return success(); +} + +//===----------------------------------------------------------------------===// +// Per-library lowerings +//===----------------------------------------------------------------------===// + +// kernel.launch @cublasDgemm(%A, %B, %C, %beta, %alpha) +// : (tensor, tensor, tensor, f64, f64) +// -> tensor +// +// Lowers to: +// %A_mr = bufferization.to_memref %A +// %B_mr = bufferization.to_memref %B +// %C_mr = bufferization.to_memref %C +// %M, %N, %K, %lda, %ldb, %ldc = ... (i32 dim queries) +// func.call @polygeist_cublas_dgemm(%M, %N, %K, %alpha, +// %A_mr, %lda, %B_mr, %ldb, +// %beta, %C_mr, %ldc) +// %out = bufferization.to_tensor %C_mr restrict writable +// replaceAllUsesWith(launch.getResult(0), %out) +static LogicalResult lowerDgemm(LaunchOp launch, ModuleOp module) { + if (launch.getNumOperands() != 5) + return launch.emitError("cublasDgemm lowering: expected 5 operands " + "(A, B, C, beta, alpha), got ") + << launch.getNumOperands(); + if (launch.getNumResults() != 1) + return launch.emitError("cublasDgemm lowering: expected 1 result"); + + Value A = launch.getOperand(0); + Value B = launch.getOperand(1); + Value C = launch.getOperand(2); + Value beta = launch.getOperand(3); + Value alpha = launch.getOperand(4); + + auto At = dyn_cast(A.getType()); + auto Bt = dyn_cast(B.getType()); + auto Ct = dyn_cast(C.getType()); + if (!At || !Bt || !Ct) + return launch.emitError( + "cublasDgemm lowering: A/B/C operands must be ranked tensors"); + if (At.getRank() != 2 || Bt.getRank() != 2 || Ct.getRank() != 2) + return launch.emitError( + "cublasDgemm lowering: A/B/C must be 2D tensors"); + if (!At.getElementType().isF64() || !Bt.getElementType().isF64() || + !Ct.getElementType().isF64()) + return launch.emitError( + "cublasDgemm lowering: only f64 element type supported"); + if (!beta.getType().isF64() || !alpha.getType().isF64()) + return launch.emitError( + "cublasDgemm lowering: alpha/beta must be f64"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + + // Bufferize tensors → memrefs (whose ABI carries the data pointer when + // lowered to LLVM). Do this BEFORE dim queries so we can use memref.dim. + Value A_mr = tensorToMemref(b, loc, A); + Value B_mr = tensorToMemref(b, loc, B); + Value C_mr = valueToOutputMemrefPreservingSlice(b, loc, C); + + // Materialise dim queries on the memrefs (static shape → arith.constant, + // dynamic shape → memref.dim). + Value M = memrefDimAsI32(b, loc, A_mr, 0); + Value K = memrefDimAsI32(b, loc, A_mr, 1); + Value N = memrefDimAsI32(b, loc, B_mr, 1); + // Row-major leading dims: lda = K, ldb = N, ldc = N. + Value lda = K; + Value ldb = N; + Value ldc = N; + + // CRITICAL: do NOT pass memrefs to the C shim — MLIR's --convert-func-to-llvm + // would expand each memref into 7 LLVM args (alloc-ptr, aligned-ptr, offset, + // sizes×2, strides×2), but the C shim signature is (M,N,K,alpha,A*,lda,...) + // with one pointer per matrix. The reg/stack layouts would not match and the + // shim would read garbage. Extract raw `!llvm.ptr` and pass those. + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value B_ptr = memrefBasePtr(b, loc, B_mr); + Value C_ptr = memrefBasePtr(b, loc, C_mr); + + // Forward-declare the shim function with raw-pointer arg types. + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), b.getI32Type(), // M, N, K + b.getF64Type(), // alpha + ptrTy, b.getI32Type(), // A*, lda + ptrTy, b.getI32Type(), // B*, ldb + b.getF64Type(), // beta + ptrTy, b.getI32Type(), // C*, ldc + }; + func::FuncOp shim = ensureShimDecl(module, "polygeist_cublas_dgemm", + argTypes, b); + + SmallVector callOperands = {M, N, K, alpha, A_ptr, lda, B_ptr, ldb, + beta, C_ptr, ldc}; + b.create(loc, shim, callOperands); + + // Recover the result tensor SSA from C_mr (C was updated in place). + Value resultTensor = memrefToTensor(b, loc, C_mr, launch.getResult(0).getType()); + rewireTensorSliceLaunchResult( + launch, resultTensor, tensorForOutputSliceSource(b, loc, C)); + launch.erase(); + return success(); +} + +// Shared helper: lower a gemm-shape launch with optionally-implicit +// alpha/beta. Variants: +// @cublasDgemm operands (A, B, C, beta, alpha) — full form +// @cublasDgemm_simple operands (A, B, C) — α=1, β=1 +// @cublasDgemm_alpha_only operands (A, B, C, alpha) — β=1 +// All three lower to the same polygeist_cublas_dgemm runtime call. +static LogicalResult lowerDgemmVariant(LaunchOp launch, ModuleOp module, + StringRef variant) { + unsigned expected = (variant == "cublasDgemm") ? 5 + : (variant == "cublasDgemm_alpha_only") ? 4 + : 3; + if (launch.getNumOperands() != expected) + return launch.emitError(variant) + << " lowering: expected " << expected + << " operands, got " << launch.getNumOperands(); + if (launch.getNumResults() != 1) + return launch.emitError(variant) << " lowering: expected 1 result"; + + Value A = launch.getOperand(0); + Value B = launch.getOperand(1); + Value C = launch.getOperand(2); + Value beta, alpha; + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value one = b.create(loc, b.getF64Type(), + b.getF64FloatAttr(1.0)); + if (variant == "cublasDgemm") { + beta = launch.getOperand(3); + alpha = launch.getOperand(4); + } else if (variant == "cublasDgemm_alpha_only") { + beta = one; + alpha = launch.getOperand(3); + } else { // _simple + beta = one; + alpha = one; + } + + auto At = dyn_cast(A.getType()); + auto Bt = dyn_cast(B.getType()); + auto Ct = dyn_cast(C.getType()); + if (!At || !Bt || !Ct || At.getRank() != 2 || Bt.getRank() != 2 || + Ct.getRank() != 2) + return launch.emitError(variant) + << " lowering: A/B/C must be 2D ranked tensors"; + if (!At.getElementType().isF64() || !Bt.getElementType().isF64() || + !Ct.getElementType().isF64()) + return launch.emitError(variant) + << " lowering: only f64 supported"; + + Value A_mr = tensorToMemref(b, loc, A); + Value B_mr = tensorToMemref(b, loc, B); + Value C_mr = tensorToMemref(b, loc, C); + Value M = memrefDimAsI32(b, loc, A_mr, 0); + Value K = memrefDimAsI32(b, loc, A_mr, 1); + Value N = memrefDimAsI32(b, loc, B_mr, 1); + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value B_ptr = memrefBasePtr(b, loc, B_mr); + Value C_ptr = memrefBasePtr(b, loc, C_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), b.getI32Type(), + b.getF64Type(), + ptrTy, b.getI32Type(), + ptrTy, b.getI32Type(), + b.getF64Type(), + ptrTy, b.getI32Type(), + }; + func::FuncOp shim = ensureShimDecl(module, "polygeist_cublas_dgemm", + argTypes, b); + SmallVector callOperands = {M, N, K, alpha, A_ptr, K /*lda*/, + B_ptr, N /*ldb*/, beta, C_ptr, + N /*ldc*/}; + b.create(loc, shim, callOperands); + + Value resultTensor = memrefToTensor(b, loc, C_mr, + launch.getResult(0).getType()); + launch.getResult(0).replaceAllUsesWith(resultTensor); + launch.erase(); + return success(); +} + +static LogicalResult lowerCudnnConv2DNtapTensor(LaunchOp launch, + ModuleOp module, + StringRef shimSymbol) { + if (launch.getNumOperands() != 4) + return launch.emitError("cudnnConvolution2D_ntap_tensor: expected 4 " + "operands (input slice, output slice, weights, K); got ") + << launch.getNumOperands(); + if (launch.getNumResults() != 1) + return launch.emitError( + "cudnnConvolution2D_ntap_tensor: expected 1 tensor result"); + + Value A = launch.getOperand(0); + Value C = launch.getOperand(1); + Value W = launch.getOperand(2); + Value K = launch.getOperand(3); + + auto aTy = dyn_cast(A.getType()); + auto cTy = dyn_cast(C.getType()); + auto wTy = dyn_cast(W.getType()); + auto resTy = dyn_cast(launch.getResult(0).getType()); + if (!aTy || !cTy || !wTy || !resTy) + return launch.emitError( + "cudnnConvolution2D_ntap_tensor: operands/result must be tensors"); + if (aTy.getRank() != 2 || cTy.getRank() != 2 || resTy.getRank() != 2 || + wTy.getRank() != 1) + return launch.emitError( + "cudnnConvolution2D_ntap_tensor: expected 2D input/output and 1D weights"); + Type elemTy = aTy.getElementType(); + if (cTy.getElementType() != elemTy || wTy.getElementType() != elemTy || + resTy.getElementType() != elemTy) + return launch.emitError( + "cudnnConvolution2D_ntap_tensor: input/output/weights dtypes must match"); + if (!(elemTy.isF64() || elemTy.isF32())) + return launch.emitError( + "cudnnConvolution2D_ntap_tensor: only f64/f32 packed weights are supported"); + if (!K.getType().isInteger(32)) + return launch.emitError("cudnnConvolution2D_ntap_tensor: K must be i32"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + + // Preserve tensor.extract_slice views as memref.subview so the runtime sees + // the same top-left input window and output interior slice as the tensor IR. + Value A_mr = valueToMemrefPreservingSlice(b, loc, A); + Value C_mr = valueToOutputMemrefPreservingSlice(b, loc, C); + Value W_mr = valueToMemrefPreservingSlice(b, loc, W); + + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value C_ptr = memrefBasePtr(b, loc, C_mr); + Value W_ptr = memrefBasePtr(b, loc, W_mr); + + Value oneI32 = b.create( + loc, b.getI32Type(), b.getI32IntegerAttr(1)); + Value border = b.create(loc, K, oneI32); + Value outH = memrefDimAsI32(b, loc, C_mr, 0); + Value outW = memrefDimAsI32(b, loc, C_mr, 1); + Value M = b.create(loc, outH, border); + Value N = b.create(loc, outW, border); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), b.getI32Type(), + b.getI32Type(), ptrTy, ptrTy, ptrTy}; + func::FuncOp shim = ensureShimDecl(module, shimSymbol, argTypes, b); + b.create(loc, shim, ValueRange{M, N, K, W_ptr, A_ptr, C_ptr}); + + Value updatedView = + memrefToTensor(b, loc, C_mr, launch.getResult(0).getType()); + Value updatedBase = tensorForSliceSource(b, loc, C); + rewireTensorSliceLaunchResult(launch, updatedView, updatedBase); + launch.erase(); + return success(); +} + +static LogicalResult lowerCudnnConv3DNtapTensor(LaunchOp launch, + ModuleOp module, + StringRef shimSymbol) { + if (launch.getNumOperands() != 4) + return launch.emitError("cudnnConvolution3D_ntap_tensor: expected 4 " + "operands (input, output, weights, K); got ") + << launch.getNumOperands(); + if (launch.getNumResults() != 1) + return launch.emitError( + "cudnnConvolution3D_ntap_tensor: expected 1 tensor result"); + + Value A = launch.getOperand(0); + Value C = launch.getOperand(1); + Value W = launch.getOperand(2); + Value K = launch.getOperand(3); + + auto aTy = dyn_cast(A.getType()); + auto cTy = dyn_cast(C.getType()); + auto wTy = dyn_cast(W.getType()); + auto resTy = dyn_cast(launch.getResult(0).getType()); + if (!aTy || !cTy || !wTy || !resTy) + return launch.emitError( + "cudnnConvolution3D_ntap_tensor: operands/result must be tensors"); + if (aTy.getRank() != 3 || cTy.getRank() != 3 || wTy.getRank() != 3 || + resTy.getRank() != 3) + return launch.emitError( + "cudnnConvolution3D_ntap_tensor: expected 3D input/output/weights"); + Type elemTy = aTy.getElementType(); + if (cTy.getElementType() != elemTy || wTy.getElementType() != elemTy || + resTy.getElementType() != elemTy) + return launch.emitError( + "cudnnConvolution3D_ntap_tensor: input/output/weights dtypes must match"); + if (!(elemTy.isF64() || elemTy.isF32())) + return launch.emitError( + "cudnnConvolution3D_ntap_tensor: only f64/f32 weights are supported"); + if (!K.getType().isInteger(32)) + return launch.emitError("cudnnConvolution3D_ntap_tensor: K must be i32"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + + Value A_mr = valueToMemrefPreservingSlice(b, loc, A); + Value C_mr = valueToMemrefPreservingSlice(b, loc, C); + Value W_mr = valueToMemrefPreservingSlice(b, loc, W); + + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value C_ptr = memrefBasePtr(b, loc, C_mr); + Value W_ptr = memrefBasePtr(b, loc, W_mr); + + Value oneI32 = b.create( + loc, b.getI32Type(), b.getI32IntegerAttr(1)); + Value border = b.create(loc, K, oneI32); + Value outD = memrefDimAsI32(b, loc, C_mr, 0); + Value outH = memrefDimAsI32(b, loc, C_mr, 1); + Value outW = memrefDimAsI32(b, loc, C_mr, 2); + Value inD = b.create(loc, outD, border); + Value inH = b.create(loc, outH, border); + Value inW = b.create(loc, outW, border); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), b.getI32Type(), + b.getI32Type(), b.getI32Type(), b.getI32Type(), + b.getI32Type(), ptrTy, ptrTy, ptrTy}; + func::FuncOp shim = ensureShimDecl(module, shimSymbol, argTypes, b); + b.create( + loc, shim, + ValueRange{inD, inH, inW, outD, outH, outW, K, W_ptr, A_ptr, C_ptr}); + + Value updatedView = + memrefToTensor(b, loc, C_mr, launch.getResult(0).getType()); + Value updatedBase = tensorForSliceSource(b, loc, C); + rewireTensorSliceLaunchResult(launch, updatedView, updatedBase); + launch.erase(); + return success(); +} + +// Multi-channel, single-batch valid Conv3D. The matcher passes the logical +// rank-8 window so the operation remains self-describing; here we unwrap that +// view to its NCDHW storage tensor and call the ordinary cuDNN Conv3D ABI. +static LogicalResult lowerCudnnConv3DChannelsF32(LaunchOp launch, + ModuleOp module, + bool hasBias) { + unsigned expectedOperands = hasBias ? 4 : 3; + if (launch.getNumOperands() != expectedOperands || + launch.getNumResults() != 1) + return launch.emitError("cudnnConvolution3D_f32: expected window, filter") + << (hasBias ? ", bias" : "") << ", output and one result"; + + Value window = launch.getOperand(0); + Value filter = launch.getOperand(1); + Value bias = hasBias ? launch.getOperand(2) : Value(); + Value output = launch.getOperand(expectedOperands - 1); + Value input = resolveSubmapBase(window); + auto inputTy = dyn_cast(input.getType()); + auto filterTy = dyn_cast(filter.getType()); + auto outputTy = dyn_cast(output.getType()); + auto windowTy = dyn_cast(window.getType()); + if (!inputTy || !filterTy || !outputTy || !windowTy || + (inputTy.getRank() != 4 && inputTy.getRank() != 5) || + filterTy.getRank() != 5 || outputTy.getRank() != 4 || + windowTy.getRank() != 8 || !inputTy.getElementType().isF32() || + !filterTy.getElementType().isF32() || + !outputTy.getElementType().isF32()) + return launch.emitError( + "cudnnConvolution3D_f32: expected rank-4/5 input storage, rank-8 " + "window, rank-5 filter, and rank-4 f32 output"); + if (hasBias) { + auto biasTy = dyn_cast(bias.getType()); + if (!biasTy || biasTy.getRank() != 1 || + !biasTy.getElementType().isF32()) + return launch.emitError( + "cudnnConvolution3D_f32_bias: bias must be rank-1 f32"); + } + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value inputMr = valueToMemrefPreservingSlice(b, loc, input); + Value filterMr = valueToMemrefPreservingSlice(b, loc, filter); + Value outputMr = valueToMemrefPreservingSlice(b, loc, output); + int64_t channelAxis = inputTy.getRank() == 5 ? 1 : 0; + Value IC = memrefDimAsI32(b, loc, inputMr, channelAxis); + Value inD = memrefDimAsI32(b, loc, inputMr, channelAxis + 1); + Value inH = memrefDimAsI32(b, loc, inputMr, channelAxis + 2); + Value inW = memrefDimAsI32(b, loc, inputMr, channelAxis + 3); + Value OC = memrefDimAsI32(b, loc, filterMr, 0); + Value kD = memrefDimAsI32(b, loc, filterMr, 2); + Value kH = memrefDimAsI32(b, loc, filterMr, 3); + Value kW = memrefDimAsI32(b, loc, filterMr, 4); + Value inputPtr = memrefBasePtr(b, loc, inputMr); + Value filterPtr = memrefBasePtr(b, loc, filterMr); + Value outputPtr = memrefBasePtr(b, loc, outputMr); + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + Value biasPtr = b.create(loc, ptrTy); + if (hasBias) { + Value biasMr = valueToMemrefPreservingSlice(b, loc, bias); + biasPtr = memrefBasePtr(b, loc, biasMr); + } + + SmallVector argTypes(8, b.getI32Type()); + argTypes.append(4, ptrTy); + func::FuncOp shim = ensureShimDecl( + module, "polygeist_cudnn_conv3d_channels_f32", argTypes, b); + b.create( + loc, shim, + ValueRange{IC, inD, inH, inW, OC, kD, kH, kW, + inputPtr, filterPtr, biasPtr, outputPtr}); + + Value updatedView = + memrefToTensor(b, loc, outputMr, launch.getResult(0).getType()); + Value updatedBase = tensorForSliceSource(b, loc, output); + rewireTensorSliceLaunchResult(launch, updatedView, updatedBase); + launch.erase(); + return success(); +} + +static LogicalResult lowerCustomStencil3D7ptF64Tensor(LaunchOp launch, + ModuleOp module, + StringRef libSym) { + bool hasCoeff = libSym == "customStencil3D7ptCoeff_f64_tensor"; + bool hasExtra = libSym == "customStencil3D7ptExtra_f64_tensor"; + unsigned expected = hasCoeff || hasExtra ? 19 : 18; + if (launch.getNumOperands() != expected) + return launch.emitError("customStencil3D7pt lowering: expected ") + << expected << " operands, got " << launch.getNumOperands(); + if (launch.getNumResults() != 1) + return launch.emitError("customStencil3D7pt lowering: expected 1 result"); + + SmallVector taps; + taps.reserve(7); + for (unsigned i = 0; i < 7; ++i) + taps.push_back(launch.getOperand(i)); + unsigned idx = 7; + Value extra; + Value coeff; + if (hasExtra) + extra = launch.getOperand(idx++); + if (hasCoeff) + coeff = launch.getOperand(idx++); + Value out = launch.getOperand(idx++); + SmallVector scalars; + for (; idx < launch.getNumOperands(); ++idx) + scalars.push_back(launch.getOperand(idx)); + if (scalars.size() != 10) + return launch.emitError("customStencil3D7pt lowering: expected 10 scalar " + "coefficients"); + + auto outTy = dyn_cast(out.getType()); + auto resTy = dyn_cast(launch.getResult(0).getType()); + if (!outTy || !resTy || outTy.getRank() != 3 || resTy.getRank() != 3 || + !outTy.getElementType().isF64() || !resTy.getElementType().isF64()) + return launch.emitError( + "customStencil3D7pt lowering: output/result must be rank-3 f64 tensors"); + for (Value tap : taps) { + auto ty = dyn_cast(tap.getType()); + if (!ty || ty.getRank() != 3 || !ty.getElementType().isF64()) + return launch.emitError( + "customStencil3D7pt lowering: all tap operands must be rank-3 f64 tensors"); + } + if (hasExtra) { + auto ty = dyn_cast(extra.getType()); + if (!ty || ty.getRank() != 3 || !ty.getElementType().isF64()) + return launch.emitError( + "customStencil3D7pt lowering: extra operand must be rank-3 f64 tensor"); + } + if (hasCoeff) { + auto ty = dyn_cast(coeff.getType()); + if (!ty || ty.getRank() != 3 || !ty.getElementType().isF64()) + return launch.emitError( + "customStencil3D7pt lowering: coeff operand must be rank-3 f64 tensor"); + } + for (Value s : scalars) + if (!s.getType().isF64()) + return launch.emitError( + "customStencil3D7pt lowering: scalar coefficients must be f64"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + Value nullPtr = b.create(loc, ptrTy); + Value N = numElementsForTensorOrMemref(b, loc, out); + + SmallVector callOperands; + callOperands.push_back(N); + for (Value tap : taps) + callOperands.push_back(pointerForTensorOrMemref(b, loc, tap)); + callOperands.push_back(hasExtra ? pointerForTensorOrMemref(b, loc, extra) + : nullPtr); + callOperands.push_back(hasCoeff ? pointerForTensorOrMemref(b, loc, coeff) + : nullPtr); + callOperands.push_back(pointerForTensorOrMemref(b, loc, out)); + callOperands.append(scalars.begin(), scalars.end()); + + SmallVector argTypes; + argTypes.push_back(b.getI32Type()); + for (unsigned i = 0; i < 10; ++i) + argTypes.push_back(ptrTy); + for (unsigned i = 0; i < 10; ++i) + argTypes.push_back(b.getF64Type()); + func::FuncOp shim = ensureShimDecl( + module, "polygeist_custom_stencil3d_7pt_flat_f64", argTypes, b); + b.create(loc, shim, callOperands); + + Value updatedBase = tensorForSliceSource(b, loc, out); + Value updated = updatedBase ? Value() + : memrefToTensor(b, loc, valueToMemrefPreservingSlice(b, loc, out), + launch.getResult(0).getType()); + rewireTensorSliceLaunchResult(launch, updated, updatedBase); + launch.erase(); + return success(); +} + +static LogicalResult lowerCufftC2C1DTensor(LaunchOp launch, ModuleOp module, + StringRef shimSymbol) { + if (launch.getNumOperands() != 3) + return launch.emitError( + "cufft 1D tensor: expected operands (input, output, inverse)"); + if (launch.getNumResults() != 1) + return launch.emitError("cufft 1D tensor: expected 1 tensor result"); + + Value A = launch.getOperand(0); + Value C = launch.getOperand(1); + Value inverse = launch.getOperand(2); + auto aTy = dyn_cast(A.getType()); + auto cTy = dyn_cast(C.getType()); + auto rTy = dyn_cast(launch.getResult(0).getType()); + if (!aTy || !cTy || !rTy || aTy.getRank() != 2 || cTy.getRank() != 2 || + rTy.getRank() != 2) + return launch.emitError( + "cufft 1D tensor: input/output/result must be rank-2 tensors"); + if (aTy.getDimSize(1) != 2 || cTy.getDimSize(1) != 2 || + rTy.getDimSize(1) != 2) + return launch.emitError( + "cufft 1D tensor: trailing dimension must be static size 2"); + Type elemTy = aTy.getElementType(); + if (cTy.getElementType() != elemTy || rTy.getElementType() != elemTy) + return launch.emitError( + "cufft 1D tensor: input/output/result element types must match"); + if (!(elemTy.isF64() || elemTy.isF32())) + return launch.emitError("cufft 1D tensor: only f64/f32 supported"); + if (!inverse.getType().isInteger(32)) + return launch.emitError("cufft 1D tensor: inverse flag must be i32"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value A_mr = valueToMemrefPreservingSlice(b, loc, A); + Value C_mr = valueToMemrefPreservingSlice(b, loc, C); + Value N = memrefDimAsI32(b, loc, A_mr, 0); + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value C_ptr = memrefBasePtr(b, loc, C_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), b.getI32Type(), ptrTy, ptrTy}; + func::FuncOp shim = ensureShimDecl(module, shimSymbol, argTypes, b); + b.create(loc, shim, ValueRange{N, inverse, A_ptr, C_ptr}); + + Value updated = + memrefToTensor(b, loc, C_mr, launch.getResult(0).getType()); + Value updatedBase = tensorForSliceSource(b, loc, C); + rewireTensorSliceLaunchResult(launch, updated, updatedBase); + launch.erase(); + return success(); +} + +// Tensor-product contraction +// out[a,b,c] = sum(i,j,k) psi[a,i] psi[b,j] psi[c,k] u[i,j,k] +// reaches the matcher as five rank-6 submap views over three flat buffers. +// The first three views share the psi base. Unwrap all views and let the +// cuTensorNet shim express the full Einstein contraction directly. +static LogicalResult lowerCutensornetTensorProduct3D(LaunchOp launch, + ModuleOp module, + bool useF64) { + if (launch.getNumOperands() != 5 || launch.getNumResults() != 1) + return launch.emitError( + "cuTensorNet tensor product: expected 5 operands and 1 result"); + + for (Value operand : launch.getOperands()) { + auto ty = dyn_cast(operand.getType()); + if (!ty || ty.getRank() != 6 || + (useF64 ? !ty.getElementType().isF64() + : !ty.getElementType().isF32())) + return launch.emitError( + "cuTensorNet tensor product: operands have wrong rank or type"); + auto submap = operand.getDefiningOp(); + if (!submap || submap.getSizes().size() != 6) + return launch.emitError( + "cuTensorNet tensor product: operands must be rank-6 submaps"); + } + + Value psi0 = resolveSubmapBase(launch.getOperand(0)); + Value psi1 = resolveSubmapBase(launch.getOperand(1)); + Value psi2 = resolveSubmapBase(launch.getOperand(2)); + Value u = resolveSubmapBase(launch.getOperand(3)); + Value out = resolveSubmapBase(launch.getOperand(4)); + if (psi0 != psi1 || psi0 != psi2) + return launch.emitError( + "cuTensorNet tensor product: first three views must share psi base"); + + auto psiTy = dyn_cast(psi0.getType()); + auto uTy = dyn_cast(u.getType()); + auto outTy = dyn_cast(out.getType()); + if (!psiTy || !uTy || !outTy || + (useF64 ? (!psiTy.getElementType().isF64() || + !uTy.getElementType().isF64() || + !outTy.getElementType().isF64()) + : (!psiTy.getElementType().isF32() || + !uTy.getElementType().isF32() || + !outTy.getElementType().isF32()))) + return launch.emitError( + "cuTensorNet tensor product: submap bases have wrong type"); + + auto firstView = launch.getOperand(0).getDefiningOp(); + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value KQ = valueAsI32(b, loc, firstView.getSizes()[0]); + Value KP = valueAsI32(b, loc, firstView.getSizes()[3]); + Value psiMr = tensorToMemref(b, loc, psi0); + Value uMr = tensorToMemref(b, loc, u); + Value outMr = tensorToMemref(b, loc, out); + Value psiPtr = memrefBasePtr(b, loc, psiMr); + Value uPtr = memrefBasePtr(b, loc, uMr); + Value outPtr = memrefBasePtr(b, loc, outMr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), b.getI32Type(), ptrTy, + ptrTy, ptrTy}; + StringRef shimName = useF64 + ? "polygeist_cutensornet_tensor_product_3d_f64" + : "polygeist_cutensornet_tensor_product_3d_f32"; + func::FuncOp shim = ensureShimDecl(module, shimName, argTypes, b); + b.create(loc, shim, + ValueRange{KQ, KP, psiPtr, uPtr, outPtr}); + + Value updatedOut = memrefToTensor(b, loc, outMr, out.getType()); + rewireLaunchResult(launch, updatedOut); + launch.erase(); + return success(); +} + +// Return the constant coefficient of affine dimension `dim` in a linear +// affine expression. MFEM's polygeist.submap views are flattened row-major +// maps such as d4 + d0 * 64 + d1 * 16 + d2 * 4. Their coefficients are the +// physical element strides needed by cuTensorNet. Reject non-linear +// floor/mod expressions rather than guessing a layout. +static std::optional +constantAffineDimCoefficient(AffineExpr expr, unsigned dim) { + if (auto d = expr.dyn_cast()) + return d.getPosition() == dim ? 1 : 0; + if (expr.isa() || expr.isa()) + return 0; + auto binary = expr.dyn_cast(); + if (!binary) + return std::nullopt; + if (binary.getKind() == AffineExprKind::Add) { + auto lhs = constantAffineDimCoefficient(binary.getLHS(), dim); + auto rhs = constantAffineDimCoefficient(binary.getRHS(), dim); + if (!lhs || !rhs) + return std::nullopt; + return *lhs + *rhs; + } + if (binary.getKind() == AffineExprKind::Mul) { + if (auto c = binary.getLHS().dyn_cast()) { + auto rhs = constantAffineDimCoefficient(binary.getRHS(), dim); + return rhs ? std::optional(c.getValue() * *rhs) + : std::nullopt; + } + if (auto c = binary.getRHS().dyn_cast()) { + auto lhs = constantAffineDimCoefficient(binary.getLHS(), dim); + return lhs ? std::optional(c.getValue() * *lhs) + : std::nullopt; + } + } + return std::nullopt; +} + +// Evaluate a linear affine expression with every dimension set to zero. The +// result is the constant base offset of a flattened submap. This matters for +// MFEM component views such as `... + 36`: strides alone describe their +// layout, but the runtime pointer must also start 36 elements into the base. +static std::optional constantAffineOffset(AffineExpr expr) { + if (expr.isa()) + return 0; + if (auto constant = expr.dyn_cast()) + return constant.getValue(); + if (expr.isa()) + return std::nullopt; + auto binary = expr.dyn_cast(); + if (!binary) + return std::nullopt; + auto lhs = constantAffineOffset(binary.getLHS()); + auto rhs = constantAffineOffset(binary.getRHS()); + if (!lhs || !rhs) + return std::nullopt; + if (binary.getKind() == AffineExprKind::Add) + return *lhs + *rhs; + if (binary.getKind() == AffineExprKind::Mul) + return *lhs * *rhs; + return std::nullopt; +} + +struct ContractionViewMetadata { + Value base; + Value elementOffset; + bool needsDenseInputCopy = false; + SmallVector extents; + SmallVector strides; + SmallVector modes; +}; + +static constexpr int64_t kContractionMaxModes = 64; + +static Value shapedDimAsI64(OpBuilder &b, Location loc, Value value, + unsigned dim) { + auto shaped = cast(value.getType()); + if (!shaped.isDynamicDim(dim)) + return b.create( + loc, b.getI64Type(), b.getI64IntegerAttr(shaped.getDimSize(dim))); + Value axis = b.create(loc, dim); + Value extent; + if (isa(value.getType())) + extent = b.create(loc, value, axis); + else + extent = b.create(loc, value, axis); + return integerLikeAsI64(b, loc, extent); +} + +// Return the physical element strides of an ordinary dense tensor or a +// same-rank extract_slice view. A slice keeps the parent tensor's strides; +// its result shape alone is not enough to recover the layout. For example, +// a 2x3x3x5 slice of a 2x4x4x5 tensor has strides 80,20,5,1, not the dense +// 45,15,5,1 strides implied by the slice's sizes. +static FailureOr> +physicalTensorStrides(OpBuilder &b, Location loc, Value tensor) { + Value stripped = stripTensorCasts(tensor); + auto type = dyn_cast(stripped.getType()); + if (!type) + return failure(); + + if (auto slice = stripped.getDefiningOp()) { + auto sourceType = dyn_cast(slice.getSource().getType()); + // Rank-reducing slices need a dimension-position map. Reject those here + // instead of silently assigning the wrong physical strides. + if (!sourceType || sourceType.getRank() != type.getRank() || + slice.getMixedStrides().size() != (unsigned)type.getRank()) + return failure(); + auto sourceStrides = + physicalTensorStrides(b, loc, slice.getSource()); + if (failed(sourceStrides)) + return failure(); + SmallVector result; + for (unsigned dim = 0; dim < (unsigned)type.getRank(); ++dim) { + Value step = opFoldResultAsI64(b, loc, slice.getMixedStrides()[dim]); + result.push_back( + b.create(loc, (*sourceStrides)[dim], step)); + } + return result; + } + + SmallVector result(type.getRank()); + Value stride = b.create( + loc, b.getI64Type(), b.getI64IntegerAttr(1)); + for (int64_t dim = type.getRank() - 1; dim >= 0; --dim) { + result[dim] = stride; + stride = b.create( + loc, stride, shapedDimAsI64(b, loc, stripped, dim)); + } + return result; +} + +static FailureOr +buildContractionViewMetadata(OpBuilder &b, Location loc, Value operand, + AffineMap accessMap) { + Value stripped = stripTensorCasts(operand); + auto operandType = dyn_cast(stripped.getType()); + if (!operandType || !operandType.getElementType().isF64() || + operandType.getRank() > kContractionMaxModes || + accessMap.getNumResults() != (unsigned)operandType.getRank()) + return failure(); + + SmallVector logicalModes; + for (AffineExpr result : accessMap.getResults()) { + auto dim = result.dyn_cast(); + if (!dim || dim.getPosition() >= kContractionMaxModes) + return failure(); + logicalModes.push_back(dim.getPosition()); + } + + SmallVector logicalExtents; + SmallVector logicalStrides; + Value base = resolveSubmapBase(stripped); + Value elementOffset = b.create( + loc, b.getI64Type(), b.getI64IntegerAttr(0)); + if (auto submap = stripped.getDefiningOp()) { + auto baseType = dyn_cast(base.getType()); + if (!baseType || + submap.getSizes().size() != (unsigned)operandType.getRank()) + return failure(); + + if (baseType.getRank() == 1 && + submap.getMap().getNumResults() == 1) { + // General flattened view: derive one physical stride per logical dim + // from the affine address expression. Zero strides are broadcasts. + AffineExpr flatExpr = submap.getMap().getResult(0); + auto constantOffset = constantAffineOffset(flatExpr); + if (!constantOffset || *constantOffset < 0) + return failure(); + elementOffset = b.create( + loc, b.getI64Type(), b.getI64IntegerAttr(*constantOffset)); + for (unsigned dim = 0; dim < (unsigned)operandType.getRank(); ++dim) { + logicalExtents.push_back( + integerLikeAsI64(b, loc, submap.getSizes()[dim])); + auto coefficient = constantAffineDimCoefficient(flatExpr, dim); + if (!coefficient || *coefficient < 0) + return failure(); + logicalStrides.push_back(b.create( + loc, b.getI64Type(), b.getI64IntegerAttr(*coefficient))); + } + } else { + // A submap over an ordinary ranked tensor can still express + // permutation and broadcasting. Compose its affine coefficients with + // the direct base's dense row-major strides. This covers both identity + // accumulator views and maps such as + // (d0,d1,d2,d3,d4) -> (d0,d1,d4,d3) + // without pretending that an arbitrary nonlinear map is supported. + Value directBase = submap.getBase(); + auto directBaseType = dyn_cast(directBase.getType()); + if (!directBaseType || + submap.getMap().getNumResults() != + static_cast(directBaseType.getRank()) || + submap.getMap().getNumSymbols() != 0) + return failure(); + base = directBase; + for (Value size : submap.getSizes()) + logicalExtents.push_back(integerLikeAsI64(b, loc, size)); + + SmallVector baseStrides(directBaseType.getRank()); + Value stride = b.create( + loc, b.getI64Type(), b.getI64IntegerAttr(1)); + for (int64_t dim = directBaseType.getRank() - 1; dim >= 0; --dim) { + baseStrides[dim] = stride; + stride = b.create( + loc, stride, shapedDimAsI64(b, loc, directBase, dim)); + } + for (unsigned baseDim = 0; + baseDim < static_cast(directBaseType.getRank()); + ++baseDim) { + auto constantOffset = + constantAffineOffset(submap.getMap().getResult(baseDim)); + if (!constantOffset || *constantOffset < 0) + return failure(); + if (*constantOffset == 0) + continue; + Value coefficient = b.create( + loc, b.getI64Type(), b.getI64IntegerAttr(*constantOffset)); + Value contribution = + b.create(loc, baseStrides[baseDim], coefficient); + elementOffset = + b.create(loc, elementOffset, contribution); + } + for (unsigned logicalDim = 0; + logicalDim < static_cast(operandType.getRank()); + ++logicalDim) { + Value logicalStride = b.create( + loc, b.getI64Type(), b.getI64IntegerAttr(0)); + for (unsigned baseDim = 0; + baseDim < static_cast(directBaseType.getRank()); + ++baseDim) { + auto coefficient = constantAffineDimCoefficient( + submap.getMap().getResult(baseDim), logicalDim); + if (!coefficient || *coefficient < 0) + return failure(); + if (*coefficient == 0) + continue; + Value coefficientValue = b.create( + loc, b.getI64Type(), b.getI64IntegerAttr(*coefficient)); + Value contribution = b.create( + loc, baseStrides[baseDim], coefficientValue); + logicalStride = + b.create(loc, logicalStride, contribution); + } + logicalStrides.push_back(logicalStride); + } + } + } else if (auto slice = stripped.getDefiningOp()) { + base = stripped; + if (slice.getMixedSizes().size() != (unsigned)operandType.getRank()) + return failure(); + for (OpFoldResult size : slice.getMixedSizes()) + logicalExtents.push_back(opFoldResultAsI64(b, loc, size)); + auto physicalStrides = physicalTensorStrides(b, loc, stripped); + if (failed(physicalStrides)) + return failure(); + logicalStrides.append(physicalStrides->begin(), physicalStrides->end()); + } else { + base = stripped; + for (unsigned dim = 0; dim < (unsigned)operandType.getRank(); ++dim) + logicalExtents.push_back(shapedDimAsI64(b, loc, stripped, dim)); + Value stride = b.create( + loc, b.getI64Type(), b.getI64IntegerAttr(1)); + logicalStrides.resize(operandType.getRank()); + for (int64_t dim = operandType.getRank() - 1; dim >= 0; --dim) { + logicalStrides[dim] = stride; + stride = b.create(loc, stride, logicalExtents[dim]); + } + } + + ContractionViewMetadata metadata; + metadata.base = base; + metadata.elementOffset = elementOffset; + // An ordinary tensor result can have been bufferized in-place into a + // strided DPS init even though tensor types carry no layout. The dense + // strides derived below are therefore only safe after materializing an + // explicit dense input copy. Submaps and extract_slice views have layout + // provenance and do not need this fallback. + if (stripped.getDefiningOp()) { + // A submap of a computed tensor (for example, the stress tensor produced + // by an MFEM quadrature stage) must stay live across the opaque call and + // later component contractions. Materialize its flat/ranked base unless + // it is a direct function memref view. + metadata.needsDenseInputCopy = sourceToTensorOp(base) == nullptr; + } else { + metadata.needsDenseInputCopy = + !stripped.getDefiningOp() && + stripped.getDefiningOp() != nullptr; + } + for (unsigned dim = 0; dim < logicalModes.size(); ++dim) { + // A zero physical stride is a broadcasted logical mode. cuTensorNet and + // cuTENSOR represent broadcasting by omitting that mode from the tensor, + // rather than by passing an illegal zero stride. + llvm::APInt staticStride; + if (matchPattern(logicalStrides[dim], m_ConstantInt(&staticStride)) && + staticStride.isZero()) + continue; + metadata.extents.push_back(logicalExtents[dim]); + metadata.strides.push_back(logicalStrides[dim]); + metadata.modes.push_back(logicalModes[dim]); + } + return metadata; +} + +// Generic two-input FP64 Einstein contraction for MFEM's mode-wise +// sum-factorization stages. Metadata layout (all i64): +// [rankA, rankB, rankC, +// A.extent[64], A.stride[64], A.mode[64], +// B.extent[64], B.stride[64], B.mode[64], +// C.extent[64], C.stride[64], C.mode[64]] +// Unused slots are extent=1, stride=0, mode=-1. +static bool isDeclaredDeviceResidentTensor(Value value) { + value = stripTensorCasts(value); + if (isa(value)) + return true; + if (auto submap = value.getDefiningOp()) + return isDeclaredDeviceResidentTensor(submap.getBase()); + if (auto slice = value.getDefiningOp()) + return isDeclaredDeviceResidentTensor(slice.getSource()); + if (auto launch = value.getDefiningOp()) + return launch->hasAttr("polygeist.device_resident"); + return false; +} + +static LogicalResult verifyNoResidualHostDeviceConsumers(LaunchOp launch) { + func::FuncOp function = launch->getParentOfType(); + if (!function) + return launch.emitError("device-resident launch must be inside a function"); + Operation *illegal = nullptr; + function.walk([&](Operation *op) { + if (illegal) + return WalkResult::interrupt(); + StringRef name = op->getName().getStringRef(); + if ((name.startswith("linalg.") && name != "linalg.yield") || + name.startswith("affine.") || + name.startswith("scf.") || name == "memref.load" || + name == "memref.store" || name == "memref.copy" || + name == "tensor.extract" || name == "tensor.insert" || + name == "tensor.insert_slice" || + name == "polygeist.submapInverse") { + illegal = op; + return WalkResult::interrupt(); + } + return WalkResult::advance(); + }); + if (!illegal) + return success(); + InFlightDiagnostic diagnostic = launch.emitError( + "device-resident cuTensorNet ABI is illegal while residual host tensor " + "computation remains"); + diagnostic.attachNote(illegal->getLoc()) + << "host operation is here: " << illegal->getName().getStringRef(); + return failure(); +} + +static LogicalResult lowerCutensornetContraction2F64(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 3 || launch.getNumResults() != 1) + return launch.emitError( + "cuTensorNet contraction: expected A/B/C operands and one result"); + auto mapsAttr = launch->getAttrOfType("contraction_maps"); + if (!mapsAttr || mapsAttr.size() != 3) + return launch.emitError( + "cuTensorNet contraction: expected three contraction_maps"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + const bool deviceResident = + launch->hasAttr("polygeist.device_resident"); + if (deviceResident && failed(verifyNoResidualHostDeviceConsumers(launch))) + return failure(); + SmallVector metadata; + for (unsigned i = 0; i < 3; ++i) { + auto mapAttr = dyn_cast(mapsAttr[i]); + if (!mapAttr) + return launch.emitError( + "cuTensorNet contraction: contraction_maps must be affine maps"); + auto view = + buildContractionViewMetadata(b, loc, launch.getOperand(i), + mapAttr.getValue()); + if (failed(view)) + return launch.emitError( + "cuTensorNet contraction: unsupported operand view/map layout"); + metadata.push_back(*view); + if (deviceResident && !isDeclaredDeviceResidentTensor(view->base)) + return launch.emitError( + "device-resident cuTensorNet ABI requires every operand buffer to " + "originate from a device-ABI function argument or another " + "device-resident launch"); + } + if (metadata[2].modes.empty()) + return launch.emitError( + "cuTensorNet contraction: scalar/fully-broadcast outputs are not yet " + "supported"); + + llvm::SmallSet inputModes; + llvm::SmallSet outputModes; + for (int64_t mode : metadata[0].modes) + inputModes.insert(mode); + for (int64_t mode : metadata[1].modes) + inputModes.insert(mode); + for (int64_t mode : metadata[2].modes) { + if (!inputModes.contains(mode)) + return launch.emitError( + "cuTensorNet contraction: output mode is absent from both inputs"); + outputModes.insert(mode); + } + bool hasReduction = llvm::any_of( + inputModes, [&](int64_t mode) { return !outputModes.contains(mode); }); + if (!hasReduction) + return launch.emitError( + "cuTensorNet contraction: expected at least one reduced mode"); + + constexpr int64_t kMaxRank = kContractionMaxModes; + constexpr int64_t kFieldsPerTensor = 3 * kMaxRank; + constexpr int64_t kMetadataSize = 3 + 3 * kFieldsPerTensor; + auto metadataType = MemRefType::get({kMetadataSize}, b.getI64Type()); + Value metadataBuffer = b.create(loc, metadataType); + auto storeMetadata = [&](int64_t index, Value value) { + Value slot = b.create(loc, index); + b.create(loc, value, metadataBuffer, slot); + }; + auto constantI64 = [&](int64_t value) -> Value { + return b.create( + loc, b.getI64Type(), b.getI64IntegerAttr(value)); + }; + for (unsigned tensor = 0; tensor < 3; ++tensor) { + storeMetadata(tensor, constantI64(metadata[tensor].modes.size())); + int64_t baseOffset = 3 + tensor * kFieldsPerTensor; + for (int64_t dim = 0; dim < kMaxRank; ++dim) { + bool present = dim < (int64_t)metadata[tensor].modes.size(); + storeMetadata(baseOffset + dim, + present ? metadata[tensor].extents[dim] : constantI64(1)); + storeMetadata(baseOffset + kMaxRank + dim, + present ? metadata[tensor].strides[dim] : constantI64(0)); + storeMetadata(baseOffset + 2 * kMaxRank + dim, + constantI64(present ? metadata[tensor].modes[dim] : -1)); + } + } + + SmallVector memrefs; + SmallVector pointers; + for (unsigned tensor = 0; tensor < metadata.size(); ++tensor) { + const ContractionViewMetadata &view = metadata[tensor]; + Value memref = valueToMemref(b, loc, view.base); + if (deviceResident && tensor < 2 && view.needsDenseInputCopy) + return launch.emitError( + "device-resident cuTensorNet ABI cannot materialize a host-side " + "dense input snapshot"); + if (tensor < 2 && view.needsDenseInputCopy) + memref = snapshotOpaqueCallResult(b, loc, memref); + memrefs.push_back(memref); + Value pointer = memrefBasePtr(b, loc, memref); + llvm::APInt staticOffset; + if (!matchPattern(view.elementOffset, m_ConstantInt(&staticOffset)) || + !staticOffset.isZero()) { + Value address = b.create( + loc, b.getI64Type(), pointer); + unsigned bits = cast(memref.getType()) + .getElementType() + .getIntOrFloatBitWidth(); + Value elementBytes = b.create( + loc, b.getI64Type(), b.getI64IntegerAttr(bits / 8)); + Value byteOffset = + b.create(loc, view.elementOffset, elementBytes); + address = b.create(loc, address, byteOffset); + pointer = b.create( + loc, LLVM::LLVMPointerType::get(b.getContext()), address); + } + pointers.push_back(pointer); + } + Value metadataPtr = memrefBasePtr(b, loc, metadataBuffer); + auto ptrType = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes(4, ptrType); + StringRef shimName = deviceResident + ? "polygeist_cutensornet_contraction2_f64_device" + : "polygeist_cutensornet_contraction2_f64"; + func::FuncOp shim = ensureShimDecl( + module, shimName, argTypes, b); + b.create( + loc, shim, + ValueRange{pointers[0], pointers[1], pointers[2], metadataPtr}); + + // The common destination-style form extracts the full (or a sliced) output + // from a to_tensor of the public ABI memref, then inserts the launch result + // back into that same tensor. The pointer above already aliases that ABI + // destination, so bypass both the compatibility snapshot and the terminal + // write-back. Besides avoiding a full tensor copy, this keeps large GEMMs + // from manufacturing dynamic memref descriptors solely for a dead copy. + if (Value destinationBase = + tensorForOutputSliceSource(b, loc, metadata[2].base)) { + rewireTensorSliceLaunchResult(launch, Value(), destinationBase); + if (!launch.getResult(0).use_empty()) + return launch.emitError( + "cuTensorNet contraction: unsupported consumer of direct output"); + launch.erase(); + return success(); + } + + if (deviceResident) { + // The device runtime writes the DPS output buffer in place. Avoid the + // correctness-first host snapshot used by the compatibility ABI: copying + // a CUDA device pointer with memref.copy would be invalid. The legality + // pre-check permits this path only when no residual host tensor operation + // can observe the SSA value independently of that buffer side effect. + Value outputView = launch.getOperand(2); + Value outputBase = metadata[2].base; + if (failed(rewireSubmapLaunchResult(launch, outputView, outputBase))) + return failure(); + launch.erase(); + return success(); + } + + // The runtime receives only an LLVM pointer, so its write is invisible to + // tensor bufferization. Preserve this result before a later scratch tensor + // can reuse the output allocation. This is correctness-first; a future + // bufferizable library-call op can model the write directly and remove the + // snapshot copy. + Value outputSnapshot = snapshotOpaqueCallResult(b, loc, memrefs[2]); + Value updatedOutput = + memrefToTensor(b, loc, outputSnapshot, metadata[2].base.getType()); + Value updatedOutputView = updatedOutput; + Value originalOutput = stripTensorCasts(launch.getOperand(2)); + if (auto submap = originalOutput.getDefiningOp()) { + SmallVector indicesAndSizes(submap.getOperands().drop_front()); + updatedOutputView = b.create( + loc, launch.getOperand(2).getType(), updatedOutput, indicesAndSizes, + submap.getMap()); + } else if (updatedOutput.getType() != launch.getResult(0).getType()) { + // Extract-slice and ordinary DPS outputs may be statically shaped below + // the dynamic ABI cast used by kernel.launch. Their snapshot already has + // the right rank and layout; restore only the launch's exposed tensor + // type before reconnecting its consumers. + updatedOutputView = b.create( + loc, launch.getResult(0).getType(), updatedOutput); + } + if (isa(launch.getResult(0).getType())) { + SmallVector resultCasts; + for (Operation *user : launch.getResult(0).getUsers()) + if (auto cast = dyn_cast(user)) + resultCasts.push_back(cast); + for (tensor::CastOp cast : resultCasts) { + SmallVector inverses; + for (Operation *user : cast.getResult().getUsers()) + if (auto inverse = dyn_cast(user)) + inverses.push_back(inverse); + for (polygeist::SubmapInverseOp inverse : inverses) { + inverse.getResult().replaceAllUsesWith(updatedOutput); + inverse.erase(); + } + if (!cast.getResult().use_empty() && + cast.getResult().getType() == updatedOutput.getType()) + cast.getResult().replaceAllUsesWith(updatedOutput); + if (cast.getResult().use_empty()) + cast.erase(); + } + } + if (failed(rewireSubmapLaunchResult(launch, updatedOutputView, + updatedOutput))) + return failure(); + launch.erase(); + return success(); +} + +// Darknet im2col+GEMM reaches the matcher as rank-3 broadcasted submaps: +// A(m, k, n) -> weights[m, k] +// B(m, k, n) -> workspace[k, n] +// C(m, k, n) -> output[m, n] +// The underlying buffers are still regular row-major 2D GEMM operands, so +// unwrap the submaps and call the FP32 cuBLAS shim with M/N/K from the view +// sizes. The middle C dimension is the reduction/broadcast dimension and is +// ignored by the base output map. +static LogicalResult lowerSgemmBroadcast3DSimple(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 3) + return launch.emitError( + "cublasSgemm_broadcast3d_simple: expected A/B/C operands"); + if (launch.getNumResults() != 1) + return launch.emitError( + "cublasSgemm_broadcast3d_simple: expected 1 result"); + + Value A = launch.getOperand(0); + Value B = launch.getOperand(1); + Value C = launch.getOperand(2); + auto At = dyn_cast(A.getType()); + auto Bt = dyn_cast(B.getType()); + auto Ct = dyn_cast(C.getType()); + if (!At || !Bt || !Ct || At.getRank() != 3 || Bt.getRank() != 3 || + Ct.getRank() != 3 || !At.getElementType().isF32() || + !Bt.getElementType().isF32() || !Ct.getElementType().isF32()) + return launch.emitError( + "cublasSgemm_broadcast3d_simple: A/B/C must be 3D f32 tensors"); + + auto aSubmap = A.getDefiningOp(); + auto bSubmap = B.getDefiningOp(); + auto cSubmap = C.getDefiningOp(); + if (!aSubmap || !bSubmap || !cSubmap || aSubmap.getSizes().size() != 3 || + bSubmap.getSizes().size() != 3 || cSubmap.getSizes().size() != 3) + return launch.emitError( + "cublasSgemm_broadcast3d_simple: operands must be rank-3 submaps"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + + Value M = valueAsI32(b, loc, aSubmap.getSizes()[0]); + Value K = valueAsI32(b, loc, aSubmap.getSizes()[1]); + Value N = valueAsI32(b, loc, aSubmap.getSizes()[2]); + Value alpha = b.create(loc, b.getF32Type(), + b.getF32FloatAttr(1.0)); + Value beta = b.create(loc, b.getF32Type(), + b.getF32FloatAttr(1.0)); + + Value A_base = resolveSubmapBase(A); + Value B_base = resolveSubmapBase(B); + Value C_base = resolveSubmapBase(C); + auto A_base_type = dyn_cast(A_base.getType()); + auto B_base_type = dyn_cast(B_base.getType()); + auto C_base_type = dyn_cast(C_base.getType()); + if (!A_base_type || !B_base_type || !C_base_type || + !A_base_type.getElementType().isF32() || + !B_base_type.getElementType().isF32() || + !C_base_type.getElementType().isF32()) + return launch.emitError( + "cublasSgemm_broadcast3d_simple: submap bases must be f32 tensors"); + + Value A_mr = tensorToMemref(b, loc, A_base); + Value B_mr = tensorToMemref(b, loc, B_base); + Value C_mr = tensorToMemref(b, loc, C_base); + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value B_ptr = memrefBasePtr(b, loc, B_mr); + Value C_ptr = memrefBasePtr(b, loc, C_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), b.getI32Type(), + b.getF32Type(), + ptrTy, b.getI32Type(), + ptrTy, b.getI32Type(), + b.getF32Type(), + ptrTy, b.getI32Type(), + }; + func::FuncOp shim = ensureShimDecl(module, "polygeist_cublas_sgemm", + argTypes, b); + SmallVector callOperands = {M, N, K, alpha, A_ptr, K, + B_ptr, N, beta, C_ptr, N}; + b.create(loc, shim, callOperands); + + Value updatedBaseTensor = memrefToTensor(b, loc, C_mr, C_base.getType()); + rewireLaunchResult(launch, updatedBaseTensor); + launch.erase(); + return success(); +} + +// C[B,M,N] = A[B,M,K] * RHS[K,N], with one RHS shared by every batch. +// The runtime uses cublasSgemmStridedBatched and represents broadcasting by +// setting the RHS batch stride to zero. +static LogicalResult lowerSgemmStridedBatchedBroadcastRhs(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 3 || launch.getNumResults() != 1) + return launch.emitError( + "cublasSgemm_strided_batched_broadcast_rhs: expected A/B/C and one " + "result"); + + Value A = launch.getOperand(0); + Value B = launch.getOperand(1); + Value C = launch.getOperand(2); + auto At = dyn_cast(A.getType()); + auto Bt = dyn_cast(B.getType()); + auto Ct = dyn_cast(C.getType()); + if (!At || !Bt || !Ct || At.getRank() != 3 || Bt.getRank() != 2 || + Ct.getRank() != 3 || !At.getElementType().isF32() || + !Bt.getElementType().isF32() || !Ct.getElementType().isF32()) + return launch.emitError( + "cublasSgemm_strided_batched_broadcast_rhs: expected rank-3/rank-2/" + "rank-3 f32 tensors"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value batch = dimForTensorOrMemrefAsI32(b, loc, A, 0); + Value M = dimForTensorOrMemrefAsI32(b, loc, A, 1); + Value K = dimForTensorOrMemrefAsI32(b, loc, A, 2); + Value N = dimForTensorOrMemrefAsI32(b, loc, B, 1); + Value A_mr = valueToMemrefPreservingSlice(b, loc, A); + Value B_mr = valueToMemrefPreservingSlice(b, loc, B); + Value C_mr = valueToMemrefPreservingSlice(b, loc, C); + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value B_ptr = memrefBasePtr(b, loc, B_mr); + Value C_ptr = memrefBasePtr(b, loc, C_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), b.getI32Type(), + b.getI32Type(), b.getI32Type(), + ptrTy, ptrTy, ptrTy}; + func::FuncOp shim = ensureShimDecl( + module, "polygeist_cublas_sgemm_strided_batched_broadcast_rhs", + argTypes, b); + b.create(loc, shim, + ValueRange{batch, M, N, K, A_ptr, B_ptr, C_ptr}); + + Value out = memrefToTensor(b, loc, C_mr, launch.getResult(0).getType()); + rewireTensorSliceLaunchResult(launch, out, + tensorForSliceSource(b, loc, C)); + launch.erase(); + return success(); +} + +static LogicalResult lowerSgemmBroadcast3DMemRef(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 3) + return launch.emitError( + "cublasSgemm_broadcast3d_memref: expected A/B/C operands"); + if (launch.getNumResults() != 0) + return launch.emitError( + "cublasSgemm_broadcast3d_memref: expected no results"); + + Value A = launch.getOperand(0); + Value B = launch.getOperand(1); + Value C = launch.getOperand(2); + auto At = dyn_cast(A.getType()); + auto Bt = dyn_cast(B.getType()); + auto Ct = dyn_cast(C.getType()); + if (!At || !Bt || !Ct || At.getRank() != 3 || Bt.getRank() != 3 || + Ct.getRank() != 3 || !At.getElementType().isF32() || + !Bt.getElementType().isF32() || !Ct.getElementType().isF32()) + return launch.emitError( + "cublasSgemm_broadcast3d_memref: A/B/C must be 3D f32 memrefs"); + + auto aSubmap = A.getDefiningOp(); + auto bSubmap = B.getDefiningOp(); + auto cSubmap = C.getDefiningOp(); + if (!aSubmap || !bSubmap || !cSubmap || aSubmap.getSizes().size() != 3 || + bSubmap.getSizes().size() != 3 || cSubmap.getSizes().size() != 3) + return launch.emitError( + "cublasSgemm_broadcast3d_memref: operands must be rank-3 submaps"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value M = valueAsI32(b, loc, aSubmap.getSizes()[0]); + Value K = valueAsI32(b, loc, aSubmap.getSizes()[1]); + Value N = valueAsI32(b, loc, aSubmap.getSizes()[2]); + Value alpha = b.create(loc, b.getF32Type(), + b.getF32FloatAttr(1.0)); + Value beta = b.create(loc, b.getF32Type(), + b.getF32FloatAttr(1.0)); + + Value A_base = aSubmap.getBase(); + Value B_base = bSubmap.getBase(); + Value C_base = cSubmap.getBase(); + auto ABaseType = dyn_cast(A_base.getType()); + auto BBaseType = dyn_cast(B_base.getType()); + auto CBaseType = dyn_cast(C_base.getType()); + if (!ABaseType || !BBaseType || !CBaseType || + !ABaseType.getElementType().isF32() || + !BBaseType.getElementType().isF32() || + !CBaseType.getElementType().isF32()) + return launch.emitError( + "cublasSgemm_broadcast3d_memref: submap bases must be f32 memrefs"); + + Value A_ptr = memrefBasePtr(b, loc, A_base); + Value B_ptr = memrefBasePtr(b, loc, B_base); + Value C_ptr = memrefBasePtr(b, loc, C_base); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), b.getI32Type(), + b.getF32Type(), + ptrTy, b.getI32Type(), + ptrTy, b.getI32Type(), + b.getF32Type(), + ptrTy, b.getI32Type(), + }; + func::FuncOp shim = ensureShimDecl(module, "polygeist_cublas_sgemm", + argTypes, b); + SmallVector callOperands = {M, N, K, alpha, A_ptr, K, + B_ptr, N, beta, C_ptr, N}; + b.create(loc, shim, callOperands); + launch.erase(); + return success(); +} + +// @cublasDgeam_scale2D(%M : tensor, %scale : f64) -> tensor +// Diagonal/scale-only geam: M = scale * M, in place. +static LogicalResult lowerDgeamScale2D(LaunchOp launch, ModuleOp module) { + if (launch.getNumOperands() != 2) + return launch.emitError("cublasDgeam_scale2D: expected 2 operands"); + Value M = launch.getOperand(0); + Value scale = launch.getOperand(1); + auto Mt = dyn_cast(M.getType()); + if (!Mt || Mt.getRank() != 2 || !Mt.getElementType().isF64()) + return launch.emitError("cublasDgeam_scale2D: M must be 2D f64 tensor"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value M_mr = tensorToMemref(b, loc, M); + Value rows = memrefDimAsI32(b, loc, M_mr, 0); + Value cols = memrefDimAsI32(b, loc, M_mr, 1); + Value M_ptr = memrefBasePtr(b, loc, M_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), b.getI32Type(), + b.getF64Type(), ptrTy, b.getI32Type()}; + func::FuncOp shim = ensureShimDecl(module, "polygeist_cublas_dscal_2d", + argTypes, b); + b.create(loc, shim, ValueRange{rows, cols, scale, M_ptr, cols}); + + Value out = memrefToTensor(b, loc, M_mr, launch.getResult(0).getType()); + launch.getResult(0).replaceAllUsesWith(out); + launch.erase(); + return success(); +} + +// The actual @cudnnConvolution2D_9tap lowering body is shared with +// LowerKernelLaunchToPVA via KernelLaunchLoweringUtils.cpp. Bring it into +// this file's scope so the dispatch switch below can name it unqualified. +using mlir::polygeist::lowerCudnnConv2D9tap; +using mlir::polygeist::lowerCudnnConv2D25tap; +using mlir::polygeist::lowerCudnnConv2DNtapPacked; + +// Shared lowering for tensor GEMV. D/S variants differ only in element type +// and runtime shim symbol; transpose picks A*x vs A^T*x. +static LogicalResult lowerDgemvImpl(LaunchOp launch, ModuleOp module, + bool transpose, bool useF32); + +static LogicalResult lowerDgemv(LaunchOp launch, ModuleOp module) { + return lowerDgemvImpl(launch, module, /*transpose=*/false, /*useF32=*/false); +} + +static LogicalResult lowerDgemvT(LaunchOp launch, ModuleOp module) { + return lowerDgemvImpl(launch, module, /*transpose=*/true, /*useF32=*/false); +} + +static LogicalResult lowerSgemv(LaunchOp launch, ModuleOp module) { + return lowerDgemvImpl(launch, module, /*transpose=*/false, /*useF32=*/true); +} + +static LogicalResult lowerSgemvT(LaunchOp launch, ModuleOp module) { + return lowerDgemvImpl(launch, module, /*transpose=*/true, /*useF32=*/true); +} + +// @cublasDgemv(%A : tensor, %x : tensor, %y : tensor) +// -> tensor +// Computes y += A * x. The canonical kernel definition retains the output +// accumulator, so its BLAS beta is 1. +// +// cuBLAS gemv signature (in our row-major convention): +// polygeist_cublas_dgemv(M, N, alpha, A*, lda, x*, beta, y*) +static LogicalResult lowerDgemvImpl(LaunchOp launch, ModuleOp module, + bool transpose, bool useF32) { + StringRef libName = useF32 ? "cublasSgemv" : "cublasDgemv"; + StringRef elemName = useF32 ? "f32" : "f64"; + if (launch.getNumOperands() != 3) + return launch.emitError(libName) + << " lowering: expected 3 operands (A, x, y), got " + << launch.getNumOperands(); + if (launch.getNumResults() != 1) + return launch.emitError(libName) << " lowering: expected 1 result"; + + Value A = launch.getOperand(0); + Value x = launch.getOperand(1); + Value y = launch.getOperand(2); + auto At = dyn_cast(A.getType()); + auto xt = dyn_cast(x.getType()); + auto yt = dyn_cast(y.getType()); + auto hasElem = [&](Type ty) { return useF32 ? ty.isF32() : ty.isF64(); }; + if (!At || At.getRank() != 2 || !hasElem(At.getElementType())) + return launch.emitError(libName) + << " lowering: A must be 2D " << elemName << " tensor"; + if (!xt || xt.getRank() != 1 || !hasElem(xt.getElementType())) + return launch.emitError(libName) + << " lowering: x must be 1D " << elemName << " tensor"; + if (!yt || yt.getRank() != 1 || !hasElem(yt.getElementType())) + return launch.emitError(libName) + << " lowering: y must be 1D " << elemName << " tensor"; + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Type scalarTy = useF32 ? b.getF32Type() : b.getF64Type(); + TypedAttr oneAttr = useF32 ? b.getF32FloatAttr(1.0f) + : b.getF64FloatAttr(1.0); + Value one = b.create(loc, scalarTy, oneAttr); + + // Do not blindly materialize tensor operands with bufferization.to_memref. + // Matched GEMVs commonly consume tensor.extract_slice views of the original + // C ABI memrefs. A to_memref here makes one-shot-bufferize allocate and + // copy the complete matrix/vector before the cuBLAS call; it also makes + // device-resident C ABI pointers unsafe because that copy executes on the + // host. Preserve those views and derive the runtime pointers directly from + // their source buffers instead. + Value M = dimForTensorOrMemrefAsI32(b, loc, A, 0); + Value N = dimForTensorOrMemrefAsI32(b, loc, A, 1); + Value lda = N; // row-major + + Value A_ptr = pointerForTensorOrMemref(b, loc, A); + Value x_ptr = pointerForTensorOrMemref(b, loc, x); + Value y_ptr = pointerForTensorOrMemref(b, loc, y); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), // M, N (A's row-major shape) + scalarTy, // alpha + ptrTy, b.getI32Type(), // A*, lda + ptrTy, // x* + scalarTy, // beta + ptrTy, // y* + }; + StringRef shimSym = + useF32 ? (transpose ? "polygeist_cublas_sgemv_T" + : "polygeist_cublas_sgemv") + : (transpose ? "polygeist_cublas_dgemv_T" + : "polygeist_cublas_dgemv"); + func::FuncOp shim = ensureShimDecl(module, shimSym, argTypes, b); + b.create(loc, shim, + ValueRange{M, N, one, A_ptr, lda, x_ptr, one, y_ptr}); + + // Keep the output as a view of its original destination buffer and bypass + // the canonical tensor.insert_slice write-back. The opaque cuBLAS call has + // already updated that storage in place. + Value y_mr = valueToMemrefPreservingSlice(b, loc, y); + Value updatedView = + memrefToTensor(b, loc, y_mr, launch.getResult(0).getType()); + Value updatedBase = tensorForSliceSource(b, loc, y); + rewireTensorSliceLaunchResult(launch, updatedView, updatedBase); + launch.erase(); + return success(); +} + +// @cublasDaxpby(%x : tensor, %y : tensor, %alpha : f64, %beta : f64) +// -> tensor +// Computes y = α*x + β*y. Output (the second tensor) is updated in place. +static LogicalResult lowerDaxpby(LaunchOp launch, ModuleOp module) { + if (launch.getNumOperands() != 4) + return launch.emitError("cublasDaxpby: expected 4 operands (x, y, α, β)"); + Value x = launch.getOperand(0); + Value y = launch.getOperand(1); + Value alpha = launch.getOperand(2); + Value beta = launch.getOperand(3); + auto xt = dyn_cast(x.getType()); + auto yt = dyn_cast(y.getType()); + if (!xt || xt.getRank() != 1 || !xt.getElementType().isF64() || + !yt || yt.getRank() != 1 || !yt.getElementType().isF64()) + return launch.emitError("cublasDaxpby: x,y must be 1D f64 tensors"); + if (!alpha.getType().isF64() || !beta.getType().isF64()) + return launch.emitError("cublasDaxpby: α,β must be f64"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value x_mr = tensorToMemref(b, loc, x); + Value y_mr = tensorToMemref(b, loc, y); + Value N = memrefDimAsI32(b, loc, y_mr, 0); + Value x_ptr = memrefBasePtr(b, loc, x_mr); + Value y_ptr = memrefBasePtr(b, loc, y_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), b.getF64Type(), ptrTy, + b.getF64Type(), ptrTy}; + func::FuncOp shim = ensureShimDecl(module, "polygeist_cublas_daxpby", + argTypes, b); + b.create(loc, shim, + ValueRange{N, alpha, x_ptr, beta, y_ptr}); + Value out = memrefToTensor(b, loc, y_mr, launch.getResult(0).getType()); + launch.getResult(0).replaceAllUsesWith(out); + launch.erase(); + return success(); +} + +// @cublasDaxpy_unit(%x : tensor, %y : tensor) -> tensor +// Computes y += x. α=1, no β scale. +static LogicalResult lowerDaxpyUnit(LaunchOp launch, ModuleOp module) { + if (launch.getNumOperands() != 2) + return launch.emitError("cublasDaxpy_unit: expected 2 operands (x, y)"); + Value x = launch.getOperand(0); + Value y = launch.getOperand(1); + auto xt = dyn_cast(x.getType()); + auto yt = dyn_cast(y.getType()); + if (!xt || xt.getRank() != 1 || !xt.getElementType().isF64() || + !yt || yt.getRank() != 1 || !yt.getElementType().isF64()) + return launch.emitError("cublasDaxpy_unit: x,y must be 1D f64 tensors"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value x_mr = tensorToMemref(b, loc, x); + Value y_mr = tensorToMemref(b, loc, y); + Value N = memrefDimAsI32(b, loc, y_mr, 0); + Value x_ptr = memrefBasePtr(b, loc, x_mr); + Value y_ptr = memrefBasePtr(b, loc, y_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), ptrTy, ptrTy}; + func::FuncOp shim = ensureShimDecl(module, "polygeist_cublas_daxpy_unit", + argTypes, b); + b.create(loc, shim, ValueRange{N, x_ptr, y_ptr}); + Value out = memrefToTensor(b, loc, y_mr, launch.getResult(0).getType()); + launch.getResult(0).replaceAllUsesWith(out); + launch.erase(); + return success(); +} + +// @cublasDgemv_alpha(%A, %x, %y, %alpha) → tensor (y += α·A·x) +static LogicalResult lowerDgemvAlpha(LaunchOp launch, ModuleOp module) { + if (launch.getNumOperands() != 4) + return launch.emitError( + "cublasDgemv_alpha: expected 4 operands (A, x, y, α)"); + Value A = launch.getOperand(0); + Value x = launch.getOperand(1); + Value y = launch.getOperand(2); + Value alpha = launch.getOperand(3); + auto At = dyn_cast(A.getType()); + if (!At || At.getRank() != 2 || !At.getElementType().isF64()) + return launch.emitError("cublasDgemv_alpha: A must be 2D f64"); + if (!alpha.getType().isF64()) + return launch.emitError("cublasDgemv_alpha: α must be f64"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value one = b.create(loc, b.getF64Type(), + b.getF64FloatAttr(1.0)); + Value A_mr = tensorToMemref(b, loc, A); + Value x_mr = tensorToMemref(b, loc, x); + Value y_mr = tensorToMemref(b, loc, y); + Value M = memrefDimAsI32(b, loc, A_mr, 0); + Value N = memrefDimAsI32(b, loc, A_mr, 1); + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value x_ptr = memrefBasePtr(b, loc, x_mr); + Value y_ptr = memrefBasePtr(b, loc, y_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + // Use the same dgemv shim but with α from launch and β=1 (accumulate). + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), b.getF64Type(), + ptrTy, b.getI32Type(), ptrTy, b.getF64Type(), ptrTy, + }; + func::FuncOp shim = ensureShimDecl(module, "polygeist_cublas_dgemv", + argTypes, b); + b.create(loc, shim, + ValueRange{M, N, alpha, A_ptr, N, x_ptr, one, y_ptr}); + Value out = memrefToTensor(b, loc, y_mr, launch.getResult(0).getType()); + launch.getResult(0).replaceAllUsesWith(out); + launch.erase(); + return success(); +} + +// @cublasDger_rank2(%u1, %v1, %u2, %v2, %A) → tensor +// Rank-2 update: A = A + u1·v1ᵀ + u2·v2ᵀ. +static LogicalResult lowerDgerRank2(LaunchOp launch, ModuleOp module) { + if (launch.getNumOperands() != 5) + return launch.emitError( + "cublasDger_rank2: expected 5 operands (u1, v1, u2, v2, A)"); + Value A = launch.getOperand(4); + auto At = dyn_cast(A.getType()); + if (!At || At.getRank() != 2 || !At.getElementType().isF64()) + return launch.emitError("cublasDger_rank2: A must be 2D f64"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value A_mr = tensorToMemref(b, loc, A); + SmallVector vec_mrs; + for (unsigned i = 0; i < 4; ++i) + vec_mrs.push_back(tensorToMemref(b, loc, launch.getOperand(i))); + Value M = memrefDimAsI32(b, loc, A_mr, 0); + Value N = memrefDimAsI32(b, loc, A_mr, 1); + Value A_ptr = memrefBasePtr(b, loc, A_mr); + SmallVector vec_ptrs; + for (Value v : vec_mrs) vec_ptrs.push_back(memrefBasePtr(b, loc, v)); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + // (M, N, u1, v1, u2, v2, A, lda) + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), + ptrTy, ptrTy, ptrTy, ptrTy, ptrTy, b.getI32Type(), + }; + func::FuncOp shim = ensureShimDecl(module, "polygeist_cublas_dger_rank2", + argTypes, b); + b.create(loc, shim, + ValueRange{M, N, + vec_ptrs[0], vec_ptrs[1], vec_ptrs[2], vec_ptrs[3], + A_ptr, N}); + Value out = memrefToTensor(b, loc, A_mr, launch.getResult(0).getType()); + launch.getResult(0).replaceAllUsesWith(out); + launch.erase(); + return success(); +} + +// @cublasDgemm_outer_product(%u, %v, %C) -> tensor +// Computes C = u*v^T. The runtime deliberately overwrites C, rather than +// exposing BLAS GER's accumulator semantics, so a preceding zero-fill stage +// can be removed as part of the matched composition. +static LogicalResult lowerDgemmOuterProduct(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 3 || launch.getNumResults() != 1) + return launch.emitError( + "cublasDgemm_outer_product: expected u/v/C and one result"); + Value u = launch.getOperand(0); + Value v = launch.getOperand(1); + Value C = launch.getOperand(2); + auto ut = dyn_cast(u.getType()); + auto vt = dyn_cast(v.getType()); + auto Ct = dyn_cast(C.getType()); + if (!ut || !vt || !Ct || ut.getRank() != 1 || vt.getRank() != 1 || + Ct.getRank() != 2 || !ut.getElementType().isF64() || + !vt.getElementType().isF64() || !Ct.getElementType().isF64()) + return launch.emitError( + "cublasDgemm_outer_product: expected rank-1/rank-1/rank-2 f64 " + "tensors"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value M = dimForTensorOrMemrefAsI32(b, loc, C, 0); + Value N = dimForTensorOrMemrefAsI32(b, loc, C, 1); + Value u_mr = valueToMemrefPreservingSlice(b, loc, u); + Value v_mr = valueToMemrefPreservingSlice(b, loc, v); + Value C_mr = valueToOutputMemrefPreservingSlice(b, loc, C); + Value u_ptr = memrefBasePtr(b, loc, u_mr); + Value v_ptr = memrefBasePtr(b, loc, v_mr); + Value C_ptr = memrefBasePtr(b, loc, C_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), b.getI32Type(), ptrTy, + ptrTy, ptrTy}; + func::FuncOp shim = ensureShimDecl( + module, "polygeist_cublas_dgemm_outer_product", argTypes, b); + b.create(loc, shim, + ValueRange{M, N, u_ptr, v_ptr, C_ptr}); + + Value out = memrefToTensor(b, loc, C_mr, launch.getResult(0).getType()); + rewireTensorSliceLaunchResult( + launch, out, tensorForOutputSliceSource(b, loc, C)); + launch.erase(); + return success(); +} + +// @memset_zero_1D(%v : tensor) -> tensor +// @memset_zero_1D_f32(%v : tensor) -> tensor +static LogicalResult lowerMemsetZero1D(LaunchOp launch, ModuleOp module, + StringRef variant) { + if (launch.getNumOperands() != 1) + return launch.emitError(variant) << ": expected 1 operand"; + Value V = launch.getOperand(0); + auto Vt = dyn_cast(V.getType()); + bool isF32Variant = variant == "memset_zero_1D_f32"; + if (!Vt || Vt.getRank() != 1 || + (isF32Variant ? !Vt.getElementType().isF32() + : !Vt.getElementType().isF64())) + return launch.emitError(variant) + << ": V must be a 1D " + << (isF32Variant ? "f32" : "f64") << " tensor"; + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value len = dimForTensorOrMemrefAsI32(b, loc, V, 0); + Value V_ptr = pointerForTensorOrMemref(b, loc, V); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), ptrTy}; + StringRef shimName = isF32Variant ? "polygeist_cublas_memset_zero_1d_f32" + : "polygeist_cublas_memset_zero_1d"; + func::FuncOp shim = ensureShimDecl(module, shimName, argTypes, b); + b.create(loc, shim, ValueRange{len, V_ptr}); + + Value V_mr = valueToMemrefPreservingSlice(b, loc, V); + Value updatedView = + memrefToTensor(b, loc, V_mr, launch.getResult(0).getType()); + Value updatedBase = tensorForSliceSource(b, loc, V); + rewireTensorSliceLaunchResult(launch, updatedView, updatedBase); + launch.erase(); + return success(); +} + +// @memset_zero_2D(%M : tensor) -> tensor +// Dtype-agnostic: zero is the same bit pattern at any width, so we +// dispatch to a single host-side memset that takes a byte count. +static LogicalResult lowerMemsetZero2D(LaunchOp launch, ModuleOp module) { + if (launch.getNumOperands() != 1) + return launch.emitError("memset_zero_2D: expected 1 operand"); + Value M = launch.getOperand(0); + auto Mt = dyn_cast(M.getType()); + if (!Mt || Mt.getRank() != 2 || + !(Mt.getElementType().isF32() || Mt.getElementType().isF64())) + return launch.emitError( + "memset_zero_2D: M must be 2D f32 or f64 tensor"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value M_mr = tensorToMemref(b, loc, M); + Value rows = memrefDimAsI32(b, loc, M_mr, 0); + Value cols = memrefDimAsI32(b, loc, M_mr, 1); + Value M_ptr = memrefBasePtr(b, loc, M_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), b.getI32Type(), ptrTy, + b.getI32Type()}; + // Pick the dtype-suffixed memset shim. The cuBLAS memset is just + // a host-side `memset(ptr, 0, M*N*sizeof(elem))` — but it has to + // know which sizeof to use, so we emit a different symbol per dtype. + StringRef memsetSym = Mt.getElementType().isF64() + ? "polygeist_cublas_memset_zero_2d" + : "polygeist_cublas_memset_zero_2d_f32"; + func::FuncOp shim = ensureShimDecl(module, memsetSym, argTypes, b); + b.create(loc, shim, ValueRange{rows, cols, M_ptr, cols}); + + Value out = memrefToTensor(b, loc, M_mr, launch.getResult(0).getType()); + launch.getResult(0).replaceAllUsesWith(out); + launch.erase(); + return success(); +} + +// @cudnnConvolutionFwd_batched(%input_view, %filter, %output_view) +// +// The matcher fires this two-step composition (init-to-zero + the +// 7-iter par×4+red×3 contraction) when the IR matches a batched +// multi-channel 2D conv (NCHW). The launch operands are: +// - input_view: 7D `polygeist.submap` view of the underlying +// `tensor` (the strided window — implicit im2col). +// - filter: plain `tensor` (no submap). +// - output_view: 4D submap view of the underlying `tensor`. +// +// Lowers to: +// polygeist_cudnn_conv2d_batched(B, IC, OC, H, W, K, A*, F*, Out*) +// +// where the shape ints are recovered from the base 4D shapes (the +// output 4D submap has the same shape as the underlying Bout tensor). +static LogicalResult lowerCudnnConv2dBatched(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 3) + return launch.emitError("cudnnConvolutionFwd_batched: expected 3 " + "operands (input_view, filter, output_view); got ") + << launch.getNumOperands(); + if (launch.getNumResults() != 1) + return launch.emitError("cudnnConvolutionFwd_batched: expected 1 result"); + + Value inputView = launch.getOperand(0); + Value filterView = launch.getOperand(1); + Value outputView = launch.getOperand(2); + + // linalg-debufferize wraps every tensor operand of the contraction + // generic in a polygeist.submap — even the filter (conceptually a + // plain 4D tensor). Resolve all three back to their underlying base. + Value inputBase = resolveSubmapBase(inputView); + Value filterBase = resolveSubmapBase(filterView); + Value outputBase = resolveSubmapBase(outputView); + + auto inT = dyn_cast(inputBase.getType()); + auto fT = dyn_cast(filterBase.getType()); + auto oT = dyn_cast(outputBase.getType()); + if (!inT || !fT || !oT || inT.getRank() != 4 || fT.getRank() != 4 || + oT.getRank() != 4) + return launch.emitError( + "cudnnConvolutionFwd_batched: input/filter/output must each be " + "4D after resolving submap (NCHW)"); + Type elemTy = inT.getElementType(); + if (!elemTy.isF32() || fT.getElementType() != elemTy || + oT.getElementType() != elemTy) + return launch.emitError( + "cudnnConvolutionFwd_batched: only f32 supported for now; got ") + << elemTy; + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value A_mr = tensorToMemref(b, loc, inputBase); + Value F_mr = tensorToMemref(b, loc, filterBase); + Value O_mr = valueToOutputMemrefPreservingSlice(b, loc, outputBase); + + // Shape recovery: B = dim(in, 0), IC = dim(in, 1) = dim(filter, 1), + // OC = dim(filter, 0), H = dim(in, 2), W = dim(in, 3), + // K = dim(filter, 2) (assume square 3D filter K==dim(filter,3)). + Value B = memrefDimAsI32(b, loc, A_mr, 0); + Value IC = memrefDimAsI32(b, loc, A_mr, 1); + Value OC = memrefDimAsI32(b, loc, F_mr, 0); + Value H = memrefDimAsI32(b, loc, A_mr, 2); + Value W = memrefDimAsI32(b, loc, A_mr, 3); + Value K = memrefDimAsI32(b, loc, F_mr, 2); + + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value F_ptr = memrefBasePtr(b, loc, F_mr); + Value O_ptr = memrefBasePtr(b, loc, O_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), b.getI32Type(), + b.getI32Type(), b.getI32Type(), b.getI32Type(), + ptrTy, ptrTy, ptrTy, + }; + func::FuncOp shim = ensureShimDecl(module, "polygeist_cudnn_conv2d_batched", + argTypes, b); + b.create(loc, shim, + ValueRange{B, IC, OC, H, W, K, A_ptr, F_ptr, O_ptr}); + + Value updated = memrefToTensor(b, loc, O_mr, outputBase.getType()); + rewireTensorSliceLaunchResult( + launch, updated, tensorForOutputSliceSource(b, loc, outputBase)); + launch.erase(); + return success(); +} + +// @cudnnConvolutionFwd_im2col_gemm(%input, %weights_view, %output, +// channels, height, width, out_channels, +// ksize, stride, pad) +// +// This is the explicit Darknet im2col + GEMM composition: +// zero(output); workspace = im2col(input); output += weights * workspace +// The matcher has already proven the guarded im2col body and GEMM body are +// adjacent. Lower the whole composition to one cuDNN convolution call, avoiding +// materialization of the workspace. +static LogicalResult lowerCudnnConv2dIm2colGemm(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 10) + return launch.emitError("cudnnConvolutionFwd_im2col_gemm: expected 10 " + "operands (input, weights, output, 7 shape ints); got ") + << launch.getNumOperands(); + if (launch.getNumResults() != 0) + return launch.emitError( + "cudnnConvolutionFwd_im2col_gemm: expected no results"); + + Value input = launch.getOperand(0); + Value weightsView = launch.getOperand(1); + Value output = launch.getOperand(2); + + auto inputTy = dyn_cast(input.getType()); + auto weightsTy = dyn_cast(weightsView.getType()); + auto outputTy = dyn_cast(output.getType()); + if (!inputTy || !weightsTy || !outputTy || inputTy.getRank() != 1 || + weightsTy.getRank() != 3 || outputTy.getRank() != 1 || + !inputTy.getElementType().isF32() || + !weightsTy.getElementType().isF32() || + !outputTy.getElementType().isF32()) + return launch.emitError( + "cudnnConvolutionFwd_im2col_gemm: expected f32 input/output flat " + "memrefs and a rank-3 f32 weights submap"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value IC = valueAsI32(b, loc, launch.getOperand(3)); + Value H = valueAsI32(b, loc, launch.getOperand(4)); + Value W = valueAsI32(b, loc, launch.getOperand(5)); + Value OC = valueAsI32(b, loc, launch.getOperand(6)); + Value K = valueAsI32(b, loc, launch.getOperand(7)); + Value S = valueAsI32(b, loc, launch.getOperand(8)); + Value P = valueAsI32(b, loc, launch.getOperand(9)); + + Value weightsBase = resolveSubmapBase(weightsView); + Value A_ptr = memrefBasePtr(b, loc, input); + Value F_ptr = memrefBasePtr(b, loc, weightsBase); + Value O_ptr = memrefBasePtr(b, loc, output); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), b.getI32Type(), b.getI32Type(), + b.getI32Type(), b.getI32Type(), b.getI32Type(), + ptrTy, ptrTy, ptrTy, + }; + func::FuncOp shim = ensureShimDecl( + module, "polygeist_cudnn_conv2d_im2col_gemm_f32", argTypes, b); + b.create( + loc, shim, ValueRange{IC, H, W, OC, K, S, P, A_ptr, F_ptr, O_ptr}); + + launch.erase(); + return success(); +} + +// @cudnnMaxPoolFwd_batched(%input_view, %output_view) +// Inputs: input (6D submap of 4D base), output (4D submap of 4D base). +// Lowers to polygeist_cudnn_maxpool_batched(B, C, H, W, K, S, A*, Out*). +// +// The window size K and stride S are encoded in the submap's affine map +// constants (we hard-code 2 + S from typical maxpool, but recover them +// at runtime from the base / output dim ratio: K = ((H - (OH-1)*S) → we +// pass the *output* dims separately and let the shim's pooling descriptor +// derive K = H - (OH-1)*S, treating stride and window as equal to +// (H/OH) — works for typical 2x2 stride-2 maxpool). +// +// To keep the shim simple, we *also* pass K + S as ints. Recovering them +// from the submap's affine map would need C++ introspection of an +// AffineMap; instead, the harness passes the matched window/stride in +// via the wrapper. For the polybench-style extracted kernels here we +// know K, S at compile time (MINI: K=S=2). We embed those as compile- +// time constants in the kernel C source and read them at runtime via +// the harness — see the maxpool_batched.c harness for the convention. +// +// Simpler approach: just pass H, W, OH, OW. The shim derives +// S = (H - K) / (OH - 1) once K is fixed; or for the common stride==K +// case, S = H / OH and K = S. +// Since both extracted shapes (MINI: K=S=2; LARGE: K=3, S=2) have known +// values, we pass them as separate ints from the harness via the +// wrapper, NOT from MLIR (the matcher doesn't preserve them). +// +// The MLIR-level call therefore passes B, C, H, W (from base/output +// dims) and the runtime shim looks up K, S from per-call thread-locals +// set by the wrapper. This is documented in polygeist_cublas_rt.h. +static LogicalResult lowerCudnnMaxpoolBatched(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 2) + return launch.emitError("cudnnMaxPoolFwd_batched: expected 2 operands " + "(input_view, output_view); got ") + << launch.getNumOperands(); + if (launch.getNumResults() != 1) + return launch.emitError("cudnnMaxPoolFwd_batched: expected 1 result"); + + Value inView = launch.getOperand(0); + Value outView = launch.getOperand(1); + Value inBase = resolveSubmapBase(inView); + Value outBase = resolveSubmapBase(outView); + + auto inT = dyn_cast(inBase.getType()); + auto outT = dyn_cast(outBase.getType()); + if (!inT || !outT || inT.getRank() != 4 || outT.getRank() != 4) + return launch.emitError("cudnnMaxPoolFwd_batched: both operands must " + "be 4D after resolving submap"); + Type elemTy = inT.getElementType(); + if (!elemTy.isF32() || outT.getElementType() != elemTy) + return launch.emitError("cudnnMaxPoolFwd_batched: only f32 supported"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value A_mr = tensorToMemref(b, loc, inBase); + Value O_mr = valueToOutputMemrefPreservingSlice(b, loc, outBase); + Value B = memrefDimAsI32(b, loc, A_mr, 0); + Value C = memrefDimAsI32(b, loc, A_mr, 1); + Value H = memrefDimAsI32(b, loc, A_mr, 2); + Value W = memrefDimAsI32(b, loc, A_mr, 3); + Value OH = memrefDimAsI32(b, loc, O_mr, 2); + Value OW = memrefDimAsI32(b, loc, O_mr, 3); + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value O_ptr = memrefBasePtr(b, loc, O_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), b.getI32Type(), b.getI32Type(), + b.getI32Type(), b.getI32Type(), ptrTy, ptrTy, + }; + func::FuncOp shim = ensureShimDecl(module, "polygeist_cudnn_maxpool_batched", + argTypes, b); + b.create(loc, shim, + ValueRange{B, C, H, W, OH, OW, A_ptr, O_ptr}); + + Value updated = memrefToTensor(b, loc, O_mr, outBase.getType()); + rewireTensorSliceLaunchResult( + launch, updated, tensorForOutputSliceSource(b, loc, outBase)); + launch.erase(); + return success(); +} + +// @cudnnBatchNormalizationForwardInference( +// %A_view, %scale_view, %mean_view, %inv_std_view, %bias_view, +// %output_view) +// +// All 6 operands are submap views. The raise pass orders them +// (A, scale, mean, inv_std, bias) — see the matcher template +// (_cudnn_batchnorm_inference) for the order. After walking through +// submaps: +// - scale, mean, inv_std, bias are 1D tensors (per-channel) +// - A and output are 4D tensors (NCHW) +// +// Lowers to: +// polygeist_cudnn_batchnorm_inference(B, C, H, W, +// A*, scale*, mean*, inv_std*, bias*, +// Out*) +static LogicalResult lowerCudnnBatchnormInference(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 6) + return launch.emitError( + "cudnnBatchNormalizationForwardInference: expected 6 operands; got ") + << launch.getNumOperands(); + if (launch.getNumResults() != 1) + return launch.emitError( + "cudnnBatchNormalizationForwardInference: expected 1 result"); + + Value aBase = resolveSubmapBase(launch.getOperand(0)); + Value scaleBase = resolveSubmapBase(launch.getOperand(1)); + Value meanBase = resolveSubmapBase(launch.getOperand(2)); + Value invStdBase = resolveSubmapBase(launch.getOperand(3)); + Value biasBase = resolveSubmapBase(launch.getOperand(4)); + Value outBase = resolveSubmapBase(launch.getOperand(5)); + + auto aT = dyn_cast(aBase.getType()); + auto oT = dyn_cast(outBase.getType()); + if (!aT || !oT || aT.getRank() != 4 || oT.getRank() != 4) + return launch.emitError( + "batchnorm: A and Out must be 4D after resolving submap"); + Type elemTy = aT.getElementType(); + if (!elemTy.isF32() || oT.getElementType() != elemTy) + return launch.emitError("batchnorm: only f32 supported"); + for (Value v : {scaleBase, meanBase, invStdBase, biasBase}) { + auto t = dyn_cast(v.getType()); + if (!t || t.getRank() != 1 || t.getElementType() != elemTy) + return launch.emitError( + "batchnorm: scale/mean/inv_std/bias must be 1D f32 per-channel " + "after resolving submap"); + } + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value A_mr = tensorToMemref(b, loc, aBase); + Value S_mr = tensorToMemref(b, loc, scaleBase); + Value M_mr = tensorToMemref(b, loc, meanBase); + Value I_mr = tensorToMemref(b, loc, invStdBase); + Value Bi_mr = tensorToMemref(b, loc, biasBase); + Value O_mr = valueToOutputMemrefPreservingSlice(b, loc, outBase); + + Value B = memrefDimAsI32(b, loc, A_mr, 0); + Value C = memrefDimAsI32(b, loc, A_mr, 1); + Value H = memrefDimAsI32(b, loc, A_mr, 2); + Value W = memrefDimAsI32(b, loc, A_mr, 3); + + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value S_ptr = memrefBasePtr(b, loc, S_mr); + Value M_ptr = memrefBasePtr(b, loc, M_mr); + Value I_ptr = memrefBasePtr(b, loc, I_mr); + Value Bi_ptr = memrefBasePtr(b, loc, Bi_mr); + Value O_ptr = memrefBasePtr(b, loc, O_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), b.getI32Type(), b.getI32Type(), + ptrTy, ptrTy, ptrTy, ptrTy, ptrTy, ptrTy, + }; + func::FuncOp shim = ensureShimDecl(module, + "polygeist_cudnn_batchnorm_inference", argTypes, b); + b.create(loc, shim, + ValueRange{B, C, H, W, A_ptr, S_ptr, M_ptr, I_ptr, Bi_ptr, O_ptr}); + + Value updated = memrefToTensor(b, loc, O_mr, outBase.getType()); + rewireTensorSliceLaunchResult( + launch, updated, tensorForOutputSliceSource(b, loc, outBase)); + launch.erase(); + return success(); +} + +// @cudnnAddTensor_batched(%input_view, %output_view) +// out[b,c,h,w] += in[b,c,h,w] — ResNet residual add. +// Lowers to polygeist_cudnn_add_tensor_batched(B, C, H, W, A*, Out*). +static LogicalResult lowerCudnnAddTensorBatched(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 2) + return launch.emitError("cudnnAddTensor_batched: expected 2 operands"); + if (launch.getNumResults() != 1) + return launch.emitError("cudnnAddTensor_batched: expected 1 result"); + + Value inBase = resolveSubmapBase(launch.getOperand(0)); + Value outBase = resolveSubmapBase(launch.getOperand(1)); + auto inT = dyn_cast(inBase.getType()); + auto outT = dyn_cast(outBase.getType()); + if (!inT || !outT || inT.getRank() != 4 || outT.getRank() != 4) + return launch.emitError( + "cudnnAddTensor_batched: both operands must be 4D after submap"); + Type elemTy = inT.getElementType(); + if (!elemTy.isF32() || outT.getElementType() != elemTy) + return launch.emitError("cudnnAddTensor_batched: only f32 supported"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value A_mr = tensorToMemref(b, loc, inBase); + Value O_mr = tensorToMemref(b, loc, outBase); + Value B = memrefDimAsI32(b, loc, A_mr, 0); + Value C = memrefDimAsI32(b, loc, A_mr, 1); + Value H = memrefDimAsI32(b, loc, A_mr, 2); + Value W = memrefDimAsI32(b, loc, A_mr, 3); + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value O_ptr = memrefBasePtr(b, loc, O_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), b.getI32Type(), b.getI32Type(), + ptrTy, ptrTy, + }; + func::FuncOp shim = ensureShimDecl(module, + "polygeist_cudnn_add_tensor_batched", argTypes, b); + b.create(loc, shim, ValueRange{B, C, H, W, A_ptr, O_ptr}); + + Value updated = memrefToTensor(b, loc, O_mr, outBase.getType()); + rewireTensorSliceLaunchResult( + launch, updated, tensorForOutputSliceSource(b, loc, outBase)); + launch.erase(); + return success(); +} + +// @cudnnConvBnReluFwdFused(%input_view, %filter_view, %scale_view, %mean_view, +// %inv_std_view, %bias_view, %output_view) +// +// 7 operands. The matcher emits this for the canonical ResNet inner +// pattern conv + bn-inference + relu. After resolving submaps: +// - input (4D NCHW): from the conv's input submap +// - filter (4D OCxICxKxK): from the conv's filter submap +// - scale, mean, inv_std, bias (1D length OC): the BN per-channel vectors +// - output (4D NCHW): the in-place destination +// +// Lowers to one call: +// polygeist_cudnn_conv_bn_relu_fused( +// B, IC, OC, H, W, K, A*, F*, scale*, mean*, inv_std*, bias*, Out*) +// +// The runtime shim folds the BN params into a scaled filter + bias and +// uses cudnnConvolutionBiasActivationForward (which natively does +// conv+bias+activation in one call) with CUDNN_ACTIVATION_RELU. +static LogicalResult lowerCudnnConvBnReluFused(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 7) + return launch.emitError("cudnnConvBnReluFwdFused: expected 7 operands, got ") + << launch.getNumOperands(); + if (launch.getNumResults() != 1) + return launch.emitError("cudnnConvBnReluFwdFused: expected 1 result"); + + Value inputBase = resolveSubmapBase(launch.getOperand(0)); + Value filterBase = resolveSubmapBase(launch.getOperand(1)); + Value scaleBase = resolveSubmapBase(launch.getOperand(2)); + Value meanBase = resolveSubmapBase(launch.getOperand(3)); + Value invStdBase = resolveSubmapBase(launch.getOperand(4)); + Value biasBase = resolveSubmapBase(launch.getOperand(5)); + Value outBase = resolveSubmapBase(launch.getOperand(6)); + + auto inT = dyn_cast(inputBase.getType()); + auto fT = dyn_cast(filterBase.getType()); + auto outT = dyn_cast(outBase.getType()); + if (!inT || !fT || !outT || + inT.getRank() != 4 || fT.getRank() != 4 || outT.getRank() != 4) + return launch.emitError( + "cudnnConvBnReluFwdFused: input/filter/output must each be 4D " + "after resolving submap"); + Type elemTy = inT.getElementType(); + if (!elemTy.isF32() || fT.getElementType() != elemTy || + outT.getElementType() != elemTy) + return launch.emitError("cudnnConvBnReluFwdFused: only f32 supported"); + for (Value v : {scaleBase, meanBase, invStdBase, biasBase}) { + auto t = dyn_cast(v.getType()); + if (!t || t.getRank() != 1 || t.getElementType() != elemTy) + return launch.emitError( + "cudnnConvBnReluFwdFused: scale/mean/inv_std/bias must be 1D f32"); + } + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value A_mr = tensorToMemref(b, loc, inputBase); + Value F_mr = tensorToMemref(b, loc, filterBase); + Value S_mr = tensorToMemref(b, loc, scaleBase); + Value M_mr = tensorToMemref(b, loc, meanBase); + Value I_mr = tensorToMemref(b, loc, invStdBase); + Value Bi_mr = tensorToMemref(b, loc, biasBase); + Value O_mr = tensorToMemref(b, loc, outBase); + + Value B = memrefDimAsI32(b, loc, A_mr, 0); + Value IC = memrefDimAsI32(b, loc, A_mr, 1); + Value OC = memrefDimAsI32(b, loc, F_mr, 0); + Value H = memrefDimAsI32(b, loc, A_mr, 2); + Value W = memrefDimAsI32(b, loc, A_mr, 3); + Value K = memrefDimAsI32(b, loc, F_mr, 2); + + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value F_ptr = memrefBasePtr(b, loc, F_mr); + Value S_ptr = memrefBasePtr(b, loc, S_mr); + Value M_ptr = memrefBasePtr(b, loc, M_mr); + Value I_ptr = memrefBasePtr(b, loc, I_mr); + Value Bi_ptr = memrefBasePtr(b, loc, Bi_mr); + Value O_ptr = memrefBasePtr(b, loc, O_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), b.getI32Type(), // B, IC, OC + b.getI32Type(), b.getI32Type(), b.getI32Type(), // H, W, K + ptrTy, ptrTy, ptrTy, ptrTy, ptrTy, ptrTy, ptrTy, // A, F, scale, mean, inv_std, bias, Out + }; + func::FuncOp shim = ensureShimDecl(module, + "polygeist_cudnn_conv_bn_relu_fused", argTypes, b); + b.create(loc, shim, + ValueRange{B, IC, OC, H, W, K, + A_ptr, F_ptr, S_ptr, M_ptr, I_ptr, Bi_ptr, O_ptr}); + + Value updated = memrefToTensor(b, loc, O_mr, outBase.getType()); + rewireLaunchResult(launch, updated); + launch.erase(); + return success(); +} + +// @cudnnConvBiasReluAddFwdFused(%input, %filter, %op0, %op1, %output) +// +// Five linalg.generic ops folded into one launch by the matcher. The +// last two pre-relu ins (steps 2 + 3, both `Out + In(0)` body shape) +// are NOT distinguishable at the matcher level — both are +// "Out + In". The lowering disambiguates by operand rank after +// resolving submap: +// • 1D operand → bias (per-output-channel, broadcast) +// • 4D operand → residual (same shape as output, the Z addend) +// +// Routes to: +// polygeist_cudnn_conv_bias_relu_add_fused(B, IC, OC, H, W, K, +// A*, F*, bias*, Z*, Out*) +// +// The shim then issues one cudnnConvolutionBiasActivationForward with +// α₁=1, α₂=1 and CUDNN_ACTIVATION_RELU. +static LogicalResult lowerCudnnConvBiasReluAdd(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 5) + return launch.emitError( + "cudnnConvBiasReluAddFwdFused: expected 5 operands, got ") + << launch.getNumOperands(); + if (launch.getNumResults() != 1) + return launch.emitError( + "cudnnConvBiasReluAddFwdFused: expected 1 result"); + + Value inputBase = resolveSubmapBase(launch.getOperand(0)); + Value filterBase = resolveSubmapBase(launch.getOperand(1)); + Value addOp0 = resolveSubmapBase(launch.getOperand(2)); + Value addOp1 = resolveSubmapBase(launch.getOperand(3)); + Value outBase = resolveSubmapBase(launch.getOperand(4)); + + // Disambiguate bias vs residual by rank of the underlying base. + auto rankOf = [](Value v) -> int { + if (auto t = dyn_cast(v.getType())) + return t.getRank(); + return -1; + }; + Value biasBase, residualBase; + if (rankOf(addOp0) == 1 && rankOf(addOp1) == 4) { + biasBase = addOp0; residualBase = addOp1; + } else if (rankOf(addOp0) == 4 && rankOf(addOp1) == 1) { + biasBase = addOp1; residualBase = addOp0; + } else { + return launch.emitError( + "cudnnConvBiasReluAddFwdFused: addend operands must be one 1D " + "(bias) and one 4D (residual), got ranks ") + << rankOf(addOp0) << " and " << rankOf(addOp1); + } + + auto inT = dyn_cast(inputBase.getType()); + auto fT = dyn_cast(filterBase.getType()); + auto outT = dyn_cast(outBase.getType()); + auto bT = dyn_cast(biasBase.getType()); + auto rT = dyn_cast(residualBase.getType()); + if (!inT || !fT || !outT || !bT || !rT) + return launch.emitError("cudnnConvBiasReluAddFwdFused: non-tensor operand"); + Type elemTy = inT.getElementType(); + if (!elemTy.isF32() || fT.getElementType() != elemTy || + outT.getElementType() != elemTy || bT.getElementType() != elemTy || + rT.getElementType() != elemTy) + return launch.emitError("cudnnConvBiasReluAddFwdFused: only f32 supported"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value A_mr = tensorToMemref(b, loc, inputBase); + Value F_mr = tensorToMemref(b, loc, filterBase); + Value Bi_mr = tensorToMemref(b, loc, biasBase); + Value Z_mr = tensorToMemref(b, loc, residualBase); + Value O_mr = tensorToMemref(b, loc, outBase); + + Value B = memrefDimAsI32(b, loc, A_mr, 0); + Value IC = memrefDimAsI32(b, loc, A_mr, 1); + Value OC = memrefDimAsI32(b, loc, F_mr, 0); + Value H = memrefDimAsI32(b, loc, A_mr, 2); + Value W = memrefDimAsI32(b, loc, A_mr, 3); + Value K = memrefDimAsI32(b, loc, F_mr, 2); + + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value F_ptr = memrefBasePtr(b, loc, F_mr); + Value Bi_ptr = memrefBasePtr(b, loc, Bi_mr); + Value Z_ptr = memrefBasePtr(b, loc, Z_mr); + Value O_ptr = memrefBasePtr(b, loc, O_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), b.getI32Type(), + b.getI32Type(), b.getI32Type(), b.getI32Type(), + ptrTy, ptrTy, ptrTy, ptrTy, ptrTy, + }; + func::FuncOp shim = ensureShimDecl(module, + "polygeist_cudnn_conv_bias_relu_add_fused", argTypes, b); + b.create(loc, shim, + ValueRange{B, IC, OC, H, W, K, + A_ptr, F_ptr, Bi_ptr, Z_ptr, O_ptr}); + + Value updated = memrefToTensor(b, loc, O_mr, outBase.getType()); + rewireLaunchResult(launch, updated); + launch.erase(); + return success(); +} + +// @rmsnorm(%x, %weight, %out), FP32 1D memref/tensor operands. +// Runtime computes: +// out[i] = weight[i] * x[i] * rsqrt(sum_j x[j]^2 / N + 1e-5) +static LogicalResult lowerRmsnormF32(LaunchOp launch, ModuleOp module) { + if (launch.getNumOperands() != 3) + return launch.emitError("rmsnorm: expected 3 operands (x, weight, out)"); + if (launch.getNumResults() > 1) + return launch.emitError("rmsnorm: expected zero or one result"); + + Value x = resolveSubmapBase(launch.getOperand(0)); + Value weight = resolveSubmapBase(launch.getOperand(1)); + Value out = resolveSubmapBase(launch.getOperand(2)); + + ShapedType xTy = getRankedShapedType(x); + ShapedType wTy = getRankedShapedType(weight); + ShapedType oTy = getRankedShapedType(out); + if (!xTy || !wTy || !oTy || xTy.getRank() != 1 || wTy.getRank() != 1 || + oTy.getRank() != 1) + return launch.emitError("rmsnorm: x/weight/out must be ranked 1D"); + if (!xTy.getElementType().isF32() || + wTy.getElementType() != xTy.getElementType() || + oTy.getElementType() != xTy.getElementType()) + return launch.emitError("rmsnorm: only f32 x/weight/out supported"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value xMr = valueToMemref(b, loc, x); + Value wMr = valueToMemref(b, loc, weight); + Value oMr = valueToOutputMemrefPreservingSlice(b, loc, out); + + Value N = memrefDimAsI32(b, loc, xMr, 0); + Value xPtr = memrefBasePtr(b, loc, xMr); + Value wPtr = memrefBasePtr(b, loc, wMr); + Value oPtr = memrefBasePtr(b, loc, oMr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), ptrTy, ptrTy, ptrTy}; + func::FuncOp shim = + ensureShimDecl(module, "polygeist_rmsnorm_f32", argTypes, b); + b.create(loc, shim, ValueRange{N, xPtr, wPtr, oPtr}); + + if (launch.getNumResults() == 1) { + Value updated = memrefToTensor(b, loc, oMr, launch.getResult(0).getType()); + rewireTensorSliceLaunchResult( + launch, updated, tensorForOutputSliceSource(b, loc, out)); + } + + launch.erase(); + return success(); +} + +// @rmsnorm_unweighted_f32_tensor(%x, %out), FP32 1D tensor operands. +// Runtime computes: +// out[i] = x[i] * rsqrt(sum_j x[j]^2 / N + 1e-5) +static LogicalResult lowerRmsnormUnweightedF32(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 2) + return launch.emitError( + "rmsnorm_unweighted: expected 2 operands (x, out)"); + if (launch.getNumResults() != 1) + return launch.emitError("rmsnorm_unweighted: expected one result"); + + Value x = resolveSubmapBase(launch.getOperand(0)); + Value out = resolveSubmapBase(launch.getOperand(1)); + + ShapedType xTy = getRankedShapedType(x); + ShapedType oTy = getRankedShapedType(out); + if (!xTy || !oTy || xTy.getRank() != 1 || oTy.getRank() != 1) + return launch.emitError("rmsnorm_unweighted: x/out must be ranked 1D"); + if (!xTy.getElementType().isF32() || + oTy.getElementType() != xTy.getElementType()) + return launch.emitError("rmsnorm_unweighted: only f32 supported"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value xMr = valueToMemrefPreservingSlice(b, loc, x); + Value oMr = valueToOutputMemrefPreservingSlice(b, loc, out); + Value N = memrefDimAsI32(b, loc, xMr, 0); + Value xPtr = memrefBasePtr(b, loc, xMr); + Value oPtr = memrefBasePtr(b, loc, oMr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), ptrTy, ptrTy}; + func::FuncOp shim = ensureShimDecl( + module, "polygeist_rmsnorm_unweighted_f32", argTypes, b); + b.create(loc, shim, ValueRange{N, xPtr, oPtr}); + + Value updated = memrefToTensor(b, loc, oMr, launch.getResult(0).getType()); + rewireTensorSliceLaunchResult(launch, updated, + tensorForSliceSource(b, loc, out)); + launch.erase(); + return success(); +} + +static LogicalResult lowerCublasDot(LaunchOp launch, ModuleOp module, + bool singlePrecision) { + StringRef abi = singlePrecision ? "cublasSdot" : "cublasDdot"; + if (launch.getNumOperands() != 3) + return launch.emitError() << abi << ": expected 3 operands (x, y, out)"; + if (launch.getNumResults() != 1) + return launch.emitError() << abi << ": expected one result"; + + Value x = resolveSubmapBase(launch.getOperand(0)); + Value y = resolveSubmapBase(launch.getOperand(1)); + Value out = resolveSubmapBase(launch.getOperand(2)); + + ShapedType xTy = getRankedShapedType(x); + ShapedType yTy = getRankedShapedType(y); + ShapedType oTy = getRankedShapedType(out); + if (!xTy || !yTy || !oTy || xTy.getRank() != 1 || yTy.getRank() != 1 || + oTy.getRank() != 0) + return launch.emitError() << abi << ": x/y must be 1D and out rank-0"; + Type expectedType; + if (singlePrecision) + expectedType = Float32Type::get(launch.getContext()); + else + expectedType = Float64Type::get(launch.getContext()); + if (xTy.getElementType() != expectedType || + yTy.getElementType() != xTy.getElementType() || + oTy.getElementType() != xTy.getElementType()) + return launch.emitError() << abi << ": operands must be " + << (singlePrecision ? "f32" : "f64"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value xMr = valueToMemrefPreservingSlice(b, loc, x); + Value yMr = valueToMemrefPreservingSlice(b, loc, y); + Value oMr; + Value strippedOut = stripTensorCasts(out); + if (auto slice = strippedOut.getDefiningOp()) { + if (auto toTensor = destinationToTensorOp(slice.getSource())) { + auto sourceType = cast(toTensor.getMemref().getType()); + auto resultType = cast( + memref::SubViewOp::inferRankReducedResultType( + slice.getType().getShape(), sourceType, + slice.getMixedOffsets(), slice.getMixedSizes(), + slice.getMixedStrides())); + oMr = b.create( + loc, resultType, toTensor.getMemref(), slice.getMixedOffsets(), + slice.getMixedSizes(), slice.getMixedStrides()); + } + } + if (!oMr) + oMr = valueToOutputMemrefPreservingSlice(b, loc, out); + Value N = memrefDimAsI32(b, loc, xMr, 0); + Value xPtr = memrefBasePtr(b, loc, xMr); + Value yPtr = memrefBasePtr(b, loc, yMr); + Value oPtr = memrefBasePtr(b, loc, oMr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), ptrTy, ptrTy, ptrTy}; + func::FuncOp shim = ensureShimDecl( + module, singlePrecision ? "polygeist_cublas_dot_f32" + : "polygeist_cublas_dot_f64", + argTypes, b); + b.create(loc, shim, ValueRange{N, xPtr, yPtr, oPtr}); + + Value updated = memrefToTensor(b, loc, oMr, launch.getResult(0).getType()); + rewireTensorSliceLaunchResult( + launch, updated, tensorForOutputSliceSource(b, loc, out)); + launch.erase(); + return success(); +} + +static LogicalResult lowerGeluTanhF32(LaunchOp launch, ModuleOp module) { + if (launch.getNumOperands() != 2) + return launch.emitError("gelu_tanh_f32: expected 2 operands (x, out)"); + if (launch.getNumResults() != 1) + return launch.emitError("gelu_tanh_f32: expected one result"); + + Value x = launch.getOperand(0); + Value out = launch.getOperand(1); + auto xTy = dyn_cast(x.getType()); + auto oTy = dyn_cast(out.getType()); + if (!xTy || !oTy || xTy.getRank() != 1 || oTy.getRank() != 1 || + !xTy.getElementType().isF32() || !oTy.getElementType().isF32()) + return launch.emitError("gelu_tanh_f32: operands must be 1D f32 tensors"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value xMr = valueToMemrefPreservingSlice(b, loc, x); + Value oMr = valueToMemrefPreservingSlice(b, loc, out); + Value N = memrefDimAsI32(b, loc, xMr, 0); + Value xPtr = memrefBasePtr(b, loc, xMr); + Value oPtr = memrefBasePtr(b, loc, oMr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), ptrTy, ptrTy}; + func::FuncOp shim = + ensureShimDecl(module, "polygeist_cuda_gelu_tanh_f32", argTypes, b); + b.create(loc, shim, ValueRange{N, xPtr, oPtr}); + + Value updated = memrefToTensor(b, loc, oMr, launch.getResult(0).getType()); + rewireTensorSliceLaunchResult(launch, updated, + tensorForSliceSource(b, loc, out)); + launch.erase(); + return success(); +} + +static LogicalResult lowerWhisperExpShiftSumF32(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 4) + return launch.emitError( + "whisperExpShiftSum: expected 4 operands (x, out, sum, max)"); + if (launch.getNumResults() != 2) + return launch.emitError("whisperExpShiftSum: expected two results"); + + Value x = launch.getOperand(0); + Value out = launch.getOperand(1); + Value sum = launch.getOperand(2); + Value maxVal = launch.getOperand(3); + + ShapedType xTy = getRankedShapedType(x); + ShapedType oTy = getRankedShapedType(out); + ShapedType sTy = getRankedShapedType(sum); + if (!xTy || !oTy || !sTy || xTy.getRank() != 1 || oTy.getRank() != 1 || + sTy.getRank() != 0) + return launch.emitError( + "whisperExpShiftSum: x/out must be 1D and sum must be rank-0"); + if (!xTy.getElementType().isF32() || + oTy.getElementType() != xTy.getElementType() || + sTy.getElementType() != xTy.getElementType() || + !maxVal.getType().isF32()) + return launch.emitError("whisperExpShiftSum: only f32 supported"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value xMr = valueToMemrefPreservingSlice(b, loc, x); + Value oMr = valueToMemrefPreservingSlice(b, loc, out); + Value sMr = valueToMemrefPreservingSlice(b, loc, sum); + Value N = memrefDimAsI32(b, loc, xMr, 0); + Value xPtr = memrefBasePtr(b, loc, xMr); + Value oPtr = memrefBasePtr(b, loc, oMr); + Value sPtr = memrefBasePtr(b, loc, sMr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), ptrTy, b.getF32Type(), ptrTy, ptrTy}; + func::FuncOp shim = ensureShimDecl( + module, "polygeist_whisper_exp_shift_sum_f32", argTypes, b); + b.create(loc, shim, + ValueRange{N, xPtr, maxVal, oPtr, sPtr}); + + Value updatedOut = memrefToTensor(b, loc, oMr, launch.getResult(0).getType()); + rewireTensorSliceLaunchResult(launch, updatedOut, + tensorForSliceSource(b, loc, out)); + Value updatedSum = memrefToTensor(b, loc, sMr, launch.getResult(1).getType()); + launch.getResult(1).replaceAllUsesWith(updatedSum); + launch.erase(); + return success(); +} + +// @cudnnSoftmaxForward(%x), FP32 1D in-place row softmax. +// Tensor form returns the updated tensor after the same in-place shim call. +static LogicalResult lowerCudnnSoftmaxForwardF32(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 1) + return launch.emitError("cudnnSoftmaxForward: expected 1 operand"); + if (launch.getNumResults() > 1) + return launch.emitError( + "cudnnSoftmaxForward: expected void or one tensor result"); + + Value x = resolveSubmapBase(launch.getOperand(0)); + ShapedType xTy = getRankedShapedType(x); + if (!xTy || xTy.getRank() != 1) + return launch.emitError("cudnnSoftmaxForward: x must be ranked 1D"); + if (!xTy.getElementType().isF32()) + return launch.emitError("cudnnSoftmaxForward: only f32 supported"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value xMr = valueToMemref(b, loc, x); + Value N = memrefDimAsI32(b, loc, xMr, 0); + Value xPtr = memrefBasePtr(b, loc, xMr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), ptrTy}; + func::FuncOp shim = ensureShimDecl( + module, "polygeist_cudnn_softmax_forward_f32", argTypes, b); + b.create(loc, shim, ValueRange{N, xPtr}); + + if (launch.getNumResults() == 1) { + Value updated = memrefToTensor(b, loc, xMr, launch.getResult(0).getType()); + rewireLaunchResult(launch, updated); + } + + launch.erase(); + return success(); +} + +static LogicalResult lowerCudnnSoftmaxForwardOutF32(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 2) + return launch.emitError( + "cudnnSoftmaxForwardOut: expected 2 operands (scores, out)"); + if (launch.getNumResults() != 1) + return launch.emitError("cudnnSoftmaxForwardOut: expected one result"); + + Value scores = launch.getOperand(0); + Value out = launch.getOperand(1); + auto sTy = dyn_cast(scores.getType()); + auto oTy = dyn_cast(out.getType()); + if (!sTy || !oTy || sTy.getRank() != 1 || oTy.getRank() != 1 || + !sTy.getElementType().isF32() || !oTy.getElementType().isF32()) + return launch.emitError( + "cudnnSoftmaxForwardOut: scores/out must be 1D f32 tensors"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value sMr = valueToMemrefPreservingSlice(b, loc, scores); + Value oMr = valueToMemrefPreservingSlice(b, loc, out); + Value N = memrefDimAsI32(b, loc, sMr, 0); + Value sPtr = memrefBasePtr(b, loc, sMr); + Value oPtr = memrefBasePtr(b, loc, oMr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), ptrTy, ptrTy}; + func::FuncOp shim = ensureShimDecl( + module, "polygeist_cudnn_softmax_forward_out_f32", argTypes, b); + b.create(loc, shim, ValueRange{N, sPtr, oPtr}); + + Value updated = memrefToTensor(b, loc, oMr, launch.getResult(0).getType()); + rewireTensorSliceLaunchResult(launch, updated, + tensorForSliceSource(b, loc, out)); + launch.erase(); + return success(); +} + +static LogicalResult lowerCudaCopyF32(LaunchOp launch, ModuleOp module, + int expectedRank) { + if (launch.getNumOperands() != 2) + return launch.emitError("cudaCopy_f32: expected 2 operands"); + if (launch.getNumResults() != 1) + return launch.emitError("cudaCopy_f32: expected one result"); + + Value src = launch.getOperand(0); + Value out = launch.getOperand(1); + auto sTy = dyn_cast(src.getType()); + auto oTy = dyn_cast(out.getType()); + if (!sTy || !oTy || sTy.getRank() != expectedRank || + oTy.getRank() != expectedRank || !sTy.getElementType().isF32() || + !oTy.getElementType().isF32()) + return launch.emitError("cudaCopy_f32: operands must be rank-") + << expectedRank << " f32 tensors"; + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value sMr = valueToMemrefPreservingSlice(b, loc, src); + Value oMr = valueToMemrefPreservingSlice(b, loc, out); + auto sMd = b.create(loc, sMr); + auto oMd = b.create(loc, oMr); + Value rows = memrefDimAsI32(b, loc, sMr, 0); + Value cols = b.create( + loc, b.getI32Type(), b.getI32IntegerAttr(1)); + Value sRowStride = valueAsI32(b, loc, sMd.getStrides()[0]); + Value oRowStride = valueAsI32(b, loc, oMd.getStrides()[0]); + Value sColStride = cols; + Value oColStride = cols; + if (expectedRank == 2) { + cols = memrefDimAsI32(b, loc, sMr, 1); + sColStride = valueAsI32(b, loc, sMd.getStrides()[1]); + oColStride = valueAsI32(b, loc, oMd.getStrides()[1]); + } + Value sPtr = memrefBasePtr(b, loc, sMr); + Value oPtr = memrefBasePtr(b, loc, oMr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes(6, b.getI32Type()); + argTypes.append({ptrTy, ptrTy}); + func::FuncOp shim = ensureShimDecl( + module, "polygeist_cuda_copy_strided_2d_f32", argTypes, b); + b.create( + loc, shim, + ValueRange{rows, cols, sRowStride, sColStride, + oRowStride, oColStride, sPtr, oPtr}); + + Value updatedBase = tensorForSliceSource(b, loc, out); + Value updated = updatedBase ? Value() + : memrefToTensor(b, loc, valueToMemrefPreservingSlice(b, loc, out), + launch.getResult(0).getType()); + rewireTensorSliceLaunchResult(launch, updated, updatedBase); + launch.erase(); + return success(); +} + +static LogicalResult lowerCudaAddF32(LaunchOp launch, ModuleOp module) { + if (launch.getNumOperands() != 3) + return launch.emitError("cudaAdd_f32: expected 3 operands"); + if (launch.getNumResults() != 1) + return launch.emitError("cudaAdd_f32: expected one result"); + + Value x = launch.getOperand(0); + Value y = launch.getOperand(1); + Value out = launch.getOperand(2); + auto xTy = dyn_cast(x.getType()); + auto yTy = dyn_cast(y.getType()); + auto oTy = dyn_cast(out.getType()); + if (!xTy || !yTy || !oTy || xTy.getRank() != 1 || yTy.getRank() != 1 || + oTy.getRank() != 1 || !xTy.getElementType().isF32() || + !yTy.getElementType().isF32() || !oTy.getElementType().isF32()) + return launch.emitError("cudaAdd_f32: operands must be 1D f32 tensors"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value xMr = valueToMemrefPreservingSlice(b, loc, x); + Value yMr = valueToMemrefPreservingSlice(b, loc, y); + Value oMr = valueToMemrefPreservingSlice(b, loc, out); + Value N = memrefDimAsI32(b, loc, oMr, 0); + Value xPtr = memrefBasePtr(b, loc, xMr); + Value yPtr = memrefBasePtr(b, loc, yMr); + Value oPtr = memrefBasePtr(b, loc, oMr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), ptrTy, ptrTy, ptrTy}; + func::FuncOp shim = + ensureShimDecl(module, "polygeist_cuda_add_f32", argTypes, b); + b.create(loc, shim, ValueRange{N, xPtr, yPtr, oPtr}); + + Value updated = memrefToTensor(b, loc, oMr, launch.getResult(0).getType()); + rewireTensorSliceLaunchResult(launch, updated, + tensorForSliceSource(b, loc, out)); + launch.erase(); + return success(); +} + +static LogicalResult lowerCudaMaskSelectF32(LaunchOp launch, ModuleOp module) { + if (launch.getNumOperands() != 3) + return launch.emitError( + "cudaMaskSelect_f32: expected 3 operands (scores, out, pos)"); + if (launch.getNumResults() != 1) + return launch.emitError("cudaMaskSelect_f32: expected one result"); + + Value scores = launch.getOperand(0); + Value out = launch.getOperand(1); + Value pos = launch.getOperand(2); + auto sTy = dyn_cast(scores.getType()); + auto oTy = dyn_cast(out.getType()); + if (!sTy || !oTy || sTy.getRank() != 1 || oTy.getRank() != 1 || + !sTy.getElementType().isF32() || !oTy.getElementType().isF32()) + return launch.emitError( + "cudaMaskSelect_f32: scores/out must be 1D f32 tensors"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value sMr = valueToMemrefPreservingSlice(b, loc, scores); + Value oMr = valueToMemrefPreservingSlice(b, loc, out); + Value N = memrefDimAsI32(b, loc, sMr, 0); + Value posI32 = valueAsI32(b, loc, pos); + Value sPtr = memrefBasePtr(b, loc, sMr); + Value oPtr = memrefBasePtr(b, loc, oMr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), b.getI32Type(), ptrTy, ptrTy}; + func::FuncOp shim = + ensureShimDecl(module, "polygeist_cuda_mask_select_f32", argTypes, b); + b.create(loc, shim, ValueRange{N, posI32, sPtr, oPtr}); + + Value updated = memrefToTensor(b, loc, oMr, launch.getResult(0).getType()); + rewireTensorSliceLaunchResult(launch, updated, + tensorForSliceSource(b, loc, out)); + launch.erase(); + return success(); +} + +static LogicalResult lowerCudaSwiGLUF32(LaunchOp launch, ModuleOp module) { + if (launch.getNumOperands() != 3) + return launch.emitError("cudaSwiGLU_f32: expected 3 operands"); + if (launch.getNumResults() != 1) + return launch.emitError("cudaSwiGLU_f32: expected one result"); + + Value gate = launch.getOperand(0); + Value up = launch.getOperand(1); + Value out = launch.getOperand(2); + auto gTy = dyn_cast(gate.getType()); + auto uTy = dyn_cast(up.getType()); + auto oTy = dyn_cast(out.getType()); + if (!gTy || !uTy || !oTy || gTy.getRank() != 1 || uTy.getRank() != 1 || + oTy.getRank() != 1 || !gTy.getElementType().isF32() || + !uTy.getElementType().isF32() || !oTy.getElementType().isF32()) + return launch.emitError("cudaSwiGLU_f32: operands must be 1D f32 tensors"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value gMr = valueToMemrefPreservingSlice(b, loc, gate); + Value uMr = valueToMemrefPreservingSlice(b, loc, up); + Value oMr = valueToMemrefPreservingSlice(b, loc, out); + Value N = memrefDimAsI32(b, loc, oMr, 0); + Value gPtr = memrefBasePtr(b, loc, gMr); + Value uPtr = memrefBasePtr(b, loc, uMr); + Value oPtr = memrefBasePtr(b, loc, oMr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), ptrTy, ptrTy, ptrTy}; + func::FuncOp shim = + ensureShimDecl(module, "polygeist_cuda_swiglu_f32", argTypes, b); + b.create(loc, shim, ValueRange{N, gPtr, uPtr, oPtr}); + + Value updated = memrefToTensor(b, loc, oMr, launch.getResult(0).getType()); + rewireTensorSliceLaunchResult(launch, updated, + tensorForSliceSource(b, loc, out)); + launch.erase(); + return success(); +} + +static LogicalResult lowerCudaRopeMulMulF32(LaunchOp launch, ModuleOp module, + bool add) { + if (launch.getNumOperands() != 5) + return launch.emitError("cudaRopeMulMul_f32: expected 5 operands"); + if (launch.getNumResults() != 1) + return launch.emitError("cudaRopeMulMul_f32: expected one result"); + + Value A = launch.getOperand(0); + Value B = launch.getOperand(1); + Value C = launch.getOperand(2); + Value D = launch.getOperand(3); + Value Out = launch.getOperand(4); + auto ATy = dyn_cast(A.getType()); + auto BTy = dyn_cast(B.getType()); + auto CTy = dyn_cast(C.getType()); + auto DTy = dyn_cast(D.getType()); + auto OTy = dyn_cast(Out.getType()); + if (!ATy || !BTy || !CTy || !DTy || !OTy || ATy.getRank() != 2 || + BTy.getRank() != 1 || CTy.getRank() != 2 || DTy.getRank() != 1 || + OTy.getRank() != 2 || !ATy.getElementType().isF32() || + !BTy.getElementType().isF32() || !CTy.getElementType().isF32() || + !DTy.getElementType().isF32() || !OTy.getElementType().isF32()) + return launch.emitError( + "cudaRopeMulMul_f32: expected [2D,1D,2D,1D,2D] f32 tensors"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value M = dimForTensorOrMemrefAsI32(b, loc, Out, 0); + Value N = dimForTensorOrMemrefAsI32(b, loc, Out, 1); + Value addI32 = b.create( + loc, b.getI32Type(), b.getI32IntegerAttr(add ? 1 : 0)); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = {b.getI32Type(), b.getI32Type(), + ptrTy, ptrTy, ptrTy, ptrTy, ptrTy, + b.getI32Type()}; + func::FuncOp shim = + ensureShimDecl(module, "polygeist_cuda_rope_mulmul_f32", argTypes, b); + b.create( + loc, shim, + ValueRange{M, N, pointerForTensorOrMemref(b, loc, A), + pointerForTensorOrMemref(b, loc, B), + pointerForTensorOrMemref(b, loc, C), + pointerForTensorOrMemref(b, loc, D), + pointerForTensorOrMemref(b, loc, Out), + addI32}); + + Value updatedBase = tensorForSliceSource(b, loc, Out); + Value updated = updatedBase ? Value() + : memrefToTensor(b, loc, valueToMemrefPreservingSlice(b, loc, Out), + launch.getResult(0).getType()); + rewireTensorSliceLaunchResult(launch, updated, updatedBase); + launch.erase(); + return success(); +} + +// @cublasLtMatmulBiasReluFused(%A_view, %B_view, %bias_view, %C_view) +// +// 4 operands. After resolving submap → 4 base tensors: +// - A: 2D (M, K) +// - B: 2D (K, N) +// - bias: 1D (N) — per-column, broadcast over rows +// - C: 2D (M, N) +// +// Routes to polygeist_cublaslt_matmul_bias_relu(M, N, K, A*, B*, bias*, C*). +// Runtime issues a single cublasLtMatmul with CUBLASLT_EPILOGUE_RELU_BIAS. +static LogicalResult lowerCublasLtMatmulBiasRelu(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 4) + return launch.emitError( + "cublasLtMatmulBiasReluFused: expected 4 operands, got ") + << launch.getNumOperands(); + if (launch.getNumResults() != 1) + return launch.emitError( + "cublasLtMatmulBiasReluFused: expected 1 result"); + + Value Abase = resolveSubmapBase(launch.getOperand(0)); + Value Bbase = resolveSubmapBase(launch.getOperand(1)); + Value biasB = resolveSubmapBase(launch.getOperand(2)); + Value Cbase = resolveSubmapBase(launch.getOperand(3)); + + auto At = dyn_cast(Abase.getType()); + auto Bt = dyn_cast(Bbase.getType()); + auto bT = dyn_cast(biasB.getType()); + auto Ct = dyn_cast(Cbase.getType()); + if (!At || !Bt || !bT || !Ct || + At.getRank() != 2 || Bt.getRank() != 2 || + bT.getRank() != 1 || Ct.getRank() != 2) + return launch.emitError( + "cublasLtMatmulBiasReluFused: expected (A:2D, B:2D, bias:1D, C:2D) " + "after resolving submap"); + Type elemTy = At.getElementType(); + if (!elemTy.isF32() || Bt.getElementType() != elemTy || + bT.getElementType() != elemTy || Ct.getElementType() != elemTy) + return launch.emitError( + "cublasLtMatmulBiasReluFused: only f32 supported"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value A_mr = tensorToMemref(b, loc, Abase); + Value B_mr = tensorToMemref(b, loc, Bbase); + Value Bi_mr = tensorToMemref(b, loc, biasB); + Value C_mr = tensorToMemref(b, loc, Cbase); + + Value M = memrefDimAsI32(b, loc, A_mr, 0); + Value K = memrefDimAsI32(b, loc, A_mr, 1); + Value N = memrefDimAsI32(b, loc, B_mr, 1); + + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value B_ptr = memrefBasePtr(b, loc, B_mr); + Value Bi_ptr = memrefBasePtr(b, loc, Bi_mr); + Value C_ptr = memrefBasePtr(b, loc, C_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), b.getI32Type(), + ptrTy, ptrTy, ptrTy, ptrTy, + }; + func::FuncOp shim = ensureShimDecl(module, + "polygeist_cublaslt_matmul_bias_relu", argTypes, b); + b.create(loc, shim, + ValueRange{M, N, K, A_ptr, B_ptr, Bi_ptr, C_ptr}); + + Value updated = memrefToTensor(b, loc, C_mr, Cbase.getType()); + rewireLaunchResult(launch, updated); + launch.erase(); + return success(); +} + +// @cublasDsyrk_alias(%A_view, %A_view, %C_view) — fired by the matcher +// when a gemm-shape composition's two inputs resolve to the same +// underlying tensor (AᵀA or A·Aᵀ). +// +// After resolving submap, the three operands are: +// - A: 2D (same SSA value for operand 0 and 1) +// - A again (same as #0) +// - C: 2D, symmetric (only upper triangle written by syrk) +// +// Routes to polygeist_cublas_dsyrk(N, K, A*, C*) — cublasDsyrk_v2 does +// the rank-K update in half the flops of the equivalent gemm. +static LogicalResult lowerCublasDsyrkAlias(LaunchOp launch, ModuleOp module) { + if (launch.getNumOperands() != 3) + return launch.emitError("cublasDsyrk_alias: expected 3 operands"); + Value A0 = resolveSubmapBase(launch.getOperand(0)); + Value A1 = resolveSubmapBase(launch.getOperand(1)); + Value Cbase = resolveSubmapBase(launch.getOperand(2)); + if (A0 != A1) + return launch.emitError( + "cublasDsyrk_alias: matcher emitted this launch but the two " + "input operands don't resolve to the same underlying tensor " + "(matcher invariant violated)"); + auto At = dyn_cast(A0.getType()); + auto Ct = dyn_cast(Cbase.getType()); + if (!At || !Ct || At.getRank() != 2 || Ct.getRank() != 2 || + !At.getElementType().isF32() || !Ct.getElementType().isF32()) + return launch.emitError("cublasDsyrk_alias: A and C must be 2D f32"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value A_mr = tensorToMemref(b, loc, A0); + Value C_mr = tensorToMemref(b, loc, Cbase); + + // For AᵀA: A is K×N, C is N×N. So N = dim(A, 1), K = dim(A, 0). + Value K = memrefDimAsI32(b, loc, A_mr, 0); + Value N = memrefDimAsI32(b, loc, A_mr, 1); + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value C_ptr = memrefBasePtr(b, loc, C_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), ptrTy, ptrTy, + }; + func::FuncOp shim = ensureShimDecl(module, "polygeist_cublas_dsyrk", + argTypes, b); + b.create(loc, shim, ValueRange{N, K, A_ptr, C_ptr}); + + Value updated = memrefToTensor(b, loc, C_mr, Cbase.getType()); + rewireLaunchResult(launch, updated); + launch.erase(); + return success(); +} + +// @cublasGemmFor1x1Conv(%A_view, %F_view, %C_view) — 1×1 conv routed +// to gemm. After resolving submap → 3 base tensors: +// - A: 4D (B, IC, H, W) +// - F: 4D (OC, IC, 1, 1) +// - C: 4D (B, OC, H, W) +// +// Reshape semantics: a 1×1 conv with stride 1 is exactly +// C_flat[m, n] = sum_k A_flat[m, k] * F_flat[k, n] +// where m = B·H·W (flattened), k = IC, n = OC. So we call cublasSgemm +// with M=B·H·W, N=OC, K=IC. +// +// The matrix layout works out perfectly *if* the NCHW data is in row- +// major IC-strided form. For NCHW: A[b,c,h,w] is at byte +// b·IC·H·W + c·H·W + h·W + w. To view as (B·H·W, IC) row-major, we'd +// need bytes at (b·H·W + h·W + w)·IC + c. *Not the same layout.* +// +// So a strict NCHW→(B·H·W, IC) reshape requires a transpose. For now +// we route NHWC-equivalent flattening: cublas computes C_col such +// that C_col[m,n] = sum_k A_col[k, m] * F_col[n, k]. Pick op flags to +// match. The harness should be aware that the routed gemm semantics +// differ slightly from a "true" 1×1 conv — for inference workloads +// with matched layouts this is the right call, and the math we +// validate against (CPU 3-loop reference) does the same flattening. +static LogicalResult lowerCublasGemmFor1x1Conv(LaunchOp launch, + ModuleOp module) { + if (launch.getNumOperands() != 3) + return launch.emitError( + "cublasGemmFor1x1Conv: expected 3 operands, got ") + << launch.getNumOperands(); + if (launch.getNumResults() != 1) + return launch.emitError("cublasGemmFor1x1Conv: expected 1 result"); + + Value Abase = resolveSubmapBase(launch.getOperand(0)); + Value Fbase = resolveSubmapBase(launch.getOperand(1)); + Value Cbase = resolveSubmapBase(launch.getOperand(2)); + + auto At = dyn_cast(Abase.getType()); + auto Ft = dyn_cast(Fbase.getType()); + auto Ct = dyn_cast(Cbase.getType()); + if (!At || !Ft || !Ct || At.getRank() != 4 || Ft.getRank() != 4 || + Ct.getRank() != 4) + return launch.emitError( + "cublasGemmFor1x1Conv: input/filter/output must each be 4D"); + Type elemTy = At.getElementType(); + if (!elemTy.isF32()) + return launch.emitError("cublasGemmFor1x1Conv: only f32 supported"); + + OpBuilder b(launch); + Location loc = launch.getLoc(); + Value A_mr = tensorToMemref(b, loc, Abase); + Value F_mr = tensorToMemref(b, loc, Fbase); + Value C_mr = tensorToMemref(b, loc, Cbase); + + // Pass B, IC, OC, HW = H*W (the batched gemm shim does B independent + // (OC, HW) = (OC, IC) × (IC, HW) gemms in one cublasSgemmStridedBatched). + Value Bdim = memrefDimAsI32(b, loc, A_mr, 0); + Value IC = memrefDimAsI32(b, loc, A_mr, 1); + Value H = memrefDimAsI32(b, loc, A_mr, 2); + Value W = memrefDimAsI32(b, loc, A_mr, 3); + Value OC = memrefDimAsI32(b, loc, F_mr, 0); + Value HW = b.create(loc, H, W); + + Value A_ptr = memrefBasePtr(b, loc, A_mr); + Value F_ptr = memrefBasePtr(b, loc, F_mr); + Value C_ptr = memrefBasePtr(b, loc, C_mr); + + auto ptrTy = LLVM::LLVMPointerType::get(b.getContext()); + SmallVector argTypes = { + b.getI32Type(), b.getI32Type(), b.getI32Type(), b.getI32Type(), + ptrTy, ptrTy, ptrTy, + }; + func::FuncOp shim = ensureShimDecl(module, "polygeist_cublas_sgemm_1x1conv", + argTypes, b); + b.create(loc, shim, ValueRange{Bdim, IC, OC, HW, + A_ptr, F_ptr, C_ptr}); + + Value updated = memrefToTensor(b, loc, C_mr, Cbase.getType()); + rewireLaunchResult(launch, updated); + launch.erase(); + return success(); +} + +//===----------------------------------------------------------------------===// +// The pass +//===----------------------------------------------------------------------===// + +struct LowerKernelLaunchToCuBLASPass + : public mlir::polygeist::LowerKernelLaunchToCuBLASBase< + LowerKernelLaunchToCuBLASPass> { + void runOnOperation() override { + ModuleOp module = getOperation(); + + // Track the set of kernel symbols we lower; after launches are gone we + // delete any kernel.defn carrying one of these symbols, since no users + // remain and downstream LLVM lowering doesn't know what kernel.defn is. + llvm::SmallSet loweredSymbols; + + SmallVector launches; + module.walk([&](LaunchOp op) { launches.push_back(op); }); + + // Pre-pass: elide redundant memset_zero_{1D,2D} launches that + // immediately precede a launch whose runtime shim uses β=0 + // (cublasDsyrk_alias today; could be extended to any overwriting + // op). The two launches show up as separate matches because the + // matcher's gemm-2-step template requires `Out*β` for the first + // step, not `Lit(0)`. After this pre-pass the memset is gone, so + // the dataflow chain is just the syrk shim's input. + SmallVector deadMemsets; + for (LaunchOp launch : launches) { + auto sym = launch->getAttrOfType("kernel"); + if (!sym) continue; + if (sym.getLeafReference().getValue() != "cublasDsyrk_alias") + continue; + // Walk the syrk's output operand chain back to find the memset. + Value v = launch.getOperand(2); + for (int hops = 0; hops < 16; ++hops) { + Operation *def = v.getDefiningOp(); + if (!def) break; + if (auto sm = dyn_cast(def)) { + v = sm.getBase(); continue; + } + if (auto inv = dyn_cast(def)) { + v = inv.getOperand(1); continue; + } + if (auto memsetLaunch = dyn_cast(def)) { + auto msym = memsetLaunch->getAttrOfType("kernel"); + if (msym && (msym.getLeafReference().getValue() == "memset_zero_2D" || + msym.getLeafReference().getValue() == "memset_zero_2D_f32" || + msym.getLeafReference().getValue() == "memset_zero_1D")) { + // Replace memset result uses with its first operand (the + // pre-init tensor). cublasSsyrk writes with β=0 anyway, so + // the prior contents don't matter. + if (memsetLaunch.getNumResults() == 1) + memsetLaunch.getResult(0).replaceAllUsesWith( + memsetLaunch.getOperand(0)); + deadMemsets.push_back(memsetLaunch); + } + break; + } + break; + } + } + for (LaunchOp m : deadMemsets) m.erase(); + // Re-collect launches now that some have been erased. + launches.clear(); + module.walk([&](LaunchOp op) { launches.push_back(op); }); + + if (deviceResidentCutensornet) { + for (LaunchOp launch : launches) { + auto sym = launch->getAttrOfType("kernel"); + if (!sym) + continue; + StringRef name = sym.getLeafReference().getValue(); + if (name == "cutensornetContraction2_f64" || + name == "cutensornetContraction2_f64_r4r5r4" || + name == "cutensornetContraction2_f64_r5r4r4" || + name == "cutensornetContraction2_f64_r5r5r4") + launch->setAttr("polygeist.device_resident", + UnitAttr::get(module.getContext())); + } + } + + for (LaunchOp launch : launches) { + auto sym = launch->getAttrOfType("kernel"); + if (!sym) { + launch.emitError( + "kernel.launch missing 'kernel' symbol ref attribute"); + return signalPassFailure(); + } + StringRef libSym = sym.getLeafReference().getValue(); + // Symbols claimed by other backend passes (e.g. PVA for int8/int16 + // conv2d) intentionally fall through — they're not errors here, + // just "not our problem". Their own pass will lower them. + if (libSym == "cudnnConvolution2D_9tap_i8" || + libSym == "cudnnConvolution2D_9tap_i16") + continue; + StringRef shim = shimSymbolFor(libSym); + if (shim.empty()) { + launch.emitError( + "lower-kernel-launch-to-cublas: no shim ABI lowering for " + "library symbol @") + << libSym + << ". Extend `shimSymbolFor` in " + "LowerKernelLaunchToCuBLAS.cpp to add one."; + return signalPassFailure(); + } + + LogicalResult r = failure(); + if (libSym == "cublasDgemm") { + r = lowerDgemm(launch, module); + } else if (libSym == "cublasDgemm_simple" || + libSym == "cublasDgemm_alpha_only") { + r = lowerDgemmVariant(launch, module, libSym); + } else if (libSym == "cublasSgemm_broadcast3d_simple") { + r = lowerSgemmBroadcast3DSimple(launch, module); + } else if (libSym == "cublasSgemm_broadcast3d_memref") { + r = lowerSgemmBroadcast3DMemRef(launch, module); + } else if (libSym == + "cublasSgemm_strided_batched_broadcast_rhs") { + r = lowerSgemmStridedBatchedBroadcastRhs(launch, module); + } else if (libSym == "cublasDgeam_scale2D") { + r = lowerDgeamScale2D(launch, module); + } else if (libSym == "cublasDgemv") { + r = lowerDgemv(launch, module); + } else if (libSym == "cublasDgemv_T") { + r = lowerDgemvT(launch, module); + } else if (libSym == "cublasSgemv") { + r = lowerSgemv(launch, module); + } else if (libSym == "cublasSgemv_T") { + r = lowerSgemvT(launch, module); + } else if (libSym == "cublasDgemv_alpha") { + r = lowerDgemvAlpha(launch, module); + } else if (libSym == "cublasDaxpby") { + r = lowerDaxpby(launch, module); + } else if (libSym == "cublasDaxpy_unit") { + r = lowerDaxpyUnit(launch, module); + } else if (libSym == "cublasDger_rank2") { + r = lowerDgerRank2(launch, module); + } else if (libSym == "cublasDgemm_outer_product") { + r = lowerDgemmOuterProduct(launch, module); + } else if (libSym == "memset_zero_2D" || + libSym == "memset_zero_2D_f32") { + r = lowerMemsetZero2D(launch, module); + } else if (libSym == "memset_zero_1D" || + libSym == "memset_zero_1D_f32") { + r = lowerMemsetZero1D(launch, module, libSym); + } else if (libSym == "cudnnConvolution2D_9tap" || + libSym == "cudnnConvolution2D_9tap_f32" || + libSym == "cudnnConvolution2D_9tap_f16" || + libSym == "cudnnConvolution2D_9tap_bf16" || + libSym == "cudnnConvolution2D_9tap_i32") { + // i8/i16 are handled by LowerKernelLaunchToPVA and aren't claimed + // here by shimSymbolFor, so they're skipped above before we ever + // reach this dispatch. + r = lowerCudnnConv2D9tap(launch, module, shim); + } else if (libSym == "cudnnConvolution2D_25tap" || + libSym == "cudnnConvolution2D_25tap_f32") { + r = lowerCudnnConv2D25tap(launch, module, shim); + } else if (libSym == "cudnnConvolution2D_ntap" || + libSym == "cudnnConvolution2D_ntap_f32") { + r = lowerCudnnConv2DNtapPacked(launch, module, shim); + } else if (libSym == "cudnnConvolution2D_ntap_tensor" || + libSym == "cudnnConvolution2D_ntap_f32_tensor") { + r = lowerCudnnConv2DNtapTensor(launch, module, shim); + } else if (libSym == "cudnnConvolution3D_ntap_tensor" || + libSym == "cudnnConvolution3D_ntap_f32_tensor") { + r = lowerCudnnConv3DNtapTensor(launch, module, shim); + } else if (libSym == "cudnnConvolution3D_f32" || + libSym == "cudnnConvolution3D_f32_bias") { + r = lowerCudnnConv3DChannelsF32( + launch, module, libSym == "cudnnConvolution3D_f32_bias"); + } else if (libSym == "customStencil3D7pt_f64_tensor" || + libSym == "customStencil3D7ptCoeff_f64_tensor" || + libSym == "customStencil3D7ptExtra_f64_tensor") { + r = lowerCustomStencil3D7ptF64Tensor(launch, module, libSym); + } else if (libSym == "cufftZ2Z_1D_tensor" || + libSym == "cufftC2C_1D_tensor") { + r = lowerCufftC2C1DTensor(launch, module, shim); + } else if (libSym == "cutensornetTensorProduct3D_f32_tensor" || + libSym == "cutensornetTensorProduct3D_f64_tensor") { + r = lowerCutensornetTensorProduct3D( + launch, module, + libSym == "cutensornetTensorProduct3D_f64_tensor"); + } else if (libSym == "cutensornetContraction2_f64" || + libSym == "cutensornetContraction2_f64_r4r5r4" || + libSym == "cutensornetContraction2_f64_r5r4r4" || + libSym == "cutensornetContraction2_f64_r5r5r4") { + r = lowerCutensornetContraction2F64(launch, module); + } else if (libSym == "cudnnConvolutionFwd_batched") { + r = lowerCudnnConv2dBatched(launch, module); + } else if (libSym == "cudnnConvolutionFwd_im2col_gemm") { + r = lowerCudnnConv2dIm2colGemm(launch, module); + } else if (libSym == "cudnnMaxPoolFwd_batched") { + r = lowerCudnnMaxpoolBatched(launch, module); + } else if (libSym == "cudnnBatchNormalizationForwardInference") { + r = lowerCudnnBatchnormInference(launch, module); + } else if (libSym == "cudnnAddTensor_batched") { + r = lowerCudnnAddTensorBatched(launch, module); + } else if (libSym == "cudnnConvBnReluFwdFused") { + r = lowerCudnnConvBnReluFused(launch, module); + } else if (libSym == "cudnnConvBiasReluAddFwdFused") { + r = lowerCudnnConvBiasReluAdd(launch, module); + } else if (libSym == "rmsnorm_f32" || + libSym == "rmsnorm_f32_tensor") { + r = lowerRmsnormF32(launch, module); + } else if (libSym == "rmsnorm_unweighted_f32_tensor") { + r = lowerRmsnormUnweightedF32(launch, module); + } else if (libSym == "gelu_tanh_f32_tensor") { + r = lowerGeluTanhF32(launch, module); + } else if (libSym == "whisperExpShiftSum_f32_tensor") { + r = lowerWhisperExpShiftSumF32(launch, module); + } else if (libSym == "cublasDdot" || libSym == "cublasSdot") { + r = lowerCublasDot(launch, module, libSym == "cublasSdot"); + } else if (libSym == "cudnnSoftmaxForward" || + libSym == "cudnnSoftmaxForward_tensor") { + r = lowerCudnnSoftmaxForwardF32(launch, module); + } else if (libSym == "cudnnSoftmaxForwardOut_tensor") { + r = lowerCudnnSoftmaxForwardOutF32(launch, module); + } else if (libSym == "cudaCopy1D_f32_tensor") { + r = lowerCudaCopyF32(launch, module, /*expectedRank=*/1); + } else if (libSym == "cudaCopy2D_f32_tensor") { + r = lowerCudaCopyF32(launch, module, /*expectedRank=*/2); + } else if (libSym == "cudaCopy3D_f32_tensor") { + r = lowerCudaCopyF32(launch, module, /*expectedRank=*/3); + } else if (libSym == "cudaCopy6D_f32_tensor") { + r = lowerCudaCopyF32(launch, module, /*expectedRank=*/6); + } else if (libSym == "cudaAdd_f32_tensor") { + r = lowerCudaAddF32(launch, module); + } else if (libSym == "cudaMaskSelect_f32_tensor") { + r = lowerCudaMaskSelectF32(launch, module); + } else if (libSym == "cudaSwiGLU_f32_tensor") { + r = lowerCudaSwiGLUF32(launch, module); + } else if (libSym == "cudaRopeMulMulSub_f32_tensor") { + r = lowerCudaRopeMulMulF32(launch, module, /*add=*/false); + } else if (libSym == "cudaRopeMulMulAdd_f32_tensor") { + r = lowerCudaRopeMulMulF32(launch, module, /*add=*/true); + } else if (libSym == "cublasLtMatmulBiasReluFused") { + r = lowerCublasLtMatmulBiasRelu(launch, module); + } else if (libSym == "cublasDsyrk_alias") { + r = lowerCublasDsyrkAlias(launch, module); + } else if (libSym == "cublasGemmFor1x1Conv") { + r = lowerCublasGemmFor1x1Conv(launch, module); + } else { + launch.emitError("internal: shimSymbolFor recognised @") + << libSym << " but no lowering branch dispatched"; + return signalPassFailure(); + } + if (failed(r)) + return signalPassFailure(); + loweredSymbols.insert(libSym); + } + + // Remove any kernel.defn that is now use-empty. After lowering, the + // stub defns we injected to satisfy the verifier are dead — and + // downstream LLVM lowering doesn't know what kernel.defn is. + // (Don't filter by loweredSymbols: scripts often inject stubs for + // every symbol the matcher might produce, only some of which the + // input actually used.) + SmallVector deadDefns; + module.walk([&](DefnOp d) { + if (SymbolTable::symbolKnownUseEmpty(d, module)) + deadDefns.push_back(d); + }); + for (DefnOp d : deadDefns) + d.erase(); + } +}; + +} // namespace + +namespace mlir { +namespace polygeist { +std::unique_ptr createLowerKernelLaunchToCuBLASPass() { + return std::make_unique(); +} +} // namespace polygeist +} // namespace mlir diff --git a/lib/polygeist/Passes/LowerKernelLaunchToPVA.cpp b/lib/polygeist/Passes/LowerKernelLaunchToPVA.cpp new file mode 100644 index 000000000000..0ef864bd09b1 --- /dev/null +++ b/lib/polygeist/Passes/LowerKernelLaunchToPVA.cpp @@ -0,0 +1,131 @@ +//===- LowerKernelLaunchToPVA.cpp - kernel.launch → PVA ABI --------------===// +// +// Lowers `kernel.launch @cudnnConvolution2D_9tap_i{8,16}` ops to +// `func.call @polygeist_pva_conv2d_3x3_i{8,16}`, the runtime-shim ABI for +// NVIDIA PVA Solutions' single-channel integer Conv2d operator +// (libpva_operator on Orin's Programmable Vision Accelerator). +// +// Why a separate pass: PVA is a distinct backend from cuBLAS/cuDNN — +// different vendor library (`libpva_operator` / `libcupva_host`), different +// host-side staging (PVA-allocated memory accessed via +// `CupvaMemGetHostPointer`, not cudaMemcpy), and different hardware +// semantics (Q-format quantized filter with REPLICATE border, not a raw +// integer multiply-accumulate). Wedging this into the cuBLAS pass would +// muddy the cuBLAS pass's symbol map; routing it through its own pass +// keeps each backend self-contained. +// +// cuDNN deliberately fails on standalone INT8/INT16 forward conv on Orin +// (CUDNN_STATUS_BAD_PARAM), and there's no host fallback either — PVA is +// the only Orin path for those dtypes today. +// +// This pass and `--lower-kernel-launch-to-cublas` handle disjoint launch +// symbol sets, so the relative order doesn't matter; both should run +// before LLVM lowering. The conv-lowering body is shared via +// `KernelLaunchLoweringUtils.h` since it's purely a memref/scalar layout +// transformation that's the same for any conv backend. +// +//===----------------------------------------------------------------------===// + +#include "PassDetails.h" + +#include "KernelLaunchLoweringUtils.h" + +#include "mlir/IR/BuiltinOps.h" +#include "mlir/IR/SymbolTable.h" +#include "mlir/Pass/Pass.h" +#include "polygeist/Kernel/KernelDialect.h" +#include "polygeist/Kernel/KernelOps.h" +#include "polygeist/Passes/Passes.h" + +using namespace mlir; +using namespace mlir::polygeist; +using namespace mlir::polygeist::kernel; + +namespace { + +// Map a matcher-emitted kernel symbol to its PVA runtime-shim symbol. +// Empty StringRef means "not a PVA target — leave for another pass." +static StringRef pvaShimSymbolFor(StringRef libSym) { + if (libSym == "cudnnConvolution2D_9tap_i16") + return "polygeist_pva_conv2d_3x3_i16"; + if (libSym == "cudnnConvolution2D_9tap_i8") + return "polygeist_pva_conv2d_3x3_i8"; + if (libSym == "pvaBoxFilter_3x3_i8") + return "polygeist_pva_boxfilter_3x3_i8"; + if (libSym == "pvaBoxFilter_3x3_i16") + return "polygeist_pva_boxfilter_3x3_i16"; + if (libSym == "pvaGaussianFilter_3x3_i8") + return "polygeist_pva_gaussian_3x3_i8"; + if (libSym == "pvaGaussianFilter_3x3_i16") + return "polygeist_pva_gaussian_3x3_i16"; + if (libSym == "pvaBilateralFilter_3x3_i8") + return "polygeist_pva_bilateral_3x3_i8"; + if (libSym == "pvaBilateralFilter_3x3_i16") + return "polygeist_pva_bilateral_3x3_i16"; + if (libSym == "pvaHistogramEqualization_i8") + return "polygeist_pva_histeq_i8"; + return StringRef(); +} + +// Classify the launch shape so the right lowering helper is invoked. +enum class PvaLaunchKind { Conv9tap, ImageFilter2op }; +static PvaLaunchKind pvaLaunchKindFor(StringRef libSym) { + if (libSym.starts_with("cudnnConvolution2D_9tap_")) + return PvaLaunchKind::Conv9tap; + // pvaBoxFilter_*, future pvaGaussianFilter_*, pvaMedianFilter_*, etc. + return PvaLaunchKind::ImageFilter2op; +} + +struct LowerKernelLaunchToPVAPass + : public mlir::polygeist::LowerKernelLaunchToPVABase< + LowerKernelLaunchToPVAPass> { + void runOnOperation() override { + ModuleOp module = getOperation(); + + SmallVector launches; + module.walk([&](LaunchOp op) { launches.push_back(op); }); + + for (LaunchOp launch : launches) { + auto sym = launch->getAttrOfType("kernel"); + if (!sym) continue; + StringRef libSym = sym.getLeafReference().getValue(); + StringRef shim = pvaShimSymbolFor(libSym); + if (shim.empty()) continue; // not ours; another pass will handle it + + LogicalResult r = failure(); + switch (pvaLaunchKindFor(libSym)) { + case PvaLaunchKind::Conv9tap: + r = lowerCudnnConv2D9tap(launch, module, shim); + break; + case PvaLaunchKind::ImageFilter2op: + r = lowerImageFilter2Operand(launch, module, shim); + break; + } + if (failed(r)) + return signalPassFailure(); + } + + // Drop any kernel.defn that has no remaining uses. The matcher injects + // stub defns to satisfy the verifier; after lowering, the ones we + // claimed have no callers. (We don't filter by which symbols we + // claimed: scripts often inject stubs for every symbol the matcher + // could emit, only some of which the input actually used.) + SmallVector deadDefns; + module.walk([&](DefnOp d) { + if (SymbolTable::symbolKnownUseEmpty(d, module)) + deadDefns.push_back(d); + }); + for (DefnOp d : deadDefns) + d.erase(); + } +}; + +} // namespace + +namespace mlir { +namespace polygeist { +std::unique_ptr createLowerKernelLaunchToPVAPass() { + return std::make_unique(); +} +} // namespace polygeist +} // namespace mlir diff --git a/lib/polygeist/Passes/LowerPolygeistSubmap.cpp b/lib/polygeist/Passes/LowerPolygeistSubmap.cpp new file mode 100644 index 000000000000..4271c042c0c7 --- /dev/null +++ b/lib/polygeist/Passes/LowerPolygeistSubmap.cpp @@ -0,0 +1,1397 @@ +#include "PassDetails.h" + +#include "mlir/Dialect/Arith/IR/Arith.h" +#include "mlir/Dialect/Affine/IR/AffineOps.h" +#include "mlir/Dialect/Func/IR/FuncOps.h" +#include "mlir/Dialect/Linalg/IR/Linalg.h" +#include "mlir/Dialect/MemRef/IR/MemRef.h" +#include "mlir/Dialect/SCF/IR/SCF.h" +#include "mlir/Dialect/Tensor/IR/Tensor.h" +#include "mlir/Dialect/Utils/ReshapeOpsUtils.h" +#include "mlir/IR/AffineExpr.h" +#include "mlir/IR/AffineMap.h" +#include "mlir/IR/IRMapping.h" +#include "mlir/Transforms/GreedyPatternRewriteDriver.h" +#include "polygeist/Ops.h" +#include "polygeist/Passes/Passes.h" +#include "llvm/Support/Debug.h" + +#include + +#define DEBUG_TYPE "lower-polygeist-submap" + +using namespace mlir; +using namespace polygeist; + +namespace { + +// Compose pure-dim-bearing polygeist.submap operands of a linalg.generic into +// the linalg's indexing_maps and switch the operands to the submap bases. +// This is done per-linalg.generic (rather than per-submap) so we can verify +// the resulting indexing_maps collectively cover every iter dim — otherwise +// linalg's shape-to-loops inference becomes ill-defined. +// +// Eligible submaps: numSymbols == 0 AND every result expression contains at +// least one DimExpr (allows `d0`, `d0 + const`, etc.; rejects pure-symbol or +// pure-constant slots). Symbol-bearing or constant-only forms are handled by +// the Subview/ExtractSlice patterns separately. +// Decompose a submap's affine map into a per-base-dim structure. Each base- +// dim is classified as either "live" (the view contributes data along this +// dim; passes through into the subview's result shape) or "dead" (the view +// reduces this base-dim to a single element via a fixed offset; subview +// rank-reduces it). +// +// Each result expression of submap.map must be one of: +// d_i → live, offset 0, view_dim = d_i +// d_i + const → live, offset const, view_dim = d_i +// const + d_i → live, offset const, view_dim = d_i +// d_i + symbol → live, offset symbol, view_dim = d_i +// symbol + d_i → live, offset symbol, view_dim = d_i +// symbol → dead, offset symbol value +// const → dead, offset constant value +// +// The "live view_dim" tells the caller which iter-dim of the consumer linalg +// maps to this base-dim AFTER the subview rank-reduction. The offsets feed +// memref.subview's offsets. "dead" base-dims rank-reduce out — they don't +// appear in the consumer linalg's new indexing_map for this operand. +struct PerBaseDim { + bool live; + OpFoldResult offset; // for !live, the fixed offset; for live, the base offset (0 or symbol/const) + unsigned viewDim; // only valid when live +}; +struct DecomposedMap { + SmallVector base; // one per result of submap.map (= base rank) +}; + +static std::optional +decomposeMapForLowering(AffineMap m, ValueRange symbols, + OpBuilder &builder) { + DecomposedMap d; + d.base.reserve(m.getNumResults()); + unsigned numDims = m.getNumDims(); + OpFoldResult zeroAttr = builder.getIndexAttr(0); + for (unsigned k = 0; k < m.getNumResults(); ++k) { + AffineExpr e = m.getResult(k); + // Pure DimExpr. + if (auto dim = e.dyn_cast()) { + if (dim.getPosition() >= numDims) return std::nullopt; + d.base.push_back(PerBaseDim{true, zeroAttr, dim.getPosition()}); + continue; + } + // Pure SymbolExpr. + if (auto sym = e.dyn_cast()) { + unsigned si = sym.getPosition(); + if (si >= symbols.size()) return std::nullopt; + d.base.push_back(PerBaseDim{false, symbols[si], 0}); + continue; + } + // Pure ConstantExpr. + if (auto c = e.dyn_cast()) { + d.base.push_back(PerBaseDim{false, builder.getIndexAttr(c.getValue()), 0}); + continue; + } + // AffineBinaryOpExpr: dim + (const|symbol). + if (auto add = e.dyn_cast()) { + if (add.getKind() != AffineExprKind::Add) return std::nullopt; + AffineExpr lhs = add.getLHS(), rhs = add.getRHS(); + AffineExpr dimSide, offSide; + if (lhs.isa()) { + dimSide = lhs; offSide = rhs; + } else if (rhs.isa()) { + dimSide = rhs; offSide = lhs; + } else { + return std::nullopt; + } + auto dimExpr = dimSide.cast(); + if (dimExpr.getPosition() >= numDims) return std::nullopt; + OpFoldResult off; + if (auto c = offSide.dyn_cast()) { + off = builder.getIndexAttr(c.getValue()); + } else if (auto s = offSide.dyn_cast()) { + unsigned si = s.getPosition(); + if (si >= symbols.size()) return std::nullopt; + off = symbols[si]; + } else { + return std::nullopt; + } + d.base.push_back(PerBaseDim{true, off, dimExpr.getPosition()}); + continue; + } + return std::nullopt; + } + return d; +} + +// Returns true iff any base-dim has a non-zero static offset (signaling that +// a subview is structurally required because base.dim values can't directly +// serve as the iteration bound — they'd let the loop run past the original +// submap's smaller view). +static bool hasAnyNonZeroOffset(const DecomposedMap &d) { + for (const auto &b : d.base) { + if (!b.live) return true; // rank-reduced — needs subview + if (auto attr = b.offset.dyn_cast()) + if (auto i = attr.dyn_cast()) + if (i.getInt() != 0) return true; + if (b.offset.is()) return true; // symbol offset — needs subview + } + return false; +} + +static std::optional getConstantIndex(Value v) { + if (auto c = v.getDefiningOp()) + return c.value(); + return std::nullopt; +} + +static std::optional> +getStaticSizeOperands(ValueRange sizes) { + SmallVector staticSizes; + staticSizes.reserve(sizes.size()); + for (Value size : sizes) { + auto c = getConstantIndex(size); + if (!c) + return std::nullopt; + staticSizes.push_back(*c); + } + return staticSizes; +} + +static bool accumulateLinearDimCoefficients( + AffineExpr e, SmallVectorImpl &coeffs, int64_t &constant, + int64_t scale = 1); + +// Prove injectivity by enumerating a bounded static view domain. This is an +// exact check for the small fixed-shape tensor-product views produced by the +// current MFEM corpus. Large or dynamic domains deliberately return +// std::nullopt: callers must not turn "unknown" into an ordinary scatter. +static std::optional +isInjectiveOnStaticDomain(AffineMap map, ArrayRef sizes) { + if (map.getNumDims() != sizes.size()) + return std::nullopt; + + constexpr int64_t kEnumerationLimit = 1'000'000; + int64_t domainSize = 1; + for (int64_t size : sizes) { + if (size <= 0 || domainSize > kEnumerationLimit / size) + return std::nullopt; + domainSize *= size; + } + + SmallVector> resultCoefficients; + SmallVector resultConstants; + resultCoefficients.reserve(map.getNumResults()); + resultConstants.reserve(map.getNumResults()); + for (AffineExpr result : map.getResults()) { + SmallVector coefficients(map.getNumDims(), 0); + int64_t constant = 0; + if (!accumulateLinearDimCoefficients(result, coefficients, constant)) + return std::nullopt; + resultCoefficients.push_back(std::move(coefficients)); + resultConstants.push_back(constant); + } + + std::set> image; + SmallVector coordinates(map.getNumDims(), 0); + for (int64_t linear = 0; linear < domainSize; ++linear) { + int64_t remaining = linear; + for (int64_t dim = static_cast(sizes.size()) - 1; dim >= 0; + --dim) { + coordinates[dim] = remaining % sizes[dim]; + remaining /= sizes[dim]; + } + + SmallVector destination; + destination.reserve(map.getNumResults()); + for (auto [coefficients, constant] : + llvm::zip(resultCoefficients, resultConstants)) { + int64_t value = constant; + for (auto [coefficient, coordinate] : + llvm::zip(coefficients, coordinates)) + value += coefficient * coordinate; + destination.push_back(value); + } + if (!image.insert(std::move(destination)).second) + return false; + } + return true; +} + +static bool accumulateLinearDimCoefficients(AffineExpr e, + SmallVectorImpl &coeffs, + int64_t &constant, + int64_t scale) { + if (auto d = e.dyn_cast()) { + unsigned pos = d.getPosition(); + if (pos >= coeffs.size()) + return false; + coeffs[pos] += scale; + return true; + } + if (auto c = e.dyn_cast()) { + constant += scale * c.getValue(); + return true; + } + if (auto bin = e.dyn_cast()) { + if (bin.getKind() == AffineExprKind::Add) { + return accumulateLinearDimCoefficients(bin.getLHS(), coeffs, constant, + scale) && + accumulateLinearDimCoefficients(bin.getRHS(), coeffs, constant, + scale); + } + if (bin.getKind() == AffineExprKind::Mul) { + if (auto c = bin.getLHS().dyn_cast()) + return accumulateLinearDimCoefficients(bin.getRHS(), coeffs, constant, + scale * c.getValue()); + if (auto c = bin.getRHS().dyn_cast()) + return accumulateLinearDimCoefficients(bin.getLHS(), coeffs, constant, + scale * c.getValue()); + } + } + return false; +} + +static bool parseSingleDimConstantStride(AffineExpr e, unsigned numDims, + unsigned &dim, int64_t &stride, + int64_t &offset) { + SmallVector coeffs(numDims, 0); + int64_t constant = 0; + if (!accumulateLinearDimCoefficients(e, coeffs, constant)) + return false; + int64_t seenDim = -1; + for (auto it : llvm::enumerate(coeffs)) { + if (it.value() == 0) + continue; + if (seenDim != -1) + return false; + seenDim = it.index(); + stride = it.value(); + } + if (seenDim == -1 || stride <= 0) + return false; + dim = static_cast(seenDim); + offset = constant; + return true; +} + +static bool isRowMajorLinearizedMap(AffineMap map, + ArrayRef staticSizes) { + if (map.getNumResults() != 1 || map.getNumDims() != staticSizes.size()) + return false; + SmallVector coeffs(staticSizes.size(), 0); + int64_t constant = 0; + if (!accumulateLinearDimCoefficients(map.getResult(0), coeffs, constant)) + return false; + if (constant != 0) + return false; + int64_t expectedStride = 1; + for (int64_t i = static_cast(staticSizes.size()) - 1; i >= 0; --i) { + if (staticSizes[i] <= 0 || coeffs[i] != expectedStride) + return false; + expectedStride *= staticSizes[i]; + } + return true; +} + +static bool isLeadingDimProjection(AffineMap map, unsigned projectedRank) { + if (map.getNumResults() != projectedRank || map.getNumDims() < projectedRank) + return false; + for (unsigned i = 0; i < projectedRank; ++i) { + auto dim = map.getResult(i).dyn_cast(); + if (!dim || dim.getPosition() != i) + return false; + } + return true; +} + +static int64_t product(ArrayRef values) { + int64_t prod = 1; + for (int64_t v : values) + prod *= v; + return prod; +} + +static SmallVector +getSingleSourceReassociation(unsigned resultRank) { + SmallVector reassociation(1); + reassociation[0].reserve(resultRank); + for (unsigned i = 0; i < resultRank; ++i) + reassociation[0].push_back(i); + return reassociation; +} + +static std::optional> +getMixedSizeOperands(ValueRange sizes, unsigned rank, OpBuilder &builder) { + if (sizes.size() < rank) + return std::nullopt; + SmallVector mixedSizes; + mixedSizes.reserve(rank); + for (unsigned i = 0; i < rank; ++i) { + if (auto c = getConstantIndex(sizes[i])) { + mixedSizes.push_back(builder.getIndexAttr(*c)); + continue; + } + mixedSizes.push_back(sizes[i]); + } + return mixedSizes; +} + +static bool sameTrailingOperands(ValueRange lhs, ValueRange rhs) { + if (lhs.size() != rhs.size()) + return false; + for (auto [l, r] : llvm::zip(lhs, rhs)) + if (l != r) + return false; + return true; +} + +static Value stripTensorCasts(Value v) { + while (auto cast = v.getDefiningOp()) + v = cast.getSource(); + return v; +} + +struct FoldIdentitySubmapInverse : public OpRewritePattern { + FoldIdentitySubmapInverse(MLIRContext *context) + : OpRewritePattern(context, /*benefit=*/2) {} + + LogicalResult matchAndRewrite(SubmapInverseOp inv, + PatternRewriter &rewriter) const final { + auto submap = inv.getViewModified().getDefiningOp(); + if (!submap) + return failure(); + if (stripTensorCasts(submap.getBase()) != + stripTensorCasts(inv.getBaseOriginal())) + return failure(); + if (submap.getMap() != inv.getMap()) + return failure(); + if (!sameTrailingOperands(submap->getOperands().drop_front(1), + inv->getOperands().drop_front(2))) + return failure(); + rewriter.replaceOp(inv, inv.getBaseOriginal()); + return success(); + } +}; + +// Rank-reduce a symbol-free, aliasing output submap of a linalg.generic. +// Unlike the slice-oriented pattern below, this also handles flattened +// strided maps such as +// (d0,d1,d2,d3,d4) -> d3 + 64*d0 + 16*d1 + 4*d2 +// by constructing an equivalent rank-4 output submap and changing the output +// indexing map to (d0,d1,d2,d3). The dropped d4 remains a real Linalg +// reduction iterator, while the new submap is injective and can safely be +// scattered back after debufferization. +struct ComposeAffineSubmapIntoLinalgGeneric + : public OpRewritePattern { + ComposeAffineSubmapIntoLinalgGeneric(MLIRContext *context) + : OpRewritePattern(context, /*benefit=*/2) {} + + LogicalResult matchAndRewrite(linalg::GenericOp generic, + PatternRewriter &rewriter) const final { + SmallVector maps(generic.getIndexingMapsArray()); + struct WorkItem { + unsigned operandNumber; + SubmapOp submap; + AffineMap reducedSubmapMap; + AffineMap outputIndexingMap; + SmallVector sizes; + MemRefType type; + }; + SmallVector work; + unsigned numInputs = generic.getNumDpsInputs(); + unsigned numLoops = generic.getNumLoops(); + auto iteratorTypes = generic.getIteratorTypesArray(); + + for (OpOperand &operand : generic->getOpOperands()) { + // Keep input submaps as shaped views for now: their projected maps are + // often what Linalg uses to infer reduction-loop bounds. The semantic + // bug addressed here is specifically an aliasing output submap. + if (operand.getOperandNumber() < numInputs) + continue; + auto submap = operand.get().getDefiningOp(); + if (!submap || submap.getMap().getNumSymbols() != 0) + continue; + if (!isa(submap.getBase().getType()) || + !isa(submap.getType())) + continue; + if (submap.getMap().getNumResults() != + cast(submap.getBase().getType()).getRank()) + continue; + + AffineMap operandMap = maps[operand.getOperandNumber()]; + if (operandMap.getNumSymbols() != 0 || + operandMap.getNumResults() != submap.getMap().getNumDims()) + continue; + AffineMap composed = submap.getMap().compose(operandMap); + + // Recover which original view dimension supplies each loop bound. A + // projected permutation is sufficient for the canonical reduction + // outputs produced by RaiseToLinalg and lets us carry the exact dynamic + // size SSA values into the reduced view. + SmallVector loopToView(numLoops, -1); + for (auto [viewDim, expr] : llvm::enumerate(operandMap.getResults())) { + auto dim = expr.dyn_cast(); + if (!dim || dim.getPosition() >= numLoops || + loopToView[dim.getPosition()] != -1) + return rewriter.notifyMatchFailure( + generic, "output indexing map is not a projected permutation"); + loopToView[dim.getPosition()] = viewDim; + } + + // An output may omit loop dimensions only when those dimensions are + // reductions. Conversely, a reduction iterator must not select a + // distinct output element. This is the legality condition that turns + // a non-injective memref view into a canonical Linalg reduction. + SmallVector used(numLoops, false); + for (AffineExpr result : composed.getResults()) + result.walk([&](AffineExpr expr) { + if (auto dim = expr.dyn_cast()) + if (dim.getPosition() < numLoops) + used[dim.getPosition()] = true; + }); + + SmallVector retainedLoops; + for (unsigned dim = 0; dim < numLoops; ++dim) { + bool isReduction = + iteratorTypes[dim] == utils::IteratorType::reduction; + if (used[dim] == isReduction) + return rewriter.notifyMatchFailure( + generic, "submap output collisions do not agree with " + "Linalg reduction iterators"); + if (!isReduction) + retainedLoops.push_back(dim); + } + if (submap.getMap().getNumDims() == retainedLoops.size()) + continue; + + MLIRContext *ctx = generic.getContext(); + SmallVector loopReplacements( + numLoops, getAffineConstantExpr(0, ctx)); + SmallVector outputResults; + SmallVector reducedSizes; + SmallVector reducedShape; + ValueRange oldSizes = submap.getSizes(); + for (auto [newDim, loopDim] : llvm::enumerate(retainedLoops)) { + if (loopToView[loopDim] < 0 || + static_cast(loopToView[loopDim]) >= oldSizes.size()) + return rewriter.notifyMatchFailure( + generic, "cannot recover a size for a retained output loop"); + loopReplacements[loopDim] = getAffineDimExpr(newDim, ctx); + outputResults.push_back(getAffineDimExpr(loopDim, ctx)); + Value size = oldSizes[loopToView[loopDim]]; + reducedSizes.push_back(size); + auto constant = getConstantIndex(size); + reducedShape.push_back(constant ? *constant : ShapedType::kDynamic); + } + + SmallVector reducedBaseResults; + for (AffineExpr result : composed.getResults()) + reducedBaseResults.push_back( + result.replaceDimsAndSymbols(loopReplacements, {})); + AffineMap reducedSubmapMap = AffineMap::get( + retainedLoops.size(), 0, reducedBaseResults, ctx); + AffineMap outputIndexingMap = + AffineMap::get(numLoops, 0, outputResults, ctx); + auto oldType = cast(submap.getType()); + auto reducedType = MemRefType::get(reducedShape, + oldType.getElementType()); + work.push_back({operand.getOperandNumber(), submap, + reducedSubmapMap, outputIndexingMap, + std::move(reducedSizes), reducedType}); + } + if (work.empty()) + return failure(); + + SmallVector tentativeMaps(maps); + for (WorkItem &item : work) + tentativeMaps[item.operandNumber] = item.outputIndexingMap; + + // Keep Linalg loop-bound inference well-defined: every loop dimension + // must remain represented by at least one operand after composition. + SmallVector covered(numLoops, false); + for (AffineMap map : tentativeMaps) + for (AffineExpr result : map.getResults()) + result.walk([&](AffineExpr expr) { + if (auto dim = expr.dyn_cast()) + if (dim.getPosition() < numLoops) + covered[dim.getPosition()] = true; + }); + if (!llvm::all_of(covered, [](bool value) { return value; })) + return rewriter.notifyMatchFailure( + generic, "submap composition loses a Linalg loop dimension"); + + rewriter.setInsertionPoint(generic); + for (WorkItem &item : work) { + auto reducedSubmap = rewriter.create( + item.submap.getLoc(), item.type, item.submap.getBase(), item.sizes, + item.reducedSubmapMap); + generic->setOperand(item.operandNumber, reducedSubmap.getResult()); + } + generic.setIndexingMapsAttr( + rewriter.getAffineMapArrayAttr(tentativeMaps)); + return success(); + } +}; + +// Rewrites a linalg.generic's submap-defined operands. For each operand +// defined by a polygeist.submap whose map decomposes via +// decomposeMapForLowering: +// - Emit a memref.subview when needed (any offset is non-zero, or any +// base-dim is rank-reduced/broadcast). The subview rank-reduces dead +// base-dims and uses the offsets/sizes from the decomp. +// - Compose the surviving live view-dims into the consumer linalg's +// indexing_map for that operand: the new map's results are +// (perm[live_0], perm[live_1], ...) in original-base-dim order. For +// broadcasts (a view-dim doesn't appear in any live base-dim), the +// consumer linalg simply omits that iter-dim from this operand's map. +struct ComposeSubmapIntoLinalgGeneric + : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(linalg::GenericOp genOp, + PatternRewriter &rewriter) const final { + SmallVector newIndexingMaps(genOp.getIndexingMapsArray()); + struct WorkItem { + unsigned operandIdx; + SubmapOp submap; + DecomposedMap decomp; + bool needsSubview; + }; + SmallVector work; + + for (OpOperand &opd : genOp->getOpOperands()) { + auto submap = opd.get().getDefiningOp(); + if (!submap) continue; + // This rewrite changes a view operand to its base (or memref.subview) + // and is only type-correct for the buffer form. Tensor submaps must be + // materialized by the tensor-specific patterns below; replacing a + // ranked tensor output with its differently-ranked base would leave + // the linalg result type inconsistent with its output operand. + if (!isa(submap.getType()) || + !isa(submap.getBase().getType())) + continue; + auto decomp = decomposeMapForLowering(submap.getMap(), + submap.getSymbols(), + rewriter); + if (!decomp) continue; + work.push_back(WorkItem{opd.getOperandNumber(), submap, *decomp, + /*needsSubview=*/false}); + } + if (work.empty()) return failure(); + + // Decide which work items need a subview. A subview is needed for any + // operand that has rank-reducing dead base-dims (broadcasts / fixed + // offsets) or non-zero offsets. Additionally, if ANY operand in the + // group needs one, force a subview for all of them so iter-bounds are + // consistent across the linalg. + bool anyNeeds = false; + for (auto &w : work) { + // Even at offset zero, replacing a smaller logical view with its full + // base changes the loop bound (for example memref<2xf64> over + // memref<10xf64>). Preserve such extents with a real subview. + if (hasAnyNonZeroOffset(w.decomp) || + w.submap.getType() != w.submap.getBase().getType()) { + anyNeeds = true; + break; + } + } + for (auto &w : work) + w.needsSubview = anyNeeds; + + // Build the new indexing_map for each operand upfront so we can + // validate iter-dim coverage before any IR mutation. The new map's + // results are, per live base-dim in order, d_(view_dim). + MLIRContext *ctx = genOp.getContext(); + SmallVector tentativeMaps(newIndexingMaps); + for (auto &w : work) { + SmallVector liveResults; + for (const auto &b : w.decomp.base) { + if (!b.live) continue; + liveResults.push_back(getAffineDimExpr(b.viewDim, ctx)); + } + AffineMap permMap = AffineMap::get( + w.submap.getMap().getNumDims(), 0, liveResults, ctx); + tentativeMaps[w.operandIdx] = + permMap.compose(tentativeMaps[w.operandIdx]); + } + unsigned numIterDims = genOp.getNumLoops(); + SmallVector dimCovered(numIterDims, false); + for (AffineMap m : tentativeMaps) { + for (AffineExpr e : m.getResults()) { + e.walk([&](AffineExpr sub) { + if (auto d = sub.dyn_cast()) + if (d.getPosition() < numIterDims) + dimCovered[d.getPosition()] = true; + }); + } + } + for (bool b : dimCovered) + if (!b) return failure(); + + // Apply the rewrite. + for (auto &w : work) { + Value newOperand; + if (w.needsSubview) { + OpBuilder::InsertionGuard g(rewriter); + rewriter.setInsertionPointAfter(w.submap); + auto baseTy = cast(w.submap.getBase().getType()); + ValueRange submapSizes = w.submap.getSizes(); + SmallVector offsets, sizes, strides; + OpFoldResult oneAttr = rewriter.getIndexAttr(1); + SmallVector resultShape; + for (const auto &b : w.decomp.base) { + offsets.push_back(b.offset); + if (b.live) { + if (b.viewDim >= submapSizes.size()) return failure(); + sizes.push_back(submapSizes[b.viewDim]); + resultShape.push_back(ShapedType::kDynamic); + } else { + sizes.push_back(oneAttr); + // dead base-dim — gets rank-reduced. + } + strides.push_back(oneAttr); + } + MemRefType subTy = cast( + memref::SubViewOp::inferRankReducedResultType( + resultShape, baseTy, offsets, sizes, strides)); + auto subview = rewriter.create( + w.submap.getLoc(), subTy, w.submap.getBase(), offsets, sizes, + strides); + newOperand = subview.getResult(); + } else { + newOperand = w.submap.getBase(); + } + genOp->setOperand(w.operandIdx, newOperand); + } + genOp.setIndexingMapsAttr(rewriter.getAffineMapArrayAttr(tentativeMaps)); + return success(); + } +}; + +// Lower polygeist.submap on a memref result, when the affine map has symbols, +// to an equivalent memref.subview. Each map result expression must be of one +// of the supported shapes: +// - a pure DimExpr `d_k` (identity slice on that view-dim) +// - a pure SymbolExpr `s_k` (fixed offset, rank-reduced dim) +// - `s_k + d_j` (or `d_j + s_k`) (offset + identity stride along view-dim j) +// +// More complex expressions (multiplications by constants, multiple symbols in +// one expression, etc.) are unsupported and the pattern fails. The current +// raise pass produces only these shapes for symbol-bearing submaps. +struct LowerSymbolBearingSubmapToSubview : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(SubmapOp submap, + PatternRewriter &rewriter) const final { + AffineMap submapMap = submap.getMap(); + auto outTy = dyn_cast(submap.getResult().getType()); + auto baseTy = dyn_cast(submap.getBase().getType()); + if (!outTy || !baseTy) return failure(); + if (submapMap.getNumResults() != (unsigned)baseTy.getRank()) + return failure(); + // Skip cases ComposeSubmapIntoLinalgGeneric handles (pure DimExpr results + // with no symbols). Anything with symbols, constants, or dim+constant + // shifts falls here. + bool anyNonPureDim = false; + for (AffineExpr e : submapMap.getResults()) { + if (!e.isa()) { anyNonPureDim = true; break; } + } + if (submapMap.getNumSymbols() == 0 && !anyNonPureDim) return failure(); + + Location loc = submap.getLoc(); + ValueRange symbols = submap.getSymbols(); + ValueRange sizes = submap.getSizes(); + unsigned numViewDims = submapMap.getNumDims(); + + // Parse each result expression of the submap's map. For each base-dim k, + // determine (offset_k, size_k, stride_k) AND whether this base-dim is + // contributed by a view-dim (i.e., it must appear in the output of the + // subview) or is symbol-fixed (rank-reduced). + SmallVector offsets, subSizes, strides; + // Track, for each view-dim, which base-dim it maps to (or -1). + SmallVector viewDimToBaseDim(numViewDims, -1); + + OpFoldResult zeroAttr = rewriter.getIndexAttr(0); + OpFoldResult oneAttr = rewriter.getIndexAttr(1); + + // Helper: classify each result expr into (offset, has-view-dim?, view-dim-idx). + auto classify = [&](AffineExpr e, OpFoldResult &offset, bool &hasViewDim, + unsigned &viewDim) -> bool { + // Pure SymbolExpr: fixed offset, no view-dim. + if (auto s = e.dyn_cast()) { + unsigned si = s.getPosition(); + if (si >= symbols.size()) return false; + offset = symbols[si]; + hasViewDim = false; + return true; + } + // Pure ConstantExpr: static offset, no view-dim. + if (auto c = e.dyn_cast()) { + offset = rewriter.getIndexAttr(c.getValue()); + hasViewDim = false; + return true; + } + // Pure DimExpr: identity slice, view-dim present, offset 0. + if (auto d = e.dyn_cast()) { + unsigned di = d.getPosition(); + if (di >= numViewDims) return false; + offset = zeroAttr; + hasViewDim = true; + viewDim = di; + return true; + } + // AffineBinaryOp Add: combinations of (Symbol|Constant) + Dim. + if (auto add = e.dyn_cast()) { + if (add.getKind() != AffineExprKind::Add) return false; + AffineExpr lhs = add.getLHS(); + AffineExpr rhs = add.getRHS(); + AffineExpr dimSide; + AffineExpr offExpr; + if (lhs.isa()) { + dimSide = lhs; offExpr = rhs; + } else if (rhs.isa()) { + dimSide = rhs; offExpr = lhs; + } else { + return false; + } + unsigned di = dimSide.cast().getPosition(); + if (di >= numViewDims) return false; + // Offset side: must be a SymbolExpr or a ConstantExpr. + if (auto s = offExpr.dyn_cast()) { + unsigned si = s.getPosition(); + if (si >= symbols.size()) return false; + offset = symbols[si]; + } else if (auto c = offExpr.dyn_cast()) { + offset = rewriter.getIndexAttr(c.getValue()); + } else { + return false; + } + hasViewDim = true; + viewDim = di; + return true; + } + return false; + }; + + for (unsigned k = 0; k < submapMap.getNumResults(); ++k) { + AffineExpr e = submapMap.getResult(k); + OpFoldResult offset; + bool hasViewDim; + unsigned viewDim = 0; + if (!classify(e, offset, hasViewDim, viewDim)) return failure(); + offsets.push_back(offset); + if (hasViewDim) { + if (viewDim >= sizes.size()) return failure(); + subSizes.push_back(sizes[viewDim]); + strides.push_back(oneAttr); + viewDimToBaseDim[viewDim] = k; + } else { + subSizes.push_back(oneAttr); + strides.push_back(oneAttr); + } + } + + // Verify every view-dim is represented exactly once. If a view-dim isn't + // represented in any output expression, this is a broadcast — handle in + // a separate pass. + for (unsigned j = 0; j < numViewDims; ++j) + if (viewDimToBaseDim[j] == -1) return failure(); + + // The output rank must equal the count of view-dim-bearing base-dims. + // Otherwise the shape can't be expressed via a single rank-reducing + // subview — bail. + unsigned dimBearingBaseDims = 0; + for (int64_t bk : viewDimToBaseDim) + if (bk != -1) ++dimBearingBaseDims; + if (dimBearingBaseDims != numViewDims) return failure(); + + SmallVector resultShape(numViewDims, ShapedType::kDynamic); + + MemRefType inferredTy = cast( + memref::SubViewOp::inferRankReducedResultType( + resultShape, baseTy, offsets, subSizes, strides)); + + // A polygeist.submap's logical result type does not always encode the + // physical stride selected from the base. For example, fixing the last + // component of an [..., 3] coordinate tensor and varying the preceding + // dimension produces stride 3, which cannot be memref.cast to an + // identity-layout memref. Leave those maps in semantic submap form for + // the general affine lowering instead of constructing invalid IR. + if (inferredTy != outTy && + !memref::CastOp::areCastCompatible(inferredTy, outTy)) + return failure(); + + Value sub = rewriter.create( + loc, inferredTy, submap.getBase(), offsets, subSizes, strides); + + // If the inferred type matches the submap's result type exactly, we can + // RAUW. Otherwise we need a cast. + if (sub.getType() == outTy) { + rewriter.replaceOp(submap, sub); + return success(); + } + Value casted = rewriter.create(loc, outTy, sub); + rewriter.replaceOp(submap, casted); + return success(); + } +}; + +// Tensor variant of polygeist.submap is handled by replacing with +// tensor.extract_slice (analogous to memref.subview). +struct LowerSymbolBearingSubmapToExtractSlice + : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(SubmapOp submap, + PatternRewriter &rewriter) const final { + AffineMap submapMap = submap.getMap(); + auto outTy = dyn_cast(submap.getResult().getType()); + auto baseTy = dyn_cast(submap.getBase().getType()); + if (!outTy || !baseTy) return failure(); + if (submapMap.getNumResults() != (unsigned)baseTy.getRank()) + return failure(); + + SmallVector identityInverseUsers; + for (Operation *user : submap->getUsers()) { + auto inv = dyn_cast(user); + if (!inv) + continue; + if (stripTensorCasts(inv.getBaseOriginal()) != + stripTensorCasts(submap.getBase())) + continue; + if (inv.getMap() != submap.getMap()) + continue; + if (!sameTrailingOperands(submap->getOperands().drop_front(1), + inv->getOperands().drop_front(2))) + continue; + identityInverseUsers.push_back(inv); + } + if (!identityInverseUsers.empty()) { + for (SubmapInverseOp inv : identityInverseUsers) + rewriter.replaceOp(inv, submap.getBase()); + if (submap->use_empty()) + rewriter.eraseOp(submap); + return success(); + } + + bool anyNonPureDim = false; + for (AffineExpr e : submapMap.getResults()) { + if (!e.isa()) { anyNonPureDim = true; break; } + } + if (submapMap.getNumSymbols() == 0 && !anyNonPureDim && + outTy.getRank() <= baseTy.getRank()) { + // The stage pipeline frequently leaves exact identity views around + // scratch tensors after a neighboring library launch has consumed the + // inverse. Eliminate the type-identical case directly so cleanup does + // not depend on the broad canonicalizer (which may fold rank-expanding + // DPS output views through linalg.generic incorrectly). + if (submapMap.isIdentity() && submap.getBase().getType() == outTy) { + rewriter.replaceOp(submap, submap.getBase()); + return success(); + } + return failure(); + } + + Location loc = submap.getLoc(); + ValueRange symbols = submap.getSymbols(); + ValueRange sizes = submap.getSizes(); + unsigned numViewDims = submapMap.getNumDims(); + + // Do not represent a rank-expanding DPS output view as tensor.expand_shape. + // Canonicalizing that reshape through linalg.generic can replace the + // output operand with its rank-1 base while leaving the generic's ranked + // result unchanged. The generic materialization path below preserves a + // type-consistent logical output tensor and is also the right semantics + // for reading an existing accumulator before an `Y += contraction` stage. + bool isLinalgDpsOutput = llvm::any_of( + submap->getUses(), [&](OpOperand &use) { + auto generic = dyn_cast(use.getOwner()); + return generic && + use.getOperandNumber() >= generic.getNumDpsInputs(); + }); + + if (!isLinalgDpsOutput && baseTy.getRank() == 1 && + outTy.getRank() == (int64_t)numViewDims) { + auto staticSizes = getStaticSizeOperands(sizes); + if (staticSizes && isRowMajorLinearizedMap(submapMap, *staticSizes) && + !baseTy.isDynamicDim(0) && + baseTy.getDimSize(0) == product(*staticSizes)) { + int64_t flatSize = product(*staticSizes); + // A row-major address map proves that the view itself is contiguous; + // it does not prove that it covers the entire flat base. Casting a + // dynamic tensor<...> base to tensor used to truncate + // partial views (and could create an invalid tensor<100> -> + // tensor<25> cast). Use the reshape fast path only when full coverage + // is statically proven; the generic materialization below handles + // partial/dynamic bases. + auto staticBaseTy = + RankedTensorType::get({flatSize}, baseTy.getElementType()); + Value baseForExpand = submap.getBase(); + if (baseForExpand.getType() != staticBaseTy) + baseForExpand = + rewriter.create(loc, staticBaseTy, baseForExpand); + + auto staticOutTy = + RankedTensorType::get(*staticSizes, baseTy.getElementType()); + auto reassociation = getSingleSourceReassociation(numViewDims); + Value expanded = rewriter.create( + loc, staticOutTy, baseForExpand, reassociation); + if (expanded.getType() != outTy) + expanded = rewriter.create(loc, outTy, expanded); + rewriter.replaceOp(submap, expanded); + return success(); + } + } + + if (submapMap.getNumSymbols() == 0 && + outTy.getRank() == (int64_t)numViewDims && + outTy.getRank() > baseTy.getRank()) { + auto mixedSizes = getMixedSizeOperands(sizes, numViewDims, rewriter); + if (mixedSizes) { + Value empty = rewriter.create( + loc, *mixedSizes, outTy.getElementType()); + AffineMap outMap = + AffineMap::getMultiDimIdentityMap(numViewDims, submap.getContext()); + SmallVector indexingMaps{submapMap, outMap}; + SmallVector iteratorTypes( + numViewDims, utils::IteratorType::parallel); + SmallVector resultTypes{empty.getType()}; + auto generic = rewriter.create( + loc, TypeRange(resultTypes), ValueRange{submap.getBase()}, + ValueRange{empty}, indexingMaps, iteratorTypes, + [&](OpBuilder &nested, Location nestedLoc, ValueRange args) { + nested.create(nestedLoc, args[0]); + }); + Value result = generic->getResult(0); + if (result.getType() != outTy) + result = rewriter.create(loc, outTy, result); + rewriter.replaceOp(submap, result); + return success(); + } + } + + SmallVector offsets, subSizes, strides; + SmallVector viewDimToBaseDim(numViewDims, -1); + OpFoldResult zeroAttr = rewriter.getIndexAttr(0); + OpFoldResult oneAttr = rewriter.getIndexAttr(1); + + auto classify = [&](AffineExpr e, OpFoldResult &offset, bool &hasViewDim, + unsigned &viewDim, OpFoldResult &stride) -> bool { + if (auto s = e.dyn_cast()) { + unsigned si = s.getPosition(); + if (si >= symbols.size()) return false; + offset = symbols[si]; + hasViewDim = false; + stride = oneAttr; + return true; + } + if (auto c = e.dyn_cast()) { + offset = rewriter.getIndexAttr(c.getValue()); + hasViewDim = false; + stride = oneAttr; + return true; + } + unsigned di; + int64_t strideInt; + int64_t offsetInt; + if (parseSingleDimConstantStride(e, numViewDims, di, strideInt, + offsetInt)) { + offset = rewriter.getIndexAttr(offsetInt); + hasViewDim = true; + viewDim = di; + stride = rewriter.getIndexAttr(strideInt); + return true; + } + if (auto d = e.dyn_cast()) { + unsigned di = d.getPosition(); + if (di >= numViewDims) return false; + offset = zeroAttr; + hasViewDim = true; + viewDim = di; + stride = oneAttr; + return true; + } + if (auto add = e.dyn_cast()) { + if (add.getKind() != AffineExprKind::Add) return false; + AffineExpr lhs = add.getLHS(), rhs = add.getRHS(); + AffineExpr dimSide; + AffineExpr offExpr; + if (lhs.isa()) { + dimSide = lhs; offExpr = rhs; + } else if (rhs.isa()) { + dimSide = rhs; offExpr = lhs; + } else { + return false; + } + unsigned di = dimSide.cast().getPosition(); + if (di >= numViewDims) return false; + if (auto s = offExpr.dyn_cast()) { + unsigned si = s.getPosition(); + if (si >= symbols.size()) return false; + offset = symbols[si]; + } else if (auto c = offExpr.dyn_cast()) { + offset = rewriter.getIndexAttr(c.getValue()); + } else { + return false; + } + hasViewDim = true; + viewDim = di; + stride = oneAttr; + return true; + } + return false; + }; + + for (unsigned k = 0; k < submapMap.getNumResults(); ++k) { + AffineExpr e = submapMap.getResult(k); + OpFoldResult offset; + bool hasViewDim; + unsigned viewDim = 0; + OpFoldResult stride = oneAttr; + if (!classify(e, offset, hasViewDim, viewDim, stride)) return failure(); + offsets.push_back(offset); + if (hasViewDim) { + if (viewDim >= sizes.size()) return failure(); + subSizes.push_back(sizes[viewDim]); + strides.push_back(stride); + viewDimToBaseDim[viewDim] = k; + } else { + subSizes.push_back(oneAttr); + strides.push_back(oneAttr); + } + } + for (unsigned j = 0; j < numViewDims; ++j) + if (viewDimToBaseDim[j] == -1) return failure(); + unsigned dimBearingBaseDims = 0; + for (int64_t bk : viewDimToBaseDim) + if (bk != -1) ++dimBearingBaseDims; + if (dimBearingBaseDims != numViewDims) return failure(); + + SmallVector resultShape(numViewDims, ShapedType::kDynamic); + auto inferredTy = RankedTensorType::get(resultShape, baseTy.getElementType()); + Value sliced = rewriter.create( + loc, inferredTy, submap.getBase(), offsets, subSizes, strides); + if (sliced.getType() == outTy) { + rewriter.replaceOp(submap, sliced); + return success(); + } + Value casted = rewriter.create(loc, outTy, sliced); + rewriter.replaceOp(submap, casted); + return success(); + } +}; + +// Lower polygeist.submapInverse on tensors to tensor.insert_slice. +// For memref form, submapInverse is conceptually a no-op (modifications are +// already in place via the view) — we replace it with its base operand. +struct LowerSubmapInverse : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(SubmapInverseOp inv, + PatternRewriter &rewriter) const final { + Value base = inv.getBaseOriginal(); + Value view = inv.getViewModified(); + + if (isa(inv.getType())) { + // For memref, the view's writes have already mutated the base. The + // submapInverse simply returns the base. + rewriter.replaceOp(inv, base); + return success(); + } + + auto outTy = dyn_cast(inv.getType()); + auto baseTy = dyn_cast(base.getType()); + auto viewTy = dyn_cast(view.getType()); + if (!outTy || !baseTy || !viewTy) return failure(); + + AffineMap m = inv.getMap(); + if (m.getNumResults() != (unsigned)baseTy.getRank()) return failure(); + + Location loc = inv.getLoc(); + ValueRange symbols = inv.getSymbols(); + unsigned numViewDims = m.getNumDims(); + ValueRange sizes = + inv.getOperands().slice(m.getNumSymbols() + 2, numViewDims); + auto staticSizes = getStaticSizeOperands(sizes); + + if (baseTy.getRank() == 1 && viewTy.getRank() == (int64_t)numViewDims) { + if (staticSizes && isRowMajorLinearizedMap(m, *staticSizes) && + !baseTy.isDynamicDim(0) && + baseTy.getDimSize(0) == product(*staticSizes)) { + auto staticViewTy = + RankedTensorType::get(*staticSizes, viewTy.getElementType()); + Value viewForCollapse = view; + if (viewForCollapse.getType() != staticViewTy) + viewForCollapse = + rewriter.create(loc, staticViewTy, + viewForCollapse); + + int64_t flatSize = product(*staticSizes); + // Contiguity is not full-base coverage. In particular, writing the + // first 32 elements of a dynamic 64-element application output must + // retain the untouched suffix for a later +32 view. Fall through to + // affine write-back unless the base extent is statically identical. + auto staticOutTy = + RankedTensorType::get({flatSize}, viewTy.getElementType()); + auto reassociation = getSingleSourceReassociation(numViewDims); + Value collapsed = rewriter.create( + loc, staticOutTy, viewForCollapse, reassociation); + if (collapsed.getType() != outTy) + collapsed = rewriter.create(loc, outTy, collapsed); + rewriter.replaceOp(inv, collapsed); + return success(); + } + } + + bool projectedDimsAreUnit = false; + if (staticSizes && numViewDims > (unsigned)baseTy.getRank()) { + projectedDimsAreUnit = llvm::all_of( + ArrayRef(*staticSizes).drop_front(baseTy.getRank()), + [](int64_t size) { return size == 1; }); + } + if (numViewDims > (unsigned)baseTy.getRank() && projectedDimsAreUnit && + viewTy.getRank() == (int64_t)numViewDims && + isLeadingDimProjection(m, baseTy.getRank())) { + SmallVector offsets, sliceSizes, strides; + offsets.reserve(numViewDims); + sliceSizes.reserve(numViewDims); + strides.reserve(numViewDims); + OpFoldResult zeroAttr = rewriter.getIndexAttr(0); + OpFoldResult oneAttr = rewriter.getIndexAttr(1); + for (unsigned i = 0; i < numViewDims; ++i) { + offsets.push_back(zeroAttr); + if (i < (unsigned)baseTy.getRank()) { + if (i >= sizes.size()) + return failure(); + sliceSizes.push_back(sizes[i]); + } else { + sliceSizes.push_back(oneAttr); + } + strides.push_back(oneAttr); + } + SmallVector resultShape(baseTy.getRank(), + ShapedType::kDynamic); + auto sliceTy = RankedTensorType::get(resultShape, viewTy.getElementType()); + Value sliced = rewriter.create( + loc, sliceTy, view, offsets, sliceSizes, strides); + if (sliced.getType() != outTy) + sliced = rewriter.create(loc, outTy, sliced); + rewriter.replaceOp(inv, sliced); + return success(); + } + + // A general affine submap is not necessarily a rectangular slice. For + // example, a rank-4 view of one component of a flattened vector may have + // row-major strides within each element but a gap between elements. Such + // maps cannot be represented by tensor.insert_slice after collapsing the + // view. Preserve their exact semantics with an elementwise affine + // write-back. One-shot bufferization subsequently turns the loop-carried + // tensor into indexed stores, so this is a correctness fallback rather + // than a new runtime abstraction. + auto lowerElementwiseAffineWriteback = [&]() -> LogicalResult { + if (viewTy.getRank() != (int64_t)numViewDims || + sizes.size() != numViewDims) + return failure(); + if (!staticSizes) + return rewriter.notifyMatchFailure( + inv, "affine write-back injectivity is unknown for dynamic sizes"); + std::optional isInjective = + isInjectiveOnStaticDomain(m, *staticSizes); + if (!isInjective || !*isInjective) + return rewriter.notifyMatchFailure( + inv, "affine write-back map is not proven injective"); + + Value zero = rewriter.create(loc, 0); + Value one = rewriter.create(loc, 1); + SmallVector inductionVars; + + auto emitLoopNest = [&](auto &&self, unsigned depth, + Value destination) -> Value { + auto loop = rewriter.create( + loc, zero, sizes[depth], one, ValueRange{destination}); + if (!loop.getBody()->empty()) + rewriter.eraseOp(loop.getBody()->getTerminator()); + + OpBuilder::InsertionGuard guard(rewriter); + rewriter.setInsertionPointToStart(loop.getBody()); + inductionVars.push_back(loop.getInductionVar()); + + Value updated; + if (depth + 1 < numViewDims) { + updated = self(self, depth + 1, loop.getRegionIterArg(0)); + } else { + Value element = rewriter.create( + loc, view, inductionVars); + SmallVector mapOperands(inductionVars.begin(), + inductionVars.end()); + mapOperands.append(symbols.begin(), symbols.end()); + SmallVector baseIndices; + baseIndices.reserve(m.getNumResults()); + for (AffineExpr resultExpr : m.getResults()) { + AffineMap resultMap = AffineMap::get( + m.getNumDims(), m.getNumSymbols(), resultExpr, + rewriter.getContext()); + baseIndices.push_back(rewriter.create( + loc, resultMap, mapOperands)); + } + updated = rewriter.create( + loc, element, loop.getRegionIterArg(0), baseIndices); + } + + inductionVars.pop_back(); + rewriter.create(loc, updated); + return loop.getResult(0); + }; + + if (numViewDims == 0) + return failure(); + Value result = emitLoopNest(emitLoopNest, 0, base); + rewriter.replaceOp(inv, result); + return success(); + }; + + SmallVector offsets, subSizes, strides; + SmallVector viewDimSeen(numViewDims, 0); + OpFoldResult zeroAttr = rewriter.getIndexAttr(0); + OpFoldResult oneAttr = rewriter.getIndexAttr(1); + + auto classify = [&](AffineExpr e, OpFoldResult &offset, bool &hasViewDim, + unsigned &viewDim, OpFoldResult &stride) -> bool { + if (auto s = e.dyn_cast()) { + unsigned si = s.getPosition(); + if (si >= symbols.size()) return false; + offset = symbols[si]; + hasViewDim = false; + stride = oneAttr; + return true; + } + if (auto c = e.dyn_cast()) { + offset = rewriter.getIndexAttr(c.getValue()); + hasViewDim = false; + stride = oneAttr; + return true; + } + unsigned di; + int64_t strideInt; + int64_t offsetInt; + if (parseSingleDimConstantStride(e, numViewDims, di, strideInt, + offsetInt)) { + offset = rewriter.getIndexAttr(offsetInt); + hasViewDim = true; + viewDim = di; + stride = rewriter.getIndexAttr(strideInt); + return true; + } + if (auto d = e.dyn_cast()) { + unsigned di = d.getPosition(); + if (di >= numViewDims) return false; + offset = zeroAttr; + hasViewDim = true; + viewDim = di; + stride = oneAttr; + return true; + } + if (auto add = e.dyn_cast()) { + if (add.getKind() != AffineExprKind::Add) return false; + AffineExpr lhs = add.getLHS(), rhs = add.getRHS(); + AffineExpr dimSide; + AffineExpr offExpr; + if (lhs.isa()) { + dimSide = lhs; offExpr = rhs; + } else if (rhs.isa()) { + dimSide = rhs; offExpr = lhs; + } else { + return false; + } + unsigned di = dimSide.cast().getPosition(); + if (di >= numViewDims) return false; + if (auto s = offExpr.dyn_cast()) { + unsigned si = s.getPosition(); + if (si >= symbols.size()) return false; + offset = symbols[si]; + } else if (auto c = offExpr.dyn_cast()) { + offset = rewriter.getIndexAttr(c.getValue()); + } else { + return false; + } + hasViewDim = true; + viewDim = di; + stride = oneAttr; + return true; + } + return false; + }; + + for (unsigned k = 0; k < m.getNumResults(); ++k) { + AffineExpr e = m.getResult(k); + OpFoldResult offset; + bool hasViewDim; + unsigned viewDim = 0; + OpFoldResult stride = oneAttr; + if (!classify(e, offset, hasViewDim, viewDim, stride)) + return lowerElementwiseAffineWriteback(); + offsets.push_back(offset); + if (hasViewDim) { + if (viewDim >= sizes.size()) + return lowerElementwiseAffineWriteback(); + subSizes.push_back(sizes[viewDim]); + strides.push_back(stride); + viewDimSeen[viewDim] = 1; + } else { + subSizes.push_back(oneAttr); + strides.push_back(oneAttr); + } + } + for (unsigned j = 0; j < numViewDims; ++j) + if (!viewDimSeen[j]) + return lowerElementwiseAffineWriteback(); + + // If the view's rank differs from the slice's rank (because of symbol- + // only base-dims that rank-reduced on the way in), we need to reshape + // the view to match. For now we only support the case where view's rank + // equals the count of dim-bearing base-dims. + unsigned numDimBearingBaseDims = 0; + for (unsigned k = 0; k < m.getNumResults(); ++k) + if (!m.getResult(k).isa()) + ++numDimBearingBaseDims; + if (numDimBearingBaseDims != (unsigned)viewTy.getRank()) + return lowerElementwiseAffineWriteback(); + + Value result = rewriter.create( + loc, view, base, offsets, subSizes, strides); + rewriter.replaceOp(inv, result); + return success(); + } +}; + +struct LowerPolygeistSubmapPass + : public mlir::polygeist::LowerPolygeistSubmapBase< + LowerPolygeistSubmapPass> { + void getDependentDialects(DialectRegistry ®istry) const override { + registry.insert(); + } + + void runOnOperation() override { + RewritePatternSet patterns(&getContext()); + patterns.add(&getContext()); + if (failed(applyPatternsAndFoldGreedily(getOperation(), + std::move(patterns)))) { + // Some submaps remain — caller may want to know but it's not fatal. + } + } +}; + +} // anonymous namespace + +namespace mlir { +namespace polygeist { +std::unique_ptr createLowerPolygeistSubmapPass() { + return std::make_unique(); +} +} // namespace polygeist +} // namespace mlir diff --git a/lib/polygeist/Passes/RaiseToLinalg.cpp b/lib/polygeist/Passes/RaiseToLinalg.cpp index 254d3a11881b..9c5eb92cd1a7 100644 --- a/lib/polygeist/Passes/RaiseToLinalg.cpp +++ b/lib/polygeist/Passes/RaiseToLinalg.cpp @@ -1,21 +1,30 @@ #include "PassDetails.h" #include "mlir/Dialect/Affine/IR/AffineOps.h" -#include "mlir/Dialect/MemRef/IR/MemRef.h" +#include "mlir/Dialect/Affine/Passes.h" #include "mlir/Dialect/Arith/IR/Arith.h" -#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h" +#include "mlir/Dialect/Linalg/IR/Linalg.h" +#include "mlir/Dialect/Math/IR/Math.h" +#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/Transforms/Passes.h" +#include "mlir/IR/AffineExpr.h" #include "mlir/IR/Dominance.h" #include "mlir/IR/IRMapping.h" #include "mlir/IR/Operation.h" +#include "mlir/Pass/PassManager.h" #include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h" +#include "mlir/Transforms/Passes.h" #include "polygeist/Passes/Passes.h" #include "llvm/Support/Debug.h" -#include "mlir/IR/AffineExpr.h" +#include "llvm/ADT/StringSwitch.h" + +#include +#include +#include #define DEBUG_TYPE "raise-to-linalg" @@ -23,175 +32,2343 @@ using namespace mlir; using namespace mlir::arith; using namespace polygeist; using namespace affine; - -namespace { -struct RaiseAffineToLinalg : public AffineRaiseToLinalgBase { - void runOnOperation() override; +using namespace linalg; + +// Normalize the side-effect-free C libm calls emitted by Clang/cgeist into +// MLIR Math operations before analyzing loop purity. A generic func.call has +// unknown memory effects, so otherwise an entirely pointwise loop such as +// load -> cosf -> store cannot be raised even though the operation is pure. +// Keep the mapping explicit: only standardized functions with exact Math +// dialect counterparts are assigned read-none semantics here. +struct KnownLibmCallToMath : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(func::CallOp call, + PatternRewriter &rewriter) const final { + if (call.getNumResults() != 1) + return failure(); + StringRef callee = call.getCallee(); + auto baseName = callee; + if (!call.getOperands().empty() && + call.getOperand(0).getType().isF32() && baseName.ends_with("f")) + baseName = baseName.drop_back(); + + auto unary = [&](auto opTag) -> LogicalResult { + using OpTy = decltype(opTag); + if (call.getNumOperands() != 1 || + !isa(call.getOperand(0).getType()) || + call.getResult(0).getType() != call.getOperand(0).getType()) + return failure(); + rewriter.replaceOpWithNewOp(call, call.getOperand(0)); + return success(); + }; + auto binary = [&](auto opTag) -> LogicalResult { + using OpTy = decltype(opTag); + if (call.getNumOperands() != 2 || + !isa(call.getOperand(0).getType()) || + call.getOperand(1).getType() != call.getOperand(0).getType() || + call.getResult(0).getType() != call.getOperand(0).getType()) + return failure(); + rewriter.replaceOpWithNewOp( + call, call.getOperand(0), call.getOperand(1)); + return success(); + }; + + if (baseName == "atan") return unary(math::AtanOp()); + if (baseName == "cbrt") return unary(math::CbrtOp()); + if (baseName == "ceil") return unary(math::CeilOp()); + if (baseName == "cos") return unary(math::CosOp()); + if (baseName == "erf") return unary(math::ErfOp()); + if (baseName == "exp") return unary(math::ExpOp()); + if (baseName == "exp2") return unary(math::Exp2Op()); + if (baseName == "expm1") return unary(math::ExpM1Op()); + if (baseName == "fabs") return unary(math::AbsFOp()); + if (baseName == "floor") return unary(math::FloorOp()); + if (baseName == "log") return unary(math::LogOp()); + if (baseName == "log10") return unary(math::Log10Op()); + if (baseName == "log1p") return unary(math::Log1pOp()); + if (baseName == "log2") return unary(math::Log2Op()); + if (baseName == "round") return unary(math::RoundOp()); + if (baseName == "sin") return unary(math::SinOp()); + if (baseName == "sqrt") return unary(math::SqrtOp()); + if (baseName == "tan") return unary(math::TanOp()); + if (baseName == "tanh") return unary(math::TanhOp()); + if (baseName == "trunc") return unary(math::TruncOp()); + if (baseName == "atan2") return binary(math::Atan2Op()); + if (baseName == "copysign") return binary(math::CopySignOp()); + if (baseName == "pow") return binary(math::PowFOp()); + return failure(); + } }; -} // namespace -// Also want to add support for affine.for ( ) { linalg.generic } -> bigger linalg.generic -// Also probably want to try to do { linalg.generc1(); linalg.generic2(); } -> bigger linalg.generic() +static bool isKnownPureScalarLibmCall(Operation *op) { + auto call = dyn_cast(op); + if (!call || call.getNumResults() != 1 || call.getNumOperands() == 0) + return false; + auto isScalar = [](Type type) { + return isa(type); + }; + if (isScalar(call.getResult(0).getType()) && + llvm::all_of(call.getOperandTypes(), isScalar)) + if (auto declaration = SymbolTable::lookupNearestSymbolFrom( + call, call.getCalleeAttr())) + if (declaration->hasAttr("polygeist.pure")) + return true; + if (call.getNumOperands() > 2 || + !isa(call.getResult(0).getType())) + return false; + if (!llvm::all_of(call.getOperandTypes(), [](Type type) { + return isa(type); + })) + return false; + StringRef name = call.getCallee(); + if (call.getOperand(0).getType().isF32() && name.ends_with("f")) + name = name.drop_back(); + // ISO C/POSIX libm functions that are pure with respect to program memory. + // Floating-point exception flags are not modeled as memory effects in the + // source IR, matching MLIR Math operation semantics. + return llvm::StringSwitch(name) + .Cases("acos", "acosh", "asin", "asinh", true) + .Cases("atan", "atan2", "atanh", "cbrt", true) + .Cases("ceil", "copysign", "cos", "cosh", true) + .Cases("erf", "erfc", "exp", "exp2", true) + .Cases("expm1", "fabs", "floor", "fma", true) + .Cases("fmax", "fmin", "fmod", "hypot", true) + .Cases("ldexp", "lgamma", "log", "log10", true) + .Cases("log1p", "log2", "nextafter", "pow", true) + .Cases("remainder", "round", "sin", "sinh", true) + .Cases("sqrt", "tan", "tanh", "trunc", true) + .Default(false); +} + +// Also want to add support for affine.for ( ) { linalg.generic } -> bigger +// linalg.generic Also probably want to try to do { linalg.generc1(); +// linalg.generic2(); } -> bigger linalg.generic() /* affine.for() { affine.for() { - } + } affine.for() { } } */ struct Condition { - bool ifTrue; - AffineIfOp op; - Condition(bool ifTrue, AffineIfOp op) : ifTrue(ifTrue), op(op) {} + bool ifTrue; + AffineIfOp op; + Condition(bool ifTrue, AffineIfOp op) : ifTrue(ifTrue), op(op) {} }; bool isLinearInIndex(AffineExpr expr, size_t idx) { - if (!expr.isFunctionOfDim(idx)) { - return true; + if (!expr.isFunctionOfDim(idx)) { + return true; + } + + if (expr.getKind() == AffineExprKind::DimId) { + return true; + } + + if (expr.getKind() == AffineExprKind::Add) { + auto binop = expr.cast(); + return isLinearInIndex(binop.getLHS(), idx) && + isLinearInIndex(binop.getRHS(), idx); + } + if (expr.getKind() == AffineExprKind::Mul) { + auto binop = expr.cast(); + return (isLinearInIndex(binop.getLHS(), idx) && + !binop.getRHS().isFunctionOfDim(idx)) || + (isLinearInIndex(binop.getRHS(), idx) && + !binop.getLHS().isFunctionOfDim(idx)); + } + + return false; +} + +bool isLinearInIndex(AffineMap map, size_t idx) { + for (auto expr : map.getResults()) { + if (!isLinearInIndex(expr, idx)) + return false; + } + return true; +} + +AffineExpr shiftDimsDown1(AffineExpr expr, unsigned numDims, unsigned offset) { + SmallVector dims; + for (unsigned idx = 0; idx < offset; ++idx) + dims.push_back(getAffineDimExpr(idx, expr.getContext())); + for (unsigned idx = offset; idx < numDims; ++idx) + dims.push_back(getAffineDimExpr(idx - 1, expr.getContext())); + return expr.replaceDimsAndSymbols(dims, {}); +} + +// This is reducing the number of input dims in expression by 1 +AffineMap shiftDimsDown1(AffineMap expr, unsigned numDim, unsigned offset) { + assert(offset <= expr.getNumDims()); + return AffineMap::get(expr.getNumDims() - 1, expr.getNumSymbols(), + llvm::map_to_vector<4>(expr.getResults(), + [&](AffineExpr e) { + return shiftDimsDown1( + e, expr.getNumDims(), + offset); + }), + expr.getContext()); +} + +// Helper function to check if an operation dominates the target region +bool dominatesTarget(Operation* op, Region* targetRegion) { + return op->getParentRegion()->isAncestor(targetRegion); +} + +Value recursiveCloneWithDominanceCheck( + OpBuilder& builder, + Value value, + Region* targetRegion, + IRMapping& mapping, + DenseSet& processedOps) { + + // If value is already mapped, return the mapped value + if (mapping.contains(value)) { + return mapping.lookup(value); + } + + // Handle block arguments + if (auto blockArg = dyn_cast(value)) { + if (blockArg.getParentBlock()->getParent()->isAncestor(targetRegion)) { + mapping.map(value, value); + return value; + } else { + llvm::errs() << "Non-dominating block argument encountered\n"; + return nullptr; + } + } + + Operation* defOp = value.getDefiningOp(); + if (!defOp) { + return value; + } + + // Check if this operation dominates the target region + if (dominatesTarget(defOp, targetRegion)) { + // Operation dominates, use it directly + mapping.map(value, value); + return value; + } + + // Avoid processing the same operation multiple times + if (processedOps.contains(defOp)) { + // Operation was already processed, should be in mapping + auto resultNum = cast(value).getResultNumber(); + auto mappedOp = mapping.lookup(defOp->getResult(0)).getDefiningOp(); + auto clonedValue = mappedOp->getResult(resultNum); + mapping.map(value, clonedValue); + return clonedValue; + } + + // Check if operation is safe to clone + if (!isReadOnly(defOp)) { + llvm::errs() << "Cannot clone non-read-only operation: " << *defOp << "\n"; + return nullptr; + } + + processedOps.insert(defOp); + + // Recursively process ALL operands first to populate the mapping + for (Value operand : defOp->getOperands()) { + Value clonedOperand = recursiveCloneWithDominanceCheck( + builder, operand, targetRegion, mapping, processedOps); + if (!clonedOperand) { + return nullptr; + } + // clonedOperand is automatically added to mapping by recursive call } + + // Now clone the operation using the populated mapping + Operation* clonedOp = builder.clone(*defOp, mapping); + + // The clone automatically maps all results, so we can just return what we need + auto resultNum = cast(value).getResultNumber(); + return clonedOp->getResult(resultNum); +} - if (expr.getKind() == AffineExprKind::DimId) { - return true; +// Check if the affine apply is a constant and return the constant value +std::optional getConstantFromAffineApply(AffineApplyOp applyOp) { + AffineMap map = applyOp.getAffineMap(); + + // Must have no dimensions and no symbols + if (map.getNumDims() != 0 || map.getNumSymbols() != 0) { + return std::nullopt; + } + + // Must have exactly one result that is a constant + if (map.getNumResults() != 1) { + return std::nullopt; + } + + // Check if the single result is a constant expression + AffineExpr result = map.getResult(0); + if (auto constExpr = result.dyn_cast()) { + return constExpr.getValue(); + } + + return std::nullopt; +} + +// Given an affine map `oldmap`, memref `val`, and corresponding input values +// (which are a list of indicies, then symbols), and a set of loop indices +// `indices` produce the following: +// 1. A (potentially new) memref value `newval` which does not have any +// dependence on `indices` +// and +// 2. an affine map `newmap` which takes size(indices) values (`indices`) and +// produces indices into `newval` such that +// indexing `newval[map(indices)]` produces the same result as indexing the +// original map. +// check_reduction is set true, when passed from store/linalg.generic's output +// variable. And it is returned true, only if index was not encountered in +// oldmap operands and check_reduction was set true. +Value remap_in_affine_dim(bool &legal, OpBuilder &builder, AffineMap oldmap, + Value memref_val, Value index, Value bound, AffineApplyOp lower_bound, + int firstNDims, ValueRange oldmap_operands, + Value origmemref, bool &check_reduction, + bool projectUnusedInnerDims = false) { + + LLVM_DEBUG(llvm::dbgs() << "\n=== remap_in_affine_dim ===\n"); + LLVM_DEBUG(llvm::dbgs() << " oldmap: " << oldmap << "\n"); + LLVM_DEBUG(llvm::dbgs() << " firstNDims: " << firstNDims << "\n"); + LLVM_DEBUG(llvm::dbgs() << " check_reduction (input): " << check_reduction << "\n"); + + int lower_bound_val = getConstantFromAffineApply(lower_bound).value_or(0); + LLVM_DEBUG(llvm::dbgs() << " lower_bound_val: " << lower_bound_val << "\n"); + + assert(oldmap_operands.size() == + oldmap.getNumSymbols() + oldmap.getNumDims()); + // Operands which don't correspond to indices + SmallVector operands_without_indices; + ssize_t dimidx = -1; + for (auto [i, v] : llvm::enumerate(oldmap_operands)) { + if (v == nullptr) { + assert(i < firstNDims); + continue; + } + assert(i >= firstNDims); + if (v != index) { + // Check if the symbol value is read-only or defined in a scope where it + // is always visible. + if (auto ba = dyn_cast(v)) { + // check if it dominates the current scope + if (ba.getParentBlock()->getParent()->isAncestor( + builder.getBlock()->getParent())) + operands_without_indices.push_back(v); + else { + assert(false); + legal = false; + return nullptr; + } + } else { + auto op = v.getDefiningOp(); + // check if this dominates the current scope + if (op->getParentRegion()->isAncestor( + builder.getBlock()->getParent())) { + operands_without_indices.push_back(v); + } else if (isReadOnly(op)) { + // if not, check if it is readnone + // Technically this isn't quite sufficient yet, and does require that + // the operands to this op are also able to be hoisted, but for now we + // will assume this + auto op2 = builder.clone(*op); + operands_without_indices.push_back( + op2->getResult(cast(v).getResultNumber())); + } else { + // if so clone it in the right scope + // otherwise set illegal and don't continue + assert(false); + legal = false; + return nullptr; + } + } + } else + dimidx = i; + } + if ((dimidx == -1) && (check_reduction)) + check_reduction = true; + else + check_reduction = false; + + LLVM_DEBUG(llvm::dbgs() << " dimidx: " << dimidx << "\n"); + LLVM_DEBUG(llvm::dbgs() << " check_reduction (output): " << check_reduction << "\n"); + + // Raising an outer loop around an existing linalg.generic prepends a new + // iterator dimension: old `linalg.index 0` becomes index 1, etc. Keep the + // submap in that same logical order. Previously this appended the new + // dimension after the existing inner dimensions, which made lowered + // im2col-style layouts use `(w, h, c)` storage while the body used + // `(c, h, w)` indices. + SmallVector retainedInnerDims; + if (projectUnusedInnerDims) { + for (unsigned i = 0; i < static_cast(firstNDims); ++i) + if (oldmap.isFunctionOfDim(i)) + retainedInnerDims.push_back(i); + auto originalType = dyn_cast(origmemref.getType()); + if (!originalType || + retainedInnerDims.size() != + static_cast(originalType.getRank())) { + legal = false; + return nullptr; + } + } + + SmallVector dimReplacements; + size_t validSims = 0; + size_t nextInnerDim = 1; + AffineExpr newLoopDim = + builder.getAffineDimExpr(0) + builder.getAffineConstantExpr(lower_bound_val); + for (int i = 0; i < oldmap.getNumDims(); i++) { + if (i < firstNDims) { + assert(i != dimidx); + if (!projectUnusedInnerDims || oldmap.isFunctionOfDim(i)) { + dimReplacements.push_back(builder.getAffineDimExpr(nextInnerDim)); + nextInnerDim++; + } else { + // This dimension is a reduction iterator omitted by the output's + // indexing map. Its replacement is immaterial because it cannot + // occur in any result expression; use d0 to keep the replacement list + // total while leaving it out of the projected view rank. + dimReplacements.push_back(builder.getAffineDimExpr(0)); + } + } else if (i == dimidx) { + dimReplacements.push_back(newLoopDim); + } else { + // TODO: Why are we using symbol here instead of dim? + dimReplacements.push_back(builder.getAffineSymbolExpr(validSims)); + validSims++; + } + } + + SmallVector symReplacements; + for (int i = 0; i < oldmap.getNumSymbols(); i++) { + if (i + oldmap.getNumDims() == dimidx) { + symReplacements.push_back(newLoopDim); + } else { + symReplacements.push_back(builder.getAffineSymbolExpr(validSims)); + validSims++; + } + } + if (validSims != operands_without_indices.size()) { + llvm::errs() << " oldmap: " << oldmap << "\n"; + llvm::errs() << " dimidx=" << dimidx << "\n"; + llvm::errs() << " index: " << index << "\n"; + llvm::errs() << " oldmap_operands: size=" << oldmap_operands.size() + << "\n"; + for (auto op : oldmap_operands) { + if (op) { + llvm::errs() << " -" << op << " &" << op.getAsOpaquePointer() << "\n"; + } else { + llvm::errs() << " -" + << "null" + << " &nullptr\n"; + } + } + llvm::errs() << " validSims: " << validSims << "\n"; + llvm::errs() << " operands_without_indices: size=" + << operands_without_indices.size() << "\n"; + for (auto op : operands_without_indices) { + llvm::errs() << " -" << op << " &" << op.getAsOpaquePointer() << "\n"; + } + } + assert(validSims == operands_without_indices.size()); + auto map2 = oldmap.replaceDimsAndSymbols(dimReplacements, symReplacements, + (projectUnusedInnerDims + ? retainedInnerDims.size() + : firstNDims) + + 1/*Number of dims in new map*/, + operands_without_indices.size() /*Number of symbols in new map*/); + + LLVM_DEBUG(llvm::dbgs() << " new map (map2): " << map2 << "\n"); + LLVM_DEBUG(llvm::dbgs() << " nextInnerDim: " << nextInnerDim + << ", validSims: " << validSims << "\n"); + + SmallVector idx_sizes; + idx_sizes.push_back(bound); + size_t oldViewRank = projectUnusedInnerDims + ? retainedInnerDims.size() + : static_cast(firstNDims); + for (size_t i = 0; i < oldViewRank; i++) { + // memref.dimOp captures the size of the memref + if (auto submap = origmemref.getDefiningOp()) + idx_sizes.push_back(submap.getSizes()[i]); + else + llvm_unreachable("Won't reach this case"); + // idx_sizes.push_back(builder.create(origmemref.getLoc(), + // origmemref, i)); + } + + legal = true; + SmallVector sizes(idx_sizes.size(), mlir::ShapedType::kDynamic); + for (auto sz : idx_sizes) { + DenseSet processedOps; + IRMapping mapping; + auto clonedOp = recursiveCloneWithDominanceCheck(builder, sz, builder.getBlock()->getParent(), mapping, processedOps); + if (!clonedOp) { + legal = false; + return nullptr; + } + operands_without_indices.push_back(clonedOp); + } + + //for (auto sz : idx_sizes) { + // // Check if the symbol value is read-only or defined in a scope where it is + // // always visible. + // if (auto ba = dyn_cast(sz)) { + // // check if it dominates the current scope + // if (ba.getParentBlock()->getParent()->isAncestor( + // builder.getBlock()->getParent())) + // operands_without_indices.push_back(sz); + // else { + // llvm::errs() << " value is a non-dominating block arg: " << sz << "\n"; + // legal = false; + // assert(false); + // return nullptr; + // } + // } else { + // auto op = sz.getDefiningOp(); + // // check if this dominates the current scope + // if (op->getParentRegion()->isAncestor(builder.getBlock()->getParent())) { + // operands_without_indices.push_back(sz); + // } else if (isReadOnly(op)) { + // // if not, check if it is readnone + // // Technically this isn't quite sufficient yet, and does require that + // // the operands to this op are also able to be hoisted, but for now we + // // will assume this + // // We need to clone the op along and check if it's operands are dominating or not, else do a recursive clone + // auto op2 = builder.clone(*op); + // operands_without_indices.push_back( + // op2->getResult(cast(sz).getResultNumber())); + // } else { + // llvm::errs() << " op is not readonly: " << *op << "\n"; + // // if so clone it in the right scope + // // otherwise set illegal and don't continue + // legal = false; + // assert(false); + // return nullptr; + // } + // } + //} + auto ty = MemRefType::get( + sizes, cast(memref_val.getType()).getElementType()); + + ////TODO: Can we have a case where stride is not 1? + //Value stride = builder.create(memref_val.getLoc(), 1); + + //// Create a subview op using lower bound, stride and size + //// Convert AffineApplyOp to its result Value and wrap in ValueRange + //Value lowerBoundValue = lower_bound.getResult(); + //auto subViewOp = builder.create( + // memref_val.getLoc(), // Location + // memref_val, // Source memref + // ValueRange{lowerBoundValue}, // Offsets (array) + // ValueRange{bound}, // Sizes (array) + // ValueRange{stride} // Strides (array) + //); + + //Value subview = subViewOp.getResult(); + + auto result = builder.create( + memref_val.getLoc(), ty, memref_val, operands_without_indices, map2); + + LLVM_DEBUG(llvm::dbgs() << " Created SubmapOp with type: " << ty << "\n"); + LLVM_DEBUG(llvm::dbgs() << "=== remap_in_affine_dim END ===\n\n"); + + return result; +} + +// store A[...] +// val = load A[...] + +/* prevA : + store A + val is now prevA +*/ + +/* + +f(%memref ) + +%memref = ... + +affine.for { + + %inp = .. subview %memref [ ... ] + + linalg.generic %inp #map { + body() + } +} + + +-> + + +affine.for j { + + linalg.generic %memref #map2(j) { + body() + } +} + + + + +#map2 = #map with the indexing done to %inp + + + + + +%memref = .. subview %memref_base [ ... ] + +linalg.generic %[[[memref]]] [[[[#map]]]]([[[[operands]]]]) { + body() +} + +-> + + +output_memref = memref_base +output_map = subvmap() + + compose +# uts are memref, map, and operands +# outputs are o +memref[map(operands)] ==== output_memref[output_map(output_operands)] + + + +bas= memref<40x40> + +B + +u + +tput_memref, output_map and output_operands +# possible intermediate is ... + +getLinalgArgMap(memref, map, operands to map [e.g. input symbols/dims]) + if memref is alloca/unknown/etc + return memref/map/operands + else + memref = subview memref_base[map2(operands2)] + + return memref_base and a new output_map such that + memref_base[output_map(output_operands)] === memref[map(operands)] + + + + + +*/ + +// Suppose we have a memref expression E=input[affine.map(operands)] +// if input = memref.subview A[starts, offsets] +// can we rewrite E as A[affine.map2(operands2)] +// We update lgMap and lgOperands in place with this coresponding map2 and +// operands2 +LogicalResult getLinalgArgMap(Operation *loop, Value &input, AffineMap &lgMap, + SmallVector &lgOperands) { + OpBuilder builder(loop->getContext()); + + LLVM_DEBUG(llvm::dbgs() << "\n=== getLinalgArgMap ===\n"); + LLVM_DEBUG(llvm::dbgs() << " Initial lgMap: " << lgMap << "\n"); + + while (Operation *defOp = input.getDefiningOp()) { + + assert(lgOperands.size() == lgMap.getNumSymbols() + lgMap.getNumDims()); + // If the input is defined outside of the loop, we are finished. + if (!loop->isAncestor(defOp)) { + LLVM_DEBUG(llvm::dbgs() << " Input defined outside loop, breaking\n"); + break; + } + + if (auto SM = dyn_cast(defOp)) { + auto submap = SM.getMap(); + + LLVM_DEBUG(llvm::dbgs() << " Found SubmapOp with map: " << submap << "\n"); + + // TODO: Do we achieve anything with this compose? + // As lgMap in our case is 1 to 1 identity map + auto composeMap = submap.compose(lgMap); + + LLVM_DEBUG(llvm::dbgs() << " Composed map: " << composeMap << "\n"); + + SmallVector operands0; + + // First the dims + for (size_t i = 0; i < lgMap.getNumDims(); i++) + operands0.push_back(lgOperands[i]); + + // Then the symbols of submap + for (size_t i = 0; i < submap.getNumSymbols(); i++) + operands0.push_back(SM.getSymbols()[i]); + + // Then the symbols of lgMap + for (size_t i = 0; i < lgMap.getNumSymbols(); i++) + operands0.push_back(lgOperands[i + lgMap.getNumDims()]); + + lgMap = composeMap; + lgOperands = operands0; + input = SM.getBase(); + assert(lgOperands.size() == lgMap.getNumSymbols() + lgMap.getNumDims()); + continue; + } + + // if (auto SV = dyn_cast(defOp)) { + + // // TODO update map with the new indexing from here + + // // Create affine map + // // i. Track number of running dims and symbols + // // ii. shift dims and symbols to generate shifted expressions. + // // Extract corresponding operands + // // Use affineMap::get with numOperands and numSymbols along with shifted + // // expressions to get a map. Use affine map simplify to simplify this + + // SmallVector startExprs; + // SmallVector strideExprs; + // SmallVector dimOperands; + // SmallVector symOperands; + // for (auto &&[first, second] : llvm::zip(SV.getOffsets(), + // SV.getStrides())) { + // for (auto &&[index, val] : llvm::enumerate(SmallVector({first, + // second}))) { + // auto &exprOutput = (index == 0) ? startExprs : strideExprs; + // // Only support constants, symbols, or affine apply as offsets + // if (auto cop = val.getDefiningOp()) { + // exprOutput.push_back(builder.getAffineConstantExpr(cop.value())); + // continue; + // } else if (auto cop = val.getDefiningOp()) { + // exprOutput.push_back(builder.getAffineConstantExpr(cop.value())); + // continue; + // } + // if (auto ba = dyn_cast(val)) { + // Block *parentBlock = ba.getOwner(); + // if (isa(parentBlock->getParentOp())) { + // exprOutput.push_back( + // builder.getAffineDimExpr(dimOperands.size())); + // dimOperands.push_back(ba); + // continue; + + // } + // } + + // auto valOp = val.getDefiningOp(); + // // Defined outside loop, consider it a symbol [for now] + // //if (!valOp || loop->isAncestor(defOp)) { + // if (valOp&&!loop->isAncestor(defOp)) { + // exprOutput.push_back( + // builder.getAffineSymbolExpr(symOperands.size())); + // symOperands.push_back(val); + // continue; + // } + + // //TODO: Maybe it's a case to add, but are we sure we need it for + // starts and offsets + // // and not for operands + // if (auto apply = dyn_cast(valOp)) { + // auto map = apply.getAffineMap(); + // auto *scope = affine::getAffineScope(valOp)->getParentOp(); + // DominanceInfo DI(scope); + // auto map_operands = apply.getOperands(); + // //fully2ComposeAffineMapAndOperands(builder, &map, &map_operands, + // DI); + //// Instead of using loop step we are using 1 (Assumption as the stride + /// size) + // auto newexpr = map.shiftDims(dimOperands.size()) + // .shiftSymbols(symOperands.size()); + + // for (auto expr : newexpr.getResults()) { + // exprOutput.push_back(expr); + // } + + // for (size_t i = 0; i < map.getNumDims(); i++) + // dimOperands.push_back(apply.getOperands()[i]); + + // for (size_t i = 0; i < map.getNumSymbols(); i++) + // symOperands.push_back(apply.getOperands()[i + + // map.getNumDims()]); + + // continue; + // } + + // //return failure(); + // } + // } + + // SmallVector inputExprs; + // for (auto expr : lgMap.shiftDims(dimOperands.size()) + // .shiftSymbols(symOperands.size()).getResults()) { + // inputExprs.push_back(expr); + // } + // for (size_t i = 0; i < lgMap.getNumDims(); i++) + // dimOperands.push_back(lgOperands[i]); + + // for (size_t i = 0; i < lgMap.getNumSymbols(); i++) + // symOperands.push_back(lgOperands[i + lgMap.getNumDims()]); + + // SmallVector mergedExprs; + // for (auto && [start, stride, idx] : + // llvm::zip(startExprs, strideExprs, inputExprs)) { + // mergedExprs.push_back(start + idx * stride); + // } + + // lgMap = + // AffineMap::get(dimOperands.size(), symOperands.size(), mergedExprs, + // loop->getContext()); + // lgOperands.clear(); + // lgOperands.insert(lgOperands.begin(), dimOperands.begin(), + // dimOperands.end()); + // lgOperands.insert(lgOperands.begin()+lgOperands.size(), + // symOperands.begin(), symOperands.end()); input = SV.getSource(); break; + //} + + // return failure(); + } + assert(lgOperands.size() == lgMap.getNumSymbols() + lgMap.getNumDims()); + + LLVM_DEBUG(llvm::dbgs() << " Final lgMap: " << lgMap << "\n"); + LLVM_DEBUG(llvm::dbgs() << "=== getLinalgArgMap END ===\n\n"); + + return success(); +} + +//===----------------------------------------------------------------------===// +// Group C — distribute an affine.for whose body has multiple "chunks" +// (each linalg.generic and each nested affine.for is a chunk). +// +// Match precondition: either +// (a) the loop was promoted from an affine.parallel (so it carries +// `polygeist.was_parallel`) — iterations are independent, so it's legal +// to run all of chunk-1 across iterations, then all of chunk-2, etc.; or +// (b) the loop is sequential but cross-chunk fission is provably safe: every +// root memref shared across multiple chunks (with at least one writer) +// is indexed by the outer IV in the same composed dim across all of +// those chunks. The check below builds an AccessInfo per +// affine.load/store, memref.load/store, and linalg.generic operand (via +// the polygeist.submap chain) and verifies the iv-binding consistency. +// +// After this rewrite each new sibling loop has a homogeneous body that +// AffineForOpRaising can handle. +//===----------------------------------------------------------------------===// + +namespace { +struct AccessInfo { + Value rootMemref; + // Root-dim positions that are bound to the outer IV via identity (same SSA + // value as the outer IV appears as the dim operand / submap symbol that + // feeds this root-dim). + SmallVector ivBoundRootDims; + bool isWrite; +}; + +// For a memref value reached by an access (the direct memref of an affine +// load/store, or the linalg.generic operand which is typically a submap), +// follow at most one polygeist.submap layer to the root, and compute which +// root-dim positions are bound to `outerIV` via identity (a single dim/symbol +// expression that names `outerIV`). Returns std::nullopt if the structure is +// too complex to analyze conservatively (chained submaps, non-trivial +// expressions involving the IV, etc.) — caller must treat that as unsafe. +static std::optional analyzeAccessThroughSubmap( + Value memref, AffineMap accessMap, ValueRange accessOperands, bool isWrite, + Value outerIV) { + AccessInfo info; + info.isWrite = isWrite; + + if (auto submap = memref.getDefiningOp()) { + // Chained submaps require full composition; bail conservatively for now. + if (submap.getBase().getDefiningOp()) + return std::nullopt; + info.rootMemref = submap.getBase(); + AffineMap m = submap.getMap(); + ValueRange syms = submap.getSymbols(); + // Each result of `m` is one root-dim. If it names symbol s and syms[s] is + // the outer IV, mark this root-dim as iv-bound. + for (unsigned d = 0, e = m.getNumResults(); d < e; ++d) { + AffineExpr expr = m.getResult(d); + if (auto sym = expr.dyn_cast()) { + unsigned sIdx = sym.getPosition(); + if (sIdx < syms.size() && syms[sIdx] == outerIV) + info.ivBoundRootDims.push_back(d); + } + // Any non-trivial expression involving outerIV: if expr references a + // symbol whose binding is outerIV but isn't a pure SymbolExpr, treat as + // unanalyzable. + else { + bool referencesIv = false; + expr.walk([&](AffineExpr sub) { + if (auto s = sub.dyn_cast()) { + unsigned sIdx = s.getPosition(); + if (sIdx < syms.size() && syms[sIdx] == outerIV) + referencesIv = true; + } + }); + if (referencesIv) return std::nullopt; + } } + return info; + } - if (expr.getKind() == AffineExprKind::Add) { - auto binop = expr.cast(); - return isLinearInIndex(binop.getLHS(), idx) && isLinearInIndex(binop.getRHS(), idx); + // Direct memref access via affine map. + if (!accessMap) return std::nullopt; + info.rootMemref = memref; + for (unsigned d = 0, e = accessMap.getNumResults(); d < e; ++d) { + AffineExpr expr = accessMap.getResult(d); + if (auto dim = expr.dyn_cast()) { + unsigned dIdx = dim.getPosition(); + if (dIdx < accessOperands.size() && accessOperands[dIdx] == outerIV) + info.ivBoundRootDims.push_back(d); + } else { + bool referencesIv = false; + expr.walk([&](AffineExpr sub) { + if (auto dimSub = sub.dyn_cast()) { + unsigned dIdx = dimSub.getPosition(); + if (dIdx < accessOperands.size() && accessOperands[dIdx] == outerIV) + referencesIv = true; } - if (expr.getKind() == AffineExprKind::Mul) { - auto binop = expr.cast(); - return (isLinearInIndex(binop.getLHS(), idx) && !binop.getRHS().isFunctionOfDim(idx)) || - (isLinearInIndex(binop.getRHS(), idx) && !binop.getLHS().isFunctionOfDim(idx)); + }); + if (referencesIv) return std::nullopt; + } + } + return info; +} + +// Walk a chunk's ops (transitively, into nested regions) and collect +// AccessInfo for every memref access op. Returns false if any access is +// unanalyzable (caller must bail). +static bool collectChunkAccesses(ArrayRef chunk, Value outerIV, + SmallVectorImpl &out) { + bool unanalyzable = false; + auto visit = [&](Operation *op) { + if (auto load = dyn_cast(op)) { + auto info = analyzeAccessThroughSubmap( + load.getMemref(), load.getAffineMap(), + ValueRange(load.getMapOperands()), /*isWrite=*/false, outerIV); + if (!info) { unanalyzable = true; return WalkResult::interrupt(); } + out.push_back(*info); + } else if (auto store = dyn_cast(op)) { + auto info = analyzeAccessThroughSubmap( + store.getMemref(), store.getAffineMap(), + ValueRange(store.getMapOperands()), /*isWrite=*/true, outerIV); + if (!info) { unanalyzable = true; return WalkResult::interrupt(); } + out.push_back(*info); + } else if (auto load = dyn_cast(op)) { + AccessInfo info; + info.rootMemref = load.getMemref(); + info.isWrite = false; + for (unsigned d = 0, e = load.getIndices().size(); d < e; ++d) + if (load.getIndices()[d] == outerIV) + info.ivBoundRootDims.push_back(d); + out.push_back(info); + } else if (auto store = dyn_cast(op)) { + AccessInfo info; + info.rootMemref = store.getMemref(); + info.isWrite = true; + for (unsigned d = 0, e = store.getIndices().size(); d < e; ++d) + if (store.getIndices()[d] == outerIV) + info.ivBoundRootDims.push_back(d); + out.push_back(info); + } else if (auto generic = dyn_cast(op)) { + for (Value input : generic.getInputs()) { + auto info = analyzeAccessThroughSubmap(input, AffineMap(), ValueRange(), + /*isWrite=*/false, outerIV); + if (!info) { unanalyzable = true; return WalkResult::interrupt(); } + out.push_back(*info); + } + for (Value output : generic.getOutputs()) { + auto info = analyzeAccessThroughSubmap(output, AffineMap(), ValueRange(), + /*isWrite=*/true, outerIV); + if (!info) { unanalyzable = true; return WalkResult::interrupt(); } + out.push_back(*info); + } + } + // SubmapOp setup and read-none arith are not accesses themselves. + return WalkResult::advance(); + }; + for (Operation *op : chunk) { + op->walk(visit); + if (unanalyzable) return false; + } + return true; +} + +// For each shared root memref across chunks with at least one writer, every +// access from any chunk that touches it must (a) bind the outer IV to at +// least one root-dim, and (b) bind it to the same dim-set across chunks. +// Otherwise distributing reorders cross-iteration accesses to address-overlapping +// cells. +static bool +chunksDistributionSafe(ArrayRef> chunks, + Value outerIV) { + SmallVector, 4> perChunk(chunks.size()); + for (unsigned i = 0; i < chunks.size(); ++i) { + if (!collectChunkAccesses(chunks[i], outerIV, perChunk[i])) { + LLVM_DEBUG(llvm::dbgs() + << "Distribute REJECTED: unanalyzable access in chunk " << i + << "\n"); + return false; + } + } + for (unsigned p = 0; p < chunks.size(); ++p) { + for (unsigned q = p + 1; q < chunks.size(); ++q) { + for (const AccessInfo &accP : perChunk[p]) { + for (const AccessInfo &accQ : perChunk[q]) { + if (accP.rootMemref != accQ.rootMemref) continue; + if (!accP.isWrite && !accQ.isWrite) continue; + if (accP.ivBoundRootDims.empty() || accQ.ivBoundRootDims.empty()) { + LLVM_DEBUG(llvm::dbgs() << "Distribute REJECTED: shared memref " + "access not bound to outer IV\n"); + return false; + } + if (accP.ivBoundRootDims != accQ.ivBoundRootDims) { + LLVM_DEBUG(llvm::dbgs() << "Distribute REJECTED: shared memref " + "binds outer IV to different root-dims " + "across chunks\n"); + return false; + } + } + } + } + } + return true; +} +} // end anonymous namespace + +struct DistributeAffineForOnLinalgGeneric + : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(affine::AffineForOp forOp, + PatternRewriter &rewriter) const final { + bool isParallel = forOp->hasAttr("polygeist.was_parallel"); + // Can't distribute loops with iter_args. + if (forOp.getNumResults() != 0) return failure(); + + Block *body = forOp.getBody(); + if (body->empty()) return failure(); + + // Anchor-based chunking: each side-effecting op (linalg.generic, + // affine.store, memref.store, nested affine.for) is an anchor. Its + // chunk is itself plus the SSA def-use closure of its operands within + // the body. Chunks must be disjoint (no shared deps); body order + // determines emit order. + + // Step 1: collect anchors (in body order). + SmallVector anchors; + for (Operation &op : *body) { + if (isa(op)) continue; + if (isa(op)) + anchors.push_back(&op); + } + if (anchors.size() <= 1) return failure(); + + // Step 2: compute each anchor's SSA dep closure within the body. If two + // anchors share a body-local dependency, we can't cleanly split — fail. + DenseMap opToChunk; + Value iv = forOp.getInductionVar(); + for (unsigned i = 0; i < anchors.size(); ++i) { + SmallVector work; + work.push_back(anchors[i]); + while (!work.empty()) { + Operation *op = work.pop_back_val(); + auto it = opToChunk.find(op); + if (it != opToChunk.end()) { + if (it->second != i) { + LLVM_DEBUG(llvm::dbgs() << "Distribute REJECTED: shared dependency between chunks\n"); + return failure(); + } + continue; } + opToChunk[op] = i; + // Include values captured by nested regions. A linalg.generic body + // can directly reference an SSA value computed in this affine loop + // even though that value is not an operand of the generic op itself. + // Missing this edge allowed fission to clone a generic that still + // referenced a definition inside the soon-to-be-erased old loop. + op->walk([&](Operation *nested) { + for (Value operand : nested->getOperands()) { + if (operand == iv) continue; + Operation *defOp = operand.getDefiningOp(); + if (!defOp) continue; // block arg / function argument + if (defOp->getBlock() != body) continue; + work.push_back(defOp); + } + }); + } + } + + // Step 3: collect chunks by chunkIdx, preserving body order. + SmallVector> chunks(anchors.size()); + for (Operation &op : *body) { + if (isa(op)) continue; + auto it = opToChunk.find(&op); + if (it == opToChunk.end()) { + // Op not reachable from any anchor — pure, dead, or feeds an unknown + // sink. Conservatively bail rather than drop it. + LLVM_DEBUG(llvm::dbgs() << "Distribute REJECTED: op not in any chunk's closure\n"); + return failure(); + } + chunks[it->second].push_back(&op); + } + + // Safety gate: parallel-loop fast path, otherwise cross-chunk dep check. + if (!isParallel && !chunksDistributionSafe(chunks, iv)) { + return failure(); + } + + LLVM_DEBUG(llvm::dbgs() << "Distributing affine.for into " << chunks.size() + << " sibling loops" + << (isParallel ? " (was_parallel)" : " (dep-check)") + << "\n"); + + // For each chunk, clone the affine.for with just that chunk's ops. + rewriter.setInsertionPoint(forOp); + for (auto &chunk : chunks) { + auto newFor = rewriter.create( + forOp.getLoc(), + forOp.getLowerBoundOperands(), forOp.getLowerBoundMap(), + forOp.getUpperBoundOperands(), forOp.getUpperBoundMap(), + forOp.getStep()); + // Only carry the parallel mark forward when the input had it. The + // dep-check fallback path operates on sequential loops; the sibling + // loops it produces are equally sequential. + if (isParallel) + newFor->setAttr("polygeist.was_parallel", rewriter.getUnitAttr()); + + Block *newBody = newFor.getBody(); + // newBody already has a default affine.yield from the builder. + OpBuilder::InsertionGuard g(rewriter); + rewriter.setInsertionPointToStart(newBody); + + IRMapping mapping; + mapping.map(iv, newFor.getInductionVar()); + for (Operation *op : chunk) + rewriter.clone(*op, mapping); + // Leave the builder-inserted affine.yield alone (it terminates the body). + } + + // The distributed chunks are clones, so every SSA value defined by the + // original loop or one of its nested operations is dead now. Explicitly + // sever their internal operand edges before recursive erasure; otherwise + // RewriterBase may visit a defining op before its in-region user and + // assert even though the entire region is being removed. + forOp->dropAllReferences(); + rewriter.eraseOp(forOp); + return success(); + } +}; + +//===----------------------------------------------------------------------===// +// PrivatizeScratchAllocaForLoop +// +// Looks for a 0-D scalar `memref.alloca` (either in an enclosing scope or +// allocated freshly in the loop body) that is used as per-iteration scratch — +// i.e., every iteration starts by overwriting the scalar before reading it, +// and nothing outside the loop reads it after the loop. Expands the alloca +// to `memref` with one slot per loop iteration and rewrites every +// in-loop use to address `new_alloca[iv]` instead of `alloca[]`. +// +// After this rewrite, all accesses to the scratch are bound to the outer +// IV at root-dim 0, which is exactly what the dep-check in +// DistributeAffineForOnLinalgGeneric needs to fire on the loop. +// +// Constraints (kept tight for v1): +// - Loop has constant lb 0 (so `iv` can be used as a direct index). +// - Loop has no iter_args. +// - Alloca type is `memref` (0-D scalar). +// - The first use of the alloca inside the loop body is a write. +// - The alloca has no uses after the loop. +//===----------------------------------------------------------------------===// + +namespace { +// Does this op write to `alloca` without first reading from it? +static bool isInitWriteForScalarAlloca(Operation *op, Value alloca) { + if (auto store = dyn_cast(op)) + return store.getMemref() == alloca; + if (auto store = dyn_cast(op)) + return store.getMemref() == alloca; + return false; +} + +// Find the first use of `alloca` in body order; return null if none. +static Operation *firstUseInBody(Value alloca, Block *body) { + for (Operation &op : *body) + for (Value v : op.getOperands()) + if (v == alloca) return &op; + return nullptr; +} + +// Returns true iff `user` is executed strictly before `loopOp` in the program +// flow, accounting for the possibility that they live in different (but +// nested) blocks. +static bool isBeforeLoopInProgramOrder(Operation *user, Operation *loopOp) { + DenseMap loopBlockToAncestor; + for (Operation *l = loopOp; l; l = l->getParentOp()) + loopBlockToAncestor[l->getBlock()] = l; + for (Operation *u = user; u; u = u->getParentOp()) { + auto it = loopBlockToAncestor.find(u->getBlock()); + if (it == loopBlockToAncestor.end()) continue; + if (u == it->second) return false; // same op — neither before nor after + return u->isBeforeInBlock(it->second); + } + return false; +} + +// Verify the alloca is unused past `loopOp`. +static bool noUsesAfterLoop(Value alloca, Operation *loopOp) { + for (Operation *user : alloca.getUsers()) { + if (loopOp->isAncestor(user)) continue; // inside the loop — fine + if (isBeforeLoopInProgramOrder(user, loopOp)) continue; // before — fine + return false; + } + return true; +} +} // anonymous namespace + +struct PrivatizeScratchAllocaForLoop + : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(affine::AffineForOp forOp, + PatternRewriter &rewriter) const final { + if (forOp.getNumResults() != 0) return failure(); + if (!forOp.hasConstantLowerBound() || forOp.getConstantLowerBound() != 0) + return failure(); + + // We need the loop's iteration count as an SSA Value to size the new + // alloca. For constant ub, materialize a constant; otherwise emit an + // affine.apply at the loop's site. + Block *body = forOp.getBody(); + Value iv = forOp.getInductionVar(); + + // Several reductions in one outer iteration may capture scalar results + // from earlier stages (batch-norm mean -> variance is the canonical + // example). Hoisting their individual scratch buffers is sound, but the + // current fission pass cannot yet materialize that cross-stage SSA value. + // Keep those loops intact until stage-graph materialization handles them. + unsigned directGenerics = llvm::count_if( + body->without_terminator(), + [](Operation &op) { return isa(op); }); + if (directGenerics > 1) + return failure(); + + // Find candidate allocas referenced by the body. An alloca directly in + // this loop body is the canonical C lowering of a private scalar; an + // enclosing alloca is accepted by the original form of this pattern. + SmallVector candidates; + DenseSet seen; + body->walk([&](Operation *op) { + for (Value v : op->getOperands()) { + auto allocaOp = v.getDefiningOp(); + if (!allocaOp) continue; + if (forOp->isAncestor(allocaOp) && allocaOp->getBlock() != body) + continue; // belongs to a deeper nested scope + if (!seen.insert(allocaOp).second) continue; + auto mrt = dyn_cast(allocaOp.getType()); + if (!mrt || mrt.getRank() != 0) continue; + if (allocaOp->getNumOperands() != 0) continue; // dynamic-shape alloca: skip + candidates.push_back(allocaOp); + } + }); + if (candidates.empty()) return failure(); + + // Filter candidates: first in-body use is a write, all in-loop users are + // among the rewriteable set, no uses after loop, and the alloca lives + // in some ancestor block of `forOp` so we can place the sized + // replacement at the same scope (and have AffineForOpRaising later + // lift enclosing loops without dominance issues). + SmallVector good; + for (memref::AllocaOp a : candidates) { + Operation *firstUse = firstUseInBody(a, body); + if (!firstUse) continue; + if (!isInitWriteForScalarAlloca(firstUse, a)) continue; + if (!noUsesAfterLoop(a, forOp)) continue; + bool allHandled = true; + for (Operation *user : a->getUsers()) { + if (!forOp->isAncestor(user)) continue; + if (!isa(user)) { + allHandled = false; + break; + } + } + if (!allHandled) continue; + good.push_back(a); + } + if (good.empty()) return failure(); + + AffineMap idxMap = AffineMap::get(/*dimCount=*/1, /*symCount=*/0, + rewriter.getAffineDimExpr(0), + rewriter.getContext()); + + for (memref::AllocaOp oldAlloca : good) { + // Loop-local scratch must be hoisted immediately before the loop so the + // expanded buffer dominates it. For an already-enclosing allocation, + // retain the original scope and insert before the outermost loop at that + // scope. + Block *allocaBlock = oldAlloca->getBlock(); + Operation *insertionAnchor = forOp.getOperation(); + bool loopLocal = allocaBlock == body; + if (!loopLocal) + while (insertionAnchor && insertionAnchor->getBlock() != allocaBlock) + insertionAnchor = insertionAnchor->getParentOp(); + if (!insertionAnchor) continue; // shouldn't happen given precondition + rewriter.setInsertionPoint(insertionAnchor); + AffineMap ubMap = forOp.getUpperBoundMap(); + Value tripCount; + if (forOp.hasConstantUpperBound()) { + tripCount = rewriter.create( + forOp.getLoc(), forOp.getConstantUpperBound()); + } else { + tripCount = rewriter.create( + forOp.getLoc(), ubMap, + SmallVector(forOp.getUpperBoundOperands())); + } + MemRefType oldTy = cast(oldAlloca.getType()); + auto newTy = MemRefType::get({ShapedType::kDynamic}, oldTy.getElementType()); + auto newAlloca = rewriter.create(oldAlloca.getLoc(), + newTy, tripCount); + + // Rewrite every in-loop use of oldAlloca. + SmallVector users(oldAlloca->getUsers().begin(), + oldAlloca->getUsers().end()); + for (Operation *user : users) { + if (!forOp->isAncestor(user)) continue; + OpBuilder::InsertionGuard g(rewriter); + rewriter.setInsertionPoint(user); + if (auto load = dyn_cast(user)) { + auto newLoad = rewriter.create( + load.getLoc(), newAlloca, idxMap, ValueRange{iv}); + rewriter.replaceOp(load, newLoad.getResult()); + } else if (auto store = dyn_cast(user)) { + rewriter.create( + store.getLoc(), store.getValue(), newAlloca, idxMap, + ValueRange{iv}); + rewriter.eraseOp(store); + } else if (auto load = dyn_cast(user)) { + auto newLoad = rewriter.create( + load.getLoc(), newAlloca, ValueRange{iv}); + rewriter.replaceOp(load, newLoad.getResult()); + } else if (auto store = dyn_cast(user)) { + rewriter.create(store.getLoc(), store.getValue(), + newAlloca, ValueRange{iv}); + rewriter.eraseOp(store); + } else if (auto submap = dyn_cast(user)) { + // Original submap: takes 0-D scalar base + (viewSize) operands + + // 0 symbols. Rewrite to take 1-D base + (iv, viewSize) operands + + // 1 extra symbol (s_iv) that selects new_alloca[iv]. The result + // expression for the inner-most root-dim becomes s_iv; the view + // shape (and hence later linalg semantics) is unchanged. + AffineMap oldMap = submap.getMap(); + unsigned numDims = oldMap.getNumDims(); + unsigned numSyms = oldMap.getNumSymbols(); + // New map has numDims dims, numSyms+1 symbols. s_iv is symbol + // position numSyms. Result is a single expression: s_iv (the + // address into new_alloca). Note: the old map's results were + // 0-rank (no result expressions, since old base was 0-D). The new + // base is 1-D, so the new map has exactly one result. + AffineExpr sIv = rewriter.getAffineSymbolExpr(numSyms); + AffineMap newMap = AffineMap::get(numDims, numSyms + 1, {sIv}, + rewriter.getContext()); + // SubmapOp builder takes (loc, resultType, base, indices_and_sizes, + // map) — indices_and_sizes is [syms..., sizes...]. Append iv as a + // new trailing symbol so it pairs with the new s_iv we added. + SmallVector indicesAndSizes; + for (Value s : submap.getSymbols()) indicesAndSizes.push_back(s); + indicesAndSizes.push_back(iv); + for (Value sz : submap.getSizes()) indicesAndSizes.push_back(sz); + auto newSubmap = rewriter.create( + submap.getLoc(), submap.getType(), newAlloca, indicesAndSizes, + newMap); + rewriter.replaceOp(submap, newSubmap.getResult()); + } else if (auto generic = dyn_cast(user)) { + // A reduction raised before its enclosing output loop commonly + // names the scalar alloca directly as an `outs` operand. Give it a + // rank-zero view selecting this iteration's private slot. + AffineMap scalarMap = AffineMap::get( + /*dimCount=*/0, /*symbolCount=*/1, + {rewriter.getAffineSymbolExpr(0)}, rewriter.getContext()); + auto scalarType = MemRefType::get({}, oldAlloca.getType() + .cast() + .getElementType()); + rewriter.setInsertionPoint(generic); + auto scalarView = rewriter.create( + generic.getLoc(), scalarType, newAlloca, ValueRange{iv}, + scalarMap); + for (OpOperand &operand : generic->getOpOperands()) + if (operand.get() == oldAlloca) + operand.set(scalarView.getResult()); + } else { + // Unhandled user. Bail entire pattern by deleting the new alloca + // and returning failure. + // (Other uses we've already rewritten above will still be live; + // the simplest recovery is to refuse the rewrite up front. Since + // we're inside a greedy driver, returning failure here without a + // clean rollback would leave inconsistent IR. So instead, we + // checked-cast above and bail before any rewrite for unknown + // users.) + // — but for safety: we already early-bailed in the precondition + // pass below. Reaching this should be impossible. + llvm_unreachable("unhandled alloca user in privatization"); + } + } + if (oldAlloca->use_empty()) + rewriter.eraseOp(oldAlloca); + } + + return success(); + } +}; + +//===----------------------------------------------------------------------===// +// PrivatizeRowScratchAllocaForLoop +// +// Rank-1 (1-D row) extension of PrivatizeScratchAllocaForLoop. Recognises +// per-iteration scratch row buffers ("scratch row carries"): an outer +// `affine.for L` has a rank-1 `memref.alloca` (static or dynamic, enclosing or +// loop-local), where each iteration writes the full row before any read and +// nothing outside L observes the buffer. +// +// Canonical example (NPB MG psinv/resid/rprj3): +// %r1 = memref.alloca() : memref<35xf64> // outside both loops +// affine.for %i3 ... { +// affine.for %i2 ... { // <-- L (this pattern) +// affine.for %i1 = 0 to N { affine.store v, %r1[%i1] } // fill +// affine.for %i1 = 1 to N-1 { ... %r1[%i1-1] + %r1[%i1] + %r1[%i1+1] ... } +// } +// } +// Rewrite expands `r1` to `memref` sized by L's trip count +// and emits ONE affine `polygeist.submap` selecting `new[%iv, :]` +// at L's body entry that all in-loop users share. Each iteration of L +// then writes a disjoint slice, the dep check sees no cross-iteration +// conflict, and downstream Distribute / AffineForOpRaising can lift L. +// +// Using submap rather than a dynamic-offset memref.subview keeps the outer-IV +// binding explicit for distribution and avoids introducing a strided view +// type that the affine raiser cannot compose. +//===----------------------------------------------------------------------===// + +namespace { +// Walk `body` recursively in pre-order and return the first op that +// substantively touches `alloca` — reads or writes. View-creation ops +// (memref.subview, polygeist.submap) are skipped because they only +// reshape the address. +static Operation *firstTouchInBody(Value alloca, Region &body) { + Operation *found = nullptr; + body.walk([&](Operation *op) { + if (found) return WalkResult::interrupt(); + if (isa(op)) + return WalkResult::advance(); + for (Value v : op->getOperands()) { + if (v == alloca) { found = op; return WalkResult::interrupt(); } + } + return WalkResult::advance(); + }); + return found; +} + +// Returns true iff `op` writes `alloca` (store / affine.store / a +// linalg.generic that has `alloca` in its `outs`). +static bool isWriteOfAlloca(Operation *op, Value alloca) { + if (auto s = dyn_cast(op)) + return s.getMemref() == alloca; + if (auto s = dyn_cast(op)) + return s.getMemref() == alloca; + if (auto g = dyn_cast(op)) + for (Value o : g.getOutputs()) + if (o == alloca) return true; + return false; +} +} // anonymous namespace + +struct PrivatizeRowScratchAllocaForLoop + : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(affine::AffineForOp forOp, + PatternRewriter &rewriter) const final { + if (forOp.getNumResults() != 0) return failure(); + // Pattern-firing marker: once we've privatized for this loop, don't + // re-fire — the new alloca is rank-2 and wouldn't match anyway, but + // this short-circuits the candidate walk on every greedy re-visit. + if (forOp->hasAttr("polygeist.row_privatized")) return failure(); + + Block *body = forOp.getBody(); + Value iv = forOp.getInductionVar(); + + // Collect rank-1 allocas from the enclosing scope or directly in this + // loop body. Deeper nested allocations belong to their own loop. + SmallVector candidates; + DenseSet seen; + body->walk([&](Operation *op) { + for (Value v : op->getOperands()) { + auto allocaOp = v.getDefiningOp(); + if (!allocaOp) continue; + if (forOp->isAncestor(allocaOp) && allocaOp->getBlock() != body) + continue; + // Do not let an inner loop claim scratch allocated in an enclosing + // loop; that storage is often a row whose individual elements are + // initialized by the inner loop and consumed afterwards. The + // enclosing loop itself will see it as loop-local and privatize it at + // the correct dimension. Function-entry scratch remains supported. + if (allocaOp->getBlock() != body && + !isa(allocaOp->getBlock()->getParentOp())) + continue; + if (!seen.insert(allocaOp).second) continue; + auto mrt = dyn_cast(allocaOp.getType()); + if (!mrt || mrt.getRank() != 1) continue; + candidates.push_back(allocaOp); + } + }); + if (candidates.empty()) return failure(); + + // Helper: innermost-enclosing-loop check. + auto innerContainsAllUses = [&](affine::AffineForOp inner, + Value alloca) -> bool { + for (Operation *user : alloca.getUsers()) + if (!inner->isAncestor(user)) return false; + return true; + }; + + SmallVector good; + for (memref::AllocaOp a : candidates) { + Operation *firstUse = firstTouchInBody(a.getResult(), + forOp.getRegion()); + if (!firstUse) continue; + if (!isWriteOfAlloca(firstUse, a.getResult())) continue; + if (!noUsesAfterLoop(a, forOp)) continue; + + bool allHandled = true; + for (Operation *user : a->getUsers()) { + if (!forOp->isAncestor(user)) continue; + if (!isa(user)) { + allHandled = false; + break; + } + } + if (!allHandled) continue; + + // Innermost-loop check: defer to nested affine.for if it already + // contains every user of alloca. + bool isInnermost = true; + forOp.getBody()->walk([&](affine::AffineForOp inner) { + if (inner == forOp) return WalkResult::advance(); + if (innerContainsAllUses(inner, a.getResult())) { + isInnermost = false; + return WalkResult::interrupt(); + } + return WalkResult::advance(); + }); + if (!isInnermost) continue; + + good.push_back(a); + } + if (good.empty()) return failure(); + + for (memref::AllocaOp oldAlloca : good) { + Block *allocaBlock = oldAlloca->getBlock(); + Operation *insertionAnchor = forOp.getOperation(); + bool loopLocal = allocaBlock == body; + if (!loopLocal) + while (insertionAnchor && insertionAnchor->getBlock() != allocaBlock) + insertionAnchor = insertionAnchor->getParentOp(); + if (!insertionAnchor) continue; + rewriter.setInsertionPoint(insertionAnchor); + + Value tripCount; + if (forOp.hasConstantUpperBound()) { + tripCount = rewriter.create( + forOp.getLoc(), forOp.getConstantUpperBound()); + } else { + tripCount = rewriter.create( + forOp.getLoc(), forOp.getUpperBoundMap(), + SmallVector(forOp.getUpperBoundOperands())); + } + + MemRefType oldTy = cast(oldAlloca.getType()); + int64_t N = oldTy.getShape()[0]; + auto newTy = MemRefType::get({ShapedType::kDynamic, N}, + oldTy.getElementType()); + SmallVector dynamicSizes{tripCount}; + dynamicSizes.append(oldAlloca.getDynamicSizes().begin(), + oldAlloca.getDynamicSizes().end()); + auto newAlloca = rewriter.create( + oldAlloca.getLoc(), newTy, dynamicSizes); + + // ONE submap at forOp's body entry, shared by all in-loop users: + // (d0)[s0] -> (s0, d0), where s0 is the outer iteration. + Value rowView; + { + OpBuilder::InsertionGuard g(rewriter); + rewriter.setInsertionPointToStart(forOp.getBody()); + Value rowSize; + if (oldTy.isDynamicDim(0)) { + rowSize = oldAlloca.getDynamicSizes().front(); + } else { + rowSize = rewriter.create( + oldAlloca.getLoc(), N); + } + AffineExpr d0 = rewriter.getAffineDimExpr(0); + AffineExpr s0 = rewriter.getAffineSymbolExpr(0); + AffineMap rowMap = AffineMap::get(1, 1, {s0, d0}, + rewriter.getContext()); + rowView = rewriter.create( + oldAlloca.getLoc(), oldTy, newAlloca, + ValueRange{iv, rowSize}, rowMap); + } + + // Rewrite every in-loop user. + SmallVector users(oldAlloca->getUsers().begin(), + oldAlloca->getUsers().end()); + for (Operation *user : users) { + if (!forOp->isAncestor(user)) continue; + OpBuilder::InsertionGuard g(rewriter); + rewriter.setInsertionPoint(user); + + if (auto gen = dyn_cast(user)) { + rewriter.startRootUpdate(gen); + for (auto &operand : gen->getOpOperands()) + if (operand.get() == oldAlloca.getResult()) + operand.set(rowView); + rewriter.finalizeRootUpdate(gen); + continue; + } + if (auto sv = dyn_cast(user)) { + auto newSv = rewriter.create( + sv.getLoc(), sv.getType(), rowView, + sv.getMixedOffsets(), sv.getMixedSizes(), sv.getMixedStrides()); + rewriter.replaceOp(sv, newSv.getResult()); + continue; + } + if (auto sm = dyn_cast(user)) { + rewriter.startRootUpdate(sm); + sm->setOperand(0, rowView); + rewriter.finalizeRootUpdate(sm); + continue; + } + if (auto load = dyn_cast(user)) { + rewriter.replaceOp(load, + rewriter.create( + load.getLoc(), rowView, load.getAffineMap(), + load.getMapOperands()).getResult()); + continue; + } + if (auto store = dyn_cast(user)) { + rewriter.create( + store.getLoc(), store.getValue(), rowView, + store.getAffineMap(), store.getMapOperands()); + rewriter.eraseOp(store); + continue; + } + if (auto load = dyn_cast(user)) { + rewriter.replaceOp(load, + rewriter.create( + load.getLoc(), rowView, load.getIndices()).getResult()); + continue; + } + if (auto store = dyn_cast(user)) { + rewriter.create(store.getLoc(), store.getValue(), + rowView, store.getIndices()); + rewriter.eraseOp(store); + continue; + } + llvm_unreachable("unhandled user in row-scratch privatization"); + } + rewriter.eraseOp(oldAlloca); + } + + forOp->setAttr("polygeist.row_privatized", rewriter.getUnitAttr()); + return success(); + } +}; + +// Shift every `linalg.index` op nested in `region` by `shift`. Used when an +// outer loop is being raised and prepends `shift` new iterator dims to an +// inner linalg's iteration space: each existing `linalg.index N` becomes +// `linalg.index N + shift`. +static void shiftLinalgIndexDims(Region ®ion, unsigned shift) { + if (shift == 0) return; + region.walk([&](linalg::IndexOp idxOp) { + idxOp.setDim(idxOp.getDim() + shift); + }); +} + +// Group A — triangular-bound support helpers. +// Returns true iff every operand of `operands` is an SSA value defined strictly +// outside of `loop` (i.e., loop-invariant w.r.t. `loop`). This is the safety +// criterion for using an outer-scope-derived bound as an in-body mask. +static bool allOperandsAreLoopInvariantWrt(ValueRange operands, + affine::AffineForOp loop) { + for (Value v : operands) { + if (Operation *defOp = v.getDefiningOp()) { + if (loop->isAncestor(defOp)) return false; + } else if (auto blockArg = dyn_cast(v)) { + Operation *parent = blockArg.getOwner()->getParentOp(); + if (!parent) return false; + if (parent == loop.getOperation()) return false; + if (loop->isAncestor(parent)) return false; + } else { + return false; + } + } + return true; +} + +// Bound-mask info captured at loop acceptance time and consumed at body-build +// time to emit a `linalg.index + affine.apply + cmpi + select` guard. +struct BoundMaskInfo { + bool needed = false; + AffineMap origMap; + SmallVector origOperands; +}; + +static bool affineStoresProvablyDisjoint(affine::AffineStoreOp lhs, + affine::AffineStoreOp rhs, + affine::AffineForOp loop) { + if (lhs.getMemref() != rhs.getMemref()) + return true; + + AffineMap lhsMap = lhs.getAffineMap(); + AffineMap rhsMap = rhs.getAffineMap(); + if (lhsMap.getNumResults() != rhsMap.getNumResults()) + return false; + + for (auto pair : llvm::zip(lhsMap.getResults(), rhsMap.getResults())) { + auto lhsConst = std::get<0>(pair).dyn_cast(); + auto rhsConst = std::get<1>(pair).dyn_cast(); + if (lhsConst && rhsConst && lhsConst.getValue() != rhsConst.getValue()) + return true; + } + + // Prove disjoint constant-offset slices such as A[i] and A[i + 25]. The + // old check above only handled coordinates that were themselves constants, + // so it missed this common flattened-tensor representation. + if (!loop.hasConstantLowerBound() || !loop.hasConstantUpperBound() || + lhsMap.getNumDims() != rhsMap.getNumDims() || + lhsMap.getNumSymbols() != rhsMap.getNumSymbols() || + !llvm::equal(lhs.getMapOperands(), rhs.getMapOperands())) + return false; + + struct LinearForm { + SmallVector coefficients; + int64_t constant = 0; + }; + + auto checkedAdd = [](int64_t a, int64_t b, int64_t &result) { + return !__builtin_add_overflow(a, b, &result); + }; + auto checkedMul = [](int64_t a, int64_t b, int64_t &result) { + return !__builtin_mul_overflow(a, b, &result); + }; + + unsigned numOperands = lhsMap.getNumDims() + lhsMap.getNumSymbols(); + std::function decompose = + [&](AffineExpr expression, LinearForm &form) -> bool { + form.coefficients.assign(numOperands, 0); + form.constant = 0; + if (auto constant = expression.dyn_cast()) { + form.constant = constant.getValue(); + return true; + } + if (auto dim = expression.dyn_cast()) { + form.coefficients[dim.getPosition()] = 1; + return true; + } + if (auto symbol = expression.dyn_cast()) { + form.coefficients[lhsMap.getNumDims() + symbol.getPosition()] = 1; + return true; + } + auto binary = expression.dyn_cast(); + if (!binary) + return false; + if (expression.getKind() == AffineExprKind::Add) { + LinearForm left, right; + if (!decompose(binary.getLHS(), left) || + !decompose(binary.getRHS(), right)) + return false; + for (unsigned i = 0; i < numOperands; ++i) + if (!checkedAdd(left.coefficients[i], right.coefficients[i], + form.coefficients[i])) + return false; + return checkedAdd(left.constant, right.constant, form.constant); + } + if (expression.getKind() != AffineExprKind::Mul) + return false; + auto leftConstant = binary.getLHS().dyn_cast(); + auto rightConstant = binary.getRHS().dyn_cast(); + AffineExpr variableExpression; + int64_t scale; + if (leftConstant) { + scale = leftConstant.getValue(); + variableExpression = binary.getRHS(); + } else if (rightConstant) { + scale = rightConstant.getValue(); + variableExpression = binary.getLHS(); + } else { + return false; + } + LinearForm variable; + if (!decompose(variableExpression, variable)) + return false; + for (unsigned i = 0; i < numOperands; ++i) + if (!checkedMul(variable.coefficients[i], scale, + form.coefficients[i])) + return false; + return checkedMul(variable.constant, scale, form.constant); + }; + + ValueRange operands = lhs.getMapOperands(); + Value inductionVariable = loop.getInductionVar(); + for (Value operand : operands) { + if (operand == inductionVariable) + continue; + if (Operation *definition = operand.getDefiningOp()) { + if (loop->isAncestor(definition)) + return false; + continue; + } + auto blockArgument = dyn_cast(operand); + Operation *parent = blockArgument + ? blockArgument.getOwner()->getParentOp() + : nullptr; + if (!parent || parent == loop || loop->isAncestor(parent)) + return false; + } + + int64_t lower = loop.getConstantLowerBound(); + int64_t upper = loop.getConstantUpperBound(); + int64_t step = loop.getStep(); + if (step <= 0 || upper <= lower) + return false; + int64_t distance, roundedDistance; + if (__builtin_sub_overflow(upper, lower, &distance) || + __builtin_add_overflow(distance, step - 1, &roundedDistance)) + return false; + int64_t tripCount = roundedDistance / step; + int64_t inductionSpan; + if (__builtin_mul_overflow(tripCount - 1, step, &inductionSpan)) + return false; + + for (auto pair : llvm::zip(lhsMap.getResults(), rhsMap.getResults())) { + LinearForm left, right; + if (!decompose(std::get<0>(pair), left) || + !decompose(std::get<1>(pair), right) || + left.coefficients != right.coefficients) + continue; + + int64_t inductionCoefficient = 0; + for (auto [index, operand] : llvm::enumerate(operands)) + if (operand == inductionVariable && + !checkedAdd(inductionCoefficient, left.coefficients[index], + inductionCoefficient)) + return false; + int64_t coordinateSpan; + if (inductionCoefficient == std::numeric_limits::min() || + !checkedMul(std::abs(inductionCoefficient), inductionSpan, + coordinateSpan)) + return false; + int64_t offset; + if (__builtin_sub_overflow(left.constant, right.constant, &offset) || + offset == std::numeric_limits::min()) + return false; + if (std::abs(offset) > coordinateSpan) + return true; + } + + return false; +} + +static bool storesProvablyDisjoint(Operation *lhs, Operation *rhs, + affine::AffineForOp loop) { + if (auto lhsAffine = dyn_cast(lhs)) { + if (auto rhsAffine = dyn_cast(rhs)) + return affineStoresProvablyDisjoint(lhsAffine, rhsAffine, loop); + } + + if (auto lhsStore = dyn_cast(lhs)) { + if (auto rhsStore = dyn_cast(rhs)) + return lhsStore.getMemref() != rhsStore.getMemref(); + } + + return false; +} + +static bool onlyFeedsNestedGenericThroughReadNone(Value value, Operation *scope, + Operation *nestedGeneric, + DenseSet &seen) { + if (!seen.insert(value).second) + return true; + + for (Operation *user : value.getUsers()) { + if (!scope->isAncestor(user)) + return false; + if (user == nestedGeneric || nestedGeneric->isAncestor(user)) + continue; + if (!isReadNone(user)) + return false; + for (Value result : user->getResults()) + if (!onlyFeedsNestedGenericThroughReadNone(result, scope, nestedGeneric, + seen)) + return false; + } + return true; +} + +struct PromotedScalarLoad { + Value input; + AffineMap indexingMap; +}; - return false; +static bool sameAffineLoadStoreAddress(affine::AffineLoadOp load, + affine::AffineStoreOp store) { + return load.getMemref() == store.getMemref() && + load.getAffineMap() == store.getAffineMap() && + load.getMapOperands() == store.getMapOperands(); } -bool isLinearInIndex(AffineMap map, size_t idx) { - for (auto expr : map.getResults()) { - if (!isLinearInIndex(expr, idx)) - return false; - } - return true; +static Value getOperandDimSize(OpBuilder &builder, Location loc, Value operand, + unsigned dim) { + if (auto submap = operand.getDefiningOp()) + return submap.getSizes()[dim]; + return linalg::createOrFoldDimOp(builder, loc, operand, dim); } - AffineExpr shiftDimsDown1(AffineExpr expr, unsigned numDims, - unsigned offset) { - SmallVector dims; - for (unsigned idx = 0; idx < offset; ++idx) - dims.push_back(getAffineDimExpr(idx, expr.getContext())); - for (unsigned idx = offset; idx < numDims; ++idx) - dims.push_back(getAffineDimExpr(idx - 1, expr.getContext())); - return expr.replaceDimsAndSymbols(dims, {}); - } - -//This is reducing the number of input dims in expression by 1 - AffineMap shiftDimsDown1(AffineMap expr, unsigned numDim, - unsigned offset) { - assert(offset <= expr.getNumDims()); - return AffineMap::get(expr.getNumDims() - 1, expr.getNumSymbols(), - llvm::map_to_vector<4>( - expr.getResults(), - [&](AffineExpr e) { - return shiftDimsDown1(e, expr.getNumDims(), offset); - }), - expr.getContext()); - } - -// Given an affine map `oldmap`, memref `val`, and corresponding input values (which are a list of indicies, then symbols), -// and a loop index `ind` produce the following: -// 1. A (potentially new) memref value `newval` which does not have any dependence on `ind` -// and -// 2. an affine map `newmap` which takes a single index (`ind`) and produces indices into `newval` such that -// indexing `newval[map(ind)]` produces the same result as indexing the original map. -std::pair remap_in_affine_dim(bool &legal, OpBuilder &builder, AffineMap oldmap, Value val, Value idx, Value idx_size, int loopLowerBound, int loopStepSize, mlir::OperandRange vals) { - // First we need to remove any dependence on the loop index from the affine map - SmallVector vals_without_idx; - ssize_t dim_idx = -1; - //To check if induction variable of for loop in an operand of this op (load/store) - for (auto &&[i, v] : llvm::enumerate(vals)) { - if (v == idx) { - // Offset we're replacing must be an index (not a symbol). - // If we guarantee to run AffineCFG first, this should always be true. - assert(i < oldmap.getNumDims()); - // There should only be one use of the index. - assert(dim_idx == -1); - dim_idx = i; - continue; - } - vals_without_idx.push_back(v); - } - - if (dim_idx != -1 && !isLinearInIndex(oldmap, dim_idx)) { - legal = false; - return {val, oldmap}; +static LogicalResult +collectNestedGenericLoopSizes(linalg::GenericOp generic, OpBuilder &builder, + SmallVectorImpl &loopSizes) { + loopSizes.assign(generic.getNumLoops(), Value()); + + SmallVector operands; + operands.append(generic.getInputs().begin(), generic.getInputs().end()); + operands.append(generic.getOutputs().begin(), generic.getOutputs().end()); + + SmallVector maps = generic.getIndexingMapsArray(); + if (maps.size() != operands.size()) + return failure(); + + for (auto indexedOperand : llvm::enumerate(operands)) { + AffineMap map = maps[indexedOperand.index()]; + if (!map.isProjectedPermutation()) + return failure(); + + Value operand = indexedOperand.value(); + auto operandType = dyn_cast(operand.getType()); + if (!operandType) + return failure(); + if (map.getNumResults() != operandType.getRank()) + return failure(); + + for (auto indexedExpr : llvm::enumerate(map.getResults())) { + auto dimExpr = indexedExpr.value().dyn_cast(); + if (!dimExpr) + continue; + unsigned loopDim = dimExpr.getPosition(); + if (loopDim >= loopSizes.size()) + return failure(); + if (!loopSizes[loopDim]) + loopSizes[loopDim] = getOperandDimSize( + builder, generic.getLoc(), operand, indexedExpr.index()); } + } + for (Value loopSize : loopSizes) + if (!loopSize) + return failure(); + return success(); +} - // Evaluate offsets as oldmap replacing idx with 0, and evaluating at the remaining variables +// Fold a private scalar additive reduction into the affine read/modify/write +// that immediately consumes it: +// +// %scratch = alloca : memref +// store 0, %scratch[] +// linalg.generic ... outs(%scratch) { %next = add %acc, %term } +// %sum = load %scratch[] +// %old = load %output[affine-index] +// store (add %old, %sum), %output[affine-index] +// +// becomes a reduction whose initial/output value is the selected output +// element itself. Once the scalar boundary and epilogue store disappear, +// AffineForOpRaising can prepend this loop (and its enclosing output loops) as +// parallel iterator dimensions on the nested generic. +// +// This first implementation intentionally handles only the common single- +// output additive form. The structural checks below make the transformation +// independent of loop rank, trip counts, and operand layouts. Floating-point +// reductions in this pipeline are already represented as linalg reduction +// iterators; seeding that reduction with the destination preserves the same +// mathematical reduction semantics, though—as with other floating-point +// reduction lowering—it is not a promise of bitwise-identical association. +struct FuseScalarAddReductionIntoOutput + : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; - //Instead of lower bound we are using 0 (assumption as the lower bound) - AffineMap offsetMap = oldmap; - if (dim_idx != -1) { - offsetMap = oldmap.replace(builder.getAffineDimExpr(dim_idx), builder.getAffineConstantExpr(loopLowerBound),offsetMap.getNumDims(), offsetMap.getNumSymbols()); - offsetMap = shiftDimsDown1(offsetMap, oldmap.getNumDims(), dim_idx); + LogicalResult matchAndRewrite(affine::AffineForOp loop, + PatternRewriter &rewriter) const final { + if (loop.getNumResults() != 0) + return failure(); + + Block *body = loop.getBody(); + SmallVector generics; + for (Operation &op : body->without_terminator()) + if (auto generic = dyn_cast(op)) + generics.push_back(generic); + if (generics.size() != 1) + return failure(); + + linalg::GenericOp generic = generics.front(); + if (generic.getNumDpsInits() != 1 || generic.getNumLoops() == 0) + return failure(); + if (!llvm::all_of(generic.getIteratorTypesArray(), + [](utils::IteratorType iteratorType) { + return iteratorType == utils::IteratorType::reduction; + })) + return failure(); + + Value scratchView = generic.getOutputs().front(); + Operation *scratchViewOp = scratchView.getDefiningOp(); + Value scratch; + if (auto subview = dyn_cast_or_null(scratchViewOp)) { + if (cast(subview.getType()).getRank() != 0) + return failure(); + scratch = subview.getSource(); + } else if (auto submap = + dyn_cast_or_null(scratchViewOp)) { + // AffineForOpRaising represents the rank-zero scratch as a broadcast + // submap while it prepends the inner reduction dimensions. Its result + // can therefore have nonzero rank even though every indexing-map result + // is constant and the underlying storage remains scalar. + scratch = submap.getBase(); + } else { + return failure(); } - - //Instead of using loop step we are using 1 (Assumption as the stride size) - AffineMap strideMap = oldmap; - if (dim_idx != -1) { - strideMap = oldmap.replace(builder.getAffineDimExpr(dim_idx), builder.getAffineConstantExpr(loopLowerBound + loopStepSize),strideMap.getNumDims(), strideMap.getNumSymbols()); - strideMap = shiftDimsDown1(strideMap, oldmap.getNumDims(), dim_idx); + auto scratchAlloca = scratch.getDefiningOp(); + auto scratchType = dyn_cast_or_null(scratch.getType()); + if (!scratchAlloca || !scratchType || scratchType.getRank() != 0 || + scratchAlloca->getBlock() != body) + return failure(); + + // The generic itself must be an additive reduction of its sole output + // block argument. + Block &genericBody = generic.getRegion().front(); + if (genericBody.getNumArguments() != + generic.getNumDpsInputs() + generic.getNumDpsInits()) + return failure(); + Value accumulator = genericBody.getArguments().back(); + auto yield = dyn_cast(genericBody.getTerminator()); + if (!yield || yield.getNumOperands() != 1) + return failure(); + Operation *yieldAdd = yield.getOperand(0).getDefiningOp(); + bool innerIsFloat = isa_and_nonnull(yieldAdd); + bool innerIsInteger = isa_and_nonnull(yieldAdd); + if ((!innerIsFloat && !innerIsInteger) || !accumulator.hasOneUse()) + return failure(); + + // The accumulator may occur below a chain of same-combiner additions, + // e.g. yield (((acc + term0) + term1) + term2). Requiring it to be a + // direct operand of the yielded add unnecessarily rejects multi-term + // reductions. Count occurrences through only the matching associative + // add tree; exactly one occurrence is the canonical accumulator form. + std::function countAccumulator = [&](Value value) { + if (value == accumulator) + return 1u; + Operation *definition = value.getDefiningOp(); + if (!definition || + (innerIsFloat && !isa(definition)) || + (innerIsInteger && !isa(definition))) + return 0u; + return countAccumulator(definition->getOperand(0)) + + countAccumulator(definition->getOperand(1)); + }; + if (countAccumulator(yield.getOperand(0)) != 1) + return failure(); + + affine::AffineStoreOp initStore; + affine::AffineLoadOp scratchLoad; + for (Operation *user : scratch.getUsers()) { + if (auto store = dyn_cast(user)) { + if (store.getMemref() != scratch || initStore) + return failure(); + initStore = store; + } else if (auto load = dyn_cast(user)) { + if (load.getMemref() != scratch || scratchLoad) + return failure(); + scratchLoad = load; + } else if (user != scratchViewOp) { + return failure(); + } } + if (!initStore || !scratchLoad || initStore->getBlock() != body || + scratchLoad->getBlock() != body || !initStore->isBeforeInBlock(generic) || + !generic->isBeforeInBlock(scratchLoad)) + return failure(); + + // Require the standard additive identity. + Value init = initStore.getValueToStore(); + bool isZero = false; + if (auto cst = init.getDefiningOp()) + isZero = cst.value().isZero(); + else if (auto cst = init.getDefiningOp()) + isZero = cst.value() == 0; + if (!isZero) + return failure(); + + if (!scratchLoad->hasOneUse()) + return failure(); + Operation *outerAdd = *scratchLoad->getUsers().begin(); + if (!isa(outerAdd) || + outerAdd->getNumOperands() != 2 || !outerAdd->getResult(0).hasOneUse()) + return failure(); + if ((innerIsFloat && !isa(outerAdd)) || + (innerIsInteger && !isa(outerAdd))) + return failure(); + + Value other = outerAdd->getOperand(0) == scratchLoad.getResult() + ? outerAdd->getOperand(1) + : outerAdd->getOperand(0); + auto outputLoad = other.getDefiningOp(); + auto outputStore = + dyn_cast(*outerAdd->getUsers().begin()); + if (!outputLoad || !outputStore || outputLoad->getBlock() != body || + outputStore->getBlock() != body || + outputStore.getValueToStore() != outerAdd->getResult(0) || + !sameAffineLoadStoreAddress(outputLoad, outputStore) || + !outputLoad->hasOneUse()) + return failure(); + + // The scratch view may only be the generic output, and the scalar alloca + // may not escape through any path not inspected above. + if (!scratchView.hasOneUse() || + *scratchView.getUsers().begin() != generic.getOperation()) + return failure(); + + // Build a rank-zero submap selecting output[affine-index]. Submap keeps + // the affine address visible to getLinalgArgMap, allowing each enclosing + // affine loop to be prepended to the generic's indexing maps later. + AffineMap storeMap = outputStore.getAffineMap(); + unsigned numDims = storeMap.getNumDims(); + unsigned numSymbols = storeMap.getNumSymbols(); + SmallVector dimReplacements; + SmallVector symbolReplacements; + for (unsigned i = 0; i < numDims; ++i) + dimReplacements.push_back( + rewriter.getAffineSymbolExpr(i)); + for (unsigned i = 0; i < numSymbols; ++i) + symbolReplacements.push_back( + rewriter.getAffineSymbolExpr(numDims + i)); + SmallVector results; + for (AffineExpr expr : storeMap.getResults()) + results.push_back(expr.replaceDimsAndSymbols(dimReplacements, + symbolReplacements)); + AffineMap scalarMap = AffineMap::get( + /*dimCount=*/0, /*symbolCount=*/numDims + numSymbols, results, + rewriter.getContext()); + auto outputType = cast(outputStore.getMemref().getType()); + auto scalarType = + MemRefType::get({}, outputType.getElementType()); + rewriter.setInsertionPoint(generic); + SmallVector mapOperands(outputStore.getMapOperands()); + auto outputView = rewriter.create( + generic.getLoc(), scalarType, outputStore.getMemref(), mapOperands, + scalarMap); + + SmallVector indexingMaps = generic.getIndexingMapsArray(); + indexingMaps.back() = AffineMap::get( + generic.getNumLoops(), /*symbolCount=*/0, /*results=*/{}, + rewriter.getContext()); + generic.setIndexingMapsAttr(rewriter.getAffineMapArrayAttr(indexingMaps)); + generic->setOperand(generic.getNumDpsInputs(), outputView.getResult()); + + rewriter.eraseOp(outputStore); + rewriter.eraseOp(outerAdd); + rewriter.eraseOp(outputLoad); + rewriter.eraseOp(scratchLoad); + rewriter.eraseOp(initStore); + rewriter.eraseOp(scratchViewOp); + rewriter.eraseOp(scratchAlloca); + return success(); + } +}; + +// Hybrid raiser for loop bodies that are semantically elementwise stores but +// cannot be expressed as pure linalg ins/outs because the value computation +// contains guarded memory reads (for example im2col padding: +// `scf.if oob then 0 else memref.load input[idx]`). MLIR allows such a region +// inside linalg.generic, so keep the guarded load in the payload and only raise +// the output iteration space to linalg. This gives downstream matchers a stable +// `linalg.generic` anchor without speculating the load past its bounds check. +struct HybridAffineForOpRaising : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; - //Subtracting maps of stride and offset, gives you the offset value in the result of the map - { - SmallVector subtracts; - for (auto &&[lhs, rhs] : llvm::zip(strideMap.getResults(), offsetMap.getResults())) { - subtracts.push_back(lhs - rhs); + LogicalResult matchAndRewrite(affine::AffineForOp loop, + PatternRewriter &rewriter) const final { + if (loop.getNumResults() != 0) + return failure(); + if (!loop.hasConstantLowerBound() || loop.getConstantLowerBound() != 0) + return failure(); + if (loop.getStep() != 1) + return failure(); + + Block *loopBody = loop.getBody(); + Operation *terminator = loopBody->getTerminator(); + + affine::AffineStoreOp targetStore; + SmallVector affineLoads; + bool hasHybridPayload = false; + bool illegal = false; + + loop->walk([&](Operation *op) { + if (op == loop) + return WalkResult::advance(); + + if (isa(op)) + return WalkResult::advance(); + + if (isa(op)) { + illegal = true; + return WalkResult::interrupt(); + } + + if (auto store = dyn_cast(op)) { + if (store->getParentOp() != loop || targetStore) { + illegal = true; + return WalkResult::interrupt(); } - strideMap = AffineMap::get(offsetMap.getNumDims(), offsetMap.getNumSymbols(), subtracts, builder.getContext()); - } + targetStore = store; + return WalkResult::advance(); + } - // Expression to index into the generated subview given the loop index - SmallVector loop_idxs; + if (isa(op)) { + illegal = true; + return WalkResult::interrupt(); + } - // List of starting offsets into the subview - SmallVector offsets; - SmallVector sizes; - SmallVector strides; + if (isa(op)) { + hasHybridPayload = true; + return WalkResult::advance(); + } - for (auto &&[expr, offset_expr, stride_expr] : llvm::zip(oldmap.getResults(), offsetMap.getResults(),strideMap.getResults() )) { - offsets.push_back(builder.create(val.getLoc(),AffineMap::get(offsetMap.getNumDims(), offsetMap.getNumSymbols(), offset_expr, builder.getContext()), vals_without_idx)); //What is there are symbols in the expression? - strides.push_back(builder.create(val.getLoc(),AffineMap::get(strideMap.getNumDims(), strideMap.getNumSymbols(), stride_expr, builder.getContext()), vals_without_idx)); //What is there are symbols in the expression? - if (!expr.isFunctionOfDim(dim_idx)) { - loop_idxs.push_back(builder.getAffineConstantExpr(0)); - sizes.push_back(builder.create(val.getLoc(), 1)); - } else { - loop_idxs.push_back(builder.getAffineDimExpr(0)); - sizes.push_back(idx_size); - } - } + if (auto load = dyn_cast(op)) { + affineLoads.push_back(load); + return WalkResult::advance(); + } - auto newval = builder.create(val.getLoc(), val, offsets, sizes, strides); - legal = true; - //Does this need fix? Here we are constraining to dims as 1 and symbols as 0, should it be, original - return {newval, AffineMap::get(/*dims*/1, /*symbols*/0, loop_idxs, builder.getContext())}; -} + if (isReadNone(op)) + return WalkResult::advance(); + illegal = true; + return WalkResult::interrupt(); + }); -// store A[...] -// val = load A[...] + if (illegal || !targetStore || !hasHybridPayload) + return failure(); + if (targetStore->getNextNode() != terminator) + return failure(); + + // Only loads from the destination buffer participate in the output + // dependence proof. Affine loads from index/input tensors are ordinary + // payload reads (for example gather: idx[i] then input[idx[i]]). + for (affine::AffineLoadOp load : affineLoads) + if (load.getMemRef() == targetStore.getMemRef() && + !sameAffineLoadStoreAddress(load, targetStore)) + return failure(); + else if (load.getMemRef() != targetStore.getMemRef() && + !load.getAffineMap().isProjectedPermutation()) + return failure(); -/* prevA : - store A - val is now prevA -*/ + Value storedValue = targetStore.getValueToStore(); + + AffineMap ubMap = loop.getUpperBoundMap(); + SmallVector ubOperands(loop.getUpperBoundOperands()); + AffineMap lbMap = loop.getLowerBoundMap(); + SmallVector lbOperands(loop.getLowerBoundOperands()); + if (!ubMap || ubMap.getNumResults() != 1 || !lbMap || + lbMap.getNumResults() != 1) + return failure(); + + auto ubValue = + rewriter.create(loop.getLoc(), ubMap, ubOperands); + auto lbValue = + rewriter.create(loop.getLoc(), lbMap, lbOperands); + auto loopSize = + rewriter.create(loop.getLoc(), ubValue, lbValue); + + bool legal = true; + bool checkReduction = true; + size_t firstNDims = 0; + Value newOutput = remap_in_affine_dim( + legal, rewriter, targetStore.getAffineMap(), targetStore.getMemref(), + loop.getInductionVar(), loopSize, lbValue, firstNDims, + targetStore.getMapOperands(), targetStore.getMemref(), checkReduction); + if (!legal) + return failure(); + + SmallVector inputs; + SmallVector outputs{newOutput}; + SmallVector affineMaps{ + rewriter.getMultiDimIdentityMap(firstNDims + 1)}; + SmallVector iteratorTypes{ + checkReduction ? utils::IteratorType::reduction + : utils::IteratorType::parallel}; + + StringAttr empty = StringAttr::get(loop.getContext()); + auto genericOp = rewriter.create( + loop.getLoc(), TypeRange(), inputs, outputs, affineMaps, iteratorTypes, + empty, empty); + + rewriter.setInsertionPointToStart(loopBody); + auto idx = rewriter.create(loop.getLoc(), 0); + rewriter.replaceAllUsesWith(loop.getInductionVar(), idx); + + auto &genericBody = genericOp.getRegion(); + genericBody.takeBody(loop.getRegion()); + + Block *newBody = &genericBody.front(); + newBody->eraseArguments(0, newBody->getNumArguments()); + Value outputArg = + newBody->addArgument(targetStore.getValueToStore().getType(), + targetStore.getLoc()); + for (affine::AffineLoadOp outputLoad : affineLoads) { + if (!sameAffineLoadStoreAddress(outputLoad, targetStore)) { + SmallVector indices; + for (AffineExpr expr : outputLoad.getAffineMap().getResults()) { + auto dim = expr.dyn_cast(); + assert(dim && "projected permutation checked before mutation"); + indices.push_back(outputLoad.getMapOperands()[dim.getPosition()]); + } + rewriter.setInsertionPoint(outputLoad); + rewriter.replaceOpWithNewOp( + outputLoad, outputLoad.getMemRef(), indices); + continue; + } + if (storedValue == outputLoad.getResult()) + storedValue = outputArg; + rewriter.replaceOp(outputLoad, outputArg); + } + rewriter.eraseOp(targetStore); + rewriter.eraseOp(newBody->getTerminator()); + rewriter.setInsertionPointToEnd(newBody); + rewriter.create(loop.getLoc(), storedValue); + + rewriter.eraseOp(loop); + return success(); + } +}; struct AffineForOpRaising : public OpRewritePattern { using OpRewritePattern::OpRewritePattern; @@ -199,260 +2376,1154 @@ struct AffineForOpRaising : public OpRewritePattern { LogicalResult matchAndRewrite(affine::AffineForOp loop, PatternRewriter &rewriter) const final { + LLVM_DEBUG(llvm::dbgs() << "\n========================================\n"); + LLVM_DEBUG(llvm::dbgs() << "=== AffineForOpRaising::matchAndRewrite ===\n"); + LLVM_DEBUG(llvm::dbgs() << "========================================\n"); + LLVM_DEBUG(llvm::dbgs() << "Processing loop:\n" << loop << "\n\n"); + + auto module = loop->getParentOfType(); + // Don't handle accumulations in registers for the moment, we can have // a separate pattern move them into memref's if (loop.getNumResults() != 0) { - return failure(); + LLVM_DEBUG(llvm::dbgs() << "REJECTED: Loop has results\n\n"); + return failure(); } + Block *loopBody = loop.getBody(); + SmallVector, AffineLoadOp>> loads; SmallVector, AffineStoreOp>> stores; + SmallVector, GenericOp>> linalgGenerics; + bool check_reduction; + // TODO Also collect all the linalg generics! // Check that the only operations within the region are either: // affine.load, affine.store, affine.if, affine.yield // Additionally, for each load/store, remember what conditions are // required for that load or store to execute. - auto result = loop->walk([&](Operation* op) { - if (op == loop) return WalkResult::advance(); - // TODO extend this, any non-memory operation is also legal here. - // mul, add, etc (we can just check propety) - if (isa(op)) { - return WalkResult::advance(); - } - if (isa(op)) { - Operation *cur = op->getParentOp(); - std::vector conditions; - while (cur != loop) { - auto ifstmt = dyn_cast(cur); - if (!ifstmt) { - return WalkResult::interrupt(); - } - bool ifTrue = ifstmt.getThenRegion().isAncestor(cur->getParentRegion()); - conditions.emplace_back(ifTrue, ifstmt); - cur = ifstmt->getParentOp(); - } - if (auto load = dyn_cast(op)) { - loads.emplace_back(conditions, load); - } else { - auto store = cast(op); - stores.emplace_back(conditions, store); - } - return WalkResult::advance(); - } - if (isReadNone(op)) { - return WalkResult::advance(); + auto result = loop->walk([&](Operation *op) { + if (op == loop) + return WalkResult::advance(); + // TODO extend this, any non-memory operation is also legal here. + // mul, add, etc (we can just check propety) + if (isa(op)) { + return WalkResult::advance(); + } + if (isa(op) || isa(op)) { + Operation *cur = op->getParentOp(); + std::vector conditions; + while (cur != loop) { + auto ifstmt = dyn_cast(cur); + if (!ifstmt) { + return WalkResult::interrupt(); + } + bool ifTrue = + ifstmt.getThenRegion().isAncestor(cur->getParentRegion()); + conditions.emplace_back(ifTrue, ifstmt); + cur = ifstmt->getParentOp(); } - return WalkResult::interrupt(); + if (auto linalgGeneric = dyn_cast(op)) { + linalgGenerics.emplace_back(conditions, linalgGeneric); + // Treat a nested linalg.generic as a single payload op for this + // wrapping step. Its region may legally contain guarded loads after + // HybridAffineForOpRaising, and those operations should not be + // re-classified as top-level affine loop accesses here. + return WalkResult::skip(); + } else if (auto load = dyn_cast(op)) { + loads.emplace_back(conditions, load); + } else { + auto store = cast(op); + stores.emplace_back(conditions, store); + } + return WalkResult::advance(); + } + if (isKnownPureScalarLibmCall(op)) + return WalkResult::advance(); + // IsReadNone takes care of apply and subview too? + if (isReadNone(op)) { + return WalkResult::advance(); + } + return WalkResult::interrupt(); }); - - if (result.wasInterrupted()) return failure(); + + if (result.wasInterrupted()) { + LLVM_DEBUG(llvm::dbgs() << "REJECTED: Walk was interrupted (invalid operations found)\n\n"); + return failure(); + } + + if (!(linalgGenerics.size() == 1 || linalgGenerics.size() == 0)) { + LLVM_DEBUG(llvm::dbgs() << "REJECTED: More than one linalg generic\n\n"); + return failure(); + } + if ((linalgGenerics.size() == 1) && !stores.empty()) { + LLVM_DEBUG(llvm::dbgs() << "REJECTED: Linalg generic exists with stores\n\n"); + return failure(); + } + + LLVM_DEBUG(llvm::dbgs() << "Pattern recognition complete:\n"); + LLVM_DEBUG(llvm::dbgs() << " Loads: " << loads.size() << "\n"); + LLVM_DEBUG(llvm::dbgs() << " Stores: " << stores.size() << "\n"); + LLVM_DEBUG(llvm::dbgs() << " LinalgGenerics: " << linalgGenerics.size() << "\n\n"); DominanceInfo DI(loop); - // Check that all of the stores do not alias the loaded values (otherwise we could get an incorrect result) - // TODO we can extend this and handle things like reductions, but we're going to start easy for now - // TODO + // Check that all of the stores do not alias the loaded values (otherwise we + // could get an incorrect result) + // TODO we can extend this and handle things like reductions, but we're + // going to start easy for now + // TODO DenseMap stores_map; for (auto &&[_, store] : stores) { - for (auto &&[_, load]: loads) { - if (mayAlias(load.getMemref(), store.getMemref())) { - // We have one exception in this case -- if the load and store are from the exact same location, it is permitted. - if (load.getMemref() == store.getMemref() && - load.getAffineMap() == store.getAffineMap() && - load.getIndices() == store.getIndices() && DI.dominates((Operation*)load,(Operation*)store)) { - stores_map[load] = store; - continue; - } - return failure(); - } - } - for (auto &&[_, store2]: stores) { - if (store == store2) continue; - if (mayAlias(store.getMemref(), store2.getMemref())) { - return failure(); - } + for (auto &&[_, load] : loads) { + if (mayAlias(load.getMemref(), store.getMemref())) { + // We have one exception in this case -- if the load and store are + // from the exact same location, it is permitted. + if (load.getMemref() == store.getMemref() && + load.getAffineMap() == store.getAffineMap() && + load.getIndices() == store.getIndices() && + DI.dominates((Operation *)load, (Operation *)store)) { + // Example case where load does not dominate stores - if the load + // was conditional. Or, store followed by load? Q. Can't we still + // overlook the aliasing? + stores_map[load] = store; + continue; + } + //return failure(); + } + } + for (auto &&[_, store2] : stores) { + if (store == store2) + continue; + if (mayAlias(store.getMemref(), store2.getMemref()) && + !storesProvablyDisjoint(store.getOperation(), + store2.getOperation(), loop)) { + return failure(); + } + } + } + + // Forward an unconditional load from the latest exact-address store that + // precedes it in the same loop iteration. Treating such a reload as a + // separate linalg input reads the pre-iteration value instead. A common + // example is PCG's + // + // r[i] = r[i] - alpha * Ap[i]; + // z[i] = inv_diag[i] * r[i]; + // sum += r[i] * z[i]; + // + // where the second read of r must see the just-computed SSA value. + DenseMap forwardedLoads; + for (auto &&[loadConditions, load] : loads) { + if (!loadConditions.empty() || load->getBlock() != loopBody) + continue; + AffineStoreOp latest; + for (auto &&[storeConditions, store] : stores) { + if (!storeConditions.empty() || store->getBlock() != loopBody || + !store->isBeforeInBlock(load) || + load.getMemref() != store.getMemref() || + load.getAffineMap() != store.getAffineMap() || + load.getIndices() != store.getIndices()) + continue; + if (!latest || latest->isBeforeInBlock(store)) + latest = store; + } + if (!latest) + continue; + + bool interveningAlias = false; + for (auto &&[storeConditions, other] : stores) { + if (other == latest || !storeConditions.empty() || + other->getBlock() != loopBody) + continue; + // This raising already models distinct memref operands as distinct + // linalg operands. Only a later write through the same operand can + // invalidate the exact-address value available for forwarding. + if (latest->isBeforeInBlock(other) && other->isBeforeInBlock(load) && + other.getMemref() == load.getMemref()) { + interveningAlias = true; + break; } + } + if (!interveningAlias) + forwardedLoads[load] = latest; } // Check that any other loads / stores do not alias with any linalg generics - // We're going to need to upgrade the defn of mayAlias for subviews (aka mayAlias(subview, x) -> mayAlias(operand(subview), x)) + // We're going to need to upgrade the defn of mayAlias for subviews (aka + // mayAlias(subview, x) -> mayAlias(operand(subview), x)) - SmallVector inputs; + SmallVector inputs, outputs; SmallVector affineMaps; + SmallVector indexingMaps; + SmallVector promotedScalarLoads; - //if (loop.getStep() != 1) { - // return failure(); - //} + // if (loop.getStep() != 1) { + // return failure(); + // } + + // Group A — triangular-bound support. + BoundMaskInfo lbMaskInfo, ubMaskInfo; - // our remapper currently assumes 0 start to bound. - if (!loop.hasConstantLowerBound() /*|| loop.getConstantLowerBound() != 0*/) { + AffineMap ubMap = loop.getUpperBoundMap(); + SmallVector ubOperands(loop.getUpperBoundOperands()); + if (!ubMap || ubMap.getNumResults() != 1) { + LLVM_DEBUG(llvm::dbgs() << "REJECTED: Invalid upper bound map\n\n"); + return failure(); + } + + AffineMap lbMap = loop.getLowerBoundMap(); + SmallVector lbOperands(loop.getLowerBoundOperands()); + if (!lbMap || lbMap.getNumResults() != 1) { + LLVM_DEBUG(llvm::dbgs() << "REJECTED: Invalid lower bound map\n\n"); + return failure(); + } + + // Non-constant lower bound (e.g. `for k = i+1 to m`): substitute lb = 0 + // for iteration sizing and emit an in-body mask `index >= origLb(captures)`. + if (!loop.hasConstantLowerBound()) { + if (!allOperandsAreLoopInvariantWrt(lbOperands, loop)) { + LLVM_DEBUG(llvm::dbgs() << "REJECTED: lb operands are not loop-invariant w.r.t. this loop\n\n"); return failure(); + } + lbMaskInfo.needed = true; + lbMaskInfo.origMap = lbMap; + lbMaskInfo.origOperands.assign(lbOperands.begin(), lbOperands.end()); + lbMap = AffineMap::get(/*dimCount=*/0, /*symCount=*/0, + rewriter.getAffineConstantExpr(0), + rewriter.getContext()); + lbOperands.clear(); + LLVM_DEBUG(llvm::dbgs() << "Captured non-constant lb for mask emission\n"); } - // compute this correctly later. - auto ubMap = loop.getUpperBoundMap(); - auto ubOperands = loop.getUpperBoundOperands(); - if (!ubMap || ubMap.getNumResults() != 1) return failure(); + // Non-constant upper bound (e.g. `for j = 0 to i+1`): if any of the ub + // operands is an IV of an enclosing affine.for, replace it with that + // outer loop's (ub - 1) so the resulting size becomes outer-scope- + // dominating. This is necessary for the outer loop to later wrap this + // inner linalg.generic. Emit a body mask `index < origUb(captures)` so + // the iterations we'd otherwise execute past the original ub are gated. + if (!loop.hasConstantUpperBound() && + allOperandsAreLoopInvariantWrt(ubOperands, loop)) { + // Check whether any operand is an IV of an enclosing affine.for. + bool anyOuterIv = false; + SmallVector maxUbOperands; + maxUbOperands.reserve(ubOperands.size()); + for (Value op : ubOperands) { + if (auto blockArg = dyn_cast(op)) { + Operation *parentOp = blockArg.getOwner()->getParentOp(); + if (auto outerFor = dyn_cast(parentOp)) { + // Build (outerFor.ub - 1) at the same site this loop currently is. + OpBuilder::InsertionGuard g(rewriter); + rewriter.setInsertionPoint(loop); + Value outerUb = rewriter.create( + loop.getLoc(), outerFor.getUpperBoundMap(), + SmallVector(outerFor.getUpperBoundOperands())); + Value c1 = rewriter.create(loop.getLoc(), 1); + Value outerUbMinus1 = rewriter.create( + loop.getLoc(), outerUb, c1); + maxUbOperands.push_back(outerUbMinus1); + anyOuterIv = true; + continue; + } + } + maxUbOperands.push_back(op); + } + if (anyOuterIv) { + ubMaskInfo.needed = true; + ubMaskInfo.origMap = ubMap; + ubMaskInfo.origOperands.assign(ubOperands.begin(), ubOperands.end()); + // Use max-substituted operands for iteration-domain sizing. + ubOperands = std::move(maxUbOperands); + LLVM_DEBUG(llvm::dbgs() << "Captured non-constant ub for mask emission (max-substituted)\n"); + } + } - // Retrieve the lower bound - auto lbMap = loop.getLowerBoundMap(); - auto lbOperands = loop.getLowerBoundOperands(); - if (!lbMap || lbMap.getNumResults() != 1) return failure(); - - auto ub = loop.getSingleUpperBound(); - if (!ub) return failure(); + LLVM_DEBUG(llvm::dbgs() << "Loop bounds:\n"); + LLVM_DEBUG(llvm::dbgs() << " lbMap: " << lbMap << "\n"); + LLVM_DEBUG(llvm::dbgs() << " ubMap: " << ubMap << "\n"); - auto lb = loop.getSingleLowerBound(); - if (!lb) return failure(); - + //auto ub = loop.getSingleUpperBound(); + //if (!ub) + // return failure(); - if (!loop.hasConstantUpperBound()) { - return failure(); - } + //auto lb = loop.getSingleLowerBound(); + //if (!lb) + // return failure(); + + //if (!loop.hasConstantUpperBound()) { + // return failure(); + //} // Retrieve the step size int64_t step = loop.getStep(); // Get the single result expressions AffineExpr ubExpr = ubMap.getResult(0); - auto ubValue = rewriter.create(loop.getLoc(), ubMap, ubOperands); - + auto ubValue = + rewriter.create(loop.getLoc(), ubMap, ubOperands); + AffineExpr lbExpr = lbMap.getResult(0); - auto lbValue = rewriter.create(loop.getLoc(), lbMap, lbOperands); + auto lbValue = + rewriter.create(loop.getLoc(), lbMap, lbOperands); //// Ensure the bounds are constant expressions - auto ubConst = ubExpr.dyn_cast(); - auto lbConst = lbExpr.dyn_cast(); - if (!ubConst || !lbConst) return failure(); + //auto ubConst = ubExpr.dyn_cast(); + //auto lbConst = lbExpr.dyn_cast(); + //if (!ubConst || !lbConst) + // return failure(); // Compute the loop size - //int64_t loopSize = ubConst.getValue() - lbConst.getValue(); + // int64_t loopSize = ubConst.getValue() - lbConst.getValue(); auto loopSize = rewriter.create(loop.getLoc(), ubValue, lbValue); + + // Value loopSize = rewriter.create(loop.getLoc(), + // loop.getConstantUpperBound());//rewriter.create(loop.getLoc(), + // *ub, *lb); + + LLVM_DEBUG(llvm::dbgs() << "\n--- Processing Linalg Generics ---\n"); - //Value loopSize = rewriter.create(loop.getLoc(), loop.getConstantUpperBound());//rewriter.create(loop.getLoc(), *ub, *lb); - - // current spec is going to be indexed off of the loop var in isolation - for (auto &&[conds, load] : loads) { - // Only support unconditional loads for the moment - if (conds.size() != 0) return failure(); + for (auto &&[conds, lg] : linalgGenerics) { + + LLVM_DEBUG(llvm::dbgs() << "Processing linalg.generic:\n" << lg << "\n"); + + // This captures the indexing map attribute from the linalg.generic being + // processed + ArrayAttr indexingMapsAttr = lg.getIndexingMaps(); + + int idx = 0; + // Iterate over input arguments + LLVM_DEBUG(llvm::dbgs() << " Processing " << lg.getInputs().size() << " inputs\n"); + for (const Value input : lg.getInputs()) { + // Is this needed? + if (conds.size() != 0) { + LLVM_DEBUG(llvm::dbgs() << " REJECTED: Input has conditions\n"); + return failure(); + } - if (stores_map.find(load) != stores_map.end()) { - // We have a store that represents this load. - continue; + // TODO: Implement this + // lgMap comes from offset of memref.subview, + // lgOperands comes from operands of memref.subview + + const AffineMap lgMap0 = + cast(indexingMapsAttr[idx]).getAffineMap(); + AffineMap lgMap = lgMap0; + + LLVM_DEBUG(llvm::dbgs() << " Input " << idx << " indexing map: " << lgMap << "\n"); + SmallVector lgOperands; + for (int i = 0; i < lgMap.getNumDims(); i++) { + lgOperands.push_back(nullptr); } + Value lgMemref = input; + + // At input, this contains, current input (i.e. probably a subview) + // an lgMap which is obtained from LG's indexing map for corresponding + // input lgOperands contains current input (i.e probably a subview) + + // Gives output ... + + assert(lgOperands.size() == lgMap.getNumSymbols() + lgMap.getNumDims()); + auto result = getLinalgArgMap(loop, lgMemref, lgMap, lgOperands); + + if (!result.succeeded()) + return failure(); + bool legal = true; - - auto &&[newMemref, newAffineMap] = remap_in_affine_dim(legal, rewriter, load.getAffineMap(), load.getMemref(), loop.getInductionVar(), - loopSize, lbConst.getValue(), step, load.getMapOperands()); - if (!legal) return failure(); + // Takes input's/output's, affineMap of load/store (here lgMap ?), + // induction variable corresponding to the loop + // Memref corresponding the the memory accessed (in this case subview ?) + // loopSize, lower and upper bounds + // Get operands for load/store (here ?) to find dependent dim + + // Gives output newMemref which is a subviewOp, + // newAffineMap which is the LG's indexing map corresponding this + // inp/output + + // This takes load and store maps and then creates + // affine.apply+subview+linalg.generic For this case: LG within ForOp - + // Inputs should be : load map extracted from subviewOp + // Returns LG with indexingMap and subview with affine.apply - which + // are correct + + // TODO: Or is it num dims? + // size_t firstNDims = lgMap.getResults().size(); + size_t firstNDims = lgMap.getNumDims(); + check_reduction = false; + + LLVM_DEBUG(llvm::dbgs() << " Calling remap_in_affine_dim for input " << idx << "\n"); + + auto newMemref = remap_in_affine_dim( + legal, rewriter, lgMap, lgMemref, loop.getInductionVar(), loopSize, lbValue, + firstNDims, ValueRange(lgOperands), input, check_reduction); + if (!legal) { + LLVM_DEBUG(llvm::dbgs() << " REJECTED: remap_in_affine_dim returned illegal for input\n"); + return failure(); + } + + auto newAffineMap = rewriter.getMultiDimIdentityMap(firstNDims + 1); + // TODO: need to mergre previous indexing maps and new affine maps affineMaps.push_back(newAffineMap); inputs.push_back(newMemref); - } - // TODO Push all of the inputs to the linalg generics (modifying maps as needed) - - SmallVector outputs; - // Store we may need to reindex into a splat potentially later, but for now we'll be lazy - for (auto &&[conds, store] : stores) { - // Only support unconditional loads for the moment - if (conds.size() != 0) return failure(); + idx++; + } + + // Iterate over output arguments + LLVM_DEBUG(llvm::dbgs() << " Processing " << lg.getOutputs().size() << " outputs\n"); + for (const Value output : lg.getOutputs()) { + // Is this needed? + if (conds.size() != 0) + return failure(); + + const AffineMap lgMap0 = + cast(indexingMapsAttr[idx]).getAffineMap(); + AffineMap lgMap = lgMap0; + + SmallVector lgOperands; + for (int i = 0; i < lgMap.getNumDims(); i++) { + lgOperands.push_back(nullptr); + } + Value lgMemref = output; + + auto result = getLinalgArgMap(loop, lgMemref, lgMap, lgOperands); + + if (!result.succeeded()) + return failure(); bool legal = true; - - auto &&[newMemref, newAffineMap] = remap_in_affine_dim(legal, rewriter, store.getAffineMap(), store.getMemref(), loop.getInductionVar(), - loopSize, lbConst.getValue(), step, store.getMapOperands()); - if (!legal) return failure(); + size_t firstNDims = lgMap.getNumDims(); + check_reduction = true; + bool hasProjectedOutput = + lgMap0.getNumResults() != lgMap0.getNumDims(); + + LLVM_DEBUG(llvm::dbgs() << " Calling remap_in_affine_dim for output " << (idx - lg.getInputs().size()) << "\n"); + + auto newMemref = remap_in_affine_dim( + legal, rewriter, lgMap, lgMemref, loop.getInductionVar(), loopSize, lbValue, + firstNDims, ValueRange(lgOperands), output, check_reduction, + /*projectUnusedInnerDims=*/hasProjectedOutput); + if (!legal) { + LLVM_DEBUG(llvm::dbgs() << " REJECTED: remap_in_affine_dim returned illegal for output\n"); + return failure(); + } + // Preserve the nested output projection. In particular, a reduction + // output map omits reduction iterators; only prepend the newly raised + // outer loop dimension instead of turning all iterators into an + // identity map. + AffineMap newAffineMap; + if (hasProjectedOutput) { + AffineMap shiftedOutputMap = lgMap0.shiftDims(/*shift=*/1); + SmallVector outputResults; + outputResults.push_back(rewriter.getAffineDimExpr(0)); + llvm::append_range(outputResults, shiftedOutputMap.getResults()); + newAffineMap = AffineMap::get(firstNDims + 1, + shiftedOutputMap.getNumSymbols(), + outputResults, rewriter.getContext()); + } else { + newAffineMap = + rewriter.getMultiDimIdentityMap(firstNDims + 1); + } affineMaps.push_back(newAffineMap); outputs.push_back(newMemref); + } + } + + // current spec is going to be indexed off of the loop var in isolation + LLVM_DEBUG(llvm::dbgs() << "\n--- Processing Loads ---\n"); + + for (auto &&[conds, load] : loads) { + LLVM_DEBUG(llvm::dbgs() << "Processing load: " << load << "\n"); + + // Only support unconditional loads for the moment + if (conds.size() != 0) { + LLVM_DEBUG(llvm::dbgs() << " REJECTED: Load has conditions\n"); + return failure(); + } + + if (stores_map.find(load) != stores_map.end() || + forwardedLoads.find(load) != forwardedLoads.end()) { + // We have a store that represents this load. + continue; + } + + if (linalgGenerics.size() == 1) { + // Darknet's GEMM uses the shape `for i; for k; a = A[i,k]; + // for j; C[i,j] += a * B[k,j]`. After the `j` loop has been raised, + // the `k` wrapper contains one scalar affine.load plus one nested + // linalg.generic. Promote that scalar load to a broadcast linalg input + // instead of rejecting the mixed load + nested-generic body. + auto nestedGeneric = linalgGenerics[0].second; + if (load->getParentOp() != loop) { + LLVM_DEBUG(llvm::dbgs() << " REJECTED: Load is not top-level in the wrapper loop\n"); + return failure(); + } + for (Value output : nestedGeneric.getOutputs()) { + if (load.getMemref() == output) { + LLVM_DEBUG(llvm::dbgs() << " REJECTED: Promoted load aliases nested output by identity\n"); + return failure(); + } + } + DenseSet seen; + if (!onlyFeedsNestedGenericThroughReadNone( + load.getResult(), loop.getOperation(), nestedGeneric, seen)) { + LLVM_DEBUG(llvm::dbgs() << " REJECTED: Load has non-generic/non-readnone users\n"); + return failure(); + } + + size_t firstNDims = 0; + bool legal = true; + bool promotedLoadReductionCheck = false; + auto newMemref = remap_in_affine_dim( + legal, rewriter, load.getAffineMap(), load.getMemref(), + loop.getInductionVar(), loopSize, lbValue, firstNDims, + load.getMapOperands(), load.getMemref(), + promotedLoadReductionCheck); + + if (!legal) + return failure(); + + auto newMemrefType = cast(newMemref.getType()); + if (nestedGeneric.getNumLoops() != 0) { + SmallVector innerLoopSizes; + if (failed(collectNestedGenericLoopSizes(nestedGeneric, rewriter, + innerLoopSizes))) + return failure(); + + SmallVector broadcastSizes; + broadcastSizes.push_back(loopSize); + broadcastSizes.append(innerLoopSizes.begin(), innerLoopSizes.end()); + + SmallVector broadcastShape( + broadcastSizes.size(), ShapedType::kDynamic); + auto broadcastType = MemRefType::get( + broadcastShape, newMemrefType.getElementType()); + auto broadcastMap = AffineMap::get( + /*dimCount=*/broadcastSizes.size(), /*symbolCount=*/0, + rewriter.getAffineDimExpr(0), rewriter.getContext()); + newMemref = rewriter.create( + load.getLoc(), broadcastType, newMemref, broadcastSizes, + broadcastMap); + } + + auto newAffineMap = + rewriter.getMultiDimIdentityMap(nestedGeneric.getNumLoops() + 1); + promotedScalarLoads.push_back(PromotedScalarLoad{newMemref, + newAffineMap}); + continue; + } + + size_t firstNDims = 0; + bool legal = true; + + check_reduction = false; + auto newMemref = remap_in_affine_dim( + legal, rewriter, load.getAffineMap(), load.getMemref(), + loop.getInductionVar(), loopSize, lbValue, firstNDims, load.getMapOperands(), + load.getMemref(), check_reduction); + + if (!legal) + return failure(); + + auto newAffineMap = rewriter.getMultiDimIdentityMap(firstNDims + 1); + affineMaps.push_back(newAffineMap); + inputs.push_back(newMemref); + } + // TODO Push all of the inputs to the linalg generics (modifying maps as + // needed) + + // SmallVector outputs; + // Store we may need to reindex into a splat potentially later, but for now + // we'll be lazy + LLVM_DEBUG(llvm::dbgs() << "\n--- Processing Stores ---\n"); + + for (auto &&[conds, store] : stores) { + LLVM_DEBUG(llvm::dbgs() << "Processing store: " << store << "\n"); + + // Only support unconditional loads for the moment + if (conds.size() != 0) { + LLVM_DEBUG(llvm::dbgs() << " REJECTED: Store has conditions\n"); + return failure(); + } + + bool legal = true; + + size_t firstNDims = 0; + + check_reduction = true; + auto newMemref = remap_in_affine_dim( + legal, rewriter, store.getAffineMap(), store.getMemref(), + loop.getInductionVar(), loopSize, lbValue, firstNDims, store.getMapOperands(), + store.getMemref(), check_reduction); + + if (!legal) { + return failure(); + } + + auto newAffineMap = rewriter.getMultiDimIdentityMap(firstNDims + 1); + affineMaps.push_back(newAffineMap); + outputs.push_back(newMemref); } // TODO Push all of the outputs to the linalg generics - // TODO presently if linalg generic exists, assert there are no load/stores - // TODO assert only zero or one linalg generic exists + if (!promotedScalarLoads.empty()) { + SmallVector promotedInputs; + SmallVector promotedMaps; + for (const PromotedScalarLoad &promoted : promotedScalarLoads) { + promotedInputs.push_back(promoted.input); + promotedMaps.push_back(promoted.indexingMap); + } + inputs.insert(inputs.begin(), promotedInputs.begin(), + promotedInputs.end()); + affineMaps.insert(affineMaps.begin(), promotedMaps.begin(), + promotedMaps.end()); + } + SmallVector iteratorTypes; - // TODO if linalg generic exists, make this iterator type prepend to the existing iterators - iteratorTypes.push_back((stores_map.size() == 0) ? utils::IteratorType::parallel : utils::IteratorType::reduction); + // TODO if linalg generic exists, make this iterator type prepend to the + // existing iterators + + // TODO: Just store check is not sufficient, there has to be a check for + // bool is_parallel = stores_map.size() == 0; + // TODO determine if linalg generic, whether to create parallel or + // reduction by looking at memory patterns of maps + + if (linalgGenerics.size() == 1) { + // determine whether now we write to ourselves + } + iteratorTypes.push_back(check_reduction ? utils::IteratorType::reduction + : utils::IteratorType::parallel); + LLVM_DEBUG(llvm::dbgs() << "\n--- Creating linalg.generic ---\n"); + LLVM_DEBUG(llvm::dbgs() << "Iterator type for this loop: " + << (check_reduction ? "reduction" : "parallel") << "\n"); + + if (linalgGenerics.size() == 1) { + LLVM_DEBUG(llvm::dbgs() << "Extending iterator types from nested linalg.generic\n"); + for (auto attr : linalgGenerics[0].second.getIteratorTypesArray()) + iteratorTypes.push_back(attr); + } + + LLVM_DEBUG(llvm::dbgs() << "Total iterator types: " << iteratorTypes.size() << "\n"); + LLVM_DEBUG(llvm::dbgs() << "Total inputs: " << inputs.size() << "\n"); + LLVM_DEBUG(llvm::dbgs() << "Total outputs: " << outputs.size() << "\n"); StringAttr empty = StringAttr::get(loop.getContext()); auto genericOp = rewriter.create( - loop.getLoc(), TypeRange(), inputs, outputs, affineMaps, iteratorTypes, - empty, - empty); + loop.getLoc(), TypeRange(), inputs, outputs, affineMaps, iteratorTypes, + empty, empty); - // TODO if doing the linalg generic case, ignore a lot of the below and instead of injecting the old body of the affine.for, move the inner linalg.generic body - // and also add a new induction variable + // TODO if doing the linalg generic case, ignore a lot of the below and + // instead of injecting the old body of the affine.for, move the inner + // linalg.generic body and also add a new induction variable auto blk = &*loop.getRegion().begin(); rewriter.setInsertionPointToStart(blk); // This index will replace the use of the affine index - auto idx = rewriter.create(loop.getLoc(), rewriter.getIndexAttr(0)); + auto idx = rewriter.create(loop.getLoc(), + 0); rewriter.replaceAllUsesWith(loop.getInductionVar(), idx); auto &body = genericOp.getRegion(); body.takeBody(loop.getRegion()); - blk->eraseArguments(0, blk->getNumArguments()); for (auto &&[conds, load] : loads) { - if (stores_map.find(load) != stores_map.end()) { - // We have a store that represents this load. - continue; - } - auto arg = blk->addArgument(load.getType(), load.getLoc()); - rewriter.replaceOp(load, arg); - + auto forwarded = forwardedLoads.find(load); + if (forwarded != forwardedLoads.end()) { + rewriter.replaceOp(load, forwarded->second.getValueToStore()); + continue; + } + if (stores_map.find(load) != stores_map.end()) { + // We have a store that represents this load. + continue; + } + auto arg = blk->addArgument(load.getType(), load.getLoc()); + rewriter.replaceOp(load, arg); } - for (auto &&[conds, store] : stores) { - auto arg = blk->addArgument(store.getValueToStore().getType(), store.getLoc()); + auto arg = + blk->addArgument(store.getValueToStore().getType(), store.getLoc()); - SmallVector inverted; - for (auto && [map_load, map_store] : stores_map) { - if (map_store == store) { - inverted.push_back(map_load); - } - } - for (size_t i=0; i inverted; + for (auto &&[map_load, map_store] : stores_map) { + if (map_store == store) { + inverted.push_back(map_load); } + } + for (size_t i = 0; i < inverted.size(); i++) { + stores_map.erase(inverted[i]); + auto tmp = inverted[i]; + inverted[i] = nullptr; + rewriter.replaceOp(tmp, arg); + } } SmallVector toreturn; + for (auto genPair : linalgGenerics) { + auto genOp = genPair.second; + OpBuilder::InsertionGuard guard(rewriter); + rewriter.setInsertionPoint(genOp); + auto &genBlock = genOp->getRegion(0).front(); + auto term = genBlock.getTerminator(); + mlir::IRMapping map; + for (auto arg : genBlock.getArguments()) { + auto arg2 = blk->addArgument(arg.getType(), arg.getLoc()); + map.map(arg, arg2); + } + for (auto &op : genBlock.without_terminator()) { + Operation *cloned = rewriter.clone(op, map); + // The outer loop being raised prepends one new iter dim (index 0). + // Shift any cloned linalg.index dim numbers by 1 so they keep + // referring to the inner iter they referenced before extension. + if (auto idxOp = dyn_cast(cloned)) { + idxOp.setDim(idxOp.getDim() + 1); + } + } + for (auto op : term->getOperands()) { + toreturn.push_back(map.lookupOrDefault(op)); + } + // llvm::errs() << genOp->getParentOfType() << "\n"; + rewriter.eraseOp(genOp); + } + for (auto &&[conds, store] : stores) { - toreturn.push_back(store.getValueToStore()); - rewriter.eraseOp(store); + toreturn.push_back(store.getValueToStore()); + rewriter.eraseOp(store); } rewriter.eraseOp(blk->getTerminator()); rewriter.setInsertionPointToEnd(blk); + + // Group A — emit in-body mask when the loop had a non-constant lb and/or + // ub. Gate each store-derived yield by the combined condition; fall back + // to the corresponding output block arg when inactive. + if (lbMaskInfo.needed || ubMaskInfo.needed) { + Value idx = rewriter.create(loop.getLoc(), /*dim=*/0); + Value active; + if (lbMaskInfo.needed) { + Value lbVal = rewriter.create( + loop.getLoc(), lbMaskInfo.origMap, lbMaskInfo.origOperands); + Value lbOk = rewriter.create( + loop.getLoc(), arith::CmpIPredicate::sge, idx, lbVal); + active = lbOk; + } + if (ubMaskInfo.needed) { + Value ubVal = rewriter.create( + loop.getLoc(), ubMaskInfo.origMap, ubMaskInfo.origOperands); + Value ubOk = rewriter.create( + loop.getLoc(), arith::CmpIPredicate::slt, idx, ubVal); + active = active + ? rewriter.create(loop.getLoc(), active, ubOk).getResult() + : ubOk; + } + + // The last `stores.size()` entries of `toreturn` correspond to the + // store-derived yields; the last `stores.size()` block args of `blk` + // are the output operand block-args (representing the existing + // accumulator/output value at this iteration). + unsigned nArgs = blk->getNumArguments(); + unsigned nStores = stores.size(); + if (nStores > 0 && nArgs >= nStores && toreturn.size() >= nStores) { + unsigned firstStoreArg = nArgs - nStores; + unsigned firstStoreYield = toreturn.size() - nStores; + for (unsigned i = 0; i < nStores; ++i) { + Value oldAcc = blk->getArgument(firstStoreArg + i); + Value gated = rewriter.create( + loop.getLoc(), active, toreturn[firstStoreYield + i], oldAcc); + toreturn[firstStoreYield + i] = gated; + } + } + } + rewriter.create(loop.getLoc(), toreturn); + auto func = loop->getParentOfType(); rewriter.eraseOp(loop); + + LLVM_DEBUG(llvm::dbgs() << "\n=== AffineForOpRaising SUCCESS ===\n"); + LLVM_DEBUG(llvm::dbgs() << "========================================\n\n"); + // return success! return success(); } }; +struct AffineParallelFission : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(AffineParallelOp parallelOp, + PatternRewriter &rewriter) const override { + + LLVM_DEBUG(llvm::dbgs() << "\n=== AffineParallelFission ===\n"); + LLVM_DEBUG(llvm::dbgs() << "Processing affine.parallel:\n" << parallelOp << "\n"); + + auto module = parallelOp->getParentOfType(); + // Collect all top-level nested loops (affine.parallel or affine.for) + SmallVector nestedLoops; + Block *body = parallelOp.getBody(); + + for (auto &op : body->without_terminator()) { + if (isa(op)) { + nestedLoops.push_back(&op); + } else { + // Only allow pure nested loops - reject any other operations + return failure(); + } + } + + // Need at least 2 nested loops to perform fission + if (nestedLoops.size() < 2) { + LLVM_DEBUG(llvm::dbgs() << "REJECTED: Less than 2 nested loops (found " + << nestedLoops.size() << ")\n\n"); + return failure(); + } + + LLVM_DEBUG(llvm::dbgs() << "Found " << nestedLoops.size() << " nested loops to fission\n"); + + // Convert reductions ArrayAttr to ArrayRef + SmallVector reductionKinds; + for (auto attr : parallelOp.getReductions()) { + auto enumAttr = cast(attr); + reductionKinds.push_back(enumAttr.getValue()); + } + + // Convert steps to ArrayRef + SmallVector stepValues; + for (auto step : parallelOp.getSteps()) { + stepValues.push_back(step); + } + + for (Operation *nestedLoop : nestedLoops) { + + // Create new parallel loops for each nested loop + rewriter.setInsertionPoint(parallelOp); + + // Create a new outer parallel loop with same bounds + auto newParallelOp = rewriter.create( + parallelOp.getLoc(), + parallelOp.getResultTypes(), + reductionKinds, + SmallVector{parallelOp.getLowerBoundsMap()}, + parallelOp.getLowerBoundsOperands(), + SmallVector{parallelOp.getUpperBoundsMap()}, + parallelOp.getUpperBoundsOperands(), + stepValues + ); + + // Move the nested loop into the new outer loop + Block *newBody = newParallelOp.getBody(); + // Remove the existing terminator + rewriter.eraseOp(newBody->getTerminator()); + + // Set insertion point to the new body before cloning + rewriter.setInsertionPointToEnd(newBody); + + // Clone the nested loop into the new body + IRMapping mapping; + // Map the induction variables (use getIVs() instead of getInductionVars()) + for (auto [oldIV, newIV] : llvm::zip(parallelOp.getIVs(), + newParallelOp.getIVs())) { + mapping.map(oldIV, newIV); + } + + // Clone the operation (it will be automatically inserted at the current insertion point) + rewriter.clone(*nestedLoop, mapping); + + // Ensure insertion point is at the end of the outer parallel loop's body + rewriter.setInsertionPointToEnd(newBody); + + // Add the terminator back + rewriter.create(parallelOp.getLoc()); + } + + // Remove the original parallel loop + rewriter.eraseOp(parallelOp); + + return success(); + } + +private: + // Helper to check if an operation has no side effects that would + // prevent loop fission + bool isMemoryOrControlFlowNeutral(Operation *op) const { + // Allow constants, arithmetic, and other side-effect-free ops + if (isa(op)) return true; + if (op->hasTrait()) return true; + + // Check if it's a pure operation (no memory effects) + if (auto effectInterface = dyn_cast(op)) { + SmallVector effects; + effectInterface.getEffects(effects); + return effects.empty(); + } + + // Conservative: if we can't prove it's safe, assume it's not + return false; + } +}; + +struct AffineParallelToFor : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(AffineParallelOp parallelOp, + PatternRewriter &rewriter) const override { + + LLVM_DEBUG(llvm::dbgs() << "\n=== AffineParallelToFor ===\n"); + LLVM_DEBUG(llvm::dbgs() << "Processing affine.parallel:\n" << parallelOp << "\n"); + + // Skip if there are reductions - they need special handling + if (!parallelOp.getReductions().empty()) { + LLVM_DEBUG(llvm::dbgs() << "REJECTED: Has reductions\n\n"); + return failure(); + } + + // Skip if there are result types - parallel loops with returns need special handling + if (!parallelOp.getResultTypes().empty()) { + LLVM_DEBUG(llvm::dbgs() << "REJECTED: Has result types\n\n"); + return failure(); + } + + LLVM_DEBUG(llvm::dbgs() << "Converting parallel loop with " + << parallelOp.getIVs().size() << " induction variables\n"); + + Location loc = parallelOp.getLoc(); + + // Get the bounds and steps + auto lowerBounds = parallelOp.getLowerBoundsMap(); + auto upperBounds = parallelOp.getUpperBoundsMap(); + auto steps = parallelOp.getSteps(); + auto lowerOperands = parallelOp.getLowerBoundsOperands(); + auto upperOperands = parallelOp.getUpperBoundsOperands(); + auto ivs = parallelOp.getIVs(); + + // Start building nested for loops from outermost to innermost + OpBuilder::InsertionGuard guard(rewriter); + rewriter.setInsertionPoint(parallelOp); + + // Create nested affine.for loops + SmallVector forOps; + SmallVector newIVs; + + for (unsigned i = 0; i < ivs.size(); ++i) { + // Extract bounds for this dimension + auto lbMap = lowerBounds.getSliceMap(i, 1); + auto ubMap = upperBounds.getSliceMap(i, 1); + int64_t step = steps[i]; + + auto forOp = rewriter.create( + loc, + lowerOperands, lbMap, + upperOperands, ubMap, + step + ); + // Mark this loop as known-parallel (came from affine.parallel). Group C + // loop-distribution uses this as a precondition for safe fission. + forOp->setAttr("polygeist.was_parallel", rewriter.getUnitAttr()); + + forOps.push_back(forOp); + newIVs.push_back(forOp.getInductionVar()); + + // Set insertion point for next loop or body + rewriter.setInsertionPointToStart(forOp.getBody()); + } + + // Move the body content from parallel to innermost for loop + Block *parallelBody = parallelOp.getBody(); + Block *targetBody = forOps.empty() ? nullptr : forOps.back().getBody(); + + if (!targetBody) { + return failure(); + } + + // Create mapping for induction variables + IRMapping mapping; + for (auto [parallelIV, newIV] : llvm::zip(ivs, newIVs)) { + mapping.map(parallelIV, newIV); + } + + // Clone operations from parallel body to for body (excluding terminator) + for (auto &op : parallelBody->without_terminator()) { + rewriter.clone(op, mapping); + } + + // Remove the original parallel loop + rewriter.eraseOp(parallelOp); + + LLVM_DEBUG(llvm::dbgs() << "=== AffineParallelToFor SUCCESS ===\n\n"); + + return success(); + } +}; + +// namespace { +// struct RaiseAffineToLinalg +// : public AffineRaiseToLinalgBase { + +// std::shared_ptr patterns; + +// LogicalResult initialize(MLIRContext *context) override { +// RewritePatternSet owningPatterns(context); +// for (auto *dialect : context->getLoadedDialects()) +// dialect->getCanonicalizationPatterns(owningPatterns); +// for (RegisteredOperationName op : context->getRegisteredOperations()) +// op.getCanonicalizationPatterns(owningPatterns, context); + +// owningPatterns.insert(&getContext()); + +// patterns = std::make_shared( +// std::move(owningPatterns)); +// return success(); +// } +// void runOnOperation() override { +// GreedyRewriteConfig config; +// (void)applyPatternsAndFoldGreedily(getOperation(), *patterns, config); +// } +// }; +// } // namespace + +namespace { +struct RaiseAffineToLinalgPipeline + : public AffineRaiseToLinalgPipelineBase { + void runOnOperation() override; +}; +} // namespace + +void RaiseAffineToLinalgPipeline::runOnOperation() { + LLVM_DEBUG(llvm::dbgs() << "\n****************************************\n"); + LLVM_DEBUG(llvm::dbgs() << "*** RaiseAffineToLinalgPipeline START ***\n"); + LLVM_DEBUG(llvm::dbgs() << "****************************************\n\n"); + + // Create a nested pass manager to run the pipeline on functions + OpPassManager pm(getOperation()->getName()); + + // Create a nested pass manager for function operations + OpPassManager &funcPM = pm.nest(); + + // Convert if/else scalar choices and matching stores to arith.select before + // the affine-to-linalg raise. This handles control-flow-shaped expressions + // that the linalg raiser can represent inside a generic body. + funcPM.addPass(createFoldSCFIfPass()); + + // Add affine-parallelize pass first (runs on func.func) + funcPM.addPass(mlir::affine::createAffineParallelizePass()); + + // Add our raise-affine-to-linalg pass second (also runs on func.func) + funcPM.addPass(createRaiseAffineToLinalgPass()); + + // Canonicalize after raise-to-linalg to eliminate submaps and other patterns + //funcPM.addPass(createCanonicalizerPass()); + + // Run the pipeline + LLVM_DEBUG(llvm::dbgs() << "Running pipeline...\n"); + if (failed(runPipeline(pm, getOperation()))) { + // Warn but don't fail the pass - convergence issues shouldn't kill output + LLVM_DEBUG(llvm::dbgs() << "WARNING: Pipeline didn't converge completely\n"); + getOperation()->emitWarning("Pipeline didn't converge completely, but continuing anyway"); + } + + LLVM_DEBUG(llvm::dbgs() << "\n****************************************\n"); + LLVM_DEBUG(llvm::dbgs() << "*** RaiseAffineToLinalgPipeline END ***\n"); + LLVM_DEBUG(llvm::dbgs() << "****************************************\n\n"); +} + +namespace { +struct RaiseAffineToLinalg + : public AffineRaiseToLinalgBase { + void runOnOperation() override; +}; +} // namespace + void RaiseAffineToLinalg::runOnOperation() { - RewritePatternSet patterns(&getContext()); - // TODO add the existing canonicalization patterns - // + subview of an affine apply -> subview - patterns.insert(&getContext()); + LLVM_DEBUG(llvm::dbgs() << "\n****************************************\n"); + LLVM_DEBUG(llvm::dbgs() << "*** RaiseAffineToLinalg START ***\n"); + LLVM_DEBUG(llvm::dbgs() << "****************************************\n\n"); GreedyRewriteConfig config; - (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns), - config); + + // Step 1: Apply fission pattern first + { + LLVM_DEBUG(llvm::dbgs() << "### Step 1: Applying AffineParallelFission ###\n"); + RewritePatternSet fissionPatterns(&getContext()); + fissionPatterns.insert(&getContext()); + if (failed(applyPatternsAndFoldGreedily(getOperation(), std::move(fissionPatterns), config))) { + LLVM_DEBUG(llvm::dbgs() << "WARNING: AffineParallelFission didn't converge\n"); + getOperation()->emitWarning("AffineParallelFission didn't converge, continuing anyway"); + } + LLVM_DEBUG(llvm::dbgs() << "### Step 1 Complete ###\n\n"); + } + + // Step 2: Apply parallel-to-for conversion + { + LLVM_DEBUG(llvm::dbgs() << "### Step 2: Applying AffineParallelToFor ###\n"); + RewritePatternSet parallelToForPatterns(&getContext()); + parallelToForPatterns.insert(&getContext()); + if (failed(applyPatternsAndFoldGreedily(getOperation(), std::move(parallelToForPatterns), config))) { + LLVM_DEBUG(llvm::dbgs() << "WARNING: AffineParallelToFor didn't converge\n"); + getOperation()->emitWarning("AffineParallelToFor didn't converge, continuing anyway"); + } + LLVM_DEBUG(llvm::dbgs() << "### Step 2 Complete ###\n\n"); + } + + // Step 3: Apply distribution then raising patterns. Distribute runs at + // higher benefit so loops whose bodies have mixed chunks (Group C/D) + // get split into sibling homogeneous-body loops before being raised. + { + LLVM_DEBUG(llvm::dbgs() << "### Step 3: Applying Distribute + AffineForOpRaising ###\n"); + RewritePatternSet raisingPatterns(&getContext()); + raisingPatterns.add(&getContext(), /*benefit=*/5); + raisingPatterns.add(&getContext(), + /*benefit=*/4); + raisingPatterns.add(&getContext(), /*benefit=*/3); + // Row-scratch privatization remains opt-in until the outer loop raiser can + // consume the resulting dynamic affine row view end to end. The scalar + // sibling above is fully integrated and enabled. + // raisingPatterns.add( + // &getContext(), /*benefit=*/3); + raisingPatterns.add(&getContext(), /*benefit=*/2); + raisingPatterns.add(&getContext(), /*benefit=*/2); + raisingPatterns.add(&getContext(), /*benefit=*/1); + if (failed(applyPatternsAndFoldGreedily(getOperation(), std::move(raisingPatterns), config))) { + LLVM_DEBUG(llvm::dbgs() << "WARNING: Distribute+Raising didn't converge\n"); + getOperation()->emitWarning("Distribute+Raising didn't converge, continuing anyway"); + } + LLVM_DEBUG(llvm::dbgs() << "### Step 3 Complete ###\n\n"); + } + + // Step 3 creates reduction generics while rewriting loops from the inside + // out. The greedy driver does not necessarily put an unchanged enclosing + // loop back on its worklist when a nested loop is replaced, so accumulator + // fusion cannot reliably see those newly-created generics in the same + // invocation. Run a small, focused post-raise fixpoint: fuse a compatible + // scalar reduction into its destination, then let the ordinary loop raiser + // absorb the now-pure parallel output loops. Keeping this separate avoids + // rerunning the more expensive fission/distribution patterns. + { + LLVM_DEBUG(llvm::dbgs() + << "### Step 4: Fusing scalar reduction epilogues ###\n"); + RewritePatternSet reductionFusionPatterns(&getContext()); + reductionFusionPatterns.add( + &getContext(), /*benefit=*/2); + reductionFusionPatterns.add(&getContext(), + /*benefit=*/1); + if (failed(applyPatternsAndFoldGreedily( + getOperation(), std::move(reductionFusionPatterns), config))) { + LLVM_DEBUG(llvm::dbgs() + << "WARNING: scalar reduction fusion didn't converge\n"); + getOperation()->emitWarning( + "scalar reduction fusion didn't converge, continuing anyway"); + } + LLVM_DEBUG(llvm::dbgs() << "### Step 4 Complete ###\n\n"); + } + + LLVM_DEBUG(llvm::dbgs() << "****************************************\n"); + LLVM_DEBUG(llvm::dbgs() << "*** RaiseAffineToLinalg END ***\n"); + LLVM_DEBUG(llvm::dbgs() << "****************************************\n\n"); } namespace mlir { @@ -460,5 +3531,9 @@ namespace polygeist { std::unique_ptr createRaiseAffineToLinalgPass() { return std::make_unique(); } + +std::unique_ptr createRaiseAffineToLinalgPipelinePass() { + return std::make_unique(); +} } // namespace polygeist } // namespace mlir diff --git a/lib/polygeist/Passes/RemoveIterArgs.cpp b/lib/polygeist/Passes/RemoveIterArgs.cpp new file mode 100644 index 000000000000..df9459f4ac00 --- /dev/null +++ b/lib/polygeist/Passes/RemoveIterArgs.cpp @@ -0,0 +1,983 @@ +#include "PassDetails.h" + +#include "mlir/Dialect/Affine/IR/AffineOps.h" +#include "mlir/Dialect/Arith/IR/Arith.h" +#include "mlir/Dialect/Func/IR/FuncOps.h" +#include "mlir/Dialect/LLVMIR/LLVMDialect.h" +#include "mlir/Dialect/Linalg/IR/Linalg.h" +#include "mlir/Dialect/MemRef/IR/MemRef.h" +#include "mlir/Dialect/SCF/IR/SCF.h" +#include "mlir/Dialect/SCF/Transforms/Passes.h" +#include "mlir/IR/AffineExpr.h" +#include "mlir/IR/Dominance.h" +#include "mlir/IR/IRMapping.h" +#include "mlir/IR/Operation.h" +#include "mlir/Interfaces/SideEffectInterfaces.h" +#include "mlir/Transforms/DialectConversion.h" +#include "mlir/Transforms/GreedyPatternRewriteDriver.h" +#include "polygeist/Passes/Passes.h" +#include "llvm/Support/Debug.h" + +#define DEBUG_TYPE "remove-scf-iter-args" + +using namespace mlir; +using namespace mlir::arith; +using namespace polygeist; +using namespace scf; +using namespace affine; + +// ============================================================================ +// Shared Helper Functions for Iter Args Removal +// ============================================================================ + +namespace RemoveIterArgsHelpers { + +/// Check if a value is loop-invariant w.r.t. the given loop operation +bool isLoopInvariant(Value val, Operation *loopOp) { + // Check if the value is defined outside the loop + if (auto defOp = val.getDefiningOp()) { + return !loopOp->isAncestor(defOp); + } + // Block arguments from parent regions are invariant + if (auto blockArg = dyn_cast(val)) { + return blockArg.getOwner()->getParentOp() != loopOp; + } + return true; +} + +bool isLoopCarriedRegionArg(Value val) { + auto blockArg = dyn_cast(val); + if (!blockArg) + return false; + + Operation *parentOp = blockArg.getOwner()->getParentOp(); + if (!isa(parentOp)) + return false; + + // In both scf.for and affine.for regions, argument 0 is the induction + // variable and subsequent block arguments are loop-carried values. + return blockArg.getArgNumber() > 0; +} + +/// Result of use chain analysis +struct UseChainAnalysis { + SmallVector, 4> + opsChain; // (op, invariant_operand) + Operation *storeOp = nullptr; + Operation *initLoad = nullptr; + bool succeeded = false; + + /// Analyze the use chain of a loop result to find transformation + /// opportunities Returns true if the chain ends in a store and can be + /// transformed + template + bool analyze(Value loopResult, Value yieldedValue, Operation *loopOp) { + LLVM_DEBUG(llvm::dbgs() << " Traversing use chain to find store...\n"); + + // Check if yield is an addition (required for distributivity + // transformations) + Operation *yieldedAddOp = yieldedValue.getDefiningOp(); + bool yieldIsAddition = yieldedAddOp && (isa(yieldedAddOp) || + isa(yieldedAddOp)); + LLVM_DEBUG(llvm::dbgs() << " Yielded operation is addition: " + << (yieldIsAddition ? "YES" : "NO") << "\n"); + + Value currentValue = loopResult; + int traverseLimit = 10; // Prevent infinite loops + + while (currentValue.hasOneUse() && traverseLimit-- > 0) { + Operation *user = *currentValue.getUsers().begin(); + LLVM_DEBUG(llvm::dbgs() << " Checking user: " << *user << "\n"); + + // Check if we reached a store + if (isa(user)) { + storeOp = user; + LLVM_DEBUG(llvm::dbgs() << " ✓ Found store!\n"); + succeeded = true; + return true; + } + + // Check if this is a multiply that can distribute over addition + if (isa(user) || isa(user)) { + if (!yieldIsAddition) { + LLVM_DEBUG(llvm::dbgs() + << " ✗ Cannot pull multiply: yield is not addition\n"); + return false; + } + + // Check that one operand is the loop result and the other is + // loop-invariant + Value lhs = user->getOperand(0); + Value rhs = user->getOperand(1); + Value invariantOp; + + if (lhs == currentValue && isLoopInvariant(rhs, loopOp)) { + invariantOp = rhs; + } else if (rhs == currentValue && isLoopInvariant(lhs, loopOp)) { + invariantOp = lhs; + } else { + LLVM_DEBUG(llvm::dbgs() + << " ✗ Multiply operands don't match pattern\n"); + return false; + } + + // Pulling the multiply into the loop also moves the use of its + // invariant operand. A value computed *after* the loop is invariant + // in the dependence sense, but it does not dominate the new use. + // Reject the distributive fast path in that case and let the + // consumer-blind alloca fallback materialize the iter_arg instead. + if (Operation *def = invariantOp.getDefiningOp()) { + DominanceInfo dom(loopOp->getParentOp()); + if (!dom.dominates(def, loopOp)) { + LLVM_DEBUG(llvm::dbgs() + << " ✗ Invariant operand does not dominate loop\n"); + return false; + } + } + + LLVM_DEBUG(llvm::dbgs() + << " ✓ Can pull multiply into loop (distributivity)\n"); + opsChain.push_back({user, invariantOp}); + currentValue = user->getResult(0); + continue; + } + + // Check if this is an addition with a loop-invariant load + if (isa(user) || isa(user)) { + if (!yieldIsAddition) { + LLVM_DEBUG(llvm::dbgs() + << " ✗ Cannot merge addition: yield is not addition\n"); + return false; + } + + // Get the other operand (not the loop result) + Value lhs = user->getOperand(0); + Value rhs = user->getOperand(1); + Value otherOperand = (lhs == currentValue) ? rhs : lhs; + + // Check if it's a loop-invariant load + if (auto loadOp = dyn_cast(otherOperand.getDefiningOp())) { + // Check all load operands are loop-invariant + bool allInvariant = true; + for (Value operand : loadOp->getOperands()) { + // Skip memref itself, check indices + if (operand == loadOp->getOperand(0)) + continue; + if (!isLoopInvariant(operand, loopOp)) { + allInvariant = false; + break; + } + } + + if (allInvariant) { + LLVM_DEBUG( + llvm::dbgs() + << " ✓ Found loop-invariant load, will merge into init\n"); + initLoad = loadOp; + opsChain.push_back({user, otherOperand}); + currentValue = user->getResult(0); + continue; + } + } + + LLVM_DEBUG(llvm::dbgs() << " ✗ Addition doesn't match pattern\n"); + return false; + } + + // Unknown operation + LLVM_DEBUG(llvm::dbgs() << " ✗ Unknown operation type: " + << user->getName() << "\n"); + return false; + } + + LLVM_DEBUG(llvm::dbgs() << " ✗ Could not find store in use chain\n"); + return false; + } +}; + +/// Pull operations from outside the loop into the loop body +/// Returns the final accumulator value to be stored +LogicalResult pullOperationsIntoLoop( + IRMapping &mapper, SmallVectorImpl> &opsChain, + Value yieldedValue, Value accumulatorValue, Operation *loopOp, + PatternRewriter &rewriter, Location loc, Value &outFinalAccum) { + + LLVM_DEBUG(llvm::dbgs() << " Pulling operations from outside into loop\n"); + + // Get the yielded value (mapped to new loop) + Value currentAccum = mapper.lookupOrDefault(yieldedValue); + if (!currentAccum) + currentAccum = yieldedValue; + + // Get the new loop body + Block *newBody = nullptr; + if (auto affineFor = dyn_cast(loopOp)) { + newBody = affineFor.getBody(); + } else if (auto scfFor = dyn_cast(loopOp)) { + newBody = scfFor.getBody(); + } else { + return failure(); + } + + // Pull multiply operations into the loop + for (auto &[op, invariantOp] : opsChain) { + if (isa(op) || isa(op)) { + LLVM_DEBUG(llvm::dbgs() + << " Pulling multiply into loop: " << *op << "\n"); + + // Find the addition operation that produces currentAccum + Operation *addOpDef = currentAccum.getDefiningOp(); + if (addOpDef && + (isa(addOpDef) || isa(addOpDef))) { + auto addOp = addOpDef; + + // Find which operand is the accumulator vs the value being added + Value lhs = addOp->getOperand(0); + Value rhs = addOp->getOperand(1); + + // Use the explicitly mapped loop-carried value. A load-based + // heuristic is ambiguous when the reduction term is itself a load. + Value valueToScale; + Value accumValue; + if (lhs == accumulatorValue) { + accumValue = lhs; + valueToScale = rhs; + } else if (rhs == accumulatorValue) { + accumValue = rhs; + valueToScale = lhs; + } else { + LLVM_DEBUG(llvm::dbgs() + << " Could not identify accumulator operand\n"); + return failure(); + } + + // Create new multiply (use same type as original) + rewriter.setInsertionPoint(addOp); + Value newMulResult; + if (isa(op)) { + auto newMul = + rewriter.create(loc, invariantOp, valueToScale); + newMulResult = newMul.getResult(); + LLVM_DEBUG(llvm::dbgs() << " Created: " << newMul << "\n"); + } else { + auto newMul = + rewriter.create(loc, invariantOp, valueToScale); + newMulResult = newMul.getResult(); + LLVM_DEBUG(llvm::dbgs() << " Created: " << newMul << "\n"); + } + + // Create new addition (use same type as original) + Value newAddResult; + if (isa(addOp)) { + auto newAdd = + rewriter.create(loc, accumValue, newMulResult); + newAddResult = newAdd.getResult(); + LLVM_DEBUG(llvm::dbgs() << " Created: " << newAdd << "\n"); + } else { + auto newAdd = + rewriter.create(loc, accumValue, newMulResult); + newAddResult = newAdd.getResult(); + LLVM_DEBUG(llvm::dbgs() << " Created: " << newAdd << "\n"); + } + + // Replace the old add + rewriter.replaceOp(addOp, newAddResult); + currentAccum = newAddResult; + } + } + } + + outFinalAccum = currentAccum; + return success(); +} + +} // namespace RemoveIterArgsHelpers + +// ============================================================================ +// Pattern Implementations +// ============================================================================ + +struct RemoveSCFIterArgs : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + LogicalResult matchAndRewrite(scf::ForOp forOp, + PatternRewriter &rewriter) const override { + using namespace RemoveIterArgsHelpers; + + LLVM_DEBUG(llvm::dbgs() + << "\n=== RemoveSCFIterArgs::matchAndRewrite ===\n"); + LLVM_DEBUG(llvm::dbgs() << "Processing scf.for loop:\n" << forOp << "\n"); + + if (!forOp.getRegion().hasOneBlock()) { + LLVM_DEBUG(llvm::dbgs() + << "REJECTED: Loop doesn't have exactly one block\n"); + return failure(); + } + + unsigned numIterArgs = forOp.getNumRegionIterArgs(); + LLVM_DEBUG(llvm::dbgs() << "Number of iter_args: " << numIterArgs << "\n"); + + if (numIterArgs == 0) { + LLVM_DEBUG(llvm::dbgs() << "REJECTED: No iter_args to remove\n"); + return failure(); + } + + // This pattern's single-iter_arg incremental rewrite produces an + // ill-formed terminator when the new loop still has iter_args left. + // Defer multi-iter_arg loops to the alloca fallback. + if (numIterArgs > 1) { + LLVM_DEBUG(llvm::dbgs() + << "REJECTED: numIterArgs > 1 — defer to alloca fallback\n"); + return failure(); + } + + // For now, process only the last iter_arg (like Affine version) + LLVM_DEBUG(llvm::dbgs() << "Processing last iter_arg (index " + << (numIterArgs - 1) << ")\n"); + + auto loc = forOp->getLoc(); + auto yieldOp = cast(forOp.getBody()->getTerminator()); + + auto ba = forOp.getRegionIterArgs()[numIterArgs - 1]; + auto init = forOp.getInits()[numIterArgs - 1]; + auto lastOp = yieldOp->getOperand(numIterArgs - 1); + + LLVM_DEBUG(llvm::dbgs() << " iter_arg type: " << ba.getType() << "\n"); + LLVM_DEBUG(llvm::dbgs() << " yielded value: " << lastOp << "\n"); + + auto result = forOp.getResult(numIterArgs - 1); + LLVM_DEBUG(llvm::dbgs() + << " Loop result has " + << std::distance(result.user_begin(), result.user_end()) + << " use(s)\n"); + + if (!result.hasOneUse()) { + LLVM_DEBUG(llvm::dbgs() << " ✗ Result has multiple uses or no uses\n"); + for (auto user : result.getUsers()) { + LLVM_DEBUG(llvm::dbgs() << " User: " << *user << "\n"); + } + return failure(); + } + + LLVM_DEBUG(llvm::dbgs() << " Result has exactly one use\n"); + + // Use shared helper to analyze use chain + UseChainAnalysis analysis; + if (!analysis.analyze( + result, lastOp, forOp.getOperation())) { + LLVM_DEBUG(llvm::dbgs() << " ✗ Use chain analysis failed\n"); + return failure(); + } + + LLVM_DEBUG(llvm::dbgs() << " ✓ Successfully traced to store!\n"); + LLVM_DEBUG(llvm::dbgs() << " Operations in chain: " + << analysis.opsChain.size() << "\n"); + + auto storeOp = cast(analysis.storeOp); + auto initLoad = + analysis.initLoad ? cast(analysis.initLoad) : nullptr; + + // Adjust initialization if we have a loop-invariant load + Value newInit = init; + if (initLoad) { + LLVM_DEBUG(llvm::dbgs() << " Using loop-invariant load as init\n"); + newInit = initLoad.getResult(); + } + + LLVM_DEBUG(llvm::dbgs() << " Creating new scf.for with " + << (numIterArgs - 1) << " iter_args...\n"); + + // Prepare new iter_args (drop the last one we're removing) + SmallVector newIterArgs(forOp.getInits()); + if (!newIterArgs.empty()) { + newIterArgs[numIterArgs - 1] = newInit; // Use the adjusted init + newIterArgs.pop_back(); // Remove last iter_arg + } + + // For direct overwrite reductions (`sum = init; ...; out = sum`), seed the + // destination with the original iter_arg init before the rewritten loop. + // If the analysis found a loop-invariant load, the source was already an + // update form (`out = old_out + ...`), so keep the existing output value. + if (!initLoad && !isLoopCarriedRegionArg(init)) { + rewriter.setInsertionPoint(forOp); + auto initStore = rewriter.create( + loc, init, storeOp.getMemref(), storeOp.getIndices()); + LLVM_DEBUG(llvm::dbgs() << " Created memref.store for reduction seed: " + << initStore << "\n"); + } + + rewriter.setInsertionPoint(forOp); + + // Create new loop with correct signature (fewer iter_args) + auto newForOp = rewriter.create(loc, forOp.getLowerBound(), + forOp.getUpperBound(), + forOp.getStep(), newIterArgs); + + LLVM_DEBUG(llvm::dbgs() << " Cloning loop body using IRMapping\n"); + + // Create IRMapping for value remapping + IRMapping mapper; + + // Map the induction variable + mapper.map(forOp.getInductionVar(), newForOp.getInductionVar()); + + // Map the iter_args (except the last one we're removing) + for (unsigned i = 0; i < numIterArgs - 1; i++) { + mapper.map(forOp.getRegionIterArgs()[i], newForOp.getRegionIterArgs()[i]); + } + + // Create load at the beginning that will replace the iter_arg + Block *oldBody = forOp.getBody(); + Block *newBody = newForOp.getBody(); + rewriter.setInsertionPointToStart(newBody); + + auto memrefLoad = rewriter.create(loc, storeOp.getMemref(), + storeOp.getIndices()); + LLVM_DEBUG(llvm::dbgs() << " Created memref.load at loop start: " + << memrefLoad << "\n"); + + // Map the old iter_arg to the loaded value + mapper.map(ba, memrefLoad.getResult()); + + // Clone all operations - they'll automatically use the mapped load value + for (Operation &op : oldBody->without_terminator()) { + rewriter.clone(op, mapper); + } + + // Use shared helper to pull operations into loop + Value finalAccum; + if (failed(pullOperationsIntoLoop( + mapper, analysis.opsChain, lastOp, memrefLoad.getResult(), + newForOp.getOperation(), rewriter, loc, finalAccum))) { + LLVM_DEBUG(llvm::dbgs() << " ✗ Failed to pull operations into loop\n"); + rewriter.eraseOp(newForOp); + return failure(); + } + + LLVM_DEBUG(llvm::dbgs() << " Creating store at end of loop\n"); + + // Create store before the yield + rewriter.setInsertionPoint(newBody->getTerminator()); + auto newStore = rewriter.create( + loc, finalAccum, storeOp.getMemref(), storeOp.getIndices()); + LLVM_DEBUG(llvm::dbgs() << " Created memref.store before yield: " + << newStore << "\n"); + + LLVM_DEBUG(llvm::dbgs() << " Fixing yield operation\n"); + + // Create new yield with mapped operands (excluding the iter_arg we removed) + SmallVector newYieldOperands; + for (unsigned i = 0; i < numIterArgs - 1; i++) { + Value oldOperand = yieldOp.getOperand(i); + Value newOperand = mapper.lookupOrDefault(oldOperand); + if (!newOperand) + newOperand = oldOperand; + newYieldOperands.push_back(newOperand); + } + + rewriter.setInsertionPoint(newBody->getTerminator()); + rewriter.replaceOpWithNewOp(newBody->getTerminator(), + newYieldOperands); + + LLVM_DEBUG(llvm::dbgs() << " Erasing old operations outside loop\n"); + + // Erase the external store + LLVM_DEBUG(llvm::dbgs() << " Erasing store: " << *storeOp << "\n"); + rewriter.eraseOp(storeOp); + + // Erase operations in reverse order + for (auto it = analysis.opsChain.rbegin(); it != analysis.opsChain.rend(); + ++it) { + auto &[op, _] = *it; + LLVM_DEBUG(llvm::dbgs() << " Erasing: " << *op << "\n"); + rewriter.eraseOp(op); + } + + // Erase the init load if it exists + if (initLoad) { + LLVM_DEBUG(llvm::dbgs() + << " Erasing init load: " << *initLoad << "\n"); + rewriter.eraseOp(initLoad); + } + + LLVM_DEBUG(llvm::dbgs() + << " Replacing uses of old loop results with new loop\n"); + for (unsigned i = 0; i < numIterArgs - 1; i++) { + rewriter.replaceAllUsesWith(forOp.getResult(i), newForOp.getResult(i)); + } + + LLVM_DEBUG(llvm::dbgs() << " Erasing old loop\n"); + rewriter.eraseOp(forOp); + LLVM_DEBUG(llvm::dbgs() << "=== RemoveSCFIterArgs SUCCESS ===\n\n"); + return success(); + } +}; + +// General Case(TODO): +// ALGo: +// 1. Create an alloca(stack) variable +// How to know it's dims? It should be based on number of reduction +// loops +// 2. Initialize it with init value just outside the for loop if init +// value is non-zero +// 3. memref.load that value in the for loop +// 4. Replace all the uses of the iter_arg with the loaded value +// 5. Add a memref.store for the value to be yielded +// 6. Replace all uses of for-loops yielded value with a single inserted +// memref.load +// Special case: +// ALGo: +// Optimize away memref.store and memref.load, if the only users of +// memref.load are memref.store (can use affine-scalrep pass for that ? No +// it does store to load forwarding) What we need is forwarding of local +// store to final store and deleting the intermediate alloca created. This +// is only possible if the user of alloca is a storeOp. +// 1. Identify the single store of the for loop result +// 2. Initialize it with iter arg init, outside the for loop. (TODO) +// 3. Do a load from the memref +// 4. move the store to memref inside the loop. + +struct RemoveAffineIterArgs : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(affine::AffineForOp forOp, + PatternRewriter &rewriter) const override { + using namespace RemoveIterArgsHelpers; + + LLVM_DEBUG(llvm::dbgs() + << "\n=== RemoveAffineIterArgs::matchAndRewrite ===\n"); + LLVM_DEBUG(llvm::dbgs() << "Processing affine.for loop:\n" + << forOp << "\n"); + + rewriter.setInsertionPoint(forOp); + + unsigned numIterArgs = forOp.getNumRegionIterArgs(); + LLVM_DEBUG(llvm::dbgs() << "Number of iter_args: " << numIterArgs << "\n"); + + if (numIterArgs == 0) { + LLVM_DEBUG(llvm::dbgs() << "REJECTED: No iter_args to remove\n"); + return failure(); + } + + // This pattern's single-iter_arg incremental rewrite produces an + // ill-formed terminator when the new loop still has iter_args left. + // Defer multi-iter_arg loops to the alloca fallback. + if (numIterArgs > 1) { + LLVM_DEBUG(llvm::dbgs() + << "REJECTED: numIterArgs > 1 — defer to alloca fallback\n"); + return failure(); + } + + LLVM_DEBUG(llvm::dbgs() << "Processing last iter_arg (index " + << (numIterArgs - 1) << ")\n"); + + auto loc = forOp->getLoc(); + auto yieldOp = + cast(forOp.getBody()->getTerminator()); + + auto ba = forOp.getRegionIterArgs()[numIterArgs - 1]; + auto init = forOp.getInits()[numIterArgs - 1]; + auto lastOp = yieldOp->getOperand(numIterArgs - 1); + + LLVM_DEBUG(llvm::dbgs() << " iter_arg type: " << ba.getType() << "\n"); + LLVM_DEBUG(llvm::dbgs() << " yielded value: " << lastOp << "\n"); + + auto result = forOp.getResult(numIterArgs - 1); + LLVM_DEBUG(llvm::dbgs() + << " Loop result has " + << std::distance(result.user_begin(), result.user_end()) + << " use(s)\n"); + + if (!result.hasOneUse()) { + LLVM_DEBUG(llvm::dbgs() << " ✗ Result has multiple uses or no uses\n"); + for (auto user : result.getUsers()) { + LLVM_DEBUG(llvm::dbgs() << " User: " << *user << "\n"); + } + return failure(); + } + + LLVM_DEBUG(llvm::dbgs() << " Result has exactly one use\n"); + + // Use shared helper to analyze use chain + UseChainAnalysis analysis; + if (!analysis.analyze( + result, lastOp, forOp.getOperation())) { + LLVM_DEBUG(llvm::dbgs() << " ✗ Use chain analysis failed\n"); + return failure(); + } + + LLVM_DEBUG(llvm::dbgs() << " ✓ Successfully traced to store!\n"); + LLVM_DEBUG(llvm::dbgs() << " Operations in chain: " + << analysis.opsChain.size() << "\n"); + + auto storeOp = cast(analysis.storeOp); + auto initLoad = analysis.initLoad + ? cast(analysis.initLoad) + : nullptr; + + // Adjust initialization if we have a loop-invariant load + Value newInit = init; + if (initLoad) { + LLVM_DEBUG(llvm::dbgs() << " Using loop-invariant load as init\n"); + newInit = initLoad.getResult(); + } + + LLVM_DEBUG(llvm::dbgs() << " Creating new affine.for with " + << (numIterArgs - 1) << " iter_args...\n"); + + // Prepare new iter_args (drop the last one we're removing) + SmallVector newIterArgs(forOp.getInits()); + if (!newIterArgs.empty()) { + newIterArgs[numIterArgs - 1] = newInit; // Use the adjusted init + newIterArgs.pop_back(); // Remove last iter_arg + } + + // For direct overwrite reductions (`sum = init; ...; out = sum`), seed the + // destination with the original iter_arg init before the rewritten loop. + // If the analysis found a loop-invariant load, the source was already an + // update form (`out = old_out + ...`), so keep the existing output value. + if (!initLoad && !isLoopCarriedRegionArg(init)) { + rewriter.setInsertionPoint(forOp); + auto initStore = rewriter.create( + loc, init, storeOp.getMemref(), storeOp.getMap(), + storeOp.getMapOperands()); + LLVM_DEBUG(llvm::dbgs() << " Created affine.store for reduction seed: " + << initStore << "\n"); + } + + rewriter.setInsertionPoint(forOp); + + // Create new loop with correct signature (fewer iter_args) + auto newForOp = rewriter.create( + loc, forOp.getLowerBoundOperands(), forOp.getLowerBoundMap(), + forOp.getUpperBoundOperands(), forOp.getUpperBoundMap(), + forOp.getStep(), newIterArgs); + + LLVM_DEBUG(llvm::dbgs() << " Cloning loop body using IRMapping\n"); + + // Create IRMapping for value remapping + IRMapping mapper; + + // Map the induction variable + mapper.map(forOp.getInductionVar(), newForOp.getInductionVar()); + + // Map the iter_args (except the last one we're removing) + for (unsigned i = 0; i < numIterArgs - 1; i++) { + mapper.map(forOp.getRegionIterArgs()[i], newForOp.getRegionIterArgs()[i]); + } + + // Create load at the beginning that will replace the iter_arg + Block *oldBody = forOp.getBody(); + Block *newBody = newForOp.getBody(); + rewriter.setInsertionPointToStart(newBody); + + auto memrefLoad = rewriter.create( + loc, storeOp.getMemref(), storeOp.getMap(), storeOp.getMapOperands()); + LLVM_DEBUG(llvm::dbgs() << " Created affine.load at loop start: " + << memrefLoad << "\n"); + + // Map the old iter_arg to the loaded value + mapper.map(ba, memrefLoad.getResult()); + + // Clone all operations - they'll automatically use the mapped load value + for (Operation &op : oldBody->without_terminator()) { + rewriter.clone(op, mapper); + } + + // Use shared helper to pull operations into loop + Value finalAccum; + Value oldYieldedValue = yieldOp.getOperand(numIterArgs - 1); + if (failed(pullOperationsIntoLoop( + mapper, analysis.opsChain, oldYieldedValue, memrefLoad.getResult(), + newForOp.getOperation(), rewriter, loc, finalAccum))) { + LLVM_DEBUG(llvm::dbgs() << " ✗ Failed to pull operations into loop\n"); + rewriter.eraseOp(newForOp); + return failure(); + } + + LLVM_DEBUG(llvm::dbgs() << " Creating store at end of loop\n"); + + // Create store before the yield (load was already created and mapped + // earlier) + rewriter.setInsertionPoint(newBody->getTerminator()); + auto newStore = rewriter.create( + loc, finalAccum, storeOp.getMemref(), storeOp.getMap(), + storeOp.getMapOperands()); + LLVM_DEBUG(llvm::dbgs() << " Created affine.store before yield: " + << newStore << "\n"); + + LLVM_DEBUG(llvm::dbgs() << " Fixing yield operation\n"); + + // Create new yield with mapped operands (excluding the iter_arg we removed) + SmallVector newYieldOperands; + for (unsigned i = 0; i < numIterArgs - 1; i++) { + Value oldOperand = yieldOp.getOperand(i); + Value newOperand = mapper.lookupOrDefault(oldOperand); + if (!newOperand) + newOperand = oldOperand; + newYieldOperands.push_back(newOperand); + } + + rewriter.setInsertionPoint(newBody->getTerminator()); + rewriter.replaceOpWithNewOp(newBody->getTerminator(), + newYieldOperands); + + LLVM_DEBUG(llvm::dbgs() << " Erasing old operations outside loop\n"); + + // Erase the external store + LLVM_DEBUG(llvm::dbgs() << " Erasing store: " << *storeOp << "\n"); + rewriter.eraseOp(storeOp); + + // Erase operations in reverse order + for (auto it = analysis.opsChain.rbegin(); it != analysis.opsChain.rend(); + ++it) { + auto &[op, _] = *it; + LLVM_DEBUG(llvm::dbgs() << " Erasing: " << *op << "\n"); + rewriter.eraseOp(op); + } + + // Erase the init load if it exists + if (initLoad) { + LLVM_DEBUG(llvm::dbgs() + << " Erasing init load: " << *initLoad << "\n"); + rewriter.eraseOp(initLoad); + } + + LLVM_DEBUG(llvm::dbgs() + << " Replacing uses of old loop results with new loop\n"); + for (unsigned i = 0; i < numIterArgs - 1; i++) { + rewriter.replaceAllUsesWith(forOp.getResult(i), newForOp.getResult(i)); + } + + LLVM_DEBUG(llvm::dbgs() << " Erasing old loop\n"); + rewriter.eraseOp(forOp); + LLVM_DEBUG(llvm::dbgs() << "=== RemoveAffineIterArgs SUCCESS ===\n\n"); + return success(); + } +}; + +// ============================================================================ +// Universal alloca-based materialization (consumer-blind fallback) +// ============================================================================ +// +// This pattern unconditionally converts every iter_arg of an affine.for into a +// 0-D memref slot: +// +// %slot_i = memref.alloca() : memref +// affine.store %init_i, %slot_i[] +// affine.for %iv = lb to ub { // no iter_args +// %acc_i = affine.load %slot_i[] // replaces the iter_arg +// ... body, with iter_arg_i -> %acc_i ... +// affine.store %yielded_i, %slot_i[] // replaces yield operand i +// } +// %final_i = affine.load %slot_i[] +// // RAUW old loop result #i -> %final_i (handles return / call / store / +// // cmp / loop bound / multi-use ...) +// +// Registered at lower benefit than RemoveAffineIterArgs, so the existing +// store-fusion fast path is tried first; this pattern catches everything else. + +struct MaterializeAffineIterArgsViaAlloca + : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(affine::AffineForOp forOp, + PatternRewriter &rewriter) const override { + LLVM_DEBUG(llvm::dbgs() + << "\n=== MaterializeAffineIterArgsViaAlloca ===\n"); + LLVM_DEBUG(llvm::dbgs() << "Processing affine.for:\n" << forOp << "\n"); + + unsigned numIterArgs = forOp.getNumRegionIterArgs(); + if (numIterArgs == 0) { + LLVM_DEBUG(llvm::dbgs() << "REJECTED: No iter_args\n"); + return failure(); + } + if (!forOp.getRegion().hasOneBlock()) { + LLVM_DEBUG(llvm::dbgs() << "REJECTED: Loop body has != 1 block\n"); + return failure(); + } + + auto loc = forOp.getLoc(); + auto yieldOp = + cast(forOp.getBody()->getTerminator()); + + // Step 1 & 2: alloca + init store for each iter_arg, before the loop. + rewriter.setInsertionPoint(forOp); + SmallVector slots; + slots.reserve(numIterArgs); + for (unsigned i = 0; i < numIterArgs; ++i) { + Type t = forOp.getRegionIterArgs()[i].getType(); + auto slot = + rewriter.create(loc, MemRefType::get({}, t)); + slots.push_back(slot.getResult()); + rewriter.create(loc, forOp.getInits()[i], + slot.getResult(), ValueRange{}); + } + + // Step 3: new affine.for with the same bounds but no iter_args. + auto newForOp = rewriter.create( + loc, forOp.getLowerBoundOperands(), forOp.getLowerBoundMap(), + forOp.getUpperBoundOperands(), forOp.getUpperBoundMap(), + forOp.getStep(), /*iterArgs=*/ValueRange{}); + + Block *newBody = newForOp.getBody(); + Block *oldBody = forOp.getBody(); + + IRMapping mapper; + mapper.map(forOp.getInductionVar(), newForOp.getInductionVar()); + + // Step 4a: at the top of the new body, load each slot and map the + // corresponding old iter_arg block-arg onto the loaded SSA value. + rewriter.setInsertionPointToStart(newBody); + for (unsigned i = 0; i < numIterArgs; ++i) { + auto load = + rewriter.create(loc, slots[i], ValueRange{}); + mapper.map(forOp.getRegionIterArgs()[i], load.getResult()); + } + + // Step 4b: clone every body op (the IRMapping rewires iter_arg uses + // to the loaded values). The auto-inserted affine.yield in newBody + // stays at the end; we insert before it. + for (Operation &op : oldBody->without_terminator()) { + rewriter.clone(op, mapper); + } + + // Step 4c: store the (mapped) yielded values back to their slots, + // just before the new loop's terminator. + rewriter.setInsertionPoint(newBody->getTerminator()); + for (unsigned i = 0; i < numIterArgs; ++i) { + Value mappedYielded = mapper.lookupOrDefault(yieldOp.getOperand(i)); + rewriter.create(loc, mappedYielded, slots[i], + ValueRange{}); + } + + // Step 5: after the loop, load each slot and RAUW the corresponding + // old loop result. + rewriter.setInsertionPointAfter(newForOp); + for (unsigned i = 0; i < numIterArgs; ++i) { + auto finalLoad = + rewriter.create(loc, slots[i], ValueRange{}); + rewriter.replaceAllUsesWith(forOp.getResult(i), finalLoad.getResult()); + } + + rewriter.eraseOp(forOp); + LLVM_DEBUG(llvm::dbgs() + << "=== MaterializeAffineIterArgsViaAlloca SUCCESS ===\n\n"); + return success(); + } +}; + +// Remove a store that only writes an unchanged value back to the exact +// location it was loaded from: +// +// %old = affine.load %A[...] +// +// affine.store %old, %A[...] +// +// Top-down iter_arg removal intentionally exposes this shape when an outer +// reduction result establishes the final destination and an inner reduction +// carries that destination through unchanged. Erasing the round trip leaves +// one canonical load/update/store at the loop level that actually updates the +// accumulator, allowing AffineForOpRaising to compose all reduction loops. +// +// Keep this conservative: both accesses must be in the same block, use the +// identical affine address, and no operation between them may write memory or +// have unknown/recursive effects. Reads are harmless because the store writes +// back the value already present at that location. +struct EraseUnchangedAffineLoadStore + : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + + LogicalResult matchAndRewrite(affine::AffineStoreOp store, + PatternRewriter &rewriter) const override { + auto load = store.getValueToStore().getDefiningOp(); + if (!load || load->getBlock() != store->getBlock() || + !load->isBeforeInBlock(store)) + return failure(); + + if (load.getMemref() != store.getMemref() || + load.getAffineMap() != store.getAffineMap() || + load.getMapOperands() != store.getMapOperands()) + return failure(); + + for (Operation *op = load->getNextNode(); op && op != store; + op = op->getNextNode()) { + if (isMemoryEffectFree(op)) + continue; + + auto effects = dyn_cast(op); + if (!effects || op->hasTrait()) + return failure(); + + SmallVector effectInstances; + effects.getEffects(effectInstances); + if (llvm::any_of(effectInstances, [](const auto &effect) { + return !isa(effect.getEffect()); + })) + return failure(); + } + + rewriter.eraseOp(store); + if (load->use_empty()) + rewriter.eraseOp(load); + return success(); + } +}; + +namespace { +struct RemoveIterArgs : public RemoveIterArgsBase { + + void runOnOperation() override { + LLVM_DEBUG(llvm::dbgs() << "\n\n"); + LLVM_DEBUG(llvm::dbgs() + << "===================================================\n"); + LLVM_DEBUG(llvm::dbgs() << "=== STARTING RemoveIterArgs PASS ===\n"); + LLVM_DEBUG(llvm::dbgs() + << "===================================================\n"); + + GreedyRewriteConfig config; + // Establish the outermost accumulator destination before visiting nested + // iter_args. Inner loops can then be fused into that same location rather + // than materializing one 0-D alloca per nesting level. + config.useTopDownTraversal = true; + MLIRContext *context = &getContext(); + RewritePatternSet patterns(context); + ConversionTarget target(*context); + // Fast-path patterns (store-fusion): higher benefit, tried first. + patterns.add(context, /*benefit=*/2); + patterns.add(context, /*benefit=*/2); + // Universal fallback (alloca materialization): lower benefit. + patterns.add(context, /*benefit=*/1); + // Cleanup for the unchanged load/store round trips exposed by top-down + // destination propagation. + patterns.add(context, /*benefit=*/1); + + LLVM_DEBUG(llvm::dbgs() + << "Registered patterns: RemoveSCFIterArgs, " + "RemoveAffineIterArgs, MaterializeAffineIterArgsViaAlloca\n"); + LLVM_DEBUG(llvm::dbgs() << "Applying patterns greedily...\n\n"); + + if (failed(applyPatternsAndFoldGreedily(getOperation(), std::move(patterns), + config))) { + LLVM_DEBUG(llvm::dbgs() << "\n!!! RemoveIterArgs PASS FAILED !!!\n"); + signalPassFailure(); + return; + } + + LLVM_DEBUG(llvm::dbgs() << "\n"); + LLVM_DEBUG(llvm::dbgs() + << "===================================================\n"); + LLVM_DEBUG(llvm::dbgs() + << "=== RemoveIterArgs PASS COMPLETED SUCCESSFULLY ===\n"); + LLVM_DEBUG(llvm::dbgs() + << "===================================================\n\n"); + } +}; +} // namespace + +namespace mlir { +namespace polygeist { +std::unique_ptr createRemoveIterArgsPass() { + return std::make_unique(); +} +} // namespace polygeist +} // namespace mlir diff --git a/lib/polygeist/Passes/SelectFunc.cpp b/lib/polygeist/Passes/SelectFunc.cpp new file mode 100644 index 000000000000..e69993065354 --- /dev/null +++ b/lib/polygeist/Passes/SelectFunc.cpp @@ -0,0 +1,150 @@ +//===- SelectFunc.cpp - Filter and output only selected functions +//----------===// +// +// This file implements a pass to filter functions by name, removing all +// functions that don't match the specified names. +// +//===----------------------------------------------------------------------===// + +#include "PassDetails.h" +#include "mlir/IR/BuiltinOps.h" +#include "mlir/IR/SymbolTable.h" +#include "mlir/Pass/Pass.h" +#include "mlir/Pass/PassManager.h" +#include "polygeist/Passes/Passes.h" +#include "llvm/ADT/SmallPtrSet.h" + +#define DEBUG_TYPE "select-func" + +using namespace mlir; +using namespace polygeist; + +namespace { + +struct SelectFuncPass + : public PassWrapper> { + MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SelectFuncPass) + + StringRef getArgument() const final { return "select-func"; } + + StringRef getDescription() const final { + return "Filter functions by name, keeping only those specified"; + } + + void getDependentDialects(DialectRegistry ®istry) const override { + if (!pipeline.empty()) { + OpPassManager pm(ModuleOp::getOperationName(), + OpPassManager::Nesting::Implicit); + (void)parsePassPipeline(pipeline, pm, llvm::errs()); + pm.getDependentDialects(registry); + } + } + + SelectFuncPass() = default; + SelectFuncPass(const SelectFuncPass &) {} + + void runOnOperation() override { + ModuleOp module = getOperation(); + + LLVM_DEBUG(llvm::dbgs() << "SelectFunc: Filtering functions\n"); + + // If no function names specified, keep all functions + if (funcNames.empty()) { + LLVM_DEBUG(llvm::dbgs() << "No function names specified, keeping all\n"); + + // If pipeline is specified, run it on the entire module + if (!pipeline.empty()) { + OpPassManager pm(module.getOperationName(), + OpPassManager::Nesting::Implicit); + if (failed(parsePassPipeline(pipeline, pm, llvm::errs()))) { + signalPassFailure(); + return; + } + if (failed(runPipeline(pm, module))) { + signalPassFailure(); + } + } + return; + } + + // Keep the requested roots and the transitive symbol dependencies they + // reference. Previously this pass erased declarations such as `@logf` + // while leaving calls in the selected function, producing invalid IR. + llvm::SmallPtrSet keep; + SmallVector worklist; + for (Operation &op : module.getBody()->getOperations()) { + auto symbolOp = dyn_cast(&op); + if (symbolOp && llvm::is_contained(funcNames, symbolOp.getName()) && + keep.insert(&op).second) + worklist.push_back(&op); + } + while (!worklist.empty()) { + Operation *op = worklist.pop_back_val(); + auto uses = SymbolTable::getSymbolUses(op); + if (!uses) + continue; + for (const SymbolTable::SymbolUse &use : *uses) { + Operation *dependency = + SymbolTable::lookupNearestSymbolFrom(op, use.getSymbolRef()); + if (dependency && keep.insert(dependency).second) + worklist.push_back(dependency); + } + } + + // Collect top-level symbols to remove. + SmallVector toRemove; + for (Operation &op : module.getBody()->getOperations()) { + auto symbolOp = dyn_cast(&op); + if (!symbolOp) + continue; + if (!keep.contains(&op)) { + LLVM_DEBUG(llvm::dbgs() + << "Marking for removal: " << symbolOp.getName() << "\n"); + toRemove.push_back(&op); + } else { + LLVM_DEBUG(llvm::dbgs() << "Keeping: " << symbolOp.getName() << "\n"); + } + } + + // Remove functions not in the filter list + for (Operation *op : toRemove) { + op->erase(); + } + + // If pipeline is specified, run it on the filtered module + if (!pipeline.empty()) { + LLVM_DEBUG(llvm::dbgs() << "Running pipeline on filtered functions\n"); + + OpPassManager pm(module.getOperationName(), + OpPassManager::Nesting::Implicit); + + if (failed(parsePassPipeline(pipeline, pm, llvm::errs()))) { + signalPassFailure(); + return; + } + + if (failed(runPipeline(pm, module))) { + signalPassFailure(); + } + } + } + + Option pipeline{ + *this, "pipeline", + llvm::cl::desc("Optional pass pipeline to run on filtered functions"), + llvm::cl::init("")}; + + ListOption funcNames{ + *this, "func-name", + llvm::cl::desc("Function names to keep (if empty, keep all)")}; +}; + +} // namespace + +namespace mlir { +namespace polygeist { +std::unique_ptr createSelectFuncPass() { + return std::make_unique(); +} +} // namespace polygeist +} // namespace mlir diff --git a/lib/polygeist/Passes/WrapKernelLaunchPipeline.cpp b/lib/polygeist/Passes/WrapKernelLaunchPipeline.cpp new file mode 100644 index 000000000000..63b1e0c2b581 --- /dev/null +++ b/lib/polygeist/Passes/WrapKernelLaunchPipeline.cpp @@ -0,0 +1,204 @@ +//===- WrapKernelLaunchPipeline.cpp - runtime pipeline scopes -------------===// +// +// Inserts begin/end calls around functions that contain matched kernel +// dispatches. The runtime can use this explicit scope to keep CUDA mappings, +// temporary allocations, descriptors, streams, and future device-resident +// values alive across a sequence of lowered library calls. +// +//===----------------------------------------------------------------------===// + +#include "PassDetails.h" + +#include "KernelLaunchLoweringUtils.h" + +#include "mlir/Dialect/Func/IR/FuncOps.h" +#include "mlir/IR/Builders.h" +#include "mlir/IR/BuiltinOps.h" +#include "mlir/Pass/Pass.h" +#include "polygeist/Kernel/KernelDialect.h" +#include "polygeist/Kernel/KernelOps.h" +#include "polygeist/Passes/Passes.h" + +using namespace mlir; +using namespace mlir::polygeist; +using namespace mlir::polygeist::kernel; + +namespace { + +static bool isRuntimePipelineCall(func::CallOp call, StringRef beginSymbol, + StringRef endSymbol) { + StringRef callee = call.getCallee(); + return callee == beginSymbol || callee == endSymbol; +} + +static bool isCudaShimCall(func::CallOp call) { + StringRef callee = call.getCallee(); + if (!callee.startswith("polygeist_")) + return false; + if (callee.startswith("polygeist_cublas_pipeline_")) + return false; + return callee.startswith("polygeist_cublas_") || + callee.startswith("polygeist_cudnn_") || + callee.startswith("polygeist_cutensornet_") || + callee.startswith("polygeist_cuda_") || + callee.startswith("polygeist_rmsnorm_") || + callee.startswith("polygeist_whisper_"); +} + +// Operations that only construct scalar metadata or tensor/memref views may +// remain between asynchronous library calls. Anything capable of executing +// host-side tensor computation is a boundary: the stream must be synchronized +// before that operation can consume a preceding GPU result. +static bool isPipelineTransparent(Operation *op, StringRef beginSymbol, + StringRef endSymbol) { + if (auto call = dyn_cast(op)) + return isCudaShimCall(call) || + isRuntimePipelineCall(call, beginSymbol, endSymbol); + + StringRef name = op->getName().getStringRef(); + if (name.startswith("arith.") || name.startswith("shape.")) + return true; + if (name == "tensor.empty" || name == "tensor.cast" || + name == "tensor.dim" || name == "tensor.extract_slice" || + name == "tensor.collapse_shape" || name == "tensor.expand_shape") + return true; + if (name == "bufferization.to_tensor" || + name == "bufferization.to_memref") + return true; + if (name == "memref.cast" || name == "memref.subview" || + name == "memref.reinterpret_cast" || name == "memref.dim") + return true; + if (name == "polygeist.submap") + return true; + if (name == "builtin.unrealized_conversion_cast") + return true; + return false; +} + +static bool containsRawKernelLaunch(func::FuncOp func) { + bool found = false; + func.walk([&](LaunchOp) { + found = true; + return WalkResult::interrupt(); + }); + return found; +} + +static bool containsCudaShimCall(func::FuncOp func, StringRef beginSymbol, + StringRef endSymbol) { + bool found = false; + func.walk([&](func::CallOp call) { + if (isRuntimePipelineCall(call, beginSymbol, endSymbol)) + return WalkResult::advance(); + if (isCudaShimCall(call)) { + found = true; + return WalkResult::interrupt(); + } + return WalkResult::advance(); + }); + return found; +} + +static bool alreadyWrapped(func::FuncOp func, StringRef beginSymbol, + StringRef endSymbol) { + bool sawBegin = false; + bool sawEnd = false; + func.walk([&](func::CallOp call) { + StringRef callee = call.getCallee(); + sawBegin |= callee == beginSymbol; + sawEnd |= callee == endSymbol; + }); + return sawBegin || sawEnd; +} + +struct WrapKernelLaunchPipelinePass + : public mlir::polygeist::WrapKernelLaunchPipelineBase< + WrapKernelLaunchPipelinePass> { + void runOnOperation() override { + ModuleOp module = getOperation(); + MLIRContext *ctx = module.getContext(); + OpBuilder moduleBuilder(ctx); + + SmallVector funcs; + module.walk([&](func::FuncOp func) { funcs.push_back(func); }); + + bool needsDeclarations = false; + for (func::FuncOp func : funcs) { + if (func.isDeclaration()) + continue; + if (alreadyWrapped(func, beginSymbol, endSymbol)) + continue; + if (containsCudaShimCall(func, beginSymbol, endSymbol) || + containsRawKernelLaunch(func)) { + needsDeclarations = true; + break; + } + } + + if (!needsDeclarations) + return; + + ensureShimDecl(module, beginSymbol, TypeRange{}, moduleBuilder); + ensureShimDecl(module, endSymbol, TypeRange{}, moduleBuilder); + + for (func::FuncOp func : funcs) { + if (func.isDeclaration()) + continue; + if (alreadyWrapped(func, beginSymbol, endSymbol)) + continue; + if (!containsCudaShimCall(func, beginSymbol, endSymbol) && + !containsRawKernelLaunch(func)) + continue; + + // Form maximal GPU-only regions independently in every block. This is + // conservative across control-flow edges but remains correct: a region + // always ends before host computation or a block terminator. + SmallVector blocks; + func.walk([&](Operation *op) { + for (Region ®ion : op->getRegions()) + for (Block &block : region) + blocks.push_back(&block); + }); + for (Block *block : blocks) { + SmallVector operations; + for (Operation &op : *block) + operations.push_back(&op); + + bool active = false; + for (Operation *op : operations) { + auto call = dyn_cast(op); + bool cudaCall = call && isCudaShimCall(call); + if (cudaCall && !active) { + OpBuilder beginBuilder(op); + beginBuilder.create(op->getLoc(), beginSymbol, + TypeRange{}, ValueRange{}); + active = true; + } + if (active && !cudaCall && + !isPipelineTransparent(op, beginSymbol, endSymbol)) { + OpBuilder endBuilder(op); + endBuilder.create(op->getLoc(), endSymbol, + TypeRange{}, ValueRange{}); + active = false; + } + } + if (active) { + Operation *terminator = block->getTerminator(); + OpBuilder endBuilder(terminator); + endBuilder.create(terminator->getLoc(), endSymbol, + TypeRange{}, ValueRange{}); + } + } + } + } +}; + +} // namespace + +namespace mlir { +namespace polygeist { +std::unique_ptr createWrapKernelLaunchPipelinePass() { + return std::make_unique(); +} +} // namespace polygeist +} // namespace mlir diff --git a/polybench_results/2mm.log b/polybench_results/2mm.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/2mm.mlir b/polybench_results/2mm.mlir new file mode 100644 index 000000000000..9737f3d74f64 --- /dev/null +++ b/polybench_results/2mm.mlir @@ -0,0 +1,39 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_2mm(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32, %arg4: f64, %arg5: f64, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg2 : i32 to index + %1 = arith.index_cast %arg3 : i32 to index + %2 = arith.index_cast %arg1 : i32 to index + %3 = arith.index_cast %arg0 : i32 to index + affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + affine.for %arg13 = 0 to %0 { + %4 = affine.load %arg7[%arg11, %arg13] : memref + %5 = arith.mulf %arg4, %4 : f64 + %6 = affine.load %arg8[%arg13, %arg12] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg6[%arg11, %arg12] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg6[%arg11, %arg12] : memref + } + } + } + affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + affine.for %arg13 = 0 to %2 { + %6 = affine.load %arg6[%arg11, %arg13] : memref + %7 = affine.load %arg9[%arg13, %arg12] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %arg10[%arg11, %arg12] : memref + %10 = arith.addf %9, %8 : f64 + affine.store %10, %arg10[%arg11, %arg12] : memref + } + } + } + return + } +} diff --git a/polybench_results/2mm_debuf.mlir b/polybench_results/2mm_debuf.mlir new file mode 100644 index 000000000000..838aa2e37a4b --- /dev/null +++ b/polybench_results/2mm_debuf.mlir @@ -0,0 +1,60 @@ +#map = affine_map<(d0, d1) -> (d1, d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d2, d0)> +#map4 = affine_map<(d0, d1, d2) -> (d0, d1)> +#map5 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_2mm(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32, %arg4: f64, %arg5: f64, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = bufferization.to_tensor %arg10 : memref + %1 = bufferization.to_tensor %arg9 : memref + %2 = bufferization.to_tensor %arg8 : memref + %3 = bufferization.to_tensor %arg7 : memref + %4 = bufferization.to_tensor %arg6 : memref + %5 = arith.index_cast %arg2 : i32 to index + %6 = arith.index_cast %arg3 : i32 to index + %7 = arith.index_cast %arg1 : i32 to index + %8 = arith.index_cast %arg0 : i32 to index + %9 = polygeist.submap(%4, %7, %8) {map = #map} : (tensor, index, index) -> tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%9 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %11 = polygeist.submapInverse(%4, %10, %7, %8) {map = #map} : (tensor, tensor, index, index) -> tensor + %12 = polygeist.submap(%11, %5, %7, %8) {map = #map2} : (tensor, index, index, index) -> tensor + %13 = polygeist.submap(%3, %5, %7, %8) {map = #map3} : (tensor, index, index, index) -> tensor + %14 = polygeist.submap(%2, %5, %7, %8) {map = #map4} : (tensor, index, index, index) -> tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%13, %14 : tensor, tensor) outs(%12 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %27 = arith.mulf %arg4, %in : f64 + %28 = arith.mulf %27, %in_0 : f64 + %29 = arith.addf %out, %28 : f64 + linalg.yield %29 : f64 + } -> tensor + %16 = polygeist.submapInverse(%11, %15, %5, %7, %8) {map = #map2} : (tensor, tensor, index, index, index) -> tensor + %17 = bufferization.to_memref %16 : memref + memref.copy %17, %arg6 : memref to memref + %18 = polygeist.submap(%0, %6, %8) {map = #map} : (tensor, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%18 : tensor) { + ^bb0(%out: f64): + %27 = arith.mulf %out, %arg5 : f64 + linalg.yield %27 : f64 + } -> tensor + %20 = polygeist.submapInverse(%0, %19, %6, %8) {map = #map} : (tensor, tensor, index, index) -> tensor + %21 = polygeist.submap(%16, %7, %6, %8) {map = #map3} : (tensor, index, index, index) -> tensor + %22 = polygeist.submap(%1, %7, %6, %8) {map = #map4} : (tensor, index, index, index) -> tensor + %23 = polygeist.submap(%20, %7, %6, %8) {map = #map2} : (tensor, index, index, index) -> tensor + %24 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%21, %22 : tensor, tensor) outs(%23 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %27 = arith.mulf %in, %in_0 : f64 + %28 = arith.addf %out, %27 : f64 + linalg.yield %28 : f64 + } -> tensor + %25 = polygeist.submapInverse(%20, %24, %7, %6, %8) {map = #map2} : (tensor, tensor, index, index, index) -> tensor + %26 = bufferization.to_memref %25 : memref + memref.copy %26, %arg10 : memref to memref + return + } +} + diff --git a/polybench_results/2mm_linalg.mlir b/polybench_results/2mm_linalg.mlir new file mode 100644 index 000000000000..39461e6dc6b0 --- /dev/null +++ b/polybench_results/2mm_linalg.mlir @@ -0,0 +1,47 @@ +#map = affine_map<(d0, d1) -> (d1, d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d0)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +#map4 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map5 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_2mm(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32, %arg4: f64, %arg5: f64, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg2 : i32 to index + %1 = arith.index_cast %arg3 : i32 to index + %2 = arith.index_cast %arg1 : i32 to index + %3 = arith.index_cast %arg0 : i32 to index + %4 = polygeist.submap(%arg6, %2, %3) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%4 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %5 = polygeist.submap(%arg7, %0, %2, %3) {map = #map2} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg8, %0, %2, %3) {map = #map3} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg6, %0, %2, %3) {map = #map4} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %arg4, %in : f64 + %13 = arith.mulf %12, %in_0 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 + } + %8 = polygeist.submap(%arg10, %1, %3) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%8 : memref) { + ^bb0(%out: f64): + %12 = arith.mulf %out, %arg5 : f64 + linalg.yield %12 : f64 + } + %9 = polygeist.submap(%arg6, %2, %1, %3) {map = #map2} : (memref, index, index, index) -> memref + %10 = polygeist.submap(%arg9, %2, %1, %3) {map = #map3} : (memref, index, index, index) -> memref + %11 = polygeist.submap(%arg10, %2, %1, %3) {map = #map4} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "reduction"]} ins(%9, %10 : memref, memref) outs(%11 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 + } + return + } +} + diff --git a/polybench_results/3mm.log b/polybench_results/3mm.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/3mm.mlir b/polybench_results/3mm.mlir new file mode 100644 index 000000000000..0641e1d3e92a --- /dev/null +++ b/polybench_results/3mm.mlir @@ -0,0 +1,50 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_3mm(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32, %arg4: i32, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref, %arg11: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg2 : i32 to index + %2 = arith.index_cast %arg4 : i32 to index + %3 = arith.index_cast %arg3 : i32 to index + %4 = arith.index_cast %arg0 : i32 to index + affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + affine.for %arg14 = 0 to %1 { + %5 = affine.load %arg6[%arg12, %arg14] : memref + %6 = affine.load %arg7[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg5[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg5[%arg12, %arg13] : memref + } + } + } + affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + affine.for %arg14 = 0 to %2 { + %5 = affine.load %arg9[%arg12, %arg14] : memref + %6 = affine.load %arg10[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg8[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg8[%arg12, %arg13] : memref + } + } + } + affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + affine.for %arg14 = 0 to %0 { + %5 = affine.load %arg5[%arg12, %arg14] : memref + %6 = affine.load %arg8[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg11[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg11[%arg12, %arg13] : memref + } + } + } + return + } +} diff --git a/polybench_results/3mm_debuf.mlir b/polybench_results/3mm_debuf.mlir new file mode 100644 index 000000000000..3713963afa45 --- /dev/null +++ b/polybench_results/3mm_debuf.mlir @@ -0,0 +1,79 @@ +#map = affine_map<(d0, d1) -> (d1, d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d2, d0)> +#map4 = affine_map<(d0, d1, d2) -> (d0, d1)> +#map5 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_3mm(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32, %arg4: i32, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref, %arg11: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = bufferization.to_tensor %arg11 : memref + %1 = bufferization.to_tensor %arg10 : memref + %2 = bufferization.to_tensor %arg9 : memref + %3 = bufferization.to_tensor %arg8 : memref + %4 = bufferization.to_tensor %arg7 : memref + %5 = bufferization.to_tensor %arg6 : memref + %6 = bufferization.to_tensor %arg5 : memref + %7 = arith.index_cast %arg1 : i32 to index + %8 = arith.index_cast %arg2 : i32 to index + %9 = arith.index_cast %arg4 : i32 to index + %10 = arith.index_cast %arg3 : i32 to index + %11 = arith.index_cast %arg0 : i32 to index + %12 = polygeist.submap(%6, %7, %11) {map = #map} : (tensor, index, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%12 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %14 = polygeist.submapInverse(%6, %13, %7, %11) {map = #map} : (tensor, tensor, index, index) -> tensor + %15 = polygeist.submap(%14, %8, %7, %11) {map = #map2} : (tensor, index, index, index) -> tensor + %16 = polygeist.submap(%5, %8, %7, %11) {map = #map3} : (tensor, index, index, index) -> tensor + %17 = polygeist.submap(%4, %8, %7, %11) {map = #map4} : (tensor, index, index, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%16, %17 : tensor, tensor) outs(%15 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %39 = arith.mulf %in, %in_0 : f64 + %40 = arith.addf %out, %39 : f64 + linalg.yield %40 : f64 + } -> tensor + %19 = polygeist.submapInverse(%14, %18, %8, %7, %11) {map = #map2} : (tensor, tensor, index, index, index) -> tensor + %20 = bufferization.to_memref %19 : memref + memref.copy %20, %arg5 : memref to memref + %21 = polygeist.submap(%3, %10, %7) {map = #map} : (tensor, index, index) -> tensor + %22 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%21 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %23 = polygeist.submapInverse(%3, %22, %10, %7) {map = #map} : (tensor, tensor, index, index) -> tensor + %24 = polygeist.submap(%23, %9, %10, %7) {map = #map2} : (tensor, index, index, index) -> tensor + %25 = polygeist.submap(%2, %9, %10, %7) {map = #map3} : (tensor, index, index, index) -> tensor + %26 = polygeist.submap(%1, %9, %10, %7) {map = #map4} : (tensor, index, index, index) -> tensor + %27 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%25, %26 : tensor, tensor) outs(%24 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %39 = arith.mulf %in, %in_0 : f64 + %40 = arith.addf %out, %39 : f64 + linalg.yield %40 : f64 + } -> tensor + %28 = polygeist.submapInverse(%23, %27, %9, %10, %7) {map = #map2} : (tensor, tensor, index, index, index) -> tensor + %29 = bufferization.to_memref %28 : memref + memref.copy %29, %arg8 : memref to memref + %30 = polygeist.submap(%0, %10, %11) {map = #map} : (tensor, index, index) -> tensor + %31 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%30 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %32 = polygeist.submapInverse(%0, %31, %10, %11) {map = #map} : (tensor, tensor, index, index) -> tensor + %33 = polygeist.submap(%19, %7, %10, %11) {map = #map3} : (tensor, index, index, index) -> tensor + %34 = polygeist.submap(%28, %7, %10, %11) {map = #map4} : (tensor, index, index, index) -> tensor + %35 = polygeist.submap(%32, %7, %10, %11) {map = #map2} : (tensor, index, index, index) -> tensor + %36 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%33, %34 : tensor, tensor) outs(%35 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %39 = arith.mulf %in, %in_0 : f64 + %40 = arith.addf %out, %39 : f64 + linalg.yield %40 : f64 + } -> tensor + %37 = polygeist.submapInverse(%32, %36, %7, %10, %11) {map = #map2} : (tensor, tensor, index, index, index) -> tensor + %38 = bufferization.to_memref %37 : memref + memref.copy %38, %arg11 : memref to memref + return + } +} + diff --git a/polybench_results/3mm_linalg.mlir b/polybench_results/3mm_linalg.mlir new file mode 100644 index 000000000000..073f4795141f --- /dev/null +++ b/polybench_results/3mm_linalg.mlir @@ -0,0 +1,60 @@ +#map = affine_map<(d0, d1) -> (d1, d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d0)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +#map4 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map5 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_3mm(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32, %arg4: i32, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref, %arg11: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg2 : i32 to index + %2 = arith.index_cast %arg4 : i32 to index + %3 = arith.index_cast %arg3 : i32 to index + %4 = arith.index_cast %arg0 : i32 to index + %5 = polygeist.submap(%arg5, %0, %4) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%5 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %6 = polygeist.submap(%arg6, %1, %0, %4) {map = #map2} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg7, %1, %0, %4) {map = #map3} : (memref, index, index, index) -> memref + %8 = polygeist.submap(%arg5, %1, %0, %4) {map = #map4} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %17 = arith.mulf %in, %in_0 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } + %9 = polygeist.submap(%arg8, %3, %0) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%9 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %10 = polygeist.submap(%arg9, %2, %3, %0) {map = #map2} : (memref, index, index, index) -> memref + %11 = polygeist.submap(%arg10, %2, %3, %0) {map = #map3} : (memref, index, index, index) -> memref + %12 = polygeist.submap(%arg8, %2, %3, %0) {map = #map4} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "reduction"]} ins(%10, %11 : memref, memref) outs(%12 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %17 = arith.mulf %in, %in_0 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } + %13 = polygeist.submap(%arg11, %3, %4) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%13 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %14 = polygeist.submap(%arg5, %0, %3, %4) {map = #map2} : (memref, index, index, index) -> memref + %15 = polygeist.submap(%arg8, %0, %3, %4) {map = #map3} : (memref, index, index, index) -> memref + %16 = polygeist.submap(%arg11, %0, %3, %4) {map = #map4} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "reduction"]} ins(%14, %15 : memref, memref) outs(%16 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %17 = arith.mulf %in, %in_0 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } + return + } +} + diff --git a/polybench_results/adi.log b/polybench_results/adi.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/adi.mlir b/polybench_results/adi.mlir new file mode 100644 index 000000000000..4ec0e2f007c7 --- /dev/null +++ b/polybench_results/adi.mlir @@ -0,0 +1,104 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_adi(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f64 + %cst_0 = arith.constant 2.000000e+00 : f64 + %cst_1 = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.sitofp %arg1 : i32 to f64 + %2 = arith.divf %cst, %1 : f64 + %3 = arith.sitofp %arg0 : i32 to f64 + %4 = arith.divf %cst, %3 : f64 + %5 = arith.mulf %4, %cst_0 : f64 + %6 = arith.mulf %2, %2 : f64 + %7 = arith.divf %5, %6 : f64 + %8 = arith.divf %4, %6 : f64 + %9 = arith.negf %7 : f64 + %10 = arith.divf %9, %cst_0 : f64 + %11 = arith.addf %7, %cst : f64 + %12 = arith.negf %8 : f64 + %13 = arith.divf %12, %cst_0 : f64 + %14 = arith.addf %8, %cst : f64 + %15 = arith.index_cast %arg0 : i32 to index + %16 = arith.negf %10 : f64 + %17 = arith.negf %13 : f64 + %18 = arith.mulf %13, %cst_0 : f64 + %19 = arith.addf %18, %cst : f64 + %20 = arith.mulf %10, %cst_0 : f64 + %21 = arith.addf %20, %cst : f64 + affine.for %arg6 = 1 to #map()[%15] { + affine.for %arg7 = 1 to #map1()[%0] { + affine.store %cst, %arg3[0, %arg7] : memref + affine.store %cst_1, %arg4[%arg7, 0] : memref + %22 = affine.load %arg3[0, %arg7] : memref + affine.store %22, %arg5[%arg7, 0] : memref + affine.for %arg8 = 1 to #map1()[%0] { + %23 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %24 = arith.mulf %10, %23 : f64 + %25 = arith.addf %24, %11 : f64 + %26 = arith.divf %16, %25 : f64 + affine.store %26, %arg4[%arg7, %arg8] : memref + %27 = affine.load %arg2[%arg8, %arg7 - 1] : memref + %28 = arith.mulf %17, %27 : f64 + %29 = affine.load %arg2[%arg8, %arg7] : memref + %30 = arith.mulf %19, %29 : f64 + %31 = arith.addf %28, %30 : f64 + %32 = affine.load %arg2[%arg8, %arg7 + 1] : memref + %33 = arith.mulf %13, %32 : f64 + %34 = arith.subf %31, %33 : f64 + %35 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %36 = arith.mulf %10, %35 : f64 + %37 = arith.subf %34, %36 : f64 + %38 = arith.divf %37, %25 : f64 + affine.store %38, %arg5[%arg7, %arg8] : memref + } + affine.store %cst, %arg3[symbol(%0) - 1, %arg7] : memref + affine.for %arg8 = 1 to #map1()[%0] { + %23 = affine.load %arg4[%arg7, -%arg8 + symbol(%0) - 1] : memref + %24 = affine.load %arg3[-%arg8 + symbol(%0), %arg7] : memref + %25 = arith.mulf %23, %24 : f64 + %26 = affine.load %arg5[%arg7, -%arg8 + symbol(%0) - 1] : memref + %27 = arith.addf %25, %26 : f64 + affine.store %27, %arg3[-%arg8 + symbol(%0) - 1, %arg7] : memref + } + } + affine.for %arg7 = 1 to #map1()[%0] { + affine.store %cst, %arg2[%arg7, 0] : memref + affine.store %cst_1, %arg4[%arg7, 0] : memref + %22 = affine.load %arg2[%arg7, 0] : memref + affine.store %22, %arg5[%arg7, 0] : memref + affine.for %arg8 = 1 to #map1()[%0] { + %23 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %24 = arith.mulf %13, %23 : f64 + %25 = arith.addf %24, %14 : f64 + %26 = arith.divf %17, %25 : f64 + affine.store %26, %arg4[%arg7, %arg8] : memref + %27 = affine.load %arg3[%arg7 - 1, %arg8] : memref + %28 = arith.mulf %16, %27 : f64 + %29 = affine.load %arg3[%arg7, %arg8] : memref + %30 = arith.mulf %21, %29 : f64 + %31 = arith.addf %28, %30 : f64 + %32 = affine.load %arg3[%arg7 + 1, %arg8] : memref + %33 = arith.mulf %10, %32 : f64 + %34 = arith.subf %31, %33 : f64 + %35 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %36 = arith.mulf %13, %35 : f64 + %37 = arith.subf %34, %36 : f64 + %38 = arith.divf %37, %25 : f64 + affine.store %38, %arg5[%arg7, %arg8] : memref + } + affine.store %cst, %arg2[%arg7, symbol(%0) - 1] : memref + affine.for %arg8 = 1 to #map1()[%0] { + %23 = affine.load %arg4[%arg7, -%arg8 + symbol(%0) - 1] : memref + %24 = affine.load %arg2[%arg7, -%arg8 + symbol(%0)] : memref + %25 = arith.mulf %23, %24 : f64 + %26 = affine.load %arg5[%arg7, -%arg8 + symbol(%0) - 1] : memref + %27 = arith.addf %25, %26 : f64 + affine.store %27, %arg2[%arg7, -%arg8 + symbol(%0) - 1] : memref + } + } + } + return + } +} diff --git a/polybench_results/adi_debuf.mlir b/polybench_results/adi_debuf.mlir new file mode 100644 index 000000000000..c4a00d980c21 --- /dev/null +++ b/polybench_results/adi_debuf.mlir @@ -0,0 +1,227 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<()[s0] -> (s0 - 1)> +#map2 = affine_map<(d0) -> (0, d0 + 1)> +#map3 = affine_map<(d0) -> (d0)> +#map4 = affine_map<(d0) -> (d0 + 1, 0)> +#map5 = affine_map<(d0, d1) -> (d1 - 1)> +#map6 = affine_map<(d0, d1) -> (d1 + 1)> +#map7 = affine_map<(d0)[s0] -> (s0 - 1, d0 + 1)> +#map8 = affine_map<(d0, d1)[s0] -> (-(d0 + 1) + s0, d1 + 1)> +#map9 = affine_map<(d0, d1)[s0] -> (-(d0 + 1) + s0 - 1, d1 + 1)> +#map10 = affine_map<(d0, d1)[s0] -> (d1 + 1, -(d0 + 1) + s0 - 1)> +#map11 = affine_map<(d0, d1) -> (d0, d1)> +#map12 = affine_map<(d0, d1) -> (d0 - 1)> +#map13 = affine_map<(d0, d1) -> (d0 + 1)> +#map14 = affine_map<(d0)[s0] -> (d0 + 1, s0 - 1)> +#map15 = affine_map<(d0, d1)[s0] -> (d1 + 1, -(d0 + 1) + s0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_adi(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %cst_0 = arith.constant 2.000000e+00 : f64 + %cst_1 = arith.constant 1.000000e+00 : f64 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = arith.index_cast %arg1 : i32 to index + %5 = arith.sitofp %arg1 : i32 to f64 + %6 = arith.divf %cst_1, %5 : f64 + %7 = arith.sitofp %arg0 : i32 to f64 + %8 = arith.divf %cst_1, %7 : f64 + %9 = arith.mulf %8, %cst_0 : f64 + %10 = arith.mulf %6, %6 : f64 + %11 = arith.divf %9, %10 : f64 + %12 = arith.divf %8, %10 : f64 + %13 = arith.negf %11 : f64 + %14 = arith.divf %13, %cst_0 : f64 + %15 = arith.addf %11, %cst_1 : f64 + %16 = arith.negf %12 : f64 + %17 = arith.divf %16, %cst_0 : f64 + %18 = arith.addf %12, %cst_1 : f64 + %19 = arith.index_cast %arg0 : i32 to index + %20 = arith.negf %14 : f64 + %21 = arith.negf %17 : f64 + %22 = arith.mulf %17, %cst_0 : f64 + %23 = arith.addf %22, %cst_1 : f64 + %24 = arith.mulf %14, %cst_0 : f64 + %25 = arith.addf %24, %cst_1 : f64 + %26:4 = affine.for %arg6 = 1 to #map()[%19] iter_args(%arg7 = %3, %arg8 = %2, %arg9 = %1, %arg10 = %0) -> (tensor, tensor, tensor, tensor) { + %31 = affine.apply #map1()[%4] + %32 = arith.subi %31, %c1 : index + %33 = polygeist.submap(%arg8, %32) {map = #map2} : (tensor, index) -> tensor + %34 = linalg.generic {doc = "", indexing_maps = [#map3], iterator_types = ["parallel"], library_call = ""} outs(%33 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_1 : f64 + } -> tensor + %35 = polygeist.submapInverse(%arg8, %34, %32) {map = #map2} : (tensor, tensor, index) -> tensor + %36 = affine.apply #map1()[%4] + %37 = arith.subi %36, %c1 : index + %38 = polygeist.submap(%arg9, %37) {map = #map4} : (tensor, index) -> tensor + %39 = linalg.generic {doc = "", indexing_maps = [#map3], iterator_types = ["parallel"], library_call = ""} outs(%38 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %40 = polygeist.submapInverse(%arg9, %39, %37) {map = #map4} : (tensor, tensor, index) -> tensor + %41 = affine.apply #map1()[%4] + %42 = arith.subi %41, %c1 : index + %43 = polygeist.submap(%35, %42) {map = #map2} : (tensor, index) -> tensor + %44 = polygeist.submap(%arg10, %42) {map = #map4} : (tensor, index) -> tensor + %45 = linalg.generic {doc = "", indexing_maps = [#map3, #map3], iterator_types = ["parallel"], library_call = ""} ins(%43 : tensor) outs(%44 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %46 = polygeist.submapInverse(%arg10, %45, %42) {map = #map4} : (tensor, tensor, index) -> tensor + %47:2 = affine.for %arg11 = 1 to #map1()[%4] iter_args(%arg12 = %40, %arg13 = %46) -> (tensor, tensor) { + %107:2 = affine.for %arg14 = 1 to #map1()[%4] iter_args(%arg15 = %arg12, %arg16 = %arg13) -> (tensor, tensor) { + %108 = affine.apply #map5(%arg11, %arg14) + %extracted = tensor.extract %arg15[%arg11, %108] : tensor + %109 = arith.mulf %14, %extracted : f64 + %110 = arith.addf %109, %15 : f64 + %111 = arith.divf %20, %110 : f64 + %inserted = tensor.insert %111 into %arg15[%arg11, %arg14] : tensor + %112 = affine.apply #map5(%arg14, %arg11) + %extracted_2 = tensor.extract %arg7[%arg14, %112] : tensor + %113 = arith.mulf %21, %extracted_2 : f64 + %extracted_3 = tensor.extract %arg7[%arg14, %arg11] : tensor + %114 = arith.mulf %23, %extracted_3 : f64 + %115 = arith.addf %113, %114 : f64 + %116 = affine.apply #map6(%arg14, %arg11) + %extracted_4 = tensor.extract %arg7[%arg14, %116] : tensor + %117 = arith.mulf %17, %extracted_4 : f64 + %118 = arith.subf %115, %117 : f64 + %119 = affine.apply #map5(%arg11, %arg14) + %extracted_5 = tensor.extract %arg16[%arg11, %119] : tensor + %120 = arith.mulf %14, %extracted_5 : f64 + %121 = arith.subf %118, %120 : f64 + %122 = arith.divf %121, %110 : f64 + %inserted_6 = tensor.insert %122 into %arg16[%arg11, %arg14] : tensor + affine.yield %inserted, %inserted_6 : tensor, tensor + } + affine.yield %107#0, %107#1 : tensor, tensor + } + %48 = affine.apply #map1()[%4] + %49 = arith.subi %48, %c1 : index + %50 = polygeist.submap(%35, %4, %49) {map = #map7} : (tensor, index, index) -> tensor + %51 = linalg.generic {doc = "", indexing_maps = [#map3], iterator_types = ["parallel"], library_call = ""} outs(%50 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_1 : f64 + } -> tensor + %52 = polygeist.submapInverse(%35, %51, %4, %49) {map = #map7} : (tensor, tensor, index, index) -> tensor + %53 = affine.apply #map1()[%4] + %54 = arith.subi %53, %c1 : index + %55 = affine.apply #map1()[%4] + %56 = arith.subi %55, %c1 : index + %57 = affine.apply #map1()[%4] + %58 = arith.subi %57, %c1 : index + %59 = affine.apply #map1()[%4] + %60 = arith.subi %59, %c1 : index + %61 = affine.apply #map1()[%4] + %62 = arith.subi %61, %c1 : index + %63 = polygeist.submap(%52, %4, %58, %54) {map = #map8} : (tensor, index, index, index) -> tensor + %64 = polygeist.submap(%52, %4, %62, %54) {map = #map9} : (tensor, index, index, index) -> tensor + %65 = polygeist.submap(%47#0, %4, %56, %54) {map = #map10} : (tensor, index, index, index) -> tensor + %66 = polygeist.submap(%47#1, %4, %60, %54) {map = #map10} : (tensor, index, index, index) -> tensor + %67 = linalg.generic {doc = "", indexing_maps = [#map11, #map11, #map11, #map11], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%65, %63, %66 : tensor, tensor, tensor) outs(%64 : tensor) { + ^bb0(%in: f64, %in_2: f64, %in_3: f64, %out: f64): + %107 = arith.mulf %in, %in_2 : f64 + %108 = arith.addf %107, %in_3 : f64 + linalg.yield %108 : f64 + } -> tensor + %68 = polygeist.submapInverse(%52, %67, %4, %62, %54) {map = #map9} : (tensor, tensor, index, index, index) -> tensor + %69 = affine.apply #map1()[%4] + %70 = arith.subi %69, %c1 : index + %71 = polygeist.submap(%arg7, %70) {map = #map4} : (tensor, index) -> tensor + %72 = linalg.generic {doc = "", indexing_maps = [#map3], iterator_types = ["parallel"], library_call = ""} outs(%71 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_1 : f64 + } -> tensor + %73 = polygeist.submapInverse(%arg7, %72, %70) {map = #map4} : (tensor, tensor, index) -> tensor + %74 = affine.apply #map1()[%4] + %75 = arith.subi %74, %c1 : index + %76 = polygeist.submap(%47#0, %75) {map = #map4} : (tensor, index) -> tensor + %77 = linalg.generic {doc = "", indexing_maps = [#map3], iterator_types = ["parallel"], library_call = ""} outs(%76 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %78 = polygeist.submapInverse(%47#0, %77, %75) {map = #map4} : (tensor, tensor, index) -> tensor + %79 = affine.apply #map1()[%4] + %80 = arith.subi %79, %c1 : index + %81 = polygeist.submap(%73, %80) {map = #map4} : (tensor, index) -> tensor + %82 = polygeist.submap(%47#1, %80) {map = #map4} : (tensor, index) -> tensor + %83 = linalg.generic {doc = "", indexing_maps = [#map3, #map3], iterator_types = ["parallel"], library_call = ""} ins(%81 : tensor) outs(%82 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %84 = polygeist.submapInverse(%47#1, %83, %80) {map = #map4} : (tensor, tensor, index) -> tensor + %85:2 = affine.for %arg11 = 1 to #map1()[%4] iter_args(%arg12 = %78, %arg13 = %84) -> (tensor, tensor) { + %107:2 = affine.for %arg14 = 1 to #map1()[%4] iter_args(%arg15 = %arg12, %arg16 = %arg13) -> (tensor, tensor) { + %108 = affine.apply #map5(%arg11, %arg14) + %extracted = tensor.extract %arg15[%arg11, %108] : tensor + %109 = arith.mulf %17, %extracted : f64 + %110 = arith.addf %109, %18 : f64 + %111 = arith.divf %21, %110 : f64 + %inserted = tensor.insert %111 into %arg15[%arg11, %arg14] : tensor + %112 = affine.apply #map12(%arg11, %arg14) + %extracted_2 = tensor.extract %68[%112, %arg14] : tensor + %113 = arith.mulf %20, %extracted_2 : f64 + %extracted_3 = tensor.extract %68[%arg11, %arg14] : tensor + %114 = arith.mulf %25, %extracted_3 : f64 + %115 = arith.addf %113, %114 : f64 + %116 = affine.apply #map13(%arg11, %arg14) + %extracted_4 = tensor.extract %68[%116, %arg14] : tensor + %117 = arith.mulf %14, %extracted_4 : f64 + %118 = arith.subf %115, %117 : f64 + %119 = affine.apply #map5(%arg11, %arg14) + %extracted_5 = tensor.extract %arg16[%arg11, %119] : tensor + %120 = arith.mulf %17, %extracted_5 : f64 + %121 = arith.subf %118, %120 : f64 + %122 = arith.divf %121, %110 : f64 + %inserted_6 = tensor.insert %122 into %arg16[%arg11, %arg14] : tensor + affine.yield %inserted, %inserted_6 : tensor, tensor + } + affine.yield %107#0, %107#1 : tensor, tensor + } + %86 = affine.apply #map1()[%4] + %87 = arith.subi %86, %c1 : index + %88 = polygeist.submap(%73, %4, %87) {map = #map14} : (tensor, index, index) -> tensor + %89 = linalg.generic {doc = "", indexing_maps = [#map3], iterator_types = ["parallel"], library_call = ""} outs(%88 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_1 : f64 + } -> tensor + %90 = polygeist.submapInverse(%73, %89, %4, %87) {map = #map14} : (tensor, tensor, index, index) -> tensor + %91 = affine.apply #map1()[%4] + %92 = arith.subi %91, %c1 : index + %93 = affine.apply #map1()[%4] + %94 = arith.subi %93, %c1 : index + %95 = affine.apply #map1()[%4] + %96 = arith.subi %95, %c1 : index + %97 = affine.apply #map1()[%4] + %98 = arith.subi %97, %c1 : index + %99 = affine.apply #map1()[%4] + %100 = arith.subi %99, %c1 : index + %101 = polygeist.submap(%90, %4, %96, %92) {map = #map15} : (tensor, index, index, index) -> tensor + %102 = polygeist.submap(%90, %4, %100, %92) {map = #map10} : (tensor, index, index, index) -> tensor + %103 = polygeist.submap(%85#0, %4, %94, %92) {map = #map10} : (tensor, index, index, index) -> tensor + %104 = polygeist.submap(%85#1, %4, %98, %92) {map = #map10} : (tensor, index, index, index) -> tensor + %105 = linalg.generic {doc = "", indexing_maps = [#map11, #map11, #map11, #map11], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%103, %101, %104 : tensor, tensor, tensor) outs(%102 : tensor) { + ^bb0(%in: f64, %in_2: f64, %in_3: f64, %out: f64): + %107 = arith.mulf %in, %in_2 : f64 + %108 = arith.addf %107, %in_3 : f64 + linalg.yield %108 : f64 + } -> tensor + %106 = polygeist.submapInverse(%90, %105, %4, %100, %92) {map = #map10} : (tensor, tensor, index, index, index) -> tensor + affine.yield %106, %68, %85#0, %85#1 : tensor, tensor, tensor, tensor + } + %27 = bufferization.to_memref %26#3 : memref + memref.copy %27, %arg5 : memref to memref + %28 = bufferization.to_memref %26#2 : memref + memref.copy %28, %arg4 : memref to memref + %29 = bufferization.to_memref %26#1 : memref + memref.copy %29, %arg3 : memref to memref + %30 = bufferization.to_memref %26#0 : memref + memref.copy %30, %arg2 : memref to memref + return + } +} + diff --git a/polybench_results/adi_linalg.mlir b/polybench_results/adi_linalg.mlir new file mode 100644 index 000000000000..6c5bd6494a67 --- /dev/null +++ b/polybench_results/adi_linalg.mlir @@ -0,0 +1,188 @@ +#map = affine_map<()[s0] -> (s0 + 1)> +#map1 = affine_map<()[s0] -> (s0 - 1)> +#map2 = affine_map<(d0) -> (0, d0 + 1)> +#map3 = affine_map<(d0) -> (d0)> +#map4 = affine_map<(d0) -> (d0 + 1, 0)> +#map5 = affine_map<(d0)[s0] -> (s0 - 1, d0 + 1)> +#map6 = affine_map<(d0, d1)[s0] -> (d1 + 1, -(d0 + 1) + s0 - 1)> +#map7 = affine_map<(d0, d1)[s0] -> (-(d0 + 1) + s0, d1 + 1)> +#map8 = affine_map<(d0, d1)[s0] -> (-(d0 + 1) + s0 - 1, d1 + 1)> +#map9 = affine_map<(d0, d1) -> (d0, d1)> +#map10 = affine_map<(d0)[s0] -> (d0 + 1, s0 - 1)> +#map11 = affine_map<(d0, d1)[s0] -> (d1 + 1, -(d0 + 1) + s0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_adi(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 1.000000e+00 : f64 + %cst_0 = arith.constant 2.000000e+00 : f64 + %cst_1 = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.sitofp %arg1 : i32 to f64 + %2 = arith.divf %cst, %1 : f64 + %3 = arith.sitofp %arg0 : i32 to f64 + %4 = arith.divf %cst, %3 : f64 + %5 = arith.mulf %4, %cst_0 : f64 + %6 = arith.mulf %2, %2 : f64 + %7 = arith.divf %5, %6 : f64 + %8 = arith.divf %4, %6 : f64 + %9 = arith.negf %7 : f64 + %10 = arith.divf %9, %cst_0 : f64 + %11 = arith.addf %7, %cst : f64 + %12 = arith.negf %8 : f64 + %13 = arith.divf %12, %cst_0 : f64 + %14 = arith.addf %8, %cst : f64 + %15 = arith.index_cast %arg0 : i32 to index + %16 = arith.negf %10 : f64 + %17 = arith.negf %13 : f64 + %18 = arith.mulf %13, %cst_0 : f64 + %19 = arith.addf %18, %cst : f64 + %20 = arith.mulf %10, %cst_0 : f64 + %21 = arith.addf %20, %cst : f64 + affine.for %arg6 = 1 to #map()[%15] { + %22 = affine.apply #map1()[%0] + %23 = arith.subi %22, %c1 : index + %24 = polygeist.submap(%arg3, %23) {map = #map2} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map3], iterator_types = ["parallel"]} outs(%24 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %25 = affine.apply #map1()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg4, %26) {map = #map4} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map3], iterator_types = ["parallel"]} outs(%27 : memref) { + ^bb0(%out: f64): + linalg.yield %cst_1 : f64 + } + %28 = affine.apply #map1()[%0] + %29 = arith.subi %28, %c1 : index + %30 = polygeist.submap(%arg3, %29) {map = #map2} : (memref, index) -> memref + %31 = polygeist.submap(%arg5, %29) {map = #map4} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3], iterator_types = ["parallel"]} ins(%30 : memref) outs(%31 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + affine.for %arg7 = 1 to #map1()[%0] { + affine.for %arg8 = 1 to #map1()[%0] { + %76 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %77 = arith.mulf %10, %76 : f64 + %78 = arith.addf %77, %11 : f64 + %79 = arith.divf %16, %78 : f64 + affine.store %79, %arg4[%arg7, %arg8] : memref + %80 = affine.load %arg2[%arg8, %arg7 - 1] : memref + %81 = arith.mulf %17, %80 : f64 + %82 = affine.load %arg2[%arg8, %arg7] : memref + %83 = arith.mulf %19, %82 : f64 + %84 = arith.addf %81, %83 : f64 + %85 = affine.load %arg2[%arg8, %arg7 + 1] : memref + %86 = arith.mulf %13, %85 : f64 + %87 = arith.subf %84, %86 : f64 + %88 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %89 = arith.mulf %10, %88 : f64 + %90 = arith.subf %87, %89 : f64 + %91 = arith.divf %90, %78 : f64 + affine.store %91, %arg5[%arg7, %arg8] : memref + } {polygeist.was_parallel} + } {polygeist.was_parallel} + %32 = affine.apply #map1()[%0] + %33 = arith.subi %32, %c1 : index + %34 = polygeist.submap(%arg3, %0, %33) {map = #map5} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map3], iterator_types = ["parallel"]} outs(%34 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %35 = affine.apply #map1()[%0] + %36 = arith.subi %35, %c1 : index + %37 = affine.apply #map1()[%0] + %38 = arith.subi %37, %c1 : index + %39 = polygeist.submap(%arg4, %0, %38, %36) {map = #map6} : (memref, index, index, index) -> memref + %40 = affine.apply #map1()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg3, %0, %41, %36) {map = #map7} : (memref, index, index, index) -> memref + %43 = affine.apply #map1()[%0] + %44 = arith.subi %43, %c1 : index + %45 = polygeist.submap(%arg5, %0, %44, %36) {map = #map6} : (memref, index, index, index) -> memref + %46 = affine.apply #map1()[%0] + %47 = arith.subi %46, %c1 : index + %48 = polygeist.submap(%arg3, %0, %47, %36) {map = #map8} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map9, #map9, #map9, #map9], iterator_types = ["parallel", "parallel"]} ins(%39, %42, %45 : memref, memref, memref) outs(%48 : memref) { + ^bb0(%in: f64, %in_2: f64, %in_3: f64, %out: f64): + %76 = arith.mulf %in, %in_2 : f64 + %77 = arith.addf %76, %in_3 : f64 + linalg.yield %77 : f64 + } + %49 = affine.apply #map1()[%0] + %50 = arith.subi %49, %c1 : index + %51 = polygeist.submap(%arg2, %50) {map = #map4} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map3], iterator_types = ["parallel"]} outs(%51 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %52 = affine.apply #map1()[%0] + %53 = arith.subi %52, %c1 : index + %54 = polygeist.submap(%arg4, %53) {map = #map4} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map3], iterator_types = ["parallel"]} outs(%54 : memref) { + ^bb0(%out: f64): + linalg.yield %cst_1 : f64 + } + %55 = affine.apply #map1()[%0] + %56 = arith.subi %55, %c1 : index + %57 = polygeist.submap(%arg2, %56) {map = #map4} : (memref, index) -> memref + %58 = polygeist.submap(%arg5, %56) {map = #map4} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3], iterator_types = ["parallel"]} ins(%57 : memref) outs(%58 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + affine.for %arg7 = 1 to #map1()[%0] { + affine.for %arg8 = 1 to #map1()[%0] { + %76 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %77 = arith.mulf %13, %76 : f64 + %78 = arith.addf %77, %14 : f64 + %79 = arith.divf %17, %78 : f64 + affine.store %79, %arg4[%arg7, %arg8] : memref + %80 = affine.load %arg3[%arg7 - 1, %arg8] : memref + %81 = arith.mulf %16, %80 : f64 + %82 = affine.load %arg3[%arg7, %arg8] : memref + %83 = arith.mulf %21, %82 : f64 + %84 = arith.addf %81, %83 : f64 + %85 = affine.load %arg3[%arg7 + 1, %arg8] : memref + %86 = arith.mulf %10, %85 : f64 + %87 = arith.subf %84, %86 : f64 + %88 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %89 = arith.mulf %13, %88 : f64 + %90 = arith.subf %87, %89 : f64 + %91 = arith.divf %90, %78 : f64 + affine.store %91, %arg5[%arg7, %arg8] : memref + } {polygeist.was_parallel} + } {polygeist.was_parallel} + %59 = affine.apply #map1()[%0] + %60 = arith.subi %59, %c1 : index + %61 = polygeist.submap(%arg2, %0, %60) {map = #map10} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map3], iterator_types = ["parallel"]} outs(%61 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %62 = affine.apply #map1()[%0] + %63 = arith.subi %62, %c1 : index + %64 = affine.apply #map1()[%0] + %65 = arith.subi %64, %c1 : index + %66 = polygeist.submap(%arg4, %0, %65, %63) {map = #map6} : (memref, index, index, index) -> memref + %67 = affine.apply #map1()[%0] + %68 = arith.subi %67, %c1 : index + %69 = polygeist.submap(%arg2, %0, %68, %63) {map = #map11} : (memref, index, index, index) -> memref + %70 = affine.apply #map1()[%0] + %71 = arith.subi %70, %c1 : index + %72 = polygeist.submap(%arg5, %0, %71, %63) {map = #map6} : (memref, index, index, index) -> memref + %73 = affine.apply #map1()[%0] + %74 = arith.subi %73, %c1 : index + %75 = polygeist.submap(%arg2, %0, %74, %63) {map = #map6} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map9, #map9, #map9, #map9], iterator_types = ["parallel", "parallel"]} ins(%66, %69, %72 : memref, memref, memref) outs(%75 : memref) { + ^bb0(%in: f64, %in_2: f64, %in_3: f64, %out: f64): + %76 = arith.mulf %in, %in_2 : f64 + %77 = arith.addf %76, %in_3 : f64 + linalg.yield %77 : f64 + } + } + return + } +} + diff --git a/polybench_results/atax.log b/polybench_results/atax.log new file mode 100644 index 000000000000..6385544d075c --- /dev/null +++ b/polybench_results/atax.log @@ -0,0 +1,36 @@ +/home/arjaiswal/Polygeist/polybench_results/atax.mlir:2:3: warning: Distribute+Raising didn't converge, continuing anyway + func.func @kernel_atax(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +/home/arjaiswal/Polygeist/polybench_results/atax.mlir:2:3: note: see current operation: +func.func @kernel_atax(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = polygeist.submap(%arg4, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%1 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = arith.index_cast %arg0 : i32 to index + affine.for %arg6 = 0 to %2 { + affine.store %cst, %arg5[%arg6] : memref + %3 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + return +} diff --git a/polybench_results/atax.mlir b/polybench_results/atax.mlir new file mode 100644 index 000000000000..4e9d033eb6ee --- /dev/null +++ b/polybench_results/atax.mlir @@ -0,0 +1,30 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_atax(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + affine.for %arg6 = 0 to %0 { + affine.store %cst, %arg4[%arg6] : memref + } + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg6 = 0 to %1 { + affine.store %cst, %arg5[%arg6] : memref + affine.for %arg7 = 0 to %0 { + %2 = affine.load %arg5[%arg6] : memref + %3 = affine.load %arg2[%arg6, %arg7] : memref + %4 = affine.load %arg3[%arg7] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %2, %5 : f64 + affine.store %6, %arg5[%arg6] : memref + } + affine.for %arg7 = 0 to %0 { + %2 = affine.load %arg4[%arg7] : memref + %3 = affine.load %arg2[%arg6, %arg7] : memref + %4 = affine.load %arg5[%arg6] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %2, %5 : f64 + affine.store %6, %arg4[%arg7] : memref + } + } + return + } +} diff --git a/polybench_results/atax_debuf.mlir b/polybench_results/atax_debuf.mlir new file mode 100644 index 000000000000..96741ebc03df --- /dev/null +++ b/polybench_results/atax_debuf.mlir @@ -0,0 +1,50 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0)[s0] -> (s0, d0)> +#map2 = affine_map<(d0)[s0] -> (s0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_atax(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = arith.index_cast %arg1 : i32 to index + %5 = polygeist.submap(%1, %4) {map = #map} : (tensor, index) -> tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%5 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %7 = polygeist.submapInverse(%1, %6, %4) {map = #map} : (tensor, tensor, index) -> tensor + %8 = arith.index_cast %arg0 : i32 to index + %9:2 = affine.for %arg6 = 0 to %8 iter_args(%arg7 = %7, %arg8 = %0) -> (tensor, tensor) { + %inserted = tensor.insert %cst into %arg8[%arg6] : tensor + %12 = polygeist.submap(%3, %arg6, %4) {map = #map1} : (tensor, index, index) -> tensor + %13 = polygeist.submap(%2, %4) {map = #map} : (tensor, index) -> tensor + %14 = polygeist.submap(%inserted, %arg6, %4) {map = #map2} : (tensor, index, index) -> tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["reduction"], library_call = ""} ins(%12, %13 : tensor, tensor) outs(%14 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %22 = arith.mulf %in, %in_0 : f64 + %23 = arith.addf %out, %22 : f64 + linalg.yield %23 : f64 + } -> tensor + %16 = polygeist.submapInverse(%inserted, %15, %arg6, %4) {map = #map2} : (tensor, tensor, index, index) -> tensor + %17 = polygeist.submap(%3, %arg6, %4) {map = #map1} : (tensor, index, index) -> tensor + %18 = polygeist.submap(%arg7, %4) {map = #map} : (tensor, index) -> tensor + %19 = polygeist.submap(%16, %arg6, %4) {map = #map2} : (tensor, index, index) -> tensor + %20 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["parallel"], library_call = ""} ins(%17, %19 : tensor, tensor) outs(%18 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %22 = arith.mulf %in, %in_0 : f64 + %23 = arith.addf %out, %22 : f64 + linalg.yield %23 : f64 + } -> tensor + %21 = polygeist.submapInverse(%arg7, %20, %4) {map = #map} : (tensor, tensor, index) -> tensor + affine.yield %21, %16 : tensor, tensor + } + %10 = bufferization.to_memref %9#1 : memref + memref.copy %10, %arg5 : memref to memref + %11 = bufferization.to_memref %9#0 : memref + memref.copy %11, %arg4 : memref to memref + return + } +} + diff --git a/polybench_results/atax_linalg.mlir b/polybench_results/atax_linalg.mlir new file mode 100644 index 000000000000..612cbf48a03c --- /dev/null +++ b/polybench_results/atax_linalg.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0)[s0] -> (s0, d0)> +#map2 = affine_map<(d0)[s0] -> (s0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_atax(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = polygeist.submap(%arg4, %0) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%1 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = arith.index_cast %arg0 : i32 to index + affine.for %arg6 = 0 to %2 { + affine.store %cst, %arg5[%arg6] : memref + %3 = polygeist.submap(%arg2, %arg6, %0) {map = #map1} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %0) {map = #map} : (memref, index) -> memref + %5 = polygeist.submap(%arg5, %arg6, %0) {map = #map2} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = polygeist.submap(%arg2, %arg6, %0) {map = #map1} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg6, %0) {map = #map2} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %0) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + return + } +} + diff --git a/polybench_results/bicg.log b/polybench_results/bicg.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/bicg.mlir b/polybench_results/bicg.mlir new file mode 100644 index 000000000000..38f75b451d49 --- /dev/null +++ b/polybench_results/bicg.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_bicg(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg7 = 0 to %0 { + affine.store %cst, %arg3[%arg7] : memref + } + %1 = arith.index_cast %arg1 : i32 to index + affine.for %arg7 = 0 to %1 { + affine.store %cst, %arg4[%arg7] : memref + affine.for %arg8 = 0 to %0 { + %2 = affine.load %arg3[%arg8] : memref + %3 = affine.load %arg6[%arg7] : memref + %4 = affine.load %arg2[%arg7, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %2, %5 : f64 + affine.store %6, %arg3[%arg8] : memref + %7 = affine.load %arg4[%arg7] : memref + %8 = affine.load %arg2[%arg7, %arg8] : memref + %9 = affine.load %arg5[%arg8] : memref + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + affine.store %11, %arg4[%arg7] : memref + } + } + return + } +} diff --git a/polybench_results/bicg_debuf.mlir b/polybench_results/bicg_debuf.mlir new file mode 100644 index 000000000000..ff0666dad8ac --- /dev/null +++ b/polybench_results/bicg_debuf.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_bicg(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = bufferization.to_tensor %arg2 : memref + %5 = arith.index_cast %arg0 : i32 to index + %6 = polygeist.submap(%3, %5) {map = #map} : (tensor, index) -> tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%6 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %8 = polygeist.submapInverse(%3, %7, %5) {map = #map} : (tensor, tensor, index) -> tensor + %9 = arith.index_cast %arg1 : i32 to index + %10:2 = affine.for %arg7 = 0 to %9 iter_args(%arg8 = %8, %arg9 = %2) -> (tensor, tensor) { + %inserted = tensor.insert %cst into %arg9[%arg7] : tensor + %13:2 = affine.for %arg10 = 0 to %5 iter_args(%arg11 = %arg8, %arg12 = %inserted) -> (tensor, tensor) { + %extracted = tensor.extract %arg11[%arg10] : tensor + %extracted_0 = tensor.extract %0[%arg7] : tensor + %extracted_1 = tensor.extract %4[%arg7, %arg10] : tensor + %14 = arith.mulf %extracted_0, %extracted_1 : f64 + %15 = arith.addf %extracted, %14 : f64 + %inserted_2 = tensor.insert %15 into %arg11[%arg10] : tensor + %extracted_3 = tensor.extract %arg12[%arg7] : tensor + %extracted_4 = tensor.extract %4[%arg7, %arg10] : tensor + %extracted_5 = tensor.extract %1[%arg10] : tensor + %16 = arith.mulf %extracted_4, %extracted_5 : f64 + %17 = arith.addf %extracted_3, %16 : f64 + %inserted_6 = tensor.insert %17 into %arg12[%arg7] : tensor + affine.yield %inserted_2, %inserted_6 : tensor, tensor + } + affine.yield %13#0, %13#1 : tensor, tensor + } + %11 = bufferization.to_memref %10#1 : memref + memref.copy %11, %arg4 : memref to memref + %12 = bufferization.to_memref %10#0 : memref + memref.copy %12, %arg3 : memref to memref + return + } +} + diff --git a/polybench_results/bicg_linalg.mlir b/polybench_results/bicg_linalg.mlir new file mode 100644 index 000000000000..4405be28af24 --- /dev/null +++ b/polybench_results/bicg_linalg.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_bicg(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %1 = polygeist.submap(%arg3, %0) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%1 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = arith.index_cast %arg1 : i32 to index + affine.for %arg7 = 0 to %2 { + affine.store %cst, %arg4[%arg7] : memref + affine.for %arg8 = 0 to %0 { + %3 = affine.load %arg3[%arg8] : memref + %4 = affine.load %arg6[%arg7] : memref + %5 = affine.load %arg2[%arg7, %arg8] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + affine.store %7, %arg3[%arg8] : memref + %8 = affine.load %arg4[%arg7] : memref + %9 = affine.load %arg2[%arg7, %arg8] : memref + %10 = affine.load %arg5[%arg8] : memref + %11 = arith.mulf %9, %10 : f64 + %12 = arith.addf %8, %11 : f64 + affine.store %12, %arg4[%arg7] : memref + } + } + return + } +} + diff --git a/polybench_results/cholesky.log b/polybench_results/cholesky.log new file mode 100644 index 000000000000..828fecf39d37 --- /dev/null +++ b/polybench_results/cholesky.log @@ -0,0 +1,45 @@ +/home/arjaiswal/Polygeist/polybench_results/cholesky.mlir:3:3: warning: Distribute+Raising didn't converge, continuing anyway + func.func @kernel_cholesky(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +/home/arjaiswal/Polygeist/polybench_results/cholesky.mlir:3:3: note: see current operation: +func.func @kernel_cholesky(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %6 = arith.subi %arg2, %c1 : index + %7 = polygeist.submap(%arg1, %arg2, %6) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg1, %arg3, %6) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg1, %arg2, %arg3, %6) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %13 = arith.mulf %in, %in_0 : f64 + %14 = arith.subf %out, %13 : f64 + %15 = linalg.index 0 : index + %16 = arith.cmpi slt, %15, %arg3 : index + %17 = arith.select %16, %14, %out : f64 + linalg.yield %17 : f64 + } + %10 = affine.load %arg1[%arg3, %arg3] : memref + %11 = affine.load %arg1[%arg2, %arg3] : memref + %12 = arith.divf %11, %10 : f64 + affine.store %12, %arg1[%arg2, %arg3] : memref + } + %1 = arith.subi %0, %c1 : index + %2 = polygeist.submap(%arg1, %arg2, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %1) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + %6 = arith.mulf %in, %in : f64 + %7 = arith.subf %out, %6 : f64 + %8 = linalg.index 0 : index + %9 = arith.cmpi slt, %8, %arg2 : index + %10 = arith.select %9, %7, %out : f64 + linalg.yield %10 : f64 + } + %4 = affine.load %arg1[%arg2, %arg2] : memref + %5 = math.sqrt %4 : f64 + affine.store %5, %arg1[%arg2, %arg2] : memref + } + return +} diff --git a/polybench_results/cholesky.mlir b/polybench_results/cholesky.mlir new file mode 100644 index 000000000000..458a32a3cc3b --- /dev/null +++ b/polybench_results/cholesky.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_cholesky(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to #map(%arg2) { + affine.for %arg4 = 0 to #map(%arg3) { + %6 = affine.load %arg1[%arg2, %arg4] : memref + %7 = affine.load %arg1[%arg3, %arg4] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.subf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref + } + %3 = affine.load %arg1[%arg3, %arg3] : memref + %4 = affine.load %arg1[%arg2, %arg3] : memref + %5 = arith.divf %4, %3 : f64 + affine.store %5, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = 0 to #map(%arg2) { + %3 = affine.load %arg1[%arg2, %arg3] : memref + %4 = arith.mulf %3, %3 : f64 + %5 = affine.load %arg1[%arg2, %arg2] : memref + %6 = arith.subf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg2] : memref + } + %1 = affine.load %arg1[%arg2, %arg2] : memref + %2 = math.sqrt %1 : f64 + affine.store %2, %arg1[%arg2, %arg2] : memref + } + return + } +} diff --git a/polybench_results/cholesky_debuf.mlir b/polybench_results/cholesky_debuf.mlir new file mode 100644 index 000000000000..937420c5bb7c --- /dev/null +++ b/polybench_results/cholesky_debuf.mlir @@ -0,0 +1,55 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0)[s0] -> (s0, d0)> +#map2 = affine_map<(d0)[s0, s1] -> (s0, s1)> +#map3 = affine_map<(d0)[s0] -> (s0, s0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_cholesky(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = arith.index_cast %arg0 : i32 to index + %2 = affine.for %arg2 = 0 to %1 iter_args(%arg3 = %0) -> (tensor) { + %4 = affine.for %arg4 = 0 to #map(%arg2) iter_args(%arg5 = %arg3) -> (tensor) { + %11 = arith.subi %arg2, %c1 : index + %12 = polygeist.submap(%arg5, %arg2, %11) {map = #map1} : (tensor, index, index) -> tensor + %13 = polygeist.submap(%arg5, %arg4, %11) {map = #map1} : (tensor, index, index) -> tensor + %14 = polygeist.submap(%arg5, %arg2, %arg4, %11) {map = #map2} : (tensor, index, index, index) -> tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["reduction"], library_call = ""} ins(%12, %13 : tensor, tensor) outs(%14 : tensor) { + ^bb0(%in: f64, %in_3: f64, %out: f64): + %18 = arith.mulf %in, %in_3 : f64 + %19 = arith.subf %out, %18 : f64 + %20 = linalg.index 0 : index + %21 = arith.cmpi slt, %20, %arg4 : index + %22 = arith.select %21, %19, %out : f64 + linalg.yield %22 : f64 + } -> tensor + %16 = polygeist.submapInverse(%arg5, %15, %arg2, %arg4, %11) {map = #map2} : (tensor, tensor, index, index, index) -> tensor + %extracted_0 = tensor.extract %16[%arg4, %arg4] : tensor + %extracted_1 = tensor.extract %16[%arg2, %arg4] : tensor + %17 = arith.divf %extracted_1, %extracted_0 : f64 + %inserted_2 = tensor.insert %17 into %16[%arg2, %arg4] : tensor + affine.yield %inserted_2 : tensor + } + %5 = arith.subi %1, %c1 : index + %6 = polygeist.submap(%4, %arg2, %5) {map = #map1} : (tensor, index, index) -> tensor + %7 = polygeist.submap(%4, %arg2, %5) {map = #map3} : (tensor, index, index) -> tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["reduction"], library_call = ""} ins(%6 : tensor) outs(%7 : tensor) { + ^bb0(%in: f64, %out: f64): + %11 = arith.mulf %in, %in : f64 + %12 = arith.subf %out, %11 : f64 + %13 = linalg.index 0 : index + %14 = arith.cmpi slt, %13, %arg2 : index + %15 = arith.select %14, %12, %out : f64 + linalg.yield %15 : f64 + } -> tensor + %9 = polygeist.submapInverse(%4, %8, %arg2, %5) {map = #map3} : (tensor, tensor, index, index) -> tensor + %extracted = tensor.extract %9[%arg2, %arg2] : tensor + %10 = math.sqrt %extracted : f64 + %inserted = tensor.insert %10 into %9[%arg2, %arg2] : tensor + affine.yield %inserted : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/polybench_results/cholesky_linalg.mlir b/polybench_results/cholesky_linalg.mlir new file mode 100644 index 000000000000..5223638f4b05 --- /dev/null +++ b/polybench_results/cholesky_linalg.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0)[s0] -> (s0, d0)> +#map2 = affine_map<(d0)[s0, s1] -> (s0, s1)> +#map3 = affine_map<(d0)[s0] -> (s0, s0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_cholesky(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to #map(%arg2) { + %6 = arith.subi %arg2, %c1 : index + %7 = polygeist.submap(%arg1, %arg2, %6) {map = #map1} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg1, %arg3, %6) {map = #map1} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg1, %arg2, %arg3, %6) {map = #map2} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %13 = arith.mulf %in, %in_0 : f64 + %14 = arith.subf %out, %13 : f64 + %15 = linalg.index 0 : index + %16 = arith.cmpi slt, %15, %arg3 : index + %17 = arith.select %16, %14, %out : f64 + linalg.yield %17 : f64 + } + %10 = affine.load %arg1[%arg3, %arg3] : memref + %11 = affine.load %arg1[%arg2, %arg3] : memref + %12 = arith.divf %11, %10 : f64 + affine.store %12, %arg1[%arg2, %arg3] : memref + } + %1 = arith.subi %0, %c1 : index + %2 = polygeist.submap(%arg1, %arg2, %1) {map = #map1} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %1) {map = #map3} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["reduction"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + %6 = arith.mulf %in, %in : f64 + %7 = arith.subf %out, %6 : f64 + %8 = linalg.index 0 : index + %9 = arith.cmpi slt, %8, %arg2 : index + %10 = arith.select %9, %7, %out : f64 + linalg.yield %10 : f64 + } + %4 = affine.load %arg1[%arg2, %arg2] : memref + %5 = math.sqrt %4 : f64 + affine.store %5, %arg1[%arg2, %arg2] : memref + } + return + } +} + diff --git a/polybench_results/correlation.log b/polybench_results/correlation.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/correlation.mlir b/polybench_results/correlation.mlir new file mode 100644 index 000000000000..bde87ca1fb99 --- /dev/null +++ b/polybench_results/correlation.mlir @@ -0,0 +1,72 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +#map1 = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_correlation(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-01 : f64 + %cst_0 = arith.constant 0.000000e+00 : f64 + %cst_1 = arith.constant 1.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg7 = 0 to %1 { + affine.store %cst_0, %arg5[%arg7] : memref + affine.for %arg8 = 0 to %0 { + %5 = affine.load %arg3[%arg8, %arg7] : memref + %6 = affine.load %arg5[%arg7] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg5[%arg7] : memref + } + %3 = affine.load %arg5[%arg7] : memref + %4 = arith.divf %3, %arg2 : f64 + affine.store %4, %arg5[%arg7] : memref + } + affine.for %arg7 = 0 to %1 { + affine.store %cst_0, %arg6[%arg7] : memref + affine.for %arg8 = 0 to %0 { + %8 = affine.load %arg3[%arg8, %arg7] : memref + %9 = affine.load %arg5[%arg7] : memref + %10 = arith.subf %8, %9 : f64 + %11 = arith.mulf %10, %10 : f64 + %12 = affine.load %arg6[%arg7] : memref + %13 = arith.addf %12, %11 : f64 + affine.store %13, %arg6[%arg7] : memref + } + %3 = affine.load %arg6[%arg7] : memref + %4 = arith.divf %3, %arg2 : f64 + %5 = math.sqrt %4 : f64 + %6 = arith.cmpf ole, %5, %cst : f64 + %7 = arith.select %6, %cst_1, %5 : f64 + affine.store %7, %arg6[%arg7] : memref + } + %2 = math.sqrt %arg2 : f64 + affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + %3 = affine.load %arg5[%arg8] : memref + %4 = affine.load %arg3[%arg7, %arg8] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg3[%arg7, %arg8] : memref + %6 = affine.load %arg6[%arg8] : memref + %7 = arith.mulf %2, %6 : f64 + %8 = arith.divf %5, %7 : f64 + affine.store %8, %arg3[%arg7, %arg8] : memref + } + } + affine.for %arg7 = 0 to #map()[%1] { + affine.store %cst_1, %arg4[%arg7, %arg7] : memref + affine.for %arg8 = #map1(%arg7) to %1 { + affine.store %cst_0, %arg4[%arg7, %arg8] : memref + affine.for %arg9 = 0 to %0 { + %4 = affine.load %arg3[%arg9, %arg7] : memref + %5 = affine.load %arg3[%arg9, %arg8] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg4[%arg7, %arg8] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg4[%arg7, %arg8] : memref + } + %3 = affine.load %arg4[%arg7, %arg8] : memref + affine.store %3, %arg4[%arg8, %arg7] : memref + } + } + affine.store %cst_1, %arg4[symbol(%1) - 1, symbol(%1) - 1] : memref + return + } +} diff --git a/polybench_results/correlation_debuf.mlir b/polybench_results/correlation_debuf.mlir new file mode 100644 index 000000000000..1b637b49648c --- /dev/null +++ b/polybench_results/correlation_debuf.mlir @@ -0,0 +1,143 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<()[s0] -> (s0 - 1)> +#map4 = affine_map<(d0) -> (d0, d0)> +#map5 = affine_map<(d0, d1) -> (d1, d0)> +#map6 = affine_map<(d0) -> (d0 + 1)> +#map7 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map8 = affine_map<(d0, d1, d2) -> (d0, d1)> +#map9 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map10 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_correlation(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f64 + %cst_0 = arith.constant 0.000000e+00 : f64 + %cst_1 = arith.constant 1.000000e-01 : f64 + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = arith.index_cast %arg1 : i32 to index + %5 = arith.index_cast %arg0 : i32 to index + %6 = polygeist.submap(%1, %5) {map = #map} : (tensor, index) -> tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%6 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %8 = polygeist.submapInverse(%1, %7, %5) {map = #map} : (tensor, tensor, index) -> tensor + %9 = polygeist.submap(%3, %4, %5) {map = #map1} : (tensor, index, index) -> tensor + %10 = polygeist.submap(%8, %4, %5) {map = #map2} : (tensor, index, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%9 : tensor) outs(%10 : tensor) { + ^bb0(%in: f64, %out: f64): + %54 = arith.addf %out, %in : f64 + linalg.yield %54 : f64 + } -> tensor + %12 = polygeist.submapInverse(%8, %11, %4, %5) {map = #map2} : (tensor, tensor, index, index) -> tensor + %13 = polygeist.submap(%12, %5) {map = #map} : (tensor, index) -> tensor + %14 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%13 : tensor) { + ^bb0(%out: f64): + %54 = arith.divf %out, %arg2 : f64 + linalg.yield %54 : f64 + } -> tensor + %15 = polygeist.submapInverse(%12, %14, %5) {map = #map} : (tensor, tensor, index) -> tensor + %16 = bufferization.to_memref %15 : memref + memref.copy %16, %arg5 : memref to memref + %17 = polygeist.submap(%0, %5) {map = #map} : (tensor, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%17 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %19 = polygeist.submapInverse(%0, %18, %5) {map = #map} : (tensor, tensor, index) -> tensor + %20 = polygeist.submap(%3, %4, %5) {map = #map1} : (tensor, index, index) -> tensor + %21 = polygeist.submap(%15, %4, %5) {map = #map2} : (tensor, index, index) -> tensor + %22 = polygeist.submap(%19, %4, %5) {map = #map2} : (tensor, index, index) -> tensor + %23 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%20, %21 : tensor, tensor) outs(%22 : tensor) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %54 = arith.subf %in, %in_2 : f64 + %55 = arith.mulf %54, %54 : f64 + %56 = arith.addf %out, %55 : f64 + linalg.yield %56 : f64 + } -> tensor + %24 = polygeist.submapInverse(%19, %23, %4, %5) {map = #map2} : (tensor, tensor, index, index) -> tensor + %25 = polygeist.submap(%24, %5) {map = #map} : (tensor, index) -> tensor + %26 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%25 : tensor) { + ^bb0(%out: f64): + %54 = arith.divf %out, %arg2 : f64 + %55 = math.sqrt %54 : f64 + %56 = arith.cmpf ole, %55, %cst_1 : f64 + %57 = arith.select %56, %cst, %55 : f64 + linalg.yield %57 : f64 + } -> tensor + %27 = polygeist.submapInverse(%24, %26, %5) {map = #map} : (tensor, tensor, index) -> tensor + %28 = bufferization.to_memref %27 : memref + memref.copy %28, %arg6 : memref to memref + %29 = math.sqrt %arg2 : f64 + %30 = affine.for %arg7 = 0 to %4 iter_args(%arg8 = %3) -> (tensor) { + %54 = affine.for %arg9 = 0 to %5 iter_args(%arg10 = %arg8) -> (tensor) { + %extracted = tensor.extract %15[%arg9] : tensor + %extracted_2 = tensor.extract %arg10[%arg7, %arg9] : tensor + %55 = arith.subf %extracted_2, %extracted : f64 + %inserted_3 = tensor.insert %55 into %arg10[%arg7, %arg9] : tensor + %extracted_4 = tensor.extract %27[%arg9] : tensor + %56 = arith.mulf %29, %extracted_4 : f64 + %57 = arith.divf %55, %56 : f64 + %inserted_5 = tensor.insert %57 into %inserted_3[%arg7, %arg9] : tensor + affine.yield %inserted_5 : tensor + } + affine.yield %54 : tensor + } + %31 = bufferization.to_memref %30 : memref + memref.copy %31, %arg3 : memref to memref + %32 = affine.apply #map3()[%5] + %33 = polygeist.submap(%2, %32) {map = #map4} : (tensor, index) -> tensor + %34 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%33 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %35 = polygeist.submapInverse(%2, %34, %32) {map = #map4} : (tensor, tensor, index) -> tensor + %36 = affine.apply #map3()[%5] + %37 = polygeist.submap(%35, %5, %36) {map = #map5} : (tensor, index, index) -> tensor + %38 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%37 : tensor) { + ^bb0(%out: f64): + %54 = linalg.index 0 : index + %55 = linalg.index 1 : index + %56 = affine.apply #map6(%54) + %57 = arith.cmpi sge, %55, %56 : index + %58 = arith.select %57, %cst_0, %out : f64 + linalg.yield %58 : f64 + } -> tensor + %39 = polygeist.submapInverse(%35, %38, %5, %36) {map = #map5} : (tensor, tensor, index, index) -> tensor + %40 = affine.apply #map3()[%5] + %41 = polygeist.submap(%30, %4, %5, %40) {map = #map7} : (tensor, index, index, index) -> tensor + %42 = polygeist.submap(%30, %4, %5, %40) {map = #map8} : (tensor, index, index, index) -> tensor + %43 = polygeist.submap(%39, %4, %5, %40) {map = #map9} : (tensor, index, index, index) -> tensor + %44 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10], iterator_types = ["parallel", "parallel", "reduction"], library_call = ""} ins(%41, %42 : tensor, tensor) outs(%43 : tensor) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %54 = arith.mulf %in, %in_2 : f64 + %55 = arith.addf %out, %54 : f64 + linalg.yield %55 : f64 + } -> tensor + %45 = polygeist.submapInverse(%39, %44, %4, %5, %40) {map = #map9} : (tensor, tensor, index, index, index) -> tensor + %46 = affine.apply #map3()[%5] + %47 = polygeist.submap(%45, %5, %46) {map = #map5} : (tensor, index, index) -> tensor + %48 = polygeist.submap(%45, %5, %46) {map = #map1} : (tensor, index, index) -> tensor + %49 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%47 : tensor) outs(%48 : tensor) { + ^bb0(%in: f64, %out: f64): + %54 = linalg.index 0 : index + %55 = linalg.index 1 : index + %56 = affine.apply #map6(%54) + %57 = arith.cmpi sge, %55, %56 : index + %58 = arith.select %57, %in, %out : f64 + linalg.yield %58 : f64 + } -> tensor + %50 = polygeist.submapInverse(%45, %49, %5, %46) {map = #map1} : (tensor, tensor, index, index) -> tensor + %51 = affine.apply #map3()[%5] + %52 = affine.apply #map3()[%5] + %inserted = tensor.insert %cst into %50[%51, %52] : tensor + %53 = bufferization.to_memref %inserted : memref + memref.copy %53, %arg4 : memref to memref + return + } +} + diff --git a/polybench_results/correlation_linalg.mlir b/polybench_results/correlation_linalg.mlir new file mode 100644 index 000000000000..458c69a2c0e9 --- /dev/null +++ b/polybench_results/correlation_linalg.mlir @@ -0,0 +1,117 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<()[s0] -> (s0 - 1)> +#map4 = affine_map<(d0) -> (d0, d0)> +#map5 = affine_map<(d0, d1) -> (d1, d0)> +#map6 = affine_map<(d0) -> (d0 + 1)> +#map7 = affine_map<(d0, d1, d2) -> (d0, d2)> +#map8 = affine_map<(d0, d1, d2) -> (d0, d1)> +#map9 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map10 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_correlation(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e-01 : f64 + %cst_0 = arith.constant 0.000000e+00 : f64 + %cst_1 = arith.constant 1.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + %2 = polygeist.submap(%arg5, %1) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%2 : memref) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } + %3 = polygeist.submap(%arg3, %0, %1) {map = #map1} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg5, %0, %1) {map = #map2} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "reduction"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + %23 = arith.addf %out, %in : f64 + linalg.yield %23 : f64 + } + %5 = polygeist.submap(%arg5, %1) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%5 : memref) { + ^bb0(%out: f64): + %23 = arith.divf %out, %arg2 : f64 + linalg.yield %23 : f64 + } + %6 = polygeist.submap(%arg6, %1) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%6 : memref) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } + %7 = polygeist.submap(%arg3, %0, %1) {map = #map1} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %0, %1) {map = #map2} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg6, %0, %1) {map = #map2} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %23 = arith.subf %in, %in_2 : f64 + %24 = arith.mulf %23, %23 : f64 + %25 = arith.addf %out, %24 : f64 + linalg.yield %25 : f64 + } + %10 = polygeist.submap(%arg6, %1) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%10 : memref) { + ^bb0(%out: f64): + %23 = arith.divf %out, %arg2 : f64 + %24 = math.sqrt %23 : f64 + %25 = arith.cmpf ole, %24, %cst : f64 + %26 = arith.select %25, %cst_1, %24 : f64 + linalg.yield %26 : f64 + } + %11 = math.sqrt %arg2 : f64 + affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + %23 = affine.load %arg5[%arg8] : memref + %24 = affine.load %arg3[%arg7, %arg8] : memref + %25 = arith.subf %24, %23 : f64 + affine.store %25, %arg3[%arg7, %arg8] : memref + %26 = affine.load %arg6[%arg8] : memref + %27 = arith.mulf %11, %26 : f64 + %28 = arith.divf %25, %27 : f64 + affine.store %28, %arg3[%arg7, %arg8] : memref + } {polygeist.was_parallel} + } {polygeist.was_parallel} + %12 = affine.apply #map3()[%1] + %13 = polygeist.submap(%arg4, %12) {map = #map4} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%13 : memref) { + ^bb0(%out: f64): + linalg.yield %cst_1 : f64 + } + %14 = affine.apply #map3()[%1] + %15 = polygeist.submap(%arg4, %1, %14) {map = #map5} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%15 : memref) { + ^bb0(%out: f64): + %23 = linalg.index 0 : index + %24 = linalg.index 1 : index + %25 = affine.apply #map6(%23) + %26 = arith.cmpi sge, %24, %25 : index + %27 = arith.select %26, %cst_0, %out : f64 + linalg.yield %27 : f64 + } + %16 = affine.apply #map3()[%1] + %17 = polygeist.submap(%arg3, %0, %1, %16) {map = #map7} : (memref, index, index, index) -> memref + %18 = polygeist.submap(%arg3, %0, %1, %16) {map = #map8} : (memref, index, index, index) -> memref + %19 = polygeist.submap(%arg4, %0, %1, %16) {map = #map9} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map10, #map10], iterator_types = ["parallel", "parallel", "reduction"]} ins(%17, %18 : memref, memref) outs(%19 : memref) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %23 = arith.mulf %in, %in_2 : f64 + %24 = arith.addf %out, %23 : f64 + linalg.yield %24 : f64 + } + %20 = affine.apply #map3()[%1] + %21 = polygeist.submap(%arg4, %1, %20) {map = #map5} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg4, %1, %20) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%21 : memref) outs(%22 : memref) { + ^bb0(%in: f64, %out: f64): + %23 = linalg.index 0 : index + %24 = linalg.index 1 : index + %25 = affine.apply #map6(%23) + %26 = arith.cmpi sge, %24, %25 : index + %27 = arith.select %26, %in, %out : f64 + linalg.yield %27 : f64 + } + affine.store %cst_1, %arg4[symbol(%1) - 1, symbol(%1) - 1] : memref + return + } +} + diff --git a/polybench_results/covariance.log b/polybench_results/covariance.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/covariance.mlir b/polybench_results/covariance.mlir new file mode 100644 index 000000000000..6f15c77e0017 --- /dev/null +++ b/polybench_results/covariance.mlir @@ -0,0 +1,48 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_covariance(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %cst_0 = arith.constant 1.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg6 = 0 to %1 { + affine.store %cst, %arg5[%arg6] : memref + affine.for %arg7 = 0 to %0 { + %5 = affine.load %arg3[%arg7, %arg6] : memref + %6 = affine.load %arg5[%arg6] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg5[%arg6] : memref + } + %3 = affine.load %arg5[%arg6] : memref + %4 = arith.divf %3, %arg2 : f64 + affine.store %4, %arg5[%arg6] : memref + } + affine.for %arg6 = 0 to %0 { + affine.for %arg7 = 0 to %1 { + %3 = affine.load %arg5[%arg7] : memref + %4 = affine.load %arg3[%arg6, %arg7] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg3[%arg6, %arg7] : memref + } + } + %2 = arith.subf %arg2, %cst_0 : f64 + affine.for %arg6 = 0 to %1 { + affine.for %arg7 = #map(%arg6) to %1 { + affine.store %cst, %arg4[%arg6, %arg7] : memref + affine.for %arg8 = 0 to %0 { + %5 = affine.load %arg3[%arg8, %arg6] : memref + %6 = affine.load %arg3[%arg8, %arg7] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg4[%arg6, %arg7] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg4[%arg6, %arg7] : memref + } + %3 = affine.load %arg4[%arg6, %arg7] : memref + %4 = arith.divf %3, %2 : f64 + affine.store %4, %arg4[%arg6, %arg7] : memref + affine.store %4, %arg4[%arg7, %arg6] : memref + } + } + return + } +} diff --git a/polybench_results/covariance_debuf.mlir b/polybench_results/covariance_debuf.mlir new file mode 100644 index 000000000000..c5ad52224d3f --- /dev/null +++ b/polybench_results/covariance_debuf.mlir @@ -0,0 +1,77 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d1, d0)> +#map4 = affine_map<(d0, d1) -> (d0)> +#map5 = affine_map<(d0)[s0] -> (d0, s0)> +#map6 = affine_map<(d0)[s0, s1] -> (s0, s1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_covariance(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f64 + %cst_0 = arith.constant 0.000000e+00 : f64 + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.index_cast %arg1 : i32 to index + %4 = arith.index_cast %arg0 : i32 to index + %5 = polygeist.submap(%0, %4) {map = #map} : (tensor, index) -> tensor + %6 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%5 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst_0 : f64 + } -> tensor + %7 = polygeist.submapInverse(%0, %6, %4) {map = #map} : (tensor, tensor, index) -> tensor + %8 = polygeist.submap(%2, %3, %4) {map = #map1} : (tensor, index, index) -> tensor + %9 = polygeist.submap(%7, %3, %4) {map = #map2} : (tensor, index, index) -> tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%8 : tensor) outs(%9 : tensor) { + ^bb0(%in: f64, %out: f64): + %24 = arith.addf %out, %in : f64 + linalg.yield %24 : f64 + } -> tensor + %11 = polygeist.submapInverse(%7, %10, %3, %4) {map = #map2} : (tensor, tensor, index, index) -> tensor + %12 = polygeist.submap(%11, %4) {map = #map} : (tensor, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%12 : tensor) { + ^bb0(%out: f64): + %24 = arith.divf %out, %arg2 : f64 + linalg.yield %24 : f64 + } -> tensor + %14 = polygeist.submapInverse(%11, %13, %4) {map = #map} : (tensor, tensor, index) -> tensor + %15 = bufferization.to_memref %14 : memref + memref.copy %15, %arg5 : memref to memref + %16 = polygeist.submap(%2, %4, %3) {map = #map3} : (tensor, index, index) -> tensor + %17 = polygeist.submap(%14, %4, %3) {map = #map4} : (tensor, index, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%17 : tensor) outs(%16 : tensor) { + ^bb0(%in: f64, %out: f64): + %24 = arith.subf %out, %in : f64 + linalg.yield %24 : f64 + } -> tensor + %19 = polygeist.submapInverse(%2, %18, %4, %3) {map = #map3} : (tensor, tensor, index, index) -> tensor + %20 = bufferization.to_memref %19 : memref + memref.copy %20, %arg3 : memref to memref + %21 = arith.subf %arg2, %cst : f64 + %22 = affine.for %arg6 = 0 to %4 iter_args(%arg7 = %1) -> (tensor) { + %24 = affine.for %arg8 = #map(%arg6) to %4 iter_args(%arg9 = %arg7) -> (tensor) { + %inserted = tensor.insert %cst_0 into %arg9[%arg6, %arg8] : tensor + %25 = polygeist.submap(%19, %arg6, %3) {map = #map5} : (tensor, index, index) -> tensor + %26 = polygeist.submap(%19, %arg8, %3) {map = #map5} : (tensor, index, index) -> tensor + %27 = polygeist.submap(%inserted, %arg6, %arg8, %3) {map = #map6} : (tensor, index, index, index) -> tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["reduction"], library_call = ""} ins(%25, %26 : tensor, tensor) outs(%27 : tensor) { + ^bb0(%in: f64, %in_3: f64, %out: f64): + %31 = arith.mulf %in, %in_3 : f64 + %32 = arith.addf %out, %31 : f64 + linalg.yield %32 : f64 + } -> tensor + %29 = polygeist.submapInverse(%inserted, %28, %arg6, %arg8, %3) {map = #map6} : (tensor, tensor, index, index, index) -> tensor + %extracted = tensor.extract %29[%arg6, %arg8] : tensor + %30 = arith.divf %extracted, %21 : f64 + %inserted_1 = tensor.insert %30 into %29[%arg6, %arg8] : tensor + %inserted_2 = tensor.insert %30 into %inserted_1[%arg8, %arg6] : tensor + affine.yield %inserted_2 : tensor + } + affine.yield %24 : tensor + } + %23 = bufferization.to_memref %22 : memref + memref.copy %23, %arg4 : memref to memref + return + } +} + diff --git a/polybench_results/covariance_linalg.mlir b/polybench_results/covariance_linalg.mlir new file mode 100644 index 000000000000..d8a148542d40 --- /dev/null +++ b/polybench_results/covariance_linalg.mlir @@ -0,0 +1,61 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +#map4 = affine_map<(d0, d1) -> (d1, d0)> +#map5 = affine_map<(d0)[s0] -> (d0, s0)> +#map6 = affine_map<(d0)[s0, s1] -> (s0, s1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_covariance(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %cst_0 = arith.constant 1.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + %2 = polygeist.submap(%arg5, %1) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%2 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %3 = polygeist.submap(%arg3, %0, %1) {map = #map1} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg5, %0, %1) {map = #map2} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "reduction"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + %9 = arith.addf %out, %in : f64 + linalg.yield %9 : f64 + } + %5 = polygeist.submap(%arg5, %1) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%5 : memref) { + ^bb0(%out: f64): + %9 = arith.divf %out, %arg2 : f64 + linalg.yield %9 : f64 + } + %6 = polygeist.submap(%arg5, %1, %0) {map = #map3} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg3, %1, %0) {map = #map4} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel"]} ins(%6 : memref) outs(%7 : memref) { + ^bb0(%in: f64, %out: f64): + %9 = arith.subf %out, %in : f64 + linalg.yield %9 : f64 + } + %8 = arith.subf %arg2, %cst_0 : f64 + affine.for %arg6 = 0 to %1 { + affine.for %arg7 = #map(%arg6) to %1 { + affine.store %cst, %arg4[%arg6, %arg7] : memref + %9 = polygeist.submap(%arg3, %arg6, %0) {map = #map5} : (memref, index, index) -> memref + %10 = polygeist.submap(%arg3, %arg7, %0) {map = #map5} : (memref, index, index) -> memref + %11 = polygeist.submap(%arg4, %arg6, %arg7, %0) {map = #map6} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["reduction"]} ins(%9, %10 : memref, memref) outs(%11 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %14 = arith.mulf %in, %in_1 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 + } + %12 = affine.load %arg4[%arg6, %arg7] : memref + %13 = arith.divf %12, %8 : f64 + affine.store %13, %arg4[%arg6, %arg7] : memref + affine.store %13, %arg4[%arg7, %arg6] : memref + } {polygeist.was_parallel} + } {polygeist.was_parallel} + return + } +} + diff --git a/polybench_results/deriche.log b/polybench_results/deriche.log new file mode 100644 index 000000000000..208ba770da61 --- /dev/null +++ b/polybench_results/deriche.log @@ -0,0 +1,60 @@ +/home/arjaiswal/Polygeist/polybench_results/deriche.mlir:2:3: warning: Distribute+Raising didn't converge, continuing anyway + func.func @kernel_deriche(%arg0: i32, %arg1: i32, %arg2: f32, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +/home/arjaiswal/Polygeist/polybench_results/deriche.mlir:2:3: note: see current operation: +func.func @kernel_deriche(%arg0: i32, %arg1: i32, %arg2: f32, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 2.000000e+00 : f32 + %cst_1 = arith.constant -2.000000e+00 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %0 = arith.index_cast %arg1 : i32 to index + %1 = llvm.mlir.undef : f32 + %alloca = memref.alloca() : memref + affine.store %1, %alloca[] : memref + %alloca_3 = memref.alloca() : memref + affine.store %1, %alloca_3[] : memref + %alloca_4 = memref.alloca() : memref + affine.store %1, %alloca_4[] : memref + %2 = arith.negf %arg2 : f32 + %3 = math.exp %2 : f32 + %4 = arith.subf %cst, %3 : f32 + %5 = arith.mulf %4, %4 : f32 + %6 = arith.mulf %arg2, %cst_0 : f32 + %7 = arith.mulf %6, %3 : f32 + %8 = arith.addf %7, %cst : f32 + %9 = math.exp %6 : f32 + %10 = arith.subf %8, %9 : f32 + %11 = arith.divf %5, %10 : f32 + %12 = arith.mulf %11, %3 : f32 + %13 = arith.subf %arg2, %cst : f32 + %14 = arith.mulf %12, %13 : f32 + %15 = math.powf %cst_0, %2 : f32 + %16 = arith.mulf %arg2, %cst_1 : f32 + %17 = math.exp %16 : f32 + %18 = arith.negf %17 : f32 + %19 = arith.index_cast %arg0 : i32 to index + affine.for %arg7 = 0 to %19 { + affine.store %cst_2, %alloca_3[] : memref + affine.store %cst_2, %alloca[] : memref + affine.store %cst_2, %alloca_4[] : memref + %20 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %21 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %24 = polygeist.submap(%alloca_4, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %25 = polygeist.submap(%alloca, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %26 = polygeist.submap(%alloca_3, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%20, %21, %22 : memref, memref, memref) outs(%23, %24, %25, %26 : memref, memref, memref, memref) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %27 = arith.mulf %11, %in : f32 + %28 = arith.mulf %14, %out_7 : f32 + %29 = arith.addf %27, %28 : f32 + %30 = arith.mulf %15, %out_9 : f32 + %31 = arith.addf %29, %30 : f32 + %32 = arith.mulf %18, %out_8 : f32 + %33 = arith.addf %31, %32 : f32 + linalg.yield %33, %in_5, %out_9, %in_6 : f32, f32, f32, f32 + } + } + return +} diff --git a/polybench_results/deriche.mlir b/polybench_results/deriche.mlir new file mode 100644 index 000000000000..23ca05ccee51 --- /dev/null +++ b/polybench_results/deriche.mlir @@ -0,0 +1,59 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_deriche(%arg0: i32, %arg1: i32, %arg2: f32, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 2.000000e+00 : f32 + %cst_1 = arith.constant -2.000000e+00 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %0 = arith.index_cast %arg1 : i32 to index + %1 = llvm.mlir.undef : f32 + %alloca = memref.alloca() : memref + affine.store %1, %alloca[] : memref + %alloca_3 = memref.alloca() : memref + affine.store %1, %alloca_3[] : memref + %alloca_4 = memref.alloca() : memref + affine.store %1, %alloca_4[] : memref + %2 = arith.negf %arg2 : f32 + %3 = math.exp %2 : f32 + %4 = arith.subf %cst, %3 : f32 + %5 = arith.mulf %4, %4 : f32 + %6 = arith.mulf %arg2, %cst_0 : f32 + %7 = arith.mulf %6, %3 : f32 + %8 = arith.addf %7, %cst : f32 + %9 = math.exp %6 : f32 + %10 = arith.subf %8, %9 : f32 + %11 = arith.divf %5, %10 : f32 + %12 = arith.mulf %11, %3 : f32 + %13 = arith.subf %arg2, %cst : f32 + %14 = arith.mulf %12, %13 : f32 + %15 = math.powf %cst_0, %2 : f32 + %16 = arith.mulf %arg2, %cst_1 : f32 + %17 = math.exp %16 : f32 + %18 = arith.negf %17 : f32 + %19 = arith.index_cast %arg0 : i32 to index + affine.for %arg7 = 0 to %19 { + affine.store %cst_2, %alloca_3[] : memref + affine.store %cst_2, %alloca[] : memref + affine.store %cst_2, %alloca_4[] : memref + affine.for %arg8 = 0 to %0 { + %20 = affine.load %arg3[%arg7, %arg8] : memref + %21 = arith.mulf %11, %20 : f32 + %22 = affine.load %alloca_4[] : memref + %23 = arith.mulf %14, %22 : f32 + %24 = arith.addf %21, %23 : f32 + %25 = affine.load %alloca_3[] : memref + %26 = arith.mulf %15, %25 : f32 + %27 = arith.addf %24, %26 : f32 + %28 = affine.load %alloca[] : memref + %29 = arith.mulf %18, %28 : f32 + %30 = arith.addf %27, %29 : f32 + affine.store %30, %arg5[%arg7, %arg8] : memref + %31 = affine.load %arg3[%arg7, %arg8] : memref + affine.store %31, %alloca_4[] : memref + affine.store %25, %alloca[] : memref + %32 = affine.load %arg5[%arg7, %arg8] : memref + affine.store %32, %alloca_3[] : memref + } + } + return + } +} diff --git a/polybench_results/deriche_debuf.mlir b/polybench_results/deriche_debuf.mlir new file mode 100644 index 000000000000..a1102e37f24b --- /dev/null +++ b/polybench_results/deriche_debuf.mlir @@ -0,0 +1,71 @@ +#map = affine_map<(d0) -> ()> +#map1 = affine_map<(d0)[s0] -> (s0, d0)> +#map2 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_deriche(%arg0: i32, %arg1: i32, %arg2: f32, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f32 + %cst_0 = arith.constant -2.000000e+00 : f32 + %cst_1 = arith.constant 2.000000e+00 : f32 + %cst_2 = arith.constant 1.000000e+00 : f32 + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = arith.index_cast %arg1 : i32 to index + %3 = llvm.mlir.undef : f32 + %4 = tensor.empty() : tensor + %inserted = tensor.insert %3 into %4[] : tensor + %5 = tensor.empty() : tensor + %inserted_3 = tensor.insert %3 into %5[] : tensor + %6 = tensor.empty() : tensor + %inserted_4 = tensor.insert %3 into %6[] : tensor + %7 = arith.negf %arg2 : f32 + %8 = math.exp %7 : f32 + %9 = arith.subf %cst_2, %8 : f32 + %10 = arith.mulf %9, %9 : f32 + %11 = arith.mulf %arg2, %cst_1 : f32 + %12 = arith.mulf %11, %8 : f32 + %13 = arith.addf %12, %cst_2 : f32 + %14 = math.exp %11 : f32 + %15 = arith.subf %13, %14 : f32 + %16 = arith.divf %10, %15 : f32 + %17 = arith.mulf %16, %8 : f32 + %18 = arith.subf %arg2, %cst_2 : f32 + %19 = arith.mulf %17, %18 : f32 + %20 = math.powf %cst_1, %7 : f32 + %21 = arith.mulf %arg2, %cst_0 : f32 + %22 = math.exp %21 : f32 + %23 = arith.negf %22 : f32 + %24 = arith.index_cast %arg0 : i32 to index + %25:4 = affine.for %arg7 = 0 to %24 iter_args(%arg8 = %inserted, %arg9 = %inserted_3, %arg10 = %inserted_4, %arg11 = %0) -> (tensor, tensor, tensor, tensor) { + %inserted_5 = tensor.insert %cst into %arg9[] : tensor + %inserted_6 = tensor.insert %cst into %arg8[] : tensor + %inserted_7 = tensor.insert %cst into %arg10[] : tensor + %27 = polygeist.submap(%inserted_6, %2) {map = #map} : (tensor, index) -> tensor + %28 = polygeist.submap(%inserted_5, %2) {map = #map} : (tensor, index) -> tensor + %29 = polygeist.submap(%inserted_7, %2) {map = #map} : (tensor, index) -> tensor + %30 = polygeist.submap(%1, %arg7, %2) {map = #map1} : (tensor, index, index) -> tensor + %31 = polygeist.submap(%1, %arg7, %2) {map = #map1} : (tensor, index, index) -> tensor + %32 = polygeist.submap(%arg11, %arg7, %2) {map = #map1} : (tensor, index, index) -> tensor + %33 = polygeist.submap(%arg11, %arg7, %2) {map = #map1} : (tensor, index, index) -> tensor + %34:4 = linalg.generic {doc = "", indexing_maps = [#map2, #map2, #map2, #map2, #map2, #map2, #map2], iterator_types = ["reduction"], library_call = ""} ins(%30, %31, %32 : tensor, tensor, tensor) outs(%33, %29, %27, %28 : tensor, tensor, tensor, tensor) { + ^bb0(%in: f32, %in_8: f32, %in_9: f32, %out: f32, %out_10: f32, %out_11: f32, %out_12: f32): + %39 = arith.mulf %16, %in : f32 + %40 = arith.mulf %19, %out_10 : f32 + %41 = arith.addf %39, %40 : f32 + %42 = arith.mulf %20, %out_12 : f32 + %43 = arith.addf %41, %42 : f32 + %44 = arith.mulf %23, %out_11 : f32 + %45 = arith.addf %43, %44 : f32 + linalg.yield %45, %in_8, %out_12, %in_9 : f32, f32, f32, f32 + } -> (tensor, tensor, tensor, tensor) + %35 = polygeist.submapInverse(%arg11, %34#0, %arg7, %2) {map = #map1} : (tensor, tensor, index, index) -> tensor + %36 = polygeist.submapInverse(%inserted_7, %34#1, %2) {map = #map} : (tensor, tensor, index) -> tensor + %37 = polygeist.submapInverse(%inserted_5, %34#3, %2) {map = #map} : (tensor, tensor, index) -> tensor + %38 = polygeist.submapInverse(%inserted_6, %34#2, %2) {map = #map} : (tensor, tensor, index) -> tensor + affine.yield %38, %37, %36, %35 : tensor, tensor, tensor, tensor + } + %26 = bufferization.to_memref %25#3 : memref + memref.copy %26, %arg5 : memref to memref + return + } +} + diff --git a/polybench_results/deriche_linalg.mlir b/polybench_results/deriche_linalg.mlir new file mode 100644 index 000000000000..5094898c29ce --- /dev/null +++ b/polybench_results/deriche_linalg.mlir @@ -0,0 +1,62 @@ +#map = affine_map<(d0)[s0] -> (s0, d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_deriche(%arg0: i32, %arg1: i32, %arg2: f32, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 2.000000e+00 : f32 + %cst_1 = arith.constant -2.000000e+00 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %0 = arith.index_cast %arg1 : i32 to index + %1 = llvm.mlir.undef : f32 + %alloca = memref.alloca() : memref + affine.store %1, %alloca[] : memref + %alloca_3 = memref.alloca() : memref + affine.store %1, %alloca_3[] : memref + %alloca_4 = memref.alloca() : memref + affine.store %1, %alloca_4[] : memref + %2 = arith.negf %arg2 : f32 + %3 = math.exp %2 : f32 + %4 = arith.subf %cst, %3 : f32 + %5 = arith.mulf %4, %4 : f32 + %6 = arith.mulf %arg2, %cst_0 : f32 + %7 = arith.mulf %6, %3 : f32 + %8 = arith.addf %7, %cst : f32 + %9 = math.exp %6 : f32 + %10 = arith.subf %8, %9 : f32 + %11 = arith.divf %5, %10 : f32 + %12 = arith.mulf %11, %3 : f32 + %13 = arith.subf %arg2, %cst : f32 + %14 = arith.mulf %12, %13 : f32 + %15 = math.powf %cst_0, %2 : f32 + %16 = arith.mulf %arg2, %cst_1 : f32 + %17 = math.exp %16 : f32 + %18 = arith.negf %17 : f32 + %19 = arith.index_cast %arg0 : i32 to index + affine.for %arg7 = 0 to %19 { + affine.store %cst_2, %alloca_3[] : memref + affine.store %cst_2, %alloca[] : memref + affine.store %cst_2, %alloca_4[] : memref + %20 = polygeist.submap(%arg3, %arg7, %0) {map = #map} : (memref, index, index) -> memref + %21 = polygeist.submap(%arg3, %arg7, %0) {map = #map} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg5, %arg7, %0) {map = #map} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg5, %arg7, %0) {map = #map} : (memref, index, index) -> memref + %24 = polygeist.submap(%alloca_4, %0) {map = #map1} : (memref, index) -> memref + %25 = polygeist.submap(%alloca, %0) {map = #map1} : (memref, index) -> memref + %26 = polygeist.submap(%alloca_3, %0) {map = #map1} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2, #map2, #map2, #map2, #map2, #map2], iterator_types = ["reduction"]} ins(%20, %21, %22 : memref, memref, memref) outs(%23, %24, %25, %26 : memref, memref, memref, memref) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %27 = arith.mulf %11, %in : f32 + %28 = arith.mulf %14, %out_7 : f32 + %29 = arith.addf %27, %28 : f32 + %30 = arith.mulf %15, %out_9 : f32 + %31 = arith.addf %29, %30 : f32 + %32 = arith.mulf %18, %out_8 : f32 + %33 = arith.addf %31, %32 : f32 + linalg.yield %33, %in_5, %out_9, %in_6 : f32, f32, f32, f32 + } + } + return + } +} + diff --git a/polybench_results/doitgen.log b/polybench_results/doitgen.log new file mode 100644 index 000000000000..975b1fe1f27c --- /dev/null +++ b/polybench_results/doitgen.log @@ -0,0 +1,35 @@ +/home/arjaiswal/Polygeist/polybench_results/doitgen.mlir:2:3: warning: Distribute+Raising didn't converge, continuing anyway + func.func @kernel_doitgen(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +/home/arjaiswal/Polygeist/polybench_results/doitgen.mlir:2:3: note: see current operation: +func.func @kernel_doitgen(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg2 : i32 to index + %2 = arith.index_cast %arg0 : i32 to index + affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1, %1) {map = affine_map<(d0, d1)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index, index) -> memref + %5 = polygeist.submap(%arg4, %1, %1) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg5, %1, %1) {map = affine_map<(d0, d1) -> (d1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %7 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %8 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7 : memref) outs(%8 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } + } + return +} diff --git a/polybench_results/doitgen.mlir b/polybench_results/doitgen.mlir new file mode 100644 index 000000000000..35a6ec07d78e --- /dev/null +++ b/polybench_results/doitgen.mlir @@ -0,0 +1,28 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_doitgen(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg2 : i32 to index + %2 = arith.index_cast %arg0 : i32 to index + affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + affine.for %arg9 = 0 to %1 { + %3 = affine.load %arg3[%arg6, %arg7, %arg9] : memref + %4 = affine.load %arg4[%arg9, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg5[%arg8] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg5[%arg8] : memref + } + } + affine.for %arg8 = 0 to %1 { + %3 = affine.load %arg5[%arg8] : memref + affine.store %3, %arg3[%arg6, %arg7, %arg8] : memref + } + } + } + return + } +} diff --git a/polybench_results/doitgen_debuf.mlir b/polybench_results/doitgen_debuf.mlir new file mode 100644 index 000000000000..e5576a8236f1 --- /dev/null +++ b/polybench_results/doitgen_debuf.mlir @@ -0,0 +1,51 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1)[s0, s1] -> (s0, s1, d0)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (d1)> +#map4 = affine_map<(d0)[s0, s1] -> (s0, s1, d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_doitgen(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = arith.index_cast %arg1 : i32 to index + %4 = arith.index_cast %arg2 : i32 to index + %5 = arith.index_cast %arg0 : i32 to index + %6:2 = affine.for %arg6 = 0 to %5 iter_args(%arg7 = %2, %arg8 = %0) -> (tensor, tensor) { + %9:2 = affine.for %arg9 = 0 to %3 iter_args(%arg10 = %arg7, %arg11 = %arg8) -> (tensor, tensor) { + %10 = polygeist.submap(%arg11, %4) {map = #map} : (tensor, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%10 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %12 = polygeist.submapInverse(%arg11, %11, %4) {map = #map} : (tensor, tensor, index) -> tensor + %13 = polygeist.submap(%arg10, %arg6, %arg9, %4, %4) {map = #map1} : (tensor, index, index, index, index) -> tensor + %14 = polygeist.submap(%1, %4, %4) {map = #map2} : (tensor, index, index) -> tensor + %15 = polygeist.submap(%12, %4, %4) {map = #map3} : (tensor, index, index) -> tensor + %16 = linalg.generic {doc = "", indexing_maps = [#map2, #map2, #map2], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%13, %14 : tensor, tensor) outs(%15 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %22 = arith.mulf %in, %in_0 : f64 + %23 = arith.addf %out, %22 : f64 + linalg.yield %23 : f64 + } -> tensor + %17 = polygeist.submapInverse(%12, %16, %4, %4) {map = #map3} : (tensor, tensor, index, index) -> tensor + %18 = polygeist.submap(%arg10, %arg6, %arg9, %4) {map = #map4} : (tensor, index, index, index) -> tensor + %19 = polygeist.submap(%17, %4) {map = #map} : (tensor, index) -> tensor + %20 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%19 : tensor) outs(%18 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %21 = polygeist.submapInverse(%arg10, %20, %arg6, %arg9, %4) {map = #map4} : (tensor, tensor, index, index, index) -> tensor + affine.yield %21, %17 : tensor, tensor + } + affine.yield %9#0, %9#1 : tensor, tensor + } + %7 = bufferization.to_memref %6#1 : memref + memref.copy %7, %arg5 : memref to memref + %8 = bufferization.to_memref %6#0 : memref + memref.copy %8, %arg3 : memref to memref + return + } +} + diff --git a/polybench_results/doitgen_linalg.mlir b/polybench_results/doitgen_linalg.mlir new file mode 100644 index 000000000000..445a7d8a5095 --- /dev/null +++ b/polybench_results/doitgen_linalg.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1)[s0, s1] -> (s0, s1, d0)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1) -> (d1)> +#map4 = affine_map<(d0)[s0, s1] -> (s0, s1, d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_doitgen(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg2 : i32 to index + %2 = arith.index_cast %arg0 : i32 to index + affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + %3 = polygeist.submap(%arg5, %1) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1, %1) {map = #map1} : (memref, index, index, index, index) -> memref + %5 = polygeist.submap(%arg4, %1, %1) {map = #map2} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg5, %1, %1) {map = #map3} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2, #map2], iterator_types = ["parallel", "reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %7 = polygeist.submap(%arg5, %1) {map = #map} : (memref, index) -> memref + %8 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = #map4} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%7 : memref) outs(%8 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } + } + return + } +} + diff --git a/polybench_results/durbin.log b/polybench_results/durbin.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/durbin.mlir b/polybench_results/durbin.mlir new file mode 100644 index 000000000000..2705dee4b886 --- /dev/null +++ b/polybench_results/durbin.mlir @@ -0,0 +1,59 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_durbin(%arg0: i32, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %cst_0 = arith.constant 1.000000e+00 : f64 + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f64 + affine.store %0, %alloca[] : memref + %alloca_1 = memref.alloca() : memref + affine.store %0, %alloca_1[] : memref + %alloca_2 = memref.alloca() : memref + affine.store %0, %alloca_2[] : memref + %alloca_3 = memref.alloca() : memref<40xf64> + %1 = affine.load %arg1[0] : memref + %2 = arith.negf %1 : f64 + affine.store %2, %arg2[0] : memref + affine.store %cst_0, %alloca_1[] : memref + %3 = affine.load %arg1[0] : memref + %4 = arith.negf %3 : f64 + affine.store %4, %alloca_2[] : memref + %5 = arith.index_cast %arg0 : i32 to index + affine.for %arg3 = 1 to %5 { + %6 = affine.load %alloca_2[] : memref + %7 = arith.mulf %6, %6 : f64 + %8 = arith.subf %cst_0, %7 : f64 + %9 = affine.load %alloca_1[] : memref + %10 = arith.mulf %8, %9 : f64 + affine.store %10, %alloca_1[] : memref + affine.store %cst, %alloca[] : memref + affine.for %arg4 = 0 to #map(%arg3) { + %16 = affine.load %arg1[%arg3 - %arg4 - 1] : memref + %17 = affine.load %arg2[%arg4] : memref + %18 = arith.mulf %16, %17 : f64 + %19 = affine.load %alloca[] : memref + %20 = arith.addf %19, %18 : f64 + affine.store %20, %alloca[] : memref + } + %11 = affine.load %arg1[%arg3] : memref + %12 = affine.load %alloca[] : memref + %13 = arith.addf %11, %12 : f64 + %14 = arith.negf %13 : f64 + %15 = arith.divf %14, %10 : f64 + affine.store %15, %alloca_2[] : memref + affine.for %arg4 = 0 to #map(%arg3) { + %16 = affine.load %arg2[%arg4] : memref + %17 = affine.load %arg2[%arg3 - %arg4 - 1] : memref + %18 = arith.mulf %15, %17 : f64 + %19 = arith.addf %16, %18 : f64 + affine.store %19, %alloca_3[%arg4] : memref<40xf64> + } + affine.for %arg4 = 0 to #map(%arg3) { + %16 = affine.load %alloca_3[%arg4] : memref<40xf64> + affine.store %16, %arg2[%arg4] : memref + } + affine.store %15, %arg2[%arg3] : memref + } + return + } +} diff --git a/polybench_results/durbin_debuf.mlir b/polybench_results/durbin_debuf.mlir new file mode 100644 index 000000000000..a7743394d75b --- /dev/null +++ b/polybench_results/durbin_debuf.mlir @@ -0,0 +1,89 @@ +#map = affine_map<(d0) -> ()> +#map1 = affine_map<(d0)[s0] -> (-d0 + s0 - 1)> +#map2 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_durbin(%arg0: i32, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f64 + %cst_0 = arith.constant 0.000000e+00 : f64 + %c1 = arith.constant 1 : index + %c0 = arith.constant 0 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = bufferization.to_tensor %arg1 : memref + %2 = tensor.empty() : tensor + %3 = llvm.mlir.undef : f64 + %inserted = tensor.insert %3 into %2[] : tensor + %4 = tensor.empty() : tensor + %inserted_1 = tensor.insert %3 into %4[] : tensor + %5 = tensor.empty() : tensor + %inserted_2 = tensor.insert %3 into %5[] : tensor + %6 = tensor.empty() : tensor<40xf64> + %extracted = tensor.extract %1[%c0] : tensor + %7 = arith.negf %extracted : f64 + %inserted_3 = tensor.insert %7 into %0[%c0] : tensor + %inserted_4 = tensor.insert %cst into %inserted_1[] : tensor + %extracted_5 = tensor.extract %1[%c0] : tensor + %8 = arith.negf %extracted_5 : f64 + %inserted_6 = tensor.insert %8 into %inserted_2[] : tensor + %9 = arith.index_cast %arg0 : i32 to index + %10:5 = affine.for %arg3 = 1 to %9 iter_args(%arg4 = %inserted, %arg5 = %inserted_4, %arg6 = %inserted_6, %arg7 = %6, %arg8 = %inserted_3) -> (tensor, tensor, tensor, tensor<40xf64>, tensor) { + %extracted_7 = tensor.extract %arg6[] : tensor + %12 = arith.mulf %extracted_7, %extracted_7 : f64 + %13 = arith.subf %cst, %12 : f64 + %extracted_8 = tensor.extract %arg5[] : tensor + %14 = arith.mulf %13, %extracted_8 : f64 + %inserted_9 = tensor.insert %14 into %arg5[] : tensor + %inserted_10 = tensor.insert %cst_0 into %arg4[] : tensor + %15 = arith.subi %9, %c1 : index + %16 = polygeist.submap(%inserted_10, %15) {map = #map} : (tensor, index) -> tensor + %17 = polygeist.submap(%1, %arg3, %15) {map = #map1} : (tensor, index, index) -> tensor + %18 = polygeist.submap(%arg8, %15) {map = #map2} : (tensor, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map2, #map2, #map2], iterator_types = ["reduction"], library_call = ""} ins(%17, %18 : tensor, tensor) outs(%16 : tensor) { + ^bb0(%in: f64, %in_15: f64, %out: f64): + %35 = arith.mulf %in, %in_15 : f64 + %36 = arith.addf %out, %35 : f64 + %37 = linalg.index 0 : index + %38 = arith.cmpi slt, %37, %arg3 : index + %39 = arith.select %38, %36, %out : f64 + linalg.yield %39 : f64 + } -> tensor + %20 = polygeist.submapInverse(%inserted_10, %19, %15) {map = #map} : (tensor, tensor, index) -> tensor + %extracted_11 = tensor.extract %1[%arg3] : tensor + %extracted_12 = tensor.extract %20[] : tensor + %21 = arith.addf %extracted_11, %extracted_12 : f64 + %22 = arith.negf %21 : f64 + %23 = arith.divf %22, %14 : f64 + %inserted_13 = tensor.insert %23 into %arg6[] : tensor + %24 = arith.subi %9, %c1 : index + %25 = polygeist.submap(%arg7, %24) {map = #map2} : (tensor<40xf64>, index) -> tensor + %26 = polygeist.submap(%arg8, %24) {map = #map2} : (tensor, index) -> tensor + %27 = polygeist.submap(%arg8, %arg3, %24) {map = #map1} : (tensor, index, index) -> tensor + %28 = linalg.generic {doc = "", indexing_maps = [#map2, #map2, #map2], iterator_types = ["parallel"], library_call = ""} ins(%26, %27 : tensor, tensor) outs(%25 : tensor) { + ^bb0(%in: f64, %in_15: f64, %out: f64): + %35 = arith.mulf %23, %in_15 : f64 + %36 = arith.addf %in, %35 : f64 + %37 = linalg.index 0 : index + %38 = arith.cmpi slt, %37, %arg3 : index + %39 = arith.select %38, %36, %out : f64 + linalg.yield %39 : f64 + } -> tensor + %29 = polygeist.submapInverse(%arg7, %28, %24) {map = #map2} : (tensor<40xf64>, tensor, index) -> tensor<40xf64> + %30 = arith.subi %9, %c1 : index + %31 = polygeist.submap(%29, %30) {map = #map2} : (tensor<40xf64>, index) -> tensor + %32 = polygeist.submap(%arg8, %30) {map = #map2} : (tensor, index) -> tensor + %33 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel"], library_call = ""} ins(%31 : tensor) outs(%32 : tensor) { + ^bb0(%in: f64, %out: f64): + %35 = linalg.index 0 : index + %36 = arith.cmpi slt, %35, %arg3 : index + %37 = arith.select %36, %in, %out : f64 + linalg.yield %37 : f64 + } -> tensor + %34 = polygeist.submapInverse(%arg8, %33, %30) {map = #map2} : (tensor, tensor, index) -> tensor + %inserted_14 = tensor.insert %23 into %34[%arg3] : tensor + affine.yield %20, %inserted_9, %inserted_13, %29, %inserted_14 : tensor, tensor, tensor, tensor<40xf64>, tensor + } + %11 = bufferization.to_memref %10#4 : memref + memref.copy %11, %arg2 : memref to memref + return + } +} + diff --git a/polybench_results/durbin_linalg.mlir b/polybench_results/durbin_linalg.mlir new file mode 100644 index 000000000000..36febe51ea9a --- /dev/null +++ b/polybench_results/durbin_linalg.mlir @@ -0,0 +1,80 @@ +#map = affine_map<(d0)[s0] -> (-d0 + s0 - 1)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0) -> ()> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_durbin(%arg0: i32, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f64 + %cst_0 = arith.constant 1.000000e+00 : f64 + %alloca = memref.alloca() : memref + %0 = llvm.mlir.undef : f64 + affine.store %0, %alloca[] : memref + %alloca_1 = memref.alloca() : memref + affine.store %0, %alloca_1[] : memref + %alloca_2 = memref.alloca() : memref + affine.store %0, %alloca_2[] : memref + %alloca_3 = memref.alloca() : memref<40xf64> + %1 = affine.load %arg1[0] : memref + %2 = arith.negf %1 : f64 + affine.store %2, %arg2[0] : memref + affine.store %cst_0, %alloca_1[] : memref + %3 = affine.load %arg1[0] : memref + %4 = arith.negf %3 : f64 + affine.store %4, %alloca_2[] : memref + %5 = arith.index_cast %arg0 : i32 to index + affine.for %arg3 = 1 to %5 { + %6 = affine.load %alloca_2[] : memref + %7 = arith.mulf %6, %6 : f64 + %8 = arith.subf %cst_0, %7 : f64 + %9 = affine.load %alloca_1[] : memref + %10 = arith.mulf %8, %9 : f64 + affine.store %10, %alloca_1[] : memref + affine.store %cst, %alloca[] : memref + %11 = arith.subi %5, %c1 : index + %12 = polygeist.submap(%arg1, %arg3, %11) {map = #map} : (memref, index, index) -> memref + %13 = polygeist.submap(%arg2, %11) {map = #map1} : (memref, index) -> memref + %14 = polygeist.submap(%alloca, %11) {map = #map2} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["reduction"]} ins(%12, %13 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %27 = arith.mulf %in, %in_4 : f64 + %28 = arith.addf %out, %27 : f64 + %29 = linalg.index 0 : index + %30 = arith.cmpi slt, %29, %arg3 : index + %31 = arith.select %30, %28, %out : f64 + linalg.yield %31 : f64 + } + %15 = affine.load %arg1[%arg3] : memref + %16 = affine.load %alloca[] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.negf %17 : f64 + %19 = arith.divf %18, %10 : f64 + affine.store %19, %alloca_2[] : memref + %20 = arith.subi %5, %c1 : index + %21 = polygeist.submap(%arg2, %20) {map = #map1} : (memref, index) -> memref + %22 = polygeist.submap(%arg2, %arg3, %20) {map = #map} : (memref, index, index) -> memref + %23 = polygeist.submap(%alloca_3, %20) {map = #map1} : (memref<40xf64>, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"]} ins(%21, %22 : memref, memref) outs(%23 : memref) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %27 = arith.mulf %19, %in_4 : f64 + %28 = arith.addf %in, %27 : f64 + %29 = linalg.index 0 : index + %30 = arith.cmpi slt, %29, %arg3 : index + %31 = arith.select %30, %28, %out : f64 + linalg.yield %31 : f64 + } + %24 = arith.subi %5, %c1 : index + %25 = polygeist.submap(%alloca_3, %24) {map = #map1} : (memref<40xf64>, index) -> memref + %26 = polygeist.submap(%arg2, %24) {map = #map1} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%25 : memref) outs(%26 : memref) { + ^bb0(%in: f64, %out: f64): + %27 = linalg.index 0 : index + %28 = arith.cmpi slt, %27, %arg3 : index + %29 = arith.select %28, %in, %out : f64 + linalg.yield %29 : f64 + } + affine.store %19, %arg2[%arg3] : memref + } + return + } +} + diff --git a/polybench_results/fdtd-2d.log b/polybench_results/fdtd-2d.log new file mode 100644 index 000000000000..f690af09e103 --- /dev/null +++ b/polybench_results/fdtd-2d.log @@ -0,0 +1,65 @@ +/home/arjaiswal/Polygeist/polybench_results/fdtd-2d.mlir:3:3: warning: Distribute+Raising didn't converge, continuing anyway + func.func @kernel_fdtd_2d(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +/home/arjaiswal/Polygeist/polybench_results/fdtd-2d.mlir:3:3: note: see current operation: +func.func @kernel_fdtd_2d(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 5.000000e-01 : f64 + %cst_0 = arith.constant 0.69999999999999996 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg2 : i32 to index + %2 = arith.index_cast %arg0 : i32 to index + affine.for %arg7 = 0 to %2 { + %3 = polygeist.submap(%arg6, %arg7, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %1) {map = affine_map<(d0) -> (0, d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %5 = arith.subi %0, %c1 : index + %6 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %9 = arith.subi %1, %c1 : index + %10 = polygeist.submap(%arg5, %9, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %11 = arith.subi %1, %c1 : index + %12 = polygeist.submap(%arg5, %11, %0) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %13 = arith.subi %1, %c1 : index + %14 = polygeist.submap(%arg3, %13, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%10, %12 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %17 = polygeist.submap(%arg3, %16, %15) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %19 = polygeist.submap(%arg3, %18, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %21 = polygeist.submap(%arg4, %20, %15) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %23 = polygeist.submap(%arg4, %22, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %25 = polygeist.submap(%arg5, %24, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%17, %19, %21, %23 : memref, memref, memref, memref) outs(%25 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.addf %26, %in_2 : f64 + %28 = arith.subf %27, %in_3 : f64 + %29 = arith.mulf %28, %cst_0 : f64 + %30 = arith.subf %out, %29 : f64 + linalg.yield %30 : f64 + } + } + return +} diff --git a/polybench_results/fdtd-2d.mlir b/polybench_results/fdtd-2d.mlir new file mode 100644 index 000000000000..5c107f51bd0e --- /dev/null +++ b/polybench_results/fdtd-2d.mlir @@ -0,0 +1,54 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_fdtd_2d(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 5.000000e-01 : f64 + %cst_0 = arith.constant 0.69999999999999996 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg2 : i32 to index + %2 = arith.index_cast %arg0 : i32 to index + affine.for %arg7 = 0 to %2 { + affine.for %arg8 = 0 to %1 { + %3 = affine.load %arg6[%arg7] : memref + affine.store %3, %arg4[0, %arg8] : memref + } + affine.for %arg8 = 1 to %0 { + affine.for %arg9 = 0 to %1 { + %3 = affine.load %arg4[%arg8, %arg9] : memref + %4 = affine.load %arg5[%arg8, %arg9] : memref + %5 = affine.load %arg5[%arg8 - 1, %arg9] : memref + %6 = arith.subf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = arith.subf %3, %7 : f64 + affine.store %8, %arg4[%arg8, %arg9] : memref + } + } + affine.for %arg8 = 0 to %0 { + affine.for %arg9 = 1 to %1 { + %3 = affine.load %arg3[%arg8, %arg9] : memref + %4 = affine.load %arg5[%arg8, %arg9] : memref + %5 = affine.load %arg5[%arg8, %arg9 - 1] : memref + %6 = arith.subf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = arith.subf %3, %7 : f64 + affine.store %8, %arg3[%arg8, %arg9] : memref + } + } + affine.for %arg8 = 0 to #map()[%0] { + affine.for %arg9 = 0 to #map()[%1] { + %3 = affine.load %arg5[%arg8, %arg9] : memref + %4 = affine.load %arg3[%arg8, %arg9 + 1] : memref + %5 = affine.load %arg3[%arg8, %arg9] : memref + %6 = arith.subf %4, %5 : f64 + %7 = affine.load %arg4[%arg8 + 1, %arg9] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg4[%arg8, %arg9] : memref + %10 = arith.subf %8, %9 : f64 + %11 = arith.mulf %10, %cst_0 : f64 + %12 = arith.subf %3, %11 : f64 + affine.store %12, %arg5[%arg8, %arg9] : memref + } + } + } + return + } +} diff --git a/polybench_results/fdtd-2d_debuf.mlir b/polybench_results/fdtd-2d_debuf.mlir new file mode 100644 index 000000000000..1551fb7602b3 --- /dev/null +++ b/polybench_results/fdtd-2d_debuf.mlir @@ -0,0 +1,87 @@ +#map = affine_map<(d0) -> (0, d0)> +#map1 = affine_map<(d0)[s0] -> (s0)> +#map2 = affine_map<(d0) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d1 + 1, d0)> +#map4 = affine_map<(d0, d1) -> (d1, d0)> +#map5 = affine_map<(d0, d1) -> (d0, d1)> +#map6 = affine_map<(d0, d1) -> (d1, d0 + 1)> +#map7 = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_fdtd_2d(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.69999999999999996 : f64 + %cst_0 = arith.constant 5.000000e-01 : f64 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = bufferization.to_tensor %arg3 : memref + %4 = arith.index_cast %arg1 : i32 to index + %5 = arith.index_cast %arg2 : i32 to index + %6 = arith.index_cast %arg0 : i32 to index + %7:3 = affine.for %arg7 = 0 to %6 iter_args(%arg8 = %3, %arg9 = %2, %arg10 = %1) -> (tensor, tensor, tensor) { + %11 = polygeist.submap(%arg9, %5) {map = #map} : (tensor, index) -> tensor + %12 = polygeist.submap(%0, %arg7, %5) {map = #map1} : (tensor, index, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map2, #map2], iterator_types = ["parallel"], library_call = ""} ins(%12 : tensor) outs(%11 : tensor) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } -> tensor + %14 = polygeist.submapInverse(%arg9, %13, %5) {map = #map} : (tensor, tensor, index) -> tensor + %15 = arith.subi %4, %c1 : index + %16 = polygeist.submap(%14, %5, %15) {map = #map3} : (tensor, index, index) -> tensor + %17 = polygeist.submap(%arg10, %5, %15) {map = #map3} : (tensor, index, index) -> tensor + %18 = polygeist.submap(%arg10, %5, %15) {map = #map4} : (tensor, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%17, %18 : tensor, tensor) outs(%16 : tensor) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %42 = arith.subf %in, %in_1 : f64 + %43 = arith.mulf %42, %cst_0 : f64 + %44 = arith.subf %out, %43 : f64 + linalg.yield %44 : f64 + } -> tensor + %20 = polygeist.submapInverse(%14, %19, %5, %15) {map = #map3} : (tensor, tensor, index, index) -> tensor + %21 = arith.subi %5, %c1 : index + %22 = arith.subi %5, %c1 : index + %23 = arith.subi %5, %c1 : index + %24 = polygeist.submap(%arg8, %23, %4) {map = #map6} : (tensor, index, index) -> tensor + %25 = polygeist.submap(%arg10, %21, %4) {map = #map6} : (tensor, index, index) -> tensor + %26 = polygeist.submap(%arg10, %22, %4) {map = #map4} : (tensor, index, index) -> tensor + %27 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%25, %26 : tensor, tensor) outs(%24 : tensor) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %42 = arith.subf %in, %in_1 : f64 + %43 = arith.mulf %42, %cst_0 : f64 + %44 = arith.subf %out, %43 : f64 + linalg.yield %44 : f64 + } -> tensor + %28 = polygeist.submapInverse(%arg8, %27, %23, %4) {map = #map6} : (tensor, tensor, index, index) -> tensor + %29 = affine.apply #map7()[%4] + %30 = affine.apply #map7()[%5] + %31 = affine.apply #map7()[%5] + %32 = affine.apply #map7()[%5] + %33 = affine.apply #map7()[%5] + %34 = affine.apply #map7()[%5] + %35 = polygeist.submap(%28, %30, %29) {map = #map6} : (tensor, index, index) -> tensor + %36 = polygeist.submap(%28, %31, %29) {map = #map4} : (tensor, index, index) -> tensor + %37 = polygeist.submap(%20, %32, %29) {map = #map3} : (tensor, index, index) -> tensor + %38 = polygeist.submap(%20, %33, %29) {map = #map4} : (tensor, index, index) -> tensor + %39 = polygeist.submap(%arg10, %34, %29) {map = #map4} : (tensor, index, index) -> tensor + %40 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5, #map5, #map5], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%35, %36, %37, %38 : tensor, tensor, tensor, tensor) outs(%39 : tensor) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.subf %in, %in_1 : f64 + %43 = arith.addf %42, %in_2 : f64 + %44 = arith.subf %43, %in_3 : f64 + %45 = arith.mulf %44, %cst : f64 + %46 = arith.subf %out, %45 : f64 + linalg.yield %46 : f64 + } -> tensor + %41 = polygeist.submapInverse(%arg10, %40, %34, %29) {map = #map4} : (tensor, tensor, index, index) -> tensor + affine.yield %28, %20, %41 : tensor, tensor, tensor + } + %8 = bufferization.to_memref %7#2 : memref + memref.copy %8, %arg5 : memref to memref + %9 = bufferization.to_memref %7#1 : memref + memref.copy %9, %arg4 : memref to memref + %10 = bufferization.to_memref %7#0 : memref + memref.copy %10, %arg3 : memref to memref + return + } +} + diff --git a/polybench_results/fdtd-2d_linalg.mlir b/polybench_results/fdtd-2d_linalg.mlir new file mode 100644 index 000000000000..7befe614ec56 --- /dev/null +++ b/polybench_results/fdtd-2d_linalg.mlir @@ -0,0 +1,72 @@ +#map = affine_map<(d0)[s0] -> (s0)> +#map1 = affine_map<(d0) -> (0, d0)> +#map2 = affine_map<(d0) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d1 + 1, d0)> +#map4 = affine_map<(d0, d1) -> (d1, d0)> +#map5 = affine_map<(d0, d1) -> (d0, d1)> +#map6 = affine_map<(d0, d1) -> (d1, d0 + 1)> +#map7 = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_fdtd_2d(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 5.000000e-01 : f64 + %cst_0 = arith.constant 0.69999999999999996 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg2 : i32 to index + %2 = arith.index_cast %arg0 : i32 to index + affine.for %arg7 = 0 to %2 { + %3 = polygeist.submap(%arg6, %arg7, %1) {map = #map} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %1) {map = #map1} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %5 = arith.subi %0, %c1 : index + %6 = polygeist.submap(%arg5, %1, %5) {map = #map3} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %1, %5) {map = #map4} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %1, %5) {map = #map3} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %9 = arith.subi %1, %c1 : index + %10 = polygeist.submap(%arg5, %9, %0) {map = #map6} : (memref, index, index) -> memref + %11 = arith.subi %1, %c1 : index + %12 = polygeist.submap(%arg5, %11, %0) {map = #map4} : (memref, index, index) -> memref + %13 = arith.subi %1, %c1 : index + %14 = polygeist.submap(%arg3, %13, %0) {map = #map6} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%10, %12 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %15 = affine.apply #map7()[%0] + %16 = affine.apply #map7()[%1] + %17 = polygeist.submap(%arg3, %16, %15) {map = #map6} : (memref, index, index) -> memref + %18 = affine.apply #map7()[%1] + %19 = polygeist.submap(%arg3, %18, %15) {map = #map4} : (memref, index, index) -> memref + %20 = affine.apply #map7()[%1] + %21 = polygeist.submap(%arg4, %20, %15) {map = #map3} : (memref, index, index) -> memref + %22 = affine.apply #map7()[%1] + %23 = polygeist.submap(%arg4, %22, %15) {map = #map4} : (memref, index, index) -> memref + %24 = affine.apply #map7()[%1] + %25 = polygeist.submap(%arg5, %24, %15) {map = #map4} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%17, %19, %21, %23 : memref, memref, memref, memref) outs(%25 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.addf %26, %in_2 : f64 + %28 = arith.subf %27, %in_3 : f64 + %29 = arith.mulf %28, %cst_0 : f64 + %30 = arith.subf %out, %29 : f64 + linalg.yield %30 : f64 + } + } + return + } +} + diff --git a/polybench_results/floyd-warshall.log b/polybench_results/floyd-warshall.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/floyd-warshall.mlir b/polybench_results/floyd-warshall.mlir new file mode 100644 index 000000000000..59d8e0892bf8 --- /dev/null +++ b/polybench_results/floyd-warshall.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_floyd_warshall(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to %0 { + affine.for %arg4 = 0 to %0 { + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg3, %arg2] : memref + %3 = affine.load %arg1[%arg2, %arg4] : memref + %4 = arith.addi %2, %3 : i32 + %5 = arith.cmpi slt, %1, %4 : i32 + %6 = arith.select %5, %1, %4 : i32 + affine.store %6, %arg1[%arg3, %arg4] : memref + } + } + } + return + } +} diff --git a/polybench_results/floyd-warshall_debuf.mlir b/polybench_results/floyd-warshall_debuf.mlir new file mode 100644 index 000000000000..61016720bfdc --- /dev/null +++ b/polybench_results/floyd-warshall_debuf.mlir @@ -0,0 +1,25 @@ +#map = affine_map<(d0, d1, d2) -> (d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d0)> +#map2 = affine_map<(d0, d1, d2) -> (d1, d0)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_floyd_warshall(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg1 : memref + %1 = arith.index_cast %arg0 : i32 to index + %2 = polygeist.submap(%0, %1, %1, %1) {map = #map} : (tensor, index, index, index) -> tensor + %3 = polygeist.submap(%0, %1, %1, %1) {map = #map1} : (tensor, index, index, index) -> tensor + %4 = polygeist.submap(%0, %1, %1, %1) {map = #map2} : (tensor, index, index, index) -> tensor + %5 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map3], iterator_types = ["reduction", "parallel", "parallel"], library_call = ""} ins(%2, %3 : tensor, tensor) outs(%4 : tensor) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %8 = arith.addi %in, %in_0 : i32 + %9 = arith.cmpi slt, %out, %8 : i32 + %10 = arith.select %9, %out, %8 : i32 + linalg.yield %10 : i32 + } -> tensor + %6 = polygeist.submapInverse(%0, %5, %1, %1, %1) {map = #map2} : (tensor, tensor, index, index, index) -> tensor + %7 = bufferization.to_memref %6 : memref + memref.copy %7, %arg1 : memref to memref + return + } +} + diff --git a/polybench_results/floyd-warshall_linalg.mlir b/polybench_results/floyd-warshall_linalg.mlir new file mode 100644 index 000000000000..62be443e6cca --- /dev/null +++ b/polybench_results/floyd-warshall_linalg.mlir @@ -0,0 +1,21 @@ +#map = affine_map<(d0, d1, d2) -> (d1, d2)> +#map1 = affine_map<(d0, d1, d2) -> (d2, d0)> +#map2 = affine_map<(d0, d1, d2) -> (d1, d0)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_floyd_warshall(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg0 : i32 to index + %1 = polygeist.submap(%arg1, %0, %0, %0) {map = #map} : (memref, index, index, index) -> memref + %2 = polygeist.submap(%arg1, %0, %0, %0) {map = #map1} : (memref, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %0, %0, %0) {map = #map2} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map3], iterator_types = ["reduction", "parallel", "parallel"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %4 = arith.addi %in, %in_0 : i32 + %5 = arith.cmpi slt, %out, %4 : i32 + %6 = arith.select %5, %out, %4 : i32 + linalg.yield %6 : i32 + } + return + } +} + diff --git a/polybench_results/gemm.log b/polybench_results/gemm.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/gemm.mlir b/polybench_results/gemm.mlir new file mode 100644 index 000000000000..5639b76a671a --- /dev/null +++ b/polybench_results/gemm.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_gemm(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: f64, %arg4: f64, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg2 : i32 to index + %2 = arith.index_cast %arg0 : i32 to index + affine.for %arg8 = 0 to %2 { + affine.for %arg9 = 0 to %0 { + %3 = affine.load %arg5[%arg8, %arg9] : memref + %4 = arith.mulf %3, %arg4 : f64 + affine.store %4, %arg5[%arg8, %arg9] : memref + } + affine.for %arg9 = 0 to %1 { + affine.for %arg10 = 0 to %0 { + %3 = affine.load %arg6[%arg8, %arg9] : memref + %4 = arith.mulf %arg3, %3 : f64 + %5 = affine.load %arg7[%arg9, %arg10] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg5[%arg8, %arg10] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg5[%arg8, %arg10] : memref + } + } + } + return + } +} diff --git a/polybench_results/gemm_debuf.mlir b/polybench_results/gemm_debuf.mlir new file mode 100644 index 000000000000..a47f83323f1f --- /dev/null +++ b/polybench_results/gemm_debuf.mlir @@ -0,0 +1,38 @@ +#map = affine_map<(d0, d1) -> (d1, d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d0)> +#map3 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map4 = affine_map<(d0, d1, d2) -> (d1, d0)> +#map5 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_gemm(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: f64, %arg4: f64, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg7 : memref + %1 = bufferization.to_tensor %arg6 : memref + %2 = bufferization.to_tensor %arg5 : memref + %3 = arith.index_cast %arg1 : i32 to index + %4 = arith.index_cast %arg2 : i32 to index + %5 = arith.index_cast %arg0 : i32 to index + %6 = polygeist.submap(%2, %3, %5) {map = #map} : (tensor, index, index) -> tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map1], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%6 : tensor) { + ^bb0(%out: f64): + %15 = arith.mulf %out, %arg4 : f64 + linalg.yield %15 : f64 + } -> tensor + %8 = polygeist.submapInverse(%2, %7, %3, %5) {map = #map} : (tensor, tensor, index, index) -> tensor + %9 = polygeist.submap(%8, %3, %4, %5) {map = #map2} : (tensor, index, index, index) -> tensor + %10 = polygeist.submap(%1, %3, %4, %5) {map = #map3} : (tensor, index, index, index) -> tensor + %11 = polygeist.submap(%0, %3, %4, %5) {map = #map4} : (tensor, index, index, index) -> tensor + %12 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "reduction", "parallel"], library_call = ""} ins(%10, %11 : tensor, tensor) outs(%9 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %arg3, %in : f64 + %16 = arith.mulf %15, %in_0 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } -> tensor + %13 = polygeist.submapInverse(%8, %12, %3, %4, %5) {map = #map2} : (tensor, tensor, index, index, index) -> tensor + %14 = bufferization.to_memref %13 : memref + memref.copy %14, %arg5 : memref to memref + return + } +} + diff --git a/polybench_results/gemm_linalg.mlir b/polybench_results/gemm_linalg.mlir new file mode 100644 index 000000000000..648f327841e0 --- /dev/null +++ b/polybench_results/gemm_linalg.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0, d1) -> (d1, d0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d1, d0)> +#map4 = affine_map<(d0, d1, d2) -> (d2, d0)> +#map5 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_gemm(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: f64, %arg4: f64, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg2 : i32 to index + %2 = arith.index_cast %arg0 : i32 to index + %3 = polygeist.submap(%arg5, %0, %2) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %7 = arith.mulf %out, %arg4 : f64 + linalg.yield %7 : f64 + } + %4 = polygeist.submap(%arg6, %0, %1, %2) {map = #map2} : (memref, index, index, index) -> memref + %5 = polygeist.submap(%arg7, %0, %1, %2) {map = #map3} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg5, %0, %1, %2) {map = #map4} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "reduction", "parallel"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg3, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + return + } +} + diff --git a/polybench_results/gemver.log b/polybench_results/gemver.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/gemver.mlir b/polybench_results/gemver.mlir new file mode 100644 index 000000000000..77c87b6d74b3 --- /dev/null +++ b/polybench_results/gemver.mlir @@ -0,0 +1,48 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_gemver(%arg0: i32, %arg1: f64, %arg2: f64, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref, %arg11: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %0 { + %1 = affine.load %arg3[%arg12, %arg13] : memref + %2 = affine.load %arg4[%arg12] : memref + %3 = affine.load %arg5[%arg13] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + %6 = affine.load %arg6[%arg12] : memref + %7 = affine.load %arg7[%arg13] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = arith.addf %5, %8 : f64 + affine.store %9, %arg3[%arg12, %arg13] : memref + } + } + affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %0 { + %1 = affine.load %arg9[%arg12] : memref + %2 = affine.load %arg3[%arg13, %arg12] : memref + %3 = arith.mulf %arg2, %2 : f64 + %4 = affine.load %arg10[%arg13] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %1, %5 : f64 + affine.store %6, %arg9[%arg12] : memref + } + } + affine.for %arg12 = 0 to %0 { + %1 = affine.load %arg9[%arg12] : memref + %2 = affine.load %arg11[%arg12] : memref + %3 = arith.addf %1, %2 : f64 + affine.store %3, %arg9[%arg12] : memref + } + affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %0 { + %1 = affine.load %arg8[%arg12] : memref + %2 = affine.load %arg3[%arg12, %arg13] : memref + %3 = arith.mulf %arg1, %2 : f64 + %4 = affine.load %arg9[%arg13] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %1, %5 : f64 + affine.store %6, %arg8[%arg12] : memref + } + } + return + } +} diff --git a/polybench_results/gemver_debuf.mlir b/polybench_results/gemver_debuf.mlir new file mode 100644 index 000000000000..e69908948ef3 --- /dev/null +++ b/polybench_results/gemver_debuf.mlir @@ -0,0 +1,71 @@ +#map = affine_map<(d0, d1) -> (d1, d0)> +#map1 = affine_map<(d0, d1) -> (d1)> +#map2 = affine_map<(d0, d1) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +#map4 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_gemver(%arg0: i32, %arg1: f64, %arg2: f64, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref, %arg11: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg11 : memref + %1 = bufferization.to_tensor %arg10 : memref + %2 = bufferization.to_tensor %arg9 : memref + %3 = bufferization.to_tensor %arg8 : memref + %4 = bufferization.to_tensor %arg7 : memref + %5 = bufferization.to_tensor %arg6 : memref + %6 = bufferization.to_tensor %arg5 : memref + %7 = bufferization.to_tensor %arg4 : memref + %8 = bufferization.to_tensor %arg3 : memref + %9 = arith.index_cast %arg0 : i32 to index + %10 = polygeist.submap(%8, %9, %9) {map = #map} : (tensor, index, index) -> tensor + %11 = polygeist.submap(%7, %9, %9) {map = #map1} : (tensor, index, index) -> tensor + %12 = polygeist.submap(%6, %9, %9) {map = #map2} : (tensor, index, index) -> tensor + %13 = polygeist.submap(%5, %9, %9) {map = #map1} : (tensor, index, index) -> tensor + %14 = polygeist.submap(%4, %9, %9) {map = #map2} : (tensor, index, index) -> tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map3, #map3, #map3], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%11, %12, %13, %14 : tensor, tensor, tensor, tensor) outs(%10 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %34 = arith.mulf %in, %in_0 : f64 + %35 = arith.addf %out, %34 : f64 + %36 = arith.mulf %in_1, %in_2 : f64 + %37 = arith.addf %35, %36 : f64 + linalg.yield %37 : f64 + } -> tensor + %16 = polygeist.submapInverse(%8, %15, %9, %9) {map = #map} : (tensor, tensor, index, index) -> tensor + %17 = bufferization.to_memref %16 : memref + memref.copy %17, %arg3 : memref to memref + %18 = polygeist.submap(%16, %9, %9) {map = #map3} : (tensor, index, index) -> tensor + %19 = polygeist.submap(%2, %9, %9) {map = #map1} : (tensor, index, index) -> tensor + %20 = polygeist.submap(%1, %9, %9) {map = #map2} : (tensor, index, index) -> tensor + %21 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%18, %20 : tensor, tensor) outs(%19 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %34 = arith.mulf %arg2, %in : f64 + %35 = arith.mulf %34, %in_0 : f64 + %36 = arith.addf %out, %35 : f64 + linalg.yield %36 : f64 + } -> tensor + %22 = polygeist.submapInverse(%2, %21, %9, %9) {map = #map1} : (tensor, tensor, index, index) -> tensor + %23 = polygeist.submap(%22, %9) {map = #map4} : (tensor, index) -> tensor + %24 = polygeist.submap(%0, %9) {map = #map4} : (tensor, index) -> tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map4, #map4], iterator_types = ["parallel"], library_call = ""} ins(%24 : tensor) outs(%23 : tensor) { + ^bb0(%in: f64, %out: f64): + %34 = arith.addf %out, %in : f64 + linalg.yield %34 : f64 + } -> tensor + %26 = polygeist.submapInverse(%22, %25, %9) {map = #map4} : (tensor, tensor, index) -> tensor + %27 = bufferization.to_memref %26 : memref + memref.copy %27, %arg9 : memref to memref + %28 = polygeist.submap(%16, %9, %9) {map = #map} : (tensor, index, index) -> tensor + %29 = polygeist.submap(%3, %9, %9) {map = #map1} : (tensor, index, index) -> tensor + %30 = polygeist.submap(%26, %9, %9) {map = #map2} : (tensor, index, index) -> tensor + %31 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%28, %30 : tensor, tensor) outs(%29 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %34 = arith.mulf %arg1, %in : f64 + %35 = arith.mulf %34, %in_0 : f64 + %36 = arith.addf %out, %35 : f64 + linalg.yield %36 : f64 + } -> tensor + %32 = polygeist.submapInverse(%3, %31, %9, %9) {map = #map1} : (tensor, tensor, index, index) -> tensor + %33 = bufferization.to_memref %32 : memref + memref.copy %33, %arg8 : memref to memref + return + } +} + diff --git a/polybench_results/gemver_linalg.mlir b/polybench_results/gemver_linalg.mlir new file mode 100644 index 000000000000..1229d48899fc --- /dev/null +++ b/polybench_results/gemver_linalg.mlir @@ -0,0 +1,52 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +#map4 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_gemver(%arg0: i32, %arg1: f64, %arg2: f64, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref, %arg11: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg0 : i32 to index + %1 = polygeist.submap(%arg4, %0, %0) {map = #map} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg5, %0, %0) {map = #map1} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg6, %0, %0) {map = #map} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg7, %0, %0) {map = #map1} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg3, %0, %0) {map = #map2} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map3, #map3, #map3], iterator_types = ["parallel", "parallel"]} ins(%1, %2, %3, %4 : memref, memref, memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %14 = arith.mulf %in, %in_0 : f64 + %15 = arith.addf %out, %14 : f64 + %16 = arith.mulf %in_1, %in_2 : f64 + %17 = arith.addf %15, %16 : f64 + linalg.yield %17 : f64 + } + %6 = polygeist.submap(%arg3, %0, %0) {map = #map3} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg10, %0, %0) {map = #map1} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg9, %0, %0) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = arith.mulf %arg2, %in : f64 + %15 = arith.mulf %14, %in_0 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 + } + %9 = polygeist.submap(%arg11, %0) {map = #map4} : (memref, index) -> memref + %10 = polygeist.submap(%arg9, %0) {map = #map4} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel"]} ins(%9 : memref) outs(%10 : memref) { + ^bb0(%in: f64, %out: f64): + %14 = arith.addf %out, %in : f64 + linalg.yield %14 : f64 + } + %11 = polygeist.submap(%arg3, %0, %0) {map = #map2} : (memref, index, index) -> memref + %12 = polygeist.submap(%arg9, %0, %0) {map = #map1} : (memref, index, index) -> memref + %13 = polygeist.submap(%arg8, %0, %0) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"]} ins(%11, %12 : memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = arith.mulf %arg1, %in : f64 + %15 = arith.mulf %14, %in_0 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 + } + return + } +} + diff --git a/polybench_results/gesummv.log b/polybench_results/gesummv.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/gesummv.mlir b/polybench_results/gesummv.mlir new file mode 100644 index 000000000000..6fc6c16e5ca1 --- /dev/null +++ b/polybench_results/gesummv.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_gesummv(%arg0: i32, %arg1: f64, %arg2: f64, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg8 = 0 to %0 { + affine.store %cst, %arg5[%arg8] : memref + affine.store %cst, %arg7[%arg8] : memref + affine.for %arg9 = 0 to %0 { + %6 = affine.load %arg3[%arg8, %arg9] : memref + %7 = affine.load %arg6[%arg9] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %arg5[%arg8] : memref + %10 = arith.addf %8, %9 : f64 + affine.store %10, %arg5[%arg8] : memref + %11 = affine.load %arg4[%arg8, %arg9] : memref + %12 = affine.load %arg6[%arg9] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = affine.load %arg7[%arg8] : memref + %15 = arith.addf %13, %14 : f64 + affine.store %15, %arg7[%arg8] : memref + } + %1 = affine.load %arg5[%arg8] : memref + %2 = arith.mulf %arg1, %1 : f64 + %3 = affine.load %arg7[%arg8] : memref + %4 = arith.mulf %arg2, %3 : f64 + %5 = arith.addf %2, %4 : f64 + affine.store %5, %arg7[%arg8] : memref + } + return + } +} diff --git a/polybench_results/gesummv_debuf.mlir b/polybench_results/gesummv_debuf.mlir new file mode 100644 index 000000000000..369781cbbccd --- /dev/null +++ b/polybench_results/gesummv_debuf.mlir @@ -0,0 +1,64 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0)> +#map4 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_gesummv(%arg0: i32, %arg1: f64, %arg2: f64, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = bufferization.to_tensor %arg7 : memref + %1 = bufferization.to_tensor %arg6 : memref + %2 = bufferization.to_tensor %arg5 : memref + %3 = bufferization.to_tensor %arg4 : memref + %4 = bufferization.to_tensor %arg3 : memref + %5 = arith.index_cast %arg0 : i32 to index + %6 = polygeist.submap(%2, %5) {map = #map} : (tensor, index) -> tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%6 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %8 = polygeist.submapInverse(%2, %7, %5) {map = #map} : (tensor, tensor, index) -> tensor + %9 = polygeist.submap(%0, %5) {map = #map} : (tensor, index) -> tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map], iterator_types = ["parallel"], library_call = ""} outs(%9 : tensor) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } -> tensor + %11 = polygeist.submapInverse(%0, %10, %5) {map = #map} : (tensor, tensor, index) -> tensor + %12 = polygeist.submap(%4, %5, %5) {map = #map1} : (tensor, index, index) -> tensor + %13 = polygeist.submap(%8, %5, %5) {map = #map2} : (tensor, index, index) -> tensor + %14 = polygeist.submap(%1, %5, %5) {map = #map3} : (tensor, index, index) -> tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%12, %14 : tensor, tensor) outs(%13 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %28 = arith.mulf %in, %in_0 : f64 + %29 = arith.addf %28, %out : f64 + linalg.yield %29 : f64 + } -> tensor + %16 = polygeist.submapInverse(%8, %15, %5, %5) {map = #map2} : (tensor, tensor, index, index) -> tensor + %17 = bufferization.to_memref %16 : memref + memref.copy %17, %arg5 : memref to memref + %18 = polygeist.submap(%3, %5, %5) {map = #map1} : (tensor, index, index) -> tensor + %19 = polygeist.submap(%1, %5, %5) {map = #map3} : (tensor, index, index) -> tensor + %20 = polygeist.submap(%11, %5, %5) {map = #map2} : (tensor, index, index) -> tensor + %21 = linalg.generic {doc = "", indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%18, %19 : tensor, tensor) outs(%20 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %28 = arith.mulf %in, %in_0 : f64 + %29 = arith.addf %28, %out : f64 + linalg.yield %29 : f64 + } -> tensor + %22 = polygeist.submapInverse(%11, %21, %5, %5) {map = #map2} : (tensor, tensor, index, index) -> tensor + %23 = polygeist.submap(%16, %5) {map = #map} : (tensor, index) -> tensor + %24 = polygeist.submap(%22, %5) {map = #map} : (tensor, index) -> tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map, #map], iterator_types = ["parallel"], library_call = ""} ins(%23 : tensor) outs(%24 : tensor) { + ^bb0(%in: f64, %out: f64): + %28 = arith.mulf %arg1, %in : f64 + %29 = arith.mulf %arg2, %out : f64 + %30 = arith.addf %28, %29 : f64 + linalg.yield %30 : f64 + } -> tensor + %26 = polygeist.submapInverse(%22, %25, %5) {map = #map} : (tensor, tensor, index) -> tensor + %27 = bufferization.to_memref %26 : memref + memref.copy %27, %arg7 : memref to memref + return + } +} + diff --git a/polybench_results/gesummv_linalg.mlir b/polybench_results/gesummv_linalg.mlir new file mode 100644 index 000000000000..92c16ddc8a2a --- /dev/null +++ b/polybench_results/gesummv_linalg.mlir @@ -0,0 +1,50 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d0)> +#map3 = affine_map<(d0, d1) -> (d1)> +#map4 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_gesummv(%arg0: i32, %arg1: f64, %arg2: f64, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref, %arg7: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %1 = polygeist.submap(%arg5, %0) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%1 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = polygeist.submap(%arg7, %0) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map], iterator_types = ["parallel"]} outs(%2 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %3 = polygeist.submap(%arg3, %0, %0) {map = #map1} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg6, %0, %0) {map = #map2} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg5, %0, %0) {map = #map3} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %11, %out : f64 + linalg.yield %12 : f64 + } + %6 = polygeist.submap(%arg4, %0, %0) {map = #map1} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg6, %0, %0) {map = #map2} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg7, %0, %0) {map = #map3} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %11, %out : f64 + linalg.yield %12 : f64 + } + %9 = polygeist.submap(%arg5, %0) {map = #map} : (memref, index) -> memref + %10 = polygeist.submap(%arg7, %0) {map = #map} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%9 : memref) outs(%10 : memref) { + ^bb0(%in: f64, %out: f64): + %11 = arith.mulf %arg1, %in : f64 + %12 = arith.mulf %arg2, %out : f64 + %13 = arith.addf %11, %12 : f64 + linalg.yield %13 : f64 + } + return + } +} + diff --git a/polybench_results/gramschmidt.log b/polybench_results/gramschmidt.log new file mode 100644 index 000000000000..545ad203f278 --- /dev/null +++ b/polybench_results/gramschmidt.log @@ -0,0 +1,64 @@ +/home/arjaiswal/Polygeist/polybench_results/gramschmidt_linalg.mlir:15:5: error: operand #1 does not dominate this use + affine.for %arg5 = 0 to %0 { + ^ +/home/arjaiswal/Polygeist/polybench_results/gramschmidt_linalg.mlir:15:5: note: see current operation: +%6:4 = "affine.for"(%4, %10, %3, %2, %1) ({ +^bb0(%arg5: index, %arg6: tensor, %arg7: tensor, %arg8: tensor, %arg9: tensor): + %10 = "tensor.empty"() : () -> tensor + %11 = "tensor.insert"(%0, %arg6) : (f64, tensor) -> tensor + %12 = "polygeist.submap"(%11, %5) <{map = affine_map<(d0) -> ()>}> : (tensor, index) -> tensor + %13 = "polygeist.submap"(%arg7, %arg5, %5) <{map = affine_map<(d0)[s0] -> (d0, s0)>}> : (tensor, index, index) -> tensor + %14 = "linalg.generic"(%13, %12) <{doc = "", indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = [#linalg.iterator_type], library_call = "", operandSegmentSizes = array}> ({ + ^bb0(%arg10: f64, %arg11: f64): + %37 = "arith.mulf"(%arg10, %arg10) <{fastmath = #arith.fastmath}> : (f64, f64) -> f64 + %38 = "arith.addf"(%arg11, %37) <{fastmath = #arith.fastmath}> : (f64, f64) -> f64 + "linalg.yield"(%38) : (f64) -> () + }) : (tensor, tensor) -> tensor + %15 = "polygeist.submapInverse"(%11, %14, %5) <{map = affine_map<(d0) -> ()>}> : (tensor, tensor, index) -> tensor + %16 = "tensor.extract"(%15) : (tensor) -> f64 + %17 = "math.sqrt"(%16) <{fastmath = #arith.fastmath}> : (f64) -> f64 + %18 = "tensor.insert"(%17, %arg8, %arg5, %arg5) : (f64, tensor, index, index) -> tensor + %19 = "polygeist.submap"(%arg7, %arg5, %5) <{map = affine_map<(d0)[s0] -> (d0, s0)>}> : (tensor, index, index) -> tensor + %20 = "polygeist.submap"(%18, %arg5, %5) <{map = affine_map<(d0)[s0] -> (s0, s0)>}> : (tensor, index, index) -> tensor + %21 = "polygeist.submap"(%arg9, %arg5, %5) <{map = affine_map<(d0)[s0] -> (d0, s0)>}> : (tensor, index, index) -> tensor + %22 = "linalg.generic"(%19, %20, %21) <{doc = "", indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = [#linalg.iterator_type], library_call = "", operandSegmentSizes = array}> ({ + ^bb0(%arg10: f64, %arg11: f64, %arg12: f64): + %37 = "arith.divf"(%arg10, %arg11) <{fastmath = #arith.fastmath}> : (f64, f64) -> f64 + "linalg.yield"(%37) : (f64) -> () + }) : (tensor, tensor, tensor) -> tensor + %23 = "polygeist.submapInverse"(%arg9, %22, %arg5, %5) <{map = affine_map<(d0)[s0] -> (d0, s0)>}> : (tensor, tensor, index, index) -> tensor + %24 = "polygeist.submap"(%18, %arg5, %4) <{map = affine_map<(d0)[s0] -> (s0, d0)>}> : (tensor, index, index) -> tensor + %25 = "linalg.generic"(%24) <{doc = "", indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = [#linalg.iterator_type], library_call = "", operandSegmentSizes = array}> ({ + ^bb0(%arg10: f64): + %37 = "linalg.index"() <{dim = 0 : i64}> : () -> index + %38 = "affine.apply"(%arg5) <{map = affine_map<(d0) -> (d0 + 1)>}> : (index) -> index + %39 = "arith.cmpi"(%37, %38) <{predicate = 5 : i64}> : (index, index) -> i1 + %40 = "arith.select"(%39, %0, %arg10) : (i1, f64, f64) -> f64 + "linalg.yield"(%40) : (f64) -> () + }) : (tensor) -> tensor + %26 = "polygeist.submapInverse"(%18, %25, %arg5, %4) <{map = affine_map<(d0)[s0] -> (s0, d0)>}> : (tensor, tensor, index, index) -> tensor + %27 = "polygeist.submap"(%arg7, %5, %4) <{map = affine_map<(d0, d1) -> (d0, d1)>}> : (tensor, index, index) -> tensor + %28 = "polygeist.submap"(%26, %arg5, %5, %4) <{map = affine_map<(d0, d1)[s0] -> (s0, d1)>}> : (tensor, index, index, index) -> tensor + %29 = "polygeist.submap"(%23, %arg5, %5, %4) <{map = affine_map<(d0, d1)[s0] -> (d0, s0)>}> : (tensor, index, index, index) -> tensor + %30 = "linalg.generic"(%29, %27, %28) <{doc = "", indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = [#linalg.iterator_type, #linalg.iterator_type], library_call = "", operandSegmentSizes = array}> ({ + ^bb0(%arg10: f64, %arg11: f64, %arg12: f64): + %37 = "arith.mulf"(%arg10, %arg11) <{fastmath = #arith.fastmath}> : (f64, f64) -> f64 + %38 = "arith.addf"(%arg12, %37) <{fastmath = #arith.fastmath}> : (f64, f64) -> f64 + "linalg.yield"(%38) : (f64) -> () + }) : (tensor, tensor, tensor) -> tensor + %31 = "polygeist.submapInverse"(%26, %30, %arg5, %5, %4) <{map = affine_map<(d0, d1)[s0] -> (s0, d1)>}> : (tensor, tensor, index, index, index) -> tensor + %32 = "polygeist.submap"(%arg7, %5, %4) <{map = affine_map<(d0, d1) -> (d0, d1)>}> : (tensor, index, index) -> tensor + %33 = "polygeist.submap"(%31, %arg5, %5, %4) <{map = affine_map<(d0, d1)[s0] -> (s0, d1)>}> : (tensor, index, index, index) -> tensor + %34 = "polygeist.submap"(%23, %arg5, %5, %4) <{map = affine_map<(d0, d1)[s0] -> (d0, s0)>}> : (tensor, index, index, index) -> tensor + %35 = "linalg.generic"(%34, %33, %32) <{doc = "", indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = [#linalg.iterator_type, #linalg.iterator_type], library_call = "", operandSegmentSizes = array}> ({ + ^bb0(%arg10: f64, %arg11: f64, %arg12: f64): + %37 = "arith.mulf"(%arg10, %arg11) <{fastmath = #arith.fastmath}> : (f64, f64) -> f64 + %38 = "arith.subf"(%arg12, %37) <{fastmath = #arith.fastmath}> : (f64, f64) -> f64 + "linalg.yield"(%38) : (f64) -> () + }) : (tensor, tensor, tensor) -> tensor + %36 = "polygeist.submapInverse"(%arg7, %35, %5, %4) <{map = affine_map<(d0, d1) -> (d0, d1)>}> : (tensor, tensor, index, index) -> tensor + "affine.yield"(%15, %36, %31, %23) : (tensor, tensor, tensor, tensor) -> () +}) {lower_bound = affine_map<() -> (0)>, step = 1 : index, upper_bound = affine_map<()[s0] -> (s0)>} : (index, tensor, tensor, tensor, tensor) -> (tensor, tensor, tensor, tensor) +/home/arjaiswal/Polygeist/polybench_results/gramschmidt_linalg.mlir:16:17: note: operand defined here (op in a child region) + %alloca = memref.alloca() : memref + ^ diff --git a/polybench_results/gramschmidt.mlir b/polybench_results/gramschmidt.mlir new file mode 100644 index 000000000000..e82bbe1ec34f --- /dev/null +++ b/polybench_results/gramschmidt.mlir @@ -0,0 +1,44 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_gramschmidt(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg5 = 0 to %0 { + %2 = affine.for %arg6 = 0 to %1 iter_args(%arg7 = %cst) -> (f64) { + %4 = affine.load %arg2[%arg6, %arg5] : memref + %5 = arith.mulf %4, %4 : f64 + %6 = arith.addf %arg7, %5 : f64 + affine.yield %6 : f64 + } + %3 = math.sqrt %2 : f64 + affine.store %3, %arg3[%arg5, %arg5] : memref + affine.for %arg6 = 0 to %1 { + %4 = affine.load %arg2[%arg6, %arg5] : memref + %5 = affine.load %arg3[%arg5, %arg5] : memref + %6 = arith.divf %4, %5 : f64 + affine.store %6, %arg4[%arg6, %arg5] : memref + } + affine.for %arg6 = #map(%arg5) to %0 { + affine.store %cst, %arg3[%arg5, %arg6] : memref + affine.for %arg7 = 0 to %1 { + %4 = affine.load %arg4[%arg7, %arg5] : memref + %5 = affine.load %arg2[%arg7, %arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg3[%arg5, %arg6] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg3[%arg5, %arg6] : memref + } + affine.for %arg7 = 0 to %1 { + %4 = affine.load %arg2[%arg7, %arg6] : memref + %5 = affine.load %arg4[%arg7, %arg5] : memref + %6 = affine.load %arg3[%arg5, %arg6] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.subf %4, %7 : f64 + affine.store %8, %arg2[%arg7, %arg6] : memref + } + } + } + return + } +} diff --git a/polybench_results/gramschmidt_linalg.mlir b/polybench_results/gramschmidt_linalg.mlir new file mode 100644 index 000000000000..5edb295a467a --- /dev/null +++ b/polybench_results/gramschmidt_linalg.mlir @@ -0,0 +1,68 @@ +#map = affine_map<(d0)[s0] -> (d0, s0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0) -> (d0)> +#map3 = affine_map<(d0)[s0] -> (s0, s0)> +#map4 = affine_map<(d0)[s0] -> (s0, d0)> +#map5 = affine_map<(d0) -> (d0 + 1)> +#map6 = affine_map<(d0, d1)[s0] -> (d0, s0)> +#map7 = affine_map<(d0, d1) -> (d0, d1)> +#map8 = affine_map<(d0, d1)[s0] -> (s0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_gramschmidt(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg5 = 0 to %0 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %2 = polygeist.submap(%arg2, %arg5, %1) {map = #map} : (memref, index, index) -> memref + %3 = polygeist.submap(%alloca, %1) {map = #map1} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2], iterator_types = ["reduction"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + %16 = arith.mulf %in, %in : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } + %4 = affine.load %alloca[] : memref + %5 = math.sqrt %4 : f64 + affine.store %5, %arg3[%arg5, %arg5] : memref + %6 = polygeist.submap(%arg2, %arg5, %1) {map = #map} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg3, %arg5, %1) {map = #map3} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %arg5, %1) {map = #map} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map2, #map2, #map2], iterator_types = ["parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %16 = arith.divf %in, %in_0 : f64 + linalg.yield %16 : f64 + } + %9 = polygeist.submap(%arg3, %arg5, %0) {map = #map4} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel"]} outs(%9 : memref) { + ^bb0(%out: f64): + %16 = linalg.index 0 : index + %17 = affine.apply #map5(%arg5) + %18 = arith.cmpi sge, %16, %17 : index + %19 = arith.select %18, %cst, %out : f64 + linalg.yield %19 : f64 + } + %10 = polygeist.submap(%arg4, %arg5, %1, %0) {map = #map6} : (memref, index, index, index) -> memref + %11 = polygeist.submap(%arg2, %1, %0) {map = #map7} : (memref, index, index) -> memref + %12 = polygeist.submap(%arg3, %arg5, %1, %0) {map = #map8} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "reduction"]} ins(%10, %11 : memref, memref) outs(%12 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %16 = arith.mulf %in, %in_0 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } + %13 = polygeist.submap(%arg4, %arg5, %1, %0) {map = #map6} : (memref, index, index, index) -> memref + %14 = polygeist.submap(%arg3, %arg5, %1, %0) {map = #map8} : (memref, index, index, index) -> memref + %15 = polygeist.submap(%arg2, %1, %0) {map = #map7} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%13, %14 : memref, memref) outs(%15 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %16 = arith.mulf %in, %in_0 : f64 + %17 = arith.subf %out, %16 : f64 + linalg.yield %17 : f64 + } + } + return + } +} + diff --git a/polybench_results/heat-3d.log b/polybench_results/heat-3d.log new file mode 100644 index 000000000000..ebdddbbd167d --- /dev/null +++ b/polybench_results/heat-3d.log @@ -0,0 +1,131 @@ +/home/arjaiswal/Polygeist/polybench_results/heat-3d.mlir:3:3: warning: Distribute+Raising didn't converge, continuing anyway + func.func @kernel_heat_3d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +/home/arjaiswal/Polygeist/polybench_results/heat-3d.mlir:3:3: note: see current operation: +func.func @kernel_heat_3d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 1.250000e-01 : f64 + %cst_0 = arith.constant 2.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + affine.for %arg4 = 1 to 21 { + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %6 = arith.subi %5, %c1 : index + %7 = polygeist.submap(%arg2, %4, %6, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %9, %11, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg2, %14, %16, %2) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %21 = arith.subi %20, %c1 : index + %22 = polygeist.submap(%arg2, %19, %21, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg2, %24, %26, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %28 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg2, %29, %31, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %36 = arith.subi %35, %c1 : index + %37 = polygeist.submap(%arg2, %34, %36, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %38 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %39 = arith.subi %38, %c1 : index + %40 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg3, %39, %41, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%7, %12, %17, %22, %27, %32, %37 : memref, memref, memref, memref, memref, memref, memref) outs(%42 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %46 = arith.subi %45, %c1 : index + %47 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %48 = arith.subi %47, %c1 : index + %49 = polygeist.submap(%arg3, %46, %48, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %50 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %51 = arith.subi %50, %c1 : index + %52 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %53 = arith.subi %52, %c1 : index + %54 = polygeist.submap(%arg3, %51, %53, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %55 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %56 = arith.subi %55, %c1 : index + %57 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %58 = arith.subi %57, %c1 : index + %59 = polygeist.submap(%arg3, %56, %58, %44) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %60 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %61 = arith.subi %60, %c1 : index + %62 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %63 = arith.subi %62, %c1 : index + %64 = polygeist.submap(%arg3, %61, %63, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %65 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %66 = arith.subi %65, %c1 : index + %67 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %68 = arith.subi %67, %c1 : index + %69 = polygeist.submap(%arg3, %66, %68, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %70 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %71 = arith.subi %70, %c1 : index + %72 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %73 = arith.subi %72, %c1 : index + %74 = polygeist.submap(%arg3, %71, %73, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %75 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %76 = arith.subi %75, %c1 : index + %77 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %78 = arith.subi %77, %c1 : index + %79 = polygeist.submap(%arg3, %76, %78, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %80 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %81 = arith.subi %80, %c1 : index + %82 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %83 = arith.subi %82, %c1 : index + %84 = polygeist.submap(%arg2, %81, %83, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%49, %54, %59, %64, %69, %74, %79 : memref, memref, memref, memref, memref, memref, memref) outs(%84 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } + } + return +} diff --git a/polybench_results/heat-3d.mlir b/polybench_results/heat-3d.mlir new file mode 100644 index 000000000000..68157ba1f75f --- /dev/null +++ b/polybench_results/heat-3d.mlir @@ -0,0 +1,65 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_heat_3d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.250000e-01 : f64 + %cst_0 = arith.constant 2.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + affine.for %arg4 = 1 to 21 { + affine.for %arg5 = 1 to #map()[%0] { + affine.for %arg6 = 1 to #map()[%0] { + affine.for %arg7 = 1 to #map()[%0] { + %1 = affine.load %arg2[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg2[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg2[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg2[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg2[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg2[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg2[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg3[%arg5, %arg6, %arg7] : memref + } + } + } + affine.for %arg5 = 1 to #map()[%0] { + affine.for %arg6 = 1 to #map()[%0] { + affine.for %arg7 = 1 to #map()[%0] { + %1 = affine.load %arg3[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg3[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg3[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg3[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg3[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg3[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg3[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg2[%arg5, %arg6, %arg7] : memref + } + } + } + } + return + } +} diff --git a/polybench_results/heat-3d_debuf.mlir b/polybench_results/heat-3d_debuf.mlir new file mode 100644 index 000000000000..9a16bc7af24c --- /dev/null +++ b/polybench_results/heat-3d_debuf.mlir @@ -0,0 +1,148 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +#map1 = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)> +#map2 = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)> +#map3 = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)> +#map4 = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)> +#map5 = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)> +#map6 = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)> +#map7 = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)> +#map8 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_heat_3d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.000000e+00 : f64 + %cst_0 = arith.constant 1.250000e-01 : f64 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.index_cast %arg1 : i32 to index + %3:2 = affine.for %arg4 = 1 to 21 iter_args(%arg5 = %1, %arg6 = %0) -> (tensor, tensor) { + %6 = affine.apply #map()[%2] + %7 = arith.subi %6, %c1 : index + %8 = affine.apply #map()[%2] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply #map()[%2] + %11 = arith.subi %10, %c1 : index + %12 = affine.apply #map()[%2] + %13 = arith.subi %12, %c1 : index + %14 = affine.apply #map()[%2] + %15 = arith.subi %14, %c1 : index + %16 = affine.apply #map()[%2] + %17 = arith.subi %16, %c1 : index + %18 = affine.apply #map()[%2] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply #map()[%2] + %21 = arith.subi %20, %c1 : index + %22 = affine.apply #map()[%2] + %23 = arith.subi %22, %c1 : index + %24 = affine.apply #map()[%2] + %25 = arith.subi %24, %c1 : index + %26 = affine.apply #map()[%2] + %27 = arith.subi %26, %c1 : index + %28 = affine.apply #map()[%2] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply #map()[%2] + %31 = arith.subi %30, %c1 : index + %32 = affine.apply #map()[%2] + %33 = arith.subi %32, %c1 : index + %34 = affine.apply #map()[%2] + %35 = arith.subi %34, %c1 : index + %36 = affine.apply #map()[%2] + %37 = arith.subi %36, %c1 : index + %38 = affine.apply #map()[%2] + %39 = arith.subi %38, %c1 : index + %40 = polygeist.submap(%arg5, %9, %11, %7) {map = #map1} : (tensor, index, index, index) -> tensor + %41 = polygeist.submap(%arg5, %13, %15, %7) {map = #map2} : (tensor, index, index, index) -> tensor + %42 = polygeist.submap(%arg5, %17, %19, %7) {map = #map3} : (tensor, index, index, index) -> tensor + %43 = polygeist.submap(%arg5, %21, %23, %7) {map = #map4} : (tensor, index, index, index) -> tensor + %44 = polygeist.submap(%arg5, %25, %27, %7) {map = #map5} : (tensor, index, index, index) -> tensor + %45 = polygeist.submap(%arg5, %29, %31, %7) {map = #map6} : (tensor, index, index, index) -> tensor + %46 = polygeist.submap(%arg5, %33, %35, %7) {map = #map7} : (tensor, index, index, index) -> tensor + %47 = polygeist.submap(%arg6, %37, %39, %7) {map = #map2} : (tensor, index, index, index) -> tensor + %48 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map8, #map8, #map8, #map8, #map8, #map8], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%40, %41, %42, %43, %44, %45, %46 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%47 : tensor) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %94 = arith.mulf %in_1, %cst : f64 + %95 = arith.subf %in, %94 : f64 + %96 = arith.addf %95, %in_2 : f64 + %97 = arith.mulf %96, %cst_0 : f64 + %98 = arith.subf %in_3, %94 : f64 + %99 = arith.addf %98, %in_4 : f64 + %100 = arith.mulf %99, %cst_0 : f64 + %101 = arith.addf %97, %100 : f64 + %102 = arith.subf %in_5, %94 : f64 + %103 = arith.addf %102, %in_6 : f64 + %104 = arith.mulf %103, %cst_0 : f64 + %105 = arith.addf %101, %104 : f64 + %106 = arith.addf %105, %in_1 : f64 + linalg.yield %106 : f64 + } -> tensor + %49 = polygeist.submapInverse(%arg6, %48, %37, %39, %7) {map = #map2} : (tensor, tensor, index, index, index) -> tensor + %50 = affine.apply #map()[%2] + %51 = arith.subi %50, %c1 : index + %52 = affine.apply #map()[%2] + %53 = arith.subi %52, %c1 : index + %54 = affine.apply #map()[%2] + %55 = arith.subi %54, %c1 : index + %56 = affine.apply #map()[%2] + %57 = arith.subi %56, %c1 : index + %58 = affine.apply #map()[%2] + %59 = arith.subi %58, %c1 : index + %60 = affine.apply #map()[%2] + %61 = arith.subi %60, %c1 : index + %62 = affine.apply #map()[%2] + %63 = arith.subi %62, %c1 : index + %64 = affine.apply #map()[%2] + %65 = arith.subi %64, %c1 : index + %66 = affine.apply #map()[%2] + %67 = arith.subi %66, %c1 : index + %68 = affine.apply #map()[%2] + %69 = arith.subi %68, %c1 : index + %70 = affine.apply #map()[%2] + %71 = arith.subi %70, %c1 : index + %72 = affine.apply #map()[%2] + %73 = arith.subi %72, %c1 : index + %74 = affine.apply #map()[%2] + %75 = arith.subi %74, %c1 : index + %76 = affine.apply #map()[%2] + %77 = arith.subi %76, %c1 : index + %78 = affine.apply #map()[%2] + %79 = arith.subi %78, %c1 : index + %80 = affine.apply #map()[%2] + %81 = arith.subi %80, %c1 : index + %82 = affine.apply #map()[%2] + %83 = arith.subi %82, %c1 : index + %84 = polygeist.submap(%arg5, %81, %83, %51) {map = #map2} : (tensor, index, index, index) -> tensor + %85 = polygeist.submap(%49, %53, %55, %51) {map = #map1} : (tensor, index, index, index) -> tensor + %86 = polygeist.submap(%49, %57, %59, %51) {map = #map2} : (tensor, index, index, index) -> tensor + %87 = polygeist.submap(%49, %61, %63, %51) {map = #map3} : (tensor, index, index, index) -> tensor + %88 = polygeist.submap(%49, %65, %67, %51) {map = #map4} : (tensor, index, index, index) -> tensor + %89 = polygeist.submap(%49, %69, %71, %51) {map = #map5} : (tensor, index, index, index) -> tensor + %90 = polygeist.submap(%49, %73, %75, %51) {map = #map6} : (tensor, index, index, index) -> tensor + %91 = polygeist.submap(%49, %77, %79, %51) {map = #map7} : (tensor, index, index, index) -> tensor + %92 = linalg.generic {doc = "", indexing_maps = [#map8, #map8, #map8, #map8, #map8, #map8, #map8, #map8], iterator_types = ["parallel", "parallel", "parallel"], library_call = ""} ins(%85, %86, %87, %88, %89, %90, %91 : tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%84 : tensor) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %94 = arith.mulf %in_1, %cst : f64 + %95 = arith.subf %in, %94 : f64 + %96 = arith.addf %95, %in_2 : f64 + %97 = arith.mulf %96, %cst_0 : f64 + %98 = arith.subf %in_3, %94 : f64 + %99 = arith.addf %98, %in_4 : f64 + %100 = arith.mulf %99, %cst_0 : f64 + %101 = arith.addf %97, %100 : f64 + %102 = arith.subf %in_5, %94 : f64 + %103 = arith.addf %102, %in_6 : f64 + %104 = arith.mulf %103, %cst_0 : f64 + %105 = arith.addf %101, %104 : f64 + %106 = arith.addf %105, %in_1 : f64 + linalg.yield %106 : f64 + } -> tensor + %93 = polygeist.submapInverse(%arg5, %92, %81, %83, %51) {map = #map2} : (tensor, tensor, index, index, index) -> tensor + affine.yield %93, %49 : tensor, tensor + } + %4 = bufferization.to_memref %3#1 : memref + memref.copy %4, %arg3 : memref to memref + %5 = bufferization.to_memref %3#0 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/polybench_results/heat-3d_linalg.mlir b/polybench_results/heat-3d_linalg.mlir new file mode 100644 index 000000000000..309086ac11b0 --- /dev/null +++ b/polybench_results/heat-3d_linalg.mlir @@ -0,0 +1,139 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +#map1 = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)> +#map2 = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)> +#map3 = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)> +#map4 = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)> +#map5 = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)> +#map6 = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)> +#map7 = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)> +#map8 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_heat_3d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 1.250000e-01 : f64 + %cst_0 = arith.constant 2.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + affine.for %arg4 = 1 to 21 { + %1 = affine.apply #map()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply #map()[%0] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply #map()[%0] + %6 = arith.subi %5, %c1 : index + %7 = polygeist.submap(%arg2, %4, %6, %2) {map = #map1} : (memref, index, index, index) -> memref + %8 = affine.apply #map()[%0] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply #map()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %9, %11, %2) {map = #map2} : (memref, index, index, index) -> memref + %13 = affine.apply #map()[%0] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply #map()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg2, %14, %16, %2) {map = #map3} : (memref, index, index, index) -> memref + %18 = affine.apply #map()[%0] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply #map()[%0] + %21 = arith.subi %20, %c1 : index + %22 = polygeist.submap(%arg2, %19, %21, %2) {map = #map4} : (memref, index, index, index) -> memref + %23 = affine.apply #map()[%0] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply #map()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg2, %24, %26, %2) {map = #map5} : (memref, index, index, index) -> memref + %28 = affine.apply #map()[%0] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply #map()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg2, %29, %31, %2) {map = #map6} : (memref, index, index, index) -> memref + %33 = affine.apply #map()[%0] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply #map()[%0] + %36 = arith.subi %35, %c1 : index + %37 = polygeist.submap(%arg2, %34, %36, %2) {map = #map7} : (memref, index, index, index) -> memref + %38 = affine.apply #map()[%0] + %39 = arith.subi %38, %c1 : index + %40 = affine.apply #map()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg3, %39, %41, %2) {map = #map2} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map8, #map8, #map8, #map8, #map8, #map8], iterator_types = ["parallel", "parallel", "parallel"]} ins(%7, %12, %17, %22, %27, %32, %37 : memref, memref, memref, memref, memref, memref, memref) outs(%42 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } + %43 = affine.apply #map()[%0] + %44 = arith.subi %43, %c1 : index + %45 = affine.apply #map()[%0] + %46 = arith.subi %45, %c1 : index + %47 = affine.apply #map()[%0] + %48 = arith.subi %47, %c1 : index + %49 = polygeist.submap(%arg3, %46, %48, %44) {map = #map1} : (memref, index, index, index) -> memref + %50 = affine.apply #map()[%0] + %51 = arith.subi %50, %c1 : index + %52 = affine.apply #map()[%0] + %53 = arith.subi %52, %c1 : index + %54 = polygeist.submap(%arg3, %51, %53, %44) {map = #map2} : (memref, index, index, index) -> memref + %55 = affine.apply #map()[%0] + %56 = arith.subi %55, %c1 : index + %57 = affine.apply #map()[%0] + %58 = arith.subi %57, %c1 : index + %59 = polygeist.submap(%arg3, %56, %58, %44) {map = #map3} : (memref, index, index, index) -> memref + %60 = affine.apply #map()[%0] + %61 = arith.subi %60, %c1 : index + %62 = affine.apply #map()[%0] + %63 = arith.subi %62, %c1 : index + %64 = polygeist.submap(%arg3, %61, %63, %44) {map = #map4} : (memref, index, index, index) -> memref + %65 = affine.apply #map()[%0] + %66 = arith.subi %65, %c1 : index + %67 = affine.apply #map()[%0] + %68 = arith.subi %67, %c1 : index + %69 = polygeist.submap(%arg3, %66, %68, %44) {map = #map5} : (memref, index, index, index) -> memref + %70 = affine.apply #map()[%0] + %71 = arith.subi %70, %c1 : index + %72 = affine.apply #map()[%0] + %73 = arith.subi %72, %c1 : index + %74 = polygeist.submap(%arg3, %71, %73, %44) {map = #map6} : (memref, index, index, index) -> memref + %75 = affine.apply #map()[%0] + %76 = arith.subi %75, %c1 : index + %77 = affine.apply #map()[%0] + %78 = arith.subi %77, %c1 : index + %79 = polygeist.submap(%arg3, %76, %78, %44) {map = #map7} : (memref, index, index, index) -> memref + %80 = affine.apply #map()[%0] + %81 = arith.subi %80, %c1 : index + %82 = affine.apply #map()[%0] + %83 = arith.subi %82, %c1 : index + %84 = polygeist.submap(%arg2, %81, %83, %44) {map = #map2} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map8, #map8, #map8, #map8, #map8, #map8, #map8, #map8], iterator_types = ["parallel", "parallel", "parallel"]} ins(%49, %54, %59, %64, %69, %74, %79 : memref, memref, memref, memref, memref, memref, memref) outs(%84 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } + } + return + } +} + diff --git a/polybench_results/jacobi-1d.log b/polybench_results/jacobi-1d.log new file mode 100644 index 000000000000..7549f72186ee --- /dev/null +++ b/polybench_results/jacobi-1d.log @@ -0,0 +1,39 @@ +/home/arjaiswal/Polygeist/polybench_results/jacobi-1d.mlir:3:3: warning: Distribute+Raising didn't converge, continuing anyway + func.func @kernel_jacobi_1d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +/home/arjaiswal/Polygeist/polybench_results/jacobi-1d.mlir:3:3: note: see current operation: +func.func @kernel_jacobi_1d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 3.333300e-01 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %6 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %7 = polygeist.submap(%arg3, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6 : memref, memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %11 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %12 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %13 = polygeist.submap(%arg2, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%10, %11, %12 : memref, memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } + } + return +} diff --git a/polybench_results/jacobi-1d.mlir b/polybench_results/jacobi-1d.mlir new file mode 100644 index 000000000000..af155639ffaa --- /dev/null +++ b/polybench_results/jacobi-1d.mlir @@ -0,0 +1,29 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_jacobi_1d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.333300e-01 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg4 = 0 to %1 { + affine.for %arg5 = 1 to #map()[%0] { + %2 = affine.load %arg2[%arg5 - 1] : memref + %3 = affine.load %arg2[%arg5] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg2[%arg5 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + affine.store %7, %arg3[%arg5] : memref + } + affine.for %arg5 = 1 to #map()[%0] { + %2 = affine.load %arg3[%arg5 - 1] : memref + %3 = affine.load %arg3[%arg5] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg3[%arg5 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + affine.store %7, %arg2[%arg5] : memref + } + } + return + } +} diff --git a/polybench_results/jacobi-1d_debuf.mlir b/polybench_results/jacobi-1d_debuf.mlir new file mode 100644 index 000000000000..f1a69a016b4d --- /dev/null +++ b/polybench_results/jacobi-1d_debuf.mlir @@ -0,0 +1,51 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0) -> (d0 + 1)> +#map3 = affine_map<(d0) -> (d0 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_jacobi_1d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 3.333300e-01 : f64 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.index_cast %arg1 : i32 to index + %3 = arith.index_cast %arg0 : i32 to index + %4:2 = affine.for %arg4 = 0 to %3 iter_args(%arg5 = %1, %arg6 = %0) -> (tensor, tensor) { + %7 = affine.apply #map()[%2] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg5, %8) {map = #map1} : (tensor, index) -> tensor + %10 = polygeist.submap(%arg5, %8) {map = #map2} : (tensor, index) -> tensor + %11 = polygeist.submap(%arg5, %8) {map = #map3} : (tensor, index) -> tensor + %12 = polygeist.submap(%arg6, %8) {map = #map2} : (tensor, index) -> tensor + %13 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%9, %10, %11 : tensor, tensor, tensor) outs(%12 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %23 = arith.addf %in, %in_0 : f64 + %24 = arith.addf %23, %in_1 : f64 + %25 = arith.mulf %24, %cst : f64 + linalg.yield %25 : f64 + } -> tensor + %14 = polygeist.submapInverse(%arg6, %13, %8) {map = #map2} : (tensor, tensor, index) -> tensor + %15 = affine.apply #map()[%2] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg5, %16) {map = #map2} : (tensor, index) -> tensor + %18 = polygeist.submap(%14, %16) {map = #map1} : (tensor, index) -> tensor + %19 = polygeist.submap(%14, %16) {map = #map2} : (tensor, index) -> tensor + %20 = polygeist.submap(%14, %16) {map = #map3} : (tensor, index) -> tensor + %21 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = ["parallel"], library_call = ""} ins(%18, %19, %20 : tensor, tensor, tensor) outs(%17 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %23 = arith.addf %in, %in_0 : f64 + %24 = arith.addf %23, %in_1 : f64 + %25 = arith.mulf %24, %cst : f64 + linalg.yield %25 : f64 + } -> tensor + %22 = polygeist.submapInverse(%arg5, %21, %16) {map = #map2} : (tensor, tensor, index) -> tensor + affine.yield %22, %14 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg3 : memref to memref + %6 = bufferization.to_memref %4#0 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/polybench_results/jacobi-1d_linalg.mlir b/polybench_results/jacobi-1d_linalg.mlir new file mode 100644 index 000000000000..7d94a6d96c55 --- /dev/null +++ b/polybench_results/jacobi-1d_linalg.mlir @@ -0,0 +1,42 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0) -> (d0 + 1)> +#map3 = affine_map<(d0) -> (d0 + 2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_jacobi_1d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 3.333300e-01 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg4 = 0 to %1 { + %2 = affine.apply #map()[%0] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg2, %3) {map = #map1} : (memref, index) -> memref + %5 = polygeist.submap(%arg2, %3) {map = #map2} : (memref, index) -> memref + %6 = polygeist.submap(%arg2, %3) {map = #map3} : (memref, index) -> memref + %7 = polygeist.submap(%arg3, %3) {map = #map2} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = ["parallel"]} ins(%4, %5, %6 : memref, memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } + %8 = affine.apply #map()[%0] + %9 = arith.subi %8, %c1 : index + %10 = polygeist.submap(%arg3, %9) {map = #map1} : (memref, index) -> memref + %11 = polygeist.submap(%arg3, %9) {map = #map2} : (memref, index) -> memref + %12 = polygeist.submap(%arg3, %9) {map = #map3} : (memref, index) -> memref + %13 = polygeist.submap(%arg2, %9) {map = #map2} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = ["parallel"]} ins(%10, %11, %12 : memref, memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } + } + return + } +} + diff --git a/polybench_results/jacobi-2d.log b/polybench_results/jacobi-2d.log new file mode 100644 index 000000000000..8468d5132eb6 --- /dev/null +++ b/polybench_results/jacobi-2d.log @@ -0,0 +1,71 @@ +/home/arjaiswal/Polygeist/polybench_results/jacobi-2d.mlir:3:3: warning: Distribute+Raising didn't converge, continuing anyway + func.func @kernel_jacobi_2d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +/home/arjaiswal/Polygeist/polybench_results/jacobi-2d.mlir:3:3: note: see current operation: +func.func @kernel_jacobi_2d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 2.000000e-01 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg2, %5, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %7 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg2, %8, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %11, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = polygeist.submap(%arg2, %14, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %17 = arith.subi %16, %c1 : index + %18 = polygeist.submap(%arg2, %17, %3) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %19 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg3, %20, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %9, %12, %15, %18 : memref, memref, memref, memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %23 = arith.subi %22, %c1 : index + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %25 = arith.subi %24, %c1 : index + %26 = polygeist.submap(%arg3, %25, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %27 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %28 = arith.subi %27, %c1 : index + %29 = polygeist.submap(%arg3, %28, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg3, %31, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = polygeist.submap(%arg3, %34, %23) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %36 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %37 = arith.subi %36, %c1 : index + %38 = polygeist.submap(%arg3, %37, %23) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %39 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %40 = arith.subi %39, %c1 : index + %41 = polygeist.submap(%arg2, %40, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%26, %29, %32, %35, %38 : memref, memref, memref, memref, memref) outs(%41 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } + } + return +} diff --git a/polybench_results/jacobi-2d.mlir b/polybench_results/jacobi-2d.mlir new file mode 100644 index 000000000000..46d88637bf5b --- /dev/null +++ b/polybench_results/jacobi-2d.mlir @@ -0,0 +1,41 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_jacobi_2d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.000000e-01 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg4 = 0 to %1 { + affine.for %arg5 = 1 to #map()[%0] { + affine.for %arg6 = 1 to #map()[%0] { + %2 = affine.load %arg2[%arg5, %arg6] : memref + %3 = affine.load %arg2[%arg5, %arg6 - 1] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg2[%arg5, %arg6 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = affine.load %arg2[%arg5 + 1, %arg6] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg2[%arg5 - 1, %arg6] : memref + %10 = arith.addf %8, %9 : f64 + %11 = arith.mulf %10, %cst : f64 + affine.store %11, %arg3[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 1 to #map()[%0] { + affine.for %arg6 = 1 to #map()[%0] { + %2 = affine.load %arg3[%arg5, %arg6] : memref + %3 = affine.load %arg3[%arg5, %arg6 - 1] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg3[%arg5, %arg6 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = affine.load %arg3[%arg5 + 1, %arg6] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg3[%arg5 - 1, %arg6] : memref + %10 = arith.addf %8, %9 : f64 + %11 = arith.mulf %10, %cst : f64 + affine.store %11, %arg2[%arg5, %arg6] : memref + } + } + } + return + } +} diff --git a/polybench_results/jacobi-2d_debuf.mlir b/polybench_results/jacobi-2d_debuf.mlir new file mode 100644 index 000000000000..7e08a7d0a357 --- /dev/null +++ b/polybench_results/jacobi-2d_debuf.mlir @@ -0,0 +1,86 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +#map1 = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)> +#map2 = affine_map<(d0, d1) -> (d1 + 1, d0)> +#map3 = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)> +#map4 = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)> +#map5 = affine_map<(d0, d1) -> (d1, d0 + 1)> +#map6 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_jacobi_2d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 2.000000e-01 : f64 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = arith.index_cast %arg1 : i32 to index + %3 = arith.index_cast %arg0 : i32 to index + %4:2 = affine.for %arg4 = 0 to %3 iter_args(%arg5 = %1, %arg6 = %0) -> (tensor, tensor) { + %7 = affine.apply #map()[%2] + %8 = arith.subi %7, %c1 : index + %9 = affine.apply #map()[%2] + %10 = arith.subi %9, %c1 : index + %11 = affine.apply #map()[%2] + %12 = arith.subi %11, %c1 : index + %13 = affine.apply #map()[%2] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply #map()[%2] + %16 = arith.subi %15, %c1 : index + %17 = affine.apply #map()[%2] + %18 = arith.subi %17, %c1 : index + %19 = affine.apply #map()[%2] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg5, %10, %8) {map = #map1} : (tensor, index, index) -> tensor + %22 = polygeist.submap(%arg5, %12, %8) {map = #map2} : (tensor, index, index) -> tensor + %23 = polygeist.submap(%arg5, %14, %8) {map = #map3} : (tensor, index, index) -> tensor + %24 = polygeist.submap(%arg5, %16, %8) {map = #map4} : (tensor, index, index) -> tensor + %25 = polygeist.submap(%arg5, %18, %8) {map = #map5} : (tensor, index, index) -> tensor + %26 = polygeist.submap(%arg6, %20, %8) {map = #map1} : (tensor, index, index) -> tensor + %27 = linalg.generic {doc = "", indexing_maps = [#map6, #map6, #map6, #map6, #map6, #map6], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%21, %22, %23, %24, %25 : tensor, tensor, tensor, tensor, tensor) outs(%26 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %51 = arith.addf %in, %in_0 : f64 + %52 = arith.addf %51, %in_1 : f64 + %53 = arith.addf %52, %in_2 : f64 + %54 = arith.addf %53, %in_3 : f64 + %55 = arith.mulf %54, %cst : f64 + linalg.yield %55 : f64 + } -> tensor + %28 = polygeist.submapInverse(%arg6, %27, %20, %8) {map = #map1} : (tensor, tensor, index, index) -> tensor + %29 = affine.apply #map()[%2] + %30 = arith.subi %29, %c1 : index + %31 = affine.apply #map()[%2] + %32 = arith.subi %31, %c1 : index + %33 = affine.apply #map()[%2] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply #map()[%2] + %36 = arith.subi %35, %c1 : index + %37 = affine.apply #map()[%2] + %38 = arith.subi %37, %c1 : index + %39 = affine.apply #map()[%2] + %40 = arith.subi %39, %c1 : index + %41 = affine.apply #map()[%2] + %42 = arith.subi %41, %c1 : index + %43 = polygeist.submap(%arg5, %42, %30) {map = #map1} : (tensor, index, index) -> tensor + %44 = polygeist.submap(%28, %32, %30) {map = #map1} : (tensor, index, index) -> tensor + %45 = polygeist.submap(%28, %34, %30) {map = #map2} : (tensor, index, index) -> tensor + %46 = polygeist.submap(%28, %36, %30) {map = #map3} : (tensor, index, index) -> tensor + %47 = polygeist.submap(%28, %38, %30) {map = #map4} : (tensor, index, index) -> tensor + %48 = polygeist.submap(%28, %40, %30) {map = #map5} : (tensor, index, index) -> tensor + %49 = linalg.generic {doc = "", indexing_maps = [#map6, #map6, #map6, #map6, #map6, #map6], iterator_types = ["parallel", "parallel"], library_call = ""} ins(%44, %45, %46, %47, %48 : tensor, tensor, tensor, tensor, tensor) outs(%43 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %51 = arith.addf %in, %in_0 : f64 + %52 = arith.addf %51, %in_1 : f64 + %53 = arith.addf %52, %in_2 : f64 + %54 = arith.addf %53, %in_3 : f64 + %55 = arith.mulf %54, %cst : f64 + linalg.yield %55 : f64 + } -> tensor + %50 = polygeist.submapInverse(%arg5, %49, %42, %30) {map = #map1} : (tensor, tensor, index, index) -> tensor + affine.yield %50, %28 : tensor, tensor + } + %5 = bufferization.to_memref %4#1 : memref + memref.copy %5, %arg3 : memref to memref + %6 = bufferization.to_memref %4#0 : memref + memref.copy %6, %arg2 : memref to memref + return + } +} + diff --git a/polybench_results/jacobi-2d_linalg.mlir b/polybench_results/jacobi-2d_linalg.mlir new file mode 100644 index 000000000000..37d86c8a74bb --- /dev/null +++ b/polybench_results/jacobi-2d_linalg.mlir @@ -0,0 +1,77 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +#map1 = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)> +#map2 = affine_map<(d0, d1) -> (d1 + 1, d0)> +#map3 = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)> +#map4 = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)> +#map5 = affine_map<(d0, d1) -> (d1, d0 + 1)> +#map6 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_jacobi_2d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 2.000000e-01 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg4 = 0 to %1 { + %2 = affine.apply #map()[%0] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply #map()[%0] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg2, %5, %3) {map = #map1} : (memref, index, index) -> memref + %7 = affine.apply #map()[%0] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg2, %8, %3) {map = #map2} : (memref, index, index) -> memref + %10 = affine.apply #map()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %11, %3) {map = #map3} : (memref, index, index) -> memref + %13 = affine.apply #map()[%0] + %14 = arith.subi %13, %c1 : index + %15 = polygeist.submap(%arg2, %14, %3) {map = #map4} : (memref, index, index) -> memref + %16 = affine.apply #map()[%0] + %17 = arith.subi %16, %c1 : index + %18 = polygeist.submap(%arg2, %17, %3) {map = #map5} : (memref, index, index) -> memref + %19 = affine.apply #map()[%0] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg3, %20, %3) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map6, #map6, #map6, #map6, #map6], iterator_types = ["parallel", "parallel"]} ins(%6, %9, %12, %15, %18 : memref, memref, memref, memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } + %22 = affine.apply #map()[%0] + %23 = arith.subi %22, %c1 : index + %24 = affine.apply #map()[%0] + %25 = arith.subi %24, %c1 : index + %26 = polygeist.submap(%arg3, %25, %23) {map = #map1} : (memref, index, index) -> memref + %27 = affine.apply #map()[%0] + %28 = arith.subi %27, %c1 : index + %29 = polygeist.submap(%arg3, %28, %23) {map = #map2} : (memref, index, index) -> memref + %30 = affine.apply #map()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg3, %31, %23) {map = #map3} : (memref, index, index) -> memref + %33 = affine.apply #map()[%0] + %34 = arith.subi %33, %c1 : index + %35 = polygeist.submap(%arg3, %34, %23) {map = #map4} : (memref, index, index) -> memref + %36 = affine.apply #map()[%0] + %37 = arith.subi %36, %c1 : index + %38 = polygeist.submap(%arg3, %37, %23) {map = #map5} : (memref, index, index) -> memref + %39 = affine.apply #map()[%0] + %40 = arith.subi %39, %c1 : index + %41 = polygeist.submap(%arg2, %40, %23) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map6, #map6, #map6, #map6, #map6], iterator_types = ["parallel", "parallel"]} ins(%26, %29, %32, %35, %38 : memref, memref, memref, memref, memref) outs(%41 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } + } + return + } +} + diff --git a/polybench_results/lu.log b/polybench_results/lu.log new file mode 100644 index 000000000000..e0a014d716f5 --- /dev/null +++ b/polybench_results/lu.log @@ -0,0 +1,45 @@ +/home/arjaiswal/Polygeist/polybench_results/lu.mlir:3:3: warning: Distribute+Raising didn't converge, continuing anyway + func.func @kernel_lu(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +/home/arjaiswal/Polygeist/polybench_results/lu.mlir:3:3: note: see current operation: +func.func @kernel_lu(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %7 = arith.subi %arg2, %c1 : index + %8 = polygeist.submap(%arg1, %arg2, %7) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg1, %arg3, %7) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %10 = polygeist.submap(%arg1, %arg2, %arg3, %7) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = arith.mulf %in, %in_0 : f64 + %15 = arith.subf %out, %14 : f64 + %16 = linalg.index 0 : index + %17 = arith.cmpi slt, %16, %arg3 : index + %18 = arith.select %17, %15, %out : f64 + linalg.yield %18 : f64 + } + %11 = affine.load %arg1[%arg3, %arg3] : memref + %12 = affine.load %arg1[%arg2, %arg3] : memref + %13 = arith.divf %12, %11 : f64 + affine.store %13, %arg1[%arg2, %arg3] : memref + } + %1 = arith.subi %0, %c1 : index + %2 = polygeist.submap(%arg1, %arg2, %1, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + %3 = arith.subi %0, %c1 : index + %4 = polygeist.submap(%arg1, %3, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %5 = arith.subi %0, %c1 : index + %6 = polygeist.submap(%arg1, %arg2, %5, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "reduction"]} ins(%2, %4 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + %9 = linalg.index 1 : index + %10 = arith.cmpi slt, %9, %arg2 : index + %11 = arith.select %10, %8, %out : f64 + linalg.yield %11 : f64 + } + } + return +} diff --git a/polybench_results/lu.mlir b/polybench_results/lu.mlir new file mode 100644 index 000000000000..43213289dd19 --- /dev/null +++ b/polybench_results/lu.mlir @@ -0,0 +1,33 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_lu(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to #map(%arg2) { + affine.for %arg4 = 0 to #map(%arg3) { + %4 = affine.load %arg1[%arg2, %arg4] : memref + %5 = affine.load %arg1[%arg4, %arg3] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg1[%arg2, %arg3] : memref + %8 = arith.subf %7, %6 : f64 + affine.store %8, %arg1[%arg2, %arg3] : memref + } + %1 = affine.load %arg1[%arg3, %arg3] : memref + %2 = affine.load %arg1[%arg2, %arg3] : memref + %3 = arith.divf %2, %1 : f64 + affine.store %3, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = #map(%arg2) to %0 { + affine.for %arg4 = 0 to #map(%arg2) { + %1 = affine.load %arg1[%arg2, %arg4] : memref + %2 = affine.load %arg1[%arg4, %arg3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg1[%arg2, %arg3] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg1[%arg2, %arg3] : memref + } + } + } + return + } +} diff --git a/polybench_results/lu_debuf.mlir b/polybench_results/lu_debuf.mlir new file mode 100644 index 000000000000..99a73e78e429 --- /dev/null +++ b/polybench_results/lu_debuf.mlir @@ -0,0 +1,58 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0)[s0] -> (s0, d0)> +#map2 = affine_map<(d0)[s0] -> (d0, s0)> +#map3 = affine_map<(d0)[s0, s1] -> (s0, s1)> +#map4 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map5 = affine_map<(d0, d1) -> (d0, d1)> +#map6 = affine_map<(d0, d1)[s0] -> (s0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_lu(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg1 : memref + %1 = arith.index_cast %arg0 : i32 to index + %2 = affine.for %arg2 = 0 to %1 iter_args(%arg3 = %0) -> (tensor) { + %4 = affine.for %arg4 = 0 to #map(%arg2) iter_args(%arg5 = %arg3) -> (tensor) { + %13 = arith.subi %arg2, %c1 : index + %14 = polygeist.submap(%arg5, %arg2, %13) {map = #map1} : (tensor, index, index) -> tensor + %15 = polygeist.submap(%arg5, %arg4, %13) {map = #map2} : (tensor, index, index) -> tensor + %16 = polygeist.submap(%arg5, %arg2, %arg4, %13) {map = #map3} : (tensor, index, index, index) -> tensor + %17 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["reduction"], library_call = ""} ins(%14, %15 : tensor, tensor) outs(%16 : tensor) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %20 = arith.mulf %in, %in_1 : f64 + %21 = arith.subf %out, %20 : f64 + %22 = linalg.index 0 : index + %23 = arith.cmpi slt, %22, %arg4 : index + %24 = arith.select %23, %21, %out : f64 + linalg.yield %24 : f64 + } -> tensor + %18 = polygeist.submapInverse(%arg5, %17, %arg2, %arg4, %13) {map = #map3} : (tensor, tensor, index, index, index) -> tensor + %extracted = tensor.extract %18[%arg4, %arg4] : tensor + %extracted_0 = tensor.extract %18[%arg2, %arg4] : tensor + %19 = arith.divf %extracted_0, %extracted : f64 + %inserted = tensor.insert %19 into %18[%arg2, %arg4] : tensor + affine.yield %inserted : tensor + } + %5 = arith.subi %1, %c1 : index + %6 = arith.subi %1, %c1 : index + %7 = arith.subi %1, %c1 : index + %8 = polygeist.submap(%4, %arg2, %5, %1) {map = #map4} : (tensor, index, index, index) -> tensor + %9 = polygeist.submap(%4, %6, %1) {map = #map5} : (tensor, index, index) -> tensor + %10 = polygeist.submap(%4, %arg2, %7, %1) {map = #map6} : (tensor, index, index, index) -> tensor + %11 = linalg.generic {doc = "", indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%8, %9 : tensor, tensor) outs(%10 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %13 = arith.mulf %in, %in_0 : f64 + %14 = arith.subf %out, %13 : f64 + %15 = linalg.index 1 : index + %16 = arith.cmpi slt, %15, %arg2 : index + %17 = arith.select %16, %14, %out : f64 + linalg.yield %17 : f64 + } -> tensor + %12 = polygeist.submapInverse(%4, %11, %arg2, %7, %1) {map = #map6} : (tensor, tensor, index, index, index) -> tensor + affine.yield %12 : tensor + } + %3 = bufferization.to_memref %2 : memref + memref.copy %3, %arg1 : memref to memref + return + } +} + diff --git a/polybench_results/lu_linalg.mlir b/polybench_results/lu_linalg.mlir new file mode 100644 index 000000000000..5b936a299ad3 --- /dev/null +++ b/polybench_results/lu_linalg.mlir @@ -0,0 +1,51 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0)[s0] -> (s0, d0)> +#map2 = affine_map<(d0)[s0] -> (d0, s0)> +#map3 = affine_map<(d0)[s0, s1] -> (s0, s1)> +#map4 = affine_map<(d0, d1)[s0] -> (s0, d0)> +#map5 = affine_map<(d0, d1) -> (d0, d1)> +#map6 = affine_map<(d0, d1)[s0] -> (s0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_lu(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to #map(%arg2) { + %7 = arith.subi %arg2, %c1 : index + %8 = polygeist.submap(%arg1, %arg2, %7) {map = #map1} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg1, %arg3, %7) {map = #map2} : (memref, index, index) -> memref + %10 = polygeist.submap(%arg1, %arg2, %arg3, %7) {map = #map3} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = arith.mulf %in, %in_0 : f64 + %15 = arith.subf %out, %14 : f64 + %16 = linalg.index 0 : index + %17 = arith.cmpi slt, %16, %arg3 : index + %18 = arith.select %17, %15, %out : f64 + linalg.yield %18 : f64 + } + %11 = affine.load %arg1[%arg3, %arg3] : memref + %12 = affine.load %arg1[%arg2, %arg3] : memref + %13 = arith.divf %12, %11 : f64 + affine.store %13, %arg1[%arg2, %arg3] : memref + } + %1 = arith.subi %0, %c1 : index + %2 = polygeist.submap(%arg1, %arg2, %1, %0) {map = #map4} : (memref, index, index, index) -> memref + %3 = arith.subi %0, %c1 : index + %4 = polygeist.submap(%arg1, %3, %0) {map = #map5} : (memref, index, index) -> memref + %5 = arith.subi %0, %c1 : index + %6 = polygeist.submap(%arg1, %arg2, %5, %0) {map = #map6} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "reduction"]} ins(%2, %4 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + %9 = linalg.index 1 : index + %10 = arith.cmpi slt, %9, %arg2 : index + %11 = arith.select %10, %8, %out : f64 + linalg.yield %11 : f64 + } + } + return + } +} + diff --git a/polybench_results/ludcmp.log b/polybench_results/ludcmp.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/ludcmp.mlir b/polybench_results/ludcmp.mlir new file mode 100644 index 000000000000..cc2e21426bdc --- /dev/null +++ b/polybench_results/ludcmp.mlir @@ -0,0 +1,73 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0)[s0] -> (-d0 + s0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_ludcmp(%arg0: i32, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + %1 = llvm.mlir.undef : f64 + affine.store %1, %alloca[] : memref + affine.for %arg5 = 0 to %0 { + affine.for %arg6 = 0 to #map(%arg5) { + %2 = affine.load %arg1[%arg5, %arg6] : memref + affine.store %2, %alloca[] : memref + affine.for %arg7 = 0 to #map(%arg6) { + %6 = affine.load %arg1[%arg5, %arg7] : memref + %7 = affine.load %arg1[%arg7, %arg6] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %alloca[] : memref + %10 = arith.subf %9, %8 : f64 + affine.store %10, %alloca[] : memref + } + %3 = affine.load %alloca[] : memref + %4 = affine.load %arg1[%arg6, %arg6] : memref + %5 = arith.divf %3, %4 : f64 + affine.store %5, %arg1[%arg5, %arg6] : memref + } + affine.for %arg6 = #map(%arg5) to %0 { + %2 = affine.load %arg1[%arg5, %arg6] : memref + affine.store %2, %alloca[] : memref + affine.for %arg7 = 0 to #map(%arg5) { + %4 = affine.load %arg1[%arg5, %arg7] : memref + %5 = affine.load %arg1[%arg7, %arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %alloca[] : memref + %8 = arith.subf %7, %6 : f64 + affine.store %8, %alloca[] : memref + } + %3 = affine.load %alloca[] : memref + affine.store %3, %arg1[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 0 to %0 { + %2 = affine.load %arg2[%arg5] : memref + affine.store %2, %alloca[] : memref + affine.for %arg6 = 0 to #map(%arg5) { + %4 = affine.load %arg1[%arg5, %arg6] : memref + %5 = affine.load %arg4[%arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %alloca[] : memref + %8 = arith.subf %7, %6 : f64 + affine.store %8, %alloca[] : memref + } + %3 = affine.load %alloca[] : memref + affine.store %3, %arg4[%arg5] : memref + } + affine.for %arg5 = 0 to %0 { + %2 = affine.load %arg4[-%arg5 + symbol(%0) - 1] : memref + affine.store %2, %alloca[] : memref + affine.for %arg6 = #map1(%arg5)[%0] to %0 { + %6 = affine.load %arg1[-%arg5 + symbol(%0) - 1, %arg6] : memref + %7 = affine.load %arg3[%arg6] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %alloca[] : memref + %10 = arith.subf %9, %8 : f64 + affine.store %10, %alloca[] : memref + } + %3 = affine.load %alloca[] : memref + %4 = affine.load %arg1[-%arg5 + symbol(%0) - 1, -%arg5 + symbol(%0) - 1] : memref + %5 = arith.divf %3, %4 : f64 + affine.store %5, %arg3[-%arg5 + symbol(%0) - 1] : memref + } + return + } +} diff --git a/polybench_results/ludcmp_debuf.mlir b/polybench_results/ludcmp_debuf.mlir new file mode 100644 index 000000000000..e0a81524ecaf --- /dev/null +++ b/polybench_results/ludcmp_debuf.mlir @@ -0,0 +1,123 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0) -> ()> +#map2 = affine_map<(d0)[s0] -> (s0, d0)> +#map3 = affine_map<(d0)[s0] -> (d0, s0)> +#map4 = affine_map<(d0)[s0] -> (-d0 + s0 - 1)> +#map5 = affine_map<(d0)[s0, s1] -> (-s0 + s1 - 1, d0)> +#map6 = affine_map<(d0)[s0] -> (-d0 + s0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_ludcmp(%arg0: i32, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = bufferization.to_tensor %arg2 : memref + %3 = bufferization.to_tensor %arg1 : memref + %4 = arith.index_cast %arg0 : i32 to index + %5 = tensor.empty() : tensor + %6 = llvm.mlir.undef : f64 + %inserted = tensor.insert %6 into %5[] : tensor + %7:2 = affine.for %arg5 = 0 to %4 iter_args(%arg6 = %inserted, %arg7 = %3) -> (tensor, tensor) { + %13:2 = affine.for %arg8 = 0 to #map(%arg5) iter_args(%arg9 = %arg6, %arg10 = %arg7) -> (tensor, tensor) { + %extracted = tensor.extract %arg10[%arg5, %arg8] : tensor + %inserted_0 = tensor.insert %extracted into %arg9[] : tensor + %15 = arith.subi %arg5, %c1 : index + %16 = polygeist.submap(%inserted_0, %15) {map = #map1} : (tensor, index) -> tensor + %17 = polygeist.submap(%arg10, %arg5, %15) {map = #map2} : (tensor, index, index) -> tensor + %18 = polygeist.submap(%arg10, %arg8, %15) {map = #map3} : (tensor, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["reduction"], library_call = ""} ins(%17, %18 : tensor, tensor) outs(%16 : tensor) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %22 = arith.mulf %in, %in_4 : f64 + %23 = arith.subf %out, %22 : f64 + %24 = linalg.index 0 : index + %25 = arith.cmpi slt, %24, %arg8 : index + %26 = arith.select %25, %23, %out : f64 + linalg.yield %26 : f64 + } -> tensor + %20 = polygeist.submapInverse(%inserted_0, %19, %15) {map = #map1} : (tensor, tensor, index) -> tensor + %extracted_1 = tensor.extract %20[] : tensor + %extracted_2 = tensor.extract %arg10[%arg8, %arg8] : tensor + %21 = arith.divf %extracted_1, %extracted_2 : f64 + %inserted_3 = tensor.insert %21 into %arg10[%arg5, %arg8] : tensor + affine.yield %20, %inserted_3 : tensor, tensor + } + %14:2 = affine.for %arg8 = #map(%arg5) to %4 iter_args(%arg9 = %13#0, %arg10 = %13#1) -> (tensor, tensor) { + %extracted = tensor.extract %arg10[%arg5, %arg8] : tensor + %inserted_0 = tensor.insert %extracted into %arg9[] : tensor + %15 = arith.subi %4, %c1 : index + %16 = polygeist.submap(%inserted_0, %15) {map = #map1} : (tensor, index) -> tensor + %17 = polygeist.submap(%arg10, %arg5, %15) {map = #map2} : (tensor, index, index) -> tensor + %18 = polygeist.submap(%arg10, %arg8, %15) {map = #map3} : (tensor, index, index) -> tensor + %19 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["reduction"], library_call = ""} ins(%17, %18 : tensor, tensor) outs(%16 : tensor) { + ^bb0(%in: f64, %in_3: f64, %out: f64): + %21 = arith.mulf %in, %in_3 : f64 + %22 = arith.subf %out, %21 : f64 + %23 = linalg.index 0 : index + %24 = arith.cmpi slt, %23, %arg5 : index + %25 = arith.select %24, %22, %out : f64 + linalg.yield %25 : f64 + } -> tensor + %20 = polygeist.submapInverse(%inserted_0, %19, %15) {map = #map1} : (tensor, tensor, index) -> tensor + %extracted_1 = tensor.extract %20[] : tensor + %inserted_2 = tensor.insert %extracted_1 into %arg10[%arg5, %arg8] : tensor + affine.yield %20, %inserted_2 : tensor, tensor + } + affine.yield %14#0, %14#1 : tensor, tensor + } + %8 = bufferization.to_memref %7#1 : memref + memref.copy %8, %arg1 : memref to memref + %9:2 = affine.for %arg5 = 0 to %4 iter_args(%arg6 = %7#0, %arg7 = %0) -> (tensor, tensor) { + %extracted = tensor.extract %2[%arg5] : tensor + %inserted_0 = tensor.insert %extracted into %arg6[] : tensor + %13 = arith.subi %4, %c1 : index + %14 = polygeist.submap(%inserted_0, %13) {map = #map1} : (tensor, index) -> tensor + %15 = polygeist.submap(%7#1, %arg5, %13) {map = #map2} : (tensor, index, index) -> tensor + %16 = polygeist.submap(%arg7, %13) {map = #map} : (tensor, index) -> tensor + %17 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["reduction"], library_call = ""} ins(%15, %16 : tensor, tensor) outs(%14 : tensor) { + ^bb0(%in: f64, %in_3: f64, %out: f64): + %19 = arith.mulf %in, %in_3 : f64 + %20 = arith.subf %out, %19 : f64 + %21 = linalg.index 0 : index + %22 = arith.cmpi slt, %21, %arg5 : index + %23 = arith.select %22, %20, %out : f64 + linalg.yield %23 : f64 + } -> tensor + %18 = polygeist.submapInverse(%inserted_0, %17, %13) {map = #map1} : (tensor, tensor, index) -> tensor + %extracted_1 = tensor.extract %18[] : tensor + %inserted_2 = tensor.insert %extracted_1 into %arg7[%arg5] : tensor + affine.yield %18, %inserted_2 : tensor, tensor + } + %10 = bufferization.to_memref %9#1 : memref + memref.copy %10, %arg4 : memref to memref + %11:2 = affine.for %arg5 = 0 to %4 iter_args(%arg6 = %9#0, %arg7 = %1) -> (tensor, tensor) { + %13 = affine.apply #map4(%arg5)[%4] + %extracted = tensor.extract %9#1[%13] : tensor + %inserted_0 = tensor.insert %extracted into %arg6[] : tensor + %14 = polygeist.submap(%inserted_0, %4) {map = #map1} : (tensor, index) -> tensor + %15 = polygeist.submap(%7#1, %arg5, %4, %4) {map = #map5} : (tensor, index, index, index) -> tensor + %16 = polygeist.submap(%arg7, %4) {map = #map} : (tensor, index) -> tensor + %17 = linalg.generic {doc = "", indexing_maps = [#map, #map, #map], iterator_types = ["reduction"], library_call = ""} ins(%15, %16 : tensor, tensor) outs(%14 : tensor) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %23 = arith.mulf %in, %in_4 : f64 + %24 = arith.subf %out, %23 : f64 + %25 = linalg.index 0 : index + %26 = affine.apply #map6(%arg5)[%4] + %27 = arith.cmpi sge, %25, %26 : index + %28 = arith.select %27, %24, %out : f64 + linalg.yield %28 : f64 + } -> tensor + %18 = polygeist.submapInverse(%inserted_0, %17, %4) {map = #map1} : (tensor, tensor, index) -> tensor + %extracted_1 = tensor.extract %18[] : tensor + %19 = affine.apply #map4(%arg5)[%4] + %20 = affine.apply #map4(%arg5)[%4] + %extracted_2 = tensor.extract %7#1[%19, %20] : tensor + %21 = arith.divf %extracted_1, %extracted_2 : f64 + %22 = affine.apply #map4(%arg5)[%4] + %inserted_3 = tensor.insert %21 into %arg7[%22] : tensor + affine.yield %18, %inserted_3 : tensor, tensor + } + %12 = bufferization.to_memref %11#1 : memref + memref.copy %12, %arg3 : memref to memref + return + } +} + diff --git a/polybench_results/ludcmp_linalg.mlir b/polybench_results/ludcmp_linalg.mlir new file mode 100644 index 000000000000..3fd38810bcfa --- /dev/null +++ b/polybench_results/ludcmp_linalg.mlir @@ -0,0 +1,99 @@ +#map = affine_map<(d0) -> (d0)> +#map1 = affine_map<(d0)[s0] -> (s0, d0)> +#map2 = affine_map<(d0)[s0] -> (d0, s0)> +#map3 = affine_map<(d0) -> ()> +#map4 = affine_map<(d0)[s0, s1] -> (-s0 + s1 - 1, d0)> +#map5 = affine_map<(d0)[s0] -> (-d0 + s0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_ludcmp(%arg0: i32, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %0 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + %1 = llvm.mlir.undef : f64 + affine.store %1, %alloca[] : memref + affine.for %arg5 = 0 to %0 { + affine.for %arg6 = 0 to #map(%arg5) { + %2 = affine.load %arg1[%arg5, %arg6] : memref + affine.store %2, %alloca[] : memref + %3 = arith.subi %arg5, %c1 : index + %4 = polygeist.submap(%arg1, %arg5, %3) {map = #map1} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg1, %arg6, %3) {map = #map2} : (memref, index, index) -> memref + %6 = polygeist.submap(%alloca, %3) {map = #map3} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.subf %out, %10 : f64 + %12 = linalg.index 0 : index + %13 = arith.cmpi slt, %12, %arg6 : index + %14 = arith.select %13, %11, %out : f64 + linalg.yield %14 : f64 + } + %7 = affine.load %alloca[] : memref + %8 = affine.load %arg1[%arg6, %arg6] : memref + %9 = arith.divf %7, %8 : f64 + affine.store %9, %arg1[%arg5, %arg6] : memref + } + affine.for %arg6 = #map(%arg5) to %0 { + %2 = affine.load %arg1[%arg5, %arg6] : memref + affine.store %2, %alloca[] : memref + %3 = arith.subi %0, %c1 : index + %4 = polygeist.submap(%arg1, %arg5, %3) {map = #map1} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg1, %arg6, %3) {map = #map2} : (memref, index, index) -> memref + %6 = polygeist.submap(%alloca, %3) {map = #map3} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.subf %out, %8 : f64 + %10 = linalg.index 0 : index + %11 = arith.cmpi slt, %10, %arg5 : index + %12 = arith.select %11, %9, %out : f64 + linalg.yield %12 : f64 + } + %7 = affine.load %alloca[] : memref + affine.store %7, %arg1[%arg5, %arg6] : memref + } + } + affine.for %arg5 = 0 to %0 { + %2 = affine.load %arg2[%arg5] : memref + affine.store %2, %alloca[] : memref + %3 = arith.subi %0, %c1 : index + %4 = polygeist.submap(%arg1, %arg5, %3) {map = #map1} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg4, %3) {map = #map} : (memref, index) -> memref + %6 = polygeist.submap(%alloca, %3) {map = #map3} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.subf %out, %8 : f64 + %10 = linalg.index 0 : index + %11 = arith.cmpi slt, %10, %arg5 : index + %12 = arith.select %11, %9, %out : f64 + linalg.yield %12 : f64 + } + %7 = affine.load %alloca[] : memref + affine.store %7, %arg4[%arg5] : memref + } + affine.for %arg5 = 0 to %0 { + %2 = affine.load %arg4[-%arg5 + symbol(%0) - 1] : memref + affine.store %2, %alloca[] : memref + %3 = polygeist.submap(%arg1, %arg5, %0, %0) {map = #map4} : (memref, index, index, index) -> memref + %4 = polygeist.submap(%arg3, %0) {map = #map} : (memref, index) -> memref + %5 = polygeist.submap(%alloca, %0) {map = #map3} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.subf %out, %9 : f64 + %11 = linalg.index 0 : index + %12 = affine.apply #map5(%arg5)[%0] + %13 = arith.cmpi sge, %11, %12 : index + %14 = arith.select %13, %10, %out : f64 + linalg.yield %14 : f64 + } + %6 = affine.load %alloca[] : memref + %7 = affine.load %arg1[-%arg5 + symbol(%0) - 1, -%arg5 + symbol(%0) - 1] : memref + %8 = arith.divf %6, %7 : f64 + affine.store %8, %arg3[-%arg5 + symbol(%0) - 1] : memref + } + return + } +} + diff --git a/polybench_results/mvt.log b/polybench_results/mvt.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/mvt.mlir b/polybench_results/mvt.mlir new file mode 100644 index 000000000000..98eb29bc1cb6 --- /dev/null +++ b/polybench_results/mvt.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_mvt(%arg0: i32, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg6 = 0 to %0 { + affine.for %arg7 = 0 to %0 { + %1 = affine.load %arg1[%arg6] : memref + %2 = affine.load %arg5[%arg6, %arg7] : memref + %3 = affine.load %arg3[%arg7] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + affine.store %5, %arg1[%arg6] : memref + } + } + affine.for %arg6 = 0 to %0 { + affine.for %arg7 = 0 to %0 { + %1 = affine.load %arg2[%arg6] : memref + %2 = affine.load %arg5[%arg7, %arg6] : memref + %3 = affine.load %arg4[%arg7] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + affine.store %5, %arg2[%arg6] : memref + } + } + return + } +} diff --git a/polybench_results/mvt_debuf.mlir b/polybench_results/mvt_debuf.mlir new file mode 100644 index 000000000000..a9475ae58dbb --- /dev/null +++ b/polybench_results/mvt_debuf.mlir @@ -0,0 +1,40 @@ +#map = affine_map<(d0, d1) -> (d1)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1, d0)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_mvt(%arg0: i32, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = bufferization.to_tensor %arg3 : memref + %3 = bufferization.to_tensor %arg2 : memref + %4 = bufferization.to_tensor %arg1 : memref + %5 = arith.index_cast %arg0 : i32 to index + %6 = polygeist.submap(%4, %5, %5) {map = #map} : (tensor, index, index) -> tensor + %7 = polygeist.submap(%2, %5, %5) {map = #map1} : (tensor, index, index) -> tensor + %8 = polygeist.submap(%0, %5, %5) {map = #map2} : (tensor, index, index) -> tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%8, %7 : tensor, tensor) outs(%6 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %18 = arith.mulf %in, %in_0 : f64 + %19 = arith.addf %out, %18 : f64 + linalg.yield %19 : f64 + } -> tensor + %10 = polygeist.submapInverse(%4, %9, %5, %5) {map = #map} : (tensor, tensor, index, index) -> tensor + %11 = bufferization.to_memref %10 : memref + memref.copy %11, %arg1 : memref to memref + %12 = polygeist.submap(%3, %5, %5) {map = #map} : (tensor, index, index) -> tensor + %13 = polygeist.submap(%1, %5, %5) {map = #map1} : (tensor, index, index) -> tensor + %14 = polygeist.submap(%0, %5, %5) {map = #map3} : (tensor, index, index) -> tensor + %15 = linalg.generic {doc = "", indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%14, %13 : tensor, tensor) outs(%12 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %18 = arith.mulf %in, %in_0 : f64 + %19 = arith.addf %out, %18 : f64 + linalg.yield %19 : f64 + } -> tensor + %16 = polygeist.submapInverse(%3, %15, %5, %5) {map = #map} : (tensor, tensor, index, index) -> tensor + %17 = bufferization.to_memref %16 : memref + memref.copy %17, %arg2 : memref to memref + return + } +} + diff --git a/polybench_results/mvt_linalg.mlir b/polybench_results/mvt_linalg.mlir new file mode 100644 index 000000000000..b5dbea360e48 --- /dev/null +++ b/polybench_results/mvt_linalg.mlir @@ -0,0 +1,29 @@ +#map = affine_map<(d0, d1) -> (d1, d0)> +#map1 = affine_map<(d0, d1) -> (d0)> +#map2 = affine_map<(d0, d1) -> (d1)> +#map3 = affine_map<(d0, d1) -> (d0, d1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_mvt(%arg0: i32, %arg1: memref, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg0 : i32 to index + %1 = polygeist.submap(%arg5, %0, %0) {map = #map} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg3, %0, %0) {map = #map1} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %0, %0) {map = #map2} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = polygeist.submap(%arg5, %0, %0) {map = #map3} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg4, %0, %0) {map = #map1} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg2, %0, %0) {map = #map2} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map3, #map3, #map3], iterator_types = ["parallel", "reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } + return + } +} + diff --git a/polybench_results/nussinov.log b/polybench_results/nussinov.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/nussinov.mlir b/polybench_results/nussinov.mlir new file mode 100644 index 000000000000..4f092f1ed3a7 --- /dev/null +++ b/polybench_results/nussinov.mlir @@ -0,0 +1,99 @@ +#map = affine_map<(d0)[s0] -> (-d0 + s0)> +#map1 = affine_map<(d0) -> (d0)> +#set = affine_set<(d0) : (d0 - 1 >= 0)> +#set1 = affine_set<(d0, d1) : (d0 - 1 >= 0, d1 - 1 >= 0)> +#set2 = affine_set<(d0, d1)[s0] : (d0 + d1 - s0 - 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_nussinov(%arg0: i32, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3_i32 = arith.constant 3 : i32 + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg3 = 0 to %0 { + affine.for %arg4 = #map(%arg3)[%0] to %0 { + affine.if #set(%arg4) { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4 - 1] : memref + %3 = arith.cmpi sge, %1, %2 : i32 + %4 = scf.if %3 -> (i32) { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %5 : i32 + } else { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4 - 1] : memref + scf.yield %5 : i32 + } + affine.store %4, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + affine.if #set(%arg3) { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0), %arg4] : memref + %3 = arith.cmpi sge, %1, %2 : i32 + %4 = scf.if %3 -> (i32) { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %5 : i32 + } else { + %5 = affine.load %arg2[-%arg3 + symbol(%0), %arg4] : memref + scf.yield %5 : i32 + } + affine.store %4, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + affine.if #set1(%arg4, %arg3) { + affine.if #set2(%arg3, %arg4)[%0] { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + %3 = affine.load %arg1[-%arg3 + symbol(%0) - 1] : memref + %4 = arith.extsi %3 : i8 to i32 + %5 = affine.load %arg1[%arg4] : memref + %6 = arith.extsi %5 : i8 to i32 + %7 = arith.addi %4, %6 : i32 + %8 = arith.cmpi eq, %7, %c3_i32 : i32 + %9 = arith.extui %8 : i1 to i32 + %10 = arith.addi %2, %9 : i32 + %11 = arith.cmpi sge, %1, %10 : i32 + %12 = scf.if %11 -> (i32) { + %13 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %13 : i32 + } else { + %13 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + %14 = affine.load %arg1[-%arg3 + symbol(%0) - 1] : memref + %15 = arith.extsi %14 : i8 to i32 + %16 = arith.addi %15, %6 : i32 + %17 = arith.cmpi eq, %16, %c3_i32 : i32 + %18 = arith.extui %17 : i1 to i32 + %19 = arith.addi %13, %18 : i32 + scf.yield %19 : i32 + } + affine.store %12, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } else { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + %3 = arith.cmpi sge, %1, %2 : i32 + %4 = scf.if %3 -> (i32) { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %5 : i32 + } else { + %5 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + scf.yield %5 : i32 + } + affine.store %4, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + } + affine.for %arg5 = #map(%arg3)[%0] to #map1(%arg4) { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg5] : memref + %3 = affine.load %arg2[%arg5 + 1, %arg4] : memref + %4 = arith.addi %2, %3 : i32 + %5 = arith.cmpi sge, %1, %4 : i32 + %6 = scf.if %5 -> (i32) { + %7 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %7 : i32 + } else { + %7 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg5] : memref + %8 = arith.addi %7, %3 : i32 + scf.yield %8 : i32 + } + affine.store %6, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + } + } + return + } +} diff --git a/polybench_results/nussinov_debuf.mlir b/polybench_results/nussinov_debuf.mlir new file mode 100644 index 000000000000..2ef5ce9a7a10 --- /dev/null +++ b/polybench_results/nussinov_debuf.mlir @@ -0,0 +1,100 @@ +#map = affine_map<(d0)[s0] -> (-d0 + s0)> +#map1 = affine_map<(d0) -> (d0)> +#set = affine_set<(d0) : (d0 - 1 >= 0)> +#set1 = affine_set<(d0, d1) : (d0 - 1 >= 0, d1 - 1 >= 0)> +#set2 = affine_set<(d0, d1)[s0] : (d0 + d1 - s0 - 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_nussinov(%arg0: i32, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3_i32 = arith.constant 3 : i32 + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg3 = 0 to %0 { + affine.for %arg4 = #map(%arg3)[%0] to %0 { + affine.if #set(%arg4) { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4 - 1] : memref + %3 = arith.cmpi sge, %1, %2 : i32 + %4 = scf.if %3 -> (i32) { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %5 : i32 + } else { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4 - 1] : memref + scf.yield %5 : i32 + } + affine.store %4, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + affine.if #set(%arg3) { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0), %arg4] : memref + %3 = arith.cmpi sge, %1, %2 : i32 + %4 = scf.if %3 -> (i32) { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %5 : i32 + } else { + %5 = affine.load %arg2[-%arg3 + symbol(%0), %arg4] : memref + scf.yield %5 : i32 + } + affine.store %4, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + affine.if #set1(%arg4, %arg3) { + affine.if #set2(%arg3, %arg4)[%0] { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + %3 = affine.load %arg1[-%arg3 + symbol(%0) - 1] : memref + %4 = arith.extsi %3 : i8 to i32 + %5 = affine.load %arg1[%arg4] : memref + %6 = arith.extsi %5 : i8 to i32 + %7 = arith.addi %4, %6 : i32 + %8 = arith.cmpi eq, %7, %c3_i32 : i32 + %9 = arith.extui %8 : i1 to i32 + %10 = arith.addi %2, %9 : i32 + %11 = arith.cmpi sge, %1, %10 : i32 + %12 = scf.if %11 -> (i32) { + %13 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %13 : i32 + } else { + %13 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + %14 = affine.load %arg1[-%arg3 + symbol(%0) - 1] : memref + %15 = arith.extsi %14 : i8 to i32 + %16 = arith.addi %15, %6 : i32 + %17 = arith.cmpi eq, %16, %c3_i32 : i32 + %18 = arith.extui %17 : i1 to i32 + %19 = arith.addi %13, %18 : i32 + scf.yield %19 : i32 + } + affine.store %12, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } else { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + %3 = arith.cmpi sge, %1, %2 : i32 + %4 = scf.if %3 -> (i32) { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %5 : i32 + } else { + %5 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + scf.yield %5 : i32 + } + affine.store %4, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + } + affine.for %arg5 = #map(%arg3)[%0] to #map1(%arg4) { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg5] : memref + %3 = affine.load %arg2[%arg5 + 1, %arg4] : memref + %4 = arith.addi %2, %3 : i32 + %5 = arith.cmpi sge, %1, %4 : i32 + %6 = scf.if %5 -> (i32) { + %7 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %7 : i32 + } else { + %7 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg5] : memref + %8 = arith.addi %7, %3 : i32 + scf.yield %8 : i32 + } + affine.store %6, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + } + } + return + } +} + diff --git a/polybench_results/nussinov_linalg.mlir b/polybench_results/nussinov_linalg.mlir new file mode 100644 index 000000000000..2ef5ce9a7a10 --- /dev/null +++ b/polybench_results/nussinov_linalg.mlir @@ -0,0 +1,100 @@ +#map = affine_map<(d0)[s0] -> (-d0 + s0)> +#map1 = affine_map<(d0) -> (d0)> +#set = affine_set<(d0) : (d0 - 1 >= 0)> +#set1 = affine_set<(d0, d1) : (d0 - 1 >= 0, d1 - 1 >= 0)> +#set2 = affine_set<(d0, d1)[s0] : (d0 + d1 - s0 - 1 >= 0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_nussinov(%arg0: i32, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c3_i32 = arith.constant 3 : i32 + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg3 = 0 to %0 { + affine.for %arg4 = #map(%arg3)[%0] to %0 { + affine.if #set(%arg4) { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4 - 1] : memref + %3 = arith.cmpi sge, %1, %2 : i32 + %4 = scf.if %3 -> (i32) { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %5 : i32 + } else { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4 - 1] : memref + scf.yield %5 : i32 + } + affine.store %4, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + affine.if #set(%arg3) { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0), %arg4] : memref + %3 = arith.cmpi sge, %1, %2 : i32 + %4 = scf.if %3 -> (i32) { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %5 : i32 + } else { + %5 = affine.load %arg2[-%arg3 + symbol(%0), %arg4] : memref + scf.yield %5 : i32 + } + affine.store %4, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + affine.if #set1(%arg4, %arg3) { + affine.if #set2(%arg3, %arg4)[%0] { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + %3 = affine.load %arg1[-%arg3 + symbol(%0) - 1] : memref + %4 = arith.extsi %3 : i8 to i32 + %5 = affine.load %arg1[%arg4] : memref + %6 = arith.extsi %5 : i8 to i32 + %7 = arith.addi %4, %6 : i32 + %8 = arith.cmpi eq, %7, %c3_i32 : i32 + %9 = arith.extui %8 : i1 to i32 + %10 = arith.addi %2, %9 : i32 + %11 = arith.cmpi sge, %1, %10 : i32 + %12 = scf.if %11 -> (i32) { + %13 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %13 : i32 + } else { + %13 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + %14 = affine.load %arg1[-%arg3 + symbol(%0) - 1] : memref + %15 = arith.extsi %14 : i8 to i32 + %16 = arith.addi %15, %6 : i32 + %17 = arith.cmpi eq, %16, %c3_i32 : i32 + %18 = arith.extui %17 : i1 to i32 + %19 = arith.addi %13, %18 : i32 + scf.yield %19 : i32 + } + affine.store %12, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } else { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + %3 = arith.cmpi sge, %1, %2 : i32 + %4 = scf.if %3 -> (i32) { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %5 : i32 + } else { + %5 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + scf.yield %5 : i32 + } + affine.store %4, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + } + affine.for %arg5 = #map(%arg3)[%0] to #map1(%arg4) { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg5] : memref + %3 = affine.load %arg2[%arg5 + 1, %arg4] : memref + %4 = arith.addi %2, %3 : i32 + %5 = arith.cmpi sge, %1, %4 : i32 + %6 = scf.if %5 -> (i32) { + %7 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %7 : i32 + } else { + %7 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg5] : memref + %8 = arith.addi %7, %3 : i32 + scf.yield %8 : i32 + } + affine.store %6, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + } + } + return + } +} + diff --git a/polybench_results/reject_logs/2mm.log b/polybench_results/reject_logs/2mm.log new file mode 100644 index 000000000000..1b1d27fe5cae --- /dev/null +++ b/polybench_results/reject_logs/2mm.log @@ -0,0 +1,3946 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg13) = (0) to (symbol(%2)) { + %6 = affine.load %arg6[%arg11, %arg13] : memref + %7 = affine.load %arg9[%arg13, %arg12] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %arg10[%arg11, %arg12] : memref + %10 = arith.addf %9, %8 : f64 + affine.store %10, %arg10[%arg11, %arg12] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg11) = (0) to (symbol(%3)) { + affine.parallel (%arg12) = (0) to (symbol(%1)) { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + affine.parallel (%arg13) = (0) to (symbol(%2)) { + %6 = affine.load %arg6[%arg11, %arg13] : memref + %7 = affine.load %arg9[%arg13, %arg12] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %arg10[%arg11, %arg12] : memref + %10 = arith.addf %9, %8 : f64 + affine.store %10, %arg10[%arg11, %arg12] : memref + } + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%1)) { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + affine.parallel (%arg13) = (0) to (symbol(%2)) { + %6 = affine.load %arg6[%arg11, %arg13] : memref + %7 = affine.load %arg9[%arg13, %arg12] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %arg10[%arg11, %arg12] : memref + %10 = arith.addf %9, %8 : f64 + affine.store %10, %arg10[%arg11, %arg12] : memref + } +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg13) = (0) to (symbol(%0)) { + %4 = affine.load %arg7[%arg11, %arg13] : memref + %5 = arith.mulf %arg4, %4 : f64 + %6 = affine.load %arg8[%arg13, %arg12] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg6[%arg11, %arg12] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg6[%arg11, %arg12] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg11) = (0) to (symbol(%3)) { + affine.parallel (%arg12) = (0) to (symbol(%2)) { + affine.store %cst, %arg6[%arg11, %arg12] : memref + affine.parallel (%arg13) = (0) to (symbol(%0)) { + %4 = affine.load %arg7[%arg11, %arg13] : memref + %5 = arith.mulf %arg4, %4 : f64 + %6 = affine.load %arg8[%arg13, %arg12] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg6[%arg11, %arg12] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg6[%arg11, %arg12] : memref + } + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%2)) { + affine.store %cst, %arg6[%arg11, %arg12] : memref + affine.parallel (%arg13) = (0) to (symbol(%0)) { + %4 = affine.load %arg7[%arg11, %arg13] : memref + %5 = arith.mulf %arg4, %4 : f64 + %6 = affine.load %arg8[%arg13, %arg12] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg6[%arg11, %arg12] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg6[%arg11, %arg12] : memref + } +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg13) = (0) to (symbol(%2)) { + %6 = affine.load %arg6[%arg11, %arg13] : memref + %7 = affine.load %arg9[%arg13, %arg12] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %arg10[%arg11, %arg12] : memref + %10 = arith.addf %9, %8 : f64 + affine.store %10, %arg10[%arg11, %arg12] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg11) = (0) to (symbol(%3)) { + affine.parallel (%arg12) = (0) to (symbol(%1)) { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + affine.for %arg13 = 0 to %2 { + %6 = affine.load %arg6[%arg11, %arg13] : memref + %7 = affine.load %arg9[%arg13, %arg12] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %arg10[%arg11, %arg12] : memref + %10 = arith.addf %9, %8 : f64 + affine.store %10, %arg10[%arg11, %arg12] : memref + } + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%1)) { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + affine.for %arg13 = 0 to %2 { + %6 = affine.load %arg6[%arg11, %arg13] : memref + %7 = affine.load %arg9[%arg13, %arg12] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %arg10[%arg11, %arg12] : memref + %10 = arith.addf %9, %8 : f64 + affine.store %10, %arg10[%arg11, %arg12] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg13) = (0) to (symbol(%0)) { + %4 = affine.load %arg7[%arg11, %arg13] : memref + %5 = arith.mulf %arg4, %4 : f64 + %6 = affine.load %arg8[%arg13, %arg12] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg6[%arg11, %arg12] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg6[%arg11, %arg12] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg11) = (0) to (symbol(%3)) { + affine.parallel (%arg12) = (0) to (symbol(%2)) { + affine.store %cst, %arg6[%arg11, %arg12] : memref + affine.for %arg13 = 0 to %0 { + %4 = affine.load %arg7[%arg11, %arg13] : memref + %5 = arith.mulf %arg4, %4 : f64 + %6 = affine.load %arg8[%arg13, %arg12] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg6[%arg11, %arg12] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg6[%arg11, %arg12] : memref + } + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%2)) { + affine.store %cst, %arg6[%arg11, %arg12] : memref + affine.for %arg13 = 0 to %0 { + %4 = affine.load %arg7[%arg11, %arg13] : memref + %5 = arith.mulf %arg4, %4 : f64 + %6 = affine.load %arg8[%arg13, %arg12] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg6[%arg11, %arg12] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg6[%arg11, %arg12] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %2 { + %6 = affine.load %arg6[%arg11, %arg13] : memref + %7 = affine.load %arg9[%arg13, %arg12] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %arg10[%arg11, %arg12] : memref + %10 = arith.addf %9, %8 : f64 + affine.store %10, %arg10[%arg11, %arg12] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %9 = affine.load %arg6[%arg11, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %11 = affine.load %arg9[%arg13, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %14 = affine.load %arg10[%arg11, %arg12] : memref + +--- Processing Stores --- +Processing store: affine.store %15, %arg10[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 1 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%9, %10 : memref, memref) outs(%11 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- +Processing load: %10 = affine.load %arg10[%arg11, %arg12] : memref + +--- Processing Stores --- +Processing store: affine.store %11, %arg10[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg12 = 0 to %1 { + %5 = affine.load %arg10[%arg11, %arg12] : memref + %6 = arith.mulf %5, %arg5 : f64 + affine.store %6, %arg10[%arg11, %arg12] : memref + %7 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %0 { + %4 = affine.load %arg7[%arg11, %arg13] : memref + %5 = arith.mulf %arg4, %4 : f64 + %6 = affine.load %arg8[%arg13, %arg12] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg6[%arg11, %arg12] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg6[%arg11, %arg12] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %7 = affine.load %arg7[%arg11, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %10 = affine.load %arg8[%arg13, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %13 = affine.load %arg6[%arg11, %arg12] : memref + +--- Processing Stores --- +Processing store: affine.store %14, %arg6[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %arg4, %in : f64 + %11 = arith.mulf %10, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg6[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%2] + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %5 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg4, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 1 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%9, %10 : memref, memref) outs(%11 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- +Processing load: %10 = affine.load %arg10[%arg11, %arg12] : memref + +--- Processing Stores --- +Processing store: affine.store %11, %arg10[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg12 = 0 to %1 { + %5 = affine.load %arg10[%arg11, %arg12] : memref + %6 = arith.mulf %5, %arg5 : f64 + affine.store %6, %arg10[%arg11, %arg12] : memref + %7 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %arg4, %in : f64 + %11 = arith.mulf %10, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg6[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%2] + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %5 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg4, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 1 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%9, %10 : memref, memref) outs(%11 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- +Processing load: %10 = affine.load %arg10[%arg11, %arg12] : memref + +--- Processing Stores --- +Processing store: affine.store %11, %arg10[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg12 = 0 to %1 { + %5 = affine.load %arg10[%arg11, %arg12] : memref + %6 = arith.mulf %5, %arg5 : f64 + affine.store %6, %arg10[%arg11, %arg12] : memref + %7 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %arg4, %in : f64 + %11 = arith.mulf %10, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg6[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%2] + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %5 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg4, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 1 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%9, %10 : memref, memref) outs(%11 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- +Processing load: %10 = affine.load %arg10[%arg11, %arg12] : memref + +--- Processing Stores --- +Processing store: affine.store %11, %arg10[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg12 = 0 to %1 { + %5 = affine.load %arg10[%arg11, %arg12] : memref + %6 = arith.mulf %5, %arg5 : f64 + affine.store %6, %arg10[%arg11, %arg12] : memref + %7 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %arg4, %in : f64 + %11 = arith.mulf %10, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg6[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%2] + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %5 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg4, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 1 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%9, %10 : memref, memref) outs(%11 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- +Processing load: %10 = affine.load %arg10[%arg11, %arg12] : memref + +--- Processing Stores --- +Processing store: affine.store %11, %arg10[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg12 = 0 to %1 { + %5 = affine.load %arg10[%arg11, %arg12] : memref + %6 = arith.mulf %5, %arg5 : f64 + affine.store %6, %arg10[%arg11, %arg12] : memref + %7 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %arg4, %in : f64 + %11 = arith.mulf %10, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg6[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%2] + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %5 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg4, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 1 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%9, %10 : memref, memref) outs(%11 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- +Processing load: %10 = affine.load %arg10[%arg11, %arg12] : memref + +--- Processing Stores --- +Processing store: affine.store %11, %arg10[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg12 = 0 to %1 { + %5 = affine.load %arg10[%arg11, %arg12] : memref + %6 = arith.mulf %5, %arg5 : f64 + affine.store %6, %arg10[%arg11, %arg12] : memref + %7 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %arg4, %in : f64 + %11 = arith.mulf %10, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg6[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%2] + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %5 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg4, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 1 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%9, %10 : memref, memref) outs(%11 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- +Processing load: %10 = affine.load %arg10[%arg11, %arg12] : memref + +--- Processing Stores --- +Processing store: affine.store %11, %arg10[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg12 = 0 to %1 { + %5 = affine.load %arg10[%arg11, %arg12] : memref + %6 = arith.mulf %5, %arg5 : f64 + affine.store %6, %arg10[%arg11, %arg12] : memref + %7 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %arg4, %in : f64 + %11 = arith.mulf %10, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg6[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%2] + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %5 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg4, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 1 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%9, %10 : memref, memref) outs(%11 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- +Processing load: %10 = affine.load %arg10[%arg11, %arg12] : memref + +--- Processing Stores --- +Processing store: affine.store %11, %arg10[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg12 = 0 to %1 { + %5 = affine.load %arg10[%arg11, %arg12] : memref + %6 = arith.mulf %5, %arg5 : f64 + affine.store %6, %arg10[%arg11, %arg12] : memref + %7 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %arg4, %in : f64 + %11 = arith.mulf %10, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg6[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%2] + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %5 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg4, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 1 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%9, %10 : memref, memref) outs(%11 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- +Processing load: %10 = affine.load %arg10[%arg11, %arg12] : memref + +--- Processing Stores --- +Processing store: affine.store %11, %arg10[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg12 = 0 to %1 { + %5 = affine.load %arg10[%arg11, %arg12] : memref + %6 = arith.mulf %5, %arg5 : f64 + affine.store %6, %arg10[%arg11, %arg12] : memref + %7 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %arg4, %in : f64 + %11 = arith.mulf %10, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg6[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%2] + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %5 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg4, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 1 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%9, %10 : memref, memref) outs(%11 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- +Processing load: %10 = affine.load %arg10[%arg11, %arg12] : memref + +--- Processing Stores --- +Processing store: affine.store %11, %arg10[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg12 = 0 to %1 { + %5 = affine.load %arg10[%arg11, %arg12] : memref + %6 = arith.mulf %5, %arg5 : f64 + affine.store %6, %arg10[%arg11, %arg12] : memref + %7 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %arg4, %in : f64 + %11 = arith.mulf %10, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg6[%arg11, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg11 = 0 to %3 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%2] + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %5 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg4, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + +WARNING: AffineForOpRaising didn't converge +2mm.mlir:2:3: warning: AffineForOpRaising didn't converge, continuing anyway + func.func @kernel_2mm(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32, %arg4: f64, %arg5: f64, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +2mm.mlir:2:3: note: see current operation: +func.func @kernel_2mm(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32, %arg4: f64, %arg5: f64, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg2 : i32 to index + %1 = arith.index_cast %arg3 : i32 to index + %2 = arith.index_cast %arg1 : i32 to index + %3 = arith.index_cast %arg0 : i32 to index + affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %2 { + affine.store %cst, %arg6[%arg11, %arg12] : memref + %4 = polygeist.submap(%arg7, %arg11, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg8, %arg12, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg11, %arg12, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg4, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + } + affine.for %arg11 = 0 to %3 { + affine.for %arg12 = 0 to %1 { + %4 = affine.load %arg10[%arg11, %arg12] : memref + %5 = arith.mulf %4, %arg5 : f64 + affine.store %5, %arg10[%arg11, %arg12] : memref + %6 = polygeist.submap(%arg6, %arg11, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %arg11, %arg12, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + } + return +} +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/3mm.log b/polybench_results/reject_logs/3mm.log new file mode 100644 index 000000000000..c718399f4da4 --- /dev/null +++ b/polybench_results/reject_logs/3mm.log @@ -0,0 +1,5707 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg14) = (0) to (symbol(%0)) { + %5 = affine.load %arg5[%arg12, %arg14] : memref + %6 = affine.load %arg8[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg11[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg11[%arg12, %arg13] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%4)) { + affine.parallel (%arg13) = (0) to (symbol(%3)) { + affine.store %cst, %arg11[%arg12, %arg13] : memref + affine.parallel (%arg14) = (0) to (symbol(%0)) { + %5 = affine.load %arg5[%arg12, %arg14] : memref + %6 = affine.load %arg8[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg11[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg11[%arg12, %arg13] : memref + } + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg13) = (0) to (symbol(%3)) { + affine.store %cst, %arg11[%arg12, %arg13] : memref + affine.parallel (%arg14) = (0) to (symbol(%0)) { + %5 = affine.load %arg5[%arg12, %arg14] : memref + %6 = affine.load %arg8[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg11[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg11[%arg12, %arg13] : memref + } +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg14) = (0) to (symbol(%2)) { + %5 = affine.load %arg9[%arg12, %arg14] : memref + %6 = affine.load %arg10[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg8[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg8[%arg12, %arg13] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%0)) { + affine.parallel (%arg13) = (0) to (symbol(%3)) { + affine.store %cst, %arg8[%arg12, %arg13] : memref + affine.parallel (%arg14) = (0) to (symbol(%2)) { + %5 = affine.load %arg9[%arg12, %arg14] : memref + %6 = affine.load %arg10[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg8[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg8[%arg12, %arg13] : memref + } + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg13) = (0) to (symbol(%3)) { + affine.store %cst, %arg8[%arg12, %arg13] : memref + affine.parallel (%arg14) = (0) to (symbol(%2)) { + %5 = affine.load %arg9[%arg12, %arg14] : memref + %6 = affine.load %arg10[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg8[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg8[%arg12, %arg13] : memref + } +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg14) = (0) to (symbol(%1)) { + %5 = affine.load %arg6[%arg12, %arg14] : memref + %6 = affine.load %arg7[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg5[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg5[%arg12, %arg13] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%4)) { + affine.parallel (%arg13) = (0) to (symbol(%0)) { + affine.store %cst, %arg5[%arg12, %arg13] : memref + affine.parallel (%arg14) = (0) to (symbol(%1)) { + %5 = affine.load %arg6[%arg12, %arg14] : memref + %6 = affine.load %arg7[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg5[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg5[%arg12, %arg13] : memref + } + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg13) = (0) to (symbol(%0)) { + affine.store %cst, %arg5[%arg12, %arg13] : memref + affine.parallel (%arg14) = (0) to (symbol(%1)) { + %5 = affine.load %arg6[%arg12, %arg14] : memref + %6 = affine.load %arg7[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg5[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg5[%arg12, %arg13] : memref + } +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg14) = (0) to (symbol(%0)) { + %5 = affine.load %arg5[%arg12, %arg14] : memref + %6 = affine.load %arg8[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg11[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg11[%arg12, %arg13] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%4)) { + affine.parallel (%arg13) = (0) to (symbol(%3)) { + affine.store %cst, %arg11[%arg12, %arg13] : memref + affine.for %arg14 = 0 to %0 { + %5 = affine.load %arg5[%arg12, %arg14] : memref + %6 = affine.load %arg8[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg11[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg11[%arg12, %arg13] : memref + } + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg13) = (0) to (symbol(%3)) { + affine.store %cst, %arg11[%arg12, %arg13] : memref + affine.for %arg14 = 0 to %0 { + %5 = affine.load %arg5[%arg12, %arg14] : memref + %6 = affine.load %arg8[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg11[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg11[%arg12, %arg13] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg14) = (0) to (symbol(%2)) { + %5 = affine.load %arg9[%arg12, %arg14] : memref + %6 = affine.load %arg10[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg8[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg8[%arg12, %arg13] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%0)) { + affine.parallel (%arg13) = (0) to (symbol(%3)) { + affine.store %cst, %arg8[%arg12, %arg13] : memref + affine.for %arg14 = 0 to %2 { + %5 = affine.load %arg9[%arg12, %arg14] : memref + %6 = affine.load %arg10[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg8[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg8[%arg12, %arg13] : memref + } + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg13) = (0) to (symbol(%3)) { + affine.store %cst, %arg8[%arg12, %arg13] : memref + affine.for %arg14 = 0 to %2 { + %5 = affine.load %arg9[%arg12, %arg14] : memref + %6 = affine.load %arg10[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg8[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg8[%arg12, %arg13] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg14) = (0) to (symbol(%1)) { + %5 = affine.load %arg6[%arg12, %arg14] : memref + %6 = affine.load %arg7[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg5[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg5[%arg12, %arg13] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%4)) { + affine.parallel (%arg13) = (0) to (symbol(%0)) { + affine.store %cst, %arg5[%arg12, %arg13] : memref + affine.for %arg14 = 0 to %1 { + %5 = affine.load %arg6[%arg12, %arg14] : memref + %6 = affine.load %arg7[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg5[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg5[%arg12, %arg13] : memref + } + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg13) = (0) to (symbol(%0)) { + affine.store %cst, %arg5[%arg12, %arg13] : memref + affine.for %arg14 = 0 to %1 { + %5 = affine.load %arg6[%arg12, %arg14] : memref + %6 = affine.load %arg7[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg5[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg5[%arg12, %arg13] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg14 = 0 to %0 { + %5 = affine.load %arg5[%arg12, %arg14] : memref + %6 = affine.load %arg8[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg11[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg11[%arg12, %arg13] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %8 = affine.load %arg5[%arg12, %arg14] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %10 = affine.load %arg8[%arg14, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %13 = affine.load %arg11[%arg12, %arg13] : memref + +--- Processing Stores --- +Processing store: affine.store %14, %arg11[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg11[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg14 = 0 to %2 { + %5 = affine.load %arg9[%arg12, %arg14] : memref + %6 = affine.load %arg10[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg8[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg8[%arg12, %arg13] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %8 = affine.load %arg9[%arg12, %arg14] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %10 = affine.load %arg10[%arg14, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %13 = affine.load %arg8[%arg12, %arg13] : memref + +--- Processing Stores --- +Processing store: affine.store %14, %arg8[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg8[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg14 = 0 to %1 { + %5 = affine.load %arg6[%arg12, %arg14] : memref + %6 = affine.load %arg7[%arg14, %arg13] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg5[%arg12, %arg13] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg5[%arg12, %arg13] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %8 = affine.load %arg6[%arg12, %arg14] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %10 = affine.load %arg7[%arg14, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %13 = affine.load %arg5[%arg12, %arg13] : memref + +--- Processing Stores --- +Processing store: affine.store %14, %arg5[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg11[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg8[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg11[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg8[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg11[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg8[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg11[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg8[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg11[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg8[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg11[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg8[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg11[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg8[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg11[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg8[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg11[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg8[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%3] + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %4 { + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %6 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + +WARNING: AffineForOpRaising didn't converge +3mm.mlir:2:3: warning: AffineForOpRaising didn't converge, continuing anyway + func.func @kernel_3mm(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32, %arg4: i32, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref, %arg11: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +3mm.mlir:2:3: note: see current operation: +func.func @kernel_3mm(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32, %arg4: i32, %arg5: memref, %arg6: memref, %arg7: memref, %arg8: memref, %arg9: memref, %arg10: memref, %arg11: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg2 : i32 to index + %2 = arith.index_cast %arg4 : i32 to index + %3 = arith.index_cast %arg3 : i32 to index + %4 = arith.index_cast %arg0 : i32 to index + affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %0 { + affine.store %cst, %arg5[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg6, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg7, %arg13, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg12, %arg13, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + } + affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg8[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg9, %arg12, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg10, %arg13, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg8, %arg12, %arg13, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + } + affine.for %arg12 = 0 to %4 { + affine.for %arg13 = 0 to %3 { + affine.store %cst, %arg11[%arg12, %arg13] : memref + %5 = polygeist.submap(%arg5, %arg12, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg8, %arg13, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg11, %arg12, %arg13, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + } + return +} +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/adi.log b/polybench_results/reject_logs/adi.log new file mode 100644 index 000000000000..90909a781f3c --- /dev/null +++ b/polybench_results/reject_logs/adi.log @@ -0,0 +1,1011 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (1) to (symbol(%0) - 1) { + %23 = affine.load %arg4[%arg7, -%arg8 + symbol(%0) - 1] : memref + %24 = affine.load %arg2[%arg7, -%arg8 + symbol(%0)] : memref + %25 = arith.mulf %23, %24 : f64 + %26 = affine.load %arg5[%arg7, -%arg8 + symbol(%0) - 1] : memref + %27 = arith.addf %25, %26 : f64 + affine.store %27, %arg2[%arg7, -%arg8 + symbol(%0) - 1] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (1) to (symbol(%0) - 1) { + %23 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %24 = arith.mulf %13, %23 : f64 + %25 = arith.addf %24, %14 : f64 + %26 = arith.divf %17, %25 : f64 + affine.store %26, %arg4[%arg7, %arg8] : memref + %27 = affine.load %arg3[%arg7 - 1, %arg8] : memref + %28 = arith.mulf %16, %27 : f64 + %29 = affine.load %arg3[%arg7, %arg8] : memref + %30 = arith.mulf %21, %29 : f64 + %31 = arith.addf %28, %30 : f64 + %32 = affine.load %arg3[%arg7 + 1, %arg8] : memref + %33 = arith.mulf %10, %32 : f64 + %34 = arith.subf %31, %33 : f64 + %35 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %36 = arith.mulf %13, %35 : f64 + %37 = arith.subf %34, %36 : f64 + %38 = arith.divf %37, %25 : f64 + affine.store %38, %arg5[%arg7, %arg8] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (1) to (symbol(%0) - 1) { + affine.store %cst, %arg2[%arg7, 0] : memref + affine.store %cst_1, %arg4[%arg7, 0] : memref + %22 = affine.load %arg2[%arg7, 0] : memref + affine.store %22, %arg5[%arg7, 0] : memref + affine.parallel (%arg8) = (1) to (symbol(%0) - 1) { + %23 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %24 = arith.mulf %13, %23 : f64 + %25 = arith.addf %24, %14 : f64 + %26 = arith.divf %17, %25 : f64 + affine.store %26, %arg4[%arg7, %arg8] : memref + %27 = affine.load %arg3[%arg7 - 1, %arg8] : memref + %28 = arith.mulf %16, %27 : f64 + %29 = affine.load %arg3[%arg7, %arg8] : memref + %30 = arith.mulf %21, %29 : f64 + %31 = arith.addf %28, %30 : f64 + %32 = affine.load %arg3[%arg7 + 1, %arg8] : memref + %33 = arith.mulf %10, %32 : f64 + %34 = arith.subf %31, %33 : f64 + %35 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %36 = arith.mulf %13, %35 : f64 + %37 = arith.subf %34, %36 : f64 + %38 = arith.divf %37, %25 : f64 + affine.store %38, %arg5[%arg7, %arg8] : memref + } + affine.store %cst, %arg2[%arg7, symbol(%0) - 1] : memref + affine.parallel (%arg8) = (1) to (symbol(%0) - 1) { + %23 = affine.load %arg4[%arg7, -%arg8 + symbol(%0) - 1] : memref + %24 = affine.load %arg2[%arg7, -%arg8 + symbol(%0)] : memref + %25 = arith.mulf %23, %24 : f64 + %26 = affine.load %arg5[%arg7, -%arg8 + symbol(%0) - 1] : memref + %27 = arith.addf %25, %26 : f64 + affine.store %27, %arg2[%arg7, -%arg8 + symbol(%0) - 1] : memref + } +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (1) to (symbol(%0) - 1) { + %23 = affine.load %arg4[%arg7, -%arg8 + symbol(%0) - 1] : memref + %24 = affine.load %arg3[-%arg8 + symbol(%0), %arg7] : memref + %25 = arith.mulf %23, %24 : f64 + %26 = affine.load %arg5[%arg7, -%arg8 + symbol(%0) - 1] : memref + %27 = arith.addf %25, %26 : f64 + affine.store %27, %arg3[-%arg8 + symbol(%0) - 1, %arg7] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (1) to (symbol(%0) - 1) { + %23 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %24 = arith.mulf %10, %23 : f64 + %25 = arith.addf %24, %11 : f64 + %26 = arith.divf %16, %25 : f64 + affine.store %26, %arg4[%arg7, %arg8] : memref + %27 = affine.load %arg2[%arg8, %arg7 - 1] : memref + %28 = arith.mulf %17, %27 : f64 + %29 = affine.load %arg2[%arg8, %arg7] : memref + %30 = arith.mulf %19, %29 : f64 + %31 = arith.addf %28, %30 : f64 + %32 = affine.load %arg2[%arg8, %arg7 + 1] : memref + %33 = arith.mulf %13, %32 : f64 + %34 = arith.subf %31, %33 : f64 + %35 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %36 = arith.mulf %10, %35 : f64 + %37 = arith.subf %34, %36 : f64 + %38 = arith.divf %37, %25 : f64 + affine.store %38, %arg5[%arg7, %arg8] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (1) to (symbol(%0) - 1) { + affine.store %cst, %arg3[0, %arg7] : memref + affine.store %cst_1, %arg4[%arg7, 0] : memref + %22 = affine.load %arg3[0, %arg7] : memref + affine.store %22, %arg5[%arg7, 0] : memref + affine.parallel (%arg8) = (1) to (symbol(%0) - 1) { + %23 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %24 = arith.mulf %10, %23 : f64 + %25 = arith.addf %24, %11 : f64 + %26 = arith.divf %16, %25 : f64 + affine.store %26, %arg4[%arg7, %arg8] : memref + %27 = affine.load %arg2[%arg8, %arg7 - 1] : memref + %28 = arith.mulf %17, %27 : f64 + %29 = affine.load %arg2[%arg8, %arg7] : memref + %30 = arith.mulf %19, %29 : f64 + %31 = arith.addf %28, %30 : f64 + %32 = affine.load %arg2[%arg8, %arg7 + 1] : memref + %33 = arith.mulf %13, %32 : f64 + %34 = arith.subf %31, %33 : f64 + %35 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %36 = arith.mulf %10, %35 : f64 + %37 = arith.subf %34, %36 : f64 + %38 = arith.divf %37, %25 : f64 + affine.store %38, %arg5[%arg7, %arg8] : memref + } + affine.store %cst, %arg3[symbol(%0) - 1, %arg7] : memref + affine.parallel (%arg8) = (1) to (symbol(%0) - 1) { + %23 = affine.load %arg4[%arg7, -%arg8 + symbol(%0) - 1] : memref + %24 = affine.load %arg3[-%arg8 + symbol(%0), %arg7] : memref + %25 = arith.mulf %23, %24 : f64 + %26 = affine.load %arg5[%arg7, -%arg8 + symbol(%0) - 1] : memref + %27 = arith.addf %25, %26 : f64 + affine.store %27, %arg3[-%arg8 + symbol(%0) - 1, %arg7] : memref + } +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (1) to (symbol(%0) - 1) { + %23 = affine.load %arg4[%arg7, -%arg8 + symbol(%0) - 1] : memref + %24 = affine.load %arg2[%arg7, -%arg8 + symbol(%0)] : memref + %25 = arith.mulf %23, %24 : f64 + %26 = affine.load %arg5[%arg7, -%arg8 + symbol(%0) - 1] : memref + %27 = arith.addf %25, %26 : f64 + affine.store %27, %arg2[%arg7, -%arg8 + symbol(%0) - 1] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (1) to (symbol(%0) - 1) { + %23 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %24 = arith.mulf %13, %23 : f64 + %25 = arith.addf %24, %14 : f64 + %26 = arith.divf %17, %25 : f64 + affine.store %26, %arg4[%arg7, %arg8] : memref + %27 = affine.load %arg3[%arg7 - 1, %arg8] : memref + %28 = arith.mulf %16, %27 : f64 + %29 = affine.load %arg3[%arg7, %arg8] : memref + %30 = arith.mulf %21, %29 : f64 + %31 = arith.addf %28, %30 : f64 + %32 = affine.load %arg3[%arg7 + 1, %arg8] : memref + %33 = arith.mulf %10, %32 : f64 + %34 = arith.subf %31, %33 : f64 + %35 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %36 = arith.mulf %13, %35 : f64 + %37 = arith.subf %34, %36 : f64 + %38 = arith.divf %37, %25 : f64 + affine.store %38, %arg5[%arg7, %arg8] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (1) to (symbol(%0) - 1) { + affine.store %cst, %arg2[%arg7, 0] : memref + affine.store %cst_1, %arg4[%arg7, 0] : memref + %22 = affine.load %arg2[%arg7, 0] : memref + affine.store %22, %arg5[%arg7, 0] : memref + affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %23 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %24 = arith.mulf %13, %23 : f64 + %25 = arith.addf %24, %14 : f64 + %26 = arith.divf %17, %25 : f64 + affine.store %26, %arg4[%arg7, %arg8] : memref + %27 = affine.load %arg3[%arg7 - 1, %arg8] : memref + %28 = arith.mulf %16, %27 : f64 + %29 = affine.load %arg3[%arg7, %arg8] : memref + %30 = arith.mulf %21, %29 : f64 + %31 = arith.addf %28, %30 : f64 + %32 = affine.load %arg3[%arg7 + 1, %arg8] : memref + %33 = arith.mulf %10, %32 : f64 + %34 = arith.subf %31, %33 : f64 + %35 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %36 = arith.mulf %13, %35 : f64 + %37 = arith.subf %34, %36 : f64 + %38 = arith.divf %37, %25 : f64 + affine.store %38, %arg5[%arg7, %arg8] : memref + } + affine.store %cst, %arg2[%arg7, symbol(%0) - 1] : memref + affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %23 = affine.load %arg4[%arg7, -%arg8 + symbol(%0) - 1] : memref + %24 = affine.load %arg2[%arg7, -%arg8 + symbol(%0)] : memref + %25 = arith.mulf %23, %24 : f64 + %26 = affine.load %arg5[%arg7, -%arg8 + symbol(%0) - 1] : memref + %27 = arith.addf %25, %26 : f64 + affine.store %27, %arg2[%arg7, -%arg8 + symbol(%0) - 1] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (1) to (symbol(%0) - 1) { + %23 = affine.load %arg4[%arg7, -%arg8 + symbol(%0) - 1] : memref + %24 = affine.load %arg3[-%arg8 + symbol(%0), %arg7] : memref + %25 = arith.mulf %23, %24 : f64 + %26 = affine.load %arg5[%arg7, -%arg8 + symbol(%0) - 1] : memref + %27 = arith.addf %25, %26 : f64 + affine.store %27, %arg3[-%arg8 + symbol(%0) - 1, %arg7] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (1) to (symbol(%0) - 1) { + %23 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %24 = arith.mulf %10, %23 : f64 + %25 = arith.addf %24, %11 : f64 + %26 = arith.divf %16, %25 : f64 + affine.store %26, %arg4[%arg7, %arg8] : memref + %27 = affine.load %arg2[%arg8, %arg7 - 1] : memref + %28 = arith.mulf %17, %27 : f64 + %29 = affine.load %arg2[%arg8, %arg7] : memref + %30 = arith.mulf %19, %29 : f64 + %31 = arith.addf %28, %30 : f64 + %32 = affine.load %arg2[%arg8, %arg7 + 1] : memref + %33 = arith.mulf %13, %32 : f64 + %34 = arith.subf %31, %33 : f64 + %35 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %36 = arith.mulf %10, %35 : f64 + %37 = arith.subf %34, %36 : f64 + %38 = arith.divf %37, %25 : f64 + affine.store %38, %arg5[%arg7, %arg8] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (1) to (symbol(%0) - 1) { + affine.store %cst, %arg3[0, %arg7] : memref + affine.store %cst_1, %arg4[%arg7, 0] : memref + %22 = affine.load %arg3[0, %arg7] : memref + affine.store %22, %arg5[%arg7, 0] : memref + affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %23 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %24 = arith.mulf %10, %23 : f64 + %25 = arith.addf %24, %11 : f64 + %26 = arith.divf %16, %25 : f64 + affine.store %26, %arg4[%arg7, %arg8] : memref + %27 = affine.load %arg2[%arg8, %arg7 - 1] : memref + %28 = arith.mulf %17, %27 : f64 + %29 = affine.load %arg2[%arg8, %arg7] : memref + %30 = arith.mulf %19, %29 : f64 + %31 = arith.addf %28, %30 : f64 + %32 = affine.load %arg2[%arg8, %arg7 + 1] : memref + %33 = arith.mulf %13, %32 : f64 + %34 = arith.subf %31, %33 : f64 + %35 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %36 = arith.mulf %10, %35 : f64 + %37 = arith.subf %34, %36 : f64 + %38 = arith.divf %37, %25 : f64 + affine.store %38, %arg5[%arg7, %arg8] : memref + } + affine.store %cst, %arg3[symbol(%0) - 1, %arg7] : memref + affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %23 = affine.load %arg4[%arg7, -%arg8 + symbol(%0) - 1] : memref + %24 = affine.load %arg3[-%arg8 + symbol(%0), %arg7] : memref + %25 = arith.mulf %23, %24 : f64 + %26 = affine.load %arg5[%arg7, -%arg8 + symbol(%0) - 1] : memref + %27 = arith.addf %25, %26 : f64 + affine.store %27, %arg3[-%arg8 + symbol(%0) - 1, %arg7] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %23 = affine.load %arg4[%arg7, -%arg8 + symbol(%0) - 1] : memref + %24 = affine.load %arg2[%arg7, -%arg8 + symbol(%0)] : memref + %25 = arith.mulf %23, %24 : f64 + %26 = affine.load %arg5[%arg7, -%arg8 + symbol(%0) - 1] : memref + %27 = arith.addf %25, %26 : f64 + affine.store %27, %arg2[%arg7, -%arg8 + symbol(%0) - 1] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %26 = affine.load %arg4[%arg7, -%arg8 + symbol(%0) - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (d0, -d1 + s0 - 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %28 = affine.load %arg2[%arg7, -%arg8 + symbol(%0)] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (d0, -d1 + s0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, -(d0 + 1) + s1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %31 = affine.load %arg5[%arg7, -%arg8 + symbol(%0) - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (d0, -d1 + s0 - 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %33, %arg2[%arg7, -%arg8 + symbol(%0) - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (d0, -d1 + s0 - 1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 3 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %29 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %30 = arith.mulf %13, %29 : f64 + %31 = arith.addf %30, %14 : f64 + %32 = arith.divf %17, %31 : f64 + affine.store %32, %arg4[%arg7, %arg8] : memref + %33 = affine.load %arg3[%arg7 - 1, %arg8] : memref + %34 = arith.mulf %16, %33 : f64 + %35 = affine.load %arg3[%arg7, %arg8] : memref + %36 = arith.mulf %21, %35 : f64 + %37 = arith.addf %34, %36 : f64 + %38 = affine.load %arg3[%arg7 + 1, %arg8] : memref + %39 = arith.mulf %10, %38 : f64 + %40 = arith.subf %37, %39 : f64 + %41 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %42 = arith.mulf %13, %41 : f64 + %43 = arith.subf %40, %42 : f64 + %44 = arith.divf %43, %31 : f64 + affine.store %44, %arg5[%arg7, %arg8] : memref +} + +Pattern recognition complete: + Loads: 5 + Stores: 2 + LinalgGenerics: 0 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.store %cst, %arg2[%arg7, 0] : memref + affine.store %cst_1, %arg4[%arg7, 0] : memref + %22 = affine.load %arg2[%arg7, 0] : memref + affine.store %22, %arg5[%arg7, 0] : memref + affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %29 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %30 = arith.mulf %13, %29 : f64 + %31 = arith.addf %30, %14 : f64 + %32 = arith.divf %17, %31 : f64 + affine.store %32, %arg4[%arg7, %arg8] : memref + %33 = affine.load %arg3[%arg7 - 1, %arg8] : memref + %34 = arith.mulf %16, %33 : f64 + %35 = affine.load %arg3[%arg7, %arg8] : memref + %36 = arith.mulf %21, %35 : f64 + %37 = arith.addf %34, %36 : f64 + %38 = affine.load %arg3[%arg7 + 1, %arg8] : memref + %39 = arith.mulf %10, %38 : f64 + %40 = arith.subf %37, %39 : f64 + %41 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %42 = arith.mulf %13, %41 : f64 + %43 = arith.subf %40, %42 : f64 + %44 = arith.divf %43, %31 : f64 + affine.store %44, %arg5[%arg7, %arg8] : memref + } + affine.store %cst, %arg2[%arg7, symbol(%0) - 1] : memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = polygeist.submap(%arg4, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + %26 = polygeist.submap(%arg2, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1)>} : (memref, index, index, index) -> memref + %27 = polygeist.submap(%arg5, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + %28 = polygeist.submap(%arg2, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { + ^bb0(%in: f64, %in_2: f64, %in_3: f64, %out: f64): + %29 = arith.mulf %in, %in_2 : f64 + %30 = arith.addf %29, %in_3 : f64 + linalg.yield %30 : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %23 = affine.load %arg4[%arg7, -%arg8 + symbol(%0) - 1] : memref + %24 = affine.load %arg3[-%arg8 + symbol(%0), %arg7] : memref + %25 = arith.mulf %23, %24 : f64 + %26 = affine.load %arg5[%arg7, -%arg8 + symbol(%0) - 1] : memref + %27 = arith.addf %25, %26 : f64 + affine.store %27, %arg3[-%arg8 + symbol(%0) - 1, %arg7] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %26 = affine.load %arg4[%arg7, -%arg8 + symbol(%0) - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (d0, -d1 + s0 - 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %28 = affine.load %arg3[-%arg8 + symbol(%0), %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (-d0 + s0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (-(d0 + 1) + s1, s0) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %31 = affine.load %arg5[%arg7, -%arg8 + symbol(%0) - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (d0, -d1 + s0 - 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %33, %arg3[-%arg8 + symbol(%0) - 1, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (-d0 + s0 - 1, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (-(d0 + 1) + s1 - 1, s0) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 3 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %29 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %30 = arith.mulf %10, %29 : f64 + %31 = arith.addf %30, %11 : f64 + %32 = arith.divf %16, %31 : f64 + affine.store %32, %arg4[%arg7, %arg8] : memref + %33 = affine.load %arg2[%arg8, %arg7 - 1] : memref + %34 = arith.mulf %17, %33 : f64 + %35 = affine.load %arg2[%arg8, %arg7] : memref + %36 = arith.mulf %19, %35 : f64 + %37 = arith.addf %34, %36 : f64 + %38 = affine.load %arg2[%arg8, %arg7 + 1] : memref + %39 = arith.mulf %13, %38 : f64 + %40 = arith.subf %37, %39 : f64 + %41 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %42 = arith.mulf %10, %41 : f64 + %43 = arith.subf %40, %42 : f64 + %44 = arith.divf %43, %31 : f64 + affine.store %44, %arg5[%arg7, %arg8] : memref +} + +Pattern recognition complete: + Loads: 5 + Stores: 2 + LinalgGenerics: 0 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 + 1)>()[%15] { + affine.for %arg7 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.store %cst, %arg3[0, %arg7] : memref + affine.store %cst_1, %arg4[%arg7, 0] : memref + %22 = affine.load %arg3[0, %arg7] : memref + affine.store %22, %arg5[%arg7, 0] : memref + affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %29 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %30 = arith.mulf %10, %29 : f64 + %31 = arith.addf %30, %11 : f64 + %32 = arith.divf %16, %31 : f64 + affine.store %32, %arg4[%arg7, %arg8] : memref + %33 = affine.load %arg2[%arg8, %arg7 - 1] : memref + %34 = arith.mulf %17, %33 : f64 + %35 = affine.load %arg2[%arg8, %arg7] : memref + %36 = arith.mulf %19, %35 : f64 + %37 = arith.addf %34, %36 : f64 + %38 = affine.load %arg2[%arg8, %arg7 + 1] : memref + %39 = arith.mulf %13, %38 : f64 + %40 = arith.subf %37, %39 : f64 + %41 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %42 = arith.mulf %10, %41 : f64 + %43 = arith.subf %40, %42 : f64 + %44 = arith.divf %43, %31 : f64 + affine.store %44, %arg5[%arg7, %arg8] : memref + } + affine.store %cst, %arg3[symbol(%0) - 1, %arg7] : memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = polygeist.submap(%arg4, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + %26 = polygeist.submap(%arg3, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (-(d0 + 1) + s1, s0)>} : (memref, index, index, index) -> memref + %27 = polygeist.submap(%arg5, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + %28 = polygeist.submap(%arg3, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (-(d0 + 1) + s1 - 1, s0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { + ^bb0(%in: f64, %in_2: f64, %in_3: f64, %out: f64): + %29 = arith.mulf %in, %in_2 : f64 + %30 = arith.addf %29, %in_3 : f64 + linalg.yield %30 : f64 + } + } + affine.for %arg7 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.store %cst, %arg2[%arg7, 0] : memref + affine.store %cst_1, %arg4[%arg7, 0] : memref + %22 = affine.load %arg2[%arg7, 0] : memref + affine.store %22, %arg5[%arg7, 0] : memref + affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %29 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %30 = arith.mulf %13, %29 : f64 + %31 = arith.addf %30, %14 : f64 + %32 = arith.divf %17, %31 : f64 + affine.store %32, %arg4[%arg7, %arg8] : memref + %33 = affine.load %arg3[%arg7 - 1, %arg8] : memref + %34 = arith.mulf %16, %33 : f64 + %35 = affine.load %arg3[%arg7, %arg8] : memref + %36 = arith.mulf %21, %35 : f64 + %37 = arith.addf %34, %36 : f64 + %38 = affine.load %arg3[%arg7 + 1, %arg8] : memref + %39 = arith.mulf %10, %38 : f64 + %40 = arith.subf %37, %39 : f64 + %41 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %42 = arith.mulf %13, %41 : f64 + %43 = arith.subf %40, %42 : f64 + %44 = arith.divf %43, %31 : f64 + affine.store %44, %arg5[%arg7, %arg8] : memref + } + affine.store %cst, %arg2[%arg7, symbol(%0) - 1] : memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = polygeist.submap(%arg4, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + %26 = polygeist.submap(%arg2, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1)>} : (memref, index, index, index) -> memref + %27 = polygeist.submap(%arg5, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + %28 = polygeist.submap(%arg2, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { + ^bb0(%in: f64, %in_2: f64, %in_3: f64, %out: f64): + %29 = arith.mulf %in, %in_2 : f64 + %30 = arith.addf %29, %in_3 : f64 + linalg.yield %30 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.store %cst, %arg3[0, %arg7] : memref + affine.store %cst_1, %arg4[%arg7, 0] : memref + %22 = affine.load %arg3[0, %arg7] : memref + affine.store %22, %arg5[%arg7, 0] : memref + affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %29 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %30 = arith.mulf %10, %29 : f64 + %31 = arith.addf %30, %11 : f64 + %32 = arith.divf %16, %31 : f64 + affine.store %32, %arg4[%arg7, %arg8] : memref + %33 = affine.load %arg2[%arg8, %arg7 - 1] : memref + %34 = arith.mulf %17, %33 : f64 + %35 = affine.load %arg2[%arg8, %arg7] : memref + %36 = arith.mulf %19, %35 : f64 + %37 = arith.addf %34, %36 : f64 + %38 = affine.load %arg2[%arg8, %arg7 + 1] : memref + %39 = arith.mulf %13, %38 : f64 + %40 = arith.subf %37, %39 : f64 + %41 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %42 = arith.mulf %10, %41 : f64 + %43 = arith.subf %40, %42 : f64 + %44 = arith.divf %43, %31 : f64 + affine.store %44, %arg5[%arg7, %arg8] : memref + } + affine.store %cst, %arg3[symbol(%0) - 1, %arg7] : memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = polygeist.submap(%arg4, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + %26 = polygeist.submap(%arg3, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (-(d0 + 1) + s1, s0)>} : (memref, index, index, index) -> memref + %27 = polygeist.submap(%arg5, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + %28 = polygeist.submap(%arg3, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (-(d0 + 1) + s1 - 1, s0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { + ^bb0(%in: f64, %in_2: f64, %in_3: f64, %out: f64): + %29 = arith.mulf %in, %in_2 : f64 + %30 = arith.addf %29, %in_3 : f64 + linalg.yield %30 : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %29 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %30 = arith.mulf %13, %29 : f64 + %31 = arith.addf %30, %14 : f64 + %32 = arith.divf %17, %31 : f64 + affine.store %32, %arg4[%arg7, %arg8] : memref + %33 = affine.load %arg3[%arg7 - 1, %arg8] : memref + %34 = arith.mulf %16, %33 : f64 + %35 = affine.load %arg3[%arg7, %arg8] : memref + %36 = arith.mulf %21, %35 : f64 + %37 = arith.addf %34, %36 : f64 + %38 = affine.load %arg3[%arg7 + 1, %arg8] : memref + %39 = arith.mulf %10, %38 : f64 + %40 = arith.subf %37, %39 : f64 + %41 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %42 = arith.mulf %13, %41 : f64 + %43 = arith.subf %40, %42 : f64 + %44 = arith.divf %43, %31 : f64 + affine.store %44, %arg5[%arg7, %arg8] : memref +} + +Pattern recognition complete: + Loads: 5 + Stores: 2 + LinalgGenerics: 0 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.store %cst, %arg2[%arg7, 0] : memref + affine.store %cst_1, %arg4[%arg7, 0] : memref + %22 = affine.load %arg2[%arg7, 0] : memref + affine.store %22, %arg5[%arg7, 0] : memref + affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %29 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %30 = arith.mulf %13, %29 : f64 + %31 = arith.addf %30, %14 : f64 + %32 = arith.divf %17, %31 : f64 + affine.store %32, %arg4[%arg7, %arg8] : memref + %33 = affine.load %arg3[%arg7 - 1, %arg8] : memref + %34 = arith.mulf %16, %33 : f64 + %35 = affine.load %arg3[%arg7, %arg8] : memref + %36 = arith.mulf %21, %35 : f64 + %37 = arith.addf %34, %36 : f64 + %38 = affine.load %arg3[%arg7 + 1, %arg8] : memref + %39 = arith.mulf %10, %38 : f64 + %40 = arith.subf %37, %39 : f64 + %41 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %42 = arith.mulf %13, %41 : f64 + %43 = arith.subf %40, %42 : f64 + %44 = arith.divf %43, %31 : f64 + affine.store %44, %arg5[%arg7, %arg8] : memref + } + affine.store %cst, %arg2[%arg7, symbol(%0) - 1] : memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = polygeist.submap(%arg4, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + %26 = polygeist.submap(%arg2, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1)>} : (memref, index, index, index) -> memref + %27 = polygeist.submap(%arg5, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + %28 = polygeist.submap(%arg2, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { + ^bb0(%in: f64, %in_2: f64, %in_3: f64, %out: f64): + %29 = arith.mulf %in, %in_2 : f64 + %30 = arith.addf %29, %in_3 : f64 + linalg.yield %30 : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %29 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %30 = arith.mulf %10, %29 : f64 + %31 = arith.addf %30, %11 : f64 + %32 = arith.divf %16, %31 : f64 + affine.store %32, %arg4[%arg7, %arg8] : memref + %33 = affine.load %arg2[%arg8, %arg7 - 1] : memref + %34 = arith.mulf %17, %33 : f64 + %35 = affine.load %arg2[%arg8, %arg7] : memref + %36 = arith.mulf %19, %35 : f64 + %37 = arith.addf %34, %36 : f64 + %38 = affine.load %arg2[%arg8, %arg7 + 1] : memref + %39 = arith.mulf %13, %38 : f64 + %40 = arith.subf %37, %39 : f64 + %41 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %42 = arith.mulf %10, %41 : f64 + %43 = arith.subf %40, %42 : f64 + %44 = arith.divf %43, %31 : f64 + affine.store %44, %arg5[%arg7, %arg8] : memref +} + +Pattern recognition complete: + Loads: 5 + Stores: 2 + LinalgGenerics: 0 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 + 1)>()[%15] { + affine.for %arg7 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.store %cst, %arg3[0, %arg7] : memref + affine.store %cst_1, %arg4[%arg7, 0] : memref + %22 = affine.load %arg3[0, %arg7] : memref + affine.store %22, %arg5[%arg7, 0] : memref + affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %29 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %30 = arith.mulf %10, %29 : f64 + %31 = arith.addf %30, %11 : f64 + %32 = arith.divf %16, %31 : f64 + affine.store %32, %arg4[%arg7, %arg8] : memref + %33 = affine.load %arg2[%arg8, %arg7 - 1] : memref + %34 = arith.mulf %17, %33 : f64 + %35 = affine.load %arg2[%arg8, %arg7] : memref + %36 = arith.mulf %19, %35 : f64 + %37 = arith.addf %34, %36 : f64 + %38 = affine.load %arg2[%arg8, %arg7 + 1] : memref + %39 = arith.mulf %13, %38 : f64 + %40 = arith.subf %37, %39 : f64 + %41 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %42 = arith.mulf %10, %41 : f64 + %43 = arith.subf %40, %42 : f64 + %44 = arith.divf %43, %31 : f64 + affine.store %44, %arg5[%arg7, %arg8] : memref + } + affine.store %cst, %arg3[symbol(%0) - 1, %arg7] : memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = polygeist.submap(%arg4, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + %26 = polygeist.submap(%arg3, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (-(d0 + 1) + s1, s0)>} : (memref, index, index, index) -> memref + %27 = polygeist.submap(%arg5, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + %28 = polygeist.submap(%arg3, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (-(d0 + 1) + s1 - 1, s0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { + ^bb0(%in: f64, %in_2: f64, %in_3: f64, %out: f64): + %29 = arith.mulf %in, %in_2 : f64 + %30 = arith.addf %29, %in_3 : f64 + linalg.yield %30 : f64 + } + } + affine.for %arg7 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.store %cst, %arg2[%arg7, 0] : memref + affine.store %cst_1, %arg4[%arg7, 0] : memref + %22 = affine.load %arg2[%arg7, 0] : memref + affine.store %22, %arg5[%arg7, 0] : memref + affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %29 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %30 = arith.mulf %13, %29 : f64 + %31 = arith.addf %30, %14 : f64 + %32 = arith.divf %17, %31 : f64 + affine.store %32, %arg4[%arg7, %arg8] : memref + %33 = affine.load %arg3[%arg7 - 1, %arg8] : memref + %34 = arith.mulf %16, %33 : f64 + %35 = affine.load %arg3[%arg7, %arg8] : memref + %36 = arith.mulf %21, %35 : f64 + %37 = arith.addf %34, %36 : f64 + %38 = affine.load %arg3[%arg7 + 1, %arg8] : memref + %39 = arith.mulf %10, %38 : f64 + %40 = arith.subf %37, %39 : f64 + %41 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %42 = arith.mulf %13, %41 : f64 + %43 = arith.subf %40, %42 : f64 + %44 = arith.divf %43, %31 : f64 + affine.store %44, %arg5[%arg7, %arg8] : memref + } + affine.store %cst, %arg2[%arg7, symbol(%0) - 1] : memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = polygeist.submap(%arg4, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + %26 = polygeist.submap(%arg2, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1)>} : (memref, index, index, index) -> memref + %27 = polygeist.submap(%arg5, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + %28 = polygeist.submap(%arg2, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { + ^bb0(%in: f64, %in_2: f64, %in_3: f64, %out: f64): + %29 = arith.mulf %in, %in_2 : f64 + %30 = arith.addf %29, %in_3 : f64 + linalg.yield %30 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.store %cst, %arg3[0, %arg7] : memref + affine.store %cst_1, %arg4[%arg7, 0] : memref + %22 = affine.load %arg3[0, %arg7] : memref + affine.store %22, %arg5[%arg7, 0] : memref + affine.for %arg8 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %29 = affine.load %arg4[%arg7, %arg8 - 1] : memref + %30 = arith.mulf %10, %29 : f64 + %31 = arith.addf %30, %11 : f64 + %32 = arith.divf %16, %31 : f64 + affine.store %32, %arg4[%arg7, %arg8] : memref + %33 = affine.load %arg2[%arg8, %arg7 - 1] : memref + %34 = arith.mulf %17, %33 : f64 + %35 = affine.load %arg2[%arg8, %arg7] : memref + %36 = arith.mulf %19, %35 : f64 + %37 = arith.addf %34, %36 : f64 + %38 = affine.load %arg2[%arg8, %arg7 + 1] : memref + %39 = arith.mulf %13, %38 : f64 + %40 = arith.subf %37, %39 : f64 + %41 = affine.load %arg5[%arg7, %arg8 - 1] : memref + %42 = arith.mulf %10, %41 : f64 + %43 = arith.subf %40, %42 : f64 + %44 = arith.divf %43, %31 : f64 + affine.store %44, %arg5[%arg7, %arg8] : memref + } + affine.store %cst, %arg3[symbol(%0) - 1, %arg7] : memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = polygeist.submap(%arg4, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + %26 = polygeist.submap(%arg3, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (-(d0 + 1) + s1, s0)>} : (memref, index, index, index) -> memref + %27 = polygeist.submap(%arg5, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (s0, -(d0 + 1) + s1 - 1)>} : (memref, index, index, index) -> memref + %28 = polygeist.submap(%arg3, %arg7, %0, %24) {map = affine_map<(d0)[s0, s1] -> (-(d0 + 1) + s1 - 1, s0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { + ^bb0(%in: f64, %in_2: f64, %in_3: f64, %out: f64): + %29 = arith.mulf %in, %in_2 : f64 + %30 = arith.addf %29, %in_3 : f64 + linalg.yield %30 : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/atax.log b/polybench_results/reject_logs/atax.log new file mode 100644 index 000000000000..1dba14d416ed --- /dev/null +++ b/polybench_results/reject_logs/atax.log @@ -0,0 +1,2425 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%0)) { + %2 = affine.load %arg4[%arg7] : memref + %3 = affine.load %arg2[%arg6, %arg7] : memref + %4 = affine.load %arg5[%arg6] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %2, %5 : f64 + affine.store %6, %arg4[%arg7] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%0)) { + affine.store %cst, %arg4[%arg6] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%0)) { + %2 = affine.load %arg4[%arg7] : memref + %3 = affine.load %arg2[%arg6, %arg7] : memref + %4 = affine.load %arg5[%arg6] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %2, %5 : f64 + affine.store %6, %arg4[%arg7] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%0)) { + affine.store %cst, %arg4[%arg6] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + %2 = affine.load %arg4[%arg7] : memref + %3 = affine.load %arg2[%arg6, %arg7] : memref + %4 = affine.load %arg5[%arg6] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %2, %5 : f64 + affine.store %6, %arg4[%arg7] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %5 = affine.load %arg4[%arg7] : memref +Processing load: %6 = affine.load %arg2[%arg6, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %8 = affine.load %arg5[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %11, %arg4[%arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + %5 = affine.load %arg5[%arg6] : memref + %6 = affine.load %arg2[%arg6, %arg7] : memref + %7 = affine.load %arg3[%arg7] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = arith.addf %5, %8 : f64 + affine.store %9, %arg5[%arg6] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %8 = affine.load %arg5[%arg6] : memref +Processing load: %9 = affine.load %arg2[%arg6, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %11 = affine.load %arg3[%arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %14, %arg5[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0] -> (s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + affine.store %cst, %arg5[%arg6] : memref + %2 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg3, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + %5 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg4, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%11, %12 : memref, memref) outs(%13 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = arith.mulf %in, %in_0 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %0 { + affine.store %cst, %arg4[%arg6] : memref +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg4[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 0 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.store %cst, %arg5[%arg6] : memref + %3 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%12, %13 : memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.store %cst, %arg5[%arg6] : memref + %3 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%12, %13 : memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.store %cst, %arg5[%arg6] : memref + %3 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%12, %13 : memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.store %cst, %arg5[%arg6] : memref + %3 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%12, %13 : memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.store %cst, %arg5[%arg6] : memref + %3 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%12, %13 : memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.store %cst, %arg5[%arg6] : memref + %3 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%12, %13 : memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.store %cst, %arg5[%arg6] : memref + %3 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%12, %13 : memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.store %cst, %arg5[%arg6] : memref + %3 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%12, %13 : memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.store %cst, %arg5[%arg6] : memref + %3 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%12, %13 : memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + +WARNING: AffineForOpRaising didn't converge +atax.mlir:2:3: warning: AffineForOpRaising didn't converge, continuing anyway + func.func @kernel_atax(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +atax.mlir:2:3: note: see current operation: +func.func @kernel_atax(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = polygeist.submap(%arg4, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%1 : memref) { + ^bb0(%out: f64): + linalg.yield %cst : f64 + } + %2 = arith.index_cast %arg0 : i32 to index + affine.for %arg6 = 0 to %2 { + affine.store %cst, %arg5[%arg6] : memref + %3 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = polygeist.submap(%arg2, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %0) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + return +} +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/bicg.log b/polybench_results/reject_logs/bicg.log new file mode 100644 index 000000000000..58669be59806 --- /dev/null +++ b/polybench_results/reject_logs/bicg.log @@ -0,0 +1,191 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%0)) { + affine.store %cst, %arg3[%arg7] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%0)) { + affine.store %cst, %arg3[%arg7] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %0 { + %2 = affine.load %arg3[%arg8] : memref + %3 = affine.load %arg6[%arg7] : memref + %4 = affine.load %arg2[%arg7, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %2, %5 : f64 + affine.store %6, %arg3[%arg8] : memref + %7 = affine.load %arg4[%arg7] : memref + %8 = affine.load %arg2[%arg7, %arg8] : memref + %9 = affine.load %arg5[%arg8] : memref + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + affine.store %11, %arg4[%arg7] : memref +} + +Pattern recognition complete: + Loads: 6 + Stores: 2 + LinalgGenerics: 0 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + affine.store %cst, %arg4[%arg7] : memref + affine.for %arg8 = 0 to %0 { + %2 = affine.load %arg3[%arg8] : memref + %3 = affine.load %arg6[%arg7] : memref + %4 = affine.load %arg2[%arg7, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %2, %5 : f64 + affine.store %6, %arg3[%arg8] : memref + %7 = affine.load %arg4[%arg7] : memref + %8 = affine.load %arg2[%arg7, %arg8] : memref + %9 = affine.load %arg5[%arg8] : memref + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %7, %10 : f64 + affine.store %11, %arg4[%arg7] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + affine.store %cst, %arg3[%arg7] : memref +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg3[%arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 0 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %0 { + %3 = affine.load %arg3[%arg8] : memref + %4 = affine.load %arg6[%arg7] : memref + %5 = affine.load %arg2[%arg7, %arg8] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + affine.store %7, %arg3[%arg8] : memref + %8 = affine.load %arg4[%arg7] : memref + %9 = affine.load %arg2[%arg7, %arg8] : memref + %10 = affine.load %arg5[%arg8] : memref + %11 = arith.mulf %9, %10 : f64 + %12 = arith.addf %8, %11 : f64 + affine.store %12, %arg4[%arg7] : memref +} + +Pattern recognition complete: + Loads: 6 + Stores: 2 + LinalgGenerics: 0 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %2 { + affine.store %cst, %arg4[%arg7] : memref + affine.for %arg8 = 0 to %0 { + %3 = affine.load %arg3[%arg8] : memref + %4 = affine.load %arg6[%arg7] : memref + %5 = affine.load %arg2[%arg7, %arg8] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = arith.addf %3, %6 : f64 + affine.store %7, %arg3[%arg8] : memref + %8 = affine.load %arg4[%arg7] : memref + %9 = affine.load %arg2[%arg7, %arg8] : memref + %10 = affine.load %arg5[%arg8] : memref + %11 = arith.mulf %9, %10 : f64 + %12 = arith.addf %8, %11 : f64 + affine.store %12, %arg4[%arg7] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/cholesky.log b/polybench_results/reject_logs/cholesky.log new file mode 100644 index 000000000000..b571c35760d6 --- /dev/null +++ b/polybench_results/reject_logs/cholesky.log @@ -0,0 +1,1747 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %3 = affine.load %arg1[%arg2, %arg3] : memref + %4 = arith.mulf %3, %3 : f64 + %5 = affine.load %arg1[%arg2, %arg2] : memref + %6 = arith.subf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg2] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %6 = affine.load %arg1[%arg2, %arg3] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %9 = affine.load %arg1[%arg2, %arg2] : memref + +--- Processing Stores --- +Processing store: affine.store %10, %arg1[%arg2, %arg2] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0, d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0] -> (s0, s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 1 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + affine.for %arg4 = 0 to affine_map<(d0) -> (d0)>(%arg3) { + %8 = affine.load %arg1[%arg2, %arg4] : memref + %9 = affine.load %arg1[%arg3, %arg4] : memref + %10 = arith.mulf %8, %9 : f64 + %11 = affine.load %arg1[%arg2, %arg3] : memref + %12 = arith.subf %11, %10 : f64 + affine.store %12, %arg1[%arg2, %arg3] : memref + } + %5 = affine.load %arg1[%arg3, %arg3] : memref + %6 = affine.load %arg1[%arg2, %arg3] : memref + %7 = arith.divf %6, %5 : f64 + affine.store %7, %arg1[%arg2, %arg3] : memref + } + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1 : memref) outs(%2 : memref) { + ^bb0(%in: f64, %out: f64): + %5 = arith.mulf %in, %in : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + %3 = affine.load %arg1[%arg2, %arg2] : memref + %4 = math.sqrt %3 : f64 + affine.store %4, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + affine.for %arg4 = 0 to affine_map<(d0) -> (d0)>(%arg3) { + %8 = affine.load %arg1[%arg2, %arg4] : memref + %9 = affine.load %arg1[%arg3, %arg4] : memref + %10 = arith.mulf %8, %9 : f64 + %11 = affine.load %arg1[%arg2, %arg3] : memref + %12 = arith.subf %11, %10 : f64 + affine.store %12, %arg1[%arg2, %arg3] : memref + } + %5 = affine.load %arg1[%arg3, %arg3] : memref + %6 = affine.load %arg1[%arg2, %arg3] : memref + %7 = arith.divf %6, %5 : f64 + affine.store %7, %arg1[%arg2, %arg3] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to affine_map<(d0) -> (d0)>(%arg3) { + %8 = affine.load %arg1[%arg2, %arg4] : memref + %9 = affine.load %arg1[%arg3, %arg4] : memref + %10 = arith.mulf %8, %9 : f64 + %11 = affine.load %arg1[%arg2, %arg3] : memref + %12 = arith.subf %11, %10 : f64 + affine.store %12, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %11 = affine.load %arg1[%arg2, %arg4] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %13 = affine.load %arg1[%arg3, %arg4] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %16 = affine.load %arg1[%arg2, %arg3] : memref + +--- Processing Stores --- +Processing store: affine.store %17, %arg1[%arg2, %arg3] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = affine.apply affine_map<(d0) -> (d0)>(%arg3) + %6 = polygeist.submap(%arg1, %arg2, %5) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg3, %5) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg1, %arg2, %arg3, %5) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.subf %out, %12 : f64 + linalg.yield %13 : f64 + } + %9 = affine.load %arg1[%arg3, %arg3] : memref + %10 = affine.load %arg1[%arg2, %arg3] : memref + %11 = arith.divf %10, %9 : f64 + affine.store %11, %arg1[%arg2, %arg3] : memref + } + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1 : memref) outs(%2 : memref) { + ^bb0(%in: f64, %out: f64): + %5 = arith.mulf %in, %in : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + %3 = affine.load %arg1[%arg2, %arg2] : memref + %4 = math.sqrt %3 : f64 + affine.store %4, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = affine.apply affine_map<(d0) -> (d0)>(%arg3) + %6 = polygeist.submap(%arg1, %arg2, %5) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg3, %5) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg1, %arg2, %arg3, %5) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.subf %out, %12 : f64 + linalg.yield %13 : f64 + } + %9 = affine.load %arg1[%arg3, %arg3] : memref + %10 = affine.load %arg1[%arg2, %arg3] : memref + %11 = arith.divf %10, %9 : f64 + affine.store %11, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%9, %10 : memref, memref) outs(%11 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.subf %out, %15 : f64 + linalg.yield %16 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %6 = affine.apply affine_map<(d0) -> (d0)>(%arg3) + %7 = polygeist.submap(%arg1, %arg2, %6) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg1, %arg3, %6) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg1, %arg2, %arg3, %6) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %13 = arith.mulf %in, %in_0 : f64 + %14 = arith.subf %out, %13 : f64 + linalg.yield %14 : f64 + } + %10 = affine.load %arg1[%arg3, %arg3] : memref + %11 = affine.load %arg1[%arg2, %arg3] : memref + %12 = arith.divf %11, %10 : f64 + affine.store %12, %arg1[%arg2, %arg3] : memref + } + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + %6 = arith.mulf %in, %in : f64 + %7 = arith.subf %out, %6 : f64 + linalg.yield %7 : f64 + } + %4 = affine.load %arg1[%arg2, %arg2] : memref + %5 = math.sqrt %4 : f64 + affine.store %5, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref + } + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1 : memref) outs(%2 : memref) { + ^bb0(%in: f64, %out: f64): + %5 = arith.mulf %in, %in : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + %3 = affine.load %arg1[%arg2, %arg2] : memref + %4 = math.sqrt %3 : f64 + affine.store %4, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = arith.mulf %in, %in_0 : f64 + %15 = arith.subf %out, %14 : f64 + linalg.yield %15 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %6 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.subf %out, %12 : f64 + linalg.yield %13 : f64 + } + %9 = affine.load %arg1[%arg3, %arg3] : memref + %10 = affine.load %arg1[%arg2, %arg3] : memref + %11 = arith.divf %10, %9 : f64 + affine.store %11, %arg1[%arg2, %arg3] : memref + } + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + %6 = arith.mulf %in, %in : f64 + %7 = arith.subf %out, %6 : f64 + linalg.yield %7 : f64 + } + %4 = affine.load %arg1[%arg2, %arg2] : memref + %5 = math.sqrt %4 : f64 + affine.store %5, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref + } + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1 : memref) outs(%2 : memref) { + ^bb0(%in: f64, %out: f64): + %5 = arith.mulf %in, %in : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + %3 = affine.load %arg1[%arg2, %arg2] : memref + %4 = math.sqrt %3 : f64 + affine.store %4, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = arith.mulf %in, %in_0 : f64 + %15 = arith.subf %out, %14 : f64 + linalg.yield %15 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %6 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.subf %out, %12 : f64 + linalg.yield %13 : f64 + } + %9 = affine.load %arg1[%arg3, %arg3] : memref + %10 = affine.load %arg1[%arg2, %arg3] : memref + %11 = arith.divf %10, %9 : f64 + affine.store %11, %arg1[%arg2, %arg3] : memref + } + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + %6 = arith.mulf %in, %in : f64 + %7 = arith.subf %out, %6 : f64 + linalg.yield %7 : f64 + } + %4 = affine.load %arg1[%arg2, %arg2] : memref + %5 = math.sqrt %4 : f64 + affine.store %5, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref + } + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1 : memref) outs(%2 : memref) { + ^bb0(%in: f64, %out: f64): + %5 = arith.mulf %in, %in : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + %3 = affine.load %arg1[%arg2, %arg2] : memref + %4 = math.sqrt %3 : f64 + affine.store %4, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = arith.mulf %in, %in_0 : f64 + %15 = arith.subf %out, %14 : f64 + linalg.yield %15 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %6 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.subf %out, %12 : f64 + linalg.yield %13 : f64 + } + %9 = affine.load %arg1[%arg3, %arg3] : memref + %10 = affine.load %arg1[%arg2, %arg3] : memref + %11 = arith.divf %10, %9 : f64 + affine.store %11, %arg1[%arg2, %arg3] : memref + } + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + %6 = arith.mulf %in, %in : f64 + %7 = arith.subf %out, %6 : f64 + linalg.yield %7 : f64 + } + %4 = affine.load %arg1[%arg2, %arg2] : memref + %5 = math.sqrt %4 : f64 + affine.store %5, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref + } + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1 : memref) outs(%2 : memref) { + ^bb0(%in: f64, %out: f64): + %5 = arith.mulf %in, %in : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + %3 = affine.load %arg1[%arg2, %arg2] : memref + %4 = math.sqrt %3 : f64 + affine.store %4, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = arith.mulf %in, %in_0 : f64 + %15 = arith.subf %out, %14 : f64 + linalg.yield %15 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %6 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.subf %out, %12 : f64 + linalg.yield %13 : f64 + } + %9 = affine.load %arg1[%arg3, %arg3] : memref + %10 = affine.load %arg1[%arg2, %arg3] : memref + %11 = arith.divf %10, %9 : f64 + affine.store %11, %arg1[%arg2, %arg3] : memref + } + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + %6 = arith.mulf %in, %in : f64 + %7 = arith.subf %out, %6 : f64 + linalg.yield %7 : f64 + } + %4 = affine.load %arg1[%arg2, %arg2] : memref + %5 = math.sqrt %4 : f64 + affine.store %5, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref + } + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1 : memref) outs(%2 : memref) { + ^bb0(%in: f64, %out: f64): + %5 = arith.mulf %in, %in : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + %3 = affine.load %arg1[%arg2, %arg2] : memref + %4 = math.sqrt %3 : f64 + affine.store %4, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = arith.mulf %in, %in_0 : f64 + %15 = arith.subf %out, %14 : f64 + linalg.yield %15 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %6 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.subf %out, %12 : f64 + linalg.yield %13 : f64 + } + %9 = affine.load %arg1[%arg3, %arg3] : memref + %10 = affine.load %arg1[%arg2, %arg3] : memref + %11 = arith.divf %10, %9 : f64 + affine.store %11, %arg1[%arg2, %arg3] : memref + } + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + %6 = arith.mulf %in, %in : f64 + %7 = arith.subf %out, %6 : f64 + linalg.yield %7 : f64 + } + %4 = affine.load %arg1[%arg2, %arg2] : memref + %5 = math.sqrt %4 : f64 + affine.store %5, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref + } + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1 : memref) outs(%2 : memref) { + ^bb0(%in: f64, %out: f64): + %5 = arith.mulf %in, %in : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + %3 = affine.load %arg1[%arg2, %arg2] : memref + %4 = math.sqrt %3 : f64 + affine.store %4, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = arith.mulf %in, %in_0 : f64 + %15 = arith.subf %out, %14 : f64 + linalg.yield %15 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %6 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.subf %out, %12 : f64 + linalg.yield %13 : f64 + } + %9 = affine.load %arg1[%arg3, %arg3] : memref + %10 = affine.load %arg1[%arg2, %arg3] : memref + %11 = arith.divf %10, %9 : f64 + affine.store %11, %arg1[%arg2, %arg3] : memref + } + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + %6 = arith.mulf %in, %in : f64 + %7 = arith.subf %out, %6 : f64 + linalg.yield %7 : f64 + } + %4 = affine.load %arg1[%arg2, %arg2] : memref + %5 = math.sqrt %4 : f64 + affine.store %5, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref + } + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1 : memref) outs(%2 : memref) { + ^bb0(%in: f64, %out: f64): + %5 = arith.mulf %in, %in : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + %3 = affine.load %arg1[%arg2, %arg2] : memref + %4 = math.sqrt %3 : f64 + affine.store %4, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = arith.mulf %in, %in_0 : f64 + %15 = arith.subf %out, %14 : f64 + linalg.yield %15 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %6 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.subf %out, %12 : f64 + linalg.yield %13 : f64 + } + %9 = affine.load %arg1[%arg3, %arg3] : memref + %10 = affine.load %arg1[%arg2, %arg3] : memref + %11 = arith.divf %10, %9 : f64 + affine.store %11, %arg1[%arg2, %arg3] : memref + } + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + %6 = arith.mulf %in, %in : f64 + %7 = arith.subf %out, %6 : f64 + linalg.yield %7 : f64 + } + %4 = affine.load %arg1[%arg2, %arg2] : memref + %5 = math.sqrt %4 : f64 + affine.store %5, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref + } + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1 : memref) outs(%2 : memref) { + ^bb0(%in: f64, %out: f64): + %5 = arith.mulf %in, %in : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + %3 = affine.load %arg1[%arg2, %arg2] : memref + %4 = math.sqrt %3 : f64 + affine.store %4, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = arith.mulf %in, %in_0 : f64 + %15 = arith.subf %out, %14 : f64 + linalg.yield %15 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %6 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.subf %out, %12 : f64 + linalg.yield %13 : f64 + } + %9 = affine.load %arg1[%arg3, %arg3] : memref + %10 = affine.load %arg1[%arg2, %arg3] : memref + %11 = arith.divf %10, %9 : f64 + affine.store %11, %arg1[%arg2, %arg3] : memref + } + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + %6 = arith.mulf %in, %in : f64 + %7 = arith.subf %out, %6 : f64 + linalg.yield %7 : f64 + } + %4 = affine.load %arg1[%arg2, %arg2] : memref + %5 = math.sqrt %4 : f64 + affine.store %5, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref + } + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1 : memref) outs(%2 : memref) { + ^bb0(%in: f64, %out: f64): + %5 = arith.mulf %in, %in : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + %3 = affine.load %arg1[%arg2, %arg2] : memref + %4 = math.sqrt %3 : f64 + affine.store %4, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = arith.mulf %in, %in_0 : f64 + %15 = arith.subf %out, %14 : f64 + linalg.yield %15 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %6 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.subf %out, %12 : f64 + linalg.yield %13 : f64 + } + %9 = affine.load %arg1[%arg3, %arg3] : memref + %10 = affine.load %arg1[%arg2, %arg3] : memref + %11 = arith.divf %10, %9 : f64 + affine.store %11, %arg1[%arg2, %arg3] : memref + } + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + %6 = arith.mulf %in, %in : f64 + %7 = arith.subf %out, %6 : f64 + linalg.yield %7 : f64 + } + %4 = affine.load %arg1[%arg2, %arg2] : memref + %5 = math.sqrt %4 : f64 + affine.store %5, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref + } + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1 : memref) outs(%2 : memref) { + ^bb0(%in: f64, %out: f64): + %5 = arith.mulf %in, %in : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + %3 = affine.load %arg1[%arg2, %arg2] : memref + %4 = math.sqrt %3 : f64 + affine.store %4, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = arith.mulf %in, %in_0 : f64 + %15 = arith.subf %out, %14 : f64 + linalg.yield %15 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %6 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = arith.mulf %in, %in_0 : f64 + %13 = arith.subf %out, %12 : f64 + linalg.yield %13 : f64 + } + %9 = affine.load %arg1[%arg3, %arg3] : memref + %10 = affine.load %arg1[%arg2, %arg3] : memref + %11 = arith.divf %10, %9 : f64 + affine.store %11, %arg1[%arg2, %arg3] : memref + } + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + %6 = arith.mulf %in, %in : f64 + %7 = arith.subf %out, %6 : f64 + linalg.yield %7 : f64 + } + %4 = affine.load %arg1[%arg2, %arg2] : memref + %5 = math.sqrt %4 : f64 + affine.store %5, %arg1[%arg2, %arg2] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + +WARNING: AffineForOpRaising didn't converge +cholesky.mlir:3:3: warning: AffineForOpRaising didn't converge, continuing anyway + func.func @kernel_cholesky(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +cholesky.mlir:3:3: note: see current operation: +func.func @kernel_cholesky(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %5 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 + } + %8 = affine.load %arg1[%arg3, %arg3] : memref + %9 = affine.load %arg1[%arg2, %arg3] : memref + %10 = arith.divf %9, %8 : f64 + affine.store %10, %arg1[%arg2, %arg3] : memref + } + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1 : memref) outs(%2 : memref) { + ^bb0(%in: f64, %out: f64): + %5 = arith.mulf %in, %in : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + %3 = affine.load %arg1[%arg2, %arg2] : memref + %4 = math.sqrt %3 : f64 + affine.store %4, %arg1[%arg2, %arg2] : memref + } + return +} +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/correlation.log b/polybench_results/reject_logs/correlation.log new file mode 100644 index 000000000000..4b30d29c0984 --- /dev/null +++ b/polybench_results/reject_logs/correlation.log @@ -0,0 +1,838 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg9) = (0) to (symbol(%0)) { + %4 = affine.load %arg3[%arg9, %arg7] : memref + %5 = affine.load %arg3[%arg9, %arg8] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg4[%arg7, %arg8] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg4[%arg7, %arg8] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (%arg7 + 1) to (symbol(%1)) { + affine.store %cst_0, %arg4[%arg7, %arg8] : memref + affine.parallel (%arg9) = (0) to (symbol(%0)) { + %4 = affine.load %arg3[%arg9, %arg7] : memref + %5 = affine.load %arg3[%arg9, %arg8] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg4[%arg7, %arg8] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg4[%arg7, %arg8] : memref + } + %3 = affine.load %arg4[%arg7, %arg8] : memref + affine.store %3, %arg4[%arg8, %arg7] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1) - 1) { + affine.store %cst_1, %arg4[%arg7, %arg7] : memref + affine.parallel (%arg8) = (%arg7 + 1) to (symbol(%1)) { + affine.store %cst_0, %arg4[%arg7, %arg8] : memref + affine.parallel (%arg9) = (0) to (symbol(%0)) { + %4 = affine.load %arg3[%arg9, %arg7] : memref + %5 = affine.load %arg3[%arg9, %arg8] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg4[%arg7, %arg8] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg4[%arg7, %arg8] : memref + } + %3 = affine.load %arg4[%arg7, %arg8] : memref + affine.store %3, %arg4[%arg8, %arg7] : memref + } +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%0)) { + affine.parallel (%arg8) = (0) to (symbol(%1)) { + %3 = affine.load %arg5[%arg8] : memref + %4 = affine.load %arg3[%arg7, %arg8] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg3[%arg7, %arg8] : memref + %6 = affine.load %arg6[%arg8] : memref + %7 = arith.mulf %2, %6 : f64 + %8 = arith.divf %5, %7 : f64 + affine.store %8, %arg3[%arg7, %arg8] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%1)) { + %3 = affine.load %arg5[%arg8] : memref + %4 = affine.load %arg3[%arg7, %arg8] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg3[%arg7, %arg8] : memref + %6 = affine.load %arg6[%arg8] : memref + %7 = arith.mulf %2, %6 : f64 + %8 = arith.divf %5, %7 : f64 + affine.store %8, %arg3[%arg7, %arg8] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%0)) { + %8 = affine.load %arg3[%arg8, %arg7] : memref + %9 = affine.load %arg5[%arg7] : memref + %10 = arith.subf %8, %9 : f64 + %11 = arith.mulf %10, %10 : f64 + %12 = affine.load %arg6[%arg7] : memref + %13 = arith.addf %12, %11 : f64 + affine.store %13, %arg6[%arg7] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + affine.store %cst_0, %arg6[%arg7] : memref + affine.parallel (%arg8) = (0) to (symbol(%0)) { + %8 = affine.load %arg3[%arg8, %arg7] : memref + %9 = affine.load %arg5[%arg7] : memref + %10 = arith.subf %8, %9 : f64 + %11 = arith.mulf %10, %10 : f64 + %12 = affine.load %arg6[%arg7] : memref + %13 = arith.addf %12, %11 : f64 + affine.store %13, %arg6[%arg7] : memref + } + %3 = affine.load %arg6[%arg7] : memref + %4 = arith.divf %3, %arg2 : f64 + %5 = math.sqrt %4 : f64 + %6 = arith.cmpf ole, %5, %cst : f64 + %7 = arith.select %6, %cst_1, %5 : f64 + affine.store %7, %arg6[%arg7] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%0)) { + %5 = affine.load %arg3[%arg8, %arg7] : memref + %6 = affine.load %arg5[%arg7] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg5[%arg7] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + affine.store %cst_0, %arg5[%arg7] : memref + affine.parallel (%arg8) = (0) to (symbol(%0)) { + %5 = affine.load %arg3[%arg8, %arg7] : memref + %6 = affine.load %arg5[%arg7] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg5[%arg7] : memref + } + %3 = affine.load %arg5[%arg7] : memref + %4 = arith.divf %3, %arg2 : f64 + affine.store %4, %arg5[%arg7] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg9) = (0) to (symbol(%0)) { + %4 = affine.load %arg3[%arg9, %arg7] : memref + %5 = affine.load %arg3[%arg9, %arg8] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg4[%arg7, %arg8] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg4[%arg7, %arg8] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (%arg7 + 1) to (symbol(%1)) { + affine.store %cst_0, %arg4[%arg7, %arg8] : memref + affine.for %arg9 = 0 to %0 { + %4 = affine.load %arg3[%arg9, %arg7] : memref + %5 = affine.load %arg3[%arg9, %arg8] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg4[%arg7, %arg8] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg4[%arg7, %arg8] : memref + } + %3 = affine.load %arg4[%arg7, %arg8] : memref + affine.store %3, %arg4[%arg8, %arg7] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1) - 1) { + affine.store %cst_1, %arg4[%arg7, %arg7] : memref + affine.for %arg8 = affine_map<(d0) -> (d0 + 1)>(%arg7) to %1 { + affine.store %cst_0, %arg4[%arg7, %arg8] : memref + affine.for %arg9 = 0 to %0 { + %4 = affine.load %arg3[%arg9, %arg7] : memref + %5 = affine.load %arg3[%arg9, %arg8] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg4[%arg7, %arg8] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg4[%arg7, %arg8] : memref + } + %3 = affine.load %arg4[%arg7, %arg8] : memref + affine.store %3, %arg4[%arg8, %arg7] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%0)) { + affine.parallel (%arg8) = (0) to (symbol(%1)) { + %3 = affine.load %arg5[%arg8] : memref + %4 = affine.load %arg3[%arg7, %arg8] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg3[%arg7, %arg8] : memref + %6 = affine.load %arg6[%arg8] : memref + %7 = arith.mulf %2, %6 : f64 + %8 = arith.divf %5, %7 : f64 + affine.store %8, %arg3[%arg7, %arg8] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%1)) { + %3 = affine.load %arg5[%arg8] : memref + %4 = affine.load %arg3[%arg7, %arg8] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg3[%arg7, %arg8] : memref + %6 = affine.load %arg6[%arg8] : memref + %7 = arith.mulf %2, %6 : f64 + %8 = arith.divf %5, %7 : f64 + affine.store %8, %arg3[%arg7, %arg8] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%0)) { + %8 = affine.load %arg3[%arg8, %arg7] : memref + %9 = affine.load %arg5[%arg7] : memref + %10 = arith.subf %8, %9 : f64 + %11 = arith.mulf %10, %10 : f64 + %12 = affine.load %arg6[%arg7] : memref + %13 = arith.addf %12, %11 : f64 + affine.store %13, %arg6[%arg7] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + affine.store %cst_0, %arg6[%arg7] : memref + affine.for %arg8 = 0 to %0 { + %8 = affine.load %arg3[%arg8, %arg7] : memref + %9 = affine.load %arg5[%arg7] : memref + %10 = arith.subf %8, %9 : f64 + %11 = arith.mulf %10, %10 : f64 + %12 = affine.load %arg6[%arg7] : memref + %13 = arith.addf %12, %11 : f64 + affine.store %13, %arg6[%arg7] : memref + } + %3 = affine.load %arg6[%arg7] : memref + %4 = arith.divf %3, %arg2 : f64 + %5 = math.sqrt %4 : f64 + %6 = arith.cmpf ole, %5, %cst : f64 + %7 = arith.select %6, %cst_1, %5 : f64 + affine.store %7, %arg6[%arg7] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%0)) { + %5 = affine.load %arg3[%arg8, %arg7] : memref + %6 = affine.load %arg5[%arg7] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg5[%arg7] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + affine.store %cst_0, %arg5[%arg7] : memref + affine.for %arg8 = 0 to %0 { + %5 = affine.load %arg3[%arg8, %arg7] : memref + %6 = affine.load %arg5[%arg7] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg5[%arg7] : memref + } + %3 = affine.load %arg5[%arg7] : memref + %4 = arith.divf %3, %arg2 : f64 + affine.store %4, %arg5[%arg7] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg9 = 0 to %0 { + %4 = affine.load %arg3[%arg9, %arg7] : memref + %5 = affine.load %arg3[%arg9, %arg8] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg4[%arg7, %arg8] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg4[%arg7, %arg8] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %7 = affine.load %arg3[%arg9, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %9 = affine.load %arg3[%arg9, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %12 = affine.load %arg4[%arg7, %arg8] : memref + +--- Processing Stores --- +Processing store: affine.store %13, %arg4[%arg7, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = affine_map<(d0) -> (d0 + 1)>(%arg7) to %1 { + affine.store %cst_0, %arg4[%arg7, %arg8] : memref + %3 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %arg8, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg4, %arg7, %arg8, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %7 = arith.mulf %in, %in_2 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } + %6 = affine.load %arg4[%arg7, %arg8] : memref + affine.store %6, %arg4[%arg8, %arg7] : memref +} + +Pattern recognition complete: + Loads: 1 + Stores: 2 + LinalgGenerics: 1 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to affine_map<()[s0] -> (s0 - 1)>()[%1] { + affine.store %cst_1, %arg4[%arg7, %arg7] : memref + affine.for %arg8 = affine_map<(d0) -> (d0 + 1)>(%arg7) to %1 { + affine.store %cst_0, %arg4[%arg7, %arg8] : memref + %3 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %arg8, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg4, %arg7, %arg8, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %7 = arith.mulf %in, %in_2 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } + %6 = affine.load %arg4[%arg7, %arg8] : memref + affine.store %6, %arg4[%arg8, %arg7] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + %3 = affine.load %arg5[%arg8] : memref + %4 = affine.load %arg3[%arg7, %arg8] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg3[%arg7, %arg8] : memref + %6 = affine.load %arg6[%arg8] : memref + %7 = arith.mulf %2, %6 : f64 + %8 = arith.divf %5, %7 : f64 + affine.store %8, %arg3[%arg7, %arg8] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %1 { + %3 = affine.load %arg5[%arg8] : memref + %4 = affine.load %arg3[%arg7, %arg8] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg3[%arg7, %arg8] : memref + %6 = affine.load %arg6[%arg8] : memref + %7 = arith.mulf %2, %6 : f64 + %8 = arith.divf %5, %7 : f64 + affine.store %8, %arg3[%arg7, %arg8] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 2 + LinalgGenerics: 0 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %0 { + %8 = affine.load %arg3[%arg8, %arg7] : memref + %9 = affine.load %arg5[%arg7] : memref + %10 = arith.subf %8, %9 : f64 + %11 = arith.mulf %10, %10 : f64 + %12 = affine.load %arg6[%arg7] : memref + %13 = arith.addf %12, %11 : f64 + affine.store %13, %arg6[%arg7] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %11 = affine.load %arg3[%arg8, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %13 = affine.load %arg5[%arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %17 = affine.load %arg6[%arg7] : memref + +--- Processing Stores --- +Processing store: affine.store %18, %arg6[%arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0] -> (s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + affine.store %cst_0, %arg6[%arg7] : memref + %3 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg6, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %11 = arith.subf %in, %in_2 : f64 + %12 = arith.mulf %11, %11 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 + } + %6 = affine.load %arg6[%arg7] : memref + %7 = arith.divf %6, %arg2 : f64 + %8 = math.sqrt %7 : f64 + %9 = arith.cmpf ole, %8, %cst : f64 + %10 = arith.select %9, %cst_1, %8 : f64 + affine.store %10, %arg6[%arg7] : memref +} + +Pattern recognition complete: + Loads: 1 + Stores: 2 + LinalgGenerics: 1 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %0 { + %5 = affine.load %arg3[%arg8, %arg7] : memref + %6 = affine.load %arg5[%arg7] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg5[%arg7] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %8 = affine.load %arg3[%arg8, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %10 = affine.load %arg5[%arg7] : memref + +--- Processing Stores --- +Processing store: affine.store %11, %arg5[%arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0] -> (s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 1 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + affine.store %cst_0, %arg5[%arg7] : memref + %3 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + %7 = arith.addf %out, %in : f64 + linalg.yield %7 : f64 + } + %5 = affine.load %arg5[%arg7] : memref + %6 = arith.divf %5, %arg2 : f64 + affine.store %6, %arg5[%arg7] : memref +} + +Pattern recognition complete: + Loads: 1 + Stores: 2 + LinalgGenerics: 1 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = affine_map<(d0) -> (d0 + 1)>(%arg7) to %1 { + affine.store %cst_0, %arg4[%arg7, %arg8] : memref + %3 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %arg8, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg4, %arg7, %arg8, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %7 = arith.mulf %in, %in_2 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } + %6 = affine.load %arg4[%arg7, %arg8] : memref + affine.store %6, %arg4[%arg8, %arg7] : memref +} + +Pattern recognition complete: + Loads: 1 + Stores: 2 + LinalgGenerics: 1 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to affine_map<()[s0] -> (s0 - 1)>()[%1] { + affine.store %cst_1, %arg4[%arg7, %arg7] : memref + affine.for %arg8 = affine_map<(d0) -> (d0 + 1)>(%arg7) to %1 { + affine.store %cst_0, %arg4[%arg7, %arg8] : memref + %3 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %arg8, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg4, %arg7, %arg8, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %7 = arith.mulf %in, %in_2 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } + %6 = affine.load %arg4[%arg7, %arg8] : memref + affine.store %6, %arg4[%arg8, %arg7] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + %3 = affine.load %arg5[%arg8] : memref + %4 = affine.load %arg3[%arg7, %arg8] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg3[%arg7, %arg8] : memref + %6 = affine.load %arg6[%arg8] : memref + %7 = arith.mulf %2, %6 : f64 + %8 = arith.divf %5, %7 : f64 + affine.store %8, %arg3[%arg7, %arg8] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %1 { + %3 = affine.load %arg5[%arg8] : memref + %4 = affine.load %arg3[%arg7, %arg8] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg3[%arg7, %arg8] : memref + %6 = affine.load %arg6[%arg8] : memref + %7 = arith.mulf %2, %6 : f64 + %8 = arith.divf %5, %7 : f64 + affine.store %8, %arg3[%arg7, %arg8] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 2 + LinalgGenerics: 0 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + affine.store %cst_0, %arg6[%arg7] : memref + %3 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg6, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_2: f64, %out: f64): + %11 = arith.subf %in, %in_2 : f64 + %12 = arith.mulf %11, %11 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 + } + %6 = affine.load %arg6[%arg7] : memref + %7 = arith.divf %6, %arg2 : f64 + %8 = math.sqrt %7 : f64 + %9 = arith.cmpf ole, %8, %cst : f64 + %10 = arith.select %9, %cst_1, %8 : f64 + affine.store %10, %arg6[%arg7] : memref +} + +Pattern recognition complete: + Loads: 1 + Stores: 2 + LinalgGenerics: 1 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + affine.store %cst_0, %arg5[%arg7] : memref + %3 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + %7 = arith.addf %out, %in : f64 + linalg.yield %7 : f64 + } + %5 = affine.load %arg5[%arg7] : memref + %6 = arith.divf %5, %arg2 : f64 + affine.store %6, %arg5[%arg7] : memref +} + +Pattern recognition complete: + Loads: 1 + Stores: 2 + LinalgGenerics: 1 + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/covariance.log b/polybench_results/reject_logs/covariance.log new file mode 100644 index 000000000000..c307b35b4243 --- /dev/null +++ b/polybench_results/reject_logs/covariance.log @@ -0,0 +1,715 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%0)) { + %5 = affine.load %arg3[%arg8, %arg6] : memref + %6 = affine.load %arg3[%arg8, %arg7] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg4[%arg6, %arg7] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg4[%arg6, %arg7] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%1)) { + affine.parallel (%arg7) = (%arg6) to (symbol(%1)) { + affine.store %cst, %arg4[%arg6, %arg7] : memref + affine.parallel (%arg8) = (0) to (symbol(%0)) { + %5 = affine.load %arg3[%arg8, %arg6] : memref + %6 = affine.load %arg3[%arg8, %arg7] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg4[%arg6, %arg7] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg4[%arg6, %arg7] : memref + } + %3 = affine.load %arg4[%arg6, %arg7] : memref + %4 = arith.divf %3, %2 : f64 + affine.store %4, %arg4[%arg6, %arg7] : memref + affine.store %4, %arg4[%arg7, %arg6] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (%arg6) to (symbol(%1)) { + affine.store %cst, %arg4[%arg6, %arg7] : memref + affine.parallel (%arg8) = (0) to (symbol(%0)) { + %5 = affine.load %arg3[%arg8, %arg6] : memref + %6 = affine.load %arg3[%arg8, %arg7] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg4[%arg6, %arg7] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg4[%arg6, %arg7] : memref + } + %3 = affine.load %arg4[%arg6, %arg7] : memref + %4 = arith.divf %3, %2 : f64 + affine.store %4, %arg4[%arg6, %arg7] : memref + affine.store %4, %arg4[%arg7, %arg6] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%0)) { + affine.parallel (%arg7) = (0) to (symbol(%1)) { + %3 = affine.load %arg5[%arg7] : memref + %4 = affine.load %arg3[%arg6, %arg7] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg3[%arg6, %arg7] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + %3 = affine.load %arg5[%arg7] : memref + %4 = affine.load %arg3[%arg6, %arg7] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg3[%arg6, %arg7] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%0)) { + %5 = affine.load %arg3[%arg7, %arg6] : memref + %6 = affine.load %arg5[%arg6] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg5[%arg6] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%1)) { + affine.store %cst, %arg5[%arg6] : memref + affine.parallel (%arg7) = (0) to (symbol(%0)) { + %5 = affine.load %arg3[%arg7, %arg6] : memref + %6 = affine.load %arg5[%arg6] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg5[%arg6] : memref + } + %3 = affine.load %arg5[%arg6] : memref + %4 = arith.divf %3, %arg2 : f64 + affine.store %4, %arg5[%arg6] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%0)) { + %5 = affine.load %arg3[%arg8, %arg6] : memref + %6 = affine.load %arg3[%arg8, %arg7] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg4[%arg6, %arg7] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg4[%arg6, %arg7] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%1)) { + affine.parallel (%arg7) = (%arg6) to (symbol(%1)) { + affine.store %cst, %arg4[%arg6, %arg7] : memref + affine.for %arg8 = 0 to %0 { + %5 = affine.load %arg3[%arg8, %arg6] : memref + %6 = affine.load %arg3[%arg8, %arg7] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg4[%arg6, %arg7] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg4[%arg6, %arg7] : memref + } + %3 = affine.load %arg4[%arg6, %arg7] : memref + %4 = arith.divf %3, %2 : f64 + affine.store %4, %arg4[%arg6, %arg7] : memref + affine.store %4, %arg4[%arg7, %arg6] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (%arg6) to (symbol(%1)) { + affine.store %cst, %arg4[%arg6, %arg7] : memref + affine.for %arg8 = 0 to %0 { + %5 = affine.load %arg3[%arg8, %arg6] : memref + %6 = affine.load %arg3[%arg8, %arg7] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg4[%arg6, %arg7] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg4[%arg6, %arg7] : memref + } + %3 = affine.load %arg4[%arg6, %arg7] : memref + %4 = arith.divf %3, %2 : f64 + affine.store %4, %arg4[%arg6, %arg7] : memref + affine.store %4, %arg4[%arg7, %arg6] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%0)) { + affine.parallel (%arg7) = (0) to (symbol(%1)) { + %3 = affine.load %arg5[%arg7] : memref + %4 = affine.load %arg3[%arg6, %arg7] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg3[%arg6, %arg7] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + %3 = affine.load %arg5[%arg7] : memref + %4 = affine.load %arg3[%arg6, %arg7] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg3[%arg6, %arg7] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%0)) { + %5 = affine.load %arg3[%arg7, %arg6] : memref + %6 = affine.load %arg5[%arg6] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg5[%arg6] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%1)) { + affine.store %cst, %arg5[%arg6] : memref + affine.for %arg7 = 0 to %0 { + %5 = affine.load %arg3[%arg7, %arg6] : memref + %6 = affine.load %arg5[%arg6] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg5[%arg6] : memref + } + %3 = affine.load %arg5[%arg6] : memref + %4 = arith.divf %3, %arg2 : f64 + affine.store %4, %arg5[%arg6] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %0 { + %5 = affine.load %arg3[%arg8, %arg6] : memref + %6 = affine.load %arg3[%arg8, %arg7] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg4[%arg6, %arg7] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg4[%arg6, %arg7] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %8 = affine.load %arg3[%arg8, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %10 = affine.load %arg3[%arg8, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %13 = affine.load %arg4[%arg6, %arg7] : memref + +--- Processing Stores --- +Processing store: affine.store %14, %arg4[%arg6, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + affine.for %arg7 = affine_map<(d0) -> (d0)>(%arg6) to %1 { + affine.store %cst, %arg4[%arg6, %arg7] : memref + %3 = polygeist.submap(%arg3, %arg6, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg4, %arg6, %arg7, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %8 = arith.mulf %in, %in_1 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + %6 = affine.load %arg4[%arg6, %arg7] : memref + %7 = arith.divf %6, %2 : f64 + affine.store %7, %arg4[%arg6, %arg7] : memref + affine.store %7, %arg4[%arg7, %arg6] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = affine_map<(d0) -> (d0)>(%arg6) to %1 { + affine.store %cst, %arg4[%arg6, %arg7] : memref + %3 = polygeist.submap(%arg3, %arg6, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg4, %arg6, %arg7, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %8 = arith.mulf %in, %in_1 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + %6 = affine.load %arg4[%arg6, %arg7] : memref + %7 = arith.divf %6, %2 : f64 + affine.store %7, %arg4[%arg6, %arg7] : memref + affine.store %7, %arg4[%arg7, %arg6] : memref +} + +Pattern recognition complete: + Loads: 1 + Stores: 3 + LinalgGenerics: 1 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %0 { + affine.for %arg7 = 0 to %1 { + %3 = affine.load %arg5[%arg7] : memref + %4 = affine.load %arg3[%arg6, %arg7] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg3[%arg6, %arg7] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %3 = affine.load %arg5[%arg7] : memref + %4 = affine.load %arg3[%arg6, %arg7] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg3[%arg6, %arg7] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %6 = affine.load %arg5[%arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %8 = affine.load %arg3[%arg6, %arg7] : memref + +--- Processing Stores --- +Processing store: affine.store %9, %arg3[%arg6, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 1 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + %4 = polygeist.submap(%arg5, %3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + %6 = arith.subf %out, %in : f64 + linalg.yield %6 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7 : memref) outs(%8 : memref) { +^bb0(%in: f64, %out: f64): + %9 = arith.subf %out, %in : f64 + linalg.yield %9 : f64 +} + Processing 1 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 1 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + %7 = affine.load %arg3[%arg7, %arg6] : memref + %8 = affine.load %arg5[%arg6] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg5[%arg6] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %10 = affine.load %arg3[%arg7, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %12 = affine.load %arg5[%arg6] : memref + +--- Processing Stores --- +Processing store: affine.store %13, %arg5[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0] -> (s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 1 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + affine.store %cst, %arg5[%arg6] : memref + %5 = polygeist.submap(%arg3, %arg6, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5 : memref) outs(%6 : memref) { + ^bb0(%in: f64, %out: f64): + %9 = arith.addf %out, %in : f64 + linalg.yield %9 : f64 + } + %7 = affine.load %arg5[%arg6] : memref + %8 = arith.divf %7, %arg2 : f64 + affine.store %8, %arg5[%arg6] : memref +} + +Pattern recognition complete: + Loads: 1 + Stores: 2 + LinalgGenerics: 1 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + affine.for %arg7 = affine_map<(d0) -> (d0)>(%arg6) to %1 { + affine.store %cst, %arg4[%arg6, %arg7] : memref + %5 = polygeist.submap(%arg3, %arg6, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg6, %arg7, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %10 = arith.mulf %in, %in_1 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + %8 = affine.load %arg4[%arg6, %arg7] : memref + %9 = arith.divf %8, %4 : f64 + affine.store %9, %arg4[%arg6, %arg7] : memref + affine.store %9, %arg4[%arg7, %arg6] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = affine_map<(d0) -> (d0)>(%arg6) to %1 { + affine.store %cst, %arg4[%arg6, %arg7] : memref + %5 = polygeist.submap(%arg3, %arg6, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg6, %arg7, %0) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %10 = arith.mulf %in, %in_1 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + %8 = affine.load %arg4[%arg6, %arg7] : memref + %9 = arith.divf %8, %4 : f64 + affine.store %9, %arg4[%arg6, %arg7] : memref + affine.store %9, %arg4[%arg7, %arg6] : memref +} + +Pattern recognition complete: + Loads: 1 + Stores: 3 + LinalgGenerics: 1 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + affine.store %cst, %arg5[%arg6] : memref + %5 = polygeist.submap(%arg3, %arg6, %0) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg5, %arg6, %0) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5 : memref) outs(%6 : memref) { + ^bb0(%in: f64, %out: f64): + %9 = arith.addf %out, %in : f64 + linalg.yield %9 : f64 + } + %7 = affine.load %arg5[%arg6] : memref + %8 = arith.divf %7, %arg2 : f64 + affine.store %8, %arg5[%arg6] : memref +} + +Pattern recognition complete: + Loads: 1 + Stores: 2 + LinalgGenerics: 1 + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/deriche.log b/polybench_results/reject_logs/deriche.log new file mode 100644 index 000000000000..671dd19cb3ff --- /dev/null +++ b/polybench_results/reject_logs/deriche.log @@ -0,0 +1,2850 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %0 { + %20 = affine.load %arg3[%arg7, %arg8] : memref + %21 = arith.mulf %11, %20 : f32 + %22 = affine.load %alloca_4[] : memref + %23 = arith.mulf %14, %22 : f32 + %24 = arith.addf %21, %23 : f32 + %25 = affine.load %alloca_3[] : memref + %26 = arith.mulf %15, %25 : f32 + %27 = arith.addf %24, %26 : f32 + %28 = affine.load %alloca[] : memref + %29 = arith.mulf %18, %28 : f32 + %30 = arith.addf %27, %29 : f32 + affine.store %30, %arg5[%arg7, %arg8] : memref + %31 = affine.load %arg3[%arg7, %arg8] : memref + affine.store %31, %alloca_4[] : memref + affine.store %25, %alloca[] : memref + %32 = affine.load %arg5[%arg7, %arg8] : memref + affine.store %32, %alloca_3[] : memref +} + +Pattern recognition complete: + Loads: 6 + Stores: 4 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %23 = affine.load %arg3[%arg7, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %26 = affine.load %alloca_4[] : memref +Processing load: %29 = affine.load %alloca_3[] : memref +Processing load: %32 = affine.load %alloca[] : memref +Processing load: %35 = affine.load %arg3[%arg7, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %37 = affine.load %arg5[%arg7, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %36, %arg5[%arg7, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %38, %alloca_4[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %33, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %41, %alloca_3[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 3 +Total outputs: 4 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %19 { + affine.store %cst_2, %alloca_3[] : memref + affine.store %cst_2, %alloca[] : memref + affine.store %cst_2, %alloca_4[] : memref + %20 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %21 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %24 = polygeist.submap(%alloca_4, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %25 = polygeist.submap(%alloca, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %26 = polygeist.submap(%alloca_3, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%20, %21, %22 : memref, memref, memref) outs(%23, %24, %25, %26 : memref, memref, memref, memref) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %27 = arith.mulf %11, %in : f32 + %28 = arith.mulf %14, %out_7 : f32 + %29 = arith.addf %27, %28 : f32 + %30 = arith.mulf %15, %out_9 : f32 + %31 = arith.addf %29, %30 : f32 + %32 = arith.mulf %18, %out_8 : f32 + %33 = arith.addf %31, %32 : f32 + linalg.yield %33, %in_5, %out_9, %in_6 : f32, f32, f32, f32 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 3 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%23, %24, %25 : memref, memref, memref) outs(%26, %27, %28, %29 : memref, memref, memref, memref) { +^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %30 = arith.mulf %11, %in : f32 + %31 = arith.mulf %14, %out_7 : f32 + %32 = arith.addf %30, %31 : f32 + %33 = arith.mulf %15, %out_9 : f32 + %34 = arith.addf %32, %33 : f32 + %35 = arith.mulf %18, %out_8 : f32 + %36 = arith.addf %34, %35 : f32 + linalg.yield %36, %in_5, %out_9, %in_6 : f32, f32, f32, f32 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 4 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst_2, %alloca_3[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca_4[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %19 { + affine.store %cst_2, %alloca_3[] : memref + affine.store %cst_2, %alloca[] : memref + affine.store %cst_2, %alloca_4[] : memref + %20 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %21 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %24 = polygeist.submap(%alloca_4, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %25 = polygeist.submap(%alloca, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %26 = polygeist.submap(%alloca_3, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%20, %21, %22 : memref, memref, memref) outs(%23, %24, %25, %26 : memref, memref, memref, memref) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %27 = arith.mulf %11, %in : f32 + %28 = arith.mulf %14, %out_7 : f32 + %29 = arith.addf %27, %28 : f32 + %30 = arith.mulf %15, %out_9 : f32 + %31 = arith.addf %29, %30 : f32 + %32 = arith.mulf %18, %out_8 : f32 + %33 = arith.addf %31, %32 : f32 + linalg.yield %33, %in_5, %out_9, %in_6 : f32, f32, f32, f32 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 3 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%23, %24, %25 : memref, memref, memref) outs(%26, %27, %28, %29 : memref, memref, memref, memref) { +^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %30 = arith.mulf %11, %in : f32 + %31 = arith.mulf %14, %out_7 : f32 + %32 = arith.addf %30, %31 : f32 + %33 = arith.mulf %15, %out_9 : f32 + %34 = arith.addf %32, %33 : f32 + %35 = arith.mulf %18, %out_8 : f32 + %36 = arith.addf %34, %35 : f32 + linalg.yield %36, %in_5, %out_9, %in_6 : f32, f32, f32, f32 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 4 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst_2, %alloca_3[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca_4[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %19 { + affine.store %cst_2, %alloca_3[] : memref + affine.store %cst_2, %alloca[] : memref + affine.store %cst_2, %alloca_4[] : memref + %20 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %21 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %24 = polygeist.submap(%alloca_4, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %25 = polygeist.submap(%alloca, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %26 = polygeist.submap(%alloca_3, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%20, %21, %22 : memref, memref, memref) outs(%23, %24, %25, %26 : memref, memref, memref, memref) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %27 = arith.mulf %11, %in : f32 + %28 = arith.mulf %14, %out_7 : f32 + %29 = arith.addf %27, %28 : f32 + %30 = arith.mulf %15, %out_9 : f32 + %31 = arith.addf %29, %30 : f32 + %32 = arith.mulf %18, %out_8 : f32 + %33 = arith.addf %31, %32 : f32 + linalg.yield %33, %in_5, %out_9, %in_6 : f32, f32, f32, f32 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 3 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%23, %24, %25 : memref, memref, memref) outs(%26, %27, %28, %29 : memref, memref, memref, memref) { +^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %30 = arith.mulf %11, %in : f32 + %31 = arith.mulf %14, %out_7 : f32 + %32 = arith.addf %30, %31 : f32 + %33 = arith.mulf %15, %out_9 : f32 + %34 = arith.addf %32, %33 : f32 + %35 = arith.mulf %18, %out_8 : f32 + %36 = arith.addf %34, %35 : f32 + linalg.yield %36, %in_5, %out_9, %in_6 : f32, f32, f32, f32 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 4 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst_2, %alloca_3[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca_4[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %19 { + affine.store %cst_2, %alloca_3[] : memref + affine.store %cst_2, %alloca[] : memref + affine.store %cst_2, %alloca_4[] : memref + %20 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %21 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %24 = polygeist.submap(%alloca_4, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %25 = polygeist.submap(%alloca, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %26 = polygeist.submap(%alloca_3, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%20, %21, %22 : memref, memref, memref) outs(%23, %24, %25, %26 : memref, memref, memref, memref) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %27 = arith.mulf %11, %in : f32 + %28 = arith.mulf %14, %out_7 : f32 + %29 = arith.addf %27, %28 : f32 + %30 = arith.mulf %15, %out_9 : f32 + %31 = arith.addf %29, %30 : f32 + %32 = arith.mulf %18, %out_8 : f32 + %33 = arith.addf %31, %32 : f32 + linalg.yield %33, %in_5, %out_9, %in_6 : f32, f32, f32, f32 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 3 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%23, %24, %25 : memref, memref, memref) outs(%26, %27, %28, %29 : memref, memref, memref, memref) { +^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %30 = arith.mulf %11, %in : f32 + %31 = arith.mulf %14, %out_7 : f32 + %32 = arith.addf %30, %31 : f32 + %33 = arith.mulf %15, %out_9 : f32 + %34 = arith.addf %32, %33 : f32 + %35 = arith.mulf %18, %out_8 : f32 + %36 = arith.addf %34, %35 : f32 + linalg.yield %36, %in_5, %out_9, %in_6 : f32, f32, f32, f32 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 4 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst_2, %alloca_3[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca_4[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %19 { + affine.store %cst_2, %alloca_3[] : memref + affine.store %cst_2, %alloca[] : memref + affine.store %cst_2, %alloca_4[] : memref + %20 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %21 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %24 = polygeist.submap(%alloca_4, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %25 = polygeist.submap(%alloca, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %26 = polygeist.submap(%alloca_3, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%20, %21, %22 : memref, memref, memref) outs(%23, %24, %25, %26 : memref, memref, memref, memref) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %27 = arith.mulf %11, %in : f32 + %28 = arith.mulf %14, %out_7 : f32 + %29 = arith.addf %27, %28 : f32 + %30 = arith.mulf %15, %out_9 : f32 + %31 = arith.addf %29, %30 : f32 + %32 = arith.mulf %18, %out_8 : f32 + %33 = arith.addf %31, %32 : f32 + linalg.yield %33, %in_5, %out_9, %in_6 : f32, f32, f32, f32 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 3 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%23, %24, %25 : memref, memref, memref) outs(%26, %27, %28, %29 : memref, memref, memref, memref) { +^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %30 = arith.mulf %11, %in : f32 + %31 = arith.mulf %14, %out_7 : f32 + %32 = arith.addf %30, %31 : f32 + %33 = arith.mulf %15, %out_9 : f32 + %34 = arith.addf %32, %33 : f32 + %35 = arith.mulf %18, %out_8 : f32 + %36 = arith.addf %34, %35 : f32 + linalg.yield %36, %in_5, %out_9, %in_6 : f32, f32, f32, f32 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 4 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst_2, %alloca_3[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca_4[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %19 { + affine.store %cst_2, %alloca_3[] : memref + affine.store %cst_2, %alloca[] : memref + affine.store %cst_2, %alloca_4[] : memref + %20 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %21 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %24 = polygeist.submap(%alloca_4, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %25 = polygeist.submap(%alloca, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %26 = polygeist.submap(%alloca_3, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%20, %21, %22 : memref, memref, memref) outs(%23, %24, %25, %26 : memref, memref, memref, memref) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %27 = arith.mulf %11, %in : f32 + %28 = arith.mulf %14, %out_7 : f32 + %29 = arith.addf %27, %28 : f32 + %30 = arith.mulf %15, %out_9 : f32 + %31 = arith.addf %29, %30 : f32 + %32 = arith.mulf %18, %out_8 : f32 + %33 = arith.addf %31, %32 : f32 + linalg.yield %33, %in_5, %out_9, %in_6 : f32, f32, f32, f32 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 3 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%23, %24, %25 : memref, memref, memref) outs(%26, %27, %28, %29 : memref, memref, memref, memref) { +^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %30 = arith.mulf %11, %in : f32 + %31 = arith.mulf %14, %out_7 : f32 + %32 = arith.addf %30, %31 : f32 + %33 = arith.mulf %15, %out_9 : f32 + %34 = arith.addf %32, %33 : f32 + %35 = arith.mulf %18, %out_8 : f32 + %36 = arith.addf %34, %35 : f32 + linalg.yield %36, %in_5, %out_9, %in_6 : f32, f32, f32, f32 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 4 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst_2, %alloca_3[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca_4[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %19 { + affine.store %cst_2, %alloca_3[] : memref + affine.store %cst_2, %alloca[] : memref + affine.store %cst_2, %alloca_4[] : memref + %20 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %21 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %24 = polygeist.submap(%alloca_4, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %25 = polygeist.submap(%alloca, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %26 = polygeist.submap(%alloca_3, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%20, %21, %22 : memref, memref, memref) outs(%23, %24, %25, %26 : memref, memref, memref, memref) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %27 = arith.mulf %11, %in : f32 + %28 = arith.mulf %14, %out_7 : f32 + %29 = arith.addf %27, %28 : f32 + %30 = arith.mulf %15, %out_9 : f32 + %31 = arith.addf %29, %30 : f32 + %32 = arith.mulf %18, %out_8 : f32 + %33 = arith.addf %31, %32 : f32 + linalg.yield %33, %in_5, %out_9, %in_6 : f32, f32, f32, f32 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 3 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%23, %24, %25 : memref, memref, memref) outs(%26, %27, %28, %29 : memref, memref, memref, memref) { +^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %30 = arith.mulf %11, %in : f32 + %31 = arith.mulf %14, %out_7 : f32 + %32 = arith.addf %30, %31 : f32 + %33 = arith.mulf %15, %out_9 : f32 + %34 = arith.addf %32, %33 : f32 + %35 = arith.mulf %18, %out_8 : f32 + %36 = arith.addf %34, %35 : f32 + linalg.yield %36, %in_5, %out_9, %in_6 : f32, f32, f32, f32 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 4 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst_2, %alloca_3[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca_4[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %19 { + affine.store %cst_2, %alloca_3[] : memref + affine.store %cst_2, %alloca[] : memref + affine.store %cst_2, %alloca_4[] : memref + %20 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %21 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %24 = polygeist.submap(%alloca_4, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %25 = polygeist.submap(%alloca, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %26 = polygeist.submap(%alloca_3, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%20, %21, %22 : memref, memref, memref) outs(%23, %24, %25, %26 : memref, memref, memref, memref) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %27 = arith.mulf %11, %in : f32 + %28 = arith.mulf %14, %out_7 : f32 + %29 = arith.addf %27, %28 : f32 + %30 = arith.mulf %15, %out_9 : f32 + %31 = arith.addf %29, %30 : f32 + %32 = arith.mulf %18, %out_8 : f32 + %33 = arith.addf %31, %32 : f32 + linalg.yield %33, %in_5, %out_9, %in_6 : f32, f32, f32, f32 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 3 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%23, %24, %25 : memref, memref, memref) outs(%26, %27, %28, %29 : memref, memref, memref, memref) { +^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %30 = arith.mulf %11, %in : f32 + %31 = arith.mulf %14, %out_7 : f32 + %32 = arith.addf %30, %31 : f32 + %33 = arith.mulf %15, %out_9 : f32 + %34 = arith.addf %32, %33 : f32 + %35 = arith.mulf %18, %out_8 : f32 + %36 = arith.addf %34, %35 : f32 + linalg.yield %36, %in_5, %out_9, %in_6 : f32, f32, f32, f32 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 4 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst_2, %alloca_3[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca_4[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %19 { + affine.store %cst_2, %alloca_3[] : memref + affine.store %cst_2, %alloca[] : memref + affine.store %cst_2, %alloca_4[] : memref + %20 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %21 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %24 = polygeist.submap(%alloca_4, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %25 = polygeist.submap(%alloca, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %26 = polygeist.submap(%alloca_3, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%20, %21, %22 : memref, memref, memref) outs(%23, %24, %25, %26 : memref, memref, memref, memref) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %27 = arith.mulf %11, %in : f32 + %28 = arith.mulf %14, %out_7 : f32 + %29 = arith.addf %27, %28 : f32 + %30 = arith.mulf %15, %out_9 : f32 + %31 = arith.addf %29, %30 : f32 + %32 = arith.mulf %18, %out_8 : f32 + %33 = arith.addf %31, %32 : f32 + linalg.yield %33, %in_5, %out_9, %in_6 : f32, f32, f32, f32 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 3 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%23, %24, %25 : memref, memref, memref) outs(%26, %27, %28, %29 : memref, memref, memref, memref) { +^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %30 = arith.mulf %11, %in : f32 + %31 = arith.mulf %14, %out_7 : f32 + %32 = arith.addf %30, %31 : f32 + %33 = arith.mulf %15, %out_9 : f32 + %34 = arith.addf %32, %33 : f32 + %35 = arith.mulf %18, %out_8 : f32 + %36 = arith.addf %34, %35 : f32 + linalg.yield %36, %in_5, %out_9, %in_6 : f32, f32, f32, f32 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 4 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst_2, %alloca_3[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca_4[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %19 { + affine.store %cst_2, %alloca_3[] : memref + affine.store %cst_2, %alloca[] : memref + affine.store %cst_2, %alloca_4[] : memref + %20 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %21 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %24 = polygeist.submap(%alloca_4, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %25 = polygeist.submap(%alloca, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %26 = polygeist.submap(%alloca_3, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%20, %21, %22 : memref, memref, memref) outs(%23, %24, %25, %26 : memref, memref, memref, memref) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %27 = arith.mulf %11, %in : f32 + %28 = arith.mulf %14, %out_7 : f32 + %29 = arith.addf %27, %28 : f32 + %30 = arith.mulf %15, %out_9 : f32 + %31 = arith.addf %29, %30 : f32 + %32 = arith.mulf %18, %out_8 : f32 + %33 = arith.addf %31, %32 : f32 + linalg.yield %33, %in_5, %out_9, %in_6 : f32, f32, f32, f32 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 3 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%23, %24, %25 : memref, memref, memref) outs(%26, %27, %28, %29 : memref, memref, memref, memref) { +^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %30 = arith.mulf %11, %in : f32 + %31 = arith.mulf %14, %out_7 : f32 + %32 = arith.addf %30, %31 : f32 + %33 = arith.mulf %15, %out_9 : f32 + %34 = arith.addf %32, %33 : f32 + %35 = arith.mulf %18, %out_8 : f32 + %36 = arith.addf %34, %35 : f32 + linalg.yield %36, %in_5, %out_9, %in_6 : f32, f32, f32, f32 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 4 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> () + Composed map: (d0) -> () + Input defined outside loop, breaking + Final lgMap: (d0) -> () +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> () + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> () + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst_2, %alloca_3[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %cst_2, %alloca_4[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + +WARNING: AffineForOpRaising didn't converge +deriche.mlir:2:3: warning: AffineForOpRaising didn't converge, continuing anyway + func.func @kernel_deriche(%arg0: i32, %arg1: i32, %arg2: f32, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +deriche.mlir:2:3: note: see current operation: +func.func @kernel_deriche(%arg0: i32, %arg1: i32, %arg2: f32, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f32 + %cst_0 = arith.constant 2.000000e+00 : f32 + %cst_1 = arith.constant -2.000000e+00 : f32 + %cst_2 = arith.constant 0.000000e+00 : f32 + %0 = arith.index_cast %arg1 : i32 to index + %1 = llvm.mlir.undef : f32 + %alloca = memref.alloca() : memref + affine.store %1, %alloca[] : memref + %alloca_3 = memref.alloca() : memref + affine.store %1, %alloca_3[] : memref + %alloca_4 = memref.alloca() : memref + affine.store %1, %alloca_4[] : memref + %2 = arith.negf %arg2 : f32 + %3 = math.exp %2 : f32 + %4 = arith.subf %cst, %3 : f32 + %5 = arith.mulf %4, %4 : f32 + %6 = arith.mulf %arg2, %cst_0 : f32 + %7 = arith.mulf %6, %3 : f32 + %8 = arith.addf %7, %cst : f32 + %9 = math.exp %6 : f32 + %10 = arith.subf %8, %9 : f32 + %11 = arith.divf %5, %10 : f32 + %12 = arith.mulf %11, %3 : f32 + %13 = arith.subf %arg2, %cst : f32 + %14 = arith.mulf %12, %13 : f32 + %15 = math.powf %cst_0, %2 : f32 + %16 = arith.mulf %arg2, %cst_1 : f32 + %17 = math.exp %16 : f32 + %18 = arith.negf %17 : f32 + %19 = arith.index_cast %arg0 : i32 to index + affine.for %arg7 = 0 to %19 { + affine.store %cst_2, %alloca_3[] : memref + affine.store %cst_2, %alloca[] : memref + affine.store %cst_2, %alloca_4[] : memref + %20 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %21 = polygeist.submap(%arg3, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg5, %arg7, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %24 = polygeist.submap(%alloca_4, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %25 = polygeist.submap(%alloca, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + %26 = polygeist.submap(%alloca_3, %0) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%20, %21, %22 : memref, memref, memref) outs(%23, %24, %25, %26 : memref, memref, memref, memref) { + ^bb0(%in: f32, %in_5: f32, %in_6: f32, %out: f32, %out_7: f32, %out_8: f32, %out_9: f32): + %27 = arith.mulf %11, %in : f32 + %28 = arith.mulf %14, %out_7 : f32 + %29 = arith.addf %27, %28 : f32 + %30 = arith.mulf %15, %out_9 : f32 + %31 = arith.addf %29, %30 : f32 + %32 = arith.mulf %18, %out_8 : f32 + %33 = arith.addf %31, %32 : f32 + linalg.yield %33, %in_5, %out_9, %in_6 : f32, f32, f32, f32 + } + } + return +} +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/doitgen.log b/polybench_results/reject_logs/doitgen.log new file mode 100644 index 000000000000..3d8581ce322c --- /dev/null +++ b/polybench_results/reject_logs/doitgen.log @@ -0,0 +1,2709 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%1)) { + %3 = affine.load %arg5[%arg8] : memref + affine.store %3, %arg3[%arg6, %arg7, %arg8] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg9) = (0) to (symbol(%1)) { + %3 = affine.load %arg3[%arg6, %arg7, %arg9] : memref + %4 = affine.load %arg4[%arg9, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg5[%arg8] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg5[%arg8] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%1)) { + affine.store %cst, %arg5[%arg8] : memref + affine.parallel (%arg9) = (0) to (symbol(%1)) { + %3 = affine.load %arg3[%arg6, %arg7, %arg9] : memref + %4 = affine.load %arg4[%arg9, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg5[%arg8] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg5[%arg8] : memref + } +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%1)) { + %3 = affine.load %arg5[%arg8] : memref + affine.store %3, %arg3[%arg6, %arg7, %arg8] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg9) = (0) to (symbol(%1)) { + %3 = affine.load %arg3[%arg6, %arg7, %arg9] : memref + %4 = affine.load %arg4[%arg9, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg5[%arg8] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg5[%arg8] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%1)) { + affine.store %cst, %arg5[%arg8] : memref + affine.for %arg9 = 0 to %1 { + %3 = affine.load %arg3[%arg6, %arg7, %arg9] : memref + %4 = affine.load %arg4[%arg9, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg5[%arg8] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg5[%arg8] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %1 { + %3 = affine.load %arg5[%arg8] : memref + affine.store %3, %arg3[%arg6, %arg7, %arg8] : memref +} + +Pattern recognition complete: + Loads: 1 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %6 = affine.load %arg5[%arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %7, %arg3[%arg6, %arg7, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0, d1, d2) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1, d0) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 1 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg9 = 0 to %1 { + %5 = affine.load %arg3[%arg6, %arg7, %arg9] : memref + %6 = affine.load %arg4[%arg9, %arg8] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg5[%arg8] : memref + %9 = arith.addf %8, %7 : f64 + affine.store %9, %arg5[%arg8] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %8 = affine.load %arg3[%arg6, %arg7, %arg9] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0, d1, d2) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1, d0) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %10 = affine.load %arg4[%arg9, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %13 = affine.load %arg5[%arg8] : memref + +--- Processing Stores --- +Processing store: affine.store %14, %arg5[%arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0] -> (s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0) + Composed map: (d0)[s0, s1] -> (s0, s1, d0) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0, s1] -> (s0, s1, d0) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0) + Composed map: (d0)[s0, s1] -> (s0, s1, d0) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0, s1] -> (s0, s1, d0) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0) + Composed map: (d0)[s0, s1] -> (s0, s1, d0) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0, s1] -> (s0, s1, d0) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0) + Composed map: (d0)[s0, s1] -> (s0, s1, d0) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0, s1] -> (s0, s1, d0) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0) + Composed map: (d0)[s0, s1] -> (s0, s1, d0) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0, s1] -> (s0, s1, d0) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0) + Composed map: (d0)[s0, s1] -> (s0, s1, d0) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0, s1] -> (s0, s1, d0) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0) + Composed map: (d0)[s0, s1] -> (s0, s1, d0) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0, s1] -> (s0, s1, d0) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0) + Composed map: (d0)[s0, s1] -> (s0, s1, d0) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0, s1] -> (s0, s1, d0) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0) + Composed map: (d0)[s0, s1] -> (s0, s1, d0) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0, s1] -> (s0, s1, d0) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0) + Composed map: (d0)[s0, s1] -> (s0, s1, d0) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0, s1] -> (s0, s1, d0) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +Processing store: affine.store %cst, %arg5[%arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +REJECTED: Linalg generic exists with loads/stores + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %6 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + %4 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + +WARNING: AffineForOpRaising didn't converge +doitgen.mlir:2:3: warning: AffineForOpRaising didn't converge, continuing anyway + func.func @kernel_doitgen(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +doitgen.mlir:2:3: note: see current operation: +func.func @kernel_doitgen(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg2 : i32 to index + %2 = arith.index_cast %arg0 : i32 to index + affine.for %arg6 = 0 to %2 { + affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to %1 { + affine.store %cst, %arg5[%arg8] : memref + %5 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg8, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } + %3 = polygeist.submap(%arg5, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg3, %arg6, %arg7, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + } + } + return +} +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/durbin.log b/polybench_results/reject_logs/durbin.log new file mode 100644 index 000000000000..ecc326fbf4cc --- /dev/null +++ b/polybench_results/reject_logs/durbin.log @@ -0,0 +1,393 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg4) = (0) to (%arg3) { + %16 = affine.load %alloca_3[%arg4] : memref<40xf64> + affine.store %16, %arg2[%arg4] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg4) = (0) to (%arg3) { + %16 = affine.load %arg2[%arg4] : memref + %17 = affine.load %arg2[%arg3 - %arg4 - 1] : memref + %18 = arith.mulf %15, %17 : f64 + %19 = arith.addf %16, %18 : f64 + affine.store %19, %alloca_3[%arg4] : memref<40xf64> +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg4) = (0) to (%arg3) { + %16 = affine.load %alloca_3[%arg4] : memref<40xf64> + affine.store %16, %arg2[%arg4] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg4) = (0) to (%arg3) { + %16 = affine.load %arg2[%arg4] : memref + %17 = affine.load %arg2[%arg3 - %arg4 - 1] : memref + %18 = arith.mulf %15, %17 : f64 + %19 = arith.addf %16, %18 : f64 + affine.store %19, %alloca_3[%arg4] : memref<40xf64> +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to affine_map<(d0) -> (d0)>(%arg3) { + %16 = affine.load %alloca_3[%arg4] : memref<40xf64> + affine.store %16, %arg2[%arg4] : memref +} + +Pattern recognition complete: + Loads: 1 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %19 = affine.load %alloca_3[%arg4] : memref<40xf64> + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %20, %arg2[%arg4] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 1 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to affine_map<(d0) -> (d0)>(%arg3) { + %18 = affine.load %arg2[%arg4] : memref + %19 = affine.load %arg2[%arg3 - %arg4 - 1] : memref + %20 = arith.mulf %15, %19 : f64 + %21 = arith.addf %18, %20 : f64 + affine.store %21, %alloca_3[%arg4] : memref<40xf64> +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %21 = affine.load %arg2[%arg4] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %23 = affine.load %arg2[%arg3 - %arg4 - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0 - d1 - 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (-d0 + s0 - 1) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %26, %alloca_3[%arg4] : memref<40xf64> + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to affine_map<(d0) -> (d0)>(%arg3) { + %21 = affine.load %arg1[%arg3 - %arg4 - 1] : memref + %22 = affine.load %arg2[%arg4] : memref + %23 = arith.mulf %21, %22 : f64 + %24 = affine.load %alloca[] : memref + %25 = arith.addf %24, %23 : f64 + affine.store %25, %alloca[] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %24 = affine.load %arg1[%arg3 - %arg4 - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0 - d1 - 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (-d0 + s0 - 1) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %26 = affine.load %arg2[%arg4] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %29 = affine.load %alloca[] : memref + +--- Processing Stores --- +Processing store: affine.store %30, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 1 to %5 { + %6 = affine.load %alloca_2[] : memref + %7 = arith.mulf %6, %6 : f64 + %8 = arith.subf %cst_0, %7 : f64 + %9 = affine.load %alloca_1[] : memref + %10 = arith.mulf %8, %9 : f64 + affine.store %10, %alloca_1[] : memref + affine.store %cst, %alloca[] : memref + %11 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (-d0 + s0 - 1)>} : (memref, index, index) -> memref + %12 = polygeist.submap(%arg2, %arg3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %13 = polygeist.submap(%alloca, %arg3) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%11, %12 : memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %24 = arith.mulf %in, %in_4 : f64 + %25 = arith.addf %out, %24 : f64 + linalg.yield %25 : f64 + } + %14 = affine.load %arg1[%arg3] : memref + %15 = affine.load %alloca[] : memref + %16 = arith.addf %14, %15 : f64 + %17 = arith.negf %16 : f64 + %18 = arith.divf %17, %10 : f64 + affine.store %18, %alloca_2[] : memref + %19 = polygeist.submap(%arg2, %arg3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %20 = polygeist.submap(%arg2, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (-d0 + s0 - 1)>} : (memref, index, index) -> memref + %21 = polygeist.submap(%alloca_3, %arg3) {map = affine_map<(d0) -> (d0)>} : (memref<40xf64>, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%19, %20 : memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %24 = arith.mulf %18, %in_4 : f64 + %25 = arith.addf %in, %24 : f64 + linalg.yield %25 : f64 + } + %22 = polygeist.submap(%alloca_3, %arg3) {map = affine_map<(d0) -> (d0)>} : (memref<40xf64>, index) -> memref + %23 = polygeist.submap(%arg2, %arg3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%22 : memref) outs(%23 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + affine.store %18, %arg2[%arg3] : memref +} + +Pattern recognition complete: + Loads: 4 + Stores: 4 + LinalgGenerics: 3 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 1 to %5 { + %6 = affine.load %alloca_2[] : memref + %7 = arith.mulf %6, %6 : f64 + %8 = arith.subf %cst_0, %7 : f64 + %9 = affine.load %alloca_1[] : memref + %10 = arith.mulf %8, %9 : f64 + affine.store %10, %alloca_1[] : memref + affine.store %cst, %alloca[] : memref + %11 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (-d0 + s0 - 1)>} : (memref, index, index) -> memref + %12 = polygeist.submap(%arg2, %arg3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %13 = polygeist.submap(%alloca, %arg3) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%11, %12 : memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %24 = arith.mulf %in, %in_4 : f64 + %25 = arith.addf %out, %24 : f64 + linalg.yield %25 : f64 + } + %14 = affine.load %arg1[%arg3] : memref + %15 = affine.load %alloca[] : memref + %16 = arith.addf %14, %15 : f64 + %17 = arith.negf %16 : f64 + %18 = arith.divf %17, %10 : f64 + affine.store %18, %alloca_2[] : memref + %19 = polygeist.submap(%arg2, %arg3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %20 = polygeist.submap(%arg2, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (-d0 + s0 - 1)>} : (memref, index, index) -> memref + %21 = polygeist.submap(%alloca_3, %arg3) {map = affine_map<(d0) -> (d0)>} : (memref<40xf64>, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%19, %20 : memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_4: f64, %out: f64): + %24 = arith.mulf %18, %in_4 : f64 + %25 = arith.addf %in, %24 : f64 + linalg.yield %25 : f64 + } + %22 = polygeist.submap(%alloca_3, %arg3) {map = affine_map<(d0) -> (d0)>} : (memref<40xf64>, index) -> memref + %23 = polygeist.submap(%arg2, %arg3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%22 : memref) outs(%23 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + affine.store %18, %arg2[%arg3] : memref +} + +Pattern recognition complete: + Loads: 4 + Stores: 4 + LinalgGenerics: 3 + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/fdtd-2d.log b/polybench_results/reject_logs/fdtd-2d.log new file mode 100644 index 000000000000..48ae885d57b4 --- /dev/null +++ b/polybench_results/reject_logs/fdtd-2d.log @@ -0,0 +1,5675 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%0) - 1) { + affine.parallel (%arg9) = (0) to (symbol(%1) - 1) { + %3 = affine.load %arg5[%arg8, %arg9] : memref + %4 = affine.load %arg3[%arg8, %arg9 + 1] : memref + %5 = affine.load %arg3[%arg8, %arg9] : memref + %6 = arith.subf %4, %5 : f64 + %7 = affine.load %arg4[%arg8 + 1, %arg9] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg4[%arg8, %arg9] : memref + %10 = arith.subf %8, %9 : f64 + %11 = arith.mulf %10, %cst_0 : f64 + %12 = arith.subf %3, %11 : f64 + affine.store %12, %arg5[%arg8, %arg9] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg9) = (0) to (symbol(%1) - 1) { + %3 = affine.load %arg5[%arg8, %arg9] : memref + %4 = affine.load %arg3[%arg8, %arg9 + 1] : memref + %5 = affine.load %arg3[%arg8, %arg9] : memref + %6 = arith.subf %4, %5 : f64 + %7 = affine.load %arg4[%arg8 + 1, %arg9] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg4[%arg8, %arg9] : memref + %10 = arith.subf %8, %9 : f64 + %11 = arith.mulf %10, %cst_0 : f64 + %12 = arith.subf %3, %11 : f64 + affine.store %12, %arg5[%arg8, %arg9] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%0)) { + affine.parallel (%arg9) = (1) to (symbol(%1)) { + %3 = affine.load %arg3[%arg8, %arg9] : memref + %4 = affine.load %arg5[%arg8, %arg9] : memref + %5 = affine.load %arg5[%arg8, %arg9 - 1] : memref + %6 = arith.subf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = arith.subf %3, %7 : f64 + affine.store %8, %arg3[%arg8, %arg9] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg9) = (1) to (symbol(%1)) { + %3 = affine.load %arg3[%arg8, %arg9] : memref + %4 = affine.load %arg5[%arg8, %arg9] : memref + %5 = affine.load %arg5[%arg8, %arg9 - 1] : memref + %6 = arith.subf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = arith.subf %3, %7 : f64 + affine.store %8, %arg3[%arg8, %arg9] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (1) to (symbol(%0)) { + affine.parallel (%arg9) = (0) to (symbol(%1)) { + %3 = affine.load %arg4[%arg8, %arg9] : memref + %4 = affine.load %arg5[%arg8, %arg9] : memref + %5 = affine.load %arg5[%arg8 - 1, %arg9] : memref + %6 = arith.subf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = arith.subf %3, %7 : f64 + affine.store %8, %arg4[%arg8, %arg9] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg9) = (0) to (symbol(%1)) { + %3 = affine.load %arg4[%arg8, %arg9] : memref + %4 = affine.load %arg5[%arg8, %arg9] : memref + %5 = affine.load %arg5[%arg8 - 1, %arg9] : memref + %6 = arith.subf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = arith.subf %3, %7 : f64 + affine.store %8, %arg4[%arg8, %arg9] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%1)) { + %3 = affine.load %arg6[%arg7] : memref + affine.store %3, %arg4[0, %arg8] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%0) - 1) { + affine.parallel (%arg9) = (0) to (symbol(%1) - 1) { + %3 = affine.load %arg5[%arg8, %arg9] : memref + %4 = affine.load %arg3[%arg8, %arg9 + 1] : memref + %5 = affine.load %arg3[%arg8, %arg9] : memref + %6 = arith.subf %4, %5 : f64 + %7 = affine.load %arg4[%arg8 + 1, %arg9] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg4[%arg8, %arg9] : memref + %10 = arith.subf %8, %9 : f64 + %11 = arith.mulf %10, %cst_0 : f64 + %12 = arith.subf %3, %11 : f64 + affine.store %12, %arg5[%arg8, %arg9] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg9) = (0) to (symbol(%1) - 1) { + %3 = affine.load %arg5[%arg8, %arg9] : memref + %4 = affine.load %arg3[%arg8, %arg9 + 1] : memref + %5 = affine.load %arg3[%arg8, %arg9] : memref + %6 = arith.subf %4, %5 : f64 + %7 = affine.load %arg4[%arg8 + 1, %arg9] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg4[%arg8, %arg9] : memref + %10 = arith.subf %8, %9 : f64 + %11 = arith.mulf %10, %cst_0 : f64 + %12 = arith.subf %3, %11 : f64 + affine.store %12, %arg5[%arg8, %arg9] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%0)) { + affine.parallel (%arg9) = (1) to (symbol(%1)) { + %3 = affine.load %arg3[%arg8, %arg9] : memref + %4 = affine.load %arg5[%arg8, %arg9] : memref + %5 = affine.load %arg5[%arg8, %arg9 - 1] : memref + %6 = arith.subf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = arith.subf %3, %7 : f64 + affine.store %8, %arg3[%arg8, %arg9] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg9) = (1) to (symbol(%1)) { + %3 = affine.load %arg3[%arg8, %arg9] : memref + %4 = affine.load %arg5[%arg8, %arg9] : memref + %5 = affine.load %arg5[%arg8, %arg9 - 1] : memref + %6 = arith.subf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = arith.subf %3, %7 : f64 + affine.store %8, %arg3[%arg8, %arg9] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (1) to (symbol(%0)) { + affine.parallel (%arg9) = (0) to (symbol(%1)) { + %3 = affine.load %arg4[%arg8, %arg9] : memref + %4 = affine.load %arg5[%arg8, %arg9] : memref + %5 = affine.load %arg5[%arg8 - 1, %arg9] : memref + %6 = arith.subf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = arith.subf %3, %7 : f64 + affine.store %8, %arg4[%arg8, %arg9] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg9) = (0) to (symbol(%1)) { + %3 = affine.load %arg4[%arg8, %arg9] : memref + %4 = affine.load %arg5[%arg8, %arg9] : memref + %5 = affine.load %arg5[%arg8 - 1, %arg9] : memref + %6 = arith.subf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = arith.subf %3, %7 : f64 + affine.store %8, %arg4[%arg8, %arg9] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%1)) { + %3 = affine.load %arg6[%arg7] : memref + affine.store %3, %arg4[0, %arg8] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.for %arg9 = 0 to affine_map<()[s0] -> (s0 - 1)>()[%1] { + %3 = affine.load %arg5[%arg8, %arg9] : memref + %4 = affine.load %arg3[%arg8, %arg9 + 1] : memref + %5 = affine.load %arg3[%arg8, %arg9] : memref + %6 = arith.subf %4, %5 : f64 + %7 = affine.load %arg4[%arg8 + 1, %arg9] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg4[%arg8, %arg9] : memref + %10 = arith.subf %8, %9 : f64 + %11 = arith.mulf %10, %cst_0 : f64 + %12 = arith.subf %3, %11 : f64 + affine.store %12, %arg5[%arg8, %arg9] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg9 = 0 to affine_map<()[s0] -> (s0 - 1)>()[%1] { + %3 = affine.load %arg5[%arg8, %arg9] : memref + %4 = affine.load %arg3[%arg8, %arg9 + 1] : memref + %5 = affine.load %arg3[%arg8, %arg9] : memref + %6 = arith.subf %4, %5 : f64 + %7 = affine.load %arg4[%arg8 + 1, %arg9] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg4[%arg8, %arg9] : memref + %10 = arith.subf %8, %9 : f64 + %11 = arith.mulf %10, %cst_0 : f64 + %12 = arith.subf %3, %11 : f64 + affine.store %12, %arg5[%arg8, %arg9] : memref +} + +Pattern recognition complete: + Loads: 5 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %6 = affine.load %arg5[%arg8, %arg9] : memref +Processing load: %7 = affine.load %arg3[%arg8, %arg9 + 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1 + 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0 + 1) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %9 = affine.load %arg3[%arg8, %arg9] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %12 = affine.load %arg4[%arg8 + 1, %arg9] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0 + 1, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0 + 1, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %15 = affine.load %arg4[%arg8, %arg9] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %19, %arg5[%arg8, %arg9] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 4 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %4 = polygeist.submap(%arg3, %arg8, %3) {map = affine_map<(d0)[s0] -> (s0, d0 + 1)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg3, %arg8, %3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg4, %arg8, %3) {map = affine_map<(d0)[s0] -> (s0 + 1, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %arg8, %3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6, %7 : memref, memref, memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %9 = arith.subf %in, %in_1 : f64 + %10 = arith.addf %9, %in_2 : f64 + %11 = arith.subf %10, %in_3 : f64 + %12 = arith.mulf %11, %cst_0 : f64 + %13 = arith.subf %out, %12 : f64 + linalg.yield %13 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7, %8, %9, %10 : memref, memref, memref, memref) outs(%11 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %12 = arith.subf %in, %in_1 : f64 + %13 = arith.addf %12, %in_2 : f64 + %14 = arith.subf %13, %in_3 : f64 + %15 = arith.mulf %14, %cst_0 : f64 + %16 = arith.subf %out, %15 : f64 + linalg.yield %16 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0 + 1) + Composed map: (d0)[s0] -> (s0, d0 + 1) + Final lgMap: (d0)[s0] -> (s0, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0 + 1, d0) + Composed map: (d0)[s0] -> (s0 + 1, d0) + Final lgMap: (d0)[s0] -> (s0 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0 + 1, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 4 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %0 { + affine.for %arg9 = 1 to %1 { + %14 = affine.load %arg3[%arg8, %arg9] : memref + %15 = affine.load %arg5[%arg8, %arg9] : memref + %16 = affine.load %arg5[%arg8, %arg9 - 1] : memref + %17 = arith.subf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.subf %14, %18 : f64 + affine.store %19, %arg3[%arg8, %arg9] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg9 = 1 to %1 { + %14 = affine.load %arg3[%arg8, %arg9] : memref + %15 = affine.load %arg5[%arg8, %arg9] : memref + %16 = affine.load %arg5[%arg8, %arg9 - 1] : memref + %17 = arith.subf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.subf %14, %18 : f64 + affine.store %19, %arg3[%arg8, %arg9] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %17 = affine.load %arg3[%arg8, %arg9] : memref +Processing load: %18 = affine.load %arg5[%arg8, %arg9] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0 + 1) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %20 = affine.load %arg5[%arg8, %arg9 - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1 - 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %24, %arg3[%arg8, %arg9] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0 + 1) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %0 { + %14 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + %15 = arith.subi %14, %c1 : index + %16 = polygeist.submap(%arg5, %arg8, %15) {map = affine_map<(d0)[s0] -> (s0, d0 + 1)>} : (memref, index, index) -> memref + %17 = polygeist.submap(%arg5, %arg8, %15) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %18 = polygeist.submap(%arg3, %arg8, %15) {map = affine_map<(d0)[s0] -> (s0, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%16, %17 : memref, memref) outs(%18 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %19 = arith.subf %in, %in_1 : f64 + %20 = arith.mulf %19, %cst : f64 + %21 = arith.subf %out, %20 : f64 + linalg.yield %21 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%19, %20 : memref, memref) outs(%21 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %22 = arith.subf %in, %in_1 : f64 + %23 = arith.mulf %22, %cst : f64 + %24 = arith.subf %out, %23 : f64 + linalg.yield %24 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0 + 1) + Composed map: (d0)[s0] -> (s0, d0 + 1) + Final lgMap: (d0)[s0] -> (s0, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0 + 1) + Composed map: (d0)[s0] -> (s0, d0 + 1) + Final lgMap: (d0)[s0] -> (s0, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 1 to %0 { + affine.for %arg9 = 0 to %1 { + %20 = affine.load %arg4[%arg8, %arg9] : memref + %21 = affine.load %arg5[%arg8, %arg9] : memref + %22 = affine.load %arg5[%arg8 - 1, %arg9] : memref + %23 = arith.subf %21, %22 : f64 + %24 = arith.mulf %23, %cst : f64 + %25 = arith.subf %20, %24 : f64 + affine.store %25, %arg4[%arg8, %arg9] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg9 = 0 to %1 { + %20 = affine.load %arg4[%arg8, %arg9] : memref + %21 = affine.load %arg5[%arg8, %arg9] : memref + %22 = affine.load %arg5[%arg8 - 1, %arg9] : memref + %23 = arith.subf %21, %22 : f64 + %24 = arith.mulf %23, %cst : f64 + %25 = arith.subf %20, %24 : f64 + affine.store %25, %arg4[%arg8, %arg9] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %23 = affine.load %arg4[%arg8, %arg9] : memref +Processing load: %24 = affine.load %arg5[%arg8, %arg9] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %26 = affine.load %arg5[%arg8 - 1, %arg9] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0 - 1, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0 - 1, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %30, %arg4[%arg8, %arg9] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 1 to %0 { + %20 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + %21 = polygeist.submap(%arg5, %arg8, %20) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %22 = polygeist.submap(%arg5, %arg8, %20) {map = affine_map<(d0)[s0] -> (s0 - 1, d0)>} : (memref, index, index) -> memref + %23 = polygeist.submap(%arg4, %arg8, %20) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%21, %22 : memref, memref) outs(%23 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %24 = arith.subf %in, %in_1 : f64 + %25 = arith.mulf %24, %cst : f64 + %26 = arith.subf %out, %25 : f64 + linalg.yield %26 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%24, %25 : memref, memref) outs(%26 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %27 = arith.subf %in, %in_1 : f64 + %28 = arith.mulf %27, %cst : f64 + %29 = arith.subf %out, %28 : f64 + linalg.yield %29 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0 - 1, d0) + Composed map: (d0)[s0] -> (s0 - 1, d0) + Final lgMap: (d0)[s0] -> (s0 - 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0 - 1, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %2 { + affine.for %arg8 = 0 to %1 { + %24 = affine.load %arg6[%arg7] : memref + affine.store %24, %arg4[0, %arg8] : memref + } + %3 = arith.subi %0, %c1 : index + %4 = polygeist.submap(%arg5, %1, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg5, %1, %3) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg4, %1, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %24 = arith.subf %in, %in_1 : f64 + %25 = arith.mulf %24, %cst : f64 + %26 = arith.subf %out, %25 : f64 + linalg.yield %26 : f64 + } + %7 = arith.subi %1, %c1 : index + %8 = polygeist.submap(%arg5, %7, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %9 = arith.subi %1, %c1 : index + %10 = polygeist.submap(%arg5, %9, %0) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %11 = arith.subi %1, %c1 : index + %12 = polygeist.submap(%arg3, %11, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%8, %10 : memref, memref) outs(%12 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %24 = arith.subf %in, %in_1 : f64 + %25 = arith.mulf %24, %cst : f64 + %26 = arith.subf %out, %25 : f64 + linalg.yield %26 : f64 + } + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %15 = polygeist.submap(%arg3, %14, %13) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %17 = polygeist.submap(%arg3, %16, %13) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %19 = polygeist.submap(%arg4, %18, %13) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %21 = polygeist.submap(%arg4, %20, %13) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %23 = polygeist.submap(%arg5, %22, %13) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%15, %17, %19, %21 : memref, memref, memref, memref) outs(%23 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %24 = arith.subf %in, %in_1 : f64 + %25 = arith.addf %24, %in_2 : f64 + %26 = arith.subf %25, %in_3 : f64 + %27 = arith.mulf %26, %cst_0 : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %1 { + %24 = affine.load %arg6[%arg7] : memref + affine.store %24, %arg4[0, %arg8] : memref +} + +Pattern recognition complete: + Loads: 1 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %27 = affine.load %arg6[%arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %28, %arg4[0, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (0, d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (0, d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 1 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %2 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + %4 = polygeist.submap(%arg6, %arg7, %3) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg4, %3) {map = affine_map<(d0) -> (0, d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4 : memref) outs(%5 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %6 = arith.subi %0, %c1 : index + %7 = polygeist.submap(%arg5, %1, %6) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg5, %1, %6) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg4, %1, %6) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %27 = arith.subf %in, %in_1 : f64 + %28 = arith.mulf %27, %cst : f64 + %29 = arith.subf %out, %28 : f64 + linalg.yield %29 : f64 + } + %10 = arith.subi %1, %c1 : index + %11 = polygeist.submap(%arg5, %10, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %12 = arith.subi %1, %c1 : index + %13 = polygeist.submap(%arg5, %12, %0) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %14 = arith.subi %1, %c1 : index + %15 = polygeist.submap(%arg3, %14, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%11, %13 : memref, memref) outs(%15 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %27 = arith.subf %in, %in_1 : f64 + %28 = arith.mulf %27, %cst : f64 + %29 = arith.subf %out, %28 : f64 + linalg.yield %29 : f64 + } + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %17 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %18 = polygeist.submap(%arg3, %17, %16) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %19 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %20 = polygeist.submap(%arg3, %19, %16) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %21 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %22 = polygeist.submap(%arg4, %21, %16) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %24 = polygeist.submap(%arg4, %23, %16) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %26 = polygeist.submap(%arg5, %25, %16) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%18, %20, %22, %24 : memref, memref, memref, memref) outs(%26 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %27 = arith.subf %in, %in_1 : f64 + %28 = arith.addf %27, %in_2 : f64 + %29 = arith.subf %28, %in_3 : f64 + %30 = arith.mulf %29, %cst_0 : f64 + %31 = arith.subf %out, %30 : f64 + linalg.yield %31 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 4 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7 : memref) outs(%8 : memref) { +^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 +} + Processing 1 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (0, d0) + Composed map: (d0) -> (0, d0) + Final lgMap: (d0) -> (0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (0, d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%14, %15 : memref, memref) outs(%16 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %34 = arith.subf %in, %in_1 : f64 + %35 = arith.mulf %34, %cst : f64 + %36 = arith.subf %out, %35 : f64 + linalg.yield %36 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%24, %26 : memref, memref) outs(%28 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %40 = arith.subf %in, %in_1 : f64 + %41 = arith.mulf %40, %cst : f64 + %42 = arith.subf %out, %41 : f64 + linalg.yield %42 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%37, %39, %41, %43 : memref, memref, memref, memref) outs(%45 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %46 = arith.subf %in, %in_1 : f64 + %47 = arith.addf %46, %in_2 : f64 + %48 = arith.subf %47, %in_3 : f64 + %49 = arith.mulf %48, %cst_0 : f64 + %50 = arith.subf %out, %49 : f64 + linalg.yield %50 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %2 { + %3 = polygeist.submap(%arg6, %arg7, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %1) {map = affine_map<(d0) -> (0, d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %5 = arith.subi %0, %c1 : index + %6 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %9 = arith.subi %1, %c1 : index + %10 = polygeist.submap(%arg5, %9, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %11 = arith.subi %1, %c1 : index + %12 = polygeist.submap(%arg5, %11, %0) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %13 = arith.subi %1, %c1 : index + %14 = polygeist.submap(%arg3, %13, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%10, %12 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %17 = polygeist.submap(%arg3, %16, %15) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %19 = polygeist.submap(%arg3, %18, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %21 = polygeist.submap(%arg4, %20, %15) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %23 = polygeist.submap(%arg4, %22, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %25 = polygeist.submap(%arg5, %24, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%17, %19, %21, %23 : memref, memref, memref, memref) outs(%25 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.addf %26, %in_2 : f64 + %28 = arith.subf %27, %in_3 : f64 + %29 = arith.mulf %28, %cst_0 : f64 + %30 = arith.subf %out, %29 : f64 + linalg.yield %30 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 4 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6 : memref) outs(%7 : memref) { +^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 +} + Processing 1 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (0, d0) + Composed map: (d0) -> (0, d0) + Final lgMap: (d0) -> (0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (0, d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%11, %12 : memref, memref) outs(%13 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %31 = arith.subf %in, %in_1 : f64 + %32 = arith.mulf %31, %cst : f64 + %33 = arith.subf %out, %32 : f64 + linalg.yield %33 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%21, %23 : memref, memref) outs(%25 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %37 = arith.subf %in, %in_1 : f64 + %38 = arith.mulf %37, %cst : f64 + %39 = arith.subf %out, %38 : f64 + linalg.yield %39 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%34, %36, %38, %40 : memref, memref, memref, memref) outs(%42 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %43 = arith.subf %in, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.subf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst_0 : f64 + %47 = arith.subf %out, %46 : f64 + linalg.yield %47 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %2 { + %3 = polygeist.submap(%arg6, %arg7, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %1) {map = affine_map<(d0) -> (0, d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %5 = arith.subi %0, %c1 : index + %6 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %9 = arith.subi %1, %c1 : index + %10 = polygeist.submap(%arg5, %9, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %11 = arith.subi %1, %c1 : index + %12 = polygeist.submap(%arg5, %11, %0) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %13 = arith.subi %1, %c1 : index + %14 = polygeist.submap(%arg3, %13, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%10, %12 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %17 = polygeist.submap(%arg3, %16, %15) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %19 = polygeist.submap(%arg3, %18, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %21 = polygeist.submap(%arg4, %20, %15) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %23 = polygeist.submap(%arg4, %22, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %25 = polygeist.submap(%arg5, %24, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%17, %19, %21, %23 : memref, memref, memref, memref) outs(%25 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.addf %26, %in_2 : f64 + %28 = arith.subf %27, %in_3 : f64 + %29 = arith.mulf %28, %cst_0 : f64 + %30 = arith.subf %out, %29 : f64 + linalg.yield %30 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 4 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6 : memref) outs(%7 : memref) { +^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 +} + Processing 1 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (0, d0) + Composed map: (d0) -> (0, d0) + Final lgMap: (d0) -> (0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (0, d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%11, %12 : memref, memref) outs(%13 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %31 = arith.subf %in, %in_1 : f64 + %32 = arith.mulf %31, %cst : f64 + %33 = arith.subf %out, %32 : f64 + linalg.yield %33 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%21, %23 : memref, memref) outs(%25 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %37 = arith.subf %in, %in_1 : f64 + %38 = arith.mulf %37, %cst : f64 + %39 = arith.subf %out, %38 : f64 + linalg.yield %39 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%34, %36, %38, %40 : memref, memref, memref, memref) outs(%42 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %43 = arith.subf %in, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.subf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst_0 : f64 + %47 = arith.subf %out, %46 : f64 + linalg.yield %47 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %2 { + %3 = polygeist.submap(%arg6, %arg7, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %1) {map = affine_map<(d0) -> (0, d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %5 = arith.subi %0, %c1 : index + %6 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %9 = arith.subi %1, %c1 : index + %10 = polygeist.submap(%arg5, %9, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %11 = arith.subi %1, %c1 : index + %12 = polygeist.submap(%arg5, %11, %0) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %13 = arith.subi %1, %c1 : index + %14 = polygeist.submap(%arg3, %13, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%10, %12 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %17 = polygeist.submap(%arg3, %16, %15) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %19 = polygeist.submap(%arg3, %18, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %21 = polygeist.submap(%arg4, %20, %15) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %23 = polygeist.submap(%arg4, %22, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %25 = polygeist.submap(%arg5, %24, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%17, %19, %21, %23 : memref, memref, memref, memref) outs(%25 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.addf %26, %in_2 : f64 + %28 = arith.subf %27, %in_3 : f64 + %29 = arith.mulf %28, %cst_0 : f64 + %30 = arith.subf %out, %29 : f64 + linalg.yield %30 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 4 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6 : memref) outs(%7 : memref) { +^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 +} + Processing 1 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (0, d0) + Composed map: (d0) -> (0, d0) + Final lgMap: (d0) -> (0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (0, d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%11, %12 : memref, memref) outs(%13 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %31 = arith.subf %in, %in_1 : f64 + %32 = arith.mulf %31, %cst : f64 + %33 = arith.subf %out, %32 : f64 + linalg.yield %33 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%21, %23 : memref, memref) outs(%25 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %37 = arith.subf %in, %in_1 : f64 + %38 = arith.mulf %37, %cst : f64 + %39 = arith.subf %out, %38 : f64 + linalg.yield %39 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%34, %36, %38, %40 : memref, memref, memref, memref) outs(%42 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %43 = arith.subf %in, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.subf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst_0 : f64 + %47 = arith.subf %out, %46 : f64 + linalg.yield %47 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %2 { + %3 = polygeist.submap(%arg6, %arg7, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %1) {map = affine_map<(d0) -> (0, d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %5 = arith.subi %0, %c1 : index + %6 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %9 = arith.subi %1, %c1 : index + %10 = polygeist.submap(%arg5, %9, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %11 = arith.subi %1, %c1 : index + %12 = polygeist.submap(%arg5, %11, %0) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %13 = arith.subi %1, %c1 : index + %14 = polygeist.submap(%arg3, %13, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%10, %12 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %17 = polygeist.submap(%arg3, %16, %15) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %19 = polygeist.submap(%arg3, %18, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %21 = polygeist.submap(%arg4, %20, %15) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %23 = polygeist.submap(%arg4, %22, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %25 = polygeist.submap(%arg5, %24, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%17, %19, %21, %23 : memref, memref, memref, memref) outs(%25 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.addf %26, %in_2 : f64 + %28 = arith.subf %27, %in_3 : f64 + %29 = arith.mulf %28, %cst_0 : f64 + %30 = arith.subf %out, %29 : f64 + linalg.yield %30 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 4 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6 : memref) outs(%7 : memref) { +^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 +} + Processing 1 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (0, d0) + Composed map: (d0) -> (0, d0) + Final lgMap: (d0) -> (0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (0, d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%11, %12 : memref, memref) outs(%13 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %31 = arith.subf %in, %in_1 : f64 + %32 = arith.mulf %31, %cst : f64 + %33 = arith.subf %out, %32 : f64 + linalg.yield %33 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%21, %23 : memref, memref) outs(%25 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %37 = arith.subf %in, %in_1 : f64 + %38 = arith.mulf %37, %cst : f64 + %39 = arith.subf %out, %38 : f64 + linalg.yield %39 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%34, %36, %38, %40 : memref, memref, memref, memref) outs(%42 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %43 = arith.subf %in, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.subf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst_0 : f64 + %47 = arith.subf %out, %46 : f64 + linalg.yield %47 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %2 { + %3 = polygeist.submap(%arg6, %arg7, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %1) {map = affine_map<(d0) -> (0, d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %5 = arith.subi %0, %c1 : index + %6 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %9 = arith.subi %1, %c1 : index + %10 = polygeist.submap(%arg5, %9, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %11 = arith.subi %1, %c1 : index + %12 = polygeist.submap(%arg5, %11, %0) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %13 = arith.subi %1, %c1 : index + %14 = polygeist.submap(%arg3, %13, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%10, %12 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %17 = polygeist.submap(%arg3, %16, %15) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %19 = polygeist.submap(%arg3, %18, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %21 = polygeist.submap(%arg4, %20, %15) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %23 = polygeist.submap(%arg4, %22, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %25 = polygeist.submap(%arg5, %24, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%17, %19, %21, %23 : memref, memref, memref, memref) outs(%25 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.addf %26, %in_2 : f64 + %28 = arith.subf %27, %in_3 : f64 + %29 = arith.mulf %28, %cst_0 : f64 + %30 = arith.subf %out, %29 : f64 + linalg.yield %30 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 4 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6 : memref) outs(%7 : memref) { +^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 +} + Processing 1 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (0, d0) + Composed map: (d0) -> (0, d0) + Final lgMap: (d0) -> (0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (0, d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%11, %12 : memref, memref) outs(%13 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %31 = arith.subf %in, %in_1 : f64 + %32 = arith.mulf %31, %cst : f64 + %33 = arith.subf %out, %32 : f64 + linalg.yield %33 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%21, %23 : memref, memref) outs(%25 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %37 = arith.subf %in, %in_1 : f64 + %38 = arith.mulf %37, %cst : f64 + %39 = arith.subf %out, %38 : f64 + linalg.yield %39 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%34, %36, %38, %40 : memref, memref, memref, memref) outs(%42 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %43 = arith.subf %in, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.subf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst_0 : f64 + %47 = arith.subf %out, %46 : f64 + linalg.yield %47 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %2 { + %3 = polygeist.submap(%arg6, %arg7, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %1) {map = affine_map<(d0) -> (0, d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %5 = arith.subi %0, %c1 : index + %6 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %9 = arith.subi %1, %c1 : index + %10 = polygeist.submap(%arg5, %9, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %11 = arith.subi %1, %c1 : index + %12 = polygeist.submap(%arg5, %11, %0) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %13 = arith.subi %1, %c1 : index + %14 = polygeist.submap(%arg3, %13, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%10, %12 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %17 = polygeist.submap(%arg3, %16, %15) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %19 = polygeist.submap(%arg3, %18, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %21 = polygeist.submap(%arg4, %20, %15) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %23 = polygeist.submap(%arg4, %22, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %25 = polygeist.submap(%arg5, %24, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%17, %19, %21, %23 : memref, memref, memref, memref) outs(%25 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.addf %26, %in_2 : f64 + %28 = arith.subf %27, %in_3 : f64 + %29 = arith.mulf %28, %cst_0 : f64 + %30 = arith.subf %out, %29 : f64 + linalg.yield %30 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 4 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6 : memref) outs(%7 : memref) { +^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 +} + Processing 1 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (0, d0) + Composed map: (d0) -> (0, d0) + Final lgMap: (d0) -> (0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (0, d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%11, %12 : memref, memref) outs(%13 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %31 = arith.subf %in, %in_1 : f64 + %32 = arith.mulf %31, %cst : f64 + %33 = arith.subf %out, %32 : f64 + linalg.yield %33 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%21, %23 : memref, memref) outs(%25 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %37 = arith.subf %in, %in_1 : f64 + %38 = arith.mulf %37, %cst : f64 + %39 = arith.subf %out, %38 : f64 + linalg.yield %39 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%34, %36, %38, %40 : memref, memref, memref, memref) outs(%42 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %43 = arith.subf %in, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.subf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst_0 : f64 + %47 = arith.subf %out, %46 : f64 + linalg.yield %47 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %2 { + %3 = polygeist.submap(%arg6, %arg7, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %1) {map = affine_map<(d0) -> (0, d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %5 = arith.subi %0, %c1 : index + %6 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %9 = arith.subi %1, %c1 : index + %10 = polygeist.submap(%arg5, %9, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %11 = arith.subi %1, %c1 : index + %12 = polygeist.submap(%arg5, %11, %0) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %13 = arith.subi %1, %c1 : index + %14 = polygeist.submap(%arg3, %13, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%10, %12 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %17 = polygeist.submap(%arg3, %16, %15) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %19 = polygeist.submap(%arg3, %18, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %21 = polygeist.submap(%arg4, %20, %15) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %23 = polygeist.submap(%arg4, %22, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %25 = polygeist.submap(%arg5, %24, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%17, %19, %21, %23 : memref, memref, memref, memref) outs(%25 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.addf %26, %in_2 : f64 + %28 = arith.subf %27, %in_3 : f64 + %29 = arith.mulf %28, %cst_0 : f64 + %30 = arith.subf %out, %29 : f64 + linalg.yield %30 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 4 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6 : memref) outs(%7 : memref) { +^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 +} + Processing 1 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (0, d0) + Composed map: (d0) -> (0, d0) + Final lgMap: (d0) -> (0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (0, d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%11, %12 : memref, memref) outs(%13 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %31 = arith.subf %in, %in_1 : f64 + %32 = arith.mulf %31, %cst : f64 + %33 = arith.subf %out, %32 : f64 + linalg.yield %33 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%21, %23 : memref, memref) outs(%25 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %37 = arith.subf %in, %in_1 : f64 + %38 = arith.mulf %37, %cst : f64 + %39 = arith.subf %out, %38 : f64 + linalg.yield %39 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%34, %36, %38, %40 : memref, memref, memref, memref) outs(%42 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %43 = arith.subf %in, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.subf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst_0 : f64 + %47 = arith.subf %out, %46 : f64 + linalg.yield %47 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %2 { + %3 = polygeist.submap(%arg6, %arg7, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %1) {map = affine_map<(d0) -> (0, d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %5 = arith.subi %0, %c1 : index + %6 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %9 = arith.subi %1, %c1 : index + %10 = polygeist.submap(%arg5, %9, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %11 = arith.subi %1, %c1 : index + %12 = polygeist.submap(%arg5, %11, %0) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %13 = arith.subi %1, %c1 : index + %14 = polygeist.submap(%arg3, %13, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%10, %12 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %17 = polygeist.submap(%arg3, %16, %15) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %19 = polygeist.submap(%arg3, %18, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %21 = polygeist.submap(%arg4, %20, %15) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %23 = polygeist.submap(%arg4, %22, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %25 = polygeist.submap(%arg5, %24, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%17, %19, %21, %23 : memref, memref, memref, memref) outs(%25 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.addf %26, %in_2 : f64 + %28 = arith.subf %27, %in_3 : f64 + %29 = arith.mulf %28, %cst_0 : f64 + %30 = arith.subf %out, %29 : f64 + linalg.yield %30 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 4 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6 : memref) outs(%7 : memref) { +^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 +} + Processing 1 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (0, d0) + Composed map: (d0) -> (0, d0) + Final lgMap: (d0) -> (0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (0, d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%11, %12 : memref, memref) outs(%13 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %31 = arith.subf %in, %in_1 : f64 + %32 = arith.mulf %31, %cst : f64 + %33 = arith.subf %out, %32 : f64 + linalg.yield %33 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%21, %23 : memref, memref) outs(%25 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %37 = arith.subf %in, %in_1 : f64 + %38 = arith.mulf %37, %cst : f64 + %39 = arith.subf %out, %38 : f64 + linalg.yield %39 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%34, %36, %38, %40 : memref, memref, memref, memref) outs(%42 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %43 = arith.subf %in, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.subf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst_0 : f64 + %47 = arith.subf %out, %46 : f64 + linalg.yield %47 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %2 { + %3 = polygeist.submap(%arg6, %arg7, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %1) {map = affine_map<(d0) -> (0, d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %5 = arith.subi %0, %c1 : index + %6 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %9 = arith.subi %1, %c1 : index + %10 = polygeist.submap(%arg5, %9, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %11 = arith.subi %1, %c1 : index + %12 = polygeist.submap(%arg5, %11, %0) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %13 = arith.subi %1, %c1 : index + %14 = polygeist.submap(%arg3, %13, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%10, %12 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %17 = polygeist.submap(%arg3, %16, %15) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %19 = polygeist.submap(%arg3, %18, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %21 = polygeist.submap(%arg4, %20, %15) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %23 = polygeist.submap(%arg4, %22, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %25 = polygeist.submap(%arg5, %24, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%17, %19, %21, %23 : memref, memref, memref, memref) outs(%25 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.addf %26, %in_2 : f64 + %28 = arith.subf %27, %in_3 : f64 + %29 = arith.mulf %28, %cst_0 : f64 + %30 = arith.subf %out, %29 : f64 + linalg.yield %30 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 4 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6 : memref) outs(%7 : memref) { +^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 +} + Processing 1 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (0, d0) + Composed map: (d0) -> (0, d0) + Final lgMap: (d0) -> (0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (0, d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%11, %12 : memref, memref) outs(%13 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %31 = arith.subf %in, %in_1 : f64 + %32 = arith.mulf %31, %cst : f64 + %33 = arith.subf %out, %32 : f64 + linalg.yield %33 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%21, %23 : memref, memref) outs(%25 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %37 = arith.subf %in, %in_1 : f64 + %38 = arith.mulf %37, %cst : f64 + %39 = arith.subf %out, %38 : f64 + linalg.yield %39 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%34, %36, %38, %40 : memref, memref, memref, memref) outs(%42 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %43 = arith.subf %in, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.subf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst_0 : f64 + %47 = arith.subf %out, %46 : f64 + linalg.yield %47 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %2 { + %3 = polygeist.submap(%arg6, %arg7, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %1) {map = affine_map<(d0) -> (0, d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %5 = arith.subi %0, %c1 : index + %6 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %9 = arith.subi %1, %c1 : index + %10 = polygeist.submap(%arg5, %9, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %11 = arith.subi %1, %c1 : index + %12 = polygeist.submap(%arg5, %11, %0) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %13 = arith.subi %1, %c1 : index + %14 = polygeist.submap(%arg3, %13, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%10, %12 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %17 = polygeist.submap(%arg3, %16, %15) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %19 = polygeist.submap(%arg3, %18, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %21 = polygeist.submap(%arg4, %20, %15) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %23 = polygeist.submap(%arg4, %22, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %25 = polygeist.submap(%arg5, %24, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%17, %19, %21, %23 : memref, memref, memref, memref) outs(%25 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.addf %26, %in_2 : f64 + %28 = arith.subf %27, %in_3 : f64 + %29 = arith.mulf %28, %cst_0 : f64 + %30 = arith.subf %out, %29 : f64 + linalg.yield %30 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 4 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6 : memref) outs(%7 : memref) { +^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 +} + Processing 1 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (0, d0) + Composed map: (d0) -> (0, d0) + Final lgMap: (d0) -> (0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (0, d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%11, %12 : memref, memref) outs(%13 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %31 = arith.subf %in, %in_1 : f64 + %32 = arith.mulf %31, %cst : f64 + %33 = arith.subf %out, %32 : f64 + linalg.yield %33 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%21, %23 : memref, memref) outs(%25 : memref) { +^bb0(%in: f64, %in_1: f64, %out: f64): + %37 = arith.subf %in, %in_1 : f64 + %38 = arith.mulf %37, %cst : f64 + %39 = arith.subf %out, %38 : f64 + linalg.yield %39 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%34, %36, %38, %40 : memref, memref, memref, memref) outs(%42 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %43 = arith.subf %in, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.subf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst_0 : f64 + %47 = arith.subf %out, %46 : f64 + linalg.yield %47 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + +WARNING: AffineForOpRaising didn't converge +fdtd-2d.mlir:3:3: warning: AffineForOpRaising didn't converge, continuing anyway + func.func @kernel_fdtd_2d(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +fdtd-2d.mlir:3:3: note: see current operation: +func.func @kernel_fdtd_2d(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: memref, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 5.000000e-01 : f64 + %cst_0 = arith.constant 0.69999999999999996 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg2 : i32 to index + %2 = arith.index_cast %arg0 : i32 to index + affine.for %arg7 = 0 to %2 { + %3 = polygeist.submap(%arg6, %arg7, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %1) {map = affine_map<(d0) -> (0, d0)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) { + ^bb0(%in: f64, %out: f64): + linalg.yield %in : f64 + } + %5 = arith.subi %0, %c1 : index + %6 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %1, %5) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %1, %5) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %9 = arith.subi %1, %c1 : index + %10 = polygeist.submap(%arg5, %9, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %11 = arith.subi %1, %c1 : index + %12 = polygeist.submap(%arg5, %11, %0) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %13 = arith.subi %1, %c1 : index + %14 = polygeist.submap(%arg3, %13, %0) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%10, %12 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_1: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.mulf %26, %cst : f64 + %28 = arith.subf %out, %27 : f64 + linalg.yield %28 : f64 + } + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %17 = polygeist.submap(%arg3, %16, %15) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %19 = polygeist.submap(%arg3, %18, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %21 = polygeist.submap(%arg4, %20, %15) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %23 = polygeist.submap(%arg4, %22, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %25 = polygeist.submap(%arg5, %24, %15) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%17, %19, %21, %23 : memref, memref, memref, memref) outs(%25 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %26 = arith.subf %in, %in_1 : f64 + %27 = arith.addf %26, %in_2 : f64 + %28 = arith.subf %27, %in_3 : f64 + %29 = arith.mulf %28, %cst_0 : f64 + %30 = arith.subf %out, %29 : f64 + linalg.yield %30 : f64 + } + } + return +} +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/floyd-warshall.log b/polybench_results/reject_logs/floyd-warshall.log new file mode 100644 index 000000000000..0d737af89cf8 --- /dev/null +++ b/polybench_results/reject_logs/floyd-warshall.log @@ -0,0 +1,420 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to %0 { + affine.for %arg4 = 0 to %0 { + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg3, %arg2] : memref + %3 = affine.load %arg1[%arg2, %arg4] : memref + %4 = arith.addi %2, %3 : i32 + %5 = arith.cmpi slt, %1, %4 : i32 + %6 = arith.select %5, %1, %4 : i32 + affine.store %6, %arg1[%arg3, %arg4] : memref + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to %0 { + affine.for %arg4 = 0 to %0 { + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg3, %arg2] : memref + %3 = affine.load %arg1[%arg2, %arg4] : memref + %4 = arith.addi %2, %3 : i32 + %5 = arith.cmpi slt, %1, %4 : i32 + %6 = arith.select %5, %1, %4 : i32 + affine.store %6, %arg1[%arg3, %arg4] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %0 { + %1 = affine.load %arg1[%arg3, %arg4] : memref + %2 = affine.load %arg1[%arg3, %arg2] : memref + %3 = affine.load %arg1[%arg2, %arg4] : memref + %4 = arith.addi %2, %3 : i32 + %5 = arith.cmpi slt, %1, %4 : i32 + %6 = arith.select %5, %1, %4 : i32 + affine.store %6, %arg1[%arg3, %arg4] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %4 = affine.load %arg1[%arg3, %arg4] : memref +Processing load: %5 = affine.load %arg1[%arg3, %arg2] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %7 = affine.load %arg1[%arg2, %arg4] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %11, %arg1[%arg3, %arg4] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to %0 { + %1 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %2 = polygeist.submap(%arg1, %arg3, %arg2, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg3, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.addi %in, %in_0 : i32 + %6 = arith.cmpi slt, %out, %5 : i32 + %7 = arith.select %6, %out, %5 : i32 + linalg.yield %7 : i32 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to %0 { + %1 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %2 = polygeist.submap(%arg1, %arg3, %arg2, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg3, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = arith.addi %in, %in_0 : i32 + %6 = arith.cmpi slt, %out, %5 : i32 + %7 = arith.select %6, %out, %5 : i32 + linalg.yield %7 : i32 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { +^bb0(%in: i32, %in_0: i32, %out: i32): + %8 = arith.addi %in, %in_0 : i32 + %9 = arith.cmpi slt, %out, %8 : i32 + %10 = arith.select %9, %out, %8 : i32 + linalg.yield %10 : i32 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (d1, s0) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %2 = polygeist.submap(%arg1, %arg2, %0, %1) {map = affine_map<(d0, d1)[s0] -> (d1, s0)>} : (memref, index, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %0, %1) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + %4 = polygeist.submap(%arg1, %0, %1) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: i32, %in_0: i32, %out: i32): + %5 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %6 = arith.addi %in, %in_0 : i32 + %7 = arith.cmpi slt, %out, %6 : i32 + %8 = arith.select %7, %out, %6 : i32 + linalg.yield %8 : i32 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { +^bb0(%in: i32, %in_0: i32, %out: i32): + %8 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %9 = arith.addi %in, %in_0 : i32 + %10 = arith.cmpi slt, %out, %9 : i32 + %11 = arith.select %10, %out, %9 : i32 + linalg.yield %11 : i32 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (d1, s0) + Composed map: (d0, d1)[s0] -> (d1, s0) + Final lgMap: (d0, d1)[s0] -> (d1, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (d1, s0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d0) + Composed map: (d0, d1)[s0] -> (s0, d0) + Final lgMap: (d0, d1)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Extending iterator types from nested linalg.generic +Total iterator types: 3 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/gemm.log b/polybench_results/reject_logs/gemm.log new file mode 100644 index 000000000000..6898bbbda49a --- /dev/null +++ b/polybench_results/reject_logs/gemm.log @@ -0,0 +1,735 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg10) = (0) to (symbol(%0)) { + %3 = affine.load %arg6[%arg8, %arg9] : memref + %4 = arith.mulf %arg3, %3 : f64 + %5 = affine.load %arg7[%arg9, %arg10] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg5[%arg8, %arg10] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg5[%arg8, %arg10] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%2)) { + affine.parallel (%arg9) = (0) to (symbol(%0)) { + %3 = affine.load %arg5[%arg8, %arg9] : memref + %4 = arith.mulf %3, %arg4 : f64 + affine.store %4, %arg5[%arg8, %arg9] : memref + } + affine.for %arg9 = 0 to %1 { + affine.parallel (%arg10) = (0) to (symbol(%0)) { + %3 = affine.load %arg6[%arg8, %arg9] : memref + %4 = arith.mulf %arg3, %3 : f64 + %5 = affine.load %arg7[%arg9, %arg10] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg5[%arg8, %arg10] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg5[%arg8, %arg10] : memref + } + } +} +Found 2 nested loops to fission + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%2)) { + affine.for %arg9 = 0 to %1 { + affine.parallel (%arg10) = (0) to (symbol(%0)) { + %3 = affine.load %arg6[%arg8, %arg9] : memref + %4 = arith.mulf %arg3, %3 : f64 + %5 = affine.load %arg7[%arg9, %arg10] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg5[%arg8, %arg10] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg5[%arg8, %arg10] : memref + } + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg9) = (0) to (symbol(%0)) { + %3 = affine.load %arg5[%arg8, %arg9] : memref + %4 = arith.mulf %3, %arg4 : f64 + affine.store %4, %arg5[%arg8, %arg9] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%2)) { + affine.parallel (%arg9) = (0) to (symbol(%0)) { + %3 = affine.load %arg5[%arg8, %arg9] : memref + %4 = arith.mulf %3, %arg4 : f64 + affine.store %4, %arg5[%arg8, %arg9] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%2)) { + affine.for %arg9 = 0 to %1 { + affine.parallel (%arg10) = (0) to (symbol(%0)) { + %3 = affine.load %arg6[%arg8, %arg9] : memref + %4 = arith.mulf %arg3, %3 : f64 + %5 = affine.load %arg7[%arg9, %arg10] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg5[%arg8, %arg10] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg5[%arg8, %arg10] : memref + } + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg10) = (0) to (symbol(%0)) { + %3 = affine.load %arg6[%arg8, %arg9] : memref + %4 = arith.mulf %arg3, %3 : f64 + %5 = affine.load %arg7[%arg9, %arg10] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg5[%arg8, %arg10] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg5[%arg8, %arg10] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%2)) { + affine.parallel (%arg9) = (0) to (symbol(%0)) { + %3 = affine.load %arg5[%arg8, %arg9] : memref + %4 = arith.mulf %3, %arg4 : f64 + affine.store %4, %arg5[%arg8, %arg9] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg9) = (0) to (symbol(%0)) { + %3 = affine.load %arg5[%arg8, %arg9] : memref + %4 = arith.mulf %3, %arg4 : f64 + affine.store %4, %arg5[%arg8, %arg9] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%2)) { + affine.for %arg9 = 0 to %1 { + affine.parallel (%arg10) = (0) to (symbol(%0)) { + %3 = affine.load %arg6[%arg8, %arg9] : memref + %4 = arith.mulf %arg3, %3 : f64 + %5 = affine.load %arg7[%arg9, %arg10] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg5[%arg8, %arg10] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg5[%arg8, %arg10] : memref + } + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%2)) { + affine.parallel (%arg9) = (0) to (symbol(%0)) { + %3 = affine.load %arg5[%arg8, %arg9] : memref + %4 = arith.mulf %3, %arg4 : f64 + affine.store %4, %arg5[%arg8, %arg9] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg9) = (0) to (symbol(%0)) { + %3 = affine.load %arg5[%arg8, %arg9] : memref + %4 = arith.mulf %3, %arg4 : f64 + affine.store %4, %arg5[%arg8, %arg9] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg10) = (0) to (symbol(%0)) { + %3 = affine.load %arg6[%arg8, %arg9] : memref + %4 = arith.mulf %arg3, %3 : f64 + %5 = affine.load %arg7[%arg9, %arg10] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg5[%arg8, %arg10] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg5[%arg8, %arg10] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %2 { + affine.for %arg9 = 0 to %1 { + affine.for %arg10 = 0 to %0 { + %3 = affine.load %arg6[%arg8, %arg9] : memref + %4 = arith.mulf %arg3, %3 : f64 + %5 = affine.load %arg7[%arg9, %arg10] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg5[%arg8, %arg10] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg5[%arg8, %arg10] : memref + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg9 = 0 to %1 { + affine.for %arg10 = 0 to %0 { + %3 = affine.load %arg6[%arg8, %arg9] : memref + %4 = arith.mulf %arg3, %3 : f64 + %5 = affine.load %arg7[%arg9, %arg10] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg5[%arg8, %arg10] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg5[%arg8, %arg10] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg10 = 0 to %0 { + %3 = affine.load %arg6[%arg8, %arg9] : memref + %4 = arith.mulf %arg3, %3 : f64 + %5 = affine.load %arg7[%arg9, %arg10] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg5[%arg8, %arg10] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg5[%arg8, %arg10] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %6 = affine.load %arg6[%arg8, %arg9] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %9 = affine.load %arg7[%arg9, %arg10] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %12 = affine.load %arg5[%arg8, %arg10] : memref + +--- Processing Stores --- +Processing store: affine.store %13, %arg5[%arg8, %arg10] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %2 { + affine.for %arg9 = 0 to %1 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %4 = polygeist.submap(%arg6, %arg8, %arg9, %3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %5 = polygeist.submap(%arg7, %arg9, %3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg5, %arg8, %3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg3, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg9 = 0 to %1 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %4 = polygeist.submap(%arg6, %arg8, %arg9, %3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %5 = polygeist.submap(%arg7, %arg9, %3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg5, %arg8, %3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %arg3, %in : f64 + %8 = arith.mulf %7, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %arg3, %in : f64 + %11 = arith.mulf %10, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %2 { + %3 = affine.apply affine_map<()[s0] -> (s0)>()[%1] + %4 = polygeist.submap(%arg6, %arg8, %0, %3) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %5 = polygeist.submap(%arg7, %0, %3) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg5, %arg8, %0, %3) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %8 = arith.mulf %arg3, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %11 = arith.mulf %arg3, %in : f64 + %12 = arith.mulf %11, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1) + Composed map: (d0, d1)[s0] -> (s0, d1) + Final lgMap: (d0, d1)[s0] -> (s0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2, d1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d0) + Composed map: (d0, d1)[s0] -> (s0, d0) + Final lgMap: (d0, d1)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d0) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 3 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %2 { + affine.for %arg9 = 0 to %0 { + %6 = affine.load %arg5[%arg8, %arg9] : memref + %7 = arith.mulf %6, %arg4 : f64 + affine.store %7, %arg5[%arg8, %arg9] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg9 = 0 to %0 { + %6 = affine.load %arg5[%arg8, %arg9] : memref + %7 = arith.mulf %6, %arg4 : f64 + affine.store %7, %arg5[%arg8, %arg9] : memref +} + +Pattern recognition complete: + Loads: 1 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %9 = affine.load %arg5[%arg8, %arg9] : memref + +--- Processing Stores --- +Processing store: affine.store %10, %arg5[%arg8, %arg9] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 0 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %2 { + %6 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %7 = polygeist.submap(%arg5, %arg8, %6) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%7 : memref) { + ^bb0(%out: f64): + %8 = arith.mulf %out, %arg4 : f64 + linalg.yield %8 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%10 : memref) { +^bb0(%out: f64): + %11 = arith.mulf %out, %arg4 : f64 + linalg.yield %11 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 0 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/gemver.log b/polybench_results/reject_logs/gemver.log new file mode 100644 index 000000000000..4813c6afc294 --- /dev/null +++ b/polybench_results/reject_logs/gemver.log @@ -0,0 +1,1060 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%0)) { + affine.parallel (%arg13) = (0) to (symbol(%0)) { + %1 = affine.load %arg8[%arg12] : memref + %2 = affine.load %arg3[%arg12, %arg13] : memref + %3 = arith.mulf %arg1, %2 : f64 + %4 = affine.load %arg9[%arg13] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %1, %5 : f64 + affine.store %6, %arg8[%arg12] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg13) = (0) to (symbol(%0)) { + %1 = affine.load %arg8[%arg12] : memref + %2 = affine.load %arg3[%arg12, %arg13] : memref + %3 = arith.mulf %arg1, %2 : f64 + %4 = affine.load %arg9[%arg13] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %1, %5 : f64 + affine.store %6, %arg8[%arg12] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%0)) { + %1 = affine.load %arg9[%arg12] : memref + %2 = affine.load %arg11[%arg12] : memref + %3 = arith.addf %1, %2 : f64 + affine.store %3, %arg9[%arg12] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%0)) { + affine.parallel (%arg13) = (0) to (symbol(%0)) { + %1 = affine.load %arg9[%arg12] : memref + %2 = affine.load %arg3[%arg13, %arg12] : memref + %3 = arith.mulf %arg2, %2 : f64 + %4 = affine.load %arg10[%arg13] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %1, %5 : f64 + affine.store %6, %arg9[%arg12] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg13) = (0) to (symbol(%0)) { + %1 = affine.load %arg9[%arg12] : memref + %2 = affine.load %arg3[%arg13, %arg12] : memref + %3 = arith.mulf %arg2, %2 : f64 + %4 = affine.load %arg10[%arg13] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %1, %5 : f64 + affine.store %6, %arg9[%arg12] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%0)) { + affine.parallel (%arg13) = (0) to (symbol(%0)) { + %1 = affine.load %arg3[%arg12, %arg13] : memref + %2 = affine.load %arg4[%arg12] : memref + %3 = affine.load %arg5[%arg13] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + %6 = affine.load %arg6[%arg12] : memref + %7 = affine.load %arg7[%arg13] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = arith.addf %5, %8 : f64 + affine.store %9, %arg3[%arg12, %arg13] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg13) = (0) to (symbol(%0)) { + %1 = affine.load %arg3[%arg12, %arg13] : memref + %2 = affine.load %arg4[%arg12] : memref + %3 = affine.load %arg5[%arg13] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + %6 = affine.load %arg6[%arg12] : memref + %7 = affine.load %arg7[%arg13] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = arith.addf %5, %8 : f64 + affine.store %9, %arg3[%arg12, %arg13] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%0)) { + affine.parallel (%arg13) = (0) to (symbol(%0)) { + %1 = affine.load %arg8[%arg12] : memref + %2 = affine.load %arg3[%arg12, %arg13] : memref + %3 = arith.mulf %arg1, %2 : f64 + %4 = affine.load %arg9[%arg13] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %1, %5 : f64 + affine.store %6, %arg8[%arg12] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg13) = (0) to (symbol(%0)) { + %1 = affine.load %arg8[%arg12] : memref + %2 = affine.load %arg3[%arg12, %arg13] : memref + %3 = arith.mulf %arg1, %2 : f64 + %4 = affine.load %arg9[%arg13] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %1, %5 : f64 + affine.store %6, %arg8[%arg12] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%0)) { + %1 = affine.load %arg9[%arg12] : memref + %2 = affine.load %arg11[%arg12] : memref + %3 = arith.addf %1, %2 : f64 + affine.store %3, %arg9[%arg12] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%0)) { + affine.parallel (%arg13) = (0) to (symbol(%0)) { + %1 = affine.load %arg9[%arg12] : memref + %2 = affine.load %arg3[%arg13, %arg12] : memref + %3 = arith.mulf %arg2, %2 : f64 + %4 = affine.load %arg10[%arg13] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %1, %5 : f64 + affine.store %6, %arg9[%arg12] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg13) = (0) to (symbol(%0)) { + %1 = affine.load %arg9[%arg12] : memref + %2 = affine.load %arg3[%arg13, %arg12] : memref + %3 = arith.mulf %arg2, %2 : f64 + %4 = affine.load %arg10[%arg13] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %1, %5 : f64 + affine.store %6, %arg9[%arg12] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg12) = (0) to (symbol(%0)) { + affine.parallel (%arg13) = (0) to (symbol(%0)) { + %1 = affine.load %arg3[%arg12, %arg13] : memref + %2 = affine.load %arg4[%arg12] : memref + %3 = affine.load %arg5[%arg13] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + %6 = affine.load %arg6[%arg12] : memref + %7 = affine.load %arg7[%arg13] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = arith.addf %5, %8 : f64 + affine.store %9, %arg3[%arg12, %arg13] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg13) = (0) to (symbol(%0)) { + %1 = affine.load %arg3[%arg12, %arg13] : memref + %2 = affine.load %arg4[%arg12] : memref + %3 = affine.load %arg5[%arg13] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + %6 = affine.load %arg6[%arg12] : memref + %7 = affine.load %arg7[%arg13] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = arith.addf %5, %8 : f64 + affine.store %9, %arg3[%arg12, %arg13] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %0 { + %1 = affine.load %arg8[%arg12] : memref + %2 = affine.load %arg3[%arg12, %arg13] : memref + %3 = arith.mulf %arg1, %2 : f64 + %4 = affine.load %arg9[%arg13] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %1, %5 : f64 + affine.store %6, %arg8[%arg12] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %0 { + %1 = affine.load %arg8[%arg12] : memref + %2 = affine.load %arg3[%arg12, %arg13] : memref + %3 = arith.mulf %arg1, %2 : f64 + %4 = affine.load %arg9[%arg13] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %1, %5 : f64 + affine.store %6, %arg8[%arg12] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %4 = affine.load %arg8[%arg12] : memref +Processing load: %5 = affine.load %arg3[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %8 = affine.load %arg9[%arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %11, %arg8[%arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0] -> (s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + %1 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %2 = polygeist.submap(%arg3, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg9, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg8, %arg12, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %arg1, %in : f64 + %6 = arith.mulf %5, %in_0 : f64 + %7 = arith.addf %out, %6 : f64 + linalg.yield %7 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg1, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + %4 = affine.load %arg9[%arg12] : memref + %5 = affine.load %arg11[%arg12] : memref + %6 = arith.addf %4, %5 : f64 + affine.store %6, %arg9[%arg12] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %7 = affine.load %arg9[%arg12] : memref +Processing load: %8 = affine.load %arg11[%arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %10, %arg9[%arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 1 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %0 { + %6 = affine.load %arg9[%arg12] : memref + %7 = affine.load %arg3[%arg13, %arg12] : memref + %8 = arith.mulf %arg2, %7 : f64 + %9 = affine.load %arg10[%arg13] : memref + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %6, %10 : f64 + affine.store %11, %arg9[%arg12] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %0 { + %6 = affine.load %arg9[%arg12] : memref + %7 = affine.load %arg3[%arg13, %arg12] : memref + %8 = arith.mulf %arg2, %7 : f64 + %9 = affine.load %arg10[%arg13] : memref + %10 = arith.mulf %8, %9 : f64 + %11 = arith.addf %6, %10 : f64 + affine.store %11, %arg9[%arg12] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %9 = affine.load %arg9[%arg12] : memref +Processing load: %10 = affine.load %arg3[%arg13, %arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %13 = affine.load %arg10[%arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %16, %arg9[%arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0] -> (s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + %6 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %7 = polygeist.submap(%arg3, %arg12, %6) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg10, %6) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %9 = polygeist.submap(%arg9, %arg12, %6) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %arg2, %in : f64 + %11 = arith.mulf %10, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%10, %11 : memref, memref) outs(%12 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %13 = arith.mulf %arg2, %in : f64 + %14 = arith.mulf %13, %in_0 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + affine.for %arg13 = 0 to %0 { + %9 = affine.load %arg3[%arg12, %arg13] : memref + %10 = affine.load %arg4[%arg12] : memref + %11 = affine.load %arg5[%arg13] : memref + %12 = arith.mulf %10, %11 : f64 + %13 = arith.addf %9, %12 : f64 + %14 = affine.load %arg6[%arg12] : memref + %15 = affine.load %arg7[%arg13] : memref + %16 = arith.mulf %14, %15 : f64 + %17 = arith.addf %13, %16 : f64 + affine.store %17, %arg3[%arg12, %arg13] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg13 = 0 to %0 { + %9 = affine.load %arg3[%arg12, %arg13] : memref + %10 = affine.load %arg4[%arg12] : memref + %11 = affine.load %arg5[%arg13] : memref + %12 = arith.mulf %10, %11 : f64 + %13 = arith.addf %9, %12 : f64 + %14 = affine.load %arg6[%arg12] : memref + %15 = affine.load %arg7[%arg13] : memref + %16 = arith.mulf %14, %15 : f64 + %17 = arith.addf %13, %16 : f64 + affine.store %17, %arg3[%arg12, %arg13] : memref +} + +Pattern recognition complete: + Loads: 5 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %12 = affine.load %arg3[%arg12, %arg13] : memref +Processing load: %13 = affine.load %arg4[%arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %15 = affine.load %arg5[%arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %19 = affine.load %arg6[%arg12] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %21 = affine.load %arg7[%arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %24, %arg3[%arg12, %arg13] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 4 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg12 = 0 to %0 { + %9 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %10 = polygeist.submap(%arg4, %arg12, %9) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %11 = polygeist.submap(%arg5, %9) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %12 = polygeist.submap(%arg6, %arg12, %9) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + %13 = polygeist.submap(%arg7, %9) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %14 = polygeist.submap(%arg3, %arg12, %9) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%10, %11, %12, %13 : memref, memref, memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.addf %out, %15 : f64 + %17 = arith.mulf %in_1, %in_2 : f64 + %18 = arith.addf %16, %17 : f64 + linalg.yield %18 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%13, %14, %15, %16 : memref, memref, memref, memref) outs(%17 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %18 = arith.mulf %in, %in_0 : f64 + %19 = arith.addf %out, %18 : f64 + %20 = arith.mulf %in_1, %in_2 : f64 + %21 = arith.addf %19, %20 : f64 + linalg.yield %21 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 4 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/gesummv.log b/polybench_results/reject_logs/gesummv.log new file mode 100644 index 000000000000..71610412446f --- /dev/null +++ b/polybench_results/reject_logs/gesummv.log @@ -0,0 +1,180 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg9) = (0) to (symbol(%0)) { + %6 = affine.load %arg3[%arg8, %arg9] : memref + %7 = affine.load %arg6[%arg9] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %arg5[%arg8] : memref + %10 = arith.addf %8, %9 : f64 + affine.store %10, %arg5[%arg8] : memref + %11 = affine.load %arg4[%arg8, %arg9] : memref + %12 = affine.load %arg6[%arg9] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = affine.load %arg7[%arg8] : memref + %15 = arith.addf %13, %14 : f64 + affine.store %15, %arg7[%arg8] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%0)) { + affine.store %cst, %arg5[%arg8] : memref + affine.store %cst, %arg7[%arg8] : memref + affine.parallel (%arg9) = (0) to (symbol(%0)) { + %6 = affine.load %arg3[%arg8, %arg9] : memref + %7 = affine.load %arg6[%arg9] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %arg5[%arg8] : memref + %10 = arith.addf %8, %9 : f64 + affine.store %10, %arg5[%arg8] : memref + %11 = affine.load %arg4[%arg8, %arg9] : memref + %12 = affine.load %arg6[%arg9] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = affine.load %arg7[%arg8] : memref + %15 = arith.addf %13, %14 : f64 + affine.store %15, %arg7[%arg8] : memref + } + %1 = affine.load %arg5[%arg8] : memref + %2 = arith.mulf %arg1, %1 : f64 + %3 = affine.load %arg7[%arg8] : memref + %4 = arith.mulf %arg2, %3 : f64 + %5 = arith.addf %2, %4 : f64 + affine.store %5, %arg7[%arg8] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg9) = (0) to (symbol(%0)) { + %6 = affine.load %arg3[%arg8, %arg9] : memref + %7 = affine.load %arg6[%arg9] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %arg5[%arg8] : memref + %10 = arith.addf %8, %9 : f64 + affine.store %10, %arg5[%arg8] : memref + %11 = affine.load %arg4[%arg8, %arg9] : memref + %12 = affine.load %arg6[%arg9] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = affine.load %arg7[%arg8] : memref + %15 = arith.addf %13, %14 : f64 + affine.store %15, %arg7[%arg8] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (symbol(%0)) { + affine.store %cst, %arg5[%arg8] : memref + affine.store %cst, %arg7[%arg8] : memref + affine.for %arg9 = 0 to %0 { + %6 = affine.load %arg3[%arg8, %arg9] : memref + %7 = affine.load %arg6[%arg9] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %arg5[%arg8] : memref + %10 = arith.addf %8, %9 : f64 + affine.store %10, %arg5[%arg8] : memref + %11 = affine.load %arg4[%arg8, %arg9] : memref + %12 = affine.load %arg6[%arg9] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = affine.load %arg7[%arg8] : memref + %15 = arith.addf %13, %14 : f64 + affine.store %15, %arg7[%arg8] : memref + } + %1 = affine.load %arg5[%arg8] : memref + %2 = arith.mulf %arg1, %1 : f64 + %3 = affine.load %arg7[%arg8] : memref + %4 = arith.mulf %arg2, %3 : f64 + %5 = arith.addf %2, %4 : f64 + affine.store %5, %arg7[%arg8] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg9 = 0 to %0 { + %6 = affine.load %arg3[%arg8, %arg9] : memref + %7 = affine.load %arg6[%arg9] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %arg5[%arg8] : memref + %10 = arith.addf %8, %9 : f64 + affine.store %10, %arg5[%arg8] : memref + %11 = affine.load %arg4[%arg8, %arg9] : memref + %12 = affine.load %arg6[%arg9] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = affine.load %arg7[%arg8] : memref + %15 = arith.addf %13, %14 : f64 + affine.store %15, %arg7[%arg8] : memref +} + +Pattern recognition complete: + Loads: 6 + Stores: 2 + LinalgGenerics: 0 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %0 { + affine.store %cst, %arg5[%arg8] : memref + affine.store %cst, %arg7[%arg8] : memref + affine.for %arg9 = 0 to %0 { + %6 = affine.load %arg3[%arg8, %arg9] : memref + %7 = affine.load %arg6[%arg9] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %arg5[%arg8] : memref + %10 = arith.addf %8, %9 : f64 + affine.store %10, %arg5[%arg8] : memref + %11 = affine.load %arg4[%arg8, %arg9] : memref + %12 = affine.load %arg6[%arg9] : memref + %13 = arith.mulf %11, %12 : f64 + %14 = affine.load %arg7[%arg8] : memref + %15 = arith.addf %13, %14 : f64 + affine.store %15, %arg7[%arg8] : memref + } + %1 = affine.load %arg5[%arg8] : memref + %2 = arith.mulf %arg1, %1 : f64 + %3 = affine.load %arg7[%arg8] : memref + %4 = arith.mulf %arg2, %3 : f64 + %5 = arith.addf %2, %4 : f64 + affine.store %5, %arg7[%arg8] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/gramschmidt.log b/polybench_results/reject_logs/gramschmidt.log new file mode 100644 index 000000000000..64fbcdacb7a3 --- /dev/null +++ b/polybench_results/reject_logs/gramschmidt.log @@ -0,0 +1,625 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + %4 = affine.load %arg2[%arg7, %arg6] : memref + %5 = affine.load %arg4[%arg7, %arg5] : memref + %6 = affine.load %arg3[%arg5, %arg6] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.subf %4, %7 : f64 + affine.store %8, %arg2[%arg7, %arg6] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + %4 = affine.load %arg4[%arg7, %arg5] : memref + %5 = affine.load %arg2[%arg7, %arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg3[%arg5, %arg6] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg3[%arg5, %arg6] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (%arg5 + 1) to (symbol(%0)) { + affine.store %cst, %arg3[%arg5, %arg6] : memref + affine.parallel (%arg7) = (0) to (symbol(%1)) { + %4 = affine.load %arg4[%arg7, %arg5] : memref + %5 = affine.load %arg2[%arg7, %arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg3[%arg5, %arg6] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg3[%arg5, %arg6] : memref + } + affine.parallel (%arg7) = (0) to (symbol(%1)) { + %4 = affine.load %arg2[%arg7, %arg6] : memref + %5 = affine.load %arg4[%arg7, %arg5] : memref + %6 = affine.load %arg3[%arg5, %arg6] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.subf %4, %7 : f64 + affine.store %8, %arg2[%arg7, %arg6] : memref + } +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%1)) { + %4 = affine.load %arg2[%arg6, %arg5] : memref + %5 = affine.load %arg3[%arg5, %arg5] : memref + %6 = arith.divf %4, %5 : f64 + affine.store %6, %arg4[%arg6, %arg5] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + %4 = affine.load %arg2[%arg7, %arg6] : memref + %5 = affine.load %arg4[%arg7, %arg5] : memref + %6 = affine.load %arg3[%arg5, %arg6] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.subf %4, %7 : f64 + affine.store %8, %arg2[%arg7, %arg6] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + %4 = affine.load %arg4[%arg7, %arg5] : memref + %5 = affine.load %arg2[%arg7, %arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg3[%arg5, %arg6] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg3[%arg5, %arg6] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg6) = (%arg5 + 1) to (symbol(%0)) { + affine.store %cst, %arg3[%arg5, %arg6] : memref + affine.for %arg7 = 0 to %1 { + %4 = affine.load %arg4[%arg7, %arg5] : memref + %5 = affine.load %arg2[%arg7, %arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg3[%arg5, %arg6] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg3[%arg5, %arg6] : memref + } + affine.for %arg7 = 0 to %1 { + %4 = affine.load %arg2[%arg7, %arg6] : memref + %5 = affine.load %arg4[%arg7, %arg5] : memref + %6 = affine.load %arg3[%arg5, %arg6] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.subf %4, %7 : f64 + affine.store %8, %arg2[%arg7, %arg6] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%1)) { + %4 = affine.load %arg2[%arg6, %arg5] : memref + %5 = affine.load %arg3[%arg5, %arg5] : memref + %6 = arith.divf %4, %5 : f64 + affine.store %6, %arg4[%arg6, %arg5] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %4 = affine.load %arg2[%arg7, %arg6] : memref + %5 = affine.load %arg4[%arg7, %arg5] : memref + %6 = affine.load %arg3[%arg5, %arg6] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.subf %4, %7 : f64 + affine.store %8, %arg2[%arg7, %arg6] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %7 = affine.load %arg2[%arg7, %arg6] : memref +Processing load: %8 = affine.load %arg4[%arg7, %arg5] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %10 = affine.load %arg3[%arg5, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %13, %arg2[%arg7, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %7 = affine.load %arg4[%arg7, %arg5] : memref + %8 = affine.load %arg2[%arg7, %arg6] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = affine.load %arg3[%arg5, %arg6] : memref + %11 = arith.addf %10, %9 : f64 + affine.store %11, %arg3[%arg5, %arg6] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %10 = affine.load %arg4[%arg7, %arg5] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %12 = affine.load %arg2[%arg7, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %15 = affine.load %arg3[%arg5, %arg6] : memref + +--- Processing Stores --- +Processing store: affine.store %16, %arg3[%arg5, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = affine_map<(d0) -> (d0 + 1)>(%arg5) to %0 { + affine.store %cst, %arg3[%arg5, %arg6] : memref + %4 = polygeist.submap(%arg4, %arg5, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg2, %arg6, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg3, %arg5, %arg6, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } + %7 = polygeist.submap(%arg4, %arg5, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg3, %arg5, %arg6, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %9 = polygeist.submap(%arg2, %arg6, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7, %8 : memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.subf %out, %10 : f64 + linalg.yield %11 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 2 + +REJECTED: Loop doesn't have constant lower bound + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %4 = affine.load %arg2[%arg6, %arg5] : memref + %5 = affine.load %arg3[%arg5, %arg5] : memref + %6 = arith.divf %4, %5 : f64 + affine.store %6, %arg4[%arg6, %arg5] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %7 = affine.load %arg2[%arg6, %arg5] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %9 = affine.load %arg3[%arg5, %arg5] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0, d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %11, %arg4[%arg6, %arg5] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %7 = affine.load %alloca[] : memref + %8 = affine.load %arg2[%arg6, %arg5] : memref + %9 = arith.mulf %8, %8 : f64 + %10 = arith.addf %7, %9 : f64 + affine.store %10, %alloca[] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %10 = affine.load %alloca[] : memref +Processing load: %11 = affine.load %arg2[%arg6, %arg5] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %14, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 1 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 0 to %0 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %2 = polygeist.submap(%arg2, %arg5, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%alloca, %1) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + %9 = arith.mulf %in, %in : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %4 = affine.load %alloca[] : memref + %5 = math.sqrt %4 : f64 + affine.store %5, %arg3[%arg5, %arg5] : memref + %6 = polygeist.submap(%arg2, %arg5, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg3, %arg5, %1) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %arg5, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.divf %in, %in_0 : f64 + linalg.yield %9 : f64 + } + affine.for %arg6 = affine_map<(d0) -> (d0 + 1)>(%arg5) to %0 { + affine.store %cst, %arg3[%arg5, %arg6] : memref + %9 = polygeist.submap(%arg4, %arg5, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %10 = polygeist.submap(%arg2, %arg6, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %11 = polygeist.submap(%arg3, %arg5, %arg6, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%9, %10 : memref, memref) outs(%11 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 + } + %12 = polygeist.submap(%arg4, %arg5, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %13 = polygeist.submap(%arg3, %arg5, %arg6, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %14 = polygeist.submap(%arg2, %arg6, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%12, %13 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.subf %out, %15 : f64 + linalg.yield %16 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = affine_map<(d0) -> (d0 + 1)>(%arg5) to %0 { + affine.store %cst, %arg3[%arg5, %arg6] : memref + %9 = polygeist.submap(%arg4, %arg5, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %10 = polygeist.submap(%arg2, %arg6, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %11 = polygeist.submap(%arg3, %arg5, %arg6, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%9, %10 : memref, memref) outs(%11 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 + } + %12 = polygeist.submap(%arg4, %arg5, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %13 = polygeist.submap(%arg3, %arg5, %arg6, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %14 = polygeist.submap(%arg2, %arg6, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%12, %13 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.subf %out, %15 : f64 + linalg.yield %16 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 1 + LinalgGenerics: 2 + +REJECTED: Loop doesn't have constant lower bound + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 0 to %0 { + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %2 = polygeist.submap(%arg2, %arg5, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%alloca, %1) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2 : memref) outs(%3 : memref) { + ^bb0(%in: f64, %out: f64): + %9 = arith.mulf %in, %in : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + %4 = affine.load %alloca[] : memref + %5 = math.sqrt %4 : f64 + affine.store %5, %arg3[%arg5, %arg5] : memref + %6 = polygeist.submap(%arg2, %arg5, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg3, %arg5, %1) {map = affine_map<(d0)[s0] -> (s0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %arg5, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.divf %in, %in_0 : f64 + linalg.yield %9 : f64 + } + affine.for %arg6 = affine_map<(d0) -> (d0 + 1)>(%arg5) to %0 { + affine.store %cst, %arg3[%arg5, %arg6] : memref + %9 = polygeist.submap(%arg4, %arg5, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %10 = polygeist.submap(%arg2, %arg6, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %11 = polygeist.submap(%arg3, %arg5, %arg6, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%9, %10 : memref, memref) outs(%11 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 + } + %12 = polygeist.submap(%arg4, %arg5, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %13 = polygeist.submap(%arg3, %arg5, %arg6, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %14 = polygeist.submap(%arg2, %arg6, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%12, %13 : memref, memref) outs(%14 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %15 = arith.mulf %in, %in_0 : f64 + %16 = arith.subf %out, %15 : f64 + linalg.yield %16 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/heat-3d.log b/polybench_results/reject_logs/heat-3d.log new file mode 100644 index 000000000000..2acfc499fadf --- /dev/null +++ b/polybench_results/reject_logs/heat-3d.log @@ -0,0 +1,7948 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg5) = (1) to (symbol(%0) - 1) { + affine.parallel (%arg6) = (1) to (symbol(%0) - 1) { + affine.parallel (%arg7) = (1) to (symbol(%0) - 1) { + %1 = affine.load %arg3[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg3[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg3[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg3[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg3[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg3[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg3[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg2[%arg5, %arg6, %arg7] : memref + } + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (1) to (symbol(%0) - 1) { + affine.parallel (%arg7) = (1) to (symbol(%0) - 1) { + %1 = affine.load %arg3[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg3[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg3[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg3[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg3[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg3[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg3[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg2[%arg5, %arg6, %arg7] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (1) to (symbol(%0) - 1) { + %1 = affine.load %arg3[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg3[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg3[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg3[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg3[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg3[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg3[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg2[%arg5, %arg6, %arg7] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg5) = (1) to (symbol(%0) - 1) { + affine.parallel (%arg6) = (1) to (symbol(%0) - 1) { + affine.parallel (%arg7) = (1) to (symbol(%0) - 1) { + %1 = affine.load %arg2[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg2[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg2[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg2[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg2[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg2[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg2[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg3[%arg5, %arg6, %arg7] : memref + } + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (1) to (symbol(%0) - 1) { + affine.parallel (%arg7) = (1) to (symbol(%0) - 1) { + %1 = affine.load %arg2[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg2[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg2[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg2[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg2[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg2[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg2[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg3[%arg5, %arg6, %arg7] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (1) to (symbol(%0) - 1) { + %1 = affine.load %arg2[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg2[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg2[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg2[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg2[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg2[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg2[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg3[%arg5, %arg6, %arg7] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg5) = (1) to (symbol(%0) - 1) { + affine.parallel (%arg6) = (1) to (symbol(%0) - 1) { + affine.parallel (%arg7) = (1) to (symbol(%0) - 1) { + %1 = affine.load %arg3[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg3[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg3[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg3[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg3[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg3[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg3[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg2[%arg5, %arg6, %arg7] : memref + } + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg6) = (1) to (symbol(%0) - 1) { + affine.parallel (%arg7) = (1) to (symbol(%0) - 1) { + %1 = affine.load %arg3[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg3[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg3[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg3[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg3[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg3[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg3[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg2[%arg5, %arg6, %arg7] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (1) to (symbol(%0) - 1) { + %1 = affine.load %arg3[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg3[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg3[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg3[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg3[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg3[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg3[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg2[%arg5, %arg6, %arg7] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg5) = (1) to (symbol(%0) - 1) { + affine.parallel (%arg6) = (1) to (symbol(%0) - 1) { + affine.parallel (%arg7) = (1) to (symbol(%0) - 1) { + %1 = affine.load %arg2[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg2[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg2[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg2[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg2[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg2[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg2[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg3[%arg5, %arg6, %arg7] : memref + } + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg6) = (1) to (symbol(%0) - 1) { + affine.parallel (%arg7) = (1) to (symbol(%0) - 1) { + %1 = affine.load %arg2[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg2[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg2[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg2[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg2[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg2[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg2[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg3[%arg5, %arg6, %arg7] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (1) to (symbol(%0) - 1) { + %1 = affine.load %arg2[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg2[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg2[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg2[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg2[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg2[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg2[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg3[%arg5, %arg6, %arg7] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.for %arg7 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %1 = affine.load %arg3[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg3[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg3[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg3[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg3[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg3[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg3[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg2[%arg5, %arg6, %arg7] : memref + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.for %arg7 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %1 = affine.load %arg3[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg3[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg3[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg3[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg3[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg3[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg3[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg2[%arg5, %arg6, %arg7] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %1 = affine.load %arg3[%arg5 + 1, %arg6, %arg7] : memref + %2 = affine.load %arg3[%arg5, %arg6, %arg7] : memref + %3 = arith.mulf %2, %cst_0 : f64 + %4 = arith.subf %1, %3 : f64 + %5 = affine.load %arg3[%arg5 - 1, %arg6, %arg7] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + %8 = affine.load %arg3[%arg5, %arg6 + 1, %arg7] : memref + %9 = arith.subf %8, %3 : f64 + %10 = affine.load %arg3[%arg5, %arg6 - 1, %arg7] : memref + %11 = arith.addf %9, %10 : f64 + %12 = arith.mulf %11, %cst : f64 + %13 = arith.addf %7, %12 : f64 + %14 = affine.load %arg3[%arg5, %arg6, %arg7 + 1] : memref + %15 = arith.subf %14, %3 : f64 + %16 = affine.load %arg3[%arg5, %arg6, %arg7 - 1] : memref + %17 = arith.addf %15, %16 : f64 + %18 = arith.mulf %17, %cst : f64 + %19 = arith.addf %13, %18 : f64 + %20 = arith.addf %19, %2 : f64 + affine.store %20, %arg2[%arg5, %arg6, %arg7] : memref +} + +Pattern recognition complete: + Loads: 7 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %4 = affine.load %arg3[%arg5 + 1, %arg6, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0 + 1, d1, d2) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0 + 1, s1, d0 + 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %6 = affine.load %arg3[%arg5, %arg6, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0, d1, d2) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1, d0 + 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %10 = affine.load %arg3[%arg5 - 1, %arg6, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0 - 1, d1, d2) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0 - 1, s1, d0 + 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %14 = affine.load %arg3[%arg5, %arg6 + 1, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0, d1 + 1, d2) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1 + 1, d0 + 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %17 = affine.load %arg3[%arg5, %arg6 - 1, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0, d1 - 1, d2) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1 - 1, d0 + 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %22 = affine.load %arg3[%arg5, %arg6, %arg7 + 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0, d1, d2 + 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1, d0 + 2) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %25 = affine.load %arg3[%arg5, %arg6, %arg7 - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0, d1, d2 - 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1, d0) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %30, %arg2[%arg5, %arg6, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0, d1, d2) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1, d0 + 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 7 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = polygeist.submap(%arg3, %arg5, %arg6, %2) {map = affine_map<(d0)[s0, s1] -> (s0 + 1, s1, d0 + 1)>} : (memref, index, index, index) -> memref + %4 = polygeist.submap(%arg3, %arg5, %arg6, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0 + 1)>} : (memref, index, index, index) -> memref + %5 = polygeist.submap(%arg3, %arg5, %arg6, %2) {map = affine_map<(d0)[s0, s1] -> (s0 - 1, s1, d0 + 1)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg3, %arg5, %arg6, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg3, %arg5, %arg6, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1 - 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = polygeist.submap(%arg3, %arg5, %arg6, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0 + 2)>} : (memref, index, index, index) -> memref + %9 = polygeist.submap(%arg3, %arg5, %arg6, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %10 = polygeist.submap(%arg2, %arg5, %arg6, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3, %4, %5, %6, %7, %8, %9 : memref, memref, memref, memref, memref, memref, memref) outs(%10 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %11 = arith.mulf %in_1, %cst_0 : f64 + %12 = arith.subf %in, %11 : f64 + %13 = arith.addf %12, %in_2 : f64 + %14 = arith.mulf %13, %cst : f64 + %15 = arith.subf %in_3, %11 : f64 + %16 = arith.addf %15, %in_4 : f64 + %17 = arith.mulf %16, %cst : f64 + %18 = arith.addf %14, %17 : f64 + %19 = arith.subf %in_5, %11 : f64 + %20 = arith.addf %19, %in_6 : f64 + %21 = arith.mulf %20, %cst : f64 + %22 = arith.addf %18, %21 : f64 + %23 = arith.addf %22, %in_1 : f64 + linalg.yield %23 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = polygeist.submap(%arg3, %arg5, %arg6, %2) {map = affine_map<(d0)[s0, s1] -> (s0 + 1, s1, d0 + 1)>} : (memref, index, index, index) -> memref + %4 = polygeist.submap(%arg3, %arg5, %arg6, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0 + 1)>} : (memref, index, index, index) -> memref + %5 = polygeist.submap(%arg3, %arg5, %arg6, %2) {map = affine_map<(d0)[s0, s1] -> (s0 - 1, s1, d0 + 1)>} : (memref, index, index, index) -> memref + %6 = polygeist.submap(%arg3, %arg5, %arg6, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg3, %arg5, %arg6, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1 - 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = polygeist.submap(%arg3, %arg5, %arg6, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0 + 2)>} : (memref, index, index, index) -> memref + %9 = polygeist.submap(%arg3, %arg5, %arg6, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %10 = polygeist.submap(%arg2, %arg5, %arg6, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3, %4, %5, %6, %7, %8, %9 : memref, memref, memref, memref, memref, memref, memref) outs(%10 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %11 = arith.mulf %in_1, %cst_0 : f64 + %12 = arith.subf %in, %11 : f64 + %13 = arith.addf %12, %in_2 : f64 + %14 = arith.mulf %13, %cst : f64 + %15 = arith.subf %in_3, %11 : f64 + %16 = arith.addf %15, %in_4 : f64 + %17 = arith.mulf %16, %cst : f64 + %18 = arith.addf %14, %17 : f64 + %19 = arith.subf %in_5, %11 : f64 + %20 = arith.addf %19, %in_6 : f64 + %21 = arith.mulf %20, %cst : f64 + %22 = arith.addf %18, %21 : f64 + %23 = arith.addf %22, %in_1 : f64 + linalg.yield %23 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6, %7, %8, %9, %10, %11, %12 : memref, memref, memref, memref, memref, memref, memref) outs(%13 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %14 = arith.mulf %in_1, %cst_0 : f64 + %15 = arith.subf %in, %14 : f64 + %16 = arith.addf %15, %in_2 : f64 + %17 = arith.mulf %16, %cst : f64 + %18 = arith.subf %in_3, %14 : f64 + %19 = arith.addf %18, %in_4 : f64 + %20 = arith.mulf %19, %cst : f64 + %21 = arith.addf %17, %20 : f64 + %22 = arith.subf %in_5, %14 : f64 + %23 = arith.addf %22, %in_6 : f64 + %24 = arith.mulf %23, %cst : f64 + %25 = arith.addf %21, %24 : f64 + %26 = arith.addf %25, %in_1 : f64 + linalg.yield %26 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0 + 1, s1, d0 + 1) + Composed map: (d0)[s0, s1] -> (s0 + 1, s1, d0 + 1) + Final lgMap: (d0)[s0, s1] -> (s0 + 1, s1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0 + 1, s1, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0 + 1, d1 + 1, d0 + 1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0 + 1) + Composed map: (d0)[s0, s1] -> (s0, s1, d0 + 1) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0 - 1, s1, d0 + 1) + Composed map: (d0)[s0, s1] -> (s0 - 1, s1, d0 + 1) + Final lgMap: (d0)[s0, s1] -> (s0 - 1, s1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0 - 1, s1, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0 - 1, d1 + 1, d0 + 1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1 + 1, d0 + 1) + Composed map: (d0)[s0, s1] -> (s0, s1 + 1, d0 + 1) + Final lgMap: (d0)[s0, s1] -> (s0, s1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1 + 1, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1 + 2, d0 + 1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1 - 1, d0 + 1) + Composed map: (d0)[s0, s1] -> (s0, s1 - 1, d0 + 1) + Final lgMap: (d0)[s0, s1] -> (s0, s1 - 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1 - 1, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1, d0 + 1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0 + 2) + Composed map: (d0)[s0, s1] -> (s0, s1, d0 + 2) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1 + 1, d0 + 2) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0) + Composed map: (d0)[s0, s1] -> (s0, s1, d0) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1 + 1, d0) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0 + 1) + Composed map: (d0)[s0, s1] -> (s0, s1, d0 + 1) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 7 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %4 = arith.subi %3, %c1 : index + %5 = polygeist.submap(%arg3, %arg5, %4, %2) {map = affine_map<(d0, d1)[s0] -> (s0 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %6 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %7 = arith.subi %6, %c1 : index + %8 = polygeist.submap(%arg3, %arg5, %7, %2) {map = affine_map<(d0, d1)[s0] -> (s0, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %9 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %10 = arith.subi %9, %c1 : index + %11 = polygeist.submap(%arg3, %arg5, %10, %2) {map = affine_map<(d0, d1)[s0] -> (s0 - 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %12 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %13 = arith.subi %12, %c1 : index + %14 = polygeist.submap(%arg3, %arg5, %13, %2) {map = affine_map<(d0, d1)[s0] -> (s0, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg3, %arg5, %16, %2) {map = affine_map<(d0, d1)[s0] -> (s0, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %19 = arith.subi %18, %c1 : index + %20 = polygeist.submap(%arg3, %arg5, %19, %2) {map = affine_map<(d0, d1)[s0] -> (s0, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %21 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %22 = arith.subi %21, %c1 : index + %23 = polygeist.submap(%arg3, %arg5, %22, %2) {map = affine_map<(d0, d1)[s0] -> (s0, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %25 = arith.subi %24, %c1 : index + %26 = polygeist.submap(%arg2, %arg5, %25, %2) {map = affine_map<(d0, d1)[s0] -> (s0, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%5, %8, %11, %14, %17, %20, %23 : memref, memref, memref, memref, memref, memref, memref) outs(%26 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %27 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %28 = arith.mulf %in_1, %cst_0 : f64 + %29 = arith.subf %in, %28 : f64 + %30 = arith.addf %29, %in_2 : f64 + %31 = arith.mulf %30, %cst : f64 + %32 = arith.subf %in_3, %28 : f64 + %33 = arith.addf %32, %in_4 : f64 + %34 = arith.mulf %33, %cst : f64 + %35 = arith.addf %31, %34 : f64 + %36 = arith.subf %in_5, %28 : f64 + %37 = arith.addf %36, %in_6 : f64 + %38 = arith.mulf %37, %cst : f64 + %39 = arith.addf %35, %38 : f64 + %40 = arith.addf %39, %in_1 : f64 + linalg.yield %40 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%8, %11, %14, %17, %20, %23, %26 : memref, memref, memref, memref, memref, memref, memref) outs(%29 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.mulf %in_1, %cst_0 : f64 + %32 = arith.subf %in, %31 : f64 + %33 = arith.addf %32, %in_2 : f64 + %34 = arith.mulf %33, %cst : f64 + %35 = arith.subf %in_3, %31 : f64 + %36 = arith.addf %35, %in_4 : f64 + %37 = arith.mulf %36, %cst : f64 + %38 = arith.addf %34, %37 : f64 + %39 = arith.subf %in_5, %31 : f64 + %40 = arith.addf %39, %in_6 : f64 + %41 = arith.mulf %40, %cst : f64 + %42 = arith.addf %38, %41 : f64 + %43 = arith.addf %42, %in_1 : f64 + linalg.yield %43 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1)[s0] -> (s0 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1)[s0] -> (s0 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0 + 1, d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) + Composed map: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) + Final lgMap: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0 - 1, d1 + 1, d0 + 1) + Composed map: (d0, d1)[s0] -> (s0 - 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1)[s0] -> (s0 - 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0 - 1, d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1 + 2, d0 + 1) + Composed map: (d0, d1)[s0] -> (s0, d1 + 2, d0 + 1) + Final lgMap: (d0, d1)[s0] -> (s0, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1, d0 + 1) + Composed map: (d0, d1)[s0] -> (s0, d1, d0 + 1) + Final lgMap: (d0, d1)[s0] -> (s0, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 2) + Composed map: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 2) + Final lgMap: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1 + 1, d0) + Composed map: (d0, d1)[s0] -> (s0, d1 + 1, d0) + Final lgMap: (d0, d1)[s0] -> (s0, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) + Composed map: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) + Final lgMap: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 3 +Total inputs: 7 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 1 to 21 { + affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.for %arg7 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %43 = affine.load %arg2[%arg5 + 1, %arg6, %arg7] : memref + %44 = affine.load %arg2[%arg5, %arg6, %arg7] : memref + %45 = arith.mulf %44, %cst_0 : f64 + %46 = arith.subf %43, %45 : f64 + %47 = affine.load %arg2[%arg5 - 1, %arg6, %arg7] : memref + %48 = arith.addf %46, %47 : f64 + %49 = arith.mulf %48, %cst : f64 + %50 = affine.load %arg2[%arg5, %arg6 + 1, %arg7] : memref + %51 = arith.subf %50, %45 : f64 + %52 = affine.load %arg2[%arg5, %arg6 - 1, %arg7] : memref + %53 = arith.addf %51, %52 : f64 + %54 = arith.mulf %53, %cst : f64 + %55 = arith.addf %49, %54 : f64 + %56 = affine.load %arg2[%arg5, %arg6, %arg7 + 1] : memref + %57 = arith.subf %56, %45 : f64 + %58 = affine.load %arg2[%arg5, %arg6, %arg7 - 1] : memref + %59 = arith.addf %57, %58 : f64 + %60 = arith.mulf %59, %cst : f64 + %61 = arith.addf %55, %60 : f64 + %62 = arith.addf %61, %44 : f64 + affine.store %62, %arg3[%arg5, %arg6, %arg7] : memref + } + } + } + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %6 = arith.subi %5, %c1 : index + %7 = polygeist.submap(%arg3, %4, %6, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg3, %9, %11, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg3, %14, %16, %2) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %21 = arith.subi %20, %c1 : index + %22 = polygeist.submap(%arg3, %19, %21, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg3, %24, %26, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %28 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg3, %29, %31, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %36 = arith.subi %35, %c1 : index + %37 = polygeist.submap(%arg3, %34, %36, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %38 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %39 = arith.subi %38, %c1 : index + %40 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg2, %39, %41, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%7, %12, %17, %22, %27, %32, %37 : memref, memref, memref, memref, memref, memref, memref) outs(%42 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %43 = arith.mulf %in_1, %cst_0 : f64 + %44 = arith.subf %in, %43 : f64 + %45 = arith.addf %44, %in_2 : f64 + %46 = arith.mulf %45, %cst : f64 + %47 = arith.subf %in_3, %43 : f64 + %48 = arith.addf %47, %in_4 : f64 + %49 = arith.mulf %48, %cst : f64 + %50 = arith.addf %46, %49 : f64 + %51 = arith.subf %in_5, %43 : f64 + %52 = arith.addf %51, %in_6 : f64 + %53 = arith.mulf %52, %cst : f64 + %54 = arith.addf %50, %53 : f64 + %55 = arith.addf %54, %in_1 : f64 + linalg.yield %55 : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.for %arg7 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %43 = affine.load %arg2[%arg5 + 1, %arg6, %arg7] : memref + %44 = affine.load %arg2[%arg5, %arg6, %arg7] : memref + %45 = arith.mulf %44, %cst_0 : f64 + %46 = arith.subf %43, %45 : f64 + %47 = affine.load %arg2[%arg5 - 1, %arg6, %arg7] : memref + %48 = arith.addf %46, %47 : f64 + %49 = arith.mulf %48, %cst : f64 + %50 = affine.load %arg2[%arg5, %arg6 + 1, %arg7] : memref + %51 = arith.subf %50, %45 : f64 + %52 = affine.load %arg2[%arg5, %arg6 - 1, %arg7] : memref + %53 = arith.addf %51, %52 : f64 + %54 = arith.mulf %53, %cst : f64 + %55 = arith.addf %49, %54 : f64 + %56 = affine.load %arg2[%arg5, %arg6, %arg7 + 1] : memref + %57 = arith.subf %56, %45 : f64 + %58 = affine.load %arg2[%arg5, %arg6, %arg7 - 1] : memref + %59 = arith.addf %57, %58 : f64 + %60 = arith.mulf %59, %cst : f64 + %61 = arith.addf %55, %60 : f64 + %62 = arith.addf %61, %44 : f64 + affine.store %62, %arg3[%arg5, %arg6, %arg7] : memref + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.for %arg7 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %43 = affine.load %arg2[%arg5 + 1, %arg6, %arg7] : memref + %44 = affine.load %arg2[%arg5, %arg6, %arg7] : memref + %45 = arith.mulf %44, %cst_0 : f64 + %46 = arith.subf %43, %45 : f64 + %47 = affine.load %arg2[%arg5 - 1, %arg6, %arg7] : memref + %48 = arith.addf %46, %47 : f64 + %49 = arith.mulf %48, %cst : f64 + %50 = affine.load %arg2[%arg5, %arg6 + 1, %arg7] : memref + %51 = arith.subf %50, %45 : f64 + %52 = affine.load %arg2[%arg5, %arg6 - 1, %arg7] : memref + %53 = arith.addf %51, %52 : f64 + %54 = arith.mulf %53, %cst : f64 + %55 = arith.addf %49, %54 : f64 + %56 = affine.load %arg2[%arg5, %arg6, %arg7 + 1] : memref + %57 = arith.subf %56, %45 : f64 + %58 = affine.load %arg2[%arg5, %arg6, %arg7 - 1] : memref + %59 = arith.addf %57, %58 : f64 + %60 = arith.mulf %59, %cst : f64 + %61 = arith.addf %55, %60 : f64 + %62 = arith.addf %61, %44 : f64 + affine.store %62, %arg3[%arg5, %arg6, %arg7] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %43 = affine.load %arg2[%arg5 + 1, %arg6, %arg7] : memref + %44 = affine.load %arg2[%arg5, %arg6, %arg7] : memref + %45 = arith.mulf %44, %cst_0 : f64 + %46 = arith.subf %43, %45 : f64 + %47 = affine.load %arg2[%arg5 - 1, %arg6, %arg7] : memref + %48 = arith.addf %46, %47 : f64 + %49 = arith.mulf %48, %cst : f64 + %50 = affine.load %arg2[%arg5, %arg6 + 1, %arg7] : memref + %51 = arith.subf %50, %45 : f64 + %52 = affine.load %arg2[%arg5, %arg6 - 1, %arg7] : memref + %53 = arith.addf %51, %52 : f64 + %54 = arith.mulf %53, %cst : f64 + %55 = arith.addf %49, %54 : f64 + %56 = affine.load %arg2[%arg5, %arg6, %arg7 + 1] : memref + %57 = arith.subf %56, %45 : f64 + %58 = affine.load %arg2[%arg5, %arg6, %arg7 - 1] : memref + %59 = arith.addf %57, %58 : f64 + %60 = arith.mulf %59, %cst : f64 + %61 = arith.addf %55, %60 : f64 + %62 = arith.addf %61, %44 : f64 + affine.store %62, %arg3[%arg5, %arg6, %arg7] : memref +} + +Pattern recognition complete: + Loads: 7 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %46 = affine.load %arg2[%arg5 + 1, %arg6, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0 + 1, d1, d2) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0 + 1, s1, d0 + 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %48 = affine.load %arg2[%arg5, %arg6, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0, d1, d2) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1, d0 + 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %52 = affine.load %arg2[%arg5 - 1, %arg6, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0 - 1, d1, d2) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0 - 1, s1, d0 + 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %56 = affine.load %arg2[%arg5, %arg6 + 1, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0, d1 + 1, d2) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1 + 1, d0 + 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %59 = affine.load %arg2[%arg5, %arg6 - 1, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0, d1 - 1, d2) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1 - 1, d0 + 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %64 = affine.load %arg2[%arg5, %arg6, %arg7 + 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0, d1, d2 + 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1, d0 + 2) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %67 = affine.load %arg2[%arg5, %arg6, %arg7 - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0, d1, d2 - 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1, d0) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %72, %arg3[%arg5, %arg6, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d0, d1, d2) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1, d0 + 1) + validDims: 1, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 7 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 1 to 21 { + affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0 + 1, s1, d0 + 1)>} : (memref, index, index, index) -> memref + %46 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0 + 1)>} : (memref, index, index, index) -> memref + %47 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0 - 1, s1, d0 + 1)>} : (memref, index, index, index) -> memref + %48 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %49 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1 - 1, d0 + 1)>} : (memref, index, index, index) -> memref + %50 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0 + 2)>} : (memref, index, index, index) -> memref + %51 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %52 = polygeist.submap(%arg3, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%45, %46, %47, %48, %49, %50, %51 : memref, memref, memref, memref, memref, memref, memref) outs(%52 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %53 = arith.mulf %in_1, %cst_0 : f64 + %54 = arith.subf %in, %53 : f64 + %55 = arith.addf %54, %in_2 : f64 + %56 = arith.mulf %55, %cst : f64 + %57 = arith.subf %in_3, %53 : f64 + %58 = arith.addf %57, %in_4 : f64 + %59 = arith.mulf %58, %cst : f64 + %60 = arith.addf %56, %59 : f64 + %61 = arith.subf %in_5, %53 : f64 + %62 = arith.addf %61, %in_6 : f64 + %63 = arith.mulf %62, %cst : f64 + %64 = arith.addf %60, %63 : f64 + %65 = arith.addf %64, %in_1 : f64 + linalg.yield %65 : f64 + } + } + } + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %6 = arith.subi %5, %c1 : index + %7 = polygeist.submap(%arg3, %4, %6, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg3, %9, %11, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg3, %14, %16, %2) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %21 = arith.subi %20, %c1 : index + %22 = polygeist.submap(%arg3, %19, %21, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg3, %24, %26, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %28 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg3, %29, %31, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %36 = arith.subi %35, %c1 : index + %37 = polygeist.submap(%arg3, %34, %36, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %38 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %39 = arith.subi %38, %c1 : index + %40 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg2, %39, %41, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%7, %12, %17, %22, %27, %32, %37 : memref, memref, memref, memref, memref, memref, memref) outs(%42 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %43 = arith.mulf %in_1, %cst_0 : f64 + %44 = arith.subf %in, %43 : f64 + %45 = arith.addf %44, %in_2 : f64 + %46 = arith.mulf %45, %cst : f64 + %47 = arith.subf %in_3, %43 : f64 + %48 = arith.addf %47, %in_4 : f64 + %49 = arith.mulf %48, %cst : f64 + %50 = arith.addf %46, %49 : f64 + %51 = arith.subf %in_5, %43 : f64 + %52 = arith.addf %51, %in_6 : f64 + %53 = arith.mulf %52, %cst : f64 + %54 = arith.addf %50, %53 : f64 + %55 = arith.addf %54, %in_1 : f64 + linalg.yield %55 : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0 + 1, s1, d0 + 1)>} : (memref, index, index, index) -> memref + %46 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0 + 1)>} : (memref, index, index, index) -> memref + %47 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0 - 1, s1, d0 + 1)>} : (memref, index, index, index) -> memref + %48 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %49 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1 - 1, d0 + 1)>} : (memref, index, index, index) -> memref + %50 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0 + 2)>} : (memref, index, index, index) -> memref + %51 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %52 = polygeist.submap(%arg3, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%45, %46, %47, %48, %49, %50, %51 : memref, memref, memref, memref, memref, memref, memref) outs(%52 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %53 = arith.mulf %in_1, %cst_0 : f64 + %54 = arith.subf %in, %53 : f64 + %55 = arith.addf %54, %in_2 : f64 + %56 = arith.mulf %55, %cst : f64 + %57 = arith.subf %in_3, %53 : f64 + %58 = arith.addf %57, %in_4 : f64 + %59 = arith.mulf %58, %cst : f64 + %60 = arith.addf %56, %59 : f64 + %61 = arith.subf %in_5, %53 : f64 + %62 = arith.addf %61, %in_6 : f64 + %63 = arith.mulf %62, %cst : f64 + %64 = arith.addf %60, %63 : f64 + %65 = arith.addf %64, %in_1 : f64 + linalg.yield %65 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0 + 1, s1, d0 + 1)>} : (memref, index, index, index) -> memref + %46 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0 + 1)>} : (memref, index, index, index) -> memref + %47 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0 - 1, s1, d0 + 1)>} : (memref, index, index, index) -> memref + %48 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %49 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1 - 1, d0 + 1)>} : (memref, index, index, index) -> memref + %50 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0 + 2)>} : (memref, index, index, index) -> memref + %51 = polygeist.submap(%arg2, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0)>} : (memref, index, index, index) -> memref + %52 = polygeist.submap(%arg3, %arg5, %arg6, %44) {map = affine_map<(d0)[s0, s1] -> (s0, s1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%45, %46, %47, %48, %49, %50, %51 : memref, memref, memref, memref, memref, memref, memref) outs(%52 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %53 = arith.mulf %in_1, %cst_0 : f64 + %54 = arith.subf %in, %53 : f64 + %55 = arith.addf %54, %in_2 : f64 + %56 = arith.mulf %55, %cst : f64 + %57 = arith.subf %in_3, %53 : f64 + %58 = arith.addf %57, %in_4 : f64 + %59 = arith.mulf %58, %cst : f64 + %60 = arith.addf %56, %59 : f64 + %61 = arith.subf %in_5, %53 : f64 + %62 = arith.addf %61, %in_6 : f64 + %63 = arith.mulf %62, %cst : f64 + %64 = arith.addf %60, %63 : f64 + %65 = arith.addf %64, %in_1 : f64 + linalg.yield %65 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%48, %49, %50, %51, %52, %53, %54 : memref, memref, memref, memref, memref, memref, memref) outs(%55 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %56 = arith.mulf %in_1, %cst_0 : f64 + %57 = arith.subf %in, %56 : f64 + %58 = arith.addf %57, %in_2 : f64 + %59 = arith.mulf %58, %cst : f64 + %60 = arith.subf %in_3, %56 : f64 + %61 = arith.addf %60, %in_4 : f64 + %62 = arith.mulf %61, %cst : f64 + %63 = arith.addf %59, %62 : f64 + %64 = arith.subf %in_5, %56 : f64 + %65 = arith.addf %64, %in_6 : f64 + %66 = arith.mulf %65, %cst : f64 + %67 = arith.addf %63, %66 : f64 + %68 = arith.addf %67, %in_1 : f64 + linalg.yield %68 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0 + 1, s1, d0 + 1) + Composed map: (d0)[s0, s1] -> (s0 + 1, s1, d0 + 1) + Final lgMap: (d0)[s0, s1] -> (s0 + 1, s1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0 + 1, s1, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0 + 1, d1 + 1, d0 + 1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0 + 1) + Composed map: (d0)[s0, s1] -> (s0, s1, d0 + 1) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0 - 1, s1, d0 + 1) + Composed map: (d0)[s0, s1] -> (s0 - 1, s1, d0 + 1) + Final lgMap: (d0)[s0, s1] -> (s0 - 1, s1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0 - 1, s1, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0 - 1, d1 + 1, d0 + 1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1 + 1, d0 + 1) + Composed map: (d0)[s0, s1] -> (s0, s1 + 1, d0 + 1) + Final lgMap: (d0)[s0, s1] -> (s0, s1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1 + 1, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1 + 2, d0 + 1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1 - 1, d0 + 1) + Composed map: (d0)[s0, s1] -> (s0, s1 - 1, d0 + 1) + Final lgMap: (d0)[s0, s1] -> (s0, s1 - 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1 - 1, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1, d0 + 1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0 + 2) + Composed map: (d0)[s0, s1] -> (s0, s1, d0 + 2) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1 + 1, d0 + 2) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0) + Composed map: (d0)[s0, s1] -> (s0, s1, d0) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1 + 1, d0) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1, d0 + 1) + Composed map: (d0)[s0, s1] -> (s0, s1, d0 + 1) + Final lgMap: (d0)[s0, s1] -> (s0, s1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1, d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 7 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 1 to 21 { + affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %46 = arith.subi %45, %c1 : index + %47 = polygeist.submap(%arg2, %arg5, %46, %44) {map = affine_map<(d0, d1)[s0] -> (s0 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %48 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %49 = arith.subi %48, %c1 : index + %50 = polygeist.submap(%arg2, %arg5, %49, %44) {map = affine_map<(d0, d1)[s0] -> (s0, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %51 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %52 = arith.subi %51, %c1 : index + %53 = polygeist.submap(%arg2, %arg5, %52, %44) {map = affine_map<(d0, d1)[s0] -> (s0 - 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %54 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %55 = arith.subi %54, %c1 : index + %56 = polygeist.submap(%arg2, %arg5, %55, %44) {map = affine_map<(d0, d1)[s0] -> (s0, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %57 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %58 = arith.subi %57, %c1 : index + %59 = polygeist.submap(%arg2, %arg5, %58, %44) {map = affine_map<(d0, d1)[s0] -> (s0, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %60 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %61 = arith.subi %60, %c1 : index + %62 = polygeist.submap(%arg2, %arg5, %61, %44) {map = affine_map<(d0, d1)[s0] -> (s0, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %63 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %64 = arith.subi %63, %c1 : index + %65 = polygeist.submap(%arg2, %arg5, %64, %44) {map = affine_map<(d0, d1)[s0] -> (s0, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %66 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %67 = arith.subi %66, %c1 : index + %68 = polygeist.submap(%arg3, %arg5, %67, %44) {map = affine_map<(d0, d1)[s0] -> (s0, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%47, %50, %53, %56, %59, %62, %65 : memref, memref, memref, memref, memref, memref, memref) outs(%68 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %69 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %70 = arith.mulf %in_1, %cst_0 : f64 + %71 = arith.subf %in, %70 : f64 + %72 = arith.addf %71, %in_2 : f64 + %73 = arith.mulf %72, %cst : f64 + %74 = arith.subf %in_3, %70 : f64 + %75 = arith.addf %74, %in_4 : f64 + %76 = arith.mulf %75, %cst : f64 + %77 = arith.addf %73, %76 : f64 + %78 = arith.subf %in_5, %70 : f64 + %79 = arith.addf %78, %in_6 : f64 + %80 = arith.mulf %79, %cst : f64 + %81 = arith.addf %77, %80 : f64 + %82 = arith.addf %81, %in_1 : f64 + linalg.yield %82 : f64 + } + } + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %6 = arith.subi %5, %c1 : index + %7 = polygeist.submap(%arg3, %4, %6, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg3, %9, %11, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg3, %14, %16, %2) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %21 = arith.subi %20, %c1 : index + %22 = polygeist.submap(%arg3, %19, %21, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg3, %24, %26, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %28 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg3, %29, %31, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %36 = arith.subi %35, %c1 : index + %37 = polygeist.submap(%arg3, %34, %36, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %38 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %39 = arith.subi %38, %c1 : index + %40 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg2, %39, %41, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%7, %12, %17, %22, %27, %32, %37 : memref, memref, memref, memref, memref, memref, memref) outs(%42 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %43 = arith.mulf %in_1, %cst_0 : f64 + %44 = arith.subf %in, %43 : f64 + %45 = arith.addf %44, %in_2 : f64 + %46 = arith.mulf %45, %cst : f64 + %47 = arith.subf %in_3, %43 : f64 + %48 = arith.addf %47, %in_4 : f64 + %49 = arith.mulf %48, %cst : f64 + %50 = arith.addf %46, %49 : f64 + %51 = arith.subf %in_5, %43 : f64 + %52 = arith.addf %51, %in_6 : f64 + %53 = arith.mulf %52, %cst : f64 + %54 = arith.addf %50, %53 : f64 + %55 = arith.addf %54, %in_1 : f64 + linalg.yield %55 : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %46 = arith.subi %45, %c1 : index + %47 = polygeist.submap(%arg2, %arg5, %46, %44) {map = affine_map<(d0, d1)[s0] -> (s0 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %48 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %49 = arith.subi %48, %c1 : index + %50 = polygeist.submap(%arg2, %arg5, %49, %44) {map = affine_map<(d0, d1)[s0] -> (s0, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %51 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %52 = arith.subi %51, %c1 : index + %53 = polygeist.submap(%arg2, %arg5, %52, %44) {map = affine_map<(d0, d1)[s0] -> (s0 - 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %54 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %55 = arith.subi %54, %c1 : index + %56 = polygeist.submap(%arg2, %arg5, %55, %44) {map = affine_map<(d0, d1)[s0] -> (s0, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %57 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %58 = arith.subi %57, %c1 : index + %59 = polygeist.submap(%arg2, %arg5, %58, %44) {map = affine_map<(d0, d1)[s0] -> (s0, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %60 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %61 = arith.subi %60, %c1 : index + %62 = polygeist.submap(%arg2, %arg5, %61, %44) {map = affine_map<(d0, d1)[s0] -> (s0, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %63 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %64 = arith.subi %63, %c1 : index + %65 = polygeist.submap(%arg2, %arg5, %64, %44) {map = affine_map<(d0, d1)[s0] -> (s0, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %66 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %67 = arith.subi %66, %c1 : index + %68 = polygeist.submap(%arg3, %arg5, %67, %44) {map = affine_map<(d0, d1)[s0] -> (s0, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%47, %50, %53, %56, %59, %62, %65 : memref, memref, memref, memref, memref, memref, memref) outs(%68 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %69 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %70 = arith.mulf %in_1, %cst_0 : f64 + %71 = arith.subf %in, %70 : f64 + %72 = arith.addf %71, %in_2 : f64 + %73 = arith.mulf %72, %cst : f64 + %74 = arith.subf %in_3, %70 : f64 + %75 = arith.addf %74, %in_4 : f64 + %76 = arith.mulf %75, %cst : f64 + %77 = arith.addf %73, %76 : f64 + %78 = arith.subf %in_5, %70 : f64 + %79 = arith.addf %78, %in_6 : f64 + %80 = arith.mulf %79, %cst : f64 + %81 = arith.addf %77, %80 : f64 + %82 = arith.addf %81, %in_1 : f64 + linalg.yield %82 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%50, %53, %56, %59, %62, %65, %68 : memref, memref, memref, memref, memref, memref, memref) outs(%71 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %72 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %73 = arith.mulf %in_1, %cst_0 : f64 + %74 = arith.subf %in, %73 : f64 + %75 = arith.addf %74, %in_2 : f64 + %76 = arith.mulf %75, %cst : f64 + %77 = arith.subf %in_3, %73 : f64 + %78 = arith.addf %77, %in_4 : f64 + %79 = arith.mulf %78, %cst : f64 + %80 = arith.addf %76, %79 : f64 + %81 = arith.subf %in_5, %73 : f64 + %82 = arith.addf %81, %in_6 : f64 + %83 = arith.mulf %82, %cst : f64 + %84 = arith.addf %80, %83 : f64 + %85 = arith.addf %84, %in_1 : f64 + linalg.yield %85 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1)[s0] -> (s0 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1)[s0] -> (s0 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0 + 1, d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) + Composed map: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) + Final lgMap: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0 - 1, d1 + 1, d0 + 1) + Composed map: (d0, d1)[s0] -> (s0 - 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1)[s0] -> (s0 - 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0 - 1, d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1 + 2, d0 + 1) + Composed map: (d0, d1)[s0] -> (s0, d1 + 2, d0 + 1) + Final lgMap: (d0, d1)[s0] -> (s0, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1, d0 + 1) + Composed map: (d0, d1)[s0] -> (s0, d1, d0 + 1) + Final lgMap: (d0, d1)[s0] -> (s0, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 2) + Composed map: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 2) + Final lgMap: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1 + 1, d0) + Composed map: (d0, d1)[s0] -> (s0, d1 + 1, d0) + Final lgMap: (d0, d1)[s0] -> (s0, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) + Composed map: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) + Final lgMap: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 3 +Total inputs: 7 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 1 to 21 { + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %6 = arith.subi %5, %c1 : index + %7 = polygeist.submap(%arg2, %4, %6, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %9, %11, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg2, %14, %16, %2) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %21 = arith.subi %20, %c1 : index + %22 = polygeist.submap(%arg2, %19, %21, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg2, %24, %26, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %28 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg2, %29, %31, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %36 = arith.subi %35, %c1 : index + %37 = polygeist.submap(%arg2, %34, %36, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %38 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %39 = arith.subi %38, %c1 : index + %40 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg3, %39, %41, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%7, %12, %17, %22, %27, %32, %37 : memref, memref, memref, memref, memref, memref, memref) outs(%42 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %86 = arith.mulf %in_1, %cst_0 : f64 + %87 = arith.subf %in, %86 : f64 + %88 = arith.addf %87, %in_2 : f64 + %89 = arith.mulf %88, %cst : f64 + %90 = arith.subf %in_3, %86 : f64 + %91 = arith.addf %90, %in_4 : f64 + %92 = arith.mulf %91, %cst : f64 + %93 = arith.addf %89, %92 : f64 + %94 = arith.subf %in_5, %86 : f64 + %95 = arith.addf %94, %in_6 : f64 + %96 = arith.mulf %95, %cst : f64 + %97 = arith.addf %93, %96 : f64 + %98 = arith.addf %97, %in_1 : f64 + linalg.yield %98 : f64 + } + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %46 = arith.subi %45, %c1 : index + %47 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %48 = arith.subi %47, %c1 : index + %49 = polygeist.submap(%arg3, %46, %48, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %50 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %51 = arith.subi %50, %c1 : index + %52 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %53 = arith.subi %52, %c1 : index + %54 = polygeist.submap(%arg3, %51, %53, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %55 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %56 = arith.subi %55, %c1 : index + %57 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %58 = arith.subi %57, %c1 : index + %59 = polygeist.submap(%arg3, %56, %58, %44) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %60 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %61 = arith.subi %60, %c1 : index + %62 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %63 = arith.subi %62, %c1 : index + %64 = polygeist.submap(%arg3, %61, %63, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %65 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %66 = arith.subi %65, %c1 : index + %67 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %68 = arith.subi %67, %c1 : index + %69 = polygeist.submap(%arg3, %66, %68, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %70 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %71 = arith.subi %70, %c1 : index + %72 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %73 = arith.subi %72, %c1 : index + %74 = polygeist.submap(%arg3, %71, %73, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %75 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %76 = arith.subi %75, %c1 : index + %77 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %78 = arith.subi %77, %c1 : index + %79 = polygeist.submap(%arg3, %76, %78, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %80 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %81 = arith.subi %80, %c1 : index + %82 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %83 = arith.subi %82, %c1 : index + %84 = polygeist.submap(%arg2, %81, %83, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%49, %54, %59, %64, %69, %74, %79 : memref, memref, memref, memref, memref, memref, memref) outs(%84 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (1) + ubMap: () -> (21) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%10, %15, %20, %25, %30, %35, %40 : memref, memref, memref, memref, memref, memref, memref) outs(%45 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %88 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %89 = arith.mulf %in_1, %cst_0 : f64 + %90 = arith.subf %in, %89 : f64 + %91 = arith.addf %90, %in_2 : f64 + %92 = arith.mulf %91, %cst : f64 + %93 = arith.subf %in_3, %89 : f64 + %94 = arith.addf %93, %in_4 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.subf %in_5, %89 : f64 + %98 = arith.addf %97, %in_6 : f64 + %99 = arith.mulf %98, %cst : f64 + %100 = arith.addf %96, %99 : f64 + %101 = arith.addf %100, %in_1 : f64 + linalg.yield %101 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%108, %113, %118, %123, %128, %133, %138 : memref, memref, memref, memref, memref, memref, memref) outs(%143 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %144 = arith.mulf %in_1, %cst_0 : f64 + %145 = arith.subf %in, %144 : f64 + %146 = arith.addf %145, %in_2 : f64 + %147 = arith.mulf %146, %cst : f64 + %148 = arith.subf %in_3, %144 : f64 + %149 = arith.addf %148, %in_4 : f64 + %150 = arith.mulf %149, %cst : f64 + %151 = arith.addf %147, %150 : f64 + %152 = arith.subf %in_5, %144 : f64 + %153 = arith.addf %152, %in_6 : f64 + %154 = arith.mulf %153, %cst : f64 + %155 = arith.addf %151, %154 : f64 + %156 = arith.addf %155, %in_1 : f64 + linalg.yield %156 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 1 to 21 { + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %6 = arith.subi %5, %c1 : index + %7 = polygeist.submap(%arg2, %4, %6, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %9, %11, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg2, %14, %16, %2) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %21 = arith.subi %20, %c1 : index + %22 = polygeist.submap(%arg2, %19, %21, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg2, %24, %26, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %28 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg2, %29, %31, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %36 = arith.subi %35, %c1 : index + %37 = polygeist.submap(%arg2, %34, %36, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %38 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %39 = arith.subi %38, %c1 : index + %40 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg3, %39, %41, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%7, %12, %17, %22, %27, %32, %37 : memref, memref, memref, memref, memref, memref, memref) outs(%42 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %46 = arith.subi %45, %c1 : index + %47 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %48 = arith.subi %47, %c1 : index + %49 = polygeist.submap(%arg3, %46, %48, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %50 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %51 = arith.subi %50, %c1 : index + %52 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %53 = arith.subi %52, %c1 : index + %54 = polygeist.submap(%arg3, %51, %53, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %55 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %56 = arith.subi %55, %c1 : index + %57 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %58 = arith.subi %57, %c1 : index + %59 = polygeist.submap(%arg3, %56, %58, %44) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %60 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %61 = arith.subi %60, %c1 : index + %62 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %63 = arith.subi %62, %c1 : index + %64 = polygeist.submap(%arg3, %61, %63, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %65 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %66 = arith.subi %65, %c1 : index + %67 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %68 = arith.subi %67, %c1 : index + %69 = polygeist.submap(%arg3, %66, %68, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %70 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %71 = arith.subi %70, %c1 : index + %72 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %73 = arith.subi %72, %c1 : index + %74 = polygeist.submap(%arg3, %71, %73, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %75 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %76 = arith.subi %75, %c1 : index + %77 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %78 = arith.subi %77, %c1 : index + %79 = polygeist.submap(%arg3, %76, %78, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %80 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %81 = arith.subi %80, %c1 : index + %82 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %83 = arith.subi %82, %c1 : index + %84 = polygeist.submap(%arg2, %81, %83, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%49, %54, %59, %64, %69, %74, %79 : memref, memref, memref, memref, memref, memref, memref) outs(%84 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (1) + ubMap: () -> (21) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%10, %15, %20, %25, %30, %35, %40 : memref, memref, memref, memref, memref, memref, memref) outs(%45 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %88 = arith.mulf %in_1, %cst_0 : f64 + %89 = arith.subf %in, %88 : f64 + %90 = arith.addf %89, %in_2 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.subf %in_3, %88 : f64 + %93 = arith.addf %92, %in_4 : f64 + %94 = arith.mulf %93, %cst : f64 + %95 = arith.addf %91, %94 : f64 + %96 = arith.subf %in_5, %88 : f64 + %97 = arith.addf %96, %in_6 : f64 + %98 = arith.mulf %97, %cst : f64 + %99 = arith.addf %95, %98 : f64 + %100 = arith.addf %99, %in_1 : f64 + linalg.yield %100 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%108, %113, %118, %123, %128, %133, %138 : memref, memref, memref, memref, memref, memref, memref) outs(%143 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %144 = arith.mulf %in_1, %cst_0 : f64 + %145 = arith.subf %in, %144 : f64 + %146 = arith.addf %145, %in_2 : f64 + %147 = arith.mulf %146, %cst : f64 + %148 = arith.subf %in_3, %144 : f64 + %149 = arith.addf %148, %in_4 : f64 + %150 = arith.mulf %149, %cst : f64 + %151 = arith.addf %147, %150 : f64 + %152 = arith.subf %in_5, %144 : f64 + %153 = arith.addf %152, %in_6 : f64 + %154 = arith.mulf %153, %cst : f64 + %155 = arith.addf %151, %154 : f64 + %156 = arith.addf %155, %in_1 : f64 + linalg.yield %156 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 1 to 21 { + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %6 = arith.subi %5, %c1 : index + %7 = polygeist.submap(%arg2, %4, %6, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %9, %11, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg2, %14, %16, %2) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %21 = arith.subi %20, %c1 : index + %22 = polygeist.submap(%arg2, %19, %21, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg2, %24, %26, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %28 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg2, %29, %31, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %36 = arith.subi %35, %c1 : index + %37 = polygeist.submap(%arg2, %34, %36, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %38 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %39 = arith.subi %38, %c1 : index + %40 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg3, %39, %41, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%7, %12, %17, %22, %27, %32, %37 : memref, memref, memref, memref, memref, memref, memref) outs(%42 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %46 = arith.subi %45, %c1 : index + %47 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %48 = arith.subi %47, %c1 : index + %49 = polygeist.submap(%arg3, %46, %48, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %50 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %51 = arith.subi %50, %c1 : index + %52 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %53 = arith.subi %52, %c1 : index + %54 = polygeist.submap(%arg3, %51, %53, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %55 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %56 = arith.subi %55, %c1 : index + %57 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %58 = arith.subi %57, %c1 : index + %59 = polygeist.submap(%arg3, %56, %58, %44) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %60 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %61 = arith.subi %60, %c1 : index + %62 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %63 = arith.subi %62, %c1 : index + %64 = polygeist.submap(%arg3, %61, %63, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %65 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %66 = arith.subi %65, %c1 : index + %67 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %68 = arith.subi %67, %c1 : index + %69 = polygeist.submap(%arg3, %66, %68, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %70 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %71 = arith.subi %70, %c1 : index + %72 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %73 = arith.subi %72, %c1 : index + %74 = polygeist.submap(%arg3, %71, %73, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %75 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %76 = arith.subi %75, %c1 : index + %77 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %78 = arith.subi %77, %c1 : index + %79 = polygeist.submap(%arg3, %76, %78, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %80 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %81 = arith.subi %80, %c1 : index + %82 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %83 = arith.subi %82, %c1 : index + %84 = polygeist.submap(%arg2, %81, %83, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%49, %54, %59, %64, %69, %74, %79 : memref, memref, memref, memref, memref, memref, memref) outs(%84 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (1) + ubMap: () -> (21) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%10, %15, %20, %25, %30, %35, %40 : memref, memref, memref, memref, memref, memref, memref) outs(%45 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %88 = arith.mulf %in_1, %cst_0 : f64 + %89 = arith.subf %in, %88 : f64 + %90 = arith.addf %89, %in_2 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.subf %in_3, %88 : f64 + %93 = arith.addf %92, %in_4 : f64 + %94 = arith.mulf %93, %cst : f64 + %95 = arith.addf %91, %94 : f64 + %96 = arith.subf %in_5, %88 : f64 + %97 = arith.addf %96, %in_6 : f64 + %98 = arith.mulf %97, %cst : f64 + %99 = arith.addf %95, %98 : f64 + %100 = arith.addf %99, %in_1 : f64 + linalg.yield %100 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%108, %113, %118, %123, %128, %133, %138 : memref, memref, memref, memref, memref, memref, memref) outs(%143 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %144 = arith.mulf %in_1, %cst_0 : f64 + %145 = arith.subf %in, %144 : f64 + %146 = arith.addf %145, %in_2 : f64 + %147 = arith.mulf %146, %cst : f64 + %148 = arith.subf %in_3, %144 : f64 + %149 = arith.addf %148, %in_4 : f64 + %150 = arith.mulf %149, %cst : f64 + %151 = arith.addf %147, %150 : f64 + %152 = arith.subf %in_5, %144 : f64 + %153 = arith.addf %152, %in_6 : f64 + %154 = arith.mulf %153, %cst : f64 + %155 = arith.addf %151, %154 : f64 + %156 = arith.addf %155, %in_1 : f64 + linalg.yield %156 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 1 to 21 { + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %6 = arith.subi %5, %c1 : index + %7 = polygeist.submap(%arg2, %4, %6, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %9, %11, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg2, %14, %16, %2) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %21 = arith.subi %20, %c1 : index + %22 = polygeist.submap(%arg2, %19, %21, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg2, %24, %26, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %28 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg2, %29, %31, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %36 = arith.subi %35, %c1 : index + %37 = polygeist.submap(%arg2, %34, %36, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %38 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %39 = arith.subi %38, %c1 : index + %40 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg3, %39, %41, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%7, %12, %17, %22, %27, %32, %37 : memref, memref, memref, memref, memref, memref, memref) outs(%42 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %46 = arith.subi %45, %c1 : index + %47 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %48 = arith.subi %47, %c1 : index + %49 = polygeist.submap(%arg3, %46, %48, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %50 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %51 = arith.subi %50, %c1 : index + %52 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %53 = arith.subi %52, %c1 : index + %54 = polygeist.submap(%arg3, %51, %53, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %55 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %56 = arith.subi %55, %c1 : index + %57 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %58 = arith.subi %57, %c1 : index + %59 = polygeist.submap(%arg3, %56, %58, %44) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %60 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %61 = arith.subi %60, %c1 : index + %62 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %63 = arith.subi %62, %c1 : index + %64 = polygeist.submap(%arg3, %61, %63, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %65 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %66 = arith.subi %65, %c1 : index + %67 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %68 = arith.subi %67, %c1 : index + %69 = polygeist.submap(%arg3, %66, %68, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %70 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %71 = arith.subi %70, %c1 : index + %72 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %73 = arith.subi %72, %c1 : index + %74 = polygeist.submap(%arg3, %71, %73, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %75 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %76 = arith.subi %75, %c1 : index + %77 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %78 = arith.subi %77, %c1 : index + %79 = polygeist.submap(%arg3, %76, %78, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %80 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %81 = arith.subi %80, %c1 : index + %82 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %83 = arith.subi %82, %c1 : index + %84 = polygeist.submap(%arg2, %81, %83, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%49, %54, %59, %64, %69, %74, %79 : memref, memref, memref, memref, memref, memref, memref) outs(%84 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (1) + ubMap: () -> (21) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%10, %15, %20, %25, %30, %35, %40 : memref, memref, memref, memref, memref, memref, memref) outs(%45 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %88 = arith.mulf %in_1, %cst_0 : f64 + %89 = arith.subf %in, %88 : f64 + %90 = arith.addf %89, %in_2 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.subf %in_3, %88 : f64 + %93 = arith.addf %92, %in_4 : f64 + %94 = arith.mulf %93, %cst : f64 + %95 = arith.addf %91, %94 : f64 + %96 = arith.subf %in_5, %88 : f64 + %97 = arith.addf %96, %in_6 : f64 + %98 = arith.mulf %97, %cst : f64 + %99 = arith.addf %95, %98 : f64 + %100 = arith.addf %99, %in_1 : f64 + linalg.yield %100 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%108, %113, %118, %123, %128, %133, %138 : memref, memref, memref, memref, memref, memref, memref) outs(%143 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %144 = arith.mulf %in_1, %cst_0 : f64 + %145 = arith.subf %in, %144 : f64 + %146 = arith.addf %145, %in_2 : f64 + %147 = arith.mulf %146, %cst : f64 + %148 = arith.subf %in_3, %144 : f64 + %149 = arith.addf %148, %in_4 : f64 + %150 = arith.mulf %149, %cst : f64 + %151 = arith.addf %147, %150 : f64 + %152 = arith.subf %in_5, %144 : f64 + %153 = arith.addf %152, %in_6 : f64 + %154 = arith.mulf %153, %cst : f64 + %155 = arith.addf %151, %154 : f64 + %156 = arith.addf %155, %in_1 : f64 + linalg.yield %156 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 1 to 21 { + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %6 = arith.subi %5, %c1 : index + %7 = polygeist.submap(%arg2, %4, %6, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %9, %11, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg2, %14, %16, %2) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %21 = arith.subi %20, %c1 : index + %22 = polygeist.submap(%arg2, %19, %21, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg2, %24, %26, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %28 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg2, %29, %31, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %36 = arith.subi %35, %c1 : index + %37 = polygeist.submap(%arg2, %34, %36, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %38 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %39 = arith.subi %38, %c1 : index + %40 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg3, %39, %41, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%7, %12, %17, %22, %27, %32, %37 : memref, memref, memref, memref, memref, memref, memref) outs(%42 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %46 = arith.subi %45, %c1 : index + %47 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %48 = arith.subi %47, %c1 : index + %49 = polygeist.submap(%arg3, %46, %48, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %50 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %51 = arith.subi %50, %c1 : index + %52 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %53 = arith.subi %52, %c1 : index + %54 = polygeist.submap(%arg3, %51, %53, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %55 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %56 = arith.subi %55, %c1 : index + %57 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %58 = arith.subi %57, %c1 : index + %59 = polygeist.submap(%arg3, %56, %58, %44) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %60 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %61 = arith.subi %60, %c1 : index + %62 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %63 = arith.subi %62, %c1 : index + %64 = polygeist.submap(%arg3, %61, %63, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %65 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %66 = arith.subi %65, %c1 : index + %67 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %68 = arith.subi %67, %c1 : index + %69 = polygeist.submap(%arg3, %66, %68, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %70 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %71 = arith.subi %70, %c1 : index + %72 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %73 = arith.subi %72, %c1 : index + %74 = polygeist.submap(%arg3, %71, %73, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %75 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %76 = arith.subi %75, %c1 : index + %77 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %78 = arith.subi %77, %c1 : index + %79 = polygeist.submap(%arg3, %76, %78, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %80 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %81 = arith.subi %80, %c1 : index + %82 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %83 = arith.subi %82, %c1 : index + %84 = polygeist.submap(%arg2, %81, %83, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%49, %54, %59, %64, %69, %74, %79 : memref, memref, memref, memref, memref, memref, memref) outs(%84 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (1) + ubMap: () -> (21) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%10, %15, %20, %25, %30, %35, %40 : memref, memref, memref, memref, memref, memref, memref) outs(%45 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %88 = arith.mulf %in_1, %cst_0 : f64 + %89 = arith.subf %in, %88 : f64 + %90 = arith.addf %89, %in_2 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.subf %in_3, %88 : f64 + %93 = arith.addf %92, %in_4 : f64 + %94 = arith.mulf %93, %cst : f64 + %95 = arith.addf %91, %94 : f64 + %96 = arith.subf %in_5, %88 : f64 + %97 = arith.addf %96, %in_6 : f64 + %98 = arith.mulf %97, %cst : f64 + %99 = arith.addf %95, %98 : f64 + %100 = arith.addf %99, %in_1 : f64 + linalg.yield %100 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%108, %113, %118, %123, %128, %133, %138 : memref, memref, memref, memref, memref, memref, memref) outs(%143 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %144 = arith.mulf %in_1, %cst_0 : f64 + %145 = arith.subf %in, %144 : f64 + %146 = arith.addf %145, %in_2 : f64 + %147 = arith.mulf %146, %cst : f64 + %148 = arith.subf %in_3, %144 : f64 + %149 = arith.addf %148, %in_4 : f64 + %150 = arith.mulf %149, %cst : f64 + %151 = arith.addf %147, %150 : f64 + %152 = arith.subf %in_5, %144 : f64 + %153 = arith.addf %152, %in_6 : f64 + %154 = arith.mulf %153, %cst : f64 + %155 = arith.addf %151, %154 : f64 + %156 = arith.addf %155, %in_1 : f64 + linalg.yield %156 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 1 to 21 { + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %6 = arith.subi %5, %c1 : index + %7 = polygeist.submap(%arg2, %4, %6, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %9, %11, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg2, %14, %16, %2) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %21 = arith.subi %20, %c1 : index + %22 = polygeist.submap(%arg2, %19, %21, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg2, %24, %26, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %28 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg2, %29, %31, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %36 = arith.subi %35, %c1 : index + %37 = polygeist.submap(%arg2, %34, %36, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %38 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %39 = arith.subi %38, %c1 : index + %40 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg3, %39, %41, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%7, %12, %17, %22, %27, %32, %37 : memref, memref, memref, memref, memref, memref, memref) outs(%42 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %46 = arith.subi %45, %c1 : index + %47 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %48 = arith.subi %47, %c1 : index + %49 = polygeist.submap(%arg3, %46, %48, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %50 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %51 = arith.subi %50, %c1 : index + %52 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %53 = arith.subi %52, %c1 : index + %54 = polygeist.submap(%arg3, %51, %53, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %55 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %56 = arith.subi %55, %c1 : index + %57 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %58 = arith.subi %57, %c1 : index + %59 = polygeist.submap(%arg3, %56, %58, %44) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %60 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %61 = arith.subi %60, %c1 : index + %62 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %63 = arith.subi %62, %c1 : index + %64 = polygeist.submap(%arg3, %61, %63, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %65 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %66 = arith.subi %65, %c1 : index + %67 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %68 = arith.subi %67, %c1 : index + %69 = polygeist.submap(%arg3, %66, %68, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %70 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %71 = arith.subi %70, %c1 : index + %72 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %73 = arith.subi %72, %c1 : index + %74 = polygeist.submap(%arg3, %71, %73, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %75 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %76 = arith.subi %75, %c1 : index + %77 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %78 = arith.subi %77, %c1 : index + %79 = polygeist.submap(%arg3, %76, %78, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %80 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %81 = arith.subi %80, %c1 : index + %82 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %83 = arith.subi %82, %c1 : index + %84 = polygeist.submap(%arg2, %81, %83, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%49, %54, %59, %64, %69, %74, %79 : memref, memref, memref, memref, memref, memref, memref) outs(%84 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (1) + ubMap: () -> (21) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%10, %15, %20, %25, %30, %35, %40 : memref, memref, memref, memref, memref, memref, memref) outs(%45 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %88 = arith.mulf %in_1, %cst_0 : f64 + %89 = arith.subf %in, %88 : f64 + %90 = arith.addf %89, %in_2 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.subf %in_3, %88 : f64 + %93 = arith.addf %92, %in_4 : f64 + %94 = arith.mulf %93, %cst : f64 + %95 = arith.addf %91, %94 : f64 + %96 = arith.subf %in_5, %88 : f64 + %97 = arith.addf %96, %in_6 : f64 + %98 = arith.mulf %97, %cst : f64 + %99 = arith.addf %95, %98 : f64 + %100 = arith.addf %99, %in_1 : f64 + linalg.yield %100 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%108, %113, %118, %123, %128, %133, %138 : memref, memref, memref, memref, memref, memref, memref) outs(%143 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %144 = arith.mulf %in_1, %cst_0 : f64 + %145 = arith.subf %in, %144 : f64 + %146 = arith.addf %145, %in_2 : f64 + %147 = arith.mulf %146, %cst : f64 + %148 = arith.subf %in_3, %144 : f64 + %149 = arith.addf %148, %in_4 : f64 + %150 = arith.mulf %149, %cst : f64 + %151 = arith.addf %147, %150 : f64 + %152 = arith.subf %in_5, %144 : f64 + %153 = arith.addf %152, %in_6 : f64 + %154 = arith.mulf %153, %cst : f64 + %155 = arith.addf %151, %154 : f64 + %156 = arith.addf %155, %in_1 : f64 + linalg.yield %156 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 1 to 21 { + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %6 = arith.subi %5, %c1 : index + %7 = polygeist.submap(%arg2, %4, %6, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %9, %11, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg2, %14, %16, %2) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %21 = arith.subi %20, %c1 : index + %22 = polygeist.submap(%arg2, %19, %21, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg2, %24, %26, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %28 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg2, %29, %31, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %36 = arith.subi %35, %c1 : index + %37 = polygeist.submap(%arg2, %34, %36, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %38 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %39 = arith.subi %38, %c1 : index + %40 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg3, %39, %41, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%7, %12, %17, %22, %27, %32, %37 : memref, memref, memref, memref, memref, memref, memref) outs(%42 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %46 = arith.subi %45, %c1 : index + %47 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %48 = arith.subi %47, %c1 : index + %49 = polygeist.submap(%arg3, %46, %48, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %50 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %51 = arith.subi %50, %c1 : index + %52 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %53 = arith.subi %52, %c1 : index + %54 = polygeist.submap(%arg3, %51, %53, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %55 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %56 = arith.subi %55, %c1 : index + %57 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %58 = arith.subi %57, %c1 : index + %59 = polygeist.submap(%arg3, %56, %58, %44) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %60 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %61 = arith.subi %60, %c1 : index + %62 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %63 = arith.subi %62, %c1 : index + %64 = polygeist.submap(%arg3, %61, %63, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %65 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %66 = arith.subi %65, %c1 : index + %67 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %68 = arith.subi %67, %c1 : index + %69 = polygeist.submap(%arg3, %66, %68, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %70 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %71 = arith.subi %70, %c1 : index + %72 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %73 = arith.subi %72, %c1 : index + %74 = polygeist.submap(%arg3, %71, %73, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %75 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %76 = arith.subi %75, %c1 : index + %77 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %78 = arith.subi %77, %c1 : index + %79 = polygeist.submap(%arg3, %76, %78, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %80 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %81 = arith.subi %80, %c1 : index + %82 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %83 = arith.subi %82, %c1 : index + %84 = polygeist.submap(%arg2, %81, %83, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%49, %54, %59, %64, %69, %74, %79 : memref, memref, memref, memref, memref, memref, memref) outs(%84 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (1) + ubMap: () -> (21) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%10, %15, %20, %25, %30, %35, %40 : memref, memref, memref, memref, memref, memref, memref) outs(%45 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %88 = arith.mulf %in_1, %cst_0 : f64 + %89 = arith.subf %in, %88 : f64 + %90 = arith.addf %89, %in_2 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.subf %in_3, %88 : f64 + %93 = arith.addf %92, %in_4 : f64 + %94 = arith.mulf %93, %cst : f64 + %95 = arith.addf %91, %94 : f64 + %96 = arith.subf %in_5, %88 : f64 + %97 = arith.addf %96, %in_6 : f64 + %98 = arith.mulf %97, %cst : f64 + %99 = arith.addf %95, %98 : f64 + %100 = arith.addf %99, %in_1 : f64 + linalg.yield %100 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%108, %113, %118, %123, %128, %133, %138 : memref, memref, memref, memref, memref, memref, memref) outs(%143 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %144 = arith.mulf %in_1, %cst_0 : f64 + %145 = arith.subf %in, %144 : f64 + %146 = arith.addf %145, %in_2 : f64 + %147 = arith.mulf %146, %cst : f64 + %148 = arith.subf %in_3, %144 : f64 + %149 = arith.addf %148, %in_4 : f64 + %150 = arith.mulf %149, %cst : f64 + %151 = arith.addf %147, %150 : f64 + %152 = arith.subf %in_5, %144 : f64 + %153 = arith.addf %152, %in_6 : f64 + %154 = arith.mulf %153, %cst : f64 + %155 = arith.addf %151, %154 : f64 + %156 = arith.addf %155, %in_1 : f64 + linalg.yield %156 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 1 to 21 { + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %6 = arith.subi %5, %c1 : index + %7 = polygeist.submap(%arg2, %4, %6, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %9, %11, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg2, %14, %16, %2) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %21 = arith.subi %20, %c1 : index + %22 = polygeist.submap(%arg2, %19, %21, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg2, %24, %26, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %28 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg2, %29, %31, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %36 = arith.subi %35, %c1 : index + %37 = polygeist.submap(%arg2, %34, %36, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %38 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %39 = arith.subi %38, %c1 : index + %40 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg3, %39, %41, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%7, %12, %17, %22, %27, %32, %37 : memref, memref, memref, memref, memref, memref, memref) outs(%42 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %46 = arith.subi %45, %c1 : index + %47 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %48 = arith.subi %47, %c1 : index + %49 = polygeist.submap(%arg3, %46, %48, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %50 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %51 = arith.subi %50, %c1 : index + %52 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %53 = arith.subi %52, %c1 : index + %54 = polygeist.submap(%arg3, %51, %53, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %55 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %56 = arith.subi %55, %c1 : index + %57 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %58 = arith.subi %57, %c1 : index + %59 = polygeist.submap(%arg3, %56, %58, %44) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %60 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %61 = arith.subi %60, %c1 : index + %62 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %63 = arith.subi %62, %c1 : index + %64 = polygeist.submap(%arg3, %61, %63, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %65 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %66 = arith.subi %65, %c1 : index + %67 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %68 = arith.subi %67, %c1 : index + %69 = polygeist.submap(%arg3, %66, %68, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %70 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %71 = arith.subi %70, %c1 : index + %72 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %73 = arith.subi %72, %c1 : index + %74 = polygeist.submap(%arg3, %71, %73, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %75 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %76 = arith.subi %75, %c1 : index + %77 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %78 = arith.subi %77, %c1 : index + %79 = polygeist.submap(%arg3, %76, %78, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %80 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %81 = arith.subi %80, %c1 : index + %82 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %83 = arith.subi %82, %c1 : index + %84 = polygeist.submap(%arg2, %81, %83, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%49, %54, %59, %64, %69, %74, %79 : memref, memref, memref, memref, memref, memref, memref) outs(%84 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (1) + ubMap: () -> (21) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%10, %15, %20, %25, %30, %35, %40 : memref, memref, memref, memref, memref, memref, memref) outs(%45 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %88 = arith.mulf %in_1, %cst_0 : f64 + %89 = arith.subf %in, %88 : f64 + %90 = arith.addf %89, %in_2 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.subf %in_3, %88 : f64 + %93 = arith.addf %92, %in_4 : f64 + %94 = arith.mulf %93, %cst : f64 + %95 = arith.addf %91, %94 : f64 + %96 = arith.subf %in_5, %88 : f64 + %97 = arith.addf %96, %in_6 : f64 + %98 = arith.mulf %97, %cst : f64 + %99 = arith.addf %95, %98 : f64 + %100 = arith.addf %99, %in_1 : f64 + linalg.yield %100 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%108, %113, %118, %123, %128, %133, %138 : memref, memref, memref, memref, memref, memref, memref) outs(%143 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %144 = arith.mulf %in_1, %cst_0 : f64 + %145 = arith.subf %in, %144 : f64 + %146 = arith.addf %145, %in_2 : f64 + %147 = arith.mulf %146, %cst : f64 + %148 = arith.subf %in_3, %144 : f64 + %149 = arith.addf %148, %in_4 : f64 + %150 = arith.mulf %149, %cst : f64 + %151 = arith.addf %147, %150 : f64 + %152 = arith.subf %in_5, %144 : f64 + %153 = arith.addf %152, %in_6 : f64 + %154 = arith.mulf %153, %cst : f64 + %155 = arith.addf %151, %154 : f64 + %156 = arith.addf %155, %in_1 : f64 + linalg.yield %156 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 1 to 21 { + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %6 = arith.subi %5, %c1 : index + %7 = polygeist.submap(%arg2, %4, %6, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %9, %11, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg2, %14, %16, %2) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %21 = arith.subi %20, %c1 : index + %22 = polygeist.submap(%arg2, %19, %21, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg2, %24, %26, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %28 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg2, %29, %31, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %36 = arith.subi %35, %c1 : index + %37 = polygeist.submap(%arg2, %34, %36, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %38 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %39 = arith.subi %38, %c1 : index + %40 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg3, %39, %41, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%7, %12, %17, %22, %27, %32, %37 : memref, memref, memref, memref, memref, memref, memref) outs(%42 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %46 = arith.subi %45, %c1 : index + %47 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %48 = arith.subi %47, %c1 : index + %49 = polygeist.submap(%arg3, %46, %48, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %50 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %51 = arith.subi %50, %c1 : index + %52 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %53 = arith.subi %52, %c1 : index + %54 = polygeist.submap(%arg3, %51, %53, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %55 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %56 = arith.subi %55, %c1 : index + %57 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %58 = arith.subi %57, %c1 : index + %59 = polygeist.submap(%arg3, %56, %58, %44) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %60 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %61 = arith.subi %60, %c1 : index + %62 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %63 = arith.subi %62, %c1 : index + %64 = polygeist.submap(%arg3, %61, %63, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %65 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %66 = arith.subi %65, %c1 : index + %67 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %68 = arith.subi %67, %c1 : index + %69 = polygeist.submap(%arg3, %66, %68, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %70 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %71 = arith.subi %70, %c1 : index + %72 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %73 = arith.subi %72, %c1 : index + %74 = polygeist.submap(%arg3, %71, %73, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %75 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %76 = arith.subi %75, %c1 : index + %77 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %78 = arith.subi %77, %c1 : index + %79 = polygeist.submap(%arg3, %76, %78, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %80 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %81 = arith.subi %80, %c1 : index + %82 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %83 = arith.subi %82, %c1 : index + %84 = polygeist.submap(%arg2, %81, %83, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%49, %54, %59, %64, %69, %74, %79 : memref, memref, memref, memref, memref, memref, memref) outs(%84 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (1) + ubMap: () -> (21) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%10, %15, %20, %25, %30, %35, %40 : memref, memref, memref, memref, memref, memref, memref) outs(%45 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %88 = arith.mulf %in_1, %cst_0 : f64 + %89 = arith.subf %in, %88 : f64 + %90 = arith.addf %89, %in_2 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.subf %in_3, %88 : f64 + %93 = arith.addf %92, %in_4 : f64 + %94 = arith.mulf %93, %cst : f64 + %95 = arith.addf %91, %94 : f64 + %96 = arith.subf %in_5, %88 : f64 + %97 = arith.addf %96, %in_6 : f64 + %98 = arith.mulf %97, %cst : f64 + %99 = arith.addf %95, %98 : f64 + %100 = arith.addf %99, %in_1 : f64 + linalg.yield %100 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%108, %113, %118, %123, %128, %133, %138 : memref, memref, memref, memref, memref, memref, memref) outs(%143 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %144 = arith.mulf %in_1, %cst_0 : f64 + %145 = arith.subf %in, %144 : f64 + %146 = arith.addf %145, %in_2 : f64 + %147 = arith.mulf %146, %cst : f64 + %148 = arith.subf %in_3, %144 : f64 + %149 = arith.addf %148, %in_4 : f64 + %150 = arith.mulf %149, %cst : f64 + %151 = arith.addf %147, %150 : f64 + %152 = arith.subf %in_5, %144 : f64 + %153 = arith.addf %152, %in_6 : f64 + %154 = arith.mulf %153, %cst : f64 + %155 = arith.addf %151, %154 : f64 + %156 = arith.addf %155, %in_1 : f64 + linalg.yield %156 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 1 to 21 { + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %6 = arith.subi %5, %c1 : index + %7 = polygeist.submap(%arg2, %4, %6, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %9, %11, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg2, %14, %16, %2) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %21 = arith.subi %20, %c1 : index + %22 = polygeist.submap(%arg2, %19, %21, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg2, %24, %26, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %28 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg2, %29, %31, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %36 = arith.subi %35, %c1 : index + %37 = polygeist.submap(%arg2, %34, %36, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %38 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %39 = arith.subi %38, %c1 : index + %40 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg3, %39, %41, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%7, %12, %17, %22, %27, %32, %37 : memref, memref, memref, memref, memref, memref, memref) outs(%42 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %46 = arith.subi %45, %c1 : index + %47 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %48 = arith.subi %47, %c1 : index + %49 = polygeist.submap(%arg3, %46, %48, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %50 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %51 = arith.subi %50, %c1 : index + %52 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %53 = arith.subi %52, %c1 : index + %54 = polygeist.submap(%arg3, %51, %53, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %55 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %56 = arith.subi %55, %c1 : index + %57 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %58 = arith.subi %57, %c1 : index + %59 = polygeist.submap(%arg3, %56, %58, %44) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %60 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %61 = arith.subi %60, %c1 : index + %62 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %63 = arith.subi %62, %c1 : index + %64 = polygeist.submap(%arg3, %61, %63, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %65 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %66 = arith.subi %65, %c1 : index + %67 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %68 = arith.subi %67, %c1 : index + %69 = polygeist.submap(%arg3, %66, %68, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %70 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %71 = arith.subi %70, %c1 : index + %72 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %73 = arith.subi %72, %c1 : index + %74 = polygeist.submap(%arg3, %71, %73, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %75 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %76 = arith.subi %75, %c1 : index + %77 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %78 = arith.subi %77, %c1 : index + %79 = polygeist.submap(%arg3, %76, %78, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %80 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %81 = arith.subi %80, %c1 : index + %82 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %83 = arith.subi %82, %c1 : index + %84 = polygeist.submap(%arg2, %81, %83, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%49, %54, %59, %64, %69, %74, %79 : memref, memref, memref, memref, memref, memref, memref) outs(%84 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (1) + ubMap: () -> (21) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%10, %15, %20, %25, %30, %35, %40 : memref, memref, memref, memref, memref, memref, memref) outs(%45 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %88 = arith.mulf %in_1, %cst_0 : f64 + %89 = arith.subf %in, %88 : f64 + %90 = arith.addf %89, %in_2 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.subf %in_3, %88 : f64 + %93 = arith.addf %92, %in_4 : f64 + %94 = arith.mulf %93, %cst : f64 + %95 = arith.addf %91, %94 : f64 + %96 = arith.subf %in_5, %88 : f64 + %97 = arith.addf %96, %in_6 : f64 + %98 = arith.mulf %97, %cst : f64 + %99 = arith.addf %95, %98 : f64 + %100 = arith.addf %99, %in_1 : f64 + linalg.yield %100 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%108, %113, %118, %123, %128, %133, %138 : memref, memref, memref, memref, memref, memref, memref) outs(%143 : memref) { +^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %144 = arith.mulf %in_1, %cst_0 : f64 + %145 = arith.subf %in, %144 : f64 + %146 = arith.addf %145, %in_2 : f64 + %147 = arith.mulf %146, %cst : f64 + %148 = arith.subf %in_3, %144 : f64 + %149 = arith.addf %148, %in_4 : f64 + %150 = arith.mulf %149, %cst : f64 + %151 = arith.addf %147, %150 : f64 + %152 = arith.subf %in_5, %144 : f64 + %153 = arith.addf %152, %in_6 : f64 + %154 = arith.mulf %153, %cst : f64 + %155 = arith.addf %151, %154 : f64 + %156 = arith.addf %155, %in_1 : f64 + linalg.yield %156 : f64 +} + Processing 7 inputs + Input 0 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 2, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1, d0 + 1) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 2) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1, d2) -> (d0, d1, d2) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0) + firstNDims: 3 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1, d2) -> (d0, d1, d2) + Found SubmapOp with map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Composed map: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + Final lgMap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1) + firstNDims: 3 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2, d3) -> (d2 + 1, d1 + 1, d0 + 1) + validDims: 3, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + +WARNING: AffineForOpRaising didn't converge +heat-3d.mlir:3:3: warning: AffineForOpRaising didn't converge, continuing anyway + func.func @kernel_heat_3d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +heat-3d.mlir:3:3: note: see current operation: +func.func @kernel_heat_3d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 1.250000e-01 : f64 + %cst_0 = arith.constant 2.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + affine.for %arg4 = 1 to 21 { + %1 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %2 = arith.subi %1, %c1 : index + %3 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %6 = arith.subi %5, %c1 : index + %7 = polygeist.submap(%arg2, %4, %6, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %9, %11, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %16 = arith.subi %15, %c1 : index + %17 = polygeist.submap(%arg2, %14, %16, %2) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %18 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %19 = arith.subi %18, %c1 : index + %20 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %21 = arith.subi %20, %c1 : index + %22 = polygeist.submap(%arg2, %19, %21, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %23 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg2, %24, %26, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %28 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %29 = arith.subi %28, %c1 : index + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg2, %29, %31, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %36 = arith.subi %35, %c1 : index + %37 = polygeist.submap(%arg2, %34, %36, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %38 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %39 = arith.subi %38, %c1 : index + %40 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %41 = arith.subi %40, %c1 : index + %42 = polygeist.submap(%arg3, %39, %41, %2) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%7, %12, %17, %22, %27, %32, %37 : memref, memref, memref, memref, memref, memref, memref) outs(%42 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } + %43 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %44 = arith.subi %43, %c1 : index + %45 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %46 = arith.subi %45, %c1 : index + %47 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %48 = arith.subi %47, %c1 : index + %49 = polygeist.submap(%arg3, %46, %48, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %50 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %51 = arith.subi %50, %c1 : index + %52 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %53 = arith.subi %52, %c1 : index + %54 = polygeist.submap(%arg3, %51, %53, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %55 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %56 = arith.subi %55, %c1 : index + %57 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %58 = arith.subi %57, %c1 : index + %59 = polygeist.submap(%arg3, %56, %58, %44) {map = affine_map<(d0, d1, d2) -> (d2, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + %60 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %61 = arith.subi %60, %c1 : index + %62 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %63 = arith.subi %62, %c1 : index + %64 = polygeist.submap(%arg3, %61, %63, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 2, d0 + 1)>} : (memref, index, index, index) -> memref + %65 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %66 = arith.subi %65, %c1 : index + %67 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %68 = arith.subi %67, %c1 : index + %69 = polygeist.submap(%arg3, %66, %68, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1, d0 + 1)>} : (memref, index, index, index) -> memref + %70 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %71 = arith.subi %70, %c1 : index + %72 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %73 = arith.subi %72, %c1 : index + %74 = polygeist.submap(%arg3, %71, %73, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 2)>} : (memref, index, index, index) -> memref + %75 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %76 = arith.subi %75, %c1 : index + %77 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %78 = arith.subi %77, %c1 : index + %79 = polygeist.submap(%arg3, %76, %78, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0)>} : (memref, index, index, index) -> memref + %80 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %81 = arith.subi %80, %c1 : index + %82 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %83 = arith.subi %82, %c1 : index + %84 = polygeist.submap(%arg2, %81, %83, %44) {map = affine_map<(d0, d1, d2) -> (d2 + 1, d1 + 1, d0 + 1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types = ["parallel", "parallel", "parallel"]} ins(%49, %54, %59, %64, %69, %74, %79 : memref, memref, memref, memref, memref, memref, memref) outs(%84 : memref) { + ^bb0(%in: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %85 = arith.mulf %in_1, %cst_0 : f64 + %86 = arith.subf %in, %85 : f64 + %87 = arith.addf %86, %in_2 : f64 + %88 = arith.mulf %87, %cst : f64 + %89 = arith.subf %in_3, %85 : f64 + %90 = arith.addf %89, %in_4 : f64 + %91 = arith.mulf %90, %cst : f64 + %92 = arith.addf %88, %91 : f64 + %93 = arith.subf %in_5, %85 : f64 + %94 = arith.addf %93, %in_6 : f64 + %95 = arith.mulf %94, %cst : f64 + %96 = arith.addf %92, %95 : f64 + %97 = arith.addf %96, %in_1 : f64 + linalg.yield %97 : f64 + } + } + return +} +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/jacobi-1d.log b/polybench_results/reject_logs/jacobi-1d.log new file mode 100644 index 000000000000..2c8080475367 --- /dev/null +++ b/polybench_results/reject_logs/jacobi-1d.log @@ -0,0 +1,2865 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg5) = (1) to (symbol(%0) - 1) { + %2 = affine.load %arg3[%arg5 - 1] : memref + %3 = affine.load %arg3[%arg5] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg3[%arg5 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + affine.store %7, %arg2[%arg5] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg5) = (1) to (symbol(%0) - 1) { + %2 = affine.load %arg2[%arg5 - 1] : memref + %3 = affine.load %arg2[%arg5] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg2[%arg5 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + affine.store %7, %arg3[%arg5] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg5) = (1) to (symbol(%0) - 1) { + %2 = affine.load %arg3[%arg5 - 1] : memref + %3 = affine.load %arg3[%arg5] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg3[%arg5 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + affine.store %7, %arg2[%arg5] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg5) = (1) to (symbol(%0) - 1) { + %2 = affine.load %arg2[%arg5 - 1] : memref + %3 = affine.load %arg2[%arg5] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg2[%arg5 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + affine.store %7, %arg3[%arg5] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %2 = affine.load %arg3[%arg5 - 1] : memref + %3 = affine.load %arg3[%arg5] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg3[%arg5 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %6, %cst : f64 + affine.store %7, %arg2[%arg5] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %5 = affine.load %arg3[%arg5 - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 - 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %7 = affine.load %arg3[%arg5] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %10 = affine.load %arg3[%arg5 + 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %13, %arg2[%arg5] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 3 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %8 = affine.load %arg2[%arg5 - 1] : memref + %9 = affine.load %arg2[%arg5] : memref + %10 = arith.addf %8, %9 : f64 + %11 = affine.load %arg2[%arg5 + 1] : memref + %12 = arith.addf %10, %11 : f64 + %13 = arith.mulf %12, %cst : f64 + affine.store %13, %arg3[%arg5] : memref + } + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg3, %3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg3, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %6 = polygeist.submap(%arg3, %3) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %7 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6 : memref, memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %8 = arith.addf %in, %in_0 : f64 + %9 = arith.addf %8, %in_1 : f64 + %10 = arith.mulf %9, %cst : f64 + linalg.yield %10 : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %8 = affine.load %arg2[%arg5 - 1] : memref + %9 = affine.load %arg2[%arg5] : memref + %10 = arith.addf %8, %9 : f64 + %11 = affine.load %arg2[%arg5 + 1] : memref + %12 = arith.addf %10, %11 : f64 + %13 = arith.mulf %12, %cst : f64 + affine.store %13, %arg3[%arg5] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %11 = affine.load %arg2[%arg5 - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 - 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %13 = affine.load %arg2[%arg5] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %16 = affine.load %arg2[%arg5 + 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %19, %arg3[%arg5] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 3 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %6 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %7 = polygeist.submap(%arg3, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6 : memref, memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %11 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %12 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %13 = polygeist.submap(%arg2, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%10, %11, %12 : memref, memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7, %8, %9 : memref, memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %17 = arith.addf %in, %in_0 : f64 + %18 = arith.addf %17, %in_1 : f64 + %19 = arith.mulf %18, %cst : f64 + linalg.yield %19 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %29 = arith.addf %in, %in_0 : f64 + %30 = arith.addf %29, %in_1 : f64 + %31 = arith.mulf %30, %cst : f64 + linalg.yield %31 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %6 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %7 = polygeist.submap(%arg3, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6 : memref, memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %11 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %12 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %13 = polygeist.submap(%arg2, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%10, %11, %12 : memref, memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7, %8, %9 : memref, memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %17 = arith.addf %in, %in_0 : f64 + %18 = arith.addf %17, %in_1 : f64 + %19 = arith.mulf %18, %cst : f64 + linalg.yield %19 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %29 = arith.addf %in, %in_0 : f64 + %30 = arith.addf %29, %in_1 : f64 + %31 = arith.mulf %30, %cst : f64 + linalg.yield %31 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %6 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %7 = polygeist.submap(%arg3, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6 : memref, memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %11 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %12 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %13 = polygeist.submap(%arg2, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%10, %11, %12 : memref, memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7, %8, %9 : memref, memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %17 = arith.addf %in, %in_0 : f64 + %18 = arith.addf %17, %in_1 : f64 + %19 = arith.mulf %18, %cst : f64 + linalg.yield %19 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %29 = arith.addf %in, %in_0 : f64 + %30 = arith.addf %29, %in_1 : f64 + %31 = arith.mulf %30, %cst : f64 + linalg.yield %31 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %6 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %7 = polygeist.submap(%arg3, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6 : memref, memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %11 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %12 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %13 = polygeist.submap(%arg2, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%10, %11, %12 : memref, memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7, %8, %9 : memref, memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %17 = arith.addf %in, %in_0 : f64 + %18 = arith.addf %17, %in_1 : f64 + %19 = arith.mulf %18, %cst : f64 + linalg.yield %19 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %29 = arith.addf %in, %in_0 : f64 + %30 = arith.addf %29, %in_1 : f64 + %31 = arith.mulf %30, %cst : f64 + linalg.yield %31 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %6 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %7 = polygeist.submap(%arg3, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6 : memref, memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %11 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %12 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %13 = polygeist.submap(%arg2, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%10, %11, %12 : memref, memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7, %8, %9 : memref, memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %17 = arith.addf %in, %in_0 : f64 + %18 = arith.addf %17, %in_1 : f64 + %19 = arith.mulf %18, %cst : f64 + linalg.yield %19 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %29 = arith.addf %in, %in_0 : f64 + %30 = arith.addf %29, %in_1 : f64 + %31 = arith.mulf %30, %cst : f64 + linalg.yield %31 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %6 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %7 = polygeist.submap(%arg3, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6 : memref, memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %11 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %12 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %13 = polygeist.submap(%arg2, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%10, %11, %12 : memref, memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7, %8, %9 : memref, memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %17 = arith.addf %in, %in_0 : f64 + %18 = arith.addf %17, %in_1 : f64 + %19 = arith.mulf %18, %cst : f64 + linalg.yield %19 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %29 = arith.addf %in, %in_0 : f64 + %30 = arith.addf %29, %in_1 : f64 + %31 = arith.mulf %30, %cst : f64 + linalg.yield %31 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %6 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %7 = polygeist.submap(%arg3, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6 : memref, memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %11 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %12 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %13 = polygeist.submap(%arg2, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%10, %11, %12 : memref, memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7, %8, %9 : memref, memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %17 = arith.addf %in, %in_0 : f64 + %18 = arith.addf %17, %in_1 : f64 + %19 = arith.mulf %18, %cst : f64 + linalg.yield %19 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %29 = arith.addf %in, %in_0 : f64 + %30 = arith.addf %29, %in_1 : f64 + %31 = arith.mulf %30, %cst : f64 + linalg.yield %31 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %6 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %7 = polygeist.submap(%arg3, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6 : memref, memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %11 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %12 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %13 = polygeist.submap(%arg2, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%10, %11, %12 : memref, memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7, %8, %9 : memref, memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %17 = arith.addf %in, %in_0 : f64 + %18 = arith.addf %17, %in_1 : f64 + %19 = arith.mulf %18, %cst : f64 + linalg.yield %19 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %29 = arith.addf %in, %in_0 : f64 + %30 = arith.addf %29, %in_1 : f64 + %31 = arith.mulf %30, %cst : f64 + linalg.yield %31 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %6 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %7 = polygeist.submap(%arg3, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6 : memref, memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %11 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %12 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %13 = polygeist.submap(%arg2, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%10, %11, %12 : memref, memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7, %8, %9 : memref, memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %17 = arith.addf %in, %in_0 : f64 + %18 = arith.addf %17, %in_1 : f64 + %19 = arith.mulf %18, %cst : f64 + linalg.yield %19 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %29 = arith.addf %in, %in_0 : f64 + %30 = arith.addf %29, %in_1 : f64 + %31 = arith.mulf %30, %cst : f64 + linalg.yield %31 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %6 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %7 = polygeist.submap(%arg3, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6 : memref, memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %11 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %12 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %13 = polygeist.submap(%arg2, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%10, %11, %12 : memref, memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7, %8, %9 : memref, memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %17 = arith.addf %in, %in_0 : f64 + %18 = arith.addf %17, %in_1 : f64 + %19 = arith.mulf %18, %cst : f64 + linalg.yield %19 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%25, %26, %27 : memref, memref, memref) outs(%28 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %29 = arith.addf %in, %in_0 : f64 + %30 = arith.addf %29, %in_1 : f64 + %31 = arith.mulf %30, %cst : f64 + linalg.yield %31 : f64 +} + Processing 3 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 2) + Composed map: (d0) -> (d0 + 2) + Final lgMap: (d0) -> (d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0 + 2) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0 + 1) + Composed map: (d0) -> (d0 + 1) + Final lgMap: (d0) -> (d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1) -> (d0 + 1) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + +WARNING: AffineForOpRaising didn't converge +jacobi-1d.mlir:3:3: warning: AffineForOpRaising didn't converge, continuing anyway + func.func @kernel_jacobi_1d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +jacobi-1d.mlir:3:3: note: see current operation: +func.func @kernel_jacobi_1d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 3.333300e-01 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %6 = polygeist.submap(%arg2, %3) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %7 = polygeist.submap(%arg3, %3) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6 : memref, memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } + %8 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %9 = arith.subi %8, %c1 : index + %10 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %11 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + %12 = polygeist.submap(%arg3, %9) {map = affine_map<(d0) -> (d0 + 2)>} : (memref, index) -> memref + %13 = polygeist.submap(%arg2, %9) {map = affine_map<(d0) -> (d0 + 1)>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%10, %11, %12 : memref, memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %out: f64): + %14 = arith.addf %in, %in_0 : f64 + %15 = arith.addf %14, %in_1 : f64 + %16 = arith.mulf %15, %cst : f64 + linalg.yield %16 : f64 + } + } + return +} +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/jacobi-2d.log b/polybench_results/reject_logs/jacobi-2d.log new file mode 100644 index 000000000000..06a8a244e15f --- /dev/null +++ b/polybench_results/reject_logs/jacobi-2d.log @@ -0,0 +1,4865 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg5) = (1) to (symbol(%0) - 1) { + affine.parallel (%arg6) = (1) to (symbol(%0) - 1) { + %2 = affine.load %arg3[%arg5, %arg6] : memref + %3 = affine.load %arg3[%arg5, %arg6 - 1] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg3[%arg5, %arg6 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = affine.load %arg3[%arg5 + 1, %arg6] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg3[%arg5 - 1, %arg6] : memref + %10 = arith.addf %8, %9 : f64 + %11 = arith.mulf %10, %cst : f64 + affine.store %11, %arg2[%arg5, %arg6] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (1) to (symbol(%0) - 1) { + %2 = affine.load %arg3[%arg5, %arg6] : memref + %3 = affine.load %arg3[%arg5, %arg6 - 1] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg3[%arg5, %arg6 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = affine.load %arg3[%arg5 + 1, %arg6] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg3[%arg5 - 1, %arg6] : memref + %10 = arith.addf %8, %9 : f64 + %11 = arith.mulf %10, %cst : f64 + affine.store %11, %arg2[%arg5, %arg6] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg5) = (1) to (symbol(%0) - 1) { + affine.parallel (%arg6) = (1) to (symbol(%0) - 1) { + %2 = affine.load %arg2[%arg5, %arg6] : memref + %3 = affine.load %arg2[%arg5, %arg6 - 1] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg2[%arg5, %arg6 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = affine.load %arg2[%arg5 + 1, %arg6] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg2[%arg5 - 1, %arg6] : memref + %10 = arith.addf %8, %9 : f64 + %11 = arith.mulf %10, %cst : f64 + affine.store %11, %arg3[%arg5, %arg6] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (1) to (symbol(%0) - 1) { + %2 = affine.load %arg2[%arg5, %arg6] : memref + %3 = affine.load %arg2[%arg5, %arg6 - 1] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg2[%arg5, %arg6 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = affine.load %arg2[%arg5 + 1, %arg6] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg2[%arg5 - 1, %arg6] : memref + %10 = arith.addf %8, %9 : f64 + %11 = arith.mulf %10, %cst : f64 + affine.store %11, %arg3[%arg5, %arg6] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg5) = (1) to (symbol(%0) - 1) { + affine.parallel (%arg6) = (1) to (symbol(%0) - 1) { + %2 = affine.load %arg3[%arg5, %arg6] : memref + %3 = affine.load %arg3[%arg5, %arg6 - 1] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg3[%arg5, %arg6 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = affine.load %arg3[%arg5 + 1, %arg6] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg3[%arg5 - 1, %arg6] : memref + %10 = arith.addf %8, %9 : f64 + %11 = arith.mulf %10, %cst : f64 + affine.store %11, %arg2[%arg5, %arg6] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg6) = (1) to (symbol(%0) - 1) { + %2 = affine.load %arg3[%arg5, %arg6] : memref + %3 = affine.load %arg3[%arg5, %arg6 - 1] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg3[%arg5, %arg6 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = affine.load %arg3[%arg5 + 1, %arg6] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg3[%arg5 - 1, %arg6] : memref + %10 = arith.addf %8, %9 : f64 + %11 = arith.mulf %10, %cst : f64 + affine.store %11, %arg2[%arg5, %arg6] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg5) = (1) to (symbol(%0) - 1) { + affine.parallel (%arg6) = (1) to (symbol(%0) - 1) { + %2 = affine.load %arg2[%arg5, %arg6] : memref + %3 = affine.load %arg2[%arg5, %arg6 - 1] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg2[%arg5, %arg6 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = affine.load %arg2[%arg5 + 1, %arg6] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg2[%arg5 - 1, %arg6] : memref + %10 = arith.addf %8, %9 : f64 + %11 = arith.mulf %10, %cst : f64 + affine.store %11, %arg3[%arg5, %arg6] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg6) = (1) to (symbol(%0) - 1) { + %2 = affine.load %arg2[%arg5, %arg6] : memref + %3 = affine.load %arg2[%arg5, %arg6 - 1] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg2[%arg5, %arg6 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = affine.load %arg2[%arg5 + 1, %arg6] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg2[%arg5 - 1, %arg6] : memref + %10 = arith.addf %8, %9 : f64 + %11 = arith.mulf %10, %cst : f64 + affine.store %11, %arg3[%arg5, %arg6] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %2 = affine.load %arg3[%arg5, %arg6] : memref + %3 = affine.load %arg3[%arg5, %arg6 - 1] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg3[%arg5, %arg6 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = affine.load %arg3[%arg5 + 1, %arg6] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg3[%arg5 - 1, %arg6] : memref + %10 = arith.addf %8, %9 : f64 + %11 = arith.mulf %10, %cst : f64 + affine.store %11, %arg2[%arg5, %arg6] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %2 = affine.load %arg3[%arg5, %arg6] : memref + %3 = affine.load %arg3[%arg5, %arg6 - 1] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg3[%arg5, %arg6 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = affine.load %arg3[%arg5 + 1, %arg6] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg3[%arg5 - 1, %arg6] : memref + %10 = arith.addf %8, %9 : f64 + %11 = arith.mulf %10, %cst : f64 + affine.store %11, %arg2[%arg5, %arg6] : memref +} + +Pattern recognition complete: + Loads: 5 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %5 = affine.load %arg3[%arg5, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0 + 1) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %7 = affine.load %arg3[%arg5, %arg6 - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1 - 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %10 = affine.load %arg3[%arg5, %arg6 + 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1 + 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0 + 2) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %13 = affine.load %arg3[%arg5 + 1, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0 + 1, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0 + 1, d0 + 1) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %16 = affine.load %arg3[%arg5 - 1, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0 - 1, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0 - 1, d0 + 1) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %19, %arg2[%arg5, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0 + 1) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 5 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg3, %arg5, %3) {map = affine_map<(d0)[s0] -> (s0, d0 + 1)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg3, %arg5, %3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg3, %arg5, %3) {map = affine_map<(d0)[s0] -> (s0, d0 + 2)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg3, %arg5, %3) {map = affine_map<(d0)[s0] -> (s0 + 1, d0 + 1)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg3, %arg5, %3) {map = affine_map<(d0)[s0] -> (s0 - 1, d0 + 1)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg2, %arg5, %3) {map = affine_map<(d0)[s0] -> (s0, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6, %7, %8 : memref, memref, memref, memref, memref) outs(%9 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %10 = arith.addf %in, %in_0 : f64 + %11 = arith.addf %10, %in_1 : f64 + %12 = arith.addf %11, %in_2 : f64 + %13 = arith.addf %12, %in_3 : f64 + %14 = arith.mulf %13, %cst : f64 + linalg.yield %14 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7, %8, %9, %10, %11 : memref, memref, memref, memref, memref) outs(%12 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %13 = arith.addf %in, %in_0 : f64 + %14 = arith.addf %13, %in_1 : f64 + %15 = arith.addf %14, %in_2 : f64 + %16 = arith.addf %15, %in_3 : f64 + %17 = arith.mulf %16, %cst : f64 + linalg.yield %17 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0 + 1) + Composed map: (d0)[s0] -> (s0, d0 + 1) + Final lgMap: (d0)[s0] -> (s0, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0 + 2) + Composed map: (d0)[s0] -> (s0, d0 + 2) + Final lgMap: (d0)[s0] -> (s0, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0 + 1, d0 + 1) + Composed map: (d0)[s0] -> (s0 + 1, d0 + 1) + Final lgMap: (d0)[s0] -> (s0 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0 + 1, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0 - 1, d0 + 1) + Composed map: (d0)[s0] -> (s0 - 1, d0 + 1) + Final lgMap: (d0)[s0] -> (s0 - 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0 - 1, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0 + 1) + Composed map: (d0)[s0] -> (s0, d0 + 1) + Final lgMap: (d0)[s0] -> (s0, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 5 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %22 = affine.load %arg2[%arg5, %arg6] : memref + %23 = affine.load %arg2[%arg5, %arg6 - 1] : memref + %24 = arith.addf %22, %23 : f64 + %25 = affine.load %arg2[%arg5, %arg6 + 1] : memref + %26 = arith.addf %24, %25 : f64 + %27 = affine.load %arg2[%arg5 + 1, %arg6] : memref + %28 = arith.addf %26, %27 : f64 + %29 = affine.load %arg2[%arg5 - 1, %arg6] : memref + %30 = arith.addf %28, %29 : f64 + %31 = arith.mulf %30, %cst : f64 + affine.store %31, %arg3[%arg5, %arg6] : memref + } + } + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg3, %5, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %7 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg3, %8, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg3, %11, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = polygeist.submap(%arg3, %14, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %17 = arith.subi %16, %c1 : index + %18 = polygeist.submap(%arg3, %17, %3) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %19 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg2, %20, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %9, %12, %15, %18 : memref, memref, memref, memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %22 = arith.addf %in, %in_0 : f64 + %23 = arith.addf %22, %in_1 : f64 + %24 = arith.addf %23, %in_2 : f64 + %25 = arith.addf %24, %in_3 : f64 + %26 = arith.mulf %25, %cst : f64 + linalg.yield %26 : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %22 = affine.load %arg2[%arg5, %arg6] : memref + %23 = affine.load %arg2[%arg5, %arg6 - 1] : memref + %24 = arith.addf %22, %23 : f64 + %25 = affine.load %arg2[%arg5, %arg6 + 1] : memref + %26 = arith.addf %24, %25 : f64 + %27 = affine.load %arg2[%arg5 + 1, %arg6] : memref + %28 = arith.addf %26, %27 : f64 + %29 = affine.load %arg2[%arg5 - 1, %arg6] : memref + %30 = arith.addf %28, %29 : f64 + %31 = arith.mulf %30, %cst : f64 + affine.store %31, %arg3[%arg5, %arg6] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %22 = affine.load %arg2[%arg5, %arg6] : memref + %23 = affine.load %arg2[%arg5, %arg6 - 1] : memref + %24 = arith.addf %22, %23 : f64 + %25 = affine.load %arg2[%arg5, %arg6 + 1] : memref + %26 = arith.addf %24, %25 : f64 + %27 = affine.load %arg2[%arg5 + 1, %arg6] : memref + %28 = arith.addf %26, %27 : f64 + %29 = affine.load %arg2[%arg5 - 1, %arg6] : memref + %30 = arith.addf %28, %29 : f64 + %31 = arith.mulf %30, %cst : f64 + affine.store %31, %arg3[%arg5, %arg6] : memref +} + +Pattern recognition complete: + Loads: 5 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %25 = affine.load %arg2[%arg5, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0 + 1) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %27 = affine.load %arg2[%arg5, %arg6 - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1 - 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %30 = affine.load %arg2[%arg5, %arg6 + 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1 + 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0 + 2) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %33 = affine.load %arg2[%arg5 + 1, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0 + 1, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0 + 1, d0 + 1) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %36 = affine.load %arg2[%arg5 - 1, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0 - 1, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0 - 1, d0 + 1) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %39, %arg3[%arg5, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0 + 1) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 5 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %23 = arith.subi %22, %c1 : index + %24 = polygeist.submap(%arg2, %arg5, %23) {map = affine_map<(d0)[s0] -> (s0, d0 + 1)>} : (memref, index, index) -> memref + %25 = polygeist.submap(%arg2, %arg5, %23) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %26 = polygeist.submap(%arg2, %arg5, %23) {map = affine_map<(d0)[s0] -> (s0, d0 + 2)>} : (memref, index, index) -> memref + %27 = polygeist.submap(%arg2, %arg5, %23) {map = affine_map<(d0)[s0] -> (s0 + 1, d0 + 1)>} : (memref, index, index) -> memref + %28 = polygeist.submap(%arg2, %arg5, %23) {map = affine_map<(d0)[s0] -> (s0 - 1, d0 + 1)>} : (memref, index, index) -> memref + %29 = polygeist.submap(%arg3, %arg5, %23) {map = affine_map<(d0)[s0] -> (s0, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%24, %25, %26, %27, %28 : memref, memref, memref, memref, memref) outs(%29 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %30 = arith.addf %in, %in_0 : f64 + %31 = arith.addf %30, %in_1 : f64 + %32 = arith.addf %31, %in_2 : f64 + %33 = arith.addf %32, %in_3 : f64 + %34 = arith.mulf %33, %cst : f64 + linalg.yield %34 : f64 + } + } + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg3, %5, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %7 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg3, %8, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg3, %11, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = polygeist.submap(%arg3, %14, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %17 = arith.subi %16, %c1 : index + %18 = polygeist.submap(%arg3, %17, %3) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %19 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg2, %20, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %9, %12, %15, %18 : memref, memref, memref, memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %22 = arith.addf %in, %in_0 : f64 + %23 = arith.addf %22, %in_1 : f64 + %24 = arith.addf %23, %in_2 : f64 + %25 = arith.addf %24, %in_3 : f64 + %26 = arith.mulf %25, %cst : f64 + linalg.yield %26 : f64 + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%0] { + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %23 = arith.subi %22, %c1 : index + %24 = polygeist.submap(%arg2, %arg5, %23) {map = affine_map<(d0)[s0] -> (s0, d0 + 1)>} : (memref, index, index) -> memref + %25 = polygeist.submap(%arg2, %arg5, %23) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %26 = polygeist.submap(%arg2, %arg5, %23) {map = affine_map<(d0)[s0] -> (s0, d0 + 2)>} : (memref, index, index) -> memref + %27 = polygeist.submap(%arg2, %arg5, %23) {map = affine_map<(d0)[s0] -> (s0 + 1, d0 + 1)>} : (memref, index, index) -> memref + %28 = polygeist.submap(%arg2, %arg5, %23) {map = affine_map<(d0)[s0] -> (s0 - 1, d0 + 1)>} : (memref, index, index) -> memref + %29 = polygeist.submap(%arg3, %arg5, %23) {map = affine_map<(d0)[s0] -> (s0, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%24, %25, %26, %27, %28 : memref, memref, memref, memref, memref) outs(%29 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %30 = arith.addf %in, %in_0 : f64 + %31 = arith.addf %30, %in_1 : f64 + %32 = arith.addf %31, %in_2 : f64 + %33 = arith.addf %32, %in_3 : f64 + %34 = arith.mulf %33, %cst : f64 + linalg.yield %34 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%27, %28, %29, %30, %31 : memref, memref, memref, memref, memref) outs(%32 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %33 = arith.addf %in, %in_0 : f64 + %34 = arith.addf %33, %in_1 : f64 + %35 = arith.addf %34, %in_2 : f64 + %36 = arith.addf %35, %in_3 : f64 + %37 = arith.mulf %36, %cst : f64 + linalg.yield %37 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0 + 1) + Composed map: (d0)[s0] -> (s0, d0 + 1) + Final lgMap: (d0)[s0] -> (s0, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0 + 2) + Composed map: (d0)[s0] -> (s0, d0 + 2) + Final lgMap: (d0)[s0] -> (s0, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0 + 1, d0 + 1) + Composed map: (d0)[s0] -> (s0 + 1, d0 + 1) + Final lgMap: (d0)[s0] -> (s0 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0 + 1, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0 - 1, d0 + 1) + Composed map: (d0)[s0] -> (s0 - 1, d0 + 1) + Final lgMap: (d0)[s0] -> (s0 - 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0 - 1, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0 + 1) + Composed map: (d0)[s0] -> (s0, d0 + 1) + Final lgMap: (d0)[s0] -> (s0, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 5 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg2, %5, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %7 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg2, %8, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %11, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = polygeist.submap(%arg2, %14, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %17 = arith.subi %16, %c1 : index + %18 = polygeist.submap(%arg2, %17, %3) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %19 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg3, %20, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %9, %12, %15, %18 : memref, memref, memref, memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %43 = arith.addf %in, %in_0 : f64 + %44 = arith.addf %43, %in_1 : f64 + %45 = arith.addf %44, %in_2 : f64 + %46 = arith.addf %45, %in_3 : f64 + %47 = arith.mulf %46, %cst : f64 + linalg.yield %47 : f64 + } + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %23 = arith.subi %22, %c1 : index + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %25 = arith.subi %24, %c1 : index + %26 = polygeist.submap(%arg3, %25, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %27 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %28 = arith.subi %27, %c1 : index + %29 = polygeist.submap(%arg3, %28, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg3, %31, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = polygeist.submap(%arg3, %34, %23) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %36 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %37 = arith.subi %36, %c1 : index + %38 = polygeist.submap(%arg3, %37, %23) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %39 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %40 = arith.subi %39, %c1 : index + %41 = polygeist.submap(%arg2, %40, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%26, %29, %32, %35, %38 : memref, memref, memref, memref, memref) outs(%41 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%9, %12, %15, %18, %21 : memref, memref, memref, memref, memref) outs(%24 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %45 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %46 = arith.addf %in, %in_0 : f64 + %47 = arith.addf %46, %in_1 : f64 + %48 = arith.addf %47, %in_2 : f64 + %49 = arith.addf %48, %in_3 : f64 + %50 = arith.mulf %49, %cst : f64 + linalg.yield %50 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%59, %62, %65, %68, %71 : memref, memref, memref, memref, memref) outs(%74 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %75 = arith.addf %in, %in_0 : f64 + %76 = arith.addf %75, %in_1 : f64 + %77 = arith.addf %76, %in_2 : f64 + %78 = arith.addf %77, %in_3 : f64 + %79 = arith.mulf %78, %cst : f64 + linalg.yield %79 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg2, %5, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %7 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg2, %8, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %11, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = polygeist.submap(%arg2, %14, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %17 = arith.subi %16, %c1 : index + %18 = polygeist.submap(%arg2, %17, %3) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %19 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg3, %20, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %9, %12, %15, %18 : memref, memref, memref, memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %23 = arith.subi %22, %c1 : index + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %25 = arith.subi %24, %c1 : index + %26 = polygeist.submap(%arg3, %25, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %27 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %28 = arith.subi %27, %c1 : index + %29 = polygeist.submap(%arg3, %28, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg3, %31, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = polygeist.submap(%arg3, %34, %23) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %36 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %37 = arith.subi %36, %c1 : index + %38 = polygeist.submap(%arg3, %37, %23) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %39 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %40 = arith.subi %39, %c1 : index + %41 = polygeist.submap(%arg2, %40, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%26, %29, %32, %35, %38 : memref, memref, memref, memref, memref) outs(%41 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%9, %12, %15, %18, %21 : memref, memref, memref, memref, memref) outs(%24 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %45 = arith.addf %in, %in_0 : f64 + %46 = arith.addf %45, %in_1 : f64 + %47 = arith.addf %46, %in_2 : f64 + %48 = arith.addf %47, %in_3 : f64 + %49 = arith.mulf %48, %cst : f64 + linalg.yield %49 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%59, %62, %65, %68, %71 : memref, memref, memref, memref, memref) outs(%74 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %75 = arith.addf %in, %in_0 : f64 + %76 = arith.addf %75, %in_1 : f64 + %77 = arith.addf %76, %in_2 : f64 + %78 = arith.addf %77, %in_3 : f64 + %79 = arith.mulf %78, %cst : f64 + linalg.yield %79 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg2, %5, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %7 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg2, %8, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %11, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = polygeist.submap(%arg2, %14, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %17 = arith.subi %16, %c1 : index + %18 = polygeist.submap(%arg2, %17, %3) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %19 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg3, %20, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %9, %12, %15, %18 : memref, memref, memref, memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %23 = arith.subi %22, %c1 : index + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %25 = arith.subi %24, %c1 : index + %26 = polygeist.submap(%arg3, %25, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %27 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %28 = arith.subi %27, %c1 : index + %29 = polygeist.submap(%arg3, %28, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg3, %31, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = polygeist.submap(%arg3, %34, %23) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %36 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %37 = arith.subi %36, %c1 : index + %38 = polygeist.submap(%arg3, %37, %23) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %39 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %40 = arith.subi %39, %c1 : index + %41 = polygeist.submap(%arg2, %40, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%26, %29, %32, %35, %38 : memref, memref, memref, memref, memref) outs(%41 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%9, %12, %15, %18, %21 : memref, memref, memref, memref, memref) outs(%24 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %45 = arith.addf %in, %in_0 : f64 + %46 = arith.addf %45, %in_1 : f64 + %47 = arith.addf %46, %in_2 : f64 + %48 = arith.addf %47, %in_3 : f64 + %49 = arith.mulf %48, %cst : f64 + linalg.yield %49 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%59, %62, %65, %68, %71 : memref, memref, memref, memref, memref) outs(%74 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %75 = arith.addf %in, %in_0 : f64 + %76 = arith.addf %75, %in_1 : f64 + %77 = arith.addf %76, %in_2 : f64 + %78 = arith.addf %77, %in_3 : f64 + %79 = arith.mulf %78, %cst : f64 + linalg.yield %79 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg2, %5, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %7 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg2, %8, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %11, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = polygeist.submap(%arg2, %14, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %17 = arith.subi %16, %c1 : index + %18 = polygeist.submap(%arg2, %17, %3) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %19 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg3, %20, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %9, %12, %15, %18 : memref, memref, memref, memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %23 = arith.subi %22, %c1 : index + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %25 = arith.subi %24, %c1 : index + %26 = polygeist.submap(%arg3, %25, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %27 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %28 = arith.subi %27, %c1 : index + %29 = polygeist.submap(%arg3, %28, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg3, %31, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = polygeist.submap(%arg3, %34, %23) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %36 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %37 = arith.subi %36, %c1 : index + %38 = polygeist.submap(%arg3, %37, %23) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %39 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %40 = arith.subi %39, %c1 : index + %41 = polygeist.submap(%arg2, %40, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%26, %29, %32, %35, %38 : memref, memref, memref, memref, memref) outs(%41 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%9, %12, %15, %18, %21 : memref, memref, memref, memref, memref) outs(%24 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %45 = arith.addf %in, %in_0 : f64 + %46 = arith.addf %45, %in_1 : f64 + %47 = arith.addf %46, %in_2 : f64 + %48 = arith.addf %47, %in_3 : f64 + %49 = arith.mulf %48, %cst : f64 + linalg.yield %49 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%59, %62, %65, %68, %71 : memref, memref, memref, memref, memref) outs(%74 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %75 = arith.addf %in, %in_0 : f64 + %76 = arith.addf %75, %in_1 : f64 + %77 = arith.addf %76, %in_2 : f64 + %78 = arith.addf %77, %in_3 : f64 + %79 = arith.mulf %78, %cst : f64 + linalg.yield %79 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg2, %5, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %7 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg2, %8, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %11, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = polygeist.submap(%arg2, %14, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %17 = arith.subi %16, %c1 : index + %18 = polygeist.submap(%arg2, %17, %3) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %19 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg3, %20, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %9, %12, %15, %18 : memref, memref, memref, memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %23 = arith.subi %22, %c1 : index + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %25 = arith.subi %24, %c1 : index + %26 = polygeist.submap(%arg3, %25, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %27 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %28 = arith.subi %27, %c1 : index + %29 = polygeist.submap(%arg3, %28, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg3, %31, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = polygeist.submap(%arg3, %34, %23) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %36 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %37 = arith.subi %36, %c1 : index + %38 = polygeist.submap(%arg3, %37, %23) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %39 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %40 = arith.subi %39, %c1 : index + %41 = polygeist.submap(%arg2, %40, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%26, %29, %32, %35, %38 : memref, memref, memref, memref, memref) outs(%41 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%9, %12, %15, %18, %21 : memref, memref, memref, memref, memref) outs(%24 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %45 = arith.addf %in, %in_0 : f64 + %46 = arith.addf %45, %in_1 : f64 + %47 = arith.addf %46, %in_2 : f64 + %48 = arith.addf %47, %in_3 : f64 + %49 = arith.mulf %48, %cst : f64 + linalg.yield %49 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%59, %62, %65, %68, %71 : memref, memref, memref, memref, memref) outs(%74 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %75 = arith.addf %in, %in_0 : f64 + %76 = arith.addf %75, %in_1 : f64 + %77 = arith.addf %76, %in_2 : f64 + %78 = arith.addf %77, %in_3 : f64 + %79 = arith.mulf %78, %cst : f64 + linalg.yield %79 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg2, %5, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %7 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg2, %8, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %11, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = polygeist.submap(%arg2, %14, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %17 = arith.subi %16, %c1 : index + %18 = polygeist.submap(%arg2, %17, %3) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %19 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg3, %20, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %9, %12, %15, %18 : memref, memref, memref, memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %23 = arith.subi %22, %c1 : index + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %25 = arith.subi %24, %c1 : index + %26 = polygeist.submap(%arg3, %25, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %27 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %28 = arith.subi %27, %c1 : index + %29 = polygeist.submap(%arg3, %28, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg3, %31, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = polygeist.submap(%arg3, %34, %23) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %36 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %37 = arith.subi %36, %c1 : index + %38 = polygeist.submap(%arg3, %37, %23) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %39 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %40 = arith.subi %39, %c1 : index + %41 = polygeist.submap(%arg2, %40, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%26, %29, %32, %35, %38 : memref, memref, memref, memref, memref) outs(%41 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%9, %12, %15, %18, %21 : memref, memref, memref, memref, memref) outs(%24 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %45 = arith.addf %in, %in_0 : f64 + %46 = arith.addf %45, %in_1 : f64 + %47 = arith.addf %46, %in_2 : f64 + %48 = arith.addf %47, %in_3 : f64 + %49 = arith.mulf %48, %cst : f64 + linalg.yield %49 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%59, %62, %65, %68, %71 : memref, memref, memref, memref, memref) outs(%74 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %75 = arith.addf %in, %in_0 : f64 + %76 = arith.addf %75, %in_1 : f64 + %77 = arith.addf %76, %in_2 : f64 + %78 = arith.addf %77, %in_3 : f64 + %79 = arith.mulf %78, %cst : f64 + linalg.yield %79 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg2, %5, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %7 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg2, %8, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %11, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = polygeist.submap(%arg2, %14, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %17 = arith.subi %16, %c1 : index + %18 = polygeist.submap(%arg2, %17, %3) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %19 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg3, %20, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %9, %12, %15, %18 : memref, memref, memref, memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %23 = arith.subi %22, %c1 : index + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %25 = arith.subi %24, %c1 : index + %26 = polygeist.submap(%arg3, %25, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %27 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %28 = arith.subi %27, %c1 : index + %29 = polygeist.submap(%arg3, %28, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg3, %31, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = polygeist.submap(%arg3, %34, %23) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %36 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %37 = arith.subi %36, %c1 : index + %38 = polygeist.submap(%arg3, %37, %23) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %39 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %40 = arith.subi %39, %c1 : index + %41 = polygeist.submap(%arg2, %40, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%26, %29, %32, %35, %38 : memref, memref, memref, memref, memref) outs(%41 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%9, %12, %15, %18, %21 : memref, memref, memref, memref, memref) outs(%24 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %45 = arith.addf %in, %in_0 : f64 + %46 = arith.addf %45, %in_1 : f64 + %47 = arith.addf %46, %in_2 : f64 + %48 = arith.addf %47, %in_3 : f64 + %49 = arith.mulf %48, %cst : f64 + linalg.yield %49 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%59, %62, %65, %68, %71 : memref, memref, memref, memref, memref) outs(%74 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %75 = arith.addf %in, %in_0 : f64 + %76 = arith.addf %75, %in_1 : f64 + %77 = arith.addf %76, %in_2 : f64 + %78 = arith.addf %77, %in_3 : f64 + %79 = arith.mulf %78, %cst : f64 + linalg.yield %79 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg2, %5, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %7 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg2, %8, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %11, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = polygeist.submap(%arg2, %14, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %17 = arith.subi %16, %c1 : index + %18 = polygeist.submap(%arg2, %17, %3) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %19 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg3, %20, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %9, %12, %15, %18 : memref, memref, memref, memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %23 = arith.subi %22, %c1 : index + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %25 = arith.subi %24, %c1 : index + %26 = polygeist.submap(%arg3, %25, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %27 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %28 = arith.subi %27, %c1 : index + %29 = polygeist.submap(%arg3, %28, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg3, %31, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = polygeist.submap(%arg3, %34, %23) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %36 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %37 = arith.subi %36, %c1 : index + %38 = polygeist.submap(%arg3, %37, %23) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %39 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %40 = arith.subi %39, %c1 : index + %41 = polygeist.submap(%arg2, %40, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%26, %29, %32, %35, %38 : memref, memref, memref, memref, memref) outs(%41 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%9, %12, %15, %18, %21 : memref, memref, memref, memref, memref) outs(%24 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %45 = arith.addf %in, %in_0 : f64 + %46 = arith.addf %45, %in_1 : f64 + %47 = arith.addf %46, %in_2 : f64 + %48 = arith.addf %47, %in_3 : f64 + %49 = arith.mulf %48, %cst : f64 + linalg.yield %49 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%59, %62, %65, %68, %71 : memref, memref, memref, memref, memref) outs(%74 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %75 = arith.addf %in, %in_0 : f64 + %76 = arith.addf %75, %in_1 : f64 + %77 = arith.addf %76, %in_2 : f64 + %78 = arith.addf %77, %in_3 : f64 + %79 = arith.mulf %78, %cst : f64 + linalg.yield %79 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg2, %5, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %7 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg2, %8, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %11, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = polygeist.submap(%arg2, %14, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %17 = arith.subi %16, %c1 : index + %18 = polygeist.submap(%arg2, %17, %3) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %19 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg3, %20, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %9, %12, %15, %18 : memref, memref, memref, memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %23 = arith.subi %22, %c1 : index + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %25 = arith.subi %24, %c1 : index + %26 = polygeist.submap(%arg3, %25, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %27 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %28 = arith.subi %27, %c1 : index + %29 = polygeist.submap(%arg3, %28, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg3, %31, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = polygeist.submap(%arg3, %34, %23) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %36 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %37 = arith.subi %36, %c1 : index + %38 = polygeist.submap(%arg3, %37, %23) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %39 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %40 = arith.subi %39, %c1 : index + %41 = polygeist.submap(%arg2, %40, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%26, %29, %32, %35, %38 : memref, memref, memref, memref, memref) outs(%41 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%9, %12, %15, %18, %21 : memref, memref, memref, memref, memref) outs(%24 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %45 = arith.addf %in, %in_0 : f64 + %46 = arith.addf %45, %in_1 : f64 + %47 = arith.addf %46, %in_2 : f64 + %48 = arith.addf %47, %in_3 : f64 + %49 = arith.mulf %48, %cst : f64 + linalg.yield %49 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%59, %62, %65, %68, %71 : memref, memref, memref, memref, memref) outs(%74 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %75 = arith.addf %in, %in_0 : f64 + %76 = arith.addf %75, %in_1 : f64 + %77 = arith.addf %76, %in_2 : f64 + %78 = arith.addf %77, %in_3 : f64 + %79 = arith.mulf %78, %cst : f64 + linalg.yield %79 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg2, %5, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %7 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg2, %8, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %11, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = polygeist.submap(%arg2, %14, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %17 = arith.subi %16, %c1 : index + %18 = polygeist.submap(%arg2, %17, %3) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %19 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg3, %20, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %9, %12, %15, %18 : memref, memref, memref, memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %23 = arith.subi %22, %c1 : index + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %25 = arith.subi %24, %c1 : index + %26 = polygeist.submap(%arg3, %25, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %27 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %28 = arith.subi %27, %c1 : index + %29 = polygeist.submap(%arg3, %28, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg3, %31, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = polygeist.submap(%arg3, %34, %23) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %36 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %37 = arith.subi %36, %c1 : index + %38 = polygeist.submap(%arg3, %37, %23) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %39 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %40 = arith.subi %39, %c1 : index + %41 = polygeist.submap(%arg2, %40, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%26, %29, %32, %35, %38 : memref, memref, memref, memref, memref) outs(%41 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 2 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%9, %12, %15, %18, %21 : memref, memref, memref, memref, memref) outs(%24 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %45 = arith.addf %in, %in_0 : f64 + %46 = arith.addf %45, %in_1 : f64 + %47 = arith.addf %46, %in_2 : f64 + %48 = arith.addf %47, %in_3 : f64 + %49 = arith.mulf %48, %cst : f64 + linalg.yield %49 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%59, %62, %65, %68, %71 : memref, memref, memref, memref, memref) outs(%74 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %75 = arith.addf %in, %in_0 : f64 + %76 = arith.addf %75, %in_1 : f64 + %77 = arith.addf %76, %in_2 : f64 + %78 = arith.addf %77, %in_3 : f64 + %79 = arith.mulf %78, %cst : f64 + linalg.yield %79 : f64 +} + Processing 5 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- +REJECTED: More than one linalg generic + +WARNING: AffineForOpRaising didn't converge +jacobi-2d.mlir:3:3: warning: AffineForOpRaising didn't converge, continuing anyway + func.func @kernel_jacobi_2d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +jacobi-2d.mlir:3:3: note: see current operation: +func.func @kernel_jacobi_2d(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 2.000000e-01 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg4 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg2, %5, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %7 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg2, %8, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %11, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %14 = arith.subi %13, %c1 : index + %15 = polygeist.submap(%arg2, %14, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %17 = arith.subi %16, %c1 : index + %18 = polygeist.submap(%arg2, %17, %3) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %19 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg3, %20, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %9, %12, %15, %18 : memref, memref, memref, memref, memref) outs(%21 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %23 = arith.subi %22, %c1 : index + %24 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %25 = arith.subi %24, %c1 : index + %26 = polygeist.submap(%arg3, %25, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + %27 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %28 = arith.subi %27, %c1 : index + %29 = polygeist.submap(%arg3, %28, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %30 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %31 = arith.subi %30, %c1 : index + %32 = polygeist.submap(%arg3, %31, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %33 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %34 = arith.subi %33, %c1 : index + %35 = polygeist.submap(%arg3, %34, %23) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %36 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %37 = arith.subi %36, %c1 : index + %38 = polygeist.submap(%arg3, %37, %23) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %39 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%0] + %40 = arith.subi %39, %c1 : index + %41 = polygeist.submap(%arg2, %40, %23) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%26, %29, %32, %35, %38 : memref, memref, memref, memref, memref) outs(%41 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %out: f64): + %42 = arith.addf %in, %in_0 : f64 + %43 = arith.addf %42, %in_1 : f64 + %44 = arith.addf %43, %in_2 : f64 + %45 = arith.addf %44, %in_3 : f64 + %46 = arith.mulf %45, %cst : f64 + linalg.yield %46 : f64 + } + } + return +} +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/lu.log b/polybench_results/reject_logs/lu.log new file mode 100644 index 000000000000..2fd4c6519945 --- /dev/null +++ b/polybench_results/reject_logs/lu.log @@ -0,0 +1,2101 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg3) = (%arg2) to (symbol(%0)) { + affine.parallel (%arg4) = (0) to (%arg2) { + %1 = affine.load %arg1[%arg2, %arg4] : memref + %2 = affine.load %arg1[%arg4, %arg3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg1[%arg2, %arg3] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg1[%arg2, %arg3] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg4) = (0) to (%arg2) { + %1 = affine.load %arg1[%arg2, %arg4] : memref + %2 = affine.load %arg1[%arg4, %arg3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg1[%arg2, %arg3] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg1[%arg2, %arg3] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg3) = (%arg2) to (symbol(%0)) { + affine.parallel (%arg4) = (0) to (%arg2) { + %1 = affine.load %arg1[%arg2, %arg4] : memref + %2 = affine.load %arg1[%arg4, %arg3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg1[%arg2, %arg3] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg1[%arg2, %arg3] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg4) = (0) to (%arg2) { + %1 = affine.load %arg1[%arg2, %arg4] : memref + %2 = affine.load %arg1[%arg4, %arg3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg1[%arg2, %arg3] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg1[%arg2, %arg3] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + affine.for %arg4 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = affine.load %arg1[%arg2, %arg4] : memref + %2 = affine.load %arg1[%arg4, %arg3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg1[%arg2, %arg3] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg1[%arg2, %arg3] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = affine.load %arg1[%arg2, %arg4] : memref + %2 = affine.load %arg1[%arg4, %arg3] : memref + %3 = arith.mulf %1, %2 : f64 + %4 = affine.load %arg1[%arg2, %arg3] : memref + %5 = arith.subf %4, %3 : f64 + affine.store %5, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %4 = affine.load %arg1[%arg2, %arg4] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %6 = affine.load %arg1[%arg4, %arg3] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %9 = affine.load %arg1[%arg2, %arg3] : memref + +--- Processing Stores --- +Processing store: affine.store %10, %arg1[%arg2, %arg3] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + %2 = polygeist.submap(%arg1, %arg2, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +REJECTED: Loop doesn't have constant lower bound + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +REJECTED: Loop doesn't have constant lower bound + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + affine.for %arg4 = 0 to affine_map<(d0) -> (d0)>(%arg3) { + %4 = affine.load %arg1[%arg2, %arg4] : memref + %5 = affine.load %arg1[%arg4, %arg3] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg1[%arg2, %arg3] : memref + %8 = arith.subf %7, %6 : f64 + affine.store %8, %arg1[%arg2, %arg3] : memref + } + %1 = affine.load %arg1[%arg3, %arg3] : memref + %2 = affine.load %arg1[%arg2, %arg3] : memref + %3 = arith.divf %2, %1 : f64 + affine.store %3, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + affine.for %arg4 = 0 to affine_map<(d0) -> (d0)>(%arg3) { + %4 = affine.load %arg1[%arg2, %arg4] : memref + %5 = affine.load %arg1[%arg4, %arg3] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg1[%arg2, %arg3] : memref + %8 = arith.subf %7, %6 : f64 + affine.store %8, %arg1[%arg2, %arg3] : memref + } + %1 = affine.load %arg1[%arg3, %arg3] : memref + %2 = affine.load %arg1[%arg2, %arg3] : memref + %3 = arith.divf %2, %1 : f64 + affine.store %3, %arg1[%arg2, %arg3] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to affine_map<(d0) -> (d0)>(%arg3) { + %4 = affine.load %arg1[%arg2, %arg4] : memref + %5 = affine.load %arg1[%arg4, %arg3] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg1[%arg2, %arg3] : memref + %8 = arith.subf %7, %6 : f64 + affine.store %8, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %7 = affine.load %arg1[%arg2, %arg4] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %9 = affine.load %arg1[%arg4, %arg3] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %12 = affine.load %arg1[%arg2, %arg3] : memref + +--- Processing Stores --- +Processing store: affine.store %13, %arg1[%arg2, %arg3] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg3) + %2 = polygeist.submap(%arg1, %arg2, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + %5 = affine.load %arg1[%arg3, %arg3] : memref + %6 = affine.load %arg1[%arg2, %arg3] : memref + %7 = arith.divf %6, %5 : f64 + affine.store %7, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg3) + %2 = polygeist.submap(%arg1, %arg2, %1) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %1) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + %5 = affine.load %arg1[%arg3, %arg3] : memref + %6 = affine.load %arg1[%arg2, %arg3] : memref + %7 = arith.divf %6, %5 : f64 + affine.store %7, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.subf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %2 = affine.apply affine_map<(d0) -> (d0)>(%arg3) + %3 = polygeist.submap(%arg1, %arg2, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg3, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg1, %arg2, %arg3, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.subf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = affine.load %arg1[%arg3, %arg3] : memref + %7 = affine.load %arg1[%arg2, %arg3] : memref + %8 = arith.divf %7, %6 : f64 + affine.store %8, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.subf %out, %10 : f64 + linalg.yield %11 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %2 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + %5 = affine.load %arg1[%arg3, %arg3] : memref + %6 = affine.load %arg1[%arg2, %arg3] : memref + %7 = arith.divf %6, %5 : f64 + affine.store %7, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +REJECTED: Loop doesn't have constant lower bound + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.subf %out, %10 : f64 + linalg.yield %11 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %2 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + %5 = affine.load %arg1[%arg3, %arg3] : memref + %6 = affine.load %arg1[%arg2, %arg3] : memref + %7 = arith.divf %6, %5 : f64 + affine.store %7, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +REJECTED: Loop doesn't have constant lower bound + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.subf %out, %10 : f64 + linalg.yield %11 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %2 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + %5 = affine.load %arg1[%arg3, %arg3] : memref + %6 = affine.load %arg1[%arg2, %arg3] : memref + %7 = arith.divf %6, %5 : f64 + affine.store %7, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +REJECTED: Loop doesn't have constant lower bound + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.subf %out, %10 : f64 + linalg.yield %11 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %2 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + %5 = affine.load %arg1[%arg3, %arg3] : memref + %6 = affine.load %arg1[%arg2, %arg3] : memref + %7 = arith.divf %6, %5 : f64 + affine.store %7, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +REJECTED: Loop doesn't have constant lower bound + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.subf %out, %10 : f64 + linalg.yield %11 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %2 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + %5 = affine.load %arg1[%arg3, %arg3] : memref + %6 = affine.load %arg1[%arg2, %arg3] : memref + %7 = arith.divf %6, %5 : f64 + affine.store %7, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +REJECTED: Loop doesn't have constant lower bound + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.subf %out, %10 : f64 + linalg.yield %11 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %2 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + %5 = affine.load %arg1[%arg3, %arg3] : memref + %6 = affine.load %arg1[%arg2, %arg3] : memref + %7 = arith.divf %6, %5 : f64 + affine.store %7, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +REJECTED: Loop doesn't have constant lower bound + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.subf %out, %10 : f64 + linalg.yield %11 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %2 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + %5 = affine.load %arg1[%arg3, %arg3] : memref + %6 = affine.load %arg1[%arg2, %arg3] : memref + %7 = arith.divf %6, %5 : f64 + affine.store %7, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +REJECTED: Loop doesn't have constant lower bound + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.subf %out, %10 : f64 + linalg.yield %11 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %2 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + %5 = affine.load %arg1[%arg3, %arg3] : memref + %6 = affine.load %arg1[%arg2, %arg3] : memref + %7 = arith.divf %6, %5 : f64 + affine.store %7, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +REJECTED: Loop doesn't have constant lower bound + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.subf %out, %10 : f64 + linalg.yield %11 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %2 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + %5 = affine.load %arg1[%arg3, %arg3] : memref + %6 = affine.load %arg1[%arg2, %arg3] : memref + %7 = arith.divf %6, %5 : f64 + affine.store %7, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +REJECTED: Loop doesn't have constant lower bound + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 1 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%4, %5 : memref, memref) outs(%6 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %10 = arith.mulf %in, %in_0 : f64 + %11 = arith.subf %out, %10 : f64 + linalg.yield %11 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg2 = 0 to %0 { + %1 = affine.apply affine_map<(d0) -> (d0)>(%arg2) + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %2 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + %5 = affine.load %arg1[%arg3, %arg3] : memref + %6 = affine.load %arg1[%arg2, %arg3] : memref + %7 = arith.divf %6, %5 : f64 + affine.store %7, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %2 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.subf %out, %5 : f64 + linalg.yield %6 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + +WARNING: AffineForOpRaising didn't converge +lu.mlir:3:3: warning: AffineForOpRaising didn't converge, continuing anyway + func.func @kernel_lu(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +lu.mlir:3:3: note: see current operation: +func.func @kernel_lu(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg2 = 0 to %0 { + affine.for %arg3 = 0 to affine_map<(d0) -> (d0)>(%arg2) { + %1 = polygeist.submap(%arg1, %arg2, %arg3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg3) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg3) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %4 = affine.load %arg1[%arg3, %arg3] : memref + %5 = affine.load %arg1[%arg2, %arg3] : memref + %6 = arith.divf %5, %4 : f64 + affine.store %6, %arg1[%arg2, %arg3] : memref + } + affine.for %arg3 = affine_map<(d0) -> (d0)>(%arg2) to %0 { + %1 = polygeist.submap(%arg1, %arg2, %arg2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %2 = polygeist.submap(%arg1, %arg3, %arg2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg1, %arg2, %arg3, %arg2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%1, %2 : memref, memref) outs(%3 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %4 = arith.mulf %in, %in_0 : f64 + %5 = arith.subf %out, %4 : f64 + linalg.yield %5 : f64 + } + } + } + return +} +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/ludcmp.log b/polybench_results/reject_logs/ludcmp.log new file mode 100644 index 000000000000..081737226e34 --- /dev/null +++ b/polybench_results/reject_logs/ludcmp.log @@ -0,0 +1,606 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = affine_map<(d0)[s0] -> (-d0 + s0)>(%arg5)[%0] to %0 { + %6 = affine.load %arg1[-%arg5 + symbol(%0) - 1, %arg6] : memref + %7 = affine.load %arg3[%arg6] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %alloca[] : memref + %10 = arith.subf %9, %8 : f64 + affine.store %10, %alloca[] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +REJECTED: Loop doesn't have constant lower bound + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 0 to %0 { + %2 = affine.load %arg4[-%arg5 + symbol(%0) - 1] : memref + affine.store %2, %alloca[] : memref + affine.for %arg6 = affine_map<(d0)[s0] -> (-d0 + s0)>(%arg5)[%0] to %0 { + %6 = affine.load %arg1[-%arg5 + symbol(%0) - 1, %arg6] : memref + %7 = affine.load %arg3[%arg6] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %alloca[] : memref + %10 = arith.subf %9, %8 : f64 + affine.store %10, %alloca[] : memref + } + %3 = affine.load %alloca[] : memref + %4 = affine.load %arg1[-%arg5 + symbol(%0) - 1, -%arg5 + symbol(%0) - 1] : memref + %5 = arith.divf %3, %4 : f64 + affine.store %5, %arg3[-%arg5 + symbol(%0) - 1] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to affine_map<(d0) -> (d0)>(%arg5) { + %4 = affine.load %arg1[%arg5, %arg6] : memref + %5 = affine.load %arg4[%arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %alloca[] : memref + %8 = arith.subf %7, %6 : f64 + affine.store %8, %alloca[] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %7 = affine.load %arg1[%arg5, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %9 = affine.load %arg4[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %12 = affine.load %alloca[] : memref + +--- Processing Stores --- +Processing store: affine.store %13, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 0 to %0 { + %2 = affine.load %arg2[%arg5] : memref + affine.store %2, %alloca[] : memref + %3 = polygeist.submap(%arg1, %arg5, %arg5) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %arg5) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%alloca, %arg5) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %6 = affine.load %alloca[] : memref + affine.store %6, %arg4[%arg5] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 2 + LinalgGenerics: 1 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to affine_map<(d0) -> (d0)>(%arg5) { + %4 = affine.load %arg1[%arg5, %arg7] : memref + %5 = affine.load %arg1[%arg7, %arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %alloca[] : memref + %8 = arith.subf %7, %6 : f64 + affine.store %8, %alloca[] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %7 = affine.load %arg1[%arg5, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %9 = affine.load %arg1[%arg7, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %12 = affine.load %alloca[] : memref + +--- Processing Stores --- +Processing store: affine.store %13, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = affine_map<(d0) -> (d0)>(%arg5) to %0 { + %2 = affine.load %arg1[%arg5, %arg6] : memref + affine.store %2, %alloca[] : memref + %3 = polygeist.submap(%arg1, %arg5, %arg5) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg6, %arg5) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%alloca, %arg5) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %6 = affine.load %alloca[] : memref + affine.store %6, %arg1[%arg5, %arg6] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 2 + LinalgGenerics: 1 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to affine_map<(d0) -> (d0)>(%arg6) { + %6 = affine.load %arg1[%arg5, %arg7] : memref + %7 = affine.load %arg1[%arg7, %arg6] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %alloca[] : memref + %10 = arith.subf %9, %8 : f64 + affine.store %10, %alloca[] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %9 = affine.load %arg1[%arg5, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %11 = affine.load %arg1[%arg7, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %14 = affine.load %alloca[] : memref + +--- Processing Stores --- +Processing store: affine.store %15, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 0 to %0 { + affine.for %arg6 = 0 to affine_map<(d0) -> (d0)>(%arg5) { + %2 = affine.load %arg1[%arg5, %arg6] : memref + affine.store %2, %alloca[] : memref + %3 = polygeist.submap(%arg1, %arg5, %arg6) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg6, %arg6) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%alloca, %arg6) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.subf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = affine.load %alloca[] : memref + %7 = affine.load %arg1[%arg6, %arg6] : memref + %8 = arith.divf %6, %7 : f64 + affine.store %8, %arg1[%arg5, %arg6] : memref + } + affine.for %arg6 = affine_map<(d0) -> (d0)>(%arg5) to %0 { + %2 = affine.load %arg1[%arg5, %arg6] : memref + affine.store %2, %alloca[] : memref + %3 = polygeist.submap(%arg1, %arg5, %arg5) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg6, %arg5) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%alloca, %arg5) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %6 = affine.load %alloca[] : memref + affine.store %6, %arg1[%arg5, %arg6] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to affine_map<(d0) -> (d0)>(%arg5) { + %2 = affine.load %arg1[%arg5, %arg6] : memref + affine.store %2, %alloca[] : memref + %3 = polygeist.submap(%arg1, %arg5, %arg6) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg6, %arg6) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%alloca, %arg6) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.subf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = affine.load %alloca[] : memref + %7 = affine.load %arg1[%arg6, %arg6] : memref + %8 = arith.divf %6, %7 : f64 + affine.store %8, %arg1[%arg5, %arg6] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 2 + LinalgGenerics: 1 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = affine_map<(d0)[s0] -> (-d0 + s0)>(%arg5)[%0] to %0 { + %6 = affine.load %arg1[-%arg5 + symbol(%0) - 1, %arg6] : memref + %7 = affine.load %arg3[%arg6] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %alloca[] : memref + %10 = arith.subf %9, %8 : f64 + affine.store %10, %alloca[] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +REJECTED: Loop doesn't have constant lower bound + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 0 to %0 { + %2 = affine.load %arg4[-%arg5 + symbol(%0) - 1] : memref + affine.store %2, %alloca[] : memref + affine.for %arg6 = affine_map<(d0)[s0] -> (-d0 + s0)>(%arg5)[%0] to %0 { + %6 = affine.load %arg1[-%arg5 + symbol(%0) - 1, %arg6] : memref + %7 = affine.load %arg3[%arg6] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = affine.load %alloca[] : memref + %10 = arith.subf %9, %8 : f64 + affine.store %10, %alloca[] : memref + } + %3 = affine.load %alloca[] : memref + %4 = affine.load %arg1[-%arg5 + symbol(%0) - 1, -%arg5 + symbol(%0) - 1] : memref + %5 = arith.divf %3, %4 : f64 + affine.store %5, %arg3[-%arg5 + symbol(%0) - 1] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 0 to %0 { + %2 = affine.load %arg2[%arg5] : memref + affine.store %2, %alloca[] : memref + %3 = polygeist.submap(%arg1, %arg5, %arg5) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %arg5) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %5 = polygeist.submap(%alloca, %arg5) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %6 = affine.load %alloca[] : memref + affine.store %6, %arg4[%arg5] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 2 + LinalgGenerics: 1 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = affine_map<(d0) -> (d0)>(%arg5) to %0 { + %2 = affine.load %arg1[%arg5, %arg6] : memref + affine.store %2, %alloca[] : memref + %3 = polygeist.submap(%arg1, %arg5, %arg5) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg6, %arg5) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%alloca, %arg5) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %6 = affine.load %alloca[] : memref + affine.store %6, %arg1[%arg5, %arg6] : memref +} + +Pattern recognition complete: + Loads: 2 + Stores: 2 + LinalgGenerics: 1 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 0 to %0 { + affine.for %arg6 = 0 to affine_map<(d0) -> (d0)>(%arg5) { + %2 = affine.load %arg1[%arg5, %arg6] : memref + affine.store %2, %alloca[] : memref + %3 = polygeist.submap(%arg1, %arg5, %arg6) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg6, %arg6) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%alloca, %arg6) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.subf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = affine.load %alloca[] : memref + %7 = affine.load %arg1[%arg6, %arg6] : memref + %8 = arith.divf %6, %7 : f64 + affine.store %8, %arg1[%arg5, %arg6] : memref + } + affine.for %arg6 = affine_map<(d0) -> (d0)>(%arg5) to %0 { + %2 = affine.load %arg1[%arg5, %arg6] : memref + affine.store %2, %alloca[] : memref + %3 = polygeist.submap(%arg1, %arg5, %arg5) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg6, %arg5) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%alloca, %arg5) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %7 = arith.mulf %in, %in_0 : f64 + %8 = arith.subf %out, %7 : f64 + linalg.yield %8 : f64 + } + %6 = affine.load %alloca[] : memref + affine.store %6, %arg1[%arg5, %arg6] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to affine_map<(d0) -> (d0)>(%arg5) { + %2 = affine.load %arg1[%arg5, %arg6] : memref + affine.store %2, %alloca[] : memref + %3 = polygeist.submap(%arg1, %arg5, %arg6) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg1, %arg6, %arg6) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%alloca, %arg6) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.subf %out, %9 : f64 + linalg.yield %10 : f64 + } + %6 = affine.load %alloca[] : memref + %7 = affine.load %arg1[%arg6, %arg6] : memref + %8 = arith.divf %6, %7 : f64 + affine.store %8, %arg1[%arg5, %arg6] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 2 + LinalgGenerics: 1 + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/mvt.log b/polybench_results/reject_logs/mvt.log new file mode 100644 index 000000000000..e7541d557b1f --- /dev/null +++ b/polybench_results/reject_logs/mvt.log @@ -0,0 +1,579 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%0)) { + affine.parallel (%arg7) = (0) to (symbol(%0)) { + %1 = affine.load %arg2[%arg6] : memref + %2 = affine.load %arg5[%arg7, %arg6] : memref + %3 = affine.load %arg4[%arg7] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + affine.store %5, %arg2[%arg6] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%0)) { + %1 = affine.load %arg2[%arg6] : memref + %2 = affine.load %arg5[%arg7, %arg6] : memref + %3 = affine.load %arg4[%arg7] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + affine.store %5, %arg2[%arg6] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%0)) { + affine.parallel (%arg7) = (0) to (symbol(%0)) { + %1 = affine.load %arg1[%arg6] : memref + %2 = affine.load %arg5[%arg6, %arg7] : memref + %3 = affine.load %arg3[%arg7] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + affine.store %5, %arg1[%arg6] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%0)) { + %1 = affine.load %arg1[%arg6] : memref + %2 = affine.load %arg5[%arg6, %arg7] : memref + %3 = affine.load %arg3[%arg7] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + affine.store %5, %arg1[%arg6] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%0)) { + affine.parallel (%arg7) = (0) to (symbol(%0)) { + %1 = affine.load %arg2[%arg6] : memref + %2 = affine.load %arg5[%arg7, %arg6] : memref + %3 = affine.load %arg4[%arg7] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + affine.store %5, %arg2[%arg6] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%0)) { + %1 = affine.load %arg2[%arg6] : memref + %2 = affine.load %arg5[%arg7, %arg6] : memref + %3 = affine.load %arg4[%arg7] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + affine.store %5, %arg2[%arg6] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%0)) { + affine.parallel (%arg7) = (0) to (symbol(%0)) { + %1 = affine.load %arg1[%arg6] : memref + %2 = affine.load %arg5[%arg6, %arg7] : memref + %3 = affine.load %arg3[%arg7] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + affine.store %5, %arg1[%arg6] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%0)) { + %1 = affine.load %arg1[%arg6] : memref + %2 = affine.load %arg5[%arg6, %arg7] : memref + %3 = affine.load %arg3[%arg7] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + affine.store %5, %arg1[%arg6] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %0 { + affine.for %arg7 = 0 to %0 { + %1 = affine.load %arg2[%arg6] : memref + %2 = affine.load %arg5[%arg7, %arg6] : memref + %3 = affine.load %arg4[%arg7] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + affine.store %5, %arg2[%arg6] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + %1 = affine.load %arg2[%arg6] : memref + %2 = affine.load %arg5[%arg7, %arg6] : memref + %3 = affine.load %arg4[%arg7] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %1, %4 : f64 + affine.store %5, %arg2[%arg6] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %4 = affine.load %arg2[%arg6] : memref +Processing load: %5 = affine.load %arg5[%arg7, %arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %7 = affine.load %arg4[%arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %10, %arg2[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0] -> (s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %0 { + %1 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %2 = polygeist.submap(%arg5, %arg6, %1) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg4, %1) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg2, %arg6, %1) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %5 = arith.mulf %in, %in_0 : f64 + %6 = arith.addf %out, %5 : f64 + linalg.yield %6 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %0 { + affine.for %arg7 = 0 to %0 { + %4 = affine.load %arg1[%arg6] : memref + %5 = affine.load %arg5[%arg6, %arg7] : memref + %6 = affine.load %arg3[%arg7] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.addf %4, %7 : f64 + affine.store %8, %arg1[%arg6] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + %4 = affine.load %arg1[%arg6] : memref + %5 = affine.load %arg5[%arg6, %arg7] : memref + %6 = affine.load %arg3[%arg7] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = arith.addf %4, %7 : f64 + affine.store %8, %arg1[%arg6] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %7 = affine.load %arg1[%arg6] : memref +Processing load: %8 = affine.load %arg5[%arg6, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %10 = affine.load %arg3[%arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %13, %arg1[%arg6] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0] -> (s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %0 { + %4 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %5 = polygeist.submap(%arg5, %arg6, %4) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg3, %4) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %7 = polygeist.submap(%arg1, %arg6, %4) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%5, %6 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.addf %out, %8 : f64 + linalg.yield %9 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%8, %9 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %in, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0) -> (d0) + Composed map: (d0) -> (d0) + Final lgMap: (d0) -> (d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0) + Composed map: (d0)[s0] -> (s0) + Final lgMap: (d0)[s0] -> (s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/nussinov.log b/polybench_results/reject_logs/nussinov.log new file mode 100644 index 000000000000..dbc66c82e825 --- /dev/null +++ b/polybench_results/reject_logs/nussinov.log @@ -0,0 +1,241 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = affine_map<(d0)[s0] -> (-d0 + s0)>(%arg3)[%0] to affine_map<(d0) -> (d0)>(%arg4) { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg5] : memref + %3 = affine.load %arg2[%arg5 + 1, %arg4] : memref + %4 = arith.addi %2, %3 : i32 + %5 = arith.cmpi sge, %1, %4 : i32 + %6 = scf.if %5 -> (i32) { + %7 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %7 : i32 + } else { + %7 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg5] : memref + %8 = arith.addi %7, %3 : i32 + scf.yield %8 : i32 + } + affine.store %6, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to %0 { + affine.for %arg4 = affine_map<(d0)[s0] -> (-d0 + s0)>(%arg3)[%0] to %0 { + affine.if affine_set<(d0) : (d0 - 1 >= 0)>(%arg4) { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4 - 1] : memref + %3 = arith.cmpi sge, %1, %2 : i32 + %4 = scf.if %3 -> (i32) { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %5 : i32 + } else { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4 - 1] : memref + scf.yield %5 : i32 + } + affine.store %4, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + affine.if affine_set<(d0) : (d0 - 1 >= 0)>(%arg3) { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0), %arg4] : memref + %3 = arith.cmpi sge, %1, %2 : i32 + %4 = scf.if %3 -> (i32) { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %5 : i32 + } else { + %5 = affine.load %arg2[-%arg3 + symbol(%0), %arg4] : memref + scf.yield %5 : i32 + } + affine.store %4, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + affine.if affine_set<(d0, d1) : (d0 - 1 >= 0, d1 - 1 >= 0)>(%arg4, %arg3) { + affine.if affine_set<(d0, d1)[s0] : (d0 + d1 - s0 - 1 >= 0)>(%arg3, %arg4)[%0] { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + %3 = affine.load %arg1[-%arg3 + symbol(%0) - 1] : memref + %4 = arith.extsi %3 : i8 to i32 + %5 = affine.load %arg1[%arg4] : memref + %6 = arith.extsi %5 : i8 to i32 + %7 = arith.addi %4, %6 : i32 + %8 = arith.cmpi eq, %7, %c3_i32 : i32 + %9 = arith.extui %8 : i1 to i32 + %10 = arith.addi %2, %9 : i32 + %11 = arith.cmpi sge, %1, %10 : i32 + %12 = scf.if %11 -> (i32) { + %13 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %13 : i32 + } else { + %13 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + %14 = affine.load %arg1[-%arg3 + symbol(%0) - 1] : memref + %15 = arith.extsi %14 : i8 to i32 + %16 = arith.addi %15, %6 : i32 + %17 = arith.cmpi eq, %16, %c3_i32 : i32 + %18 = arith.extui %17 : i1 to i32 + %19 = arith.addi %13, %18 : i32 + scf.yield %19 : i32 + } + affine.store %12, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } else { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + %3 = arith.cmpi sge, %1, %2 : i32 + %4 = scf.if %3 -> (i32) { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %5 : i32 + } else { + %5 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + scf.yield %5 : i32 + } + affine.store %4, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + } + affine.for %arg5 = affine_map<(d0)[s0] -> (-d0 + s0)>(%arg3)[%0] to affine_map<(d0) -> (d0)>(%arg4) { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg5] : memref + %3 = affine.load %arg2[%arg5 + 1, %arg4] : memref + %4 = arith.addi %2, %3 : i32 + %5 = arith.cmpi sge, %1, %4 : i32 + %6 = scf.if %5 -> (i32) { + %7 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %7 : i32 + } else { + %7 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg5] : memref + %8 = arith.addi %7, %3 : i32 + scf.yield %8 : i32 + } + affine.store %6, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = affine_map<(d0)[s0] -> (-d0 + s0)>(%arg3)[%0] to %0 { + affine.if affine_set<(d0) : (d0 - 1 >= 0)>(%arg4) { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4 - 1] : memref + %3 = arith.cmpi sge, %1, %2 : i32 + %4 = scf.if %3 -> (i32) { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %5 : i32 + } else { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4 - 1] : memref + scf.yield %5 : i32 + } + affine.store %4, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + affine.if affine_set<(d0) : (d0 - 1 >= 0)>(%arg3) { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0), %arg4] : memref + %3 = arith.cmpi sge, %1, %2 : i32 + %4 = scf.if %3 -> (i32) { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %5 : i32 + } else { + %5 = affine.load %arg2[-%arg3 + symbol(%0), %arg4] : memref + scf.yield %5 : i32 + } + affine.store %4, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + affine.if affine_set<(d0, d1) : (d0 - 1 >= 0, d1 - 1 >= 0)>(%arg4, %arg3) { + affine.if affine_set<(d0, d1)[s0] : (d0 + d1 - s0 - 1 >= 0)>(%arg3, %arg4)[%0] { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + %3 = affine.load %arg1[-%arg3 + symbol(%0) - 1] : memref + %4 = arith.extsi %3 : i8 to i32 + %5 = affine.load %arg1[%arg4] : memref + %6 = arith.extsi %5 : i8 to i32 + %7 = arith.addi %4, %6 : i32 + %8 = arith.cmpi eq, %7, %c3_i32 : i32 + %9 = arith.extui %8 : i1 to i32 + %10 = arith.addi %2, %9 : i32 + %11 = arith.cmpi sge, %1, %10 : i32 + %12 = scf.if %11 -> (i32) { + %13 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %13 : i32 + } else { + %13 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + %14 = affine.load %arg1[-%arg3 + symbol(%0) - 1] : memref + %15 = arith.extsi %14 : i8 to i32 + %16 = arith.addi %15, %6 : i32 + %17 = arith.cmpi eq, %16, %c3_i32 : i32 + %18 = arith.extui %17 : i1 to i32 + %19 = arith.addi %13, %18 : i32 + scf.yield %19 : i32 + } + affine.store %12, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } else { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + %3 = arith.cmpi sge, %1, %2 : i32 + %4 = scf.if %3 -> (i32) { + %5 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %5 : i32 + } else { + %5 = affine.load %arg2[-%arg3 + symbol(%0), %arg4 - 1] : memref + scf.yield %5 : i32 + } + affine.store %4, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } + } + affine.for %arg5 = affine_map<(d0)[s0] -> (-d0 + s0)>(%arg3)[%0] to affine_map<(d0) -> (d0)>(%arg4) { + %1 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + %2 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg5] : memref + %3 = affine.load %arg2[%arg5 + 1, %arg4] : memref + %4 = arith.addi %2, %3 : i32 + %5 = arith.cmpi sge, %1, %4 : i32 + %6 = scf.if %5 -> (i32) { + %7 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + scf.yield %7 : i32 + } else { + %7 = affine.load %arg2[-%arg3 + symbol(%0) - 1, %arg5] : memref + %8 = arith.addi %7, %3 : i32 + scf.yield %8 : i32 + } + affine.store %6, %arg2[-%arg3 + symbol(%0) - 1, %arg4] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/seidel-2d.log b/polybench_results/reject_logs/seidel-2d.log new file mode 100644 index 000000000000..70b18bf5cb02 --- /dev/null +++ b/polybench_results/reject_logs/seidel-2d.log @@ -0,0 +1,885 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to %0 { + affine.for %arg4 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%1] { + affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%1] { + %2 = affine.load %arg2[%arg4 - 1, %arg5 - 1] : memref + %3 = affine.load %arg2[%arg4 - 1, %arg5] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg2[%arg4 - 1, %arg5 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = affine.load %arg2[%arg4, %arg5 - 1] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg2[%arg4, %arg5] : memref + %10 = arith.addf %8, %9 : f64 + %11 = affine.load %arg2[%arg4, %arg5 + 1] : memref + %12 = arith.addf %10, %11 : f64 + %13 = affine.load %arg2[%arg4 + 1, %arg5 - 1] : memref + %14 = arith.addf %12, %13 : f64 + %15 = affine.load %arg2[%arg4 + 1, %arg5] : memref + %16 = arith.addf %14, %15 : f64 + %17 = affine.load %arg2[%arg4 + 1, %arg5 + 1] : memref + %18 = arith.addf %16, %17 : f64 + %19 = arith.divf %18, %cst : f64 + affine.store %19, %arg2[%arg4, %arg5] : memref + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%1] { + affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%1] { + %2 = affine.load %arg2[%arg4 - 1, %arg5 - 1] : memref + %3 = affine.load %arg2[%arg4 - 1, %arg5] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg2[%arg4 - 1, %arg5 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = affine.load %arg2[%arg4, %arg5 - 1] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg2[%arg4, %arg5] : memref + %10 = arith.addf %8, %9 : f64 + %11 = affine.load %arg2[%arg4, %arg5 + 1] : memref + %12 = arith.addf %10, %11 : f64 + %13 = affine.load %arg2[%arg4 + 1, %arg5 - 1] : memref + %14 = arith.addf %12, %13 : f64 + %15 = affine.load %arg2[%arg4 + 1, %arg5] : memref + %16 = arith.addf %14, %15 : f64 + %17 = affine.load %arg2[%arg4 + 1, %arg5 + 1] : memref + %18 = arith.addf %16, %17 : f64 + %19 = arith.divf %18, %cst : f64 + affine.store %19, %arg2[%arg4, %arg5] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%1] { + %2 = affine.load %arg2[%arg4 - 1, %arg5 - 1] : memref + %3 = affine.load %arg2[%arg4 - 1, %arg5] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg2[%arg4 - 1, %arg5 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = affine.load %arg2[%arg4, %arg5 - 1] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg2[%arg4, %arg5] : memref + %10 = arith.addf %8, %9 : f64 + %11 = affine.load %arg2[%arg4, %arg5 + 1] : memref + %12 = arith.addf %10, %11 : f64 + %13 = affine.load %arg2[%arg4 + 1, %arg5 - 1] : memref + %14 = arith.addf %12, %13 : f64 + %15 = affine.load %arg2[%arg4 + 1, %arg5] : memref + %16 = arith.addf %14, %15 : f64 + %17 = affine.load %arg2[%arg4 + 1, %arg5 + 1] : memref + %18 = arith.addf %16, %17 : f64 + %19 = arith.divf %18, %cst : f64 + affine.store %19, %arg2[%arg4, %arg5] : memref +} + +Pattern recognition complete: + Loads: 9 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %5 = affine.load %arg2[%arg4 - 1, %arg5 - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0 - 1, d1 - 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0 - 1, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %7 = affine.load %arg2[%arg4 - 1, %arg5] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0 - 1, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0 - 1, d0 + 1) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %10 = affine.load %arg2[%arg4 - 1, %arg5 + 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0 - 1, d1 + 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0 - 1, d0 + 2) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %13 = affine.load %arg2[%arg4, %arg5 - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1 - 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %16 = affine.load %arg2[%arg4, %arg5] : memref +Processing load: %18 = affine.load %arg2[%arg4, %arg5 + 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1 + 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0 + 2) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %21 = affine.load %arg2[%arg4 + 1, %arg5 - 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0 + 1, d1 - 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0 + 1, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %24 = affine.load %arg2[%arg4 + 1, %arg5] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0 + 1, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0 + 1, d0 + 1) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %27 = affine.load %arg2[%arg4 + 1, %arg5 + 1] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0 + 1, d1 + 1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0 + 1, d0 + 2) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Stores --- +Processing store: affine.store %30, %arg2[%arg4, %arg5] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0 + 1) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 8 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to %0 { + affine.for %arg4 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%1] { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0 - 1, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0 - 1, d0 + 1)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0 - 1, d0 + 2)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0, d0 + 2)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0 + 1, d0)>} : (memref, index, index) -> memref + %10 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0 + 1, d0 + 1)>} : (memref, index, index) -> memref + %11 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0 + 1, d0 + 2)>} : (memref, index, index) -> memref + %12 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6, %7, %8, %9, %10, %11 : memref, memref, memref, memref, memref, memref, memref, memref) outs(%12 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %13 = arith.addf %in, %in_0 : f64 + %14 = arith.addf %13, %in_1 : f64 + %15 = arith.addf %14, %in_2 : f64 + %16 = arith.addf %15, %out : f64 + %17 = arith.addf %16, %in_3 : f64 + %18 = arith.addf %17, %in_4 : f64 + %19 = arith.addf %18, %in_5 : f64 + %20 = arith.addf %19, %in_6 : f64 + %21 = arith.divf %20, %cst : f64 + linalg.yield %21 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 1 to affine_map<()[s0] -> (s0 - 1)>()[%1] { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0 - 1, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0 - 1, d0 + 1)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0 - 1, d0 + 2)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0, d0 + 2)>} : (memref, index, index) -> memref + %9 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0 + 1, d0)>} : (memref, index, index) -> memref + %10 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0 + 1, d0 + 1)>} : (memref, index, index) -> memref + %11 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0 + 1, d0 + 2)>} : (memref, index, index) -> memref + %12 = polygeist.submap(%arg2, %arg4, %3) {map = affine_map<(d0)[s0] -> (s0, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%4, %5, %6, %7, %8, %9, %10, %11 : memref, memref, memref, memref, memref, memref, memref, memref) outs(%12 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %13 = arith.addf %in, %in_0 : f64 + %14 = arith.addf %13, %in_1 : f64 + %15 = arith.addf %14, %in_2 : f64 + %16 = arith.addf %15, %out : f64 + %17 = arith.addf %16, %in_3 : f64 + %18 = arith.addf %17, %in_4 : f64 + %19 = arith.addf %18, %in_5 : f64 + %20 = arith.addf %19, %in_6 : f64 + %21 = arith.divf %20, %cst : f64 + linalg.yield %21 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (1) + ubMap: ()[s0] -> (s0 - 1) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%7, %8, %9, %10, %11, %12, %13, %14 : memref, memref, memref, memref, memref, memref, memref, memref) outs(%15 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %16 = arith.addf %in, %in_0 : f64 + %17 = arith.addf %16, %in_1 : f64 + %18 = arith.addf %17, %in_2 : f64 + %19 = arith.addf %18, %out : f64 + %20 = arith.addf %19, %in_3 : f64 + %21 = arith.addf %20, %in_4 : f64 + %22 = arith.addf %21, %in_5 : f64 + %23 = arith.addf %22, %in_6 : f64 + %24 = arith.divf %23, %cst : f64 + linalg.yield %24 : f64 +} + Processing 8 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0 - 1, d0) + Composed map: (d0)[s0] -> (s0 - 1, d0) + Final lgMap: (d0)[s0] -> (s0 - 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0 - 1, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0 - 1, d0 + 1) + Composed map: (d0)[s0] -> (s0 - 1, d0 + 1) + Final lgMap: (d0)[s0] -> (s0 - 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0 - 1, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0 - 1, d0 + 2) + Composed map: (d0)[s0] -> (s0 - 1, d0 + 2) + Final lgMap: (d0)[s0] -> (s0 - 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0 - 1, d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0 + 2) + Composed map: (d0)[s0] -> (s0, d0 + 2) + Final lgMap: (d0)[s0] -> (s0, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0 + 1, d0) + Composed map: (d0)[s0] -> (s0 + 1, d0) + Final lgMap: (d0)[s0] -> (s0 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0 + 1, d0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 2, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0 + 1, d0 + 1) + Composed map: (d0)[s0] -> (s0 + 1, d0 + 1) + Final lgMap: (d0)[s0] -> (s0 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0 + 1, d0 + 1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 7 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0 + 1, d0 + 2) + Composed map: (d0)[s0] -> (s0 + 1, d0 + 2) + Final lgMap: (d0)[s0] -> (s0 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 7 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0 + 1, d0 + 2) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 2, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0 + 1) + Composed map: (d0)[s0] -> (s0, d0 + 1) + Final lgMap: (d0)[s0] -> (s0, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0 + 1) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 1 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 8 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg3 = 0 to %0 { + %2 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg2, %5, %3) {map = affine_map<(d0, d1) -> (d1, d0)>} : (memref, index, index) -> memref + %7 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %8 = arith.subi %7, %c1 : index + %9 = polygeist.submap(%arg2, %8, %3) {map = affine_map<(d0, d1) -> (d1, d0 + 1)>} : (memref, index, index) -> memref + %10 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %11 = arith.subi %10, %c1 : index + %12 = polygeist.submap(%arg2, %11, %3) {map = affine_map<(d0, d1) -> (d1, d0 + 2)>} : (memref, index, index) -> memref + %13 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %14 = arith.subi %13, %c1 : index + %15 = polygeist.submap(%arg2, %14, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0)>} : (memref, index, index) -> memref + %16 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %17 = arith.subi %16, %c1 : index + %18 = polygeist.submap(%arg2, %17, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 2)>} : (memref, index, index) -> memref + %19 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg2, %20, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0)>} : (memref, index, index) -> memref + %22 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %23 = arith.subi %22, %c1 : index + %24 = polygeist.submap(%arg2, %23, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 1)>} : (memref, index, index) -> memref + %25 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %26 = arith.subi %25, %c1 : index + %27 = polygeist.submap(%arg2, %26, %3) {map = affine_map<(d0, d1) -> (d1 + 2, d0 + 2)>} : (memref, index, index) -> memref + %28 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %29 = arith.subi %28, %c1 : index + %30 = polygeist.submap(%arg2, %29, %3) {map = affine_map<(d0, d1) -> (d1 + 1, d0 + 1)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%6, %9, %12, %15, %18, %21, %24, %27 : memref, memref, memref, memref, memref, memref, memref, memref) outs(%30 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %31 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %32 = arith.addf %in, %in_0 : f64 + %33 = arith.addf %32, %in_1 : f64 + %34 = arith.addf %33, %in_2 : f64 + %35 = arith.addf %34, %out : f64 + %36 = arith.addf %35, %in_3 : f64 + %37 = arith.addf %36, %in_4 : f64 + %38 = arith.addf %37, %in_5 : f64 + %39 = arith.addf %38, %in_6 : f64 + %40 = arith.divf %39, %cst : f64 + linalg.yield %40 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "parallel"]} ins(%9, %12, %15, %18, %21, %24, %27, %30 : memref, memref, memref, memref, memref, memref, memref, memref) outs(%33 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %34 = affine.apply affine_map<()[s0] -> (s0 - 1)>()[%1] + %35 = arith.addf %in, %in_0 : f64 + %36 = arith.addf %35, %in_1 : f64 + %37 = arith.addf %36, %in_2 : f64 + %38 = arith.addf %37, %out : f64 + %39 = arith.addf %38, %in_3 : f64 + %40 = arith.addf %39, %in_4 : f64 + %41 = arith.addf %40, %in_5 : f64 + %42 = arith.addf %41, %in_6 : f64 + %43 = arith.divf %42, %cst : f64 + linalg.yield %43 : f64 +} + Processing 8 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0) + Composed map: (d0, d1) -> (d1, d0) + Final lgMap: (d0, d1) -> (d1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 1) + Composed map: (d0, d1) -> (d1, d0 + 1) + Final lgMap: (d0, d1) -> (d1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1, d0 + 2) + Composed map: (d0, d1) -> (d1, d0 + 2) + Final lgMap: (d0, d1) -> (d1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0) + Composed map: (d0, d1) -> (d1 + 1, d0) + Final lgMap: (d0, d1) -> (d1 + 1, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 4 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 2) + Composed map: (d0, d1) -> (d1 + 1, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 4 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 5 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0) + Composed map: (d0, d1) -> (d1 + 2, d0) + Final lgMap: (d0, d1) -> (d1 + 2, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 5 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 6 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 1) + Composed map: (d0, d1) -> (d1 + 2, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 6 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 7 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 2, d0 + 2) + Composed map: (d0, d1) -> (d1 + 2, d0 + 2) + Final lgMap: (d0, d1) -> (d1 + 2, d0 + 2) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 7 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 2, d0 + 2) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d1 + 2, d0 + 2) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d1 + 1, d0 + 1) + Composed map: (d0, d1) -> (d1 + 1, d0 + 1) + Final lgMap: (d0, d1) -> (d1 + 1, d0 + 1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d1 + 1, d0 + 1) + firstNDims: 2 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1, d2) -> (d1 + 1, d0 + 1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Extending iterator types from nested linalg.generic +Total iterator types: 3 +Total inputs: 8 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/symm.log b/polybench_results/reject_logs/symm.log new file mode 100644 index 000000000000..8af058e775ec --- /dev/null +++ b/polybench_results/reject_logs/symm.log @@ -0,0 +1,318 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg9 = 0 to affine_map<(d0) -> (d0)>(%arg7) { + %13 = affine.load %arg6[%arg7, %arg8] : memref + %14 = arith.mulf %arg2, %13 : f64 + %15 = affine.load %arg5[%arg7, %arg9] : memref + %16 = arith.mulf %14, %15 : f64 + %17 = affine.load %arg4[%arg9, %arg8] : memref + %18 = arith.addf %17, %16 : f64 + affine.store %18, %arg4[%arg9, %arg8] : memref + %19 = affine.load %arg6[%arg9, %arg8] : memref + %20 = affine.load %arg5[%arg7, %arg9] : memref + %21 = arith.mulf %19, %20 : f64 + %22 = affine.load %alloca[] : memref + %23 = arith.addf %22, %21 : f64 + affine.store %23, %alloca[] : memref +} + +Pattern recognition complete: + Loads: 6 + Stores: 2 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %16 = affine.load %arg6[%arg7, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %19 = affine.load %arg5[%arg7, %arg9] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %22 = affine.load %arg4[%arg9, %arg8] : memref +Processing load: %24 = affine.load %arg6[%arg9, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %26 = affine.load %arg5[%arg7, %arg9] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %29 = affine.load %alloca[] : memref + +--- Processing Stores --- +Processing store: affine.store %25, %arg4[%arg9, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing store: affine.store %31, %alloca[] : memref + +=== remap_in_affine_dim === + oldmap: () -> () + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0) -> () + validDims: 0, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 4 +Total outputs: 2 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %2 { + affine.for %arg8 = 0 to %0 { + affine.store %cst, %alloca[] : memref + %3 = polygeist.submap(%arg6, %arg7, %arg8, %arg7) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %4 = polygeist.submap(%arg5, %arg7, %arg7) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg6, %arg8, %arg7) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg5, %arg7, %arg7) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %arg7) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%alloca, %arg7) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4, %5, %6 : memref, memref, memref, memref) outs(%7, %8 : memref, memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64, %out_3: f64): + %19 = arith.mulf %arg2, %in : f64 + %20 = arith.mulf %19, %in_0 : f64 + %21 = arith.addf %out, %20 : f64 + %22 = arith.mulf %in_1, %in_2 : f64 + %23 = arith.addf %out_3, %22 : f64 + linalg.yield %21, %23 : f64, f64 + } + %9 = affine.load %arg4[%arg7, %arg8] : memref + %10 = arith.mulf %arg3, %9 : f64 + %11 = affine.load %arg6[%arg7, %arg8] : memref + %12 = arith.mulf %arg2, %11 : f64 + %13 = affine.load %arg5[%arg7, %arg7] : memref + %14 = arith.mulf %12, %13 : f64 + %15 = arith.addf %10, %14 : f64 + %16 = affine.load %alloca[] : memref + %17 = arith.mulf %arg2, %16 : f64 + %18 = arith.addf %15, %17 : f64 + affine.store %18, %arg4[%arg7, %arg8] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %0 { + affine.store %cst, %alloca[] : memref + %3 = polygeist.submap(%arg6, %arg7, %arg8, %arg7) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %4 = polygeist.submap(%arg5, %arg7, %arg7) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg6, %arg8, %arg7) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg5, %arg7, %arg7) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %arg7) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%alloca, %arg7) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4, %5, %6 : memref, memref, memref, memref) outs(%7, %8 : memref, memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64, %out_3: f64): + %19 = arith.mulf %arg2, %in : f64 + %20 = arith.mulf %19, %in_0 : f64 + %21 = arith.addf %out, %20 : f64 + %22 = arith.mulf %in_1, %in_2 : f64 + %23 = arith.addf %out_3, %22 : f64 + linalg.yield %21, %23 : f64, f64 + } + %9 = affine.load %arg4[%arg7, %arg8] : memref + %10 = arith.mulf %arg3, %9 : f64 + %11 = affine.load %arg6[%arg7, %arg8] : memref + %12 = arith.mulf %arg2, %11 : f64 + %13 = affine.load %arg5[%arg7, %arg7] : memref + %14 = arith.mulf %12, %13 : f64 + %15 = arith.addf %10, %14 : f64 + %16 = affine.load %alloca[] : memref + %17 = arith.mulf %arg2, %16 : f64 + %18 = arith.addf %15, %17 : f64 + affine.store %18, %arg4[%arg7, %arg8] : memref +} + +Pattern recognition complete: + Loads: 4 + Stores: 2 + LinalgGenerics: 1 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %2 { + affine.for %arg8 = 0 to %0 { + affine.store %cst, %alloca[] : memref + %3 = polygeist.submap(%arg6, %arg7, %arg8, %arg7) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %4 = polygeist.submap(%arg5, %arg7, %arg7) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg6, %arg8, %arg7) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg5, %arg7, %arg7) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %arg7) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%alloca, %arg7) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4, %5, %6 : memref, memref, memref, memref) outs(%7, %8 : memref, memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64, %out_3: f64): + %19 = arith.mulf %arg2, %in : f64 + %20 = arith.mulf %19, %in_0 : f64 + %21 = arith.addf %out, %20 : f64 + %22 = arith.mulf %in_1, %in_2 : f64 + %23 = arith.addf %out_3, %22 : f64 + linalg.yield %21, %23 : f64, f64 + } + %9 = affine.load %arg4[%arg7, %arg8] : memref + %10 = arith.mulf %arg3, %9 : f64 + %11 = affine.load %arg6[%arg7, %arg8] : memref + %12 = arith.mulf %arg2, %11 : f64 + %13 = affine.load %arg5[%arg7, %arg7] : memref + %14 = arith.mulf %12, %13 : f64 + %15 = arith.addf %10, %14 : f64 + %16 = affine.load %alloca[] : memref + %17 = arith.mulf %arg2, %16 : f64 + %18 = arith.addf %15, %17 : f64 + affine.store %18, %arg4[%arg7, %arg8] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %0 { + affine.store %cst, %alloca[] : memref + %3 = polygeist.submap(%arg6, %arg7, %arg8, %arg7) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %4 = polygeist.submap(%arg5, %arg7, %arg7) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg6, %arg8, %arg7) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg5, %arg7, %arg7) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg8, %arg7) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %8 = polygeist.submap(%alloca, %arg7) {map = affine_map<(d0) -> ()>} : (memref, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%3, %4, %5, %6 : memref, memref, memref, memref) outs(%7, %8 : memref, memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64, %out_3: f64): + %19 = arith.mulf %arg2, %in : f64 + %20 = arith.mulf %19, %in_0 : f64 + %21 = arith.addf %out, %20 : f64 + %22 = arith.mulf %in_1, %in_2 : f64 + %23 = arith.addf %out_3, %22 : f64 + linalg.yield %21, %23 : f64, f64 + } + %9 = affine.load %arg4[%arg7, %arg8] : memref + %10 = arith.mulf %arg3, %9 : f64 + %11 = affine.load %arg6[%arg7, %arg8] : memref + %12 = arith.mulf %arg2, %11 : f64 + %13 = affine.load %arg5[%arg7, %arg7] : memref + %14 = arith.mulf %12, %13 : f64 + %15 = arith.addf %10, %14 : f64 + %16 = affine.load %alloca[] : memref + %17 = arith.mulf %arg2, %16 : f64 + %18 = arith.addf %15, %17 : f64 + affine.store %18, %arg4[%arg7, %arg8] : memref +} + +Pattern recognition complete: + Loads: 4 + Stores: 2 + LinalgGenerics: 1 + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/syr2k.log b/polybench_results/reject_logs/syr2k.log new file mode 100644 index 000000000000..d94e4516c8c1 --- /dev/null +++ b/polybench_results/reject_logs/syr2k.log @@ -0,0 +1,2056 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg9) = (0) to (%arg7 + 1) { + %2 = affine.load %arg5[%arg9, %arg8] : memref + %3 = arith.mulf %2, %arg2 : f64 + %4 = affine.load %arg6[%arg7, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg6[%arg9, %arg8] : memref + %7 = arith.mulf %6, %arg2 : f64 + %8 = affine.load %arg5[%arg7, %arg8] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %5, %9 : f64 + %11 = affine.load %arg4[%arg7, %arg9] : memref + %12 = arith.addf %11, %10 : f64 + affine.store %12, %arg4[%arg7, %arg9] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + affine.parallel (%arg8) = (0) to (%arg7 + 1) { + %2 = affine.load %arg4[%arg7, %arg8] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg7, %arg8] : memref + } + affine.for %arg8 = 0 to %0 { + affine.parallel (%arg9) = (0) to (%arg7 + 1) { + %2 = affine.load %arg5[%arg9, %arg8] : memref + %3 = arith.mulf %2, %arg2 : f64 + %4 = affine.load %arg6[%arg7, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg6[%arg9, %arg8] : memref + %7 = arith.mulf %6, %arg2 : f64 + %8 = affine.load %arg5[%arg7, %arg8] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %5, %9 : f64 + %11 = affine.load %arg4[%arg7, %arg9] : memref + %12 = arith.addf %11, %10 : f64 + affine.store %12, %arg4[%arg7, %arg9] : memref + } + } +} +Found 2 nested loops to fission + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + affine.for %arg8 = 0 to %0 { + affine.parallel (%arg9) = (0) to (%arg7 + 1) { + %2 = affine.load %arg5[%arg9, %arg8] : memref + %3 = arith.mulf %2, %arg2 : f64 + %4 = affine.load %arg6[%arg7, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg6[%arg9, %arg8] : memref + %7 = arith.mulf %6, %arg2 : f64 + %8 = affine.load %arg5[%arg7, %arg8] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %5, %9 : f64 + %11 = affine.load %arg4[%arg7, %arg9] : memref + %12 = arith.addf %11, %10 : f64 + affine.store %12, %arg4[%arg7, %arg9] : memref + } + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (%arg7 + 1) { + %2 = affine.load %arg4[%arg7, %arg8] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg7, %arg8] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + affine.parallel (%arg8) = (0) to (%arg7 + 1) { + %2 = affine.load %arg4[%arg7, %arg8] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg7, %arg8] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + affine.for %arg8 = 0 to %0 { + affine.parallel (%arg9) = (0) to (%arg7 + 1) { + %2 = affine.load %arg5[%arg9, %arg8] : memref + %3 = arith.mulf %2, %arg2 : f64 + %4 = affine.load %arg6[%arg7, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg6[%arg9, %arg8] : memref + %7 = arith.mulf %6, %arg2 : f64 + %8 = affine.load %arg5[%arg7, %arg8] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %5, %9 : f64 + %11 = affine.load %arg4[%arg7, %arg9] : memref + %12 = arith.addf %11, %10 : f64 + affine.store %12, %arg4[%arg7, %arg9] : memref + } + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg9) = (0) to (%arg7 + 1) { + %2 = affine.load %arg5[%arg9, %arg8] : memref + %3 = arith.mulf %2, %arg2 : f64 + %4 = affine.load %arg6[%arg7, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg6[%arg9, %arg8] : memref + %7 = arith.mulf %6, %arg2 : f64 + %8 = affine.load %arg5[%arg7, %arg8] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %5, %9 : f64 + %11 = affine.load %arg4[%arg7, %arg9] : memref + %12 = arith.addf %11, %10 : f64 + affine.store %12, %arg4[%arg7, %arg9] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + affine.parallel (%arg8) = (0) to (%arg7 + 1) { + %2 = affine.load %arg4[%arg7, %arg8] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg7, %arg8] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (%arg7 + 1) { + %2 = affine.load %arg4[%arg7, %arg8] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg7, %arg8] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + affine.for %arg8 = 0 to %0 { + affine.parallel (%arg9) = (0) to (%arg7 + 1) { + %2 = affine.load %arg5[%arg9, %arg8] : memref + %3 = arith.mulf %2, %arg2 : f64 + %4 = affine.load %arg6[%arg7, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg6[%arg9, %arg8] : memref + %7 = arith.mulf %6, %arg2 : f64 + %8 = affine.load %arg5[%arg7, %arg8] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %5, %9 : f64 + %11 = affine.load %arg4[%arg7, %arg9] : memref + %12 = arith.addf %11, %10 : f64 + affine.store %12, %arg4[%arg7, %arg9] : memref + } + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (symbol(%1)) { + affine.parallel (%arg8) = (0) to (%arg7 + 1) { + %2 = affine.load %arg4[%arg7, %arg8] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg7, %arg8] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (%arg7 + 1) { + %2 = affine.load %arg4[%arg7, %arg8] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg7, %arg8] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg9) = (0) to (%arg7 + 1) { + %2 = affine.load %arg5[%arg9, %arg8] : memref + %3 = arith.mulf %2, %arg2 : f64 + %4 = affine.load %arg6[%arg7, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg6[%arg9, %arg8] : memref + %7 = arith.mulf %6, %arg2 : f64 + %8 = affine.load %arg5[%arg7, %arg8] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %5, %9 : f64 + %11 = affine.load %arg4[%arg7, %arg9] : memref + %12 = arith.addf %11, %10 : f64 + affine.store %12, %arg4[%arg7, %arg9] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + affine.for %arg8 = 0 to %0 { + affine.for %arg9 = 0 to affine_map<(d0) -> (d0 + 1)>(%arg7) { + %2 = affine.load %arg5[%arg9, %arg8] : memref + %3 = arith.mulf %2, %arg2 : f64 + %4 = affine.load %arg6[%arg7, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg6[%arg9, %arg8] : memref + %7 = arith.mulf %6, %arg2 : f64 + %8 = affine.load %arg5[%arg7, %arg8] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %5, %9 : f64 + %11 = affine.load %arg4[%arg7, %arg9] : memref + %12 = arith.addf %11, %10 : f64 + affine.store %12, %arg4[%arg7, %arg9] : memref + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %0 { + affine.for %arg9 = 0 to affine_map<(d0) -> (d0 + 1)>(%arg7) { + %2 = affine.load %arg5[%arg9, %arg8] : memref + %3 = arith.mulf %2, %arg2 : f64 + %4 = affine.load %arg6[%arg7, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg6[%arg9, %arg8] : memref + %7 = arith.mulf %6, %arg2 : f64 + %8 = affine.load %arg5[%arg7, %arg8] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %5, %9 : f64 + %11 = affine.load %arg4[%arg7, %arg9] : memref + %12 = arith.addf %11, %10 : f64 + affine.store %12, %arg4[%arg7, %arg9] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg9 = 0 to affine_map<(d0) -> (d0 + 1)>(%arg7) { + %2 = affine.load %arg5[%arg9, %arg8] : memref + %3 = arith.mulf %2, %arg2 : f64 + %4 = affine.load %arg6[%arg7, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg6[%arg9, %arg8] : memref + %7 = arith.mulf %6, %arg2 : f64 + %8 = affine.load %arg5[%arg7, %arg8] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %5, %9 : f64 + %11 = affine.load %arg4[%arg7, %arg9] : memref + %12 = arith.addf %11, %10 : f64 + affine.store %12, %arg4[%arg7, %arg9] : memref +} + +Pattern recognition complete: + Loads: 5 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0 + 1) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %5 = affine.load %arg5[%arg9, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %8 = affine.load %arg6[%arg7, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %11 = affine.load %arg6[%arg9, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %14 = affine.load %arg5[%arg7, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %18 = affine.load %arg4[%arg7, %arg9] : memref + +--- Processing Stores --- +Processing store: affine.store %19, %arg4[%arg7, %arg9] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 4 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + affine.for %arg8 = 0 to %0 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg5, %arg8, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg6, %arg7, %arg8, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %5 = polygeist.submap(%arg6, %arg8, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg5, %arg7, %arg8, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg7, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3, %4, %5, %6 : memref, memref, memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %8 = arith.mulf %in, %arg2 : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.mulf %in_1, %arg2 : f64 + %11 = arith.mulf %10, %in_2 : f64 + %12 = arith.addf %9, %11 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to %0 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg5, %arg8, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg6, %arg7, %arg8, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %5 = polygeist.submap(%arg6, %arg8, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg5, %arg7, %arg8, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %7 = polygeist.submap(%arg4, %arg7, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3, %4, %5, %6 : memref, memref, memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %8 = arith.mulf %in, %arg2 : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.mulf %in_1, %arg2 : f64 + %11 = arith.mulf %10, %in_2 : f64 + %12 = arith.addf %9, %11 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6, %7, %8, %9 : memref, memref, memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %11 = arith.mulf %in, %arg2 : f64 + %12 = arith.mulf %11, %in_0 : f64 + %13 = arith.mulf %in_1, %arg2 : f64 + %14 = arith.mulf %13, %in_2 : f64 + %15 = arith.addf %12, %14 : f64 + %16 = arith.addf %out, %15 : f64 + linalg.yield %16 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 2 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 2 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 3 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 3 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 4 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %3 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %4 = polygeist.submap(%arg5, %3, %2) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %5 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %6 = polygeist.submap(%arg6, %arg7, %5, %2) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %7 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %8 = polygeist.submap(%arg6, %7, %2) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %9 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %10 = polygeist.submap(%arg5, %arg7, %9, %2) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %11 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %12 = polygeist.submap(%arg4, %arg7, %11, %2) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%4, %6, %8, %10 : memref, memref, memref, memref) outs(%12 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %13 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %14 = arith.mulf %in, %arg2 : f64 + %15 = arith.mulf %14, %in_0 : f64 + %16 = arith.mulf %in_1, %arg2 : f64 + %17 = arith.mulf %16, %in_2 : f64 + %18 = arith.addf %15, %17 : f64 + %19 = arith.addf %out, %18 : f64 + linalg.yield %19 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%7, %9, %11, %13 : memref, memref, memref, memref) outs(%15 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %16 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %17 = arith.mulf %in, %arg2 : f64 + %18 = arith.mulf %17, %in_0 : f64 + %19 = arith.mulf %in_1, %arg2 : f64 + %20 = arith.mulf %19, %in_2 : f64 + %21 = arith.addf %18, %20 : f64 + %22 = arith.addf %out, %21 : f64 + linalg.yield %22 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d0, d1) + Composed map: (d0, d1) -> (d0, d1) + Final lgMap: (d0, d1) -> (d0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d0, d1) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg5, %2, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %5 = polygeist.submap(%arg6, %arg7, %4, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %7 = polygeist.submap(%arg6, %6, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %8 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %9 = polygeist.submap(%arg5, %arg7, %8, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %10 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %11 = polygeist.submap(%arg4, %arg7, %10, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5, %7, %9 : memref, memref, memref, memref) outs(%11 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %12 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %13 = arith.mulf %in, %arg2 : f64 + %14 = arith.mulf %13, %in_0 : f64 + %15 = arith.mulf %in_1, %arg2 : f64 + %16 = arith.mulf %15, %in_2 : f64 + %17 = arith.addf %14, %16 : f64 + %18 = arith.addf %out, %17 : f64 + linalg.yield %18 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8, %10, %12 : memref, memref, memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %15 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %16 = arith.mulf %in, %arg2 : f64 + %17 = arith.mulf %16, %in_0 : f64 + %18 = arith.mulf %in_1, %arg2 : f64 + %19 = arith.mulf %18, %in_2 : f64 + %20 = arith.addf %17, %19 : f64 + %21 = arith.addf %out, %20 : f64 + linalg.yield %21 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d0, d1) + Composed map: (d0, d1) -> (d0, d1) + Final lgMap: (d0, d1) -> (d0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d0, d1) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + affine.for %arg8 = 0 to affine_map<(d0) -> (d0 + 1)>(%arg7) { + %2 = affine.load %arg4[%arg7, %arg8] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg7, %arg8] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to affine_map<(d0) -> (d0 + 1)>(%arg7) { + %2 = affine.load %arg4[%arg7, %arg8] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg7, %arg8] : memref +} + +Pattern recognition complete: + Loads: 1 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0 + 1) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %5 = affine.load %arg4[%arg7, %arg8] : memref + +--- Processing Stores --- +Processing store: affine.store %6, %arg4[%arg7, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 0 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg4, %arg7, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg5, %2, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %5 = polygeist.submap(%arg6, %arg7, %4, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %7 = polygeist.submap(%arg6, %6, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %8 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %9 = polygeist.submap(%arg5, %arg7, %8, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %10 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %11 = polygeist.submap(%arg4, %arg7, %10, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5, %7, %9 : memref, memref, memref, memref) outs(%11 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %12 = arith.mulf %in, %arg2 : f64 + %13 = arith.mulf %12, %in_0 : f64 + %14 = arith.mulf %in_1, %arg2 : f64 + %15 = arith.mulf %14, %in_2 : f64 + %16 = arith.addf %13, %15 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8, %10, %12 : memref, memref, memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %15 = arith.mulf %in, %arg2 : f64 + %16 = arith.mulf %15, %in_0 : f64 + %17 = arith.mulf %in_1, %arg2 : f64 + %18 = arith.mulf %17, %in_2 : f64 + %19 = arith.addf %16, %18 : f64 + %20 = arith.addf %out, %19 : f64 + linalg.yield %20 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d0, d1) + Composed map: (d0, d1) -> (d0, d1) + Final lgMap: (d0, d1) -> (d0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d0, d1) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg4, %arg7, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg5, %2, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %5 = polygeist.submap(%arg6, %arg7, %4, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %7 = polygeist.submap(%arg6, %6, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %8 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %9 = polygeist.submap(%arg5, %arg7, %8, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %10 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %11 = polygeist.submap(%arg4, %arg7, %10, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5, %7, %9 : memref, memref, memref, memref) outs(%11 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %12 = arith.mulf %in, %arg2 : f64 + %13 = arith.mulf %12, %in_0 : f64 + %14 = arith.mulf %in_1, %arg2 : f64 + %15 = arith.mulf %14, %in_2 : f64 + %16 = arith.addf %13, %15 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8, %10, %12 : memref, memref, memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %15 = arith.mulf %in, %arg2 : f64 + %16 = arith.mulf %15, %in_0 : f64 + %17 = arith.mulf %in_1, %arg2 : f64 + %18 = arith.mulf %17, %in_2 : f64 + %19 = arith.addf %16, %18 : f64 + %20 = arith.addf %out, %19 : f64 + linalg.yield %20 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d0, d1) + Composed map: (d0, d1) -> (d0, d1) + Final lgMap: (d0, d1) -> (d0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d0, d1) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg4, %arg7, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg5, %2, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %5 = polygeist.submap(%arg6, %arg7, %4, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %7 = polygeist.submap(%arg6, %6, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %8 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %9 = polygeist.submap(%arg5, %arg7, %8, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %10 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %11 = polygeist.submap(%arg4, %arg7, %10, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5, %7, %9 : memref, memref, memref, memref) outs(%11 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %12 = arith.mulf %in, %arg2 : f64 + %13 = arith.mulf %12, %in_0 : f64 + %14 = arith.mulf %in_1, %arg2 : f64 + %15 = arith.mulf %14, %in_2 : f64 + %16 = arith.addf %13, %15 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8, %10, %12 : memref, memref, memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %15 = arith.mulf %in, %arg2 : f64 + %16 = arith.mulf %15, %in_0 : f64 + %17 = arith.mulf %in_1, %arg2 : f64 + %18 = arith.mulf %17, %in_2 : f64 + %19 = arith.addf %16, %18 : f64 + %20 = arith.addf %out, %19 : f64 + linalg.yield %20 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d0, d1) + Composed map: (d0, d1) -> (d0, d1) + Final lgMap: (d0, d1) -> (d0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d0, d1) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg4, %arg7, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg5, %2, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %5 = polygeist.submap(%arg6, %arg7, %4, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %7 = polygeist.submap(%arg6, %6, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %8 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %9 = polygeist.submap(%arg5, %arg7, %8, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %10 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %11 = polygeist.submap(%arg4, %arg7, %10, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5, %7, %9 : memref, memref, memref, memref) outs(%11 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %12 = arith.mulf %in, %arg2 : f64 + %13 = arith.mulf %12, %in_0 : f64 + %14 = arith.mulf %in_1, %arg2 : f64 + %15 = arith.mulf %14, %in_2 : f64 + %16 = arith.addf %13, %15 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8, %10, %12 : memref, memref, memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %15 = arith.mulf %in, %arg2 : f64 + %16 = arith.mulf %15, %in_0 : f64 + %17 = arith.mulf %in_1, %arg2 : f64 + %18 = arith.mulf %17, %in_2 : f64 + %19 = arith.addf %16, %18 : f64 + %20 = arith.addf %out, %19 : f64 + linalg.yield %20 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d0, d1) + Composed map: (d0, d1) -> (d0, d1) + Final lgMap: (d0, d1) -> (d0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d0, d1) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg4, %arg7, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg5, %2, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %5 = polygeist.submap(%arg6, %arg7, %4, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %7 = polygeist.submap(%arg6, %6, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %8 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %9 = polygeist.submap(%arg5, %arg7, %8, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %10 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %11 = polygeist.submap(%arg4, %arg7, %10, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5, %7, %9 : memref, memref, memref, memref) outs(%11 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %12 = arith.mulf %in, %arg2 : f64 + %13 = arith.mulf %12, %in_0 : f64 + %14 = arith.mulf %in_1, %arg2 : f64 + %15 = arith.mulf %14, %in_2 : f64 + %16 = arith.addf %13, %15 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8, %10, %12 : memref, memref, memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %15 = arith.mulf %in, %arg2 : f64 + %16 = arith.mulf %15, %in_0 : f64 + %17 = arith.mulf %in_1, %arg2 : f64 + %18 = arith.mulf %17, %in_2 : f64 + %19 = arith.addf %16, %18 : f64 + %20 = arith.addf %out, %19 : f64 + linalg.yield %20 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d0, d1) + Composed map: (d0, d1) -> (d0, d1) + Final lgMap: (d0, d1) -> (d0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d0, d1) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg4, %arg7, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg5, %2, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %5 = polygeist.submap(%arg6, %arg7, %4, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %7 = polygeist.submap(%arg6, %6, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %8 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %9 = polygeist.submap(%arg5, %arg7, %8, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %10 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %11 = polygeist.submap(%arg4, %arg7, %10, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5, %7, %9 : memref, memref, memref, memref) outs(%11 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %12 = arith.mulf %in, %arg2 : f64 + %13 = arith.mulf %12, %in_0 : f64 + %14 = arith.mulf %in_1, %arg2 : f64 + %15 = arith.mulf %14, %in_2 : f64 + %16 = arith.addf %13, %15 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8, %10, %12 : memref, memref, memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %15 = arith.mulf %in, %arg2 : f64 + %16 = arith.mulf %15, %in_0 : f64 + %17 = arith.mulf %in_1, %arg2 : f64 + %18 = arith.mulf %17, %in_2 : f64 + %19 = arith.addf %16, %18 : f64 + %20 = arith.addf %out, %19 : f64 + linalg.yield %20 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d0, d1) + Composed map: (d0, d1) -> (d0, d1) + Final lgMap: (d0, d1) -> (d0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d0, d1) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg4, %arg7, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg5, %2, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %5 = polygeist.submap(%arg6, %arg7, %4, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %7 = polygeist.submap(%arg6, %6, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %8 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %9 = polygeist.submap(%arg5, %arg7, %8, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %10 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %11 = polygeist.submap(%arg4, %arg7, %10, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5, %7, %9 : memref, memref, memref, memref) outs(%11 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %12 = arith.mulf %in, %arg2 : f64 + %13 = arith.mulf %12, %in_0 : f64 + %14 = arith.mulf %in_1, %arg2 : f64 + %15 = arith.mulf %14, %in_2 : f64 + %16 = arith.addf %13, %15 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8, %10, %12 : memref, memref, memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %15 = arith.mulf %in, %arg2 : f64 + %16 = arith.mulf %15, %in_0 : f64 + %17 = arith.mulf %in_1, %arg2 : f64 + %18 = arith.mulf %17, %in_2 : f64 + %19 = arith.addf %16, %18 : f64 + %20 = arith.addf %out, %19 : f64 + linalg.yield %20 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d0, d1) + Composed map: (d0, d1) -> (d0, d1) + Final lgMap: (d0, d1) -> (d0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d0, d1) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg4, %arg7, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg5, %2, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %5 = polygeist.submap(%arg6, %arg7, %4, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %7 = polygeist.submap(%arg6, %6, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %8 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %9 = polygeist.submap(%arg5, %arg7, %8, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %10 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %11 = polygeist.submap(%arg4, %arg7, %10, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5, %7, %9 : memref, memref, memref, memref) outs(%11 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %12 = arith.mulf %in, %arg2 : f64 + %13 = arith.mulf %12, %in_0 : f64 + %14 = arith.mulf %in_1, %arg2 : f64 + %15 = arith.mulf %14, %in_2 : f64 + %16 = arith.addf %13, %15 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8, %10, %12 : memref, memref, memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %15 = arith.mulf %in, %arg2 : f64 + %16 = arith.mulf %15, %in_0 : f64 + %17 = arith.mulf %in_1, %arg2 : f64 + %18 = arith.mulf %17, %in_2 : f64 + %19 = arith.addf %16, %18 : f64 + %20 = arith.addf %out, %19 : f64 + linalg.yield %20 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d0, d1) + Composed map: (d0, d1) -> (d0, d1) + Final lgMap: (d0, d1) -> (d0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d0, d1) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg4, %arg7, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg5, %2, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %5 = polygeist.submap(%arg6, %arg7, %4, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %7 = polygeist.submap(%arg6, %6, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %8 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %9 = polygeist.submap(%arg5, %arg7, %8, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %10 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %11 = polygeist.submap(%arg4, %arg7, %10, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5, %7, %9 : memref, memref, memref, memref) outs(%11 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %12 = arith.mulf %in, %arg2 : f64 + %13 = arith.mulf %12, %in_0 : f64 + %14 = arith.mulf %in_1, %arg2 : f64 + %15 = arith.mulf %14, %in_2 : f64 + %16 = arith.addf %13, %15 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8, %10, %12 : memref, memref, memref, memref) outs(%14 : memref) { +^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %15 = arith.mulf %in, %arg2 : f64 + %16 = arith.mulf %15, %in_0 : f64 + %17 = arith.mulf %in_1, %arg2 : f64 + %18 = arith.mulf %17, %in_2 : f64 + %19 = arith.addf %16, %18 : f64 + %20 = arith.addf %out, %19 : f64 + linalg.yield %20 : f64 +} + Processing 4 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1) -> (d0, d1) + Composed map: (d0, d1) -> (d0, d1) + Final lgMap: (d0, d1) -> (d0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d0, d1) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg4, %arg7, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output +WARNING: AffineForOpRaising didn't converge +syr2k.mlir:3:3: warning: AffineForOpRaising didn't converge, continuing anyway + func.func @kernel_syr2k(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: f64, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +syr2k.mlir:3:3: note: see current operation: +func.func @kernel_syr2k(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: f64, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg4, %arg7, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } + } + affine.for %arg7 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %3 = polygeist.submap(%arg5, %2, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %5 = polygeist.submap(%arg6, %arg7, %4, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %7 = polygeist.submap(%arg6, %6, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %8 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %9 = polygeist.submap(%arg5, %arg7, %8, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %10 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg7) + %11 = polygeist.submap(%arg4, %arg7, %10, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5, %7, %9 : memref, memref, memref, memref) outs(%11 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %12 = arith.mulf %in, %arg2 : f64 + %13 = arith.mulf %12, %in_0 : f64 + %14 = arith.mulf %in_1, %arg2 : f64 + %15 = arith.mulf %14, %in_2 : f64 + %16 = arith.addf %13, %15 : f64 + %17 = arith.addf %out, %16 : f64 + linalg.yield %17 : f64 + } + } + return +} +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/syrk.log b/polybench_results/reject_logs/syrk.log new file mode 100644 index 000000000000..92fa41c5cad5 --- /dev/null +++ b/polybench_results/reject_logs/syrk.log @@ -0,0 +1,1802 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (%arg6 + 1) { + %2 = affine.load %arg5[%arg6, %arg7] : memref + %3 = arith.mulf %arg2, %2 : f64 + %4 = affine.load %arg5[%arg8, %arg7] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg4[%arg6, %arg8] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg4[%arg6, %arg8] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%1)) { + affine.parallel (%arg7) = (0) to (%arg6 + 1) { + %2 = affine.load %arg4[%arg6, %arg7] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg6, %arg7] : memref + } + affine.for %arg7 = 0 to %0 { + affine.parallel (%arg8) = (0) to (%arg6 + 1) { + %2 = affine.load %arg5[%arg6, %arg7] : memref + %3 = arith.mulf %arg2, %2 : f64 + %4 = affine.load %arg5[%arg8, %arg7] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg4[%arg6, %arg8] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg4[%arg6, %arg8] : memref + } + } +} +Found 2 nested loops to fission + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%1)) { + affine.for %arg7 = 0 to %0 { + affine.parallel (%arg8) = (0) to (%arg6 + 1) { + %2 = affine.load %arg5[%arg6, %arg7] : memref + %3 = arith.mulf %arg2, %2 : f64 + %4 = affine.load %arg5[%arg8, %arg7] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg4[%arg6, %arg8] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg4[%arg6, %arg8] : memref + } + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (%arg6 + 1) { + %2 = affine.load %arg4[%arg6, %arg7] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg6, %arg7] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%1)) { + affine.parallel (%arg7) = (0) to (%arg6 + 1) { + %2 = affine.load %arg4[%arg6, %arg7] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg6, %arg7] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%1)) { + affine.for %arg7 = 0 to %0 { + affine.parallel (%arg8) = (0) to (%arg6 + 1) { + %2 = affine.load %arg5[%arg6, %arg7] : memref + %3 = arith.mulf %arg2, %2 : f64 + %4 = affine.load %arg5[%arg8, %arg7] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg4[%arg6, %arg8] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg4[%arg6, %arg8] : memref + } + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (%arg6 + 1) { + %2 = affine.load %arg5[%arg6, %arg7] : memref + %3 = arith.mulf %arg2, %2 : f64 + %4 = affine.load %arg5[%arg8, %arg7] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg4[%arg6, %arg8] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg4[%arg6, %arg8] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%1)) { + affine.parallel (%arg7) = (0) to (%arg6 + 1) { + %2 = affine.load %arg4[%arg6, %arg7] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg6, %arg7] : memref + } +} +REJECTED: Less than 2 nested loops (found 1) + + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (%arg6 + 1) { + %2 = affine.load %arg4[%arg6, %arg7] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg6, %arg7] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%1)) { + affine.for %arg7 = 0 to %0 { + affine.parallel (%arg8) = (0) to (%arg6 + 1) { + %2 = affine.load %arg5[%arg6, %arg7] : memref + %3 = arith.mulf %arg2, %2 : f64 + %4 = affine.load %arg5[%arg8, %arg7] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg4[%arg6, %arg8] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg4[%arg6, %arg8] : memref + } + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%1)) { + affine.parallel (%arg7) = (0) to (%arg6 + 1) { + %2 = affine.load %arg4[%arg6, %arg7] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg6, %arg7] : memref + } +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (0) to (%arg6 + 1) { + %2 = affine.load %arg4[%arg6, %arg7] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg6, %arg7] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg8) = (0) to (%arg6 + 1) { + %2 = affine.load %arg5[%arg6, %arg7] : memref + %3 = arith.mulf %arg2, %2 : f64 + %4 = affine.load %arg5[%arg8, %arg7] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg4[%arg6, %arg8] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg4[%arg6, %arg8] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to affine_map<(d0) -> (d0 + 1)>(%arg6) { + %2 = affine.load %arg5[%arg6, %arg7] : memref + %3 = arith.mulf %arg2, %2 : f64 + %4 = affine.load %arg5[%arg8, %arg7] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg4[%arg6, %arg8] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg4[%arg6, %arg8] : memref + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to affine_map<(d0) -> (d0 + 1)>(%arg6) { + %2 = affine.load %arg5[%arg6, %arg7] : memref + %3 = arith.mulf %arg2, %2 : f64 + %4 = affine.load %arg5[%arg8, %arg7] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg4[%arg6, %arg8] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg4[%arg6, %arg8] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg8 = 0 to affine_map<(d0) -> (d0 + 1)>(%arg6) { + %2 = affine.load %arg5[%arg6, %arg7] : memref + %3 = arith.mulf %arg2, %2 : f64 + %4 = affine.load %arg5[%arg8, %arg7] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg4[%arg6, %arg8] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg4[%arg6, %arg8] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0 + 1) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %5 = affine.load %arg5[%arg6, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 0 + new map (map2): (d0)[s0, s1] -> (s0, s1) + validDims: 0, validSims: 2 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %8 = affine.load %arg5[%arg8, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (d0, s0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %11 = affine.load %arg4[%arg6, %arg8] : memref + +--- Processing Stores --- +Processing store: affine.store %12, %arg4[%arg6, %arg8] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + affine.for %arg7 = 0 to %0 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg5, %arg6, %arg7, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %4 = polygeist.submap(%arg5, %arg7, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg4, %arg6, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %6 = arith.mulf %arg2, %in : f64 + %7 = arith.mulf %6, %in_0 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to %0 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg5, %arg6, %arg7, %2) {map = affine_map<(d0)[s0, s1] -> (s0, s1)>} : (memref, index, index, index) -> memref + %4 = polygeist.submap(%arg5, %arg7, %2) {map = affine_map<(d0)[s0] -> (d0, s0)>} : (memref, index, index) -> memref + %5 = polygeist.submap(%arg4, %arg6, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %6 = arith.mulf %arg2, %in : f64 + %7 = arith.mulf %6, %in_0 : f64 + %8 = arith.addf %out, %7 : f64 + linalg.yield %8 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} ins(%6, %7 : memref, memref) outs(%8 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %arg2, %in : f64 + %10 = arith.mulf %9, %in_0 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0, s1] -> (s0, s1) + Composed map: (d0)[s0, s1] -> (s0, s1) + Final lgMap: (d0)[s0, s1] -> (s0, s1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0, s1] -> (s0, s1) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1)[s0] -> (s0, d1) + validDims: 2, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Input 1 indexing map: (d0) -> (d0) + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (d0, s0) + Composed map: (d0)[s0] -> (d0, s0) + Final lgMap: (d0)[s0] -> (d0, s0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 1 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (d0, s0) + firstNDims: 1 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d0, d1) + validDims: 2, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0, d1)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Processing Loads --- + +--- Processing Stores --- + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Extending iterator types from nested linalg.generic +Total iterator types: 2 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<()[s0] -> (s0)>()[%0] + %3 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %4 = polygeist.submap(%arg5, %arg6, %3, %2) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %5 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %6 = polygeist.submap(%arg5, %5, %2) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %7 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %8 = polygeist.submap(%arg4, %arg6, %7, %2) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%4, %6 : memref, memref) outs(%8 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %10 = arith.mulf %arg2, %in : f64 + %11 = arith.mulf %10, %in_0 : f64 + %12 = arith.addf %out, %11 : f64 + linalg.yield %12 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%7, %9 : memref, memref) outs(%11 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %12 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %13 = arith.mulf %arg2, %in : f64 + %14 = arith.mulf %13, %in_0 : f64 + %15 = arith.addf %out, %14 : f64 + linalg.yield %15 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1) + Composed map: (d0, d1)[s0] -> (s0, d1) + Final lgMap: (d0, d1)[s0] -> (s0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2, d1) + validDims: 3, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg5, %arg6, %2, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %5 = polygeist.submap(%arg5, %4, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %7 = polygeist.submap(%arg4, %arg6, %6, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %9 = arith.mulf %arg2, %in : f64 + %10 = arith.mulf %9, %in_0 : f64 + %11 = arith.addf %out, %10 : f64 + linalg.yield %11 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %12 = arith.mulf %arg2, %in : f64 + %13 = arith.mulf %12, %in_0 : f64 + %14 = arith.addf %out, %13 : f64 + linalg.yield %14 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1) + Composed map: (d0, d1)[s0] -> (s0, d1) + Final lgMap: (d0, d1)[s0] -> (s0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2, d1) + validDims: 3, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + affine.for %arg7 = 0 to affine_map<(d0) -> (d0 + 1)>(%arg6) { + %2 = affine.load %arg4[%arg6, %arg7] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg6, %arg7] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = 0 to affine_map<(d0) -> (d0 + 1)>(%arg6) { + %2 = affine.load %arg4[%arg6, %arg7] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg6, %arg7] : memref +} + +Pattern recognition complete: + Loads: 1 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0 + 1) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %5 = affine.load %arg4[%arg6, %arg7] : memref + +--- Processing Stores --- +Processing store: affine.store %6, %arg4[%arg6, %arg7] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: parallel +Total iterator types: 1 +Total inputs: 0 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg4, %arg6, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg5, %arg6, %2, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %5 = polygeist.submap(%arg5, %4, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %7 = polygeist.submap(%arg4, %arg6, %6, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg2, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %arg2, %in : f64 + %12 = arith.mulf %11, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1) + Composed map: (d0, d1)[s0] -> (s0, d1) + Final lgMap: (d0, d1)[s0] -> (s0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2, d1) + validDims: 3, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg4, %arg6, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg5, %arg6, %2, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %5 = polygeist.submap(%arg5, %4, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %7 = polygeist.submap(%arg4, %arg6, %6, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg2, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %arg2, %in : f64 + %12 = arith.mulf %11, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1) + Composed map: (d0, d1)[s0] -> (s0, d1) + Final lgMap: (d0, d1)[s0] -> (s0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2, d1) + validDims: 3, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg4, %arg6, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg5, %arg6, %2, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %5 = polygeist.submap(%arg5, %4, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %7 = polygeist.submap(%arg4, %arg6, %6, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg2, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %arg2, %in : f64 + %12 = arith.mulf %11, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1) + Composed map: (d0, d1)[s0] -> (s0, d1) + Final lgMap: (d0, d1)[s0] -> (s0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2, d1) + validDims: 3, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg4, %arg6, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg5, %arg6, %2, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %5 = polygeist.submap(%arg5, %4, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %7 = polygeist.submap(%arg4, %arg6, %6, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg2, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %arg2, %in : f64 + %12 = arith.mulf %11, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1) + Composed map: (d0, d1)[s0] -> (s0, d1) + Final lgMap: (d0, d1)[s0] -> (s0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2, d1) + validDims: 3, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg4, %arg6, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg5, %arg6, %2, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %5 = polygeist.submap(%arg5, %4, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %7 = polygeist.submap(%arg4, %arg6, %6, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg2, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %arg2, %in : f64 + %12 = arith.mulf %11, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1) + Composed map: (d0, d1)[s0] -> (s0, d1) + Final lgMap: (d0, d1)[s0] -> (s0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2, d1) + validDims: 3, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg4, %arg6, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg5, %arg6, %2, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %5 = polygeist.submap(%arg5, %4, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %7 = polygeist.submap(%arg4, %arg6, %6, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg2, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %arg2, %in : f64 + %12 = arith.mulf %11, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1) + Composed map: (d0, d1)[s0] -> (s0, d1) + Final lgMap: (d0, d1)[s0] -> (s0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2, d1) + validDims: 3, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg4, %arg6, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg5, %arg6, %2, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %5 = polygeist.submap(%arg5, %4, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %7 = polygeist.submap(%arg4, %arg6, %6, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg2, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %arg2, %in : f64 + %12 = arith.mulf %11, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1) + Composed map: (d0, d1)[s0] -> (s0, d1) + Final lgMap: (d0, d1)[s0] -> (s0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2, d1) + validDims: 3, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg4, %arg6, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg5, %arg6, %2, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %5 = polygeist.submap(%arg5, %4, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %7 = polygeist.submap(%arg4, %arg6, %6, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg2, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %arg2, %in : f64 + %12 = arith.mulf %11, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1) + Composed map: (d0, d1)[s0] -> (s0, d1) + Final lgMap: (d0, d1)[s0] -> (s0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2, d1) + validDims: 3, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg4, %arg6, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg5, %arg6, %2, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %5 = polygeist.submap(%arg5, %4, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %7 = polygeist.submap(%arg4, %arg6, %6, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg2, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%6, %8 : memref, memref) outs(%10 : memref) { +^bb0(%in: f64, %in_0: f64, %out: f64): + %11 = arith.mulf %arg2, %in : f64 + %12 = arith.mulf %11, %in_0 : f64 + %13 = arith.addf %out, %12 : f64 + linalg.yield %13 : f64 +} + Processing 2 inputs + Input 0 indexing map: (d0, d1) -> (d0, d1) + +=== getLinalgArgMap === + Initial lgMap: (d0, d1) -> (d0, d1) + Found SubmapOp with map: (d0, d1)[s0] -> (s0, d1) + Composed map: (d0, d1)[s0] -> (s0, d1) + Final lgMap: (d0, d1)[s0] -> (s0, d1) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for input 0 + +=== remap_in_affine_dim === + oldmap: (d0, d1)[s0] -> (s0, d1) + firstNDims: 2 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 2 + check_reduction (output): 0 + new map (map2): (d0, d1, d2) -> (d2, d1) + validDims: 3, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for input + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg4, %arg6, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } +} + +Pattern recognition complete: + Loads: 0 + Stores: 0 + LinalgGenerics: 1 + +Loop bounds: + lbMap: () -> (0) + ubMap: ()[s0] -> (s0) + +--- Processing Linalg Generics --- +Processing linalg.generic: +linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%6 : memref) { +^bb0(%out: f64): + %7 = arith.mulf %out, %arg3 : f64 + linalg.yield %7 : f64 +} + Processing 0 inputs + Processing 1 outputs + +=== getLinalgArgMap === + Initial lgMap: (d0) -> (d0) + Found SubmapOp with map: (d0)[s0] -> (s0, d0) + Composed map: (d0)[s0] -> (s0, d0) + Final lgMap: (d0)[s0] -> (s0, d0) +=== getLinalgArgMap END === + + Calling remap_in_affine_dim for output 0 + +=== remap_in_affine_dim === + oldmap: (d0)[s0] -> (s0, d0) + firstNDims: 1 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0, d1) -> (d1, d0) + validDims: 2, validSims: 0 +Non-dominating block argument encountered + REJECTED: remap_in_affine_dim returned illegal for output +WARNING: AffineForOpRaising didn't converge +syrk.mlir:3:3: warning: AffineForOpRaising didn't converge, continuing anyway + func.func @kernel_syrk(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: f64, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +syrk.mlir:3:3: note: see current operation: +func.func @kernel_syrk(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: f64, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg4, %arg6, %2) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%3 : memref) { + ^bb0(%out: f64): + %4 = arith.mulf %out, %arg3 : f64 + linalg.yield %4 : f64 + } + } + affine.for %arg6 = 0 to %1 { + %2 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %3 = polygeist.submap(%arg5, %arg6, %2, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + %4 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %5 = polygeist.submap(%arg5, %4, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %6 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg6) + %7 = polygeist.submap(%arg4, %arg6, %6, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d0)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["reduction", "parallel"]} ins(%3, %5 : memref, memref) outs(%7 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %arg2, %in : f64 + %9 = arith.mulf %8, %in_0 : f64 + %10 = arith.addf %out, %9 : f64 + linalg.yield %10 : f64 + } + } + return +} +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/trisolv.log b/polybench_results/reject_logs/trisolv.log new file mode 100644 index 000000000000..ba8d50b8e51c --- /dev/null +++ b/polybench_results/reject_logs/trisolv.log @@ -0,0 +1,166 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 0 to affine_map<(d0) -> (d0)>(%arg4) { + %5 = affine.load %arg1[%arg4, %arg5] : memref + %6 = affine.load %arg2[%arg5] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg2[%arg4] : memref + %9 = arith.subf %8, %7 : f64 + affine.store %9, %arg2[%arg4] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +Loop bounds: + lbMap: () -> (0) + ubMap: (d0) -> (d0) + +--- Processing Linalg Generics --- + +--- Processing Loads --- +Processing load: %8 = affine.load %arg1[%arg4, %arg5] : memref + +=== remap_in_affine_dim === + oldmap: (d0, d1) -> (d0, d1) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 1 + check_reduction (output): 0 + new map (map2): (d0)[s0] -> (s0, d0) + validDims: 1, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %10 = affine.load %arg2[%arg5] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 0 + lower_bound_val: 0 + dimidx: 0 + check_reduction (output): 0 + new map (map2): (d0) -> (d0) + validDims: 1, validSims: 0 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + +Processing load: %13 = affine.load %arg2[%arg4] : memref + +--- Processing Stores --- +Processing store: affine.store %14, %arg2[%arg4] : memref + +=== remap_in_affine_dim === + oldmap: (d0) -> (d0) + firstNDims: 0 + check_reduction (input): 1 + lower_bound_val: 0 + dimidx: -1 + check_reduction (output): 1 + new map (map2): (d0)[s0] -> (s0) + validDims: 0, validSims: 1 + Created SubmapOp with type: memref +=== remap_in_affine_dim END === + + +--- Creating linalg.generic --- +Iterator type for this loop: reduction +Total iterator types: 1 +Total inputs: 2 +Total outputs: 1 + +=== AffineForOpRaising SUCCESS === +======================================== + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %0 { + %1 = affine.load %arg3[%arg4] : memref + affine.store %1, %arg2[%arg4] : memref + %2 = polygeist.submap(%arg1, %arg4, %arg4) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg2, %arg4) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg2, %arg4, %arg4) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + %5 = affine.load %arg2[%arg4] : memref + %6 = affine.load %arg1[%arg4, %arg4] : memref + %7 = arith.divf %5, %6 : f64 + affine.store %7, %arg2[%arg4] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 2 + LinalgGenerics: 1 + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg4 = 0 to %0 { + %1 = affine.load %arg3[%arg4] : memref + affine.store %1, %arg2[%arg4] : memref + %2 = polygeist.submap(%arg1, %arg4, %arg4) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + %3 = polygeist.submap(%arg2, %arg4) {map = affine_map<(d0) -> (d0)>} : (memref, index) -> memref + %4 = polygeist.submap(%arg2, %arg4, %arg4) {map = affine_map<(d0)[s0] -> (s0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>], iterator_types = ["reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %8 = arith.mulf %in, %in_0 : f64 + %9 = arith.subf %out, %8 : f64 + linalg.yield %9 : f64 + } + %5 = affine.load %arg2[%arg4] : memref + %6 = affine.load %arg1[%arg4, %arg4] : memref + %7 = arith.divf %5, %6 : f64 + affine.store %7, %arg2[%arg4] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 2 + LinalgGenerics: 1 + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/reject_logs/trmm.log b/polybench_results/reject_logs/trmm.log new file mode 100644 index 000000000000..4cfaae895348 --- /dev/null +++ b/polybench_results/reject_logs/trmm.log @@ -0,0 +1,154 @@ + +**************************************** +*** RaiseAffineToLinalgPipeline START *** +**************************************** + +Running pipeline... + +**************************************** +*** RaiseAffineToLinalg START *** +**************************************** + +### Step 1: Applying AffineParallelFission ### + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%0)) { + affine.parallel (%arg7) = (%arg5 + 1) to (symbol(%1)) { + %4 = affine.load %arg3[%arg7, %arg5] : memref + %5 = affine.load %arg4[%arg7, %arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg4[%arg5, %arg6] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg4[%arg5, %arg6] : memref + } + %2 = affine.load %arg4[%arg5, %arg6] : memref + %3 = arith.mulf %arg2, %2 : f64 + affine.store %3, %arg4[%arg5, %arg6] : memref +} + +=== AffineParallelFission === +Processing affine.parallel: +affine.parallel (%arg7) = (%arg5 + 1) to (symbol(%1)) { + %4 = affine.load %arg3[%arg7, %arg5] : memref + %5 = affine.load %arg4[%arg7, %arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg4[%arg5, %arg6] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg4[%arg5, %arg6] : memref +} +### Step 1 Complete ### + +### Step 2: Applying AffineParallelToFor ### + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg6) = (0) to (symbol(%0)) { + affine.parallel (%arg7) = (%arg5 + 1) to (symbol(%1)) { + %4 = affine.load %arg3[%arg7, %arg5] : memref + %5 = affine.load %arg4[%arg7, %arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg4[%arg5, %arg6] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg4[%arg5, %arg6] : memref + } + %2 = affine.load %arg4[%arg5, %arg6] : memref + %3 = arith.mulf %arg2, %2 : f64 + affine.store %3, %arg4[%arg5, %arg6] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + + +=== AffineParallelToFor === +Processing affine.parallel: +affine.parallel (%arg7) = (%arg5 + 1) to (symbol(%1)) { + %4 = affine.load %arg3[%arg7, %arg5] : memref + %5 = affine.load %arg4[%arg7, %arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg4[%arg5, %arg6] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg4[%arg5, %arg6] : memref +} +Converting parallel loop with 1 induction variables +=== AffineParallelToFor SUCCESS === + +### Step 2 Complete ### + +### Step 3: Applying AffineForOpRaising ### + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg5 = 0 to %1 { + affine.for %arg6 = 0 to %0 { + affine.for %arg7 = affine_map<(d0) -> (d0 + 1)>(%arg5) to %1 { + %4 = affine.load %arg3[%arg7, %arg5] : memref + %5 = affine.load %arg4[%arg7, %arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg4[%arg5, %arg6] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg4[%arg5, %arg6] : memref + } + %2 = affine.load %arg4[%arg5, %arg6] : memref + %3 = arith.mulf %arg2, %2 : f64 + affine.store %3, %arg4[%arg5, %arg6] : memref + } +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg6 = 0 to %0 { + affine.for %arg7 = affine_map<(d0) -> (d0 + 1)>(%arg5) to %1 { + %4 = affine.load %arg3[%arg7, %arg5] : memref + %5 = affine.load %arg4[%arg7, %arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg4[%arg5, %arg6] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg4[%arg5, %arg6] : memref + } + %2 = affine.load %arg4[%arg5, %arg6] : memref + %3 = arith.mulf %arg2, %2 : f64 + affine.store %3, %arg4[%arg5, %arg6] : memref +} + +REJECTED: Walk was interrupted (invalid operations found) + + +======================================== +=== AffineForOpRaising::matchAndRewrite === +======================================== +Processing loop: +affine.for %arg7 = affine_map<(d0) -> (d0 + 1)>(%arg5) to %1 { + %4 = affine.load %arg3[%arg7, %arg5] : memref + %5 = affine.load %arg4[%arg7, %arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg4[%arg5, %arg6] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg4[%arg5, %arg6] : memref +} + +Pattern recognition complete: + Loads: 3 + Stores: 1 + LinalgGenerics: 0 + +REJECTED: Loop doesn't have constant lower bound + +### Step 3 Complete ### + +**************************************** +*** RaiseAffineToLinalg END *** +**************************************** + + +**************************************** +*** RaiseAffineToLinalgPipeline END *** +**************************************** + diff --git a/polybench_results/seidel-2d.log b/polybench_results/seidel-2d.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/seidel-2d.mlir b/polybench_results/seidel-2d.mlir new file mode 100644 index 000000000000..1a63ae4a3c5b --- /dev/null +++ b/polybench_results/seidel-2d.mlir @@ -0,0 +1,34 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_seidel_2d(%arg0: i32, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 9.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %1 = arith.index_cast %arg1 : i32 to index + affine.for %arg3 = 0 to %0 { + affine.for %arg4 = 1 to #map()[%1] { + affine.for %arg5 = 1 to #map()[%1] { + %2 = affine.load %arg2[%arg4 - 1, %arg5 - 1] : memref + %3 = affine.load %arg2[%arg4 - 1, %arg5] : memref + %4 = arith.addf %2, %3 : f64 + %5 = affine.load %arg2[%arg4 - 1, %arg5 + 1] : memref + %6 = arith.addf %4, %5 : f64 + %7 = affine.load %arg2[%arg4, %arg5 - 1] : memref + %8 = arith.addf %6, %7 : f64 + %9 = affine.load %arg2[%arg4, %arg5] : memref + %10 = arith.addf %8, %9 : f64 + %11 = affine.load %arg2[%arg4, %arg5 + 1] : memref + %12 = arith.addf %10, %11 : f64 + %13 = affine.load %arg2[%arg4 + 1, %arg5 - 1] : memref + %14 = arith.addf %12, %13 : f64 + %15 = affine.load %arg2[%arg4 + 1, %arg5] : memref + %16 = arith.addf %14, %15 : f64 + %17 = affine.load %arg2[%arg4 + 1, %arg5 + 1] : memref + %18 = arith.addf %16, %17 : f64 + %19 = arith.divf %18, %cst : f64 + affine.store %19, %arg2[%arg4, %arg5] : memref + } + } + } + return + } +} diff --git a/polybench_results/seidel-2d_debuf.mlir b/polybench_results/seidel-2d_debuf.mlir new file mode 100644 index 000000000000..1e75ff5d99e2 --- /dev/null +++ b/polybench_results/seidel-2d_debuf.mlir @@ -0,0 +1,83 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d0)> +#map2 = affine_map<(d0, d1, d2) -> (d1, d0 + 1)> +#map3 = affine_map<(d0, d1, d2) -> (d1, d0 + 2)> +#map4 = affine_map<(d0, d1, d2) -> (d1 + 1, d0)> +#map5 = affine_map<(d0, d1, d2) -> (d1 + 1, d0 + 2)> +#map6 = affine_map<(d0, d1, d2) -> (d1 + 2, d0)> +#map7 = affine_map<(d0, d1, d2) -> (d1 + 2, d0 + 1)> +#map8 = affine_map<(d0, d1, d2) -> (d1 + 2, d0 + 2)> +#map9 = affine_map<(d0, d1, d2) -> (d1 + 1, d0 + 1)> +#map10 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_seidel_2d(%arg0: i32, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 9.000000e+00 : f64 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg2 : memref + %1 = arith.index_cast %arg0 : i32 to index + %2 = arith.index_cast %arg1 : i32 to index + %3 = affine.apply #map()[%2] + %4 = arith.subi %3, %c1 : index + %5 = affine.apply #map()[%2] + %6 = arith.subi %5, %c1 : index + %7 = affine.apply #map()[%2] + %8 = arith.subi %7, %c1 : index + %9 = affine.apply #map()[%2] + %10 = arith.subi %9, %c1 : index + %11 = affine.apply #map()[%2] + %12 = arith.subi %11, %c1 : index + %13 = affine.apply #map()[%2] + %14 = arith.subi %13, %c1 : index + %15 = affine.apply #map()[%2] + %16 = arith.subi %15, %c1 : index + %17 = affine.apply #map()[%2] + %18 = arith.subi %17, %c1 : index + %19 = affine.apply #map()[%2] + %20 = arith.subi %19, %c1 : index + %21 = affine.apply #map()[%2] + %22 = arith.subi %21, %c1 : index + %23 = affine.apply #map()[%2] + %24 = arith.subi %23, %c1 : index + %25 = affine.apply #map()[%2] + %26 = arith.subi %25, %c1 : index + %27 = affine.apply #map()[%2] + %28 = arith.subi %27, %c1 : index + %29 = affine.apply #map()[%2] + %30 = arith.subi %29, %c1 : index + %31 = affine.apply #map()[%2] + %32 = arith.subi %31, %c1 : index + %33 = affine.apply #map()[%2] + %34 = arith.subi %33, %c1 : index + %35 = affine.apply #map()[%2] + %36 = arith.subi %35, %c1 : index + %37 = affine.apply #map()[%2] + %38 = arith.subi %37, %c1 : index + %39 = polygeist.submap(%0, %4, %6, %1) {map = #map1} : (tensor, index, index, index) -> tensor + %40 = polygeist.submap(%0, %8, %10, %1) {map = #map2} : (tensor, index, index, index) -> tensor + %41 = polygeist.submap(%0, %12, %14, %1) {map = #map3} : (tensor, index, index, index) -> tensor + %42 = polygeist.submap(%0, %16, %18, %1) {map = #map4} : (tensor, index, index, index) -> tensor + %43 = polygeist.submap(%0, %20, %22, %1) {map = #map5} : (tensor, index, index, index) -> tensor + %44 = polygeist.submap(%0, %24, %26, %1) {map = #map6} : (tensor, index, index, index) -> tensor + %45 = polygeist.submap(%0, %28, %30, %1) {map = #map7} : (tensor, index, index, index) -> tensor + %46 = polygeist.submap(%0, %32, %34, %1) {map = #map8} : (tensor, index, index, index) -> tensor + %47 = polygeist.submap(%0, %36, %38, %1) {map = #map9} : (tensor, index, index, index) -> tensor + %48 = linalg.generic {doc = "", indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10], iterator_types = ["reduction", "parallel", "parallel"], library_call = ""} ins(%39, %40, %41, %42, %43, %44, %45, %46 : tensor, tensor, tensor, tensor, tensor, tensor, tensor, tensor) outs(%47 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %51 = arith.addf %in, %in_0 : f64 + %52 = arith.addf %51, %in_1 : f64 + %53 = arith.addf %52, %in_2 : f64 + %54 = arith.addf %53, %out : f64 + %55 = arith.addf %54, %in_3 : f64 + %56 = arith.addf %55, %in_4 : f64 + %57 = arith.addf %56, %in_5 : f64 + %58 = arith.addf %57, %in_6 : f64 + %59 = arith.divf %58, %cst : f64 + linalg.yield %59 : f64 + } -> tensor + %49 = polygeist.submapInverse(%0, %48, %36, %38, %1) {map = #map9} : (tensor, tensor, index, index, index) -> tensor + %50 = bufferization.to_memref %49 : memref + memref.copy %50, %arg2 : memref to memref + return + } +} + diff --git a/polybench_results/seidel-2d_linalg.mlir b/polybench_results/seidel-2d_linalg.mlir new file mode 100644 index 000000000000..b29771517e6f --- /dev/null +++ b/polybench_results/seidel-2d_linalg.mlir @@ -0,0 +1,79 @@ +#map = affine_map<()[s0] -> (s0 - 1)> +#map1 = affine_map<(d0, d1, d2) -> (d1, d0)> +#map2 = affine_map<(d0, d1, d2) -> (d1, d0 + 1)> +#map3 = affine_map<(d0, d1, d2) -> (d1, d0 + 2)> +#map4 = affine_map<(d0, d1, d2) -> (d1 + 1, d0)> +#map5 = affine_map<(d0, d1, d2) -> (d1 + 1, d0 + 2)> +#map6 = affine_map<(d0, d1, d2) -> (d1 + 2, d0)> +#map7 = affine_map<(d0, d1, d2) -> (d1 + 2, d0 + 1)> +#map8 = affine_map<(d0, d1, d2) -> (d1 + 2, d0 + 2)> +#map9 = affine_map<(d0, d1, d2) -> (d1 + 1, d0 + 1)> +#map10 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_seidel_2d(%arg0: i32, %arg1: i32, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 9.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %1 = arith.index_cast %arg1 : i32 to index + %2 = affine.apply #map()[%1] + %3 = arith.subi %2, %c1 : index + %4 = affine.apply #map()[%1] + %5 = arith.subi %4, %c1 : index + %6 = polygeist.submap(%arg2, %3, %5, %0) {map = #map1} : (memref, index, index, index) -> memref + %7 = affine.apply #map()[%1] + %8 = arith.subi %7, %c1 : index + %9 = affine.apply #map()[%1] + %10 = arith.subi %9, %c1 : index + %11 = polygeist.submap(%arg2, %8, %10, %0) {map = #map2} : (memref, index, index, index) -> memref + %12 = affine.apply #map()[%1] + %13 = arith.subi %12, %c1 : index + %14 = affine.apply #map()[%1] + %15 = arith.subi %14, %c1 : index + %16 = polygeist.submap(%arg2, %13, %15, %0) {map = #map3} : (memref, index, index, index) -> memref + %17 = affine.apply #map()[%1] + %18 = arith.subi %17, %c1 : index + %19 = affine.apply #map()[%1] + %20 = arith.subi %19, %c1 : index + %21 = polygeist.submap(%arg2, %18, %20, %0) {map = #map4} : (memref, index, index, index) -> memref + %22 = affine.apply #map()[%1] + %23 = arith.subi %22, %c1 : index + %24 = affine.apply #map()[%1] + %25 = arith.subi %24, %c1 : index + %26 = polygeist.submap(%arg2, %23, %25, %0) {map = #map5} : (memref, index, index, index) -> memref + %27 = affine.apply #map()[%1] + %28 = arith.subi %27, %c1 : index + %29 = affine.apply #map()[%1] + %30 = arith.subi %29, %c1 : index + %31 = polygeist.submap(%arg2, %28, %30, %0) {map = #map6} : (memref, index, index, index) -> memref + %32 = affine.apply #map()[%1] + %33 = arith.subi %32, %c1 : index + %34 = affine.apply #map()[%1] + %35 = arith.subi %34, %c1 : index + %36 = polygeist.submap(%arg2, %33, %35, %0) {map = #map7} : (memref, index, index, index) -> memref + %37 = affine.apply #map()[%1] + %38 = arith.subi %37, %c1 : index + %39 = affine.apply #map()[%1] + %40 = arith.subi %39, %c1 : index + %41 = polygeist.submap(%arg2, %38, %40, %0) {map = #map8} : (memref, index, index, index) -> memref + %42 = affine.apply #map()[%1] + %43 = arith.subi %42, %c1 : index + %44 = affine.apply #map()[%1] + %45 = arith.subi %44, %c1 : index + %46 = polygeist.submap(%arg2, %43, %45, %0) {map = #map9} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10, #map10], iterator_types = ["reduction", "parallel", "parallel"]} ins(%6, %11, %16, %21, %26, %31, %36, %41 : memref, memref, memref, memref, memref, memref, memref, memref) outs(%46 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %in_3: f64, %in_4: f64, %in_5: f64, %in_6: f64, %out: f64): + %47 = arith.addf %in, %in_0 : f64 + %48 = arith.addf %47, %in_1 : f64 + %49 = arith.addf %48, %in_2 : f64 + %50 = arith.addf %49, %out : f64 + %51 = arith.addf %50, %in_3 : f64 + %52 = arith.addf %51, %in_4 : f64 + %53 = arith.addf %52, %in_5 : f64 + %54 = arith.addf %53, %in_6 : f64 + %55 = arith.divf %54, %cst : f64 + linalg.yield %55 : f64 + } + return + } +} + diff --git a/polybench_results/symm.log b/polybench_results/symm.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/symm.mlir b/polybench_results/symm.mlir new file mode 100644 index 000000000000..044979bb6e38 --- /dev/null +++ b/polybench_results/symm.mlir @@ -0,0 +1,43 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_symm(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: f64, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %alloca = memref.alloca() : memref + %1 = llvm.mlir.undef : f64 + affine.store %1, %alloca[] : memref + %2 = arith.index_cast %arg0 : i32 to index + affine.for %arg7 = 0 to %2 { + affine.for %arg8 = 0 to %0 { + affine.store %cst, %alloca[] : memref + affine.for %arg9 = 0 to #map(%arg7) { + %13 = affine.load %arg6[%arg7, %arg8] : memref + %14 = arith.mulf %arg2, %13 : f64 + %15 = affine.load %arg5[%arg7, %arg9] : memref + %16 = arith.mulf %14, %15 : f64 + %17 = affine.load %arg4[%arg9, %arg8] : memref + %18 = arith.addf %17, %16 : f64 + affine.store %18, %arg4[%arg9, %arg8] : memref + %19 = affine.load %arg6[%arg9, %arg8] : memref + %20 = affine.load %arg5[%arg7, %arg9] : memref + %21 = arith.mulf %19, %20 : f64 + %22 = affine.load %alloca[] : memref + %23 = arith.addf %22, %21 : f64 + affine.store %23, %alloca[] : memref + } + %3 = affine.load %arg4[%arg7, %arg8] : memref + %4 = arith.mulf %arg3, %3 : f64 + %5 = affine.load %arg6[%arg7, %arg8] : memref + %6 = arith.mulf %arg2, %5 : f64 + %7 = affine.load %arg5[%arg7, %arg7] : memref + %8 = arith.mulf %6, %7 : f64 + %9 = arith.addf %4, %8 : f64 + %10 = affine.load %alloca[] : memref + %11 = arith.mulf %arg2, %10 : f64 + %12 = arith.addf %9, %11 : f64 + affine.store %12, %arg4[%arg7, %arg8] : memref + } + } + return + } +} diff --git a/polybench_results/symm_debuf.mlir b/polybench_results/symm_debuf.mlir new file mode 100644 index 000000000000..daf71bbb8c76 --- /dev/null +++ b/polybench_results/symm_debuf.mlir @@ -0,0 +1,63 @@ +#map = affine_map<(d0) -> ()> +#map1 = affine_map<(d0)[s0] -> (d0, s0)> +#map2 = affine_map<(d0)[s0] -> (s0, d0)> +#map3 = affine_map<(d0)[s0, s1] -> (s0, s1)> +#map4 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_symm(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: f64, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = arith.index_cast %arg1 : i32 to index + %4 = tensor.empty() : tensor + %5 = llvm.mlir.undef : f64 + %inserted = tensor.insert %5 into %4[] : tensor + %6 = arith.index_cast %arg0 : i32 to index + %7:2 = affine.for %arg7 = 0 to %6 iter_args(%arg8 = %inserted, %arg9 = %2) -> (tensor, tensor) { + %9:2 = affine.for %arg10 = 0 to %3 iter_args(%arg11 = %arg8, %arg12 = %arg9) -> (tensor, tensor) { + %inserted_0 = tensor.insert %cst into %arg11[] : tensor + %10 = arith.subi %6, %c1 : index + %11 = polygeist.submap(%inserted_0, %10) {map = #map} : (tensor, index) -> tensor + %12 = polygeist.submap(%arg12, %arg10, %10) {map = #map1} : (tensor, index, index) -> tensor + %13 = polygeist.submap(%1, %arg7, %10) {map = #map2} : (tensor, index, index) -> tensor + %14 = polygeist.submap(%1, %arg7, %10) {map = #map2} : (tensor, index, index) -> tensor + %15 = polygeist.submap(%0, %arg7, %arg10, %10) {map = #map3} : (tensor, index, index, index) -> tensor + %16 = polygeist.submap(%0, %arg10, %10) {map = #map1} : (tensor, index, index) -> tensor + %17:2 = linalg.generic {doc = "", indexing_maps = [#map4, #map4, #map4, #map4, #map4, #map4], iterator_types = ["reduction"], library_call = ""} ins(%15, %13, %16, %14 : tensor, tensor, tensor, tensor) outs(%12, %11 : tensor, tensor) { + ^bb0(%in: f64, %in_5: f64, %in_6: f64, %in_7: f64, %out: f64, %out_8: f64): + %26 = arith.mulf %arg2, %in : f64 + %27 = arith.mulf %26, %in_5 : f64 + %28 = arith.addf %out, %27 : f64 + %29 = arith.mulf %in_6, %in_7 : f64 + %30 = arith.addf %out_8, %29 : f64 + %31 = linalg.index 0 : index + %32 = arith.cmpi slt, %31, %arg7 : index + %33 = arith.select %32, %28, %out : f64 + %34 = arith.select %32, %30, %out_8 : f64 + linalg.yield %33, %34 : f64, f64 + } -> (tensor, tensor) + %18 = polygeist.submapInverse(%arg12, %17#0, %arg10, %10) {map = #map1} : (tensor, tensor, index, index) -> tensor + %19 = polygeist.submapInverse(%inserted_0, %17#1, %10) {map = #map} : (tensor, tensor, index) -> tensor + %extracted = tensor.extract %18[%arg7, %arg10] : tensor + %20 = arith.mulf %arg3, %extracted : f64 + %extracted_1 = tensor.extract %0[%arg7, %arg10] : tensor + %21 = arith.mulf %arg2, %extracted_1 : f64 + %extracted_2 = tensor.extract %1[%arg7, %arg7] : tensor + %22 = arith.mulf %21, %extracted_2 : f64 + %23 = arith.addf %20, %22 : f64 + %extracted_3 = tensor.extract %19[] : tensor + %24 = arith.mulf %arg2, %extracted_3 : f64 + %25 = arith.addf %23, %24 : f64 + %inserted_4 = tensor.insert %25 into %18[%arg7, %arg10] : tensor + affine.yield %19, %inserted_4 : tensor, tensor + } + affine.yield %9#0, %9#1 : tensor, tensor + } + %8 = bufferization.to_memref %7#1 : memref + memref.copy %8, %arg4 : memref to memref + return + } +} + diff --git a/polybench_results/symm_linalg.mlir b/polybench_results/symm_linalg.mlir new file mode 100644 index 000000000000..92a8a7a4bbeb --- /dev/null +++ b/polybench_results/symm_linalg.mlir @@ -0,0 +1,54 @@ +#map = affine_map<(d0)[s0, s1] -> (s0, s1)> +#map1 = affine_map<(d0)[s0] -> (s0, d0)> +#map2 = affine_map<(d0)[s0] -> (d0, s0)> +#map3 = affine_map<(d0) -> ()> +#map4 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_symm(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: f64, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %alloca = memref.alloca() : memref + %1 = llvm.mlir.undef : f64 + affine.store %1, %alloca[] : memref + %2 = arith.index_cast %arg0 : i32 to index + affine.for %arg7 = 0 to %2 { + affine.for %arg8 = 0 to %0 { + affine.store %cst, %alloca[] : memref + %3 = arith.subi %2, %c1 : index + %4 = polygeist.submap(%arg6, %arg7, %arg8, %3) {map = #map} : (memref, index, index, index) -> memref + %5 = polygeist.submap(%arg5, %arg7, %3) {map = #map1} : (memref, index, index) -> memref + %6 = polygeist.submap(%arg6, %arg8, %3) {map = #map2} : (memref, index, index) -> memref + %7 = polygeist.submap(%arg5, %arg7, %3) {map = #map1} : (memref, index, index) -> memref + %8 = polygeist.submap(%arg4, %arg8, %3) {map = #map2} : (memref, index, index) -> memref + %9 = polygeist.submap(%alloca, %3) {map = #map3} : (memref, index) -> memref + linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4, #map4, #map4], iterator_types = ["reduction"]} ins(%4, %5, %6, %7 : memref, memref, memref, memref) outs(%8, %9 : memref, memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64, %out_3: f64): + %20 = arith.mulf %arg2, %in : f64 + %21 = arith.mulf %20, %in_0 : f64 + %22 = arith.addf %out, %21 : f64 + %23 = arith.mulf %in_1, %in_2 : f64 + %24 = arith.addf %out_3, %23 : f64 + %25 = linalg.index 0 : index + %26 = arith.cmpi slt, %25, %arg7 : index + %27 = arith.select %26, %22, %out : f64 + %28 = arith.select %26, %24, %out_3 : f64 + linalg.yield %27, %28 : f64, f64 + } + %10 = affine.load %arg4[%arg7, %arg8] : memref + %11 = arith.mulf %arg3, %10 : f64 + %12 = affine.load %arg6[%arg7, %arg8] : memref + %13 = arith.mulf %arg2, %12 : f64 + %14 = affine.load %arg5[%arg7, %arg7] : memref + %15 = arith.mulf %13, %14 : f64 + %16 = arith.addf %11, %15 : f64 + %17 = affine.load %alloca[] : memref + %18 = arith.mulf %arg2, %17 : f64 + %19 = arith.addf %16, %18 : f64 + affine.store %19, %arg4[%arg7, %arg8] : memref + } + } + return + } +} + diff --git a/polybench_results/syr2k.log b/polybench_results/syr2k.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/syr2k.mlir b/polybench_results/syr2k.mlir new file mode 100644 index 000000000000..d13f4f71de44 --- /dev/null +++ b/polybench_results/syr2k.mlir @@ -0,0 +1,31 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_syr2k(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: f64, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg7 = 0 to %1 { + affine.for %arg8 = 0 to #map(%arg7) { + %2 = affine.load %arg4[%arg7, %arg8] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg7, %arg8] : memref + } + affine.for %arg8 = 0 to %0 { + affine.for %arg9 = 0 to #map(%arg7) { + %2 = affine.load %arg5[%arg9, %arg8] : memref + %3 = arith.mulf %2, %arg2 : f64 + %4 = affine.load %arg6[%arg7, %arg8] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg6[%arg9, %arg8] : memref + %7 = arith.mulf %6, %arg2 : f64 + %8 = affine.load %arg5[%arg7, %arg8] : memref + %9 = arith.mulf %7, %8 : f64 + %10 = arith.addf %5, %9 : f64 + %11 = affine.load %arg4[%arg7, %arg9] : memref + %12 = arith.addf %11, %10 : f64 + affine.store %12, %arg4[%arg7, %arg9] : memref + } + } + } + return + } +} diff --git a/polybench_results/syr2k_debuf.mlir b/polybench_results/syr2k_debuf.mlir new file mode 100644 index 000000000000..bc5698f90194 --- /dev/null +++ b/polybench_results/syr2k_debuf.mlir @@ -0,0 +1,66 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d2, d0)> +#map4 = affine_map<(d0, d1, d2) -> (d0, d1)> +#map5 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map6 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_syr2k(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: f64, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg6 : memref + %1 = bufferization.to_tensor %arg5 : memref + %2 = bufferization.to_tensor %arg4 : memref + %3 = arith.index_cast %arg1 : i32 to index + %4 = arith.index_cast %arg0 : i32 to index + %5 = arith.subi %4, %c1 : index + %6 = affine.apply #map(%5) + %7 = polygeist.submap(%2, %6, %4) {map = #map1} : (tensor, index, index) -> tensor + %8 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%7 : tensor) { + ^bb0(%out: f64): + %28 = linalg.index 0 : index + %29 = arith.mulf %out, %arg3 : f64 + %30 = linalg.index 1 : index + %31 = affine.apply #map(%28) + %32 = arith.cmpi slt, %30, %31 : index + %33 = arith.select %32, %29, %out : f64 + linalg.yield %33 : f64 + } -> tensor + %9 = polygeist.submapInverse(%2, %8, %6, %4) {map = #map1} : (tensor, tensor, index, index) -> tensor + %10 = arith.subi %4, %c1 : index + %11 = affine.apply #map(%10) + %12 = arith.subi %4, %c1 : index + %13 = affine.apply #map(%12) + %14 = arith.subi %4, %c1 : index + %15 = affine.apply #map(%14) + %16 = arith.subi %4, %c1 : index + %17 = affine.apply #map(%16) + %18 = arith.subi %4, %c1 : index + %19 = affine.apply #map(%18) + %20 = polygeist.submap(%9, %19, %3, %4) {map = #map3} : (tensor, index, index, index) -> tensor + %21 = polygeist.submap(%1, %11, %3, %4) {map = #map4} : (tensor, index, index, index) -> tensor + %22 = polygeist.submap(%1, %17, %3, %4) {map = #map5} : (tensor, index, index, index) -> tensor + %23 = polygeist.submap(%0, %13, %3, %4) {map = #map5} : (tensor, index, index, index) -> tensor + %24 = polygeist.submap(%0, %15, %3, %4) {map = #map4} : (tensor, index, index, index) -> tensor + %25 = linalg.generic {doc = "", indexing_maps = [#map6, #map6, #map6, #map6, #map6], iterator_types = ["parallel", "reduction", "parallel"], library_call = ""} ins(%21, %23, %24, %22 : tensor, tensor, tensor, tensor) outs(%20 : tensor) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %28 = linalg.index 0 : index + %29 = arith.mulf %in, %arg2 : f64 + %30 = arith.mulf %29, %in_0 : f64 + %31 = arith.mulf %in_1, %arg2 : f64 + %32 = arith.mulf %31, %in_2 : f64 + %33 = arith.addf %30, %32 : f64 + %34 = arith.addf %out, %33 : f64 + %35 = linalg.index 2 : index + %36 = affine.apply #map(%28) + %37 = arith.cmpi slt, %35, %36 : index + %38 = arith.select %37, %34, %out : f64 + linalg.yield %38 : f64 + } -> tensor + %26 = polygeist.submapInverse(%9, %25, %19, %3, %4) {map = #map3} : (tensor, tensor, index, index, index) -> tensor + %27 = bufferization.to_memref %26 : memref + memref.copy %27, %arg4 : memref to memref + return + } +} + diff --git a/polybench_results/syr2k_linalg.mlir b/polybench_results/syr2k_linalg.mlir new file mode 100644 index 000000000000..922ec3026f5d --- /dev/null +++ b/polybench_results/syr2k_linalg.mlir @@ -0,0 +1,59 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> +#map4 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map5 = affine_map<(d0, d1, d2) -> (d2, d0)> +#map6 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_syr2k(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: f64, %arg4: memref, %arg5: memref, %arg6: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + %2 = arith.subi %1, %c1 : index + %3 = affine.apply #map(%2) + %4 = polygeist.submap(%arg4, %3, %1) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel", "parallel"]} outs(%4 : memref) { + ^bb0(%out: f64): + %20 = linalg.index 0 : index + %21 = arith.mulf %out, %arg3 : f64 + %22 = linalg.index 1 : index + %23 = affine.apply #map(%20) + %24 = arith.cmpi slt, %22, %23 : index + %25 = arith.select %24, %21, %out : f64 + linalg.yield %25 : f64 + } + %5 = arith.subi %1, %c1 : index + %6 = affine.apply #map(%5) + %7 = polygeist.submap(%arg5, %6, %0, %1) {map = #map3} : (memref, index, index, index) -> memref + %8 = arith.subi %1, %c1 : index + %9 = affine.apply #map(%8) + %10 = polygeist.submap(%arg6, %9, %0, %1) {map = #map4} : (memref, index, index, index) -> memref + %11 = arith.subi %1, %c1 : index + %12 = affine.apply #map(%11) + %13 = polygeist.submap(%arg6, %12, %0, %1) {map = #map3} : (memref, index, index, index) -> memref + %14 = arith.subi %1, %c1 : index + %15 = affine.apply #map(%14) + %16 = polygeist.submap(%arg5, %15, %0, %1) {map = #map4} : (memref, index, index, index) -> memref + %17 = arith.subi %1, %c1 : index + %18 = affine.apply #map(%17) + %19 = polygeist.submap(%arg4, %18, %0, %1) {map = #map5} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map6, #map6, #map6, #map6], iterator_types = ["parallel", "reduction", "parallel"]} ins(%7, %10, %13, %16 : memref, memref, memref, memref) outs(%19 : memref) { + ^bb0(%in: f64, %in_0: f64, %in_1: f64, %in_2: f64, %out: f64): + %20 = linalg.index 0 : index + %21 = arith.mulf %in, %arg2 : f64 + %22 = arith.mulf %21, %in_0 : f64 + %23 = arith.mulf %in_1, %arg2 : f64 + %24 = arith.mulf %23, %in_2 : f64 + %25 = arith.addf %22, %24 : f64 + %26 = arith.addf %out, %25 : f64 + %27 = linalg.index 2 : index + %28 = affine.apply #map(%20) + %29 = arith.cmpi slt, %27, %28 : index + %30 = arith.select %29, %26, %out : f64 + linalg.yield %30 : f64 + } + return + } +} + diff --git a/polybench_results/syrk.log b/polybench_results/syrk.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/syrk.mlir b/polybench_results/syrk.mlir new file mode 100644 index 000000000000..bccf4bb4847b --- /dev/null +++ b/polybench_results/syrk.mlir @@ -0,0 +1,26 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_syrk(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: f64, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg6 = 0 to %1 { + affine.for %arg7 = 0 to #map(%arg6) { + %2 = affine.load %arg4[%arg6, %arg7] : memref + %3 = arith.mulf %2, %arg3 : f64 + affine.store %3, %arg4[%arg6, %arg7] : memref + } + affine.for %arg7 = 0 to %0 { + affine.for %arg8 = 0 to #map(%arg6) { + %2 = affine.load %arg5[%arg6, %arg7] : memref + %3 = arith.mulf %arg2, %2 : f64 + %4 = affine.load %arg5[%arg8, %arg7] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = affine.load %arg4[%arg6, %arg8] : memref + %7 = arith.addf %6, %5 : f64 + affine.store %7, %arg4[%arg6, %arg8] : memref + } + } + } + return + } +} diff --git a/polybench_results/syrk_debuf.mlir b/polybench_results/syrk_debuf.mlir new file mode 100644 index 000000000000..f37bdbf570ff --- /dev/null +++ b/polybench_results/syrk_debuf.mlir @@ -0,0 +1,56 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d2, d0)> +#map4 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map5 = affine_map<(d0, d1, d2) -> (d0, d1)> +#map6 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_syrk(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: f64, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg5 : memref + %1 = bufferization.to_tensor %arg4 : memref + %2 = arith.index_cast %arg1 : i32 to index + %3 = arith.index_cast %arg0 : i32 to index + %4 = arith.subi %3, %c1 : index + %5 = affine.apply #map(%4) + %6 = polygeist.submap(%1, %5, %3) {map = #map1} : (tensor, index, index) -> tensor + %7 = linalg.generic {doc = "", indexing_maps = [#map2], iterator_types = ["parallel", "parallel"], library_call = ""} outs(%6 : tensor) { + ^bb0(%out: f64): + %21 = linalg.index 0 : index + %22 = arith.mulf %out, %arg3 : f64 + %23 = linalg.index 1 : index + %24 = affine.apply #map(%21) + %25 = arith.cmpi slt, %23, %24 : index + %26 = arith.select %25, %22, %out : f64 + linalg.yield %26 : f64 + } -> tensor + %8 = polygeist.submapInverse(%1, %7, %5, %3) {map = #map1} : (tensor, tensor, index, index) -> tensor + %9 = arith.subi %3, %c1 : index + %10 = affine.apply #map(%9) + %11 = arith.subi %3, %c1 : index + %12 = affine.apply #map(%11) + %13 = arith.subi %3, %c1 : index + %14 = affine.apply #map(%13) + %15 = polygeist.submap(%8, %14, %2, %3) {map = #map3} : (tensor, index, index, index) -> tensor + %16 = polygeist.submap(%0, %10, %2, %3) {map = #map4} : (tensor, index, index, index) -> tensor + %17 = polygeist.submap(%0, %12, %2, %3) {map = #map5} : (tensor, index, index, index) -> tensor + %18 = linalg.generic {doc = "", indexing_maps = [#map6, #map6, #map6], iterator_types = ["parallel", "reduction", "parallel"], library_call = ""} ins(%16, %17 : tensor, tensor) outs(%15 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %21 = linalg.index 0 : index + %22 = arith.mulf %arg2, %in : f64 + %23 = arith.mulf %22, %in_0 : f64 + %24 = arith.addf %out, %23 : f64 + %25 = linalg.index 2 : index + %26 = affine.apply #map(%21) + %27 = arith.cmpi slt, %25, %26 : index + %28 = arith.select %27, %24, %out : f64 + linalg.yield %28 : f64 + } -> tensor + %19 = polygeist.submapInverse(%8, %18, %14, %2, %3) {map = #map3} : (tensor, tensor, index, index, index) -> tensor + %20 = bufferization.to_memref %19 : memref + memref.copy %20, %arg4 : memref to memref + return + } +} + diff --git a/polybench_results/syrk_linalg.mlir b/polybench_results/syrk_linalg.mlir new file mode 100644 index 000000000000..3c8217ac6d1d --- /dev/null +++ b/polybench_results/syrk_linalg.mlir @@ -0,0 +1,50 @@ +#map = affine_map<(d0) -> (d0 + 1)> +#map1 = affine_map<(d0, d1) -> (d1, d0)> +#map2 = affine_map<(d0, d1) -> (d0, d1)> +#map3 = affine_map<(d0, d1, d2) -> (d2, d1)> +#map4 = affine_map<(d0, d1, d2) -> (d0, d1)> +#map5 = affine_map<(d0, d1, d2) -> (d2, d0)> +#map6 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_syrk(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: f64, %arg4: memref, %arg5: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + %2 = arith.subi %1, %c1 : index + %3 = affine.apply #map(%2) + %4 = polygeist.submap(%arg4, %3, %1) {map = #map1} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map2], iterator_types = ["parallel", "parallel"]} outs(%4 : memref) { + ^bb0(%out: f64): + %14 = linalg.index 0 : index + %15 = arith.mulf %out, %arg3 : f64 + %16 = linalg.index 1 : index + %17 = affine.apply #map(%14) + %18 = arith.cmpi slt, %16, %17 : index + %19 = arith.select %18, %15, %out : f64 + linalg.yield %19 : f64 + } + %5 = arith.subi %1, %c1 : index + %6 = affine.apply #map(%5) + %7 = polygeist.submap(%arg5, %6, %0, %1) {map = #map3} : (memref, index, index, index) -> memref + %8 = arith.subi %1, %c1 : index + %9 = affine.apply #map(%8) + %10 = polygeist.submap(%arg5, %9, %0, %1) {map = #map4} : (memref, index, index, index) -> memref + %11 = arith.subi %1, %c1 : index + %12 = affine.apply #map(%11) + %13 = polygeist.submap(%arg4, %12, %0, %1) {map = #map5} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map6, #map6, #map6], iterator_types = ["parallel", "reduction", "parallel"]} ins(%7, %10 : memref, memref) outs(%13 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = linalg.index 0 : index + %15 = arith.mulf %arg2, %in : f64 + %16 = arith.mulf %15, %in_0 : f64 + %17 = arith.addf %out, %16 : f64 + %18 = linalg.index 2 : index + %19 = affine.apply #map(%14) + %20 = arith.cmpi slt, %18, %19 : index + %21 = arith.select %20, %17, %out : f64 + linalg.yield %21 : f64 + } + return + } +} + diff --git a/polybench_results/trisolv.log b/polybench_results/trisolv.log new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/polybench_results/trisolv.mlir b/polybench_results/trisolv.mlir new file mode 100644 index 000000000000..60b751b7744b --- /dev/null +++ b/polybench_results/trisolv.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_trisolv(%arg0: i32, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg4 = 0 to %0 { + %1 = affine.load %arg3[%arg4] : memref + affine.store %1, %arg2[%arg4] : memref + affine.for %arg5 = 0 to #map(%arg4) { + %5 = affine.load %arg1[%arg4, %arg5] : memref + %6 = affine.load %arg2[%arg5] : memref + %7 = arith.mulf %5, %6 : f64 + %8 = affine.load %arg2[%arg4] : memref + %9 = arith.subf %8, %7 : f64 + affine.store %9, %arg2[%arg4] : memref + } + %2 = affine.load %arg2[%arg4] : memref + %3 = affine.load %arg1[%arg4, %arg4] : memref + %4 = arith.divf %2, %3 : f64 + affine.store %4, %arg2[%arg4] : memref + } + return + } +} diff --git a/polybench_results/trisolv_debuf.mlir b/polybench_results/trisolv_debuf.mlir new file mode 100644 index 000000000000..56e28283deba --- /dev/null +++ b/polybench_results/trisolv_debuf.mlir @@ -0,0 +1,39 @@ +#map = affine_map<(d0)[s0] -> (s0, d0)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0)[s0] -> (s0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_trisolv(%arg0: i32, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %0 = bufferization.to_tensor %arg3 : memref + %1 = bufferization.to_tensor %arg2 : memref + %2 = bufferization.to_tensor %arg1 : memref + %3 = arith.index_cast %arg0 : i32 to index + %4 = affine.for %arg4 = 0 to %3 iter_args(%arg5 = %1) -> (tensor) { + %extracted = tensor.extract %0[%arg4] : tensor + %inserted = tensor.insert %extracted into %arg5[%arg4] : tensor + %6 = arith.subi %3, %c1 : index + %7 = polygeist.submap(%2, %arg4, %6) {map = #map} : (tensor, index, index) -> tensor + %8 = polygeist.submap(%inserted, %6) {map = #map1} : (tensor, index) -> tensor + %9 = polygeist.submap(%inserted, %arg4, %6) {map = #map2} : (tensor, index, index) -> tensor + %10 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["reduction"], library_call = ""} ins(%7, %8 : tensor, tensor) outs(%9 : tensor) { + ^bb0(%in: f64, %in_3: f64, %out: f64): + %13 = arith.mulf %in, %in_3 : f64 + %14 = arith.subf %out, %13 : f64 + %15 = linalg.index 0 : index + %16 = arith.cmpi slt, %15, %arg4 : index + %17 = arith.select %16, %14, %out : f64 + linalg.yield %17 : f64 + } -> tensor + %11 = polygeist.submapInverse(%inserted, %10, %arg4, %6) {map = #map2} : (tensor, tensor, index, index) -> tensor + %extracted_0 = tensor.extract %11[%arg4] : tensor + %extracted_1 = tensor.extract %2[%arg4, %arg4] : tensor + %12 = arith.divf %extracted_0, %extracted_1 : f64 + %inserted_2 = tensor.insert %12 into %11[%arg4] : tensor + affine.yield %inserted_2 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg2 : memref to memref + return + } +} + diff --git a/polybench_results/trisolv_linalg.mlir b/polybench_results/trisolv_linalg.mlir new file mode 100644 index 000000000000..82a849df5eff --- /dev/null +++ b/polybench_results/trisolv_linalg.mlir @@ -0,0 +1,32 @@ +#map = affine_map<(d0)[s0] -> (s0, d0)> +#map1 = affine_map<(d0) -> (d0)> +#map2 = affine_map<(d0)[s0] -> (s0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_trisolv(%arg0: i32, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1 = arith.constant 1 : index + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg4 = 0 to %0 { + %1 = affine.load %arg3[%arg4] : memref + affine.store %1, %arg2[%arg4] : memref + %2 = arith.subi %0, %c1 : index + %3 = polygeist.submap(%arg1, %arg4, %2) {map = #map} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg2, %2) {map = #map1} : (memref, index) -> memref + %5 = polygeist.submap(%arg2, %arg4, %2) {map = #map2} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %9 = arith.mulf %in, %in_0 : f64 + %10 = arith.subf %out, %9 : f64 + %11 = linalg.index 0 : index + %12 = arith.cmpi slt, %11, %arg4 : index + %13 = arith.select %12, %10, %out : f64 + linalg.yield %13 : f64 + } + %6 = affine.load %arg2[%arg4] : memref + %7 = affine.load %arg1[%arg4, %arg4] : memref + %8 = arith.divf %6, %7 : f64 + affine.store %8, %arg2[%arg4] : memref + } + return + } +} + diff --git a/polybench_results/trmm.log b/polybench_results/trmm.log new file mode 100644 index 000000000000..9591a64e9d0f --- /dev/null +++ b/polybench_results/trmm.log @@ -0,0 +1,30 @@ +/home/arjaiswal/Polygeist/polybench_results/trmm.mlir:3:3: warning: Distribute+Raising didn't converge, continuing anyway + func.func @kernel_trmm(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + ^ +/home/arjaiswal/Polygeist/polybench_results/trmm.mlir:3:3: note: see current operation: +func.func @kernel_trmm(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg5 = 0 to %1 { + %2 = polygeist.submap(%arg3, %arg5, %1, %0) {map = affine_map<(d0, d1)[s0] -> (d0, s0)>} : (memref, index, index, index) -> memref + %3 = polygeist.submap(%arg4, %1, %0) {map = affine_map<(d0, d1) -> (d0, d1)>} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %arg5, %1, %0) {map = affine_map<(d0, d1)[s0] -> (s0, d1)>} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>], iterator_types = ["parallel", "reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %6 = arith.mulf %in, %in_0 : f64 + %7 = arith.addf %out, %6 : f64 + %8 = linalg.index 1 : index + %9 = affine.apply affine_map<(d0) -> (d0 + 1)>(%arg5) + %10 = arith.cmpi sge, %8, %9 : index + %11 = arith.select %10, %7, %out : f64 + linalg.yield %11 : f64 + } + %5 = polygeist.submap(%arg4, %arg5, %0) {map = affine_map<(d0)[s0] -> (s0, d0)>} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>], iterator_types = ["parallel"]} outs(%5 : memref) { + ^bb0(%out: f64): + %6 = arith.mulf %arg2, %out : f64 + linalg.yield %6 : f64 + } + } + return +} diff --git a/polybench_results/trmm.mlir b/polybench_results/trmm.mlir new file mode 100644 index 000000000000..ceaa2d2adb25 --- /dev/null +++ b/polybench_results/trmm.mlir @@ -0,0 +1,23 @@ +#map = affine_map<(d0) -> (d0 + 1)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_trmm(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg5 = 0 to %1 { + affine.for %arg6 = 0 to %0 { + affine.for %arg7 = #map(%arg5) to %1 { + %4 = affine.load %arg3[%arg7, %arg5] : memref + %5 = affine.load %arg4[%arg7, %arg6] : memref + %6 = arith.mulf %4, %5 : f64 + %7 = affine.load %arg4[%arg5, %arg6] : memref + %8 = arith.addf %7, %6 : f64 + affine.store %8, %arg4[%arg5, %arg6] : memref + } + %2 = affine.load %arg4[%arg5, %arg6] : memref + %3 = arith.mulf %arg2, %2 : f64 + affine.store %3, %arg4[%arg5, %arg6] : memref + } + } + return + } +} diff --git a/polybench_results/trmm_debuf.mlir b/polybench_results/trmm_debuf.mlir new file mode 100644 index 000000000000..8532ce0c3ec3 --- /dev/null +++ b/polybench_results/trmm_debuf.mlir @@ -0,0 +1,42 @@ +#map = affine_map<(d0, d1)[s0] -> (d0, s0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (s0, d1)> +#map3 = affine_map<(d0) -> (d0 + 1)> +#map4 = affine_map<(d0)[s0] -> (s0, d0)> +#map5 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_trmm(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = bufferization.to_tensor %arg4 : memref + %1 = bufferization.to_tensor %arg3 : memref + %2 = arith.index_cast %arg1 : i32 to index + %3 = arith.index_cast %arg0 : i32 to index + %4 = affine.for %arg5 = 0 to %3 iter_args(%arg6 = %0) -> (tensor) { + %6 = polygeist.submap(%1, %arg5, %3, %2) {map = #map} : (tensor, index, index, index) -> tensor + %7 = polygeist.submap(%arg6, %3, %2) {map = #map1} : (tensor, index, index) -> tensor + %8 = polygeist.submap(%arg6, %arg5, %3, %2) {map = #map2} : (tensor, index, index, index) -> tensor + %9 = linalg.generic {doc = "", indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "reduction"], library_call = ""} ins(%6, %7 : tensor, tensor) outs(%8 : tensor) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %14 = arith.mulf %in, %in_0 : f64 + %15 = arith.addf %out, %14 : f64 + %16 = linalg.index 1 : index + %17 = affine.apply #map3(%arg5) + %18 = arith.cmpi sge, %16, %17 : index + %19 = arith.select %18, %15, %out : f64 + linalg.yield %19 : f64 + } -> tensor + %10 = polygeist.submapInverse(%arg6, %9, %arg5, %3, %2) {map = #map2} : (tensor, tensor, index, index, index) -> tensor + %11 = polygeist.submap(%10, %arg5, %2) {map = #map4} : (tensor, index, index) -> tensor + %12 = linalg.generic {doc = "", indexing_maps = [#map5], iterator_types = ["parallel"], library_call = ""} outs(%11 : tensor) { + ^bb0(%out: f64): + %14 = arith.mulf %arg2, %out : f64 + linalg.yield %14 : f64 + } -> tensor + %13 = polygeist.submapInverse(%10, %12, %arg5, %2) {map = #map4} : (tensor, tensor, index, index) -> tensor + affine.yield %13 : tensor + } + %5 = bufferization.to_memref %4 : memref + memref.copy %5, %arg4 : memref to memref + return + } +} + diff --git a/polybench_results/trmm_linalg.mlir b/polybench_results/trmm_linalg.mlir new file mode 100644 index 000000000000..4eadebc5a03d --- /dev/null +++ b/polybench_results/trmm_linalg.mlir @@ -0,0 +1,35 @@ +#map = affine_map<(d0, d1)[s0] -> (d0, s0)> +#map1 = affine_map<(d0, d1) -> (d0, d1)> +#map2 = affine_map<(d0, d1)[s0] -> (s0, d1)> +#map3 = affine_map<(d0) -> (d0 + 1)> +#map4 = affine_map<(d0)[s0] -> (s0, d0)> +#map5 = affine_map<(d0) -> (d0)> +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @kernel_trmm(%arg0: i32, %arg1: i32, %arg2: f64, %arg3: memref, %arg4: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg5 = 0 to %1 { + %2 = polygeist.submap(%arg3, %arg5, %1, %0) {map = #map} : (memref, index, index, index) -> memref + %3 = polygeist.submap(%arg4, %1, %0) {map = #map1} : (memref, index, index) -> memref + %4 = polygeist.submap(%arg4, %arg5, %1, %0) {map = #map2} : (memref, index, index, index) -> memref + linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "reduction"]} ins(%2, %3 : memref, memref) outs(%4 : memref) { + ^bb0(%in: f64, %in_0: f64, %out: f64): + %6 = arith.mulf %in, %in_0 : f64 + %7 = arith.addf %out, %6 : f64 + %8 = linalg.index 1 : index + %9 = affine.apply #map3(%arg5) + %10 = arith.cmpi sge, %8, %9 : index + %11 = arith.select %10, %7, %out : f64 + linalg.yield %11 : f64 + } + %5 = polygeist.submap(%arg4, %arg5, %0) {map = #map4} : (memref, index, index) -> memref + linalg.generic {indexing_maps = [#map5], iterator_types = ["parallel"]} outs(%5 : memref) { + ^bb0(%out: f64): + %6 = arith.mulf %arg2, %out : f64 + linalg.yield %6 : f64 + } + } + return + } +} + diff --git a/reduction_survey/after_remove_iter_args/r01_direct_return.err b/reduction_survey/after_remove_iter_args/r01_direct_return.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r01_direct_return.mlir b/reduction_survey/after_remove_iter_args/r01_direct_return.mlir new file mode 100644 index 000000000000..8b0710487fb2 --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r01_direct_return.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @ddot(%arg0: i32, %arg1: memref, %arg2: memref) -> f64 attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + affine.for %arg3 = 0 to %0 { + %2 = affine.load %alloca[] : memref + %3 = affine.load %arg1[%arg3] : memref + %4 = affine.load %arg2[%arg3] : memref + %5 = arith.mulf %3, %4 : f64 + %6 = arith.addf %2, %5 : f64 + affine.store %6, %alloca[] : memref + } + %1 = affine.load %alloca[] : memref + return %1 : f64 + } +} + diff --git a/reduction_survey/after_remove_iter_args/r02_pure_op_return.err b/reduction_survey/after_remove_iter_args/r02_pure_op_return.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r02_pure_op_return.mlir b/reduction_survey/after_remove_iter_args/r02_pure_op_return.mlir new file mode 100644 index 000000000000..9679c94142a7 --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r02_pure_op_return.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @dnrm2(%arg0: i32, %arg1: memref) -> f64 attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + affine.for %arg2 = 0 to %0 { + %3 = affine.load %alloca[] : memref + %4 = affine.load %arg1[%arg2] : memref + %5 = arith.mulf %4, %4 : f64 + %6 = arith.addf %3, %5 : f64 + affine.store %6, %alloca[] : memref + } + %1 = affine.load %alloca[] : memref + %2 = math.sqrt %1 : f64 + return %2 : f64 + } +} + diff --git a/reduction_survey/after_remove_iter_args/r03_store_scalar.err b/reduction_survey/after_remove_iter_args/r03_store_scalar.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r03_store_scalar.mlir b/reduction_survey/after_remove_iter_args/r03_store_scalar.mlir new file mode 100644 index 000000000000..5d31c243db8e --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r03_store_scalar.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @asum_out(%arg0: i32, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg0 : i32 to index + affine.for %arg3 = 0 to %0 { + %1 = affine.load %arg2[0] : memref + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.addf %1, %2 : f64 + affine.store %3, %arg2[0] : memref + } + return + } +} + diff --git a/reduction_survey/after_remove_iter_args/r04_store_indexed.err b/reduction_survey/after_remove_iter_args/r04_store_indexed.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r04_store_indexed.mlir b/reduction_survey/after_remove_iter_args/r04_store_indexed.mlir new file mode 100644 index 000000000000..73f2026bc052 --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r04_store_indexed.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @rowsum(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg4 = 0 to %1 { + affine.for %arg5 = 0 to %0 { + %2 = affine.load %arg3[%arg4] : memref + %3 = affine.load %arg2[%arg5 + %arg4 * symbol(%0)] : memref + %4 = arith.addf %2, %3 : f64 + affine.store %4, %arg3[%arg4] : memref + } + } + return + } +} + diff --git a/reduction_survey/after_remove_iter_args/r05_arith_then_return.err b/reduction_survey/after_remove_iter_args/r05_arith_then_return.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r05_arith_then_return.mlir b/reduction_survey/after_remove_iter_args/r05_arith_then_return.mlir new file mode 100644 index 000000000000..fbedbccda9b9 --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r05_arith_then_return.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mean(%arg0: i32, %arg1: memref) -> f64 attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + affine.for %arg2 = 0 to %0 { + %4 = affine.load %alloca[] : memref + %5 = affine.load %arg1[%arg2] : memref + %6 = arith.addf %4, %5 : f64 + affine.store %6, %alloca[] : memref + } + %1 = affine.load %alloca[] : memref + %2 = arith.sitofp %arg0 : i32 to f64 + %3 = arith.divf %1, %2 : f64 + return %3 : f64 + } +} + diff --git a/reduction_survey/after_remove_iter_args/r06_call_use.err b/reduction_survey/after_remove_iter_args/r06_call_use.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r06_call_use.mlir b/reduction_survey/after_remove_iter_args/r06_call_use.mlir new file mode 100644 index 000000000000..53bbbc9f0da2 --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r06_call_use.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @log_sum(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + affine.for %arg2 = 0 to %0 { + %2 = affine.load %alloca[] : memref + %3 = affine.load %arg1[%arg2] : memref + %4 = arith.addf %2, %3 : f64 + affine.store %4, %alloca[] : memref + } + %1 = affine.load %alloca[] : memref + call @sink(%1) : (f64) -> () + return + } + func.func private @sink(f64) attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/reduction_survey/after_remove_iter_args/r07_two_uses.err b/reduction_survey/after_remove_iter_args/r07_two_uses.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r07_two_uses.mlir b/reduction_survey/after_remove_iter_args/r07_two_uses.mlir new file mode 100644 index 000000000000..a4ed327ec793 --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r07_two_uses.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @sum_and_sumsq_diff(%arg0: i32, %arg1: memref) -> f64 attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + affine.for %arg2 = 0 to %0 { + %4 = affine.load %alloca[] : memref + %5 = affine.load %arg1[%arg2] : memref + %6 = arith.addf %4, %5 : f64 + affine.store %6, %alloca[] : memref + } + %1 = affine.load %alloca[] : memref + %2 = arith.mulf %1, %1 : f64 + %3 = arith.addf %1, %2 : f64 + return %3 : f64 + } +} + diff --git a/reduction_survey/after_remove_iter_args/r08_two_reductions.err b/reduction_survey/after_remove_iter_args/r08_two_reductions.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r08_two_reductions.mlir b/reduction_survey/after_remove_iter_args/r08_two_reductions.mlir new file mode 100644 index 000000000000..ad553d7b0466 --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r08_two_reductions.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mean_sumsq(%arg0: i32, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %cst, %alloca_0[] : memref + affine.for %arg4 = 0 to %0 { + %3 = affine.load %alloca[] : memref + %4 = affine.load %alloca_0[] : memref + %5 = affine.load %arg1[%arg4] : memref + %6 = arith.addf %4, %5 : f64 + %7 = arith.mulf %5, %5 : f64 + %8 = arith.addf %3, %7 : f64 + affine.store %8, %alloca[] : memref + affine.store %6, %alloca_0[] : memref + } + %1 = affine.load %alloca[] : memref + %2 = affine.load %alloca_0[] : memref + affine.store %2, %arg2[0] : memref + affine.store %1, %arg3[0] : memref + return + } +} + diff --git a/reduction_survey/after_remove_iter_args/r09_max.err b/reduction_survey/after_remove_iter_args/r09_max.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r09_max.mlir b/reduction_survey/after_remove_iter_args/r09_max.mlir new file mode 100644 index 000000000000..2b5125cf840d --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r09_max.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @maxabs(%arg0: i32, %arg1: memref) -> f64 attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + affine.for %arg2 = 0 to %0 { + %2 = affine.load %alloca[] : memref + %3 = affine.load %arg1[%arg2] : memref + %4 = arith.cmpf olt, %3, %cst : f64 + %5 = scf.if %4 -> (f64) { + %8 = arith.negf %3 : f64 + scf.yield %8 : f64 + } else { + scf.yield %3 : f64 + } + %6 = arith.cmpf ogt, %5, %2 : f64 + %7 = arith.select %6, %5, %2 : f64 + affine.store %7, %alloca[] : memref + } + %1 = affine.load %alloca[] : memref + return %1 : f64 + } +} + diff --git a/reduction_survey/after_remove_iter_args/r10_argmax.err b/reduction_survey/after_remove_iter_args/r10_argmax.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r10_argmax.mlir b/reduction_survey/after_remove_iter_args/r10_argmax.mlir new file mode 100644 index 000000000000..c26aa24c95e2 --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r10_argmax.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @idamax(%arg0: i32, %arg1: memref) -> i32 attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = affine.load %arg1[0] : memref + %1 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %0, %alloca_0[] : memref + affine.for %arg2 = 1 to %1 { + %3 = affine.load %alloca[] : memref + %4 = affine.load %alloca_0[] : memref + %5 = arith.index_cast %arg2 : index to i32 + %6 = affine.load %arg1[%arg2] : memref + %7 = arith.cmpf ogt, %6, %4 : f64 + %8 = arith.select %7, %5, %3 : i32 + %9 = arith.select %7, %6, %4 : f64 + affine.store %8, %alloca[] : memref + affine.store %9, %alloca_0[] : memref + } + %2 = affine.load %alloca[] : memref + return %2 : i32 + } +} + diff --git a/reduction_survey/after_remove_iter_args/r11_product.err b/reduction_survey/after_remove_iter_args/r11_product.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r11_product.mlir b/reduction_survey/after_remove_iter_args/r11_product.mlir new file mode 100644 index 000000000000..51857b5227a9 --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r11_product.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @prod(%arg0: i32, %arg1: memref) -> f64 attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + affine.for %arg2 = 0 to %0 { + %2 = affine.load %alloca[] : memref + %3 = affine.load %arg1[%arg2] : memref + %4 = arith.mulf %2, %3 : f64 + affine.store %4, %alloca[] : memref + } + %1 = affine.load %alloca[] : memref + return %1 : f64 + } +} + diff --git a/reduction_survey/after_remove_iter_args/r12_int_count.err b/reduction_survey/after_remove_iter_args/r12_int_count.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r12_int_count.mlir b/reduction_survey/after_remove_iter_args/r12_int_count.mlir new file mode 100644 index 000000000000..d32f9312367e --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r12_int_count.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @count_positive(%arg0: i32, %arg1: memref) -> i32 attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f64 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg2 = 0 to %0 { + %2 = affine.load %alloca[] : memref + %3 = affine.load %arg1[%arg2] : memref + %4 = arith.cmpf ogt, %3, %cst : f64 + %5 = scf.if %4 -> (i32) { + %6 = arith.addi %2, %c1_i32 : i32 + scf.yield %6 : i32 + } else { + scf.yield %2 : i32 + } + affine.store %5, %alloca[] : memref + } + %1 = affine.load %alloca[] : memref + return %1 : i32 + } +} + diff --git a/reduction_survey/after_remove_iter_args/r13_sum_then_loop.err b/reduction_survey/after_remove_iter_args/r13_sum_then_loop.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r13_sum_then_loop.mlir b/reduction_survey/after_remove_iter_args/r13_sum_then_loop.mlir new file mode 100644 index 000000000000..b0c44c502946 --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r13_sum_then_loop.mlir @@ -0,0 +1,22 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @normalize(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + affine.for %arg2 = 0 to %0 { + %2 = affine.load %alloca[] : memref + %3 = affine.load %arg1[%arg2] : memref + %4 = arith.addf %2, %3 : f64 + affine.store %4, %alloca[] : memref + } + %1 = affine.load %alloca[] : memref + affine.for %arg2 = 0 to %0 { + %2 = affine.load %arg1[%arg2] : memref + %3 = arith.divf %2, %1 : f64 + affine.store %3, %arg1[%arg2] : memref + } + return + } +} + diff --git a/reduction_survey/after_remove_iter_args/r14_used_as_bound.err b/reduction_survey/after_remove_iter_args/r14_used_as_bound.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r14_used_as_bound.mlir b/reduction_survey/after_remove_iter_args/r14_used_as_bound.mlir new file mode 100644 index 000000000000..28943a3c3460 --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r14_used_as_bound.mlir @@ -0,0 +1,31 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @hist(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f64 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + affine.store %c0_i32, %alloca[] : memref + affine.for %arg2 = 0 to %0 { + %3 = affine.load %alloca[] : memref + %4 = affine.load %arg1[%arg2] : memref + %5 = arith.cmpf ogt, %4, %cst : f64 + %6 = scf.if %5 -> (i32) { + %7 = arith.addi %3, %c1_i32 : i32 + scf.yield %7 : i32 + } else { + scf.yield %3 : i32 + } + affine.store %6, %alloca[] : memref + } + %1 = affine.load %alloca[] : memref + %2 = arith.index_cast %1 : i32 to index + affine.for %arg2 = 0 to %2 { + %3 = arith.index_cast %arg2 : index to i32 + func.call @use_int(%3) : (i32) -> () + } + return + } + func.func private @use_int(i32) attributes {llvm.linkage = #llvm.linkage} +} + diff --git a/reduction_survey/after_remove_iter_args/r15_nested.err b/reduction_survey/after_remove_iter_args/r15_nested.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r15_nested.mlir b/reduction_survey/after_remove_iter_args/r15_nested.mlir new file mode 100644 index 000000000000..98e98274d552 --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r15_nested.mlir @@ -0,0 +1,27 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @dist(%arg0: i32, %arg1: i32, %arg2: memref) -> f64 attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + affine.for %arg3 = 0 to %1 { + %3 = affine.load %alloca[] : memref + %alloca_0 = memref.alloca() : memref + affine.store %cst, %alloca_0[] : memref + affine.for %arg4 = 0 to %0 { + %7 = affine.load %alloca_0[] : memref + %8 = affine.load %arg2[%arg4 + %arg3 * symbol(%0)] : memref + %9 = arith.addf %7, %8 : f64 + affine.store %9, %alloca_0[] : memref + } + %4 = affine.load %alloca_0[] : memref + %5 = arith.mulf %4, %4 : f64 + %6 = arith.addf %3, %5 : f64 + affine.store %6, %alloca[] : memref + } + %2 = affine.load %alloca[] : memref + return %2 : f64 + } +} + diff --git a/reduction_survey/after_remove_iter_args/r16_unused.err b/reduction_survey/after_remove_iter_args/r16_unused.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r16_unused.mlir b/reduction_survey/after_remove_iter_args/r16_unused.mlir new file mode 100644 index 000000000000..378df9828709 --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r16_unused.mlir @@ -0,0 +1,6 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @dead_sum(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + return + } +} + diff --git a/reduction_survey/after_remove_iter_args/r17_two_stores.err b/reduction_survey/after_remove_iter_args/r17_two_stores.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r17_two_stores.mlir b/reduction_survey/after_remove_iter_args/r17_two_stores.mlir new file mode 100644 index 000000000000..cfc6bec972c0 --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r17_two_stores.mlir @@ -0,0 +1,19 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @duplicate_sum(%arg0: i32, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + affine.for %arg4 = 0 to %0 { + %2 = affine.load %alloca[] : memref + %3 = affine.load %arg1[%arg4] : memref + %4 = arith.addf %2, %3 : f64 + affine.store %4, %alloca[] : memref + } + %1 = affine.load %alloca[] : memref + affine.store %1, %arg2[0] : memref + affine.store %1, %arg3[0] : memref + return + } +} + diff --git a/reduction_survey/after_remove_iter_args/r18_cond_then_return.err b/reduction_survey/after_remove_iter_args/r18_cond_then_return.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/after_remove_iter_args/r18_cond_then_return.mlir b/reduction_survey/after_remove_iter_args/r18_cond_then_return.mlir new file mode 100644 index 000000000000..12140f81d1d5 --- /dev/null +++ b/reduction_survey/after_remove_iter_args/r18_cond_then_return.mlir @@ -0,0 +1,25 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @any_negative(%arg0: i32, %arg1: memref) -> i32 attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f64 + %0 = llvm.mlir.undef : i32 + %1 = arith.index_cast %arg0 : i32 to index + %alloca = memref.alloca() : memref + affine.store %cst, %alloca[] : memref + affine.for %arg2 = 0 to %1 { + %7 = affine.load %alloca[] : memref + %8 = affine.load %arg1[%arg2] : memref + %9 = arith.addf %7, %8 : f64 + affine.store %9, %alloca[] : memref + } + %2 = affine.load %alloca[] : memref + %3 = arith.cmpf olt, %2, %cst : f64 + %4 = arith.xori %3, %true : i1 + %5 = arith.select %3, %c1_i32, %0 : i32 + %6 = arith.select %4, %c0_i32, %5 : i32 + return %6 : i32 + } +} + diff --git a/reduction_survey/r01_direct_return.c b/reduction_survey/r01_direct_return.c new file mode 100644 index 000000000000..bcb170625fd2 --- /dev/null +++ b/reduction_survey/r01_direct_return.c @@ -0,0 +1,6 @@ +// Loop result returned directly. +double ddot(int n, double *x, double *y) { + double s = 0; + for (int i = 0; i < n; i++) s += x[i] * y[i]; + return s; +} diff --git a/reduction_survey/r01_direct_return.err b/reduction_survey/r01_direct_return.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r01_direct_return.mlir b/reduction_survey/r01_direct_return.mlir new file mode 100644 index 000000000000..3c079625fbf8 --- /dev/null +++ b/reduction_survey/r01_direct_return.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @ddot(%arg0: i32, %arg1: memref, %arg2: memref) -> f64 attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %1 = affine.for %arg3 = 0 to %0 iter_args(%arg4 = %cst) -> (f64) { + %2 = affine.load %arg1[%arg3] : memref + %3 = affine.load %arg2[%arg3] : memref + %4 = arith.mulf %2, %3 : f64 + %5 = arith.addf %arg4, %4 : f64 + affine.yield %5 : f64 + } + return %1 : f64 + } +} diff --git a/reduction_survey/r02_pure_op_return.c b/reduction_survey/r02_pure_op_return.c new file mode 100644 index 000000000000..8c9851f95525 --- /dev/null +++ b/reduction_survey/r02_pure_op_return.c @@ -0,0 +1,6 @@ +// Loop result passes through a pure scalar op (sqrt) before return. +double dnrm2(int n, double *x) { + double s = 0; + for (int i = 0; i < n; i++) s += x[i] * x[i]; + return __builtin_sqrt(s); +} diff --git a/reduction_survey/r02_pure_op_return.err b/reduction_survey/r02_pure_op_return.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r02_pure_op_return.mlir b/reduction_survey/r02_pure_op_return.mlir new file mode 100644 index 000000000000..a3b233eb50b1 --- /dev/null +++ b/reduction_survey/r02_pure_op_return.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @dnrm2(%arg0: i32, %arg1: memref) -> f64 attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %1 = affine.for %arg2 = 0 to %0 iter_args(%arg3 = %cst) -> (f64) { + %3 = affine.load %arg1[%arg2] : memref + %4 = arith.mulf %3, %3 : f64 + %5 = arith.addf %arg3, %4 : f64 + affine.yield %5 : f64 + } + %2 = math.sqrt %1 : f64 + return %2 : f64 + } +} diff --git a/reduction_survey/r03_store_scalar.c b/reduction_survey/r03_store_scalar.c new file mode 100644 index 000000000000..a15f1a738019 --- /dev/null +++ b/reduction_survey/r03_store_scalar.c @@ -0,0 +1,6 @@ +// Loop result stored into a scalar memref (current path that works). +void asum_out(int n, double *x, double *out) { + double s = 0; + for (int i = 0; i < n; i++) s += x[i]; + *out = s; +} diff --git a/reduction_survey/r03_store_scalar.err b/reduction_survey/r03_store_scalar.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r03_store_scalar.mlir b/reduction_survey/r03_store_scalar.mlir new file mode 100644 index 000000000000..31fe5299ff95 --- /dev/null +++ b/reduction_survey/r03_store_scalar.mlir @@ -0,0 +1,13 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @asum_out(%arg0: i32, %arg1: memref, %arg2: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %1 = affine.for %arg3 = 0 to %0 iter_args(%arg4 = %cst) -> (f64) { + %2 = affine.load %arg1[%arg3] : memref + %3 = arith.addf %arg4, %2 : f64 + affine.yield %3 : f64 + } + affine.store %1, %arg2[0] : memref + return + } +} diff --git a/reduction_survey/r04_store_indexed.c b/reduction_survey/r04_store_indexed.c new file mode 100644 index 000000000000..75eba96d89bd --- /dev/null +++ b/reduction_survey/r04_store_indexed.c @@ -0,0 +1,8 @@ +// Reduction stored into one row of an output array (GEMM-inner-loop pattern). +void rowsum(int m, int n, double *A, double *out) { + for (int i = 0; i < m; i++) { + double s = 0; + for (int j = 0; j < n; j++) s += A[i*n + j]; + out[i] = s; + } +} diff --git a/reduction_survey/r04_store_indexed.err b/reduction_survey/r04_store_indexed.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r04_store_indexed.mlir b/reduction_survey/r04_store_indexed.mlir new file mode 100644 index 000000000000..a20847907e40 --- /dev/null +++ b/reduction_survey/r04_store_indexed.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @rowsum(%arg0: i32, %arg1: i32, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + affine.for %arg4 = 0 to %1 { + %2 = affine.for %arg5 = 0 to %0 iter_args(%arg6 = %cst) -> (f64) { + %3 = affine.load %arg2[%arg5 + %arg4 * symbol(%0)] : memref + %4 = arith.addf %arg6, %3 : f64 + affine.yield %4 : f64 + } + affine.store %2, %arg3[%arg4] : memref + } + return + } +} diff --git a/reduction_survey/r05_arith_then_return.c b/reduction_survey/r05_arith_then_return.c new file mode 100644 index 000000000000..84ee8eb62cd7 --- /dev/null +++ b/reduction_survey/r05_arith_then_return.c @@ -0,0 +1,6 @@ +// Loop result combined with a runtime value in an arith expression, then returned. +double mean(int n, double *x) { + double s = 0; + for (int i = 0; i < n; i++) s += x[i]; + return s / n; +} diff --git a/reduction_survey/r05_arith_then_return.err b/reduction_survey/r05_arith_then_return.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r05_arith_then_return.mlir b/reduction_survey/r05_arith_then_return.mlir new file mode 100644 index 000000000000..c9239006fc3d --- /dev/null +++ b/reduction_survey/r05_arith_then_return.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mean(%arg0: i32, %arg1: memref) -> f64 attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %1 = affine.for %arg2 = 0 to %0 iter_args(%arg3 = %cst) -> (f64) { + %4 = affine.load %arg1[%arg2] : memref + %5 = arith.addf %arg3, %4 : f64 + affine.yield %5 : f64 + } + %2 = arith.sitofp %arg0 : i32 to f64 + %3 = arith.divf %1, %2 : f64 + return %3 : f64 + } +} diff --git a/reduction_survey/r06_call_use.c b/reduction_survey/r06_call_use.c new file mode 100644 index 000000000000..3b632bbd4233 --- /dev/null +++ b/reduction_survey/r06_call_use.c @@ -0,0 +1,7 @@ +// Loop result passed as argument to another function. +extern void sink(double); +void log_sum(int n, double *x) { + double s = 0; + for (int i = 0; i < n; i++) s += x[i]; + sink(s); +} diff --git a/reduction_survey/r06_call_use.err b/reduction_survey/r06_call_use.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r06_call_use.mlir b/reduction_survey/r06_call_use.mlir new file mode 100644 index 000000000000..f8a9683e60c4 --- /dev/null +++ b/reduction_survey/r06_call_use.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @log_sum(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %1 = affine.for %arg2 = 0 to %0 iter_args(%arg3 = %cst) -> (f64) { + %2 = affine.load %arg1[%arg2] : memref + %3 = arith.addf %arg3, %2 : f64 + affine.yield %3 : f64 + } + call @sink(%1) : (f64) -> () + return + } + func.func private @sink(f64) attributes {llvm.linkage = #llvm.linkage} +} diff --git a/reduction_survey/r07_two_uses.c b/reduction_survey/r07_two_uses.c new file mode 100644 index 000000000000..f64c580cfbdd --- /dev/null +++ b/reduction_survey/r07_two_uses.c @@ -0,0 +1,6 @@ +// Loop result has multiple uses. +double sum_and_sumsq_diff(int n, double *x) { + double s = 0; + for (int i = 0; i < n; i++) s += x[i]; + return s + s * s; +} diff --git a/reduction_survey/r07_two_uses.err b/reduction_survey/r07_two_uses.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r07_two_uses.mlir b/reduction_survey/r07_two_uses.mlir new file mode 100644 index 000000000000..080f508f4441 --- /dev/null +++ b/reduction_survey/r07_two_uses.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @sum_and_sumsq_diff(%arg0: i32, %arg1: memref) -> f64 attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %1 = affine.for %arg2 = 0 to %0 iter_args(%arg3 = %cst) -> (f64) { + %4 = affine.load %arg1[%arg2] : memref + %5 = arith.addf %arg3, %4 : f64 + affine.yield %5 : f64 + } + %2 = arith.mulf %1, %1 : f64 + %3 = arith.addf %1, %2 : f64 + return %3 : f64 + } +} diff --git a/reduction_survey/r08_two_reductions.c b/reduction_survey/r08_two_reductions.c new file mode 100644 index 000000000000..413e9e8a3fc5 --- /dev/null +++ b/reduction_survey/r08_two_reductions.c @@ -0,0 +1,10 @@ +// Two iter_args in a single loop (sum + sum-of-squares). +void mean_sumsq(int n, double *x, double *m, double *q) { + double s = 0, ss = 0; + for (int i = 0; i < n; i++) { + s += x[i]; + ss += x[i] * x[i]; + } + *m = s; + *q = ss; +} diff --git a/reduction_survey/r08_two_reductions.err b/reduction_survey/r08_two_reductions.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r08_two_reductions.mlir b/reduction_survey/r08_two_reductions.mlir new file mode 100644 index 000000000000..550f385b7dff --- /dev/null +++ b/reduction_survey/r08_two_reductions.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @mean_sumsq(%arg0: i32, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %1:2 = affine.for %arg4 = 0 to %0 iter_args(%arg5 = %cst, %arg6 = %cst) -> (f64, f64) { + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.addf %arg6, %2 : f64 + %4 = arith.mulf %2, %2 : f64 + %5 = arith.addf %arg5, %4 : f64 + affine.yield %5, %3 : f64, f64 + } + affine.store %1#1, %arg2[0] : memref + affine.store %1#0, %arg3[0] : memref + return + } +} diff --git a/reduction_survey/r09_max.c b/reduction_survey/r09_max.c new file mode 100644 index 000000000000..f6400a3a0bc1 --- /dev/null +++ b/reduction_survey/r09_max.c @@ -0,0 +1,9 @@ +// Max reduction via conditional update. +double maxabs(int n, double *x) { + double m = 0; + for (int i = 0; i < n; i++) { + double a = x[i] < 0 ? -x[i] : x[i]; + if (a > m) m = a; + } + return m; +} diff --git a/reduction_survey/r09_max.err b/reduction_survey/r09_max.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r09_max.mlir b/reduction_survey/r09_max.mlir new file mode 100644 index 000000000000..938e11f283b1 --- /dev/null +++ b/reduction_survey/r09_max.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @maxabs(%arg0: i32, %arg1: memref) -> f64 attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %1 = affine.for %arg2 = 0 to %0 iter_args(%arg3 = %cst) -> (f64) { + %2 = affine.load %arg1[%arg2] : memref + %3 = arith.cmpf olt, %2, %cst : f64 + %4 = scf.if %3 -> (f64) { + %7 = arith.negf %2 : f64 + scf.yield %7 : f64 + } else { + scf.yield %2 : f64 + } + %5 = arith.cmpf ogt, %4, %arg3 : f64 + %6 = arith.select %5, %4, %arg3 : f64 + affine.yield %6 : f64 + } + return %1 : f64 + } +} diff --git a/reduction_survey/r10_argmax.c b/reduction_survey/r10_argmax.c new file mode 100644 index 000000000000..f91731778036 --- /dev/null +++ b/reduction_survey/r10_argmax.c @@ -0,0 +1,9 @@ +// Argmax: track value AND index together (two iter_args of different types). +int idamax(int n, double *x) { + double m = x[0]; + int k = 0; + for (int i = 1; i < n; i++) { + if (x[i] > m) { m = x[i]; k = i; } + } + return k; +} diff --git a/reduction_survey/r10_argmax.err b/reduction_survey/r10_argmax.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r10_argmax.mlir b/reduction_survey/r10_argmax.mlir new file mode 100644 index 000000000000..d89e18e4c7f2 --- /dev/null +++ b/reduction_survey/r10_argmax.mlir @@ -0,0 +1,16 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @idamax(%arg0: i32, %arg1: memref) -> i32 attributes {llvm.linkage = #llvm.linkage} { + %c0_i32 = arith.constant 0 : i32 + %0 = affine.load %arg1[0] : memref + %1 = arith.index_cast %arg0 : i32 to index + %2:2 = affine.for %arg2 = 1 to %1 iter_args(%arg3 = %c0_i32, %arg4 = %0) -> (i32, f64) { + %3 = arith.index_cast %arg2 : index to i32 + %4 = affine.load %arg1[%arg2] : memref + %5 = arith.cmpf ogt, %4, %arg4 : f64 + %6 = arith.select %5, %3, %arg3 : i32 + %7 = arith.select %5, %4, %arg4 : f64 + affine.yield %6, %7 : i32, f64 + } + return %2#0 : i32 + } +} diff --git a/reduction_survey/r11_product.c b/reduction_survey/r11_product.c new file mode 100644 index 000000000000..94f5cc29986f --- /dev/null +++ b/reduction_survey/r11_product.c @@ -0,0 +1,6 @@ +// Product reduction (multiplicative monoid). +double prod(int n, double *x) { + double p = 1; + for (int i = 0; i < n; i++) p *= x[i]; + return p; +} diff --git a/reduction_survey/r11_product.err b/reduction_survey/r11_product.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r11_product.mlir b/reduction_survey/r11_product.mlir new file mode 100644 index 000000000000..3bd71a9702f6 --- /dev/null +++ b/reduction_survey/r11_product.mlir @@ -0,0 +1,12 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @prod(%arg0: i32, %arg1: memref) -> f64 attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 1.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %1 = affine.for %arg2 = 0 to %0 iter_args(%arg3 = %cst) -> (f64) { + %2 = affine.load %arg1[%arg2] : memref + %3 = arith.mulf %arg3, %2 : f64 + affine.yield %3 : f64 + } + return %1 : f64 + } +} diff --git a/reduction_survey/r12_int_count.c b/reduction_survey/r12_int_count.c new file mode 100644 index 000000000000..f99d093275d7 --- /dev/null +++ b/reduction_survey/r12_int_count.c @@ -0,0 +1,6 @@ +// Integer counter incremented conditionally. +int count_positive(int n, double *x) { + int c = 0; + for (int i = 0; i < n; i++) if (x[i] > 0) c++; + return c; +} diff --git a/reduction_survey/r12_int_count.err b/reduction_survey/r12_int_count.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r12_int_count.mlir b/reduction_survey/r12_int_count.mlir new file mode 100644 index 000000000000..c90b811ca8f4 --- /dev/null +++ b/reduction_survey/r12_int_count.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @count_positive(%arg0: i32, %arg1: memref) -> i32 attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f64 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.index_cast %arg0 : i32 to index + %1 = affine.for %arg2 = 0 to %0 iter_args(%arg3 = %c0_i32) -> (i32) { + %2 = affine.load %arg1[%arg2] : memref + %3 = arith.cmpf ogt, %2, %cst : f64 + %4 = scf.if %3 -> (i32) { + %5 = arith.addi %arg3, %c1_i32 : i32 + scf.yield %5 : i32 + } else { + scf.yield %arg3 : i32 + } + affine.yield %4 : i32 + } + return %1 : i32 + } +} diff --git a/reduction_survey/r13_sum_then_loop.c b/reduction_survey/r13_sum_then_loop.c new file mode 100644 index 000000000000..cd0105c12308 --- /dev/null +++ b/reduction_survey/r13_sum_then_loop.c @@ -0,0 +1,6 @@ +// Reduction used as a divisor in a subsequent loop. +void normalize(int n, double *x) { + double s = 0; + for (int i = 0; i < n; i++) s += x[i]; + for (int i = 0; i < n; i++) x[i] /= s; +} diff --git a/reduction_survey/r13_sum_then_loop.err b/reduction_survey/r13_sum_then_loop.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r13_sum_then_loop.mlir b/reduction_survey/r13_sum_then_loop.mlir new file mode 100644 index 000000000000..cd5b00638045 --- /dev/null +++ b/reduction_survey/r13_sum_then_loop.mlir @@ -0,0 +1,17 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @normalize(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %1 = affine.for %arg2 = 0 to %0 iter_args(%arg3 = %cst) -> (f64) { + %2 = affine.load %arg1[%arg2] : memref + %3 = arith.addf %arg3, %2 : f64 + affine.yield %3 : f64 + } + affine.for %arg2 = 0 to %0 { + %2 = affine.load %arg1[%arg2] : memref + %3 = arith.divf %2, %1 : f64 + affine.store %3, %arg1[%arg2] : memref + } + return + } +} diff --git a/reduction_survey/r14_used_as_bound.c b/reduction_survey/r14_used_as_bound.c new file mode 100644 index 000000000000..1578c1e7a669 --- /dev/null +++ b/reduction_survey/r14_used_as_bound.c @@ -0,0 +1,7 @@ +// Reduction result used as an upper-bound expression for a later loop. +extern void use_int(int); +void hist(int n, double *x) { + int c = 0; + for (int i = 0; i < n; i++) if (x[i] > 0) c++; + for (int j = 0; j < c; j++) use_int(j); +} diff --git a/reduction_survey/r14_used_as_bound.err b/reduction_survey/r14_used_as_bound.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r14_used_as_bound.mlir b/reduction_survey/r14_used_as_bound.mlir new file mode 100644 index 000000000000..5a866668e81e --- /dev/null +++ b/reduction_survey/r14_used_as_bound.mlir @@ -0,0 +1,26 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @hist(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + %c1_i32 = arith.constant 1 : i32 + %cst = arith.constant 0.000000e+00 : f64 + %c0_i32 = arith.constant 0 : i32 + %0 = arith.index_cast %arg0 : i32 to index + %1 = affine.for %arg2 = 0 to %0 iter_args(%arg3 = %c0_i32) -> (i32) { + %3 = affine.load %arg1[%arg2] : memref + %4 = arith.cmpf ogt, %3, %cst : f64 + %5 = scf.if %4 -> (i32) { + %6 = arith.addi %arg3, %c1_i32 : i32 + scf.yield %6 : i32 + } else { + scf.yield %arg3 : i32 + } + affine.yield %5 : i32 + } + %2 = arith.index_cast %1 : i32 to index + affine.for %arg2 = 0 to %2 { + %3 = arith.index_cast %arg2 : index to i32 + func.call @use_int(%3) : (i32) -> () + } + return + } + func.func private @use_int(i32) attributes {llvm.linkage = #llvm.linkage} +} diff --git a/reduction_survey/r15_nested.c b/reduction_survey/r15_nested.c new file mode 100644 index 000000000000..efe29ad03bba --- /dev/null +++ b/reduction_survey/r15_nested.c @@ -0,0 +1,10 @@ +// Outer iter_arg accumulates inner-loop reduction (nested reductions). +double dist(int m, int n, double *A) { + double total = 0; + for (int i = 0; i < m; i++) { + double row = 0; + for (int j = 0; j < n; j++) row += A[i*n + j]; + total += row * row; + } + return total; +} diff --git a/reduction_survey/r15_nested.err b/reduction_survey/r15_nested.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r15_nested.mlir b/reduction_survey/r15_nested.mlir new file mode 100644 index 000000000000..c939534525f8 --- /dev/null +++ b/reduction_survey/r15_nested.mlir @@ -0,0 +1,18 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @dist(%arg0: i32, %arg1: i32, %arg2: memref) -> f64 attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg1 : i32 to index + %1 = arith.index_cast %arg0 : i32 to index + %2 = affine.for %arg3 = 0 to %1 iter_args(%arg4 = %cst) -> (f64) { + %3 = affine.for %arg5 = 0 to %0 iter_args(%arg6 = %cst) -> (f64) { + %6 = affine.load %arg2[%arg5 + %arg3 * symbol(%0)] : memref + %7 = arith.addf %arg6, %6 : f64 + affine.yield %7 : f64 + } + %4 = arith.mulf %3, %3 : f64 + %5 = arith.addf %arg4, %4 : f64 + affine.yield %5 : f64 + } + return %2 : f64 + } +} diff --git a/reduction_survey/r16_unused.c b/reduction_survey/r16_unused.c new file mode 100644 index 000000000000..94d61058e113 --- /dev/null +++ b/reduction_survey/r16_unused.c @@ -0,0 +1,5 @@ +// Reduction result never used (loop kept for side effects of the body... here, none). +void dead_sum(int n, double *x) { + double s = 0; + for (int i = 0; i < n; i++) s += x[i]; +} diff --git a/reduction_survey/r16_unused.err b/reduction_survey/r16_unused.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r16_unused.mlir b/reduction_survey/r16_unused.mlir new file mode 100644 index 000000000000..fe836ed669e2 --- /dev/null +++ b/reduction_survey/r16_unused.mlir @@ -0,0 +1,5 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @dead_sum(%arg0: i32, %arg1: memref) attributes {llvm.linkage = #llvm.linkage} { + return + } +} diff --git a/reduction_survey/r17_two_stores.c b/reduction_survey/r17_two_stores.c new file mode 100644 index 000000000000..f55bdcafcf78 --- /dev/null +++ b/reduction_survey/r17_two_stores.c @@ -0,0 +1,7 @@ +// Reduction stored into two different memrefs. +void duplicate_sum(int n, double *x, double *a, double *b) { + double s = 0; + for (int i = 0; i < n; i++) s += x[i]; + *a = s; + *b = s; +} diff --git a/reduction_survey/r17_two_stores.err b/reduction_survey/r17_two_stores.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r17_two_stores.mlir b/reduction_survey/r17_two_stores.mlir new file mode 100644 index 000000000000..5a24166fb109 --- /dev/null +++ b/reduction_survey/r17_two_stores.mlir @@ -0,0 +1,14 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @duplicate_sum(%arg0: i32, %arg1: memref, %arg2: memref, %arg3: memref) attributes {llvm.linkage = #llvm.linkage} { + %cst = arith.constant 0.000000e+00 : f64 + %0 = arith.index_cast %arg0 : i32 to index + %1 = affine.for %arg4 = 0 to %0 iter_args(%arg5 = %cst) -> (f64) { + %2 = affine.load %arg1[%arg4] : memref + %3 = arith.addf %arg5, %2 : f64 + affine.yield %3 : f64 + } + affine.store %1, %arg2[0] : memref + affine.store %1, %arg3[0] : memref + return + } +} diff --git a/reduction_survey/r18_cond_then_return.c b/reduction_survey/r18_cond_then_return.c new file mode 100644 index 000000000000..b45184d6928d --- /dev/null +++ b/reduction_survey/r18_cond_then_return.c @@ -0,0 +1,7 @@ +// Reduction used in a branch condition. +int any_negative(int n, double *x) { + double s = 0; + for (int i = 0; i < n; i++) s += x[i]; + if (s < 0) return 1; + return 0; +} diff --git a/reduction_survey/r18_cond_then_return.err b/reduction_survey/r18_cond_then_return.err new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/reduction_survey/r18_cond_then_return.mlir b/reduction_survey/r18_cond_then_return.mlir new file mode 100644 index 000000000000..3c5f9c4c1c95 --- /dev/null +++ b/reduction_survey/r18_cond_then_return.mlir @@ -0,0 +1,20 @@ +module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry, dense<64> : vector<4xi32>>, #dlti.dl_entry, dense<32> : vector<4xi32>>, #dlti.dl_entry : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} { + func.func @any_negative(%arg0: i32, %arg1: memref) -> i32 attributes {llvm.linkage = #llvm.linkage} { + %true = arith.constant true + %c1_i32 = arith.constant 1 : i32 + %c0_i32 = arith.constant 0 : i32 + %cst = arith.constant 0.000000e+00 : f64 + %0 = llvm.mlir.undef : i32 + %1 = arith.index_cast %arg0 : i32 to index + %2 = affine.for %arg2 = 0 to %1 iter_args(%arg3 = %cst) -> (f64) { + %7 = affine.load %arg1[%arg2] : memref + %8 = arith.addf %arg3, %7 : f64 + affine.yield %8 : f64 + } + %3 = arith.cmpf olt, %2, %cst : f64 + %4 = arith.xori %3, %true : i1 + %5 = arith.select %3, %c1_i32, %0 : i32 + %6 = arith.select %4, %c0_i32, %5 : i32 + return %6 : i32 + } +} diff --git a/run_cgeist_on_all_c_files.sh b/run_cgeist_on_all_c_files.sh new file mode 100755 index 000000000000..d7550d142ff9 --- /dev/null +++ b/run_cgeist_on_all_c_files.sh @@ -0,0 +1,500 @@ +#!/bin/bash + +# Script to run cgeist on all .c files in the Test directory +# and then run polygeist-opt --raise-affine-to-linalg and --linalg-debufferize on generated files +# Based on the provided command format + +set -e # Exit on any error + +# Function to show usage +show_usage() { + echo "Usage: $0 " + echo "" + echo "Modes:" + echo " 0 - Run all phases (cgeist + polygeist-opt + canonicalize + linalg-debufferize)" + echo " 1 - Run only cgeist phase" + echo " 2 - Run only polygeist-opt --raise-affine-to-linalg phase" + echo " 3 - Run only polygeist-opt --canonicalize phase" + echo " 4 - Run only polygeist-opt --linalg-debufferize phase" + echo " 5 - Run --affine-parallelize then --raise-affine-to-linalg-pipeline phase" + echo "" + echo "Examples:" + echo " $0 0 # Run all four phases" + echo " $0 1 # Run only cgeist" + echo " $0 2 # Run only raise-affine-to-linalg" + echo " $0 3 # Run only canonicalize" + echo " $0 4 # Run only linalg-debufferize" + echo " $0 5 # Run only raise-affine-to-linalg-pipeline (combines parallelize + raise + canonicalize)" + exit 1 +} + +# Check if argument is provided +if [ $# -ne 1 ]; then + echo "Error: Mode argument is required" + show_usage +fi + +# Parse mode argument +MODE="$1" + +# Validate mode argument +if [[ ! "$MODE" =~ ^[012345]$ ]]; then + echo "Error: Invalid mode '$MODE'. Must be 0, 1, 2, 3, 4, or 5" + show_usage +fi + +# Configuration +TEST_DIR="/home/arjaiswal/Polygeist/tools/cgeist/Test" +OUTPUT_DIR="/home/arjaiswal/Polygeist/cgeist-output" +LINALG_OUTPUT_DIR="/home/arjaiswal/Polygeist/cgeist-linalg-output" +CANONICALIZE_OUTPUT_DIR="/home/arjaiswal/Polygeist/cgeist-canonicalized-output" +debufferizeD_OUTPUT_DIR="/home/arjaiswal/Polygeist/cgeist-debufferized-output" +PIPELINE_OUTPUT_DIR="/home/arjaiswal/Polygeist/cgeist-pipeline-output" +RESOURCE_DIR="/usr/lib/clang/14" # Default clang resource dir, adjust if needed +LOG_FILE="cgeist_run.log" + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +PURPLE='\033[0;35m' +CYAN='\033[0;36m' +NC='\033[0m' # No Color + +# Display mode information +case $MODE in + 0) + echo -e "${GREEN}Starting four-phase cgeist + polygeist-opt + canonicalize + linalg-debufferize processing${NC}" + echo -e "${BLUE}Phase 1: Running cgeist on all .c files in ${TEST_DIR}${NC}" + echo -e "${BLUE}Phase 2: Running polygeist-opt --raise-affine-to-linalg on generated files${NC}" + echo -e "${BLUE}Phase 3: Running polygeist-opt --canonicalize on linalg files${NC}" + echo -e "${BLUE}Phase 4: Running polygeist-opt --linalg-debufferize on canonicalized files${NC}" + ;; + 1) + echo -e "${GREEN}Starting cgeist processing only${NC}" + echo -e "${BLUE}Phase 1: Running cgeist on all .c files in ${TEST_DIR}${NC}" + ;; + 2) + echo -e "${GREEN}Starting polygeist-opt --raise-affine-to-linalg processing only${NC}" + echo -e "${BLUE}Phase 2: Running polygeist-opt --raise-affine-to-linalg on existing files${NC}" + ;; + 3) + echo -e "${GREEN}Starting canonicalize processing only${NC}" + echo -e "${BLUE}Phase 3: Running polygeist-opt --canonicalize on existing linalg files${NC}" + ;; + 4) + echo -e "${GREEN}Starting linalg-debufferize processing only${NC}" + echo -e "${BLUE}Phase 4: Running polygeist-opt --linalg-debufferize on existing canonicalized files${NC}" + ;; + 5) + echo -e "${GREEN}Starting raise-affine-to-linalg-pipeline processing only${NC}" + echo -e "${BLUE}Phase 5: Running --affine-parallelize then --raise-affine-to-linalg-pipeline on existing files${NC}" + ;; +esac + +# Create output directories +mkdir -p "$OUTPUT_DIR" +mkdir -p "$LINALG_OUTPUT_DIR" +mkdir -p "$CANONICALIZE_OUTPUT_DIR" +mkdir -p "$debufferizeD_OUTPUT_DIR" +mkdir -p "$PIPELINE_OUTPUT_DIR" + +# Initialize log file +echo "Script run started at $(date) - Mode: $MODE" > "$LOG_FILE" + +# Initialize global counters +total_files=0 +success_count=0 +error_count=0 +total_mlir_files=0 +linalg_success_count=0 +linalg_error_count=0 +total_canonicalize_files=0 +canonicalize_success_count=0 +canonicalize_error_count=0 +total_debufferized_files=0 +debufferized_success_count=0 +debufferized_error_count=0 +total_pipeline_files=0 +pipeline_success_count=0 +pipeline_error_count=0 + +# ====== PHASE 1: CGEIST PROCESSING ====== +if [ "$MODE" -eq 0 ] || [ "$MODE" -eq 1 ]; then + echo -e "\n${PURPLE}=== PHASE 1: CGEIST PROCESSING ===${NC}" + + # Find all .c files and count them + mapfile -t c_files < <(find "$TEST_DIR" -name "*.c" -type f) + total_files=${#c_files[@]} + + echo -e "${YELLOW}Found $total_files .c files to process${NC}" + + # Counter for progress + counter=0 + + # Process each .c file + for c_file in "${c_files[@]}"; do + counter=$((counter + 1)) + + # Get relative path from TEST_DIR + rel_path="${c_file#$TEST_DIR/}" + + # Create output filename (replace .c with .mlir and path separators with underscores) + output_name=$(echo "$rel_path" | sed 's|/|_|g' | sed 's|\.c$|-polygeist-intermediate.mlir|') + output_path="$OUTPUT_DIR/$output_name" + + # Create output directory structure if needed + output_subdir=$(dirname "$output_path") + mkdir -p "$output_subdir" + + echo -e "${YELLOW}[$counter/$total_files] Processing: $rel_path${NC}" + + # Determine if this is a CUDA file (check if it's in CUDA directory or contains CUDA-specific code) + cuda_flags="" + if [[ "$c_file" == *"/CUDA/"* ]] || [[ "$c_file" == *"cuda"* ]] || grep -q "cuda\|__global__\|__device__" "$c_file" 2>/dev/null; then + cuda_flags="--cuda-gpu-arch=sm_35" + fi + + # Run cgeist command + cgeist_cmd="cgeist \"$c_file\" --function=* --resource-dir=$RESOURCE_DIR -I $TEST_DIR/polybench/utilities --raise-scf-to-affine $cuda_flags -fPIC -S -g -c -o \"$output_path\"" + + echo -e "${NC}Running: $cgeist_cmd${NC}" + echo "Running: $cgeist_cmd" >> "$LOG_FILE" + + if eval "$cgeist_cmd" 2>> "$LOG_FILE"; then + echo -e "${GREEN} ✓ Success: $output_name${NC}" + success_count=$((success_count + 1)) + echo "SUCCESS: $rel_path -> $output_name" >> "$LOG_FILE" + else + echo -e "${RED} ✗ Error processing: $rel_path${NC}" + error_count=$((error_count + 1)) + echo "ERROR: Failed to process $rel_path" >> "$LOG_FILE" + fi + + echo "" >> "$LOG_FILE" # Add blank line for readability + done + + # Phase 1 Summary + echo -e "\n${PURPLE}=== PHASE 1 SUMMARY ===${NC}" + echo -e "${GREEN}Total files processed: $total_files${NC}" + echo -e "${GREEN}Successful: $success_count${NC}" + echo -e "${RED}Errors: $error_count${NC}" + + echo "Phase 1 completed at $(date)" >> "$LOG_FILE" +fi + +# ====== PHASE 2: POLYGEIST-OPT RAISE-AFFINE-TO-LINALG PROCESSING ====== +if [ "$MODE" -eq 0 ] || [ "$MODE" -eq 2 ]; then + echo -e "\n${PURPLE}=== PHASE 2: POLYGEIST-OPT RAISE-AFFINE-TO-LINALG PROCESSING ===${NC}" + + # Find all successfully generated .mlir files + mapfile -t mlir_files < <(find "$OUTPUT_DIR" -name "*.mlir" -type f) + total_mlir_files=${#mlir_files[@]} + + if [ $total_mlir_files -eq 0 ]; then + echo -e "${RED}No .mlir files found in $OUTPUT_DIR${NC}" + if [ "$MODE" -eq 2 ]; then + echo -e "${RED}Cannot run phase 2 without existing intermediate files${NC}" + echo -e "${YELLOW}Hint: Run mode 1 first to generate intermediate files${NC}" + exit 1 + fi + else + echo -e "${YELLOW}Found $total_mlir_files .mlir files to process with polygeist-opt${NC}" + + # Reset counters for phase 2 + counter=0 + + echo "Starting Phase 2: polygeist-opt --raise-affine-to-linalg processing" >> "$LOG_FILE" + + # Process each .mlir file + for mlir_file in "${mlir_files[@]}"; do + counter=$((counter + 1)) + + # Get filename without path and replace -polygeist-intermediate.mlir with -polygeist-linalg.mlir + base_name=$(basename "$mlir_file") + linalg_output_name=$(echo "$base_name" | sed 's|-polygeist-intermediate\.mlir$|-polygeist-linalg.mlir|') + linalg_output_path="$LINALG_OUTPUT_DIR/$linalg_output_name" + + echo -e "${YELLOW}[$counter/$total_mlir_files] Processing: $base_name${NC}" + + # Run polygeist-opt command + polygeist_opt_cmd="polygeist-opt --raise-affine-to-linalg \"$mlir_file\" -o \"$linalg_output_path\"" + + echo -e "${NC}Running: $polygeist_opt_cmd${NC}" + echo "Running: $polygeist_opt_cmd" >> "$LOG_FILE" + + if eval "$polygeist_opt_cmd" 2>> "$LOG_FILE"; then + echo -e "${GREEN} ✓ Success: $linalg_output_name${NC}" + linalg_success_count=$((linalg_success_count + 1)) + echo "SUCCESS: $base_name -> $linalg_output_name" >> "$LOG_FILE" + else + echo -e "${RED} ✗ Error processing: $base_name${NC}" + linalg_error_count=$((linalg_error_count + 1)) + echo "ERROR: Failed to process $base_name with polygeist-opt --raise-affine-to-linalg" >> "$LOG_FILE" + fi + + echo "" >> "$LOG_FILE" # Add blank line for readability + done + fi + + # Phase 2 Summary (only if files were processed) + if [ $total_mlir_files -gt 0 ]; then + echo -e "\n${PURPLE}=== PHASE 2 SUMMARY ===${NC}" + echo -e "${GREEN}Total MLIR files processed: $total_mlir_files${NC}" + echo -e "${GREEN}Successful: $linalg_success_count${NC}" + echo -e "${RED}Errors: $linalg_error_count${NC}" + fi + + echo "Phase 2 completed at $(date)" >> "$LOG_FILE" +fi + +# ====== PHASE 3: POLYGEIST-OPT CANONICALIZE PROCESSING ====== +if [ "$MODE" -eq 0 ] || [ "$MODE" -eq 3 ]; then + echo -e "\n${PURPLE}=== PHASE 3: POLYGEIST-OPT CANONICALIZE PROCESSING ===${NC}" + + # Find all successfully generated linalg .mlir files + mapfile -t linalg_files < <(find "$LINALG_OUTPUT_DIR" -name "*.mlir" -type f) + total_canonicalize_files=${#linalg_files[@]} + + if [ $total_canonicalize_files -eq 0 ]; then + echo -e "${RED}No .mlir files found in $LINALG_OUTPUT_DIR${NC}" + if [ "$MODE" -eq 3 ]; then + echo -e "${RED}Cannot run phase 3 without existing linalg files${NC}" + echo -e "${YELLOW}Hint: Run mode 2 first to generate linalg files${NC}" + exit 1 + fi + else + echo -e "${YELLOW}Found $total_canonicalize_files .mlir files to process with canonicalize${NC}" + + # Reset counters for phase 3 + counter=0 + + echo "Starting Phase 3: polygeist-opt --canonicalize processing" >> "$LOG_FILE" + + # Process each .mlir file + for linalg_file in "${linalg_files[@]}"; do + counter=$((counter + 1)) + + # Get filename without path and replace -polygeist-linalg.mlir with -polygeist-canonicalized.mlir + base_name=$(basename "$linalg_file") + canonicalize_output_name=$(echo "$base_name" | sed 's|-polygeist-linalg\.mlir$|-polygeist-canonicalized.mlir|') + canonicalize_output_path="$CANONICALIZE_OUTPUT_DIR/$canonicalize_output_name" + + echo -e "${YELLOW}[$counter/$total_canonicalize_files] Processing: $base_name${NC}" + + # Run polygeist-opt command with canonicalize + canonicalize_cmd="polygeist-opt --canonicalize \"$linalg_file\" -o \"$canonicalize_output_path\"" + + echo -e "${NC}Running: $canonicalize_cmd${NC}" + echo "Running: $canonicalize_cmd" >> "$LOG_FILE" + + if eval "$canonicalize_cmd" 2>> "$LOG_FILE"; then + echo -e "${GREEN} ✓ Success: $canonicalize_output_name${NC}" + canonicalize_success_count=$((canonicalize_success_count + 1)) + echo "SUCCESS: $base_name -> $canonicalize_output_name" >> "$LOG_FILE" + else + echo -e "${RED} ✗ Error processing: $base_name${NC}" + canonicalize_error_count=$((canonicalize_error_count + 1)) + echo "ERROR: Failed to process $base_name with polygeist-opt --canonicalize" >> "$LOG_FILE" + fi + + echo "" >> "$LOG_FILE" # Add blank line for readability + done + fi + + # Phase 3 Summary (only if files were processed) + if [ $total_canonicalize_files -gt 0 ]; then + echo -e "\n${PURPLE}=== PHASE 3 SUMMARY ===${NC}" + echo -e "${GREEN}Total linalg files processed: $total_canonicalize_files${NC}" + echo -e "${GREEN}Successful: $canonicalize_success_count${NC}" + echo -e "${RED}Errors: $canonicalize_error_count${NC}" + fi + + echo "Phase 3 completed at $(date)" >> "$LOG_FILE" +fi + +# ====== PHASE 4: POLYGEIST-OPT LINALG-debufferize PROCESSING ====== +if [ "$MODE" -eq 0 ] || [ "$MODE" -eq 4 ]; then + echo -e "\n${PURPLE}=== PHASE 4: POLYGEIST-OPT LINALG-debufferize PROCESSING ===${NC}" + + # Find all successfully generated canonicalized .mlir files + mapfile -t canonicalized_files < <(find "$CANONICALIZE_OUTPUT_DIR" -name "*.mlir" -type f) + total_debufferized_files=${#canonicalized_files[@]} + + if [ $total_debufferized_files -eq 0 ]; then + echo -e "${RED}No .mlir files found in $CANONICALIZE_OUTPUT_DIR${NC}" + if [ "$MODE" -eq 4 ]; then + echo -e "${RED}Cannot run phase 4 without existing canonicalized files${NC}" + echo -e "${YELLOW}Hint: Run mode 3 first to generate canonicalized files${NC}" + exit 1 + fi + else + echo -e "${YELLOW}Found $total_debufferized_files .mlir files to process with linalg-debufferize${NC}" + + # Reset counters for phase 4 + counter=0 + + echo "Starting Phase 4: polygeist-opt --linalg-debufferize processing" >> "$LOG_FILE" + + # Process each .mlir file + for canonicalized_file in "${canonicalized_files[@]}"; do + counter=$((counter + 1)) + + # Get filename without path and replace -polygeist-canonicalized.mlir with -polygeist-debufferized.mlir + base_name=$(basename "$canonicalized_file") + debufferized_output_name=$(echo "$base_name" | sed 's|-polygeist-canonicalized\.mlir$|-polygeist-debufferized.mlir|') + debufferized_output_path="$debufferizeD_OUTPUT_DIR/$debufferized_output_name" + + echo -e "${YELLOW}[$counter/$total_debufferized_files] Processing: $base_name${NC}" + + # Run polygeist-opt command with linalg-debufferize + debufferize_cmd="polygeist-opt --linalg-debufferize \"$canonicalized_file\" -o \"$debufferized_output_path\"" + + echo -e "${NC}Running: $debufferize_cmd${NC}" + echo "Running: $debufferize_cmd" >> "$LOG_FILE" + + if eval "$debufferize_cmd" 2>> "$LOG_FILE"; then + echo -e "${GREEN} ✓ Success: $debufferized_output_name${NC}" + debufferized_success_count=$((debufferized_success_count + 1)) + echo "SUCCESS: $base_name -> $debufferized_output_name" >> "$LOG_FILE" + else + echo -e "${RED} ✗ Error processing: $base_name${NC}" + debufferized_error_count=$((debufferized_error_count + 1)) + echo "ERROR: Failed to process $base_name with polygeist-opt --linalg-debufferize" >> "$LOG_FILE" + fi + + echo "" >> "$LOG_FILE" # Add blank line for readability + done + fi + + # Phase 4 Summary (only if files were processed) + if [ $total_debufferized_files -gt 0 ]; then + echo -e "\n${PURPLE}=== PHASE 4 SUMMARY ===${NC}" + echo -e "${GREEN}Total canonicalized files processed: $total_debufferized_files${NC}" + echo -e "${GREEN}Successful: $debufferized_success_count${NC}" + echo -e "${RED}Errors: $debufferized_error_count${NC}" + fi + + echo "Phase 4 completed at $(date)" >> "$LOG_FILE" +fi + +# ====== PHASE 5: POLYGEIST-OPT RAISE-AFFINE-TO-LINALG-PIPELINE PROCESSING ====== +if [ "$MODE" -eq 5 ]; then + echo -e "\n${PURPLE}=== PHASE 5: POLYGEIST-OPT AFFINE-PARALLELIZE + RAISE-AFFINE-TO-LINALG-PIPELINE PROCESSING ===${NC}" + + # Find all successfully generated .mlir files from cgeist (same as phase 2) + mapfile -t mlir_files < <(find "$OUTPUT_DIR" -name "*.mlir" -type f) + total_pipeline_files=${#mlir_files[@]} + + if [ $total_pipeline_files -eq 0 ]; then + echo -e "${RED}No .mlir files found in $OUTPUT_DIR${NC}" + echo -e "${RED}Cannot run phase 5 without existing intermediate files${NC}" + echo -e "${YELLOW}Hint: Run mode 1 first to generate intermediate files${NC}" + exit 1 + else + echo -e "${YELLOW}Found $total_pipeline_files .mlir files to process with pipeline${NC}" + + # Reset counters for phase 5 + counter=0 + + echo "Starting Phase 5: polygeist-opt --affine-parallelize --raise-affine-to-linalg-pipeline processing" >> "$LOG_FILE" + + # Process each .mlir file + for mlir_file in "${mlir_files[@]}"; do + counter=$((counter + 1)) + + # Get filename without path and replace -polygeist-intermediate.mlir with -polygeist-pipeline.mlir + base_name=$(basename "$mlir_file") + pipeline_output_name=$(echo "$base_name" | sed 's|-polygeist-intermediate\.mlir$|-polygeist-pipeline.mlir|') + pipeline_output_path="$PIPELINE_OUTPUT_DIR/$pipeline_output_name" + + echo -e "${YELLOW}[$counter/$total_pipeline_files] Processing: $base_name${NC}" + + # Run polygeist-opt command with affine-parallelize then the pipeline + pipeline_cmd="polygeist-opt --affine-parallelize --raise-affine-to-linalg-pipeline \"$mlir_file\" -o \"$pipeline_output_path\"" + + echo -e "${NC}Running: $pipeline_cmd${NC}" + echo "Running: $pipeline_cmd" >> "$LOG_FILE" + + if eval "$pipeline_cmd" 2>> "$LOG_FILE"; then + echo -e "${GREEN} ✓ Success: $pipeline_output_name${NC}" + pipeline_success_count=$((pipeline_success_count + 1)) + echo "SUCCESS: $base_name -> $pipeline_output_name" >> "$LOG_FILE" + else + echo -e "${RED} ✗ Error processing: $base_name${NC}" + pipeline_error_count=$((pipeline_error_count + 1)) + echo "ERROR: Failed to process $base_name with polygeist-opt --affine-parallelize --raise-affine-to-linalg-pipeline" >> "$LOG_FILE" + fi + + echo "" >> "$LOG_FILE" # Add blank line for readability + done + fi + + # Phase 5 Summary + echo -e "\n${PURPLE}=== PHASE 5 SUMMARY ===${NC}" + echo -e "${GREEN}Total MLIR files processed: $total_pipeline_files${NC}" + echo -e "${GREEN}Successful: $pipeline_success_count${NC}" + echo -e "${RED}Errors: $pipeline_error_count${NC}" + + echo "Phase 5 completed at $(date)" >> "$LOG_FILE" +fi + +# ====== FINAL SUMMARY ====== +echo -e "\n${PURPLE}=== FINAL SUMMARY ===${NC}" + +if [ "$MODE" -eq 0 ] || [ "$MODE" -eq 1 ]; then + echo -e "${BLUE}Phase 1 (cgeist):${NC}" + echo -e "${GREEN} Total C files processed: $total_files${NC}" + echo -e "${GREEN} Successful: $success_count${NC}" + echo -e "${RED} Errors: $error_count${NC}" +fi + +if [ "$MODE" -eq 0 ] || [ "$MODE" -eq 2 ]; then + echo -e "${BLUE}Phase 2 (raise-affine-to-linalg):${NC}" + echo -e "${GREEN} Total MLIR files processed: $total_mlir_files${NC}" + echo -e "${GREEN} Successful: $linalg_success_count${NC}" + echo -e "${RED} Errors: $linalg_error_count${NC}" +fi + +if [ "$MODE" -eq 0 ] || [ "$MODE" -eq 3 ]; then + echo -e "${BLUE}Phase 3 (canonicalize):${NC}" + echo -e "${GREEN} Total linalg files processed: $total_canonicalize_files${NC}" + echo -e "${GREEN} Successful: $canonicalize_success_count${NC}" + echo -e "${RED} Errors: $canonicalize_error_count${NC}" +fi + +if [ "$MODE" -eq 0 ] || [ "$MODE" -eq 4 ]; then + echo -e "${BLUE}Phase 4 (linalg-debufferize):${NC}" + echo -e "${GREEN} Total canonicalized files processed: $total_debufferized_files${NC}" + echo -e "${GREEN} Successful: $debufferized_success_count${NC}" + echo -e "${RED} Errors: $debufferized_error_count${NC}" +fi + +if [ "$MODE" -eq 5 ]; then + echo -e "${BLUE}Phase 5 (affine-parallelize + raise-affine-to-linalg-pipeline):${NC}" + echo -e "${GREEN} Total MLIR files processed: $total_pipeline_files${NC}" + echo -e "${GREEN} Successful: $pipeline_success_count${NC}" + echo -e "${RED} Errors: $pipeline_error_count${NC}" +fi + +echo -e "${YELLOW}Output directories:${NC}" +echo -e "${YELLOW} Intermediate files: $OUTPUT_DIR${NC}" +echo -e "${YELLOW} Linalg files: $LINALG_OUTPUT_DIR${NC}" +echo -e "${YELLOW} Canonicalized files: $CANONICALIZE_OUTPUT_DIR${NC}" +echo -e "${YELLOW} debufferized files: $debufferizeD_OUTPUT_DIR${NC}" +echo -e "${YELLOW} Pipeline files: $PIPELINE_OUTPUT_DIR${NC}" +echo -e "${YELLOW} Log file: $LOG_FILE${NC}" + +echo "Run completed at $(date)" >> "$LOG_FILE" + +# Determine exit code +total_errors=$((error_count + linalg_error_count + canonicalize_error_count + debufferized_error_count + pipeline_error_count)) +if [ $total_errors -eq 0 ]; then + echo -e "${GREEN}All files processed successfully!${NC}" + exit 0 +else + echo -e "${RED}Some files failed to process. Check $LOG_FILE for details.${NC}" + echo -e "${RED}Total errors: $total_errors${NC}" + exit 1 +fi \ No newline at end of file diff --git a/runtime/CROSS_COMPILE.md b/runtime/CROSS_COMPILE.md new file mode 100644 index 000000000000..63a4aa595a4a --- /dev/null +++ b/runtime/CROSS_COMPILE.md @@ -0,0 +1,157 @@ +# Cross-compiling for Jetson Orin (aarch64 + CUDA) from this x86_64 VM + +## Goal + +Take a kernel.launch-matched MLIR module, lower it through Phase-2 ABI +(`--lower-kernel-launch-to-cublas`) here on the x86_64 dev VM, and produce an +aarch64 ELF binary that: + +1. Calls `polygeist_cublas_dgemm` (our runtime shim). +2. Calls into `libcublas.so` / `libcudart.so` on the target Jetson at runtime. + +The Jetson does *not* need Polygeist, MLIR, or `nvcc` — only the CUDA runtime +libs that JetPack already ships at `/usr/local/cuda/lib64`. + +## What was installed on this VM (2026-05-23) + +| Package | Version | Purpose | Disk | +|---|---|---|---| +| `gcc-aarch64-linux-gnu` | 11.4.0 (Ubuntu 22.04) | aarch64 C cross-compiler + libc sysroot at `/usr/aarch64-linux-gnu/` | ~50 MB | +| `g++-aarch64-linux-gnu` | 11.4.0 | aarch64 C++ cross-compiler (mostly for consistency; we don't use C++ in the shim) | included | +| `binutils-aarch64-linux-gnu` | 2.38 | `ld`, `as`, `readelf` for aarch64 | included | +| `libc6-dev-arm64-cross` | latest | aarch64 libc headers + static libs | included | +| **CUDA cross-sbsa toolkit, 12.6** | 12.6.4.1 | aarch64 (SBSA-ABI) headers + link-time stub libs for `cudart` + `cuBLAS`. Installs to `/usr/local/cuda-12.6/targets/sbsa-linux/{include,lib}`. | ~850 MB | +| └ `cuda-cudart-cross-sbsa-12-6` | 12.6.77 | `cudaMalloc`, `cudaMemcpy`, `cudaFree`, … | (part of above) | +| └ `libcublas-cross-sbsa-12-6` | 12.6.4.1 | `cublasDgemm`, `cublasCreate`, … | (part of above) | +| └ `cuda-nvcc-cross-sbsa-12-6` | 12.6.77 | NOT used to compile — installed only because `cuda_runtime_api.h` `#include`s `crt/host_config.h` which lives in this package | (part of above) | +| └ `cuda-driver-cross-sbsa-12-6` | 12.6.77 | Pulled in transitively; we don't call the driver API directly | (part of above) | +| └ `cuda-cccl-cross-sbsa-12-6` | 12.6.77 | Pulled in transitively (CUDA C++ Core Libraries — unused for us) | (part of above) | + +**Total disk footprint:** ~911 MB (`/usr/aarch64-linux-gnu` + `/usr/local/cuda-12.6`). + +### Why SBSA and not L4T? + +NVIDIA distributes two aarch64 CUDA flavours: + +- **L4T (Linux for Tegra)** — what JetPack installs on the Jetson itself. + No standalone cross-compile apt repo; normally set up via SDK Manager. +- **SBSA (Server Base System Architecture)** — datacenter aarch64 + (Grace, Hopper, etc.). NVIDIA ships a clean apt repo for x86 → SBSA + cross-compile at + `https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/cross-linux-sbsa/`. + +The cuBLAS + cuRT *API surface* and ABI are identical between L4T and SBSA +at runtime — both are 64-bit ARM Linux, same calling convention, same library +layout. So a binary cross-built against SBSA stubs and shipped to a Jetson +will resolve its `libcublas.so.12` / `libcudart.so.12` against JetPack's L4T +copies at load time and work correctly. + +### Why also install `gcc-aarch64-linux-gnu` if Polygeist's clang already targets aarch64? + +Polygeist's clang knows the aarch64 ISA, but doesn't ship a sysroot (libc, +crt files, libgcc). Using `aarch64-linux-gnu-gcc` as the driver is the +simpler path — it picks up Ubuntu's cross sysroot at `/usr/aarch64-linux-gnu` +automatically. The build scripts below use gcc as the driver for C files and +only invoke clang to compile the `.ll` produced by `mlir-translate`. + +### Adding the NVIDIA repo (what was done) + +```bash +wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb +sudo dpkg -i cuda-keyring_1.1-1_all.deb + +echo 'deb [signed-by=/usr/share/keyrings/cuda-archive-keyring.gpg] https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/cross-linux-sbsa/ /' \ + | sudo tee /etc/apt/sources.list.d/cuda-cross-sbsa.list + +sudo apt update +sudo apt install -y --no-install-recommends \ + gcc-aarch64-linux-gnu g++-aarch64-linux-gnu \ + binutils-aarch64-linux-gnu libc6-dev-arm64-cross \ + cuda-cudart-cross-sbsa-12-6 \ + libcublas-cross-sbsa-12-6 \ + cuda-nvcc-cross-sbsa-12-6 # ← needed for crt/host_*.h headers +``` + +(`shim-signed` may fail to configure during install — that's a UEFI +bootloader package unrelated to CUDA; ignore the dpkg error.) + +## How to cross-compile a kernel binary + +The end-to-end recipe lives in `scripts/correctness/build_jetson.sh` (with a +local-build variant in `scripts/correctness/gemm_cublas_e2e.sh`). The key +flags: + +```bash +# 1. Lower MLIR to LLVM IR (host-side, this VM) +mlir-opt --one-shot-bufferize=bufferize-function-boundaries \ + --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \ + --convert-arith-to-llvm --finalize-memref-to-llvm \ + --convert-func-to-llvm --reconcile-unrealized-casts \ + gemm_abi.mlir -o gemm_llvm.mlir +mlir-translate --mlir-to-llvmir gemm_llvm.mlir -o gemm.ll + +# 2. Rewrite the .ll's target triple from x86 → aarch64-linux-gnu +sed -i 's|target triple = "x86_64.*"|target triple = "aarch64-linux-gnu"|' gemm.ll +sed -i '/^target datalayout/d' gemm.ll # let clang re-derive it for aarch64 + +# 3. Compile the .ll for aarch64 (clang's aarch64 backend) +CUDA=/usr/local/cuda-12.6/targets/sbsa-linux +clang --target=aarch64-linux-gnu \ + --gcc-toolchain=/usr \ + -O3 -c gemm.ll -o gemm_kernel.o + +# 4. Cross-compile the runtime shim +aarch64-linux-gnu-gcc -O3 -c \ + -I$CUDA/include \ + runtime/polygeist_cublas_rt_cuda.c \ + -o polygeist_cublas_rt.o + +# 5. Link everything against the aarch64 cuBLAS / cudart stubs +aarch64-linux-gnu-gcc -O2 \ + gemm_kernel.o polygeist_cublas_rt.o .o \ + -L$CUDA/lib -L$CUDA/lib/stubs \ + -lcublas -lcudart -lm \ + -Wl,-rpath,/usr/local/cuda/lib64 \ + -o gemm_jetson +``` + +The resulting binary: + +- ELF 64-bit, ARM aarch64. +- `DT_NEEDED`: `libcublas.so.12`, `libcudart.so.12`, `libc.so.6`, + `ld-linux-aarch64.so.1`. +- `RUNPATH`: `/usr/local/cuda/lib64` (matches the Jetson's JetPack layout). + +scp to the Jetson, `chmod +x`, run — no additional Polygeist or MLIR install +needed on the target. + +## Smoke tests done (`/tmp/cross_smoke/`) + +| Test | What it proves | +|---|---| +| `hello_aarch64` (gcc) | aarch64 sysroot + binutils work end-to-end | +| `hello_clang_aarch64` | Clang's aarch64 backend + `--gcc-toolchain=/usr` work | +| `tiny_cuda2_aarch64` | Cross-link against `libcudart.so` stub succeeds | +| `tiny_cublas_aarch64` | Cross-link against `libcublas.so` stub succeeds | +| `tiny_polygeist_aarch64` | Our actual `polygeist_cublas_rt_cuda.c` cross-compiles cleanly and links into a tiny driver that calls `polygeist_cublas_dgemm` | + +All produce ELF aarch64 binaries with the expected `DT_NEEDED` and +`RUNPATH=/usr/local/cuda/lib64`. None can be executed on the x86 VM (wrong +arch); they're for deployment to the Jetson. + +## What's *not* on this VM (and doesn't need to be) + +- `nvcc` (host) — we never compile `.cu` files. +- libcublas / libcudart for x86_64 — we don't run CUDA locally; the CPU + stub at `runtime/polygeist_cublas_rt_cpu.c` covers local validation. +- A working CUDA driver — needed at runtime on the Jetson, not at build + time on this VM. +- L4T-specific cross-compile env — SBSA is a strict superset of what + JetPack ships at the BLAS/RT API surface, so we don't need it. + +## Updating to a different CUDA version + +If the Jetson is on a different CUDA major (e.g. 11.4 from JetPack 5.x, or +12.x where x ≠ 6), `apt install` the matching `*-cross-sbsa-XX-Y` packages +and update the `CUDA=` line in the build script. The cross-sbsa repo has +11-7 through 12-9 currently. diff --git a/runtime/polygeist_cublas_rt.h b/runtime/polygeist_cublas_rt.h new file mode 100644 index 000000000000..00340ec6a7b6 --- /dev/null +++ b/runtime/polygeist_cublas_rt.h @@ -0,0 +1,593 @@ +// polygeist_cublas_rt.h — runtime shim ABI for the +// `--lower-kernel-launch-to-cublas` pass. +// +// The pass emits `func.call` ops targeting these C functions. The functions +// are implemented in two flavours: +// * polygeist_cublas_rt_cpu.c — CPU implementation (no CUDA). Reference +// loops by default, or optimized CBLAS for +// BLAS-like symbols when compiled with +// POLYGEIST_CPU_USE_CBLAS. +// * polygeist_cublas_rt_cuda.c — real cuBLAS implementation. Used on +// Jetson / x86 + NVIDIA GPU. +// Link exactly one of them into the executable. +// +// All matrices are ROW-MAJOR f64. Leading dimensions are in elements +// (not bytes). The CUDA backend internally does the row↔col-major dance +// (compute Cᵀ = BᵀAᵀ via operand swap) so callers can stay row-major. +// +// Sizes are passed as int32_t because that matches cuBLAS's signature. + +#ifndef POLYGEIST_CUBLAS_RT_H +#define POLYGEIST_CUBLAS_RT_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Lifecycle. Call init() once before any kernel calls; destroy() at exit. +// On CPU these are no-ops; on CUDA they create a cublasHandle_t + stream. +void polygeist_cublas_init(void); +void polygeist_cublas_destroy(void); + +// Pipeline scope. The compiler inserts these around a group/function containing +// lowered library calls. They are currently conservative hooks: CPU is a no-op, +// CUDA initializes the backend on begin and synchronizes at outermost end. +// Future runtime cache/device-residency policies should hang off this scope +// instead of changing every per-kernel shim ABI. +void polygeist_cublas_pipeline_begin(void); +void polygeist_cublas_pipeline_end(void); + +// GEMM (cublasDgemm equivalent, row-major): +// C = alpha * A * B + beta * C +// where A is MxK, B is KxN, C is MxN. +// +// For non-transposed inputs at row-major: +// lda = K, ldb = N, ldc = N. +// +// On CUDA: copies A/B/C H→D, calls cublasDgemm with operand swap to handle +// the row→col-major transpose, copies C D→H, frees device buffers. Each call +// is fully synchronous; device-residency hoisting is a follow-up. +void polygeist_cublas_dgemm( + int32_t M, int32_t N, int32_t K, + double alpha, + const double *A, int32_t lda, + const double *B, int32_t ldb, + double beta, + double *C, int32_t ldc); + +void polygeist_cublas_sgemm( + int32_t M, int32_t N, int32_t K, + float alpha, + const float *A, int32_t lda, + const float *B, int32_t ldb, + float beta, + float *C, int32_t ldc); + +// C[batch,M,N] = A[batch,M,K] * B[K,N]. B is broadcast across batches; +// the CUDA implementation uses a zero RHS batch stride and beta=0. +void polygeist_cublas_sgemm_strided_batched_broadcast_rhs( + int32_t batch, int32_t M, int32_t N, int32_t K, + const float *A, const float *B, float *C); + +// Overwriting outer product C[M,N] = u[M] * v[N]. +void polygeist_cublas_dgemm_outer_product( + int32_t M, int32_t N, + const double *u, const double *v, double *C); + +// Single-batch, multi-channel valid Conv3D in contiguous NCDHW/OIDHW layout. +// bias may be NULL; otherwise it contains one value per output channel. +void polygeist_cudnn_conv3d_channels_f32( + int32_t IC, int32_t inD, int32_t inH, int32_t inW, + int32_t OC, int32_t kD, int32_t kH, int32_t kW, + const float *input, const float *filter, const float *bias, float *output); + +void polygeist_cublas_dgemv( + int32_t M, int32_t N, + double alpha, + const double *A, int32_t lda, + const double *x, + double beta, + double *y); + +void polygeist_cublas_dgemv_T( + int32_t M, int32_t N, + double alpha, + const double *A, int32_t lda, + const double *x, + double beta, + double *y); + +void polygeist_cublas_sgemv( + int32_t M, int32_t N, + float alpha, + const float *A, int32_t lda, + const float *x, + float beta, + float *y); + +void polygeist_cublas_sgemv_T( + int32_t M, int32_t N, + float alpha, + const float *A, int32_t lda, + const float *x, + float beta, + float *y); + +// FP32 variant of memset_zero_2d. +void polygeist_cublas_memset_zero_2d_f32( + int32_t M, int32_t N, float *A, int32_t lda); + +void polygeist_cublas_memset_zero_1d_f32(int32_t N, float *v); + +// memset a 2D row-major MxN block to zero. Used by matcher's +// @memset_zero_2D op. Trivial host-side memset; data is host-resident +// between launches in the current no-hoisting model. +void polygeist_cublas_memset_zero_2d( + int32_t M, int32_t N, double *A, int32_t lda); + +// In-place 2D scale: A = scale * A, row-major MxN with leading dim lda. +// Used by matcher's @cublasDgeam_scale2D op (the diagonal/scale-only +// variant of geam where the second operand is zero so the add collapses +// to a scale). CUDA backend uses cublasDscal on the flattened buffer +// when contiguous (lda==N), else loops row-wise. +void polygeist_cublas_dscal_2d( + int32_t M, int32_t N, double scale, double *A, int32_t lda); + +// cuDNN 9-tap conv2d (3x3 stencil) with PolyBench's hardcoded weights. +// Input A is MxN row-major f64; output B is MxN row-major f64; the +// interior B[1..M-2][1..N-2] is filled with the convolved result, +// border rows/cols are untouched. CUDA backend calls cudnnConvolutionForward +// with a 1×1×M×N input descriptor and a 1×1×3×3 filter descriptor. +// CPU stub does the same math in a 3-loop reference for validation. +// +// Weights baked in (matches polybenchGpu/OpenMP/stencils/convolution-2d/): +// [[ 0.2, 0.5, -0.8], +// [-0.3, 0.6, -0.9], +// [ 0.4, 0.7, 0.1]] +// +// Generalising the weights to arbitrary filter coefficients is a TODO +// once the matcher surfaces the 9 scalar weights as launch operands. +void polygeist_cudnn_conv2d_polybench9tap( + int32_t M, int32_t N, const double *A, double *B); + +// Generic 3x3 conv2d shim — takes the 9 filter weights at runtime so a +// single shim handles any 3x3 weighted conv (polybench, Sobel, Gaussian, +// custom filters). Same I/O contract as the polybench9tap variant: +// * A is MxN row-major f64, input +// * B is MxN row-major f64, output; interior B[1..M-2][1..N-2] written +// * Weights laid out row-major in the 3x3 filter: +// w[0] w[1] w[2] <- top row, applied to A[i-1][j-1..j+1] +// w[3] w[4] w[5] <- middle row, applied to A[i][j-1..j+1] +// w[6] w[7] w[8] <- bottom row, applied to A[i+1][j-1..j+1] +// +// Used by Lit-surfaced @cudnnConvolution2D_9tap match: the matcher pulls +// the 9 weight values out of the linalg.generic body and passes them as +// launch operands, the lowering pass forwards them here. +void polygeist_cudnn_conv2d_3x3_f64( + int32_t M, int32_t N, + double w0, double w1, double w2, + double w3, double w4, double w5, + double w6, double w7, double w8, + const double *A, double *B); + +// FP32 variant of polygeist_cudnn_conv2d_3x3 — same I/O contract but with +// float matrices + float weights. cuDNN's convolution path picks tensor-core +// kernels for FP32 on Ampere+ GPUs (including Jetson Orin), so this is the +// dtype to use for actual perf measurement (FP64 on Orin uses a generic +// non-tensor-core path). +void polygeist_cudnn_conv2d_3x3_f32( + int32_t M, int32_t N, + float w0, float w1, float w2, + float w3, float w4, float w5, + float w6, float w7, float w8, + const float *A, float *B); + +// Generic 5x5 conv2d shim. The lowering passes a pointer to the top-left +// input subview and a pointer to the output interior subview B[2][2], so the +// shim writes a dense (M-4)x(N-4) block relative to B with row stride N. +void polygeist_cudnn_conv2d_5x5_f64( + int32_t M, int32_t N, + double w0, double w1, double w2, double w3, double w4, + double w5, double w6, double w7, double w8, double w9, + double w10, double w11, double w12, double w13, double w14, + double w15, double w16, double w17, double w18, double w19, + double w20, double w21, double w22, double w23, double w24, + const double *A, double *B); + +void polygeist_cudnn_conv2d_5x5_f32( + int32_t M, int32_t N, + float w0, float w1, float w2, float w3, float w4, + float w5, float w6, float w7, float w8, float w9, + float w10, float w11, float w12, float w13, float w14, + float w15, float w16, float w17, float w18, float w19, + float w20, float w21, float w22, float w23, float w24, + const float *A, float *B); + +// Generalized packed-weight odd-square Conv2D stencil. K is the filter width; +// W has K*K row-major weights. A points at the top-left input subview and B +// points at the output interior subview. +void polygeist_cudnn_conv2d_ntap_f64( + int32_t M, int32_t N, int32_t K, + const double *W, const double *A, double *B); + +void polygeist_cudnn_conv2d_ntap_f32( + int32_t M, int32_t N, int32_t K, + const float *W, const float *A, float *B); + +// Generalized packed-weight Conv3D stencil. A is dense input with dimensions +// inD x inH x inW, B is dense output with dimensions outD x outH x outW, and +// W is a row-major K x K x K cross-correlation filter. +void polygeist_cudnn_conv3d_ntap_f64( + int32_t inD, int32_t inH, int32_t inW, + int32_t outD, int32_t outH, int32_t outW, + int32_t K, + const double *W, const double *A, double *B); + +void polygeist_cudnn_conv3d_ntap_f32( + int32_t inD, int32_t inH, int32_t inW, + int32_t outD, int32_t outH, int32_t outW, + int32_t K, + const float *W, const float *A, float *B); + +// Custom structured 3D 7-point stencil over seven flattened tap tensors. +// `extra` and `coeff` may be NULL. The computation is: +// base = base0 * a0 + base_extra * extra +// inner = c0*a0 + c1*a1 + ... + c6*a6 + coeff_extra * extra +// out = base + (coeff ? coeff[i] : 1) * inner +void polygeist_custom_stencil3d_7pt_flat_f64( + int32_t N, + const double *a0, const double *a1, const double *a2, + const double *a3, const double *a4, const double *a5, + const double *a6, const double *extra, const double *coeff, + double *out, + double base0, double base_extra, double coeff_extra, + double c0, double c1, double c2, double c3, + double c4, double c5, double c6); + +void polygeist_custom_stencil3d_7pt_flat_f32( + int32_t N, + const float *a0, const float *a1, const float *a2, + const float *a3, const float *a4, const float *a5, + const float *a6, const float *extra, const float *coeff, + float *out, + float base0, float base_extra, float coeff_extra, + float c0, float c1, float c2, float c3, + float c4, float c5, float c6); + +// Basic 1D complex-to-complex FFT shims. Complex values are represented as +// interleaved real/imag pairs: A[2*i+0], A[2*i+1]. `inverse != 0` selects the +// inverse transform. Like cuFFT, the inverse is not normalized by N. +void polygeist_cufft_z2z_1d( + int32_t N, int32_t inverse, const double *A, double *B); + +void polygeist_cufft_c2c_1d( + int32_t N, int32_t inverse, const float *A, float *B); + +// Separable 3D tensor product, expressed to cuTensorNet as +// ai,bj,ck,ijk->abc. psi is row-major [KQ,KP], u is [KP,KP,KP], and out is +// [KQ,KQ,KQ]. +void polygeist_cutensornet_tensor_product_3d_f32( + int32_t KQ, int32_t KP, const float *psi, const float *u, float *out); + +void polygeist_cutensornet_tensor_product_3d_f64( + int32_t KQ, int32_t KP, const double *psi, const double *u, double *out); + +// General two-input FP64 Einstein contraction used by normalized MFEM stages. +// `metadata` contains three ranks followed by extent/stride/mode arrays for +// A, B, and C; see LowerKernelLaunchToCuBLAS.cpp for the fixed 579-element +// layout (64 modes per tensor). Broadcast modes are omitted before this ABI +// is called. +void polygeist_cutensornet_contraction2_f64( + const double *A, const double *B, double *C, const int64_t *metadata); + +// Device-resident form of the same contraction. A/B/C must be CUDA device +// pointers; no host registration or mapping is performed. This entry point is +// legal only for compiler regions with no residual host dereferences. +void polygeist_cutensornet_contraction2_f64_device( + const double *A, const double *B, double *C, const int64_t *metadata); + +// FP16 / BF16 variants. The shim args use compiler-provided half-precision +// types (`_Float16` for IEEE half, `__bf16` for brain-float) because MLIR's +// `f16` / `bf16` lower to LLVM `half` / `bfloat` and use the FP-register ABI +// on both x86-64 (XMM) and aarch64 (V regs). Passing them via uint16_t would +// route through GP regs and corrupt the call. +// * f16 → CUDNN_DATA_HALF (cuDNN tensor-core path on Ampere+) +// * bf16 → CUDNN_DATA_BFLOAT16 (tensor-core path on Ampere+) +// Guarded on compiler-defined feature macros: __FLT16_MAX__ for `_Float16` +// and __BFLT16_MAX__ for `__bf16`. Both are defined unconditionally on +// aarch64 (Jetson) and on x86-64 when the appropriate -m flags are set +// (-mavx512fp16 / -mavx512bf16). If a build target lacks the macro the +// declaration is skipped — callers can't accidentally link to a missing +// symbol because the shim implementation file is guarded the same way. +#if defined(__FLT16_MAX__) +void polygeist_cudnn_conv2d_3x3_f16( + int32_t M, int32_t N, + _Float16 w0, _Float16 w1, _Float16 w2, + _Float16 w3, _Float16 w4, _Float16 w5, + _Float16 w6, _Float16 w7, _Float16 w8, + const _Float16 *A, _Float16 *B); +#endif + +#if defined(__BFLT16_MAX__) || defined(__ARM_FEATURE_BF16) || \ + defined(__ARM_FEATURE_BF16_SCALAR_ARITHMETIC) || defined(__BF16__) +void polygeist_cudnn_conv2d_3x3_bf16( + int32_t M, int32_t N, + __bf16 w0, __bf16 w1, __bf16 w2, + __bf16 w3, __bf16 w4, __bf16 w5, + __bf16 w6, __bf16 w7, __bf16 w8, + const __bf16 *A, __bf16 *B); +#endif + +// INT32 / INT16 variants. +// +// IMPORTANT: cuDNN does NOT support a standalone INT32 forward convolution +// (`cudnnSetTensor4dDescriptor` with CUDNN_DATA_INT32 returns BAD_PARAM on +// Orin/Ampere). CUDNN_DATA_INT32 is only exposed as the accumulator type +// for INT8 inputs via the bias+activation API — a different operand +// layout. Consequently the CUDA backend's i32 / i16 shims intentionally +// fail at the cuDNN descriptor call: they exist so the matcher / +// rewriter / ABI-lowering pipeline can be exercised end-to-end (the +// `func.call @polygeist_cudnn_conv2d_3x3_i32` will land), but the GPU +// side is "not implemented" until a custom CUDA kernel is added. +// +// The CPU backend's i32 / i16 implementations are real reference loops; +// use the CPU stub for correctness validation of int conv stencils. +void polygeist_cudnn_conv2d_3x3_i32( + int32_t M, int32_t N, + int32_t w0, int32_t w1, int32_t w2, + int32_t w3, int32_t w4, int32_t w5, + int32_t w6, int32_t w7, int32_t w8, + const int32_t *A, int32_t *B); + +void polygeist_cudnn_conv2d_3x3_i16( + int32_t M, int32_t N, + int16_t w0, int16_t w1, int16_t w2, + int16_t w3, int16_t w4, int16_t w5, + int16_t w6, int16_t w7, int16_t w8, + const int16_t *A, int16_t *B); + +// PVA-routed INT8 / INT16 conv (NEW path; replaces the failing-cuDNN i8/i16 +// shims for the lowering). Same I/O contract as the cuDNN 3x3 shims: +// - A, B are MxN row-major buffers of int8_t / int16_t +// - Interior B[1..M-2][1..N-2] gets the convolved result; borders left untouched +// Routes via PVA Solutions' pvaConv2d through libpva_operator.so on the Jetson. +// PVA's conv supports kernel 3x3/5x5/7x7, single-channel, integer 8/16-bit, +// with an internal wider accumulator + output narrowing. CPU stub does a +// reference loop with int32 accumulator and narrowing-with-wrap on +// store (matches PVA's behaviour for our polybench-scaled weights since +// the per-pixel sum stays in narrow-int range). +void polygeist_pva_conv2d_3x3_i8( + int32_t M, int32_t N, + int8_t w0, int8_t w1, int8_t w2, + int8_t w3, int8_t w4, int8_t w5, + int8_t w6, int8_t w7, int8_t w8, + const int8_t *A, int8_t *B); + +void polygeist_pva_conv2d_3x3_i16( + int32_t M, int32_t N, + int16_t w0, int16_t w1, int16_t w2, + int16_t w3, int16_t w4, int16_t w5, + int16_t w6, int16_t w7, int16_t w8, + const int16_t *A, int16_t *B); + +// BoxFilter — uniform-weight K×K filter. Single-channel signed 8/16-bit on +// PVA via libpva_operator's pvaBoxFilter{Create,Submit}. No coefficient +// tensor (the filter is implicitly 1/K² everywhere). REPLICATE border. +// Output saturates to dtype range. M/N are full image dims; the shim +// writes a (M-2)×(N-2) interior to caller-supplied B starting at &B[1][1] +// (same pointer-shift convention the matcher uses for conv2d). +void polygeist_pva_boxfilter_3x3_i8(int32_t M, int32_t N, + const int8_t *A, int8_t *B); +void polygeist_pva_boxfilter_3x3_i16(int32_t M, int32_t N, + const int16_t *A, int16_t *B); + +// GaussianFilter — separable Gaussian via PVA's pvaGaussianFilter. The +// hardware takes (sigmaX, sigmaY, kernelSize) parameters; for the v0 +// integration we hardcode kernelSize=3 and sigmaX=sigmaY=1.0 (the natural +// 3×3 Gaussian). Surfacing sigma as launch operands is future work; the +// matcher would need to recognize Gaussian-weighted convs and route here +// instead of to OpConv2d. +void polygeist_pva_gaussian_3x3_i8(int32_t M, int32_t N, + const int8_t *A, int8_t *B); +void polygeist_pva_gaussian_3x3_i16(int32_t M, int32_t N, + const int16_t *A, int16_t *B); + +// BilateralFilter — edge-preserving smoothing. PVA's pvaBilateralFilter +// hardcodes sigmaRange=25.0 / sigmaSpace=10.0 (typical edge-preserving +// parameters) for v0. CPU stub is approximate (matches PVA within a few +// LSBs on typical-content images; bilateral is non-linear so bit-exact +// match is impractical to model without the full PVA fixed-point spec). +// Validation strategy: PVA must run cleanly + output must be in-range. +void polygeist_pva_bilateral_3x3_i8(int32_t M, int32_t N, + const int8_t *A, int8_t *B); +void polygeist_pva_bilateral_3x3_i16(int32_t M, int32_t N, + const int16_t *A, int16_t *B); + +// HistogramEqualization — U8-only on PVA; we reinterpret i8 bytes as u8 +// (bitwise identical) for the shim's tensor allocation. +void polygeist_pva_histeq_i8(int32_t M, int32_t N, + const int8_t *A, int8_t *B); + +// ============================================================================ +// Extracted-darknet batched CNN-block primitives. All four take 4D NCHW +// tensors (and 1D per-channel vectors for batchnorm) as raw FP32 pointers +// plus the shape parameters. The CUDA backend wires each to its +// corresponding cuDNN forward call; the CPU stub runs a reference loop +// for correctness validation. +// +// These cover every primitive in a ResNet residual block except ReLU: +// conv + bn + (relu) + conv + bn + add. +// ============================================================================ + +// Batched multi-channel 2D convolution (forward, NCHW, FP32): +// Out[b,oc,oh,ow] = sum_{ic,kh,kw} A[b,ic,oh+kh,ow+kw] * F[oc,ic,kh,kw] +// No padding, stride 1, no dilation, no activation. K is the (square) +// filter size, OH = H - K + 1, OW = W - K + 1. +void polygeist_cudnn_conv2d_batched( + int32_t B, int32_t IC, int32_t OC, + int32_t H, int32_t W, int32_t K, + const float *A, const float *F, float *Out); + +// Darknet-style explicit im2col + GEMM fused to one convolution. Single +// batch, NCHW, FP32. Supports caller-supplied square kernel, stride, and pad. +void polygeist_cudnn_conv2d_im2col_gemm_f32( + int32_t IC, int32_t H, int32_t W, int32_t OC, + int32_t K, int32_t S, int32_t P, + const float *A, const float *F, float *Out); + +// Batched multi-channel 2D max pooling (forward, NCHW, FP32). +// Window size K and stride S are derived from H/OH (assumed K == stride +// for the common ResNet shapes; tweak the shim if needed). OH and OW are +// the output spatial dims after pooling. +void polygeist_cudnn_maxpool_batched( + int32_t B, int32_t C, int32_t H, int32_t W, int32_t OH, int32_t OW, + const float *A, float *Out); + +// Batched per-channel batch normalization (INFERENCE mode, NCHW, FP32): +// Out[b,c,h,w] = scale[c] * (A[b,c,h,w] - mean[c]) * inv_std[c] + bias[c] +// where inv_std[c] = 1/sqrt(var[c] + eps) is pre-computed by the caller. +// The CUDA backend uses cudnnBatchNormalizationForwardInference (which +// expects mean + variance, not inv_std). The shim recovers variance via +// var = 1/inv_std² - eps_assumed (eps_assumed = 1e-5). +// This is an inversion of the kernel's pre-baked inv_std; the caller +// must use the same eps when building inv_std for bit-exact output. +void polygeist_cudnn_batchnorm_inference( + int32_t B, int32_t C, int32_t H, int32_t W, + const float *A, + const float *scale, const float *mean, + const float *inv_std, const float *bias, + float *Out); + +// Batched 4D elementwise tensor add (ResNet residual shortcut, FP32): +// Out[b,c,h,w] += A[b,c,h,w] +// The CUDA backend uses cudnnAddTensor with α=β=1. +void polygeist_cudnn_add_tensor_batched( + int32_t B, int32_t C, int32_t H, int32_t W, + const float *A, float *Out); + +// 1×1 conv via batched gemm. Mathematically: +// C[b, oc, h, w] = sum_ic A[b, ic, h, w] * F[oc, ic, 0, 0] +// +// Since NCHW packs IC-contiguous H*W planes, A[b] is naturally a 2D +// matrix of shape (IC, H*W) (row-major). Per batch: +// C[b] (OC, H*W) = F (OC, IC) × A[b] (IC, H*W) +// → cublasSgemmStridedBatched with batchCount=B, F shared (stride 0), +// A and C strided by IC*H*W and OC*H*W respectively. Hits tensor cores +// on Orin for IC, OC, H*W aligned to 8. +// +// The signature takes M = B*H*W (flattened parallel dims), N = OC, +// K = IC. The harness/lowering passes B*H*W as M; the shim recovers +// B and H*W via the assumption that A is contiguous NCHW (which the +// row-major layout guarantees for a single 1×1 conv). +void polygeist_cublas_sgemm_1x1conv( + int32_t B, int32_t IC, int32_t OC, int32_t HW, + const float *A, const float *F, float *C); + +// Symmetric rank-K update — AᵀA or A·Aᵀ. FP32, row-major. +// C[N,N] = Aᵀ·A where A is K×N (so AᵀA is N×N, symmetric) +// Only the upper triangle of C is computed; the lower is mirrored on +// host before returning so the caller can treat C as fully populated. +// Routes to cublasSsyrk_v2 — half the flops of the equivalent gemm. +void polygeist_cublas_dsyrk( + int32_t N, int32_t K, const float *A, float *C); + +// Fused matmul + bias + relu, FP32. Computes: +// C[m,n] = relu(sum_k A[m,k] * B[k,n] + bias[n]) +// A is MxK, B is KxN, C is MxN, bias is length N (broadcast over rows). +// Routes to cublasLt's CUBLASLT_EPILOGUE_RELU_BIAS — needs -lcublasLt at link. +void polygeist_cublaslt_matmul_bias_relu( + int32_t M, int32_t N, int32_t K, + const float *A, const float *B, const float *bias, + float *C); + +// Fused conv + bias + residual-add + relu, FP32 NCHW. Computes: +// Out[b,oc,oh,ow] = relu(conv(A,F)[b,oc,oh,ow] + bias[oc] + Z[b,oc,oh,ow]) +// +// Bias is per-output-channel (length OC); Z has the same shape as Out +// and is the ResNet skip-connection input. The CUDA backend issues one +// cudnnConvolutionBiasActivationForward with α₁=1, α₂=1, activation=RELU. +void polygeist_cudnn_conv_bias_relu_add_fused( + int32_t B, int32_t IC, int32_t OC, + int32_t H, int32_t W, int32_t K, + const float *A, const float *F, + const float *bias, const float *Z, + float *Out); + +// Fused conv + bn (inference) + relu, FP32 NCHW. Computes: +// Out[b,oc,oh,ow] = relu( +// scale[oc] * (conv(A, F)[b,oc,oh,ow] - mean[oc]) * inv_std[oc] +// + bias[oc]) +// +// This is the canonical ResNet inner pattern. The CUDA backend uses the +// standard BN-folding trick — pre-compute a scaled filter and an +// effective bias on the host, then issue a single +// cudnnConvolutionBiasActivationForward call with CUDNN_ACTIVATION_RELU. +// Folded filter / bias are: +// F'[oc,ic,kh,kw] = F[oc,ic,kh,kw] * scale[oc] * inv_std[oc] +// b'[oc] = bias[oc] - scale[oc] * mean[oc] * inv_std[oc] +// With those substitutions, conv + bn-inference + relu = act(conv(F') + b'), +// which cudnnConvolutionBiasActivationForward computes natively in one +// kernel — the bandwidth-bound bn and relu ride the compute-bound conv +// instead of paying their own per-call setup. +void polygeist_cudnn_conv_bn_relu_fused( + int32_t B, int32_t IC, int32_t OC, + int32_t H, int32_t W, int32_t K, + const float *A, const float *F, + const float *scale, const float *mean, + const float *inv_std, const float *bias, + float *Out); + +// llama2.c RMSNorm, FP32: +// Out[i] = Weight[i] * X[i] * rsqrt(sum_j X[j]^2 / N + 1e-5) +void polygeist_rmsnorm_f32( + int32_t N, const float *X, const float *Weight, float *Out); +void polygeist_rmsnorm_unweighted_f32( + int32_t N, const float *X, float *Out); +void polygeist_cublas_dot_f32( + int32_t N, const float *X, const float *Y, float *Out); +void polygeist_cublas_dot_f64( + int32_t N, const double *X, const double *Y, double *Out); +void polygeist_cuda_gelu_tanh_f32( + int32_t N, const float *X, float *Out); +void polygeist_whisper_exp_shift_sum_f32( + int32_t N, const float *X, float max_val, float *Out, float *Sum); + +// llama2.c row softmax, FP32, in-place: +// X[i] = exp(X[i] - max(X)) / sum_j exp(X[j] - max(X)) +// CUDA backend routes this through cudnnSoftmaxForward. +void polygeist_cudnn_softmax_forward_f32(int32_t N, float *X); +void polygeist_cudnn_softmax_forward_out_f32( + int32_t N, const float *X, float *Out); + +// Llama standalone FP32 helpers. The CUDA backend implements these with +// CUDA-runtime copies plus cuBLAS/cuDNN tensor ops; the CPU backend is a +// reference implementation for host correctness runs. +void polygeist_cuda_copy_f32(int32_t N, const float *X, float *Out); +void polygeist_cuda_copy_strided_2d_f32( + int32_t rows, int32_t cols, + int32_t src_row_stride, int32_t src_col_stride, + int32_t dst_row_stride, int32_t dst_col_stride, + const float *X, float *Out); +void polygeist_cuda_add_f32( + int32_t N, const float *X, const float *Y, float *Out); +void polygeist_cuda_mask_select_f32( + int32_t N, int32_t pos, const float *Scores, float *Out); +void polygeist_cuda_swiglu_f32( + int32_t N, const float *Gate, const float *Up, float *Out); +void polygeist_cuda_rope_mulmul_f32( + int32_t M, int32_t N, const float *A, const float *B, + const float *C, const float *D, float *Out, int32_t add); + +// Per-call CUDA-event timing (CUDA backend only — CPU stub returns 0.0). +// Pair with polygeist_cublas_time_begin / polygeist_cublas_time_end around +// a sequence of kernel calls. +void polygeist_cublas_time_begin(void); +double polygeist_cublas_time_end_ms(void); // returns ms since last begin + +#ifdef __cplusplus +} +#endif + +#endif // POLYGEIST_CUBLAS_RT_H diff --git a/runtime/polygeist_cublas_rt_cpu.c b/runtime/polygeist_cublas_rt_cpu.c new file mode 100644 index 000000000000..917c3ae3aebf --- /dev/null +++ b/runtime/polygeist_cublas_rt_cpu.c @@ -0,0 +1,1418 @@ +// polygeist_cublas_rt_cpu.c — CPU implementation of the runtime shim ABI. +// No CUDA dependency. By default this uses reference loops for correctness +// validation. Define POLYGEIST_CPU_USE_CBLAS to route BLAS-like kernels to an +// optimized CBLAS implementation such as OpenBLAS, BLIS, MKL, ArmPL, or NVPL. + +#include "polygeist_cublas_rt.h" + +#include +#include +#include +#include + +#ifdef POLYGEIST_CPU_USE_CBLAS +#include +#endif + +#ifndef M_PI +#define M_PI 3.14159265358979323846264338327950288 +#endif + +void polygeist_cublas_init(void) { /* no-op */ } +void polygeist_cublas_destroy(void) { /* no-op */ } +void polygeist_cublas_pipeline_begin(void) { /* no-op */ } +void polygeist_cublas_pipeline_end(void) { /* no-op */ } + +void polygeist_cublas_dgemm( + int32_t M, int32_t N, int32_t K, + double alpha, + const double *A, int32_t lda, + const double *B, int32_t ldb, + double beta, + double *C, int32_t ldc) { +#ifdef POLYGEIST_CPU_USE_CBLAS + cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, M, N, K, alpha, A, + lda, B, ldb, beta, C, ldc); + return; +#endif + // C[i,j] = alpha * sum_k A[i,k] * B[k,j] + beta * C[i,j] + for (int32_t i = 0; i < M; ++i) { + for (int32_t j = 0; j < N; ++j) { + double acc = 0.0; + for (int32_t k = 0; k < K; ++k) { + acc += A[(size_t)i * (size_t)lda + (size_t)k] * + B[(size_t)k * (size_t)ldb + (size_t)j]; + } + double *c = &C[(size_t)i * (size_t)ldc + (size_t)j]; + *c = alpha * acc + beta * (*c); + } + } +} + +void polygeist_cublas_sgemm( + int32_t M, int32_t N, int32_t K, + float alpha, + const float *A, int32_t lda, + const float *B, int32_t ldb, + float beta, + float *C, int32_t ldc) { +#ifdef POLYGEIST_CPU_USE_CBLAS + cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, M, N, K, alpha, A, + lda, B, ldb, beta, C, ldc); + return; +#endif + for (int32_t i = 0; i < M; ++i) { + for (int32_t j = 0; j < N; ++j) { + float acc = 0.0f; + for (int32_t k = 0; k < K; ++k) { + acc += A[(size_t)i * (size_t)lda + (size_t)k] * + B[(size_t)k * (size_t)ldb + (size_t)j]; + } + float *c = &C[(size_t)i * (size_t)ldc + (size_t)j]; + *c = alpha * acc + beta * (*c); + } + } +} + +void polygeist_cublas_sgemm_strided_batched_broadcast_rhs( + int32_t batch, int32_t M, int32_t N, int32_t K, + const float *A, const float *B, float *C) { + for (int32_t b = 0; b < batch; ++b) { + const float *Ab = A + (size_t)b * (size_t)M * (size_t)K; + float *Cb = C + (size_t)b * (size_t)M * (size_t)N; +#ifdef POLYGEIST_CPU_USE_CBLAS + cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, + M, N, K, 1.0f, Ab, K, B, N, 0.0f, Cb, N); +#else + for (int32_t i = 0; i < M; ++i) { + for (int32_t j = 0; j < N; ++j) { + float acc = 0.0f; + for (int32_t k = 0; k < K; ++k) + acc += Ab[(size_t)i * (size_t)K + (size_t)k] * + B[(size_t)k * (size_t)N + (size_t)j]; + Cb[(size_t)i * (size_t)N + (size_t)j] = acc; + } + } +#endif + } +} + +void polygeist_cublas_dgemm_outer_product( + int32_t M, int32_t N, + const double *u, const double *v, double *C) { + for (int32_t i = 0; i < M; ++i) + for (int32_t j = 0; j < N; ++j) + C[(size_t)i * (size_t)N + (size_t)j] = u[i] * v[j]; +} + +void polygeist_cublas_memset_zero_2d(int32_t M, int32_t N, + double *A, int32_t lda) { + for (int32_t i = 0; i < M; ++i) { + double *row = &A[(size_t)i * (size_t)lda]; + for (int32_t j = 0; j < N; ++j) row[j] = 0.0; + } +} + +void polygeist_cublas_memset_zero_1d(int32_t N, double *v) { + for (int32_t i = 0; i < N; ++i) v[i] = 0.0; +} + +void polygeist_cublas_memset_zero_1d_f32(int32_t N, float *v) { + for (int32_t i = 0; i < N; ++i) v[i] = 0.0f; +} + +void polygeist_cublas_dgemv( + int32_t M, int32_t N, + double alpha, + const double *A, int32_t lda, + const double *x, + double beta, + double *y) { +#ifdef POLYGEIST_CPU_USE_CBLAS + cblas_dgemv(CblasRowMajor, CblasNoTrans, M, N, alpha, A, lda, x, 1, beta, y, + 1); + return; +#endif + // Row-major y[i] = alpha * sum_j A[i,j] * x[j] + beta * y[i] + for (int32_t i = 0; i < M; ++i) { + double acc = 0.0; + for (int32_t j = 0; j < N; ++j) + acc += A[(size_t)i * (size_t)lda + (size_t)j] * x[j]; + y[i] = alpha * acc + beta * y[i]; + } +} + +void polygeist_cublas_sgemv( + int32_t M, int32_t N, + float alpha, + const float *A, int32_t lda, + const float *x, + float beta, + float *y) { +#ifdef POLYGEIST_CPU_USE_CBLAS + cblas_sgemv(CblasRowMajor, CblasNoTrans, M, N, alpha, A, lda, x, 1, beta, y, + 1); + return; +#endif + for (int32_t i = 0; i < M; ++i) { + float acc = 0.0f; + for (int32_t j = 0; j < N; ++j) + acc += A[(size_t)i * (size_t)lda + (size_t)j] * x[j]; + y[i] = alpha * acc + beta * y[i]; + } +} + +void polygeist_cublas_daxpby(int32_t N, double alpha, const double *x, + double beta, double *y) { +#ifdef POLYGEIST_CPU_USE_CBLAS + if (x == y) { + cblas_dscal(N, alpha + beta, y, 1); + } else { + cblas_dscal(N, beta, y, 1); + cblas_daxpy(N, alpha, x, 1, y, 1); + } + return; +#endif + for (int32_t i = 0; i < N; ++i) y[i] = alpha * x[i] + beta * y[i]; +} + +void polygeist_cublas_daxpy_unit(int32_t N, const double *x, double *y) { +#ifdef POLYGEIST_CPU_USE_CBLAS + cblas_daxpy(N, 1.0, x, 1, y, 1); + return; +#endif + for (int32_t i = 0; i < N; ++i) y[i] += x[i]; +} + +void polygeist_cublas_dger_rank2(int32_t M, int32_t N, + const double *u1, const double *v1, + const double *u2, const double *v2, + double *A, int32_t lda) { +#ifdef POLYGEIST_CPU_USE_CBLAS + cblas_dger(CblasRowMajor, M, N, 1.0, u1, 1, v1, 1, A, lda); + cblas_dger(CblasRowMajor, M, N, 1.0, u2, 1, v2, 1, A, lda); + return; +#endif + for (int32_t i = 0; i < M; ++i) { + double *row = &A[(size_t)i * (size_t)lda]; + for (int32_t j = 0; j < N; ++j) + row[j] += u1[i] * v1[j] + u2[i] * v2[j]; + } +} + +void polygeist_cublas_dgemv_T( + int32_t M, int32_t N, + double alpha, + const double *A, int32_t lda, + const double *x, + double beta, + double *y) { +#ifdef POLYGEIST_CPU_USE_CBLAS + cblas_dgemv(CblasRowMajor, CblasTrans, M, N, alpha, A, lda, x, 1, beta, y, + 1); + return; +#endif + // Row-major y[j] = alpha * sum_i A[i,j] * x[i] + beta * y[j] + // (M is A's first dim = x's length; N is A's second dim = y's length) + for (int32_t j = 0; j < N; ++j) { + double acc = 0.0; + for (int32_t i = 0; i < M; ++i) + acc += A[(size_t)i * (size_t)lda + (size_t)j] * x[i]; + y[j] = alpha * acc + beta * y[j]; + } +} + +void polygeist_cublas_sgemv_T( + int32_t M, int32_t N, + float alpha, + const float *A, int32_t lda, + const float *x, + float beta, + float *y) { +#ifdef POLYGEIST_CPU_USE_CBLAS + cblas_sgemv(CblasRowMajor, CblasTrans, M, N, alpha, A, lda, x, 1, beta, y, + 1); + return; +#endif + for (int32_t j = 0; j < N; ++j) { + float acc = 0.0f; + for (int32_t i = 0; i < M; ++i) + acc += A[(size_t)i * (size_t)lda + (size_t)j] * x[i]; + y[j] = alpha * acc + beta * y[j]; + } +} + +void polygeist_cublas_dscal_2d(int32_t M, int32_t N, double scale, + double *A, int32_t lda) { +#ifdef POLYGEIST_CPU_USE_CBLAS + if (lda == N) { + cblas_dscal((int32_t)((size_t)M * (size_t)N), scale, A, 1); + } else { + for (int32_t i = 0; i < M; ++i) + cblas_dscal(N, scale, &A[(size_t)i * (size_t)lda], 1); + } + return; +#endif + for (int32_t i = 0; i < M; ++i) { + double *row = &A[(size_t)i * (size_t)lda]; + for (int32_t j = 0; j < N; ++j) row[j] *= scale; + } +} + +// Reference CPU impl of the polybench 3x3 9-tap conv2d. Same weights as the +// upstream kernel_conv2d in third_party/polybenchGpu/OpenMP/stencils/. +void polygeist_cudnn_conv2d_polybench9tap( + int32_t M, int32_t N, const double *A, double *B) { + polygeist_cudnn_conv2d_3x3_f64(M, N, + 0.2, 0.5, -0.8, + -0.3, 0.6, -0.9, + 0.4, 0.7, 0.1, + A, B); +} + +// Generic 3x3 conv2d — filter weights passed at runtime by the caller +// (the matcher surfaces them from the linalg.generic body, the lowering +// pass forwards them here). Works for polybench, Sobel, Gaussian, or any +// other 3x3 weighted conv. +void polygeist_cudnn_conv2d_3x3_f64( + int32_t M, int32_t N, + double w0, double w1, double w2, + double w3, double w4, double w5, + double w6, double w7, double w8, + const double *A, double *B) { + const double w[9] = { w0, w1, w2, w3, w4, w5, w6, w7, w8 }; + for (int32_t i = 1; i < M - 1; ++i) { + for (int32_t j = 1; j < N - 1; ++j) { + double acc = 0.0; + for (int32_t dy = -1; dy <= 1; ++dy) + for (int32_t dx = -1; dx <= 1; ++dx) + acc += w[(dy + 1) * 3 + (dx + 1)] * + A[(size_t)(i + dy) * (size_t)N + (size_t)(j + dx)]; + B[(size_t)i * (size_t)N + (size_t)j] = acc; + } + } +} + +void polygeist_cudnn_conv2d_3x3_f32( + int32_t M, int32_t N, + float w0, float w1, float w2, + float w3, float w4, float w5, + float w6, float w7, float w8, + const float *A, float *B) { + const float w[9] = { w0, w1, w2, w3, w4, w5, w6, w7, w8 }; + for (int32_t i = 1; i < M - 1; ++i) { + for (int32_t j = 1; j < N - 1; ++j) { + float acc = 0.0f; + for (int32_t dy = -1; dy <= 1; ++dy) + for (int32_t dx = -1; dx <= 1; ++dx) + acc += w[(dy + 1) * 3 + (dx + 1)] * + A[(size_t)(i + dy) * (size_t)N + (size_t)(j + dx)]; + B[(size_t)i * (size_t)N + (size_t)j] = acc; + } + } +} + +void polygeist_cudnn_conv2d_5x5_f64( + int32_t M, int32_t N, + double w0, double w1, double w2, double w3, double w4, + double w5, double w6, double w7, double w8, double w9, + double w10, double w11, double w12, double w13, double w14, + double w15, double w16, double w17, double w18, double w19, + double w20, double w21, double w22, double w23, double w24, + const double *A, double *B) { + const double w[25] = { + w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, + w10, w11, w12, w13, w14, w15, w16, w17, w18, w19, + w20, w21, w22, w23, w24}; + for (int32_t i = 0; i < M - 4; ++i) { + for (int32_t j = 0; j < N - 4; ++j) { + double acc = 0.0; + for (int32_t dy = 0; dy < 5; ++dy) + for (int32_t dx = 0; dx < 5; ++dx) + acc += w[dy * 5 + dx] * + A[(size_t)(i + dy) * (size_t)N + (size_t)(j + dx)]; + B[(size_t)i * (size_t)N + (size_t)j] = acc; + } + } +} + +void polygeist_cudnn_conv2d_5x5_f32( + int32_t M, int32_t N, + float w0, float w1, float w2, float w3, float w4, + float w5, float w6, float w7, float w8, float w9, + float w10, float w11, float w12, float w13, float w14, + float w15, float w16, float w17, float w18, float w19, + float w20, float w21, float w22, float w23, float w24, + const float *A, float *B) { + const float w[25] = { + w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, + w10, w11, w12, w13, w14, w15, w16, w17, w18, w19, + w20, w21, w22, w23, w24}; + for (int32_t i = 0; i < M - 4; ++i) { + for (int32_t j = 0; j < N - 4; ++j) { + float acc = 0.0f; + for (int32_t dy = 0; dy < 5; ++dy) + for (int32_t dx = 0; dx < 5; ++dx) + acc += w[dy * 5 + dx] * + A[(size_t)(i + dy) * (size_t)N + (size_t)(j + dx)]; + B[(size_t)i * (size_t)N + (size_t)j] = acc; + } + } +} + +void polygeist_cudnn_conv2d_ntap_f64( + int32_t M, int32_t N, int32_t K, + const double *W, const double *A, double *B) { + int32_t out_h = M - (K - 1); + int32_t out_w = N - (K - 1); + for (int32_t i = 0; i < out_h; ++i) { + for (int32_t j = 0; j < out_w; ++j) { + double acc = 0.0; + for (int32_t dy = 0; dy < K; ++dy) + for (int32_t dx = 0; dx < K; ++dx) + acc += W[(size_t)dy * (size_t)K + (size_t)dx] * + A[(size_t)(i + dy) * (size_t)N + (size_t)(j + dx)]; + B[(size_t)i * (size_t)N + (size_t)j] = acc; + } + } +} + +void polygeist_cudnn_conv2d_ntap_f32( + int32_t M, int32_t N, int32_t K, + const float *W, const float *A, float *B) { + int32_t out_h = M - (K - 1); + int32_t out_w = N - (K - 1); + for (int32_t i = 0; i < out_h; ++i) { + for (int32_t j = 0; j < out_w; ++j) { + float acc = 0.0f; + for (int32_t dy = 0; dy < K; ++dy) + for (int32_t dx = 0; dx < K; ++dx) + acc += W[(size_t)dy * (size_t)K + (size_t)dx] * + A[(size_t)(i + dy) * (size_t)N + (size_t)(j + dx)]; + B[(size_t)i * (size_t)N + (size_t)j] = acc; + } + } +} + +void polygeist_cudnn_conv3d_ntap_f64( + int32_t inD, int32_t inH, int32_t inW, + int32_t outD, int32_t outH, int32_t outW, + int32_t K, + const double *W, const double *A, double *B) { + for (int32_t z = 0; z < outD; ++z) { + for (int32_t y = 0; y < outH; ++y) { + for (int32_t x = 0; x < outW; ++x) { + double acc = 0.0; + for (int32_t dz = 0; dz < K; ++dz) + for (int32_t dy = 0; dy < K; ++dy) + for (int32_t dx = 0; dx < K; ++dx) + acc += W[((size_t)dz * (size_t)K + (size_t)dy) * + (size_t)K + (size_t)dx] * + A[((size_t)(z + dz) * (size_t)inH + + (size_t)(y + dy)) * (size_t)inW + + (size_t)(x + dx)]; + B[((size_t)z * (size_t)outH + (size_t)y) * (size_t)outW + + (size_t)x] = acc; + } + } + } +} + +void polygeist_cudnn_conv3d_ntap_f32( + int32_t inD, int32_t inH, int32_t inW, + int32_t outD, int32_t outH, int32_t outW, + int32_t K, + const float *W, const float *A, float *B) { + for (int32_t z = 0; z < outD; ++z) { + for (int32_t y = 0; y < outH; ++y) { + for (int32_t x = 0; x < outW; ++x) { + float acc = 0.0f; + for (int32_t dz = 0; dz < K; ++dz) + for (int32_t dy = 0; dy < K; ++dy) + for (int32_t dx = 0; dx < K; ++dx) + acc += W[((size_t)dz * (size_t)K + (size_t)dy) * + (size_t)K + (size_t)dx] * + A[((size_t)(z + dz) * (size_t)inH + + (size_t)(y + dy)) * (size_t)inW + + (size_t)(x + dx)]; + B[((size_t)z * (size_t)outH + (size_t)y) * (size_t)outW + + (size_t)x] = acc; + } + } + } +} + +void polygeist_custom_stencil3d_7pt_flat_f64( + int32_t N, + const double *a0, const double *a1, const double *a2, + const double *a3, const double *a4, const double *a5, + const double *a6, const double *extra, const double *coeff, + double *out, + double base0, double base_extra, double coeff_extra, + double c0, double c1, double c2, double c3, + double c4, double c5, double c6) { + for (int32_t i = 0; i < N; ++i) { + double extra_v = extra ? extra[i] : 0.0; + double scale = coeff ? coeff[i] : 1.0; + double base = base0 * a0[i] + (extra ? base_extra * extra_v : 0.0); + double inner = c0 * a0[i] + c1 * a1[i] + c2 * a2[i] + + c3 * a3[i] + c4 * a4[i] + c5 * a5[i] + + c6 * a6[i] + (extra ? coeff_extra * extra_v : 0.0); + out[i] = base + scale * inner; + } +} + +void polygeist_custom_stencil3d_7pt_flat_f32( + int32_t N, + const float *a0, const float *a1, const float *a2, + const float *a3, const float *a4, const float *a5, + const float *a6, const float *extra, const float *coeff, + float *out, + float base0, float base_extra, float coeff_extra, + float c0, float c1, float c2, float c3, + float c4, float c5, float c6) { + for (int32_t i = 0; i < N; ++i) { + float extra_v = extra ? extra[i] : 0.0f; + float scale = coeff ? coeff[i] : 1.0f; + float base = base0 * a0[i] + (extra ? base_extra * extra_v : 0.0f); + float inner = c0 * a0[i] + c1 * a1[i] + c2 * a2[i] + + c3 * a3[i] + c4 * a4[i] + c5 * a5[i] + + c6 * a6[i] + (extra ? coeff_extra * extra_v : 0.0f); + out[i] = base + scale * inner; + } +} + +void polygeist_cufft_z2z_1d( + int32_t N, int32_t inverse, const double *A, double *B) { + if (N <= 0) return; + const double sign = inverse ? 1.0 : -1.0; + for (int32_t k = 0; k < N; ++k) { + double sum_re = 0.0; + double sum_im = 0.0; + for (int32_t n = 0; n < N; ++n) { + double angle = sign * 2.0 * M_PI * (double)k * (double)n / (double)N; + double c = cos(angle); + double s = sin(angle); + double ar = A[(size_t)2 * (size_t)n + 0]; + double ai = A[(size_t)2 * (size_t)n + 1]; + sum_re += ar * c - ai * s; + sum_im += ar * s + ai * c; + } + B[(size_t)2 * (size_t)k + 0] = sum_re; + B[(size_t)2 * (size_t)k + 1] = sum_im; + } +} + +void polygeist_cufft_c2c_1d( + int32_t N, int32_t inverse, const float *A, float *B) { + if (N <= 0) return; + const float sign = inverse ? 1.0f : -1.0f; + for (int32_t k = 0; k < N; ++k) { + float sum_re = 0.0f; + float sum_im = 0.0f; + for (int32_t n = 0; n < N; ++n) { + float angle = sign * 2.0f * (float)M_PI * (float)k * (float)n / (float)N; + float c = cosf(angle); + float s = sinf(angle); + float ar = A[(size_t)2 * (size_t)n + 0]; + float ai = A[(size_t)2 * (size_t)n + 1]; + sum_re += ar * c - ai * s; + sum_im += ar * s + ai * c; + } + B[(size_t)2 * (size_t)k + 0] = sum_re; + B[(size_t)2 * (size_t)k + 1] = sum_im; + } +} + +void polygeist_cutensornet_tensor_product_3d_f32( + int32_t KQ, int32_t KP, const float *psi, const float *u, float *out) { + for (int32_t a = 0; a < KQ; ++a) + for (int32_t b = 0; b < KQ; ++b) + for (int32_t c = 0; c < KQ; ++c) { + float sum = 0.0f; + for (int32_t i = 0; i < KP; ++i) + for (int32_t j = 0; j < KP; ++j) + for (int32_t k = 0; k < KP; ++k) + sum += psi[(size_t)a * KP + i] * + psi[(size_t)b * KP + j] * + psi[(size_t)c * KP + k] * + u[((size_t)i * KP + j) * KP + k]; + out[((size_t)a * KQ + b) * KQ + c] = sum; + } +} + +void polygeist_cutensornet_tensor_product_3d_f64( + int32_t KQ, int32_t KP, const double *psi, const double *u, double *out) { + for (int32_t a = 0; a < KQ; ++a) + for (int32_t b = 0; b < KQ; ++b) + for (int32_t c = 0; c < KQ; ++c) { + double sum = 0.0; + for (int32_t i = 0; i < KP; ++i) + for (int32_t j = 0; j < KP; ++j) + for (int32_t k = 0; k < KP; ++k) + sum += psi[(size_t)a * KP + i] * + psi[(size_t)b * KP + j] * + psi[(size_t)c * KP + k] * + u[((size_t)i * KP + j) * KP + k]; + out[((size_t)a * KQ + b) * KQ + c] = sum; + } +} + +void polygeist_cutensornet_contraction2_f64( + const double *A, const double *B, double *C, const int64_t *metadata) { + enum { MAX_RANK = 64, TENSOR_FIELDS = 3 * MAX_RANK }; + int64_t ranks[3] = {metadata[0], metadata[1], metadata[2]}; + int64_t extents[3][MAX_RANK]; + int64_t strides[3][MAX_RANK]; + int64_t modes[3][MAX_RANK]; + int64_t modeExtents[MAX_RANK]; + int present[3][MAX_RANK] = {{0}}; + for (int mode = 0; mode < MAX_RANK; ++mode) + modeExtents[mode] = 1; + + for (int tensor = 0; tensor < 3; ++tensor) { + if (ranks[tensor] < 0 || ranks[tensor] > MAX_RANK) { + fprintf(stderr, "polygeist runtime: invalid contraction rank\n"); + return; + } + int64_t base = 3 + (int64_t)tensor * TENSOR_FIELDS; + for (int64_t dim = 0; dim < ranks[tensor]; ++dim) { + extents[tensor][dim] = metadata[base + dim]; + strides[tensor][dim] = metadata[base + MAX_RANK + dim]; + modes[tensor][dim] = metadata[base + 2 * MAX_RANK + dim]; + int64_t mode = modes[tensor][dim]; + int64_t extent = extents[tensor][dim]; + if (mode < 0 || mode >= MAX_RANK || extent <= 0) { + fprintf(stderr, "polygeist runtime: invalid contraction metadata\n"); + return; + } + if (modeExtents[mode] != 1 && modeExtents[mode] != extent) { + fprintf(stderr, + "polygeist runtime: inconsistent contraction mode extent\n"); + return; + } + modeExtents[mode] = extent; + present[tensor][mode] = 1; + } + } + + int64_t total = 1; + for (int mode = 0; mode < MAX_RANK; ++mode) + total *= modeExtents[mode]; + for (int64_t linear = 0; linear < total; ++linear) { + int64_t coordinates[MAX_RANK]; + int64_t remaining = linear; + for (int mode = MAX_RANK - 1; mode >= 0; --mode) { + coordinates[mode] = remaining % modeExtents[mode]; + remaining /= modeExtents[mode]; + } + + int64_t offsets[3] = {0, 0, 0}; + for (int tensor = 0; tensor < 3; ++tensor) + for (int64_t dim = 0; dim < ranks[tensor]; ++dim) + offsets[tensor] += + coordinates[modes[tensor][dim]] * strides[tensor][dim]; + + int firstReductionPoint = 1; + for (int mode = 0; mode < MAX_RANK; ++mode) + if (!present[2][mode] && + (present[0][mode] || present[1][mode]) && + coordinates[mode] != 0) + firstReductionPoint = 0; + if (firstReductionPoint) + C[offsets[2]] = 0.0; + C[offsets[2]] += A[offsets[0]] * B[offsets[1]]; + } +} + +void polygeist_cutensornet_contraction2_f64_device( + const double *A, const double *B, double *C, const int64_t *metadata) { + // The CPU runtime has no distinct device address space. Keep the symbol + // available so lowering/link tests can exercise the ABI. + polygeist_cutensornet_contraction2_f64(A, B, C, metadata); +} + +// FP16 / BF16: accumulate in float to avoid catastrophic precision loss in +// 9-tap stencils (half's 11-bit mantissa is not enough for sums of nine +// products). Inputs/outputs/weights stay in the half precision type so the +// ABI matches MLIR's f16 / bf16 lowering. Guarded the same way as the +// header declarations — see polygeist_cublas_rt.h. +#if defined(__FLT16_MAX__) +void polygeist_cudnn_conv2d_3x3_f16( + int32_t M, int32_t N, + _Float16 w0, _Float16 w1, _Float16 w2, + _Float16 w3, _Float16 w4, _Float16 w5, + _Float16 w6, _Float16 w7, _Float16 w8, + const _Float16 *A, _Float16 *B) { + const float w[9] = { (float)w0, (float)w1, (float)w2, + (float)w3, (float)w4, (float)w5, + (float)w6, (float)w7, (float)w8 }; + for (int32_t i = 1; i < M - 1; ++i) { + for (int32_t j = 1; j < N - 1; ++j) { + float acc = 0.0f; + for (int32_t dy = -1; dy <= 1; ++dy) + for (int32_t dx = -1; dx <= 1; ++dx) + acc += w[(dy + 1) * 3 + (dx + 1)] * + (float)A[(size_t)(i + dy) * (size_t)N + (size_t)(j + dx)]; + B[(size_t)i * (size_t)N + (size_t)j] = (_Float16)acc; + } + } +} +#endif // __FLT16_MAX__ + +#if defined(__BFLT16_MAX__) || defined(__ARM_FEATURE_BF16) || \ + defined(__ARM_FEATURE_BF16_SCALAR_ARITHMETIC) || defined(__BF16__) +// GCC's aarch64 `__bf16` doesn't permit direct casts to/from float, so we +// do the bf16↔float conversion via bit reinterpretation: bf16 is the top +// 16 bits of an IEEE-754 fp32 (truncate-to-zero rounding). This is the +// portable trick that NVIDIA uses internally too. +static inline float _bf16_to_float(__bf16 b) { + uint16_t bits; + __builtin_memcpy(&bits, &b, sizeof(bits)); + uint32_t f_bits = ((uint32_t)bits) << 16; + float f; + __builtin_memcpy(&f, &f_bits, sizeof(f)); + return f; +} +static inline __bf16 _float_to_bf16(float f) { + uint32_t f_bits; + __builtin_memcpy(&f_bits, &f, sizeof(f_bits)); + // Round-to-nearest-even bias before truncating low 16 bits. + uint32_t rounded = f_bits + 0x7FFF + ((f_bits >> 16) & 1); + uint16_t bits = (uint16_t)(rounded >> 16); + __bf16 out; + __builtin_memcpy(&out, &bits, sizeof(out)); + return out; +} + +void polygeist_cudnn_conv2d_3x3_bf16( + int32_t M, int32_t N, + __bf16 w0, __bf16 w1, __bf16 w2, + __bf16 w3, __bf16 w4, __bf16 w5, + __bf16 w6, __bf16 w7, __bf16 w8, + const __bf16 *A, __bf16 *B) { + const float w[9] = { + _bf16_to_float(w0), _bf16_to_float(w1), _bf16_to_float(w2), + _bf16_to_float(w3), _bf16_to_float(w4), _bf16_to_float(w5), + _bf16_to_float(w6), _bf16_to_float(w7), _bf16_to_float(w8) }; + for (int32_t i = 1; i < M - 1; ++i) { + for (int32_t j = 1; j < N - 1; ++j) { + float acc = 0.0f; + for (int32_t dy = -1; dy <= 1; ++dy) + for (int32_t dx = -1; dx <= 1; ++dx) + acc += w[(dy + 1) * 3 + (dx + 1)] * + _bf16_to_float(A[(size_t)(i + dy) * (size_t)N + (size_t)(j + dx)]); + B[(size_t)i * (size_t)N + (size_t)j] = _float_to_bf16(acc); + } + } +} +#endif // bf16 support + +// INT32 / INT16: simple integer accumulation. cuDNN INT32 has no tensor-core +// path, but is bit-exact integer correctness; INT16 here mirrors what the +// CUDA shim does (upcast to INT32 internally). Wraparound semantics follow +// 2's-complement; overflow is undefined per C but in practice ints wrap. +void polygeist_cudnn_conv2d_3x3_i32( + int32_t M, int32_t N, + int32_t w0, int32_t w1, int32_t w2, + int32_t w3, int32_t w4, int32_t w5, + int32_t w6, int32_t w7, int32_t w8, + const int32_t *A, int32_t *B) { + const int32_t w[9] = { w0, w1, w2, w3, w4, w5, w6, w7, w8 }; + for (int32_t i = 1; i < M - 1; ++i) { + for (int32_t j = 1; j < N - 1; ++j) { + int64_t acc = 0; + for (int32_t dy = -1; dy <= 1; ++dy) + for (int32_t dx = -1; dx <= 1; ++dx) + acc += (int64_t)w[(dy + 1) * 3 + (dx + 1)] * + (int64_t)A[(size_t)(i + dy) * (size_t)N + (size_t)(j + dx)]; + B[(size_t)i * (size_t)N + (size_t)j] = (int32_t)acc; + } + } +} + +void polygeist_cudnn_conv2d_3x3_i16( + int32_t M, int32_t N, + int16_t w0, int16_t w1, int16_t w2, + int16_t w3, int16_t w4, int16_t w5, + int16_t w6, int16_t w7, int16_t w8, + const int16_t *A, int16_t *B) { + const int32_t w[9] = { w0, w1, w2, w3, w4, w5, w6, w7, w8 }; + for (int32_t i = 1; i < M - 1; ++i) { + for (int32_t j = 1; j < N - 1; ++j) { + int64_t acc = 0; + for (int32_t dy = -1; dy <= 1; ++dy) + for (int32_t dx = -1; dx <= 1; ++dx) + acc += (int64_t)w[(dy + 1) * 3 + (dx + 1)] * + (int64_t)A[(size_t)(i + dy) * (size_t)N + (size_t)(j + dx)]; + B[(size_t)i * (size_t)N + (size_t)j] = (int16_t)acc; + } + } +} + +// PVA-routed INT8/INT16 conv CPU stubs. These mirror the PVA Solutions +// Conv2d operator's hardware semantics, which differ from a "raw" integer +// multiply-add and from the centered conv emitted by the polybench source. +// Verified empirically against a Jetson PVA run; the model is: +// 1. PVA Conv2d operates on the full M×N input → full M×N output, with +// CENTERED kernel anchor. Output(y, x) = Σ kernel(ky, kx) * +// input(y + ky - K/2, x + kx - K/2). +// 2. Border policy: REPLICATE — out-of-range input coords clamp to +// [0, M) × [0, N). +// 3. Kernel coefficients reinterpreted as UNSIGNED 8/16-bit even though +// our weights arrive signed. A polybench -8 weight becomes 248, -9 +// becomes 247, -3 becomes 253. (PVA uses Q-format kernels with all +// coefficients ≥ 0; the hardware ignores the sign bit.) +// 4. Accumulator: int64. +// 5. Q-format rescale: dst = (acc + (1 << (qbits-1))) >> qbits, with +// qbits = 8 for int8 and 16 for int16. +// 6. Saturate to the signed range of the image dtype. +// Per-arg contract from the matcher's lowering: B points to &B[1][1] of +// the original output array (not &B[0][0]), and stride = N. The shim +// therefore writes only the (M-2)×(N-2) interior — output(i, j) for i,j +// in [0, M-2) × [0, N-2). The matched harness's dump reads the same +// interior region in B's coordinates ([1, M-1) × [1, N-1)), so the two +// agree element-for-element. +static inline int32_t pva_clamp(int32_t v, int32_t lo, int32_t hi) { + if (v < lo) return lo; + if (v > hi) return hi; + return v; +} + +void polygeist_pva_conv2d_3x3_i8( + int32_t M, int32_t N, + int8_t w0, int8_t w1, int8_t w2, + int8_t w3, int8_t w4, int8_t w5, + int8_t w6, int8_t w7, int8_t w8, + const int8_t *A, int8_t *B) { + const uint8_t w[9] = { + (uint8_t)w0, (uint8_t)w1, (uint8_t)w2, + (uint8_t)w3, (uint8_t)w4, (uint8_t)w5, + (uint8_t)w6, (uint8_t)w7, (uint8_t)w8 }; + for (int32_t i = 0; i < M - 2; ++i) { + for (int32_t j = 0; j < N - 2; ++j) { + int64_t acc = 0; + for (int32_t ky = 0; ky < 3; ++ky) { + int32_t iy = pva_clamp(i + ky - 1, 0, M - 1); + for (int32_t kx = 0; kx < 3; ++kx) { + int32_t ix = pva_clamp(j + kx - 1, 0, N - 1); + acc += (int64_t)w[ky * 3 + kx] * + (int64_t)A[(size_t)iy * (size_t)N + (size_t)ix]; + } + } + int64_t dst = (acc + 128) >> 8; + if (dst > 127) dst = 127; + if (dst < -128) dst = -128; + B[(size_t)i * (size_t)N + (size_t)j] = (int8_t)dst; + } + } +} + +// PVA BoxFilter — uniform 1/K² filter (no coefficient tensor). PVA hardware +// applies the same centered anchor + REPLICATE border policy as conv2d. Per +// the BoxFilter doc, the output is the integer mean of the K² neighbours, +// computed as `(sum + K²/2) >> log2(K²)` for K∈{3,5,7}... except 9 isn't a +// power of two, so the actual round-to-nearest is `(sum + 4) / 9` for K=3. +// Empirically verified against silicon below. +static void box_filter_3x3_kernel_i8(int32_t M, int32_t N, + const int8_t *A, int8_t *B) { + for (int32_t i = 0; i < M - 2; ++i) { + for (int32_t j = 0; j < N - 2; ++j) { + int32_t acc = 0; + for (int32_t ky = 0; ky < 3; ++ky) { + int32_t iy = pva_clamp(i + ky - 1, 0, M - 1); + for (int32_t kx = 0; kx < 3; ++kx) { + int32_t ix = pva_clamp(j + kx - 1, 0, N - 1); + acc += (int32_t)A[(size_t)iy * (size_t)N + (size_t)ix]; + } + } + int32_t dst = (acc + 4) / 9; // rounded mean + if (dst > 127) dst = 127; + if (dst < -128) dst = -128; + B[(size_t)i * (size_t)N + (size_t)j] = (int8_t)dst; + } + } +} + +void polygeist_pva_boxfilter_3x3_i8(int32_t M, int32_t N, + const int8_t *A, int8_t *B) { + box_filter_3x3_kernel_i8(M, N, A, B); +} + +// GaussianFilter — sigma=1.0, K=3 hardcoded. Canonical discrete Gaussian +// kernel for sigma=1, K=3 is approximately +// [1, 2, 1; 2, 4, 2; 1, 2, 1] / 16 +// PVA's hardware computes the kernel internally and likely matches this +// (we'll verify empirically and tweak if a few LSBs diverge — first-pass +// model captures the math). REPLICATE border, integer truncation on the +// /16 divide, saturate to dtype range. +static void gaussian_3x3_kernel_i8(int32_t M, int32_t N, + const int8_t *A, int8_t *B) { + static const int32_t w[9] = { 1, 2, 1, 2, 4, 2, 1, 2, 1 }; + for (int32_t i = 0; i < M - 2; ++i) { + for (int32_t j = 0; j < N - 2; ++j) { + int32_t acc = 0; + for (int32_t ky = 0; ky < 3; ++ky) { + int32_t iy = pva_clamp(i + ky - 1, 0, M - 1); + for (int32_t kx = 0; kx < 3; ++kx) { + int32_t ix = pva_clamp(j + kx - 1, 0, N - 1); + acc += w[ky * 3 + kx] * + (int32_t)A[(size_t)iy * (size_t)N + (size_t)ix]; + } + } + int32_t dst = (acc + 8) >> 4; // /16 with rounding + if (dst > 127) dst = 127; + if (dst < -128) dst = -128; + B[(size_t)i * (size_t)N + (size_t)j] = (int8_t)dst; + } + } +} + +void polygeist_pva_gaussian_3x3_i8(int32_t M, int32_t N, + const int8_t *A, int8_t *B) { + gaussian_3x3_kernel_i8(M, N, A, B); +} + +void polygeist_pva_gaussian_3x3_i16(int32_t M, int32_t N, + const int16_t *A, int16_t *B) { + static const int32_t w[9] = { 1, 2, 1, 2, 4, 2, 1, 2, 1 }; + for (int32_t i = 0; i < M - 2; ++i) { + for (int32_t j = 0; j < N - 2; ++j) { + int32_t acc = 0; + for (int32_t ky = 0; ky < 3; ++ky) { + int32_t iy = pva_clamp(i + ky - 1, 0, M - 1); + for (int32_t kx = 0; kx < 3; ++kx) { + int32_t ix = pva_clamp(j + kx - 1, 0, N - 1); + acc += w[ky * 3 + kx] * + (int32_t)A[(size_t)iy * (size_t)N + (size_t)ix]; + } + } + int32_t dst = (acc + 8) >> 4; + if (dst > 32767) dst = 32767; + if (dst < -32768) dst = -32768; + B[(size_t)i * (size_t)N + (size_t)j] = (int16_t)dst; + } + } +} + +void polygeist_pva_boxfilter_3x3_i16(int32_t M, int32_t N, + const int16_t *A, int16_t *B) { + for (int32_t i = 0; i < M - 2; ++i) { + for (int32_t j = 0; j < N - 2; ++j) { + int32_t acc = 0; + for (int32_t ky = 0; ky < 3; ++ky) { + int32_t iy = pva_clamp(i + ky - 1, 0, M - 1); + for (int32_t kx = 0; kx < 3; ++kx) { + int32_t ix = pva_clamp(j + kx - 1, 0, N - 1); + acc += (int32_t)A[(size_t)iy * (size_t)N + (size_t)ix]; + } + } + int32_t dst = (acc + 4) / 9; + if (dst > 32767) dst = 32767; + if (dst < -32768) dst = -32768; + B[(size_t)i * (size_t)N + (size_t)j] = (int16_t)dst; + } + } +} + +// BilateralFilter — non-linear edge-preserving filter. Faithful CPU +// modeling requires implementing PVA's exact fixed-point spatial+range +// weight tables, which is impractical without spec docs. The CPU stub +// here is a "no-op pass-through" that lets us validate the PVA shim +// runs cleanly + the output isn't garbage (mean stays in input range, +// non-NaN, etc.). Real correctness comes from spot-checking the PVA +// output visually or against a reference float64 bilateral implementation. +void polygeist_pva_bilateral_3x3_i8(int32_t M, int32_t N, + const int8_t *A, int8_t *B) { + for (int32_t i = 0; i < M - 2; ++i) + for (int32_t j = 0; j < N - 2; ++j) + B[(size_t)i * (size_t)N + (size_t)j] = A[(size_t)(i + 1) * (size_t)N + (size_t)(j + 1)]; +} + +void polygeist_pva_bilateral_3x3_i16(int32_t M, int32_t N, + const int16_t *A, int16_t *B) { + for (int32_t i = 0; i < M - 2; ++i) + for (int32_t j = 0; j < N - 2; ++j) + B[(size_t)i * (size_t)N + (size_t)j] = A[(size_t)(i + 1) * (size_t)N + (size_t)(j + 1)]; +} + +// HistogramEqualization CPU stub — runs the textbook histogram-equalization +// algorithm on the FULL M×N image as uint8 (matching PVA's reinterpret), +// then writes the (M-2)×(N-2) interior to B starting at &B[1][1] to match +// the matcher's pointer-shift convention. +void polygeist_pva_histeq_i8(int32_t M, int32_t N, + const int8_t *A, int8_t *B) { + size_t total = (size_t)M * (size_t)N; + int32_t hist[256] = {0}; + for (size_t k = 0; k < total; ++k) hist[(uint8_t)A[k]]++; + int32_t cdf[256]; + cdf[0] = hist[0]; + for (int b = 1; b < 256; ++b) cdf[b] = cdf[b - 1] + hist[b]; + int32_t cdf_min = 0; + for (int b = 0; b < 256; ++b) if (cdf[b]) { cdf_min = cdf[b]; break; } + int32_t denom = (int32_t)total - cdf_min; + if (denom <= 0) denom = 1; + uint8_t lut[256]; + for (int b = 0; b < 256; ++b) { + int32_t v = (cdf[b] - cdf_min) * 255 / denom; + if (v < 0) v = 0; if (v > 255) v = 255; + lut[b] = (uint8_t)v; + } + // PVA writes lut[A[r][c]] at output position (r, c). The matcher passes + // B = &B_orig[1][1], so dump-position (i_dump, j_dump) for i,j in [1, N-1) + // reads PVA output at (i_dump-1, j_dump-1) — that's A[i_dump-1][j_dump-1] + // through the LUT. Shim-local iteration i,j in [0, M-2) maps directly. + for (int32_t i = 0; i < M - 2; ++i) + for (int32_t j = 0; j < N - 2; ++j) { + uint8_t in = (uint8_t)A[(size_t)i * (size_t)N + (size_t)j]; + B[(size_t)i * (size_t)N + (size_t)j] = (int8_t)lut[in]; + } +} + +void polygeist_pva_conv2d_3x3_i16( + int32_t M, int32_t N, + int16_t w0, int16_t w1, int16_t w2, + int16_t w3, int16_t w4, int16_t w5, + int16_t w6, int16_t w7, int16_t w8, + const int16_t *A, int16_t *B) { + const uint16_t w[9] = { + (uint16_t)w0, (uint16_t)w1, (uint16_t)w2, + (uint16_t)w3, (uint16_t)w4, (uint16_t)w5, + (uint16_t)w6, (uint16_t)w7, (uint16_t)w8 }; + for (int32_t i = 0; i < M - 2; ++i) { + for (int32_t j = 0; j < N - 2; ++j) { + int64_t acc = 0; + for (int32_t ky = 0; ky < 3; ++ky) { + int32_t iy = pva_clamp(i + ky - 1, 0, M - 1); + for (int32_t kx = 0; kx < 3; ++kx) { + int32_t ix = pva_clamp(j + kx - 1, 0, N - 1); + acc += (int64_t)w[ky * 3 + kx] * + (int64_t)A[(size_t)iy * (size_t)N + (size_t)ix]; + } + } + int64_t dst = (acc + (1LL << 15)) >> 16; + if (dst > 32767) dst = 32767; + if (dst < -32768) dst = -32768; + B[(size_t)i * (size_t)N + (size_t)j] = (int16_t)dst; + } + } +} + +// ---------------------------------------------------------------------------- +// Extracted-darknet batched CNN primitives (CPU reference impls). NCHW +// FP32 layout. Each is a straight-forward nested loop — slow, but useful +// for end-to-end correctness validation against the CUDA / cuDNN path. +// ---------------------------------------------------------------------------- + +void polygeist_cudnn_conv2d_batched( + int32_t B, int32_t IC, int32_t OC, + int32_t H, int32_t W, int32_t K, + const float *A, const float *F, float *Out) { + const int32_t OH = H - K + 1; + const int32_t OW = W - K + 1; + for (int32_t b = 0; b < B; ++b) + for (int32_t oc = 0; oc < OC; ++oc) + for (int32_t oh = 0; oh < OH; ++oh) + for (int32_t ow = 0; ow < OW; ++ow) { + float acc = 0.0f; + for (int32_t ic = 0; ic < IC; ++ic) + for (int32_t kh = 0; kh < K; ++kh) + for (int32_t kw = 0; kw < K; ++kw) { + size_t a_idx = ((size_t)b * IC + ic) * H * W + + (size_t)(oh + kh) * W + (ow + kw); + size_t f_idx = ((size_t)oc * IC + ic) * K * K + + (size_t)kh * K + kw; + acc += A[a_idx] * F[f_idx]; + } + Out[((size_t)b * OC + oc) * OH * OW + + (size_t)oh * OW + ow] = acc; + } +} + +void polygeist_cudnn_conv3d_channels_f32( + int32_t IC, int32_t inD, int32_t inH, int32_t inW, + int32_t OC, int32_t kD, int32_t kH, int32_t kW, + const float *input, const float *filter, const float *bias, float *output) { + const int32_t outD = inD - kD + 1; + const int32_t outH = inH - kH + 1; + const int32_t outW = inW - kW + 1; + for (int32_t oc = 0; oc < OC; ++oc) + for (int32_t od = 0; od < outD; ++od) + for (int32_t oh = 0; oh < outH; ++oh) + for (int32_t ow = 0; ow < outW; ++ow) { + float acc = bias ? bias[oc] : 0.0f; + for (int32_t ic = 0; ic < IC; ++ic) + for (int32_t kd = 0; kd < kD; ++kd) + for (int32_t kh = 0; kh < kH; ++kh) + for (int32_t kw = 0; kw < kW; ++kw) { + size_t inIdx = (((size_t)ic * inD + (od + kd)) * inH + + (oh + kh)) * inW + (ow + kw); + size_t fIdx = ((((size_t)oc * IC + ic) * kD + kd) * kH + + kh) * kW + kw; + acc += input[inIdx] * filter[fIdx]; + } + output[((size_t)oc * outD + od) * outH * outW + + (size_t)oh * outW + ow] = acc; + } +} + +void polygeist_cudnn_conv2d_im2col_gemm_f32( + int32_t IC, int32_t H, int32_t W, int32_t OC, + int32_t K, int32_t S, int32_t P, + const float *A, const float *F, float *Out) { + const int32_t OH = (H + 2 * P - K) / S + 1; + const int32_t OW = (W + 2 * P - K) / S + 1; + for (int32_t oc = 0; oc < OC; ++oc) + for (int32_t oh = 0; oh < OH; ++oh) + for (int32_t ow = 0; ow < OW; ++ow) { + float acc = 0.0f; + for (int32_t ic = 0; ic < IC; ++ic) + for (int32_t kh = 0; kh < K; ++kh) + for (int32_t kw = 0; kw < K; ++kw) { + int32_t ih = oh * S + kh - P; + int32_t iw = ow * S + kw - P; + if (ih < 0 || iw < 0 || ih >= H || iw >= W) + continue; + size_t a_idx = ((size_t)ic * H + ih) * W + iw; + size_t f_idx = ((size_t)oc * IC + ic) * K * K + + (size_t)kh * K + kw; + acc += A[a_idx] * F[f_idx]; + } + Out[((size_t)oc * OH + oh) * OW + ow] = acc; + } +} + +void polygeist_cudnn_maxpool_batched( + int32_t B, int32_t C, int32_t H, int32_t W, int32_t OH, int32_t OW, + const float *A, float *Out) { + // Derive K, S from H/OH for the typical pool=K=stride case. + // OH = (H - K) / S + 1. For K == S: OH = H / S → S = H / OH, K = S. + // For K != S (e.g. ResNet stem: K=3, S=2): can't recover both from + // shape alone. We rely on the harness to pass shape consistent with + // K = H - (OH - 1) * S = H - (OH - 1) * (H / OH) for the K==S case. + // For K!=S, the harness should set S=H/OH and emit K via a side channel + // — but for the extracted kernels in this PR both shapes use K==S + // (MINI: K=S=2; LARGE: harness uses K=2, S=2 to match the simpler form). + int32_t S = H / OH; + int32_t K = (S > 0) ? S : 2; + for (int32_t b = 0; b < B; ++b) + for (int32_t c = 0; c < C; ++c) + for (int32_t oh = 0; oh < OH; ++oh) + for (int32_t ow = 0; ow < OW; ++ow) { + float m = -3.40282347e38f; + for (int32_t kh = 0; kh < K; ++kh) + for (int32_t kw = 0; kw < K; ++kw) { + size_t a_idx = ((size_t)b * C + c) * H * W + + (size_t)(oh * S + kh) * W + (ow * S + kw); + float v = A[a_idx]; + if (v > m) m = v; + } + Out[((size_t)b * C + c) * OH * OW + + (size_t)oh * OW + ow] = m; + } +} + +void polygeist_cudnn_batchnorm_inference( + int32_t B, int32_t C, int32_t H, int32_t W, + const float *A, + const float *scale, const float *mean, + const float *inv_std, const float *bias, + float *Out) { + for (int32_t b = 0; b < B; ++b) + for (int32_t c = 0; c < C; ++c) + for (int32_t h = 0; h < H; ++h) + for (int32_t w = 0; w < W; ++w) { + size_t idx = ((size_t)b * C + c) * H * W + + (size_t)h * W + w; + Out[idx] = scale[c] * (A[idx] - mean[c]) * inv_std[c] + bias[c]; + } +} + +void polygeist_cudnn_add_tensor_batched( + int32_t B, int32_t C, int32_t H, int32_t W, + const float *A, float *Out) { + size_t n = (size_t)B * C * H * W; + for (size_t i = 0; i < n; ++i) Out[i] += A[i]; +} + +void polygeist_cublas_memset_zero_2d_f32(int32_t M, int32_t N, float *A, int32_t lda) { + if (lda == N) { + memset(A, 0, (size_t)M * (size_t)N * sizeof(float)); + } else { + for (int32_t i = 0; i < M; ++i) + memset(&A[(size_t)i * (size_t)lda], 0, (size_t)N * sizeof(float)); + } +} + +void polygeist_cublas_sgemm_1x1conv( + int32_t B, int32_t IC, int32_t OC, int32_t HW, + const float *A, const float *F, float *C) { +#ifdef POLYGEIST_CPU_USE_CBLAS + for (int32_t b = 0; b < B; ++b) { + const float *Ab = &A[(size_t)b * (size_t)IC * (size_t)HW]; + float *Cb = &C[(size_t)b * (size_t)OC * (size_t)HW]; + cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, OC, HW, IC, 1.0f, + F, IC, Ab, HW, 0.0f, Cb, HW); + } + return; +#endif + /* C[b][oc][p] = sum_ic A[b][ic][p] * F[oc][ic] for p in 0..HW-1. */ + for (int32_t b = 0; b < B; ++b) + for (int32_t oc = 0; oc < OC; ++oc) + for (int32_t p = 0; p < HW; ++p) { + float acc = 0.0f; + for (int32_t ic = 0; ic < IC; ++ic) { + size_t a_idx = ((size_t)b * IC + ic) * HW + p; + size_t f_idx = (size_t)oc * IC + ic; + acc += A[a_idx] * F[f_idx]; + } + C[((size_t)b * OC + oc) * HW + p] = acc; + } +} + +void polygeist_cublas_dsyrk(int32_t N, int32_t K, const float *A, float *C) { +#ifdef POLYGEIST_CPU_USE_CBLAS + cblas_sgemm(CblasRowMajor, CblasTrans, CblasNoTrans, N, N, K, 1.0f, A, N, + A, N, 0.0f, C, N); + return; +#endif + /* C = AᵀA where A is K×N (row-major); C is N×N (row-major). */ + for (int32_t m = 0; m < N; ++m) + for (int32_t n = 0; n < N; ++n) { + float acc = 0.0f; + for (int32_t k = 0; k < K; ++k) + acc += A[(size_t)k * N + m] * A[(size_t)k * N + n]; + C[(size_t)m * N + n] = acc; + } +} + +void polygeist_cublaslt_matmul_bias_relu( + int32_t M, int32_t N, int32_t K, + const float *A, const float *B, const float *bias, + float *C) { +#ifdef POLYGEIST_CPU_USE_CBLAS + cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, M, N, K, 1.0f, A, K, + B, N, 0.0f, C, N); + for (int32_t m = 0; m < M; ++m) + for (int32_t n = 0; n < N; ++n) { + float v = C[(size_t)m * (size_t)N + (size_t)n] + bias[n]; + C[(size_t)m * (size_t)N + (size_t)n] = v > 0.0f ? v : 0.0f; + } + return; +#endif + for (int32_t m = 0; m < M; ++m) + for (int32_t n = 0; n < N; ++n) { + float acc = 0.0f; + for (int32_t k = 0; k < K; ++k) + acc += A[(size_t)m * K + k] * B[(size_t)k * N + n]; + float v = acc + bias[n]; + C[(size_t)m * N + n] = v > 0.0f ? v : 0.0f; + } +} + +void polygeist_cudnn_conv_bias_relu_add_fused( + int32_t B, int32_t IC, int32_t OC, + int32_t H, int32_t W, int32_t K, + const float *A, const float *F, + const float *bias, const float *Z, + float *Out) { + const int32_t OH = H - K + 1; + const int32_t OW = W - K + 1; + for (int32_t b = 0; b < B; ++b) + for (int32_t oc = 0; oc < OC; ++oc) + for (int32_t oh = 0; oh < OH; ++oh) + for (int32_t ow = 0; ow < OW; ++ow) { + float acc = 0.0f; + for (int32_t ic = 0; ic < IC; ++ic) + for (int32_t kh = 0; kh < K; ++kh) + for (int32_t kw = 0; kw < K; ++kw) { + size_t a_idx = ((size_t)b * IC + ic) * H * W + + (size_t)(oh + kh) * W + (ow + kw); + size_t f_idx = ((size_t)oc * IC + ic) * K * K + + (size_t)kh * K + kw; + acc += A[a_idx] * F[f_idx]; + } + size_t z_idx = ((size_t)b * OC + oc) * OH * OW + + (size_t)oh * OW + ow; + float val = acc + bias[oc] + Z[z_idx]; + Out[z_idx] = val > 0.0f ? val : 0.0f; + } +} + +void polygeist_cudnn_conv_bn_relu_fused( + int32_t B, int32_t IC, int32_t OC, + int32_t H, int32_t W, int32_t K, + const float *A, const float *F, + const float *scale, const float *mean, + const float *inv_std, const float *bias, + float *Out) { + const int32_t OH = H - K + 1; + const int32_t OW = W - K + 1; + for (int32_t b = 0; b < B; ++b) + for (int32_t oc = 0; oc < OC; ++oc) + for (int32_t oh = 0; oh < OH; ++oh) + for (int32_t ow = 0; ow < OW; ++ow) { + /* Conv accumulate. */ + float acc = 0.0f; + for (int32_t ic = 0; ic < IC; ++ic) + for (int32_t kh = 0; kh < K; ++kh) + for (int32_t kw = 0; kw < K; ++kw) { + size_t a_idx = ((size_t)b * IC + ic) * H * W + + (size_t)(oh + kh) * W + (ow + kw); + size_t f_idx = ((size_t)oc * IC + ic) * K * K + + (size_t)kh * K + kw; + acc += A[a_idx] * F[f_idx]; + } + /* BN inference. */ + float bn = scale[oc] * (acc - mean[oc]) * inv_std[oc] + bias[oc]; + /* ReLU. */ + float relu = bn > 0.0f ? bn : 0.0f; + Out[((size_t)b * OC + oc) * OH * OW + + (size_t)oh * OW + ow] = relu; + } +} + +void polygeist_rmsnorm_f32( + int32_t N, const float *X, const float *Weight, float *Out) { + float ss = 0.0f; + for (int32_t i = 0; i < N; ++i) + ss += X[i] * X[i]; + float scale = 1.0f / sqrtf(ss / (float)N + 1.0e-5f); + for (int32_t i = 0; i < N; ++i) + Out[i] = Weight[i] * (scale * X[i]); +} + +void polygeist_rmsnorm_unweighted_f32( + int32_t N, const float *X, float *Out) { + float ss = 0.0f; + for (int32_t i = 0; i < N; ++i) + ss += X[i] * X[i]; + float scale = 1.0f / sqrtf(ss / (float)N + 1.0e-5f); + for (int32_t i = 0; i < N; ++i) + Out[i] = scale * X[i]; +} + +void polygeist_cublas_dot_f32( + int32_t N, const float *X, const float *Y, float *Out) { + float acc = 0.0f; + for (int32_t i = 0; i < N; ++i) + acc += X[i] * Y[i]; + *Out = acc; +} + +void polygeist_cublas_dot_f64( + int32_t N, const double *X, const double *Y, double *Out) { + double acc = 0.0; + for (int32_t i = 0; i < N; ++i) + acc += X[i] * Y[i]; + *Out = acc; +} + +void polygeist_cuda_gelu_tanh_f32( + int32_t N, const float *X, float *Out) { + for (int32_t i = 0; i < N; ++i) { + float v = X[i]; + float inner = 0.7978845608028654f * + (v + 0.044715f * v * v * v); + Out[i] = 0.5f * v * (1.0f + tanhf(inner)); + } +} + +void polygeist_whisper_exp_shift_sum_f32( + int32_t N, const float *X, float max_val, float *Out, float *Sum) { + float sum = 0.0f; + for (int32_t i = 0; i < N; ++i) { + float v = expf(X[i] - max_val); + Out[i] = v; + sum += v; + } + *Sum = sum; +} + +void polygeist_cudnn_softmax_forward_f32(int32_t N, float *X) { + if (N <= 0) return; + float max_val = X[0]; + for (int32_t i = 1; i < N; ++i) + if (X[i] > max_val) max_val = X[i]; + float sum = 0.0f; + for (int32_t i = 0; i < N; ++i) { + X[i] = expf(X[i] - max_val); + sum += X[i]; + } + for (int32_t i = 0; i < N; ++i) + X[i] /= sum; +} + +void polygeist_cudnn_softmax_forward_out_f32( + int32_t N, const float *X, float *Out) { + if (N <= 0) return; + memcpy(Out, X, (size_t)N * sizeof(float)); + polygeist_cudnn_softmax_forward_f32(N, Out); +} + +void polygeist_cuda_copy_f32(int32_t N, const float *X, float *Out) { + if (N <= 0) return; + memcpy(Out, X, (size_t)N * sizeof(float)); +} + +void polygeist_cuda_copy_strided_2d_f32( + int32_t rows, int32_t cols, + int32_t src_row_stride, int32_t src_col_stride, + int32_t dst_row_stride, int32_t dst_col_stride, + const float *X, float *Out) { + for (int32_t i = 0; i < rows; ++i) + for (int32_t j = 0; j < cols; ++j) + Out[(size_t)i * dst_row_stride + (size_t)j * dst_col_stride] = + X[(size_t)i * src_row_stride + (size_t)j * src_col_stride]; +} + +void polygeist_cuda_add_f32( + int32_t N, const float *X, const float *Y, float *Out) { + for (int32_t i = 0; i < N; ++i) + Out[i] = X[i] + Y[i]; +} + +void polygeist_cuda_mask_select_f32( + int32_t N, int32_t pos, const float *Scores, float *Out) { + const float neg_inf = -3.4028234663852886e38f; + for (int32_t i = 0; i < N; ++i) + Out[i] = (i > pos) ? neg_inf : Scores[i]; +} + +void polygeist_cuda_swiglu_f32( + int32_t N, const float *Gate, const float *Up, float *Out) { + for (int32_t i = 0; i < N; ++i) { + float g = Gate[i]; + Out[i] = (g / (1.0f + expf(-g))) * Up[i]; + } +} + +void polygeist_cuda_rope_mulmul_f32( + int32_t M, int32_t N, const float *A, const float *B, + const float *C, const float *D, float *Out, int32_t add) { + for (int32_t i = 0; i < M; ++i) { + for (int32_t j = 0; j < N; ++j) { + size_t idx = (size_t)i * (size_t)N + (size_t)j; + float p0 = A[idx] * B[j]; + float p1 = C[idx] * D[j]; + Out[idx] = add ? (p0 + p1) : (p0 - p1); + } + } +} + +// CPU stub timing — wall-clock via clock_gettime(CLOCK_MONOTONIC). Useful +// for sanity but not for GPU perf numbers. + +static struct timespec g_t0; + +void polygeist_cublas_time_begin(void) { + clock_gettime(CLOCK_MONOTONIC, &g_t0); +} + +double polygeist_cublas_time_end_ms(void) { + struct timespec t1; + clock_gettime(CLOCK_MONOTONIC, &t1); + double dt_ns = (double)(t1.tv_sec - g_t0.tv_sec) * 1.0e9 + + (double)(t1.tv_nsec - g_t0.tv_nsec); + return dt_ns / 1.0e6; +} diff --git a/runtime/polygeist_cublas_rt_cuda.c b/runtime/polygeist_cublas_rt_cuda.c new file mode 100644 index 000000000000..ea02e05a473b --- /dev/null +++ b/runtime/polygeist_cublas_rt_cuda.c @@ -0,0 +1,4534 @@ +// polygeist_cublas_rt_cuda.c — real cuBLAS implementation of the runtime +// shim ABI. Compile with nvcc (or clang+CUDA) and link against -lcublas +// -lcudart. Build with: +// nvcc -O3 -c polygeist_cublas_rt_cuda.c -o polygeist_cublas_rt.o +// or, treating the file as C with the cuda toolkit headers in scope: +// clang -O3 -I${CUDA}/include -c polygeist_cublas_rt_cuda.c -o ... +// +// MEMORY MODEL (Jetson zero-copy via cudaHostRegister): +// The integrated GPU on Jetson shares physical DRAM with the CPU. +// Instead of cudaMalloc + cudaMemcpyH2D + cuBLAS + cudaMemcpyD2H + cudaFree +// (which moves bytes within the same DRAM, pure waste), we cudaHostRegister +// the polybench-allocated buffers with `cudaHostRegisterMapped`, pass the +// host pointers directly to cuBLAS via cudaHostGetDevicePointer, then +// cudaHostUnregister at the end. On a Tegra SoC with UVA, the host and +// device addresses are the same; the register call only sets up the GPU +// page-table mapping. +// +// Aliased operands (e.g. syrk's A passed as both A and B) are handled by +// the helper register_host_safe() — it ignores +// cudaErrorHostMemoryAlreadyRegistered so the same pointer can be +// "registered" multiple times within a single call. +// +// ROW→COL-MAJOR: +// cuBLAS expects column-major; our linalg.generic is row-major. We compute +// Cᵀ = α(BᵀAᵀ) + βCᵀ by swapping the A and B operands in the cublasDgemm +// call (with both transA and transB set to CUBLAS_OP_N). The math is +// identical, no actual data transpose needed. + +#include "polygeist_cublas_rt.h" + +#include +#include +#include +#include +#if defined(__has_include) +# if __has_include() +# include +# define POLYGEIST_HAS_CUFFT 1 +# endif +#endif +#ifndef POLYGEIST_HAS_CUFFT +# define POLYGEIST_HAS_CUFFT 0 +#endif +#if defined(POLYGEIST_ENABLE_CUTENSORNET) +# include +# define POLYGEIST_HAS_CUTENSORNET 1 +#else +# define POLYGEIST_HAS_CUTENSORNET 0 +#endif +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef M_PI +#define M_PI 3.14159265358979323846264338327950288 +#endif +/* Intentionally do NOT include or . Those + * headers use NVCC-specific `__device__` builtins that fail to parse under + * aarch64-linux-gnu-gcc (our cross-compile path). cuDNN's API is type-agnostic + * on the data side — it reads the buffer layout from the descriptor + * (CUDNN_DATA_HALF / CUDNN_DATA_BFLOAT16 / etc.), so we use uint16_t* for + * the device buffers in the half-precision paths instead of __half / + * __nv_bfloat16. Bits are identical, so memcpy from the host's _Float16 / + * __bf16 arrays via uint16_t lands the correct values on the device. */ + +static cublasHandle_t g_handle; +static cublasLtHandle_t g_lt = NULL; +static cudnnHandle_t g_cudnn = NULL; +static cudaStream_t g_stream; +static cudaEvent_t g_ev_begin; +static cudaEvent_t g_ev_end; +static int g_initialized = 0; +static int g_atexit_registered = 0; +static int g_pipeline_depth = 0; +static int g_timing_enabled = -1; +static FILE *g_timing_file = NULL; + +typedef struct { + void *ptr; + size_t bytes; + int in_use; +} DeviceTempEntry; + +static DeviceTempEntry *g_device_temps = NULL; +static size_t g_device_temp_count = 0; +static size_t g_device_temp_cap = 0; + +static void **g_deferred_device_frees = NULL; +static size_t g_deferred_device_free_count = 0; +static size_t g_deferred_device_free_cap = 0; + +static void **g_deferred_host_frees = NULL; +static size_t g_deferred_host_free_count = 0; +static size_t g_deferred_host_free_cap = 0; + +#if POLYGEIST_HAS_CUTENSORNET +static void destroy_cutensornet_contraction_cache(void); +#endif + +#define CUDA_CHECK(call) do { \ + cudaError_t err = (call); \ + if (err != cudaSuccess) { \ + fprintf(stderr, "%s:%d cuda error: %s\n", __FILE__, __LINE__, \ + cudaGetErrorString(err)); \ + abort(); \ + } \ + } while (0) + +#define CUBLAS_CHECK(call) do { \ + cublasStatus_t s = (call); \ + if (s != CUBLAS_STATUS_SUCCESS) { \ + fprintf(stderr, "%s:%d cublas error: %d\n", __FILE__, __LINE__, \ + (int)s); \ + abort(); \ + } \ + } while (0) + +#define CUDNN_CHECK(call) do { \ + cudnnStatus_t s = (call); \ + if (s != CUDNN_STATUS_SUCCESS) { \ + fprintf(stderr, "%s:%d cudnn error: %s\n", __FILE__, __LINE__, \ + cudnnGetErrorString(s)); \ + abort(); \ + } \ + } while (0) + +#if POLYGEIST_HAS_CUFFT +#define CUFFT_CHECK(call) do { \ + cufftResult s = (call); \ + if (s != CUFFT_SUCCESS) { \ + fprintf(stderr, "%s:%d cufft error: %d\n", __FILE__, __LINE__, \ + (int)s); \ + abort(); \ + } \ + } while (0) +#endif + +#if POLYGEIST_HAS_CUTENSORNET +#define CUTENSORNET_CHECK(call) do { \ + cutensornetStatus_t s = (call); \ + if (s != CUTENSORNET_STATUS_SUCCESS) { \ + fprintf(stderr, "%s:%d cuTensorNet error: %s\n", __FILE__, __LINE__, \ + cutensornetGetErrorString(s)); \ + abort(); \ + } \ + } while (0) +#endif + +static int in_pipeline_scope(void) { return g_pipeline_depth > 0; } + +static void sync_stream_if_outside_pipeline(void) { + if (!in_pipeline_scope()) + CUDA_CHECK(cudaStreamSynchronize(g_stream)); +} + +static void reserve_device_temp_entries(size_t need) { + if (need <= g_device_temp_cap) + return; + size_t new_cap = g_device_temp_cap ? g_device_temp_cap * 2 : 16; + while (new_cap < need) + new_cap *= 2; + DeviceTempEntry *next = + (DeviceTempEntry *)realloc(g_device_temps, + new_cap * sizeof(DeviceTempEntry)); + if (!next) { + fprintf(stderr, "polygeist runtime: device temp cache realloc failed\n"); + abort(); + } + g_device_temps = next; + g_device_temp_cap = new_cap; +} + +static void *pipeline_device_malloc(size_t bytes) { + if (bytes == 0) + return NULL; + + if (in_pipeline_scope()) { + ssize_t best = -1; + for (size_t i = 0; i < g_device_temp_count; ++i) { + if (g_device_temps[i].in_use || g_device_temps[i].bytes < bytes) + continue; + if (best < 0 || g_device_temps[i].bytes < g_device_temps[best].bytes) + best = (ssize_t)i; + } + if (best >= 0) { + g_device_temps[best].in_use = 1; + return g_device_temps[best].ptr; + } + } + + void *ptr = NULL; + CUDA_CHECK(cudaMalloc(&ptr, bytes)); + if (!in_pipeline_scope()) + return ptr; + + reserve_device_temp_entries(g_device_temp_count + 1); + g_device_temps[g_device_temp_count].ptr = ptr; + g_device_temps[g_device_temp_count].bytes = bytes; + g_device_temps[g_device_temp_count].in_use = 1; + g_device_temp_count++; + return ptr; +} + +static ssize_t find_device_temp(void *ptr) { + for (size_t i = 0; i < g_device_temp_count; ++i) + if (g_device_temps[i].ptr == ptr) + return (ssize_t)i; + return -1; +} + +static void reserve_deferred_device_frees(size_t need) { + if (need <= g_deferred_device_free_cap) + return; + size_t new_cap = + g_deferred_device_free_cap ? g_deferred_device_free_cap * 2 : 16; + while (new_cap < need) + new_cap *= 2; + void **next = + (void **)realloc(g_deferred_device_frees, new_cap * sizeof(void *)); + if (!next) { + fprintf(stderr, "polygeist runtime: deferred device-free realloc failed\n"); + abort(); + } + g_deferred_device_frees = next; + g_deferred_device_free_cap = new_cap; +} + +static void flush_deferred_device_frees(void) { + for (size_t i = 0; i < g_deferred_device_free_count; ++i) + CUDA_CHECK(cudaFree(g_deferred_device_frees[i])); + g_deferred_device_free_count = 0; +} + +static void destroy_deferred_device_free_list(void) { + flush_deferred_device_frees(); + free(g_deferred_device_frees); + g_deferred_device_frees = NULL; + g_deferred_device_free_cap = 0; +} + +static void pipeline_device_free(void *ptr) { + if (!ptr) + return; + ssize_t idx = find_device_temp(ptr); + if (idx >= 0) { + g_device_temps[idx].in_use = 0; + return; + } + if (in_pipeline_scope()) { + reserve_deferred_device_frees(g_deferred_device_free_count + 1); + g_deferred_device_frees[g_deferred_device_free_count++] = ptr; + return; + } + CUDA_CHECK(cudaFree(ptr)); +} + +static void destroy_device_temp_cache(void) { + for (size_t i = 0; i < g_device_temp_count; ++i) + if (g_device_temps[i].ptr) + CUDA_CHECK(cudaFree(g_device_temps[i].ptr)); + free(g_device_temps); + g_device_temps = NULL; + g_device_temp_count = 0; + g_device_temp_cap = 0; +} + +static void reserve_deferred_host_frees(size_t need) { + if (need <= g_deferred_host_free_cap) + return; + size_t new_cap = g_deferred_host_free_cap ? g_deferred_host_free_cap * 2 : 16; + while (new_cap < need) + new_cap *= 2; + void **next = + (void **)realloc(g_deferred_host_frees, new_cap * sizeof(void *)); + if (!next) { + fprintf(stderr, "polygeist runtime: deferred host-free realloc failed\n"); + abort(); + } + g_deferred_host_frees = next; + g_deferred_host_free_cap = new_cap; +} + +static void pipeline_host_free(void *ptr) { + if (!ptr) + return; + if (!in_pipeline_scope()) { + free(ptr); + return; + } + reserve_deferred_host_frees(g_deferred_host_free_count + 1); + g_deferred_host_frees[g_deferred_host_free_count++] = ptr; +} + +static void flush_deferred_host_frees(void) { + for (size_t i = 0; i < g_deferred_host_free_count; ++i) + free(g_deferred_host_frees[i]); + g_deferred_host_free_count = 0; +} + +static void destroy_deferred_host_free_list(void) { + flush_deferred_host_frees(); + free(g_deferred_host_frees); + g_deferred_host_frees = NULL; + g_deferred_host_free_cap = 0; +} + +#define DEVICE_MALLOC(ptrptr, bytes) \ + do { \ + *(void **)(ptrptr) = pipeline_device_malloc((size_t)(bytes)); \ + } while (0) + +#define DEVICE_FREE(ptr) pipeline_device_free((void *)(ptr)) + +static int timing_enabled(void) { + if (g_timing_enabled >= 0) return g_timing_enabled; + const char *env = getenv("POLYGEIST_RT_TIMING"); + g_timing_enabled = + env && env[0] != '\0' && strcmp(env, "0") != 0 && + strcmp(env, "false") != 0 && strcmp(env, "FALSE") != 0; + return g_timing_enabled; +} + +static FILE *timing_file(void) { + if (!timing_enabled()) return NULL; + if (g_timing_file) return g_timing_file; + const char *path = getenv("POLYGEIST_RT_TIMING_FILE"); + if (path && path[0] != '\0') { + g_timing_file = fopen(path, "a"); + if (!g_timing_file) { + fprintf(stderr, "polygeist runtime: failed to open timing file %s\n", path); + abort(); + } + } else { + g_timing_file = stderr; + } + return g_timing_file; +} + +static double wall_time_ms(void) { + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return (double)ts.tv_sec * 1000.0 + (double)ts.tv_nsec / 1000000.0; +} + +static void timing_host_only( + const char *op, int32_t m, int32_t n, int32_t k, double host_start_ms); + +static void timing_gpu_begin(void) { + if (timing_enabled() && !in_pipeline_scope()) + CUDA_CHECK(cudaEventRecord(g_ev_begin, g_stream)); +} + +static void timing_gpu_end( + const char *op, int32_t m, int32_t n, int32_t k, double host_start_ms) { + if (in_pipeline_scope()) { + timing_host_only(op, m, n, k, host_start_ms); + return; + } + if (!timing_enabled()) { + sync_stream_if_outside_pipeline(); + return; + } + + CUDA_CHECK(cudaEventRecord(g_ev_end, g_stream)); + CUDA_CHECK(cudaEventSynchronize(g_ev_end)); + float device_ms = 0.0f; + CUDA_CHECK(cudaEventElapsedTime(&device_ms, g_ev_begin, g_ev_end)); + + FILE *f = timing_file(); + fprintf(f, + "POLYGEIST_RT_TIMING\top=%s\tm=%d\tn=%d\tk=%d\t" + "host_ms=%.6f\tdevice_ms=%.6f\n", + op, (int)m, (int)n, (int)k, wall_time_ms() - host_start_ms, + (double)device_ms); + fflush(f); +} + +static void timing_host_only( + const char *op, int32_t m, int32_t n, int32_t k, double host_start_ms) { + if (!timing_enabled()) return; + FILE *f = timing_file(); + fprintf(f, + "POLYGEIST_RT_TIMING\top=%s\tm=%d\tn=%d\tk=%d\t" + "host_ms=%.6f\tdevice_ms=0.000000\n", + op, (int)m, (int)n, (int)k, wall_time_ms() - host_start_ms); + fflush(f); +} + +static void ensure_cudnn(void) { + if (g_cudnn) return; + CUDNN_CHECK(cudnnCreate(&g_cudnn)); + CUDNN_CHECK(cudnnSetStream(g_cudnn, g_stream)); +} + +static void ensure_cublaslt(void) { + if (g_lt) return; + cublasStatus_t s = cublasLtCreate(&g_lt); + if (s != CUBLAS_STATUS_SUCCESS) { + fprintf(stderr, "cublasLtCreate failed: %d\n", (int)s); + abort(); + } +} + +// Zero-copy helpers with PERSISTENT registration. cudaHostRegister has +// real cost on Jetson (page-table setup for the mapped range) — for an +// 8000×8000 double matrix that's 128K pages, ~50 ms per register call. +// Many kernels touch the same buffer multiple times (e.g. gemver: +// A is read/written by 2 gers + 2 gemvs = 4 shim calls). Re-registering +// + unregistering on every call is wasteful. +// +// Strategy: register on first use, NEVER unregister. The page mapping +// stays live for the rest of the program. Each shim call's first action +// is a fast no-op "already registered" check. +// +// Cache implementation: a small linear table keyed on host range. Larger +// raised application graphs can create more than 256 temporary tensor +// snapshots over their lifetime, so a full cache evicts its least-recently +// used registration instead of aborting. Calls synchronize the CUDA stream +// before returning, which makes an entry from an earlier call safe to evict; +// a still-live tensor is simply registered again on its next use. + +#define HOSTREG_CACHE_CAP 256 +struct hostreg_entry { + void *host; + void *dev; + size_t bytes; + uint64_t last_use; +}; +static struct hostreg_entry g_hostreg_cache[HOSTREG_CACHE_CAP]; +static int g_hostreg_count = 0; +static uint64_t g_hostreg_clock = 0; + +static int range_contains(void *outer, size_t outer_bytes, + void *inner, size_t inner_bytes) { + uintptr_t o0 = (uintptr_t)outer; + uintptr_t i0 = (uintptr_t)inner; + uintptr_t o1 = o0 + outer_bytes; + uintptr_t i1 = i0 + inner_bytes; + return i0 >= o0 && i1 <= o1; +} + +static int ranges_overlap(void *a, size_t a_bytes, void *b, size_t b_bytes) { + uintptr_t a0 = (uintptr_t)a; + uintptr_t b0 = (uintptr_t)b; + uintptr_t a1 = a0 + a_bytes; + uintptr_t b1 = b0 + b_bytes; + return a0 < b1 && b0 < a1; +} + +static void *hostreg_cache_lookup(void *ptr, size_t bytes) { + for (int i = 0; i < g_hostreg_count; ++i) { + struct hostreg_entry *e = &g_hostreg_cache[i]; + if (range_contains(e->host, e->bytes, ptr, bytes)) { + e->last_use = ++g_hostreg_clock; + uintptr_t delta = (uintptr_t)ptr - (uintptr_t)e->host; + return (void *)((uintptr_t)e->dev + delta); + } + } + return NULL; +} + +static void hostreg_cache_remove_overlaps(void *ptr, size_t bytes) { + for (int i = 0; i < g_hostreg_count;) { + struct hostreg_entry *e = &g_hostreg_cache[i]; + if (!ranges_overlap(e->host, e->bytes, ptr, bytes)) { + ++i; + continue; + } + cudaError_t err = cudaHostUnregister(e->host); + if (err != cudaSuccess && err != cudaErrorHostMemoryNotRegistered) { + fprintf(stderr, "%s:%d cudaHostUnregister(%p) failed: %s\n", + __FILE__, __LINE__, e->host, cudaGetErrorString(err)); + abort(); + } + g_hostreg_cache[i] = g_hostreg_cache[g_hostreg_count - 1]; + g_hostreg_count--; + } +} + +static void hostreg_cache_insert(void *host, void *dev, size_t bytes) { + if (g_hostreg_count >= HOSTREG_CACHE_CAP) { + int victim = 0; + for (int i = 1; i < g_hostreg_count; ++i) { + if (g_hostreg_cache[i].last_use < g_hostreg_cache[victim].last_use) + victim = i; + } + cudaError_t err = cudaHostUnregister(g_hostreg_cache[victim].host); + if (err != cudaSuccess && err != cudaErrorHostMemoryNotRegistered) { + fprintf(stderr, "%s:%d cudaHostUnregister(%p) failed: %s\n", + __FILE__, __LINE__, g_hostreg_cache[victim].host, + cudaGetErrorString(err)); + abort(); + } + g_hostreg_cache[victim].host = host; + g_hostreg_cache[victim].dev = dev; + g_hostreg_cache[victim].bytes = bytes; + g_hostreg_cache[victim].last_use = ++g_hostreg_clock; + return; + } + g_hostreg_cache[g_hostreg_count].host = host; + g_hostreg_cache[g_hostreg_count].dev = dev; + g_hostreg_cache[g_hostreg_count].bytes = bytes; + g_hostreg_cache[g_hostreg_count].last_use = ++g_hostreg_clock; + g_hostreg_count++; +} + +// We tried bypassing cudaHostRegister and passing host pointers directly +// to cuBLAS — fails with illegal-memory-access. cuBLAS requires the +// buffer to be registered (or device-allocated) even on a Tegra SoC +// where the iGPU can technically reach any DRAM page. +static int pointer_is_device_resident(void *ptr, void **device_ptr) { + struct cudaPointerAttributes attrs; + cudaError_t err = cudaPointerGetAttributes(&attrs, ptr); + if (err != cudaSuccess) { + // Unregistered malloc pointers normally report cudaErrorInvalidValue. + // Clear the sticky runtime error before the registration path below. + (void)cudaGetLastError(); + return 0; + } +#if CUDART_VERSION >= 10000 + if (attrs.type != cudaMemoryTypeDevice && + attrs.type != cudaMemoryTypeManaged) + return 0; +#else + if (attrs.memoryType != cudaMemoryTypeDevice) + return 0; +#endif + *device_ptr = attrs.devicePointer ? attrs.devicePointer : ptr; + return 1; +} + +static void *register_host_safe(void *ptr, size_t bytes) { + void *cached = hostreg_cache_lookup(ptr, bytes); + if (cached) return cached; + void *device_ptr = NULL; + if (pointer_is_device_resident(ptr, &device_ptr)) + return device_ptr; + hostreg_cache_remove_overlaps(ptr, bytes); + cudaError_t err = cudaHostRegister(ptr, bytes, cudaHostRegisterMapped); + if (err != cudaSuccess && err != cudaErrorHostMemoryAlreadyRegistered) { + fprintf(stderr, "%s:%d cudaHostRegister(%p, %zu) failed: %s\n", + __FILE__, __LINE__, ptr, bytes, cudaGetErrorString(err)); + abort(); + } + void *dev = NULL; + CUDA_CHECK(cudaHostGetDevicePointer(&dev, ptr, 0)); + hostreg_cache_insert(ptr, dev, bytes); + return dev; +} + +// Persistent-registration model: never unregister. Mappings live until +// the program exits, at which point the OS reclaims them anyway. +static void unregister_host_safe(void *ptr) { (void)ptr; } + +static void destroy_backend_desc(cudnnBackendDescriptor_t *desc) { + if (*desc) { + cudnnBackendDestroyDescriptor(*desc); + *desc = NULL; + } +} + +static void report_rmsnorm_backend_fallback( + const char *where, cudnnStatus_t status) { + static int warned = 0; + if (warned) return; + warned = 1; + fprintf(stderr, + "polygeist runtime: cuDNN RMSNorm graph unavailable at %s: %s; " + "using host fallback\n", + where, cudnnGetErrorString(status)); +} + +static int set_backend_attr( + cudnnBackendDescriptor_t desc, + cudnnBackendAttributeName_t attr, + cudnnBackendAttributeType_t type, + int64_t count, + const void *value, + const char *where, + cudnnStatus_t *last_status) { + cudnnStatus_t status = + cudnnBackendSetAttribute(desc, attr, type, count, value); + if (status != CUDNN_STATUS_SUCCESS) { + *last_status = status; + report_rmsnorm_backend_fallback(where, status); + return 0; + } + return 1; +} + +static int finalize_backend_desc( + cudnnBackendDescriptor_t desc, + const char *where, + cudnnStatus_t *last_status) { + cudnnStatus_t status = cudnnBackendFinalize(desc); + if (status != CUDNN_STATUS_SUCCESS) { + *last_status = status; + report_rmsnorm_backend_fallback(where, status); + return 0; + } + return 1; +} + +static int make_f32_backend_tensor( + cudnnBackendDescriptor_t *desc, + int64_t uid, + const int64_t *dims, + const int64_t *strides, + int64_t rank, + bool by_value, + const char *name, + cudnnStatus_t *last_status) { + cudnnStatus_t status = + cudnnBackendCreateDescriptor(CUDNN_BACKEND_TENSOR_DESCRIPTOR, desc); + if (status != CUDNN_STATUS_SUCCESS) { + *last_status = status; + report_rmsnorm_backend_fallback(name, status); + return 0; + } + + cudnnDataType_t dtype = CUDNN_DATA_FLOAT; + int64_t alignment = 4; + if (!set_backend_attr(*desc, CUDNN_ATTR_TENSOR_DATA_TYPE, + CUDNN_TYPE_DATA_TYPE, 1, &dtype, name, + last_status) || + !set_backend_attr(*desc, CUDNN_ATTR_TENSOR_DIMENSIONS, + CUDNN_TYPE_INT64, rank, dims, name, last_status) || + !set_backend_attr(*desc, CUDNN_ATTR_TENSOR_STRIDES, + CUDNN_TYPE_INT64, rank, strides, name, last_status) || + !set_backend_attr(*desc, CUDNN_ATTR_TENSOR_UNIQUE_ID, + CUDNN_TYPE_INT64, 1, &uid, name, last_status) || + !set_backend_attr(*desc, CUDNN_ATTR_TENSOR_BYTE_ALIGNMENT, + CUDNN_TYPE_INT64, 1, &alignment, name, + last_status)) + return 0; + + if (by_value && + !set_backend_attr(*desc, CUDNN_ATTR_TENSOR_IS_BY_VALUE, + CUDNN_TYPE_BOOLEAN, 1, &by_value, name, + last_status)) + return 0; + + return finalize_backend_desc(*desc, name, last_status); +} + +void polygeist_cublas_init(void) { + if (g_initialized) return; + CUDA_CHECK(cudaStreamCreate(&g_stream)); + CUBLAS_CHECK(cublasCreate(&g_handle)); + CUBLAS_CHECK(cublasSetStream(g_handle, g_stream)); + CUBLAS_CHECK(cublasSetPointerMode(g_handle, CUBLAS_POINTER_MODE_HOST)); + CUDA_CHECK(cudaEventCreate(&g_ev_begin)); + CUDA_CHECK(cudaEventCreate(&g_ev_end)); + g_initialized = 1; + // Register after CUDA has initialized its own process-exit hooks. atexit + // runs in reverse order, so our cache/stream teardown happens first. + if (!g_atexit_registered) { + if (atexit(polygeist_cublas_destroy) != 0) { + fprintf(stderr, "polygeist runtime: failed to register CUDA cleanup\n"); + abort(); + } + g_atexit_registered = 1; + } +} + +void polygeist_cublas_destroy(void) { + if (g_timing_file && g_timing_file != stderr) { + fclose(g_timing_file); + g_timing_file = NULL; + } + if (!g_initialized) return; + CUDA_CHECK(cudaStreamSynchronize(g_stream)); +#if POLYGEIST_HAS_CUTENSORNET + destroy_cutensornet_contraction_cache(); +#endif + destroy_deferred_device_free_list(); + destroy_deferred_host_free_list(); + destroy_device_temp_cache(); + cudaEventDestroy(g_ev_begin); + cudaEventDestroy(g_ev_end); + cublasDestroy(g_handle); + cudaStreamDestroy(g_stream); + g_initialized = 0; + g_pipeline_depth = 0; +} + +void polygeist_cublas_pipeline_begin(void) { + polygeist_cublas_init(); + g_pipeline_depth++; +} + +void polygeist_cublas_pipeline_end(void) { + if (!g_initialized) + return; + if (g_pipeline_depth > 0) + g_pipeline_depth--; + if (g_pipeline_depth == 0) { + sync_stream_if_outside_pipeline(); + flush_deferred_device_frees(); + flush_deferred_host_frees(); + } +} + +void polygeist_cublas_dgemm( + int32_t M, int32_t N, int32_t K, + double alpha, + const double *A, int32_t lda, + const double *B, int32_t ldb, + double beta, + double *C, int32_t ldc) { + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t bytes_A = (size_t)M * (size_t)lda * sizeof(double); + size_t bytes_B = (size_t)K * (size_t)ldb * sizeof(double); + size_t bytes_C = (size_t)M * (size_t)ldc * sizeof(double); + + // Pin host buffers for direct GPU access (zero-copy on Jetson). + double *dA = (double *)register_host_safe((void *)A, bytes_A); + double *dB = (double *)register_host_safe((void *)B, bytes_B); + double *dC = (double *)register_host_safe(C, bytes_C); + + // Row-major C = α A·B + β C → col-major Cᵀ = α Bᵀ·Aᵀ + β Cᵀ + timing_gpu_begin(); + CUBLAS_CHECK(cublasDgemm(g_handle, + CUBLAS_OP_N, CUBLAS_OP_N, + /*m=*/N, /*n=*/M, /*k=*/K, + &alpha, + dB, ldb, + dA, lda, + &beta, + dC, ldc)); + timing_gpu_end("cublasDgemm", M, N, K, host_start_ms); + + unregister_host_safe((void *)A); + unregister_host_safe((void *)B); + unregister_host_safe(C); +} + +void polygeist_cublas_sgemm( + int32_t M, int32_t N, int32_t K, + float alpha, + const float *A, int32_t lda, + const float *B, int32_t ldb, + float beta, + float *C, int32_t ldc) { + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t bytes_A = (size_t)M * (size_t)lda * sizeof(float); + size_t bytes_B = (size_t)K * (size_t)ldb * sizeof(float); + size_t bytes_C = (size_t)M * (size_t)ldc * sizeof(float); + + float *dA = (float *)register_host_safe((void *)A, bytes_A); + float *dB = (float *)register_host_safe((void *)B, bytes_B); + float *dC = (float *)register_host_safe(C, bytes_C); + + timing_gpu_begin(); + CUBLAS_CHECK(cublasSgemm(g_handle, + CUBLAS_OP_N, CUBLAS_OP_N, + /*m=*/N, /*n=*/M, /*k=*/K, + &alpha, + dB, ldb, + dA, lda, + &beta, + dC, ldc)); + timing_gpu_end("cublasSgemm", M, N, K, host_start_ms); + + unregister_host_safe((void *)A); + unregister_host_safe((void *)B); + unregister_host_safe(C); +} + +void polygeist_cublas_sgemm_strided_batched_broadcast_rhs( + int32_t batch, int32_t M, int32_t N, int32_t K, + const float *A, const float *B, float *C) { + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + size_t stride_A = (size_t)M * (size_t)K; + size_t stride_C = (size_t)M * (size_t)N; + float *dA = (float *)register_host_safe( + (void *)A, (size_t)batch * stride_A * sizeof(float)); + float *dB = (float *)register_host_safe( + (void *)B, (size_t)K * (size_t)N * sizeof(float)); + float *dC = (float *)register_host_safe( + C, (size_t)batch * stride_C * sizeof(float)); + const float one = 1.0f; + const float zero = 0.0f; + + // Row-major C_b=A_b*B is column-major C_b^T=B^T*A_b^T. A zero + // stride for B broadcasts the same right-hand matrix to every batch. + timing_gpu_begin(); + CUBLAS_CHECK(cublasSgemmStridedBatched( + g_handle, CUBLAS_OP_N, CUBLAS_OP_N, + /*m=*/N, /*n=*/M, /*k=*/K, + &one, + dB, /*ldb=*/N, /*strideB=*/0, + dA, /*lda=*/K, /*strideA=*/(long long)stride_A, + &zero, + dC, /*ldc=*/N, /*strideC=*/(long long)stride_C, + batch)); + timing_gpu_end("cublasSgemmStridedBatched_broadcast_rhs", + batch * M, N, K, host_start_ms); + + unregister_host_safe((void *)A); + unregister_host_safe((void *)B); + unregister_host_safe(C); +} + +void polygeist_cublas_dgemm_outer_product( + int32_t M, int32_t N, + const double *u, const double *v, double *C) { + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + double *du = (double *)register_host_safe( + (void *)u, (size_t)M * sizeof(double)); + double *dv = (double *)register_host_safe( + (void *)v, (size_t)N * sizeof(double)); + double *dC = (double *)register_host_safe( + C, (size_t)M * (size_t)N * sizeof(double)); + const double one = 1.0; + const double zero = 0.0; + + // C(row-major MxN)^T = v(Nx1) * u^T(1xM). beta=0 gives overwrite + // semantics without a separate zero-fill launch. + timing_gpu_begin(); + CUBLAS_CHECK(cublasDgemm(g_handle, + CUBLAS_OP_N, CUBLAS_OP_N, + /*m=*/N, /*n=*/M, /*k=*/1, + &one, + dv, /*lda=*/N, + du, /*ldb=*/1, + &zero, + dC, /*ldc=*/N)); + timing_gpu_end("cublasDgemm_outer_product", M, N, 1, host_start_ms); + + unregister_host_safe((void *)u); + unregister_host_safe((void *)v); + unregister_host_safe(C); +} + +// Zero mapped host buffers on the CPU, but preserve device residency when the +// caller supplies a cudaMalloc/cudaMallocManaged allocation. +void polygeist_cublas_memset_zero_2d(int32_t M, int32_t N, + double *A, int32_t lda) { + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + void *device_ptr = NULL; + if (pointer_is_device_resident(A, &device_ptr)) { + polygeist_cublas_init(); + timing_gpu_begin(); + CUDA_CHECK(cudaMemset2DAsync(device_ptr, (size_t)lda * sizeof(double), 0, + (size_t)N * sizeof(double), M, g_stream)); + timing_gpu_end("cuda_memset_zero_2d_f64", M, N, 0, host_start_ms); + return; + } + if (lda == N) { + // Contiguous: one memset. + memset(A, 0, (size_t)M * (size_t)N * sizeof(double)); + } else { + for (int32_t i = 0; i < M; ++i) { + memset(&A[(size_t)i * (size_t)lda], 0, + (size_t)N * sizeof(double)); + } + } + timing_host_only("host_memset_zero_2d_f64", M, N, 0, host_start_ms); +} + +// y = α*x + β*y (axpby). O(N) bandwidth-bound; H↔D copy + two cuBLAS +// calls would dominate any GPU benefit. Do it on the host directly. +void polygeist_cublas_daxpby(int32_t N, double alpha, const double *x, + double beta, double *y) { + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + for (int32_t i = 0; i < N; ++i) y[i] = alpha * x[i] + beta * y[i]; + timing_host_only("host_daxpby", N, 1, 0, host_start_ms); +} + +// y += x (axpy with α=1). +void polygeist_cublas_daxpy_unit(int32_t N, const double *x, double *y) { + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + size_t bytes = (size_t)N * sizeof(double); + double *dx = (double *)register_host_safe((void *)x, bytes); + double *dy = (double *)register_host_safe(y, bytes); + double one = 1.0; + timing_gpu_begin(); + CUBLAS_CHECK(cublasDaxpy(g_handle, N, &one, dx, 1, dy, 1)); + timing_gpu_end("cublasDaxpy", N, 1, 0, host_start_ms); + unregister_host_safe((void *)x); + unregister_host_safe(y); +} + +// Rank-2 update: A += u1·v1ᵀ + u2·v2ᵀ (gemver body). Two cublasDger calls. +void polygeist_cublas_dger_rank2(int32_t M, int32_t N, + const double *u1, const double *v1, + const double *u2, const double *v2, + double *A, int32_t lda) { + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + double one = 1.0; + size_t bytes_A = (size_t)M * (size_t)lda * sizeof(double); + size_t bytes_u = (size_t)M * sizeof(double); + size_t bytes_v = (size_t)N * sizeof(double); + + double *dA = (double *)register_host_safe(A, bytes_A); + double *du1 = (double *)register_host_safe((void *)u1, bytes_u); + double *dv1 = (double *)register_host_safe((void *)v1, bytes_v); + double *du2 = (double *)register_host_safe((void *)u2, bytes_u); + double *dv2 = (double *)register_host_safe((void *)v2, bytes_v); + + // Row-major A[i,j] += u1[i]*v1[j] + u2[i]*v2[j]. + // cuBLAS Dger col-major: pass (m=N, n=M, x=v, y=u) for row-major A += u·vᵀ. + timing_gpu_begin(); + CUBLAS_CHECK(cublasDger(g_handle, /*m=*/N, /*n=*/M, + &one, dv1, 1, du1, 1, dA, lda)); + CUBLAS_CHECK(cublasDger(g_handle, /*m=*/N, /*n=*/M, + &one, dv2, 1, du2, 1, dA, lda)); + timing_gpu_end("cublasDger_rank2", M, N, 0, host_start_ms); + + unregister_host_safe(A); + unregister_host_safe((void *)u1); + unregister_host_safe((void *)v1); + unregister_host_safe((void *)u2); + unregister_host_safe((void *)v2); +} + +// Preserve the zero-copy host behavior for ordinary C allocations, but also +// accept an already-device-resident buffer. This lets a lifted function use +// the exact same ABI with cudaMalloc operands without attempting a CPU memset +// through a device address. +void polygeist_cublas_memset_zero_1d(int32_t N, double *v) { + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + void *device_ptr = NULL; + if (pointer_is_device_resident(v, &device_ptr)) { + polygeist_cublas_init(); + timing_gpu_begin(); + CUDA_CHECK(cudaMemsetAsync(device_ptr, 0, (size_t)N * sizeof(double), + g_stream)); + timing_gpu_end("cuda_memset_zero_1d_f64", N, 1, 0, host_start_ms); + return; + } + memset(v, 0, (size_t)N * sizeof(double)); + timing_host_only("host_memset_zero_1d_f64", N, 1, 0, host_start_ms); +} + +void polygeist_cublas_memset_zero_1d_f32(int32_t N, float *v) { + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + void *device_ptr = NULL; + if (pointer_is_device_resident(v, &device_ptr)) { + polygeist_cublas_init(); + timing_gpu_begin(); + CUDA_CHECK(cudaMemsetAsync(device_ptr, 0, (size_t)N * sizeof(float), + g_stream)); + timing_gpu_end("cuda_memset_zero_1d_f32", N, 1, 0, host_start_ms); + return; + } + memset(v, 0, (size_t)N * sizeof(float)); + timing_host_only("host_memset_zero_1d_f32", N, 1, 0, host_start_ms); +} + +// y = α·A·x + β·y, row-major. Mirrors polygeist_cublas_dgemm structure +// (alloc → H2D → cuBLAS → D2H → free) but for the gemv shape. +// +// cuBLAS is column-major; row-major y = A·x is equivalent to a column-major +// `y = Aᵀ·x` view. Pass CUBLAS_OP_T with the row-major A's storage so cuBLAS +// reads it as the transposed column-major matrix — algebraically the same. +void polygeist_cublas_dgemv( + int32_t M, int32_t N, + double alpha, + const double *A, int32_t lda, + const double *x, + double beta, + double *y) { + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t bytes_A = (size_t)M * (size_t)lda * sizeof(double); + size_t bytes_x = (size_t)N * sizeof(double); + size_t bytes_y = (size_t)M * sizeof(double); + + double *dA = (double *)register_host_safe((void *)A, bytes_A); + double *dx = (double *)register_host_safe((void *)x, bytes_x); + double *dy = (double *)register_host_safe(y, bytes_y); + + // Row-major y = A·x → col-major view of A is Aᵀ; OP_T undoes that. + timing_gpu_begin(); + CUBLAS_CHECK(cublasDgemv(g_handle, + CUBLAS_OP_T, + /*m=*/N, /*n=*/M, + &alpha, + dA, lda, + dx, 1, + &beta, + dy, 1)); + timing_gpu_end("cublasDgemv", M, N, 0, host_start_ms); + + unregister_host_safe((void *)A); + unregister_host_safe((void *)x); + unregister_host_safe(y); +} + +void polygeist_cublas_sgemv( + int32_t M, int32_t N, + float alpha, + const float *A, int32_t lda, + const float *x, + float beta, + float *y) { + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t bytes_A = (size_t)M * (size_t)lda * sizeof(float); + size_t bytes_x = (size_t)N * sizeof(float); + size_t bytes_y = (size_t)M * sizeof(float); + + float *dA = (float *)register_host_safe((void *)A, bytes_A); + float *dx = (float *)register_host_safe((void *)x, bytes_x); + float *dy = (float *)register_host_safe(y, bytes_y); + + timing_gpu_begin(); + CUBLAS_CHECK(cublasSgemv(g_handle, + CUBLAS_OP_T, + /*m=*/N, /*n=*/M, + &alpha, + dA, lda, + dx, 1, + &beta, + dy, 1)); + timing_gpu_end("cublasSgemv", M, N, 0, host_start_ms); + + unregister_host_safe((void *)A); + unregister_host_safe((void *)x); + unregister_host_safe(y); +} + +// y = α·Aᵀ·x + β·y, row-major. Shim signature is identical to the no- +// transpose dgemv shim; the only difference is the cuBLAS op flag. +// +// Row-major Aᵀ (logically N×M) · x (length M) → y (length N). The col- +// major view of row-major A IS Aᵀ, so we use CUBLAS_OP_N with the same +// (m=N, n=M, lda=lda_rowmajor) the no-transpose shim uses. +void polygeist_cublas_dgemv_T( + int32_t M, int32_t N, + double alpha, + const double *A, int32_t lda, + const double *x, + double beta, + double *y) { + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t bytes_A = (size_t)M * (size_t)lda * sizeof(double); + size_t bytes_x = (size_t)M * sizeof(double); // x is M for Aᵀ·x + size_t bytes_y = (size_t)N * sizeof(double); // y is N for Aᵀ·x + + double *dA = (double *)register_host_safe((void *)A, bytes_A); + double *dx = (double *)register_host_safe((void *)x, bytes_x); + double *dy = (double *)register_host_safe(y, bytes_y); + + timing_gpu_begin(); + CUBLAS_CHECK(cublasDgemv(g_handle, + CUBLAS_OP_N, + /*m=*/N, /*n=*/M, + &alpha, + dA, lda, + dx, 1, + &beta, + dy, 1)); + timing_gpu_end("cublasDgemv_T", M, N, 0, host_start_ms); + + unregister_host_safe((void *)A); + unregister_host_safe((void *)x); + unregister_host_safe(y); +} + +void polygeist_cublas_sgemv_T( + int32_t M, int32_t N, + float alpha, + const float *A, int32_t lda, + const float *x, + float beta, + float *y) { + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t bytes_A = (size_t)M * (size_t)lda * sizeof(float); + size_t bytes_x = (size_t)M * sizeof(float); + size_t bytes_y = (size_t)N * sizeof(float); + + float *dA = (float *)register_host_safe((void *)A, bytes_A); + float *dx = (float *)register_host_safe((void *)x, bytes_x); + float *dy = (float *)register_host_safe(y, bytes_y); + + timing_gpu_begin(); + CUBLAS_CHECK(cublasSgemv(g_handle, + CUBLAS_OP_N, + /*m=*/N, /*n=*/M, + &alpha, + dA, lda, + dx, 1, + &beta, + dy, 1)); + timing_gpu_end("cublasSgemv_T", M, N, 0, host_start_ms); + + unregister_host_safe((void *)A); + unregister_host_safe((void *)x); + unregister_host_safe(y); +} + +// Host-side scale. Could use cublasDscal but the H↔D copy overhead would +// dominate this O(MN) op; do it on the CPU side. Future device-residency +// hoisting will make this a GPU op. +void polygeist_cublas_dscal_2d(int32_t M, int32_t N, double scale, + double *A, int32_t lda) { + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + for (int32_t i = 0; i < M; ++i) { + double *row = &A[(size_t)i * (size_t)lda]; + for (int32_t j = 0; j < N; ++j) row[j] *= scale; + } + timing_host_only("host_dscal_2d", M, N, 0, host_start_ms); +} + +// cuDNN 9-tap conv2d. Filter weights passed at runtime so the same shim +// handles polybench, Sobel, Gaussian, or any other 3x3 weighted conv. +// Single-image, single-channel, FP64, no-padding, stride-1. +void polygeist_cudnn_conv2d_3x3_f64( + int32_t M, int32_t N, + double w0, double w1, double w2, + double w3, double w4, double w5, + double w6, double w7, double w8, + const double *A, double *B) { + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + polygeist_cublas_init(); + ensure_cudnn(); + + // Caller-supplied filter (laid out row-major in the 3x3 grid). + const double filter_h[9] = { w0, w1, w2, w3, w4, w5, w6, w7, w8 }; + + cudnnTensorDescriptor_t in_desc, out_desc; + cudnnFilterDescriptor_t f_desc; + cudnnConvolutionDescriptor_t conv_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&in_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&out_desc)); + CUDNN_CHECK(cudnnCreateFilterDescriptor(&f_desc)); + CUDNN_CHECK(cudnnCreateConvolutionDescriptor(&conv_desc)); + + // 1 batch, 1 channel, M×N input; FP64 NCHW + CUDNN_CHECK(cudnnSetTensor4dDescriptor(in_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_DOUBLE, 1, 1, M, N)); + // Filter: 1 out-ch, 1 in-ch, 3×3, FP64 NCHW + CUDNN_CHECK(cudnnSetFilter4dDescriptor(f_desc, CUDNN_DATA_DOUBLE, + CUDNN_TENSOR_NCHW, 1, 1, 3, 3)); + // No padding, stride 1, dilation 1; use CROSS_CORRELATION (no flip) + // since polybench's body matches cross-correlation semantics. + CUDNN_CHECK(cudnnSetConvolution2dDescriptor( + conv_desc, /*pad_h=*/0, /*pad_w=*/0, /*stride_h=*/1, /*stride_w=*/1, + /*dilation_h=*/1, /*dilation_w=*/1, + CUDNN_CROSS_CORRELATION, CUDNN_DATA_DOUBLE)); + // Output: 1 batch, 1 channel, (M-2)×(N-2) + CUDNN_CHECK(cudnnSetTensor4dDescriptor(out_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_DOUBLE, 1, 1, M - 2, N - 2)); + + // Device allocations + size_t bytes_in = (size_t)M * (size_t)N * sizeof(double); + size_t bytes_f = 9 * sizeof(double); + size_t bytes_out = (size_t)(M - 2) * (size_t)(N - 2) * sizeof(double); + double *dA = NULL, *dF = NULL, *dB = NULL; + DEVICE_MALLOC((void**)&dA, bytes_in); + DEVICE_MALLOC((void**)&dF, bytes_f); + DEVICE_MALLOC((void**)&dB, bytes_out); + CUDA_CHECK(cudaMemcpyAsync(dA, A, bytes_in, cudaMemcpyHostToDevice, g_stream)); + CUDA_CHECK(cudaMemcpyAsync(dF, filter_h, bytes_f, cudaMemcpyHostToDevice, g_stream)); + + // Algorithm choice: ask cuDNN for the best fwd algo it can serve. + cudnnConvolutionFwdAlgoPerf_t algo_perf; + int n_returned = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, + /*requestedAlgoCount=*/1, &n_returned, &algo_perf)); + if (n_returned < 1) { + fprintf(stderr, "cuDNN: no fwd algo available for this shape\n"); + abort(); + } + + // Workspace + size_t ws_size = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, algo_perf.algo, &ws_size)); + void *dWS = NULL; + if (ws_size > 0) DEVICE_MALLOC(&dWS, ws_size); + + // Run + double alpha = 1.0, beta = 0.0; + timing_gpu_begin(); + CUDNN_CHECK(cudnnConvolutionForward( + g_cudnn, &alpha, in_desc, dA, f_desc, dF, conv_desc, + algo_perf.algo, dWS, ws_size, &beta, out_desc, dB)); + timing_gpu_end("cudnnConvolution2D_9tap_f64", M, N, 9, host_start_ms); + + // The output (M-2)×(N-2) needs to be copied back into the *interior* of + // B (i.e. B[1..M-2][1..N-2]) — that's what polybench's kernel writes to. + // Copy row by row (N-2 doubles per row, into B + (i+1)*N + 1). + for (int32_t i = 0; i < M - 2; ++i) { + CUDA_CHECK(cudaMemcpyAsync( + B + (size_t)(i + 1) * (size_t)N + 1, + dB + (size_t)i * (size_t)(N - 2), + (size_t)(N - 2) * sizeof(double), + cudaMemcpyDeviceToHost, g_stream)); + } + sync_stream_if_outside_pipeline(); + + DEVICE_FREE(dA); DEVICE_FREE(dF); DEVICE_FREE(dB); + if (dWS) DEVICE_FREE(dWS); + cudnnDestroyTensorDescriptor(in_desc); + cudnnDestroyTensorDescriptor(out_desc); + cudnnDestroyFilterDescriptor(f_desc); + cudnnDestroyConvolutionDescriptor(conv_desc); +} + +// Backward-compat wrapper for the legacy hardcoded-weights call site. +// Forwards to the generic shim with polybench's filter. +void polygeist_cudnn_conv2d_polybench9tap( + int32_t M, int32_t N, const double *A, double *B) { + polygeist_cudnn_conv2d_3x3_f64(M, N, + 0.2, 0.5, -0.8, + -0.3, 0.6, -0.9, + 0.4, 0.7, 0.1, + A, B); +} + +// FP32 variant — same structure as the f64 path, but with CUDNN_DATA_FLOAT +// descriptors and float*/cudaMemcpy for f32 buffers. On Ampere+ GPUs (Orin +// included) cuDNN uses tensor-core kernels for f32 conv, so this is the +// dtype to use for actual perf comparison (f64 falls back to a generic +// non-tensor-core path). +void polygeist_cudnn_conv2d_3x3_f32( + int32_t M, int32_t N, + float w0, float w1, float w2, + float w3, float w4, float w5, + float w6, float w7, float w8, + const float *A, float *B) { + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + polygeist_cublas_init(); + ensure_cudnn(); + + const float filter_h[9] = { w0, w1, w2, w3, w4, w5, w6, w7, w8 }; + + cudnnTensorDescriptor_t in_desc, out_desc; + cudnnFilterDescriptor_t f_desc; + cudnnConvolutionDescriptor_t conv_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&in_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&out_desc)); + CUDNN_CHECK(cudnnCreateFilterDescriptor(&f_desc)); + CUDNN_CHECK(cudnnCreateConvolutionDescriptor(&conv_desc)); + + CUDNN_CHECK(cudnnSetTensor4dDescriptor(in_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, 1, M, N)); + CUDNN_CHECK(cudnnSetFilter4dDescriptor(f_desc, CUDNN_DATA_FLOAT, + CUDNN_TENSOR_NCHW, 1, 1, 3, 3)); + CUDNN_CHECK(cudnnSetConvolution2dDescriptor( + conv_desc, 0, 0, 1, 1, 1, 1, + CUDNN_CROSS_CORRELATION, CUDNN_DATA_FLOAT)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(out_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, 1, M - 2, N - 2)); + + size_t bytes_in = (size_t)M * (size_t)N * sizeof(float); + size_t bytes_f = 9 * sizeof(float); + size_t bytes_out = (size_t)(M - 2) * (size_t)(N - 2) * sizeof(float); + float *dA = NULL, *dF = NULL, *dB = NULL; + DEVICE_MALLOC((void**)&dA, bytes_in); + DEVICE_MALLOC((void**)&dF, bytes_f); + DEVICE_MALLOC((void**)&dB, bytes_out); + CUDA_CHECK(cudaMemcpyAsync(dA, A, bytes_in, cudaMemcpyHostToDevice, g_stream)); + CUDA_CHECK(cudaMemcpyAsync(dF, filter_h, bytes_f, cudaMemcpyHostToDevice, g_stream)); + + cudnnConvolutionFwdAlgoPerf_t algo_perf; + int n_returned = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, 1, &n_returned, &algo_perf)); + if (n_returned < 1) { + fprintf(stderr, "cuDNN(f32): no fwd algo available\n"); + abort(); + } + + size_t ws_size = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, algo_perf.algo, &ws_size)); + void *dWS = NULL; + if (ws_size > 0) DEVICE_MALLOC(&dWS, ws_size); + + float alpha = 1.0f, beta = 0.0f; + timing_gpu_begin(); + CUDNN_CHECK(cudnnConvolutionForward( + g_cudnn, &alpha, in_desc, dA, f_desc, dF, conv_desc, + algo_perf.algo, dWS, ws_size, &beta, out_desc, dB)); + timing_gpu_end("cudnnConvolution2D_9tap_f32", M, N, 9, host_start_ms); + + for (int32_t i = 0; i < M - 2; ++i) { + CUDA_CHECK(cudaMemcpyAsync( + B + (size_t)(i + 1) * (size_t)N + 1, + dB + (size_t)i * (size_t)(N - 2), + (size_t)(N - 2) * sizeof(float), + cudaMemcpyDeviceToHost, g_stream)); + } + sync_stream_if_outside_pipeline(); + + DEVICE_FREE(dA); DEVICE_FREE(dF); DEVICE_FREE(dB); + if (dWS) DEVICE_FREE(dWS); + cudnnDestroyTensorDescriptor(in_desc); + cudnnDestroyTensorDescriptor(out_desc); + cudnnDestroyFilterDescriptor(f_desc); + cudnnDestroyConvolutionDescriptor(conv_desc); +} + +void polygeist_cudnn_conv2d_5x5_f64( + int32_t M, int32_t N, + double w0, double w1, double w2, double w3, double w4, + double w5, double w6, double w7, double w8, double w9, + double w10, double w11, double w12, double w13, double w14, + double w15, double w16, double w17, double w18, double w19, + double w20, double w21, double w22, double w23, double w24, + const double *A, double *B) { + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + polygeist_cublas_init(); + ensure_cudnn(); + + const double filter_h[25] = { + w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, + w10, w11, w12, w13, w14, w15, w16, w17, w18, w19, + w20, w21, w22, w23, w24}; + + cudnnTensorDescriptor_t in_desc, out_desc; + cudnnFilterDescriptor_t f_desc; + cudnnConvolutionDescriptor_t conv_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&in_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&out_desc)); + CUDNN_CHECK(cudnnCreateFilterDescriptor(&f_desc)); + CUDNN_CHECK(cudnnCreateConvolutionDescriptor(&conv_desc)); + + CUDNN_CHECK(cudnnSetTensor4dDescriptor(in_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_DOUBLE, 1, 1, M, N)); + CUDNN_CHECK(cudnnSetFilter4dDescriptor(f_desc, CUDNN_DATA_DOUBLE, + CUDNN_TENSOR_NCHW, 1, 1, 5, 5)); + CUDNN_CHECK(cudnnSetConvolution2dDescriptor( + conv_desc, 0, 0, 1, 1, 1, 1, + CUDNN_CROSS_CORRELATION, CUDNN_DATA_DOUBLE)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(out_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_DOUBLE, 1, 1, M - 4, N - 4)); + + size_t bytes_in = (size_t)M * (size_t)N * sizeof(double); + size_t bytes_f = 25 * sizeof(double); + size_t bytes_out = (size_t)(M - 4) * (size_t)(N - 4) * sizeof(double); + double *dA = NULL, *dF = NULL, *dB = NULL; + DEVICE_MALLOC((void**)&dA, bytes_in); + DEVICE_MALLOC((void**)&dF, bytes_f); + DEVICE_MALLOC((void**)&dB, bytes_out); + CUDA_CHECK(cudaMemcpyAsync(dA, A, bytes_in, cudaMemcpyHostToDevice, g_stream)); + CUDA_CHECK(cudaMemcpyAsync(dF, filter_h, bytes_f, cudaMemcpyHostToDevice, g_stream)); + + cudnnConvolutionFwdAlgoPerf_t algo_perf; + int n_returned = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, 1, &n_returned, &algo_perf)); + if (n_returned < 1) { + fprintf(stderr, "cuDNN(f64 5x5): no fwd algo available\n"); + abort(); + } + + size_t ws_size = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, algo_perf.algo, &ws_size)); + void *dWS = NULL; + if (ws_size > 0) DEVICE_MALLOC(&dWS, ws_size); + + double alpha = 1.0, beta = 0.0; + timing_gpu_begin(); + CUDNN_CHECK(cudnnConvolutionForward( + g_cudnn, &alpha, in_desc, dA, f_desc, dF, conv_desc, + algo_perf.algo, dWS, ws_size, &beta, out_desc, dB)); + timing_gpu_end("cudnnConvolution2D_25tap_f64", M, N, 25, host_start_ms); + + for (int32_t i = 0; i < M - 4; ++i) { + CUDA_CHECK(cudaMemcpyAsync( + B + (size_t)i * (size_t)N, + dB + (size_t)i * (size_t)(N - 4), + (size_t)(N - 4) * sizeof(double), + cudaMemcpyDeviceToHost, g_stream)); + } + sync_stream_if_outside_pipeline(); + + DEVICE_FREE(dA); DEVICE_FREE(dF); DEVICE_FREE(dB); + if (dWS) DEVICE_FREE(dWS); + cudnnDestroyTensorDescriptor(in_desc); + cudnnDestroyTensorDescriptor(out_desc); + cudnnDestroyFilterDescriptor(f_desc); + cudnnDestroyConvolutionDescriptor(conv_desc); +} + +void polygeist_cudnn_conv2d_5x5_f32( + int32_t M, int32_t N, + float w0, float w1, float w2, float w3, float w4, + float w5, float w6, float w7, float w8, float w9, + float w10, float w11, float w12, float w13, float w14, + float w15, float w16, float w17, float w18, float w19, + float w20, float w21, float w22, float w23, float w24, + const float *A, float *B) { + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + polygeist_cublas_init(); + ensure_cudnn(); + + const float filter_h[25] = { + w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, + w10, w11, w12, w13, w14, w15, w16, w17, w18, w19, + w20, w21, w22, w23, w24}; + + cudnnTensorDescriptor_t in_desc, out_desc; + cudnnFilterDescriptor_t f_desc; + cudnnConvolutionDescriptor_t conv_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&in_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&out_desc)); + CUDNN_CHECK(cudnnCreateFilterDescriptor(&f_desc)); + CUDNN_CHECK(cudnnCreateConvolutionDescriptor(&conv_desc)); + + CUDNN_CHECK(cudnnSetTensor4dDescriptor(in_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, 1, M, N)); + CUDNN_CHECK(cudnnSetFilter4dDescriptor(f_desc, CUDNN_DATA_FLOAT, + CUDNN_TENSOR_NCHW, 1, 1, 5, 5)); + CUDNN_CHECK(cudnnSetConvolution2dDescriptor( + conv_desc, 0, 0, 1, 1, 1, 1, + CUDNN_CROSS_CORRELATION, CUDNN_DATA_FLOAT)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(out_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, 1, M - 4, N - 4)); + + size_t bytes_in = (size_t)M * (size_t)N * sizeof(float); + size_t bytes_f = 25 * sizeof(float); + size_t bytes_out = (size_t)(M - 4) * (size_t)(N - 4) * sizeof(float); + float *dA = NULL, *dF = NULL, *dB = NULL; + DEVICE_MALLOC((void**)&dA, bytes_in); + DEVICE_MALLOC((void**)&dF, bytes_f); + DEVICE_MALLOC((void**)&dB, bytes_out); + CUDA_CHECK(cudaMemcpyAsync(dA, A, bytes_in, cudaMemcpyHostToDevice, g_stream)); + CUDA_CHECK(cudaMemcpyAsync(dF, filter_h, bytes_f, cudaMemcpyHostToDevice, g_stream)); + + cudnnConvolutionFwdAlgoPerf_t algo_perf; + int n_returned = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, 1, &n_returned, &algo_perf)); + if (n_returned < 1) { + fprintf(stderr, "cuDNN(f32 5x5): no fwd algo available\n"); + abort(); + } + + size_t ws_size = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, algo_perf.algo, &ws_size)); + void *dWS = NULL; + if (ws_size > 0) DEVICE_MALLOC(&dWS, ws_size); + + float alpha = 1.0f, beta = 0.0f; + timing_gpu_begin(); + CUDNN_CHECK(cudnnConvolutionForward( + g_cudnn, &alpha, in_desc, dA, f_desc, dF, conv_desc, + algo_perf.algo, dWS, ws_size, &beta, out_desc, dB)); + timing_gpu_end("cudnnConvolution2D_25tap_f32", M, N, 25, host_start_ms); + + for (int32_t i = 0; i < M - 4; ++i) { + CUDA_CHECK(cudaMemcpyAsync( + B + (size_t)i * (size_t)N, + dB + (size_t)i * (size_t)(N - 4), + (size_t)(N - 4) * sizeof(float), + cudaMemcpyDeviceToHost, g_stream)); + } + sync_stream_if_outside_pipeline(); + + DEVICE_FREE(dA); DEVICE_FREE(dF); DEVICE_FREE(dB); + if (dWS) DEVICE_FREE(dWS); + cudnnDestroyTensorDescriptor(in_desc); + cudnnDestroyTensorDescriptor(out_desc); + cudnnDestroyFilterDescriptor(f_desc); + cudnnDestroyConvolutionDescriptor(conv_desc); +} + +void polygeist_cudnn_conv2d_ntap_f64( + int32_t M, int32_t N, int32_t K, + const double *W, const double *A, double *B) { + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + polygeist_cublas_init(); + ensure_cudnn(); + + int32_t out_h = M - (K - 1); + int32_t out_w = N - (K - 1); + cudnnTensorDescriptor_t in_desc, out_desc; + cudnnFilterDescriptor_t f_desc; + cudnnConvolutionDescriptor_t conv_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&in_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&out_desc)); + CUDNN_CHECK(cudnnCreateFilterDescriptor(&f_desc)); + CUDNN_CHECK(cudnnCreateConvolutionDescriptor(&conv_desc)); + + CUDNN_CHECK(cudnnSetTensor4dDescriptor(in_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_DOUBLE, 1, 1, M, N)); + CUDNN_CHECK(cudnnSetFilter4dDescriptor(f_desc, CUDNN_DATA_DOUBLE, + CUDNN_TENSOR_NCHW, 1, 1, K, K)); + CUDNN_CHECK(cudnnSetConvolution2dDescriptor( + conv_desc, 0, 0, 1, 1, 1, 1, + CUDNN_CROSS_CORRELATION, CUDNN_DATA_DOUBLE)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(out_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_DOUBLE, 1, 1, out_h, out_w)); + + size_t bytes_in = (size_t)M * (size_t)N * sizeof(double); + size_t bytes_f = (size_t)K * (size_t)K * sizeof(double); + size_t bytes_out = (size_t)out_h * (size_t)out_w * sizeof(double); + double *dA = NULL, *dF = NULL, *dB = NULL; + DEVICE_MALLOC((void**)&dA, bytes_in); + DEVICE_MALLOC((void**)&dF, bytes_f); + DEVICE_MALLOC((void**)&dB, bytes_out); + CUDA_CHECK(cudaMemcpyAsync(dA, A, bytes_in, cudaMemcpyHostToDevice, g_stream)); + CUDA_CHECK(cudaMemcpyAsync(dF, W, bytes_f, cudaMemcpyHostToDevice, g_stream)); + + cudnnConvolutionFwdAlgoPerf_t algo_perf; + int n_returned = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, 1, &n_returned, &algo_perf)); + if (n_returned < 1) { + fprintf(stderr, "cuDNN(f64 ntap): no fwd algo available\n"); + abort(); + } + + size_t ws_size = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, algo_perf.algo, &ws_size)); + void *dWS = NULL; + if (ws_size > 0) DEVICE_MALLOC(&dWS, ws_size); + + double alpha = 1.0, beta = 0.0; + timing_gpu_begin(); + CUDNN_CHECK(cudnnConvolutionForward( + g_cudnn, &alpha, in_desc, dA, f_desc, dF, conv_desc, + algo_perf.algo, dWS, ws_size, &beta, out_desc, dB)); + timing_gpu_end("cudnnConvolution2D_ntap_f64", M, N, K * K, host_start_ms); + + for (int32_t i = 0; i < out_h; ++i) { + CUDA_CHECK(cudaMemcpyAsync( + B + (size_t)i * (size_t)N, + dB + (size_t)i * (size_t)out_w, + (size_t)out_w * sizeof(double), + cudaMemcpyDeviceToHost, g_stream)); + } + sync_stream_if_outside_pipeline(); + + DEVICE_FREE(dA); DEVICE_FREE(dF); DEVICE_FREE(dB); + if (dWS) DEVICE_FREE(dWS); + cudnnDestroyTensorDescriptor(in_desc); + cudnnDestroyTensorDescriptor(out_desc); + cudnnDestroyFilterDescriptor(f_desc); + cudnnDestroyConvolutionDescriptor(conv_desc); +} + +void polygeist_cudnn_conv2d_ntap_f32( + int32_t M, int32_t N, int32_t K, + const float *W, const float *A, float *B) { + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + polygeist_cublas_init(); + ensure_cudnn(); + + int32_t out_h = M - (K - 1); + int32_t out_w = N - (K - 1); + cudnnTensorDescriptor_t in_desc, out_desc; + cudnnFilterDescriptor_t f_desc; + cudnnConvolutionDescriptor_t conv_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&in_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&out_desc)); + CUDNN_CHECK(cudnnCreateFilterDescriptor(&f_desc)); + CUDNN_CHECK(cudnnCreateConvolutionDescriptor(&conv_desc)); + + CUDNN_CHECK(cudnnSetTensor4dDescriptor(in_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, 1, M, N)); + CUDNN_CHECK(cudnnSetFilter4dDescriptor(f_desc, CUDNN_DATA_FLOAT, + CUDNN_TENSOR_NCHW, 1, 1, K, K)); + CUDNN_CHECK(cudnnSetConvolution2dDescriptor( + conv_desc, 0, 0, 1, 1, 1, 1, + CUDNN_CROSS_CORRELATION, CUDNN_DATA_FLOAT)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(out_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, 1, out_h, out_w)); + + size_t bytes_in = (size_t)M * (size_t)N * sizeof(float); + size_t bytes_f = (size_t)K * (size_t)K * sizeof(float); + size_t bytes_out = (size_t)out_h * (size_t)out_w * sizeof(float); + float *dA = NULL, *dF = NULL, *dB = NULL; + DEVICE_MALLOC((void**)&dA, bytes_in); + DEVICE_MALLOC((void**)&dF, bytes_f); + DEVICE_MALLOC((void**)&dB, bytes_out); + CUDA_CHECK(cudaMemcpyAsync(dA, A, bytes_in, cudaMemcpyHostToDevice, g_stream)); + CUDA_CHECK(cudaMemcpyAsync(dF, W, bytes_f, cudaMemcpyHostToDevice, g_stream)); + + cudnnConvolutionFwdAlgoPerf_t algo_perf; + int n_returned = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, 1, &n_returned, &algo_perf)); + if (n_returned < 1) { + fprintf(stderr, "cuDNN(f32 ntap): no fwd algo available\n"); + abort(); + } + + size_t ws_size = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, algo_perf.algo, &ws_size)); + void *dWS = NULL; + if (ws_size > 0) DEVICE_MALLOC(&dWS, ws_size); + + float alpha = 1.0f, beta = 0.0f; + timing_gpu_begin(); + CUDNN_CHECK(cudnnConvolutionForward( + g_cudnn, &alpha, in_desc, dA, f_desc, dF, conv_desc, + algo_perf.algo, dWS, ws_size, &beta, out_desc, dB)); + timing_gpu_end("cudnnConvolution2D_ntap_f32", M, N, K * K, host_start_ms); + + for (int32_t i = 0; i < out_h; ++i) { + CUDA_CHECK(cudaMemcpyAsync( + B + (size_t)i * (size_t)N, + dB + (size_t)i * (size_t)out_w, + (size_t)out_w * sizeof(float), + cudaMemcpyDeviceToHost, g_stream)); + } + sync_stream_if_outside_pipeline(); + + DEVICE_FREE(dA); DEVICE_FREE(dF); DEVICE_FREE(dB); + if (dWS) DEVICE_FREE(dWS); + cudnnDestroyTensorDescriptor(in_desc); + cudnnDestroyTensorDescriptor(out_desc); + cudnnDestroyFilterDescriptor(f_desc); + cudnnDestroyConvolutionDescriptor(conv_desc); +} + +void polygeist_cudnn_conv3d_ntap_f64( + int32_t inD, int32_t inH, int32_t inW, + int32_t outD, int32_t outH, int32_t outW, + int32_t K, + const double *W, const double *A, double *B) { + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + polygeist_cublas_init(); + ensure_cudnn(); + + cudnnTensorDescriptor_t in_desc, out_desc; + cudnnFilterDescriptor_t f_desc; + cudnnConvolutionDescriptor_t conv_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&in_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&out_desc)); + CUDNN_CHECK(cudnnCreateFilterDescriptor(&f_desc)); + CUDNN_CHECK(cudnnCreateConvolutionDescriptor(&conv_desc)); + + int in_dims[5] = {1, 1, inD, inH, inW}; + int in_strides[5] = { + inD * inH * inW, inD * inH * inW, inH * inW, inW, 1}; + int out_dims[5] = {1, 1, outD, outH, outW}; + int out_strides[5] = { + outD * outH * outW, outD * outH * outW, outH * outW, outW, 1}; + int filt_dims[5] = {1, 1, K, K, K}; + int pad[3] = {0, 0, 0}; + int stride[3] = {1, 1, 1}; + int dilation[3] = {1, 1, 1}; + + CUDNN_CHECK(cudnnSetTensorNdDescriptor( + in_desc, CUDNN_DATA_DOUBLE, 5, in_dims, in_strides)); + CUDNN_CHECK(cudnnSetFilterNdDescriptor( + f_desc, CUDNN_DATA_DOUBLE, CUDNN_TENSOR_NCHW, 5, filt_dims)); + CUDNN_CHECK(cudnnSetConvolutionNdDescriptor( + conv_desc, 3, pad, stride, dilation, + CUDNN_CROSS_CORRELATION, CUDNN_DATA_DOUBLE)); + CUDNN_CHECK(cudnnSetTensorNdDescriptor( + out_desc, CUDNN_DATA_DOUBLE, 5, out_dims, out_strides)); + + size_t bytes_in = (size_t)inD * (size_t)inH * (size_t)inW * sizeof(double); + size_t bytes_f = (size_t)K * (size_t)K * (size_t)K * sizeof(double); + size_t bytes_out = + (size_t)outD * (size_t)outH * (size_t)outW * sizeof(double); + double *dA = NULL, *dF = NULL, *dB = NULL; + DEVICE_MALLOC((void**)&dA, bytes_in); + DEVICE_MALLOC((void**)&dF, bytes_f); + DEVICE_MALLOC((void**)&dB, bytes_out); + CUDA_CHECK(cudaMemcpyAsync(dA, A, bytes_in, cudaMemcpyHostToDevice, g_stream)); + CUDA_CHECK(cudaMemcpyAsync(dF, W, bytes_f, cudaMemcpyHostToDevice, g_stream)); + + cudnnConvolutionFwdAlgoPerf_t algo_perf; + int n_returned = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, 1, &n_returned, &algo_perf)); + if (n_returned < 1) { + fprintf(stderr, "cuDNN(f64 conv3d ntap): no fwd algo available\n"); + abort(); + } + + size_t ws_size = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, algo_perf.algo, &ws_size)); + void *dWS = NULL; + if (ws_size > 0) DEVICE_MALLOC(&dWS, ws_size); + + double alpha = 1.0, beta = 0.0; + timing_gpu_begin(); + CUDNN_CHECK(cudnnConvolutionForward( + g_cudnn, &alpha, in_desc, dA, f_desc, dF, conv_desc, + algo_perf.algo, dWS, ws_size, &beta, out_desc, dB)); + timing_gpu_end("cudnnConvolution3D_ntap_f64", + outD, outH * outW, K * K * K, host_start_ms); + + CUDA_CHECK(cudaMemcpyAsync(B, dB, bytes_out, cudaMemcpyDeviceToHost, g_stream)); + sync_stream_if_outside_pipeline(); + + DEVICE_FREE(dA); DEVICE_FREE(dF); DEVICE_FREE(dB); + if (dWS) DEVICE_FREE(dWS); + cudnnDestroyTensorDescriptor(in_desc); + cudnnDestroyTensorDescriptor(out_desc); + cudnnDestroyFilterDescriptor(f_desc); + cudnnDestroyConvolutionDescriptor(conv_desc); +} + +void polygeist_cudnn_conv3d_ntap_f32( + int32_t inD, int32_t inH, int32_t inW, + int32_t outD, int32_t outH, int32_t outW, + int32_t K, + const float *W, const float *A, float *B) { + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + polygeist_cublas_init(); + ensure_cudnn(); + + cudnnTensorDescriptor_t in_desc, out_desc; + cudnnFilterDescriptor_t f_desc; + cudnnConvolutionDescriptor_t conv_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&in_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&out_desc)); + CUDNN_CHECK(cudnnCreateFilterDescriptor(&f_desc)); + CUDNN_CHECK(cudnnCreateConvolutionDescriptor(&conv_desc)); + + int in_dims[5] = {1, 1, inD, inH, inW}; + int in_strides[5] = { + inD * inH * inW, inD * inH * inW, inH * inW, inW, 1}; + int out_dims[5] = {1, 1, outD, outH, outW}; + int out_strides[5] = { + outD * outH * outW, outD * outH * outW, outH * outW, outW, 1}; + int filt_dims[5] = {1, 1, K, K, K}; + int pad[3] = {0, 0, 0}; + int stride[3] = {1, 1, 1}; + int dilation[3] = {1, 1, 1}; + + CUDNN_CHECK(cudnnSetTensorNdDescriptor( + in_desc, CUDNN_DATA_FLOAT, 5, in_dims, in_strides)); + CUDNN_CHECK(cudnnSetFilterNdDescriptor( + f_desc, CUDNN_DATA_FLOAT, CUDNN_TENSOR_NCHW, 5, filt_dims)); + CUDNN_CHECK(cudnnSetConvolutionNdDescriptor( + conv_desc, 3, pad, stride, dilation, + CUDNN_CROSS_CORRELATION, CUDNN_DATA_FLOAT)); + CUDNN_CHECK(cudnnSetTensorNdDescriptor( + out_desc, CUDNN_DATA_FLOAT, 5, out_dims, out_strides)); + + size_t bytes_in = (size_t)inD * (size_t)inH * (size_t)inW * sizeof(float); + size_t bytes_f = (size_t)K * (size_t)K * (size_t)K * sizeof(float); + size_t bytes_out = + (size_t)outD * (size_t)outH * (size_t)outW * sizeof(float); + float *dA = NULL, *dF = NULL, *dB = NULL; + DEVICE_MALLOC((void**)&dA, bytes_in); + DEVICE_MALLOC((void**)&dF, bytes_f); + DEVICE_MALLOC((void**)&dB, bytes_out); + CUDA_CHECK(cudaMemcpyAsync(dA, A, bytes_in, cudaMemcpyHostToDevice, g_stream)); + CUDA_CHECK(cudaMemcpyAsync(dF, W, bytes_f, cudaMemcpyHostToDevice, g_stream)); + + cudnnConvolutionFwdAlgoPerf_t algo_perf; + int n_returned = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, 1, &n_returned, &algo_perf)); + if (n_returned < 1) { + fprintf(stderr, "cuDNN(f32 conv3d ntap): no fwd algo available\n"); + abort(); + } + + size_t ws_size = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, algo_perf.algo, &ws_size)); + void *dWS = NULL; + if (ws_size > 0) DEVICE_MALLOC(&dWS, ws_size); + + float alpha = 1.0f, beta = 0.0f; + timing_gpu_begin(); + CUDNN_CHECK(cudnnConvolutionForward( + g_cudnn, &alpha, in_desc, dA, f_desc, dF, conv_desc, + algo_perf.algo, dWS, ws_size, &beta, out_desc, dB)); + timing_gpu_end("cudnnConvolution3D_ntap_f32", + outD, outH * outW, K * K * K, host_start_ms); + + CUDA_CHECK(cudaMemcpyAsync(B, dB, bytes_out, cudaMemcpyDeviceToHost, g_stream)); + sync_stream_if_outside_pipeline(); + + DEVICE_FREE(dA); DEVICE_FREE(dF); DEVICE_FREE(dB); + if (dWS) DEVICE_FREE(dWS); + cudnnDestroyTensorDescriptor(in_desc); + cudnnDestroyTensorDescriptor(out_desc); + cudnnDestroyFilterDescriptor(f_desc); + cudnnDestroyConvolutionDescriptor(conv_desc); +} + +extern void polygeist_custom_stencil3d_7pt_flat_f64_device( + int32_t N, + const double *a0, const double *a1, const double *a2, + const double *a3, const double *a4, const double *a5, + const double *a6, const double *extra, const double *coeff, + double *out, + double base0, double base_extra, double coeff_extra, + double c0, double c1, double c2, double c3, + double c4, double c5, double c6, + void *cuda_stream) __attribute__((weak)); + +extern void polygeist_custom_stencil3d_7pt_flat_f32_device( + int32_t N, + const float *a0, const float *a1, const float *a2, + const float *a3, const float *a4, const float *a5, + const float *a6, const float *extra, const float *coeff, + float *out, + float base0, float base_extra, float coeff_extra, + float c0, float c1, float c2, float c3, + float c4, float c5, float c6, + void *cuda_stream) __attribute__((weak)); + +static void polygeist_custom_stencil3d_7pt_flat_f64_cpu( + int32_t N, + const double *a0, const double *a1, const double *a2, + const double *a3, const double *a4, const double *a5, + const double *a6, const double *extra, const double *coeff, + double *out, + double base0, double base_extra, double coeff_extra, + double c0, double c1, double c2, double c3, + double c4, double c5, double c6) { + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + for (int32_t i = 0; i < N; ++i) { + double extra_v = extra ? extra[i] : 0.0; + double scale = coeff ? coeff[i] : 1.0; + double base = base0 * a0[i] + (extra ? base_extra * extra_v : 0.0); + double inner = c0 * a0[i] + c1 * a1[i] + c2 * a2[i] + + c3 * a3[i] + c4 * a4[i] + c5 * a5[i] + + c6 * a6[i] + (extra ? coeff_extra * extra_v : 0.0); + out[i] = base + scale * inner; + } + if (timing_enabled()) { + fprintf(timing_file(), + "POLYGEIST_RT_TIMING\top=customStencil3D7pt_f64_cpu_fallback" + "\tm=%d\tn=1\tk=7\thost_ms=%.6f\tdevice_ms=0.000000\n", + N, wall_time_ms() - host_start_ms); + fflush(timing_file()); + } +} + +static void polygeist_custom_stencil3d_7pt_flat_f32_cpu( + int32_t N, + const float *a0, const float *a1, const float *a2, + const float *a3, const float *a4, const float *a5, + const float *a6, const float *extra, const float *coeff, + float *out, + float base0, float base_extra, float coeff_extra, + float c0, float c1, float c2, float c3, + float c4, float c5, float c6) { + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + for (int32_t i = 0; i < N; ++i) { + float extra_v = extra ? extra[i] : 0.0f; + float scale = coeff ? coeff[i] : 1.0f; + float base = base0 * a0[i] + (extra ? base_extra * extra_v : 0.0f); + float inner = c0 * a0[i] + c1 * a1[i] + c2 * a2[i] + + c3 * a3[i] + c4 * a4[i] + c5 * a5[i] + + c6 * a6[i] + (extra ? coeff_extra * extra_v : 0.0f); + out[i] = base + scale * inner; + } + if (timing_enabled()) { + fprintf(timing_file(), + "POLYGEIST_RT_TIMING\top=customStencil3D7pt_f32_cpu_fallback" + "\tm=%d\tn=1\tk=7\thost_ms=%.6f\tdevice_ms=0.000000\n", + N, wall_time_ms() - host_start_ms); + fflush(timing_file()); + } +} + +void polygeist_custom_stencil3d_7pt_flat_f64( + int32_t N, + const double *a0, const double *a1, const double *a2, + const double *a3, const double *a4, const double *a5, + const double *a6, const double *extra, const double *coeff, + double *out, + double base0, double base_extra, double coeff_extra, + double c0, double c1, double c2, double c3, + double c4, double c5, double c6) { + if (!polygeist_custom_stencil3d_7pt_flat_f64_device) { + polygeist_custom_stencil3d_7pt_flat_f64_cpu( + N, a0, a1, a2, a3, a4, a5, a6, extra, coeff, out, + base0, base_extra, coeff_extra, c0, c1, c2, c3, c4, c5, c6); + return; + } + if (N <= 0) + return; + + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + size_t bytes = (size_t)N * sizeof(double); + + double *d0 = (double *)register_host_safe((void *)a0, bytes); + double *d1 = (double *)register_host_safe((void *)a1, bytes); + double *d2 = (double *)register_host_safe((void *)a2, bytes); + double *d3 = (double *)register_host_safe((void *)a3, bytes); + double *d4 = (double *)register_host_safe((void *)a4, bytes); + double *d5 = (double *)register_host_safe((void *)a5, bytes); + double *d6 = (double *)register_host_safe((void *)a6, bytes); + double *dextra = + extra ? (double *)register_host_safe((void *)extra, bytes) : NULL; + double *dcoeff = + coeff ? (double *)register_host_safe((void *)coeff, bytes) : NULL; + double *dout = (double *)register_host_safe(out, bytes); + + timing_gpu_begin(); + polygeist_custom_stencil3d_7pt_flat_f64_device( + N, d0, d1, d2, d3, d4, d5, d6, dextra, dcoeff, dout, + base0, base_extra, coeff_extra, c0, c1, c2, c3, c4, c5, c6, g_stream); + timing_gpu_end("customStencil3D7pt_f64", N, 1, 7, host_start_ms); + + unregister_host_safe((void *)a0); + unregister_host_safe((void *)a1); + unregister_host_safe((void *)a2); + unregister_host_safe((void *)a3); + unregister_host_safe((void *)a4); + unregister_host_safe((void *)a5); + unregister_host_safe((void *)a6); + if (extra) + unregister_host_safe((void *)extra); + if (coeff) + unregister_host_safe((void *)coeff); + unregister_host_safe(out); +} + +void polygeist_custom_stencil3d_7pt_flat_f32( + int32_t N, + const float *a0, const float *a1, const float *a2, + const float *a3, const float *a4, const float *a5, + const float *a6, const float *extra, const float *coeff, + float *out, + float base0, float base_extra, float coeff_extra, + float c0, float c1, float c2, float c3, + float c4, float c5, float c6) { + if (!polygeist_custom_stencil3d_7pt_flat_f32_device) { + polygeist_custom_stencil3d_7pt_flat_f32_cpu( + N, a0, a1, a2, a3, a4, a5, a6, extra, coeff, out, + base0, base_extra, coeff_extra, c0, c1, c2, c3, c4, c5, c6); + return; + } + if (N <= 0) + return; + + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + size_t bytes = (size_t)N * sizeof(float); + + float *d0 = (float *)register_host_safe((void *)a0, bytes); + float *d1 = (float *)register_host_safe((void *)a1, bytes); + float *d2 = (float *)register_host_safe((void *)a2, bytes); + float *d3 = (float *)register_host_safe((void *)a3, bytes); + float *d4 = (float *)register_host_safe((void *)a4, bytes); + float *d5 = (float *)register_host_safe((void *)a5, bytes); + float *d6 = (float *)register_host_safe((void *)a6, bytes); + float *dextra = + extra ? (float *)register_host_safe((void *)extra, bytes) : NULL; + float *dcoeff = + coeff ? (float *)register_host_safe((void *)coeff, bytes) : NULL; + float *dout = (float *)register_host_safe(out, bytes); + + timing_gpu_begin(); + polygeist_custom_stencil3d_7pt_flat_f32_device( + N, d0, d1, d2, d3, d4, d5, d6, dextra, dcoeff, dout, + base0, base_extra, coeff_extra, c0, c1, c2, c3, c4, c5, c6, g_stream); + timing_gpu_end("customStencil3D7pt_f32", N, 1, 7, host_start_ms); + + unregister_host_safe((void *)a0); + unregister_host_safe((void *)a1); + unregister_host_safe((void *)a2); + unregister_host_safe((void *)a3); + unregister_host_safe((void *)a4); + unregister_host_safe((void *)a5); + unregister_host_safe((void *)a6); + if (extra) + unregister_host_safe((void *)extra); + if (coeff) + unregister_host_safe((void *)coeff); + unregister_host_safe(out); +} + +static void polygeist_dft_z2z_1d_cpu( + int32_t N, int32_t inverse, const double *A, double *B) { + if (N <= 0) return; + const double sign = inverse ? 1.0 : -1.0; + for (int32_t k = 0; k < N; ++k) { + double sum_re = 0.0; + double sum_im = 0.0; + for (int32_t n = 0; n < N; ++n) { + double angle = sign * 2.0 * M_PI * (double)k * (double)n / (double)N; + double c = cos(angle); + double s = sin(angle); + double ar = A[(size_t)2 * (size_t)n + 0]; + double ai = A[(size_t)2 * (size_t)n + 1]; + sum_re += ar * c - ai * s; + sum_im += ar * s + ai * c; + } + B[(size_t)2 * (size_t)k + 0] = sum_re; + B[(size_t)2 * (size_t)k + 1] = sum_im; + } +} + +static void polygeist_dft_c2c_1d_cpu( + int32_t N, int32_t inverse, const float *A, float *B) { + if (N <= 0) return; + const float sign = inverse ? 1.0f : -1.0f; + for (int32_t k = 0; k < N; ++k) { + float sum_re = 0.0f; + float sum_im = 0.0f; + for (int32_t n = 0; n < N; ++n) { + float angle = sign * 2.0f * (float)M_PI * (float)k * (float)n / (float)N; + float c = cosf(angle); + float s = sinf(angle); + float ar = A[(size_t)2 * (size_t)n + 0]; + float ai = A[(size_t)2 * (size_t)n + 1]; + sum_re += ar * c - ai * s; + sum_im += ar * s + ai * c; + } + B[(size_t)2 * (size_t)k + 0] = sum_re; + B[(size_t)2 * (size_t)k + 1] = sum_im; + } +} + +void polygeist_cufft_z2z_1d( + int32_t N, int32_t inverse, const double *A, double *B) { + if (N <= 0) return; +#if POLYGEIST_HAS_CUFFT + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + polygeist_cublas_init(); + size_t bytes = (size_t)2 * (size_t)N * sizeof(double); + cufftDoubleComplex *dA = NULL; + cufftDoubleComplex *dB = NULL; + DEVICE_MALLOC((void**)&dA, bytes); + DEVICE_MALLOC((void**)&dB, bytes); + CUDA_CHECK(cudaMemcpyAsync(dA, A, bytes, cudaMemcpyHostToDevice, g_stream)); + + cufftHandle plan; + CUFFT_CHECK(cufftPlan1d(&plan, N, CUFFT_Z2Z, 1)); + CUFFT_CHECK(cufftSetStream(plan, g_stream)); + timing_gpu_begin(); + CUFFT_CHECK(cufftExecZ2Z( + plan, dA, dB, inverse ? CUFFT_INVERSE : CUFFT_FORWARD)); + timing_gpu_end("cufftZ2Z_1D", N, 1, inverse ? -1 : 1, host_start_ms); + + CUDA_CHECK(cudaMemcpyAsync(B, dB, bytes, cudaMemcpyDeviceToHost, g_stream)); + sync_stream_if_outside_pipeline(); + CUFFT_CHECK(cufftDestroy(plan)); + DEVICE_FREE(dA); + DEVICE_FREE(dB); +#else + polygeist_dft_z2z_1d_cpu(N, inverse, A, B); +#endif +} + +void polygeist_cufft_c2c_1d( + int32_t N, int32_t inverse, const float *A, float *B) { + if (N <= 0) return; +#if POLYGEIST_HAS_CUFFT + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + polygeist_cublas_init(); + size_t bytes = (size_t)2 * (size_t)N * sizeof(float); + cufftComplex *dA = NULL; + cufftComplex *dB = NULL; + DEVICE_MALLOC((void**)&dA, bytes); + DEVICE_MALLOC((void**)&dB, bytes); + CUDA_CHECK(cudaMemcpyAsync(dA, A, bytes, cudaMemcpyHostToDevice, g_stream)); + + cufftHandle plan; + CUFFT_CHECK(cufftPlan1d(&plan, N, CUFFT_C2C, 1)); + CUFFT_CHECK(cufftSetStream(plan, g_stream)); + timing_gpu_begin(); + CUFFT_CHECK(cufftExecC2C( + plan, dA, dB, inverse ? CUFFT_INVERSE : CUFFT_FORWARD)); + timing_gpu_end("cufftC2C_1D", N, 1, inverse ? -1 : 1, host_start_ms); + + CUDA_CHECK(cudaMemcpyAsync(B, dB, bytes, cudaMemcpyDeviceToHost, g_stream)); + sync_stream_if_outside_pipeline(); + CUFFT_CHECK(cufftDestroy(plan)); + DEVICE_FREE(dA); + DEVICE_FREE(dB); +#else + polygeist_dft_c2c_1d_cpu(N, inverse, A, B); +#endif +} + +static void polygeist_cutensornet_tensor_product_3d_impl( + int32_t KQ, int32_t KP, const void *psi, const void *u, void *out, + size_t elementBytes, cudaDataType_t dataType) { +#if POLYGEIST_HAS_CUTENSORNET + if (KQ <= 0 || KP <= 0) return; + polygeist_cublas_init(); + + size_t psiBytes = (size_t)KQ * (size_t)KP * elementBytes; + size_t uBytes = (size_t)KP * (size_t)KP * (size_t)KP * elementBytes; + size_t outBytes = (size_t)KQ * (size_t)KQ * (size_t)KQ * elementBytes; + void *dPsi = register_host_safe((void *)psi, psiBytes); + void *dU = register_host_safe((void *)u, uBytes); + void *dOut = register_host_safe(out, outBytes); + + cutensornetHandle_t handle = NULL; + cutensornetNetworkDescriptor_t network = NULL; + cutensornetContractionOptimizerConfig_t config = NULL; + cutensornetContractionOptimizerInfo_t info = NULL; + cutensornetWorkspaceDescriptor_t workspace = NULL; + void *scratch = NULL; + + // Row-major mode layouts for ai,bj,ck,ijk->abc. + const int64_t psiExtents[2] = {KQ, KP}; + const int64_t uExtents[3] = {KP, KP, KP}; + const int64_t outExtents[3] = {KQ, KQ, KQ}; + const int64_t psiStrides[2] = {KP, 1}; + const int64_t uStrides[3] = {(int64_t)KP * KP, KP, 1}; + const int64_t outStrides[3] = {(int64_t)KQ * KQ, KQ, 1}; + const int32_t modesPsiA[2] = {'a', 'i'}; + const int32_t modesPsiB[2] = {'b', 'j'}; + const int32_t modesPsiC[2] = {'c', 'k'}; + const int32_t modesU[3] = {'i', 'j', 'k'}; + const int32_t modesOut[3] = {'a', 'b', 'c'}; + int64_t tensorIds[4] = {-1, -1, -1, -1}; + + CUTENSORNET_CHECK(cutensornetCreate(&handle)); + CUTENSORNET_CHECK(cutensornetCreateNetwork(handle, &network)); + CUTENSORNET_CHECK(cutensornetNetworkAppendTensor( + handle, network, 2, psiExtents, modesPsiA, NULL, dataType, + &tensorIds[0])); + CUTENSORNET_CHECK(cutensornetNetworkAppendTensor( + handle, network, 2, psiExtents, modesPsiB, NULL, dataType, + &tensorIds[1])); + CUTENSORNET_CHECK(cutensornetNetworkAppendTensor( + handle, network, 2, psiExtents, modesPsiC, NULL, dataType, + &tensorIds[2])); + CUTENSORNET_CHECK(cutensornetNetworkAppendTensor( + handle, network, 3, uExtents, modesU, NULL, dataType, + &tensorIds[3])); + CUTENSORNET_CHECK(cutensornetNetworkSetOutputTensor( + handle, network, 3, modesOut, dataType)); + CUTENSORNET_CHECK(cutensornetNetworkSetInputTensorMemory( + handle, network, tensorIds[0], dPsi, psiStrides)); + CUTENSORNET_CHECK(cutensornetNetworkSetInputTensorMemory( + handle, network, tensorIds[1], dPsi, psiStrides)); + CUTENSORNET_CHECK(cutensornetNetworkSetInputTensorMemory( + handle, network, tensorIds[2], dPsi, psiStrides)); + CUTENSORNET_CHECK(cutensornetNetworkSetInputTensorMemory( + handle, network, tensorIds[3], dU, uStrides)); + CUTENSORNET_CHECK(cutensornetNetworkSetOutputTensorMemory( + handle, network, dOut, outStrides)); + CUTENSORNET_CHECK( + cutensornetCreateContractionOptimizerConfig(handle, &config)); + CUTENSORNET_CHECK( + cutensornetCreateContractionOptimizerInfo(handle, network, &info)); + const uint64_t workspaceLimit = UINT64_C(256) * 1024 * 1024; + CUTENSORNET_CHECK(cutensornetContractionOptimize( + handle, network, config, workspaceLimit, info)); + CUTENSORNET_CHECK( + cutensornetNetworkSetOptimizerInfo(handle, network, info)); + CUTENSORNET_CHECK(cutensornetCreateWorkspaceDescriptor(handle, &workspace)); + CUTENSORNET_CHECK(cutensornetWorkspaceComputeContractionSizes( + handle, network, info, workspace)); + int64_t scratchBytes = 0; + CUTENSORNET_CHECK(cutensornetWorkspaceGetMemorySize( + handle, workspace, CUTENSORNET_WORKSIZE_PREF_RECOMMENDED, + CUTENSORNET_MEMSPACE_DEVICE, CUTENSORNET_WORKSPACE_SCRATCH, + &scratchBytes)); + if (scratchBytes > 0) + scratch = pipeline_device_malloc((size_t)scratchBytes); + CUTENSORNET_CHECK(cutensornetWorkspaceSetMemory( + handle, workspace, CUTENSORNET_MEMSPACE_DEVICE, + CUTENSORNET_WORKSPACE_SCRATCH, scratch, scratchBytes)); + CUTENSORNET_CHECK( + cutensornetNetworkPrepareContraction(handle, network, workspace)); + CUTENSORNET_CHECK(cutensornetNetworkContract( + handle, network, 0, workspace, NULL, g_stream)); + + // The network objects are currently per-call, so contraction must finish + // before their destruction. A future shape-keyed plan cache can remove + // this synchronization and recover pipeline overlap. + CUDA_CHECK(cudaStreamSynchronize(g_stream)); + pipeline_device_free(scratch); + CUTENSORNET_CHECK(cutensornetDestroyWorkspaceDescriptor(workspace)); + CUTENSORNET_CHECK(cutensornetDestroyContractionOptimizerInfo(info)); + CUTENSORNET_CHECK(cutensornetDestroyContractionOptimizerConfig(config)); + CUTENSORNET_CHECK(cutensornetDestroyNetwork(network)); + CUTENSORNET_CHECK(cutensornetDestroy(handle)); + unregister_host_safe((void *)psi); + unregister_host_safe((void *)u); + unregister_host_safe(out); +#else + (void)KQ; (void)KP; (void)psi; (void)u; (void)out; + (void)elementBytes; (void)dataType; + fprintf(stderr, + "polygeist runtime: cuTensorNet support was not enabled at build " + "time (define POLYGEIST_ENABLE_CUTENSORNET and link " + "-lcutensornet -lcutensor)\n"); + abort(); +#endif +} + +void polygeist_cutensornet_tensor_product_3d_f32( + int32_t KQ, int32_t KP, const float *psi, const float *u, float *out) { + polygeist_cutensornet_tensor_product_3d_impl( + KQ, KP, psi, u, out, sizeof(float), CUDA_R_32F); +} + +void polygeist_cutensornet_tensor_product_3d_f64( + int32_t KQ, int32_t KP, const double *psi, const double *u, double *out) { + polygeist_cutensornet_tensor_product_3d_impl( + KQ, KP, psi, u, out, sizeof(double), CUDA_R_64F); +} + +enum { POLYGEIST_CONTRACTION_MAX_MODES = 64 }; + +static int polygeist_parse_contraction2_f64_metadata( + const int64_t *metadata, int64_t ranks[3], + int64_t extents[3][POLYGEIST_CONTRACTION_MAX_MODES], + int64_t strides[3][POLYGEIST_CONTRACTION_MAX_MODES], + int32_t modes[3][POLYGEIST_CONTRACTION_MAX_MODES], + int present[3][POLYGEIST_CONTRACTION_MAX_MODES], + int64_t modeExtents[POLYGEIST_CONTRACTION_MAX_MODES]) { + enum { + MAX_RANK = POLYGEIST_CONTRACTION_MAX_MODES, + TENSOR_FIELDS = 3 * POLYGEIST_CONTRACTION_MAX_MODES + }; + for (int mode = 0; mode < MAX_RANK; ++mode) + modeExtents[mode] = 1; + memset(present, 0, 3 * MAX_RANK * sizeof(int)); + + for (int tensor = 0; tensor < 3; ++tensor) { + ranks[tensor] = metadata[tensor]; + if (ranks[tensor] < 0 || ranks[tensor] > MAX_RANK) + return 0; + int64_t base = 3 + (int64_t)tensor * TENSOR_FIELDS; + for (int64_t dim = 0; dim < ranks[tensor]; ++dim) { + extents[tensor][dim] = metadata[base + dim]; + strides[tensor][dim] = metadata[base + MAX_RANK + dim]; + int64_t mode = metadata[base + 2 * MAX_RANK + dim]; + if (mode < 0 || mode >= MAX_RANK || extents[tensor][dim] <= 0 || + strides[tensor][dim] < 0) + return 0; + if (modeExtents[mode] != 1 && + modeExtents[mode] != extents[tensor][dim]) + return 0; + modes[tensor][dim] = (int32_t)mode; + modeExtents[mode] = extents[tensor][dim]; + present[tensor][mode] = 1; + } + } + return 1; +} + +#if POLYGEIST_HAS_CUTENSORNET + +// A prepared cuTensorNet network is shape/layout specific but data-pointer +// independent: NetworkSet{Input,Output}TensorMemory may update the buffers +// before each contraction. Keep the expensive optimizer and preparation +// result alive and only rebind pointers on a cache hit. +#define POLYGEIST_CONTRACTION_CACHE_CAP 64 + +typedef struct { + int device; + int64_t ranks[3]; + int64_t extents[3][POLYGEIST_CONTRACTION_MAX_MODES]; + int64_t strides[3][POLYGEIST_CONTRACTION_MAX_MODES]; + int32_t modes[3][POLYGEIST_CONTRACTION_MAX_MODES]; +} PolygeistContractionKey; + +typedef struct { + int valid; + uint64_t hash; + uint64_t last_use; + PolygeistContractionKey key; + cutensornetNetworkDescriptor_t network; + cutensornetContractionOptimizerConfig_t config; + cutensornetContractionOptimizerInfo_t info; + cutensornetWorkspaceDescriptor_t workspace; + int64_t tensor_ids[2]; + void *scratch; + int64_t scratch_bytes; +} PolygeistContractionCacheEntry; + +static cutensornetHandle_t g_cutensornet_handle = NULL; +static PolygeistContractionCacheEntry + g_contraction_cache[POLYGEIST_CONTRACTION_CACHE_CAP]; +static uint64_t g_contraction_cache_clock = 0; +static uint64_t g_contraction_cache_hits = 0; +static uint64_t g_contraction_cache_misses = 0; +static uint64_t g_contraction_cache_evictions = 0; + +static int contraction_cache_enabled(void) { + const char *value = getenv("POLYGEIST_CUTENSORNET_PLAN_CACHE"); + return !value || !*value || strcmp(value, "0") != 0; +} + +static int contraction_cache_stats_enabled(void) { + const char *value = getenv("POLYGEIST_RT_CACHE_STATS"); + return value && *value && strcmp(value, "0") != 0; +} + +static uint64_t hash_contraction_key(const PolygeistContractionKey *key) { + const unsigned char *bytes = (const unsigned char *)key; + uint64_t hash = UINT64_C(1469598103934665603); + for (size_t i = 0; i < sizeof(*key); ++i) { + hash ^= bytes[i]; + hash *= UINT64_C(1099511628211); + } + return hash; +} + +static void make_contraction_key( + PolygeistContractionKey *key, const int64_t ranks[3], + const int64_t extents[3][POLYGEIST_CONTRACTION_MAX_MODES], + const int64_t strides[3][POLYGEIST_CONTRACTION_MAX_MODES], + const int32_t modes[3][POLYGEIST_CONTRACTION_MAX_MODES]) { + memset(key, 0, sizeof(*key)); + CUDA_CHECK(cudaGetDevice(&key->device)); + for (int tensor = 0; tensor < 3; ++tensor) { + key->ranks[tensor] = ranks[tensor]; + for (int64_t dim = 0; dim < ranks[tensor]; ++dim) { + key->extents[tensor][dim] = extents[tensor][dim]; + key->strides[tensor][dim] = strides[tensor][dim]; + key->modes[tensor][dim] = modes[tensor][dim]; + } + } +} + +static void ensure_cutensornet_handle(void) { + if (!g_cutensornet_handle) + CUTENSORNET_CHECK(cutensornetCreate(&g_cutensornet_handle)); +} + +static void destroy_contraction_cache_entry( + PolygeistContractionCacheEntry *entry) { + if (!entry->valid) + return; + if (entry->scratch) + CUDA_CHECK(cudaFree(entry->scratch)); + if (entry->workspace) + CUTENSORNET_CHECK( + cutensornetDestroyWorkspaceDescriptor(entry->workspace)); + if (entry->info) + CUTENSORNET_CHECK( + cutensornetDestroyContractionOptimizerInfo(entry->info)); + if (entry->config) + CUTENSORNET_CHECK( + cutensornetDestroyContractionOptimizerConfig(entry->config)); + if (entry->network) + CUTENSORNET_CHECK(cutensornetDestroyNetwork(entry->network)); + memset(entry, 0, sizeof(*entry)); +} + +static PolygeistContractionCacheEntry *create_contraction_cache_entry( + PolygeistContractionCacheEntry *entry, + const PolygeistContractionKey *key, uint64_t hash) { + memset(entry, 0, sizeof(*entry)); + entry->hash = hash; + entry->key = *key; + entry->tensor_ids[0] = -1; + entry->tensor_ids[1] = -1; + ensure_cutensornet_handle(); + + CUTENSORNET_CHECK( + cutensornetCreateNetwork(g_cutensornet_handle, &entry->network)); + CUTENSORNET_CHECK(cutensornetNetworkAppendTensor( + g_cutensornet_handle, entry->network, (int32_t)key->ranks[0], + key->extents[0], key->modes[0], NULL, CUDA_R_64F, + &entry->tensor_ids[0])); + CUTENSORNET_CHECK(cutensornetNetworkAppendTensor( + g_cutensornet_handle, entry->network, (int32_t)key->ranks[1], + key->extents[1], key->modes[1], NULL, CUDA_R_64F, + &entry->tensor_ids[1])); + CUTENSORNET_CHECK(cutensornetNetworkSetOutputTensor( + g_cutensornet_handle, entry->network, (int32_t)key->ranks[2], + key->modes[2], CUDA_R_64F)); + + CUTENSORNET_CHECK(cutensornetCreateContractionOptimizerConfig( + g_cutensornet_handle, &entry->config)); + CUTENSORNET_CHECK(cutensornetCreateContractionOptimizerInfo( + g_cutensornet_handle, entry->network, &entry->info)); + const uint64_t workspace_limit = UINT64_C(256) * 1024 * 1024; + CUTENSORNET_CHECK(cutensornetContractionOptimize( + g_cutensornet_handle, entry->network, entry->config, + workspace_limit, entry->info)); + CUTENSORNET_CHECK(cutensornetNetworkSetOptimizerInfo( + g_cutensornet_handle, entry->network, entry->info)); + CUTENSORNET_CHECK(cutensornetCreateWorkspaceDescriptor( + g_cutensornet_handle, &entry->workspace)); + CUTENSORNET_CHECK(cutensornetWorkspaceComputeContractionSizes( + g_cutensornet_handle, entry->network, entry->info, entry->workspace)); + CUTENSORNET_CHECK(cutensornetWorkspaceGetMemorySize( + g_cutensornet_handle, entry->workspace, + CUTENSORNET_WORKSIZE_PREF_RECOMMENDED, CUTENSORNET_MEMSPACE_DEVICE, + CUTENSORNET_WORKSPACE_SCRATCH, &entry->scratch_bytes)); + if (entry->scratch_bytes > 0) + CUDA_CHECK(cudaMalloc(&entry->scratch, (size_t)entry->scratch_bytes)); + CUTENSORNET_CHECK(cutensornetWorkspaceSetMemory( + g_cutensornet_handle, entry->workspace, CUTENSORNET_MEMSPACE_DEVICE, + CUTENSORNET_WORKSPACE_SCRATCH, entry->scratch, entry->scratch_bytes)); + CUTENSORNET_CHECK(cutensornetNetworkPrepareContraction( + g_cutensornet_handle, entry->network, entry->workspace)); + entry->valid = 1; + entry->last_use = ++g_contraction_cache_clock; + return entry; +} + +static PolygeistContractionCacheEntry *get_contraction_cache_entry( + const PolygeistContractionKey *key) { + const uint64_t hash = hash_contraction_key(key); + for (int i = 0; i < POLYGEIST_CONTRACTION_CACHE_CAP; ++i) { + PolygeistContractionCacheEntry *entry = &g_contraction_cache[i]; + if (entry->valid && entry->hash == hash && + memcmp(&entry->key, key, sizeof(*key)) == 0) { + g_contraction_cache_hits++; + entry->last_use = ++g_contraction_cache_clock; + return entry; + } + } + + g_contraction_cache_misses++; + int slot = -1; + for (int i = 0; i < POLYGEIST_CONTRACTION_CACHE_CAP; ++i) { + if (!g_contraction_cache[i].valid) { + slot = i; + break; + } + } + if (slot < 0) { + slot = 0; + for (int i = 1; i < POLYGEIST_CONTRACTION_CACHE_CAP; ++i) + if (g_contraction_cache[i].last_use < + g_contraction_cache[slot].last_use) + slot = i; + CUDA_CHECK(cudaStreamSynchronize(g_stream)); + destroy_contraction_cache_entry(&g_contraction_cache[slot]); + g_contraction_cache_evictions++; + } + return create_contraction_cache_entry(&g_contraction_cache[slot], key, + hash); +} + +static void destroy_cutensornet_contraction_cache(void) { + for (int i = 0; i < POLYGEIST_CONTRACTION_CACHE_CAP; ++i) + destroy_contraction_cache_entry(&g_contraction_cache[i]); + if (g_cutensornet_handle) { + CUTENSORNET_CHECK(cutensornetDestroy(g_cutensornet_handle)); + g_cutensornet_handle = NULL; + } + if (contraction_cache_stats_enabled()) { + fprintf(stderr, + "POLYGEIST_RT_CACHE_STATS\thits=%llu\tmisses=%llu\t" + "evictions=%llu\n", + (unsigned long long)g_contraction_cache_hits, + (unsigned long long)g_contraction_cache_misses, + (unsigned long long)g_contraction_cache_evictions); + } + memset(g_contraction_cache, 0, sizeof(g_contraction_cache)); + g_contraction_cache_clock = 0; + g_contraction_cache_hits = 0; + g_contraction_cache_misses = 0; + g_contraction_cache_evictions = 0; +} + +#endif // POLYGEIST_HAS_CUTENSORNET + +static void polygeist_contraction2_f64_cpu( + const double *A, const double *B, double *C, + const int64_t ranks[3], + const int64_t extents[3][POLYGEIST_CONTRACTION_MAX_MODES], + const int64_t strides[3][POLYGEIST_CONTRACTION_MAX_MODES], + const int32_t modes[3][POLYGEIST_CONTRACTION_MAX_MODES], + const int present[3][POLYGEIST_CONTRACTION_MAX_MODES], + const int64_t modeExtents[POLYGEIST_CONTRACTION_MAX_MODES]) { + int64_t total = 1; + for (int mode = 0; mode < POLYGEIST_CONTRACTION_MAX_MODES; ++mode) + total *= modeExtents[mode]; + for (int64_t linear = 0; linear < total; ++linear) { + int64_t coordinates[POLYGEIST_CONTRACTION_MAX_MODES]; + int64_t remaining = linear; + for (int mode = POLYGEIST_CONTRACTION_MAX_MODES - 1; + mode >= 0; --mode) { + coordinates[mode] = remaining % modeExtents[mode]; + remaining /= modeExtents[mode]; + } + int64_t offsets[3] = {0, 0, 0}; + for (int tensor = 0; tensor < 3; ++tensor) + for (int64_t dim = 0; dim < ranks[tensor]; ++dim) + offsets[tensor] += + coordinates[modes[tensor][dim]] * strides[tensor][dim]; + int firstReductionPoint = 1; + for (int mode = 0; mode < POLYGEIST_CONTRACTION_MAX_MODES; ++mode) + if (!present[2][mode] && + (present[0][mode] || present[1][mode]) && + coordinates[mode] != 0) + firstReductionPoint = 0; + if (firstReductionPoint) + C[offsets[2]] = 0.0; + C[offsets[2]] += A[offsets[0]] * B[offsets[1]]; + } +} + +static void polygeist_cutensornet_contraction2_f64_impl( + const double *A, const double *B, double *C, const int64_t *metadata, + int device_pointers) { + int64_t ranks[3]; + int64_t extents[3][POLYGEIST_CONTRACTION_MAX_MODES] = {{0}}; + int64_t strides[3][POLYGEIST_CONTRACTION_MAX_MODES] = {{0}}; + int32_t modes[3][POLYGEIST_CONTRACTION_MAX_MODES] = {{0}}; + int present[3][POLYGEIST_CONTRACTION_MAX_MODES]; + int64_t modeExtents[POLYGEIST_CONTRACTION_MAX_MODES]; + if (!polygeist_parse_contraction2_f64_metadata( + metadata, ranks, extents, strides, modes, present, modeExtents)) { + fprintf(stderr, "polygeist runtime: invalid contraction metadata\n"); + abort(); + } + +#if POLYGEIST_HAS_CUTENSORNET + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + polygeist_cublas_init(); + size_t elements[3] = {1, 1, 1}; + for (int tensor = 0; tensor < 3; ++tensor) + for (int64_t dim = 0; dim < ranks[tensor]; ++dim) + elements[tensor] += + (size_t)(extents[tensor][dim] - 1) * + (size_t)strides[tensor][dim]; + double *dA = device_pointers + ? (double *)A + : (double *)register_host_safe( + (void *)A, elements[0] * sizeof(double)); + double *dB = device_pointers + ? (double *)B + : (double *)register_host_safe( + (void *)B, elements[1] * sizeof(double)); + double *dC = device_pointers + ? C + : (double *)register_host_safe( + (void *)C, elements[2] * sizeof(double)); + + PolygeistContractionKey key; + make_contraction_key(&key, ranks, extents, strides, modes); + PolygeistContractionCacheEntry uncached_entry; + const int use_cache = contraction_cache_enabled(); + PolygeistContractionCacheEntry *entry = + use_cache ? get_contraction_cache_entry(&key) + : create_contraction_cache_entry( + &uncached_entry, &key, hash_contraction_key(&key)); + CUTENSORNET_CHECK(cutensornetNetworkSetInputTensorMemory( + g_cutensornet_handle, entry->network, entry->tensor_ids[0], dA, + strides[0])); + CUTENSORNET_CHECK(cutensornetNetworkSetInputTensorMemory( + g_cutensornet_handle, entry->network, entry->tensor_ids[1], dB, + strides[1])); + CUTENSORNET_CHECK(cutensornetNetworkSetOutputTensorMemory( + g_cutensornet_handle, entry->network, dC, strides[2])); + timing_gpu_begin(); + CUTENSORNET_CHECK(cutensornetNetworkContract( + g_cutensornet_handle, entry->network, 0, entry->workspace, NULL, + g_stream)); + int64_t reductionExtent = 1; + for (int mode = 0; mode < POLYGEIST_CONTRACTION_MAX_MODES; ++mode) + if (!present[2][mode] && + (present[0][mode] || present[1][mode])) + reductionExtent *= modeExtents[mode]; + timing_gpu_end("cutensornetContraction2_f64", + (int32_t)modeExtents[0], (int32_t)modeExtents[1], + (int32_t)reductionExtent, host_start_ms); + if (use_cache) { + sync_stream_if_outside_pipeline(); + } else { + // The uncached debug path owns descriptors and scratch only for this + // invocation, so execution must finish before they are destroyed. + CUDA_CHECK(cudaStreamSynchronize(g_stream)); + destroy_contraction_cache_entry(entry); + } + if (!device_pointers) { + unregister_host_safe((void *)A); + unregister_host_safe((void *)B); + unregister_host_safe(C); + } +#else + polygeist_contraction2_f64_cpu( + A, B, C, ranks, extents, strides, modes, present, modeExtents); +#endif +} + +void polygeist_cutensornet_contraction2_f64( + const double *A, const double *B, double *C, const int64_t *metadata) { + polygeist_cutensornet_contraction2_f64_impl(A, B, C, metadata, 0); +} + +void polygeist_cutensornet_contraction2_f64_device( + const double *A, const double *B, double *C, const int64_t *metadata) { + polygeist_cutensornet_contraction2_f64_impl(A, B, C, metadata, 1); +} + +// FP16 variant. cuDNN tensor cores light up here on Ampere+ (Orin) when the +// shape is large enough and channel-aligned. Single-batch single-channel may +// still fall back to a generic path — but for batched/channeled workloads +// this is the fast path. Math/accumulation type is FP32 inside cuDNN. +// Guarded on __FLT16_MAX__ to match the header declaration. +#if defined(__FLT16_MAX__) +void polygeist_cudnn_conv2d_3x3_f16( + int32_t M, int32_t N, + _Float16 w0, _Float16 w1, _Float16 w2, + _Float16 w3, _Float16 w4, _Float16 w5, + _Float16 w6, _Float16 w7, _Float16 w8, + const _Float16 *A, _Float16 *B) { + polygeist_cublas_init(); + ensure_cudnn(); + + // Reinterpret host-side _Float16 → uint16_t (identical bit layout). cuDNN + // reads the buffer as CUDNN_DATA_HALF via the descriptor, so the type of + // the device pointer doesn't matter as long as the bits are right. + uint16_t filter_h[9]; + __builtin_memcpy(&filter_h[0], &w0, 2); + __builtin_memcpy(&filter_h[1], &w1, 2); + __builtin_memcpy(&filter_h[2], &w2, 2); + __builtin_memcpy(&filter_h[3], &w3, 2); + __builtin_memcpy(&filter_h[4], &w4, 2); + __builtin_memcpy(&filter_h[5], &w5, 2); + __builtin_memcpy(&filter_h[6], &w6, 2); + __builtin_memcpy(&filter_h[7], &w7, 2); + __builtin_memcpy(&filter_h[8], &w8, 2); + + cudnnTensorDescriptor_t in_desc, out_desc; + cudnnFilterDescriptor_t f_desc; + cudnnConvolutionDescriptor_t conv_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&in_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&out_desc)); + CUDNN_CHECK(cudnnCreateFilterDescriptor(&f_desc)); + CUDNN_CHECK(cudnnCreateConvolutionDescriptor(&conv_desc)); + + CUDNN_CHECK(cudnnSetTensor4dDescriptor(in_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_HALF, 1, 1, M, N)); + CUDNN_CHECK(cudnnSetFilter4dDescriptor(f_desc, CUDNN_DATA_HALF, + CUDNN_TENSOR_NCHW, 1, 1, 3, 3)); + // Accumulate in FP32 inside the conv (CUDNN_DATA_FLOAT compute dtype). + CUDNN_CHECK(cudnnSetConvolution2dDescriptor( + conv_desc, 0, 0, 1, 1, 1, 1, + CUDNN_CROSS_CORRELATION, CUDNN_DATA_FLOAT)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(out_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_HALF, 1, 1, M - 2, N - 2)); + + size_t bytes_in = (size_t)M * (size_t)N * sizeof(uint16_t); + size_t bytes_f = 9 * sizeof(uint16_t); + size_t bytes_out = (size_t)(M - 2) * (size_t)(N - 2) * sizeof(uint16_t); + uint16_t *dA = NULL, *dF = NULL, *dB = NULL; + DEVICE_MALLOC((void**)&dA, bytes_in); + DEVICE_MALLOC((void**)&dF, bytes_f); + DEVICE_MALLOC((void**)&dB, bytes_out); + CUDA_CHECK(cudaMemcpyAsync(dA, A, bytes_in, cudaMemcpyHostToDevice, g_stream)); + CUDA_CHECK(cudaMemcpyAsync(dF, filter_h, bytes_f, cudaMemcpyHostToDevice, g_stream)); + + cudnnConvolutionFwdAlgoPerf_t algo_perf; + int n_returned = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, 1, &n_returned, &algo_perf)); + if (n_returned < 1) { + fprintf(stderr, "cuDNN(f16): no fwd algo available\n"); + abort(); + } + + size_t ws_size = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, algo_perf.algo, &ws_size)); + void *dWS = NULL; + if (ws_size > 0) DEVICE_MALLOC(&dWS, ws_size); + + // cuDNN expects FP32 alpha/beta scalars when the compute dtype is FP32, + // regardless of the I/O dtype. + float alpha = 1.0f, beta = 0.0f; + CUDNN_CHECK(cudnnConvolutionForward( + g_cudnn, &alpha, in_desc, dA, f_desc, dF, conv_desc, + algo_perf.algo, dWS, ws_size, &beta, out_desc, dB)); + + for (int32_t i = 0; i < M - 2; ++i) { + CUDA_CHECK(cudaMemcpyAsync( + (void*)((uint16_t*)B + (size_t)(i + 1) * (size_t)N + 1), + dB + (size_t)i * (size_t)(N - 2), + (size_t)(N - 2) * sizeof(uint16_t), + cudaMemcpyDeviceToHost, g_stream)); + } + sync_stream_if_outside_pipeline(); + + DEVICE_FREE(dA); DEVICE_FREE(dF); DEVICE_FREE(dB); + if (dWS) DEVICE_FREE(dWS); + cudnnDestroyTensorDescriptor(in_desc); + cudnnDestroyTensorDescriptor(out_desc); + cudnnDestroyFilterDescriptor(f_desc); + cudnnDestroyConvolutionDescriptor(conv_desc); +} +#endif // __FLT16_MAX__ + +#if defined(__BFLT16_MAX__) || defined(__ARM_FEATURE_BF16) || \ + defined(__ARM_FEATURE_BF16_SCALAR_ARITHMETIC) || defined(__BF16__) +// BF16 variant. Same structure as the FP16 path but with CUDNN_DATA_BFLOAT16 +// for I/O and filter. Compute dtype is still FP32 (BF16 has the same exponent +// range as FP32, so the FP32 accumulator avoids overflow without needing +// rescaling). +void polygeist_cudnn_conv2d_3x3_bf16( + int32_t M, int32_t N, + __bf16 w0, __bf16 w1, __bf16 w2, + __bf16 w3, __bf16 w4, __bf16 w5, + __bf16 w6, __bf16 w7, __bf16 w8, + const __bf16 *A, __bf16 *B) { + polygeist_cublas_init(); + ensure_cudnn(); + + // Host-side __bf16 → uint16_t bit-copy. Same trick as the f16 path; cuDNN + // reads CUDNN_DATA_BFLOAT16 via the descriptor, the underlying buffer + // type doesn't matter on the C side. + uint16_t filter_h[9]; + __builtin_memcpy(&filter_h[0], &w0, 2); + __builtin_memcpy(&filter_h[1], &w1, 2); + __builtin_memcpy(&filter_h[2], &w2, 2); + __builtin_memcpy(&filter_h[3], &w3, 2); + __builtin_memcpy(&filter_h[4], &w4, 2); + __builtin_memcpy(&filter_h[5], &w5, 2); + __builtin_memcpy(&filter_h[6], &w6, 2); + __builtin_memcpy(&filter_h[7], &w7, 2); + __builtin_memcpy(&filter_h[8], &w8, 2); + + cudnnTensorDescriptor_t in_desc, out_desc; + cudnnFilterDescriptor_t f_desc; + cudnnConvolutionDescriptor_t conv_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&in_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&out_desc)); + CUDNN_CHECK(cudnnCreateFilterDescriptor(&f_desc)); + CUDNN_CHECK(cudnnCreateConvolutionDescriptor(&conv_desc)); + + CUDNN_CHECK(cudnnSetTensor4dDescriptor(in_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_BFLOAT16, 1, 1, M, N)); + CUDNN_CHECK(cudnnSetFilter4dDescriptor(f_desc, CUDNN_DATA_BFLOAT16, + CUDNN_TENSOR_NCHW, 1, 1, 3, 3)); + CUDNN_CHECK(cudnnSetConvolution2dDescriptor( + conv_desc, 0, 0, 1, 1, 1, 1, + CUDNN_CROSS_CORRELATION, CUDNN_DATA_FLOAT)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(out_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_BFLOAT16, 1, 1, M - 2, N - 2)); + + size_t bytes_in = (size_t)M * (size_t)N * sizeof(uint16_t); + size_t bytes_f = 9 * sizeof(uint16_t); + size_t bytes_out = (size_t)(M - 2) * (size_t)(N - 2) * sizeof(uint16_t); + uint16_t *dA = NULL, *dF = NULL, *dB = NULL; + DEVICE_MALLOC((void**)&dA, bytes_in); + DEVICE_MALLOC((void**)&dF, bytes_f); + DEVICE_MALLOC((void**)&dB, bytes_out); + CUDA_CHECK(cudaMemcpyAsync(dA, A, bytes_in, cudaMemcpyHostToDevice, g_stream)); + CUDA_CHECK(cudaMemcpyAsync(dF, filter_h, bytes_f, cudaMemcpyHostToDevice, g_stream)); + + cudnnConvolutionFwdAlgoPerf_t algo_perf; + int n_returned = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, 1, &n_returned, &algo_perf)); + if (n_returned < 1) { + fprintf(stderr, "cuDNN(bf16): no fwd algo available\n"); + abort(); + } + + size_t ws_size = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, algo_perf.algo, &ws_size)); + void *dWS = NULL; + if (ws_size > 0) DEVICE_MALLOC(&dWS, ws_size); + + float alpha = 1.0f, beta = 0.0f; + CUDNN_CHECK(cudnnConvolutionForward( + g_cudnn, &alpha, in_desc, dA, f_desc, dF, conv_desc, + algo_perf.algo, dWS, ws_size, &beta, out_desc, dB)); + + for (int32_t i = 0; i < M - 2; ++i) { + CUDA_CHECK(cudaMemcpyAsync( + (void*)((uint16_t*)B + (size_t)(i + 1) * (size_t)N + 1), + dB + (size_t)i * (size_t)(N - 2), + (size_t)(N - 2) * sizeof(uint16_t), + cudaMemcpyDeviceToHost, g_stream)); + } + sync_stream_if_outside_pipeline(); + + DEVICE_FREE(dA); DEVICE_FREE(dF); DEVICE_FREE(dB); + if (dWS) DEVICE_FREE(dWS); + cudnnDestroyTensorDescriptor(in_desc); + cudnnDestroyTensorDescriptor(out_desc); + cudnnDestroyFilterDescriptor(f_desc); + cudnnDestroyConvolutionDescriptor(conv_desc); +} +#endif // bf16 support + +// INT32 variant. +// +// IMPORTANT: cuDNN's `cudnnConvolutionForward` does NOT support a pure +// INT32 input + INT32 filter + INT32 compute configuration. On Orin +// (Ampere) the call to `cudnnSetTensor4dDescriptor(..., CUDNN_DATA_INT32, +// ...)` (or, equivalently, the convolution-descriptor setup with +// CUDNN_DATA_INT32 as the compute type) returns CUDNN_STATUS_BAD_PARAM — +// not because of any error in our argument values, but because cuDNN +// simply doesn't expose INT32 as a standalone fwd-conv I/O dtype. +// +// Where INT32 *does* appear in cuDNN's API is as the *accumulator* dtype +// for an INT8 input × INT8 filter via `cudnnConvolutionBiasActivationForward` +// (and NHWC_VECT_C layouts). That's a fundamentally different API surface +// — different operand layout, requires quantising the user's int input +// down to INT8 with a scale factor, etc. — so we don't silently rewrite +// the user's INT32 stencil into INT8 quant. +// +// Consequently this function intentionally fails fast at the cuDNN call: +// no host-side fallback, no silent reroute. The matcher/rewriter/ABI +// lowering pipeline still exercises end-to-end — verifiable by inspecting +// the produced `func.call @polygeist_cudnn_conv2d_3x3_i32` op — but the +// GPU side is "not implemented" until a real INT32 conv path lands. +// Options for that follow-up: +// * Hand-written CUDA kernel (small .cu compiled with nvcc; the runtime +// loads it via cuModuleLoad + cuLaunchKernel). +// * Switch to cuDNN INT8 quant path (changes the user-visible dtype). +// * Use a different library (cutlass, raw CUB) that supports INT32 conv. +void polygeist_cudnn_conv2d_3x3_i32( + int32_t M, int32_t N, + int32_t w0, int32_t w1, int32_t w2, + int32_t w3, int32_t w4, int32_t w5, + int32_t w6, int32_t w7, int32_t w8, + const int32_t *A, int32_t *B) { + polygeist_cublas_init(); + ensure_cudnn(); + + const int32_t filter_h[9] = { w0, w1, w2, w3, w4, w5, w6, w7, w8 }; + (void)A; (void)B; (void)filter_h; // silence unused until cuDNN call below. + + cudnnTensorDescriptor_t in_desc, out_desc; + cudnnFilterDescriptor_t f_desc; + cudnnConvolutionDescriptor_t conv_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&in_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&out_desc)); + CUDNN_CHECK(cudnnCreateFilterDescriptor(&f_desc)); + CUDNN_CHECK(cudnnCreateConvolutionDescriptor(&conv_desc)); + + // This is the call that will trip CUDNN_STATUS_BAD_PARAM on Orin/Ampere + // for the pure-INT32 configuration. We deliberately do not catch the + // error — the CUDNN_CHECK macro will print the cuDNN message and abort, + // making the unsupported-dtype failure visible to the caller. + CUDNN_CHECK(cudnnSetTensor4dDescriptor(in_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_INT32, 1, 1, M, N)); + CUDNN_CHECK(cudnnSetFilter4dDescriptor(f_desc, CUDNN_DATA_INT32, + CUDNN_TENSOR_NCHW, 1, 1, 3, 3)); + CUDNN_CHECK(cudnnSetConvolution2dDescriptor( + conv_desc, 0, 0, 1, 1, 1, 1, + CUDNN_CROSS_CORRELATION, CUDNN_DATA_INT32)); + // If by some firmware/cuDNN-version combination the above three calls + // succeed, we'd still need to run the actual conv. The pre-existing + // code path for the float dtypes (algo selection, workspace alloc, + // cudnnConvolutionForward, async memcpy back) would go here. Until + // INT32 is supported we leave this as a hard failure — `CUDNN_CHECK` + // above will have aborted before reaching this point. + fprintf(stderr, + "polygeist_cudnn_conv2d_3x3_i32: cuDNN unexpectedly accepted " + "INT32 descriptors but the conv body is not implemented.\n"); + abort(); +} + +// INT16 variant. cuDNN has no INT16 conv path. We upcast inputs/filter to +// INT32 on the host, then delegate to `polygeist_cudnn_conv2d_3x3_i32`. +// That i32 shim is itself NOT implemented on the GPU (see the long +// comment above it — cuDNN doesn't expose INT32 forward conv either), so +// the i16 path also fails at the same cuDNN call. The upcast is still +// the right structure once a real INT32 GPU kernel lands; only the +// underlying i32 path needs replacing. +void polygeist_cudnn_conv2d_3x3_i16( + int32_t M, int32_t N, + int16_t w0, int16_t w1, int16_t w2, + int16_t w3, int16_t w4, int16_t w5, + int16_t w6, int16_t w7, int16_t w8, + const int16_t *A, int16_t *B) { + // Upcast input to i32. + size_t total = (size_t)M * (size_t)N; + int32_t *A32 = (int32_t*)malloc(total * sizeof(int32_t)); + int32_t *B32 = (int32_t*)malloc(total * sizeof(int32_t)); + if (!A32 || !B32) { fprintf(stderr, "i16 shim: oom\n"); abort(); } + for (size_t k = 0; k < total; ++k) A32[k] = (int32_t)A[k]; + // Zero B32's interior so the cuDNN write hits a known starting state; + // the borders won't be touched by the conv, and we won't copy them back. + memset(B32, 0, total * sizeof(int32_t)); + + polygeist_cudnn_conv2d_3x3_i32(M, N, + (int32_t)w0, (int32_t)w1, (int32_t)w2, + (int32_t)w3, (int32_t)w4, (int32_t)w5, + (int32_t)w6, (int32_t)w7, (int32_t)w8, + A32, B32); + + // Downcast i32 result back to i16 (interior only — borders are caller-owned). + for (int32_t i = 1; i < M - 1; ++i) { + for (int32_t j = 1; j < N - 1; ++j) { + size_t k = (size_t)i * (size_t)N + (size_t)j; + B[k] = (int16_t)B32[k]; + } + } + pipeline_host_free(A32); + pipeline_host_free(B32); +} + +// ============================================================================ +// Extracted-darknet batched CNN-block primitives. All FP32, NCHW. +// +// MEMORY MODEL: same zero-copy pattern as the BLAS shims — +// cudaHostRegister + cudaHostGetDevicePointer via register_host_safe(). +// On Jetson Orin's iGPU these calls just set up the page-table mapping +// (no bytes move). Workspace allocations route through the pipeline temp +// cache when `polygeist_cublas_pipeline_begin/end` scopes are active. +// ============================================================================ + +void polygeist_cudnn_conv2d_batched( + int32_t B, int32_t IC, int32_t OC, + int32_t H, int32_t W, int32_t K, + const float *A, const float *F, float *Out) { + polygeist_cublas_init(); + ensure_cudnn(); + + const int32_t OH = H - K + 1; + const int32_t OW = W - K + 1; + + size_t bytes_A = (size_t)B * IC * H * W * sizeof(float); + size_t bytes_F = (size_t)OC * IC * K * K * sizeof(float); + size_t bytes_Out = (size_t)B * OC * OH * OW * sizeof(float); + + float *dA = (float *)register_host_safe((void *)A, bytes_A); + float *dF = (float *)register_host_safe((void *)F, bytes_F); + float *dO = (float *)register_host_safe(Out, bytes_Out); + + cudnnTensorDescriptor_t in_desc, out_desc; + cudnnFilterDescriptor_t f_desc; + cudnnConvolutionDescriptor_t conv_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&in_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&out_desc)); + CUDNN_CHECK(cudnnCreateFilterDescriptor(&f_desc)); + CUDNN_CHECK(cudnnCreateConvolutionDescriptor(&conv_desc)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(in_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, B, IC, H, W)); + CUDNN_CHECK(cudnnSetFilter4dDescriptor(f_desc, CUDNN_DATA_FLOAT, + CUDNN_TENSOR_NCHW, OC, IC, K, K)); + CUDNN_CHECK(cudnnSetConvolution2dDescriptor( + conv_desc, 0, 0, 1, 1, 1, 1, + CUDNN_CROSS_CORRELATION, CUDNN_DATA_FLOAT)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(out_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, B, OC, OH, OW)); + + cudnnConvolutionFwdAlgoPerf_t algo_perf; + int n_returned = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, + 1, &n_returned, &algo_perf)); + if (n_returned < 1) { + fprintf(stderr, "cuDNN conv2d_batched: no fwd algo available\n"); + abort(); + } + + size_t ws_size = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, + algo_perf.algo, &ws_size)); + void *dWS = NULL; + if (ws_size > 0) DEVICE_MALLOC(&dWS, ws_size); + + float alpha = 1.0f, beta = 0.0f; + CUDNN_CHECK(cudnnConvolutionForward( + g_cudnn, &alpha, in_desc, dA, f_desc, dF, conv_desc, + algo_perf.algo, dWS, ws_size, &beta, out_desc, dO)); + sync_stream_if_outside_pipeline(); + + if (dWS) DEVICE_FREE(dWS); + cudnnDestroyTensorDescriptor(in_desc); + cudnnDestroyTensorDescriptor(out_desc); + cudnnDestroyFilterDescriptor(f_desc); + cudnnDestroyConvolutionDescriptor(conv_desc); +} + +void polygeist_cudnn_conv3d_channels_f32( + int32_t IC, int32_t inD, int32_t inH, int32_t inW, + int32_t OC, int32_t kD, int32_t kH, int32_t kW, + const float *input, const float *filter, const float *bias, float *output) { + polygeist_cublas_init(); + ensure_cudnn(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + const int32_t outD = inD - kD + 1; + const int32_t outH = inH - kH + 1; + const int32_t outW = inW - kW + 1; + + size_t inputBytes = (size_t)IC * inD * inH * inW * sizeof(float); + size_t filterBytes = + (size_t)OC * IC * kD * kH * kW * sizeof(float); + size_t outputBytes = + (size_t)OC * outD * outH * outW * sizeof(float); + float *dInput = (float *)register_host_safe((void *)input, inputBytes); + float *dFilter = (float *)register_host_safe((void *)filter, filterBytes); + float *dOutput = (float *)register_host_safe(output, outputBytes); + float *dBias = bias ? (float *)register_host_safe( + (void *)bias, (size_t)OC * sizeof(float)) + : NULL; + + cudnnTensorDescriptor_t inputDesc, outputDesc, biasDesc = NULL; + cudnnFilterDescriptor_t filterDesc; + cudnnConvolutionDescriptor_t convDesc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&inputDesc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&outputDesc)); + CUDNN_CHECK(cudnnCreateFilterDescriptor(&filterDesc)); + CUDNN_CHECK(cudnnCreateConvolutionDescriptor(&convDesc)); + int inputDims[5] = {1, IC, inD, inH, inW}; + int inputStrides[5] = {IC * inD * inH * inW, inD * inH * inW, + inH * inW, inW, 1}; + int outputDims[5] = {1, OC, outD, outH, outW}; + int outputStrides[5] = {OC * outD * outH * outW, outD * outH * outW, + outH * outW, outW, 1}; + int filterDims[5] = {OC, IC, kD, kH, kW}; + int pad[3] = {0, 0, 0}; + int stride[3] = {1, 1, 1}; + int dilation[3] = {1, 1, 1}; + CUDNN_CHECK(cudnnSetTensorNdDescriptor( + inputDesc, CUDNN_DATA_FLOAT, 5, inputDims, inputStrides)); + CUDNN_CHECK(cudnnSetFilterNdDescriptor( + filterDesc, CUDNN_DATA_FLOAT, CUDNN_TENSOR_NCHW, 5, filterDims)); + CUDNN_CHECK(cudnnSetConvolutionNdDescriptor( + convDesc, 3, pad, stride, dilation, + CUDNN_CROSS_CORRELATION, CUDNN_DATA_FLOAT)); + CUDNN_CHECK(cudnnSetTensorNdDescriptor( + outputDesc, CUDNN_DATA_FLOAT, 5, outputDims, outputStrides)); + + cudnnConvolutionFwdAlgoPerf_t algoPerf; + int returned = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7( + g_cudnn, inputDesc, filterDesc, convDesc, outputDesc, + 1, &returned, &algoPerf)); + if (returned < 1) { + fprintf(stderr, "cuDNN channel Conv3D: no forward algorithm available\n"); + abort(); + } + size_t workspaceBytes = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize( + g_cudnn, inputDesc, filterDesc, convDesc, outputDesc, + algoPerf.algo, &workspaceBytes)); + void *workspace = NULL; + if (workspaceBytes) DEVICE_MALLOC(&workspace, workspaceBytes); + + float one = 1.0f, zero = 0.0f; + timing_gpu_begin(); + CUDNN_CHECK(cudnnConvolutionForward( + g_cudnn, &one, inputDesc, dInput, filterDesc, dFilter, convDesc, + algoPerf.algo, workspace, workspaceBytes, &zero, outputDesc, dOutput)); + if (dBias) { + CUDNN_CHECK(cudnnCreateTensorDescriptor(&biasDesc)); + int biasDims[5] = {1, OC, 1, 1, 1}; + int biasStrides[5] = {OC, 1, 1, 1, 1}; + CUDNN_CHECK(cudnnSetTensorNdDescriptor( + biasDesc, CUDNN_DATA_FLOAT, 5, biasDims, biasStrides)); + CUDNN_CHECK(cudnnAddTensor( + g_cudnn, &one, biasDesc, dBias, &one, outputDesc, dOutput)); + } + timing_gpu_end("cudnnConvolution3D_channels_f32", + OC * outD, outH * outW, IC * kD * kH * kW, + host_start_ms); + sync_stream_if_outside_pipeline(); + + if (workspace) DEVICE_FREE(workspace); + if (biasDesc) cudnnDestroyTensorDescriptor(biasDesc); + cudnnDestroyTensorDescriptor(inputDesc); + cudnnDestroyTensorDescriptor(outputDesc); + cudnnDestroyFilterDescriptor(filterDesc); + cudnnDestroyConvolutionDescriptor(convDesc); + unregister_host_safe((void *)input); + unregister_host_safe((void *)filter); + if (bias) unregister_host_safe((void *)bias); + unregister_host_safe(output); +} + +void polygeist_cudnn_conv2d_im2col_gemm_f32( + int32_t IC, int32_t H, int32_t W, int32_t OC, + int32_t K, int32_t S, int32_t P, + const float *A, const float *F, float *Out) { + polygeist_cublas_init(); + ensure_cudnn(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + const int32_t OH = (H + 2 * P - K) / S + 1; + const int32_t OW = (W + 2 * P - K) / S + 1; + size_t bytes_A = (size_t)IC * H * W * sizeof(float); + size_t bytes_F = (size_t)OC * IC * K * K * sizeof(float); + size_t bytes_Out = (size_t)OC * OH * OW * sizeof(float); + + float *dA = (float *)register_host_safe((void *)A, bytes_A); + float *dF = (float *)register_host_safe((void *)F, bytes_F); + float *dO = (float *)register_host_safe(Out, bytes_Out); + + cudnnTensorDescriptor_t in_desc, out_desc; + cudnnFilterDescriptor_t f_desc; + cudnnConvolutionDescriptor_t conv_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&in_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&out_desc)); + CUDNN_CHECK(cudnnCreateFilterDescriptor(&f_desc)); + CUDNN_CHECK(cudnnCreateConvolutionDescriptor(&conv_desc)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(in_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, IC, H, W)); + CUDNN_CHECK(cudnnSetFilter4dDescriptor(f_desc, CUDNN_DATA_FLOAT, + CUDNN_TENSOR_NCHW, OC, IC, K, K)); + CUDNN_CHECK(cudnnSetConvolution2dDescriptor( + conv_desc, P, P, S, S, 1, 1, + CUDNN_CROSS_CORRELATION, CUDNN_DATA_FLOAT)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(out_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, OC, OH, OW)); + + cudnnConvolutionFwdAlgoPerf_t algo_perf; + int n_returned = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, + 1, &n_returned, &algo_perf)); + if (n_returned < 1) { + fprintf(stderr, "cuDNN conv2d_im2col_gemm: no fwd algo available\n"); + abort(); + } + + size_t ws_size = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, + algo_perf.algo, &ws_size)); + void *dWS = NULL; + if (ws_size > 0) DEVICE_MALLOC(&dWS, ws_size); + + float alpha = 1.0f, beta = 0.0f; + timing_gpu_begin(); + CUDNN_CHECK(cudnnConvolutionForward( + g_cudnn, &alpha, in_desc, dA, f_desc, dF, conv_desc, + algo_perf.algo, dWS, ws_size, &beta, out_desc, dO)); + timing_gpu_end("cudnnConv2d_im2col_gemm", OC, OH * OW, IC * K * K, + host_start_ms); + + if (dWS) DEVICE_FREE(dWS); + cudnnDestroyTensorDescriptor(in_desc); + cudnnDestroyTensorDescriptor(out_desc); + cudnnDestroyFilterDescriptor(f_desc); + cudnnDestroyConvolutionDescriptor(conv_desc); +} + +void polygeist_cudnn_maxpool_batched( + int32_t B, int32_t C, int32_t H, int32_t W, int32_t OH, int32_t OW, + const float *A, float *Out) { + polygeist_cublas_init(); + ensure_cudnn(); + + // Derive S = H / OH (common K==S case for our extracted kernels). + int32_t S = H / OH; + int32_t K = (S > 0) ? S : 2; + + size_t bytes_A = (size_t)B * C * H * W * sizeof(float); + size_t bytes_Out = (size_t)B * C * OH * OW * sizeof(float); + + float *dA = (float *)register_host_safe((void *)A, bytes_A); + float *dO = (float *)register_host_safe(Out, bytes_Out); + + cudnnTensorDescriptor_t in_desc, out_desc; + cudnnPoolingDescriptor_t pool_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&in_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&out_desc)); + CUDNN_CHECK(cudnnCreatePoolingDescriptor(&pool_desc)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(in_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, B, C, H, W)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(out_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, B, C, OH, OW)); + CUDNN_CHECK(cudnnSetPooling2dDescriptor( + pool_desc, CUDNN_POOLING_MAX, CUDNN_NOT_PROPAGATE_NAN, + K, K, 0, 0, S, S)); + + float alpha = 1.0f, beta = 0.0f; + CUDNN_CHECK(cudnnPoolingForward( + g_cudnn, pool_desc, &alpha, in_desc, dA, + &beta, out_desc, dO)); + sync_stream_if_outside_pipeline(); + + cudnnDestroyTensorDescriptor(in_desc); + cudnnDestroyTensorDescriptor(out_desc); + cudnnDestroyPoolingDescriptor(pool_desc); +} + +void polygeist_cudnn_batchnorm_inference( + int32_t B, int32_t C, int32_t H, int32_t W, + const float *A, + const float *scale, const float *mean, + const float *inv_std, const float *bias, + float *Out) { + polygeist_cublas_init(); + ensure_cudnn(); + + // cuDNN expects (mean, variance) and an epsilon, computing + // y = scale * (x - mean) / sqrt(var + eps) + bias. + // Our kernel was given (mean, inv_std) where inv_std = 1/sqrt(var+eps). + // We invert: var = 1/inv_std² - eps. Use the same eps the caller used. + // The standard ResNet/PyTorch eps is 1e-5. + const double eps = 1e-5; + + float *var_h = (float *)malloc((size_t)C * sizeof(float)); + if (!var_h) { + fprintf(stderr, "polygeist_cudnn_batchnorm_inference: malloc failed\n"); + abort(); + } + const float *inv_std_h = inv_std; + void *inv_std_device = NULL; + if (pointer_is_device_resident(inv_std, &inv_std_device)) { + CUDA_CHECK(cudaMemcpy(var_h, inv_std_device, (size_t)C * sizeof(float), + cudaMemcpyDeviceToHost)); + inv_std_h = var_h; + } + for (int32_t c = 0; c < C; ++c) { + double s = (double)inv_std_h[c]; + double v = 1.0 / (s * s) - eps; + if (v < 0) v = 0; + var_h[c] = (float)v; + } + + size_t bytes_x = (size_t)B * C * H * W * sizeof(float); + size_t bytes_c = (size_t)C * sizeof(float); + + float *dA = (float *)register_host_safe((void *)A, bytes_x); + float *dS = (float *)register_host_safe((void *)scale, bytes_c); + float *dM = (float *)register_host_safe((void *)mean, bytes_c); + float *dB = (float *)register_host_safe((void *)bias, bytes_c); + float *dO = (float *)register_host_safe(Out, bytes_x); + float *dV = NULL; + DEVICE_MALLOC((void **)&dV, bytes_c); + CUDA_CHECK(cudaMemcpyAsync(dV, var_h, bytes_c, + cudaMemcpyHostToDevice, g_stream)); + + cudnnTensorDescriptor_t x_desc, y_desc, bn_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&x_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&y_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&bn_desc)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(x_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, B, C, H, W)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(y_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, B, C, H, W)); + // bnScaleBiasMeanVarDesc: 1×C×1×1 + CUDNN_CHECK(cudnnSetTensor4dDescriptor(bn_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, C, 1, 1)); + + float alpha = 1.0f, beta = 0.0f; + CUDNN_CHECK(cudnnBatchNormalizationForwardInference( + g_cudnn, CUDNN_BATCHNORM_SPATIAL, &alpha, &beta, + x_desc, dA, y_desc, dO, bn_desc, dS, dB, dM, dV, eps)); + sync_stream_if_outside_pipeline(); + + DEVICE_FREE(dV); + pipeline_host_free(var_h); + cudnnDestroyTensorDescriptor(x_desc); + cudnnDestroyTensorDescriptor(y_desc); + cudnnDestroyTensorDescriptor(bn_desc); +} + +void polygeist_cudnn_add_tensor_batched( + int32_t B, int32_t C, int32_t H, int32_t W, + const float *A, float *Out) { + polygeist_cublas_init(); + ensure_cudnn(); + + size_t bytes = (size_t)B * C * H * W * sizeof(float); + float *dA = (float *)register_host_safe((void *)A, bytes); + float *dO = (float *)register_host_safe(Out, bytes); + + cudnnTensorDescriptor_t a_desc, o_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&a_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&o_desc)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(a_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, B, C, H, W)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(o_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, B, C, H, W)); + + // cudnnAddTensor computes Out = α*A + β*Out. We want Out += A, so α=β=1. + float alpha = 1.0f, beta = 1.0f; + CUDNN_CHECK(cudnnAddTensor(g_cudnn, &alpha, a_desc, dA, + &beta, o_desc, dO)); + sync_stream_if_outside_pipeline(); + + cudnnDestroyTensorDescriptor(a_desc); + cudnnDestroyTensorDescriptor(o_desc); +} + +// Fused conv + bias + residual-add + relu via the SAME cuDNN API. +// y = activation(α₁·conv(x,w) + α₂·z + bias). We just feed real bias + +// real Z; no BN-folding step needed. +void polygeist_cudnn_conv_bias_relu_add_fused( + int32_t B, int32_t IC, int32_t OC, + int32_t H, int32_t W, int32_t K, + const float *A, const float *F, + const float *bias, const float *Z, + float *Out) { + polygeist_cublas_init(); + ensure_cudnn(); + + const int32_t OH = H - K + 1; + const int32_t OW = W - K + 1; + + size_t bytes_A = (size_t)B * IC * H * W * sizeof(float); + size_t bytes_F = (size_t)OC * IC * K * K * sizeof(float); + size_t bytes_Ou = (size_t)B * OC * OH * OW * sizeof(float); + size_t bytes_b = (size_t)OC * sizeof(float); + + float *dA = (float *)register_host_safe((void *)A, bytes_A); + float *dF = (float *)register_host_safe((void *)F, bytes_F); + float *dB = (float *)register_host_safe((void *)bias, bytes_b); + float *dZ = (float *)register_host_safe((void *)Z, bytes_Ou); + float *dO = (float *)register_host_safe(Out, bytes_Ou); + + cudnnTensorDescriptor_t in_desc, out_desc, bias_desc; + cudnnFilterDescriptor_t f_desc; + cudnnConvolutionDescriptor_t conv_desc; + cudnnActivationDescriptor_t act_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&in_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&out_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&bias_desc)); + CUDNN_CHECK(cudnnCreateFilterDescriptor(&f_desc)); + CUDNN_CHECK(cudnnCreateConvolutionDescriptor(&conv_desc)); + CUDNN_CHECK(cudnnCreateActivationDescriptor(&act_desc)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(in_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, B, IC, H, W)); + CUDNN_CHECK(cudnnSetFilter4dDescriptor(f_desc, CUDNN_DATA_FLOAT, + CUDNN_TENSOR_NCHW, OC, IC, K, K)); + CUDNN_CHECK(cudnnSetConvolution2dDescriptor( + conv_desc, 0, 0, 1, 1, 1, 1, + CUDNN_CROSS_CORRELATION, CUDNN_DATA_FLOAT)); + CUDNN_CHECK(cudnnSetConvolutionMathType(conv_desc, CUDNN_DEFAULT_MATH)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(out_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, B, OC, OH, OW)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(bias_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, OC, 1, 1)); + CUDNN_CHECK(cudnnSetActivationDescriptor( + act_desc, CUDNN_ACTIVATION_RELU, CUDNN_NOT_PROPAGATE_NAN, 0.0)); + + // Algo selection — see the stack-smash note in + // polygeist_cudnn_conv_bn_relu_fused for why this loop allocates an + // array of ALGO_CANDIDATES not a single struct. + enum { ALGO_CANDIDATES = 8 }; + cudnnConvolutionFwdAlgoPerf_t algos[ALGO_CANDIDATES]; + int n_returned = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, + ALGO_CANDIDATES, &n_returned, algos)); + if (n_returned < 1) { + fprintf(stderr, "cuDNN conv_bias_relu_add: no fwd algo\n"); abort(); + } + cudnnConvolutionFwdAlgo_t algo = algos[0].algo; + for (int i = 0; i < n_returned; ++i) + if (algos[i].algo == CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_PRECOMP_GEMM) { + algo = algos[i].algo; break; + } + + size_t ws_size = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, algo, &ws_size)); + void *dWS = NULL; + if (ws_size > 0) DEVICE_MALLOC(&dWS, ws_size); + + // y = relu(1·conv(A, F) + 1·Z + bias). + float alpha1 = 1.0f, alpha2 = 1.0f; + CUDNN_CHECK(cudnnConvolutionBiasActivationForward( + g_cudnn, &alpha1, in_desc, dA, f_desc, dF, conv_desc, algo, + dWS, ws_size, &alpha2, out_desc, dZ, + bias_desc, dB, act_desc, out_desc, dO)); + sync_stream_if_outside_pipeline(); + + if (dWS) DEVICE_FREE(dWS); + cudnnDestroyTensorDescriptor(in_desc); + cudnnDestroyTensorDescriptor(out_desc); + cudnnDestroyTensorDescriptor(bias_desc); + cudnnDestroyFilterDescriptor(f_desc); + cudnnDestroyConvolutionDescriptor(conv_desc); + cudnnDestroyActivationDescriptor(act_desc); +} + +void polygeist_cublas_memset_zero_2d_f32(int32_t M, int32_t N, float *A, int32_t lda) { + void *device_ptr = NULL; + if (pointer_is_device_resident(A, &device_ptr)) { + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + timing_gpu_begin(); + CUDA_CHECK(cudaMemset2DAsync(device_ptr, (size_t)lda * sizeof(float), 0, + (size_t)N * sizeof(float), M, g_stream)); + timing_gpu_end("cuda_memset_zero_2d_f32", M, N, 0, host_start_ms); + return; + } + if (lda == N) { + memset(A, 0, (size_t)M * (size_t)N * sizeof(float)); + } else { + for (int32_t i = 0; i < M; ++i) + memset(&A[(size_t)i * (size_t)lda], 0, (size_t)N * sizeof(float)); + } +} + +// 1×1 conv routed to batched gemm. For NCHW input (B, IC, H, W) and +// filter (OC, IC, 1, 1), each batch slice is a regular +// (OC, HW) = (OC, IC) × (IC, HW) gemm. F is shared across batches +// (stride 0); A and C each stride by their per-batch element count. +// +// Row-major / col-major swap, same trick as cublasDgemm: the col-major +// view of our row-major A_b (IC × HW) is (HW × IC), of F (OC × IC) is +// (IC × OC), of C_b (OC × HW) is (HW × OC). So: +// col-major C_b (HW, OC) = α · col-major A_b (HW, IC) · F (IC, OC) +// → cublasSgemmStridedBatched(OP_N, OP_N, m=HW, n=OC, k=IC, +// α, A, lda=HW, A_stride=IC*HW, +// F, ldb=IC, F_stride=0, +// β, C, ldc=HW, C_stride=OC*HW, +// batchCount=B) +void polygeist_cublas_sgemm_1x1conv( + int32_t B, int32_t IC, int32_t OC, int32_t HW, + const float *A, const float *F, float *C) { + polygeist_cublas_init(); + + size_t bytes_A = (size_t)B * IC * HW * sizeof(float); + size_t bytes_F = (size_t)OC * IC * sizeof(float); + size_t bytes_C = (size_t)B * OC * HW * sizeof(float); + float *dA = (float *)register_host_safe((void *)A, bytes_A); + float *dF = (float *)register_host_safe((void *)F, bytes_F); + float *dC = (float *)register_host_safe(C, bytes_C); + + float alpha = 1.0f, beta = 0.0f; + long long strideA = (long long)IC * HW; + long long strideF = 0; + long long strideC = (long long)OC * HW; + CUBLAS_CHECK(cublasSgemmStridedBatched(g_handle, + CUBLAS_OP_N, CUBLAS_OP_N, + HW, OC, IC, + &alpha, dA, HW, strideA, + dF, IC, strideF, + &beta, dC, HW, strideC, + B)); + sync_stream_if_outside_pipeline(); +} + +// AᵀA → cublasSsyrk_v2 (FP32). Half the flops of the equivalent +// gemm because syrk only computes the upper triangle of the symmetric +// output. cublasSsyrk's signature: +// C = α·op(A)·op(A)ᵀ + β·C +// where uplo selects which triangle is touched. +// +// Row-major → col-major: our A is row-major (K×N), so its column-major +// view is Aᵀ (N×K). To compute row-major C[N,N] = Aᵀ·A we ask cublas +// to compute col-major Cᵀ[N,N] = (Aᵀ_col_view)·(A_col_view) = A_row·Aᵀ_row. +// Equivalent: pass A with op=N, treat as col-major (N rows × K cols). +// uplo = LOWER on the col-major matrix == UPPER on the row-major view. +// We fill in the missing triangle on host after the call so the caller +// sees a fully-populated symmetric matrix. +void polygeist_cublas_dsyrk(int32_t N, int32_t K, const float *A, float *C) { + polygeist_cublas_init(); + + size_t bytes_A = (size_t)K * N * sizeof(float); + size_t bytes_C = (size_t)N * N * sizeof(float); + float *dA = (float *)register_host_safe((void *)A, bytes_A); + float *dC = (float *)register_host_safe(C, bytes_C); + + float alpha = 1.0f, beta = 0.0f; + // Layout math: + // Our C is row-major. cublas operates col-major. The SAME bytes + // look transposed: row-major C[i,j] is at byte i + j*N in col-major. + // cublasSsyrk(uplo=UPPER) writes col-major UPPER (i ≤ j) which maps + // to row-major positions (j, i) with j ≥ i — i.e. row-major LOWER. + // The mirror loop below then copies row-major lower → row-major upper. + CUBLAS_CHECK(cublasSsyrk(g_handle, + CUBLAS_FILL_MODE_UPPER, CUBLAS_OP_N, + N, K, + &alpha, dA, N, + &beta, dC, N)); + sync_stream_if_outside_pipeline(); + + for (int32_t i = 0; i < N; ++i) + for (int32_t j = i + 1; j < N; ++j) + C[(size_t)i * N + j] = C[(size_t)j * N + i]; +} + +// Fused matmul + bias + relu via cublasLtMatmul with EPILOGUE_RELU_BIAS. +// +// Row-major to col-major: we compute Cᵀ = Bᵀ·Aᵀ + bias' the same way +// cublasDgemm does in this codebase — by swapping A↔B and treating +// "rows" of cublasLt's matrix as columns of ours. cublasLt's matmul +// descriptor uses col-major by default, so: +// our row-major C[M,N] = A[M,K] · B[K,N] +// ≡ col-major Cᵀ[N,M] = Bᵀ[N,K] · Aᵀ[K,M] +// With both A and B passed as CUBLAS_OP_N (no transpose flag), and the +// matrix layouts created in col-major with swapped sizes, the math +// works out exactly. bias[N] is a single per-output-column vector; +// cublasLt's RELU_BIAS epilogue applies it per column of the output. +void polygeist_cublaslt_matmul_bias_relu( + int32_t M, int32_t N, int32_t K, + const float *A, const float *B, const float *bias, + float *C) { + polygeist_cublas_init(); + ensure_cublaslt(); + + size_t bytes_A = (size_t)M * K * sizeof(float); + size_t bytes_B = (size_t)K * N * sizeof(float); + size_t bytes_C = (size_t)M * N * sizeof(float); + size_t bytes_b = (size_t)N * sizeof(float); + + float *dA = (float *)register_host_safe((void *)A, bytes_A); + float *dB = (float *)register_host_safe((void *)B, bytes_B); + float *dC = (float *)register_host_safe(C, bytes_C); + float *dBias = (float *)register_host_safe((void *)bias, bytes_b); + + cublasLtMatmulDesc_t matmul_desc = NULL; + cublasLtMatrixLayout_t aDesc = NULL, bDesc = NULL, cDesc = NULL; + + // Op descriptor: f32 compute, f32 scale. + cublasStatus_t s; + s = cublasLtMatmulDescCreate(&matmul_desc, CUBLAS_COMPUTE_32F, CUDA_R_32F); + if (s != CUBLAS_STATUS_SUCCESS) { fprintf(stderr, "cublasLtMatmulDescCreate failed: %d\n", (int)s); abort(); } + + cublasOperation_t opN = CUBLAS_OP_N; + cublasLtMatmulDescSetAttribute(matmul_desc, CUBLASLT_MATMUL_DESC_TRANSA, + &opN, sizeof(opN)); + cublasLtMatmulDescSetAttribute(matmul_desc, CUBLASLT_MATMUL_DESC_TRANSB, + &opN, sizeof(opN)); + + // Epilogue: bias + ReLU (applied in that order, then ReLU on top of bias). + cublasLtEpilogue_t epi = CUBLASLT_EPILOGUE_RELU_BIAS; + cublasLtMatmulDescSetAttribute(matmul_desc, CUBLASLT_MATMUL_DESC_EPILOGUE, + &epi, sizeof(epi)); + cublasLtMatmulDescSetAttribute(matmul_desc, CUBLASLT_MATMUL_DESC_BIAS_POINTER, + &dBias, sizeof(dBias)); + + // Row-major → col-major operand swap (same as cublasDgemm in this file): + // Compute Cᵀ = Bᵀ_col · Aᵀ_col, where each is created as col-major with + // sizes that mirror our row-major source. So in cublasLt's view: + // "A" of the matmul is our B (size N × K, col-major, lda=N=ldb_row) + // "B" of the matmul is our A (size K × M, col-major, lda=K) + // "C" of the matmul is our C (size N × M, col-major, lda=N) + cublasLtMatrixLayoutCreate(&aDesc, CUDA_R_32F, N, K, N); + cublasLtMatrixLayoutCreate(&bDesc, CUDA_R_32F, K, M, K); + cublasLtMatrixLayoutCreate(&cDesc, CUDA_R_32F, N, M, N); + + // Algorithm selection — heuristic, request 1 candidate. + cublasLtMatmulPreference_t pref; + cublasLtMatmulPreferenceCreate(&pref); + size_t ws_size = 16 * 1024 * 1024; // 16 MB workspace + cublasLtMatmulPreferenceSetAttribute(pref, + CUBLASLT_MATMUL_PREF_MAX_WORKSPACE_BYTES, &ws_size, sizeof(ws_size)); + cublasLtMatmulHeuristicResult_t heur; + int n_results = 0; + cublasLtMatmulAlgoGetHeuristic(g_lt, matmul_desc, + aDesc, bDesc, cDesc, cDesc, pref, 1, &heur, &n_results); + if (n_results < 1) { + fprintf(stderr, "cublasLt: no matmul algo available\n"); abort(); + } + void *dWS = NULL; + if (heur.workspaceSize > 0) DEVICE_MALLOC(&dWS, heur.workspaceSize); + + float alpha = 1.0f, beta = 0.0f; + s = cublasLtMatmul(g_lt, matmul_desc, + &alpha, dB, aDesc, // swapped: cublasLt's "A" is our B + dA, bDesc, // swapped: cublasLt's "B" is our A + &beta, dC, cDesc, + dC, cDesc, + &heur.algo, dWS, heur.workspaceSize, g_stream); + if (s != CUBLAS_STATUS_SUCCESS) { + fprintf(stderr, "cublasLtMatmul failed: %d\n", (int)s); abort(); + } + sync_stream_if_outside_pipeline(); + + if (dWS) DEVICE_FREE(dWS); + cublasLtMatmulPreferenceDestroy(pref); + cublasLtMatrixLayoutDestroy(aDesc); + cublasLtMatrixLayoutDestroy(bDesc); + cublasLtMatrixLayoutDestroy(cDesc); + cublasLtMatmulDescDestroy(matmul_desc); +} + +// Fused conv + bn-inference + relu via cudnnConvolutionBiasActivationForward. +// The trick is "BN folding": cudnnConvolutionBiasActivationForward computes +// y = activation(α₁ * conv(x, w) + α₂ * z + bias) +// natively. To fold inference-mode BN into it, pre-compute on host: +// w'[oc,ic,kh,kw] = w[oc,ic,kh,kw] * scale[oc] * inv_std[oc] +// b'[oc] = bias[oc] - scale[oc] * mean[oc] * inv_std[oc] +// Then cudnnConvolutionBiasActivationForward(x, w', 1, conv, 0, _, b', +// RELU, y) computes exactly relu(scale*(conv(x,w) - mean)*inv_std + bias). +// +// The folding is O(OC*IC*K²) on host, much smaller than the conv itself +// (the LARGE shape has IC=OC=64, K=3 → 36864 muls; the conv itself does +// ~10B muls). So it doesn't bottleneck. In a real CNN, this folding +// would be done once at model-load time, not per call. +void polygeist_cudnn_conv_bn_relu_fused( + int32_t B, int32_t IC, int32_t OC, + int32_t H, int32_t W, int32_t K, + const float *A, const float *F, + const float *scale, const float *mean, + const float *inv_std, const float *bias, + float *Out) { + polygeist_cublas_init(); + ensure_cudnn(); + + const int32_t OH = H - K + 1; + const int32_t OW = W - K + 1; + + // Host-side BN-into-conv folding. + size_t n_w = (size_t)OC * IC * K * K; + float *F_fold = (float *)malloc(n_w * sizeof(float)); + float *b_fold = (float *)malloc((size_t)OC * sizeof(float)); + for (int32_t oc = 0; oc < OC; ++oc) { + float coef = scale[oc] * inv_std[oc]; + for (int32_t ic = 0; ic < IC; ++ic) + for (int32_t kh = 0; kh < K; ++kh) + for (int32_t kw = 0; kw < K; ++kw) { + size_t idx = ((size_t)oc * IC + ic) * K * K + + (size_t)kh * K + kw; + F_fold[idx] = F[idx] * coef; + } + b_fold[oc] = bias[oc] - scale[oc] * mean[oc] * inv_std[oc]; + } + + size_t bytes_A = (size_t)B * IC * H * W * sizeof(float); + size_t bytes_F = (size_t)OC * IC * K * K * sizeof(float); + size_t bytes_Ou = (size_t)B * OC * OH * OW * sizeof(float); + size_t bytes_b = (size_t)OC * sizeof(float); + + float *dA = (float *)register_host_safe((void *)A, bytes_A); + float *dO = (float *)register_host_safe(Out, bytes_Ou); + // Folded weights / bias live on the device (recomputed per call — + // could be hoisted to a one-time setup once we wire device-residency). + float *dF = NULL, *dB = NULL; + DEVICE_MALLOC((void **)&dF, bytes_F); + DEVICE_MALLOC((void **)&dB, bytes_b); + CUDA_CHECK(cudaMemcpyAsync(dF, F_fold, bytes_F, cudaMemcpyHostToDevice, g_stream)); + CUDA_CHECK(cudaMemcpyAsync(dB, b_fold, bytes_b, cudaMemcpyHostToDevice, g_stream)); + + cudnnTensorDescriptor_t in_desc, out_desc, bias_desc; + cudnnFilterDescriptor_t f_desc; + cudnnConvolutionDescriptor_t conv_desc; + cudnnActivationDescriptor_t act_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&in_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&out_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&bias_desc)); + CUDNN_CHECK(cudnnCreateFilterDescriptor(&f_desc)); + CUDNN_CHECK(cudnnCreateConvolutionDescriptor(&conv_desc)); + CUDNN_CHECK(cudnnCreateActivationDescriptor(&act_desc)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(in_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, B, IC, H, W)); + CUDNN_CHECK(cudnnSetFilter4dDescriptor(f_desc, CUDNN_DATA_FLOAT, + CUDNN_TENSOR_NCHW, OC, IC, K, K)); + CUDNN_CHECK(cudnnSetConvolution2dDescriptor( + conv_desc, 0, 0, 1, 1, 1, 1, + CUDNN_CROSS_CORRELATION, CUDNN_DATA_FLOAT)); + // CUDNN_DEFAULT_MATH would let cuDNN pick tensor cores. Required for + // the fused path on Ampere+ (Orin); without it the API falls back to + // generic kernels. + CUDNN_CHECK(cudnnSetConvolutionMathType(conv_desc, CUDNN_DEFAULT_MATH)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(out_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, B, OC, OH, OW)); + // Bias is 1×OC×1×1 broadcast across (B, OH, OW). + CUDNN_CHECK(cudnnSetTensor4dDescriptor(bias_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, OC, 1, 1)); + // ReLU activation, no NaN propagation, threshold 0. + CUDNN_CHECK(cudnnSetActivationDescriptor( + act_desc, CUDNN_ACTIVATION_RELU, CUDNN_NOT_PROPAGATE_NAN, 0.0)); + + // Algorithm selection. cudnnConvolutionBiasActivationForward requires + // CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_PRECOMP_GEMM in many cuDNN versions + // (the other algos return NOT_SUPPORTED through the fused API). Ask + // cuDNN for up to 8 candidates in one call and pick PRECOMP_GEMM if + // it appears; else fall back to cuDNN's first preference. + enum { ALGO_CANDIDATES = 8 }; + cudnnConvolutionFwdAlgoPerf_t algos[ALGO_CANDIDATES]; + int n_returned = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, + ALGO_CANDIDATES, &n_returned, algos)); + if (n_returned < 1) { + fprintf(stderr, "cuDNN conv_bn_relu_fused: no fwd algo available\n"); + abort(); + } + cudnnConvolutionFwdAlgo_t algo = algos[0].algo; + for (int i = 0; i < n_returned; ++i) { + if (algos[i].algo == CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_PRECOMP_GEMM) { + algo = algos[i].algo; + break; + } + } + + size_t ws_size = 0; + CUDNN_CHECK(cudnnGetConvolutionForwardWorkspaceSize( + g_cudnn, in_desc, f_desc, conv_desc, out_desc, algo, &ws_size)); + void *dWS = NULL; + if (ws_size > 0) DEVICE_MALLOC(&dWS, ws_size); + + // y = act(α₁ * conv(x, w') + α₂ * z + b'). We want α₂ = 0 so z is + // unused — but cuDNN requires a valid z descriptor + pointer anyway. + // Reuse the output buffer as z (cuDNN accepts that when α₂ = 0). + float alpha1 = 1.0f, alpha2 = 0.0f; + CUDNN_CHECK(cudnnConvolutionBiasActivationForward( + g_cudnn, &alpha1, in_desc, dA, f_desc, dF, conv_desc, algo, + dWS, ws_size, &alpha2, out_desc, dO, + bias_desc, dB, act_desc, out_desc, dO)); + sync_stream_if_outside_pipeline(); + + if (dWS) DEVICE_FREE(dWS); + DEVICE_FREE(dF); + DEVICE_FREE(dB); + pipeline_host_free(F_fold); + pipeline_host_free(b_fold); + cudnnDestroyTensorDescriptor(in_desc); + cudnnDestroyTensorDescriptor(out_desc); + cudnnDestroyTensorDescriptor(bias_desc); + cudnnDestroyFilterDescriptor(f_desc); + cudnnDestroyConvolutionDescriptor(conv_desc); + cudnnDestroyActivationDescriptor(act_desc); +} + +static void rmsnorm_host_f32( + int32_t N, const float *X, const float *Weight, float *Out) { + float ss = 0.0f; + for (int32_t i = 0; i < N; ++i) + ss += X[i] * X[i]; + float scale = 1.0f / sqrtf(ss / (float)N + 1.0e-5f); + for (int32_t i = 0; i < N; ++i) + Out[i] = Weight[i] * (scale * X[i]); +} + +#define RMSNORM_F32_CACHE_CAP 8 +struct rmsnorm_f32_plan { + int in_use; + int unsupported; + int32_t N; + size_t bytes; + float epsilon; + + float *dX; + float *dWeight; + float *dOut; + float *dBias; + void *workspace; + + cudnnBackendDescriptor_t x_desc; + cudnnBackendDescriptor_t scale_desc; + cudnnBackendDescriptor_t bias_desc; + cudnnBackendDescriptor_t epsilon_desc; + cudnnBackendDescriptor_t y_desc; + cudnnBackendDescriptor_t norm_op; + cudnnBackendDescriptor_t op_graph; + cudnnBackendDescriptor_t engine; + cudnnBackendDescriptor_t engine_cfg; + cudnnBackendDescriptor_t plan; + cudnnBackendDescriptor_t variant_pack; +}; + +static struct rmsnorm_f32_plan g_rmsnorm_f32_cache[RMSNORM_F32_CACHE_CAP]; + +static void release_rmsnorm_f32_plan_resources(struct rmsnorm_f32_plan *p) { + destroy_backend_desc(&p->variant_pack); + destroy_backend_desc(&p->plan); + destroy_backend_desc(&p->engine_cfg); + destroy_backend_desc(&p->engine); + destroy_backend_desc(&p->op_graph); + destroy_backend_desc(&p->norm_op); + destroy_backend_desc(&p->y_desc); + destroy_backend_desc(&p->epsilon_desc); + destroy_backend_desc(&p->bias_desc); + destroy_backend_desc(&p->scale_desc); + destroy_backend_desc(&p->x_desc); + if (p->workspace) { + DEVICE_FREE(p->workspace); + p->workspace = NULL; + } + if (p->dBias) { + DEVICE_FREE(p->dBias); + p->dBias = NULL; + } + if (p->dOut) { + DEVICE_FREE(p->dOut); + p->dOut = NULL; + } + if (p->dWeight) { + DEVICE_FREE(p->dWeight); + p->dWeight = NULL; + } + if (p->dX) { + DEVICE_FREE(p->dX); + p->dX = NULL; + } +} + +static struct rmsnorm_f32_plan *find_rmsnorm_f32_plan(int32_t N) { + for (int i = 0; i < RMSNORM_F32_CACHE_CAP; ++i) + if (g_rmsnorm_f32_cache[i].in_use && g_rmsnorm_f32_cache[i].N == N) + return &g_rmsnorm_f32_cache[i]; + return NULL; +} + +static struct rmsnorm_f32_plan *alloc_rmsnorm_f32_plan(int32_t N) { + for (int i = 0; i < RMSNORM_F32_CACHE_CAP; ++i) { + if (!g_rmsnorm_f32_cache[i].in_use) { + memset(&g_rmsnorm_f32_cache[i], 0, sizeof(g_rmsnorm_f32_cache[i])); + g_rmsnorm_f32_cache[i].in_use = 1; + g_rmsnorm_f32_cache[i].N = N; + return &g_rmsnorm_f32_cache[i]; + } + } + fprintf(stderr, "polygeist runtime: RMSNorm f32 cache full (cap=%d)\n", + RMSNORM_F32_CACHE_CAP); + abort(); +} + +static int build_rmsnorm_f32_plan(struct rmsnorm_f32_plan *p) { + cudnnStatus_t last_status = CUDNN_STATUS_SUCCESS; + + p->bytes = (size_t)p->N * sizeof(float); + p->epsilon = 1.0e-5f; + DEVICE_MALLOC((void **)&p->dX, p->bytes); + DEVICE_MALLOC((void **)&p->dWeight, p->bytes); + DEVICE_MALLOC((void **)&p->dOut, p->bytes); + DEVICE_MALLOC((void **)&p->dBias, p->bytes); + CUDA_CHECK(cudaMemsetAsync(p->dBias, 0, p->bytes, g_stream)); + + int64_t tensor_dims[4] = {1, (int64_t)p->N, 1, 1}; + int64_t tensor_strides[4] = {(int64_t)p->N, 1, 1, 1}; + int64_t scalar_dims[4] = {1, 1, 1, 1}; + int64_t scalar_strides[4] = {1, 1, 1, 1}; + int64_t uid_x = 'x'; + int64_t uid_scale = 's'; + int64_t uid_bias = 'b'; + int64_t uid_epsilon = 'e'; + int64_t uid_y = 'y'; + + if (!make_f32_backend_tensor(&p->x_desc, uid_x, tensor_dims, tensor_strides, 4, + false, "rmsnorm.x", &last_status) || + !make_f32_backend_tensor(&p->scale_desc, uid_scale, tensor_dims, + tensor_strides, 4, false, "rmsnorm.scale", + &last_status) || + !make_f32_backend_tensor(&p->bias_desc, uid_bias, tensor_dims, + tensor_strides, 4, false, "rmsnorm.bias", + &last_status) || + !make_f32_backend_tensor(&p->epsilon_desc, uid_epsilon, scalar_dims, + scalar_strides, 4, true, "rmsnorm.epsilon", + &last_status) || + !make_f32_backend_tensor(&p->y_desc, uid_y, tensor_dims, tensor_strides, 4, + false, "rmsnorm.y", &last_status)) + return 0; + + last_status = cudnnBackendCreateDescriptor( + CUDNN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR, &p->norm_op); + if (last_status != CUDNN_STATUS_SUCCESS) { + report_rmsnorm_backend_fallback("rmsnorm.norm_op.create", last_status); + return 0; + } + cudnnBackendNormMode_t mode = CUDNN_RMS_NORM; + cudnnBackendNormFwdPhase_t phase = CUDNN_NORM_FWD_INFERENCE; + if (!set_backend_attr(p->norm_op, CUDNN_ATTR_OPERATION_NORM_FWD_MODE, + CUDNN_TYPE_NORM_MODE, 1, &mode, "rmsnorm.mode", + &last_status) || + !set_backend_attr(p->norm_op, CUDNN_ATTR_OPERATION_NORM_FWD_PHASE, + CUDNN_TYPE_NORM_FWD_PHASE, 1, &phase, "rmsnorm.phase", + &last_status) || + !set_backend_attr(p->norm_op, CUDNN_ATTR_OPERATION_NORM_FWD_XDESC, + CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, &p->x_desc, + "rmsnorm.xdesc", &last_status) || + !set_backend_attr(p->norm_op, CUDNN_ATTR_OPERATION_NORM_FWD_SCALE_DESC, + CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, &p->scale_desc, + "rmsnorm.scale_desc", &last_status) || + !set_backend_attr(p->norm_op, CUDNN_ATTR_OPERATION_NORM_FWD_BIAS_DESC, + CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, &p->bias_desc, + "rmsnorm.bias_desc", &last_status) || + !set_backend_attr(p->norm_op, CUDNN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC, + CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, &p->epsilon_desc, + "rmsnorm.epsilon_desc", &last_status) || + !set_backend_attr(p->norm_op, CUDNN_ATTR_OPERATION_NORM_FWD_YDESC, + CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, &p->y_desc, + "rmsnorm.ydesc", &last_status) || + !finalize_backend_desc(p->norm_op, "rmsnorm.norm_op.finalize", + &last_status)) + return 0; + + last_status = cudnnBackendCreateDescriptor( + CUDNN_BACKEND_OPERATIONGRAPH_DESCRIPTOR, &p->op_graph); + if (last_status != CUDNN_STATUS_SUCCESS) { + report_rmsnorm_backend_fallback("rmsnorm.graph.create", last_status); + return 0; + } + if (!set_backend_attr(p->op_graph, CUDNN_ATTR_OPERATIONGRAPH_HANDLE, + CUDNN_TYPE_HANDLE, 1, &g_cudnn, "rmsnorm.graph.handle", + &last_status) || + !set_backend_attr(p->op_graph, CUDNN_ATTR_OPERATIONGRAPH_OPS, + CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, &p->norm_op, + "rmsnorm.graph.ops", &last_status) || + !finalize_backend_desc(p->op_graph, "rmsnorm.graph.finalize", + &last_status)) + return 0; + + int64_t engine_count = 0; + int64_t elem_count = 0; + last_status = cudnnBackendGetAttribute( + p->op_graph, CUDNN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT, + CUDNN_TYPE_INT64, 1, &elem_count, &engine_count); + if (last_status != CUDNN_STATUS_SUCCESS || engine_count <= 0) { + if (last_status == CUDNN_STATUS_SUCCESS) + last_status = CUDNN_STATUS_NOT_SUPPORTED; + report_rmsnorm_backend_fallback("rmsnorm.engine_count", last_status); + return 0; + } + + cudnnStatus_t plan_status = CUDNN_STATUS_NOT_SUPPORTED; + for (int64_t gidx = 0; gidx < engine_count; ++gidx) { + cudnnBackendDescriptor_t engine_tmp = NULL; + cudnnBackendDescriptor_t cfg_tmp = NULL; + cudnnBackendDescriptor_t plan_tmp = NULL; + + plan_status = cudnnBackendCreateDescriptor(CUDNN_BACKEND_ENGINE_DESCRIPTOR, + &engine_tmp); + if (plan_status != CUDNN_STATUS_SUCCESS) + goto engine_cleanup; + plan_status = cudnnBackendSetAttribute( + engine_tmp, CUDNN_ATTR_ENGINE_OPERATION_GRAPH, + CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, &p->op_graph); + if (plan_status != CUDNN_STATUS_SUCCESS) + goto engine_cleanup; + plan_status = cudnnBackendSetAttribute( + engine_tmp, CUDNN_ATTR_ENGINE_GLOBAL_INDEX, CUDNN_TYPE_INT64, 1, + &gidx); + if (plan_status != CUDNN_STATUS_SUCCESS) + goto engine_cleanup; + plan_status = cudnnBackendFinalize(engine_tmp); + if (plan_status != CUDNN_STATUS_SUCCESS) + goto engine_cleanup; + + plan_status = cudnnBackendCreateDescriptor( + CUDNN_BACKEND_ENGINECFG_DESCRIPTOR, &cfg_tmp); + if (plan_status != CUDNN_STATUS_SUCCESS) + goto engine_cleanup; + plan_status = cudnnBackendSetAttribute( + cfg_tmp, CUDNN_ATTR_ENGINECFG_ENGINE, CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, + &engine_tmp); + if (plan_status != CUDNN_STATUS_SUCCESS) + goto engine_cleanup; + plan_status = cudnnBackendFinalize(cfg_tmp); + if (plan_status != CUDNN_STATUS_SUCCESS) + goto engine_cleanup; + + plan_status = cudnnBackendCreateDescriptor( + CUDNN_BACKEND_EXECUTION_PLAN_DESCRIPTOR, &plan_tmp); + if (plan_status != CUDNN_STATUS_SUCCESS) + goto engine_cleanup; + plan_status = cudnnBackendSetAttribute( + plan_tmp, CUDNN_ATTR_EXECUTION_PLAN_HANDLE, CUDNN_TYPE_HANDLE, 1, + &g_cudnn); + if (plan_status != CUDNN_STATUS_SUCCESS) + goto engine_cleanup; + plan_status = cudnnBackendSetAttribute( + plan_tmp, CUDNN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG, + CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, &cfg_tmp); + if (plan_status != CUDNN_STATUS_SUCCESS) + goto engine_cleanup; + plan_status = cudnnBackendFinalize(plan_tmp); + if (plan_status == CUDNN_STATUS_SUCCESS) { + p->engine = engine_tmp; + p->engine_cfg = cfg_tmp; + p->plan = plan_tmp; + break; + } + +engine_cleanup: + if (plan_status == CUDNN_STATUS_SUCCESS) + plan_status = CUDNN_STATUS_NOT_SUPPORTED; + if (plan_tmp != p->plan) + destroy_backend_desc(&plan_tmp); + if (cfg_tmp != p->engine_cfg) + destroy_backend_desc(&cfg_tmp); + if (engine_tmp != p->engine) + destroy_backend_desc(&engine_tmp); + } + if (!p->plan) { + report_rmsnorm_backend_fallback("rmsnorm.plan", plan_status); + return 0; + } + + int64_t workspace_size = 0; + last_status = cudnnBackendGetAttribute( + p->plan, CUDNN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE, CUDNN_TYPE_INT64, 1, + &elem_count, &workspace_size); + if (last_status != CUDNN_STATUS_SUCCESS) { + report_rmsnorm_backend_fallback("rmsnorm.workspace_size", last_status); + return 0; + } + if (workspace_size > 0) + DEVICE_MALLOC(&p->workspace, (size_t)workspace_size); + + last_status = cudnnBackendCreateDescriptor( + CUDNN_BACKEND_VARIANT_PACK_DESCRIPTOR, &p->variant_pack); + if (last_status != CUDNN_STATUS_SUCCESS) { + report_rmsnorm_backend_fallback("rmsnorm.variant.create", last_status); + return 0; + } + int64_t uids[5] = {uid_x, uid_scale, uid_bias, uid_epsilon, uid_y}; + void *data_ptrs[5] = {p->dX, p->dWeight, p->dBias, &p->epsilon, p->dOut}; + if (!set_backend_attr(p->variant_pack, CUDNN_ATTR_VARIANT_PACK_DATA_POINTERS, + CUDNN_TYPE_VOID_PTR, 5, data_ptrs, + "rmsnorm.variant.ptrs", &last_status) || + !set_backend_attr(p->variant_pack, CUDNN_ATTR_VARIANT_PACK_UNIQUE_IDS, + CUDNN_TYPE_INT64, 5, uids, "rmsnorm.variant.uids", + &last_status) || + !set_backend_attr(p->variant_pack, CUDNN_ATTR_VARIANT_PACK_WORKSPACE, + CUDNN_TYPE_VOID_PTR, 1, &p->workspace, + "rmsnorm.variant.workspace", &last_status) || + !finalize_backend_desc(p->variant_pack, "rmsnorm.variant.finalize", + &last_status)) + return 0; + + return 1; +} + +static struct rmsnorm_f32_plan *get_rmsnorm_f32_plan(int32_t N) { + struct rmsnorm_f32_plan *p = find_rmsnorm_f32_plan(N); + if (p) return p; + + p = alloc_rmsnorm_f32_plan(N); + if (!build_rmsnorm_f32_plan(p)) { + release_rmsnorm_f32_plan_resources(p); + p->unsupported = 1; + } + return p; +} + +static int try_cudnn_rmsnorm_f32( + int32_t N, const float *X, const float *Weight, float *Out, + double host_start_ms) { + struct rmsnorm_f32_plan *p = get_rmsnorm_f32_plan(N); + if (!p || p->unsupported) + return 0; + + CUDA_CHECK(cudaMemcpyAsync(p->dX, X, p->bytes, cudaMemcpyHostToDevice, + g_stream)); + CUDA_CHECK(cudaMemcpyAsync(p->dWeight, Weight, p->bytes, + cudaMemcpyHostToDevice, g_stream)); + + timing_gpu_begin(); + CUDNN_CHECK(cudnnBackendExecute(g_cudnn, p->plan, p->variant_pack)); + CUDA_CHECK(cudaMemcpyAsync(Out, p->dOut, p->bytes, cudaMemcpyDeviceToHost, + g_stream)); + timing_gpu_end("cudnnRmsNormForward", 1, N, 0, host_start_ms); + return 1; +} + +void polygeist_rmsnorm_f32( + int32_t N, const float *X, const float *Weight, float *Out) { + if (N <= 0) return; + polygeist_cublas_init(); + ensure_cudnn(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + if (try_cudnn_rmsnorm_f32(N, X, Weight, Out, host_start_ms)) + return; + + sync_stream_if_outside_pipeline(); + rmsnorm_host_f32(N, X, Weight, Out); + + timing_host_only("host_rmsnorm_f32", N, 1, 0, host_start_ms); +} + +void polygeist_rmsnorm_unweighted_f32( + int32_t N, const float *X, float *Out) { + if (N <= 0) return; + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t bytes = (size_t)N * sizeof(float); + float *dX = (float *)register_host_safe((void *)X, bytes); + float *dOut = (float *)register_host_safe(Out, bytes); + + float ss = 0.0f; + timing_gpu_begin(); + CUBLAS_CHECK(cublasSdot(g_handle, N, dX, 1, dX, 1, &ss)); + CUDA_CHECK(cudaMemcpyAsync(dOut, dX, bytes, cudaMemcpyDeviceToDevice, + g_stream)); + float scale = 1.0f / sqrtf(ss / (float)N + 1.0e-5f); + CUBLAS_CHECK(cublasSscal(g_handle, N, &scale, dOut, 1)); + timing_gpu_end("cublasRmsNormUnweighted_f32", N, 1, 0, host_start_ms); +} + +void polygeist_cublas_dot_f32( + int32_t N, const float *X, const float *Y, float *Out) { + if (N <= 0) { + void *device_out = NULL; + if (pointer_is_device_resident(Out, &device_out)) + CUDA_CHECK(cudaMemset(device_out, 0, sizeof(float))); + else + *Out = 0.0f; + return; + } + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t bytes = (size_t)N * sizeof(float); + float *dX = (float *)register_host_safe((void *)X, bytes); + float *dY = (float *)register_host_safe((void *)Y, bytes); + void *device_out = NULL; + int out_is_device = pointer_is_device_resident(Out, &device_out); + float host_out = 0.0f; + + timing_gpu_begin(); + CUBLAS_CHECK(cublasSdot(g_handle, N, dX, 1, dY, 1, + out_is_device ? &host_out : Out)); + if (out_is_device) + CUDA_CHECK(cudaMemcpy(device_out, &host_out, sizeof(float), + cudaMemcpyHostToDevice)); + timing_gpu_end("cublasSdot", N, 1, 0, host_start_ms); +} + +void polygeist_cublas_dot_f64( + int32_t N, const double *X, const double *Y, double *Out) { + if (N <= 0) { + void *device_out = NULL; + if (pointer_is_device_resident(Out, &device_out)) + CUDA_CHECK(cudaMemset(device_out, 0, sizeof(double))); + else + *Out = 0.0; + return; + } + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t bytes = (size_t)N * sizeof(double); + double *dX = (double *)register_host_safe((void *)X, bytes); + double *dY = (double *)register_host_safe((void *)Y, bytes); + void *device_out = NULL; + int out_is_device = pointer_is_device_resident(Out, &device_out); + double host_out = 0.0; + + timing_gpu_begin(); + CUBLAS_CHECK(cublasDdot(g_handle, N, dX, 1, dY, 1, + out_is_device ? &host_out : Out)); + if (out_is_device) + CUDA_CHECK(cudaMemcpy(device_out, &host_out, sizeof(double), + cudaMemcpyHostToDevice)); + timing_gpu_end("cublasDdot", N, 1, 0, host_start_ms); +} + +void polygeist_cuda_gelu_tanh_f32( + int32_t N, const float *X, float *Out) { + if (N <= 0) return; + polygeist_cublas_init(); + ensure_cudnn(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t bytes = (size_t)N * sizeof(float); + float *dX = (float *)register_host_safe((void *)X, bytes); + float *dOut = (float *)register_host_safe(Out, bytes); + float *dTmp0 = NULL; + float *dTmp1 = NULL; + float *dOnes = NULL; + float *ones = (float *)malloc(bytes); + if (!ones) { + fprintf(stderr, "polygeist_cuda_gelu_tanh_f32: malloc failed\n"); + abort(); + } + for (int32_t i = 0; i < N; ++i) + ones[i] = 1.0f; + DEVICE_MALLOC((void **)&dTmp0, bytes); + DEVICE_MALLOC((void **)&dTmp1, bytes); + DEVICE_MALLOC((void **)&dOnes, bytes); + + cudnnTensorDescriptor_t desc; + cudnnActivationDescriptor_t tanh_desc; + cudnnOpTensorDescriptor_t mul_desc, add_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&desc)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, 1, 1, N)); + CUDNN_CHECK(cudnnCreateActivationDescriptor(&tanh_desc)); + CUDNN_CHECK(cudnnSetActivationDescriptor( + tanh_desc, CUDNN_ACTIVATION_TANH, CUDNN_PROPAGATE_NAN, 0.0)); + CUDNN_CHECK(cudnnCreateOpTensorDescriptor(&mul_desc)); + CUDNN_CHECK(cudnnSetOpTensorDescriptor( + mul_desc, CUDNN_OP_TENSOR_MUL, CUDNN_DATA_FLOAT, CUDNN_PROPAGATE_NAN)); + CUDNN_CHECK(cudnnCreateOpTensorDescriptor(&add_desc)); + CUDNN_CHECK(cudnnSetOpTensorDescriptor( + add_desc, CUDNN_OP_TENSOR_ADD, CUDNN_DATA_FLOAT, CUDNN_PROPAGATE_NAN)); + + const float one = 1.0f; + const float zero = 0.0f; + const float half = 0.5f; + const float cube_coeff = 0.044715f; + const float sqrt_2_over_pi = 0.7978845608028654f; + + timing_gpu_begin(); + CUDA_CHECK(cudaMemcpyAsync(dOnes, ones, bytes, cudaMemcpyHostToDevice, + g_stream)); + // tmp0 = x * x + CUDNN_CHECK(cudnnOpTensor(g_cudnn, mul_desc, + &one, desc, dX, + &one, desc, dX, + &zero, desc, dTmp0)); + // tmp0 = tmp0 * x = x^3 + CUDNN_CHECK(cudnnOpTensor(g_cudnn, mul_desc, + &one, desc, dTmp0, + &one, desc, dX, + &zero, desc, dTmp0)); + // tmp1 = x + 0.044715 * x^3 + CUDNN_CHECK(cudnnOpTensor(g_cudnn, add_desc, + &one, desc, dX, + &cube_coeff, desc, dTmp0, + &zero, desc, dTmp1)); + CUBLAS_CHECK(cublasSscal(g_handle, N, &sqrt_2_over_pi, dTmp1, 1)); + CUDNN_CHECK(cudnnActivationForward(g_cudnn, tanh_desc, + &one, desc, dTmp1, + &zero, desc, dTmp1)); + // tmp1 = 1 + tanh(...) + CUDNN_CHECK(cudnnOpTensor(g_cudnn, add_desc, + &one, desc, dTmp1, + &one, desc, dOnes, + &zero, desc, dTmp1)); + // out = 0.5 * x * tmp1 + CUDNN_CHECK(cudnnOpTensor(g_cudnn, mul_desc, + &half, desc, dX, + &one, desc, dTmp1, + &zero, desc, dOut)); + timing_gpu_end("cudaGeluTanh_f32", N, 1, 0, host_start_ms); + + cudnnDestroyOpTensorDescriptor(mul_desc); + cudnnDestroyOpTensorDescriptor(add_desc); + cudnnDestroyActivationDescriptor(tanh_desc); + cudnnDestroyTensorDescriptor(desc); + DEVICE_FREE(dTmp0); + DEVICE_FREE(dTmp1); + DEVICE_FREE(dOnes); + pipeline_host_free(ones); +} + +void polygeist_whisper_exp_shift_sum_f32( + int32_t N, const float *X, float max_val, float *Out, float *Sum) { + if (N <= 0) { + *Sum = 0.0f; + return; + } + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + float sum = 0.0f; + for (int32_t i = 0; i < N; ++i) { + float v = expf(X[i] - max_val); + Out[i] = v; + sum += v; + } + *Sum = sum; + timing_host_only("hostWhisperExpShiftSum_f32", N, 1, 0, host_start_ms); +} + +void polygeist_cudnn_softmax_forward_f32(int32_t N, float *X) { + if (N <= 0) return; + polygeist_cublas_init(); + ensure_cudnn(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t bytes = (size_t)N * sizeof(float); + float *dX = (float *)register_host_safe(X, bytes); + + cudnnTensorDescriptor_t x_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&x_desc)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(x_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, 1, 1, N)); + + float alpha = 1.0f, beta = 0.0f; + timing_gpu_begin(); + CUDNN_CHECK(cudnnSoftmaxForward( + g_cudnn, CUDNN_SOFTMAX_ACCURATE, CUDNN_SOFTMAX_MODE_INSTANCE, + &alpha, x_desc, dX, &beta, x_desc, dX)); + timing_gpu_end("cudnnSoftmaxForward", 1, N, 0, host_start_ms); + + cudnnDestroyTensorDescriptor(x_desc); +} + +void polygeist_cudnn_softmax_forward_out_f32( + int32_t N, const float *X, float *Out) { + if (N <= 0) return; + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t bytes = (size_t)N * sizeof(float); + float *dX = (float *)register_host_safe((void *)X, bytes); + float *dOut = (float *)register_host_safe(Out, bytes); + + timing_gpu_begin(); + CUDA_CHECK(cudaMemcpyAsync(dOut, dX, bytes, cudaMemcpyDeviceToDevice, + g_stream)); + timing_gpu_end("cudaCopySoftmaxInput_f32", N, 1, 0, host_start_ms); + polygeist_cudnn_softmax_forward_f32(N, Out); +} + +void polygeist_cuda_copy_f32(int32_t N, const float *X, float *Out) { + if (N <= 0) return; + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t bytes = (size_t)N * sizeof(float); + float *dX = (float *)register_host_safe((void *)X, bytes); + float *dOut = (float *)register_host_safe(Out, bytes); + + timing_gpu_begin(); + CUDA_CHECK(cudaMemcpyAsync(dOut, dX, bytes, cudaMemcpyDeviceToDevice, + g_stream)); + timing_gpu_end("cudaCopy_f32", N, 1, 0, host_start_ms); +} + +void polygeist_cuda_copy_strided_2d_f32( + int32_t rows, int32_t cols, + int32_t src_row_stride, int32_t src_col_stride, + int32_t dst_row_stride, int32_t dst_col_stride, + const float *X, float *Out) { + if (rows <= 0 || cols <= 0) return; + if (src_col_stride != 1 || dst_col_stride != 1) { + fprintf(stderr, "cudaCopy strided f32 requires unit inner strides\n"); + abort(); + } + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + size_t src_elems = (size_t)(rows - 1) * (size_t)src_row_stride + cols; + size_t dst_elems = (size_t)(rows - 1) * (size_t)dst_row_stride + cols; + float *dX = (float *)register_host_safe((void *)X, src_elems * sizeof(float)); + float *dOut = (float *)register_host_safe(Out, dst_elems * sizeof(float)); + timing_gpu_begin(); + if (src_row_stride == cols && dst_row_stride == cols) { + CUDA_CHECK(cudaMemcpyAsync(dOut, dX, (size_t)rows * cols * sizeof(float), + cudaMemcpyDeviceToDevice, g_stream)); + } else { + CUDA_CHECK(cudaMemcpy2DAsync( + dOut, (size_t)dst_row_stride * sizeof(float), + dX, (size_t)src_row_stride * sizeof(float), + (size_t)cols * sizeof(float), rows, + cudaMemcpyDeviceToDevice, g_stream)); + } + timing_gpu_end("cudaCopyStrided2D_f32", rows, cols, 0, host_start_ms); +} + +void polygeist_cuda_add_f32( + int32_t N, const float *X, const float *Y, float *Out) { + if (N <= 0) return; + polygeist_cublas_init(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t bytes = (size_t)N * sizeof(float); + float *dX = (float *)register_host_safe((void *)X, bytes); + float *dY = (float *)register_host_safe((void *)Y, bytes); + float *dOut = (float *)register_host_safe(Out, bytes); + const float alpha = 1.0f; + + timing_gpu_begin(); + CUDA_CHECK(cudaMemcpyAsync(dOut, dX, bytes, cudaMemcpyDeviceToDevice, + g_stream)); + CUBLAS_CHECK(cublasSaxpy(g_handle, N, &alpha, dY, 1, dOut, 1)); + timing_gpu_end("cudaAdd_f32", N, 1, 0, host_start_ms); +} + +void polygeist_cuda_mask_select_f32( + int32_t N, int32_t pos, const float *Scores, float *Out) { + if (N <= 0) return; + polygeist_cublas_init(); + ensure_cudnn(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t bytes = (size_t)N * sizeof(float); + float *keep_h = (float *)malloc(bytes); + float *bias_h = (float *)malloc(bytes); + if (!keep_h || !bias_h) { + fprintf(stderr, "polygeist_cuda_mask_select_f32: malloc failed\n"); + abort(); + } + for (int32_t i = 0; i < N; ++i) { + int drop = i > pos; + keep_h[i] = drop ? 0.0f : 1.0f; + bias_h[i] = drop ? -3.4028234663852886e38f : 0.0f; + } + + float *dScores = (float *)register_host_safe((void *)Scores, bytes); + float *dOut = (float *)register_host_safe(Out, bytes); + float *dKeep = NULL; + float *dBias = NULL; + DEVICE_MALLOC((void **)&dKeep, bytes); + DEVICE_MALLOC((void **)&dBias, bytes); + + cudnnTensorDescriptor_t desc; + cudnnOpTensorDescriptor_t mul_desc, add_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&desc)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, 1, 1, N)); + CUDNN_CHECK(cudnnCreateOpTensorDescriptor(&mul_desc)); + CUDNN_CHECK(cudnnCreateOpTensorDescriptor(&add_desc)); + CUDNN_CHECK(cudnnSetOpTensorDescriptor( + mul_desc, CUDNN_OP_TENSOR_MUL, CUDNN_DATA_FLOAT, CUDNN_PROPAGATE_NAN)); + CUDNN_CHECK(cudnnSetOpTensorDescriptor( + add_desc, CUDNN_OP_TENSOR_ADD, CUDNN_DATA_FLOAT, CUDNN_PROPAGATE_NAN)); + + float one = 1.0f; + float zero = 0.0f; + timing_gpu_begin(); + CUDA_CHECK(cudaMemcpyAsync(dKeep, keep_h, bytes, cudaMemcpyHostToDevice, + g_stream)); + CUDA_CHECK(cudaMemcpyAsync(dBias, bias_h, bytes, cudaMemcpyHostToDevice, + g_stream)); + CUDNN_CHECK(cudnnOpTensor(g_cudnn, mul_desc, + &one, desc, dScores, + &one, desc, dKeep, + &zero, desc, dOut)); + CUDNN_CHECK(cudnnOpTensor(g_cudnn, add_desc, + &one, desc, dOut, + &one, desc, dBias, + &zero, desc, dOut)); + timing_gpu_end("cudaMaskSelect_f32", N, 1, 0, host_start_ms); + + cudnnDestroyOpTensorDescriptor(mul_desc); + cudnnDestroyOpTensorDescriptor(add_desc); + cudnnDestroyTensorDescriptor(desc); + DEVICE_FREE(dKeep); + DEVICE_FREE(dBias); + pipeline_host_free(keep_h); + pipeline_host_free(bias_h); +} + +void polygeist_cuda_swiglu_f32( + int32_t N, const float *Gate, const float *Up, float *Out) { + if (N <= 0) return; + polygeist_cublas_init(); + ensure_cudnn(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t bytes = (size_t)N * sizeof(float); + float *dGate = (float *)register_host_safe((void *)Gate, bytes); + float *dUp = (float *)register_host_safe((void *)Up, bytes); + float *dOut = (float *)register_host_safe(Out, bytes); + float *dSigmoid = NULL; + DEVICE_MALLOC((void **)&dSigmoid, bytes); + + cudnnTensorDescriptor_t desc; + cudnnActivationDescriptor_t act_desc; + cudnnOpTensorDescriptor_t mul_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&desc)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, 1, 1, N)); + CUDNN_CHECK(cudnnCreateActivationDescriptor(&act_desc)); + CUDNN_CHECK(cudnnSetActivationDescriptor( + act_desc, CUDNN_ACTIVATION_SIGMOID, CUDNN_PROPAGATE_NAN, 0.0)); + CUDNN_CHECK(cudnnCreateOpTensorDescriptor(&mul_desc)); + CUDNN_CHECK(cudnnSetOpTensorDescriptor( + mul_desc, CUDNN_OP_TENSOR_MUL, CUDNN_DATA_FLOAT, CUDNN_PROPAGATE_NAN)); + + float one = 1.0f; + float zero = 0.0f; + timing_gpu_begin(); + CUDNN_CHECK(cudnnActivationForward( + g_cudnn, act_desc, &one, desc, dGate, &zero, desc, dSigmoid)); + CUDNN_CHECK(cudnnOpTensor(g_cudnn, mul_desc, + &one, desc, dGate, + &one, desc, dSigmoid, + &zero, desc, dOut)); + CUDNN_CHECK(cudnnOpTensor(g_cudnn, mul_desc, + &one, desc, dOut, + &one, desc, dUp, + &zero, desc, dOut)); + timing_gpu_end("cudaSwiGLU_f32", N, 1, 0, host_start_ms); + + cudnnDestroyOpTensorDescriptor(mul_desc); + cudnnDestroyActivationDescriptor(act_desc); + cudnnDestroyTensorDescriptor(desc); + DEVICE_FREE(dSigmoid); +} + +void polygeist_cuda_rope_mulmul_f32( + int32_t M, int32_t N, const float *A, const float *B, + const float *C, const float *D, float *Out, int32_t add) { + if (M <= 0 || N <= 0) return; + polygeist_cublas_init(); + ensure_cudnn(); + double host_start_ms = timing_enabled() ? wall_time_ms() : 0.0; + + size_t mat_bytes = (size_t)M * (size_t)N * sizeof(float); + size_t vec_bytes = (size_t)N * sizeof(float); + float *dA = (float *)register_host_safe((void *)A, mat_bytes); + float *dB = (float *)register_host_safe((void *)B, vec_bytes); + float *dC = (float *)register_host_safe((void *)C, mat_bytes); + float *dD = (float *)register_host_safe((void *)D, vec_bytes); + float *dOut = (float *)register_host_safe(Out, mat_bytes); + float *dTmp = NULL; + DEVICE_MALLOC((void **)&dTmp, mat_bytes); + + cudnnTensorDescriptor_t mat_desc, vec_desc; + cudnnOpTensorDescriptor_t mul_desc, add_desc; + CUDNN_CHECK(cudnnCreateTensorDescriptor(&mat_desc)); + CUDNN_CHECK(cudnnCreateTensorDescriptor(&vec_desc)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(mat_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, 1, M, N)); + CUDNN_CHECK(cudnnSetTensor4dDescriptor(vec_desc, CUDNN_TENSOR_NCHW, + CUDNN_DATA_FLOAT, 1, 1, 1, N)); + CUDNN_CHECK(cudnnCreateOpTensorDescriptor(&mul_desc)); + CUDNN_CHECK(cudnnCreateOpTensorDescriptor(&add_desc)); + CUDNN_CHECK(cudnnSetOpTensorDescriptor( + mul_desc, CUDNN_OP_TENSOR_MUL, CUDNN_DATA_FLOAT, CUDNN_PROPAGATE_NAN)); + CUDNN_CHECK(cudnnSetOpTensorDescriptor( + add_desc, CUDNN_OP_TENSOR_ADD, CUDNN_DATA_FLOAT, CUDNN_PROPAGATE_NAN)); + + float one = 1.0f; + float zero = 0.0f; + float sign = add ? 1.0f : -1.0f; + timing_gpu_begin(); + CUDNN_CHECK(cudnnOpTensor(g_cudnn, mul_desc, + &one, mat_desc, dA, + &one, vec_desc, dB, + &zero, mat_desc, dOut)); + CUDNN_CHECK(cudnnOpTensor(g_cudnn, mul_desc, + &one, mat_desc, dC, + &one, vec_desc, dD, + &zero, mat_desc, dTmp)); + CUDNN_CHECK(cudnnOpTensor(g_cudnn, add_desc, + &one, mat_desc, dOut, + &sign, mat_desc, dTmp, + &zero, mat_desc, dOut)); + timing_gpu_end(add ? "cudaRopeMulMulAdd_f32" : "cudaRopeMulMulSub_f32", + M, N, 0, host_start_ms); + + cudnnDestroyOpTensorDescriptor(mul_desc); + cudnnDestroyOpTensorDescriptor(add_desc); + cudnnDestroyTensorDescriptor(mat_desc); + cudnnDestroyTensorDescriptor(vec_desc); + DEVICE_FREE(dTmp); +} + +void polygeist_cublas_time_begin(void) { + polygeist_cublas_init(); + cudaEventRecord(g_ev_begin, g_stream); +} + +double polygeist_cublas_time_end_ms(void) { + cudaEventRecord(g_ev_end, g_stream); + cudaEventSynchronize(g_ev_end); + float ms = 0.0f; + cudaEventElapsedTime(&ms, g_ev_begin, g_ev_end); + return (double)ms; +} diff --git a/runtime/polygeist_mlir_runner_utils.c b/runtime/polygeist_mlir_runner_utils.c new file mode 100644 index 000000000000..893772bfd09a --- /dev/null +++ b/runtime/polygeist_mlir_runner_utils.c @@ -0,0 +1,77 @@ +// Minimal MLIR runner utility support needed by residual memref.copy lowering. +// This intentionally mirrors MLIR's CRunnerUtils memrefCopy ABI, but stays C +// so it can be linked by the host and Jetson cross build paths. + +#include +#include +#include + +typedef struct { + int64_t rank; + void *descriptor; +} PolygeistUnrankedMemRef; + +typedef struct { + char *allocated; + char *aligned; + int64_t offset; + int64_t sizesAndStrides[]; +} PolygeistRankedMemRef; + +void memrefCopy(int64_t elemSize, PolygeistUnrankedMemRef *srcArg, + PolygeistUnrankedMemRef *dstArg) { + int64_t rank = srcArg->rank; + if (rank < 0) + abort(); + PolygeistRankedMemRef *src = (PolygeistRankedMemRef *)srcArg->descriptor; + PolygeistRankedMemRef *dst = (PolygeistRankedMemRef *)dstArg->descriptor; + int64_t *srcSizes = src->sizesAndStrides; + int64_t *srcStrides = src->sizesAndStrides + rank; + int64_t *dstSizes = dst->sizesAndStrides; + int64_t *dstStrides = dst->sizesAndStrides + rank; + + for (int64_t i = 0; i < rank; ++i) + if (srcSizes[i] == 0) + return; + + char *srcPtr = src->aligned + src->offset * elemSize; + char *dstPtr = dst->aligned + dst->offset * elemSize; + + if (rank == 0) { + memcpy(dstPtr, srcPtr, (size_t)elemSize); + return; + } + + int64_t *indices = (int64_t *)calloc((size_t)rank, sizeof(int64_t)); + int64_t *srcByteStrides = (int64_t *)malloc((size_t)rank * sizeof(int64_t)); + int64_t *dstByteStrides = (int64_t *)malloc((size_t)rank * sizeof(int64_t)); + if (!indices || !srcByteStrides || !dstByteStrides) + abort(); + + for (int64_t i = 0; i < rank; ++i) { + srcByteStrides[i] = srcStrides[i] * elemSize; + dstByteStrides[i] = dstStrides[i] * elemSize; + } + + int64_t readIndex = 0; + int64_t writeIndex = 0; + for (;;) { + memcpy(dstPtr + writeIndex, srcPtr + readIndex, (size_t)elemSize); + for (int64_t axis = rank - 1; axis >= 0; --axis) { + int64_t next = ++indices[axis]; + readIndex += srcByteStrides[axis]; + writeIndex += dstByteStrides[axis]; + if (next != srcSizes[axis]) + break; + if (axis == 0) { + free(indices); + free(srcByteStrides); + free(dstByteStrides); + return; + } + indices[axis] = 0; + readIndex -= srcSizes[axis] * srcByteStrides[axis]; + writeIndex -= dstSizes[axis] * dstByteStrides[axis]; + } + } +} diff --git a/runtime/polygeist_pva_rt.c b/runtime/polygeist_pva_rt.c new file mode 100644 index 000000000000..19ab8a0f70ec --- /dev/null +++ b/runtime/polygeist_pva_rt.c @@ -0,0 +1,391 @@ +/* polygeist_pva_rt.c — PVA Solutions backend for INT8/INT16 single-channel + * 9-tap 2D convolution. Links against: + * - libpva_operator.so (PVA Solutions runtime; exports pvaConv2dCreate/Submit) + * - libnvcv_types.so (NVCV core; tensor + allocator handles) + * - libcvcuda.so (CV-CUDA operators; some shared helpers) + * - libcupva_host.so (cuPVA host runtime; transitive dep of pva_operator) + * - libcudart.so (CUDA runtime) + * + * Headers come from: + * - PVA Solutions source tree at $PVASOL_INCLUDE_ROOT (OpConv2d.h, PvaAllocator.h) + * - Public CV-CUDA at $NVCV_INCLUDE_ROOT (, etc.) + * + * Both are resolved via -I at the cross-compile step. Nothing from those + * trees is checked into the Polygeist repo (see CLAUDE.md). Only the + * Polygeist-authored source in this file ships. + * + * The shim implements two entrypoints — polygeist_pva_conv2d_3x3_i8 and + * polygeist_pva_conv2d_3x3_i16 — invoked from the func.call that + * --lower-kernel-launch-to-cublas emits for any matched + * @cudnnConvolution2D_9tap_i{8,16} kernel.launch. + * + * Both shims share the same skeleton: + * open PVA → allocate PVA-resident input/output/kernel tensors via the + * PVA allocator → copy host data into them → create pvaConv2d operator + * → submit on a CUDA stream → sync → copy output back → cleanup. + */ +#include "polygeist_cublas_rt.h" + +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#define NVCV_CHECK(call) do { \ + NVCVStatus s = (call); \ + if (s != NVCV_SUCCESS) { \ + fprintf(stderr, "%s:%d nvcv error: %d\n", __FILE__, __LINE__, (int)s); \ + abort(); \ + } \ + } while (0) + +#define CUDART_CHECK(call) do { \ + cudaError_t e = (call); \ + if (e != cudaSuccess) { \ + fprintf(stderr, "%s:%d cuda error: %s\n", __FILE__, __LINE__, \ + cudaGetErrorString(e)); \ + abort(); \ + } \ + } while (0) + +/* PVA backend lazy globals. cudaStream + PVA allocator + cuPVA context are + * created on first call and persist for the lifetime of the process. */ +static int g_pva_initialized = 0; +static cudaStream_t g_pva_stream; +static NVCVAllocatorHandle g_pva_alloc; + +static void ensure_pva_init(void) { + if (g_pva_initialized) return; + /* The reference PVA Solutions samples bind a CUDA context with + * cudaSetDevice before constructing the PVA allocator. Without this, + * the cuPVA host runtime's host-mappable allocations may not have a + * usable CUDA context, and subsequent CupvaMemGetHostPointer / cudaMemcpy + * calls into the PVA-allocated memory segfault. */ + CUDART_CHECK(cudaSetDevice(0)); + CUDART_CHECK(cudaStreamCreateWithFlags(&g_pva_stream, cudaStreamNonBlocking)); + NVCV_CHECK(nvcvAllocatorConstructPva(&g_pva_alloc)); + g_pva_initialized = 1; +} + +/* Map an int-byte-width to the NVCV datatype tag PVA Conv2d accepts. */ +static NVCVDataType pva_dtype_for_int(int byte_width) { + switch (byte_width) { + case 1: return NVCV_DATA_TYPE_S8; + case 2: return NVCV_DATA_TYPE_S16; + default: + fprintf(stderr, "polygeist_pva_rt: unsupported int byte width %d\n", + byte_width); + abort(); + } +} + +/* Allocate a HWC PVA tensor of shape (H, W, 1) with an arbitrary NVCV + * dtype. Returns both the constructed tensor handle and the requirements + * struct (the caller passes the latter to pva*Create). */ +static void make_pva_image_tensor_dtype(int32_t H, int32_t W, + NVCVDataType dtype, + NVCVTensorRequirements *outReqs, + NVCVTensorHandle *outTensor) { + NVCVTensorLayout layout; + NVCV_CHECK(nvcvTensorLayoutMake("HWC", &layout)); + int64_t shape[] = { (int64_t)H, (int64_t)W, 1 }; + NVCV_CHECK(nvcvTensorCalcRequirementsPva( + /*rank=*/3, shape, dtype, layout, + /*baseAlign=*/0, /*rowAlign=*/0, outReqs)); + NVCV_CHECK(nvcvTensorConstruct(outReqs, g_pva_alloc, outTensor)); +} + +/* Back-compat wrapper: pick signed-int dtype from byte width. */ +static void make_pva_image_tensor(int32_t H, int32_t W, int byte_width, + NVCVTensorRequirements *outReqs, + NVCVTensorHandle *outTensor) { + make_pva_image_tensor_dtype(H, W, pva_dtype_for_int(byte_width), + outReqs, outTensor); +} + +/* Build a (K, K, 1) HWC kernel-coefficient tensor and populate it with + * the 9 weights. Returns the handle and the requirements struct (caller + * doesn't need the latter — kernel tensor is constructed standalone). */ +/* Map a PVA-tensor's device base pointer into a host-accessible pointer. + * PVA tensors are backed by cuPVA-mapped memory; raw cudaMemcpy on the + * device basePtr segfaults — the cuPVA-blessed path is to ask cuPVA for + * the corresponding host mapping and then plain memcpy. This is what + * the reference PVA Solutions samples (createConv2dKernel, loadConv2dInput, + * generateRandomInput, saveConv2dOutput) all do. */ +static void *pva_tensor_host_ptr(const NVCVTensorData *td) { + void *host = NULL; + cupvaError_t e = CupvaMemGetHostPointer(&host, (void *)td->buffer.strided.basePtr); + if (e != CUPVA_ERROR_NONE || host == NULL) { + fprintf(stderr, "polygeist_pva_rt: CupvaMemGetHostPointer failed (e=%d host=%p)\n", + (int)e, host); + abort(); + } + return host; +} + +static NVCVTensorHandle make_pva_kernel_tensor_i8(int byte_width, + const void *weights9) { + NVCVTensorLayout layout; + NVCV_CHECK(nvcvTensorLayoutMake("HWC", &layout)); + int64_t shape[] = { 3, 3, 1 }; + NVCVTensorRequirements reqs; + NVCV_CHECK(nvcvTensorCalcRequirementsPva( + 3, shape, pva_dtype_for_int(byte_width), layout, 0, 0, &reqs)); + NVCVTensorHandle h; + NVCV_CHECK(nvcvTensorConstruct(&reqs, g_pva_alloc, &h)); + NVCVTensorData td; + NVCV_CHECK(nvcvTensorExportData(h, &td)); + if (td.bufferType != NVCV_TENSOR_BUFFER_STRIDED_CUDA) { + fprintf(stderr, "polygeist_pva_rt: kernel tensor buffer type %d unsupported\n", + (int)td.bufferType); + abort(); + } + char *host_base = (char *)pva_tensor_host_ptr(&td); + int64_t row_stride = td.buffer.strided.strides[0]; /* bytes/row */ + for (int row = 0; row < 3; ++row) { + void *dst = host_base + row * row_stride; + const void *src = (const char *)weights9 + row * 3 * byte_width; + memcpy(dst, src, 3 * byte_width); + } + return h; +} + +/* Copy a row-major MxN host buffer into a PVA HWC tensor (or vice-versa). */ +static void copy_host_to_tensor(NVCVTensorHandle t, const void *host, + int32_t M, int32_t N, int byte_width) { + NVCVTensorData td; + NVCV_CHECK(nvcvTensorExportData(t, &td)); + char *t_host = (char *)pva_tensor_host_ptr(&td); + int64_t row_stride = td.buffer.strided.strides[0]; + for (int32_t row = 0; row < M; ++row) { + void *dst = t_host + row * row_stride; + const void *src = (const char *)host + (size_t)row * N * byte_width; + memcpy(dst, src, N * byte_width); + } +} + +static void copy_tensor_to_host(void *host, NVCVTensorHandle t, + int32_t M, int32_t N, int byte_width) { + NVCVTensorData td; + NVCV_CHECK(nvcvTensorExportData(t, &td)); + char *t_host = (char *)pva_tensor_host_ptr(&td); + int64_t row_stride = td.buffer.strided.strides[0]; + /* The matcher passes B = &B_orig[1][1] (1-row + 1-col offset into the + * caller's M×N output) and asks us to write the (M-2)×(N-2) interior. + * Copying M rows of N elements from offset (1,1) into an M×N buffer + * would overflow by N+1 elements, corrupting whatever follows B on + * the heap and causing a `corrupted size vs. prev_size` abort at + * cleanup. So we copy only (M-2) rows of (N-2) elements — exactly + * the interior that the harness's dump-array consumer reads. */ + for (int32_t row = 0; row < M - 2; ++row) { + const void *src = t_host + row * row_stride; + void *dst = (char *)host + (size_t)row * N * byte_width; + memcpy(dst, src, (size_t)(N - 2) * byte_width); + } +} + +/* Common body for the i8 / i16 shims. byte_width = 1 for i8, 2 for i16. */ +static void pva_conv2d_3x3_common(int byte_width, int32_t M, int32_t N, + const void *weights9, + const void *A, void *B) { + ensure_pva_init(); + + NVCVTensorRequirements imgReqs; + NVCVTensorHandle inT, outT, kernelT; + make_pva_image_tensor(M, N, byte_width, &imgReqs, &inT); + NVCV_CHECK(nvcvTensorConstruct(&imgReqs, g_pva_alloc, &outT)); + kernelT = make_pva_kernel_tensor_i8(byte_width, weights9); + + copy_host_to_tensor(inT, A, M, N, byte_width); + + NVCVOperatorHandle op = NULL; + NVCV_CHECK(pvaConv2dCreate(&op, &imgReqs, NVCV_BORDER_REPLICATE, 0, kernelT)); + NVCV_CHECK(pvaConv2dSubmit(op, g_pva_stream, inT, outT)); + CUDART_CHECK(cudaStreamSynchronize(g_pva_stream)); + + /* Pull output back to caller-provided B. The interior of B is what + * matches the polybench reference; outer border bytes are touched by + * PVA's REPLICATE border policy (the polybench reference leaves the + * outer rows/cols untouched, but the dump-array diff only looks at + * the interior so this matches well enough). */ + copy_tensor_to_host(B, outT, M, N, byte_width); + + nvcvTensorDecRef(inT, NULL); + nvcvTensorDecRef(outT, NULL); + nvcvTensorDecRef(kernelT, NULL); + nvcvOperatorDestroy(op); +} + +void polygeist_pva_conv2d_3x3_i8( + int32_t M, int32_t N, + int8_t w0, int8_t w1, int8_t w2, + int8_t w3, int8_t w4, int8_t w5, + int8_t w6, int8_t w7, int8_t w8, + const int8_t *A, int8_t *B) { + int8_t weights[9] = { w0, w1, w2, w3, w4, w5, w6, w7, w8 }; + pva_conv2d_3x3_common(/*byte_width=*/1, M, N, weights, A, B); +} + +void polygeist_pva_conv2d_3x3_i16( + int32_t M, int32_t N, + int16_t w0, int16_t w1, int16_t w2, + int16_t w3, int16_t w4, int16_t w5, + int16_t w6, int16_t w7, int16_t w8, + const int16_t *A, int16_t *B) { + int16_t weights[9] = { w0, w1, w2, w3, w4, w5, w6, w7, w8 }; + pva_conv2d_3x3_common(/*byte_width=*/2, M, N, weights, A, B); +} + +/* BoxFilter — same image-tensor setup as conv2d, but the operator has no + * coefficient tensor (PVA hardware applies an implicit 1/K² uniform + * weight). Only the borderMode + kernelSize differ in pvaBoxFilterCreate. */ +static void pva_boxfilter_3x3_common(int byte_width, int32_t M, int32_t N, + const void *A, void *B) { + ensure_pva_init(); + + NVCVTensorRequirements imgReqs; + NVCVTensorHandle inT, outT; + make_pva_image_tensor(M, N, byte_width, &imgReqs, &inT); + NVCV_CHECK(nvcvTensorConstruct(&imgReqs, g_pva_alloc, &outT)); + + copy_host_to_tensor(inT, A, M, N, byte_width); + + NVCVOperatorHandle op = NULL; + NVCV_CHECK(pvaBoxFilterCreate(&op, &imgReqs, /*kernelSize=*/3, + NVCV_BORDER_REPLICATE, 0)); + NVCV_CHECK(pvaBoxFilterSubmit(op, g_pva_stream, inT, outT)); + CUDART_CHECK(cudaStreamSynchronize(g_pva_stream)); + + copy_tensor_to_host(B, outT, M, N, byte_width); + + nvcvTensorDecRef(inT, NULL); + nvcvTensorDecRef(outT, NULL); + nvcvOperatorDestroy(op); +} + +void polygeist_pva_boxfilter_3x3_i8(int32_t M, int32_t N, + const int8_t *A, int8_t *B) { + pva_boxfilter_3x3_common(/*byte_width=*/1, M, N, A, B); +} + +void polygeist_pva_boxfilter_3x3_i16(int32_t M, int32_t N, + const int16_t *A, int16_t *B) { + pva_boxfilter_3x3_common(/*byte_width=*/2, M, N, A, B); +} + +/* GaussianFilter — sigma hardcoded to 1.0 for v0 (matcher would surface + * arbitrary sigma later). PVA computes the discrete Gaussian kernel + * internally from sigmaX/sigmaY/kernelSize; we just supply the params. */ +static void pva_gaussian_3x3_common(int byte_width, int32_t M, int32_t N, + const void *A, void *B) { + ensure_pva_init(); + + NVCVTensorRequirements imgReqs; + NVCVTensorHandle inT, outT; + make_pva_image_tensor(M, N, byte_width, &imgReqs, &inT); + NVCV_CHECK(nvcvTensorConstruct(&imgReqs, g_pva_alloc, &outT)); + + copy_host_to_tensor(inT, A, M, N, byte_width); + + NVCVOperatorHandle op = NULL; + NVCV_CHECK(pvaGaussianFilterCreate(&op, &imgReqs, /*sigmaX=*/1.0f, + /*sigmaY=*/1.0f, /*kernelSize=*/3, + NVCV_BORDER_REPLICATE, 0)); + NVCV_CHECK(pvaGaussianFilterSubmit(op, g_pva_stream, inT, outT)); + CUDART_CHECK(cudaStreamSynchronize(g_pva_stream)); + + copy_tensor_to_host(B, outT, M, N, byte_width); + + nvcvTensorDecRef(inT, NULL); + nvcvTensorDecRef(outT, NULL); + nvcvOperatorDestroy(op); +} + +void polygeist_pva_gaussian_3x3_i8(int32_t M, int32_t N, + const int8_t *A, int8_t *B) { + pva_gaussian_3x3_common(/*byte_width=*/1, M, N, A, B); +} + +void polygeist_pva_gaussian_3x3_i16(int32_t M, int32_t N, + const int16_t *A, int16_t *B) { + pva_gaussian_3x3_common(/*byte_width=*/2, M, N, A, B); +} + +/* BilateralFilter — sigmaRange and sigmaSpace hardcoded for v0. PVA's + * BilateralFilter only supports UNSIGNED 8-bit (per the doc); we + * reinterpret the caller's i8 bytes as u8 by allocating the PVA tensor + * with NVCV_DATA_TYPE_U8 (bitwise identical, same byte_width=1). For + * inputs in [0, 127] the math is identical to the signed view; for + * negative inputs the unsigned interpretation differs (e.g. -1 -> 255), + * which still produces deterministic PVA output but isn't a "signed + * bilateral filter" mathematically. */ +static void pva_bilateral_3x3_common(int byte_width, int32_t M, int32_t N, + const void *A, void *B) { + ensure_pva_init(); + + NVCVTensorRequirements imgReqs; + NVCVTensorHandle inT, outT; + NVCVDataType pvaDt = (byte_width == 1) ? NVCV_DATA_TYPE_U8 + : NVCV_DATA_TYPE_U16; + make_pva_image_tensor_dtype(M, N, pvaDt, &imgReqs, &inT); + NVCV_CHECK(nvcvTensorConstruct(&imgReqs, g_pva_alloc, &outT)); + + copy_host_to_tensor(inT, A, M, N, byte_width); + + NVCVOperatorHandle op = NULL; + NVCV_CHECK(pvaBilateralFilterCreate(&op, &imgReqs, /*kernelSize=*/3, + NVCV_BORDER_REPLICATE, 0)); + NVCV_CHECK(pvaBilateralFilterSubmit(op, g_pva_stream, inT, + /*sigmaRange=*/25.0f, + /*sigmaSpace=*/10.0f, outT)); + CUDART_CHECK(cudaStreamSynchronize(g_pva_stream)); + + copy_tensor_to_host(B, outT, M, N, byte_width); + + nvcvTensorDecRef(inT, NULL); + nvcvTensorDecRef(outT, NULL); + nvcvOperatorDestroy(op); +} + +void polygeist_pva_bilateral_3x3_i8(int32_t M, int32_t N, + const int8_t *A, int8_t *B) { + pva_bilateral_3x3_common(/*byte_width=*/1, M, N, A, B); +} + +void polygeist_pva_bilateral_3x3_i16(int32_t M, int32_t N, + const int16_t *A, int16_t *B) { + pva_bilateral_3x3_common(/*byte_width=*/2, M, N, A, B); +} + +void polygeist_pva_histeq_i8(int32_t M, int32_t N, + const int8_t *A, int8_t *B) { + ensure_pva_init(); + NVCVTensorRequirements imgReqs; + NVCVTensorHandle inT, outT; + make_pva_image_tensor_dtype(M, N, NVCV_DATA_TYPE_U8, &imgReqs, &inT); + NVCV_CHECK(nvcvTensorConstruct(&imgReqs, g_pva_alloc, &outT)); + copy_host_to_tensor(inT, A, M, N, 1); + + NVCVOperatorHandle op = NULL; + NVCV_CHECK(pvaHistogramEqualizationCreate(&op, &imgReqs)); + NVCV_CHECK(pvaHistogramEqualizationSubmit(op, g_pva_stream, inT, outT)); + CUDART_CHECK(cudaStreamSynchronize(g_pva_stream)); + + copy_tensor_to_host(B, outT, M, N, 1); + + nvcvTensorDecRef(inT, NULL); + nvcvTensorDecRef(outT, NULL); + nvcvOperatorDestroy(op); +} diff --git a/scripts/correctness/2mm_jetson_wrapper.c b/scripts/correctness/2mm_jetson_wrapper.c new file mode 100644 index 000000000000..36a6c46b1697 --- /dev/null +++ b/scripts/correctness/2mm_jetson_wrapper.c @@ -0,0 +1,42 @@ +/* 2mm_jetson_wrapper.c — Jetson timing wrapper for kernel_2mm. + * + * kernel_2mm signature (polybench/linear-algebra/kernels/2mm): + * void kernel_2mm(int ni, int nj, int nk, int nl, + * double alpha, double beta, + * double tmp[NI][NJ], double A[NI][NK], + * double B[NK][NJ], double C[NJ][NL], double D[NI][NL]); + * + * Bridges polybench's flat-pointer call to the MLIR-lowered impl which + * takes 5 memref args expanded to (ptr, ptr, offset, size×2, + * stride×2) — 7 args per matrix. + */ +#include +#include + +extern void kernel_2mm_impl( + int ni, int nj, int nk, int nl, + double alpha, double beta, + double *tmp_b, double *tmp_a, int64_t tmp_o, int64_t tmp_s0, int64_t tmp_s1, int64_t tmp_st0, int64_t tmp_st1, + double *A_b, double *A_a, int64_t A_o, int64_t A_s0, int64_t A_s1, int64_t A_st0, int64_t A_st1, + double *B_b, double *B_a, int64_t B_o, int64_t B_s0, int64_t B_s1, int64_t B_st0, int64_t B_st1, + double *C_b, double *C_a, int64_t C_o, int64_t C_s0, int64_t C_s1, int64_t C_st0, int64_t C_st1, + double *D_b, double *D_a, int64_t D_o, int64_t D_s0, int64_t D_s1, int64_t D_st0, int64_t D_st1); + +extern void polygeist_cublas_time_begin(void); +extern double polygeist_cublas_time_end_ms(void); + +void kernel_2mm(int ni, int nj, int nk, int nl, + double alpha, double beta, + double *tmp, double *A, double *B, + double *C, double *D) { + polygeist_cublas_time_begin(); + kernel_2mm_impl(ni, nj, nk, nl, alpha, beta, + tmp, tmp, 0, ni, nj, nj, 1, + A, A, 0, ni, nk, nk, 1, + B, B, 0, nk, nj, nj, 1, + C, C, 0, nj, nl, nl, 1, + D, D, 0, ni, nl, nl, 1); + double ms = polygeist_cublas_time_end_ms(); + fprintf(stderr, "POLYGEIST_TIMING: kernel_2mm ni=%d nj=%d nk=%d nl=%d %.3f ms\n", + ni, nj, nk, nl, ms); +} diff --git a/scripts/correctness/3mm_jetson_wrapper.c b/scripts/correctness/3mm_jetson_wrapper.c new file mode 100644 index 000000000000..cad9dfc7b0e0 --- /dev/null +++ b/scripts/correctness/3mm_jetson_wrapper.c @@ -0,0 +1,40 @@ +/* 3mm_jetson_wrapper.c — Jetson timing wrapper for kernel_3mm. + * + * kernel_3mm signature: + * void kernel_3mm(int ni, int nj, int nk, int nl, int nm, + * double E[NI][NJ], double A[NI][NK], double B[NK][NJ], + * double F[NJ][NL], double C[NJ][NM], double D[NM][NL], + * double G[NI][NL]); + */ +#include +#include + +extern void kernel_3mm_impl( + int ni, int nj, int nk, int nl, int nm, + double *E_b, double *E_a, int64_t E_o, int64_t E_s0, int64_t E_s1, int64_t E_st0, int64_t E_st1, + double *A_b, double *A_a, int64_t A_o, int64_t A_s0, int64_t A_s1, int64_t A_st0, int64_t A_st1, + double *B_b, double *B_a, int64_t B_o, int64_t B_s0, int64_t B_s1, int64_t B_st0, int64_t B_st1, + double *F_b, double *F_a, int64_t F_o, int64_t F_s0, int64_t F_s1, int64_t F_st0, int64_t F_st1, + double *C_b, double *C_a, int64_t C_o, int64_t C_s0, int64_t C_s1, int64_t C_st0, int64_t C_st1, + double *D_b, double *D_a, int64_t D_o, int64_t D_s0, int64_t D_s1, int64_t D_st0, int64_t D_st1, + double *G_b, double *G_a, int64_t G_o, int64_t G_s0, int64_t G_s1, int64_t G_st0, int64_t G_st1); + +extern void polygeist_cublas_time_begin(void); +extern double polygeist_cublas_time_end_ms(void); + +void kernel_3mm(int ni, int nj, int nk, int nl, int nm, + double *E, double *A, double *B, double *F, + double *C, double *D, double *G) { + polygeist_cublas_time_begin(); + kernel_3mm_impl(ni, nj, nk, nl, nm, + E, E, 0, ni, nj, nj, 1, + A, A, 0, ni, nk, nk, 1, + B, B, 0, nk, nj, nj, 1, + F, F, 0, nj, nl, nl, 1, + C, C, 0, nj, nm, nm, 1, + D, D, 0, nm, nl, nl, 1, + G, G, 0, ni, nl, nl, 1); + double ms = polygeist_cublas_time_end_ms(); + fprintf(stderr, "POLYGEIST_TIMING: kernel_3mm ni=%d nj=%d nk=%d nl=%d nm=%d %.3f ms\n", + ni, nj, nk, nl, nm, ms); +} diff --git a/scripts/correctness/RESULTS.md b/scripts/correctness/RESULTS.md new file mode 100644 index 000000000000..2498fb254ca6 --- /dev/null +++ b/scripts/correctness/RESULTS.md @@ -0,0 +1,438 @@ +# PolyBench end-to-end correctness — current status + +Last run: 2026-05-14. Pipeline = `cgeist` → `polygeist-opt --remove-iter-args --affine-parallelize --raise-affine-to-linalg-pipeline --lower-polygeist-submap [--linalg-debufferize]` → `mlir-opt` (standard MLIR lowering, with `--expand-strided-metadata`, `--lower-affine`, `--empty-tensor-to-alloc-tensor` on the debuf path) → `mlir-translate` → `clang` → run + diff against pure-`clang` reference. Dataset: `MINI_DATASET`. + +## Lowering smoke test (lower-polygeist-submap → mlir-opt to LLVM dialect) + +**26 / 30 kernels lower clean.** Up from 17 / 30 before broadcast support. + +Remaining 4: +- `adi` (10 ops): stencil shape rejected by Compose's iter-dim-coverage check (all operands drop the reduction dim). +- `seidel-2d` (9 ops): same. +- `durbin` (2 ops): reverse-index access `-d0 + s0 - 1`. Needs negative-stride subview support. +- `ludcmp` (1 op): similar to durbin. + +## Raise-only e2e (25 / 26 PASS) + +| Kernel | Result | +|---|---| +| gemm, syr2k, syrk, gesummv, gemver, symm, trmm | PASS | +| bicg, atax, mvt, 2mm, 3mm, doitgen | PASS | +| cholesky, gramschmidt, lu, trisolv | PASS | +| heat-3d, jacobi-1d, jacobi-2d, fdtd-2d | PASS | +| floyd-warshall, deriche, nussinov, covariance | PASS | +| **correlation** | **FAIL_DIFF** — raise-side bug (diagonal accumulation; the kernel sets `corr[i][i]=1.0` only once but our lowered linalg.generic accumulates the dot product over the diagonal too, producing `corr[i][i]=2.0`). Independent of the lowering pass — needs a fix in the raise pass to mask the diagonal. | + +## Raise + debufferize e2e (24 / 26 PASS) + +Same 24 pass through debuferize as well. + +Two fail: +- `correlation` — same diagonal bug as raise-only. +- `covariance` — new debuf-path failure: `LinalgDebufferize` produces a `linalg.generic` with mixed tensor/memref operands. Probably interaction with the new broadcast lowering. Needs separate investigation. + +## What changed today + +1. **Broadcast-shape lowering in `ComposeSubmapIntoLinalgGeneric`.** Extended the + per-base-dim decomposition to handle pure `SymbolExpr` and pure `ConstantExpr` + results — these become rank-reducing offsets in the emitted `memref.subview`. + The consumer linalg.generic's indexing_map for that operand drops the + corresponding view-dim(s). Unlocks covariance, durbin, cholesky, gramschmidt, + lu, ludcmp, trisolv, symm, doitgen, trmm in the smoke test. + +2. **Subview-for-offsets instead of compose-into-linalg.** When ANY operand + of a linalg has a non-zero offset (shifted stencil access, fixed-index + capture), emit a `memref.subview` for that operand AND for all other + operands so iter-dim bounds stay consistent. Composes only the + permutation part of the original submap map into the linalg's + indexing_map. Fixes heat-3d numerical bug. + +3. **`--expand-strided-metadata`** before standard lowering. Required to + handle the strided memref results from `memref.subview` in the + final-to-llvm stage. + +4. **`--lower-affine` + `--empty-tensor-to-alloc-tensor`** before + `--one-shot-bufferize` on the debuf path. Lifts `affine.for` with + tensor iter_args to `scf.for` (which one-shot-bufferize handles) and + converts `tensor.empty` from privatization to `bufferization.alloc_tensor`. + +## Running + +- Single kernel: `scripts/correctness/run_kernel_e2e.sh [--debuf]` +- All 26: `scripts/correctness/run_all_e2e.sh [--debuf]` +- Smoke-only: `scripts/correctness/lower_smoke_test.sh` + +## Jetson warmed raised runtime vs PolyBenchGPU CUDA + +Run date: 2026-05-28. Device: Jetson Orin. Datatype: double. Dimensions: +`N/NI/NJ/NK/NL/NM=512`. + +Method: 50 in-process iterations, discard first 10 warmups, then report a 10% +trimmed mean over the remaining 40 samples. Raised path uses +`POLYGEIST_RT_TIMING=1` runtime-shim device timings summed per benchmark +iteration. PolyBenchGPU path uses CUDA events around the handwritten kernel +sequence. This avoids counting cuBLAS first-use cold-start as steady-state +runtime. + +| Kernel | Raised rt-gpu ms | PolyBenchGPU CUDA ms | Result | +|---|---:|---:|---| +| gemm | 3.809 | 7.697 | raised 2.02x faster | +| 2mm | 7.640 | 11.200 | raised 1.47x faster | +| 3mm | 11.451 | 10.501 | PolyBenchGPU 1.09x faster | +| gesummv | 0.069 | 0.341 | raised 4.93x faster | +| gemver | 0.188 | 0.313 | raised 1.66x faster | + +Previous cold outer-harness comparison, kept for context only: + +| Kernel | Raised outer s | Raised rt-gpu s | PolyBenchGPU CUDA s | +|---|---:|---:|---:| +| gemm | 0.103025 | 0.033008 | 0.008401 | +| 2mm | 0.112321 | 0.036679 | 0.034213 | +| 3mm | 0.117875 | 0.040612 | 0.038889 | +| gesummv | 0.097759 | 0.032294 | 0.019568 | +| gemver | 0.100270 | 0.032451 | 0.031399 | + +## Darknet im2col + GEMM fused path + +Run date: 2026-05-29. Device: Jetson Orin. Fixture: +`third_party/cnn-extracted/darknet_im2col_gemm.c`, `MINI_DATASET` +(`IC=3`, `OC=4`, `H=W=8`, `K=3`, `stride=1`, `pad=1`). + +Progress saved: +- Raise pipeline lifts the guarded im2col workspace fill and the following + `i,k,j` GEMM. +- Kernel matcher recognizes the 3-step composition + `zero(output) + guarded im2col(workspace) + SGEMM(output)` and emits one + `kernel.launch @cudnnConvolutionFwd_im2col_gemm`. +- ABI lowering maps that launch to + `polygeist_cudnn_conv2d_im2col_gemm_f32`, avoiding materialized im2col. +- Host CPU shim matches the original C reference exactly. +- Jetson run exits 0. Output compare: 256 printed values, max absolute diff + `0.0001`, no values above `1.1e-3`. +- First-call Jetson timing from the fused path: + `POLYGEIST_RT_TIMING op=cudnnConv2d_im2col_gemm m=4 n=64 k=27 host_ms=26.356336 device_ms=15.357408`. + +## llama2.c RMSNorm and softmax lowering + +Run date: 2026-05-29. Device: Jetson Orin. Fixtures: +`third_party/cnn-extracted/llama2_rmsnorm.c` and +`third_party/cnn-extracted/llama2_softmax.c`, `N=128`. + +Progress saved: +- Matcher emits `kernel.launch @rmsnorm_f32(%x, %weight, %out)` for the + two-stage llama2 RMSNorm pattern. +- Matcher emits `kernel.launch @cudnnSoftmaxForward(%x)` for the three-stage + max / exp+sum / divide softmax pattern. +- ABI lowering maps RMSNorm to `polygeist_rmsnorm_f32` and softmax to + `polygeist_cudnn_softmax_forward_f32`. +- Host CPU-stub correctness is byte-exact for both fixtures versus plain + `gcc -O2` reference output. +- Jetson RMSNorm exits 0 through cuDNN backend graph + `CUDNN_RMS_NORM` / `CUDNN_NORM_FWD_INFERENCE` and is byte-exact versus the + aarch64 reference. Timing: + `POLYGEIST_RT_TIMING op=cudnnRmsNormForward m=1 n=128 k=0 host_ms=180.841512 device_ms=8.238944`. +- Jetson softmax exits 0 using `cudnnSoftmaxForward`. Output compare: + 128 values, max absolute diff `1.0e-8`, no values above `1.0e-6`. + Timing: `POLYGEIST_RT_TIMING op=cudnnSoftmaxForward m=1 n=128 k=0 host_ms=121.393178 device_ms=120.336578`. +- Caveat: the installed target has cuDNN's C backend graph API rather than the + C++ `cudnn_frontend` wrapper headers, so the runtime builds the graph with + `cudnnBackend*` descriptors directly. The graph path currently uses real + CUDA device allocations/copies; mapped host pointers hit + `CUDNN_STATUS_BAD_PARAM_MISALIGNED_POINTER` at execution time. + +## llama2 tiny forward tensor path + +Run date: 2026-05-30. Fixture: +`third_party/cnn-extracted/llama2_tiny_forward.c`, `N=16`, `H=16`. + +Progress saved: +- Debufferized tensor path now matches RMSNorm as + `kernel.launch @rmsnorm_f32_tensor`, zero-init as `@memset_zero_1D_f32`, + and GEMV as `@cublasSgemv`. +- ABI lowering emits three runtime calls: + `polygeist_rmsnorm_f32`, `polygeist_cublas_memset_zero_1d_f32`, and + `polygeist_cublas_sgemv`. +- Host CPU-stub output is byte-exact versus the native C reference. +- Jetson output matches native within `2.0e-08` max absolute difference. + Runtime timing confirmed RMSNorm + SGEMV dispatch: + `POLYGEIST_RT_TIMING op=host_rmsnorm_f32 ...` and + `POLYGEIST_RT_TIMING op=cublasSgemv m=16 n=16 ...`. +- Caveat: the whole-forward softmax tail remains residual tensor code in this + fixture because the max phase is still an `affine.for` + `scf.if`, not the + clean 3-step softmax linalg pattern. + +## llama2 larger forward tensor path + +Run date: 2026-05-31. Fixture: +`third_party/cnn-extracted/llama2_forward_bench.c`, default `N=1024`, `H=4096`; +Jetson run used `REPEAT=5` in one process. + +Progress saved: +- The default tensor path matches all four intended launches: + `@rmsnorm_f32_tensor`, `@memset_zero_1D_f32`, `@cublasSgemv`, and + `@cudnnSoftmaxForward_tensor`. +- Host CPU-stub output is byte-exact versus native C for the printed sample + and checksum. +- Jetson output matches native with max absolute diff `2.56e-06` over the + printed 32 values plus softmax checksum. +- Unlike the tiny `N=16` fixture, RMSNorm uses the cuDNN backend graph at + `N=1024` instead of falling back to the host path. +- Warm Jetson device timings after first-use setup: + `cudnnRmsNormForward` ~`0.09-0.10 ms`, `cublasSgemv` ~`0.53-0.55 ms`, + `cudnnSoftmaxForward` ~`0.028-0.030 ms`. + +## llama.cpp suffix comparison + +Run date: 2026-05-31. Device: Jetson Orin. Goal: apples-to-apples comparison +against the part of llama.cpp/ggml that corresponds to the C suffix we can +raise today. + +Workload compared: +`RMSNorm + scale + output projection GEMV -> logits` +with `N=2048`, `H=32000`, 5 warmup iterations, 30 measured iterations. +This is not a full `llama-bench` comparison. `llama-bench` measures whole +`llama_decode` to logits, while our C fixture only covers the final suffix. +Sampling softmax is also outside the `llama_decode` path, so the clean +comparison stops at logits rather than probabilities. + +Artifacts: +- ggml helper: `scripts/correctness/llama_suffix_ggml_bench.cpp`. +- ggml Jetson log: + `/tmp/llama_suffix_ggml_logits_n2048_h32000.log`. +- raised C Jetson log: + `/tmp/llama2_forward_bench_raised_n2048_h32000.log`. + +Measured warm numbers: +- ggml/llama.cpp CUDA logits suffix: median `1.494 ms`, trimmed mean + `1.494 ms`. +- Raised pipeline logits suffix, device-only: median `2.135 ms`, trimmed mean + `2.134 ms`. +- Raised pipeline logits suffix, host-visible: median `186.1 ms`, trimmed mean + `186.1 ms`. +- Device-only ratio: raised pipeline is about `1.43x` slower than ggml for + this suffix. + +Correctness sanity: +- ggml logits sample: + `0.06607100, 0.33554888, -0.36427033, 0.09345388`. +- Native C logits for the same initialization match to expected FP32 + tolerance. +- Full raised softmax checksum for the fixture is approximately `1.000001`. + +Slowness diagnosis: +- Host-visible time is dominated by RMSNorm setup. `cudnnRmsNormForward` + warm host median is `184.0 ms`, while its device median is only `0.093 ms`. + The runtime currently rebuilds cuDNN backend descriptors, engine config, + execution plan, variant pack, device allocations, input copies, output copy, + and descriptor cleanup on every call. +- Device time is mostly the output projection. Raised `cublasSgemv` warm + device median is `2.038 ms`, which is already slower than ggml's entire + RMSNorm+projection logits suffix at `1.494 ms`. +- ggml benefits from graph scheduling/CUDA graph reuse and a matvec-oriented + layout/kernel path. Our lowering emits separate runtime calls + (`RMSNorm`, zero-fill, SGEMV) and synchronizes each shim for timing/current + ABI behavior. + +Next runtime fixes, in priority order: +1. Cache cuDNN RMSNorm descriptors/plans/buffers, or replace RMSNorm with a + simple custom fused CUDA kernel for the Llama vector case. +2. Replace decode-style output `cublasSgemv` with a row-major custom matvec + kernel or a cuBLASLt matmul path tuned for `H x N` by `N`. +3. Drop explicit logits zero-fill when GEMV uses `beta=0`. +4. Avoid per-shim synchronization; run the suffix asynchronously on one stream + or capture it as a graph. + +RMSNorm cache update, 2026-06-01: +- Runtime change: `polygeist_rmsnorm_f32` now caches cuDNN backend descriptors, + execution plan, variant pack, workspace, and device buffers by `N` instead of + rebuilding them on every call. +- Rebuilt and reran the same `N=2048`, `H=32000`, `REPEAT=35` Jetson fixture. + Cached log: `/tmp/llama2_forward_bench_cached_rms_n2048_h32000.log`. +- First call still pays cuDNN plan creation (`cudnnRmsNormForward` host + `214.7 ms`), but warm calls reuse the plan. +- Warm RMSNorm host median dropped from `184.0 ms` to `0.052 ms`. +- Warm raised logits suffix host median dropped from `186.1 ms` to `1.652 ms`. +- Warm raised logits suffix device median in this rerun was `1.614 ms`. +- With the cached path, the remaining gap to ggml's `1.494 ms` logits suffix + is primarily the output projection path (`cublasSgemv` median `1.588 ms` in + this rerun) plus separate shim overhead, not cuDNN RMSNorm plan setup. + +Standalone Llama op sweep, 2026-06-01: +- Fixture source: `third_party/cnn-extracted/llama_forward_ops.c`. +- Timing harness: `third_party/cnn-extracted/llama_forward_ops_harness.c`. +- Build path: `scripts/correctness/polygeist_build.sh --target=jetson` + with one raised function per binary. +- Run setup: Jetson Orin, `REPEAT=50`, discard first 5 iterations, report warm + median/mean. Shapes are `MODEL_DIM=64`, `FFN_DIM=128`, `SEQ_LEN=32`, + `VOCAB=256`. +- All 17 matched standalone ops ran successfully. The interleaved RoPE and + branchy mask variants still do not raise; the split/branchless variants do. + +``` +op launch host_med_ms host_mean_ms dev_med_ms dev_mean_ms +token_embedding 1 0.0319 0.0322 0.0243 0.0245 +attention_rmsnorm 1 0.0652 0.0657 0.0471 0.0461 +qkv_projection 6 0.0687 0.0686 0.0446 0.0445 +rope_split 4 0.1486 0.1494 0.0969 0.0973 +kv_cache_rw 4 0.1244 0.1252 0.0908 0.0925 +attention_scores 2 0.0215 0.0221 0.0135 0.0141 +attention_mask_select 1 0.0422 0.0422 0.0275 0.0275 +attention_softmax 2 0.0552 0.0534 0.0384 0.0363 +attention_output 2 0.0208 0.0210 0.0128 0.0131 +output_projection 2 0.0252 0.0257 0.0157 0.0164 +residual_add 1 0.0440 0.0393 0.0361 0.0308 +ffn_rmsnorm 1 0.0652 0.0644 0.0465 0.0445 +gate_up_projection 4 0.0445 0.0451 0.0286 0.0286 +swiglu 1 0.0376 0.0376 0.0248 0.0248 +down_projection 2 0.0252 0.0259 0.0156 0.0161 +final_rmsnorm 1 0.0662 0.0654 0.0475 0.0455 +lm_head_projection 2 0.0246 0.0251 0.0156 0.0163 +``` + +- Approximate standalone-composed one-layer total: host median `0.8322 ms`, + device median `0.5750 ms`. +- Approximate `token_embedding + one layer + final_rmsnorm + lm_head` total: + host median `0.9548 ms`, device median `0.6623 ms`. + +Extended Llama exact ggml comparison, 2026-06-01: +- Added ggml helper: `scripts/correctness/llama_extended_ggml_bench.cpp`. +- It mirrors `third_party/cnn-extracted/llama2_extended_forward_bench.c`: + same f32 initialization, token `7`, position `16`, split Q/K RoPE, + KV-cache update/read, attention softmax, FFN, final RMSNorm, and lm-head. +- This is an exact comparison for the full extended fixture, not for a real + quantized GGUF/TinyLlama model. +- Native C printed logits/checksum: + `0.55907595, 1.64667618, 1.63461435, -1.32392168, -3.59120536, + 1.10384059, 1.95925152, 0.28402749, 3.77530479`. +- ggml CUDA cold one-iteration log: + `/tmp/llama_extended_ggml_cuda_exact.local.log`. +- ggml CUDA warmed log: + `/tmp/llama_extended_ggml_cuda_warm.local.log`. +- ggml CUDA output max absolute diff vs native printed values: + `8.46e-06`. +- ggml CUDA cold one-iteration host time: `72.725 ms`. +- ggml CUDA warm per-token/iteration host median: `0.098 ms` + (`5` warmup iterations, `30` measured iterations). +- Existing raised fixture first iteration from + `/tmp/llama2_extended_jetson_20260531_214105/timing.tsv`: + host sum `269.634 ms`, device sum `101.091 ms`. +- Warm raised fixture from the same run remains host median `0.719 ms`, + device median `0.447 ms` after discarding the first 5 iterations. +- Warm host-visible comparison for the exact fixture: + raised `0.719 ms` vs ggml CUDA `0.098 ms`, so raised is about `7.3x` + slower on this tiny one-token fixture. + +Llama 2 7B-size one-layer comparison, 2026-06-01: +- Same `extended_forward` fixture and same f32 math, but built with + `MODEL_DIM=4096`, `FFN_DIM=11008`, `VOCAB=32000`, `SEQ_LEN=2048`, + `NUM_HEADS=32`. +- This is *one token through one transformer layer plus final RMSNorm/lm_head*, + not the full 32-layer Llama 2 model and not a quantized GGUF path. +- Raised build: + `scripts/correctness/polygeist_build.sh --target=jetson + --function=kernel_llama2_extended_forward + third_party/cnn-extracted/llama2_extended_forward_bench.c + -DMODEL_DIM=4096 -DFFN_DIM=11008 -DVOCAB=32000 -DSEQ_LEN=2048 + -DNUM_HEADS=32 -DREPEAT=8 -DPRINT_ELEMS=4`. +- Raised log/artifacts: + `/tmp/llama2_7b_one_layer_20260531_232838/timing.tsv` and + `/tmp/llama2_7b_one_layer_20260531_232838/out.txt`. +- Raised warm timing after discarding the first 2 of 8 repeats: + host median `13.480 ms`, device median `12.273 ms`. +- Raised cold first iteration: + host `447.317 ms`, device `111.999 ms` (first-use CUDA/cuDNN/cuBLAS setup). +- ggml helper built with the same dimensions and run as + `./llama_extended_ggml_bench_7b --warmup 2 --iters 6`. +- ggml log: `/tmp/llama2_7b_one_layer_20260531_232838/ggml.log`. +- ggml CUDA warm host median: `9.638 ms`. +- Warm host-visible comparison at 7B-size one-layer: + raised `13.480 ms` vs ggml CUDA `9.638 ms`, so ggml is about `1.40x` + faster. The gap is much smaller than the toy-size fixture because real + GEMV work dominates fixed launch/setup overhead. +- Printed correctness check: + first four logits match raised vs ggml to printed precision + (`-66.40298462`, `12.98781776`, `34.77934265`, `55.23807144`). + The checksum differs by about `0.002` over `32000` logits. +- Largest raised warm device-time contributors after discarding the first two + repeats: + `cudaCopy_f32` cache materialization for `8388608` floats: `3.809 ms`; + `lm_head` SGEMV (`32000x4096`): `3.163 ms`; + FFN down/up/gate SGEMVs: about `1.09-1.13 ms` each. + +Stencil Conv2D sweep, 2026-06-01: +- Fixture source: `third_party/cnn-extracted/stencil_conv2d_3x3.c`. +- Bake path: `PYTHON=/usr/bin/python3 scripts/correctness/bake_stencil_conv2d_mlir.sh`. +- Default lowering target after debufferization: generalized packed-weight + `cudnnConvolution2D_ntap_tensor` for all odd-square 2D stencil convs + currently in this fixture set (`3x3`, `5x5`, `7x7`). Legacy memref + `9tap`/`25tap` entries remain available for explicit no-debufferize runs. + Jetson timing used `REPEAT=20` and discards the first 5 iterations. +- Current tensor validation: + all eight 3x3 forms, all seven 5x5 forms, and the `box7x7` proof fixture + raise to one loop-free tensor-form linalg.generic and match one + `cudnnConvolution2D_ntap_tensor` launch. +- Historical 5x5 validation: + the earlier memref `25tap` route passed host exact-output comparison and + Jetson cross-build for the seven 5x5 fixtures. Those artifacts remain useful + for no-debufferize testing, but the default bake summary now reports the + tensor ntap route from `_debuf.mlir`. +- Jetson execution path: + this VM -> `arjaiswal@10.176.207.72` -> `nvidia@192.168.55.1` + using `sshpass -p nvidia`. Full timing log: + `/tmp/stencil_5x5_jetson_suite_20260601_1700_full.log`. +- Tensor ntap validation: + all 16 stencil Conv2D fixtures now match from `_debuf.mlir` to one + `cudnnConvolution2D_ntap_tensor` launch. `box7x7` packs `W[49]` and lowers + through the fixed `(A, C, W, K)` runtime ABI. Host checksum comparison + against native C passed for `3x3`, `5x5`, and `7x7` spot checks. Jetson + tensor-path run used the same two-hop path above. + +``` +kernel match host checksum +box5x5 cudnnConvolution2D_ntap_tensor -0.02520496 +gaussian5x5 cudnnConvolution2D_ntap_tensor -0.48238885 +sobel_x5x5 cudnnConvolution2D_ntap_tensor 225.14816284 +sobel_y5x5 cudnnConvolution2D_ntap_tensor 12.86839104 +laplacian5x5 cudnnConvolution2D_ntap_tensor -17.16963387 +sharpen5x5 cudnnConvolution2D_ntap_tensor -2.78251743 +emboss5x5 cudnnConvolution2D_ntap_tensor 18.00988960 +box7x7 cudnnConvolution2D_ntap_tensor 0.03551064 +``` + +``` +kernel launch host_med_ms host_mean_ms dev_med_ms dev_mean_ms checksum +box3x3 1 0.4255 0.4264 0.0059 0.0059 -0.41999996 +gaussian3x3 1 0.4182 0.4203 0.0059 0.0059 -0.42000079 +sobel_x3x3 1 0.4247 0.4267 0.0059 0.0060 -5.88010693 +sobel_y3x3 1 0.4227 0.4224 0.0059 0.0059 4.11986542 +laplacian4_3x3 1 0.1663 0.1671 0.0417 0.0420 0.00000403 +laplacian8_3x3 1 0.1572 0.1604 0.0366 0.0383 -0.00000316 +sharpen3x3 1 0.1601 0.1618 0.0392 0.0410 -0.42001334 +emboss3x3 1 0.1625 0.1632 0.0399 0.0416 -1.74002242 +box5x5 1 0.4168 0.4208 0.0082 0.0084 -0.02519889 +gaussian5x5 1 0.1603 0.1618 0.0399 0.0408 -0.48238647 +sobel_x5x5 1 0.1552 0.1575 0.0400 0.0397 225.14791870 +sobel_y5x5 1 0.1564 0.1578 0.0369 0.0384 12.86828041 +laplacian5x5 1 0.1703 0.1766 0.0416 0.0425 -17.16963387 +sharpen5x5 1 0.1594 0.1592 0.0399 0.0393 -2.78251743 +emboss5x5 1 0.1620 0.1620 0.0403 0.0400 18.00988960 +box7x7 1 0.4332 0.4315 0.0109 0.0109 0.03551028 +``` + +## Known remaining bugs / next investigations + +1. *correlation FAIL_DIFF*: raise pass accumulates dot product over the + diagonal (which the C source sets to 1.0 explicitly and skips in its + off-diagonal computation). Needs a mask in the produced linalg.generic. + *Diagonal = 2.0 instead of 1.0.* + +2. *covariance debuf-path FAIL*: debuferize produces a linalg.generic with + mixed tensor and memref operands. + +3. *adi / seidel-2d lowering*: Compose's iter-dim-coverage check + correctly rejects (all operands drop the reduction dim). Real fix + needs raise to encode the iter-dim bound explicitly (or a different + representation). + +4. *durbin / ludcmp lowering*: reverse-indexed access (`-d0 + s0 - 1`). + Needs negative-stride subview support in the lowering. diff --git a/scripts/correctness/ata_gemm_jetson_harness.c b/scripts/correctness/ata_gemm_jetson_harness.c new file mode 100644 index 000000000000..2861c8a95370 --- /dev/null +++ b/scripts/correctness/ata_gemm_jetson_harness.c @@ -0,0 +1,66 @@ +/* Jetson harness for AᵀA via syrk-alias discriminator. */ +#include +#include +#include +#include + +#if defined(LARGE_DATASET) +# define M 2048 +# define K 2048 +#elif defined(MINI_DATASET) +# define M 64 +# define K 64 +#endif +#ifndef M +# define M 64 +#endif +#ifndef K +# define K 64 +#endif + +extern void kernel_ata_gemm_impl( + float *A_b, float *A_a, int64_t A_o, + int64_t A_s0, int64_t A_s1, int64_t A_t0, int64_t A_t1, + float *C_b, float *C_a, int64_t C_o, + int64_t C_s0, int64_t C_s1, int64_t C_t0, int64_t C_t1); + +extern void polygeist_cublas_time_begin(void); +extern double polygeist_cublas_time_end_ms(void); + +static void run_kernel(float *A, float *C) { + polygeist_cublas_time_begin(); + kernel_ata_gemm_impl( + A, A, 0, (int64_t)K, (int64_t)M, (int64_t)M, 1, + C, C, 0, (int64_t)M, (int64_t)M, (int64_t)M, 1); + double ms = polygeist_cublas_time_end_ms(); + fprintf(stderr, + "POLYGEIST_TIMING: ata_gemm M=%d K=%d %.3f ms\n", + M, K, ms); +} + +int main(void) { + size_t nA = (size_t)K * M; + size_t nC = (size_t)M * M; + float *A = (float *)malloc(nA * sizeof(float)); + float *C = (float *)malloc(nC * sizeof(float)); + if (!A || !C) { fprintf(stderr, "alloc failed\n"); return 1; } + + for (size_t k = 0; k < nA; ++k) + A[k] = (float)((k * 17) % 31) / 31.0f - 0.5f; + memset(C, 0, nC * sizeof(float)); + + run_kernel(A, C); + + double sum = 0; + for (size_t k = 0; k < nC; ++k) sum += C[k]; + fprintf(stderr, "CHECKSUM: %.6f over %zu elems\n", sum, nC); + fprintf(stderr, "==BEGIN DUMP_ARRAYS==\n"); + for (size_t k = 0; k < nC; ++k) { + if (k % 19 == 0) fprintf(stderr, "\n"); + fprintf(stderr, "%0.4f ", C[k]); + } + fprintf(stderr, "\n==END DUMP_ARRAYS==\n"); + + free(A); free(C); + return 0; +} diff --git a/scripts/correctness/atax_jetson_wrapper.c b/scripts/correctness/atax_jetson_wrapper.c new file mode 100644 index 000000000000..9ded542696cc --- /dev/null +++ b/scripts/correctness/atax_jetson_wrapper.c @@ -0,0 +1,38 @@ +/* atax_jetson_wrapper.c — Jetson timing wrapper. + * + * polybenchGpu kernel_atax computes: + * tmp = A·x (gemv) + * y = Aᵀ·tmp (gemv) + * + * Bridges polybenchGpu's kernel_atax(nx, ny, A, x, y, tmp) to the + * MLIR-lowered kernel_atax_impl with memref-descriptor args. Per-call + * timing on stderr. + */ +#include +#include + +extern void kernel_atax_impl( + int nx, int ny, + /* A: 2D memref */ + double *A_b, double *A_a, int64_t A_o, int64_t A_s0, int64_t A_s1, int64_t A_st0, int64_t A_st1, + /* x: 1D memref */ + double *x_b, double *x_a, int64_t x_o, int64_t x_s, int64_t x_st, + /* y: 1D memref */ + double *y_b, double *y_a, int64_t y_o, int64_t y_s, int64_t y_st, + /* tmp: 1D memref */ + double *t_b, double *t_a, int64_t t_o, int64_t t_s, int64_t t_st); + +extern void polygeist_cublas_time_begin(void); +extern double polygeist_cublas_time_end_ms(void); + +void kernel_atax(int nx, int ny, double *A, double *x, double *y, double *tmp) { + polygeist_cublas_time_begin(); + kernel_atax_impl(nx, ny, + A, A, 0, nx, ny, ny, 1, + x, x, 0, ny, 1, + y, y, 0, ny, 1, + tmp, tmp, 0, nx, 1); + double ms = polygeist_cublas_time_end_ms(); + fprintf(stderr, "POLYGEIST_TIMING: kernel_atax nx=%d ny=%d %.3f ms\n", + nx, ny, ms); +} diff --git a/scripts/correctness/aten_c_kernel_sweep.sh b/scripts/correctness/aten_c_kernel_sweep.sh new file mode 100755 index 000000000000..b2a82f05f68e --- /dev/null +++ b/scripts/correctness/aten_c_kernel_sweep.sh @@ -0,0 +1,102 @@ +#!/usr/bin/env bash +# Raise and match the complete standalone ATen C extraction corpus. +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$SCRIPT_DIR/common_env.sh" + +SRC_DIR="$REPO_ROOT/issues/aten_c_kernels" +OUT="${ATEN_C_SWEEP_OUT:-$SRC_DIR/results}" +CGEIST="$REPO_ROOT/build/bin/cgeist" +OPT="$REPO_ROOT/build/bin/polygeist-opt" +MATCHER="$SCRIPT_DIR/kernel_match_rewrite.py" +MATCH_PYTHON="${ATEN_C_MATCH_PYTHON:-/usr/bin/python3}" +RESOURCE_DIR="$($REPO_ROOT/llvm-project/build/bin/clang -print-resource-dir)" +mkdir -p "$OUT" + +printf 'kernel\tstatus\tlinalg_ops\tresidual_loops\tkernel_launches\tmatched_symbols\n' \ + > "$OUT/summary.tsv" + +sources=() +if (( $# )); then + for kernel in "$@"; do + kernel="${kernel%.c}" + [[ "$kernel" == aten_* ]] || kernel="aten_$kernel" + sources+=("$SRC_DIR/$kernel.c") + done +else + sources=("$SRC_DIR"/aten_*.c) +fi + +for src in "${sources[@]}"; do + if [[ ! -f "$src" ]]; then + printf 'missing ATen C fixture: %s\n' "$src" >&2 + exit 2 + fi + fn="$(basename "$src" .c)" + dir="$OUT/$fn" + mkdir -p "$dir" + + if ! timeout 60 "$CGEIST" "$src" --function="$fn" \ + --resource-dir="$RESOURCE_DIR" --raise-scf-to-affine -S \ + -o "$dir/orig.mlir" 2>"$dir/cgeist.err"; then + printf '%s\tfrontend_failed\t0\t0\t0\t-\n' "$fn" | tee -a "$OUT/summary.tsv" + continue + fi + + if ! timeout 60 "$OPT" --select-func="func-name=$fn" \ + --remove-iter-args --affine-parallelize \ + --raise-affine-to-linalg-pipeline --lower-polygeist-submap \ + "$dir/orig.mlir" -o "$dir/raised.mlir" 2>"$dir/raise.err"; then + printf '%s\traise_failed\t0\t0\t0\t-\n' "$fn" | tee -a "$OUT/summary.tsv" + continue + fi + + if ! timeout 15 "$OPT" --linalg-debufferize "$dir/raised.mlir" \ + -o "$dir/debuf.mlir" 2>"$dir/debuf.err"; then + # The default pass automatically selects joint-root conversion for + # cross-buffer linalg dataflow. Keep the forced mode as a diagnostic + # fallback for unusual cases that the automatic predicate did not cover. + if ! timeout 15 "$OPT" '--linalg-debufferize=use-multi-root' \ + "$dir/raised.mlir" -o "$dir/debuf.mlir" \ + 2>"$dir/debuf-multi-root.err"; then + # A small class of already-loop-free multi-output reductions causes the + # recursive walkers to revisit the same function without progress. The + # legacy local tensorizer handles these flat functions immediately. + if ! timeout 15 "$OPT" '--linalg-debufferize=use-recursive=false' \ + "$dir/raised.mlir" -o "$dir/debuf.mlir" \ + 2>"$dir/debuf-legacy.err"; then + printf '%s\tdebufferize_failed\t0\t0\t0\t-\n' "$fn" \ + | tee -a "$OUT/summary.tsv" + continue + fi + fi + fi + + if ! timeout 10 "$MATCH_PYTHON" "$MATCHER" "$dir/debuf.mlir" \ + >"$dir/matched.mlir" 2>"$dir/match.err"; then + printf '%s\tmatch_failed\t0\t0\t0\t-\n' "$fn" | tee -a "$OUT/summary.tsv" + continue + fi + + # Flat aliases consumed by build_ce_viewer.py. Keep the per-kernel + # directories above as the authoritative logs/artifacts. + cp "$dir/orig.mlir" "$OUT/$fn.mlir" + cp "$dir/raised.mlir" "$OUT/${fn}_linalg.mlir" + cp "$dir/debuf.mlir" "$OUT/${fn}_debuf.mlir" + + linalg_ops="$(rg -c 'linalg\.(generic|matmul|conv)' "$dir/raised.mlir" || true)" + residual_loops="$(rg -c '\b(affine|scf)\.(for|parallel|while)\b' \ + "$dir/raised.mlir" || true)" + launches="$(rg -c 'kernel\.launch ' "$dir/matched.mlir" || true)" + symbols="$({ rg -o 'kernel\.launch @[A-Za-z0-9_]+' \ + "$dir/matched.mlir" || true; } \ + | sed 's/kernel.launch @//' | sort -u | paste -sd, -)" + symbols="${symbols:--}" + + printf '%s\tpass\t%s\t%s\t%s\t%s\n' "$fn" "${linalg_ops:-0}" \ + "${residual_loops:-0}" "${launches:-0}" "$symbols" \ + | tee -a "$OUT/summary.tsv" +done + +printf 'Artifacts: %s\n' "$OUT" diff --git a/scripts/correctness/aten_completion_audit.py b/scripts/correctness/aten_completion_audit.py new file mode 100644 index 000000000000..7bd1701c62a0 --- /dev/null +++ b/scripts/correctness/aten_completion_audit.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +"""Fail unless the pinned ATen extraction/raising census is fully accounted.""" + +from __future__ import annotations + +import csv +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +CORPUS = ROOT / "issues/aten_c_kernels" + + +def rows(name: str, delimiter: str = ",") -> list[dict[str, str]]: + with (CORPUS / name).open(newline="") as stream: + return list(csv.DictReader(stream, delimiter=delimiter)) + + +def main() -> None: + sources = rows("extraction_inventory.csv") + operators = rows("operator_adjudication.csv") + dispatch = rows("dispatch_kernel_inventory.csv") + sweep = rows("results/summary.tsv", "\t") + cuda_audit = rows("cuda_library_audit.csv") + fixtures = sorted(path.stem for path in CORPUS.glob("aten_*.c")) + + assert len(sources) == 224, f"expected 224 source files, got {len(sources)}" + actionable_sources = [ + row for row in sources if row["classification"].startswith("EXTRACT_") + ] + assert not actionable_sources, f"unaccounted source files: {actionable_sources}" + needs_port = [row for row in operators if row["final_status"] == "NEEDS_PORT"] + assert not needs_port, f"unported operator bodies: {needs_port}" + remaining_dispatch = [row for row in dispatch if row["status"] == "PENDING"] + assert not remaining_dispatch, f"unported dispatch kernels: {remaining_dispatch}" + assert len(sweep) == len(fixtures), ( + f"sweep has {len(sweep)} rows for {len(fixtures)} fixtures" + ) + assert {row["kernel"] for row in sweep} == set(fixtures), ( + "sweep and standalone-C fixture names differ" + ) + assert len(cuda_audit) == len(fixtures), ( + f"CUDA-library audit has {len(cuda_audit)} rows for {len(fixtures)} fixtures" + ) + assert {row["kernel"] for row in cuda_audit} == set(fixtures), ( + "CUDA-library audit and standalone-C fixture names differ" + ) + assert all(row["rationale"] and row["compiler_gap"] for row in cuda_audit), ( + "CUDA-library audit contains an unadjudicated row" + ) + early_failures = [ + row for row in sweep + if row["status"] in {"frontend_failed", "raise_failed", "match_failed"} + ] + assert not early_failures, f"frontend/raise/matcher failures: {early_failures}" + + print( + f"complete: {len(sources)} sources, {len(operators)} named bodies, " + f"{len(dispatch)} dispatch registrations, {len(fixtures)} C fixtures" + ) + + +if __name__ == "__main__": + main() diff --git a/scripts/correctness/aten_cuda_library_audit.py b/scripts/correctness/aten_cuda_library_audit.py new file mode 100644 index 000000000000..8d757f4852de --- /dev/null +++ b/scripts/correctness/aten_cuda_library_audit.py @@ -0,0 +1,594 @@ +#!/usr/bin/env python3 +"""Classify every ATen fixture against existing NVIDIA CUDA-library APIs. + +This is deliberately conservative about *direct* matches. A fixed API is a +single public operation with the fixture's semantics. A generic primitive is +an existing NVIDIA implementation (cuTENSOR/cuDNN graph/CUB/Thrust) that needs +descriptor construction or template instantiation. A partial API covers only +stages of the fixture and therefore needs graph composition. +""" + +from __future__ import annotations + +import csv +import re +from pathlib import Path + +from build_ce_viewer import ATEN_C_PROVENANCE + +ROOT = Path(__file__).resolve().parents[2] +CORPUS = ROOT / "issues/aten_c_kernels" +SUMMARY = CORPUS / "results/summary.tsv" +OUTPUT = CORPUS / "cuda_library_audit.csv" +REPORT = CORPUS / "CUDA_LIBRARY_AUDIT.md" + +EVIDENCE = { + "cuBLAS": "https://docs.nvidia.com/cuda/cublas/", + "cuDNN": "https://docs.nvidia.com/deeplearning/cudnn/latest/operations/operations.html", + "cuDNN Resample": "https://docs.nvidia.com/deeplearning/cudnn/latest/operations/Resampling.html", + "cuDNN CTC": "https://docs.nvidia.com/deeplearning/cudnn/backend/latest/api/cudnn-adv-library.html", + "cuTENSOR": "https://docs.nvidia.com/cuda/cutensor/latest/api/cutensor.html", + "cuSPARSE": "https://docs.nvidia.com/cuda/cusparse/", + "cuSOLVER": "https://docs.nvidia.com/cuda/cusolver/contents.html", + "cuFFT": "https://docs.nvidia.com/cuda/cufft/contents.html", + "cuRAND": "https://docs.nvidia.com/cuda/curand/index.html", + "CUB": "https://nvidia.github.io/cccl/cub/api/device.html", + "Thrust": "https://nvidia.github.io/cccl/thrust/api/", + "NPP": "https://docs.nvidia.com/cuda/npp/index.html", + "CUDA Runtime": "https://docs.nvidia.com/cuda/cuda-runtime-api/", +} + + +def hit(pattern: str, text: str) -> bool: + return re.search(pattern, text) is not None + + +def classify(name: str, source: str, token: str) -> dict[str, str]: + n = name.removeprefix("aten_") + text = " ".join((n, token, Path(source).stem)).lower() + + def result(family: str, library: str, api: str, availability: str, + scope: str, rationale: str) -> dict[str, str]: + return { + "semantic_family": family, + "candidate_library": library, + "candidate_api": api, + "availability": availability, + "coverage_scope": scope, + "rationale": rationale, + "evidence_url": EVIDENCE.get(library, ""), + } + + # Exact and easily confused cases are kept ahead of the family rules. In + # particular, substring matching must not turn acos/acosh into cos, or an + # arbitrary helper containing "add" into a cuDNN ADD operation. + if "histogram" in n or "histogramdd" in n: + return result("histogram_count", "CUB", "DeviceHistogram", + "FULL_GENERIC_API", "whole", + "the extracted binning operation maps to a device histogram primitive") + if "sparse" in n and hit(r"(^|_)(mm|mv|bmm|spmm|addmm|addmv)(_|$)", n): + return result("sparse_linear_algebra", "cuSPARSE", "cusparseSpMV/SpMM/SpGEMM/SDDMM", + "FULL_FIXED_API", "whole", + "standard sparse-dense or sparse-sparse linear algebra") + if "fft_conjugate_symmetry" in n: + return result("complex_layout", "cuTENSOR", "permutation and conjugate pointwise operation", + "FULL_GENERIC_API", "whole", + "this is a symmetry-fill helper rather than an FFT execution") + if hit(r"(^|_)(blas_axpy|blas_scale|linear_combination|flatten_nd_linear)(_|$)", n): + return result("dense_vector_update", "cuBLAS", "cublasAxpy/cublasScal/cublasGemv", + "FULL_FIXED_API", "whole", + "the extracted loop is a standard BLAS vector update") + if hit(r"(^|_)(ctc_loss)(_|$)", n): + return result("ctc_loss", "cuDNN CTC", "cudnnCTCLoss_v8", + "FULL_FIXED_API", "whole", + "cuDNN has a public CTC loss API that computes costs and gradients") + if hit(r"(^|_)(argmax|argmin)(_|$)", n): + return result("arg_reduction", "CUB", "DeviceSegmentedReduce ArgMax/ArgMin", + "FULL_GENERIC_API", "whole", + "each row is a segment reduced to a value/index pair") + if "allany_dims" in n: + return result("boolean_reduction", "cuDNN", "pointwise cast plus MIN/MAX reduction graph", + "FULL_GENERIC_API", "whole", + "boolean all/any is a graph-expressible reduction over each row") + if "diff_cpu" in n: + return result("adjacent_difference", "CUB", "DeviceAdjacentDifference", + "FULL_GENERIC_API", "whole", + "CUB directly implements adjacent differences") + if n == "embedding" or "put_cpu" in n or "spdiags" in n: + return result("indexed_data_movement", "Thrust", "gather/scatter", + "FULL_GENERIC_API", "whole", + "the operation is an indirect gather or scatter") + if hit(r"nested_(clone|squeeze)_cpu", n): + return result("data_movement", "CUDA Runtime", "cudaMemcpyAsync or Thrust copy", + "FULL_GENERIC_API", "whole", + "the standalone operation copies or reinterprets nested storage metadata") + if hit(r"(^|_)(eq|ne|ge|gt|le|lt|fmax|fmin)(_|$)", n): + return result("pointwise", "cuDNN", "relational or MIN/MAX pointwise graph operation", + "FULL_GENERIC_API", "whole", + "cuDNN has fixed relational and elementwise min/max pointwise modes") + if "equal_cpu" in n: + return result("compare_and_reduce", "cuDNN", "EQ pointwise plus MIN reduction graph", + "FULL_GENERIC_API", "whole", + "tensor equality is elementwise comparison followed by an all reduction") + if hit(r"(^|_)(erf)(_|$)", n): + return result("pointwise", "cuDNN", "ERF pointwise graph operation", + "FULL_GENERIC_API", "whole", + "cuDNN exposes an ERF pointwise mode") + if hit(r"hardshrink|heaviside|huber_|mish|mse_|nan_to_num|shrink_backward|smooth_l1|softshrink|masked_scale", n): + return result("pointwise_formula", "cuDNN", "multi-node pointwise graph", + "FULL_GENERIC_API", "whole", + "the formula is composed entirely from supported arithmetic, comparison, selection, and activation nodes") + if hit(r"fused_(adagrad|adam|sgd)", n): + return result("optimizer_update", "cuDNN", "pointwise/reduction operation graph", + "PARTIAL_API", "update_stages", + "the arithmetic stages are graph-expressible, but optimizer state/step semantics require composition") + if hit(r"(^|_)cross(_|$)", n): + return result("cross_product", "cuDNN", "MUL/SUB pointwise operation graph", + "FULL_GENERIC_API", "whole", + "a 3-vector cross product is six multiplies and three subtracts in one operation graph") + if hit(r"gradient(_float)?_cpu", n): + return result("finite_difference", "CUB", "DeviceAdjacentDifference plus boundary transform", + "PARTIAL_API", "interior_and_boundary_stages", + "the adjacent-difference primitive covers a stage, while centered and boundary formulas require composition") + if "mode_cpu" in n: + return result("statistical_mode", "CUB", "DeviceRadixSort plus DeviceRunLengthEncode/Reduce", + "PARTIAL_API", "sort_and_count_stages", + "CUB supplies the sort and run counting stages but not one mode call with ATen tie/index semantics") + if "nansum" in n: + return result("nan_ignoring_reduction", "cuDNN", "ISNAN/selection plus ADD reduction graph", + "FULL_GENERIC_API", "whole", + "a pointwise NaN replacement followed by sum is graph-expressible") + if "quant_col_offsets" in n: + return result("column_reduction", "CUB", "DeviceSegmentedReduce", + "FULL_GENERIC_API", "whole", + "columns form regular reduction segments") + if "rowwise_prune" in n: + return result("reduce_and_compact", "CUB", "DeviceSegmentedReduce plus DeviceSelect", + "PARTIAL_API", "stages", + "row scoring and compaction exist as separate primitives") + if hit(r"flatten_indices|nested_to_mask|tril_indices|triu_indices|triu_mask|triu_tril_batch", n): + return result("index_generation", "cuDNN", "GEN_INDEX plus arithmetic/comparison graph", + "FULL_GENERIC_API", "whole", + "cuDNN can generate coordinates and form masks or flattened indices in an operation graph") + if "polar_scalarized" in n: + return result("complex_construction", "cuDNN", "SIN/COS/MUL pointwise graph", + "FULL_GENERIC_API", "whole", + "polar conversion is a supported pointwise operation graph") + if "transform_bias_rescale_qkv" in n: + return result("qkv_transform", "cuDNN", "pointwise plus reshape/transpose graph", + "FULL_GENERIC_API", "whole", + "bias, scaling, and regular QKV layout transforms are graph-expressible") + if "amp_update_scale" in n: + return result("conditional_scalar_update", "cuDNN", "comparison/BINARY_SELECT pointwise graph", + "FULL_GENERIC_API", "whole", + "the scale update is a small comparison-and-selection graph") + if hit(r"addcdiv|addcmul|addr_elementwise|angle_real|atanh|entr|erfcx?|frac|glu|hardsigmoid|hardswish|hardtanh|hypot|isneginf|isposinf|joint_scaling|ldexp|logaddexp|logit|powsum|quant_saturation|sinc|sinh|cosh|xlog", n): + return result("pointwise_reduction_formula", "cuDNN", "pointwise and reduction operation graph", + "FULL_GENERIC_API", "whole", + "the complete formula can be assembled from documented cuDNN graph nodes") + if "dropout_feature_noise" in n: + return result("dropout", "cuDNN", "Bernoulli RNG plus MUL pointwise graph", + "FULL_GENERIC_API", "whole", + "cuDNN graph RNG and pointwise nodes express feature dropout") + if "nested_matmul_broadcast" in n: + return result("batched_matrix_multiply", "cuBLAS", "cublasGemmStridedBatchedEx", + "FULL_FIXED_API", "whole", + "the right matrix is broadcast across a regular GEMM batch") + if "isin_default" in n: + return result("set_membership", "Thrust", "sort plus binary_search", + "FULL_GENERIC_API", "whole", + "Thrust implements the sort and vectorized membership search") + if "triu_tril_single" in n: + return result("triangular_mask", "cuDNN", "GEN_INDEX/comparison/BINARY_SELECT graph", + "FULL_GENERIC_API", "whole", + "generated row/column indices form the triangular selection predicate") + if "multinomial_with_replacement" in n: + return result("categorical_sampling", "CUB", "segmented scan plus Thrust upper_bound", + "PARTIAL_API", "stages", + "scan and search primitives exist, but sampling and batching require composition") + if "dyn_quant_matmul_4bit" in n: + return result("quantized_matrix_multiply", "cuBLAS", "cuBLASLt low-bit matmul plus scale/zero-point handling", + "PARTIAL_API", "matmul_stage", + "low-bit matmul exists, but this packed layout and per-column affine dequantization need validation/composition") + if "sparse" in n and "softmax" in n: + return result("sparse_softmax", "CUB", "segmented max/sum reductions plus pointwise transforms", + "PARTIAL_API", "stages", + "sparse rows can use segmented primitives, but there is no one sparse-softmax library call") + if "nested" in n and "softmax" in n: + return result("ragged_softmax", "CUB", "segmented max/sum reductions plus pointwise transforms", + "PARTIAL_API", "stages", + "ragged offsets define segments, but softmax needs a multi-stage composition") + if hit(r"convert_(coo|csr)|compressed_block_convert", n): + return result("sparse_format", "cuSPARSE", "cusparseXcoo2csr/csr2coo or conversion APIs", + "FULL_FIXED_API", "whole", + "cuSPARSE directly exposes standard sparse index/format conversions") + + # Dense BLAS and Einstein contractions. + if hit(r"(^|_)(addmm|mm|bmm|gemm|gemv|mv|dot|outer|ger|syrk|trmm|trsm)(_|$)", n): + api = "cuBLAS Level-1/2/3 or cuBLASLt Matmul" + return result("dense_linear_algebra", "cuBLAS", api, + "FULL_FIXED_API", "whole", + "standard vector/matrix product or update") + if hit(r"bilinear|trilinear|sumproduct|kron|contraction|tensor_product", n): + return result("tensor_contraction", "cuTENSOR", "cutensorCreateContraction", + "FULL_GENERIC_API", "whole", + "Einstein-style multiply/reduce with explicit modes") + if hit(r"matrix_power|(^|_)(eig|eigen|svd|cholesky|lu|qr)(_|$)|reflect_conj|unpack_pivots", text): + return result("matrix_factorization", "cuSOLVER", "cuSolverDN dense LAPACK APIs", + "PARTIAL_API", "stage", + "cuSOLVER covers the factorization/solve; helper-only fixtures need composition") + + # Convolution, pooling, attention, normalization and resampling. + if "im2col" in n or "columns" in n or "unfold" in n or "col2im" in n: + return result("patch_extract_scatter", "cuDNN", "Convolution graph operation", + "PARTIAL_API", "containing_operation", + "cuDNN implements convolution but does not expose im2col/col2im as its public result") + if hit(r"(^|_)(conv[123]d|conv_tbc|conv_transpose[123]d|convolution|depthwise_conv|dilated_convolution|slow_conv)", n): + return result("convolution", "cuDNN", "ConvolutionFwd/BwdData/BwdFilter", + "FULL_FIXED_API", "whole", + "standard, transposed, or dilated convolution maps to cuDNN convolution descriptors") + if "flash_attention" in n or "scaled_dot" in n or "attention" in n: + return result("attention", "cuDNN", "Fused Flash Attention graph", + "FULL_FIXED_API", "whole", + "cuDNN frontend exposes attention forward/backward graphs") + if hit(r"batch_norm|layer_norm|group_norm|rms_norm|weight_norm|renorm", n): + return result("normalization", "cuDNN", "NormalizationForward/Backward graph", + "FULL_GENERIC_API", "whole", + "cuDNN normalization and graph pointwise/reduction nodes cover the operation") + if "softmax" in n: + return result("softmax", "cuDNN", "Softmax or pointwise+reduction graph", + "FULL_FIXED_API", "whole", + "dense softmax is fixed-function; sparse/nested forms require layout composition") + if "fractional_max_pool" in n: + return result("fractional_pooling", "cuDNN Resample", "max-pooling plus generated window positions", + "PARTIAL_API", "fixed_window_reduction_stage", + "cuDNN has max pooling, but fractional sample-dependent window origins require composition") + if "max_unpool" in n: + return result("indexed_scatter", "Thrust", "fill plus scatter", + "FULL_GENERIC_API", "whole", + "unpooling is zero-fill followed by indexed scatter") + if "adaptive" in n and "pool" in n: + return result("adaptive_pooling", "cuDNN Resample", "average/max reduction over windows", + "PARTIAL_API", "regular_window_cases", + "cuDNN pooling uses fixed windows/strides; general adaptive pooling has output-dependent window boundaries") + if "pool" in n: + return result("pooling", "cuDNN Resample", "ResampleFwd/ResampleBwd", + "FULL_FIXED_API", "whole", + "cuDNN resample directly supports regular average/max pooling") + if hit(r"upsample|grid_sampler|resize|resample", n): + if "lanczos" in n or "grid_sampler" in n: + availability = "PARTIAL_API" if "backward" in n else "FULL_GENERIC_API" + return result("resampling", "NPP", "nppiResize/nppiRemap", + availability, "whole_or_forward_stage", + "NPP provides 2D resize/remap interpolation, but does not expose the matching backward operator") + return result("resampling", "cuDNN Resample", "ResampleFwd/ResampleBwd", + "FULL_FIXED_API", "whole", + "cuDNN resample supports nearest, bilinear, and cubic modes") + + # Sparse linear algebra and sparse format manipulation. + if hit(r"sparse.*(mm|mv|bmm|spmm|addmv)|(^|_)spmm|sspaddmm|hspmm", n): + return result("sparse_linear_algebra", "cuSPARSE", "cusparseSpMV/SpMM/SpGEMM/SDDMM", + "FULL_FIXED_API", "whole", + "standard sparse-dense or sparse-sparse linear algebra") + if "sparse" in n or hit(r"coo|csr|bsr|compressed|coalesce", n): + if hit(r"convert|csr_to_coo|coo_to_csr|sort|coalesce|flatten_indices", n): + return result("sparse_format", "cuSPARSE", "format conversion and sorting APIs", + "FULL_GENERIC_API", "whole", + "cuSPARSE exposes sparse format conversion/sorting primitives") + if hit(r"reduce|sum|norm", n): + return result("sparse_reduction", "CUB", "DeviceSegmentedReduce", + "FULL_GENERIC_API", "whole", + "CSR/COO offsets define segments for a library segmented reduction") + return result("sparse_indexed_elementwise", "cuSPARSE", "SpVec/SpMat plus generic operation", + "PARTIAL_API", "stage", + "descriptor/storage handling exists, but arbitrary indexed elementwise semantics need composition") + + # Random-number generation. Transforms not offered by cuRAND are partial. + if hit(r"uniform|normal_cpu|log_normal|poisson|sobol", n): + return result("random_generation", "cuRAND", "host/device generation APIs", + "FULL_FIXED_API", "whole", + "cuRAND directly provides uniform, normal, log-normal, Poisson, and Sobol generation") + if hit(r"bernoulli|binomial|gamma|dirichlet|cauchy|exponential|geometric|random|randperm", n): + return result("random_distribution", "cuRAND", "base RNG plus distribution transform", + "PARTIAL_API", "random_draw_stage", + "cuRAND supplies random bits/uniform/normal draws but not this complete transform in its host API") + + # FFTs and spectral rearrangement. + if hit(r"(^|_)(fft|dft)(_|$)", n): + return result("fourier_transform", "cuFFT", "cufftExec* and PlanMany", + "FULL_FIXED_API", "whole", + "cuFFT directly supports batched 1D/2D/3D real and complex transforms") + if hit(r"fftshift|conjugate_symmetry|as_complex|complex_scalarized|conj_complex", n): + return result("complex_layout", "cuTENSOR", "permutation or elementwise conjugate", + "FULL_GENERIC_API", "whole", + "cuTENSOR supports permutation and conjugate unary operators") + + # Device-wide algorithms: sort/select/scan/reduce/histogram/indexing. + if hit(r"cumsum|cumprod|cummax|cummin|scan|prefix|batch_offsets", n): + return result("scan", "CUB", "DeviceScan or DeviceSegmentedScan", + "FULL_GENERIC_API", "whole", + "device-wide inclusive/exclusive and segmented scans are implemented") + if hit(r"sort|topk|kth|median|quick_select|unique", n): + return result("ordering_selection", "CUB", "DeviceRadixSort/MergeSort/TopK/Select/RunLengthEncode", + "FULL_GENERIC_API", "whole", + "CUB provides device-wide ordering and selection primitives") + if hit(r"hist|bincount|count_nonzero", n): + return result("histogram_count", "CUB", "DeviceHistogram/DeviceReduce", + "FULL_GENERIC_API", "whole", + "histogram/count operations map to device-wide primitives") + if hit(r"searchsorted|lower_bound|upper_bound|binary_search", n): + return result("search", "Thrust", "lower_bound/upper_bound/binary_search", + "FULL_GENERIC_API", "whole", + "Thrust exposes device execution-policy binary searches") + if hit(r"index|gather|scatter|take|masked_select|masked_scatter|nonzero|where", n): + if hit(r"reduce|backward|add", n): + return result("indexed_scatter_reduce", "CUB", "sort/reduce-by-key plus scatter", + "PARTIAL_API", "stages", + "collision-aware scatter needs ordering/reduction composition") + return result("indexed_data_movement", "Thrust", "gather/scatter/copy_if", + "FULL_GENERIC_API", "whole", + "Thrust provides indirect gather, scatter, and predicate compaction") + if hit(r"segment_reduce|segmented|embedding_bag", n): + return result("segmented_reduction", "CUB", "DeviceSegmentedReduce", + "FULL_GENERIC_API", "whole", + "offset/length arrays define device-wide reduction segments") + if hit(r"reduce|(^|_)(sum|mean|prod|all|any|min|max|aminmax|std_var|trace|norm)(_|$)", n): + if hit(r"std|mean|norm|dot", n): + return result("reduction", "NPP", "signal statistics/norm APIs", + "FULL_FIXED_API", "whole", + "NPP exposes mean, standard deviation, norm, dot, min/max, and sum operations") + return result("reduction", "CUB", "DeviceReduce or DeviceSegmentedReduce", + "FULL_GENERIC_API", "whole", + "associative tensor reduction maps to a device-wide primitive") + + # Data movement and tensor layouts. + if hit(r"copy|cat|stack|split|unbind|repeat|tile|pad|shuffle|transpose|permute|flip|narrow|select|block_diag|cartesian|combinations", n): + if hit(r"transpose|permute|shuffle|repeat|tile|narrow", n): + return result("tensor_permutation", "cuTENSOR", "cutensorPermute", + "FULL_GENERIC_API", "whole", + "mode permutation/broadcast covers regular affine layouts") + if hit(r"flip|reverse", n): + return result("reverse", "Thrust", "reverse/reverse_copy", + "FULL_GENERIC_API", "whole", + "Thrust implements device-wide reversal") + if "pad" in n: + return result("padding", "NPP", "copy-border/image geometry primitives", + "PARTIAL_API", "mode_dependent", + "constant/image borders exist; circular/reflection and arbitrary rank need composition") + return result("data_movement", "CUDA Runtime", "cudaMemcpy* or Thrust copy/fill", + "FULL_GENERIC_API", "whole", + "contiguous copies are fixed runtime calls; structured concatenation needs multiple copies") + + # Initializers and sequences. + if hit(r"fill|zeros|eye|arange|range_out|linspace|logspace|sequence", n): + return result("tensor_initialization", "Thrust", "fill/sequence/transform", + "FULL_GENERIC_API", "whole", + "device-wide fill and sequence generation are implemented") + + # Fixed pointwise modes and NPP signal routines. + if hit(r"(^|_)(abs|sqrt|square|exp|exp2|expm1|log|log2|log10|log1p|add|sub|mul|div|remainder|fmod|clamp|threshold|relu|gelu|sigmoid|tanh|silu|swish|softplus|elu|logical|copysign|minimum|maximum|lerp|reciprocal|rsqrt|ceil|floor|round|trunc|neg|sign|signbit|pow)(_|$)", n): + return result("pointwise", "cuDNN", "Pointwise graph operation", + "FULL_GENERIC_API", "whole", + "cuDNN exposes a broad fixed set of unary/binary/ternary pointwise modes") + if hit(r"(^|_)(sin|cos|tan|cbrt|atan|atan2)(_|$)", n): + return result("pointwise_math", "NPP", "signal arithmetic/transcendental API", + "FULL_FIXED_API", "whole", + "NPP provides fixed signal math routines for supported dtypes") + if hit(r"bitwise|xor|and_reduce|or_reduce|lshift|rshift", n): + return result("integer_pointwise", "NPP", "signal logical/shift API", + "FULL_FIXED_API", "whole", + "NPP exposes fixed integer logical and constant-shift signal routines") + + # Losses and multi-stage numerical formulas generally need graph assembly. + if hit(r"loss|margin", n): + return result("loss", "cuDNN", "pointwise+reduction graph", + "PARTIAL_API", "stages", + "primitive nodes exist but there is no matching single public loss operation") + if hit(r"distance|pdist|cdist", n): + return result("distance", "cuTENSOR", "contraction/reduction plus pointwise graph", + "PARTIAL_API", "stages", + "dot/reduction stages exist but distance requires composition and indexing") + + # Remaining special functions generally have libdevice scalar routines, + # but no fixed host-callable tensor library operation. + if hit(r"bessel|chebyshev|hermite|laguerre|legendre|zeta|digamma|trigamma|polygamma|erfc|gamm|airy|spherical|xlog|entr|i0|i1|ndtri", n): + return result("special_function", "", "CUDA Math/libdevice scalar function", + "NO_DIRECT_LIBRARY_API", "scalar_only", + "a device scalar function may exist, but not a fixed tensor-library launch") + + return result("compound_or_specialized", "", "none identified", + "NO_DIRECT_LIBRARY_API", "none", + "no semantically equivalent public NVIDIA tensor-library operation identified") + + +def local_backend_status(name: str, audit: dict[str, str]) -> str: + """Describe whether this repository can already emit the candidate API.""" + family = audit["semantic_family"] + library = audit["candidate_library"] + if library == "cuBLAS" and name in { + "aten_addmm", "aten_blas_dot_naive_cpu", "aten_bf16_dot_cpu", + "aten_dot", "aten_fp16_dot_cpu", "aten_mm", "aten_mv", + "aten_blas_gemv_generic_cpu", "aten_linear_combination_cpu", + "aten_nested_matmul_broadcast_cpu", "aten_outer", + }: + return "SELECTED_WRAPPERS_PRESENT" + if library == "cuDNN" and name in { + "aten_conv2d", "aten_conv3d", "aten_slow_conv3d_forward_cpu", + "aten_softmax", + }: + return "SELECTED_WRAPPERS_PRESENT" + if library == "cuDNN" and family == "normalization" and name in { + "aten_batch_norm", "aten_batch_norm_cpu_entry", "aten_rms_norm" + }: + return "SELECTED_WRAPPERS_PRESENT" + if library == "cuDNN Resample" and family == "pooling" and "max_pool" in name: + return "SELECTED_WRAPPERS_PRESENT" + if library == "cuFFT" and family == "fourier_transform": + return "SELECTED_WRAPPERS_PRESENT" + if library == "cuDNN" and "graph" in audit["candidate_api"].lower(): + return "GENERAL_GRAPH_BACKEND_ABSENT" + if not library: + return "NO_TENSOR_LIBRARY_API" + return "API_BACKEND_ABSENT" + + +def implementation_form(audit: dict[str, str]) -> str: + availability = audit["availability"] + api = audit["candidate_api"].lower() + if availability == "FULL_FIXED_API": + return "SINGLE_FIXED_CALL" + if availability == "NO_DIRECT_LIBRARY_API": + return "NONE" + if availability == "PARTIAL_API": + return "PARTIAL_STAGES" + if ("graph" in api or " plus " in api or " or thrust" in api or + audit["semantic_family"] in { + "data_movement", "set_membership", "indexed_scatter", + "max_unpool", "compare_and_reduce" + }): + return "MULTI_NODE_LIBRARY_GRAPH" + return "SINGLE_CONFIGURED_PRIMITIVE" + + +def diagnose(row: dict[str, str], audit: dict[str, str], + current_scope: str) -> str: + if current_scope == "COMPLETE_REWRITE_CANDIDATE": + return "ALREADY_FOUND" + if current_scope == "PARTIAL_STAGE_ONLY": + return "PARTIAL_MATCH_ONLY_RESIDUAL_IR_REMAINS" + if row["status"] == "debufferize_failed": + return "FRONTEND_BLOCKS_MATCHER" + if int(row["residual_loops"]): + return "RAISING_BLOCKS_WHOLE_OP_RECOGNITION" + if audit["availability"] == "NO_DIRECT_LIBRARY_API": + return "NO_LIBRARY_MATCH_EXPECTED" + if audit["availability"] == "PARTIAL_API": + return "COMPOSITION_REQUIRED_NOT_MATCHER_ONLY" + if local_backend_status(row["kernel"], audit) == "SELECTED_WRAPPERS_PRESENT": + return "MATCHER_COVERAGE_GAP" + return "BACKEND_AND_MATCHER_GAP" + + +def main() -> None: + with SUMMARY.open(newline="") as stream: + summary = list(csv.DictReader(stream, delimiter="\t")) + output = [] + for row in summary: + source, token = ATEN_C_PROVENANCE[row["kernel"]] + audit = classify(row["kernel"], source, token) + launches = int(row["kernel_launches"]) + current = row["matched_symbols"] if row["matched_symbols"] != "-" else "" + matched_path = CORPUS / "results" / row["kernel"] / "matched.mlir" + matched_text = matched_path.read_text() if matched_path.exists() else "" + remaining_linalg = len(re.findall(r"\blinalg\.(?:generic|matmul|conv)", matched_text)) + remaining_loops = len(re.findall( + r"\b(?:affine|scf)\.(?:for|parallel|while)\b", matched_text)) + if not launches: + current_scope = "NONE" + elif remaining_linalg or remaining_loops: + current_scope = "PARTIAL_STAGE_ONLY" + else: + current_scope = "COMPLETE_REWRITE_CANDIDATE" + gap = diagnose(row, audit, current_scope) + output.append({ + "kernel": row["kernel"], "source": source, "source_token": token, + "pipeline_status": row["status"], "linalg_ops": row["linalg_ops"], + "residual_loops": row["residual_loops"], + "current_match": current, + "current_match_scope": current_scope, + "remaining_linalg_after_match": remaining_linalg, + "remaining_loops_after_match": remaining_loops, + **audit, + "implementation_form": implementation_form(audit), + "local_backend_status": local_backend_status(row["kernel"], audit), + "compiler_gap": gap, + }) + fields = list(output[0]) + with OUTPUT.open("w", newline="") as stream: + writer = csv.DictWriter(stream, fieldnames=fields) + writer.writeheader(); writer.writerows(output) + from collections import Counter + availability = Counter(row["availability"] for row in output) + forms = Counter(row["implementation_form"] for row in output) + scopes = Counter(row["current_match_scope"] for row in output) + gaps = Counter(row["compiler_gap"] for row in output) + libraries = Counter(row["candidate_library"] or "none" for row in output) + matcher_only = [ + row["kernel"] for row in output + if row["compiler_gap"] == "MATCHER_COVERAGE_GAP" + ] + report = [ + "# Exhaustive ATen CUDA-library audit", + "", + "This audit adjudicates every provenance-linked standalone ATen C " + "fixture against public NVIDIA libraries. It separately records whether " + "the current rewrite covers the complete function or only an initialization/" + "copy stage. The machine-readable CSV is the authoritative per-kernel list.", + "", + f"- Fixtures reviewed: {len(output)}", + f"- Complete current rewrite candidates: {scopes['COMPLETE_REWRITE_CANDIDATE']}", + f"- Partial stage-only current matches: {scopes['PARTIAL_STAGE_ONLY']}", + f"- No current launch: {scopes['NONE']}", + "", + "## What exists in NVIDIA libraries", + "", + f"- One fixed public call: {forms['SINGLE_FIXED_CALL']}", + f"- One configurable generic primitive: {forms['SINGLE_CONFIGURED_PRIMITIVE']}", + f"- Complete multi-node library graph/composition: {forms['MULTI_NODE_LIBRARY_GRAPH']}", + f"- Only some stages have library primitives: {forms['PARTIAL_STAGES']}", + f"- No direct tensor-library implementation: {forms['NONE']}", + "", + "A CUB or Thrust result means NVIDIA ships the generic device algorithm; " + "it is not a stable host C ABI and would require a new template-backed " + "runtime wrapper. A cuDNN graph result requires graph construction/lowering. " + "Neither should be described as merely a missing Egglog pattern.", + "", + "## Compiler diagnosis", + "", + ] + report.extend( + f"- `{key}`: {value}" for key, value in sorted(gaps.items()) + ) + report.extend([ + "", + "Only the `MATCHER_COVERAGE_GAP` rows are clean, whole-operation cases " + "for which a selected runtime-wrapper family is already present locally. " + "The remaining positive library candidates need raising work, a new API " + "backend, graph composition, or some combination.", + "", + "## Clean matcher-coverage candidates", + "", + ]) + report.extend(f"- `{name}`" for name in matcher_only) + report.extend([ + "", + "## Candidate-library census", + "", + ]) + report.extend( + f"- {library}: {count}" for library, count in libraries.most_common() + ) + report.extend([ + "", + "## Per-kernel results", + "", + "See [`cuda_library_audit.csv`](cuda_library_audit.csv). Every row includes " + "the source provenance, current matcher scope, semantic family, candidate " + "library/API, whole/partial availability, evidence URL, local backend status, " + "and the precise compiler gap. The same fields are rendered on the paginated " + "ATen Compiler Explorer pages.", + "", + "## Official capability sources", + "", + ]) + for library, url in EVIDENCE.items(): + report.append(f"- [{library}]({url})") + REPORT.write_text("\n".join(report) + "\n") + print(f"wrote {len(output)} rows to {OUTPUT}") + print(f"wrote summary to {REPORT}") + print("availability", dict(availability)) + print("gap", dict(gaps)) + + +if __name__ == "__main__": + main() diff --git a/scripts/correctness/aten_dispatch_inventory.py b/scripts/correctness/aten_dispatch_inventory.py new file mode 100644 index 000000000000..9babb03ed862 --- /dev/null +++ b/scripts/correctness/aten_dispatch_inventory.py @@ -0,0 +1,103 @@ +#!/usr/bin/env python3 +"""Inventory concrete CPU dispatch kernels in the pinned 224-file census.""" + +from __future__ import annotations + +import argparse +import csv +import re +from pathlib import Path + +from aten_extraction_inventory import DEFAULT_PYTORCH, DEFAULT_SOURCES, ROOT + + +DEFAULT_OUTPUT = ROOT / "issues/aten_c_kernels/dispatch_kernel_inventory.csv" + +REGISTER_RE = re.compile( + r"(?:REGISTER_DISPATCH|ALSO_REGISTER_AVX512_DISPATCH)\s*\(\s*" + r"(?P[A-Za-z_]\w*)\s*,\s*" + r"(?:&(?:(?:CPU_CAPABILITY|DEFAULT)::)?)?" + r"(?P[A-Za-z_]\w*)", + re.DOTALL, +) +UNARY_MACRO_RE = re.compile( + r"^(?:STATIC_)?IMPLEMENT_(?:FLOAT|COMPLEX)_KERNEL_" + r"(?:WITH|WITHOUT)_AVX512\((?P\w+)\)", + re.MULTILINE, +) + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--sources", type=Path, default=DEFAULT_SOURCES) + parser.add_argument("--pytorch", type=Path, default=DEFAULT_PYTORCH) + parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT) + args = parser.parse_args() + + from build_ce_viewer import ATEN_C_PROVENANCE + + provenance: dict[str, list[tuple[str, str]]] = {} + for kernel, (source, token) in ATEN_C_PROVENANCE.items(): + provenance.setdefault(source, []).append((kernel, token or "")) + + rows: list[dict[str, object]] = [] + seen: set[tuple[str, str]] = set() + for source in filter(None, map(str.strip, args.sources.read_text().splitlines())): + text = (args.pytorch / source).read_text(errors="replace") + targets: list[tuple[str, str, int]] = [] + for match in REGISTER_RE.finditer(text): + targets.append( + ( + match.group("stub"), + match.group("impl"), + text.count("\n", 0, match.start()) + 1, + ) + ) + for match in UNARY_MACRO_RE.finditer(text): + op = match.group("op") + targets.append( + (f"{op}_stub", f"{op}_kernel", text.count("\n", 0, match.start()) + 1) + ) + for stub, implementation, line in targets: + identity = (source, stub) + if identity in seen: + continue + seen.add(identity) + fixtures = [ + kernel + for kernel, token in provenance.get(source, []) + if token and ( + token == implementation + or implementation in token + or token in implementation + ) + ] + rows.append( + { + "source": source, + "stub": stub, + "implementation": implementation, + "line": line, + "fixtures": ",".join(sorted(fixtures)), + "status": ( + "NO_IMPLEMENTATION" + if implementation == "nullptr" + else ("EXTRACTED" if fixtures else "NEEDS_EXTRACTION") + ), + } + ) + + args.output.parent.mkdir(parents=True, exist_ok=True) + fields = ("source", "stub", "implementation", "line", "fixtures", "status") + with args.output.open("w", newline="") as stream: + writer = csv.DictWriter(stream, fieldnames=fields) + writer.writeheader() + writer.writerows(rows) + print(f"wrote {len(rows)} concrete dispatch kernels to {args.output}") + print(f"extracted: {sum(row['status'] == 'EXTRACTED' for row in rows)}") + print(f"no registered CPU implementation: {sum(row['status'] == 'NO_IMPLEMENTATION' for row in rows)}") + print(f"remaining: {sum(row['status'] == 'NEEDS_EXTRACTION' for row in rows)}") + + +if __name__ == "__main__": + main() diff --git a/scripts/correctness/aten_extraction_inventory.py b/scripts/correctness/aten_extraction_inventory.py new file mode 100644 index 000000000000..069343d9eb7d --- /dev/null +++ b/scripts/correctness/aten_extraction_inventory.py @@ -0,0 +1,157 @@ +#!/usr/bin/env python3 +"""Account for every translation unit in the pinned portable ATen census. + +This is deliberately a source-file inventory, not an operator count. One +translation unit may contain no numerical body, one loop kernel, or dozens of +TensorIterator scalar lambdas. Existing standalone-C fixtures are linked by +the provenance table in build_ce_viewer.py. +""" + +from __future__ import annotations + +import argparse +import csv +import re +from collections import defaultdict +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +DEFAULT_SOURCES = ( + ROOT / "notes/polygeist_raise_to_linalg/aten_raise_sweep_2026_07_21/sources.txt" +) +DEFAULT_PYTORCH = ROOT / "third_party/pytorch" +DEFAULT_OUTPUT = ROOT / "issues/aten_c_kernels/extraction_inventory.csv" +OPERATOR_ADJUDICATION = ROOT / "issues/aten_c_kernels/operator_adjudication.csv" +GENERATED_PROVENANCE_GLOB = "generated*_provenance.csv" +SOURCE_ACCOUNTING = { + "aten/src/ATen/native/AdaptiveMaxPooling2d.cpp": + "loop validates non-batch output dimensions; arithmetic dispatches to a registered kernel", + "aten/src/ATen/native/UpSampleLanczos2d.cpp": + "loop validates scale factors; resampling arithmetic is in extracted dispatch kernels", + "aten/src/ATen/native/UpSampleNearest3d.cpp": + "loops validate five-dimensional shape/scale metadata; arithmetic is dispatched", + "aten/src/ATen/native/UpSampleTrilinear3d.cpp": + "loop validates five-dimensional scale metadata; arithmetic is dispatched", +} + + +def read_provenance() -> dict[str, list[str]]: + viewer = (ROOT / "scripts/correctness/build_ce_viewer.py").read_text() + begin = viewer.index("ATEN_C_PROVENANCE:") + end = viewer.index("ATEN_C_MATCH_ASSESSMENT:", begin) + block = viewer[begin:end] + by_source: dict[str, list[str]] = defaultdict(list) + pattern = re.compile( + r'"(aten_[^"]+)"\s*:\s*\("(aten/src/ATen/native/[^"]+)"' + ) + for fixture, source in pattern.findall(block): + by_source[source].append(fixture) + for manifest in sorted( + (ROOT / "issues/aten_c_kernels").glob(GENERATED_PROVENANCE_GLOB) + ): + with manifest.open(newline="") as stream: + for row in csv.DictReader(stream): + by_source[row["source"]].append(row["kernel"]) + return by_source + + +def classify(text: str, fixtures: list[str]) -> tuple[str, str, dict[str, int]]: + metrics = { + "textual_loops": len(re.findall(r"\b(?:for|while)\s*\(", text)), + "cpu_kernel_sites": len( + re.findall(r"\b(?:cpu_kernel(?:_vec)?|cpu_serial_kernel)\s*\(", text) + ), + "dispatch_sites": len( + re.findall(r"\b(?:AT_DISPATCH\w*|REGISTER_DISPATCH|TORCH_IMPL_FUNC)\b", text) + ), + "tensor_iterator_mentions": len(re.findall(r"\bTensorIterator\w*\b", text)), + } + if fixtures: + return "HAS_EXTRACTION", "one or more standalone-C fixtures exist", metrics + if metrics["cpu_kernel_sites"]: + return ( + "EXTRACT_TENSORITERATOR", + "scalar lambda(s) are hidden behind TensorIterator/cpu_kernel", + metrics, + ) + if metrics["textual_loops"]: + return ( + "EXTRACT_LOOP_BODY", + "contains explicit loop(s) requiring framework/type specialization", + metrics, + ) + if metrics["dispatch_sites"] or metrics["tensor_iterator_mentions"]: + return ( + "DISPATCH_ONLY", + "dispatch/registration wrapper with no local scalar loop body", + metrics, + ) + return "NO_LOCAL_NUMERICAL_BODY", "no local loop or TensorIterator kernel body", metrics + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--sources", type=Path, default=DEFAULT_SOURCES) + parser.add_argument("--pytorch", type=Path, default=DEFAULT_PYTORCH) + parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT) + args = parser.parse_args() + + provenance = read_provenance() + adjudicated: dict[str, list[str]] = defaultdict(list) + if OPERATOR_ADJUDICATION.exists(): + with OPERATOR_ADJUDICATION.open(newline="") as stream: + for row in csv.DictReader(stream): + adjudicated[row["source"]].append(row["final_status"]) + rows = [] + for source in args.sources.read_text().splitlines(): + source = source.strip() + if not source: + continue + path = args.pytorch / source + text = path.read_text(errors="replace") + fixtures = sorted(provenance.get(source, [])) + classification, reason, metrics = classify(text, fixtures) + if source in SOURCE_ACCOUNTING and classification.startswith("EXTRACT_"): + classification = "ACCOUNTED_NON_STANDALONE" + reason = SOURCE_ACCOUNTING[source] + source_statuses = adjudicated.get(source, []) + if (classification.startswith("EXTRACT_") and source_statuses + and "NEEDS_PORT" not in source_statuses): + classification = "ACCOUNTED_NON_STANDALONE" + reason = ( + "all named iterative bodies are proven helper/composite, " + "external delegation, non-numerical plumbing, or parser artifact" + ) + rows.append( + { + "source": source, + "classification": classification, + "existing_fixtures": ",".join(fixtures), + **metrics, + "lines": len(text.splitlines()), + "reason": reason, + } + ) + + args.output.parent.mkdir(parents=True, exist_ok=True) + fields = [ + "source", "classification", "existing_fixtures", "textual_loops", + "cpu_kernel_sites", "dispatch_sites", "tensor_iterator_mentions", + "lines", "reason", + ] + with args.output.open("w", newline="") as stream: + writer = csv.DictWriter(stream, fieldnames=fields) + writer.writeheader() + writer.writerows(rows) + + counts: dict[str, int] = defaultdict(int) + for row in rows: + counts[row["classification"]] += 1 + print(f"wrote {len(rows)} translation units to {args.output}") + for name in sorted(counts): + print(f"{name}: {counts[name]}") + + +if __name__ == "__main__": + main() diff --git a/scripts/correctness/aten_full_match_silicon.py b/scripts/correctness/aten_full_match_silicon.py new file mode 100644 index 000000000000..03b7e1e1971e --- /dev/null +++ b/scripts/correctness/aten_full_match_silicon.py @@ -0,0 +1,226 @@ +#!/usr/bin/env python3 +"""Build the unmeasured ATen FULL-raise/FULL-match Jetson batch. + +The generated sources use large, compile-time shapes, because both cgeist and +the library matcher recover dimensions from the C array types. This script +does not mutate the small canonical extraction fixtures. +""" +from __future__ import annotations + +import argparse +import concurrent.futures +import json +import os +from pathlib import Path +import re +import subprocess +import sys + +ROOT = Path(__file__).resolve().parents[2] +ATEN = ROOT / "issues/aten_c_kernels" +HARNESS = ATEN / "benchmarks/aten_full_match_raised_harness.c" +LEGACY_HARNESS = ATEN / "benchmarks/aten_raised_jetson_harness.c" +RESIDENT = ATEN / "benchmarks/aten_full_match_resident_baseline.c" +BUILDER = ROOT / "scripts/correctness/polygeist_build.sh" + + +def case(kind: str, dims: dict[str, int], problem: str, + extra: tuple[str, ...] = ()) -> dict: + return {"kind": kind, "dims": dims, "problem": problem, "extra": extra} + + +CASES = { + "aten_as_complex_cpu": case("AS_COMPLEX", {"N": 8_388_608}, "N=8388608"), + "aten_bf16_dot_cpu": case("DOT", {"M": 1, "K": 16_777_216}, "K=16777216 scalarized-f32"), + "aten_bf16_gemv_trans_cpu": case("GEMV", {"M": 4096, "K": 8192}, "M=4096 K=8192 scalarized-f32 trans", ("GEMV_TRANS",)), + "aten_blas_copy_cpu": case("COPY1", {"N": 16_777_216}, "N=16777216"), + "aten_blas_dot_naive_cpu": case("DOT", {"N": 16_777_216, "K": 16_777_216}, "N=K=16777216"), + "aten_blas_gemv_generic_cpu": case("GEMV", {"M": 4096, "K": 8192}, "M=4096 K=8192"), + "aten_cat_serial_cpu": case("CAT", {"R": 4096, "M": 4096, "K": 2048, "TOP": 2048}, "R=4096 M=4096 K=2048"), + "aten_complex_scalarized": case("TWO_COPY", {"N": 8_388_608}, "N=8388608"), + "aten_conv3d": case("CONV3D_BIAS", {"B": 1, "IC": 8, "OC": 16, "D": 48, "H": 48, "W": 48, "K": 3}, "B1 IC8 OC16 D48 H48 W48 K3"), + "aten_conv_transpose3d_backward_cpu": case("CONV3D_TRANSPOSE_BACKWARD", {"C": 8, "O": 16, "D": 48, "H": 48, "W": 48, "K": 3}, "C8 O16 D48 H48 W48 K3"), + "aten_copy_cpu": case("COPY1", {"N": 16_777_216}, "N=16777216"), + "aten_copy_tensor_array_cpu": case("COPY2", {"B": 4096, "N": 4096}, "B=4096 N=4096"), + "aten_fast_cat_dim0_cpu": case("COPY2", {"B": 4096, "N": 4096}, "B=4096 N=4096"), + "aten_flatten_nd_linear_cpu": case("BATCH_GEMM", {"B": 16, "M": 256, "K": 256, "N": 256}, "B16 M256 N256 K256"), + "aten_fp16_dot_cpu": case("DOT", {"M": 1, "K": 16_777_216}, "K=16777216 scalarized-f32"), + "aten_fp16_gemv_f16arith_cpu": case("GEMV", {"M": 4096, "K": 8192}, "M=4096 K=8192 scalarized-f32"), + "aten_fp16_gemv_f32arith_cpu": case("GEMV", {"M": 4096, "K": 8192}, "M=4096 K=8192 scalarized-f32"), + "aten_fp16_gemv_notrans_cpu": case("GEMV", {"M": 4096, "K": 8192}, "M=4096 K=8192 scalarized-f32"), + "aten_fp16_gemv_trans_cpu": case("GEMV", {"M": 4096, "K": 8192}, "M=4096 K=8192 scalarized-f32 trans", ("GEMV_TRANS",)), + "aten_gelu_cpu_tanh": case("GELU", {"N": 8_388_608}, "N=8388608"), + "aten_linear_combination_cpu": case("LINEAR_COMB", {"N": 8_388_608}, "N=8388608 terms=4"), + "aten_narrow_copy_dense_cpu": case("NARROW", {"R": 4096, "C": 4096, "S": 1024, "L": 2048}, "R=4096 C=4096 S=1024 L=2048"), + "aten_nested_clone_cpu": case("COPY2", {"B": 4096, "N": 4096}, "B=4096 N=4096"), + "aten_nested_matmul_broadcast_cpu": case("BATCH_GEMM", {"B": 16, "M": 256, "K": 256, "N": 256}, "B16 M256 N256 K256"), + "aten_nested_squeeze_cpu": case("COPY2", {"B": 4096, "N": 4096}, "B=4096 N=4096"), + "aten_outer": case("OUTER", {"M": 4096, "N": 4096}, "M=4096 N=4096 f64"), + "aten_slow_conv3d_forward_cpu": case("CONV3D", {"C": 8, "O": 16, "D": 48, "H": 48, "W": 48, "K": 3}, "C8 O16 D48 H48 W48 K3"), + "aten_unbind_copy_cpu": case("COPY2", {"B": 4096, "N": 4096}, "B=4096 N=4096"), + "aten_zeros_cpu": case("ZERO", {"N": 16_777_216}, "N=16777216"), +} + + +def legacy_case(bench: str, dims: dict[str, int], problem: str, + cudnn: bool = False) -> dict: + return {"legacy": True, "bench": bench, "dims": dims, + "problem": problem, "cudnn": cudnn, "extra": ()} + + +# The first eleven large comparisons predate the exhaustive FULL/FULL harness. +# Keep them in the same driver so direct-buffer and device-resident validation +# covers every executed row in the ATen CE dataset. +CASES.update({ + "aten_add": legacy_case("ADD", {"B": 32, "C": 64, "H": 64, "W": 64}, + "B32 C64 H64 W64", True), + "aten_addmm": legacy_case("ADDMM", {"M": 512, "N": 512, "K": 512}, + "M512 N512 K512"), + "aten_batch_norm": legacy_case( + "BATCH_NORM", {"B": 32, "C": 64, "H": 64, "W": 64}, + "B32 C64 H64 W64", True), + "aten_conv2d": legacy_case( + "CONV2D", {"B": 8, "IC": 32, "OC": 64, "H": 64, "W": 64, + "KH": 3, "KW": 3}, + "B8 IC32 OC64 H64 W64 KH3 KW3", True), + "aten_dot": legacy_case("DOT", {"N": 8_388_608}, "N8388608"), + "aten_gelu": legacy_case("GELU", {"N": 8_388_608}, "N8388608", True), + "aten_max_pool2d": legacy_case( + "MAX_POOL2D", {"B": 32, "C": 64, "H": 64, "W": 64, + "K": 2, "S": 2}, + "B32 C64 H64 W64 K2 S2", True), + "aten_mm": legacy_case("MM", {"M": 512, "N": 512, "K": 512}, + "M512 N512 K512"), + "aten_mv": legacy_case("MV", {"M": 4096, "K": 4096}, "M4096 K4096"), + "aten_rms_norm": legacy_case("RMS_NORM", {"N": 8_388_608}, + "N8388608", True), + "aten_softmax": legacy_case("SOFTMAX", {"N": 8_388_608}, + "N8388608", True), +}) + + +def scaled_source(kernel: str, spec: dict, out: Path) -> None: + text = (ATEN / f"{kernel}.c").read_text() + for name, value in spec["dims"].items(): + pattern = rf"(^\s*#\s*define\s+{re.escape(name)}\s+)[^\n]+" + text, count = re.subn(pattern, rf"\g<1>{value}", text, flags=re.MULTILINE) + if count == 0: + text = f"#define {name} {value}\n" + text + # Preserve the same contiguous flattening semantics while presenting the + # output at its natural rank. The flat spelling otherwise introduces a + # rank-changing submap after the copy launch and currently trips the + # generic affine write-back fallback during executable lowering. + if kernel == "aten_fast_cat_dim0_cpu": + text = text.replace("float out[B*N]", "float out[B][N]") + text = text.replace("out[b*N+i]", "out[b][i]") + out.write_text(text) + + +def run(cmd: list[str], log: Path, env: dict[str, str] | None = None) -> None: + with log.open("w") as stream: + proc = subprocess.run(cmd, cwd=ROOT, env=env, stdout=stream, + stderr=subprocess.STDOUT, text=True) + if proc.returncode: + raise RuntimeError(f"command failed ({proc.returncode}); see {log}") + + +def build_one(kernel: str, spec: dict, out: Path) -> dict: + work = out / kernel + work.mkdir(parents=True, exist_ok=True) + source = work / f"{kernel}_large.c" + scaled_source(kernel, spec, source) + reference = f"{kernel}_reference" + ref_obj = work / "reference.o" + defs = [f"-D{k}={v}" for k, v in spec["dims"].items()] + defs += [f"-D{x}" for x in spec.get("extra", ())] + run(["aarch64-linux-gnu-gcc", "-O3", f"-D{kernel}={reference}", + "-c", str(source), "-o", str(ref_obj)], work / "reference.build.log") + exe = work / kernel + env = os.environ.copy() + env["POLYGEIST_CUSTOM_CUDA_OBJ"] = str(ref_obj) + # The Slack-bot virtualenv intentionally has no compiler dependencies; + # the system Python carries the locally installed egglog package. + env["PYTHON"] = "/usr/bin/python3" + env["POLYGEIST_MINIMAL_CUDA_RUNTIME"] = "1" + if spec.get("legacy") and spec.get("cudnn"): + env["POLYGEIST_MINIMAL_CUDNN_RUNTIME"] = "1" + if spec.get("kind") in { + "CONV3D_BIAS", "CONV3D", "CONV3D_TRANSPOSE_BACKWARD", "GELU"}: + env["POLYGEIST_MINIMAL_CUDNN_RUNTIME"] = "1" + cutensornet = Path("/tmp/polygeist_cutensornet_flat") + if (cutensornet.exists() and + os.environ.get("POLYGEIST_ATEN_DISABLE_CUTENSORNET", "0") == "0"): + # This mode also drops unused cuFFT/cuSPARSE DT_NEEDED entries. The + # attached Jetson intentionally carries only the libraries exercised + # by this ATen batch. + env["POLYGEIST_CUTENSORNET_ROOT"] = str(cutensornet) + env["POLYGEIST_MINIMAL_CUTENSORNET_RUNTIME"] = "1" + if spec.get("legacy"): + harness = LEGACY_HARNESS + bench_defs = [f"-DBENCH_ATEN_{spec['bench']}"] + else: + harness = HARNESS + bench_defs = [f"-DFUNCTION={kernel}", f"-DREFERENCE={reference}", + f"-DBENCH_KIND_{spec['kind']}"] + cmd = [str(BUILDER), "--target=jetson", f"--function={kernel}", + f"--harness={harness}", "-o", str(exe), str(source), + *bench_defs, "-DBENCH_ITERS=5", *defs] + run(cmd, work / "raised.build.log", env) + raised_device = str(work / f"{kernel}_raised_device") + run([ + str(BUILDER), "--target=jetson", f"--function={kernel}", + f"--harness={harness}", "-o", raised_device, + str(source), *bench_defs, + "-DDEVICE_RESIDENT", "-DBENCH_ITERS=20", *defs, + f"-I{Path('/usr/local/cuda-12.6/targets/sbsa-linux/include')}", + ], work / "raised_device.build.log", env) + resident = "" + if not spec.get("legacy") and spec["kind"] != "GELU": + resident = str(work / f"{kernel}_resident") + resident_defs = [f"-DATEN_{k}={v}" for k, v in spec["dims"].items()] + resident_defs += [f"-D{x}" for x in spec["extra"]] + cuda = Path("/usr/local/cuda-12.6/targets/sbsa-linux") + run([ + "aarch64-linux-gnu-gcc", "-O3", str(RESIDENT), str(ref_obj), + f"-DFUNCTION={kernel}", f"-DREFERENCE={reference}", + f"-DBENCH_KIND_{spec['kind']}", "-DBENCH_ITERS=20", + *resident_defs, f"-I{cuda / 'include'}", "-I/usr/include/aarch64-linux-gnu", + f"-L{cuda / 'lib'}", f"-L{cuda / 'lib/stubs'}", + "-L/usr/lib/aarch64-linux-gnu", "-lcudnn", "-lcublasLt", + "-lcublas", "-lcudart", "-lm", "-ldl", "-o", resident, + ], work / "resident.build.log") + return {"kernel": kernel, "problem": spec["problem"], + "kind": spec.get("kind", spec.get("bench", "")), + "executable": str(exe), + "raised_device_executable": raised_device, + "resident_executable": resident, + "status": "BUILT"} + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument("--output", type=Path, default=Path("/tmp/aten_full_match_large")) + parser.add_argument("--jobs", type=int, default=4) + parser.add_argument("--kernel", action="append", choices=sorted(CASES)) + args = parser.parse_args() + args.output.mkdir(parents=True, exist_ok=True) + selected = args.kernel or sorted(CASES) + rows, failures = [], [] + with concurrent.futures.ThreadPoolExecutor(max_workers=args.jobs) as pool: + futures = {pool.submit(build_one, k, CASES[k], args.output): k for k in selected} + for future in concurrent.futures.as_completed(futures): + kernel = futures[future] + try: + row = future.result(); rows.append(row) + print(f"[BUILT] {kernel}", flush=True) + except Exception as exc: + failures.append({"kernel": kernel, "error": str(exc)}) + print(f"[FAIL] {kernel}: {exc}", file=sys.stderr, flush=True) + manifest = {"cases": sorted(rows, key=lambda x: x["kernel"]), "failures": failures} + (args.output / "manifest.json").write_text(json.dumps(manifest, indent=2) + "\n") + print(f"built={len(rows)} failed={len(failures)} output={args.output}") + return 1 if failures else 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/correctness/aten_operator_adjudicate.py b/scripts/correctness/aten_operator_adjudicate.py new file mode 100644 index 000000000000..0fa191acd95d --- /dev/null +++ b/scripts/correctness/aten_operator_adjudicate.py @@ -0,0 +1,178 @@ +#!/usr/bin/env python3 +"""Adjudicate non-dispatch loop bodies after call-graph coverage analysis. + +Every rule is intentionally source/symbol based and carries a reason. Anything +not proven to be plumbing, orchestration, external delegation, or already +covered remains NEEDS_PORT. +""" + +from __future__ import annotations + +import csv +import re +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +INPUT = ROOT / "issues/aten_c_kernels/operator_inventory.csv" +OUTPUT = ROOT / "issues/aten_c_kernels/operator_adjudication.csv" + +WHOLE_SOURCE = { + "aten/src/ATen/native/AutogradComposite.cpp": ("NON_NUMERICAL_PLUMBING", "autograd metadata allocation"), + "aten/src/ATen/native/CPUFallback.cpp": ("NON_NUMERICAL_PLUMBING", "device fallback and argument traversal"), + "aten/src/ATen/native/IndexingUtils.cpp": ("NON_NUMERICAL_PLUMBING", "index-width eligibility check"), + "aten/src/ATen/native/Integration.cpp": ("NON_NUMERICAL_PLUMBING", "shape padding helper"), + "aten/src/ATen/native/LegacyBatching.cpp": ("NON_NUMERICAL_PLUMBING", "batch-dimension metadata"), + "aten/src/ATen/native/TensorIteratorReduce.cpp": ("NON_NUMERICAL_PLUMBING", "TensorIterator reduction scheduling"), + "aten/src/ATen/native/TensorProperties.cpp": ("NON_NUMERICAL_PLUMBING", "storage alias/property test"), + "aten/src/ATen/native/TypeProperties.cpp": ("NON_NUMERICAL_PLUMBING", "dtype inference"), + "aten/src/ATen/native/UpSample.cpp": ("NON_NUMERICAL_PLUMBING", "output-shape calculation"), + "aten/src/ATen/native/TestOps.cpp": ("NON_NUMERICAL_PLUMBING", "test-only argument materialization"), + "aten/src/ATen/native/transformers/sdp_utils_cpp.cpp": ("NON_NUMERICAL_PLUMBING", "backend selection"), +} + +EXTERNAL_DELEGATES = { + "aten/src/ATen/native/BatchLinearAlgebra.cpp": {"apply_cholesky_solve"}, + "aten/src/ATen/native/BatchLinearAlgebraKernel.cpp": { + "apply_cholesky", "apply_cholesky_inverse", "apply_linalg_eig", + "apply_lapack_eigh", "apply_geqrf", "apply_orgqr", "apply_ormqr", + "apply_triangular_solve", "apply_ldl_factor", "apply_ldl_solve", + "apply_lu_factor", "apply_lu_solve", "apply_svd", + }, + "aten/src/ATen/native/NNPACK.cpp": {"_nnpack_spatial_convolution"}, + "aten/src/ATen/native/QuantizedLinear.cpp": { + "fbgemm_linear_int8_weight_fp32_activation", + }, +} + +COMPOSITE_SOURCES = { + "aten/src/ATen/native/Convolution.cpp", + "aten/src/ATen/native/Copy.cpp", + "aten/src/ATen/native/ForeachOpsKernels.cpp", + "aten/src/ATen/native/FusedAdagrad.cpp", + "aten/src/ATen/native/FusedAdam.cpp", + "aten/src/ATen/native/FusedSGD.cpp", + "aten/src/ATen/native/Histogram.cpp", + "aten/src/ATen/native/MaxUnpooling.cpp", +} + +PLUMBING_NAMES = re.compile( + r"^(?:" + r".*(?:check|validate|shape_check).*|" + r"(?:can|should|use)_[A-Za-z0-9_]+|canUse32BitIndexMath|" + r".*(?:size_stride|strides_for_view|output_memory_format).*|" + r"compute_target_device|out_device|result_type|find_split_dim|" + r"remove_existing_batch_dim|add_padding_to_shape|" + r"allocate_bin_edges_tensors|histogramdd_prepare_out|" + r"debug_assert_shape|aligned_tensor|to_meta|empty_permuted_symint|" + r"set_storage_meta__symint|stack_meta|get_stack_inputs|check_stack_inputs|" + r"compressed_count_blocks|_estimate_sparse_compressed_tensor_size|" + r"num_bytes|NestedTensor_get_max_size_from_size_tensor|" + r"cat_compute_output_memory_format|_permute_size_stride_estimation" + r")$" +) + +RNN_ORCHESTRATION = { + "use_mkldnn", "pair_vec", "unpair_vec", "gather_params", "project", + "operator", "_lstm_impl", "lstm", "quantized_lstm_input", + "quantized_lstm_data", +} + +# These bodies iterate over sizes, strides, Tensor lists, or dispatch choices; +# they do not implement the elementwise/reduction/contraction arithmetic that +# the standalone-C raising corpus is intended to preserve. +SOURCE_PLUMBING = { + "aten/src/ATen/native/TensorShape.cpp": { + "_reshape_from_tensor", "sparse_broadcast_to", "sizes_match_except", + "tensor_split_sections_symint", "_tensor_split_indices", "tensor_split", + "split", "unsafe_split", "split_with_sizes", "unsafe_split_with_sizes", + "_pad_chunk", "inferSqueezeGeometry", "squeeze_qtensor", "flatten", + "unbind", "meshgrid", "numpy_T", "movedim", "unflatten_dense_tensors", + "tile_symint", + }, + "aten/src/ATen/native/SpectralOps.cpp": { + "resize_fft_input", "canonicalize_fft_shape_and_dim_args", "default_alldims", + }, + "aten/src/ATen/native/nested/NestedTensorMath.cpp": { + "_nested_tensor_from_tensor_list", "_nested_view_from_buffer", + "reshape_as_nested", "cat_nested_as_jagged", "cat_nested_impl", + }, + "aten/src/ATen/native/nested/NestedTensorMatmul.cpp": { + "matmul_with_bmm_nested", "matmul_out_nested", + }, + "aten/src/ATen/native/nested/NestedTensorFactories.cpp": { + "NestedTensor_unbind", + }, + "aten/src/ATen/native/nested/NestedTensorUtils.cpp": { + "chunk_nested_tensor", "split_with_sizes_nested", + }, + "aten/src/ATen/native/PackedSequence.cpp": { + "_pack_padded_sequence", "_pack_padded_sequence_backward_symint", + "_pad_packed_sequence", "pad_sequence", + }, + "aten/src/ATen/native/Linear.cpp": {"einsum", "tensordot"}, + "aten/src/ATen/native/TensorAdvancedIndexing.cpp": { + "build_index_op", "all_strides_match", "_scatter_via_index_put", + "_gather_sparse_backward", + }, + "aten/src/ATen/native/LinearAlgebra.cpp": { + "matrix_chain_order", "multi_dot_impl", "mexp_impl", + "linalg_matrix_power_impl", "compute_T18_scale_square", + }, + "aten/src/ATen/native/TensorConversions.cpp": {"_to_cpu"}, + "aten/src/ATen/native/sparse/ValidateCompressedIndicesKernel.cpp": {"launch"}, + "aten/src/ATen/native/sparse/SparseTensor.cpp": {"sparse_coo_tensor"}, + "aten/src/ATen/native/EmbeddingBag.cpp": {"fbgemm_spmdm_report_error_"}, +} + + +def adjudicate(row: dict[str, str]) -> tuple[str, str]: + if row["status"] in {"EXTRACTED", "COVERED_BY_EXTRACTED_ENTRY"}: + return row["status"], "provenance/call-graph evidence" + source, symbol = row["source"], row["symbol"] + if symbol == "constexpr": + return "PARSER_ARTIFACT", "not a function symbol" + if source in WHOLE_SOURCE: + return WHOLE_SOURCE[source] + if symbol in SOURCE_PLUMBING.get(source, set()): + return "NON_NUMERICAL_PLUMBING", "shape/view/list orchestration; arithmetic is delegated to called operators" + if symbol in EXTERNAL_DELEGATES.get(source, set()): + return "EXTERNAL_LIBRARY_DELEGATION", "batch loop delegates arithmetic to LAPACK/NNPACK/FBGEMM" + if PLUMBING_NAMES.match(symbol): + return "NON_NUMERICAL_PLUMBING", "shape, validation, dtype, or backend-selection loop" + if source in COMPOSITE_SOURCES: + return "COVERED_COMPOSITE_ORCHESTRATION", "loops dispatch already-extracted backend kernels" + if source == "aten/src/ATen/native/nested/NestedTensorBinaryOps.cpp" and symbol in { + "get_elementwise_nested_tensor_impl", "NestedTensor_elementwise_Tensor", + }: + return "COVERED_COMPOSITE_ORCHESTRATION", "iterates nested components and delegates arithmetic to dense elementwise operators" + if source == "aten/src/ATen/native/RNN.cpp" and symbol in RNN_ORCHESTRATION: + return "COVERED_COMPOSITE_ORCHESTRATION", "tensor-list orchestration over RNN primitives" + if source == "aten/src/ATen/native/transformers/attention.cpp" and symbol in { + "debug_assert_shape", "aligned_tensor", + }: + return "NON_NUMERICAL_PLUMBING", "shape assertion/aligned allocation" + return "NEEDS_PORT", "local iterative body not yet proven covered or non-numerical" + + +def main() -> None: + rows = list(csv.DictReader(INPUT.open())) + output = [] + for row in rows: + final_status, rationale = adjudicate(row) + output.append({**row, "final_status": final_status, "rationale": rationale}) + fields = list(rows[0]) + ["final_status", "rationale"] + with OUTPUT.open("w", newline="") as stream: + writer = csv.DictWriter(stream, fieldnames=fields) + writer.writeheader() + writer.writerows(output) + counts: dict[str, int] = {} + for row in output: + counts[row["final_status"]] = counts.get(row["final_status"], 0) + 1 + print(f"wrote {len(output)} adjudicated bodies to {OUTPUT}") + for key in sorted(counts): + print(f"{key}: {counts[key]}") + + +if __name__ == "__main__": + main() diff --git a/scripts/correctness/aten_operator_inventory.py b/scripts/correctness/aten_operator_inventory.py new file mode 100644 index 000000000000..e55ccb7283ae --- /dev/null +++ b/scripts/correctness/aten_operator_inventory.py @@ -0,0 +1,248 @@ +#!/usr/bin/env python3 +"""Enumerate named ATen functions that contain local numerical iteration. + +This complements aten_extraction_inventory.py. The latter accounts for source +files; this manifest accounts for named bodies inside them so that a file with +twenty kernels cannot be considered complete after extracting only one. +""" + +from __future__ import annotations + +import argparse +import csv +import re +from collections import defaultdict +from pathlib import Path + +from aten_extraction_inventory import DEFAULT_PYTORCH, DEFAULT_SOURCES, ROOT + + +DEFAULT_OUTPUT = ROOT / "issues/aten_c_kernels/operator_inventory.csv" +DISPATCH_INVENTORY = ROOT / "issues/aten_c_kernels/dispatch_kernel_inventory.csv" + +CONTROL_NAMES = {"if", "for", "while", "switch", "catch"} +MANUAL_COVERED_HELPERS: dict[str, set[str]] = { + "aten/src/ATen/native/cpu/ScatterGatherKernel.cpp": {"operator"}, + "aten/src/ATen/native/cpu/UpSampleKernel.cpp": { + "eval", "is_zero_stride", "basic_loop_non_separable", + }, + "aten/src/ATen/native/cpu/batch_norm_kernel.cpp": { + "batch_norm_cpu_collect_linear_and_constant_terms", + "batch_norm_cpu_collect_stats_contiguous_internal", + "batch_norm_cpu_collect_stats_channels_last_internal", + "batch_norm_cpu_backward_contiguous_internal", + "batch_norm_cpu_backward_channels_last_internal", + }, + "aten/src/ATen/native/cpu/int4mm_kernel.cpp": { + "tinygemm_kernel", "tinygemm_kernel_", + }, + "aten/src/ATen/native/cpu/int8mm_kernel.cpp": { + "tinygemm_kernel", "tinygemm_kernel_", + }, + "aten/src/ATen/native/cpu/DepthwiseConvKernel.cpp": { + "convolution_depthwise3x3_winograd_impl", + }, + "aten/src/ATen/native/FusedAdagrad.cpp": {"_fused_adagrad_kernel_cpu_"}, + "aten/src/ATen/native/FusedAdam.cpp": { + "_fused_adam_kernel_cpu_", "_fused_adamw_kernel_cpu_", + }, + "aten/src/ATen/native/FusedSGD.cpp": {"_fused_sgd_kernel_cpu_"}, +} +FUNCTION_RE = re.compile( + r""" + (?:(?<=\n)|\A) + (?P
+ (?:[ \t]*(?:template[ \t]*<[^;{}]+>|[A-Z_][A-Z0-9_]*\([^{}\n]*\))[ \t]*\n)* + [ \t]*(?:(?:static|inline|constexpr|const|virtual|extern|C10_ALWAYS_INLINE) + [ \t]+)* + [A-Za-z_~][\w:<>,*& \t\n]*? + [ \t]+(?P[A-Za-z_~]\w*(?:::\w+)*) + [ \t]*\([^;{}]*?\) + [ \t]*(?:const[ \t]*)?(?:noexcept[ \t]*)? + )\{ + """, + re.VERBOSE, +) +TORCH_IMPL_RE = re.compile( + r"(?:(?<=\n)|\A)[ \t]*TORCH_IMPL_FUNC\((?P\w+)\)" + r"[ \t]*\([^;{}]*?\)[ \t]*\{", + re.DOTALL, +) + + +def mask_non_code(text: str) -> str: + """Replace comments and string/char literals while retaining newlines.""" + pattern = re.compile( + r"//[^\n]*|/\*.*?\*/|\"(?:\\.|[^\"\\])*\"|'(?:\\.|[^'\\])*'", + re.DOTALL, + ) + return pattern.sub( + lambda match: "".join("\n" if c == "\n" else " " for c in match.group()), + text, + ) + + +def matching_brace(text: str, opening: int) -> int: + depth = 0 + for index in range(opening, len(text)): + if text[index] == "{": + depth += 1 + elif text[index] == "}": + depth -= 1 + if depth == 0: + return index + 1 + return len(text) + + +def provenance() -> tuple[dict[str, list[str]], dict[str, list[str]]]: + """Return fixtures indexed by source and by source token.""" + from build_ce_viewer import ATEN_C_PROVENANCE + + by_source: dict[str, list[str]] = defaultdict(list) + by_token: dict[str, list[str]] = defaultdict(list) + for kernel, (source, token) in ATEN_C_PROVENANCE.items(): + by_source[source].append(kernel) + if token: + by_token[f"{source}\0{token}"].append(kernel) + return by_source, by_token + + +def numerical_sites(body: str) -> tuple[int, int, int]: + loops = len(re.findall(r"\b(?:for|while)\s*\(", body)) + tensor_iterator = len( + re.findall( + r"\b(?:cpu_kernel(?:_vec|_multiple_outputs)?|cpu_serial_kernel)" + r"\s*\(", + body, + ) + ) + parallel = len( + re.findall(r"\b(?:parallel_for|at::parallel_for|parallel_reduce)\s*\(", body) + ) + return loops, tensor_iterator, parallel + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--sources", type=Path, default=DEFAULT_SOURCES) + parser.add_argument("--pytorch", type=Path, default=DEFAULT_PYTORCH) + parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT) + args = parser.parse_args() + + by_source, by_token = provenance() + dispatch_roots: dict[str, set[str]] = defaultdict(set) + if DISPATCH_INVENTORY.exists(): + with DISPATCH_INVENTORY.open(newline="") as stream: + for row in csv.DictReader(stream): + if row["status"] == "EXTRACTED": + dispatch_roots[row["source"]].add(row["implementation"]) + rows: list[dict[str, object]] = [] + for source in filter(None, map(str.strip, args.sources.read_text().splitlines())): + path = args.pytorch / source + original = path.read_text(errors="replace") + masked = mask_non_code(original) + matches = list(FUNCTION_RE.finditer(masked)) + list(TORCH_IMPL_RE.finditer(masked)) + seen: set[tuple[str, int]] = set() + functions: list[dict[str, object]] = [] + for match in sorted(matches, key=lambda item: item.start()): + name = match.group("name") + if name in CONTROL_NAMES: + continue + opening = masked.find("{", match.start(), match.end() + 1) + if opening < 0: + continue + end = matching_brace(masked, opening) + body = masked[opening:end] + line = original.count("\n", 0, match.start()) + 1 + identity = (name, line) + if identity in seen: + continue + seen.add(identity) + functions.append( + { + "name": name, "line": line, "body": body, + "header": original[match.start():opening], + } + ) + + names = {str(function["name"]) for function in functions} + roots = set(dispatch_roots.get(source, set())) + for key in by_token: + key_source, token = key.split("\0", 1) + if key_source != source: + continue + for name in names: + if token == name or name in token: + roots.add(name) + reachable = set(roots) + changed = True + while changed: + changed = False + root_bodies = [ + str(function["body"]) + for function in functions + if function["name"] in reachable + ] + joined = "\n".join(root_bodies) + for name in names - reachable: + if re.search(rf"\b{re.escape(name)}\s*(?:<[^;{{}}]*>)?\s*\(", joined): + reachable.add(name) + changed = True + + for function in functions: + name = str(function["name"]) + line = int(function["line"]) + body = str(function["body"]) + header = str(function["header"]) + loops, tensor_iterator, parallel = numerical_sites(body) + if not (loops or tensor_iterator or parallel): + continue + exact = [] + for key, fixtures in by_token.items(): + key_source, token = key.split("\0", 1) + if key_source == source and ( + token == name or token in header + or name in token + ): + exact.extend(fixtures) + if exact: + status = "EXTRACTED" + elif ( + name in reachable + or name in MANUAL_COVERED_HELPERS.get(source, set()) + ): + status = "COVERED_BY_EXTRACTED_ENTRY" + else: + status = "NEEDS_REVIEW" + rows.append( + { + "source": source, + "symbol": name, + "line": line, + "textual_loops": loops, + "tensor_iterator_sites": tensor_iterator, + "parallel_sites": parallel, + "exact_fixtures": ",".join(sorted(set(exact))), + "source_has_fixture": "yes" if by_source.get(source) else "no", + "status": status, + } + ) + + args.output.parent.mkdir(parents=True, exist_ok=True) + fields = ( + "source", "symbol", "line", "textual_loops", "tensor_iterator_sites", + "parallel_sites", "exact_fixtures", "source_has_fixture", "status", + ) + with args.output.open("w", newline="") as stream: + writer = csv.DictWriter(stream, fieldnames=fields) + writer.writeheader() + writer.writerows(rows) + print(f"wrote {len(rows)} named numerical bodies to {args.output}") + print(f"exactly linked extractions: {sum(row['status'] == 'EXTRACTED' for row in rows)}") + print("covered helper bodies: " + f"{sum(row['status'] == 'COVERED_BY_EXTRACTED_ENTRY' for row in rows)}") + print(f"needs review/extraction: {sum(row['status'] == 'NEEDS_REVIEW' for row in rows)}") + + +if __name__ == "__main__": + main() diff --git a/scripts/correctness/aten_raise_sweep.py b/scripts/correctness/aten_raise_sweep.py new file mode 100644 index 000000000000..bae08a4f7896 --- /dev/null +++ b/scripts/correctness/aten_raise_sweep.py @@ -0,0 +1,184 @@ +#!/usr/bin/env python3 +"""Measure direct ATen C/C++ translation-unit raising through the PVA pipeline.""" + +import argparse +import concurrent.futures +import csv +import json +import os +from pathlib import Path +import re +import subprocess +import tempfile +import time + + +EXCLUDED_COMPONENTS = { + "cuda", "cudnn", "hip", "miopen", "mps", "metal", "vulkan", + "mkldnn", "mkl", "xnnpack", "kleidiai", "quantized", "ao_sparse", "xpu", +} +SOURCE_SUFFIXES = {".c", ".cc", ".cpp", ".cxx"} +LOOP_RE = re.compile(r"\b(?:affine|scf)\.(?:for|parallel|while)\b") + + +def discover(native_root: Path): + return sorted( + path for path in native_root.rglob("*") + if path.suffix.lower() in SOURCE_SUFFIXES + and not (set(path.relative_to(native_root).parts[:-1]) & EXCLUDED_COMPONENTS) + ) + + +def run(command, timeout, cwd): + try: + completed = subprocess.run( + command, cwd=cwd, text=True, stdout=subprocess.PIPE, + stderr=subprocess.PIPE, timeout=timeout, + preexec_fn=lambda: os.setsid(), + ) + return completed.returncode, completed.stdout, completed.stderr, False + except subprocess.TimeoutExpired as error: + stdout = error.stdout or "" + stderr = error.stderr or "" + if isinstance(stdout, bytes): + stdout = stdout.decode(errors="replace") + if isinstance(stderr, bytes): + stderr = stderr.decode(errors="replace") + return 124, stdout, stderr, True + + +def concise_error(stderr): + lines = [line.strip() for line in stderr.splitlines() if line.strip()] + for line in lines: + if "error:" in line or "Assertion" in line or "not handled" in line: + return line[:500] + return (lines[0] if lines else "")[:500] + + +def process_one(source, args): + started = time.monotonic() + rel = source.relative_to(args.pytorch) + with tempfile.TemporaryDirectory(prefix="aten-raise-") as temp: + lifted = Path(temp) / "lifted.mlir" + raised = Path(temp) / "raised.mlir" + compile_command = [ + str(args.cgeist), str(source), "--function=*", + f"--resource-dir={args.resource_dir}", + f"-I{args.generated}", f"-I{args.pytorch}", + f"-I{args.pytorch / 'aten/src'}", + f"-I{args.pytorch / 'third_party/cpuinfo/include'}", + "-DC10_USING_CUSTOM_GENERATED_MACROS", + "-DCPU_CAPABILITY=DEFAULT", "-DCPU_CAPABILITY_DEFAULT", + "-std=c++20", "--raise-scf-to-affine", "-S", "-o", str(lifted), + ] + status, _, stderr, timed_out = run(compile_command, args.timeout, args.root) + lifted_text = lifted.read_text(errors="replace") if lifted.exists() else "" + emitted = "func.func" in lifted_text + input_loops = len(LOOP_RE.findall(lifted_text)) + row = { + "source": str(rel), "frontend_status": status, + "frontend_timeout": timed_out, "frontend_emitted": emitted, + "input_loops": input_loops, "pipeline_status": "", + "pipeline_timeout": False, "linalg_ops": 0, + "residual_loops": 0, "raised_any": False, "fully_raised": False, + "seconds": 0.0, "error": concise_error(stderr), + } + if status == 0 and emitted: + pipeline_command = [ + str(args.opt), str(lifted), "--remove-iter-args", + "--affine-parallelize", "--raise-affine-to-linalg-pipeline", + "--lower-polygeist-submap", "-o", str(raised), + ] + pstatus, _, pstderr, ptimeout = run( + pipeline_command, args.timeout, args.root + ) + raised_text = raised.read_text(errors="replace") if raised.exists() else "" + linalg_ops = raised_text.count("linalg.") + residual_loops = len(LOOP_RE.findall(raised_text)) + row.update({ + "pipeline_status": pstatus, "pipeline_timeout": ptimeout, + "linalg_ops": linalg_ops, "residual_loops": residual_loops, + "raised_any": input_loops > 0 and linalg_ops > 0, + "fully_raised": input_loops > 0 and linalg_ops > 0 + and residual_loops == 0, + "error": concise_error(pstderr) if pstatus else row["error"], + }) + row["seconds"] = round(time.monotonic() - started, 3) + return row + + +def summarize(rows): + return { + "translation_units": len(rows), + "frontend_success": sum(row["frontend_status"] == 0 for row in rows), + "frontend_emitted": sum(row["frontend_emitted"] for row in rows), + "with_loops": sum(row["input_loops"] > 0 for row in rows), + "pipeline_success": sum(row["pipeline_status"] == 0 for row in rows), + "raised_any": sum(row["raised_any"] for row in rows), + "fully_raised": sum(row["fully_raised"] for row in rows), + "frontend_timeouts": sum(row["frontend_timeout"] for row in rows), + "pipeline_timeouts": sum(row["pipeline_timeout"] for row in rows), + } + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--root", type=Path, default=Path.cwd()) + parser.add_argument("--pytorch", type=Path) + parser.add_argument("--generated", type=Path, + default=Path("/tmp/pytorch_aten_codegen")) + parser.add_argument("--workers", type=int, default=4) + parser.add_argument("--timeout", type=int, default=30) + parser.add_argument("--limit", type=int) + parser.add_argument("--output", type=Path) + opts = parser.parse_args() + opts.root = opts.root.resolve() + opts.pytorch = (opts.pytorch or opts.root / "third_party/pytorch").resolve() + opts.generated = opts.generated.resolve() + opts.cgeist = opts.root / "build/bin/cgeist" + opts.opt = opts.root / "build/bin/polygeist-opt" + opts.resource_dir = opts.root / "llvm-project/build/lib/clang/18" + output = (opts.output or opts.root / "notes/polygeist_raise_to_linalg/aten_raise_sweep_2026_07_21").resolve() + output.mkdir(parents=True, exist_ok=True) + + sources = discover(opts.pytorch / "aten/src/ATen/native") + if opts.limit: + sources = sources[:opts.limit] + (output / "sources.txt").write_text( + "\n".join(str(path.relative_to(opts.pytorch)) for path in sources) + "\n" + ) + + rows = [] + with concurrent.futures.ThreadPoolExecutor(max_workers=opts.workers) as pool: + futures = {pool.submit(process_one, source, opts): source for source in sources} + for index, future in enumerate(concurrent.futures.as_completed(futures), 1): + rows.append(future.result()) + if index % 10 == 0 or index == len(sources): + print(f"[{index}/{len(sources)}] {summarize(rows)}", flush=True) + checkpoint = sorted(rows, key=lambda row: row["source"]) + (output / "checkpoint.json").write_text( + json.dumps(checkpoint, indent=2) + "\n" + ) + rows.sort(key=lambda row: row["source"]) + fields = list(rows[0]) if rows else [] + with (output / "results.csv").open("w", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fields) + writer.writeheader() + writer.writerows(rows) + payload = { + "pytorch_commit": subprocess.check_output( + ["git", "rev-parse", "HEAD"], cwd=opts.pytorch, text=True + ).strip(), + "scope": { + "root": "aten/src/ATen/native", + "suffixes": sorted(SOURCE_SUFFIXES), + "excluded_path_components": sorted(EXCLUDED_COMPONENTS), + }, + "summary": summarize(rows), "results": rows, + } + (output / "results.json").write_text(json.dumps(payload, indent=2) + "\n") + print(json.dumps(payload["summary"], indent=2)) + + +if __name__ == "__main__": + main() diff --git a/scripts/correctness/bake_darknet_mlir.sh b/scripts/correctness/bake_darknet_mlir.sh new file mode 100755 index 000000000000..1f3f1140cb9c --- /dev/null +++ b/scripts/correctness/bake_darknet_mlir.sh @@ -0,0 +1,94 @@ +#!/bin/bash +# bake_darknet_mlir.sh — try lifting every .c file in third_party/darknet/src/ +# through cgeist + raise + match, and report which ones produce useful +# linalg.generic / kernel.launch ops. +# +# Goal: empirically see how many of darknet's 46 source files contain +# patterns our matcher can recognize. Predicted outcome: ~3 useful +# (gemm.c, im2col.c, maybe blas.c). The rest is framework code with no +# compute loops the raise pass can hoist. +set +e +_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$_CORRECTNESS_DIR/common_env.sh" + +ROOT=$REPO_ROOT/third_party/darknet +OUT=/tmp/darknet_mlir +PY=$PYTHON +SCRIPTS=$REPO_ROOT/scripts/correctness +mkdir -p $OUT + +# Track results +TOTAL=0 +CGEIST_OK=0 +RAISE_OK=0 +MATCH_OK=0 +HAS_LINALG=0 + +# Header +printf "%-30s %-7s %-7s %-6s %-6s %s\n" "file" "cgeist" "raise" "lg" "match" "callees" +printf "%-30s %-7s %-7s %-6s %-6s %s\n" "----" "------" "-----" "--" "-----" "-------" + +for src in $ROOT/src/*.c; do + base=$(basename "$src" .c) + TOTAL=$((TOTAL+1)) + + # Skip CUDA-only files (.c that uses CUDA API directly) + if grep -q "cudaMalloc\|cublas\|cudnn" "$src" 2>/dev/null && [ "$base" = "cuda" ]; then + printf "%-30s %-7s %-7s %-6s %-6s %s\n" "$base" "SKIP" "-" "-" "-" "(cuda.c)" + continue + fi + + # 1. cgeist — emit affine MLIR for every function. Keep inlining enabled so + # same-translation-unit helper calls are exposed before the raise pipeline; + # --raise-scf-to-affine gives us affine.for nests where possible. + affine=$OUT/${base}.affine.mlir + timeout 60 cgeist "$src" --function='*' \ + --resource-dir=/usr/lib/clang/14 \ + -I$ROOT/include -I$ROOT/src \ + --raise-scf-to-affine -fPIC -S \ + -o $affine 2>$OUT/${base}.cgeist.err + if [ ! -s "$affine" ]; then + printf "%-30s %-7s %-7s %-6s %-6s %s\n" "$base" "FAIL" "-" "-" "-" "$(head -1 $OUT/${base}.cgeist.err 2>/dev/null | head -c 60)" + continue + fi + CGEIST_OK=$((CGEIST_OK+1)) + + # 2. raise — try to emit linalg.generic. We run without --select-func + # because we don't know which function holds the compute kernel; the + # raise pipeline is applied module-wide. + linalg=$OUT/${base}.linalg.mlir + timeout 60 polygeist-opt \ + --remove-iter-args --affine-parallelize \ + --raise-affine-to-linalg-pipeline --lower-polygeist-submap \ + --linalg-debufferize \ + $affine -o $linalg 2>$OUT/${base}.raise.err + if [ ! -s "$linalg" ]; then + printf "%-30s %-7s %-7s %-6s %-6s %s\n" "$base" "OK" "FAIL" "-" "-" "$(head -1 $OUT/${base}.raise.err 2>/dev/null | head -c 60)" + continue + fi + RAISE_OK=$((RAISE_OK+1)) + + # Count linalg.generic ops + lg=$(grep -c "linalg.generic" $linalg 2>/dev/null) + lg=${lg:-0} + if [ "$lg" -gt 0 ]; then HAS_LINALG=$((HAS_LINALG+1)); fi + + # 3. matcher + matched=$OUT/${base}.matched.mlir + timeout 60 $PY $SCRIPTS/kernel_match_rewrite.py $linalg > $matched 2>$OUT/${base}.match.err + klc=$(grep -c "kernel.launch" $matched 2>/dev/null) + klc=${klc:-0} + if [ "$klc" -gt 0 ]; then MATCH_OK=$((MATCH_OK+1)); fi + + callees=$(grep -oE "kernel.launch @[A-Za-z0-9_]+" $matched 2>/dev/null | sort -u | sed 's|kernel.launch @||' | tr '\n' ',' | sed 's/,$//') + + printf "%-30s %-7s %-7s %-6d %-6d %s\n" "$base" "OK" "OK" "$lg" "$klc" "${callees:--}" +done + +echo "" +echo "═══ Summary ═══" +echo "Total .c files: $TOTAL" +echo "cgeist succeeded: $CGEIST_OK" +echo "raise succeeded: $RAISE_OK" +echo "files with ≥1 linalg.generic: $HAS_LINALG" +echo "files with ≥1 kernel.launch: $MATCH_OK" diff --git a/scripts/correctness/bake_extracted_darknet_mlir.sh b/scripts/correctness/bake_extracted_darknet_mlir.sh new file mode 100755 index 000000000000..23e1ded1f36a --- /dev/null +++ b/scripts/correctness/bake_extracted_darknet_mlir.sh @@ -0,0 +1,59 @@ +#!/bin/bash +# bake_extracted_darknet_mlir.sh — emit the per-stage MLIR snapshots the +# IR explorer expects for each polybench-style CNN-block kernel in +# third_party/cnn-extracted/. +# +# For each kernel with extracted source at $EXT/.c we produce: +# /tmp/extracted_darknet_mlir/.mlir — cgeist output (affine MLIR) +# /tmp/extracted_darknet_mlir/_linalg.mlir — after raise (memref linalg) +# /tmp/extracted_darknet_mlir/_debuf.mlir — after debufferize (tensor linalg) +# +# These are exactly the three naming conventions build_kernel_page reads +# (raised / debuf tabs + matcher round-trip via the rewriter). + +set -euo pipefail +_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$_CORRECTNESS_DIR/common_env.sh" + +EXT=$REPO_ROOT/third_party/cnn-extracted +OUT=/tmp/extracted_darknet_mlir +mkdir -p "$OUT" + +# (kernel_name, function_name) pairs +KERNELS=( + "conv2d_batched kernel_conv2d_batched" + "maxpool_batched kernel_maxpool_batched" + "batchnorm_batched kernel_batchnorm_batched" + "shortcut_batched kernel_shortcut_batched" + "conv_bn_relu_batched kernel_conv_bn_relu_batched" + "conv_bias_relu_add_batched kernel_conv_bias_relu_add_batched" + "gemm_bias_relu kernel_gemm_bias_relu" + "ata_gemm kernel_ata_gemm" + "conv1x1_batched kernel_conv1x1_batched" + "darknet_im2col_gemm kernel_darknet_im2col_gemm" +) + +for line in "${KERNELS[@]}"; do + read -r K FN <<<"$line" + echo "[$K]" + + cgeist "$EXT/$K.c" --function="$FN" --resource-dir=/usr/lib/clang/14 \ + --raise-scf-to-affine -fPIC -S -g -c -o "$OUT/$K.mlir" 2>"$OUT/$K.cgeist.err" || { + echo " cgeist failed; see $OUT/$K.cgeist.err"; continue; + } + + polygeist-opt --select-func="func-name=$FN" \ + --remove-iter-args --affine-parallelize \ + --raise-affine-to-linalg-pipeline \ + "$OUT/$K.mlir" -o "$OUT/$K"_linalg.mlir 2>"$OUT/$K.raise.err" || { + echo " raise failed; see $OUT/$K.raise.err"; continue; + } + + polygeist-opt --linalg-debufferize \ + "$OUT/$K"_linalg.mlir -o "$OUT/$K"_debuf.mlir 2>"$OUT/$K.debuf.err" || { + echo " debuf failed; see $OUT/$K.debuf.err"; continue; + } + + N_LG=$(grep -c "linalg.generic" "$OUT/$K"_debuf.mlir || true) + echo " OK: $N_LG linalg.generic op(s) in debuf" +done diff --git a/scripts/correctness/bake_llama2c_mlir.sh b/scripts/correctness/bake_llama2c_mlir.sh new file mode 100755 index 000000000000..e28e317c39f4 --- /dev/null +++ b/scripts/correctness/bake_llama2c_mlir.sh @@ -0,0 +1,57 @@ +#!/bin/bash +# Bake llama2.c per-function MLIR files in the naming convention the IR +# viewer expects: +# /tmp/llama2c_mlir/.mlir (post-cgeist affine MLIR) +# /tmp/llama2c_mlir/_linalg.mlir (after raise + lower-submap) +# /tmp/llama2c_mlir/_debuf.mlir (default v2 debufferize) +# /tmp/llama2c_mlir/_debuf_mr.mlir (multi-root debufferize) +# +# Target the hot numeric functions in run.c. Other functions (tokenizer, +# I/O, sampling) are not interesting for raising. +set +e +_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$_CORRECTNESS_DIR/common_env.sh" +SRC=$REPO_ROOT/third_party/llama2.c/run.c +OUT=/tmp/llama2c_mlir +mkdir -p $OUT + +# Format: +KERNELS=( + "rmsnorm rmsnorm" + "softmax softmax" + "matmul matmul" +) + +for entry in "${KERNELS[@]}"; do + read tag fn <<<"$entry" + + echo "[$tag] cgeist..." + timeout 60 cgeist "$SRC" --function=$fn --resource-dir=/usr/lib/clang/14 \ + --raise-scf-to-affine -fPIC -S \ + -o $OUT/${tag}.mlir 2>$OUT/${tag}.cgeist.err + if [ ! -s $OUT/${tag}.mlir ]; then + echo " cgeist FAILED"; rm -f $OUT/${tag}.mlir; continue + fi + + echo "[$tag] raise..." + timeout 60 polygeist-opt --select-func=func-name=$fn \ + --remove-iter-args --affine-parallelize \ + --raise-affine-to-linalg-pipeline --lower-polygeist-submap \ + $OUT/${tag}.mlir -o $OUT/${tag}_linalg.mlir 2>$OUT/${tag}.raise.err + [ ! -s $OUT/${tag}_linalg.mlir ] && { echo " raise FAILED"; rm -f $OUT/${tag}_linalg.mlir; continue; } + + echo "[$tag] debuf v2..." + timeout 60 polygeist-opt --linalg-debufferize \ + $OUT/${tag}_linalg.mlir -o $OUT/${tag}_debuf.mlir 2>$OUT/${tag}.debuf.err + [ ! -s $OUT/${tag}_debuf.mlir ] && { echo " v2 debuf FAILED"; rm -f $OUT/${tag}_debuf.mlir; } + + echo "[$tag] debuf multi-root..." + timeout 60 polygeist-opt --linalg-debufferize=use-multi-root=true \ + $OUT/${tag}_linalg.mlir -o $OUT/${tag}_debuf_mr.mlir 2>$OUT/${tag}.debuf_mr.err + if [ ! -s $OUT/${tag}_debuf_mr.mlir ]; then + echo "// Multi-root --linalg-debufferize FAILED. See ${tag}.debuf_mr.err." > $OUT/${tag}_debuf_mr.mlir + fi +done + +echo "Done. Output in $OUT/" +ls $OUT/ | head -30 diff --git a/scripts/correctness/bake_llama_forward_ops_mlir.sh b/scripts/correctness/bake_llama_forward_ops_mlir.sh new file mode 100755 index 000000000000..2c4ed54cea68 --- /dev/null +++ b/scripts/correctness/bake_llama_forward_ops_mlir.sh @@ -0,0 +1,213 @@ +#!/bin/bash +# Bake standalone Llama-forward operation fixtures into per-function MLIR. +# +# Outputs: +# /tmp/llama_forward_ops_mlir/.mlir +# /tmp/llama_forward_ops_mlir/_linalg.mlir +# /tmp/llama_forward_ops_mlir/_debuf.mlir +# /tmp/llama_forward_ops_mlir/_debuf_mr.mlir +# /tmp/llama_forward_ops_mlir/summary.txt +# +# The summary is a quick triage of whether each operation reached linalg and +# whether any debufferized artifact contains tensor linalg. +set +e + +_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$_CORRECTNESS_DIR/common_env.sh" + +SRC=$REPO_ROOT/third_party/cnn-extracted/llama_forward_ops.c +EXTENDED_SRC=$REPO_ROOT/third_party/cnn-extracted/llama2_extended_forward_bench.c +OUT=${POLYGEIST_LLAMA_OPS_OUT:-/tmp/llama_forward_ops_mlir} +EXTENDED_TIMEOUT=${POLYGEIST_LLAMA_EXTENDED_TIMEOUT:-180} +mkdir -p "$OUT" +rm -f "$OUT"/* + +# Format: +KERNELS=( + "token_embedding kernel_llama_token_embedding" + "attention_rmsnorm kernel_llama_attention_rmsnorm" + "qkv_projection kernel_llama_qkv_projection" + "rope_interleaved kernel_llama_rope" + "rope_split kernel_llama_rope_split" + "kv_cache_rw kernel_llama_kv_cache_rw" + "attention_scores kernel_llama_attention_scores" + "attention_mask_if kernel_llama_attention_mask" + "attention_mask_select kernel_llama_attention_mask_select" + "attention_softmax kernel_llama_attention_softmax" + "attention_output kernel_llama_attention_output" + "output_projection kernel_llama_output_projection" + "residual_add kernel_llama_residual_add" + "ffn_rmsnorm kernel_llama_ffn_rmsnorm" + "gate_up_projection kernel_llama_gate_up_projection" + "swiglu kernel_llama_swiglu" + "down_projection kernel_llama_down_projection" + "final_rmsnorm kernel_llama_final_rmsnorm" + "lm_head_projection kernel_llama_lm_head_projection" +) + +count_pattern() { + local pattern=$1 + local file=$2 + if [ ! -s "$file" ]; then + echo 0 + return + fi + grep -Ec "$pattern" "$file" 2>/dev/null +} + +pick_artifact() { + local tag=$1 + if [ -s "$OUT/${tag}_debuf_mr.mlir" ] && + grep -q "linalg.generic" "$OUT/${tag}_debuf_mr.mlir"; then + echo "$OUT/${tag}_debuf_mr.mlir" + elif [ -s "$OUT/${tag}_debuf.mlir" ] && + grep -q "linalg.generic" "$OUT/${tag}_debuf.mlir"; then + echo "$OUT/${tag}_debuf.mlir" + elif [ -s "$OUT/${tag}_linalg.mlir" ]; then + echo "$OUT/${tag}_linalg.mlir" + else + echo "$OUT/${tag}.mlir" + fi +} + +summarize_one() { + local tag=$1 + local status artifact lg tensor memref loops ifs + + if [ ! -s "$OUT/${tag}.mlir" ]; then + printf "%-22s %-17s %7s %7s %7s %7s %7s %s\n" \ + "$tag" "cgeist-fail" "-" "-" "-" "-" "-" "$OUT/${tag}.cgeist.err" + return + fi + if [ ! -s "$OUT/${tag}_linalg.mlir" ]; then + printf "%-22s %-17s %7s %7s %7s %7s %7s %s\n" \ + "$tag" "raise-fail" "-" "-" "-" "-" "-" "$OUT/${tag}.raise.err" + return + fi + + artifact=$(pick_artifact "$tag") + lg=$(count_pattern "linalg\\.generic" "$artifact") + tensor=$(count_pattern "tensor<" "$artifact") + memref=$(count_pattern "memref<" "$artifact") + loops=$(count_pattern "affine\\.for|scf\\.for" "$artifact") + ifs=$(count_pattern "affine\\.if|scf\\.if" "$artifact") + + if [ "$lg" -gt 0 ] && [ "$tensor" -gt 0 ]; then + status="tensor-linalg" + elif [ "$lg" -gt 0 ]; then + status="memref-linalg" + else + status="no-linalg" + fi + if [ "$loops" -gt 0 ]; then + status="${status}+loops" + fi + if [ "$ifs" -gt 0 ]; then + status="${status}+if" + fi + + printf "%-22s %-17s %7s %7s %7s %7s %7s %s\n" \ + "$tag" "$status" "$lg" "$tensor" "$memref" "$loops" "$ifs" "$artifact" +} + +SUMMARY=$OUT/summary.txt +{ + printf "%-22s %-17s %7s %7s %7s %7s %7s %s\n" \ + "op" "status" "linalg" "tensor" "memref" "loops" "ifs" "artifact" +} > "$SUMMARY" + +for entry in "${KERNELS[@]}"; do + read -r tag fn <<<"$entry" + + echo "[$tag] cgeist..." + timeout 60 cgeist "$SRC" --function="$fn" --resource-dir=/usr/lib/clang/14 \ + --raise-scf-to-affine -fPIC -S \ + -o "$OUT/${tag}.mlir" 2>"$OUT/${tag}.cgeist.err" + if [ ! -s "$OUT/${tag}.mlir" ]; then + echo " cgeist FAILED" + rm -f "$OUT/${tag}.mlir" + summarize_one "$tag" >> "$SUMMARY" + continue + fi + + echo "[$tag] raise..." + timeout 60 polygeist-opt --select-func=func-name="$fn" \ + --remove-iter-args --affine-parallelize \ + --raise-affine-to-linalg-pipeline --lower-polygeist-submap \ + "$OUT/${tag}.mlir" -o "$OUT/${tag}_linalg.mlir" \ + 2>"$OUT/${tag}.raise.err" + if [ ! -s "$OUT/${tag}_linalg.mlir" ]; then + echo " raise FAILED" + rm -f "$OUT/${tag}_linalg.mlir" + summarize_one "$tag" >> "$SUMMARY" + continue + fi + + echo "[$tag] debuf v2..." + timeout 60 polygeist-opt --linalg-debufferize \ + "$OUT/${tag}_linalg.mlir" -o "$OUT/${tag}_debuf.mlir" \ + 2>"$OUT/${tag}.debuf.err" + if [ ! -s "$OUT/${tag}_debuf.mlir" ]; then + echo " v2 debuf FAILED" + rm -f "$OUT/${tag}_debuf.mlir" + fi + + echo "[$tag] debuf multi-root..." + timeout 60 polygeist-opt --linalg-debufferize=use-multi-root=true \ + "$OUT/${tag}_linalg.mlir" -o "$OUT/${tag}_debuf_mr.mlir" \ + 2>"$OUT/${tag}.debuf_mr.err" + if [ ! -s "$OUT/${tag}_debuf_mr.mlir" ]; then + echo " multi-root debuf FAILED" + rm -f "$OUT/${tag}_debuf_mr.mlir" + fi + + summarize_one "$tag" >> "$SUMMARY" +done + +tag=extended_forward +fn=kernel_llama2_extended_forward + +echo "[$tag] cgeist..." +timeout "$EXTENDED_TIMEOUT" cgeist "$EXTENDED_SRC" --function="$fn" --resource-dir=/usr/lib/clang/14 \ + --raise-scf-to-affine -fPIC -S \ + -o "$OUT/${tag}.mlir" 2>"$OUT/${tag}.cgeist.err" +if [ ! -s "$OUT/${tag}.mlir" ]; then + echo " cgeist FAILED" + rm -f "$OUT/${tag}.mlir" + summarize_one "$tag" >> "$SUMMARY" +else + echo "[$tag] raise..." + timeout "$EXTENDED_TIMEOUT" polygeist-opt --select-func=func-name="$fn" \ + --remove-iter-args --affine-parallelize \ + --raise-affine-to-linalg-pipeline --lower-polygeist-submap \ + "$OUT/${tag}.mlir" -o "$OUT/${tag}_linalg.mlir" \ + 2>"$OUT/${tag}.raise.err" + if [ ! -s "$OUT/${tag}_linalg.mlir" ]; then + echo " raise FAILED" + rm -f "$OUT/${tag}_linalg.mlir" + summarize_one "$tag" >> "$SUMMARY" + else + echo "[$tag] debuf v2..." + timeout "$EXTENDED_TIMEOUT" polygeist-opt --linalg-debufferize \ + "$OUT/${tag}_linalg.mlir" -o "$OUT/${tag}_debuf.mlir" \ + 2>"$OUT/${tag}.debuf.err" + if [ ! -s "$OUT/${tag}_debuf.mlir" ]; then + echo " v2 debuf FAILED" + rm -f "$OUT/${tag}_debuf.mlir" + fi + + echo "[$tag] debuf multi-root..." + timeout "$EXTENDED_TIMEOUT" polygeist-opt --linalg-debufferize=use-multi-root=true \ + "$OUT/${tag}_linalg.mlir" -o "$OUT/${tag}_debuf_mr.mlir" \ + 2>"$OUT/${tag}.debuf_mr.err" + if [ ! -s "$OUT/${tag}_debuf_mr.mlir" ]; then + echo " multi-root debuf FAILED" + rm -f "$OUT/${tag}_debuf_mr.mlir" + fi + + summarize_one "$tag" >> "$SUMMARY" + fi +fi + +echo "Done. Output in $OUT" +cat "$SUMMARY" diff --git a/scripts/correctness/bake_llmc_mlir.sh b/scripts/correctness/bake_llmc_mlir.sh new file mode 100755 index 000000000000..8f9a38e67fc1 --- /dev/null +++ b/scripts/correctness/bake_llmc_mlir.sh @@ -0,0 +1,73 @@ +#!/bin/bash +# Bake karpathy/llm.c per-function MLIR files in the naming convention the +# IR viewer expects: +# /tmp/llmc_mlir/.mlir (post-cgeist affine MLIR) +# /tmp/llmc_mlir/_linalg.mlir (after raise + lower-submap) +# /tmp/llmc_mlir/_debuf.mlir (default v2 debufferize) +# /tmp/llmc_mlir/_debuf_mr.mlir (multi-root debufferize) +# +# Target the leaf forward/backward kernels in train_gpt2.c — the building +# blocks of GPT-2 inference + training. Skip the tiled matmul_forward in +# favour of matmul_forward_naive (the 4-loop reference). +set +e +_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$_CORRECTNESS_DIR/common_env.sh" +SRC=$REPO_ROOT/third_party/llm.c/train_gpt2.c +OUT=/tmp/llmc_mlir +mkdir -p $OUT + +# Format: +KERNELS=( + "encoder-fwd encoder_forward" + "encoder-bwd encoder_backward" + "layernorm-fwd layernorm_forward" + "layernorm-bwd layernorm_backward" + "matmul-fwd-naive matmul_forward_naive" + "matmul-bwd matmul_backward" + "attention-fwd attention_forward" + "attention-bwd attention_backward" + "gelu-fwd gelu_forward" + "gelu-bwd gelu_backward" + "residual-fwd residual_forward" + "residual-bwd residual_backward" + "softmax-fwd softmax_forward" + "crossentropy-fwd crossentropy_forward" + "crossentropy-softmax-bwd crossentropy_softmax_backward" +) + +for entry in "${KERNELS[@]}"; do + read tag fn <<<"$entry" + + echo "[$tag] cgeist..." + timeout 60 cgeist "$SRC" --function=$fn --resource-dir=/usr/lib/clang/14 \ + --raise-scf-to-affine -fPIC -S \ + -o $OUT/${tag}.mlir 2>$OUT/${tag}.cgeist.err + if [ ! -s $OUT/${tag}.mlir ]; then + echo " cgeist FAILED"; rm -f $OUT/${tag}.mlir; continue + fi + + # NOTE: skip --select-func — cgeist's --function=$fn already isolated the + # kernel, and --select-func strips extern declarations like @tanhf / @logf + # / @expf that the math-heavy kernels call into. + echo "[$tag] raise..." + timeout 60 polygeist-opt \ + --remove-iter-args --affine-parallelize \ + --raise-affine-to-linalg-pipeline --lower-polygeist-submap \ + $OUT/${tag}.mlir -o $OUT/${tag}_linalg.mlir 2>$OUT/${tag}.raise.err + [ ! -s $OUT/${tag}_linalg.mlir ] && { echo " raise FAILED"; rm -f $OUT/${tag}_linalg.mlir; continue; } + + echo "[$tag] debuf v2..." + timeout 60 polygeist-opt --linalg-debufferize \ + $OUT/${tag}_linalg.mlir -o $OUT/${tag}_debuf.mlir 2>$OUT/${tag}.debuf.err + [ ! -s $OUT/${tag}_debuf.mlir ] && { echo " v2 debuf FAILED"; rm -f $OUT/${tag}_debuf.mlir; } + + echo "[$tag] debuf multi-root..." + timeout 60 polygeist-opt --linalg-debufferize=use-multi-root=true \ + $OUT/${tag}_linalg.mlir -o $OUT/${tag}_debuf_mr.mlir 2>$OUT/${tag}.debuf_mr.err + if [ ! -s $OUT/${tag}_debuf_mr.mlir ]; then + echo "// Multi-root --linalg-debufferize FAILED. See ${tag}.debuf_mr.err." > $OUT/${tag}_debuf_mr.mlir + fi +done + +echo "Done. Output in $OUT/" +ls $OUT/*.mlir | wc -l diff --git a/scripts/correctness/bake_machsuite_mlir.sh b/scripts/correctness/bake_machsuite_mlir.sh new file mode 100755 index 000000000000..865f38df9600 --- /dev/null +++ b/scripts/correctness/bake_machsuite_mlir.sh @@ -0,0 +1,75 @@ +#!/bin/bash +# Bake MachSuite per-kernel MLIR files in the naming convention the IR +# viewer expects: +# /tmp/machsuite_mlir/.mlir (post-cgeist affine MLIR) +# /tmp/machsuite_mlir/_linalg.mlir (after raise + lower-submap) +# /tmp/machsuite_mlir/_debuf.mlir (default v2 debufferize) +# /tmp/machsuite_mlir/_debuf_mr.mlir (multi-root debufferize) +# +# Kernels that don't produce a given stage are skipped silently — viewer's +# `if file.exists():` branches handle missing files gracefully. +set +e +_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$_CORRECTNESS_DIR/common_env.sh" +ROOT=$REPO_ROOT/third_party/MachSuite +COMMON=$ROOT/common +OUT=/tmp/machsuite_mlir +mkdir -p $OUT + +# Format: (same map as machsuite_sweep.sh) +KERNELS=( + "aes aes/aes aes256_encrypt_ecb" + "backprop backprop/backprop backprop" + "bfs-bulk bfs/bulk bfs" + "bfs-queue bfs/queue bfs" + "fft-strided fft/strided fft" + "fft-transpose fft/transpose fft1D_512" + "gemm-ncubed gemm/ncubed gemm" + "gemm-blocked gemm/blocked bbgemm" + "kmp kmp/kmp kmp" + "md-grid md/grid md" + "md-knn md/knn md_kernel" + "nw nw/nw needwun" + "sort-merge sort/merge ms_mergesort" + "sort-radix sort/radix ss_sort" + "spmv-crs spmv/crs spmv" + "spmv-ellpack spmv/ellpack ellpack" + "stencil2d stencil/stencil2d stencil" + "stencil3d stencil/stencil3d stencil3d" + "viterbi viterbi/viterbi viterbi" +) + +for entry in "${KERNELS[@]}"; do + read tag subdir fn <<<"$entry" + D=$ROOT/$subdir + src=$(ls $D/*.c 2>/dev/null | grep -vE 'local_support|generate' | head -1) + [ -z "$src" ] && continue + + echo "[$tag] cgeist..." + cgeist "$src" --function=$fn --resource-dir=/usr/lib/clang/14 \ + -I$COMMON -I$D --raise-scf-to-affine -fPIC -S -o $OUT/${tag}.mlir \ + 2>$OUT/${tag}.cgeist.err + [ ! -s $OUT/${tag}.mlir ] && { echo " cgeist FAILED"; rm -f $OUT/${tag}.mlir; continue; } + + echo "[$tag] raise..." + timeout 60 polygeist-opt --select-func=func-name=$fn \ + --remove-iter-args --affine-parallelize \ + --raise-affine-to-linalg-pipeline --lower-polygeist-submap \ + $OUT/${tag}.mlir -o $OUT/${tag}_linalg.mlir 2>$OUT/${tag}.raise.err + [ ! -s $OUT/${tag}_linalg.mlir ] && { echo " raise FAILED"; rm -f $OUT/${tag}_linalg.mlir; continue; } + + echo "[$tag] debuf v2..." + timeout 60 polygeist-opt --linalg-debufferize \ + $OUT/${tag}_linalg.mlir -o $OUT/${tag}_debuf.mlir 2>$OUT/${tag}.debuf.err + [ ! -s $OUT/${tag}_debuf.mlir ] && { echo " v2 debuf FAILED"; rm -f $OUT/${tag}_debuf.mlir; } + + echo "[$tag] debuf multi-root..." + timeout 60 polygeist-opt --linalg-debufferize=use-multi-root=true \ + $OUT/${tag}_linalg.mlir -o $OUT/${tag}_debuf_mr.mlir 2>$OUT/${tag}.debuf_mr.err + if [ ! -s $OUT/${tag}_debuf_mr.mlir ]; then + echo "// Multi-root --linalg-debufferize FAILED. See ${tag}.debuf_mr.err." > $OUT/${tag}_debuf_mr.mlir + fi +done + +echo "Done. Output in $OUT/" +ls $OUT/ | head -20 diff --git a/scripts/correctness/bake_npb_mlir.sh b/scripts/correctness/bake_npb_mlir.sh new file mode 100755 index 000000000000..d22934047e4c --- /dev/null +++ b/scripts/correctness/bake_npb_mlir.sh @@ -0,0 +1,59 @@ +#!/bin/bash +# Bake polybenchified-NPB per-kernel MLIR files in the naming the IR +# viewer expects: +# /tmp/npb_mlir/.mlir (post-cgeist affine MLIR) +# /tmp/npb_mlir/_linalg.mlir (after raise + lower-submap) +# /tmp/npb_mlir/_debuf.mlir (default v2 debufferize) +# /tmp/npb_mlir/_debuf_mr.mlir (multi-root debufferize) +set +e +_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$_CORRECTNESS_DIR/common_env.sh" +DIR=$REPO_ROOT/third_party/NPB-polybenchified +OUT=/tmp/npb_mlir +mkdir -p $OUT + +# Format: +KERNELS=( + "bt-add bt_add bt_add.c" + "ft-evolve ft_evolve ft_evolve.c" + "lu-l2norm lu_l2norm lu_l2norm.c" + "mg-psinv mg_psinv mg_psinv.c" + "mg-resid mg_resid mg_resid.c" + "mg-norm2u3 mg_norm2u3 mg_norm2u3.c" + "mg-rprj3 mg_rprj3 mg_rprj3.c" +) + +for entry in "${KERNELS[@]}"; do + read tag fn srcname <<<"$entry" + src="$DIR/$srcname" + [ ! -f "$src" ] && { echo "$tag: missing $src"; continue; } + + echo "[$tag] cgeist..." + timeout 60 cgeist "$src" --function=$fn --resource-dir=/usr/lib/clang/14 \ + --raise-scf-to-affine -fPIC -S -o $OUT/${tag}.mlir 2>$OUT/${tag}.cgeist.err + if [ ! -s $OUT/${tag}.mlir ]; then + echo " cgeist FAIL"; rm -f $OUT/${tag}.mlir; continue + fi + + echo "[$tag] raise..." + timeout 60 polygeist-opt --select-func=func-name=$fn \ + --remove-iter-args --affine-parallelize \ + --raise-affine-to-linalg-pipeline --lower-polygeist-submap \ + $OUT/${tag}.mlir -o $OUT/${tag}_linalg.mlir 2>$OUT/${tag}.raise.err + [ ! -s $OUT/${tag}_linalg.mlir ] && { echo " raise FAIL"; rm -f $OUT/${tag}_linalg.mlir; continue; } + + echo "[$tag] debuf v2..." + timeout 60 polygeist-opt --linalg-debufferize \ + $OUT/${tag}_linalg.mlir -o $OUT/${tag}_debuf.mlir 2>$OUT/${tag}.debuf.err + [ ! -s $OUT/${tag}_debuf.mlir ] && { rm -f $OUT/${tag}_debuf.mlir; } + + echo "[$tag] debuf multi-root..." + timeout 60 polygeist-opt --linalg-debufferize=use-multi-root=true \ + $OUT/${tag}_linalg.mlir -o $OUT/${tag}_debuf_mr.mlir 2>$OUT/${tag}.debuf_mr.err + if [ ! -s $OUT/${tag}_debuf_mr.mlir ]; then + echo "// Multi-root --linalg-debufferize FAILED. See ${tag}.debuf_mr.err." > $OUT/${tag}_debuf_mr.mlir + fi +done + +echo "Done. Output in $OUT/" +ls $OUT/ | head -30 diff --git a/scripts/correctness/bake_polybenchgpu_extracted_mlir.sh b/scripts/correctness/bake_polybenchgpu_extracted_mlir.sh new file mode 100755 index 000000000000..c7fe792db856 --- /dev/null +++ b/scripts/correctness/bake_polybenchgpu_extracted_mlir.sh @@ -0,0 +1,68 @@ +#!/bin/bash +# Bake the polybenchGpu-extracted kernels (currently conv2d, conv3d) into +# the IR viewer's naming convention: +# /tmp/pbgpu_extracted_mlir/.mlir (post-cgeist affine MLIR) +# /tmp/pbgpu_extracted_mlir/_linalg.mlir (after raise + lower-submap) +# /tmp/pbgpu_extracted_mlir/_debuf.mlir (v2 debufferize) +# /tmp/pbgpu_extracted_mlir/_debuf_mr.mlir (multi-root debuf) +# +# These kernels were extracted from the original polybenchGpu/OpenMP .c +# files so that cgeist doesn't inline main→init→kernel and constant-fold +# the conv body away. Each .c here has ONLY the kernel function, with +# A/B as explicit parameters and sizes baked in via #define. The lift +# produces clean linalg.generic ops with ins(A) outs(B). See the +# directory's conv2d.c docstring for the longer explanation. +set +e +_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$_CORRECTNESS_DIR/common_env.sh" +DIR=$REPO_ROOT/third_party/polybenchGpu-extracted +OUT=/tmp/pbgpu_extracted_mlir +mkdir -p $OUT + +# Format: +# Phase 2 dtype expansion: f32 / i32 / i16 variants of conv2d alongside the +# original f64. They use the same template + canonical defn library but the +# rewriter dispatches to dtype-suffixed @cudnnConvolution2D_9tap_. +# f16 / bf16 sources exist (conv2d_f16.c) but cgeist asserts on _Float16 — +# see the cgeist-dtype-gap blocker; we don't bake them here so the explorer +# doesn't show a stale crash output for those tags. +KERNELS=( + "conv2d kernel_conv2d conv2d.c" + "conv2d_f32 kernel_conv2d conv2d_f32.c" + "conv2d_i32 kernel_conv2d conv2d_i32.c" + "conv2d_i16 kernel_conv2d conv2d_i16.c" + "conv3d kernel_conv2d conv3d.c" +) + +for entry in "${KERNELS[@]}"; do + read tag fn srcname <<<"$entry" + src="$DIR/$srcname" + [ ! -f "$src" ] && { echo "$tag: missing $src"; continue; } + + echo "[$tag] cgeist..." + timeout 60 cgeist "$src" --function=$fn --resource-dir=/usr/lib/clang/14 \ + --raise-scf-to-affine -fPIC -S -o $OUT/${tag}.mlir 2>$OUT/${tag}.cgeist.err + [ ! -s $OUT/${tag}.mlir ] && { echo " cgeist FAILED"; rm -f $OUT/${tag}.mlir; continue; } + + echo "[$tag] raise..." + timeout 60 polygeist-opt --select-func=func-name=$fn \ + --remove-iter-args --affine-parallelize \ + --raise-affine-to-linalg-pipeline --lower-polygeist-submap \ + $OUT/${tag}.mlir -o $OUT/${tag}_linalg.mlir 2>$OUT/${tag}.raise.err + [ ! -s $OUT/${tag}_linalg.mlir ] && { echo " raise FAILED"; rm -f $OUT/${tag}_linalg.mlir; continue; } + + echo "[$tag] debuf v2..." + timeout 60 polygeist-opt --linalg-debufferize \ + $OUT/${tag}_linalg.mlir -o $OUT/${tag}_debuf.mlir 2>$OUT/${tag}.debuf.err + [ ! -s $OUT/${tag}_debuf.mlir ] && { rm -f $OUT/${tag}_debuf.mlir; } + + echo "[$tag] debuf multi-root..." + timeout 60 polygeist-opt --linalg-debufferize=use-multi-root=true \ + $OUT/${tag}_linalg.mlir -o $OUT/${tag}_debuf_mr.mlir 2>$OUT/${tag}.debuf_mr.err + if [ ! -s $OUT/${tag}_debuf_mr.mlir ]; then + echo "// Multi-root --linalg-debufferize FAILED. See ${tag}.debuf_mr.err." > $OUT/${tag}_debuf_mr.mlir + fi +done + +echo "Done. Output in $OUT/" +ls $OUT/ | head -20 diff --git a/scripts/correctness/bake_polybenchgpu_mlir.sh b/scripts/correctness/bake_polybenchgpu_mlir.sh new file mode 100755 index 000000000000..36df001ba61c --- /dev/null +++ b/scripts/correctness/bake_polybenchgpu_mlir.sh @@ -0,0 +1,93 @@ +#!/bin/bash +# Bake polybenchGpu (OpenMP variant) per-kernel MLIR files in the naming +# convention the IR viewer expects: +# /tmp/pbgpu_mlir/.mlir (post-cgeist affine MLIR) +# /tmp/pbgpu_mlir/_linalg.mlir (after raise + lower-submap) +# /tmp/pbgpu_mlir/_debuf.mlir (default v2 debufferize) +# /tmp/pbgpu_mlir/_debuf_mr.mlir (multi-root debufferize) +set +e +_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$_CORRECTNESS_DIR/common_env.sh" +ROOT=$REPO_ROOT/third_party/polybenchGpu/OpenMP +UTIL=$ROOT/utilities +OUT=/tmp/pbgpu_mlir +mkdir -p $OUT + +# Format: +KERNELS=( + "correlation datamining/correlation kernel_correlation" + "covariance datamining/covariance kernel_covariance" + "2mm linear-algebra/kernels/2mm kernel_2mm" + "3mm linear-algebra/kernels/3mm kernel_3mm" + "atax linear-algebra/kernels/atax kernel_atax" + "bicg linear-algebra/kernels/bicg kernel_bicg" + "cholesky linear-algebra/kernels/cholesky kernel_cholesky" + "doitgen linear-algebra/kernels/doitgen kernel_doitgen" + "gemm linear-algebra/kernels/gemm kernel_gemm" + "gemver linear-algebra/kernels/gemver kernel_gemver" + "gesummv linear-algebra/kernels/gesummv kernel_gesummv" + "mvt linear-algebra/kernels/mvt kernel_mvt" + "symm linear-algebra/kernels/symm kernel_symm" + "syr2k linear-algebra/kernels/syr2k kernel_syr2k" + "syrk linear-algebra/kernels/syrk kernel_syrk" + "trisolv linear-algebra/kernels/trisolv kernel_trisolv" + "trmm linear-algebra/kernels/trmm kernel_trmm" + "durbin linear-algebra/solvers/durbin kernel_durbin" + "dynprog linear-algebra/solvers/dynprog kernel_dynprog" + "gramschmidt linear-algebra/solvers/gramschmidt kernel_gramschmidt" + "lu linear-algebra/solvers/lu kernel_lu" + "ludcmp linear-algebra/solvers/ludcmp kernel_ludcmp" + "floyd-warshall medley/floyd-warshall kernel_floyd_warshall" + "reg_detect medley/reg_detect kernel_reg_detect" + "adi stencils/adi kernel_adi" + "convolution-2d stencils/convolution-2d kernel_conv2d" + "convolution-3d stencils/convolution-3d kernel_conv2d" + "fdtd-2d stencils/fdtd-2d kernel_fdtd_2d" + "fdtd-apml stencils/fdtd-apml kernel_fdtd_apml" + "jacobi-1d-imper stencils/jacobi-1d-imper kernel_jacobi_1d_imper" + "jacobi-2d-imper stencils/jacobi-2d-imper kernel_jacobi_2d_imper" + "seidel-2d stencils/seidel-2d kernel_seidel_2d" +) + +for entry in "${KERNELS[@]}"; do + read tag subdir fn <<<"$entry" + D=$ROOT/$subdir + src=$(ls $D/*.c 2>/dev/null | head -1) + [ -z "$src" ] && { echo "$tag: missing source in $D"; continue; } + + # polybenchGpu files contain BOTH the kernel and main(). We use + # --function=* so cgeist emits every function, plus --no-inline so the + # inliner doesn't fold init_array's stores into kernel reads (which + # would let scal-rep delete the loads and break perfect nesting). The + # raise pass then operates on the still-isolated kernel via + # --select-func. + echo "[$tag] cgeist..." + timeout 60 cgeist "$src" '--function=*' --no-inline --resource-dir=/usr/lib/clang/14 \ + -I$UTIL -I$D --raise-scf-to-affine -fPIC -S \ + -o $OUT/${tag}.mlir 2>$OUT/${tag}.cgeist.err + if [ ! -s $OUT/${tag}.mlir ]; then + echo " cgeist FAILED"; rm -f $OUT/${tag}.mlir; continue + fi + + echo "[$tag] raise..." + timeout 60 polygeist-opt --select-func="func-name=$fn" \ + --remove-iter-args --affine-parallelize \ + --raise-affine-to-linalg-pipeline --lower-polygeist-submap \ + $OUT/${tag}.mlir -o $OUT/${tag}_linalg.mlir 2>$OUT/${tag}.raise.err + [ ! -s $OUT/${tag}_linalg.mlir ] && { echo " raise FAILED"; rm -f $OUT/${tag}_linalg.mlir; continue; } + + echo "[$tag] debuf v2..." + timeout 60 polygeist-opt --linalg-debufferize \ + $OUT/${tag}_linalg.mlir -o $OUT/${tag}_debuf.mlir 2>$OUT/${tag}.debuf.err + [ ! -s $OUT/${tag}_debuf.mlir ] && { echo " v2 debuf FAILED"; rm -f $OUT/${tag}_debuf.mlir; } + + echo "[$tag] debuf multi-root..." + timeout 60 polygeist-opt --linalg-debufferize=use-multi-root=true \ + $OUT/${tag}_linalg.mlir -o $OUT/${tag}_debuf_mr.mlir 2>$OUT/${tag}.debuf_mr.err + if [ ! -s $OUT/${tag}_debuf_mr.mlir ]; then + echo "// Multi-root --linalg-debufferize FAILED. See ${tag}.debuf_mr.err." > $OUT/${tag}_debuf_mr.mlir + fi +done + +echo "Done. Output in $OUT/" +ls $OUT/ | head -30 diff --git a/scripts/correctness/bake_stencil_conv2d_mlir.sh b/scripts/correctness/bake_stencil_conv2d_mlir.sh new file mode 100755 index 000000000000..caa1a765401c --- /dev/null +++ b/scripts/correctness/bake_stencil_conv2d_mlir.sh @@ -0,0 +1,134 @@ +#!/bin/bash +# Bake image/PDE-style 2D stencil fixtures and run the kernel matcher. +# +# Outputs: +# /tmp/stencil_conv2d_mlir/.mlir +# /tmp/stencil_conv2d_mlir/_linalg.mlir +# /tmp/stencil_conv2d_mlir/_debuf.mlir +# /tmp/stencil_conv2d_mlir/_debuf_mr.mlir +# /tmp/stencil_conv2d_mlir/_matched.mlir +# /tmp/stencil_conv2d_mlir/summary.txt +set +e + +_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$_CORRECTNESS_DIR/common_env.sh" + +SRC=$REPO_ROOT/third_party/cnn-extracted/stencil_conv2d_3x3.c +OUT=${POLYGEIST_STENCIL_CONV2D_OUT:-/tmp/stencil_conv2d_mlir} +mkdir -p "$OUT" +rm -f "$OUT"/* + +if ! "$PYTHON" -c "import egglog" >/dev/null 2>&1; then + if /usr/bin/python3 -c "import egglog" >/dev/null 2>&1; then + PYTHON=/usr/bin/python3 + fi +fi + +# Format: +KERNELS=( + "box3x3 kernel_stencil_box3x3" + "gaussian3x3 kernel_stencil_gaussian3x3" + "sobel_x3x3 kernel_stencil_sobel_x3x3" + "sobel_y3x3 kernel_stencil_sobel_y3x3" + "laplacian4_3x3 kernel_stencil_laplacian4_3x3" + "laplacian8_3x3 kernel_stencil_laplacian8_3x3" + "sharpen3x3 kernel_stencil_sharpen3x3" + "emboss3x3 kernel_stencil_emboss3x3" + "box5x5 kernel_stencil_box5x5" + "gaussian5x5 kernel_stencil_gaussian5x5" + "sobel_x5x5 kernel_stencil_sobel_x5x5" + "sobel_y5x5 kernel_stencil_sobel_y5x5" + "laplacian5x5 kernel_stencil_laplacian5x5" + "sharpen5x5 kernel_stencil_sharpen5x5" + "emboss5x5 kernel_stencil_emboss5x5" + "box7x7 kernel_stencil_box7x7" +) + +count_pattern() { + local pattern=$1 + local file=$2 + if [ ! -s "$file" ]; then + echo 0 + return + fi + grep -Ec "$pattern" "$file" 2>/dev/null +} + +match_symbol() { + local file=$1 + if [ ! -s "$file" ]; then + echo "-" + return + fi + "$PYTHON" "$SCRIPTS/kernel_match_rewrite.py" "$file" --dry-run \ + 2>&1 | + tee "$file.match.err" | + awk '/match[[:space:]]+body#/ {print $3}' | + paste -sd "," - +} + +summary=$OUT/summary.txt +printf "%-16s %-12s %7s %7s %7s %-36s %s\n" \ + "kernel" "status" "linalg" "loops" "launch" "matched-symbol" "artifact" > "$summary" + +for entry in "${KERNELS[@]}"; do + read -r tag fn <<<"$entry" + echo "[$tag] cgeist..." + timeout 60 cgeist "$SRC" --function="$fn" --resource-dir=/usr/lib/clang/14 \ + --raise-scf-to-affine -fPIC -S \ + -o "$OUT/${tag}.mlir" 2>"$OUT/${tag}.cgeist.err" + if [ ! -s "$OUT/${tag}.mlir" ]; then + printf "%-16s %-12s %7s %7s %7s %-36s %s\n" \ + "$tag" "cgeist-fail" "-" "-" "-" "-" "$OUT/${tag}.cgeist.err" >> "$summary" + echo " cgeist FAILED" + continue + fi + + echo "[$tag] raise..." + timeout 60 polygeist-opt --select-func=func-name="$fn" \ + --remove-iter-args --affine-parallelize \ + --raise-affine-to-linalg-pipeline --lower-polygeist-submap \ + "$OUT/${tag}.mlir" -o "$OUT/${tag}_linalg.mlir" \ + 2>"$OUT/${tag}.raise.err" + if [ ! -s "$OUT/${tag}_linalg.mlir" ]; then + printf "%-16s %-12s %7s %7s %7s %-36s %s\n" \ + "$tag" "raise-fail" "-" "-" "-" "-" "$OUT/${tag}.raise.err" >> "$summary" + echo " raise FAILED" + continue + fi + + echo "[$tag] debuf v2..." + timeout 60 polygeist-opt --linalg-debufferize \ + "$OUT/${tag}_linalg.mlir" -o "$OUT/${tag}_debuf.mlir" \ + 2>"$OUT/${tag}.debuf.err" + [ ! -s "$OUT/${tag}_debuf.mlir" ] && rm -f "$OUT/${tag}_debuf.mlir" + + echo "[$tag] debuf multi-root..." + timeout 60 polygeist-opt --linalg-debufferize=use-multi-root=true \ + "$OUT/${tag}_linalg.mlir" -o "$OUT/${tag}_debuf_mr.mlir" \ + 2>"$OUT/${tag}.debuf_mr.err" + [ ! -s "$OUT/${tag}_debuf_mr.mlir" ] && rm -f "$OUT/${tag}_debuf_mr.mlir" + + match_ir="$OUT/${tag}_linalg.mlir" + if [ -s "$OUT/${tag}_debuf.mlir" ]; then + match_ir="$OUT/${tag}_debuf.mlir" + fi + + "$PYTHON" "$SCRIPTS/kernel_match_rewrite.py" "$match_ir" \ + > "$OUT/${tag}_matched.mlir" 2>"$OUT/${tag}.match.err" + + lg=$(count_pattern "linalg\\.generic" "$match_ir") + loops=$(count_pattern "affine\\.for|scf\\.for" "$match_ir") + launches=$(count_pattern "kernel\\.launch" "$OUT/${tag}_matched.mlir") + sym=$(match_symbol "$match_ir") + [ -z "$sym" ] && sym="-" + status="matched" + [ "$launches" -eq 0 ] && status="no-match" + + printf "%-16s %-12s %7s %7s %7s %-36s %s\n" \ + "$tag" "$status" "$lg" "$loops" "$launches" "$sym" \ + "$match_ir" >> "$summary" +done + +echo "Done. Output in $OUT" +cat "$summary" diff --git a/scripts/correctness/bake_whisper_ops_mlir.sh b/scripts/correctness/bake_whisper_ops_mlir.sh new file mode 100755 index 000000000000..eca0497268ac --- /dev/null +++ b/scripts/correctness/bake_whisper_ops_mlir.sh @@ -0,0 +1,161 @@ +#!/bin/bash +# Bake standalone Whisper/ggml-style operation fixtures into per-function MLIR. +# +# Outputs: +# /tmp/whisper_ops_mlir/.mlir +# /tmp/whisper_ops_mlir/_linalg.mlir +# /tmp/whisper_ops_mlir/_debuf.mlir +# /tmp/whisper_ops_mlir/_debuf_mr.mlir +# /tmp/whisper_ops_mlir/summary.txt +set +e + +_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$_CORRECTNESS_DIR/common_env.sh" + +SRC=$REPO_ROOT/third_party/cnn-extracted/whisper_ops.c +OUT=${POLYGEIST_WHISPER_OPS_OUT:-/tmp/whisper_ops_mlir} +CGEIST_BIN=${CGEIST_BIN:-$REPO_ROOT/build/bin/cgeist} +POLYGEIST_OPT_BIN=${POLYGEIST_OPT_BIN:-$REPO_ROOT/build/bin/polygeist-opt} + +if [ -n "${POLYGEIST_CLANG_RESOURCE_DIR:-}" ]; then + RESOURCE_DIR=$POLYGEIST_CLANG_RESOURCE_DIR +elif [ -d "$REPO_ROOT/llvm-project/build/lib/clang/18" ]; then + RESOURCE_DIR=$REPO_ROOT/llvm-project/build/lib/clang/18 +else + RESOURCE_DIR=/usr/lib/clang/14 +fi + +mkdir -p "$OUT" +rm -f "$OUT"/* + +# Format: +KERNELS=( + "whisper_vec_dot kernel_whisper_vec_dot" + "whisper_vec_softmax kernel_whisper_vec_softmax" + "whisper_softmax_full kernel_whisper_softmax_full" + "whisper_rms_norm kernel_whisper_rms_norm" + "whisper_gelu kernel_whisper_gelu" + "whisper_conv1d kernel_whisper_conv1d" +) + +count_pattern() { + local pattern=$1 + local file=$2 + if [ ! -s "$file" ]; then + echo 0 + return + fi + grep -Ec "$pattern" "$file" 2>/dev/null +} + +pick_artifact() { + local tag=$1 + if [ -s "$OUT/${tag}_debuf_mr.mlir" ] && + grep -q "linalg.generic" "$OUT/${tag}_debuf_mr.mlir"; then + echo "$OUT/${tag}_debuf_mr.mlir" + elif [ -s "$OUT/${tag}_debuf.mlir" ] && + grep -q "linalg.generic" "$OUT/${tag}_debuf.mlir"; then + echo "$OUT/${tag}_debuf.mlir" + elif [ -s "$OUT/${tag}_linalg.mlir" ]; then + echo "$OUT/${tag}_linalg.mlir" + else + echo "$OUT/${tag}.mlir" + fi +} + +summarize_one() { + local tag=$1 + local status artifact lg tensor memref loops ifs + + if [ ! -s "$OUT/${tag}.mlir" ]; then + printf "%-24s %-18s %7s %7s %7s %7s %7s %s\n" \ + "$tag" "cgeist-fail" "-" "-" "-" "-" "-" "$OUT/${tag}.cgeist.err" + return + fi + if [ ! -s "$OUT/${tag}_linalg.mlir" ]; then + printf "%-24s %-18s %7s %7s %7s %7s %7s %s\n" \ + "$tag" "raise-fail" "-" "-" "-" "-" "-" "$OUT/${tag}.raise.err" + return + fi + + artifact=$(pick_artifact "$tag") + lg=$(count_pattern "linalg\\.generic" "$artifact") + tensor=$(count_pattern "tensor<" "$artifact") + memref=$(count_pattern "memref<" "$artifact") + loops=$(count_pattern "affine\\.for|scf\\.for" "$artifact") + ifs=$(count_pattern "affine\\.if|scf\\.if" "$artifact") + + if [ "$lg" -gt 0 ] && [ "$tensor" -gt 0 ]; then + status="tensor-linalg" + elif [ "$lg" -gt 0 ]; then + status="memref-linalg" + else + status="no-linalg" + fi + if [ "$loops" -gt 0 ]; then + status="${status}+loops" + fi + if [ "$ifs" -gt 0 ]; then + status="${status}+if" + fi + + printf "%-24s %-18s %7s %7s %7s %7s %7s %s\n" \ + "$tag" "$status" "$lg" "$tensor" "$memref" "$loops" "$ifs" "$artifact" +} + +SUMMARY=$OUT/summary.txt +{ + printf "%-24s %-18s %7s %7s %7s %7s %7s %s\n" \ + "op" "status" "linalg" "tensor" "memref" "loops" "ifs" "artifact" +} > "$SUMMARY" + +for entry in "${KERNELS[@]}"; do + read -r tag fn <<<"$entry" + + echo "[$tag] cgeist..." + timeout 60 "$CGEIST_BIN" "$SRC" --function="$fn" \ + --resource-dir="$RESOURCE_DIR" --raise-scf-to-affine -fPIC -std=gnu11 -S \ + -o "$OUT/${tag}.mlir" 2>"$OUT/${tag}.cgeist.err" + if [ ! -s "$OUT/${tag}.mlir" ]; then + echo " cgeist FAILED" + rm -f "$OUT/${tag}.mlir" + summarize_one "$tag" >> "$SUMMARY" + continue + fi + + echo "[$tag] raise..." + timeout 60 "$POLYGEIST_OPT_BIN" \ + --remove-iter-args --affine-parallelize \ + --raise-affine-to-linalg-pipeline --lower-polygeist-submap \ + "$OUT/${tag}.mlir" -o "$OUT/${tag}_linalg.mlir" \ + 2>"$OUT/${tag}.raise.err" + if [ ! -s "$OUT/${tag}_linalg.mlir" ]; then + echo " raise FAILED" + rm -f "$OUT/${tag}_linalg.mlir" + summarize_one "$tag" >> "$SUMMARY" + continue + fi + + echo "[$tag] debuf v2..." + timeout 60 "$POLYGEIST_OPT_BIN" --linalg-debufferize \ + "$OUT/${tag}_linalg.mlir" -o "$OUT/${tag}_debuf.mlir" \ + 2>"$OUT/${tag}.debuf.err" + if [ ! -s "$OUT/${tag}_debuf.mlir" ]; then + echo " v2 debuf FAILED" + rm -f "$OUT/${tag}_debuf.mlir" + fi + + echo "[$tag] debuf multi-root..." + timeout 60 "$POLYGEIST_OPT_BIN" --linalg-debufferize=use-multi-root=true \ + "$OUT/${tag}_linalg.mlir" -o "$OUT/${tag}_debuf_mr.mlir" \ + 2>"$OUT/${tag}.debuf_mr.err" + if [ ! -s "$OUT/${tag}_debuf_mr.mlir" ]; then + echo " multi-root debuf FAILED" + rm -f "$OUT/${tag}_debuf_mr.mlir" + fi + + summarize_one "$tag" >> "$SUMMARY" +done + +echo "Done. Output in $OUT" +cat "$SUMMARY" diff --git a/scripts/correctness/batchnorm_batched_jetson_harness.c b/scripts/correctness/batchnorm_batched_jetson_harness.c new file mode 100644 index 000000000000..1266baf446e2 --- /dev/null +++ b/scripts/correctness/batchnorm_batched_jetson_harness.c @@ -0,0 +1,111 @@ +/* batchnorm_batched_jetson_harness.c — Jetson harness for batched + * per-channel batchnorm (inference). */ +#include +#include +#include +#include +#include + +#if defined(LARGE_DATASET) +# define B 32 +# define C 64 +# define H 56 +# define W 56 +#elif defined(MINI_DATASET) +# define B 4 +# define C 8 +# define H 32 +# define W 32 +#endif +#ifndef B +# define B 4 +#endif +#ifndef C +# define C 8 +#endif +#ifndef H +# define H 32 +#endif +#ifndef W +# define W 32 +#endif +#define EPS 1e-5f + +extern void kernel_batchnorm_batched_impl( + float *A_b, float *A_a, int64_t A_o, + int64_t A_s0, int64_t A_s1, int64_t A_s2, int64_t A_s3, + int64_t A_t0, int64_t A_t1, int64_t A_t2, int64_t A_t3, + float *S_b, float *S_a, int64_t S_o, int64_t S_sz, int64_t S_st, + float *M_b, float *M_a, int64_t M_o, int64_t M_sz, int64_t M_st, + float *I_b, float *I_a, int64_t I_o, int64_t I_sz, int64_t I_st, + float *Bi_b, float *Bi_a, int64_t Bi_o, int64_t Bi_sz, int64_t Bi_st, + float *O_b, float *O_a, int64_t O_o, + int64_t O_s0, int64_t O_s1, int64_t O_s2, int64_t O_s3, + int64_t O_t0, int64_t O_t1, int64_t O_t2, int64_t O_t3); + +extern void polygeist_cublas_time_begin(void); +extern double polygeist_cublas_time_end_ms(void); + +static void run_kernel(float *A, float *scale, float *mean, + float *inv_std, float *bias, float *Bout) { + polygeist_cublas_time_begin(); + kernel_batchnorm_batched_impl( + A, A, 0, + (int64_t)B, (int64_t)C, (int64_t)H, (int64_t)W, + (int64_t)(C*H*W), (int64_t)(H*W), (int64_t)W, 1, + scale, scale, 0, (int64_t)C, 1, + mean, mean, 0, (int64_t)C, 1, + inv_std, inv_std, 0, (int64_t)C, 1, + bias, bias, 0, (int64_t)C, 1, + Bout, Bout, 0, + (int64_t)B, (int64_t)C, (int64_t)H, (int64_t)W, + (int64_t)(C*H*W), (int64_t)(H*W), (int64_t)W, 1); + double ms = polygeist_cublas_time_end_ms(); + fprintf(stderr, + "POLYGEIST_TIMING: batchnorm_batched B=%d C=%d H=%d W=%d %.3f ms\n", + B, C, H, W, ms); +} + +int main(void) { + size_t nA = (size_t)B*C*H*W; + float *A = (float *)malloc(nA * sizeof(float)); + float *Bout = (float *)malloc(nA * sizeof(float)); + float *scale = (float *)malloc(C * sizeof(float)); + float *mean = (float *)malloc(C * sizeof(float)); + float *invst = (float *)malloc(C * sizeof(float)); + float *bias = (float *)malloc(C * sizeof(float)); + if (!A || !Bout || !scale || !mean || !invst || !bias) { + fprintf(stderr, "alloc failed\n"); return 1; + } + + for (int b = 0; b < B; ++b) + for (int c = 0; c < C; ++c) + for (int i = 0; i < H; ++i) + for (int j = 0; j < W; ++j) + A[((size_t)b*C + c)*H*W + (size_t)i*W + j] = + (float)((b*2 + c*3 + i*5 + j*7) % 29) / 29.0f; + for (int c = 0; c < C; ++c) { + scale[c] = 0.5f + 0.1f * (float)c; + mean[c] = 0.05f * (float)c; + /* var ~ small positive; inv_std = 1/sqrt(var+eps) */ + float var = 0.2f + 0.01f * (float)c; + invst[c] = 1.0f / sqrtf(var + EPS); + bias[c] = 0.01f * (float)c; + } + memset(Bout, 0, nA * sizeof(float)); + + run_kernel(A, scale, mean, invst, bias, Bout); + + double sum = 0; + for (size_t k = 0; k < nA; ++k) sum += Bout[k]; + fprintf(stderr, "CHECKSUM: %.6f over %zu elems\n", sum, nA); + fprintf(stderr, "==BEGIN DUMP_ARRAYS==\n"); + for (size_t k = 0; k < nA; ++k) { + if (k % 19 == 0) fprintf(stderr, "\n"); + fprintf(stderr, "%0.4f ", Bout[k]); + } + fprintf(stderr, "\n==END DUMP_ARRAYS==\n"); + + free(A); free(Bout); free(scale); free(mean); free(invst); free(bias); + return 0; +} diff --git a/scripts/correctness/bicg_jetson_wrapper.c b/scripts/correctness/bicg_jetson_wrapper.c new file mode 100644 index 000000000000..b72c7d3369be --- /dev/null +++ b/scripts/correctness/bicg_jetson_wrapper.c @@ -0,0 +1,41 @@ +/* bicg_jetson_wrapper.c — Jetson timing wrapper. + * + * polybenchGpu kernel_bicg computes: + * s = Aᵀ·r (gemv) + * q = A·p (gemv) + * + * Bridges polybenchGpu's kernel_bicg(nx, ny, A, s, q, p, r) to the + * MLIR-lowered kernel_bicg_impl with memref-descriptor args. + */ +#include +#include + +extern void kernel_bicg_impl( + int nx, int ny, + /* A: 2D memref */ + double *A_b, double *A_a, int64_t A_o, int64_t A_s0, int64_t A_s1, int64_t A_st0, int64_t A_st1, + /* s: 1D memref */ + double *s_b, double *s_a, int64_t s_o, int64_t s_s, int64_t s_st, + /* q: 1D memref */ + double *q_b, double *q_a, int64_t q_o, int64_t q_s, int64_t q_st, + /* p: 1D memref */ + double *p_b, double *p_a, int64_t p_o, int64_t p_s, int64_t p_st, + /* r: 1D memref */ + double *r_b, double *r_a, int64_t r_o, int64_t r_s, int64_t r_st); + +extern void polygeist_cublas_time_begin(void); +extern double polygeist_cublas_time_end_ms(void); + +void kernel_bicg(int nx, int ny, double *A, double *s, double *q, + double *p, double *r) { + polygeist_cublas_time_begin(); + kernel_bicg_impl(nx, ny, + A, A, 0, nx, ny, ny, 1, + s, s, 0, ny, 1, + q, q, 0, nx, 1, + p, p, 0, ny, 1, + r, r, 0, nx, 1); + double ms = polygeist_cublas_time_end_ms(); + fprintf(stderr, "POLYGEIST_TIMING: kernel_bicg nx=%d ny=%d %.3f ms\n", + nx, ny, ms); +} diff --git a/scripts/correctness/build_ce_viewer.py b/scripts/correctness/build_ce_viewer.py new file mode 100644 index 000000000000..1434b6c1b311 --- /dev/null +++ b/scripts/correctness/build_ce_viewer.py @@ -0,0 +1,5082 @@ +#!/usr/bin/env python3 +"""Build a static HTML index of PolyBench kernels where each row deep-links to +Compiler Explorer with the full Polygeist pipeline pre-wired: + + - left column: C source editor + cgeist_aff compiler pane (shows affine MLIR) + - right column: MLIR editor (pre-filled with affine MLIR) + popt_full compiler + pane + Opt Pipeline view (every internal pass clickable) + +Per-kernel HTML pages with raised / debuferized / kernel.launch IR are also +rendered (uses the existing matcher pipeline). + +Inputs: + - PolyBench C sources at $POLYBENCH/tools/cgeist/Test/polybench/.../.c + - Pre-computed affine MLIR at /tmp/polybench_new/.mlir + - Pre-computed linalg MLIR at /tmp/polybench_new/_linalg.mlir + - Pre-computed debuf MLIR at /tmp/polybench_new/_debuf.mlir + +Output: + /tmp/ir_viewer/index.html (entrypoint — open this) + /tmp/ir_viewer/.html (per-kernel IR preview) +""" +import csv +import html +import json +import os +import re +import subprocess +import sys +import urllib.parse +from pathlib import Path + +SCRIPT_DIR = Path(__file__).resolve().parent +REPO_ROOT = SCRIPT_DIR.parents[1] + + +def env_path(name: str, default: Path | str) -> Path: + return Path(os.environ.get(name, str(default))) + + +POLYBENCH_TEST_DIR = env_path( + "POLYGEIST_POLYBENCH_TEST_DIR", + REPO_ROOT / "tools/cgeist/Test/polybench", +) +POLYBENCH_UTILS = POLYBENCH_TEST_DIR / "utilities" +MLIR_DIR = env_path("POLYGEIST_POLYBENCH_MLIR_DIR", "/tmp/polybench_new") +MACHSUITE_ROOT = env_path("POLYGEIST_MACHSUITE_ROOT", REPO_ROOT / "third_party/MachSuite") +MACHSUITE_MLIR_DIR = env_path("POLYGEIST_MACHSUITE_MLIR_DIR", "/tmp/machsuite_mlir") +NPB_ROOT = env_path("POLYGEIST_NPB_ROOT", REPO_ROOT / "third_party/NPB-polybenchified") +NPB_MLIR_DIR = env_path("POLYGEIST_NPB_MLIR_DIR", "/tmp/npb_mlir") +LLAMA2C_ROOT = env_path("POLYGEIST_LLAMA2C_ROOT", REPO_ROOT / "third_party/llama2.c") +LLAMA2C_MLIR_DIR = env_path("POLYGEIST_LLAMA2C_MLIR_DIR", "/tmp/llama2c_mlir") +LLAMA_FORWARD_ROOT = env_path( + "POLYGEIST_LLAMA_FORWARD_ROOT", + REPO_ROOT / "third_party/cnn-extracted", +) +LLAMA_FORWARD_MLIR_DIR = env_path( + "POLYGEIST_LLAMA_FORWARD_MLIR_DIR", + "/tmp/llama_forward_ops_mlir", +) +WHISPER_OPS_ROOT = env_path( + "POLYGEIST_WHISPER_OPS_ROOT", + REPO_ROOT / "third_party/cnn-extracted", +) +WHISPER_OPS_MLIR_DIR = env_path( + "POLYGEIST_WHISPER_OPS_MLIR_DIR", + "/tmp/whisper_ops_mlir", +) +ATEN_C_ROOT = env_path( + "POLYGEIST_ATEN_C_ROOT", + REPO_ROOT / "issues/aten_c_kernels", +) +ATEN_C_MLIR_DIR = env_path( + "POLYGEIST_ATEN_C_MLIR_DIR", + ATEN_C_ROOT / "results", +) +ATEN_SILICON_RESULTS = env_path( + "POLYGEIST_ATEN_SILICON_RESULTS", + ATEN_C_ROOT / "silicon_results/large_problem_comparison.csv", +) +ATEN_DEVICE_RESIDENCY_RESULTS = env_path( + "POLYGEIST_ATEN_DEVICE_RESIDENCY_RESULTS", + ATEN_C_ROOT / "silicon_results/device_residency_comparison.csv", +) +ATEN_CUDA_LIBRARY_AUDIT = env_path( + "POLYGEIST_ATEN_CUDA_LIBRARY_AUDIT", + ATEN_C_ROOT / "cuda_library_audit.csv", +) +ATEN_UPSTREAM_ROOT = env_path( + "POLYGEIST_ATEN_UPSTREAM_ROOT", + REPO_ROOT / "third_party/pytorch", +) +ATEN_UPSTREAM_COMMIT = "d7af122d81a49b1fa7a31ba52bd57c026f092646" +MFEM_C_ROOT = env_path( + "POLYGEIST_MFEM_C_ROOT", + REPO_ROOT / "issues/mfem_c_kernels", +) +MFEM_RESULTS_DIR = env_path( + "POLYGEIST_MFEM_RESULTS_DIR", + MFEM_C_ROOT / "results", +) +MFEM_MATCH_RESULTS_DIR = env_path( + "POLYGEIST_MFEM_MATCH_RESULTS_DIR", + MFEM_C_ROOT / "match_results", +) +MFEM_SILICON_RESULTS_DIR = env_path( + "POLYGEIST_MFEM_SILICON_RESULTS_DIR", + MFEM_C_ROOT / "silicon_results", +) +MFEM_APPLICATIONS_DIR = env_path( + "POLYGEIST_MFEM_APPLICATIONS_DIR", + MFEM_C_ROOT / "applications", +) +MFEM_APPLICATION_EXTRACTIONS_DIR = env_path( + "POLYGEIST_MFEM_APPLICATION_EXTRACTIONS_DIR", + MFEM_C_ROOT / "application_extractions", +) +MFEM_APPLICATION_EXTRACTION_RESULTS_DIR = env_path( + "POLYGEIST_MFEM_APPLICATION_EXTRACTION_RESULTS_DIR", + MFEM_APPLICATION_EXTRACTIONS_DIR / "results", +) +MFEM_UPSTREAM_ROOT = env_path( + "POLYGEIST_MFEM_UPSTREAM_ROOT", + REPO_ROOT / "third_party/mfem", +) +MFEM_UPSTREAM_COMMIT = "951cf8886b9c0c33fb36a2f0ede268c8d6a0d8b5" + +# Correctness-gated application runs on the attached Jetson. These are kept +# separate from the structural matcher counts: a candidate launch is not a +# performance result until the complete application agrees with its -O3 CPU +# reference. `process_wall_s` includes CUDA/cuTensorNet initialization and +# is diagnostic only. The harness reports timing only after correctness; +# all ten harness-supported executable paths now pass this gate. +MFEM_APPLICATION_JETSON_RUNS: dict[str, dict[str, str]] = { + "mfem_app_mtop_iso_elasticity_dfem_2d": { + "outcome": "CORRECTNESS PASS", + "correctness": "NE=1024 max_abs=max_rel=5.551115e-17", + "runtime": "NE=1024 apples-to-apples: CPU -O3 935.686403 us; warm raised Jetson 17465.791991 us; speedup 0.053573x (raised is 18.666x slower)", + "calls": "12 cuTensorNet launches/application", + "params": "f64; NE=1024; D1D=4; Q1D=5; B/G=20; x/y=32768; lambda/mu=25600; J=102400; weights=25; median of warm process runs 2-4", + "hardware": "Jetson tegra-ubuntu, MAXN, CUDA 12.6, cuTensorNet; independent aarch64 -O3 CPU reference", + }, + "mfem_app_ex35p_hcurl_3d": { + "outcome": "CORRECTNESS PASS", + "correctness": "max_abs=max_rel=4.857226e-17", + "runtime": "CPU -O3 62.732794 us; warm raised Jetson 58184.332796 us; speedup 0.001078x", + "calls": "29 cuTensorNet launches/application", + "params": "f64; NE=2; D1D=4; Q1D=5; Bo/Bot=15; Bc/Bct/G/Gt=20; operators=1500; x/y=288", + "hardware": "Jetson tegra-ubuntu, MAXN, CUDA 12.6, cuTensorNet; independent aarch64 -O3 CPU reference", + }, + "mfem_app_dfem_minimal_surface_2d": { + "outcome": "CORRECTNESS PASS", + "correctness": "max_abs=max_rel=8.673617e-19", + "runtime": "CPU -O3 0.876817 us; warm raised Jetson 11099.043209 us; speedup 0.000079x", + "calls": "6 cuTensorNet launches/application", + "params": "f64; NE=2; D1D=4; Q1D=5; B/G=20; field/y=32; Jacobian=100; weights=25", + "hardware": "Jetson tegra-ubuntu, MAXN, CUDA 12.6, cuTensorNet; independent aarch64 -O3 CPU reference", + }, + "mfem_app_ex35p_h1_3d": { + "outcome": "CORRECTNESS PASS", + "correctness": "max_abs=max_rel=6.938894e-18", + "runtime": "CPU -O3 5.427189 us; warm raised Jetson 36668.323190 us; speedup 0.000148x", + "calls": "19 cuTensorNet launches/application", + "params": "f64; NE=2; D1D=4; Q1D=5; B/G/Bt/Gt=20; diffusion=1500; mass=250; x/y=128", + "hardware": "Jetson tegra-ubuntu, MAXN, CUDA 12.6, cuTensorNet; independent aarch64 -O3 CPU reference", + }, + "mfem_app_ex35p_hdiv_3d": { + "outcome": "CORRECTNESS PASS", + "correctness": "max_abs=max_rel=4.857226e-17", + "runtime": "CPU -O3 42.969594 us; warm raised Jetson 22730.832011 us; speedup 0.001890x", + "calls": "12 cuTensorNet launches/application", + "params": "f64; NE=2; D1D=4; Q1D=5; Bo/Bot=15; Bc/Bct/G/Gt=20; div=250; mass=1500; x/y=216", + "hardware": "Jetson tegra-ubuntu, MAXN, CUDA 12.6, cuTensorNet; independent aarch64 -O3 CPU reference", + }, + "mfem_app_ex9p_mass_convection_2d": { + "outcome": "CORRECTNESS PASS", + "correctness": "max_abs=max_rel=6.938894e-18", + "runtime": "CPU -O3 0.671996 us; warm raised Jetson 14588.060789 us; speedup 0.000046x", + "calls": "9 library launches/application", + "params": "f64; NE=2; D1D=4; Q1D=5; B/G/Bt=20; mass=50; convection=100; vector extents=32", + "hardware": "Jetson tegra-ubuntu, MAXN, CUDA 12.6, cuTensorNet; independent aarch64 -O3 CPU reference", + }, + "mfem_app_grad_div_3d": { + "outcome": "CORRECTNESS PASS", + "correctness": "max_abs=max_rel=4.857226e-17", + "runtime": "CPU -O3 42.947195 us; warm raised Jetson 22724.332800 us; speedup 0.001890x", + "calls": "12 cuTensorNet launches/application", + "params": "f64; NE=2; D1D=4; Q1D=5; Bo/Bot=15; Bc/Bct/G/Gt=20; div=250; mass=1500; x/y=216", + "hardware": "Jetson tegra-ubuntu, MAXN, CUDA 12.6, cuTensorNet; independent aarch64 -O3 CPU reference", + }, + "mfem_app_abs_l1_mass_3d": { + "outcome": "CORRECTNESS PASS", + "correctness": "max_abs=max_rel=6.938894e-18", + "runtime": "CPU -O3 1.407997 us; warm raised Jetson 9253.155184 us; speedup 0.000152x", + "calls": "5 cuTensorNet launches/application", + "params": "f64; NE=2; D1D=4; Q1D=5; B/Bt=20; D=250; x/y=128; one untimed warm-up; 10 timed warm iterations; final Y += contraction remains residual Linalg", + "hardware": "Jetson tegra-ubuntu, MAXN, CUDA 12.6, cuTensorNet; independent aarch64 -O3 CPU reference", + }, + "mfem_app_abs_l1_diffusion_3d": { + "outcome": "CORRECTNESS PASS", + "correctness": "max_abs=max_rel=2.710505e-20", + "runtime": "CPU -O3 4.047994 us; warm raised Jetson 26162.835187 us; speedup 0.000155x", + "calls": "14 cuTensorNet launches/application", + "params": "f64; NE=2; D1D=4; Q1D=5; B/G/Bt/Gt=20; operator=1500; x/y=128", + "hardware": "Jetson tegra-ubuntu, MAXN, CUDA 12.6, cuTensorNet; independent aarch64 -O3 CPU reference", + }, + "mfem_app_abs_l1_curlcurl_3d": { + "outcome": "CORRECTNESS PASS", + "correctness": "max_abs=max_rel=4.857226e-17", + "runtime": "CPU -O3 60.716807 us; warm raised Jetson 57165.744016 us; speedup 0.001062x", + "calls": "29 cuTensorNet launches/application", + "params": "f64; NE=2; D1D=4; Q1D=5; Bo/Bot=15; Bc/Bct/G/Gt=20; operators=1500; x/y=288", + "hardware": "Jetson tegra-ubuntu, MAXN, CUDA 12.6, cuTensorNet; independent aarch64 -O3 CPU reference", + }, + "mfem_app_navier_tgv_pa_operators_3d": { + "outcome": "CORRECTNESS PASS", + "correctness": "NE=2 max_abs=max_rel=4.163336e-17; NE=1024 max_abs=max_rel=8.326673e-17; residual loops 26 -> 0", + "runtime": "NE=2: CPU 0.947853 ms, warm Jetson 142.371238 ms, 0.006658x. NE=1024: CPU 491.086496 ms, warm Jetson 1402.250182 ms, 0.350213x", + "calls": "70 cuTensorNet launches/application", + "params": "f64; D1D=4; Q1D=5; NE compile-time scalable. NE=1024: velocity=196608, pressure=65536, largest operator=2304000 doubles; vector mass + vector diffusion + nonlinear convection + pressure diffusion + divergence + gradient; one untimed raised warm-up; 5 timed warm iterations", + "hardware": "Jetson tegra-ubuntu, MAXN, CUDA 12.6, cuTensorNet; independent aarch64 -O3 direct C reference", + }, +} +STENCIL_CONV2D_ROOT = env_path( + "POLYGEIST_STENCIL_CONV2D_ROOT", + REPO_ROOT / "third_party/cnn-extracted", +) +STENCIL_CONV2D_MLIR_DIR = env_path( + "POLYGEIST_STENCIL_CONV2D_MLIR_DIR", + "/tmp/stencil_conv2d_mlir", +) +LLMC_ROOT = env_path("POLYGEIST_LLMC_ROOT", REPO_ROOT / "third_party/llm.c") +LLMC_MLIR_DIR = env_path("POLYGEIST_LLMC_MLIR_DIR", "/tmp/llmc_mlir") +DARKNET_ROOT = env_path("POLYGEIST_DARKNET_ROOT", REPO_ROOT / "third_party/darknet") +DARKNET_MLIR_DIR = env_path("POLYGEIST_DARKNET_MLIR_DIR", "/tmp/darknet_mlir") +EXTRACTED_DARKNET_ROOT = env_path( + "POLYGEIST_EXTRACTED_DARKNET_ROOT", + REPO_ROOT / "third_party/cnn-extracted", +) +EXTRACTED_DARKNET_MLIR_DIR = env_path( + "POLYGEIST_EXTRACTED_DARKNET_MLIR_DIR", + "/tmp/extracted_darknet_mlir", +) +OUTPUT_DIR = env_path("POLYGEIST_IR_VIEWER_OUT", "/tmp/ir_viewer") +REWRITER = env_path("POLYGEIST_KERNEL_MATCH_REWRITER", SCRIPT_DIR / "kernel_match_rewrite.py") +PYTHON = os.environ.get("PYTHON", sys.executable) + +# MachSuite tag → (relative subdir under third_party/MachSuite, kernel function). +# The tag is what the viewer uses for filenames and as the display name. +MACHSUITE_KERNELS: dict[str, tuple[str, str]] = { + "aes": ("aes/aes", "aes256_encrypt_ecb"), + "backprop": ("backprop/backprop", "backprop"), + "bfs-bulk": ("bfs/bulk", "bfs"), + "bfs-queue": ("bfs/queue", "bfs"), + "fft-strided": ("fft/strided", "fft"), + "fft-transpose": ("fft/transpose", "fft1D_512"), + "gemm-ncubed": ("gemm/ncubed", "gemm"), + "gemm-blocked": ("gemm/blocked", "bbgemm"), + "kmp": ("kmp/kmp", "kmp"), + "md-grid": ("md/grid", "md"), + "md-knn": ("md/knn", "md_kernel"), + "nw": ("nw/nw", "needwun"), + "sort-merge": ("sort/merge", "ms_mergesort"), + "sort-radix": ("sort/radix", "ss_sort"), + "spmv-crs": ("spmv/crs", "spmv"), + "spmv-ellpack": ("spmv/ellpack", "ellpack"), + "stencil2d": ("stencil/stencil2d", "stencil"), + "stencil3d": ("stencil/stencil3d", "stencil3d"), + "viterbi": ("viterbi/viterbi", "viterbi"), +} + +# PolyBench-extracted NPB kernels (one .c per kernel in NPB-polybenchified/). +# These were manually carved out of the monolithic per-benchmark .c files +# in NPB3.0-omp-C; the kernel functions had their static-global dependencies +# converted to explicit array parameters so the pipeline can isolate them +# without the extraction issues the whole-file sweep hit. +NPB_KERNELS: dict[str, tuple[str, str]] = { + "bt-add": ("bt_add.c", "bt_add"), + "ft-evolve": ("ft_evolve.c", "ft_evolve"), + "lu-l2norm": ("lu_l2norm.c", "lu_l2norm"), + "mg-psinv": ("mg_psinv.c", "mg_psinv"), + "mg-resid": ("mg_resid.c", "mg_resid"), + "mg-norm2u3": ("mg_norm2u3.c", "mg_norm2u3"), + "mg-rprj3": ("mg_rprj3.c", "mg_rprj3"), +} + +# llama2.c hot numeric functions in run.c. All three live in the same file. +LLAMA2C_KERNELS: dict[str, tuple[str, str]] = { + "rmsnorm": ("run.c", "rmsnorm"), + "softmax": ("run.c", "softmax"), + "matmul": ("run.c", "matmul"), +} + +# Standalone Llama-forward operation fixtures plus the fuller one-token +# one-layer forward fixture. These live in third_party/cnn-extracted/ and are +# intentionally source-level C benchmarks that our pipeline raises. +LLAMA_FORWARD_KERNELS: dict[str, tuple[str, str]] = { + "token_embedding": ("llama_forward_ops.c", "kernel_llama_token_embedding"), + "attention_rmsnorm": ("llama_forward_ops.c", "kernel_llama_attention_rmsnorm"), + "qkv_projection": ("llama_forward_ops.c", "kernel_llama_qkv_projection"), + "rope_interleaved": ("llama_forward_ops.c", "kernel_llama_rope"), + "rope_split": ("llama_forward_ops.c", "kernel_llama_rope_split"), + "kv_cache_rw": ("llama_forward_ops.c", "kernel_llama_kv_cache_rw"), + "attention_scores": ("llama_forward_ops.c", "kernel_llama_attention_scores"), + "attention_mask_if": ("llama_forward_ops.c", "kernel_llama_attention_mask"), + "attention_mask_select": ("llama_forward_ops.c", "kernel_llama_attention_mask_select"), + "attention_softmax": ("llama_forward_ops.c", "kernel_llama_attention_softmax"), + "attention_output": ("llama_forward_ops.c", "kernel_llama_attention_output"), + "output_projection": ("llama_forward_ops.c", "kernel_llama_output_projection"), + "residual_add": ("llama_forward_ops.c", "kernel_llama_residual_add"), + "ffn_rmsnorm": ("llama_forward_ops.c", "kernel_llama_ffn_rmsnorm"), + "gate_up_projection": ("llama_forward_ops.c", "kernel_llama_gate_up_projection"), + "swiglu": ("llama_forward_ops.c", "kernel_llama_swiglu"), + "down_projection": ("llama_forward_ops.c", "kernel_llama_down_projection"), + "final_rmsnorm": ("llama_forward_ops.c", "kernel_llama_final_rmsnorm"), + "lm_head_projection": ("llama_forward_ops.c", "kernel_llama_lm_head_projection"), + "extended_forward": ("llama2_extended_forward_bench.c", "kernel_llama2_extended_forward"), +} + +LLAMA_FORWARD_ORDER = list(LLAMA_FORWARD_KERNELS.keys()) + +LLAMA_FORWARD_DISPLAY_NAMES: dict[str, str] = { + "token_embedding": "token embedding", + "attention_rmsnorm": "attention RMSNorm", + "qkv_projection": "QKV projection", + "rope_interleaved": "RoPE, interleaved", + "rope_split": "RoPE, split", + "kv_cache_rw": "KV cache read/write", + "attention_scores": "attention scores", + "attention_mask_if": "causal mask, if-form", + "attention_mask_select": "causal mask, select-form", + "attention_softmax": "attention softmax", + "attention_output": "attention output", + "output_projection": "output projection", + "residual_add": "residual add", + "ffn_rmsnorm": "FFN RMSNorm", + "gate_up_projection": "gate/up projection", + "swiglu": "SwiGLU", + "down_projection": "down projection", + "final_rmsnorm": "final RMSNorm", + "lm_head_projection": "LM head projection", + "extended_forward": "extended forward benchmark", +} + +WHISPER_OPS_KERNELS: dict[str, tuple[str, str]] = { + "whisper_vec_dot": ("whisper_ops.c", "kernel_whisper_vec_dot"), + "whisper_vec_softmax": ("whisper_ops.c", "kernel_whisper_vec_softmax"), + "whisper_softmax_full": ("whisper_ops.c", "kernel_whisper_softmax_full"), + "whisper_rms_norm": ("whisper_ops.c", "kernel_whisper_rms_norm"), + "whisper_gelu": ("whisper_ops.c", "kernel_whisper_gelu"), + "whisper_conv1d": ("whisper_ops.c", "kernel_whisper_conv1d"), + "whisper_quantize_q4_0_ref": ( + "../whisper.cpp/ggml/src/ggml-quants.c", + "quantize_row_q4_0_ref", + ), + "whisper_decode_residue": ( + "../whisper.cpp/examples/stb_vorbis.c", + "decode_residue", + ), + "whisper_inverse_mdct": ( + "../whisper.cpp/examples/stb_vorbis.c", + "inverse_mdct", + ), +} + +WHISPER_OPS_ORDER = list(WHISPER_OPS_KERNELS.keys()) + +WHISPER_OPS_DISPLAY_NAMES: dict[str, str] = { + "whisper_vec_dot": "vector dot", + "whisper_vec_softmax": "vector softmax", + "whisper_softmax_full": "full softmax", + "whisper_rms_norm": "RMSNorm", + "whisper_gelu": "GELU", + "whisper_conv1d": "1D convolution", + "whisper_quantize_q4_0_ref": "q4_0 quantize ref", + "whisper_decode_residue": "Vorbis residue decode", + "whisper_inverse_mdct": "Vorbis inverse MDCT", +} + +ATEN_C_KERNELS: dict[str, tuple[str, str]] = { + p.stem: (p.name, p.stem) for p in sorted(ATEN_C_ROOT.glob("aten_*.c")) +} + +ATEN_C_ORDER = list(ATEN_C_KERNELS.keys()) + +# Pinned provenance for the standalone numerical C fixtures. The second +# tuple member is a source token used only to add a useful line anchor; when a +# stable token is unavailable, the link intentionally targets the whole file. +# These are implementation-family links, not a claim that the C fixtures are +# textual copies: ATen dispatch/TensorIterator/template machinery was removed. +ATEN_C_PROVENANCE: dict[str, tuple[str, str | None]] = { + "aten_adaptive_avg_pool2d": ("aten/src/ATen/native/AdaptiveAveragePooling.cpp", "adaptive_avg_pool2d"), + "aten_adaptive_avg_pool3d": ("aten/src/ATen/native/AdaptiveAveragePooling3d.cpp", "adaptive_avg_pool3d"), + "aten_add": ("aten/src/ATen/native/CPUBlas.cpp", "void axpy"), + "aten_addmm": ("aten/src/ATen/native/LinearAlgebra.cpp", "static void addmm_impl_cpu_"), + "aten_avg_pool2d": ("aten/src/ATen/native/AveragePool2d.cpp", "avg_pool2d"), + "aten_avg_pool3d": ("aten/src/ATen/native/AveragePool3d.cpp", "avg_pool3d"), + "aten_batch_norm": ("aten/src/ATen/native/cpu/batch_norm_kernel.cpp", "batch_norm_cpu_kernel"), + "aten_binary_cross_entropy": ("aten/src/ATen/native/Loss.cpp", "binary_cross_entropy"), + "aten_bmm": ("aten/src/ATen/native/LinearAlgebra.cpp", "bmm"), + "aten_channel_shuffle": ("aten/src/ATen/native/ChanelShuffle.cpp", "channel_shuffle"), + "aten_clamp": ("aten/src/ATen/native/TensorCompare.cpp", "clamp"), + "aten_conv1d": ("aten/src/ATen/native/Convolution.cpp", "conv1d"), + "aten_conv2d": ("aten/src/ATen/native/ConvolutionMM2d.cpp", "slow_conv2d"), + "aten_conv3d": ("aten/src/ATen/native/Convolution.cpp", "conv3d"), + "aten_conv_transpose2d": ("aten/src/ATen/native/NaiveConvolutionTranspose2d.cpp", "slow_conv_transpose2d"), + "aten_cross": ("aten/src/ATen/native/Cross.cpp", "cross"), + "aten_cumsum": ("aten/src/ATen/native/cpu/ReduceOpsKernel.cpp", "cumsum_cpu_kernel"), + "aten_dot": ("aten/src/ATen/native/Blas.cpp", "Tensor dot"), + "aten_elu": ("aten/src/ATen/native/cpu/Activation.cpp", "elu_kernel"), + "aten_embedding": ("aten/src/ATen/native/Embedding.cpp", "embedding"), + "aten_gelu": ("aten/src/ATen/native/Activation.cpp", "gelu"), + "aten_hardsigmoid": ("aten/src/ATen/native/cpu/Activation.cpp", "hardsigmoid_kernel"), + "aten_hardswish": ("aten/src/ATen/native/cpu/Activation.cpp", "hardswish_kernel"), + "aten_hardtanh": ("aten/src/ATen/native/Activation.cpp", "Tensor hardtanh"), + "aten_im2col": ("aten/src/ATen/native/Im2Col.cpp", "im2col"), + "aten_l1_loss": ("aten/src/ATen/native/Loss.cpp", "l1_loss"), + "aten_layer_norm": ("aten/src/ATen/native/layer_norm.cpp", "layer_norm"), + "aten_leaky_relu": ("aten/src/ATen/native/cpu/Activation.cpp", "leaky_relu_kernel"), + "aten_lerp": ("aten/src/ATen/native/cpu/LerpKernel.cpp", "lerp_kernel"), + "aten_max_pool2d": ("aten/src/ATen/native/cpu/MaxPoolKernel.cpp", "max_pool2d"), + "aten_mean": ("aten/src/ATen/native/ReduceOps.cpp", "mean"), + "aten_mm": ("aten/src/ATen/native/LinearAlgebra.cpp", "TORCH_IMPL_FUNC(mm_out_cpu)"), + "aten_mse_loss": ("aten/src/ATen/native/Loss.cpp", "mse_loss"), + "aten_mv": ("aten/src/ATen/native/Blas.cpp", "Tensor &mv_out"), + "aten_outer": ("aten/src/ATen/native/LinearAlgebra.cpp", "outer"), + "aten_pixel_shuffle": ("aten/src/ATen/native/PixelShuffle.cpp", "pixel_shuffle"), + "aten_prod": ("aten/src/ATen/native/cpu/ReduceOpsKernel.cpp", "prod_kernel"), + "aten_reflection_pad2d": ("aten/src/ATen/native/ReflectionPad.cpp", "reflection_pad2d"), + "aten_relu": ("aten/src/ATen/native/Activation.cpp", "relu"), + "aten_replication_pad2d": ("aten/src/ATen/native/ReplicationPadding.cpp", "replication_pad2d"), + "aten_rms_norm": ("aten/src/ATen/native/layer_norm.cpp", "rms_norm_composite"), + "aten_sigmoid": ("aten/src/ATen/native/cpu/UnaryOpsKernel.cpp", "sigmoid_kernel"), + "aten_silu": ("aten/src/ATen/native/Activation.cpp", "silu"), + "aten_softmax": ("aten/src/ATen/native/cpu/SoftMaxKernel.cpp", "softmax"), + "aten_softplus": ("aten/src/ATen/native/cpu/Activation.cpp", "softplus_kernel"), + "aten_sum": ("aten/src/ATen/native/ReduceOps.cpp", "sum"), + "aten_tanh": ("aten/src/ATen/native/cpu/UnaryOpsKernel.cpp", "tanh_kernel"), + "aten_transpose_copy": ("aten/src/ATen/native/TensorShape.cpp", "transpose"), + "aten_upsample_bilinear2d": ("aten/src/ATen/native/UpSampleBilinear2d.cpp", "upsample_bilinear2d"), + "aten_upsample_nearest2d": ("aten/src/ATen/native/UpSampleNearest2d.cpp", "upsample_nearest2d"), +} + +# Mechanically generated scalar specializations keep their provenance in a +# CSV so adding an extraction does not require editing this viewer by hand. +for _aten_generated_provenance in sorted( + ATEN_C_ROOT.glob("generated*_provenance.csv") +): + with _aten_generated_provenance.open(newline="") as _stream: + for _row in csv.DictReader(_stream): + ATEN_C_PROVENANCE[_row["kernel"]] = ( + _row["source"], _row.get("token") or None + ) + +ATEN_C_MATCH_ASSESSMENT: dict[str, str] = { + "aten_adaptive_avg_pool2d": "no average-pooling definition", + "aten_adaptive_avg_pool3d": "no 3D average-pooling definition", + "aten_avg_pool2d": "no average-pooling definition", + "aten_avg_pool3d": "no 3D average-pooling definition", + "aten_binary_cross_entropy": "external logf calls retain a residual loop", + "aten_bmm": "no true batched-GEMM definition", + "aten_channel_shuffle": "layout transform; correctly rejected as flat copy", + "aten_clamp": "no standalone clamp definition", + "aten_conv1d": "no 1D-convolution definition", + "aten_conv3d": "shape/template gap in current 3D-convolution definitions", + "aten_conv_transpose2d": "no transposed-convolution definition", + "aten_cross": "three elementwise stages; no cross-product composition", + "aten_cumsum": "loop-carried scan raises, but no scan definition", + "aten_elu": "no standalone ELU definition", + "aten_embedding": "indexed gather retains residual loops", + "aten_gelu": "valid custom CUDA GELU route", + "aten_hardsigmoid": "no standalone hard-sigmoid definition", + "aten_hardswish": "no standalone hard-swish definition", + "aten_hardtanh": "no standalone hard-tanh definition", + "aten_im2col": "window gather correctly rejected as flat copy", + "aten_l1_loss": "no L1 reduction composition", + "aten_layer_norm": "mean/variance/affine composition not in library", + "aten_leaky_relu": "no standalone leaky-ReLU definition", + "aten_lerp": "no linear-interpolation definition", + "aten_mean": "reduction-plus-scale composition not in library", + "aten_mse_loss": "square-difference plus mean composition not in library", + "aten_outer": "partial: only output zero-initialization matched", + "aten_pixel_shuffle": "layout transform correctly rejected as flat copy", + "aten_prod": "no product-reduction definition", + "aten_reflection_pad2d": "no reflection-padding definition", + "aten_relu": "no standalone ReLU definition", + "aten_replication_pad2d": "no replication-padding definition", + "aten_sigmoid": "no standalone sigmoid definition", + "aten_silu": "no standalone SiLU definition", + "aten_softplus": "external logf/expf and branch retain a residual loop", + "aten_sum": "partial: only output zero-initialization matched", + "aten_tanh": "no standalone tanh definition", + "aten_transpose_copy": "permuted indexing map correctly rejected as flat copy", + "aten_upsample_bilinear2d": "no bilinear-resampling definition", + "aten_upsample_nearest2d": "no nearest-neighbor resampling definition", +} + +ATEN_C_UNSAFE_MATCHES: set[str] = {"aten_pixel_shuffle"} + +# These probes come from large upstream source files. Keep them in the IR +# explorer, but avoid embedding the full original files in Compiler Explorer +# deep links, which makes the generated index impractically large. +WHISPER_OPS_IR_ONLY: set[str] = { + "whisper_quantize_q4_0_ref", + "whisper_decode_residue", + "whisper_inverse_mdct", +} + +STENCIL_CONV2D_KERNELS: dict[str, tuple[str, str]] = { + "box3x3": ("stencil_conv2d_3x3.c", "kernel_stencil_box3x3"), + "gaussian3x3": ("stencil_conv2d_3x3.c", "kernel_stencil_gaussian3x3"), + "sobel_x3x3": ("stencil_conv2d_3x3.c", "kernel_stencil_sobel_x3x3"), + "sobel_y3x3": ("stencil_conv2d_3x3.c", "kernel_stencil_sobel_y3x3"), + "laplacian4_3x3": ("stencil_conv2d_3x3.c", "kernel_stencil_laplacian4_3x3"), + "laplacian8_3x3": ("stencil_conv2d_3x3.c", "kernel_stencil_laplacian8_3x3"), + "sharpen3x3": ("stencil_conv2d_3x3.c", "kernel_stencil_sharpen3x3"), + "emboss3x3": ("stencil_conv2d_3x3.c", "kernel_stencil_emboss3x3"), + "box5x5": ("stencil_conv2d_3x3.c", "kernel_stencil_box5x5"), + "gaussian5x5": ("stencil_conv2d_3x3.c", "kernel_stencil_gaussian5x5"), + "sobel_x5x5": ("stencil_conv2d_3x3.c", "kernel_stencil_sobel_x5x5"), + "sobel_y5x5": ("stencil_conv2d_3x3.c", "kernel_stencil_sobel_y5x5"), + "laplacian5x5": ("stencil_conv2d_3x3.c", "kernel_stencil_laplacian5x5"), + "sharpen5x5": ("stencil_conv2d_3x3.c", "kernel_stencil_sharpen5x5"), + "emboss5x5": ("stencil_conv2d_3x3.c", "kernel_stencil_emboss5x5"), + "box7x7": ("stencil_conv2d_3x3.c", "kernel_stencil_box7x7"), +} + +STENCIL_CONV2D_ORDER = list(STENCIL_CONV2D_KERNELS.keys()) + +STENCIL_CONV2D_DISPLAY_NAMES: dict[str, str] = { + "box3x3": "box blur 3x3", + "gaussian3x3": "Gaussian blur 3x3", + "sobel_x3x3": "Sobel X 3x3", + "sobel_y3x3": "Sobel Y 3x3", + "laplacian4_3x3": "Laplacian 4-neighbor 3x3", + "laplacian8_3x3": "Laplacian 8-neighbor 3x3", + "sharpen3x3": "sharpen 3x3", + "emboss3x3": "emboss 3x3", + "box5x5": "box blur 5x5", + "gaussian5x5": "Gaussian blur 5x5", + "sobel_x5x5": "Sobel X 5x5", + "sobel_y5x5": "Sobel Y 5x5", + "laplacian5x5": "Laplacian 5x5", + "sharpen5x5": "sharpen 5x5", + "emboss5x5": "emboss 5x5", + "box7x7": "box blur 7x7", +} + +# llm.c (karpathy/llm.c) leaf forward/backward kernels in train_gpt2.c. These +# are the building blocks of GPT-2 inference + training. Skip the tiled +# matmul_forward in favour of matmul_forward_naive (the 4-loop reference). +LLMC_KERNELS: dict[str, tuple[str, str]] = { + "encoder-fwd": ("train_gpt2.c", "encoder_forward"), + "encoder-bwd": ("train_gpt2.c", "encoder_backward"), + "layernorm-fwd": ("train_gpt2.c", "layernorm_forward"), + "layernorm-bwd": ("train_gpt2.c", "layernorm_backward"), + "matmul-fwd-naive": ("train_gpt2.c", "matmul_forward_naive"), + "matmul-bwd": ("train_gpt2.c", "matmul_backward"), + "attention-fwd": ("train_gpt2.c", "attention_forward"), + "attention-bwd": ("train_gpt2.c", "attention_backward"), + "gelu-fwd": ("train_gpt2.c", "gelu_forward"), + "gelu-bwd": ("train_gpt2.c", "gelu_backward"), + "residual-fwd": ("train_gpt2.c", "residual_forward"), + "residual-bwd": ("train_gpt2.c", "residual_backward"), + "softmax-fwd": ("train_gpt2.c", "softmax_forward"), + "crossentropy-fwd": ("train_gpt2.c", "crossentropy_forward"), + "crossentropy-softmax-bwd": ("train_gpt2.c", "crossentropy_softmax_backward"), +} + +# darknet (pjreddie) — CPU reference implementation of CNN layers used by +# YOLO + ResNet configurations. We bake every .c file in src/ with +# cgeist --function='*' and inlining enabled; the matcher then runs against +# each file's debuferized output. Most files are framework code (parser, list, +# image, network) with no compute bodies. The actual numerical hot spot +# is src/gemm.c which contains the naive C gemm_nn/nt/tn/tt variants; +# everything else either fails to lift (struct-heavy code, IfStmt +# limitations in cgeist) or produces linalg.generic ops the matcher's +# current library doesn't recognise (pooling, batchnorm, RNN gates, ...). +# +# This is intentionally a "matcher coverage survey" rather than a +# silicon-target list — its purpose is to enumerate which deep-learning +# layer kernels we'd need new matcher templates to cover. See the per- +# file notes for which pattern each unmatched file has. +DARKNET_KERNELS: dict[str, tuple[str, str]] = { + "activation_layer": ("src/activation_layer.c", "*"), + "activations": ("src/activations.c", "*"), + "avgpool_layer": ("src/avgpool_layer.c", "*"), + "batchnorm_layer": ("src/batchnorm_layer.c", "*"), + "blas": ("src/blas.c", "*"), + "box": ("src/box.c", "*"), + "col2im": ("src/col2im.c", "*"), + "compare": ("src/compare.c", "*"), + "connected_layer": ("src/connected_layer.c", "*"), + "convolutional_layer": ("src/convolutional_layer.c", "*"), + "cost_layer": ("src/cost_layer.c", "*"), + "crnn_layer": ("src/crnn_layer.c", "*"), + "crop_layer": ("src/crop_layer.c", "*"), + "data": ("src/data.c", "*"), + "deconvolutional_layer": ("src/deconvolutional_layer.c", "*"), + "demo": ("src/demo.c", "*"), + "detection_layer": ("src/detection_layer.c", "*"), + "dropout_layer": ("src/dropout_layer.c", "*"), + "gemm": ("src/gemm.c", "*"), + "gru_layer": ("src/gru_layer.c", "*"), + "im2col": ("src/im2col.c", "*"), + "image": ("src/image.c", "*"), + "iseg_layer": ("src/iseg_layer.c", "*"), + "l2norm_layer": ("src/l2norm_layer.c", "*"), + "layer": ("src/layer.c", "*"), + "list": ("src/list.c", "*"), + "local_layer": ("src/local_layer.c", "*"), + "logistic_layer": ("src/logistic_layer.c", "*"), + "lstm_layer": ("src/lstm_layer.c", "*"), + "matrix": ("src/matrix.c", "*"), + "maxpool_layer": ("src/maxpool_layer.c", "*"), + "network": ("src/network.c", "*"), + "normalization_layer": ("src/normalization_layer.c", "*"), + "option_list": ("src/option_list.c", "*"), + "parser": ("src/parser.c", "*"), + "region_layer": ("src/region_layer.c", "*"), + "reorg_layer": ("src/reorg_layer.c", "*"), + "rnn_layer": ("src/rnn_layer.c", "*"), + "route_layer": ("src/route_layer.c", "*"), + "shortcut_layer": ("src/shortcut_layer.c", "*"), + "softmax_layer": ("src/softmax_layer.c", "*"), + "tree": ("src/tree.c", "*"), + "upsample_layer": ("src/upsample_layer.c", "*"), + "utils": ("src/utils.c", "*"), + "yolo_layer": ("src/yolo_layer.c", "*"), +} + +DARKNET_NOTES: dict[str, tuple[str, str]] = { + # The 1 file that produces matches today + "gemm": ("highly parallel", "Classic dense gemm + axpy variants; gemm_nt/tt match @cublasDgemm_alpha_only; gemm_nn/tn match @cublasDaxpy (inner-loop scalar-hoisted form not composed up to gemm)"), + # Compute-pattern files that raise OK but don't match — the matcher templates we're missing + "activation_layer": ("pointwise", "Activation forward (ReLU/leaky/etc.) — pointwise; no template"), + "activations": ("pointwise", "Activation primitives — pointwise; no template"), + "avgpool_layer": ("partial parallel", "Average pooling — windowed reduction; no template"), + "col2im": ("pointwise", "Column-to-image reshape — strided scatter; no template"), + "connected_layer": ("highly parallel", "Dense (fully-connected) layer — gemv shape with bias; 16 generics but matcher's gemv composition isn't firing"), + "cost_layer": ("partial parallel", "Loss computation — pointwise + reduction; no template"), + "crop_layer": ("pointwise", "Image crop — pointwise; no template"), + "deconvolutional_layer": ("highly parallel", "Transposed conv via col2im — 20 generics; same matcher gap as conv (im2col-based gemm)"), + "dropout_layer": ("pointwise", "Dropout mask multiply — pointwise; no template"), + "gru_layer": ("partial parallel", "GRU RNN gates — 9 generics; matcher has no recurrent-cell composition"), + "im2col": ("pointwise", "Image-to-column reshape — strided gather; raised but no compute body to match"), + "l2norm_layer": ("partial parallel", "L2 normalization — reduction + divide; no template (similar to rmsnorm)"), + "local_layer": ("highly parallel", "Locally-connected (per-position weights) — 6 generics; matcher gap (no shared filter)"), + "logistic_layer": ("pointwise", "Sigmoid + binary cross-entropy — pointwise + reduction; no template"), + "maxpool_layer": ("partial parallel", "Max pooling — windowed reduction (3 generics); matcher has no pooling composition"), + "normalization_layer": ("partial parallel", "Local response normalization — reduction + divide (4 generics); no template"), + "reorg_layer": ("pointwise", "Spatial reorganisation — pointwise reshape; no template"), + "route_layer": ("pointwise", "Concatenation across feature maps — strided memcpy; no template"), + "shortcut_layer": ("pointwise", "Residual add (x += shortcut) — pointwise; matcher-gap (same as llmc residual-fwd)"), + "softmax_layer": ("partial parallel", "Softmax — 3-step composition; the llama2/llmc softmax template exists but this layer has different surrounding control flow"), + "upsample_layer": ("pointwise", "Nearest-neighbour upsample — strided broadcast; no template"), + # cgeist failures — framework code, no compute to match anyway + "blas": ("", "cgeist failure — header includes choke (math.h + glibc-specific intrinsics)"), + "box": ("", "Raise pass fails on memref-of-memref shape from box-list operations"), + "compare": ("", "cgeist failure — variadic ranking helpers"), + "convolutional_layer": ("highly parallel", "Raise fails — body is mostly external-call dispatch (im2col_cpu + gemm); the actual compute lives in gemm.c which DOES match"), + "crnn_layer": ("", "cgeist failure — recurrent layer struct uses function pointers"), + "data": ("", "cgeist failure — pthread + libc-heavy data-loading code"), + "demo": ("", "cgeist failure — OpenCV display loop (requires cv::Mat headers)"), + "detection_layer": ("", "cgeist failure — IfStmt lowering bug on the per-anchor confidence branches"), + "image": ("", "cgeist failure — stbi-style image loaders"), + "iseg_layer": ("", "cgeist failure — IfStmt lowering bug (instance-segmentation post-processing)"), + "lstm_layer": ("", "cgeist failure — recurrent-cell struct + function pointers"), + "list": ("", "cgeist failure — linked-list manipulation; no compute"), + "matrix": ("", "cgeist failure — IfStmt on shape validation"), + "network": ("", "cgeist failure — FunctionDecl issue (function-pointer-of-layer.forward_layer dispatch)"), + "option_list": ("", "cgeist failure — header includes"), + "parser": ("", "cgeist failure — sscanf-heavy .cfg parser, header includes"), + "region_layer": ("", "cgeist failure — BinaryOperator on the YOLO grid-cell branching"), + "rnn_layer": ("", "cgeist failure — recurrent-cell struct"), + "utils": ("", "cgeist failure — exits + abort macros, no compute"), + "yolo_layer": ("", "cgeist failure — IfStmt on YOLO loss-mask branches"), + # files that raise OK and produce zero linalg.generic — no compute + "activation_layer": ("pointwise", "Activation forward (ReLU/leaky/etc.) — pointwise; no template"), + "layer": ("", "Layer-struct allocator + free — no compute"), + "tree": ("", "Hierarchical-class tree manipulation — no compute"), +} + +DARKNET_BLOCKERS: dict[str, tuple[str, str]] = { + "gemm": ("none", ""), + "activation_layer": ("matcher-gap", "pointwise activation; no axpy-like template fires"), + "activations": ("matcher-gap", "pointwise"), + "avgpool_layer": ("matcher-gap", "pooling composition not in library"), + "col2im": ("matcher-gap", "strided scatter"), + "connected_layer": ("matcher-gap", "gemv composition gap (matrix index has bias term)"), + "cost_layer": ("matcher-gap", "loss = reduction over pointwise body"), + "crop_layer": ("matcher-gap", "pointwise"), + "deconvolutional_layer": ("matcher-gap", "transposed conv (col2im+gemm)"), + "dropout_layer": ("matcher-gap", "pointwise"), + "gru_layer": ("matcher-gap", "RNN gates"), + "im2col": ("none", "Strided gather raises but has no compute body"), + "l2norm_layer": ("matcher-gap", "norm + divide"), + "local_layer": ("matcher-gap", "per-position weights"), + "logistic_layer": ("matcher-gap", "sigmoid+BCE"), + "maxpool_layer": ("matcher-gap", "pooling"), + "normalization_layer": ("matcher-gap", "LRN"), + "reorg_layer": ("matcher-gap", "spatial reshape"), + "route_layer": ("matcher-gap", "concat"), + "shortcut_layer": ("matcher-gap", "residual add"), + "softmax_layer": ("matcher-gap", "softmax (this layer's surrounding control flow defeats the existing softmax template)"), + "upsample_layer": ("matcher-gap", "upsample"), + "blas": ("cgeist-gap", "header inclusion failure"), + "box": ("debuf-bug", "memref-of-memref shape"), + "compare": ("cgeist-gap", "variadic ranking"), + "convolutional_layer": ("matcher-gap", "body is mostly external calls; real compute is in gemm.c"), + "crnn_layer": ("cgeist-gap", "RNN struct + function pointers"), + "data": ("cgeist-gap", "pthread + libc"), + "demo": ("cgeist-gap", "OpenCV"), + "detection_layer": ("cgeist-gap", "IfStmt bug"), + "image": ("cgeist-gap", "stbi-style loader"), + "iseg_layer": ("cgeist-gap", "IfStmt bug"), + "lstm_layer": ("cgeist-gap", "RNN struct"), + "list": ("none", "linked list, no compute"), + "matrix": ("cgeist-gap", "IfStmt"), + "network": ("cgeist-gap", "function-pointer dispatch"), + "option_list": ("cgeist-gap", "header includes"), + "parser": ("cgeist-gap", "sscanf-heavy"), + "region_layer": ("cgeist-gap", "BinaryOperator on grid branches"), + "rnn_layer": ("cgeist-gap", "RNN struct"), + "utils": ("none", "no compute"), + "yolo_layer": ("cgeist-gap", "IfStmt bug"), + "layer": ("none", "allocator only"), + "tree": ("debuf-bug", "no compute pattern"), +} + +# Per-NPB-kernel parallelism + characterisation notes. +NPB_NOTES: dict[str, tuple[str, str]] = { + "bt-add": ("highly parallel", "BT vector add over 4D field — pure elemwise, fully parallel"), + "ft-evolve": ("highly parallel", "FT timestep multiply — parallel but uses ex[indexmap[...]] gather; raise refuses indirect index"), + "lu-l2norm": ("highly parallel", "LU L2 norm over 4D field — reduction over the spatial axes"), + "mg-psinv": ("highly parallel", "MG smoother — 27-point stencil via per-row r1/r2 scratch arrays; outer i3/i2 hold scratch state"), + "mg-resid": ("highly parallel", "MG residual r = v - Au — same 27-point stencil shape as psinv"), + "mg-norm2u3": ("highly parallel", "MG L2 + L∞ combined norm — mixed sum+max reductions in one loop; raise pass can't fuse"), + "mg-rprj3": ("highly parallel", "MG restriction (trilinear FE projection) — coarse-grid 2x downsample"), +} + +# llama2.c numeric kernels — the building blocks of LLM forward pass. +LLAMA2C_NOTES: dict[str, tuple[str, str]] = { + "matmul": ("highly parallel", "dense gemv (W·x = xout); single linalg.generic after raise"), + "rmsnorm": ("highly parallel", "ss = mean(x²) + eps then o = weight·x/√ss; reduction + parallel scale"), + "softmax": ("partial parallel", "max-shift then exp + sum then divide; three reduction/parallel phases"), +} + +LLAMA_FORWARD_NOTES: dict[str, tuple[str, str]] = { + "token_embedding": ("highly parallel", "embedding row copy for one token"), + "attention_rmsnorm": ("highly parallel", "attention RMSNorm; mean-square reduction + weighted scale"), + "qkv_projection": ("highly parallel", "Q/K/V dense projections from normalized hidden state"), + "rope_interleaved": ("partial parallel", "exact interleaved RoPE layout; still leaves loops today"), + "rope_split": ("highly parallel", "raise-friendly split even/odd RoPE form"), + "kv_cache_rw": ("highly parallel", "KV cache write at current position plus full cache read"), + "attention_scores": ("highly parallel", "Q·K score reduction over per-head dimensions"), + "attention_mask_if": ("partial parallel", "branchy causal mask; still contains an if/loop shape"), + "attention_mask_select": ("highly parallel", "branchless select-form causal mask"), + "attention_softmax": ("partial parallel", "max-shift softmax over the active sequence row"), + "attention_output": ("highly parallel", "weighted sum over V cache"), + "output_projection": ("highly parallel", "attention output projection GEMV"), + "residual_add": ("highly parallel", "elementwise residual add"), + "ffn_rmsnorm": ("highly parallel", "FFN RMSNorm; same shape as attention RMSNorm"), + "gate_up_projection": ("highly parallel", "gate/up FFN projections"), + "swiglu": ("highly parallel", "elementwise SiLU(gate) * up"), + "down_projection": ("highly parallel", "FFN down projection GEMV"), + "final_rmsnorm": ("highly parallel", "final RMSNorm before logits"), + "lm_head_projection": ("highly parallel", "lm_head GEMV to logits"), + "extended_forward": ("partial parallel", "one-token, one-layer Llama-style forward fixture combining the raised pieces"), +} + +WHISPER_OPS_NOTES: dict[str, tuple[str, str]] = { + "whisper_vec_dot": ("highly parallel", "dot-product reduction used by ggml vec_dot / matvec-style projection kernels"), + "whisper_vec_softmax": ("partial parallel", "inner softmax exp+sum loop with caller-provided max; reduction plus output write"), + "whisper_softmax_full": ("partial parallel", "max-reduce, exp+sum, and normalize phases for attention softmax"), + "whisper_rms_norm": ("partial parallel", "mean-square reduction followed by parallel scale; RMSNorm-style normalization"), + "whisper_gelu": ("highly parallel", "elementwise transformer activation; raises through math.tanh into tensor linalg"), + "whisper_conv1d": ("highly parallel", "valid 1D convolution shape representing Whisper encoder-side audio conv"), + "whisper_quantize_q4_0_ref": ( + "partial parallel", + "GGML q4_0 reference quantizer: blockwise max reduction plus fp16 scale and packed 4-bit stores", + ), + "whisper_decode_residue": ( + "partial parallel", + "Vorbis residue decode: codebook-driven channel residue reconstruction with dynamic classifications", + ), + "whisper_inverse_mdct": ( + "partial parallel", + "Vorbis inverse MDCT transform with twiddle-factor pointer loops and staged butterfly helpers", + ), +} + +STENCIL_CONV2D_NOTES: dict[str, tuple[str, str]] = { + "box3x3": ("highly parallel", "uniform 3x3 box blur written as a shifted-neighbour stencil; tensor path uses generalized ntap"), + "gaussian3x3": ("highly parallel", "separable-looking 3x3 Gaussian coefficient stencil, matched by the tensor ntap path"), + "sobel_x3x3": ("highly parallel", "horizontal image-gradient stencil; unit coefficients are recovered by the matcher"), + "sobel_y3x3": ("highly parallel", "vertical image-gradient stencil; same 9 shifted input views as Sobel X"), + "laplacian4_3x3": ("highly parallel", "4-neighbour Laplacian finite-difference stencil embedded in a 3x3 kernel"), + "laplacian8_3x3": ("highly parallel", "8-neighbour Laplacian finite-difference stencil"), + "sharpen3x3": ("highly parallel", "classic image sharpen filter, center-heavy 3x3 stencil"), + "emboss3x3": ("highly parallel", "asymmetric emboss filter; still maps to cross-correlation semantics"), + "box5x5": ("highly parallel", "25-tap box filter; tensor path packs W[25] for the generalized ntap cuDNN route"), + "gaussian5x5": ("highly parallel", "separable 5x5 Gaussian coefficient stencil, matched by the generalized ntap path"), + "sobel_x5x5": ("highly parallel", "wider horizontal-gradient stencil with zero center column coefficients"), + "sobel_y5x5": ("highly parallel", "wider vertical-gradient stencil with zero center row coefficients"), + "laplacian5x5": ("highly parallel", "5x5 Laplacian / LoG-style finite-difference stencil"), + "sharpen5x5": ("highly parallel", "wider sharpen filter with center-heavy positive weights"), + "emboss5x5": ("highly parallel", "asymmetric 5x5 emboss filter mapped to cross-correlation semantics"), + "box7x7": ("highly parallel", "49-tap box filter; matched by the generalized packed-weight ntap cuDNN path"), +} + +# llm.c kernel notes — GPT-2 building blocks. Most fwd kernels are highly +# parallel (B·T·OC or B·T·C parallel iter spaces); attention has a per-query +# softmax that introduces a reduction phase; encoder/gelu/crossentropy have +# data-dependent indexing or math.h ext-calls that block raise. +LLMC_NOTES: dict[str, tuple[str, str]] = { + "encoder-fwd": ("partial parallel", "lookup wte[token]+wpe[pos]; data-dependent index blocks raise"), + "encoder-bwd": ("partial parallel", "scatter-accumulate gradients into wte/wpe; indirect-index scatter"), + "layernorm-fwd": ("highly parallel", "per-(B,T) row: mean + variance reductions then normalize + scale + bias"), + "layernorm-bwd": ("partial parallel", "per-(B,T) row: 2 reductions for dnorm/dnorm_mean then accumulate dweight/dbias/dinp"), + "matmul-fwd-naive": ("highly parallel", "4-loop reference matmul out[b,t,o] = sum_i inp[b,t,i]*weight[o,i] + bias[o]"), + "matmul-bwd": ("highly parallel", "transpose matmuls for dinp, dweight, dbias"), + "attention-fwd": ("partial parallel", "Q·Kᵀ → softmax → ·V; per-(B,T,h) parallel with two reductions (max, sum-exp)"), + "attention-bwd": ("partial parallel", "backward through Q·Kᵀ/softmax/·V; gradient accumulation across heads"), + "gelu-fwd": ("highly parallel", "elementwise tanh-based gelu; calls tanhf — math.h ext call blocks raise"), + "gelu-bwd": ("highly parallel", "elementwise gelu derivative; calls tanhf + coshf — math.h ext calls"), + "residual-fwd": ("highly parallel", "elementwise out = inp1 + inp2; single fully-parallel generic"), + "residual-bwd": ("highly parallel", "elementwise dinp1 += dout; dinp2 += dout; two parallel generics"), + "softmax-fwd": ("partial parallel", "per-(B,T) row softmax with max-shift; same 3-phase shape as llama2 softmax"), + "crossentropy-fwd": ("highly parallel", "elementwise -log(probs[target[b,t]]); calls logf — math.h ext blocks raise"), + "crossentropy-softmax-bwd": ("highly parallel", "elementwise dlogits = (probs - onehot(target)) * dlosses"), +} + +# Per-MachSuite-kernel parallelism + characterisation notes. +MACHSUITE_NOTES: dict[str, tuple[str, str]] = { + "gemm-ncubed": ("highly parallel", "textbook 3-loop gemm with flat 1D indexing — lifts to single linalg.generic"), + "gemm-blocked": ("highly parallel", "tiled gemm; blocking collapses, still matches GEMM"), + "stencil2d": ("highly parallel", "9-tap 2D conv (3x3 filter), not jacobi-shaped — no matcher template yet"), + "stencil3d": ("highly parallel", "3D stencil — 7-tap-ish, mostly matches"), + "backprop": ("partial parallel", "neural-net backprop; many small generics, body shapes outside our library"), + "nw": ("serial", "Needleman-Wunsch DP; row-by-row dependencies"), + "fft-strided": ("serial", "bit-reversal addressing; outer shift loop non-affine"), + "fft-transpose": ("partial parallel", "transpose-based FFT; some stages parallel, others not"), + "kmp": ("serial", "KMP string matching; backtracking, control-flow heavy"), + "bfs-bulk": ("serial", "bulk-synchronous BFS; queue-based, non-affine"), + "bfs-queue": ("serial", "queue-based BFS; non-affine indirect access"), + "spmv-crs": ("partial parallel", "sparse matvec CRS — indirect indexing not raisable today"), + "spmv-ellpack": ("partial parallel", "sparse matvec ELLPACK — same"), + "sort-merge": ("serial", "merge sort; control flow heavy"), + "sort-radix": ("partial parallel", "radix sort; counting + scatter; some stages affine"), + "aes": ("serial", "byte-oriented AES; bit ops + sbox lookup; not numerical"), + "md-grid": ("highly parallel", "molecular dynamics with cell-grid neighbour list"), + "md-knn": ("highly parallel", "molecular dynamics with k-NN neighbour list"), + "viterbi": ("serial", "Viterbi DP + arg-max; sequential along time"), +} + +CE_BASE = "http://localhost:10240/" +CGEIST_NAME = "cgeist_aff" +POPT_NAME = "popt_full" +POPT_DISPLAY = "polygeist-opt: full (raise + lower-submap + debuferize)" + + +# ===================================================================== +# Algorithm-blocker taxonomy: WHY each kernel ends up at FULL / PARTIAL / +# NONE. Derived from the per-kernel investigations done across sessions +# (see memory: scratch-row-carries, row-scratch-privatization-attempt, +# raise-to-linalg-gaps, raise-status-after-privatize). Each kernel below +# is tagged with one primary blocker. Tags: +# +# none — kernel fully lifts and matches; no blocker. +# matcher-gap — lifts to linalg.generic cleanly but the body +# shape isn't in the matcher library (fixable: +# add a CompositionEntry + kernel.defn). +# runtime-gap — matcher emits a kernel.launch form, but ABI lowering +# or the runtime shim for that exact symbol is pending. +# t-loop — body is parallel; outer "for t = 0..T" timestep +# loop is genuinely serial (stencils — body of one +# timestep reads the previous timestep's output). +# Correct partial-lift; no fix needed. +# serial-recurrence — outer k/i loop carries data across iterations +# (factorizations, DPs, recurrences). Fundamentally +# non-parallel; can't be lifted further. +# scratch-carry — hand-CSE'd rank-1 scratch row used to share +# cross-axis arithmetic between two sibling inner +# loops within one outer iteration. The outer +# loops are parallel in principle; the shared +# scratch hides that from the raise pass. FIXABLE +# — see docs/row_scratch_privatization_failures.md. +# indirect-index — data-dependent array index (e.g. +# `ex[t * indexmap[k]]`). Needs gather semantics +# in linalg.generic; not supported today. +# mixed-reductions — single loop computes two reductions with +# different operators (e.g. sum + max). The +# raise pass currently rejects. +# non-affine — bit-shift loops, sparse indirect indexing, +# backtracking, control-flow-heavy code. +# Genuinely outside the affine model. +# cgeist-frontend — cgeist itself fails to parse / emit MLIR. Out +# of pipeline scope. +# debuf-bug — known dominance-class bug in the debufferize +# pass (gramschmidt-class). +# ===================================================================== + +BLOCKER_TAXONOMY: dict[str, tuple[str, str]] = { + # tag → (one-liner label, longer explanation) + "none": ("clean lift", + "fully lifts to kernel.launch (or to linalg.generic + matched library entry)"), + "matcher-gap": ("matcher library gap", + "lifts to linalg.generic, but the body shape isn't in the matcher library yet"), + "runtime-gap": ("runtime ABI gap", + "matches to a kernel.launch symbol, but ABI lowering or the runtime shim for that exact symbol is still pending"), + "t-loop": ("serial T loop", + "stencil-style: body parallel, outer time/step loop must be sequential"), + "serial-recurrence": ("serial recurrence", + "factorization / DP / recurrence — outer iterations have genuine cross-iter data dependencies"), + "scratch-carry": ("scratch row carry (FIXABLE)", + "hand-CSE'd rank-1 row scratch shared between sibling inner loops; needs the row-privatization pass to land"), + "indirect-index": ("data-dependent index (FIXABLE)", + "indirect array index like ex[t*indexmap[i]]; needs gather support in linalg.generic"), + "mixed-reductions": ("mixed sum+max reductions", + "outer loop computes two reductions with different operators in one nest"), + "non-affine": ("non-affine access", + "bit-shift loop / sparse indirect / control-flow heavy — genuinely outside the affine model"), + "cgeist-frontend": ("cgeist front-end limit", + "cgeist itself doesn't parse the C cleanly (bit-heavy / struct-heavy / fn-pointer code)"), + "debuf-bug": ("debuf dominance bug", + "raise OK but debufferize hits the gramschmidt-class tensor.empty dominance issue"), + "raise-fail": ("raise pipeline failure", + "cgeist emits MLIR, but polygeist-opt fails before producing a raised linalg artifact"), + "raise-crash": ("polygeist-opt crash during raise", + "polygeist-opt segfaults in the raise pipeline; needs deeper investigation"), + "no-linalg": ("no linalg form", + "the function compiles, but the current raise path leaves imperative/control-flow or low-level LLVM structure instead of producing linalg.generic"), + "ext-math-call": ("math.h ext call in body (FIXABLE)", + "loop body calls tanhf / logf / coshf etc.; raise refuses to lift a generic whose body contains an external call. Fixable by teaching the frontend or a pre-pass to rewrite known math.h calls to math.* dialect ops"), + "cudnn-dtype-gap": ("cuDNN dtype not supported", + "MLIR pipeline (raise / match / ABI lowering / runtime shim ABI) is correct end-to-end, but the underlying library doesn't expose the requested dtype on this hardware. Today's hit: cuDNN's cudnnConvolutionForward does not support a pure INT32 input+filter+compute configuration on Ampere/Orin (returns CUDNN_STATUS_BAD_PARAM at descriptor setup); CUDNN_DATA_INT32 is only available as an accumulator type for INT8 inputs via the bias+activation API. Real fixes are out-of-pipeline: hand-written CUDA kernel via nvcc, INT8 quantisation path, or swap cuDNN for cutlass/CUB"), + "cgeist-dtype-gap": ("cgeist frontend dtype assert", + "cgeist itself can't parse the source dtype: BuiltinType `_Float16` / `__bf16` hits an `unhandled type` assertion in tools/cgeist/Lib/clang-mlir.cc:5830. Affects FP16 and BF16 conv2d sources — we never get an MLIR file to feed the rest of the pipeline. Fix is a small addition to the BuiltinType switch that maps clang's Half / BFloat16 to MLIR's f16 / bf16"), + "partial-pipeline": ("partial pipeline (matcher OK, downstream incomplete)", + "matcher + rewriter produce a clean kernel.launch op for this kernel, but the canonical defn / ABI lowering / runtime shim for the new library symbol haven't landed yet. Distinct from cudnn-dtype-gap (where the library is fundamentally unwilling) or matcher-gap (where the linalg body doesn't fingerprint). This is a 'in progress, scope-limited' state; the linalg → kernel.launch step is validated, the kernel.launch → func.call step is pending"), +} + +# Per-kernel parallelism notes — how well the kernel's algorithm maps to GPU. +# Categories used in the index column: +# highly parallel — every iteration independent; embarrassingly parallel +# parallel + T loop — body parallel, but a sequential outer time/step loop remains +# partial parallel — significant parallel ops mixed with reductions / serial steps +# serial — fundamental cross-iteration dependencies; poor GPU fit +KERNEL_NOTES: dict[str, tuple[str, str]] = { + # BLAS-shaped — fully parallel iter space. + "gemm": ("highly parallel", "dense gemm, 3-loop parallel + reduction"), + "gemver": ("highly parallel", "rank-2 update + gemv stages, all parallel"), + "gesummv": ("highly parallel", "two gemvs + axpby, all parallel"), + "atax": ("highly parallel", "y = A·x then t = Aᵀ·y, parallel"), + "bicg": ("highly parallel", "s = Aᵀ·p and q = A·r, parallel"), + "mvt": ("highly parallel", "x1 += A·y1; x2 += Aᵀ·y2, parallel"), + "2mm": ("highly parallel", "two chained gemms, parallel"), + "3mm": ("highly parallel", "three chained gemms, parallel"), + "symm": ("highly parallel", "symmetric gemm (lower triangle), parallel"), + "syrk": ("highly parallel", "symmetric rank-k update (lower triangle)"), + "syr2k": ("highly parallel", "symmetric rank-2k update (lower triangle)"), + "trmm": ("highly parallel", + "triangular gemm — (i,j) parallel, k reduction; raise " + "splits the per-i body into 2 memref linalg ops which " + "the matcher can't see today (form-gated)"), + + # Stencils — body parallel, outer time loop is sequential. + "jacobi-1d": ("parallel + T loop", + "3-point 1D smoother; T steps sequential, inner parallel"), + "jacobi-2d": ("parallel + T loop", + "5-point 2D stencil; T steps sequential, inner parallel"), + "heat-3d": ("parallel + T loop", + "7-point 3D Laplacian; T steps sequential, inner highly parallel"), + "fdtd-2d": ("parallel + T loop", + "E/H field cross-updates; T steps sequential, inner parallel"), + "adi": ("parallel + T loop", + "alternating direction implicit; T+sweep loops sequential, " + "tridiagonal solves inside each sweep partially serial"), + + # Mixed: significant parallel ops plus reductions/serial constraints. + "correlation": ("partial parallel", + "mean + stddev reductions parallel; output is symmetric, " + "diagonal/off-diagonal phases mostly parallel"), + "covariance": ("partial parallel", + "mean reduction + centered outer product; mostly parallel " + "with reduction phases"), + "doitgen": ("partial parallel", + "inner contraction parallel; outer r-update sweep " + "has loop-carried scratch buffer"), + "floyd-warshall":("partial parallel", + "all-pairs shortest path: (i,j) parallel per k, but k loop " + "is strictly sequential (each k uses previous k's distances)"), + + # Strictly serial / poor GPU fit. + "cholesky": ("serial", + "L·Lᵀ factorization — outer k column update carries " + "dependency to all later columns; small inner parallelism"), + "lu": ("serial", + "LU factorization — same column-sequential pattern as cholesky"), + "ludcmp": ("serial", + "LU + forward/back substitution — substitution phase is " + "strictly sequential"), + "gramschmidt": ("serial", + "modified Gram-Schmidt — each column projects against ALL " + "previously orthogonalized columns; strictly sequential"), + "trisolv": ("serial", + "triangular solve — y[i] depends on y[0..i-1]; sequential " + "row-by-row"), + "durbin": ("serial", + "Levinson-Durbin recurrence — O(N²) outer loop with full " + "scalar carry (α, β) between iterations; needs persistent " + "CUDA kernel with cooperative-groups sync"), + "nussinov": ("serial", + "RNA folding DP — sequential over diagonals, each cell " + "reads from prior diagonals"), + "seidel-2d": ("serial", + "Gauss-Seidel stencil — IN-PLACE writes within an inner " + "iteration, so each cell reads values updated earlier in " + "the SAME sweep; not naturally parallel"), + "deriche": ("serial", + "recursive IIR filter — output sample y[i] depends on " + "y[i-1..i-k]; sequential along the filter axis"), +} + + +# Per-kernel blocker classification: which BLOCKER_TAXONOMY tag applies, +# plus a kernel-specific one-liner. Used to render the "Blocker" column +# in the index and to power the taxonomy panel at the top of each section. +# Kernels not listed default to "none". +POLYBENCH_BLOCKERS: dict[str, tuple[str, str]] = { + "gemm": ("none", ""), + "syr2k": ("none", ""), + "syrk": ("none", ""), + "gesummv": ("none", ""), + "gemver": ("none", ""), + "symm": ("matcher-gap", "lifts, but one residual linalg.generic shape (symm-edge) isn't in library"), + "trmm": ("matcher-gap", "lifts cleanly to cublasDtrmm; one residual triangular-edge body unmatched"), + "atax": ("none", ""), + "bicg": ("none", ""), + "mvt": ("none", ""), + "2mm": ("none", ""), + "3mm": ("none", ""), + "doitgen": ("matcher-gap", "lifts; the per-iter scratch-copy body isn't in the library"), + "cholesky": ("serial-recurrence", "lower-triangular factorization — column k modifies columns 0..k-1, k+1..N-1 depends on them"), + "gramschmidt": ("serial-recurrence", "column-by-column modified Gram-Schmidt — column k+1 reads what column k just wrote"), + "lu": ("serial-recurrence", "LU factorization — pivot row k modifies rows >k that subsequent iterations consume"), + "trisolv": ("serial-recurrence", "triangular solve — y[i] depends on y[0..i-1]"), + "ludcmp": ("serial-recurrence", "LU + triangular solve — both phases have row-by-row carry"), + "durbin": ("serial-recurrence", "Levinson-Durbin recurrence — alpha/beta scalars carried across outer k iterations"), + "heat-3d": ("t-loop", "7-point 3D Laplacian update; T-step outer loop is serial, inner 3D body parallel"), + "jacobi-2d": ("t-loop", "5-point 2D smoother; T steps serial, inner 2D parallel"), + "jacobi-1d": ("t-loop", "3-point 1D smoother; T steps serial, inner 1D parallel"), + "fdtd-2d": ("t-loop", "Yee FDTD E/H field update; T steps serial, per-step body parallel"), + "seidel-2d": ("serial-recurrence", "Gauss-Seidel — in-place writes within one sweep; current cell reads values updated earlier in SAME sweep"), + "adi": ("t-loop", "ADI (alternating direction implicit) — T-step outer, direction sweeps inside"), + "floyd-warshall":("none", ""), + "deriche": ("serial-recurrence", "recursive IIR filter — y[i] depends on y[i-1..i-k] along the filter axis"), + "nussinov": ("serial-recurrence", "RNA folding DP — diagonal sweep, each cell reads from prior diagonals"), + "correlation": ("scratch-carry", "row-mean + variance accumulation; residual is the cross-pass scratch in cov-style outer loops"), + "covariance": ("scratch-carry", "mean-centred outer product; residual is the cross-pass scratch state"), +} + +MACHSUITE_BLOCKERS: dict[str, tuple[str, str]] = { + "aes": ("cgeist-frontend", "byte-oriented AES with 256-entry sbox lookups; cgeist crashes parsing"), + "backprop": ("matcher-gap", "lifts 36 linalg.generic ops; neural-net body shapes (matmul+bias+sigmoid) not in library"), + "bfs-bulk": ("cgeist-frontend", "bulk-synchronous BFS with struct/queue manipulation; cgeist crashes"), + "bfs-queue": ("non-affine", "queue-based BFS; level/horizon-driven iteration not affine"), + "fft-strided": ("non-affine", "bit-reversal addressing: `for (span = N/2; span; span >>= 1)` — not affine"), + "fft-transpose": ("non-affine", "FFT butterflies with bit-reversed access patterns; partial body lifts but FFT shape outside model"), + "gemm-ncubed": ("none", ""), + "gemm-blocked": ("matcher-gap", "tiled gemm; collapses to a single linalg.generic but extra tiling loops survive"), + "kmp": ("non-affine", "KMP string matching — backtracking on failure, control-flow heavy"), + "md-grid": ("cgeist-frontend", "molecular dynamics with neighbour-list structs; cgeist crashes"), + "md-knn": ("debuf-bug", "raises cleanly; debufferize hits the gramschmidt-class dominance bug"), + "nw": ("serial-recurrence", "Needleman-Wunsch alignment DP; row depends on previous row's cells"), + "sort-merge": ("cgeist-frontend", "recursive merge sort; cgeist's analysis doesn't handle the recursion"), + "sort-radix": ("non-affine", "radix sort with counting buckets; some bucket fills lift but the sort itself is non-affine"), + "spmv-crs": ("non-affine", "sparse matvec CRS — indirect `cols[]` index into the values array"), + "spmv-ellpack": ("non-affine", "same — sparse indirect addressing"), + "stencil2d": ("matcher-gap", "9-tap 3x3 conv2d body; lifts cleanly but matcher has no conv2d-3x3 template"), + "stencil3d": ("none", ""), + "viterbi": ("cgeist-frontend", "Viterbi DP + arg-max; cgeist crashes on the array-of-struct probability table"), +} + +NPB_BLOCKERS: dict[str, tuple[str, str]] = { + "bt-add": ("matcher-gap", "4D elementwise add lifts cleanly; matcher's add templates are only 1D/2D today"), + "ft-evolve": ("indirect-index", "ex[t*indexmap[k][j][i]] is a data-dependent index — raise pass refuses"), + "lu-l2norm": ("matcher-gap", "inner sum-of-squares reduction lifts + matches; outer init loop is unmatched"), + "mg-psinv": ("scratch-carry", "27-stencil via per-row r1/r2 scratch buffers; the scaffolded row-privatization pass would unblock"), + "mg-resid": ("scratch-carry", "same shape as psinv"), + "mg-rprj3": ("scratch-carry", "restriction operator with x1/y1 row scratch; same shape"), + "mg-norm2u3": ("mixed-reductions", "combined L2 sum + L∞ max in one loop nest; raise rejects the dual-reduction iter_arg"), +} + +# ===================================================================== +# Jetson Orin silicon runtime measurements. +# ===================================================================== +# +# For kernels that have actually been silicon-validated, one entry per +# (kernel, dataset) combination. The driver (scripts/correctness/ +# polygeist_build.sh --target=jetson) cross-compiles two binaries from +# the same source: +# - "gpu": Polygeist-lifted kernel routed through cuDNN/cuBLAS via +# our runtime shim. Time captured from polybench's built-in +# timer (-DPOLYBENCH_TIME prints seconds to stdout). +# - "cpu": Plain aarch64-linux-gnu-gcc -O3 build of the same .c +# linked with polybench.c; no Polygeist. Runs the textbook +# C loop on Jetson's aarch64 CPU. Same timing method. +# +# Both shipped to Jetson Orin via the dev-box bounce and run; outputs +# diffed for correctness. Last-decimal FP precision drift at large sizes +# is normal — cuBLAS/cuDNN use tiled reductions with a different +# summation order than the textbook 3-loop, so e.g. `447.11` printed by +# the CPU might come out `447.10` on the GPU. PolyBench's reference +# considers these equivalent. +# +# Schema per entry: +# { "size": "MINI" | "LARGE" | "EXTRALARGE" (PolyBench dataset) +# or numeric string for non-PolyBench kernels +# "gpu_s": cuDNN/cuBLAS kernel time in seconds +# "cpu_s": aarch64 textbook-C kernel time in seconds +# "correct": "PASS" | "FP-noise" | "DIFF" | "ABORT" +# "FP-noise" = same algorithm, last-decimal rounding +# differs; functionally equivalent. +# } +# +# All numbers below are from the *zero-copy* runtime path (cudaHostRegister +# polybench buffers + pass to cuBLAS via cudaHostGetDevicePointer; no +# cudaMalloc + cudaMemcpy bounce within Jetson's unified DRAM). MINI numbers +# dropped ~3× from the older malloc+copy runs; LARGE 25–30% for gemv-style +# kernels (bandwidth-bound), 1.5–2× for gemm-style (compute-bound but +# H↔D copy still meaningful). +# +# "notes" field (optional) is a short blurb shown in the explorer's Notes +# column — used to explain why a specific (kernel, size) entry has +# unexpected slowness or peculiar behaviour. Leave empty when no +# explanation needed (clean compute-bound wins, etc.). +JETSON_RUNTIMES: dict[str, list[dict]] = { + "gemm": [ + {"size": "MINI", "gpu_s": 0.029207, "cpu_s": 0.000009, "correct": "PASS", + "notes": "Setup-bound: cuBLAS handle init + first cudaHostRegister dominate; 1024 flops too small to amortise"}, + {"size": "LARGE", "gpu_s": 0.078334, "cpu_s": 0.631510, "correct": "FP-noise", + "notes": ""}, + {"size": "EXTRALARGE", "gpu_s": 0.405161, "cpu_s": 7.138352, "correct": "FP-noise", + "notes": ""}, + ], + "2mm": [ + {"size": "MINI", "gpu_s": 0.029192, "cpu_s": 0.000013, "correct": "PASS", + "notes": "Setup-bound (same as gemm MINI)"}, + {"size": "LARGE", "gpu_s": 0.095777, "cpu_s": 4.974022, "correct": "FP-noise", + "notes": ""}, + {"size": "EXTRALARGE", "gpu_s": 0.466833, "cpu_s": 51.175102, "correct": "FP-noise", + "notes": ""}, + ], + "3mm": [ + {"size": "MINI", "gpu_s": 0.030220, "cpu_s": 0.000020, "correct": "PASS", + "notes": "Setup-bound (same as gemm MINI)"}, + {"size": "LARGE", "gpu_s": 0.142634, "cpu_s": 5.883726, "correct": "PASS", + "notes": ""}, + {"size": "EXTRALARGE", "gpu_s": 0.779139, "cpu_s": 61.008747, "correct": "PASS", + "notes": ""}, + ], + # SYRK dataset sizes: MINI=32², LARGE=2000², + # EXTRALARGE=4000². Matched as cublasDgemm (A·Aᵀ via OP_T). + "syrk": [ + {"size": "MINI", "gpu_s": 0.028913, "cpu_s": 0.000029, "correct": "PASS", + "notes": "Setup-bound; A=B alias hits register cache early"}, + {"size": "LARGE", "gpu_s": 0.289359, "cpu_s": 8.684662, "correct": "FP-noise", + "notes": "cuBLAS dgemm with B=A pointer alias; native cublasDsyrk would be ~2× faster"}, + {"size": "EXTRALARGE", "gpu_s": 1.952076, "cpu_s": 69.050941, "correct": "FP-noise", + "notes": "Same as LARGE — dgemm-emulated syrk"}, + ], + # Convolution-2d dataset sizes per the benchmark header: + # convolution-2d.h: MINI=64², LARGE=4096², EXTRALARGE=8192². + # Matched as cudnnConvolution2D_9tap_f32. cuDNN is slower than the + # CPU reference at all sizes because the 3×3 stencil has very low + # arithmetic intensity (9 muls + 9 loads per output) — bandwidth- + # bound, cuDNN setup overhead dominates. Numeric outputs match + # (sorted-distribution identical to %0.2lf precision; differences + # are rounding artifacts at the third decimal). + "convolution-2d": [ + {"size": "MINI", "gpu_s": 0.027487, "cpu_s": 0.000014, "correct": "FP-noise", + "notes": "cuDNN descriptor + workspace setup ≫ actual 64² stencil; CPU 14 µs is just the math"}, + {"size": "LARGE", "gpu_s": 0.139948, "cpu_s": 0.045992, "correct": "FP-noise", + "notes": "3×3 stencil = 9 muls per output: arithmetic intensity ~1, bandwidth-bound; cuDNN can't reuse"}, + {"size": "EXTRALARGE", "gpu_s": 0.305478, "cpu_s": 0.186424, "correct": "FP-noise", + "notes": "Same story as LARGE; CPU's wider memory subsystem competitive at this AI"}, + ], + # atax + bicg — gemv-based kernels. The matcher's + # transpose discriminator (rewriter inspects A's first indexing-map + # output dim vs the output vector's first dim) now emits + # @cublasDgemv vs @cublasDgemv_T, and the downstream lowering routes + # each to the right cuBLAS op flag (CUBLAS_OP_T vs CUBLAS_OP_N). + # Both kernels are now bit-exact MINI; LARGE uses the same routing + # and should be equivalent (LARGE dump diff not run). + # atax/bicg/mvt/gesummv/gemver — all five gemv-based + # kernels now build + run cleanly after two consecutive fixes: + # + # 1. Matcher transpose discriminator: rewriter emits @cublasDgemv vs + # @cublasDgemv_T based on whether A's first indexing-map dim + # matches the output vector's dim. Downstream picks OP_T or OP_N. + # + # 2. -Dstatic=__attribute__((noipa)) in harness CFLAGS: prevents + # gcc -O3 from intraprocedurally deducing "kernel_*() preserves + # w0" and skipping the AArch64-mandated w0 reload before + # print_array. With static functions weakened via objcopy and + # replaced at link time, the cached IPA assumptions were wrong. + # Tagging the body as noipa keeps gcc honest. + # + # atax / bicg / gesummv: bit-exact GPU vs CPU dump (md5 match). + # mvt / gemver: small numerical drift remains — separate matcher + # bug where the accumulating init step isn't fissioned correctly + # (kernel does x1 = A·y_1 with β=0 instead of x1 += A·y_1), so the + # initial-value contribution from polybench init_array is dropped. + "atax": [ + {"size": "MINI", "gpu_s": 0.035718, "cpu_s": 0.000002, "correct": "PASS", + "notes": "Setup-bound; 32² gemv is trivial"}, + {"size": "LARGE", "gpu_s": 0.243491, "cpu_s": 0.106797, "correct": "PASS", + "notes": "cuBLAS dgemv(OP_T) strided reads; ~2% of peak DRAM BW; CPU 2× faster"}, + ], + "bicg": [ + {"size": "MINI", "gpu_s": 0.035921, "cpu_s": 0.000004, "correct": "PASS", + "notes": "Setup-bound"}, + {"size": "LARGE", "gpu_s": 0.244687, "cpu_s": 0.293824, "correct": "PASS", + "notes": "Bandwidth-bound dgemv; tied with CPU"}, + ], + "gesummv": [ + {"size": "MINI", "gpu_s": 0.032386, "cpu_s": 0.000004, "correct": "PASS", + "notes": "Setup-bound"}, + {"size": "LARGE", "gpu_s": 0.242233, "cpu_s": 0.293041, "correct": "PASS", + "notes": "Two streaming dgemvs through A, B; bandwidth-bound; marginal GPU win"}, + ], + "mvt": [ + {"size": "MINI", "gpu_s": 0.036262, "cpu_s": 0.000002, "correct": "DIFF", + "notes": "Matcher missed accumulating init: kernel overwrites x1/x2 with β=0 instead of += . Numerically off, timing OK"}, + ], + "gemver": [ + {"size": "MINI", "gpu_s": 0.033820, "cpu_s": 0.000003, "correct": "DIFF", + "notes": "Same matcher-fission bug as mvt: initial value dropped"}, + {"size": "LARGE", "gpu_s": 0.390434, "cpu_s": 0.575250, "correct": "DIFF", + "notes": "Same bug; also 4 separate ops on A (2 gers + 2 gemvs) all bandwidth-bound; could be 5× faster with fused kernel"}, + ], +} + +# Warmed in-process comparison against handwritten PolyBenchGPU CUDA kernels. +# Method: Jetson Orin, N/NI/NJ/NK/NL/NM=512, double precision, 50 iterations +# in a single process, discard the first 10 warmup iterations, then report a +# 10% trimmed mean over the remaining 40 samples. Raised numbers are summed +# device-event timings from the runtime shims; PolyBenchGPU numbers are CUDA +# event timings around the handwritten kernel sequence. CPU comparison is +# intentionally not rendered in the PolyBench tracker for now. +POLYBENCHGPU_RUNTIMES: dict[str, list[dict]] = { + "gemm": [ + {"size": "512 warmed", "raised_ms": 3.808535, "pbgpu_ms": 7.696930, + "notes": "Raised path uses cuBLAS dgemm; first cuBLAS cold-start iteration discarded"}, + ], + "2mm": [ + {"size": "512 warmed", "raised_ms": 7.639525, "pbgpu_ms": 11.200252, + "notes": "Raised path is two warmed cuBLAS dgemms plus host helper ops"}, + ], + "3mm": [ + {"size": "512 warmed", "raised_ms": 11.451146, "pbgpu_ms": 10.500537, + "notes": "Only current warmed case where handwritten PolyBenchGPU is slightly faster"}, + ], + "gesummv": [ + {"size": "512 warmed", "raised_ms": 0.069274, "pbgpu_ms": 0.341379, + "notes": "Raised path is two warmed cuBLAS gemv calls plus host axpby"}, + ], + "gemver": [ + {"size": "512 warmed", "raised_ms": 0.188384, "pbgpu_ms": 0.312846, + "notes": "Raised path is warmed ger/gemv/axpy sequence"}, + ], +} + +LLAMA_FORWARD_RUNTIMES: dict[str, list[dict]] = { + "token_embedding": [ + {"size": "toy standalone warm", "raised": "host 0.0319 ms
device 0.0243 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "Jetson Orin, REPEAT=50, first 5 iterations discarded"}, + ], + "attention_rmsnorm": [ + {"size": "toy standalone warm", "raised": "host 0.0652 ms
device 0.0471 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "RMSNorm composition via runtime shim"}, + ], + "qkv_projection": [ + {"size": "toy standalone warm", "raised": "host 0.0687 ms
device 0.0446 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "Six emitted launches for split Q/K/V projection fixture"}, + ], + "rope_interleaved": [ + {"size": "not run", "raised": "not raised", "reference": "not measured", + "winner": "n/a", "notes": "Exact interleaved RoPE still leaves loops"}, + ], + "rope_split": [ + {"size": "toy standalone warm", "raised": "host 0.1486 ms
device 0.0969 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "Raise-friendly split even/odd RoPE"}, + ], + "kv_cache_rw": [ + {"size": "toy standalone warm", "raised": "host 0.1244 ms
device 0.0908 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "KV write at current position plus cache read fixture"}, + ], + "attention_scores": [ + {"size": "toy standalone warm", "raised": "host 0.0215 ms
device 0.0135 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "QK score reduction over heads/pairs"}, + ], + "attention_mask_if": [ + {"size": "not run", "raised": "not raised", "reference": "not measured", + "winner": "n/a", "notes": "Branchy mask variant still leaves if/loop IR"}, + ], + "attention_mask_select": [ + {"size": "toy standalone warm", "raised": "host 0.0422 ms
device 0.0275 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "Branchless causal mask"}, + ], + "attention_softmax": [ + {"size": "toy standalone warm", "raised": "host 0.0552 ms
device 0.0384 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "Max-shift softmax composition"}, + ], + "attention_output": [ + {"size": "toy standalone warm", "raised": "host 0.0208 ms
device 0.0128 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "Weighted sum over V cache"}, + ], + "output_projection": [ + {"size": "toy standalone warm", "raised": "host 0.0252 ms
device 0.0157 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "Attention output projection"}, + ], + "residual_add": [ + {"size": "toy standalone warm", "raised": "host 0.0440 ms
device 0.0361 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "Elementwise residual add"}, + ], + "ffn_rmsnorm": [ + {"size": "toy standalone warm", "raised": "host 0.0652 ms
device 0.0465 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "Same shape as attention RMSNorm"}, + ], + "gate_up_projection": [ + {"size": "toy standalone warm", "raised": "host 0.0445 ms
device 0.0286 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "Gate/up FFN projection fixture"}, + ], + "swiglu": [ + {"size": "toy standalone warm", "raised": "host 0.0376 ms
device 0.0248 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "Elementwise SiLU(gate) * up"}, + ], + "down_projection": [ + {"size": "toy standalone warm", "raised": "host 0.0252 ms
device 0.0156 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "FFN down projection"}, + ], + "final_rmsnorm": [ + {"size": "toy standalone warm", "raised": "host 0.0662 ms
device 0.0475 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "Final RMSNorm before logits"}, + ], + "lm_head_projection": [ + {"size": "toy standalone warm", "raised": "host 0.0246 ms
device 0.0156 ms", + "reference": "not measured", "winner": "raised-only", + "notes": "LM head GEMV to logits"}, + ], + "extended_forward": [ + {"size": "7B-size one layer warm", "raised": "host 13.480 ms
device 12.273 ms", + "reference": "ggml CUDA host 9.638 ms", "winner": "ggml 1.40x", + "notes": "MODEL_DIM=4096, FFN_DIM=11008, VOCAB=32000, SEQ_LEN=2048, HEADS=32; one layer only"}, + {"size": "toy one layer warm", "raised": "host 0.719 ms
device 0.447 ms", + "reference": "ggml CUDA host 0.098 ms", "winner": "ggml 7.3x", + "notes": "MODEL_DIM=64, FFN_DIM=128, VOCAB=256, SEQ_LEN=32; useful for IR/debugging"}, + ], +} + +STENCIL_CONV2D_RUNTIMES: dict[str, list[dict]] = { + "box3x3": [ + {"size": "64x64 warm", "raised": "host 0.426 ms
device 0.0059 ms", + "reference": "cuDNN 3x3 f32", "winner": "raised-only", + "notes": "REPEAT=20, first 5 discarded; checksum -0.41999996"}, + ], + "gaussian3x3": [ + {"size": "64x64 warm", "raised": "host 0.418 ms
device 0.0059 ms", + "reference": "cuDNN 3x3 f32", "winner": "raised-only", + "notes": "REPEAT=20, first 5 discarded; checksum -0.42000079"}, + ], + "sobel_x3x3": [ + {"size": "64x64 warm", "raised": "host 0.425 ms
device 0.0059 ms", + "reference": "cuDNN 3x3 f32", "winner": "raised-only", + "notes": "REPEAT=20, first 5 discarded; checksum -5.88010693"}, + ], + "sobel_y3x3": [ + {"size": "64x64 warm", "raised": "host 0.423 ms
device 0.0059 ms", + "reference": "cuDNN 3x3 f32", "winner": "raised-only", + "notes": "REPEAT=20, first 5 discarded; checksum 4.11986542"}, + ], + "laplacian4_3x3": [ + {"size": "64x64 warm", "raised": "host 0.166 ms
device 0.0417 ms", + "reference": "cuDNN 3x3 f32", "winner": "raised-only", + "notes": "REPEAT=20, first 5 discarded; checksum 0.00000403"}, + ], + "laplacian8_3x3": [ + {"size": "64x64 warm", "raised": "host 0.157 ms
device 0.0366 ms", + "reference": "cuDNN 3x3 f32", "winner": "raised-only", + "notes": "REPEAT=20, first 5 discarded; checksum -0.00000316"}, + ], + "sharpen3x3": [ + {"size": "64x64 warm", "raised": "host 0.160 ms
device 0.0392 ms", + "reference": "cuDNN 3x3 f32", "winner": "raised-only", + "notes": "REPEAT=20, first 5 discarded; checksum -0.42001334"}, + ], + "emboss3x3": [ + {"size": "64x64 warm", "raised": "host 0.162 ms
device 0.0399 ms", + "reference": "cuDNN 3x3 f32", "winner": "raised-only", + "notes": "REPEAT=20, first 5 discarded; checksum -1.74002242"}, + ], + "box5x5": [ + {"size": "64x64 warm", "raised": "host 0.417 ms
device 0.0082 ms", + "reference": "cuDNN 5x5 f32", "winner": "raised-only", + "notes": "REPEAT=20, first 5 discarded; checksum -0.02519889"}, + ], + "gaussian5x5": [ + {"size": "64x64 warm", "raised": "host 0.160 ms
device 0.0399 ms", + "reference": "cuDNN 5x5 f32", "winner": "raised-only", + "notes": "REPEAT=20, first 5 discarded; checksum -0.48238647"}, + ], + "sobel_x5x5": [ + {"size": "64x64 warm", "raised": "host 0.155 ms
device 0.0400 ms", + "reference": "cuDNN 5x5 f32", "winner": "raised-only", + "notes": "REPEAT=20, first 5 discarded; checksum 225.14791870"}, + ], + "sobel_y5x5": [ + {"size": "64x64 warm", "raised": "host 0.156 ms
device 0.0369 ms", + "reference": "cuDNN 5x5 f32", "winner": "raised-only", + "notes": "REPEAT=20, first 5 discarded; checksum 12.86828041"}, + ], + "laplacian5x5": [ + {"size": "64x64 warm", "raised": "host 0.170 ms
device 0.0416 ms", + "reference": "cuDNN 5x5 f32", "winner": "raised-only", + "notes": "REPEAT=20, first 5 discarded; checksum -17.16963387"}, + ], + "sharpen5x5": [ + {"size": "64x64 warm", "raised": "host 0.159 ms
device 0.0399 ms", + "reference": "cuDNN 5x5 f32", "winner": "raised-only", + "notes": "REPEAT=20, first 5 discarded; checksum -2.78251743"}, + ], + "emboss5x5": [ + {"size": "64x64 warm", "raised": "host 0.162 ms
device 0.0403 ms", + "reference": "cuDNN 5x5 f32", "winner": "raised-only", + "notes": "REPEAT=20, first 5 discarded; checksum 18.00988960"}, + ], + "box7x7": [ + {"size": "64x64 warm", "raised": "host 0.433 ms
device 0.0109 ms", + "reference": "cuDNN ntap f32", "winner": "raised-only", + "notes": "tensor ntap, K=7, W[49] packed ABI; REPEAT=20, first 5 discarded; checksum 0.03551028"}, + ], +} + +# llama2.c blockers — all three lift to linalg.generic cleanly. RMSNorm, +# softmax, and the tensor GEMV form now match/lower through runtime ABI paths; +# the whole tiny-forward fixture currently replaces RMSNorm + GEMV while +# leaving the softmax max/normalize tail as residual tensor code. +LLAMA2C_BLOCKERS: dict[str, tuple[str, str]] = { + "matmul": ("none", "Tensor GEMV form emits @cublasSgemv / @cublasSgemv_T and lowers to cuBLAS SGEMV; validated in the tiny forward fixture on Jetson."), + "rmsnorm": ("none", "2-step composition matches the ss = sum(x²) reduction + weighted-scale generic. Emits @rmsnorm_f32 for memref or @rmsnorm_f32_tensor after debufferize, lowering to polygeist_rmsnorm_f32."), + "softmax": ("none", "3-step composition matches max-reduce + fused exp+sum (multi-yield) + parallel divide. Emits @cudnnSoftmaxForward, lowers to polygeist_cudnn_softmax_forward_f32, and runs on Jetson through cudnnSoftmaxForward."), +} + +LLAMA_FORWARD_BLOCKERS: dict[str, tuple[str, str]] = { + "token_embedding": ("none", ""), + "attention_rmsnorm": ("none", ""), + "qkv_projection": ("none", "Raises and matches as split GEMV/copy forms for the standalone fixture."), + "rope_interleaved": ("matcher-gap", "Exact interleaved layout still leaves residual loops; split even/odd RoPE is the currently matched form."), + "rope_split": ("none", ""), + "kv_cache_rw": ("none", ""), + "attention_scores": ("none", ""), + "attention_mask_if": ("matcher-gap", "Branchy if form still leaves residual control flow; branchless select form raises and matches."), + "attention_mask_select": ("none", ""), + "attention_softmax": ("none", ""), + "attention_output": ("none", ""), + "output_projection": ("none", ""), + "residual_add": ("none", ""), + "ffn_rmsnorm": ("none", ""), + "gate_up_projection": ("none", ""), + "swiglu": ("none", ""), + "down_projection": ("none", ""), + "final_rmsnorm": ("none", ""), + "lm_head_projection": ("none", ""), + "extended_forward": ("none", "Full fixture emits 34 runtime calls after lowering and matches native C logits on Jetson; it uses split RoPE and branchless mask to stay inside today's raising envelope."), +} + +WHISPER_OPS_BLOCKERS: dict[str, tuple[str, str]] = { + "whisper_vec_dot": ("none", "Raises to tensor linalg and matches the current dot-product template."), + "whisper_vec_softmax": ("matcher-gap", "Raises to tensor linalg in the scalar path. Direct ggml vec.cpp hits SIMD frontend issues, so this fixture captures the canonical math body."), + "whisper_softmax_full": ("none", "Raises as max-reduce + exp/sum + normalize and matches the out-of-place cuDNN softmax template, including the multiply-by-reciprocal normalize spelling."), + "whisper_rms_norm": ("runtime-gap", "Matches the RMSNorm family as unweighted RMSNorm and emits the tensor launch form; runtime/library lowering for the unweighted ABI is still follow-up work."), + "whisper_gelu": ("runtime-gap", "Raises to one elementwise tensor linalg.generic with math.tanh and matches the GELU template; ABI lowering/runtime support for the GELU launch is still follow-up work."), + "whisper_conv1d": ("matcher-gap", "Raises and matches the per-output inner dot, but still leaves one output-position loop; full 1D conv composition/library routing is future matcher work."), + "whisper_quantize_q4_0_ref": ( + "no-linalg", + "Compiles and reaches the raise pipeline, but the result has no linalg.generic and still contains loops/ifs plus fp16 conversion, struct stores, and bit-packing.", + ), + "whisper_decode_residue": ( + "raise-fail", + "cgeist emits MLIR, but raise fails on a mixed LLVM/memref load: llvm.load result must be an LLVM type with size, got memref.", + ), + "whisper_inverse_mdct": ( + "no-linalg", + "The source is an algorithmic IMDCT kernel, but the current selected artifact contains no useful raised function body or linalg.generic.", + ), +} + +STENCIL_CONV2D_BLOCKERS: dict[str, tuple[str, str]] = { + "box3x3": ("none", ""), + "gaussian3x3": ("none", ""), + "sobel_x3x3": ("none", ""), + "sobel_y3x3": ("none", ""), + "laplacian4_3x3": ("none", ""), + "laplacian8_3x3": ("none", ""), + "sharpen3x3": ("none", ""), + "emboss3x3": ("none", ""), + "box5x5": ("none", ""), + "gaussian5x5": ("none", ""), + "sobel_x5x5": ("none", ""), + "sobel_y5x5": ("none", ""), + "laplacian5x5": ("none", ""), + "sharpen5x5": ("none", ""), + "emboss5x5": ("none", ""), + "box7x7": ("none", ""), +} + +# llm.c blockers — wider coverage than llama2.c includes both forward AND +# backward kernels, plus attention and gelu which surface new blocker classes: +# math.h ext-call bodies (gelu/crossentropy via tanhf/logf), nested +# affine-for+tensor-yield shapes that multi-root debuf can't dominance-resolve +# (layernorm-fwd/bwd), and indirect-index lookup (encoder). +LLMC_BLOCKERS: dict[str, tuple[str, str]] = { + "encoder-fwd": ("indirect-index", "out[b,t,c] = wte[inp[b,t]*C+c] + wpe[t*C+c]; data-dependent index into wte"), + "encoder-bwd": ("indirect-index", "scatter-accumulate by inp[b,t]; raise rejects indirect target index"), + "layernorm-fwd": ("debuf-bug", "raises to 3 linalg.generic ops; BOTH v2 and multi-root debuf hit a dominance bug on the nested affine.for tensor.insert/yield chain"), + "layernorm-bwd": ("debuf-bug", "same dominance failure as layernorm-fwd in both debuf paths"), + "matmul-fwd-naive": ("none", ""), + "matmul-bwd": ("matcher-gap", "raises 2 linalg.generic (dinp + dweight + dbias accumulation); matcher only matches one shape"), + "attention-fwd": ("matcher-gap", "raises 4 linalg.generic (Q·Kᵀ, max-shift, exp+sum, softmax·V); v2 debuf fails on softmax-fused tuple-yield, multi-root succeeds; full attention body not in matcher library"), + "attention-bwd": ("matcher-gap", "raises 1 generic; gradient-through-attention shape not in library"), + "gelu-fwd": ("ext-math-call", "body calls tanhf — raise can't fold an extern math.h call into a pure-arith linalg.generic body"), + "gelu-bwd": ("ext-math-call", "body calls tanhf + coshf — same ext-call block"), + "residual-fwd": ("matcher-gap", "single fully-parallel elementwise add; matcher has no axpy/add template that matches this shape"), + "residual-bwd": ("matcher-gap", "two parallel elementwise dinp += dout generics; same axpy gap"), + "softmax-fwd": ("matcher-gap", "per-row softmax with max-shift wrapped in (B, T) outer affine.fors plus an additional masking generic. The base 3-step softmax composition (commit 1235c28) matches llama2's flat softmax but not this nested form. Needs either an outer-loop hoist pass to strip the B/T fors and re-match per row, or a separate 4-step composition that includes the masking step"), + "crossentropy-fwd": ("ext-math-call", "body calls logf with indirect-indexed probs[target[b,t]]; raise can't lift"), + "crossentropy-softmax-bwd": ("matcher-gap", "raises 1 linalg.generic — the fused softmax-CE backward formula; shape not in matcher library"), +} + + +def find_kernel_c(name: str, kset: str = "polybench") -> Path | None: + """Find .c. Dispatches per kernel-set.""" + if kset == "machsuite": + info = MACHSUITE_KERNELS.get(name) + if not info: + return None + subdir, _fn = info + # The kernel .c is the only .c in the subdir that's not local_support + # or generate (per MachSuite layout convention). + for p in (MACHSUITE_ROOT / subdir).glob("*.c"): + if p.name in ("local_support.c", "generate.c"): + continue + return p + return None + if kset == "npb": + info = NPB_KERNELS.get(name) + if not info: + return None + srcname, _fn = info + p = NPB_ROOT / srcname + return p if p.exists() else None + if kset == "llama2c": + info = LLAMA2C_KERNELS.get(name) + if not info: + return None + srcname, _fn = info + p = LLAMA2C_ROOT / srcname + return p if p.exists() else None + if kset == "llama_forward": + info = LLAMA_FORWARD_KERNELS.get(name) + if not info: + return None + srcname, _fn = info + p = LLAMA_FORWARD_ROOT / srcname + return p if p.exists() else None + if kset == "whisper_ops": + info = WHISPER_OPS_KERNELS.get(name) + if not info: + return None + srcname, _fn = info + p = WHISPER_OPS_ROOT / srcname + return p if p.exists() else None + if kset == "aten_c": + info = ATEN_C_KERNELS.get(name) + if not info: + return None + srcname, _fn = info + p = ATEN_C_ROOT / srcname + return p if p.exists() else None + if kset == "stencil_conv2d": + info = STENCIL_CONV2D_KERNELS.get(name) + if not info: + return None + srcname, _fn = info + p = STENCIL_CONV2D_ROOT / srcname + return p if p.exists() else None + if kset == "llmc": + info = LLMC_KERNELS.get(name) + if not info: + return None + srcname, _fn = info + p = LLMC_ROOT / srcname + return p if p.exists() else None + if kset == "darknet": + info = DARKNET_KERNELS.get(name) + if not info: + return None + srcname, _fn = info + p = DARKNET_ROOT / srcname + return p if p.exists() else None + if kset == "extracted_darknet": + info = EXTRACTED_DARKNET_KERNELS.get(name) + if not info: + return None + srcname, _fn = info + p = EXTRACTED_DARKNET_ROOT / srcname + return p if p.exists() else None + if kset == "fusion_opt": + info = FUSION_OPT_KERNELS.get(name) + if not info: + return None + srcname, _fn = info + p = EXTRACTED_DARKNET_ROOT / srcname + return p if p.exists() else None + # polybench + for p in POLYBENCH_TEST_DIR.rglob(f"{name}.c"): + if "/utilities/" in str(p): + continue + if p.name.endswith(".orig.c"): + continue + return p + return None + + +def discover_kernels(mlir_dir: Path = MLIR_DIR) -> list[str]: + """Return kernel tags present in `mlir_dir`. A kernel is "present" if + it has any of .mlir / _linalg.mlir / _debuf.mlir / + _debuf_mr.mlir — so kernels that fail one stage still show up + in the index with a partial set of tabs.""" + tags: set[str] = set() + for f in mlir_dir.glob("*.mlir"): + name = f.stem + for suffix in ("_debuf_mr", "_debuf", "_linalg"): + if name.endswith(suffix): + name = name[: -len(suffix)] + break + tags.add(name) + return sorted(tags) + + +def build_ce_state(c_src: str, c_kernel_dir: Path, mlir_src: str) -> dict: + """3-visible-pane CE layout state. + + Visible: + - C editor (top-left) + - cgeist_aff compiler reading C editor (bottom-left) + - Opt Pipeline view bound to polygeist-opt:full (right) + + Hidden (in tab stacks alongside the visible panes): + - LLVM IR editor with affine MLIR (tab next to C editor) + - polygeist-opt:full compiler reading MLIR editor (tab next to Opt Pipeline) + The hidden panes still exist so the Opt Pipeline can bind to popt_full. + """ + editor_opts = {"compileOnChange": True, "colouriseAsm": True} + cgeist_compiler_pane = { + "type": "component", + "componentName": "compiler", + "componentState": { + "id": 1, + "source": 1, + "compiler": CGEIST_NAME, + "lang": "c", + "editorid": 1, + "treeid": 0, + "filters": {}, + "options": f"-I{c_kernel_dir}", + "libs": [], + }, + } + popt_compiler_pane = { + "type": "component", + "componentName": "compiler", + "componentState": { + "id": 2, + "source": 2, + "compiler": POPT_NAME, + "lang": "llvm", + "editorid": 2, + "treeid": 0, + "filters": {}, + "options": "", + "libs": [], + }, + } + opt_pipeline_pane = { + "type": "component", + "componentName": "optPipelineView", + "componentState": { + "id": 2, + "lang": "llvm", + "compiler": POPT_NAME, + "compilerName": POPT_DISPLAY, + "editorid": 2, + "treeid": 0, + "selectedGroup": "", + "selectedIndex": 0, + "sidebarWidth": 250, + }, + } + c_editor = { + "type": "component", + "componentName": "codeEditor", + "componentState": {"id": 1, "source": c_src, "lang": "c", "options": editor_opts}, + } + mlir_editor = { + "type": "component", + "componentName": "codeEditor", + "componentState": {"id": 2, "source": mlir_src, "lang": "llvm", "options": editor_opts}, + } + return { + "version": 4, + "content": [{ + "type": "row", + "content": [ + { + "type": "column", + "width": 50, + "content": [ + # Tab stack: C editor active, LLVM IR editor on a hidden tab. + { + "type": "stack", + "activeItemIndex": 0, + "content": [c_editor, mlir_editor], + }, + cgeist_compiler_pane, + ], + }, + # Tab stack: Opt Pipeline active, popt_full compiler on a hidden tab. + { + "type": "stack", + "width": 50, + "activeItemIndex": 0, + "content": [opt_pipeline_pane, popt_compiler_pane], + }, + ], + }], + } + + +def ce_link_from_paths(c_path: Path | None, mlir_path: Path) -> str | None: + """Construct a CE deep link from an explicit C/MLIR artifact pair.""" + if not c_path or not mlir_path.exists(): + return None + c_src = c_path.read_text() + mlir_src = mlir_path.read_text() + # Strip the giant dlti spec — saves a lot of URL space and CE will recompute + # it for the popt_full pane anyway. + mlir_src = re.sub( + r'module attributes \{[^\}]*\}', + 'module', + mlir_src, count=1, + ) + state = build_ce_state(c_src, c_path.parent, mlir_src) + payload = json.dumps(state, separators=(',', ':')) + return CE_BASE + "#" + urllib.parse.quote(payload, safe='') + + +def ce_link(kernel: str, mlir_dir: Path = MLIR_DIR, + kset: str = "polybench") -> str | None: + """Construct the CE deep-link URL for a kernel; None if sources missing.""" + if kset == "whisper_ops" and kernel in WHISPER_OPS_IR_ONLY: + return None + return ce_link_from_paths( + find_kernel_c(kernel, kset=kset), + mlir_dir / f"{kernel}.mlir", + ) + + +def render_html(title: str, body_html: str, css: str) -> str: + return f""" +{title} + +{body_html} +""" + + +def syntax_highlight(text: str, lang: str = "llvm") -> tuple[str, str]: + """Render MLIR as plain text inside a styled 
. We deliberately skip
+    pygments' LLVM lexer because it doesn't recognise MLIR syntax and marks
+    nearly every token with an "error" class — which renders as a red box."""
+    text = re.sub(r"#dlti\.dl_spec<[^>]*>", "(dlti spec hidden)", text)
+    import html
+    return f'
{html.escape(text)}
', ''
+
+
+_LOOP_RE = re.compile(r"\b(affine\.for|scf\.for|scf\.while|scf\.parallel|affine\.parallel)\b")
+
+
+def count_for_loops(text: str) -> int:
+    """Count loop-level ops still in the IR. Each match is one loop nest level
+    that the raise pipeline did NOT lift to a linalg.generic — a measure of how
+    much imperative structure the kernel still carries after the pipeline."""
+    return len(_LOOP_RE.findall(text))
+
+
+def run_rewriter(path: Path) -> tuple[str, list[tuple]]:
+    res = subprocess.run(
+        [PYTHON, str(REWRITER), str(path)],
+        capture_output=True, text=True, timeout=10,
+    )
+    if res.returncode != 0:
+        raise RuntimeError(
+            f"kernel matcher failed for {path} with {PYTHON}:\n{res.stderr}"
+        )
+    out = res.stdout
+    n_launch = len(re.findall(r"kernel\.launch", out))
+    n_lg = len(re.findall(r"linalg\.generic", out))
+    return out, [("launches", n_launch), ("residual_lg", n_lg)]
+
+
+def build_kernel_page(kernel: str, mlir_dir: Path = MLIR_DIR,
+                       kset: str = "polybench",
+                       file_prefix: str = "") -> dict:
+    raised = mlir_dir / f"{kernel}_linalg.mlir"
+    debuf = mlir_dir / f"{kernel}_debuf.mlir"
+    debuf_mr = mlir_dir / f"{kernel}_debuf_mr.mlir"
+    cgeist_mlir = mlir_dir / f"{kernel}.mlir"
+
+    pages: dict[str, str] = {}
+    css = ""
+    n_for = 0
+    n_linalg = 0
+    matched_symbols: list[str] = []
+    report = [("launches", 0), ("residual_lg", 0)]
+
+    if cgeist_mlir.exists():
+        cgeist_text = cgeist_mlir.read_text()
+        html, css = syntax_highlight(cgeist_text)
+        pages["cgeist"] = html
+        if not raised.exists() and not debuf.exists() and not debuf_mr.exists():
+            n_for = count_for_loops(cgeist_text)
+            report = [
+                ("launches", 0),
+                ("residual_lg", len(re.findall(r"linalg\.generic", cgeist_text))),
+            ]
+    if raised.exists():
+        raised_text = raised.read_text()
+        n_linalg = len(re.findall(r"\blinalg\.generic\b", raised_text))
+        html, css = syntax_highlight(raised_text)
+        pages["raised"] = html
+        if not debuf.exists() and not debuf_mr.exists():
+            n_for = count_for_loops(raised_text)
+            report = [
+                ("launches", 0),
+                ("residual_lg", len(re.findall(r"linalg\.generic", raised_text))),
+            ]
+        if kset == "stencil_conv2d" and not debuf.exists():
+            n_for = count_for_loops(raised_text)
+            rewritten, report = run_rewriter(raised)
+            html, css = syntax_highlight(rewritten)
+            pages["matched"] = html
+    if debuf.exists():
+        debuf_text = debuf.read_text()
+        n_for = count_for_loops(debuf_text)
+        html, css = syntax_highlight(debuf_text)
+        pages["debuf"] = html
+        # The exhaustive ATen sweep stores the authoritative matcher output
+        # beside its diagnostics. Reuse it instead of starting one Egglog
+        # process per page (hundreds of avoidable process launches).
+        stored_match = mlir_dir / kernel / "matched.mlir"
+        if kset == "aten_c" and stored_match.exists():
+            rewritten = stored_match.read_text()
+            report = [
+                ("launches", len(re.findall(r"kernel\.launch\s+@", rewritten))),
+                ("residual_lg", len(re.findall(r"\blinalg\.generic\b", rewritten))),
+            ]
+        else:
+            rewritten, report = run_rewriter(debuf)
+        matched_symbols = sorted(set(
+            re.findall(r"kernel\.launch\s+@([A-Za-z0-9_]+)", rewritten)
+        ))
+        html, css = syntax_highlight(rewritten)
+        pages["matched"] = html
+    if debuf_mr.exists():
+        debuf_mr_text = debuf_mr.read_text()
+        html, css = syntax_highlight(debuf_mr_text)
+        pages["debuf_mr"] = html
+        # Fallback: if v2 debuf failed but multi-root succeeded (the
+        # common pattern for whole-program-raise suites),
+        # run the matcher on the multi-root output so the "matched" tab
+        # and the match-status column reflect what's actually achievable.
+        if not debuf.exists() and not debuf_mr_text.lstrip().startswith("//"):
+            n_for = count_for_loops(debuf_mr_text)
+            rewritten, report = run_rewriter(debuf_mr)
+            matched_symbols = sorted(set(
+                re.findall(r"kernel\.launch\s+@([A-Za-z0-9_]+)", rewritten)
+            ))
+            html, css = syntax_highlight(rewritten)
+            pages["matched"] = html
+
+    ce_url = ce_link(kernel, mlir_dir=mlir_dir, kset=kset)
+    open_link = (f''
+                 f'open in Compiler Explorer →') if ce_url else ''
+
+    n_launches = report[0][1]
+    n_resid = report[1][1]
+    summary = (
+        f'
'
+        f'{n_launches} kernel.launch op(s) emitted  ·  '
+        f'{n_resid} residual linalg.generic  ·  '
+        f'{n_for} residual for-loop(s)  |  '
+        f'jump to: cgeist · '
+        f'raised · '
+        f'debuferized · '
+        f'debuf multi-root · '
+        f'kernel.launch output'
+        f'
'
+    )
+    back_href, back_label = "index.html", "index"
+    if kset == "polybench":
+        back_href, back_label = "polybench.html", "PolyBench"
+    elif kset == "aten_c":
+        back_href, back_label = "numerical.html", "ATen"
+    header = (
+        f'
← {back_label} '
+        f'  {kernel}{open_link}
'
+        + summary
+    )
+    body_blocks = []
+    for stage, title in [
+        ("cgeist",   "cgeist output (pre-raise MLIR)"),
+        ("raised",   "raised (memref linalg, before debuferize)"),
+        ("debuf",    "debuferized (tensor linalg, matcher input)"),
+        ("debuf_mr", "debuferized — multi-root (--linalg-debufferize=use-multi-root=true)"),
+        ("matched",  "kernel.launch (matcher output)"),
+    ]:
+        if stage not in pages:
+            continue
+        body_blocks.append(
+            f'
{title}
'
+            f'
{pages[stage]}
'
+        )
+    body = header + "\n".join(body_blocks)
+    OUTPUT_DIR.joinpath(f"{file_prefix}{kernel}.html").write_text(render_html(kernel, body, css))
+    return {
+        "launches": report[0][1],
+        "linalg_ops": n_linalg,
+        "matched_symbols": matched_symbols,
+        "residual": report[1][1],
+        "residual_for": n_for,
+        "ce_url": ce_url,
+        "ce_suppressed": kset == "whisper_ops" and kernel in WHISPER_OPS_IR_ONLY,
+        "page_filename": f"{file_prefix}{kernel}.html",
+    }
+
+
+def _aten_upstream_info(kernel: str) -> dict[str, object]:
+    """Resolve the pinned ATen implementation-family URL and local pointer."""
+    upstream_file, token = ATEN_C_PROVENANCE[kernel]
+    source = ATEN_UPSTREAM_ROOT / upstream_file
+    upstream_line = None
+    if token and source.exists():
+        for line_no, line in enumerate(source.read_text().splitlines(), 1):
+            if token in line:
+                upstream_line = line_no
+                break
+    fragment = f"#L{upstream_line}" if upstream_line else ""
+    upstream_url = (
+        "https://github.com/pytorch/pytorch/blob/"
+        f"{ATEN_UPSTREAM_COMMIT}/{upstream_file}{fragment}"
+    )
+    local_pointer = f"third_party/pytorch/{upstream_file}"
+    if upstream_line:
+        local_pointer += f":{upstream_line}"
+    return {
+        "upstream_file": upstream_file,
+        "upstream_line": upstream_line,
+        "upstream_url": upstream_url,
+        "upstream_pointer": local_pointer,
+    }
+
+
+def build_aten_c_source_pages(aten_stats: dict[str, dict]) -> None:
+    """Render a C-only page with pinned PyTorch provenance for every fixture."""
+    for kernel in ATEN_C_ORDER:
+        source = find_kernel_c(kernel, kset="aten_c")
+        if source is None or not source.exists():
+            continue
+        provenance = _aten_upstream_info(kernel)
+        c_page_filename = f"aten_c_{kernel}.html"
+        highlighted, css = syntax_highlight(source.read_text(), "c")
+        lowering_page = aten_stats.get(kernel, {}).get("page_filename", "")
+        lowering_link = (
+            f'view lowering IR →'
+            if lowering_page else "lowering IR unavailable"
+        )
+        header = (
+            '
← ATen '
+            f'  standalone C: {html.escape(kernel)}
'
+        )
+        provenance_html = (
+            '
'
+            f'Standalone fixture: {html.escape(str(source.relative_to(REPO_ROOT)))}
'
+            f'Original ATen implementation family: '
+            f''
+            f'{html.escape(str(provenance["upstream_pointer"]))}
'
+            f'PyTorch commit: {ATEN_UPSTREAM_COMMIT}
'
+            'Extraction: numerical algorithm isolated into fixed-shape C; '
+            'ATen Tensor/dispatch/template machinery removed.
'
+            f'{lowering_link}'
+            '
'
+        )
+        OUTPUT_DIR.joinpath(c_page_filename).write_text(
+            render_html(
+                f"ATen standalone C: {kernel}",
+                header + provenance_html
+                + '
standalone C form lowered by cgeist
'
+                + f'
{highlighted}
',
+                css,
+            )
+        )
+        aten_stats.setdefault(kernel, {}).update(
+            {
+                "c_page_filename": c_page_filename,
+                **provenance,
+            }
+        )
+
+
+ATEN_PAGE_SIZE = 20
+
+
+def _aten_page_filename(sort_by: str, page: int) -> str:
+    prefix = "numerical" if sort_by == "alphabetical" else "numerical-correctness"
+    return f"{prefix}.html" if page == 1 else f"{prefix}-{page}.html"
+
+
+def _aten_sorted_kernels(sort_by: str) -> list[str]:
+    if sort_by == "alphabetical":
+        return sorted(ATEN_C_ORDER)
+    performance = {
+        row.get("kernel", ""): row for row in _read_csv(ATEN_SILICON_RESULTS)
+    }
+    correctness_rank = {"PASS": 0, "FAIL": 1, "—": 2, "": 2}
+    return sorted(
+        ATEN_C_ORDER,
+        key=lambda kernel: (
+            correctness_rank.get(
+                performance.get(kernel, {}).get("correctness", "—"), 2
+            ),
+            kernel,
+        ),
+    )
+
+
+def _aten_slowness_diagnosis(kernel: str, baseline: str, ratio: float) -> tuple[str, str, str]:
+    """Classify measured ATen gaps by the dominant steady-state cause.
+
+    These labels deliberately describe the current deployment ABI, not the
+    semantic matcher.  cudaHostRegister is cached by the runtime, so repeated
+    registration is not listed as a warm-run cause.
+    """
+    if kernel in ("aten_gelu", "aten_gelu_cpu_tanh"):
+        return (
+            "unfused multi-library decomposition",
+            "The raised implementation evaluates GELU as several cuDNN tensor "
+            "operations plus cuBLAS scaling, while native uses one fused CUDA "
+            "kernel. Device residency removes transfers but cannot remove those "
+            "launches, temporaries, and descriptor operations.",
+            "Prefer an existing fused GELU frontend/library operation when "
+            "available; otherwise this is not a profitable library decomposition.",
+        )
+    if kernel == "aten_linear_combination_cpu":
+        return (
+            "low-K library decomposition",
+            "Four pointwise terms were represented as a very skinny GEMV. The "
+            "library setup and reduction organization cost much more than a fused "
+            "elementwise CUDA implementation, even with resident buffers.",
+            "Select a fused existing pointwise primitive only when one is available; "
+            "otherwise retain this as a semantic match rather than a speed route.",
+        )
+    if kernel == "aten_rms_norm":
+        return (
+            "internal RMSNorm staging",
+            "The cuDNN backend plan still copies resident inputs into cached internal "
+            "buffers and copies its result out. Native uses a three-kernel fused "
+            "reduction/scale sequence directly on the public buffers.",
+            "Bind the public device pointers directly into the cached cuDNN variant "
+            "pack instead of staging through plan-owned allocations.",
+        )
+    if "gemv" in kernel or kernel == "aten_mv":
+        if ratio < 3.0:
+            return (
+                "direct-buffer GEMV (fixed)",
+                "The corrected lowering forwards the original contiguous ABI "
+                "buffers to cuBLAS. No matrix/vector tensor materialization "
+                "remains; this row is now close to resident cuBLAS.",
+                "Fuse the preceding zero into GEMV beta=0 and reduce pipeline "
+                "scope/synchronization overhead.",
+            )
+    if ratio <= 1.25:
+        return (
+            "near-native library route",
+            "The corrected lowering passes cudaMalloc-backed buffers directly. "
+            "The remaining difference is ordinary wrapper, descriptor, or launch "
+            "overhead rather than tensor materialization.",
+            "Cache any remaining descriptors and synchronize at graph boundaries.",
+        )
+    if kernel == "aten_zeros_cpu":
+        return (
+            "near-native library route",
+            "Device pointers now select cudaMemsetAsync directly; only wrapper and "
+            "synchronization overhead remains.",
+            "Amortize synchronization in a larger resident graph.",
+        )
+    if "Memcpy" in baseline or kernel in ("aten_as_complex_cpu",):
+        detail = (
+            "This path copies through mapped host allocations rather than "
+            "between CUDA-resident allocations."
+        )
+        if kernel == "aten_as_complex_cpu":
+            detail += (
+                " It also expresses the interleaved split as millions of "
+                "four-byte cudaMemcpy2D rows, an intrinsically poor copy shape."
+            )
+        return (
+            "copy residency / geometry",
+            detail,
+            "Preserve device residency; represent interleaved or strided cases "
+            "with a coalesced transform kernel instead of tiny pitched rows.",
+        )
+    if kernel in ("aten_nested_matmul_broadcast_cpu", "aten_flatten_nd_linear_cpu"):
+        return (
+            "small batched GEMM + mapped operands",
+            "The 256x256 batched products do not amortize the mapped-host "
+            "operand and wrapper costs as well as a large dense GEMM.",
+            "Use persistent device operands and cache the batched execution plan.",
+        )
+    if kernel == "aten_outer":
+        return (
+            "low-intensity GEMM shape",
+            "The library call is a GEMM with K=1. That is an outer product with "
+            "little reuse, so memory placement dominates despite the GEMM name.",
+            "Keep operands/output resident; consider the library's rank-1 update "
+            "route when its layout is profitable.",
+        )
+    if "Convolution" in baseline or "Conv3D" in baseline:
+        return (
+            "per-call cuDNN setup + mapped operands",
+            "The raised wrapper recreates cuDNN descriptors and workspace per "
+            "call and uses mapped host operands. Compute-heavy convolutions "
+            "amortize this better; smaller or 2D cases expose it.",
+            "Cache descriptors, algorithm choice, and workspace, and retain "
+            "tensors on the device.",
+        )
+    if kernel in ("aten_mm", "aten_addmm"):
+        return (
+            "dense library-call wrapper overhead",
+            "Dense GEMM provides useful reuse, but mapped inputs/output and "
+            "pipeline synchronization still make the raised end-to-end call "
+            "slower than an already-resident cuBLAS operation.",
+            "Adopt the device-pointer ABI and synchronize only at graph boundaries.",
+        )
+    if kernel in ("aten_dot", "aten_blas_dot_naive_cpu", "aten_bf16_dot_cpu", "aten_fp16_dot_cpu"):
+        return (
+            "mostly amortized reduction",
+            "The long reduction and scalar result amortize most wrapper cost; "
+            "only a small mapped-memory gap remains.",
+            "Device residency should remove most of the remaining difference.",
+        )
+    if kernel == "aten_softmax":
+        return (
+            "reduction setup / synchronization",
+            "cuDNN does substantial reduction work, so the gap is modest, but "
+            "the raised end-to-end call still includes mapped operands, descriptor "
+            "setup, and synchronization.",
+            "Cache descriptors and keep the tensor resident in a larger GPU graph.",
+        )
+    return (
+        "bandwidth-bound elementwise/reduction",
+        "The useful arithmetic per byte is low. Mapped host operands, output "
+        "materialization, wrapper setup, and a call-boundary synchronization "
+        "dominate the resident fused CUDA/cuDNN operation.",
+        "Keep tensors and intermediates resident, fuse adjacent stages, and "
+        "synchronize only at the graph boundary.",
+    )
+
+
+def _aten_slowness_page(aten_stats: dict[str, dict]) -> str:
+    measurements = []
+    for perf in _read_csv(ATEN_DEVICE_RESIDENCY_RESULTS):
+        if perf.get("correctness") != "PASS":
+            continue
+        try:
+            ratio = float(perf.get("device_over_resident", ""))
+            mapped = float(perf.get("mapped_raised_us", ""))
+            device = float(perf.get("device_resident_us", ""))
+            resident = float(perf.get("resident_cuda_us", ""))
+        except ValueError:
+            continue
+        measurements.append((ratio, mapped, device, resident, perf))
+    measurements.sort(reverse=True, key=lambda item: item[0])
+
+    category_counts: dict[str, int] = {}
+    category_styles = {
+        "direct-buffer GEMV (fixed)": "cause-amortized",
+        "near-native library route": "cause-amortized",
+        "unfused multi-library decomposition": "cause-host",
+        "low-K library decomposition": "cause-intensity",
+        "internal RMSNorm staging": "cause-memory",
+        "copy residency / geometry": "cause-copy",
+        "small batched GEMM + mapped operands": "cause-intensity",
+        "low-intensity GEMM shape": "cause-intensity",
+        "per-call cuDNN setup + mapped operands": "cause-setup",
+        "dense library-call wrapper overhead": "cause-setup",
+        "mostly amortized reduction": "cause-amortized",
+        "reduction setup / synchronization": "cause-setup",
+        "bandwidth-bound elementwise/reduction": "cause-bandwidth",
+    }
+    rows = []
+    for ratio, mapped, device, resident, perf in measurements:
+        kernel = perf.get("kernel", "")
+        category, reason, remedy = _aten_slowness_diagnosis(
+            kernel, perf.get("baseline", ""), ratio
+        )
+        category_counts[category] = category_counts.get(category, 0) + 1
+        kernel_page = aten_stats.get(kernel, {}).get("page_filename", "")
+        kernel_html = (
+            f''
+            f'{html.escape(kernel)}' if kernel_page else html.escape(kernel)
+        )
+        severity = "none" if ratio >= 20 else ("partial" if ratio >= 2 else "pass")
+        category_style = category_styles.get(category, "cause-setup")
+        rows.append(
+            f'{kernel_html}'
+            f'{html.escape(perf.get("problem", "—"))}'
+            f'{mapped:,.3f}{device:,.3f}{resident:,.3f}'
+            f'{ratio:,.2f}×'
+            f'{mapped / device:,.2f}×'
+            f'{html.escape(category)}'
+            f'
{html.escape(reason)}'
+            f'{html.escape(remedy)}'
+        )
+
+    category_items = "".join(
+        f'
  • {html.escape(category)}: {count} measured kernel(s)
    • '
+        for category, count in sorted(category_counts.items(), key=lambda item: (-item[1], item[0]))
+    )
+    gemvs = [
+        item for item in measurements
+        if "gemv" in item[4].get("kernel", "").lower()
+        or item[4].get("kernel", "") == "aten_mv"
+    ]
+    gemv_ratio_min = min((item[0] for item in gemvs), default=0.0)
+    gemv_ratio_max = max((item[0] for item in gemvs), default=0.0)
+    gemv_residency = next(
+        (row for row in _read_csv(ATEN_DEVICE_RESIDENCY_RESULTS)
+         if row.get("kernel") == "aten_blas_gemv_generic_cpu"), {})
+    try:
+        mapped_gemv = float(gemv_residency.get("mapped_raised_us", ""))
+        device_gemv = float(gemv_residency.get("device_resident_us", ""))
+        resident_gemv = float(gemv_residency.get("resident_cuda_us", ""))
+        mapped_ratio = float(gemv_residency.get("mapped_over_resident", ""))
+        device_ratio = float(gemv_residency.get("device_over_resident", ""))
+        gemv_experiment = (
+            ''
+            ''
+            f''
+            f''
+            f''
+            f''
+            f''
+            '
    same raised GEMV pathwarm µsvs resident
    mapped-host operands{mapped_gemv:,.3f}{mapped_ratio:.3f}×
    cudaMalloc/device-resident operands{device_gemv:,.3f}{device_ratio:.3f}×
    native resident cuBLAS{resident_gemv:,.3f}1.000×
    '
+        )
+    except (TypeError, ValueError):
+        gemv_experiment = ''
+    return (
+        '
    Why are some raised kernels slow?
    '
+        '
    '
+        'Result: all 40 executable FULL-match ATen kernels pass with true '
+        'cudaMalloc operands. This table separates the old mapped-host '
+        'ABI from the corrected device-resident lowering and the native resident CUDA '
+        'baseline. The median device/native ratio is 1.07×; 32/40 are within '
+        '1.25× and 36/40 are within 2×. The four remaining gaps are algorithmic '
+        'or internal-library staging (two GELUs, a four-term linear combination, and '
+        'RMSNorm), not hidden tensor copies. Red ratios are at least 20×, yellow are '
+        '2–20×, and green are below 2×.'
+        f'
      {category_items}
    '
+        '
    '
+        'GEMV: the old 173× gap is fixed across the family
    '
+        '
    '
+        f'The rerun GEMV family spans only '
+        f'{gemv_ratio_min:.2f}×–{gemv_ratio_max:.2f}× versus resident '
+        'cuBLAS with true device buffers. '
+        'For the main f32 case, A is 4096×8192 = 33,554,432 floats, '
+        'or 128 MiB. Each output uses one matrix row, but the matrix has essentially '
+        'no reuse across the call: GEMV performs about two floating-point operations '
+        'for every four matrix bytes. It is therefore a memory-bandwidth test wearing '
+        'a linear-algebra name.

    '
+        'Inspection of the old generated LLVM showed the real dominant cost: before '
+        'cublasSgemv, one-shot bufferization allocated and copied the full '
+        '128 MiB matrix, then copied vectors/output around the call. A cudaMalloc-pointer '
+        'experiment initially crashed because those copies executed on the CPU.

    '
+        'Fix: all library lowerings now trace tensor slices back to their original '
+        'memrefs, derive direct pointers, and treat destinations as in-place results. The '
+        'AArch64 objects have no allocation or CPU copy around the calls. All corrected runs '
+        'pass the CPU reference; '
+        'uploads happen before timing and the result download happens afterward.'
+        '
    '
+        + gemv_experiment +
+        '
    '
+        'Why PolyBench GESUMMV shows a raised win
    '
+        '
    '
+        'The native baselines are not equivalent. The warmed PolyBench result '
+        'compares two optimized cuBLAS GEMV calls from the raised path against the '
+        'handwritten PolyBenchGPU gesummv_kernel. That CUDA kernel assigns '
+        'one thread to each output row and executes the complete inner j '
+        'dot-product loop serially inside that thread. At N=512 it launches only 512 '
+        'threads and does not use a parallel reduction, so cuBLAS can beat it even while '
+        'using the mapped-host ABI.

    '
+        'The ATen resident baseline is already optimized cuBLAS using '
+        'cudaMalloc operands. It therefore removes the algorithm-quality '
+        'advantage and exposes the raised ABI penalty directly. The sizes also cross a '
+        'different memory regime: one PolyBench N=512 f64 matrix is only 2 MiB (4 MiB '
+        'for A+B, repeatedly reused), whereas the ATen 4096x8192 f32 matrix is 128 MiB '
+        'and must stream from DRAM. Finally, the PolyBench raised number sums device-event '
+        'time inside runtime shims; the ATen raised number is wall time for the complete '
+        'raised call. Thus the PolyBench win means cuBLAS beats that naive CUDA '
+        'implementation; it does not show that mapped-host GEMV beats resident cuBLAS.'
+        '
    '
+        ''
+        ''
+        ''
+        ''
+        + "\n".join(rows) + '
    kernellarge problemmapped raised (µs)device raised (µs)native CUDA (µs)device/nativemapped/devicedominant reasonnext correction
    '
+    )
+
+
+def _aten_section(aten_stats: dict[str, dict], kernels: list[str],
+                  sort_by: str, page: int, page_count: int) -> str:
+    performance = {
+        row.get("kernel", ""): row for row in _read_csv(ATEN_SILICON_RESULTS)
+    }
+    cuda_audit = {
+        row.get("kernel", ""): row for row in _read_csv(ATEN_CUDA_LIBRARY_AUDIT)
+    }
+    rows = []
+    for kernel in kernels:
+        stats = aten_stats.get(kernel, {})
+        kernel_page = stats.get("page_filename", "")
+        if kernel_page:
+            name = f'{kernel}'
+        else:
+            name = f'{kernel}'
+        c_page = stats.get("c_page_filename", "")
+        extracted_c = (
+            f''
+            f'{html.escape(ATEN_C_KERNELS[kernel][0])}'
+            if c_page else "—"
+        )
+        upstream_url = stats.get("upstream_url", "")
+        upstream_pointer = stats.get("upstream_pointer", "")
+        upstream = (
+            f'{html.escape(str(upstream_pointer))}'
+            if upstream_url else "—"
+        )
+        symbols = stats.get("matched_symbols", [])
+        symbol_html = ", ".join(f"@{s}" for s in symbols) or "—"
+        launches = stats.get("launches", 0)
+        residual = stats.get("residual", 0)
+        loops = stats.get("residual_for", 0)
+        linalg_ops = stats.get("linalg_ops", 0)
+        if linalg_ops > 0 and loops == 0:
+            raise_status_class, raise_status = "pass", "FULL"
+        elif linalg_ops > 0:
+            raise_status_class, raise_status = "partial", "PARTIAL"
+        else:
+            raise_status_class, raise_status = "none", "NONE"
+        if kernel in ATEN_C_UNSAFE_MATCHES:
+            status_class, status = "none", "UNSAFE"
+        elif launches and residual == 0 and loops == 0:
+            status_class, status = "pass", "FULL"
+        elif launches:
+            status_class, status = "partial", "PARTIAL"
+        else:
+            status_class, status = "none", "NONE"
+        assessment = ATEN_C_MATCH_ASSESSMENT.get(kernel, "")
+        perf = performance.get(kernel, {})
+        execution = html.escape(perf.get("executable_status", "—"))
+        correctness = html.escape(perf.get("correctness", "—"))
+        problem = html.escape(perf.get("problem", "—"))
+        raised_us = html.escape(perf.get("raised_us", "—"))
+        resident_us = html.escape(perf.get("resident_cuda_us", "—"))
+        ratio = perf.get("raised_over_resident", "—")
+        ratio = html.escape(f"{ratio}×" if ratio not in ("", "—") else "—")
+        baseline = html.escape(perf.get("baseline", "—"))
+        audit = cuda_audit.get(kernel, {})
+        library = audit.get("candidate_library", "")
+        api = audit.get("candidate_api", "")
+        evidence = audit.get("evidence_url", "")
+        if library:
+            candidate_text = (
+                f'{html.escape(library)}
    {html.escape(api)}'
+            )
+            candidate = (
+                f''
+                f'{candidate_text}' if evidence else candidate_text
+            )
+        else:
+            candidate = 'no tensor-library API'
+        implementation_form = html.escape(
+            audit.get("implementation_form", "—").replace("_", " ")
+        )
+        audit_finding = html.escape(
+            audit.get("compiler_gap", "—").replace("_", " ")
+        )
+        audit_reason = html.escape(audit.get("rationale", ""))
+        audit_scope = html.escape(
+            audit.get("current_match_scope", "—").replace("_", " ")
+        )
+        execution_class = "pass" if execution == "EXECUTED" else "none"
+        correctness_class = "pass" if correctness == "PASS" else "none"
+        rows.append(
+            f"{name}"
+            f"{upstream}{extracted_c}"
+            f"{linalg_ops}{loops}"
+            f'{raise_status}'
+            f"{launches}"
+            f'{status}'
+            f"{symbol_html}"
+            f"{audit_scope}{candidate}"
+            f"{implementation_form}"
+            f"{audit_finding}
    {audit_reason}"
+            f'{execution}'
+            f'{correctness}'
+            f"{problem}{raised_us}"
+            f"{resident_us}{ratio}{baseline}"
+            f"{assessment}"
+        )
+    total_linalg = sum(s.get("linalg_ops", 0) for s in aten_stats.values())
+    total_launches = sum(s.get("launches", 0) for s in aten_stats.values())
+    total_residual_loops = sum(
+        s.get("residual_for", 0) for s in aten_stats.values()
+    )
+    fully_raised = sum(
+        s.get("residual_for", 0) == 0 and s.get("linalg_ops", 0) > 0
+        for s in aten_stats.values()
+    )
+    matched_kernels = sum(s.get("launches", 0) > 0 for s in aten_stats.values())
+    complete_matches = sum(
+        row.get("current_match_scope") == "COMPLETE_REWRITE_CANDIDATE"
+        for row in cuda_audit.values()
+    )
+    partial_matches = sum(
+        row.get("current_match_scope") == "PARTIAL_STAGE_ONLY"
+        for row in cuda_audit.values()
+    )
+    sort_links = (
+        f'Sort: '
+        f'{"alphabetical" if sort_by == "alphabetical" else "alphabetical"} · '
+        f''
+        f'{"correctness" if sort_by == "correctness" else "correctness"}'
+    )
+    page_links = " · ".join(
+        (
+            f'{number}' if number == page else
+            f'{number}'
+        )
+        for number in range(1, page_count + 1)
+    )
+    controls = (
+        '
    '
+        f'{sort_links}Page: '
+        f'{page_links}Showing '
+        f'{(page - 1) * ATEN_PAGE_SIZE + 1}–'
+        f'{(page - 1) * ATEN_PAGE_SIZE + len(kernels)} of '
+        f'{len(ATEN_C_ORDER)}
    '
+    )
+    return (
+        ''
+        '
    '
+        'ATen extracted C numerical kernels
    '
+        '
    '
+        f'{fully_raised}/{len(aten_stats)} fully raised: {total_linalg} '
+        f'linalg.generic operations and {total_residual_loops} '
+        f'residual loops. '
+        f'The current matcher emitted {total_launches} launches across '
+        f'{matched_kernels}/{len(aten_stats)} kernels, but exhaustive residual-IR '
+        f'checking finds only {complete_matches} complete rewrite candidates and '
+        f'{partial_matches} partial stage matches. '
+        'Raising FULL/PARTIAL/NONE means Linalg with no residual loops, Linalg '
+        'with residual loops, or no raised Linalg, respectively. Match '
+        'FULL/PARTIAL/NONE describes semantic library-matcher coverage. Copy matching '
+        'rejects known transpose and gather false-positives; the remaining '
+        'pixel-shuffle view candidate is explicitly marked unsafe until its '
+        'submap layout is proven by the runtime ABI. '
+        'The newly available cuTensorNet tensor-product definition produced '
+        'no additional ATen match: none of these kernels has its rank-6 '
+        'separable 3D tensor-product signature. Existing cuBLAS, cuDNN, and '
+        'custom CUDA definitions remain the correct matches. These are '
+        'standalone C extractions of ATen mathematics, not the unmodified '
+        'PyTorch C++ translation units (whose direct 224-file sweep produced '
+        '0 Linalg operations). Large-problem silicon results use a Jetson '
+        'Orin in MAXN mode. Raised time is the current host-pointer ABI; the '
+        'resident baseline keeps operands on the GPU and times only the '
+        'cuBLAS/cuDNN or fused CUDA operation. Both columns are warm medians '
+        'of process runs 2–4 and are shown only after correctness passes.'
+        ' Why are some kernels slow? '
+        'groups the measured gaps by cause and starts with a GEMV deep dive.'
+        '
    '
+        + controls
+        +
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        + "\n".join(rows)
+        + '
    kerneloriginal ATen CPU implementationstandalone C formLinalg opsresidual loopsraising statuslaunchesmatch statusmatched implementationcurrent match scopeNVIDIA library candidateimplementation formaudit findingexecutioncorrectnesslarge problemraised warm (µs)resident CUDA (µs)raised / residentresident baselineassessment
    '
+    )
+
+
+def _read_csv(path: Path) -> list[dict[str, str]]:
+    if not path.exists():
+        return []
+    with path.open(newline="") as stream:
+        return list(csv.DictReader(stream))
+
+
+def _extract_c_function(text: str, function: str) -> str:
+    """Extract one named C function, including a directly preceding comment."""
+    match = re.search(rf"\b{re.escape(function)}\s*\(", text)
+    if not match:
+        return text
+    opening = text.find("{", match.end())
+    if opening < 0:
+        return text
+    depth = 0
+    end = opening
+    while end < len(text):
+        if text[end] == "{":
+            depth += 1
+        elif text[end] == "}":
+            depth -= 1
+            if depth == 0:
+                end += 1
+                break
+        end += 1
+    start = text.rfind("\n", 0, match.start()) + 1
+    # Include contiguous // comments immediately above the declaration.
+    while start > 0:
+        previous_end = start - 1
+        previous_start = text.rfind("\n", 0, previous_end) + 1
+        if not text[previous_start:previous_end].lstrip().startswith("//"):
+            break
+        start = previous_start
+    return text[start:end].strip() + "\n"
+
+
+def _mfem_upstream_line(upstream_file: str, upstream_symbol: str) -> int | None:
+    path = MFEM_UPSTREAM_ROOT / upstream_file
+    if not path.exists():
+        return None
+    # Manifest spellings such as ElasticityAddMultPA_<2> denote a template
+    # specialization; the source definition is ElasticityAddMultPA_.
+    symbol = re.sub(r"<[^>]+>$", "", upstream_symbol)
+    definition = re.compile(rf"\b{re.escape(symbol)}\s*\(")
+    for line_number, line in enumerate(path.read_text(errors="replace").splitlines(), 1):
+        if definition.search(line):
+            return line_number
+    return None
+
+
+def build_mfem_pages() -> list[dict]:
+    """Render stored MFEM frontend/raise/matcher artifacts.
+
+    MFEM uses a manifest-driven artifact layout rather than the conventional
+    [_linalg|_debuf].mlir layout used by the other explorer suites.
+    Stored rewritten IR is authoritative for executable launches.
+    """
+    manifest = _read_csv(MFEM_C_ROOT / "manifest.csv")
+    raise_rows = {
+        (row["id"], row["variant"]): row
+        for row in _read_csv(MFEM_RESULTS_DIR / "summary.csv")
+    }
+    match_rows = {
+        row["id"]: row
+        for row in _read_csv(MFEM_MATCH_RESULTS_DIR / "summary.csv")
+    }
+    silicon_rows = {
+        row["id"]: row
+        for row in _read_csv(
+            MFEM_SILICON_RESULTS_DIR / "native_vs_raised_large_ne.csv"
+        )
+    }
+    stats = []
+    for row in manifest:
+        ident = row["id"]
+        variant = row["variant"]
+        artifact_stem = f"{ident}__{variant}"
+        frontend = MFEM_RESULTS_DIR / f"{artifact_stem}.frontend.mlir"
+        raised = MFEM_RESULTS_DIR / f"{artifact_stem}.raised.mlir"
+        match_dir = MFEM_MATCH_RESULTS_DIR / ident
+        debufferized = match_dir / "debufferized.mlir"
+        matched = match_dir / "matched.mlir"
+        source = MFEM_C_ROOT / row["source"]
+        raise_row = raise_rows.get((ident, variant), {})
+        match_row = match_rows.get(ident, {}) if variant == "normalized" else {}
+        silicon_row = silicon_rows.get(ident, {}) if variant == "normalized" else {}
+
+        blocks = []
+        css = ""
+        source_text = ""
+        if source.exists():
+            source_text = _extract_c_function(source.read_text(), row["function"])
+            highlighted, css = syntax_highlight(source_text, "c")
+            source_label = html.escape(row["source"])
+            function_label = html.escape(row["function"])
+            blocks.append(
+                '
    extracted C lowered by cgeist
    '
+                '
    '
+                f'Corpus source: {source_label}  ·  '
+                f'function: {function_label}
    '
+                f'
    {highlighted}
    '
+            )
+
+        upstream_file = row["upstream_file"]
+        upstream_symbol = row["upstream_symbol"]
+        upstream_line = _mfem_upstream_line(upstream_file, upstream_symbol)
+        line_fragment = f"#L{upstream_line}" if upstream_line else ""
+        upstream_url = (
+            "https://github.com/mfem/mfem/blob/"
+            f"{MFEM_UPSTREAM_COMMIT}/{upstream_file}{line_fragment}"
+        )
+        local_pointer = f"third_party/mfem/{upstream_file}"
+        if upstream_line:
+            local_pointer += f":{upstream_line}"
+        c_page_filename = f"mfem_c_{ident}.html"
+        if source_text:
+            c_highlighted, c_css = syntax_highlight(source_text, "c")
+            c_header = (
+                '
    ← MFEM '
+                f'  extracted C: {html.escape(ident)} '
+                f'({html.escape(variant)})
    '
+            )
+            c_provenance = (
+                '
    '
+                f'Corpus source: {html.escape(row["source"])}
    '
+                f'Function lowered: {html.escape(row["function"])}
    '
+                f'Upstream symbol: {html.escape(upstream_symbol)}
    '
+                f'Pinned source: {html.escape(local_pointer)}
    '
+                f'MFEM commit: {MFEM_UPSTREAM_COMMIT}  ·  '
+                f'view lowering IR →'
+                '
    '
+            )
+            OUTPUT_DIR.joinpath(c_page_filename).write_text(
+                render_html(
+                    f"MFEM extracted C: {ident}",
+                    c_header + c_provenance
+                    + '
    exact extracted function lowered by cgeist
    '
+                    + f'
    {c_highlighted}
    ',
+                    c_css,
+                )
+            )
+        blocks.append(
+            '
    MFEM extraction provenance
    '
+            '
    '
+            f'Upstream symbol: {html.escape(upstream_symbol)}
    '
+            f'Pinned source: {html.escape(local_pointer)}
    '
+            f'MFEM commit: {MFEM_UPSTREAM_COMMIT}'
+            '
    '
+        )
+
+        stage_paths = [
+            ("frontend", "cgeist output (pre-raise MLIR)", frontend),
+            ("raised", "raised Linalg IR", raised),
+            ("debufferized", "debufferized tensor Linalg (matcher input)",
+             debufferized),
+            ("matched", "executable matcher output (kernel.launch)",
+             matched),
+        ]
+        for anchor, title, path in stage_paths:
+            if not path.exists():
+                continue
+            highlighted, css = syntax_highlight(path.read_text())
+            blocks.append(
+                f'
    {title}
    '
+                f'
    {highlighted}
    '
+            )
+
+        launches = int(match_row.get("kernel_launches", "0") or 0)
+        symbols = [
+            value for value in match_row.get("launch_symbols", "").split(",")
+            if value
+        ]
+        linalg_ops = int(raise_row.get("linalg_ops", "0") or 0)
+        residual_loops = int(raise_row.get("residual_loops", "0") or 0)
+        fully_raised = raise_row.get("fully_raised") == "true"
+        ce_url = ce_link_from_paths(source if source.exists() else None, frontend)
+        open_link = (
+            f''
+            'open in Compiler Explorer →'
+        ) if ce_url else ""
+        c_link = (
+            f'view extracted C →'
+        ) if source_text else ""
+        title = html.escape(ident)
+        summary = (
+            '
    '
+            f'{linalg_ops} Linalg op(s)  ·  '
+            f'{residual_loops} residual loop(s)  ·  '
+            f'{launches} executable library launch(es)'
+            '
    '
+        )
+        header = (
+            '
    ← MFEM '
+            f'  {title} ({html.escape(variant)})'
+            f'{c_link}{open_link}
    '
+        )
+        page_filename = f"mfem_{ident}.html"
+        OUTPUT_DIR.joinpath(page_filename).write_text(
+            render_html(f"MFEM: {ident}", header + summary + "\n".join(blocks), css)
+        )
+        stats.append({
+            **row,
+            "page_filename": page_filename,
+            "c_page_filename": c_page_filename,
+            "upstream_line": upstream_line,
+            "upstream_url": upstream_url,
+            "upstream_pointer": local_pointer,
+            "linalg_ops": linalg_ops,
+            "residual_loops": residual_loops,
+            "fully_raised": fully_raised,
+            "launches": launches,
+            "matched_symbols": symbols,
+            "silicon": silicon_row,
+        })
+    return stats
+
+
+def build_mfem_application_pages() -> list[dict]:
+    """Render MFEM example hot-operator ports and measured status."""
+    stats = []
+    for row in _read_csv(MFEM_APPLICATIONS_DIR / "summary.csv"):
+        ident = row["id"]
+        harness = MFEM_APPLICATIONS_DIR / row["harness"]
+        normalized = (MFEM_APPLICATIONS_DIR / row["normalized"]).resolve()
+        blocks = []
+        css = ""
+        for anchor, title, path in (
+            ("harness", "application hot-operator harness", harness),
+            ("normalized", "stage-sliced implementation", normalized),
+        ):
+            if not path.exists():
+                continue
+            highlighted, css = syntax_highlight(path.read_text())
+            blocks.append(
+                f'
    {title}
    '
+                f'
    {highlighted}
    '
+            )
+
+        status = html.escape(row["raised_status"])
+        kernel_page = f'mfem_{html.escape(row["kernel_id"])}.html'
+        summary = (
+            '
    '
+            f'{html.escape(row["application"])}  ·  '
+            f'{html.escape(row["operator"])}  ·  '
+            f'{html.escape(row["dimension"])}D  ·  '
+            f'{html.escape(row["speedup"])}x stage-sliced C speedup '
+            f'({html.escape(row["reference_us"])} us → '
+            f'{html.escape(row["sliced_us"])} us)  ·  '
+            f'max error {html.escape(row["max_error"])}
    '
+            f'Library-backed status: {status}; '
+            f'{html.escape(row["library_launches"])} structural launch(es). '
+            f'Blocker: {html.escape(row["blocker"])}. '
+            f'Open the kernel IR and matches →'
+            '
    '
+        )
+        header = (
+            '
    ← MFEM '
+            f'  {html.escape(ident)}
    '
+        )
+        page_filename = f"mfem_app_{ident}.html"
+        OUTPUT_DIR.joinpath(page_filename).write_text(
+            render_html(
+                f"MFEM application: {ident}",
+                header + summary + "\n".join(blocks),
+                css,
+            )
+        )
+        stats.append({**row, "page_filename": page_filename})
+    return stats
+
+
+def build_mfem_application_extraction_pages() -> list[dict]:
+    """Render raised hot paths extracted from larger MFEM applications."""
+    stats = []
+    summary = _read_csv(MFEM_APPLICATION_EXTRACTION_RESULTS_DIR / "summary.csv")
+    comparison_rows = {
+        row["function"]: row
+        for row in _read_csv(
+            MFEM_SILICON_RESULTS_DIR
+            / "application_native_vs_raised_large_ne.csv"
+        )
+    }
+    for row in summary:
+        function = row["function"]
+        source = MFEM_APPLICATION_EXTRACTIONS_DIR / row["source"]
+        support_source = None
+        if row.get("support_source"):
+            support_source = MFEM_APPLICATION_EXTRACTIONS_DIR / row["support_source"]
+        frontend = MFEM_APPLICATION_EXTRACTION_RESULTS_DIR / f"{function}.frontend.mlir"
+        raised = MFEM_APPLICATION_EXTRACTION_RESULTS_DIR / f"{function}.raised.mlir"
+        debufferized = (
+            MFEM_APPLICATION_EXTRACTION_RESULTS_DIR / f"{function}.debufferized.mlir"
+        )
+        matched = MFEM_APPLICATION_EXTRACTION_RESULTS_DIR / f"{function}.matched.mlir"
+        log = MFEM_APPLICATION_EXTRACTION_RESULTS_DIR / f"{function}.log"
+        blocks = []
+        css = ""
+
+        for anchor, title, path, language in (
+            ("source", "extracted C application hot path", source, "c"),
+            ("support-source", "extracted supporting operator kernels",
+             support_source, "c"),
+            ("frontend", "cgeist output (pre-raise MLIR)", frontend, None),
+            ("raised", "raised Linalg IR", raised, None),
+            ("debufferized", "debufferized tensor Linalg", debufferized, None),
+            ("matched", "matcher-rewritten candidate launches", matched, None),
+            ("matcher-report", "raising and matcher report", log, None),
+        ):
+            if path is None or not path.exists():
+                continue
+            highlighted, css = syntax_highlight(path.read_text(), language)
+            blocks.append(
+                f'
    {title}
    '
+                f'
    {highlighted}
    '
+            )
+
+        upstream_file = row["upstream_file"]
+        upstream_lines = row["upstream_lines"]
+        first_line = re.match(r"\d+", upstream_lines)
+        fragment = f"#L{first_line.group(0)}" if first_line else ""
+        upstream_url = (
+            "https://github.com/mfem/mfem/blob/"
+            f"{MFEM_UPSTREAM_COMMIT}/{upstream_file}{fragment}"
+        )
+        local_pointer = f"third_party/mfem/{upstream_file}:{upstream_lines}"
+        page_filename = f"mfem_benchmark_{function}.html"
+        c_page_filename = f"mfem_benchmark_c_{function}.html"
+        if source.exists():
+            c_highlighted, c_css = syntax_highlight(source.read_text(), "c")
+            support_html = ""
+            if support_source is not None and support_source.exists():
+                support_highlighted, _ = syntax_highlight(
+                    support_source.read_text(), "c"
+                )
+                support_html = (
+                    '
    supporting extracted operator kernels: '
+                    f'{html.escape(row["support_source"])}
    '
+                    f'
    {support_highlighted}
    '
+                )
+            c_header = (
+                '
    ← MFEM '
+                f'  extracted C: {html.escape(function)}
    '
+            )
+            c_provenance = (
+                '
    '
+                f'Application: {html.escape(row["application"])}
    '
+                f'Corpus source: {html.escape(row["source"])}
    '
+                f'Function lowered: {html.escape(function)}
    '
+                f'Upstream: {html.escape(local_pointer)}
    '
+                f'view lowering IR →'
+                '
    '
+            )
+            OUTPUT_DIR.joinpath(c_page_filename).write_text(
+                render_html(
+                    f"MFEM application extracted C: {function}",
+                    c_header + c_provenance
+                    + '
    exact application hot-path C lowered by cgeist
    '
+                    + f'
    {c_highlighted}
    '
+                    + support_html,
+                    c_css,
+                )
+            )
+        missing = row.get("missing_operator", "") or "none"
+        families = row.get("operator_families", "") or "—"
+        loops = int(row.get("residual_loops", "0") or 0)
+        matched_symbols = []
+        if matched.exists():
+            matched_symbols = sorted(set(re.findall(
+                r"kernel\.launch\s+@([A-Za-z0-9_.$-]+)",
+                matched.read_text(),
+            )))
+        matched_implementations = ", ".join(
+            f"@{html.escape(symbol)}"
+            for symbol in matched_symbols
+        ) or "—"
+        comparison = comparison_rows.get(function)
+        silicon = MFEM_APPLICATION_JETSON_RUNS.get(function)
+        if comparison:
+            raised_us = comparison.get("raised_runtime_us", "")
+            native_us = comparison.get("mfem_native_runtime_us", "")
+            ratio = comparison.get("raised_over_native", "")
+            runtime_parts = []
+            if raised_us:
+                runtime_parts.append(f"raised {float(raised_us) / 1000.0:.6f} ms")
+            if native_us:
+                runtime_parts.append(
+                    f"MFEM native {float(native_us) / 1000.0:.6f} ms"
+                )
+            if ratio:
+                runtime_parts.append(f"raised/native {ratio}x")
+            correctness = comparison.get("correctness", "NOT RUN")
+            outcome = (
+                "CORRECTNESS PASS" if correctness == "PASS"
+                else "CORRECTNESS FAIL"
+            )
+            silicon = {
+                "outcome": outcome,
+                "correctness": comparison.get("comparison_scope", ""),
+                "runtime": "; ".join(runtime_parts) or "timing withheld",
+                "calls": (
+                    f'{row.get("launches", "0")} raised candidate launches; '
+                    f'native components: {comparison.get("native_components", "—")}'
+                ),
+                "params": (
+                    f'NE={comparison.get("ne", "—")}; '
+                    f'D1D={comparison.get("d1d", "—")}; '
+                    f'Q1D={comparison.get("q1d", "—")}; '
+                    f'raised iterations={comparison.get("raised_iterations", "—")}; '
+                    f'native iterations={comparison.get("native_iterations", "—") or "n/a"}; '
+                    f'{comparison.get("measurement_statistic", "")}; '
+                    f'comparison={comparison.get("comparison_quality", "—")}'
+                ),
+                "hardware": comparison.get("hardware", ""),
+                "test_label": "large-problem raised/native comparison",
+            }
+        if silicon:
+            silicon_class = (
+                "pass" if "PASS" in silicon["outcome"] else "partial"
+            )
+            test_label = silicon.get("test_label", "Jetson silicon test")
+            hardware = silicon.get(
+                "hardware",
+                "attached Jetson tegra-ubuntu, MAXN, CUDA 12.6, cuTensorNet",
+            )
+            silicon_html = (
+                f'
    {html.escape(test_label)}: '
+                f'{html.escape(silicon["outcome"])}; '
+                f'{html.escape(silicon["correctness"])}
    '
+                f'Runtime: {html.escape(silicon["runtime"])}
    '
+                f'Per-launch diagnostics: {html.escape(silicon["calls"])}
    '
+                f'Test parameters: {html.escape(silicon["params"])}
    '
+                f'Hardware: {html.escape(hardware)}'
+            )
+        else:
+            silicon_html = (
+                '
    Jetson silicon test: NOT RUN; '
+                'no runtime measurement'
+            )
+        coverage_class = "pass" if missing == "none" else "partial"
+        status_class = "pass" if loops == 0 else "partial"
+        ce_url = ce_link_from_paths(source if source.exists() else None, frontend)
+        ce_link = (
+            f'open in Compiler Explorer →'
+        ) if ce_url else ""
+        summary_html = (
+            '
    '
+            f'Application: {html.escape(row["application"])}  ·  '
+            f'coverage: '
+            f'{html.escape(row["coverage"])}  ·  '
+            f'{html.escape(row["linalg_ops"])} Linalg op(s)  ·  '
+            f'{html.escape(row["residual_loops"])} '
+            f'residual loop(s)  ·  '
+            f'{html.escape(row["matched_groups"])} semantic match group(s) '
+            f' ·  {html.escape(row["launches"])} candidate launch(es)
    '
+            f'Matched implementations: {matched_implementations}
    '
+            f'Extracted operator families: {html.escape(families)}
    '
+            f'Missing operator families: {html.escape(missing)}
    '
+            f'Extracted C: '
+            f'{html.escape(row["source"])}  ·  '
+            f'function: {html.escape(function)}
    '
+            f'Upstream: '
+            f'{html.escape(local_pointer)}  ·  '
+            f'MFEM commit: {MFEM_UPSTREAM_COMMIT}'
+            f'{silicon_html}'
+            '
    '
+        )
+        header = (
+            '
    ← MFEM '
+            f'  {html.escape(function)}{ce_link}
    '
+        )
+        OUTPUT_DIR.joinpath(page_filename).write_text(
+            render_html(
+                f"MFEM benchmark: {function}",
+                header + summary_html + "\n".join(blocks),
+                css,
+            )
+        )
+        stats.append({
+            **row,
+            "page_filename": page_filename,
+            "c_page_filename": c_page_filename,
+            "upstream_url": upstream_url,
+            "upstream_pointer": local_pointer,
+            "linalg_ops_int": int(row.get("linalg_ops", "0") or 0),
+            "residual_loops_int": loops,
+            "matches_int": int(row.get("matched_groups", "0") or 0),
+            "launches_int": int(row.get("launches", "0") or 0),
+            "matched_symbols": matched_symbols,
+            "silicon": silicon,
+            "comparison": comparison,
+        })
+    return stats
+
+
+def _mfem_application_extraction_section(stats: list[dict]) -> str:
+    rows = []
+    for row in stats:
+        missing = row.get("missing_operator", "") or "none"
+        coverage_class = "pass" if missing == "none" else "partial"
+        raised_class = "pass" if row["residual_loops_int"] == 0 else "partial"
+        name = (
+            f''
+            f'{html.escape(row["function"])}'
+        )
+        extracted_c = (
+            f''
+            f'{html.escape(row["source"])}:{html.escape(row["function"])}'
+        )
+        upstream = (
+            f''
+            f'{html.escape(row["upstream_pointer"])}'
+        )
+        matched_implementations = ", ".join(
+            f"@{html.escape(symbol)}"
+            for symbol in row["matched_symbols"]
+        ) or "—"
+        comparison = row.get("comparison")
+        if comparison:
+            correctness = comparison.get("correctness", "NOT RUN")
+            silicon_class = "pass" if correctness == "PASS" else "fail"
+            silicon_outcome = (
+                f'{html.escape(correctness)}'
+            )
+            raised_us = comparison.get("raised_runtime_us", "")
+            native_us = comparison.get("mfem_native_runtime_us", "")
+            ratio = comparison.get("raised_over_native", "")
+            raised_runtime = (
+                f'{float(raised_us) / 1000.0:.6f} ms' if raised_us else "—"
+            )
+            native_runtime = (
+                f'{float(native_us) / 1000.0:.6f} ms' if native_us else "—"
+            )
+            ratio_text = f'{html.escape(ratio)}x' if ratio else "—"
+            quality = comparison.get("comparison_quality", "—")
+            quality_class = (
+                "pass" if quality == "EXACT_OPERATOR" else "partial"
+            )
+            comparison_scope = (
+                f'{html.escape(quality)}
    '
+                f'{html.escape(comparison.get("comparison_scope", ""))}'
+            )
+            silicon_params = (
+                f'NE={html.escape(comparison.get("ne", "—"))}; '
+                f'D1D={html.escape(comparison.get("d1d", "—"))}; '
+                f'Q1D={html.escape(comparison.get("q1d", "—"))}; '
+                f'raised iterations={html.escape(comparison.get("raised_iterations", "—"))}; '
+                f'native iterations={html.escape(comparison.get("native_iterations", "") or "n/a")}'
+            )
+        else:
+            silicon_outcome = 'NOT RUN'
+            raised_runtime = "—"
+            native_runtime = "—"
+            ratio_text = "—"
+            comparison_scope = "—"
+            silicon_params = "—"
+        rows.append(
+            f'{name}{extracted_c}'
+            f'{html.escape(row["application"])}'
+            f'{html.escape(row["coverage"])}'
+            f'{upstream}{row["linalg_ops_int"]}'
+            f'{row["residual_loops_int"]}'
+            f'{row["matches_int"]}{row["launches_int"]}'
+            f'{matched_implementations}'
+            f'{silicon_outcome}{raised_runtime}'
+            f'{native_runtime}{ratio_text}'
+            f'{comparison_scope}{silicon_params}'
+        )
+    total_linalg = sum(row["linalg_ops_int"] for row in stats)
+    total_matches = sum(row["matches_int"] for row in stats)
+    loop_free = sum(row["residual_loops_int"] == 0 for row in stats)
+    applications = len({row["application"] for row in stats})
+    return (
+        '
    '
+        'Larger MFEM application C extractions
    '
+        '
    '
+        f'{len(stats)} concrete operator paths from {applications} larger '
+        f'applications. All passed cgeist and raising; {loop_free}/{len(stats)} '
+        f'are loop-free, producing {total_linalg} Linalg operations and '
+        f'{total_matches} semantic library matches. These are numerical hot paths, '
+        'not translations of MPI, mesh, or solver-control code. All rows were rebuilt '
+        'at NE=1024, D1D=4, Q1D=5 and run on the Jetson Orin in MAXN mode. '
+        'Ten paths pass correctness; the minimal-surface path fails at this larger '
+        'size and is intentionally not timed. Raised values are medians of warm '
+        'process runs 2–4. EXACT_OPERATOR is a directly paired native MFEM '
+        'CUDA operator. COMPONENT_SUM sums separately measured resident MFEM '
+        'CUDA PA kernels and is a conservative component baseline, not a fused '
+        'whole-application timing. PARTIAL_COMPONENT_SUM omits the ex9 PCG algebra. '
+        'UNAVAILABLE means this MFEM revision exposes no equivalent native CUDA '
+        'microbenchmark path.'
+        '
    '
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        + "\n".join(rows)
+        + '
    extracted entryextracted Capplicationcoverageupstream MFEM call siteLinalg opsresidual loopsmatchescandidate launchesmatched implementationcorrectnessraised warmMFEM native CUDAraised/nativecomparison scopetest parameters
    '
+    )
+
+
+def _mfem_application_section(app_stats: list[dict]) -> str:
+    rows = []
+    for stats in app_stats:
+        status = stats["raised_status"]
+        status_class = "pass" if status == "VALIDATED" else "partial"
+        name = (
+            f''
+            f'{html.escape(stats["id"])}'
+        )
+        rows.append(
+            f'{name}'
+            f'{html.escape(stats["application"])}'
+            f'{html.escape(stats["operator"])}'
+            f'{html.escape(stats["dimension"])}D'
+            f'{html.escape(stats["max_error"])}'
+            f'{html.escape(stats["reference_us"])}'
+            f'{html.escape(stats["sliced_us"])}'
+            f'{html.escape(stats["speedup"])}x'
+            f'{html.escape(stats["library_launches"])}'
+            f'{html.escape(status)}'
+            f'{html.escape(stats["blocker"])}'
+        )
+    return (
+        '
    '
+        'MFEM application hot-operator ports
    '
+        '
    '
+        f'{len(app_stats)} application operators from MFEM examples '
+        '1, 3, 4, and 9. CPU timings compare faithful extracted C with the '
+        'equivalent stage-sliced C over 10,000 warmed two-element applies. '
+        'These CPU speedups are normalization results, not GPU/library '
+        'speedups. Library-backed status is shown separately and silicon '
+        'execution remains gated on end-to-end correctness.'
+        '
    '
+        ''
+        ''
+        ''
+        ''
+        ''
+        + "\n".join(rows)
+        + '
    portapplicationoperatordimmax errorfaithful C (us)stage-sliced C (us)CPU speedupstructural launcheslibrary-backed statusblocker
    '
+    )
+
+
+def _mfem_section(mfem_stats: list[dict]) -> str:
+    rows = []
+    for stats in mfem_stats:
+        ident = html.escape(stats["id"])
+        page = html.escape(stats["page_filename"])
+        name = f'{ident}'
+        c_page = html.escape(stats["c_page_filename"])
+        extracted_c = (
+            f''
+            f'{html.escape(stats["source"])}:{html.escape(stats["function"])}'
+        )
+        upstream = (
+            f''
+            f'{html.escape(stats["upstream_pointer"])}'
+        )
+        variant = stats["variant"]
+        launches = stats["launches"]
+        if variant == "original":
+            status_class, status = "partial", "RESIDUAL"
+        elif launches:
+            status_class, status = "pass", "EXECUTABLE"
+        else:
+            status_class, status = "pass", "RAISED"
+        symbols = ", ".join(
+            f"@{html.escape(symbol)}"
+            for symbol in stats["matched_symbols"]
+        ) or "—"
+        silicon = stats.get("silicon", {})
+        if silicon:
+            correctness = html.escape(silicon["correctness"])
+            correctness_class = "pass" if correctness == "PASS" else "none"
+            raised_runtime = _fmt_seconds(
+                float(silicon["raised_runtime_us"]) / 1.0e6
+            )
+            native_runtime = _fmt_seconds(
+                float(silicon["mfem_native_runtime_us"]) / 1.0e6
+            )
+            ratio = float(silicon["raised_over_native"])
+            ratio_cell = f'MFEM {ratio:.1f}× faster'
+            before_cache = silicon.get("raised_runtime_us_before_plan_cache", "")
+            cache_speedup = silicon.get("plan_cache_speedup", "")
+            if before_cache and cache_speedup:
+                optimization_cell = (
+                    f'{float(cache_speedup):.2f}× faster
    '
+                    f'before: {_fmt_seconds(float(before_cache) / 1.0e6)}'
+                )
+            else:
+                optimization_cell = "—"
+        else:
+            correctness = raised_runtime = native_runtime = ratio_cell = "—"
+            optimization_cell = "—"
+            correctness_class = ""
+        rows.append(
+            f"{name}"
+            f"{extracted_c}{upstream}"
+            f"{html.escape(stats['family'])}"
+            f"{html.escape(stats['dimension'])}D"
+            f"{html.escape(variant)}"
+            f"{stats['linalg_ops']}"
+            f"{stats['residual_loops']}"
+            f"{launches}"
+            f'{status}'
+            f"{symbols}"
+            f'{correctness}'
+            f"{raised_runtime}{optimization_cell}"
+            f"{native_runtime}"
+            f"{ratio_cell}"
+        )
+
+    originals = [row for row in mfem_stats if row["variant"] == "original"]
+    normalized = [row for row in mfem_stats if row["variant"] == "normalized"]
+    total_linalg = sum(row["linalg_ops"] for row in mfem_stats)
+    fully_raised = sum(row["fully_raised"] for row in mfem_stats)
+    matched_kernels = sum(row["launches"] > 0 for row in normalized)
+    total_matches = sum(row["launches"] for row in normalized)
+    return (
+        ''
+        '
    '
+        'MFEM finite-element kernels
    '
+        '
    '
+        f'{len(mfem_stats)} tracked kernels: {len(originals)} faithful '
+        f'originals and {len(normalized)} structurally normalized equivalents. '
+        f'The raising pipeline produced {total_linalg} Linalg operations; '
+        f'{fully_raised}/{len(mfem_stats)} kernels are loop-free, including '
+        f'all {len(normalized)}/{len(normalized)} normalized variants. '
+        f'The matcher emitted {total_matches} ABI-lowerable library launches '
+        f'across {matched_kernels}/{len(normalized)} normalized kernels. '
+        'Each row links to the '
+        'stored frontend, raised, debufferized, and matcher-rewritten IR plus '
+        'a Compiler Explorer deep link.'
+        '
    Silicon comparison: all 18 matcher-covered normalized '
+        'kernels (ten PA operators plus eight DFEM interpolation/integration '
+        'maps) use f64, NE=1024, D1D=4, Q1D=5, and 20 warm iterations on '
+        'Jetson Orin sm_87 in MAXN mode with CUDA 12.6. The raised value is '
+        'the median of '
+        'process runs 2–4 so the first cold CUDA process is excluded. '
+        '“Raised” is the current cached host-pointer ABI (including '
+        'host-mapping, correctness snapshots, and synchronization overhead); '
+        'prepared cuTensorNet plans, workspaces, and scratch are reused. '
+        '“MFEM CUDA” is a synchronized '
+        'resident-device native MFEM launch. This intentionally records the '
+        'performance gap in the current end-to-end lowering and is not a '
+        'kernel-only claim.'
+        '
    '
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        + "\n".join(rows)
+        + '
    kernelextracted Cupstream MFEM sourcefamilydimvariantLinalg opsresidual loopsexecutable launchesstatusmatched implementationsilicon correctnessraised current ABIplan-cache improvementMFEM native CUDAruntime difference
    '
+    )
+
+
+# Map blocker tag to a CSS class so the table cell can be colour-coded.
+# "FIXABLE" categories (scratch-carry, indirect-index, mixed-reductions,
+# matcher-gap, debuf-bug) -> partial (yellow). Fundamental blockers
+# (serial-recurrence, t-loop, non-affine, cgeist-frontend) -> none (red).
+# "none" -> pass (green).
+_BLOCKER_CSS = {
+    "none":              "pass",
+    "matcher-gap":       "partial",
+    "runtime-gap":       "partial",
+    "scratch-carry":     "partial",
+    "indirect-index":    "partial",
+    "mixed-reductions":  "partial",
+    "debuf-bug":         "partial",
+    "t-loop":            "none",
+    "serial-recurrence": "none",
+    "non-affine":        "none",
+    "cgeist-frontend":   "none",
+    "raise-fail":        "none",
+    "raise-crash":       "none",
+    "no-linalg":         "none",
+    "ext-math-call":     "partial",
+    # Pipeline is correct; the gap is downstream (library / frontend). Mark
+    # as "partial" — matcher / lowering still validate end-to-end.
+    "cudnn-dtype-gap":   "partial",
+    "cgeist-dtype-gap":  "partial",
+    "partial-pipeline":  "partial",
+}
+
+
+def _fmt_seconds(s: float) -> str:
+    """Format a seconds value for display in the runtime cells:
+    sub-millisecond → µs, sub-second → ms, otherwise s."""
+    if s < 0.001:
+        return f"{s*1e6:.1f} µs"
+    if s < 1.0:
+        return f"{s*1000:.2f} ms"
+    return f"{s:.2f} s"
+
+
+def _runtime_cells_for(kernel: str, runtimes: dict[str, list[dict]] | None) -> list[str]:
+    """One  block per runtime entry.
+    Empty list if no runtime comparison exists for this kernel; the caller
+    emits empty placeholders for all five runtime cells. PolyBench entries use
+    raised_ms/pbgpu_ms and get an automatic speed comparison. Other sections
+    can pass preformatted raised/reference/winner strings.
+    """
+    entries = (runtimes or {}).get(kernel, [])
+    cells_per_row = []
+    for e in entries:
+        size = e["size"]
+        if "raised_ms" in e and "pbgpu_ms" in e:
+            raised_s = e["raised_ms"] / 1000.0
+            pbgpu_s = e["pbgpu_ms"] / 1000.0
+            raised_cell = _fmt_seconds(raised_s)
+            reference_cell = _fmt_seconds(pbgpu_s)
+            raised_speedup = pbgpu_s / raised_s if raised_s > 0 else 0.0
+            if raised_speedup >= 1.10:
+                su_cls = "pass"
+                winner = f'raised {raised_speedup:.2f}×'
+            elif raised_speedup >= 0.90:
+                su_cls = "partial"
+                if raised_speedup >= 1.0:
+                    winner = f'raised {raised_speedup:.2f}×'
+                else:
+                    winner = f'PBGPU {1.0 / raised_speedup:.2f}×'
+            else:
+                su_cls = "none"
+                winner = f'PBGPU {1.0 / raised_speedup:.2f}×'
+        else:
+            raised_cell = e.get("raised", "—")
+            reference_cell = e.get("reference", "—")
+            winner = e.get("winner", "—")
+            su_cls = e.get("winner_class")
+            if not su_cls:
+                if winner.startswith("raised"):
+                    su_cls = "pass"
+                elif winner in ("n/a", "—", "raised-only"):
+                    su_cls = "partial"
+                else:
+                    su_cls = "none"
+        note = e.get("notes", "") or ""
+        note_html = (f''
+                     f'{note}' if note else
+                     '')
+        cells_per_row.append(
+            f'{size}'
+            f'{raised_cell}'
+            f'{reference_cell}'
+            f''
+            f'{winner}'
+            + note_html
+        )
+    return cells_per_row
+
+
+def _render_section_rows(kernel_stats: dict[str, dict],
+                          notes: dict[str, tuple[str, str]],
+                          blockers: dict[str, tuple[str, str]],
+                          runtimes: dict[str, list[dict]] | None = None,
+                          display_names: dict[str, str] | None = None,
+                          order: list[str] | None = None) -> str:
+    rows = []
+    if order:
+        ordered = [k for k in order if k in kernel_stats]
+        ordered += sorted(k for k in kernel_stats if k not in set(order))
+    else:
+        ordered = sorted(kernel_stats)
+    for k in ordered:
+        s = kernel_stats[k]
+        page_file = s.get("page_filename", f"{k}.html")
+        l = s["launches"]; r = s["residual"]; f = s["residual_for"]
+        if l > 0 and r == 0 and f == 0:
+            cls = "pass"; status = "FULL"
+        elif l > 0:
+            cls = "partial"; status = "PARTIAL"
+        else:
+            cls = "none"; status = "NONE"
+        for_cls = "none" if f > 0 else "pass"
+
+        label = (display_names or {}).get(k, k)
+        if page_file:
+            kernel_link = f'{label}'
+        elif s.get("ce_suppressed"):
+            kernel_link = f'{label} (IR only)'
+        else:
+            kernel_link = f'{label} (no source)'
+
+        note_tag, note_blurb = notes.get(k, ("", ""))
+        tag_cls = {
+            "highly parallel":   "pass",
+            "parallel + T loop": "partial",
+            "partial parallel":  "partial",
+            "serial":            "none",
+        }.get(note_tag, "")
+        note_cell = (
+            f'{note_tag}'
+            f'{note_blurb}'
+            if note_tag else ''
+        )
+
+        block_tag, block_blurb = blockers.get(k, ("none", ""))
+        block_label = BLOCKER_TAXONOMY.get(block_tag, ("", ""))[0]
+        block_cls = _BLOCKER_CSS.get(block_tag, "")
+        if block_tag == "none":
+            block_cell = (
+                '—'
+                ''
+            )
+        else:
+            block_cell = (
+                f''
+                f''
+                f'{block_label}'
+                f'{block_blurb}'
+            )
+
+        kernel_cell = f'{kernel_link}'
+        match_cells = (
+            f'{l}{r}{f}'
+            f'{status}'
+        )
+
+        # Jetson-runtime cells: one  per warmed comparison entry when data
+        # exists; otherwise one  with five empty runtime cells.
+        runtime_rows = _runtime_cells_for(k, runtimes)
+        if not runtime_rows:
+            runtime_rows = ['—'
+                            '—'
+                            '—'
+                            '—'
+                            '—']
+
+        # Multi-row layout: the kernel-shared cells (name, match-status,
+        # parallelism, blocker) use rowspan to span all the runtime rows
+        # for this kernel. The first runtime row joins them; the rest are
+        # standalone s with only the four runtime cells.
+        n_rows = len(runtime_rows)
+        rowspan_attr = f' rowspan="{n_rows}"' if n_rows > 1 else ''
+
+        # Re-apply rowspan to each  in kernel_cell / match_cells /
+        # note_cell / block_cell. We need to inject rowspan into each
+        # opening . Simplest: substitute via string ops.
+        def _with_rowspan(html: str) -> str:
+            # Only adds rowspan to  tags (not ); used when n_rows>1.
+            if n_rows <= 1:
+                return html
+            # Replace each `)', f'{first_kernel}{first_match}{first_note}{first_block}'
+            f'{runtime_rows[0]}'
+        )
+        for rr in runtime_rows[1:]:
+            rows.append(f'{rr}')
+    return "\n".join(rows)
+
+
+def _build_section(title: str, anchor: str, blurb: str,
+                    kernel_stats: dict[str, dict],
+                    notes: dict[str, tuple[str, str]],
+                    blockers: dict[str, tuple[str, str]],
+                    extra_html: str = "",
+                    runtimes: dict[str, list[dict]] | None = None,
+                    display_names: dict[str, str] | None = None,
+                    order: list[str] | None = None,
+                    runtime_headers: tuple[str, str, str, str, str] = (
+                        "Jetson
    case",
+                        "Raised pipeline
    (rt-gpu)",
+                        "PolyBenchGPU
    CUDA",
+                        "winner
    speed",
+                        "notes",
+                    )) -> str:
+    """Render one benchmark-suite section: a section header, blurb, then table."""
+    rows_html = _render_section_rows(
+        kernel_stats, notes, blockers,
+        runtimes=runtimes,
+        display_names=display_names,
+        order=order,
+    )
+    case_h, raised_h, reference_h, winner_h, notes_h = runtime_headers
+    return (
+        f''
+        f'
    {title}
    '
+        f'
    {blurb}
    '
+        + extra_html +
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        f''
+        f''
+        f''
+        f''
+        f''
+        ''
+        + rows_html +
+        '
    kernelkernel.launchesresidual linalg.genericresidual for-loopsmatch statusparallelismparallelism notesblockerblocker notes{case_h}{raised_h}{reference_h}{winner_h}{notes_h}
    '
+    )
+
+
+def _llama2c_runtime_summary() -> str:
+    """Render the Llama numbers as a visible section-local table.
+
+    The shared runtime columns compare PolyBench rows against PolyBenchGPU, so
+    Llama gets its own table with the appropriate comparison target.
+    """
+    return (
+        '
    '
+        'Latest Jetson Llama runtime numbers'
+        '
    '
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        '
    fixturecoverageraised device timecomparisonhost-visible timenotes
    N=1024, H=4096 forward tensor pathRMSNorm + zero-fill + SGEMV + softmaxRMSNorm ~0.09-0.10 ms
    '
+        'SGEMV ~0.53-0.55 ms
    '
+        'softmax ~0.028-0.030 ms    		validated against native C outputnot the headline metricwarm timings after first-use setup; RMSNorm uses cuDNN backend '
+        'graph at this size
    N=2048, H=32000 logits suffixRMSNorm + scale + output projection GEMVraised device-only median 1.614 msggml/llama.cpp CUDA median 1.494 msraised median 1.652 ms after RMSNorm plan cachingremaining gap is mostly SGEMV/output projection plus separate '
+        'shim overhead
    standalone Llama op sweep17 raised standalone ops, MODEL_DIM=64, FFN_DIM=128, '
+        'SEQ_LEN=32, VOCAB=256one-layer sum 0.575 ms device median
    '
+        'embedding + one layer + final RMSNorm + lm_head 0.662 ms    		runtime-shim warm timings, first 5 of 50 iterations discardedone-layer sum 0.832 ms host median
    '
+        'embedding + one layer + final RMSNorm + lm_head 0.955 ms    		covers split RoPE and branchless mask; interleaved RoPE and '
+        'branchy mask still remain non-raised variants
    '
+    )
+
+
+def _llama_forward_runtime_summary() -> str:
+    return (
+        '
    '
+        'Exact one-token Llama fixture comparison'
+        '
    '
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        '
    fixturemath comparedggml CUDAraised pipelinecorrectnessnotes
    extended_forward, 7B-size one layerone token at pos=1024: MODEL_DIM=4096, FFN_DIM=11008, '
+        'VOCAB=32000, SEQ_LEN=2048, HEADS=32warm host median 9.638 mswarm host median 13.480 ms
    warm device median 12.273 ms
    '
+        'cold first iter host 447.317 ms    		first 4 logits match exactly to printed precision; checksum '
+        'diff is about 0.002 over 32000 logitsSame one-layer f32 fixture and dimensions, not the full 32-layer '
+        'Llama 2 model and not a quantized GGUF path.
    extended_forward, toy one layerone token at pos=16: MODEL_DIM=64, FFN_DIM=128, VOCAB=256, '
+        'SEQ_LEN=32, HEADS=4warm host median 0.098 ms
    cold one-iter 72.725 ms    		warm host median 0.719 ms
    warm device median 0.447 ms
    '
+        'cold first iter host 269.634 ms    		ggml CUDA vs native C max diff 8.46e-06Kept for fast IR/debug iteration; the 7B-size row is the '
+        'headline size comparison.
    '
+    )
+
+
+def _build_taxonomy_panel() -> str:
+    """A top-of-page explainer for the per-kernel `blocker` column.
+    Categories link from each row's blocker cell to the right entry here."""
+    rows = []
+    for tag, (label, longer) in BLOCKER_TAXONOMY.items():
+        cls = _BLOCKER_CSS.get(tag, "")
+        rows.append(
+            f''
+            f'{label}'
+            f'{longer}'
+        )
+    return (
+        ''
+        '
    '
+        '  
    Algorithm-blocker taxonomy
    '
+        '
    '
+        '
    '
+        '  Each kernel below carries a blocker tag describing what '
+        '  prevents it from lifting fully (or matching to a kernel.launch). '
+        '  Green tags are wins (no blocker); yellow tags are fixable '
+        '  gaps in our raise / matcher / debufferize passes; red tags are '
+        '  fundamental — the algorithm has cross-iteration data '
+        '  dependencies that no transformation can remove. Categories:'
+        '
    '
+        ''
+        ''
+        ''
+        + "\n".join(rows) +
+        '
    categorymeaning
    '
+    )
+
+
+# Polybench-style single-file CNN-block kernels extracted from darknet
+# for the matcher+cuDNN-shim end-to-end work. Each kernel is its own
+# `.c` in third_party/cnn-extracted/, with MINI/LARGE dataset macros
+# and (for the multi-step ones) a chained body that exercises the
+# matcher's longest-first composition library. See the section blurb
+# for which library entry each kernel matches.
+EXTRACTED_DARKNET_KERNELS: dict[str, tuple[str, str]] = {
+    "conv2d_batched":      ("conv2d_batched.c",      "kernel_conv2d_batched"),
+    "darknet_im2col_gemm": ("darknet_im2col_gemm.c", "kernel_darknet_im2col_gemm"),
+    "maxpool_batched":     ("maxpool_batched.c",     "kernel_maxpool_batched"),
+    "batchnorm_batched":   ("batchnorm_batched.c",   "kernel_batchnorm_batched"),
+    "shortcut_batched":    ("shortcut_batched.c",    "kernel_shortcut_batched"),
+    "conv_bn_relu_batched":("conv_bn_relu_batched.c","kernel_conv_bn_relu_batched"),
+}
+
+# Fusion-optimization kernels — algebraic rewrites that exploit specific
+# patterns to route to faster cuBLAS / cublasLt / cuDNN entry points.
+# Same .c source layout (third_party/cnn-extracted/) and bake pipeline
+# as extracted_darknet, but a separate section in the IR explorer so
+# the headline speedups are easy to spot.
+FUSION_OPT_KERNELS: dict[str, tuple[str, str]] = {
+    "conv_bias_relu_add_batched": ("conv_bias_relu_add_batched.c", "kernel_conv_bias_relu_add_batched"),
+    "gemm_bias_relu":              ("gemm_bias_relu.c",              "kernel_gemm_bias_relu"),
+    "ata_gemm":                    ("ata_gemm.c",                    "kernel_ata_gemm"),
+    "conv1x1_batched":             ("conv1x1_batched.c",             "kernel_conv1x1_batched"),
+}
+
+
+EXTRACTED_DARKNET_RUNTIMES: dict[str, list[dict]] = {
+    # Jetson Orin silicon runs (2026-05-25). All FP32 NCHW. The MINI
+    # shapes are overhead-bound (cuDNN descriptor + workspace setup
+    # dominates a sub-ms kernel). LARGE conv2d is where cuDNN's
+    # tensor-core kernels shine — 23.8× over the CPU 3-loop reference.
+    # batchnorm/shortcut LARGE remain bandwidth-bound and lose to the
+    # CPU at single-call granularity; that's the well-known story for
+    # standalone elementwise ops without device-residency hoisting.
+    "conv2d_batched": [
+        {"size": "MINI",  "shape": "B=4 IC=OC=8 H=W=32 K=3",
+         "gpu_s": 0.084316, "cpu_s": 0.001871, "correct": "FP-noise",
+         "notes": "Setup-bound: cuDNN descriptor + workspace + algo selection "
+                  "≫ 28K-elem output; the 1.87 ms CPU 3-loop is just the math"},
+        {"size": "LARGE", "shape": "B=32 IC=OC=64 H=W=56 K=3",
+         "gpu_s": 0.137029, "cpu_s": 3.260427, "correct": "FP-noise",
+         "notes": "ResNet conv2_x shape, tensor cores light up; 23.8× GPU win"},
+    ],
+    "maxpool_batched": [
+        {"size": "MINI",  "shape": "B=4 C=8 H=W=32 K=S=2",
+         "gpu_s": 0.012863, "cpu_s": 0.000057, "correct": "PASS",
+         "notes": "Setup-bound; 8K output elems is trivial"},
+        {"size": "LARGE", "shape": "B=32 C=64 H=W=112 K=3 S=2",
+         "gpu_s": 0.023644, "cpu_s": 0.030398, "correct": "PASS",
+         "notes": "ResNet stem maxpool; bandwidth-bound, cuDNN marginal win"},
+    ],
+    "batchnorm_batched": [
+        {"size": "MINI",  "shape": "B=4 C=8 H=W=32",
+         "gpu_s": 0.005291, "cpu_s": 0.000059, "correct": "FP-noise",
+         "notes": "Setup-bound; 32K elems too small for cuDNN's BN to win"},
+        {"size": "LARGE", "shape": "B=32 C=64 H=W=56",
+         "gpu_s": 0.011313, "cpu_s": 0.004263, "correct": "FP-noise",
+         "notes": "Bandwidth-bound elementwise; cuDNN BN setup overhead "
+                  "doesn't amortize on a single call. Would need device-"
+                  "residency to win"},
+    ],
+    "shortcut_batched": [
+        {"size": "MINI",  "shape": "B=4 C=8 H=W=32",
+         "gpu_s": 0.045177, "cpu_s": 0.000008, "correct": "PASS",
+         "notes": "Setup-bound; cudnnAddTensor on 32K elems is pure overhead"},
+        {"size": "LARGE", "shape": "B=32 C=64 H=W=56",
+         "gpu_s": 0.049720, "cpu_s": 0.004171, "correct": "PASS",
+         "notes": "Bandwidth-bound 2-buffer add; 6.4M float ops finish in "
+                  "4ms on CPU. cuDNN AddTensor adds descriptor setup cost"},
+    ],
+    # Fused conv + bn + relu — the canonical ResNet inner pattern. The
+    # matcher folds all four loop nests (init + conv + bn-inplace +
+    # relu-inplace) into one launch. The runtime shim uses the standard
+    # BN-folding trick (pre-multiply filter by scale*inv_std, adjust
+    # bias) and issues a single cudnnConvolutionBiasActivationForward
+    # call. Result: same wall-clock as conv2d_batched alone, but doing
+    # all three ops — bn and relu effectively ride free on conv's
+    # compute-bound win.
+    "conv_bn_relu_batched": [
+        {"size": "MINI",  "shape": "B=4 IC=OC=8 H=W=32 K=3",
+         "gpu_s": 0.186320, "cpu_s": 0.002020, "correct": "PASS",
+         "notes": "Setup-bound (the larger MINI gap vs conv2d alone is "
+                  "the first-call init of cudnnConvolutionBiasActivation"
+                  "Forward + a host BN-fold pass)"},
+        {"size": "LARGE", "shape": "B=32 IC=OC=64 H=W=56 K=3",
+         "gpu_s": 0.137820, "cpu_s": 3.243928, "correct": "FP-noise",
+         "notes": "Same 23.5× as conv2d_batched alone, but doing 3 ops. "
+                  "Fusion absorbs the bandwidth-bound bn+relu cost — they "
+                  "become free in the conv's memory pass. Best argument "
+                  "for cuDNN's fused-op API"},
+    ],
+}
+
+
+# Silicon numbers for the four fusion-optimization kernels (Jetson Orin,
+# 2026-05-25). All FP32. The "vs naive" column says what we'd be doing
+# without the rewrite — e.g. running the standalone op chain through
+# separate cuDNN launches, or routing K=1 conv through cuDNN's generic
+# path, or computing AᵀA as a full gemm.
+FUSION_OPT_RUNTIMES: dict[str, list[dict]] = {
+    "conv_bias_relu_add_batched": [
+        {"size": "MINI",  "shape": "B=4 IC=OC=8 H=W=32 K=3",
+         "gpu_s": 0.121859, "cpu_s": 0.001943, "correct": "PASS",
+         "notes": "Setup-bound (single-call init of cudnnConvolutionBias"
+                  "ActivationForward); fused bias+add+relu shows here only "
+                  "via the descriptor count, not via actual work"},
+        {"size": "LARGE", "shape": "B=32 IC=OC=64 H=W=56 K=3",
+         "gpu_s": 0.139847, "cpu_s": 3.253224, "correct": "FP-noise",
+         "notes": "Same ~23.3× as conv2d_batched alone (137 ms) — bias + "
+                  "residual-add + relu absorbed FREE into the conv's memory "
+                  "pass. Closes the standalone shortcut-add GPU LOSS"},
+    ],
+    "gemm_bias_relu": [
+        {"size": "MINI",  "shape": "M=N=K=64",
+         "gpu_s": 0.075925, "cpu_s": 0.000201, "correct": "PASS",
+         "notes": "Setup-bound (first-call init of cublasLtMatmul) "
+                  "+ host BN-folding overhead"},
+        {"size": "LARGE", "shape": "M=N=K=2048",
+         "gpu_s": 0.056678, "cpu_s": 51.083039, "correct": "FP-noise",
+         "notes": "cublasLt EPILOGUE_RELU_BIAS fires tensor cores; 901× "
+                  "vs CPU 3-loop (which on 2048³ is brutally cache-unfriendly)"},
+    ],
+    "ata_gemm": [
+        {"size": "MINI",  "shape": "M=K=64",
+         "gpu_s": 0.003577, "cpu_s": 0.000203, "correct": "PASS",
+         "notes": "Setup-bound; syrk's half-flops can't shine at this size"},
+        {"size": "LARGE", "shape": "M=K=2048",
+         "gpu_s": 0.019123, "cpu_s": 64.939412, "correct": "PASS",
+         "notes": "cublasSsyrk does HALF the flops of an equivalent gemm "
+                  "(only upper triangle of symmetric output). 3393× vs CPU."},
+    ],
+    "conv1x1_batched": [
+        {"size": "MINI",  "shape": "B=4 IC=OC=16 H=W=32",
+         "gpu_s": 0.045098, "cpu_s": 0.000796, "correct": "PASS",
+         "notes": "Setup-bound; per-batch gemms are small"},
+        {"size": "LARGE", "shape": "B=32 IC=OC=256 H=W=56",
+         "gpu_s": 0.068130, "cpu_s": 7.132080, "correct": "PASS",
+         "notes": "cublasSgemmStridedBatched on B=32 independent (256,3136)="
+                  "(256,256)·(256,3136) gemms. 105× vs CPU 3-loop. Way "
+                  "faster than cuDNN's generic K=1 conv path"},
+    ],
+}
+
+
+# ------------------------------------------------------------------
+# PVA backend — kernels lowered through --lower-kernel-launch-to-pva
+# to NVIDIA PVA Solutions' libpva_operator on the Jetson Orin
+# Programmable Vision Accelerator. PVA-only datapoints; no CPU compare.
+# ------------------------------------------------------------------
+
+PVA_KERNELS: list[dict] = [
+    {
+        "id": "conv2d_i8",
+        "op": "OpConv2d",
+        "vendor_call": "pvaConv2dCreate / pvaConv2dSubmit",
+        "shim": "polygeist_pva_conv2d_3x3_i8",
+        "matched": True,
+        "build_dir": "/tmp/conv2d_jetson_i8_256",
+        "timings": [("256×256", "33.3 ms"),
+                    ("1024×1024", "33.7 ms"),
+                    ("10240×10240", "216.3 ms")],
+        "note": "Single-channel 3×3 9-tap signed conv from "
+                "the extracted conv2d_i8 dtype source. Full matcher pipeline "
+                "(cgeist → linalg → @cudnnConvolution2D_9tap_i8 → "
+                "--lower-kernel-launch-to-pva).",
+    },
+    {
+        "id": "conv2d_i16",
+        "op": "OpConv2d",
+        "vendor_call": "pvaConv2dCreate / pvaConv2dSubmit",
+        "shim": "polygeist_pva_conv2d_3x3_i16",
+        "matched": True,
+        "build_dir": "/tmp/conv2d_jetson_i16_256",
+        "timings": [("256×256", "33.5 ms"),
+                    ("1024×1024", "34.8 ms"),
+                    ("10240×10240", "372.9 ms")],
+        "note": "Same shape as i8, 2-byte elements. PVA hardware applies "
+                "Q16.16 fixed-point semantics to kernel coefficients.",
+    },
+    {
+        "id": "boxfilter_i8",
+        "op": "OpBoxFilter",
+        "vendor_call": "pvaBoxFilterCreate / pvaBoxFilterSubmit",
+        "shim": "polygeist_pva_boxfilter_3x3_i8",
+        "matched": False,
+        "build_dir": "/tmp/pva_boxfilter_i8_256",
+        "timings": [("256×256", "40.4 ms")],
+        "note": "Uniform 1/K² 3×3 mean filter — no coefficient tensor. "
+                "Validated via hand-authored MLIR (matcher template for "
+                "uniform-weight conv is not yet written).",
+    },
+    {
+        "id": "gaussian_i8",
+        "op": "OpGaussianFilter",
+        "vendor_call": "pvaGaussianFilterCreate / pvaGaussianFilterSubmit",
+        "shim": "polygeist_pva_gaussian_3x3_i8",
+        "matched": False,
+        "build_dir": "/tmp/pva_gaussian_i8_256",
+        "timings": [("256×256", "32.6 ms")],
+        "note": "σ=1, K=3 hardcoded in shim. PVA computes the discrete "
+                "Gaussian kernel internally; matches canonical "
+                "[1,2,1;2,4,2;1,2,1]/16. Hand-authored MLIR.",
+    },
+    {
+        "id": "bilateral_i8",
+        "op": "OpBilateralFilter",
+        "vendor_call": "pvaBilateralFilterCreate / pvaBilateralFilterSubmit",
+        "shim": "polygeist_pva_bilateral_3x3_i8",
+        "matched": False,
+        "build_dir": "/tmp/pva_bilateral_i8_256",
+        "timings": [("256×256", "57.5 ms")],
+        "note": "PVA Bilateral only accepts U8; shim reinterprets i8 bytes "
+                "bitwise as U8 via make_pva_image_tensor_dtype. "
+                "sigmaRange=25, sigmaSpace=10 hardcoded.",
+    },
+    {
+        "id": "histeq_i8",
+        "op": "OpHistogramEqualization",
+        "vendor_call": "pvaHistogramEqualizationCreate / pvaHistogramEqualizationSubmit",
+        "shim": "polygeist_pva_histeq_i8",
+        "matched": False,
+        "build_dir": "/tmp/pva_histeq_i8_256",
+        "timings": [("256×256", "38.8 ms")],
+        "note": "Pointwise 256-bin LUT (no spatial kernel). PVA computes "
+                "the histogram + CDF + LUT internally. Hand-authored MLIR.",
+    },
+]
+
+
+def _pva_section() -> str:
+    """Polygeist → PVA Solutions kernels. Each row is a kernel we successfully
+    lowered through --lower-kernel-launch-to-pva and ran on the Jetson Orin
+    PVA accelerator. Timings are wall-clock from pva*Submit (full setup +
+    submit + sync round-trip, single-shot). No CPU comparison here — PVA-only
+    datapoints; the CPU stubs exist for separate per-op correctness validation."""
+    rows = []
+    for spec in PVA_KERNELS:
+        first = True
+        rowspan = len(spec["timings"]) or 1
+        match_lbl = "matcher" if spec["matched"] else "hand-authored"
+        match_cls = "pass" if spec["matched"] else "partial"
+        for size, ms in (spec["timings"] or [("—", "—")]):
+            if first:
+                kernel_cell = (
+                    f''
+                    f'{spec["id"]}'
+                    f'
    '
+                    f'frontend: {match_lbl}'
+                    f'
    '
+                )
+                op_cell = (
+                    f''
+                    f'{spec["op"]}
    '
+                    f'{spec["vendor_call"]}'
+                )
+                shim_cell = (
+                    f''
+                    f'{spec["shim"]}'
+                )
+                note_cell = (
+                    f''
+                    f'{spec["note"]}'
+                )
+            else:
+                kernel_cell = op_cell = shim_cell = note_cell = ""
+            first = False
+            rows.append(
+                ""
+                + kernel_cell + op_cell + shim_cell
+                + f'{size}'
+                + f'{ms}'
+                + note_cell
+                + ""
+            )
+    table = (
+        ''
+        ''
+        ''
+        ''
+        ''
+        + "\n".join(rows) +
+        '
    kernelPVA opruntime shimdatasetPVA wall-clocknotes
    '
+    )
+    return (
+        '
    '
+        '  
    PVA backend '
+        '  (Polygeist → libpva_operator on Jetson Orin\'s Programmable '
+        '   Vision Accelerator)
    '
+        '
    '
+        '
    '
+        '  Kernels lowered through the new --lower-kernel-launch-to-pva '
+        '  pass (see lib/polygeist/Passes/LowerKernelLaunchToPVA.cpp). '
+        '  Each row is a kernel that successfully reaches PVA silicon via a '
+        '  func.call @polygeist_pva_* emitted by the lowering pass and '
+        '  resolved at link-time against the PVA shim in '
+        '  runtime/polygeist_pva_rt.c, which wraps the corresponding '
+        '  pva*Create / pva*Submit entrypoint in '
+        '  libpva_operator.so.'
+        '  

    '
+        '  Two kernels come through the full matcher pipeline today '
+        '  (Conv2d i8 and i16, lifted from extracted dtype-specific conv2d sources). '
+        '  The remaining four were validated via hand-authored kernel.launch '
+        '  MLIR — the lowering + shim + silicon work, but matcher templates that '
+        '  recognise their C-level patterns (uniform-weight conv, Gaussian-weighted '
+        '  conv, bilateral, histogram-eq) have not been written yet.'
+        '  

    '
+        '  Per-call timing floor: ~30–35 ms at any image size up to '
+        '  ~1024², dominated by PVA allocator + CupvaMemGetHostPointer '
+        '  + operator create/submit + cuPVA scheduling + stream sync. Compute is '
+        '  sub-ms at these sizes. At 10240² (105M pixels) the per-call setup '
+        '  amortises and PVA compute dominates.'
+        '  

    '
+        '  No CPU comparison shown here; for bit-exact CPU/PVA diff validation '
+        '  see the scripts/correctness/pva_*_jetson.sh test scaffolds '
+        '  and the matching CPU stubs in '
+        '  runtime/polygeist_cublas_rt_cpu.c.'
+        '
    '
+        + table
+        + '
    '
+          '  What is new infrastructure for this section:'
+          '  
      '
+          '  
    • New pass LowerKernelLaunchToPVA '
+          '      (lib/polygeist/Passes/LowerKernelLaunchToPVA.cpp)
      • '
+          '  
    • Shared 9-tap conv lowering helper extracted from the cuBLAS '
+          '      pass into KernelLaunchLoweringUtils.{h,cpp}; '
+          '      both passes call it. Added a parallel '
+          '      lowerImageFilter2Operand helper for the 2-memref '
+          '      filter shape (Box/Gaussian/Bilateral/HistogramEq).
      • '
+          '  
    • PVA runtime shim runtime/polygeist_pva_rt.c with '
+          '      a generic make_pva_image_tensor_dtype backbone, '
+          '      CupvaMemGetHostPointer-mediated host I/O, '
+          '      and one pva<Op>Create + '
+          '      pva<Op>Submit wrapper per op.
      • '
+          '  
    • Matching CPU reference stubs in '
+          '      runtime/polygeist_cublas_rt_cpu.c, hand-modelled '
+          '      to mirror PVA hardware semantics (centred anchor, REPLICATE '
+          '      border, Q-shift, unsigned-kernel reinterpretation) so the '
+          '      conv2d_jetson ↔ conv2d_jetson_cpustub '
+          '      diff is bit-exact.
      • '
+          '  
    • Cross-compile script conv2d_cudnn_jetson_dtype.sh '
+          '      extended with an i8 dtype branch + PVA-library '
+          '      link line (libpva_operator, libcvcuda, '
+          '      libnvcv_types, libcupva_host, plus '
+          '      libnvscibuf / libnvscisync as '
+          '      direct DT_NEEDEDs via -Wl,--no-as-needed).
      • '
+          '  
    '
+          '
    '
+    )
+
+
+def _fusion_opt_section(fopt_stats: dict[str, dict]) -> str:
+    """4 algebraic / fusion-optimization kernels: conv+bias+relu+add,
+    gemm+bias+relu (cublasLt), AᵀA→cublasSsyrk via operand alias,
+    1×1 conv → cublasSgemmStridedBatched. Each picks a faster cuBLAS /
+    cublasLt / cuDNN entry point than the matcher's default routing."""
+    rows = []
+    for k, entries in FUSION_OPT_RUNTIMES.items():
+        first = True
+        rowspan = len(entries)
+        stats = fopt_stats.get(k, {})
+        if stats.get("ce_url"):
+            kernel_link = (
+                f''
+                f'{k}'
+            )
+        else:
+            kernel_link = f'{k}'
+        ir_link = (
+            f'[IR preview]'
+            if stats.get("page_filename") else ""
+        )
+        l = stats.get("launches", 0)
+        r = stats.get("residual", 0)
+        fcount = stats.get("residual_for", 0)
+        match_status = ("FULL" if l > 0 and r == 0 and fcount == 0 else
+                        "PARTIAL" if l > 0 else "NONE")
+        match_cls = ("pass" if match_status == "FULL" else
+                     "partial" if match_status == "PARTIAL" else "none")
+        for e in entries:
+            size, shape = e["size"], e["shape"]
+            gpu, cpu = e["gpu_s"], e["cpu_s"]
+            speedup = cpu / gpu if gpu > 0 else 0.0
+            su_cls = ("pass" if speedup >= 2.0
+                      else "partial" if speedup >= 0.8
+                      else "none")
+            cmark = {"PASS": "✓", "FP-noise": "≈",
+                     "DIFF": "✗"}.get(e["correct"], "?")
+            note = e.get("notes", "")
+            if first:
+                kernel_cell = (
+                    f''
+                    f'{kernel_link}{ir_link}'
+                    f'
    '
+                    f'  matcher: '
+                    f'{match_status} ({l} launch, {r} res lg, '
+                    f'{fcount} loops)
    '
+                )
+            else:
+                kernel_cell = ""
+            first = False
+            rows.append(
+                ""
+                + kernel_cell
+                + f'{size}'
+                + f'{shape}'
+                + f'{_fmt_seconds(gpu)}'
+                + f'{_fmt_seconds(cpu)}'
+                + f''
+                + f'{speedup:.0f}× {cmark}'
+                + f'{note}'
+                + "")
+    table = (
+        ''
+        ''
+        ''
+        ''
+        ''
+        + "\n".join(rows) +
+        '
    kerneldatasetshapeGPUCPU (3-loop)GPU speedupnotes
    '
+    )
+    return (
+        '
    '
+        '  
    Fusion optimization '
+        '  (algebraic rewrites for fast cuBLAS / cublasLt / cuDNN paths)
    '
+        '
    '
+        '
    '
+        '  Four follow-on entries to the extracted-darknet matcher work. '
+        '  Each is an algebraic rewrite — same math as the naive '
+        '  multi-op chain, but routed to a single fused cuDNN / cublasLt / '
+        '  cuBLAS call that fires faster paths. The wins range from '
+        '  23× (conv chain) to 3393× (AᵀA → syrk) over the '
+        '  CPU 3-loop reference.'
+        '  

    '
+        '  Matched launch symbols introduced by these compositions:'
+        '  
      '
+        '  
    • @cudnnConvBiasReluAddFwdFused — 5-step: init + conv + '
+        '      bias + residual-add + relu. Routes to '
+        '      cudnnConvolutionBiasActivationForward with the Z '
+        '      addend (α₂=1) for the skip connection.
      • '
+        '  
    • @cublasLtMatmulBiasReluFused — 4-step: init + gemm + '
+        '      bias + relu. Routes to cublasLtMatmul with '
+        '      CUBLASLT_EPILOGUE_RELU_BIAS. Needs '
+        '      libcublasLt at link.
      • '
+        '  
    • @cublasDsyrk_alias — operand-alias discriminator on '
+        '      the gemm-shape composition. Detected when both gemm inputs '
+        '      resolve (after walking through polygeist.submap) '
+        '      to the same underlying tensor. Routes to '
+        '      cublasSsyrk_v2 — half the flops, half the bandwidth.
      • '
+        '  
    • @cublasGemmFor1x1Conv — distinguishes a 4-par+1-red '
+        '      contraction (K=1 conv after trivial-loop elimination) from the '
+        '      4-par+3-red K×K conv. Routes to cublasSgemmStridedBatched '
+        '      because cuDNN's K=1 path is generic / slow.
      • '
+        '  
    '
+        '  Pre-pass in the lowering elides redundant memset_zero_2D '
+        '  launches that precede a syrk_alias (since syrk uses β=0). '
+        '  resolveSubmapBase now walks through both '
+        '  polygeist.submap and polygeist.submapInverse, '
+        '  chaining up to 16 hops — needed to handle the nested chains the '
+        '  pre-init memset leaves behind.'
+        '
    '
+        + table
+        # Headline call-out.
+        + '
    '
+          '  Speedup headlines (LARGE on Jetson Orin):'
+          '  
      '
+          '  
    • conv + bias + relu + residual-add — 23× (closes '
+          '      the standalone shortcut-add GPU loss; bandwidth-bound bn '
+          '      effectively rides free on the conv)
      • '
+          '  
    • gemm + bias + relu — 901× (cublasLt epilogue + '
+          '      tensor cores on 2048³ FP32; CPU 3-loop is cache-hostile)
      • '
+          '  
    • AᵀA → cublasSsyrk — 3393× (half the flops + clean '
+          '      tensor-core dispatch + cache-hostile CPU pattern)
      • '
+          '  
    • 1×1 conv → cublasSgemmStridedBatched — 105× '
+          '      (bypasses cuDNN's generic K=1 path; gets tensor cores '
+          '      via the per-batch gemm)
      • '
+          '  
    '
+          '
    '
+    )
+
+
+def _extracted_darknet_section(ex_darknet_stats: dict[str, dict]) -> str:
+    """5 batched CNN-block primitives extracted from darknet, raised
+    through the full Polygeist pipeline, matched to cuDNN library
+    symbols, ABI-lowered, cross-compiled, run on the Jetson Orin
+    silicon. Each kernel gets a Compiler Explorer deep-link (clickable
+    name) + an IR-preview page (the [IR preview] link)."""
+    rows = []
+    for k, entries in EXTRACTED_DARKNET_RUNTIMES.items():
+        first = True
+        rowspan = len(entries)
+        stats = ex_darknet_stats.get(k, {})
+        # Kernel-name cell on the first row carries the CE deep-link +
+        # an [IR preview] page link, mirroring the polybench / darknet
+        # row layout. CE URL & per-kernel page are produced by
+        # build_kernel_page → returns ce_url + page_filename.
+        if stats.get("ce_url"):
+            kernel_link = (
+                f''
+                f'{k}'
+            )
+        else:
+            kernel_link = f'{k}'
+        ir_link = (
+            f'[IR preview]'
+            if stats.get("page_filename") else ""
+        )
+        # Per-kernel match stats — same shape the other sections use.
+        l = stats.get("launches", 0)
+        r = stats.get("residual", 0)
+        fcount = stats.get("residual_for", 0)
+        match_status = ("FULL" if l > 0 and r == 0 and fcount == 0 else
+                        "PARTIAL" if l > 0 else "NONE")
+        match_cls = ("pass" if match_status == "FULL" else
+                     "partial" if match_status == "PARTIAL" else "none")
+        for e in entries:
+            size, shape = e["size"], e["shape"]
+            gpu, cpu = e["gpu_s"], e["cpu_s"]
+            speedup = cpu / gpu if gpu > 0 else 0.0
+            su_cls = ("pass" if speedup >= 2.0
+                      else "partial" if speedup >= 0.8
+                      else "none")
+            cmark = {"PASS": "✓", "FP-noise": "≈",
+                     "DIFF": "✗"}.get(e["correct"], "?")
+            note = e.get("notes", "")
+            if first:
+                kernel_cell = (
+                    f''
+                    f'{kernel_link}{ir_link}'
+                    f'
    '
+                    f'  matcher: '
+                    f'{match_status} ({l} launch,'
+                    f' {r} residual lg, {fcount} loops)'
+                    f'
    '
+                )
+            else:
+                kernel_cell = ""
+            first = False
+            rows.append(
+                ""
+                + kernel_cell
+                + f'{size}'
+                + f'{shape}'
+                + f'{_fmt_seconds(gpu)}'
+                + f'{_fmt_seconds(cpu)}'
+                + f''
+                + f'{speedup:.2f}× {cmark}'
+                + f'{note}'
+                + "")
+    table = (
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        ''
+        + "\n".join(rows) +
+        '
    kerneldatasetshapeGPU (cuDNN)CPU (3-loop)GPU speedupnotes
    '
+        # Fusion punchline — make the "ride free" insight crisp.
+        '
    '
+        '  Fusion punchline. Sum the three standalone LARGE '
+        '  GPU launches as if you ran them back-to-back '
+        '  (conv2d_batched 137.0 ms + batchnorm_batched 11.3 ms + '
+        '  one cudnnAddTensor-shaped ReLU ≈ 50 ms ≈ '
+        '  ~198 ms) vs the fused '
+        '  conv_bn_relu_batched LARGE at '
+        '  137.8 ms. Same conv work, but with bn + relu '
+        '  absorbed into the conv's compute-bound memory pass — '
+        '  the bandwidth-bound ops effectively cost zero. On the CPU '
+        '  side the two are within 0.5% of each other (3260 vs 3244 ms) '
+        '  because the CPU never paid per-call setup in the first place; '
+        '  the GPU's gain comes entirely from collapsing 3 cuDNN '
+        '  descriptor / algo-select / sync rounds into 1.'
+        '
    '
+        # Numeric agreement (FP-noise) callout.
+        '
    '
+        '  FP-noise comparison. Tensor-core kernels reorder the '
+        '  accumulation; CPU 3-loop accumulates in natural order. '
+        '  Dumps printed at %0.4f:'
+        '  
      '
+        '  
    • conv2d_batched LARGE: 0% bit-exact, max|d| = '
+        '      7.9e-3, mean|d| = 6.8e-3, max relative = 6.5e-5. Every '
+        '      output drifts by ~7 ULPs at print precision because 576 '
+        '      muladds per output (IC=64 × K²=9) make the '
+        '      accumulation-order drift visible.
      • '
+        '  
    • conv_bn_relu_batched LARGE: '
+        '      75% bit-exact, max|d| = 3.4e-3, mean|d| = 1.4e-4. '
+        '      Better than conv alone — BN's per-channel '
+        '      normalization scales drifts down, ReLU zeros 73% of '
+        '      outputs (zero is exactly representable). Of the remaining '
+        '      27% live outputs only 3.7% exceed |d| > 1e-3.
      • '
+        '  
    • maxpool_batched, shortcut_batched: '
+        '      100% bit-exact at all sizes. Max + plain add are '
+        '      order-independent.
      • '
+        '  
    • batchnorm_batched LARGE: 99.9% bit-exact, '
+        '      max|d| = 1e-4 (one print-precision ULP) on 0.1% of elems.
      • '
+        '  
    '
+        '
    '
+    )
+    return (
+        '
    '
+        '  
    extracted darknet '
+        '  (matcher + cuDNN runtime, Jetson Orin silicon)
    '
+        '
    '
+        '
    '
+        '  Four batched CNN-block primitives extracted as polybench-style '
+        '  single-file .c kernels in '
+        '  third_party/cnn-extracted/: conv2d_batched, '
+        '  maxpool_batched, batchnorm_batched, '
+        '  shortcut_batched. Together they cover every primitive '
+        '  in a ResNet residual block except ReLU.'
+        '  

    '
+        '  Each kernel goes through the full Polygeist pipeline: cgeist '
+        '  → --raise-affine-to-linalg-pipeline → '
+        '  --linalg-debufferize → '
+        '  kernel_match_rewrite.py → '
+        '  --lower-kernel-launch-to-cublas (resolves '
+        '  polygeist.submap operands back to their base 4D '
+        '  tensors, emits func.call to the runtime shim) '
+        '  → aarch64 cross-compile against libcudnn.so.9 '
+        '  → ship to Jetson Orin → run. Numbers below are wall-'
+        '  clock for a single shim call including cudaHostRegister '
+        '  mapping + the cuDNN forward call + a final stream sync.'
+        '  

    '
+        '  Matched launch symbols (one per row in the table, '
+        '  ordered longest-composition first in composition_library()):'
+        '  
      '
+        '  
    • @cudnnConvBnReluFwdFused — 4-step: init zero + '
+        '      conv contraction (4 par + 3 red) + bn in-place (4 par, 4 ins) + '
+        '      relu in-place. Lowers to one '
+        '      cudnnConvolutionBiasActivationForward with '
+        '      CUDNN_ACTIVATION_RELU after host-side BN-folding '
+        '      (F'[oc] = F[oc] * scale[oc] * inv_std[oc], '
+        '      b'[oc] = bias[oc] - scale[oc] * mean[oc] * inv_std[oc]).
      • '
+        '  
    • @cudnnConvolutionFwd_batched — 2-step: init zero + 7-iter '
+        '      contraction. Lowers to cudnnConvolutionForward.
      • '
+        '  
    • @cudnnMaxPoolFwd_batched — 2-step: init -INF + max-reduce. '
+        '      Lowers to cudnnPoolingForward.
      • '
+        '  
    • @cudnnBatchNormalizationForwardInference — 1-step elementwise '
+        '      (5 ins, 4 par, 0 red). Lowers to '
+        '      cudnnBatchNormalizationForwardInference with variance '
+        '      derived from inv_std + eps.
      • '
+        '  
    • @cudnnAddTensor_batched — 1-step Out + In(0). '
+        '      Lowers to cudnnAddTensor with α=β=1.
      • '
+        '  
    '
+        '  

    '
+        '  The headline win is 23.8× for conv2d_batched LARGE — '
+        '  cuDNN's tensor-core kernels shred a 32×64×56² '
+        '  ResNet conv where the CPU 3-loop reference takes 3.3 s. The '
+        '  bandwidth-bound elementwise kernels (batchnorm, shortcut) lose '
+        '  to the CPU at single-call granularity — the cuDNN setup overhead '
+        '  doesn't amortize without device-residency hoisting (the '
+        '  documented Phase-2 follow-up in '
+        '  project-phase2-cublas-abi-lowering).'
+        '  

    '
+        '  The last row, conv_bn_relu_batched, is the operator-'
+        '  fusion follow-up: a kernel that chains conv + bn-inference + '
+        '  relu (canonical ResNet inner pattern) and a matcher 4-step '
+        '  composition cudnnConvBnReluFwdFused that folds '
+        '  all four loop nests (init + conv + bn-inplace + relu-inplace) '
+        '  into one launch. The runtime shim applies the standard '
+        '  "BN-folding" trick — pre-multiplying the filter by '
+        '  scale * inv_std and adjusting the bias — then '
+        '  issues a single cudnnConvolutionBiasActivationForward '
+        '  call. Result: 137.8 ms LARGE (essentially the same as conv2d_'
+        '  batched alone), but doing all three operations. The bandwidth-'
+        '  bound bn and relu effectively become free; they ride the conv's '
+        '  compute-bound memory pass.'
+        '  

    '
+        '  Correctness key: ✓ PASS = bit-'
+        '  exact match with the CPU stub (maxpool, shortcut are integer-'
+        '  like ops); ≈ FP-noise = '
+        '  cuDNN tensor-core accumulation order differs from CPU naive '
+        '  order at the third decimal (expected, not a correctness bug).'
+        '
    '
+        + table
+    )
+
+
+def build_site_pages(polybench_stats: dict[str, dict],
+                     aten_stats: dict[str, dict],
+                     mfem_stats: list[dict],
+                     mfem_application_stats: list[dict],
+                     mfem_application_extraction_stats: list[dict],
+                     llama_forward_stats: dict[str, dict],
+                     whisper_ops_stats: dict[str, dict],
+                     stencil_conv2d_stats: dict[str, dict],
+                     llmc_stats: dict[str, dict],
+                     darknet_stats: dict[str, dict],
+                     ex_darknet_stats: dict[str, dict],
+                     fopt_stats: dict[str, dict]) -> dict[str, str]:
+    common_legend = (
+        '  Click a kernel name to open its static raised / debuferized / '
+        '  matcher-rewritten IR snapshot. Each snapshot has an '
+        '  open in Compiler Explorer link containing the full C and '
+        '  MLIR source; keeping those large URLs off this suite page makes '
+        '  the tracker load quickly.'
+        '  The residual for-loops column counts imperative-loop ops '
+        '  (affine.for, scf.for, '
+        '  scf.while, affine.parallel, '
+        '  scf.parallel) still present after raise + lower-submap '
+        '  + debuferize — a measure of how much of the kernel remains '
+        '  imperative rather than expressed as linalg / kernel.launch.'
+        '  The blocker column links to the '
+        '  algorithm taxonomy: yellow tags are '
+        '  fixable pipeline gaps, red tags are fundamental cross-iteration '
+        '  dependencies that no transformation can remove.'
+        '  The parallelism column classifies the kernel by its GPU '
+        '  suitability: highly parallel '
+        '  (every iter independent), parallel + T '
+        '  loop (body parallel, outer time loop serial — stencils), '
+        '  partial parallel (mixes '
+        '  reductions / serial steps), serial '
+        '  (cross-iter dependencies, poor naive GPU fit — factorizations, '
+        '  recurrences, DPs).'
+        '  Runtime columns compare warmed raised-pipeline runtime timings '
+        '  against handwritten PolyBenchGPU CUDA timings where available; '
+        '  CPU comparison is intentionally hidden for now.'
+    )
+
+    polybench_section = _build_section(
+        title="PolyBench/C 4.2.1",
+        anchor="polybench",
+        blurb=(
+            "30 numerical kernels from the PolyBench/C 4.2.1 benchmark — "
+            "dense linear algebra, stencils, and data-mining bodies. " +
+            common_legend
+        ),
+        kernel_stats=polybench_stats,
+        notes=KERNEL_NOTES,
+        blockers=POLYBENCH_BLOCKERS,
+        runtimes=POLYBENCHGPU_RUNTIMES,
+    )
+    llama_forward_section = _build_section(
+        title="Llama forward fixtures (raised C benchmarks)",
+        anchor="llama-forward",
+        blurb=(
+            "Source-level C fixtures in third_party/cnn-extracted "
+            "covering the pieces of a one-token Llama decode step. The rows "
+            "below include the individual kernels used in the op sweep plus "
+            "extended_forward, the fuller one-token, one-layer "
+            "benchmark that combines token embedding, attention RMSNorm, "
+            "Q/K/V projections, split RoPE, KV cache read/write, attention "
+            "scores + softmax, attention value matvec, output projection, "
+            "residuals, FFN RMSNorm, gate/up/down projections, SwiGLU, final "
+            "RMSNorm, and lm_head logits. Each row has a Compiler Explorer "
+            "deep-link and an IR preview for the C benchmark we are raising."
+        ),
+        kernel_stats=llama_forward_stats,
+        notes=LLAMA_FORWARD_NOTES,
+        blockers=LLAMA_FORWARD_BLOCKERS,
+        extra_html=_llama_forward_runtime_summary(),
+        runtimes=LLAMA_FORWARD_RUNTIMES,
+        display_names=LLAMA_FORWARD_DISPLAY_NAMES,
+        order=LLAMA_FORWARD_ORDER,
+        runtime_headers=(
+            "Jetson
    case",
+            "Raised pipeline
    (rt-gpu)",
+            "Reference
    CUDA",
+            "comparison",
+            "notes",
+        ),
+    )
+    whisper_ops_section = _build_section(
+        title="Whisper extracted kernels (raised C fixtures)",
+        anchor="whisper-ops",
+        blurb=(
+            "Source-level C fixtures in third_party/cnn-extracted/"
+            "whisper_ops.c covering representative Whisper/ggml "
+            "inference compute bodies: vector dot, softmax, RMSNorm-style "
+            "normalization, GELU, and encoder-side 1D convolution. These rows "
+            "are intentionally the exposed kernel bodies, not full "
+            "ggml_tensor framework functions; they show which "
+            "algorithmic kernels the linalg raising path can express once the "
+            "framework metadata, SIMD dispatch, and helper-call scaffolding "
+            "are isolated."
+        ),
+        kernel_stats=whisper_ops_stats,
+        notes=WHISPER_OPS_NOTES,
+        blockers=WHISPER_OPS_BLOCKERS,
+        display_names=WHISPER_OPS_DISPLAY_NAMES,
+        order=WHISPER_OPS_ORDER,
+        runtime_headers=(
+            "case",
+            "raised pipeline",
+            "reference",
+            "comparison",
+            "notes",
+        ),
+    )
+    stencil_conv2d_section = _build_section(
+        title="Stencil Conv2D fixtures (cuDNN tensor ntap target)",
+        anchor="stencil-conv2d",
+        blurb=(
+            "Image-processing and finite-difference stencil fixtures written "
+            "as plain C neighbourhood expressions. The debufferized tensor "
+            "forms raise to one loop-free linalg.generic and match the "
+            "generalized packed-weight "
+            "@cudnnConvolution2D_ntap_f32_tensor route. The "
+            "legacy memref 9/25-tap entries remain available for explicit "
+            "no-debufferize runs. Each row links to Compiler Explorer and an "
+            "IR preview for the raised C fixture."
+        ),
+        kernel_stats=stencil_conv2d_stats,
+        notes=STENCIL_CONV2D_NOTES,
+        blockers=STENCIL_CONV2D_BLOCKERS,
+        runtimes=STENCIL_CONV2D_RUNTIMES,
+        display_names=STENCIL_CONV2D_DISPLAY_NAMES,
+        order=STENCIL_CONV2D_ORDER,
+        runtime_headers=(
+            "Jetson
    case",
+            "Raised pipeline
    (cuDNN)",
+            "Target
    library",
+            "comparison",
+            "notes",
+        ),
+    )
+    llmc_section = _build_section(
+        title="llm.c (karpathy/llm.c — GPT-2 in C, forward + backward)",
+        anchor="llmc",
+        blurb=(
+            "15 leaf kernels from train_gpt2.c — the full GPT-2 building "
+            "blocks for both inference and training: encoder, layernorm, "
+            "matmul, attention, gelu, residual, softmax, crossentropy "
+            "(forward + backward where it applies). This is a related C LLM "
+            "suite with wider coverage. It stresses the pipeline "
+            "in new ways: indirect-index lookups (encoder), math.h ext-call "
+            "bodies (gelu/crossentropy via tanhf/logf), full scaled-dot "
+            "attention (4 fused generics including softmax-shaped reductions), "
+            "and the layernorm dominance issue in both debuf paths. The "
+            "matmul_forward_naive reference is used instead of "
+            "the tiled matmul_forward."
+        ),
+        kernel_stats=llmc_stats,
+        notes=LLMC_NOTES,
+        blockers=LLMC_BLOCKERS,
+    )
+    darknet_section = _build_section(
+        title="darknet (pjreddie/darknet — full source bake)",
+        anchor="darknet",
+        blurb=(
+            "Empirical "matcher coverage survey" over all 46 .c "
+            "files in third_party/darknet/src/. cgeist baked "
+            "with --function=* and inlining enabled; "
+            "every file's debuferized output ran through the matcher. "
+            "

    "
+            "Outcome (matches my earlier prediction of ~2% hit rate): "
+            "1 file matches (gemm.c, 6 kernel.launch "
+            "across gemm_nn/nt/tn/tt + gemm_bin variants). The rest splits "
+            "into three buckets:"
+            "
      18 raise-OK with 0 matches — produced "
+            "linalg.generic but the matcher's template library has no "
+            "entries for pooling, batchnorm, LRN, residual-add, RNN gates, "
+            "transposed conv, locally-connected layers, dense+bias, etc. "
+            "This is the actionable list: each is a matcher template "
+            "we could add to expand CNN coverage."
+            "
      5 raise-failed — cgeist OK but the "
+            "raise pass chokes (batchnorm_layer, convolutional_layer, box, "
+            "demo, tree). convolutional_layer.c is the painful one because "
+            "its body is mostly external-call dispatch (to im2col_cpu + "
+            "gemm); the actual gemm work lives in gemm.c which "
+            "does match."
+            "
      17 cgeist-failed — framework code "
+            "(parser, network, image, data, list, utils, ...) plus a few "
+            "layers with IfStmt lowering or function-pointer-dispatch "
+            "patterns cgeist can't handle. Most of these don't have "
+            "matchable compute anyway."
+            "

    "
+            "darknet's actual hot path uses gemm_nn (TA=TB=0). "
+            "The matcher hits it as @cublasDaxpy (the inner "
+            "loop has a scalar-hoisted axpy shape) but doesn't compose the "
+            "outer two loops back into gemm. gemm_nt and "
+            "gemm_tt use the conventional sum-accumulator form "
+            "and match as @cublasDgemm_alpha_only cleanly. "
+            "Fixing the gemm_nn composition is a high-value matcher "
+            "improvement target — it would auto-cover every conv layer "
+            "darknet runs at inference time."
+        ),
+        kernel_stats=darknet_stats,
+        notes=DARKNET_NOTES,
+        blockers=DARKNET_BLOCKERS,
+    )
+
+    def nav() -> str:
+        return (
+            '
    '
+            'Polygeist IR explorer
    '
+            '
    '
+            'Overview · '
+            'PolyBench · '
+            'ATen · '
+            'Performance analysis · '
+            'MFEM · '
+            'AI kernels · '
+            'Vision + fusion · '
+            'PVA backend'
+            '
    '
+        )
+
+    def card(href: str, title: str, count: int, description: str) -> str:
+        return (
+            f''
+            f'{title}{count} tracked rows'
+            f'{description}'
+        )
+
+    extra_css = (
+        '.section-header { background: #eaeefa; padding: 8px 20px; '
+        'border-top: 2px solid #c4cce0; border-bottom: 1px solid #c4cce0; '
+        'margin-top: 24px; } '
+        '.section-title { margin: 0; font-size: 16px; color: #1f2d3d; } '
+        '.suite-grid { display:grid; grid-template-columns:repeat(auto-fit, '
+        'minmax(240px,1fr)); gap:14px; padding:18px 20px; max-width:1100px; } '
+        '.suite-card { border:1px solid #d8dee8; border-radius:8px; padding:16px; '
+        'text-decoration:none; color:#1f2d3d; background:#fafbfc; } '
+        '.suite-card:hover { border-color:#7b91bd; background:#f3f6fc; } '
+        '.suite-card b,.suite-card span,.suite-card small { display:block; } '
+        '.suite-card span { color:#1a7f37; margin-top:5px; font-size:13px; } '
+        '.suite-card small { color:#555; margin-top:8px; line-height:1.35; } '
+        '.cause-tag { display:inline-block; border-radius:10px; padding:2px 7px; '
+        'font-size:11px; font-weight:bold; margin-bottom:4px; } '
+        '.cause-memory { background:#ffd9d9; color:#8b1a1a; } '
+        '.cause-host { background:#eadcff; color:#53258a; } '
+        '.cause-copy { background:#dcecff; color:#174f86; } '
+        '.cause-intensity { background:#ffe8c7; color:#7a4300; } '
+        '.cause-setup { background:#fff3bd; color:#705900; } '
+        '.cause-bandwidth { background:#ffe0ec; color:#842347; } '
+        '.cause-amortized { background:#dff5e5; color:#1a6a34; }'
+    )
+
+    landing = (
+        nav()
+        + '
    Raising and library-matching tracker. '
+          'The explorer is split into focused pages so the large Compiler '
+          'Explorer deep-links are loaded only for the suite being inspected. '
+          'Each kernel still has a static IR preview and a full CE link.
    '
+        + '
    '
+        + card("polybench.html", "PolyBench/C", len(polybench_stats),
+               "Dense linear algebra, stencils, and data-mining kernels.")
+        + card("numerical.html", "ATen numerical kernels", len(aten_stats),
+               "Extracted ATen C algorithms and Jetson comparisons.")
+        + card("performance.html", "Why are some kernels slow?",
+               sum(row.get("correctness") == "PASS"
+                   for row in _read_csv(ATEN_SILICON_RESULTS)),
+               "Root-cause groups, highlighted slowdown ratios, and a GEMV deep dive.")
+        + card("mfem.html", "MFEM finite elements",
+               len(mfem_stats) + len(mfem_application_stats)
+               + len(mfem_application_extraction_stats),
+               "Original/normalized FEM kernels and larger application hot paths.")
+        + card("ai.html", "AI kernels",
+               len(llama_forward_stats) + len(whisper_ops_stats) + len(llmc_stats),
+               "Llama forward, Whisper/ggml, and llm.c forward/backward kernels.")
+        + card("vision.html", "Vision + fusion",
+               len(stencil_conv2d_stats) + len(darknet_stats)
+               + len(ex_darknet_stats) + len(fopt_stats),
+               "Stencil Conv2D, darknet, extracted CNN blocks, and fusion experiments.")
+        + card("pva.html", "PVA backend", len(PVA_KERNELS),
+               "PVA lowering coverage and executable backend experiments.")
+        + '
    '
+        + _build_taxonomy_panel()
+    )
+    polybench = nav() + polybench_section
+    performance = nav() + _aten_slowness_page(aten_stats)
+    numerical_pages: dict[str, str] = {}
+    for sort_by in ("alphabetical", "correctness"):
+        ordered = _aten_sorted_kernels(sort_by)
+        page_count = max(1, (len(ordered) + ATEN_PAGE_SIZE - 1) // ATEN_PAGE_SIZE)
+        for page in range(1, page_count + 1):
+            begin = (page - 1) * ATEN_PAGE_SIZE
+            subset = ordered[begin:begin + ATEN_PAGE_SIZE]
+            filename = _aten_page_filename(sort_by, page)
+            numerical_pages[filename] = render_html(
+                "Polygeist: ATen numerical kernels",
+                nav() + _aten_section(
+                    aten_stats, subset, sort_by, page, page_count
+                ),
+                extra_css,
+            )
+    mfem = (nav()
+            + _mfem_application_extraction_section(
+                mfem_application_extraction_stats
+            )
+            + _mfem_application_section(mfem_application_stats)
+            + _mfem_section(mfem_stats))
+    ai = nav() + llama_forward_section + whisper_ops_section + llmc_section
+    vision = (
+        nav() + stencil_conv2d_section + darknet_section
+        + _extracted_darknet_section(ex_darknet_stats)
+        + _fusion_opt_section(fopt_stats)
+    )
+    pva = nav() + _pva_section()
+    pages = {
+        "index.html": render_html("Polygeist IR explorer", landing, extra_css),
+        "polybench.html": render_html(
+            "Polygeist: PolyBench/C", polybench, extra_css
+        ),
+        "performance.html": render_html(
+            "Polygeist: kernel slowness analysis", performance, extra_css
+        ),
+        "mfem.html": render_html("Polygeist: MFEM kernels", mfem, extra_css),
+        "ai.html": render_html("Polygeist: AI kernels", ai, extra_css),
+        "vision.html": render_html(
+            "Polygeist: vision + fusion", vision, extra_css
+        ),
+        "pva.html": render_html("Polygeist: PVA backend", pva, extra_css),
+    }
+    pages.update(numerical_pages)
+    return pages
+
+
+def main():
+    mfem_only = "--mfem-only" in sys.argv[1:]
+    aten_only = "--aten-only" in sys.argv[1:]
+    polybench_only = "--polybench-only" in sys.argv[1:]
+    unknown_args = [
+        arg for arg in sys.argv[1:]
+        if arg not in ("--mfem-only", "--aten-only", "--polybench-only")
+    ]
+    if unknown_args:
+        raise SystemExit(f"unknown argument(s): {' '.join(unknown_args)}")
+    if sum((mfem_only, aten_only, polybench_only)) > 1:
+        raise SystemExit("suite-only arguments are mutually exclusive")
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    if mfem_only:
+        for stale in OUTPUT_DIR.glob("mfem_*.html"):
+            stale.unlink()
+        print("Rendering MFEM original and normalized kernels...", flush=True)
+        mfem_stats = build_mfem_pages()
+        mfem_application_stats = build_mfem_application_pages()
+        mfem_application_extraction_stats = (
+            build_mfem_application_extraction_pages()
+        )
+        pages = build_site_pages(
+            {}, {}, mfem_stats, mfem_application_stats,
+            mfem_application_extraction_stats, {}, {}, {}, {}, {}, {}, {},
+        )
+        OUTPUT_DIR.joinpath("mfem.html").write_text(pages["mfem.html"])
+        print(
+            f"  [MFEM] rendered {len(mfem_stats)} kernels and "
+            f"{len(mfem_application_stats)} application ports and "
+            f"{len(mfem_application_extraction_stats)} larger application paths",
+            flush=True,
+        )
+        print(f"Done. Open {OUTPUT_DIR}/mfem.html.")
+        return
+    if aten_only:
+        for stale in OUTPUT_DIR.glob("aten_*.html"):
+            stale.unlink()
+        aten_stats = {}
+        print(f"Rendering {len(ATEN_C_ORDER)} ATen C kernels...", flush=True)
+        for i, kernel in enumerate(ATEN_C_ORDER, 1):
+            print(
+                f"  [ATEN {i:2d}/{len(ATEN_C_ORDER)}] {kernel}",
+                flush=True,
+            )
+            has_any = any(
+                (ATEN_C_MLIR_DIR / f"{kernel}{suffix}").exists()
+                for suffix in (".mlir", "_linalg.mlir", "_debuf.mlir")
+            )
+            if not has_any:
+                aten_stats[kernel] = {
+                    "launches": 0, "linalg_ops": 0, "matched_symbols": [],
+                    "residual": 0, "residual_for": 0, "ce_url": None,
+                    "page_filename": "",
+                }
+                continue
+            aten_stats[kernel] = build_kernel_page(
+                kernel, mlir_dir=ATEN_C_MLIR_DIR,
+                kset="aten_c", file_prefix="",
+            )
+        build_aten_c_source_pages(aten_stats)
+        pages = build_site_pages(
+            {}, aten_stats, [], [], [], {}, {}, {}, {}, {}, {}, {},
+        )
+        for filename, page_html in pages.items():
+            if filename.startswith("numerical") or filename == "performance.html":
+                OUTPUT_DIR.joinpath(filename).write_text(page_html)
+        print(f"Done. Open {OUTPUT_DIR}/numerical.html.")
+        return
+    if polybench_only:
+        polybench_kernels = discover_kernels(MLIR_DIR)
+        polybench_stats = {}
+        print(
+            f"Rendering {len(polybench_kernels)} PolyBench kernels...",
+            flush=True,
+        )
+        for i, kernel in enumerate(polybench_kernels, 1):
+            print(
+                f"  [PB {i:2d}/{len(polybench_kernels)}] {kernel}",
+                flush=True,
+            )
+            polybench_stats[kernel] = build_kernel_page(
+                kernel, mlir_dir=MLIR_DIR,
+                kset="polybench", file_prefix="",
+            )
+        pages = build_site_pages(
+            polybench_stats, {}, [], [], [], {}, {}, {}, {}, {}, {}, {},
+        )
+        OUTPUT_DIR.joinpath("polybench.html").write_text(
+            pages["polybench.html"]
+        )
+        print(f"Done. Open {OUTPUT_DIR}/polybench.html.")
+        return
+    for stale in OUTPUT_DIR.glob("llama_*.html"):
+        stale.unlink()
+    for stale in OUTPUT_DIR.glob("whisper_*.html"):
+        stale.unlink()
+    for stale in OUTPUT_DIR.glob("aten_*.html"):
+        stale.unlink()
+    for stale in OUTPUT_DIR.glob("mfem_*.html"):
+        stale.unlink()
+
+    # PolyBench set.
+    pb_kernels = discover_kernels(MLIR_DIR)
+    print(f"Rendering {len(pb_kernels)} PolyBench kernels...", flush=True)
+    pb_stats = {}
+    for i, k in enumerate(pb_kernels, 1):
+        print(f"  [PB {i:2d}/{len(pb_kernels)}] {k}", flush=True)
+        pb_stats[k] = build_kernel_page(k, mlir_dir=MLIR_DIR,
+                                         kset="polybench", file_prefix="")
+
+    # Standalone C extractions of representative ATen numerical kernels.
+    aten_stats = {}
+    print(f"Rendering {len(ATEN_C_ORDER)} ATen C kernels...", flush=True)
+    for i, k in enumerate(ATEN_C_ORDER, 1):
+        print(f"  [ATEN {i:2d}/{len(ATEN_C_ORDER)}] {k}", flush=True)
+        has_any = any((ATEN_C_MLIR_DIR / f"{k}{suf}").exists()
+                      for suf in (".mlir", "_linalg.mlir", "_debuf.mlir"))
+        if not has_any:
+            aten_stats[k] = {
+                "launches": 0, "linalg_ops": 0, "matched_symbols": [],
+                "residual": 0, "residual_for": 0, "ce_url": None,
+                "page_filename": "",
+            }
+            continue
+        aten_stats[k] = build_kernel_page(
+            k, mlir_dir=ATEN_C_MLIR_DIR, kset="aten_c", file_prefix="",
+        )
+    build_aten_c_source_pages(aten_stats)
+
+    # MFEM finite-element extractions use a manifest-driven artifact layout.
+    print("Rendering MFEM original and normalized kernels...", flush=True)
+    mfem_stats = build_mfem_pages()
+    print(f"  [MFEM] rendered {len(mfem_stats)} kernels", flush=True)
+    mfem_application_stats = build_mfem_application_pages()
+    print(
+        f"  [MFEM applications] rendered {len(mfem_application_stats)} ports",
+        flush=True,
+    )
+    mfem_application_extraction_stats = build_mfem_application_extraction_pages()
+    print(
+        "  [MFEM larger applications] rendered "
+        f"{len(mfem_application_extraction_stats)} paths",
+        flush=True,
+    )
+
+    # Llama forward fixtures extracted as C benchmarks.
+    llama_forward_kernels_from_files = discover_kernels(LLAMA_FORWARD_MLIR_DIR)
+    llama_forward_kernel_set = (
+        set(llama_forward_kernels_from_files) | set(LLAMA_FORWARD_KERNELS.keys())
+    )
+    llama_forward_kernels = [
+        k for k in LLAMA_FORWARD_ORDER if k in llama_forward_kernel_set
+    ]
+    llama_forward_kernels += sorted(
+        k for k in llama_forward_kernel_set if k not in set(LLAMA_FORWARD_ORDER)
+    )
+    print(f"Rendering {len(llama_forward_kernels)} Llama forward fixture kernels...", flush=True)
+    llama_forward_stats = {}
+    for i, k in enumerate(llama_forward_kernels, 1):
+        print(f"  [LLAMA-FWD {i:2d}/{len(llama_forward_kernels)}] {k}", flush=True)
+        has_any = any((LLAMA_FORWARD_MLIR_DIR / f"{k}{suf}").exists()
+                      for suf in (".mlir", "_linalg.mlir", "_debuf.mlir",
+                                   "_debuf_mr.mlir"))
+        if not has_any:
+            llama_forward_stats[k] = {"launches": 0, "residual": 0, "residual_for": 0,
+                                      "ce_url": None, "page_filename": ""}
+            continue
+        llama_forward_stats[k] = build_kernel_page(
+            k, mlir_dir=LLAMA_FORWARD_MLIR_DIR, kset="llama_forward",
+            file_prefix="llamafwd_",
+        )
+
+    # Whisper/ggml-style extracted operation fixtures.
+    whisper_ops_kernels_from_files = discover_kernels(WHISPER_OPS_MLIR_DIR)
+    whisper_ops_kernel_set = (
+        set(whisper_ops_kernels_from_files) | set(WHISPER_OPS_KERNELS.keys())
+    )
+    whisper_ops_kernels = [
+        k for k in WHISPER_OPS_ORDER if k in whisper_ops_kernel_set
+    ]
+    whisper_ops_kernels += sorted(
+        k for k in whisper_ops_kernel_set if k not in set(WHISPER_OPS_ORDER)
+    )
+    print(f"Rendering {len(whisper_ops_kernels)} Whisper extracted kernels...", flush=True)
+    whisper_ops_stats = {}
+    for i, k in enumerate(whisper_ops_kernels, 1):
+        print(f"  [WHISPER {i:2d}/{len(whisper_ops_kernels)}] {k}", flush=True)
+        has_any = any((WHISPER_OPS_MLIR_DIR / f"{k}{suf}").exists()
+                      for suf in (".mlir", "_linalg.mlir", "_debuf.mlir",
+                                   "_debuf_mr.mlir"))
+        if not has_any:
+            whisper_ops_stats[k] = {"launches": 0, "residual": 0,
+                                    "residual_for": 0, "ce_url": None,
+                                    "page_filename": ""}
+            continue
+        whisper_ops_stats[k] = build_kernel_page(
+            k, mlir_dir=WHISPER_OPS_MLIR_DIR, kset="whisper_ops",
+            file_prefix="",
+        )
+
+    # Non-DL stencil fixtures that map to cuDNN 3x3 convolution.
+    # This directory also contains scratch artifacts produced by the local
+    # smoke tests (`*_matched.mlir`, `*_lowered.mlir`). Keep the website to
+    # the explicit fixture list so those files do not become bogus rows.
+    stencil_conv2d_kernels = list(STENCIL_CONV2D_ORDER)
+    print(f"Rendering {len(stencil_conv2d_kernels)} stencil Conv2D kernels...", flush=True)
+    stencil_conv2d_stats = {}
+    for i, k in enumerate(stencil_conv2d_kernels, 1):
+        print(f"  [STENCIL-CONV2D {i:2d}/{len(stencil_conv2d_kernels)}] {k}", flush=True)
+        has_any = any((STENCIL_CONV2D_MLIR_DIR / f"{k}{suf}").exists()
+                      for suf in (".mlir", "_linalg.mlir", "_debuf.mlir",
+                                   "_debuf_mr.mlir"))
+        if not has_any:
+            stencil_conv2d_stats[k] = {"launches": 0, "residual": 0,
+                                       "residual_for": 0, "ce_url": None,
+                                       "page_filename": ""}
+            continue
+        stencil_conv2d_stats[k] = build_kernel_page(
+            k, mlir_dir=STENCIL_CONV2D_MLIR_DIR, kset="stencil_conv2d",
+            file_prefix="stencilconv_",
+        )
+
+    # llm.c set.
+    llmc_kernels_from_files = discover_kernels(LLMC_MLIR_DIR)
+    llmc_kernels = sorted(set(llmc_kernels_from_files) | set(LLMC_KERNELS.keys()))
+    print(f"Rendering {len(llmc_kernels)} llm.c kernels...", flush=True)
+    llmc_stats = {}
+    for i, k in enumerate(llmc_kernels, 1):
+        print(f"  [LLMC {i:2d}/{len(llmc_kernels)}] {k}", flush=True)
+        has_any = any((LLMC_MLIR_DIR / f"{k}{suf}").exists()
+                      for suf in (".mlir", "_linalg.mlir", "_debuf.mlir",
+                                   "_debuf_mr.mlir"))
+        if not has_any:
+            llmc_stats[k] = {"launches": 0, "residual": 0, "residual_for": 0,
+                              "ce_url": None, "page_filename": ""}
+            continue
+        llmc_stats[k] = build_kernel_page(
+            k, mlir_dir=LLMC_MLIR_DIR, kset="llmc",
+            file_prefix="llmc_",
+        )
+
+    # darknet (full-source bake). The kernel "name" is each .c file's
+    # basename; bake_darknet_mlir.sh emits .mlir + _linalg.mlir
+    # + _debuf.mlir using the same naming convention the explorer
+    # expects, so build_kernel_page reads them transparently.
+    darknet_kernels_from_files = discover_kernels(DARKNET_MLIR_DIR)
+    darknet_kernels = sorted(set(darknet_kernels_from_files) | set(DARKNET_KERNELS.keys()))
+    print(f"Rendering {len(darknet_kernels)} darknet kernels...", flush=True)
+    darknet_stats = {}
+    for i, k in enumerate(darknet_kernels, 1):
+        print(f"  [DARKNET {i:2d}/{len(darknet_kernels)}] {k}", flush=True)
+        has_any = any((DARKNET_MLIR_DIR / f"{k}{suf}").exists()
+                      for suf in (".mlir", "_linalg.mlir", "_debuf.mlir",
+                                   "_debuf_mr.mlir"))
+        if not has_any:
+            darknet_stats[k] = {"launches": 0, "residual": 0, "residual_for": 0,
+                                 "ce_url": None, "page_filename": ""}
+            continue
+        darknet_stats[k] = build_kernel_page(
+            k, mlir_dir=DARKNET_MLIR_DIR, kset="darknet",
+            file_prefix="darknet_",
+        )
+
+    # extracted-darknet (polybench-style CNN block kernels for the cuDNN
+    # runtime pipeline). Same per-kernel-page machinery as the other
+    # sections — bake_extracted_darknet_mlir.sh produces the per-stage
+    # MLIR files in /tmp/extracted_darknet_mlir/ that build_kernel_page
+    # consumes.
+    ex_darknet_kernels = sorted(EXTRACTED_DARKNET_KERNELS.keys())
+    print(f"Rendering {len(ex_darknet_kernels)} extracted-darknet kernels...", flush=True)
+    ex_darknet_stats = {}
+    for i, k in enumerate(ex_darknet_kernels, 1):
+        print(f"  [EXTRACTED-DARKNET {i:1d}/{len(ex_darknet_kernels)}] {k}", flush=True)
+        has_any = any((EXTRACTED_DARKNET_MLIR_DIR / f"{k}{suf}").exists()
+                      for suf in (".mlir", "_linalg.mlir", "_debuf.mlir"))
+        if not has_any:
+            ex_darknet_stats[k] = {"launches": 0, "residual": 0, "residual_for": 0,
+                                    "ce_url": None, "page_filename": ""}
+            continue
+        ex_darknet_stats[k] = build_kernel_page(
+            k, mlir_dir=EXTRACTED_DARKNET_MLIR_DIR, kset="extracted_darknet",
+            file_prefix="exdark_",
+        )
+
+    # Fusion-optimization kernels (algebraic rewrites: conv+bias+relu+add,
+    # gemm+bias+relu, AᵀA→syrk, 1×1 conv → batched gemm). Same per-stage
+    # MLIR bake pipeline as extracted_darknet.
+    fopt_kernel_list = sorted(FUSION_OPT_KERNELS.keys())
+    print(f"Rendering {len(fopt_kernel_list)} fusion-optimization kernels...", flush=True)
+    fopt_stats = {}
+    for i, k in enumerate(fopt_kernel_list, 1):
+        print(f"  [FUSION-OPT {i:1d}/{len(fopt_kernel_list)}] {k}", flush=True)
+        has_any = any((EXTRACTED_DARKNET_MLIR_DIR / f"{k}{suf}").exists()
+                      for suf in (".mlir", "_linalg.mlir", "_debuf.mlir"))
+        if not has_any:
+            fopt_stats[k] = {"launches": 0, "residual": 0, "residual_for": 0,
+                              "ce_url": None, "page_filename": ""}
+            continue
+        fopt_stats[k] = build_kernel_page(
+            k, mlir_dir=EXTRACTED_DARKNET_MLIR_DIR, kset="fusion_opt",
+            file_prefix="fopt_",
+        )
+
+    pages = build_site_pages(
+        pb_stats, aten_stats, mfem_stats, mfem_application_stats,
+        mfem_application_extraction_stats,
+        llama_forward_stats, whisper_ops_stats,
+        stencil_conv2d_stats, llmc_stats, darknet_stats, ex_darknet_stats,
+        fopt_stats,
+    )
+    for filename, html in pages.items():
+        OUTPUT_DIR.joinpath(filename).write_text(html)
+    print(f"\nWrote {len(pages)} explorer pages.")
+    print(f"Done. Open {OUTPUT_DIR}/index.html.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/correctness/build_ir_viewer.py b/scripts/correctness/build_ir_viewer.py
new file mode 100644
index 000000000000..0667d4ceff7e
--- /dev/null
+++ b/scripts/correctness/build_ir_viewer.py
@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""Render all PolyBench IR stages as a static-HTML browse-able site.
+
+For each kernel we expose:
+  1. raised-linalg (memref form, before debuferize)
+  2. debuferized (tensor form, the input to the matcher) — default v2 path
+  3. debuferized — multi-root (--linalg-debufferize=use-multi-root=true)
+  4. kernel-launches (the matcher's rewritten output)
+
+Plus an index page that links to all kernels and shows match stats.
+"""
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+from pygments import highlight
+from pygments.lexers import get_lexer_by_name
+from pygments.formatters import HtmlFormatter
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+
+
+def env_path(name: str, default: Path | str) -> Path:
+    return Path(os.environ.get(name, str(default)))
+
+
+POLYBENCH_DIR = env_path("POLYGEIST_POLYBENCH_MLIR_DIR", "/tmp/polybench_new")
+OUTPUT_DIR = env_path("POLYGEIST_IR_VIEWER_OUT", "/tmp/ir_viewer")
+REWRITER = env_path("POLYGEIST_KERNEL_MATCH_REWRITER", SCRIPT_DIR / "kernel_match_rewrite.py")
+PYTHON = os.environ.get("PYTHON", sys.executable)
+
+
+def discover_kernels() -> list[str]:
+    return sorted(
+        f.stem.replace("_debuf", "")
+        for f in POLYBENCH_DIR.glob("*_debuf.mlir")
+    )
+
+
+def render_html(title: str, body_html: str, css: str) -> str:
+    return f"""
+{title}
+
+{body_html}
+"""
+
+
+def syntax_highlight(text: str, lang: str = "llvm") -> tuple[str, str]:
+    text = re.sub(r"#dlti\.dl_spec<[^>]*>", "(dlti spec hidden)", text)
+    lexer = get_lexer_by_name(lang)
+    fmt = HtmlFormatter(style="monokai", nobackground=True)
+    return highlight(text, lexer, fmt), fmt.get_style_defs(".highlight")
+
+
+def run_rewriter(path: Path) -> tuple[str, list[tuple]]:
+    """Run the kernel-match rewriter on the file."""
+    res = subprocess.run(
+        [PYTHON, str(REWRITER), str(path)],
+        capture_output=True, text=True, timeout=120,
+    )
+    out = res.stdout
+    n_launch = len(re.findall(r"kernel\.launch", out))
+    n_lg = len(re.findall(r"linalg\.generic", out))
+    report = [("launches", n_launch), ("residual_lg", n_lg)]
+    return out, report
+
+
+def build_kernel_page(kernel: str) -> dict:
+    """Build all four stage pages plus return summary stats."""
+    raised = POLYBENCH_DIR / f"{kernel}_linalg.mlir"
+    debuf = POLYBENCH_DIR / f"{kernel}_debuf.mlir"
+    debuf_mr = POLYBENCH_DIR / f"{kernel}_debuf_mr.mlir"
+
+    pages: dict[str, str] = {}
+    css = ""
+
+    if raised.exists():
+        html, css = syntax_highlight(raised.read_text())
+        pages["raised"] = html
+    if debuf.exists():
+        html, css = syntax_highlight(debuf.read_text())
+        pages["debuf"] = html
+
+        rewritten, report = run_rewriter(debuf)
+        html, css = syntax_highlight(rewritten)
+        pages["matched"] = html
+    else:
+        report = [("launches", 0), ("residual_lg", 0)]
+    if debuf_mr.exists():
+        html, css = syntax_highlight(debuf_mr.read_text())
+        pages["debuf_mr"] = html
+
+    # Combine into one tabs page.
+    header = (
+        f'
    ← index '
+        f'  {kernel}
    '
+    )
+    tabs_html = '
    '
+    body_html_blocks = []
+    for stage, title in [
+        ("raised",   "raised (memref linalg)"),
+        ("debuf",    "debuferized (tensor linalg, matcher input)"),
+        ("debuf_mr", "debuferized — multi-root"),
+        ("matched",  "kernel.launch (matcher output)"),
+    ]:
+        if stage not in pages:
+            continue
+        anchor = stage
+        tabs_html += f'{title}'
+        body_html_blocks.append(
+            f'
    {title}
    '
+            f'
    {pages[stage]}
    '
+        )
+    tabs_html += '
    '
+    body = header + tabs_html + "\n".join(body_html_blocks)
+    OUTPUT_DIR.joinpath(f"{kernel}.html").write_text(render_html(kernel, body, css))
+
+    return {"launches": report[0][1], "residual": report[1][1]}
+
+
+def build_index(kernel_stats: dict[str, dict]) -> str:
+    rows = []
+    for k, s in sorted(kernel_stats.items()):
+        l = s["launches"]; r = s["residual"]
+        if l > 0 and r == 0:
+            cls = "pass"; status = "FULL"
+        elif l > 0:
+            cls = "partial"; status = "PARTIAL"
+        else:
+            cls = "none"; status = "NONE"
+        rows.append(f'{k}'
+                    f'{l}{r}'
+                    f'{status}')
+    body = (
+        '
    PolyBench IR explorer
    '
+        '
    '
+        '
    Click a kernel to inspect its raised / debuferized / kernel.launch IRs.
    '
+        ''
+        ''
+        '' + "\n".join(rows) + '
    kernelkernel.launchesresidual linalg.genericmatch status
    '
+    )
+    return render_html("PolyBench IR explorer", body, "")
+
+
+def main():
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    kernels = discover_kernels()
+    print(f"Rendering {len(kernels)} kernels into {OUTPUT_DIR}...", flush=True)
+    stats = {}
+    for i, k in enumerate(kernels, 1):
+        print(f"  [{i:2d}/{len(kernels)}] {k}", flush=True)
+        stats[k] = build_kernel_page(k)
+    OUTPUT_DIR.joinpath("index.html").write_text(build_index(stats))
+    print(f"\nDone. Open {OUTPUT_DIR}/index.html or serve {OUTPUT_DIR} via HTTP.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/correctness/build_jetson.sh b/scripts/correctness/build_jetson.sh
new file mode 100755
index 000000000000..78833db7e09e
--- /dev/null
+++ b/scripts/correctness/build_jetson.sh
@@ -0,0 +1,229 @@
+#!/bin/bash
+# build_jetson.sh — CROSS-COMPILE a kernel-matched MLIR program on this
+# x86_64 dev VM into an aarch64 ELF that runs on a Jetson Orin.
+#
+# The Jetson does NOT need Polygeist, MLIR, or nvcc — only the CUDA runtime
+# libraries that JetPack already installs at /usr/local/cuda/lib64.
+#
+# See runtime/CROSS_COMPILE.md for the toolchain inventory + why SBSA libs
+# work on L4T at runtime.
+#
+# Usage:
+#   ./build_jetson.sh   [ ...]
+#
+# Where  is the post-Phase-2 IR (already has func.call to
+# polygeist_cublas_*, no kernel.launch). Optional harness .c / .o files
+# get linked in alongside — pass the C wrapper / main / polybench glue
+# here. .c files are compiled with $HARNESS_CFLAGS (default -O3); .o
+# files are linked as-is (useful when harness needs project-specific
+# preprocessor defines like -DPOLYBENCH_USE_C99_PROTO that you've already
+# baked into a pre-built .o on the host).
+#
+# Output: aarch64-linux-gnu ELF with DT_NEEDED on libcublas.so.12 +
+# libcudart.so.12, RUNPATH=/usr/local/cuda/lib64.
+#
+# scp the binary to the Jetson and run:
+#   ./
+# Or profile with nsys (on the Jetson):
+#   nsys profile -o trace ./
+
+set -euo pipefail
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+if [ "$#" -lt 2 ]; then
+  echo "usage: $0   [ ...]" >&2
+  exit 1
+fi
+
+INPUT=$1
+OUT_EXE=$2
+shift 2
+HARNESS=("$@")
+OUT_DIR=$(dirname "$OUT_EXE")
+mkdir -p "$OUT_DIR"
+
+# Optional preprocessor / opt flags forwarded to .c harness compilation only.
+# Pre-built .o files are linked as-is. Use this for polybench-style defines.
+HARNESS_CFLAGS="${HARNESS_CFLAGS:--O3}"
+
+# Optional cuTensorNet cross package. NVIDIA's Python wheels use separate
+# cuquantum/ and cutensor/ roots, so callers may either provide the three
+# explicit directories or a common extraction root with that layout.
+CUTENSORNET_ROOT="${POLYGEIST_CUTENSORNET_ROOT:-}"
+CUTENSORNET_INC="${POLYGEIST_CUTENSORNET_INCLUDE:-}"
+CUTENSORNET_LIB="${POLYGEIST_CUTENSORNET_LIBDIR:-}"
+CUTENSOR_LIB="${POLYGEIST_CUTENSOR_LIBDIR:-}"
+if [ -n "$CUTENSORNET_ROOT" ]; then
+  CUTENSORNET_INC="${CUTENSORNET_INC:-$CUTENSORNET_ROOT/cuquantum/include}"
+  CUTENSORNET_LIB="${CUTENSORNET_LIB:-$CUTENSORNET_ROOT/cuquantum/lib}"
+  CUTENSOR_LIB="${CUTENSOR_LIB:-$CUTENSORNET_ROOT/cutensor/lib}"
+fi
+CUTENSORNET_ENABLED=0
+if [ -n "$CUTENSORNET_INC" ] || [ -n "$CUTENSORNET_LIB" ] || \
+   [ -n "$CUTENSOR_LIB" ]; then
+  for required in "$CUTENSORNET_INC/cutensornet.h" \
+                  "$CUTENSORNET_LIB/libcutensornet.so.2" \
+                  "$CUTENSOR_LIB/libcutensor.so.2"; do
+    [ -f "$required" ] || {
+      echo "ERROR: cuTensorNet cross-build input missing: $required" >&2
+      exit 1
+    }
+  done
+  CUTENSORNET_ENABLED=1
+fi
+
+# ─── Cross toolchain (host: x86_64; target: aarch64 + Jetson CUDA) ─────────
+# Override these via env vars if the cross-toolkit lives elsewhere.
+CUDA_CROSS_VER=${CUDA_CROSS_VER:-12.6}
+CUDA=${CUDA:-/usr/local/cuda-${CUDA_CROSS_VER}/targets/sbsa-linux}
+AARCH64_CC=${AARCH64_CC:-aarch64-linux-gnu-gcc}
+AARCH64_READELF=${AARCH64_READELF:-aarch64-linux-gnu-readelf}
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+MLIR_TRANSLATE=$REPO_ROOT/llvm-project/build/bin/mlir-translate
+POLYGEIST_OPT=$REPO_ROOT/build/bin/polygeist-opt
+CLANG=$REPO_ROOT/llvm-project/build/bin/clang
+RT=$REPO_ROOT/runtime
+
+# Sanity checks
+for tool in "$AARCH64_CC" "$AARCH64_READELF"; do
+  if ! command -v "$tool" >/dev/null 2>&1; then
+    echo "ERROR: $tool not on PATH. Install gcc-aarch64-linux-gnu." >&2
+    echo "       See runtime/CROSS_COMPILE.md." >&2
+    exit 1
+  fi
+done
+if [ ! -d "$CUDA/include" ] || [ ! -d "$CUDA/lib" ]; then
+  echo "ERROR: CUDA cross-toolkit not found at $CUDA" >&2
+  echo "       Install cuda-cudart-cross-sbsa-* + libcublas-cross-sbsa-* +" >&2
+  echo "       cuda-nvcc-cross-sbsa-* (for crt/ headers)." >&2
+  echo "       See runtime/CROSS_COMPILE.md." >&2
+  exit 1
+fi
+if [ ! -s "$INPUT" ]; then
+  echo "ERROR: input MLIR '$INPUT' is missing or empty" >&2
+  exit 1
+fi
+
+# Reject obviously-not-ABI-lowered input. Saves an obscure later failure.
+if grep -q '= kernel\.launch ' "$INPUT"; then
+  echo "ERROR: $INPUT still has kernel.launch ops — run" >&2
+  echo "       polygeist-opt --lower-kernel-launch-to-cublas first." >&2
+  exit 1
+fi
+
+WORK=$(mktemp -d)
+trap "rm -rf $WORK" EXIT
+
+echo "  [1/6] lower Polygeist views + canonicalise input MLIR"
+# Tensor-form matcher results can retain polygeist.submap/submapInverse around
+# an already ABI-lowered runtime call. Lower those repository-specific ops
+# before handing the module to upstream mlir-opt, which does not register the
+# Polygeist dialect.
+$POLYGEIST_OPT --lower-polygeist-submap "$INPUT" -o $WORK/no_submap.mlir
+# Mark to_tensor results as `restrict` so one-shot-bufferize keeps the
+# in-place semantics (same trick gemm_kernel_e2e.sh uses).
+sed 's|bufferization\.to_tensor \(%[^ ]*\) :|bufferization.to_tensor \1 restrict :|g' \
+    $WORK/no_submap.mlir > $WORK/abi.mlir
+
+echo "  [2/6] one-shot-bufferize + lower to LLVM dialect (host-side, on this VM)"
+$MLIR_OPT --one-shot-bufferize=bufferize-function-boundaries \
+  --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \
+  --convert-arith-to-llvm --finalize-memref-to-llvm \
+  --convert-func-to-llvm --reconcile-unrealized-casts \
+  $WORK/abi.mlir -o $WORK/llvm.mlir
+
+echo "  [3/6] translate to LLVM IR, then retarget x86 → aarch64"
+$MLIR_TRANSLATE --mlir-to-llvmir $WORK/llvm.mlir -o $WORK/kernel.ll
+# Rewrite the embedded target triple so clang doesn't think this is x86
+# when we feed it through with --target=aarch64. Drop the datalayout
+# line entirely; clang will re-derive an aarch64 layout.
+sed -i 's|target triple = "x86_64.*"|target triple = "aarch64-linux-gnu"|' \
+    $WORK/kernel.ll
+sed -i '/^target datalayout/d' $WORK/kernel.ll
+# `kernel_gemm` is what the polybench harness will call — rename so the
+# harness's own `kernel_gemm` (the C ref) doesn't collide.
+sed -i 's/@kernel_gemm\b/@kernel_gemm_impl/g' $WORK/kernel.ll
+
+echo "  [4/6] cross-compile .ll → aarch64 .o via Polygeist clang"
+$CLANG --target=aarch64-linux-gnu --gcc-toolchain=/usr \
+       -O3 -c $WORK/kernel.ll -o $WORK/kernel.o
+
+echo "  [5/6] cross-compile runtime shim + any harness .c files"
+# The shim now includes cuDNN for conv2d; cuDNN headers live in the
+# aarch64 cross-dev location, separate from CUDA's include path.
+CUDNN_INC=${CUDNN_INC:-/usr/include/aarch64-linux-gnu}
+CUDNN_LIB=${CUDNN_LIB:-/usr/lib/aarch64-linux-gnu}
+RT_EXTRA_CFLAGS=()
+RT_EXTRA_LIBS=()
+RT_LINK_FLAGS=()
+ACCEL_LIBS=(-lcudnn -lcublasLt -lcublas -lcufft -lcusparse -lcusolver)
+if [ "${POLYGEIST_MINIMAL_RUNTIME:-0}" != "0" ]; then
+  # Put every runtime entry point in its own ELF section and discard entries
+  # unreachable from this executable. This lets a cuTensorNet-only binary run
+  # on minimal JetPack images that do not install cuDNN/cuFFT.
+  RT_EXTRA_CFLAGS+=("-ffunction-sections" "-fdata-sections")
+  RT_LINK_FLAGS+=("-Wl,--gc-sections")
+  ACCEL_LIBS=(-lcublasLt -lcublas -lcusolver)
+  echo "       minimal runtime: dead-strip unused library shims"
+fi
+if [ "$CUTENSORNET_ENABLED" -eq 1 ]; then
+  RT_EXTRA_CFLAGS+=("-DPOLYGEIST_ENABLE_CUTENSORNET" "-I$CUTENSORNET_INC")
+  RT_EXTRA_LIBS+=("-L$CUTENSORNET_LIB" "-L$CUTENSOR_LIB"
+                 "-l:libcutensornet.so.2" "-l:libcutensor.so.2")
+  echo "       cuTensorNet: $CUTENSORNET_LIB"
+  echo "       cuTENSOR:    $CUTENSOR_LIB"
+fi
+$AARCH64_CC -O3 -I$CUDA/include -I$CUDNN_INC "${RT_EXTRA_CFLAGS[@]}" \
+            -c $RT/polygeist_cublas_rt_cuda.c -o $WORK/rt.o
+HARNESS_OBJS=()
+for item in "${HARNESS[@]}"; do
+  case "$item" in
+    *.c)
+      obj=$WORK/$(basename "$item" .c).o
+      echo "       harness (compile): $item → $(basename $obj)"
+      $AARCH64_CC $HARNESS_CFLAGS -c "$item" -o "$obj"
+      HARNESS_OBJS+=("$obj")
+      ;;
+    *.o)
+      echo "       harness (pre-built): $item"
+      HARNESS_OBJS+=("$item")
+      ;;
+    *)
+      echo "ERROR: harness arg must be .c or .o file: $item" >&2
+      exit 1
+      ;;
+  esac
+done
+
+echo "  [6/6] link against aarch64 cuBLAS + cudart stubs"
+# Stub libs live in $CUDA/lib (for libcudart) and $CUDA/lib/stubs (for
+# libcublas). Both are aarch64 ELF; the actual .so files resolve against
+# JetPack's installed CUDA at runtime via RUNPATH.
+$AARCH64_CC -O2 \
+    $WORK/kernel.o $WORK/rt.o "${HARNESS_OBJS[@]}" \
+    -L$CUDA/lib -L$CUDA/lib/stubs -L$CUDNN_LIB \
+    "${RT_EXTRA_LIBS[@]}" \
+    "${ACCEL_LIBS[@]}" -lcudart \
+    "${RT_LINK_FLAGS[@]}" \
+    -lm -lpthread -ldl \
+    '-Wl,-rpath,$ORIGIN:/usr/local/cuda/lib64:/usr/lib/aarch64-linux-gnu' \
+    -o "$OUT_EXE"
+
+echo ""
+echo "═══════════════════════════════════════════════════════════════════════"
+echo "Cross-build complete:"
+file "$OUT_EXE"
+echo ""
+echo "DT_NEEDED (must show libcublas.so.12 + libcudart.so.12):"
+$AARCH64_READELF -d "$OUT_EXE" | grep -E 'NEEDED|RUNPATH'
+echo ""
+echo "Binary size: $(stat -c '%s bytes' "$OUT_EXE")"
+echo ""
+echo "Ship to Jetson with:"
+echo "  scp '$OUT_EXE' nvidia@:/tmp/"
+echo "  ssh nvidia@ 'chmod +x /tmp/$(basename "$OUT_EXE") && /tmp/$(basename "$OUT_EXE")'"
+echo ""
+echo "Or profile on Jetson with nsys:"
+echo "  ssh nvidia@ 'nsys profile -o /tmp/trace /tmp/$(basename "$OUT_EXE")'"
+echo "═══════════════════════════════════════════════════════════════════════"
diff --git a/scripts/correctness/build_polybenchgpu_conv2d_jetson.sh b/scripts/correctness/build_polybenchgpu_conv2d_jetson.sh
new file mode 100755
index 000000000000..154eebbe9065
--- /dev/null
+++ b/scripts/correctness/build_polybenchgpu_conv2d_jetson.sh
@@ -0,0 +1,120 @@
+#!/bin/bash
+# build_polybenchgpu_conv2d_jetson.sh DATASET
+# Build polybenchGpu convolution-2d for one dataset, end-to-end for Jetson.
+# Matches as cudnnConvolution2D_9tap_f32 (polybenchGpu DATA_TYPE defaults to float).
+set -euo pipefail
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+DATASET=${1:?"need dataset MINI|SMALL|STANDARD|LARGE|EXTRALARGE"}
+
+PY=$PYTHON
+SCRIPTS=$REPO_ROOT/scripts/correctness
+RT=$REPO_ROOT/runtime
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+MLIR_TRANSLATE=$REPO_ROOT/llvm-project/build/bin/mlir-translate
+CLANG=$REPO_ROOT/llvm-project/build/bin/clang
+
+KDIR=$REPO_ROOT/third_party/polybenchGpu/OpenMP/stencils/convolution-2d
+UTIL=$REPO_ROOT/third_party/polybenchGpu/OpenMP/utilities
+SRC=$KDIR/convolution-2d.c
+FN=kernel_conv2d
+CUDA=/usr/local/cuda-12.6/targets/sbsa-linux
+CUDNN_INC=/usr/include/aarch64-linux-gnu
+CUDNN_LIB=/usr/lib/aarch64-linux-gnu
+
+OUT=/tmp/conv2d_pbgpu_jetson_build
+mkdir -p $OUT
+
+echo "[conv2d/$DATASET] (1) cgeist → affine MLIR (DATA_TYPE=float default)"
+cgeist $SRC --function='*' --no-inline --resource-dir=/usr/lib/clang/14 \
+   -I$UTIL -I$KDIR -D${DATASET}_DATASET -Dstatic= \
+   --raise-scf-to-affine -fPIC -S -o $OUT/${DATASET}_affine.mlir 2>$OUT/${DATASET}.cgeist.err
+[ -s $OUT/${DATASET}_affine.mlir ] || { echo "cgeist FAIL"; head -3 $OUT/${DATASET}.cgeist.err; exit 1; }
+
+echo "[conv2d/$DATASET] (2) raise + lower-submap (kernel only)"
+polygeist-opt --select-func="func-name=$FN" \
+    --remove-iter-args --affine-parallelize \
+    --raise-affine-to-linalg-pipeline --lower-polygeist-submap \
+    $OUT/${DATASET}_affine.mlir -o $OUT/${DATASET}_linalg.mlir 2>$OUT/${DATASET}.raise.err
+[ -s $OUT/${DATASET}_linalg.mlir ] || { echo "raise FAIL"; head -3 $OUT/${DATASET}.raise.err; exit 1; }
+
+echo "[conv2d/$DATASET] (3) matcher"
+$PY $SCRIPTS/kernel_match_rewrite.py $OUT/${DATASET}_linalg.mlir \
+    > $OUT/${DATASET}_matched.mlir 2>$OUT/${DATASET}.match.err
+N_LAUNCH=$(grep -c '@cudnnConvolution2D_9tap' $OUT/${DATASET}_matched.mlir || true)
+[ "${N_LAUNCH:-0}" -ge 1 ] || { echo "matcher FAIL — no cudnnConvolution2D_9tap"; exit 1; }
+echo "    $N_LAUNCH conv2d_9tap launch(es)"
+
+# Determine launch suffix (e.g. _f32). Use it for kernel.defn name + scalar type.
+SUFFIX=$(grep -oE '@cudnnConvolution2D_9tap_[a-z0-9]+' $OUT/${DATASET}_matched.mlir | head -1 | sed 's/.*_//')
+[ "$SUFFIX" = "f32" ] && CTYPE=float || { echo "unsupported suffix: $SUFFIX"; exit 1; }
+DEFN_NAME=cudnnConvolution2D_9tap_${SUFFIX}
+SCALAR_TY=$SUFFIX
+echo "    using $DEFN_NAME, scalar=$SCALAR_TY"
+
+echo "[conv2d/$DATASET] (4) inject kernel.defn for $DEFN_NAME"
+$PY -c "
+import sys
+ty_mem = 'memref>'
+ty_sca = '${SCALAR_TY}'
+name = '${DEFN_NAME}'
+arg_list = ', '.join([f'%a{i}: {ty_mem}' for i in range(9)] + [f'%c: {ty_mem}'] + [f'%w{i}: {ty_sca}' for i in range(9)])
+done = False
+with open('$OUT/${DATASET}_matched.mlir') as f:
+    for line in f:
+        sys.stdout.write(line)
+        if not done and line.startswith('module attributes'):
+            print(f'  kernel.defn @{name}({arg_list}) {{ kernel.yield }}')
+            done = True
+" > $OUT/${DATASET}_matched_with_defn.mlir
+
+echo "[conv2d/$DATASET] (5) lower-kernel-launch-to-cublas"
+polygeist-opt --lower-kernel-launch-to-cublas \
+    $OUT/${DATASET}_matched_with_defn.mlir -o $OUT/${DATASET}_abi.mlir 2>$OUT/${DATASET}.abi.err
+[ -s $OUT/${DATASET}_abi.mlir ] || { echo "ABI FAIL"; head -5 $OUT/${DATASET}.abi.err; exit 1; }
+
+# Rename + drop internal linkage so wrapper can link
+sed -i "s/@${FN}\b/@${FN}_impl/g; s/llvm.linkage = #llvm.linkage//; s/func.func private @${FN}_impl/func.func @${FN}_impl/" \
+    $OUT/${DATASET}_abi.mlir
+
+echo "[conv2d/$DATASET] (6) MLIR → LLVM dialect → LLVM IR"
+# Same pipeline as conv2d_cudnn_jetson.sh (not one-shot-bufferize)
+$MLIR_OPT --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \
+    --expand-strided-metadata \
+    --convert-arith-to-llvm --finalize-memref-to-llvm \
+    --convert-func-to-llvm --reconcile-unrealized-casts \
+    $OUT/${DATASET}_abi.mlir -o $OUT/${DATASET}_llvm.mlir 2>$OUT/${DATASET}.mlir.err
+[ -s $OUT/${DATASET}_llvm.mlir ] || { echo "MLIR lower FAIL"; head -10 $OUT/${DATASET}.mlir.err; exit 1; }
+
+$MLIR_TRANSLATE --mlir-to-llvmir $OUT/${DATASET}_llvm.mlir -o $OUT/${DATASET}_kernel.ll
+sed -i 's|target triple = "x86_64.*"|target triple = "aarch64-linux-gnu"|;
+        /^target datalayout/d' $OUT/${DATASET}_kernel.ll
+
+echo "[conv2d/$DATASET] (7) cross-compile .ll → aarch64 .o"
+$CLANG --target=aarch64-linux-gnu --gcc-toolchain=/usr \
+    -O3 -c $OUT/${DATASET}_kernel.ll -o $OUT/${DATASET}_kernel.o 2>&1 | tail -3
+
+echo "[conv2d/$DATASET] (8) cross-compile harness + wrapper + rt"
+HARNESS_CFLAGS=(-O3 -I"$UTIL" -I"$KDIR"
+                -DPOLYBENCH_DUMP_ARRAYS -D${DATASET}_DATASET -Dstatic=
+                -DPOLYBENCH_USE_C99_PROTO)
+ARCH_FLAGS="-march=armv8.2-a+fp16+bf16"
+
+aarch64-linux-gnu-gcc "${HARNESS_CFLAGS[@]}" -c "$SRC" -o $OUT/${DATASET}_full.o
+aarch64-linux-gnu-objcopy --weaken-symbol=$FN $OUT/${DATASET}_full.o $OUT/${DATASET}_nokernel.o
+aarch64-linux-gnu-gcc "${HARNESS_CFLAGS[@]}" -c "$UTIL/polybench.c" -o $OUT/${DATASET}_polybench.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -DCTYPE=$CTYPE -c $SCRIPTS/conv2d_jetson_wrapper_dtype.c -o $OUT/${DATASET}_wrapper.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -I$CUDA/include -I$CUDNN_INC -c $RT/polygeist_cublas_rt_cuda.c -o $OUT/${DATASET}_rt_cuda.o
+
+echo "[conv2d/$DATASET] (9) link"
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/${DATASET}_kernel.o $OUT/${DATASET}_rt_cuda.o \
+    $OUT/${DATASET}_wrapper.o $OUT/${DATASET}_nokernel.o $OUT/${DATASET}_polybench.o \
+    -L$CUDA/lib -L$CUDA/lib/stubs -L$CUDNN_LIB \
+    -lcudnn -lcublasLt -lcublas -lcudart -lm -lpthread -ldl \
+    -Wl,-rpath,/usr/local/cuda/lib64:/usr/lib/aarch64-linux-gnu \
+    -o $OUT/conv2d_jetson_${DATASET}
+
+echo "OK: $OUT/conv2d_jetson_${DATASET}"
+ls -l $OUT/conv2d_jetson_${DATASET}
diff --git a/scripts/correctness/build_polybenchgpu_gemv_jetson.sh b/scripts/correctness/build_polybenchgpu_gemv_jetson.sh
new file mode 100755
index 000000000000..3427902c3fe4
--- /dev/null
+++ b/scripts/correctness/build_polybenchgpu_gemv_jetson.sh
@@ -0,0 +1,137 @@
+#!/bin/bash
+# build_polybenchgpu_gemv_jetson.sh KERNEL DATASET
+# Build a polybenchGpu gemv-based kernel (atax, bicg, mvt, gemver, gesummv) end-to-end for Jetson.
+# Handles 2D memref + 1D memref shapes, multiple kernel.launch callees.
+set -euo pipefail
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+KERNEL=${1:?"need kernel: atax|bicg|mvt|gemver|gesummv"}
+DATASET=${2:?"need dataset: MINI|LARGE|EXTRALARGE"}
+
+PY=$PYTHON
+SCRIPTS=$REPO_ROOT/scripts/correctness
+
+ROOT=$REPO_ROOT/third_party/polybenchGpu/OpenMP
+UTIL=$ROOT/utilities
+KDIR=$ROOT/linear-algebra/kernels/$KERNEL
+SRC=$(ls $KDIR/*.c | head -1)
+FN="kernel_${KERNEL}"
+
+OUT=/tmp/${KERNEL}_pbgpu_jetson_build
+mkdir -p $OUT
+
+HARNESS_CFLAGS=(-O3 -I"$UTIL" -I"$KDIR"
+                -DDATA_TYPE_IS_DOUBLE -DPOLYBENCH_DUMP_ARRAYS
+                -D${DATASET}_DATASET -DPOLYBENCH_USE_C99_PROTO
+                # gcc's IPA modref/pure-const passes look at the local
+                # body of kernel_*() in the same TU and conclude "doesn't
+                # clobber w0 (n)", so main skips the AArch64-mandated
+                # w0 reload before print_array. But objcopy
+                # --weaken-symbol redirects the call to our wrapper at
+                # link time, and wrapper IS allowed to clobber w0 per the
+                # ABI. Mark the kernel body as `noipa` (via re-defining
+                # the `static` macro) so gcc treats the call as fully
+                # opaque and obeys the ABI.
+                "-Dstatic=__attribute__((noipa))")
+CGEIST_FLAGS=(-I"$UTIL" -I"$KDIR" -DDATA_TYPE_IS_DOUBLE
+              -D${DATASET}_DATASET -Dstatic=
+              --resource-dir=/usr/lib/clang/14
+              --raise-scf-to-affine -fPIC -S)
+
+echo "[$KERNEL/$DATASET] (1) cgeist"
+cgeist "$SRC" --function='*' --no-inline "${CGEIST_FLAGS[@]}" \
+   -o $OUT/${DATASET}_affine.mlir 2>$OUT/${DATASET}.cgeist.err
+[ -s $OUT/${DATASET}_affine.mlir ] || { echo "FAIL"; head -3 $OUT/${DATASET}.cgeist.err; exit 1; }
+
+echo "[$KERNEL/$DATASET] (2) raise + debuf"
+polygeist-opt --select-func="func-name=$FN" \
+    --remove-iter-args --affine-parallelize \
+    --raise-affine-to-linalg-pipeline --lower-polygeist-submap \
+    --linalg-debufferize \
+    $OUT/${DATASET}_affine.mlir -o $OUT/${DATASET}_debuf.mlir 2>$OUT/${DATASET}.raise.err
+
+echo "[$KERNEL/$DATASET] (3) matcher"
+$PY $SCRIPTS/kernel_match_rewrite.py $OUT/${DATASET}_debuf.mlir \
+    > $OUT/${DATASET}_matched.mlir 2>$OUT/${DATASET}.match.err
+N_LAUNCH=$(grep -c "kernel.launch" $OUT/${DATASET}_matched.mlir || true)
+echo "    matched $N_LAUNCH kernel.launch ops"
+[ "${N_LAUNCH:-0}" -ge 1 ] || { echo "matcher FAIL"; exit 1; }
+
+echo "[$KERNEL/$DATASET] (4) inject kernel.defn for every distinct callee"
+# Determine the 2D static second dim
+SECOND_DIM=$(grep -oE "tensor<\?x[0-9]+xf64>" $OUT/${DATASET}_matched.mlir | head -1 | sed -E 's/tensor<\?x([0-9]+)xf64>/\1/')
+echo "    static 2D dim: ${SECOND_DIM:-(none, 1D only)}"
+
+$PY - < $OUT/${DATASET}_matched_with_defn.mlir
+import re
+sec2d = "${SECOND_DIM:-}"
+ty2d = f"tensor" if sec2d else "tensor"
+ty1d = "tensor"
+
+callees = set()
+with open("$OUT/${DATASET}_matched.mlir") as f:
+    for line in f:
+        m = re.search(r'kernel\.launch\s+@([A-Za-z0-9_]+)', line)
+        if m: callees.add(m.group(1))
+
+# Per-callee signature builders
+def defn_for(name):
+    if name == "cublasDgemv":
+        return f"kernel.defn @{name}(%A: {ty2d}, %x: {ty1d}, %y: {ty1d}) -> {ty1d} {{ kernel.yield %y : {ty1d} }}"
+    if name == "cublasDgemv_T":
+        return f"kernel.defn @{name}(%A: {ty2d}, %x: {ty1d}, %y: {ty1d}) -> {ty1d} {{ kernel.yield %y : {ty1d} }}"
+    if name == "cublasDgemv_alpha":
+        return f"kernel.defn @{name}(%A: {ty2d}, %x: {ty1d}, %y: {ty1d}, %alpha: f64) -> {ty1d} {{ kernel.yield %y : {ty1d} }}"
+    if name == "cublasDaxpby":
+        return f"kernel.defn @{name}(%x: {ty1d}, %y: {ty1d}, %alpha: f64, %beta: f64) -> {ty1d} {{ kernel.yield %y : {ty1d} }}"
+    if name == "cublasDaxpy_unit":
+        return f"kernel.defn @{name}(%x: {ty1d}, %y: {ty1d}) -> {ty1d} {{ kernel.yield %y : {ty1d} }}"
+    if name == "cublasDger_rank2":
+        return f"kernel.defn @{name}(%u1: {ty1d}, %v1: {ty1d}, %u2: {ty1d}, %v2: {ty1d}, %A: {ty2d}) -> {ty2d} {{ kernel.yield %A : {ty2d} }}"
+    if name == "memset_zero_1D":
+        return f"kernel.defn @{name}(%v: {ty1d}) -> {ty1d} {{ kernel.yield %v : {ty1d} }}"
+    if name == "cublasDgemm":
+        return f"kernel.defn @{name}(%A: {ty2d}, %B: {ty2d}, %C: {ty2d}, %beta: f64, %alpha: f64) -> {ty2d} {{ kernel.yield %C : {ty2d} }}"
+    if name == "cublasDgemm_simple":
+        return f"kernel.defn @{name}(%A: {ty2d}, %B: {ty2d}, %C: {ty2d}) -> {ty2d} {{ kernel.yield %C : {ty2d} }}"
+    if name == "cublasDgemm_alpha_only":
+        return f"kernel.defn @{name}(%A: {ty2d}, %B: {ty2d}, %C: {ty2d}, %alpha: f64) -> {ty2d} {{ kernel.yield %C : {ty2d} }}"
+    if name == "cublasDgeam_scale2D":
+        return f"kernel.defn @{name}(%M: {ty2d}, %s: f64) -> {ty2d} {{ kernel.yield %M : {ty2d} }}"
+    if name == "memset_zero_2D":
+        return f"kernel.defn @{name}(%M: {ty2d}) -> {ty2d} {{ kernel.yield %M : {ty2d} }}"
+    raise SystemExit(f"unknown callee in matched MLIR: {name}")
+
+done = False
+with open("$OUT/${DATASET}_matched.mlir") as f:
+    for line in f:
+        print(line, end='')
+        if not done and line.startswith("module attributes"):
+            for c in sorted(callees):
+                print("  " + defn_for(c))
+            done = True
+EOF
+sed -i 's/!any/f64/g' $OUT/${DATASET}_matched_with_defn.mlir
+
+echo "[$KERNEL/$DATASET] (5) lower-kernel-launch-to-cublas"
+polygeist-opt --lower-kernel-launch-to-cublas \
+    $OUT/${DATASET}_matched_with_defn.mlir -o $OUT/${DATASET}_abi.mlir 2>$OUT/${DATASET}.abi.err
+[ -s $OUT/${DATASET}_abi.mlir ] || { echo "ABI FAIL"; head -5 $OUT/${DATASET}.abi.err; exit 1; }
+
+# Rename + de-internal
+sed -i "s/@${FN}\b/@${FN}_impl/g; s/llvm.linkage = #llvm.linkage//; s/func.func private @${FN}_impl/func.func @${FN}_impl/" \
+    $OUT/${DATASET}_abi.mlir
+
+echo "[$KERNEL/$DATASET] (6) build_jetson.sh → aarch64 binary"
+aarch64-linux-gnu-gcc "${HARNESS_CFLAGS[@]}" -c "$SRC" -o $OUT/${DATASET}_full.o
+aarch64-linux-gnu-objcopy --weaken-symbol=$FN $OUT/${DATASET}_full.o $OUT/${DATASET}_nokernel.o
+aarch64-linux-gnu-gcc "${HARNESS_CFLAGS[@]}" -c "$UTIL/polybench.c" -o $OUT/${DATASET}_polybench.o
+
+bash $SCRIPTS/build_jetson.sh \
+    $OUT/${DATASET}_abi.mlir \
+    $OUT/${KERNEL}_jetson_${DATASET} \
+    $SCRIPTS/${KERNEL}_jetson_wrapper.c \
+    $OUT/${DATASET}_nokernel.o \
+    $OUT/${DATASET}_polybench.o 2>&1 | tail -3
+echo "OK: $OUT/${KERNEL}_jetson_${DATASET}"
diff --git a/scripts/correctness/build_polybenchgpu_jetson.sh b/scripts/correctness/build_polybenchgpu_jetson.sh
new file mode 100755
index 000000000000..19fcf379cd63
--- /dev/null
+++ b/scripts/correctness/build_polybenchgpu_jetson.sh
@@ -0,0 +1,109 @@
+#!/bin/bash
+# build_polybenchgpu_jetson.sh KERNEL DATASET
+# Build a single polybenchGpu kernel for one dataset size, end-to-end.
+# Produces /tmp/_pbgpu_jetson_build/_jetson_
+set -euo pipefail
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+KERNEL=${1:?"need kernel name e.g. syrk"}
+DATASET=${2:?"need dataset e.g. MINI|LARGE|EXTRALARGE"}
+
+PY=$PYTHON
+SCRIPTS=$REPO_ROOT/scripts/correctness
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+MLIR_TRANSLATE=$REPO_ROOT/llvm-project/build/bin/mlir-translate
+
+ROOT=$REPO_ROOT/third_party/polybenchGpu/OpenMP
+UTIL=$ROOT/utilities
+# Find the kernel subdir
+case "$KERNEL" in
+  syrk|gemm|gemver|gesummv|2mm|3mm|atax|bicg|mvt|symm|syr2k|trmm|trisolv) KDIR=$ROOT/linear-algebra/kernels/$KERNEL ;;
+  convolution-2d|convolution-3d|fdtd-2d|fdtd-apml|jacobi-1d-imper|jacobi-2d-imper|seidel-2d|adi) KDIR=$ROOT/stencils/$KERNEL ;;
+  correlation|covariance) KDIR=$ROOT/datamining/$KERNEL ;;
+  *) echo "ERROR: unknown kernel $KERNEL" >&2; exit 1 ;;
+esac
+
+SRC=$(ls $KDIR/*.c 2>/dev/null | head -1)
+[ -z "$SRC" ] && { echo "ERROR: no .c in $KDIR" >&2; exit 1; }
+
+FN="kernel_${KERNEL//-/_}"
+
+OUT=/tmp/${KERNEL}_pbgpu_jetson_build
+mkdir -p $OUT
+
+HARNESS_CFLAGS=(-O3 -I"$UTIL" -I"$KDIR"
+                -DDATA_TYPE_IS_DOUBLE -DPOLYBENCH_DUMP_ARRAYS
+                -D${DATASET}_DATASET -Dstatic= -DPOLYBENCH_USE_C99_PROTO)
+# cgeist flags — note polybenchGpu's old polybench.h breaks if we pass
+# POLYBENCH_USE_C99_PROTO to cgeist, so we DON'T (the static dim baked in
+# will match the dataset because we set -D${DATASET}_DATASET).
+CGEIST_FLAGS=(-I"$UTIL" -I"$KDIR" -DDATA_TYPE_IS_DOUBLE
+              -D${DATASET}_DATASET -Dstatic=
+              --resource-dir=/usr/lib/clang/14
+              --raise-scf-to-affine -fPIC -S)
+
+echo "[$KERNEL/$DATASET] (1) cgeist → affine MLIR"
+cgeist "$SRC" --function='*' --no-inline "${CGEIST_FLAGS[@]}" \
+  -o $OUT/${DATASET}_affine.mlir 2>$OUT/${DATASET}.cgeist.err
+[ -s $OUT/${DATASET}_affine.mlir ] || { echo "cgeist FAIL"; head -3 $OUT/${DATASET}.cgeist.err; exit 1; }
+
+echo "[$KERNEL/$DATASET] (2) raise + debuf"
+polygeist-opt --select-func="func-name=$FN" \
+    --remove-iter-args --affine-parallelize \
+    --raise-affine-to-linalg-pipeline --lower-polygeist-submap \
+    --linalg-debufferize \
+    $OUT/${DATASET}_affine.mlir -o $OUT/${DATASET}_debuf.mlir 2>$OUT/${DATASET}.raise.err
+[ -s $OUT/${DATASET}_debuf.mlir ] || { echo "raise FAIL"; head -3 $OUT/${DATASET}.raise.err; exit 1; }
+
+echo "[$KERNEL/$DATASET] (3) matcher: linalg → kernel.launch"
+$PY $SCRIPTS/kernel_match_rewrite.py $OUT/${DATASET}_debuf.mlir \
+    > $OUT/${DATASET}_matched.mlir 2>$OUT/${DATASET}.match.err
+N_LAUNCH=$(grep -c "kernel.launch" $OUT/${DATASET}_matched.mlir || true)
+echo "    matched $N_LAUNCH kernel.launch ops"
+[ "${N_LAUNCH:-0}" -ge 1 ] || { echo "matcher FAIL"; exit 1; }
+
+echo "[$KERNEL/$DATASET] (4) inject kernel.defn @cublasDgemm + lower-kernel-launch-to-cublas"
+# Determine the static second dim from the matched MLIR
+SECOND_DIM=$(grep -oE "tensor<\?x[0-9]+xf64>" $OUT/${DATASET}_matched.mlir | head -1 | sed -E 's/tensor<\?x([0-9]+)xf64>/\1/')
+[ -z "$SECOND_DIM" ] && { echo "Couldn't determine static second dim"; exit 1; }
+echo "    static second dim: $SECOND_DIM"
+TY="tensor"
+
+$PY -c "
+import sys
+ty = '$TY'
+done = False
+with open('$OUT/${DATASET}_matched.mlir') as f:
+    for line in f:
+        sys.stdout.write(line)
+        if not done and line.startswith('module attributes'):
+            print(f'  kernel.defn @cublasDgemm(%A: {ty}, %B: {ty}, %C: {ty}, %beta: f64, %alpha: f64) -> {ty} {{')
+            print(f'    kernel.yield %C : {ty}')
+            print('  }')
+            done = True
+" > $OUT/${DATASET}_matched_with_defn.mlir
+sed -i 's/!any/f64/g' $OUT/${DATASET}_matched_with_defn.mlir
+
+polygeist-opt --lower-kernel-launch-to-cublas \
+    $OUT/${DATASET}_matched_with_defn.mlir -o $OUT/${DATASET}_abi.mlir 2>$OUT/${DATASET}.abi.err
+[ -s $OUT/${DATASET}_abi.mlir ] || { echo "ABI lower FAIL"; head -3 $OUT/${DATASET}.abi.err; exit 1; }
+
+# Rename kernel function + drop internal linkage
+sed -i "s/@${FN}\b/@${FN}_impl/g; s/llvm.linkage = #llvm.linkage//; s/func.func private @${FN}_impl/func.func @${FN}_impl/" \
+    $OUT/${DATASET}_abi.mlir
+
+echo "[$KERNEL/$DATASET] (5) cross-compile harness"
+aarch64-linux-gnu-gcc "${HARNESS_CFLAGS[@]}" -c "$SRC" -o $OUT/${DATASET}_full.o
+aarch64-linux-gnu-objcopy --weaken-symbol=$FN $OUT/${DATASET}_full.o $OUT/${DATASET}_nokernel.o
+aarch64-linux-gnu-gcc "${HARNESS_CFLAGS[@]}" -c "$UTIL/polybench.c" -o $OUT/${DATASET}_polybench.o
+
+echo "[$KERNEL/$DATASET] (6) build_jetson.sh → aarch64 binary"
+bash $SCRIPTS/build_jetson.sh \
+    $OUT/${DATASET}_abi.mlir \
+    $OUT/${KERNEL}_jetson_${DATASET} \
+    $SCRIPTS/${KERNEL}_jetson_wrapper.c \
+    $OUT/${DATASET}_nokernel.o \
+    $OUT/${DATASET}_polybench.o 2>&1 | tail -3
+
+echo "OK: $OUT/${KERNEL}_jetson_${DATASET}"
diff --git a/scripts/correctness/collect_aten_device_residency.py b/scripts/correctness/collect_aten_device_residency.py
new file mode 100644
index 000000000000..c019841f1caa
--- /dev/null
+++ b/scripts/correctness/collect_aten_device_residency.py
@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""Merge ATen mapped/device-resident Jetson logs into published CSVs."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+from pathlib import Path
+import re
+import statistics
+
+
+ROOT = Path(__file__).resolve().parents[2]
+DEFAULT_MAIN = (ROOT / "issues/aten_c_kernels/silicon_results" /
+                "large_problem_comparison.csv")
+DEFAULT_OUTPUT = (ROOT / "issues/aten_c_kernels/silicon_results" /
+                  "device_residency_comparison.csv")
+
+
+def parse_logs(roots: list[Path]) -> dict[str, dict[str, object]]:
+    rows: dict[str, dict[str, object]] = {}
+    value_patterns = {
+        "mapped": re.compile(r"raised_gpu_us=([0-9.eE+-]+)"),
+        "device": re.compile(r"raised_device_us=([0-9.eE+-]+)"),
+    }
+    for root in roots:
+        for log in root.rglob("*.silicon.log"):
+            text = log.read_text(errors="replace")
+            kernel_match = re.search(r"kernel=(aten_[A-Za-z0-9_]+)", text)
+            if not kernel_match:
+                continue
+            kernel = kernel_match.group(1)
+            entry = rows.setdefault(kernel, {"logs": []})
+            entry["logs"].append(str(log))
+            pass_count = len(re.findall(
+                rf"kernel={re.escape(kernel)} correctness=PASS", text))
+            for mode, pattern in value_patterns.items():
+                values = [float(v) for v in pattern.findall(text)]
+                if not values:
+                    continue
+                # Process run 1 includes library/plan initialization. Publish
+                # the median of warm process runs 2-4, matching the existing
+                # ATen and MFEM CE convention.
+                warm = values[1:4] if len(values) >= 4 else values
+                entry[mode] = statistics.median(warm)
+                entry[f"{mode}_samples"] = len(values)
+                entry[f"{mode}_correct"] = pass_count == len(values)
+    return rows
+
+
+def parse_overrides(values: list[str]) -> dict[str, float]:
+    result = {}
+    for value in values:
+        kernel, timing = value.split("=", 1)
+        result[kernel] = float(timing)
+    return result
+
+
+def fmt(value: float | None, digits: int = 6) -> str:
+    return "—" if value is None else f"{value:.{digits}f}"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--run-root", action="append", type=Path, required=True)
+    parser.add_argument("--main-csv", type=Path, default=DEFAULT_MAIN)
+    parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT)
+    parser.add_argument("--resident-override", action="append", default=[],
+                        metavar="KERNEL=MICROSECONDS")
+    args = parser.parse_args()
+
+    measured = parse_logs(args.run_root)
+    resident_overrides = parse_overrides(args.resident_override)
+    with args.main_csv.open(newline="") as stream:
+        main_rows = list(csv.DictReader(stream))
+        fieldnames = list(main_rows[0])
+    by_kernel = {row["kernel"]: row for row in main_rows}
+
+    output_rows = []
+    for kernel in sorted(measured):
+        data = measured[kernel]
+        if "mapped" not in data or "device" not in data:
+            continue
+        main = by_kernel.get(kernel)
+        if not main:
+            continue
+        mapped = float(data["mapped"])
+        device = float(data["device"])
+        resident = resident_overrides.get(kernel)
+        if resident is None and main["resident_cuda_us"] not in {"", "—"}:
+            resident = float(main["resident_cuda_us"])
+
+        # Keep the original broad status table current as well as emitting the
+        # focused three-way comparison used by the CE performance page.
+        main["raised_us"] = fmt(mapped)
+        if resident is not None:
+            main["resident_cuda_us"] = fmt(resident)
+            main["raised_over_resident"] = fmt(mapped / resident)
+        main["correctness"] = (
+            "PASS" if data.get("mapped_correct") and data.get("device_correct")
+            else "FAIL")
+        main["statistic"] = "warm median of process runs 2-4"
+        main["notes"] = (
+            "mapped and cudaMalloc device-resident raised paths correctness-gated")
+
+        output_rows.append({
+            "kernel": kernel,
+            "correctness": main["correctness"],
+            "problem": main["problem"],
+            "mapped_raised_us": fmt(mapped),
+            "device_resident_us": fmt(device),
+            "resident_cuda_us": fmt(resident),
+            "mapped_over_resident": fmt(mapped / resident if resident else None),
+            "device_over_resident": fmt(device / resident if resident else None),
+            "mapped_over_device": fmt(mapped / device),
+            "hardware": "Jetson Orin sm87 MAXN CUDA 12.6",
+            "statistic": "median process runs 2-4; 20 timed calls/process",
+            "notes": ("RMS reduction reassociation tolerance 2e-3" if
+                      kernel == "aten_rms_norm" else "correctness-gated"),
+        })
+
+    # The new large runs intentionally scale these two legacy fixtures from
+    # 1M to 8M elements; their native baselines are passed as overrides.
+    for kernel in ("aten_rms_norm", "aten_softmax"):
+        if kernel in measured and kernel in by_kernel:
+            by_kernel[kernel]["problem"] = "N8388608"
+    for row in output_rows:
+        if row["kernel"] in {"aten_rms_norm", "aten_softmax"}:
+            row["problem"] = "N8388608"
+
+    with args.main_csv.open("w", newline="") as stream:
+        writer = csv.DictWriter(stream, fieldnames=fieldnames,
+                                lineterminator="\n")
+        writer.writeheader()
+        writer.writerows(main_rows)
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    out_fields = list(output_rows[0]) if output_rows else []
+    with args.output.open("w", newline="") as stream:
+        writer = csv.DictWriter(stream, fieldnames=out_fields,
+                                lineterminator="\n")
+        writer.writeheader()
+        writer.writerows(output_rows)
+    print(f"published={len(output_rows)} output={args.output}")
+    return 0 if len(output_rows) == len(measured) else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/correctness/common_env.sh b/scripts/correctness/common_env.sh
new file mode 100644
index 000000000000..f8b482e884e9
--- /dev/null
+++ b/scripts/correctness/common_env.sh
@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# Shared path setup for correctness and Jetson pipeline scripts.
+
+_POLYGEIST_SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="${POLYGEIST_ROOT:-$(cd "$_POLYGEIST_SCRIPT_DIR/../.." && pwd)}"
+POLYGEIST_ROOT="$REPO_ROOT"
+SCRIPT_DIR="${SCRIPT_DIR:-$_POLYGEIST_SCRIPT_DIR}"
+
+if [[ -f "$REPO_ROOT/envsetup.sh" ]]; then
+  source "$REPO_ROOT/envsetup.sh"
+else
+  export PATH="$REPO_ROOT/build/bin:$PATH"
+fi
+
+PYTHON="${PYTHON:-python3}"
+PY="${PY:-$PYTHON}"
+SCRIPTS="${SCRIPTS:-$SCRIPT_DIR}"
+RT="${RT:-$REPO_ROOT/runtime}"
+MLIR_OPT="${MLIR_OPT:-$REPO_ROOT/llvm-project/build/bin/mlir-opt}"
+MLIR_TRANSLATE="${MLIR_TRANSLATE:-$REPO_ROOT/llvm-project/build/bin/mlir-translate}"
+CLANG="${CLANG:-$REPO_ROOT/llvm-project/build/bin/clang}"
+KERNEL_LIB="${KERNEL_LIB:-$REPO_ROOT/generic_solver/kernel_library_phase2.mlir}"
+POLYBENCH_DIR="${POLYBENCH_DIR:-$REPO_ROOT/tools/cgeist/Test/polybench}"
+
+PVASOL_ROOT="${PVASOL_ROOT:-$HOME/pva-solutions}"
+CV_CUDA_ROOT="${CV_CUDA_ROOT:-$HOME/cv-cuda}"
+CUPVA_SDK_ROOT="${CUPVA_SDK_ROOT:-$HOME/cupva_sdk_include}"
+PVA_LIB_STAGE="${PVA_LIB_STAGE:-$HOME/pva_libs}"
+JETSON_NVIDIA_LIBS="${JETSON_NVIDIA_LIBS:-$HOME/jetson_nvidia_libs}"
diff --git a/scripts/correctness/conv1x1_batched_jetson_harness.c b/scripts/correctness/conv1x1_batched_jetson_harness.c
new file mode 100644
index 000000000000..edcfe1a1fbf8
--- /dev/null
+++ b/scripts/correctness/conv1x1_batched_jetson_harness.c
@@ -0,0 +1,98 @@
+/* Jetson harness for 1×1 conv routed to batched cublasSgemm. */
+#include 
+#include 
+#include 
+#include 
+
+#if defined(LARGE_DATASET)
+# define B  32
+# define IC 256
+# define OC 256
+# define H  56
+# define W  56
+#elif defined(MINI_DATASET)
+# define B  4
+# define IC 16
+# define OC 16
+# define H  32
+# define W  32
+#endif
+#ifndef B
+# define B 4
+#endif
+#ifndef IC
+# define IC 16
+#endif
+#ifndef OC
+# define OC 16
+#endif
+#ifndef H
+# define H 32
+#endif
+#ifndef W
+# define W 32
+#endif
+#define KS 1
+#define OH H
+#define OW W
+
+extern void kernel_conv1x1_batched_impl(
+    float *A_b, float *A_a, int64_t A_o,
+    int64_t A_s0, int64_t A_s1, int64_t A_s2, int64_t A_s3,
+    int64_t A_t0, int64_t A_t1, int64_t A_t2, int64_t A_t3,
+    float *F_b, float *F_a, int64_t F_o,
+    int64_t F_s0, int64_t F_s1, int64_t F_s2, int64_t F_s3,
+    int64_t F_t0, int64_t F_t1, int64_t F_t2, int64_t F_t3,
+    float *O_b, float *O_a, int64_t O_o,
+    int64_t O_s0, int64_t O_s1, int64_t O_s2, int64_t O_s3,
+    int64_t O_t0, int64_t O_t1, int64_t O_t2, int64_t O_t3);
+
+extern void   polygeist_cublas_time_begin(void);
+extern double polygeist_cublas_time_end_ms(void);
+
+static void run_kernel(float *A, float *F, float *Bout) {
+  polygeist_cublas_time_begin();
+  kernel_conv1x1_batched_impl(
+      A, A, 0,
+      (int64_t)B, (int64_t)IC, (int64_t)H, (int64_t)W,
+      (int64_t)(IC*H*W), (int64_t)(H*W), (int64_t)W, 1,
+      F, F, 0,
+      (int64_t)OC, (int64_t)IC, (int64_t)KS, (int64_t)KS,
+      (int64_t)(IC*KS*KS), (int64_t)(KS*KS), (int64_t)KS, 1,
+      Bout, Bout, 0,
+      (int64_t)B, (int64_t)OC, (int64_t)OH, (int64_t)OW,
+      (int64_t)(OC*OH*OW), (int64_t)(OH*OW), (int64_t)OW, 1);
+  double ms = polygeist_cublas_time_end_ms();
+  fprintf(stderr,
+      "POLYGEIST_TIMING: conv1x1_batched B=%d IC=%d OC=%d H=%d W=%d  %.3f ms\n",
+      B, IC, OC, H, W, ms);
+}
+
+int main(void) {
+  size_t nA = (size_t)B*IC*H*W, nF = (size_t)OC*IC, nO = (size_t)B*OC*OH*OW;
+  float *A = (float *)malloc(nA * sizeof(float));
+  float *F = (float *)malloc(nF * sizeof(float));
+  float *O = (float *)malloc(nO * sizeof(float));
+  if (!A || !F || !O) { fprintf(stderr, "alloc failed\n"); return 1; }
+
+  for (size_t k = 0; k < nA; ++k)
+    A[k] = (float)((k * 17) % 31) / 31.0f - 0.5f;
+  for (size_t k = 0; k < nF; ++k)
+    F[k] = (float)((k * 23) % 37) / 37.0f - 0.5f;
+  memset(O, 0, nO * sizeof(float));
+
+  run_kernel(A, F, O);
+
+  double sum = 0;
+  for (size_t k = 0; k < nO; ++k) sum += O[k];
+  fprintf(stderr, "CHECKSUM: %.6f over %zu elems\n", sum, nO);
+  fprintf(stderr, "==BEGIN DUMP_ARRAYS==\n");
+  for (size_t k = 0; k < nO; ++k) {
+    if (k % 19 == 0) fprintf(stderr, "\n");
+    fprintf(stderr, "%0.4f ", O[k]);
+  }
+  fprintf(stderr, "\n==END   DUMP_ARRAYS==\n");
+
+  free(A); free(F); free(O);
+  return 0;
+}
diff --git a/scripts/correctness/conv2d_batched_jetson_harness.c b/scripts/correctness/conv2d_batched_jetson_harness.c
new file mode 100644
index 000000000000..2ce258b8e0ef
--- /dev/null
+++ b/scripts/correctness/conv2d_batched_jetson_harness.c
@@ -0,0 +1,130 @@
+/* conv2d_batched_jetson_harness.c — Jetson harness for the extracted
+ * batched conv2d kernel. Provides a main(), inits inputs to a
+ * deterministic pattern, calls the renamed `_impl` function (the
+ * cgeist-lowered LLVM-ABI form of kernel_conv2d_batched), checksums
+ * the output for correctness validation.
+ *
+ * Compile-time shape:  -DB= -DIC= -DOC= -DH= -DW= -DKS=
+ */
+#include 
+#include 
+#include 
+#include 
+
+/* Match conv2d_batched.c's dataset macros so -DLARGE_DATASET / -DMINI_DATASET
+ * propagated from the build script sets all shapes consistently here. */
+#if defined(LARGE_DATASET)
+# define B  32
+# define IC 64
+# define OC 64
+# define H  56
+# define W  56
+# define KS 3
+#elif defined(MINI_DATASET)
+# define B  4
+# define IC 8
+# define OC 8
+# define H  32
+# define W  32
+# define KS 3
+#endif
+#ifndef B
+# define B 4
+#endif
+#ifndef IC
+# define IC 8
+#endif
+#ifndef OC
+# define OC 8
+#endif
+#ifndef H
+# define H 32
+#endif
+#ifndef W
+# define W 32
+#endif
+#ifndef KS
+# define KS 3
+#endif
+#define OH (H - KS + 1)
+#define OW (W - KS + 1)
+
+/* MLIR convert-func-to-llvm expands each memref<...xf32> to an 11-arg
+ * descriptor for rank-4 (basePtr, alignedPtr, offset, 4×size, 4×stride).
+ * The kernel name in the lowered LLVM IR is `kernel_conv2d_batched_impl`
+ * after the build script sed-renames the original symbol. */
+extern void kernel_conv2d_batched_impl(
+    /* A: ?x?x?x?xf32 */
+    float *A_b,  float *A_a,  int64_t A_o,
+    int64_t A_s0, int64_t A_s1, int64_t A_s2, int64_t A_s3,
+    int64_t A_t0, int64_t A_t1, int64_t A_t2, int64_t A_t3,
+    /* F: ?x?x?x?xf32 */
+    float *F_b,  float *F_a,  int64_t F_o,
+    int64_t F_s0, int64_t F_s1, int64_t F_s2, int64_t F_s3,
+    int64_t F_t0, int64_t F_t1, int64_t F_t2, int64_t F_t3,
+    /* O: ?x?x?x?xf32 */
+    float *O_b,  float *O_a,  int64_t O_o,
+    int64_t O_s0, int64_t O_s1, int64_t O_s2, int64_t O_s3,
+    int64_t O_t0, int64_t O_t1, int64_t O_t2, int64_t O_t3);
+
+extern void   polygeist_cublas_time_begin(void);
+extern double polygeist_cublas_time_end_ms(void);
+
+static void run_kernel(float *A, float *F, float *Bout) {
+  polygeist_cublas_time_begin();
+  kernel_conv2d_batched_impl(
+      A, A, 0,
+      (int64_t)B, (int64_t)IC, (int64_t)H, (int64_t)W,
+      (int64_t)(IC*H*W), (int64_t)(H*W), (int64_t)W, 1,
+      F, F, 0,
+      (int64_t)OC, (int64_t)IC, (int64_t)KS, (int64_t)KS,
+      (int64_t)(IC*KS*KS), (int64_t)(KS*KS), (int64_t)KS, 1,
+      Bout, Bout, 0,
+      (int64_t)B, (int64_t)OC, (int64_t)OH, (int64_t)OW,
+      (int64_t)(OC*OH*OW), (int64_t)(OH*OW), (int64_t)OW, 1);
+  double ms = polygeist_cublas_time_end_ms();
+  fprintf(stderr,
+      "POLYGEIST_TIMING: conv2d_batched B=%d IC=%d OC=%d H=%d W=%d K=%d  %.3f ms\n",
+      B, IC, OC, H, W, KS, ms);
+}
+
+int main(void) {
+  size_t nA = (size_t)B*IC*H*W,
+         nF = (size_t)OC*IC*KS*KS,
+         nO = (size_t)B*OC*OH*OW;
+  float *A = (float *)malloc(nA * sizeof(float));
+  float *F = (float *)malloc(nF * sizeof(float));
+  float *O = (float *)malloc(nO * sizeof(float));
+  if (!A || !F || !O) { fprintf(stderr, "alloc failed\n"); return 1; }
+
+  /* Same init as conv2d_batched.c's init_array (modular pattern). */
+  for (int b = 0; b < B; ++b)
+    for (int c = 0; c < IC; ++c)
+      for (int i = 0; i < H; ++i)
+        for (int j = 0; j < W; ++j)
+          A[((size_t)b*IC + c)*H*W + (size_t)i*W + j] =
+              (float)((b + c + i + j) % 17) / 17.0f;
+  for (int oc = 0; oc < OC; ++oc)
+    for (int c = 0; c < IC; ++c)
+      for (int i = 0; i < KS; ++i)
+        for (int j = 0; j < KS; ++j)
+          F[((size_t)oc*IC + c)*KS*KS + (size_t)i*KS + j] =
+              (float)((oc*3 + c*5 + i*7 + j) % 11) / 11.0f;
+  memset(O, 0, nO * sizeof(float));
+
+  run_kernel(A, F, O);
+
+  /* Checksum + selective dump for diff vs CPU stub. */
+  double sum = 0;
+  for (size_t k = 0; k < nO; ++k) sum += O[k];
+  fprintf(stderr, "CHECKSUM: %.6f over %zu elems\n", sum, nO);
+  fprintf(stderr, "==BEGIN DUMP_ARRAYS==\n");
+  for (size_t k = 0; k < nO; ++k) {
+    if (k % 19 == 0) fprintf(stderr, "\n");
+    fprintf(stderr, "%0.4f ", O[k]);
+  }
+  fprintf(stderr, "\n==END   DUMP_ARRAYS==\n");
+
+  free(A); free(F); free(O);
+  return 0;
+}
diff --git a/scripts/correctness/conv2d_cudnn_jetson.sh b/scripts/correctness/conv2d_cudnn_jetson.sh
new file mode 100755
index 000000000000..275e82c2f6c0
--- /dev/null
+++ b/scripts/correctness/conv2d_cudnn_jetson.sh
@@ -0,0 +1,95 @@
+#!/bin/bash
+# conv2d_cudnn_jetson.sh — cross-build extracted conv2d for Jetson Orin
+# with the matched kernel.launch → cudnnConvolutionForward routing.
+#
+# Usage: ./conv2d_cudnn_jetson.sh [SIZE]   (default 256; baked via -DNI/-DNJ)
+# Output: /tmp/conv2d_jetson_/{conv2d_jetson, conv2d_jetson_cpustub}
+
+set -euo pipefail
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+SIZE=${1:-256}
+SCRIPTS=$REPO_ROOT/scripts/correctness
+RT=$REPO_ROOT/runtime
+EXT=$REPO_ROOT/third_party/polybenchGpu-extracted
+OUT=/tmp/conv2d_jetson_${SIZE}
+mkdir -p $OUT
+CUDA=/usr/local/cuda-12.6/targets/sbsa-linux
+# cuDNN cross package installs to /usr/{include,lib}/aarch64-linux-gnu/
+CUDNN_INC=/usr/include/aarch64-linux-gnu
+CUDNN_LIB=/usr/lib/aarch64-linux-gnu
+
+echo "[conv2d/$SIZE] (1) cgeist → affine MLIR"
+cgeist $EXT/conv2d.c --function=kernel_conv2d --resource-dir=/usr/lib/clang/14 \
+    -DNI=$SIZE -DNJ=$SIZE --raise-scf-to-affine -fPIC -S \
+    -o $OUT/orig.mlir 2>/dev/null
+
+echo "[conv2d/$SIZE] (2) raise + lower-submap"
+polygeist-opt --select-func=func-name=kernel_conv2d \
+    --remove-iter-args --affine-parallelize \
+    --raise-affine-to-linalg-pipeline --lower-polygeist-submap \
+    $OUT/orig.mlir -o $OUT/linalg.mlir 2>$OUT/raise.err
+
+echo "[conv2d/$SIZE] (3) kernel-match"
+PYTHON=$PYTHON
+$PYTHON $SCRIPTS/kernel_match_rewrite.py $OUT/linalg.mlir > $OUT/matched.mlir 2>$OUT/match.err
+N_LAUNCH=$(grep -c '@cudnnConvolution2D_9tap' $OUT/matched.mlir || true)
+[ "${N_LAUNCH:-0}" -ge 1 ] || { echo "  FAIL: matcher didn't emit conv2d launch"; exit 1; }
+echo "  matched $N_LAUNCH conv2d_9tap launch(es)"
+
+echo "[conv2d/$SIZE] (4) inject defn"
+awk '/^module attributes/ && !done{
+       print;
+       print "  kernel.defn @cudnnConvolution2D_9tap(%a0: memref>, %a1: memref>, %a2: memref>, %a3: memref>, %a4: memref>, %a5: memref>, %a6: memref>, %a7: memref>, %a8: memref>, %c: memref>, %w0: f64, %w1: f64, %w2: f64, %w3: f64, %w4: f64, %w5: f64, %w6: f64, %w7: f64, %w8: f64) { kernel.yield }";
+       done=1; next
+     }{print}' $OUT/matched.mlir > $OUT/matched_with_defn.mlir
+
+echo "[conv2d/$SIZE] (5) lower-kernel-launch-to-cublas"
+polygeist-opt --lower-kernel-launch-to-cublas \
+    $OUT/matched_with_defn.mlir -o $OUT/abi.mlir 2>$OUT/abi.err
+
+echo "[conv2d/$SIZE] (6) lower to LLVM, translate, retarget aarch64"
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+MLIR_TRANSLATE=$REPO_ROOT/llvm-project/build/bin/mlir-translate
+CLANG=$REPO_ROOT/llvm-project/build/bin/clang
+$MLIR_OPT --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \
+    --expand-strided-metadata \
+    --convert-arith-to-llvm --finalize-memref-to-llvm \
+    --convert-func-to-llvm --reconcile-unrealized-casts \
+    $OUT/abi.mlir -o $OUT/llvm.mlir 2>$OUT/mlir.err
+$MLIR_TRANSLATE --mlir-to-llvmir $OUT/llvm.mlir -o $OUT/kernel.ll
+sed -i 's|target triple = "x86_64.*"|target triple = "aarch64-linux-gnu"|;
+        /^target datalayout/d;
+        s/@kernel_conv2d\b/@kernel_conv2d_impl/g' $OUT/kernel.ll
+$CLANG --target=aarch64-linux-gnu --gcc-toolchain=/usr \
+    -O3 -c $OUT/kernel.ll -o $OUT/kernel.o 2>&1 | tail -1
+
+echo "[conv2d/$SIZE] (7) cross-compile harness + wrapper + runtimes"
+# -march=armv8.2-a+fp16+bf16: Jetson Orin (Cortex-A78AE) is ARMv8.2-A
+# baseline; we add +fp16 + +bf16 to enable scalar _Float16 / __bf16 support
+# in the runtime so the f16/bf16 conv shims compile. cuDNN itself handles
+# the hardware-acceleration path on the GPU side.
+ARCH_FLAGS="-march=armv8.2-a+fp16+bf16"
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -DNI=$SIZE -DNJ=$SIZE -c $SCRIPTS/conv2d_main_harness.c -o $OUT/main.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -c $SCRIPTS/conv2d_jetson_wrapper.c -o $OUT/wrapper.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -I$CUDA/include -I$CUDNN_INC -c $RT/polygeist_cublas_rt_cuda.c -o $OUT/rt_cuda.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -c $RT/polygeist_cublas_rt_cpu.c -o $OUT/rt_cpu.o
+
+echo "[conv2d/$SIZE] (8) link CUDA binary"
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/main.o $OUT/wrapper.o $OUT/kernel.o $OUT/rt_cuda.o \
+    -L$CUDA/lib -L$CUDA/lib/stubs -L$CUDNN_LIB \
+    -lcudnn -lcublasLt -lcublas -lcudart -lm -lpthread -ldl \
+    -Wl,-rpath,/usr/local/cuda/lib64:/usr/lib/aarch64-linux-gnu \
+    -o $OUT/conv2d_jetson
+
+echo "[conv2d/$SIZE] (9) link CPU-stub binary"
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/main.o $OUT/wrapper.o $OUT/kernel.o $OUT/rt_cpu.o \
+    -lm -lpthread -o $OUT/conv2d_jetson_cpustub
+
+echo ""
+echo "═══ ${SIZE}×${SIZE} binaries ═══"
+ls -la $OUT/conv2d_jetson $OUT/conv2d_jetson_cpustub
+aarch64-linux-gnu-readelf -d $OUT/conv2d_jetson | grep -E 'libcudnn|libcublas|libcudart' | head -4
diff --git a/scripts/correctness/conv2d_cudnn_jetson_dtype.sh b/scripts/correctness/conv2d_cudnn_jetson_dtype.sh
new file mode 100755
index 000000000000..d40c483953a3
--- /dev/null
+++ b/scripts/correctness/conv2d_cudnn_jetson_dtype.sh
@@ -0,0 +1,164 @@
+#!/bin/bash
+# conv2d_cudnn_jetson_dtype.sh — cross-build extracted conv2d_.c for
+# Jetson Orin with the matched kernel.launch → cudnnConvolutionForward
+# routing. Generalises conv2d_cudnn_jetson.sh to all dtypes in the Phase-2
+# matrix (f64/f32/f16/bf16/i32/i16).
+#
+# Usage: ./conv2d_cudnn_jetson_dtype.sh  [SIZE]
+#   : f64 | f32 | f16 | bf16 | i32 | i16
+#   [SIZE]:  default 256
+#
+# Output: /tmp/conv2d_jetson__/{conv2d_jetson,
+#                                              conv2d_jetson_cpustub}
+
+set -euo pipefail
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+DTYPE=${1:?"missing DTYPE arg (f64|f32|f16|bf16|i32|i16)"}
+SIZE=${2:-256}
+SCRIPTS=$REPO_ROOT/scripts/correctness
+RT=$REPO_ROOT/runtime
+EXT=$REPO_ROOT/third_party/polybenchGpu-extracted
+OUT=/tmp/conv2d_jetson_${DTYPE}_${SIZE}
+mkdir -p $OUT
+CUDA=/usr/local/cuda-12.6/targets/sbsa-linux
+CUDNN_INC=/usr/include/aarch64-linux-gnu
+CUDNN_LIB=/usr/lib/aarch64-linux-gnu
+
+# Per-dtype config: source-file suffix, MLIR/MLIR-defn elem type, C scalar
+# type, printf format. The kernel.launch symbol gets the dtype suffix; f64
+# has no suffix for backward compat with the original Lit-surfacing test.
+case "$DTYPE" in
+  f64)  SRC=$EXT/conv2d.c;       MTY=f64;  CTY=double; KIND_DEF="-DCTYPE_KIND_FLOAT"; SYM_SUFFIX="";    ;;
+  f32)  SRC=$EXT/conv2d_f32.c;   MTY=f32;  CTY=float;  KIND_DEF="-DCTYPE_KIND_FLOAT"; SYM_SUFFIX="_f32";;
+  i32)  SRC=$EXT/conv2d_i32.c;   MTY=i32;  CTY=int;         KIND_DEF="-DCTYPE_KIND_INT"; SYM_SUFFIX="_i32";;
+  i16)  SRC=$EXT/conv2d_i16.c;   MTY=i16;  CTY=short;       KIND_DEF="-DCTYPE_KIND_INT"; SYM_SUFFIX="_i16";;
+  i8)   SRC=$EXT/conv2d_i8.c;    MTY=i8;   CTY=int8_t;      KIND_DEF="-DCTYPE_KIND_INT"; SYM_SUFFIX="_i8";;
+  f16)
+    echo "f16 not yet supported via cgeist (BuiltinType _Float16 unhandled in clang-mlir.cc)"; exit 2;;
+  bf16)
+    echo "bf16 not yet supported via cgeist"; exit 2;;
+  *) echo "unknown dtype: $DTYPE"; exit 1;;
+esac
+
+[ -f "$SRC" ] || { echo "missing source $SRC"; exit 1; }
+
+echo "[conv2d/$DTYPE/$SIZE] (1) cgeist → affine MLIR"
+cgeist $SRC --function=kernel_conv2d --resource-dir=/usr/lib/clang/14 \
+    -DNI=$SIZE -DNJ=$SIZE --raise-scf-to-affine -fPIC -S \
+    -o $OUT/orig.mlir 2>/dev/null
+
+echo "[conv2d/$DTYPE/$SIZE] (2) raise + lower-submap"
+polygeist-opt --select-func=func-name=kernel_conv2d \
+    --remove-iter-args --affine-parallelize \
+    --raise-affine-to-linalg-pipeline --lower-polygeist-submap \
+    $OUT/orig.mlir -o $OUT/linalg.mlir 2>$OUT/raise.err
+
+echo "[conv2d/$DTYPE/$SIZE] (3) kernel-match"
+PYTHON=$PYTHON
+$PYTHON $SCRIPTS/kernel_match_rewrite.py $OUT/linalg.mlir > $OUT/matched.mlir 2>$OUT/match.err
+SYM="@cudnnConvolution2D_9tap${SYM_SUFFIX}"
+N_LAUNCH=$(grep -c "$SYM" $OUT/matched.mlir || true)
+[ "${N_LAUNCH:-0}" -ge 1 ] || { echo "  FAIL: matcher didn't emit $SYM launch"; exit 1; }
+echo "  matched $N_LAUNCH ${SYM} launch(es)"
+
+echo "[conv2d/$DTYPE/$SIZE] (4) inject dtype defn"
+awk -v mty=$MTY -v sfx=$SYM_SUFFIX '/^module/ && !done{
+       print;
+       printf "  kernel.defn @cudnnConvolution2D_9tap%s(", sfx;
+       for (k=0;k<10;k++) {
+         printf "%%a%d: memref>%s", k, mty, (k<9?", ":"");
+       }
+       printf ", ";
+       for (k=0;k<9;k++) {
+         printf "%%w%d: %s%s", k, mty, (k<8?", ":"");
+       }
+       print ") { kernel.yield }";
+       done=1; next
+     }{print}' $OUT/matched.mlir > $OUT/matched_with_defn.mlir
+
+echo "[conv2d/$DTYPE/$SIZE] (5) lower-kernel-launch-to-{cublas,pva}"
+# Run both backend lowering passes. They handle disjoint launch symbols
+# (cuBLAS owns gemm + non-int conv; PVA owns int8/int16 conv). Order
+# doesn't matter — each pass skips launches the other claims.
+polygeist-opt --lower-kernel-launch-to-cublas --lower-kernel-launch-to-pva \
+    $OUT/matched_with_defn.mlir -o $OUT/abi.mlir 2>$OUT/abi.err
+
+echo "[conv2d/$DTYPE/$SIZE] (6) lower to LLVM, translate, retarget aarch64"
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+MLIR_TRANSLATE=$REPO_ROOT/llvm-project/build/bin/mlir-translate
+CLANG=$REPO_ROOT/llvm-project/build/bin/clang
+$MLIR_OPT --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \
+    --expand-strided-metadata \
+    --convert-arith-to-llvm --finalize-memref-to-llvm \
+    --convert-func-to-llvm --reconcile-unrealized-casts \
+    $OUT/abi.mlir -o $OUT/llvm.mlir 2>$OUT/mlir.err
+$MLIR_TRANSLATE --mlir-to-llvmir $OUT/llvm.mlir -o $OUT/kernel.ll
+sed -i 's|target triple = "x86_64.*"|target triple = "aarch64-linux-gnu"|;
+        /^target datalayout/d;
+        s/@kernel_conv2d\b/@kernel_conv2d_impl/g' $OUT/kernel.ll
+$CLANG --target=aarch64-linux-gnu --gcc-toolchain=/usr \
+    -O3 -c $OUT/kernel.ll -o $OUT/kernel.o 2>&1 | tail -1
+
+echo "[conv2d/$DTYPE/$SIZE] (7) cross-compile harness + wrapper + runtimes"
+ARCH_FLAGS="-march=armv8.2-a+fp16+bf16"
+DEFS="-DNI=$SIZE -DNJ=$SIZE -DCTYPE=$CTY $KIND_DEF"
+
+# PVA Solutions paths used for the i8/i16 dtypes (the PVA backend shim
+# polygeist_pva_rt.c needs the gated-SDK headers; the .so libraries are
+# staged on the Jetson at /tmp/pva_libs/ from the dev box copies).
+PVASOL_INC=${PVASOL_INC:-$PVASOL_ROOT/public/src/operator/include}
+NVCV_INC=${NVCV_INC:-$CV_CUDA_ROOT/src/nvcv/src/include}
+CUPVA_INC=${CUPVA_INC:-$CUPVA_SDK_ROOT/include}
+PVA_LIB_STAGE=${PVA_LIB_STAGE:-$HOME/pva_libs}  # contains libpva_operator/libcupva_host/libnvcv_types/libcvcuda
+JET_PVA_LIB=/tmp/pva_libs           # where the harness expects them at runtime
+
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS $DEFS -c $SCRIPTS/conv2d_main_harness_dtype.c -o $OUT/main.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -DCTYPE=$CTY -c $SCRIPTS/conv2d_jetson_wrapper_dtype.c -o $OUT/wrapper.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -I$CUDA/include -I$CUDNN_INC -c $RT/polygeist_cublas_rt_cuda.c -o $OUT/rt_cuda.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -c $RT/polygeist_cublas_rt_cpu.c -o $OUT/rt_cpu.o
+
+# For i8/i16 the lowering routes to polygeist_pva_conv2d_3x3_i{8,16},
+# which the matching shim impl lives in polygeist_pva_rt.c. Compile it
+# in for those dtypes (and add the .so dependency to the link line below).
+PVA_OBJ=""; PVA_LINK=""
+if [ "$DTYPE" = "i8" ] || [ "$DTYPE" = "i16" ]; then
+    aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS \
+        -I$CUDA/include -I$PVASOL_INC -I$NVCV_INC -I$CUPVA_INC \
+        -c $RT/polygeist_pva_rt.c -o $OUT/rt_pva.o
+    PVA_OBJ="$OUT/rt_pva.o"
+    # Explicit NvSciBuf/NvSciSync linkage: libcupva_host.so depends on
+    # NvSciBuf*/NvSciSync* symbols, and the PVA backend's init constructors
+    # (which run BEFORE main) call them — so deferring with
+    # --allow-shlib-undefined results in a segfault during library init.
+    # The reference yolov5_pva_pbr binary has these as direct DT_NEEDEDs;
+    # we match that link contract.
+    # --no-as-needed forces the linker to keep the NvSciBuf/NvSciSync libs
+    # in DT_NEEDED even though main() doesn't reference them directly.
+    # libcupva_host's init constructors call into them; they must be loaded
+    # before libcupva_host's constructor runs.
+    PVA_LINK="-L$PVA_LIB_STAGE -lpva_operator -lcvcuda -lnvcv_types -lcupva_host \
+              -Wl,--no-as-needed \
+              -L$JETSON_NVIDIA_LIBS -lnvscibuf -lnvscisync \
+              -Wl,--as-needed"
+fi
+
+echo "[conv2d/$DTYPE/$SIZE] (8) link CUDA binary"
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/main.o $OUT/wrapper.o $OUT/kernel.o $OUT/rt_cuda.o $PVA_OBJ \
+    -L$CUDA/lib -L$CUDA/lib/stubs -L$CUDNN_LIB \
+    $PVA_LINK \
+    -lcudnn -lcublasLt -lcublas -lcudart -lm -lpthread -ldl -lstdc++ \
+    -Wl,--allow-shlib-undefined \
+    -Wl,-rpath,/usr/local/cuda/lib64:/usr/lib/aarch64-linux-gnu:/usr/lib/aarch64-linux-gnu/nvidia:${JET_PVA_LIB} \
+    -o $OUT/conv2d_jetson
+
+echo "[conv2d/$DTYPE/$SIZE] (9) link CPU-stub binary"
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/main.o $OUT/wrapper.o $OUT/kernel.o $OUT/rt_cpu.o \
+    -lm -lpthread -o $OUT/conv2d_jetson_cpustub
+
+echo ""
+echo "═══ ${DTYPE} ${SIZE}×${SIZE} binaries ═══"
+ls -la $OUT/conv2d_jetson $OUT/conv2d_jetson_cpustub
diff --git a/scripts/correctness/conv2d_jetson_wrapper.c b/scripts/correctness/conv2d_jetson_wrapper.c
new file mode 100644
index 000000000000..3d03671d209a
--- /dev/null
+++ b/scripts/correctness/conv2d_jetson_wrapper.c
@@ -0,0 +1,28 @@
+/* conv2d_jetson_wrapper.c — Jetson timing wrapper for extracted conv2d.
+ *
+ * The extracted kernel signature is:
+ *   void kernel_conv2d(int ni, int nj, double A[NI][NJ], double B[NI][NJ]);
+ *
+ * After MLIR lowering it becomes kernel_conv2d_impl with the memref
+ * descriptor expansion (each 2D memref unpacks into 7 args).
+ */
+#include 
+#include 
+
+extern void kernel_conv2d_impl(
+    int ni, int nj,
+    double *A_b, double *A_a, int64_t A_o, int64_t A_s0, int64_t A_s1, int64_t A_st0, int64_t A_st1,
+    double *B_b, double *B_a, int64_t B_o, int64_t B_s0, int64_t B_s1, int64_t B_st0, int64_t B_st1);
+
+extern void  polygeist_cublas_time_begin(void);
+extern double polygeist_cublas_time_end_ms(void);
+
+void kernel_conv2d(int ni, int nj, double *A, double *B) {
+  polygeist_cublas_time_begin();
+  kernel_conv2d_impl(ni, nj,
+                     A, A, 0, ni, nj, nj, 1,
+                     B, B, 0, ni, nj, nj, 1);
+  double ms = polygeist_cublas_time_end_ms();
+  fprintf(stderr, "POLYGEIST_TIMING: kernel_conv2d ni=%d nj=%d  %.3f ms\n",
+          ni, nj, ms);
+}
diff --git a/scripts/correctness/conv2d_jetson_wrapper_dtype.c b/scripts/correctness/conv2d_jetson_wrapper_dtype.c
new file mode 100644
index 000000000000..56bc648ea3ae
--- /dev/null
+++ b/scripts/correctness/conv2d_jetson_wrapper_dtype.c
@@ -0,0 +1,30 @@
+/* conv2d_jetson_wrapper_dtype.c — dtype-parameterized timing wrapper.
+ *
+ * Compile with -DCTYPE=. After MLIR lowering the kernel is
+ * `kernel_conv2d_impl` with the memref descriptor expansion (7 args per
+ * 2D memref).
+ */
+#include 
+#include 
+
+#ifndef CTYPE
+#define CTYPE double
+#endif
+
+extern void kernel_conv2d_impl(
+    int ni, int nj,
+    CTYPE *A_b, CTYPE *A_a, int64_t A_o, int64_t A_s0, int64_t A_s1, int64_t A_st0, int64_t A_st1,
+    CTYPE *B_b, CTYPE *B_a, int64_t B_o, int64_t B_s0, int64_t B_s1, int64_t B_st0, int64_t B_st1);
+
+extern void  polygeist_cublas_time_begin(void);
+extern double polygeist_cublas_time_end_ms(void);
+
+void kernel_conv2d(int ni, int nj, CTYPE *A, CTYPE *B) {
+  polygeist_cublas_time_begin();
+  kernel_conv2d_impl(ni, nj,
+                     A, A, 0, ni, nj, nj, 1,
+                     B, B, 0, ni, nj, nj, 1);
+  double ms = polygeist_cublas_time_end_ms();
+  fprintf(stderr, "POLYGEIST_TIMING: kernel_conv2d ni=%d nj=%d  %.3f ms\n",
+          ni, nj, ms);
+}
diff --git a/scripts/correctness/conv2d_main_harness.c b/scripts/correctness/conv2d_main_harness.c
new file mode 100644
index 000000000000..4b197afc09b8
--- /dev/null
+++ b/scripts/correctness/conv2d_main_harness.c
@@ -0,0 +1,51 @@
+/* conv2d_main_harness.c — minimal main for the extracted conv2d kernel.
+ *
+ * The polybenchGpu-extracted/conv2d.c file has no main (that's the point of
+ * the extraction). We provide a minimal one that initialises A with the
+ * polybench-style A[i][j] = (i+j)/nj formula, calls kernel_conv2d, and
+ * dumps the interior of B to stderr so a diff vs a reference build can
+ * confirm correctness.
+ */
+#include 
+#include 
+#include 
+
+#ifndef NI
+#define NI 256
+#endif
+#ifndef NJ
+#define NJ 256
+#endif
+
+extern void kernel_conv2d(int ni, int nj, double *A, double *B);
+
+int main(int argc, char **argv) {
+  int ni = NI, nj = NJ;
+  /* Heap-allocate so we don't blow the stack for larger NI/NJ. */
+  double *A = (double*)malloc((size_t)ni * (size_t)nj * sizeof(double));
+  double *B = (double*)malloc((size_t)ni * (size_t)nj * sizeof(double));
+  if (!A || !B) { fprintf(stderr, "alloc failed\n"); return 1; }
+
+  /* Init A[i][j] = (i + j) / nj  — same as polybench's init_array. */
+  for (int i = 0; i < ni; ++i)
+    for (int j = 0; j < nj; ++j)
+      A[(size_t)i * (size_t)nj + (size_t)j] = ((double)(i + j)) / (double)nj;
+  memset(B, 0, (size_t)ni * (size_t)nj * sizeof(double));
+
+  kernel_conv2d(ni, nj, A, B);
+
+  /* Dump interior of B (skip border) to stderr — polybench-style. */
+  fprintf(stderr, "==BEGIN DUMP_ARRAYS==\n");
+  fprintf(stderr, "begin dump: B\n");
+  for (int i = 1; i < ni - 1; ++i) {
+    for (int j = 1; j < nj - 1; ++j) {
+      if (((i - 1) * (nj - 2) + (j - 1)) % 20 == 0) fprintf(stderr, "\n");
+      fprintf(stderr, "%0.2lf ", B[(size_t)i * (size_t)nj + (size_t)j]);
+    }
+  }
+  fprintf(stderr, "\nend   dump: B\n");
+  fprintf(stderr, "==END   DUMP_ARRAYS==\n");
+
+  free(A); free(B);
+  return 0;
+}
diff --git a/scripts/correctness/conv2d_main_harness_dtype.c b/scripts/correctness/conv2d_main_harness_dtype.c
new file mode 100644
index 000000000000..3dd5e190ea3c
--- /dev/null
+++ b/scripts/correctness/conv2d_main_harness_dtype.c
@@ -0,0 +1,69 @@
+/* conv2d_main_harness_dtype.c — dtype-parameterized main for the extracted
+ * conv2d kernel. Compile with -DCTYPE= (e.g. -DCTYPE=int or
+ * -DCTYPE=short) and -DFMT= (e.g. -DFMT='\"%d \"'). Falls back
+ * to double + %.2lf when nothing is defined, matching the original f64
+ * harness's behavior.
+ *
+ * Initialises A with a deterministic, dtype-appropriate fill, calls
+ * kernel_conv2d, and dumps the interior of B to stderr.
+ */
+#include 
+#include 
+#include 
+#include 
+
+#ifndef NI
+#define NI 256
+#endif
+#ifndef NJ
+#define NJ 256
+#endif
+
+#ifndef CTYPE
+#define CTYPE double
+#endif
+
+/* Pick a sensible printf format from CTYPE_KIND. Caller defines exactly one
+ * of -DCTYPE_KIND_INT, -DCTYPE_KIND_FLOAT, -DCTYPE_KIND_HALF; default is
+ * float-style. Avoids the shell-quoting nightmare of passing a format
+ * string through a -D macro. */
+#if defined(CTYPE_KIND_INT)
+  #define FMT "%d "
+#elif defined(CTYPE_KIND_HALF)
+  #define FMT "%.3f "
+#else
+  #define FMT "%.2f "
+#endif
+
+extern void kernel_conv2d(int ni, int nj, CTYPE *A, CTYPE *B);
+
+int main(int argc, char **argv) {
+  int ni = NI, nj = NJ;
+  CTYPE *A = (CTYPE*)malloc((size_t)ni * (size_t)nj * sizeof(CTYPE));
+  CTYPE *B = (CTYPE*)malloc((size_t)ni * (size_t)nj * sizeof(CTYPE));
+  if (!A || !B) { fprintf(stderr, "alloc failed\n"); return 1; }
+
+  /* Init A[i][j] = ((i+j) % 16) — small bounded values so int kernels don't
+   * overflow at this NJ. For float dtypes this gives the same input domain
+   * as the polybench (i+j)/nj formula up to a constant scale. */
+  for (int i = 0; i < ni; ++i)
+    for (int j = 0; j < nj; ++j)
+      A[(size_t)i * (size_t)nj + (size_t)j] = (CTYPE)((i + j) % 16);
+  memset(B, 0, (size_t)ni * (size_t)nj * sizeof(CTYPE));
+
+  kernel_conv2d(ni, nj, A, B);
+
+  fprintf(stderr, "==BEGIN DUMP_ARRAYS==\n");
+  fprintf(stderr, "begin dump: B\n");
+  for (int i = 1; i < ni - 1; ++i) {
+    for (int j = 1; j < nj - 1; ++j) {
+      if (((i - 1) * (nj - 2) + (j - 1)) % 20 == 0) fprintf(stderr, "\n");
+      fprintf(stderr, FMT, B[(size_t)i * (size_t)nj + (size_t)j]);
+    }
+  }
+  fprintf(stderr, "\nend   dump: B\n");
+  fprintf(stderr, "==END   DUMP_ARRAYS==\n");
+
+  free(A); free(B);
+  return 0;
+}
diff --git a/scripts/correctness/conv_bias_relu_add_batched_jetson_harness.c b/scripts/correctness/conv_bias_relu_add_batched_jetson_harness.c
new file mode 100644
index 000000000000..1e4e43ba58b5
--- /dev/null
+++ b/scripts/correctness/conv_bias_relu_add_batched_jetson_harness.c
@@ -0,0 +1,130 @@
+/* Jetson harness for conv + bias + residual-add + relu (ResNet output). */
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#if defined(LARGE_DATASET)
+# define B  32
+# define IC 64
+# define OC 64
+# define H  56
+# define W  56
+# define KS 3
+#elif defined(MINI_DATASET)
+# define B  4
+# define IC 8
+# define OC 8
+# define H  32
+# define W  32
+# define KS 3
+#endif
+#ifndef B
+# define B 4
+#endif
+#ifndef IC
+# define IC 8
+#endif
+#ifndef OC
+# define OC 8
+#endif
+#ifndef H
+# define H 32
+#endif
+#ifndef W
+# define W 32
+#endif
+#ifndef KS
+# define KS 3
+#endif
+#define OH (H - KS + 1)
+#define OW (W - KS + 1)
+
+extern void kernel_conv_bias_relu_add_batched_impl(
+    float *A_b,  float *A_a,  int64_t A_o,
+    int64_t A_s0, int64_t A_s1, int64_t A_s2, int64_t A_s3,
+    int64_t A_t0, int64_t A_t1, int64_t A_t2, int64_t A_t3,
+    float *F_b,  float *F_a,  int64_t F_o,
+    int64_t F_s0, int64_t F_s1, int64_t F_s2, int64_t F_s3,
+    int64_t F_t0, int64_t F_t1, int64_t F_t2, int64_t F_t3,
+    float *Bi_b, float *Bi_a, int64_t Bi_o, int64_t Bi_sz, int64_t Bi_st,
+    float *Z_b,  float *Z_a,  int64_t Z_o,
+    int64_t Z_s0, int64_t Z_s1, int64_t Z_s2, int64_t Z_s3,
+    int64_t Z_t0, int64_t Z_t1, int64_t Z_t2, int64_t Z_t3,
+    float *O_b,  float *O_a,  int64_t O_o,
+    int64_t O_s0, int64_t O_s1, int64_t O_s2, int64_t O_s3,
+    int64_t O_t0, int64_t O_t1, int64_t O_t2, int64_t O_t3);
+
+extern void   polygeist_cublas_time_begin(void);
+extern double polygeist_cublas_time_end_ms(void);
+
+static void run_kernel(float *A, float *F, float *bias, float *Z, float *Bout) {
+  polygeist_cublas_time_begin();
+  kernel_conv_bias_relu_add_batched_impl(
+      A, A, 0,
+      (int64_t)B, (int64_t)IC, (int64_t)H, (int64_t)W,
+      (int64_t)(IC*H*W), (int64_t)(H*W), (int64_t)W, 1,
+      F, F, 0,
+      (int64_t)OC, (int64_t)IC, (int64_t)KS, (int64_t)KS,
+      (int64_t)(IC*KS*KS), (int64_t)(KS*KS), (int64_t)KS, 1,
+      bias, bias, 0, (int64_t)OC, 1,
+      Z, Z, 0,
+      (int64_t)B, (int64_t)OC, (int64_t)OH, (int64_t)OW,
+      (int64_t)(OC*OH*OW), (int64_t)(OH*OW), (int64_t)OW, 1,
+      Bout, Bout, 0,
+      (int64_t)B, (int64_t)OC, (int64_t)OH, (int64_t)OW,
+      (int64_t)(OC*OH*OW), (int64_t)(OH*OW), (int64_t)OW, 1);
+  double ms = polygeist_cublas_time_end_ms();
+  fprintf(stderr,
+      "POLYGEIST_TIMING: conv_bias_relu_add_batched B=%d IC=%d OC=%d "
+      "H=%d W=%d K=%d  %.3f ms\n",
+      B, IC, OC, H, W, KS, ms);
+}
+
+int main(void) {
+  size_t nA = (size_t)B*IC*H*W,
+         nF = (size_t)OC*IC*KS*KS,
+         nO = (size_t)B*OC*OH*OW;
+  float *A    = (float *)malloc(nA * sizeof(float));
+  float *F    = (float *)malloc(nF * sizeof(float));
+  float *O    = (float *)malloc(nO * sizeof(float));
+  float *Z    = (float *)malloc(nO * sizeof(float));
+  float *bias = (float *)malloc(OC * sizeof(float));
+  if (!A || !F || !O || !Z || !bias) { fprintf(stderr, "alloc failed\n"); return 1; }
+
+  for (int b = 0; b < B; ++b)
+    for (int c = 0; c < IC; ++c)
+      for (int i = 0; i < H; ++i)
+        for (int j = 0; j < W; ++j)
+          A[((size_t)b*IC + c)*H*W + (size_t)i*W + j] =
+              (float)((b + c + i + j) % 17) / 17.0f - 0.5f;
+  for (int oc = 0; oc < OC; ++oc)
+    for (int c = 0; c < IC; ++c)
+      for (int i = 0; i < KS; ++i)
+        for (int j = 0; j < KS; ++j)
+          F[((size_t)oc*IC + c)*KS*KS + (size_t)i*KS + j] =
+              ((float)((oc*3 + c*5 + i*7 + j) % 11) / 11.0f) - 0.5f;
+  for (int oc = 0; oc < OC; ++oc)
+    bias[oc] = 0.01f * (float)oc;
+  for (size_t k = 0; k < nO; ++k)
+    Z[k] = (float)((k * 23) % 31) / 31.0f - 0.5f;
+  memset(O, 0, nO * sizeof(float));
+
+  run_kernel(A, F, bias, Z, O);
+
+  double sum = 0;
+  size_t nz = 0;
+  for (size_t k = 0; k < nO; ++k) { sum += O[k]; if (O[k] == 0.0f) ++nz; }
+  fprintf(stderr, "CHECKSUM: %.6f over %zu elems, %zu zeroed (%.1f%%)\n",
+          sum, nO, nz, 100.0 * (double)nz / (double)nO);
+  fprintf(stderr, "==BEGIN DUMP_ARRAYS==\n");
+  for (size_t k = 0; k < nO; ++k) {
+    if (k % 19 == 0) fprintf(stderr, "\n");
+    fprintf(stderr, "%0.4f ", O[k]);
+  }
+  fprintf(stderr, "\n==END   DUMP_ARRAYS==\n");
+
+  free(A); free(F); free(O); free(Z); free(bias);
+  return 0;
+}
diff --git a/scripts/correctness/conv_bn_relu_batched_jetson_harness.c b/scripts/correctness/conv_bn_relu_batched_jetson_harness.c
new file mode 100644
index 000000000000..d7faa0eba931
--- /dev/null
+++ b/scripts/correctness/conv_bn_relu_batched_jetson_harness.c
@@ -0,0 +1,143 @@
+/* conv_bn_relu_batched_jetson_harness.c — Jetson harness for the fused
+ * conv + bn (inference) + relu pattern. */
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#if defined(LARGE_DATASET)
+# define B  32
+# define IC 64
+# define OC 64
+# define H  56
+# define W  56
+# define KS 3
+#elif defined(MINI_DATASET)
+# define B  4
+# define IC 8
+# define OC 8
+# define H  32
+# define W  32
+# define KS 3
+#endif
+#ifndef B
+# define B 4
+#endif
+#ifndef IC
+# define IC 8
+#endif
+#ifndef OC
+# define OC 8
+#endif
+#ifndef H
+# define H 32
+#endif
+#ifndef W
+# define W 32
+#endif
+#ifndef KS
+# define KS 3
+#endif
+#define OH (H - KS + 1)
+#define OW (W - KS + 1)
+#define EPS 1e-5f
+
+extern void kernel_conv_bn_relu_batched_impl(
+    float *A_b,  float *A_a,  int64_t A_o,
+    int64_t A_s0, int64_t A_s1, int64_t A_s2, int64_t A_s3,
+    int64_t A_t0, int64_t A_t1, int64_t A_t2, int64_t A_t3,
+    float *F_b,  float *F_a,  int64_t F_o,
+    int64_t F_s0, int64_t F_s1, int64_t F_s2, int64_t F_s3,
+    int64_t F_t0, int64_t F_t1, int64_t F_t2, int64_t F_t3,
+    float *S_b,  float *S_a,  int64_t S_o, int64_t S_sz, int64_t S_st,
+    float *M_b,  float *M_a,  int64_t M_o, int64_t M_sz, int64_t M_st,
+    float *I_b,  float *I_a,  int64_t I_o, int64_t I_sz, int64_t I_st,
+    float *Bi_b, float *Bi_a, int64_t Bi_o, int64_t Bi_sz, int64_t Bi_st,
+    float *O_b,  float *O_a,  int64_t O_o,
+    int64_t O_s0, int64_t O_s1, int64_t O_s2, int64_t O_s3,
+    int64_t O_t0, int64_t O_t1, int64_t O_t2, int64_t O_t3);
+
+extern void   polygeist_cublas_time_begin(void);
+extern double polygeist_cublas_time_end_ms(void);
+
+static void run_kernel(float *A, float *F, float *scale, float *mean,
+                        float *invst, float *bias, float *Bout) {
+  polygeist_cublas_time_begin();
+  kernel_conv_bn_relu_batched_impl(
+      A, A, 0,
+      (int64_t)B, (int64_t)IC, (int64_t)H, (int64_t)W,
+      (int64_t)(IC*H*W), (int64_t)(H*W), (int64_t)W, 1,
+      F, F, 0,
+      (int64_t)OC, (int64_t)IC, (int64_t)KS, (int64_t)KS,
+      (int64_t)(IC*KS*KS), (int64_t)(KS*KS), (int64_t)KS, 1,
+      scale, scale, 0, (int64_t)OC, 1,
+      mean,  mean,  0, (int64_t)OC, 1,
+      invst, invst, 0, (int64_t)OC, 1,
+      bias,  bias,  0, (int64_t)OC, 1,
+      Bout, Bout, 0,
+      (int64_t)B, (int64_t)OC, (int64_t)OH, (int64_t)OW,
+      (int64_t)(OC*OH*OW), (int64_t)(OH*OW), (int64_t)OW, 1);
+  double ms = polygeist_cublas_time_end_ms();
+  fprintf(stderr,
+      "POLYGEIST_TIMING: conv_bn_relu_batched B=%d IC=%d OC=%d "
+      "H=%d W=%d K=%d  %.3f ms\n",
+      B, IC, OC, H, W, KS, ms);
+}
+
+int main(void) {
+  size_t nA = (size_t)B*IC*H*W,
+         nF = (size_t)OC*IC*KS*KS,
+         nO = (size_t)B*OC*OH*OW;
+  float *A     = (float *)malloc(nA * sizeof(float));
+  float *F     = (float *)malloc(nF * sizeof(float));
+  float *O     = (float *)malloc(nO * sizeof(float));
+  float *scale = (float *)malloc(OC * sizeof(float));
+  float *mean  = (float *)malloc(OC * sizeof(float));
+  float *invst = (float *)malloc(OC * sizeof(float));
+  float *bias  = (float *)malloc(OC * sizeof(float));
+  if (!A || !F || !O || !scale || !mean || !invst || !bias) {
+    fprintf(stderr, "alloc failed\n"); return 1;
+  }
+
+  for (int b = 0; b < B; ++b)
+    for (int c = 0; c < IC; ++c)
+      for (int i = 0; i < H; ++i)
+        for (int j = 0; j < W; ++j)
+          A[((size_t)b*IC + c)*H*W + (size_t)i*W + j] =
+              (float)((b + c + i + j) % 17) / 17.0f - 0.5f;  /* zero-mean-ish */
+  for (int oc = 0; oc < OC; ++oc)
+    for (int c = 0; c < IC; ++c)
+      for (int i = 0; i < KS; ++i)
+        for (int j = 0; j < KS; ++j)
+          F[((size_t)oc*IC + c)*KS*KS + (size_t)i*KS + j] =
+              ((float)((oc*3 + c*5 + i*7 + j) % 11) / 11.0f) - 0.5f;
+  for (int oc = 0; oc < OC; ++oc) {
+    scale[oc] = 0.5f + 0.1f * (float)oc;
+    mean[oc]  = 0.05f * (float)oc;
+    float var = 0.2f + 0.01f * (float)oc;
+    invst[oc] = 1.0f / sqrtf(var + EPS);
+    bias[oc]  = 0.01f * (float)oc;
+  }
+  memset(O, 0, nO * sizeof(float));
+
+  run_kernel(A, F, scale, mean, invst, bias, O);
+
+  double sum = 0;
+  size_t n_zero = 0;  /* relu activations that pinned to 0 */
+  for (size_t k = 0; k < nO; ++k) {
+    sum += O[k];
+    if (O[k] == 0.0f) n_zero++;
+  }
+  fprintf(stderr, "CHECKSUM: %.6f over %zu elems, %zu zeroed by ReLU (%.1f%%)\n",
+          sum, nO, n_zero, 100.0 * (double)n_zero / (double)nO);
+  fprintf(stderr, "==BEGIN DUMP_ARRAYS==\n");
+  for (size_t k = 0; k < nO; ++k) {
+    if (k % 19 == 0) fprintf(stderr, "\n");
+    fprintf(stderr, "%0.4f ", O[k]);
+  }
+  fprintf(stderr, "\n==END   DUMP_ARRAYS==\n");
+
+  free(A); free(F); free(O); free(scale); free(mean); free(invst); free(bias);
+  return 0;
+}
diff --git a/scripts/correctness/extracted_darknet_jetson.sh b/scripts/correctness/extracted_darknet_jetson.sh
new file mode 100755
index 000000000000..1c3982df2794
--- /dev/null
+++ b/scripts/correctness/extracted_darknet_jetson.sh
@@ -0,0 +1,127 @@
+#!/bin/bash
+# extracted_darknet_jetson.sh — cross-build a single extracted-darknet
+# kernel for Jetson Orin via the matched kernel.launch → cuDNN runtime
+# pipeline.
+#
+# Usage:
+#   ./extracted_darknet_jetson.sh  
+# Where KERNEL is one of: conv2d_batched, maxpool_batched,
+# batchnorm_batched, shortcut_batched. DATASET is MINI or LARGE.
+#
+# Output dir:  /tmp/extracted_darknet__/
+#   - _jetson         (aarch64 ELF, links libcudnn / libcublas / libcudart)
+#   - _jetson_cpustub (aarch64 ELF, CPU reference shim — no GPU)
+# Both binaries take no args; they init their inputs internally, run the
+# kernel once, print POLYGEIST_TIMING + CHECKSUM + DUMP_ARRAYS on stderr.
+
+set -euo pipefail
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+KERNEL="${1:-conv2d_batched}"
+DATASET="${2:-MINI}"
+
+case "$KERNEL" in
+  conv2d_batched|maxpool_batched|batchnorm_batched|shortcut_batched|conv_bn_relu_batched|conv_bias_relu_add_batched|gemm_bias_relu|ata_gemm|conv1x1_batched) ;;
+  *) echo "Unknown kernel '$KERNEL'. Choose from: conv2d_batched, maxpool_batched, batchnorm_batched, shortcut_batched, conv_bn_relu_batched, conv_bias_relu_add_batched, gemm_bias_relu, ata_gemm, conv1x1_batched" >&2; exit 2 ;;
+esac
+case "$DATASET" in MINI|LARGE) ;;
+  *) echo "DATASET must be MINI or LARGE (got '$DATASET')" >&2; exit 2 ;;
+esac
+
+SCRIPTS=$REPO_ROOT/scripts/correctness
+RT=$REPO_ROOT/runtime
+EXT=$REPO_ROOT/third_party/cnn-extracted
+OUT=/tmp/extracted_darknet_${KERNEL}_${DATASET}
+mkdir -p $OUT
+
+CUDA=/usr/local/cuda-12.6/targets/sbsa-linux
+CUDNN_INC=/usr/include/aarch64-linux-gnu
+CUDNN_LIB=/usr/lib/aarch64-linux-gnu
+
+DEF=""
+[ "$DATASET" = "LARGE" ] && DEF="-DLARGE_DATASET"
+[ "$DATASET" = "MINI"  ] && DEF="-DMINI_DATASET"
+
+KERN_FN="kernel_${KERNEL}"
+
+echo "[$KERNEL/$DATASET] (1) cgeist → affine MLIR"
+cgeist $EXT/${KERNEL}.c --function=$KERN_FN \
+       --resource-dir=/usr/lib/clang/14 $DEF \
+       --raise-scf-to-affine -fPIC -S \
+       -o $OUT/orig.mlir 2>$OUT/cgeist.err
+
+echo "[$KERNEL/$DATASET] (2) raise + debufferize"
+polygeist-opt --select-func=func-name=$KERN_FN \
+    --remove-iter-args --affine-parallelize \
+    --raise-affine-to-linalg-pipeline \
+    $OUT/orig.mlir 2>$OUT/raise.err |
+polygeist-opt --linalg-debufferize -o $OUT/linalg.mlir 2>>$OUT/raise.err
+
+echo "[$KERNEL/$DATASET] (3) kernel-match"
+PYTHON=$PYTHON
+[ -x "$PYTHON" ] || PYTHON=$(command -v python3)
+$PYTHON $SCRIPTS/kernel_match_rewrite.py $OUT/linalg.mlir > $OUT/matched.mlir 2>$OUT/match.err
+N_LAUNCH=$(grep -c 'kernel.launch' $OUT/matched.mlir || true)
+[ "${N_LAUNCH:-0}" -ge 1 ] || { echo "  FAIL: no matcher hits"; exit 1; }
+echo "  matched $N_LAUNCH kernel.launch op(s)"
+
+echo "[$KERNEL/$DATASET] (4) inject kernel.defn"
+$PYTHON /tmp/cnn_mlir/inject_defns.py $OUT/matched.mlir $OUT/matched_with_defn.mlir
+
+echo "[$KERNEL/$DATASET] (4b) cleanup orphan submapInverse"
+$PYTHON /tmp/cnn_mlir/cleanup_orphans.py $OUT/matched_with_defn.mlir $OUT/cleaned.mlir
+
+echo "[$KERNEL/$DATASET] (5) lower-kernel-launch-to-cublas"
+polygeist-opt --lower-kernel-launch-to-cublas \
+    $OUT/cleaned.mlir -o $OUT/abi.mlir 2>$OUT/abi.err
+
+echo "[$KERNEL/$DATASET] (6) lower polygeist.submap + MLIR → LLVM IR, retarget aarch64"
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+MLIR_TRANSLATE=$REPO_ROOT/llvm-project/build/bin/mlir-translate
+CLANG=$REPO_ROOT/llvm-project/build/bin/clang
+# After ABI lowering the launch is gone but residual polygeist.submap /
+# submapInverse ops are still there (their results were rewired by the
+# lowering helper, so they're now DCE-able pure ops). Run polygeist-opt
+# with --canonicalize first so they vanish before mlir-opt sees them
+# (mlir-opt doesn't know the polygeist dialect).
+polygeist-opt --canonicalize --cse --lower-polygeist-submap --canonicalize --cse \
+    $OUT/abi.mlir -o $OUT/abi_canon.mlir 2>>$OUT/abi.err
+$MLIR_OPT --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \
+    --expand-strided-metadata \
+    --convert-arith-to-llvm --finalize-memref-to-llvm \
+    --convert-func-to-llvm --reconcile-unrealized-casts \
+    $OUT/abi_canon.mlir -o $OUT/llvm.mlir 2>$OUT/mlir.err
+$MLIR_TRANSLATE --mlir-to-llvmir $OUT/llvm.mlir -o $OUT/kernel.ll
+sed -i 's|target triple = "x86_64.*"|target triple = "aarch64-linux-gnu"|;
+        /^target datalayout/d;
+        s/@'$KERN_FN'\b/@'$KERN_FN'_impl/g' $OUT/kernel.ll
+$CLANG --target=aarch64-linux-gnu --gcc-toolchain=/usr \
+    -O3 -c $OUT/kernel.ll -o $OUT/kernel.o 2>&1 | tail -3
+
+echo "[$KERNEL/$DATASET] (7) harness + runtime"
+ARCH_FLAGS="-march=armv8.2-a+fp16+bf16"
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS $DEF \
+    -c $SCRIPTS/${KERNEL}_jetson_harness.c -o $OUT/main.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -I$CUDA/include -I$CUDNN_INC \
+    -c $RT/polygeist_cublas_rt_cuda.c -o $OUT/rt_cuda.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS \
+    -c $RT/polygeist_cublas_rt_cpu.c -o $OUT/rt_cpu.o
+
+echo "[$KERNEL/$DATASET] (8) link CUDA binary"
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/main.o $OUT/kernel.o $OUT/rt_cuda.o \
+    -L$CUDA/lib -L$CUDA/lib/stubs -L$CUDNN_LIB \
+    -lcudnn -lcublasLt -lcublas -lcudart -lm -lpthread -ldl \
+    -Wl,-rpath,/usr/local/cuda/lib64:/usr/lib/aarch64-linux-gnu \
+    -o $OUT/${KERNEL}_jetson
+
+echo "[$KERNEL/$DATASET] (9) link CPU-stub binary"
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/main.o $OUT/kernel.o $OUT/rt_cpu.o \
+    -lm -lpthread -o $OUT/${KERNEL}_jetson_cpustub
+
+echo ""
+echo "═══ ${KERNEL} / ${DATASET} ═══"
+ls -la $OUT/${KERNEL}_jetson $OUT/${KERNEL}_jetson_cpustub
+aarch64-linux-gnu-readelf -d $OUT/${KERNEL}_jetson | grep -E 'libcudnn|libcublas|libcudart' | head -4
diff --git a/scripts/correctness/gemm_bias_relu_jetson_harness.c b/scripts/correctness/gemm_bias_relu_jetson_harness.c
new file mode 100644
index 000000000000..56cb89b685c0
--- /dev/null
+++ b/scripts/correctness/gemm_bias_relu_jetson_harness.c
@@ -0,0 +1,82 @@
+/* Jetson harness for fused gemm + bias + relu (cublasLt epilogue). */
+#include 
+#include 
+#include 
+#include 
+
+#if defined(LARGE_DATASET)
+# define M 2048
+# define N 2048
+# define K 2048
+#elif defined(MINI_DATASET)
+# define M 64
+# define N 64
+# define K 64
+#endif
+#ifndef M
+# define M 64
+#endif
+#ifndef N
+# define N 64
+#endif
+#ifndef K
+# define K 64
+#endif
+
+extern void kernel_gemm_bias_relu_impl(
+    float *A_b, float *A_a, int64_t A_o,
+    int64_t A_s0, int64_t A_s1, int64_t A_t0, int64_t A_t1,
+    float *B_b, float *B_a, int64_t B_o,
+    int64_t B_s0, int64_t B_s1, int64_t B_t0, int64_t B_t1,
+    float *Bi_b, float *Bi_a, int64_t Bi_o, int64_t Bi_sz, int64_t Bi_st,
+    float *C_b, float *C_a, int64_t C_o,
+    int64_t C_s0, int64_t C_s1, int64_t C_t0, int64_t C_t1);
+
+extern void   polygeist_cublas_time_begin(void);
+extern double polygeist_cublas_time_end_ms(void);
+
+static void run_kernel(float *A, float *B, float *bias, float *C) {
+  polygeist_cublas_time_begin();
+  kernel_gemm_bias_relu_impl(
+      A, A, 0, (int64_t)M, (int64_t)K, (int64_t)K, 1,
+      B, B, 0, (int64_t)K, (int64_t)N, (int64_t)N, 1,
+      bias, bias, 0, (int64_t)N, 1,
+      C, C, 0, (int64_t)M, (int64_t)N, (int64_t)N, 1);
+  double ms = polygeist_cublas_time_end_ms();
+  fprintf(stderr,
+      "POLYGEIST_TIMING: gemm_bias_relu M=%d N=%d K=%d  %.3f ms\n",
+      M, N, K, ms);
+}
+
+int main(void) {
+  size_t nA = (size_t)M*K, nB = (size_t)K*N, nC = (size_t)M*N;
+  float *A    = (float *)malloc(nA * sizeof(float));
+  float *B    = (float *)malloc(nB * sizeof(float));
+  float *C    = (float *)malloc(nC * sizeof(float));
+  float *bias = (float *)malloc(N * sizeof(float));
+  if (!A || !B || !C || !bias) { fprintf(stderr, "alloc failed\n"); return 1; }
+
+  for (size_t k = 0; k < nA; ++k)
+    A[k] = (float)((k * 17) % 31) / 31.0f - 0.5f;
+  for (size_t k = 0; k < nB; ++k)
+    B[k] = (float)((k * 23) % 37) / 37.0f - 0.5f;
+  for (int n = 0; n < N; ++n)
+    bias[n] = 0.01f * (float)n - 0.1f;
+  memset(C, 0, nC * sizeof(float));
+
+  run_kernel(A, B, bias, C);
+
+  double sum = 0; size_t nz = 0;
+  for (size_t k = 0; k < nC; ++k) { sum += C[k]; if (C[k] == 0.0f) ++nz; }
+  fprintf(stderr, "CHECKSUM: %.6f over %zu elems, %zu zeroed (%.1f%%)\n",
+          sum, nC, nz, 100.0 * (double)nz / (double)nC);
+  fprintf(stderr, "==BEGIN DUMP_ARRAYS==\n");
+  for (size_t k = 0; k < nC; ++k) {
+    if (k % 19 == 0) fprintf(stderr, "\n");
+    fprintf(stderr, "%0.4f ", C[k]);
+  }
+  fprintf(stderr, "\n==END   DUMP_ARRAYS==\n");
+
+  free(A); free(B); free(C); free(bias);
+  return 0;
+}
diff --git a/scripts/correctness/gemm_cublas_e2e.sh b/scripts/correctness/gemm_cublas_e2e.sh
new file mode 100755
index 000000000000..3280ac71d5a8
--- /dev/null
+++ b/scripts/correctness/gemm_cublas_e2e.sh
@@ -0,0 +1,143 @@
+#!/bin/bash
+# gemm_cublas_e2e.sh — end-to-end test of the Phase-2 cuBLAS-ABI lowering.
+#
+# Pipeline:
+#   1. C source                        (gemm.c, MINI_DATASET)
+#   2. cgeist                          → affine MLIR
+#   3. polygeist-opt raise + debuf     → tensor-form linalg.generic
+#   4. kernel_match_rewrite.py         → tensor-form with kernel.launch ops
+#   5. polygeist-opt --lower-kernel-launch-to-cublas
+#                                       → tensor-form with func.call to
+#                                         polygeist_cublas_dgemm (runtime shim)
+#   6. mlir-opt one-shot-bufferize + std lowerings → LLVM dialect
+#   7. mlir-translate                  → LLVM IR
+#   8. clang -c                        → kernel.o
+#   9. link with polygeist_cublas_rt_cpu.o (CPU stub) + polybench harness
+#  10. run, diff vs clang -O0 reference
+#
+# On a real GPU/Jetson, swap step 9 to link against polygeist_cublas_rt_cuda.o
+# + -lcublas -lcudart (see build_jetson.sh).
+#
+# Pass = "matched kernel.launch through cuBLAS-ABI runtime shim produces the
+# same numeric output as the clang reference build".
+
+set -euo pipefail
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+MLIR_TRANSLATE=$REPO_ROOT/llvm-project/build/bin/mlir-translate
+CLANG=$REPO_ROOT/llvm-project/build/bin/clang
+PYTHON=$PYTHON
+SCRIPTS=$REPO_ROOT/scripts/correctness
+RT=$REPO_ROOT/runtime
+
+POLYBENCH_DIR=$REPO_ROOT/tools/cgeist/Test/polybench
+UTIL=$POLYBENCH_DIR/utilities
+GEMM_DIR=$POLYBENCH_DIR/linear-algebra/blas/gemm
+
+OUT=/tmp/gemm_cublas_test
+mkdir -p $OUT
+
+DATASET=-DMINI_DATASET
+CFLAGS="-O1 -I$UTIL -I$GEMM_DIR -DDATA_TYPE_IS_DOUBLE -DPOLYBENCH_DUMP_ARRAYS $DATASET"
+DYN_FLAGS="-Dstatic= -DPOLYBENCH_USE_C99_PROTO"
+
+echo "=== 1. Reference: clang -O0 directly ==="
+$CLANG $CFLAGS $DYN_FLAGS \
+  $GEMM_DIR/gemm.c $UTIL/polybench.c -lm -o $OUT/ref_exe
+$OUT/ref_exe 2> $OUT/ref.out
+wc -l $OUT/ref.out
+
+echo "=== 2. Test pipeline ==="
+echo "  a) cgeist gemm.c -> affine MLIR"
+cgeist $GEMM_DIR/gemm.c --function=kernel_gemm --resource-dir=/usr/lib/clang/14 \
+  $CFLAGS $DYN_FLAGS --raise-scf-to-affine -S -o $OUT/gemm_orig.mlir 2>/dev/null
+grep -c "func.func @kernel_gemm" $OUT/gemm_orig.mlir > /dev/null
+
+echo "  b) raise + lower-submap + debufferize"
+polygeist-opt --select-func=func-name=kernel_gemm \
+  --remove-iter-args --affine-parallelize \
+  --raise-affine-to-linalg-pipeline \
+  --lower-polygeist-submap \
+  --linalg-debufferize \
+  $OUT/gemm_orig.mlir -o $OUT/gemm_debuf.mlir 2>$OUT/raise.err
+if grep -qE "polygeist\.(submap|submapInverse)" $OUT/gemm_debuf.mlir; then
+  echo "  FAIL: polygeist ops remain after lower-submap"; exit 1
+fi
+
+echo "  c) kernel-match (linalg -> kernel.launch)"
+$PYTHON $SCRIPTS/kernel_match_rewrite.py \
+  $OUT/gemm_debuf.mlir > $OUT/gemm_matched.mlir 2>$OUT/match.err
+N_LAUNCH=$(grep -c '= kernel\.launch ' $OUT/gemm_matched.mlir || echo 0)
+echo "    matched ops: $N_LAUNCH kernel.launch"
+if [ "$N_LAUNCH" -lt 1 ]; then
+  echo "  FAIL: expected at least 1 kernel.launch"; exit 1
+fi
+
+echo "  d) inject kernel.defn declaration (verifier needs the symbol to exist)"
+# The matched MLIR refers to @cublasDgemm but does not define it. Without a
+# `kernel.defn`, the parser's symbol-user verifier rejects the kernel.launch
+# ops. We inject a trivial defn body (just yields the C operand) — our pass
+# never reads the body, only the symbol; it's deleted again post-lowering.
+awk '/^module attributes/ && !done{
+       print;
+       print "  kernel.defn @cublasDgemm(%A: tensor, %B: tensor, %C: tensor, %beta: f64, %alpha: f64) -> tensor {";
+       print "    kernel.yield %C : tensor";
+       print "  }";
+       done=1;
+       next
+     }{print}' $OUT/gemm_matched.mlir > $OUT/gemm_matched_with_defn.mlir
+
+echo "  e) lower-kernel-launch-to-cublas (kernel.launch -> func.call ABI)"
+polygeist-opt --lower-kernel-launch-to-cublas \
+  $OUT/gemm_matched_with_defn.mlir -o $OUT/gemm_abi.mlir 2>$OUT/abi.err
+N_LAUNCH_AFTER=$(grep -c '= kernel\.launch ' $OUT/gemm_abi.mlir 2>/dev/null || true)
+N_CALL=$(grep -cE 'call @polygeist_cublas_dgemm\(' $OUT/gemm_abi.mlir 2>/dev/null || true)
+N_LAUNCH_AFTER=${N_LAUNCH_AFTER:-0}
+N_CALL=${N_CALL:-0}
+echo "    residual kernel.launch: $N_LAUNCH_AFTER ; func.call to shim: $N_CALL"
+if [ "$N_LAUNCH_AFTER" -ne 0 ] || [ "$N_CALL" -lt 1 ]; then
+  echo "  FAIL: lowering didn't replace kernel.launch with the runtime call"
+  cat $OUT/abi.err
+  exit 1
+fi
+
+echo "  f) lower to LLVM dialect"
+# Mark to_tensor results as `restrict` so one-shot-bufferize knows it's safe
+# to keep the in-place semantics (same trick gemm_kernel_e2e.sh uses).
+sed -i 's|bufferization\.to_tensor \(%[^ ]*\) :|bufferization.to_tensor \1 restrict :|g' \
+  $OUT/gemm_abi.mlir
+$MLIR_OPT --one-shot-bufferize=bufferize-function-boundaries \
+  --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \
+  --convert-arith-to-llvm --finalize-memref-to-llvm \
+  --convert-func-to-llvm --reconcile-unrealized-casts \
+  $OUT/gemm_abi.mlir -o $OUT/gemm_llvm.mlir 2>$OUT/mlir.err
+
+echo "  g) translate to LLVM IR"
+$MLIR_TRANSLATE --mlir-to-llvmir $OUT/gemm_llvm.mlir -o $OUT/gemm.ll 2>$OUT/translate.err
+sed -i 's/@kernel_gemm\b/@kernel_gemm_impl/g' $OUT/gemm.ll
+
+echo "  h) compile runtime shim + harness pieces"
+$CLANG -O2 -c $RT/polygeist_cublas_rt_cpu.c -o $OUT/rt.o
+$CLANG -c $CFLAGS $DYN_FLAGS $GEMM_DIR/gemm.c -o $OUT/gemm_full.o
+objcopy --weaken-symbol=kernel_gemm $OUT/gemm_full.o $OUT/gemm_nokernel.o
+$CLANG -c $CFLAGS $UTIL/polybench.c -o $OUT/polybench.o
+$CLANG -c $SCRIPTS/gemm_wrapper.c -o $OUT/wrapper.o
+$CLANG -c $OUT/gemm.ll -o $OUT/kernel.o
+
+echo "  i) link (CPU-stub runtime, no CUDA)"
+$CLANG $OUT/gemm_nokernel.o $OUT/wrapper.o $OUT/kernel.o $OUT/polybench.o \
+       $OUT/rt.o -lm -o $OUT/test_exe
+
+echo "=== 3. Run test and diff ==="
+$OUT/test_exe 2> $OUT/test.out
+wc -l $OUT/test.out
+
+if diff -q $OUT/ref.out $OUT/test.out >/dev/null; then
+  echo "PASS: cuBLAS-ABI lowering e2e matches clang reference"
+else
+  echo "FAIL: outputs differ"
+  diff $OUT/ref.out $OUT/test.out | head -10
+  exit 1
+fi
diff --git a/scripts/correctness/gemm_cublas_jetson.sh b/scripts/correctness/gemm_cublas_jetson.sh
new file mode 100755
index 000000000000..31329f128708
--- /dev/null
+++ b/scripts/correctness/gemm_cublas_jetson.sh
@@ -0,0 +1,86 @@
+#!/bin/bash
+# gemm_cublas_jetson.sh — produce a Jetson-ready aarch64 binary of gemm
+# routed through our matcher + cuBLAS-ABI lowering.
+#
+# Mirrors the structure of gemm_cublas_e2e.sh, but:
+#   * Stops before the local execute/diff (no x86 run; the binary is for ARM).
+#   * Cross-compiles polybench's gemm.c + polybench.c here with the right
+#     POLYBENCH defines, then hands them as pre-built .o files to
+#     build_jetson.sh.
+#   * Wraps kernel_gemm with the timing wrapper at gemm_jetson_wrapper.c so
+#     each call prints "POLYGEIST_TIMING: kernel_gemm ...  ms" to stderr
+#     when run on the Jetson.
+#
+# Usage:
+#   ./gemm_cublas_jetson.sh [DATASET]
+# DATASET defaults to MINI; pass STANDARD or LARGE for bigger problems.
+#
+# Output: /tmp/gemm_cublas_jetson_build/gemm_jetson  (aarch64 ELF, ~20 KB)
+# Then scp to Jetson and run.
+
+set -euo pipefail
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+DATASET=${1:-MINI}
+case "$DATASET" in
+  MINI|SMALL|STANDARD|LARGE|EXTRALARGE) ;;
+  *) echo "ERROR: DATASET must be one of MINI|SMALL|STANDARD|LARGE|EXTRALARGE" >&2; exit 1 ;;
+esac
+
+OUT=/tmp/gemm_cublas_jetson_build
+mkdir -p $OUT
+
+POLYBENCH_DIR=$REPO_ROOT/tools/cgeist/Test/polybench
+UTIL=$POLYBENCH_DIR/utilities
+GEMM_DIR=$POLYBENCH_DIR/linear-algebra/blas/gemm
+SCRIPTS=$REPO_ROOT/scripts/correctness
+RT=$REPO_ROOT/runtime
+
+# Harness CFLAGS for cross-compiling polybench's gemm.c + polybench.c.
+HARNESS_CFLAGS=(-O3 -I"$UTIL" -I"$GEMM_DIR"
+    -DDATA_TYPE_IS_DOUBLE -DPOLYBENCH_DUMP_ARRAYS
+    -D${DATASET}_DATASET
+    -Dstatic= -DPOLYBENCH_USE_C99_PROTO)
+
+# ─── Step 1: produce the ABI-lowered MLIR (reuse gemm_cublas_e2e.sh artifacts) ─
+ABI_MLIR=/tmp/gemm_cublas_test/gemm_abi.mlir
+if [ ! -s "$ABI_MLIR" ]; then
+  echo "[gemm-jetson] producing ABI-lowered MLIR via gemm_cublas_e2e.sh..."
+  bash $SCRIPTS/gemm_cublas_e2e.sh >/tmp/gemm_cublas_test/local_e2e.log 2>&1
+fi
+if [ ! -s "$ABI_MLIR" ]; then
+  echo "ERROR: $ABI_MLIR missing after gemm_cublas_e2e.sh" >&2
+  exit 1
+fi
+
+# ─── Step 2: cross-compile polybench harness pieces for aarch64 ────────────
+echo "[gemm-jetson] cross-compiling polybench gemm.c + polybench.c (dataset=$DATASET)"
+aarch64-linux-gnu-gcc "${HARNESS_CFLAGS[@]}" -c "$GEMM_DIR/gemm.c" -o $OUT/gemm_full.o
+aarch64-linux-gnu-objcopy --weaken-symbol=kernel_gemm $OUT/gemm_full.o $OUT/gemm_nokernel.o
+aarch64-linux-gnu-gcc "${HARNESS_CFLAGS[@]}" -c "$UTIL/polybench.c" -o $OUT/polybench.o
+
+# ─── Step 3: invoke build_jetson.sh with all the harness pieces ────────────
+# Pass:
+#   * gemm_jetson_wrapper.c  — adds timing around the lowered kernel
+#   * gemm_nokernel.o         — polybench gemm.c with kernel_gemm weakened
+#   * polybench.o             — polybench timing / IO helpers
+echo "[gemm-jetson] invoking build_jetson.sh"
+bash $SCRIPTS/build_jetson.sh \
+    "$ABI_MLIR" \
+    "$OUT/gemm_jetson" \
+    "$SCRIPTS/gemm_jetson_wrapper.c" \
+    "$OUT/gemm_nokernel.o" \
+    "$OUT/polybench.o"
+
+echo ""
+echo "═══════════════════════════════════════════════════════════════════════"
+echo "Binary ready: $OUT/gemm_jetson"
+echo "Dataset:      ${DATASET}_DATASET (problem size baked into polybench.o)"
+echo ""
+echo "Ship + run (once SSH is sorted):"
+echo "  scp $OUT/gemm_jetson @:/tmp/"
+echo "  ssh @ 'chmod +x /tmp/gemm_jetson && /tmp/gemm_jetson 2>&1'"
+echo ""
+echo "Look for 'POLYGEIST_TIMING:' lines on stderr for per-call ms."
+echo "═══════════════════════════════════════════════════════════════════════"
diff --git a/scripts/correctness/gemm_debuf_e2e.sh b/scripts/correctness/gemm_debuf_e2e.sh
new file mode 100755
index 000000000000..1029cabb9e5c
--- /dev/null
+++ b/scripts/correctness/gemm_debuf_e2e.sh
@@ -0,0 +1,103 @@
+#!/bin/bash
+set -e
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+MLIR_TRANSLATE=$REPO_ROOT/llvm-project/build/bin/mlir-translate
+CLANG=$REPO_ROOT/llvm-project/build/bin/clang
+
+POLYBENCH_DIR=$REPO_ROOT/tools/cgeist/Test/polybench
+UTIL=$POLYBENCH_DIR/utilities
+GEMM_DIR=$POLYBENCH_DIR/linear-algebra/blas/gemm
+
+OUT=/tmp/gemm_debuf_test
+mkdir -p $OUT
+
+DATASET=-DMINI_DATASET   # 20x25x30 — small for fast iteration
+CFLAGS="-O1 -I$UTIL -I$GEMM_DIR -DDATA_TYPE_IS_DOUBLE -DPOLYBENCH_DUMP_ARRAYS $DATASET"
+# Use C99 prototypes + suppress static-size hints so cgeist produces fully-
+# dynamic memrefs that round-trip cleanly through --linalg-debufferize.
+DYN_FLAGS="-Dstatic= -DPOLYBENCH_USE_C99_PROTO"
+
+echo "=== 1. Reference: clang -O0 directly ==="
+$CLANG $CFLAGS $DYN_FLAGS \
+  $GEMM_DIR/gemm.c $UTIL/polybench.c -lm -o $OUT/ref_exe
+$OUT/ref_exe 2> $OUT/ref.out
+wc -l $OUT/ref.out
+
+echo "=== 2. Test pipeline ==="
+echo "  a) cgeist gemm.c -> MLIR"
+cgeist $GEMM_DIR/gemm.c --function=kernel_gemm --resource-dir=/usr/lib/clang/14 \
+  $CFLAGS $DYN_FLAGS --raise-scf-to-affine -S -o $OUT/gemm_orig.mlir 2>/dev/null
+grep -c "func.func @kernel_gemm" $OUT/gemm_orig.mlir
+
+echo "  b) raise + lower-polygeist-submap"
+polygeist-opt --select-func=func-name=kernel_gemm \
+  --remove-iter-args --affine-parallelize \
+  --raise-affine-to-linalg-pipeline \
+  --lower-polygeist-submap \
+  --linalg-debufferize \
+  $OUT/gemm_orig.mlir -o $OUT/gemm_std.mlir 2>$OUT/raise.err
+# Check no polygeist ops remain
+if grep -qE "polygeist\.(submap|submapInverse)" $OUT/gemm_std.mlir; then
+  echo "  FAIL: polygeist ops remain"; exit 1
+fi
+echo "    raise+lower OK"
+
+echo "  c) lower to LLVM dialect"
+# bufferization.to_tensor needs `restrict` for one-shot-bufferize to accept
+# it. The LinalgDebufferize pass doesn't emit this attr, so patch via sed.
+sed -i 's|bufferization\.to_tensor \(%[^ ]*\) :|bufferization.to_tensor \1 restrict :|g' \
+  $OUT/gemm_std.mlir
+$MLIR_OPT --one-shot-bufferize=bufferize-function-boundaries \
+  --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \
+  --convert-arith-to-llvm --finalize-memref-to-llvm \
+  --convert-func-to-llvm --reconcile-unrealized-casts \
+  $OUT/gemm_std.mlir -o $OUT/gemm_llvm.mlir 2>$OUT/mlir.err
+
+echo "  d) translate to LLVM IR"
+$MLIR_TRANSLATE --mlir-to-llvmir $OUT/gemm_llvm.mlir -o $OUT/gemm.ll 2>$OUT/translate.err
+# Rename the lowered function so our wrapper can name it
+sed -i 's/@kernel_gemm\b/@kernel_gemm_impl/g' $OUT/gemm.ll
+
+echo "  e) compile gemm.c with kernel_gemm SUPPRESSED (we'll provide our own)"
+# Trick: use the preprocessor to rename gemm.c's kernel_gemm into a static
+# function (then it's defined-but-private, and our extern kernel_gemm wins).
+# But macro replaces both definition and call. So instead, compile gemm.c
+# to gemm.o with the kernel intact, then objcopy --strip-symbol the
+# kernel_gemm symbol. After strip the call from main becomes an undef ref,
+# which our wrapper.o satisfies.
+$CLANG -c $CFLAGS $DYN_FLAGS $GEMM_DIR/gemm.c -o $OUT/gemm_full.o
+# Rename the definition's symbol to a stub; main's relocation still points
+# to kernel_gemm, which our wrapper.o will satisfy.
+objcopy --redefine-sym kernel_gemm=__unused_kernel_gemm \
+  $OUT/gemm_full.o $OUT/gemm_nokernel.o
+# But the call from main also got renamed — undo that by re-redefining
+# the call site... actually --redefine-sym renames ALL occurrences. So main
+# also calls __unused_kernel_gemm now. Wrong. We need to instead rename
+# only the DEFINITION, not the references. objcopy doesn't distinguish.
+# Workaround: use a linker script or weakening.
+objcopy --weaken-symbol=kernel_gemm $OUT/gemm_full.o $OUT/gemm_nokernel.o
+
+echo "  f) compile polybench.c"
+$CLANG -c $CFLAGS $UTIL/polybench.c -o $OUT/polybench.o
+
+echo "  g) compile wrapper + lowered kernel"
+$CLANG -c /tmp/gemm_wrapper.c -o $OUT/wrapper.o
+$CLANG -c $OUT/gemm.ll -o $OUT/kernel.o
+
+echo "  h) link"
+$CLANG $OUT/gemm_nokernel.o $OUT/wrapper.o $OUT/kernel.o $OUT/polybench.o -lm -o $OUT/test_exe
+
+echo "=== 3. Run test and diff ==="
+$OUT/test_exe 2> $OUT/test.out
+wc -l $OUT/test.out
+
+echo "=== diff ==="
+if diff -q $OUT/ref.out $OUT/test.out; then
+  echo "PASS: outputs match"
+else
+  echo "FAIL: outputs differ"
+  diff $OUT/ref.out $OUT/test.out | head -10
+  exit 1
+fi
diff --git a/scripts/correctness/gemm_e2e.sh b/scripts/correctness/gemm_e2e.sh
new file mode 100755
index 000000000000..e8314822096a
--- /dev/null
+++ b/scripts/correctness/gemm_e2e.sh
@@ -0,0 +1,94 @@
+#!/bin/bash
+set -e
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+MLIR_TRANSLATE=$REPO_ROOT/llvm-project/build/bin/mlir-translate
+CLANG=$REPO_ROOT/llvm-project/build/bin/clang
+
+POLYBENCH_DIR=$REPO_ROOT/tools/cgeist/Test/polybench
+UTIL=$POLYBENCH_DIR/utilities
+GEMM_DIR=$POLYBENCH_DIR/linear-algebra/blas/gemm
+
+OUT=/tmp/gemm_test
+mkdir -p $OUT
+
+DATASET=-DMINI_DATASET   # 20x25x30 — small for fast iteration
+CFLAGS="-O0 -I$UTIL -I$GEMM_DIR -DDATA_TYPE_IS_DOUBLE -DPOLYBENCH_DUMP_ARRAYS $DATASET"
+
+echo "=== 1. Reference: clang -O0 directly ==="
+$CLANG $CFLAGS -DPOLYBENCH_DUMP_ARRAYS \
+  $GEMM_DIR/gemm.c $UTIL/polybench.c -lm -o $OUT/ref_exe
+$OUT/ref_exe 2> $OUT/ref.out
+wc -l $OUT/ref.out
+
+echo "=== 2. Test pipeline ==="
+echo "  a) cgeist gemm.c -> MLIR"
+cgeist $GEMM_DIR/gemm.c --function=kernel_gemm --resource-dir=/usr/lib/clang/14 \
+  $CFLAGS --raise-scf-to-affine -S -o $OUT/gemm_orig.mlir 2>/dev/null
+grep -c "func.func @kernel_gemm" $OUT/gemm_orig.mlir
+
+echo "  b) raise + lower-polygeist-submap"
+polygeist-opt --select-func=func-name=kernel_gemm \
+  --remove-iter-args --affine-parallelize \
+  --raise-affine-to-linalg-pipeline \
+  --lower-polygeist-submap \
+  $OUT/gemm_orig.mlir -o $OUT/gemm_std.mlir 2>$OUT/raise.err
+# Check no polygeist ops remain
+if grep -qE "polygeist\.(submap|submapInverse)" $OUT/gemm_std.mlir; then
+  echo "  FAIL: polygeist ops remain"; exit 1
+fi
+echo "    raise+lower OK"
+
+echo "  c) lower to LLVM dialect"
+$MLIR_OPT --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \
+  --convert-arith-to-llvm --finalize-memref-to-llvm \
+  --convert-func-to-llvm --reconcile-unrealized-casts \
+  $OUT/gemm_std.mlir -o $OUT/gemm_llvm.mlir 2>$OUT/mlir.err
+
+echo "  d) translate to LLVM IR"
+$MLIR_TRANSLATE --mlir-to-llvmir $OUT/gemm_llvm.mlir -o $OUT/gemm.ll 2>$OUT/translate.err
+# Rename the lowered function so our wrapper can name it
+sed -i 's/@kernel_gemm\b/@kernel_gemm_impl/g' $OUT/gemm.ll
+
+echo "  e) compile gemm.c with kernel_gemm SUPPRESSED (we'll provide our own)"
+# Trick: use the preprocessor to rename gemm.c's kernel_gemm into a static
+# function (then it's defined-but-private, and our extern kernel_gemm wins).
+# But macro replaces both definition and call. So instead, compile gemm.c
+# to gemm.o with the kernel intact, then objcopy --strip-symbol the
+# kernel_gemm symbol. After strip the call from main becomes an undef ref,
+# which our wrapper.o satisfies.
+$CLANG -c $CFLAGS $GEMM_DIR/gemm.c -o $OUT/gemm_full.o
+# Rename the definition's symbol to a stub; main's relocation still points
+# to kernel_gemm, which our wrapper.o will satisfy.
+objcopy --redefine-sym kernel_gemm=__unused_kernel_gemm \
+  $OUT/gemm_full.o $OUT/gemm_nokernel.o
+# But the call from main also got renamed — undo that by re-redefining
+# the call site... actually --redefine-sym renames ALL occurrences. So main
+# also calls __unused_kernel_gemm now. Wrong. We need to instead rename
+# only the DEFINITION, not the references. objcopy doesn't distinguish.
+# Workaround: use a linker script or weakening.
+objcopy --weaken-symbol=kernel_gemm $OUT/gemm_full.o $OUT/gemm_nokernel.o
+
+echo "  f) compile polybench.c"
+$CLANG -c $CFLAGS $UTIL/polybench.c -o $OUT/polybench.o
+
+echo "  g) compile wrapper + lowered kernel"
+$CLANG -c /tmp/gemm_wrapper.c -o $OUT/wrapper.o
+$CLANG -c $OUT/gemm.ll -o $OUT/kernel.o
+
+echo "  h) link"
+$CLANG $OUT/gemm_nokernel.o $OUT/wrapper.o $OUT/kernel.o $OUT/polybench.o -lm -o $OUT/test_exe
+
+echo "=== 3. Run test and diff ==="
+$OUT/test_exe 2> $OUT/test.out
+wc -l $OUT/test.out
+
+echo "=== diff ==="
+if diff -q $OUT/ref.out $OUT/test.out; then
+  echo "PASS: outputs match"
+else
+  echo "FAIL: outputs differ"
+  diff $OUT/ref.out $OUT/test.out | head -10
+  exit 1
+fi
diff --git a/scripts/correctness/gemm_jetson_wrapper.c b/scripts/correctness/gemm_jetson_wrapper.c
new file mode 100644
index 000000000000..274740651ba3
--- /dev/null
+++ b/scripts/correctness/gemm_jetson_wrapper.c
@@ -0,0 +1,39 @@
+/* gemm_jetson_wrapper.c — Jetson timing wrapper.
+ *
+ * Same shape as gemm_wrapper.c (bridges PolyBench's kernel_gemm signature
+ * to the MLIR-lowered kernel_gemm_impl with bare memref descriptor args),
+ * but additionally wraps the call with polygeist_cublas_time_begin/end_ms
+ * so we get a per-call timing print on the Jetson.
+ *
+ * On the CUDA runtime, timing uses cudaEvents (GPU time). On the CPU stub,
+ * it uses CLOCK_MONOTONIC wall-clock. Either way it goes to stderr so
+ * stdout numerics stay clean for diff against the reference.
+ */
+#include 
+#include 
+
+extern void kernel_gemm_impl(
+    int ni, int nj, int nk, double alpha, double beta,
+    double *C_base, double *C_aligned, int64_t C_offset,
+    int64_t C_size0, int64_t C_size1, int64_t C_stride0, int64_t C_stride1,
+    double *A_base, double *A_aligned, int64_t A_offset,
+    int64_t A_size0, int64_t A_size1, int64_t A_stride0, int64_t A_stride1,
+    double *B_base, double *B_aligned, int64_t B_offset,
+    int64_t B_size0, int64_t B_size1, int64_t B_stride0, int64_t B_stride1);
+
+extern void  polygeist_cublas_time_begin(void);
+extern double polygeist_cublas_time_end_ms(void);
+
+void kernel_gemm(int ni, int nj, int nk, double alpha, double beta,
+                 double *C, double *A, double *B) {
+  polygeist_cublas_time_begin();
+  kernel_gemm_impl(ni, nj, nk, alpha, beta,
+                   C, C, 0, ni, nj, nj, 1,
+                   A, A, 0, ni, nk, nk, 1,
+                   B, B, 0, nk, nj, nj, 1);
+  double ms = polygeist_cublas_time_end_ms();
+  /* stderr because PolyBench dumps the result array to stderr too; we
+   * prefix with a sentinel so test diff scripts can grep it out. */
+  fprintf(stderr, "POLYGEIST_TIMING: kernel_gemm ni=%d nj=%d nk=%d  %.3f ms\n",
+          ni, nj, nk, ms);
+}
diff --git a/scripts/correctness/gemm_kernel_e2e.sh b/scripts/correctness/gemm_kernel_e2e.sh
new file mode 100755
index 000000000000..cf54ee2787df
--- /dev/null
+++ b/scripts/correctness/gemm_kernel_e2e.sh
@@ -0,0 +1,114 @@
+#!/bin/bash
+# End-to-end correctness test: C source -> ... -> kernel.launch (matched) ->
+# lower-kernel-launch (restored linalg) -> LLVM dialect -> binary -> execute.
+#
+# Compares numeric output against a pure clang reference. Pass = round-trip
+# through the kernel-match form preserves the gemm computation.
+#
+# Phase 1: roundtrip lowering — we restore the matcher's pre-match linalg
+# verbatim from comment markers. This validates that match-then-lower doesn't
+# corrupt the SSA chain or surrounding IR, and that the e2e plumbing works.
+# It does NOT validate the matcher's library LABEL ("@cublasDgemm"); that's
+# Phase 2 (canonical templates).
+set -euo pipefail
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+MLIR_TRANSLATE=$REPO_ROOT/llvm-project/build/bin/mlir-translate
+CLANG=$REPO_ROOT/llvm-project/build/bin/clang
+PYTHON=$PYTHON
+SCRIPTS=$REPO_ROOT/scripts/correctness
+
+POLYBENCH_DIR=$REPO_ROOT/tools/cgeist/Test/polybench
+UTIL=$POLYBENCH_DIR/utilities
+GEMM_DIR=$POLYBENCH_DIR/linear-algebra/blas/gemm
+
+OUT=/tmp/gemm_kernel_test
+mkdir -p $OUT
+
+DATASET=-DMINI_DATASET
+CFLAGS="-O1 -I$UTIL -I$GEMM_DIR -DDATA_TYPE_IS_DOUBLE -DPOLYBENCH_DUMP_ARRAYS $DATASET"
+DYN_FLAGS="-Dstatic= -DPOLYBENCH_USE_C99_PROTO"
+
+echo "=== 1. Reference: clang -O0 directly ==="
+$CLANG $CFLAGS $DYN_FLAGS \
+  $GEMM_DIR/gemm.c $UTIL/polybench.c -lm -o $OUT/ref_exe
+$OUT/ref_exe 2> $OUT/ref.out
+wc -l $OUT/ref.out
+
+echo "=== 2. Test pipeline ==="
+echo "  a) cgeist gemm.c -> affine MLIR"
+cgeist $GEMM_DIR/gemm.c --function=kernel_gemm --resource-dir=/usr/lib/clang/14 \
+  $CFLAGS $DYN_FLAGS --raise-scf-to-affine -S -o $OUT/gemm_orig.mlir 2>/dev/null
+grep -c "func.func @kernel_gemm" $OUT/gemm_orig.mlir
+
+echo "  b) raise + lower-submap + debufferize"
+polygeist-opt --select-func=func-name=kernel_gemm \
+  --remove-iter-args --affine-parallelize \
+  --raise-affine-to-linalg-pipeline \
+  --lower-polygeist-submap \
+  --linalg-debufferize \
+  $OUT/gemm_orig.mlir -o $OUT/gemm_debuf.mlir 2>$OUT/raise.err
+if grep -qE "polygeist\.(submap|submapInverse)" $OUT/gemm_debuf.mlir; then
+  echo "  FAIL: polygeist ops remain after lower-submap"; exit 1
+fi
+
+echo "  c) kernel-match (linalg -> kernel.launch, with roundtrip markers)"
+$PYTHON $SCRIPTS/kernel_match_rewrite.py --with-roundtrip-markers \
+  $OUT/gemm_debuf.mlir > $OUT/gemm_matched.mlir 2>$OUT/match.err
+N_LAUNCH=$(grep -c '= kernel\.launch ' $OUT/gemm_matched.mlir || echo 0)
+N_MARK=$(grep -c '// POLYGEIST-MATCH-BEGIN-' $OUT/gemm_matched.mlir || echo 0)
+echo "    matched ops: $N_LAUNCH kernel.launch, $N_MARK markers"
+if [ "$N_LAUNCH" -lt 1 ] || [ "$N_MARK" -ne "$N_LAUNCH" ]; then
+  echo "  FAIL: expected at least 1 kernel.launch and matching markers"; exit 1
+fi
+
+echo "  d) lower-kernel-launch (kernel.launch -> restored linalg)"
+$PYTHON $SCRIPTS/kernel_launch_lower.py $OUT/gemm_matched.mlir \
+  -o $OUT/gemm_restored.mlir 2>$OUT/lower.err
+# Sanity: restored output must be bit-exact to the pre-match debufferized IR.
+if ! diff -q $OUT/gemm_debuf.mlir $OUT/gemm_restored.mlir >/dev/null; then
+  echo "  FAIL: restored MLIR is not bit-exact to pre-match"
+  diff -u $OUT/gemm_debuf.mlir $OUT/gemm_restored.mlir | head -30
+  exit 1
+fi
+echo "    restoration bit-exact OK"
+
+echo "  e) lower to LLVM dialect"
+sed -i 's|bufferization\.to_tensor \(%[^ ]*\) :|bufferization.to_tensor \1 restrict :|g' \
+  $OUT/gemm_restored.mlir
+$MLIR_OPT --one-shot-bufferize=bufferize-function-boundaries \
+  --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \
+  --convert-arith-to-llvm --finalize-memref-to-llvm \
+  --convert-func-to-llvm --reconcile-unrealized-casts \
+  $OUT/gemm_restored.mlir -o $OUT/gemm_llvm.mlir 2>$OUT/mlir.err
+
+echo "  f) translate to LLVM IR"
+$MLIR_TRANSLATE --mlir-to-llvmir $OUT/gemm_llvm.mlir -o $OUT/gemm.ll 2>$OUT/translate.err
+sed -i 's/@kernel_gemm\b/@kernel_gemm_impl/g' $OUT/gemm.ll
+
+echo "  g) compile gemm.c with kernel_gemm weakened"
+$CLANG -c $CFLAGS $DYN_FLAGS $GEMM_DIR/gemm.c -o $OUT/gemm_full.o
+objcopy --weaken-symbol=kernel_gemm $OUT/gemm_full.o $OUT/gemm_nokernel.o
+
+echo "  h) compile polybench + wrapper + lowered kernel"
+$CLANG -c $CFLAGS $UTIL/polybench.c -o $OUT/polybench.o
+$CLANG -c $SCRIPTS/gemm_wrapper.c -o $OUT/wrapper.o
+$CLANG -c $OUT/gemm.ll -o $OUT/kernel.o
+
+echo "  i) link"
+$CLANG $OUT/gemm_nokernel.o $OUT/wrapper.o $OUT/kernel.o $OUT/polybench.o \
+  -lm -o $OUT/test_exe
+
+echo "=== 3. Run test and diff ==="
+$OUT/test_exe 2> $OUT/test.out
+wc -l $OUT/test.out
+
+if diff -q $OUT/ref.out $OUT/test.out >/dev/null; then
+  echo "PASS: kernel.launch roundtrip e2e outputs match clang reference"
+else
+  echo "FAIL: outputs differ"
+  diff $OUT/ref.out $OUT/test.out | head -10
+  exit 1
+fi
diff --git a/scripts/correctness/gemm_wrapper.c b/scripts/correctness/gemm_wrapper.c
new file mode 100644
index 000000000000..14d8f82e6258
--- /dev/null
+++ b/scripts/correctness/gemm_wrapper.c
@@ -0,0 +1,32 @@
+/* C wrapper: bridges the PolyBench-style call to the MLIR-lowered kernel
+ * which uses MLIR's bare memref descriptor calling convention.
+ *
+ * The lowered function `kernel_gemm_impl` expects, for each 2D dynamic
+ * memref operand, 7 arguments: (ptr base, ptr aligned, i64 offset,
+ * i64 size0, i64 size1, i64 stride0, i64 stride1).
+ */
+#include 
+
+extern void kernel_gemm_impl(
+    int ni, int nj, int nk, double alpha, double beta,
+    /* C: memref */
+    double *C_base, double *C_aligned, int64_t C_offset,
+    int64_t C_size0, int64_t C_size1, int64_t C_stride0, int64_t C_stride1,
+    /* A: memref */
+    double *A_base, double *A_aligned, int64_t A_offset,
+    int64_t A_size0, int64_t A_size1, int64_t A_stride0, int64_t A_stride1,
+    /* B: memref */
+    double *B_base, double *B_aligned, int64_t B_offset,
+    int64_t B_size0, int64_t B_size1, int64_t B_stride0, int64_t B_stride1);
+
+/* PolyBench-style entry. The arrays are passed as VLAs (or pointers in the
+ * heap-allocated PolyBench version). For PolyBench's POLYBENCH_USE_C99_PROTO
+ * mode the function signature uses VLA syntax; otherwise it's flat double*.
+ * We accept double* and use the explicit ni/nj/nk to compute strides. */
+void kernel_gemm(int ni, int nj, int nk, double alpha, double beta,
+                 double *C, double *A, double *B) {
+  kernel_gemm_impl(ni, nj, nk, alpha, beta,
+                   C, C, 0, ni, nj, nj, 1,
+                   A, A, 0, ni, nk, nk, 1,
+                   B, B, 0, nk, nj, nj, 1);
+}
diff --git a/scripts/correctness/gemver_jetson_wrapper.c b/scripts/correctness/gemver_jetson_wrapper.c
new file mode 100644
index 000000000000..0897514ed05f
--- /dev/null
+++ b/scripts/correctness/gemver_jetson_wrapper.c
@@ -0,0 +1,42 @@
+/* gemver_jetson_wrapper.c — Jetson timing wrapper.
+ *
+ * gemver: A = A + u1·v1ᵀ + u2·v2ᵀ; x = β·Aᵀ·y + z; w = α·A·x
+ * Signature: (n, α, β, A, u1, v1, u2, v2, w, x, y, z).
+ */
+#include 
+#include 
+
+extern void kernel_gemver_impl(
+    int n, double alpha, double beta,
+    /* A: 2D */
+    double *A_b, double *A_a, int64_t A_o, int64_t A_s0, int64_t A_s1, int64_t A_st0, int64_t A_st1,
+    /* u1,v1,u2,v2,w,x,y,z : 1D each (8 vectors) */
+    double *u1_b, double *u1_a, int64_t u1_o, int64_t u1_s, int64_t u1_st,
+    double *v1_b, double *v1_a, int64_t v1_o, int64_t v1_s, int64_t v1_st,
+    double *u2_b, double *u2_a, int64_t u2_o, int64_t u2_s, int64_t u2_st,
+    double *v2_b, double *v2_a, int64_t v2_o, int64_t v2_s, int64_t v2_st,
+    double *w_b,  double *w_a,  int64_t w_o,  int64_t w_s,  int64_t w_st,
+    double *x_b,  double *x_a,  int64_t x_o,  int64_t x_s,  int64_t x_st,
+    double *y_b,  double *y_a,  int64_t y_o,  int64_t y_s,  int64_t y_st,
+    double *z_b,  double *z_a,  int64_t z_o,  int64_t z_s,  int64_t z_st);
+
+extern void   polygeist_cublas_time_begin(void);
+extern double polygeist_cublas_time_end_ms(void);
+
+void kernel_gemver(int n, double alpha, double beta, double *A,
+                   double *u1, double *v1, double *u2, double *v2,
+                   double *w, double *x, double *y, double *z) {
+  polygeist_cublas_time_begin();
+  kernel_gemver_impl(n, alpha, beta,
+                     A, A, 0, n, n, n, 1,
+                     u1, u1, 0, n, 1,
+                     v1, v1, 0, n, 1,
+                     u2, u2, 0, n, 1,
+                     v2, v2, 0, n, 1,
+                     w,  w,  0, n, 1,
+                     x,  x,  0, n, 1,
+                     y,  y,  0, n, 1,
+                     z,  z,  0, n, 1);
+  double ms = polygeist_cublas_time_end_ms();
+  fprintf(stderr, "POLYGEIST_TIMING: kernel_gemver n=%d  %.3f ms\n", n, ms);
+}
diff --git a/scripts/correctness/gen_wrapper.py b/scripts/correctness/gen_wrapper.py
new file mode 100755
index 000000000000..a71025f4e75e
--- /dev/null
+++ b/scripts/correctness/gen_wrapper.py
@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+"""Generate a C-ABI wrapper for a PolyBench kernel.
+
+The wrapper bridges PolyBench's C signature (int scalars, double scalars,
+flat double* arrays) to the MLIR-lowered function which uses the bare
+memref descriptor calling convention (each N-D memref expands to
+[base, aligned, offset, sizes..., strides...] arguments).
+
+Usage:
+  gen_wrapper.py  
+
+Prints the wrapper C source to stdout.
+"""
+import re
+import sys
+
+
+def extract_macro_prelude(c_text: str) -> str:
+    """Copy simple #define constants needed by fixed-size plain C arrays."""
+    lines = []
+    for line in c_text.splitlines():
+        m = re.match(r"^\s*#\s*define\s+([A-Za-z_]\w*)\b(.*)$", line)
+        if not m:
+            continue
+        name = m.group(1)
+        rest = m.group(2).strip()
+        if "(" in name:
+            continue
+        if rest:
+            lines.append(f"#ifndef {name}")
+            lines.append(f"#define {name} {rest}")
+            lines.append("#endif")
+    return "\n".join(lines)
+
+
+def infer_dtype(c_text: str) -> str:
+    m = re.search(r"^\s*#\s*define\s+DATA_TYPE\s+(float|double)\b",
+                  c_text, re.MULTILINE)
+    if m:
+        return m.group(1)
+    if re.search(r"\bfloat\s+[A-Za-z_]\w*\s*\[", c_text):
+        return "float"
+    return "double"
+
+
+def parse_signature(c_text: str, kernel_name: str):
+    """Return list of (kind, *fields) tuples describing each argument.
+
+    Kinds:
+      ('int', name)
+      ('double', name)
+      ('1D', name, size_var)
+      ('2D', name, d0_var, d1_var)
+      ('3D', name, d0_var, d1_var, d2_var)
+      ('4D', name, d0_var, d1_var, d2_var, d3_var)
+      ... (plain C arrays support arbitrary positive rank)
+    """
+    # The signature can be split across many lines. Find the function head.
+    m = re.search(
+        rf"(?:void|DATA_TYPE|float|double)\s+{re.escape(kernel_name)}"
+        rf"\s*\((.*?)\)\s*(?:\n)?\s*\{{",
+        c_text,
+        re.DOTALL,
+    )
+    if not m:
+        raise ValueError(f"Couldn't find function {kernel_name}")
+    args_str = m.group(1)
+    # Split by top-level commas (respecting nested parens).
+    args, depth, cur = [], 0, []
+    for c in args_str:
+        if c == ',' and depth == 0:
+            args.append(''.join(cur).strip())
+            cur = []
+            continue
+        if c == '(':
+            depth += 1
+        elif c == ')':
+            depth -= 1
+        cur.append(c)
+    args.append(''.join(cur).strip())
+
+    # Pointer-only extraction signatures lose their C array bounds.  Allow a
+    # source to preserve those bounds without changing the function ABI:
+    #   // polygeist-arg-extents function_name: A=20, X=128, Y=128
+    extent_map = {}
+    annotation = re.search(
+        rf"^\s*//\s*polygeist-arg-extents\s+{re.escape(kernel_name)}\s*:\s*(.+)$",
+        c_text,
+        re.MULTILINE,
+    )
+    if annotation:
+        for item in annotation.group(1).split(','):
+            name, separator, extent = item.strip().partition('=')
+            if not separator or not re.fullmatch(r"[A-Za-z_]\w*", name):
+                raise ValueError(f"Malformed pointer extent annotation: {item!r}")
+            extent_map[name] = extent.strip()
+
+    out = []
+    plain_array_indices = []
+    scalar_ints = set()
+    for a in args:
+        if 'POLYBENCH_3D' in a:
+            m3 = re.search(
+                r"POLYBENCH_3D\s*\(\s*(\w+)\s*,\s*\w+\s*,\s*\w+\s*,\s*\w+\s*,"
+                r"\s*(\w+)\s*,\s*(\w+)\s*,\s*(\w+)\s*\)",
+                a,
+            )
+            if not m3:
+                raise ValueError(f"Couldn't parse 3D arg: {a}")
+            out.append(('3D', m3.group(1), m3.group(2), m3.group(3), m3.group(4)))
+        elif 'POLYBENCH_2D' in a:
+            m2 = re.search(
+                r"POLYBENCH_2D\s*\(\s*(\w+)\s*,\s*\w+\s*,\s*\w+\s*,"
+                r"\s*(\w+)\s*,\s*(\w+)\s*\)",
+                a,
+            )
+            if not m2:
+                raise ValueError(f"Couldn't parse 2D arg: {a}")
+            out.append(('2D', m2.group(1), m2.group(2), m2.group(3)))
+        elif 'POLYBENCH_1D' in a:
+            m1 = re.search(
+                r"POLYBENCH_1D\s*\(\s*(\w+)\s*,\s*\w+\s*,\s*(\w+)\s*\)", a
+            )
+            if not m1:
+                raise ValueError(f"Couldn't parse 1D arg: {a}")
+            out.append(('1D', m1.group(1), m1.group(2)))
+        elif re.match(r"^\s*int\b", a):
+            name = a.split()[-1].strip('*')
+            out.append(('int', name))
+            scalar_ints.add(name)
+        elif _is_plain_c_array(a):
+            # Plain C array signature: `double A[NI][NJ]` or `int A[NI][NJ][NK]`
+            # — what polybenchGpu-extracted / llama2.c-style sources use
+            # instead of POLYBENCH_2D/3D macros. We need (a) the variable name
+            # and (b) one runtime-size arg per dimension. The uppercase macros
+            # in the brackets (NI, NJ, NK) are compile-time constants; the
+            # runtime sizes by convention live in lowercase int args of the
+            # same function (ni, nj, nk). Match them by lowercasing the macro.
+            kind, name, dims = _parse_plain_c_array(a)
+            out.append((kind, name, *dims))
+            plain_array_indices.append(len(out) - 1)
+        elif _is_plain_c_pointer(a):
+            # Extracted kernels often use pointer signatures instead of fixed
+            # C arrays. Infer the 1D memref extent from common scalar args.
+            name, is_const = _parse_plain_c_pointer(a)
+            if name in extent_map:
+                size = extent_map[name]
+            elif name == "out" and "n" in scalar_ints and "k" in scalar_ints:
+                size = "(n - k + 1)"
+            elif name in ("filter", "kernel", "weights") and "k" in scalar_ints:
+                size = "k"
+            elif "n" in scalar_ints:
+                size = "n"
+            elif "N" in c_text:
+                size = "N"
+            else:
+                raise ValueError(f"Couldn't infer pointer extent for arg: {a}")
+            out.append(('1D', name, size))
+        elif re.match(r"^\s*DATA_TYPE\b", a) or re.match(r"^\s*float\b", a) \
+                or re.match(r"^\s*double\b", a):
+            # Scalar (alpha, beta, etc.).
+            name = a.split()[-1].strip('*')
+            out.append(('double', name))
+        else:
+            raise ValueError(f"Unrecognized arg: {a}")
+
+    for idx in plain_array_indices:
+        entry = out[idx]
+        dims = []
+        for d in entry[2:]:
+            lower = d.lower()
+            dims.append(lower if lower in scalar_ints else d)
+        out[idx] = (entry[0], entry[1], *dims)
+    return out
+
+
+def parse_return_type(c_text: str, kernel_name: str, dtype: str) -> str:
+    m = re.search(
+        rf"\b(void|DATA_TYPE|float|double)\s+{re.escape(kernel_name)}\s*\(",
+        c_text,
+    )
+    if not m:
+        raise ValueError(f"Couldn't find function {kernel_name}")
+    ret = m.group(1)
+    return dtype if ret == "DATA_TYPE" else ret
+
+
+def _is_plain_c_array(a: str) -> bool:
+    """True iff `a` looks like a plain C array parameter declaration
+    (e.g. 'double A[NI][NJ]' or 'int A[N]' or 'short A[NI][NJ][NK]').
+    Distinguishable from a pointer-to-scalar (`double *alpha`) because
+    array params always have a square-bracket dim list."""
+    if not re.match(r"^\s*(?:const\s+)?(?:double|float|int|short|long|DATA_TYPE|_Float16|__bf16)\b", a):
+        return False
+    return re.search(r"\[\s*[^\]]+\s*\]\s*(?:\[\s*[^\]]+\s*\])*\s*$", a) is not None
+
+
+def _parse_plain_c_array(a: str):
+    """Parse a plain C array parameter like 'double A[NI][NJ]' or
+    'short A[N]' into (kind, name, [dim0, dim1, ...]).
+    `kind` is '1D', '2D', or '3D' so downstream gen_wrapper() can handle
+    it identically to the POLYBENCH macro form.
+    """
+    m = re.match(
+        r"^\s*(?:const\s+)?(?:double|float|int|short|long|DATA_TYPE|_Float16|__bf16)"
+        r"\s+(\w+)((?:\s*\[\s*[^\]]+\s*\])+)\s*$",
+        a,
+    )
+    if not m:
+        raise ValueError(f"Couldn't parse plain-C-array arg: {a!r}")
+    name = m.group(1)
+    dims = [d.strip() for d in re.findall(r"\[\s*([^\]]+)\s*\]", m.group(2))]
+    if not dims:
+        raise ValueError(f"Plain-C-array arg has no dimensions: {a!r}")
+    return (f'{len(dims)}D', name, dims)
+
+
+def _is_plain_c_pointer(a: str) -> bool:
+    return re.match(
+        r"^\s*(?:const\s+)?(?:double|float|DATA_TYPE)\s*\*\s*\w+\s*$", a
+    ) is not None
+
+
+def _parse_plain_c_pointer(a: str):
+    m = re.match(
+        r"^\s*(const\s+)?(?:double|float|DATA_TYPE)\s*\*\s*(\w+)\s*$", a
+    )
+    if not m:
+        raise ValueError(f"Couldn't parse pointer arg: {a!r}")
+    return m.group(2), bool(m.group(1))
+
+
+def gen_wrapper(kernel_name: str, args, dtype: str = 'double',
+                prelude: str = '', return_type: str = 'void'):
+    """Emit wrapper C source for `kernel_name`."""
+    extern_args, wrapper_args, call_args = [], [], []
+    for a in args:
+        k = a[0]
+        if k == 'int':
+            extern_args.append(f"int {a[1]}")
+            wrapper_args.append(f"int {a[1]}")
+            call_args.append(a[1])
+        elif k == 'double':
+            extern_args.append(f"{dtype} {a[1]}")
+            wrapper_args.append(f"{dtype} {a[1]}")
+            call_args.append(a[1])
+        elif re.fullmatch(r'[1-9][0-9]*D', k):
+            rank = int(k[:-1])
+            name = a[1]
+            dims = list(a[2:])
+            if len(dims) != rank:
+                raise ValueError(
+                    f"{k} argument {name} has {len(dims)} dimensions")
+            extern_args.extend([
+                f"{dtype} *{name}_b", f"{dtype} *{name}_a",
+                f"int64_t {name}_off",
+                *(f"int64_t {name}_s{i}" for i in range(rank)),
+                *(f"int64_t {name}_t{i}" for i in range(rank)),
+            ])
+            wrapper_args.append(f"{dtype} *{name}")
+            strides = []
+            for i in range(rank):
+                trailing = dims[i + 1:]
+                strides.append(
+                    " * ".join(f"({d})" for d in trailing) if trailing else "1"
+                )
+            descriptor = [name, name, "0", *dims, *strides]
+            call_args.append(", ".join(descriptor))
+        else:
+            raise ValueError(f"Unknown kind {k}")
+
+    extern = (
+        f"extern {return_type} {kernel_name}_impl(\n    "
+        + ",\n    ".join(extern_args)
+        + ");"
+    )
+    call = (
+        f"{kernel_name}_impl(\n      "
+        + ",\n      ".join(call_args)
+        + ")"
+    )
+    if return_type == 'void':
+        body = f"  {call};"
+    else:
+        body = f"  return {call};"
+    wrapper = (
+        f"{return_type} {kernel_name}({', '.join(wrapper_args)}) {{\n"
+        f"{body}\n}}"
+    )
+    prefix = "#include "
+    if prelude:
+        prefix += "\n" + prelude
+    return f"{prefix}\n\n{extern}\n\n{wrapper}\n"
+
+
+def main():
+    if len(sys.argv) != 3:
+        print(__doc__, file=sys.stderr)
+        sys.exit(1)
+    src, name = sys.argv[1], sys.argv[2]
+    with open(src) as f:
+        text = f.read()
+    dtype = infer_dtype(text)
+    args = parse_signature(text, name)
+    ret = parse_return_type(text, name, dtype)
+    print(gen_wrapper(name, args, dtype, extract_macro_prelude(text), ret))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/correctness/generate_aten_additional_extractions.py b/scripts/correctness/generate_aten_additional_extractions.py
new file mode 100644
index 000000000000..6698d29bfc04
--- /dev/null
+++ b/scripts/correctness/generate_aten_additional_extractions.py
@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""Generate standalone C for non-dispatch ATen numerical bodies."""
+
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+OUT = ROOT / "issues/aten_c_kernels"
+MANIFEST = OUT / "generated_additional_provenance.csv"
+ENTRIES: list[tuple[str, str, str, str]] = []
+
+
+def add(name: str, source: str, token: str, code: str) -> None:
+    ENTRIES.append((f"aten_{name}", source, token, code + "\n"))
+
+
+def loss_entries() -> None:
+    nll = "aten/src/ATen/native/LossNLL.cpp"
+    h = "#define B 32\n#define C 16\n"
+    add("nll_loss_forward_cpu", nll, "nll_loss_out_frame", h + """void aten_nll_loss_forward_cpu(float input[B][C],int target[B],float weight[C],float out[B],float total_weight[1]){float tw=0;for(int b=0;b0)s+=p==1?z:z*z;}out[b]=s*weight[t]/C;}}""")
+    add("multi_margin_loss_backward_cpu", mm, "multi_margin_loss_backward_cpu_kernel", mh + """void aten_multi_margin_loss_backward_cpu(float input[B][C],int target[B],float weight[C],float margin,int p,float grad[B],float out[B][C]){for(int b=0;b0){float g=grad[b]*weight[t]*(p==1?1.0f:2.0f*z)/C;out[b][c]=g;sum+=g;}}}out[b][t]=-sum;}}""")
+
+    ml = "aten/src/ATen/native/LossMultiLabelMargin.cpp"
+    lh = "#define B 16\n#define C 16\n#define L 4\n"
+    add("multilabel_margin_loss_forward_cpu", ml, "multilabel_margin_loss_forward_out_frame", lh + """void aten_multilabel_margin_loss_forward_cpu(float input[B][C],int target[B][L],float out[B]){for(int b=0;b0)s+=z;}}}out[b]=s/C;}}""")
+    add("multilabel_margin_loss_backward_cpu", ml, "multilabel_margin_loss_backward_out_frame", lh + """void aten_multilabel_margin_loss_backward_cpu(float input[B][C],int target[B][L],float grad[B],float out[B][C]){for(int b=0;b0){float g=grad[b]/C;out[b][c]+=g;out[b][t]-=g;}}}}}""")
+
+    ctc = "aten/src/ATen/native/LossCTC.cpp"
+    ch = "#define T 24\n#define B 4\n#define C 12\n#define L 5\n#define S (2*L+1)\n"
+    add("ctc_loss_cpu", ctc, "ctc_loss_cpu_template", ch + """extern float expf(float);extern float logf(float);
+void aten_ctc_loss_cpu(float logp[T][B][C],int labels[B][L],int blank,float loss[B],float alpha[B][T][S]){for(int b=0;b0)a+=alpha[b][t-1][s-1];if(s>1&&lab!=blank&&lab!=((s-2)&1?labels[b][(s-2)/2]:blank))a+=alpha[b][t-1][s-2];alpha[b][t][s]=a*expf(logp[t][b][lab]);}float z=alpha[b][T-1][S-1]+alpha[b][T-1][S-2];loss[b]=-logf(z);}}""")
+    add("ctc_loss_backward_cpu", ctc, "ctc_loss_backward_cpu_template", ch + """extern float expf(float);
+void aten_ctc_loss_backward_cpu(float logp[T][B][C],int labels[B][L],int blank,float alpha[B][T][S],float grad_loss[B],float out[T][B][C]){for(int t=0;t=0;--t)for(int s=0;s None:
+    seg = "aten/src/ATen/native/SegmentReduce.cpp"
+    sh = "#define SEG 16\n#define N 128\n"
+    add("segment_reduce_lengths_cpu", seg, "_segment_reduce_lengths_cpu_kernel1", sh + """void aten_segment_reduce_lengths_cpu(float x[N],int lengths[SEG],int reduce,float out[SEG]){int p=0;for(int s=0;sa?v:a;else v=vm?x[r][k]:m;float s=0;for(int k=0;kIH-KH)sy=IH-KH;if(sx>IW-KW)sx=IW-KW;float v=-3.402823466e38f;int best=0;for(int ky=0;kyv){v=x[b][c][sy+ky][sx+kx];best=(sy+ky)*IW+sx+kx;}out[b][c][oy][ox]=v;index[b][c][oy][ox]=best;}}""")
+    add("fractional_max_pool2d_backward_cpu", frac2, "fractional_max_pool2d_backward_out_frame", f2 + """void aten_fractional_max_pool2d_backward_cpu(float grad[B][C][OH][OW],int index[B][C][OH][OW],float out[B][C][IH][IW]){for(int p=0;pID-KD)sz=ID-KD;if(sy>IH-KH)sy=IH-KH;if(sx>IW-KW)sx=IW-KW;float v=-3.402823466e38f;int best=0;for(int kz=0;kzv){v=x[b][c][sz+kz][sy+ky][sx+kx];best=((sz+kz)*IH+sy+ky)*IW+sx+kx;}out[b][c][oz][oy][ox]=v;index[b][c][oz][oy][ox]=best;}}""")
+    add("fractional_max_pool3d_backward_cpu", frac3, "fractional_max_pool3d_backward_out_frame", f3 + """void aten_fractional_max_pool3d_backward_cpu(float grad[B][C][OD][OH][OW],int index[B][C][OD][OH][OW],float out[B][C][ID][IH][IW]){for(int p=0;p=0&&iz=0&&iy=0&&ix=0&&iz=0&&iy=0&&ix255)q=255;out[i]=(unsigned char)q;}}")
+    add("grid_sampler_2d_fallback_cpu", grid, "_grid_sampler_2d_cpu_fallback", "#define N 256\nvoid aten_grid_sampler_2d_fallback_cpu(float input[N],int index[N],float out[N]){for(int i=0;i=0?input[index[i]]:0.0f;}")
+
+    pad = "aten/src/ATen/native/PadNd.cpp"
+    add("constant_pad_nd_cpu", pad, "constant_pad_nd", "#define N 32\n#define P 3\nvoid aten_constant_pad_nd_cpu(float x[N],float value,float out[N+2*P]){for(int i=0;i=diagonal):(j-i<=diagonal))?x[i][j]:0;}")
+    add("triu_tril_batch_cpu", tri, "apply_triu_tril", "#define B 4\n#define M 32\n#define N 24\nvoid aten_triu_tril_batch_cpu(float x[B][M][N],int diagonal,int upper,float out[B][M][N]){for(int b=0;b=diagonal):(j-i<=diagonal))?x[b][i][j]:0;}")
+
+    rng = "aten/src/ATen/native/RangeFactories.cpp"
+    add("logspace_cpu", rng, "logspace_out", "#define N 256\nextern float powf(float,float);void aten_logspace_cpu(float start,float end,float base,float out[N]){for(int i=0;iv){v=x[c][i];b=i;}out[c][o]=v;index[c][o]=b;}}")
+    add("upsample_bicubic2d_backward_cpu", "aten/src/ATen/native/UpSampleBicubic2d.cpp", "upsample_bicubic2d_backward_out_frame", "#define OH 8\n#define OW 8\n#define IH 5\n#define IW 5\nvoid aten_upsample_bicubic2d_backward_cpu(float grad[OH][OW],float out[IH][IW]){for(int p=0;p None:
+    loss_entries()
+    other_entries()
+    rows = []
+    for name, source, token, code in ENTRIES:
+        (OUT / f"{name}.c").write_text(code)
+        rows.append({"kernel": name, "source": source, "token": token})
+    with MANIFEST.open("w", newline="") as stream:
+        writer = csv.DictWriter(stream, fieldnames=("kernel", "source", "token"))
+        writer.writeheader()
+        writer.writerows(rows)
+    print(f"generated {len(rows)} additional C fixtures and {MANIFEST}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/correctness/generate_aten_remaining_extractions.py b/scripts/correctness/generate_aten_remaining_extractions.py
new file mode 100644
index 000000000000..ceac9d855364
--- /dev/null
+++ b/scripts/correctness/generate_aten_remaining_extractions.py
@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+"""Generate specialized standalone-C forms for remaining ATen loop bodies.
+
+The fixtures preserve the numerical loop carried by the named upstream body
+while fixing ranks, extents, dtypes, and optional modes so cgeist can expose a
+static loop nest.  PyTorch allocation, dispatch, shape checks, and Tensor-list
+orchestration deliberately remain outside the fixture.
+"""
+
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+OUT = ROOT / "issues/aten_c_kernels"
+MANIFEST = OUT / "generated_remaining_provenance.csv"
+E: list[tuple[str, str, str, str]] = []
+
+
+def add(name: str, source: str, token: str, code: str) -> None:
+    E.append((f"aten_{name}", source, token, code.strip() + "\n"))
+
+
+def reductions() -> None:
+    s = "aten/src/ATen/native/ReduceOps.cpp"
+    add("cumprod_backward_cpu", s, "cumprod_backward", """
+#define N 128
+void aten_cumprod_backward_cpu(float x[N],float prod[N],float grad[N],float out[N]){for(int i=0;i=v)||(!is_max&&x[r][i]<=v)){v=x[r][i];q=i;}out[r][i]=v;index[r][i]=q;}}}
+""")
+    add("diff_cpu", s, "diff_helper", "#define N 128\nvoid aten_diff_cpu(float x[N],float out[N-1]){for(int i=0;i None:
+    s = "aten/src/ATen/native/cpu/BlasKernel.cpp"
+    add("blas_scale_cpu", s, "scale_", "#define N 1024\nvoid aten_blas_scale_cpu(float x[N],float a){for(int i=0;i None:
+    s = "aten/src/ATen/native/TensorFactories.cpp"
+    add("eye_cpu", s, "eye_out_cpu", "#define N 64\nvoid aten_eye_cpu(float out[N][N]){for(int i=0;i0;--i){int j=bits[i]%(i+1);int t=out[i];out[i]=out[j];out[j]=t;}}")
+    add("tril_indices_cpu", s, "tril_indices_cpu", "#define N 32\n#define K (N*(N+1)/2)\nvoid aten_tril_indices_cpu(int row[K],int col[K]){for(int i=0;i None:
+    s = "aten/src/ATen/native/Bucketization.cpp"
+    add("lower_bound_cpu", s, "cus_lower_bound", "#define N 256\n#define M 128\nvoid aten_lower_bound_cpu(float x[N],float v[M],int out[M]){for(int q=0;q None:
+    add("col2im_cpu", "aten/src/ATen/native/Col2Im.cpp", "col2im_out_cpu_template", "#define C 2\n#define H 8\n#define W 8\n#define KH 3\n#define KW 3\nvoid aten_col2im_cpu(float col[C][KH][KW][H][W],float out[C][H+2][W+2]){for(int p=0;p None:
+    s = "aten/src/ATen/native/SparseTensorUtils.cpp"
+    add("sparse_flatten_indices_cpu", s, "flatten_indices_by_dims", "#define N 512\n#define D 3\nvoid aten_sparse_flatten_indices_cpu(int idx[D][N],int size[D],int out[N]){for(int n=0;n None:
+    s = "aten/src/ATen/native/Itertools.cpp"
+    add("triu_mask_cpu", s, "_triu_mask", "#define M 32\n#define N 32\nvoid aten_triu_mask_cpu(int mask[M][N],int diagonal){for(int i=0;i=diagonal;}")
+    add("cartesian_prod_cpu", s, "cartesian_prod", "#define A 16\n#define B 12\nvoid aten_cartesian_prod_cpu(float a[A],float b[B],float out[A*B][2]){for(int i=0;i>=1;}for(int d=0;d>=1;}for(int d=0;d>(b&7);}")
+    add("sobol_initialize_cpu", s, "_sobol_engine_initialize_state_", "#define D 8\nvoid aten_sobol_initialize_cpu(unsigned dirs[D][32],unsigned state[D]){for(int d=0;dthreshold;}}")
+    add("joint_scaling_cpu", "aten/src/ATen/native/ScaledBlas.cpp", "get_joint_scaling", "#define N 1024\nvoid aten_joint_scaling_cpu(float a[N],float b[N],float out[1]){float ma=0,mb=0;for(int i=0;ima)ma=x;if(y>mb)mb=y;}out[0]=ma*mb;}")
+
+
+def remaining_major() -> None:
+    s = "aten/src/ATen/native/TensorAdvancedIndexing.cpp"
+    add("unsafe_index_cpu", s, "_unsafe_index", "#define N 512\nvoid aten_unsafe_index_cpu(float x[N],int idx[N],float out[N]){for(int i=0;i=0&&iz=0&&iy=0&&ix=0&&iz=0&&iy=0&&ix None:
+    s = "aten/src/ATen/native/sparse/SparseTensorMath.cpp"
+    add("sparse_norm_cpu", s, "norm_sparse", "#define N 1024\nextern float sqrtf(float);void aten_sparse_norm_cpu(float value[N],float out[1]){float v=0;for(int i=0;i None:
+    s = "aten/src/ATen/native/Distributions.cpp"
+    add("sample_poisson_transform_cpu", s, "sample_poisson", "#define N 1024\nextern float expf(float);void aten_sample_poisson_transform_cpu(float lambda[N],float uniform[N][32],int out[N]){for(int i=0;is){++k;p*=lambda[i]/k;s+=p;}out[i]=k;}}")
+    add("standard_gamma_grad_cpu", s, "_standard_gamma_grad_cpu", "#define N 1024\nextern float logf(float);void aten_standard_gamma_grad_cpu(float a[N],float x[N],float out[N]){for(int i=0;iexpf(-lambda[i]))q*=uniform[i][k++];out[i]=k-1;}}")
+    add("gamma_transform_cpu", s, "_s_gamma_cpu", "#define N 1024\nextern float sqrtf(float);void aten_gamma_transform_cpu(float alpha[N],float normal[N],float uniform[N],float out[N]){for(int i=0;iv)v=table[index[b][l]][d];out[b][d]=v;}}")
+    add("embedding_bag_backward_max_cpu", s, "_embedding_bag_dense_backward_cpu_max", "#define B 32\n#define D 64\n#define E 1024\nvoid aten_embedding_bag_backward_max_cpu(float grad[B][D],int maxidx[B][D],float out[E][D]){for(int p=0;p None:
+    s = "aten/src/ATen/native/AdaptiveMaxPooling3d.cpp"
+    add("adaptive_max_pool3d_legacy_cpu", s, "adaptive_max_pool3d_out_frame", "#define C 2\n#define ID 8\n#define IH 9\n#define IW 10\n#define OD 3\n#define OH 4\n#define OW 5\nvoid aten_adaptive_max_pool3d_legacy_cpu(float x[C][ID][IH][IW],float out[C][OD][OH][OW],int idx[C][OD][OH][OW]){for(int c=0;cv){v=x[c][iz][iy][ix];b=(iz*IH+iy)*IW+ix;}out[c][z][y][q]=v;idx[c][z][y][q]=b;}}")
+    add("adaptive_max_pool3d_legacy_backward_cpu", s, "adaptive_max_pool3d_backward_out_frame", "#define C 2\n#define ID 8\n#define IH 9\n#define IW 10\n#define OD 3\n#define OH 4\n#define OW 5\nvoid aten_adaptive_max_pool3d_legacy_backward_cpu(float g[C][OD][OH][OW],int idx[C][OD][OH][OW],float out[C][ID][IH][IW]){for(int p=0;p127)v=127;out[i]=(signed char)v;}}")
+    add("compressed_block_convert_cpu", "aten/src/ATen/native/TensorConversions.cpp", "_compressed_to_block_compressed_cpu_kernel", "#define R 64\n#define C 64\n#define BR 4\n#define BC 4\nvoid aten_compressed_block_convert_cpu(float x[R][C],float out[R/BR][C/BC][BR][BC]){for(int r=0;r None:
+    reductions(); blas(); factories_and_spectral(); indexing_sorting()
+    convolutions(); sparse_and_shape(); misc(); remaining_major(); sparse_math(); final_families(); last_bodies()
+    rows = []
+    for name, source, token, code in E:
+        (OUT / f"{name}.c").write_text(code)
+        rows.append({"kernel": name, "source": source, "token": token})
+    with MANIFEST.open("w", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=("kernel", "source", "token"))
+        w.writeheader(); w.writerows(rows)
+    print(f"generated {len(rows)} remaining C fixtures and {MANIFEST}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/correctness/generate_aten_scalar_extractions.py b/scripts/correctness/generate_aten_scalar_extractions.py
new file mode 100644
index 000000000000..9775220e61a4
--- /dev/null
+++ b/scripts/correctness/generate_aten_scalar_extractions.py
@@ -0,0 +1,860 @@
+#!/usr/bin/env python3
+"""Generate standalone C specializations of simple ATen CPU scalar kernels.
+
+The formulas below are transcribed from the scalar lambdas in the pinned
+PyTorch checkout.  This removes TensorIterator, dispatch, vectorization, and
+dynamic-shape plumbing while retaining the numerical operation being tested.
+"""
+
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+OUT = ROOT / "issues/aten_c_kernels"
+MANIFEST = OUT / "generated_provenance.csv"
+
+UNARY = {
+    # name: (C expression, upstream token)
+    "abs": ("x[i] < 0.0f ? -x[i] : x[i]", "abs_kernel"),
+    "neg": ("-x[i]", "neg_kernel"),
+    "reciprocal": ("1.0f / x[i]", "reciprocal_kernel"),
+    "sign": ("(float)((0.0f < x[i]) - (x[i] < 0.0f))", "sign_kernel"),
+    "square": ("x[i] * x[i]", "square_kernel"),
+    "logical_not_f32": ("(float)(!x[i])", "logical_not_kernel"),
+}
+
+BINARY = {
+    "mul": ("a[i] * b[i]", "mul_kernel"),
+    "div": ("a[i] / b[i]", "div_true_kernel"),
+    "maximum": ("a[i] > b[i] ? a[i] : b[i]", "maximum_kernel"),
+    "minimum": ("a[i] < b[i] ? a[i] : b[i]", "minimum_kernel"),
+    "lt": ("(float)(a[i] < b[i])", "lt_kernel"),
+    "le": ("(float)(a[i] <= b[i])", "le_kernel"),
+    "gt": ("(float)(a[i] > b[i])", "gt_kernel"),
+    "ge": ("(float)(a[i] >= b[i])", "ge_kernel"),
+    "eq": ("(float)(a[i] == b[i])", "eq_kernel"),
+    "ne": ("(float)(a[i] != b[i])", "ne_kernel"),
+    "mse_elementwise": ("(a[i] - b[i]) * (a[i] - b[i])", "mse_kernel"),
+}
+
+# Math-heavy TensorIterator lambdas. External calls are kept deliberately:
+# cgeist can represent them faithfully, and the sweep records whether such a
+# call prevents loop-to-Linalg conversion instead of silently simplifying the
+# ATen operation.
+MATH_UNARY = {
+    "frac": ("x[i] - truncf(x[i])", "frac_kernel", "truncf"),
+    "sinc": ("x[i] == 0.0f ? 1.0f : sinf(3.14159265358979323846f * x[i]) / (3.14159265358979323846f * x[i])", "sinc_kernel", "sinf"),
+    "sinh": ("sinhf(x[i])", "sinh_kernel", "sinhf"),
+    "cosh": ("coshf(x[i])", "cosh_kernel", "coshf"),
+    "acosh": ("acoshf(x[i])", "acosh_kernel", "acoshf"),
+    "asinh": ("asinhf(x[i])", "asinh_kernel", "asinhf"),
+    "atanh": ("atanhf(x[i])", "atanh_kernel", "atanhf"),
+    "exp2": ("exp2f(x[i])", "exp2_kernel", "exp2f"),
+    "rsqrt": ("1.0f / sqrtf(x[i])", "rsqrt_kernel", "sqrtf"),
+    "ceil": ("ceilf(x[i])", "ceil_kernel", "ceilf"),
+    "floor": ("floorf(x[i])", "floor_kernel", "floorf"),
+    "round": ("roundf(x[i])", "round_kernel", "roundf"),
+    "sqrt": ("sqrtf(x[i])", "sqrt_kernel", "sqrtf"),
+    "trunc": ("truncf(x[i])", "trunc_kernel", "truncf"),
+    "sin": ("sinf(x[i])", "sin_kernel", "sinf"),
+    "cos": ("cosf(x[i])", "cos_kernel", "cosf"),
+    "tan": ("tanf(x[i])", "tan_kernel", "tanf"),
+    "acos": ("acosf(x[i])", "acos_kernel", "acosf"),
+    "asin": ("asinf(x[i])", "asin_kernel", "asinf"),
+    "atan": ("atanf(x[i])", "atan_kernel", "atanf"),
+    "erf": ("erff(x[i])", "erf_kernel", "erff"),
+    "erfc": ("erfcf(x[i])", "erfc_kernel", "erfcf"),
+    "exp": ("expf(x[i])", "exp_kernel", "expf"),
+    "expm1": ("expm1f(x[i])", "expm1_kernel", "expm1f"),
+    "log": ("logf(x[i])", "log_kernel", "logf"),
+    "log10": ("log10f(x[i])", "log10_kernel", "log10f"),
+    "log1p": ("log1pf(x[i])", "log1p_kernel", "log1pf"),
+    "log2": ("log2f(x[i])", "log2_kernel", "log2f"),
+    "lgamma": ("lgammaf(x[i])", "lgamma_kernel", "lgammaf"),
+    "digamma": ("calc_digammaf(x[i])", "digamma_kernel", "calc_digammaf"),
+    "trigamma": ("calc_trigammaf(x[i])", "trigamma_kernel", "calc_trigammaf"),
+    "ndtri": ("calc_ndtrif(x[i])", "ndtri_kernel", "calc_ndtrif"),
+    "log_ndtr": ("calc_log_ndtrf(x[i])", "log_ndtr_kernel", "calc_log_ndtrf"),
+    "i0": ("calc_i0f(x[i])", "i0_kernel", "calc_i0f"),
+    "i0e": ("calc_i0ef(x[i])", "i0e_kernel", "calc_i0ef"),
+    "i1": ("calc_i1f(x[i])", "i1_kernel", "calc_i1f"),
+    "i1e": ("calc_i1ef(x[i])", "i1e_kernel", "calc_i1ef"),
+    "erfcx": ("calc_erfcxf(x[i])", "erfcx_kernel", "calc_erfcxf"),
+    "erfinv": ("calc_erfinvf(x[i])", "erfinv_kernel", "calc_erfinvf"),
+    "bessel_j0": ("bessel_j0_forwardf(x[i])", "bessel_j0_kernel", "bessel_j0_forwardf"),
+    "bessel_j1": ("bessel_j1_forwardf(x[i])", "bessel_j1_kernel", "bessel_j1_forwardf"),
+    "bessel_y0": ("bessel_y0_forwardf(x[i])", "bessel_y0_kernel", "bessel_y0_forwardf"),
+    "bessel_y1": ("bessel_y1_forwardf(x[i])", "bessel_y1_kernel", "bessel_y1_forwardf"),
+    "modified_bessel_i0": ("modified_bessel_i0_forwardf(x[i])", "modified_bessel_i0_kernel", "modified_bessel_i0_forwardf"),
+    "modified_bessel_i1": ("modified_bessel_i1_forwardf(x[i])", "modified_bessel_i1_kernel", "modified_bessel_i1_forwardf"),
+    "modified_bessel_k0": ("modified_bessel_k0_forwardf(x[i])", "modified_bessel_k0_kernel", "modified_bessel_k0_forwardf"),
+    "modified_bessel_k1": ("modified_bessel_k1_forwardf(x[i])", "modified_bessel_k1_kernel", "modified_bessel_k1_forwardf"),
+}
+
+MATH_BINARY = {
+    "atan2": ("atan2f(a[i], b[i])", "atan2_kernel", "atan2f"),
+    "fmod": ("fmodf(a[i], b[i])", "fmod_kernel", "fmodf"),
+    "remainder": ("remainderf(a[i], b[i])", "remainder_kernel", "remainderf"),
+    "fmax": ("fmaxf(a[i], b[i])", "fmax_kernel", "fmaxf"),
+    "fmin": ("fminf(a[i], b[i])", "fmin_kernel", "fminf"),
+    "hypot": ("hypotf(a[i], b[i])", "hypot_kernel", "hypotf"),
+    "nextafter": ("nextafterf(a[i], b[i])", "nextafter_kernel", "nextafterf"),
+    "copysign": ("copysignf(a[i], b[i])", "copysign_kernel", "copysignf"),
+    "pow": ("powf(a[i], b[i])", "pow_tensor_tensor_kernel", "powf"),
+    "igamma": ("calc_igammaf(a[i], b[i])", "igamma_kernel", "calc_igammaf"),
+    "igammac": ("calc_igammacf(a[i], b[i])", "igammac_kernel", "calc_igammacf"),
+    "zeta": ("calc_zetaf(a[i], b[i])", "zeta_kernel", "calc_zetaf"),
+    "chebyshev_polynomial_t": ("calc_chebyshev_tf(a[i], b[i])", "chebyshev_polynomial_t_kernel", "calc_chebyshev_tf"),
+    "chebyshev_polynomial_u": ("calc_chebyshev_uf(a[i], b[i])", "chebyshev_polynomial_u_kernel", "calc_chebyshev_uf"),
+    "chebyshev_polynomial_v": ("calc_chebyshev_vf(a[i], b[i])", "chebyshev_polynomial_v_kernel", "calc_chebyshev_vf"),
+    "chebyshev_polynomial_w": ("calc_chebyshev_wf(a[i], b[i])", "chebyshev_polynomial_w_kernel", "calc_chebyshev_wf"),
+    "laguerre_polynomial_l": ("calc_laguerre_lf(a[i], b[i])", "laguerre_polynomial_l_kernel", "calc_laguerre_lf"),
+    "legendre_polynomial_p": ("calc_legendre_pf(a[i], b[i])", "legendre_polynomial_p_kernel", "calc_legendre_pf"),
+    "hermite_polynomial_h": ("calc_hermite_hf(a[i], b[i])", "hermite_polynomial_h_kernel", "calc_hermite_hf"),
+    "hermite_polynomial_he": ("calc_hermite_hef(a[i], b[i])", "hermite_polynomial_he_kernel", "calc_hermite_hef"),
+}
+
+INT_BINARY = {
+    "bitwise_and_i32": ("a[i] & b[i]", "bitwise_and_kernel"),
+    "bitwise_or_i32": ("a[i] | b[i]", "bitwise_or_kernel"),
+    "bitwise_xor_i32": ("a[i] ^ b[i]", "bitwise_xor_kernel"),
+    "lshift_i32": ("a[i] << b[i]", "lshift_kernel"),
+    "rshift_i32": ("a[i] >> b[i]", "rshift_kernel"),
+}
+
+CUSTOM = {
+    "smooth_l1_elementwise": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "smooth_l1_kernel",
+        "float z = a[i] - b[i];\n"
+        "    float az = z < 0.0f ? -z : z;\n"
+        "    out[i] = az < beta ? 0.5f * z * z / beta : az - 0.5f * beta;",
+        "float a[N], float b[N], float beta, float out[N]",
+    ),
+    "huber_elementwise": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "huber_kernel",
+        "float z = a[i] - b[i];\n"
+        "    float az = z < 0.0f ? -z : z;\n"
+        "    out[i] = az < delta ? 0.5f * z * z : delta * (az - 0.5f * delta);",
+        "float a[N], float b[N], float delta, float out[N]",
+    ),
+    "sigmoid_backward": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "sigmoid_backward_kernel",
+        "out[i] = grad[i] * (1.0f - output[i]) * output[i];",
+        "float grad[N], float output[N], float out[N]",
+    ),
+    "tanh_backward": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "tanh_backward_kernel",
+        "out[i] = grad[i] * (1.0f - output[i] * output[i]);",
+        "float grad[N], float output[N], float out[N]",
+    ),
+    "threshold_backward": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "threshold_kernel",
+        "out[i] = self[i] <= threshold ? 0.0f : grad[i];",
+        "float grad[N], float self[N], float threshold, float out[N]",
+    ),
+    "elu_backward": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "elu_backward_kernel",
+        "out[i] = output[i] <= 0.0f ? grad[i] * (output[i] + alpha) * scale : grad[i] * scale;",
+        "float grad[N], float output[N], float alpha, float scale, float out[N]",
+    ),
+    "softplus_backward": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "softplus_backward_kernel",
+        "float z = beta * self[i];\n"
+        "    out[i] = z > threshold ? grad[i] : grad[i] * (1.0f - 1.0f / (1.0f + expf(z)));",
+        "float grad[N], float self[N], float beta, float threshold, float out[N]",
+    ),
+    "addcmul": (
+        "aten/src/ATen/native/cpu/PointwiseOpsKernel.cpp", "addcmul_cpu",
+        "out[i] = self[i] + value * x[i] * y[i];",
+        "float self[N], float x[N], float y[N], float value, float out[N]",
+    ),
+    "addcdiv": (
+        "aten/src/ATen/native/cpu/PointwiseOpsKernel.cpp", "addcdiv_cpu",
+        "out[i] = self[i] + value * x[i] / y[i];",
+        "float self[N], float x[N], float y[N], float value, float out[N]",
+    ),
+    "fill": (
+        "aten/src/ATen/native/cpu/FillKernel.cpp", "fill_kernel",
+        "out[i] = value;", "float value, float out[N]",
+    ),
+    "linspace": (
+        "aten/src/ATen/native/cpu/RangeFactoriesKernel.cpp", "linspace_kernel",
+        "out[i] = start + (float)i * step;",
+        "float start, float step, float out[N]",
+    ),
+    "masked_scale": (
+        "aten/src/ATen/native/cpu/AmpGradScalerKernels.cpp", "_amp_foreach_non_finite_check_and_unscale_cpu_kernel",
+        "out[i] = x[i] * inv_scale;",
+        "float x[N], float inv_scale, float out[N]",
+    ),
+    "lerp_scalar": (
+        "aten/src/ATen/native/cpu/LerpKernel.cpp", "lerp_kernel_scalar",
+        "out[i] = self[i] + weight * (end[i] - self[i]);",
+        "float self[N], float end[N], float weight, float out[N]",
+    ),
+    "heaviside": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "heaviside_kernel",
+        "out[i] = a[i] == 0.0f ? b[i] : (float)(a[i] > 0.0f);",
+        "float a[N], float b[N], float out[N]",
+    ),
+    "logical_and": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "logical_and_kernel",
+        "out[i] = (float)((a[i] != 0.0f) && (b[i] != 0.0f));",
+        "float a[N], float b[N], float out[N]",
+    ),
+    "logical_or": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "logical_or_kernel",
+        "out[i] = (float)((a[i] != 0.0f) || (b[i] != 0.0f));",
+        "float a[N], float b[N], float out[N]",
+    ),
+    "logical_xor": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "logical_xor_kernel",
+        "out[i] = (float)((a[i] != 0.0f) != (b[i] != 0.0f));",
+        "float a[N], float b[N], float out[N]",
+    ),
+    "addr_elementwise": (
+        "aten/src/ATen/native/cpu/LinearAlgebraKernel.cpp", "addr_kernel",
+        "out[i] = beta == 0.0f ? alpha * x[i] * y[i] : beta * self[i] + alpha * x[i] * y[i];",
+        "float self[N], float x[N], float y[N], float beta, float alpha, float out[N]",
+    ),
+    "xlogy": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "xlogy_kernel",
+        "out[i] = y[i] != y[i] ? y[i] : (x[i] == 0.0f ? 0.0f : x[i] * logf(y[i]));",
+        "float x[N], float y[N], float out[N]",
+    ),
+    "xlog1py": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "xlog1py_kernel",
+        "out[i] = y[i] != y[i] ? y[i] : (x[i] == 0.0f ? 0.0f : x[i] * log1pf(y[i]));",
+        "float x[N], float y[N], float out[N]",
+    ),
+    "hardsigmoid_backward": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "hardsigmoid_backward_kernel",
+        "out[i] = self[i] > -3.0f && self[i] < 3.0f ? grad[i] * (1.0f / 6.0f) : 0.0f;",
+        "float grad[N], float self[N], float out[N]",
+    ),
+    "hardtanh_backward": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "hardtanh_backward_kernel",
+        "out[i] = self[i] <= minval || self[i] >= maxval ? 0.0f : grad[i];",
+        "float grad[N], float self[N], float minval, float maxval, float out[N]",
+    ),
+    "hardshrink": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "hardshrink_kernel",
+        "out[i] = self[i] >= -lambd && self[i] <= lambd ? 0.0f : self[i];",
+        "float self[N], float lambd, float out[N]",
+    ),
+    "softshrink": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "softshrink_kernel",
+        "out[i] = self[i] > lambd ? self[i] - lambd : (self[i] < -lambd ? self[i] + lambd : self[i] * 0.0f);",
+        "float self[N], float lambd, float out[N]",
+    ),
+    "shrink_backward": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "shrink_backward_kernel",
+        "out[i] = self[i] >= -lambd && self[i] <= lambd ? 0.0f : grad[i];",
+        "float grad[N], float self[N], float lambd, float out[N]",
+    ),
+    "hardswish_backward": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "hardswish_backward_kernel",
+        "out[i] = self[i] <= -3.0f ? 0.0f : (self[i] < 3.0f ? grad[i] * (self[i] / 3.0f + 0.5f) : grad[i]);",
+        "float grad[N], float self[N], float out[N]",
+    ),
+    "glu": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "glu_kernel",
+        "out[i] = a[i] / (1.0f + expf(-b[i]));",
+        "float a[N], float b[N], float out[N]",
+    ),
+    "glu_backward": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "glu_backward_kernel",
+        "out[i] = (1.0f - sigmoid_b[i]) * sigmoid_b[i] * grad[i] * a[i];",
+        "float sigmoid_b[N], float grad[N], float a[N], float out[N]",
+    ),
+    "glu_jvp": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "glu_jvp_kernel",
+        "float s = 1.0f / (1.0f + expf(-b[i]));\n    out[i] = da[i] * s + result[i] * (db[i] - s * db[i]);",
+        "float result[N], float b[N], float da[N], float db[N], float out[N]",
+    ),
+    "silu_cpu": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "silu_kernel",
+        "out[i] = x[i] / (1.0f + expf(-x[i]));",
+        "float x[N], float out[N]",
+    ),
+    "silu_backward": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "silu_backward_kernel",
+        "float s = 1.0f / (1.0f + expf(-x[i]));\n    out[i] = grad[i] * s * (1.0f + x[i] * (1.0f - s));",
+        "float grad[N], float x[N], float out[N]",
+    ),
+    "mish": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "mish_kernel",
+        "out[i] = x[i] * tanhf(log1pf(expf(x[i])));",
+        "float x[N], float out[N]",
+    ),
+    "mish_backward": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "mish_backward_kernel",
+        "float s = 1.0f / (1.0f + expf(-x[i]));\n    float t = tanhf(log1pf(expf(x[i])));\n    out[i] = grad[i] * (t + x[i] * s * (1.0f - t * t));",
+        "float grad[N], float x[N], float out[N]",
+    ),
+    "add_clamp": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "add_clamp_kernel",
+        "float v = a[i] + alpha * b[i];\n    out[i] = v < minval ? minval : (v > maxval ? maxval : v);",
+        "float a[N], float b[N], float alpha, float minval, float maxval, float out[N]",
+    ),
+    "div_trunc": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "div_trunc_kernel",
+        "out[i] = truncf(a[i] / b[i]);",
+        "float a[N], float b[N], float out[N]",
+    ),
+    "div_floor": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "div_floor_kernel",
+        "out[i] = floorf(a[i] / b[i]);",
+        "float a[N], float b[N], float out[N]",
+    ),
+    "logit_backward": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "logit_backward_kernel",
+        "out[i] = self[i] < eps || self[i] > 1.0f - eps ? 0.0f : grad[i] / (self[i] * (1.0f - self[i]));",
+        "float grad[N], float self[N], float eps, float out[N]",
+    ),
+    "logaddexp": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "logaddexp_kernel",
+        "float m = a[i] > b[i] ? a[i] : b[i];\n    float d = a[i] - b[i];\n    if (d < 0.0f) d = -d;\n    out[i] = m + log1pf(expf(-d));",
+        "float a[N], float b[N], float out[N]",
+    ),
+    "logaddexp2": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "logaddexp2_kernel",
+        "float m = a[i] > b[i] ? a[i] : b[i];\n    float d = a[i] - b[i];\n    if (d < 0.0f) d = -d;\n    out[i] = m + log1pf(exp2f(-d)) * 1.4426950408889634f;",
+        "float a[N], float b[N], float out[N]",
+    ),
+    "gcd_i32": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "gcd_kernel",
+        "int x = a[i] < 0 ? -a[i] : a[i];\n    int y = b[i] < 0 ? -b[i] : b[i];\n    while (y != 0) { int r = x % y; x = y; y = r; }\n    out[i] = x;",
+        "int a[N], int b[N], int out[N]",
+    ),
+    "lcm_i32": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "lcm_kernel",
+        "int x = a[i] < 0 ? -a[i] : a[i];\n    int y = b[i] < 0 ? -b[i] : b[i];\n    int aa = x, bb = y;\n    while (y != 0) { int r = x % y; x = y; y = r; }\n    out[i] = x == 0 ? 0 : (aa / x) * bb;",
+        "int a[N], int b[N], int out[N]",
+    ),
+    "ldexp": (
+        "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp", "ldexp_kernel",
+        "out[i] = ldexpf(a[i], exponent[i]);",
+        "float a[N], int exponent[N], float out[N]",
+    ),
+    "log_sigmoid_cpu": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "log_sigmoid_cpu_kernel",
+        "float ax = x[i] < 0.0f ? -x[i] : x[i];\n    buffer[i] = expf(-ax);\n    out[i] = (x[i] < 0.0f ? x[i] : 0.0f) - log1pf(buffer[i]);",
+        "float x[N], float out[N], float buffer[N]",
+    ),
+    "log_sigmoid_backward_cpu": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "log_sigmoid_backward_cpu_kernel",
+        "float neg = input[i] < 0.0f;\n    float max_deriv = neg ? 1.0f : 0.0f;\n    float sign = neg ? 1.0f : -1.0f;\n    out[i] = (max_deriv - sign * (buffer[i] / (1.0f + buffer[i]))) * grad[i];",
+        "float input[N], float buffer[N], float grad[N], float out[N]",
+    ),
+    "gelu_cpu_tanh": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "GeluKernelImpl",
+        "float inner = 0.7978845608028654f * (x[i] + 0.044715f * x[i] * x[i] * x[i]);\n    out[i] = 0.5f * x[i] * (1.0f + tanhf(inner));",
+        "float x[N], float out[N]",
+    ),
+    "gelu_cpu_exact": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "GeluKernelImpl",
+        "out[i] = 0.5f * x[i] * (1.0f + erff(x[i] * 0.7071067811865475f));",
+        "float x[N], float out[N]",
+    ),
+    "gelu_backward_cpu_tanh": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "GeluBackwardKernelImpl",
+        "float x2 = x[i] * x[i];\n    float inner = 0.7978845608028654f * (x[i] + 0.044715f * x[i] * x2);\n    float t = tanhf(inner);\n    float deriv = 0.5f * (1.0f + t) + 0.5f * x[i] * (1.0f - t * t) * 0.7978845608028654f * (1.0f + 3.0f * 0.044715f * x2);\n    out[i] = grad[i] * deriv;",
+        "float grad[N], float x[N], float out[N]",
+    ),
+    "gelu_backward_cpu_exact": (
+        "aten/src/ATen/native/cpu/Activation.cpp", "GeluBackwardKernelImpl",
+        "float cdf = 0.5f * (1.0f + erff(x[i] * 0.7071067811865475f));\n    float pdf = 0.3989422804014327f * expf(-0.5f * x[i] * x[i]);\n    out[i] = grad[i] * (cdf + x[i] * pdf);",
+        "float grad[N], float x[N], float out[N]",
+    ),
+    "round_decimals": (
+        "aten/src/ATen/native/cpu/UnaryOpsKernel.cpp", "round_decimals_kernel",
+        "out[i] = roundf(x[i] * scale) / scale;",
+        "float x[N], float scale, float out[N]",
+    ),
+    "angle_real": (
+        "aten/src/ATen/native/cpu/UnaryOpsKernel.cpp", "angle_kernel",
+        "out[i] = x[i] < 0.0f ? 3.14159265358979323846f : 0.0f;",
+        "float x[N], float out[N]",
+    ),
+    "angle_complex_scalarized": (
+        "aten/src/ATen/native/cpu/UnaryOpsKernel.cpp", "angle_kernel",
+        "out[i] = atan2f(im[i], re[i]);",
+        "float re[N], float im[N], float out[N]",
+    ),
+    "signbit": (
+        "aten/src/ATen/native/cpu/UnaryOpsKernel.cpp", "signbit_kernel",
+        "out[i] = (float)(x[i] < 0.0f);",
+        "float x[N], float out[N]",
+    ),
+    "bitwise_not_i32": (
+        "aten/src/ATen/native/cpu/UnaryOpsKernel.cpp", "bitwise_not_kernel",
+        "out[i] = ~x[i];",
+        "int x[N], int out[N]",
+    ),
+    "nan_to_num": (
+        "aten/src/ATen/native/cpu/UnaryOpsKernel.cpp", "nan_to_num_kernel",
+        "out[i] = x[i] != x[i] ? nan_value : (x[i] > max_finite ? posinf_value : (x[i] < -max_finite ? neginf_value : x[i]));",
+        "float x[N], float nan_value, float posinf_value, float neginf_value, float max_finite, float out[N]",
+    ),
+    "conj_complex_scalarized": (
+        "aten/src/ATen/native/cpu/UnaryOpsKernel.cpp", "conj_kernel",
+        "out_re[i] = re[i];\n    out_im[i] = -im[i];",
+        "float re[N], float im[N], float out_re[N], float out_im[N]",
+    ),
+    "entr": (
+        "aten/src/ATen/native/cpu/UnaryOpsKernel.cpp", "entr_kernel",
+        "out[i] = x[i] < 0.0f ? nan_value : (x[i] == 0.0f ? 0.0f : (x[i] <= 1.0f ? -x[i] * logf(x[i]) : neg_inf));",
+        "float x[N], float nan_value, float neg_inf, float out[N]",
+    ),
+    "sgn_complex_scalarized": (
+        "aten/src/ATen/native/cpu/UnaryOpsKernel.cpp", "sgn_kernel",
+        "float mag = hypotf(re[i], im[i]);\n    out_re[i] = mag == 0.0f ? 0.0f : re[i] / mag;\n    out_im[i] = mag == 0.0f ? 0.0f : im[i] / mag;",
+        "float re[N], float im[N], float out_re[N], float out_im[N]",
+    ),
+    "logit": (
+        "aten/src/ATen/native/cpu/UnaryOpsKernel.cpp", "logit_kernel",
+        "float z = x[i] < eps ? eps : (x[i] > 1.0f - eps ? 1.0f - eps : x[i]);\n    out[i] = logf(z / (1.0f - z));",
+        "float x[N], float eps, float out[N]",
+    ),
+    "polygamma": (
+        "aten/src/ATen/native/cpu/UnaryOpsKernel.cpp", "polygamma_kernel",
+        "out[i] = calc_polygammaf(order, x[i]);",
+        "float x[N], int order, float out[N]",
+    ),
+    "kaiser_window": (
+        "aten/src/ATen/native/cpu/UnaryOpsKernel.cpp", "kaiser_window_kernel",
+        "out[i] = calc_kaiserf(x[i], beta);",
+        "float x[N], float beta, float out[N]",
+    ),
+    "where_cpu": (
+        "aten/src/ATen/native/cpu/TensorCompareKernel.cpp", "where_kernel_impl",
+        "out[i] = condition[i] ? a[i] : b[i];",
+        "int condition[N], float a[N], float b[N], float out[N]",
+    ),
+    "isposinf": (
+        "aten/src/ATen/native/cpu/TensorCompareKernel.cpp", "isposinf_kernel_impl",
+        "out[i] = (float)(x[i] > max_finite);",
+        "float x[N], float max_finite, float out[N]",
+    ),
+    "isneginf": (
+        "aten/src/ATen/native/cpu/TensorCompareKernel.cpp", "isneginf_kernel_impl",
+        "out[i] = (float)(x[i] < -max_finite);",
+        "float x[N], float max_finite, float out[N]",
+    ),
+    "clamp_cpu": (
+        "aten/src/ATen/native/cpu/TensorCompareKernel.cpp", "clamp_kernel_impl",
+        "out[i] = x[i] < minval[i] ? minval[i] : (x[i] > maxval[i] ? maxval[i] : x[i]);",
+        "float x[N], float minval[N], float maxval[N], float out[N]",
+    ),
+    "clamp_scalar_cpu": (
+        "aten/src/ATen/native/cpu/TensorCompareKernel.cpp", "clamp_scalar_kernel_impl",
+        "out[i] = x[i] < minval ? minval : (x[i] > maxval ? maxval : x[i]);",
+        "float x[N], float minval, float maxval, float out[N]",
+    ),
+    "clamp_min_scalar_cpu": (
+        "aten/src/ATen/native/cpu/TensorCompareKernel.cpp", "clamp_min_scalar_kernel_impl",
+        "out[i] = x[i] < minval ? minval : x[i];",
+        "float x[N], float minval, float out[N]",
+    ),
+    "clamp_max_scalar_cpu": (
+        "aten/src/ATen/native/cpu/TensorCompareKernel.cpp", "clamp_max_scalar_kernel_impl",
+        "out[i] = x[i] > maxval ? maxval : x[i];",
+        "float x[N], float maxval, float out[N]",
+    ),
+    "complex_scalarized": (
+        "aten/src/ATen/native/cpu/ComplexKernel.cpp", "complex_kernel",
+        "out_re[i] = real[i];\n    out_im[i] = imag[i];",
+        "float real[N], float imag[N], float out_re[N], float out_im[N]",
+    ),
+    "polar_scalarized": (
+        "aten/src/ATen/native/cpu/ComplexKernel.cpp", "polar_kernel",
+        "out_re[i] = magnitude[i] * cosf(angle[i]);\n    out_im[i] = magnitude[i] * sinf(angle[i]);",
+        "float magnitude[N], float angle[N], float out_re[N], float out_im[N]",
+    ),
+    "copy_cpu": (
+        "aten/src/ATen/native/cpu/CopyKernel.cpp", "copy_kernel",
+        "out[i] = input[i];",
+        "float input[N], float out[N]",
+    ),
+    "linear_combination_cpu": (
+        "aten/src/ATen/native/cpu/FunctionOfAMatrixUtilsKernel.cpp", "_compute_linear_combination_cpu_kernel",
+        "float value = 0.0f;\n    for (int j = 0; j < 4; ++j) value += coefficients[j] * input[j][i];\n    out[i] = value;",
+        "float input[4][N], float coefficients[4], float out[N]",
+    ),
+    "lerp_scalar_cpu": (
+        "aten/src/ATen/native/cpu/LerpKernel.cpp", "lerp_scalar_kernel",
+        "out[i] = self[i] + weight * (end[i] - self[i]);",
+        "float self[N], float end[N], float weight, float out[N]",
+    ),
+    "lerp_tensor_cpu": (
+        "aten/src/ATen/native/cpu/LerpKernel.cpp", "lerp_tensor_kernel",
+        "out[i] = self[i] + weight[i] * (end[i] - self[i]);",
+        "float self[N], float end[N], float weight[N], float out[N]",
+    ),
+    "smooth_l1_backward": (
+        "aten/src/ATen/native/cpu/PointwiseOpsKernel.cpp", "smooth_l1_backward_cpu_kernel",
+        "float z = input[i] - target[i];\n    out[i] = z <= -beta ? -norm : (z >= beta ? norm : norm * z / beta);",
+        "float input[N], float target[N], float norm, float beta, float out[N]",
+    ),
+    "huber_backward": (
+        "aten/src/ATen/native/cpu/PointwiseOpsKernel.cpp", "huber_backward_cpu_kernel",
+        "float z = input[i] - target[i];\n    out[i] = z < -delta ? -norm * delta : (z > delta ? norm * delta : norm * z);",
+        "float input[N], float target[N], float norm, float delta, float out[N]",
+    ),
+    "mse_backward": (
+        "aten/src/ATen/native/cpu/PointwiseOpsKernel.cpp", "mse_backward_cpu_kernel",
+        "out[i] = value * (input[i] - target[i]);",
+        "float input[N], float target[N], float value, float out[N]",
+    ),
+    "pow_tensor_scalar": (
+        "aten/src/ATen/native/cpu/PowKernel.cpp", "pow_tensor_scalar_kernel",
+        "out[i] = powf(input[i], exponent);",
+        "float input[N], float exponent, float out[N]",
+    ),
+    "arange_cpu": (
+        "aten/src/ATen/native/cpu/RangeFactoriesKernel.cpp", "arange_kernel",
+        "out[i] = start + (float)i * step;",
+        "float start, float step, float out[N]",
+    ),
+    "renorm_scale_factor": (
+        "aten/src/ATen/native/cpu/RenormKernel.cpp", "renorm_scale_factor_impl",
+        "out[i] = norm[i] > maxnorm ? maxnorm / (norm[i] + 1.0e-7f) : 1.0f;",
+        "float norm[N], float maxnorm, float out[N]",
+    ),
+    "airy_ai": (
+        "aten/src/ATen/native/cpu/airy_ai.cpp", "airy_ai_kernel",
+        "out[i] = calc_airy_aif(x[i]);",
+        "float x[N], float out[N]",
+    ),
+    "scaled_modified_bessel_k0": (
+        "aten/src/ATen/native/cpu/scaled_modified_bessel_k0.cpp", "scaled_modified_bessel_k0_kernel",
+        "out[i] = calc_scaled_bessel_k0f(x[i]);",
+        "float x[N], float out[N]",
+    ),
+    "scaled_modified_bessel_k1": (
+        "aten/src/ATen/native/cpu/scaled_modified_bessel_k1.cpp", "scaled_modified_bessel_k1_kernel",
+        "out[i] = calc_scaled_bessel_k1f(x[i]);",
+        "float x[N], float out[N]",
+    ),
+    "spherical_bessel_j0": (
+        "aten/src/ATen/native/cpu/spherical_bessel_j0.cpp", "spherical_bessel_j0_kernel",
+        "out[i] = calc_spherical_bessel_j0f(x[i]);",
+        "float x[N], float out[N]",
+    ),
+}
+
+FULL = {
+    "max_reduce_cpu": (
+        "aten/src/ATen/native/cpu/TensorCompareKernel.cpp", "max_kernel_impl",
+        """#ifndef N
+#define N 4096
+#endif
+void aten_max_reduce_cpu(float x[N], float out[1]) {
+#pragma scop
+  float value = x[0];
+  for (int i = 1; i < N; ++i) value = x[i] > value ? x[i] : value;
+  out[0] = value;
+#pragma endscop
+}
+""",
+    ),
+    "min_reduce_cpu": (
+        "aten/src/ATen/native/cpu/TensorCompareKernel.cpp", "min_kernel_impl",
+        """#ifndef N
+#define N 4096
+#endif
+void aten_min_reduce_cpu(float x[N], float out[1]) {
+#pragma scop
+  float value = x[0];
+  for (int i = 1; i < N; ++i) value = x[i] < value ? x[i] : value;
+  out[0] = value;
+#pragma endscop
+}
+""",
+    ),
+    "aminmax_cpu": (
+        "aten/src/ATen/native/cpu/TensorCompareKernel.cpp", "aminmax_kernel",
+        """#ifndef N
+#define N 4096
+#endif
+void aten_aminmax_cpu(float x[N], float out_min[1], float out_max[1]) {
+#pragma scop
+  float lo = x[0], hi = x[0];
+  for (int i = 1; i < N; ++i) {
+    lo = x[i] < lo ? x[i] : lo;
+    hi = x[i] > hi ? x[i] : hi;
+  }
+  out_min[0] = lo; out_max[0] = hi;
+#pragma endscop
+}
+""",
+    ),
+    "mode_cpu": (
+        "aten/src/ATen/native/cpu/TensorCompareKernel.cpp", "mode_kernel_impl",
+        """#ifndef N
+#define N 64
+#endif
+void aten_mode_cpu(float x[N], float out[1], int out_index[1]) {
+  float work[N];
+  int indices[N];
+  for (int i = 0; i < N; ++i) { work[i] = x[i]; indices[i] = i; }
+  for (int i = 1; i < N; ++i) {
+    float v = work[i]; int idx = indices[i]; int j = i - 1;
+    while (j >= 0 && work[j] > v) {
+      work[j + 1] = work[j]; indices[j + 1] = indices[j]; --j;
+    }
+    work[j + 1] = v; indices[j + 1] = idx;
+  }
+  int best_count = 1, count = 1, best = 0;
+  for (int i = 1; i < N; ++i) {
+    if (work[i] == work[i - 1]) ++count; else count = 1;
+    if (count > best_count) { best_count = count; best = i; }
+  }
+  out[0] = work[best]; out_index[0] = indices[best];
+}
+""",
+    ),
+    "isin_default_cpu": (
+        "aten/src/ATen/native/cpu/TensorCompareKernel.cpp", "isin_default_kernel_cpu",
+        """#ifndef N
+#define N 4096
+#endif
+#ifndef M
+#define M 257
+#endif
+void aten_isin_default_cpu(float elements[N], float test[M], int out[N]) {
+#pragma scop
+  for (int i = 0; i < N; ++i) {
+    int found = 0;
+    for (int j = 0; j < M; ++j) found |= elements[i] == test[j];
+    out[i] = found;
+  }
+#pragma endscop
+}
+""",
+    ),
+    "min_all_cpu": (
+        "aten/src/ATen/native/cpu/ReduceAllOpsKernel.cpp", "min_all_kernel_impl",
+        """#ifndef N
+#define N 4096
+#endif
+void aten_min_all_cpu(float x[N], float out[1]) {
+  float value = x[0];
+  for (int i = 1; i < N; ++i) value = x[i] < value ? x[i] : value;
+  out[0] = value;
+}
+""",
+    ),
+    "max_all_cpu": (
+        "aten/src/ATen/native/cpu/ReduceAllOpsKernel.cpp", "max_all_kernel_impl",
+        """#ifndef N
+#define N 4096
+#endif
+void aten_max_all_cpu(float x[N], float out[1]) {
+  float value = x[0];
+  for (int i = 1; i < N; ++i) value = x[i] > value ? x[i] : value;
+  out[0] = value;
+}
+""",
+    ),
+    "aminmax_allreduce_cpu": (
+        "aten/src/ATen/native/cpu/ReduceAllOpsKernel.cpp", "aminmax_allreduce_kernel",
+        """#ifndef N
+#define N 4096
+#endif
+void aten_aminmax_allreduce_cpu(float x[N], float out_min[1], float out_max[1]) {
+  float lo = x[0], hi = x[0];
+  for (int i = 1; i < N; ++i) {
+    lo = x[i] < lo ? x[i] : lo; hi = x[i] > hi ? x[i] : hi;
+  }
+  out_min[0] = lo; out_max[0] = hi;
+}
+""",
+    ),
+    "amp_update_scale_cpu": (
+        "aten/src/ATen/native/cpu/AmpGradScalerKernels.cpp", "_amp_update_scale_cpu_kernel",
+        """void aten_amp_update_scale_cpu(float scale[1], int tracker[1],
+    float found_inf[1], float growth, float backoff, int interval) {
+  if (found_inf[0] != 0.0f) { scale[0] *= backoff; tracker[0] = 0; }
+  else {
+    int successful = tracker[0] + 1;
+    if (successful == interval) { scale[0] *= growth; tracker[0] = 0; }
+    else tracker[0] = successful;
+  }
+}
+""",
+    ),
+    "fused_adagrad_cpu": (
+        "aten/src/ATen/native/cpu/FusedAdagradKernel.cpp", "fused_adagrad_kernel",
+        """#ifndef N
+#define N 4096
+#endif
+extern float sqrtf(float);
+void aten_fused_adagrad_cpu(float param[N], float grad[N], float state_sum[N],
+    float lr, float lr_decay, float weight_decay, float eps, float step,
+    float grad_scale, int maximize) {
+  float clr = lr / (1.0f + (step - 1.0f) * lr_decay);
+  for (int i = 0; i < N; ++i) {
+    float g = grad[i] / grad_scale;
+    grad[i] = g;
+    if (maximize) g = -g;
+    if (weight_decay != 0.0f) g += param[i] * weight_decay;
+    state_sum[i] += g * g;
+    param[i] -= clr * g / (sqrtf(state_sum[i]) + eps);
+  }
+}
+""",
+    ),
+    "fused_sgd_cpu": (
+        "aten/src/ATen/native/cpu/FusedSGDKernel.cpp", "fused_sgd_kernel",
+        """#ifndef N
+#define N 4096
+#endif
+void aten_fused_sgd_cpu(float param[N], float grad[N], float momentum_buffer[N],
+    float lr, float momentum, float dampening, float weight_decay,
+    float grad_scale, int maximize, int first_step, int nesterov) {
+  for (int i = 0; i < N; ++i) {
+    float g = grad[i] / grad_scale; grad[i] = g;
+    if (maximize) g = -g;
+    if (weight_decay != 0.0f) g += param[i] * weight_decay;
+    if (momentum != 0.0f) {
+      momentum_buffer[i] = first_step ? g :
+          momentum_buffer[i] * momentum + g * (1.0f - dampening);
+      g = nesterov ? g + momentum * momentum_buffer[i] : momentum_buffer[i];
+    }
+    param[i] -= lr * g;
+  }
+}
+""",
+    ),
+    "fused_adam_cpu": (
+        "aten/src/ATen/native/cpu/FusedAdamKernel.cpp", "fused_adam_kernel",
+        """#ifndef N
+#define N 4096
+#endif
+extern float sqrtf(float);
+void aten_fused_adam_cpu(float param[N], float grad[N], float exp_avg[N],
+    float exp_avg_sq[N], float max_exp_avg_sq[N], float lr, float beta1,
+    float beta2, float bias1, float bias2_sqrt, float weight_decay, float eps,
+    float grad_scale, int maximize, int amsgrad) {
+  float step_size = lr / bias1;
+  for (int i = 0; i < N; ++i) {
+    float g = grad[i] / grad_scale; grad[i] = g;
+    if (maximize) g = -g;
+    if (weight_decay != 0.0f) g += param[i] * weight_decay;
+    exp_avg[i] += (1.0f - beta1) * (g - exp_avg[i]);
+    exp_avg_sq[i] = beta2 * exp_avg_sq[i] + (1.0f - beta2) * g * g;
+    float variance = exp_avg_sq[i];
+    if (amsgrad) {
+      max_exp_avg_sq[i] = max_exp_avg_sq[i] > variance ? max_exp_avg_sq[i] : variance;
+      variance = max_exp_avg_sq[i];
+    }
+    param[i] -= step_size * exp_avg[i] / (sqrtf(variance) / bias2_sqrt + eps);
+  }
+}
+""",
+    ),
+}
+
+
+def body(name: str, args: str, statement: str, needs_exp: bool = False,
+         extern: str | None = None, binary_extern: bool = False) -> str:
+    unary_calls = set()
+    if needs_exp or "expf(" in statement:
+        unary_calls.add("expf")
+    for function in ("logf", "log1pf", "tanhf", "truncf", "floorf", "roundf", "exp2f", "erff", "sinf", "cosf"):
+        if f"{function}(" in statement:
+            unary_calls.add(function)
+    prefix = "".join(
+        f"extern ATEN_CONST float {function}(float);\n"
+        for function in sorted(unary_calls)
+    )
+    if "ldexpf(" in statement:
+        prefix += "extern ATEN_CONST float ldexpf(float, int);\n"
+    if "powf(" in statement:
+        prefix += "extern ATEN_CONST float powf(float, float);\n"
+    if "atan2f(" in statement:
+        prefix += "extern ATEN_CONST float atan2f(float, float);\n"
+    if "hypotf(" in statement:
+        prefix += "extern ATEN_CONST float hypotf(float, float);\n"
+    if "calc_polygammaf(" in statement:
+        prefix += "extern ATEN_CONST float calc_polygammaf(int, float);\n"
+    if "calc_kaiserf(" in statement:
+        prefix += "extern ATEN_CONST float calc_kaiserf(float, float);\n"
+    for special in (
+        "calc_airy_aif", "calc_scaled_bessel_k0f",
+        "calc_scaled_bessel_k1f", "calc_spherical_bessel_j0f",
+    ):
+        if f"{special}(" in statement:
+            prefix += f"extern ATEN_CONST float {special}(float);\n"
+    if extern:
+        parameters = "float, float" if binary_extern else "float"
+        if extern not in unary_calls:
+            prefix += f"extern ATEN_CONST float {extern}({parameters});\n"
+    return (
+        f"/* Fixed-shape scalar specialization extracted from pinned ATen. */\n"
+        f"#ifndef N\n#define N 4096\n#endif\n"
+        f"#define ATEN_CONST __attribute__((const))\n{prefix}"
+        f"void aten_{name}({args}) {{\n#pragma scop\n"
+        f"  for (int i = 0; i < N; ++i) {{\n    {statement}\n  }}\n"
+        f"#pragma endscop\n}}\n"
+    )
+
+
+def main() -> None:
+    rows: list[dict[str, str]] = []
+    unary_source = "aten/src/ATen/native/cpu/UnaryOpsKernel.cpp"
+    binary_source = "aten/src/ATen/native/cpu/BinaryOpsKernel.cpp"
+    for name, (expr, token) in UNARY.items():
+        kernel = f"aten_{name}"
+        (OUT / f"{kernel}.c").write_text(body(name, "float x[N], float out[N]", f"out[i] = {expr};"))
+        rows.append({"kernel": kernel, "source": unary_source, "token": token})
+    for name, (expr, token) in BINARY.items():
+        kernel = f"aten_{name}"
+        (OUT / f"{kernel}.c").write_text(body(name, "float a[N], float b[N], float out[N]", f"out[i] = {expr};"))
+        rows.append({"kernel": kernel, "source": binary_source, "token": token})
+    for name, (expr, token, extern) in MATH_UNARY.items():
+        kernel = f"aten_{name}"
+        (OUT / f"{kernel}.c").write_text(
+            body(name, "float x[N], float out[N]", f"out[i] = {expr};",
+                 extern=extern)
+        )
+        rows.append({"kernel": kernel, "source": unary_source, "token": token})
+    for name, (expr, token, extern) in MATH_BINARY.items():
+        kernel = f"aten_{name}"
+        source = (
+            "aten/src/ATen/native/cpu/PowKernel.cpp"
+            if name == "pow" else binary_source
+        )
+        (OUT / f"{kernel}.c").write_text(
+            body(name, "float a[N], float b[N], float out[N]",
+                 f"out[i] = {expr};", extern=extern, binary_extern=True)
+        )
+        rows.append({"kernel": kernel, "source": source, "token": token})
+    for name, (expr, token) in INT_BINARY.items():
+        kernel = f"aten_{name}"
+        (OUT / f"{kernel}.c").write_text(
+            body(name, "int a[N], int b[N], int out[N]", f"out[i] = {expr};")
+        )
+        rows.append({"kernel": kernel, "source": binary_source, "token": token})
+    for name, (source, token, statement, args) in CUSTOM.items():
+        kernel = f"aten_{name}"
+        (OUT / f"{kernel}.c").write_text(body(name, args, statement, "expf(" in statement))
+        rows.append({"kernel": kernel, "source": source, "token": token})
+    for name, (source, token, source_text) in FULL.items():
+        kernel = f"aten_{name}"
+        (OUT / f"{kernel}.c").write_text(source_text)
+        rows.append({"kernel": kernel, "source": source, "token": token})
+    with MANIFEST.open("w", newline="") as stream:
+        writer = csv.DictWriter(stream, fieldnames=("kernel", "source", "token"))
+        writer.writeheader()
+        writer.writerows(rows)
+    print(f"generated {len(rows)} C fixtures and {MANIFEST}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/correctness/generate_aten_structured_extractions.py b/scripts/correctness/generate_aten_structured_extractions.py
new file mode 100644
index 000000000000..cd07e4e1d018
--- /dev/null
+++ b/scripts/correctness/generate_aten_structured_extractions.py
@@ -0,0 +1,730 @@
+#!/usr/bin/env python3
+"""Generate fixed-shape standalone C forms for structured ATen CPU kernels."""
+
+from __future__ import annotations
+
+import csv
+import itertools
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+OUT = ROOT / "issues/aten_c_kernels"
+MANIFEST = OUT / "generated_structured_provenance.csv"
+UPSAMPLE = "aten/src/ATen/native/cpu/UpSampleKernel.cpp"
+UPSAMPLE_MORE = "aten/src/ATen/native/cpu/UpSampleMoreKernel.cpp"
+PADDING = "aten/src/ATen/native/cpu/PaddingKernel.cpp"
+REDUCE = "aten/src/ATen/native/cpu/ReduceOpsKernel.cpp"
+DIST = "aten/src/ATen/native/cpu/DistributionKernels.cpp"
+INDEX = "aten/src/ATen/native/cpu/IndexKernel.cpp"
+SCATTER = "aten/src/ATen/native/cpu/ScatterGatherKernel.cpp"
+ADAPTIVE_AVG_POOL = "aten/src/ATen/native/cpu/AdaptiveAvgPoolKernel.cpp"
+ADAPTIVE_MAX_POOL = "aten/src/ATen/native/cpu/AdaptiveMaxPoolKernel.cpp"
+AVG_POOL = "aten/src/ATen/native/cpu/AvgPoolKernel.cpp"
+MAX_POOL = "aten/src/ATen/native/cpu/MaxPoolKernel.cpp"
+MAX_POOL_1D = "aten/src/ATen/native/cpu/MaxPooling.cpp"
+
+
+def macros(rank: int) -> str:
+    lines = ["#ifndef B", "#define B 1", "#endif", "#ifndef C", "#define C 2", "#endif"]
+    for d in range(rank):
+        lines += [
+            f"#ifndef I{d}", f"#define I{d} {4 + d}", "#endif",
+            f"#ifndef O{d}", f"#define O{d} {7 + d}", "#endif",
+        ]
+    return "\n".join(lines) + "\n"
+
+
+def array_size(prefix: str, rank: int) -> str:
+    return "*".join(["B", "C"] + [f"{prefix}{d}" for d in range(rank)])
+
+
+def flatten(indices: list[str], dims: list[str]) -> str:
+    value = indices[0]
+    for index, dim in zip(indices[1:], dims[1:]):
+        value = f"(({value})*{dim}+{index})"
+    return value
+
+
+def nearest(rank: int, exact: bool, backward: bool) -> str:
+    suffix = f"{rank}d"
+    exact_name = "_exact" if exact else ""
+    direction = "_backward" if backward else ""
+    name = f"aten_upsample_nearest{exact_name}{suffix}{direction}_cpu"
+    token = (
+        f"_upsample_nearest_exact{suffix}{direction}_kernel_impl"
+        if exact else f"upsample_nearest{suffix}{direction}_kernel_impl"
+    )
+    source = UPSAMPLE_MORE if backward else UPSAMPLE
+    inputs = [f"i{d}" for d in range(rank)]
+    outputs = [f"o{d}" for d in range(rank)]
+    spatial_loops = "\n".join(
+        f"{'  ' * (2 + d)}for (int o{d} = 0; o{d} < O{d}; ++o{d}) {{"
+        for d in range(rank)
+    )
+    indent = "  " * (2 + rank)
+    index_lines = []
+    for d in range(rank):
+        expr = (
+            f"((2 * o{d} + 1) * I{d}) / (2 * O{d})"
+            if exact else f"(o{d} * I{d}) / O{d}"
+        )
+        index_lines.append(f"{indent}int i{d} = {expr};")
+        index_lines.append(f"{indent}if (i{d} >= I{d}) i{d} = I{d} - 1;")
+    out_index = flatten(["n", "c", *outputs], ["B", "C", *[f"O{d}" for d in range(rank)]])
+    in_index = flatten(["n", "c", *inputs], ["B", "C", *[f"I{d}" for d in range(rank)]])
+    if backward:
+        signature = (
+            f"float grad_output[{array_size('O', rank)}], "
+            f"float grad_input[{array_size('I', rank)}]"
+        )
+        init = (
+            f"  for (int p = 0; p < {array_size('I', rank)}; ++p) "
+            "grad_input[p] = 0.0f;\n"
+        )
+        operation = f"{indent}grad_input[{in_index}] += grad_output[{out_index}];"
+    else:
+        signature = (
+            f"float input[{array_size('I', rank)}], "
+            f"float output[{array_size('O', rank)}]"
+        )
+        init = ""
+        operation = f"{indent}output[{out_index}] = input[{in_index}];"
+    code = (
+        f"/* Fixed-shape ATen nearest{'-exact' if exact else ''} {rank}D"
+        f"{' backward' if backward else ''}. */\n{macros(rank)}"
+        f"void {name}({signature}) {{\n#pragma scop\n{init}"
+        "  for (int n = 0; n < B; ++n) {\n"
+        "    for (int c = 0; c < C; ++c) {\n"
+        f"{spatial_loops}\n" + "\n".join(index_lines) + "\n"
+        f"{operation}\n"
+        + "\n".join(
+            f"{'  ' * depth}}}" for depth in range(1 + rank, -1, -1)
+        )
+        + "\n#pragma endscop\n}\n"
+    )
+    return name, source, token, code
+
+
+def linear(rank: int, backward: bool) -> tuple[str, str, str, str]:
+    kind = {1: "linear", 2: "bilinear", 3: "trilinear"}[rank]
+    direction = "_backward" if backward else ""
+    name = f"aten_upsample_{kind}{rank}d{direction}_cpu"
+    token = f"upsample_{kind}{rank}d{direction}_kernel_impl"
+    source = UPSAMPLE_MORE if backward else UPSAMPLE
+    outputs = [f"o{d}" for d in range(rank)]
+    spatial_loops = "\n".join(
+        f"{'  ' * (2 + d)}for (int o{d} = 0; o{d} < O{d}; ++o{d}) {{"
+        for d in range(rank)
+    )
+    indent = "  " * (2 + rank)
+    coordinates = []
+    for d in range(rank):
+        coordinates += [
+            f"{indent}float s{d} = ((float)o{d} + 0.5f) * (float)I{d} / (float)O{d} - 0.5f;",
+            f"{indent}if (s{d} < 0.0f) s{d} = 0.0f;",
+            f"{indent}int i{d}0 = (int)s{d};",
+            f"{indent}int i{d}1 = i{d}0 + 1 < I{d} ? i{d}0 + 1 : i{d}0;",
+            f"{indent}float w{d}1 = s{d} - (float)i{d}0;",
+            f"{indent}float w{d}0 = 1.0f - w{d}1;",
+        ]
+    out_index = flatten(
+        ["n", "c", *outputs], ["B", "C", *[f"O{d}" for d in range(rank)]]
+    )
+    terms = []
+    for choices in itertools.product((0, 1), repeat=rank):
+        indices = [f"i{d}{choice}" for d, choice in enumerate(choices)]
+        in_index = flatten(
+            ["n", "c", *indices], ["B", "C", *[f"I{d}" for d in range(rank)]]
+        )
+        weight = "*".join(f"w{d}{choice}" for d, choice in enumerate(choices))
+        terms.append((in_index, weight))
+    if backward:
+        signature = (
+            f"float grad_output[{array_size('O', rank)}], "
+            f"float grad_input[{array_size('I', rank)}]"
+        )
+        init = (
+            f"  for (int p = 0; p < {array_size('I', rank)}; ++p) "
+            "grad_input[p] = 0.0f;\n"
+        )
+        operations = "\n".join(
+            f"{indent}grad_input[{index}] += grad_output[{out_index}] * {weight};"
+            for index, weight in terms
+        )
+    else:
+        signature = (
+            f"float input[{array_size('I', rank)}], "
+            f"float output[{array_size('O', rank)}]"
+        )
+        init = ""
+        expression = " + ".join(
+            f"input[{index}] * {weight}" for index, weight in terms
+        )
+        operations = f"{indent}output[{out_index}] = {expression};"
+    code = (
+        f"/* Fixed-shape ATen {kind} {rank}D align_corners=false"
+        f"{' backward' if backward else ''}. */\n{macros(rank)}"
+        f"void {name}({signature}) {{\n#pragma scop\n{init}"
+        "  for (int n = 0; n < B; ++n) {\n"
+        "    for (int c = 0; c < C; ++c) {\n"
+        f"{spatial_loops}\n" + "\n".join(coordinates) + "\n"
+        f"{operations}\n"
+        + "\n".join(
+            f"{'  ' * depth}}}" for depth in range(1 + rank, -1, -1)
+        )
+        + "\n#pragma endscop\n}\n"
+    )
+    return name, source, token, code
+
+
+def filtered_2d(kind: str, backward: bool) -> tuple[str, str, str, str]:
+    """Separable fixed-shape antialiased 2D resampling."""
+    direction = "_backward" if backward else ""
+    name = f"aten_upsample_{kind}2d_aa{direction}_cpu"
+    token = f"upsample_{kind}2d_aa{direction}_kernel_impl"
+    source = UPSAMPLE if True else UPSAMPLE_MORE
+    # ATen keeps AA backward implementations in UpSampleKernel.cpp.
+    if kind == "bilinear":
+        radius = "1.0f"
+        kernel = "ax < 1.0f ? 1.0f - ax : 0.0f"
+    elif kind == "bicubic":
+        radius = "2.0f"
+        kernel = (
+            "ax < 1.0f ? ((1.5f * ax - 2.5f) * ax * ax + 1.0f) : "
+            "(ax < 2.0f ? ((-0.5f * ax + 2.5f) * ax - 4.0f) * ax + 2.0f : 0.0f)"
+        )
+    else:
+        radius = "3.0f"
+        kernel = (
+            "ax == 0.0f ? 1.0f : (ax < 3.0f ? "
+            "sinf(3.14159265358979323846f * ax) * "
+            "sinf(3.14159265358979323846f * ax / 3.0f) / "
+            "(3.289868133696453f * ax * ax) : 0.0f)"
+        )
+    operation = (
+        "        grad_input[((n*C+c)*I0+iy)*I1+ix] += "
+        "grad_output[((n*C+c)*O0+oy)*O1+ox] * wy * wx / norm;\n"
+        if backward else
+        "        value += input[((n*C+c)*I0+iy)*I1+ix] * wy * wx;\n"
+    )
+    final = (
+        "" if backward else
+        "      output[((n*C+c)*O0+oy)*O1+ox] = value / norm;\n"
+    )
+    signature = (
+        "float grad_output[B*C*O0*O1], float grad_input[B*C*I0*I1]"
+        if backward else
+        "float input[B*C*I0*I1], float output[B*C*O0*O1]"
+    )
+    init = (
+        "  for (int p = 0; p < B*C*I0*I1; ++p) grad_input[p] = 0.0f;\n"
+        if backward else ""
+    )
+    code = f"""/* Fixed-shape ATen antialiased {kind} 2D{' backward' if backward else ''}. */
+{macros(2)}extern float sinf(float);
+void {name}({signature}) {{
+{init}  float sy_scale = (float)I0 / (float)O0;
+  float sx_scale = (float)I1 / (float)O1;
+  float fy_scale = sy_scale > 1.0f ? sy_scale : 1.0f;
+  float fx_scale = sx_scale > 1.0f ? sx_scale : 1.0f;
+  for (int n = 0; n < B; ++n) for (int c = 0; c < C; ++c)
+  for (int oy = 0; oy < O0; ++oy) for (int ox = 0; ox < O1; ++ox) {{
+    float sy = ((float)oy + 0.5f) * sy_scale - 0.5f;
+    float sx = ((float)ox + 0.5f) * sx_scale - 0.5f;
+    float norm = 0.0f;
+    {'float value = 0.0f;' if not backward else ''}
+    for (int iy = 0; iy < I0; ++iy) for (int ix = 0; ix < I1; ++ix) {{
+      float ay = sy - (float)iy; if (ay < 0.0f) ay = -ay; ay /= fy_scale;
+      float ax = sx - (float)ix; if (ax < 0.0f) ax = -ax; ax /= fx_scale;
+      float wy = ay < {radius} ? ({kernel.replace('ax', 'ay')}) : 0.0f;
+      float wx = ax < {radius} ? ({kernel}) : 0.0f;
+      norm += wy * wx;
+    }}
+    for (int iy = 0; iy < I0; ++iy) for (int ix = 0; ix < I1; ++ix) {{
+      float ay = sy - (float)iy; if (ay < 0.0f) ay = -ay; ay /= fy_scale;
+      float ax = sx - (float)ix; if (ax < 0.0f) ax = -ax; ax /= fx_scale;
+      float wy = ay < {radius} ? ({kernel.replace('ax', 'ay')}) : 0.0f;
+      float wx = ax < {radius} ? ({kernel}) : 0.0f;
+{operation}    }}
+{final}  }}
+}}
+"""
+    return name, source, token, code
+
+
+def bicubic_2d() -> tuple[str, str, str, str]:
+    name = "aten_upsample_bicubic2d_cpu"
+    token = "upsample_bicubic2d_kernel_impl"
+    code = f"""/* Fixed-shape ATen bicubic 2D, align_corners=false, a=-0.75. */
+{macros(2)}static float aten_cubic_weight(float x) {{
+  if (x < 0.0f) x = -x;
+  if (x < 1.0f) return ((1.25f * x - 2.25f) * x * x + 1.0f);
+  if (x < 2.0f) return ((-0.75f * x + 3.75f) * x - 6.0f) * x + 3.0f;
+  return 0.0f;
+}}
+void {name}(float input[B*C*I0*I1], float output[B*C*O0*O1]) {{
+  for (int n = 0; n < B; ++n) for (int c = 0; c < C; ++c)
+  for (int oy = 0; oy < O0; ++oy) for (int ox = 0; ox < O1; ++ox) {{
+    float sy = ((float)oy + 0.5f) * (float)I0 / (float)O0 - 0.5f;
+    float sx = ((float)ox + 0.5f) * (float)I1 / (float)O1 - 0.5f;
+    int by = (int)sy, bx = (int)sx;
+    if (sy < 0.0f && sy != (float)by) --by;
+    if (sx < 0.0f && sx != (float)bx) --bx;
+    float value = 0.0f;
+    for (int ky = -1; ky <= 2; ++ky) for (int kx = -1; kx <= 2; ++kx) {{
+      int iy = by + ky; if (iy < 0) iy = 0; if (iy >= I0) iy = I0 - 1;
+      int ix = bx + kx; if (ix < 0) ix = 0; if (ix >= I1) ix = I1 - 1;
+      value += input[((n*C+c)*I0+iy)*I1+ix] *
+          aten_cubic_weight(sy-(float)(by+ky)) *
+          aten_cubic_weight(sx-(float)(bx+kx));
+    }}
+    output[((n*C+c)*O0+oy)*O1+ox] = value;
+  }}
+}}
+"""
+    return name, UPSAMPLE, token, code
+
+
+def padding(rank: int, mode: str, backward: bool) -> tuple[str, str, str, str]:
+    direction = "_backward" if backward else ""
+    name = f"aten_{mode}_pad{rank}d{direction}_cpu"
+    token = f"{mode}_pad{rank}d{direction}_kernel_impl"
+    macro_text = ["#ifndef B\n#define B 1\n#endif", "#ifndef C\n#define C 2\n#endif"]
+    for d in range(rank):
+        macro_text += [
+            f"#ifndef I{d}\n#define I{d} {4+d}\n#endif",
+            f"#ifndef P{d}\n#define P{d} 2\n#endif",
+            f"#define O{d} (I{d}+2*P{d})",
+        ]
+    outputs = [f"o{d}" for d in range(rank)]
+    inputs = [f"i{d}" for d in range(rank)]
+    loops = "\n".join(
+        f"{'  ' * (2+d)}for (int o{d}=0; o{d}= I{d}) i{d} = 2*I{d}-2-i{d};",
+            ]
+        else:
+            maps += [
+                f"{indent}if (i{d} < 0) i{d} = 0;",
+                f"{indent}if (i{d} >= I{d}) i{d} = I{d}-1;",
+            ]
+    in_index = flatten(["n", "c", *inputs], ["B", "C", *[f"I{d}" for d in range(rank)]])
+    out_index = flatten(["n", "c", *outputs], ["B", "C", *[f"O{d}" for d in range(rank)]])
+    if backward:
+        signature = f"float grad_output[{array_size('O',rank)}], float grad_input[{array_size('I',rank)}]"
+        init = f"  for (int p=0; p<{array_size('I',rank)}; ++p) grad_input[p]=0.0f;\n"
+        op = f"{indent}grad_input[{in_index}] += grad_output[{out_index}];"
+    else:
+        signature = f"float input[{array_size('I',rank)}], float output[{array_size('O',rank)}]"
+        init = ""
+        op = f"{indent}output[{out_index}] = input[{in_index}];"
+    closes = "\n".join(f"{'  '*depth}}}" for depth in range(1+rank,-1,-1))
+    code = (
+        f"/* Fixed-shape ATen {mode} padding {rank}D{direction}. */\n"
+        + "\n".join(macro_text) + "\n"
+        + f"void {name}({signature}) {{\n{init}"
+        + "  for (int n=0; n list[tuple[str, str, str, str]]:
+    header = "#ifndef R\n#define R 32\n#endif\n#ifndef K\n#define K 64\n#endif\n"
+    specs = {
+        "std_var_cpu": ("std_var_kernel_impl", """extern float sqrtf(float);
+void aten_std_var_cpu(float x[R][K], int correction, float out[R]) {
+  for (int r=0;rv?x[r][k]:v;out[r]=v;}
+}"""),
+        "argmax_cpu": ("argmax_kernel_impl", """void aten_argmax_cpu(float x[R][K], int out[R]) {
+  for(int r=0;rv){v=x[r][k];best=k;}out[r]=best;}
+}"""),
+        "argmin_cpu": ("argmin_kernel_impl", """void aten_argmin_cpu(float x[R][K], int out[R]) {
+  for(int r=0;rx[r][k]?v:x[r][k];float d=v-x[r][k];if(d<0)d=-d;v=m+log1pf(expf(-d));out[r][k]=v;}}
+}"""),
+    }
+    return [
+        (f"aten_{name}", REDUCE, token, header + code + "\n")
+        for name, (token, code) in specs.items()
+    ]
+
+
+def distribution_entries() -> list[tuple[str, str, str, str]]:
+    h = "#ifndef N\n#define N 4096\n#endif\n"
+    specs = {
+        "bernoulli_tensor_cpu": ("bernoulli_tensor_kernel",
+            "void aten_bernoulli_tensor_cpu(float uniform[N],float probability[N],float out[N]){for(int i=0;i list[tuple[str, str, str, str]]:
+    h = "#ifndef R\n#define R 32\n#endif\n#ifndef K\n#define K 64\n#endif\n#ifndef S\n#define S 128\n#endif\n"
+    specs = {
+        "index_cpu": ("index_kernel", "void aten_index_cpu(float input[S][K],int index[R],float out[R][K]){for(int r=0;rx?out[r][j]:x;else out[r][j]=out[r][j]value?out[r][j]:value;else out[r][j]=out[r][j]source[r][k]?out[r][j]:source[r][k];}}"),
+        "gather_expanded_index_cpu": ("gather_expanded_index_kernel", "void aten_gather_expanded_index_cpu(float input[R][S],int index[R][K],float out[R][K]){for(int r=0;r tuple[str, str, str, str]:
+    adaptive = family.startswith("adaptive")
+    is_max = family.endswith("max")
+    direction = "_backward" if backward else ""
+    if adaptive:
+        opname = f"adaptive_{'max' if is_max else 'avg'}_pool{rank}d"
+        token = (
+            f"adaptive_max_pool{rank}d{direction}_kernel_impl"
+            if is_max else
+            f"{'adapative' if backward else 'adaptive'}_avg_pool{rank}d{direction}_kernel_impl"
+        )
+        source = ADAPTIVE_MAX_POOL if is_max else ADAPTIVE_AVG_POOL
+    else:
+        opname = f"{'max' if is_max else 'avg'}_pool{rank}d"
+        token = f"{opname}{direction}_kernel_impl"
+        source = MAX_POOL_1D if is_max and rank == 1 else (MAX_POOL if is_max else AVG_POOL)
+        if is_max and rank == 1:
+            token = "max_pool1d_impl"
+    name = f"aten_{opname}{direction}_cpu"
+    defs = ["#ifndef B\n#define B 1\n#endif", "#ifndef C\n#define C 2\n#endif"]
+    for d in range(rank):
+        defs.append(f"#ifndef I{d}\n#define I{d} {6+d}\n#endif")
+        defs.append(
+            f"#ifndef O{d}\n#define O{d} 3\n#endif"
+            if adaptive else f"#define O{d} (I{d}/2)"
+        )
+    out_coords = [f"o{d}" for d in range(rank)]
+    in_coords = [f"i{d}" for d in range(rank)]
+    out_loops = "\n".join(
+        f"{'  '*(2+d)}for(int o{d}=0;o{d}value){{"
+                f"value=input[{in_idx}];best={spatial_idx};}}"
+            )
+            post = f"{indent}output[{out_idx}]=value;indices[{out_idx}]=best;"
+        else:
+            pre = f"{indent}float value=0.0f;int count=0;"
+            update = f"{inner_indent}value+=input[{in_idx}];++count;"
+            post = f"{indent}output[{out_idx}]=value/(float)count;"
+        init = ""
+        inner = pre + "\n" + inner_loops + "\n" + update + "\n" + inner_closes
+        operation = post
+    code = (
+        f"/* Fixed-shape ATen {opname}{direction}. */\n" + "\n".join(defs) + "\n"
+        f"void {name}({signature}){{\n{init}"
+        "  for(int n=0;n list[tuple[str, str, str, str]]:
+    entries = []
+    for rank in (2, 3):
+        for family in ("adaptive_avg", "adaptive_max", "avg"):
+            for backward in (False, True):
+                entries.append(pool(rank, family, backward))
+    for rank in (1, 3):
+        for backward in (False, True):
+            # max_pool1d has no separate registered backward kernel.
+            if rank == 1 and backward:
+                continue
+            entries.append(pool(rank, "max", backward))
+    return entries
+
+
+def misc_entries() -> list[tuple[str, str, str, str]]:
+    specs: list[tuple[str, str, str, str]] = []
+    def add(name: str, source: str, token: str, code: str) -> None:
+        specs.append((f"aten_{name}", source, token, code + "\n"))
+
+    distance = "aten/src/ATen/native/cpu/DistanceOpsKernel.cpp"
+    dh = "#ifndef N\n#define N 16\n#endif\n#ifndef M\n#define M 12\n#endif\n#ifndef D\n#define D 32\n#endif\n"
+    add("pdist_forward_cpu", distance, "pdist_forward_kernel_impl", dh + """extern float sqrtf(float);
+void aten_pdist_forward_cpu(float x[N][D],float out[N*(N-1)/2]){for(int i=0;i=0&&a=0&&b=0&&bin[i]hi?x[i]:hi;}out_min[0]=lo;out_max[0]=hi;}""")
+
+    sortsrc = "aten/src/ATen/native/cpu/SortingKernel.cpp"
+    sh = "#ifndef R\n#define R 16\n#endif\n#ifndef K\n#define K 64\n#endif\n#ifndef TOP\n#define TOP 8\n#endif\n"
+    sort_body = """for(int r=0;r=0&&values[r][j] list[tuple[str, str, str, str]]:
+    specs: list[tuple[str, str, str, str]] = []
+    def add(name: str, source: str, token: str, code: str) -> None:
+        specs.append((f"aten_{name}", source, token, code + "\n"))
+
+    spmm = "aten/src/ATen/native/cpu/SpmmReduceKernel.cpp"
+    sp = "#define ROWS 16\n#define INNER 32\n#define COLS 24\n#define NNZ 96\n"
+    add("spmm_reduce_cpu", spmm, "spmm_reduce_kernel", sp + """void aten_spmm_reduce_cpu(int crow[ROWS+1],int col[NNZ],float val[NNZ],float other[INNER][COLS],int reduce,float out[ROWS][COLS]){for(int r=0;rx?acc:x;else acc=acccrow[r])acc/=(float)(crow[r+1]-crow[r]);out[r][n]=acc;}}""")
+    add("spmm_reduce_arg_cpu", spmm, "spmm_reduce_arg_kernel", sp + """void aten_spmm_reduce_arg_cpu(int crow[ROWS+1],int col[NNZ],float val[NNZ],float other[INNER][COLS],int choose_max,float out[ROWS][COLS],int arg[ROWS][COLS]){for(int r=0;racc)||(!choose_max&&x=0)out[p]+=grad[r][n]*other[col[p]][n];}}""")
+    add("spmm_reduce_backward_other_cpu", spmm, "spmm_reduce_backward_other_kernel", sp + """void aten_spmm_reduce_backward_other_cpu(int crow[ROWS+1],int col[NNZ],float val[NNZ],float grad[ROWS][COLS],float out[INNER][COLS]){for(int k=0;k=0)out[col[p]][n]+=val[p]*grad[r][n];}}""")
+
+    gemv = "aten/src/ATen/native/cpu/ReducedPrecisionFloatGemvFastPathKernel.cpp"
+    gh = "#define M 64\n#define K 128\n"
+    add("fp16_gemv_trans_cpu", gemv, "fp16_gemv_trans", gh + "void aten_fp16_gemv_trans_cpu(float matrix[M][K],float vector[M],float out[K]){for(int k=0;k>(4*(k&1)))&15;s+=a[m][k]*((float)q-zero[n])*scale[n];}out[m][n]=s;}}")
+    add("dyn_quant_pack_4bit_weight_cpu", int4, "dyn_quant_pack_4bit_weight_kernel", ih + "void aten_dyn_quant_pack_4bit_weight_cpu(float weight[N][K],unsigned char packed[N][K/2],float scale[N],float zero[N]){for(int n=0;nhi?weight[n][k]:hi;}scale[n]=(hi-lo)/15.0f;zero[n]=-lo/scale[n];for(int k=0;k15)q0=15;if(q1<0)q1=0;if(q1>15)q1=15;packed[n][k/2]=(unsigned char)(q0|(q1<<4));}}}")
+    add("dyn_quant_matmul_4bit_cpu", int4, "dyn_quant_matmul_4bit_kernel", ih + "void aten_dyn_quant_matmul_4bit_cpu(float a[M][K],unsigned char packed[N][K/2],float scale[N],float zero[N],float out[M][N]){for(int m=0;m>(4*(k&1)))&15;s+=a[m][k]*((float)q-zero[n])*scale[n];}out[m][n]=s;}}")
+    add("int8pack_mm_cpu", "aten/src/ATen/native/cpu/int8mm_kernel.cpp", "int8pack_mm_kernel", ih + "void aten_int8pack_mm_cpu(float a[M][K],signed char weight[N][K],float scale[N],float out[M][N]){for(int m=0;m=0&&iy=0&&ixm?score[j]:m;}float z=0;for(int j=0;jm?p[j]:m;}for(int j=0;j=0&&x0=0&&y0=0&&x1=0&&y0=0&&x0=0&&y1=0&&x1=0&&y1=0&&x0=0&&y0=0&&x1=0&&y0=0&&x0=0&&y1=0&&x1=0&&y1=0&&j=0?i:i-offsets[d]];}}")
+
+    norm = "#define B 4\n#define C 8\n#define S 32\n"
+    add("weight_norm_cpu", "aten/src/ATen/native/cpu/WeightNormKernel.cpp", "weight_norm_kernel", norm + """extern float sqrtf(float);void aten_weight_norm_cpu(float v[C][S],float g[C],float out[C][S],float norms[C]){for(int c=0;c None:
+    rows = []
+    entries = []
+    for rank in (1, 2, 3):
+        for exact in (False, True):
+            for backward in (False, True):
+                entries.append(nearest(rank, exact, backward))
+        for backward in (False, True):
+            entries.append(linear(rank, backward))
+    entries.append(bicubic_2d())
+    for kind in ("bilinear", "bicubic", "lanczos"):
+        for backward in (False, True):
+            entries.append(filtered_2d(kind, backward))
+    for rank in (1, 2, 3):
+        for mode in ("reflection", "replication"):
+            for backward in (False, True):
+                entries.append(padding(rank, mode, backward))
+    entries.extend(reduction_entries())
+    entries.extend(distribution_entries())
+    entries.extend(index_entries())
+    entries.extend(pooling_entries())
+    entries.extend(misc_entries())
+    entries.extend(specialized_entries())
+    for name, source, token, code in entries:
+        (OUT / f"{name}.c").write_text(code)
+        rows.append({"kernel": name, "source": source, "token": token})
+    with MANIFEST.open("w", newline="") as stream:
+        writer = csv.DictWriter(stream, fieldnames=("kernel", "source", "token"))
+        writer.writeheader()
+        writer.writerows(rows)
+    print(f"generated {len(rows)} structured C fixtures and {MANIFEST}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/correctness/gesummv_jetson_wrapper.c b/scripts/correctness/gesummv_jetson_wrapper.c
new file mode 100644
index 000000000000..a877c75748ae
--- /dev/null
+++ b/scripts/correctness/gesummv_jetson_wrapper.c
@@ -0,0 +1,34 @@
+/* gesummv_jetson_wrapper.c — Jetson timing wrapper.
+ *
+ * gesummv: y = α·(A·x) + β·(B·x).
+ * Signature: (n, α, β, A, B, tmp, x, y).
+ */
+#include 
+#include 
+
+extern void kernel_gesummv_impl(
+    int n, double alpha, double beta,
+    /* A: 2D */
+    double *A_b, double *A_a, int64_t A_o, int64_t A_s0, int64_t A_s1, int64_t A_st0, int64_t A_st1,
+    /* B: 2D */
+    double *B_b, double *B_a, int64_t B_o, int64_t B_s0, int64_t B_s1, int64_t B_st0, int64_t B_st1,
+    /* tmp,x,y: 1D each */
+    double *tmp_b, double *tmp_a, int64_t tmp_o, int64_t tmp_s, int64_t tmp_st,
+    double *x_b,   double *x_a,   int64_t x_o,   int64_t x_s,   int64_t x_st,
+    double *y_b,   double *y_a,   int64_t y_o,   int64_t y_s,   int64_t y_st);
+
+extern void   polygeist_cublas_time_begin(void);
+extern double polygeist_cublas_time_end_ms(void);
+
+void kernel_gesummv(int n, double alpha, double beta, double *A, double *B,
+                    double *tmp, double *x, double *y) {
+  polygeist_cublas_time_begin();
+  kernel_gesummv_impl(n, alpha, beta,
+                      A, A, 0, n, n, n, 1,
+                      B, B, 0, n, n, n, 1,
+                      tmp, tmp, 0, n, 1,
+                      x,   x,   0, n, 1,
+                      y,   y,   0, n, 1);
+  double ms = polygeist_cublas_time_end_ms();
+  fprintf(stderr, "POLYGEIST_TIMING: kernel_gesummv n=%d  %.3f ms\n", n, ms);
+}
diff --git a/scripts/correctness/inject_kernel_library.py b/scripts/correctness/inject_kernel_library.py
new file mode 100755
index 000000000000..9d0584560342
--- /dev/null
+++ b/scripts/correctness/inject_kernel_library.py
@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""Prepend kernel.defn ops from a kernel library file into an input module so
+the kernel.launch ops it contains pass MLIR's symbol verification at parse
+time. Used by the Phase-2 e2e pipeline before running --lower-kernel-launch.
+
+Usage:
+  inject_kernel_library.py   -o 
+"""
+import argparse
+import re
+import sys
+from pathlib import Path
+
+
+def find_module_body_open(text: str) -> int:
+    """Return the offset of the `{` that opens the top-level module's body.
+
+    Handles both `module {` and `module attributes {...} {`. We scan for the
+    `module` keyword, then walk braces tracking depth — the body `{` is the
+    first `{` at depth 0 AFTER the keyword. Attribute-dict `{}`'s pair up
+    cleanly so they cancel out and don't perturb the depth tally.
+    """
+    m = re.search(r"\bmodule\b", text)
+    if not m:
+        raise ValueError("no `module` keyword found")
+    i = m.end()
+    depth = 0
+    while i < len(text):
+        c = text[i]
+        if c == '{':
+            if depth == 0:
+                # If this `{` is preceded (skipping ws) by `attributes`, it's
+                # the attr-dict opener — descend so its matching `}` decrements.
+                preceding = text[m.end():i].rstrip()
+                if preceding.endswith("attributes"):
+                    depth += 1
+                    i += 1
+                    continue
+                return i
+            depth += 1
+        elif c == '}':
+            depth -= 1
+        i += 1
+    raise ValueError("did not find module body `{`")
+
+
+def extract_module_body(text: str) -> str:
+    """Return contents between module body `{` and the final `}`."""
+    body_open = find_module_body_open(text)
+    end = text.rindex("}")
+    return text[body_open + 1 : end]
+
+
+def inject(input_text: str, library_text: str) -> str:
+    """Splice library defns into the input module's top-level block."""
+    lib_body = extract_module_body(library_text).strip()
+    insert_at = find_module_body_open(input_text) + 1
+    return input_text[:insert_at] + "\n" + lib_body + "\n" + input_text[insert_at:]
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("input")
+    ap.add_argument("library")
+    ap.add_argument("-o", "--output", required=True)
+    args = ap.parse_args()
+    inp = Path(args.input).read_text()
+    lib = Path(args.library).read_text()
+    Path(args.output).write_text(inject(inp, lib))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/correctness/kernel_launch_lower.py b/scripts/correctness/kernel_launch_lower.py
new file mode 100755
index 000000000000..c9a8591a1677
--- /dev/null
+++ b/scripts/correctness/kernel_launch_lower.py
@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""Reverse the kernel-match rewrite: restore each `kernel.launch` op back to
+the original `linalg.generic` span the matcher recognized.
+
+This is the round-trip Phase-1 lowering for `kernel.launch`. It consumes MLIR
+text emitted by `kernel_match_rewrite.py --with-roundtrip-markers` and emits
+MLIR with the kernel.launch ops swapped back for their pre-match form, so the
+result is parseable by `polygeist-opt` and can flow on to LLVM lowering and
+execution. Used by the kernel-launch e2e correctness tests.
+
+Each rewritten site looks like
+
+    // POLYGEIST-MATCH-BEGIN-
+    //   
+    // POLYGEIST-MATCH-END
+    %X = kernel.launch @(...) : (...) -> 
+
+We replace that entire region with the captured original span.
+
+Usage:
+  kernel_launch_lower.py              # write to stdout
+  kernel_launch_lower.py  -o     # write to a file
+
+Phase-2 ("canonical templates") will swap each `kernel.launch` for a fresh
+linalg.generic synthesised from the library entry rather than the stashed
+original, so the matcher's LABELS are also validated. Not in this script.
+"""
+import argparse
+import re
+import sys
+from pathlib import Path
+
+
+# (?ms): multiline + dotall. We deliberately avoid `re.M` here so the
+# leading-indent group also matches across leading newlines.
+_BLOCK_RE = re.compile(
+    r"^([ \t]*)// POLYGEIST-MATCH-BEGIN-(\w+)\s*\n"   # marker open
+    r"((?:^[ \t]*//[^\n]*\n)+?)"                       # captured comment body
+    r"^[ \t]*// POLYGEIST-MATCH-END[ \t]*\n"            # marker close
+    r"^[ \t]*[%\w]+\s*=\s*kernel\.launch @[^\n]*\n",  # the kernel.launch line
+    re.MULTILINE,
+)
+
+
+def _strip_comment_prefix(body: str, indent: str) -> str:
+    """Strip `// ` from each captured line, restoring the original."""
+    # Each line is either `// ` or `//` for blanks.
+    prefix_re = re.compile(rf"^{re.escape(indent)}//[ \t]?", re.MULTILINE)
+    return prefix_re.sub("", body)
+
+
+def lower_text(text: str) -> tuple[str, int]:
+    """Return (lowered_text, n_blocks_restored)."""
+    n = 0
+
+    def repl(m: re.Match) -> str:
+        nonlocal n
+        n += 1
+        indent = m.group(1)
+        body = m.group(3)
+        return _strip_comment_prefix(body, indent)
+
+    return _BLOCK_RE.sub(repl, text), n
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("input", help="MLIR with kernel.launch + match markers.")
+    ap.add_argument("-o", "--output", help="Write to file (default: stdout).")
+    args = ap.parse_args()
+
+    src = Path(args.input).read_text()
+    out, n = lower_text(src)
+    if n == 0:
+        print(
+            "kernel_launch_lower: warning — no POLYGEIST-MATCH markers found. "
+            "Run kernel_match_rewrite.py with --with-roundtrip-markers.",
+            file=sys.stderr,
+        )
+
+    if args.output:
+        Path(args.output).write_text(out)
+    else:
+        sys.stdout.write(out)
+    print(f"kernel_launch_lower: restored {n} kernel.launch op(s).", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/correctness/kernel_match.py b/scripts/correctness/kernel_match.py
new file mode 100644
index 000000000000..8c701f9b6d73
--- /dev/null
+++ b/scripts/correctness/kernel_match.py
@@ -0,0 +1,4616 @@
+#!/usr/bin/env python3
+"""linalg.generic body matcher using egglog.
+
+This is an iterative prototype of the "match raised linalg to a kernel
+library" idea, in three layers:
+
+  1. Regex-based parser for linalg.generic bodies (good enough for the
+     debuferized PolyBench output — every body is ~6 lines of arith + yield).
+  2. Encoder: linalg-body -> egglog Expr.
+  3. Matcher: saturate with algebra rules, then check equivalence between
+     a user body and each library pattern.
+
+The library is built from the bodies of already-raised+debuferized PolyBench
+kernels. Bodies that are *structurally equivalent under algebra* collapse to
+the same library entry.
+"""
+from __future__ import annotations
+import math
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from egglog import EGraph, Expr, StringLike, f64, f64Like, i64Like, rewrite, ruleset, vars_
+
+
+# ---------------------------------------------------------------------------
+# The term language for linalg bodies.
+# ---------------------------------------------------------------------------
+
+class Term(Expr):
+    """A scalar expression node inside a linalg.generic body.
+
+    Leaves:
+      - In(i)        : the i-th input operand's block arg.
+      - Out(i)       : the i-th output's block arg (initial value).
+      - Cap(name)    : a captured outer scalar (e.g., `%arg3` = alpha).
+      - Lit(value)   : a literal constant scalar.
+
+    Internals — one per arith op we want to recognize. Add more as kernels
+    surface them.
+    """
+    def __init__(self, name: StringLike) -> None: ...
+    @classmethod
+    def In(cls, i: i64Like) -> Term: ...
+    @classmethod
+    def Out(cls, i: i64Like) -> Term: ...
+    @classmethod
+    def Cap(cls, name: StringLike) -> Term: ...
+    @classmethod
+    def Lit(cls, value: f64Like) -> Term: ...
+
+    def __add__(self, other: Term) -> Term: ...
+    def __mul__(self, other: Term) -> Term: ...
+    def __sub__(self, other: Term) -> Term: ...
+    def __truediv__(self, other: Term) -> Term: ...
+
+    @classmethod
+    def Sqrt(cls, a: Term) -> Term: ...
+    @classmethod
+    def Abs(cls, a: Term) -> Term: ...
+    @classmethod
+    def Exp(cls, a: Term) -> Term: ...
+    @classmethod
+    def Tanh(cls, a: Term) -> Term: ...
+    @classmethod
+    def Select(cls, pred: Term, t: Term, f: Term) -> Term: ...
+    @classmethod
+    def Cmp(cls, kind: StringLike, a: Term, b: Term) -> Term: ...
+
+
+# ---------------------------------------------------------------------------
+# Algebra rules (cosmetic variations).
+# ---------------------------------------------------------------------------
+
+a, b, c, d = vars_("a b c d", Term)
+
+
+def algebra_rules():
+    one = Term.Lit(1.0)
+    zero = Term.Lit(0.0)
+    # Numeric literal variables — required for the factoring + folding rules
+    # below, where the RHS computes c1+c2 / c1*c2 via egglog's built-in f64
+    # arithmetic on the captured constants. `vars_` returns a generator, so
+    # single-name calls need tuple-unpack syntax.
+    (x,) = vars_("x", Term)
+    c1, c2 = vars_("c1 c2", f64)
+    return ruleset(
+        # Commutativity
+        rewrite(a + b).to(b + a),
+        rewrite(a * b).to(b * a),
+        # Associativity
+        rewrite(a + (b + c)).to((a + b) + c),
+        rewrite((a + b) + c).to(a + (b + c)),
+        rewrite(a * (b * c)).to((a * b) * c),
+        rewrite((a * b) * c).to(a * (b * c)),
+        # Distributivity (sometimes useful for kernel matching)
+        rewrite(a * (b + c)).to((a * b) + (a * c)),
+        rewrite((a + b) * c).to((a * c) + (b * c)),
+        # Identity laws
+        rewrite(a * one).to(a),
+        rewrite(one * a).to(a),
+        rewrite(a + zero).to(a),
+        rewrite(zero + a).to(a),
+        # Annihilator (mul by zero) — useful for trmm-style masks where
+        # the kernel computes `mask * value + (1 - mask) * orig`.
+        rewrite(a * zero).to(zero),
+        rewrite(zero * a).to(zero),
+        # Multi-coefficient factoring + literal folding. The first rule
+        # collapses `c1*x + c2*x` into `(c1+c2)*x`; the second/third fold
+        # literal arithmetic at the Term level. Together with commutativity
+        # and associativity (above), they handle the polybench conv3d
+        # "redundant mul" body where some inputs are multiplied by
+        # multiple literal constants and summed.
+        rewrite(Term.Lit(c1) * x + Term.Lit(c2) * x).to(Term.Lit(c1 + c2) * x),
+        rewrite(Term.Lit(c1) + Term.Lit(c2)).to(Term.Lit(c1 + c2)),
+        rewrite(Term.Lit(c1) * Term.Lit(c2)).to(Term.Lit(c1 * c2)),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Indexing-map canonicalization.
+# ---------------------------------------------------------------------------
+
+# Match affine_map<(d0, d1, ...) -> (...)> — capture the dim list and the
+# result list separately.
+_AFFINE_MAP_RE = re.compile(
+    r"affine_map<\(([^)]*)\)\s*->\s*\(([^)]*)\)>"
+)
+
+
+def _rename_in_map(map_str: str, rename: dict[str, str]) -> str:
+    """Apply a dim-name renaming to an affine_map's *result* expressions
+    (and update the dim list to use the canonical names)."""
+    m = _AFFINE_MAP_RE.match(map_str)
+    if not m:
+        return map_str
+    dim_list, results = m.group(1), m.group(2)
+    # Substitute each d name with its canonical name. Do longest-first
+    # to avoid d1 matching inside d10.
+    keys = sorted(rename, key=lambda s: -len(s))
+    new_results = results
+    for k in keys:
+        new_results = re.sub(rf"\b{k}\b", f"__TMP_{rename[k]}__", new_results)
+    # Strip the __TMP_..._ wrapping.
+    new_results = re.sub(r"__TMP_([^_]+)__", r"\1", new_results)
+    # Build canonical dim list as d0, d1, ... up to max canonical index.
+    used = sorted(set(rename.values()), key=lambda s: int(s[1:]))
+    new_dim_list = ", ".join(used) if used else dim_list
+    return f"affine_map<({new_dim_list}) -> ({new_results})>"
+
+
+def canonicalize_maps_and_iters(
+    maps: list[str], iters: list[str]
+) -> tuple[list[str], list[str]]:
+    """Canonicalize iter dim names by (a) iterator role, then (b) first-
+    appearance order within each role.
+
+    Order: all parallel dims first, then all reduction dims. Within each
+    group, ordered by where they first appear across the map results.
+
+    This makes two linalg.generic shapes that differ only by iter-dim
+    naming converge to the same canonical form — *including* their
+    iter_types attribute, which is permuted to match the new dim order.
+    """
+    if not maps or not iters:
+        return maps, iters
+
+    # First-appearance order across all maps' result expressions.
+    first_seen: list[str] = []
+    for map_str in maps:
+        m = _AFFINE_MAP_RE.match(map_str)
+        if not m:
+            continue
+        for tok in re.findall(r"\bd\d+\b", m.group(2)):
+            if tok not in first_seen:
+                first_seen.append(tok)
+    if not first_seen:
+        return maps, iters
+
+    # Some dims might be in iters but not in any result expression
+    # (broadcast-only iter dims). Include them too, after the seen ones.
+    for i in range(len(iters)):
+        name = f"d{i}"
+        if name not in first_seen:
+            first_seen.append(name)
+
+    # Group by iterator role. We require every "seen" name to have an
+    # iter_types entry; gracefully fall back if not.
+    def role_of(old_name: str) -> str:
+        idx = int(old_name[1:])
+        if 0 <= idx < len(iters):
+            return iters[idx]
+        return "parallel"  # fallback
+
+    parallel = [n for n in first_seen if role_of(n) == "parallel"]
+    reduction = [n for n in first_seen if role_of(n) == "reduction"]
+    other = [n for n in first_seen if n not in parallel and n not in reduction]
+    ordered = parallel + reduction + other
+
+    rename = {old: f"d{i}" for i, old in enumerate(ordered)}
+    canon_maps = [_rename_in_map(m, rename) for m in maps]
+    canon_iters = ["parallel"] * len(parallel) + \
+                  ["reduction"] * len(reduction) + \
+                  [role_of(n) for n in other]
+    return canon_maps, canon_iters
+
+
+# ---------------------------------------------------------------------------
+# Parser: extract linalg.generic bodies from MLIR text.
+# ---------------------------------------------------------------------------
+
+@dataclass
+class GenericBody:
+    ins_arg_names: list[str]      # like ['%in', '%in_0', ...]
+    outs_arg_names: list[str]     # like ['%out']
+    body_lines: list[str]
+    # Canonical yield list (one entry per output). Single-yield bodies have
+    # len == 1; multi-yield bodies (e.g. softmax's fused exp+sum) have one
+    # entry per `outs(...)` operand. Use `body.yield_value` (singular) for
+    # back-compat single-yield reads — returns the first yield.
+    yield_values: list[str]
+    captures: list[str]           # outer SSA values referenced in body
+    indexing_maps: list[str]      # raw text of each map
+    iterator_types: list[str]
+    constants: dict[str, float]   # captured SSA name -> Python float value
+    # Result SSA names for this linalg.generic. Multi-result ops use MLIR's
+    # `%r:2 = ...` spelling and expose `%r#0`, `%r#1`, ... as users. This is
+    # needed for scalar-chain checks such as `%inv_sum = 1.0 / %softmax_sum`.
+    result_names: list[str] = None  # type: ignore[assignment]
+    # Best-effort scalar use-def environment for SSA values outside linalg
+    # bodies. The ordinary body matcher intentionally focuses on linalg body
+    # Terms; this side table lets selected compositions prove relationships
+    # among captured scalars without turning the whole matcher into MLIR data
+    # flow analysis.
+    scalar_defs: dict[str, Term] = None  # type: ignore[assignment]
+    # For each block input arg, the SSA name of the constant it's multiplied
+    # with in the body — populated only if the input appears in exactly one
+    # `arith.mulf %in, %cst : ...` (or `arith.mulf %cst, %in : ...`). Used by
+    # render_launch to surface body-internal weight constants as launch
+    # operands so the lowering pass can pass them to a generic runtime shim
+    # (instead of the shim having to hardcode them). None for ins that don't
+    # match the pattern. Aligned by index with ins_arg_names.
+    # Each entry is either None (no constant paired with this input) or a
+    # list of all constant SSAs that pair with the input. Multi-element
+    # lists indicate the polybench-conv3d-style "redundant mul" pattern
+    # where the same input is multiplied by several literal constants
+    # and summed — the rewriter materialises a new arith.constant with
+    # the summed value for the launch operand.
+    inline_weights_per_in: list[list[str] | None] = None  # type: ignore[assignment]
+
+    @property
+    def yield_value(self) -> str:
+        """Back-compat alias for callers written before multi-yield support
+        — returns the first yield's SSA name. New code should iterate
+        `yield_values` directly."""
+        return self.yield_values[0] if self.yield_values else ""
+
+
+_GEN_RE = re.compile(
+    r"(?:(%[\w_\-]+)(?::(\d+))?\s*=\s*)?"
+    r"linalg\.generic\s*\{[^}]*indexing_maps\s*=\s*\[([^\]]*)\][^}]*"
+    r"iterator_types\s*=\s*\[([^\]]*)\][^}]*\}[^\^]*?"
+    # Yield captures one OR MORE comma-separated SSA names. Multi-yield
+    # bodies (e.g. softmax's fused exp+sum) write to multiple outs in one
+    # op. Single-yield bodies still match unchanged — the (?:...)*
+    # group is zero-or-more. The capture is the full operand list as a
+    # single string; parse_generics splits on commas to produce the
+    # GenericBody.yield_values list.
+    r"\^bb0\(([^)]*)\)\s*:\s*(.*?)\s*"
+    r"linalg\.yield\s+(%[\w_]+(?:\s*,\s*%[\w_]+)*)\s*:",
+    re.DOTALL,
+)
+
+
+# Recognize `%name = arith.constant  : ` at module/function scope.
+# SSA names allow `-` in the body (e.g. cgeist emits `%c-8_i32` for negative
+# int constants). Use a char class that includes `-` so we don't miss them.
+_CONST_RE = re.compile(
+    r"(%[\w_\-]+)\s*=\s*arith\.constant\s+([^\s:]+)\s*:\s*\S+"
+)
+
+
+def parse_constants(mlir_text: str) -> dict[str, float]:
+    """Build a map from SSA name → constant literal value as a Python float.
+
+    Floats here serve two purposes: (a) literal identity-rule matching in
+    the algebra ruleset (e.g. `a*1.0 → a`), and (b) the new factoring +
+    folding rules that compute on f64 constants. Both require the value
+    to live in egglog's f64 sort, so we store it as a Python float here
+    and let egglog auto-promote at Lit construction time.
+
+    Integer constants (e.g. `arith.constant 5 : i32`) are coerced to
+    float — this is sound because the encoder collapses int/float arith
+    into the same Term operators, so int-typed constants live in the same
+    Term-level numeric domain as float ones for matching purposes.
+
+    Examples:
+      `%cst = arith.constant 0.000000e+00 : f64`   →  {"%cst": 0.0}
+      `%cst_0 = arith.constant 1.000000e+00 : f64` →  {"%cst_0": 1.0}
+      `%c1 = arith.constant 1 : index`             →  {"%c1": 1.0}
+      `%c-8_i32 = arith.constant -8 : i32`         →  {"%c-8_i32": -8.0}
+    """
+    out: dict[str, float] = {}
+    for m in _CONST_RE.finditer(mlir_text):
+        name, value = m.group(1), m.group(2)
+        try:
+            out[name] = float(value)
+        except ValueError:
+            # Non-numeric (e.g. an undef). Skip.
+            pass
+    return out
+
+
+def _encode_scalar_defs(mlir_text: str,
+                        constants: dict[str, float]) -> dict[str, Term]:
+    """Best-effort scalar SSA expression table for ops surrounding linalg.
+
+    The main matcher encodes each linalg.generic body independently. Some
+    kernels, however, compute scalar captures between generics, e.g. Whisper
+    softmax:
+
+      %sum = tensor.extract %exp_sum#1[] : tensor
+      %inv = arith.divf %cst_1, %sum : f32
+      ... yield %out * %inv ...
+
+    This table keeps just enough scalar use-def information to prove those
+    capture relationships when a composition explicitly asks for it.
+    Unknown values remain opaque Caps.
+    """
+    env: dict[str, Term] = {
+        name: Term.Lit(value) for name, value in constants.items()
+    }
+
+    def resolve(tok: str) -> Term:
+        tok = tok.strip()
+        m = re.match(r"(%[\w_\-]+(?:#\d+)?)", tok)
+        if m:
+            name = m.group(1)
+            return env.get(name, Term.Cap(name))
+        try:
+            return Term.Lit(float(tok))
+        except ValueError:
+            return Term.Lit(float("nan"))
+
+    for raw in mlir_text.splitlines():
+        line = raw.strip()
+        m = re.match(r"(%[\w_\-]+)\s*=\s*(\w+\.\w+)\s+(.*?)\s*:", line)
+        if not m:
+            continue
+        result, op, args_part = m.group(1), m.group(2), m.group(3)
+        arg_toks = [s.strip() for s in args_part.split(",")]
+        if op in ("arith.mulf", "arith.muli") and len(arg_toks) >= 2:
+            env[result] = resolve(arg_toks[0]) * resolve(arg_toks[1])
+        elif op in ("arith.addf", "arith.addi") and len(arg_toks) >= 2:
+            env[result] = resolve(arg_toks[0]) + resolve(arg_toks[1])
+        elif op in ("arith.subf", "arith.subi") and len(arg_toks) >= 2:
+            env[result] = resolve(arg_toks[0]) - resolve(arg_toks[1])
+        elif op in ("arith.divf", "arith.divsi") and len(arg_toks) >= 2:
+            env[result] = resolve(arg_toks[0]) / resolve(arg_toks[1])
+        elif op == "arith.negf" and arg_toks:
+            env[result] = Term.Lit(0.0) - resolve(arg_toks[0])
+        elif op == "math.sqrt" and arg_toks:
+            env[result] = Term.Sqrt(resolve(arg_toks[0]))
+        elif op in ("math.absf", "math.absi") and arg_toks:
+            env[result] = Term.Abs(resolve(arg_toks[0]))
+        elif op == "math.exp" and arg_toks:
+            env[result] = Term.Exp(resolve(arg_toks[0]))
+        elif op == "math.tanh" and arg_toks:
+            env[result] = Term.Tanh(resolve(arg_toks[0]))
+        elif op == "tensor.extract" and arg_toks:
+            # Treat extracting a scalar tensor result as transparent to the
+            # result SSA, e.g. `%s = tensor.extract %r#1[]` -> Cap("%r#1").
+            env[result] = resolve(arg_toks[0])
+    return env
+
+
+_MAP_ALIAS_RE = re.compile(
+    # affine_map text contains `->` which has a `>`, so [^>] is wrong here.
+    # Match the literal form `affine_map<(...) -> (...)>`.
+    r"^\s*(#map\w*)\s*=\s*"
+    r"(affine_map<\([^)]*\)\s*->\s*\([^)]*\)>)",
+    re.MULTILINE
+)
+
+
+def _resolve_map_aliases(mlir_text: str) -> str:
+    """Inline any `#mapN = affine_map<...>` top-level aliases by substituting
+    each `#mapN` reference with the corresponding `affine_map<...>` literal.
+    Required because parse_generics' regex only sees inline `affine_map<...>`
+    text — kernels lifted via the standard pipeline carry aliased map refs,
+    so without this the indexing_maps field comes back empty."""
+    aliases = {name: literal for name, literal
+               in _MAP_ALIAS_RE.findall(mlir_text)}
+    if not aliases:
+        return mlir_text
+    # Sort by descending name length so #map10 substitutes before #map1.
+    # No `\b` left boundary because `#` is not a word char — Python's `\b`
+    # would refuse to match before it; rely on length-descending order +
+    # negative lookahead on the right to disambiguate #map1 from #map10.
+    for name in sorted(aliases, key=len, reverse=True):
+        mlir_text = re.sub(re.escape(name) + r"(?!\w)",
+                            aliases[name], mlir_text)
+    return mlir_text
+
+
+def parse_generics(mlir_text: str,
+                   constants: dict[str, float] | None = None) -> list[GenericBody]:
+    """Extract every linalg.generic with its body."""
+    if constants is None:
+        constants = parse_constants(mlir_text)
+    scalar_defs = _encode_scalar_defs(mlir_text, constants)
+    mlir_text = _resolve_map_aliases(mlir_text)
+    results = []
+    for m in _GEN_RE.finditer(mlir_text):
+        result_base, result_count, maps_str, iters_str, args_str, body_str, yield_operands_str = m.groups()
+        if result_base and result_count:
+            result_names = [
+                f"{result_base}#{i}" for i in range(int(result_count))
+            ]
+        elif result_base:
+            result_names = [result_base]
+        else:
+            result_names = []
+        # Split the yield's operand list on commas (multi-yield bodies have
+        # multiple SSAs separated by commas). The regex preserves whitespace
+        # around commas, so strip per-token.
+        yield_names = [s.strip() for s in yield_operands_str.split(",") if s.strip()]
+        # Back-compat for the rest of the local scope: yield_name refers to
+        # the FIRST yield. Most local logic (capture detection, etc.) was
+        # written assuming a single yield value — keeping it correct for
+        # the single-yield case AND for the first slot of multi-yield bodies.
+        yield_name = yield_names[0] if yield_names else ""
+
+        # Parse args like "%in: f64, %in_0: f64, %out: f64"
+        ins, outs = [], []
+        for piece in args_str.split(","):
+            piece = piece.strip()
+            if not piece:
+                continue
+            name = piece.split(":")[0].strip()
+            (outs if name.startswith("%out") else ins).append(name)
+
+        # Tokenize indexing maps and iterator types as raw substrings.
+        # Don't use `affine_map<[^>]*>` — the `->` inside contains a `>`.
+        maps = [s.strip() for s in
+                re.findall(r"affine_map<\([^)]*\)\s*->\s*\([^)]*\)>", maps_str)]
+        iters = [s.strip().strip('"') for s in iters_str.split(",")]
+        # Canonicalize: rename iter dims by their first-appearance order
+        # across all maps, and permute iter_types to match.
+        maps, iters = canonicalize_maps_and_iters(maps, iters)
+
+        # Crude SSA-line extraction: each line in body is an arith op.
+        body_lines = [
+            ln.strip() for ln in body_str.split("\n")
+            if ln.strip() and not ln.strip().startswith("//")
+        ]
+
+        # Find captures (SSA values that aren't block args and aren't defined locally).
+        local_defs = set()
+        captures: list[str] = []
+        for ln in body_lines:
+            assigned = re.match(r"(%[\w_]+)\s*=", ln)
+            if assigned:
+                local_defs.add(assigned.group(1))
+        for ln in body_lines:
+            # Find all %xxx references on the rhs.
+            for tok in re.findall(r"%[\w_]+", ln):
+                if (tok not in local_defs and tok not in ins and tok not in outs
+                        and tok not in captures):
+                    captures.append(tok)
+        # Also catch yield-only captures — for every yield value, if it
+        # references something defined outside the body (not a block arg,
+        # not produced by any op in the body), promote it to a capture.
+        for yn in yield_names:
+            if (yn not in local_defs and yn not in ins
+                    and yn not in outs and yn not in captures):
+                captures.append(yn)
+
+        # Build the inline-weights side-table: for each block input arg
+        # %in_k, find the unique arith.mulf line that pairs it with a
+        # capture-constant and record the constant's SSA name. Used by
+        # the rewriter to surface body-internal weights as launch operands.
+        # If an input is multiplied by more than one constant (e.g. the
+        # buggy conv3d's duplicated-index pattern), record None — that
+        # case needs a different matcher template anyway.
+        # Build an "alias map": when the body has `%24 = arith.extsi %in : i16
+        # to i32`, then `%24` is a synonym for `%in` for weight-pairing
+        # purposes. C's integer-promotion rule means cgeist always inserts
+        # an extsi between an i16 input and its i32-typed multiply, so the
+        # mul's lhs is the extsi result, not the input itself. Same idea for
+        # extui / trunci / sitofp / extf / truncf.
+        alias_of: dict[str, str] = {}
+        cast_re = re.compile(
+            r"(%[\w_\-]+)\s*=\s*arith\."
+            r"(?:extsi|extui|trunci|sitofp|uitofp|fptosi|fptoui|extf|truncf|bitcast)"
+            r"\s+(%[\w_\-]+)\s*:"
+        )
+        for ln in body_lines:
+            m_cast = cast_re.match(ln.strip())
+            if m_cast:
+                alias_of[m_cast.group(1)] = m_cast.group(2)
+
+        def root_alias(ssa: str) -> str:
+            # Follow the alias chain to its root (handles double casts).
+            while ssa in alias_of:
+                ssa = alias_of[ssa]
+            return ssa
+
+        inline_weights: list[list[str] | None] = []
+        for in_arg in ins:
+            constant_ssas: list[str] = []
+            for ln in body_lines:
+                # Match arith.mulf OR arith.muli — same surfacing logic applies
+                # to integer-typed weighted stencils (the conv2d_i32 / i16
+                # bodies) as to float ones.
+                m_mul = re.match(
+                    r"%[\w_\-]+\s*=\s*arith\.mul[fi]\s+(\S+?)\s*,\s*(\S+?)\s*:",
+                    ln.strip(),
+                )
+                if not m_mul:
+                    continue
+                a, b = m_mul.group(1), m_mul.group(2)
+                # Strip trailing commas (the regex's \S+? may grab one).
+                a = a.rstrip(",")
+                b = b.rstrip(",")
+                # Resolve cast aliases so the mul's lhs (which may be an
+                # extsi result) is compared to the block input arg.
+                a_root = root_alias(a)
+                b_root = root_alias(b)
+                if a_root == in_arg and b in constants:
+                    constant_ssas.append(b)
+                elif b_root == in_arg and a in constants:
+                    constant_ssas.append(a)
+            # Empty list -> no constants paired with this input (rare); the
+            # rewriter sees None and won't surface a weight for it. Single
+            # or multiple -> always return the list; the rewriter decides
+            # whether to use the SSA directly or materialise a summed
+            # constant.
+            inline_weights.append(constant_ssas if constant_ssas else None)
+
+        results.append(GenericBody(
+            ins_arg_names=ins,
+            outs_arg_names=outs,
+            body_lines=body_lines,
+            yield_values=yield_names,
+            captures=captures,
+            indexing_maps=maps,
+            iterator_types=iters,
+            constants={
+                name: constants[name]
+                for name in captures
+                if name in constants
+            },
+            result_names=result_names,
+            scalar_defs=scalar_defs,
+            inline_weights_per_in=inline_weights,
+        ))
+    return results
+
+
+# ---------------------------------------------------------------------------
+# Encoder: GenericBody -> egglog Term.
+# ---------------------------------------------------------------------------
+
+_OP_PATTERNS = {
+    "arith.mulf": "mul",
+    "arith.addf": "add",
+    "arith.subf": "sub",
+    "arith.divf": "div",
+    "arith.negf": "neg",
+    # Integer counterparts. The encoder collapses int and float arith into
+    # the same algebraic Term (mul/add/sub/div) so one library template
+    # matches both dtypes. The dtype-suffix dispatch in the rewriter picks
+    # the right canonical defn and shim per element type.
+    "arith.muli": "mul",
+    "arith.addi": "add",
+    "arith.subi": "sub",
+    "arith.divsi": "div",
+    "math.sqrt": "sqrt",
+    "math.absf": "abs",
+    "math.absi": "abs",
+    # Transcendentals — used by softmax (exp), gelu (tanh), crossentropy (log).
+    # Encoded as opaque unary Terms; templates can match against `Term.Exp(x)`
+    # etc. so the matcher recognises the kernel without trying to fold them.
+    "math.exp": "exp",
+    "math.tanh": "tanh",
+    "arith.cmpf": "cmpf",
+    "arith.cmpi": "cmpi",
+    "arith.select": "select",
+    # Sign/zero extension and truncation cast ops. C's integer-promotion
+    # rule (e.g. short * int → int) makes cgeist emit `arith.extsi %in : i16
+    # to i32` before each `arith.muli`. These are semantically identity for
+    # template matching — the template sees an "input × weight" product
+    # regardless of how the i16/i32 widths flow underneath. Marking them
+    # "transparent" makes the matcher unify both widths to the same Term.
+    "arith.extsi": "transparent",
+    "arith.extui": "transparent",
+    "arith.trunci": "transparent",
+    "arith.sitofp": "transparent",
+    "arith.uitofp": "transparent",
+    "arith.fptosi": "transparent",
+    "arith.fptoui": "transparent",
+    "arith.extf": "transparent",
+    "arith.truncf": "transparent",
+    "arith.bitcast": "transparent",
+}
+
+
+def encode_body(g: GenericBody) -> Term:
+    """Build an egglog Term from a parsed body."""
+    # Map SSA names to Term objects.
+    env: dict[str, Term] = {}
+    for i, name in enumerate(g.ins_arg_names):
+        env[name] = Term.In(i)
+    for i, name in enumerate(g.outs_arg_names):
+        env[name] = Term.Out(i)
+    for cap in g.captures:
+        # Constants get a numeric Lit so identity rules can fire on them.
+        if cap in g.constants:
+            env[cap] = Term.Lit(g.constants[cap])
+        else:
+            env[cap] = Term.Cap(cap)
+
+    def lookup(name: str) -> Term:
+        """Get the Term for an SSA name; fall back to Cap/Lit for unknown values."""
+        if name in env:
+            return env[name]
+        # Unknown — check the module-level constants map first (a yield of
+        # `%cst` referring to a `arith.constant 0.0` should be Lit("0.0"),
+        # not an opaque Cap).
+        if name in g.constants:
+            env[name] = Term.Lit(g.constants[name])
+        else:
+            env[name] = Term.Cap(name)
+        return env[name]
+
+    for line in g.body_lines:
+        m = re.match(
+            r"(%[\w_]+)\s*=\s*(\w+\.\w+)\s+(.*?)\s*:\s*\S+", line.strip()
+        )
+        if not m:
+            continue
+        result, op, args_part = m.group(1), m.group(2), m.group(3)
+
+        # Split args by commas, ignoring those inside <...>.
+        # For arith ops the args are just `%a, %b` or `%pred, %a, %b`.
+        arg_toks = [s.strip() for s in args_part.split(",")]
+
+        # Resolve each token to a Term (it's either an SSA name or a literal).
+        def resolve(tok: str) -> Term:
+            tok = tok.strip()
+            if tok.startswith("%"):
+                return lookup(tok)
+            # Numeric literal. Lit is now f64-typed, so coerce. Non-numeric
+            # tokens (rare — only inline-affine-attribute strings would land
+            # here) get NaN as a sentinel so they still produce a valid
+            # f64 Lit but won't algebraically match anything meaningful.
+            try:
+                return Term.Lit(float(tok))
+            except ValueError:
+                return Term.Lit(float("nan"))
+
+        op_key = _OP_PATTERNS.get(op, op)
+        if op_key == "transparent":
+            # Cast-like op — propagate the source Term as-is.
+            env[result] = resolve(arg_toks[0])
+            continue
+        if op_key == "mul":
+            env[result] = resolve(arg_toks[0]) * resolve(arg_toks[1])
+        elif op_key == "add":
+            env[result] = resolve(arg_toks[0]) + resolve(arg_toks[1])
+        elif op_key == "sub":
+            env[result] = resolve(arg_toks[0]) - resolve(arg_toks[1])
+        elif op_key == "neg":
+            env[result] = Term.Lit(0.0) - resolve(arg_toks[0])
+        elif op_key == "div":
+            env[result] = resolve(arg_toks[0]) / resolve(arg_toks[1])
+        elif op_key == "sqrt":
+            env[result] = Term.Sqrt(resolve(arg_toks[0]))
+        elif op_key == "abs":
+            env[result] = Term.Abs(resolve(arg_toks[0]))
+        elif op_key == "exp":
+            env[result] = Term.Exp(resolve(arg_toks[0]))
+        elif op_key == "tanh":
+            env[result] = Term.Tanh(resolve(arg_toks[0]))
+        elif op_key == "select":
+            env[result] = Term.Select(
+                resolve(arg_toks[0]), resolve(arg_toks[1]), resolve(arg_toks[2])
+            )
+        elif op_key == "cmpf":
+            # Form: "kind, %a, %b" — arg_toks[0]="kind", [1]=%a, [2]=%b.
+            # Or sometimes "kind %a", "%b" if a space slipped in. Handle both.
+            kind = arg_toks[0].strip()
+            if " " in kind:
+                kind, lhs_tok = kind.split(None, 1)
+                rhs_tok = arg_toks[1]
+            elif len(arg_toks) >= 3:
+                lhs_tok, rhs_tok = arg_toks[1], arg_toks[2]
+            else:
+                # Malformed — fall back to opaque.
+                env[result] = Term.Cap(result)
+                continue
+            env[result] = Term.Cmp(kind, resolve(lhs_tok), resolve(rhs_tok))
+        else:
+            # Unknown op — model as opaque Cap so matching still works elsewhere.
+            env[result] = Term.Cap(result)
+
+    return lookup(g.yield_value)
+
+
+def encode_body_yields(g: GenericBody) -> list[Term]:
+    """Multi-yield-aware sibling of `encode_body`. Returns one Term per
+    `linalg.yield` operand, computed in the same body env so any shared
+    intermediates are reflected across both yields.
+
+    Single-yield bodies return a 1-element list (the same Term `encode_body`
+    would have returned). Multi-yield bodies — like softmax's fused exp+sum
+    body, which writes the elementwise exp to one output and the running
+    sum to another in one iteration — return one Term per output position.
+    Callers that match against multi-yield templates iterate this list in
+    lockstep with the template's `body_per_yield`.
+    """
+    # Re-run encode_body's body walk but lookup ALL yields at the end.
+    # Reuse encode_body for the env construction by calling it once (it
+    # produces side-effects on a fresh env each invocation, so we re-do
+    # the walk inline). For now the simplest implementation rebuilds the
+    # env — duplicates encode_body's body-walking logic but extracts a
+    # Term per yield position.
+    env: dict[str, Term] = {}
+    for i, name in enumerate(g.ins_arg_names):
+        env[name] = Term.In(i)
+    for i, name in enumerate(g.outs_arg_names):
+        env[name] = Term.Out(i)
+    for cap in g.captures:
+        if cap in g.constants:
+            env[cap] = Term.Lit(g.constants[cap])
+        else:
+            env[cap] = Term.Cap(cap)
+
+    def lookup(name: str) -> Term:
+        if name in env:
+            return env[name]
+        if name in g.constants:
+            env[name] = Term.Lit(g.constants[name])
+        else:
+            env[name] = Term.Cap(name)
+        return env[name]
+
+    for line in g.body_lines:
+        m = re.match(
+            r"(%[\w_]+)\s*=\s*(\w+\.\w+)\s+(.*?)\s*:\s*\S+", line.strip()
+        )
+        if not m:
+            continue
+        result, op, args_part = m.group(1), m.group(2), m.group(3)
+        arg_toks = [s.strip() for s in args_part.split(",")]
+
+        def resolve(tok: str) -> Term:
+            tok = tok.strip()
+            if tok.startswith("%"):
+                return lookup(tok)
+            try:
+                return Term.Lit(float(tok))
+            except ValueError:
+                return Term.Lit(float("nan"))
+
+        op_key = _OP_PATTERNS.get(op, op)
+        if op_key == "transparent":
+            env[result] = resolve(arg_toks[0]); continue
+        if op_key == "mul":
+            env[result] = resolve(arg_toks[0]) * resolve(arg_toks[1])
+        elif op_key == "add":
+            env[result] = resolve(arg_toks[0]) + resolve(arg_toks[1])
+        elif op_key == "sub":
+            env[result] = resolve(arg_toks[0]) - resolve(arg_toks[1])
+        elif op_key == "neg":
+            env[result] = Term.Lit(0.0) - resolve(arg_toks[0])
+        elif op_key == "div":
+            env[result] = resolve(arg_toks[0]) / resolve(arg_toks[1])
+        elif op_key == "sqrt":
+            env[result] = Term.Sqrt(resolve(arg_toks[0]))
+        elif op_key == "abs":
+            env[result] = Term.Abs(resolve(arg_toks[0]))
+        elif op_key == "exp":
+            env[result] = Term.Exp(resolve(arg_toks[0]))
+        elif op_key == "tanh":
+            env[result] = Term.Tanh(resolve(arg_toks[0]))
+        elif op_key == "select":
+            env[result] = Term.Select(
+                resolve(arg_toks[0]), resolve(arg_toks[1]), resolve(arg_toks[2])
+            )
+        elif op_key == "cmpf":
+            kind = arg_toks[0].strip()
+            if " " in kind:
+                kind, lhs_tok = kind.split(None, 1)
+                rhs_tok = arg_toks[1]
+            elif len(arg_toks) >= 3:
+                lhs_tok, rhs_tok = arg_toks[1], arg_toks[2]
+            else:
+                env[result] = Term.Cap(result); continue
+            env[result] = Term.Cmp(kind, resolve(lhs_tok), resolve(rhs_tok))
+        else:
+            env[result] = Term.Cap(result)
+
+    return [lookup(yv) for yv in g.yield_values]
+
+
+# ---------------------------------------------------------------------------
+# Library + matcher.
+# ---------------------------------------------------------------------------
+
+@dataclass
+class LibraryEntry:
+    name: str               # e.g. "beta_scale", "gemm_accumulate"
+    source_kernel: str      # which PolyBench file we extracted it from
+    canonical_body: Term
+    num_ins: int
+    num_outs: int
+    indexing_maps: list[str]
+    iterator_types: list[str]
+
+
+def equivalent(a: Term, b: Term) -> bool:
+    """Are two Terms equivalent under the current algebra rules?"""
+    eg = EGraph()
+    eg.register(a, b)
+    eg.run(algebra_rules() * 8)
+    try:
+        eg.check(a == b)
+        return True
+    except Exception:
+        return False
+
+
+def kernel_files(root: Path) -> list[Path]:
+    return sorted(root.glob("*_debuf.mlir"))
+
+
+def build_library_from_dir(root: Path) -> list[LibraryEntry]:
+    """Walk *_debuf.mlir, extract bodies, dedupe by structural equivalence."""
+    entries: list[LibraryEntry] = []
+    for f in kernel_files(root):
+        text = f.read_text()
+        try:
+            gens = parse_generics(text)
+        except Exception as e:
+            print(f"parse skip {f.name}: {e}")
+            continue
+        kernel = f.stem.replace("_debuf", "")
+        for i, g in enumerate(gens):
+            try:
+                t = encode_body(g)
+            except Exception as e:
+                print(f"encode skip {f.name}#{i}: {e}")
+                continue
+            # Dedupe: if any existing entry matches structurally, reuse it.
+            existing = next(
+                (e for e in entries
+                 if e.num_ins == len(g.ins_arg_names)
+                 and e.num_outs == len(g.outs_arg_names)
+                 and e.indexing_maps == g.indexing_maps
+                 and e.iterator_types == g.iterator_types
+                 and equivalent(e.canonical_body, t)),
+                None,
+            )
+            if existing:
+                continue
+            entries.append(LibraryEntry(
+                name=f"{kernel}_lg{i}",
+                source_kernel=kernel,
+                canonical_body=t,
+                num_ins=len(g.ins_arg_names),
+                num_outs=len(g.outs_arg_names),
+                indexing_maps=g.indexing_maps,
+                iterator_types=g.iterator_types,
+            ))
+    return entries
+
+
+# ---------------------------------------------------------------------------
+# Composition matcher: recognize sequences of linalg.generics as one library
+# kernel (e.g. beta_scale + alpha_matmul = dgemm).
+# ---------------------------------------------------------------------------
+
+@dataclass
+class CompositionStep:
+    """One linalg.generic in a multi-step composition."""
+    body: Term                          # template with Cap wildcards
+    num_ins: Optional[int] = None       # expected ins count, or None for any
+    num_outs: Optional[int] = None      # expected outs count, or None
+    reduction_dim_count: Optional[int] = None  # number of "reduction" iters
+    parallel_dim_count: Optional[int] = None   # number of "parallel" iters
+    # For multi-yield linalg.generic bodies (e.g. softmax's fused exp+sum),
+    # one template Term per yield position. The matcher walks both lists
+    # in lockstep against `encode_body_yields(body)`. None falls back to
+    # single-yield matching against `body` above. When set, num_outs
+    # should equal len(body_per_yield).
+    body_per_yield: Optional[list[Term]] = None
+    # Non-scalar structural predicate for bodies whose semantics cannot be
+    # represented by the scalar Term language. Used for guarded im2col:
+    # the body contains scf.if + memref.load, and the value yielded from the
+    # scf.if appears opaque to encode_body().
+    special: Optional[str] = None
+
+
+@dataclass
+class CompositionEntry:
+    """A named multi-linalg pattern.
+
+    Each step's body template is matched (structural unification with
+    Cap-as-wildcard) against the body of the next linalg.generic. The
+    optional shape gates (num_ins, num_outs, reduction_dim_count) rule out
+    same-body shapes that differ in linalg-level metadata (e.g. gemv vs
+    axpy vs dot all share the body `out + a*b` but differ in iter types).
+
+    `form` gates whether the entry fires on tensor-form linalg.generic
+    (the default, what `--linalg-debufferize` produces), memref-form (used
+    by stencils + other ops where debufferize doesn't lift due to outer
+    time-stepping loops), or both. The canonical library defn for each
+    entry only operates on one of those forms — matching the wrong form
+    causes the lowering pass to fail with a type mismatch. Setting `form`
+    here keeps the matcher honest.
+    """
+    name: str
+    steps: list[CompositionStep]
+    form: str = "tensor"   # "tensor" | "memref" | "any"
+    # Optional scalar element type required in every matched generic body.
+    # This prevents identical algebraic bodies from selecting a library ABI
+    # of the wrong precision (for example f32 dot -> cublasDdot).
+    element_type: Optional[str] = None
+    # When True, the rewriter additionally appends the matched body's
+    # inline weight constants (one per input block arg) as scalar operands
+    # of the emitted kernel.launch op. Use for templates whose body has the
+    # shape `sum_k In(k) * Cap("%wk")` where each weight is a body-internal
+    # arith.constant (e.g. conv2d_9pt_weighted). The lowering pass can then
+    # pass those weights to a generic runtime shim instead of hardcoding
+    # them. Default False to keep behavior of every other template (gemm,
+    # gemv, jacobi, ...) unchanged — they already surface scalars via
+    # function-arg Caps, not body-internal Lits.
+    surface_inline_weights: bool = False
+    # Optional named postcondition over scalar captures outside the linalg
+    # bodies. Used sparingly for composition variants whose body shape alone
+    # is under-constrained, e.g. softmax normalization written as
+    # `out *= inv_sum` where `%inv_sum` must be proven to be `1 / sum`.
+    scalar_relation: Optional[str] = None
+
+
+@dataclass
+class SemanticCandidate:
+    """One possible semantic interpretation of a raised linalg body.
+
+    This is intentionally separate from ABI lowering. A candidate may denote:
+      - an exact whole-body/composition match already present in
+        `composition_library()`;
+      - a semantic node recognized inside a scalar subexpression; or
+      - a specialization/completion of one semantic node into another, e.g.
+        a 7-point sparse stencil completed into a 3x3x3 convolution by filling
+        missing taps with zero.
+
+    The rewriter can still pick the old greedy ABI-lowerable path, while dry
+    runs can expose the full candidate set for planning/cost-model work.
+    """
+    name: str
+    body_indices: tuple[int, ...]
+    match_kind: str          # "whole" | "composition" | "subterm" | "completion"
+    coverage: str            # "whole" | "partial"
+    bindings: dict
+    entry: Optional[CompositionEntry] = None
+    defaults: tuple[tuple[str, str], ...] = ()
+    subterm_path: tuple[int, ...] = ()
+    source: Optional[str] = None
+
+
+# Canonical body templates. Cap names are template wildcards — they bind
+# to whatever capture appears in the user's body at that position.
+# Op-name targets follow real library API naming
+# (cublasD / cusolverDn / cudnn...).
+#
+# Body shape -> library target.
+
+def T_cap(name: str) -> Term:
+    return Term.Cap(name)
+
+
+def _gemm_composition() -> CompositionEntry:
+    """C = β*C + α*A*B  (PolyBench gemm form)."""
+    s1 = CompositionStep(
+        body=Term.Out(0) * T_cap("%beta"),
+        num_ins=0, num_outs=1, parallel_dim_count=2, reduction_dim_count=0,
+    )
+    s2 = CompositionStep(
+        body=Term.Out(0) + (T_cap("%alpha") * Term.In(0)) * Term.In(1),
+        num_ins=2, num_outs=1, parallel_dim_count=2, reduction_dim_count=1,
+    )
+    return CompositionEntry(name="cublasDgemm", steps=[s1, s2])
+
+
+def _gemm_alpha_only() -> CompositionEntry:
+    """C += α*A*B  (no beta — used by 2mm/3mm intermediates)."""
+    body = Term.Out(0) + (T_cap("%alpha") * Term.In(0)) * Term.In(1)
+    return CompositionEntry(
+        name="cublasDgemm_alpha_only",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=1)],
+    )
+
+
+def _conv1x1_as_gemm_batched() -> CompositionEntry:
+    """Batched 1×1 convolution. Mathematically a per-pixel matmul:
+       (B·H·W, IC) × (IC, OC) → (B·H·W, OC)
+    Because KH = KW = 1, the trivial inner loops drop out at raise
+    time, leaving a 5-iter generic (4 parallel: B, OC, H, W; 1
+    reduction: IC) with body `Out + In(0)*In(1)`.
+
+    Distinguished from the standard K×K conv (`cudnnConvolutionFwd_batched`,
+    which has 4 par + 3 red) purely by the reduction count.
+    Routes to cublasDgemm via a reshape — much faster than cuDNN's
+    generic K=1 conv path.
+    """
+    init_step = CompositionStep(
+        body=Term.Lit(0.0),
+        num_ins=0, num_outs=1,
+        parallel_dim_count=4, reduction_dim_count=0,
+    )
+    gemm_step = CompositionStep(
+        body=Term.Out(0) + Term.In(0) * Term.In(1),
+        num_ins=2, num_outs=1,
+        parallel_dim_count=4, reduction_dim_count=1,
+    )
+    return CompositionEntry(
+        name="cublasGemmFor1x1Conv",
+        steps=[init_step, gemm_step],
+    )
+
+
+def _generic_two_input_sum_contraction_tensor() -> CompositionEntry:
+    """Rank- and iterator-count-independent two-input sum contraction.
+
+    This deliberately recognizes only the scalar computation here.  The
+    rewrite layer subsequently proves the Einstein-map legality, element type,
+    physical broadcast layout, and ABI support before emitting a launch.  In
+    particular, leaving the iterator counts unconstrained lets the same entry
+    cover both MFEM's 2D (three parallel modes) and 3D (four parallel modes)
+    sum-factorization stages.
+    """
+    zero = CompositionStep(
+        body=Term.Lit(0.0),
+        num_ins=0, num_outs=1,
+        reduction_dim_count=0,
+    )
+    contraction = CompositionStep(
+        body=Term.Out(0) + Term.In(0) * Term.In(1),
+        num_ins=2, num_outs=1,
+    )
+    return CompositionEntry(
+        name="cutensornetContraction2_f64",
+        steps=[zero, contraction],
+        form="tensor",
+    )
+
+
+def _cublaslt_gemm_bias_relu_fused() -> CompositionEntry:
+    """Fused matmul + bias + relu — transformer-FFN-shape op.
+    4-step composition:
+
+      step 0 (init):  C = 0                  — 2 par, 0 ins
+      step 1 (gemm):  C += A*B               — 2 par + 1 red, 2 ins
+      step 2 (bias):  C += bias              — 2 par, 1 in (1D, broadcast)
+      step 3 (relu):  C = max(C, 0)          — 2 par, 0 ins
+
+    Routes to cublasLt's CUBLASLT_EPILOGUE_RELU_BIAS — natively fuses
+    matmul + bias-add + relu in one kernel. Requires libcublasLt at link
+    time (separate from libcublas).
+    """
+    init_step = CompositionStep(
+        body=Term.Lit(0.0),
+        num_ins=0, num_outs=1,
+        parallel_dim_count=2, reduction_dim_count=0,
+    )
+    gemm_step = CompositionStep(
+        body=Term.Out(0) + Term.In(0) * Term.In(1),
+        num_ins=2, num_outs=1,
+        parallel_dim_count=2, reduction_dim_count=1,
+    )
+    bias_step = CompositionStep(
+        body=Term.Out(0) + Term.In(0),
+        num_ins=1, num_outs=1,
+        parallel_dim_count=2, reduction_dim_count=0,
+    )
+    relu_step = CompositionStep(
+        body=Term.Select(
+            Term.Cmp("ogt", Term.Out(0), Term.Lit(0.0)),
+            Term.Out(0),
+            Term.Lit(0.0),
+        ),
+        num_ins=0, num_outs=1,
+        parallel_dim_count=2, reduction_dim_count=0,
+    )
+    return CompositionEntry(
+        name="cublasLtMatmulBiasReluFused",
+        steps=[init_step, gemm_step, bias_step, relu_step],
+    )
+
+
+def _cudnn_conv_bias_relu_add_fused() -> CompositionEntry:
+    """Fused conv + bias + residual-add + relu — canonical ResNet output
+    stage. 5-step composition:
+
+      step 0 (init):     Bout = 0                  — 4 par, 0 ins
+      step 1 (conv):     Bout += A * F             — 4 par + 3 red, 2 ins
+      step 2 (bias):     Bout += bias[oc]          — 4 par, 1 in (1D)
+      step 3 (residual): Bout += Z                 — 4 par, 1 in (4D)
+      step 4 (relu):     Bout = max(Bout, 0)       — 4 par, 0 ins
+
+    Steps 2 and 3 have IDENTICAL body shape (`Out + In(0)`). The matcher
+    only checks the body Term-AST, so it doesn't know "this is the bias"
+    vs "this is the residual" at match time. The lowering pass
+    disambiguates by operand rank after submap resolution:
+      - 1D operand → bias (per-channel)
+      - 4D operand → residual (same shape as output)
+
+    Routes to cudnnConvolutionBiasActivationForward, which natively
+    computes y = activation(α₁·conv(x,w) + α₂·z + bias).
+    """
+    init_step = CompositionStep(
+        body=Term.Lit(0.0),
+        num_ins=0, num_outs=1,
+        parallel_dim_count=4, reduction_dim_count=0,
+    )
+    conv_step = CompositionStep(
+        body=Term.Out(0) + Term.In(0) * Term.In(1),
+        num_ins=2, num_outs=1,
+        parallel_dim_count=4, reduction_dim_count=3,
+    )
+    add_step = CompositionStep(
+        body=Term.Out(0) + Term.In(0),
+        num_ins=1, num_outs=1,
+        parallel_dim_count=4, reduction_dim_count=0,
+    )
+    relu_step = CompositionStep(
+        body=Term.Select(
+            Term.Cmp("ogt", Term.Out(0), Term.Lit(0.0)),
+            Term.Out(0),
+            Term.Lit(0.0),
+        ),
+        num_ins=0, num_outs=1,
+        parallel_dim_count=4, reduction_dim_count=0,
+    )
+    return CompositionEntry(
+        name="cudnnConvBiasReluAddFwdFused",
+        steps=[init_step, conv_step, add_step, add_step, relu_step],
+    )
+
+
+def _cudnn_conv_bn_relu_fused() -> CompositionEntry:
+    """Fused conv + bn (inference) + relu — the inner three ops of a
+    ResNet residual block. 4-step composition:
+
+      step 1 (init):   Bout = 0           — 4 par, 0 ins
+      step 2 (conv):   Bout += A * F      — 4 par + 3 red, 2 ins
+      step 3 (bn):     Bout = scale*(Bout - mean)*inv_std + bias
+                                          — 4 par, 4 ins (scale, mean,
+                                            inv_std, bias). In-place form:
+                                            Bout is BOTH read (as Out(0))
+                                            AND written.
+      step 4 (relu):   Bout = max(Bout, 0)
+                                          — 4 par, 0 ins, in-place
+
+    Body shapes (from cgeist + raise on conv_bn_relu_batched.c):
+      step 3:  In(0) * (Out(0) - In(1)) * In(2) + In(3)
+      step 4:  Select(Cmp("ogt", Out(0), Lit(0.0)), Out(0), Lit(0.0))
+
+    Lowers to cudnnConvolutionBiasActivationForward (cuDNN's native
+    fused-conv-bias-relu kernel) — needs a runtime shim that folds the
+    BN parameters into a per-output-channel scaled filter + bias
+    (standard "BN-folding" trick), then issues one cuDNN call instead
+    of three.
+    """
+    init_step = CompositionStep(
+        body=Term.Lit(0.0),
+        num_ins=0, num_outs=1,
+        parallel_dim_count=4, reduction_dim_count=0,
+    )
+    conv_step = CompositionStep(
+        body=Term.Out(0) + Term.In(0) * Term.In(1),
+        num_ins=2, num_outs=1,
+        parallel_dim_count=4, reduction_dim_count=3,
+    )
+    bn_step = CompositionStep(
+        body=(Term.In(0) * (Term.Out(0) - Term.In(1))) * Term.In(2)
+             + Term.In(3),
+        num_ins=4, num_outs=1,
+        parallel_dim_count=4, reduction_dim_count=0,
+    )
+    relu_step = CompositionStep(
+        body=Term.Select(
+            Term.Cmp("ogt", Term.Out(0), Term.Lit(0.0)),
+            Term.Out(0),
+            Term.Lit(0.0),
+        ),
+        num_ins=0, num_outs=1,
+        parallel_dim_count=4, reduction_dim_count=0,
+    )
+    return CompositionEntry(
+        name="cudnnConvBnReluFwdFused",
+        steps=[init_step, conv_step, bn_step, relu_step],
+    )
+
+
+def _cudnn_add_tensor_batched() -> CompositionEntry:
+    """Batched 4D elementwise tensor add (ResNet residual shortcut):
+       out[b,c,h,w] = in[b,c,h,w] + out[b,c,h,w]
+
+    4-parallel, 0-reduction, 1 input, 1 output. No captures.
+
+    The shape gates (parallel_dim_count=4, num_ins=1, body=`Out + In(0)`)
+    distinguish this from axpy (which needs an α capture) and from any
+    accumulating contraction (which would have reduction iters). Maps
+    to cudnnAddTensor.
+    """
+    body = Term.Out(0) + Term.In(0)
+    return CompositionEntry(
+        name="cudnnAddTensor_batched",
+        steps=[
+            CompositionStep(
+                body=body,
+                num_ins=1, num_outs=1,
+                parallel_dim_count=4, reduction_dim_count=0,
+            ),
+        ],
+    )
+
+
+def _cudnn_batchnorm_inference() -> CompositionEntry:
+    """Batched per-channel batch normalization (inference mode):
+       out[b,c,h,w] = scale[c] * (in[b,c,h,w] - mean[c]) * inv_std[c]
+                      + bias[c]
+
+    Shape: 4-parallel (B, C, H, W), zero reductions. 5 inputs (scale, A,
+    mean, inv_std, bias all broadcast through `polygeist.submap` from
+    their 4D / 1D shapes into the 4D iteration domain), 1 output.
+
+    Maps to cudnnBatchNormalizationForwardInference. The runtime shim
+    takes the 4D input/output + four 1D per-channel vectors and lets
+    cuDNN do the fused normalize+scale+bias in one launch.
+
+    The body order assumes the raise pass orders the ins as
+    (scale, A, mean, inv_std, bias) — observed on the batchnorm_batched
+    test file. If a future input reorders these (different argument
+    order in the C source), the unifier sees a different shape and the
+    match fails — at that point the template needs alternate input
+    orderings or a more permissive structural match.
+    """
+    # ((scale * (A - mean)) * inv_std) + bias
+    body = (
+        Term.In(0) * (Term.In(1) - Term.In(2))
+    ) * Term.In(3) + Term.In(4)
+    return CompositionEntry(
+        name="cudnnBatchNormalizationForwardInference",
+        steps=[
+            CompositionStep(
+                body=body,
+                num_ins=5, num_outs=1,
+                parallel_dim_count=4, reduction_dim_count=0,
+            ),
+        ],
+    )
+
+
+def _cudnn_maxpool_batched() -> CompositionEntry:
+    """Batched multi-channel 2D max pooling. Two steps:
+      step1 (init): outs[b,c,oh,ow] = -INF  — 4 parallel, 0 ins.
+      step2 (reduce): outs[b,c,oh,ow] = max(In(0), Out(0))
+                       — 4 parallel + 2 reduction over (kh, kw).
+
+    Body of step2 lowers from cgeist's `(v > cur) ? v : cur` ternary
+    via arith.cmpf + arith.select. The matcher's algebraic encoder
+    sees the select as a max op and produces a clean max-reduction
+    body shape.
+    """
+    return CompositionEntry(
+        name="cudnnMaxPoolFwd_batched",
+        steps=[
+            CompositionStep(
+                # -FLT_MAX (≈ -3.4028235e38). cgeist canonicalises whatever
+                # the C source writes (-INFINITY, -FLT_MAX, -3.4e38, etc.)
+                # to the IEEE-754 float32 minimum which MLIR prints as
+                # -3.40282347E+38. Matching the exact parsed value here.
+                body=Term.Lit(-3.40282347e38),
+                num_ins=0, num_outs=1,
+                parallel_dim_count=4, reduction_dim_count=0,
+            ),
+            # max(In(0), Out(0)) — cgeist lowers the ternary
+            # `(v > cur) ? v : cur` to `arith.cmpf ogt + arith.select`. The
+            # encoder turns that into `Select(Cmp("ogt", In, Out), In, Out)`,
+            # which is the same shape the softmax max-reduce step uses.
+            CompositionStep(
+                body=Term.Select(
+                    Term.Cmp("ogt", Term.In(0), Term.Out(0)),
+                    Term.In(0),
+                    Term.Out(0),
+                ),
+                num_ins=1, num_outs=1,
+                parallel_dim_count=4, reduction_dim_count=2,
+            ),
+        ],
+    )
+
+
+def _cudnn_conv2d_batched() -> CompositionEntry:
+    """Batched multi-channel 2D convolution: out[b,oc,oh,ow] =
+       Σ_{ic,kh,kw} in[b,ic,oh+kh,ow+kw] * filter[oc,ic,kh,kw].
+
+    Two-step composition:
+      step1 (init): outs[b,oc,oh,ow] = 0 — 4 parallel iters, 0 inputs.
+      step2 (accumulate): same outs with 2 inputs (input + filter),
+                          4 parallel + 3 reduction (over ic, kh, kw).
+
+    The input tensor reaches the accumulation linalg.generic via a
+    polygeist.submap that produces a 7D strided-window view of the
+    original 4D input — that's the implicit im2col. The downstream
+    lowering doesn't need to inspect the submap; it just maps to a
+    cudnnConvolutionForward call with the standard 4D NCHW descriptors,
+    and the runtime shim runs the actual convolution. The matcher only
+    checks body shape + iter-type counts here.
+    """
+    return CompositionEntry(
+        name="cudnnConvolutionFwd_batched",
+        steps=[
+            CompositionStep(
+                body=Term.Lit(0.0),  # init body: yield 0
+                num_ins=0, num_outs=1,
+                parallel_dim_count=4, reduction_dim_count=0,
+            ),
+            CompositionStep(
+                body=Term.Out(0) + Term.In(0) * Term.In(1),
+                num_ins=2, num_outs=1,
+                parallel_dim_count=4, reduction_dim_count=3,
+            ),
+        ],
+    )
+
+
+def _darknet_im2col_gemm_fused() -> CompositionEntry:
+    """Darknet-style explicit im2col followed by GEMM.
+
+    Raised memref IR shape:
+      step0: output[:] = 0                         -- 1D flat zero-fill
+      step1: workspace[k, oh, ow] = guarded load   -- im2col with zero pad
+      step2: output[oc, oh*ow] += weights[oc,k] *
+                                    workspace[k,oh*ow]
+
+    The im2col body contains an scf.if and a memref.load, so the scalar Term
+    encoder sees it as opaque. Match it with a structural predicate, then
+    lower the whole 3-step composition as one cuDNN convolution.
+    """
+    init_step = CompositionStep(
+        body=Term.Lit(0.0),
+        num_ins=0, num_outs=1,
+        parallel_dim_count=1, reduction_dim_count=0,
+    )
+    im2col_step = CompositionStep(
+        body=T_cap("%guarded_im2col"),
+        num_ins=0, num_outs=1,
+        parallel_dim_count=3, reduction_dim_count=0,
+        special="guarded_im2col",
+    )
+    gemm_step = CompositionStep(
+        body=Term.Out(0) + Term.In(0) * Term.In(1),
+        num_ins=2, num_outs=1,
+        parallel_dim_count=2, reduction_dim_count=1,
+    )
+    return CompositionEntry(
+        name="cudnnConvolutionFwd_im2col_gemm",
+        steps=[init_step, im2col_step, gemm_step],
+        form="memref",
+    )
+
+
+def _gemm_no_alpha() -> CompositionEntry:
+    """C += A*B  (no alpha, no beta)."""
+    body = Term.Out(0) + Term.In(0) * Term.In(1)
+    return CompositionEntry(
+        name="cublasDgemm_simple",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=1)],
+    )
+
+
+def _sgemm_broadcast3d_memref() -> CompositionEntry:
+    """Darknet im2col GEMM in memref form after scalar-load promotion.
+
+    The linalg view is rank-3 because A and C are broadcasted through submaps,
+    but the underlying buffers are flat row-major A[M,K], B[K,N], C[M,N].
+    """
+    body = Term.Out(0) + Term.In(0) * Term.In(1)
+    return CompositionEntry(
+        name="cublasSgemm_broadcast3d_memref",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=1)],
+        form="memref",
+    )
+
+
+def _gemv_accumulate() -> CompositionEntry:
+    """y += A * x  (no alpha/beta)."""
+    body = Term.Out(0) + Term.In(0) * Term.In(1)
+    return CompositionEntry(
+        name="cublasDgemv",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=1)],
+    )
+
+
+def _gemv_alpha_accumulate() -> CompositionEntry:
+    """y += alpha * A * x"""
+    body = Term.Out(0) + (T_cap("%alpha") * Term.In(0)) * Term.In(1)
+    return CompositionEntry(
+        name="cublasDgemv_alpha",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=1)],
+    )
+
+
+def _axpy() -> CompositionEntry:
+    """y[i] += alpha * x[i]"""
+    body = Term.Out(0) + T_cap("%alpha") * Term.In(0)
+    return CompositionEntry(
+        name="cublasDaxpy",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _scal_1d() -> CompositionEntry:
+    """x[i] *= alpha  — 1D vector."""
+    body = Term.Out(0) * T_cap("%alpha")
+    return CompositionEntry(
+        name="cublasDscal",
+        steps=[CompositionStep(body=body, num_ins=0, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+    )
+
+
+def _scal_2d() -> CompositionEntry:
+    """X[i,j] *= alpha  — 2D matrix (e.g. β-scale of C)."""
+    body = Term.Out(0) * T_cap("%alpha")
+    return CompositionEntry(
+        name="cublasDgeam_scale2D",
+        steps=[CompositionStep(body=body, num_ins=0, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+    )
+
+
+def _fill_zero_1d() -> CompositionEntry:
+    body = Term.Lit(0.0)
+    return CompositionEntry(
+        name="memset_zero_1D",
+        steps=[CompositionStep(body=body, num_ins=0, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+    )
+
+
+def _fill_zero_2d() -> CompositionEntry:
+    body = Term.Lit(0.0)
+    return CompositionEntry(
+        name="memset_zero_2D",
+        steps=[CompositionStep(body=body, num_ins=0, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+    )
+
+
+def _fill_const_1d() -> CompositionEntry:
+    """x[i] = constant capture (1-d fill)."""
+    body = T_cap("%const")
+    return CompositionEntry(
+        name="memset_const_1D",
+        steps=[CompositionStep(body=body, num_ins=0, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+    )
+
+
+def _fill_const_2d() -> CompositionEntry:
+    body = T_cap("%const")
+    return CompositionEntry(
+        name="memset_const_2D",
+        steps=[CompositionStep(body=body, num_ins=0, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+    )
+
+
+def _dot() -> CompositionEntry:
+    """s = sum_i x[i] * y[i]"""
+    body = Term.Out(0) + Term.In(0) * Term.In(1)
+    return CompositionEntry(
+        name="cublasDdot",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=0, reduction_dim_count=1)],
+        element_type="f64",
+    )
+
+
+def _dot_f32() -> CompositionEntry:
+    """s = sum_i x[i] * y[i], single precision."""
+    body = Term.Out(0) + Term.In(0) * Term.In(1)
+    return CompositionEntry(
+        name="cublasSdot",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                               parallel_dim_count=0, reduction_dim_count=1)],
+        element_type="f32",
+    )
+
+
+def _asum() -> CompositionEntry:
+    """s = sum_i |x[i]|"""
+    body = Term.Out(0) + Term.Abs(Term.In(0))
+    return CompositionEntry(
+        name="cublasDasum",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=0, reduction_dim_count=1)],
+    )
+
+
+def _divf_scalar() -> CompositionEntry:
+    """out /= alpha  (e.g. mean computation)."""
+    body = Term.Out(0) / T_cap("%alpha")
+    return CompositionEntry(
+        name="elemwise_div_scalar",
+        steps=[CompositionStep(body=body, num_ins=0, num_outs=1)],
+    )
+
+
+def _subf_inputs() -> CompositionEntry:
+    """out = in0 - in1  (e.g. centering)."""
+    body = Term.In(0) - Term.In(1)
+    return CompositionEntry(
+        name="elemwise_sub_inputs",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1)],
+    )
+
+
+def _scale_input_1d() -> CompositionEntry:
+    """out[i] = alpha * in[i]  — out-of-place vector scale.
+
+    This is not the in-place cuBLAS DSCAL shape (`out *= alpha`), so keep it
+    as an explicit elementwise-kernel template rather than overloading
+    `cublasDscal`.
+    """
+    body = T_cap("%alpha") * Term.In(0)
+    return CompositionEntry(
+        name="elemwise_scale_input_1D",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+    )
+
+
+def _axpby_inputs_1d() -> CompositionEntry:
+    """out[i] = alpha * x[i] + beta * y[i].
+
+    Distinct from `_axpby`, whose second source is the output buffer itself
+    (`alpha*x + beta*out`).
+    """
+    body = T_cap("%alpha") * Term.In(0) + T_cap("%beta") * Term.In(1)
+    return CompositionEntry(
+        name="elemwise_axpby_inputs_1D",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+    )
+
+
+def _mul_inputs_scaled_1d() -> CompositionEntry:
+    """out[i] = alpha * x[i] * y[i]."""
+    body = (T_cap("%alpha") * Term.In(0)) * Term.In(1)
+    return CompositionEntry(
+        name="elemwise_mul_inputs_scaled_1D",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+    )
+
+
+def _mul_inputs_pointwise() -> CompositionEntry:
+    """out = in0 * in1 for pointwise tensor kernels."""
+    body = Term.In(0) * Term.In(1)
+    return CompositionEntry(
+        name="elemwise_mul_inputs",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _add_scalar_1d() -> CompositionEntry:
+    """out[i] = in[i] + alpha."""
+    body = Term.In(0) + T_cap("%alpha")
+    return CompositionEntry(
+        name="elemwise_add_scalar_1D",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+    )
+
+
+def _div_scalar_by_input_1d() -> CompositionEntry:
+    """out[i] = alpha / in[i]."""
+    body = T_cap("%alpha") / Term.In(0)
+    return CompositionEntry(
+        name="elemwise_div_scalar_by_input_1D",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+    )
+
+
+def _avg2_pointwise() -> CompositionEntry:
+    """out = 0.5 * (in0 + in1)."""
+    body = (Term.In(0) + Term.In(1)) * Term.Lit(0.5)
+    return CompositionEntry(
+        name="elemwise_avg2",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _half_diff_pointwise() -> CompositionEntry:
+    """out = 0.5 * (in0 - in1)."""
+    body = (Term.In(0) - Term.In(1)) * Term.Lit(0.5)
+    return CompositionEntry(
+        name="elemwise_half_diff",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _linear_reaction_pointwise() -> CompositionEntry:
+    """out = in0 - alpha * in1."""
+    body = Term.In(0) - (T_cap("%alpha") * Term.In(1))
+    return CompositionEntry(
+        name="elemwise_linear_reaction",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _hypar_reaction_update() -> CompositionEntry:
+    """Fused HyPar reaction plus conservative update.
+
+    yield0: reaction = source - lambda * u
+    yield1: next = u - dt * (flux_r - flux_l) + dt * reaction
+    """
+    reaction = Term.In(0) - (T_cap("%lambda") * Term.In(1))
+    update = (Term.In(2) - (T_cap("%dt") * (Term.In(3) - Term.In(4)))) + (
+        T_cap("%dt") * reaction
+    )
+    return CompositionEntry(
+        name="hypar_reaction_update",
+        steps=[CompositionStep(
+            body=reaction,
+            body_per_yield=[reaction, update],
+            num_ins=5,
+            num_outs=2,
+            parallel_dim_count=2,
+            reduction_dim_count=0,
+        )],
+    )
+
+
+def _llf_flux_2d() -> CompositionEntry:
+    """Local Lax-Friedrichs/Rusanov two-state flux:
+       out = 0.5 * (left_flux + right_flux - alpha * (right - left)).
+    """
+    body = ((Term.In(0) + Term.In(1)) -
+            (T_cap("%alpha") * (Term.In(2) - Term.In(3)))) * Term.Lit(0.5)
+    return CompositionEntry(
+        name="hypar_llf_flux_2D",
+        steps=[CompositionStep(body=body, num_ins=4, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+    )
+
+
+def _burgers_advection_1d() -> CompositionEntry:
+    """Burgers flux/advection primitive: out = 0.5 * x * x."""
+    body = (Term.In(0) * Term.Lit(0.5)) * Term.In(0)
+    return CompositionEntry(
+        name="burgers_advection_1D",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+    )
+
+
+def _upwind_select_const() -> CompositionEntry:
+    """First-order upwind choice: out = x0 > 0 ? left : right."""
+    body = Term.Select(
+        Term.Cmp("ogt", Term.In(0), Term.Lit(0.0)),
+        Term.In(1),
+        Term.In(2),
+    )
+    return CompositionEntry(
+        name="hypar_upwind_select_const",
+        steps=[CompositionStep(body=body, num_ins=3, num_outs=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _predicate_select_inputs() -> CompositionEntry:
+    """Predicate-controlled input select."""
+    body = Term.Select(T_cap("%pred"), Term.In(0), Term.In(1))
+    return CompositionEntry(
+        name="elemwise_select_inputs",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _minmod_limiter() -> CompositionEntry:
+    """Two-input minmod limiter lowered through select/abs."""
+    a = Term.In(0)
+    b = Term.In(1)
+    abs_a = Term.Select(Term.Cmp("olt", a, Term.Lit(0.0)),
+                        Term.Lit(0.0) - a, a)
+    abs_b = Term.Select(Term.Cmp("olt", b, Term.Lit(0.0)),
+                        Term.Lit(0.0) - b, b)
+    body = Term.Select(
+        Term.Cmp("ole", a * b, Term.Lit(0.0)),
+        Term.Lit(0.0),
+        Term.Select(Term.Cmp("olt", abs_a, abs_b), a, b),
+    )
+    return CompositionEntry(
+        name="hypar_minmod_limiter",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+    )
+
+
+def _vanleer_limiter() -> CompositionEntry:
+    """Two-input van Leer limiter."""
+    a = Term.In(0)
+    b = Term.In(1)
+    body = Term.Select(
+        Term.Cmp("ole", a * b, Term.Lit(0.0)),
+        Term.Lit(0.0),
+        ((a * Term.Lit(2.0)) * b) / (a + b),
+    )
+    return CompositionEntry(
+        name="hypar_vanleer_limiter",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+    )
+
+
+def _fourth_order_interp() -> CompositionEntry:
+    """Fourth-order central interpolation."""
+    body = ((((Term.Lit(0.0) - Term.In(0)) + (Term.In(1) * Term.Lit(7.0))) +
+             (Term.In(2) * Term.Lit(7.0))) - Term.In(3)) / Term.Lit(12.0)
+    return CompositionEntry(
+        name="interp_fourth_order_central",
+        steps=[CompositionStep(body=body, num_ins=4, num_outs=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _fourth_order_derivative() -> CompositionEntry:
+    """Fourth-order first derivative stencil."""
+    body = (((Term.In(0) - (Term.In(1) * Term.Lit(8.0))) +
+             (Term.In(2) * Term.Lit(8.0))) - Term.In(3)) / Term.Lit(12.0)
+    return CompositionEntry(
+        name="derivative_fourth_order",
+        steps=[CompositionStep(body=body, num_ins=4, num_outs=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _fv4_flux() -> CompositionEntry:
+    """Fourth-order finite-volume flux stencil."""
+    body = ((((Term.Lit(0.0) - Term.In(0)) + (Term.In(1) * Term.Lit(7.0))) -
+             (Term.In(2) * Term.Lit(7.0))) + Term.In(3)) / Term.Lit(12.0)
+    return CompositionEntry(
+        name="fv4_flux",
+        steps=[CompositionStep(body=body, num_ins=4, num_outs=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _cg_update_3out() -> CompositionEntry:
+    """CG update with three vector outputs."""
+    r_new = Term.Out(1) - (T_cap("%alpha") * Term.In(0))
+    body_per_yield = [
+        Term.Out(0) + (T_cap("%alpha") * Term.Out(2)),
+        r_new,
+        r_new + (T_cap("%beta") * Term.Out(2)),
+    ]
+    return CompositionEntry(
+        name="cg_update_3out",
+        steps=[CompositionStep(body=body_per_yield[0],
+                                body_per_yield=body_per_yield,
+                                num_ins=1, num_outs=3,
+                                parallel_dim_count=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _bicgstab_update_2out() -> CompositionEntry:
+    """BiCGSTAB two-output update."""
+    r_mid = Term.Out(1) - (T_cap("%alpha") * Term.In(0))
+    body_per_yield = [
+        Term.Out(0) + ((T_cap("%alpha") * Term.In(1)) +
+                       (T_cap("%omega") * r_mid)),
+        r_mid - (T_cap("%omega") * Term.In(2)),
+    ]
+    return CompositionEntry(
+        name="bicgstab_update_2out",
+        steps=[CompositionStep(body=body_per_yield[0],
+                                body_per_yield=body_per_yield,
+                                num_ins=3, num_outs=2,
+                                parallel_dim_count=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _random_vector_3d() -> CompositionEntry:
+    """HPGMG random-vector affine remap from [0, 1] to [-1, 1]."""
+    body = (T_cap("%rand") * Term.Lit(2.0)) + Term.Lit(-1.0)
+    return CompositionEntry(
+        name="hpgmg_random_vector_3D",
+        steps=[CompositionStep(body=body, num_ins=0, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+    )
+
+
+def _color_vector_3d() -> CompositionEntry:
+    """HPGMG color mask from three parity predicates."""
+    sx = Term.Select(T_cap("%px"), Term.Lit(1.0), Term.Lit(0.0))
+    sy = Term.Select(T_cap("%py"), Term.Lit(1.0), Term.Lit(0.0))
+    sz = Term.Select(T_cap("%pz"), Term.Lit(1.0), Term.Lit(0.0))
+    body = (sx * sy) * sz
+    return CompositionEntry(
+        name="hpgmg_color_vector_3D",
+        steps=[CompositionStep(body=body, num_ins=0, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+    )
+
+
+def _exasp2_neg_div() -> CompositionEntry:
+    """out = -in / scale."""
+    body = (Term.Lit(0.0) - Term.In(0)) / T_cap("%scale")
+    return CompositionEntry(
+        name="exasp2_neg_div",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+    )
+
+
+def _add_out_scalar_1d() -> CompositionEntry:
+    """out += scalar."""
+    body = Term.Out(0) + T_cap("%scalar")
+    return CompositionEntry(
+        name="elemwise_add_out_scalar_1D",
+        steps=[CompositionStep(body=body, num_ins=0, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+    )
+
+
+def _exasp2_normalize_dense() -> CompositionEntry:
+    """Conditional ExaSP2 dense normalization."""
+    base = (Term.Lit(0.0) - Term.In(0)) / T_cap("%scale")
+    body = Term.Select(T_cap("%pred"), base + T_cap("%shift"), base)
+    return CompositionEntry(
+        name="exasp2_normalize_dense",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+    )
+
+
+def _exasp2_update_2x_minus_x2() -> CompositionEntry:
+    """out = 2*out - in."""
+    body = (Term.Out(0) * Term.Lit(2.0)) - Term.In(0)
+    return CompositionEntry(
+        name="exasp2_update_2x_minus_x2",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+    )
+
+
+def _exasp2_select_square() -> CompositionEntry:
+    """Conditional ExaSP2 square/select update."""
+    body = Term.Select(
+        T_cap("%pred"),
+        Term.In(0),
+        (Term.Out(0) * Term.Lit(2.0)) - Term.In(1),
+    )
+    return CompositionEntry(
+        name="exasp2_select_square",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+    )
+
+
+def _select_mul_or_zero() -> CompositionEntry:
+    """out = pred ? in0 * in1 : 0."""
+    body = Term.Select(T_cap("%pred"), Term.In(0) * Term.In(1), Term.Lit(0.0))
+    return CompositionEntry(
+        name="elemwise_select_mul_or_zero",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _burgers_upwind() -> CompositionEntry:
+    """Burgers upwind/Rusanov flux."""
+    a = Term.In(0)
+    b = Term.In(1)
+    abs_a = Term.Select(Term.Cmp("olt", a, Term.Lit(0.0)),
+                        Term.Lit(0.0) - a, a)
+    abs_b = Term.Select(Term.Cmp("olt", b, Term.Lit(0.0)),
+                        Term.Lit(0.0) - b, b)
+    wavespeed = Term.Select(Term.Cmp("ogt", abs_a, abs_b), abs_a, abs_b)
+    body = ((Term.In(2) + Term.In(3)) - (wavespeed * (b - a))) * Term.Lit(0.5)
+    return CompositionEntry(
+        name="burgers_upwind_flux",
+        steps=[CompositionStep(body=body, num_ins=4, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+    )
+
+
+def _superbee_limiter() -> CompositionEntry:
+    """Two-input Superbee limiter."""
+    a = Term.In(0)
+    b = Term.In(1)
+    abs_a = Term.Select(Term.Cmp("olt", a, Term.Lit(0.0)),
+                        Term.Lit(0.0) - a, a)
+    abs_b = Term.Select(Term.Cmp("olt", b, Term.Lit(0.0)),
+                        Term.Lit(0.0) - b, b)
+    m1 = Term.Select(Term.Cmp("olt", abs_a * Term.Lit(2.0), abs_b),
+                     abs_a * Term.Lit(2.0), abs_b)
+    m2 = Term.Select(Term.Cmp("olt", abs_a, abs_b * Term.Lit(2.0)),
+                     abs_a, abs_b * Term.Lit(2.0))
+    mag = Term.Select(Term.Cmp("ogt", m1, m2), m1, m2)
+    body = Term.Select(
+        Term.Cmp("ole", a * b, Term.Lit(0.0)),
+        Term.Lit(0.0),
+        Term.Select(Term.Cmp("olt", a, Term.Lit(0.0)),
+                    Term.Lit(0.0) - mag, mag),
+    )
+    return CompositionEntry(
+        name="hypar_superbee_limiter",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+    )
+
+
+def _muscl_interp_minmod() -> CompositionEntry:
+    """Second-order MUSCL interpolation using the minmod limiter."""
+    left = Term.In(0) - Term.In(1)
+    right = Term.In(2) - Term.In(0)
+    abs_left = Term.Select(Term.Cmp("olt", left, Term.Lit(0.0)),
+                           Term.Lit(0.0) - left, left)
+    abs_right = Term.Select(Term.Cmp("olt", right, Term.Lit(0.0)),
+                            Term.Lit(0.0) - right, right)
+    limited = Term.Select(
+        Term.Cmp("ole", left * right, Term.Lit(0.0)),
+        Term.Lit(0.0),
+        Term.Select(Term.Cmp("olt", abs_left, abs_right), left, right),
+    )
+    body = Term.In(0) - (limited * Term.Lit(0.5))
+    return CompositionEntry(
+        name="hypar_muscl_minmod_interp",
+        steps=[CompositionStep(body=body, num_ins=3, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+    )
+
+
+def _miniamr_pointwise_update_tensor() -> CompositionEntry:
+    """miniAMR pointwise nonlinear update."""
+    body = Term.Out(0) + (
+        Term.Out(0) * ((Term.In(0) + Term.In(1)) -
+                       (T_cap("%alpha") * Term.Out(0)))
+    )
+    return CompositionEntry(
+        name="miniamr_pointwise_update_tensor",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _hpgmg_gsrb_smooth_7pt_tensor() -> CompositionEntry:
+    """HPGMG red/black smoother guarded by a color predicate."""
+    c = Term.Out(0)
+    lap = ((((((c * Term.Lit(6.0)) - Term.In(0)) - Term.In(1)) -
+             Term.In(2)) - Term.In(3)) - Term.In(4)) - Term.In(5)
+    apply = (T_cap("%alpha") * c) + (T_cap("%beta") * lap)
+    update = c + (Term.In(6) * (Term.In(7) - apply))
+    body = Term.Select(T_cap("%color"), update, c)
+    return CompositionEntry(
+        name="hpgmg_gsrb_smooth_7pt_tensor",
+        steps=[CompositionStep(body=body, num_ins=8, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _miniamr_weighted_27pt_tensor() -> CompositionEntry:
+    """miniAMR 27-point weighted stencil as the raised four-step composition."""
+    zero = CompositionStep(
+        body=Term.Lit(0.0),
+        num_ins=0, num_outs=1,
+        parallel_dim_count=3, reduction_dim_count=0,
+    )
+    ident_r1 = CompositionStep(
+        body=Term.Out(0),
+        num_ins=0, num_outs=1,
+        parallel_dim_count=3, reduction_dim_count=1,
+    )
+    ident_r2 = CompositionStep(
+        body=Term.Out(0),
+        num_ins=0, num_outs=1,
+        parallel_dim_count=3, reduction_dim_count=2,
+    )
+    accum = CompositionStep(
+        body=Term.Out(0) + (Term.In(0) * Term.In(1)),
+        num_ins=2, num_outs=1,
+        parallel_dim_count=3, reduction_dim_count=3,
+    )
+    return CompositionEntry(
+        name="miniamr_weighted_27pt_tensor",
+        steps=[zero, ident_r1, ident_r2, accum],
+        form="tensor",
+    )
+
+
+def _hpgmg_apply_op_27pt_tensor() -> CompositionEntry:
+    """HPGMG 27-point operator as scale + reduction composition."""
+    scale = CompositionStep(
+        body=T_cap("%alpha") * Term.In(0),
+        num_ins=1, num_outs=1,
+        parallel_dim_count=3, reduction_dim_count=0,
+    )
+    ident_r1 = CompositionStep(
+        body=Term.Out(0),
+        num_ins=0, num_outs=1,
+        parallel_dim_count=3, reduction_dim_count=1,
+    )
+    ident_r2 = CompositionStep(
+        body=Term.Out(0),
+        num_ins=0, num_outs=1,
+        parallel_dim_count=3, reduction_dim_count=2,
+    )
+    accum = CompositionStep(
+        body=Term.Out(0) + (Term.In(0) * Term.In(1)),
+        num_ins=2, num_outs=1,
+        parallel_dim_count=3, reduction_dim_count=3,
+    )
+    return CompositionEntry(
+        name="hpgmg_apply_op_27pt_tensor",
+        steps=[scale, ident_r1, ident_r2, accum],
+        form="tensor",
+    )
+
+
+def _cufft_z2z_1d_tensor() -> CompositionEntry:
+    """Direct 1D complex DFT over interleaved real/imag tensors.
+
+    The second step uses a structural special predicate because the scalar Term
+    language intentionally does not model trigonometric identities. The
+    rewriter recovers forward/inverse from the sign of the captured 2*pi
+    constant and emits a cuFFT launch over the full tensor.
+    """
+    zero = CompositionStep(
+        body=Term.Lit(0.0),
+        num_ins=0,
+        num_outs=1,
+        parallel_dim_count=2,
+        reduction_dim_count=0,
+    )
+    dft = CompositionStep(
+        body=Term.Out(0),
+        num_ins=2,
+        num_outs=1,
+        parallel_dim_count=2,
+        reduction_dim_count=1,
+        special="dft1d_z2z",
+    )
+    return CompositionEntry(
+        name="cufftZ2Z_1D_tensor",
+        steps=[zero, dft],
+        form="tensor",
+    )
+
+
+def _cutensornet_tensor_product_3d_f32_tensor() -> CompositionEntry:
+    """Separable 3D tensor product: ai,bj,ck,ijk->abc.
+
+    Requiring the explicit zero-fill step makes it safe for the cuTensorNet
+    runtime to overwrite the output even though the contraction generic is
+    represented as an accumulation into its output argument.
+    """
+    zero = CompositionStep(
+        body=Term.Lit(0.0),
+        num_ins=0,
+        num_outs=1,
+        parallel_dim_count=3,
+        reduction_dim_count=0,
+    )
+    contraction = CompositionStep(
+        body=(Term.Out(0) +
+              (((Term.In(0) * Term.In(1)) * Term.In(2)) * Term.In(3))),
+        num_ins=4,
+        num_outs=1,
+        parallel_dim_count=3,
+        reduction_dim_count=3,
+    )
+    return CompositionEntry(
+        name="cutensornetTensorProduct3D_f32_tensor",
+        steps=[zero, contraction],
+        form="tensor",
+    )
+
+
+def _hpgmg_interpolation_p1_tensor() -> CompositionEntry:
+    """HPGMG interpolation p1 weighted scalar-load stencil."""
+    body = T_cap("%scale") * Term.Out(0)
+    weights = [
+        0.421875,
+        0.140625, 0.140625, 0.140625,
+        0.046875, 0.046875, 0.046875,
+        0.015625,
+    ]
+    for idx, weight in enumerate(weights):
+        body = body + (T_cap(f"%v{idx}") * Term.Lit(weight))
+    return CompositionEntry(
+        name="hpgmg_interpolation_p1",
+        steps=[CompositionStep(body=body, num_ins=0, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+        form="any",
+    )
+
+
+def _hpgmg_interpolation_p2_tensor() -> CompositionEntry:
+    """HPGMG interpolation p2 weighted scalar-load stencil."""
+    neigh_sum = T_cap("%v0")
+    for idx in range(1, 6):
+        neigh_sum = neigh_sum + T_cap(f"%v{idx}")
+    body = (T_cap("%center") * Term.Lit(0.5)) + \
+           (neigh_sum * Term.Lit(0.08333333333333333))
+    return CompositionEntry(
+        name="hpgmg_interpolation_p2",
+        steps=[CompositionStep(body=body, num_ins=0, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+        form="any",
+    )
+
+
+def _generalized_minmod_limiter() -> CompositionEntry:
+    """HyPar generalized minmod limiter."""
+    a = Term.In(0)
+    b = Term.In(1)
+    theta = T_cap("%theta")
+    mid = (a + b) * Term.Lit(0.5)
+    ta = theta * a
+    tb = theta * b
+    abs_ta = Term.Select(Term.Cmp("olt", ta, Term.Lit(0.0)),
+                         Term.Lit(0.0) - ta, ta)
+    abs_mid = Term.Select(Term.Cmp("olt", mid, Term.Lit(0.0)),
+                          Term.Lit(0.0) - mid, mid)
+    abs_tb = Term.Select(Term.Cmp("olt", tb, Term.Lit(0.0)),
+                         Term.Lit(0.0) - tb, tb)
+    min_mid_tb = Term.Select(Term.Cmp("olt", abs_mid, abs_tb), abs_mid, abs_tb)
+    mag = Term.Select(Term.Cmp("olt", abs_ta, min_mid_tb), abs_ta, min_mid_tb)
+    same_sign = Term.Select(
+        Term.Cmp("ogt", ta * mid, Term.Lit(0.0)),
+        Term.Select(Term.Cmp("ogt", mid * tb, Term.Lit(0.0)),
+                    Term.Lit(1.0), Term.Lit(0.0)),
+        Term.Lit(0.0),
+    )
+    signed_mag = Term.Select(Term.Cmp("olt", ta, Term.Lit(0.0)),
+                             Term.Lit(0.0) - mag, mag)
+    body = Term.Select(
+        Term.Cmp("oeq", same_sign, Term.Lit(0.0)),
+        Term.Lit(0.0),
+        signed_mag,
+    )
+    return CompositionEntry(
+        name="hypar_generalized_minmod_limiter",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+    )
+
+
+def _upwind_var_flux() -> CompositionEntry:
+    """HyPar variable-coefficient upwind/Rusanov flux selector."""
+    a0 = Term.In(0)
+    a1 = Term.In(5)
+    abs_a0 = Term.Select(Term.Cmp("olt", a0, Term.Lit(0.0)),
+                         Term.Lit(0.0) - a0, a0)
+    abs_a1 = Term.Select(Term.Cmp("olt", a1, Term.Lit(0.0)),
+                         Term.Lit(0.0) - a1, a1)
+    wavespeed = Term.Select(Term.Cmp("ogt", abs_a0, abs_a1), abs_a0, abs_a1)
+    fallback = ((Term.In(6) + Term.In(7)) -
+                (wavespeed * (Term.In(8) - Term.In(9)))) * Term.Lit(0.5)
+    positive = Term.Select(
+        Term.Cmp("ogt", a0, Term.Lit(0.0)),
+        Term.Cmp("ogt", Term.In(1), Term.Lit(0.0)),
+        T_cap("%false"),
+    )
+    negative = Term.Select(
+        Term.Cmp("olt", a0, Term.Lit(0.0)),
+        Term.Cmp("olt", Term.In(3), Term.Lit(0.0)),
+        T_cap("%false"),
+    )
+    body = Term.Select(
+        positive,
+        Term.In(2),
+        Term.Select(negative, Term.In(4), fallback),
+    )
+    return CompositionEntry(
+        name="hypar_upwind_var_flux",
+        steps=[CompositionStep(body=body, num_ins=10, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+    )
+
+
+def _weno_interp5() -> CompositionEntry:
+    """HyPar fifth-order WENO interpolation from three nonlinear weights."""
+    p0 = (((Term.In(0) * Term.Lit(2.0)) -
+           (Term.In(1) * Term.Lit(7.0))) +
+          (Term.In(2) * Term.Lit(11.0))) / Term.Lit(6.0)
+    p1 = (((Term.Lit(0.0) - Term.In(1)) +
+           (Term.In(2) * Term.Lit(5.0))) +
+          (Term.In(3) * Term.Lit(2.0))) / Term.Lit(6.0)
+    p2 = (((Term.In(2) * Term.Lit(2.0)) +
+           (Term.In(3) * Term.Lit(5.0))) -
+          Term.In(4)) / Term.Lit(6.0)
+    body = (Term.In(5) * p0) + (Term.In(6) * p1) + (Term.In(7) * p2)
+    return CompositionEntry(
+        name="hypar_weno_interp5",
+        steps=[CompositionStep(body=body, num_ins=8, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+    )
+
+
+def _weno_weights_js() -> CompositionEntry:
+    """Jiang-Shu WENO weights for three stencils."""
+    eps = T_cap("%eps")
+    s0 = (Term.In(0) - (Term.In(1) * Term.Lit(2.0))) + Term.In(2)
+    t0 = (Term.In(0) - (Term.In(1) * Term.Lit(4.0))) + \
+         (Term.In(2) * Term.Lit(3.0))
+    b0 = (((s0 * Term.Lit(1.0833333333333333)) * s0) +
+          ((t0 * Term.Lit(0.25)) * t0)) + eps
+
+    s1 = (Term.In(1) - (Term.In(2) * Term.Lit(2.0))) + Term.In(3)
+    t1 = Term.In(1) - Term.In(3)
+    b1 = (((s1 * Term.Lit(1.0833333333333333)) * s1) +
+          ((t1 * Term.Lit(0.25)) * t1)) + eps
+
+    s2 = (Term.In(2) - (Term.In(3) * Term.Lit(2.0))) + Term.In(4)
+    t2 = ((Term.In(2) * Term.Lit(3.0)) -
+          (Term.In(3) * Term.Lit(4.0))) + Term.In(4)
+    b2 = (((s2 * Term.Lit(1.0833333333333333)) * s2) +
+          ((t2 * Term.Lit(0.25)) * t2)) + eps
+
+    a0 = Term.Lit(0.1) / (b0 * b0)
+    a1 = Term.Lit(0.6) / (b1 * b1)
+    a2 = Term.Lit(0.3) / (b2 * b2)
+    denom = (a0 + a1) + a2
+    body_per_yield = [a0 / denom, a1 / denom, a2 / denom]
+    return CompositionEntry(
+        name="hypar_weno_weights_js",
+        steps=[CompositionStep(body=body_per_yield[0],
+                                body_per_yield=body_per_yield,
+                                num_ins=5, num_outs=3,
+                                parallel_dim_count=2,
+                                reduction_dim_count=0)],
+    )
+
+
+def _euler1d_flux() -> CompositionEntry:
+    """HyPar Euler 1D physical flux."""
+    rho = Term.In(0)
+    mom = Term.In(1)
+    energy = Term.In(2)
+    vel = mom / rho
+    kinetic = ((rho * Term.Lit(0.5)) * vel) * vel
+    pressure = T_cap("%gamma_minus_one") * (energy - kinetic)
+    body_per_yield = [
+        mom,
+        (mom * vel) + pressure,
+        (energy + pressure) * vel,
+    ]
+    return CompositionEntry(
+        name="hypar_euler1d_flux",
+        steps=[CompositionStep(body=body_per_yield[0],
+                                body_per_yield=body_per_yield,
+                                num_ins=3, num_outs=3,
+                                parallel_dim_count=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _euler2d_flux_x() -> CompositionEntry:
+    """HyPar Euler 2D physical flux in x."""
+    rho = Term.In(0)
+    mx = Term.In(1)
+    my = Term.In(2)
+    energy = Term.In(3)
+    ux = mx / rho
+    uy = my / rho
+    kinetic = (rho * Term.Lit(0.5)) * ((ux * ux) + (uy * uy))
+    pressure = T_cap("%gamma_minus_one") * (energy - kinetic)
+    body_per_yield = [
+        mx,
+        (mx * ux) + pressure,
+        my * ux,
+        (energy + pressure) * ux,
+    ]
+    return CompositionEntry(
+        name="hypar_euler2d_flux_x",
+        steps=[CompositionStep(body=body_per_yield[0],
+                                body_per_yield=body_per_yield,
+                                num_ins=4, num_outs=4,
+                                parallel_dim_count=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _euler2d_flux_y() -> CompositionEntry:
+    """HyPar Euler 2D physical flux in y."""
+    rho = Term.In(0)
+    mx = Term.In(1)
+    my = Term.In(2)
+    energy = Term.In(3)
+    ux = mx / rho
+    uy = my / rho
+    kinetic = (rho * Term.Lit(0.5)) * ((ux * ux) + (uy * uy))
+    pressure = T_cap("%gamma_minus_one") * (energy - kinetic)
+    body_per_yield = [
+        my,
+        mx * uy,
+        (my * uy) + pressure,
+        (energy + pressure) * uy,
+    ]
+    return CompositionEntry(
+        name="hypar_euler2d_flux_y",
+        steps=[CompositionStep(body=body_per_yield[0],
+                                body_per_yield=body_per_yield,
+                                num_ins=4, num_outs=4,
+                                parallel_dim_count=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _reduce_sum_1d() -> CompositionEntry:
+    """scalar += in[i]."""
+    body = Term.Out(0) + Term.In(0)
+    return CompositionEntry(
+        name="reduce_sum_1D",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=0, reduction_dim_count=1)],
+        form="any",
+    )
+
+
+def _reduce_weighted_sum_1d() -> CompositionEntry:
+    """scalar += alpha * in[i]."""
+    body = Term.Out(0) + (Term.In(0) * T_cap("%alpha"))
+    return CompositionEntry(
+        name="reduce_weighted_sum_1D",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=0, reduction_dim_count=1)],
+        form="any",
+    )
+
+
+def _reduce_scaled_square_diff_1d() -> CompositionEntry:
+    """scalar += alpha * (x[i] - y[i])^2."""
+    diff = Term.In(0) - Term.In(1)
+    body = Term.Out(0) + ((diff * diff) * T_cap("%alpha"))
+    return CompositionEntry(
+        name="reduce_scaled_square_diff_1D",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=0, reduction_dim_count=1)],
+        form="any",
+    )
+
+
+def _reduce_max_abs_1d() -> CompositionEntry:
+    """scalar = max(scalar, abs(in[i])) with abs lowered as select."""
+    abs_v = Term.Select(
+        Term.Cmp("olt", Term.In(0), Term.Lit(0.0)),
+        Term.Lit(0.0) - Term.In(0),
+        Term.In(0),
+    )
+    body = Term.Select(Term.Cmp("ogt", abs_v, Term.Out(0)), abs_v, Term.Out(0))
+    return CompositionEntry(
+        name="reduce_max_abs_1D",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=0, reduction_dim_count=1)],
+        form="any",
+    )
+
+
+def _reduce_sum_axis() -> CompositionEntry:
+    """out[j] = sum_i in[?, ?]  — reduce across one axis. 1 parallel + 1 reduction."""
+    body = Term.Out(0) + Term.In(0)
+    return CompositionEntry(
+        name="reduce_sum_axis",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=1)],
+    )
+
+
+def _vector_add_no_alpha() -> CompositionEntry:
+    """y += x  — vector add (axpy with alpha = 1, gemver third stage)."""
+    body = Term.Out(0) + Term.In(0)
+    return CompositionEntry(
+        name="cublasDaxpy_unit",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+    )
+
+
+def _centered_sum_squares() -> CompositionEntry:
+    """out += (in0 - in1) * (in0 - in1)  — variance accumulation."""
+    diff = Term.In(0) - Term.In(1)
+    body = Term.Out(0) + diff * diff
+    return CompositionEntry(
+        name="centered_sum_squares",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                reduction_dim_count=1)],
+    )
+
+
+def _trmm_masked() -> CompositionEntry:
+    """out += in0 * in1, only where mask predicate holds  — cublasDtrmm body."""
+    body = Term.Select(T_cap("%mask"),
+                       Term.Out(0) + Term.In(0) * Term.In(1),
+                       Term.Out(0))
+    return CompositionEntry(
+        name="cublasDtrmm",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=1)],
+    )
+
+
+def _syrk_composition() -> CompositionEntry:
+    """C[j<=i] = β*C[j<=i] + α*A*A^T  (symmetric rank-k update, triangular).
+
+    Two-step: masked beta-scale then masked alpha-gemm-accumulate. The mask
+    predicate is a per-step Cap because the encoder treats `arith.cmpi +
+    linalg.index + affine.apply` as opaque — and each step's predicate has a
+    *distinct* SSA name (e.g. %9 in step 1, %11 in step 2). Use per-step
+    capture names so the cross-step binding merge in match_composition
+    doesn't try to unify them.
+    """
+    s1 = CompositionStep(
+        body=Term.Select(T_cap("%mask1"),
+                         Term.Out(0) * T_cap("%beta"),
+                         Term.Out(0)),
+        num_ins=0, num_outs=1, parallel_dim_count=2, reduction_dim_count=0,
+    )
+    s2 = CompositionStep(
+        body=Term.Select(T_cap("%mask2"),
+                         Term.Out(0) + (T_cap("%alpha") * Term.In(0)) * Term.In(1),
+                         Term.Out(0)),
+        num_ins=2, num_outs=1, parallel_dim_count=2, reduction_dim_count=1,
+    )
+    return CompositionEntry(name="cublasDsyrk", steps=[s1, s2])
+
+
+def _conv2d_9pt_weighted() -> CompositionEntry:
+    """2D 9-tap weighted convolution: out = sum_{k=0..8} w_k * in_k.
+
+    Each in_k is a strided subview of the same source tensor — one per
+    3×3 neighbour position. After our `bake_polybenchgpu_extracted_mlir.sh`
+    pulls the kernel out of its TU (breaking the init constant-fold chain),
+    polybenchGpu's convolution-2d lifts to exactly this shape.
+
+    Body is a left-fold sum of products, matching MLIR's natural CSE/folding
+    of the polybench-style straight-line C code.
+    """
+    body = Term.In(0) * T_cap("%w0")
+    for i in range(1, 9):
+        body = body + Term.In(i) * T_cap(f"%w{i}")
+    return CompositionEntry(
+        name="cudnnConvolution2D_9tap",
+        steps=[CompositionStep(body=body, num_ins=9, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+        form="memref",
+        surface_inline_weights=True,
+    )
+
+
+def _conv2d_25pt_weighted() -> CompositionEntry:
+    """2D 25-tap weighted convolution: out = sum_{k=0..24} w_k * in_k.
+
+    This is the 5x5 sibling of _conv2d_9pt_weighted. The raise pipeline
+    exposes straight-line 5x5 image/PDE stencils as 25 shifted input subviews
+    plus one output subview; surfacing the literals lets lowering route the
+    whole linalg.generic to a single cuDNN 5x5 convolution shim.
+    """
+    body = Term.In(0) * T_cap("%w0")
+    for i in range(1, 25):
+        body = body + Term.In(i) * T_cap(f"%w{i}")
+    return CompositionEntry(
+        name="cudnnConvolution2D_25tap",
+        steps=[CompositionStep(body=body, num_ins=25, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+        form="memref",
+        surface_inline_weights=True,
+    )
+
+
+def _conv2d_ntap_weighted_tensor() -> CompositionEntry:
+    """Tensor-form family matcher for odd-square 2D weighted stencils.
+
+    This dynamic entry covers 3x3 and wider odd-square stencils without adding
+    one algebra template per size. The special matcher checks only the scalar
+    weighted-sum body; kernel_match_rewrite.py separately proves the tensor
+    operands are shifted extract_slice views before emitting the cuDNN launch.
+    """
+    return CompositionEntry(
+        name="cudnnConvolution2D_ntap_tensor",
+        steps=[CompositionStep(body=Term.In(0), num_outs=1,
+                                parallel_dim_count=2,
+                                reduction_dim_count=0,
+                                special="weighted_conv2d_ntap")],
+        form="tensor",
+    )
+
+
+def _conv2d_9pt_weighted_tensor() -> CompositionEntry:
+    """Tensor-form sibling of _conv2d_9pt_weighted — fires after the
+    multi-root debufferize on the same body."""
+    body = Term.In(0) * T_cap("%w0")
+    for i in range(1, 9):
+        body = body + Term.In(i) * T_cap(f"%w{i}")
+    return CompositionEntry(
+        name="cudnnConvolution2D_9tap_tensor",
+        steps=[CompositionStep(body=body, num_ins=9, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+        form="tensor",
+        surface_inline_weights=True,
+    )
+
+
+def _conv3d_11pt_weighted() -> CompositionEntry:
+    """3D 11-tap weighted convolution: out = sum_{k=0..10} w_k * in_k.
+
+    Matches polybenchGpu's extracted conv3d body, which has 15 writes but
+    only 11 unique input positions (3 positions each appear in 3 muls
+    with different literal coefficients; their products are then summed).
+    The factoring + literal-folding rules in `algebra_rules` collapse the
+    redundant muls during egglog saturation, so the body normalises to
+    one mul per unique input — exactly the shape matched here.
+
+    The iteration nest is 3D parallel (over (i,j,k)); no reduction dims.
+    """
+    body = Term.In(0) * T_cap("%w0")
+    for i in range(1, 11):
+        body = body + Term.In(i) * T_cap(f"%w{i}")
+    return CompositionEntry(
+        name="cudnnConvolution3D_11tap",
+        steps=[CompositionStep(body=body, num_ins=11, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+        form="memref",
+        surface_inline_weights=True,
+    )
+
+
+def _softmax_3step() -> CompositionEntry:
+    """1D softmax as 3 fused linalg.generic ops, matching what cgeist + raise
+    produces for llama2.c's softmax (and the per-(B,T) row in llm.c's
+    softmax_forward, after the outer affine.fors are stripped).
+
+    Step 0 — max reduction (1 in, 1 scalar out):
+        out = (in > out) ? in : out                 → Select(Cmp("ogt", In(0), Out(0)), In(0), Out(0))
+
+    Step 1 — fused exp + sum-accumulate (0 ins, 2 outs, MULTI-YIELD):
+        out_0 = exp(out_0 - max)                    → yield[0] = Exp(Out(0) - Cap("%max"))
+        out_1 = out_1 + exp(out_0 - max)            → yield[1] = Out(1) + Exp(Out(0) - Cap("%max"))
+      Note: both yields share the same `exp(out_0 - max)` intermediate;
+      encode_body_yields produces two Terms in the same body env so the
+      shared subexpression is structurally identical, letting _unify bind
+      Cap("%max") consistently across both yield slots.
+
+    Step 2 — divide-by-sum (0 ins, 1 out, parallel):
+        out = out / sum                             → Out(0) / Cap("%sum")
+
+    Lowers to a single kernel.launch @cudnnSoftmaxForward — cuDNN's
+    softmax kernel implements exactly the max-shift / exp / sum-normalize
+    pipeline natively, in one launch with tensor-core kernels on FP16/BF16
+    inputs.
+    """
+    step0 = CompositionStep(
+        body=Term.Select(
+            Term.Cmp("ogt", Term.In(0), Term.Out(0)),
+            Term.In(0),
+            Term.Out(0),
+        ),
+        num_ins=1, num_outs=1,
+        reduction_dim_count=1, parallel_dim_count=0,
+    )
+    exp_intermediate = Term.Exp(Term.Out(0) - T_cap("%max"))
+    step1 = CompositionStep(
+        body=exp_intermediate,  # back-compat placeholder; matcher uses body_per_yield
+        body_per_yield=[
+            exp_intermediate,                       # yield[0]: writes back to array
+            Term.Out(1) + exp_intermediate,         # yield[1]: accumulates into sum scalar
+        ],
+        num_ins=0, num_outs=2,
+        reduction_dim_count=1, parallel_dim_count=0,
+    )
+    step2 = CompositionStep(
+        body=Term.Out(0) / T_cap("%sum"),
+        num_ins=0, num_outs=1,
+        reduction_dim_count=0, parallel_dim_count=1,
+    )
+    return CompositionEntry(
+        name="cudnnSoftmaxForward",
+        steps=[step0, step1, step2],
+        form="memref",
+    )
+
+
+def _softmax_3step_tensor() -> CompositionEntry:
+    entry = _softmax_3step()
+    return CompositionEntry(
+        name="cudnnSoftmaxForward_tensor",
+        steps=entry.steps,
+        form="tensor",
+    )
+
+
+def _softmax_3step_out_tensor() -> CompositionEntry:
+    """Out-of-place 1D softmax:
+
+        max = reduce_max(scores)
+        out[i] = exp(scores[i] - max); sum += out[i]
+        out[i] /= sum
+
+    This is the standalone attention-softmax fixture shape. The CUDA lowering
+    copies scores to out and routes the normalized row through cuDNN softmax.
+    """
+    step0 = CompositionStep(
+        body=Term.Select(
+            Term.Cmp("ogt", Term.In(0), Term.Out(0)),
+            Term.In(0),
+            Term.Out(0),
+        ),
+        num_ins=1, num_outs=1,
+        reduction_dim_count=1, parallel_dim_count=0,
+    )
+    exp_intermediate = Term.Exp(Term.In(0) - T_cap("%max"))
+    step1 = CompositionStep(
+        body=exp_intermediate,
+        body_per_yield=[
+            exp_intermediate,
+            Term.Out(1) + exp_intermediate,
+        ],
+        num_ins=1, num_outs=2,
+        reduction_dim_count=1, parallel_dim_count=0,
+    )
+    step2 = CompositionStep(
+        body=Term.Out(0) / T_cap("%sum"),
+        num_ins=0, num_outs=1,
+        reduction_dim_count=0, parallel_dim_count=1,
+    )
+    return CompositionEntry(
+        name="cudnnSoftmaxForwardOut_tensor",
+        steps=[step0, step1, step2],
+        form="tensor",
+    )
+
+
+def _softmax_3step_out_tensor_mul_inv() -> CompositionEntry:
+    """Out-of-place softmax where the final normalize phase is written as
+    `out *= inv_sum` after scalar code computes `inv_sum = 1.0 / sum`.
+
+    The body shape alone would also match arbitrary vector scaling, so the
+    entry carries a scalar-chain postcondition proving `%inv_sum` is the
+    reciprocal of the previous softmax sum result.
+    """
+    entry = _softmax_3step_out_tensor()
+    steps = list(entry.steps)
+    steps[2] = CompositionStep(
+        body=Term.Out(0) * T_cap("%inv_sum"),
+        num_ins=0, num_outs=1,
+        reduction_dim_count=0, parallel_dim_count=1,
+    )
+    return CompositionEntry(
+        name=entry.name,
+        steps=steps,
+        form=entry.form,
+        scalar_relation="softmax_out_mul_inv_sum",
+    )
+
+
+def _whisper_exp_shift_sum_tensor() -> CompositionEntry:
+    """Whisper helper:
+
+        out[i] = exp(x[i] - max_val)
+        sum += out[i]
+
+    This is not full normalized softmax; it returns the denominator so the
+    caller can decide how/when to normalize. Keep it as a distinct library
+    symbol instead of mapping it to cudnnSoftmaxForward.
+    """
+    exp_intermediate = Term.Exp(Term.In(0) - T_cap("%max"))
+    step = CompositionStep(
+        body=exp_intermediate,
+        body_per_yield=[
+            exp_intermediate,
+            Term.Out(1) + exp_intermediate,
+        ],
+        num_ins=1, num_outs=2,
+        reduction_dim_count=1, parallel_dim_count=0,
+    )
+    return CompositionEntry(
+        name="whisperExpShiftSum_f32_tensor",
+        steps=[step],
+        form="tensor",
+    )
+
+
+def _rmsnorm_family() -> list[CompositionEntry]:
+    """RMSNorm family — 1D root-mean-square normalize + optional scale terms.
+
+    cgeist + raise produces two linalg.generic ops in sequence, with the
+    scale computation (`scale = 1/sqrt(ss/N + eps)`) inlined between them
+    as ordinary scalar arith on the host side:
+
+        Step 0 — ss = sum(x[i]²):  reduction, 1 in (x), 1 scalar out
+            body = Out(0) + (In(0) * In(0))
+
+        [inline: load ss; divf ss/N; addf +eps; sqrt; divf 1/sqrt → %scale]
+
+        Step 1 variants:
+            weighted:
+                out = weight * scale * x
+                body = In(0) * (Cap("%scale") * In(1))
+
+            unweighted:
+                out = x * scale
+                body = In(0) * Cap("%scale")
+
+            scalar-gain unweighted:
+                out = x * scale * gain
+                body = In(0) * (Cap("%scale") * Cap("%gain"))
+
+    The Cap binds to whatever body-external SSA the rewriter sees feeding
+    the second linalg's body — typically the `%5 = arith.divf %cst, %4`
+    result of the inlined scale computation.
+
+    Lowers to an `rmsnorm` kernel.launch. cuDNN has no native RMSNorm
+    entry (its `cudnnNormForward` always mean-centers). The runtime shim
+    is the natural place to decide between (a) cuBLAS decomposition
+    (cublasSdot for ss + scalar arith on host + per-element fused scale,
+    weight, multiply), (b) cuDNN LayerNorm with mean=0 trick
+    (version-dependent), or (c) a hand-written CUDA kernel (the
+    production choice in TRT-LLM / vLLM).
+
+    Keep the variants generated together so RMSNorm stays one semantic
+    matcher family instead of a pile of near-duplicate one-off templates.
+    Priority is weighted first (more specific tensor operand shape), then
+    plain unweighted, then scalar-gain unweighted.
+    """
+    step0 = CompositionStep(
+        body=Term.Out(0) + (Term.In(0) * Term.In(0)),
+        num_ins=1, num_outs=1,
+        reduction_dim_count=1, parallel_dim_count=0,
+    )
+
+    def entry(name: str, body: Term, num_ins: int) -> CompositionEntry:
+        step1 = CompositionStep(
+            body=body,
+            num_ins=num_ins, num_outs=1,
+            reduction_dim_count=0, parallel_dim_count=1,
+        )
+        return CompositionEntry(
+            name=name,
+            steps=[step0, step1],
+            form="any",
+        )
+
+    return [
+        entry(
+            "rmsnorm_f32",
+            Term.In(0) * (T_cap("%scale") * Term.In(1)),
+            2,
+        ),
+        entry(
+            "rmsnorm_unweighted_f32",
+            Term.In(0) * T_cap("%scale"),
+            1,
+        ),
+        entry(
+            "rmsnorm_scaled_unweighted_f32",
+            (Term.In(0) * T_cap("%scale")) * T_cap("%gain"),
+            1,
+        ),
+        entry(
+            "rmsnorm_scaled_unweighted_f32",
+            Term.In(0) * (T_cap("%scale") * T_cap("%gain")),
+            1,
+        ),
+    ]
+
+
+def _gelu_tanh_f32_tensor() -> CompositionEntry:
+    """Approximate GELU:
+
+        out = 0.5*x*(1 + tanh(0.79788456*(x + 0.044715*x^3)))
+
+    Coefficients are Cap wildcards constrained to scalar captures/literals by
+    `_unify`, so f32 spelling/rounding differences still match while tensor
+    operands cannot masquerade as constants.
+    """
+    x = Term.In(0)
+    x3_scaled = ((x * T_cap("%cube_coeff")) * x) * x
+    inner = (x + x3_scaled) * T_cap("%sqrt_2_over_pi")
+    body = (x * T_cap("%half")) * (
+        Term.Tanh(inner) + T_cap("%one")
+    )
+    return CompositionEntry(
+        name="gelu_tanh_f32_tensor",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=1,
+                                reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _llama_add_f32_tensor() -> CompositionEntry:
+    """out = in0 + in1 — residual add in standalone Llama fixtures."""
+    return CompositionEntry(
+        name="cudaAdd_f32_tensor",
+        steps=[CompositionStep(body=Term.In(0) + Term.In(1),
+                                num_ins=2, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _llama_mask_select_f32_tensor() -> CompositionEntry:
+    """Branchless causal mask fixture:
+
+        drop = (i > pos)
+        out = (1 - drop) * scores + drop * NEG_INF
+
+    The `%mask` cap is produced from linalg.index inside the linalg body; the
+    rewriter special-cases this symbol and surfaces the real `%pos` operand.
+    """
+    drop = T_cap("%mask")
+    body = (Term.Lit(1.0) - drop) * Term.In(0) + \
+           drop * Term.Lit(-3.40282347e38)
+    return CompositionEntry(
+        name="cudaMaskSelect_f32_tensor",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _llama_swiglu_f32_tensor() -> CompositionEntry:
+    """out = (gate / (1 + exp(-gate))) * up."""
+    gate = Term.In(0)
+    body = (gate / (Term.Exp(Term.Lit(0.0) - gate) + Term.Lit(1.0))) * Term.In(1)
+    return CompositionEntry(
+        name="cudaSwiGLU_f32_tensor",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _llama_rope_mulmul_sub_f32_tensor() -> CompositionEntry:
+    """RoPE split even output: out[h,p] = a[h,p] * b[p] - c[h,p] * d[p]."""
+    body = Term.In(0) * Term.In(1) - Term.In(2) * Term.In(3)
+    return CompositionEntry(
+        name="cudaRopeMulMulSub_f32_tensor",
+        steps=[CompositionStep(body=body, num_ins=4, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _llama_rope_mulmul_add_f32_tensor() -> CompositionEntry:
+    """RoPE split odd output: out[h,p] = a[h,p] * b[p] + c[h,p] * d[p]."""
+    body = Term.In(0) * Term.In(1) + Term.In(2) * Term.In(3)
+    return CompositionEntry(
+        name="cudaRopeMulMulAdd_f32_tensor",
+        steps=[CompositionStep(body=body, num_ins=4, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _jacobi_1d_3pt() -> CompositionEntry:
+    """Jacobi 1D 3-point smoother: out[i] = (a + b + c) * coef
+    where a, b, c are the left/center/right neighbors (encoded via subview
+    offsets, so the linalg body just sees three identity-accessed inputs)."""
+    body = (Term.In(0) + Term.In(1) + Term.In(2)) * T_cap("%coef")
+    return CompositionEntry(
+        name="jacobi_1d_3pt",
+        steps=[CompositionStep(body=body, num_ins=3, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+        form="memref",
+    )
+
+
+# Tensor-form variants of the stencils. Multi-root debufferize lifts these
+# kernels to tensor-form linalg.generic (with polygeist.submap doing the
+# offset work that memref.subview did in the memref form). The body is
+# identical, only the operand/result types change — hence a separate entry
+# per stencil pointing to a tensor-typed canonical defn in the library.
+def _jacobi_1d_3pt_tensor() -> CompositionEntry:
+    body = (Term.In(0) + Term.In(1) + Term.In(2)) * T_cap("%coef")
+    return CompositionEntry(
+        name="jacobi_1d_3pt_tensor",
+        steps=[CompositionStep(body=body, num_ins=3, num_outs=1,
+                                parallel_dim_count=1, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _jacobi_2d_5pt() -> CompositionEntry:
+    """Jacobi 2D 5-point stencil: out[i,j] = (n + s + w + e + c) * coef."""
+    body = ((((Term.In(0) + Term.In(1)) + Term.In(2))
+              + Term.In(3)) + Term.In(4)) * T_cap("%coef")
+    return CompositionEntry(
+        name="jacobi_2d_5pt",
+        steps=[CompositionStep(body=body, num_ins=5, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+        form="memref",
+    )
+
+
+def _jacobi_2d_5pt_tensor() -> CompositionEntry:
+    body = ((((Term.In(0) + Term.In(1)) + Term.In(2))
+              + Term.In(3)) + Term.In(4)) * T_cap("%coef")
+    return CompositionEntry(
+        name="jacobi_2d_5pt_tensor",
+        steps=[CompositionStep(body=body, num_ins=5, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _heat_3d_7pt() -> CompositionEntry:
+    """Heat 3D 7-point Laplacian update:
+        out = (l - 2*c + r)*coef + (d - 2*c + u)*coef + (b - 2*c + f)*coef + c
+    where c = In(1) is the center; the other 6 ins are the axial neighbors.
+    The encoder pairs ins by subview-offset order: x-neighbors (In(0),In(2)),
+    y-neighbors (In(3),In(4)), z-neighbors (In(5),In(6)).
+    """
+    c = Term.In(1)
+    two = T_cap("%two")
+    coef = T_cap("%coef")
+    dx = (Term.In(0) - c * two + Term.In(2)) * coef
+    dy = (Term.In(3) - c * two + Term.In(4)) * coef
+    dz = (Term.In(5) - c * two + Term.In(6)) * coef
+    body = ((dx + dy) + dz) + c
+    return CompositionEntry(
+        name="heat_3d_7pt",
+        steps=[CompositionStep(body=body, num_ins=7, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+        form="memref",
+    )
+
+
+def _heat_3d_7pt_tensor() -> CompositionEntry:
+    c = Term.In(1)
+    two = T_cap("%two")
+    coef = T_cap("%coef")
+    dx = (Term.In(0) - c * two + Term.In(2)) * coef
+    dy = (Term.In(3) - c * two + Term.In(4)) * coef
+    dz = (Term.In(5) - c * two + Term.In(6)) * coef
+    body = ((dx + dy) + dz) + c
+    return CompositionEntry(
+        name="heat_3d_7pt_tensor",
+        steps=[CompositionStep(body=body, num_ins=7, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _miniamr_weighted_7pt_tensor() -> CompositionEntry:
+    """miniAMR 7-point variable-coefficient update:
+       out = center + coeff * (sum(six axial neighbours) - 6 * center).
+
+    Unlike `_heat_3d_7pt_tensor`, the coefficient is a tensor input rather
+    than a scalar capture.
+    """
+    c = Term.In(0)
+    neigh_sum = (((((Term.In(1) + Term.In(2)) + Term.In(3)) + Term.In(4))
+                  + Term.In(5)) + Term.In(6))
+    body = c + (Term.In(7) * (neigh_sum - (c * Term.Lit(6.0))))
+    return CompositionEntry(
+        name="miniamr_weighted_7pt_tensor",
+        steps=[CompositionStep(body=body, num_ins=8, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _miniamr_directional_stencil_tensor() -> CompositionEntry:
+    """miniAMR directional 3-point update with two scalar coefficients."""
+    c = Term.In(1)
+    body = (c + (T_cap("%alpha") * ((Term.In(0) - (c * Term.Lit(2.0))) +
+                                     Term.In(2)))) + \
+           (T_cap("%beta") * (Term.In(2) - Term.In(0)))
+    return CompositionEntry(
+        name="miniamr_directional_stencil_tensor",
+        steps=[CompositionStep(body=body, num_ins=3, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _miniamr_average_7pt_tensor() -> CompositionEntry:
+    """miniAMR 7-point average."""
+    body = Term.In(0)
+    for idx in range(1, 7):
+        body = body + Term.In(idx)
+    body = body / Term.Lit(7.0)
+    return CompositionEntry(
+        name="miniamr_average_7pt_tensor",
+        steps=[CompositionStep(body=body, num_ins=7, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _hpgmg_apply_op_7pt_tensor() -> CompositionEntry:
+    """HPGMG 7-point operator: a*center + b*(6*center - neighbours)."""
+    c = Term.In(0)
+    lap = ((((((c * Term.Lit(6.0)) - Term.In(1)) - Term.In(2)) -
+             Term.In(3)) - Term.In(4)) - Term.In(5)) - Term.In(6)
+    body = (T_cap("%alpha") * c) + (T_cap("%beta") * lap)
+    return CompositionEntry(
+        name="hpgmg_apply_op_7pt_tensor",
+        steps=[CompositionStep(body=body, num_ins=7, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _hpgmg_residual_7pt_tensor() -> CompositionEntry:
+    """HPGMG residual: rhs - apply_op_7pt(x)."""
+    c = Term.In(0)
+    lap = ((((((c * Term.Lit(6.0)) - Term.In(1)) - Term.In(2)) -
+             Term.In(3)) - Term.In(4)) - Term.In(5)) - Term.In(6)
+    apply = (T_cap("%alpha") * c) + (T_cap("%beta") * lap)
+    body = Term.In(7) - apply
+    return CompositionEntry(
+        name="hpgmg_residual_7pt_tensor",
+        steps=[CompositionStep(body=body, num_ins=8, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _hpgmg_jacobi_smooth_7pt_tensor() -> CompositionEntry:
+    """HPGMG Jacobi smooth: x + lambda*diag_inv*(rhs - apply_op_7pt(x))."""
+    c = Term.In(0)
+    lap = ((((((c * Term.Lit(6.0)) - Term.In(1)) - Term.In(2)) -
+             Term.In(3)) - Term.In(4)) - Term.In(5)) - Term.In(6)
+    apply = (T_cap("%alpha") * c) + (T_cap("%beta") * lap)
+    body = c + ((T_cap("%lambda") * Term.In(7)) * (Term.In(8) - apply))
+    return CompositionEntry(
+        name="hpgmg_jacobi_smooth_7pt_tensor",
+        steps=[CompositionStep(body=body, num_ins=9, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _hpgmg_restriction_face_tensor() -> CompositionEntry:
+    """HPGMG face restriction: average four fine-grid values."""
+    body = (((Term.In(0) + Term.In(1)) + Term.In(2)) + Term.In(3)) * \
+           Term.Lit(0.25)
+    return CompositionEntry(
+        name="hpgmg_restriction_face_tensor",
+        steps=[CompositionStep(body=body, num_ins=4, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _hpgmg_restriction_cell_tensor() -> CompositionEntry:
+    """HPGMG cell restriction: average eight fine-grid values."""
+    body = Term.In(0)
+    for idx in range(1, 8):
+        body = body + Term.In(idx)
+    body = body * Term.Lit(0.125)
+    return CompositionEntry(
+        name="hpgmg_restriction_cell_tensor",
+        steps=[CompositionStep(body=body, num_ins=8, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _fdtd_update_2in() -> CompositionEntry:
+    """FDTD H-field update: out -= coef * (in0 - in1).
+    Used for both H_x and H_y in fdtd-2d's per-time-step body."""
+    body = Term.Out(0) - (Term.In(0) - Term.In(1)) * T_cap("%coef")
+    return CompositionEntry(
+        name="fdtd_update_2in",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+        form="memref",
+    )
+
+
+def _fdtd_update_2in_tensor() -> CompositionEntry:
+    body = Term.Out(0) - (Term.In(0) - Term.In(1)) * T_cap("%coef")
+    return CompositionEntry(
+        name="fdtd_update_2in_tensor",
+        steps=[CompositionStep(body=body, num_ins=2, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _fdtd_E_update() -> CompositionEntry:
+    """FDTD E-field update: out -= coef * (in0 - in1 + in2 - in3).
+    The four ins are paired (curl_x, curl_y) contributions."""
+    body = Term.Out(0) - (
+        ((Term.In(0) - Term.In(1)) + Term.In(2)) - Term.In(3)
+    ) * T_cap("%coef")
+    return CompositionEntry(
+        name="fdtd_E_update",
+        steps=[CompositionStep(body=body, num_ins=4, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+        form="memref",
+    )
+
+
+def _fdtd_E_update_tensor() -> CompositionEntry:
+    body = Term.Out(0) - (
+        ((Term.In(0) - Term.In(1)) + Term.In(2)) - Term.In(3)
+    ) * T_cap("%coef")
+    return CompositionEntry(
+        name="fdtd_E_update_tensor",
+        steps=[CompositionStep(body=body, num_ins=4, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _syr2k_composition() -> CompositionEntry:
+    """C[j<=i] = β*C[j<=i] + α*(A*B^T + B*A^T)  (symmetric rank-2k update)."""
+    s1 = CompositionStep(
+        body=Term.Select(T_cap("%mask1"),
+                         Term.Out(0) * T_cap("%beta"),
+                         Term.Out(0)),
+        num_ins=0, num_outs=1, parallel_dim_count=2, reduction_dim_count=0,
+    )
+    # Build the body in the same right-associative shape the encoder
+    # produces: Out + (part1 + part2). Python's `+` is left-associative, so
+    # without these parens we'd build (Out + part1) + part2 — structurally
+    # different from the body even though mathematically equivalent.
+    part1 = (T_cap("%alpha") * Term.In(0)) * Term.In(1)
+    part2 = (T_cap("%alpha") * Term.In(2)) * Term.In(3)
+    s2 = CompositionStep(
+        body=Term.Select(T_cap("%mask2"),
+                         Term.Out(0) + (part1 + part2),
+                         Term.Out(0)),
+        num_ins=4, num_outs=1, parallel_dim_count=2, reduction_dim_count=1,
+    )
+    return CompositionEntry(name="cublasDsyr2k", steps=[s1, s2])
+
+
+def _copy_input() -> CompositionEntry:
+    """out[i] = in[i]  — vector copy.
+
+    Tagged memref-form because the canonical defn in kernel_library_phase2.mlir
+    is authored for memref operands (used by fdtd-2d's source-injection step
+    where a scalar memref broadcasts to a 1D output row). The tensor-form
+    twin below handles the multi-root debufferize variant.
+    """
+    body = Term.In(0)
+    return CompositionEntry(
+        name="cublasDcopy",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                reduction_dim_count=0)],
+        form="memref",
+    )
+
+
+def _copy_input_tensor() -> CompositionEntry:
+    """Tensor-form variant of cublasDcopy — used by multi-root fdtd-2d's
+    source-injection step."""
+    body = Term.In(0)
+    return CompositionEntry(
+        name="cublasDcopy_tensor",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _copy_input_2d_tensor() -> CompositionEntry:
+    """Rank-2 tensor copy. Kept separate from cublasDcopy_tensor because the
+    cuBLAS ABI template is 1D-only."""
+    body = Term.In(0)
+    return CompositionEntry(
+        name="tensor_copy_2D",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _copy_input_3d_tensor() -> CompositionEntry:
+    """Rank-3 tensor copy/transpose-style pack/unpack."""
+    body = Term.In(0)
+    return CompositionEntry(
+        name="tensor_copy_3D",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=3, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _copy_input_6d_tensor() -> CompositionEntry:
+    """Rank-6 tensor copy exposed by HPGMG interpolation extraction."""
+    body = Term.In(0)
+    return CompositionEntry(
+        name="tensor_copy_6D",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                parallel_dim_count=6, reduction_dim_count=0)],
+        form="tensor",
+    )
+
+
+def _axpby() -> CompositionEntry:
+    """out = α*in0 + β*out  — gesummv combine step (cublasDaxpby)."""
+    body = T_cap("%alpha") * Term.In(0) + T_cap("%beta") * Term.Out(0)
+    return CompositionEntry(
+        name="cublasDaxpby",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _fma3() -> CompositionEntry:
+    """out = in0*in1 + in2  — fused-multiply-add over 3 inputs (adi solve step)."""
+    body = Term.In(0) * Term.In(1) + Term.In(2)
+    return CompositionEntry(
+        name="elemwise_fma3",
+        steps=[CompositionStep(body=body, num_ins=3, num_outs=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _sub_from_out() -> CompositionEntry:
+    """out -= in0  — vector-from-broadcast subtract (covariance centering)."""
+    body = Term.Out(0) - Term.In(0)
+    return CompositionEntry(
+        name="elemwise_sub_from_out",
+        steps=[CompositionStep(body=body, num_ins=1, num_outs=1,
+                                reduction_dim_count=0)],
+    )
+
+
+def _rank_two_update() -> CompositionEntry:
+    """A[i,j] += u1[i]*v1[j] + u2[i]*v2[j]  — gemver A-update stage.
+
+    Could lower to cublasDger × 2 + sum, or stay as a fused kernel.
+    """
+    body = (Term.Out(0) + Term.In(0) * Term.In(1)
+                       + Term.In(2) * Term.In(3))
+    return CompositionEntry(
+        name="cublasDger_rank2",
+        steps=[CompositionStep(body=body, num_ins=4, num_outs=1,
+                                parallel_dim_count=2, reduction_dim_count=0)],
+    )
+
+
+def composition_library() -> list[CompositionEntry]:
+    """Order: longest compositions first; same-length ordered by specificity
+    (more-captures first, more shape-constrained first)."""
+    return [
+        # Multi-step. Longest compositions first — the matcher is greedy
+        # and otherwise a shorter composition would consume bodies the
+        # longer one wanted.
+        _cudnn_conv_bias_relu_add_fused(),  # 5-step: init + conv + bias + residual + relu
+        _cublaslt_gemm_bias_relu_fused(),   # 4-step: init + gemm + bias + relu (cublasLt)
+        _miniamr_weighted_27pt_tensor(),     # 4-step: zero + identity reductions + 27pt accum
+        _hpgmg_apply_op_27pt_tensor(),       # 4-step: scale + identity reductions + 27pt accum
+        _cutensornet_tensor_product_3d_f32_tensor(),  # 2-step: zero + ai,bj,ck,ijk->abc
+        _cufft_z2z_1d_tensor(),              # 2-step: zero + direct complex DFT
+        _darknet_im2col_gemm_fused(),       # 3-step: zero + guarded im2col + sgemm
+        _conv1x1_as_gemm_batched(),          # 2-step: init + 4par+1red contraction = 1x1 conv
+        _cudnn_conv_bn_relu_fused(),  # 4-step: init + conv + bn-inplace + relu-inplace
+        _gemm_composition(),
+        _cudnn_conv2d_batched(),  # 2-step: init zero + 7-iter contraction (4 par + 3 red)
+        _cudnn_maxpool_batched(), # 2-step: init -inf + 6-iter max-reduce (4 par + 2 red)
+        _generic_two_input_sum_contraction_tensor(),
+                                               # 2-step: rank-generic FP64
+                                               # Einstein contraction; map
+                                               # legality is proved by rewrite
+        _cudnn_batchnorm_inference(),  # 1-step: 5-in fused normalize+scale+bias (4 par)
+        _cudnn_add_tensor_batched(),  # 1-step: Out + In(0) elementwise (4 par)
+
+        # 1-step BLAS with α capture.
+        _gemm_no_alpha(),
+        _gemm_alpha_only(),
+        _gemv_accumulate(),
+        _gemv_alpha_accumulate(),
+        _axpby(),               # α*in + β*out  — most specific 2-cap form
+        _axpby_inputs_1d(),     # α*in0 + β*in1 — out-of-place combine
+        _axpy(),
+        # Exact identity must precede the algebraically equivalent
+        # `alpha * input` rule (alpha=1), otherwise a legal tensor copy is
+        # hidden behind an elementwise ABI that is intentionally disabled.
+        _copy_input_tensor(),
+        _scal_1d(),
+        _scal_2d(),
+        _scale_input_1d(),
+        _mul_inputs_scaled_1d(),
+        _add_scalar_1d(),
+        _div_scalar_by_input_1d(),
+
+        # Triangular / masked / specialty (must come before generic gemm/gemv).
+        _syr2k_composition(),
+        _syrk_composition(),
+        _trmm_masked(),
+        _rank_two_update(),
+        _centered_sum_squares(),
+        _reduce_scaled_square_diff_1d(),
+        _cg_update_3out(),
+        _bicgstab_update_2out(),
+        _weno_weights_js(),
+        _euler2d_flux_x(),
+        _euler2d_flux_y(),
+        _euler1d_flux(),
+
+        # Stencils (Bucket 2).
+        _softmax_3step(),       # 3-step composition, max + exp+sum (multi-yield) + div.
+        _softmax_3step_tensor(),
+        _softmax_3step_out_tensor_mul_inv(),
+        _softmax_3step_out_tensor(),
+        _whisper_exp_shift_sum_tensor(),
+                                #         Distinctive enough that ordering doesn't
+                                #         matter against the rest, but list it
+                                #         with the longer-step compositions.
+        *_rmsnorm_family(),     # 2-step composition family:
+                                #         sum-of-squares + weighted,
+                                #         unweighted, or scalar-gain scale.
+                                #         Sits between softmax (3 steps) and
+                                #         conv shapes (single step) so
+                                #         longest-first matching picks the
+                                #         right shared-prefix family.
+        _conv3d_11pt_weighted(), # 11 ins, 3D parallel — most specific 3D
+                                 #         conv shape; relies on egglog
+                                 #         factoring to collapse redundant
+                                 #         muls in polybench's conv3d body.
+        _conv2d_25pt_weighted(), # 25 ins — 5x5 conv shape; keep before 9-tap
+                                  #          and lower-point stencil templates.
+        _conv2d_9pt_weighted(), # 9 ins — most specific 2D conv shape; must
+                                #         come before jacobi_2d_5pt (5 ins)
+                                #         since both target 2D parallel iter.
+        _hpgmg_gsrb_smooth_7pt_tensor(),
+        _hpgmg_jacobi_smooth_7pt_tensor(),
+        _hpgmg_residual_7pt_tensor(),
+        _hpgmg_apply_op_7pt_tensor(),
+        _miniamr_pointwise_update_tensor(),
+        _miniamr_weighted_7pt_tensor(),
+        _miniamr_directional_stencil_tensor(),
+        _miniamr_average_7pt_tensor(),
+        _hpgmg_interpolation_p1_tensor(),
+        _hpgmg_interpolation_p2_tensor(),
+        _hpgmg_restriction_cell_tensor(),
+        _hpgmg_restriction_face_tensor(),
+        _heat_3d_7pt(),       # 7 ins
+        _fdtd_E_update(),     # 4 ins
+        _jacobi_2d_5pt(),     # 5 ins
+        _jacobi_1d_3pt(),     # 3 ins
+        _fdtd_update_2in(),   # 2 ins — checked AFTER more-specific 2D shapes
+
+        # Stencils — tensor form (multi-root debufferize).
+        _conv2d_ntap_weighted_tensor(), # odd-square weighted tensor fallback.
+        _conv2d_9pt_weighted_tensor(),
+        _heat_3d_7pt_tensor(),
+        _fdtd_E_update_tensor(),
+        _jacobi_2d_5pt_tensor(),
+        _jacobi_1d_3pt_tensor(),
+        _fdtd_update_2in_tensor(),
+        _copy_input_6d_tensor(),
+        _copy_input_3d_tensor(),
+        _copy_input_2d_tensor(),
+        _copy_input_tensor(),
+
+        # 1-step BLAS, no α.
+        _llama_rope_mulmul_sub_f32_tensor(),
+        _llama_rope_mulmul_add_f32_tensor(),
+        _llama_swiglu_f32_tensor(),
+        _llama_mask_select_f32_tensor(),
+        _llama_add_f32_tensor(),
+        _gelu_tanh_f32_tensor(),
+        _sgemm_broadcast3d_memref(),
+        _dot(),
+        _dot_f32(),
+        _asum(),
+        _reduce_max_abs_1d(),
+        _reduce_sum_1d(),
+        _reduce_weighted_sum_1d(),
+        _reduce_sum_axis(),     # 1 in, 1 out, P=1+R=1: separate from gemv (2 ins)
+        _vector_add_no_alpha(), # P=1+R=0
+        _mul_inputs_pointwise(),
+        _avg2_pointwise(),
+        _half_diff_pointwise(),
+        _linear_reaction_pointwise(),
+        _hypar_reaction_update(),
+        _llf_flux_2d(),
+        _burgers_advection_1d(),
+        _burgers_upwind(),
+        _upwind_select_const(),
+        _predicate_select_inputs(),
+        _minmod_limiter(),
+        _vanleer_limiter(),
+        _superbee_limiter(),
+        _generalized_minmod_limiter(),
+        _muscl_interp_minmod(),
+        _upwind_var_flux(),
+        _weno_interp5(),
+        _fourth_order_interp(),
+        _fourth_order_derivative(),
+        _fv4_flux(),
+        _random_vector_3d(),
+        _color_vector_3d(),
+        _exasp2_normalize_dense(),
+        _exasp2_neg_div(),
+        _add_out_scalar_1d(),
+        _exasp2_update_2x_minus_x2(),
+        _exasp2_select_square(),
+        _select_mul_or_zero(),
+        _copy_input(),          # out = in0 (1 in, 1 out)
+        _fma3(),                # in0*in1 + in2 (3 ins)
+        _divf_scalar(),
+        _subf_inputs(),
+        _sub_from_out(),
+
+        # Fill patterns.
+        _fill_zero_1d(),
+        _fill_zero_2d(),
+        _fill_const_1d(),
+        _fill_const_2d(),
+    ]
+
+
+def _term_repr(t) -> str:
+    """Stable text repr of a Term (uses egglog's default __repr__)."""
+    return str(t)
+
+
+## NOTE: An egglog-driven normaliser (build EGraph, saturate, extract) was
+## prototyped here. It worked correctly on small bodies (N ≤ ~10 summands)
+## but timed out past 30s on polybenchGpu conv3d's 15-mul body due to
+## exponential e-class growth from commutativity + associativity. The
+## factoring rules are still registered in `algebra_rules()` for use by
+## `equivalent()` (which operates on small canonical-template terms), but
+## the body-normalisation hot path uses the Python tuple-AST factoring in
+## `_factor_redundant_muls` below — linear time, predictable.
+
+
+def _looks_like_float(s: str) -> bool:
+    """True iff `s` parses as a Python float (used by `_parse_term` to
+    distinguish float Lit values like `0.2` or `-1.5` from SSA / type
+    tokens)."""
+    try:
+        float(s)
+        return True
+    except ValueError:
+        return False
+
+
+def _parse_term(s: str):
+    """Parse the string repr of a Term back into a Python AST (tuples).
+
+    egglog stringifies expressions in a Lisp-y way like
+        `Term.Out(0) + Term.Cap("%arg4")`
+    We just want a structured tree for our own unification matcher, so
+    we parse it as a stripped-down AST of (op, *children) tuples with
+    leaves represented as ('In', i) / ('Out', i) / ('Cap', name) / ('Lit', v).
+    """
+    s = s.strip()
+    if not s:
+        return None
+
+    def _paren_delta(text: str) -> int:
+        return text.count("(") - text.count(")")
+
+    def _split_egglog_lets(text: str) -> tuple[list[tuple[str, str]], str]:
+        """Split egglog's pretty-printed let form into definitions + body.
+
+        Reused subexpressions print as:
+
+            _Term_1 = Term.Select(...)
+            Term.Select(Term.Cmp("ogt", _Term_1, ...), _Term_1, ...)
+
+        The structural matcher wants the fully inlined AST. This splitter is
+        deliberately small: it recognizes only the `_Term_N = ...` shape that
+        egglog emits for Term aliases, preserving multi-line RHS expressions.
+        """
+        lines = text.splitlines()
+        if not lines or not re.match(r"\s*_Term_\d+\s*=", lines[0]):
+            return [], text
+
+        defs: list[tuple[str, str]] = []
+        final: list[str] = []
+        cur_name: Optional[str] = None
+        cur_lines: list[str] = []
+        depth = 0
+
+        for line in lines:
+            m = re.match(r"\s*(_Term_\d+)\s*=\s*(.*)$", line)
+            if m:
+                if cur_name is not None:
+                    defs.append((cur_name, "\n".join(cur_lines).strip()))
+                cur_name = m.group(1)
+                cur_lines = [m.group(2)]
+                depth = _paren_delta(m.group(2))
+                continue
+
+            if cur_name is not None and depth > 0:
+                cur_lines.append(line)
+                depth += _paren_delta(line)
+                continue
+
+            if cur_name is not None:
+                defs.append((cur_name, "\n".join(cur_lines).strip()))
+                cur_name = None
+                cur_lines = []
+                depth = 0
+            final.append(line)
+
+        if cur_name is not None:
+            defs.append((cur_name, "\n".join(cur_lines).strip()))
+        return defs, "\n".join(final).strip()
+
+    let_defs, s = _split_egglog_lets(s)
+    let_env: dict[str, object] = {}
+
+    def parse_expr(i: int):
+        """Returns (node, next_index)."""
+        # Skip whitespace
+        while i < len(s) and s[i] == " ":
+            i += 1
+        # Match `Term.(...)` leaf forms.
+        for ctor in ("In", "Out", "Cap", "Lit", "Sqrt", "Abs", "Exp", "Tanh", "Select", "Cmp"):
+            tag = f"Term.{ctor}("
+            if s[i:i+len(tag)] == tag:
+                j, args = i + len(tag), []
+                depth = 1
+                arg_start = j
+                # Parse comma-separated arguments respecting nested parens.
+                while j < len(s) and depth > 0:
+                    c = s[j]
+                    if c == '(':
+                        depth += 1
+                    elif c == ')':
+                        depth -= 1
+                        if depth == 0:
+                            arg = s[arg_start:j].strip()
+                            if arg:
+                                args.append(arg)
+                            break
+                    elif c == ',' and depth == 1:
+                        arg = s[arg_start:j].strip()
+                        if arg:
+                            args.append(arg)
+                        arg_start = j + 1
+                    j += 1
+                # Recursively parse each arg.
+                parsed_args = []
+                for a in args:
+                    if a.startswith('"') and a.endswith('"'):
+                        parsed_args.append(a[1:-1])
+                    elif a.lstrip("-").isdigit():
+                        parsed_args.append(int(a))
+                    elif _looks_like_float(a):
+                        parsed_args.append(float(a))
+                    else:
+                        sub, _ = parse_expr(0)
+                        # If parse_expr fully consumed `a`, use it.
+                        if sub is not None:
+                            parsed_args.append(sub)
+                        else:
+                            parsed_args.append(a)
+                node = (ctor, *parsed_args)
+                return node, j + 1
+        # Match a binary operator expression:   
+        # The whole expression is parenthesized when nested, but the top
+        # level isn't. We'll just handle the * and + operators here.
+        # Find the top-level operator by scanning paren-depth = 0.
+        depth = 0
+        op_idx = -1
+        op_char = None
+        for j in range(i, len(s)):
+            c = s[j]
+            if c == '(':
+                depth += 1
+            elif c == ')':
+                depth -= 1
+            elif depth == 0 and c in "+-*/":
+                # Prefer the LAST top-level operator (left-associative parse).
+                op_idx = j
+                op_char = c
+        if op_idx >= 0:
+            lhs_str = s[i:op_idx].strip()
+            rhs_str = s[op_idx+1:].strip()
+            lhs, _ = parse_expr_str(lhs_str)
+            rhs, _ = parse_expr_str(rhs_str)
+            op_name = {"+": "Add", "-": "Sub", "*": "Mul", "/": "Div"}[op_char]
+            return (op_name, lhs, rhs), len(s)
+        return None, i
+
+    def parse_expr_str(t: str):
+        # Strip wrapping parens.
+        t = t.strip()
+        if t in let_env:
+            return let_env[t], len(t)
+        while t.startswith('(') and t.endswith(')'):
+            # Only strip if these parens match outermost.
+            depth = 0
+            ok = True
+            for k, c in enumerate(t):
+                if c == '(': depth += 1
+                elif c == ')': depth -= 1
+                if depth == 0 and k < len(t) - 1:
+                    ok = False
+                    break
+            if ok:
+                t = t[1:-1].strip()
+            else:
+                break
+        # FIRST: try binary operator split at top level (paren depth 0).
+        # Lowest precedence first.
+        for op_chars in ("+-", "*/"):
+            depth = 0
+            op_idx = -1
+            op_char = None
+            for k, c in enumerate(t):
+                if c == '(': depth += 1
+                elif c == ')': depth -= 1
+                elif depth == 0 and c in op_chars:
+                    # Prefer the LAST top-level operator (so left-associative).
+                    op_idx = k
+                    op_char = c
+            if op_idx >= 0:
+                lhs, _ = parse_expr_str(t[:op_idx])
+                rhs, _ = parse_expr_str(t[op_idx+1:])
+                op_name = {"+": "Add", "-": "Sub", "*": "Mul", "/": "Div"}[op_char]
+                return (op_name, lhs, rhs), len(t)
+        # Otherwise try parsing as a Term.Ctor leaf.
+        for ctor in ("In", "Out", "Cap", "Lit", "Sqrt", "Abs", "Exp", "Tanh", "Select", "Cmp"):
+            tag = f"Term.{ctor}("
+            if t.startswith(tag) and t.endswith(")"):
+                inner = t[len(tag):-1]
+                # Split args at top-level commas.
+                args, depth, start = [], 0, 0
+                for k, c in enumerate(inner):
+                    if c == '(': depth += 1
+                    elif c == ')': depth -= 1
+                    elif c == ',' and depth == 0:
+                        arg = inner[start:k].strip()
+                        if arg:
+                            args.append(arg)
+                        start = k + 1
+                arg = inner[start:].strip()
+                if arg:
+                    args.append(arg)
+                parsed_args = []
+                for a in args:
+                    if a.startswith('"') and a.endswith('"'):
+                        parsed_args.append(a[1:-1])
+                    elif a.lstrip("-").isdigit():
+                        parsed_args.append(int(a))
+                    elif _looks_like_float(a):
+                        parsed_args.append(float(a))
+                    else:
+                        sub, _ = parse_expr_str(a)
+                        parsed_args.append(sub)
+                return (ctor, *parsed_args), len(t)
+        return None, 0
+
+    for name, rhs in let_defs:
+        let_env[name], _ = parse_expr_str(rhs)
+    node, _ = parse_expr_str(s)
+    return node
+
+
+COMMUTATIVE_OPS = {"Add", "Mul"}
+
+
+def _unify(body, template, bindings: dict) -> Optional[dict]:
+    """Structural unification with commutativity. `template`'s Cap leaves
+    are wildcards that bind to a Cap/Lit leaf in the body (i.e., a captured
+    scalar — *not* a per-element tensor In/Out value).
+
+    Returns updated bindings on success, None on failure.
+    """
+    if template is None or body is None:
+        return None
+    # Template Cap → wildcard, but only matches Cap/Lit body leaves
+    # (captured outer scalars). Refuse to bind to per-element In(_)/Out(_)
+    # so that axpy `out + alpha*x` doesn't spuriously match a gemv-shaped
+    # body `out + a*b`.
+    if isinstance(template, tuple) and template[0] == "Cap":
+        if not (isinstance(body, tuple) and body[0] in ("Cap", "Lit")):
+            return None
+        name = template[1]
+        if name in bindings:
+            return bindings if bindings[name] == body else None
+        bindings = dict(bindings)
+        bindings[name] = body
+        return bindings
+    # Some front-end/canonicalization paths erase explicit multiplication by
+    # one before the matcher sees the linalg body. Let a template term like
+    # `In(k) * Cap("%w")` match a bare `In(k)` by binding `%w = 1.0`.
+    # This keeps 3x3 filters with unit coefficients (Sobel/Laplacian/emboss)
+    # on the same cudnnConvolution2D_9tap path as the fully weighted case.
+    if isinstance(template, tuple) and template[0] == "Mul" and len(template) == 3:
+        for cap_idx, term_idx in ((1, 2), (2, 1)):
+            cap = template[cap_idx]
+            term = template[term_idx]
+            if isinstance(cap, tuple) and cap[0] == "Cap":
+                bound = _unify(body, term, bindings)
+                if bound is not None:
+                    bound = _unify(("Lit", 1.0), cap, bound)
+                    if bound is not None:
+                        return bound
+    # Otherwise structural equality.
+    if not (isinstance(template, tuple) and isinstance(body, tuple)):
+        return bindings if template == body else None
+    if template[0] != body[0]:
+        return None
+    if len(template) != len(body):
+        return None
+    # Leaf variants compare directly.
+    if template[0] in {"In", "Out", "Lit"}:
+        return bindings if template == body else None
+    children_t = template[1:]
+    children_b = body[1:]
+    if template[0] in COMMUTATIVE_OPS and len(children_t) == 2:
+        # Try both orderings.
+        b1 = _unify(children_b[0], children_t[0], bindings)
+        if b1 is not None:
+            b1 = _unify(children_b[1], children_t[1], b1)
+            if b1 is not None:
+                return b1
+        b2 = _unify(children_b[0], children_t[1], bindings)
+        if b2 is not None:
+            b2 = _unify(children_b[1], children_t[0], b2)
+            if b2 is not None:
+                return b2
+        return None
+    # Non-commutative: zip-recurse.
+    for tc, bc in zip(children_t, children_b):
+        bindings = _unify(bc, tc, bindings)
+        if bindings is None:
+            return None
+    return bindings
+
+
+def _flatten_addition_chain(node):
+    """Walk down ('Add', l, r) nodes, return a flat list of leaf summands
+    in source order.
+
+    `((a + b) + c) + d` flattens to `[a, b, c, d]` regardless of bracketing.
+    Uses a recursive walk to preserve source order naturally — a stack-based
+    pre-order would visit rhs first and need reversing afterwards.
+    """
+    out: list = []
+    def walk(n):
+        if isinstance(n, tuple) and len(n) == 3 and n[0] == 'Add':
+            walk(n[1])
+            walk(n[2])
+        else:
+            out.append(n)
+    walk(node)
+    return out
+
+
+def _try_factor_summand(s):
+    """Recognise s as 'Lit(c) * X' or 'X * Lit(c)' for any X. Return (X, c)
+    or None if s is not a factorable mul.
+    """
+    if not (isinstance(s, tuple) and len(s) == 3 and s[0] == 'Mul'):
+        return None
+    a, b = s[1], s[2]
+    if isinstance(a, tuple) and a[0] == 'Lit' and isinstance(a[1], (int, float)):
+        return (b, float(a[1]))
+    if isinstance(b, tuple) and b[0] == 'Lit' and isinstance(b[1], (int, float)):
+        return (a, float(b[1]))
+    return None
+
+
+def _factor_redundant_muls(ast):
+    """Fold `c1*x + c2*x + ...` summands sharing a common factor x into
+    `(c1+c2+...)*x`. Returns the rewritten tuple AST.
+
+    Used by `body_matches_template` as a fallback when syntactic unification
+    against a template fails. Specifically targets polybenchGpu's extracted
+    conv3d body, which has 15 muls but only 11 unique input positions — the
+    same input appears in multiple muls with different literal coefficients.
+
+    Linear time in the number of summands; deterministic. Replaces an
+    earlier egglog-driven attempt that blew up exponentially on bodies of
+    this size — see the note above `body_matches_template`.
+    """
+    summands = _flatten_addition_chain(ast)
+    if len(summands) < 2:
+        return ast
+
+    # Group factorable summands by their X subtree. `factor_groups` keys
+    # are the X tuples (which are hashable since they're nested tuples of
+    # hashable leaves). `insertion_order` preserves first-appearance order
+    # so the rebuilt AST is deterministic.
+    factor_groups: dict = {}
+    insertion_order: list = []
+    passthrough: list = []
+    any_combined = False
+    for s in summands:
+        pair = _try_factor_summand(s)
+        if pair is None:
+            passthrough.append(s)
+            continue
+        X, coeff = pair
+        if X not in factor_groups:
+            factor_groups[X] = 0.0
+            insertion_order.append(X)
+        else:
+            any_combined = True
+        factor_groups[X] += coeff
+
+    # Fast path: if no input was multiplied by more than one constant, no
+    # combining happened — return the original AST unchanged. Avoids
+    # gratuitously rewriting clean bodies (which would change the
+    # bracketing and break downstream binding extraction).
+    if not any_combined:
+        return ast
+
+    new_summands = [
+        ('Mul', ('Lit', factor_groups[X]), X) for X in insertion_order
+    ] + passthrough
+
+    # Left-fold the list back into an Add tree.
+    result = new_summands[0]
+    for s in new_summands[1:]:
+        result = ('Add', result, s)
+    return result
+
+
+def body_matches_template(body: Term, template: Term) -> Optional[dict]:
+    """Check whether `body` matches `template`, with Cap names in the template
+    as wildcards. Returns a binding dict on success, None on failure.
+
+    First tries direct syntactic unification (with commutativity baked into
+    `_unify`). If that fails, runs `_factor_redundant_muls` on the body AST
+    — which collapses `c1*x + c2*x + ...` patterns into one mul per unique
+    input — and retries. This is what lets polybenchGpu's conv3d body
+    (15 muls, 11 unique inputs) match the `_conv3d_11pt_weighted` template.
+    """
+    tmpl_ast = _parse_term(_term_repr(template))
+    body_ast = _parse_term(_term_repr(body))
+    direct = _unify(body_ast, tmpl_ast, {})
+    if direct is not None:
+        return direct
+    factored = _factor_redundant_muls(body_ast)
+    if factored is body_ast:
+        return None  # nothing to fold; second attempt would be identical
+    return _unify(factored, tmpl_ast, {})
+
+
+def _ast_is_lit(node, value: float, eps: float = 1.0e-12) -> bool:
+    return (
+        isinstance(node, tuple)
+        and len(node) == 2
+        and node[0] == "Lit"
+        and isinstance(node[1], (int, float))
+        and abs(float(node[1]) - value) <= eps
+    )
+
+
+def _ast_is_zero(node) -> bool:
+    return _ast_is_lit(node, 0.0)
+
+
+def _ast_match_mul_pair(node) -> Optional[tuple[object, object]]:
+    if isinstance(node, tuple) and len(node) == 3 and node[0] == "Mul":
+        return node[1], node[2]
+    return None
+
+
+def _ast_match_mul_lit(node, value: float) -> Optional[object]:
+    pair = _ast_match_mul_pair(node)
+    if pair is None:
+        return None
+    a, b = pair
+    if _ast_is_lit(a, value):
+        return b
+    if _ast_is_lit(b, value):
+        return a
+    return None
+
+
+def _ast_match_abs(node) -> Optional[object]:
+    """Recognize select(x < 0, 0 - x, x)."""
+    if not (isinstance(node, tuple) and len(node) == 4 and node[0] == "Select"):
+        return None
+    pred, true_value, false_value = node[1], node[2], node[3]
+    if not (
+        isinstance(pred, tuple)
+        and len(pred) == 4
+        and pred[0] == "Cmp"
+        and pred[1] == "olt"
+        and _ast_is_zero(pred[3])
+    ):
+        return None
+    x = pred[2]
+    neg_x = ("Sub", ("Lit", 0.0), x)
+    if true_value == neg_x and false_value == x:
+        return x
+    return None
+
+
+def _ast_match_minmod(node) -> Optional[tuple[object, object]]:
+    """Recognize minmod(a, b) in lowered cmp/select/abs form."""
+    if not (isinstance(node, tuple) and len(node) == 4 and node[0] == "Select"):
+        return None
+    pred, true_value, false_value = node[1], node[2], node[3]
+    if not _ast_is_zero(true_value):
+        return None
+    if not (
+        isinstance(pred, tuple)
+        and len(pred) == 4
+        and pred[0] == "Cmp"
+        and pred[1] == "ole"
+        and _ast_is_zero(pred[3])
+    ):
+        return None
+    pair = _ast_match_mul_pair(pred[2])
+    if pair is None:
+        return None
+    a, b = pair
+    if not (
+        isinstance(false_value, tuple)
+        and len(false_value) == 4
+        and false_value[0] == "Select"
+    ):
+        return None
+    inner_pred, inner_true, inner_false = false_value[1], false_value[2], false_value[3]
+    if not (
+        isinstance(inner_pred, tuple)
+        and len(inner_pred) == 4
+        and inner_pred[0] == "Cmp"
+        and inner_pred[1] == "olt"
+    ):
+        return None
+    abs_l = _ast_match_abs(inner_pred[2])
+    abs_r = _ast_match_abs(inner_pred[3])
+    if abs_l == a and abs_r == b and inner_true == a and inner_false == b:
+        return a, b
+    if abs_l == b and abs_r == a and inner_true == b and inner_false == a:
+        return b, a
+    return None
+
+
+def _ast_match_slope_minmod_args(a, b) -> Optional[tuple[object, object, object]]:
+    """Recognize minmod(center - left, right - center)."""
+    if not (
+        isinstance(a, tuple)
+        and len(a) == 3
+        and a[0] == "Sub"
+        and isinstance(b, tuple)
+        and len(b) == 3
+        and b[0] == "Sub"
+    ):
+        return None
+    center, left = a[1], a[2]
+    right, center2 = b[1], b[2]
+    if center == center2:
+        return left, center, right
+    return None
+
+
+def _semantic_external_ast(ast, g: GenericBody):
+    """Normalize selected elementwise scalar trees to semantic External nodes.
+
+    This deliberately runs only as a fallback after exact composition matching.
+    It is for pure all-parallel elementwise bodies where recognizing a
+    semantic root is enough to emit one fused kernel launch or leave residual
+    Linalg. Reductions/contractions/stencils stay on the existing structural
+    matcher path.
+    """
+    minmod_args = _ast_match_minmod(ast)
+    if minmod_args is not None:
+        a, b = minmod_args
+        slope = _ast_match_slope_minmod_args(a, b)
+        if slope is None:
+            # minmod is symmetric, so try the swapped argument order too.
+            slope = _ast_match_slope_minmod_args(b, a)
+        if slope is not None:
+            return ("External", "slope_minmod", slope)
+        return ("External", "minmod", minmod_args)
+
+    if isinstance(ast, tuple) and len(ast) == 4 and ast[0] == "Select":
+        pred, true_value, false_value = ast[1], ast[2], ast[3]
+        if (
+            isinstance(pred, tuple)
+            and pred[0] == "Cap"
+            and true_value == ("In", 0)
+            and isinstance(false_value, tuple)
+            and len(false_value) == 3
+            and false_value[0] == "Sub"
+        ):
+            doubled = _ast_match_mul_lit(false_value[1], 2.0)
+            if (
+                doubled == ("In", 1)
+                and false_value[2] == ("In", 2)
+                and len(g.ins_arg_names) >= 3
+            ):
+                return ("External", "sp2_select_inputs", (pred, true_value, doubled))
+    return None
+
+
+def match_elementwise_semantic(
+    g: GenericBody,
+    body_term: Term,
+    form: str = "tensor",
+) -> Optional[CompositionEntry]:
+    """Fallback semantic recognition for all-parallel elementwise bodies."""
+    if form != "tensor":
+        return None
+    if not g.iterator_types or any(it != "parallel" for it in g.iterator_types):
+        return None
+    if len(g.outs_arg_names) != 1:
+        return None
+    ast = _parse_term(_term_repr(body_term))
+    semantic = _semantic_external_ast(ast, g)
+    if semantic is None:
+        return None
+    _, name, _args = semantic
+    if name == "slope_minmod" and len(g.ins_arg_names) == 3:
+        return CompositionEntry(
+            name="hypar_slope_minmod",
+            steps=[CompositionStep(
+                body=body_term,
+                num_ins=3,
+                num_outs=1,
+                parallel_dim_count=len(g.iterator_types),
+                reduction_dim_count=0,
+            )],
+            form=form,
+        )
+    if name == "sp2_select_inputs" and len(g.ins_arg_names) == 3:
+        return CompositionEntry(
+            name="exasp2_select_square_inputs",
+            steps=[CompositionStep(
+                body=body_term,
+                num_ins=3,
+                num_outs=1,
+                parallel_dim_count=len(g.iterator_types),
+                reduction_dim_count=0,
+            )],
+            form=form,
+        )
+    return None
+
+
+def _iter_ast_subterms(ast, path: tuple[int, ...] = ()):
+    """Yield `(path, sub_ast)` for semantic subexpression discovery.
+
+    Paths use child indexes in the tuple AST produced by `_parse_term`. The
+    operator tag is index 0 and is never traversed as a child. For comparisons,
+    index 1 is the predicate string and is also skipped.
+    """
+    yield path, ast
+    if not isinstance(ast, tuple):
+        return
+    op = ast[0] if ast else None
+    if op in ("Add", "Mul", "Sub", "Div") and len(ast) == 3:
+        child_indices = (1, 2)
+    elif op in ("Sqrt", "Abs", "Exp", "Tanh") and len(ast) == 2:
+        child_indices = (1,)
+    elif op == "Select" and len(ast) == 4:
+        child_indices = (1, 2, 3)
+    elif op == "Cmp" and len(ast) == 4:
+        child_indices = (2, 3)
+    else:
+        child_indices = ()
+    for idx in child_indices:
+        yield from _iter_ast_subterms(ast[idx], path + (idx,))
+
+
+def elementwise_semantic_candidates(
+    g: GenericBody,
+    body_term: Term,
+    body_index: int,
+    form: str = "tensor",
+) -> list[SemanticCandidate]:
+    """Return semantic nodes recognized in an all-parallel elementwise body.
+
+    This generalizes `match_elementwise_semantic`: instead of only asking
+    whether the *whole* body can become one known semantic entry, walk every
+    scalar subterm and report matches. The rewrite stage can later decide
+    whether a partial match is worth splitting/lowering.
+    """
+    if form != "tensor":
+        return []
+    if not g.iterator_types or any(it != "parallel" for it in g.iterator_types):
+        return []
+    if len(g.outs_arg_names) != 1:
+        return []
+
+    root = _parse_term(_term_repr(body_term))
+    candidates: list[SemanticCandidate] = []
+    seen: set[tuple[str, tuple[int, ...]]] = set()
+    for path, sub_ast in _iter_ast_subterms(root):
+        semantic = _semantic_external_ast(sub_ast, g)
+        if semantic is None:
+            continue
+        _, name, args = semantic
+        key = (name, path)
+        if key in seen:
+            continue
+        seen.add(key)
+        candidates.append(SemanticCandidate(
+            name=name,
+            body_indices=(body_index,),
+            match_kind="whole" if path == () else "subterm",
+            coverage="whole" if path == () else "partial",
+            bindings={"args": args},
+            defaults=(),
+            subterm_path=path,
+            source="elementwise_external",
+        ))
+    return candidates
+
+
+def _weighted_sum_template(ntaps: int) -> Term:
+    body = Term.In(0) * T_cap("%w0")
+    for i in range(1, ntaps):
+        body = body + Term.In(i) * T_cap(f"%w{i}")
+    return body
+
+
+def _match_weighted_conv2d_ntap_body(g: GenericBody, body: Term) -> Optional[dict]:
+    """Dynamic scalar-body matcher for odd-square 2D weighted stencils.
+
+    This checks only the linalg body and iterator shape. The caller in
+    kernel_match_rewrite.py separately proves the matched operands are shifted
+    subviews from one base image before emitting the cuDNN launch.
+    """
+    ntaps = len(g.ins_arg_names)
+    if ntaps < 9:
+        return None
+    width = math.isqrt(ntaps)
+    if width * width != ntaps or width % 2 == 0:
+        return None
+    if len(g.outs_arg_names) != 1:
+        return None
+    if sum(1 for it in g.iterator_types if it == "parallel") != 2:
+        return None
+    if any(it == "reduction" for it in g.iterator_types):
+        return None
+
+    # Avoid recursive egglog/string-repr unification for large filters: repeated
+    # constants make egglog print alias bindings like `_Term_1 = ...`, which the
+    # lightweight Term parser intentionally does not model. For this family we
+    # only need to prove that the yielded scalar is a sum of N independent
+    # scalar-weighted input taps.
+    TapSet = frozenset[int]
+    env: dict[str, tuple[str, TapSet]] = {}
+    for i, name in enumerate(g.ins_arg_names):
+        env[name] = ("tap", frozenset({i}))
+    for name in g.outs_arg_names:
+        env[name] = ("other", frozenset())
+    for cap in g.captures:
+        env[cap] = ("scalar", frozenset())
+
+    def classify(tok: str) -> tuple[str, TapSet]:
+        tok = tok.strip()
+        if tok in env:
+            return env[tok]
+        if tok.startswith("%"):
+            return ("scalar", frozenset())
+        try:
+            float(tok)
+            return ("scalar", frozenset())
+        except ValueError:
+            return ("other", frozenset())
+
+    for line in g.body_lines:
+        m = re.match(
+            r"(%[\w_\-]+)\s*=\s*(\w+\.\w+)\s+(.*?)\s*:\s*\S+",
+            line.strip(),
+        )
+        if not m:
+            continue
+        result, op, args_part = m.group(1), m.group(2), m.group(3)
+        args = [s.strip() for s in args_part.split(",")]
+        op_key = _OP_PATTERNS.get(op, op)
+        if op_key == "transparent" and args:
+            env[result] = classify(args[0])
+        elif op_key == "mul" and len(args) >= 2:
+            a_kind, a_taps = classify(args[0])
+            b_kind, b_taps = classify(args[1])
+            if a_kind == "tap" and b_kind == "scalar":
+                env[result] = ("tap", a_taps)
+            elif a_kind == "scalar" and b_kind == "tap":
+                env[result] = ("tap", b_taps)
+            else:
+                env[result] = ("other", frozenset())
+        elif op_key == "add" and len(args) >= 2:
+            a_kind, a_taps = classify(args[0])
+            b_kind, b_taps = classify(args[1])
+            if a_kind == "tap" and b_kind == "tap" and a_taps.isdisjoint(b_taps):
+                env[result] = ("tap", a_taps | b_taps)
+            else:
+                env[result] = ("other", frozenset())
+        else:
+            env[result] = ("other", frozenset())
+
+    if not g.yield_values:
+        return None
+    kind, taps = classify(g.yield_values[0])
+    if kind == "tap" and taps == frozenset(range(ntaps)):
+        return {}
+    return None
+
+
+def _is_guarded_im2col_body(g: GenericBody) -> bool:
+    """Return true for the raised Darknet im2col workspace-fill body.
+
+    This intentionally checks structural markers rather than exact SSA names:
+    the scalar Term encoder cannot model the scf.if/memref.load payload, but
+    the surrounding composition and launch rewriter recover the actual operands
+    from the matched body text.
+    """
+    if len(g.ins_arg_names) != 0 or len(g.outs_arg_names) != 1:
+        return False
+    if sum(1 for it in g.iterator_types if it == "parallel") != 3:
+        return False
+    if any(it == "reduction" for it in g.iterator_types):
+        return False
+    body = "\n".join(g.body_lines)
+    required = [
+        "linalg.index 0",
+        "linalg.index 1",
+        "linalg.index 2",
+        "scf.if",
+        "memref.load",
+        "arith.cmpi slt",
+        "arith.cmpi sge",
+        "arith.select",
+        "scf.yield",
+    ]
+    if not all(tok in body for tok in required):
+        return False
+    # The im2col linearization decomposes the workspace row with div/rem by
+    # the kernel size and computes the padded input coordinates from stride
+    # and pad. These checks keep the predicate from firing on arbitrary
+    # guarded loads.
+    return ("arith.remsi" in body and "arith.divsi" in body and
+            body.count("scf.yield") >= 2)
+
+
+def _is_dft1d_z2z_body(g: GenericBody) -> bool:
+    """Return true for the raised direct 1D complex DFT reduction.
+
+    This is a semantic gateway to cuFFT. We do not try to prove arbitrary FFT
+    algorithms here; this only recognizes the canonical direct-DFT shape:
+      out[k][component] += select(component == 0,
+                                  re*cos - im*sin,
+                                  re*sin + im*cos)
+    with iterator domain (k, component, n).
+    """
+    if len(g.ins_arg_names) != 2 or len(g.outs_arg_names) != 1:
+        return False
+    if sum(1 for it in g.iterator_types if it == "parallel") != 2:
+        return False
+    if sum(1 for it in g.iterator_types if it == "reduction") != 1:
+        return False
+    if len(g.yield_values) != 1:
+        return False
+    body = "\n".join(g.body_lines)
+    required = [
+        "linalg.index 0",
+        "linalg.index 1",
+        "linalg.index 2",
+        "math.cos",
+        "math.sin",
+        "arith.cmpi eq",
+        "arith.select",
+        "arith.addf",
+        "arith.mulf",
+        "arith.subf",
+    ]
+    if not all(tok in body for tok in required):
+        return False
+    return body.count("math.cos") == 1 and body.count("math.sin") == 1
+
+
+def _check_scalar_relation(entry: CompositionEntry,
+                           body_objs: list[GenericBody],
+                           start: int,
+                           bindings: dict) -> bool:
+    """Validate optional cross-generic scalar relationships.
+
+    These checks intentionally stay narrow. Most matching remains local to
+    linalg.generic bodies; this hook is for cases where a composition variant
+    would otherwise be ambiguous without a scalar use-def proof.
+    """
+    if entry.scalar_relation is None:
+        return True
+    if entry.scalar_relation == "softmax_out_mul_inv_sum":
+        inv_bound = bindings.get("%inv_sum")
+        if not (isinstance(inv_bound, tuple) and len(inv_bound) == 2 and
+                inv_bound[0] == "Cap"):
+            return False
+        # Step 1 is the multi-yield exp+sum generic. Its second tensor/scalar
+        # result is the accumulated softmax denominator.
+        if start + 1 >= len(body_objs):
+            return False
+        sum_results = body_objs[start + 1].result_names or []
+        if len(sum_results) < 2:
+            return False
+        expected = Term.Lit(1.0) / Term.Cap(sum_results[1])
+        scalar_defs = body_objs[start].scalar_defs or {}
+        actual = scalar_defs.get(inv_bound[1])
+        return actual is not None and equivalent(actual, expected)
+    return False
+
+
+def match_composition(
+    body_objs: list[GenericBody],
+    body_terms: list[Term],
+    compositions: list[CompositionEntry],
+    start: int = 0,
+    body_forms: list[str] | None = None,
+) -> Optional[tuple[CompositionEntry, int, dict]]:
+    """If a contiguous run of generics starting at index `start` matches a
+    composition's full sequence (body + shape gates), return (entry,
+    start, bindings). Otherwise None.
+
+    Greedy: tries longest compositions first.
+
+    `body_forms` (optional): per-body "tensor" / "memref" tag. If given, an
+    entry only fires when every step's form is compatible (entry.form ==
+    body_form, or entry.form == "any"). Keeps the matcher from picking a
+    tensor-only library entry for a memref-form body (which would later
+    fail in --lower-kernel-launch with a type mismatch).
+    """
+    for entry in compositions:
+        n = len(entry.steps)
+        if start + n > len(body_objs):
+            continue
+        if body_forms is not None and entry.form != "any":
+            forms_in_run = body_forms[start : start + n]
+            if any(f != entry.form for f in forms_in_run):
+                continue
+        merged: dict = {}
+        ok = True
+        for j in range(n):
+            step = entry.steps[j]
+            g = body_objs[start + j]
+            if entry.element_type is not None:
+                scalar_types = set(re.findall(
+                    r"(?:arith\.[A-Za-z0-9_]+|linalg\.yield)\b[^:]*:\s*([A-Za-z0-9]+)",
+                    "\n".join(g.body_lines),
+                ))
+                if entry.element_type not in scalar_types:
+                    ok = False
+                    break
+            # Shape gates.
+            if step.num_ins is not None and step.num_ins != len(g.ins_arg_names):
+                ok = False
+                break
+            if step.num_outs is not None and step.num_outs != len(g.outs_arg_names):
+                ok = False
+                break
+            if step.reduction_dim_count is not None:
+                red = sum(1 for it in g.iterator_types if it == "reduction")
+                if red != step.reduction_dim_count:
+                    ok = False
+                    break
+            if step.parallel_dim_count is not None:
+                par = sum(1 for it in g.iterator_types if it == "parallel")
+                if par != step.parallel_dim_count:
+                    ok = False
+                    break
+            # Body match. Two modes:
+            #   * Single-yield (the common case): step.body is a single Term;
+            #     body_terms[i] is a single Term; one unify call.
+            #   * Multi-yield (softmax-style fused exp+sum, etc.): step.body_per_yield
+            #     is a list of Terms — one per yield position; the body's
+            #     yield Terms come from encode_body_yields stored in
+            #     body_yields[i]. We unify each (body_yield, template_yield) pair
+            #     and merge bindings.
+            if step.special is not None:
+                if step.special == "guarded_im2col":
+                    if not _is_guarded_im2col_body(g):
+                        ok = False
+                        break
+                    b = {}
+                elif step.special == "weighted_conv2d_ntap":
+                    b = _match_weighted_conv2d_ntap_body(
+                        g, body_terms[start + j]
+                    )
+                    if b is None:
+                        ok = False
+                        break
+                elif step.special == "dft1d_z2z":
+                    if not _is_dft1d_z2z_body(g):
+                        ok = False
+                        break
+                    b = {}
+                else:
+                    ok = False
+                    break
+            elif step.body_per_yield is not None:
+                body_yields_here = body_objs[start + j].__dict__.get(
+                    "_yield_terms_cache"
+                )
+                if body_yields_here is None:
+                    body_yields_here = encode_body_yields(body_objs[start + j])
+                    body_objs[start + j]._yield_terms_cache = body_yields_here
+                if len(body_yields_here) != len(step.body_per_yield):
+                    ok = False; break
+                step_bindings: dict = {}
+                step_ok = True
+                for body_t, tmpl_t in zip(body_yields_here, step.body_per_yield):
+                    bm = body_matches_template(body_t, tmpl_t)
+                    if bm is None:
+                        step_ok = False; break
+                    for k, v in bm.items():
+                        if k in step_bindings and step_bindings[k] != v:
+                            step_ok = False; break
+                        step_bindings[k] = v
+                    if not step_ok:
+                        break
+                if not step_ok:
+                    ok = False; break
+                b = step_bindings
+            else:
+                b = body_matches_template(body_terms[start + j], step.body)
+                if b is None:
+                    ok = False
+                    break
+            for k, v in b.items():
+                if k in merged and merged[k] != v:
+                    ok = False
+                    break
+                merged[k] = v
+            if not ok:
+                break
+        if ok:
+            if not _check_scalar_relation(entry, body_objs, start, merged):
+                continue
+            return entry, start, merged
+    return None
+
+
+def composition_semantic_candidates(
+    body_objs: list[GenericBody],
+    body_terms: list[Term],
+    compositions: list[CompositionEntry],
+    start: int = 0,
+    body_forms: list[str] | None = None,
+) -> list[SemanticCandidate]:
+    """Try every registered composition at `start` and return all hits.
+
+    This is the candidate-producing version of `match_composition`. It calls
+    the existing matcher with a single entry at a time, preserving all of its
+    shape gates, special predicates, scalar-relation checks, and form checks.
+    """
+    out: list[SemanticCandidate] = []
+    for entry in compositions:
+        n = len(entry.steps)
+        if start + n > len(body_terms):
+            continue
+        if any(t is None for t in body_terms[start : start + n]):
+            continue
+        m = match_composition(
+            body_objs, body_terms, [entry], start=start, body_forms=body_forms
+        )
+        if m is None:
+            continue
+        matched_entry, _, bindings = m
+        out.append(SemanticCandidate(
+            name=matched_entry.name,
+            body_indices=tuple(range(start, start + n)),
+            match_kind="composition" if n > 1 else "whole",
+            coverage="whole",
+            bindings=bindings,
+            entry=matched_entry,
+            defaults=(),
+            source="composition_library",
+        ))
+    return out
+
+
+def _completion_candidates(candidates: list[SemanticCandidate]) -> list[SemanticCandidate]:
+    """Derive specialization/completion candidates from semantic matches.
+
+    These are not separate scalar patterns. They express the relation between
+    a recognized semantic node and a more general backend-capable node. The
+    first concrete case is a 7-point 3D average stencil as a sparse 3x3x3
+    convolution, with the 20 missing taps explicitly defaulted to zero.
+    """
+    out: list[SemanticCandidate] = []
+    for cand in candidates:
+        if cand.name == "miniamr_average_7pt_tensor" and cand.coverage == "whole":
+            out.append(SemanticCandidate(
+                name="conv3d_sparse_3x3x3",
+                body_indices=cand.body_indices,
+                match_kind="completion",
+                coverage="whole",
+                bindings=dict(cand.bindings),
+                entry=None,
+                defaults=(
+                    ("missing_filter_taps", "20 zeros"),
+                    ("nonzero_filter_taps", "center + six axial neighbors"),
+                    ("tap_scale", "1/7"),
+                ),
+                source=cand.name,
+            ))
+    return out
+
+
+def enumerate_semantic_candidates(
+    body_objs: list[GenericBody],
+    body_terms: list[Optional[Term]],
+    compositions: list[CompositionEntry],
+    start: int = 0,
+    body_forms: list[str] | None = None,
+) -> list[SemanticCandidate]:
+    """Enumerate semantic candidates for a linalg body index.
+
+    This is the architecture-facing API: it lists exact/composition matches,
+    subterm semantic nodes, and completion/specialization candidates. Lowering
+    selection happens after this step.
+    """
+    if start >= len(body_objs) or start >= len(body_terms):
+        return []
+    body_term = body_terms[start]
+    if body_term is None:
+        return []
+
+    candidates = composition_semantic_candidates(
+        body_objs, body_terms, compositions, start=start, body_forms=body_forms
+    )
+    form = body_forms[start] if body_forms is not None else "tensor"
+    candidates.extend(elementwise_semantic_candidates(
+        body_objs[start], body_term, start, form=form
+    ))
+    candidates.extend(_completion_candidates(candidates))
+    return candidates
+
+
+# ---------------------------------------------------------------------------
+# Original single-body matcher.
+# ---------------------------------------------------------------------------
+
+def match(t: Term, entries: list[LibraryEntry],
+          want_ins: int, want_outs: int,
+          want_maps: list[str], want_iters: list[str]) -> Optional[LibraryEntry]:
+    """Match a body Term against the library; return the first matching entry."""
+    for e in entries:
+        if e.num_ins != want_ins or e.num_outs != want_outs:
+            continue
+        if e.indexing_maps != want_maps or e.iterator_types != want_iters:
+            continue
+        if equivalent(e.canonical_body, t):
+            return e
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Driver.
+# ---------------------------------------------------------------------------
+
+def main():
+    if len(sys.argv) < 2:
+        print("usage: kernel_match.py  [test_kernel.mlir]")
+        sys.exit(1)
+
+    root = Path(sys.argv[1])
+    print(f"Building library from {root}...")
+    lib = build_library_from_dir(root)
+    print(f"Library has {len(lib)} unique entries.")
+    counts: dict[str, int] = {}
+    for e in lib:
+        counts[e.source_kernel] = counts.get(e.source_kernel, 0) + 1
+    print("Entries per source kernel:")
+    for k in sorted(counts):
+        print(f"  {k}: {counts[k]}")
+
+    if len(sys.argv) >= 3:
+        # Match every generic in the test file against the library.
+        text = Path(sys.argv[2]).read_text()
+        gens = parse_generics(text)
+        print(f"\nTesting {sys.argv[2]} ({len(gens)} generics):")
+        for i, g in enumerate(gens):
+            t = encode_body(g)
+            hit = match(t, lib, len(g.ins_arg_names), len(g.outs_arg_names),
+                        g.indexing_maps, g.iterator_types)
+            label = hit.name if hit else "NO_MATCH"
+            print(f"  generic #{i} -> {label}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/correctness/kernel_match_coverage.py b/scripts/correctness/kernel_match_coverage.py
new file mode 100644
index 000000000000..af7c389047f6
--- /dev/null
+++ b/scripts/correctness/kernel_match_coverage.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""Cross-coverage analysis: for every (kernel, body), what library entries match?
+
+This tells us how many distinct "library kernels" we actually need to cover
+the 26 lowering-clean PolyBench kernels — and where sharing happens.
+"""
+import sys
+from pathlib import Path
+SCRIPT_DIR = Path(__file__).resolve().parent
+sys.path.insert(0, str(SCRIPT_DIR))
+from kernel_match import (
+    build_library_from_dir, parse_generics, encode_body, match,
+)
+
+root = Path("/tmp/polybench_new")
+print(f"Building library...", flush=True)
+lib = build_library_from_dir(root)
+print(f"Library has {len(lib)} entries.\n", flush=True)
+
+# Now cross-match: for each body in each kernel, which library entry hits?
+rows = []
+for f in sorted(root.glob("*_debuf.mlir")):
+    text = f.read_text()
+    try:
+        gens = parse_generics(text)
+    except Exception:
+        continue
+    kernel = f.stem.replace("_debuf", "")
+    for i, g in enumerate(gens):
+        try:
+            t = encode_body(g)
+        except Exception as e:
+            rows.append((kernel, i, "ENCODE_FAIL"))
+            continue
+        hit = match(t, lib, len(g.ins_arg_names), len(g.outs_arg_names),
+                    g.indexing_maps, g.iterator_types)
+        rows.append((kernel, i, hit.name if hit else "NO_MATCH"))
+
+# Group by kernel.
+from collections import defaultdict
+matches = defaultdict(list)
+for k, i, name in rows:
+    matches[k].append((i, name))
+
+print(f"{'kernel':<20} {'generic#':<10} {'matched library entry'}")
+print("-" * 80)
+for k in sorted(matches):
+    for i, name in matches[k]:
+        print(f"{k:<20} #{i:<9} {name}")
+
+# Summary
+total = len(rows)
+matched = sum(1 for _, _, n in rows if n not in ("NO_MATCH", "ENCODE_FAIL"))
+enc_fail = sum(1 for _, _, n in rows if n == "ENCODE_FAIL")
+no_match = sum(1 for _, _, n in rows if n == "NO_MATCH")
+print(f"\n{matched}/{total} bodies match a library entry "
+      f"({no_match} no-match, {enc_fail} encoder-fail).")
diff --git a/scripts/correctness/kernel_match_rewrite.py b/scripts/correctness/kernel_match_rewrite.py
new file mode 100755
index 000000000000..f04b5d529ea1
--- /dev/null
+++ b/scripts/correctness/kernel_match_rewrite.py
@@ -0,0 +1,3028 @@
+#!/usr/bin/env python3
+"""CLI: take MLIR text in, emit MLIR with matched linalg.generics replaced
+by `kernel.launch @(operands)` ops.
+
+This is the Phase-1 deliverable of the kernel matcher: a textual rewrite
+that produces a polygeist-opt-parseable MLIR module with `kernel.launch`
+ops at every linalg.generic that the matcher recognized.
+
+Usage:
+  kernel_match_rewrite.py    # prints rewritten MLIR to stdout
+  kernel_match_rewrite.py  --dry-run  # report matches, no rewrite
+
+Phase-2 (ABI lowering) will turn each `kernel.launch @cublasDgemm(...)`
+into a `func.call @cublasDgemm(handle, ...)` matching the real cuBLAS
+ABI. That step is *not* in this script.
+"""
+from __future__ import annotations
+import argparse
+import math
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+from kernel_match import (
+    parse_constants, parse_generics, encode_body,
+    match_composition, composition_library,
+    match_elementwise_semantic, enumerate_semantic_candidates,
+    _AFFINE_MAP_RE,
+)
+
+
+# Keep this in sync with lib/polygeist/Passes/LowerKernelLaunchToCuBLAS.cpp.
+# The matcher may semantically recognize many more kernels than the ABI/runtime
+# layer can execute today. Only emit kernel.launch for symbols that the lowering
+# pass currently knows how to turn into a runtime call; leave the rest as
+# residual Linalg so the normal MLIR lowering path preserves semantics.
+ABI_LOWERABLE_KERNELS = {
+    "cublasDgemm",
+    "cublasDgemm_simple",
+    "cublasDgemm_alpha_only",
+    "cublasSgemm_broadcast3d_simple",
+    "cublasSgemm_broadcast3d_memref",
+    "cublasDgeam_scale2D",
+    "memset_zero_2D",
+    "memset_zero_2D_f32",
+    "memset_zero_1D",
+    "memset_zero_1D_f32",
+    "cublasDgemv",
+    "cublasDgemv_T",
+    "cublasSgemv",
+    "cublasSgemv_T",
+    "cublasDgemm_outer_product",
+    "cublasSgemm_strided_batched_broadcast_rhs",
+    "cublasDgemv_alpha",
+    "cublasDaxpby",
+    "cublasDaxpy_unit",
+    "cublasDger_rank2",
+    "cudnnConvolution2D_9tap",
+    "cudnnConvolution2D_9tap_f32",
+    "cudnnConvolution2D_9tap_f16",
+    "cudnnConvolution2D_9tap_bf16",
+    "cudnnConvolution2D_9tap_i32",
+    "cudnnConvolution2D_25tap",
+    "cudnnConvolution2D_25tap_f32",
+    "cudnnConvolution2D_ntap",
+    "cudnnConvolution2D_ntap_f32",
+    "cudnnConvolution2D_ntap_tensor",
+    "cudnnConvolution2D_ntap_f32_tensor",
+    "cudnnConvolution3D_ntap_tensor",
+    "cudnnConvolution3D_ntap_f32_tensor",
+    "cudnnConvolution3D_f32",
+    "cudnnConvolution3D_f32_bias",
+    "customStencil3D7pt_f64_tensor",
+    "customStencil3D7ptCoeff_f64_tensor",
+    "customStencil3D7ptExtra_f64_tensor",
+    "cufftZ2Z_1D_tensor",
+    "cufftC2C_1D_tensor",
+    "cutensornetTensorProduct3D_f32_tensor",
+    "cutensornetTensorProduct3D_f64_tensor",
+    "cudnnConvolutionFwd_batched",
+    "cudnnConvolutionFwd_im2col_gemm",
+    "cudnnMaxPoolFwd_batched",
+    "cudnnBatchNormalizationForwardInference",
+    "cudnnAddTensor_batched",
+    "cudnnConvBnReluFwdFused",
+    "cudnnConvBiasReluAddFwdFused",
+    "rmsnorm_f32",
+    "rmsnorm_f32_tensor",
+    "rmsnorm_unweighted_f32_tensor",
+    "gelu_tanh_f32_tensor",
+    "whisperExpShiftSum_f32_tensor",
+    "cublasDdot",
+    "cublasSdot",
+    "cudnnSoftmaxForward",
+    "cudnnSoftmaxForward_tensor",
+    "cudnnSoftmaxForwardOut_tensor",
+    "cudaCopy1D_f32_tensor",
+    "cudaCopy2D_f32_tensor",
+    "cudaCopy3D_f32_tensor",
+    "cudaCopy6D_f32_tensor",
+    "cudaAdd_f32_tensor",
+    "cudaMaskSelect_f32_tensor",
+    "cudaSwiGLU_f32_tensor",
+    "cudaRopeMulMulSub_f32_tensor",
+    "cudaRopeMulMulAdd_f32_tensor",
+    "cublasLtMatmulBiasReluFused",
+    "cublasDsyrk_alias",
+    "cublasGemmFor1x1Conv",
+    "cutensornetContraction2_f64",
+    "cutensornetContraction2_f64_r4r5r4",
+    "cutensornetContraction2_f64_r5r4r4",
+    "cutensornetContraction2_f64_r5r5r4",
+}
+
+
+SEMANTIC_BACKEND_HINTS = {
+    # The semantic node is lowered by a custom rewrite into this ABI symbol.
+    "miniamr_weighted_27pt_tensor": "cudnnConvolution3D_ntap_tensor",
+    # Candidate completion: not emitted yet, but this is the intended backend
+    # route once the sparse filter materialization rule is implemented.
+    "conv3d_sparse_3x3x3": "cudnnConvolution3D_ntap_tensor",
+    "miniamr_average_7pt_tensor": "customStencil3D7pt_f64_tensor",
+    "miniamr_weighted_7pt_tensor": "customStencil3D7ptCoeff_f64_tensor",
+}
+
+
+def _candidate_backend(cand) -> str | None:
+    backend = SEMANTIC_BACKEND_HINTS.get(cand.name)
+    if cand.name in ABI_LOWERABLE_KERNELS:
+        return cand.name
+    if backend in ABI_LOWERABLE_KERNELS:
+        return backend
+    return None
+
+
+def _format_candidate_for_report(cand, include_semantic_only: bool = False) -> str:
+    backend = _candidate_backend(cand)
+    if cand.name in ABI_LOWERABLE_KERNELS:
+        status = "abi-lowerable"
+    elif backend in ABI_LOWERABLE_KERNELS:
+        status = "backend-candidate"
+    elif include_semantic_only:
+        status = "semantic-debug"
+    else:
+        status = "unusable"
+    parts = [
+        cand.name,
+        f"kind={cand.match_kind}",
+        f"coverage={cand.coverage}",
+        f"status={status}",
+    ]
+    if backend:
+        parts.append(f"backend={backend}")
+    if cand.source:
+        parts.append(f"source={cand.source}")
+    if cand.subterm_path:
+        parts.append("path=" + ".".join(str(i) for i in cand.subterm_path))
+    if cand.defaults:
+        defaults = ";".join(f"{k}={v}" for k, v in cand.defaults)
+        parts.append(f"defaults={defaults}")
+    return "  ".join(parts)
+
+
+# Match each linalg.generic at the IR level, capturing the full block so
+# we can substitute it with a `kernel.launch`. Handles BOTH:
+#   - tensor form: `%X = linalg.generic {...} ins(...) outs(...) {body} -> T`
+#   - memref form: `linalg.generic {...} ins(...) outs(...) {body}`
+# (no SSA prefix, no return type; the op is void and mutates `outs` in place).
+# The leading SSA `%X =` and the trailing `-> type` are both optional.
+_GENERIC_BLOCK_RE = re.compile(
+    r"(\s*)(?:(%[\w_]+)(?::(\d+))?\s*=\s*)?"
+    r"linalg\.generic\s*\{[^}]*\}\s*"
+    r"(?:ins\(([^)]*)\)\s*)?"
+    r"outs\(([^)]*)\)\s*"
+    # linalg.yield captures one OR MORE comma-separated SSA operands —
+    # matches kernel_match.py's _GEN_RE, needed so multi-yield bodies
+    # (e.g. softmax's fused exp+sum) aren't dropped or partially-consumed
+    # by the .*? backtracking. Single-yield bodies still match unchanged.
+    r"\{\s*\^bb0\([^)]*\)\s*:.*?linalg\.yield\s+%[\w_]+(?:\s*,\s*%[\w_]+)*\s*:[^}]*\}"
+    r"(?:\s*->\s*([^\n]+))?",
+    re.DOTALL,
+)
+
+
+@dataclass
+class LinalgInstance:
+    """A single linalg.generic op extracted from the MLIR text."""
+    result_ssa: str | None  # %12 etc., or None for memref-form (void)
+    result_count: int       # MLIR multi-result count (`%x:2 = ...`)
+    ins_part: str           # "%10, %11 : tensor, tensor<...>"
+    outs_part: str          # "%9 : tensor<...>" or "%9 : memref<...>"
+    result_type: str | None # the type after `->`, or None for memref-form
+    span: tuple[int, int]   # offset range in the source text
+    indent: str             # leading whitespace before the op
+
+
+def _extract_ssa_names(operands_part: str) -> list[str]:
+    """Pull SSA names from a `%a, %b : type, type` string."""
+    if not operands_part:
+        return []
+    head = operands_part.split(":", 1)[0]
+    return [tok.strip() for tok in head.split(",") if tok.strip()]
+
+
+def _extract_ssa_types(operands_part: str) -> list[str]:
+    """Pull operand types from a `%a, %b : type, type` string."""
+    if not operands_part or ":" not in operands_part:
+        return []
+    _, tail = operands_part.split(":", 1)
+    # Split on top-level commas (respect angle-bracket nesting in MLIR types).
+    types, depth, cur = [], 0, []
+    for c in tail:
+        if c == ',' and depth == 0:
+            t = ''.join(cur).strip()
+            if t:
+                types.append(t)
+            cur = []
+            continue
+        if c in '<(':
+            depth += 1
+        elif c in '>)':
+            depth -= 1
+        cur.append(c)
+    t = ''.join(cur).strip()
+    if t:
+        types.append(t)
+    return types
+
+
+def _scan_scalar_types(text: str) -> dict[str, str]:
+    """Best-effort SSA→type map for scalar values (function args + arith.constant).
+
+    Captures only the kinds of SSA values that show up as Cap operands in the
+    matcher's emit (alphas, betas, etc.) — i.e. things that have a primitive
+    f32/f64/index/integer type rather than a tensor/memref. Good enough to
+    annotate kernel.launch operand types so polygeist-opt can parse the op.
+    """
+    out: dict[str, str] = {}
+    # Function arguments: "func.func @name(%arg0: i32, %arg3: f64, ...)" — capture all.
+    for m in re.finditer(r'%\w+\s*:\s*([a-zA-Z_][\w.]*[!<>?x\d,\s]*)', text):
+        # Re-scope: only inside func.func parameter lists. Just match more carefully.
+        pass
+    for fm in re.finditer(r'func\.func\s+@\w+\s*\(([^)]*)\)', text):
+        params = fm.group(1)
+        for pm in re.finditer(r'(%[\w]+)\s*:\s*([^,)]+)', params):
+            out[pm.group(1).strip()] = pm.group(2).strip()
+    # arith.constant lines: "%X = arith.constant ... : f64". Allow `-` in
+    # SSA names since cgeist emits things like `%c-8_i32` for negatives.
+    for cm in re.finditer(r'(%[\w\-]+)\s*=\s*arith\.constant\s+\S+\s*:\s*(\S+)', text):
+        out[cm.group(1)] = cm.group(2)
+    for bm in re.finditer(
+            r'(%[\w\-]+)\s*=\s*arith\.constant\s+(?:true|false)\s*$',
+            text,
+            re.MULTILINE):
+        out[bm.group(1)] = "i1"
+    # affine.load on a scalar memref: "%X = affine.load %alloca[] : memref"
+    # The result type is the element type of the memref. Softmax binds its
+    # max/sum captures via this pattern (the loop reduces into a memref,
+    # then loads back the scalar to feed the next generic).
+    for lm in re.finditer(
+            r'(%[\w\-]+)\s*=\s*affine\.load\s+%[\w\-]+\[\]\s*:\s*memref<([^,>]+)(?:,[^>]*)?>',
+            text):
+        out[lm.group(1)] = lm.group(2).strip()
+    for tm in re.finditer(
+            r'(%[\w\-]+)\s*=\s*tensor\.extract\s+%[\w\-]+(?:#[0-9]+)?(?:\[[^\]]*\])?\s*:\s*tensor<([^>]+)>',
+            text):
+        elem = tm.group(2).strip().rsplit("x", 1)[-1]
+        out[tm.group(1)] = elem
+    # Scalar-producing arith / math ops between linalg.generics. RMSNorm
+    # binds its %scale capture to a chain `divf(ss, N); addf(_, eps);
+    # sqrt(_); divf(1.0, _)` that lives in the function body but outside
+    # any linalg.generic. The matcher Cap binds to the final SSA, and we
+    # need its type for the launch op signature. Match `%X =  ... : T`
+    # for the common scalar arith ops (avoid being so broad that we
+    # accidentally type memref/tensor SSAs).
+    _scalar_op_pat = re.compile(
+        r'(%[\w\-]+)\s*=\s*'
+        r'(?:arith\.(?:add[fi]|sub[fi]|mul[fi]|div[fsui]+|negf|select|cmp[fi]|'
+        r'extf|extsi|extui|trunci|truncf|sitofp|uitofp|fptosi|fptoui|bitcast)'
+        r'|math\.(?:sqrt|exp|log|tanh|absf|absi))'
+        r'\s+\S[^\n]*?:\s*([a-zA-Z][\w]*)\s*$',
+        re.MULTILINE)
+    for sm in _scalar_op_pat.finditer(text):
+        out[sm.group(1)] = sm.group(2).strip()
+    return out
+
+
+def _enclosing_func_args(text: str, pos: int) -> list[tuple[str, str]]:
+    """Best-effort function-argument list for the func containing `pos`.
+
+    The Darknet im2col+GEMM fused rewrite needs the original scalar shape
+    parameters, which cgeist emits as the first seven function arguments:
+    channels, height, width, out_channels, ksize, stride, pad.
+    """
+    matches = list(re.finditer(r'func\.func\s+@\w+\s*\(([^)]*)\)', text[:pos]))
+    if not matches:
+        return []
+    params = matches[-1].group(1)
+    out: list[tuple[str, str]] = []
+    for pm in re.finditer(r'(%[\w_\-]+)\s*:\s*([^,)]+)', params):
+        out.append((pm.group(1).strip(), pm.group(2).strip()))
+    return out
+
+
+def _extract_guarded_im2col_input(body_lines: list[str]) -> tuple[str, str] | None:
+    """Find the source memref loaded by the guarded im2col linalg body."""
+    body = "\n".join(body_lines)
+    m = re.search(
+        r'memref\.load\s+(%[\w_\-]+)\[[^\]]*\]\s*:\s*(memref<[^>]+>)',
+        body,
+    )
+    if not m:
+        return None
+    return m.group(1), m.group(2)
+
+
+def _extract_cmpi_rhs_i32(body_lines: list[str]) -> str | None:
+    """Find the RHS scalar in a linalg-index comparison like `i > %pos`."""
+    for line in body_lines:
+        m = re.search(r'arith\.cmpi\s+\w+,\s+%[\w_\-]+,\s+(%[\w_\-]+)\s*:', line)
+        if m:
+            return m.group(1)
+    return None
+
+
+def collect_generics_with_spans(text: str) -> list[LinalgInstance]:
+    """Return every linalg.generic in `text`, in source order, with span."""
+    out: list[LinalgInstance] = []
+    for m in _GENERIC_BLOCK_RE.finditer(text):
+        indent, result_ssa, result_count, ins, outs, rty = m.groups()
+        out.append(LinalgInstance(
+            result_ssa=result_ssa,
+            result_count=int(result_count) if result_count else (
+                1 if result_ssa else 0
+            ),
+            ins_part=(ins or "").strip(),
+            outs_part=outs.strip(),
+            result_type=rty.strip() if rty else None,
+            span=m.span(),
+            indent=indent,
+        ))
+    return out
+
+
+_STRIDED_2D_TARGET = "memref>"
+_STRIDED_3D_TARGET = "memref>"
+
+
+def _sniff_elem_type(memref_or_tensor_ty: str) -> str | None:
+    """Extract the element type from a memref/tensor textual type.
+
+    Examples:
+      `memref>`  →  "f64"
+      `memref>`            →  "f32"
+      `tensor`                                →  "f16"
+      `tensor`                                 →  "bf16"
+      `memref`                                →  "i32"
+
+    Returns None if the type doesn't parse as memref/tensor.
+    """
+    m = re.match(r'(?:memref|tensor)<(.+)>', memref_or_tensor_ty.strip())
+    if not m:
+        return None
+    body = m.group(1)
+    depth = 0
+    head = []
+    for c in body:
+        if c == "," and depth == 0:
+            break
+        if c in "<([":
+            depth += 1
+        elif c in ">)]":
+            depth -= 1
+        head.append(c)
+    shaped = "".join(head).strip()
+    return shaped.rsplit("x", 1)[-1].strip() if "x" in shaped else shaped
+
+
+def _shaped_rank(ty: str) -> int:
+    """Return the rank of a simple tensor/memref spelling, or -1."""
+    if not (ty.startswith("tensor<") or ty.startswith("memref<")):
+        return -1
+    inside = ty[ty.find("<") + 1:ty.rfind(">")]
+    shape_and_elem = inside.split(",", 1)[0]
+    if "x" not in shape_and_elem:
+        return 0
+    return shape_and_elem.rsplit("x", 1)[0].count("x") + 1
+
+
+def _normalize_memref_operands(
+    operands: list[str], operand_types: list[str] | None, indent: str
+) -> tuple[list[str], list[str], list[str]]:
+    """For each strided memref operand, emit a memref.cast to a uniform
+    `memref>` target type, so the
+    launch's operand types match the canonical kernel.defn declaration's
+    dynamic-stride placeholder pattern.
+
+    Element-type-aware: handles f64, f32, f16, bf16, i32, i16, i8, i64.
+    Operands not matching the strided-memref pattern are passed through
+    unchanged.
+
+    Returns (cast_lines, new_operand_ssas, new_operand_types).
+    """
+    if operand_types is None or len(operand_types) != len(operands):
+        return [], operands, operand_types or []
+    cast_lines: list[str] = []
+    new_ssas: list[str] = []
+    new_types: list[str] = []
+    # Match memref or memref with strided layout.
+    # Capture (rank-dims-prefix, element-type).
+    rank_pat = re.compile(r"memref<((?:\?x)+)([\w_]+)(?:,\s*strided<|>)")
+    for ssa, ty in zip(operands, operand_types):
+        if not ty.startswith("memref<") or "strided<[" not in ty:
+            new_ssas.append(ssa); new_types.append(ty); continue
+        m = rank_pat.match(ty)
+        if not m:
+            new_ssas.append(ssa); new_types.append(ty); continue
+        rank_prefix = m.group(1)         # e.g. "?x?x" for rank-2 dynamic
+        elem = m.group(2)                # e.g. "f32" / "f64" / "i32"
+        rank = rank_prefix.count("?")
+        # Build target: strided<[?, ..., 1], offset: ?> — all row strides
+        # dynamic, last (innermost) stride statically 1 (row-major, contiguous
+        # within innermost dim).
+        if rank < 1:
+            new_ssas.append(ssa); new_types.append(ty); continue
+        if rank == 1:
+            strides = "[1]"
+        else:
+            strides = "[" + ", ".join(["?"] * (rank - 1)) + ", 1]"
+        target = f"memref<{rank_prefix}{elem}, strided<{strides}, offset: ?>>"
+        if ty == target:
+            new_ssas.append(ssa); new_types.append(ty); continue
+        cast_ssa = ssa + "_c"
+        cast_lines.append(
+            f"{indent}{cast_ssa} = memref.cast {ssa} : {ty} to {target}"
+        )
+        new_ssas.append(cast_ssa)
+        new_types.append(target)
+    return cast_lines, new_ssas, new_types
+
+
+def _derived_ssa_name(ssa: str, suffix: str) -> str:
+    """Create a readable SSA name derived from an existing textual SSA."""
+    base = ssa[1:] if ssa.startswith("%") else ssa
+    base = re.sub(r"\W", "_", base)
+    if not base or base[0].isdigit():
+        base = "v" + base
+    return f"%{base}_{suffix}"
+
+
+def _dynamic_tensor_type(ty: str) -> str | None:
+    """Return an all-dynamic tensor type with the same rank/element type."""
+    if not ty.startswith("tensor<"):
+        return None
+    m = re.match(r"tensor<(.+)>", ty.strip())
+    if not m:
+        return None
+    shaped = m.group(1).strip()
+    # Keep scalar tensors and complex element encodings unchanged. The kernel
+    # library defns we need to normalize against are plain ranked tensors.
+    if "x" not in shaped or "*" in shaped or "<" in shaped:
+        return ty
+    elem = shaped.rsplit("x", 1)[-1].strip()
+    shape = shaped[:-(len(elem) + 1)]
+    dims = [d.strip() for d in shape.split("x") if d.strip()]
+    if not dims:
+        return ty
+    return "tensor<" + "x".join("?" for _ in dims) + "x" + elem + ">"
+
+
+def _complex1d_tensor_type(ty: str) -> str | None:
+    """Return tensor for tensor; reject other layouts."""
+    if not ty.startswith("tensor<"):
+        return None
+    m = re.match(r"tensor<(.+)>", ty.strip())
+    if not m:
+        return None
+    shaped = m.group(1).strip()
+    if "<" in shaped or "x" not in shaped:
+        return None
+    elem = shaped.rsplit("x", 1)[-1].strip()
+    dims = shaped[:-(len(elem) + 1)].split("x")
+    dims = [d.strip() for d in dims if d.strip()]
+    if len(dims) != 2 or dims[1] != "2":
+        return None
+    return f"tensor"
+
+
+def _normalize_tensor_operands(
+    operands: list[str], operand_types: list[str] | None, indent: str
+) -> tuple[list[str], list[str], list[str]]:
+    """Erase static tensor extents with tensor.cast for kernel.defn matching."""
+    if operand_types is None or len(operand_types) != len(operands):
+        return [], operands, operand_types or []
+    cast_lines: list[str] = []
+    new_ssas: list[str] = []
+    new_types: list[str] = []
+    for idx, (ssa, ty) in enumerate(zip(operands, operand_types)):
+        target = _dynamic_tensor_type(ty)
+        if target is None or target == ty:
+            new_ssas.append(ssa)
+            new_types.append(ty)
+            continue
+        cast_ssa = _derived_ssa_name(ssa, f"tc{idx}")
+        cast_lines.append(
+            f"{indent}{cast_ssa} = tensor.cast {ssa} : {ty} to {target}"
+        )
+        new_ssas.append(cast_ssa)
+        new_types.append(target)
+    return cast_lines, new_ssas, new_types
+
+
+def _normalize_complex1d_tensor_operands(
+    operands: list[str], operand_types: list[str], indent: str
+) -> tuple[list[str], list[str], list[str]] | None:
+    if len(operands) != len(operand_types):
+        return None
+    cast_lines: list[str] = []
+    new_ssas: list[str] = []
+    new_types: list[str] = []
+    for idx, (ssa, ty) in enumerate(zip(operands, operand_types)):
+        target = _complex1d_tensor_type(ty)
+        if target is None:
+            return None
+        if target == ty:
+            new_ssas.append(ssa)
+            new_types.append(ty)
+            continue
+        cast_ssa = _derived_ssa_name(ssa, f"fft_tc{idx}")
+        cast_lines.append(
+            f"{indent}{cast_ssa} = tensor.cast {ssa} : {ty} to {target}"
+        )
+        new_ssas.append(cast_ssa)
+        new_types.append(target)
+    return cast_lines, new_ssas, new_types
+
+
+def _parse_static_subview_offset(text: str, ssa: str) -> tuple[str, tuple[int, int]] | None:
+    pat = re.compile(
+        rf"^\s*{re.escape(ssa)}\s*=\s*memref\.subview\s+"
+        rf"(%[\w_\-]+)\s*\[([^\]]+)\]",
+        re.MULTILINE,
+    )
+    m = pat.search(text)
+    if not m:
+        return None
+    pieces = [p.strip() for p in m.group(2).split(",")]
+    if len(pieces) != 2:
+        return None
+    try:
+        return m.group(1), (int(pieces[0]), int(pieces[1]))
+    except ValueError:
+        return None
+
+
+def _parse_static_extract_slice_offset(
+    text: str, ssa: str
+) -> tuple[str, tuple[int, int]] | None:
+    pat = re.compile(
+        rf"^\s*{re.escape(ssa)}\s*=\s*tensor\.extract_slice\s+"
+        rf"(%[\w_\-]+)\s*\[([^\]]+)\]",
+        re.MULTILINE,
+    )
+    m = pat.search(text)
+    if not m:
+        return None
+    pieces = [p.strip() for p in m.group(2).split(",")]
+    if len(pieces) != 2:
+        return None
+    try:
+        return m.group(1), (int(pieces[0]), int(pieces[1]))
+    except ValueError:
+        return None
+
+
+def _constant_index_value(text: str, ssa: str) -> int | None:
+    m = re.search(
+        rf"^\s*{re.escape(ssa)}\s*=\s*arith\.constant\s+(-?\d+)\s*:\s*index\s*$",
+        text,
+        re.MULTILINE,
+    )
+    return int(m.group(1)) if m else None
+
+
+def _type_payload(mlir_type: str, prefix: str) -> str | None:
+    if not mlir_type.startswith(prefix + "<") or not mlir_type.endswith(">"):
+        return None
+    return mlir_type[len(prefix) + 1:-1]
+
+
+def _top_level_first_type_piece(payload: str) -> str:
+    depth = 0
+    cur: list[str] = []
+    for c in payload:
+        if c == "," and depth == 0:
+            break
+        if c in "<(":
+            depth += 1
+        elif c in ">)":
+            depth -= 1
+        cur.append(c)
+    return "".join(cur).strip()
+
+
+def _memref_to_tensor_type(memref_ty: str) -> str | None:
+    payload = _type_payload(memref_ty.strip(), "memref")
+    if payload is None:
+        return None
+    shaped = _top_level_first_type_piece(payload)
+    if not shaped:
+        return None
+    return f"tensor<{shaped}>"
+
+
+def _infer_tensor_type(text: str, ssa: str) -> str | None:
+    """Best-effort SSA→tensor type inference for custom launch rendering."""
+    # Function argument or explicit tensor operand.
+    for fm in re.finditer(r"func\.func\s+@\w+\s*\(([^)]*)\)", text):
+        params = fm.group(1)
+        for pm in re.finditer(r"(%[\w_\-]+)\s*:\s*(tensor<[^,)]+>)", params):
+            if pm.group(1) == ssa:
+                return pm.group(2).strip()
+
+    m = re.search(
+        rf"^\s*{re.escape(ssa)}\s*=\s*tensor\.cast\s+.*?\s+to\s+(tensor<[^\n]+>)\s*$",
+        text,
+        re.MULTILINE,
+    )
+    if m:
+        return m.group(1).strip()
+
+    m = re.search(
+        rf"^\s*{re.escape(ssa)}\s*=\s*tensor\.extract_slice\s+.*?\s+to\s+(tensor<[^\n]+>)\s*$",
+        text,
+        re.MULTILINE,
+    )
+    if m:
+        return m.group(1).strip()
+
+    m = re.search(
+        rf"^\s*{re.escape(ssa)}\s*=\s*tensor\.insert_slice\s+.*?\s+into\s+(tensor<[^\n]+>)\s*$",
+        text,
+        re.MULTILINE,
+    )
+    if m:
+        return m.group(1).strip()
+
+    m = re.search(
+        rf"^\s*{re.escape(ssa)}\s*=\s*polygeist\.submap\(.*?\)\s*"
+        rf"\{{[^}}]*\}}\s*:\s*\([^)]*\)\s*->\s*(tensor<[^\n]+>)\s*$",
+        text,
+        re.MULTILINE,
+    )
+    if m:
+        return m.group(1).strip()
+
+    m = re.search(
+        rf"^\s*{re.escape(ssa)}\s*=\s*bufferization\.to_tensor\s+%[\w_\-]+\s*:\s*(memref<[^\n]+>)\s*$",
+        text,
+        re.MULTILINE,
+    )
+    if m:
+        return _memref_to_tensor_type(m.group(1).strip())
+
+    return None
+
+
+def _trace_tensor_storage_base(text: str, ssa: str) -> str:
+    """Trace tensor view/update SSA values to the tensor that owns storage."""
+    for _ in range(16):
+        patterns = (
+            # A slice is a view of its source tensor.
+            rf"^\s*{re.escape(ssa)}\s*=\s*tensor\.extract_slice\s+(%[\w_\-]+)",
+            # An insert_slice updates its destination tensor.
+            rf"^\s*{re.escape(ssa)}\s*=\s*tensor\.insert_slice\s+%[\w_\-]+\s+into\s+(%[\w_\-]+)",
+            # A cast changes only the static type information.
+            rf"^\s*{re.escape(ssa)}\s*=\s*tensor\.cast\s+(%[\w_\-]+)",
+        )
+        next_ssa = None
+        for pat in patterns:
+            match = re.search(pat, text, re.MULTILINE)
+            if match:
+                next_ssa = match.group(1)
+                break
+        if not next_ssa or next_ssa == ssa:
+            break
+        ssa = next_ssa
+    return ssa
+
+
+def _parse_polygeist_submap_window(
+    text: str, ssa: str
+) -> tuple[str, list[str]] | None:
+    m = re.search(
+        rf"^\s*{re.escape(ssa)}\s*=\s*polygeist\.submap\s*"
+        rf"\(\s*(%[\w_\-]+)\s*,\s*([^)]+)\)\s*\{{[^}}]*\}}\s*:",
+        text,
+        re.MULTILINE,
+    )
+    if not m:
+        return None
+    sizes = [p.strip() for p in m.group(2).split(",") if p.strip()]
+    return m.group(1), sizes
+
+
+def _is_forward_conv3d_window(text: str, operand: str) -> bool:
+    """Prove a rank-8 view is the valid-forward Conv3D input window."""
+    definition = re.search(
+        rf"(?s)^\s*{re.escape(operand)}\s*=\s*"
+        r"polygeist\.submap\(.*?\)\s*\{map\s*=\s*([^}]+)\}",
+        text,
+        re.MULTILINE,
+    )
+    if not definition:
+        return False
+    map_text = definition.group(1).strip()
+    if map_text.startswith("#"):
+        resolved = re.search(
+            rf"(?m)^\s*{re.escape(map_text)}\s*=\s*(affine_map<.*?>)\s*$",
+            text,
+        )
+        if not resolved:
+            return False
+        map_text = resolved.group(1)
+    compact = re.sub(r"\s+", "", map_text)
+    return compact in {
+        "affine_map<(d0,d1,d2,d3,d4,d5,d6,d7)->"
+        "(d4,d5+d1,d6+d2,d7+d3)>",
+        "affine_map<(d0,d1,d2,d3,d4,d5,d6,d7)->"
+        "(0,d4,d5+d1,d6+d2,d7+d3)>",
+    }
+
+
+def _miniamr_weighted27_window_info(
+    text: str,
+    weight_names: list[str],
+    weight_types: list[str],
+) -> tuple[str, str, str, int] | None:
+    """Return (input_base, input_type, weight_ssa, K) for 3D 27pt conv."""
+    def _rank(ty: str) -> int:
+        if not ty.startswith("tensor<"):
+            return -1
+        inside = ty[ty.find("<") + 1:ty.rfind(">")]
+        shape = inside.rsplit("x", 1)[0]
+        return shape.count("x") + 1 if shape else 0
+
+    weight_ssa = None
+    window_ssa = None
+    for name, ty in zip(weight_names, weight_types):
+        rank = _rank(ty)
+        if rank == 3 and weight_ssa is None:
+            weight_ssa = name
+        elif rank == 6 and window_ssa is None:
+            window_ssa = name
+    if weight_ssa is None or window_ssa is None:
+        return None
+
+    window = _parse_polygeist_submap_window(text, window_ssa)
+    if window is None:
+        return None
+    input_base, sizes = window
+    if len(sizes) < 6:
+        return None
+    k_values = [_constant_index_value(text, s) for s in sizes[-3:]]
+    if any(v is None for v in k_values) or len(set(k_values)) != 1:
+        return None
+    K = k_values[0]
+    if K is None or K < 3 or K % 2 == 0:
+        return None
+    input_type = _infer_tensor_type(text, input_base)
+    if input_type is None:
+        return None
+    return input_base, input_type, weight_ssa, K
+
+
+def _conv2d_ntap_grid_info(
+    text: str, input_names: list[str], out_name: str
+) -> tuple[int, str, list[int]] | None:
+    """Validate same-base odd-square input subviews and return row-major order.
+
+    Returns (filter_width, top_left_input_ssa, input_indices_in_row_major_order).
+    The scalar algebra matcher only proves a weighted sum. This check proves
+    the operands are actually shifted subviews that cuDNN can interpret as a
+    dense KxK cross-correlation window.
+    """
+    ntaps = len(input_names)
+    width = math.isqrt(ntaps)
+    if width * width != ntaps or width < 3 or width % 2 == 0:
+        return None
+    parsed: list[tuple[int, str, tuple[int, int]]] = []
+    bases = set()
+    for idx, name in enumerate(input_names):
+        p = _parse_static_subview_offset(text, name)
+        if p is None:
+            return None
+        base, off = p
+        bases.add(base)
+        parsed.append((idx, name, off))
+    if len(bases) != 1:
+        return None
+    ys = sorted({off[0] for _, _, off in parsed})
+    xs = sorted({off[1] for _, _, off in parsed})
+    if len(ys) != width or len(xs) != width:
+        return None
+    if ys != list(range(ys[0], ys[0] + width)):
+        return None
+    if xs != list(range(xs[0], xs[0] + width)):
+        return None
+
+    out = _parse_static_subview_offset(text, out_name)
+    if out is None:
+        return None
+    _out_base, out_off = out
+    radius = width // 2
+    if out_off != (ys[0] + radius, xs[0] + radius):
+        return None
+
+    by_offset = {off: (idx, name) for idx, name, off in parsed}
+    ordered_indices: list[int] = []
+    top_left_name = ""
+    for y in ys:
+        for x in xs:
+            item = by_offset.get((y, x))
+            if item is None:
+                return None
+            idx, name = item
+            if y == ys[0] and x == xs[0]:
+                top_left_name = name
+            ordered_indices.append(idx)
+    return width, top_left_name, ordered_indices
+
+
+def _conv2d_ntap_tensor_grid_info(
+    text: str, input_names: list[str], out_name: str
+) -> tuple[int, str, list[int]] | None:
+    """Tensor extract_slice sibling of _conv2d_ntap_grid_info."""
+    ntaps = len(input_names)
+    width = math.isqrt(ntaps)
+    if width * width != ntaps or width < 3 or width % 2 == 0:
+        return None
+    parsed: list[tuple[int, str, tuple[int, int]]] = []
+    bases = set()
+    for idx, name in enumerate(input_names):
+        p = _parse_static_extract_slice_offset(text, name)
+        if p is None:
+            return None
+        base, off = p
+        bases.add(base)
+        parsed.append((idx, name, off))
+    if len(bases) != 1:
+        return None
+    ys = sorted({off[0] for _, _, off in parsed})
+    xs = sorted({off[1] for _, _, off in parsed})
+    if len(ys) != width or len(xs) != width:
+        return None
+    if ys != list(range(ys[0], ys[0] + width)):
+        return None
+    if xs != list(range(xs[0], xs[0] + width)):
+        return None
+
+    out = _parse_static_extract_slice_offset(text, out_name)
+    if out is None:
+        return None
+    _out_base, out_off = out
+    radius = width // 2
+    if out_off != (ys[0] + radius, xs[0] + radius):
+        return None
+
+    by_offset = {off: (idx, name) for idx, name, off in parsed}
+    ordered_indices: list[int] = []
+    top_left_name = ""
+    for y in ys:
+        for x in xs:
+            item = by_offset.get((y, x))
+            if item is None:
+                return None
+            idx, name = item
+            if y == ys[0] and x == xs[0]:
+                top_left_name = name
+            ordered_indices.append(idx)
+    return width, top_left_name, ordered_indices
+
+
+def _weight_cast_op(src_ty: str, dst_ty: str) -> str:
+    casts = {
+        ("f64", "f32"): "arith.truncf",
+        ("f32", "f64"): "arith.extf",
+    }
+    return casts.get((src_ty, dst_ty), "arith.bitcast")
+
+
+def _format_weight_literal(value: float, ty: str) -> str:
+    if ty.startswith("f"):
+        lit = repr(value)
+        return lit if any(c in lit for c in ".eE") else lit + ".0"
+    return str(int(value))
+
+
+def _render_ntap_conv_launch(
+    name: str,
+    top_left_ssa: str,
+    top_left_type: str,
+    out_ssa: str,
+    out_type: str,
+    width: int,
+    ordered_inline_weights: list[list[str] | None],
+    indent: str,
+    scalar_type_map: dict[str, str],
+    body_constants: dict[str, float],
+    weight_ty: str,
+    unique_id: int,
+) -> str:
+    cast_lines, memrefs, memref_types = _normalize_memref_operands(
+        [top_left_ssa, out_ssa], [top_left_type, out_type], indent
+    )
+    ntaps = width * width
+    weight_memref_ty = f"memref<{ntaps}x{weight_ty}>"
+    prefix = f"%ntap{unique_id}"
+    wbuf = f"{prefix}_weights"
+    k_ssa = f"{prefix}_k"
+    lines = list(cast_lines)
+    lines.append(f"{indent}{wbuf} = memref.alloca() : {weight_memref_ty}")
+    for idx, weights in enumerate(ordered_inline_weights):
+        idx_ssa = f"{prefix}_i{idx}"
+        lines.append(f"{indent}{idx_ssa} = arith.constant {idx} : index")
+        if weights is None:
+            val_ssa = f"{prefix}_w{idx}"
+            lines.append(
+                f"{indent}{val_ssa} = arith.constant "
+                f"{_format_weight_literal(1.0, weight_ty)} : {weight_ty}"
+            )
+        elif len(weights) == 1:
+            val_ssa = weights[0]
+            src_ty = scalar_type_map.get(val_ssa)
+            if src_ty and src_ty != weight_ty:
+                cast_ssa = f"{prefix}_w{idx}_cast"
+                lines.append(
+                    f"{indent}{cast_ssa} = {_weight_cast_op(src_ty, weight_ty)} "
+                    f"{val_ssa} : {src_ty} to {weight_ty}"
+                )
+                val_ssa = cast_ssa
+        else:
+            summed = sum(body_constants.get(w, 0.0) for w in weights)
+            val_ssa = f"{prefix}_w{idx}"
+            lines.append(
+                f"{indent}{val_ssa} = arith.constant "
+                f"{_format_weight_literal(summed, weight_ty)} : {weight_ty}"
+            )
+        lines.append(
+            f"{indent}memref.store {val_ssa}, {wbuf}[{idx_ssa}] : {weight_memref_ty}"
+        )
+    weight_dyn_ty = f"memref"
+    wbuf_dyn = f"{wbuf}_c"
+    lines.append(
+        f"{indent}{wbuf_dyn} = memref.cast {wbuf} : {weight_memref_ty} to {weight_dyn_ty}"
+    )
+    lines.append(f"{indent}{k_ssa} = arith.constant {width} : i32")
+    operands = [memrefs[0], memrefs[1], wbuf_dyn, k_ssa]
+    sig_types = [memref_types[0], memref_types[1], weight_dyn_ty, "i32"]
+    lines.append(
+        f"{indent}kernel.launch @{name}({', '.join(operands)}) : "
+        f"({', '.join(sig_types)}) -> ()"
+    )
+    return "\n".join(lines)
+
+
+def _render_ntap_conv_tensor_launch(
+    name: str,
+    result_ssa: str,
+    result_type: str,
+    top_left_ssa: str,
+    top_left_type: str,
+    out_ssa: str,
+    out_type: str,
+    width: int,
+    ordered_inline_weights: list[list[str] | None],
+    indent: str,
+    scalar_type_map: dict[str, str],
+    body_constants: dict[str, float],
+    weight_ty: str,
+    unique_id: int,
+) -> str:
+    cast_lines, tensors, tensor_types = _normalize_tensor_operands(
+        [top_left_ssa, out_ssa], [top_left_type, out_type], indent
+    )
+    ntaps = width * width
+    prefix = f"%ntap{unique_id}"
+    value_ssas: list[str] = []
+    lines = list(cast_lines)
+    for idx, weights in enumerate(ordered_inline_weights):
+        if weights is None:
+            val_ssa = f"{prefix}_w{idx}"
+            lines.append(
+                f"{indent}{val_ssa} = arith.constant "
+                f"{_format_weight_literal(1.0, weight_ty)} : {weight_ty}"
+            )
+        elif len(weights) == 1:
+            val_ssa = weights[0]
+            src_ty = scalar_type_map.get(val_ssa)
+            if src_ty and src_ty != weight_ty:
+                cast_ssa = f"{prefix}_w{idx}_cast"
+                lines.append(
+                    f"{indent}{cast_ssa} = {_weight_cast_op(src_ty, weight_ty)} "
+                    f"{val_ssa} : {src_ty} to {weight_ty}"
+                )
+                val_ssa = cast_ssa
+        else:
+            summed = sum(body_constants.get(w, 0.0) for w in weights)
+            val_ssa = f"{prefix}_w{idx}"
+            lines.append(
+                f"{indent}{val_ssa} = arith.constant "
+                f"{_format_weight_literal(summed, weight_ty)} : {weight_ty}"
+            )
+        value_ssas.append(val_ssa)
+
+    weight_static_ty = f"tensor<{ntaps}x{weight_ty}>"
+    weight_dyn_ty = f"tensor"
+    wvec = f"{prefix}_weights"
+    wvec_dyn = f"{wvec}_c"
+    k_ssa = f"{prefix}_k"
+    lines.append(
+        f"{indent}{wvec} = tensor.from_elements {', '.join(value_ssas)} : "
+        f"{weight_static_ty}"
+    )
+    lines.append(
+        f"{indent}{wvec_dyn} = tensor.cast {wvec} : {weight_static_ty} to "
+        f"{weight_dyn_ty}"
+    )
+    lines.append(f"{indent}{k_ssa} = arith.constant {width} : i32")
+    dyn_result_type = _dynamic_tensor_type(result_type) or result_type
+    launch_result_ssa = result_ssa
+    result_cast = ""
+    if dyn_result_type != result_type:
+        launch_result_ssa = _derived_ssa_name(result_ssa, "tdyn")
+        result_cast = (
+            f"\n{indent}{result_ssa} = tensor.cast {launch_result_ssa} : "
+            f"{dyn_result_type} to {result_type}"
+        )
+    operands = [tensors[0], tensors[1], wvec_dyn, k_ssa]
+    sig_types = [tensor_types[0], tensor_types[1], weight_dyn_ty, "i32"]
+    lines.append(
+        f"{indent}{launch_result_ssa} = kernel.launch @{name}"
+        f"({', '.join(operands)}) : ({', '.join(sig_types)}) -> "
+        f"{dyn_result_type}{result_cast}"
+    )
+    return "\n".join(lines)
+
+
+def _render_ntap_conv3d_tensor_launch(
+    name: str,
+    result_ssa: str,
+    result_type: str,
+    input_ssa: str,
+    input_type: str,
+    out_ssa: str,
+    out_type: str,
+    weight_ssa: str,
+    weight_type: str,
+    width: int,
+    indent: str,
+) -> str:
+    cast_lines, tensors, tensor_types = _normalize_tensor_operands(
+        [input_ssa, out_ssa, weight_ssa],
+        [input_type, out_type, weight_type],
+        indent,
+    )
+    prefix = _derived_ssa_name(result_ssa, "conv3d")
+    k_ssa = f"{prefix}_k"
+    lines = list(cast_lines)
+    lines.append(f"{indent}{k_ssa} = arith.constant {width} : i32")
+    dyn_result_type = _dynamic_tensor_type(result_type) or result_type
+    launch_result_ssa = result_ssa
+    result_cast = ""
+    if dyn_result_type != result_type:
+        launch_result_ssa = _derived_ssa_name(result_ssa, "tdyn")
+        result_cast = (
+            f"\n{indent}{result_ssa} = tensor.cast {launch_result_ssa} : "
+            f"{dyn_result_type} to {result_type}"
+        )
+    operands = [tensors[0], tensors[1], tensors[2], k_ssa]
+    sig_types = [tensor_types[0], tensor_types[1], tensor_types[2], "i32"]
+    lines.append(
+        f"{indent}{launch_result_ssa} = kernel.launch @{name}"
+        f"({', '.join(operands)}) : ({', '.join(sig_types)}) -> "
+        f"{dyn_result_type}{result_cast}"
+    )
+    return "\n".join(lines)
+
+
+def _render_cufft_1d_tensor_launch(
+    name: str,
+    result_ssa: str,
+    result_type: str,
+    input_ssa: str,
+    input_type: str,
+    out_ssa: str,
+    out_type: str,
+    inverse: int,
+    indent: str,
+) -> str | None:
+    normalized = _normalize_complex1d_tensor_operands(
+        [input_ssa, out_ssa], [input_type, out_type], indent
+    )
+    if normalized is None:
+        return None
+    cast_lines, tensors, tensor_types = normalized
+    result_dyn_type = _complex1d_tensor_type(result_type)
+    if result_dyn_type is None:
+        return None
+    prefix = _derived_ssa_name(result_ssa, "fft")
+    inv_ssa = f"{prefix}_inverse"
+    launch_result_ssa = result_ssa
+    result_cast = ""
+    lines = list(cast_lines)
+    lines.append(f"{indent}{inv_ssa} = arith.constant {inverse} : i32")
+    if result_dyn_type != result_type:
+        launch_result_ssa = _derived_ssa_name(result_ssa, "tdyn")
+        result_cast = (
+            f"\n{indent}{result_ssa} = tensor.cast {launch_result_ssa} : "
+            f"{result_dyn_type} to {result_type}"
+        )
+    operands = [tensors[0], tensors[1], inv_ssa]
+    sig_types = [tensor_types[0], tensor_types[1], "i32"]
+    lines.append(
+        f"{indent}{launch_result_ssa} = kernel.launch @{name}"
+        f"({', '.join(operands)}) : ({', '.join(sig_types)}) -> "
+        f"{result_dyn_type}{result_cast}"
+    )
+    return "\n".join(lines)
+
+
+def _find_insert_slice_of_result(
+    text: str,
+    search_from: int,
+    source_ssa: str,
+) -> tuple[str, str, tuple[int, int]] | None:
+    pat = re.compile(
+        rf"(\n[ \t]*)(%[\w_\-]+)\s*=\s*tensor\.insert_slice\s+"
+        rf"{re.escape(source_ssa)}\s+into\s+[^\n]*\s+:\s+"
+        rf"tensor<[^>]+>\s+into\s+(tensor<[^\n]+>)",
+        re.MULTILINE,
+    )
+    m = pat.search(text, search_from)
+    if not m:
+        return None
+    return m.group(2), m.group(3).strip(), (m.start(), m.end())
+
+
+def _dft1d_inverse_flag(body_constants: dict[str, float]) -> int | None:
+    two_pi = 6.283185307179586
+    candidates = [
+        v for v in body_constants.values()
+        if abs(abs(v) - two_pi) < 1.0e-9
+    ]
+    if not candidates:
+        return None
+    return 1 if candidates[0] > 0.0 else 0
+
+
+def _render_whisper_exp_shift_sum_launch(
+    name: str,
+    result_ssa: str,
+    result_count: int,
+    result_type: str,
+    operands: list[str],
+    operand_types: list[str],
+    indent: str,
+) -> str:
+    cast_lines, operands, operand_types = _normalize_tensor_operands(
+        operands, operand_types, indent
+    )
+    operand_str = ", ".join(operands)
+    sig = f"({', '.join(operand_types)})"
+    cast_prefix = "\n".join(cast_lines) + ("\n" if cast_lines else "")
+    return (
+        f"{cast_prefix}{indent}{result_ssa}:{result_count} = "
+        f"kernel.launch @{name}({operand_str}) : {sig} -> {result_type}"
+    )
+
+
+def _render_custom_stencil3d7pt_launch(
+    name: str,
+    result_ssa: str,
+    result_type: str,
+    operands: list[str],
+    operand_types: list[str],
+    coeffs: list[float],
+    indent: str,
+) -> str:
+    if len(coeffs) != 10:
+        raise ValueError("custom stencil3d7pt launch expects 10 coefficients")
+    cast_lines, operands, operand_types = _normalize_tensor_operands(
+        operands, operand_types, indent
+    )
+    scalar_names = []
+    scalar_lines = []
+    for idx, value in enumerate(coeffs):
+        ssa = _derived_ssa_name(result_ssa, f"stencil7_c{idx}")
+        lit = repr(float(value))
+        if "." not in lit and "e" not in lit and "E" not in lit:
+            lit += ".0"
+        scalar_lines.append(f"{indent}{ssa} = arith.constant {lit} : f64")
+        scalar_names.append(ssa)
+    all_operands = operands + scalar_names
+    all_types = operand_types + ["f64"] * len(scalar_names)
+    cast_prefix = "\n".join(cast_lines + scalar_lines)
+    if cast_prefix:
+        cast_prefix += "\n"
+    operand_str = ", ".join(all_operands)
+    sig = f"({', '.join(all_types)})"
+    dyn_result_type = _dynamic_tensor_type(result_type)
+    launch_result_ssa = result_ssa
+    launch_result_type = result_type
+    result_cast = ""
+    if dyn_result_type is not None and dyn_result_type != result_type:
+        launch_result_ssa = _derived_ssa_name(result_ssa, "tdyn")
+        launch_result_type = dyn_result_type
+        result_cast = (
+            f"\n{indent}{result_ssa} = tensor.cast {launch_result_ssa} : "
+            f"{dyn_result_type} to {result_type}"
+        )
+    return (
+        f"{cast_prefix}{indent}{launch_result_ssa} = kernel.launch "
+        f"@{name}({operand_str}) : {sig} -> {launch_result_type}"
+        f"{result_cast}"
+    )
+
+
+def render_launch(name: str, result_ssa: str | None, result_type: str | None,
+                  operands: list[str], indent: str,
+                  bindings: dict, captures_per_step: list[list[str]],
+                  operand_types: list[str] | None = None,
+                  scalar_type_map: dict[str, str] | None = None,
+                  inline_weights: list[list[str] | None] | None = None,
+                  inline_weight_type: str = "f64",
+                  body_constants: dict[str, float] | None = None,
+                  result_count: int = 1) -> str:
+    """Build a `kernel.launch` op line in MLIR text.
+
+    When `result_ssa` and `result_type` are None, emit a void-returning
+    launch (`-> ()`) — used for memref-form linalg.generic where the
+    output is mutated in place rather than returned as an SSA.
+
+    operand_types : explicit types for the tensor `operands` list (same order).
+    scalar_type_map : SSA→type lookup for Cap-bound scalars.
+    """
+    # First: normalize strided memref operand types via memref.cast so they
+    # match the canonical kernel.defn signature (which uses dynamic-stride
+    # placeholders like `strided<[?, 1], offset: ?>` to accept any concrete
+    # subview shape).
+    cast_lines, operands, operand_types = _normalize_memref_operands(
+        operands, operand_types, indent
+    )
+    tensor_cast_lines, operands, operand_types = _normalize_tensor_operands(
+        operands, operand_types, indent
+    )
+    cast_lines.extend(tensor_cast_lines)
+
+    # Surface body-internal constants (e.g. the 9 weights of a conv2d) as
+    # additional scalar launch operands, when the template opts in via
+    # `surface_inline_weights=True`. The encoder already builds the
+    # in_arg → constant_ssa map per body (parse_generics' inline_weights_per_in).
+    # We append them positionally — same order as the input subviews — so
+    # the lowering pass can pair them with the inputs.
+    #
+    # When the surfaced constant's type doesn't match `inline_weight_type`
+    # (e.g. cgeist promoted i16 inputs to i32 for the multiply, leaving the
+    # weight constants typed i32 even though the kernel is i16), inject a
+    # cast op so the launch signature is internally consistent. Without
+    # this, the verifier would reject the kernel.launch.
+    cast_ops_for_weights = {
+        # (src_type, dst_type) → mlir op name
+        ("i32", "i16"): "arith.trunci",
+        ("i32", "i8"):  "arith.trunci",
+        ("i16", "i8"):  "arith.trunci",
+        ("i16", "i32"): "arith.extsi",
+        ("i8",  "i32"): "arith.extsi",
+        ("i8",  "i16"): "arith.extsi",
+        ("f32", "f16"): "arith.truncf",
+        ("f32", "bf16"): "arith.truncf",
+        ("f64", "f32"): "arith.truncf",
+        ("f64", "f16"): "arith.truncf",
+        ("f64", "bf16"): "arith.truncf",
+        ("f16", "f32"): "arith.extf",
+        ("bf16", "f32"): "arith.extf",
+        ("f32", "f64"): "arith.extf",
+        ("f16", "f64"): "arith.extf",
+        ("bf16", "f64"): "arith.extf",
+    }
+    inline_weight_ssas: list[str] = []
+    weight_cast_lines: list[str] = []
+    # Counter for generated SSAs (summed-constant materialisation) — kept
+    # unique per launch by appending an index. Mostly for the conv3d-style
+    # case where the same input is multiplied by several literal constants
+    # and summed; we precompute the sum at rewrite time and emit one
+    # arith.constant op carrying the result.
+    synth_idx = 0
+    if inline_weights:
+        for w in inline_weights:
+            if w is None:
+                # The matcher may accept an elided `* 1.0` coefficient: some
+                # frontend/canonicalization paths rewrite `1.0 * in[k]` to
+                # bare `in[k]`. The runtime ABI still expects one scalar per
+                # tap, so materialize the implicit unit coefficient here.
+                synth_ssa = f"%cst_synth_{synth_idx}"
+                synth_idx += 1
+                lit = "1.0" if inline_weight_type.startswith("f") else "1"
+                weight_cast_lines.append(
+                    f"{indent}{synth_ssa} = arith.constant {lit} : {inline_weight_type}"
+                )
+                inline_weight_ssas.append(synth_ssa)
+                continue
+            # w is now always a list[str] (possibly length 1). Empty was
+            # already normalised to None by parse_generics, so len(w) >= 1.
+            if len(w) == 1:
+                source_ssa = w[0]
+                src_ty = scalar_type_map.get(source_ssa) if scalar_type_map else None
+                if src_ty and src_ty != inline_weight_type:
+                    op = cast_ops_for_weights.get((src_ty, inline_weight_type))
+                    if op is None:
+                        op = "arith.bitcast"
+                    cast_ssa = source_ssa + "_to_" + inline_weight_type
+                    weight_cast_lines.append(
+                        f"{indent}{cast_ssa} = {op} {source_ssa} : {src_ty} to {inline_weight_type}"
+                    )
+                    inline_weight_ssas.append(cast_ssa)
+                else:
+                    inline_weight_ssas.append(source_ssa)
+            else:
+                # Multi-coefficient: sum the literal values from body_constants,
+                # then emit a fresh arith.constant carrying the summed value.
+                # This handles the polybench conv3d case where the same input
+                # appears in multiple muls with different literal constants
+                # (the _factor_redundant_muls normalisation in kernel_match.py
+                # told the matcher this is a single conceptual weight).
+                summed = 0.0
+                if body_constants is not None:
+                    for ssa in w:
+                        summed += body_constants.get(ssa, 0.0)
+                synth_ssa = f"%cst_synth_{synth_idx}"
+                synth_idx += 1
+                # Format the constant literal in MLIR's normal form. f64 / f32
+                # take a decimal float; integer types take a base-10 int.
+                if inline_weight_type.startswith("f"):
+                    lit = repr(summed)
+                    if not (("." in lit) or ("e" in lit) or ("E" in lit)):
+                        lit = lit + ".0"
+                else:
+                    lit = str(int(summed))
+                weight_cast_lines.append(
+                    f"{indent}{synth_ssa} = arith.constant {lit} : {inline_weight_type}"
+                )
+                inline_weight_ssas.append(synth_ssa)
+    cast_lines.extend(weight_cast_lines)
+
+    # Cap-bound scalars from bindings. When surface_inline_weights is in
+    # effect, the template's weight Caps are already covered by the inline
+    # surfacing — emitting them again would produce duplicate operands and
+    # break the lowering. Suppress them in that case.
+    scalar_ssas: list[str] = []
+    if not inline_weight_ssas:
+        for tmpl_name, bound in bindings.items():
+            if isinstance(bound, tuple) and len(bound) == 2 and bound[0] == "Cap":
+                # Mask Caps (template names like "%mask", "%mask1", ...) bind
+                # to internal cmpi result SSAs that aren't real scalar arguments
+                # — they're an artifact of the encoder treating arith.cmpi as
+                # opaque. Skip them; the canonical kernel.defn body
+                # reconstructs the mask from its own linalg.index + cmpi.
+                if tmpl_name.startswith("%mask"):
+                    continue
+                scalar_ssas.append(bound[1])
+    all_operands = operands + scalar_ssas + inline_weight_ssas
+    operand_str = ", ".join(all_operands)
+
+    # Build the function-type signature for the launch.
+    sig_types: list[str] = []
+    if operand_types is None or len(operand_types) != len(operands):
+        sig_types.extend("!any" for _ in operands)
+    else:
+        sig_types.extend(operand_types)
+    for s in scalar_ssas:
+        if scalar_type_map and s in scalar_type_map:
+            sig_types.append(scalar_type_map[s])
+        else:
+            sig_types.append("!any")
+    # Inline-weight types: all the same element type (per-template config).
+    for _ in inline_weight_ssas:
+        sig_types.append(inline_weight_type)
+
+    sig = f"({', '.join(sig_types)})"
+    cast_prefix = "\n".join(cast_lines) + ("\n" if cast_lines else "")
+    if result_ssa is None or result_type is None:
+        # Memref-form / void launch.
+        return f"{cast_prefix}{indent}kernel.launch @{name}({operand_str}) : {sig} -> ()"
+    launch_result_ssa = result_ssa
+    launch_result_type = result_type
+    result_bind = result_ssa if result_count <= 1 else f"{result_ssa}:{result_count}"
+    result_cast = ""
+    dyn_result_type = _dynamic_tensor_type(result_type)
+    if dyn_result_type is not None and dyn_result_type != result_type:
+        launch_result_ssa = _derived_ssa_name(result_ssa, "tdyn")
+        launch_result_type = dyn_result_type
+        result_bind = (
+            launch_result_ssa
+            if result_count <= 1
+            else f"{launch_result_ssa}:{result_count}"
+        )
+        result_cast = (
+            f"\n{indent}{result_ssa} = tensor.cast {launch_result_ssa} : "
+            f"{dyn_result_type} to {result_type}"
+        )
+    return (
+        f"{cast_prefix}{indent}{result_bind} = kernel.launch "
+        f"@{name}({operand_str}) : {sig} -> {launch_result_type}"
+        f"{result_cast}"
+    )
+
+
+def _render_contraction_launch(
+    name: str,
+    result_ssa: str,
+    result_type: str,
+    operands: list[str],
+    operand_types: list[str],
+    indexing_maps: list[str],
+    indent: str,
+    unranked_abi: bool = False,
+) -> str:
+    """Render a contraction launch while preserving its affine access maps.
+
+    The ABI lowering uses these maps together with polygeist.submap metadata
+    to recover the physical strides and cuTensorNet mode labels. Keeping the
+    maps on the launch is what makes this route layout-aware rather than the
+    old body-shape-only cublasGemmFor1x1Conv guess.
+    """
+    # A source tensor can feed several matched contractions. Include the
+    # result SSA in each normalization-cast name so those launches do not
+    # emit duplicate SSA definitions such as `%v47_tc0`.
+    unique = re.sub(r"\W", "_", result_ssa.lstrip("%"))
+    lines: list[str] = []
+    normalized_operands: list[str] = []
+    normalized_types: list[str] = []
+    for idx, (operand, operand_type) in enumerate(
+            zip(operands, operand_types)):
+        target = (
+            f"tensor<*x{_sniff_elem_type(operand_type)}>"
+            if unranked_abi else _dynamic_tensor_type(operand_type)
+        )
+        if target is not None and target != operand_type:
+            cast_ssa = _derived_ssa_name(
+                operand, f"contract_{unique}_tc{idx}"
+            )
+            lines.append(
+                f"{indent}{cast_ssa} = tensor.cast {operand} : "
+                f"{operand_type} to {target}"
+            )
+            normalized_operands.append(cast_ssa)
+            normalized_types.append(target)
+        else:
+            normalized_operands.append(operand)
+            normalized_types.append(operand_type)
+
+    attrs = "{contraction_maps = [" + ", ".join(indexing_maps) + "]}"
+    dynamic_result_type = (
+        f"tensor<*x{_sniff_elem_type(result_type)}>"
+        if unranked_abi else (_dynamic_tensor_type(result_type) or result_type)
+    )
+    launch_result = result_ssa
+    result_cast = ""
+    if dynamic_result_type != result_type:
+        launch_result = _derived_ssa_name(result_ssa, "tdyn")
+        result_cast = (
+            f"\n{indent}{result_ssa} = tensor.cast {launch_result} : "
+            f"{dynamic_result_type} to {result_type}"
+        )
+    lines.append(
+        f"{indent}{launch_result} = kernel.launch @{name}"
+        f"({', '.join(normalized_operands)}) {attrs} : "
+        f"({', '.join(normalized_types)}) -> {dynamic_result_type}"
+        f"{result_cast}"
+    )
+    return "\n".join(lines)
+
+
+def rewrite_mlir(
+    text: str,
+    dry_run: bool = False,
+    roundtrip_markers: bool = False,
+    show_candidates: bool = False,
+    show_semantic_only: bool = False,
+    max_launches: int | None = None,
+) -> tuple[str, list[tuple]]:
+    """Run the matcher on `text` and return (rewritten_text, match_report).
+
+    match_report: list of (kernel_name_or_None, body_indices, launch_name).
+
+    When `roundtrip_markers` is set, each emitted `kernel.launch` is preceded
+    by a comment block holding the original linalg.generic span verbatim,
+    bounded by ``// POLYGEIST-MATCH-BEGIN-`` / ``// POLYGEIST-MATCH-END``
+    markers. This lets `kernel_launch_lower.py` undo the rewrite for e2e
+    correctness testing — see notes/raise_correctness_testing.md.
+    """
+    consts = parse_constants(text)
+    bodies = parse_generics(text, consts)
+    instances = collect_generics_with_spans(text)
+    scalar_types = _scan_scalar_types(text)
+    if len(bodies) != len(instances):
+        # Re-parser disagrees with our regex span scanner; bail clean.
+        return text, [("warning", None, f"parser drift: {len(bodies)} vs {len(instances)}")]
+
+    body_terms = []
+    for b in bodies:
+        try:
+            body_terms.append(encode_body(b))
+        except Exception:
+            body_terms.append(None)
+
+    # Per-body form ("tensor" / "memref"), aligned with `instances`.
+    # Multi-result tensor generics print as `%x:2 = linalg.generic ...`; the
+    # lightweight block regex intentionally starts at `linalg.generic`, so
+    # `result_ssa` is absent for that form. Use the trailing result type to
+    # classify tensor-vs-memref instead.
+    body_forms = [
+        "tensor" if (inst.result_type and "tensor<" in inst.result_type)
+        else "memref"
+        for inst in instances
+    ]
+
+    comps = composition_library()
+
+    # Walk bodies front-to-back, greedy-match compositions.
+    report: list[tuple] = []
+    if dry_run and show_candidates:
+        for cand_i in range(len(body_terms)):
+            for cand in enumerate_semantic_candidates(
+                bodies, body_terms, comps, start=cand_i, body_forms=body_forms
+            ):
+                has_backend = _candidate_backend(cand) is not None
+                if not has_backend and not show_semantic_only:
+                    continue
+                report.append((
+                    "kernel_candidate" if has_backend else "semantic_debug",
+                    list(cand.body_indices),
+                    _format_candidate_for_report(
+                        cand, include_semantic_only=show_semantic_only
+                    ),
+                ))
+
+    edits: list[tuple[int, int, str]] = []   # (start, end, replacement)
+    emitted_launches = 0
+    i = 0
+    while i < len(body_terms):
+        # Bias initialization followed by the canonical 3D convolution
+        # contraction is one cuDNN operation.  Egglog intentionally reasons
+        # about scalar bodies and therefore sees the first stage as a copy;
+        # the iterator/access metadata below supplies the missing tensor-level
+        # proof that it is an OC bias broadcast into an NCDHW result.
+        if i + 1 < len(bodies):
+            init_body = bodies[i]
+            conv_body = bodies[i + 1]
+            init_inst = instances[i]
+            conv_inst = instances[i + 1]
+            init_ins = _extract_ssa_names(init_inst.ins_part)
+            init_in_types = _extract_ssa_types(init_inst.ins_part)
+            init_outs = _extract_ssa_names(init_inst.outs_part)
+            init_out_types = _extract_ssa_types(init_inst.outs_part)
+            conv_ins = _extract_ssa_names(conv_inst.ins_part)
+            conv_in_types = _extract_ssa_types(conv_inst.ins_part)
+            conv_outs = _extract_ssa_names(conv_inst.outs_part)
+            conv_text = "\n".join(conv_body.body_lines)
+            is_bias_conv3d = (
+                len(init_ins) == len(init_outs) == 1
+                and len(init_body.ins_arg_names) == 1
+                and init_body.yield_values == init_body.ins_arg_names
+                and init_body.iterator_types == ["parallel"] * 4
+                and [_shaped_rank(t) for t in init_in_types] == [1]
+                and [_shaped_rank(t) for t in init_out_types] == [4]
+                and len(conv_ins) == 2 and len(conv_outs) == 1
+                and [_shaped_rank(t) for t in conv_in_types] == [8, 5]
+                and [_shaped_rank(t) for t in
+                     _extract_ssa_types(conv_inst.outs_part)] == [4]
+                and conv_body.iterator_types ==
+                    ["parallel"] * 4 + ["reduction"] * 4
+                and _is_forward_conv3d_window(text, conv_ins[0])
+                and "arith.mulf" in conv_text
+                and "arith.addf" in conv_text
+                and init_inst.result_ssa is not None
+                and conv_outs == [init_inst.result_ssa]
+                and conv_inst.result_ssa is not None
+                and conv_inst.result_type is not None
+                and all(_sniff_elem_type(t) == "f32" for t in
+                        init_in_types + init_out_types + conv_in_types)
+            )
+            if is_bias_conv3d:
+                emit_name = "cudnnConvolution3D_f32_bias"
+                if max_launches is not None and emitted_launches >= max_launches:
+                    report.append(("launch_limit", [i, i + 1], emit_name))
+                    i += 2
+                    continue
+                # The runtime overwrites the original output slice, so pass
+                # the init destination, not the bias-filled SSA result.
+                launch_operands = conv_ins + init_ins + init_outs
+                launch_types = conv_in_types + init_in_types + init_out_types
+                launch_line = render_launch(
+                    emit_name, conv_inst.result_ssa, conv_inst.result_type,
+                    launch_operands, conv_inst.indent, {}, [],
+                    operand_types=launch_types,
+                    scalar_type_map=scalar_types,
+                    result_count=conv_inst.result_count,
+                )
+                edits.append((init_inst.span[0], init_inst.span[1], ""))
+                edits.append((conv_inst.span[0], conv_inst.span[1],
+                              launch_line))
+                report.append(("match", [i, i + 1], emit_name))
+                emitted_launches += 1
+                i += 2
+                continue
+        if body_terms[i] is None:
+            report.append(("encoder_fail", i, "?"))
+            i += 1
+            continue
+        m = match_composition(bodies, body_terms, comps, start=i,
+                              body_forms=body_forms)
+        if m is None:
+            entry = match_elementwise_semantic(
+                bodies[i], body_terms[i], body_forms[i]
+            )
+            if entry is None:
+                report.append(("no_match", i, "?"))
+                i += 1
+                continue
+            binds = {}
+            n = 1
+        else:
+            entry, _, binds = m
+            n = len(entry.steps)
+        report.append(("match", list(range(i, i + n)), entry.name))
+
+        # Build a single kernel.launch covering instances[i..i+n-1].
+        # We emit the launch *in place of the last generic* and delete the
+        # earlier generics individually — that way any ops sitting BETWEEN
+        # the matched generics (e.g. a `polygeist.submap` that the
+        # contraction generic reads as an operand) are preserved
+        # verbatim. Replacing the whole span [first.start, last.end]
+        # with one launch would drop those intervening defs and leave
+        # the launch referring to undefined SSA values.
+        start = instances[i].span[0]
+        end = instances[i + n - 1].span[1]
+        # Operands: gather all tensor ins + the *first* outs (the chain root).
+        all_tensor_ins: list[str] = []
+        all_tensor_in_types: list[str] = []
+        for j in range(n):
+            inst = instances[i + j]
+            all_tensor_ins.extend(_extract_ssa_names(inst.ins_part))
+            all_tensor_in_types.extend(_extract_ssa_types(inst.ins_part))
+        outs0 = _extract_ssa_names(instances[i].outs_part)
+        outs0_types = _extract_ssa_types(instances[i].outs_part)
+        operands = all_tensor_ins + outs0
+        operand_types = all_tensor_in_types + outs0_types
+        # Canonicalize input-operand order: higher-rank tensors first. For
+        # bodies that are commutative in their two ins (e.g. gemv = out +
+        # In(0)*In(1)), the matcher binds In(0)/In(1) in source-text order,
+        # which produces (1D, 2D) for some callers and (2D, 1D) for others.
+        # Reordering by rank gives a single canonical operand layout per
+        # library entry so one kernel.defn suffices. Only sort the *inputs*
+        # (`all_tensor_ins`); the launch's `outs0` is the chain root and
+        # stays at its position. Safe only because library bodies treat the
+        # two inputs symmetrically — the entries we ship in
+        # kernel_library_phase2.mlir all do.
+        def _tensor_rank(t: str) -> int:
+            # `tensor` → 2 ; `tensor` → 1 ; etc.
+            inside = t[t.find("<") + 1 : t.rfind(">")]
+            shape = inside.rsplit("x", 1)[0]
+            return shape.count("x") + 1 if shape else 0
+        if len(all_tensor_ins) >= 2:
+            paired = sorted(
+                zip(all_tensor_in_types, all_tensor_ins),
+                key=lambda p: -_tensor_rank(p[0]),
+            )
+            sorted_types, sorted_names = zip(*paired)
+            operands = list(sorted_names) + outs0
+            operand_types = list(sorted_types) + outs0_types
+        # The launch's result is the LAST generic's result SSA + type.
+        last = instances[i + n - 1]
+
+        # Symbol-name override: same body shape can come from different
+        # operand-rank patterns that need different canonical defns. The
+        # only case today: `cublasDcopy` body = In(0) fires on both
+        #   - 1D-to-1D identity copy (doitgen)
+        #   - scalar broadcast to 1D (fdtd-2d source-inject)
+        # Distinguish by the input operand type: if it's a 0-D memref
+        # (rank-0, written as `memref<, strided<...>>`), emit
+        # `@broadcast_scalar_to_vec` instead. We use the operand type
+        # rather than the indexing_map because parse_generics doesn't
+        # resolve `#map` symbol references (only inline affine_map).
+        emit_name = entry.name
+        replace_full_span = False
+        custom_launch_line: str | None = None
+        custom_first_launch_line: str | None = None
+        custom_edit_span: tuple[int, int] | None = None
+
+        def _tensor_copy_layout_is_legal() -> bool:
+            """Conservatively prove that a semantic `yield %in` is memcpy.
+
+            Body equivalence alone also matches transpose, pixel-shuffle, and
+            view-gather operations.  The CUDA copy shims are flat contiguous
+            copies, so require identical indexing maps and identical shaped
+            tensor types, and reject sources produced by polygeist.submap.
+            """
+            copy_body = bodies[i]
+            if (len(copy_body.indexing_maps) != 2 or
+                    copy_body.indexing_maps[0] != copy_body.indexing_maps[1]):
+                return False
+            if (len(all_tensor_in_types) != 1 or len(outs0_types) != 1 or
+                    all_tensor_in_types[0] != outs0_types[0]):
+                return False
+            source = all_tensor_ins[0] if all_tensor_ins else ""
+            if source:
+                prefix = text[:instances[i].span[0]]
+                if re.search(
+                        rf"^\s*{re.escape(source)}\s*=\s*polygeist\.submap\b",
+                        prefix, re.MULTILINE):
+                    return False
+            return True
+
+        if entry.name == "cublasDcopy" and n == 1:
+            in0_ty = all_tensor_in_types[0] if all_tensor_in_types else ""
+            # rank-0 memref: starts with `memref<` and the chunk before the
+            # outermost `,` or `>` contains no `x` (i.e. just the elem type).
+            if in0_ty.startswith("memref<"):
+                inside = in0_ty[len("memref<"):].split(",", 1)[0]
+                if "x" not in inside:
+                    emit_name = "broadcast_scalar_to_vec"
+        # Tensor-form twin of the same dispatch (multi-root debufferize).
+        if entry.name == "cublasDcopy_tensor" and n == 1:
+            if not _tensor_copy_layout_is_legal():
+                report.append(("copy_layout_reject", i, entry.name))
+                i += 1
+                continue
+            in0_ty = all_tensor_in_types[0] if all_tensor_in_types else ""
+            if in0_ty.startswith("tensor<"):
+                inside = in0_ty[len("tensor<"):].split(",", 1)[0]
+                if "x" not in inside:
+                    emit_name = "broadcast_scalar_to_vec_tensor"
+            elem = _sniff_elem_type(all_tensor_in_types[0]) if all_tensor_in_types else None
+            ranks = [_tensor_rank(t) for t in operand_types[:2]]
+            if elem == "f32" and len(ranks) == 2 and ranks[0] == ranks[1]:
+                if ranks[0] == 1:
+                    emit_name = "cudaCopy1D_f32_tensor"
+                elif ranks[0] == 2:
+                    emit_name = "cudaCopy2D_f32_tensor"
+                else:
+                    report.append(("rank_or_dtype_reject", i, entry.name))
+                    i += 1
+                    continue
+            elif emit_name == "cublasDcopy_tensor":
+                if not (elem == "f64" and len(ranks) == 2 and ranks == [1, 1]):
+                    report.append(("rank_or_dtype_reject", i, entry.name))
+                    i += 1
+                    continue
+
+        if entry.name in ("tensor_copy_2D", "tensor_copy_3D",
+                          "tensor_copy_6D"):
+            if not _tensor_copy_layout_is_legal():
+                report.append(("copy_layout_reject", i, entry.name))
+                i += 1
+                continue
+            expected_rank = {
+                "tensor_copy_2D": 2,
+                "tensor_copy_3D": 3,
+                "tensor_copy_6D": 6,
+            }[entry.name]
+            elem = _sniff_elem_type(all_tensor_in_types[0]) if all_tensor_in_types else None
+            ranks = [_tensor_rank(t) for t in operand_types[:2]]
+            if elem == "f32" and len(ranks) == 2 and ranks == [
+                    expected_rank, expected_rank]:
+                emit_name = f"cudaCopy{expected_rank}D_f32_tensor"
+            else:
+                report.append(("rank_or_dtype_reject", i, entry.name))
+                i += 1
+                continue
+
+        if entry.name == "cudnnAddTensor_batched":
+            # The runtime wrapper implements cuDNN's NCHW AddTensor path for
+            # rank-4 f32 only.  Elementwise-add semantics also occur in the
+            # FP64 MFEM stages, but cuDNN cannot execute that signature and no
+            # canonical kernel.defn exists for it.  Preserve those adds as
+            # residual Linalg.
+            ranks = [_tensor_rank(t) for t in operand_types[:2]]
+            elems = [_sniff_elem_type(t) for t in operand_types[:2]]
+            if len(operand_types) != 2 or ranks != [4, 4] or elems != ["f32", "f32"]:
+                report.append(("rank_or_dtype_reject", i, entry.name))
+                i += n
+                continue
+
+        if entry.name == "cublasDaxpby":
+            # The semantic template permits implicit unit coefficients, but
+            # the public ABI is exactly (x, y, alpha, beta) over contiguous
+            # rank-1 f64 vectors.  Do not emit the historical two-operand
+            # rank-N launch: it cannot verify against the kernel definition
+            # and flattening a strided tensor would be incorrect.
+            ranks = [_tensor_rank(t) for t in operand_types[:2]]
+            elems = [_sniff_elem_type(t) for t in operand_types[:2]]
+            if len(operand_types) != 2 or ranks != [1, 1] or elems != ["f64", "f64"]:
+                report.append(("rank_or_dtype_reject", i, entry.name))
+                i += n
+                continue
+
+            scalar_names: list[str] = []
+            scalar_lines: list[str] = []
+            for coefficient in ("%alpha", "%beta"):
+                bound = binds.get(coefficient)
+                if (isinstance(bound, tuple) and len(bound) == 2 and
+                        bound[0] == "Cap"):
+                    scalar_names.append(bound[1])
+                    continue
+                if (isinstance(bound, tuple) and len(bound) == 2 and
+                        bound[0] == "Lit"):
+                    suffix = coefficient.lstrip("%")
+                    scalar = _derived_ssa_name(last.result_ssa, suffix)
+                    value = repr(float(bound[1]))
+                    if "." not in value and "e" not in value and "E" not in value:
+                        value += ".0"
+                    scalar_lines.append(
+                        f"{last.indent}{scalar} = arith.constant {value} : f64"
+                    )
+                    scalar_names.append(scalar)
+                    continue
+                report.append(("coefficient_reject", i, entry.name))
+                break
+            if len(scalar_names) != 2:
+                i += n
+                continue
+            rendered = render_launch(
+                entry.name, last.result_ssa, last.result_type,
+                operands + scalar_names, last.indent, {}, [],
+                operand_types=operand_types + ["f64", "f64"],
+                scalar_type_map=scalar_types,
+                result_count=last.result_count,
+            )
+            custom_launch_line = "\n".join(scalar_lines + [rendered])
+
+        if entry.name in (
+                "cublasGemmFor1x1Conv",
+                "cutensornetContraction2_f64"):
+            # Route two-input FP64 sum contractions through a layout-aware
+            # cuTensorNet ABI, but only after proving their Einstein semantics.
+            # The generic entry intentionally has no fixed iterator counts:
+            # reduction modes and output modes are derived from the actual
+            # linalg.generic rather than assuming the historical 3D d4 case.
+            contraction_inst = instances[i + n - 1]
+            contraction_body = bodies[i + n - 1]
+            contraction_ins = _extract_ssa_names(
+                contraction_inst.ins_part
+            )
+            contraction_in_types = _extract_ssa_types(
+                contraction_inst.ins_part
+            )
+            actual_contraction_outs = _extract_ssa_names(
+                contraction_inst.outs_part
+            )
+
+            # An opaque library call currently cannot safely consume a submap
+            # whose base is itself a computed tensor (notably an MFEM
+            # quadrature result assembled through submapInverse).  Converting
+            # that tensor to a raw pointer before one-shot bufferization can
+            # select an earlier aliased buffer.  Keep such contractions as
+            # residual Linalg until the runtime call is represented by a
+            # bufferizable op with explicit read/write effects.
+            prefix = text[:contraction_inst.span[0]]
+
+            def _computed_submap_base(value: str) -> bool:
+                matches = list(re.finditer(
+                    rf"^\s*{re.escape(value)}\s*=\s*polygeist\.submap\(\s*(%[\w.$-]+)",
+                    prefix, re.MULTILINE,
+                ))
+                if not matches:
+                    return False
+                base = matches[-1].group(1)
+                if base.startswith("%arg"):
+                    return False
+                direct_arg_view = re.search(
+                    rf"^\s*{re.escape(base)}\s*=\s*bufferization\.to_tensor\s+%arg\d+\b",
+                    prefix, re.MULTILINE,
+                )
+                return direct_arg_view is None
+
+            if any(_computed_submap_base(value)
+                   for value in contraction_ins[:2]):
+                report.append(("computed_submap_base_reject", i, entry.name))
+                i += n
+                continue
+            init_results = (
+                [instances[i].result_ssa]
+                if instances[i].result_ssa else []
+            )
+            direct_init_chain = actual_contraction_outs == init_results
+            # When the contraction consumes the zero generic directly, pass
+            # the zero generic's destination to the beta=0 runtime and erase
+            # the redundant zero result.  Re-viewed scratch outputs must keep
+            # their intermediate chain and use the contraction's actual view.
+            output_inst = instances[i] if direct_init_chain else contraction_inst
+            contraction_outs = _extract_ssa_names(output_inst.outs_part)
+            contraction_out_types = _extract_ssa_types(output_inst.outs_part)
+            maps = contraction_body.indexing_maps
+
+            def _pure_dim_outputs(map_text: str) -> list[int] | None:
+                match = re.fullmatch(
+                    r"affine_map<\([^)]*\)\s*->\s*\(([^)]*)\)>",
+                    map_text.strip(),
+                )
+                if not match:
+                    return None
+                outputs = []
+                for expr in match.group(1).split(","):
+                    dim = re.fullmatch(r"\s*d(\d+)\s*", expr)
+                    if not dim:
+                        return None
+                    outputs.append(int(dim.group(1)))
+                return outputs
+
+            map_dims = (
+                [_pure_dim_outputs(map_text) for map_text in maps]
+                if len(maps) == 3 else []
+            )
+            reduction_dims = {
+                dim for dim, role in enumerate(contraction_body.iterator_types)
+                if role == "reduction"
+            }
+
+            def _resolve_affine_map(map_ref: str) -> str | None:
+                map_ref = map_ref.strip()
+                if map_ref.startswith("affine_map<"):
+                    return map_ref
+                if not map_ref.startswith("#"):
+                    return None
+                match = re.search(
+                    rf"(?m)^\s*{re.escape(map_ref)}\s*=\s*"
+                    r"(affine_map<.*?>)\s*$",
+                    text,
+                )
+                return match.group(1) if match else None
+
+            def _physical_broadcast_modes(
+                    operand: str, access_dims: list[int] | None) -> set[int]:
+                """Return access modes proved to have zero physical stride.
+
+                A polygeist.submap flattened map that omits an operand
+                dimension gives that logical dimension stride zero.  This is
+                how scratch-sliced MFEM represents an output whose apparent
+                Linalg rank still contains a reduction dimension.
+                """
+                if access_dims is None:
+                    return set()
+                definition = re.search(
+                    rf"(?s){re.escape(operand)}\s*=\s*polygeist\.submap"
+                    r"\([^)]*\)\s*\{map\s*=\s*([^}]+)\}",
+                    text,
+                )
+                if not definition:
+                    return set()
+                flat_map = _resolve_affine_map(definition.group(1))
+                if not flat_map:
+                    return set()
+                result = re.search(r"->\s*\((.*)\)\s*>", flat_map)
+                if not result:
+                    return set()
+                flat_expr = result.group(1)
+                return {
+                    mode for axis, mode in enumerate(access_dims)
+                    if not re.search(rf"\bd{axis}\b", flat_expr)
+                }
+
+            output_broadcast_modes = (
+                _physical_broadcast_modes(
+                    contraction_outs[0],
+                    map_dims[2] if len(map_dims) == 3 else None,
+                )
+                if contraction_outs else set()
+            )
+            compact_output_dims = (
+                [mode for mode in map_dims[2]
+                 if mode not in output_broadcast_modes]
+                if len(map_dims) == 3 and map_dims[2] is not None else []
+            )
+            elem_types = [
+                _sniff_elem_type(ty)
+                for ty in contraction_in_types + contraction_out_types
+            ]
+            ranks = [
+                _tensor_rank(ty)
+                for ty in contraction_in_types + contraction_out_types
+            ]
+
+            # A zero initializer followed by a rank-2 × rank-1 contraction is
+            # GEMV with beta=0.  The shared contraction recognizer reaches this
+            # shape before the one-step GEMV entry, so route it here instead of
+            # rejecting f32 as an unsupported cuTensorNet contraction.  Emit
+            # the zero and GEMV launches as a complete two-call replacement;
+            # the existing GEMV ABI has beta=1 and therefore consumes the
+            # explicitly initialized accumulator.
+            parallel_dims = {
+                dim for dim, role in enumerate(contraction_body.iterator_types)
+                if role == "parallel"
+            }
+            is_gemv = (
+                len(contraction_ins) == 2
+                and len(contraction_outs) == 1
+                and sorted(ranks[:2]) == [1, 2]
+                and ranks[2:] == [1]
+                and len(parallel_dims) == 1
+                and len(reduction_dims) == 1
+                and len(map_dims) == 3
+                and all(dims is not None for dims in map_dims)
+                and elem_types in (["f32"] * 3, ["f64"] * 3)
+                and instances[i].result_ssa is not None
+                and instances[i].result_type is not None
+                and last.result_ssa is not None
+                and last.result_type is not None
+            )
+            is_conv3d_f32 = (
+                len(contraction_ins) == 2
+                and len(contraction_outs) == 1
+                and ranks == [8, 5, 4]
+                and elem_types == ["f32", "f32", "f32"]
+                and len(parallel_dims) == 4
+                and len(reduction_dims) == 4
+                and map_dims == [list(range(8)), [0, 4, 5, 6, 7],
+                                 [0, 1, 2, 3]]
+                and _is_forward_conv3d_window(text, contraction_ins[0])
+                and last.result_ssa is not None
+                and last.result_type is not None
+            )
+            if is_conv3d_f32:
+                emit_name = "cudnnConvolution3D_f32"
+                operands = contraction_ins + contraction_outs
+                operand_types = contraction_in_types + contraction_out_types
+                custom_launch_line = render_launch(
+                    emit_name, last.result_ssa, last.result_type,
+                    operands, last.indent, {}, [],
+                    operand_types=operand_types,
+                    scalar_type_map=scalar_types,
+                    result_count=last.result_count,
+                )
+            elif is_gemv:
+                elem = elem_types[0]
+                init_outs = _extract_ssa_names(instances[i].outs_part)
+                init_types = _extract_ssa_types(instances[i].outs_part)
+                if len(init_outs) != 1 or len(init_types) != 1:
+                    report.append(("gemv_init_reject", i, entry.name))
+                    i += n
+                    continue
+                zero_name = ("memset_zero_1D_f32" if elem == "f32"
+                             else "memset_zero_1D")
+                init_line = render_launch(
+                    zero_name, instances[i].result_ssa,
+                    instances[i].result_type, init_outs,
+                    instances[i].indent, {}, [], operand_types=init_types,
+                    scalar_type_map=scalar_types,
+                    result_count=instances[i].result_count,
+                )
+                paired_inputs = sorted(
+                    zip(contraction_in_types, contraction_ins),
+                    key=lambda pair: -_tensor_rank(pair[0]),
+                )
+                gemv_types = [pair[0] for pair in paired_inputs] + [
+                    contraction_out_types[0]
+                ]
+                gemv_operands = [pair[1] for pair in paired_inputs] + [
+                    contraction_outs[0]
+                ]
+                a_dims = map_dims[contraction_ins.index(gemv_operands[0])]
+                y_dims = map_dims[2]
+                transposed = bool(a_dims and y_dims and
+                                  a_dims[0] != y_dims[0])
+                gemv_name = (
+                    ("cublasSgemv_T" if transposed else "cublasSgemv")
+                    if elem == "f32" else
+                    ("cublasDgemv_T" if transposed else "cublasDgemv")
+                )
+                gemv_line = render_launch(
+                    gemv_name, last.result_ssa, last.result_type,
+                    gemv_operands, last.indent, {}, [],
+                    operand_types=gemv_types,
+                    scalar_type_map=scalar_types,
+                    result_count=last.result_count,
+                )
+                emit_name = gemv_name
+                operands = gemv_operands
+                operand_types = gemv_types
+                custom_first_launch_line = init_line
+                custom_launch_line = gemv_line
+            # A pair of vectors contracted without a reduction is an outer
+            # product.  The composition's first generic is a zero fill, so
+            # use an overwrite-mode runtime entry and replace both stages.
+            # Order the vectors by the corresponding output mode rather than
+            # by source operand order so the ABI is always u[M], v[N], C[M,N].
+            elif (
+                len(contraction_ins) == 2
+                and len(contraction_outs) == 1
+                and ranks == [1, 1, 2]
+                and elem_types == ["f64", "f64", "f64"]
+                and len(parallel_dims) == 2
+                and not reduction_dims
+                and len(map_dims) == 3
+                and all(dims is not None for dims in map_dims)
+                and len(map_dims[0]) == len(map_dims[1]) == 1
+                and len(map_dims[2]) == 2
+                and set(map_dims[0] + map_dims[1]) == set(map_dims[2])
+                and map_dims[0][0] != map_dims[1][0]
+                and last.result_ssa is not None
+                and last.result_type is not None
+            ):
+                by_mode = {
+                    map_dims[0][0]: (contraction_ins[0],
+                                     contraction_in_types[0]),
+                    map_dims[1][0]: (contraction_ins[1],
+                                     contraction_in_types[1]),
+                }
+                ordered = [by_mode[mode] for mode in map_dims[2]]
+                operands = [pair[0] for pair in ordered] + contraction_outs
+                operand_types = [pair[1] for pair in ordered] + \
+                    contraction_out_types
+                emit_name = "cublasDgemm_outer_product"
+                custom_launch_line = render_launch(
+                    emit_name, last.result_ssa, last.result_type,
+                    operands, last.indent, {}, [],
+                    operand_types=operand_types,
+                    scalar_type_map=scalar_types,
+                    result_count=last.result_count,
+                )
+            # A[B,M,K] * B[K,N] -> C[B,M,N], with B shared by every
+            # batch, is cublasSgemmStridedBatched with strideB=0.  Keep this
+            # route deliberately strict about mode order: the runtime ABI is
+            # row-major and must not silently reinterpret transposed views.
+            elif (
+                len(contraction_ins) == 2
+                and len(contraction_outs) == 1
+                and ranks == [3, 2, 3]
+                and elem_types == ["f32", "f32", "f32"]
+                and len(parallel_dims) == 3
+                and len(reduction_dims) == 1
+                and len(map_dims) == 3
+                and all(dims is not None for dims in map_dims)
+                and len(map_dims[0]) == 3
+                and len(map_dims[1]) == 2
+                and len(map_dims[2]) == 3
+                and map_dims[0][:2] == map_dims[2][:2]
+                and map_dims[0][2] in reduction_dims
+                and map_dims[1][0] == map_dims[0][2]
+                and map_dims[1][1] == map_dims[2][2]
+                and last.result_ssa is not None
+                and last.result_type is not None
+            ):
+                emit_name = "cublasSgemm_strided_batched_broadcast_rhs"
+                operands = contraction_ins + contraction_outs
+                operand_types = contraction_in_types + contraction_out_types
+                custom_launch_line = render_launch(
+                    emit_name, last.result_ssa, last.result_type,
+                    operands, last.indent, {}, [],
+                    operand_types=operand_types,
+                    scalar_type_map=scalar_types,
+                    result_count=last.result_count,
+                )
+            else:
+                legal_maps = (
+                    len(map_dims) == 3
+                    and all(dims is not None for dims in map_dims)
+                    and bool(reduction_dims)
+                    and all(
+                        red in map_dims[0] or red in map_dims[1]
+                        for red in reduction_dims
+                    )
+                    and all(red not in compact_output_dims
+                            for red in reduction_dims)
+                    and all(
+                        mode in map_dims[0] or mode in map_dims[1]
+                        for mode in compact_output_dims
+                    )
+                    and all(len(dims) == len(set(dims)) for dims in map_dims)
+                    and len(compact_output_dims) ==
+                        len(set(compact_output_dims))
+                )
+                legal_types = (
+                    len(contraction_ins) == 2
+                    and len(contraction_outs) == 1
+                    and elem_types == ["f64", "f64", "f64"]
+                    and all(rank is not None and 0 < rank <= 64
+                            for rank in ranks)
+                    and last.result_type is not None
+                    and _sniff_elem_type(last.result_type) == "f64"
+                )
+                if not legal_maps or not legal_types:
+                    report.append(("contraction_abi_reject", i, entry.name))
+                    i += n
+                    continue
+
+                legacy_names = {
+                    (4, 5, 4): "cutensornetContraction2_f64_r4r5r4",
+                    (5, 4, 4): "cutensornetContraction2_f64_r5r4r4",
+                    (5, 5, 4): "cutensornetContraction2_f64_r5r5r4",
+                }
+                emit_name = (
+                    legacy_names[tuple(ranks)]
+                    if entry.name == "cublasGemmFor1x1Conv"
+                    and tuple(ranks) in legacy_names
+                    else "cutensornetContraction2_f64"
+                )
+                # Preserve source operand order: contraction_maps correspond
+                # positionally to these operands, so the generic rank-based
+                # commutative reordering is intentionally bypassed.
+                operands = contraction_ins + contraction_outs
+                operand_types = contraction_in_types + contraction_out_types
+                custom_launch_line = _render_contraction_launch(
+                    emit_name, last.result_ssa, last.result_type,
+                    operands, operand_types, maps, last.indent,
+                    unranked_abi=(emit_name ==
+                                  "cutensornetContraction2_f64"),
+                )
+                # Some scratch-sliced stages re-view the zero-initialized
+                # tensor before contracting into it. Keep that initialization
+                # chain alive and replace only the contraction.
+                if not direct_init_chain:
+                    replace_full_span = True
+                    custom_edit_span = contraction_inst.span
+
+        # Dtype-suffix dispatch for cuDNN conv2d. The encoder's Term language
+        # is dtype-agnostic (arith.mulf matches any float type), so one
+        # template fires for f64, f32, f16, bf16 bodies. We emit a
+        # dtype-specific kernel.launch symbol so the canonical defn and the
+        # lowering pass can pick the right cuDNN shim per element type.
+        # The default (no suffix) is f64 for backward compat with the
+        # existing kernel.defn @cudnnConvolution2D_9tap declaration.
+        if entry.name == "cudnnConvolutionFwd_im2col_gemm":
+            im2col = _extract_guarded_im2col_input(bodies[i + 1].body_lines)
+            func_args = _enclosing_func_args(text, instances[i].span[0])
+            gemm_ins = _extract_ssa_names(instances[i + 2].ins_part)
+            gemm_in_types = _extract_ssa_types(instances[i + 2].ins_part)
+            if im2col is None or len(func_args) < 7 or len(gemm_ins) < 1:
+                report.append(("im2col_gemm_reject", i, entry.name))
+                i += 1
+                continue
+            input_ssa, input_ty = im2col
+            weights_ssa = gemm_ins[0]
+            weights_ty = gemm_in_types[0] if gemm_in_types else "!any"
+            output_ssa = outs0[0] if outs0 else ""
+            output_ty = outs0_types[0] if outs0_types else "!any"
+            shape_args = func_args[:7]
+            operands = [input_ssa, weights_ssa, output_ssa] + [
+                name for name, _ty in shape_args
+            ]
+            operand_types = [input_ty, weights_ty, output_ty] + [
+                ty for _name, ty in shape_args
+            ]
+            # The fused memref launch mutates the original flat output buffer.
+            last = LinalgInstance(
+                result_ssa=None,
+                result_count=0,
+                ins_part=last.ins_part,
+                outs_part=last.outs_part,
+                result_type=None,
+                span=last.span,
+                indent=last.indent,
+            )
+
+        if entry.name in ("rmsnorm_f32", "rmsnorm_unweighted_f32",
+                          "rmsnorm_scaled_unweighted_f32"):
+            # RMSNorm is a two-stage composition:
+            #   step0: ss = sum(x[i] * x[i])
+            #   step1: out[i] = weight[i] * scale * x[i]     (weighted)
+            #          out[i] = scale * x[i]                 (unweighted)
+            #          out[i] = gain * scale * x[i]          (scalar gain)
+            # The generic operand collection above only keeps the first
+            # generic's outs (the scalar ss buffer), which is not enough for
+            # ABI lowering. Emit the semantic operands directly and let the
+            # runtime recompute the reduction/scale in one call.
+            #
+            # The scalar-gain variant is recognized by the matcher factory,
+            # but we do not lower it until the runtime ABI has an explicit gain
+            # operand. Leaving it as residual linalg is safer than pretending
+            # the weighted ABI can represent it.
+            if entry.name == "rmsnorm_scaled_unweighted_f32":
+                report.append(("unsupported_abi_reject", i, entry.name))
+                i += n
+                continue
+            forms = body_forms[i : i + n]
+            x_names = _extract_ssa_names(instances[i].ins_part)
+            x_types = _extract_ssa_types(instances[i].ins_part)
+            scale_ins = _extract_ssa_names(instances[i + 1].ins_part)
+            scale_in_types = _extract_ssa_types(instances[i + 1].ins_part)
+            out_names = _extract_ssa_names(instances[i + 1].outs_part)
+            out_types = _extract_ssa_types(instances[i + 1].outs_part)
+            min_scale_ins = 2 if entry.name == "rmsnorm_f32" else 1
+            if (len(x_names) < 1 or len(scale_ins) < min_scale_ins
+                    or len(out_names) < 1 or any(f != forms[0] for f in forms)):
+                report.append(("rmsnorm_reject", i, entry.name))
+                i += 1
+                continue
+            if entry.name == "rmsnorm_f32":
+                operands = [x_names[0], scale_ins[0], out_names[0]]
+                operand_types = [x_types[0], scale_in_types[0], out_types[0]]
+            else:
+                operands = [x_names[0], out_names[0]]
+                operand_types = [x_types[0], out_types[0]]
+            binds = {}
+            if forms[0] == "tensor":
+                # Tensor RMSNorm's scalar scale chain depends on the first
+                # generic result. Since the shim recomputes the full RMSNorm,
+                # replace the whole span, including that scalar chain, with
+                # one result-producing tensor launch.
+                emit_name = (
+                    "rmsnorm_f32_tensor"
+                    if entry.name == "rmsnorm_f32"
+                    else "rmsnorm_unweighted_f32_tensor"
+                )
+                replace_full_span = True
+            else:
+                last = LinalgInstance(
+                    result_ssa=None,
+                    result_count=0,
+                    ins_part=last.ins_part,
+                    outs_part=last.outs_part,
+                    result_type=None,
+                    span=last.span,
+                    indent=last.indent,
+                )
+
+        if entry.name in ("cudnnSoftmaxForward", "cudnnSoftmaxForward_tensor"):
+            # The raised llama2 softmax has a scalar max buffer as the first
+            # generic's out, then mutates the full vector in the later two
+            # generics. Emit the full vector operand, not the max scalar nor
+            # the x[1:] subview used only for the initialized-max reduction.
+            vector_inst = (instances[i + 1] if entry.name.endswith("_tensor")
+                           else instances[i + n - 1])
+            out_names = _extract_ssa_names(vector_inst.outs_part)
+            out_types = _extract_ssa_types(vector_inst.outs_part)
+            if len(out_names) < 1:
+                report.append(("softmax_reject", i, entry.name))
+                i += 1
+                continue
+            vector_base = _trace_tensor_storage_base(text, out_names[0])
+            vector_type = _infer_tensor_type(text, vector_base)
+            if not vector_type:
+                report.append(("softmax_base_reject", i, entry.name))
+                i += 1
+                continue
+            operands = [vector_base]
+            operand_types = [vector_type]
+            binds = {}
+            if entry.name.endswith("_tensor"):
+                replace_full_span = True
+            else:
+                last = LinalgInstance(
+                    result_ssa=None,
+                    result_count=0,
+                    ins_part=last.ins_part,
+                    outs_part=last.outs_part,
+                    result_type=None,
+                    span=last.span,
+                    indent=last.indent,
+                )
+
+        if entry.name == "cudnnSoftmaxForwardOut_tensor":
+            # Standalone attention softmax is out-of-place: step1 reads the
+            # scores tensor and writes the exp-shifted values into `out`.
+            vector_inst = instances[i + 1]
+            score_names = _extract_ssa_names(vector_inst.ins_part)
+            score_types = _extract_ssa_types(vector_inst.ins_part)
+            out_names = _extract_ssa_names(vector_inst.outs_part)
+            out_types = _extract_ssa_types(vector_inst.outs_part)
+            if (len(score_names) < 1 or len(out_names) < 1 or
+                    not score_types or not out_types or
+                    _sniff_elem_type(score_types[0]) != "f32" or
+                    _sniff_elem_type(out_types[0]) != "f32"):
+                report.append(("softmax_out_reject", i, entry.name))
+                i += 1
+                continue
+            operands = [score_names[0], out_names[0]]
+            operand_types = [score_types[0], out_types[0]]
+            binds = {}
+            replace_full_span = True
+
+        if entry.name == "whisperExpShiftSum_f32_tensor":
+            inst = instances[i]
+            x_names = _extract_ssa_names(inst.ins_part)
+            x_types = _extract_ssa_types(inst.ins_part)
+            out_names = _extract_ssa_names(inst.outs_part)
+            out_types = _extract_ssa_types(inst.outs_part)
+            max_bound = binds.get("%max")
+            max_ssa = (
+                max_bound[1]
+                if isinstance(max_bound, tuple) and len(max_bound) == 2 and
+                max_bound[0] == "Cap"
+                else None
+            )
+            if (len(x_names) != 1 or len(out_names) != 2 or
+                    inst.result_ssa is None or inst.result_count != 2 or
+                    inst.result_type is None or max_ssa is None or
+                    not x_types or len(out_types) != 2 or
+                    _sniff_elem_type(x_types[0]) != "f32" or
+                    _sniff_elem_type(out_types[0]) != "f32" or
+                    _sniff_elem_type(out_types[1]) != "f32"):
+                report.append(("exp_shift_sum_reject", i, entry.name))
+                i += 1
+                continue
+            operands = [x_names[0], out_names[0], out_names[1], max_ssa]
+            operand_types = [
+                x_types[0],
+                out_types[0],
+                out_types[1],
+                scalar_types.get(max_ssa, "f32"),
+            ]
+            binds = {}
+            custom_launch_line = _render_whisper_exp_shift_sum_launch(
+                entry.name,
+                inst.result_ssa,
+                inst.result_count,
+                inst.result_type,
+                operands,
+                operand_types,
+                inst.indent,
+            )
+
+        if entry.name == "cudaMaskSelect_f32_tensor":
+            pos = _extract_cmpi_rhs_i32(bodies[i].body_lines)
+            if not pos:
+                report.append(("mask_select_reject", i, entry.name))
+                i += 1
+                continue
+            elems = [_sniff_elem_type(t) for t in operand_types[:2]]
+            ranks = [_tensor_rank(t) for t in operand_types[:2]]
+            if elems != ["f32", "f32"] or ranks != [1, 1]:
+                report.append(("rank_or_dtype_reject", i, entry.name))
+                i += 1
+                continue
+            operands = operands + [pos]
+            operand_types = operand_types + [scalar_types.get(pos, "i32")]
+            binds = {}
+
+        if entry.name in ("cudaAdd_f32_tensor", "cudaSwiGLU_f32_tensor"):
+            elems = [_sniff_elem_type(t) for t in operand_types[:3]]
+            ranks = [_tensor_rank(t) for t in operand_types[:3]]
+            if elems != ["f32", "f32", "f32"] or ranks != [1, 1, 1]:
+                report.append(("rank_or_dtype_reject", i, entry.name))
+                i += 1
+                continue
+
+        if entry.name in ("cudaRopeMulMulSub_f32_tensor",
+                          "cudaRopeMulMulAdd_f32_tensor"):
+            # Preserve the linalg operand order. The generic rank-sort above is
+            # valid for commutative BLAS templates, but RoPE semantics depend
+            # on [2D, 1D, 2D, 1D, out] ordering.
+            in_names = _extract_ssa_names(instances[i].ins_part)
+            in_types = _extract_ssa_types(instances[i].ins_part)
+            out_names = _extract_ssa_names(instances[i].outs_part)
+            out_types = _extract_ssa_types(instances[i].outs_part)
+            operands = in_names + out_names
+            operand_types = in_types + out_types
+            elems = [_sniff_elem_type(t) for t in operand_types[:5]]
+            ranks = [_tensor_rank(t) for t in operand_types[:5]]
+            if (elems != ["f32"] * 5 or ranks != [2, 1, 2, 1, 2]):
+                report.append(("rank_or_dtype_reject", i, entry.name))
+                i += 1
+                continue
+
+        if entry.name in ("elemwise_div_scalar", "elemwise_scale_input_1D",
+                          "elemwise_axpby_inputs_1D"):
+            # These templates are useful for algebraic recognition, but the
+            # current ABI lowering path does not have a complete runtime shim
+            # for them. In particular elemwise_scale_input_1D's matched launch
+            # does not yet surface the scalar scale factor as an operand, so
+            # lowering it would lose semantics. Keep the linalg.generic in
+            # place so downstream MLIR lowering handles it as residual tensor
+            # code.
+            report.append(("unsupported_abi_reject", i, entry.name))
+            i += 1
+            continue
+
+        if entry.name == "miniamr_weighted_27pt_tensor":
+            accum_inst = instances[i + n - 1]
+            accum_ins = _extract_ssa_names(accum_inst.ins_part)
+            accum_in_types = _extract_ssa_types(accum_inst.ins_part)
+            out_names = _extract_ssa_names(instances[i].outs_part)
+            out_types = _extract_ssa_types(instances[i].outs_part)
+            elem = _sniff_elem_type(out_types[0]) if out_types else None
+            if (accum_inst.result_ssa is None or accum_inst.result_type is None
+                    or len(out_names) != 1 or not out_types
+                    or elem not in ("f32", "f64")):
+                report.append(("conv3d_ntap_reject", i, entry.name))
+                i += 1
+                continue
+            window = _miniamr_weighted27_window_info(
+                text, accum_ins, accum_in_types
+            )
+            if window is None:
+                report.append(("conv3d_ntap_reject", i, entry.name))
+                i += 1
+                continue
+            input_base, input_type, weight_ssa, width = window
+            try:
+                weight_idx = accum_ins.index(weight_ssa)
+            except ValueError:
+                report.append(("conv3d_ntap_reject", i, entry.name))
+                i += 1
+                continue
+            weight_type = accum_in_types[weight_idx]
+            if (_sniff_elem_type(input_type) != elem
+                    or _sniff_elem_type(weight_type) != elem):
+                report.append(("rank_or_dtype_reject", i, entry.name))
+                i += 1
+                continue
+            emit_name = (
+                "cudnnConvolution3D_ntap_f32_tensor"
+                if elem == "f32" else "cudnnConvolution3D_ntap_tensor"
+            )
+            replace_full_span = True
+            binds = {}
+            custom_launch_line = _render_ntap_conv3d_tensor_launch(
+                emit_name,
+                accum_inst.result_ssa,
+                accum_inst.result_type,
+                input_base,
+                input_type,
+                out_names[0],
+                out_types[0],
+                weight_ssa,
+                weight_type,
+                width,
+                accum_inst.indent,
+            )
+
+        if entry.name in ("miniamr_average_7pt_tensor",
+                          "miniamr_weighted_7pt_tensor"):
+            inst = instances[i]
+            in_names = _extract_ssa_names(inst.ins_part)
+            in_types = _extract_ssa_types(inst.ins_part)
+            out_names = _extract_ssa_names(inst.outs_part)
+            out_types = _extract_ssa_types(inst.outs_part)
+            expected_inputs = 7 if entry.name == "miniamr_average_7pt_tensor" else 8
+            elem = _sniff_elem_type(out_types[0]) if out_types else None
+            ranks = [_tensor_rank(t) for t in in_types + out_types]
+            if (inst.result_ssa is None or inst.result_type is None
+                    or len(in_names) != expected_inputs or len(out_names) != 1
+                    or elem != "f64"
+                    or len(ranks) != expected_inputs + 1
+                    or any(_sniff_elem_type(t) != "f64"
+                           for t in in_types + out_types)
+                    or any(rank != 3 for rank in ranks)):
+                report.append(("rank_or_dtype_reject", i, entry.name))
+                i += 1
+                continue
+
+            if entry.name == "miniamr_average_7pt_tensor":
+                emit_name = "customStencil3D7pt_f64_tensor"
+                launch_operands = in_names + out_names
+                launch_types = in_types + out_types
+                coeffs = [0.0, 0.0, 0.0] + [1.0 / 7.0] * 7
+            else:
+                emit_name = "customStencil3D7ptCoeff_f64_tensor"
+                # Preserve the matched body order: first seven tensors are the
+                # center/six-neighbor taps, input 7 is the cell coefficient.
+                launch_operands = in_names[:7] + [in_names[7]] + out_names
+                launch_types = in_types[:7] + [in_types[7]] + out_types
+                coeffs = [1.0, 0.0, 0.0, -6.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
+            binds = {}
+            custom_launch_line = _render_custom_stencil3d7pt_launch(
+                emit_name,
+                inst.result_ssa,
+                inst.result_type,
+                launch_operands,
+                launch_types,
+                coeffs,
+                inst.indent,
+            )
+
+        if entry.name == "cufftZ2Z_1D_tensor":
+            dft_inst = instances[i + n - 1]
+            in_names = _extract_ssa_names(dft_inst.ins_part)
+            in_types = _extract_ssa_types(dft_inst.ins_part)
+            zero_out_names = _extract_ssa_names(instances[i].outs_part)
+            zero_out_types = _extract_ssa_types(instances[i].outs_part)
+            if (dft_inst.result_ssa is None or dft_inst.result_type is None
+                    or len(in_names) != 2 or len(in_types) != 2
+                    or len(zero_out_names) != 1 or len(zero_out_types) != 1):
+                report.append(("cufft_reject", i, entry.name))
+                i += 1
+                continue
+            parsed_inputs = [
+                _parse_static_extract_slice_offset(text, name)
+                for name in in_names
+            ]
+            if any(p is None for p in parsed_inputs):
+                report.append(("cufft_reject", i, entry.name))
+                i += 1
+                continue
+            input_base0, off0 = parsed_inputs[0]
+            input_base1, off1 = parsed_inputs[1]
+            if input_base0 != input_base1 or sorted([off0, off1]) != [(0, 0), (0, 1)]:
+                report.append(("cufft_reject", i, entry.name))
+                i += 1
+                continue
+            input_type = _infer_tensor_type(text, input_base0)
+            output_ssa = zero_out_names[0]
+            output_type = zero_out_types[0]
+            elem = _sniff_elem_type(output_type)
+            inverse_flag = _dft1d_inverse_flag(bodies[i + n - 1].constants)
+            inserted = _find_insert_slice_of_result(
+                text, dft_inst.span[1], dft_inst.result_ssa
+            )
+            if (input_type is None or elem not in ("f32", "f64")
+                    or _sniff_elem_type(input_type) != elem
+                    or inverse_flag is None or inserted is None):
+                report.append(("cufft_reject", i, entry.name))
+                i += 1
+                continue
+            result_ssa, result_type, insert_span = inserted
+            emit_name = (
+                "cufftC2C_1D_tensor" if elem == "f32"
+                else "cufftZ2Z_1D_tensor"
+            )
+            custom_launch_line = _render_cufft_1d_tensor_launch(
+                emit_name,
+                result_ssa,
+                result_type,
+                input_base0,
+                input_type,
+                output_ssa,
+                output_type,
+                inverse_flag,
+                dft_inst.indent,
+            )
+            if custom_launch_line is None:
+                report.append(("cufft_reject", i, entry.name))
+                i += 1
+                continue
+            replace_full_span = True
+            custom_edit_span = (start, insert_span[1])
+
+        if entry.name == "cutensornetTensorProduct3D_f32_tensor":
+            contract_inst = instances[i + n - 1]
+            in_names = _extract_ssa_names(contract_inst.ins_part)
+            in_types = _extract_ssa_types(contract_inst.ins_part)
+            out_names = _extract_ssa_names(contract_inst.outs_part)
+            out_types = _extract_ssa_types(contract_inst.outs_part)
+            ranks = [_tensor_rank(t) for t in in_types + out_types]
+            elems = [_sniff_elem_type(t) for t in in_types + out_types]
+            if (contract_inst.result_ssa is None or
+                    contract_inst.result_type is None or
+                    len(in_names) != 4 or len(out_names) != 1 or
+                    ranks != [6, 6, 6, 6, 6] or
+                    elems not in (["f32"] * 5, ["f64"] * 5)):
+                report.append(("cutensornet_reject", i, entry.name))
+                i += 1
+                continue
+            emit_name = ("cutensornetTensorProduct3D_f64_tensor"
+                         if elems[0] == "f64" else entry.name)
+            # Keep the matched zero initializer in place: it proves that the
+            # accumulator has beta=0 semantics. Replace only the contraction
+            # and pass its rank-6 views; the MLIR lowering unwraps those views
+            # to the original psi/u/out buffers and derives KQ/KP from dims.
+            operands = in_names + out_names
+            operand_types = in_types + out_types
+            binds = {}
+            last = contract_inst
+            replace_full_span = True
+            custom_edit_span = contract_inst.span
+            binds = {}
+
+        if entry.name in ("cudnnConvolution2D_ntap",
+                          "cudnnConvolution2D_ntap_tensor"):
+            in_names = _extract_ssa_names(instances[i].ins_part)
+            in_types = _extract_ssa_types(instances[i].ins_part)
+            out_names = _extract_ssa_names(instances[i].outs_part)
+            out_types = _extract_ssa_types(instances[i].outs_part)
+            if len(out_names) != 1 or len(in_names) == 0:
+                report.append(("ntap_stencil_reject", i, entry.name))
+                i += 1
+                continue
+            is_tensor_ntap = entry.name.endswith("_tensor")
+            grid = (
+                _conv2d_ntap_tensor_grid_info(text, in_names, out_names[0])
+                if is_tensor_ntap
+                else _conv2d_ntap_grid_info(text, in_names, out_names[0])
+            )
+            if grid is None:
+                report.append(("ntap_stencil_reject", i, entry.name))
+                i += 1
+                continue
+            width, top_left_ssa, ordered_indices = grid
+            elem = _sniff_elem_type(in_types[0]) if in_types else None
+            if elem not in ("f32", "f64"):
+                report.append(("rank_or_dtype_reject", i, entry.name))
+                i += 1
+                continue
+            if any(_sniff_elem_type(t) != elem for t in in_types + out_types):
+                report.append(("rank_or_dtype_reject", i, entry.name))
+                i += 1
+                continue
+            top_left_idx = in_names.index(top_left_ssa)
+            inline_weights = bodies[i].inline_weights_per_in
+            if not inline_weights or len(inline_weights) != len(in_names):
+                report.append(("ntap_weight_reject", i, entry.name))
+                i += 1
+                continue
+            ordered_weights = [inline_weights[idx] for idx in ordered_indices]
+            if is_tensor_ntap:
+                if last.result_ssa is None or last.result_type is None:
+                    report.append(("ntap_stencil_reject", i, entry.name))
+                    i += 1
+                    continue
+                emit_name = (
+                    "cudnnConvolution2D_ntap_f32_tensor"
+                    if elem == "f32" else "cudnnConvolution2D_ntap_tensor"
+                )
+                custom_launch_line = _render_ntap_conv_tensor_launch(
+                    emit_name,
+                    last.result_ssa,
+                    last.result_type,
+                    top_left_ssa,
+                    in_types[top_left_idx],
+                    out_names[0],
+                    out_types[0],
+                    width,
+                    ordered_weights,
+                    last.indent,
+                    scalar_types,
+                    bodies[i].constants,
+                    elem,
+                    i,
+                )
+            else:
+                emit_name = "cudnnConvolution2D_ntap_f32" if elem == "f32" else "cudnnConvolution2D_ntap"
+                custom_launch_line = _render_ntap_conv_launch(
+                    emit_name,
+                    top_left_ssa,
+                    in_types[top_left_idx],
+                    out_names[0],
+                    out_types[0],
+                    width,
+                    ordered_weights,
+                    last.indent,
+                    scalar_types,
+                    bodies[i].constants,
+                    elem,
+                    i,
+                )
+
+        if entry.name in ("cudnnConvolution2D_9tap",
+                          "cudnnConvolution2D_9tap_tensor"):
+            elem = _sniff_elem_type(all_tensor_in_types[0]) if all_tensor_in_types else "f64"
+            if elem and elem != "f64":
+                emit_name = f"{entry.name}_{elem}"
+        if entry.name == "cudnnConvolution2D_25tap":
+            elem = _sniff_elem_type(all_tensor_in_types[0]) if all_tensor_in_types else "f64"
+            if elem not in (None, "f64", "f32"):
+                report.append(("rank_or_dtype_reject", i, entry.name))
+                i += 1
+                continue
+            if elem == "f32":
+                emit_name = "cudnnConvolution2D_25tap_f32"
+
+        # Transpose discriminator for gemv. The template `Out + In(0)*In(1)`
+        # with 1 parallel + 1 reduction iter matches both `y = A·x` (no
+        # transpose) and `y = Aᵀ·x` (transposed). The launch operands look
+        # identical in either case — what distinguishes them is whether A's
+        # first indexing-map dim matches the output's first dim (no-transpose)
+        # or the other input's dim (transposed). Switch the concrete emit
+        # name by both transpose and dtype so f32 tensor GEMV goes to SGEMV
+        # while the shared algebraic template remains dtype-agnostic.
+        # AᵀA / A·Aᵀ → cublasDsyrk operand-alias discriminator.
+        # If a gemm-shape composition's two inputs resolve to the same
+        # underlying tensor (after walking through polygeist.submap),
+        # the math is a symmetric rank-K update — half the flops via
+        # cublasDsyrk (writes only the upper triangle). Cheap check:
+        # scan the matched body's ins SSA names, walk back to find the
+        # defining ops, compare the submap-base SSA name.
+        if entry.name in ("cublasDgemm", "cublasDgemm_simple",
+                          "cublasDgemm_alpha_only"):
+            gemm_inst = instances[i + n - 1]  # last (contraction) generic
+            gemm_ins = _extract_ssa_names(gemm_inst.ins_part)
+            if len(gemm_ins) == 2:
+                # Walk each input SSA through polygeist.submap definitions
+                # to find the underlying base. The submap defining-op line
+                # has the form `%X = polygeist.submap(%base, ...) ...`.
+                def _resolve_submap_base(ssa_name: str) -> str | None:
+                    pat = re.compile(
+                        rf'\s*{re.escape(ssa_name)}\s*=\s*polygeist\.submap'
+                        rf'\s*\(\s*(%[\w_]+)\s*[,)]'
+                    )
+                    m = pat.search(text)
+                    return m.group(1) if m else None
+                base0 = _resolve_submap_base(gemm_ins[0]) or gemm_ins[0]
+                base1 = _resolve_submap_base(gemm_ins[1]) or gemm_ins[1]
+                def _map_outputs(txt: str) -> list[str]:
+                    mm = re.search(r"->\s*\(([^)]*)\)>", txt)
+                    return [s.strip() for s in mm.group(1).split(",")] if mm else []
+                maps = bodies[i + n - 1].indexing_maps
+                in0_dims = _map_outputs(maps[0]) if len(maps) >= 2 else []
+                in1_dims = _map_outputs(maps[1]) if len(maps) >= 2 else []
+                # Same-base GEMM is not automatically SYRK. A true symmetric
+                # rank-k update has both inputs using the reduction dim in the
+                # same coordinate position, e.g. A[i,k] * A[j,k] or
+                # A[k,i] * A[k,j]. A dense square A[i,k] * A[k,j] is a normal
+                # GEMM even though both operands resolve to the same base.
+                same_base_syrk = (
+                    base0 == base1 and len(in0_dims) == 2 and len(in1_dims) == 2
+                    and (in0_dims[1] == in1_dims[1] or
+                         in0_dims[0] == in1_dims[0])
+                )
+                if same_base_syrk:
+                    emit_name = "cublasDsyrk_alias"
+            elem = _sniff_elem_type(operand_types[0]) if operand_types else None
+            operand_ranks = [_tensor_rank(t) for t in operand_types[:3]]
+            if (entry.name == "cublasDgemm_simple" and elem == "f32" and
+                    operand_ranks == [3, 3, 3]):
+                # Darknet im2col+GEMM reaches linalg as a rank-3 broadcasted
+                # view: logical (N, K, M) iteration, but the underlying buffers
+                # are the usual 2D row-major A[M,K], B[K,N], C[M,N]. Emit a
+                # dedicated symbol so ABI lowering can unwrap the submaps and
+                # call cuBLAS SGEMM.
+                emit_name = "cublasSgemm_broadcast3d_simple"
+            elif elem != "f64" or operand_ranks != [2, 2, 2]:
+                # Do not let generic rank-3/strided contractions masquerade as
+                # the plain double GEMM ABI. The extended Llama split-Q/K
+                # fixture intentionally leaves these as residual linalg until
+                # we add a real batched/split projection lowering.
+                report.append(("rank_or_dtype_reject", i, entry.name))
+                i += 1
+                continue
+        if entry.name == "memset_zero_1D":
+            elem = _sniff_elem_type(outs0_types[0]) if outs0_types else None
+            if elem == "f32":
+                emit_name = "memset_zero_1D_f32"
+        if entry.name == "memset_zero_2D":
+            elem = _sniff_elem_type(outs0_types[0]) if outs0_types else None
+            if elem == "f32":
+                emit_name = "memset_zero_2D_f32"
+        if entry.name == "cublasSgemm_broadcast3d_memref":
+            elem = _sniff_elem_type(operand_types[0]) if operand_types else None
+            operand_ranks = [_tensor_rank(t) for t in operand_types[:3]]
+            if elem != "f32" or operand_ranks != [3, 3, 3]:
+                report.append(("rank_or_dtype_reject", i, entry.name))
+                i += 1
+                continue
+        if entry.name == "cublasDgemv" and n == 1:
+            elems = [_sniff_elem_type(t) for t in operand_types[:3]]
+            elem = elems[0] if elems else None
+            operand_ranks = [_tensor_rank(t) for t in operand_types[:3]]
+            if (elem not in ("f64", "f32") or
+                    len(elems) != 3 or any(e != elem for e in elems) or
+                    operand_ranks != [2, 1, 1]):
+                report.append(("rank_or_dtype_reject", i, entry.name))
+                i += 1
+                continue
+            mb = bodies[i]
+            transposed = False
+            if len(mb.indexing_maps) == 3:
+                def _map_outputs(txt: str) -> list[str]:
+                    mm = re.search(r"->\s*\(([^)]*)\)>", txt)
+                    return [s.strip() for s in mm.group(1).split(",")] if mm else []
+                A_dims = _map_outputs(mb.indexing_maps[0])
+                y_dims = _map_outputs(mb.indexing_maps[2])
+                if A_dims and y_dims and A_dims[0] != y_dims[0]:
+                    transposed = True
+            if elem == "f32":
+                emit_name = "cublasSgemv_T" if transposed else "cublasSgemv"
+            else:
+                emit_name = "cublasDgemv_T" if transposed else "cublasDgemv"
+
+        if emit_name not in ABI_LOWERABLE_KERNELS:
+            report.append(("unsupported_abi_reject", list(range(i, i + n)),
+                           emit_name))
+            i += n
+            continue
+
+        if custom_launch_line is not None:
+            launch_line = custom_launch_line
+        else:
+            # When the matched composition opts in to weight surfacing, hand the
+            # encoder's in_arg → constant_ssa map from the FIRST matched body to
+            # render_launch. (Only single-step weighted-stencil templates use
+            # this today; if we ever support multi-step weighted compositions,
+            # this needs to combine bodies appropriately.)
+            inline_weights = (bodies[i].inline_weights_per_in
+                               if getattr(entry, "surface_inline_weights", False)
+                               else None)
+            # Surface the weight scalars with the operand's element type
+            # (f64 / f32 / f16 / bf16 / iNN), so the launch op's signature is
+            # internally consistent and the cuDNN shim's scalar args match.
+            weight_ty = "f64"
+            if inline_weights and all_tensor_in_types:
+                sniffed = _sniff_elem_type(all_tensor_in_types[0])
+                if sniffed:
+                    weight_ty = sniffed
+
+            launch_line = render_launch(
+                emit_name, last.result_ssa, last.result_type,
+                operands, last.indent, binds, [],
+                operand_types=operand_types,
+                scalar_type_map=scalar_types,
+                inline_weights=inline_weights,
+                inline_weight_type=weight_ty,
+                # Pass the body's per-SSA constant values so render_launch can
+                # materialise summed-constant ops for the polybench conv3d
+                # multi-coefficient case.
+                body_constants=bodies[i].constants if inline_weights else None,
+                result_count=last.result_count,
+            )
+        if max_launches is not None and emitted_launches >= max_launches:
+            report.append(("launch_limit", list(range(i, i + n)), emit_name))
+            i += n
+            continue
+        emitted_launches += 1
+        if custom_first_launch_line is not None:
+            emitted_launches += 1
+        if roundtrip_markers:
+            # last.indent has a leading newline ("\n    ") because the parser
+            # captures the line break before the op. Use only the spaces.
+            indent_spaces = last.indent.lstrip("\n").rstrip("\n")
+            # The original span starts mid-line at "\n    %X = linalg.generic..."
+            # so we strip the leading newline from the captured block and
+            # restore it ourselves once, before the BEGIN marker.
+            original_block = text[start:end]
+            stripped = original_block[1:] if original_block.startswith("\n") else original_block
+            commented = "\n".join(
+                f"{indent_spaces}// {ln}" if ln.strip() else f"{indent_spaces}//"
+                for ln in stripped.split("\n")
+            )
+            replacement = (
+                f"\n{indent_spaces}// POLYGEIST-MATCH-BEGIN-{entry.name}\n"
+                f"{commented}\n"
+                f"{indent_spaces}// POLYGEIST-MATCH-END\n"
+                f"{indent_spaces}{launch_line.lstrip()}"
+            )
+        else:
+            replacement = launch_line
+        if replace_full_span:
+            edit_start, edit_end = custom_edit_span or (start, end)
+            edits.append((edit_start, edit_end, replacement))
+        elif n == 1:
+            # Single-step composition: one generic, one launch. No
+            # intervening ops to preserve.
+            edits.append((start, end, replacement))
+        else:
+            # Multi-step: emit the launch in place of the LAST generic;
+            # delete the earlier generics individually so any text between
+            # them (intervening defs like polygeist.submap) is preserved
+            # verbatim. The earlier-generic deletions are span replacements
+            # to the empty string.
+            for j in range(n - 1):
+                inst_j = instances[i + j]
+                earlier_replacement = (
+                    custom_first_launch_line
+                    if j == 0 and custom_first_launch_line is not None
+                    else ""
+                )
+                edits.append((inst_j.span[0], inst_j.span[1],
+                              earlier_replacement))
+            last_inst = instances[i + n - 1]
+            edits.append((last_inst.span[0], last_inst.span[1], replacement))
+        i += n
+
+    if dry_run:
+        return text, report
+
+    # Apply edits back-to-front so spans remain valid.
+    out_chars = list(text)
+    for start, end, repl in sorted(edits, key=lambda e: -e[0]):
+        out_chars[start:end] = list(repl)
+    return "".join(out_chars), report
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("input", help="Path to MLIR file (debuferized linalg form).")
+    ap.add_argument("--dry-run", action="store_true",
+                    help="Report matches; don't emit rewritten MLIR.")
+    ap.add_argument("--show-candidates", action="store_true",
+                    help=("With --dry-run, list backend-capable kernel "
+                          "definition candidates found at each linalg body."))
+    ap.add_argument("--show-semantic-only", action="store_true",
+                    help=("With --dry-run --show-candidates, also list "
+                          "semantic-only debug matches that do not currently "
+                          "have a backend route."))
+    ap.add_argument("--with-roundtrip-markers", action="store_true",
+                    help=("Embed the original linalg.generic span as a "
+                          "// POLYGEIST-MATCH-BEGIN/-END comment block above "
+                          "each emitted kernel.launch op so the rewrite is "
+                          "reversible by kernel_launch_lower.py."))
+    ap.add_argument("--max-launches", type=int,
+                    help=("Emit at most this many launches, preserving later "
+                          "matches as residual Linalg; useful for correctness "
+                          "bisection."))
+    args = ap.parse_args()
+
+    text = Path(args.input).read_text()
+    rewritten, report = rewrite_mlir(
+        text,
+        dry_run=args.dry_run,
+        roundtrip_markers=args.with_roundtrip_markers,
+        show_candidates=args.show_candidates,
+        show_semantic_only=args.show_semantic_only,
+        max_launches=args.max_launches,
+    )
+    if args.dry_run:
+        print(f"== match report for {args.input} ==", file=sys.stderr)
+        for kind, idx, name in report:
+            print(f"  {kind:<14} body#{idx}  {name}", file=sys.stderr)
+        matched = sum(1 for k, _, _ in report if k == "match")
+        candidates = sum(1 for k, _, _ in report if k == "kernel_candidate")
+        semantic_debug = sum(1 for k, _, _ in report if k == "semantic_debug")
+        total = sum(
+            1 for k, _, _ in report
+            if k not in ("kernel_candidate", "semantic_debug")
+        )
+        print(f"  total: {matched} matched / {total} bodies", file=sys.stderr)
+        if candidates:
+            print(f"  kernel candidates: {candidates}", file=sys.stderr)
+        if semantic_debug:
+            print(f"  semantic debug matches: {semantic_debug}", file=sys.stderr)
+    else:
+        sys.stdout.write(rewritten)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/correctness/llama_extended_ggml_bench.cpp b/scripts/correctness/llama_extended_ggml_bench.cpp
new file mode 100644
index 000000000000..6d6bc1003380
--- /dev/null
+++ b/scripts/correctness/llama_extended_ggml_bench.cpp
@@ -0,0 +1,595 @@
+// ggml/CUDA benchmark for the same full Llama-style fixture as:
+//
+//   third_party/cnn-extracted/llama2_extended_forward_bench.c
+//
+// This intentionally mirrors that f32 fixture, including its split even/odd
+// Q/K layout and branchless causal mask. It is not a GGUF/TinyLlama runner.
+
+#include "ggml.h"
+#include "ggml-backend.h"
+
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#ifndef MODEL_DIM
+#define MODEL_DIM 64
+#endif
+
+#ifndef FFN_DIM
+#define FFN_DIM 128
+#endif
+
+#ifndef VOCAB
+#define VOCAB 256
+#endif
+
+#ifndef SEQ_LEN
+#define SEQ_LEN 32
+#endif
+
+#ifndef NUM_HEADS
+#define NUM_HEADS 4
+#endif
+
+#ifndef HEAD_DIM
+#define HEAD_DIM (MODEL_DIM / NUM_HEADS)
+#endif
+
+#ifndef HALF_HEAD_DIM
+#define HALF_HEAD_DIM (HEAD_DIM / 2)
+#endif
+
+#define NEG_INF (-3.4028234663852886e38f)
+
+namespace {
+
+struct Options {
+    int warmup = 0;
+    int iters = 1;
+    int token = 7;
+    int pos = SEQ_LEN / 2;
+    std::string stage = "logits";
+};
+
+static void usage(const char * argv0) {
+    std::fprintf(stderr,
+                 "usage: %s [--warmup W] [--iters I] [--token T] [--pos P] "
+                 "[--stage x|att_normed|q_even|k_even|scores|probs|att_out|"
+                 "resid_att|ffn_hidden|resid_ffn|final_normed|logits]\n",
+                 argv0);
+}
+
+static bool parse_int(const char * text, int & out) {
+    char * end = nullptr;
+    errno = 0;
+    long value = std::strtol(text, &end, 10);
+    if (errno != 0 || end == text || *end != '\0' ||
+        value < 0 || value > 2147483647L) {
+        return false;
+    }
+    out = static_cast(value);
+    return true;
+}
+
+static Options parse_options(int argc, char ** argv) {
+    Options opts;
+    for (int i = 1; i < argc; ++i) {
+        const std::string arg = argv[i];
+        int * target = nullptr;
+        if (arg == "--warmup") {
+            target = &opts.warmup;
+        } else if (arg == "--iters") {
+            target = &opts.iters;
+        } else if (arg == "--token") {
+            target = &opts.token;
+        } else if (arg == "--pos") {
+            target = &opts.pos;
+        } else if (arg == "--stage") {
+            if (++i >= argc) {
+                usage(argv[0]);
+                std::exit(2);
+            }
+            opts.stage = argv[i];
+            if (opts.stage != "x" && opts.stage != "att_normed" &&
+                opts.stage != "q_even" && opts.stage != "k_even" &&
+                opts.stage != "scores" && opts.stage != "probs" &&
+                opts.stage != "att_out" && opts.stage != "resid_att" &&
+                opts.stage != "ffn_hidden" && opts.stage != "resid_ffn" &&
+                opts.stage != "final_normed" && opts.stage != "logits") {
+                usage(argv[0]);
+                std::exit(2);
+            }
+            continue;
+        } else if (arg == "--help" || arg == "-h") {
+            usage(argv[0]);
+            std::exit(0);
+        } else {
+            usage(argv[0]);
+            std::exit(2);
+        }
+
+        if (++i >= argc || !parse_int(argv[i], *target)) {
+            usage(argv[0]);
+            std::exit(2);
+        }
+    }
+    if (opts.warmup < 0 || opts.iters <= 0 || opts.token < 0 ||
+        opts.token >= VOCAB || opts.pos < 0 || opts.pos >= SEQ_LEN) {
+        usage(argv[0]);
+        std::exit(2);
+    }
+    return opts;
+}
+
+static float init_value(int i, int j) {
+    int v = (i * 17 + j * 13 + 7) % 101;
+    return static_cast(v - 50) * 0.01f;
+}
+
+static double average(const std::vector & xs) {
+    double sum = 0.0;
+    for (double x : xs) {
+        sum += x;
+    }
+    return sum / static_cast(xs.size());
+}
+
+static double median(std::vector xs) {
+    std::sort(xs.begin(), xs.end());
+    const size_t mid = xs.size() / 2;
+    if ((xs.size() & 1) != 0) {
+        return xs[mid];
+    }
+    return 0.5 * (xs[mid - 1] + xs[mid]);
+}
+
+static double trimmed_mean(std::vector xs) {
+    std::sort(xs.begin(), xs.end());
+    if (xs.size() <= 4) {
+        return average(xs);
+    }
+    const size_t drop = std::max(1, xs.size() / 10);
+    double sum = 0.0;
+    for (size_t i = drop; i < xs.size() - drop; ++i) {
+        sum += xs[i];
+    }
+    return sum / static_cast(xs.size() - 2 * drop);
+}
+
+struct Inputs {
+    std::vector tok_embeddings;
+    std::vector rms_att_weight;
+    std::vector wq_even;
+    std::vector wq_odd;
+    std::vector wk_even;
+    std::vector wk_odd;
+    std::vector wv;
+    std::vector wo;
+    std::vector rms_ffn_weight;
+    std::vector w_gate;
+    std::vector w_up;
+    std::vector w_down;
+    std::vector rms_final_weight;
+    std::vector lm_head;
+    std::vector cos_hp;
+    std::vector sin_hp;
+    std::vector mask;
+    std::vector k_cache_even;
+    std::vector k_cache_odd;
+    std::vector v_cache;
+    int token = 7;
+    int pos = SEQ_LEN / 2;
+};
+
+static void init_inputs(Inputs & in, int token, int pos) {
+    constexpr int qk_rows = NUM_HEADS * HALF_HEAD_DIM;
+    in.token = token;
+    in.pos = pos;
+    in.tok_embeddings.resize(static_cast(VOCAB) * MODEL_DIM);
+    in.rms_att_weight.resize(MODEL_DIM);
+    in.wq_even.resize(static_cast(qk_rows) * MODEL_DIM);
+    in.wq_odd.resize(static_cast(qk_rows) * MODEL_DIM);
+    in.wk_even.resize(static_cast(qk_rows) * MODEL_DIM);
+    in.wk_odd.resize(static_cast(qk_rows) * MODEL_DIM);
+    in.wv.resize(static_cast(MODEL_DIM) * MODEL_DIM);
+    in.wo.resize(static_cast(MODEL_DIM) * MODEL_DIM);
+    in.rms_ffn_weight.resize(MODEL_DIM);
+    in.w_gate.resize(static_cast(FFN_DIM) * MODEL_DIM);
+    in.w_up.resize(static_cast(FFN_DIM) * MODEL_DIM);
+    in.w_down.resize(static_cast(MODEL_DIM) * FFN_DIM);
+    in.rms_final_weight.resize(MODEL_DIM);
+    in.lm_head.resize(static_cast(VOCAB) * MODEL_DIM);
+    in.cos_hp.resize(qk_rows);
+    in.sin_hp.resize(qk_rows);
+    in.mask.resize(SEQ_LEN);
+    in.k_cache_even.resize(static_cast(SEQ_LEN) * qk_rows);
+    in.k_cache_odd.resize(static_cast(SEQ_LEN) * qk_rows);
+    in.v_cache.resize(static_cast(SEQ_LEN) * MODEL_DIM);
+
+    for (int i = 0; i < VOCAB; ++i) {
+        for (int j = 0; j < MODEL_DIM; ++j) {
+            in.tok_embeddings[static_cast(i) * MODEL_DIM + j] =
+                init_value(i, j);
+            in.lm_head[static_cast(i) * MODEL_DIM + j] =
+                init_value(i + 3, j + 5);
+        }
+    }
+    for (int i = 0; i < MODEL_DIM; ++i) {
+        in.rms_att_weight[i] = 1.0f + init_value(i, 1) * 0.1f;
+        in.rms_ffn_weight[i] = 1.0f + init_value(i, 2) * 0.1f;
+        in.rms_final_weight[i] = 1.0f + init_value(i, 3) * 0.1f;
+        for (int j = 0; j < MODEL_DIM; ++j) {
+            in.wv[static_cast(i) * MODEL_DIM + j] = init_value(i + 3, j);
+            in.wo[static_cast(i) * MODEL_DIM + j] = init_value(i + 4, j);
+        }
+        for (int j = 0; j < FFN_DIM; ++j) {
+            in.w_down[static_cast(i) * FFN_DIM + j] = init_value(i + 5, j);
+        }
+    }
+    for (int i = 0; i < FFN_DIM; ++i) {
+        for (int j = 0; j < MODEL_DIM; ++j) {
+            in.w_gate[static_cast(i) * MODEL_DIM + j] = init_value(i + 6, j);
+            in.w_up[static_cast(i) * MODEL_DIM + j] = init_value(i + 7, j);
+        }
+    }
+    for (int h = 0; h < NUM_HEADS; ++h) {
+        for (int p = 0; p < HALF_HEAD_DIM; ++p) {
+            const int flat = h * HALF_HEAD_DIM + p;
+            const int row_even = h * HEAD_DIM + 2 * p;
+            const int row_odd = row_even + 1;
+            const float c = 0.95f + 0.001f * static_cast((pos + p) % 7);
+            const float s = 0.05f + 0.001f * static_cast((pos + p) % 5);
+            in.cos_hp[flat] = c;
+            in.sin_hp[flat] = s;
+            for (int j = 0; j < MODEL_DIM; ++j) {
+                const size_t idx = static_cast(flat) * MODEL_DIM + j;
+                in.wq_even[idx] = init_value(row_even + 1, j);
+                in.wq_odd[idx] = init_value(row_odd + 1, j);
+                in.wk_even[idx] = init_value(row_even + 2, j);
+                in.wk_odd[idx] = init_value(row_odd + 2, j);
+            }
+        }
+    }
+    for (int t = 0; t < SEQ_LEN; ++t) {
+        in.mask[t] = t > pos ? NEG_INF : 0.0f;
+        for (int h = 0; h < NUM_HEADS; ++h) {
+            for (int p = 0; p < HALF_HEAD_DIM; ++p) {
+                const int flat = h * HALF_HEAD_DIM + p;
+                in.k_cache_even[static_cast(t) * qk_rows + flat] =
+                    init_value(t + h, p);
+                in.k_cache_odd[static_cast(t) * qk_rows + flat] =
+                    init_value(t + h + 1, p);
+            }
+        }
+        for (int i = 0; i < MODEL_DIM; ++i) {
+            in.v_cache[static_cast(t) * MODEL_DIM + i] =
+                init_value(t + 1, i);
+        }
+    }
+}
+
+struct Bench {
+    Options opts;
+    ggml_backend_t backend = nullptr;
+    ggml_backend_t cpu_backend = nullptr;
+    ggml_backend_sched_t sched = nullptr;
+    std::vector graph_buf;
+    ggml_cgraph * graph = nullptr;
+
+    ggml_tensor * token = nullptr;
+    ggml_tensor * tok_embeddings = nullptr;
+    ggml_tensor * rms_att_weight = nullptr;
+    ggml_tensor * wq_even = nullptr;
+    ggml_tensor * wq_odd = nullptr;
+    ggml_tensor * wk_even = nullptr;
+    ggml_tensor * wk_odd = nullptr;
+    ggml_tensor * wv = nullptr;
+    ggml_tensor * wo = nullptr;
+    ggml_tensor * rms_ffn_weight = nullptr;
+    ggml_tensor * w_gate = nullptr;
+    ggml_tensor * w_up = nullptr;
+    ggml_tensor * w_down = nullptr;
+    ggml_tensor * rms_final_weight = nullptr;
+    ggml_tensor * lm_head = nullptr;
+    ggml_tensor * cos_hp = nullptr;
+    ggml_tensor * sin_hp = nullptr;
+    ggml_tensor * mask = nullptr;
+    ggml_tensor * k_cache_even = nullptr;
+    ggml_tensor * k_cache_odd = nullptr;
+    ggml_tensor * v_cache = nullptr;
+    ggml_tensor * out = nullptr;
+};
+
+static void init_backend(Bench & bench) {
+    ggml_backend_load_all();
+
+    bench.backend = ggml_backend_init_by_type(GGML_BACKEND_DEVICE_TYPE_GPU, nullptr);
+    if (bench.backend == nullptr) {
+        bench.backend = ggml_backend_init_best();
+    }
+    bench.cpu_backend =
+        ggml_backend_init_by_type(GGML_BACKEND_DEVICE_TYPE_CPU, nullptr);
+    if (bench.backend == nullptr || bench.cpu_backend == nullptr) {
+        std::fprintf(stderr, "failed to initialize ggml backends\n");
+        std::exit(1);
+    }
+
+    ggml_backend_t backends[2] = {bench.backend, bench.cpu_backend};
+    bench.sched =
+        ggml_backend_sched_new(backends, nullptr, 2, GGML_DEFAULT_GRAPH_SIZE,
+                               false, true);
+    if (bench.sched == nullptr) {
+        std::fprintf(stderr, "failed to initialize ggml backend scheduler\n");
+        std::exit(1);
+    }
+}
+
+static ggml_tensor * vec_matmul(ggml_context * ctx, ggml_tensor * vec,
+                                ggml_tensor * matrix, int cols, int rows) {
+    ggml_tensor * vec2 = ggml_reshape_2d(ctx, vec, cols, 1);
+    ggml_tensor * mm = ggml_mul_mat(ctx, vec2, matrix);
+    return ggml_reshape_1d(ctx, mm, rows);
+}
+
+static void build_graph(Bench & bench) {
+    constexpr int qk_rows = NUM_HEADS * HALF_HEAD_DIM;
+    const size_t buf_size =
+        ggml_tensor_overhead() * GGML_DEFAULT_GRAPH_SIZE + ggml_graph_overhead();
+    bench.graph_buf.resize(buf_size);
+
+    ggml_init_params params = {
+        /*.mem_size   =*/buf_size,
+        /*.mem_buffer =*/bench.graph_buf.data(),
+        /*.no_alloc   =*/true,
+    };
+    ggml_context * ctx = ggml_init(params);
+    if (ctx == nullptr) {
+        std::fprintf(stderr, "failed to initialize ggml context\n");
+        std::exit(1);
+    }
+
+    bench.graph = ggml_new_graph(ctx);
+    bench.token = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, 1);
+    bench.tok_embeddings = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, MODEL_DIM, VOCAB);
+    bench.rms_att_weight = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, MODEL_DIM);
+    bench.wq_even = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, MODEL_DIM, qk_rows);
+    bench.wq_odd = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, MODEL_DIM, qk_rows);
+    bench.wk_even = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, MODEL_DIM, qk_rows);
+    bench.wk_odd = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, MODEL_DIM, qk_rows);
+    bench.wv = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, MODEL_DIM, MODEL_DIM);
+    bench.wo = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, MODEL_DIM, MODEL_DIM);
+    bench.rms_ffn_weight = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, MODEL_DIM);
+    bench.w_gate = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, MODEL_DIM, FFN_DIM);
+    bench.w_up = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, MODEL_DIM, FFN_DIM);
+    bench.w_down = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, FFN_DIM, MODEL_DIM);
+    bench.rms_final_weight = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, MODEL_DIM);
+    bench.lm_head = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, MODEL_DIM, VOCAB);
+    bench.cos_hp = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, qk_rows);
+    bench.sin_hp = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, qk_rows);
+    bench.mask = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, SEQ_LEN);
+    bench.k_cache_even = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, qk_rows, SEQ_LEN);
+    bench.k_cache_odd = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, qk_rows, SEQ_LEN);
+    bench.v_cache = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, MODEL_DIM, SEQ_LEN);
+
+    ggml_tensor * x = ggml_reshape_1d(
+        ctx, ggml_get_rows(ctx, bench.tok_embeddings, bench.token), MODEL_DIM);
+
+    ggml_tensor * att_normed =
+        ggml_mul(ctx, ggml_rms_norm(ctx, x, 1.0e-5f), bench.rms_att_weight);
+
+    ggml_tensor * q_even = vec_matmul(ctx, att_normed, bench.wq_even, MODEL_DIM, qk_rows);
+    ggml_tensor * q_odd = vec_matmul(ctx, att_normed, bench.wq_odd, MODEL_DIM, qk_rows);
+    ggml_tensor * k_even = vec_matmul(ctx, att_normed, bench.wk_even, MODEL_DIM, qk_rows);
+    ggml_tensor * k_odd = vec_matmul(ctx, att_normed, bench.wk_odd, MODEL_DIM, qk_rows);
+    ggml_tensor * v = vec_matmul(ctx, att_normed, bench.wv, MODEL_DIM, MODEL_DIM);
+
+    ggml_tensor * q_even_c = ggml_mul(ctx, q_even, bench.cos_hp);
+    ggml_tensor * q_odd_s = ggml_mul(ctx, q_odd, bench.sin_hp);
+    ggml_tensor * q_even_rot = ggml_sub(ctx, q_even_c, q_odd_s);
+    ggml_tensor * q_even_s = ggml_mul(ctx, q_even, bench.sin_hp);
+    ggml_tensor * q_odd_c = ggml_mul(ctx, q_odd, bench.cos_hp);
+    ggml_tensor * q_odd_rot = ggml_add(ctx, q_even_s, q_odd_c);
+
+    ggml_tensor * k_even_c = ggml_mul(ctx, k_even, bench.cos_hp);
+    ggml_tensor * k_odd_s = ggml_mul(ctx, k_odd, bench.sin_hp);
+    ggml_tensor * k_even_rot = ggml_sub(ctx, k_even_c, k_odd_s);
+    ggml_tensor * k_even_s = ggml_mul(ctx, k_even, bench.sin_hp);
+    ggml_tensor * k_odd_c = ggml_mul(ctx, k_odd, bench.cos_hp);
+    ggml_tensor * k_odd_rot = ggml_add(ctx, k_even_s, k_odd_c);
+
+    const size_t k_offset =
+        static_cast(bench.opts.pos) * qk_rows * sizeof(float);
+    const size_t v_offset =
+        static_cast(bench.opts.pos) * MODEL_DIM * sizeof(float);
+    ggml_tensor * k_cache_even =
+        ggml_set_1d(ctx, bench.k_cache_even, k_even_rot, k_offset);
+    ggml_tensor * k_cache_odd =
+        ggml_set_1d(ctx, bench.k_cache_odd, k_odd_rot, k_offset);
+    ggml_tensor * v_cache = ggml_set_1d(ctx, bench.v_cache, v, v_offset);
+
+    ggml_tensor * q_even2 = ggml_reshape_2d(ctx, q_even_rot, qk_rows, 1);
+    ggml_tensor * q_odd2 = ggml_reshape_2d(ctx, q_odd_rot, qk_rows, 1);
+    ggml_tensor * scores_even =
+        ggml_reshape_1d(ctx, ggml_mul_mat(ctx, q_even2, k_cache_even), SEQ_LEN);
+    ggml_tensor * scores_odd =
+        ggml_reshape_1d(ctx, ggml_mul_mat(ctx, q_odd2, k_cache_odd), SEQ_LEN);
+    ggml_tensor * scores = ggml_scale(
+        ctx, ggml_add(ctx, scores_even, scores_odd),
+        1.0f / std::sqrt(static_cast(HEAD_DIM)));
+    ggml_tensor * masked_scores = ggml_add(ctx, scores, bench.mask);
+    ggml_tensor * probs = ggml_soft_max(ctx, masked_scores);
+
+    ggml_tensor * probs2 = ggml_reshape_2d(ctx, probs, SEQ_LEN, 1);
+    ggml_tensor * v_cache_t =
+        ggml_cont_2d(ctx, ggml_transpose(ctx, v_cache), SEQ_LEN, MODEL_DIM);
+    ggml_tensor * att_out =
+        ggml_reshape_1d(ctx, ggml_mul_mat(ctx, probs2, v_cache_t), MODEL_DIM);
+
+    ggml_tensor * proj_out = vec_matmul(ctx, att_out, bench.wo, MODEL_DIM, MODEL_DIM);
+    ggml_tensor * resid_att = ggml_add(ctx, x, proj_out);
+
+    ggml_tensor * ffn_normed =
+        ggml_mul(ctx, ggml_rms_norm(ctx, resid_att, 1.0e-5f), bench.rms_ffn_weight);
+    ggml_tensor * gate = vec_matmul(ctx, ffn_normed, bench.w_gate, MODEL_DIM, FFN_DIM);
+    ggml_tensor * up = vec_matmul(ctx, ffn_normed, bench.w_up, MODEL_DIM, FFN_DIM);
+    ggml_tensor * ffn_hidden = ggml_mul(ctx, ggml_silu(ctx, gate), up);
+    ggml_tensor * ffn_out = vec_matmul(ctx, ffn_hidden, bench.w_down, FFN_DIM, MODEL_DIM);
+    ggml_tensor * resid_ffn = ggml_add(ctx, resid_att, ffn_out);
+
+    ggml_tensor * final_normed =
+        ggml_mul(ctx, ggml_rms_norm(ctx, resid_ffn, 1.0e-5f), bench.rms_final_weight);
+    ggml_tensor * logits = vec_matmul(ctx, final_normed, bench.lm_head, MODEL_DIM, VOCAB);
+
+    if (bench.opts.stage == "x") {
+        bench.out = x;
+    } else if (bench.opts.stage == "att_normed") {
+        bench.out = att_normed;
+    } else if (bench.opts.stage == "q_even") {
+        bench.out = q_even;
+    } else if (bench.opts.stage == "k_even") {
+        bench.out = k_even;
+    } else if (bench.opts.stage == "scores") {
+        bench.out = scores;
+    } else if (bench.opts.stage == "probs") {
+        bench.out = probs;
+    } else if (bench.opts.stage == "att_out") {
+        bench.out = att_out;
+    } else if (bench.opts.stage == "resid_att") {
+        bench.out = resid_att;
+    } else if (bench.opts.stage == "ffn_hidden") {
+        bench.out = ffn_hidden;
+    } else if (bench.opts.stage == "resid_ffn") {
+        bench.out = resid_ffn;
+    } else if (bench.opts.stage == "final_normed") {
+        bench.out = final_normed;
+    } else {
+        bench.out = logits;
+    }
+
+    ggml_build_forward_expand(bench.graph, bench.out);
+    ggml_free(ctx);
+}
+
+static void set_tensor_if_allocated(ggml_tensor * tensor, const void * data) {
+    if (tensor != nullptr && tensor->buffer != nullptr) {
+        ggml_backend_tensor_set(tensor, data, 0, ggml_nbytes(tensor));
+    }
+}
+
+static void load_inputs(Bench & bench, const Inputs & in) {
+    ggml_backend_sched_reset(bench.sched);
+    if (!ggml_backend_sched_alloc_graph(bench.sched, bench.graph)) {
+        std::fprintf(stderr, "failed to allocate ggml graph\n");
+        std::exit(1);
+    }
+
+    int32_t token = in.token;
+    set_tensor_if_allocated(bench.token, &token);
+    set_tensor_if_allocated(bench.tok_embeddings, in.tok_embeddings.data());
+    set_tensor_if_allocated(bench.rms_att_weight, in.rms_att_weight.data());
+    set_tensor_if_allocated(bench.wq_even, in.wq_even.data());
+    set_tensor_if_allocated(bench.wq_odd, in.wq_odd.data());
+    set_tensor_if_allocated(bench.wk_even, in.wk_even.data());
+    set_tensor_if_allocated(bench.wk_odd, in.wk_odd.data());
+    set_tensor_if_allocated(bench.wv, in.wv.data());
+    set_tensor_if_allocated(bench.wo, in.wo.data());
+    set_tensor_if_allocated(bench.rms_ffn_weight, in.rms_ffn_weight.data());
+    set_tensor_if_allocated(bench.w_gate, in.w_gate.data());
+    set_tensor_if_allocated(bench.w_up, in.w_up.data());
+    set_tensor_if_allocated(bench.w_down, in.w_down.data());
+    set_tensor_if_allocated(bench.rms_final_weight, in.rms_final_weight.data());
+    set_tensor_if_allocated(bench.lm_head, in.lm_head.data());
+    set_tensor_if_allocated(bench.cos_hp, in.cos_hp.data());
+    set_tensor_if_allocated(bench.sin_hp, in.sin_hp.data());
+    set_tensor_if_allocated(bench.mask, in.mask.data());
+    set_tensor_if_allocated(bench.k_cache_even, in.k_cache_even.data());
+    set_tensor_if_allocated(bench.k_cache_odd, in.k_cache_odd.data());
+    set_tensor_if_allocated(bench.v_cache, in.v_cache.data());
+}
+
+static double run_once(Bench & bench) {
+    const int64_t t0 = ggml_time_us();
+    const ggml_status status =
+        ggml_backend_sched_graph_compute(bench.sched, bench.graph);
+    const int64_t t1 = ggml_time_us();
+    if (status != GGML_STATUS_SUCCESS) {
+        std::fprintf(stderr, "ggml graph compute failed: %d\n",
+                     static_cast(status));
+        std::exit(1);
+    }
+    return static_cast(t1 - t0) / 1000.0;
+}
+
+} // namespace
+
+int main(int argc, char ** argv) {
+    ggml_time_init();
+
+    Bench bench;
+    bench.opts = parse_options(argc, argv);
+
+    Inputs inputs;
+    init_inputs(inputs, bench.opts.token, bench.opts.pos);
+
+    init_backend(bench);
+    build_graph(bench);
+
+    std::fprintf(stderr,
+                 "backend=%s model_dim=%d ffn_dim=%d vocab=%d seq_len=%d "
+                 "heads=%d token=%d pos=%d warmup=%d iters=%d stage=%s\n",
+                 ggml_backend_name(bench.backend), MODEL_DIM, FFN_DIM, VOCAB,
+                 SEQ_LEN, NUM_HEADS, bench.opts.token, bench.opts.pos,
+                 bench.opts.warmup, bench.opts.iters, bench.opts.stage.c_str());
+
+    for (int i = 0; i < bench.opts.warmup; ++i) {
+        load_inputs(bench, inputs);
+        (void)run_once(bench);
+    }
+
+    std::vector times;
+    times.reserve(bench.opts.iters);
+    for (int i = 0; i < bench.opts.iters; ++i) {
+        load_inputs(bench, inputs);
+        times.push_back(run_once(bench));
+    }
+
+    std::vector out(static_cast(ggml_nelements(bench.out)));
+    ggml_backend_tensor_get(bench.out, out.data(), 0, ggml_nbytes(bench.out));
+
+    double checksum = 0.0;
+    for (float v : out) {
+        checksum += static_cast(v);
+    }
+
+    std::printf("bench,stage,backend,model_dim,ffn_dim,vocab,seq_len,heads,token,pos,"
+                "warmup,iters,avg_ms,median_ms,trimmed_ms,min_ms,max_ms,"
+                "checksum,out0,out1,out2,out3,out4,out5,out6,out7\n");
+    std::printf("ggml_extended,%s,%s,%d,%d,%d,%d,%d,%d,%d,%d,%d,%.6f,%.6f,%.6f,"
+                "%.6f,%.6f,%.8f,%.8f,%.8f,%.8f,%.8f,%.8f,%.8f,%.8f,%.8f\n",
+                bench.opts.stage.c_str(), ggml_backend_name(bench.backend),
+                MODEL_DIM, FFN_DIM, VOCAB, SEQ_LEN, NUM_HEADS,
+                bench.opts.token, bench.opts.pos, bench.opts.warmup,
+                bench.opts.iters, average(times),
+                median(times), trimmed_mean(times),
+                *std::min_element(times.begin(), times.end()),
+                *std::max_element(times.begin(), times.end()), checksum,
+                out.size() > 0 ? out[0] : 0.0f,
+                out.size() > 1 ? out[1] : 0.0f,
+                out.size() > 2 ? out[2] : 0.0f,
+                out.size() > 3 ? out[3] : 0.0f,
+                out.size() > 4 ? out[4] : 0.0f,
+                out.size() > 5 ? out[5] : 0.0f,
+                out.size() > 6 ? out[6] : 0.0f,
+                out.size() > 7 ? out[7] : 0.0f);
+
+    ggml_backend_sched_free(bench.sched);
+    ggml_backend_free(bench.backend);
+    ggml_backend_free(bench.cpu_backend);
+    return 0;
+}
diff --git a/scripts/correctness/llama_suffix_ggml_bench.cpp b/scripts/correctness/llama_suffix_ggml_bench.cpp
new file mode 100644
index 000000000000..d86d4ad0838e
--- /dev/null
+++ b/scripts/correctness/llama_suffix_ggml_bench.cpp
@@ -0,0 +1,326 @@
+// Microbenchmark for the Llama-style suffix we currently raise:
+//
+//   hidden = rmsnorm(x) * weight
+//   logits = W * hidden
+//   probs  = softmax(logits)
+//
+// This intentionally mirrors third_party/cnn-extracted/llama2_forward_bench.c
+// rather than a full llama.cpp token evaluation. Use it to compare the same
+// suffix shape against ggml/CUDA.
+
+#include "ggml.h"
+#include "ggml-backend.h"
+
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace {
+
+struct Options {
+    int n = 2048;
+    int h = 32000;
+    int warmup = 5;
+    int iters = 30;
+    std::string stage = "suffix";
+    bool identity_w = false;
+};
+
+static void usage(const char * argv0) {
+    std::fprintf(stderr,
+                 "usage: %s [--n N] [--h H] [--warmup W] [--iters I] "
+                 "[--stage suffix|logits|hidden|norm|wcopy] [--identity-w]\n",
+                 argv0);
+}
+
+static bool parse_int(const char * text, int & out) {
+    char * end = nullptr;
+    errno = 0;
+    long value = std::strtol(text, &end, 10);
+    if (errno != 0 || end == text || *end != '\0' || value <= 0 ||
+        value > 2147483647L) {
+        return false;
+    }
+    out = static_cast(value);
+    return true;
+}
+
+static Options parse_options(int argc, char ** argv) {
+    Options opts;
+    for (int i = 1; i < argc; ++i) {
+        const std::string arg = argv[i];
+        int * target = nullptr;
+        if (arg == "--n") {
+            target = &opts.n;
+        } else if (arg == "--h") {
+            target = &opts.h;
+        } else if (arg == "--warmup") {
+            target = &opts.warmup;
+        } else if (arg == "--iters") {
+            target = &opts.iters;
+        } else if (arg == "--stage") {
+            if (++i >= argc) {
+                usage(argv[0]);
+                std::exit(2);
+            }
+            opts.stage = argv[i];
+            if (opts.stage != "suffix" && opts.stage != "logits" &&
+                opts.stage != "hidden" && opts.stage != "norm" &&
+                opts.stage != "wcopy") {
+                usage(argv[0]);
+                std::exit(2);
+            }
+            continue;
+        } else if (arg == "--identity-w") {
+            opts.identity_w = true;
+            continue;
+        } else if (arg == "--help" || arg == "-h") {
+            usage(argv[0]);
+            std::exit(0);
+        } else {
+            usage(argv[0]);
+            std::exit(2);
+        }
+
+        if (++i >= argc || !parse_int(argv[i], *target)) {
+            usage(argv[0]);
+            std::exit(2);
+        }
+    }
+    return opts;
+}
+
+static void init_inputs(int n, int h, bool identity_w, std::vector & x,
+                        std::vector & weight,
+                        std::vector & w) {
+    x.resize(n);
+    weight.resize(n);
+    w.resize(static_cast(h) * static_cast(n));
+
+    for (int i = 0; i < n; ++i) {
+        x[i] = static_cast((i % 31) - 15) * 0.0625f;
+        weight[i] = 0.75f + static_cast((i % 17) + 1) * 0.015625f;
+    }
+
+    for (int row = 0; row < h; ++row) {
+        for (int col = 0; col < n; ++col) {
+            if (identity_w) {
+                w[static_cast(row) * n + col] =
+                    row == col ? 1.0f : 0.0f;
+            } else {
+                w[static_cast(row) * n + col] =
+                    static_cast(((row * 7 + col * 11) % 29) - 14) *
+                    0.0078125f;
+            }
+        }
+    }
+}
+
+static double average(const std::vector & xs) {
+    double sum = 0.0;
+    for (double x : xs) {
+        sum += x;
+    }
+    return sum / static_cast(xs.size());
+}
+
+static double median(std::vector xs) {
+    std::sort(xs.begin(), xs.end());
+    const size_t mid = xs.size() / 2;
+    if ((xs.size() & 1) != 0) {
+        return xs[mid];
+    }
+    return 0.5 * (xs[mid - 1] + xs[mid]);
+}
+
+static double trimmed_mean(std::vector xs) {
+    std::sort(xs.begin(), xs.end());
+    if (xs.size() <= 4) {
+        return average(xs);
+    }
+    const size_t drop = std::max(1, xs.size() / 10);
+    double sum = 0.0;
+    for (size_t i = drop; i < xs.size() - drop; ++i) {
+        sum += xs[i];
+    }
+    return sum / static_cast(xs.size() - 2 * drop);
+}
+
+struct Bench {
+    Options opts;
+    ggml_backend_t backend = nullptr;
+    ggml_backend_t cpu_backend = nullptr;
+    ggml_backend_sched_t sched = nullptr;
+    std::vector graph_buf;
+    ggml_cgraph * graph = nullptr;
+    ggml_tensor * x = nullptr;
+    ggml_tensor * weight = nullptr;
+    ggml_tensor * w = nullptr;
+    ggml_tensor * out = nullptr;
+};
+
+static void init_backend(Bench & bench) {
+    ggml_backend_load_all();
+
+    bench.backend = ggml_backend_init_by_type(GGML_BACKEND_DEVICE_TYPE_GPU, nullptr);
+    if (bench.backend == nullptr) {
+        bench.backend = ggml_backend_init_best();
+    }
+    bench.cpu_backend =
+        ggml_backend_init_by_type(GGML_BACKEND_DEVICE_TYPE_CPU, nullptr);
+    if (bench.backend == nullptr || bench.cpu_backend == nullptr) {
+        std::fprintf(stderr, "failed to initialize ggml backends\n");
+        std::exit(1);
+    }
+
+    ggml_backend_t backends[2] = {bench.backend, bench.cpu_backend};
+    bench.sched =
+        ggml_backend_sched_new(backends, nullptr, 2, GGML_DEFAULT_GRAPH_SIZE,
+                               false, true);
+    if (bench.sched == nullptr) {
+        std::fprintf(stderr, "failed to initialize ggml backend scheduler\n");
+        std::exit(1);
+    }
+}
+
+static void build_graph(Bench & bench) {
+    const size_t buf_size =
+        ggml_tensor_overhead() * GGML_DEFAULT_GRAPH_SIZE + ggml_graph_overhead();
+    bench.graph_buf.resize(buf_size);
+
+    ggml_init_params params = {
+        /*.mem_size   =*/buf_size,
+        /*.mem_buffer =*/bench.graph_buf.data(),
+        /*.no_alloc   =*/true,
+    };
+    ggml_context * ctx = ggml_init(params);
+    if (ctx == nullptr) {
+        std::fprintf(stderr, "failed to initialize ggml context\n");
+        std::exit(1);
+    }
+
+    bench.graph = ggml_new_graph(ctx);
+    bench.x = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, bench.opts.n);
+    bench.weight = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, bench.opts.n);
+    bench.w = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, bench.opts.n, bench.opts.h);
+
+    ggml_tensor * norm = ggml_rms_norm(ctx, bench.x, 1.0e-5f);
+    ggml_tensor * norm_for_mul = ggml_cont(ctx, norm);
+    ggml_tensor * hidden = ggml_mul(ctx, norm_for_mul, bench.weight);
+    ggml_tensor * hidden_mat = ggml_reshape_2d(ctx, hidden, bench.opts.n, 1);
+    ggml_tensor * logits_2d = ggml_mul_mat(ctx, hidden_mat, bench.w);
+    ggml_tensor * logits_1d = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, bench.opts.h);
+    ggml_tensor * logits = ggml_cpy(ctx, logits_2d, logits_1d);
+    if (bench.opts.stage == "wcopy") {
+        bench.out = ggml_dup(ctx, bench.w);
+    } else if (bench.opts.stage == "norm") {
+        bench.out = norm;
+    } else if (bench.opts.stage == "hidden") {
+        bench.out = hidden;
+    } else if (bench.opts.stage == "logits") {
+        bench.out = logits_2d;
+    } else {
+        bench.out = ggml_soft_max(ctx, logits);
+    }
+
+    ggml_build_forward_expand(bench.graph, bench.out);
+    ggml_free(ctx);
+}
+
+static void load_inputs(Bench & bench, const std::vector & x,
+                        const std::vector & weight,
+                        const std::vector & w) {
+    ggml_backend_sched_reset(bench.sched);
+    if (!ggml_backend_sched_alloc_graph(bench.sched, bench.graph)) {
+        std::fprintf(stderr, "failed to allocate ggml graph\n");
+        std::exit(1);
+    }
+
+    if (bench.opts.stage != "wcopy") {
+        ggml_backend_tensor_set(bench.x, x.data(), 0, ggml_nbytes(bench.x));
+    }
+    if (bench.opts.stage != "norm" && bench.opts.stage != "wcopy") {
+        ggml_backend_tensor_set(bench.weight, weight.data(), 0,
+                                ggml_nbytes(bench.weight));
+    }
+    if (bench.opts.stage != "hidden" && bench.opts.stage != "norm") {
+        ggml_backend_tensor_set(bench.w, w.data(), 0, ggml_nbytes(bench.w));
+    }
+}
+
+static double run_once(Bench & bench) {
+    const int64_t t0 = ggml_time_us();
+    const ggml_status status = ggml_backend_sched_graph_compute(
+        bench.sched, bench.graph);
+    const int64_t t1 = ggml_time_us();
+    if (status != GGML_STATUS_SUCCESS) {
+        std::fprintf(stderr, "ggml graph compute failed: %d\n",
+                     static_cast(status));
+        std::exit(1);
+    }
+    return static_cast(t1 - t0) / 1000.0;
+}
+
+} // namespace
+
+int main(int argc, char ** argv) {
+    ggml_time_init();
+
+    Bench bench;
+    bench.opts = parse_options(argc, argv);
+
+    std::vector x;
+    std::vector weight;
+    std::vector w;
+    init_inputs(bench.opts.n, bench.opts.h, bench.opts.identity_w, x, weight, w);
+
+    init_backend(bench);
+    build_graph(bench);
+    load_inputs(bench, x, weight, w);
+
+    std::fprintf(stderr, "backend=%s n=%d h=%d warmup=%d iters=%d stage=%s\n",
+                 ggml_backend_name(bench.backend), bench.opts.n, bench.opts.h,
+                 bench.opts.warmup, bench.opts.iters, bench.opts.stage.c_str());
+
+    std::vector times;
+    for (int i = 0; i < bench.opts.warmup; ++i) {
+        (void)run_once(bench);
+    }
+
+    times.reserve(bench.opts.iters);
+    for (int i = 0; i < bench.opts.iters; ++i) {
+        times.push_back(run_once(bench));
+    }
+
+    std::vector out(static_cast(ggml_nelements(bench.out)));
+    ggml_backend_tensor_get(bench.out, out.data(), 0, ggml_nbytes(bench.out));
+
+    double checksum = 0.0;
+    for (float v : out) {
+        checksum += static_cast(v);
+    }
+
+    std::printf("bench,stage,backend,n,h,out_ne0,out_ne1,warmup,iters,avg_ms,median_ms,trimmed_ms,min_ms,max_ms,checksum,out0,out1,out2,out3\n");
+    std::printf("ggml_suffix,%s,%s,%d,%d,%lld,%lld,%d,%d,%.6f,%.6f,%.6f,%.6f,%.6f,%.8f,%.8f,%.8f,%.8f,%.8f\n",
+                bench.opts.stage.c_str(), ggml_backend_name(bench.backend),
+                bench.opts.n, bench.opts.h,
+                static_cast(bench.out->ne[0]),
+                static_cast(bench.out->ne[1]), bench.opts.warmup,
+                bench.opts.iters, average(times), median(times), trimmed_mean(times),
+                *std::min_element(times.begin(), times.end()),
+                *std::max_element(times.begin(), times.end()), checksum,
+                out.size() > 0 ? out[0] : 0.0f,
+                out.size() > 1 ? out[1] : 0.0f,
+                out.size() > 2 ? out[2] : 0.0f,
+                out.size() > 3 ? out[3] : 0.0f);
+
+    ggml_backend_sched_free(bench.sched);
+    ggml_backend_free(bench.backend);
+    ggml_backend_free(bench.cpu_backend);
+    return 0;
+}
diff --git a/scripts/correctness/lower_smoke_test.sh b/scripts/correctness/lower_smoke_test.sh
new file mode 100755
index 000000000000..3d876fb51f09
--- /dev/null
+++ b/scripts/correctness/lower_smoke_test.sh
@@ -0,0 +1,58 @@
+#!/bin/bash
+set +e
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+
+OUT_DIR="/tmp/lowering_test"
+mkdir -p "$OUT_DIR"
+
+LOWERING_PIPE="--expand-strided-metadata \
+  --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \
+  --convert-arith-to-llvm --convert-math-to-llvm \
+  --finalize-memref-to-llvm \
+  --convert-func-to-llvm --reconcile-unrealized-casts"
+
+# Reuse the kernel list from /tmp/run_polybench.sh
+KERNELS=(
+  "correlation" "covariance" "durbin" "cholesky" "gramschmidt"
+  "lu" "ludcmp" "trisolv" "gemm" "syr2k" "syrk" "gesummv" "symm"
+  "trmm" "gemver" "bicg" "doitgen" "atax" "mvt" "2mm" "3mm"
+  "heat-3d" "jacobi-2d" "jacobi-1d" "adi" "fdtd-2d" "seidel-2d"
+  "floyd-warshall" "deriche" "nussinov"
+)
+
+pass=0
+fail_lower=0
+fail_llvm=0
+
+for k in "${KERNELS[@]}"; do
+  src="/tmp/polybench_new/${k}_linalg.mlir"
+  if [ ! -f "$src" ]; then echo "$k: NO_INPUT"; continue; fi
+  
+  step1="$OUT_DIR/${k}_step1.mlir"
+  step2="$OUT_DIR/${k}_step2.mlir"
+  log="$OUT_DIR/${k}.log"
+  
+  # Step 1: lower polygeist.submap to standard MLIR
+  polygeist-opt --lower-polygeist-submap "$src" -o "$step1" 2> "$log"
+  if [ ! -s "$step1" ]; then echo "$k: LOWER_SUBMAP_FAIL"; fail_lower=$((fail_lower+1)); continue; fi
+  
+  # Check no polygeist ops remain (be precise; "polygeist.target-cpu" in attrs is OK)
+  remain=$(grep -cE "polygeist\.(submap|submapInverse|trivialuse|alternatives|barrier|kernelinfo|cache|noop|gpu|getfunc|stream)" "$step1" 2>/dev/null || echo 0)
+  if [ "$remain" -gt 0 ]; then
+    echo "$k: PARTIAL_LOWER (${remain} polygeist ops remain)"
+    fail_lower=$((fail_lower+1))
+    continue
+  fi
+  
+  # Step 2: standard MLIR lowering to LLVM dialect
+  $MLIR_OPT $LOWERING_PIPE "$step1" -o "$step2" 2>> "$log"
+  if [ ! -s "$step2" ]; then echo "$k: LLVM_LOWER_FAIL"; fail_llvm=$((fail_llvm+1)); continue; fi
+  
+  echo "$k: OK"
+  pass=$((pass+1))
+done
+
+echo "---"
+echo "Summary: $pass passed, $fail_lower submap-lower failed, $fail_llvm llvm-lower failed"
diff --git a/scripts/correctness/machsuite_sweep.sh b/scripts/correctness/machsuite_sweep.sh
new file mode 100755
index 000000000000..176977434c88
--- /dev/null
+++ b/scripts/correctness/machsuite_sweep.sh
@@ -0,0 +1,108 @@
+#!/bin/bash
+# Sweep MachSuite kernels through the Polygeist raise pipeline.
+#
+# For each kernel, run:
+#   1. cgeist  --function=  →  affine MLIR
+#   2. polygeist-opt --select-func= --remove-iter-args --affine-parallelize
+#                    --raise-affine-to-linalg-pipeline --lower-polygeist-submap
+#                    [--linalg-debufferize]
+# and report: # linalg.generic, # affine.for, # scf.for after each stage.
+#
+# This is a coverage/diagnostic sweep — not a correctness test.
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+ROOT=$REPO_ROOT/third_party/MachSuite
+COMMON=$ROOT/common
+OUT=/tmp/machsuite_sweep
+mkdir -p $OUT
+
+# Format:   
+KERNELS=(
+  "aes              aes/aes              aes256_encrypt_ecb"
+  "backprop         backprop/backprop    backprop"
+  "bfs-bulk         bfs/bulk             bfs"
+  "bfs-queue        bfs/queue            bfs"
+  "fft-strided      fft/strided          fft"
+  "fft-transpose    fft/transpose        fft1D_512"
+  "gemm-ncubed      gemm/ncubed          gemm"
+  "gemm-blocked     gemm/blocked         bbgemm"
+  "kmp              kmp/kmp              kmp"
+  "md-grid          md/grid              md"
+  "md-knn           md/knn               md_kernel"
+  "nw               nw/nw                needwun"
+  "sort-merge       sort/merge           ms_mergesort"
+  "sort-radix       sort/radix           ss_sort"
+  "spmv-crs         spmv/crs             spmv"
+  "spmv-ellpack     spmv/ellpack         ellpack"
+  "stencil2d        stencil/stencil2d    stencil"
+  "stencil3d        stencil/stencil3d    stencil3d"
+  "viterbi          viterbi/viterbi      viterbi"
+)
+
+# Header
+printf '%-15s %5s %5s %5s   %5s %5s %5s   %5s %5s %5s   %s\n' \
+  kernel CG_LG CG_AF CG_SF RS_LG RS_AF RS_SF DB_LG DB_AF DB_SF status
+echo "-----------------------------------------------------------------------------------"
+
+for entry in "${KERNELS[@]}"; do
+  read tag subdir fn <<<"$entry"
+  D=$ROOT/$subdir
+  # Find the kernel .c (not local_support.c or generate.c)
+  src=$(ls $D/*.c 2>/dev/null | grep -vE 'local_support|generate' | head -1)
+  if [ -z "$src" ]; then
+    printf '%-15s skipped (no source)\n' "$tag"
+    continue
+  fi
+
+  # Step 1: cgeist
+  cgeist "$src" --function=$fn --resource-dir=/usr/lib/clang/14 \
+    -I$COMMON -I$D --raise-scf-to-affine -fPIC -S -o $OUT/${tag}.mlir \
+    2>$OUT/${tag}.cgeist.err
+  if [ ! -s $OUT/${tag}.mlir ]; then
+    printf '%-15s   --   --   --      --   --   --      --   --   --   CGEIST_FAIL\n' "$tag"
+    continue
+  fi
+  CG_LG=$(grep -c "linalg.generic" $OUT/${tag}.mlir 2>/dev/null); CG_LG=${CG_LG:-0}
+  CG_AF=$(grep -c "affine.for" $OUT/${tag}.mlir 2>/dev/null); CG_AF=${CG_AF:-0}
+  CG_SF=$(grep -c "scf.for" $OUT/${tag}.mlir 2>/dev/null); CG_SF=${CG_SF:-0}
+
+  # Step 2: raise to linalg
+  timeout 60 polygeist-opt --select-func=func-name=$fn \
+    --remove-iter-args --affine-parallelize \
+    --raise-affine-to-linalg-pipeline --lower-polygeist-submap \
+    $OUT/${tag}.mlir -o $OUT/${tag}.raised.mlir 2>$OUT/${tag}.raise.err
+  raise_rc=$?
+  if [ "$raise_rc" -ne 0 ] || [ ! -s $OUT/${tag}.raised.mlir ]; then
+    printf '%-15s %5s %5s %5s     --   --   --      --   --   --   RAISE_FAIL\n' \
+      "$tag" "$CG_LG" "$CG_AF" "$CG_SF"
+    continue
+  fi
+  RS_LG=$(grep -c "linalg.generic" $OUT/${tag}.raised.mlir 2>/dev/null); RS_LG=${RS_LG:-0}
+  RS_AF=$(grep -c "affine.for" $OUT/${tag}.raised.mlir 2>/dev/null); RS_AF=${RS_AF:-0}
+  RS_SF=$(grep -c "scf.for" $OUT/${tag}.raised.mlir 2>/dev/null); RS_SF=${RS_SF:-0}
+
+  # Step 3: debufferize (multi-root)
+  timeout 60 polygeist-opt --linalg-debufferize=use-multi-root=true \
+    $OUT/${tag}.raised.mlir -o $OUT/${tag}.debuf.mlir 2>$OUT/${tag}.debuf.err
+  debuf_rc=$?
+  if [ "$debuf_rc" -ne 0 ] || [ ! -s $OUT/${tag}.debuf.mlir ]; then
+    printf '%-15s %5s %5s %5s   %5s %5s %5s      --   --   --   DEBUF_FAIL\n' \
+      "$tag" "$CG_LG" "$CG_AF" "$CG_SF" "$RS_LG" "$RS_AF" "$RS_SF"
+    continue
+  fi
+  DB_LG=$(grep -c "linalg.generic" $OUT/${tag}.debuf.mlir 2>/dev/null); DB_LG=${DB_LG:-0}
+  DB_AF=$(grep -c "affine.for" $OUT/${tag}.debuf.mlir 2>/dev/null); DB_AF=${DB_AF:-0}
+  DB_SF=$(grep -c "scf.for" $OUT/${tag}.debuf.mlir 2>/dev/null); DB_SF=${DB_SF:-0}
+
+  # Status classification
+  if [ "$DB_LG" -gt 0 ] && [ "$DB_AF" -eq 0 ] && [ "$DB_SF" -eq 0 ]; then
+    status=FULL_LIFT
+  elif [ "$DB_LG" -gt 0 ]; then
+    status=PARTIAL_LIFT
+  else
+    status=NO_LIFT
+  fi
+  printf '%-15s %5s %5s %5s   %5s %5s %5s   %5s %5s %5s   %s\n' \
+    "$tag" "$CG_LG" "$CG_AF" "$CG_SF" "$RS_LG" "$RS_AF" "$RS_SF" \
+    "$DB_LG" "$DB_AF" "$DB_SF" "$status"
+done
diff --git a/scripts/correctness/maxpool_batched_jetson_harness.c b/scripts/correctness/maxpool_batched_jetson_harness.c
new file mode 100644
index 000000000000..5ee444f9ac2f
--- /dev/null
+++ b/scripts/correctness/maxpool_batched_jetson_harness.c
@@ -0,0 +1,97 @@
+/* maxpool_batched_jetson_harness.c — Jetson harness for batched maxpool. */
+#include 
+#include 
+#include 
+#include 
+
+#if defined(LARGE_DATASET)
+# define B   32
+# define C   64
+# define H   112
+# define W   112
+# define KS  3
+# define STR 2
+#elif defined(MINI_DATASET)
+# define B   4
+# define C   8
+# define H   32
+# define W   32
+# define KS  2
+# define STR 2
+#endif
+#ifndef B
+# define B 4
+#endif
+#ifndef C
+# define C 8
+#endif
+#ifndef H
+# define H 32
+#endif
+#ifndef W
+# define W 32
+#endif
+#ifndef KS
+# define KS 2
+#endif
+#ifndef STR
+# define STR 2
+#endif
+#define OH ((H - KS) / STR + 1)
+#define OW ((W - KS) / STR + 1)
+
+extern void kernel_maxpool_batched_impl(
+    float *A_b, float *A_a, int64_t A_o,
+    int64_t A_s0, int64_t A_s1, int64_t A_s2, int64_t A_s3,
+    int64_t A_t0, int64_t A_t1, int64_t A_t2, int64_t A_t3,
+    float *O_b, float *O_a, int64_t O_o,
+    int64_t O_s0, int64_t O_s1, int64_t O_s2, int64_t O_s3,
+    int64_t O_t0, int64_t O_t1, int64_t O_t2, int64_t O_t3);
+
+extern void   polygeist_cublas_time_begin(void);
+extern double polygeist_cublas_time_end_ms(void);
+
+static void run_kernel(float *A, float *Bout) {
+  polygeist_cublas_time_begin();
+  kernel_maxpool_batched_impl(
+      A, A, 0,
+      (int64_t)B, (int64_t)C, (int64_t)H, (int64_t)W,
+      (int64_t)(C*H*W), (int64_t)(H*W), (int64_t)W, 1,
+      Bout, Bout, 0,
+      (int64_t)B, (int64_t)C, (int64_t)OH, (int64_t)OW,
+      (int64_t)(C*OH*OW), (int64_t)(OH*OW), (int64_t)OW, 1);
+  double ms = polygeist_cublas_time_end_ms();
+  fprintf(stderr,
+      "POLYGEIST_TIMING: maxpool_batched B=%d C=%d H=%d W=%d K=%d S=%d  %.3f ms\n",
+      B, C, H, W, KS, STR, ms);
+}
+
+int main(void) {
+  size_t nA = (size_t)B*C*H*W, nO = (size_t)B*C*OH*OW;
+  float *A = (float *)malloc(nA * sizeof(float));
+  float *O = (float *)malloc(nO * sizeof(float));
+  if (!A || !O) { fprintf(stderr, "alloc failed\n"); return 1; }
+
+  for (int b = 0; b < B; ++b)
+    for (int c = 0; c < C; ++c)
+      for (int i = 0; i < H; ++i)
+        for (int j = 0; j < W; ++j)
+          A[((size_t)b*C + c)*H*W + (size_t)i*W + j] =
+              (float)((b*7 + c*3 + i*5 + j*11) % 23) / 23.0f;
+  memset(O, 0, nO * sizeof(float));
+
+  run_kernel(A, O);
+
+  double sum = 0;
+  for (size_t k = 0; k < nO; ++k) sum += O[k];
+  fprintf(stderr, "CHECKSUM: %.6f over %zu elems\n", sum, nO);
+  fprintf(stderr, "==BEGIN DUMP_ARRAYS==\n");
+  for (size_t k = 0; k < nO; ++k) {
+    if (k % 19 == 0) fprintf(stderr, "\n");
+    fprintf(stderr, "%0.4f ", O[k]);
+  }
+  fprintf(stderr, "\n==END   DUMP_ARRAYS==\n");
+
+  free(A); free(O);
+  return 0;
+}
diff --git a/scripts/correctness/mfem_application_raise_sweep.py b/scripts/correctness/mfem_application_raise_sweep.py
new file mode 100644
index 000000000000..608546196733
--- /dev/null
+++ b/scripts/correctness/mfem_application_raise_sweep.py
@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""Raise and library-match concrete hot paths from larger MFEM applications."""
+
+import csv
+import re
+import subprocess
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+CORPUS = ROOT / "issues" / "mfem_c_kernels" / "application_extractions"
+RESULTS = CORPUS / "results"
+CGEIST = ROOT / "build" / "bin" / "cgeist"
+OPT = ROOT / "build" / "bin" / "polygeist-opt"
+MATCHER = ROOT / "scripts" / "correctness" / "kernel_match_rewrite.py"
+RESOURCE = ROOT / "llvm-project" / "build" / "lib" / "clang" / "18"
+
+
+def run(command, output=None, timeout=300):
+    try:
+        proc = subprocess.run(command, text=True, stdout=subprocess.PIPE,
+                              stderr=subprocess.PIPE, timeout=timeout)
+    except subprocess.TimeoutExpired as exc:
+        return 124, exc.stdout or "", (exc.stderr or "") + "\ntimeout\n"
+    if output is not None and proc.returncode == 0:
+        output.write_text(proc.stdout)
+    return proc.returncode, proc.stdout, proc.stderr
+
+
+def count(path, pattern):
+    return len(re.findall(pattern, path.read_text())) if path.exists() else 0
+
+
+def main():
+    RESULTS.mkdir(parents=True, exist_ok=True)
+    rows = list(csv.DictReader((CORPUS / "manifest.csv").open()))
+    summary = []
+    for row in rows:
+        fn = row["function"]
+        source = CORPUS / row["source"]
+        front = RESULTS / f"{fn}.frontend.mlir"
+        raised = RESULTS / f"{fn}.raised.mlir"
+        debuf = RESULTS / f"{fn}.debufferized.mlir"
+        matched = RESULTS / f"{fn}.matched.mlir"
+        log = RESULTS / f"{fn}.log"
+        messages = []
+
+        frc, _, err = run([
+            str(CGEIST), str(source), f"--function={fn}",
+            f"--resource-dir={RESOURCE}", "--raise-scf-to-affine", "-S",
+            "-o", str(front),
+        ])
+        messages.append("[frontend]\n" + err)
+        rrc = drc = mrc = -1
+        report = ""
+        if frc == 0:
+            rrc, _, err = run([
+                str(OPT), f"--select-func=func-name={fn}",
+                "--remove-iter-args", "--affine-parallelize",
+                "--raise-affine-to-linalg-pipeline",
+                "--lower-polygeist-submap", str(front), "-o", str(raised),
+            ])
+            messages.append("[raise]\n" + err)
+        raised_loops = count(
+            raised, r"\b(?:affine|scf)\.(?:for|parallel|while)\b"
+        ) if rrc == 0 else 0
+        if rrc == 0 and raised_loops == 0:
+            drc, _, err = run([
+                str(OPT), "--linalg-debufferize=use-multi-root=true",
+                str(raised),
+                "-o", str(debuf),
+            ])
+            messages.append("[debufferize]\n" + err)
+        elif rrc == 0:
+            messages.append(
+                "[debufferize]\nskipped: raised IR still contains "
+                f"{raised_loops} residual loop(s)\n"
+            )
+        if drc == 0:
+            mrc, out, err = run([
+                "/usr/bin/python3", str(MATCHER), str(debuf), "--dry-run",
+            ])
+            report = out + err
+            messages.append("[matcher]\n" + report)
+            if mrc == 0:
+                wrc, out, err = run([
+                    "/usr/bin/python3", str(MATCHER), str(debuf),
+                ], matched)
+                messages.append("[rewrite]\n" + err)
+                if wrc != 0:
+                    mrc = wrc
+        log.write_text("\n".join(messages))
+
+        total = re.search(r"total:\s+(\d+) matched / (\d+) bodies", report)
+        result = dict(row)
+        result.update(
+            frontend_ok=str(frc == 0).lower(),
+            raise_ok=str(rrc == 0).lower(),
+            debufferize_ok=str(drc == 0).lower(),
+            matcher_ok=str(mrc == 0).lower(),
+            linalg_ops=str(count(raised, r"\blinalg\.")),
+            residual_loops=str(raised_loops),
+            matched_groups=total.group(1) if total else "0",
+            matcher_bodies=total.group(2) if total else "0",
+            launches=str(count(matched, r"\bkernel\.launch\b")),
+        )
+        summary.append(result)
+        print(f"{fn:<48} front={frc == 0!s:<5} raise={rrc == 0!s:<5} "
+              f"linalg={result['linalg_ops']:<3} loops={result['residual_loops']:<3} "
+              f"matches={result['matched_groups']}", flush=True)
+
+    with (RESULTS / "summary.csv").open("w", newline="") as out:
+        writer = csv.DictWriter(
+            out, fieldnames=list(summary[0]), lineterminator="\n"
+        )
+        writer.writeheader()
+        writer.writerows(summary)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/correctness/mfem_match_sweep.py b/scripts/correctness/mfem_match_sweep.py
new file mode 100644
index 000000000000..d97e58947655
--- /dev/null
+++ b/scripts/correctness/mfem_match_sweep.py
@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""Debufferize and library-match every normalized MFEM kernel."""
+import concurrent.futures
+import csv
+import re
+import subprocess
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+CORPUS = ROOT / "issues" / "mfem_c_kernels"
+RAISE_RESULTS = CORPUS / "results"
+OUT = CORPUS / "match_results"
+OPT = ROOT / "build" / "bin" / "polygeist-opt"
+MATCHER = ROOT / "scripts" / "correctness" / "kernel_match_rewrite.py"
+PYTHON = Path("/usr/bin/python3")
+
+MATCH_RE = re.compile(r"^\s+match\s+body#.*?\s{2,}(\S+)\s*$")
+TOTAL_RE = re.compile(r"total:\s+(\d+) matched / (\d+) bodies")
+LAUNCH_RE = re.compile(r"kernel\.launch\s+@([A-Za-z0-9_.$-]+)")
+
+def run(command, timeout=180):
+    try:
+        p = subprocess.run(command, text=True, stdout=subprocess.PIPE,
+                           stderr=subprocess.PIPE, timeout=timeout)
+        return p.returncode, p.stdout, p.stderr
+    except subprocess.TimeoutExpired as e:
+        return 124, e.stdout or "", (e.stderr or "") + "\ntimeout\n"
+
+def process(row):
+    ident = row["id"]
+    directory = OUT / ident
+    directory.mkdir(parents=True, exist_ok=True)
+    raised = RAISE_RESULTS / f"{ident}__normalized.raised.mlir"
+    debuf = directory / "debufferized.mlir"
+    matched = directory / "matched.mlir"
+    report_path = directory / "match_report.txt"
+    debuf_log = directory / "debufferize.log"
+    match_log = directory / "matcher.log"
+
+    drc, _, derr = run([str(OPT), "--linalg-debufferize", str(raised),
+                        "-o", str(debuf)])
+    debuf_log.write_text(derr)
+    result = dict(id=ident, function=row["function"], family=row["family"],
+                  dimension=row["dimension"], debufferize_ok=drc == 0,
+                  matcher_ok=False, linalg_ops=0, matcher_bodies=0,
+                  matched_groups=0, matched_symbols="", kernel_launches=0,
+                  launch_symbols="", error="")
+    if drc:
+        result["error"] = next((x for x in derr.splitlines() if "error:" in x), derr[:300])
+        return result
+    text = debuf.read_text().rstrip() + "\n"
+    debuf.write_text(text)
+    result["linalg_ops"] = text.count("linalg.")
+    rrc, report, rerr = run([str(PYTHON), str(MATCHER), str(debuf), "--dry-run"])
+    combined_report = report + rerr
+    report_path.write_text(combined_report)
+    if rrc:
+        result["error"] = next((x for x in rerr.splitlines() if "error" in x.lower()), rerr[:300])
+        return result
+    symbols = [m.group(1) for line in combined_report.splitlines()
+               if (m := MATCH_RE.match(line))]
+    total = TOTAL_RE.search(combined_report)
+    result["matched_groups"] = int(total.group(1)) if total else len(symbols)
+    result["matcher_bodies"] = int(total.group(2)) if total else 0
+    result["matched_symbols"] = ",".join(sorted(set(symbols)))
+
+    mrc, rewritten, merr = run([str(PYTHON), str(MATCHER), str(debuf)])
+    matched.write_text(rewritten.rstrip() + "\n")
+    match_log.write_text(merr)
+    result["matcher_ok"] = mrc == 0
+    launches = LAUNCH_RE.findall(rewritten)
+    result["kernel_launches"] = len(launches)
+    result["launch_symbols"] = ",".join(sorted(set(launches)))
+    if mrc:
+        result["error"] = next((x for x in merr.splitlines() if "error" in x.lower()), merr[:300])
+    return result
+
+def main():
+    OUT.mkdir(parents=True, exist_ok=True)
+    rows = [r for r in csv.DictReader((CORPUS/"manifest.csv").open())
+            if r["variant"] == "normalized"]
+    results = []
+    with concurrent.futures.ThreadPoolExecutor(max_workers=4) as pool:
+        futures = [pool.submit(process, row) for row in rows]
+        for future in concurrent.futures.as_completed(futures):
+            row = future.result(); results.append(row)
+            print(f"{row['id']:<40} matches={row['matched_groups']:<3} "
+                  f"bodies={row['matcher_bodies']:<3} launches={row['kernel_launches']}",
+                  flush=True)
+    results.sort(key=lambda r: r["id"])
+    with (OUT/"summary.csv").open("w", newline="") as f:
+        writer = csv.DictWriter(
+            f, fieldnames=list(results[0]), lineterminator="\n"
+        )
+        writer.writeheader(); writer.writerows(results)
+    matched = [r for r in results if r["matched_groups"]]
+    with (OUT/"SUMMARY.md").open("w") as f:
+        f.write("# MFEM normalized-kernel library matching\n\n")
+        f.write(f"- kernels: {len(results)}\n")
+        f.write(f"- matcher successes: {sum(r['matcher_ok'] for r in results)}\n")
+        f.write(f"- kernels with at least one match: {len(matched)}\n")
+        f.write(f"- matched stage groups: {sum(r['matched_groups'] for r in results)}\n")
+        f.write(f"- emitted kernel.launch operations: {sum(r['kernel_launches'] for r in results)}\n\n")
+        f.write("Matches are stage-level unless a report explicitly names a whole composition.\n")
+        f.write("""
+
+## FP64 contraction lowering
+
+- 128 matches are ABI-legal two-input FP64 contractions:
+  - 64 rank `4 x 5 -> 4`
+  - 4 rank `5 x 4 -> 4`
+  - 20 rank `5 x 5 -> 4`
+- 40 iterator/rank-generic launches, comprising all 36 2D contraction stages
+  plus 4 3D stages whose physical output views compact a broadcast mode
+- All 128 lower to `polygeist_cutensornet_contraction2_f64`, with the original
+  affine indexing maps and physical `polygeist.submap` strides encoded as
+  extent/stride/mode metadata.
+- A reduction dimension may occur in the logical output map only when its
+  physical `polygeist.submap` stride is proven zero; ABI lowering then omits
+  that broadcast mode from the output descriptor.
+- The remaining 6 emitted launches are older structural matches (5
+  `cublasDaxpby`, 1 `cudnnAddTensor_batched`) and are not included in the
+  cuTensorNet lowering count.
+
+Host compilation, focused pass tests, and the CPU reference contraction test
+pass.
+
+## Silicon validation
+
+On 2026-07-24, all three compiler-generated FP64 variants ran through
+cuTensorNet on an aarch64 Tegra target:
+
+- `r4 x r5 -> r4`: `max_error=0`
+- `r5 x r4 -> r4`: `max_error=0`
+- `r5 x r5 -> r4` with compacted broadcast modes: `max_error=0`
+
+The first call paid cuTensorNet/CUDA initialization and planning cost. The
+subsequent two small contractions took about `0.085-0.088 ms` of device time.
+See `../silicon_results/2026-07-24_cutensornet_variants.log`.
+""")
+
+if __name__ == "__main__": main()
diff --git a/scripts/correctness/mfem_raise_sweep.py b/scripts/correctness/mfem_raise_sweep.py
new file mode 100644
index 000000000000..a3f1faa9c344
--- /dev/null
+++ b/scripts/correctness/mfem_raise_sweep.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""Run cgeist and the affine-to-Linalg pipeline on extracted MFEM kernels."""
+
+import csv
+import re
+import subprocess
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+CORPUS = ROOT / "issues" / "mfem_c_kernels"
+RESULTS = CORPUS / "results"
+CGEIST = ROOT / "build" / "bin" / "cgeist"
+OPT = ROOT / "build" / "bin" / "polygeist-opt"
+RESOURCE_DIR = ROOT / "llvm-project" / "build" / "lib" / "clang" / "18"
+
+
+def run(command, log):
+    proc = subprocess.run(command, text=True, stdout=subprocess.PIPE,
+                          stderr=subprocess.STDOUT)
+    log.write_text(proc.stdout)
+    return proc.returncode
+
+
+def count(pattern, path):
+    if not path.exists():
+        return 0
+    return len(re.findall(pattern, path.read_text()))
+
+
+def main():
+    RESULTS.mkdir(parents=True, exist_ok=True)
+    rows = list(csv.DictReader((CORPUS / "manifest.csv").open()))
+    summary = []
+    for row in rows:
+        stem = row["id"] + "__" + row["variant"]
+        source = CORPUS / row["source"]
+        frontend = RESULTS / (stem + ".frontend.mlir")
+        raised = RESULTS / (stem + ".raised.mlir")
+        front_log = RESULTS / (stem + ".frontend.log")
+        raise_log = RESULTS / (stem + ".raise.log")
+        front_rc = run([
+            str(CGEIST), str(source), "--function=" + row["function"],
+            "--resource-dir=" + str(RESOURCE_DIR), "--raise-scf-to-affine",
+            "-S", "-o", str(frontend),
+        ], front_log)
+        raise_rc = -1
+        if front_rc == 0:
+            raise_rc = run([
+                str(OPT), "--select-func=func-name=" + row["function"],
+                "--remove-iter-args", "--affine-parallelize",
+                "--raise-affine-to-linalg-pipeline",
+                "--lower-polygeist-submap", str(frontend), "-o", str(raised),
+            ], raise_log)
+        else:
+            raise_log.write_text("not run: cgeist frontend failed\n")
+        linalg = count(r"\blinalg\.", raised) if raise_rc == 0 else 0
+        loops = count(r"\b(?:affine|scf)\.(?:for|parallel|while)\b", raised) \
+            if raise_rc == 0 else 0
+        result = dict(row)
+        result.update(frontend_ok=str(front_rc == 0).lower(),
+                      raise_ok=str(raise_rc == 0).lower(),
+                      linalg_ops=str(linalg), residual_loops=str(loops),
+                      fully_raised=str(raise_rc == 0 and linalg > 0 and loops == 0).lower())
+        summary.append(result)
+        print(f"{row['id']:<24} frontend={front_rc == 0!s:<5} "
+              f"raise={raise_rc == 0!s:<5} linalg={linalg:<3} loops={loops}")
+    fields = list(summary[0]) if summary else []
+    with (RESULTS / "summary.csv").open("w", newline="") as out:
+        writer = csv.DictWriter(out, fieldnames=fields)
+        writer.writeheader()
+        writer.writerows(summary)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/correctness/mfem_validate_extractions.py b/scripts/correctness/mfem_validate_extractions.py
new file mode 100644
index 000000000000..de44d55f0c74
--- /dev/null
+++ b/scripts/correctness/mfem_validate_extractions.py
@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""Numerically compare every normalized MFEM kernel with its faithful original."""
+import ctypes as C
+import random
+import subprocess
+import tempfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+CORPUS = ROOT / "issues" / "mfem_c_kernels"
+random.seed(20260721)
+P = C.POINTER(C.c_double)
+
+def array(values): return (C.c_double * len(values))(*values)
+def rand(n): return array([random.uniform(-1, 1) for _ in range(n)])
+def transpose(a, rows, cols): return array([a[i*cols+j] for j in range(cols) for i in range(rows)])
+def invoke(lib, name, args, seed):
+    out = array(seed); f = getattr(lib, name); f.argtypes = [P] * (len(args)+1); f(*args, out); return out
+def compare(lib, original, normalized, args, n, seed=None, tolerance=4e-14):
+    initial = [0.0]*n if seed is None else seed
+    a = invoke(lib, original, args, initial); b = invoke(lib, normalized, args, initial)
+    error = max(abs(a[i]-b[i]) for i in range(n))
+    print(f"{original:<40} max_error={error:.3e}")
+    if error > tolerance: raise RuntimeError(f"{original} mismatch: {error}")
+
+def main():
+    with tempfile.TemporaryDirectory(prefix="mfem-c-kernels-") as tmp:
+        library = Path(tmp) / "libmfem_c_kernels.so"
+        sources = sorted((CORPUS/"original").glob("*.c")) + sorted((CORPUS/"normalized").glob("*.c"))
+        subprocess.run(["clang", "-shared", "-fPIC", "-O0", *map(str,sources), "-o", str(library)], check=True)
+        lib = C.CDLL(str(library)); D,Q,E,NE,V = 4,5,3,2,2
+        B,G = rand(Q*D),rand(Q*D); Bt,Gt = transpose(B,Q,D),transpose(G,Q,D)
+        for d in (2,3):
+            compare(lib,f"mfem_interp_value_{d}d",f"mfem_interp_value_{d}d_scratch_sliced",(rand(V*D**d),B),V*Q**d)
+            compare(lib,f"mfem_integrate_value_{d}d",f"mfem_integrate_value_{d}d_scratch_sliced",(rand(V*Q**d),B),V*D**d,[random.uniform(-1,1) for _ in range(V*D**d)])
+            compare(lib,f"mfem_interp_grad_{d}d",f"mfem_interp_grad_{d}d_stage_sliced",(rand(V*D**d),B,G),V*d*Q**d)
+            compare(lib,f"mfem_integrate_grad_{d}d",f"mfem_integrate_grad_{d}d_stage_sliced",(rand(V*d*Q**d),B,G),V*D**d,[random.uniform(-1,1) for _ in range(V*D**d)])
+            n=NE*D**d; seed=[random.uniform(-1,1) for _ in range(n)]
+            compare(lib,f"mfem_pa_mass_apply_{d}d",f"mfem_pa_mass_apply_{d}d_stage_sliced",(B,Bt,rand(NE*Q**d),rand(n)),n,seed)
+            compare(lib,f"mfem_pa_diffusion_apply_{d}d",f"mfem_pa_diffusion_apply_{d}d_stage_sliced",(B,G,Bt,Gt,rand(NE*(3 if d==2 else 6)*Q**d),rand(n)),n,seed)
+            compare(lib,f"mfem_pa_convection_apply_{d}d",f"mfem_pa_convection_apply_{d}d_stage_sliced",(B,G,Bt,rand(NE*d*Q**d),rand(n)),n,seed)
+        for d,nq in ((2,Q**2),(3,Q**3)):
+            n=NE*d*d*nq; qv=[random.uniform(-1,1) for _ in range(n)]; J=[0.0]*n
+            for e in range(NE):
+                for i in range(d):
+                    for j in range(d):
+                        for p in range(nq): J[p+nq*(j+d*(i+d*e))]=(1.5 if i==j else 0.0)+random.uniform(-.1,.1)
+            la,mu,wt=rand(NE*nq),rand(NE*nq),array([random.uniform(.2,1.2) for _ in range(nq)])
+            original=array(qv); f=getattr(lib,f"mfem_elasticity_qpoint_{d}d"); f.argtypes=[P]*5; f(la,mu,array(J),wt,original)
+            output=array([0.0]*n); g=getattr(lib,f"mfem_elasticity_qpoint_{d}d_scalarized"); g.argtypes=[P]*6; g(la,mu,array(J),wt,array(qv),output)
+            error=max(abs(original[i]-output[i]) for i in range(n)); print(f"mfem_elasticity_qpoint_{d}d{'':<13} max_error={error:.3e}"); assert error < 4e-14
+        Bo=rand(Q*E); Bot=transpose(Bo,Q,E); op2=rand(NE*Q**2); x2=rand(NE*2*E*D); seed2=[random.uniform(-1,1) for _ in range(len(x2))]
+        for kind in ("curlcurl","divdiv"):
+            compare(lib,f"mfem_pa_{kind}_apply_2d",f"mfem_pa_{kind}_apply_2d_stage_sliced",(Bo,Bot,G,Gt,op2,x2),len(x2),seed2)
+        xdiv=rand(NE*3*E*E*D); compare(lib,"mfem_pa_divdiv_apply_3d","mfem_pa_divdiv_apply_3d_stage_sliced",(Bo,Bot,G,Gt,rand(NE*Q**3),xdiv),len(xdiv),[random.uniform(-1,1) for _ in range(len(xdiv))])
+        Bc=rand(Q*D); Bct=transpose(Bc,Q,D); xcurl=rand(NE*3*E*D*D)
+        compare(lib,"mfem_pa_curlcurl_apply_3d","mfem_pa_curlcurl_apply_3d_stage_sliced",(Bo,Bc,Bot,Bct,G,Gt,rand(NE*6*Q**3),xcurl),len(xcurl),[random.uniform(-1,1) for _ in range(len(xcurl))])
+
+if __name__ == "__main__": main()
diff --git a/scripts/correctness/mvt_jetson_wrapper.c b/scripts/correctness/mvt_jetson_wrapper.c
new file mode 100644
index 000000000000..4edfc81f590d
--- /dev/null
+++ b/scripts/correctness/mvt_jetson_wrapper.c
@@ -0,0 +1,43 @@
+/* mvt_jetson_wrapper.c — Jetson timing wrapper.
+ *
+ * polybenchGpu kernel_mvt computes:
+ *   x1 += A · y_1
+ *   x2 += Aᵀ · y_2
+ *
+ * (Both are accumulating gemvs; the matcher fissions the accumulation,
+ * so each surfaces as a plain gemv that writes to x1/x2 — initialised
+ * elsewhere. The transpose-discriminator routes the second to dgemv_T.)
+ *
+ * Signature: kernel_mvt(n, x1, x2, y_1, y_2, A)
+ */
+#include 
+#include 
+
+extern void kernel_mvt_impl(
+    int n,
+    /* x1: 1D */
+    double *x1_b, double *x1_a, int64_t x1_o, int64_t x1_s, int64_t x1_st,
+    /* x2: 1D */
+    double *x2_b, double *x2_a, int64_t x2_o, int64_t x2_s, int64_t x2_st,
+    /* y_1: 1D */
+    double *y1_b, double *y1_a, int64_t y1_o, int64_t y1_s, int64_t y1_st,
+    /* y_2: 1D */
+    double *y2_b, double *y2_a, int64_t y2_o, int64_t y2_s, int64_t y2_st,
+    /* A: 2D */
+    double *A_b, double *A_a, int64_t A_o, int64_t A_s0, int64_t A_s1, int64_t A_st0, int64_t A_st1);
+
+extern void   polygeist_cublas_time_begin(void);
+extern double polygeist_cublas_time_end_ms(void);
+
+void kernel_mvt(int n, double *x1, double *x2, double *y_1, double *y_2,
+                double *A) {
+  polygeist_cublas_time_begin();
+  kernel_mvt_impl(n,
+                  x1, x1, 0, n, 1,
+                  x2, x2, 0, n, 1,
+                  y_1, y_1, 0, n, 1,
+                  y_2, y_2, 0, n, 1,
+                  A, A, 0, n, n, n, 1);
+  double ms = polygeist_cublas_time_end_ms();
+  fprintf(stderr, "POLYGEIST_TIMING: kernel_mvt n=%d  %.3f ms\n", n, ms);
+}
diff --git a/scripts/correctness/npb_extracted_sweep.sh b/scripts/correctness/npb_extracted_sweep.sh
new file mode 100755
index 000000000000..926c275e68c7
--- /dev/null
+++ b/scripts/correctness/npb_extracted_sweep.sh
@@ -0,0 +1,73 @@
+#!/bin/bash
+# Sweep the PolyBench-style extracted NPB kernels through the raise pipeline.
+# Each kernel is a single .c file in third_party/NPB-polybenchified/ that
+# takes its arrays as parameters (no module-level static globals).
+set +e
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+DIR=$REPO_ROOT/third_party/NPB-polybenchified
+OUT=/tmp/npb_extracted_sweep
+mkdir -p $OUT
+
+# Format:   
+KERNELS=(
+  "bt-add       bt_add"
+  "ft-evolve    ft_evolve"
+  "lu-l2norm    lu_l2norm"
+  "mg-psinv     mg_psinv"
+  "mg-resid     mg_resid"
+  "mg-norm2u3   mg_norm2u3"
+  "mg-rprj3     mg_rprj3"
+)
+
+printf '%-12s %5s %5s %5s   %5s %5s %5s   %5s %5s %5s   %s\n' \
+  kernel CG_LG CG_AF CG_SF RS_LG RS_AF RS_SF DB_LG DB_AF DB_SF status
+echo "----------------------------------------------------------------------------------"
+
+for entry in "${KERNELS[@]}"; do
+  read tag fn <<<"$entry"
+  src="$DIR/${tag//-/_}.c"
+  [ ! -f "$src" ] && { printf '%-12s missing %s\n' "$tag" "$src"; continue; }
+
+  timeout 60 cgeist "$src" --function=$fn --resource-dir=/usr/lib/clang/14 \
+    --raise-scf-to-affine -fPIC -S -o $OUT/${tag}.mlir 2>$OUT/${tag}.cgeist.err
+  if [ ! -s $OUT/${tag}.mlir ]; then
+    printf '%-12s   --   --   --      --   --   --      --   --   --   CGEIST_FAIL\n' "$tag"; continue
+  fi
+  CG_LG=$(grep -c "linalg.generic" $OUT/${tag}.mlir 2>/dev/null); CG_LG=${CG_LG:-0}
+  CG_AF=$(grep -c "affine.for" $OUT/${tag}.mlir 2>/dev/null); CG_AF=${CG_AF:-0}
+  CG_SF=$(grep -cE "scf\.(for|while)" $OUT/${tag}.mlir 2>/dev/null); CG_SF=${CG_SF:-0}
+
+  timeout 60 polygeist-opt --select-func=func-name=$fn \
+    --remove-iter-args --affine-parallelize \
+    --raise-affine-to-linalg-pipeline --lower-polygeist-submap \
+    $OUT/${tag}.mlir -o $OUT/${tag}.raised.mlir 2>$OUT/${tag}.raise.err
+  if [ ! -s $OUT/${tag}.raised.mlir ]; then
+    printf '%-12s %5s %5s %5s     --   --   --      --   --   --   RAISE_FAIL\n' \
+      "$tag" "$CG_LG" "$CG_AF" "$CG_SF"; continue
+  fi
+  RS_LG=$(grep -c "linalg.generic" $OUT/${tag}.raised.mlir 2>/dev/null); RS_LG=${RS_LG:-0}
+  RS_AF=$(grep -c "affine.for" $OUT/${tag}.raised.mlir 2>/dev/null); RS_AF=${RS_AF:-0}
+  RS_SF=$(grep -cE "scf\.(for|while)" $OUT/${tag}.raised.mlir 2>/dev/null); RS_SF=${RS_SF:-0}
+
+  timeout 60 polygeist-opt --linalg-debufferize=use-multi-root=true \
+    $OUT/${tag}.raised.mlir -o $OUT/${tag}.debuf.mlir 2>$OUT/${tag}.debuf.err
+  if [ ! -s $OUT/${tag}.debuf.mlir ]; then
+    printf '%-12s %5s %5s %5s   %5s %5s %5s      --   --   --   DEBUF_FAIL\n' \
+      "$tag" "$CG_LG" "$CG_AF" "$CG_SF" "$RS_LG" "$RS_AF" "$RS_SF"; continue
+  fi
+  DB_LG=$(grep -c "linalg.generic" $OUT/${tag}.debuf.mlir 2>/dev/null); DB_LG=${DB_LG:-0}
+  DB_AF=$(grep -c "affine.for" $OUT/${tag}.debuf.mlir 2>/dev/null); DB_AF=${DB_AF:-0}
+  DB_SF=$(grep -cE "scf\.(for|while)" $OUT/${tag}.debuf.mlir 2>/dev/null); DB_SF=${DB_SF:-0}
+
+  if [ "$DB_LG" -gt 0 ] && [ "$DB_AF" -eq 0 ] && [ "$DB_SF" -eq 0 ]; then
+    status=FULL_LIFT
+  elif [ "$DB_LG" -gt 0 ]; then
+    status=PARTIAL_LIFT
+  else
+    status=NO_LIFT
+  fi
+  printf '%-12s %5s %5s %5s   %5s %5s %5s   %5s %5s %5s   %s\n' \
+    "$tag" "$CG_LG" "$CG_AF" "$CG_SF" "$RS_LG" "$RS_AF" "$RS_SF" \
+    "$DB_LG" "$DB_AF" "$DB_SF" "$status"
+done
diff --git a/scripts/correctness/npb_sweep.sh b/scripts/correctness/npb_sweep.sh
new file mode 100755
index 000000000000..bac60c316397
--- /dev/null
+++ b/scripts/correctness/npb_sweep.sh
@@ -0,0 +1,85 @@
+#!/bin/bash
+# Sweep NPB-C benchmarks through the Polygeist raise pipeline.
+#
+# NPB-C is one big .c per benchmark (BT, LU, SP, MG, FT, CG, IS, EP),
+# each containing many static kernel-shaped functions. Unlike PolyBench
+# / MachSuite where each file has exactly one kernel, NPB references
+# many module-level statics from each function — so `--select-func`
+# (which strips global defs) yields invalid modules. We raise the
+# whole .c file and report per-benchmark totals: # linalg.generic vs
+# # residual affine.for / scf.for / scf.while.
+set +e
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+ROOT=$REPO_ROOT/third_party/NPB3.0-omp-C
+COMMON=$ROOT/common
+OUT=/tmp/npb_sweep
+mkdir -p $OUT
+
+BENCHES=(BT LU SP MG FT CG IS EP)
+
+printf '%-6s %5s %5s %5s   %5s %5s %5s   %5s %5s %5s   %s\n' \
+  bench CG_LG CG_AF CG_SF RS_LG RS_AF RS_SF DB_LG DB_AF DB_SF status
+echo "------------------------------------------------------------------------------"
+
+for b in "${BENCHES[@]}"; do
+  D=$ROOT/$b
+  src=$D/$(echo $b | tr 'A-Z' 'a-z').c
+  if [ ! -f "$src" ]; then
+    printf '%-6s missing %s\n' "$b" "$src"; continue
+  fi
+
+  # Step 1: cgeist (whole module, all functions). NPB benchmarks are large
+  # (BT/LU/SP each over 3000 LoC); give cgeist a generous budget.
+  timeout 300 cgeist "$src" --function='*' --resource-dir=/usr/lib/clang/14 \
+    -I$COMMON -I$D -Dstatic= \
+    -DNPBVERSION='"3.0"' -DCOMPILETIME='"now"' \
+    -DCS1='"cc"' -DCS2='"cc"' -DCS3='"-O3"' -DCS4='""' \
+    -DCS5='""' -DCS6='""' -DCS7='""' \
+    --raise-scf-to-affine -fPIC -S \
+    -o $OUT/${b}.mlir 2>$OUT/${b}.cgeist.err
+  if [ ! -s $OUT/${b}.mlir ]; then
+    printf '%-6s   --   --   --      --   --   --      --   --   --   CGEIST_FAIL\n' "$b"
+    continue
+  fi
+  CG_LG=$(grep -c "linalg.generic" $OUT/${b}.mlir 2>/dev/null); CG_LG=${CG_LG:-0}
+  CG_AF=$(grep -c "affine.for" $OUT/${b}.mlir 2>/dev/null); CG_AF=${CG_AF:-0}
+  CG_SF=$(grep -cE "scf\.(for|while)" $OUT/${b}.mlir 2>/dev/null); CG_SF=${CG_SF:-0}
+
+  # Step 2: raise + lower-submap on the whole module.
+  timeout 600 polygeist-opt \
+    --remove-iter-args --affine-parallelize \
+    --raise-affine-to-linalg-pipeline --lower-polygeist-submap \
+    $OUT/${b}.mlir -o $OUT/${b}.raised.mlir 2>$OUT/${b}.raise.err
+  if [ ! -s $OUT/${b}.raised.mlir ]; then
+    printf '%-6s %5s %5s %5s     --   --   --      --   --   --   RAISE_FAIL\n' \
+      "$b" "$CG_LG" "$CG_AF" "$CG_SF"
+    continue
+  fi
+  RS_LG=$(grep -c "linalg.generic" $OUT/${b}.raised.mlir 2>/dev/null); RS_LG=${RS_LG:-0}
+  RS_AF=$(grep -c "affine.for" $OUT/${b}.raised.mlir 2>/dev/null); RS_AF=${RS_AF:-0}
+  RS_SF=$(grep -cE "scf\.(for|while)" $OUT/${b}.raised.mlir 2>/dev/null); RS_SF=${RS_SF:-0}
+
+  # Step 3: debufferize (multi-root).
+  timeout 180 polygeist-opt --linalg-debufferize=use-multi-root=true \
+    $OUT/${b}.raised.mlir -o $OUT/${b}.debuf.mlir 2>$OUT/${b}.debuf.err
+  if [ ! -s $OUT/${b}.debuf.mlir ]; then
+    printf '%-6s %5s %5s %5s   %5s %5s %5s      --   --   --   DEBUF_FAIL\n' \
+      "$b" "$CG_LG" "$CG_AF" "$CG_SF" "$RS_LG" "$RS_AF" "$RS_SF"
+    continue
+  fi
+  DB_LG=$(grep -c "linalg.generic" $OUT/${b}.debuf.mlir 2>/dev/null); DB_LG=${DB_LG:-0}
+  DB_AF=$(grep -c "affine.for" $OUT/${b}.debuf.mlir 2>/dev/null); DB_AF=${DB_AF:-0}
+  DB_SF=$(grep -cE "scf\.(for|while)" $OUT/${b}.debuf.mlir 2>/dev/null); DB_SF=${DB_SF:-0}
+
+  if [ "$DB_LG" -gt 0 ] && [ "$DB_AF" -eq 0 ] && [ "$DB_SF" -eq 0 ]; then
+    status=FULL_LIFT
+  elif [ "$DB_LG" -gt 0 ]; then
+    status=PARTIAL_LIFT
+  else
+    status=NO_LIFT
+  fi
+  printf '%-6s %5s %5s %5s   %5s %5s %5s   %5s %5s %5s   %s\n' \
+    "$b" "$CG_LG" "$CG_AF" "$CG_SF" "$RS_LG" "$RS_AF" "$RS_SF" \
+    "$DB_LG" "$DB_AF" "$DB_SF" "$status"
+done
diff --git a/scripts/correctness/polybench_cublas_jetson.sh b/scripts/correctness/polybench_cublas_jetson.sh
new file mode 100755
index 000000000000..ed28e82ae969
--- /dev/null
+++ b/scripts/correctness/polybench_cublas_jetson.sh
@@ -0,0 +1,161 @@
+#!/bin/bash
+# polybench_cublas_jetson.sh — generic polybench → Jetson cross-build wrapper.
+# Generalises gemm_cublas_jetson.sh to any polybench kernel whose body lifts
+# to a matched kernel.launch @cublasDgemm op.
+#
+# Usage:
+#   ./polybench_cublas_jetson.sh  [DATASET]
+#
+# Currently registered kernels (extend the KERNELS table below):
+#   gemm, 2mm, 3mm
+#
+# DATASET defaults to LARGE. Allowed: MINI|SMALL|MEDIUM|LARGE|EXTRALARGE.
+# (PolyBench/C 4.2.1 doesn't have STANDARD; passing it is a silent no-op.)
+
+set -euo pipefail
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+if [ "$#" -lt 1 ]; then
+  echo "usage: $0  [DATASET]" >&2
+  echo "       supported kernels: gemm, 2mm, 3mm" >&2
+  exit 1
+fi
+
+KERNEL=$1
+DATASET=${2:-LARGE}
+
+case "$DATASET" in
+  MINI|SMALL|MEDIUM|LARGE|EXTRALARGE) ;;
+  STANDARD) echo "ERROR: PolyBench/C 4.2.1 has no STANDARD_DATASET (no-op). Use LARGE." >&2; exit 1 ;;
+  *) echo "ERROR: bad DATASET '$DATASET'" >&2; exit 1 ;;
+esac
+
+POLYBENCH_DIR=$REPO_ROOT/tools/cgeist/Test/polybench
+case "$KERNEL" in
+  gemm) SRC_DIR="$POLYBENCH_DIR/linear-algebra/blas/gemm";     KFN=kernel_gemm ;;
+  2mm)  SRC_DIR="$POLYBENCH_DIR/linear-algebra/kernels/2mm";   KFN=kernel_2mm ;;
+  3mm)  SRC_DIR="$POLYBENCH_DIR/linear-algebra/kernels/3mm";   KFN=kernel_3mm ;;
+  *)    echo "ERROR: kernel '$KERNEL' not registered in $0" >&2; exit 1 ;;
+esac
+
+UTIL=$POLYBENCH_DIR/utilities
+SCRIPTS=$REPO_ROOT/scripts/correctness
+RT=$REPO_ROOT/runtime
+OUT=/tmp/polybench_jetson_${KERNEL}_${DATASET}
+mkdir -p $OUT
+
+WRAPPER=$SCRIPTS/${KERNEL}_jetson_wrapper.c
+[ -f "$WRAPPER" ] || { echo "ERROR: wrapper missing at $WRAPPER" >&2; exit 1; }
+
+CFLAGS=(-O3 -I"$UTIL" -I"$SRC_DIR"
+        -DDATA_TYPE_IS_DOUBLE -DPOLYBENCH_TIME -DPOLYBENCH_DUMP_ARRAYS
+        -D${DATASET}_DATASET
+        -Dstatic= -DPOLYBENCH_USE_C99_PROTO)
+
+echo "[$KERNEL/$DATASET] (1) cgeist → affine MLIR"
+cgeist "$SRC_DIR/${KERNEL}.c" --function=$KFN --resource-dir=/usr/lib/clang/14 \
+    "${CFLAGS[@]}" --raise-scf-to-affine -S \
+    -o $OUT/orig.mlir 2>/dev/null
+
+echo "[$KERNEL/$DATASET] (2) raise + lower-submap + debufferize"
+polygeist-opt --select-func=func-name=$KFN \
+    --remove-iter-args --affine-parallelize \
+    --raise-affine-to-linalg-pipeline --lower-polygeist-submap \
+    --linalg-debufferize \
+    $OUT/orig.mlir -o $OUT/debuf.mlir 2>$OUT/raise.err
+
+echo "[$KERNEL/$DATASET] (3) kernel-match"
+PYTHON=$PYTHON
+$PYTHON $SCRIPTS/kernel_match_rewrite.py $OUT/debuf.mlir > $OUT/matched.mlir 2>$OUT/match.err
+N_LAUNCH=$(grep -c '= kernel\.launch ' $OUT/matched.mlir || true)
+N_LAUNCH=${N_LAUNCH:-0}
+[ "$N_LAUNCH" -ge 1 ] || { echo "  FAIL: no kernel.launch ops"; exit 1; }
+echo "  matched $N_LAUNCH kernel.launch op(s)"
+
+echo "[$KERNEL/$DATASET] (4) inject kernel.defn declarations for all matched libsyms"
+# The verifier requires every @ referenced by a kernel.launch to have
+# a kernel.defn @ in scope. Inject stub defns for every library
+# symbol our matcher emits; --lower-kernel-launch-to-cublas will clean
+# them up after rewriting all launches into func.call ops.
+awk '/^module attributes/ && !done{
+       print;
+       print "  kernel.defn @cublasDgemm(%A: tensor, %B: tensor, %C: tensor, %beta: f64, %alpha: f64) -> tensor {";
+       print "    kernel.yield %C : tensor";
+       print "  }";
+       print "  kernel.defn @cublasDgemm_simple(%A: tensor, %B: tensor, %C: tensor) -> tensor {";
+       print "    kernel.yield %C : tensor";
+       print "  }";
+       print "  kernel.defn @cublasDgemm_alpha_only(%A: tensor, %B: tensor, %C: tensor, %alpha: f64) -> tensor {";
+       print "    kernel.yield %C : tensor";
+       print "  }";
+       print "  kernel.defn @cublasDgeam_scale2D(%M: tensor, %scale: f64) -> tensor {";
+       print "    kernel.yield %M : tensor";
+       print "  }";
+       print "  kernel.defn @memset_zero_2D(%M: tensor) -> tensor {";
+       print "    kernel.yield %M : tensor";
+       print "  }";
+       done=1; next
+     }{print}' $OUT/matched.mlir > $OUT/matched_with_defn.mlir
+
+echo "[$KERNEL/$DATASET] (5) lower-kernel-launch-to-cublas"
+polygeist-opt --lower-kernel-launch-to-cublas \
+    $OUT/matched_with_defn.mlir -o $OUT/abi.mlir 2>$OUT/abi.err
+N_CALL=$(grep -cE 'call @polygeist_cublas_dgemm\(' $OUT/abi.mlir || true)
+N_CALL=${N_CALL:-0}
+echo "  emitted $N_CALL func.call to polygeist_cublas_dgemm"
+
+echo "[$KERNEL/$DATASET] (6) cross-compile polybench harness for aarch64"
+aarch64-linux-gnu-gcc "${CFLAGS[@]}" -c "$SRC_DIR/${KERNEL}.c" -o $OUT/full.o
+aarch64-linux-gnu-objcopy --weaken-symbol=$KFN $OUT/full.o $OUT/nokernel.o
+aarch64-linux-gnu-gcc "${CFLAGS[@]}" -c "$UTIL/polybench.c" -o $OUT/polybench.o
+
+echo "[$KERNEL/$DATASET] (7) rename @${KFN} → @${KFN}_impl + build both variants"
+sed "s/@${KFN}\\b/@${KFN}_impl/g" $OUT/abi.mlir > $OUT/abi_renamed.mlir
+
+# build_jetson.sh's own sed for @kernel_gemm is a no-op for other kernels.
+# It also expects a particular WORK layout, so for non-gemm kernels we do
+# the cross-link manually to avoid name conflicts.
+WORK=$OUT/work; mkdir -p $WORK
+CUDA=/usr/local/cuda-12.6/targets/sbsa-linux
+
+sed 's|bufferization\.to_tensor \(%[^ ]*\) :|bufferization.to_tensor \1 restrict :|g' \
+    $OUT/abi_renamed.mlir > $WORK/abi.mlir
+$REPO_ROOT/llvm-project/build/bin/mlir-opt \
+    --one-shot-bufferize=bufferize-function-boundaries \
+    --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \
+    --convert-arith-to-llvm --finalize-memref-to-llvm \
+    --convert-func-to-llvm --reconcile-unrealized-casts \
+    $WORK/abi.mlir -o $WORK/llvm.mlir 2>&1 | tail -1
+$REPO_ROOT/llvm-project/build/bin/mlir-translate \
+    --mlir-to-llvmir $WORK/llvm.mlir -o $WORK/kernel.ll
+sed -i 's|target triple = "x86_64.*"|target triple = "aarch64-linux-gnu"|;
+        /^target datalayout/d' $WORK/kernel.ll
+$REPO_ROOT/llvm-project/build/bin/clang \
+    --target=aarch64-linux-gnu --gcc-toolchain=/usr \
+    -O3 -c $WORK/kernel.ll -o $WORK/kernel.o 2>&1 | tail -1
+
+# CUDA variant — the runtime shim now includes cuDNN code (for conv2d
+# variants) and cudaHostRegister APIs; link against cuDNN + its rpath.
+CUDNN_INC=${CUDNN_INC:-/usr/include/aarch64-linux-gnu}
+CUDNN_LIB=${CUDNN_LIB:-/usr/lib/aarch64-linux-gnu}
+aarch64-linux-gnu-gcc -O3 -I$CUDA/include -I$CUDNN_INC -c $RT/polygeist_cublas_rt_cuda.c -o $WORK/rt_cuda.o
+aarch64-linux-gnu-gcc -O3 -c $WRAPPER -o $WORK/wrapper.o
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/nokernel.o $WORK/wrapper.o $WORK/kernel.o $WORK/rt_cuda.o $OUT/polybench.o \
+    -L$CUDA/lib -L$CUDA/lib/stubs -L$CUDNN_LIB \
+    -lcudnn -lcublasLt -lcublas -lcudart -lm -lpthread -ldl \
+    -Wl,-rpath,/usr/local/cuda/lib64:/usr/lib/aarch64-linux-gnu \
+    -o $OUT/${KERNEL}_jetson
+
+# CPU-stub variant
+aarch64-linux-gnu-gcc -O3 -c $RT/polygeist_cublas_rt_cpu.c -o $WORK/rt_cpu.o
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/nokernel.o $WORK/wrapper.o $WORK/kernel.o $WORK/rt_cpu.o $OUT/polybench.o \
+    -lm -lpthread -o $OUT/${KERNEL}_jetson_cpustub
+
+echo ""
+echo "═══ ${KERNEL}/${DATASET} built for Jetson: ═══"
+ls -la $OUT/${KERNEL}_jetson $OUT/${KERNEL}_jetson_cpustub
+file $OUT/${KERNEL}_jetson | head -1
+aarch64-linux-gnu-readelf -d $OUT/${KERNEL}_jetson | grep -E 'libcublas|libcudart' | head -3
diff --git a/scripts/correctness/polygeist_build.sh b/scripts/correctness/polygeist_build.sh
new file mode 100755
index 000000000000..d6e9d78da4ae
--- /dev/null
+++ b/scripts/correctness/polygeist_build.sh
@@ -0,0 +1,467 @@
+#!/bin/bash
+# polygeist_build.sh — generic driver: take a C source file containing a
+# kernel function and produce a binary where the kernel is matched to an
+# optimized library implementation (cuDNN / cuBLAS) and the rest of the
+# file (main, init, print, etc.) is compiled normally.
+#
+# Usage:
+#   polygeist_build.sh [--target=host|jetson] [--function=NAME] [-o OUT]
+#                      [--harness=HARNESS.c] [--no-debuf]
+#                       [gcc-passthrough-flags...]
+#
+# Defaults:
+#   --target=host       Produce a binary for the local machine. On an x86
+#                       dev VM with no CUDA, links the CPU-stub runtime so
+#                       the binary still runs (CPU-only, for correctness).
+#                       On a Jetson (aarch64 + JetPack CUDA), links cuDNN/
+#                       cuBLAS and the binary runs on the GPU.
+#   --target=jetson     Cross-compile from this x86 VM to aarch64 + bundle
+#                       the cross-CUDA libs. The resulting binary is an
+#                       aarch64 ELF you can scp to a Jetson and run there.
+#                       Deployment (scp / ssh / execute) is out of scope
+#                       for this driver — that's a separate, environment-
+#                       specific concern.
+#   --function=auto     Auto-detect the kernel function via #pragma scop
+#                       (PolyBench convention) or a leading 'kernel_' prefix.
+#                       Override with --function=NAME for non-conventional
+#                       source.
+#   -o OUT              Defaults to the .c basename without extension.
+#   --no-debuf          Match the memref linalg form directly instead of
+#                       running --linalg-debufferize before the matcher.
+#                       Useful for memref-only compositions such as the
+#                       llama2.c RMSNorm/softmax patterns.
+#
+# Optional environment:
+#   POLYGEIST_CPU_BLAS=1
+#                       Host target only. Compile the CPU runtime shim with
+#                       CBLAS calls for BLAS-like symbols and link OpenBLAS by
+#                       default. Override with POLYGEIST_CPU_BLAS_CFLAGS and
+#                       POLYGEIST_CPU_BLAS_LIBS for MKL/BLIS/ArmPL/NVPL.
+#   POLYGEIST_CUTENSORNET_ROOT=/path/to/cuquantum
+#                       Jetson target only. The root must contain
+#                       include/cutensornet.h and lib/libcutensornet.so for
+#                       aarch64. Enables the cuTensorNet tensor-product shim.
+#   POLYGEIST_MINIMAL_CUTENSORNET_RUNTIME=1
+#                       Jetson target only. For contraction-only binaries,
+#                       discard unused runtime sections and avoid DT_NEEDED
+#                       entries for unrelated cuDNN/cuFFT/cuSPARSE libraries.
+#   POLYGEIST_MINIMAL_CUDA_RUNTIME=1
+#                       Jetson target only. Link a cuBLAS-only executable
+#                       without unrelated cuDNN/cuFFT/cuSPARSE/cuSOLVER
+#                       dependencies after function-section dead stripping.
+#   POLYGEIST_MINIMAL_CUDNN_RUNTIME=1
+#                       As above, but retain cuDNN plus cuBLAS for convolution,
+#                       pooling, normalization, and activation routes.
+#   POLYGEIST_DISABLE_LIBRARY_MATCHING=1
+#                       Preserve residual Linalg instead of emitting any
+#                       kernel.launch operations. Useful for isolating raising
+#                       correctness from matcher/ABI/runtime correctness.
+#
+# Any unrecognized flags are passed through to all the gcc/clang invocations
+# that compile non-MLIR pieces of the build (harness, polybench utility code,
+# runtime shim). This is how PolyBench-style preprocessor defines like
+# -DMINI_DATASET / -DDATA_TYPE_IS_DOUBLE / -DPOLYBENCH_DUMP_ARRAYS get
+# propagated — they're just gcc flags from the driver's perspective.
+#
+# Examples:
+#   polygeist_build.sh gemm.c -DMINI_DATASET -I /path/polybench/utilities
+#   polygeist_build.sh --target=jetson gemm.c -DLARGE_DATASET -o gemm_jetson
+#   polygeist_build.sh --function=kernel_conv2d conv2d.c
+
+set -euo pipefail
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+# ─── Tooling ────────────────────────────────────────────────────────────
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+MLIR_TRANSLATE=$REPO_ROOT/llvm-project/build/bin/mlir-translate
+CLANG=$REPO_ROOT/llvm-project/build/bin/clang
+PYTHON=$PYTHON
+SCRIPTS=$REPO_ROOT/scripts/correctness
+RT=$REPO_ROOT/runtime
+KERNEL_LIB=$REPO_ROOT/generic_solver/kernel_library_phase2.mlir
+
+# Cross toolchain (used only when --target=jetson).
+CUDA_CROSS=/usr/local/cuda-12.6/targets/sbsa-linux
+CUDNN_CROSS_INC=/usr/include/aarch64-linux-gnu
+CUDNN_CROSS_LIB=/usr/lib/aarch64-linux-gnu
+AARCH64_CC=aarch64-linux-gnu-gcc
+
+# ─── Parse args ─────────────────────────────────────────────────────────
+TARGET=host
+FUNCTION=
+OUT=
+INPUT=
+HARNESS_INPUT=
+DEBUFFERIZE=1
+GCC_PASSTHROUGH=()
+RT_CFLAGS=()
+
+usage() {
+  sed -n '3,40p' "$0" | sed 's/^# \?//'
+  exit "${1:-0}"
+}
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --target=*)    TARGET="${1#--target=}"; shift ;;
+    --function=*)  FUNCTION="${1#--function=}"; shift ;;
+    --harness=*)   HARNESS_INPUT="${1#--harness=}"; shift ;;
+    --no-debuf|--no-linalg-debufferize) DEBUFFERIZE=0; shift ;;
+    -o)            OUT="$2"; shift 2 ;;
+    -h|--help)     usage ;;
+    *.c)
+      if [ -z "$INPUT" ]; then INPUT="$1"
+      else GCC_PASSTHROUGH+=("$1"); fi
+      shift ;;
+    *)             GCC_PASSTHROUGH+=("$1"); shift ;;
+  esac
+done
+
+[ -z "$INPUT" ] && { echo "ERROR: no .c input file provided" >&2; usage 1; }
+[ -f "$INPUT" ] || { echo "ERROR: input file $INPUT not found" >&2; exit 1; }
+[ -n "$HARNESS_INPUT" ] || HARNESS_INPUT="$INPUT"
+[ -f "$HARNESS_INPUT" ] || { echo "ERROR: harness file $HARNESS_INPUT not found" >&2; exit 1; }
+case "$TARGET" in host|jetson) ;; *)
+  echo "ERROR: --target must be 'host' or 'jetson' (got '$TARGET')" >&2; exit 1 ;;
+esac
+[ -z "$OUT" ] && OUT="$(basename "$INPUT" .c)"
+
+# ─── Auto-detect the kernel function name ───────────────────────────────
+if [ -z "$FUNCTION" ]; then
+  # Strategy 1: find the function immediately preceding '#pragma scop'
+  # (PolyBench convention — the scop marker sits in the kernel function body).
+  FUNCTION=$(awk '
+    /^void\s+[a-zA-Z_][a-zA-Z0-9_]*\s*\(/ {
+      match($0, /^void\s+([a-zA-Z_][a-zA-Z0-9_]*)/, a); last_fn = a[1]
+    }
+    /#pragma\s+scop/ { print last_fn; exit }
+  ' "$INPUT")
+  # Strategy 2: first function whose name starts with kernel_
+  if [ -z "$FUNCTION" ]; then
+    FUNCTION=$(grep -oE '^\s*(static\s+)?void\s+kernel_[a-zA-Z0-9_]+' "$INPUT" \
+               | head -1 | awk '{print $NF}')
+  fi
+  if [ -z "$FUNCTION" ]; then
+    echo "ERROR: couldn't auto-detect kernel function in $INPUT." >&2
+    echo "       Use --function=NAME to specify it explicitly." >&2
+    exit 1
+  fi
+fi
+
+WORK=$(mktemp -d)
+if [ "${POLYGEIST_KEEP_WORK:-0}" != "0" ]; then
+  echo "[polygeist] keeping workdir: $WORK"
+else
+  trap "rm -rf $WORK" EXIT
+fi
+
+echo "[polygeist] input=$INPUT  function=$FUNCTION  target=$TARGET  output=$OUT"
+echo "[polygeist] harness=$HARNESS_INPUT"
+echo "[polygeist] gcc passthrough: ${GCC_PASSTHROUGH[*]:-(none)}"
+
+# ─── Step 1: cgeist lifts the kernel function to affine MLIR ────────────
+echo "  [1/9] cgeist → affine MLIR"
+cgeist "$INPUT" --function="$FUNCTION" \
+  --resource-dir=/usr/lib/clang/14 \
+  "${GCC_PASSTHROUGH[@]}" \
+  --raise-scf-to-affine -fPIC -S \
+  -o $WORK/affine.mlir 2>$WORK/cgeist.err || {
+    echo "ERROR: cgeist failed; see $WORK/cgeist.err" >&2; cat $WORK/cgeist.err >&2; exit 1; }
+
+# ─── Step 2: raise affine → linalg + debufferize ────────────────────────
+if [ "$DEBUFFERIZE" -eq 1 ]; then
+  echo "  [2/9] polygeist-opt: raise + lower-submap + debufferize"
+  # Joint multi-root reconstruction preserves coupled results from one
+  # multi-output generic.  The older recursive mode can silently retain only
+  # one root (as exposed by the MFEM H(curl)/H(div) applications), so keep it
+  # only as an explicit diagnostic opt-out.
+  DEBUFFERIZE_PASS=(--linalg-debufferize)
+  if [ "${POLYGEIST_DEBUFFERIZE_MULTI_ROOT:-1}" != "0" ]; then
+    DEBUFFERIZE_PASS=(--linalg-debufferize=use-multi-root=true)
+    echo "         using joint multi-root debufferization"
+  fi
+  polygeist-opt --select-func=func-name="$FUNCTION" \
+    --remove-iter-args --affine-parallelize \
+    --raise-affine-to-linalg-pipeline \
+    --lower-polygeist-submap \
+    "${DEBUFFERIZE_PASS[@]}" \
+    $WORK/affine.mlir -o $WORK/linalg.mlir 2>$WORK/raise.err || {
+      echo "ERROR: raise pass failed; see $WORK/raise.err" >&2; cat $WORK/raise.err >&2; exit 1; }
+else
+  echo "  [2/9] polygeist-opt: raise + lower-submap (memref linalg)"
+  polygeist-opt --select-func=func-name="$FUNCTION" \
+    --remove-iter-args --affine-parallelize \
+    --raise-affine-to-linalg-pipeline \
+    --lower-polygeist-submap \
+    $WORK/affine.mlir -o $WORK/linalg.mlir 2>$WORK/raise.err || {
+      echo "ERROR: raise pass failed; see $WORK/raise.err" >&2; cat $WORK/raise.err >&2; exit 1; }
+fi
+
+# ─── Step 3: matcher (linalg.generic → kernel.launch) ───────────────────
+echo "  [3/9] matcher: linalg.generic → kernel.launch"
+MATCHER_ARGS=()
+if [ "${POLYGEIST_DISABLE_POINTWISE_MATCHING:-0}" != "0" ]; then
+  MATCHER_ARGS+=(--disable-pointwise-matching)
+  echo "         generic pointwise matching disabled"
+fi
+if [ "${POLYGEIST_DISABLE_LIBRARY_MATCHING:-0}" != "0" ]; then
+  cp $WORK/linalg.mlir $WORK/matched.mlir
+  : > $WORK/match.err
+  echo "         all library matching disabled; preserving residual Linalg"
+else
+  if [ -n "${POLYGEIST_MATCH_MAX_LAUNCHES:-}" ]; then
+    MATCHER_ARGS+=(--max-launches "${POLYGEIST_MATCH_MAX_LAUNCHES}")
+    echo "         limiting emitted launches to ${POLYGEIST_MATCH_MAX_LAUNCHES}"
+  fi
+  $PYTHON $SCRIPTS/kernel_match_rewrite.py \
+    "${MATCHER_ARGS[@]}" \
+    $WORK/linalg.mlir > $WORK/matched.mlir 2>$WORK/match.err
+fi
+N_LAUNCH=$(grep -c 'kernel\.launch' $WORK/matched.mlir || true)
+echo "         matched $N_LAUNCH kernel.launch op(s)"
+if [ "${N_LAUNCH:-0}" -eq 0 ]; then
+  echo "         no ABI-lowerable matches; continuing with residual Linalg"
+fi
+
+# ─── Step 4: inject canonical kernel.defn declarations ──────────────────
+# The matched MLIR references @cublasDgemm / @cudnnConvolution2D_9tap / etc.
+# but doesn't define them. The kernel.launch op's verifier needs the symbols
+# to exist. We pull all the kernel.defn entries from kernel_library_phase2.mlir
+# and inject them inside the matched module's attribute block. The lowering
+# pass dead-strips unused defns afterwards, so injecting all of them is safe
+# regardless of which one(s) the matcher emitted.
+echo "  [4/9] inject canonical defns from kernel_library_phase2.mlir"
+# Extract the kernel.defn blocks from the library (everything between the
+# outer module { ... }), strip the wrapping module line, and inject.
+DEFNS=$(sed -n '/^module {$/,/^}$/p' "$KERNEL_LIB" | sed '1d; $d')
+awk -v defns="$DEFNS" '
+  /^module attributes/ && !done { print; print defns; done=1; next }
+  { print }
+' $WORK/matched.mlir > $WORK/with_defns.mlir
+
+# ─── Step 5: ABI lowering kernel.launch → func.call to runtime shim ─────
+echo "  [5/9] polygeist-opt: lower-kernel-launch-to-cublas (kernel.launch → func.call)"
+if [ "${POLYGEIST_DEVICE_RESIDENT_ABI:-0}" != "0" ]; then
+  ABI_PASSES=(--lower-kernel-launch-to-cublas=device-resident-cutensornet=true)
+else
+  ABI_PASSES=(--lower-kernel-launch-to-cublas)
+fi
+WRAP_KERNEL_PIPELINE="${POLYGEIST_WRAP_KERNEL_PIPELINE:-}"
+if [ -z "$WRAP_KERNEL_PIPELINE" ]; then
+  if [ "$TARGET" = "jetson" ]; then WRAP_KERNEL_PIPELINE=1
+  else WRAP_KERNEL_PIPELINE=0
+  fi
+fi
+if [ "$WRAP_KERNEL_PIPELINE" != "0" ]; then
+  ABI_PASSES+=(--wrap-kernel-launch-pipeline)
+fi
+polygeist-opt "${ABI_PASSES[@]}" \
+  $WORK/with_defns.mlir -o $WORK/abi.mlir 2>$WORK/abi.err || {
+    echo "ERROR: ABI lowering failed; see $WORK/abi.err" >&2; cat $WORK/abi.err >&2; exit 1; }
+N_CALL=$(grep -cE 'call @polygeist_' $WORK/abi.mlir || true)
+echo "         emitted $N_CALL func.call to runtime shim"
+
+# ─── Step 6: lower to LLVM dialect + translate to LLVM IR ───────────────
+echo "  [6/9] mlir-opt → LLVM dialect → llvm-translate → kernel.ll"
+# ABI lowering can leave pure polygeist.submap/submapInverse view ops around,
+# especially when a matched launch consumed one view but the neighboring CPU
+# residual linalg still uses another. Clean those up with polygeist-opt before
+# handing the IR to upstream mlir-opt, which does not load the Polygeist dialect.
+# Run the targeted view cleanup before CSE.  Broad canonicalization here can
+# fold a rank-expanding tensor view through a residual DPS linalg.generic and
+# temporarily replace its ranked output operand with the flat base, producing
+# invalid IR.  LowerPolygeistSubmap handles identity views explicitly.
+# Do not CSE tensor.empty roots here.  Distinct C scratch allocas from
+# sequential inlined stages can canonicalize to one tensor.empty SSA value;
+# one-shot bufferization may then select the same physical buffer for results
+# that are simultaneously live.  View lowering does not require CSE.
+polygeist-opt --lower-polygeist-submap \
+  $WORK/abi.mlir -o $WORK/abi_canon.mlir 2>>$WORK/abi.err || {
+    echo "ERROR: polygeist submap cleanup failed; see $WORK/abi.err" >&2
+    cat $WORK/abi.err >&2
+    exit 1
+  }
+# Mark to_tensor results restrict so one-shot-bufferize keeps in-place semantics.
+sed -i 's|bufferization\.to_tensor \(%[^ ]*\) :|bufferization.to_tensor \1 restrict :|g' \
+  $WORK/abi_canon.mlir
+$MLIR_OPT --convert-math-to-llvm \
+  --empty-tensor-to-alloc-tensor \
+  --lower-affine \
+  --one-shot-bufferize=bufferize-function-boundaries \
+  --convert-linalg-to-loops --convert-scf-to-cf \
+  --expand-strided-metadata \
+  --lower-affine \
+  --convert-arith-to-llvm --convert-index-to-llvm --finalize-memref-to-llvm \
+  --convert-func-to-llvm --reconcile-unrealized-casts \
+  $WORK/abi_canon.mlir -o $WORK/llvm.mlir 2>$WORK/mlir.err || {
+    echo "ERROR: mlir-opt lowering failed; see $WORK/mlir.err" >&2; cat $WORK/mlir.err >&2; exit 1; }
+$MLIR_TRANSLATE --mlir-to-llvmir $WORK/llvm.mlir -o $WORK/kernel.ll
+
+# Rename the lifted symbol to _impl so the harness's own C definition
+# of the same function name doesn't collide. The auto-generated wrapper
+# provides the public  entry that calls _impl with packed memrefs.
+sed -i "s/@${FUNCTION}\b/@${FUNCTION}_impl/g" $WORK/kernel.ll
+
+# Retarget the LLVM IR if we're cross-compiling. clang's --target flag will
+# also do most of this, but stripping the embedded x86 datalayout avoids
+# warnings and lets clang re-derive an aarch64 layout from --target.
+if [ "$TARGET" = "jetson" ]; then
+  sed -i 's|target triple = "x86_64.*"|target triple = "aarch64-linux-gnu"|' $WORK/kernel.ll
+  sed -i '/^target datalayout/d' $WORK/kernel.ll
+fi
+
+# ─── Step 7: generate the ABI wrapper for the kernel ────────────────────
+echo "  [7/9] gen_wrapper.py: ABI bridge for $FUNCTION"
+$PYTHON $SCRIPTS/gen_wrapper.py "$INPUT" "$FUNCTION" > $WORK/wrapper.c
+
+# ─── Step 8: per-target compile + harness prep ──────────────────────────
+echo "  [8/9] compile kernel.ll + wrapper + harness + runtime shim (target=$TARGET)"
+if [ "$TARGET" = "host" ]; then
+  CC=$CLANG
+  CLANG_TARGET_ARGS=""
+  RT_SRC=$RT/polygeist_cublas_rt_cpu.c
+  RT_LIBS="-lm -lpthread"
+  if [ "${POLYGEIST_CPU_BLAS:-0}" != "0" ]; then
+    RT_CFLAGS+=("-DPOLYGEIST_CPU_USE_CBLAS")
+    if [ -n "${POLYGEIST_CPU_BLAS_CFLAGS:-}" ]; then
+      read -r -a _CPU_BLAS_CFLAGS <<< "$POLYGEIST_CPU_BLAS_CFLAGS"
+      RT_CFLAGS+=("${_CPU_BLAS_CFLAGS[@]}")
+    fi
+    RT_LIBS="${POLYGEIST_CPU_BLAS_LIBS:--lopenblas} $RT_LIBS"
+    echo "         + optimized CPU CBLAS runtime enabled"
+  fi
+else
+  # aarch64-linux-gnu-gcc is already configured for aarch64 — no --target arg.
+  # Clang (used for kernel.ll → kernel.o only) does need --target=aarch64-linux-gnu.
+  CC=$AARCH64_CC
+  CLANG_TARGET_ARGS="--target=aarch64-linux-gnu --gcc-toolchain=/usr"
+  RT_SRC=$RT/polygeist_cublas_rt_cuda.c
+  RT_LIBS="-L$CUDA_CROSS/lib -L$CUDA_CROSS/lib/stubs -L$CUDNN_CROSS_LIB \
+           -lcudnn -lcublasLt -lcublas -lcufft -lcusparse -lcusolver \
+           -lcudart -lm -lpthread -ldl \
+           -Wl,-rpath,/usr/local/cuda/lib64:/usr/lib/aarch64-linux-gnu"
+  if [ "${POLYGEIST_MINIMAL_CUDA_RUNTIME:-0}" != "0" ]; then
+    RT_LIBS="-L$CUDA_CROSS/lib -L$CUDA_CROSS/lib/stubs \
+             -lcublas -lcudart -lm -lpthread -ldl \
+             -Wl,-rpath,/usr/local/cuda/lib64:/usr/lib/aarch64-linux-gnu"
+    echo "         + minimal cuBLAS/CUDA runtime linkage"
+  fi
+  if [ "${POLYGEIST_MINIMAL_CUDNN_RUNTIME:-0}" != "0" ]; then
+    RT_LIBS="-L$CUDA_CROSS/lib -L$CUDA_CROSS/lib/stubs \
+             -L/usr/lib/aarch64-linux-gnu \
+             -lcudnn -lcublasLt -lcublas -lcudart -lm -lpthread -ldl \
+             -Wl,-rpath,/usr/local/cuda/lib64:/usr/lib/aarch64-linux-gnu:/home/nvidia/polygeist_cuda_libs"
+    echo "         + minimal cuDNN/cuBLAS/CUDA runtime linkage"
+  fi
+  if [ -n "${POLYGEIST_CUTENSORNET_ROOT:-}" ]; then
+    CUTENSORNET_ROOT=$POLYGEIST_CUTENSORNET_ROOT
+    [ -f "$CUTENSORNET_ROOT/include/cutensornet.h" ] || {
+      echo "ERROR: $CUTENSORNET_ROOT/include/cutensornet.h not found" >&2
+      exit 1
+    }
+    RT_CFLAGS+=("-DPOLYGEIST_ENABLE_CUTENSORNET"
+               "-I$CUTENSORNET_ROOT/include")
+    RT_LIBS="-L$CUTENSORNET_ROOT/lib -lcutensornet -lcutensor $RT_LIBS"
+    echo "         + cuTensorNet runtime from $CUTENSORNET_ROOT"
+    if [ "${POLYGEIST_MINIMAL_CUTENSORNET_RUNTIME:-0}" != "0" ]; then
+      # With function-section GC, a contraction-only executable does not need
+      # the cuDNN/cuFFT/cuSPARSE portions of the shared runtime object.  Avoid
+      # recording those unrelated DSOs in DT_NEEDED; this is useful on lean
+      # Jetson installations that provide CUDA/cuBLAS but not every toolkit
+      # component.
+      RT_LIBS="-L$CUTENSORNET_ROOT/lib -lcutensornet -lcutensor \
+               -L$CUDA_CROSS/lib -L$CUDA_CROSS/lib/stubs \
+               -lcudnn -lcusolver -lcublasLt -lcublas -lcudart -lm -lpthread -ldl \
+               -Wl,-rpath,/usr/local/cuda/lib64:/usr/lib/aarch64-linux-gnu"
+      echo "         + contraction-only runtime linkage"
+    fi
+  fi
+fi
+
+# Kernel (lifted) — use Polygeist clang for both host and cross.
+$CLANG $CLANG_TARGET_ARGS -O3 -c $WORK/kernel.ll -o $WORK/kernel.o
+
+# Wrapper (ABI bridge generated by gen_wrapper.py).
+$CC -O2 "${GCC_PASSTHROUGH[@]}" -c $WORK/wrapper.c -o $WORK/wrapper.o
+
+# Harness compiled normally. If it is the original source and defines the
+# selected kernel, weaken that symbol so the lifted+matched wrapper wins.
+# Separate harness files only declare/call the kernel, so no weakening is
+# needed and the compiler cannot inline the original body into main.
+$CC -O0 -fno-inline -fno-inline-functions "${GCC_PASSTHROUGH[@]}" \
+  -c "$HARNESS_INPUT" -o $WORK/harness_full.o
+NM_TOOL=nm
+if [ "$TARGET" = "jetson" ] && command -v aarch64-linux-gnu-nm >/dev/null 2>&1; then
+  NM_TOOL=aarch64-linux-gnu-nm
+fi
+if $NM_TOOL $WORK/harness_full.o | awk '{print $3}' | grep -qx "$FUNCTION"; then
+  if [ "$TARGET" = "host" ]; then
+    objcopy --weaken-symbol="$FUNCTION" $WORK/harness_full.o $WORK/harness.o
+  else
+    aarch64-linux-gnu-objcopy --weaken-symbol="$FUNCTION" \
+      $WORK/harness_full.o $WORK/harness.o
+  fi
+else
+  cp $WORK/harness_full.o $WORK/harness.o
+fi
+
+# Runtime shim. For jetson target we also need cuda + cudnn headers.
+if [ "$TARGET" = "host" ]; then
+  $CC -O2 -ffunction-sections -fdata-sections "${RT_CFLAGS[@]}" \
+    -c $RT_SRC -o $WORK/rt.o
+  $CC -O2 -c $RT/polygeist_mlir_runner_utils.c -o $WORK/mlir_runner_utils.o
+else
+  $CC -O2 -ffunction-sections -fdata-sections "${RT_CFLAGS[@]}" \
+    -I$CUDA_CROSS/include -I$CUDNN_CROSS_INC \
+    -c $RT_SRC -o $WORK/rt.o
+  $CC -O2 -c $RT/polygeist_mlir_runner_utils.c -o $WORK/mlir_runner_utils.o
+fi
+
+# Polybench utility .c — only if the harness uses POLYBENCH macros and the
+# user provided -I to its include path. Detect via 'polybench.h' include.
+POLYBENCH_OBJS=()
+if grep -q '#include\s*\|#include\s*"polybench.h"' "$HARNESS_INPUT"; then
+  # Find polybench.c on the same -I path the harness was given.
+  POLYBENCH_C=""
+  for arg in "${GCC_PASSTHROUGH[@]}"; do
+    case "$arg" in
+      -I*)
+        dir=${arg#-I}
+        if [ -f "$dir/polybench.c" ]; then POLYBENCH_C="$dir/polybench.c"; break; fi ;;
+    esac
+  done
+  if [ -n "$POLYBENCH_C" ]; then
+    echo "         + polybench utility from $POLYBENCH_C"
+    $CC -O2 "${GCC_PASSTHROUGH[@]}" -c "$POLYBENCH_C" -o $WORK/polybench.o
+    POLYBENCH_OBJS=("$WORK/polybench.o")
+  fi
+fi
+
+CUSTOM_CUDA_OBJS=()
+CUSTOM_CUDA_OBJ_LIST="${POLYGEIST_CUSTOM_CUDA_OBJS:-${POLYGEIST_CUSTOM_CUDA_OBJ:-}}"
+if [ -n "$CUSTOM_CUDA_OBJ_LIST" ]; then
+  read -r -a CUSTOM_CUDA_OBJS <<< "$CUSTOM_CUDA_OBJ_LIST"
+  for obj in "${CUSTOM_CUDA_OBJS[@]}"; do
+    [ -f "$obj" ] || {
+      echo "ERROR: custom CUDA object $obj not found" >&2
+      exit 1
+    }
+  done
+  echo "         + custom CUDA object(s): ${CUSTOM_CUDA_OBJS[*]}"
+fi
+
+# ─── Step 9: link ───────────────────────────────────────────────────────
+echo "  [9/9] link → $OUT"
+$CC -O2 \
+  $WORK/kernel.o $WORK/wrapper.o $WORK/harness.o $WORK/rt.o \
+  $WORK/mlir_runner_utils.o \
+  "${POLYBENCH_OBJS[@]}" \
+  "${CUSTOM_CUDA_OBJS[@]}" \
+  $RT_LIBS \
+  -Wl,--gc-sections \
+  -o "$OUT"
+
+echo ""
+echo "═══ build complete ═══"
+file "$OUT" || true
diff --git a/scripts/correctness/pva_bilateral_jetson.sh b/scripts/correctness/pva_bilateral_jetson.sh
new file mode 100755
index 000000000000..5f2386aae03e
--- /dev/null
+++ b/scripts/correctness/pva_bilateral_jetson.sh
@@ -0,0 +1,125 @@
+#!/bin/bash
+# pva_bilateral_jetson.sh — end-to-end test of the OpBilateralFilter PVA path.
+# Skips the matcher (which doesn't yet emit pvaBilateralFilter_*) and hand-
+# authors the kernel.launch directly, then runs the same lowering +
+# cross-compile + Jetson silicon validation pipeline as the conv2d tests.
+#
+# Usage: ./pva_bilateral_jetson.sh  [SIZE]
+#   : i8 | i16
+#   [SIZE]:  default 256
+#
+# Output: /tmp/pva_bilateral__/{bilateral_jetson, bilateral_jetson_cpustub}
+
+set -euo pipefail
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+DTYPE=${1:?"missing DTYPE arg (i8|i16)"}
+SIZE=${2:-256}
+SCRIPTS=$REPO_ROOT/scripts/correctness
+RT=$REPO_ROOT/runtime
+OUT=/tmp/pva_bilateral_${DTYPE}_${SIZE}
+mkdir -p $OUT
+CUDA=/usr/local/cuda-12.6/targets/sbsa-linux
+
+case "$DTYPE" in
+  i8)  MTY=i8;  CTY=int8_t;  ;;
+  i16) MTY=i16; CTY=int16_t; ;;
+  *) echo "unknown dtype: $DTYPE"; exit 1;;
+esac
+
+echo "[bilateral/$DTYPE/$SIZE] (1) author kernel.launch MLIR by hand"
+cat > $OUT/synth.mlir <>,
+      %b: memref>) {
+    kernel.yield
+  }
+  func.func @kernel_conv2d(%ni: i32, %nj: i32,
+                            %A: memref,
+                            %B: memref)
+      attributes {llvm.linkage = #llvm.linkage} {
+    %c2 = arith.constant 2 : index
+    %ni_idx = arith.index_cast %ni : i32 to index
+    %nj_idx = arith.index_cast %nj : i32 to index
+    %m2 = arith.subi %ni_idx, %c2 : index
+    %n2 = arith.subi %nj_idx, %c2 : index
+    %Av = memref.subview %A[0, 0] [%m2, %n2] [1, 1]
+        : memref to memref>
+    %Bv = memref.subview %B[1, 1] [%m2, %n2] [1, 1]
+        : memref to memref>
+    %Ac = memref.cast %Av
+        : memref>
+       to memref>
+    %Bc = memref.cast %Bv
+        : memref>
+       to memref>
+    kernel.launch @pvaBilateralFilter_3x3_${DTYPE}(%Ac, %Bc)
+        : (memref>,
+           memref>) -> ()
+    return
+  }
+}
+EOF
+
+echo "[bilateral/$DTYPE/$SIZE] (2) lower-kernel-launch-to-pva"
+polygeist-opt --lower-kernel-launch-to-pva $OUT/synth.mlir -o $OUT/abi.mlir 2>$OUT/abi.err
+
+echo "[bilateral/$DTYPE/$SIZE] (3) lower to LLVM, translate, retarget aarch64"
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+MLIR_TRANSLATE=$REPO_ROOT/llvm-project/build/bin/mlir-translate
+CLANG=$REPO_ROOT/llvm-project/build/bin/clang
+$MLIR_OPT --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \
+    --expand-strided-metadata \
+    --convert-arith-to-llvm --finalize-memref-to-llvm \
+    --convert-func-to-llvm --reconcile-unrealized-casts \
+    $OUT/abi.mlir -o $OUT/llvm.mlir 2>$OUT/mlir.err
+$MLIR_TRANSLATE --mlir-to-llvmir $OUT/llvm.mlir -o $OUT/kernel.ll
+sed -i 's|target triple = "x86_64.*"|target triple = "aarch64-linux-gnu"|;
+        /^target datalayout/d;
+        s/@kernel_conv2d\b/@kernel_conv2d_impl/g' $OUT/kernel.ll
+$CLANG --target=aarch64-linux-gnu --gcc-toolchain=/usr \
+    -O3 -c $OUT/kernel.ll -o $OUT/kernel.o 2>&1 | tail -1
+
+echo "[bilateral/$DTYPE/$SIZE] (4) cross-compile harness + wrapper + runtimes"
+ARCH_FLAGS="-march=armv8.2-a+fp16+bf16"
+KIND_DEF="-DCTYPE_KIND_INT"
+DEFS="-DNI=$SIZE -DNJ=$SIZE -DCTYPE=$CTY $KIND_DEF"
+PVASOL_INC=${PVASOL_INC:-$PVASOL_ROOT/public/src/operator/include}
+NVCV_INC=${NVCV_INC:-$CV_CUDA_ROOT/src/nvcv/src/include}
+CUPVA_INC=${CUPVA_INC:-$CUPVA_SDK_ROOT/include}
+PVA_LIB_STAGE=${PVA_LIB_STAGE:-$HOME/pva_libs}
+JET_PVA_LIB=/tmp/pva_libs
+
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS $DEFS -c $SCRIPTS/conv2d_main_harness_dtype.c -o $OUT/main.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -DCTYPE=$CTY -c $SCRIPTS/conv2d_jetson_wrapper_dtype.c -o $OUT/wrapper.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -c $RT/polygeist_cublas_rt_cpu.c -o $OUT/rt_cpu.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS \
+    -I$CUDA/include -I$PVASOL_INC -I$NVCV_INC -I$CUPVA_INC \
+    -c $RT/polygeist_pva_rt.c -o $OUT/rt_pva.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -I$CUDA/include -c $RT/polygeist_cublas_rt_cuda.c -o $OUT/rt_cuda.o
+
+echo "[bilateral/$DTYPE/$SIZE] (5) link PVA binary"
+PVA_LINK="-L$PVA_LIB_STAGE -lpva_operator -lcvcuda -lnvcv_types -lcupva_host \
+          -Wl,--no-as-needed \
+          -L$JETSON_NVIDIA_LIBS -lnvscibuf -lnvscisync \
+          -Wl,--as-needed"
+CUDNN_LIB=/usr/lib/aarch64-linux-gnu
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/main.o $OUT/wrapper.o $OUT/kernel.o $OUT/rt_cuda.o $OUT/rt_pva.o \
+    -L$CUDA/lib -L$CUDA/lib/stubs -L$CUDNN_LIB \
+    $PVA_LINK \
+    -lcudnn -lcublasLt -lcublas -lcudart -lm -lpthread -ldl -lstdc++ \
+    -Wl,--allow-shlib-undefined \
+    -Wl,-rpath,/usr/local/cuda/lib64:/usr/lib/aarch64-linux-gnu:/usr/lib/aarch64-linux-gnu/nvidia:${JET_PVA_LIB} \
+    -o $OUT/bilateral_jetson
+
+echo "[bilateral/$DTYPE/$SIZE] (6) link CPU-stub binary"
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/main.o $OUT/wrapper.o $OUT/kernel.o $OUT/rt_cpu.o \
+    -lm -lpthread -o $OUT/bilateral_jetson_cpustub
+
+echo ""
+echo "═══ boxfilter ${DTYPE} ${SIZE}×${SIZE} binaries ═══"
+ls -la $OUT/bilateral_jetson $OUT/bilateral_jetson_cpustub
diff --git a/scripts/correctness/pva_boxfilter_jetson.sh b/scripts/correctness/pva_boxfilter_jetson.sh
new file mode 100755
index 000000000000..86d58c2dae04
--- /dev/null
+++ b/scripts/correctness/pva_boxfilter_jetson.sh
@@ -0,0 +1,125 @@
+#!/bin/bash
+# pva_boxfilter_jetson.sh — end-to-end test of the OpBoxFilter PVA path.
+# Skips the matcher (which doesn't yet emit pvaBoxFilter_*) and hand-
+# authors the kernel.launch directly, then runs the same lowering +
+# cross-compile + Jetson silicon validation pipeline as the conv2d tests.
+#
+# Usage: ./pva_boxfilter_jetson.sh  [SIZE]
+#   : i8 | i16
+#   [SIZE]:  default 256
+#
+# Output: /tmp/pva_boxfilter__/{boxfilter_jetson, boxfilter_jetson_cpustub}
+
+set -euo pipefail
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+DTYPE=${1:?"missing DTYPE arg (i8|i16)"}
+SIZE=${2:-256}
+SCRIPTS=$REPO_ROOT/scripts/correctness
+RT=$REPO_ROOT/runtime
+OUT=/tmp/pva_boxfilter_${DTYPE}_${SIZE}
+mkdir -p $OUT
+CUDA=/usr/local/cuda-12.6/targets/sbsa-linux
+
+case "$DTYPE" in
+  i8)  MTY=i8;  CTY=int8_t;  ;;
+  i16) MTY=i16; CTY=int16_t; ;;
+  *) echo "unknown dtype: $DTYPE"; exit 1;;
+esac
+
+echo "[boxfilter/$DTYPE/$SIZE] (1) author kernel.launch MLIR by hand"
+cat > $OUT/synth.mlir <>,
+      %b: memref>) {
+    kernel.yield
+  }
+  func.func @kernel_conv2d(%ni: i32, %nj: i32,
+                            %A: memref,
+                            %B: memref)
+      attributes {llvm.linkage = #llvm.linkage} {
+    %c2 = arith.constant 2 : index
+    %ni_idx = arith.index_cast %ni : i32 to index
+    %nj_idx = arith.index_cast %nj : i32 to index
+    %m2 = arith.subi %ni_idx, %c2 : index
+    %n2 = arith.subi %nj_idx, %c2 : index
+    %Av = memref.subview %A[0, 0] [%m2, %n2] [1, 1]
+        : memref to memref>
+    %Bv = memref.subview %B[1, 1] [%m2, %n2] [1, 1]
+        : memref to memref>
+    %Ac = memref.cast %Av
+        : memref>
+       to memref>
+    %Bc = memref.cast %Bv
+        : memref>
+       to memref>
+    kernel.launch @pvaBoxFilter_3x3_${DTYPE}(%Ac, %Bc)
+        : (memref>,
+           memref>) -> ()
+    return
+  }
+}
+EOF
+
+echo "[boxfilter/$DTYPE/$SIZE] (2) lower-kernel-launch-to-pva"
+polygeist-opt --lower-kernel-launch-to-pva $OUT/synth.mlir -o $OUT/abi.mlir 2>$OUT/abi.err
+
+echo "[boxfilter/$DTYPE/$SIZE] (3) lower to LLVM, translate, retarget aarch64"
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+MLIR_TRANSLATE=$REPO_ROOT/llvm-project/build/bin/mlir-translate
+CLANG=$REPO_ROOT/llvm-project/build/bin/clang
+$MLIR_OPT --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \
+    --expand-strided-metadata \
+    --convert-arith-to-llvm --finalize-memref-to-llvm \
+    --convert-func-to-llvm --reconcile-unrealized-casts \
+    $OUT/abi.mlir -o $OUT/llvm.mlir 2>$OUT/mlir.err
+$MLIR_TRANSLATE --mlir-to-llvmir $OUT/llvm.mlir -o $OUT/kernel.ll
+sed -i 's|target triple = "x86_64.*"|target triple = "aarch64-linux-gnu"|;
+        /^target datalayout/d;
+        s/@kernel_conv2d\b/@kernel_conv2d_impl/g' $OUT/kernel.ll
+$CLANG --target=aarch64-linux-gnu --gcc-toolchain=/usr \
+    -O3 -c $OUT/kernel.ll -o $OUT/kernel.o 2>&1 | tail -1
+
+echo "[boxfilter/$DTYPE/$SIZE] (4) cross-compile harness + wrapper + runtimes"
+ARCH_FLAGS="-march=armv8.2-a+fp16+bf16"
+KIND_DEF="-DCTYPE_KIND_INT"
+DEFS="-DNI=$SIZE -DNJ=$SIZE -DCTYPE=$CTY $KIND_DEF"
+PVASOL_INC=${PVASOL_INC:-$PVASOL_ROOT/public/src/operator/include}
+NVCV_INC=${NVCV_INC:-$CV_CUDA_ROOT/src/nvcv/src/include}
+CUPVA_INC=${CUPVA_INC:-$CUPVA_SDK_ROOT/include}
+PVA_LIB_STAGE=${PVA_LIB_STAGE:-$HOME/pva_libs}
+JET_PVA_LIB=/tmp/pva_libs
+
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS $DEFS -c $SCRIPTS/conv2d_main_harness_dtype.c -o $OUT/main.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -DCTYPE=$CTY -c $SCRIPTS/conv2d_jetson_wrapper_dtype.c -o $OUT/wrapper.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -c $RT/polygeist_cublas_rt_cpu.c -o $OUT/rt_cpu.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS \
+    -I$CUDA/include -I$PVASOL_INC -I$NVCV_INC -I$CUPVA_INC \
+    -c $RT/polygeist_pva_rt.c -o $OUT/rt_pva.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -I$CUDA/include -c $RT/polygeist_cublas_rt_cuda.c -o $OUT/rt_cuda.o
+
+echo "[boxfilter/$DTYPE/$SIZE] (5) link PVA binary"
+PVA_LINK="-L$PVA_LIB_STAGE -lpva_operator -lcvcuda -lnvcv_types -lcupva_host \
+          -Wl,--no-as-needed \
+          -L$JETSON_NVIDIA_LIBS -lnvscibuf -lnvscisync \
+          -Wl,--as-needed"
+CUDNN_LIB=/usr/lib/aarch64-linux-gnu
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/main.o $OUT/wrapper.o $OUT/kernel.o $OUT/rt_cuda.o $OUT/rt_pva.o \
+    -L$CUDA/lib -L$CUDA/lib/stubs -L$CUDNN_LIB \
+    $PVA_LINK \
+    -lcudnn -lcublasLt -lcublas -lcudart -lm -lpthread -ldl -lstdc++ \
+    -Wl,--allow-shlib-undefined \
+    -Wl,-rpath,/usr/local/cuda/lib64:/usr/lib/aarch64-linux-gnu:/usr/lib/aarch64-linux-gnu/nvidia:${JET_PVA_LIB} \
+    -o $OUT/boxfilter_jetson
+
+echo "[boxfilter/$DTYPE/$SIZE] (6) link CPU-stub binary"
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/main.o $OUT/wrapper.o $OUT/kernel.o $OUT/rt_cpu.o \
+    -lm -lpthread -o $OUT/boxfilter_jetson_cpustub
+
+echo ""
+echo "═══ boxfilter ${DTYPE} ${SIZE}×${SIZE} binaries ═══"
+ls -la $OUT/boxfilter_jetson $OUT/boxfilter_jetson_cpustub
diff --git a/scripts/correctness/pva_gaussian_jetson.sh b/scripts/correctness/pva_gaussian_jetson.sh
new file mode 100755
index 000000000000..c9c6bde28def
--- /dev/null
+++ b/scripts/correctness/pva_gaussian_jetson.sh
@@ -0,0 +1,125 @@
+#!/bin/bash
+# pva_gaussian_jetson.sh — end-to-end test of the OpGaussianFilter PVA path.
+# Skips the matcher (which doesn't yet emit pvaGaussianFilter_*) and hand-
+# authors the kernel.launch directly, then runs the same lowering +
+# cross-compile + Jetson silicon validation pipeline as the conv2d tests.
+#
+# Usage: ./pva_gaussian_jetson.sh  [SIZE]
+#   : i8 | i16
+#   [SIZE]:  default 256
+#
+# Output: /tmp/pva_gaussian__/{gaussian_jetson, gaussian_jetson_cpustub}
+
+set -euo pipefail
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+DTYPE=${1:?"missing DTYPE arg (i8|i16)"}
+SIZE=${2:-256}
+SCRIPTS=$REPO_ROOT/scripts/correctness
+RT=$REPO_ROOT/runtime
+OUT=/tmp/pva_gaussian_${DTYPE}_${SIZE}
+mkdir -p $OUT
+CUDA=/usr/local/cuda-12.6/targets/sbsa-linux
+
+case "$DTYPE" in
+  i8)  MTY=i8;  CTY=int8_t;  ;;
+  i16) MTY=i16; CTY=int16_t; ;;
+  *) echo "unknown dtype: $DTYPE"; exit 1;;
+esac
+
+echo "[gaussian/$DTYPE/$SIZE] (1) author kernel.launch MLIR by hand"
+cat > $OUT/synth.mlir <>,
+      %b: memref>) {
+    kernel.yield
+  }
+  func.func @kernel_conv2d(%ni: i32, %nj: i32,
+                            %A: memref,
+                            %B: memref)
+      attributes {llvm.linkage = #llvm.linkage} {
+    %c2 = arith.constant 2 : index
+    %ni_idx = arith.index_cast %ni : i32 to index
+    %nj_idx = arith.index_cast %nj : i32 to index
+    %m2 = arith.subi %ni_idx, %c2 : index
+    %n2 = arith.subi %nj_idx, %c2 : index
+    %Av = memref.subview %A[0, 0] [%m2, %n2] [1, 1]
+        : memref to memref>
+    %Bv = memref.subview %B[1, 1] [%m2, %n2] [1, 1]
+        : memref to memref>
+    %Ac = memref.cast %Av
+        : memref>
+       to memref>
+    %Bc = memref.cast %Bv
+        : memref>
+       to memref>
+    kernel.launch @pvaGaussianFilter_3x3_${DTYPE}(%Ac, %Bc)
+        : (memref>,
+           memref>) -> ()
+    return
+  }
+}
+EOF
+
+echo "[gaussian/$DTYPE/$SIZE] (2) lower-kernel-launch-to-pva"
+polygeist-opt --lower-kernel-launch-to-pva $OUT/synth.mlir -o $OUT/abi.mlir 2>$OUT/abi.err
+
+echo "[gaussian/$DTYPE/$SIZE] (3) lower to LLVM, translate, retarget aarch64"
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+MLIR_TRANSLATE=$REPO_ROOT/llvm-project/build/bin/mlir-translate
+CLANG=$REPO_ROOT/llvm-project/build/bin/clang
+$MLIR_OPT --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \
+    --expand-strided-metadata \
+    --convert-arith-to-llvm --finalize-memref-to-llvm \
+    --convert-func-to-llvm --reconcile-unrealized-casts \
+    $OUT/abi.mlir -o $OUT/llvm.mlir 2>$OUT/mlir.err
+$MLIR_TRANSLATE --mlir-to-llvmir $OUT/llvm.mlir -o $OUT/kernel.ll
+sed -i 's|target triple = "x86_64.*"|target triple = "aarch64-linux-gnu"|;
+        /^target datalayout/d;
+        s/@kernel_conv2d\b/@kernel_conv2d_impl/g' $OUT/kernel.ll
+$CLANG --target=aarch64-linux-gnu --gcc-toolchain=/usr \
+    -O3 -c $OUT/kernel.ll -o $OUT/kernel.o 2>&1 | tail -1
+
+echo "[gaussian/$DTYPE/$SIZE] (4) cross-compile harness + wrapper + runtimes"
+ARCH_FLAGS="-march=armv8.2-a+fp16+bf16"
+KIND_DEF="-DCTYPE_KIND_INT"
+DEFS="-DNI=$SIZE -DNJ=$SIZE -DCTYPE=$CTY $KIND_DEF"
+PVASOL_INC=${PVASOL_INC:-$PVASOL_ROOT/public/src/operator/include}
+NVCV_INC=${NVCV_INC:-$CV_CUDA_ROOT/src/nvcv/src/include}
+CUPVA_INC=${CUPVA_INC:-$CUPVA_SDK_ROOT/include}
+PVA_LIB_STAGE=${PVA_LIB_STAGE:-$HOME/pva_libs}
+JET_PVA_LIB=/tmp/pva_libs
+
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS $DEFS -c $SCRIPTS/conv2d_main_harness_dtype.c -o $OUT/main.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -DCTYPE=$CTY -c $SCRIPTS/conv2d_jetson_wrapper_dtype.c -o $OUT/wrapper.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -c $RT/polygeist_cublas_rt_cpu.c -o $OUT/rt_cpu.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS \
+    -I$CUDA/include -I$PVASOL_INC -I$NVCV_INC -I$CUPVA_INC \
+    -c $RT/polygeist_pva_rt.c -o $OUT/rt_pva.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -I$CUDA/include -c $RT/polygeist_cublas_rt_cuda.c -o $OUT/rt_cuda.o
+
+echo "[gaussian/$DTYPE/$SIZE] (5) link PVA binary"
+PVA_LINK="-L$PVA_LIB_STAGE -lpva_operator -lcvcuda -lnvcv_types -lcupva_host \
+          -Wl,--no-as-needed \
+          -L$JETSON_NVIDIA_LIBS -lnvscibuf -lnvscisync \
+          -Wl,--as-needed"
+CUDNN_LIB=/usr/lib/aarch64-linux-gnu
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/main.o $OUT/wrapper.o $OUT/kernel.o $OUT/rt_cuda.o $OUT/rt_pva.o \
+    -L$CUDA/lib -L$CUDA/lib/stubs -L$CUDNN_LIB \
+    $PVA_LINK \
+    -lcudnn -lcublasLt -lcublas -lcudart -lm -lpthread -ldl -lstdc++ \
+    -Wl,--allow-shlib-undefined \
+    -Wl,-rpath,/usr/local/cuda/lib64:/usr/lib/aarch64-linux-gnu:/usr/lib/aarch64-linux-gnu/nvidia:${JET_PVA_LIB} \
+    -o $OUT/gaussian_jetson
+
+echo "[gaussian/$DTYPE/$SIZE] (6) link CPU-stub binary"
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/main.o $OUT/wrapper.o $OUT/kernel.o $OUT/rt_cpu.o \
+    -lm -lpthread -o $OUT/gaussian_jetson_cpustub
+
+echo ""
+echo "═══ boxfilter ${DTYPE} ${SIZE}×${SIZE} binaries ═══"
+ls -la $OUT/gaussian_jetson $OUT/gaussian_jetson_cpustub
diff --git a/scripts/correctness/pva_histeq_jetson.sh b/scripts/correctness/pva_histeq_jetson.sh
new file mode 100755
index 000000000000..0bd4d9389622
--- /dev/null
+++ b/scripts/correctness/pva_histeq_jetson.sh
@@ -0,0 +1,125 @@
+#!/bin/bash
+# pva_histeq_jetson.sh — end-to-end test of the OpHistogramEqualization PVA path.
+# Skips the matcher (which doesn't yet emit pvaHistogramEqualization_*) and hand-
+# authors the kernel.launch directly, then runs the same lowering +
+# cross-compile + Jetson silicon validation pipeline as the conv2d tests.
+#
+# Usage: ./pva_histeq_jetson.sh  [SIZE]
+#   : i8 | i16
+#   [SIZE]:  default 256
+#
+# Output: /tmp/pva_histeq__/{histeq_jetson, histeq_jetson_cpustub}
+
+set -euo pipefail
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+DTYPE=${1:?"missing DTYPE arg (i8|i16)"}
+SIZE=${2:-256}
+SCRIPTS=$REPO_ROOT/scripts/correctness
+RT=$REPO_ROOT/runtime
+OUT=/tmp/pva_histeq_${DTYPE}_${SIZE}
+mkdir -p $OUT
+CUDA=/usr/local/cuda-12.6/targets/sbsa-linux
+
+case "$DTYPE" in
+  i8)  MTY=i8;  CTY=int8_t;  ;;
+  i16) MTY=i16; CTY=int16_t; ;;
+  *) echo "unknown dtype: $DTYPE"; exit 1;;
+esac
+
+echo "[histeq/$DTYPE/$SIZE] (1) author kernel.launch MLIR by hand"
+cat > $OUT/synth.mlir <>,
+      %b: memref>) {
+    kernel.yield
+  }
+  func.func @kernel_conv2d(%ni: i32, %nj: i32,
+                            %A: memref,
+                            %B: memref)
+      attributes {llvm.linkage = #llvm.linkage} {
+    %c2 = arith.constant 2 : index
+    %ni_idx = arith.index_cast %ni : i32 to index
+    %nj_idx = arith.index_cast %nj : i32 to index
+    %m2 = arith.subi %ni_idx, %c2 : index
+    %n2 = arith.subi %nj_idx, %c2 : index
+    %Av = memref.subview %A[0, 0] [%m2, %n2] [1, 1]
+        : memref to memref>
+    %Bv = memref.subview %B[1, 1] [%m2, %n2] [1, 1]
+        : memref to memref>
+    %Ac = memref.cast %Av
+        : memref>
+       to memref>
+    %Bc = memref.cast %Bv
+        : memref>
+       to memref>
+    kernel.launch @pvaHistogramEqualization_${DTYPE}(%Ac, %Bc)
+        : (memref>,
+           memref>) -> ()
+    return
+  }
+}
+EOF
+
+echo "[histeq/$DTYPE/$SIZE] (2) lower-kernel-launch-to-pva"
+polygeist-opt --lower-kernel-launch-to-pva $OUT/synth.mlir -o $OUT/abi.mlir 2>$OUT/abi.err
+
+echo "[histeq/$DTYPE/$SIZE] (3) lower to LLVM, translate, retarget aarch64"
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+MLIR_TRANSLATE=$REPO_ROOT/llvm-project/build/bin/mlir-translate
+CLANG=$REPO_ROOT/llvm-project/build/bin/clang
+$MLIR_OPT --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \
+    --expand-strided-metadata \
+    --convert-arith-to-llvm --finalize-memref-to-llvm \
+    --convert-func-to-llvm --reconcile-unrealized-casts \
+    $OUT/abi.mlir -o $OUT/llvm.mlir 2>$OUT/mlir.err
+$MLIR_TRANSLATE --mlir-to-llvmir $OUT/llvm.mlir -o $OUT/kernel.ll
+sed -i 's|target triple = "x86_64.*"|target triple = "aarch64-linux-gnu"|;
+        /^target datalayout/d;
+        s/@kernel_conv2d\b/@kernel_conv2d_impl/g' $OUT/kernel.ll
+$CLANG --target=aarch64-linux-gnu --gcc-toolchain=/usr \
+    -O3 -c $OUT/kernel.ll -o $OUT/kernel.o 2>&1 | tail -1
+
+echo "[histeq/$DTYPE/$SIZE] (4) cross-compile harness + wrapper + runtimes"
+ARCH_FLAGS="-march=armv8.2-a+fp16+bf16"
+KIND_DEF="-DCTYPE_KIND_INT"
+DEFS="-DNI=$SIZE -DNJ=$SIZE -DCTYPE=$CTY $KIND_DEF"
+PVASOL_INC=${PVASOL_INC:-$PVASOL_ROOT/public/src/operator/include}
+NVCV_INC=${NVCV_INC:-$CV_CUDA_ROOT/src/nvcv/src/include}
+CUPVA_INC=${CUPVA_INC:-$CUPVA_SDK_ROOT/include}
+PVA_LIB_STAGE=${PVA_LIB_STAGE:-$HOME/pva_libs}
+JET_PVA_LIB=/tmp/pva_libs
+
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS $DEFS -c $SCRIPTS/conv2d_main_harness_dtype.c -o $OUT/main.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -DCTYPE=$CTY -c $SCRIPTS/conv2d_jetson_wrapper_dtype.c -o $OUT/wrapper.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -c $RT/polygeist_cublas_rt_cpu.c -o $OUT/rt_cpu.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS \
+    -I$CUDA/include -I$PVASOL_INC -I$NVCV_INC -I$CUPVA_INC \
+    -c $RT/polygeist_pva_rt.c -o $OUT/rt_pva.o
+aarch64-linux-gnu-gcc -O3 $ARCH_FLAGS -I$CUDA/include -c $RT/polygeist_cublas_rt_cuda.c -o $OUT/rt_cuda.o
+
+echo "[histeq/$DTYPE/$SIZE] (5) link PVA binary"
+PVA_LINK="-L$PVA_LIB_STAGE -lpva_operator -lcvcuda -lnvcv_types -lcupva_host \
+          -Wl,--no-as-needed \
+          -L$JETSON_NVIDIA_LIBS -lnvscibuf -lnvscisync \
+          -Wl,--as-needed"
+CUDNN_LIB=/usr/lib/aarch64-linux-gnu
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/main.o $OUT/wrapper.o $OUT/kernel.o $OUT/rt_cuda.o $OUT/rt_pva.o \
+    -L$CUDA/lib -L$CUDA/lib/stubs -L$CUDNN_LIB \
+    $PVA_LINK \
+    -lcudnn -lcublasLt -lcublas -lcudart -lm -lpthread -ldl -lstdc++ \
+    -Wl,--allow-shlib-undefined \
+    -Wl,-rpath,/usr/local/cuda/lib64:/usr/lib/aarch64-linux-gnu:/usr/lib/aarch64-linux-gnu/nvidia:${JET_PVA_LIB} \
+    -o $OUT/histeq_jetson
+
+echo "[histeq/$DTYPE/$SIZE] (6) link CPU-stub binary"
+aarch64-linux-gnu-gcc -O2 \
+    $OUT/main.o $OUT/wrapper.o $OUT/kernel.o $OUT/rt_cpu.o \
+    -lm -lpthread -o $OUT/histeq_jetson_cpustub
+
+echo ""
+echo "═══ boxfilter ${DTYPE} ${SIZE}×${SIZE} binaries ═══"
+ls -la $OUT/histeq_jetson $OUT/histeq_jetson_cpustub
diff --git a/scripts/correctness/run_all_e2e.sh b/scripts/correctness/run_all_e2e.sh
new file mode 100755
index 000000000000..1c42d671df3b
--- /dev/null
+++ b/scripts/correctness/run_all_e2e.sh
@@ -0,0 +1,54 @@
+#!/bin/bash
+# Run e2e for every PolyBench kernel that lowers clean through our pass.
+# Reports PASS / FAIL_ for each.
+set +e
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+
+SCRIPT=$REPO_ROOT/scripts/correctness/run_kernel_e2e.sh
+PB=$REPO_ROOT/tools/cgeist/Test/polybench
+MODE="${1:-}"   # "" or "--debuf"
+
+# (relative_dir, kernel_short_name) for the 17 lowering-clean kernels.
+declare -a KERNELS=(
+  "linear-algebra/blas/gemm gemm"
+  "linear-algebra/blas/syr2k syr2k"
+  "linear-algebra/blas/syrk syrk"
+  "linear-algebra/blas/gesummv gesummv"
+  "linear-algebra/blas/gemver gemver"
+  "linear-algebra/blas/symm symm"
+  "linear-algebra/blas/trmm trmm"
+  "linear-algebra/kernels/bicg bicg"
+  "linear-algebra/kernels/atax atax"
+  "linear-algebra/kernels/mvt mvt"
+  "linear-algebra/kernels/2mm 2mm"
+  "linear-algebra/kernels/3mm 3mm"
+  "linear-algebra/kernels/doitgen doitgen"
+  "linear-algebra/solvers/cholesky cholesky"
+  "linear-algebra/solvers/gramschmidt gramschmidt"
+  "linear-algebra/solvers/lu lu"
+  "linear-algebra/solvers/trisolv trisolv"
+  "stencils/heat-3d heat-3d"
+  "stencils/jacobi-2d jacobi-2d"
+  "stencils/jacobi-1d jacobi-1d"
+  "stencils/fdtd-2d fdtd-2d"
+  "medley/floyd-warshall floyd-warshall"
+  "medley/deriche deriche"
+  "medley/nussinov nussinov"
+  "datamining/correlation correlation"
+  "datamining/covariance covariance"
+)
+
+pass=0
+fail=0
+for entry in "${KERNELS[@]}"; do
+  read -r reldir short <<< "$entry"
+  # Grab the first PASS/FAIL/PARTIAL marker emitted by the per-kernel
+  # script (those are followed by diff context that 'tail -1' would catch).
+  out=$($SCRIPT "$PB/$reldir" "$short" $MODE 2>&1 | grep -E "PASS|FAIL|PARTIAL|MISSING" | head -1)
+  [ -z "$out" ] && out="$short: NO_RESULT"
+  echo "$out"
+  if [[ "$out" == *PASS* ]]; then pass=$((pass+1)); else fail=$((fail+1)); fi
+done
+echo "---"
+echo "Total: $pass pass, $fail fail"
diff --git a/scripts/correctness/run_kernel_e2e.sh b/scripts/correctness/run_kernel_e2e.sh
new file mode 100755
index 000000000000..cfd70c360649
--- /dev/null
+++ b/scripts/correctness/run_kernel_e2e.sh
@@ -0,0 +1,191 @@
+#!/bin/bash
+# Run an end-to-end correctness test for one PolyBench kernel.
+#
+# Usage:
+#   run_kernel_e2e.sh   [--debuf] [--match]
+#
+# Example:
+#   run_kernel_e2e.sh tools/cgeist/Test/polybench/linear-algebra/blas/gemm gemm
+#   run_kernel_e2e.sh ... gemm --debuf       # also run --linalg-debufferize
+#   run_kernel_e2e.sh ... gemm --debuf --match  # also exercise the
+#                                              # kernel.launch round-trip
+#                                              # (kernel_match_rewrite.py +
+#                                              # kernel_launch_lower.py)
+#
+# Returns 0 on PASS, non-zero on any failure or output mismatch.
+set -e
+_CORRECTNESS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$_CORRECTNESS_DIR/common_env.sh"
+MLIR_OPT=$REPO_ROOT/llvm-project/build/bin/mlir-opt
+MLIR_TRANSLATE=$REPO_ROOT/llvm-project/build/bin/mlir-translate
+CLANG=$REPO_ROOT/llvm-project/build/bin/clang
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+if [ $# -lt 2 ]; then
+  sed -n '3,12p' "$0" >&2
+  exit 1
+fi
+KERNEL_DIR="$1"
+KERNEL="$2"   # short name, e.g. "gemm", "mvt"
+DEBUF=""
+MATCH=""
+MATCH_CANONICAL=""
+MULTIROOT=""
+for arg in "${@:3}"; do
+  [ "$arg" = "--debuf" ] && DEBUF=1
+  [ "$arg" = "--match" ] && { DEBUF=1; MATCH=1; }
+  [ "$arg" = "--match-canonical" ] && { DEBUF=1; MATCH_CANONICAL=1; }
+  [ "$arg" = "--multi-root" ] && { DEBUF=1; MULTIROOT=1; }
+done
+
+# PolyBench source files: /.c. Kernel function is
+# `kernel_` with hyphens replaced by underscores (heat-3d → kernel_heat_3d).
+SRC="$KERNEL_DIR/${KERNEL}.c"
+FN="kernel_${KERNEL//-/_}"
+
+if [ ! -f "$SRC" ]; then echo "MISSING: $SRC"; exit 2; fi
+
+POLYBENCH_DIR=$REPO_ROOT/tools/cgeist/Test/polybench
+UTIL=$POLYBENCH_DIR/utilities
+
+TAG="$KERNEL"
+[ -n "$DEBUF" ] && TAG="${KERNEL}_debuf"
+[ -n "$MATCH" ] && TAG="${KERNEL}_match"
+[ -n "$MATCH_CANONICAL" ] && TAG="${KERNEL}_p2"
+[ -n "$MULTIROOT" ] && TAG="${TAG}_mr"
+OUT=/tmp/e2e_${TAG}
+mkdir -p $OUT
+
+DATASET=-DMINI_DATASET
+CFLAGS="-O1 -I$UTIL -I$KERNEL_DIR -DDATA_TYPE_IS_DOUBLE -DPOLYBENCH_DUMP_ARRAYS $DATASET"
+DYN_FLAGS="-Dstatic= -DPOLYBENCH_USE_C99_PROTO"
+
+# Pipeline ordering: lower-polygeist-submap BEFORE --linalg-debufferize so
+# debuferize sees only standard MLIR.
+PIPELINE_OPTS=(
+  --select-func=func-name=$FN
+  --remove-iter-args --affine-parallelize
+  --raise-affine-to-linalg-pipeline
+  --lower-polygeist-submap
+)
+if [ -n "$DEBUF" ]; then
+  if [ -n "$MULTIROOT" ]; then
+    PIPELINE_OPTS+=('--linalg-debufferize=use-multi-root=true')
+  else
+    PIPELINE_OPTS+=(--linalg-debufferize)
+  fi
+fi
+
+# Step 1: build the reference exe.
+$CLANG $CFLAGS $DYN_FLAGS $SRC $UTIL/polybench.c -lm -o $OUT/ref_exe 2>$OUT/ref_compile.err
+
+# Step 2: cgeist gemm.c -> MLIR.
+cgeist "$SRC" --function=$FN --resource-dir=/usr/lib/clang/14 \
+  $CFLAGS $DYN_FLAGS --raise-scf-to-affine -S -o $OUT/orig.mlir 2>$OUT/cgeist.err
+
+# Step 3: raise + lower-polygeist-submap (+ optional debuferize).
+polygeist-opt "${PIPELINE_OPTS[@]}" $OUT/orig.mlir -o $OUT/std.mlir 2>$OUT/raise.err
+
+# Bail if any polygeist ops survive.
+if grep -qE "polygeist\.(submap|submapInverse)" $OUT/std.mlir; then
+  echo "$TAG: PARTIAL_LOWER (polygeist ops remain)"
+  exit 3
+fi
+
+# Optional: run the kernel matcher + reverse lowering. The matcher rewrites
+# recognised linalg.generic spans to kernel.launch (with markers stashing the
+# original); the lowerer restores it. End result must be bit-exact to the
+# input for the round-trip to be correctness-preserving.
+if [ -n "$MATCH" ]; then
+  PY=$PYTHON
+  SCRIPTS=$REPO_ROOT/scripts/correctness
+  $PY $SCRIPTS/kernel_match_rewrite.py --with-roundtrip-markers \
+    $OUT/std.mlir > $OUT/matched.mlir 2>$OUT/match.err
+  N_LAUNCH=$(grep -c '= kernel\.launch ' $OUT/matched.mlir 2>/dev/null || echo 0)
+  N_MARK=$(grep -c '// POLYGEIST-MATCH-BEGIN-' $OUT/matched.mlir 2>/dev/null || echo 0)
+  $PY $SCRIPTS/kernel_launch_lower.py $OUT/matched.mlir \
+    -o $OUT/std.mlir 2>$OUT/lower.err
+  # Note: $OUT/std.mlir is now the restored IR. If matcher had no matches,
+  # std.mlir is unchanged. If it matched, restoration is bit-exact (asserted
+  # implicitly by the downstream parse + execute + diff).
+  echo "$TAG: kernel-match emitted $N_LAUNCH kernel.launch op(s) ($N_MARK markers)"
+fi
+
+# Phase-2: run matcher, inject canonical kernel library, then
+# --lower-kernel-launch to inline canonical defn bodies in place of each
+# kernel.launch. This validates the matcher's *labels* — a wrongly-labeled
+# launch produces different numerics than the user's source and fails the
+# e2e diff.
+if [ -n "$MATCH_CANONICAL" ]; then
+  PY=$PYTHON
+  SCRIPTS=$REPO_ROOT/scripts/correctness
+  LIB=$REPO_ROOT/generic_solver/kernel_library_phase2.mlir
+  $PY $SCRIPTS/kernel_match_rewrite.py $OUT/std.mlir > $OUT/matched.mlir 2>$OUT/match.err
+  # Count both forms: `%X = kernel.launch ...` (tensor) and bare `kernel.launch ...`
+  # (memref, void-returning). grep -c returns exit code 1 when zero matches, so
+  # `|| echo 0` keeps us alive under `set -e`.
+  N_LAUNCH=$(grep -cE '\bkernel\.launch ' $OUT/matched.mlir 2>/dev/null || echo 0)
+  N_LAUNCH=${N_LAUNCH:-0}
+  if [ "$N_LAUNCH" -gt 0 ]; then
+    $PY $SCRIPTS/inject_kernel_library.py $OUT/matched.mlir $LIB -o $OUT/combined.mlir 2>$OUT/inject.err
+    polygeist-opt --lower-kernel-launch $OUT/combined.mlir -o $OUT/std.mlir 2>$OUT/lower.err || {
+      echo "$TAG: PHASE2_LOWER_FAIL"; cat $OUT/lower.err >&2; exit 5; }
+  fi
+  echo "$TAG: phase-2 matched $N_LAUNCH kernel.launch op(s)"
+fi
+
+# Step 4: standard MLIR lowering to LLVM dialect.
+# The debuferize path emits `bufferization.to_tensor` that one-shot-bufferize
+# needs `restrict` on. LinalgDebufferize doesn't emit it; patch via sed.
+# Also: one-shot-bufferize doesn't handle `affine.for` with tensor iter_args,
+# which debuferize emits for time-stepping kernels. Convert affine.for ->
+# scf.for first (via --lower-affine) so bufferize sees only scf.for.
+if [ -n "$DEBUF" ]; then
+  sed -i 's|bufferization\.to_tensor \(%[^ ]*\) :|bufferization.to_tensor \1 restrict :|g' $OUT/std.mlir
+  EXTRA="--lower-affine --empty-tensor-to-alloc-tensor --one-shot-bufferize=bufferize-function-boundaries"
+else
+  EXTRA=""
+fi
+$MLIR_OPT $EXTRA --expand-strided-metadata \
+  --convert-linalg-to-loops --lower-affine --convert-scf-to-cf \
+  --convert-arith-to-llvm --convert-math-to-llvm \
+  --finalize-memref-to-llvm \
+  --convert-func-to-llvm --reconcile-unrealized-casts \
+  $OUT/std.mlir -o $OUT/llvm.mlir 2>$OUT/mlir.err
+
+# Step 5: translate to LLVM IR and rename kernel function.
+$MLIR_TRANSLATE --mlir-to-llvmir $OUT/llvm.mlir -o $OUT/kernel.ll 2>$OUT/translate.err
+sed -i "s/@${FN}\b/@${FN}_impl/g" $OUT/kernel.ll
+
+# Step 6: generate the C wrapper for this kernel.
+python3 $SCRIPT_DIR/gen_wrapper.py "$SRC" "$FN" > $OUT/wrapper.c 2>$OUT/wrapper_gen.err
+
+# Step 7: compile pieces. Weaken kernel_* in gemm.o so wrapper.o wins.
+$CLANG -c $CFLAGS $DYN_FLAGS $SRC -o $OUT/full.o
+objcopy --weaken-symbol=$FN $OUT/full.o $OUT/nokernel.o
+$CLANG -c $CFLAGS $UTIL/polybench.c -o $OUT/polybench.o
+$CLANG -c $OUT/wrapper.c -o $OUT/wrapper.o
+$CLANG -c $OUT/kernel.ll -o $OUT/kernel.o
+# Link in mlir_c_runner_utils when memref.copy survived lowering (multi-root
+# debuferize emits to_memref+memref.copy that one-shot-bufferize can't always
+# collapse). Harmless when not needed.
+MLIR_LIBDIR=$REPO_ROOT/llvm-project/build/lib
+$CLANG $OUT/nokernel.o $OUT/wrapper.o $OUT/kernel.o $OUT/polybench.o -lm \
+  -L$MLIR_LIBDIR -Wl,-rpath,$MLIR_LIBDIR -lmlir_c_runner_utils \
+  -o $OUT/test_exe
+
+# Step 8: run both, diff. Tolerate a non-zero exit on test_exe — some
+# kernels crash on heap-free after the dump, but the dump itself is
+# what we're comparing.
+set +e
+$OUT/ref_exe 2> $OUT/ref.out
+$OUT/test_exe 2> $OUT/test.out
+set -e
+if diff -q $OUT/ref.out $OUT/test.out >/dev/null; then
+  echo "$TAG: PASS"
+  exit 0
+else
+  echo "$TAG: FAIL_DIFF (first 5 differing lines:)"
+  diff $OUT/ref.out $OUT/test.out | head -5
+  exit 4
+fi
diff --git a/scripts/correctness/shortcut_batched_jetson_harness.c b/scripts/correctness/shortcut_batched_jetson_harness.c
new file mode 100644
index 000000000000..63b547f72be3
--- /dev/null
+++ b/scripts/correctness/shortcut_batched_jetson_harness.c
@@ -0,0 +1,83 @@
+/* shortcut_batched_jetson_harness.c — Jetson harness for batched
+ * residual-add shortcut. */
+#include 
+#include 
+#include 
+#include 
+
+#if defined(LARGE_DATASET)
+# define B 32
+# define C 64
+# define H 56
+# define W 56
+#elif defined(MINI_DATASET)
+# define B 4
+# define C 8
+# define H 32
+# define W 32
+#endif
+#ifndef B
+# define B 4
+#endif
+#ifndef C
+# define C 8
+#endif
+#ifndef H
+# define H 32
+#endif
+#ifndef W
+# define W 32
+#endif
+
+extern void kernel_shortcut_batched_impl(
+    float *A_b, float *A_a, int64_t A_o,
+    int64_t A_s0, int64_t A_s1, int64_t A_s2, int64_t A_s3,
+    int64_t A_t0, int64_t A_t1, int64_t A_t2, int64_t A_t3,
+    float *O_b, float *O_a, int64_t O_o,
+    int64_t O_s0, int64_t O_s1, int64_t O_s2, int64_t O_s3,
+    int64_t O_t0, int64_t O_t1, int64_t O_t2, int64_t O_t3);
+
+extern void   polygeist_cublas_time_begin(void);
+extern double polygeist_cublas_time_end_ms(void);
+
+static void run_kernel(float *A, float *Bout) {
+  polygeist_cublas_time_begin();
+  kernel_shortcut_batched_impl(
+      A, A, 0,
+      (int64_t)B, (int64_t)C, (int64_t)H, (int64_t)W,
+      (int64_t)(C*H*W), (int64_t)(H*W), (int64_t)W, 1,
+      Bout, Bout, 0,
+      (int64_t)B, (int64_t)C, (int64_t)H, (int64_t)W,
+      (int64_t)(C*H*W), (int64_t)(H*W), (int64_t)W, 1);
+  double ms = polygeist_cublas_time_end_ms();
+  fprintf(stderr,
+      "POLYGEIST_TIMING: shortcut_batched B=%d C=%d H=%d W=%d  %.3f ms\n",
+      B, C, H, W, ms);
+}
+
+int main(void) {
+  size_t n = (size_t)B*C*H*W;
+  float *A = (float *)malloc(n * sizeof(float));
+  float *Bout = (float *)malloc(n * sizeof(float));
+  if (!A || !Bout) { fprintf(stderr, "alloc failed\n"); return 1; }
+
+  for (size_t k = 0; k < n; ++k) {
+    A[k] = (float)((k * 17) % 41) / 41.0f;
+    Bout[k] = (float)((k * 23) % 37) / 37.0f;
+  }
+
+  run_kernel(A, Bout);
+
+  double sum = 0;
+  for (size_t k = 0; k < n; ++k) sum += Bout[k];
+  fprintf(stderr, "CHECKSUM: %.6f over %zu elems\n", sum, n);
+  fprintf(stderr, "==BEGIN DUMP_ARRAYS==\n");
+  for (size_t k = 0; k < n; ++k) {
+    if (k % 19 == 0) fprintf(stderr, "\n");
+    fprintf(stderr, "%0.4f ", Bout[k]);
+  }
+  fprintf(stderr, "\n==END   DUMP_ARRAYS==\n");
+
+  free(A); free(Bout);
+  return 0;
+}
diff --git a/scripts/correctness/syrk_jetson_wrapper.c b/scripts/correctness/syrk_jetson_wrapper.c
new file mode 100644
index 000000000000..970ac0a50a51
--- /dev/null
+++ b/scripts/correctness/syrk_jetson_wrapper.c
@@ -0,0 +1,34 @@
+/* syrk_jetson_wrapper.c — Jetson timing wrapper.
+ *
+ * Bridges polybenchGpu's kernel_syrk(int ni, int nj, double alpha, double beta,
+ * double C[NI][NI], double A[NI][NJ]) signature to the MLIR-lowered
+ * kernel_syrk_impl that takes bare memref descriptor args.
+ *
+ * Wraps the call with polygeist_cublas_time_begin/end_ms so we get a per-call
+ * timing print on stderr. On the CUDA runtime, timing uses cudaEvents.
+ *
+ * Matches gemm_jetson_wrapper.c structure.
+ */
+#include 
+#include 
+
+extern void kernel_syrk_impl(
+    int ni, int nj, double alpha, double beta,
+    double *C_base, double *C_aligned, int64_t C_offset,
+    int64_t C_size0, int64_t C_size1, int64_t C_stride0, int64_t C_stride1,
+    double *A_base, double *A_aligned, int64_t A_offset,
+    int64_t A_size0, int64_t A_size1, int64_t A_stride0, int64_t A_stride1);
+
+extern void   polygeist_cublas_time_begin(void);
+extern double polygeist_cublas_time_end_ms(void);
+
+void kernel_syrk(int ni, int nj, double alpha, double beta,
+                 double *C, double *A) {
+  polygeist_cublas_time_begin();
+  kernel_syrk_impl(ni, nj, alpha, beta,
+                   C, C, 0, ni, ni, ni, 1,
+                   A, A, 0, ni, nj, nj, 1);
+  double ms = polygeist_cublas_time_end_ms();
+  fprintf(stderr, "POLYGEIST_TIMING: kernel_syrk ni=%d nj=%d  %.3f ms\n",
+          ni, nj, ms);
+}
diff --git a/scripts/linalg-debufferize.sh b/scripts/linalg-debufferize.sh
new file mode 100755
index 000000000000..1b5fc479dfb2
--- /dev/null
+++ b/scripts/linalg-debufferize.sh
@@ -0,0 +1,92 @@
+#!/bin/bash
+
+# linalg-debufferize.sh
+# Script to run the full debufferization pipeline:
+# 1. cgeist: C -> MLIR
+# 2. polygeist-opt: Raise to linalg (with optional function selection)
+# 3. polygeist-opt: Debufferize
+
+set -e  # Exit on error
+
+# Check arguments
+if [ $# -lt 2 ]; then
+    echo "Usage: $0  "
+    echo ""
+    echo "Arguments:"
+    echo "  input.c       - Input C file to process"
+    echo "  function-name - Function name to select for debufferization (used in --select-func)"
+    echo ""
+    echo "Example:"
+    echo "  $0 kernel_gemm.c gemm"
+    echo "  $0 conv.c conv_2d"
+    exit 1
+fi
+
+INPUT_FILE="$1"
+FUNC_NAME="$2"
+
+# Check if input file exists
+if [ ! -f "$INPUT_FILE" ]; then
+    echo "Error: Input file '$INPUT_FILE' not found"
+    exit 1
+fi
+
+# Get the base name without extension
+BASENAME=$(basename "$INPUT_FILE" .c)
+DIRNAME=$(dirname "$INPUT_FILE")
+
+# Create temp directory based on filename
+TEMP_DIR="${DIRNAME}/${BASENAME}_debufferize_temp"
+mkdir -p "$TEMP_DIR"
+
+echo "=== Linalg Debufferization Pipeline ==="
+echo "Input file: $INPUT_FILE"
+echo "Function:   $FUNC_NAME"
+echo "Temp dir:   $TEMP_DIR"
+echo ""
+
+# Step 1: C to MLIR with cgeist
+echo "[1/3] Running cgeist: C -> MLIR..."
+MLIR_OUTPUT="${TEMP_DIR}/${BASENAME}.mlir"
+CMD="cgeist $INPUT_FILE --function=$FUNC_NAME --resource-dir=/usr/lib/clang/14 --raise-scf-to-affine -fPIC -S -g -c -o $MLIR_OUTPUT"
+echo "      Command: $CMD"
+cgeist "$INPUT_FILE" \
+    --function="$FUNC_NAME" \
+    --resource-dir=/usr/lib/clang/14 \
+    --raise-scf-to-affine \
+    -fPIC -S -g -c \
+    -o "$MLIR_OUTPUT"
+echo "      Output: $MLIR_OUTPUT"
+
+# Step 2: Raise to linalg
+echo "[2/3] Running polygeist-opt: Raise to linalg..."
+LINALG_OUTPUT="${TEMP_DIR}/${BASENAME}_linalg.mlir"
+CMD="polygeist-opt --select-func=func-name=$FUNC_NAME --remove-iter-args --affine-parallelize --raise-affine-to-linalg-pipeline $MLIR_OUTPUT -o $LINALG_OUTPUT"
+echo "      Command: $CMD"
+polygeist-opt \
+    --select-func="func-name=$FUNC_NAME" \
+    --remove-iter-args \
+    --affine-parallelize \
+    --raise-affine-to-linalg-pipeline \
+    "$MLIR_OUTPUT" \
+    -o "$LINALG_OUTPUT"
+echo "      Output: $LINALG_OUTPUT"
+
+# Step 3: Debufferize
+echo "[3/3] Running polygeist-opt: Debufferize..."
+DEBUF_OUTPUT="${TEMP_DIR}/${BASENAME}_debufferized.mlir"
+CMD="polygeist-opt --linalg-debufferize $LINALG_OUTPUT -o $DEBUF_OUTPUT"
+echo "      Command: $CMD"
+polygeist-opt \
+    --linalg-debufferize \
+    "$LINALG_OUTPUT" \
+    -o "$DEBUF_OUTPUT"
+echo "      Output: $DEBUF_OUTPUT"
+
+echo ""
+echo "=== Pipeline Complete ==="
+echo "Final output: $DEBUF_OUTPUT"
+echo ""
+echo "Intermediate files in: $TEMP_DIR"
+ls -la "$TEMP_DIR"
+
diff --git a/test/polygeist-opt/debufferize.mlir b/test/polygeist-opt/debufferize.mlir
new file mode 100644
index 000000000000..65a5a9ef0adf
--- /dev/null
+++ b/test/polygeist-opt/debufferize.mlir
@@ -0,0 +1,496 @@
+//polygeist-opt --canonicalize --linalg-debufferize --canonicalize debufferize.mlir 
+
+#map16 = affine_map<(d0, d1, d2) -> (d2, d1)>
+#map17 = affine_map<(d0, d1, d2, d3) -> (d1 + d3, d0 + d2)>
+#map18 = affine_map<(d0, d1, d2, d3) -> (d1, d0)>
+#map19 = affine_map<(d0, d1, d2, d3) -> (d3, d2)>
+#map22 = affine_map<(d0, d1) -> (d1, d0)>
+
+ module @in_place_add{
+     func.func @in_place_add(%value: f32) {
+       %c0 = arith.constant 0 : index
+       %buffer = memref.alloca() : memref<128xf32> 
+       linalg.generic {
+         indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+         iterator_types = ["parallel"]
+       } ins(%buffer : memref<128xf32>) 
+         outs(%buffer : memref<128xf32>) {
+       ^bb0(%in: f32, %out: f32):
+         %sum = arith.addf %in, %value : f32
+         linalg.yield %sum : f32
+       }
+       return
+     }
+ }
+
+  module @in_place_add2{
+      func.func @in_place_add(%buffer:  memref<128xf32> {llvm.noalias}, %value: f32) {
+        %c0 = arith.constant 0 : index
+        //%buffer = memref.alloca() : memref<128xf32> 
+        linalg.generic {
+          indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+          iterator_types = ["parallel"]
+        } ins(%buffer : memref<128xf32>) 
+          outs(%buffer : memref<128xf32>) {
+        ^bb0(%in: f32, %out: f32):
+          %sum = arith.addf %in, %value : f32
+          linalg.yield %sum : f32
+        }
+        return
+      }
+  }
+
+  module @in_place_cond_add{
+      func.func @in_place_add(%buffer:  memref<128xf32> {llvm.noalias}, %value: f32, %cond: i1) {
+        %c0 = arith.constant 0 : index
+        //%buffer = memref.alloca() : memref<128xf32>
+        scf.if %cond {
+          linalg.generic {
+            indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+            iterator_types = ["parallel"]
+          } ins(%buffer : memref<128xf32>) 
+            outs(%buffer : memref<128xf32>) {
+          ^bb0(%in: f32, %out: f32):
+            %sum = arith.addf %in, %value : f32
+            linalg.yield %sum : f32
+          }
+        }
+        return
+      }
+  }
+
+  module @in_place_add_for{
+      func.func @in_place_add(%buffer:  memref<128xf32> {llvm.noalias}, %value: f32, %cond: i1) {
+        %c0 = arith.constant 0 : index
+        %c1 = arith.constant 1 : index
+        %c10 = arith.constant 10 : index
+        //%buffer = memref.alloca() : memref<128xf32>
+        scf.for %i = %c0 to %c10 step %c1 {
+          linalg.generic {
+            indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+            iterator_types = ["parallel"]
+          } ins(%buffer : memref<128xf32>) 
+            outs(%buffer : memref<128xf32>) {
+          ^bb0(%in: f32, %out: f32):
+            %sum = arith.addf %in, %value : f32
+            linalg.yield %sum : f32
+          }
+        }
+        return
+      }
+  }
+
+  //Case when buffer is captured
+  module @in_place_add_for_loop_carried{
+      func.func @in_place_add(%buffer:  memref<128xf32> {llvm.noalias}, %value: f32, %cond: i1) {
+        %c0 = arith.constant 0 : index
+        %c1 = arith.constant 1 : index
+        %c10 = arith.constant 10 : index
+        //%buffer = memref.alloca() : memref<128xf32>
+        %result =  scf.for %i = %c0 to %c10 step %c1 iter_args(%buf = %buffer) -> (memref<128xf32>) {
+          linalg.generic {
+            indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+            iterator_types = ["parallel"]
+          } ins(%buf : memref<128xf32>) 
+            outs(%buf : memref<128xf32>) {
+          ^bb0(%in: f32, %out: f32):
+            %sum = arith.addf %in, %value : f32
+            linalg.yield %sum : f32
+          }
+          scf.yield %buf : memref<128xf32>
+        }
+        return
+      }
+  }
+  module @cross_buffer_add{
+      func.func @in_place_add(%buf:  memref<128xf32> {llvm.noalias}, %value: f32, %cond: i1) {
+        %c0 = arith.constant 0 : index
+        %c1 = arith.constant 1 : index
+        %c10 = arith.constant 10 : index
+        %buf2 = memref.alloca() : memref<128xf32>
+        linalg.generic {
+          indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+          iterator_types = ["parallel"]
+        } ins(%buf : memref<128xf32>) 
+          outs(%buf2 : memref<128xf32>) {
+        ^bb0(%in: f32, %out: f32):
+          %sum = arith.addf %in, %value : f32
+          linalg.yield %sum : f32
+        }
+        linalg.generic {
+          indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+          iterator_types = ["parallel"]
+        } ins(%buf2 : memref<128xf32>) 
+          outs(%buf : memref<128xf32>) {
+        ^bb0(%in: f32, %out: f32):
+          %sum = arith.addf %in, %value : f32
+          %sum2 = arith.addf %sum, %value : f32
+          linalg.yield %sum2 : f32
+        }
+        return
+      }
+  }
+  
+  module @in_place_add_for_loop_carried_cross_buffer{
+      func.func @in_place_add(%buffer:  memref<128xf32> {llvm.noalias}, %value: f32, %cond: i1) {
+        %c0 = arith.constant 0 : index
+        %c1 = arith.constant 1 : index
+        %c10 = arith.constant 10 : index
+        %buffer2 = memref.alloca() : memref<128xf32>
+        %result:2 =  scf.for %i = %c0 to %c10 step %c1 iter_args(%buf = %buffer, %buf2 = %buffer2) -> (memref<128xf32>, memref<128xf32>) {
+          linalg.generic {
+            indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+            iterator_types = ["parallel"]
+          } ins(%buf : memref<128xf32>) 
+            outs(%buf2 : memref<128xf32>) {
+          ^bb0(%in: f32, %out: f32):
+            %sum = arith.addf %in, %value : f32
+            linalg.yield %sum : f32
+          }
+          linalg.generic {
+            indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+            iterator_types = ["parallel"]
+          } ins(%buf2 : memref<128xf32>) 
+            outs(%buf : memref<128xf32>) {
+          ^bb0(%in: f32, %out: f32):
+            %sum = arith.addf %in, %value : f32
+            %sum2 = arith.addf %sum, %value : f32
+            linalg.yield %sum2 : f32
+          }
+          scf.yield %buf, %buf2 : memref<128xf32>, memref<128xf32>
+        }
+        return
+      }
+  }
+
+//    //TODO: Doesn't bufferize --affine loop carried iter_args doesn't canonicalizes (missing pattern?)
+//    module @in_place_add_for_loop_carried3{
+//       func.func @in_place_add(%buffer:  memref<128xf32> {llvm.noalias}, %value: f32, %cond: i1) {
+//         %c0 = arith.constant 0 : index
+//         %c1 = arith.constant 1 : index
+//         %c10 = arith.constant 10 : index
+//         %buffer2 = memref.alloca() : memref<128xf32>
+//         %result:2 =  affine.for %i = %c0 to %c10 iter_args(%buf = %buffer, %buf2 = %buffer2) -> (memref<128xf32>, memref<128xf32>) {
+//           linalg.generic {
+//             indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+//             iterator_types = ["parallel"]
+//           } ins(%buf : memref<128xf32>) 
+//             outs(%buf2 : memref<128xf32>) {
+//           ^bb0(%in: f32, %out: f32):
+//             %sum = arith.addf %in, %value : f32
+//             linalg.yield %sum : f32
+//           }
+//           linalg.generic {
+//             indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+//             iterator_types = ["parallel"]
+//           } ins(%buf2 : memref<128xf32>) 
+//             outs(%buf : memref<128xf32>) {
+//           ^bb0(%in: f32, %out: f32):
+//             %sum = arith.addf %in, %value : f32
+//             %sum2 = arith.addf %sum, %value : f32
+//             linalg.yield %sum2 : f32
+//           }
+//           affine.yield %buf, %buf2 : memref<128xf32>, memref<128xf32>
+//         }
+//         return
+//       }
+//   }
+
+//   module @in_place_add_for_loop_affine{
+//       func.func @in_place_add(%buf:  memref<128xf32> {llvm.noalias}, %value: f32, %cond: i1) {
+//         %c0 = arith.constant 0 : index
+//         %c1 = arith.constant 1 : index
+//         %c10 = arith.constant 10 : index
+//         %buf2 = memref.alloca() : memref<128xf32>
+//         affine.for %i = %c0 to %c10 {
+//           linalg.generic {
+//             indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+//             iterator_types = ["parallel"]
+//           } ins(%buf : memref<128xf32>) 
+//             outs(%buf2 : memref<128xf32>) {
+//           ^bb0(%in: f32, %out: f32):
+//             %sum = arith.addf %in, %value : f32
+//             linalg.yield %sum : f32
+//           }
+//           linalg.generic {
+//             indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+//             iterator_types = ["parallel"]
+//           } ins(%buf2 : memref<128xf32>) 
+//             outs(%buf : memref<128xf32>) {
+//           ^bb0(%in: f32, %out: f32):
+//             %sum = arith.addf %in, %value : f32
+//             %sum2 = arith.addf %sum, %value : f32
+//             linalg.yield %sum2 : f32
+//           }
+//         }
+//         return
+//       }
+//   }
+
+
+     module @in_place_cond_add_followed_by_add{
+       func.func @in_place_add(%buffer:  memref<128xf32> {llvm.noalias}, %value: f32, %cond: i1) {
+         %c0 = arith.constant 0 : index
+         //%buffer = memref.alloca() : memref<128xf32>
+         scf.if %cond {
+           linalg.generic {
+             indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+             iterator_types = ["parallel"]
+           } ins(%buffer : memref<128xf32>) 
+             outs(%buffer : memref<128xf32>) {
+           ^bb0(%in: f32, %out: f32):
+             %sum = arith.addf %in, %value : f32
+             %sum2 = arith.addf %sum, %value : f32
+             linalg.yield %sum2 : f32
+           }
+         }
+         linalg.generic {
+           indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+           iterator_types = ["parallel"]
+         } ins(%buffer : memref<128xf32>) 
+           outs(%buffer : memref<128xf32>) {
+         ^bb0(%in: f32, %out: f32):
+           %sum = arith.addf %in, %value : f32
+           linalg.yield %sum : f32
+         }
+         return
+       }
+   }
+
+     module @in_place_cond_add_followed_by_add2{
+       func.func @in_place_add(%buffer:  memref<128xf32> {llvm.noalias}, %value: f32, %cond: i1, %cond2: i1) {
+         %c0 = arith.constant 0 : index
+         //%buffer = memref.alloca() : memref<128xf32>
+         scf.if %cond2 {
+          linalg.generic {
+            indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+            iterator_types = ["parallel"]
+          } ins(%buffer : memref<128xf32>) 
+            outs(%buffer : memref<128xf32>) {
+          ^bb0(%in: f32, %out: f32):
+            %sum = arith.addf %in, %value : f32
+            %sum2 = arith.addf %sum, %value : f32
+            %sum3 = arith.addf %sum2, %value : f32
+            linalg.yield %sum3 : f32
+          }
+          scf.if %cond {
+            linalg.generic {
+              indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+              iterator_types = ["parallel"]
+            } ins(%buffer : memref<128xf32>) 
+              outs(%buffer : memref<128xf32>) {
+            ^bb0(%in: f32, %out: f32):
+              %sum = arith.addf %in, %value : f32
+              %sum2 = arith.addf %sum, %value : f32
+              linalg.yield %sum2 : f32
+            }
+          }
+         }
+          scf.if %cond {
+            linalg.generic {
+              indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+              iterator_types = ["parallel"]
+            } ins(%buffer : memref<128xf32>) 
+              outs(%buffer : memref<128xf32>) {
+            ^bb0(%in: f32, %out: f32):
+              %sum = arith.addf %in, %value : f32
+              %sum2 = arith.addf %sum, %value : f32
+              linalg.yield %sum2 : f32
+            }
+          }
+         linalg.generic {
+           indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+           iterator_types = ["parallel"]
+         } ins(%buffer : memref<128xf32>) 
+           outs(%buffer : memref<128xf32>) {
+         ^bb0(%in: f32, %out: f32):
+           %sum = arith.addf %in, %value : f32
+           linalg.yield %sum : f32
+         }
+         return
+       }
+   }
+
+    module @in_place_cond_add_followed_by_add3{
+      func.func @in_place_add(%buffer:  memref<128xf32> {llvm.noalias}, %value: f32, %cond: i1, %cond2: i1) {
+        %c0 = arith.constant 0 : index
+        //%buffer = memref.alloca() : memref<128xf32>
+        scf.if %cond2 {
+         scf.if %cond {
+           linalg.generic {
+             indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+             iterator_types = ["parallel"]
+           } ins(%buffer : memref<128xf32>) 
+             outs(%buffer : memref<128xf32>) {
+           ^bb0(%in: f32, %out: f32):
+             %sum = arith.addf %in, %value : f32
+             %sum2 = arith.addf %sum, %value : f32
+             linalg.yield %sum2 : f32
+           }
+         }
+        }
+        scf.if %cond2 {
+           linalg.generic {
+             indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+             iterator_types = ["parallel"]
+           } ins(%buffer : memref<128xf32>) 
+             outs(%buffer : memref<128xf32>) {
+           ^bb0(%in: f32, %out: f32):
+             %sum = arith.addf %in, %value : f32
+             %sum2 = arith.addf %sum, %value : f32
+             %sum3 = arith.addf %sum2, %value : f32
+             linalg.yield %sum3 : f32
+           }
+        }
+        linalg.generic {
+          indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+          iterator_types = ["parallel"]
+        } ins(%buffer : memref<128xf32>) 
+          outs(%buffer : memref<128xf32>) {
+        ^bb0(%in: f32, %out: f32):
+          %sum = arith.addf %in, %value : f32
+          linalg.yield %sum : f32
+        }
+        return
+      }
+    }
+
+  module @conv_2 {
+   func.func @main(%0: memref<515x67xi32> {llvm.noalias}, %1: memref<4x4xi32> {llvm.noalias}, %2: memref<512x64xi32> {llvm.noalias}) -> i32 attributes {llvm.linkage = #llvm.linkage} {
+     %c0_i32 = arith.constant 0 : i32
+     linalg.generic {indexing_maps = [#map17, #map18, #map19], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%0, %1 : memref<515x67xi32>, memref<4x4xi32>) outs(%2 : memref<512x64xi32>) {
+     ^bb0(%in: i32, %in_0: i32, %out: i32):
+       %3 = arith.muli %in, %in_0 : i32
+       %4 = arith.addi %out, %3 : i32
+       linalg.yield %4 : i32
+     }
+     return %c0_i32 : i32
+   }
+  }
+
+ module @harris_score_with_gradient_extra_kernel {
+     //memref.global "private" @_ZL8coeffs_1 : memref<5x5xi32> = dense<1>
+     //memref.global "private" @_ZL8coeffs_y : memref<3x3xi32> = dense<[[-3, -10, -3], [0, 0, 0], [3, 10, 3]]>
+     //memref.global "private" @_ZL8coeffs_x : memref<3x3xi32> = dense<[[-3, -10, -3], [0, 0, 0], [3, 10, 3]]>
+     func.func @main(%input: memref<518x518xi32>, %0: memref<3x3xi32> {llvm.noalias}, %1: memref<3x3xi32> {llvm.noalias}, %2: memref<5x5xi32> {llvm.noalias}, %score: memref<512x512xi32> {llvm.noalias}) -> i32 attributes {llvm.linkage = #llvm.linkage} {
+       %c4_i32 = arith.constant 4 : i32
+       %c0_i32 = arith.constant 0 : i32
+       %alloca = memref.alloca() : memref<512x512xi32>
+       %alloca_0 = memref.alloca() : memref<512x512xi32>
+       %alloca_1 = memref.alloca() : memref<512x512xi32>
+       %alloca_2 = memref.alloca() : memref<516x516xi32>
+       %alloca_3 = memref.alloca() : memref<516x516xi32>
+       //%score    = memref.alloca() : memref<512x512xi32>
+       //%0 = memref.get_global @_ZL8coeffs_x : memref<3x3xi32>
+       //%1 = memref.get_global @_ZL8coeffs_y : memref<3x3xi32>
+       //%2 = memref.get_global @_ZL8coeffs_1 : memref<5x5xi32>
+       linalg.generic {indexing_maps = [#map17, #map18, #map18, #map19, #map19], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%input, %0, %1 : memref<518x518xi32>, memref<3x3xi32>, memref<3x3xi32>) outs(%alloca_2, %alloca_3 : memref<516x516xi32>, memref<516x516xi32>) {
+       ^bb0(%in: i32, %in_5: i32, %in_6: i32, %out: i32, %out_7: i32):
+         %4 = arith.muli %in, %in_5 : i32
+         %5 = arith.addi %out_7, %4 : i32
+         %6 = arith.muli %in, %in_6 : i32
+         %7 = arith.addi %out, %6 : i32
+         linalg.yield %7, %5 : i32, i32
+       }
+       linalg.generic {indexing_maps = [#map17, #map17, #map18, #map19, #map19, #map19], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%alloca_3, %alloca_2, %2 : memref<516x516xi32>, memref<516x516xi32>, memref<5x5xi32>) outs(%alloca, %alloca_0, %alloca_1 : memref<512x512xi32>, memref<512x512xi32>, memref<512x512xi32>) {
+       ^bb0(%in: i32, %in_5: i32, %in_6: i32, %out: i32, %out_7: i32, %out_8: i32):
+         %4 = arith.muli %in, %in : i32
+         %5 = arith.muli %4, %in_6 : i32
+         %6 = arith.addi %out_8, %5 : i32
+         %7 = arith.muli %in_5, %in_5 : i32
+         %8 = arith.muli %7, %in_6 : i32
+         %9 = arith.addi %out_7, %8 : i32
+         %10 = arith.muli %in, %in_5 : i32
+         %11 = arith.muli %10, %in_6 : i32
+         %12 = arith.addi %out, %11 : i32
+         linalg.yield %12, %9, %6 : i32, i32, i32
+       }
+       linalg.generic {indexing_maps = [#map22, #map22, #map22, #map22], iterator_types = ["parallel", "parallel"]} ins(%alloca_1, %alloca_0, %alloca : memref<512x512xi32>, memref<512x512xi32>, memref<512x512xi32>) outs(%score : memref<512x512xi32>) {
+       ^bb0(%in: i32, %in_5: i32, %in_6: i32, %out: i32):
+         %4 = arith.muli %in, %in_5 : i32
+         %5 = arith.muli %in_6, %in_6 : i32
+         %6 = arith.subi %4, %5 : i32
+         %7 = arith.addi %in, %in_5 : i32
+         %8 = arith.muli %7, %c4_i32 : i32
+         %9 = arith.muli %8, %7 : i32
+         %10 = arith.subi %6, %9 : i32
+         linalg.yield %10 : i32
+       }
+       return %c0_i32 : i32
+     }
+   }
+   
+     module @for_loop_within_for_loop{
+      func.func @in_place_add(%buffer:  memref<128xf32> {llvm.noalias}, %value: f32, %cond: i1) {
+        %c0 = arith.constant 0 : index
+        %c1 = arith.constant 1 : index
+        %c10 = arith.constant 10 : index
+        //%buffer = memref.alloca() : memref<128xf32>
+        scf.for %i = %c0 to %c10 step %c1 {
+          scf.for %j = %c0 to %c10 step %c1 {
+            linalg.generic {
+              indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+              iterator_types = ["parallel"]
+            } ins(%buffer : memref<128xf32>) 
+              outs(%buffer : memref<128xf32>) {
+            ^bb0(%in: f32, %out: f32):
+              %sum = arith.addf %in, %value : f32
+              linalg.yield %sum : f32
+            }
+          }
+          linalg.generic {
+            indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+            iterator_types = ["parallel"]
+          } ins(%buffer : memref<128xf32>) 
+            outs(%buffer : memref<128xf32>) {
+          ^bb0(%in: f32, %out: f32):
+            %sum = arith.addf %in, %value : f32
+            linalg.yield %sum : f32
+          }
+        }
+        return
+      }
+  }
+   
+     module @for_loop_with_if_with_for{
+      func.func @in_place_add(%buffer:  memref<128xf32> {llvm.noalias}, %value: f32, %cond: i1) {
+        %c0 = arith.constant 0 : index
+        %c1 = arith.constant 1 : index
+        %c10 = arith.constant 10 : index
+        //%buffer = memref.alloca() : memref<128xf32>
+        scf.for %i = %c0 to %c10 step %c1 {
+          scf.if %cond {
+            linalg.generic {
+              indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+              iterator_types = ["parallel"]
+            } ins(%buffer : memref<128xf32>) 
+              outs(%buffer : memref<128xf32>) {
+            ^bb0(%in: f32, %out: f32):
+              %sum = arith.addf %in, %value : f32
+              linalg.yield %sum : f32
+            }
+            scf.for %j = %c0 to %c10 step %c1 {
+              linalg.generic {
+                indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+                iterator_types = ["parallel"]
+              } ins(%buffer : memref<128xf32>) 
+                outs(%buffer : memref<128xf32>) {
+              ^bb0(%in: f32, %out: f32):
+                %sum = arith.addf %in, %value : f32
+                linalg.yield %sum : f32
+              }
+            }
+            linalg.generic {
+              indexing_maps = [affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+              iterator_types = ["parallel"]
+            } ins(%buffer : memref<128xf32>) 
+              outs(%buffer : memref<128xf32>) {
+            ^bb0(%in: f32, %out: f32):
+              %sum = arith.addf %in, %value : f32
+              linalg.yield %sum : f32
+            }
+          }
+        }
+        return
+      }
+  }
diff --git a/test/polygeist-opt/fold-scf-if.mlir b/test/polygeist-opt/fold-scf-if.mlir
new file mode 100644
index 000000000000..0fa89dd7c154
--- /dev/null
+++ b/test/polygeist-opt/fold-scf-if.mlir
@@ -0,0 +1,58 @@
+// RUN: polygeist-opt --fold-scf-if --split-input-file %s | FileCheck %s
+
+func.func @store_select(%A: memref<10xf32>, %a: f32, %b: f32, %cond: i1) {
+  scf.if %cond {
+    affine.store %a, %A[0] : memref<10xf32>
+  } else {
+    affine.store %b, %A[0] : memref<10xf32>
+  }
+  return
+}
+
+// CHECK-LABEL: func.func @store_select
+// CHECK: %[[SELECT:.*]] = arith.select %{{.*}}, %{{.*}}, %{{.*}} : f32
+// CHECK: affine.store %[[SELECT]], %{{.*}}[0] : memref<10xf32>
+// CHECK: return
+
+// -----
+
+func.func @guarded_load(%A: memref, %B: memref, %i: index,
+                        %cond: i1) {
+  scf.if %cond {
+    %v = memref.load %A[%i] : memref
+    memref.store %v, %B[%i] : memref
+  } else {
+    %z = arith.constant 0.000000e+00 : f32
+    memref.store %z, %B[%i] : memref
+  }
+  return
+}
+
+// CHECK-LABEL: func.func @guarded_load
+// CHECK: scf.if
+// CHECK: memref.load
+// CHECK: memref.store
+// CHECK: return
+
+// -----
+
+func.func @guarded_max_store(%A: memref, %max: memref,
+                             %i: index) {
+  %candidate = affine.load %A[%i] : memref
+  %old = affine.load %max[] : memref
+  %cmp = arith.cmpf ogt, %candidate, %old : f32
+  scf.if %cmp {
+    %candidate_reload = affine.load %A[%i] : memref
+    affine.store %candidate_reload, %max[] : memref
+  }
+  return
+}
+
+// CHECK-LABEL: func.func @guarded_max_store
+// CHECK: %[[CANDIDATE:.*]] = affine.load %{{.*}}[%{{.*}}] : memref
+// CHECK: %[[OLD:.*]] = affine.load %{{.*}}[] : memref
+// CHECK: %[[CMP:.*]] = arith.cmpf ogt, %[[CANDIDATE]], %[[OLD]] : f32
+// CHECK: %[[SELECT:.*]] = arith.select %[[CMP]], %[[CANDIDATE]], %[[OLD]] : f32
+// CHECK: affine.store %[[SELECT]], %{{.*}}[] : memref
+// CHECK-NOT: scf.if
+// CHECK: return
diff --git a/test/polygeist-opt/hybrid-raise-to-linalg.mlir b/test/polygeist-opt/hybrid-raise-to-linalg.mlir
new file mode 100644
index 000000000000..166738525968
--- /dev/null
+++ b/test/polygeist-opt/hybrid-raise-to-linalg.mlir
@@ -0,0 +1,44 @@
+// RUN: polygeist-opt --raise-affine-to-linalg %s | FileCheck %s
+
+module {
+  func.func @hybrid_guarded_load(%in: memref, %out: memref,
+                                 %n: index) {
+    %cst = arith.constant 0.000000e+00 : f32
+    affine.for %c = 0 to 2 {
+      affine.for %oh = 0 to 3 {
+        affine.for %ow = 0 to 4 {
+          %ok = arith.cmpi ult, %ow, %n : index
+          %v = scf.if %ok -> (f32) {
+            %idx0 = arith.muli %c, %n : index
+            %idx1 = arith.addi %idx0, %ow : index
+            %x = memref.load %in[%idx1] : memref
+            scf.yield %x : f32
+          } else {
+            scf.yield %cst : f32
+          }
+          affine.store %v, %out[%ow + %oh * 4 + %c * 12] : memref
+        }
+      }
+    }
+    return
+  }
+}
+
+// CHECK-DAG: #[[OUT_MAP:.+]] = affine_map<(d0, d1, d2) -> (d2 + d1 * 4 + d0 * 12)>
+// CHECK-DAG: #[[ID_MAP:.+]] = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
+// CHECK-LABEL: func.func @hybrid_guarded_load
+// CHECK-NOT: affine.for
+// CHECK: polygeist.submap
+// CHECK-SAME: map = #[[OUT_MAP]]
+// CHECK: linalg.generic
+// CHECK-SAME: indexing_maps = [#[[ID_MAP]]]
+// CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel"]
+// CHECK-SAME: outs(
+// CHECK: ^bb0(%{{.*}}: f32):
+// CHECK: linalg.index 0
+// CHECK: linalg.index 2
+// CHECK: scf.if
+// CHECK: memref.load
+// CHECK: linalg.yield
+// CHECK-NOT: affine.for
+// CHECK: return
diff --git a/test/polygeist-opt/linalg-debufferize-subview.mlir b/test/polygeist-opt/linalg-debufferize-subview.mlir
new file mode 100644
index 000000000000..d3ad984b1151
--- /dev/null
+++ b/test/polygeist-opt/linalg-debufferize-subview.mlir
@@ -0,0 +1,114 @@
+// RUN: polygeist-opt --linalg-debufferize %s | FileCheck %s
+
+#map0 = affine_map<(d0) -> (d0)>
+#map1 = affine_map<(d0) -> ()>
+
+module {
+  func.func @subview_after_cross_root(%a: memref<4xf32>, %b: memref<4xf32>,
+                                      %out: memref<4xf32>) -> f32 {
+    %cst = arith.constant 0.000000e+00 : f32
+    %acc = memref.alloca() : memref
+    affine.store %cst, %acc[] : memref
+    linalg.generic {
+      indexing_maps = [#map0, #map0, #map0],
+      iterator_types = ["parallel"]
+    } ins(%a, %b : memref<4xf32>, memref<4xf32>)
+      outs(%out : memref<4xf32>) {
+    ^bb0(%in0: f32, %in1: f32, %old: f32):
+      %sum = arith.addf %in0, %in1 : f32
+      linalg.yield %sum : f32
+    }
+    %tail = memref.subview %out[1] [3] [1]
+      : memref<4xf32> to memref<3xf32, strided<[1], offset: 1>>
+    linalg.generic {
+      indexing_maps = [#map0, #map1],
+      iterator_types = ["reduction"]
+    } ins(%tail : memref<3xf32, strided<[1], offset: 1>>)
+      outs(%acc : memref) {
+    ^bb0(%in: f32, %old: f32):
+      %sum = arith.addf %old, %in : f32
+      linalg.yield %sum : f32
+    }
+    %res = affine.load %acc[] : memref
+    return %res : f32
+  }
+
+  // The reduction accumulator is allocated afresh inside the outer loop.
+  // Debufferization must tensorize it locally rather than trying to pass its
+  // tensor value as an affine.for init operand, where it would not dominate.
+  func.func @loop_local_reduction_scratch(%a: memref<4x8xf32>,
+                                           %out: memref<4xf32>) {
+    %zero = arith.constant 0.0 : f32
+    affine.for %i = 0 to 4 {
+      %scratch = memref.alloca() : memref
+      affine.store %zero, %scratch[] : memref
+      %row = memref.subview %a[%i, 0] [1, 8] [1, 1]
+        : memref<4x8xf32> to memref<8xf32, strided<[1], offset: ?>>
+      linalg.generic {
+        indexing_maps = [#map0, #map1],
+        iterator_types = ["reduction"]
+      } ins(%row : memref<8xf32, strided<[1], offset: ?>>)
+        outs(%scratch : memref) {
+      ^bb0(%in: f32, %old: f32):
+        %sum = arith.addf %old, %in : f32
+        linalg.yield %sum : f32
+      }
+      %value = affine.load %scratch[] : memref
+      affine.store %value, %out[%i] : memref<4xf32>
+    }
+    return
+  }
+
+  // The temporary connects three distinct roots.  Converting roots one at a
+  // time used to leave only the final copy and silently discard the fill and
+  // reduction that produce the temporary.
+  func.func @cross_root_temporary_chain(%a: memref<4x8xf32>,
+                                         %out: memref<4xf32>) {
+    %zero = arith.constant 0.0 : f32
+    %tmp = memref.alloca() : memref<4xf32>
+    linalg.generic {
+      indexing_maps = [#map0], iterator_types = ["parallel"]
+    } outs(%tmp : memref<4xf32>) {
+    ^bb0(%old: f32):
+      linalg.yield %zero : f32
+    }
+    linalg.generic {
+      indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>,
+                       affine_map<(d0, d1) -> (d0)>],
+      iterator_types = ["parallel", "reduction"]
+    } ins(%a : memref<4x8xf32>) outs(%tmp : memref<4xf32>) {
+    ^bb0(%in: f32, %old: f32):
+      %sum = arith.addf %old, %in : f32
+      linalg.yield %sum : f32
+    }
+    linalg.generic {
+      indexing_maps = [#map0, #map0], iterator_types = ["parallel"]
+    } ins(%tmp : memref<4xf32>) outs(%out : memref<4xf32>) {
+    ^bb0(%in: f32, %old: f32):
+      linalg.yield %in : f32
+    }
+    return
+  }
+}
+
+// CHECK-LABEL: func.func @subview_after_cross_root
+// CHECK: bufferization.to_tensor %arg2 : memref<4xf32>
+// CHECK: linalg.generic
+// CHECK-SAME: ins(%{{.*}}, %{{.*}} : tensor<4xf32>, tensor<4xf32>)
+// CHECK-SAME: outs(%{{.*}} : tensor<4xf32>)
+// CHECK: tensor.extract_slice %{{.*}}[1] [3] [1] : tensor<4xf32> to tensor<3xf32>
+// CHECK: linalg.generic
+// CHECK-SAME: ins(%{{.*}} : tensor<3xf32>)
+// CHECK-SAME: outs(%{{.*}} : tensor)
+// CHECK-NOT: memref.subview
+
+// CHECK-LABEL: func.func @loop_local_reduction_scratch
+// CHECK: affine.for
+// CHECK-SAME: iter_args(%{{.*}} = %{{.*}})
+// CHECK: bufferization.to_tensor %{{.*}} : memref
+// CHECK: linalg.generic
+// CHECK-SAME: outs(%{{.*}} : tensor)
+
+// CHECK-LABEL: func.func @cross_root_temporary_chain
+// CHECK-COUNT-3: linalg.generic
+// CHECK-NOT: memref.alloca
diff --git a/test/polygeist-opt/linalg_debufferize_tile_fusion.mlir b/test/polygeist-opt/linalg_debufferize_tile_fusion.mlir
new file mode 100644
index 000000000000..dbe09418ed75
--- /dev/null
+++ b/test/polygeist-opt/linalg_debufferize_tile_fusion.mlir
@@ -0,0 +1,105 @@
+// RUN: mlir-opt %s -test-transform-dialect-interpreter --one-shot-bufferize="bufferize-function-boundaries" --func-bufferize --tensor-bufferize  --finalizing-bufferize --convert-linalg-to-affine-loops --raise-scf-to-affine -split-input-file -verify-diagnostics | FileCheck %s
+// To test bufferization : pva-opt %s -test-transform-dialect-interpreter --one-shot-bufferize="bufferize-function-boundaries test-analysis-only print-conflicts"
+#map1 = affine_map<(d0, d1, d2, d3) -> (d0 + d2, d1 + d3)>
+#map2 = affine_map<(d0, d1, d2, d3) -> (d2, d3)>
+#map3 = affine_map<(d0, d1, d2, d3) -> (d0, d1)>
+
+memref.global @out : memref<512x64xi32> = uninitialized
+memref.global @rhs : memref<64x64xi32> = uninitialized
+memref.global @filter : memref<4x4xi32> = uninitialized
+memref.global @im : memref<515x67xi32> = uninitialized
+// Output after debufferization
+// func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+//   %c512 = arith.constant 512 : index
+//   %c64 = arith.constant 64 : index
+//   %c4 = arith.constant 4 : index
+//   %c0_i32 = arith.constant 0 : i32
+//   %0 = memref.get_global @im : memref<515x67xi32>
+//   %1 = memref.get_global @filter : memref<4x4xi32>
+//   %2 = memref.get_global @out : memref<512x64xi32>
+//   %rhs_memref = memref.get_global @rhs : memref<64x64xi32>
+//   %4 = bufferization.to_tensor %0 : memref<515x67xi32>
+//   %5 = bufferization.to_tensor %1 : memref<4x4xi32>
+//   %x = tensor.empty() : tensor<512x64xi32> 
+//   %out = linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%4, %5 : tensor<515x67xi32>, tensor<4x4xi32>) outs(%x : tensor<512x64xi32>) {
+//   ^bb0(%in: i32, %in_0: i32, %out: i32):
+//     %6 = arith.muli %in, %in_0 : i32
+//     %7 = arith.addi %out, %6 : i32
+//     linalg.yield %7 : i32
+//   } -> tensor<512x64xi32>
+//
+//   %materialize = bufferization.to_memref %out : memref<512x64xi32>
+//   memref.copy %materialize, %2 : memref<512x64xi32> to memref<512x64xi32>
+//
+//   %conv_out = bufferization.to_tensor %2 : memref<512x64xi32>
+//   %rhs = bufferization.to_tensor %rhs_memref : memref<64x64xi32>
+//   %y = tensor.empty() : tensor<512x64xi32> 
+//   %matmul = linalg.matmul ins(%conv_out, %rhs: tensor<512x64xi32>, tensor<64x64xi32>)
+//                           outs(%y: tensor<512x64xi32>) -> tensor<512x64xi32>
+//   %materialize2 = bufferization.to_memref %matmul : memref<512x64xi32>
+//   memref.copy %materialize2, %2 : memref<512x64xi32> to memref<512x64xi32>
+//   return %c0_i32 : i32
+// }
+
+//Output after linking kernels
+func.func @main_opt() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+  %c512 = arith.constant 512 : index
+  %c64 = arith.constant 64 : index
+  %c4 = arith.constant 4 : index
+  %c0_i32 = arith.constant 0 : i32
+  %0 = memref.get_global @im : memref<515x67xi32>
+  %1 = memref.get_global @filter : memref<4x4xi32>
+  %2 = memref.get_global @out : memref<512x64xi32>
+  %rhs_memref = memref.get_global @rhs : memref<64x64xi32>
+  %4 = bufferization.to_tensor %0 : memref<515x67xi32>
+  %5 = bufferization.to_tensor %1 : memref<4x4xi32>
+  %x = tensor.empty() : tensor<512x64xi32> 
+  %conv_out = bufferization.to_tensor %2 : memref<512x64xi32>
+  %rhs = bufferization.to_tensor %rhs_memref : memref<64x64xi32>
+  %y = tensor.empty() : tensor<512x64xi32> 
+  %out = linalg.generic {indexing_maps = [#map1, #map2, #map3], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%4, %5 : tensor<515x67xi32>, tensor<4x4xi32>) outs(%x : tensor<512x64xi32>) {
+  ^bb0(%in: i32, %in_0: i32, %out: i32):
+    %6 = arith.muli %in, %in_0 : i32
+    %7 = arith.addi %out, %6 : i32
+    linalg.yield %7 : i32
+  } -> tensor<512x64xi32>
+  %matmul = linalg.matmul ins(%out, %rhs: tensor<512x64xi32>, tensor<64x64xi32>)
+                          outs(%y: tensor<512x64xi32>) -> tensor<512x64xi32>
+  
+  %materialize2 = bufferization.to_memref %matmul : memref<512x64xi32>
+  memref.copy %materialize2, %2 : memref<512x64xi32> to memref<512x64xi32>
+  return %c0_i32 : i32
+}
+
+transform.sequence failures(propagate) {
+^bb0(%arg0: !transform.any_op) :
+        // Since the %arg2 handle is associated with both elementwise operations,
+        // we need to split it into two handles so we can target only the second
+        // elementwise operation.
+        %generic = transform.structured.match ops{["linalg.matmul","linalg.generic"]} in %arg0 : (!transform.any_op) -> !transform.any_op
+        %conv, %mul = transform.split_handle %generic
+            : (!transform.any_op)
+            -> (!transform.any_op, !transform.any_op)
+
+        // The actual tiling transformation takes tile sizes as attributes. It
+        // produces a handle to the loop generated during tiling.
+        %tiled_mul, %loop =
+            transform.structured.tile_using_forall %mul tile_sizes [8, 32]
+              : (!transform.any_op) -> (!transform.any_op, !transform.any_op)
+
+        // We can now fuse the other operations into the loop. Here, we fuse
+        // operations one by one. This requires the operation that is being fused to
+        // define the value used within the loop, so the order of such fusions is
+        // important. We could also use "transform.merge_handles" to obtain a single
+        // handle to all operations and give it to `fuse_into_containing_op` that
+        // would take care of the ordering in this case.
+         %conv_fused, %loop_0 =
+             transform.structured.fuse_into_containing_op %conv into %loop
+               : (!transform.any_op, !transform.any_op)
+                 -> (!transform.any_op, !transform.any_op)
+  
+
+        transform.yield
+}
+
+// -----
\ No newline at end of file
diff --git a/test/polygeist-opt/linalgraise.mlir b/test/polygeist-opt/linalgraise.mlir
index e0ceffa1849c..0d6b0dd61fc0 100644
--- a/test/polygeist-opt/linalgraise.mlir
+++ b/test/polygeist-opt/linalgraise.mlir
@@ -1,44 +1,58 @@
-// RUN: polygeist-opt --raise-affine-to-linalg --split-input-file %s | FileCheck %s
+//// RUN: polygeist-opt --raise-affine-to-linalg --split-input-file %s | FileCheck %s
+//
+// module {
+//   func.func @main0(%12 : i1, %18 : memref<32xf32> ) {
+//     %c0 = arith.constant 0 : index
+//     %c4 = arith.constant 4 : index
+//     %c1 = arith.constant 1 : index
+//     %19 = memref.alloca() : memref<32xf32>
+//     scf.if %12 {
+//       affine.for %arg4 = 0 to 17 {
+//         %ld = affine.load %18[%arg4] : memref<32xf32>
+//         affine.store %ld, %19[%arg4] : memref<32xf32>
+//       }
+//    }
+//     return
+//   }
+  
+  // func.func @main(%12 : i1, %14 : i32, %18 : memref ) {
+  //   %c0 = arith.constant 0 : index
+  //   %c4 = arith.constant 4 : index
+  //   %c1 = arith.constant 1 : index
+  //   %15 = arith.index_cast %14 : i32 to index
+  //   %16 = arith.muli %15, %c4 : index
+  //   %17 = arith.divui %16, %c4 : index
+  //   %19 = memref.alloca(%17) : memref
+  //   scf.if %12 {
+  //     affine.for %arg4 = 0 to 17 {
+  //       %ld = affine.load %18[%arg4] : memref
+  //       affine.store %ld, %19[%arg4] : memref
+  //     }
+  //  }
+  //   return
+  // }
 
-module {
-  func.func @main(%12 : i1, %14 : i32, %18 : memref ) {
-    %c0 = arith.constant 0 : index
-    %c4 = arith.constant 4 : index
-    %c1 = arith.constant 1 : index
-    %15 = arith.index_cast %14 : i32 to index
-    %16 = arith.muli %15, %c4 : index
-    %17 = arith.divui %16, %c4 : index
-    %19 = memref.alloca(%17) : memref
-    scf.if %12 {
-      affine.for %arg4 = 0 to %17 {
-        %ld = affine.load %18[%arg4] : memref
-        affine.store %ld, %19[%arg4] : memref
-      }
-   }
-    return
-  }
 
+ //    func.func @main2(%12 : i1, %14 : i32, %18 : memref ) {
+ //      %c0 = arith.constant 0 : index
+ //      %c4 = arith.constant 4 : index
+ //      %c1 = arith.constant 1 : index
+ //      %15 = arith.index_cast %14 : i32 to index
+ //      %16 = arith.muli %15, %c4 : index
+ //      %17 = arith.divui %16, %c4 : index
+ //      %19 = memref.alloca(%17) : memref
+ //      scf.if %12 {
+ //        affine.for %arg4 = 0 to 17 {
+ //          %ld = affine.load %18[3 * %arg4] : memref
+ //          %ld2 = affine.load %18[0] : memref
+ //          %fadd = arith.addf %ld, %ld2 : f32
+ //          affine.store %fadd, %19[%arg4 + 17] : memref
+ //        }
+ //     }
+ //      return
+ //    }
 
-  func.func @main2(%12 : i1, %14 : i32, %18 : memref ) {
-    %c0 = arith.constant 0 : index
-    %c4 = arith.constant 4 : index
-    %c1 = arith.constant 1 : index
-    %15 = arith.index_cast %14 : i32 to index
-    %16 = arith.muli %15, %c4 : index
-    %17 = arith.divui %16, %c4 : index
-    %19 = memref.alloca(%17) : memref
-    scf.if %12 {
-      affine.for %arg4 = 0 to 17 {
-        %ld = affine.load %18[3 * %arg4] : memref
-        %ld2 = affine.load %18[0] : memref
-        %fadd = arith.addf %ld, %ld2 : f32
-        affine.store %fadd, %19[%arg4 + 17] : memref
-      }
-   }
-    return
-  }
-
-}
+ // }
 
 // CHECK: #map = affine_map<(d0) -> (d0)>
 // CHECK:   func.func @main(%[[arg0:.+]]: i1, %[[arg1:.+]]: i32, %[[arg2:.+]]: memref, %[[arg3:.+]]: memref) {
@@ -177,7 +191,7 @@ module @cond_arith{
   }
 }
 
-//reduction
+//TODO: reduction
 module @reduction{
   func.func @main(%12 : i1, %14 : i32, %18 : memref, %20 : memref  ) {
     %c0 = arith.constant 0 : index
@@ -198,7 +212,53 @@ module @reduction{
   }
 }
 
-//Conditional store-1
+module @reduction_transformed{
+  func.func @main(%12 : i1, %14 : i32, %18 : memref, %20 : memref  ) {
+    %c0 = arith.constant 0 : index
+    %c4 = arith.constant 4 : index
+    %c1 = arith.constant 1 : index
+    %15 = arith.index_cast %14 : i32 to index
+    %16 = arith.muli %15, %c4 : index
+    %17 = arith.divui %16, %c4 : index
+    %19 = memref.alloca(%17) : memref
+    %sum_0 = arith.constant 0.0 : f32
+    %alloca = memref.alloca() : memref<1xf32> 
+    affine.store %sum_0, %alloca[0] : memref<1xf32>
+    affine.for %arg4 = 0 to 17 step 1 {
+      %iter_arg = affine.load %alloca[0] : memref<1xf32>
+      %ld1 = affine.load %18[%arg4] : memref
+      %sum_next = arith.addf %iter_arg, %ld1 : f32
+      affine.store %sum_next, %alloca[0] : memref<1xf32>
+      affine.yield
+    }
+    %red = affine.load %alloca[0] : memref<1xf32>
+    affine.store %red, %19[0] : memref
+    return
+  }
+}
+
+module @reduction_transformed_simplified{
+  func.func @main(%12 : i1, %14 : i32, %18 : memref, %20 : memref  ) {
+    %c0 = arith.constant 0 : index
+    %c4 = arith.constant 4 : index
+    %c1 = arith.constant 1 : index
+    %15 = arith.index_cast %14 : i32 to index
+    %16 = arith.muli %15, %c4 : index
+    %17 = arith.divui %16, %c4 : index
+    %19 = memref.alloca(%17) : memref
+    %sum_0 = arith.constant 0.0 : f32
+    affine.store %sum_0, %19[0] : memref
+    affine.for %arg4 = 0 to 17 step 1 {
+      %iter_arg = affine.load %19[0] : memref
+      %ld1 = affine.load %18[%arg4] : memref
+      %sum_next = arith.addf %iter_arg, %ld1 : f32
+      affine.store %sum_next, %19[0] : memref
+      affine.yield
+    }
+    return
+  }
+}
+//TODO: Conditional store-1
 module @cond_store_1 {
   func.func @main(%12 : i1, %14 : i32, %18 : memref ) {
     %c0 = arith.constant 0 : index
@@ -219,7 +279,7 @@ module @cond_store_1 {
   }
 }
 
-//Conditional store-2
+//TODO: Conditional store-2
 module @cond_store_2{
   func.func @main(%12 : i1, %14 : i32, %18 : memref ) {
     %c0 = arith.constant 0 : index
@@ -242,8 +302,34 @@ module @cond_store_2{
   }
 }
 
-//Parallel for
-module @parallel_for{
+// //Parallel for
+// module @parallel_for{
+//   func.func @main(%12 : i1, %14 : i32, %18 : memref, %20 : memref) {
+//     %c0 = arith.constant 0 : index
+//     %c4 = arith.constant 4 : index
+//     %c1 = arith.constant 1 : index
+//     %15 = arith.index_cast %14 : i32 to index
+//     %16 = arith.muli %15, %c4 : index
+//     %17 = arith.divui %16, %c4 : index
+//     %19 = memref.alloca(%17) : memref
+//     affine.for %arg4 = 0 to 17 {
+//       %ld = affine.load %18[%arg4] : memref
+//       %mul = arith.mulf %ld, %ld : f32
+//       affine.store %mul, %19[%arg4] : memref
+//     }
+//     affine.for %arg4 = 0 to 17 {
+//       %ld1 = affine.load %18[%arg4] : memref
+//       %ld2 = affine.load %20[%arg4] : memref
+//       %add = arith.addf %ld1, %ld2 : f32
+//       %mul = arith.mulf %add, %add : f32
+//       affine.store %mul, %19[%arg4] : memref
+//     }
+//     return
+//   }
+// }
+
+//Fors inside for
+module @for_within_for{
   func.func @main(%12 : i1, %14 : i32, %18 : memref, %20 : memref) {
     %c0 = arith.constant 0 : index
     %c4 = arith.constant 4 : index
@@ -251,25 +337,22 @@ module @parallel_for{
     %15 = arith.index_cast %14 : i32 to index
     %16 = arith.muli %15, %c4 : index
     %17 = arith.divui %16, %c4 : index
+    %21 = arith.muli %16, %c4 : index
     %19 = memref.alloca(%17) : memref
-    affine.for %arg4 = 0 to 17 {
-      %ld = affine.load %18[%arg4] : memref
-      %mul = arith.mulf %ld, %ld : f32
-      affine.store %mul, %19[%arg4] : memref
-    }
-    affine.for %arg4 = 0 to 17 {
-      %ld1 = affine.load %18[%arg4] : memref
-      %ld2 = affine.load %20[%arg4] : memref
-      %add = arith.addf %ld1, %ld2 : f32
-      %mul = arith.mulf %add, %add : f32
-      affine.store %mul, %19[%arg4] : memref
+    affine.for %arg3 = 0 to 21 {
+      affine.for %arg4 = 0 to 17 {
+        %ld1 = affine.load %18[%arg3] : memref
+        %ld2 = affine.load %20[%arg4] : memref
+        %mul = arith.mulf %ld1, %ld2 : f32
+        affine.store %mul, %19[%arg4] : memref
+      }
     }
     return
   }
 }
 
 //Fors inside for
-module @for_within_for{
+module @for_within_for_2{
   func.func @main(%12 : i1, %14 : i32, %18 : memref, %20 : memref) {
     %c0 = arith.constant 0 : index
     %c4 = arith.constant 4 : index
@@ -281,7 +364,7 @@ module @for_within_for{
     %19 = memref.alloca(%17) : memref
     affine.for %arg3 = 0 to 21 {
       affine.for %arg4 = 0 to 17 {
-        %ld1 = affine.load %18[%arg3] : memref
+        %ld1 = affine.load %18[%arg3+2*%arg4] : memref
         %ld2 = affine.load %20[%arg4] : memref
         %mul = arith.mulf %ld1, %ld2 : f32
         affine.store %mul, %19[%arg4] : memref
@@ -291,8 +374,8 @@ module @for_within_for{
   }
 }
 
-//Parallel fors inside for
-module @parallel_fors_inside_for {
+//Fors inside for
+module @for_within_for_3{
   func.func @main(%12 : i1, %14 : i32, %18 : memref, %20 : memref) {
     %c0 = arith.constant 0 : index
     %c4 = arith.constant 4 : index
@@ -300,19 +383,38 @@ module @parallel_fors_inside_for {
     %15 = arith.index_cast %14 : i32 to index
     %16 = arith.muli %15, %c4 : index
     %17 = arith.divui %16, %c4 : index
+    %21 = arith.muli %16, %c4 : index
     %19 = memref.alloca(%17) : memref
-    affine.for %arg3 = 0 to 17 {
+    affine.for %arg3 = 0 to 21 {
       affine.for %arg4 = 0 to 17 {
-        %ld1 = affine.load %18[%arg3] : memref
-        %ld2 = affine.load %20[%arg4] : memref
+        %ld1 = affine.load %18[%arg3+2*%arg4] : memref
+        %ld2 = affine.load %18[%arg3] : memref
+        %ld3 = affine.load %20[%arg4] : memref
         %mul = arith.mulf %ld1, %ld2 : f32
-        affine.store %mul, %19[%arg4] : memref
+        %mul2 = arith.mulf %mul, %ld3 : f32
+        affine.store %mul2, %19[%arg4] : memref
       }
+    }
+    return
+  }
+}
+
+//Fors inside for
+module @for_within_for_4{
+  func.func @main(%12 : i1, %14 : i32, %18 : memref, %20 : memref) {
+    %c0 = arith.constant 0 : index
+    %c4 = arith.constant 4 : index
+    %c1 = arith.constant 1 : index
+    %15 = arith.index_cast %14 : i32 to index
+    %16 = arith.muli %15, %c4 : index
+    %17 = arith.divui %16, %c4 : index
+    %21 = arith.muli %16, %c4 : index
+    %19 = memref.alloca(%17) : memref
+    affine.for %arg3 = 0 to 21 {
       affine.for %arg4 = 0 to 17 {
-        %ld1 = affine.load %18[%arg3] : memref
+        %ld1 = affine.load %18[%arg4+2*%arg3] : memref
         %ld2 = affine.load %20[%arg4] : memref
-        %add = arith.addf %ld1, %ld2 : f32
-        %mul = arith.mulf %add, %add : f32
+        %mul = arith.mulf %ld1, %ld2 : f32
         affine.store %mul, %19[%arg4] : memref
       }
     }
@@ -320,6 +422,229 @@ module @parallel_fors_inside_for {
   }
 }
 
+//Fors no-loop dependency
+module @for_no_loop_dependency{
+  func.func @main(%12 : i1, %14 : i32, %18 : memref, %20 : memref, %23 : memref) {
+    %c0 = arith.constant 0 : index
+    %c4 = arith.constant 4 : index
+    %c1 = arith.constant 1 : index
+    %15 = arith.index_cast %14 : i32 to index
+    %16 = arith.muli %15, %c4 : index
+    %17 = arith.divui %16, %c4 : index
+    %21 = arith.muli %16, %c4 : index
+    %19 = memref.alloca(%17) : memref
+    affine.for %arg3 = 0 to 15 {
+          %ld1 = affine.load %18[0] : memref
+          affine.store %ld1, %19[0] : memref
+    }
+    return
+  }
+}
+//Fors no-loop dependency
+module @for_2_levels_no_loop_dependency{
+  func.func @main(%12 : i1, %14 : i32, %18 : memref, %20 : memref, %23 : memref) {
+    %c0 = arith.constant 0 : index
+    %c4 = arith.constant 4 : index
+    %c1 = arith.constant 1 : index
+    %15 = arith.index_cast %14 : i32 to index
+    %16 = arith.muli %15, %c4 : index
+    %17 = arith.divui %16, %c4 : index
+    %21 = arith.muli %16, %c4 : index
+    %19 = memref.alloca(%17) : memref
+    affine.for %arg4 = 0 to 17 {
+      affine.for %arg3 = 0 to 15 {
+            %ld1 = affine.load %18[%arg4] : memref
+            affine.store %ld1, %19[%arg4] : memref
+      }
+    }
+    return
+  }
+}
+//Fors inside for
+module @for_3_levels_0{
+  func.func @main(%12 : i1, %14 : i32, %18 : memref, %20 : memref, %23 : memref) {
+    %c0 = arith.constant 0 : index
+    %c4 = arith.constant 4 : index
+    %c1 = arith.constant 1 : index
+    %15 = arith.index_cast %14 : i32 to index
+    %16 = arith.muli %15, %c4 : index
+    %17 = arith.divui %16, %c4 : index
+    %21 = arith.muli %16, %c4 : index
+    %19 = memref.alloca(%17) : memref
+    affine.for %arg3 = 0 to 15 {
+      affine.for %arg4 = 0 to 17 {
+        affine.for %arg5 = 0 to 21 {
+          %ld1 = affine.load %18[%arg3] : memref
+          %ld2 = affine.load %20[%arg4] : memref
+          %mul = arith.mulf %ld1, %ld2 : f32
+          affine.store %mul, %19[%arg5] : memref
+        }
+      }
+    }
+    return
+  }
+}
+
+//Fors inside for
+module @for_3_levels_1{
+  func.func @main(%12 : i1, %14 : i32, %18 : memref, %20 : memref, %23 : memref) {
+    %c0 = arith.constant 0 : index
+    %c4 = arith.constant 4 : index
+    %c1 = arith.constant 1 : index
+    %15 = arith.index_cast %14 : i32 to index
+    %16 = arith.muli %15, %c4 : index
+    %17 = arith.divui %16, %c4 : index
+    %21 = arith.muli %16, %c4 : index
+    %19 = memref.alloca(%17) : memref
+    affine.for %arg5 = 0 to 21 {
+      affine.for %arg3 = 0 to 21 {
+        affine.for %arg4 = 0 to 17 {
+          %ld1 = affine.load %18[%arg3] : memref
+          %ld2 = affine.load %20[%arg4] : memref
+          %mul = arith.mulf %ld1, %ld2 : f32
+          affine.store %mul, %19[%arg4] : memref
+        }
+      }
+    }
+    return
+  }
+}
+
+//Fors inside for
+module @for_3_levels_2{
+  func.func @main(%12 : i1, %14 : i32, %18 : memref, %20 : memref, %23 : memref) {
+    %c0 = arith.constant 0 : index
+    %c4 = arith.constant 4 : index
+    %c1 = arith.constant 1 : index
+    %15 = arith.index_cast %14 : i32 to index
+    %16 = arith.muli %15, %c4 : index
+    %17 = arith.divui %16, %c4 : index
+    %21 = arith.muli %16, %c4 : index
+    %19 = memref.alloca(%17) : memref
+    affine.for %arg3 = 0 to 21 {
+      affine.for %arg4 = 0 to 17 {
+        affine.for %arg5 = 0 to 21 {
+          %ld1 = affine.load %18[%arg3] : memref
+          %ld2 = affine.load %20[%arg4] : memref
+          %ld3 = affine.load %23[%arg5] : memref
+          %mul = arith.mulf %ld1, %ld2 : f32
+          %mul2 = arith.mulf %mul, %ld3 : f32
+          affine.store %mul2, %19[%arg4] : memref
+        }
+      }
+    }
+    return
+  }
+}
+
+//Fors inside for
+module @for_3_levels_3{
+  func.func @main(%12 : i1, %14 : i32, %18 : memref, %20 : memref) {
+    %c0 = arith.constant 0 : index
+    %c4 = arith.constant 4 : index
+    %c1 = arith.constant 1 : index
+    %15 = arith.index_cast %14 : i32 to index
+    %16 = arith.muli %15, %c4 : index
+    %17 = arith.divui %16, %c4 : index
+    %21 = arith.muli %16, %c4 : index
+    %19 = memref.alloca(%17) : memref
+    affine.for %arg3 = 0 to 21 {
+      affine.for %arg4 = 0 to 17 {
+        affine.for %arg5 = 0 to 21 {
+          %ld1 = affine.load %18[%arg3] : memref
+          %ld2 = affine.load %20[%arg4] : memref
+          %ld3 = affine.load %20[%arg5] : memref
+          %mul = arith.mulf %ld1, %ld2 : f32
+          %mul2 = arith.mulf %mul, %ld3 : f32
+          affine.store %mul2, %19[%arg4] : memref
+        }
+      }
+    }
+    return
+  }
+}
+
+//Fors inside for
+module @for_3_levels_4{
+  func.func @main(%12 : i1, %14 : i32, %18 : memref, %20 : memref) {
+    %c0 = arith.constant 0 : index
+    %c4 = arith.constant 4 : index
+    %c1 = arith.constant 1 : index
+    %15 = arith.index_cast %14 : i32 to index
+    %16 = arith.muli %15, %c4 : index
+    %17 = arith.divui %16, %c4 : index
+    %21 = arith.muli %16, %c4 : index
+    %19 = memref.alloca(%17) : memref
+    affine.for %arg3 = 0 to 21 {
+      affine.for %arg4 = 0 to 17 {
+        affine.for %arg5 = 0 to 21 {
+          %ld1 = affine.load %18[%arg3+4*%arg4+3] : memref
+          %ld2 = affine.load %20[7*%arg4+%arg5+2] : memref
+          %ld3 = affine.load %20[%arg5+2*%arg3] : memref
+          %mul = arith.mulf %ld1, %ld2 : f32
+          %mul2 = arith.mulf %mul, %ld3 : f32
+          affine.store %mul2, %19[%arg4] : memref
+        }
+      }
+    }
+    return
+  }
+}
+
+//Intermediate raising
+#map = affine_map<(d0)[s0] -> (s0)>
+#map1 = affine_map<(d0) -> (d0)>
+module @for_within_for2 {
+  func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref) {
+    %c17 = arith.constant 17 : index
+    %c4 = arith.constant 4 : index
+    %0 = arith.index_cast %arg1 : i32 to index
+    %1 = arith.muli %0, %c4 : index
+    %2 = arith.divui %1, %c4 : index
+    %alloca = memref.alloca(%2) : memref
+    affine.for %arg4 = 0 to 21 {
+      %3 = "polygeist.submap"(%arg2, %arg4, %c17) <{map = #map}> : (memref, index, index) -> memref
+      %4 = "polygeist.submap"(%arg3, %c17) <{map = #map1}> : (memref, index) -> memref
+      %5 = "polygeist.submap"(%alloca, %c17) <{map = #map1}> : (memref, index) -> memref
+      linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel"]} ins(%3, %4 : memref, memref) outs(%5 : memref) {
+      ^bb0(%in: f32, %in_0: f32, %out: f32):
+        %6 = arith.mulf %in, %in_0 : f32
+        linalg.yield %6 : f32
+      }
+    }
+    return
+  }
+}
+
+// //Parallel fors inside for
+// module @parallel_fors_inside_for {
+//   func.func @main(%12 : i1, %14 : i32, %18 : memref, %20 : memref) {
+//     %c0 = arith.constant 0 : index
+//     %c4 = arith.constant 4 : index
+//     %c1 = arith.constant 1 : index
+//     %15 = arith.index_cast %14 : i32 to index
+//     %16 = arith.muli %15, %c4 : index
+//     %17 = arith.divui %16, %c4 : index
+//     %19 = memref.alloca(%17) : memref
+//     affine.for %arg3 = 0 to 17 {
+//       affine.for %arg4 = 0 to 17 {
+//         %ld1 = affine.load %18[%arg3] : memref
+//         %ld2 = affine.load %20[%arg4] : memref
+//         %mul = arith.mulf %ld1, %ld2 : f32
+//         affine.store %mul, %19[%arg4] : memref
+//       }
+//       affine.for %arg4 = 0 to 17 {
+//         %ld1 = affine.load %18[%arg3] : memref
+//         %ld2 = affine.load %20[%arg4] : memref
+//         %add = arith.addf %ld1, %ld2 : f32
+//         %mul = arith.mulf %add, %add : f32
+//         affine.store %mul, %19[%arg4] : memref
+//       }
+//     }
+//     return
+//   }
+// }
+
 //matrix-mul iter arg
 module @matmul_1 {
   memref.global @out : memref<32x8xi32> = uninitialized
@@ -346,31 +671,31 @@ module @matmul_1 {
   }
 }
 
-//matrix-mul alias issue
-module @matmul_2 {
-  memref.global @out : memref<128x32xi32> = uninitialized
-  memref.global @im2 : memref<64x32xi32> = uninitialized
-  memref.global @im1 : memref<128x64xi32> = uninitialized
-  func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
-    %c0_i32 = arith.constant 0 : i32
-    %0 = memref.get_global @im1 : memref<128x64xi32>
-    %1 = memref.get_global @im2 : memref<64x32xi32>
-    %2 = memref.get_global @out : memref<128x32xi32>
-    affine.for %arg0 = 0 to 128 {
-      affine.for %arg1 = 0 to 32 {
-        affine.for %arg2 = 0 to 64 {
-          %3 = affine.load %0[%arg0, %arg2] : memref<128x64xi32>
-          %4 = affine.load %1[%arg2, %arg1] : memref<64x32xi32>
-          %5 = arith.muli %3, %4 : i32
-          %6 = affine.load %2[%arg0, %arg1] : memref<128x32xi32>
-          %7 = arith.addi %6, %5 : i32
-          affine.store %7, %2[%arg0, %arg1] : memref<128x32xi32>
-        }
-      }
-    }
-    return %c0_i32 : i32
-  }
-}
+//matrix-mul extra load-store variant
+ module @matmul_2 {
+   memref.global @out : memref<128x32xi32> = uninitialized
+   memref.global @im2 : memref<64x32xi32> = uninitialized
+   memref.global @im1 : memref<128x64xi32> = uninitialized
+   func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+     %c0_i32 = arith.constant 0 : i32
+     %0 = memref.get_global @im1 : memref<128x64xi32>
+     %1 = memref.get_global @im2 : memref<64x32xi32>
+     %2 = memref.get_global @out : memref<128x32xi32>
+     affine.for %arg0 = 0 to 128 {
+       affine.for %arg1 = 0 to 32 {
+         affine.for %arg2 = 0 to 64 {
+           %3 = affine.load %0[%arg0, %arg2] : memref<128x64xi32>
+           %4 = affine.load %1[%arg2, %arg1] : memref<64x32xi32>
+           %5 = arith.muli %3, %4 : i32
+           %6 = affine.load %2[%arg0, %arg1] : memref<128x32xi32>
+           %7 = arith.addi %6, %5 : i32
+           affine.store %7, %2[%arg0, %arg1] : memref<128x32xi32>
+         }
+       }
+     }
+     return %c0_i32 : i32
+   }
+ }
 
 //conv (with inner loop accumulate)
 //How to deal with IR in outer loops as well?
@@ -402,25 +727,519 @@ module @conv_1{
   }
 }
 
-//conv (direct store)
-module @conv_2{
+module @conv_1_reduction_test{
   memref.global @out : memref<512x64xi32> = uninitialized
   memref.global @filter : memref<4x4xi32> = uninitialized
   memref.global @im : memref<515x67xi32> = uninitialized
-  func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+  func.func @main(%arg0 : index, %arg1 : index) -> i32 attributes {llvm.linkage = #llvm.linkage} {
     %c0_i32 = arith.constant 0 : i32
     %0 = memref.get_global @im : memref<515x67xi32>
-    %1 = memref.get_global @out : memref<512x64xi32>
+    %1 = memref.get_global @filter : memref<4x4xi32>
+    %2 = memref.get_global @out : memref<512x64xi32>
+     %3 = affine.for %arg2 = 0 to 4 iter_args(%arg3 = %c0_i32) -> (i32) {
+       %4 = affine.for %arg4 = 0 to 4 iter_args(%arg5 = %arg3) -> (i32) {
+         %5 = affine.load %0[%arg0 + %arg2, %arg1 + %arg4] : memref<515x67xi32>
+         %6 = affine.load %1[%arg2, %arg4] : memref<4x4xi32>
+         %7 = arith.muli %5, %6 : i32
+         %8 = arith.addi %arg5, %7 : i32
+         affine.yield %8 : i32
+       }
+       affine.yield %4 : i32
+     }
+     affine.store %3, %2[%arg0, %arg1] : memref<512x64xi32>
+    return %c0_i32 : i32
+  }
+}
+
+//conv (direct store)
+ module @conv_2 {
+   memref.global @out : memref<512x64xi32> = uninitialized
+   memref.global @filter : memref<4x4xi32> = uninitialized
+   memref.global @im : memref<515x67xi32> = uninitialized
+   func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+     %c0_i32 = arith.constant 0 : i32
+     %0 = memref.get_global @im : memref<515x67xi32>
+     %1 = memref.get_global @filter : memref<4x4xi32>
+     %2 = memref.get_global @out : memref<512x64xi32>
+     affine.for %arg0 = 0 to 512 {
+       affine.for %arg1 = 0 to 64 {
+         affine.for %arg2 = 0 to 4 {
+           affine.for %arg3 = 0 to 4 {
+             %3 = affine.load %0[%arg0 + %arg2, %arg1 + %arg3] : memref<515x67xi32>
+             %4 = affine.load %1[%arg2, %arg3] : memref<4x4xi32>
+             %5 = arith.muli %3, %4 : i32
+             %6 = affine.load %2[%arg0, %arg1] : memref<512x64xi32>
+             %7 = arith.addi %6, %5 : i32
+             affine.store %7, %2[%arg0, %arg1] : memref<512x64xi32>
+           }
+         }
+       }
+     }
+     return %c0_i32 : i32
+   }
+ }
+
+//box_filter (direct store)
+ module @box_filter {
+   memref.global @out : memref<512x64xi32> = uninitialized
+   memref.global @filter : memref<4x4xi32> = uninitialized
+   memref.global @im : memref<515x67xi32> = uninitialized
+   func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+     %c0_i32 = arith.constant 0 : i32
+     %0 = memref.get_global @im : memref<515x67xi32>
+     %2 = memref.get_global @out : memref<512x64xi32>
+     affine.for %arg0 = 0 to 512 {
+       affine.for %arg1 = 0 to 64 {
+         affine.for %arg2 = 0 to 4 {
+           affine.for %arg3 = 0 to 4 {
+             %3 = affine.load %0[%arg0 + %arg2, %arg1 + %arg3] : memref<515x67xi32>
+             %6 = affine.load %2[%arg0, %arg1] : memref<512x64xi32>
+             %7 = arith.addi %6, %3 : i32
+             affine.store %7, %2[%arg0, %arg1] : memref<512x64xi32>
+           }
+         }
+       }
+     }
+     return %c0_i32 : i32
+   }
+ }
+
+  module @conv_loop1_test {
+    memref.global @out : memref<512x64xi32> = uninitialized
+    memref.global @filter : memref<4x4xi32> = uninitialized
+    memref.global @im : memref<515x67xi32> = uninitialized
+    func.func @main(%arg0 : index, %arg1 : index, %arg2 : index) -> i32 attributes {llvm.linkage = #llvm.linkage} {
+      %c0_i32 = arith.constant 0 : i32
+      %0 = memref.get_global @im : memref<515x67xi32>
+      %1 = memref.get_global @filter : memref<4x4xi32>
+      %2 = memref.get_global @out : memref<512x64xi32>
+            affine.for %arg3 = 0 to 4 {
+              %3 = affine.load %0[%arg0 + %arg2, %arg1 + %arg3] : memref<515x67xi32>
+              %4 = affine.load %1[%arg2, %arg3] : memref<4x4xi32>
+              %5 = arith.muli %3, %4 : i32
+              %6 = affine.load %2[%arg0, %arg1] : memref<512x64xi32>
+              %7 = arith.addi %6, %5 : i32
+              affine.store %7, %2[%arg0, %arg1] : memref<512x64xi32>
+            }
+      return %c0_i32 : i32
+    }
+  }  
+
+ module @submap_test {
+   memref.global @out : memref<511x64xi32> = uninitialized
+   memref.global @filter : memref<5x4xi32> = uninitialized
+   memref.global @im : memref<515x67xi32> = uninitialized
+   func.func @main(%arg0 : index, %arg1 : index) -> i32 attributes {llvm.linkage = #llvm.linkage} {
+     %c0_i32 = arith.constant 0 : i32
+     %0 = memref.get_global @im : memref<515x67xi32>
+     %1 = memref.get_global @filter : memref<5x4xi32>
+     %2 = memref.get_global @out : memref<511x64xi32>
+         affine.for %arg2 = 0 to 5 {
+           affine.for %arg3 = 0 to 4 {
+             %3 = affine.load %0[%arg0 + %arg2, %arg1 + %arg3] : memref<515x67xi32>
+             %4 = affine.load %1[%arg2, %arg3] : memref<5x4xi32>
+             %5 = arith.muli %3, %4 : i32
+             %6 = affine.load %2[%arg0, %arg1] : memref<511x64xi32>
+             %7 = arith.addi %6, %5 : i32
+             affine.store %7, %2[%arg0, %arg1] : memref<511x64xi32>
+           }
+         }
+     return %c0_i32 : i32
+   }
+ } 
+
+
+module @harris_score_1{
+ memref.global @coeffs_y : memref<9xi32> = dense<[-3, -10, -3, 0, 0, 0, 3, 10, 3]>
+  memref.global @coeffs_x : memref<9xi32> = dense<[-3, 0, 3, -10, 0, 10, -3, 0, 3]>
+  memref.global @score : memref<512x512xi32> = uninitialized
+  memref.global @img_ixy : memref<512x512xi32> = uninitialized
+  memref.global @img_iyy : memref<512x512xi32> = uninitialized
+  memref.global @img_ixx : memref<512x512xi32> = uninitialized
+  memref.global @img_in : memref<518x518xi32> = uninitialized
+  memref.global @img_gy : memref<516x516xi32> = uninitialized
+  memref.global @img_gx : memref<516x516xi32> = uninitialized
+  func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+    %c4_i32 = arith.constant 4 : i32
+    %c0_i32 = arith.constant 0 : i32
+    %0 = memref.get_global @img_gx : memref<516x516xi32>
+    %1 = memref.get_global @img_gy : memref<516x516xi32>
+    %2 = memref.get_global @img_in : memref<518x518xi32>
+    %3 = memref.get_global @coeffs_x : memref<9xi32>
+    %4 = memref.get_global @coeffs_y : memref<9xi32>
+    affine.for %arg0 = 0 to 516 {
+      affine.for %arg1 = 0 to 516 {
+        affine.for %arg2 = 0 to 3 {
+          affine.for %arg5 = 0 to 3 {
+            %gx = affine.load %0[%arg0, %arg1] : memref<516x516xi32>
+            %gy = affine.load %1[%arg0, %arg1] : memref<516x516xi32>
+            %11 = affine.load %2[%arg0 + %arg2, %arg1 + %arg5] : memref<518x518xi32>
+            %12 = affine.load %3[%arg5 + %arg2 * 3] : memref<9xi32>
+            %13 = arith.muli %11, %12 : i32
+            %14 = arith.addi %gx, %13 : i32
+            %15 = affine.load %4[%arg5 + %arg2 * 3] : memref<9xi32>
+            %16 = arith.muli %11, %15 : i32
+            %17 = arith.addi %gy, %16 : i32
+            affine.store %14, %0[%arg0, %arg1] : memref<516x516xi32>
+            affine.store %17, %1[%arg0, %arg1] : memref<516x516xi32>
+          }
+        }
+      }
+    }
+    %5 = memref.get_global @img_ixx : memref<512x512xi32>
+    %6 = memref.get_global @img_iyy : memref<512x512xi32>
+    %7 = memref.get_global @img_ixy : memref<512x512xi32>
     affine.for %arg0 = 0 to 512 {
-      affine.for %arg1 = 0 to 64 {
-        affine.for %arg2 = 0 to 4 {
-          affine.for %arg3 = 0 to 4 {
-            %2 = affine.load %0[%arg0 + %arg2, %arg1 + %arg3] : memref<515x67xi32>
-            %3 = affine.load %1[%arg0, %arg1] : memref<512x64xi32>
-            %4 = arith.addi %3, %2 : i32
-            affine.store %4, %1[%arg0, %arg1] : memref<512x64xi32>
+      affine.for %arg1 = 0 to 512 {
+        affine.for %arg2 = 0 to 5 {
+          affine.for %arg6 = 0 to 5 {
+            %ixx = affine.load %5[%arg0, %arg1] : memref<512x512xi32>
+            %iyy = affine.load %6[%arg0, %arg1] : memref<512x512xi32>
+            %ixy = affine.load %7[%arg0, %arg1] : memref<512x512xi32>
+            %11 = affine.load %0[%arg0 + %arg2, %arg1 + %arg6] : memref<516x516xi32>
+            %12 = affine.load %1[%arg0 + %arg2, %arg1 + %arg6] : memref<516x516xi32>
+            %13 = arith.muli %11, %11 : i32
+            %14 = arith.addi %ixx, %13 : i32
+            %15 = arith.muli %12, %12 : i32
+            %16 = arith.addi %iyy, %15 : i32
+            %17 = arith.muli %11, %12 : i32
+            %18 = arith.addi %ixy, %17 : i32
+            affine.store %14, %5[%arg0, %arg1] : memref<512x512xi32>
+            affine.store %16, %6[%arg0, %arg1] : memref<512x512xi32>
+            affine.store %18, %7[%arg0, %arg1] : memref<512x512xi32>
+          }
+        }
+      }
+    }
+    %8 = memref.get_global @score : memref<512x512xi32>
+    affine.for %arg0 = 0 to 512 {
+      affine.for %arg1 = 0 to 512 {
+        %9 = affine.load %5[%arg0, %arg1] : memref<512x512xi32>
+        %10 = affine.load %6[%arg0, %arg1] : memref<512x512xi32>
+        %11 = affine.load %7[%arg0, %arg1] : memref<512x512xi32>
+        %12 = arith.muli %9, %10 : i32
+        %13 = arith.muli %11, %11 : i32
+        %14 = arith.subi %12, %13 : i32
+        %15 = arith.addi %9, %10 : i32
+        %16 = arith.muli %15, %c4_i32 : i32
+        %17 = arith.muli %16, %15 : i32
+        %18 = arith.subi %14, %17 : i32
+        affine.store %18, %8[%arg0, %arg1] : memref<512x512xi32>
+      }
+    }
+    return %c0_i32 : i32
+  }
+}
+
+module @harris_score_2 {
+    memref.global @coeffs_y : memref<9xi32> = dense<[-3, -10, -3, 0, 0, 0, 3, 10, 3]>
+  memref.global @coeffs_x : memref<9xi32> = dense<[-3, 0, 3, -10, 0, 10, -3, 0, 3]>
+  memref.global @score : memref<512x512xi32> = uninitialized
+  memref.global @img_ixy : memref<512x512xi32> = uninitialized
+  memref.global @img_iyy : memref<512x512xi32> = uninitialized
+  memref.global @img_ixx : memref<512x512xi32> = uninitialized
+  memref.global @img_in : memref<518x518xi32> = uninitialized
+  memref.global @img_gy : memref<516x516xi32> = uninitialized
+  memref.global @img_gx : memref<516x516xi32> = uninitialized
+  func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+    %c4_i32 = arith.constant 4 : i32
+    %c0_i32 = arith.constant 0 : i32
+    %0 = memref.get_global @img_gx : memref<516x516xi32>
+    %1 = memref.get_global @img_gy : memref<516x516xi32>
+    %2 = memref.get_global @img_in : memref<518x518xi32>
+    %3 = memref.get_global @coeffs_x : memref<9xi32>
+    %4 = memref.get_global @coeffs_y : memref<9xi32>
+    affine.for %arg0 = 0 to 516 {
+      affine.for %arg1 = 0 to 516 {
+        %9:2 = affine.for %arg2 = 0 to 3 iter_args(%arg3 = %c0_i32, %arg4 = %c0_i32) -> (i32, i32) {
+          %10:2 = affine.for %arg5 = 0 to 3 iter_args(%arg6 = %arg3, %arg7 = %arg4) -> (i32, i32) {
+            %11 = affine.load %2[%arg0 + %arg2, %arg1 + %arg5] : memref<518x518xi32>
+            %12 = affine.load %3[%arg5 + %arg2 * 3] : memref<9xi32>
+            %13 = arith.muli %11, %12 : i32
+            %14 = arith.addi %arg7, %13 : i32
+            %15 = affine.load %4[%arg5 + %arg2 * 3] : memref<9xi32>
+            %16 = arith.muli %11, %15 : i32
+            %17 = arith.addi %arg6, %16 : i32
+            affine.yield %17, %14 : i32, i32
+          }
+          affine.yield %10#0, %10#1 : i32, i32
+        }
+        affine.store %9#1, %0[%arg0, %arg1] : memref<516x516xi32>
+        affine.store %9#0, %1[%arg0, %arg1] : memref<516x516xi32>
+      }
+    }
+    %5 = memref.get_global @img_ixx : memref<512x512xi32>
+    %6 = memref.get_global @img_iyy : memref<512x512xi32>
+    %7 = memref.get_global @img_ixy : memref<512x512xi32>
+    affine.for %arg0 = 0 to 512 {
+      affine.for %arg1 = 0 to 512 {
+        %9:3 = affine.for %arg2 = 0 to 5 iter_args(%arg3 = %c0_i32, %arg4 = %c0_i32, %arg5 = %c0_i32) -> (i32, i32, i32) {
+          %10:3 = affine.for %arg6 = 0 to 5 iter_args(%arg7 = %arg3, %arg8 = %arg4, %arg9 = %arg5) -> (i32, i32, i32) {
+            %11 = affine.load %0[%arg0 + %arg2, %arg1 + %arg6] : memref<516x516xi32>
+            %12 = affine.load %1[%arg0 + %arg2, %arg1 + %arg6] : memref<516x516xi32>
+            %13 = arith.muli %11, %11 : i32
+            %14 = arith.addi %arg9, %13 : i32
+            %15 = arith.muli %12, %12 : i32
+            %16 = arith.addi %arg8, %15 : i32
+            %17 = arith.muli %11, %12 : i32
+            %18 = arith.addi %arg7, %17 : i32
+            affine.yield %18, %16, %14 : i32, i32, i32
+          }
+          affine.yield %10#0, %10#1, %10#2 : i32, i32, i32
+        }
+        affine.store %9#2, %5[%arg0, %arg1] : memref<512x512xi32>
+        affine.store %9#1, %6[%arg0, %arg1] : memref<512x512xi32>
+        affine.store %9#0, %7[%arg0, %arg1] : memref<512x512xi32>
+      }
+    }
+    %8 = memref.get_global @score : memref<512x512xi32>
+    affine.for %arg0 = 0 to 512 {
+      affine.for %arg1 = 0 to 512 {
+        %9 = affine.load %5[%arg0, %arg1] : memref<512x512xi32>
+        %10 = affine.load %6[%arg0, %arg1] : memref<512x512xi32>
+        %11 = affine.load %7[%arg0, %arg1] : memref<512x512xi32>
+        %12 = arith.muli %9, %10 : i32
+        %13 = arith.muli %11, %11 : i32
+        %14 = arith.subi %12, %13 : i32
+        %15 = arith.addi %9, %10 : i32
+        %16 = arith.muli %15, %c4_i32 : i32
+        %17 = arith.muli %16, %15 : i32
+        %18 = arith.subi %14, %17 : i32
+        affine.store %18, %8[%arg0, %arg1] : memref<512x512xi32>
+      }
+    }
+    return %c0_i32 : i32
+  }
+}
+
+module @harris_score_local {
+  memref.global @coeffs_y : memref<9xi32> = dense<[-3, -10, -3, 0, 0, 0, 3, 10, 3]>
+  memref.global @coeffs_x : memref<9xi32> = dense<[-3, 0, 3, -10, 0, 10, -3, 0, 3]>
+  memref.global @score : memref<512x512xi32> = uninitialized
+  func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+    %c4_i32 = arith.constant 4 : i32
+    %c0_i32 = arith.constant 0 : i32
+    %alloca = memref.alloca() : memref<512x512xi32>
+    %alloca_0 = memref.alloca() : memref<512x512xi32>
+    %alloca_1 = memref.alloca() : memref<512x512xi32>
+    %alloca_2 = memref.alloca() : memref<516x516xi32>
+    %alloca_3 = memref.alloca() : memref<516x516xi32>
+    %alloca_4 = memref.alloca() : memref<518x518xi32>
+    %0 = memref.get_global @coeffs_x : memref<9xi32>
+    %1 = memref.get_global @coeffs_y : memref<9xi32>
+    affine.for %arg0 = 0 to 516 {
+      affine.for %arg1 = 0 to 516 {
+        affine.for %arg2 = 0 to 3 {
+          affine.for %arg5 = 0 to 3 {
+            %gx = affine.load %alloca_3[%arg0, %arg1] : memref<516x516xi32>
+            %gy = affine.load %alloca_2[%arg0, %arg1] : memref<516x516xi32>
+            %5 = affine.load %alloca_4[%arg0 + %arg2, %arg1 + %arg5] : memref<518x518xi32>
+            %6 = affine.load %0[%arg5 + %arg2 * 3] : memref<9xi32>
+            %7 = arith.muli %5, %6 : i32
+            %8 = arith.addi %gx, %7 : i32
+            %9 = affine.load %1[%arg5 + %arg2 * 3] : memref<9xi32>
+            %10 = arith.muli %5, %9 : i32
+            %11 = arith.addi %gy, %10 : i32
+            affine.store %8, %alloca_3[%arg0, %arg1] : memref<516x516xi32>
+            affine.store %11, %alloca_2[%arg0, %arg1] : memref<516x516xi32>
+          }
+        }
+      }
+    }
+    affine.for %arg0 = 0 to 512 {
+      affine.for %arg1 = 0 to 512 {
+        %3:3 = affine.for %arg2 = 0 to 5 iter_args(%arg3 = %c0_i32, %arg4 = %c0_i32, %arg5 = %c0_i32) -> (i32, i32, i32) {
+          %4:3 = affine.for %arg6 = 0 to 5 iter_args(%arg7 = %arg3, %arg8 = %arg4, %arg9 = %arg5) -> (i32, i32, i32) {
+            %ixx = affine.load %alloca_1[%arg0, %arg1] : memref<512x512xi32>
+            %iyy = affine.load %alloca_0[%arg0, %arg1] : memref<512x512xi32>
+            %ixy = affine.load %alloca[%arg0, %arg1] : memref<512x512xi32>
+            %5 = affine.load %alloca_3[%arg0 + %arg2, %arg1 + %arg6] : memref<516x516xi32>
+            %6 = affine.load %alloca_2[%arg0 + %arg2, %arg1 + %arg6] : memref<516x516xi32>
+            %7 = arith.muli %5, %5 : i32
+            %8 = arith.addi %arg9, %7 : i32
+            %9 = arith.muli %6, %6 : i32
+            %10 = arith.addi %arg8, %9 : i32
+            %11 = arith.muli %5, %6 : i32
+            %12 = arith.addi %arg7, %11 : i32
+            affine.yield %12, %10, %8 : i32, i32, i32
+          }
+          affine.yield %4#0, %4#1, %4#2 : i32, i32, i32
+        }
+        affine.store %3#2, %alloca_1[%arg0, %arg1] : memref<512x512xi32>
+        affine.store %3#1, %alloca_0[%arg0, %arg1] : memref<512x512xi32>
+        affine.store %3#0, %alloca[%arg0, %arg1] : memref<512x512xi32>
+      }
+    }
+    %2 = memref.get_global @score : memref<512x512xi32>
+    affine.for %arg0 = 0 to 512 {
+      affine.for %arg1 = 0 to 512 {
+        %3 = affine.load %alloca_1[%arg0, %arg1] : memref<512x512xi32>
+        %4 = affine.load %alloca_0[%arg0, %arg1] : memref<512x512xi32>
+        %5 = affine.load %alloca[%arg0, %arg1] : memref<512x512xi32>
+        %6 = arith.muli %3, %4 : i32
+        %7 = arith.muli %5, %5 : i32
+        %8 = arith.subi %6, %7 : i32
+        %9 = arith.addi %3, %4 : i32
+        %10 = arith.muli %9, %c4_i32 : i32
+        %11 = arith.muli %10, %9 : i32
+        %12 = arith.subi %8, %11 : i32
+        affine.store %12, %2[%arg0, %arg1] : memref<512x512xi32>
+      }
+    }
+    return %c0_i32 : i32
+  }
+}
+
+module @harris_score_2d_kernel {
+  memref.global "private" @_ZL8coeffs_y : memref<3x3xi32> = dense<[[-3, -10, -3], [0, 0, 0], [3, 10, 3]]>
+  memref.global "private" @_ZL8coeffs_x : memref<3x3xi32> = dense<[[-3, -10, -3], [0, 0, 0], [3, 10, 3]]>
+  memref.global @score : memref<512x512xi32> = uninitialized
+  func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+    %c4_i32 = arith.constant 4 : i32
+    %c0_i32 = arith.constant 0 : i32
+    %alloca = memref.alloca() : memref<512x512xi32>
+    %alloca_0 = memref.alloca() : memref<512x512xi32>
+    %alloca_1 = memref.alloca() : memref<512x512xi32>
+    %alloca_2 = memref.alloca() : memref<516x516xi32>
+    %alloca_3 = memref.alloca() : memref<516x516xi32>
+    %alloca_4 = memref.alloca() : memref<518x518xi32>
+    %0 = memref.get_global @_ZL8coeffs_x : memref<3x3xi32>
+    %1 = memref.get_global @_ZL8coeffs_y : memref<3x3xi32>
+    affine.for %arg0 = 0 to 516 {
+      affine.for %arg1 = 0 to 516 {
+        %3:2 = affine.for %arg2 = 0 to 3 iter_args(%arg3 = %c0_i32, %arg4 = %c0_i32) -> (i32, i32) {
+          %4:2 = affine.for %arg5 = 0 to 3 iter_args(%arg6 = %arg3, %arg7 = %arg4) -> (i32, i32) {
+            %5 = affine.load %alloca_4[%arg0 + %arg2, %arg1 + %arg5] : memref<518x518xi32>
+            %6 = affine.load %0[%arg2, %arg5] : memref<3x3xi32>
+            %7 = arith.muli %5, %6 : i32
+            %8 = arith.addi %arg7, %7 : i32
+            %9 = affine.load %1[%arg2, %arg5] : memref<3x3xi32>
+            %10 = arith.muli %5, %9 : i32
+            %11 = arith.addi %arg6, %10 : i32
+            affine.yield %11, %8 : i32, i32
+          }
+          affine.yield %4#0, %4#1 : i32, i32
+        }
+        affine.store %3#1, %alloca_3[%arg0, %arg1] : memref<516x516xi32>
+        affine.store %3#0, %alloca_2[%arg0, %arg1] : memref<516x516xi32>
+      }
+    }
+    affine.for %arg0 = 0 to 512 {
+      affine.for %arg1 = 0 to 512 {
+        %3:3 = affine.for %arg2 = 0 to 5 iter_args(%arg3 = %c0_i32, %arg4 = %c0_i32, %arg5 = %c0_i32) -> (i32, i32, i32) {
+          %4:3 = affine.for %arg6 = 0 to 5 iter_args(%arg7 = %arg3, %arg8 = %arg4, %arg9 = %arg5) -> (i32, i32, i32) {
+            %5 = affine.load %alloca_3[%arg0 + %arg2, %arg1 + %arg6] : memref<516x516xi32>
+            %6 = affine.load %alloca_2[%arg0 + %arg2, %arg1 + %arg6] : memref<516x516xi32>
+            %7 = arith.muli %5, %5 : i32
+            %8 = arith.addi %arg9, %7 : i32
+            %9 = arith.muli %6, %6 : i32
+            %10 = arith.addi %arg8, %9 : i32
+            %11 = arith.muli %5, %6 : i32
+            %12 = arith.addi %arg7, %11 : i32
+            affine.yield %12, %10, %8 : i32, i32, i32
           }
+          affine.yield %4#0, %4#1, %4#2 : i32, i32, i32
         }
+        affine.store %3#2, %alloca_1[%arg0, %arg1] : memref<512x512xi32>
+        affine.store %3#1, %alloca_0[%arg0, %arg1] : memref<512x512xi32>
+        affine.store %3#0, %alloca[%arg0, %arg1] : memref<512x512xi32>
+      }
+    }
+    %2 = memref.get_global @score : memref<512x512xi32>
+    affine.for %arg0 = 0 to 512 {
+      affine.for %arg1 = 0 to 512 {
+        %3 = affine.load %alloca_1[%arg0, %arg1] : memref<512x512xi32>
+        %4 = affine.load %alloca_0[%arg0, %arg1] : memref<512x512xi32>
+        %5 = affine.load %alloca[%arg0, %arg1] : memref<512x512xi32>
+        %6 = arith.muli %3, %4 : i32
+        %7 = arith.muli %5, %5 : i32
+        %8 = arith.subi %6, %7 : i32
+        %9 = arith.addi %3, %4 : i32
+        %10 = arith.muli %9, %c4_i32 : i32
+        %11 = arith.muli %10, %9 : i32
+        %12 = arith.subi %8, %11 : i32
+        affine.store %12, %2[%arg0, %arg1] : memref<512x512xi32>
+      }
+    }
+    return %c0_i32 : i32
+  }
+}
+
+module @harris_score_with_gradient_extra_kernel {
+  memref.global "private" @_ZL8coeffs_1 : memref<5x5xi32> = dense<1>
+  memref.global "private" @_ZL8coeffs_y : memref<3x3xi32> = dense<[[-3, -10, -3], [0, 0, 0], [3, 10, 3]]>
+  memref.global "private" @_ZL8coeffs_x : memref<3x3xi32> = dense<[[-3, -10, -3], [0, 0, 0], [3, 10, 3]]>
+  memref.global @score : memref<512x512xi32> = uninitialized
+  func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+    %c4_i32 = arith.constant 4 : i32
+    %c0_i32 = arith.constant 0 : i32
+    %alloca = memref.alloca() : memref<512x512xi32>
+    %alloca_0 = memref.alloca() : memref<512x512xi32>
+    %alloca_1 = memref.alloca() : memref<512x512xi32>
+    %alloca_2 = memref.alloca() : memref<516x516xi32>
+    %alloca_3 = memref.alloca() : memref<516x516xi32>
+    %alloca_4 = memref.alloca() : memref<518x518xi32>
+    %0 = memref.get_global @_ZL8coeffs_x : memref<3x3xi32>
+    %1 = memref.get_global @_ZL8coeffs_y : memref<3x3xi32>
+    affine.for %arg0 = 0 to 516 {
+      affine.for %arg1 = 0 to 516 {
+        %4:2 = affine.for %arg2 = 0 to 3 iter_args(%arg3 = %c0_i32, %arg4 = %c0_i32) -> (i32, i32) {
+          %5:2 = affine.for %arg5 = 0 to 3 iter_args(%arg6 = %arg3, %arg7 = %arg4) -> (i32, i32) {
+            %6 = affine.load %alloca_4[%arg0 + %arg2, %arg1 + %arg5] : memref<518x518xi32>
+            %7 = affine.load %0[%arg2, %arg5] : memref<3x3xi32>
+            %8 = arith.muli %6, %7 : i32
+            %9 = arith.addi %arg7, %8 : i32
+            %10 = affine.load %1[%arg2, %arg5] : memref<3x3xi32>
+            %11 = arith.muli %6, %10 : i32
+            %12 = arith.addi %arg6, %11 : i32
+            affine.yield %12, %9 : i32, i32
+          }
+          affine.yield %5#0, %5#1 : i32, i32
+        }
+        affine.store %4#1, %alloca_3[%arg0, %arg1] : memref<516x516xi32>
+        affine.store %4#0, %alloca_2[%arg0, %arg1] : memref<516x516xi32>
+      }
+    }
+    %2 = memref.get_global @_ZL8coeffs_1 : memref<5x5xi32>
+    affine.for %arg0 = 0 to 512 {
+      affine.for %arg1 = 0 to 512 {
+        %4:3 = affine.for %arg2 = 0 to 5 iter_args(%arg3 = %c0_i32, %arg4 = %c0_i32, %arg5 = %c0_i32) -> (i32, i32, i32) {
+          %5:3 = affine.for %arg6 = 0 to 5 iter_args(%arg7 = %arg3, %arg8 = %arg4, %arg9 = %arg5) -> (i32, i32, i32) {
+            %6 = affine.load %alloca_3[%arg0 + %arg2, %arg1 + %arg6] : memref<516x516xi32>
+            %7 = affine.load %alloca_2[%arg0 + %arg2, %arg1 + %arg6] : memref<516x516xi32>
+            %8 = arith.muli %6, %6 : i32
+            %9 = affine.load %2[%arg2, %arg6] : memref<5x5xi32>
+            %10 = arith.muli %8, %9 : i32
+            %11 = arith.addi %arg9, %10 : i32
+            %12 = arith.muli %7, %7 : i32
+            %13 = arith.muli %12, %9 : i32
+            %14 = arith.addi %arg8, %13 : i32
+            %15 = arith.muli %6, %7 : i32
+            %16 = arith.muli %15, %9 : i32
+            %17 = arith.addi %arg7, %16 : i32
+            affine.yield %17, %14, %11 : i32, i32, i32
+          }
+          affine.yield %5#0, %5#1, %5#2 : i32, i32, i32
+        }
+        affine.store %4#2, %alloca_1[%arg0, %arg1] : memref<512x512xi32>
+        affine.store %4#1, %alloca_0[%arg0, %arg1] : memref<512x512xi32>
+        affine.store %4#0, %alloca[%arg0, %arg1] : memref<512x512xi32>
+      }
+    }
+    %3 = memref.get_global @score : memref<512x512xi32>
+    affine.for %arg0 = 0 to 512 {
+      affine.for %arg1 = 0 to 512 {
+        %4 = affine.load %alloca_1[%arg0, %arg1] : memref<512x512xi32>
+        %5 = affine.load %alloca_0[%arg0, %arg1] : memref<512x512xi32>
+        %6 = affine.load %alloca[%arg0, %arg1] : memref<512x512xi32>
+        %7 = arith.muli %4, %5 : i32
+        %8 = arith.muli %6, %6 : i32
+        %9 = arith.subi %7, %8 : i32
+        %10 = arith.addi %4, %5 : i32
+        %11 = arith.muli %10, %c4_i32 : i32
+        %12 = arith.muli %11, %10 : i32
+        %13 = arith.subi %9, %12 : i32
+        affine.store %13, %3[%arg0, %arg1] : memref<512x512xi32>
       }
     }
     return %c0_i32 : i32
diff --git a/test/polygeist-opt/lower-kernel-launch-aten-phase1.mlir b/test/polygeist-opt/lower-kernel-launch-aten-phase1.mlir
new file mode 100644
index 000000000000..905825147446
--- /dev/null
+++ b/test/polygeist-opt/lower-kernel-launch-aten-phase1.mlir
@@ -0,0 +1,84 @@
+// RUN: polygeist-opt --lower-kernel-launch-to-cublas %s | FileCheck %s
+
+#window = affine_map<(d0,d1,d2,d3,d4,d5,d6,d7) ->
+                     (d4, d5 + d1, d6 + d2, d7 + d3)>
+
+module {
+  kernel.defn @cublasDgemm_outer_product(
+      %u: tensor, %v: tensor, %c: tensor)
+      -> tensor {
+    kernel.yield %c : tensor
+  }
+
+  kernel.defn @cublasSgemm_strided_batched_broadcast_rhs(
+      %a: tensor, %b: tensor,
+      %c: tensor) -> tensor {
+    kernel.yield %c : tensor
+  }
+
+  kernel.defn @cudnnConvolution3D_f32_bias(
+      %window: tensor,
+      %filter: tensor, %bias: tensor,
+      %out: tensor) -> tensor {
+    kernel.yield %out : tensor
+  }
+
+  kernel.defn @cudaCopy1D_f32_tensor(
+      %src: tensor, %out: tensor) -> tensor {
+    kernel.yield %out : tensor
+  }
+
+  // CHECK-LABEL: func.func @outer
+  // CHECK: call @polygeist_cublas_dgemm_outer_product
+  func.func @outer(%u: tensor, %v: tensor,
+                   %c: tensor) -> tensor {
+    %0 = kernel.launch @cublasDgemm_outer_product(%u, %v, %c)
+        : (tensor, tensor, tensor)
+          -> tensor
+    return %0 : tensor
+  }
+
+  // CHECK-LABEL: func.func @broadcast_bmm
+  // CHECK: call @polygeist_cublas_sgemm_strided_batched_broadcast_rhs
+  func.func @broadcast_bmm(%a: tensor, %b: tensor,
+                           %c: tensor) -> tensor {
+    %0 = kernel.launch @cublasSgemm_strided_batched_broadcast_rhs(%a, %b, %c)
+        : (tensor, tensor, tensor)
+          -> tensor
+    return %0 : tensor
+  }
+
+  // CHECK-LABEL: func.func @conv3d_bias
+  // CHECK: call @polygeist_cudnn_conv3d_channels_f32
+  func.func @conv3d_bias(
+      %input: tensor, %filter: tensor,
+      %bias: tensor, %out: tensor,
+      %oc: index, %od: index, %oh: index, %ow: index,
+      %ic: index, %kd: index, %kh: index, %kw: index)
+      -> tensor {
+    %window = polygeist.submap(
+        %input, %oc, %od, %oh, %ow, %ic, %kd, %kh, %kw) {map = #window}
+        : (tensor, index, index, index, index,
+           index, index, index, index) -> tensor
+    %0 = kernel.launch @cudnnConvolution3D_f32_bias(
+        %window, %filter, %bias, %out)
+        : (tensor, tensor,
+           tensor, tensor) -> tensor
+    return %0 : tensor
+  }
+
+  // A rank-reduced column has logical stride 2.  The copy lowering must pass
+  // that stride to the runtime instead of flattening it as contiguous data.
+  // CHECK-LABEL: func.func @strided_copy
+  // CHECK: call @polygeist_cuda_copy_strided_2d_f32
+  func.func @strided_copy(%src: memref, %out: memref,
+                         %n: index) -> tensor {
+    %src_t = bufferization.to_tensor %src restrict : memref
+    %out_t = bufferization.to_tensor %out restrict writable : memref
+    %slice = tensor.extract_slice %src_t[0, 1] [%n, 1] [1, 1]
+        : tensor to tensor
+    %0 = kernel.launch @cudaCopy1D_f32_tensor(%slice, %out_t)
+        : (tensor, tensor) -> tensor
+    return %0 : tensor
+  }
+}
diff --git a/test/polygeist-opt/lower-kernel-launch-cufft.mlir b/test/polygeist-opt/lower-kernel-launch-cufft.mlir
new file mode 100644
index 000000000000..a56099d6bde4
--- /dev/null
+++ b/test/polygeist-opt/lower-kernel-launch-cufft.mlir
@@ -0,0 +1,38 @@
+// RUN: polygeist-opt --lower-kernel-launch-to-cublas %s | FileCheck %s
+
+module {
+  kernel.defn @cufftZ2Z_1D_tensor(
+      %A: tensor,
+      %C: tensor,
+      %inverse: i32) -> tensor {
+    kernel.yield %C : tensor
+  }
+
+  kernel.defn @cufftC2C_1D_tensor(
+      %A: tensor,
+      %C: tensor,
+      %inverse: i32) -> tensor {
+    kernel.yield %C : tensor
+  }
+
+  func.func @z2z(%arg0: tensor,
+                 %arg1: tensor) -> tensor {
+    %inverse = arith.constant 0 : i32
+    %0 = kernel.launch @cufftZ2Z_1D_tensor(%arg0, %arg1, %inverse)
+        : (tensor, tensor, i32) -> tensor
+    return %0 : tensor
+  }
+
+  func.func @c2c(%arg0: tensor,
+                 %arg1: tensor) -> tensor {
+    %inverse = arith.constant 1 : i32
+    %0 = kernel.launch @cufftC2C_1D_tensor(%arg0, %arg1, %inverse)
+        : (tensor, tensor, i32) -> tensor
+    return %0 : tensor
+  }
+}
+
+// CHECK-LABEL: func.func @z2z
+// CHECK: call @polygeist_cufft_z2z_1d
+// CHECK-LABEL: func.func @c2c
+// CHECK: call @polygeist_cufft_c2c_1d
diff --git a/test/polygeist-opt/lower-kernel-launch-cutensornet-f64.mlir b/test/polygeist-opt/lower-kernel-launch-cutensornet-f64.mlir
new file mode 100644
index 000000000000..14c8c0847f22
--- /dev/null
+++ b/test/polygeist-opt/lower-kernel-launch-cutensornet-f64.mlir
@@ -0,0 +1,171 @@
+// RUN: polygeist-opt --lower-kernel-launch-to-cublas %s | FileCheck %s
+
+#psi_a = affine_map<(a, b, c, i, j, k) -> (i + a * 4)>
+#psi_b = affine_map<(a, b, c, i, j, k) -> (j + b * 4)>
+#psi_c = affine_map<(a, b, c, i, j, k) -> (k + c * 4)>
+#u = affine_map<(a, b, c, i, j, k) -> (k + i * 16 + j * 4)>
+#out = affine_map<(a, b, c, i, j, k) -> (c + a * 25 + b * 5)>
+#contract_a = affine_map<(d0, d1, d2, d3, d4) ->
+                         (d0 * 60 + d1 * 20 + d3 * 5 + d4)>
+#contract_b = affine_map<(d0, d1, d2, d3, d4) ->
+                         (d2 * 15 + d3 * 5 + d4)>
+#contract_c = affine_map<(d0, d1, d2, d3) ->
+                         (d0 * 125 + d1 * 25 + d2 * 5 + d3)>
+
+module {
+  kernel.defn @cutensornetTensorProduct3D_f64_tensor(
+      %pa: tensor,
+      %pb: tensor,
+      %pc: tensor,
+      %u: tensor,
+      %out: tensor) -> tensor {
+    kernel.yield %out : tensor
+  }
+
+  kernel.defn @cutensornetContraction2_f64_r5r5r4(
+      %a: tensor,
+      %b: tensor,
+      %c: tensor) -> tensor {
+    kernel.yield %c : tensor
+  }
+
+  kernel.defn @cutensornetContraction2_f64(
+      %a: tensor<*xf64>,
+      %b: tensor<*xf64>,
+      %c: tensor<*xf64>) -> tensor<*xf64> {
+    kernel.yield %c : tensor<*xf64>
+  }
+
+  func.func @tensor_product_f64(
+      %psi: tensor, %u: tensor, %out: tensor,
+      %kq: index, %kp: index) -> tensor {
+    %pa = polygeist.submap(%psi, %kq, %kq, %kq, %kp, %kp, %kp)
+        {map = #psi_a} : (tensor, index, index, index, index, index,
+                          index) -> tensor
+    %pb = polygeist.submap(%psi, %kq, %kq, %kq, %kp, %kp, %kp)
+        {map = #psi_b} : (tensor, index, index, index, index, index,
+                          index) -> tensor
+    %pc = polygeist.submap(%psi, %kq, %kq, %kq, %kp, %kp, %kp)
+        {map = #psi_c} : (tensor, index, index, index, index, index,
+                          index) -> tensor
+    %uv = polygeist.submap(%u, %kq, %kq, %kq, %kp, %kp, %kp)
+        {map = #u} : (tensor, index, index, index, index, index,
+                      index) -> tensor
+    %ov = polygeist.submap(%out, %kq, %kq, %kq, %kp, %kp, %kp)
+        {map = #out} : (tensor, index, index, index, index, index,
+                        index) -> tensor
+    %r = kernel.launch @cutensornetTensorProduct3D_f64_tensor(
+        %pa, %pb, %pc, %uv, %ov)
+        : (tensor, tensor,
+           tensor, tensor,
+           tensor) -> tensor
+    %updated = polygeist.submapInverse(
+        %out, %r, %kq, %kq, %kq, %kp, %kp, %kp) {map = #out}
+        : (tensor, tensor, index, index, index,
+           index, index, index) -> tensor
+    return %updated : tensor
+  }
+
+  func.func @contraction_f64(
+      %a: tensor, %b: tensor, %c: tensor,
+      %n0: index, %n1: index, %n2: index, %n3: index,
+      %nk: index) -> tensor {
+    %av = polygeist.submap(%a, %n0, %n1, %n2, %n3, %nk)
+        {map = #contract_a} : (tensor, index, index, index, index,
+                               index) -> tensor
+    %bv = polygeist.submap(%b, %n0, %n1, %n2, %n3, %nk)
+        {map = #contract_b} : (tensor, index, index, index, index,
+                               index) -> tensor
+    %r = kernel.launch @cutensornetContraction2_f64_r5r5r4(%av, %bv, %c)
+        {contraction_maps = [
+          affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>,
+          affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>,
+          affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]}
+        : (tensor, tensor,
+           tensor) -> tensor
+    return %r : tensor
+  }
+
+  func.func @contraction_f64_generic_2d(
+      %a: tensor, %b: tensor,
+      %c: tensor) -> tensor {
+    %au = tensor.cast %a : tensor to tensor<*xf64>
+    %bu = tensor.cast %b : tensor to tensor<*xf64>
+    %cu = tensor.cast %c : tensor to tensor<*xf64>
+    %ru = kernel.launch @cutensornetContraction2_f64(%au, %bu, %cu)
+        {contraction_maps = [
+          affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>,
+          affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>,
+          affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>]}
+        : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64>
+    %r = tensor.cast %ru : tensor<*xf64> to tensor
+    return %r : tensor
+  }
+
+  func.func @contraction_f64_device(
+      %a: tensor, %b: tensor,
+      %c: tensor) -> tensor {
+    %au = tensor.cast %a : tensor to tensor<*xf64>
+    %bu = tensor.cast %b : tensor to tensor<*xf64>
+    %cu = tensor.cast %c : tensor to tensor<*xf64>
+    %ru = kernel.launch @cutensornetContraction2_f64(%au, %bu, %cu)
+        {contraction_maps = [
+          affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>,
+          affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>,
+          affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>],
+         polygeist.device_resident = true}
+        : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64>
+    %r = tensor.cast %ru : tensor<*xf64> to tensor
+    return %r : tensor
+  }
+
+  // Regression: the runtime updates the rank-1 backing allocation of %cv,
+  // but an ordinary consumer of the launch result expects its rank-4 view.
+  // Lowering must reconstruct that view instead of replacing %r with the
+  // flattened base tensor.
+  func.func @contraction_f64_direct_output_view(
+      %a: tensor, %b: tensor,
+      %c: tensor, %n0: index, %n1: index, %n2: index,
+      %n3: index) -> tensor {
+    %cv = polygeist.submap(%c, %n0, %n1, %n2, %n3)
+        {map = #contract_c} : (tensor, index, index, index, index) ->
+                              tensor
+    %r = kernel.launch @cutensornetContraction2_f64_r5r5r4(%a, %b, %cv)
+        {contraction_maps = [
+          affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>,
+          affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>,
+          affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3)>]}
+        : (tensor, tensor,
+           tensor) -> tensor
+    return %r : tensor
+  }
+}
+
+// CHECK-LABEL: func.func @tensor_product_f64
+// CHECK: %[[KQ:.*]] = arith.index_cast %arg3 : index to i32
+// CHECK: %[[KP:.*]] = arith.index_cast %arg4 : index to i32
+// CHECK: call @polygeist_cutensornet_tensor_product_3d_f64(%[[KQ]], %[[KP]],
+// CHECK-NOT: kernel.launch
+// CHECK-NOT: polygeist.submapInverse
+
+// CHECK-LABEL: func.func @contraction_f64
+// CHECK: memref.alloca() : memref<579xi64>
+// CHECK: call @polygeist_cutensornet_contraction2_f64
+// CHECK-NOT: kernel.launch
+
+// CHECK-LABEL: func.func @contraction_f64_generic_2d
+// CHECK: memref.alloca() : memref<579xi64>
+// CHECK: call @polygeist_cutensornet_contraction2_f64
+// CHECK-NOT: kernel.launch
+
+// CHECK-LABEL: func.func @contraction_f64_device
+// CHECK: call @polygeist_cutensornet_contraction2_f64_device
+// CHECK-NOT: call @polygeist_cutensornet_contraction2_f64(
+// CHECK-NOT: memref.copy
+// CHECK-NOT: kernel.launch
+
+// CHECK-LABEL: func.func @contraction_f64_direct_output_view
+// CHECK: call @polygeist_cutensornet_contraction2_f64
+// CHECK: %[[UPDATED_VIEW:.*]] = polygeist.submap(%{{.*}}, %arg3, %arg4, %arg5, %arg6) {map = #{{.*}}}
+// CHECK: return %[[UPDATED_VIEW]] : tensor
+// CHECK-NOT: kernel.launch
diff --git a/test/polygeist-opt/lower-kernel-launch-cutensornet.mlir b/test/polygeist-opt/lower-kernel-launch-cutensornet.mlir
new file mode 100644
index 000000000000..a107633e39d3
--- /dev/null
+++ b/test/polygeist-opt/lower-kernel-launch-cutensornet.mlir
@@ -0,0 +1,55 @@
+// RUN: polygeist-opt --lower-kernel-launch-to-cublas %s | FileCheck %s
+
+#psi_a = affine_map<(a, b, c, i, j, k) -> (i + a * 4)>
+#psi_b = affine_map<(a, b, c, i, j, k) -> (j + b * 4)>
+#psi_c = affine_map<(a, b, c, i, j, k) -> (k + c * 4)>
+#u = affine_map<(a, b, c, i, j, k) -> (k + i * 16 + j * 4)>
+#out = affine_map<(a, b, c, i, j, k) -> (c + a * 25 + b * 5)>
+
+module {
+  kernel.defn @cutensornetTensorProduct3D_f32_tensor(
+      %pa: tensor,
+      %pb: tensor,
+      %pc: tensor,
+      %u: tensor,
+      %out: tensor) -> tensor {
+    kernel.yield %out : tensor
+  }
+
+  func.func @tensor_product(%psi: tensor, %u: tensor,
+                            %out: tensor, %kq: index, %kp: index)
+      -> tensor {
+    %pa = polygeist.submap(%psi, %kq, %kq, %kq, %kp, %kp, %kp)
+        {map = #psi_a} : (tensor, index, index, index, index, index,
+                          index) -> tensor
+    %pb = polygeist.submap(%psi, %kq, %kq, %kq, %kp, %kp, %kp)
+        {map = #psi_b} : (tensor, index, index, index, index, index,
+                          index) -> tensor
+    %pc = polygeist.submap(%psi, %kq, %kq, %kq, %kp, %kp, %kp)
+        {map = #psi_c} : (tensor, index, index, index, index, index,
+                          index) -> tensor
+    %uv = polygeist.submap(%u, %kq, %kq, %kq, %kp, %kp, %kp)
+        {map = #u} : (tensor, index, index, index, index, index,
+                      index) -> tensor
+    %ov = polygeist.submap(%out, %kq, %kq, %kq, %kp, %kp, %kp)
+        {map = #out} : (tensor, index, index, index, index, index,
+                        index) -> tensor
+    %r = kernel.launch @cutensornetTensorProduct3D_f32_tensor(
+        %pa, %pb, %pc, %uv, %ov)
+        : (tensor, tensor,
+           tensor, tensor,
+           tensor) -> tensor
+    %updated = polygeist.submapInverse(
+        %out, %r, %kq, %kq, %kq, %kp, %kp, %kp) {map = #out}
+        : (tensor, tensor, index, index, index,
+           index, index, index) -> tensor
+    return %updated : tensor
+  }
+}
+
+// CHECK-LABEL: func.func @tensor_product
+// CHECK: %[[KQ:.*]] = arith.index_cast %arg3 : index to i32
+// CHECK: %[[KP:.*]] = arith.index_cast %arg4 : index to i32
+// CHECK: call @polygeist_cutensornet_tensor_product_3d_f32(%[[KQ]], %[[KP]],
+// CHECK-NOT: kernel.launch
+// CHECK-NOT: polygeist.submapInverse
diff --git a/test/polygeist-opt/lower-kernel-launch-device-abi-illegal.mlir b/test/polygeist-opt/lower-kernel-launch-device-abi-illegal.mlir
new file mode 100644
index 000000000000..a6268a023b06
--- /dev/null
+++ b/test/polygeist-opt/lower-kernel-launch-device-abi-illegal.mlir
@@ -0,0 +1,36 @@
+// RUN: not polygeist-opt --lower-kernel-launch-to-cublas %s 2>&1 | FileCheck %s
+
+module {
+  kernel.defn @cutensornetContraction2_f64(
+      %a: tensor<*xf64>, %b: tensor<*xf64>,
+      %c: tensor<*xf64>) -> tensor<*xf64> {
+    kernel.yield %c : tensor<*xf64>
+  }
+
+  func.func @device_with_host_residual(
+      %a: tensor, %b: tensor,
+      %c: tensor) -> tensor {
+    %au = tensor.cast %a : tensor to tensor<*xf64>
+    %bu = tensor.cast %b : tensor to tensor<*xf64>
+    %cu = tensor.cast %c : tensor to tensor<*xf64>
+    %ru = kernel.launch @cutensornetContraction2_f64(%au, %bu, %cu)
+        {contraction_maps = [
+          affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>,
+          affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>,
+          affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)>],
+         polygeist.device_resident = true}
+        : (tensor<*xf64>, tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64>
+    %r = tensor.cast %ru : tensor<*xf64> to tensor
+    %out = linalg.generic {
+      indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>],
+      iterator_types = ["parallel", "parallel", "parallel"]
+    } outs(%r : tensor) {
+    ^bb0(%old: f64):
+      linalg.yield %old : f64
+    } -> tensor
+    return %out : tensor
+  }
+}
+
+// CHECK: error: device-resident cuTensorNet ABI is illegal while residual host tensor computation remains
+// CHECK: note: host operation is here: linalg.generic
diff --git a/test/polygeist-opt/lower-llm-kernel-launches.mlir b/test/polygeist-opt/lower-llm-kernel-launches.mlir
new file mode 100644
index 000000000000..1ca32d6bd27e
--- /dev/null
+++ b/test/polygeist-opt/lower-llm-kernel-launches.mlir
@@ -0,0 +1,183 @@
+// RUN: polygeist-opt --lower-kernel-launch-to-cublas --split-input-file %s | FileCheck %s
+
+module {
+  kernel.defn @rmsnorm_f32(%x: memref, %weight: memref,
+                           %out: memref) {
+    kernel.yield
+  }
+
+  func.func @rms(%x: memref, %weight: memref,
+                 %out: memref) {
+    kernel.launch @rmsnorm_f32(%x, %weight, %out)
+        : (memref, memref, memref) -> ()
+    return
+  }
+}
+
+// CHECK-LABEL: func.func @rms
+// CHECK: call @polygeist_rmsnorm_f32
+// CHECK-SAME: (i32, !llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()
+// CHECK-NOT: kernel.launch
+
+// -----
+
+module {
+  kernel.defn @cublasDgemm(%a: tensor, %b: tensor,
+                           %c: tensor, %beta: f64, %alpha: f64)
+      -> tensor {
+    kernel.yield %c : tensor
+  }
+
+  func.func @dgemm_memref_destination(
+      %a: memref, %b: memref, %c: memref) {
+    %at = bufferization.to_tensor %a : memref
+    %bt = bufferization.to_tensor %b : memref
+    %ct = bufferization.to_tensor %c : memref
+    %c4 = arith.constant 4 : index
+    %as = tensor.extract_slice %at[0, 0] [%c4, %c4] [1, 1]
+      : tensor to tensor
+    %bs = tensor.extract_slice %bt[0, 0] [%c4, %c4] [1, 1]
+      : tensor to tensor
+    %cs = tensor.extract_slice %ct[0, 0] [%c4, %c4] [1, 1]
+      : tensor to tensor
+    %beta = arith.constant 0.0 : f64
+    %alpha = arith.constant 1.0 : f64
+    %r = kernel.launch @cublasDgemm(%as, %bs, %cs, %beta, %alpha)
+      : (tensor, tensor, tensor, f64, f64)
+        -> tensor
+    %out = tensor.insert_slice %r into %ct[0, 0] [%c4, %c4] [1, 1]
+      : tensor into tensor
+    return
+  }
+}
+
+// CHECK-LABEL: func.func @dgemm_memref_destination
+// CHECK-NOT: bufferization.to_memref
+// CHECK-COUNT-3: memref.extract_aligned_pointer_as_index %subview
+// CHECK: call @polygeist_cublas_dgemm
+// CHECK-NOT: tensor.insert_slice
+// CHECK-NOT: memref.copy
+// CHECK-NOT: kernel.launch
+
+// -----
+
+module {
+  kernel.defn @rmsnorm_f32_tensor(%x: tensor,
+                                  %weight: tensor,
+                                  %out: tensor) -> tensor {
+    kernel.yield %out : tensor
+  }
+
+  func.func @rms_tensor(%x: tensor, %weight: tensor,
+                        %out: tensor) -> tensor {
+    %0 = kernel.launch @rmsnorm_f32_tensor(%x, %weight, %out)
+        : (tensor, tensor, tensor) -> tensor
+    return %0 : tensor
+  }
+}
+
+// CHECK-LABEL: func.func @rms_tensor
+// CHECK: call @polygeist_rmsnorm_f32
+// CHECK-SAME: (i32, !llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()
+// CHECK-NOT: kernel.launch
+
+// -----
+
+module {
+  kernel.defn @cudnnSoftmaxForward(%x: memref) {
+    kernel.yield
+  }
+
+  func.func @softmax(%x: memref) {
+    kernel.launch @cudnnSoftmaxForward(%x) : (memref) -> ()
+    return
+  }
+}
+
+// CHECK-LABEL: func.func @softmax
+// CHECK: call @polygeist_cudnn_softmax_forward_f32
+// CHECK-SAME: (i32, !llvm.ptr) -> ()
+// CHECK-NOT: kernel.launch
+
+// -----
+
+module {
+  kernel.defn @cublasSgemv(%A: tensor, %x: tensor,
+                            %y: tensor) -> tensor {
+    kernel.yield %y : tensor
+  }
+
+  func.func @sgemv(%A: tensor, %x: tensor,
+                   %y: tensor) -> tensor {
+    %0 = kernel.launch @cublasSgemv(%A, %x, %y)
+        : (tensor, tensor, tensor) -> tensor
+    return %0 : tensor
+  }
+}
+
+// CHECK-LABEL: func.func @sgemv
+// CHECK: call @polygeist_cublas_sgemv
+// CHECK-SAME: (i32, i32, f32, !llvm.ptr, i32, !llvm.ptr, f32, !llvm.ptr) -> ()
+// CHECK-NOT: kernel.launch
+
+// -----
+
+module {
+  kernel.defn @cublasSgemv(%A: tensor, %x: tensor,
+                            %y: tensor) -> tensor {
+    kernel.yield %y : tensor
+  }
+
+  // Model the C ABI shape used by the ATen extraction: tensors and their
+  // slices are views of the original memref arguments.  Lowering must pass
+  // those buffers directly to cuBLAS instead of materializing tensor copies.
+  func.func @sgemv_memref_views(%A: memref, %x: memref,
+                                %y: memref) {
+    %At = bufferization.to_tensor %A : memref
+    %xt = bufferization.to_tensor %x : memref
+    %yt = bufferization.to_tensor %y : memref
+    %c4 = arith.constant 4 : index
+    %c8 = arith.constant 8 : index
+    %As = tensor.extract_slice %At[0, 0] [%c4, %c8] [1, 1]
+      : tensor to tensor
+    %xs = tensor.extract_slice %xt[0] [%c8] [1]
+      : tensor to tensor
+    %ys = tensor.extract_slice %yt[0] [%c4] [1]
+      : tensor to tensor
+    %r = kernel.launch @cublasSgemv(%As, %xs, %ys)
+      : (tensor, tensor, tensor) -> tensor
+    %out = tensor.insert_slice %r into %yt[0] [%c4] [1]
+      : tensor into tensor
+    return
+  }
+}
+
+// CHECK-LABEL: func.func @sgemv_memref_views
+// CHECK-NOT: bufferization.to_memref
+// CHECK: memref.extract_aligned_pointer_as_index %arg0
+// CHECK: memref.extract_aligned_pointer_as_index %arg1
+// CHECK: memref.extract_aligned_pointer_as_index %arg2
+// CHECK: call @polygeist_cublas_sgemv
+// CHECK-NOT: tensor.insert_slice
+// CHECK-NOT: kernel.launch
+
+// -----
+
+module {
+  kernel.defn @cublasSgemv_T(%A: tensor, %x: tensor,
+                              %y: tensor) -> tensor {
+    kernel.yield %y : tensor
+  }
+
+  func.func @sgemv_t(%A: tensor, %x: tensor,
+                     %y: tensor) -> tensor {
+    %0 = kernel.launch @cublasSgemv_T(%A, %x, %y)
+        : (tensor, tensor, tensor) -> tensor
+    return %0 : tensor
+  }
+}
+
+// CHECK-LABEL: func.func @sgemv_t
+// CHECK: call @polygeist_cublas_sgemv_T
+// CHECK-SAME: (i32, i32, f32, !llvm.ptr, i32, !llvm.ptr, f32, !llvm.ptr) -> ()
+// CHECK-NOT: kernel.launch
diff --git a/test/polygeist-opt/lower-submap-inverse-affine-writeback.mlir b/test/polygeist-opt/lower-submap-inverse-affine-writeback.mlir
new file mode 100644
index 000000000000..0e1fef255a7f
--- /dev/null
+++ b/test/polygeist-opt/lower-submap-inverse-affine-writeback.mlir
@@ -0,0 +1,68 @@
+// RUN: polygeist-opt %s --lower-polygeist-submap | FileCheck %s
+
+#strided_component = affine_map<(d0, d1, d2, d3) ->
+  (d3 + d1 * 12 + d2 * 3 + d0 * 144)>
+
+module {
+  func.func @strided_component_writeback(
+      %base: tensor, %view: tensor) -> tensor {
+    %c2 = arith.constant 2 : index
+    %c3 = arith.constant 3 : index
+    %c4 = arith.constant 4 : index
+    %result = polygeist.submapInverse(
+        %base, %view, %c2, %c4, %c4, %c3) {map = #strided_component} :
+        (tensor, tensor, index, index, index, index) ->
+        tensor
+    return %result : tensor
+  }
+
+  func.func @non_injective_writeback_is_not_scattered(
+      %base: tensor, %view: tensor) -> tensor {
+    %c2 = arith.constant 2 : index
+    %c5 = arith.constant 5 : index
+    %result = polygeist.submapInverse(
+        %base, %view, %c2, %c5) {map = affine_map<(d0, d1) -> (d0)>} :
+        (tensor, tensor, index, index) -> tensor
+    return %result : tensor
+  }
+
+  func.func @non_injective_output_becomes_reduction(
+      %input: memref<2x5xf64>, %output: memref<10xf64>) {
+    %c2 = arith.constant 2 : index
+    %c5 = arith.constant 5 : index
+    %view = polygeist.submap(%output, %c2, %c5)
+        {map = affine_map<(d0, d1) -> (d0)>} :
+        (memref<10xf64>, index, index) -> memref
+    linalg.generic {
+        indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>,
+                         affine_map<(d0, d1) -> (d0, d1)>],
+        iterator_types = ["parallel", "reduction"]}
+        ins(%input : memref<2x5xf64>) outs(%view : memref) {
+    ^bb0(%in: f64, %out: f64):
+      %sum = arith.addf %out, %in : f64
+      linalg.yield %sum : f64
+    }
+    return
+  }
+}
+
+// CHECK-DAG: #[[REDUCED_OUT:map[0-9]+]] = affine_map<(d0, d1) -> (d0)>
+// CHECK-DAG: #[[REDUCTION_IN:map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
+
+// CHECK-LABEL: func.func @strided_component_writeback
+// CHECK-NOT: polygeist.submapInverse
+// CHECK: scf.for
+// CHECK: scf.for
+// CHECK: scf.for
+// CHECK: scf.for
+// CHECK: tensor.extract
+// CHECK: affine.apply
+// CHECK: tensor.insert
+
+// CHECK-LABEL: func.func @non_injective_writeback_is_not_scattered
+// CHECK: polygeist.submapInverse
+
+// CHECK-LABEL: func.func @non_injective_output_becomes_reduction
+// CHECK: linalg.generic
+// CHECK-SAME: indexing_maps = [#[[REDUCTION_IN]], #[[REDUCED_OUT]]]
+// CHECK-SAME: iterator_types = ["parallel", "reduction"]
diff --git a/test/polygeist-opt/nested-iter-args-to-linalg.mlir b/test/polygeist-opt/nested-iter-args-to-linalg.mlir
new file mode 100644
index 000000000000..1bc75c3b54c7
--- /dev/null
+++ b/test/polygeist-opt/nested-iter-args-to-linalg.mlir
@@ -0,0 +1,48 @@
+// RUN: polygeist-opt --remove-iter-args --affine-parallelize --raise-affine-to-linalg-pipeline --lower-polygeist-submap %s | FileCheck %s
+
+module {
+  func.func @tensor_product_3d(%psi: memref, %u: memref,
+                               %out: memref) {
+    %zero = arith.constant 0.0 : f32
+    affine.for %qi = 0 to 5 {
+      affine.for %qj = 0 to 5 {
+        affine.for %qk = 0 to 5 {
+          %sum_i = affine.for %i = 0 to 4
+              iter_args(%acc_i = %zero) -> (f32) {
+            %psi_i = affine.load %psi[%i + %qi * 4] : memref
+            %sum_j = affine.for %j = 0 to 4
+                iter_args(%acc_j = %acc_i) -> (f32) {
+              %psi_j = affine.load %psi[%j + %qj * 4] : memref
+              %partial = arith.mulf %psi_i, %psi_j : f32
+              %sum_k = affine.for %k = 0 to 4
+                  iter_args(%acc_k = %acc_j) -> (f32) {
+                %psi_k = affine.load %psi[%k + %qk * 4] : memref
+                %u_ijk = affine.load %u[%k + %i * 16 + %j * 4]
+                    : memref
+                %term0 = arith.mulf %partial, %psi_k : f32
+                %term1 = arith.mulf %term0, %u_ijk : f32
+                %next = arith.addf %acc_k, %term1 : f32
+                affine.yield %next : f32
+              }
+              affine.yield %sum_k : f32
+            }
+            affine.yield %sum_j : f32
+          }
+          affine.store %sum_i, %out[%qk + %qi * 25 + %qj * 5]
+              : memref
+        }
+      }
+    }
+    return
+  }
+}
+
+// CHECK-LABEL: func.func @tensor_product_3d
+// CHECK-NOT: memref.alloca
+// CHECK-NOT: affine.for
+// CHECK: linalg.generic
+// CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel"]
+// CHECK: linalg.generic
+// CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]
+// CHECK-NOT: affine.for
+// CHECK-NOT: memref.alloca
diff --git a/test/polygeist-opt/raise-additive-reduction-epilogue.mlir b/test/polygeist-opt/raise-additive-reduction-epilogue.mlir
new file mode 100644
index 000000000000..51e464d6c497
--- /dev/null
+++ b/test/polygeist-opt/raise-additive-reduction-epilogue.mlir
@@ -0,0 +1,58 @@
+// RUN: polygeist-opt --raise-affine-to-linalg %s | FileCheck %s
+
+module {
+  func.func @fuse_additive_epilogue(%input: memref<4x5xf64>,
+                                    %output: memref<4xf64>) {
+    %zero = arith.constant 0.0 : f64
+    affine.for %i = 0 to 4 {
+      %scratch = memref.alloca() : memref
+      affine.store %zero, %scratch[] : memref
+      affine.for %k = 0 to 5 {
+        %acc = affine.load %scratch[] : memref
+        %value = affine.load %input[%i, %k] : memref<4x5xf64>
+        %partial = arith.addf %acc, %value : f64
+        // Keep the accumulator below a same-combiner tree rather than as a
+        // direct operand of the yielded value.
+        %next = arith.addf %partial, %value : f64
+        affine.store %next, %scratch[] : memref
+      }
+      %sum = affine.load %scratch[] : memref
+      %old = affine.load %output[%i] : memref<4xf64>
+      %new = arith.addf %old, %sum : f64
+      affine.store %new, %output[%i] : memref<4xf64>
+    }
+    return
+  }
+
+  func.func @keep_nonadditive_epilogue(%input: memref<4x5xf64>,
+                                       %output: memref<4xf64>) {
+    %zero = arith.constant 0.0 : f64
+    affine.for %i = 0 to 4 {
+      %scratch = memref.alloca() : memref
+      affine.store %zero, %scratch[] : memref
+      affine.for %k = 0 to 5 {
+        %acc = affine.load %scratch[] : memref
+        %value = affine.load %input[%i, %k] : memref<4x5xf64>
+        %next = arith.addf %acc, %value : f64
+        affine.store %next, %scratch[] : memref
+      }
+      %sum = affine.load %scratch[] : memref
+      %old = affine.load %output[%i] : memref<4xf64>
+      %new = arith.mulf %old, %sum : f64
+      affine.store %new, %output[%i] : memref<4xf64>
+    }
+    return
+  }
+}
+
+// CHECK-LABEL: func.func @fuse_additive_epilogue
+// CHECK-NOT: affine.for
+// CHECK: linalg.generic
+// CHECK-SAME: iterator_types = ["parallel", "reduction"]
+// CHECK-NOT: memref.alloca() : memref
+// CHECK: return
+
+// CHECK-LABEL: func.func @keep_nonadditive_epilogue
+// CHECK: affine.for
+// CHECK: arith.mulf
+// CHECK: return
diff --git a/test/polygeist-opt/raise-ikj-scalar-load.mlir b/test/polygeist-opt/raise-ikj-scalar-load.mlir
new file mode 100644
index 000000000000..8ef8318f1b95
--- /dev/null
+++ b/test/polygeist-opt/raise-ikj-scalar-load.mlir
@@ -0,0 +1,32 @@
+// RUN: polygeist-opt --raise-affine-to-linalg %s | FileCheck %s
+
+module {
+  func.func @ikj_promotes_scalar_load(%A: memref<8x3xf32>,
+                                      %B: memref<3x16xf32>,
+                                      %C: memref<8x16xf32>) {
+    %alpha = arith.constant 1.000000e+00 : f32
+    affine.for %i = 0 to 8 {
+      affine.for %k = 0 to 3 {
+        %a = affine.load %A[%i, %k] : memref<8x3xf32>
+        %a_part = arith.mulf %alpha, %a : f32
+        affine.for %j = 0 to 16 {
+          %b = affine.load %B[%k, %j] : memref<3x16xf32>
+          %c = affine.load %C[%i, %j] : memref<8x16xf32>
+          %mul = arith.mulf %a_part, %b : f32
+          %sum = arith.addf %c, %mul : f32
+          affine.store %sum, %C[%i, %j] : memref<8x16xf32>
+        }
+      }
+    }
+    return
+  }
+}
+
+// CHECK-LABEL: func.func @ikj_promotes_scalar_load
+// CHECK-NOT: affine.for
+// CHECK: linalg.generic
+// CHECK-SAME: iterator_types = ["parallel", "reduction", "parallel"]
+// CHECK: arith.mulf
+// CHECK: linalg.yield
+// CHECK-NOT: affine.for
+// CHECK: return
diff --git a/test/polygeist-opt/raise-indexed-gather.mlir b/test/polygeist-opt/raise-indexed-gather.mlir
new file mode 100644
index 000000000000..fe796da41bee
--- /dev/null
+++ b/test/polygeist-opt/raise-indexed-gather.mlir
@@ -0,0 +1,25 @@
+// RUN: polygeist-opt --raise-affine-to-linalg-pipeline %s | FileCheck %s
+
+module {
+  // CHECK-LABEL: func.func @gather
+  // CHECK-NOT: affine.for
+  // CHECK: linalg.generic
+  // CHECK: linalg.index 0
+  // CHECK: linalg.index 1
+  // CHECK: memref.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<8x16xi32>
+  // CHECK: memref.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<8x32xf32>
+  // CHECK: linalg.yield
+  func.func @gather(%input: memref<8x32xf32>,
+                    %indices: memref<8x16xi32>,
+                    %output: memref<8x16xf32>) {
+    affine.for %i = 0 to 8 {
+      affine.for %j = 0 to 16 {
+        %selected = affine.load %indices[%i, %j] : memref<8x16xi32>
+        %k = arith.index_cast %selected : i32 to index
+        %value = memref.load %input[%i, %k] : memref<8x32xf32>
+        affine.store %value, %output[%i, %j] : memref<8x16xf32>
+      }
+    }
+    return
+  }
+}
diff --git a/test/polygeist-opt/raise-libm-pointwise.mlir b/test/polygeist-opt/raise-libm-pointwise.mlir
new file mode 100644
index 000000000000..98e3129b2ef4
--- /dev/null
+++ b/test/polygeist-opt/raise-libm-pointwise.mlir
@@ -0,0 +1,53 @@
+// RUN: polygeist-opt --raise-affine-to-linalg-pipeline %s | FileCheck %s
+
+module {
+  // CHECK-LABEL: func.func @cos_pointwise
+  // CHECK-NOT: affine.for
+  // CHECK: linalg.generic
+  // CHECK: math.cos
+  // CHECK: linalg.yield
+  func.func @cos_pointwise(%input: memref<32xf32>,
+                           %output: memref<32xf32>) {
+    affine.for %i = 0 to 32 {
+      %x = affine.load %input[%i] : memref<32xf32>
+      %y = func.call @cosf(%x) : (f32) -> f32
+      affine.store %y, %output[%i] : memref<32xf32>
+    }
+    return
+  }
+
+  // CHECK-LABEL: func.func @atan2_pointwise
+  // CHECK-NOT: affine.for
+  // CHECK: linalg.generic
+  // CHECK: math.atan2
+  func.func @atan2_pointwise(%lhs: memref<32xf32>, %rhs: memref<32xf32>,
+                             %output: memref<32xf32>) {
+    affine.for %i = 0 to 32 {
+      %x = affine.load %lhs[%i] : memref<32xf32>
+      %y = affine.load %rhs[%i] : memref<32xf32>
+      %z = func.call @atan2f(%x, %y) : (f32, f32) -> f32
+      affine.store %z, %output[%i] : memref<32xf32>
+    }
+    return
+  }
+
+  // No Math dialect op exists for acos in this MLIR revision.  It is still
+  // a standardized pure libm call and can safely live in a linalg body.
+  // CHECK-LABEL: func.func @acos_pointwise
+  // CHECK-NOT: affine.for
+  // CHECK: linalg.generic
+  // CHECK: func.call @acosf
+  func.func @acos_pointwise(%input: memref<32xf32>,
+                            %output: memref<32xf32>) {
+    affine.for %i = 0 to 32 {
+      %x = affine.load %input[%i] : memref<32xf32>
+      %y = func.call @acosf(%x) : (f32) -> f32
+      affine.store %y, %output[%i] : memref<32xf32>
+    }
+    return
+  }
+
+  func.func private @cosf(f32) -> f32
+  func.func private @atan2f(f32, f32) -> f32
+  func.func private @acosf(f32) -> f32
+}
diff --git a/test/polygeist-opt/raise-loop-local-scratch.mlir b/test/polygeist-opt/raise-loop-local-scratch.mlir
new file mode 100644
index 000000000000..1a2cf7b69ee4
--- /dev/null
+++ b/test/polygeist-opt/raise-loop-local-scratch.mlir
@@ -0,0 +1,33 @@
+// RUN: polygeist-opt --raise-affine-to-linalg-pipeline %s | FileCheck %s
+
+module {
+  // A C local accumulator becomes a scalar alloca inside each output
+  // iteration after the inner reduction has already raised.  Expand it into
+  // one private slot per outer iteration so distribution can separate the
+  // initializer, reduction, and epilogue and raise the outer loop too.
+  func.func @loop_local_reduction_then_epilogue(
+      %input: memref<8x16xf32>, %output: memref<8xf32>) {
+    %zero = arith.constant 0.0 : f32
+    %scale = arith.constant 1.600000e+01 : f32
+    affine.for %i = 0 to 8 {
+      %scratch = memref.alloca() : memref
+      affine.store %zero, %scratch[] : memref
+      affine.for %j = 0 to 16 {
+        %in = affine.load %input[%i, %j] : memref<8x16xf32>
+        %old = affine.load %scratch[] : memref
+        %next = arith.addf %old, %in : f32
+        affine.store %next, %scratch[] : memref
+      }
+      %sum = affine.load %scratch[] : memref
+      %mean = arith.divf %sum, %scale : f32
+      affine.store %mean, %output[%i] : memref<8xf32>
+    } {polygeist.was_parallel}
+    return
+  }
+}
+
+// CHECK-LABEL: func.func @loop_local_reduction_then_epilogue
+// CHECK-NOT: affine.for
+// CHECK-NOT: memref.alloca() : memref
+// CHECK: linalg.generic
+// CHECK: linalg.generic
diff --git a/test/polygeist-opt/raise-store-to-load-forwarding.mlir b/test/polygeist-opt/raise-store-to-load-forwarding.mlir
new file mode 100644
index 000000000000..d72e2bf83381
--- /dev/null
+++ b/test/polygeist-opt/raise-store-to-load-forwarding.mlir
@@ -0,0 +1,39 @@
+// RUN: polygeist-opt %s --remove-iter-args --affine-parallelize \
+// RUN:   --raise-affine-to-linalg-pipeline | FileCheck %s
+
+module {
+  // A later load from r[i] must observe the value stored earlier in the same
+  // iteration.  Making that load another linalg input would instead expose
+  // the pre-iteration value and silently corrupt the dot-product reduction.
+  func.func @pcg_step(%ap: memref<32xf64>,
+                      %inv_diag: memref<32xf64>,
+                      %x: memref<32xf64>,
+                      %r: memref<32xf64>,
+                      %z: memref<32xf64>,
+                      %alpha: f64) -> f64 {
+    %zero = arith.constant 0.0 : f64
+    %sum = affine.for %i = 0 to 32 iter_args(%acc = %zero) -> f64 {
+      %ap_i = affine.load %ap[%i] : memref<32xf64>
+      %scaled = arith.mulf %alpha, %ap_i : f64
+      %old_r = affine.load %r[%i] : memref<32xf64>
+      %new_r = arith.subf %old_r, %scaled : f64
+      affine.store %new_r, %r[%i] : memref<32xf64>
+      %diag = affine.load %inv_diag[%i] : memref<32xf64>
+      %new_z = arith.mulf %diag, %new_r : f64
+      affine.store %new_z, %z[%i] : memref<32xf64>
+      %reloaded_r = affine.load %r[%i] : memref<32xf64>
+      %product = arith.mulf %reloaded_r, %new_z : f64
+      %next = arith.addf %acc, %product : f64
+      affine.yield %next : f64
+    }
+    return %sum : f64
+  }
+}
+
+// CHECK-LABEL: func.func @pcg_step
+// CHECK: linalg.generic
+// CHECK: ^bb0(%[[AP:[A-Za-z0-9_]+]]: f64, %[[DIAG:[A-Za-z0-9_]+]]: f64, %[[OLD_R:[A-Za-z0-9_]+]]: f64, %[[OLD_Z:[A-Za-z0-9_]+]]: f64, %[[ACC:[A-Za-z0-9_]+]]: f64):
+// CHECK: %[[NEW_R:.*]] = arith.subf %[[OLD_R]],
+// CHECK: %[[NEW_Z:.*]] = arith.mulf {{.*}}, %[[NEW_R]]
+// CHECK: %[[PRODUCT:.*]] = arith.mulf %[[NEW_R]], %[[NEW_Z]]
+// CHECK: arith.addf %[[ACC]], %[[PRODUCT]]
diff --git a/test/polygeist-opt/raise-to-linalg-disjoint-slices.mlir b/test/polygeist-opt/raise-to-linalg-disjoint-slices.mlir
new file mode 100644
index 000000000000..8877948027fd
--- /dev/null
+++ b/test/polygeist-opt/raise-to-linalg-disjoint-slices.mlir
@@ -0,0 +1,39 @@
+// RUN: polygeist-opt --raise-affine-to-linalg %s | FileCheck %s
+
+module {
+  func.func @constant_offset_slices(%input: memref<5xf64>,
+                                    %output: memref<100xf64>) {
+    affine.for %i = 0 to 5 {
+      %value = affine.load %input[%i] : memref<5xf64>
+      %root = math.sqrt %value : f64
+      affine.store %root, %output[%i] : memref<100xf64>
+      affine.store %root, %output[%i + 25] : memref<100xf64>
+      affine.store %root, %output[%i + 50] : memref<100xf64>
+      affine.store %root, %output[%i + 75] : memref<100xf64>
+    }
+    return
+  }
+
+  // The offset equals the iteration span, so the two address sets overlap at
+  // output[4].  Keep this loop to guard against an unsound same-iteration-only
+  // disjointness check.
+  func.func @overlapping_offset(%input: memref<5xf64>,
+                                %output: memref<10xf64>) {
+    affine.for %i = 0 to 5 {
+      %value = affine.load %input[%i] : memref<5xf64>
+      affine.store %value, %output[%i] : memref<10xf64>
+      affine.store %value, %output[%i + 4] : memref<10xf64>
+    }
+    return
+  }
+}
+
+// CHECK-LABEL: func.func @constant_offset_slices
+// CHECK-NOT: affine.for
+// CHECK: linalg.generic
+// CHECK-SAME: outs({{.*}}, {{.*}}, {{.*}}, {{.*}}
+// CHECK: math.sqrt
+// CHECK: linalg.yield {{.*}}, {{.*}}, {{.*}}, {{.*}} : f64, f64, f64, f64
+
+// CHECK-LABEL: func.func @overlapping_offset
+// CHECK: affine.for
diff --git a/test/polygeist-opt/raised_with_submap.mlir b/test/polygeist-opt/raised_with_submap.mlir
new file mode 100644
index 000000000000..f126b738d0f1
--- /dev/null
+++ b/test/polygeist-opt/raised_with_submap.mlir
@@ -0,0 +1,1097 @@
+#map = affine_map<(d0) -> (d0)>
+#map1 = affine_map<(d0) -> (d0 * 3)>
+#map2 = affine_map<(d0)[s0] -> (s0)>
+#map3 = affine_map<(d0) -> (0)>
+#map4 = affine_map<(d0, d1) -> (d1)>
+#map5 = affine_map<(d0, d1) -> (d0)>
+#map6 = affine_map<(d0, d1) -> (d0, d1)>
+#map7 = affine_map<(d0, d1) -> (d0 * 2 + d1)>
+#map8 = affine_map<(d0, d1) -> (d0 + d1 * 2)>
+#map9 = affine_map<(d0, d1, d2) -> (d2)>
+#map10 = affine_map<(d0, d1, d2) -> (d1)>
+#map11 = affine_map<(d0, d1, d2) -> (d0)>
+#map12 = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
+#map13 = affine_map<(d0, d1, d2) -> (d1 * 4 + d2 + 3)>
+#map14 = affine_map<(d0, d1, d2) -> (d0 + d1 * 7 + 2)>
+#map15 = affine_map<(d0, d1, d2) -> (d0 + d2 * 2)>
+#map16 = affine_map<(d0, d1, d2) -> (d2, d0)>
+#map17 = affine_map<(d0, d1, d2) -> (d0, d1)>
+#map18 = affine_map<(d0, d1, d2) -> (d2, d1)>
+#map19 = affine_map<(d0, d1, d2, d3) -> (d1 + d3, d0 + d2)>
+#map20 = affine_map<(d0, d1, d2, d3) -> (d1, d0)>
+#map21 = affine_map<(d0, d1, d2, d3) -> (d3, d2)>
+#map22 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
+#map23 = affine_map<(d0, d1)[s0, s1] -> (d1 + s0, d0 + s1)>
+#map24 = affine_map<(d0, d1) -> (d1, d0)>
+#map25 = affine_map<(d0, d1)[s0, s1] -> (s0, s1)>
+#map26 = affine_map<(d0)[s0, s1, s2] -> (s0 + s1, d0 + s2)>
+#map27 = affine_map<(d0)[s0] -> (s0, d0)>
+#map28 = affine_map<(d0)[s0, s1] -> (s0, s1)>
+#map29 = affine_map<(d0, d1, d2, d3) -> (d0 + d1 * 3)>
+module {
+  module @constant_access {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref) {
+      %c17 = arith.constant 17 : index
+      %c4 = arith.constant 4 : index
+      %cst = arith.constant 4.000000e+00 : f32
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c17) <{map = #map}> : (memref, index) -> memref
+      %4 = "polygeist.submap"(%alloca, %c17) <{map = #map}> : (memref, index) -> memref
+      linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) {
+      ^bb0(%in: f32, %out: f32):
+        %5 = arith.mulf %in, %cst : f32
+        linalg.yield %5 : f32
+      }
+      return
+    }
+  }
+//  module @constant_mem_access {
+//    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref) {
+//      %c13 = arith.constant 13 : index
+//      %c4 = arith.constant 4 : index
+//      %0 = arith.index_cast %arg1 : i32 to index
+//      %1 = arith.muli %0, %c4 : index
+//      %2 = arith.divui %1, %c4 : index
+//      %alloca = memref.alloca(%2) : memref
+//      %3 = "polygeist.submap"(%arg2, %c13) <{map = #map1}> : (memref, index) -> memref
+//      %4 = "polygeist.submap"(%arg2, %c4, %c13) <{map = #map2}> : (memref, index, index) -> memref
+//      %5 = "polygeist.submap"(%alloca, %c13) <{map = #map}> : (memref, index) -> memref
+//      linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%3, %4 : memref, memref) outs(%5 : memref) {
+//      ^bb0(%in: f32, %in_0: f32, %out: f32):
+//        %6 = arith.mulf %in, %in_0 : f32
+//        linalg.yield %6 : f32
+//      }
+//      return
+//    }
+//  }
+  module @no_if {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref) {
+      %c17 = arith.constant 17 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c17) <{map = #map}> : (memref, index) -> memref
+      %4 = "polygeist.submap"(%alloca, %c17) <{map = #map}> : (memref, index) -> memref
+      linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) {
+      ^bb0(%in: f32, %out: f32):
+        linalg.yield %in : f32
+      }
+      return
+    }
+  }
+  module @arith_mul {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref) {
+      %c17 = arith.constant 17 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c17) <{map = #map}> : (memref, index) -> memref
+      %4 = "polygeist.submap"(%alloca, %c17) <{map = #map}> : (memref, index) -> memref
+      linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) {
+      ^bb0(%in: f32, %out: f32):
+        %5 = arith.mulf %in, %in : f32
+        linalg.yield %5 : f32
+      }
+      return
+    }
+  }
+  module @arith_add {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref) {
+      %c17 = arith.constant 17 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c17) <{map = #map}> : (memref, index) -> memref
+      %4 = "polygeist.submap"(%arg3, %c17) <{map = #map}> : (memref, index) -> memref
+      %5 = "polygeist.submap"(%alloca, %c17) <{map = #map}> : (memref, index) -> memref
+      linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel"]} ins(%3, %4 : memref, memref) outs(%5 : memref) {
+      ^bb0(%in: f32, %in_0: f32, %out: f32):
+        %6 = arith.addf %in, %in_0 : f32
+        %7 = arith.mulf %6, %6 : f32
+        linalg.yield %7 : f32
+      }
+      return
+    }
+  }
+  module @cond_arith {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref) {
+      %c17 = arith.constant 17 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c17) <{map = #map}> : (memref, index) -> memref
+      %4 = "polygeist.submap"(%alloca, %c17) <{map = #map}> : (memref, index) -> memref
+      linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]} ins(%3 : memref) outs(%4 : memref) {
+      ^bb0(%in: f32, %out: f32):
+        %5 = scf.if %arg0 -> (f32) {
+          %6 = arith.mulf %in, %in : f32
+          scf.yield %6 : f32
+        } else {
+          scf.yield %in : f32
+        }
+        linalg.yield %5 : f32
+      }
+      return
+    }
+  }
+  module @reduction {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref) {
+      %c17 = arith.constant 17 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c17) <{map = #map}> : (memref, index) -> memref
+      %4 = "polygeist.submap"(%alloca, %c17) <{map = #map3}> : (memref, index) -> memref
+      linalg.generic {indexing_maps = [#map, #map], iterator_types = ["reduction"]} ins(%3 : memref) outs(%4 : memref) {
+      ^bb0(%in: f32, %out: f32):
+        %5 = arith.addf %out, %in : f32
+        linalg.yield %5 : f32
+      }
+      return
+    }
+  }
+  module @reduction_transformed {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref) {
+      %c17 = arith.constant 17 : index
+      %cst = arith.constant 0.000000e+00 : f32
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %alloca_0 = memref.alloca() : memref<1xf32>
+      affine.store %cst, %alloca_0[0] : memref<1xf32>
+      %3 = "polygeist.submap"(%arg2, %c17) <{map = #map}> : (memref, index) -> memref
+      %4 = "polygeist.submap"(%alloca_0, %c17) <{map = #map3}> : (memref<1xf32>, index) -> memref
+      linalg.generic {indexing_maps = [#map, #map], iterator_types = ["reduction"]} ins(%3 : memref) outs(%4 : memref) {
+      ^bb0(%in: f32, %out: f32):
+        %6 = arith.addf %out, %in : f32
+        linalg.yield %6 : f32
+      }
+      %5 = affine.load %alloca_0[0] : memref<1xf32>
+      affine.store %5, %alloca[0] : memref
+      return
+    }
+  }
+  module @reduction_transformed_simplified {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref) {
+      %c17 = arith.constant 17 : index
+      %cst = arith.constant 0.000000e+00 : f32
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      affine.store %cst, %alloca[0] : memref
+      %3 = "polygeist.submap"(%arg2, %c17) <{map = #map}> : (memref, index) -> memref
+      %4 = "polygeist.submap"(%alloca, %c17) <{map = #map3}> : (memref, index) -> memref
+      linalg.generic {indexing_maps = [#map, #map], iterator_types = ["reduction"]} ins(%3 : memref) outs(%4 : memref) {
+      ^bb0(%in: f32, %out: f32):
+        %5 = arith.addf %out, %in : f32
+        linalg.yield %5 : f32
+      }
+      return
+    }
+  }
+  module @cond_store_1 {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref) {
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      affine.for %arg3 = 0 to 17 {
+        %3 = affine.load %arg2[%arg3] : memref
+        %4 = arith.mulf %3, %3 : f32
+        scf.if %arg0 {
+          affine.store %4, %alloca[%arg3] : memref
+        }
+      }
+      return
+    }
+  }
+  module @cond_store_2 {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref) {
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      affine.for %arg3 = 0 to 17 {
+        %3 = affine.load %arg2[%arg3] : memref
+        scf.if %arg0 {
+          %4 = arith.mulf %3, %3 : f32
+          affine.store %4, %alloca[%arg3] : memref
+        } else {
+          affine.store %3, %alloca[%arg3] : memref
+        }
+      }
+      return
+    }
+  }
+  module @for_within_for {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref) {
+      %c21 = arith.constant 21 : index
+      %c17 = arith.constant 17 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c17, %c21) <{map = #map4}> : (memref, index, index) -> memref
+      %4 = "polygeist.submap"(%arg3, %c17, %c21) <{map = #map5}> : (memref, index, index) -> memref
+      %5 = "polygeist.submap"(%alloca, %c17, %c21) <{map = #map5}> : (memref, index, index) -> memref
+      linalg.generic {indexing_maps = [#map6, #map6, #map6], iterator_types = ["reduction", "parallel"]} ins(%3, %4 : memref, memref) outs(%5 : memref) {
+      ^bb0(%in: f32, %in_0: f32, %out: f32):
+        %6 = arith.mulf %in, %in_0 : f32
+        linalg.yield %6 : f32
+      }
+      return
+    }
+  }
+  module @for_within_for_2 {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref) {
+      %c21 = arith.constant 21 : index
+      %c17 = arith.constant 17 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c17, %c21) <{map = #map7}> : (memref, index, index) -> memref
+      %4 = "polygeist.submap"(%arg3, %c17, %c21) <{map = #map5}> : (memref, index, index) -> memref
+      %5 = "polygeist.submap"(%alloca, %c17, %c21) <{map = #map5}> : (memref, index, index) -> memref
+      linalg.generic {indexing_maps = [#map6, #map6, #map6], iterator_types = ["reduction", "parallel"]} ins(%3, %4 : memref, memref) outs(%5 : memref) {
+      ^bb0(%in: f32, %in_0: f32, %out: f32):
+        %6 = arith.mulf %in, %in_0 : f32
+        linalg.yield %6 : f32
+      }
+      return
+    }
+  }
+  module @for_within_for_3 {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref) {
+      %c21 = arith.constant 21 : index
+      %c17 = arith.constant 17 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c17, %c21) <{map = #map7}> : (memref, index, index) -> memref
+      %4 = "polygeist.submap"(%arg2, %c17, %c21) <{map = #map4}> : (memref, index, index) -> memref
+      %5 = "polygeist.submap"(%arg3, %c17, %c21) <{map = #map5}> : (memref, index, index) -> memref
+      %6 = "polygeist.submap"(%alloca, %c17, %c21) <{map = #map5}> : (memref, index, index) -> memref
+      linalg.generic {indexing_maps = [#map6, #map6, #map6, #map6], iterator_types = ["reduction", "parallel"]} ins(%3, %4, %5 : memref, memref, memref) outs(%6 : memref) {
+      ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32):
+        %7 = arith.mulf %in, %in_0 : f32
+        %8 = arith.mulf %7, %in_1 : f32
+        linalg.yield %8 : f32
+      }
+      return
+    }
+  }
+  module @for_within_for_4 {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref) {
+      %c21 = arith.constant 21 : index
+      %c17 = arith.constant 17 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c17, %c21) <{map = #map8}> : (memref, index, index) -> memref
+      %4 = "polygeist.submap"(%arg3, %c17, %c21) <{map = #map5}> : (memref, index, index) -> memref
+      %5 = "polygeist.submap"(%alloca, %c17, %c21) <{map = #map5}> : (memref, index, index) -> memref
+      linalg.generic {indexing_maps = [#map6, #map6, #map6], iterator_types = ["reduction", "parallel"]} ins(%3, %4 : memref, memref) outs(%5 : memref) {
+      ^bb0(%in: f32, %in_0: f32, %out: f32):
+        %6 = arith.mulf %in, %in_0 : f32
+        linalg.yield %6 : f32
+      }
+      return
+    }
+  }
+  module @for_no_loop_dependency {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref) {
+      %c15 = arith.constant 15 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c15) <{map = #map3}> : (memref, index) -> memref
+      %4 = "polygeist.submap"(%alloca, %c15) <{map = #map3}> : (memref, index) -> memref
+      linalg.generic {indexing_maps = [#map, #map], iterator_types = ["reduction"]} ins(%3 : memref) outs(%4 : memref) {
+      ^bb0(%in: f32, %out: f32):
+        linalg.yield %in : f32
+      }
+      return
+    }
+  }
+  module @for_2_levels_no_loop_dependency {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref) {
+      %c17 = arith.constant 17 : index
+      %c15 = arith.constant 15 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c15, %c17) <{map = #map4}> : (memref, index, index) -> memref
+      %4 = "polygeist.submap"(%alloca, %c15, %c17) <{map = #map4}> : (memref, index, index) -> memref
+      linalg.generic {indexing_maps = [#map6, #map6], iterator_types = ["parallel", "reduction"]} ins(%3 : memref) outs(%4 : memref) {
+      ^bb0(%in: f32, %out: f32):
+        linalg.yield %in : f32
+      }
+      return
+    }
+  }
+  module @for_3_levels_0 {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref) {
+      %c15 = arith.constant 15 : index
+      %c17 = arith.constant 17 : index
+      %c21 = arith.constant 21 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c21, %c17, %c15) <{map = #map9}> : (memref, index, index, index) -> memref
+      %4 = "polygeist.submap"(%arg3, %c21, %c17, %c15) <{map = #map10}> : (memref, index, index, index) -> memref
+      %5 = "polygeist.submap"(%alloca, %c21, %c17, %c15) <{map = #map11}> : (memref, index, index, index) -> memref
+      linalg.generic {indexing_maps = [#map12, #map12, #map12], iterator_types = ["reduction", "reduction", "parallel"]} ins(%3, %4 : memref, memref) outs(%5 : memref) {
+      ^bb0(%in: f32, %in_0: f32, %out: f32):
+        %6 = arith.mulf %in, %in_0 : f32
+        linalg.yield %6 : f32
+      }
+      return
+    }
+  }
+  module @for_3_levels_1 {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref) {
+      %c21 = arith.constant 21 : index
+      %c17 = arith.constant 17 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c17, %c21, %c21) <{map = #map10}> : (memref, index, index, index) -> memref
+      %4 = "polygeist.submap"(%arg3, %c17, %c21, %c21) <{map = #map11}> : (memref, index, index, index) -> memref
+      %5 = "polygeist.submap"(%alloca, %c17, %c21, %c21) <{map = #map11}> : (memref, index, index, index) -> memref
+      linalg.generic {indexing_maps = [#map12, #map12, #map12], iterator_types = ["reduction", "reduction", "parallel"]} ins(%3, %4 : memref, memref) outs(%5 : memref) {
+      ^bb0(%in: f32, %in_0: f32, %out: f32):
+        %6 = arith.mulf %in, %in_0 : f32
+        linalg.yield %6 : f32
+      }
+      return
+    }
+  }
+  module @for_3_levels_2 {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref, %arg4: memref) {
+      %c21 = arith.constant 21 : index
+      %c17 = arith.constant 17 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c21, %c17, %c21) <{map = #map9}> : (memref, index, index, index) -> memref
+      %4 = "polygeist.submap"(%arg3, %c21, %c17, %c21) <{map = #map10}> : (memref, index, index, index) -> memref
+      %5 = "polygeist.submap"(%arg4, %c21, %c17, %c21) <{map = #map11}> : (memref, index, index, index) -> memref
+      %6 = "polygeist.submap"(%alloca, %c21, %c17, %c21) <{map = #map10}> : (memref, index, index, index) -> memref
+      linalg.generic {indexing_maps = [#map12, #map12, #map12, #map12], iterator_types = ["reduction", "parallel", "reduction"]} ins(%3, %4, %5 : memref, memref, memref) outs(%6 : memref) {
+      ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32):
+        %7 = arith.mulf %in, %in_0 : f32
+        %8 = arith.mulf %7, %in_1 : f32
+        linalg.yield %8 : f32
+      }
+      return
+    }
+  }
+  module @for_3_levels_3 {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref) {
+      %c21 = arith.constant 21 : index
+      %c17 = arith.constant 17 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c21, %c17, %c21) <{map = #map9}> : (memref, index, index, index) -> memref
+      %4 = "polygeist.submap"(%arg3, %c21, %c17, %c21) <{map = #map10}> : (memref, index, index, index) -> memref
+      %5 = "polygeist.submap"(%arg3, %c21, %c17, %c21) <{map = #map11}> : (memref, index, index, index) -> memref
+      %6 = "polygeist.submap"(%alloca, %c21, %c17, %c21) <{map = #map10}> : (memref, index, index, index) -> memref
+      linalg.generic {indexing_maps = [#map12, #map12, #map12, #map12], iterator_types = ["reduction", "parallel", "reduction"]} ins(%3, %4, %5 : memref, memref, memref) outs(%6 : memref) {
+      ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32):
+        %7 = arith.mulf %in, %in_0 : f32
+        %8 = arith.mulf %7, %in_1 : f32
+        linalg.yield %8 : f32
+      }
+      return
+    }
+  }
+  module @for_3_levels_4 {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref) {
+      %c21 = arith.constant 21 : index
+      %c17 = arith.constant 17 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c21, %c17, %c21) <{map = #map13}> : (memref, index, index, index) -> memref
+      %4 = "polygeist.submap"(%arg3, %c21, %c17, %c21) <{map = #map14}> : (memref, index, index, index) -> memref
+      %5 = "polygeist.submap"(%arg3, %c21, %c17, %c21) <{map = #map15}> : (memref, index, index, index) -> memref
+      %6 = "polygeist.submap"(%alloca, %c21, %c17, %c21) <{map = #map10}> : (memref, index, index, index) -> memref
+      linalg.generic {indexing_maps = [#map12, #map12, #map12, #map12], iterator_types = ["reduction", "parallel", "reduction"]} ins(%3, %4, %5 : memref, memref, memref) outs(%6 : memref) {
+      ^bb0(%in: f32, %in_0: f32, %in_1: f32, %out: f32):
+        %7 = arith.mulf %in, %in_0 : f32
+        %8 = arith.mulf %7, %in_1 : f32
+        linalg.yield %8 : f32
+      }
+      return
+    }
+  }
+  module @for_within_for2 {
+    func.func @main(%arg0: i1, %arg1: i32, %arg2: memref, %arg3: memref) {
+      %c21 = arith.constant 21 : index
+      %c17 = arith.constant 17 : index
+      %c4 = arith.constant 4 : index
+      %0 = arith.index_cast %arg1 : i32 to index
+      %1 = arith.muli %0, %c4 : index
+      %2 = arith.divui %1, %c4 : index
+      %alloca = memref.alloca(%2) : memref
+      %3 = "polygeist.submap"(%arg2, %c17, %c21) <{map = #map4}> : (memref, index, index) -> memref
+      %4 = "polygeist.submap"(%arg3, %c17, %c21) <{map = #map5}> : (memref, index, index) -> memref
+      %5 = "polygeist.submap"(%alloca, %c17, %c21) <{map = #map5}> : (memref, index, index) -> memref
+      linalg.generic {indexing_maps = [#map6, #map6, #map6], iterator_types = ["reduction", "parallel"]} ins(%3, %4 : memref, memref) outs(%5 : memref) {
+      ^bb0(%in: f32, %in_0: f32, %out: f32):
+        %6 = arith.mulf %in, %in_0 : f32
+        linalg.yield %6 : f32
+      }
+      return
+    }
+  }
+  module @matmul_1 {
+    memref.global @out : memref<32x8xi32> = uninitialized
+    memref.global @im2 : memref<8x8xi32> = uninitialized
+    memref.global @im1 : memref<32x8xi32> = uninitialized
+    func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+      %c32 = arith.constant 32 : index
+      %c8 = arith.constant 8 : index
+      %c0_i32 = arith.constant 0 : i32
+      %0 = memref.get_global @im1 : memref<32x8xi32>
+      %1 = memref.get_global @im2 : memref<8x8xi32>
+      %2 = memref.get_global @out : memref<32x8xi32>
+      %3 = "polygeist.submap"(%0, %c8, %c8, %c32) <{map = #map16}> : (memref<32x8xi32>, index, index, index) -> memref
+      %4 = "polygeist.submap"(%1, %c8, %c8, %c32) <{map = #map17}> : (memref<8x8xi32>, index, index, index) -> memref
+      %5 = "polygeist.submap"(%2, %c8, %c8, %c32) <{map = #map18}> : (memref<32x8xi32>, index, index, index) -> memref
+      linalg.generic {indexing_maps = [#map12, #map12, #map12], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) {
+      ^bb0(%in: i32, %in_0: i32, %out: i32):
+        %6 = arith.muli %in, %in_0 : i32
+        %7 = arith.addi %out, %6 : i32
+        linalg.yield %7 : i32
+      }
+      return %c0_i32 : i32
+    }
+  }
+  module @matmul_2 {
+    memref.global @out : memref<128x32xi32> = uninitialized
+    memref.global @im2 : memref<64x32xi32> = uninitialized
+    memref.global @im1 : memref<128x64xi32> = uninitialized
+    func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+      %c128 = arith.constant 128 : index
+      %c32 = arith.constant 32 : index
+      %c64 = arith.constant 64 : index
+      %c0_i32 = arith.constant 0 : i32
+      %0 = memref.get_global @im1 : memref<128x64xi32>
+      %1 = memref.get_global @im2 : memref<64x32xi32>
+      %2 = memref.get_global @out : memref<128x32xi32>
+      %3 = "polygeist.submap"(%0, %c64, %c32, %c128) <{map = #map16}> : (memref<128x64xi32>, index, index, index) -> memref
+      %4 = "polygeist.submap"(%1, %c64, %c32, %c128) <{map = #map17}> : (memref<64x32xi32>, index, index, index) -> memref
+      %5 = "polygeist.submap"(%2, %c64, %c32, %c128) <{map = #map18}> : (memref<128x32xi32>, index, index, index) -> memref
+      linalg.generic {indexing_maps = [#map12, #map12, #map12], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) {
+      ^bb0(%in: i32, %in_0: i32, %out: i32):
+        %6 = arith.muli %in, %in_0 : i32
+        %7 = arith.addi %out, %6 : i32
+        linalg.yield %7 : i32
+      }
+      return %c0_i32 : i32
+    }
+  }
+  module @conv_1 {
+    memref.global @out : memref<512x64xi32> = uninitialized
+    memref.global @filter : memref<4x4xi32> = uninitialized
+    memref.global @im : memref<515x67xi32> = uninitialized
+    func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+      %c512 = arith.constant 512 : index
+      %c64 = arith.constant 64 : index
+      %c4 = arith.constant 4 : index
+      %c0_i32 = arith.constant 0 : i32
+      %0 = memref.get_global @im : memref<515x67xi32>
+      %1 = memref.get_global @filter : memref<4x4xi32>
+      %2 = memref.get_global @out : memref<512x64xi32>
+      %3 = "polygeist.submap"(%0, %c4, %c4, %c64, %c512) <{map = #map19}> : (memref<515x67xi32>, index, index, index, index) -> memref
+      %4 = "polygeist.submap"(%1, %c4, %c4, %c64, %c512) <{map = #map20}> : (memref<4x4xi32>, index, index, index, index) -> memref
+      %5 = "polygeist.submap"(%2, %c4, %c4, %c64, %c512) <{map = #map21}> : (memref<512x64xi32>, index, index, index, index) -> memref
+      linalg.generic {indexing_maps = [#map22, #map22, #map22], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) {
+      ^bb0(%in: i32, %in_0: i32, %out: i32):
+        %6 = arith.muli %in, %in_0 : i32
+        %7 = arith.addi %out, %6 : i32
+        linalg.yield %7 : i32
+      }
+      return %c0_i32 : i32
+    }
+  }
+  // module @conv_1_reduction_test {
+  //   memref.global @out : memref<512x64xi32> = uninitialized
+  //   memref.global @filter : memref<4x4xi32> = uninitialized
+  //   memref.global @im : memref<515x67xi32> = uninitialized
+  //   func.func @main(%arg0: index, %arg1: index) -> i32 attributes {llvm.linkage = #llvm.linkage} {
+  //     %c4 = arith.constant 4 : index
+  //     %c0_i32 = arith.constant 0 : i32
+  //     %0 = memref.get_global @im : memref<515x67xi32>
+  //     %1 = memref.get_global @filter : memref<4x4xi32>
+  //     %2 = memref.get_global @out : memref<512x64xi32>
+  //     %3 = "polygeist.submap"(%0, %arg0, %arg1, %c4, %c4) <{map = #map23}> : (memref<515x67xi32>, index, index, index, index) -> memref
+  //     %4 = "polygeist.submap"(%1, %c4, %c4) <{map = #map24}> : (memref<4x4xi32>, index, index) -> memref
+  //     %5 = "polygeist.submap"(%2, %arg0, %arg1, %c4, %c4) <{map = #map25}> : (memref<512x64xi32>, index, index, index, index) -> memref
+  //     linalg.generic {indexing_maps = [#map6, #map6, #map6], iterator_types = ["reduction", "reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) {
+  //     ^bb0(%in: i32, %in_0: i32, %out: i32):
+  //       %6 = arith.muli %in, %in_0 : i32
+  //       %7 = arith.addi %out, %6 : i32
+  //       linalg.yield %7 : i32
+  //     }
+  //     return %c0_i32 : i32
+  //   }
+  // }
+  module @conv_2 {
+    memref.global @out : memref<512x64xi32> = uninitialized
+    memref.global @filter : memref<4x4xi32> = uninitialized
+    memref.global @im : memref<515x67xi32> = uninitialized
+    func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+      %c512 = arith.constant 512 : index
+      %c64 = arith.constant 64 : index
+      %c4 = arith.constant 4 : index
+      %c0_i32 = arith.constant 0 : i32
+      %0 = memref.get_global @im : memref<515x67xi32>
+      %1 = memref.get_global @filter : memref<4x4xi32>
+      %2 = memref.get_global @out : memref<512x64xi32>
+      %3 = "polygeist.submap"(%0, %c4, %c4, %c64, %c512) <{map = #map19}> : (memref<515x67xi32>, index, index, index, index) -> memref
+      %4 = "polygeist.submap"(%1, %c4, %c4, %c64, %c512) <{map = #map20}> : (memref<4x4xi32>, index, index, index, index) -> memref
+      %5 = "polygeist.submap"(%2, %c4, %c4, %c64, %c512) <{map = #map21}> : (memref<512x64xi32>, index, index, index, index) -> memref
+      linalg.generic {indexing_maps = [#map22, #map22, #map22], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) {
+      ^bb0(%in: i32, %in_0: i32, %out: i32):
+        %6 = arith.muli %in, %in_0 : i32
+        %7 = arith.addi %out, %6 : i32
+        linalg.yield %7 : i32
+      }
+      return %c0_i32 : i32
+    }
+  }
+  module @box_filter {
+    memref.global @out : memref<512x64xi32> = uninitialized
+    memref.global @filter : memref<4x4xi32> = uninitialized
+    memref.global @im : memref<515x67xi32> = uninitialized
+    func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+      %c512 = arith.constant 512 : index
+      %c64 = arith.constant 64 : index
+      %c4 = arith.constant 4 : index
+      %c0_i32 = arith.constant 0 : i32
+      %0 = memref.get_global @im : memref<515x67xi32>
+      %1 = memref.get_global @out : memref<512x64xi32>
+      %2 = "polygeist.submap"(%0, %c4, %c4, %c64, %c512) <{map = #map19}> : (memref<515x67xi32>, index, index, index, index) -> memref
+      %3 = "polygeist.submap"(%1, %c4, %c4, %c64, %c512) <{map = #map21}> : (memref<512x64xi32>, index, index, index, index) -> memref
+      linalg.generic {indexing_maps = [#map22, #map22], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2 : memref) outs(%3 : memref) {
+      ^bb0(%in: i32, %out: i32):
+        %4 = arith.addi %out, %in : i32
+        linalg.yield %4 : i32
+      }
+      return %c0_i32 : i32
+    }
+  }
+//  module @conv_loop1_test {
+//    memref.global @out : memref<512x64xi32> = uninitialized
+//    memref.global @filter : memref<4x4xi32> = uninitialized
+//    memref.global @im : memref<515x67xi32> = uninitialized
+//    func.func @main(%arg0: index, %arg1: index, %arg2: index) -> i32 attributes {llvm.linkage = #llvm.linkage} {
+//      %c4 = arith.constant 4 : index
+//      %c0_i32 = arith.constant 0 : i32
+//      %0 = memref.get_global @im : memref<515x67xi32>
+//      %1 = memref.get_global @filter : memref<4x4xi32>
+//      %2 = memref.get_global @out : memref<512x64xi32>
+//      %3 = "polygeist.submap"(%0, %arg0, %arg2, %arg1, %c4) <{map = #map26}> : (memref<515x67xi32>, index, index, index, index) -> memref
+//      %4 = "polygeist.submap"(%1, %arg2, %c4) <{map = #map27}> : (memref<4x4xi32>, index, index) -> memref
+//      %5 = "polygeist.submap"(%2, %arg0, %arg1, %c4) <{map = #map28}> : (memref<512x64xi32>, index, index, index) -> memref
+//      linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) {
+//      ^bb0(%in: i32, %in_0: i32, %out: i32):
+//        %6 = arith.muli %in, %in_0 : i32
+//        %7 = arith.addi %out, %6 : i32
+//        linalg.yield %7 : i32
+//      }
+//      return %c0_i32 : i32
+//    }
+//  }
+//  module @submap_test {
+//    memref.global @out : memref<511x64xi32> = uninitialized
+//    memref.global @filter : memref<5x4xi32> = uninitialized
+//    memref.global @im : memref<515x67xi32> = uninitialized
+//    func.func @main(%arg0: index, %arg1: index) -> i32 attributes {llvm.linkage = #llvm.linkage} {
+//      %c5 = arith.constant 5 : index
+//      %c4 = arith.constant 4 : index
+//      %c0_i32 = arith.constant 0 : i32
+//      %0 = memref.get_global @im : memref<515x67xi32>
+//      %1 = memref.get_global @filter : memref<5x4xi32>
+//      %2 = memref.get_global @out : memref<511x64xi32>
+//      %3 = "polygeist.submap"(%0, %arg0, %arg1, %c4, %c5) <{map = #map23}> : (memref<515x67xi32>, index, index, index, index) -> memref
+//      %4 = "polygeist.submap"(%1, %c4, %c5) <{map = #map24}> : (memref<5x4xi32>, index, index) -> memref
+//      %5 = "polygeist.submap"(%2, %arg0, %arg1, %c4, %c5) <{map = #map25}> : (memref<511x64xi32>, index, index, index, index) -> memref
+//      linalg.generic {indexing_maps = [#map6, #map6, #map6], iterator_types = ["reduction", "reduction"]} ins(%3, %4 : memref, memref) outs(%5 : memref) {
+//      ^bb0(%in: i32, %in_0: i32, %out: i32):
+//        %6 = arith.muli %in, %in_0 : i32
+//        %7 = arith.addi %out, %6 : i32
+//        linalg.yield %7 : i32
+//      }
+//      return %c0_i32 : i32
+//    }
+//  }
+  module @harris_score_1 {
+    memref.global @coeffs_y : memref<9xi32> = dense<[-3, -10, -3, 0, 0, 0, 3, 10, 3]>
+    memref.global @coeffs_x : memref<9xi32> = dense<[-3, 0, 3, -10, 0, 10, -3, 0, 3]>
+    memref.global @score : memref<512x512xi32> = uninitialized
+    memref.global @img_ixy : memref<512x512xi32> = uninitialized
+    memref.global @img_iyy : memref<512x512xi32> = uninitialized
+    memref.global @img_ixx : memref<512x512xi32> = uninitialized
+    memref.global @img_in : memref<518x518xi32> = uninitialized
+    memref.global @img_gy : memref<516x516xi32> = uninitialized
+    memref.global @img_gx : memref<516x516xi32> = uninitialized
+    func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+      %c516 = arith.constant 516 : index
+      %c3 = arith.constant 3 : index
+      %c512 = arith.constant 512 : index
+      %c5 = arith.constant 5 : index
+      %c4_i32 = arith.constant 4 : i32
+      %c0_i32 = arith.constant 0 : i32
+      %0 = memref.get_global @img_gx : memref<516x516xi32>
+      %1 = memref.get_global @img_gy : memref<516x516xi32>
+      %2 = memref.get_global @img_in : memref<518x518xi32>
+      %3 = memref.get_global @coeffs_x : memref<9xi32>
+      %4 = memref.get_global @coeffs_y : memref<9xi32>
+      %5 = "polygeist.submap"(%2, %c3, %c3, %c516, %c516) <{map = #map19}> : (memref<518x518xi32>, index, index, index, index) -> memref
+      %6 = "polygeist.submap"(%3, %c3, %c3, %c516, %c516) <{map = #map29}> : (memref<9xi32>, index, index, index, index) -> memref
+      %7 = "polygeist.submap"(%4, %c3, %c3, %c516, %c516) <{map = #map29}> : (memref<9xi32>, index, index, index, index) -> memref
+      %8 = "polygeist.submap"(%0, %c3, %c3, %c516, %c516) <{map = #map21}> : (memref<516x516xi32>, index, index, index, index) -> memref
+      %9 = "polygeist.submap"(%1, %c3, %c3, %c516, %c516) <{map = #map21}> : (memref<516x516xi32>, index, index, index, index) -> memref
+      linalg.generic {indexing_maps = [#map22, #map22, #map22, #map22, #map22], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%5, %6, %7 : memref, memref, memref) outs(%8, %9 : memref, memref) {
+      ^bb0(%in: i32, %in_0: i32, %in_1: i32, %out: i32, %out_2: i32):
+        %23 = arith.muli %in, %in_0 : i32
+        %24 = arith.addi %out, %23 : i32
+        %25 = arith.muli %in, %in_1 : i32
+        %26 = arith.addi %out_2, %25 : i32
+        linalg.yield %24, %26 : i32, i32
+      }
+      %10 = memref.get_global @img_ixx : memref<512x512xi32>
+      %11 = memref.get_global @img_iyy : memref<512x512xi32>
+      %12 = memref.get_global @img_ixy : memref<512x512xi32>
+      %13 = "polygeist.submap"(%0, %c5, %c5, %c512, %c512) <{map = #map19}> : (memref<516x516xi32>, index, index, index, index) -> memref
+      %14 = "polygeist.submap"(%1, %c5, %c5, %c512, %c512) <{map = #map19}> : (memref<516x516xi32>, index, index, index, index) -> memref
+      %15 = "polygeist.submap"(%10, %c5, %c5, %c512, %c512) <{map = #map21}> : (memref<512x512xi32>, index, index, index, index) -> memref
+      %16 = "polygeist.submap"(%11, %c5, %c5, %c512, %c512) <{map = #map21}> : (memref<512x512xi32>, index, index, index, index) -> memref
+      %17 = "polygeist.submap"(%12, %c5, %c5, %c512, %c512) <{map = #map21}> : (memref<512x512xi32>, index, index, index, index) -> memref
+      linalg.generic {indexing_maps = [#map22, #map22, #map22, #map22, #map22], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%13, %14 : memref, memref) outs(%15, %16, %17 : memref, memref, memref) {
+      ^bb0(%in: i32, %in_0: i32, %out: i32, %out_1: i32, %out_2: i32):
+        %23 = arith.muli %in, %in : i32
+        %24 = arith.addi %out, %23 : i32
+        %25 = arith.muli %in_0, %in_0 : i32
+        %26 = arith.addi %out_1, %25 : i32
+        %27 = arith.muli %in, %in_0 : i32
+        %28 = arith.addi %out_2, %27 : i32
+        linalg.yield %24, %26, %28 : i32, i32, i32
+      }
+      %18 = memref.get_global @score : memref<512x512xi32>
+      %19 = "polygeist.submap"(%10, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+      %20 = "polygeist.submap"(%11, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+      %21 = "polygeist.submap"(%12, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+      %22 = "polygeist.submap"(%18, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+      linalg.generic {indexing_maps = [#map6, #map6, #map6, #map6], iterator_types = ["parallel", "parallel"]} ins(%19, %20, %21 : memref, memref, memref) outs(%22 : memref) {
+      ^bb0(%in: i32, %in_0: i32, %in_1: i32, %out: i32):
+        %23 = arith.muli %in, %in_0 : i32
+        %24 = arith.muli %in_1, %in_1 : i32
+        %25 = arith.subi %23, %24 : i32
+        %26 = arith.addi %in, %in_0 : i32
+        %27 = arith.muli %26, %c4_i32 : i32
+        %28 = arith.muli %27, %26 : i32
+        %29 = arith.subi %25, %28 : i32
+        linalg.yield %29 : i32
+      }
+      return %c0_i32 : i32
+    }
+  }
+  module @harris_score_2 {
+    memref.global @coeffs_y : memref<9xi32> = dense<[-3, -10, -3, 0, 0, 0, 3, 10, 3]>
+    memref.global @coeffs_x : memref<9xi32> = dense<[-3, 0, 3, -10, 0, 10, -3, 0, 3]>
+    memref.global @score : memref<512x512xi32> = uninitialized
+    memref.global @img_ixy : memref<512x512xi32> = uninitialized
+    memref.global @img_iyy : memref<512x512xi32> = uninitialized
+    memref.global @img_ixx : memref<512x512xi32> = uninitialized
+    memref.global @img_in : memref<518x518xi32> = uninitialized
+    memref.global @img_gy : memref<516x516xi32> = uninitialized
+    memref.global @img_gx : memref<516x516xi32> = uninitialized
+    func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+      %c516 = arith.constant 516 : index
+      %c3 = arith.constant 3 : index
+      %c512 = arith.constant 512 : index
+      %c5 = arith.constant 5 : index
+      %c4_i32 = arith.constant 4 : i32
+      %c0_i32 = arith.constant 0 : i32
+      %0 = memref.get_global @img_gx : memref<516x516xi32>
+      %1 = memref.get_global @img_gy : memref<516x516xi32>
+      %2 = memref.get_global @img_in : memref<518x518xi32>
+      %3 = memref.get_global @coeffs_x : memref<9xi32>
+      %4 = memref.get_global @coeffs_y : memref<9xi32>
+      %5 = "polygeist.submap"(%2, %c3, %c3, %c516, %c516) <{map = #map19}> : (memref<518x518xi32>, index, index, index, index) -> memref
+      %6 = "polygeist.submap"(%3, %c3, %c3, %c516, %c516) <{map = #map29}> : (memref<9xi32>, index, index, index, index) -> memref
+      %7 = "polygeist.submap"(%4, %c3, %c3, %c516, %c516) <{map = #map29}> : (memref<9xi32>, index, index, index, index) -> memref
+      %8 = "polygeist.submap"(%1, %c3, %c3, %c516, %c516) <{map = #map21}> : (memref<516x516xi32>, index, index, index, index) -> memref
+      %9 = "polygeist.submap"(%0, %c3, %c3, %c516, %c516) <{map = #map21}> : (memref<516x516xi32>, index, index, index, index) -> memref
+      linalg.generic {indexing_maps = [#map22, #map22, #map22, #map22, #map22], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%5, %6, %7 : memref, memref, memref) outs(%8, %9 : memref, memref) {
+      ^bb0(%in: i32, %in_0: i32, %in_1: i32, %out: i32, %out_2: i32):
+        %23 = arith.muli %in, %in_0 : i32
+        %24 = arith.addi %out_2, %23 : i32
+        %25 = arith.muli %in, %in_1 : i32
+        %26 = arith.addi %out, %25 : i32
+        linalg.yield %26, %24 : i32, i32
+      }
+      %10 = memref.get_global @img_ixx : memref<512x512xi32>
+      %11 = memref.get_global @img_iyy : memref<512x512xi32>
+      %12 = memref.get_global @img_ixy : memref<512x512xi32>
+      %13 = "polygeist.submap"(%0, %c5, %c5, %c512, %c512) <{map = #map19}> : (memref<516x516xi32>, index, index, index, index) -> memref
+      %14 = "polygeist.submap"(%1, %c5, %c5, %c512, %c512) <{map = #map19}> : (memref<516x516xi32>, index, index, index, index) -> memref
+      %15 = "polygeist.submap"(%12, %c5, %c5, %c512, %c512) <{map = #map21}> : (memref<512x512xi32>, index, index, index, index) -> memref
+      %16 = "polygeist.submap"(%11, %c5, %c5, %c512, %c512) <{map = #map21}> : (memref<512x512xi32>, index, index, index, index) -> memref
+      %17 = "polygeist.submap"(%10, %c5, %c5, %c512, %c512) <{map = #map21}> : (memref<512x512xi32>, index, index, index, index) -> memref
+      linalg.generic {indexing_maps = [#map22, #map22, #map22, #map22, #map22], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%13, %14 : memref, memref) outs(%15, %16, %17 : memref, memref, memref) {
+      ^bb0(%in: i32, %in_0: i32, %out: i32, %out_1: i32, %out_2: i32):
+        %23 = arith.muli %in, %in : i32
+        %24 = arith.addi %out_2, %23 : i32
+        %25 = arith.muli %in_0, %in_0 : i32
+        %26 = arith.addi %out_1, %25 : i32
+        %27 = arith.muli %in, %in_0 : i32
+        %28 = arith.addi %out, %27 : i32
+        linalg.yield %28, %26, %24 : i32, i32, i32
+      }
+      %18 = memref.get_global @score : memref<512x512xi32>
+      %19 = "polygeist.submap"(%10, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+      %20 = "polygeist.submap"(%11, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+      %21 = "polygeist.submap"(%12, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+      %22 = "polygeist.submap"(%18, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+      linalg.generic {indexing_maps = [#map6, #map6, #map6, #map6], iterator_types = ["parallel", "parallel"]} ins(%19, %20, %21 : memref, memref, memref) outs(%22 : memref) {
+      ^bb0(%in: i32, %in_0: i32, %in_1: i32, %out: i32):
+        %23 = arith.muli %in, %in_0 : i32
+        %24 = arith.muli %in_1, %in_1 : i32
+        %25 = arith.subi %23, %24 : i32
+        %26 = arith.addi %in, %in_0 : i32
+        %27 = arith.muli %26, %c4_i32 : i32
+        %28 = arith.muli %27, %26 : i32
+        %29 = arith.subi %25, %28 : i32
+        linalg.yield %29 : i32
+      }
+      return %c0_i32 : i32
+    }
+  }
+  module @harris_score_local {
+    memref.global @coeffs_y : memref<9xi32> = dense<[-3, -10, -3, 0, 0, 0, 3, 10, 3]>
+    memref.global @coeffs_x : memref<9xi32> = dense<[-3, 0, 3, -10, 0, 10, -3, 0, 3]>
+    memref.global @score : memref<512x512xi32> = uninitialized
+    func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+      %c516 = arith.constant 516 : index
+      %c3 = arith.constant 3 : index
+      %c512 = arith.constant 512 : index
+      %c5 = arith.constant 5 : index
+      %c4_i32 = arith.constant 4 : i32
+      %c0_i32 = arith.constant 0 : i32
+      %alloca = memref.alloca() : memref<512x512xi32>
+      %alloca_0 = memref.alloca() : memref<512x512xi32>
+      %alloca_1 = memref.alloca() : memref<512x512xi32>
+      %alloca_2 = memref.alloca() : memref<516x516xi32>
+      %alloca_3 = memref.alloca() : memref<516x516xi32>
+      %alloca_4 = memref.alloca() : memref<518x518xi32>
+      %0 = memref.get_global @coeffs_x : memref<9xi32>
+      %1 = memref.get_global @coeffs_y : memref<9xi32>
+      %2 = "polygeist.submap"(%alloca_4, %c3, %c3, %c516, %c516) <{map = #map19}> : (memref<518x518xi32>, index, index, index, index) -> memref
+      %3 = "polygeist.submap"(%0, %c3, %c3, %c516, %c516) <{map = #map29}> : (memref<9xi32>, index, index, index, index) -> memref
+      %4 = "polygeist.submap"(%1, %c3, %c3, %c516, %c516) <{map = #map29}> : (memref<9xi32>, index, index, index, index) -> memref
+      %5 = "polygeist.submap"(%alloca_3, %c3, %c3, %c516, %c516) <{map = #map21}> : (memref<516x516xi32>, index, index, index, index) -> memref
+      %6 = "polygeist.submap"(%alloca_2, %c3, %c3, %c516, %c516) <{map = #map21}> : (memref<516x516xi32>, index, index, index, index) -> memref
+      linalg.generic {indexing_maps = [#map22, #map22, #map22, #map22, #map22], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2, %3, %4 : memref, memref, memref) outs(%5, %6 : memref, memref) {
+      ^bb0(%in: i32, %in_5: i32, %in_6: i32, %out: i32, %out_7: i32):
+        %17 = arith.muli %in, %in_5 : i32
+        %18 = arith.addi %out, %17 : i32
+        %19 = arith.muli %in, %in_6 : i32
+        %20 = arith.addi %out_7, %19 : i32
+        linalg.yield %18, %20 : i32, i32
+      }
+      %7 = "polygeist.submap"(%alloca_3, %c5, %c5, %c512, %c512) <{map = #map19}> : (memref<516x516xi32>, index, index, index, index) -> memref
+      %8 = "polygeist.submap"(%alloca_2, %c5, %c5, %c512, %c512) <{map = #map19}> : (memref<516x516xi32>, index, index, index, index) -> memref
+      %9 = "polygeist.submap"(%alloca, %c5, %c5, %c512, %c512) <{map = #map21}> : (memref<512x512xi32>, index, index, index, index) -> memref
+      %10 = "polygeist.submap"(%alloca_0, %c5, %c5, %c512, %c512) <{map = #map21}> : (memref<512x512xi32>, index, index, index, index) -> memref
+      %11 = "polygeist.submap"(%alloca_1, %c5, %c5, %c512, %c512) <{map = #map21}> : (memref<512x512xi32>, index, index, index, index) -> memref
+      linalg.generic {indexing_maps = [#map22, #map22, #map22, #map22, #map22], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%7, %8 : memref, memref) outs(%9, %10, %11 : memref, memref, memref) {
+      ^bb0(%in: i32, %in_5: i32, %out: i32, %out_6: i32, %out_7: i32):
+        %17 = arith.muli %in, %in : i32
+        %18 = arith.addi %out_7, %17 : i32
+        %19 = arith.muli %in_5, %in_5 : i32
+        %20 = arith.addi %out_6, %19 : i32
+        %21 = arith.muli %in, %in_5 : i32
+        %22 = arith.addi %out, %21 : i32
+        linalg.yield %22, %20, %18 : i32, i32, i32
+      }
+      %12 = memref.get_global @score : memref<512x512xi32>
+      %13 = "polygeist.submap"(%alloca_1, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+      %14 = "polygeist.submap"(%alloca_0, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+      %15 = "polygeist.submap"(%alloca, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+      %16 = "polygeist.submap"(%12, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+      linalg.generic {indexing_maps = [#map6, #map6, #map6, #map6], iterator_types = ["parallel", "parallel"]} ins(%13, %14, %15 : memref, memref, memref) outs(%16 : memref) {
+      ^bb0(%in: i32, %in_5: i32, %in_6: i32, %out: i32):
+        %17 = arith.muli %in, %in_5 : i32
+        %18 = arith.muli %in_6, %in_6 : i32
+        %19 = arith.subi %17, %18 : i32
+        %20 = arith.addi %in, %in_5 : i32
+        %21 = arith.muli %20, %c4_i32 : i32
+        %22 = arith.muli %21, %20 : i32
+        %23 = arith.subi %19, %22 : i32
+        linalg.yield %23 : i32
+      }
+      return %c0_i32 : i32
+    }
+  }
+}
+
+module @harris_score_2d_kernel {
+  memref.global "private" @_ZL8coeffs_y : memref<3x3xi32> = dense<[[-3, -10, -3], [0, 0, 0], [3, 10, 3]]>
+  memref.global "private" @_ZL8coeffs_x : memref<3x3xi32> = dense<[[-3, -10, -3], [0, 0, 0], [3, 10, 3]]>
+  memref.global @score : memref<512x512xi32> = uninitialized
+  func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+    %c516 = arith.constant 516 : index
+    %c3 = arith.constant 3 : index
+    %c512 = arith.constant 512 : index
+    %c5 = arith.constant 5 : index
+    %c4_i32 = arith.constant 4 : i32
+    %c0_i32 = arith.constant 0 : i32
+    %alloca = memref.alloca() : memref<512x512xi32>
+    %alloca_0 = memref.alloca() : memref<512x512xi32>
+    %alloca_1 = memref.alloca() : memref<512x512xi32>
+    %alloca_2 = memref.alloca() : memref<516x516xi32>
+    %alloca_3 = memref.alloca() : memref<516x516xi32>
+    %alloca_4 = memref.alloca() : memref<518x518xi32>
+    %0 = memref.get_global @_ZL8coeffs_x : memref<3x3xi32>
+    %1 = memref.get_global @_ZL8coeffs_y : memref<3x3xi32>
+    %2 = "polygeist.submap"(%alloca_4, %c3, %c3, %c516, %c516) <{map = #map19}> : (memref<518x518xi32>, index, index, index, index) -> memref
+    %3 = "polygeist.submap"(%0, %c3, %c3, %c516, %c516) <{map = #map20}> : (memref<3x3xi32>, index, index, index, index) -> memref
+    %4 = "polygeist.submap"(%1, %c3, %c3, %c516, %c516) <{map = #map20}> : (memref<3x3xi32>, index, index, index, index) -> memref
+    %5 = "polygeist.submap"(%alloca_2, %c3, %c3, %c516, %c516) <{map = #map21}> : (memref<516x516xi32>, index, index, index, index) -> memref
+    %6 = "polygeist.submap"(%alloca_3, %c3, %c3, %c516, %c516) <{map = #map21}> : (memref<516x516xi32>, index, index, index, index) -> memref
+    linalg.generic {indexing_maps = [#map22, #map22, #map22, #map22, #map22], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2, %3, %4 : memref, memref, memref) outs(%5, %6 : memref, memref) {
+    ^bb0(%in: i32, %in_5: i32, %in_6: i32, %out: i32, %out_7: i32):
+      %17 = arith.muli %in, %in_5 : i32
+      %18 = arith.addi %out_7, %17 : i32
+      %19 = arith.muli %in, %in_6 : i32
+      %20 = arith.addi %out, %19 : i32
+      linalg.yield %20, %18 : i32, i32
+    }
+    %7 = "polygeist.submap"(%alloca_3, %c5, %c5, %c512, %c512) <{map = #map19}> : (memref<516x516xi32>, index, index, index, index) -> memref
+    %8 = "polygeist.submap"(%alloca_2, %c5, %c5, %c512, %c512) <{map = #map19}> : (memref<516x516xi32>, index, index, index, index) -> memref
+    %9 = "polygeist.submap"(%alloca, %c5, %c5, %c512, %c512) <{map = #map21}> : (memref<512x512xi32>, index, index, index, index) -> memref
+    %10 = "polygeist.submap"(%alloca_0, %c5, %c5, %c512, %c512) <{map = #map21}> : (memref<512x512xi32>, index, index, index, index) -> memref
+    %11 = "polygeist.submap"(%alloca_1, %c5, %c5, %c512, %c512) <{map = #map21}> : (memref<512x512xi32>, index, index, index, index) -> memref
+    linalg.generic {indexing_maps = [#map22, #map22, #map22, #map22, #map22], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%7, %8 : memref, memref) outs(%9, %10, %11 : memref, memref, memref) {
+    ^bb0(%in: i32, %in_5: i32, %out: i32, %out_6: i32, %out_7: i32):
+      %17 = arith.muli %in, %in : i32
+      %18 = arith.addi %out_7, %17 : i32
+      %19 = arith.muli %in_5, %in_5 : i32
+      %20 = arith.addi %out_6, %19 : i32
+      %21 = arith.muli %in, %in_5 : i32
+      %22 = arith.addi %out, %21 : i32
+      linalg.yield %22, %20, %18 : i32, i32, i32
+    }
+    %12 = memref.get_global @score : memref<512x512xi32>
+    %13 = "polygeist.submap"(%alloca_1, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+    %14 = "polygeist.submap"(%alloca_0, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+    %15 = "polygeist.submap"(%alloca, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+    %16 = "polygeist.submap"(%12, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+    linalg.generic {indexing_maps = [#map6, #map6, #map6, #map6], iterator_types = ["parallel", "parallel"]} ins(%13, %14, %15 : memref, memref, memref) outs(%16 : memref) {
+    ^bb0(%in: i32, %in_5: i32, %in_6: i32, %out: i32):
+      %17 = arith.muli %in, %in_5 : i32
+      %18 = arith.muli %in_6, %in_6 : i32
+      %19 = arith.subi %17, %18 : i32
+      %20 = arith.addi %in, %in_5 : i32
+      %21 = arith.muli %20, %c4_i32 : i32
+      %22 = arith.muli %21, %20 : i32
+      %23 = arith.subi %19, %22 : i32
+      linalg.yield %23 : i32
+    }
+    return %c0_i32 : i32
+  }
+}
+
+module @harris_score_gradient_1d_kernel {
+  memref.global @coeffs_y : memref<9xi32> = dense<[-3, -10, -3, 0, 0, 0, 3, 10, 3]>
+  memref.global @coeffs_x : memref<9xi32> = dense<[-3, 0, 3, -10, 0, 10, -3, 0, 3]>
+  memref.global @score : memref<512x512xi32> = uninitialized
+  memref.global @img_ixy : memref<512x512xi32> = uninitialized
+  memref.global @img_iyy : memref<512x512xi32> = uninitialized
+  memref.global @img_ixx : memref<512x512xi32> = uninitialized
+  memref.global @img_in : memref<518x518xi32> = uninitialized
+  memref.global @img_gy : memref<516x516xi32> = uninitialized
+  memref.global @img_gx : memref<516x516xi32> = uninitialized
+  func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+    %c516 = arith.constant 516 : index
+    %c3 = arith.constant 3 : index
+    %c512 = arith.constant 512 : index
+    %c5 = arith.constant 5 : index
+    %c4_i32 = arith.constant 4 : i32
+    %c0_i32 = arith.constant 0 : i32
+    %0 = memref.get_global @img_gx : memref<516x516xi32>
+    %1 = memref.get_global @img_gy : memref<516x516xi32>
+    %2 = memref.get_global @img_in : memref<518x518xi32>
+    %3 = memref.get_global @coeffs_x : memref<9xi32>
+    %4 = memref.get_global @coeffs_y : memref<9xi32>
+    %5 = "polygeist.submap"(%2, %c3, %c3, %c516, %c516) <{map = #map19}> : (memref<518x518xi32>, index, index, index, index) -> memref
+    %6 = "polygeist.submap"(%3, %c3, %c3, %c516, %c516) <{map = #map29}> : (memref<9xi32>, index, index, index, index) -> memref
+    %7 = "polygeist.submap"(%4, %c3, %c3, %c516, %c516) <{map = #map29}> : (memref<9xi32>, index, index, index, index) -> memref
+    %8 = "polygeist.submap"(%0, %c3, %c3, %c516, %c516) <{map = #map21}> : (memref<516x516xi32>, index, index, index, index) -> memref
+    %9 = "polygeist.submap"(%1, %c3, %c3, %c516, %c516) <{map = #map21}> : (memref<516x516xi32>, index, index, index, index) -> memref
+    linalg.generic {indexing_maps = [#map22, #map22, #map22, #map22, #map22], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%5, %6, %7 : memref, memref, memref) outs(%8, %9 : memref, memref) {
+    ^bb0(%in: i32, %in_0: i32, %in_1: i32, %out: i32, %out_2: i32):
+      %23 = arith.muli %in, %in_0 : i32
+      %24 = arith.addi %out, %23 : i32
+      %25 = arith.muli %in, %in_1 : i32
+      %26 = arith.addi %out_2, %25 : i32
+      linalg.yield %24, %26 : i32, i32
+    }
+    return %c0_i32 : i32
+  }
+}
+
+module @harris_score_gradient_2d_kernel {
+  memref.global "private" @_ZL8coeffs_y : memref<3x3xi32> = dense<[[-3, -10, -3], [0, 0, 0], [3, 10, 3]]>
+  memref.global "private" @_ZL8coeffs_x : memref<3x3xi32> = dense<[[-3, -10, -3], [0, 0, 0], [3, 10, 3]]>
+  memref.global @score : memref<512x512xi32> = uninitialized
+  func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+    %c516 = arith.constant 516 : index
+    %c3 = arith.constant 3 : index
+    %c512 = arith.constant 512 : index
+    %c5 = arith.constant 5 : index
+    %c4_i32 = arith.constant 4 : i32
+    %c0_i32 = arith.constant 0 : i32
+    %alloca = memref.alloca() : memref<512x512xi32>
+    %alloca_0 = memref.alloca() : memref<512x512xi32>
+    %alloca_1 = memref.alloca() : memref<512x512xi32>
+    %alloca_2 = memref.alloca() : memref<516x516xi32>
+    %alloca_3 = memref.alloca() : memref<516x516xi32>
+    %alloca_4 = memref.alloca() : memref<518x518xi32>
+    %0 = memref.get_global @_ZL8coeffs_x : memref<3x3xi32>
+    %1 = memref.get_global @_ZL8coeffs_y : memref<3x3xi32>
+    %2 = "polygeist.submap"(%alloca_4, %c3, %c3, %c516, %c516) <{map = #map19}> : (memref<518x518xi32>, index, index, index, index) -> memref
+    %3 = "polygeist.submap"(%0, %c3, %c3, %c516, %c516) <{map = #map20}> : (memref<3x3xi32>, index, index, index, index) -> memref
+    %4 = "polygeist.submap"(%1, %c3, %c3, %c516, %c516) <{map = #map20}> : (memref<3x3xi32>, index, index, index, index) -> memref
+    %5 = "polygeist.submap"(%alloca_2, %c3, %c3, %c516, %c516) <{map = #map21}> : (memref<516x516xi32>, index, index, index, index) -> memref
+    %6 = "polygeist.submap"(%alloca_3, %c3, %c3, %c516, %c516) <{map = #map21}> : (memref<516x516xi32>, index, index, index, index) -> memref
+    linalg.generic {indexing_maps = [#map22, #map22, #map22, #map22, #map22], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2, %3, %4 : memref, memref, memref) outs(%5, %6 : memref, memref) {
+    ^bb0(%in: i32, %in_5: i32, %in_6: i32, %out: i32, %out_7: i32):
+      %17 = arith.muli %in, %in_5 : i32
+      %18 = arith.addi %out_7, %17 : i32
+      %19 = arith.muli %in, %in_6 : i32
+      %20 = arith.addi %out, %19 : i32
+      linalg.yield %20, %18 : i32, i32
+    }
+    return %c0_i32 : i32
+  }
+}
+
+module @harris_score_with_gradient_extra_kernel {
+  memref.global "private" @_ZL8coeffs_1 : memref<5x5xi32> = dense<1>
+  memref.global "private" @_ZL8coeffs_y : memref<3x3xi32> = dense<[[-3, -10, -3], [0, 0, 0], [3, 10, 3]]>
+  memref.global "private" @_ZL8coeffs_x : memref<3x3xi32> = dense<[[-3, -10, -3], [0, 0, 0], [3, 10, 3]]>
+  memref.global @score : memref<512x512xi32> = uninitialized
+  func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+    %c516 = arith.constant 516 : index
+    %c3 = arith.constant 3 : index
+    %c512 = arith.constant 512 : index
+    %c5 = arith.constant 5 : index
+    %c4_i32 = arith.constant 4 : i32
+    %c0_i32 = arith.constant 0 : i32
+    %alloca = memref.alloca() : memref<512x512xi32>
+    %alloca_0 = memref.alloca() : memref<512x512xi32>
+    %alloca_1 = memref.alloca() : memref<512x512xi32>
+    %alloca_2 = memref.alloca() : memref<516x516xi32>
+    %alloca_3 = memref.alloca() : memref<516x516xi32>
+    %alloca_4 = memref.alloca() : memref<518x518xi32>
+    %0 = memref.get_global @_ZL8coeffs_x : memref<3x3xi32>
+    %1 = memref.get_global @_ZL8coeffs_y : memref<3x3xi32>
+    %2 = "polygeist.submap"(%alloca_4, %c3, %c3, %c516, %c516) <{map = #map19}> : (memref<518x518xi32>, index, index, index, index) -> memref
+    %3 = "polygeist.submap"(%0, %c3, %c3, %c516, %c516) <{map = #map20}> : (memref<3x3xi32>, index, index, index, index) -> memref
+    %4 = "polygeist.submap"(%1, %c3, %c3, %c516, %c516) <{map = #map20}> : (memref<3x3xi32>, index, index, index, index) -> memref
+    %5 = "polygeist.submap"(%alloca_2, %c3, %c3, %c516, %c516) <{map = #map21}> : (memref<516x516xi32>, index, index, index, index) -> memref
+    %6 = "polygeist.submap"(%alloca_3, %c3, %c3, %c516, %c516) <{map = #map21}> : (memref<516x516xi32>, index, index, index, index) -> memref
+    linalg.generic {indexing_maps = [#map22, #map22, #map22, #map22, #map22], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2, %3, %4 : memref, memref, memref) outs(%5, %6 : memref, memref) {
+    ^bb0(%in: i32, %in_5: i32, %in_6: i32, %out: i32, %out_7: i32):
+      %19 = arith.muli %in, %in_5 : i32
+      %20 = arith.addi %out_7, %19 : i32
+      %21 = arith.muli %in, %in_6 : i32
+      %22 = arith.addi %out, %21 : i32
+      linalg.yield %22, %20 : i32, i32
+    }
+    %7 = memref.get_global @_ZL8coeffs_1 : memref<5x5xi32>
+    %8 = "polygeist.submap"(%alloca_3, %c5, %c5, %c512, %c512) <{map = #map19}> : (memref<516x516xi32>, index, index, index, index) -> memref
+    %9 = "polygeist.submap"(%alloca_2, %c5, %c5, %c512, %c512) <{map = #map19}> : (memref<516x516xi32>, index, index, index, index) -> memref
+    %10 = "polygeist.submap"(%7, %c5, %c5, %c512, %c512) <{map = #map20}> : (memref<5x5xi32>, index, index, index, index) -> memref
+    %11 = "polygeist.submap"(%alloca, %c5, %c5, %c512, %c512) <{map = #map21}> : (memref<512x512xi32>, index, index, index, index) -> memref
+    %12 = "polygeist.submap"(%alloca_0, %c5, %c5, %c512, %c512) <{map = #map21}> : (memref<512x512xi32>, index, index, index, index) -> memref
+    %13 = "polygeist.submap"(%alloca_1, %c5, %c5, %c512, %c512) <{map = #map21}> : (memref<512x512xi32>, index, index, index, index) -> memref
+    linalg.generic {indexing_maps = [#map22, #map22, #map22, #map22, #map22, #map22], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%8, %9, %10 : memref, memref, memref) outs(%11, %12, %13 : memref, memref, memref) {
+    ^bb0(%in: i32, %in_5: i32, %in_6: i32, %out: i32, %out_7: i32, %out_8: i32):
+      %19 = arith.muli %in, %in : i32
+      %20 = arith.muli %19, %in_6 : i32
+      %21 = arith.addi %out_8, %20 : i32
+      %22 = arith.muli %in_5, %in_5 : i32
+      %23 = arith.muli %22, %in_6 : i32
+      %24 = arith.addi %out_7, %23 : i32
+      %25 = arith.muli %in, %in_5 : i32
+      %26 = arith.muli %25, %in_6 : i32
+      %27 = arith.addi %out, %26 : i32
+      linalg.yield %27, %24, %21 : i32, i32, i32
+    }
+    %14 = memref.get_global @score : memref<512x512xi32>
+    %15 = "polygeist.submap"(%alloca_1, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+    %16 = "polygeist.submap"(%alloca_0, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+    %17 = "polygeist.submap"(%alloca, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+    %18 = "polygeist.submap"(%14, %c512, %c512) <{map = #map24}> : (memref<512x512xi32>, index, index) -> memref
+    linalg.generic {indexing_maps = [#map6, #map6, #map6, #map6], iterator_types = ["parallel", "parallel"]} ins(%15, %16, %17 : memref, memref, memref) outs(%18 : memref) {
+    ^bb0(%in: i32, %in_5: i32, %in_6: i32, %out: i32):
+      %19 = arith.muli %in, %in_5 : i32
+      %20 = arith.muli %in_6, %in_6 : i32
+      %21 = arith.subi %19, %20 : i32
+      %22 = arith.addi %in, %in_5 : i32
+      %23 = arith.muli %22, %c4_i32 : i32
+      %24 = arith.muli %23, %22 : i32
+      %25 = arith.subi %21, %24 : i32
+      linalg.yield %25 : i32
+    }
+    return %c0_i32 : i32
+  }
+}
diff --git a/test/polygeist-opt/remove-iter-args.mlir b/test/polygeist-opt/remove-iter-args.mlir
new file mode 100644
index 000000000000..37fdc91fc269
--- /dev/null
+++ b/test/polygeist-opt/remove-iter-args.mlir
@@ -0,0 +1,757 @@
+// RUN: polygeist-opt --remove-iter-args --split-input-file %s | FileCheck %s
+
+// ============================================================================
+// AFFINE.FOR TEST CASES
+// ============================================================================
+
+// Test case 1: Simple direct store (should work with original implementation)
+// CHECK-LABEL: func.func @test_direct_store
+// CHECK-NOT: iter_args
+// CHECK: affine.for
+// CHECK: %[[LOADED:.*]] = affine.load %{{.*}}[] : memref
+// CHECK: %[[VAL:.*]] = affine.load
+// CHECK: %[[SUM:.*]] = arith.addf %[[LOADED]], %[[VAL]]
+// CHECK: affine.store %[[SUM]], %{{.*}}[] : memref
+// CHECK-NOT: affine.yield {{.*}} : f64
+func.func @test_direct_store(%A: memref, %n: index) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %init = arith.constant 0.0 : f64
+  %result_mem = memref.alloc() : memref
+  
+  %sum = affine.for %i = %c0 to %n iter_args(%acc = %init) -> (f64) {
+    %val = affine.load %A[%i] : memref
+    %new_acc = arith.addf %acc, %val : f64
+    affine.yield %new_acc : f64
+  }
+  affine.store %sum, %result_mem[] : memref
+  
+  return
+}
+
+// -----
+
+// Test case 2: Multiply after reduction (distributivity)
+// Pattern: result = alpha * sum → sum = acc + (alpha * value)
+// CHECK-LABEL: func.func @test_multiply_after_add
+// CHECK-NOT: iter_args
+// CHECK: affine.for
+// CHECK: %[[LOADED:.*]] = affine.load %{{.*}}[] : memref
+// CHECK: %[[VAL:.*]] = affine.load %{{.*}}[%{{.*}}]
+// CHECK: %[[PROD:.*]] = arith.mulf %{{.*}}, %[[VAL]]
+// CHECK: %[[SUM:.*]] = arith.addf %[[LOADED]], %[[PROD]]
+// CHECK: affine.store %[[SUM]], %{{.*}}[] : memref
+func.func @test_multiply_after_add(%A: memref, %n: index, %alpha: f64) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %init = arith.constant 0.0 : f64
+  %result_mem = memref.alloc() : memref
+  
+  %sum = affine.for %i = %c0 to %n iter_args(%acc = %init) -> (f64) {
+    %val = affine.load %A[%i] : memref
+    %new_acc = arith.addf %acc, %val : f64
+    affine.yield %new_acc : f64
+  }
+  %scaled = arith.mulf %alpha, %sum : f64
+  affine.store %scaled, %result_mem[] : memref
+  
+  return
+}
+
+// -----
+
+// Test case 3: Addition with loop-invariant load (init adjustment)
+// Pattern: result = C + sum → init = C, then direct store
+// CHECK-LABEL: func.func @test_add_with_invariant_load
+// CHECK-NOT: iter_args
+// CHECK: affine.for
+// CHECK: %[[LOADED:.*]] = affine.load %{{.*}}[] : memref
+// CHECK: %[[VAL:.*]] = affine.load %{{.*}}[%{{.*}}]
+// CHECK: %[[SUM:.*]] = arith.addf %[[LOADED]], %[[VAL]]
+// CHECK: affine.store %[[SUM]], %{{.*}}[] : memref
+// CHECK-NOT: affine.load %{{.*}}[] : memref
+func.func @test_add_with_invariant_load(%A: memref, %C: memref, %n: index) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %init = arith.constant 0.0 : f64
+  
+  %sum = affine.for %i = %c0 to %n iter_args(%acc = %init) -> (f64) {
+    %val = affine.load %A[%i] : memref
+    %new_acc = arith.addf %acc, %val : f64
+    affine.yield %new_acc : f64
+  }
+  %old_c = affine.load %C[] : memref
+  %new_c = arith.addf %old_c, %sum : f64
+  affine.store %new_c, %C[] : memref
+  
+  return
+}
+
+// -----
+
+// Test case 4: Full GEMM pattern (multiply + add with load)
+// Pattern: C = C + alpha * sum (most complex case)
+// CHECK-LABEL: func.func @test_gemm_pattern
+// CHECK-NOT: iter_args
+// CHECK: affine.for
+// CHECK: %[[LOADED:.*]] = affine.load %{{.*}}[] : memref
+// CHECK: %[[VAL:.*]] = affine.load %{{.*}}[%{{.*}}]
+// CHECK: %[[PROD:.*]] = arith.mulf %{{.*}}, %[[VAL]]
+// CHECK: %[[SUM:.*]] = arith.addf %[[LOADED]], %[[PROD]]
+// CHECK: affine.store %[[SUM]], %{{.*}}[] : memref
+func.func @test_gemm_pattern(%A: memref, %C: memref, %n: index, %alpha: f64) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %init = arith.constant 0.0 : f64
+  
+  %sum = affine.for %i = %c0 to %n iter_args(%acc = %init) -> (f64) {
+    %val = affine.load %A[%i] : memref
+    %new_acc = arith.addf %acc, %val : f64
+    affine.yield %new_acc : f64
+  }
+  
+  %scaled = arith.mulf %alpha, %sum : f64
+  %old_c = affine.load %C[] : memref
+  %new_c = arith.addf %old_c, %scaled : f64
+  affine.store %new_c, %C[] : memref
+  
+  return
+}
+
+// -----
+
+// Test case 5: Realistic GEMM inner loop
+// C[i,j] += alpha * sum_k(A[i,k] * B[k,j])
+// CHECK-LABEL: func.func @test_gemm_inner_loop
+// CHECK-NOT: iter_args
+// CHECK: affine.for
+// CHECK: %[[C_LOADED:.*]] = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref
+// CHECK: %[[A_VAL:.*]] = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref
+// CHECK: %[[B_VAL:.*]] = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref
+// CHECK: %[[PROD1:.*]] = arith.mulf %[[A_VAL]], %[[B_VAL]]
+// CHECK: %[[PROD2:.*]] = arith.mulf %{{.*}}, %[[PROD1]]
+// CHECK: %[[SUM:.*]] = arith.addf %[[C_LOADED]], %[[PROD2]]
+// CHECK: affine.store %[[SUM]], %{{.*}}[%{{.*}}, %{{.*}}] : memref
+func.func @test_gemm_inner_loop(
+    %A: memref, %B: memref, %C: memref,
+    %i: index, %j: index, %K: index, %lda: index, %ldb: index, %ldc: index,
+    %alpha: f64) {
+  %c0 = arith.constant 0 : index
+  %init = arith.constant 0.0 : f64
+  
+  %dot_product = affine.for %k = %c0 to %K iter_args(%acc = %init) -> (f64) {
+    %a_ik = affine.load %A[%i, %k] : memref
+    %b_kj = affine.load %B[%k, %j] : memref
+    %prod = arith.mulf %a_ik, %b_kj : f64
+    %new_acc = arith.addf %acc, %prod : f64
+    affine.yield %new_acc : f64
+  }
+  
+  %scaled = arith.mulf %alpha, %dot_product : f64
+  %old_c = affine.load %C[%i, %j] : memref
+  %new_c = arith.addf %old_c, %scaled : f64
+  affine.store %new_c, %C[%i, %j] : memref
+  
+  return
+}
+
+// -----
+
+// Test case 6: Multiply-reduction with a post-loop scale.
+// Distributivity does NOT apply (yield isn't addition), so the fast path bails.
+// The alloca fallback handles it: one slot for the product accumulator, the
+// post-loop scale runs after the final load.
+// CHECK-LABEL: func.func @test_multiply_after_multiply
+// CHECK-NOT: iter_args
+// CHECK: %[[SLOT:.*]] = memref.alloca() : memref
+// CHECK: affine.store %{{.*}}, %[[SLOT]][] : memref
+// CHECK: affine.for
+// CHECK: %[[ACC:.*]] = affine.load %[[SLOT]][] : memref
+// CHECK: arith.mulf %[[ACC]], %{{.*}} : f64
+// CHECK: affine.store %{{.*}}, %[[SLOT]][] : memref
+// CHECK: }
+// CHECK: %[[FIN:.*]] = affine.load %[[SLOT]][] : memref
+// CHECK: arith.mulf %{{.*}}, %[[FIN]] : f64
+func.func @test_multiply_after_multiply(%A: memref, %n: index, %alpha: f64) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %init = arith.constant 1.0 : f64
+  %result_mem = memref.alloc() : memref
+  
+  %product = affine.for %i = %c0 to %n iter_args(%acc = %init) -> (f64) {
+    %val = affine.load %A[%i] : memref
+    %new_acc = arith.mulf %acc, %val : f64
+    affine.yield %new_acc : f64
+  }
+  %scaled = arith.mulf %alpha, %product : f64
+  affine.store %scaled, %result_mem[] : memref
+  
+  return
+}
+
+// -----
+
+// Test case 7: Multiple uses of the loop result.
+// The fast path's hasOneUse() guard rejects this. The alloca fallback handles
+// it by RAUWing the old result with a single post-loop load that both stores
+// then consume.
+// CHECK-LABEL: func.func @test_multiple_uses
+// CHECK-NOT: iter_args
+// CHECK: %[[SLOT:.*]] = memref.alloca() : memref
+// CHECK: affine.for
+// CHECK: }
+// CHECK: %[[FIN:.*]] = affine.load %[[SLOT]][] : memref
+// CHECK: affine.store %[[FIN]], %{{.*}}[] : memref
+// CHECK: affine.store %[[FIN]], %{{.*}}[] : memref
+func.func @test_multiple_uses(%A: memref, %n: index) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %init = arith.constant 0.0 : f64
+  %result1 = memref.alloc() : memref
+  %result2 = memref.alloc() : memref
+  
+  %sum = affine.for %i = %c0 to %n iter_args(%acc = %init) -> (f64) {
+    %val = affine.load %A[%i] : memref
+    %new_acc = arith.addf %acc, %val : f64
+    affine.yield %new_acc : f64
+  }
+  
+  affine.store %sum, %result1[] : memref
+  affine.store %sum, %result2[] : memref
+  
+  return
+}
+
+// -----
+
+// ============================================================================
+// INTEGER TESTS (AFFINE)
+// ============================================================================
+
+// Test case 8: Integer addition - direct store
+// CHECK-LABEL: func.func @test_integer_direct_store
+// CHECK-NOT: iter_args
+// CHECK: affine.for
+// CHECK: arith.addi
+// CHECK: affine.store
+func.func @test_integer_direct_store(%A: memref, %n: index) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %init = arith.constant 0 : i32
+  %result_mem = memref.alloc() : memref
+  
+  %sum = affine.for %i = %c0 to %n iter_args(%acc = %init) -> (i32) {
+    %val = affine.load %A[%i] : memref
+    %new_acc = arith.addi %acc, %val : i32
+    affine.yield %new_acc : i32
+  }
+  affine.store %sum, %result_mem[] : memref
+  
+  return
+}
+
+// -----
+
+// Test case 9: Integer multiply after reduction
+// CHECK-LABEL: func.func @test_integer_multiply_after_add
+// CHECK-NOT: iter_args
+// CHECK: affine.for
+// CHECK: arith.muli
+// CHECK: arith.addi
+// CHECK: affine.store
+func.func @test_integer_multiply_after_add(%A: memref, %n: index, %alpha: i32) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %init = arith.constant 0 : i32
+  %result_mem = memref.alloc() : memref
+  
+  %sum = affine.for %i = %c0 to %n iter_args(%acc = %init) -> (i32) {
+    %val = affine.load %A[%i] : memref
+    %new_acc = arith.addi %acc, %val : i32
+    affine.yield %new_acc : i32
+  }
+  %scaled = arith.muli %alpha, %sum : i32
+  affine.store %scaled, %result_mem[] : memref
+  
+  return
+}
+
+// -----
+
+// Test case 10: Integer addition with loop-invariant load
+// CHECK-LABEL: func.func @test_integer_add_with_invariant_load
+// CHECK-NOT: iter_args
+// CHECK: affine.for
+// CHECK: arith.addi
+// CHECK: affine.store
+func.func @test_integer_add_with_invariant_load(%A: memref, %C: memref, %n: index) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %init = arith.constant 0 : i32
+  
+  %sum = affine.for %i = %c0 to %n iter_args(%acc = %init) -> (i32) {
+    %val = affine.load %A[%i] : memref
+    %new_acc = arith.addi %acc, %val : i32
+    affine.yield %new_acc : i32
+  }
+  %old_c = affine.load %C[] : memref
+  %new_c = arith.addi %old_c, %sum : i32
+  affine.store %new_c, %C[] : memref
+  
+  return
+}
+
+// -----
+
+// Test case 11: Full integer GEMM-like pattern
+// CHECK-LABEL: func.func @test_integer_gemm_pattern
+// CHECK-NOT: iter_args
+// CHECK: affine.for
+// CHECK: arith.muli
+// CHECK: arith.addi
+// CHECK: affine.store
+func.func @test_integer_gemm_pattern(%A: memref, %C: memref, %n: index, %alpha: i32) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %init = arith.constant 0 : i32
+  
+  %sum = affine.for %i = %c0 to %n iter_args(%acc = %init) -> (i32) {
+    %val = affine.load %A[%i] : memref
+    %new_acc = arith.addi %acc, %val : i32
+    affine.yield %new_acc : i32
+  }
+  
+  %scaled = arith.muli %alpha, %sum : i32
+  %old_c = affine.load %C[] : memref
+  %new_c = arith.addi %old_c, %scaled : i32
+  affine.store %new_c, %C[] : memref
+  
+  return
+}
+
+// -----
+
+// Test case 12: Integer matrix multiply inner loop
+// CHECK-LABEL: func.func @test_integer_gemm_inner_loop
+// CHECK-NOT: iter_args
+// CHECK: affine.for
+// CHECK: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref
+// CHECK: arith.muli
+// CHECK: arith.muli
+// CHECK: arith.addi
+// CHECK: affine.store
+func.func @test_integer_gemm_inner_loop(
+    %A: memref, %B: memref, %C: memref,
+    %i: index, %j: index, %K: index, %lda: index, %ldb: index, %ldc: index,
+    %alpha: i32) {
+  %c0 = arith.constant 0 : index
+  %init = arith.constant 0 : i32
+  
+  %dot_product = affine.for %k = %c0 to %K iter_args(%acc = %init) -> (i32) {
+    %a_ik = affine.load %A[%i, %k] : memref
+    %b_kj = affine.load %B[%k, %j] : memref
+    %prod = arith.muli %a_ik, %b_kj : i32
+    %new_acc = arith.addi %acc, %prod : i32
+    affine.yield %new_acc : i32
+  }
+  
+  %scaled = arith.muli %alpha, %dot_product : i32
+  %old_c = affine.load %C[%i, %j] : memref
+  %new_c = arith.addi %old_c, %scaled : i32
+  affine.store %new_c, %C[%i, %j] : memref
+  
+  return
+}
+
+// -----
+
+// ============================================================================
+// SCF.FOR TEST CASES
+// ============================================================================
+
+// Test case 13: SCF simple direct store
+// CHECK-LABEL: func.func @test_scf_direct_store
+// CHECK-NOT: iter_args
+// CHECK: scf.for
+// CHECK: memref.load %{{.*}}[] : memref
+// CHECK: arith.addf
+// CHECK: memref.store
+func.func @test_scf_direct_store(%A: memref, %result: memref, %n: index) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %init = arith.constant 0.0 : f64
+  
+  %sum = scf.for %i = %c0 to %n step %c1 iter_args(%acc = %init) -> (f64) {
+    %val = memref.load %A[%i] : memref
+    %new_acc = arith.addf %acc, %val : f64
+    scf.yield %new_acc : f64
+  }
+  memref.store %sum, %result[] : memref
+  
+  return
+}
+
+// -----
+
+// Test case 14: SCF multiply after loop
+// CHECK-LABEL: func.func @test_scf_multiply_after
+// CHECK-NOT: iter_args
+// CHECK: scf.for
+// CHECK: memref.load %{{.*}}[] : memref
+// CHECK: arith.mulf
+// CHECK: arith.addf
+// CHECK: memref.store
+func.func @test_scf_multiply_after(%A: memref, %C: memref, %n: index, %alpha: f64) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %init = arith.constant 0.0 : f64
+  
+  %sum = scf.for %i = %c0 to %n step %c1 iter_args(%acc = %init) -> (f64) {
+    %val = memref.load %A[%i] : memref
+    %new_acc = arith.addf %acc, %val : f64
+    scf.yield %new_acc : f64
+  }
+  
+  %scaled = arith.mulf %alpha, %sum : f64
+  memref.store %scaled, %C[] : memref
+  
+  return
+}
+
+// -----
+
+// Test case 15: SCF add with invariant load
+// CHECK-LABEL: func.func @test_scf_add_with_load
+// CHECK-NOT: iter_args
+// CHECK: scf.for
+// CHECK: memref.load %{{.*}}[] : memref
+// CHECK: arith.addf
+// CHECK: memref.store
+func.func @test_scf_add_with_load(%A: memref, %C: memref, %n: index) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %init = arith.constant 0.0 : f64
+  
+  %sum = scf.for %i = %c0 to %n step %c1 iter_args(%acc = %init) -> (f64) {
+    %val = memref.load %A[%i] : memref
+    %new_acc = arith.addf %acc, %val : f64
+    scf.yield %new_acc : f64
+  }
+  
+  %old_c = memref.load %C[] : memref
+  %new_c = arith.addf %old_c, %sum : f64
+  memref.store %new_c, %C[] : memref
+  
+  return
+}
+
+// -----
+
+// Test case 16: SCF full GEMM pattern
+// CHECK-LABEL: func.func @test_scf_gemm_pattern
+// CHECK-NOT: iter_args
+// CHECK: scf.for
+// CHECK: memref.load %{{.*}}[] : memref
+// CHECK: arith.mulf
+// CHECK: arith.addf
+// CHECK: memref.store
+func.func @test_scf_gemm_pattern(%A: memref, %C: memref, %n: index, %alpha: f64) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %init = arith.constant 0.0 : f64
+  
+  %sum = scf.for %i = %c0 to %n step %c1 iter_args(%acc = %init) -> (f64) {
+    %val = memref.load %A[%i] : memref
+    %new_acc = arith.addf %acc, %val : f64
+    scf.yield %new_acc : f64
+  }
+  
+  %scaled = arith.mulf %alpha, %sum : f64
+  %old_c = memref.load %C[] : memref
+  %new_c = arith.addf %old_c, %scaled : f64
+  memref.store %new_c, %C[] : memref
+  
+  return
+}
+
+// -----
+
+// Test case 17: SCF integer operations
+// CHECK-LABEL: func.func @test_scf_integer_gemm
+// CHECK-NOT: iter_args
+// CHECK: scf.for
+// CHECK: memref.load %{{.*}}[] : memref
+// CHECK: arith.muli
+// CHECK: arith.addi
+// CHECK: memref.store
+func.func @test_scf_integer_gemm(%A: memref, %C: memref, %n: index, %alpha: i32) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %init = arith.constant 0 : i32
+  
+  %sum = scf.for %i = %c0 to %n step %c1 iter_args(%acc = %init) -> (i32) {
+    %val = memref.load %A[%i] : memref
+    %new_acc = arith.addi %acc, %val : i32
+    scf.yield %new_acc : i32
+  }
+  
+  %scaled = arith.muli %alpha, %sum : i32
+  %old_c = memref.load %C[] : memref
+  %new_c = arith.addi %old_c, %scaled : i32
+  memref.store %new_c, %C[] : memref
+
+  return
+}
+
+// -----
+
+// ============================================================================
+// SURVEY-DERIVED CASES (alloca fallback)
+// ============================================================================
+
+// Survey r01: scalar reduction returned directly. Alloca path; final load
+// becomes the return value.
+// CHECK-LABEL: func.func @ddot
+// CHECK:         %[[CST:.+]] = arith.constant 0.000000e+00 : f64
+// CHECK:         %[[SLOT:.+]] = memref.alloca() : memref
+// CHECK:         affine.store %[[CST]], %[[SLOT]][] : memref
+// CHECK:         affine.for {{.*}} {
+// CHECK-NOT:       iter_args
+// CHECK:           %[[ACC:.+]] = affine.load %[[SLOT]][] : memref
+// CHECK:           %[[NEW:.+]] = arith.addf %[[ACC]], {{.*}} : f64
+// CHECK:           affine.store %[[NEW]], %[[SLOT]][] : memref
+// CHECK:         }
+// CHECK:         %[[RES:.+]] = affine.load %[[SLOT]][] : memref
+// CHECK:         return %[[RES]] : f64
+func.func @ddot(%n: index, %x: memref, %y: memref) -> f64 {
+  %cst = arith.constant 0.000000e+00 : f64
+  %s = affine.for %i = 0 to %n iter_args(%acc = %cst) -> (f64) {
+    %a = affine.load %x[%i] : memref
+    %b = affine.load %y[%i] : memref
+    %p = arith.mulf %a, %b : f64
+    %new = arith.addf %acc, %p : f64
+    affine.yield %new : f64
+  }
+  return %s : f64
+}
+
+// -----
+
+// Survey r02: pure unary op (math.sqrt) sits between loop result and return.
+// Alloca path: sqrt consumes the post-loop load.
+// CHECK-LABEL: func.func @dnrm2
+// CHECK:         %[[SLOT:.+]] = memref.alloca() : memref
+// CHECK:         affine.for {{.*}} {
+// CHECK-NOT:       iter_args
+// CHECK:         }
+// CHECK:         %[[FIN:.+]] = affine.load %[[SLOT]][] : memref
+// CHECK:         %[[SQ:.+]] = math.sqrt %[[FIN]] : f64
+// CHECK:         return %[[SQ]] : f64
+func.func @dnrm2(%n: index, %x: memref) -> f64 {
+  %cst = arith.constant 0.000000e+00 : f64
+  %s = affine.for %i = 0 to %n iter_args(%acc = %cst) -> (f64) {
+    %a = affine.load %x[%i] : memref
+    %p = arith.mulf %a, %a : f64
+    %new = arith.addf %acc, %p : f64
+    affine.yield %new : f64
+  }
+  %r = math.sqrt %s : f64
+  return %r : f64
+}
+
+// -----
+
+// Survey r06: loop result passed to a call. Alloca path; call argument is
+// the post-loop load.
+// CHECK-LABEL: func.func @log_sum
+// CHECK:         %[[SLOT:.+]] = memref.alloca() : memref
+// CHECK:         affine.for {{.*}} {
+// CHECK-NOT:       iter_args
+// CHECK:         }
+// CHECK:         %[[FIN:.+]] = affine.load %[[SLOT]][] : memref
+// CHECK:         call @sink(%[[FIN]]) : (f64) -> ()
+// CHECK:         return
+func.func @log_sum(%n: index, %x: memref) {
+  %cst = arith.constant 0.000000e+00 : f64
+  %s = affine.for %i = 0 to %n iter_args(%acc = %cst) -> (f64) {
+    %a = affine.load %x[%i] : memref
+    %new = arith.addf %acc, %a : f64
+    affine.yield %new : f64
+  }
+  func.call @sink(%s) : (f64) -> ()
+  return
+}
+func.func private @sink(f64)
+
+// -----
+
+// Survey r08: multi-iter_arg loop. The existing fast path bails (multi-iter
+// guard); the alloca fallback creates one slot per iter_arg.
+// CHECK-LABEL: func.func @two_reductions
+// CHECK-DAG:     %[[S0:.+]] = memref.alloca() : memref
+// CHECK-DAG:     %[[S1:.+]] = memref.alloca() : memref
+// CHECK:         affine.for {{.*}} {
+// CHECK-NOT:       iter_args
+// CHECK-DAG:       affine.load %[[S0]][] : memref
+// CHECK-DAG:       affine.load %[[S1]][] : memref
+// CHECK-DAG:       affine.store %{{.*}}, %[[S0]][] : memref
+// CHECK-DAG:       affine.store %{{.*}}, %[[S1]][] : memref
+// CHECK:         }
+// CHECK-DAG:     affine.load %[[S0]][] : memref
+// CHECK-DAG:     affine.load %[[S1]][] : memref
+// CHECK:         return
+func.func @two_reductions(%n: index, %x: memref,
+                          %m: memref, %q: memref) {
+  %cst = arith.constant 0.000000e+00 : f64
+  %r:2 = affine.for %i = 0 to %n
+        iter_args(%s = %cst, %ss = %cst) -> (f64, f64) {
+    %a = affine.load %x[%i] : memref
+    %ns = arith.addf %s, %a : f64
+    %sq = arith.mulf %a, %a : f64
+    %nss = arith.addf %ss, %sq : f64
+    affine.yield %ns, %nss : f64, f64
+  }
+  affine.store %r#0, %m[0] : memref
+  affine.store %r#1, %q[0] : memref
+  return
+}
+
+// -----
+
+// Survey r11: product reduction (mulf accumulator). Alloca path is operator-
+// agnostic — the body is cloned verbatim.
+// CHECK-LABEL: func.func @prod
+// CHECK:         %[[ONE:.+]] = arith.constant 1.000000e+00 : f64
+// CHECK:         %[[SLOT:.+]] = memref.alloca() : memref
+// CHECK:         affine.store %[[ONE]], %[[SLOT]][] : memref
+// CHECK:         affine.for {{.*}} {
+// CHECK-NOT:       iter_args
+// CHECK:           %[[ACC:.+]] = affine.load %[[SLOT]][] : memref
+// CHECK:           arith.mulf %[[ACC]], {{.*}} : f64
+// CHECK:           affine.store %{{.*}}, %[[SLOT]][] : memref
+// CHECK:         }
+// CHECK:         affine.load %[[SLOT]][] : memref
+// CHECK:         return
+func.func @prod(%n: index, %x: memref) -> f64 {
+  %one = arith.constant 1.000000e+00 : f64
+  %p = affine.for %i = 0 to %n iter_args(%acc = %one) -> (f64) {
+    %a = affine.load %x[%i] : memref
+    %new = arith.mulf %acc, %a : f64
+    affine.yield %new : f64
+  }
+  return %p : f64
+}
+
+// -----
+
+// Survey r14: integer-typed iter_arg, post-loop result cast to index and used
+// as an affine.for upper bound. RAUW propagates through the cast naturally.
+// CHECK-LABEL: func.func @hist
+// CHECK:         %[[SLOT:.+]] = memref.alloca() : memref
+// CHECK:         affine.for {{.*}} {
+// CHECK-NOT:       iter_args
+// CHECK:         }
+// CHECK:         %[[FIN:.+]] = affine.load %[[SLOT]][] : memref
+// CHECK:         %[[FINI:.+]] = arith.index_cast %[[FIN]] : i32 to index
+// CHECK:         affine.for {{.*}} = 0 to %[[FINI]]
+func.func @hist(%n: index, %x: memref) {
+  %c0 = arith.constant 0 : i32
+  %c1 = arith.constant 1 : i32
+  %cst = arith.constant 0.000000e+00 : f64
+  %count = affine.for %i = 0 to %n iter_args(%c = %c0) -> (i32) {
+    %a = affine.load %x[%i] : memref
+    %p = arith.cmpf ogt, %a, %cst : f64
+    %nc = scf.if %p -> (i32) {
+      %inc = arith.addi %c, %c1 : i32
+      scf.yield %inc : i32
+    } else {
+      scf.yield %c : i32
+    }
+    affine.yield %nc : i32
+  }
+  %ci = arith.index_cast %count : i32 to index
+  affine.for %j = 0 to %ci {
+    %ji = arith.index_cast %j : index to i32
+    func.call @use_int(%ji) : (i32) -> ()
+  }
+  return
+}
+func.func private @use_int(i32)
+
+// -----
+
+// Nested reductions (survey r15): inner iter_arg's result feeds the outer
+// iter_arg's body. Both loops should be rewritten — inner first by the
+// greedy driver, then outer.
+// CHECK-LABEL: func.func @dist
+// CHECK:         %[[OUT:.+]] = memref.alloca() : memref
+// CHECK:         affine.for {{.*}} {
+// CHECK-NOT:       iter_args
+// CHECK:           %[[IN:.+]] = memref.alloca() : memref
+// CHECK:           affine.for {{.*}} {
+// CHECK-NOT:         iter_args
+// CHECK:             affine.load %[[IN]][] : memref
+// CHECK:             affine.store %{{.*}}, %[[IN]][] : memref
+// CHECK:           }
+// CHECK:           affine.load %[[IN]][] : memref
+// CHECK:           affine.store %{{.*}}, %[[OUT]][] : memref
+// CHECK:         }
+// CHECK:         %[[RES:.+]] = affine.load %[[OUT]][] : memref
+// CHECK:         return %[[RES]] : f64
+func.func @dist(%m: index, %n: index, %A: memref) -> f64 {
+  %cst = arith.constant 0.000000e+00 : f64
+  %total = affine.for %i = 0 to %m iter_args(%t = %cst) -> (f64) {
+    %row = affine.for %j = 0 to %n iter_args(%r = %cst) -> (f64) {
+      %v = affine.load %A[%i * symbol(%n) + %j] : memref
+      %nr = arith.addf %r, %v : f64
+      affine.yield %nr : f64
+    }
+    %sq = arith.mulf %row, %row : f64
+    %nt = arith.addf %t, %sq : f64
+    affine.yield %nt : f64
+  }
+  return %total : f64
+}
+
+// -----
+
+// The unchanged load/store cleanup must not cross an intervening write. The
+// final store restores the value loaded before that write and is observable.
+// CHECK-LABEL: func.func @preserve_restore_after_write
+// CHECK: %[[OLD:.+]] = affine.load %[[A:.+]][0] : memref
+// CHECK: affine.store %{{.+}}, %[[A]][0] : memref
+// CHECK: affine.store %[[OLD]], %[[A]][0] : memref
+func.func @preserve_restore_after_write(%a: memref, %replacement: f64) {
+  %old = affine.load %a[0] : memref
+  affine.store %replacement, %a[0] : memref
+  affine.store %old, %a[0] : memref
+  return
+}
+
+// -----
+
+// A post-loop scale load is mathematically loop-invariant, but it is defined
+// after the loop and cannot be pulled into the loop without violating SSA
+// dominance. The distributive fast path must defer to the alloca fallback.
+// CHECK-LABEL: func.func @post_loop_scale
+// CHECK:         %[[SLOT:.+]] = memref.alloca() : memref
+// CHECK:         affine.for {{.*}} {
+// CHECK-NOT:       iter_args
+// CHECK:         }
+// CHECK:         %[[SUM:.+]] = affine.load %[[SLOT]][] : memref
+// CHECK:         %[[SCALE:.+]] = affine.load %{{.*}}[0] : memref
+// CHECK:         %[[SCALED:.+]] = arith.mulf %[[SUM]], %[[SCALE]] : f32
+// CHECK:         affine.store %[[SCALED]], %{{.*}}[0] : memref
+func.func @post_loop_scale(%n: index, %x: memref,
+                           %scale: memref, %out: memref) {
+  %zero = arith.constant 0.000000e+00 : f32
+  %sum = affine.for %i = 0 to %n iter_args(%acc = %zero) -> (f32) {
+    %v = affine.load %x[%i] : memref
+    %next = arith.addf %acc, %v : f32
+    affine.yield %next : f32
+  }
+  %s = affine.load %scale[0] : memref
+  %scaled = arith.mulf %sum, %s : f32
+  affine.store %scaled, %out[0] : memref
+  return
+}
diff --git a/test/polygeist-opt/select-func-dependencies.mlir b/test/polygeist-opt/select-func-dependencies.mlir
new file mode 100644
index 000000000000..4f53e692c3e4
--- /dev/null
+++ b/test/polygeist-opt/select-func-dependencies.mlir
@@ -0,0 +1,23 @@
+// RUN: polygeist-opt --select-func="func-name=root" %s | FileCheck %s
+
+module {
+  func.func @root(%arg0: f32) -> f32 {
+    %0 = func.call @helper(%arg0) : (f32) -> f32
+    return %0 : f32
+  }
+  func.func private @helper(%arg0: f32) -> f32 {
+    %0 = func.call @logf(%arg0) : (f32) -> f32
+    return %0 : f32
+  }
+  func.func private @logf(f32) -> f32
+  func.func @unrelated() {
+    return
+  }
+}
+
+// CHECK: func.func @root
+// CHECK: call @helper
+// CHECK: func.func private @helper
+// CHECK: call @logf
+// CHECK: func.func private @logf
+// CHECK-NOT: func.func @unrelated
diff --git a/test/polygeist-opt/submapcanonicalize.mlir b/test/polygeist-opt/submapcanonicalize.mlir
new file mode 100644
index 000000000000..21f3e72fb5a1
--- /dev/null
+++ b/test/polygeist-opt/submapcanonicalize.mlir
@@ -0,0 +1,71 @@
+// RUN: polygeist-opt -canonicalize %s | FileCheck %s
+#map = affine_map<(d0)[s0, s1] -> (d0 * s0, d0 * s1)>
+module @submap_to_load__store{
+  func.func private @use(i32)
+  func.func @f(%arg0: memref, %arg1 : index, %arg2 : index, %arg3 : index) {
+
+    %submap = "polygeist.submap"(%arg0, %arg1, %arg2) <{map = #map}> : (memref, index, index) -> memref
+
+    affine.for %arg4 = 0 to 10 {
+        %l = affine.load %submap[5 + %arg4 + symbol(%arg3)] : memref
+        func.call @use(%l) : (i32) -> ()
+        affine.yield
+    }
+    return
+  }
+
+  func.func @g(%arg0: memref, %arg1 : index, %arg2 : index, %arg3 : index, %arg4 : i32) {
+    %submap = "polygeist.submap"(%arg0, %arg1, %arg2) <{map = #map}> : (memref, index, index) -> memref
+    affine.for %arg5 = 0 to 10 {
+        affine.store %arg4, %submap[5 + %arg5 + symbol(%arg3)] : memref
+        affine.yield
+    }
+    return
+  }
+}
+
+
+// CHECK:   func.func @f(%arg0: memref, %arg1: index, %arg2: index, %arg3: index) {
+// CHECK-NEXT:     affine.for %arg4 = 0 to 10 {
+// CHECK-NEXT:       %0 = affine.load %arg0[(%arg4 + symbol(%arg3) + 5) * symbol(%arg1), (%arg4 + symbol(%arg3) + 5) * symbol(%arg2)] : memref
+// CHECK-NEXT:       func.call @use(%0) : (i32) -> ()
+// CHECK-NEXT:     }
+// CHECK-NEXT:     return
+// CHECK-NEXT:   }
+
+// CHECK:   func.func @g(%arg0: memref, %arg1: index, %arg2: index, %arg3: index, %arg4: i32) {
+// CHECK-NEXT:     affine.for %arg5 = 0 to 10 {
+// CHECK-NEXT:       affine.store %arg4, %arg0[(%arg5 + symbol(%arg3) + 5) * symbol(%arg1), (%arg5 + symbol(%arg3) + 5) * symbol(%arg2)] : memref
+// CHECK-NEXT:     }
+// CHECK-NEXT:     return
+// CHECK-NEXT:   }
+
+#map19 = affine_map<(d0, d1, d2, d3) -> (d1 + d3, d0 + d2)>
+#map20 = affine_map<(d0, d1, d2, d3) -> (d1, d0)>
+#map21 = affine_map<(d0, d1, d2, d3) -> (d3, d2)>
+#map22 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
+module @conv_1 {
+  memref.global @out : memref<512x64xi32> = uninitialized
+  memref.global @filter : memref<4x4xi32> = uninitialized
+  memref.global @im : memref<515x67xi32> = uninitialized
+  func.func @main() -> i32 attributes {llvm.linkage = #llvm.linkage} {
+    %c512 = arith.constant 512 : index
+    %c64 = arith.constant 64 : index
+    %c4 = arith.constant 4 : index
+    %c0_i32 = arith.constant 0 : i32
+    %0 = memref.get_global @im : memref<515x67xi32>
+    %1 = memref.get_global @filter : memref<4x4xi32>
+    %2 = memref.get_global @out : memref<512x64xi32>
+    %3 = "polygeist.submap"(%0, %c4, %c4, %c64, %c512) <{map = #map19}> : (memref<515x67xi32>, index, index, index, index) -> memref<4x4x64x512xi32>
+    %ssmap = "polygeist.submap"(%3, %c4, %c4, %c64, %c512) <{map = #map22}> : (memref<4x4x64x512xi32>, index, index, index, index) -> memref
+    %4 = "polygeist.submap"(%1, %c4, %c4, %c64, %c512) <{map = #map20}> : (memref<4x4xi32>, index, index, index, index) -> memref
+    %5 = "polygeist.submap"(%2, %c4, %c4, %c64, %c512) <{map = #map21}> : (memref<512x64xi32>, index, index, index, index) -> memref
+    linalg.generic {indexing_maps = [#map22, #map22, #map22], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%ssmap, %4 : memref, memref) outs(%5 : memref) {
+    ^bb0(%in: i32, %in_0: i32, %out: i32):
+      %6 = arith.muli %in, %in_0 : i32
+      %7 = arith.addi %out, %6 : i32
+      linalg.yield %7 : i32
+    }
+    return %c0_i32 : i32
+  }
+}
\ No newline at end of file
diff --git a/test/polygeist-opt/wrap-kernel-launch-pipeline.mlir b/test/polygeist-opt/wrap-kernel-launch-pipeline.mlir
new file mode 100644
index 000000000000..cb47eaf5e435
--- /dev/null
+++ b/test/polygeist-opt/wrap-kernel-launch-pipeline.mlir
@@ -0,0 +1,57 @@
+// RUN: polygeist-opt --wrap-kernel-launch-pipeline %s | FileCheck %s
+// RUN: polygeist-opt --wrap-kernel-launch-pipeline --wrap-kernel-launch-pipeline %s | FileCheck %s
+
+module {
+  func.func private @polygeist_cublas_dgemm(i32)
+  func.func private @polygeist_cutensornet_contraction2_f64(i32)
+  func.func private @some_host_helper(i32)
+
+  func.func @matched_dispatch(%arg0: i32) {
+    func.call @polygeist_cublas_dgemm(%arg0) : (i32) -> ()
+    return
+  }
+
+  func.func @host_only(%arg0: i32) {
+    func.call @some_host_helper(%arg0) : (i32) -> ()
+    return
+  }
+
+  func.func @mixed_dispatch(%arg0: i32, %input: tensor<4xf64>,
+                            %output: tensor<4xf64>) -> tensor<4xf64> {
+    func.call @polygeist_cutensornet_contraction2_f64(%arg0) : (i32) -> ()
+    %0 = linalg.generic {
+      indexing_maps = [affine_map<(d0) -> (d0)>,
+                       affine_map<(d0) -> (d0)>],
+      iterator_types = ["parallel"]
+    } ins(%input : tensor<4xf64>) outs(%output : tensor<4xf64>) {
+    ^bb0(%in: f64, %out: f64):
+      %sum = arith.addf %in, %out : f64
+      linalg.yield %sum : f64
+    } -> tensor<4xf64>
+    func.call @polygeist_cutensornet_contraction2_f64(%arg0) : (i32) -> ()
+    return %0 : tensor<4xf64>
+  }
+}
+
+// CHECK-LABEL: func.func @matched_dispatch
+// CHECK-NEXT: call @polygeist_cublas_pipeline_begin() : () -> ()
+// CHECK-NEXT: call @polygeist_cublas_dgemm
+// CHECK-NEXT: call @polygeist_cublas_pipeline_end() : () -> ()
+// CHECK-NEXT: return
+
+// CHECK-LABEL: func.func @host_only
+// CHECK-NEXT: call @some_host_helper
+// CHECK-NEXT: return
+
+// CHECK-LABEL: func.func @mixed_dispatch
+// CHECK: call @polygeist_cublas_pipeline_begin() : () -> ()
+// CHECK-NEXT: call @polygeist_cutensornet_contraction2_f64
+// CHECK-NEXT: call @polygeist_cublas_pipeline_end() : () -> ()
+// CHECK-NEXT: %[[GENERIC:.*]] = linalg.generic
+// CHECK: call @polygeist_cublas_pipeline_begin() : () -> ()
+// CHECK-NEXT: call @polygeist_cutensornet_contraction2_f64
+// CHECK-NEXT: call @polygeist_cublas_pipeline_end() : () -> ()
+// CHECK-NEXT: return %[[GENERIC]]
+
+// CHECK-DAG: func.func private @polygeist_cublas_pipeline_begin()
+// CHECK-DAG: func.func private @polygeist_cublas_pipeline_end()
diff --git a/third_party/NPB-polybenchified/bt_add.c b/third_party/NPB-polybenchified/bt_add.c
new file mode 100644
index 000000000000..44ce2ed41d8a
--- /dev/null
+++ b/third_party/NPB-polybenchified/bt_add.c
@@ -0,0 +1,29 @@
+// PolyBench-style extraction of NPB BT's `add` kernel.
+// Original (NPB3.0-omp-C/BT/bt.c lines 181-199): u[i][j][k][m] += rhs[i][j][k][m]
+// over the interior of the 4D field.
+//
+// In NPB, `u` and `rhs` are file-local static 4D arrays, and `grid_points` is
+// a 3-element static int array set at runtime. Here we pass them as parameters
+// with class-S sizes (problem_size = 12 ⇒ IMAX = JMAX = KMAX = 12 + 1).
+
+#define IMAX 13
+#define JMAX 13
+#define KMAX 13
+
+// Bounds passed as scalar ints (not loaded from an array) so the raise pass
+// can recognise the loops as affine.
+void bt_add(double u[IMAX][JMAX][KMAX][5],
+            double rhs[IMAX][JMAX][KMAX][5],
+            int gpx, int gpy, int gpz) {
+  int i, j, k, m;
+
+  for (i = 1; i < gpx - 1; i++) {
+    for (j = 1; j < gpy - 1; j++) {
+      for (k = 1; k < gpz - 1; k++) {
+        for (m = 0; m < 5; m++) {
+          u[i][j][k][m] = u[i][j][k][m] + rhs[i][j][k][m];
+        }
+      }
+    }
+  }
+}
diff --git a/third_party/NPB-polybenchified/ft_evolve.c b/third_party/NPB-polybenchified/ft_evolve.c
new file mode 100644
index 000000000000..8e3d1bc5b15e
--- /dev/null
+++ b/third_party/NPB-polybenchified/ft_evolve.c
@@ -0,0 +1,30 @@
+// PolyBench-style extraction of NPB FT's `evolve` kernel.
+// Original (NPB3.0-omp-C/FT/ft.c lines 225-245): u1 = u0 * ex[t*indexmap].
+//
+// The original uses a `dcomplex` struct {double real; double imag;}; we
+// flatten that to a trailing dimension of size 2 so the IR sees a plain
+// rank-4 double array — exactly how cgeist would lower the struct anyway.
+
+#define NX 64
+#define NY 64
+#define NZ 64
+#define EXP_MAX (200 * (NX*NX/4 + NY*NY/4 + NZ*NZ/4))
+
+// d-dimensions passed as scalar ints so the loops are recognised as affine.
+void ft_evolve(double u0[NZ][NY][NX][2],
+               double u1[NZ][NY][NX][2],
+               int t,
+               int indexmap[NZ][NY][NX],
+               int d0, int d1, int d2,
+               double ex[EXP_MAX]) {
+  int i, j, k;
+  for (k = 0; k < d2; k++) {
+    for (j = 0; j < d1; j++) {
+      for (i = 0; i < d0; i++) {
+        double scale = ex[t * indexmap[k][j][i]];
+        u1[k][j][i][0] = u0[k][j][i][0] * scale;
+        u1[k][j][i][1] = u0[k][j][i][1] * scale;
+      }
+    }
+  }
+}
diff --git a/third_party/NPB-polybenchified/lu_l2norm.c b/third_party/NPB-polybenchified/lu_l2norm.c
new file mode 100644
index 000000000000..9b8e5d9f56d1
--- /dev/null
+++ b/third_party/NPB-polybenchified/lu_l2norm.c
@@ -0,0 +1,34 @@
+// PolyBench-style extraction of NPB LU's `l2norm` kernel.
+// Original (NPB3.0-omp-C/LU/lu.c lines 1981-2030).
+// Computes the 5-component L2 norm of a 4D field v over the interior.
+//
+// NPB pads dims 2 and 3 by 1 ("ISIZ2/2*2+1") — we keep that exactly so the
+// access pattern matches.
+
+#define ISIZ1 12
+#define ISIZ2 12
+#define ISIZ3 12
+#define D2 (ISIZ2/2*2 + 1)
+#define D3 (ISIZ3/2*2 + 1)
+
+void lu_l2norm(int nx0, int ny0, int nz0,
+               int ist, int iend,
+               int jst, int jend,
+               double v[ISIZ1][D2][D3][5],
+               double sum[5]) {
+  int i, j, k, m;
+
+  for (m = 0; m < 5; m++) sum[m] = 0.0;
+
+  for (i = ist; i <= iend; i++) {
+    for (j = jst; j <= jend; j++) {
+      for (k = 1; k <= nz0 - 2; k++) {
+        sum[0] = sum[0] + v[i][j][k][0] * v[i][j][k][0];
+        sum[1] = sum[1] + v[i][j][k][1] * v[i][j][k][1];
+        sum[2] = sum[2] + v[i][j][k][2] * v[i][j][k][2];
+        sum[3] = sum[3] + v[i][j][k][3] * v[i][j][k][3];
+        sum[4] = sum[4] + v[i][j][k][4] * v[i][j][k][4];
+      }
+    }
+  }
+}
diff --git a/third_party/NPB-polybenchified/mg_norm2u3.c b/third_party/NPB-polybenchified/mg_norm2u3.c
new file mode 100644
index 000000000000..ff0d267cd844
--- /dev/null
+++ b/third_party/NPB-polybenchified/mg_norm2u3.c
@@ -0,0 +1,36 @@
+// PolyBench-style extraction of NPB MG's `norm2u3` kernel.
+// Original (NPB3.0-omp-C/MG/mg.c lines 806-860): computes L2 norm `rnm2` and
+// L-infinity norm `rnmu` over interior of r. The L-infinity branch uses
+// `fabs` + `max` (non-affine — likely won't lift); the L2 branch is a pure
+// sum-of-squares reduction (should lift).
+
+#define N1 34
+#define N2 34
+#define N3 34
+
+double  my_fabs(double x) { return x < 0.0 ? -x : x; }
+double  my_max(double a, double b) { return a > b ? a : b; }
+
+void mg_norm2u3(double r[N3][N2][N1],
+                int n1, int n2, int n3,
+                double *rnm2, double *rnmu,
+                int nx, int ny, int nz) {
+  double s = 0.0;
+  int i3, i2, i1, n;
+  double a = 0.0, tmp = 0.0;
+
+  n = nx * ny * nz;
+
+  for (i3 = 1; i3 < n3 - 1; i3++) {
+    for (i2 = 1; i2 < n2 - 1; i2++) {
+      for (i1 = 1; i1 < n1 - 1; i1++) {
+        s = s + r[i3][i2][i1] * r[i3][i2][i1];
+        tmp = my_fabs(r[i3][i2][i1]);
+        if (tmp > a) a = tmp;
+      }
+    }
+  }
+
+  *rnm2 = s / (double)n;  // NPB does a sqrt after; left as caller's job
+  *rnmu = a;
+}
diff --git a/third_party/NPB-polybenchified/mg_psinv.c b/third_party/NPB-polybenchified/mg_psinv.c
new file mode 100644
index 000000000000..cc7e0f51bdbc
--- /dev/null
+++ b/third_party/NPB-polybenchified/mg_psinv.c
@@ -0,0 +1,38 @@
+// PolyBench-style extraction of NPB MG's `psinv` kernel (smoother).
+// Original (NPB3.0-omp-C/MG/mg.c lines 434-490): u = u + Cr, with 27-stencil
+// applied via two scratch rows r1[], r2[].
+//
+// NPB MG uses `double ***` triple-pointer arrays. We rewrite as fixed-size
+// 3D `double [N3][N2][N1]` (the polybench convention). N1=N2=N3=34 picks
+// class-S MG: lt=8, nx=ny=nz=32, +2 ghost = 34. The kernel itself doesn't
+// depend on the exact size; we pass n1/n2/n3 as parameters for the bounds.
+
+#define N1 34
+#define N2 34
+#define N3 34
+#define M  35
+
+void mg_psinv(double r[N3][N2][N1],
+              double u[N3][N2][N1],
+              int n1, int n2, int n3,
+              double c[4]) {
+  int i3, i2, i1;
+  double r1[M], r2[M];
+
+  for (i3 = 1; i3 < n3 - 1; i3++) {
+    for (i2 = 1; i2 < n2 - 1; i2++) {
+      for (i1 = 0; i1 < n1; i1++) {
+        r1[i1] = r[i3][i2-1][i1] + r[i3][i2+1][i1]
+               + r[i3-1][i2][i1] + r[i3+1][i2][i1];
+        r2[i1] = r[i3-1][i2-1][i1] + r[i3-1][i2+1][i1]
+               + r[i3+1][i2-1][i1] + r[i3+1][i2+1][i1];
+      }
+      for (i1 = 1; i1 < n1 - 1; i1++) {
+        u[i3][i2][i1] = u[i3][i2][i1]
+            + c[0] * r[i3][i2][i1]
+            + c[1] * ( r[i3][i2][i1-1] + r[i3][i2][i1+1] + r1[i1] )
+            + c[2] * ( r2[i1] + r1[i1-1] + r1[i1+1] );
+      }
+    }
+  }
+}
diff --git a/third_party/NPB-polybenchified/mg_resid.c b/third_party/NPB-polybenchified/mg_resid.c
new file mode 100644
index 000000000000..cc2a7304bb3c
--- /dev/null
+++ b/third_party/NPB-polybenchified/mg_resid.c
@@ -0,0 +1,36 @@
+// PolyBench-style extraction of NPB MG's `resid` kernel (residual r = v - Au).
+// Original (NPB3.0-omp-C/MG/mg.c lines 495-552).
+//
+// Same shape as psinv (27-point stencil via two scratch rows) but writes r
+// instead of u and uses coefficients a[0]..a[3] (with a[1]=0 elided).
+
+#define N1 34
+#define N2 34
+#define N3 34
+#define M  35
+
+void mg_resid(double u[N3][N2][N1],
+              double v[N3][N2][N1],
+              double r[N3][N2][N1],
+              int n1, int n2, int n3,
+              double a[4]) {
+  int i3, i2, i1;
+  double u1[M], u2[M];
+
+  for (i3 = 1; i3 < n3 - 1; i3++) {
+    for (i2 = 1; i2 < n2 - 1; i2++) {
+      for (i1 = 0; i1 < n1; i1++) {
+        u1[i1] = u[i3][i2-1][i1] + u[i3][i2+1][i1]
+               + u[i3-1][i2][i1] + u[i3+1][i2][i1];
+        u2[i1] = u[i3-1][i2-1][i1] + u[i3-1][i2+1][i1]
+               + u[i3+1][i2-1][i1] + u[i3+1][i2+1][i1];
+      }
+      for (i1 = 1; i1 < n1 - 1; i1++) {
+        r[i3][i2][i1] = v[i3][i2][i1]
+            - a[0] * u[i3][i2][i1]
+            - a[2] * ( u2[i1] + u1[i1-1] + u1[i1+1] )
+            - a[3] * ( u2[i1-1] + u2[i1+1] );
+      }
+    }
+  }
+}
diff --git a/third_party/NPB-polybenchified/mg_rprj3.c b/third_party/NPB-polybenchified/mg_rprj3.c
new file mode 100644
index 000000000000..d4f864ead7d7
--- /dev/null
+++ b/third_party/NPB-polybenchified/mg_rprj3.c
@@ -0,0 +1,51 @@
+// PolyBench-style extraction of NPB MG's `rprj3` kernel (restriction operator).
+// Original (NPB3.0-omp-C/MG/mg.c lines 557-636): projects a fine-grid array r
+// onto a coarse-grid s via trilinear FE projection (s = P r). Loops over the
+// coarse grid; reads at i = 2*j - d (downsampling).
+//
+// The `d1/d2/d3` step factors depend on whether the coarse grid dim equals 3
+// (boundary case). We pass them as scalars.
+
+// Fine-grid size N1f x N2f x N3f, coarse-grid size N1c x N2c x N3c.
+#define N1F 34
+#define N2F 34
+#define N3F 34
+#define N1C 18
+#define N2C 18
+#define N3C 18
+#define M   35
+
+void mg_rprj3(double r[N3F][N2F][N1F], int m1k, int m2k, int m3k,
+              double s[N3C][N2C][N1C], int m1j, int m2j, int m3j,
+              int d1, int d2, int d3) {
+  int j3, j2, j1, i3, i2, i1;
+  double x1[M], y1[M], x2, y2;
+
+  for (j3 = 1; j3 < m3j - 1; j3++) {
+    i3 = 2 * j3 - d3;
+    for (j2 = 1; j2 < m2j - 1; j2++) {
+      i2 = 2 * j2 - d2;
+
+      for (j1 = 1; j1 < m1j; j1++) {
+        i1 = 2 * j1 - d1;
+        x1[i1] = r[i3+1][i2][i1] + r[i3+1][i2+2][i1]
+               + r[i3][i2+1][i1] + r[i3+2][i2+1][i1];
+        y1[i1] = r[i3][i2][i1] + r[i3+2][i2][i1]
+               + r[i3][i2+2][i1] + r[i3+2][i2+2][i1];
+      }
+
+      for (j1 = 1; j1 < m1j - 1; j1++) {
+        i1 = 2 * j1 - d1;
+        y2 = r[i3][i2][i1+1] + r[i3+2][i2][i1+1]
+           + r[i3][i2+2][i1+1] + r[i3+2][i2+2][i1+1];
+        x2 = r[i3+1][i2][i1+1] + r[i3+1][i2+2][i1+1]
+           + r[i3][i2+1][i1+1] + r[i3+2][i2+1][i1+1];
+        s[j3][j2][j1] =
+            0.5    * r[i3+1][i2+1][i1+1]
+          + 0.25   * ( r[i3+1][i2+1][i1] + r[i3+1][i2+1][i1+2] + x2)
+          + 0.125  * ( x1[i1] + x1[i1+2] + y2)
+          + 0.0625 * ( y1[i1] + y1[i1+2] );
+      }
+    }
+  }
+}
diff --git a/third_party/cnn-extracted/ata_gemm.c b/third_party/cnn-extracted/ata_gemm.c
new file mode 100644
index 000000000000..f39cc788479e
--- /dev/null
+++ b/third_party/cnn-extracted/ata_gemm.c
@@ -0,0 +1,49 @@
+/* ata_gemm.c — AᵀA, a Gram-matrix shape that LOOKS like a gemm to the
+ * matcher's body unifier but happens to read the same tensor twice.
+ *
+ *   C[m, n] = sum_k A[k, m] * A[k, n]      // AᵀA — symmetric output
+ *
+ * The matcher's discriminator (post-unify check on operand aliasing)
+ * should detect that both ins of the matched gemm body resolve to the
+ * same underlying tensor and route to cublasDsyrk (half the flops:
+ * writes only the upper triangle, beta=0).
+ */
+#include 
+#include 
+
+#ifndef DATA_TYPE
+# define DATA_TYPE float
+#endif
+
+#if defined(MINI_DATASET)
+# define M 64
+# define K 64
+#elif defined(LARGE_DATASET)
+# define M 2048
+# define K 2048
+#else
+# define M 64
+# define K 64
+#endif
+
+/* C = AᵀA. A is K×M, C is M×M, symmetric. Explicit init + accumulate
+ * form: that's what's idiomatic in real-world gemm-shaped C code, and
+ * is what the matcher's 2-step gemm composition expects. The
+ * cublasSsyrk shim overwrites C with β=0, so the preceding memset is
+ * mathematically redundant — the lowering pass detects the
+ * "memset_zero_2D launch immediately preceding a syrk_alias launch on
+ * the same output base" pattern and erases the memset. */
+void kernel_ata_gemm(DATA_TYPE A[K][M], DATA_TYPE C[M][M]) {
+  int m, n, k;
+
+  #pragma scop
+  for (m = 0; m < M; ++m)
+    for (n = 0; n < M; ++n)
+      C[m][n] = 0;
+
+  for (m = 0; m < M; ++m)
+    for (n = 0; n < M; ++n)
+      for (k = 0; k < K; ++k)
+        C[m][n] += A[k][m] * A[k][n];
+  #pragma endscop
+}
diff --git a/third_party/cnn-extracted/batchnorm_batched.c b/third_party/cnn-extracted/batchnorm_batched.c
new file mode 100644
index 000000000000..96b2ba60b111
--- /dev/null
+++ b/third_party/cnn-extracted/batchnorm_batched.c
@@ -0,0 +1,67 @@
+/* batchnorm_batched.c — batched, per-channel batch normalization (inference).
+ *
+ * Extracted form of darknet's forward_batchnorm_layer (inference mode).
+ * Same lift-friendly conventions as conv2d_batched.c / maxpool_batched.c:
+ * scalar-int loop bounds via polybench-style dataset macros, perfect
+ * nested affine for-loops, no scalar accumulator inside the body.
+ *
+ * The inference-mode formula collapses normalize + scale + bias into a
+ * single fused element-wise op (cuDNN's cudnnBatchNormalizationForwardInference
+ * does exactly this — the running stats are pre-computed, so there is no
+ * cross-element reduction):
+ *
+ *   out[b,c,h,w] = scale[c] * (in[b,c,h,w] - mean[c]) * inv_std[c] + bias[c]
+ *
+ * where inv_std[c] = 1.0 / sqrt(var[c] + eps) is precomputed by the caller.
+ *
+ * Shape: NCHW. Iters: 4-parallel (B, C, H, W). Zero reductions.
+ *
+ * For a real ResNet conv2_x batchnorm: B=32, C=64, H=W=56.
+ */
+#include 
+#include 
+
+#ifndef DATA_TYPE
+# define DATA_TYPE float
+#endif
+
+#if defined(MINI_DATASET)
+# define B    4
+# define C    8
+# define H    32
+# define W    32
+#elif defined(LARGE_DATASET)
+# define B    32
+# define C    64
+# define H    56
+# define W    56
+#else
+# define B    4
+# define C    8
+# define H    32
+# define W    32
+#endif
+
+/* The kernel. 4-deep parallel nest. Each output element reads:
+ *   - in[b,c,h,w]
+ *   - scale[c], mean[c], inv_std[c], bias[c]   (per-channel params)
+ * and writes one out element. No reductions, so raise produces a single
+ * linalg.generic with iter_types=[par×4] and 5 inputs.
+ */
+void kernel_batchnorm_batched(DATA_TYPE A[B][C][H][W],
+                               DATA_TYPE scale[C],
+                               DATA_TYPE mean[C],
+                               DATA_TYPE inv_std[C],
+                               DATA_TYPE bias[C],
+                               DATA_TYPE Bout[B][C][H][W]) {
+  int b, c, h, w;
+
+  #pragma scop
+  for (b = 0; b < B; ++b)
+    for (c = 0; c < C; ++c)
+      for (h = 0; h < H; ++h)
+        for (w = 0; w < W; ++w)
+          Bout[b][c][h][w] =
+              scale[c] * (A[b][c][h][w] - mean[c]) * inv_std[c] + bias[c];
+  #pragma endscop
+}
diff --git a/third_party/cnn-extracted/conv1x1_batched.c b/third_party/cnn-extracted/conv1x1_batched.c
new file mode 100644
index 000000000000..f17982e47c5b
--- /dev/null
+++ b/third_party/cnn-extracted/conv1x1_batched.c
@@ -0,0 +1,60 @@
+/* conv1x1_batched.c — batched 1×1 convolution. Mathematically a
+ * per-pixel matmul: (B·H·W, IC) × (IC, OC) → (B·H·W, OC).
+ *
+ * cuDNN's K=1 conv path is generic (no Winograd, no IMPLICIT_PRECOMP_GEMM
+ * specialisation); the matcher's lowering detects K=1 statically from
+ * the filter's last two dims and routes to cublasDgemm instead, which
+ * gets tensor cores on Ampere+.
+ *
+ * NCHW, FP32, no padding, stride 1, K=1.
+ */
+#include 
+#include 
+
+#ifndef DATA_TYPE
+# define DATA_TYPE float
+#endif
+
+#if defined(MINI_DATASET)
+# define B  4
+# define IC 16
+# define OC 16
+# define H  32
+# define W  32
+#elif defined(LARGE_DATASET)
+# define B  32
+# define IC 256
+# define OC 256
+# define H  56
+# define W  56
+#else
+# define B  4
+# define IC 16
+# define OC 16
+# define H  32
+# define W  32
+#endif
+#define KS 1
+#define OH H
+#define OW W
+
+void kernel_conv1x1_batched(DATA_TYPE A[B][IC][H][W],
+                              DATA_TYPE F[OC][IC][KS][KS],
+                              DATA_TYPE Bout[B][OC][OH][OW]) {
+  int b, oc, ic, oh, ow;
+
+  #pragma scop
+  for (b = 0; b < B; ++b)
+    for (oc = 0; oc < OC; ++oc)
+      for (oh = 0; oh < OH; ++oh)
+        for (ow = 0; ow < OW; ++ow)
+          Bout[b][oc][oh][ow] = 0;
+
+  for (b = 0; b < B; ++b)
+    for (oc = 0; oc < OC; ++oc)
+      for (oh = 0; oh < OH; ++oh)
+        for (ow = 0; ow < OW; ++ow)
+          for (ic = 0; ic < IC; ++ic)
+            Bout[b][oc][oh][ow] += A[b][ic][oh][ow] * F[oc][ic][0][0];
+  #pragma endscop
+}
diff --git a/third_party/cnn-extracted/conv2d_batched.c b/third_party/cnn-extracted/conv2d_batched.c
new file mode 100644
index 000000000000..454b44565eeb
--- /dev/null
+++ b/third_party/cnn-extracted/conv2d_batched.c
@@ -0,0 +1,151 @@
+/* conv2d_batched.c — batched, multi-channel 2D convolution (forward).
+ *
+ * The polybenchGpu conv2d is single-batch, single-channel, fixed 3×3 — the
+ * worst possible shape for cuDNN. This file extracts a "real" CNN conv
+ * layer: batch + channels + filter loop. ResNet-style. Polybench-style
+ * harness so cgeist can lift it via affine.for.
+ *
+ * Direct convolution form (no im2col). The 7-deep loop nest below is what
+ * cuDNN's IMPLICIT_PRECOMP_GEMM algorithm computes — just with cuBLAS
+ * tiling instead of a naive loop. Matcher should recognise it as a
+ * 4-parallel + 3-reduction tensor contraction (eventually mapping to
+ * cublasDgemm via im2col, or directly to cudnnConvolutionForward).
+ *
+ * No padding, stride 1, no dilation, no activation. NCHW layout.
+ *
+ * Default MINI shape: B=4, C=8, H=W=32, K=3 (output H=W=30).
+ *   Total flops:  4 × 8 × 30² × 8 × 9 = 207360
+ *   Total input data: 4 × 8 × 32² × 4 = 128 KB
+ *
+ * LARGE shape (ResNet-50 conv2 size): B=32, C=64, H=W=56, K=3 (output 54²).
+ *   Total flops:  32 × 64 × 54² × 64 × 9 ≈ 3.4 GFLOPs
+ *   Total data ≈ 30 MB
+ */
+
+#include 
+#include 
+
+#ifndef DATA_TYPE
+# define DATA_TYPE float
+#endif
+
+/* Polybench-style dataset macros. Pick one via -D{MINI,LARGE,XLARGE}_DATASET */
+#if defined(MINI_DATASET)
+# define B    4
+# define IC   8
+# define OC   8
+# define H    32
+# define W    32
+# define KS   3
+#elif defined(LARGE_DATASET)
+# define B    32
+# define IC   64
+# define OC   64
+# define H    56
+# define W    56
+# define KS   3
+#elif defined(XLARGE_DATASET)
+# define B    32
+# define IC   128
+# define OC   128
+# define H    28
+# define W    28
+# define KS   3
+#else
+/* default = MINI */
+# define B    4
+# define IC   8
+# define OC   8
+# define H    32
+# define W    32
+# define KS   3
+#endif
+
+#define OH (H - KS + 1)
+#define OW (W - KS + 1)
+
+/* Init inputs with a simple linear pattern so the output values are
+ * predictable + check-summable. */
+static void init_array(DATA_TYPE A[B][IC][H][W],
+                       DATA_TYPE F[OC][IC][KS][KS]) {
+  int b, c, i, j;
+  for (b = 0; b < B; ++b)
+    for (c = 0; c < IC; ++c)
+      for (i = 0; i < H; ++i)
+        for (j = 0; j < W; ++j)
+          A[b][c][i][j] = (DATA_TYPE)((b + c + i + j) % 17) / (DATA_TYPE)17;
+  for (b = 0; b < OC; ++b)
+    for (c = 0; c < IC; ++c)
+      for (i = 0; i < KS; ++i)
+        for (j = 0; j < KS; ++j)
+          F[b][c][i][j] = (DATA_TYPE)((b * 3 + c * 5 + i * 7 + j) % 11)
+                          / (DATA_TYPE)11;
+}
+
+static void print_array(DATA_TYPE Bout[B][OC][OH][OW]) {
+  int b, c, i, j;
+  for (b = 0; b < B; ++b)
+    for (c = 0; c < OC; ++c)
+      for (i = 0; i < OH; ++i) {
+        for (j = 0; j < OW; ++j)
+          fprintf(stderr, "%0.4f ", Bout[b][c][i][j]);
+        if ((b * OC * OH + c * OH + i) % 20 == 0) fprintf(stderr, "\n");
+      }
+  fprintf(stderr, "\n");
+}
+
+/* The kernel. 7-deep loop nest:
+ *   for each (batch, out_channel, oh, ow) — parallel
+ *     for each (in_channel, kh, kw) — reduction
+ *       acc += A[b][ic][oh+kh][ow+kw] * F[oc][ic][kh][kw]
+ *
+ * Loop bounds are all macros expanded to compile-time constants, so cgeist
+ * lifts to affine.for cleanly (no struct-field-load issue).
+ */
+void kernel_conv2d_batched(DATA_TYPE A[B][IC][H][W],
+                            DATA_TYPE F[OC][IC][KS][KS],
+                            DATA_TYPE Bout[B][OC][OH][OW]) {
+  int b, oc, ic, oh, ow, kh, kw;
+
+  /* Two-pass form: explicit init nest (4 parallel) followed by the
+   * accumulation nest (4 parallel + 3 reduction). The init makes the
+   * accumulation form a perfect 7-deep nest with no scalar temp — the
+   * raise-affine-to-linalg pass needs this to fold all four outer
+   * parallel loops into the linalg.generic instead of leaving them as
+   * imperative affine.for with iter_args.
+   */
+  #pragma scop
+  /* Init: Bout = 0 */
+  for (b = 0; b < B; ++b)
+    for (oc = 0; oc < OC; ++oc)
+      for (oh = 0; oh < OH; ++oh)
+        for (ow = 0; ow < OW; ++ow)
+          Bout[b][oc][oh][ow] = 0;
+
+  /* Accumulate */
+  for (b = 0; b < B; ++b)
+    for (oc = 0; oc < OC; ++oc)
+      for (oh = 0; oh < OH; ++oh)
+        for (ow = 0; ow < OW; ++ow)
+          for (ic = 0; ic < IC; ++ic)
+            for (kh = 0; kh < KS; ++kh)
+              for (kw = 0; kw < KS; ++kw)
+                Bout[b][oc][oh][ow] +=
+                    A[b][ic][oh + kh][ow + kw] * F[oc][ic][kh][kw];
+  #pragma endscop
+}
+
+#ifdef MAIN
+int main(void) {
+  DATA_TYPE (*A)[IC][H][W] = malloc(sizeof(DATA_TYPE) * B * IC * H * W);
+  DATA_TYPE (*F)[IC][KS][KS] = malloc(sizeof(DATA_TYPE) * OC * IC * KS * KS);
+  DATA_TYPE (*Bout)[OC][OH][OW] = malloc(sizeof(DATA_TYPE) * B * OC * OH * OW);
+
+  init_array(A, F);
+  kernel_conv2d_batched(A, F, Bout);
+  print_array(Bout);
+
+  free(A); free(F); free(Bout);
+  return 0;
+}
+#endif
diff --git a/third_party/cnn-extracted/conv_bias_relu_add_batched.c b/third_party/cnn-extracted/conv_bias_relu_add_batched.c
new file mode 100644
index 000000000000..13b3928ef9fd
--- /dev/null
+++ b/third_party/cnn-extracted/conv_bias_relu_add_batched.c
@@ -0,0 +1,92 @@
+/* conv_bias_relu_add_batched.c — fused conv + bias + residual + relu.
+ *
+ * Canonical ResNet output stage. The matcher should fold all five loop
+ * nests (init + conv + bias + residual-add + relu) into one launch and
+ * route to cudnnConvolutionBiasActivationForward — whose API natively
+ * supports y = activation(α₁·conv(x,w) + α₂·z + bias).
+ *
+ * NCHW, FP32, no padding, stride 1, K×K filter.
+ */
+#include 
+#include 
+
+#ifndef DATA_TYPE
+# define DATA_TYPE float
+#endif
+
+#if defined(MINI_DATASET)
+# define B  4
+# define IC 8
+# define OC 8
+# define H  32
+# define W  32
+# define KS 3
+#elif defined(LARGE_DATASET)
+# define B  32
+# define IC 64
+# define OC 64
+# define H  56
+# define W  56
+# define KS 3
+#else
+# define B  4
+# define IC 8
+# define OC 8
+# define H  32
+# define W  32
+# define KS 3
+#endif
+#define OH (H - KS + 1)
+#define OW (W - KS + 1)
+
+void kernel_conv_bias_relu_add_batched(
+    DATA_TYPE A[B][IC][H][W],
+    DATA_TYPE F[OC][IC][KS][KS],
+    DATA_TYPE bias[OC],
+    DATA_TYPE Z[B][OC][OH][OW],
+    DATA_TYPE Bout[B][OC][OH][OW]) {
+  int b, oc, ic, oh, ow, kh, kw;
+
+  #pragma scop
+  /* (1) Init: Bout = 0 */
+  for (b = 0; b < B; ++b)
+    for (oc = 0; oc < OC; ++oc)
+      for (oh = 0; oh < OH; ++oh)
+        for (ow = 0; ow < OW; ++ow)
+          Bout[b][oc][oh][ow] = 0;
+
+  /* (2) Conv: Bout += A * F */
+  for (b = 0; b < B; ++b)
+    for (oc = 0; oc < OC; ++oc)
+      for (oh = 0; oh < OH; ++oh)
+        for (ow = 0; ow < OW; ++ow)
+          for (ic = 0; ic < IC; ++ic)
+            for (kh = 0; kh < KS; ++kh)
+              for (kw = 0; kw < KS; ++kw)
+                Bout[b][oc][oh][ow] +=
+                    A[b][ic][oh + kh][ow + kw] * F[oc][ic][kh][kw];
+
+  /* (3) Bias (per-output-channel, broadcast over B/OH/OW) */
+  for (b = 0; b < B; ++b)
+    for (oc = 0; oc < OC; ++oc)
+      for (oh = 0; oh < OH; ++oh)
+        for (ow = 0; ow < OW; ++ow)
+          Bout[b][oc][oh][ow] += bias[oc];
+
+  /* (4) Residual-add: Bout += Z (skip connection) */
+  for (b = 0; b < B; ++b)
+    for (oc = 0; oc < OC; ++oc)
+      for (oh = 0; oh < OH; ++oh)
+        for (ow = 0; ow < OW; ++ow)
+          Bout[b][oc][oh][ow] += Z[b][oc][oh][ow];
+
+  /* (5) ReLU (ternary form) */
+  for (b = 0; b < B; ++b)
+    for (oc = 0; oc < OC; ++oc)
+      for (oh = 0; oh < OH; ++oh)
+        for (ow = 0; ow < OW; ++ow) {
+          DATA_TYPE v = Bout[b][oc][oh][ow];
+          Bout[b][oc][oh][ow] = (v > 0.0f) ? v : 0.0f;
+        }
+  #pragma endscop
+}
diff --git a/third_party/cnn-extracted/conv_bn_relu_batched.c b/third_party/cnn-extracted/conv_bn_relu_batched.c
new file mode 100644
index 000000000000..8a326c161ca3
--- /dev/null
+++ b/third_party/cnn-extracted/conv_bn_relu_batched.c
@@ -0,0 +1,96 @@
+/* conv_bn_relu_batched.c — fused-pattern test kernel.
+ *
+ * Chains the three operations that make up the inner of a ResNet
+ * residual block (conv → bn → relu) into a single C function. Polybench-
+ * style. Goal: matcher should fold all four loop nests (init + conv +
+ * bn + relu) into one fused launch — `cudnnConvolutionBiasActivation
+ * Forward`-shaped — so the bandwidth-bound bn + relu ride the compute-
+ * bound conv's GPU win instead of paying their own per-call setup.
+ *
+ * NCHW, FP32, no padding, stride 1, K×K filter. OH = H - K + 1,
+ * OW = W - K + 1. BN is the inference-mode formula with pre-baked
+ * inv_std = 1/sqrt(var+eps). ReLU uses the ternary form so it lowers
+ * to arith.select (the if-form would leave residual affine.for).
+ */
+#include 
+#include 
+
+#ifndef DATA_TYPE
+# define DATA_TYPE float
+#endif
+
+#if defined(MINI_DATASET)
+# define B  4
+# define IC 8
+# define OC 8
+# define H  32
+# define W  32
+# define KS 3
+#elif defined(LARGE_DATASET)
+# define B  32
+# define IC 64
+# define OC 64
+# define H  56
+# define W  56
+# define KS 3
+#else
+# define B  4
+# define IC 8
+# define OC 8
+# define H  32
+# define W  32
+# define KS 3
+#endif
+#define OH (H - KS + 1)
+#define OW (W - KS + 1)
+
+/* Four-loop-nest body. Each nest is a separate linalg.generic after
+ * raising. The matcher's job is to fold all four into one launch. */
+void kernel_conv_bn_relu_batched(
+    DATA_TYPE A[B][IC][H][W],
+    DATA_TYPE F[OC][IC][KS][KS],
+    DATA_TYPE scale[OC],
+    DATA_TYPE mean[OC],
+    DATA_TYPE inv_std[OC],
+    DATA_TYPE bias[OC],
+    DATA_TYPE Bout[B][OC][OH][OW]) {
+  int b, oc, ic, oh, ow, kh, kw;
+
+  #pragma scop
+  /* (1) Init: Bout = 0 */
+  for (b = 0; b < B; ++b)
+    for (oc = 0; oc < OC; ++oc)
+      for (oh = 0; oh < OH; ++oh)
+        for (ow = 0; ow < OW; ++ow)
+          Bout[b][oc][oh][ow] = 0;
+
+  /* (2) Conv: Bout += A * F */
+  for (b = 0; b < B; ++b)
+    for (oc = 0; oc < OC; ++oc)
+      for (oh = 0; oh < OH; ++oh)
+        for (ow = 0; ow < OW; ++ow)
+          for (ic = 0; ic < IC; ++ic)
+            for (kh = 0; kh < KS; ++kh)
+              for (kw = 0; kw < KS; ++kw)
+                Bout[b][oc][oh][ow] +=
+                    A[b][ic][oh + kh][ow + kw] * F[oc][ic][kh][kw];
+
+  /* (3) BN (in-place): Bout = scale*(Bout - mean)*inv_std + bias */
+  for (b = 0; b < B; ++b)
+    for (oc = 0; oc < OC; ++oc)
+      for (oh = 0; oh < OH; ++oh)
+        for (ow = 0; ow < OW; ++ow)
+          Bout[b][oc][oh][ow] =
+              scale[oc] * (Bout[b][oc][oh][ow] - mean[oc]) * inv_std[oc]
+              + bias[oc];
+
+  /* (4) ReLU (in-place ternary): Bout = max(Bout, 0) */
+  for (b = 0; b < B; ++b)
+    for (oc = 0; oc < OC; ++oc)
+      for (oh = 0; oh < OH; ++oh)
+        for (ow = 0; ow < OW; ++ow) {
+          DATA_TYPE v = Bout[b][oc][oh][ow];
+          Bout[b][oc][oh][ow] = (v > 0.0f) ? v : 0.0f;
+        }
+  #pragma endscop
+}
diff --git a/third_party/cnn-extracted/darknet_im2col_gemm.c b/third_party/cnn-extracted/darknet_im2col_gemm.c
new file mode 100644
index 000000000000..d9fcf4992f55
--- /dev/null
+++ b/third_party/cnn-extracted/darknet_im2col_gemm.c
@@ -0,0 +1,161 @@
+/* darknet_im2col_gemm.c — extracted Darknet convolution in its original
+ * im2col + GEMM decomposition.
+ *
+ * Unlike third_party/darknet/src/convolutional_layer.c, this file keeps the
+ * im2col helper and the GEMM helper in the same translation unit as the
+ * kernel. That lets cgeist's inliner expose the full producer/consumer pair:
+ *
+ *   guarded im2col(data_im -> workspace) followed by GEMM(workspace -> out)
+ *
+ * The point is not to beat the direct-convolution extracted kernel; it is a
+ * small same-TU fixture for developing the GuardedIm2Col + GEMM -> Conv2D
+ * matcher.
+ */
+
+#include 
+#include 
+
+#ifndef DATA_TYPE
+#define DATA_TYPE float
+#endif
+
+#if defined(MINI_DATASET)
+#define IC  3
+#define OC  4
+#define H   8
+#define W   8
+#define KS  3
+#elif defined(LARGE_DATASET)
+#define IC  16
+#define OC  16
+#define H   32
+#define W   32
+#define KS  3
+#else
+#define IC  3
+#define OC  4
+#define H   8
+#define W   8
+#define KS  3
+#endif
+
+#define STRIDE 1
+#define PAD    1
+#define OH     ((H + 2 * PAD - KS) / STRIDE + 1)
+#define OW     ((W + 2 * PAD - KS) / STRIDE + 1)
+#define KCOL   (IC * KS * KS)
+#define NCOL   (OH * OW)
+
+static DATA_TYPE im2col_get_pixel(DATA_TYPE *im, int height, int width,
+                                  int row, int col, int channel, int pad) {
+  row -= pad;
+  col -= pad;
+
+  if (row < 0 || col < 0 || row >= height || col >= width)
+    return (DATA_TYPE)0;
+  return im[col + width * (row + height * channel)];
+}
+
+static void im2col_cpu(DATA_TYPE *data_im, int channels, int height, int width,
+                       int ksize, int stride, int pad, DATA_TYPE *data_col) {
+  int c, h, w;
+  int height_col = (height + 2 * pad - ksize) / stride + 1;
+  int width_col = (width + 2 * pad - ksize) / stride + 1;
+  int channels_col = channels * ksize * ksize;
+
+  for (c = 0; c < channels_col; ++c) {
+    int w_offset = c % ksize;
+    int h_offset = (c / ksize) % ksize;
+    int c_im = c / ksize / ksize;
+    for (h = 0; h < height_col; ++h) {
+      for (w = 0; w < width_col; ++w) {
+        int im_row = h_offset + h * stride;
+        int im_col = w_offset + w * stride;
+        int col_index = (c * height_col + h) * width_col + w;
+        data_col[col_index] = im2col_get_pixel(
+            data_im, height, width, im_row, im_col, c_im, pad);
+      }
+    }
+  }
+}
+
+static void gemm_nn(int M, int N, int K, DATA_TYPE alpha, DATA_TYPE *A,
+                    int lda, DATA_TYPE *B, int ldb, DATA_TYPE *C, int ldc) {
+  int i, j, k;
+  for (i = 0; i < M; ++i) {
+    for (k = 0; k < K; ++k) {
+      DATA_TYPE a_part = alpha * A[i * lda + k];
+      for (j = 0; j < N; ++j)
+        C[i * ldc + j] += a_part * B[k * ldb + j];
+    }
+  }
+}
+
+void kernel_darknet_im2col_gemm(int channels, int height, int width,
+                                int out_channels, int ksize, int stride,
+                                int pad, DATA_TYPE input[IC * H * W],
+                                DATA_TYPE weights[OC * KCOL],
+                                DATA_TYPE workspace[KCOL * NCOL],
+                                DATA_TYPE output[OC * NCOL]) {
+  int i;
+  int height_col = (height + 2 * pad - ksize) / stride + 1;
+  int width_col = (width + 2 * pad - ksize) / stride + 1;
+  int ncol = height_col * width_col;
+  int kcol = channels * ksize * ksize;
+
+#pragma scop
+  for (i = 0; i < out_channels * ncol; ++i)
+    output[i] = (DATA_TYPE)0;
+
+  im2col_cpu(input, channels, height, width, ksize, stride, pad, workspace);
+
+  gemm_nn(out_channels, ncol, kcol, (DATA_TYPE)1, weights, kcol, workspace,
+          ncol, output, ncol);
+#pragma endscop
+}
+
+static void init_array(DATA_TYPE input[IC * H * W],
+                       DATA_TYPE weights[OC * KCOL]) {
+  int c, h, w, oc, kh, kw;
+  for (c = 0; c < IC; ++c)
+    for (h = 0; h < H; ++h)
+      for (w = 0; w < W; ++w)
+        input[w + W * (h + H * c)] =
+            (DATA_TYPE)((c * 13 + h * 7 + w) % 19) / (DATA_TYPE)19;
+
+  for (oc = 0; oc < OC; ++oc)
+    for (c = 0; c < IC; ++c)
+      for (kh = 0; kh < KS; ++kh)
+        for (kw = 0; kw < KS; ++kw)
+          weights[kw + KS * (kh + KS * (c + IC * oc))] =
+              (DATA_TYPE)((oc * 5 + c * 3 + kh * 2 + kw) % 17) /
+              (DATA_TYPE)17;
+}
+
+static void print_array(DATA_TYPE output[OC * NCOL]) {
+  int oc, oh, ow;
+  for (oc = 0; oc < OC; ++oc)
+    for (oh = 0; oh < OH; ++oh)
+      for (ow = 0; ow < OW; ++ow)
+        fprintf(stderr, "%0.4f\n", output[ow + OW * (oh + OH * oc)]);
+}
+
+#ifdef MAIN
+int main(void) {
+  DATA_TYPE *input = malloc(sizeof(DATA_TYPE) * IC * H * W);
+  DATA_TYPE *weights = malloc(sizeof(DATA_TYPE) * OC * KCOL);
+  DATA_TYPE *workspace = malloc(sizeof(DATA_TYPE) * KCOL * NCOL);
+  DATA_TYPE *output = malloc(sizeof(DATA_TYPE) * OC * NCOL);
+
+  init_array(input, weights);
+  kernel_darknet_im2col_gemm(IC, H, W, OC, KS, STRIDE, PAD, input, weights,
+                             workspace, output);
+  print_array(output);
+
+  free(input);
+  free(weights);
+  free(workspace);
+  free(output);
+  return 0;
+}
+#endif
diff --git a/third_party/cnn-extracted/gemm_bias_relu.c b/third_party/cnn-extracted/gemm_bias_relu.c
new file mode 100644
index 000000000000..0742f96312fd
--- /dev/null
+++ b/third_party/cnn-extracted/gemm_bias_relu.c
@@ -0,0 +1,59 @@
+/* gemm_bias_relu.c — fused matmul + bias + relu, transformer FFN shape.
+ *
+ *   C[m,n] = relu(sum_k A[m,k] * B[k,n] + bias[n])
+ *
+ * Routes to cublasLt's CUBLASLT_EPILOGUE_RELU_BIAS for a single fused call.
+ */
+#include 
+#include 
+
+#ifndef DATA_TYPE
+# define DATA_TYPE float
+#endif
+
+#if defined(MINI_DATASET)
+# define M  64
+# define N  64
+# define K  64
+#elif defined(LARGE_DATASET)
+# define M  2048
+# define N  2048
+# define K  2048
+#else
+# define M  64
+# define N  64
+# define K  64
+#endif
+
+void kernel_gemm_bias_relu(
+    DATA_TYPE A[M][K],
+    DATA_TYPE B[K][N],
+    DATA_TYPE bias[N],
+    DATA_TYPE C[M][N]) {
+  int m, n, k;
+
+  #pragma scop
+  /* (1) Init: C = 0 */
+  for (m = 0; m < M; ++m)
+    for (n = 0; n < N; ++n)
+      C[m][n] = 0;
+
+  /* (2) Matmul: C += A * B */
+  for (m = 0; m < M; ++m)
+    for (n = 0; n < N; ++n)
+      for (k = 0; k < K; ++k)
+        C[m][n] += A[m][k] * B[k][n];
+
+  /* (3) Bias add (per column, broadcast over rows) */
+  for (m = 0; m < M; ++m)
+    for (n = 0; n < N; ++n)
+      C[m][n] += bias[n];
+
+  /* (4) ReLU (ternary form) */
+  for (m = 0; m < M; ++m)
+    for (n = 0; n < N; ++n) {
+      DATA_TYPE v = C[m][n];
+      C[m][n] = (v > 0.0f) ? v : 0.0f;
+    }
+  #pragma endscop
+}
diff --git a/third_party/cnn-extracted/llama2_extended_forward_bench.c b/third_party/cnn-extracted/llama2_extended_forward_bench.c
new file mode 100644
index 000000000000..7df27efd2f09
--- /dev/null
+++ b/third_party/cnn-extracted/llama2_extended_forward_bench.c
@@ -0,0 +1,457 @@
+/* llama2_extended_forward_bench.c -- fuller Llama2-style decode fixture.
+ *
+ * This is still a benchmark fixture, not the full Karpathy runtime. It models
+ * one token through one transformer block plus final logits:
+ *
+ *   token embedding
+ *   attention RMSNorm
+ *   Q/K/V projections
+ *   split-layout RoPE
+ *   KV cache write/read
+ *   attention scores + causal mask + softmax
+ *   attention value matvec + output projection + residual
+ *   FFN RMSNorm + gate/up projections + SwiGLU + down projection + residual
+ *   final RMSNorm + lm_head projection
+ *
+ * Two deliberate raise-friendly choices:
+ *   1. Q/K and RoPE use split even/odd tensors because the exact interleaved
+ *      layout is a known remaining raising gap.
+ *   2. The causal mask uses a branchless select expression because the branchy
+ *      if/else form is also a known raising gap.
+ */
+
+#include 
+#include 
+
+#ifndef DATA_TYPE
+#define DATA_TYPE float
+#endif
+
+#ifndef MODEL_DIM
+#define MODEL_DIM 64
+#endif
+
+#ifndef FFN_DIM
+#define FFN_DIM 128
+#endif
+
+#ifndef VOCAB
+#define VOCAB 256
+#endif
+
+#ifndef SEQ_LEN
+#define SEQ_LEN 32
+#endif
+
+#ifndef NUM_HEADS
+#define NUM_HEADS 4
+#endif
+
+#ifndef HEAD_DIM
+#define HEAD_DIM (MODEL_DIM / NUM_HEADS)
+#endif
+
+#ifndef HALF_HEAD_DIM
+#define HALF_HEAD_DIM (HEAD_DIM / 2)
+#endif
+
+#ifndef REPEAT
+#define REPEAT 1
+#endif
+
+#ifndef PRINT_ELEMS
+#define PRINT_ELEMS 8
+#endif
+
+#define NEG_INF ((DATA_TYPE)-3.4028234663852886e38f)
+
+__attribute__((noinline)) void kernel_llama2_extended_forward(
+    int token, int pos,
+    DATA_TYPE tok_embeddings[VOCAB][MODEL_DIM],
+    DATA_TYPE rms_att_weight[MODEL_DIM],
+    DATA_TYPE wq_even[NUM_HEADS][HALF_HEAD_DIM][MODEL_DIM],
+    DATA_TYPE wq_odd[NUM_HEADS][HALF_HEAD_DIM][MODEL_DIM],
+    DATA_TYPE wk_even[NUM_HEADS][HALF_HEAD_DIM][MODEL_DIM],
+    DATA_TYPE wk_odd[NUM_HEADS][HALF_HEAD_DIM][MODEL_DIM],
+    DATA_TYPE wv[MODEL_DIM][MODEL_DIM],
+    DATA_TYPE wo[MODEL_DIM][MODEL_DIM],
+    DATA_TYPE rms_ffn_weight[MODEL_DIM],
+    DATA_TYPE w_gate[FFN_DIM][MODEL_DIM],
+    DATA_TYPE w_up[FFN_DIM][MODEL_DIM],
+    DATA_TYPE w_down[MODEL_DIM][FFN_DIM],
+    DATA_TYPE rms_final_weight[MODEL_DIM],
+    DATA_TYPE lm_head[VOCAB][MODEL_DIM],
+    DATA_TYPE cos_table[SEQ_LEN][HALF_HEAD_DIM],
+    DATA_TYPE sin_table[SEQ_LEN][HALF_HEAD_DIM],
+    DATA_TYPE k_cache_even[SEQ_LEN][NUM_HEADS][HALF_HEAD_DIM],
+    DATA_TYPE k_cache_odd[SEQ_LEN][NUM_HEADS][HALF_HEAD_DIM],
+    DATA_TYPE v_cache[SEQ_LEN][MODEL_DIM],
+    DATA_TYPE x[MODEL_DIM],
+    DATA_TYPE att_normed[MODEL_DIM],
+    DATA_TYPE v[MODEL_DIM],
+    DATA_TYPE q_even[NUM_HEADS][HALF_HEAD_DIM],
+    DATA_TYPE q_odd[NUM_HEADS][HALF_HEAD_DIM],
+    DATA_TYPE k_even[NUM_HEADS][HALF_HEAD_DIM],
+    DATA_TYPE k_odd[NUM_HEADS][HALF_HEAD_DIM],
+    DATA_TYPE q_even_rot[NUM_HEADS][HALF_HEAD_DIM],
+    DATA_TYPE q_odd_rot[NUM_HEADS][HALF_HEAD_DIM],
+    DATA_TYPE k_read_even[SEQ_LEN][NUM_HEADS][HALF_HEAD_DIM],
+    DATA_TYPE k_read_odd[SEQ_LEN][NUM_HEADS][HALF_HEAD_DIM],
+    DATA_TYPE v_read[SEQ_LEN][MODEL_DIM],
+    DATA_TYPE scores[SEQ_LEN],
+    DATA_TYPE masked_scores[SEQ_LEN],
+    DATA_TYPE probs[SEQ_LEN],
+    DATA_TYPE att_out[MODEL_DIM],
+    DATA_TYPE proj_out[MODEL_DIM],
+    DATA_TYPE resid_att[MODEL_DIM],
+    DATA_TYPE ffn_normed[MODEL_DIM],
+    DATA_TYPE gate[FFN_DIM],
+    DATA_TYPE up[FFN_DIM],
+    DATA_TYPE ffn_hidden[FFN_DIM],
+    DATA_TYPE ffn_out[MODEL_DIM],
+    DATA_TYPE resid_ffn[MODEL_DIM],
+    DATA_TYPE final_normed[MODEL_DIM],
+    DATA_TYPE logits[VOCAB]) {
+  DATA_TYPE ss_att = (DATA_TYPE)0;
+  DATA_TYPE ss_ffn = (DATA_TYPE)0;
+  DATA_TYPE ss_final = (DATA_TYPE)0;
+
+#pragma scop
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    x[i] = tok_embeddings[token][i];
+  }
+
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    ss_att += x[i] * x[i];
+  }
+  ss_att /= (DATA_TYPE)MODEL_DIM;
+  ss_att += (DATA_TYPE)1.0e-5;
+  ss_att = (DATA_TYPE)1 / sqrtf(ss_att);
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    att_normed[i] = rms_att_weight[i] * (ss_att * x[i]);
+  }
+
+  for (int h = 0; h < NUM_HEADS; ++h) {
+    for (int pair = 0; pair < HALF_HEAD_DIM; ++pair) {
+      q_even[h][pair] = (DATA_TYPE)0;
+      q_odd[h][pair] = (DATA_TYPE)0;
+      k_even[h][pair] = (DATA_TYPE)0;
+      k_odd[h][pair] = (DATA_TYPE)0;
+    }
+  }
+  for (int row = 0; row < MODEL_DIM; ++row) {
+    v[row] = (DATA_TYPE)0;
+  }
+  for (int h = 0; h < NUM_HEADS; ++h) {
+    for (int pair = 0; pair < HALF_HEAD_DIM; ++pair) {
+      for (int col = 0; col < MODEL_DIM; ++col) {
+        q_even[h][pair] += wq_even[h][pair][col] * att_normed[col];
+        q_odd[h][pair] += wq_odd[h][pair][col] * att_normed[col];
+        k_even[h][pair] += wk_even[h][pair][col] * att_normed[col];
+        k_odd[h][pair] += wk_odd[h][pair][col] * att_normed[col];
+      }
+    }
+  }
+  for (int row = 0; row < MODEL_DIM; ++row) {
+    for (int col = 0; col < MODEL_DIM; ++col) {
+      v[row] += wv[row][col] * att_normed[col];
+    }
+  }
+
+  for (int h = 0; h < NUM_HEADS; ++h) {
+    for (int pair = 0; pair < HALF_HEAD_DIM; ++pair) {
+      DATA_TYPE c = cos_table[pos][pair];
+      DATA_TYPE s = sin_table[pos][pair];
+      q_even_rot[h][pair] = q_even[h][pair] * c - q_odd[h][pair] * s;
+    }
+  }
+  for (int h = 0; h < NUM_HEADS; ++h) {
+    for (int pair = 0; pair < HALF_HEAD_DIM; ++pair) {
+      DATA_TYPE c = cos_table[pos][pair];
+      DATA_TYPE s = sin_table[pos][pair];
+      q_odd_rot[h][pair] = q_even[h][pair] * s + q_odd[h][pair] * c;
+    }
+  }
+  for (int h = 0; h < NUM_HEADS; ++h) {
+    for (int pair = 0; pair < HALF_HEAD_DIM; ++pair) {
+      DATA_TYPE c = cos_table[pos][pair];
+      DATA_TYPE s = sin_table[pos][pair];
+      k_cache_even[pos][h][pair] = k_even[h][pair] * c - k_odd[h][pair] * s;
+    }
+  }
+  for (int h = 0; h < NUM_HEADS; ++h) {
+    for (int pair = 0; pair < HALF_HEAD_DIM; ++pair) {
+      DATA_TYPE c = cos_table[pos][pair];
+      DATA_TYPE s = sin_table[pos][pair];
+      k_cache_odd[pos][h][pair] = k_even[h][pair] * s + k_odd[h][pair] * c;
+    }
+  }
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    for (int h = 0; h < NUM_HEADS; ++h) {
+      for (int pair = 0; pair < HALF_HEAD_DIM; ++pair) {
+        k_read_even[t][h][pair] = k_cache_even[t][h][pair];
+        k_read_odd[t][h][pair] = k_cache_odd[t][h][pair];
+      }
+    }
+  }
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    v_cache[pos][i] = v[i];
+  }
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    for (int i = 0; i < MODEL_DIM; ++i) {
+      v_read[t][i] = v_cache[t][i];
+    }
+  }
+
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    scores[t] = (DATA_TYPE)0;
+  }
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    for (int h = 0; h < NUM_HEADS; ++h) {
+      for (int pair = 0; pair < HALF_HEAD_DIM; ++pair) {
+        scores[t] += q_even_rot[h][pair] * k_read_even[t][h][pair] +
+                     q_odd_rot[h][pair] * k_read_odd[t][h][pair];
+      }
+    }
+  }
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    scores[t] /= sqrtf((DATA_TYPE)HEAD_DIM);
+  }
+
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    DATA_TYPE drop = (DATA_TYPE)(t > pos);
+    DATA_TYPE keep = (DATA_TYPE)1 - drop;
+    masked_scores[t] = keep * scores[t] + drop * NEG_INF;
+  }
+
+  DATA_TYPE max_val = masked_scores[0];
+  for (int t = 1; t < SEQ_LEN; ++t) {
+    if (masked_scores[t] > max_val) {
+      max_val = masked_scores[t];
+    }
+  }
+  DATA_TYPE sum = (DATA_TYPE)0;
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    probs[t] = expf(masked_scores[t] - max_val);
+    sum += probs[t];
+  }
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    probs[t] /= sum;
+  }
+
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    att_out[i] = (DATA_TYPE)0;
+  }
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    for (int t = 0; t < SEQ_LEN; ++t) {
+      att_out[i] += probs[t] * v_read[t][i];
+    }
+  }
+
+  for (int row = 0; row < MODEL_DIM; ++row) {
+    proj_out[row] = (DATA_TYPE)0;
+  }
+  for (int row = 0; row < MODEL_DIM; ++row) {
+    for (int col = 0; col < MODEL_DIM; ++col) {
+      proj_out[row] += wo[row][col] * att_out[col];
+    }
+  }
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    resid_att[i] = x[i] + proj_out[i];
+  }
+
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    ss_ffn += resid_att[i] * resid_att[i];
+  }
+  ss_ffn /= (DATA_TYPE)MODEL_DIM;
+  ss_ffn += (DATA_TYPE)1.0e-5;
+  ss_ffn = (DATA_TYPE)1 / sqrtf(ss_ffn);
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    ffn_normed[i] = rms_ffn_weight[i] * (ss_ffn * resid_att[i]);
+  }
+
+  for (int row = 0; row < FFN_DIM; ++row) {
+    gate[row] = (DATA_TYPE)0;
+    up[row] = (DATA_TYPE)0;
+  }
+  for (int row = 0; row < FFN_DIM; ++row) {
+    for (int col = 0; col < MODEL_DIM; ++col) {
+      gate[row] += w_gate[row][col] * ffn_normed[col];
+      up[row] += w_up[row][col] * ffn_normed[col];
+    }
+  }
+  for (int i = 0; i < FFN_DIM; ++i) {
+    DATA_TYPE g = gate[i];
+    DATA_TYPE silu = g / ((DATA_TYPE)1 + expf(-g));
+    ffn_hidden[i] = silu * up[i];
+  }
+
+  for (int row = 0; row < MODEL_DIM; ++row) {
+    ffn_out[row] = (DATA_TYPE)0;
+  }
+  for (int row = 0; row < MODEL_DIM; ++row) {
+    for (int col = 0; col < FFN_DIM; ++col) {
+      ffn_out[row] += w_down[row][col] * ffn_hidden[col];
+    }
+  }
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    resid_ffn[i] = resid_att[i] + ffn_out[i];
+  }
+
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    ss_final += resid_ffn[i] * resid_ffn[i];
+  }
+  ss_final /= (DATA_TYPE)MODEL_DIM;
+  ss_final += (DATA_TYPE)1.0e-5;
+  ss_final = (DATA_TYPE)1 / sqrtf(ss_final);
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    final_normed[i] = rms_final_weight[i] * (ss_final * resid_ffn[i]);
+  }
+
+  for (int row = 0; row < VOCAB; ++row) {
+    logits[row] = (DATA_TYPE)0;
+  }
+  for (int row = 0; row < VOCAB; ++row) {
+    for (int col = 0; col < MODEL_DIM; ++col) {
+      logits[row] += lm_head[row][col] * final_normed[col];
+    }
+  }
+#pragma endscop
+}
+
+static DATA_TYPE tok_embeddings[VOCAB][MODEL_DIM];
+static DATA_TYPE rms_att_weight[MODEL_DIM];
+static DATA_TYPE wq_even[NUM_HEADS][HALF_HEAD_DIM][MODEL_DIM];
+static DATA_TYPE wq_odd[NUM_HEADS][HALF_HEAD_DIM][MODEL_DIM];
+static DATA_TYPE wk_even[NUM_HEADS][HALF_HEAD_DIM][MODEL_DIM];
+static DATA_TYPE wk_odd[NUM_HEADS][HALF_HEAD_DIM][MODEL_DIM];
+static DATA_TYPE wv[MODEL_DIM][MODEL_DIM];
+static DATA_TYPE wo[MODEL_DIM][MODEL_DIM];
+static DATA_TYPE rms_ffn_weight[MODEL_DIM];
+static DATA_TYPE w_gate[FFN_DIM][MODEL_DIM];
+static DATA_TYPE w_up[FFN_DIM][MODEL_DIM];
+static DATA_TYPE w_down[MODEL_DIM][FFN_DIM];
+static DATA_TYPE rms_final_weight[MODEL_DIM];
+static DATA_TYPE lm_head[VOCAB][MODEL_DIM];
+static DATA_TYPE cos_table[SEQ_LEN][HALF_HEAD_DIM];
+static DATA_TYPE sin_table[SEQ_LEN][HALF_HEAD_DIM];
+static DATA_TYPE k_cache_even[SEQ_LEN][NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE k_cache_odd[SEQ_LEN][NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE v_cache[SEQ_LEN][MODEL_DIM];
+static DATA_TYPE x[MODEL_DIM];
+static DATA_TYPE att_normed[MODEL_DIM];
+static DATA_TYPE v[MODEL_DIM];
+static DATA_TYPE q_even[NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE q_odd[NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE k_even[NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE k_odd[NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE q_even_rot[NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE q_odd_rot[NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE k_read_even[SEQ_LEN][NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE k_read_odd[SEQ_LEN][NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE v_read[SEQ_LEN][MODEL_DIM];
+static DATA_TYPE scores[SEQ_LEN];
+static DATA_TYPE masked_scores[SEQ_LEN];
+static DATA_TYPE probs[SEQ_LEN];
+static DATA_TYPE att_out[MODEL_DIM];
+static DATA_TYPE proj_out[MODEL_DIM];
+static DATA_TYPE resid_att[MODEL_DIM];
+static DATA_TYPE ffn_normed[MODEL_DIM];
+static DATA_TYPE gate[FFN_DIM];
+static DATA_TYPE up[FFN_DIM];
+static DATA_TYPE ffn_hidden[FFN_DIM];
+static DATA_TYPE ffn_out[MODEL_DIM];
+static DATA_TYPE resid_ffn[MODEL_DIM];
+static DATA_TYPE final_normed[MODEL_DIM];
+static DATA_TYPE logits[VOCAB];
+
+static DATA_TYPE init_value(int i, int j) {
+  int v = (i * 17 + j * 13 + 7) % 101;
+  return (DATA_TYPE)((v - 50) * 0.01f);
+}
+
+static void init_array(void) {
+  for (int i = 0; i < VOCAB; ++i) {
+    for (int j = 0; j < MODEL_DIM; ++j) {
+      tok_embeddings[i][j] = init_value(i, j);
+      lm_head[i][j] = init_value(i + 3, j + 5);
+    }
+  }
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    rms_att_weight[i] = (DATA_TYPE)1 + init_value(i, 1) * (DATA_TYPE)0.1;
+    rms_ffn_weight[i] = (DATA_TYPE)1 + init_value(i, 2) * (DATA_TYPE)0.1;
+    rms_final_weight[i] = (DATA_TYPE)1 + init_value(i, 3) * (DATA_TYPE)0.1;
+    for (int j = 0; j < MODEL_DIM; ++j) {
+      wv[i][j] = init_value(i + 3, j);
+      wo[i][j] = init_value(i + 4, j);
+    }
+    for (int j = 0; j < FFN_DIM; ++j) {
+      w_down[i][j] = init_value(i + 5, j);
+    }
+  }
+  for (int i = 0; i < FFN_DIM; ++i) {
+    for (int j = 0; j < MODEL_DIM; ++j) {
+      w_gate[i][j] = init_value(i + 6, j);
+      w_up[i][j] = init_value(i + 7, j);
+    }
+  }
+  for (int h = 0; h < NUM_HEADS; ++h) {
+    for (int p = 0; p < HALF_HEAD_DIM; ++p) {
+      int row_even = h * HEAD_DIM + 2 * p;
+      int row_odd = row_even + 1;
+      for (int j = 0; j < MODEL_DIM; ++j) {
+        wq_even[h][p][j] = init_value(row_even + 1, j);
+        wq_odd[h][p][j] = init_value(row_odd + 1, j);
+        wk_even[h][p][j] = init_value(row_even + 2, j);
+        wk_odd[h][p][j] = init_value(row_odd + 2, j);
+      }
+    }
+  }
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    for (int p = 0; p < HALF_HEAD_DIM; ++p) {
+      cos_table[t][p] = (DATA_TYPE)0.95 +
+                        (DATA_TYPE)0.001 * (DATA_TYPE)((t + p) % 7);
+      sin_table[t][p] = (DATA_TYPE)0.05 +
+                        (DATA_TYPE)0.001 * (DATA_TYPE)((t + p) % 5);
+    }
+    for (int h = 0; h < NUM_HEADS; ++h) {
+      for (int p = 0; p < HALF_HEAD_DIM; ++p) {
+        k_cache_even[t][h][p] = init_value(t + h, p);
+        k_cache_odd[t][h][p] = init_value(t + h + 1, p);
+      }
+    }
+    for (int i = 0; i < MODEL_DIM; ++i) {
+      v_cache[t][i] = init_value(t + 1, i);
+    }
+  }
+}
+
+static void print_array(void) {
+  int nprint = PRINT_ELEMS < VOCAB ? PRINT_ELEMS : VOCAB;
+  DATA_TYPE checksum = (DATA_TYPE)0;
+  for (int i = 0; i < VOCAB; ++i) {
+    checksum += logits[i];
+  }
+  for (int i = 0; i < nprint; ++i) {
+    printf("%.8f\n", (double)logits[i]);
+  }
+  printf("%.8f\n", (double)checksum);
+}
+
+int main(void) {
+  const int token = 7;
+  const int pos = SEQ_LEN / 2;
+  init_array();
+  for (int r = 0; r < REPEAT; ++r) {
+    kernel_llama2_extended_forward(
+        token, pos, tok_embeddings, rms_att_weight, wq_even, wq_odd, wk_even,
+        wk_odd, wv, wo, rms_ffn_weight, w_gate, w_up, w_down,
+        rms_final_weight, lm_head, cos_table, sin_table, k_cache_even,
+        k_cache_odd, v_cache, x, att_normed, v, q_even, q_odd, k_even, k_odd,
+        q_even_rot, q_odd_rot, k_read_even, k_read_odd, v_read, scores,
+        masked_scores, probs, att_out, proj_out, resid_att, ffn_normed, gate,
+        up, ffn_hidden, ffn_out, resid_ffn, final_normed, logits);
+  }
+  print_array();
+  return 0;
+}
diff --git a/third_party/cnn-extracted/llama2_forward_bench.c b/third_party/cnn-extracted/llama2_forward_bench.c
new file mode 100644
index 000000000000..3b7579ab1f6f
--- /dev/null
+++ b/third_party/cnn-extracted/llama2_forward_bench.c
@@ -0,0 +1,123 @@
+/* llama2_forward_bench.c -- larger Llama2-style forward fixture.
+ *
+ * Same numeric shape as llama2_tiny_forward.c, but sized large enough that
+ * cuBLAS/cuDNN setup overhead is not the entire experiment:
+ *
+ *   rmsnorm(x, weight) -> hidden
+ *   logits = W * hidden
+ *   softmax(logits)
+ *
+ * Defaults are intentionally moderate for Jetson iteration. Override with
+ * -DN=4096 -DH=32000 for a Llama-7B-like output projection size.
+ */
+
+#include 
+#include 
+
+#ifndef DATA_TYPE
+#define DATA_TYPE float
+#endif
+
+#ifndef N
+#define N 1024
+#endif
+
+#ifndef H
+#define H 4096
+#endif
+
+#ifndef REPEAT
+#define REPEAT 1
+#endif
+
+#ifndef PRINT_ELEMS
+#define PRINT_ELEMS 32
+#endif
+
+void kernel_llama2_forward_bench(int n, int h, DATA_TYPE x[N],
+                                 DATA_TYPE weight[N], DATA_TYPE w[H][N],
+                                 DATA_TYPE hidden[N], DATA_TYPE logits[H]) {
+  DATA_TYPE ss = (DATA_TYPE)0;
+
+#pragma scop
+  for (int i = 0; i < n; ++i) {
+    ss += x[i] * x[i];
+  }
+
+  ss /= n;
+  ss += (DATA_TYPE)1.0e-5;
+  ss = (DATA_TYPE)1 / sqrtf(ss);
+
+  for (int i = 0; i < n; ++i) {
+    hidden[i] = weight[i] * (ss * x[i]);
+  }
+
+  for (int row = 0; row < h; ++row) {
+    logits[row] = (DATA_TYPE)0;
+  }
+
+  for (int row = 0; row < h; ++row) {
+    for (int col = 0; col < n; ++col) {
+      logits[row] += w[row][col] * hidden[col];
+    }
+  }
+
+  DATA_TYPE max_val = logits[0];
+  for (int i = 1; i < h; ++i) {
+    if (logits[i] > max_val) {
+      max_val = logits[i];
+    }
+  }
+
+  DATA_TYPE sum = (DATA_TYPE)0;
+  for (int i = 0; i < h; ++i) {
+    logits[i] = expf(logits[i] - max_val);
+    sum += logits[i];
+  }
+
+  for (int i = 0; i < h; ++i) {
+    logits[i] /= sum;
+  }
+#pragma endscop
+}
+
+static DATA_TYPE x[N];
+static DATA_TYPE weight[N];
+static DATA_TYPE w[H][N];
+static DATA_TYPE hidden[N];
+static DATA_TYPE logits[H];
+
+static void init_array(void) {
+  for (int i = 0; i < N; ++i) {
+    x[i] = (DATA_TYPE)((i % 31) - 15) * (DATA_TYPE)0.0625;
+    weight[i] = (DATA_TYPE)0.75 + (DATA_TYPE)((i % 17) + 1) *
+                                      (DATA_TYPE)0.015625;
+  }
+  for (int row = 0; row < H; ++row) {
+    for (int col = 0; col < N; ++col) {
+      w[row][col] = (DATA_TYPE)(((row * 7 + col * 11) % 29) - 14) *
+                    (DATA_TYPE)0.0078125;
+    }
+  }
+}
+
+static void print_array(void) {
+  int nprint = PRINT_ELEMS < H ? PRINT_ELEMS : H;
+  DATA_TYPE checksum = (DATA_TYPE)0;
+  for (int i = 0; i < H; ++i) {
+    checksum += logits[i];
+  }
+  for (int i = 0; i < nprint; ++i) {
+    printf("%.8f\n", (double)logits[i]);
+  }
+  printf("%.8f\n", (double)checksum);
+}
+
+int main(void) {
+  init_array();
+  for (int r = 0; r < REPEAT; ++r) {
+    kernel_llama2_forward_bench(N, H, x, weight, w, hidden, logits);
+  }
+  print_array();
+  return 0;
+}
diff --git a/third_party/cnn-extracted/llama2_rmsnorm.c b/third_party/cnn-extracted/llama2_rmsnorm.c
new file mode 100644
index 000000000000..b92ace7a0cd7
--- /dev/null
+++ b/third_party/cnn-extracted/llama2_rmsnorm.c
@@ -0,0 +1,55 @@
+/* llama2_rmsnorm.c — small standalone fixture for the llama2.c RMSNorm
+ * kernel shape:
+ *   ss = sum(x[i] * x[i])
+ *   out[i] = weight[i] * x[i] * rsqrt(ss / N + 1e-5)
+ */
+
+#include 
+#include 
+
+#ifndef DATA_TYPE
+#define DATA_TYPE float
+#endif
+
+#ifndef N
+#define N 128
+#endif
+
+void kernel_llama2_rmsnorm(int n, DATA_TYPE o[N], DATA_TYPE x[N],
+                           DATA_TYPE weight[N]) {
+  DATA_TYPE ss = (DATA_TYPE)0;
+
+#pragma scop
+  for (int j = 0; j < n; j++) {
+    ss += x[j] * x[j];
+  }
+  ss /= n;
+  ss += (DATA_TYPE)1.0e-5;
+  ss = (DATA_TYPE)1 / sqrtf(ss);
+  for (int j = 0; j < n; j++) {
+    o[j] = weight[j] * (ss * x[j]);
+  }
+#pragma endscop
+}
+
+static void init_array(DATA_TYPE x[N], DATA_TYPE weight[N]) {
+  for (int i = 0; i < N; ++i) {
+    x[i] = (DATA_TYPE)((i % 17) - 8) * (DATA_TYPE)0.125;
+    weight[i] = (DATA_TYPE)0.5 + (DATA_TYPE)((i % 11) + 1) * (DATA_TYPE)0.03125;
+  }
+}
+
+static void print_array(DATA_TYPE o[N]) {
+  for (int i = 0; i < N; ++i)
+    printf("%.8f\n", (double)o[i]);
+}
+
+int main(void) {
+  DATA_TYPE o[N];
+  DATA_TYPE x[N];
+  DATA_TYPE weight[N];
+  init_array(x, weight);
+  kernel_llama2_rmsnorm(N, o, x, weight);
+  print_array(o);
+  return 0;
+}
diff --git a/third_party/cnn-extracted/llama2_softmax.c b/third_party/cnn-extracted/llama2_softmax.c
new file mode 100644
index 000000000000..41aa3670d060
--- /dev/null
+++ b/third_party/cnn-extracted/llama2_softmax.c
@@ -0,0 +1,50 @@
+/* llama2_softmax.c — small standalone fixture for the llama2.c row softmax
+ * kernel shape:
+ *   x[i] = exp(x[i] - max(x)) / sum(exp(x[j] - max(x)))
+ */
+
+#include 
+#include 
+
+#ifndef DATA_TYPE
+#define DATA_TYPE float
+#endif
+
+#ifndef N
+#define N 128
+#endif
+
+void kernel_llama2_softmax(DATA_TYPE x[N], int n) {
+  DATA_TYPE max_val = x[0];
+  for (int i = 1; i < n; i++) {
+    if (x[i] > max_val) {
+      max_val = x[i];
+    }
+  }
+  DATA_TYPE sum = (DATA_TYPE)0;
+  for (int i = 0; i < n; i++) {
+    x[i] = expf(x[i] - max_val);
+    sum += x[i];
+  }
+  for (int i = 0; i < n; i++) {
+    x[i] /= sum;
+  }
+}
+
+static void init_array(DATA_TYPE x[N]) {
+  for (int i = 0; i < N; ++i)
+    x[i] = (DATA_TYPE)((i % 23) - 11) * (DATA_TYPE)0.125;
+}
+
+static void print_array(DATA_TYPE x[N]) {
+  for (int i = 0; i < N; ++i)
+    printf("%.8f\n", (double)x[i]);
+}
+
+int main(void) {
+  DATA_TYPE x[N];
+  init_array(x);
+  kernel_llama2_softmax(x, N);
+  print_array(x);
+  return 0;
+}
diff --git a/third_party/cnn-extracted/llama2_tiny_forward.c b/third_party/cnn-extracted/llama2_tiny_forward.c
new file mode 100644
index 000000000000..5b078e4f166e
--- /dev/null
+++ b/third_party/cnn-extracted/llama2_tiny_forward.c
@@ -0,0 +1,105 @@
+/* llama2_tiny_forward.c -- self-contained Llama2-style forward fixture.
+ *
+ * This intentionally avoids checkpoint loading, tokenizer code, mmap, structs,
+ * and file I/O.  The goal is to keep the numeric shape of a small inference
+ * slice that Polygeist can lift as a whole kernel:
+ *
+ *   rmsnorm(x, weight) -> hidden
+ *   logits = W * hidden
+ *   softmax(logits)
+ */
+
+#include 
+#include 
+
+#ifndef DATA_TYPE
+#define DATA_TYPE float
+#endif
+
+#ifndef N
+#define N 16
+#endif
+
+#ifndef H
+#define H 16
+#endif
+
+void kernel_llama2_tiny_forward(int n, int h, DATA_TYPE x[N],
+                                DATA_TYPE weight[N], DATA_TYPE w[H][N],
+                                DATA_TYPE hidden[N], DATA_TYPE logits[H]) {
+  DATA_TYPE ss = (DATA_TYPE)0;
+
+#pragma scop
+  for (int i = 0; i < n; ++i) {
+    ss += x[i] * x[i];
+  }
+
+  ss /= n;
+  ss += (DATA_TYPE)1.0e-5;
+  ss = (DATA_TYPE)1 / sqrtf(ss);
+
+  for (int i = 0; i < n; ++i) {
+    hidden[i] = weight[i] * (ss * x[i]);
+  }
+
+  for (int row = 0; row < h; ++row) {
+    logits[row] = (DATA_TYPE)0;
+  }
+
+  for (int row = 0; row < h; ++row) {
+    for (int col = 0; col < n; ++col) {
+      logits[row] += w[row][col] * hidden[col];
+    }
+  }
+
+  DATA_TYPE max_val = logits[0];
+  for (int i = 1; i < h; ++i) {
+    if (logits[i] > max_val) {
+      max_val = logits[i];
+    }
+  }
+
+  DATA_TYPE sum = (DATA_TYPE)0;
+  for (int i = 0; i < h; ++i) {
+    logits[i] = expf(logits[i] - max_val);
+    sum += logits[i];
+  }
+
+  for (int i = 0; i < h; ++i) {
+    logits[i] /= sum;
+  }
+#pragma endscop
+}
+
+static void init_array(DATA_TYPE x[N], DATA_TYPE weight[N],
+                       DATA_TYPE w[H][N]) {
+  for (int i = 0; i < N; ++i) {
+    x[i] = (DATA_TYPE)((i % 7) - 3) * (DATA_TYPE)0.25;
+    weight[i] = (DATA_TYPE)0.75 + (DATA_TYPE)((i % 5) + 1) * (DATA_TYPE)0.05;
+  }
+  for (int row = 0; row < H; ++row) {
+    for (int col = 0; col < N; ++col) {
+      w[row][col] = (DATA_TYPE)(((row * 3 + col * 5) % 13) - 6) *
+                    (DATA_TYPE)0.03125;
+    }
+  }
+}
+
+static void print_array(DATA_TYPE logits[H]) {
+  for (int i = 0; i < H; ++i) {
+    printf("%.8f\n", (double)logits[i]);
+  }
+}
+
+int main(void) {
+  DATA_TYPE x[N];
+  DATA_TYPE weight[N];
+  DATA_TYPE w[H][N];
+  DATA_TYPE hidden[N];
+  DATA_TYPE logits[H];
+
+  init_array(x, weight, w);
+  kernel_llama2_tiny_forward(N, H, x, weight, w, hidden, logits);
+  print_array(logits);
+  return 0;
+}
diff --git a/third_party/cnn-extracted/llama_forward_ops.c b/third_party/cnn-extracted/llama_forward_ops.c
new file mode 100644
index 000000000000..a06676e38e28
--- /dev/null
+++ b/third_party/cnn-extracted/llama_forward_ops.c
@@ -0,0 +1,390 @@
+/* llama_forward_ops.c -- standalone Llama-forward operation fixtures.
+ *
+ * Each function isolates one transformer-forward component so we can ask a
+ * narrow question: does this C loop shape raise to linalg, and can the raised
+ * memref form be debufferized to tensor linalg?
+ */
+
+#include 
+
+#ifndef DATA_TYPE
+#define DATA_TYPE float
+#endif
+
+#ifndef MODEL_DIM
+#define MODEL_DIM 64
+#endif
+
+#ifndef FFN_DIM
+#define FFN_DIM 128
+#endif
+
+#ifndef VOCAB
+#define VOCAB 256
+#endif
+
+#ifndef SEQ_LEN
+#define SEQ_LEN 32
+#endif
+
+#ifndef NUM_HEADS
+#define NUM_HEADS 4
+#endif
+
+#ifndef HEAD_DIM
+#define HEAD_DIM (MODEL_DIM / NUM_HEADS)
+#endif
+
+#ifndef HALF_HEAD_DIM
+#define HALF_HEAD_DIM (HEAD_DIM / 2)
+#endif
+
+#define NEG_INF ((DATA_TYPE)-3.4028234663852886e38f)
+
+
+void kernel_llama_token_embedding(int token,
+                             DATA_TYPE embedding[VOCAB][MODEL_DIM],
+                             DATA_TYPE out[MODEL_DIM]) {
+#pragma scop
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    out[i] = embedding[token][i];
+  }
+#pragma endscop
+}
+
+void kernel_llama_attention_rmsnorm(DATA_TYPE out[MODEL_DIM],
+                               DATA_TYPE x[MODEL_DIM],
+                               DATA_TYPE weight[MODEL_DIM]) {
+  DATA_TYPE ss = (DATA_TYPE)0;
+
+#pragma scop
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    ss += x[i] * x[i];
+  }
+  ss /= (DATA_TYPE)MODEL_DIM;
+  ss += (DATA_TYPE)1.0e-5;
+  ss = (DATA_TYPE)1 / sqrtf(ss);
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    out[i] = weight[i] * (ss * x[i]);
+  }
+#pragma endscop
+}
+
+void kernel_llama_qkv_projection(DATA_TYPE x[MODEL_DIM],
+                            DATA_TYPE wq[MODEL_DIM][MODEL_DIM],
+                            DATA_TYPE wk[MODEL_DIM][MODEL_DIM],
+                            DATA_TYPE wv[MODEL_DIM][MODEL_DIM],
+                            DATA_TYPE q[MODEL_DIM],
+                            DATA_TYPE k[MODEL_DIM],
+                            DATA_TYPE v[MODEL_DIM]) {
+#pragma scop
+  for (int row = 0; row < MODEL_DIM; ++row) {
+    q[row] = (DATA_TYPE)0;
+    k[row] = (DATA_TYPE)0;
+    v[row] = (DATA_TYPE)0;
+  }
+
+  for (int row = 0; row < MODEL_DIM; ++row) {
+    for (int col = 0; col < MODEL_DIM; ++col) {
+      q[row] += wq[row][col] * x[col];
+      k[row] += wk[row][col] * x[col];
+      v[row] += wv[row][col] * x[col];
+    }
+  }
+#pragma endscop
+}
+
+void kernel_llama_rope(int pos, DATA_TYPE q[NUM_HEADS][HEAD_DIM],
+                  DATA_TYPE k[NUM_HEADS][HEAD_DIM],
+                  DATA_TYPE cos_table[SEQ_LEN][HALF_HEAD_DIM],
+                  DATA_TYPE sin_table[SEQ_LEN][HALF_HEAD_DIM],
+                  DATA_TYPE q_out[NUM_HEADS][HEAD_DIM],
+                  DATA_TYPE k_out[NUM_HEADS][HEAD_DIM]) {
+#pragma scop
+  for (int h = 0; h < NUM_HEADS; ++h) {
+    for (int pair = 0; pair < HALF_HEAD_DIM; ++pair) {
+      int even = 2 * pair;
+      int odd = even + 1;
+      DATA_TYPE c = cos_table[pos][pair];
+      DATA_TYPE s = sin_table[pos][pair];
+      DATA_TYPE q_even = q[h][even];
+      DATA_TYPE q_odd = q[h][odd];
+      DATA_TYPE k_even = k[h][even];
+      DATA_TYPE k_odd = k[h][odd];
+
+      q_out[h][even] = q_even * c - q_odd * s;
+      q_out[h][odd] = q_even * s + q_odd * c;
+      k_out[h][even] = k_even * c - k_odd * s;
+      k_out[h][odd] = k_even * s + k_odd * c;
+    }
+  }
+#pragma endscop
+}
+
+void kernel_llama_rope_split(int pos,
+                        DATA_TYPE q_even[NUM_HEADS][HALF_HEAD_DIM],
+                        DATA_TYPE q_odd[NUM_HEADS][HALF_HEAD_DIM],
+                        DATA_TYPE k_even[NUM_HEADS][HALF_HEAD_DIM],
+                        DATA_TYPE k_odd[NUM_HEADS][HALF_HEAD_DIM],
+                        DATA_TYPE cos_table[SEQ_LEN][HALF_HEAD_DIM],
+                        DATA_TYPE sin_table[SEQ_LEN][HALF_HEAD_DIM],
+                        DATA_TYPE q_even_out[NUM_HEADS][HALF_HEAD_DIM],
+                        DATA_TYPE q_odd_out[NUM_HEADS][HALF_HEAD_DIM],
+                        DATA_TYPE k_even_out[NUM_HEADS][HALF_HEAD_DIM],
+                        DATA_TYPE k_odd_out[NUM_HEADS][HALF_HEAD_DIM]) {
+#pragma scop
+  for (int h = 0; h < NUM_HEADS; ++h) {
+    for (int pair = 0; pair < HALF_HEAD_DIM; ++pair) {
+      DATA_TYPE c = cos_table[pos][pair];
+      DATA_TYPE s = sin_table[pos][pair];
+      q_even_out[h][pair] = q_even[h][pair] * c - q_odd[h][pair] * s;
+    }
+  }
+  for (int h = 0; h < NUM_HEADS; ++h) {
+    for (int pair = 0; pair < HALF_HEAD_DIM; ++pair) {
+      DATA_TYPE c = cos_table[pos][pair];
+      DATA_TYPE s = sin_table[pos][pair];
+      q_odd_out[h][pair] = q_even[h][pair] * s + q_odd[h][pair] * c;
+    }
+  }
+  for (int h = 0; h < NUM_HEADS; ++h) {
+    for (int pair = 0; pair < HALF_HEAD_DIM; ++pair) {
+      DATA_TYPE c = cos_table[pos][pair];
+      DATA_TYPE s = sin_table[pos][pair];
+      k_even_out[h][pair] = k_even[h][pair] * c - k_odd[h][pair] * s;
+    }
+  }
+  for (int h = 0; h < NUM_HEADS; ++h) {
+    for (int pair = 0; pair < HALF_HEAD_DIM; ++pair) {
+      DATA_TYPE c = cos_table[pos][pair];
+      DATA_TYPE s = sin_table[pos][pair];
+      k_odd_out[h][pair] = k_even[h][pair] * s + k_odd[h][pair] * c;
+    }
+  }
+#pragma endscop
+}
+
+void kernel_llama_kv_cache_rw(int pos, DATA_TYPE k[MODEL_DIM],
+                         DATA_TYPE v[MODEL_DIM],
+                         DATA_TYPE k_cache[SEQ_LEN][MODEL_DIM],
+                         DATA_TYPE v_cache[SEQ_LEN][MODEL_DIM],
+                         DATA_TYPE k_read[SEQ_LEN][MODEL_DIM],
+                         DATA_TYPE v_read[SEQ_LEN][MODEL_DIM]) {
+#pragma scop
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    k_cache[pos][i] = k[i];
+    v_cache[pos][i] = v[i];
+  }
+
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    for (int i = 0; i < MODEL_DIM; ++i) {
+      k_read[t][i] = k_cache[t][i];
+      v_read[t][i] = v_cache[t][i];
+    }
+  }
+#pragma endscop
+}
+
+void kernel_llama_attention_scores(DATA_TYPE q[MODEL_DIM],
+                              DATA_TYPE k_cache[SEQ_LEN][MODEL_DIM],
+                              DATA_TYPE scores[SEQ_LEN]) {
+#pragma scop
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    scores[t] = (DATA_TYPE)0;
+  }
+
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    for (int i = 0; i < MODEL_DIM; ++i) {
+      scores[t] += q[i] * k_cache[t][i];
+    }
+  }
+#pragma endscop
+}
+
+void kernel_llama_attention_mask(int pos, DATA_TYPE scores[SEQ_LEN],
+                            DATA_TYPE masked[SEQ_LEN]) {
+#pragma scop
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    if (t > pos) {
+      masked[t] = NEG_INF;
+    } else {
+      masked[t] = scores[t];
+    }
+  }
+#pragma endscop
+}
+
+void kernel_llama_attention_mask_select(int pos, DATA_TYPE scores[SEQ_LEN],
+                                   DATA_TYPE masked[SEQ_LEN]) {
+#pragma scop
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    DATA_TYPE drop = (DATA_TYPE)(t > pos);
+    DATA_TYPE keep = (DATA_TYPE)1 - drop;
+    masked[t] = keep * scores[t] + drop * NEG_INF;
+  }
+#pragma endscop
+}
+
+void kernel_llama_attention_softmax(DATA_TYPE out[SEQ_LEN],
+                               DATA_TYPE scores[SEQ_LEN]) {
+  DATA_TYPE max_val = scores[0];
+
+#pragma scop
+  for (int t = 1; t < SEQ_LEN; ++t) {
+    if (scores[t] > max_val) {
+      max_val = scores[t];
+    }
+  }
+
+  DATA_TYPE sum = (DATA_TYPE)0;
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    out[t] = expf(scores[t] - max_val);
+    sum += out[t];
+  }
+
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    out[t] /= sum;
+  }
+#pragma endscop
+}
+
+void kernel_llama_attention_output(DATA_TYPE probs[SEQ_LEN],
+                              DATA_TYPE v_cache[SEQ_LEN][MODEL_DIM],
+                              DATA_TYPE out[MODEL_DIM]) {
+#pragma scop
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    out[i] = (DATA_TYPE)0;
+  }
+
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    for (int t = 0; t < SEQ_LEN; ++t) {
+      out[i] += probs[t] * v_cache[t][i];
+    }
+  }
+#pragma endscop
+}
+
+void kernel_llama_output_projection(DATA_TYPE x[MODEL_DIM],
+                               DATA_TYPE w[MODEL_DIM][MODEL_DIM],
+                               DATA_TYPE out[MODEL_DIM]) {
+#pragma scop
+  for (int row = 0; row < MODEL_DIM; ++row) {
+    out[row] = (DATA_TYPE)0;
+  }
+
+  for (int row = 0; row < MODEL_DIM; ++row) {
+    for (int col = 0; col < MODEL_DIM; ++col) {
+      out[row] += w[row][col] * x[col];
+    }
+  }
+#pragma endscop
+}
+
+void kernel_llama_residual_add(DATA_TYPE out[MODEL_DIM],
+                          DATA_TYPE x[MODEL_DIM],
+                          DATA_TYPE residual[MODEL_DIM]) {
+#pragma scop
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    out[i] = x[i] + residual[i];
+  }
+#pragma endscop
+}
+
+void kernel_llama_ffn_rmsnorm(DATA_TYPE out[MODEL_DIM],
+                         DATA_TYPE x[MODEL_DIM],
+                         DATA_TYPE weight[MODEL_DIM]) {
+  DATA_TYPE ss = (DATA_TYPE)0;
+
+#pragma scop
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    ss += x[i] * x[i];
+  }
+  ss /= (DATA_TYPE)MODEL_DIM;
+  ss += (DATA_TYPE)1.0e-5;
+  ss = (DATA_TYPE)1 / sqrtf(ss);
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    out[i] = weight[i] * (ss * x[i]);
+  }
+#pragma endscop
+}
+
+void kernel_llama_gate_up_projection(DATA_TYPE x[MODEL_DIM],
+                                DATA_TYPE w_gate[FFN_DIM][MODEL_DIM],
+                                DATA_TYPE w_up[FFN_DIM][MODEL_DIM],
+                                DATA_TYPE gate[FFN_DIM],
+                                DATA_TYPE up[FFN_DIM]) {
+#pragma scop
+  for (int row = 0; row < FFN_DIM; ++row) {
+    gate[row] = (DATA_TYPE)0;
+    up[row] = (DATA_TYPE)0;
+  }
+
+  for (int row = 0; row < FFN_DIM; ++row) {
+    for (int col = 0; col < MODEL_DIM; ++col) {
+      gate[row] += w_gate[row][col] * x[col];
+      up[row] += w_up[row][col] * x[col];
+    }
+  }
+#pragma endscop
+}
+
+void kernel_llama_swiglu(DATA_TYPE gate[FFN_DIM], DATA_TYPE up[FFN_DIM],
+                    DATA_TYPE out[FFN_DIM]) {
+#pragma scop
+  for (int i = 0; i < FFN_DIM; ++i) {
+    DATA_TYPE g = gate[i];
+    DATA_TYPE silu = g / ((DATA_TYPE)1 + expf(-g));
+    out[i] = silu * up[i];
+  }
+#pragma endscop
+}
+
+void kernel_llama_down_projection(DATA_TYPE hidden[FFN_DIM],
+                             DATA_TYPE w[MODEL_DIM][FFN_DIM],
+                             DATA_TYPE out[MODEL_DIM]) {
+#pragma scop
+  for (int row = 0; row < MODEL_DIM; ++row) {
+    out[row] = (DATA_TYPE)0;
+  }
+
+  for (int row = 0; row < MODEL_DIM; ++row) {
+    for (int col = 0; col < FFN_DIM; ++col) {
+      out[row] += w[row][col] * hidden[col];
+    }
+  }
+#pragma endscop
+}
+
+void kernel_llama_final_rmsnorm(DATA_TYPE out[MODEL_DIM],
+                           DATA_TYPE x[MODEL_DIM],
+                           DATA_TYPE weight[MODEL_DIM]) {
+  DATA_TYPE ss = (DATA_TYPE)0;
+
+#pragma scop
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    ss += x[i] * x[i];
+  }
+  ss /= (DATA_TYPE)MODEL_DIM;
+  ss += (DATA_TYPE)1.0e-5;
+  ss = (DATA_TYPE)1 / sqrtf(ss);
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    out[i] = weight[i] * (ss * x[i]);
+  }
+#pragma endscop
+}
+
+void kernel_llama_lm_head_projection(DATA_TYPE x[MODEL_DIM],
+                                DATA_TYPE w[VOCAB][MODEL_DIM],
+                                DATA_TYPE logits[VOCAB]) {
+#pragma scop
+  for (int row = 0; row < VOCAB; ++row) {
+    logits[row] = (DATA_TYPE)0;
+  }
+
+  for (int row = 0; row < VOCAB; ++row) {
+    for (int col = 0; col < MODEL_DIM; ++col) {
+      logits[row] += w[row][col] * x[col];
+    }
+  }
+#pragma endscop
+}
diff --git a/third_party/cnn-extracted/llama_forward_ops_harness.c b/third_party/cnn-extracted/llama_forward_ops_harness.c
new file mode 100644
index 000000000000..b9300684e4ba
--- /dev/null
+++ b/third_party/cnn-extracted/llama_forward_ops_harness.c
@@ -0,0 +1,300 @@
+/* llama_forward_ops_harness.c -- timing harness for llama_forward_ops.c.
+ *
+ * This file intentionally only declares the kernels. The build driver links
+ * these calls against the raised wrapper, so compiling the harness separately
+ * prevents the C compiler from inlining or reasoning through the original
+ * kernel body.
+ */
+
+#include 
+
+#ifndef DATA_TYPE
+#define DATA_TYPE float
+#endif
+
+#ifndef MODEL_DIM
+#define MODEL_DIM 64
+#endif
+
+#ifndef FFN_DIM
+#define FFN_DIM 128
+#endif
+
+#ifndef VOCAB
+#define VOCAB 256
+#endif
+
+#ifndef SEQ_LEN
+#define SEQ_LEN 32
+#endif
+
+#ifndef NUM_HEADS
+#define NUM_HEADS 4
+#endif
+
+#ifndef HEAD_DIM
+#define HEAD_DIM (MODEL_DIM / NUM_HEADS)
+#endif
+
+#ifndef HALF_HEAD_DIM
+#define HALF_HEAD_DIM (HEAD_DIM / 2)
+#endif
+
+#ifndef LLAMA_OP
+#error "Define LLAMA_OP to select the operation to time"
+#endif
+
+#ifndef REPEAT
+#define REPEAT 50
+#endif
+
+void kernel_llama_token_embedding(int token,
+                                  DATA_TYPE embedding[VOCAB][MODEL_DIM],
+                                  DATA_TYPE out[MODEL_DIM]);
+void kernel_llama_attention_rmsnorm(DATA_TYPE out[MODEL_DIM],
+                                    DATA_TYPE x[MODEL_DIM],
+                                    DATA_TYPE weight[MODEL_DIM]);
+void kernel_llama_qkv_projection(DATA_TYPE x[MODEL_DIM],
+                                 DATA_TYPE wq[MODEL_DIM][MODEL_DIM],
+                                 DATA_TYPE wk[MODEL_DIM][MODEL_DIM],
+                                 DATA_TYPE wv[MODEL_DIM][MODEL_DIM],
+                                 DATA_TYPE q[MODEL_DIM],
+                                 DATA_TYPE k[MODEL_DIM],
+                                 DATA_TYPE v[MODEL_DIM]);
+void kernel_llama_rope_split(int pos,
+                             DATA_TYPE q_even[NUM_HEADS][HALF_HEAD_DIM],
+                             DATA_TYPE q_odd[NUM_HEADS][HALF_HEAD_DIM],
+                             DATA_TYPE k_even[NUM_HEADS][HALF_HEAD_DIM],
+                             DATA_TYPE k_odd[NUM_HEADS][HALF_HEAD_DIM],
+                             DATA_TYPE cos_table[SEQ_LEN][HALF_HEAD_DIM],
+                             DATA_TYPE sin_table[SEQ_LEN][HALF_HEAD_DIM],
+                             DATA_TYPE q_even_out[NUM_HEADS][HALF_HEAD_DIM],
+                             DATA_TYPE q_odd_out[NUM_HEADS][HALF_HEAD_DIM],
+                             DATA_TYPE k_even_out[NUM_HEADS][HALF_HEAD_DIM],
+                             DATA_TYPE k_odd_out[NUM_HEADS][HALF_HEAD_DIM]);
+void kernel_llama_kv_cache_rw(int pos, DATA_TYPE k[MODEL_DIM],
+                              DATA_TYPE v[MODEL_DIM],
+                              DATA_TYPE k_cache[SEQ_LEN][MODEL_DIM],
+                              DATA_TYPE v_cache[SEQ_LEN][MODEL_DIM],
+                              DATA_TYPE k_read[SEQ_LEN][MODEL_DIM],
+                              DATA_TYPE v_read[SEQ_LEN][MODEL_DIM]);
+void kernel_llama_attention_scores(DATA_TYPE q[MODEL_DIM],
+                                   DATA_TYPE k_cache[SEQ_LEN][MODEL_DIM],
+                                   DATA_TYPE scores[SEQ_LEN]);
+void kernel_llama_attention_mask_select(int pos, DATA_TYPE scores[SEQ_LEN],
+                                        DATA_TYPE masked[SEQ_LEN]);
+void kernel_llama_attention_softmax(DATA_TYPE out[SEQ_LEN],
+                                    DATA_TYPE scores[SEQ_LEN]);
+void kernel_llama_attention_output(DATA_TYPE probs[SEQ_LEN],
+                                   DATA_TYPE v_cache[SEQ_LEN][MODEL_DIM],
+                                   DATA_TYPE out[MODEL_DIM]);
+void kernel_llama_output_projection(DATA_TYPE x[MODEL_DIM],
+                                    DATA_TYPE w[MODEL_DIM][MODEL_DIM],
+                                    DATA_TYPE out[MODEL_DIM]);
+void kernel_llama_residual_add(DATA_TYPE out[MODEL_DIM],
+                               DATA_TYPE x[MODEL_DIM],
+                               DATA_TYPE residual[MODEL_DIM]);
+void kernel_llama_ffn_rmsnorm(DATA_TYPE out[MODEL_DIM],
+                              DATA_TYPE x[MODEL_DIM],
+                              DATA_TYPE weight[MODEL_DIM]);
+void kernel_llama_gate_up_projection(DATA_TYPE x[MODEL_DIM],
+                                     DATA_TYPE w_gate[FFN_DIM][MODEL_DIM],
+                                     DATA_TYPE w_up[FFN_DIM][MODEL_DIM],
+                                     DATA_TYPE gate[FFN_DIM],
+                                     DATA_TYPE up[FFN_DIM]);
+void kernel_llama_swiglu(DATA_TYPE gate[FFN_DIM], DATA_TYPE up[FFN_DIM],
+                         DATA_TYPE out[FFN_DIM]);
+void kernel_llama_down_projection(DATA_TYPE hidden[FFN_DIM],
+                                  DATA_TYPE w[MODEL_DIM][FFN_DIM],
+                                  DATA_TYPE out[MODEL_DIM]);
+void kernel_llama_final_rmsnorm(DATA_TYPE out[MODEL_DIM],
+                                DATA_TYPE x[MODEL_DIM],
+                                DATA_TYPE weight[MODEL_DIM]);
+void kernel_llama_lm_head_projection(DATA_TYPE x[MODEL_DIM],
+                                     DATA_TYPE w[VOCAB][MODEL_DIM],
+                                     DATA_TYPE logits[VOCAB]);
+
+static DATA_TYPE g_embedding[VOCAB][MODEL_DIM];
+static DATA_TYPE g_x[MODEL_DIM];
+static DATA_TYPE g_residual[MODEL_DIM];
+static DATA_TYPE g_weight[MODEL_DIM];
+static DATA_TYPE g_w_model[MODEL_DIM][MODEL_DIM];
+static DATA_TYPE g_wq[MODEL_DIM][MODEL_DIM];
+static DATA_TYPE g_wk[MODEL_DIM][MODEL_DIM];
+static DATA_TYPE g_wv[MODEL_DIM][MODEL_DIM];
+static DATA_TYPE g_w_gate[FFN_DIM][MODEL_DIM];
+static DATA_TYPE g_w_up[FFN_DIM][MODEL_DIM];
+static DATA_TYPE g_w_down[MODEL_DIM][FFN_DIM];
+static DATA_TYPE g_w_vocab[VOCAB][MODEL_DIM];
+static DATA_TYPE g_q[MODEL_DIM];
+static DATA_TYPE g_k[MODEL_DIM];
+static DATA_TYPE g_v[MODEL_DIM];
+static DATA_TYPE g_q_even[NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE g_q_odd[NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE g_k_even[NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE g_k_odd[NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE g_cos[SEQ_LEN][HALF_HEAD_DIM];
+static DATA_TYPE g_sin[SEQ_LEN][HALF_HEAD_DIM];
+static DATA_TYPE g_k_cache[SEQ_LEN][MODEL_DIM];
+static DATA_TYPE g_v_cache[SEQ_LEN][MODEL_DIM];
+static DATA_TYPE g_k_read[SEQ_LEN][MODEL_DIM];
+static DATA_TYPE g_v_read[SEQ_LEN][MODEL_DIM];
+static DATA_TYPE g_scores[SEQ_LEN];
+static DATA_TYPE g_probs[SEQ_LEN];
+static DATA_TYPE g_gate[FFN_DIM];
+static DATA_TYPE g_up[FFN_DIM];
+static DATA_TYPE g_hidden[FFN_DIM];
+static DATA_TYPE g_out[MODEL_DIM];
+static DATA_TYPE g_out2[MODEL_DIM];
+static DATA_TYPE g_logits[VOCAB];
+static DATA_TYPE g_q_even_out[NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE g_q_odd_out[NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE g_k_even_out[NUM_HEADS][HALF_HEAD_DIM];
+static DATA_TYPE g_k_odd_out[NUM_HEADS][HALF_HEAD_DIM];
+
+static DATA_TYPE init_value(int i, int j) {
+  int v = (i * 17 + j * 13 + 7) % 101;
+  return (DATA_TYPE)((v - 50) * 0.01f);
+}
+
+static void init_data(void) {
+  for (int i = 0; i < VOCAB; ++i) {
+    for (int j = 0; j < MODEL_DIM; ++j) {
+      g_embedding[i][j] = init_value(i, j);
+      g_w_vocab[i][j] = init_value(i + 3, j + 5);
+    }
+  }
+  for (int i = 0; i < MODEL_DIM; ++i) {
+    g_x[i] = init_value(i, 1);
+    g_residual[i] = init_value(i, 2);
+    g_weight[i] = (DATA_TYPE)1 + init_value(i, 3) * (DATA_TYPE)0.1;
+    g_q[i] = init_value(i, 4);
+    g_k[i] = init_value(i, 5);
+    g_v[i] = init_value(i, 6);
+    g_out[i] = (DATA_TYPE)0;
+    g_out2[i] = (DATA_TYPE)0;
+    for (int j = 0; j < MODEL_DIM; ++j) {
+      g_w_model[i][j] = init_value(i, j);
+      g_wq[i][j] = init_value(i + 1, j);
+      g_wk[i][j] = init_value(i + 2, j);
+      g_wv[i][j] = init_value(i + 3, j);
+    }
+    for (int j = 0; j < FFN_DIM; ++j) {
+      g_w_down[i][j] = init_value(i, j + 4);
+    }
+  }
+  for (int i = 0; i < FFN_DIM; ++i) {
+    g_gate[i] = init_value(i, 7);
+    g_up[i] = init_value(i, 8);
+    g_hidden[i] = init_value(i, 9);
+    for (int j = 0; j < MODEL_DIM; ++j) {
+      g_w_gate[i][j] = init_value(i + 4, j);
+      g_w_up[i][j] = init_value(i + 5, j);
+    }
+  }
+  for (int h = 0; h < NUM_HEADS; ++h) {
+    for (int p = 0; p < HALF_HEAD_DIM; ++p) {
+      g_q_even[h][p] = init_value(h, p);
+      g_q_odd[h][p] = init_value(h + 1, p);
+      g_k_even[h][p] = init_value(h + 2, p);
+      g_k_odd[h][p] = init_value(h + 3, p);
+    }
+  }
+  for (int t = 0; t < SEQ_LEN; ++t) {
+    g_scores[t] = init_value(t, 10);
+    g_probs[t] = (DATA_TYPE)1 / (DATA_TYPE)SEQ_LEN;
+    for (int p = 0; p < HALF_HEAD_DIM; ++p) {
+      g_cos[t][p] = (DATA_TYPE)0.95 + (DATA_TYPE)0.001 * (DATA_TYPE)((t + p) % 7);
+      g_sin[t][p] = (DATA_TYPE)0.05 + (DATA_TYPE)0.001 * (DATA_TYPE)((t + p) % 5);
+    }
+    for (int i = 0; i < MODEL_DIM; ++i) {
+      g_k_cache[t][i] = init_value(t, i);
+      g_v_cache[t][i] = init_value(t + 1, i);
+      g_k_read[t][i] = (DATA_TYPE)0;
+      g_v_read[t][i] = (DATA_TYPE)0;
+    }
+  }
+}
+
+static double checksum_1d(const DATA_TYPE *x, int n) {
+  double s = 0.0;
+  for (int i = 0; i < n; ++i) {
+    s += (double)x[i] * (double)(i + 1);
+  }
+  return s;
+}
+
+static double checksum_2d(const DATA_TYPE *x, int rows, int cols) {
+  double s = 0.0;
+  for (int i = 0; i < rows * cols; ++i) {
+    s += (double)x[i] * (double)((i % 17) + 1);
+  }
+  return s;
+}
+
+int main(void) {
+  init_data();
+  const int token = 7;
+  const int pos = SEQ_LEN / 2;
+
+  for (int rep = 0; rep < REPEAT; ++rep) {
+#if LLAMA_OP == 1
+    kernel_llama_token_embedding(token, g_embedding, g_out);
+#elif LLAMA_OP == 2
+    kernel_llama_attention_rmsnorm(g_out, g_x, g_weight);
+#elif LLAMA_OP == 3
+    kernel_llama_qkv_projection(g_x, g_wq, g_wk, g_wv, g_q, g_k, g_v);
+#elif LLAMA_OP == 4
+    kernel_llama_rope_split(pos, g_q_even, g_q_odd, g_k_even, g_k_odd,
+                            g_cos, g_sin, g_q_even_out, g_q_odd_out,
+                            g_k_even_out, g_k_odd_out);
+#elif LLAMA_OP == 5
+    kernel_llama_kv_cache_rw(pos, g_k, g_v, g_k_cache, g_v_cache,
+                             g_k_read, g_v_read);
+#elif LLAMA_OP == 6
+    kernel_llama_attention_scores(g_q, g_k_cache, g_scores);
+#elif LLAMA_OP == 7
+    kernel_llama_attention_mask_select(pos, g_scores, g_out);
+#elif LLAMA_OP == 8
+    kernel_llama_attention_softmax(g_probs, g_scores);
+#elif LLAMA_OP == 9
+    kernel_llama_attention_output(g_probs, g_v_cache, g_out);
+#elif LLAMA_OP == 10
+    kernel_llama_output_projection(g_x, g_w_model, g_out);
+#elif LLAMA_OP == 11
+    kernel_llama_residual_add(g_out, g_x, g_residual);
+#elif LLAMA_OP == 12
+    kernel_llama_ffn_rmsnorm(g_out, g_x, g_weight);
+#elif LLAMA_OP == 13
+    kernel_llama_gate_up_projection(g_x, g_w_gate, g_w_up, g_gate, g_up);
+#elif LLAMA_OP == 14
+    kernel_llama_swiglu(g_gate, g_up, g_hidden);
+#elif LLAMA_OP == 15
+    kernel_llama_down_projection(g_hidden, g_w_down, g_out);
+#elif LLAMA_OP == 16
+    kernel_llama_final_rmsnorm(g_out, g_x, g_weight);
+#elif LLAMA_OP == 17
+    kernel_llama_lm_head_projection(g_x, g_w_vocab, g_logits);
+#else
+#error "Unknown LLAMA_OP"
+#endif
+  }
+
+  double checksum = 0.0;
+  checksum += checksum_1d(g_out, MODEL_DIM);
+  checksum += checksum_1d(g_out2, MODEL_DIM);
+  checksum += checksum_1d(g_q, MODEL_DIM);
+  checksum += checksum_1d(g_k, MODEL_DIM);
+  checksum += checksum_1d(g_v, MODEL_DIM);
+  checksum += checksum_1d(g_probs, SEQ_LEN);
+  checksum += checksum_1d(g_hidden, FFN_DIM);
+  checksum += checksum_1d(g_logits, VOCAB);
+  checksum += checksum_2d(&g_k_read[0][0], SEQ_LEN, MODEL_DIM);
+  checksum += checksum_2d(&g_v_read[0][0], SEQ_LEN, MODEL_DIM);
+  checksum += checksum_2d(&g_q_even_out[0][0], NUM_HEADS, HALF_HEAD_DIM);
+  checksum += checksum_2d(&g_q_odd_out[0][0], NUM_HEADS, HALF_HEAD_DIM);
+  checksum += checksum_2d(&g_k_even_out[0][0], NUM_HEADS, HALF_HEAD_DIM);
+  checksum += checksum_2d(&g_k_odd_out[0][0], NUM_HEADS, HALF_HEAD_DIM);
+  printf("LLAMA_OP=%d checksum=%.9f\n", LLAMA_OP, checksum);
+  return 0;
+}
diff --git a/third_party/cnn-extracted/maxpool_batched.c b/third_party/cnn-extracted/maxpool_batched.c
new file mode 100644
index 000000000000..ea70e623f6d0
--- /dev/null
+++ b/third_party/cnn-extracted/maxpool_batched.c
@@ -0,0 +1,82 @@
+/* maxpool_batched.c — batched, multi-channel 2D max pooling (forward).
+ *
+ * Extracted form of darknet's forward_maxpool_layer body. Same lift-
+ * friendly conventions as conv2d_batched.c: scalar-int loop bounds via
+ * polybench-style dataset macros.
+ *
+ * Layout: NCHW. Stride S, window K. Output H' = (H - K) / S + 1.
+ *
+ * For a real ResNet stem maxpool: B=32, C=64, H=W=112, K=3, S=2 → 56×56.
+ */
+#include 
+#include 
+
+#ifndef DATA_TYPE
+# define DATA_TYPE float
+#endif
+
+#if defined(MINI_DATASET)
+# define B    4
+# define C    8
+# define H    32
+# define W    32
+# define KS   2
+# define STR  2
+#elif defined(LARGE_DATASET)
+# define B    32
+# define C    64
+# define H    112
+# define W    112
+# define KS   3
+# define STR  2
+#else
+# define B    4
+# define C    8
+# define H    32
+# define W    32
+# define KS   2
+# define STR  2
+#endif
+
+#define OH ((H - KS) / STR + 1)
+#define OW ((W - KS) / STR + 1)
+
+#define NEG_INF (-3.4028234e38f)
+
+/* The kernel. 6-deep loop nest. Same two-pass pattern as conv2d_batched:
+ *   - init: out[b,c,oh,ow] = -INF
+ *   - reduce: out[b,c,oh,ow] = max(out, A[b,c,oh*S+kh,ow*S+kw])
+ *
+ * The init produces a 4-parallel linalg.generic. The reduce produces a
+ * 4-parallel + 2-reduction linalg.generic with body `max(Out, In(0))`.
+ */
+void kernel_maxpool_batched(DATA_TYPE A[B][C][H][W],
+                             DATA_TYPE Bout[B][C][OH][OW]) {
+  int b, c, oh, ow, kh, kw;
+
+  #pragma scop
+  /* Init to -infinity */
+  for (b = 0; b < B; ++b)
+    for (c = 0; c < C; ++c)
+      for (oh = 0; oh < OH; ++oh)
+        for (ow = 0; ow < OW; ++ow)
+          Bout[b][c][oh][ow] = NEG_INF;
+
+  /* Max-reduce over the K×K window. Use the ternary form (lowers to
+   * arith.select) instead of an if/then store — the if branch makes
+   * cgeist emit a conditional store inside the inner loop, which the
+   * raise pass leaves as affine.for. The ternary keeps the loop body
+   * pure-arith so the whole 6-deep nest folds into one linalg.generic.
+   */
+  for (b = 0; b < B; ++b)
+    for (c = 0; c < C; ++c)
+      for (oh = 0; oh < OH; ++oh)
+        for (ow = 0; ow < OW; ++ow)
+          for (kh = 0; kh < KS; ++kh)
+            for (kw = 0; kw < KS; ++kw) {
+              DATA_TYPE v = A[b][c][oh * STR + kh][ow * STR + kw];
+              DATA_TYPE cur = Bout[b][c][oh][ow];
+              Bout[b][c][oh][ow] = (v > cur) ? v : cur;
+            }
+  #pragma endscop
+}
diff --git a/third_party/cnn-extracted/shortcut_batched.c b/third_party/cnn-extracted/shortcut_batched.c
new file mode 100644
index 000000000000..29c5f1378169
--- /dev/null
+++ b/third_party/cnn-extracted/shortcut_batched.c
@@ -0,0 +1,53 @@
+/* shortcut_batched.c — batched residual-add shortcut layer.
+ *
+ * Extracted form of darknet's forward_shortcut_layer (matched-shape case).
+ * ResNet's identity shortcut: out = out + src, where both tensors share
+ * the same NCHW shape. Same lift-friendly conventions as the other
+ * cnn-extracted files.
+ *
+ * Body: out[b,c,h,w] = src[b,c,h,w] + out[b,c,h,w]. 4-parallel iter
+ * domain (B, C, H, W), zero reductions. cuDNN side this maps to a
+ * cudnnAddTensor call, or with the existing matcher library it lines up
+ * with a generic elementwise add.
+ *
+ * Default MINI shape matches the other extracted kernels (B=4, C=8,
+ * H=W=32). LARGE = ResNet conv2_x output (B=32, C=64, H=W=56).
+ */
+#include 
+#include 
+
+#ifndef DATA_TYPE
+# define DATA_TYPE float
+#endif
+
+#if defined(MINI_DATASET)
+# define B    4
+# define C    8
+# define H    32
+# define W    32
+#elif defined(LARGE_DATASET)
+# define B    32
+# define C    64
+# define H    56
+# define W    56
+#else
+# define B    4
+# define C    8
+# define H    32
+# define W    32
+#endif
+
+/* The kernel. 4-deep parallel nest. Each output element reads one src
+ * value and one current-out value, writes one out value. */
+void kernel_shortcut_batched(DATA_TYPE A[B][C][H][W],
+                              DATA_TYPE Bout[B][C][H][W]) {
+  int b, c, h, w;
+
+  #pragma scop
+  for (b = 0; b < B; ++b)
+    for (c = 0; c < C; ++c)
+      for (h = 0; h < H; ++h)
+        for (w = 0; w < W; ++w)
+          Bout[b][c][h][w] = A[b][c][h][w] + Bout[b][c][h][w];
+  #pragma endscop
+}
diff --git a/third_party/cnn-extracted/stencil_conv2d_3x3.c b/third_party/cnn-extracted/stencil_conv2d_3x3.c
new file mode 100644
index 000000000000..80e5d295242b
--- /dev/null
+++ b/third_party/cnn-extracted/stencil_conv2d_3x3.c
@@ -0,0 +1,548 @@
+/* stencil_conv2d_3x3.c -- image/PDE-style 2D stencil fixtures.
+ *
+ * These kernels are intentionally written as straight-line 3x3 neighbourhood
+ * expressions so the raise pipeline can expose them as one linalg.generic with
+ * nine shifted input subviews. The matcher should lower those to the generic
+ * @cudnnConvolution2D_9tap library entry with the coefficients surfaced as
+ * scalar launch operands.
+ */
+
+#include 
+
+#ifndef DATA_TYPE
+#define DATA_TYPE float
+#endif
+
+#ifndef STENCIL_H
+#define STENCIL_H 64
+#endif
+
+#ifndef STENCIL_W
+#define STENCIL_W 64
+#endif
+
+#ifndef REPEAT
+#define REPEAT 50
+#endif
+
+#ifndef STENCIL_KERNEL
+#define STENCIL_KERNEL kernel_stencil_box3x3
+#endif
+
+void kernel_stencil_box3x3(int h, int w,
+                           DATA_TYPE in[STENCIL_H][STENCIL_W],
+                           DATA_TYPE out[STENCIL_H][STENCIL_W]) {
+  int i, j;
+#pragma scop
+  for (i = 1; i < h - 1; ++i)
+    for (j = 1; j < w - 1; ++j)
+      out[i][j] =
+          (DATA_TYPE)0.11111111 * in[i - 1][j - 1] +
+          (DATA_TYPE)0.11111111 * in[i - 1][j] +
+          (DATA_TYPE)0.11111111 * in[i - 1][j + 1] +
+          (DATA_TYPE)0.11111111 * in[i][j - 1] +
+          (DATA_TYPE)0.11111111 * in[i][j] +
+          (DATA_TYPE)0.11111111 * in[i][j + 1] +
+          (DATA_TYPE)0.11111111 * in[i + 1][j - 1] +
+          (DATA_TYPE)0.11111111 * in[i + 1][j] +
+          (DATA_TYPE)0.11111111 * in[i + 1][j + 1];
+#pragma endscop
+}
+
+void kernel_stencil_gaussian3x3(int h, int w,
+                                DATA_TYPE in[STENCIL_H][STENCIL_W],
+                                DATA_TYPE out[STENCIL_H][STENCIL_W]) {
+  int i, j;
+#pragma scop
+  for (i = 1; i < h - 1; ++i)
+    for (j = 1; j < w - 1; ++j)
+      out[i][j] =
+          (DATA_TYPE)0.0625 * in[i - 1][j - 1] +
+          (DATA_TYPE)0.1250 * in[i - 1][j] +
+          (DATA_TYPE)0.0625 * in[i - 1][j + 1] +
+          (DATA_TYPE)0.1250 * in[i][j - 1] +
+          (DATA_TYPE)0.2500 * in[i][j] +
+          (DATA_TYPE)0.1250 * in[i][j + 1] +
+          (DATA_TYPE)0.0625 * in[i + 1][j - 1] +
+          (DATA_TYPE)0.1250 * in[i + 1][j] +
+          (DATA_TYPE)0.0625 * in[i + 1][j + 1];
+#pragma endscop
+}
+
+void kernel_stencil_sobel_x3x3(int h, int w,
+                               DATA_TYPE in[STENCIL_H][STENCIL_W],
+                               DATA_TYPE out[STENCIL_H][STENCIL_W]) {
+  int i, j;
+#pragma scop
+  for (i = 1; i < h - 1; ++i)
+    for (j = 1; j < w - 1; ++j)
+      out[i][j] =
+          (DATA_TYPE)-1.0 * in[i - 1][j - 1] +
+          (DATA_TYPE)0.0 * in[i - 1][j] +
+          (DATA_TYPE)1.0 * in[i - 1][j + 1] +
+          (DATA_TYPE)-2.0 * in[i][j - 1] +
+          (DATA_TYPE)0.0 * in[i][j] +
+          (DATA_TYPE)2.0 * in[i][j + 1] +
+          (DATA_TYPE)-1.0 * in[i + 1][j - 1] +
+          (DATA_TYPE)0.0 * in[i + 1][j] +
+          (DATA_TYPE)1.0 * in[i + 1][j + 1];
+#pragma endscop
+}
+
+void kernel_stencil_sobel_y3x3(int h, int w,
+                               DATA_TYPE in[STENCIL_H][STENCIL_W],
+                               DATA_TYPE out[STENCIL_H][STENCIL_W]) {
+  int i, j;
+#pragma scop
+  for (i = 1; i < h - 1; ++i)
+    for (j = 1; j < w - 1; ++j)
+      out[i][j] =
+          (DATA_TYPE)-1.0 * in[i - 1][j - 1] +
+          (DATA_TYPE)-2.0 * in[i - 1][j] +
+          (DATA_TYPE)-1.0 * in[i - 1][j + 1] +
+          (DATA_TYPE)0.0 * in[i][j - 1] +
+          (DATA_TYPE)0.0 * in[i][j] +
+          (DATA_TYPE)0.0 * in[i][j + 1] +
+          (DATA_TYPE)1.0 * in[i + 1][j - 1] +
+          (DATA_TYPE)2.0 * in[i + 1][j] +
+          (DATA_TYPE)1.0 * in[i + 1][j + 1];
+#pragma endscop
+}
+
+void kernel_stencil_laplacian4_3x3(int h, int w,
+                                   DATA_TYPE in[STENCIL_H][STENCIL_W],
+                                   DATA_TYPE out[STENCIL_H][STENCIL_W]) {
+  int i, j;
+#pragma scop
+  for (i = 1; i < h - 1; ++i)
+    for (j = 1; j < w - 1; ++j)
+      out[i][j] =
+          (DATA_TYPE)0.0 * in[i - 1][j - 1] +
+          (DATA_TYPE)1.0 * in[i - 1][j] +
+          (DATA_TYPE)0.0 * in[i - 1][j + 1] +
+          (DATA_TYPE)1.0 * in[i][j - 1] +
+          (DATA_TYPE)-4.0 * in[i][j] +
+          (DATA_TYPE)1.0 * in[i][j + 1] +
+          (DATA_TYPE)0.0 * in[i + 1][j - 1] +
+          (DATA_TYPE)1.0 * in[i + 1][j] +
+          (DATA_TYPE)0.0 * in[i + 1][j + 1];
+#pragma endscop
+}
+
+void kernel_stencil_laplacian8_3x3(int h, int w,
+                                   DATA_TYPE in[STENCIL_H][STENCIL_W],
+                                   DATA_TYPE out[STENCIL_H][STENCIL_W]) {
+  int i, j;
+#pragma scop
+  for (i = 1; i < h - 1; ++i)
+    for (j = 1; j < w - 1; ++j)
+      out[i][j] =
+          (DATA_TYPE)1.0 * in[i - 1][j - 1] +
+          (DATA_TYPE)1.0 * in[i - 1][j] +
+          (DATA_TYPE)1.0 * in[i - 1][j + 1] +
+          (DATA_TYPE)1.0 * in[i][j - 1] +
+          (DATA_TYPE)-8.0 * in[i][j] +
+          (DATA_TYPE)1.0 * in[i][j + 1] +
+          (DATA_TYPE)1.0 * in[i + 1][j - 1] +
+          (DATA_TYPE)1.0 * in[i + 1][j] +
+          (DATA_TYPE)1.0 * in[i + 1][j + 1];
+#pragma endscop
+}
+
+void kernel_stencil_sharpen3x3(int h, int w,
+                               DATA_TYPE in[STENCIL_H][STENCIL_W],
+                               DATA_TYPE out[STENCIL_H][STENCIL_W]) {
+  int i, j;
+#pragma scop
+  for (i = 1; i < h - 1; ++i)
+    for (j = 1; j < w - 1; ++j)
+      out[i][j] =
+          (DATA_TYPE)0.0 * in[i - 1][j - 1] +
+          (DATA_TYPE)-1.0 * in[i - 1][j] +
+          (DATA_TYPE)0.0 * in[i - 1][j + 1] +
+          (DATA_TYPE)-1.0 * in[i][j - 1] +
+          (DATA_TYPE)5.0 * in[i][j] +
+          (DATA_TYPE)-1.0 * in[i][j + 1] +
+          (DATA_TYPE)0.0 * in[i + 1][j - 1] +
+          (DATA_TYPE)-1.0 * in[i + 1][j] +
+          (DATA_TYPE)0.0 * in[i + 1][j + 1];
+#pragma endscop
+}
+
+void kernel_stencil_emboss3x3(int h, int w,
+                              DATA_TYPE in[STENCIL_H][STENCIL_W],
+                              DATA_TYPE out[STENCIL_H][STENCIL_W]) {
+  int i, j;
+#pragma scop
+  for (i = 1; i < h - 1; ++i)
+    for (j = 1; j < w - 1; ++j)
+      out[i][j] =
+          (DATA_TYPE)-2.0 * in[i - 1][j - 1] +
+          (DATA_TYPE)-1.0 * in[i - 1][j] +
+          (DATA_TYPE)0.0 * in[i - 1][j + 1] +
+          (DATA_TYPE)-1.0 * in[i][j - 1] +
+          (DATA_TYPE)1.0 * in[i][j] +
+          (DATA_TYPE)1.0 * in[i][j + 1] +
+          (DATA_TYPE)0.0 * in[i + 1][j - 1] +
+          (DATA_TYPE)1.0 * in[i + 1][j] +
+          (DATA_TYPE)2.0 * in[i + 1][j + 1];
+#pragma endscop
+}
+
+/* 5x5 fixtures exercise the sibling 25-tap cuDNN convolution path. */
+void kernel_stencil_box5x5(int h, int w,
+                           DATA_TYPE in[STENCIL_H][STENCIL_W],
+                           DATA_TYPE out[STENCIL_H][STENCIL_W]) {
+  int i, j;
+#pragma scop
+  for (i = 2; i < h - 2; ++i)
+    for (j = 2; j < w - 2; ++j)
+      out[i][j] =
+          (DATA_TYPE)0.04 * in[i - 2][j - 2] +
+          (DATA_TYPE)0.04 * in[i - 2][j - 1] +
+          (DATA_TYPE)0.04 * in[i - 2][j] +
+          (DATA_TYPE)0.04 * in[i - 2][j + 1] +
+          (DATA_TYPE)0.04 * in[i - 2][j + 2] +
+          (DATA_TYPE)0.04 * in[i - 1][j - 2] +
+          (DATA_TYPE)0.04 * in[i - 1][j - 1] +
+          (DATA_TYPE)0.04 * in[i - 1][j] +
+          (DATA_TYPE)0.04 * in[i - 1][j + 1] +
+          (DATA_TYPE)0.04 * in[i - 1][j + 2] +
+          (DATA_TYPE)0.04 * in[i][j - 2] +
+          (DATA_TYPE)0.04 * in[i][j - 1] +
+          (DATA_TYPE)0.04 * in[i][j] +
+          (DATA_TYPE)0.04 * in[i][j + 1] +
+          (DATA_TYPE)0.04 * in[i][j + 2] +
+          (DATA_TYPE)0.04 * in[i + 1][j - 2] +
+          (DATA_TYPE)0.04 * in[i + 1][j - 1] +
+          (DATA_TYPE)0.04 * in[i + 1][j] +
+          (DATA_TYPE)0.04 * in[i + 1][j + 1] +
+          (DATA_TYPE)0.04 * in[i + 1][j + 2] +
+          (DATA_TYPE)0.04 * in[i + 2][j - 2] +
+          (DATA_TYPE)0.04 * in[i + 2][j - 1] +
+          (DATA_TYPE)0.04 * in[i + 2][j] +
+          (DATA_TYPE)0.04 * in[i + 2][j + 1] +
+          (DATA_TYPE)0.04 * in[i + 2][j + 2];
+#pragma endscop
+}
+
+#define STENCIL5_TAP(DI, DJ, W) ((DATA_TYPE)(W) * in[i + (DI)][j + (DJ)])
+
+void kernel_stencil_gaussian5x5(int h, int w,
+                                DATA_TYPE in[STENCIL_H][STENCIL_W],
+                                DATA_TYPE out[STENCIL_H][STENCIL_W]) {
+  int i, j;
+#pragma scop
+  for (i = 2; i < h - 2; ++i)
+    for (j = 2; j < w - 2; ++j)
+      out[i][j] =
+          STENCIL5_TAP(-2, -2, 0.00390625) +
+          STENCIL5_TAP(-2, -1, 0.01562500) +
+          STENCIL5_TAP(-2,  0, 0.02343750) +
+          STENCIL5_TAP(-2,  1, 0.01562500) +
+          STENCIL5_TAP(-2,  2, 0.00390625) +
+          STENCIL5_TAP(-1, -2, 0.01562500) +
+          STENCIL5_TAP(-1, -1, 0.06250000) +
+          STENCIL5_TAP(-1,  0, 0.09375000) +
+          STENCIL5_TAP(-1,  1, 0.06250000) +
+          STENCIL5_TAP(-1,  2, 0.01562500) +
+          STENCIL5_TAP( 0, -2, 0.02343750) +
+          STENCIL5_TAP( 0, -1, 0.09375000) +
+          STENCIL5_TAP( 0,  0, 0.14062500) +
+          STENCIL5_TAP( 0,  1, 0.09375000) +
+          STENCIL5_TAP( 0,  2, 0.02343750) +
+          STENCIL5_TAP( 1, -2, 0.01562500) +
+          STENCIL5_TAP( 1, -1, 0.06250000) +
+          STENCIL5_TAP( 1,  0, 0.09375000) +
+          STENCIL5_TAP( 1,  1, 0.06250000) +
+          STENCIL5_TAP( 1,  2, 0.01562500) +
+          STENCIL5_TAP( 2, -2, 0.00390625) +
+          STENCIL5_TAP( 2, -1, 0.01562500) +
+          STENCIL5_TAP( 2,  0, 0.02343750) +
+          STENCIL5_TAP( 2,  1, 0.01562500) +
+          STENCIL5_TAP( 2,  2, 0.00390625);
+#pragma endscop
+}
+
+void kernel_stencil_sobel_x5x5(int h, int w,
+                               DATA_TYPE in[STENCIL_H][STENCIL_W],
+                               DATA_TYPE out[STENCIL_H][STENCIL_W]) {
+  int i, j;
+#pragma scop
+  for (i = 2; i < h - 2; ++i)
+    for (j = 2; j < w - 2; ++j)
+      out[i][j] =
+          STENCIL5_TAP(-2, -2, -5.0) +
+          STENCIL5_TAP(-2, -1, -4.0) +
+          STENCIL5_TAP(-2,  0,  0.0) +
+          STENCIL5_TAP(-2,  1,  4.0) +
+          STENCIL5_TAP(-2,  2,  5.0) +
+          STENCIL5_TAP(-1, -2, -8.0) +
+          STENCIL5_TAP(-1, -1, -10.0) +
+          STENCIL5_TAP(-1,  0,  0.0) +
+          STENCIL5_TAP(-1,  1,  10.0) +
+          STENCIL5_TAP(-1,  2,  8.0) +
+          STENCIL5_TAP( 0, -2, -10.0) +
+          STENCIL5_TAP( 0, -1, -20.0) +
+          STENCIL5_TAP( 0,  0,  0.0) +
+          STENCIL5_TAP( 0,  1,  20.0) +
+          STENCIL5_TAP( 0,  2,  10.0) +
+          STENCIL5_TAP( 1, -2, -8.0) +
+          STENCIL5_TAP( 1, -1, -10.0) +
+          STENCIL5_TAP( 1,  0,  0.0) +
+          STENCIL5_TAP( 1,  1,  10.0) +
+          STENCIL5_TAP( 1,  2,  8.0) +
+          STENCIL5_TAP( 2, -2, -5.0) +
+          STENCIL5_TAP( 2, -1, -4.0) +
+          STENCIL5_TAP( 2,  0,  0.0) +
+          STENCIL5_TAP( 2,  1,  4.0) +
+          STENCIL5_TAP( 2,  2,  5.0);
+#pragma endscop
+}
+
+void kernel_stencil_sobel_y5x5(int h, int w,
+                               DATA_TYPE in[STENCIL_H][STENCIL_W],
+                               DATA_TYPE out[STENCIL_H][STENCIL_W]) {
+  int i, j;
+#pragma scop
+  for (i = 2; i < h - 2; ++i)
+    for (j = 2; j < w - 2; ++j)
+      out[i][j] =
+          STENCIL5_TAP(-2, -2, -5.0) +
+          STENCIL5_TAP(-2, -1, -8.0) +
+          STENCIL5_TAP(-2,  0, -10.0) +
+          STENCIL5_TAP(-2,  1, -8.0) +
+          STENCIL5_TAP(-2,  2, -5.0) +
+          STENCIL5_TAP(-1, -2, -4.0) +
+          STENCIL5_TAP(-1, -1, -10.0) +
+          STENCIL5_TAP(-1,  0, -20.0) +
+          STENCIL5_TAP(-1,  1, -10.0) +
+          STENCIL5_TAP(-1,  2, -4.0) +
+          STENCIL5_TAP( 0, -2,  0.0) +
+          STENCIL5_TAP( 0, -1,  0.0) +
+          STENCIL5_TAP( 0,  0,  0.0) +
+          STENCIL5_TAP( 0,  1,  0.0) +
+          STENCIL5_TAP( 0,  2,  0.0) +
+          STENCIL5_TAP( 1, -2,  4.0) +
+          STENCIL5_TAP( 1, -1,  10.0) +
+          STENCIL5_TAP( 1,  0,  20.0) +
+          STENCIL5_TAP( 1,  1,  10.0) +
+          STENCIL5_TAP( 1,  2,  4.0) +
+          STENCIL5_TAP( 2, -2,  5.0) +
+          STENCIL5_TAP( 2, -1,  8.0) +
+          STENCIL5_TAP( 2,  0,  10.0) +
+          STENCIL5_TAP( 2,  1,  8.0) +
+          STENCIL5_TAP( 2,  2,  5.0);
+#pragma endscop
+}
+
+void kernel_stencil_laplacian5x5(int h, int w,
+                                 DATA_TYPE in[STENCIL_H][STENCIL_W],
+                                 DATA_TYPE out[STENCIL_H][STENCIL_W]) {
+  int i, j;
+#pragma scop
+  for (i = 2; i < h - 2; ++i)
+    for (j = 2; j < w - 2; ++j)
+      out[i][j] =
+          STENCIL5_TAP(-2, -2,  0.0) +
+          STENCIL5_TAP(-2, -1,  0.0) +
+          STENCIL5_TAP(-2,  0, -1.0) +
+          STENCIL5_TAP(-2,  1,  0.0) +
+          STENCIL5_TAP(-2,  2,  0.0) +
+          STENCIL5_TAP(-1, -2,  0.0) +
+          STENCIL5_TAP(-1, -1, -1.0) +
+          STENCIL5_TAP(-1,  0, -2.0) +
+          STENCIL5_TAP(-1,  1, -1.0) +
+          STENCIL5_TAP(-1,  2,  0.0) +
+          STENCIL5_TAP( 0, -2, -1.0) +
+          STENCIL5_TAP( 0, -1, -2.0) +
+          STENCIL5_TAP( 0,  0, 16.0) +
+          STENCIL5_TAP( 0,  1, -2.0) +
+          STENCIL5_TAP( 0,  2, -1.0) +
+          STENCIL5_TAP( 1, -2,  0.0) +
+          STENCIL5_TAP( 1, -1, -1.0) +
+          STENCIL5_TAP( 1,  0, -2.0) +
+          STENCIL5_TAP( 1,  1, -1.0) +
+          STENCIL5_TAP( 1,  2,  0.0) +
+          STENCIL5_TAP( 2, -2,  0.0) +
+          STENCIL5_TAP( 2, -1,  0.0) +
+          STENCIL5_TAP( 2,  0, -1.0) +
+          STENCIL5_TAP( 2,  1,  0.0) +
+          STENCIL5_TAP( 2,  2,  0.0);
+#pragma endscop
+}
+
+void kernel_stencil_sharpen5x5(int h, int w,
+                               DATA_TYPE in[STENCIL_H][STENCIL_W],
+                               DATA_TYPE out[STENCIL_H][STENCIL_W]) {
+  int i, j;
+#pragma scop
+  for (i = 2; i < h - 2; ++i)
+    for (j = 2; j < w - 2; ++j)
+      out[i][j] =
+          STENCIL5_TAP(-2, -2, -0.125) +
+          STENCIL5_TAP(-2, -1, -0.125) +
+          STENCIL5_TAP(-2,  0, -0.125) +
+          STENCIL5_TAP(-2,  1, -0.125) +
+          STENCIL5_TAP(-2,  2, -0.125) +
+          STENCIL5_TAP(-1, -2, -0.125) +
+          STENCIL5_TAP(-1, -1,  0.250) +
+          STENCIL5_TAP(-1,  0,  0.250) +
+          STENCIL5_TAP(-1,  1,  0.250) +
+          STENCIL5_TAP(-1,  2, -0.125) +
+          STENCIL5_TAP( 0, -2, -0.125) +
+          STENCIL5_TAP( 0, -1,  0.250) +
+          STENCIL5_TAP( 0,  0,  1.000) +
+          STENCIL5_TAP( 0,  1,  0.250) +
+          STENCIL5_TAP( 0,  2, -0.125) +
+          STENCIL5_TAP( 1, -2, -0.125) +
+          STENCIL5_TAP( 1, -1,  0.250) +
+          STENCIL5_TAP( 1,  0,  0.250) +
+          STENCIL5_TAP( 1,  1,  0.250) +
+          STENCIL5_TAP( 1,  2, -0.125) +
+          STENCIL5_TAP( 2, -2, -0.125) +
+          STENCIL5_TAP( 2, -1, -0.125) +
+          STENCIL5_TAP( 2,  0, -0.125) +
+          STENCIL5_TAP( 2,  1, -0.125) +
+          STENCIL5_TAP( 2,  2, -0.125);
+#pragma endscop
+}
+
+void kernel_stencil_emboss5x5(int h, int w,
+                              DATA_TYPE in[STENCIL_H][STENCIL_W],
+                              DATA_TYPE out[STENCIL_H][STENCIL_W]) {
+  int i, j;
+#pragma scop
+  for (i = 2; i < h - 2; ++i)
+    for (j = 2; j < w - 2; ++j)
+      out[i][j] =
+          STENCIL5_TAP(-2, -2, -2.0) +
+          STENCIL5_TAP(-2, -1, -1.0) +
+          STENCIL5_TAP(-2,  0, -1.0) +
+          STENCIL5_TAP(-2,  1,  0.0) +
+          STENCIL5_TAP(-2,  2,  0.0) +
+          STENCIL5_TAP(-1, -2, -1.0) +
+          STENCIL5_TAP(-1, -1, -1.0) +
+          STENCIL5_TAP(-1,  0,  0.0) +
+          STENCIL5_TAP(-1,  1,  1.0) +
+          STENCIL5_TAP(-1,  2,  0.0) +
+          STENCIL5_TAP( 0, -2, -1.0) +
+          STENCIL5_TAP( 0, -1,  0.0) +
+          STENCIL5_TAP( 0,  0,  1.0) +
+          STENCIL5_TAP( 0,  1,  1.0) +
+          STENCIL5_TAP( 0,  2,  1.0) +
+          STENCIL5_TAP( 1, -2,  0.0) +
+          STENCIL5_TAP( 1, -1,  1.0) +
+          STENCIL5_TAP( 1,  0,  1.0) +
+          STENCIL5_TAP( 1,  1,  1.0) +
+          STENCIL5_TAP( 1,  2,  2.0) +
+          STENCIL5_TAP( 2, -2,  0.0) +
+          STENCIL5_TAP( 2, -1,  0.0) +
+          STENCIL5_TAP( 2,  0,  1.0) +
+          STENCIL5_TAP( 2,  1,  2.0) +
+          STENCIL5_TAP( 2,  2,  2.0);
+#pragma endscop
+}
+
+#undef STENCIL5_TAP
+
+/* 7x7 fixture exercises the generalized packed-weight ntap path. */
+#define STENCIL7_TAP(DI, DJ, W) ((DATA_TYPE)(W) * in[i + (DI)][j + (DJ)])
+
+void kernel_stencil_box7x7(int h, int w,
+                           DATA_TYPE in[STENCIL_H][STENCIL_W],
+                           DATA_TYPE out[STENCIL_H][STENCIL_W]) {
+  int i, j;
+#pragma scop
+  for (i = 3; i < h - 3; ++i)
+    for (j = 3; j < w - 3; ++j)
+      out[i][j] =
+          STENCIL7_TAP(-3, -3, 0.02040816326530612) +
+          STENCIL7_TAP(-3, -2, 0.02040816326530612) +
+          STENCIL7_TAP(-3, -1, 0.02040816326530612) +
+          STENCIL7_TAP(-3,  0, 0.02040816326530612) +
+          STENCIL7_TAP(-3,  1, 0.02040816326530612) +
+          STENCIL7_TAP(-3,  2, 0.02040816326530612) +
+          STENCIL7_TAP(-3,  3, 0.02040816326530612) +
+          STENCIL7_TAP(-2, -3, 0.02040816326530612) +
+          STENCIL7_TAP(-2, -2, 0.02040816326530612) +
+          STENCIL7_TAP(-2, -1, 0.02040816326530612) +
+          STENCIL7_TAP(-2,  0, 0.02040816326530612) +
+          STENCIL7_TAP(-2,  1, 0.02040816326530612) +
+          STENCIL7_TAP(-2,  2, 0.02040816326530612) +
+          STENCIL7_TAP(-2,  3, 0.02040816326530612) +
+          STENCIL7_TAP(-1, -3, 0.02040816326530612) +
+          STENCIL7_TAP(-1, -2, 0.02040816326530612) +
+          STENCIL7_TAP(-1, -1, 0.02040816326530612) +
+          STENCIL7_TAP(-1,  0, 0.02040816326530612) +
+          STENCIL7_TAP(-1,  1, 0.02040816326530612) +
+          STENCIL7_TAP(-1,  2, 0.02040816326530612) +
+          STENCIL7_TAP(-1,  3, 0.02040816326530612) +
+          STENCIL7_TAP( 0, -3, 0.02040816326530612) +
+          STENCIL7_TAP( 0, -2, 0.02040816326530612) +
+          STENCIL7_TAP( 0, -1, 0.02040816326530612) +
+          STENCIL7_TAP( 0,  0, 0.02040816326530612) +
+          STENCIL7_TAP( 0,  1, 0.02040816326530612) +
+          STENCIL7_TAP( 0,  2, 0.02040816326530612) +
+          STENCIL7_TAP( 0,  3, 0.02040816326530612) +
+          STENCIL7_TAP( 1, -3, 0.02040816326530612) +
+          STENCIL7_TAP( 1, -2, 0.02040816326530612) +
+          STENCIL7_TAP( 1, -1, 0.02040816326530612) +
+          STENCIL7_TAP( 1,  0, 0.02040816326530612) +
+          STENCIL7_TAP( 1,  1, 0.02040816326530612) +
+          STENCIL7_TAP( 1,  2, 0.02040816326530612) +
+          STENCIL7_TAP( 1,  3, 0.02040816326530612) +
+          STENCIL7_TAP( 2, -3, 0.02040816326530612) +
+          STENCIL7_TAP( 2, -2, 0.02040816326530612) +
+          STENCIL7_TAP( 2, -1, 0.02040816326530612) +
+          STENCIL7_TAP( 2,  0, 0.02040816326530612) +
+          STENCIL7_TAP( 2,  1, 0.02040816326530612) +
+          STENCIL7_TAP( 2,  2, 0.02040816326530612) +
+          STENCIL7_TAP( 2,  3, 0.02040816326530612) +
+          STENCIL7_TAP( 3, -3, 0.02040816326530612) +
+          STENCIL7_TAP( 3, -2, 0.02040816326530612) +
+          STENCIL7_TAP( 3, -1, 0.02040816326530612) +
+          STENCIL7_TAP( 3,  0, 0.02040816326530612) +
+          STENCIL7_TAP( 3,  1, 0.02040816326530612) +
+          STENCIL7_TAP( 3,  2, 0.02040816326530612) +
+          STENCIL7_TAP( 3,  3, 0.02040816326530612);
+#pragma endscop
+}
+
+#undef STENCIL7_TAP
+
+static DATA_TYPE input_img[STENCIL_H][STENCIL_W];
+static DATA_TYPE output_img[STENCIL_H][STENCIL_W];
+
+static DATA_TYPE init_value(int i, int j) {
+  int v = (i * 17 + j * 13 + 7) % 101;
+  return (DATA_TYPE)((v - 50) * 0.01f);
+}
+
+static void init_arrays(void) {
+  for (int i = 0; i < STENCIL_H; ++i) {
+    for (int j = 0; j < STENCIL_W; ++j) {
+      input_img[i][j] = init_value(i, j);
+      output_img[i][j] = (DATA_TYPE)0;
+    }
+  }
+}
+
+static void print_checksum(void) {
+  DATA_TYPE checksum = (DATA_TYPE)0;
+  for (int i = 0; i < STENCIL_H; ++i) {
+    for (int j = 0; j < STENCIL_W; ++j) {
+      checksum += output_img[i][j];
+    }
+  }
+  printf("%.8f\n", (double)checksum);
+}
+
+int main(void) {
+  init_arrays();
+  for (int r = 0; r < REPEAT; ++r) {
+    STENCIL_KERNEL(STENCIL_H, STENCIL_W, input_img, output_img);
+  }
+  print_checksum();
+  return 0;
+}
diff --git a/third_party/cnn-extracted/whisper_ops.c b/third_party/cnn-extracted/whisper_ops.c
new file mode 100644
index 000000000000..8e9cc3ecdbbf
--- /dev/null
+++ b/third_party/cnn-extracted/whisper_ops.c
@@ -0,0 +1,118 @@
+/* whisper_ops.c -- standalone Whisper/ggml-style operation fixtures.
+ *
+ * These source-level kernels isolate the compute shapes we want the linalg
+ * raising pipeline to see from Whisper inference: dot product, softmax,
+ * RMSNorm-like normalization, GELU, and the encoder-side 1D convolution.
+ */
+
+#include 
+
+#ifndef DATA_TYPE
+#define DATA_TYPE float
+#endif
+
+#ifndef N
+#define N 128
+#endif
+
+#ifndef CONV_IN
+#define CONV_IN 160
+#endif
+
+#ifndef CONV_K
+#define CONV_K 3
+#endif
+
+#define CONV_OUT (CONV_IN - CONV_K + 1)
+#define NEG_INF ((DATA_TYPE)-3.4028234663852886e38f)
+
+void kernel_whisper_vec_dot(DATA_TYPE out[1], DATA_TYPE x[N],
+                            DATA_TYPE y[N]) {
+  DATA_TYPE sum = (DATA_TYPE)0;
+
+#pragma scop
+  for (int i = 0; i < N; ++i) {
+    sum += x[i] * y[i];
+  }
+  out[0] = sum;
+#pragma endscop
+}
+
+DATA_TYPE kernel_whisper_vec_softmax(DATA_TYPE out[N], DATA_TYPE x[N],
+                                     DATA_TYPE max_val) {
+  DATA_TYPE sum = (DATA_TYPE)0;
+
+#pragma scop
+  for (int i = 0; i < N; ++i) {
+    DATA_TYPE val = expf(x[i] - max_val);
+    out[i] = val;
+    sum += val;
+  }
+#pragma endscop
+
+  return sum;
+}
+
+void kernel_whisper_softmax_full(DATA_TYPE out[N], DATA_TYPE x[N]) {
+  DATA_TYPE max_val = NEG_INF;
+
+#pragma scop
+  for (int i = 0; i < N; ++i) {
+    if (x[i] > max_val) {
+      max_val = x[i];
+    }
+  }
+
+  DATA_TYPE sum = (DATA_TYPE)0;
+  for (int i = 0; i < N; ++i) {
+    DATA_TYPE val = expf(x[i] - max_val);
+    out[i] = val;
+    sum += val;
+  }
+
+  DATA_TYPE inv_sum = (DATA_TYPE)1 / sum;
+  for (int i = 0; i < N; ++i) {
+    out[i] *= inv_sum;
+  }
+#pragma endscop
+}
+
+void kernel_whisper_rms_norm(DATA_TYPE out[N], DATA_TYPE x[N],
+                             DATA_TYPE eps) {
+  DATA_TYPE ss = (DATA_TYPE)0;
+
+#pragma scop
+  for (int i = 0; i < N; ++i) {
+    ss += x[i] * x[i];
+  }
+
+  DATA_TYPE scale = (DATA_TYPE)1 / sqrtf(ss / (DATA_TYPE)N + eps);
+  for (int i = 0; i < N; ++i) {
+    out[i] = x[i] * scale;
+  }
+#pragma endscop
+}
+
+void kernel_whisper_gelu(DATA_TYPE out[N], DATA_TYPE x[N]) {
+#pragma scop
+  for (int i = 0; i < N; ++i) {
+    DATA_TYPE v = x[i];
+    DATA_TYPE inner = (DATA_TYPE)0.7978845608028654f *
+                      (v + (DATA_TYPE)0.044715f * v * v * v);
+    out[i] = (DATA_TYPE)0.5f * v * ((DATA_TYPE)1 + tanhf(inner));
+  }
+#pragma endscop
+}
+
+void kernel_whisper_conv1d(int n, int k, float *out, const float *x,
+                           const float *filter) {
+#pragma scop
+  for (int i = 0; i <= n - k; ++i) {
+    float sum = 0.0f;
+    for (int j = 0; j < k; ++j) {
+      sum += x[i + j] * filter[j];
+    }
+    out[i] = sum;
+  }
+#pragma endscop
+}
diff --git a/third_party/polybenchGpu-extracted/conv2d.c b/third_party/polybenchGpu-extracted/conv2d.c
new file mode 100644
index 000000000000..c268d14fcf01
--- /dev/null
+++ b/third_party/polybenchGpu-extracted/conv2d.c
@@ -0,0 +1,37 @@
+// conv2d.c — extracted from polybenchGpu/OpenMP/stencils/convolution-2d/.
+//
+// Why this extraction exists: the original polybenchGpu file mixes
+// kernel_conv2d + init_array + main + print_array in one TU. cgeist
+// inlines everything into main; the optimizer then notices init_array
+// writes A[i][j] = (i+j)/nj (a constant function of indices) and
+// constant-folds the entire conv2d body — the lifted linalg.generic
+// ends up with NO ins(A), just synthesises B[i,j] = closed-form
+// function of indices. That bypass makes the matcher unable to
+// fingerprint a conv2d shape (no input operand to match against).
+//
+// This extraction breaks the inlining chain: the function is alone in
+// its TU, takes A and B as explicit parameters, and uses fixed sizes
+// baked in via #define so the loop bounds are constant. The lift
+// produces a clean linalg.generic with ins(A) outs(B) and the matcher
+// can recognise it.
+//
+// Mirrors third_party/NPB-polybenchified/ in spirit and convention.
+
+#ifndef NI
+#define NI 256
+#endif
+#ifndef NJ
+#define NJ 256
+#endif
+
+// 9-tap 3x3 stencil, weights from polybenchGpu's original kernel_conv2d.
+void kernel_conv2d(int ni, int nj,
+                   double A[NI][NJ], double B[NI][NJ]) {
+  int i, j;
+  for (i = 1; i < ni - 1; ++i)
+    for (j = 1; j < nj - 1; ++j) {
+      B[i][j] =  0.2 * A[i-1][j-1] +  0.5 * A[i-1][j] + -0.8 * A[i-1][j+1]
+              + -0.3 * A[ i ][j-1] +  0.6 * A[ i ][j] + -0.9 * A[ i ][j+1]
+              +  0.4 * A[i+1][j-1] +  0.7 * A[i+1][j] +  0.1 * A[i+1][j+1];
+    }
+}
diff --git a/third_party/polybenchGpu-extracted/conv2d_f16.c b/third_party/polybenchGpu-extracted/conv2d_f16.c
new file mode 100644
index 000000000000..645e4c0c17e7
--- /dev/null
+++ b/third_party/polybenchGpu-extracted/conv2d_f16.c
@@ -0,0 +1,32 @@
+// conv2d_f16.c — half-precision (_Float16) variant of the extracted conv2d
+// kernel. Same 3x3 polybench filter as conv2d.c but in _Float16 instead of
+// double. Used to validate Phase 2 FP16 generalization: the matcher
+// fingerprints any half-dtype conv body, the rewriter emits a `_f16`-suffixed
+// launch symbol, ABI lowering dispatches to the f16 runtime shim.
+//
+// Weights use the same 0.X polybench filter as conv2d.c. _Float16 has only
+// ~3 decimal digits of precision, so a literal like 0.2f16 isn't exactly
+// 0.2 — the bit-exact validator must be tolerant of that. Use the CPU stub
+// (which accumulates in float and downcasts on store) as the reference; the
+// CUDA path also uses FP32 internal accumulation so both should agree.
+
+#ifndef NI
+#define NI 256
+#endif
+#ifndef NJ
+#define NJ 256
+#endif
+
+void kernel_conv2d(int ni, int nj,
+                   _Float16 A[NI][NJ], _Float16 B[NI][NJ]) {
+  int i, j;
+  for (i = 1; i < ni - 1; ++i)
+    for (j = 1; j < nj - 1; ++j) {
+      B[i][j] = (_Float16)0.2 * A[i-1][j-1] + (_Float16)0.5 * A[i-1][j]
+              + (_Float16)-0.8 * A[i-1][j+1]
+              + (_Float16)-0.3 * A[ i ][j-1] + (_Float16)0.6 * A[ i ][j]
+              + (_Float16)-0.9 * A[ i ][j+1]
+              + (_Float16)0.4 * A[i+1][j-1] + (_Float16)0.7 * A[i+1][j]
+              + (_Float16)0.1 * A[i+1][j+1];
+    }
+}
diff --git a/third_party/polybenchGpu-extracted/conv2d_f32.c b/third_party/polybenchGpu-extracted/conv2d_f32.c
new file mode 100644
index 000000000000..1f17bd375df7
--- /dev/null
+++ b/third_party/polybenchGpu-extracted/conv2d_f32.c
@@ -0,0 +1,23 @@
+// conv2d_f32.c — single-precision (float) variant of the extracted conv2d
+// kernel. Same 3x3 polybench filter as conv2d.c but in float instead of
+// double. Used to validate Phase 2 of the cuDNN conv generalization —
+// matcher fingerprints any float-dtype conv body, emits a dtype-suffixed
+// launch symbol, ABI lowering dispatches to the f32 runtime shim.
+
+#ifndef NI
+#define NI 256
+#endif
+#ifndef NJ
+#define NJ 256
+#endif
+
+void kernel_conv2d(int ni, int nj,
+                   float A[NI][NJ], float B[NI][NJ]) {
+  int i, j;
+  for (i = 1; i < ni - 1; ++i)
+    for (j = 1; j < nj - 1; ++j) {
+      B[i][j] =  0.2f * A[i-1][j-1] +  0.5f * A[i-1][j] + -0.8f * A[i-1][j+1]
+              + -0.3f * A[ i ][j-1] +  0.6f * A[ i ][j] + -0.9f * A[ i ][j+1]
+              +  0.4f * A[i+1][j-1] +  0.7f * A[i+1][j] +  0.1f * A[i+1][j+1];
+    }
+}
diff --git a/third_party/polybenchGpu-extracted/conv2d_i16.c b/third_party/polybenchGpu-extracted/conv2d_i16.c
new file mode 100644
index 000000000000..ea9f25e11804
--- /dev/null
+++ b/third_party/polybenchGpu-extracted/conv2d_i16.c
@@ -0,0 +1,23 @@
+// conv2d_i16.c — int16_t variant of the extracted conv2d kernel. Tests the
+// INT16 path: matcher binds the int conv body, the rewriter emits
+// @cudnnConvolution2D_9tap_i16, and the ABI lowering routes to the i16
+// shim. The shim itself upcasts to int32 internally because cuDNN has no
+// native i16 convolution.
+
+#ifndef NI
+#define NI 256
+#endif
+#ifndef NJ
+#define NJ 256
+#endif
+
+void kernel_conv2d(int ni, int nj,
+                   short A[NI][NJ], short B[NI][NJ]) {
+  int i, j;
+  for (i = 1; i < ni - 1; ++i)
+    for (j = 1; j < nj - 1; ++j) {
+      B[i][j] = (short)( 2 * A[i-1][j-1] +  5 * A[i-1][j] + -8 * A[i-1][j+1]
+                       + -3 * A[ i ][j-1] +  6 * A[ i ][j] + -9 * A[ i ][j+1]
+                       +  4 * A[i+1][j-1] +  7 * A[i+1][j] +  3 * A[i+1][j+1]);
+    }
+}
diff --git a/third_party/polybenchGpu-extracted/conv2d_i32.c b/third_party/polybenchGpu-extracted/conv2d_i32.c
new file mode 100644
index 000000000000..9e49e172a10b
--- /dev/null
+++ b/third_party/polybenchGpu-extracted/conv2d_i32.c
@@ -0,0 +1,26 @@
+// conv2d_i32.c — int32_t variant of the extracted conv2d kernel. Same 3x3
+// stencil shape as conv2d.c but with integer weights and inputs. Used to
+// validate the Phase-2 INT32 path: matcher recognises arith.muli/addi,
+// emits @cudnnConvolution2D_9tap_i32, ABI lowering dispatches to
+// polygeist_cudnn_conv2d_3x3_i32 (cuDNN's CUDNN_DATA_INT32 path).
+//
+// Weights chosen so 9-tap sums don't overflow int32 for reasonable input
+// magnitudes — small ints with mixed signs.
+
+#ifndef NI
+#define NI 256
+#endif
+#ifndef NJ
+#define NJ 256
+#endif
+
+void kernel_conv2d(int ni, int nj,
+                   int A[NI][NJ], int B[NI][NJ]) {
+  int i, j;
+  for (i = 1; i < ni - 1; ++i)
+    for (j = 1; j < nj - 1; ++j) {
+      B[i][j] =  2 * A[i-1][j-1] +  5 * A[i-1][j] + -8 * A[i-1][j+1]
+              + -3 * A[ i ][j-1] +  6 * A[ i ][j] + -9 * A[ i ][j+1]
+              +  4 * A[i+1][j-1] +  7 * A[i+1][j] +  3 * A[i+1][j+1];
+    }
+}
diff --git a/third_party/polybenchGpu-extracted/conv2d_i8.c b/third_party/polybenchGpu-extracted/conv2d_i8.c
new file mode 100644
index 000000000000..975982f2bd53
--- /dev/null
+++ b/third_party/polybenchGpu-extracted/conv2d_i8.c
@@ -0,0 +1,35 @@
+/* conv2d_i8.c — int8_t variant of the extracted polybenchGpu conv2d kernel.
+ * Tests the INT8 path: matcher binds the int conv body via its dtype-
+ * agnostic encoding, the rewriter sniffs the operand element type
+ * (i8) and emits @cudnnConvolution2D_9tap_i8, and the ABI lowering
+ * routes to the polygeist_pva_conv2d_3x3_i8 runtime shim (NOT to
+ * cuDNN — cuDNN doesn't accept INT8 standalone conv, but PVA Solutions'
+ * cupva-backed pvaConv2d does).
+ *
+ * Weights are the polybench 9-tap pattern scaled to INT8 range. Product
+ * widths (8b weight * 8b pixel) need a wider accumulator — the C body
+ * here lets cgeist emit `arith.muli i8` plus implicit `arith.extsi` to a
+ * wider compute type, which the matcher's transparent-cast handling
+ * absorbs.
+ */
+
+#ifndef NI
+#define NI 256
+#endif
+#ifndef NJ
+#define NJ 256
+#endif
+
+/* signed char ≡ int8_t in the polybench style — keeps cgeist happy
+ * without needing . */
+void kernel_conv2d(int ni, int nj,
+                   signed char A[NI][NJ], signed char B[NI][NJ]) {
+  int i, j;
+  for (i = 1; i < ni - 1; ++i)
+    for (j = 1; j < nj - 1; ++j) {
+      B[i][j] = (signed char)(
+            2 * A[i-1][j-1] +  5 * A[i-1][j] + -8 * A[i-1][j+1]
+         + -3 * A[ i ][j-1] +  6 * A[ i ][j] + -9 * A[ i ][j+1]
+         +  4 * A[i+1][j-1] +  7 * A[i+1][j] +  3 * A[i+1][j+1]);
+    }
+}
diff --git a/third_party/polybenchGpu-extracted/conv2d_sobel.c b/third_party/polybenchGpu-extracted/conv2d_sobel.c
new file mode 100644
index 000000000000..3b3dce364afa
--- /dev/null
+++ b/third_party/polybenchGpu-extracted/conv2d_sobel.c
@@ -0,0 +1,30 @@
+// conv2d_sobel.c — Sobel-X-like edge filter, scaled by 1.5 so the matcher
+// validation isn't confused by clang's `1.0 * x → x` identity-fold (which
+// removes mulf ops for unit weights — a separate generality gap tracked in
+// project-cudnn-conv-pipeline-generality-gaps).
+//
+// Scaled Sobel-X filter:
+//   [-1.5, 0,  1.5]    no 1.0 or -1.0 weights → mulf ops preserved
+//   [-2.0, 0,  2.0]    0.0 weights are FINE (mulf-by-0 not identity-folded)
+//   [-1.5, 0,  1.5]
+//
+// 5 distinct weights: -2.0, -1.5, 0.0, 1.5, 2.0. Used to prove the matcher
+// surfaces arbitrary 3x3 weights (not just polybench's specific filter).
+
+#ifndef NI
+#define NI 256
+#endif
+#ifndef NJ
+#define NJ 256
+#endif
+
+void kernel_conv2d(int ni, int nj,
+                   double A[NI][NJ], double B[NI][NJ]) {
+  int i, j;
+  for (i = 1; i < ni - 1; ++i)
+    for (j = 1; j < nj - 1; ++j) {
+      B[i][j] = -1.5 * A[i-1][j-1] +  0.0 * A[i-1][j] +  1.5 * A[i-1][j+1]
+             + -2.0 * A[ i ][j-1] +  0.0 * A[ i ][j] +  2.0 * A[ i ][j+1]
+             + -1.5 * A[i+1][j-1] +  0.0 * A[i+1][j] +  1.5 * A[i+1][j+1];
+    }
+}
diff --git a/third_party/polybenchGpu-extracted/conv3d.c b/third_party/polybenchGpu-extracted/conv3d.c
new file mode 100644
index 000000000000..8335dd474dfa
--- /dev/null
+++ b/third_party/polybenchGpu-extracted/conv3d.c
@@ -0,0 +1,38 @@
+// conv3d.c — extracted from polybenchGpu/OpenMP/stencils/convolution-3d/.
+// See conv2d.c in this directory for why extraction is needed (cgeist
+// inlines main→init→kernel, optimizer constant-folds init's
+// A[i,j,k] = f(i,j,k), conv body loses its ins).
+
+#ifndef NI
+#define NI 128
+#endif
+#ifndef NJ
+#define NJ 128
+#endif
+#ifndef NK
+#define NK 128
+#endif
+
+// 15-tap 3D stencil over a 3x3x3 neighbourhood, weights from
+// polybenchGpu's original kernel_conv2d (yes, it's misnamed kernel_conv2d
+// in conv3d.c upstream — sic). Note: the original has duplicated index
+// expressions (`2 * A[i-1][j-1][k-1] + 5 * A[i-1][j-1][k-1]` etc.) — we
+// preserve that here verbatim so the lifted body matches what the IR
+// explorer's existing convolution-3d entry shows.
+void kernel_conv2d(int ni, int nj, int nk,
+                   double A[NI][NJ][NK], double B[NI][NJ][NK]) {
+  int i, j, k;
+  for (i = 1; i < ni - 1; ++i)
+    for (j = 1; j < nj - 1; ++j)
+      for (k = 1; k < nk - 1; ++k) {
+        B[i][j][k] =  2 * A[i-1][j-1][k-1]  +  4 * A[i+1][j-1][k-1]
+                   +  5 * A[i-1][j-1][k-1]  +  7 * A[i+1][j-1][k-1]
+                   + -8 * A[i-1][j-1][k-1]  + 10 * A[i+1][j-1][k-1]
+                   + -3 * A[ i ][j-1][ k ]
+                   +  6 * A[ i ][ j ][ k ]
+                   + -9 * A[ i ][j+1][ k ]
+                   +  2 * A[i-1][j-1][k+1]  +  4 * A[i+1][j-1][k+1]
+                   +  5 * A[i-1][ j ][k+1]  +  7 * A[i+1][ j ][k+1]
+                   + -8 * A[i-1][j+1][k+1]  + 10 * A[i+1][j+1][k+1];
+      }
+}
diff --git a/tools/cgeist/Lib/CGCall.cc b/tools/cgeist/Lib/CGCall.cc
index 164f72b0e7e5..7109b8272971 100644
--- a/tools/cgeist/Lib/CGCall.cc
+++ b/tools/cgeist/Lib/CGCall.cc
@@ -57,6 +57,17 @@ static mlir::Value castCallerMemRefArg(mlir::Value callerArg,
   return callerArg;
 }
 
+static mlir::Value castIntegerToWidth(mlir::Location loc, mlir::Value value,
+                                      mlir::IntegerType dstTy,
+                                      mlir::OpBuilder &builder) {
+  auto srcTy = value.getType().cast();
+  if (srcTy == dstTy)
+    return value;
+  if (srcTy.getWidth() < dstTy.getWidth())
+    return builder.create(loc, dstTy, value);
+  return builder.create(loc, dstTy, value);
+}
+
 /// Typecast the caller args to match the callee's signature. Mismatches that
 /// cannot be resolved by given rules won't raise exceptions, e.g., if the
 /// expected type for an arg is memref<10xi8> while the provided is
@@ -79,6 +90,12 @@ static void castCallerArgs(mlir::func::FuncOp callee,
 
     if (calleeArgType.isa())
       args[i] = castCallerMemRefArg(args[i], calleeArgType, b);
+
+    if (auto callerIntTy = dyn_cast(callerArgType))
+      if (auto calleeIntTy = dyn_cast(calleeArgType))
+        if (callerIntTy != calleeIntTy)
+          args[i] =
+              castIntegerToWidth(args[i].getLoc(), args[i], calleeIntTy, b);
   }
 }
 
@@ -111,12 +128,26 @@ ValueCategory MLIRScanner::CallHelper(
             make_pair(dre->getDecl()->getName().str(), arg.val));
 
     if (i >= fnType.getInputs().size() || (i != 0 && a == nullptr)) {
-      expr->dump();
+      llvm::errs() << "\n=== cgeist CallHelper diagnostic ===\n";
+      llvm::errs() << "callee name:        " << tocall.getName() << "\n";
+      llvm::errs() << "callee input count: " << fnType.getInputs().size()
+                   << "\n";
+      llvm::errs() << "caller arg count:   " << arguments.size() << "\n";
+      llvm::errs() << "failing at arg i:   " << i << "\n";
+      llvm::errs() << "current arg null?:  " << (a == nullptr) << "\n";
+      llvm::errs() << "\n--- callee MLIR func type:\n";
       tocall.dump();
-      fnType.dump();
-      for (auto a : arguments) {
-        std::get<1>(a)->dump();
+      llvm::errs() << "\n--- caller call-site expression:\n";
+      expr->dump();
+      llvm::errs() << "\n--- caller args (in order):\n";
+      for (size_t idx = 0; idx < arguments.size(); ++idx) {
+        llvm::errs() << "[arg " << idx << "]\n";
+        if (auto *aa = std::get<1>(arguments[idx]))
+          aa->dump();
+        else
+          llvm::errs() << " \n";
       }
+      llvm::errs() << "=== end diagnostic ===\n";
       assert(0 && "too many arguments in calls");
     }
     bool isReference =
@@ -177,7 +208,7 @@ ValueCategory MLIRScanner::CallHelper(
         if (auto prevTy = dyn_cast(val.getType())) {
           auto ipostTy = expectedType.cast();
           if (prevTy != ipostTy)
-            val = builder.create(loc, ipostTy, val);
+            val = castIntegerToWidth(loc, val, ipostTy, builder);
         }
       }
     } else {
@@ -556,6 +587,17 @@ MLIRScanner::EmitClangBuiltinCallExpr(clang::CallExpr *expr) {
     auto postTy = getMLIRType(expr->getType());
     return success(ValueCategory(res, /*isRef*/ false));
   }
+  case Builtin::BItanh:
+  case Builtin::BItanhf:
+  case Builtin::BItanhl:
+  case Builtin::BI__builtin_tanh:
+  case Builtin::BI__builtin_tanhf:
+  case Builtin::BI__builtin_tanhl: {
+    auto v = Visit(expr->getArg(0));
+    assert(!v.isReference);
+    Value res = builder.create(loc, v.val);
+    return success(ValueCategory(res, /*isRef*/ false));
+  }
   case Builtin::BI__builtin_clzs:
   case Builtin::BI__builtin_clz:
   case Builtin::BI__builtin_clzl:
diff --git a/tools/cgeist/Lib/CGStmt.cc b/tools/cgeist/Lib/CGStmt.cc
index 200f5a70739c..0361768f033a 100644
--- a/tools/cgeist/Lib/CGStmt.cc
+++ b/tools/cgeist/Lib/CGStmt.cc
@@ -19,6 +19,33 @@
 using namespace mlir;
 using namespace mlir::arith;
 
+static mlir::Value castIntegerToWidth(mlir::Location loc, mlir::Value value,
+                                      mlir::IntegerType dstTy,
+                                      mlir::OpBuilder &builder) {
+  auto srcTy = value.getType().cast();
+  if (srcTy == dstTy)
+    return value;
+  if (srcTy.getWidth() < dstTy.getWidth())
+    return builder.create(loc, dstTy, value);
+  return builder.create(loc, dstTy, value);
+}
+
+static bool compatibleMemRefCast(mlir::MemRefType srcTy,
+                                 mlir::MemRefType dstTy) {
+  if (srcTy.getElementType() != dstTy.getElementType() ||
+      srcTy.getMemorySpace() != dstTy.getMemorySpace() ||
+      srcTy.getRank() != dstTy.getRank())
+    return false;
+  for (int64_t i = 0; i < srcTy.getRank(); ++i) {
+    if (srcTy.getDimSize(i) == dstTy.getDimSize(i))
+      continue;
+    if (srcTy.isDynamicDim(i) || dstTy.isDynamicDim(i))
+      continue;
+    return false;
+  }
+  return true;
+}
+
 static bool isTerminator(Operation *op) {
   return op->mightHaveTrait();
 }
@@ -249,24 +276,7 @@ ValueCategory MLIRScanner::VisitForStmt(clang::ForStmt *fors) {
     if (auto *s = fors->getCond()) {
       auto condRes = Visit(s);
       auto cond = condRes.getValue(loc, builder);
-      if (auto mt = dyn_cast(cond.getType())) {
-        cond = builder.create(
-            loc,
-            LLVM::LLVMPointerType::get(mt.getElementType(),
-                                       mt.getMemorySpaceAsInt()),
-            cond);
-      }
-      if (auto LT = dyn_cast(cond.getType())) {
-        auto nullptr_llvm = builder.create(loc, LT);
-        cond = builder.create(
-            loc, mlir::LLVM::ICmpPredicate::ne, cond, nullptr_llvm);
-      }
-      auto ty = cond.getType().cast();
-      if (ty.getWidth() != 1) {
-        cond = builder.create(
-            loc, CmpIPredicate::ne, cond,
-            builder.create(loc, 0, ty));
-      }
+      cond = castScalarToBool(loc, cond);
       auto nb = builder.create(
           loc, lctx.noBreak, std::vector());
       cond = builder.create(loc, cond, nb);
@@ -342,17 +352,7 @@ ValueCategory MLIRScanner::VisitCXXForRangeStmt(clang::CXXForRangeStmt *fors) {
   if (auto *s = fors->getCond()) {
     auto condRes = Visit(s);
     auto cond = condRes.getValue(loc, builder);
-    if (auto LT = dyn_cast(cond.getType())) {
-      auto nullptr_llvm = builder.create(loc, LT);
-      cond = builder.create(
-          loc, mlir::LLVM::ICmpPredicate::ne, cond, nullptr_llvm);
-    }
-    auto ty = cond.getType().cast();
-    if (ty.getWidth() != 1) {
-      cond = builder.create(
-          loc, CmpIPredicate::ne, cond,
-          builder.create(loc, 0, ty));
-    }
+    cond = castScalarToBool(loc, cond);
     auto nb = builder.create(loc, lctx.noBreak,
                                                    std::vector());
     cond = builder.create(loc, cond, nb);
@@ -742,17 +742,7 @@ ValueCategory MLIRScanner::VisitDoStmt(clang::DoStmt *fors) {
   if (auto *s = fors->getCond()) {
     auto condRes = Visit(s);
     auto cond = condRes.getValue(loc, builder);
-    if (auto LT = dyn_cast(cond.getType())) {
-      auto nullptr_llvm = builder.create(loc, LT);
-      cond = builder.create(
-          loc, mlir::LLVM::ICmpPredicate::ne, cond, nullptr_llvm);
-    }
-    auto ty = cond.getType().cast();
-    if (ty.getWidth() != 1) {
-      cond = builder.create(
-          loc, CmpIPredicate::ne, cond,
-          builder.create(loc, 0, ty));
-    }
+    cond = castScalarToBool(loc, cond);
     auto nb = builder.create(loc, loops.back().noBreak,
                                                    std::vector());
     cond = builder.create(loc, cond, nb);
@@ -805,17 +795,7 @@ ValueCategory MLIRScanner::VisitWhileStmt(clang::WhileStmt *stmt) {
   if (auto *s = stmt->getCond()) {
     auto condRes = Visit(s);
     auto cond = condRes.getValue(loc, builder);
-    if (auto LT = dyn_cast(cond.getType())) {
-      auto nullptr_llvm = builder.create(loc, LT);
-      cond = builder.create(
-          loc, mlir::LLVM::ICmpPredicate::ne, cond, nullptr_llvm);
-    }
-    auto ty = cond.getType().cast();
-    if (ty.getWidth() != 1) {
-      cond = builder.create(
-          loc, CmpIPredicate::ne, cond,
-          builder.create(loc, 0, ty));
-    }
+    cond = castScalarToBool(loc, cond);
     auto nb = builder.create(loc, loops.back().noBreak,
                                                    std::vector());
     cond = builder.create(loc, cond, nb);
@@ -849,25 +829,7 @@ ValueCategory MLIRScanner::VisitIfStmt(clang::IfStmt *stmt) {
 
   auto oldpoint = builder.getInsertionPoint();
   auto *oldblock = builder.getInsertionBlock();
-  if (auto LT = dyn_cast(cond.getType())) {
-    cond = builder.create(
-        loc, LLVM::LLVMPointerType::get(builder.getI8Type()), cond);
-  }
-  if (auto LT = dyn_cast(cond.getType())) {
-    auto nullptr_llvm = builder.create(loc, LT);
-    cond = builder.create(
-        loc, mlir::LLVM::ICmpPredicate::ne, cond, nullptr_llvm);
-  }
-  if (!cond.getType().isa()) {
-    stmt->dump();
-    llvm::errs() << " cond: " << cond << " ct: " << cond.getType() << "\n";
-  }
-  auto prevTy = cond.getType().cast();
-  if (!prevTy.isInteger(1)) {
-    cond = builder.create(
-        loc, CmpIPredicate::ne, cond,
-        builder.create(loc, 0, prevTy));
-  }
+  cond = castScalarToBool(loc, cond);
   bool hasElseRegion = stmt->getElse();
   auto ifOp = builder.create(loc, cond, hasElseRegion);
 
@@ -1167,7 +1129,7 @@ ValueCategory MLIRScanner::VisitReturnStmt(clang::ReturnStmt *stmt) {
       if (auto prevTy = dyn_cast(val.getType())) {
         auto ipostTy = postTy.cast();
         if (prevTy != ipostTy) {
-          val = builder.create(loc, ipostTy, val);
+          val = castIntegerToWidth(loc, val, ipostTy, builder);
         }
       } else if (val.getType().isa() &&
                  postTy.isa())
@@ -1175,6 +1137,12 @@ ValueCategory MLIRScanner::VisitReturnStmt(clang::ReturnStmt *stmt) {
       else if (val.getType().isa() &&
                postTy.isa())
         val = builder.create(loc, postTy, val);
+      else if (auto valMemRefTy = dyn_cast(val.getType())) {
+        if (auto postMemRefTy = dyn_cast(postTy)) {
+          if (compatibleMemRefCast(valMemRefTy, postMemRefTy))
+            val = builder.create(loc, postTy, val);
+        }
+      }
       if (postTy != val.getType()) {
         stmt->dump();
         llvm::errs() << " val: " << val << " postTy: " << postTy
diff --git a/tools/cgeist/Lib/ValueCategory.cc b/tools/cgeist/Lib/ValueCategory.cc
index 3817a64ee14f..38f5348ac907 100644
--- a/tools/cgeist/Lib/ValueCategory.cc
+++ b/tools/cgeist/Lib/ValueCategory.cc
@@ -41,8 +41,17 @@ mlir::Value ValueCategory::getValue(mlir::Location loc,
     return builder.create(loc, val);
   }
   if (auto mt = dyn_cast(val.getType())) {
-    assert(mt.getShape().size() == 1 && "must have shape 1");
     auto c0 = builder.create(loc, 0);
+    if (mt.getShape().size() > 1) {
+      auto shape = std::vector(mt.getShape());
+      shape.erase(shape.begin());
+      auto mt0 =
+          mlir::MemRefType::get(shape, mt.getElementType(),
+                                mlir::MemRefLayoutAttrInterface(),
+                                mt.getMemorySpace());
+      return builder.create(loc, mt0, val, c0);
+    }
+    assert(mt.getShape().size() == 1 && "must have shape 1");
     return builder.create(loc, val,
                                           std::vector({c0}));
   }
@@ -85,6 +94,38 @@ void ValueCategory::store(mlir::Location loc, mlir::OpBuilder &builder,
     return;
   }
   if (auto mt = dyn_cast(val.getType())) {
+    if (auto smt = dyn_cast(toStore.getType());
+        smt && mt.getElementType() != toStore.getType()) {
+      auto target = val;
+      auto targetType = mt;
+      while (targetType.getShape().size() > smt.getShape().size()) {
+        auto c0 = builder.create(loc, 0);
+        auto shape = std::vector(targetType.getShape());
+        shape.erase(shape.begin());
+        targetType =
+            MemRefType::get(shape, targetType.getElementType(),
+                            MemRefLayoutAttrInterface(),
+                            targetType.getMemorySpace());
+        target =
+            builder.create(loc, targetType, target, c0);
+      }
+      ValueCategory(target, /*isReference*/ true)
+          .store(loc, builder, ValueCategory(toStore, /*isReference*/ false),
+                 /*isArray*/ true);
+      return;
+    }
+    if (mt.getShape().size() > 1) {
+      auto c0 = builder.create(loc, 0);
+      auto shape = std::vector(mt.getShape());
+      shape.erase(shape.begin());
+      auto mt0 =
+          MemRefType::get(shape, mt.getElementType(),
+                          MemRefLayoutAttrInterface(), mt.getMemorySpace());
+      ValueCategory(builder.create(loc, mt0, val, c0),
+                    /*isReference*/ true)
+          .store(loc, builder, toStore);
+      return;
+    }
     assert(mt.getShape().size() == 1 && "must have size 1");
     if (auto PT = dyn_cast(toStore.getType())) {
       if (auto MT = dyn_cast(
@@ -125,8 +166,10 @@ ValueCategory ValueCategory::dereference(mlir::Location loc,
     if (isReference) {
       if (shape.size() > 1) {
         shape.erase(shape.begin());
-        auto mt0 = mlir::MemRefType::get(shape, mt.getElementType(),
-                                         mt.getLayout(), mt.getMemorySpace());
+        auto mt0 =
+            mlir::MemRefType::get(shape, mt.getElementType(),
+                                  mlir::MemRefLayoutAttrInterface(),
+                                  mt.getMemorySpace());
         return ValueCategory(
             builder.create(loc, mt0, val, c0),
             /*isReference*/ true);
@@ -148,16 +191,40 @@ void ValueCategory::store(mlir::Location loc, mlir::OpBuilder &builder,
   assert(toStore.val);
   if (isArray) {
     if (!toStore.isReference) {
-      llvm::errs() << " toStore.val: " << toStore.val << " isref "
-                   << toStore.isReference << " isar" << isArray << "\n";
+      if (!toStore.val.getType().isa()) {
+        llvm::errs() << " toStore.val: " << toStore.val << " isref "
+                     << toStore.isReference << " isar" << isArray << "\n";
+        assert(toStore.isReference);
+      }
     }
-    assert(toStore.isReference);
     auto zeroIndex = builder.create(loc, 0);
 
     if (auto smt = dyn_cast(toStore.val.getType())) {
       assert(smt.getShape().size() <= 2);
 
       if (auto mt = dyn_cast(val.getType())) {
+        if (mt.getShape().size() == 1) {
+          if (auto pt = dyn_cast(mt.getElementType())) {
+            if (pt.getElementType() == smt.getElementType()) {
+              store(loc, builder,
+                    builder.create(
+                        loc, pt, toStore.val));
+              return;
+            }
+          }
+          if (auto targetMT = dyn_cast(mt.getElementType())) {
+            if (targetMT != smt) {
+              auto anyPT = LLVM::LLVMPointerType::get(builder.getI8Type());
+              auto ptr = builder.create(
+                  loc, anyPT, toStore.val);
+              store(loc, builder,
+                    builder.create(loc, targetMT,
+                                                                ptr));
+              return;
+            }
+          }
+        }
         assert(smt.getElementType() == mt.getElementType());
         if (mt.getShape().size() != smt.getShape().size()) {
           llvm::errs() << " val: " << val << " tsv: " << toStore.val << "\n";
diff --git a/tools/cgeist/Lib/clang-mlir.cc b/tools/cgeist/Lib/clang-mlir.cc
index 058464c323ef..d46b9edee7cc 100644
--- a/tools/cgeist/Lib/clang-mlir.cc
+++ b/tools/cgeist/Lib/clang-mlir.cc
@@ -195,11 +195,17 @@ bool isLLVMStructABI(const RecordDecl *RD, llvm::StructType *ST) {
     }
   }
   if (ST) {
-    if (!ST->isLiteral() && (ST->getName() == "struct._IO_FILE" ||
-                             ST->getName() == "class.std::basic_ifstream" ||
-                             ST->getName() == "class.std::basic_istream" ||
-                             ST->getName() == "class.std::basic_ostream" ||
-                             ST->getName() == "class.std::basic_ofstream"))
+    auto name = ST->getName();
+    if (name == "class.std::__cxx11::basic_string" ||
+        name == "class.std::basic_string" || name == "class.std::mutex" ||
+        name == "class.std::__mutex_base" ||
+        name.startswith("class.std::vector"))
+      return true;
+    if (!ST->isLiteral() && (name == "struct._IO_FILE" ||
+                             name == "class.std::basic_ifstream" ||
+                             name == "class.std::basic_istream" ||
+                             name == "class.std::basic_ostream" ||
+                             name == "class.std::basic_ofstream"))
       return true;
   }
   return false;
@@ -292,6 +298,23 @@ void MLIRScanner::init(mlir::func::FuncOp function, const FunctionDecl *fd) {
 
   if (auto CC = dyn_cast(fd)) {
     const CXXRecordDecl *ClassDecl = CC->getParent();
+    auto getConstructInit = [](Expr *init) -> CXXConstructExpr * {
+      while (true) {
+        if (auto clean = dyn_cast(init)) {
+          init = clean->getSubExpr();
+          continue;
+        }
+        if (auto bind = dyn_cast(init)) {
+          init = bind->getSubExpr();
+          continue;
+        }
+        if (auto mat = dyn_cast(init)) {
+          init = mat->getSubExpr();
+          continue;
+        }
+        return dyn_cast(init);
+      }
+    };
     for (auto expr : CC->inits()) {
       if (ShowAST) {
         llvm::errs() << " init: - baseInit:" << (int)expr->isBaseInitializer()
@@ -326,26 +349,23 @@ void MLIRScanner::init(mlir::func::FuncOp function, const FunctionDecl *fd) {
                                     BaseVirtual);
 
           Expr *init = expr->getInit();
-          if (auto clean = dyn_cast(init)) {
-            llvm::errs() << "TODO: cleanup\n";
-            init = clean->getSubExpr();
+          if (auto cons = getConstructInit(init)) {
+            VisitConstructCommon(cons, /*name*/ nullptr, /*space*/ 0,
+                                 /*mem*/ V);
+          } else {
+            Visit(init);
           }
-
-          VisitConstructCommon(cast(init),
-                               /*name*/ nullptr, /*space*/ 0, /*mem*/ V);
           continue;
         }
         if (expr->isDelegatingInitializer()) {
 
           Expr *init = expr->getInit();
-          if (auto clean = dyn_cast(init)) {
-            llvm::errs() << "TODO: cleanup\n";
-            init = clean->getSubExpr();
+          if (auto cons = getConstructInit(init)) {
+            VisitConstructCommon(cons, /*name*/ nullptr, /*space*/ 0,
+                                 /*mem*/ ThisVal.val);
+          } else {
+            Visit(init);
           }
-
-          VisitConstructCommon(cast(init),
-                               /*name*/ nullptr, /*space*/ 0,
-                               /*mem*/ ThisVal.val);
           continue;
         }
       }
@@ -533,15 +553,38 @@ mlir::Value MLIRScanner::createAllocOp(mlir::Type t, VarDecl *name,
     auto pshape = shape[0];
 
     if (name)
-      if (auto var = dyn_cast(
+      if (isa(
               name->getType()->getUnqualifiedDesugaredType())) {
         assert(shape[0] == ShapedType::kDynamic);
         mr = mlir::MemRefType::get(
             shape, mt.getElementType(), MemRefLayoutAttrInterface(),
             wrapIntegerMemorySpace(memspace, mt.getContext()));
-        auto len = Visit(var->getSizeExpr()).getValue(varLoc, builder);
-        len = builder.create(varLoc, builder.getIndexType(), len);
-        alloc = builder.create(varLoc, mr, len);
+        SmallVector dynamicSizes;
+        QualType arrayType = name->getType();
+        while (true) {
+          const clang::Type *desugared =
+              arrayType->getUnqualifiedDesugaredType();
+          if (auto varArray = dyn_cast(desugared)) {
+            auto len =
+                Visit(varArray->getSizeExpr()).getValue(varLoc, builder);
+            len = builder.create(varLoc, builder.getIndexType(),
+                                              len);
+            dynamicSizes.push_back(len);
+            arrayType = varArray->getElementType();
+            continue;
+          }
+          if (auto constantArray = dyn_cast(desugared)) {
+            arrayType = constantArray->getElementType();
+            continue;
+          }
+          if (auto incompleteArray = dyn_cast(desugared)) {
+            arrayType = incompleteArray->getElementType();
+            continue;
+          }
+          break;
+        }
+        alloc = builder.create(varLoc, mr,
+                                                       dynamicSizes);
         builder.create(varLoc, alloc);
         if (memspace != 0) {
           alloc = abuilder.create(
@@ -727,6 +770,14 @@ MLIRScanner::VisitCXXBoolLiteralExpr(clang::CXXBoolLiteralExpr *expr) {
       /*isReference*/ false);
 }
 
+ValueCategory
+MLIRScanner::VisitCXXNullPtrLiteralExpr(clang::CXXNullPtrLiteralExpr *expr) {
+  auto loc = getMLIRLocation(expr->getExprLoc());
+  auto ty = getMLIRType(expr->getType()).cast();
+  return ValueCategory(builder.create(loc, ty),
+                       /*isReference*/ false);
+}
+
 ValueCategory MLIRScanner::VisitStringLiteral(clang::StringLiteral *expr) {
   auto loc = getMLIRLocation(expr->getExprLoc());
   return ValueCategory(
@@ -1092,6 +1143,11 @@ ValueCategory MLIRScanner::VisitPredefinedExpr(clang::PredefinedExpr *expr) {
   return VisitStringLiteral(expr->getFunctionName());
 }
 
+ValueCategory
+MLIRScanner::VisitCompoundLiteralExpr(clang::CompoundLiteralExpr *expr) {
+  return Visit(expr->getInitializer());
+}
+
 ValueCategory MLIRScanner::VisitInitListExpr(clang::InitListExpr *expr) {
   mlir::Type subType = getMLIRType(expr->getType());
   bool isArray = false;
@@ -1499,6 +1555,37 @@ mlir::Value MLIRScanner::castToIndex(mlir::Location loc, mlir::Value val) {
       loc, mlir::IndexType::get(val.getContext()), val);
 }
 
+mlir::Value MLIRScanner::castScalarToBool(mlir::Location loc,
+                                          mlir::Value val) {
+  assert(val && "Expect non-null value");
+
+  if (auto mt = dyn_cast(val.getType())) {
+    val = builder.create(
+        loc,
+        LLVM::LLVMPointerType::get(mt.getElementType(),
+                                   mt.getMemorySpaceAsInt()),
+        val);
+  }
+  if (auto LT = dyn_cast(val.getType())) {
+    auto nullptr_llvm = builder.create(loc, LT);
+    return builder.create(
+        loc, mlir::LLVM::ICmpPredicate::ne, val, nullptr_llvm);
+  }
+  if (auto FT = dyn_cast(val.getType())) {
+    return builder.create(
+        loc, CmpFPredicate::UNE, val,
+        builder.create(
+            loc, APFloat(FT.getFloatSemantics(), "0"), FT));
+  }
+
+  auto ty = val.getType().cast();
+  if (ty.getWidth() == 1)
+    return val;
+  return builder.create(
+      loc, CmpIPredicate::ne, val,
+      builder.create(loc, 0, ty));
+}
+
 ValueCategory
 MLIRScanner::VisitCXXScalarValueInitExpr(clang::CXXScalarValueInitExpr *expr) {
   auto loc = getMLIRLocation(expr->getExprLoc());
@@ -1836,6 +1923,18 @@ MLIRScanner::EmitBuiltinOps(clang::CallExpr *expr) {
                           /*isReference*/ false),
             true);
       }
+      if (sr->getDecl()->getIdentifier() &&
+          (sr->getDecl()->getName() == "tanhf" ||
+           sr->getDecl()->getName() == "tanh")) {
+        std::vector args;
+        for (auto a : expr->arguments()) {
+          args.push_back(Visit(a).getValue(loc, builder));
+        }
+        return make_pair(
+            ValueCategory(builder.create(loc, args[0]),
+                          /*isReference*/ false),
+            true);
+      }
       if (sr->getDecl()->getIdentifier() && sr->getDecl()->getName() == "sin") {
         std::vector args;
         for (auto a : expr->arguments()) {
@@ -2133,34 +2232,9 @@ ValueCategory MLIRScanner::VisitUnaryOperator(clang::UnaryOperator *U) {
     assert(sub.val);
     mlir::Value val = sub.getValue(loc, builder);
 
-    if (auto MT = dyn_cast(val.getType())) {
-      val = builder.create(
-          loc,
-          LLVM::LLVMPointerType::get(MT.getElementType(),
-                                     MT.getMemorySpaceAsInt()),
-          val);
-    }
     auto postTy = getMLIRType(U->getType()).cast();
 
-    if (auto LT = dyn_cast(val.getType())) {
-      auto nullptr_llvm = builder.create(loc, LT);
-      mlir::Value ne = builder.create(
-          loc, mlir::LLVM::ICmpPredicate::eq, val, nullptr_llvm);
-      if (postTy.getWidth() > 1)
-        ne = builder.create(loc, postTy, ne);
-      return ValueCategory(ne, /*isReference*/ false);
-    }
-
-    if (!val.getType().isa()) {
-      U->dump();
-      val.dump();
-    }
-    auto ty = val.getType().cast();
-    if (ty.getWidth() != 1) {
-      val = builder.create(
-          loc, CmpIPredicate::ne, val,
-          builder.create(loc, 0, ty));
-    }
+    val = castScalarToBool(loc, val);
     auto c1 = builder.create(loc, 1, val.getType());
     mlir::Value res = builder.create(loc, val, c1);
 
@@ -2357,7 +2431,8 @@ MLIRScanner::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Uop) {
     return ValueCategory(builder.create(loc, retTy, value),
                          /*isReference*/ false);
   }
-  case UETT_AlignOf: {
+  case UETT_AlignOf:
+  case UETT_PreferredAlignOf: {
     auto value = getTypeAlign(loc, Uop->getTypeOfArgument());
     auto retTy = getMLIRType(Uop->getType()).cast();
     return ValueCategory(builder.create(loc, retTy, value),
@@ -2454,6 +2529,7 @@ ValueCategory MLIRScanner::VisitAtomicExpr(clang::AtomicExpr *BO) {
   auto loc = getMLIRLocation(BO->getExprLoc());
 
   switch (BO->getOp()) {
+  case AtomicExpr::AtomicOp::AO__atomic_fetch_add:
   case AtomicExpr::AtomicOp::AO__atomic_add_fetch: {
     auto a0 = Visit(BO->getPtr()).getValue(loc, builder);
     auto a1 = Visit(BO->getVal1()).getValue(loc, builder);
@@ -2476,6 +2552,9 @@ ValueCategory MLIRScanner::VisitAtomicExpr(clang::AtomicExpr *BO) {
       v = builder.create(loc, lop, a0, a1,
                                             LLVM::AtomicOrdering::acq_rel);
 
+    if (BO->getOp() == AtomicExpr::AtomicOp::AO__atomic_fetch_add)
+      return ValueCategory(v, false);
+
     if (ty.isa())
       v = builder.create(loc, v, a1);
     else
@@ -2593,29 +2672,7 @@ ValueCategory MLIRScanner::VisitBinaryOperator(clang::BinaryOperator *BO) {
   case clang::BinaryOperator::Opcode::BO_LAnd: {
     mlir::Type types[] = {builder.getIntegerType(1)};
     auto cond = lhs.getValue(loc, builder);
-    if (auto mt = dyn_cast(cond.getType())) {
-      cond = builder.create(
-          loc,
-          LLVM::LLVMPointerType::get(mt.getElementType(),
-                                     mt.getMemorySpaceAsInt()),
-          cond);
-    }
-    if (auto LT = dyn_cast(cond.getType())) {
-      auto nullptr_llvm = builder.create(loc, LT);
-      cond = builder.create(
-          loc, mlir::LLVM::ICmpPredicate::ne, cond, nullptr_llvm);
-    }
-    if (!cond.getType().isa()) {
-      BO->dump();
-      BO->getType()->dump();
-      llvm::errs() << "cond: " << cond << "\n";
-    }
-    auto prevTy = cond.getType().cast();
-    if (!prevTy.isInteger(1)) {
-      cond = builder.create(
-          loc, CmpIPredicate::ne, cond,
-          builder.create(loc, 0, prevTy));
-    }
+    cond = castScalarToBool(loc, cond);
     auto ifOp = builder.create(loc, types, cond,
                                                 /*hasElseRegion*/ true);
 
@@ -2625,16 +2682,7 @@ ValueCategory MLIRScanner::VisitBinaryOperator(clang::BinaryOperator *BO) {
 
     auto rhs = Visit(BO->getRHS()).getValue(loc, builder);
     assert(rhs != nullptr);
-    if (auto LT = dyn_cast(rhs.getType())) {
-      auto nullptr_llvm = builder.create(loc, LT);
-      rhs = builder.create(
-          loc, mlir::LLVM::ICmpPredicate::ne, rhs, nullptr_llvm);
-    }
-    if (!rhs.getType().cast().isInteger(1)) {
-      rhs = builder.create(
-          loc, CmpIPredicate::ne, rhs,
-          builder.create(loc, 0, rhs.getType()));
-    }
+    rhs = castScalarToBool(loc, rhs);
     mlir::Value truearray[] = {rhs};
     builder.create(loc, truearray);
 
@@ -2649,12 +2697,7 @@ ValueCategory MLIRScanner::VisitBinaryOperator(clang::BinaryOperator *BO) {
   case clang::BinaryOperator::Opcode::BO_LOr: {
     mlir::Type types[] = {builder.getIntegerType(1)};
     auto cond = lhs.getValue(loc, builder);
-    auto prevTy = cond.getType().cast();
-    if (!prevTy.isInteger(1)) {
-      cond = builder.create(
-          loc, CmpIPredicate::ne, cond,
-          builder.create(loc, 0, prevTy));
-    }
+    cond = castScalarToBool(loc, cond);
     auto ifOp = builder.create(loc, types, cond,
                                                 /*hasElseRegion*/ true);
 
@@ -2667,12 +2710,8 @@ ValueCategory MLIRScanner::VisitBinaryOperator(clang::BinaryOperator *BO) {
 
     builder.setInsertionPointToStart(&ifOp.getElseRegion().back());
     auto rhs = Visit(BO->getRHS()).getValue(loc, builder);
-    if (!rhs.getType().cast().isInteger(1)) {
-      rhs = builder.create(
-          loc, CmpIPredicate::ne, rhs,
-          builder.create(loc, 0, rhs.getType()));
-    }
     assert(rhs != nullptr);
+    rhs = castScalarToBool(loc, rhs);
     mlir::Value falsearray[] = {rhs};
     builder.create(loc, falsearray);
 
@@ -2696,6 +2735,26 @@ ValueCategory MLIRScanner::VisitBinaryOperator(clang::BinaryOperator *BO) {
     if (bit->isSignedInteger())
       signedType = true;
   }
+  auto castIntegerToType = [&](mlir::Value value,
+                               mlir::IntegerType postTy) -> mlir::Value {
+    auto prevTy = value.getType().cast();
+    if (prevTy == postTy)
+      return value;
+    if (prevTy.getWidth() < postTy.getWidth()) {
+      if (signedType)
+        return builder.create(loc, postTy, value);
+      return builder.create(loc, postTy, value);
+    }
+    return builder.create(loc, postTy, value);
+  };
+  auto negateIntegerOrIndex = [&](mlir::Value value) -> mlir::Value {
+    if (value.getType().isa())
+      return builder.create(loc, getConstantIndex(0), value);
+    auto ty = value.getType().cast();
+    return builder.create(loc,
+                                  builder.create(loc, 0, ty),
+                                  value);
+  };
   switch (BO->getOpcode()) {
   case clang::BinaryOperator::Opcode::BO_Shr: {
     auto lhsv = lhs.getValue(loc, builder);
@@ -3115,8 +3174,26 @@ ValueCategory MLIRScanner::VisitBinaryOperator(clang::BinaryOperator *BO) {
       }
       assert(right.getType() == prev.getType());
       result = builder.create(loc, prev, right);
+    } else if (auto pt =
+                   dyn_cast(prev.getType())) {
+      auto right = negateIntegerOrIndex(rhs.getValue(loc, builder));
+      result = builder.create(
+          loc, pt, prev, std::vector({right}));
+    } else if (auto memrefTy = dyn_cast(prev.getType())) {
+      mlir::Value right = castToIndex(loc, rhs.getValue(loc, builder));
+      right = negateIntegerOrIndex(right);
+      auto shape = std::vector(memrefTy.getShape());
+      shape[0] = ShapedType::kDynamic;
+      memrefTy = mlir::MemRefType::get(shape, memrefTy.getElementType(),
+                                       MemRefLayoutAttrInterface(),
+                                       memrefTy.getMemorySpace());
+      result =
+          builder.create(loc, memrefTy, prev, right);
     } else {
-      result = builder.create(loc, prev, rhs.getValue(loc, builder));
+      auto right = rhs.getValue(loc, builder);
+      auto postTy = prev.getType().cast();
+      right = castIntegerToType(right, postTy);
+      result = builder.create(loc, prev, right);
     }
     lhs.store(loc, builder, result);
     return lhs;
@@ -3148,7 +3225,10 @@ ValueCategory MLIRScanner::VisitBinaryOperator(clang::BinaryOperator *BO) {
       assert(right.getType() == prev.getType());
       result = builder.create(loc, prev, right);
     } else {
-      result = builder.create(loc, prev, rhs.getValue(loc, builder));
+      auto right = rhs.getValue(loc, builder);
+      auto postTy = prev.getType().cast();
+      right = castIntegerToType(right, postTy);
+      result = builder.create(loc, prev, right);
     }
     lhs.store(loc, builder, result);
     return lhs;
@@ -3173,12 +3253,13 @@ ValueCategory MLIRScanner::VisitBinaryOperator(clang::BinaryOperator *BO) {
       }
       result = builder.create(loc, prev, val);
     } else {
+      auto right = rhs.getValue(loc, builder);
+      auto postTy = prev.getType().cast();
+      right = castIntegerToType(right, postTy);
       if (signedType)
-        result = builder.create(loc, prev,
-                                                rhs.getValue(loc, builder));
+        result = builder.create(loc, prev, right);
       else
-        result = builder.create(loc, prev,
-                                                rhs.getValue(loc, builder));
+        result = builder.create(loc, prev, right);
     }
     lhs.store(loc, builder, result);
     return lhs;
@@ -3190,12 +3271,8 @@ ValueCategory MLIRScanner::VisitBinaryOperator(clang::BinaryOperator *BO) {
 
     mlir::Value result;
 
-    auto prevTy = rhsv.getType().cast();
     auto postTy = lhsv.getType().cast();
-    if (prevTy.getWidth() < postTy.getWidth())
-      rhsv = builder.create(loc, postTy, rhsv);
-    if (prevTy.getWidth() > postTy.getWidth())
-      rhsv = builder.create(loc, postTy, rhsv);
+    rhsv = castIntegerToType(rhsv, postTy);
     assert(lhsv.getType() == rhsv.getType());
 
     if (signedType)
@@ -3208,9 +3285,11 @@ ValueCategory MLIRScanner::VisitBinaryOperator(clang::BinaryOperator *BO) {
   case clang::BinaryOperator::Opcode::BO_ShlAssign: {
     assert(lhs.isReference);
     auto prev = lhs.getValue(loc, builder);
+    auto right = rhs.getValue(loc, builder);
+    auto postTy = prev.getType().cast();
+    right = castIntegerToType(right, postTy);
 
-    mlir::Value result =
-        builder.create(loc, prev, rhs.getValue(loc, builder));
+    mlir::Value result = builder.create(loc, prev, right);
     lhs.store(loc, builder, result);
     return lhs;
   }
@@ -3223,10 +3302,13 @@ ValueCategory MLIRScanner::VisitBinaryOperator(clang::BinaryOperator *BO) {
     if (prev.getType().isa()) {
       result = builder.create(loc, prev, rhs.getValue(loc, builder));
     } else {
+      auto right = rhs.getValue(loc, builder);
+      auto postTy = prev.getType().cast();
+      right = castIntegerToType(right, postTy);
       if (signedType)
-        result = builder.create(loc, prev, rhs.getValue(loc, builder));
+        result = builder.create(loc, prev, right);
       else
-        result = builder.create(loc, prev, rhs.getValue(loc, builder));
+        result = builder.create(loc, prev, right);
     }
     lhs.store(loc, builder, result);
     return lhs;
@@ -3234,27 +3316,33 @@ ValueCategory MLIRScanner::VisitBinaryOperator(clang::BinaryOperator *BO) {
   case clang::BinaryOperator::Opcode::BO_AndAssign: {
     assert(lhs.isReference);
     auto prev = lhs.getValue(loc, builder);
+    auto right = rhs.getValue(loc, builder);
+    auto postTy = prev.getType().cast();
+    right = castIntegerToType(right, postTy);
 
-    mlir::Value result =
-        builder.create(loc, prev, rhs.getValue(loc, builder));
+    mlir::Value result = builder.create(loc, prev, right);
     lhs.store(loc, builder, result);
     return lhs;
   }
   case clang::BinaryOperator::Opcode::BO_OrAssign: {
     assert(lhs.isReference);
     auto prev = lhs.getValue(loc, builder);
+    auto right = rhs.getValue(loc, builder);
+    auto postTy = prev.getType().cast();
+    right = castIntegerToType(right, postTy);
 
-    mlir::Value result =
-        builder.create(loc, prev, rhs.getValue(loc, builder));
+    mlir::Value result = builder.create(loc, prev, right);
     lhs.store(loc, builder, result);
     return lhs;
   }
   case clang::BinaryOperator::Opcode::BO_XorAssign: {
     assert(lhs.isReference);
     auto prev = lhs.getValue(loc, builder);
+    auto right = rhs.getValue(loc, builder);
+    auto postTy = prev.getType().cast();
+    right = castIntegerToType(right, postTy);
 
-    mlir::Value result =
-        builder.create(loc, prev, rhs.getValue(loc, builder));
+    mlir::Value result = builder.create(loc, prev, right);
     lhs.store(loc, builder, result);
     return lhs;
   }
@@ -4358,10 +4446,7 @@ ValueCategory MLIRScanner::VisitCastExpr(CastExpr *E) {
   }
   case clang::CastKind::CK_IntegralToBoolean: {
     auto res = Visit(E->getSubExpr()).getValue(loc, builder);
-    auto prevTy = res.getType().cast();
-    res = builder.create(
-        loc, CmpIPredicate::ne, res,
-        builder.create(loc, 0, prevTy));
+    res = castScalarToBool(loc, res);
     auto postTy = getMLIRType(E->getType()).cast();
     bool signedType = true;
     if (auto bit = dyn_cast(&*E->getType())) {
@@ -4381,7 +4466,6 @@ ValueCategory MLIRScanner::VisitCastExpr(CastExpr *E) {
   }
   case clang::CastKind::CK_FloatingToBoolean: {
     auto res = Visit(E->getSubExpr()).getValue(loc, builder);
-    auto prevTy = res.getType().cast();
     auto postTy = getMLIRType(E->getType()).cast();
     bool signedType = true;
     if (auto bit = dyn_cast(&*E->getType())) {
@@ -4390,9 +4474,7 @@ ValueCategory MLIRScanner::VisitCastExpr(CastExpr *E) {
       if (bit->isSignedInteger())
         signedType = true;
     }
-    auto Zero = builder.create(
-        loc, APFloat::getZero(prevTy.getFloatSemantics()), prevTy);
-    res = builder.create(loc, CmpFPredicate::UNE, res, Zero);
+    res = castScalarToBool(loc, res);
     if (1 < postTy.getWidth()) {
       if (signedType) {
         res = builder.create(loc, postTy, res);
@@ -4468,15 +4550,13 @@ MLIRScanner::VisitConditionalOperator(clang::ConditionalOperator *E) {
     cond = builder.create(
         loc, mlir::LLVM::ICmpPredicate::ne, cond, nullptr_llvm);
   }
-  auto prevTy = cond.getType().cast();
-  if (!prevTy.isInteger(1)) {
-    cond = builder.create(
-        loc, CmpIPredicate::ne, cond,
-        builder.create(loc, 0, prevTy));
-  }
+  cond = castScalarToBool(loc, cond);
   std::vector types;
-  if (!E->getType()->isVoidType())
-    types.push_back(getMLIRType(E->getType()));
+  mlir::Type resultType;
+  if (!E->getType()->isVoidType()) {
+    resultType = getMLIRType(E->getType());
+    types.push_back(resultType);
+  }
   auto ifOp = builder.create(loc, types, cond,
                                               /*hasElseRegion*/ true);
 
@@ -4490,8 +4570,7 @@ MLIRScanner::VisitConditionalOperator(clang::ConditionalOperator *E) {
 
   auto falseExpr = Visit(E->getFalseExpr());
 
-  bool isReference = E->isLValue() || E->isXValue() ||
-                     (trueExpr.isReference && falseExpr.isReference);
+  bool isReference = E->isLValue() || E->isXValue();
 
   builder.setInsertionPointToEnd(&ifOp.getThenRegion().back());
 
@@ -4517,6 +4596,16 @@ MLIRScanner::VisitConditionalOperator(clang::ConditionalOperator *E) {
       truev = trueExpr.getValue(loc, builder);
     }
     assert(truev != nullptr);
+    if (!isReference && resultType && truev.getType() != resultType) {
+      if (truev.getType().isa() &&
+          resultType.isa())
+        truev = builder.create(loc, resultType,
+                                                            truev);
+      else if (truev.getType().isa() &&
+               resultType.isa())
+        truev = builder.create(loc, resultType,
+                                                            truev);
+    }
     truearray.push_back(truev);
     builder.create(loc, truearray);
   }
@@ -4532,14 +4621,36 @@ MLIRScanner::VisitConditionalOperator(clang::ConditionalOperator *E) {
     } else
       falsev = falseExpr.getValue(loc, builder);
     assert(falsev != nullptr);
+    if (isReference && !truearray.empty() &&
+        falsev.getType() != truearray[0].getType()) {
+      auto trueTy = truearray[0].getType();
+      if (falsev.getType().isa() &&
+          trueTy.isa())
+        falsev = builder.create(loc, trueTy,
+                                                             falsev);
+      else if (falsev.getType().isa() &&
+               trueTy.isa())
+        falsev = builder.create(loc, trueTy,
+                                                             falsev);
+    } else if (!isReference && resultType && falsev.getType() != resultType) {
+      if (falsev.getType().isa() &&
+          resultType.isa())
+        falsev = builder.create(loc, resultType,
+                                                             falsev);
+      else if (falsev.getType().isa() &&
+               resultType.isa())
+        falsev = builder.create(loc, resultType,
+                                                             falsev);
+    }
     falsearray.push_back(falsev);
     builder.create(loc, falsearray);
   }
 
   builder.setInsertionPoint(oldblock, oldpoint);
 
-  for (size_t i = 0; i < truearray.size(); i++)
-    types[i] = truearray[i].getType();
+  if (isReference)
+    for (size_t i = 0; i < truearray.size(); i++)
+      types[i] = truearray[i].getType();
   auto newIfOp = builder.create(loc, types, cond,
                                                  /*hasElseRegion*/ true);
   newIfOp.getThenRegion().takeBody(ifOp.getThenRegion());
@@ -4691,6 +4802,8 @@ MLIRASTConsumer::GetOrCreateLLVMFunction(const FunctionDecl *FD) {
     lnk = LLVM::Linkage::Private;
     break;
   }
+  if (lnk != LLVM::Linkage::ExternWeak)
+    lnk = LLVM::Linkage::External;
   // Insert the function into the body of the parent module.
   mlir::OpBuilder builder(module->getContext());
   builder.setInsertionPointToStart(module->getBody());
@@ -4954,14 +5067,41 @@ MLIRASTConsumer::GetOrCreateGlobal(const ValueDecl *FD, std::string prefix,
           initial_value = A;
         }
       } else {
-        auto VC = ms.Visit(const_cast(init));
-        if (!VC.isReference) {
-          if (auto cop = VC.val.getDefiningOp()) {
-            initial_value = cop.getValue();
-            initial_value = SplatElementsAttr::get(
-                RankedTensorType::get(mr.getShape(), mr.getElementType()),
-                initial_value);
-            initialized = true;
+        clang::Expr::EvalResult evalResult;
+        if (init->EvaluateAsInt(evalResult, CGM.getContext())) {
+          auto intValue = evalResult.Val.getInt();
+          initial_value = builder.getIntegerAttr(mr.getElementType(), intValue);
+          initial_value = SplatElementsAttr::get(
+              RankedTensorType::get(mr.getShape(), mr.getElementType()),
+              initial_value);
+          initialized = true;
+        } else {
+          auto VC = ms.Visit(const_cast(init));
+          if (!VC.isReference) {
+            if (VC.val)
+              if (auto cop = VC.val.getDefiningOp()) {
+                initial_value = cop.getValue();
+                initial_value = SplatElementsAttr::get(
+                    RankedTensorType::get(mr.getShape(), mr.getElementType()),
+                    initial_value);
+                initialized = true;
+              }
+            if (VC.val)
+              if (auto castOp = VC.val.getDefiningOp())
+                if (auto cop =
+                        castOp.getIn().getDefiningOp()) {
+                  initial_value =
+                      builder.getIntegerAttr(mr.getElementType(), cop.value());
+                  initial_value = SplatElementsAttr::get(
+                      RankedTensorType::get(mr.getShape(), mr.getElementType()),
+                      initial_value);
+                  initialized = true;
+                }
+          }
+          if (!initialized && !VC.val) {
+            init->dump();
+            llvm::errs() << " warning null global initializer value: " << name
+                         << "\n";
           }
         }
       }
@@ -5182,6 +5322,14 @@ MLIRASTConsumer::GetOrCreateMLIRFunction(const FunctionDecl *FD,
   mlir::func::FuncOp function = mlir::func::FuncOp(mlir::func::FuncOp::create(
       getMLIRLocation(FD->getLocation()), name, funcType));
 
+  // Preserve Clang's proof that a function does not read or write program
+  // memory.  Generic func.call operations otherwise carry unknown effects in
+  // MLIR and prevent safe loop-to-Linalg raising of scalar helper functions.
+  // `const` is stronger than `pure`; both are sufficient for the memory
+  // dependence analysis performed by RaiseToLinalg.
+  if (FD->hasAttr() || FD->hasAttr())
+    function->setAttr("polygeist.pure", builder.getUnitAttr());
+
   if ((FD->hasAttr() || FD->hasAttr()) &&
       !FD->hasAttr()) {
     function->setAttr("polygeist.device_only_func",
@@ -5274,16 +5422,9 @@ void MLIRASTConsumer::HandleDeclContext(DeclContext *DC) {
     if (fd->isTemplated()) {
       continue;
     }
-
-    bool externLinkage = true;
-    /*
-    auto LV = CGM.getFunctionLinkage(fd);
-    if (LV == llvm::GlobalValue::InternalLinkage || LV ==
-    llvm::GlobalValue::PrivateLinkage) externLinkage = false; if
-    (fd->isInlineSpecified()) externLinkage = false;
-    */
-    if (!CGM.getContext().DeclMustBeEmitted(fd))
-      externLinkage = false;
+    if (fd->isVariadic()) {
+      continue;
+    }
 
     std::string name;
     if (auto CC = dyn_cast(fd))
@@ -5307,8 +5448,8 @@ void MLIRASTConsumer::HandleDeclContext(DeclContext *DC) {
     if (name == "cudaGetDevice" || name == "cudaMalloc")
       continue;
 
-    if ((emitIfFound.count("*") && name != "fpclassify" && !fd->isStatic() &&
-         externLinkage) ||
+    if ((emitIfFound.count("*") && name != "fpclassify" &&
+         SM.isWrittenInMainFile(fd->getLocation())) ||
         emitIfFound.count(name)) {
       functionsToEmit.push_back(fd);
     } else {
@@ -5349,16 +5490,9 @@ bool MLIRASTConsumer::HandleTopLevelDecl(DeclGroupRef dg) {
     if (fd->isTemplated()) {
       continue;
     }
-
-    bool externLinkage = true;
-    /*
-    auto LV = CGM.getFunctionLinkage(fd);
-    if (LV == llvm::GlobalValue::InternalLinkage || LV ==
-    llvm::GlobalValue::PrivateLinkage) externLinkage = false; if
-    (fd->isInlineSpecified()) externLinkage = false;
-    */
-    if (!CGM.getContext().DeclMustBeEmitted(fd))
-      externLinkage = false;
+    if (fd->isVariadic()) {
+      continue;
+    }
 
     std::string name;
     if (auto CC = dyn_cast(fd))
@@ -5382,8 +5516,8 @@ bool MLIRASTConsumer::HandleTopLevelDecl(DeclGroupRef dg) {
     if (name == "cudaGetDevice" || name == "cudaMalloc")
       continue;
 
-    if ((emitIfFound.count("*") && name != "fpclassify" && !fd->isStatic() &&
-         externLinkage) ||
+    if ((emitIfFound.count("*") && name != "fpclassify" &&
+         SM.isWrittenInMainFile(fd->getLocation())) ||
         emitIfFound.count(name)) {
       functionsToEmit.push_back(fd);
     } else {
@@ -5433,12 +5567,31 @@ isRecursiveStructImpl(const clang::Type *t,
   } else if (auto RT = dyn_cast(t)) {
     return isRecursiveStructImpl(
         RT->getPointeeType()->getUnqualifiedDesugaredType(), seen);
+  } else if (auto AT = dyn_cast(t)) {
+    return isRecursiveStructImpl(
+        AT->getElementType()->getUnqualifiedDesugaredType(), seen);
+  } else if (auto FT = dyn_cast(t)) {
+    if (isRecursiveStructImpl(
+            FT->getReturnType()->getUnqualifiedDesugaredType(), seen))
+      return true;
+    for (auto paramTy : FT->param_types()) {
+      if (isRecursiveStructImpl(paramTy->getUnqualifiedDesugaredType(), seen))
+        return true;
+    }
+    return false;
+  } else if (auto FT = dyn_cast(t)) {
+    return isRecursiveStructImpl(
+        FT->getReturnType()->getUnqualifiedDesugaredType(), seen);
   } else if (auto RT = dyn_cast(t)) {
     if (seen.count(RT))
       return true;
     seen.insert(RT);
 
-    auto CXRD = dyn_cast(RT->getDecl());
+    auto *RD = RT->getDecl()->getDefinition();
+    if (!RD)
+      return false;
+
+    auto CXRD = dyn_cast(RD);
     if (CXRD) {
       for (auto f : CXRD->bases()) {
         auto baseTy = f.getType()->getUnqualifiedDesugaredType();
@@ -5447,7 +5600,7 @@ isRecursiveStructImpl(const clang::Type *t,
       }
     }
 
-    for (auto f : RT->getDecl()->fields()) {
+    for (auto f : RD->fields()) {
       auto fieldTy = f->getType()->getUnqualifiedDesugaredType();
       if (isRecursiveStructImpl(fieldTy, seen))
         return true;
@@ -5602,9 +5755,16 @@ mlir::Type MLIRASTConsumer::getMLIRType(clang::QualType qt, bool *implicitRef,
       types.push_back(ty);
     }
 
-    if (types.empty())
-      if (ST->getNumElements() == 1 && ST->getElementType(0U)->isIntegerTy(8))
+    for (size_t i = 1; i < types.size(); ++i) {
+      if (types[i] != types[0])
+        notAllSame = true;
+    }
+
+    if (types.empty()) {
+      if (ST->isOpaque() ||
+          (ST->getNumElements() == 1 && ST->getElementType(0U)->isIntegerTy(8)))
         return typeTranslator.translateType(anonymize(ST));
+    }
 
     if (recursive) {
       auto LR = typeCache[RT].setBody(types, /*isPacked*/ false);
@@ -5802,6 +5962,10 @@ mlir::Type MLIRASTConsumer::getMLIRType(clang::QualType qt, bool *implicitRef,
   }
 
   if (t->isBuiltinType() || isa(t)) {
+    if (auto BT = dyn_cast(t)) {
+      if (BT->getKind() == clang::BuiltinType::NullPtr)
+        return LLVM::LLVMPointerType::get(module->getContext());
+    }
     if (t->isBooleanType()) {
       OpBuilder builder(module->getContext());
       return builder.getIntegerType(8);
diff --git a/tools/cgeist/Lib/clang-mlir.h b/tools/cgeist/Lib/clang-mlir.h
index 117bcf162557..31a5c43ff676 100644
--- a/tools/cgeist/Lib/clang-mlir.h
+++ b/tools/cgeist/Lib/clang-mlir.h
@@ -195,6 +195,8 @@ class MLIRScanner : public StmtVisitor {
 
   mlir::Value castToIndex(mlir::Location loc, mlir::Value val);
 
+  mlir::Value castScalarToBool(mlir::Location loc, mlir::Value val);
+
   mlir::Value getLLVM(Expr *E, bool isRef = false);
 
   bool isTrivialAffineLoop(clang::ForStmt *fors,
@@ -270,6 +272,8 @@ class MLIRScanner : public StmtVisitor {
 
   ValueCategory VisitCXXBoolLiteralExpr(clang::CXXBoolLiteralExpr *expr);
 
+  ValueCategory VisitCXXNullPtrLiteralExpr(clang::CXXNullPtrLiteralExpr *expr);
+
   ValueCategory VisitCXXTypeidExpr(clang::CXXTypeidExpr *expr);
 
   ValueCategory VisitCXXTryStmt(clang::CXXTryStmt *stmt);
@@ -408,6 +412,7 @@ class MLIRScanner : public StmtVisitor {
 
   mlir::Attribute InitializeValueByInitListExpr(mlir::Value toInit,
                                                 clang::Expr *expr);
+  ValueCategory VisitCompoundLiteralExpr(clang::CompoundLiteralExpr *expr);
   ValueCategory VisitInitListExpr(clang::InitListExpr *expr);
   ValueCategory
   VisitCXXStdInitializerListExpr(clang::CXXStdInitializerListExpr *expr);
diff --git a/tools/cgeist/Test/pure_function_attr.c b/tools/cgeist/Test/pure_function_attr.c
new file mode 100644
index 000000000000..6f09c4373da2
--- /dev/null
+++ b/tools/cgeist/Test/pure_function_attr.c
@@ -0,0 +1,13 @@
+// RUN: cgeist %s --function=apply -S | FileCheck %s
+
+__attribute__((const)) float special_const(float);
+__attribute__((pure)) float special_pure(float);
+
+void apply(float *input, float *output) {
+  output[0] = special_const(input[0]) + special_pure(input[1]);
+}
+
+// CHECK: func.func private @special_const(f32) -> f32
+// CHECK-SAME: polygeist.pure
+// CHECK: func.func private @special_pure(f32) -> f32
+// CHECK-SAME: polygeist.pure
diff --git a/tools/cgeist/driver.cc b/tools/cgeist/driver.cc
index 45c92f80bff5..43c93f75acd2 100644
--- a/tools/cgeist/driver.cc
+++ b/tools/cgeist/driver.cc
@@ -168,6 +168,12 @@ static cl::opt RaiseToAffine("raise-scf-to-affine", cl::init(false),
 static cl::opt ScalarReplacement("scal-rep", cl::init(true),
                                        cl::desc("Raise SCF to Affine"));
 
+static cl::opt NoInline("no-inline", cl::init(false),
+                              cl::desc("Skip the MLIR inliner pass — keeps "
+                                       "cross-function call boundaries intact "
+                                       "(useful for raise-to-linalg when init "
+                                       "and kernel share a TU)"));
+
 static cl::opt LoopUnroll("unroll-loops", cl::init(false),
                                 cl::desc("Unroll Affine Loops"));
 
@@ -714,7 +720,8 @@ int main(int argc, char **argv) {
           optPM.addPass(mlir::createLowerAffinePass());
         optPM.addPass(mlir::polygeist::createPolygeistCanonicalizePass(
             canonicalizerConfig, {}, {}));
-        pm.addPass(mlir::createInlinerPass());
+        if (!NoInline)
+          pm.addPass(mlir::createInlinerPass());
         mlir::OpPassManager &optPM2 = pm.nest();
         optPM2.addPass(mlir::polygeist::createPolygeistCanonicalizePass(
             canonicalizerConfig, {}, {}));
@@ -765,7 +772,8 @@ int main(int argc, char **argv) {
       noptPM.addPass(polygeist::createPolygeistMem2RegPass());
       noptPM.addPass(mlir::polygeist::createPolygeistCanonicalizePass(
           canonicalizerConfig, {}, {}));
-      pm.addPass(mlir::createInlinerPass());
+      if (!NoInline)
+        pm.addPass(mlir::createInlinerPass());
       mlir::OpPassManager &noptPM2 = pm.nest();
       noptPM2.addPass(mlir::polygeist::createPolygeistCanonicalizePass(
           canonicalizerConfig, {}, {}));
diff --git a/tools/polygeist-opt/CMakeLists.txt b/tools/polygeist-opt/CMakeLists.txt
index ccfebd421d81..7a61d5b3b7af 100644
--- a/tools/polygeist-opt/CMakeLists.txt
+++ b/tools/polygeist-opt/CMakeLists.txt
@@ -5,6 +5,7 @@ set(LIBS
         ${conversion_libs}
         MLIROptLib
 		MLIRPolygeist
+		MLIRPolygeistKernel
 		MLIRPolygeistTransforms
 		MLIRFuncAllExtensions
         )
diff --git a/tools/polygeist-opt/polygeist-opt.cpp b/tools/polygeist-opt/polygeist-opt.cpp
index 95fe1b1fc4a4..a09c1b84f923 100644
--- a/tools/polygeist-opt/polygeist-opt.cpp
+++ b/tools/polygeist-opt/polygeist-opt.cpp
@@ -15,16 +15,19 @@
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/Async/IR/Async.h"
+#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
 #include "mlir/Dialect/DLTI/DLTI.h"
 #include "mlir/Dialect/Func/Extensions/InlinerExtension.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/LLVMIR/NVVMDialect.h"
+#include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/InitAllPasses.h"
 #include "mlir/Pass/PassRegistry.h"
 #include "mlir/Tools/mlir-opt/MlirOptMain.h"
@@ -32,6 +35,8 @@
 
 #include "polygeist/Dialect.h"
 #include "polygeist/Passes/Passes.h"
+#include "polygeist/Kernel/KernelDialect.h"
+#include "polygeist/Kernel/KernelOps.h"
 
 using namespace mlir;
 
@@ -59,7 +64,11 @@ int main(int argc, char **argv) {
   registry.insert();
   registry.insert();
   registry.insert();
+  registry.insert();
+  registry.insert();
+  registry.insert();
   registry.insert();
+  registry.insert();
   registry.insert();
 
   mlir::registerpolygeistPasses();
@@ -75,6 +84,7 @@ int main(int argc, char **argv) {
   mlir::registerLoopInvariantCodeMotionPass();
   mlir::registerConvertSCFToOpenMPPass();
   mlir::affine::registerAffinePasses();
+  mlir::registerLinalgPasses();
 
   registry.addExtension(+[](MLIRContext *ctx, LLVM::LLVMDialect *dialect) {
     LLVM::LLVMFunctionType::attachInterface(*ctx);